
Java4Shell: איפה נגמרת בטיחות הזיכרון של Java — ואיפה AI באמת נכנס לתמונה
Yoni Fraimorice
הבטחת היסוד של Java היא ניהול זיכרון בטוח: גישות למערכים נבדקות, קלט שגוי זורק חריגה מסודרת, ובאגים רגילים בפענוח קלט לא אמורים לדרוס אובייקטים שכנים בזיכרון.
ב-17 בנובמבר 2026 פרסמו OpenJDK ו-Oracle תיקון ל-Java4Shell (CVE-2026-114938), כתיבה מחוץ לגבולות המערך ב-heap בתוך מפענח ה-Base64 של OpenJDK, ומיד אחריו יצאה התרעת עדכון דחופה של CISA. מאחר ש-Base64 נושא כותרות הזדהות, טוקנים והעלאות קבצים, קלט פגום יכול להגיע למפענח עוד לפני שלב האימות.
הפרסום של חברת המחקר Calif מלווה בכותרות דרמטיות — מ-"Write once, RCE everywhere" ועד מציאת החולשה ובניית exploit בשלוש שעות ובפחות מ-200 דולר בטוקנים של AI. כדי להפיק את הלקח ההנדסי הנכון, צריך להפריד בין מה שכבר שוחזר בקוד פתוח לבין טענות החוקרים שטרם ניתנות לבדיקה חיצונית מלאה.
ממצאים מודגמים ומאומתים לעומת טענות החוקרים
חלק מ-Java4Shell ניתן לאימות ישיר בקוד המקור של OpenJDK ובבדיקות עצמאיות; חלקים אחרים נשענים על שרשראות ניצול שנשמרו חסויות או על מדדי עבודה שדיווחו החוקרים עצמם.
| נושא | מאומת עצמאית או מבוסס פומבית | מדווח או נטען על ידי Calif |
|---|---|---|
| שורש התקלה והגלישה ב-heap | אומת ב-OpenJDK מגרסה 17.0.6 ומעלה (וב-8u511b33-perf של Oracle) על מעבדי x86-64 עם תמיכה ב-AVX-512 VBMI. בדיקת ה-Base64Trigger הפומבית ו-Datadog Security Labs משחזרות דריסה של 62 בתים מעבר למערך וקריסות JVM. | פערי דירוג חומרה: Oracle ו-OpenJDK דירגו 8.1 (CVSS v3.1, בשל מורכבות תקיפה גבוהה); Calif דירגה 9.2 (CVSS v4.0). |
| היקף הרצת קוד מרחוק (RCE) | אין קוד ניצול RCE פומבי ואין אישור לניצול בפועל (in the wild) נכון ל-18 בנובמבר. גם Calif וגם Datadog מדגישות שאין payload אוניברסלי; כל מערכת דורשת סידור heap ייעודי, וקריסת שירות קלה בהרבה להשגה מ-RCE. | דווח על RCE לפני הזדהות (כולל סרטון הדגמה) בהתקנות ברירת מחדל של Keycloak, Jira, Confluence, Artifactory, Jenkins ו-PingFederate; RCE אחרי הזדהות ב-Kafka, Solr, Elasticsearch, Gerrit ו-Spinnaker; ותקיפת צד-לקוח ב-TLS שיוחסה ל-samczsun. הקוד המבצעי הוסתר עד לעדכון המערכות. |
| גילוי וניצול בסיוע AI | הודעת OpenJDK מעניקה קרדיט לחוקר Quang Luong, וקוד ה-C++ והאסמבלי של HotSpot גלוי לעיון של מודלי קוד. | דיווח עצמי של הצוות: כשעה למציאת הבאג עם OpenAI Codex, עוד כשעתיים ל-exploit ראשון, פחות מ-200 דולר בטוקנים, ושרשראות המשך "כמעט אוטונומיות" — לאחר שהחוקרים בנו כלי מעקב והדמיה ל-heap ושכרו שרתים באותו אזור ענן. |
| תזת ה-"vibe-uncoding" | כיבוי ה-intrinsic באמצעות -XX:-UseBASE64Intrinsics אומת כמעקף זמני תקין. | ההצעה להשתמש ב-AI כדי למחוק אופטימיציות שלרוב לא נדרשות מתשתיות משותפות היא עמדה הנדסית עם השלכות ביצועים וסיכוני רגרסיה שלא נמדדו. |
הסתרת שרשראות הניצול המוכנות עבור שרתי זהויות ו-CI/CD היא החלטה אחראית. יחד עם זאת, המשמעות היא שצוותים חיצוניים אימתו עד כה את פרימיטיב השחתת הזיכרון עצמו, ולא את רמת האמינות של כל שרשרת מוצר על גבי רשתות אמיתיות.
מה Java4Shell חושפת על גבול האמון בקוד native ב-Java
שכבת ה-Java המנוהלת מקצה מערך בגודל הנכון, אבל ה-intrinsic של מהדר C2 עוקף את בדיקות הגבול על חומרת AVX-512 VBMI.
סקירות אבטחה מתייחסות בדרך כלל לגבול ה-native של Java כאל ספריות JNI חיצוניות או קריאות java.lang.foreign. Java4Shell מזכירה שגם אופטימיציות המהירות הפנימיות של ה-JVM עצמו יושבות בצד הלא-בטוח של הגבול הזה.
1. קוד "חם" מחליף בשקט bytecode באסמבלי
קריאה ל-Base64.getDecoder() או Base64.getUrlDecoder() (בגרסאות שנבדקו, getMimeDecoder() עוקף את הנתיב הפגיע) מתחילה ב-bytecode בטוח. אחרי מספיק קריאות, מהדר ה-JIT האגרסיבי של HotSpot (C2) מחליף את decodeBlock() בשגרת אסמבלי ידנית של AVX-512 VBMI בתוך stubGenerator_x86_64.cpp, שכותבת ישירות למצביעים ב-heap של Java.
2. הנחה שגויה בחישוב המסכה הופכת -1 לכתיבה של 64 בתים
ב-JDK 21 ומעלה, קלט של 64 תווי 'A' ואחריהם '=' (או 128 תווי 'A' ו-'=' ב-JDK 17) מקצה מערך פלט של 50 בתים ומשאיר זנב של בית בודד ('='). שגרת הסיום באסמבלי מחשבת (1 >> 2) * 3 = 0, מחסירה 1 עבור סימן הריפוד בלי לבדוק שהתוצאה אי-שלילית, ומעבירה -1 לפקודת bzhiq שבונה את מסכת הכתיבה עבור VMOVDQU8:
output_len = (tail_len >> 2) * 3; // 1-byte '=' tail -> 0
if (has_padding) output_len -= 1; // underflows to -1 (low byte 255)
output_mask = bzhiq(-1ULL, output_len); // 255 >= 64 -> all 64 mask bits stay 1כאשר כל 64 הביטים במסכה דלוקים, VMOVDQU8 כותבת 64 בתים החל מהיסט 48 — וגולשת ב-62 בתים לתוך האובייקט השכן ב-G1 heap.
3. חריגות Java וחומרת הפיתוח מסתירות את התקלה
אחרי ששגרת האסמבלי חוזרת מוקדם, Java זורקת IllegalArgumentException כמצופה — אבל תפיסת החריגה בקוד האפליקציה לא מתקנת כותרות אובייקטים או אורכי מערכים שכבר נדרסו. גרוע מכך: מחשבי ARM64, שרתי AWS Graviton, מעבדי x86 ישנים ללא avx512vbmi, ובדיקות יחידה קצרות שלא מגיעות לסף הקומפילציה של C2 כלל לא מריצים את הקוד הפגיע. העברת אותו קובץ .jar או קונטיינר בדיוק אל שרת Intel Xeon (מדור Ice Lake עד Granite Rapids) או AMD Zen 4 ומעלה מפעילה את נתיב האסמבלי הפגיע בלי לשנות שורת קוד אחת.
מה המקרה באמת מלמד על גילוי חולשות בסיוע AI
הכותרות מתמקדות באופן טבעי ב-"200 דולר ושלוש שעות", כפי שדיווח CyberScoop. אבל הפירוט הטכני של Calif עצמה מציג תמונה מדויקת ומעניינת יותר.
ראשית, קוד גבול native קומפקטי הוא נקודת חוזק מובהקת למודלי קוד. כמה מאות שורות של אריתמטיקת ביטים ומסכות באסמבלי (bzhiq מול ערך שלילי) הן חומר מתיש לבדיקה אנושית שורה-אחר-שורה, אבל מתוחמות מספיק כדי שמודל שפה שמכוון לאזור ה-JIT intrinsics יזהה בהן סתירה. גם שם, Luong מציין שרוב הממצאים הראשונים של המודל היו רעש לא-נגיש ("slop"), ודרשו שיפוט אנושי וכ-20 דקות של הכוונה עקשנית כדי לבודד באג אמיתי.
שנית, פיתוח ה-exploit נשען על פיגומים הנדסיים שבנו בני אדם יחד עם איטרציות AI, לא על אוטונומיה בלחיצת כפתור. הפיכת דריסה בערכים קבועים (0x9a / 69 a6 9a) לדליפת זיכרון ולהרצת קוד דרשה יציאה מאזורי ההקצאה הפרטיים של תהליכונים (TLABs) וסידור אזורי G1 דרך בקשות HTTP מדורגות. ב-Calif מציינים במפורש שה-AI נתקע בשלב ה-heap grooming עד שהחוקרים כתבו עבורו כלי ייעודי למעקב ולהדמיית ה-heap, תכננו פרימיטיבים מוכרים של דריסת אורך מערך (writer ו-reader), ושכרו מכונה וירטואלית באותו אזור ענן של המטרה כדי לעקוף רגישות ל-jitter ברשת. רק אחרי שהתשתית האנושית הזו עמדה, סוכני AI האיצו את התאמת השרשראות למוצרים נוספים.
עבור מגנים, בדיוק באזור הביניים הזה נמצא השינוי האמיתי. AI לא מבטל את מורכבות ה-heap או את פיזיקת הרשת, אבל מודלים בהכוונת חוקרים מנוסים מקצרים מאוד את הזמן שדרוש גם לסריקת שכבות C, C++, unsafe ואסמבלי מתחת לשפות בטוחות — וגם להתאמת תבנית ניצול קיימת לשורה של מערכות ארגוניות.
צעדים מעשיים לצוותי Java ותשתיות
- עדכנו סביבות ריצה בכל מקום שבו הן מסתתרות: שדרגו לגרסאות המתוקנות (
17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, 8u513-perfשל Oracle והפצות הספקים המקבילות), כולל JDK שמוטמע בתוך תמונות קונטיינר ומערכות סגורות, החל משרתי זהויות ו-CI/CD חשופים לאינטרנט כמו Keycloak, PingFederate, Jenkins, Artifactory, Jira ו-Confluence. - השתמשו בדגל ה-JVM הממוקד כשעדכון מתעכב: הפעילו מחדש תהליכים עם
-XX:-UseBASE64Intrinsics(מועדף) או-XX:UseAVX=2בשרתי x86-64 בלבד — אל תוסיפוUseAVX=2להגדרות משותפות שרצות גם על ARM64, שם ה-JVM ייכשל בעלייה — ואמתו את הדגלים הפעילים באמצעותjcmd <PID> VM.flags -all. אל תסתמכו על חציצת בקשות ב-reverse proxy או על סוג המעבד הנוכחי כהגנה קבועה; בקשות בודדות, WebSockets ושינוי גודל מכונה בענן יכולים לעקוף את שניהם. - בדקו intrinsics כמו מפענחי C חשופים: בכל מקום שבו סביבת ריצה בטוחה מחליפה bytecode באסמבלי SIMD, צריך להפעיל differential fuzzing מול מימוש הייחוס ב-Java עבור כל אורכי הקצה ודגלי המעבד.
מקורות
- Calif Research: הדיווח הטכני על Java4Shell (CVE-2026-114938)
- הודעת האבטחה של OpenJDK מ-17 בנובמבר 2026
- Oracle Critical Security Patch Update Advisory — נובמבר 2026
- התרעת CISA: חולשת Java קריטית מחייבת עדכון מיידי (17 בנובמבר 2026)
- Datadog Security Labs: שחזור שורש התקלה וניתוח דרכי ההתמודדות עם Java4Shell
- Qualys Threat Research Unit: מיפוי חשיפה, גרסאות מושפעות והנחיות תיקון ל-CVE-2026-114938
- CyberScoop: חוקרים חשפו חולשה קריטית ב-Java בסיוע AI
צילום ראשי: 5C2A5953R - 49913961083 – Silicon Wafer 20200519, צילום של Rob Bulmahn מ-19 במאי 2020. רישיון CC BY 2.0. הוקטן מ-6720 x 4480 ל-1920 x 1280 פיקסלים ונדחס כ-JPEG. זהו צילום המחשה של שבבים על פרוסת סיליקון המייצג את גבול פקודות המעבד מתחת לסביבת ריצה מנוהלת, לא של שרת OpenJDK מושפע או של סביבת המחקר של Java4Shell. אין בו הבעת תמיכה.
דיון
דיון משותף לגרסאות המאמר בעברית ובאנגלית.
טוענים תגובות...