[ טוען... ]

חולשת Java4Shell ב-OpenJDK: מי חשוף, איך בודקים ומעדכנים

תאריך: 18.11.2026
זמן קריאה: 18 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

איור קונספטואלי של נתוני Base64 שגולשים מגבולות הזיכרון במעבד שרת, הממחיש את חולשת Java4Shell ב-OpenJDK

חולשת Java4Shell, שזוהתה כ-CVE-2026-114938, היא באג השחתת זיכרון בתוך ה-JVM עצמו, ולא בספרייה או באפליקציה מסוימת. היא יושבת בקוד האסמבלי המותאם שבו משתמש ה-JIT של HotSpot כדי להאיץ פענוח Base64 על מעבדי x86-64 עם AVX-512 VBMI. קלט פגום עם תו '=' במקום הלא נכון גורם לכתיבה של 64 בתים שחורגת ב-62 בתים מגבולות המערך ב-heap, לפי הניתוח של Upwind, ובתנאים מסוימים החולשה עלולה לאפשר הרצת קוד מרחוק.

מה שהופך את החולשה לדחופה הוא השילוב בין שני דברים: Base64 מפוענח כמעט בכל מקום במערכות backend של Java (כותרות HTTP Basic, טוקני JWT ועוד), והמעבדים הפגיעים נפוצים מאוד בשרתי ענן. הרצת קוד מרחוק ללא אימות הודגמה על ידי Calif בהגדרות ברירת המחדל של Keycloak, Jira, Confluence, Artifactory, Jenkins ו-PingFederate. גורמים אחרים, כמו Blackpoint, שחזרו באופן עצמאי קריסה של ה-JVM, אך לא הרצת קוד מרחוק.

המאמר מרכז את מה שמאומת נכון לפרסום התיקון ב-17 בנובמבר 2026: מה בדיוק החולשה, מי חשוף ומי לא, איך בודקים גרסת Java ודגלי מעבד, איך מבצעים עדכון JDK כולל בנייה מחדש של תמונות Docker של Java, ומה ניתן לעשות כהקלה זמנית כשאי אפשר לעדכן מיד. לצד זה, יש התייחסות מפורשת לפרטים שעדיין שנויים במחלוקת בין המקורות.

מה קרה: ציר הזמן של הדליפה והחשיפה

החולשה התגלתה ודווחה על ידי חברת Calif, ואורקל מייחסת את הגילוי ל-Quang Luong מ-Calif.io ול-Albert Yang. לפי Tenable, ב-17 בנובמבר 2026 הודיעה Calif שפרטי החולשה דלפו, ולאחר שאורקל פרסמה את התיקון פרסמה Calif גם את הניתוח הטכני שלה.

ציר הזמן, לפי המקורות:

  • 22 באוקטובר 2026 – מזהה ה-CVE נשמר (Reserved), לפי Horizon3.
  • 17 בנובמבר 2026 – ה-CVE פורסם, לפי Horizon3.
  • 17 בנובמבר 2026 – אורקל שחררה builds מתוקנים במסגרת עדכון ה-CSPU של נובמבר, לפי Sweet Security.
  • 17 בנובמבר 2026 – Calif הודיעה על הדליפה ופרסמה את הניתוח הטכני לאחר התיקון, לפי Tenable.

בנוסף, CISA פרסמה קריאה לעדכון מיידי ורשימת המלצות לארגונים, שמפורטות בהמשך המאמר.

עדכון ה-CSPU של אורקל לנובמבר כלל 11 תיקונים ל-Java SE, ו-Java4Shell הוא אחד מהם. העובדה שהפרטים דלפו לפני שהתיקון היה מוכן מקצרת את הזמן שבו ניתן להסתמך על כך שהמידע הטכני אינו זמין לתוקפים.

למה הדיווחים הראשונים היו סותרים

בשעות הראשונות פורסמו דיווחים, למשל של Orca, שהתמקדו ב-Java 17 והשאירו את מצב ענפים אחרים לא ברור. מקורות מאוחרים יותר, כמו Upwind ו-JFrog, אישרו שגם Java 21, 25 ו-27 פגיעות. מי שקרא רק את הדיווחים הראשונים עלול היה להסיק בטעות שמעבר ל-Java 21 פותר את הבעיה. זה לא נכון.

מה החולשה: Base64 intrinsic ו-AVX-512 VBMI

כדי להבין את החולשה צריך להבין מה זה intrinsic. ה-JIT של HotSpot מחליף קריאות מסוימות ל-API של Java, כמו java.util.Base64, בקוד מכונה שנכתב ידנית ומנצל הוראות מעבד מתקדמות. על מעבדים עם AVX-512 VBMI, הפענוח עובר בנתיב אסמבלי ייעודי שנועד להאיץ את הפעולה.

המנגנון הטכני

לפי Upwind, קלט Base64 פגום עם תו '=' תועה גורם לחישוב אורך פלט שלילי, ובמצב הזה מתבצעת כתיבה של 64 בתים שחורגת מגבולות המערך. Phoronix מפרטים את הדוגמה:

  • מחרוזת Base64 באורך 65 תווים.
  • מערך תוצאה בגודל 50 בתים.
  • כתיבה של 64 בתים.
  • גלישה של 62 בתים מעבר לגבול המערך.

מדובר בחולשה מסוג CWE-122, כלומר heap buffer overflow. כתיבה מחוץ לגבולות המערך עלולה לדרוס נתונים סמוכים ב-heap של ה-JVM. האם זה מתורגם להרצת קוד תלוי באפליקציה הספציפית: לפי Sweet Security, Calif הדגימה ניצולים ייעודיים למוצרים מסוימים ואינה מפרסמת אותם.

למה זה לא באג באפליקציה

זו נקודה מהותית: הקוד של המפתח יכול להיות תקין לחלוטין. קריאה רגילה ל-Base64.getDecoder().decode(input) על קלט מהמשתמש עשויה להספיק, בתנאי שה-JVM והמעבד מתאימים. לכן גם סריקת תלויות (SCA) של קוד האפליקציה לא תמצא את הבעיה; היא נמצאת ב-runtime.

חומרה: שני ציונים שונים

אורקל ו-OpenJDK נתנו לחולשה ציון 8.1 ב-CVSS 3.1, עם מורכבות תקיפה גבוהה. Calif מעריכה אותה ב-9.2 לפי CVSS 4.0. מדובר בשתי גרסאות שונות של שיטת הדירוג ובשני גורמים מדרגים שונים, ולכן הציונים אינם ניתנים להשוואה ישירה. לצורכי תעדוף, שני הציונים מציבים את החולשה בקטגוריה של טיפול מיידי במערכות חשופות לאינטרנט.

מי חשוף לחולשת Java4Shell: גרסאות, מעבדים וספקים

לפי הניתוחים של Upwind, Tenable ו-Sweet Security, חשיפה מחייבת שלושה תנאים בו זמנית:

  1. JVM בגרסה פגיעה.
  2. מעבד x86-64 עם AVX-512 VBMI.
  3. קלט Base64 לא מהימן שמגיע למפענח.

אם אחד מהשלושה חסר, השרת הספציפי לא פגיע. עם זאת, התנאי השלישי מתקיים לעתים קרובות בשירות HTTP שמקבל אימות, כפי שמוסבר בהמשך.

גרסאות JDK פגיעות ומתוקנות

ענף Java

מצב לפי המקורות

Build מתוקן של Oracle

Java 8

ל-Java 8 הסטנדרטי אין מפענח פגיע, אך אורקל מציינת את ה-build 8u511b33-perf

8u513

Java 11

לא מושפע

11.0.33.1

Java 17

17.0.0 עד 17.0.5 לא מושפעות; 17.0.6 עד 17.0.21 פגיעות

17.0.21.1

Java 21

פגיעה עד 21.0.13

21.0.13.1

Java 25

פגיעה עד 25.0.5

25.0.5.1

Java 27

פגיעה עד 27.0.1

27.0.1.1

הנתונים בטבלה מבוססים על Upwind ועל רשימת ה-builds המתוקנים של אורקל כפי שמופיעה אצל Sweet Security. אורקל שחררה builds מתוקנים גם ל-8 ול-11, למרות שהגרסאות הסטנדרטיות שלהן לא מכילות את המפענח הפגיע. ספקים אחרים (Temurin, Corretto ואחרים) משחררים תיקונים בלוחות זמנים משלהם, ומספרי הגרסאות שלהם לא מופיעים במקורות.

אילו מעבדים חשופים

לפי Tenable, הנתיב הפגיע זמין על:

  • Intel Ice Lake
  • Intel Sapphire Rapids
  • Intel Emerald Rapids
  • Intel Granite Rapids
  • AMD Zen 4 ומעלה

בלינוקס, ארבעת הדגלים avx512f, avx512bw, avx512vbmi ו-bmi2 חייבים להופיע כולם. ב-AWS, Upwind מציינים את משפחות המכונות c6i, m6i, c7i, c7a ו-m7a כחשופות. אלה משפחות נפוצות בפרודקשן, כולל אצל צוותים ישראליים שמריצים עומסי Java על מכונות x86 ב-AWS, Azure ו-GCP.

ARM ו-Android: מה לא מושפע

שרתי ARM64, כולל AWS Graviton, אינם מושפעים, מפני שהבאג נמצא בנתיב ה-x86-64 של AVX-512 VBMI בלבד.

לגבי Android, אף אחד מהמקורות לא מתייחס ישירות. החולשה מתוארת כבאג ב-HotSpot, ואפליקציות Android רצות על ה-runtime של Android ולא על HotSpot, כך שאין בסיס בדיווחים הקיימים לטענה שמכשירי Android חשופים. מה שכן רלוונטי לצוותי מובייל הוא צד השרת: שרתי API ב-Java שמשרתים אפליקציות Android ו-iOS נמדדים לפי אותם שלושה תנאים כמו כל שירות אחר.

Spring, תמונות Docker ומערכות backend ארגוניות

השאלה המעשית אינה רק אם ה-JDK פגיע, אלא אם קלט של תוקף מגיע למפענח. לפי Sweet Security, הנתיבים הנפוצים הם כותרות HTTP Basic auth וחלק מספריות ה-JWT, כי הן מפענחות Base64 שהגיע מהתוקף לפני שהן בודקות את פרטי ההזדהות.

אפליקציות Spring Boot

Spring עצמו אינו הפגם, אבל הוא דוגמה טובה לנתיב חשיפה. Blackpoint בנו אפליקציית Spring Boot מקומית עם Spring Security, ושלחו כ-28,000 בקשות לא מאומתות עם ערך Basic auth פגום. ה-JVM קרס תוך כ-20 שניות. כלומר, גם בלי הרצת קוד, יש כאן תרחיש של מניעת שירות נגד שירות שמקבל Basic auth ורץ על JVM ומעבד פגיעים.

חשוב לדייק: Blackpoint לא שחזרו באופן עצמאי הרצת קוד מרחוק. הם שחזרו קריסה. ההדגמות של RCE מגיעות מ-Calif.

מוצרים ארגוניים מבוססי Java

ההדגמות של Calif, לפי Sweet Security, כוללות:

  • RCE לפני אימות בהגדרות ברירת מחדל: Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate.
  • RCE אחרי אימות: Kafka, Elasticsearch, Gerrit.

הניצולים הספציפיים למוצרים אלה לא פורסמו. הרשימה הזו מוכרת היטב לצוותי פיתוח ותפעול: Jenkins ו-Artifactory בצנרת ה-CI/CD, Jira ו-Confluence בניהול פרויקטים, Keycloak כספק זהויות. חלק מהמוצרים האלה מגיעים עם JDK מובנה, ולכן עדכון ה-JDK של מערכת ההפעלה לא בהכרח מתקן אותם. CISA מתייחסת לכך במפורש ומבקשת לכלול במלאי גם JDK שמוטמעים באפליקציות צד שלישי. הנושא משיק לבעיה רחבה יותר של מעקב אחרי רכיבים מוטמעים, שמתוארת בצ'קליסט אבטחת שרשרת אספקה לצוותים קטנים.

תמונות Docker של Java

כאן מסתתר המלכוד הגדול ביותר. לפי Upwind, אותה תמונת קונטיינר יכולה להיות חשופה על node אחד ובטוחה על node אחר, בהתאם למעבד שמתחתיה. אשכול Kubernetes שמשלב מכונות Graviton עם מכונות c7i עשוי להריץ את אותו pod פעם במצב בטוח ופעם במצב פגיע, לפי ה-node שה-scheduler בחר.

בנוסף, Sweet Security מדגישים שכל תמונה שמכילה Java חייבת לעבור בנייה מחדש עם JDK מתוקן. עדכון ה-host לא נוגע ב-JDK שבתוך התמונה.

הזווית הישראלית

המקורות לא כוללים התייחסות ישראלית ספציפית: אין הודעה של מערך הסייבר הלאומי שמצוטטת בהם, והאזהרות הממשלתיות שהוזכרו הן של CISA ושל ה-NIS הדרום קוריאני. עם זאת, ארגונים ישראליים רבים, בפינטק, בארגונים גדולים ובחברות ענן, מריצים מערכות backend ב-Java (Spring, Jenkins, Jira, Keycloak) על מכונות x86 בענן, כך שהחשיפה רלוונטית גם כאן.

צוותים שכבר עברו חלקית ל-Graviton צריכים לזכור שהחשיפה נקבעת ברמת ה-node ולא ברמת התמונה. מכיוון שאין במקורות התייחסות לתמיכה בעברית או ל-RTL, אין לחולשה היבט ייחודי לממשקים בעברית; הסיכון זהה לכל שירות שמפענח Base64 מקלט חיצוני.

צ'קליסט: איך בודקים גרסת Java ודגלי מעבד

CISA ממליצה על מלאי מלא של כל ה-JDK בארגון, כולל אלה שמוטמעים באפליקציות צד שלישי, בקונטיינרים ובמכשירי appliance, ותעדוף של מערכות שחשופות לאינטרנט. הצעדים הבאים הופכים את ההמלצה לפעולות.

שלב 1: איך בודקים גרסת Java

בשרת או במכונת פיתוח:

java -version
# דוגמה לפלט פגיע: openjdk version 21.0.13

שרתים רבים מריצים יותר מ-JDK אחד. כדי למצוא runtimes מוטמעים (למשל בתוך Jira או Jenkins), אפשר לחפש קובצי הפעלה בשם java. חיפוש על כל מערכת הקבצים (find /) עלול להיות איטי מאוד בשרתים עם מערכות קבצים גדולות או עם כוננים מחוברים, ולכן עדיף לתחום אותו לתיקיות שבהן JDK מותקנים בדרך כלל:

# איתור קובצי java בתיקיות הנפוצות בלבד, בלי לחצות מערכות קבצים
for dir in /opt /usr /var/lib; do
  find "$dir" -xdev -type f -name java -perm -u+x 2>/dev/null
done > /tmp/java-binaries.txt

# בדיקת הגרסה של כל אחד מהם
while read -r j; do
  echo "== $j"; "$j" -version 2>&1 | head -n 1
done < /tmp/java-binaries.txt

אם מוצרים מסוימים מותקנים במיקום אחר (למשל /home או תיקיית אפליקציות ייעודית), יש להוסיף אותו לרשימה. חשוב להריץ את הבדיקה על כל node ועל כל שרת, ולא על שרת יחיד שנחשב מייצג: גרסאות JDK וסוגי מעבדים משתנים בין מכונות, במיוחד ב-Auto Scaling.

שלב 2: בדיקת דגלי המעבד

בלינוקס, ארבעת הדגלים חייבים להופיע:

grep -owE 'avx512f|avx512bw|avx512vbmi|bmi2' /proc/cpuinfo | sort -u

אם הפלט מכיל את כל ארבעת השמות, המעבד תומך בנתיב הפגיע. אם אחד חסר, המכונה הספציפית אינה חשופה, אבל יש לבדוק כל node בנפרד, כי ב-Auto Scaling ובאשכולות מעורבים סוג המכונה משתנה.

שלב 3: בדיקת תמונות Docker

# גרסת Java בתוך תמונה
docker run --rm --entrypoint java my-registry/my-service:latest -version

# רשימת תמונות מקומיות לסריקה
docker images --format '{{.Repository}}:{{.Tag}}'

בתמונות שבהן java אינו ב-PATH, יש לחפש אותו בתוך התמונה עם find דרך --entrypoint sh.

שלב 4: בדיקת הגדרות ה-JVM בפועל

כדי לראות אם ה-intrinsic פעיל ואיזו רמת AVX ה-JVM משתמש בה:

java -XX:+PrintFlagsFinal -version | grep -E 'UseBASE64Intrinsics|UseAVX '

חשוב: הפקודה הזו מראה את ערכי הדגלים של ה-java שנמצא ב-PATH, עם האפשרויות שהועברו בשורת הפקודה בלבד. כדי שהבדיקה תשקף את הפרודקשן, יש להריץ אותה עם אותו קובץ java ועם אותן אפשרויות JVM שבהן התהליך בפרודקשן מופעל, על אותו סוג מכונה. דרך אמינה יותר היא לבדוק את התהליך הרץ עצמו:

# בדיקת הדגלים של תהליך JVM שכבר רץ
jcmd <pid> VM.flags -all | grep -E 'UseBASE64Intrinsics|UseAVX '

אחרת, הבדיקה עלולה להטעות: למשל, להראות שה-intrinsic כבוי כשבפועל התהליך רץ עם JDK אחר או בלי הדגל.

שלב 5: מיפוי נתיבי קלט

  • שירותים שמקבלים HTTP Basic auth.
  • שירותים שמאמתים JWT עם ספרייה שמפענחת לפני בדיקת חתימה.
  • כל endpoint שמקבל שדות מקודדים ב-Base64 מלקוחות חיצוניים.
  • מערכות צד שלישי מבוססות Java החשופות לאינטרנט (Keycloak, Jenkins, Jira וכדומה).

סדר העדיפויות המתבקש: שירותים חשופים לאינטרנט, על x86-64 עם AVX-512 VBMI, עם JDK פגיע ונתיב Base64 לפני אימות.

עדכון JDK, הקלות זמניות ומצב הניצול

התיקון המלא היחיד הוא מעבר ל-build מתוקן. כל שאר הצעדים הם גישור.

עדכון לגרסה מתוקנת

ה-builds המתוקנים של אורקל, ששוחררו ב-17 בנובמבר 2026, הם 8u513, 11.0.33.1, 17.0.21.1, 21.0.13.1, 25.0.5.1 ו-27.0.1.1. מי שמשתמש בהפצות אחרות של OpenJDK צריך לעקוב אחרי ההודעות של הספק הספציפי, כי לוחות הזמנים שונים.

לפי אותו מקור, עדכון הקבצים אינו מספיק:

  • כל JVM חייב אתחול כדי לטעון את הקוד המתוקן.
  • כל תמונת קונטיינר שכוללת Java חייבת לעבור build מחדש ופריסה מחדש.
  • מוצרי צד שלישי עם JDK מוטמע דורשים עדכון מהיצרן או החלפה ידנית של ה-runtime, אם היצרן תומך בכך.

בנייה מחדש של תמונות Docker

בתמונות שמבוססות על תגית כללית (למשל 21-jre), build מחדש עם --pull מושך את תמונת הבסיס העדכנית, בתנאי שהספק כבר עדכן אותה:

docker build --pull --no-cache -t my-registry/my-service:patched .
docker run --rm --entrypoint java my-registry/my-service:patched -version

אחרי ה-build, חשוב לוודא בפועל שהגרסה בתוך התמונה היא גרסה מתוקנת, ולא להניח זאת. תגיות כלליות מתעדכנות בקצב של הספק, וייתכן שבזמן ה-build התמונה עדיין לא כללה את התיקון. אחרי שנמצאה תמונת בסיס מתוקנת, הצמדה שלה ל-digest מבטיחה שבנייה עתידית לא תחזור בטעות לגרסה ישנה יותר.

הקלות זמניות כשאי אפשר לעדכן מיד

חשוב לדעת: ההודעה של אורקל אינה מפרסמת workaround. שני הדגלים הבאים מגיעים מניתוחים עצמאיים, ולפי JFrog כל אחד מהם חוסם את הניצול, לפי הדיווחים.

הקלה

יתרונות

חסרונות

-XX:-UseBASE64Intrinsics

מנטרל את ה-intrinsic הפגיע; לפי Upwind עצר את הגלישה בכל גרסה פגיעה שנבדקה; עובד על כל ארכיטקטורה

מאבד את ההאצה של פענוח Base64; לא מופיע בהודעה של אורקל; דורש אתחול

-XX:UseAVX=2

מומלץ על ידי Calif; מרחיק את ה-JVM מנתיב AVX-512

x86-64 בלבד, JVM על ARM64 לא יעלה עם הדגל; עלול להאט קוד AVX-512 אחר; דורש אתחול

עדכון ל-build מתוקן

תיקון מלא, מאושר על ידי OpenJDK ואורקל

לוחות זמנים משתנים אצל ספקים; דורש אתחולים ו-rebuild; קשה לאתר JDK מוטמעים

ההשוואה מבוססת על JFrog, Horizon3 ו-Sweet Security.

איך מחילים את הדגל בפועל

באשכולות מעורבים של x86 ו-ARM, הדגל -XX:-UseBASE64Intrinsics הוא הבחירה הבטוחה יותר, כי -XX:UseAVX=2 יגרום ל-JVM על ARM64 להיכשל בעלייה. דרך נוחה להחיל דגל בלי לשנות פקודות הפעלה היא משתנה הסביבה הסטנדרטי JAVA_TOOL_OPTIONS:

# קטע מ-Deployment של Kubernetes
env:
  - name: JAVA_TOOL_OPTIONS
    value: "-XX:-UseBASE64Intrinsics"

או בהרצה ישירה:

java -XX:-UseBASE64Intrinsics -jar app.jar

אחרי ההחלה, יש לאמת על התהליך הרץ, עם jcmd <pid> VM.flags -all, שהדגל אכן כבוי, ולא רק בהרצת java -version נפרדת. אם כבר קיים ערך ב-JAVA_TOOL_OPTIONS, יש לשרשר אליו ולא לדרוס אותו.

שכבות הגנה נוספות

CISA ממליצה גם על ולידציה של קלט Base64 והגבלות גודל, ועל ניטור קריסות JVM ו-runtimes לא מוכרים. בפועל:

  • ניטור קריסות: קובצי hs_err_pid*.log ואתחולים חוזרים של pods הם סימן אזהרה. בהתחשב בניסוי של Blackpoint, גל של קריסות אחרי בקשות אימות פגומות מחייב בדיקה.
  • הגבלת קצב על endpoints של אימות, ברמת ה-reverse proxy או ה-WAF.
  • ולידציה מוקדמת: דחיית ערכי Authorization באורך או בתבנית חריגים לפני שהם מגיעים ל-JVM. גישה דומה של דחיית payload פגום ברמת ה-proxy מתוארת במדריך ולידציה של webhooks ב-nginx.
  • איתור runtimes לא מוכרים: השוואה בין רשימת ה-JDK שנמצאה בשלב המלאי לבין מה שאמור להיות מותקן.

אף אחד מאלה אינו תחליף לעדכון. הם מקטינים את משטח התקיפה בזמן שהעדכון מתגלגל.

מצב הניצול נכון ל-17 בנובמבר

נכון ל-17 בנובמבר 2026, לא דווח על ניצול בשטח, והחולשה אינה ברשימת KEV של CISA. עם זאת, Tenable מציינים ש-Calif פרסמה PoC שמפעיל את הבאג בלי להשתלט על המערכת, וחוקר נוסף מדווח על ניצול עובד. מכיוון שהפרטים דלפו לפני התיקון, אין להסתמך על היעדר ניצול מדווח כסיבה לדחות את העדכון.

נקודות שהמקורות חלוקים עליהן

  • Java 8: Orca מעריכים שלא מושפע, ו-Upwind מציינים שרק ה-build 8u511b33-perf של אורקל מושפע. אורקל שחררה 8u513 מתוקן בכל מקרה.
  • מקור טווחי הגרסאות: Horizon3 מציינים שטווחי OpenJDK מבוססים על ניתוח עצמאי ושבזמן הכתיבה שלהם לא הייתה הודעה של OpenJDK, בעוד Tenable מדווחים שקבוצת החולשות של OpenJDK פרסמה הודעה.
  • ציון החומרה: 8.1 של אורקל מול 9.2 של Calif.
  • AVX2: Orca מציינים שנתיב AVX2 פעיל ב-Java 21 ומעלה, אך הנתיב הפגיע דורש AVX-512 VBMI. ההמלצה של Calif ו-Sweet על UseAVX=2 מרמזת ש-AVX2 בטוח, אך זו הסקה ולא קביעה מפורשת.
  • יכולת ניצול בעולם האמיתי: ניצולים תלויי אפליקציה ועלולים להפיל את ה-JVM. RCE הודגם על ידי Calif, ו-Blackpoint לא שחזרו RCE מרחוק.

ראו גם: http2shell: חולשת RCE ב-Node.js וב-Python ואיך מתגוננים.

שאלות נפוצות

האם Java 11 חשופה לחולשת Java4Shell?

לא. לפי Upwind ו-Sweet Security, ל-Java 11 אין את המפענח הפגיע. גם Java 17 בגרסאות 17.0.0 עד 17.0.5 אינה מושפעת. החשיפה מתחילה ב-17.0.6 וכוללת את 21, 25 ו-27.

האם שרתי ARM או Graviton מושפעים?

לא. לפי Calif וספקים נוספים, ARM64 אינו מושפע, כי הבאג נמצא בנתיב x86-64 של AVX-512 VBMI. עם זאת, באשכול מעורב אותה תמונה עשויה לרוץ גם על node פגיע.

איך בודקים אם המעבד חשוף?

בלינוקס, בודקים ב-/proc/cpuinfo שמופיעים כל ארבעת הדגלים: avx512f, avx512bw, avx512vbmi ו-bmi2. אם אחד חסר, הנתיב הפגיע לא יופעל על המכונה הזו. הבדיקה צריכה לרוץ על כל node בנפרד.

האם החולשה מנוצלת בפועל?

נכון ל-17 בנובמבר 2026, לא דווח ניצול בשטח והחולשה אינה ב-KEV של CISA. קיימים PoC שמפעילים את הבאג, וחוקר נוסף מדווח על ניצול עובד.

האם אפליקציית Spring צריכה עדכון?

Spring עצמו אינו הפגם, ה-JVM הוא. Blackpoint הפילו אפליקציית Spring Boot עם Spring Security באמצעות ערך Basic auth פגום, ולכן יש לעדכן את ה-JDK שעליו האפליקציה רצה, לא את תלויות Spring.

האם עדכון ה-JDK מספיק?

לא לבד. לפי Sweet Security, צריך לאתחל כל JVM ולבנות מחדש כל תמונת קונטיינר שכוללת Java. בנוסף, יש לאתר JDK מוטמעים במוצרי צד שלישי ולעדכן אותם בנפרד.

סיכום

חולשת Java4Shell היא תזכורת לכך שגם runtime בוגר כמו OpenJDK מכיל קוד אסמבלי ידני שיכול לשבור הנחות בסיסיות על בטיחות זיכרון ב-Java. הבאג עצמו פשוט יחסית, אורך פלט שלילי שמוביל לכתיבה של 64 בתים, אבל ההשפעה רחבה כי Base64 נמצא בלב מנגנוני האימות.

התמונה המאומתת ברורה מספיק כדי לפעול: גרסאות 17.0.6 ומעלה, 21, 25 ו-27 פגיעות על מעבדי x86-64 עם AVX-512 VBMI, ARM64 אינו מושפע, וקיימים builds מתוקנים מאורקל. סדר הפעולות המומלץ:

  1. מלאי של כל ה-JDK, כולל בתוך קונטיינרים ומוצרי צד שלישי, על כל node.
  2. בדיקת דגלי מעבד בכל node.
  3. תעדוף שירותים חשופים לאינטרנט עם Basic auth או JWT.
  4. עדכון ל-build מתוקן, אתחול ובנייה מחדש של תמונות.
  5. החלת -XX:-UseBASE64Intrinsics כהקלה זמנית במקומות שבהם העדכון מתעכב, ואימות על התהליך הרץ.
  6. ניטור קריסות JVM והגבלת קצב על endpoints של אימות.

מה שנותר פתוח הוא בעיקר מידת הקלות של ניצול בעולם האמיתי ומועדי התיקון של ספקי OpenJDK שאינם אורקל. שני הנושאים האלה מצדיקים מעקב צמוד, אבל לא דחייה של העדכון.

מקורות

וואטסאפ