[ טוען... ]

חולשת OpenSSL CVE-2026-121481: מי חשוף ואיך מעדכנים

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

שיתוף:

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

איור של זרם נתונים מקודדים שגולש ממיכל קטן מדי לתאי זיכרון, ממחיש את חולשת OpenSSL ב-EVP_EncodeBlock

חולשת OpenSSL CVE-2026-121481 היא גלישת חוצץ בערימה (heap buffer overflow) בפונקציה EVP_EncodeBlock(), מקודד ה-base64 של OpenSSL. לפי רשומת ה-CVE הרשמית, קריאה לפונקציה עם אורך קלט שקרוב ל-INT_MAX עלולה לגרום לגלישה בחישוב גודל הפלט, וכתוצאה מכך לכתיבה מעבר לסוף החוצץ שהקורא הקצה. התוסף של Tenable ל-Nessus מציג ציון CVSS v3.0 של 9.8, כלומר קריטי, וציון כזה מספיק כדי שסורקי פגיעויות יתחילו לסמן שרתים, אימג'ים של Docker וצינורות CI.

מאחורי המספר המרשים מסתתרת תמונה מורכבת יותר. המקורות סותרים זה את זה בשאלה אם קיימת בכלל גרסה מתוקנת, הציון 9.8 מיוחס לפי אחד המקורות ל-CISA ולא ל-OpenSSL, והתנאי להפעלת הבאג הוא קלט של יותר מ-1.5GB בקריאה בודדת. בנוסף, טווח הגרסאות הפגיעות מצומצם לענף 4.x, שעדיין אינו ברירת המחדל ברוב ההפצות.

המדריך הזה מפריד בין מה שמאומת לבין מה ששנוי במחלוקת, מסביר מדוע קישור (linking) ל-OpenSSL אינו זהה לחשיפה בפועל, ומציג פקודות מעשיות לבדיקת גרסת OpenSSL בשרתים, באימג'י Docker, ב-Node.js, ב-Python וב-nginx, יחד עם דרכי עדכון ומיתון למקרה שהתיקון הרשמי מתעכב.

מה קרה: חולשת OpenSSL CVE-2026-121481 בקצרה

מה עושה EVP_EncodeBlock

EVP_EncodeBlock היא הפונקציה החד-פעמית (one-shot) של OpenSSL לקידוד base64: מעבירים לה חוצץ קלט, אורך וחוצץ פלט, והיא מחזירה את המחרוזת המקודדת בבת אחת. לפי דף התיעוד של הפונקציה, החתימה שלה היא:

int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);

שתי נקודות חשובות עולות מהחתימה הזו:

  • האורך n הוא מסוג int, כלומר מספר שלם עם סימן שערכו המקסימלי הוא INT_MAX (2,147,483,647 בפלטפורמות הנפוצות).
  • הקורא אחראי להקצות את חוצץ הפלט t. הפונקציה לא מקצה זיכרון בעצמה, היא רק כותבת לתוך מה שהועבר לה.

לפי אותו תיעוד, קידוד base64 מייצר 4 בתים של פלט עבור כל 3 בתים של קלט. כלומר, הפלט גדול בכשליש מהקלט.

איפה החישוב נשבר

כאן נמצא שורש הבעיה. אם הקלט קרוב ל-INT_MAX, גודל הפלט הנדרש (בערך פי 4/3 מהקלט) כבר לא נכנס לטווח של int. לפי רשומת ה-CVE, במצב כזה חישוב גודל הפלט עלול לגלוש, והפונקציה כותבת מעבר לסוף החוצץ שסיפק הקורא.

חישוב להמחשה בלבד (לא ציטוט של הקוד עצמו): כדי ש-4/3 מהקלט יעבור את 2,147,483,647, הקלט צריך להיות גדול מכ-1.61 מיליארד בתים, כלומר בסביבות 1.5GiB. זה תואם את הטענה בפוסט של sysxplore שהבאג מופעל רק כשאפליקציה מעבירה קלט של יותר מ-1.5GB בקריאה אחת. המיקום המדויק של הגלישה בקוד מתועד ב-בקשת התיקון #33652.

ציר הזמן

  • 18 בנובמבר 2026: לפי CVEfeed, ה-CVE התקבל ממקור openssl-security@openssl.org. באותו יום רשומת ה-CVE עודכנה, ו-Tenable מציינת זאת כתאריך פרסום החולשה.
  • 19 בנובמבר 2026: Tenable פרסמה את תוסף Nessus מספר 383671, ו-מעקב האבטחה של Ubuntu סימן את חבילת openssl כ-Needs evaluation.
  • 20 בנובמבר 2026: פוסט של sysxplore טען שעדיין אין גרסה מתוקנת ושבקשת התיקון נמצאת בסטטוס hold: discussion.

מה מאומת ומה שנוי במחלוקת בחולשת OpenSSL CVE-2026-121481

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

מה כן מאומת

  • מהות הבאג: heap buffer overflow ב-EVP_EncodeBlock() כאשר אורך הקלט קרוב ל-INT_MAX, לפי רשומת ה-CVE.
  • טווח הגרסאות: 4.0.0 עד (לא כולל) 4.0.4, ו-4.1.0 עד (לא כולל) 4.1.1, לפי אותה רשומה.
  • מקור הדיווח: לפי CVEfeed, המקור הוא openssl-security@openssl.org, וההפניה היחידה שמופיעה היא בקשת ה-Pull Request openssl/openssl#33652.
  • אין ניצול ידוע: Tenable מציינת No known exploits are available, ו-OpenCVE מציינת שהחולשה אינה ברשימת KEV של CISA.

ציון CVSS 9.8: מאיפה הוא הגיע

Tenable מציגה ציון CVSS v3.0 בסיסי של 9.8 עם הווקטור AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, וציון CVSS v2 של 7.5. הווקטור הזה מתאר את התרחיש הגרוע ביותר: ניצול ברשת, ללא הרשאות, ללא אינטראקציה של משתמש, עם פגיעה מלאה בסודיות, בשלמות ובזמינות.

לעומת זאת, הפוסט של sysxplore טוען שהציון 9.8 מגיע מ-CISA ולא מ-OpenSSL, ושל-OpenSSL אין בכלל הודעת אבטחה (advisory) עבור החולשה. OpenCVE לא מציגה ציון, ו-CVEfeed מציגה 0.0. במילים אחרות, הציון הקריטי הוא הערכה של גורם אחד, לא קונצנזוס.

האם יש גרסה מתוקנת

זו הסתירה המשמעותית ביותר:

  • פוסט ב-LinkedIn מציין שהגרסאות המתוקנות הן 4.0.4 ו-4.1.1.
  • הפוסט של sysxplore מ-20 בנובמבר טוען שעדיין אין גרסה מתוקנת, ושבקשת התיקון של Nicky Mouha ממתינה בסטטוס hold: discussion.

גבולות הטווח ברשומת ה-CVE ("עד, לא כולל, 4.0.4 ו-4.1.1") מרמזים על אותן גרסאות כנקודות התיקון, אבל לא מוכיחים שהן כבר זמינות להורדה. לפני כל תכנון עדכון, יש לבדוק ישירות במאגר של OpenSSL ובמעקב האבטחה של ההפצה שלכם.

ניצול מרחוק וביצוע קוד

גם כאן המקורות לא מסונכרנים. CVEfeed מציינת Remotely Exploit: No, בעוד שהווקטור של Tenable מגדיר AV:N (ניצול דרך הרשת). OpenCVE מציעה את ההסבר הסביר ביותר: ניצול דורש אפליקציה שקוראת ל-EVP_EncodeBlock עם קלט גדול שנשלט על ידי תוקף. כלומר, ניצול מרחוק אפשרי רק אם קיים מסלול שבו קלט מהרשת מגיע לפונקציה בגודל עצום.

לגבי הרצת קוד: OpenCVE מציינת במפורש שהטענה לביצוע קוד היא הסקה (inferred) מפוטנציאל השחתת הזיכרון, לא ממצא מוכח.

נושא

מה נטען

מקור

סטטוס

מהות הבאג

Heap overflow ב-EVP_EncodeBlock עם קלט קרוב ל-INT_MAX

CVE.org

מאומת

גרסאות פגיעות

4.0.0–4.0.3, 4.1.0

CVE.org

מאומת

ציון CVSS

9.8 קריטי

Tenable

שנוי במחלוקת

גרסה מתוקנת

4.0.4 ו-4.1.1

LinkedIn

סותר מקור אחר

אין תיקון עדיין

ה-PR בסטטוס hold

sysxplore

סותר מקור אחר

ניצול מרחוק

No מול AV:N

CVEfeed

לא עקבי

הרצת קוד

מוסקת בלבד

OpenCVE

לא מוכח

ניצול ידוע

אין

Tenable

מאומת למועד הפרסום

מי באמת חשוף: קוראים ישירים מול מקשרים בלבד

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

אפליקציות שקוראות ל-EVP_EncodeBlock ישירות

לפי OpenCVE, תרחיש חשיפה אמיתי דורש את כל הרכיבים הבאים:

  1. גרסת OpenSSL בטווח הפגיע: 4.0.0 עד 4.0.3, או 4.1.0.
  2. קריאה ישירה ל-EVP_EncodeBlock, או דרך שכבת עטיפה (wrapper) שמעבירה אליה נתונים.
  3. קלט עצום בקריאה אחת: קרוב ל-INT_MAX, כלומר מעל כ-1.5GB לפי sysxplore.
  4. השפעה של תוקף על גודל הקלט: למשל שירות שמקבל קבצים או גופי בקשות ומקודד אותם ל-base64 במלואם בלי מגבלת גודל.

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

אפליקציות שרק מקשרות ל-OpenSSL

רוב האפליקציות משתמשות ב-OpenSSL עבור TLS, חתימות ואימות אישורים. לפי המעקב של Ubuntu ו-דפי התיעוד של Debian, רוב ההפצות היציבות מריצות בכלל ענפים ישנים יותר: Debian trixie מגיעה עם 3.5.7, ו-testing/unstable עם 3.6.5. ענף 3.x נמצא מחוץ לטווח הפגיע של ה-CVE.

מה עם שרתים שמשתמשים ב-OpenSSL רק ל-TLS

המקורות לא מתארים מסלול שבו לחיצת יד TLS רגילה מגיעה ל-EVP_EncodeBlock עם קלט של גיגה-בייטים. לכן, לפי ההסקה מהמקורות, שרת שמשתמש ב-OpenSSL רק לצורך TLS אינו מתואר כחשוף. חשוב לציין שזו הסקה ולא קביעה מפורשת של OpenSSL, ושהמצב עשוי להשתנות אם יתפרסם ניתוח נוסף.

קטגוריה

יתרונות מבחינת סיכון

חסרונות מבחינת סיכון

אפליקציות שקוראות ל-EVP_EncodeBlock (ישירות או דרך wrapper) על 4.0.0–4.0.3 או 4.1.0

ניתן לתקן בשדרוג ל-4.0.4 או 4.1.1 כשיהיו זמינות; ניתן למתן בהגבלת אורך הקלט הרחק מתחת ל-INT_MAX

חשופות בפועל אם גודל הקלט מושפע מתוקף; השחתת ערימה עלולה לגרום לקריסה, והרצת קוד רק מוסקת (OpenCVE)

אפליקציות שרק מקשרות ל-OpenSSL, או מריצות 3.x, 1.1.1 או 1.0.x

מחוץ לטווח הגרסאות הפגיע; הפעלה דורשת קריאה ישירה עם קלט של כ-1.5GB

המעקב של ההפצות עדיין ב-Needs evaluation; עותקים מוטמעים (Node.js, edk2) מסומנים בנפרד (Ubuntu)

גרסאות מושפעות, גרסאות מתוקנות ועותקים מוטמעים

טווח הגרסאות

ענף OpenSSL

גרסאות פגיעות

גרסה מתוקנת (מדווחת)

הערות

4.0.x

4.0.0 עד 4.0.3

4.0.4

זמינות התיקון שנויה במחלוקת

4.1.x

4.1.0

4.1.1

זמינות התיקון שנויה במחלוקת

3.x

לא בטווח

—

Debian trixie: 3.5.7; testing/unstable: 3.6.5

1.1.1 ו-1.0.x

לא בטווח

—

עם זאת, ראו הערה על Node.js ב-Ubuntu 22.04

הטווחים מבוססים על רשומת ה-CVE, והגרסאות המתוקנות על הפוסט ב-LinkedIn. שימו לב ש-OpenCVE מציינת שאין גרסאות רשומות, בניגוד לרשומה עצמה, כך שגם כלי מעקב אוטומטיים עלולים להציג תמונה חלקית.

מצב ההפצות: Ubuntu ו-Debian

נכון ל-19 בנובמבר 2026, המעקב של Ubuntu סימן את חבילת openssl כ-Needs evaluation בכל הגרסאות מ-14.04 ועד 26.10. כלומר, Ubuntu עדיין לא קבעה אם החבילות שלה פגיעות.

ב-Debian, דפי התיעוד מראים שענף experimental מכיל את הגרסה 4.0.3+really4.1.0-1. שם הגרסה הזה דו-משמעי: הוא מרמז שהחבילה מכילה בפועל קוד של 4.1.0 תחת מספר גרסה של 4.0.3. בכל מקרה, שתי האפשרויות נמצאות בטווח הפגיע, ולכן מי שמשתמש בחבילות מ-experimental צריך לטפל בזה. הגרסאות היציבות של Debian מריצות 3.x.

עותקים מוטמעים: Node.js ו-edk2

חלק מהתוכנות לא משתמשות ב-OpenSSL של המערכת אלא מגיעות עם עותק משלהן. לפי ההערות של Ubuntu:

  • nodejs ב-Ubuntu 22.04 (jammy) מטמיע OpenSSL 1.1.1m, ומסומן Vulnerable. בגרסאות 14.04, 20.04, 24.04, 26.04 ו-26.10 הוא מסומן Not affected.
  • edk2 (קושחת UEFI) מטמיע OpenSSL 1.1.1j ב-jammy, 3.0.9 ב-noble ו-3.5.1 ב-resolute ו-stonking.

יש כאן סתירה שכדאי לשים אליה לב: גרסה 1.1.1m נמצאת מחוץ לטווח 4.x שמופיע ברשומת ה-CVE, ובכל זאת Ubuntu מסמנת את nodejs ב-jammy כ-Vulnerable. המקורות לא מסבירים את הפער. המסקנה המעשית היא שעותקים מוטמעים דורשים הערכה נפרדת, ושלא כדאי להסתמך רק על גרסת ה-OpenSSL של המערכת.

בדיקת גרסת OpenSSL: שרתים, Docker, Node.js, Python ו-nginx

המקורות לא התייחסו באופן ספציפי ל-Docker, ל-Python או ל-nginx. הפקודות הבאות הן פקודות סטנדרטיות לבדיקת גרסת OpenSSL, ומומלץ לאמת את התוצאות מול סביבת הייצור שלכם. המטרה: לזהות אם יש במערכת OpenSSL בגרסה 4.0.0 עד 4.0.3 או 4.1.0.

שרת לינוקס

# גרסת הבינארי של openssl
openssl version -a

# Debian / Ubuntu: חבילות מותקנות
dpkg -l | grep -Ei 'libssl|openssl'
apt-cache policy openssl

# RHEL / Fedora / Rocky
rpm -qa | grep -i openssl

# Alpine
apk info -v | grep -i ssl

חשוב לזכור ש-openssl version מחזיר את גרסת כלי שורת הפקודה, ולא בהכרח את גרסת הספרייה שכל אפליקציה משתמשת בה בפועל. אפליקציות עם OpenSSL מקושר סטטית או עותק מוטמע לא יופיעו בבדיקה הזו.

אימג'י Docker

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

# אימג' שיש בו את הבינארי openssl
docker run --rm --entrypoint openssl my-image:tag version

# אימג' מבוסס Debian או Ubuntu
docker run --rm --entrypoint sh my-image:tag -c 'dpkg -l | grep -Ei "libssl|openssl"'

# אימג' מבוסס Alpine
docker run --rm --entrypoint sh my-image:tag -c 'apk info -v | grep -i ssl'

# סריקת אימג' עם סורק פגיעויות (למשל Trivy)
trivy image my-image:tag

אימג'ים מסוג distroless או scratch לא כוללים shell ולא מנהל חבילות. במקרים כאלה, סורק פגיעויות שמנתח את שכבות האימג' הוא בדרך כלל הדרך המעשית. סורקים עשויים להציג את החולשה כקריטית בגלל ציון 9.8, ולכן כדאי לבדוק בעצמכם את גרסת OpenSSL שהם זיהו לפני שמסלימים. למי שמחפש מסגרת עבודה רחבה יותר לטיפול בהתראות כאלה, יש צ'קליסט לאבטחת שרשרת אספקה בצוותים קטנים.

Node.js

Node.js מגיע בדרך כלל עם OpenSSL מוטמע, ולכן גרסת המערכת לא בהכרח רלוונטית:

# גרסת OpenSSL שבתוך Node.js
node -p "process.versions.openssl"

# בתוך אימג' Node
docker run --rm node:22 node -p "process.versions.openssl"

אם אתם על Ubuntu 22.04 ומשתמשים בחבילת nodejs של ההפצה, זכרו שלפי Ubuntu היא מסומנת Vulnerable, ועקבו אחרי עדכון החבילה. לשימוש ב-API של base64 ב-Node.js (כמו Buffer.toString('base64')) יש מימוש משלו, אך המקורות לא בדקו את הנושא, ולכן כדאי לאמת זאת בתיעוד של Node.js. ניתוח נוסף על חולשות שנגעו ב-Node.js וב-Python זמין במדריך על http2shell.

Python

# גרסת OpenSSL שמודול ssl מקושר אליה
python3 -c "import ssl; print(ssl.OPENSSL_VERSION)"

# אם משתמשים בספריית cryptography
python3 -c "from cryptography.hazmat.backends.openssl import backend; print(backend.openssl_version_text())"

חבילות Python עם wheels בינאריים עשויות להגיע עם OpenSSL משלהן, בנפרד מזו של המערכת. לכן כדאי להריץ את הבדיקה השנייה בכל סביבה וירטואלית שבה מותקנת ספריית קריפטוגרפיה.

nginx

# מראה מול איזו גרסת OpenSSL nginx נבנה
nginx -V 2>&1 | grep -i openssl

הפלט יציין את גרסת OpenSSL שאיתה nginx נבנה, ולעיתים גם את הגרסה שאיתה הוא רץ. nginx משתמש ב-OpenSSL בעיקר ל-TLS, ולכן לפי ההסקה מהמקורות הסיכון הישיר נמוך, אבל מודולים של צד שלישי עשויים לעבוד אחרת. מי שמתחזק nginx בייצור יכול להיעזר גם במדריך על חולשות nginx2root.

חיפוש קריאות ישירות ל-EVP_EncodeBlock

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

# חיפוש בקוד המקור
grep -rn 'EVP_EncodeBlock' --include='*.c' --include='*.h' --include='*.cc' --include='*.cpp' --include='*.rs' --include='*.go' .

# האם בינארי מייבא את הסמל מספרייה דינמית
nm -D --undefined-only ./my-binary | grep EVP_EncodeBlock

# לאילו ספריות OpenSSL הבינארי מקושר
ldd ./my-binary | grep -E 'libcrypto|libssl'

בינארי שמקושר סטטית לא יציג את libcrypto בפלט של ldd, ולכן במקרה כזה צריך לבדוק את מערכת הבנייה. בשפות כמו Go או Rust, חפשו גם שימוש ב-bindings ל-OpenSSL שעוטפים את הפונקציה.

איך מעדכנים OpenSSL ומה עושים עד שיש תיקון

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

אם אתם מריצים OpenSSL 4.0.0 עד 4.0.3 או 4.1.0, היעד הוא 4.0.4 או 4.1.1, בהתאם לענף, לפי הפוסט ב-LinkedIn. CVEfeed ממליצה לעדכן לגרסה מתוקנת ולבדוק גם את הטיפול בחוצצים בפונקציות קידוד קשורות.

סדר פעולות מעשי לשאלה איך מעדכנים OpenSSL:

  1. אמתו שהגרסה המתוקנת קיימת במאגר של OpenSSL ובחבילות של ההפצה שלכם. בגלל הסתירה בין המקורות, אל תניחו שהיא זמינה.
  2. עדיפו חבילות של ההפצה על פני בנייה ידנית, כי הן מקבלות עדכוני אבטחה שוטפים.
  3. בנו מחדש אימג'ים של Docker ואל תסתפקו בעדכון השרת המארח, כי כל אימג' מכיל עותק משלו.
  4. הפעילו מחדש את השירותים אחרי עדכון ספרייה דינמית, כי תהליכים פעילים ממשיכים להשתמש בעותק הישן שבזיכרון.
  5. בדקו מחדש עם הפקודות מהסעיף הקודם שהגרסה החדשה באמת בשימוש.
# Debian / Ubuntu, אחרי שעדכון זמין
sudo apt update && sudo apt install --only-upgrade openssl libssl*

# מציאת תהליכים שעדיין משתמשים בספרייה הישנה שנמחקה
sudo lsof 2>/dev/null | grep -E 'libcrypto|libssl' | grep DEL

הגבלת גודל הקלט בקוד

כל עוד אין תיקון זמין, או במקביל אליו, המיתון היעיל ביותר הוא להגביל את אורך הקלט הרחק מתחת ל-INT_MAX. OpenCVE מציינת הגבלת אורך כדרך מיתון לאפליקציות שקוראות לפונקציה. דוגמה ל-wrapper בטוח יותר ב-C:

#include <openssl/evp.h>
#include <stdlib.h>

/* Cap well below INT_MAX; tune to the real needs of the service */
#define MAX_B64_INPUT ((size_t)64 * 1024 * 1024) /* 64 MB */

unsigned char *safe_b64_encode(const unsigned char *in, size_t in_len, int *out_len)
{
    if (in == NULL || out_len == NULL || in_len > MAX_B64_INPUT)
        return NULL;

    /* 4 output bytes per 3 input bytes, plus NUL terminator, computed in size_t */
    size_t needed = 4 * ((in_len + 2) / 3) + 1;
    unsigned char *out = malloc(needed);
    if (out == NULL)
        return NULL;

    int n = EVP_EncodeBlock(out, in, (int)in_len);
    if (n < 0) {
        free(out);
        return NULL;
    }
    *out_len = n;
    return out;
}

כמה עקרונות שעומדים מאחורי הקוד:

  • החישוב נעשה ב-size_t ולא ב-int, כך שגודל החוצץ לא גולש.
  • המגבלה נאכפת לפני ההמרה ל-int, כך שערך גדול לא יגיע לפונקציה בכלל.
  • המגבלה מוגדרת לפי צורכי השירות. מעט שירותים צריכים לקודד מאות מגה-בייטים בבת אחת.
  • לנתונים גדולים באמת, עדיף לקודד בחלקים (streaming) במקום בקריאה אחת. התיעוד של OpenSSL מתאר גם ממשק הדרגתי (EVP_EncodeInit, EVP_EncodeUpdate, EVP_EncodeFinal) באותו דף תיעוד, אבל לאור ההמלצה של CVEfeed לבדוק פונקציות קידוד קשורות, גם שם כדאי לעבוד עם חלקים בגודל סביר.

בנוסף לקוד, כדאי להגביל גודל בקשות כבר בשכבה החיצונית: מגבלת גוף בקשה ב-reverse proxy, מגבלת גודל העלאה באפליקציה ומגבלות זיכרון לקונטיינר. כל שכבה כזו מקשה על תוקף להעביר קלט של 1.5GB עד לפונקציה. מקרה אחר שבו קידוד base64 עמד במרכז חולשה מתואר במדריך על Java4Shell ב-OpenJDK.

מעקב אחרי ההפצה והספק

מכיוון שגם Ubuntu וגם Debian היו בשלב Needs evaluation בזמן פרסום המקורות, כדאי לעקוב אחרי:

  • דף ה-CVE ב-Ubuntu, שמתעדכן לפי חבילה וגרסה.
  • בקשת התיקון #33652 במאגר של OpenSSL, כדי לדעת מתי היא ממוזגת.
  • רשומת ה-CVE, למקרה שהטווחים או הציון ישתנו.
  • הודעות האבטחה של ספקי אימג'ים, ספקי ענן וספקי תוכנה שמטמיעים OpenSSL.

צ'קליסט עדיפויות

לצוותי פיתוח ו-DevOps בישראל, כמו בכל מקום אחר, הסדר הבא עוזר לחלק את המאמץ לפי סיכון אמיתי ולא לפי ציון:

  1. מיפוי גרסאות: הריצו את פקודות הבדיקה על שרתי ייצור, אימג'י Docker, runners של CI וסביבות Python ו-Node.js.
  2. סינון לפי טווח: התמקדו רק במערכות עם OpenSSL 4.0.0 עד 4.0.3 או 4.1.0, וסמנו בנפרד את nodejs ב-Ubuntu 22.04.
  3. חיפוש קריאות ישירות: בדקו אם קוד שלכם או ספריות שלכם קוראים ל-EVP_EncodeBlock.
  4. בדיקת מקור הקלט: אם יש קריאה, האם תוקף יכול להשפיע על גודל הקלט? אם כן, זו העדיפות הראשונה.
  5. מיתון מיידי: הגבלת אורך קלט בקוד ובשכבות החיצוניות.
  6. עדכון: לגרסה מתוקנת ברגע שהיא זמינה ומאומתת אצל הספק שלכם.
  7. תיעוד: רשמו מה נבדק ומה הוחלט, כדי שהתראות עתידיות של סורקים ייסגרו מהר.

שאלות נפוצות

אילו גרסאות OpenSSL מושפעות מחולשת CVE-2026-121481?

לפי רשומת ה-CVE, הגרסאות המושפעות הן OpenSSL 4.0.0 עד 4.0.3 ו-4.1.0. הגרסאות המתוקנות מדווחות כ-4.0.4 ו-4.1.1, אך זמינותן שנויה במחלוקת בין המקורות.

האם השרת חשוף אם הוא משתמש ב-OpenSSL רק ל-TLS?

המקורות מצביעים על חשיפה רק כשאפליקציה קוראת ל-EVP_EncodeBlock עם קלט קרוב ל-INT_MAX, כלומר מעל כ-1.5GB, לפי sysxplore. קישור בלבד ל-OpenSSL לא מתואר כמספיק לחשיפה, אם כי זו הסקה מהמקורות ולא קביעה רשמית של OpenSSL.

האם קיים ניצול ציבורי לחולשה?

לא. Tenable מציינת שאין ניצולים ידועים, וכך גם הפוסט ב-LinkedIn. לפי OpenCVE, החולשה אינה ברשימת KEV של CISA.

האם ל-Ubuntu יש כבר עדכון?

נכון ל-19 בנובמבר 2026, חבילת openssl סומנה כ-Needs evaluation בכל הגרסאות שמופיעות ב-מעקב של Ubuntu, וחבילת nodejs ב-22.04 jammy סומנה Vulnerable. יש לבדוק את הדף שוב לפני כל תכנון עדכון.

האם החולשה ניתנת לניצול מרחוק?

המקורות לא עקביים. CVEfeed מציינת שלא, בעוד שווקטור ה-CVSS של Tenable מגדיר ניצול ברשת (AV:N). לפי OpenCVE, ניצול מרחוק תלוי באפליקציה שמעבירה לפונקציה קלט גדול ולא מהימן.

מה כדאי לעשות כבר עכשיו?

לבדוק אם מריצים OpenSSL 4.0.0 עד 4.0.3 או 4.1.0, לעדכן לגרסה מתוקנת כשהספק מספק אותה, ולהגביל את גודל הקלט בכל קוד שקורא ל-EVP_EncodeBlock, בהתאם להמלצות של CVEfeed.

סיכום

חולשת OpenSSL CVE-2026-121481 היא באג אמיתי: גלישה בחישוב גודל הפלט ב-EVP_EncodeBlock שעלולה לגרום לכתיבה מעבר לסוף חוצץ בערימה. עם זאת, הציון 9.8 משקף תרחיש גרוע ביותר, והחשיפה בפועל צרה בהרבה ממה שהמספר מרמז.

כדי להיות בסיכון, צריך שלושה דברים במקביל: גרסת OpenSSL בענף 4.x בטווח הפגיע, קוד שקורא לפונקציה ישירות, וקלט של יותר מ-1.5GB שתוקף יכול להשפיע עליו. רוב ההפצות היציבות עדיין מריצות 3.x, שנמצא מחוץ לטווח, אבל עותקים מוטמעים כמו nodejs ב-Ubuntu 22.04 מקבלים סטטוס נפרד שדורש תשומת לב.

הצעדים המעשיים ברורים: למפות גרסאות בשרתים, באימג'ים ובסביבות ריצה; לחפש קריאות ישירות; להגביל גודל קלט; ולעדכן ברגע שגרסה מתוקנת מאומתת. בגלל הסתירות בין המקורות לגבי זמינות התיקון ומקור הציון, כדאי להמשיך לעקוב אחרי רשומת ה-CVE, אחרי בקשת התיקון ואחרי מעקב האבטחה של ההפצה.

מקורות

וואטסאפ