http2shell היא החולשה שתפסה את צוותי הפיתוח והאבטחה לא מוכנים בסוף אוקטובר 2026. מה שהתחיל כפרצת אבטחה ב-Node.js בשם Node2Shell התברר תוך יומיים כבעיה רחבה בהרבה: באג במפענח Brotli, שמשותף ל-Node.js, ל-Bun, לחבילות Python, לקוד C++ ול-Envoy. לפי Aikido Security, ספריות ואפליקציות רבות שמשתמשות ב-HTTP חשופות ל-pre-auth RCE, כלומר הרצת קוד מרחוק בלי שהתוקף צריך להזדהות.
הבעיה הגדולה היא לא רק החומרה אלא הפריסה. המפענח הפגיע יושב עמוק בשרשרת התלויות: בתוך ה-runtime, בתוך חבילות שנמשכות בעקיפין כמו urllib3 ו-requests, ובתוך אימג'ים של Docker שנבנו לפני חודשים ואף אחד לא נגע בהם מאז. נכון ל-23 באוקטובר, עדיין לא היו תיקונים לכל השירותים המושפעים, וכלי הסריקה הנפוצים ל-Python לא סימנו את הגרסאות הפגיעות.
המאמר הזה מסביר מה זו http2shell בפועל, למה השם שלה מטעה, אילו גרסאות של Node.js ו-Python נפגעות, איך לבדוק אם השרת פגיע, ומהו צ'קליסט מעשי לעדכון ולמיטיגציה עבור צוותים שמריצים Next.js ו-backend מבוסס Node, כולל בסביבות קונטיינרים ו-CI.
מה זה http2shell ולמה השם מטעה
מבחינה טכנית, http2shell היא הכינוי של CVE-2026-111497, חולשה בתהליך פענוח (decompression) של נתונים דחוסים בפורמט Brotli. Brotli הוא אלגוריתם דחיסה נפוץ מאוד ברשת: שרתים משתמשים בו כדי לדחוס תגובות HTTP, ולקוחות HTTP יודעים לפרוס אותו אוטומטית כשהכותרת Content-Encoding: br מופיעה.
למרות השם, המקורות לא מתארים פגם בפרוטוקול HTTP/2 עצמו. לפי הניתוח של Aikido, הטריגר הוא נתונים דחוסים ב-Brotli: גוף בקשה שנשלח עם Content-Encoding: br, או תגובה שלקוח HTTP מוריד ופורס. השם http2shell משקף את הטווח הרחב של ספריות ואפליקציות HTTP שנפגעות, לא שכבה ספציפית של HTTP/2 פגיעות בפרוטוקול.
ציר הזמן: מ-Node2Shell ל-http2shell
ההתפתחות של החולשה הייתה מהירה, וזה חלק מהסיבה לבלבול סביבה:
- 21 באוקטובר 2026: Node.js משחררת עדכון אבטחה לפגם בפענוח Brotli בכל קווי ההפצה הנתמכים.
- 22 באוקטובר 2026: Aikido מפרסמת את הניתוח הראשון תחת השם Node2Shell, עם התמקדות ב-Node.js וב-Bun.
- 23 באוקטובר 2026: מתברר שאותו מפענח פגיע מקומפל גם לתוך חבילות Python, והבעיה מקבלת את השם HTTP2Shell. הפוסט עודכן שוב ב-24 באוקטובר.
- 23 באוקטובר 2026: Aikido מפרסמת ברשת X שטלאים זמינים ל-libbrotli, Python, C++, Node.js ו-Envoy, ושעוד טלאים בדרך. הפוסט צבר כ-52.6 אלף צפיות.
עד כמה זה חמור?
כאן כדאי לשים לב לניסוח. הפוסט המקורי על Node.js מתאר השפעה שיכולה לנוע בין קריסת תהליך, דליפה חלקית של זיכרון, ועד אפשרות להרצת קוד של התוקף. בפוסט ב-X, לעומת זאת, Aikido מגדירה את הבעיה כ-pre-auth RCE. במקורות שזמינים בשלב זה לא מופיע ציון CVSS רשמי או טקסט ייעוץ מ-NVD, וכל המידע מגיע מחברת אבטחה מסחרית אחת.
מבחינה מעשית, ההבדל הזה לא אמור לשנות את סדר העדיפויות. גם קריסת תהליך שאפשר להפעיל מבחוץ היא מתקפת מניעת שירות, ודליפת זיכרון עלולה לחשוף סודות. כשיש אפשרות ממשית ל-RCE, נכון להתייחס לחולשת RCE הזו כאל קריטית עד שיוכח אחרת.
לא לבלבל: PHP2Shell ו-CVE של HTTP/2 RST_STREAM
באותו שבוע פורסמה גם PHP2Shell (CVE-2026-109618 ו-CVE-2026-109619), חולשה נפרדת לחלוטין בעולם PHP. מי שמנהל גם אתרי וורדפרס יכול לקרוא עליה במדריך על PHP2Shell ולמה עדכון וורדפרס לא מספיק. אין קשר טכני בין שתי החולשות מעבר לסיומת השם.
בנוסף, ביולי 2026 פורסמה CVE-2026-56848, חולשת heap use-after-free במימוש HTTP/2 של Node.js שקשורה לטיפול ב-RST_STREAM. זו כן חולשה בשכבת HTTP/2, אבל היא לא http2shell. מי שעדכן את Node.js ביולי עדיין צריך לעדכן שוב עכשיו.
איך החולשה נגישה: שלושה מסלולי תקיפה
כדי להבין אם מערכת מסוימת חשופה, צריך לשאול שאלה פשוטה: האם איפשהו בקוד, ב-runtime או בתלויות, נתוני Brotli שתוקף שולט בהם עוברים פענוח? לפי Aikido, אפליקציות Node.js או Bun שפורסות נתוני Brotli בשליטת תוקף הן המושפעות. יש שלוש דרכים עיקריות שבהן זה קורה.
מסלול 1: גופי בקשה עם Content-Encoding: br
זה המסלול הישיר ביותר. לפי Aikido, Express 5 ו-body-parser בגרסה 2.x פורסים גופי בקשה שנשלחים עם Content-Encoding: br, ולכן כל לקוח יכול לשלוח בקשה כזו. אין צורך בהזדהות, אין צורך בטוקן, ואין צורך בידע מוקדם על האפליקציה מעבר לכתובת של endpoint שמקבל JSON או טופס.
לעומת זאת, שרת HTTP בסיסי של Node.js, בלי framework, לא מפענח גופי בקשה דחוסים ב-Brotli בעצמו. כלומר, החשיפה תלויה במה שיושב מעל node:http.
דוגמה לבקשה כזו, להמחשת המבנה בלבד:
POST /api/webhook HTTP/1.1
Host: api.example.co.il
Content-Type: application/json
Content-Encoding: br
Content-Length: 312
<binary brotli payload>מסלול 2: fetch ותגובות משרתים חיצוניים
המסלול השני פחות אינטואיטיבי, ודווקא בגלל זה מסוכן. לפי Aikido, הפונקציה fetch() של Node.js פורסת אוטומטית תגובות שדחוסות ב-Brotli. המשמעות: שרת בשליטת תוקף, או שרת לגיטימי שנפרץ, יכול להגיע לאפליקציה דרך התגובה שהוא מחזיר.
המטרות הטיפוסיות לפי המקור הן:
- Webhooks יוצאים: מערכת ששולחת קריאה לכתובת שהמשתמש הגדיר.
- פיצ'רים שקוראים לכתובות שהמשתמש סיפק: תצוגה מקדימה של קישורים, ייבוא מ-URL, בדיקת זמינות של אתר.
- אינטגרציות עם צד שלישי: כל API חיצוני שהאפליקציה צורכת עלול להפוך לווקטור אם הוא נפרץ.
לצוותים בישראל זה רלוונטי במיוחד. מערכות רבות מתחברות לשירותי סליקה, הפקת חשבוניות, CRM ומערכות שליחת הודעות, וחלקן מאפשרות ללקוח להגדיר כתובת callback. כלי אוטומציה בהתקנה עצמית שרצים על Node.js, כמו אלה שמתוארים במדריך האוטומציה עם n8n, מבצעים בדיוק סוג כזה של קריאות יוצאות לכתובות שהמשתמש הגדיר, ולכן גרסת ה-runtime שבתוך האימג' שלהם חשובה לא פחות מזו של האפליקציה הראשית.
מסלול 3: קריאות ישירות ל-node:zlib
המסלול השלישי הוא קוד שקורא ישירות לפונקציות ה-Brotli של מודול node:zlib על קלט לא מהימן. לפי Aikido, גם קריאות כאלה חשופות. זה כולל, למשל, קוד שמקבל קבצים דחוסים מהמשתמש, מעבד ארכיונים, או פורס payloads מתור הודעות.
import { brotliDecompressSync } from 'node:zlib';
// דפוס מסוכן כשהקלט מגיע ממשתמש או ממקור חיצוני
export function handleUpload(buffer) {
const raw = brotliDecompressSync(buffer);
return JSON.parse(raw.toString('utf8'));
}הקוד עצמו תקין. הבעיה היא במפענח שמתחתיו, ולכן התיקון הוא עדכון ה-runtime ולא שינוי בקוד.
גרסאות Node.js ו-Bun: מה פגיע ומה מתוקן
זה החלק הכי ברור בכל הסיפור. Node.js שחררה עדכון אבטחה לכל קווי ההפצה הנתמכים, והגרסאות המתוקנות הן:
קו הפצה | גרסה מתוקנת מינימלית | סטטוס |
|---|---|---|
Node.js 26.x | 26.12.1 | נתמך, יש תיקון |
Node.js 24.x | 24.22.1 | נתמך, יש תיקון |
Node.js 22.x | 22.23.4 | נתמך, יש תיקון |
Node.js 25.x | אין | EOL, אין תיקון |
Node.js 23.x | אין | EOL, אין תיקון |
Node.js 20.x ומטה | אין | EOL, אין תיקון |
Bun | 1.4.4 ומעלה | יש תיקון |
המקורות לא מפרטים את הטווח המדויק של גרסאות פגיעות בכל קו, אלא רק את נקודת התיקון. ההנחה הבטוחה היא שכל גרסה מתחת לגרסה המתוקנת באותו קו פגיעה.
קווי הפצה שהגיעו ל-EOL
לפי Aikido, Node.js 25.x, 23.x, 20.x וכל מה שלפניהם נמצאים בסוף חיים ולא יקבלו תיקון. זו נקודה קריטית לצוותים שעדיין מריצים Node 20 בפרודקשן כי ״זה עובד״. במקרה הזה אין טלאי לחכות לו: הדרך היחידה היא שדרוג לקו נתמך.
קווים בעלי מספר אי-זוגי, כמו 23 ו-25, הם קווים קצרי טווח מלכתחילה. מי שבחר בהם לפרודקשן נמצא עכשיו במצב שבו עדכון אבטחה Node.js מחייב קפיצת גרסה ראשית, עם כל הבדיקות שזה דורש.
Bun
גם Bun מושפע, והגרסה המתוקנת היא 1.4.4 ומעלה. צוותים שעברו ל-Bun בגלל ביצועים צריכים לוודא שגם הגרסה בסביבת הפיתוח, גם זו שב-CI וגם זו שבאימג' של הפרודקשן מעודכנות.
Node.js מחבילות של הפצת לינוקס
מקרה מיוחד: Node.js שמותקן מחבילות של הפצות לינוקס כמו Debian, Ubuntu, Fedora, RHEL או Alpine עשוי להשתמש בספריית Brotli של המערכת במקום בעותק שמגיע מובנה עם Node.js. במצב כזה, התיקון עשוי להגיע דרך עדכוני ההפצה ולא דרך מספר הגרסה של Node.js. הטקסט במקור קטוע בנקודה זו, ולכן כדאי לבדוק את הודעות האבטחה של ההפצה הספציפית ולוודא שגם ספריית ה-Brotli של המערכת עודכנה.
Python ותוכנות נוספות שנפגעות
הרחבת השם מ-Node2Shell ל-http2shell נובעת בעיקר מעולם ה-Python. מתברר שאותו מפענח פגיע מקומפל לתוך חבילות פופולריות מאוד.
חבילות Python הפגיעות
לפי Aikido, שתי חבילות ב-PyPI מקמפלות את אותו מפענח פגיע:
- Brotli: גרסה 1.2.0 ומטה פגיעות. התיקון בגרסה 1.2.1.
- brotlicffi: גרסאות 1.2.0.x פגיעות. התיקון בגרסה 1.2.1.0.
קיים גם ייעוץ ב-GitHub בשם GHSA-9v8h-qqgm-4m35. כדי להבין את היקף החשיפה: לחבילת Brotli יש כ-82.8 מיליון הורדות בחודש.
לקוחות HTTP שפורסים Brotli אוטומטית
כאן הסכנה האמיתית. אפליקציה יכולה להיות חשופה גם בלי לייבא את Brotli בקוד שלה. מספיק שהחבילה מותקנת בסביבה, וחלק מהלקוחות הנפוצים יפענחו תגובות Brotli אוטומטית:
- urllib3, ולכן גם requests שבנוי מעליו.
- httpx כשהוא מותקן עם ה-extra של brotli.
- aiohttp.
- Scrapy.
בפועל, שירות Python שגורד אתרים, צורך API חיצוני או שולח webhooks עלול להיות חשוף דרך תלות שאף אחד בצוות לא התקין במודע.
למה הסורקים לא יתריעו
זו אולי הנקודה הכי מטרידה. נכון ל-23 באוקטובר, לפי Aikido, מאגרי הייעוץ לא מיפו את ה-CVE לחבילות ב-PyPI. כתוצאה מכך, pip-audit, Dependabot ו-Safety לא יסמנו את הגרסאות הפגיעות. בנוסף, הערות השחרור של הגרסאות המתוקנות לא מזכירות את ה-CVE בכלל.
המשמעות: צוות שסומך על דשבורד ירוק ב-Dependabot כדי לדעת שהוא מוגן, לא מוגן. צריך לבדוק ידנית את הגרסה המותקנת.
libbrotli, C++, Envoy, Nginx ו-Apache
לפי הפוסט של Aikido ב-X, טלאים זמינים ל-libbrotli (המרכיב החשוב ביותר, כי ממנו נגזרות שאר הגרסאות), ל-Python, ל-C++, ל-Node.js ול-Envoy, ועוד טלאים בדרך. ל-Envoy יש ייעוץ נפרד: GHSA-3wvj-j6qm-62mr.
לגבי שרתי ה-web הנפוצים, Aikido מציינת שApache ו-Nginx לא מפענחים Brotli כברירת מחדל. זה חשוב כי Nginx משמש הרבה פעמים כ-reverse proxy לפני אפליקציית Node. עם זאת, העובדה ש-Nginx לא מפענח את הגוף אומרת שהוא מעביר אותו כמו שהוא לאפליקציה שמאחוריו. Nginx לא מגן על Express 5, הוא פשוט לא פגיע בעצמו.
מי שמשתמש ב-Envoy כ-API gateway, כ-sidecar ב-service mesh או כ-ingress ב-Kubernetes צריך לבדוק את הייעוץ הספציפי ואת גרסת ה-Envoy בפועל, כולל גרסאות שמגיעות ארוזות בתוך מוצרים אחרים.
איך לבדוק אם השרת פגיע
הבדיקה צריכה לכסות כל מקום שבו קוד רץ: מחשבי המפתחים, ה-CI, השרתים והקונטיינרים. Aikido ממליצה להריץ node --version בכל הסביבות האלה ולבנות מחדש אימג'ים שננעצו על תגיות ישנות.
שלב 1: גרסת Node.js בכל סביבה
# מקומית, בשרת או ב-runner של CI
node --version
# אם יש Bun
bun --versionהשוו את התוצאה לטבלה: 22.23.4 ומעלה בקו 22, 24.22.1 ומעלה בקו 24, 26.12.1 ומעלה בקו 26, ו-Bun 1.4.4 ומעלה. כל גרסה של 20, 23 או 25 דורשת שדרוג קו.
שלב 2: קונטיינרים ואימג'ים
לפי Aikido, אימג' שננעץ על תגית ישנה, למשל node:22.23.3-alpine, נשאר פגיע עד שבונים אותו מחדש על גרסה מתוקנת. זה נכון גם לאימג'ים שכבר רצים בפרודקשן: עדכון ה-Dockerfile לא משנה כלום עד שמבצעים build ו-deploy.
# בדיקת גרסת Node.js בתוך אימג' קיים
docker run --rm my-api:latest node --version
# בדיקה בתוך pod שרץ ב-Kubernetes
kubectl exec -n production deploy/my-api -- node --version
# איתור תגיות Node.js נעוצות בכל ה-Dockerfiles במאגר
grep -rn 'FROM node:' --include=Dockerfile* .אל תשכחו multi-stage builds: גם שלב ה-build וגם שלב ה-runtime צריכים להתבסס על גרסה מתוקנת, אבל השלב הקריטי הוא זה שרץ בפרודקשן.
שלב 3: האם יש מסלול חשיפה בקוד
# גרסאות Express ו-body-parser בפרויקט
npm ls express body-parser
# קריאות ישירות לפענוח Brotli
grep -rnE 'brotliDecompress|createBrotliDecompress' --include=*.js --include=*.ts src/
# שימושים ב-fetch שעשויים לפנות לכתובות חיצוניות
grep -rn 'fetch(' --include=*.ts --include=*.js src/ | grep -v node_modulesהבדיקה הזו לא מחליפה את העדכון, אבל היא עוזרת לתעדף. שירות שמריץ Express 5 ומקבל בקשות מהאינטרנט הוא בעדיפות עליונה. שירות פנימי שלא מקבל קלט חיצוני ולא פונה לכתובות שהמשתמש מגדיר נמצא נמוך יותר בתור, אבל עדיין צריך עדכון.
שלב 4: סביבות Python
מכיוון שהסורקים לא יתריעו, הבדיקה חייבת להיות ידנית:
# האם החבילות מותקנות ובאיזו גרסה
pip show Brotli brotlicffi
# בדיקה מהירה בכל הסביבה
pip list 2>/dev/null | grep -i brotli
# מי מושך את Brotli בעקיפין (דורש pipdeptree)
pipdeptree --reverse --packages Brotli,brotlicffi
# עדכון לגרסאות המתוקנות
pip install --upgrade 'Brotli>=1.2.1' 'brotlicffi>=1.2.1.0'בדקו גם קבצי lock כמו requirements.txt, poetry.lock או uv.lock, ונעצו גרסה מינימלית מתוקנת כדי שהתקנה עתידית לא תחזיר גרסה פגיעה.
שלב 5: פלטפורמות מנוהלות והפצות לינוקס
לפי Aikido, פלטפורמות מנוהלות שאורזות גרסת Node.js משלהן עשויות לפגר אחרי upstream. מי שמריץ פונקציות serverless, שירותי hosting מנוהלים או פלטפורמות PaaS צריך לבדוק בפועל איזו גרסת runtime רצה, ולא להניח שהספק כבר עדכן. דרך פשוטה היא endpoint זמני שמחזיר את process.version, או בדיקה בלוגים של ה-build.
אם Node.js מותקן מחבילת הפצה, הריצו את מנהל החבילות של ההפצה (apt, dnf, apk) ובדקו שגם Node.js וגם ספריית Brotli של המערכת עודכנו.
צ'קליסט אבטחת שרתי Next.js ו-Node backend
הצ'קליסט הבא מרכז את כל הצעדים לפי סדר עדיפות. הוא מיועד לצוותים שמריצים Next.js, Express, Fastify או שירותי Node אחרים, לצד שירותי Python.
הערה חשובה על Next.js
המקורות לא מכסים במפורש את החשיפה של Next.js. לא מאומת אם Next.js מפענח גופי בקשה דחוסים ב-Brotli. מה שכן ידוע הוא ש-Next.js רץ על Node.js, ולכן כל פיצ'ר בו שמשתמש ב-fetch() מול כתובות חיצוניות (Server Components, Route Handlers, Server Actions) נשען על ה-fetch של ה-runtime, שלפי Aikido פורס תגובות Brotli אוטומטית. בנוסף, פרויקטים רבים מריצים Express או שרת custom לצד Next.js. המסקנה המעשית: גרסת Node.js שמריצה את Next.js חייבת להיות מתוקנת, בלי קשר לשאלה הפתוחה לגבי גופי בקשה. מי שבוחר טכנולוגיה לאתר יכול להעמיק בשיקולים בהשוואה בין Next.js ל-Webflow.
הצ'קליסט
- מיפוי: רשימה של כל השירותים, האימג'ים, ה-runners והפונקציות שמריצים Node.js, Bun או Python.
- גרסאות Node.js: עדכון ל-22.23.4, 24.22.1 או 26.12.1 ומעלה. שירותים על 20, 23 או 25 עוברים לקו נתמך.
- Bun: עדכון ל-1.4.4 ומעלה.
- Dockerfiles: עדכון תגיות
FROM, בנייה מחדש ופריסה. לא להסתפק בשינוי הקובץ. - אימג'ים שרצים: וידוא בפועל עם
docker runאוkubectl execשהגרסה החדשה רצה בפרודקשן. - CI runners: עדכון גרסת Node.js ב-workflows, כולל runners בהתקנה עצמית.
- Python: עדכון Brotli ל-1.2.1 ו-brotlicffi ל-1.2.1.0, ונעיצת גרסה מינימלית בקבצי ה-lock.
- סורקים: לא לסמוך על pip-audit, Dependabot או Safety בנושא הזה עד שהמאגרים יתעדכנו.
- הפצות לינוקס: עדכון חבילות מערכת, כולל ספריית Brotli.
- Envoy: בדיקת הייעוץ GHSA-3wvj-j6qm-62mr ועדכון.
- פלטפורמות מנוהלות: בדיקה בפועל של גרסת ה-runtime אצל ספק ה-hosting.
- Express 5 ו-body-parser 2.x: אם העדכון לא אפשרי מיד, חסימה זמנית של בקשות עם
Content-Encoding: br(ראו בהמשך). - פיצ'רים יוצאים: מיפוי webhooks, תצוגות מקדימה וקריאות לכתובות שמשתמשים מגדירים, ומתן עדיפות לעדכון השירותים שמריצים אותם.
- ניטור: מעקב אחרי קריסות חריגות של תהליכים, שעלולות להעיד על ניסיונות ניצול.
מיטיגציות כשאין טלאי
לפי Aikido, כשאין טלאי לספרייה או לאפליקציה מושפעת, ההמלצה היא לבטל את פענוח Brotli עד שהטלאים יגיעו, ובמקביל לחפש עדכוני תלות ל-Brotli 1.2.1. המקורות לא מפרטים צעדי ביטול ספציפיים לכל framework, ולכן הפתרון תלוי בארכיטקטורה.
עבור אפליקציית Express, אפשר להוסיף middleware שרץ לפני ה-body parser ודוחה בקשות עם קידוד Brotli. זו דוגמה כללית לגישה, לא פתרון רשמי:
import express from 'express';
const app = express();
// חסימה זמנית של גופי בקשה דחוסים ב-Brotli עד לעדכון ה-runtime
app.use((req, res, next) => {
const encoding = (req.headers['content-encoding'] || '').toLowerCase();
if (encoding.split(',').map((e) => e.trim()).includes('br')) {
return res.status(415).json({ error: 'Unsupported Content-Encoding' });
}
next();
});
app.use(express.json());חשוב להבין את המגבלות של גישה כזו:
- היא מטפלת רק במסלול של גופי בקשה נכנסים, לא בתגובות ש-
fetch()מוריד ולא בקריאות ישירות ל-node:zlib. - היא חייבת לרוץ לפני כל middleware שמפענח את הגוף.
- לקוחות לגיטימיים ששולחים בקשות דחוסות ב-Brotli ייחסמו. ברוב ה-APIs זה נדיר, אבל כדאי לבדוק לוגים.
אפשר להחיל חסימה דומה גם ברמת ה-reverse proxy או ה-WAF, על ידי דחיית בקשות שהכותרת Content-Encoding שלהן מכילה br. היתרון הוא כיסוי של כל השירותים מאחורי ה-proxy בבת אחת.
לגבי המסלול היוצא, אין דרך פשוטה לבטל את הפענוח האוטומטי של fetch() בלי לשנות קוד, ולכן עדכון ה-runtime הוא הפתרון האמיתי. עד אז, כדאי לבודד שירותים שפונים לכתובות שמשתמשים מגדירים בקונטיינרים נפרדים עם הרשאות מינימליות וגישה מוגבלת לסודות ולרשת הפנימית. בידוד כזה לא מונע ניצול, אבל מצמצם את הנזק.
טיפים לפריסה בטוחה של העדכון
עדכון runtime בכל השירותים בבת אחת הוא שינוי גדול, במיוחד כשחלק מהשירותים קופצים קו גרסה. כמה דגשים:
- פריסה מדורגת: התחילו בשירותים החשופים לאינטרנט, ובמיוחד אלה שמריצים Express 5.
- בדיקות regression: מעבר מ-Node 20 ל-22 או 24 עלול לשבור תלויות native. הריצו את סוויטת הבדיקות המלאה.
- ניטור אחרי פריסה: עליות בשיעור השגיאות אחרי deploy עלולות לגרום לגל של ניסיונות חוזרים בין שירותים. על הדינמיקה הזו והדרכים להימנע ממנה אפשר לקרוא במדריך על retry storm, backoff ו-circuit breaker.
- תיעוד: רשמו איזה שירות עודכן, לאיזו גרסה ומתי. כשיגיעו טלאים נוספים לספריות אחרות, הרשימה הזו תחסוך זמן.
השוואה בין הגישות
גישה | יתרונות | חסרונות |
|---|---|---|
עדכון runtime וספריות (Node 22.23.4 / 24.22.1 / 26.12.1, Brotli 1.2.1) | תיקון אמיתי; מכסה את המסלולים של Node, Bun ו-Python | דורש בנייה מחדש של קונטיינרים; פלטפורמות מנוהלות וחבילות הפצה עלולות לפגר; סורקי Python לא יתריעו |
ביטול פענוח Brotli עד לעדכון | פתרון ביניים כשאין טלאי; ההמלצה הזמנית של Aikido | לא מכסה את כל המסלולים; צעדי ביטול לכל framework לא מפורטים במקורות; Apache ו-Nginx ממילא לא מפענחים כברירת מחדל |
מקור ההשוואה: Aikido על Node2Shell ו-Aikido ב-X.
שאלות נפוצות
האם http2shell היא פגיעות בפרוטוקול HTTP/2?
לא. לפי המקורות, מדובר בחולשה בפענוח Brotli (CVE-2026-111497) בתוך מפענח Brotli. השם HTTP2Shell משקף את ההשפעה הרחבה על ספריות ואפליקציות HTTP, לא פגם בשכבת הפרוטוקול. החולשה הנפרדת שכן קשורה ל-HTTP/2 ב-Node.js היא CVE-2026-56848 מיולי 2026.
אילו גרסאות Node.js מתקנות את החולשה?
22.23.4, 24.22.1 ו-26.12.1, או גרסאות טלאי חדשות יותר באותו קו. קווים בסוף חיים, כלומר 25.x, 23.x, 20.x ומטה, לא יקבלו תיקון. ב-Bun התיקון הוא בגרסה 1.4.4 ומעלה.
איך לבדוק אם השרת פגיע?
הריצו node --version במחשבי הפיתוח, ב-runners של CI, בשרתים ובתוך הקונטיינרים, ובנו מחדש אימג'ים שננעצו על תגיות ישנות. בנוסף, בדקו אם האפליקציה משתמשת ב-Express 5 או ב-body-parser 2.x, אם היא פונה בעזרת fetch() לכתובות חיצוניות, ואם יש בקוד קריאות ישירות לפענוח Brotli.
האם אפליקציית Python שלי מושפעת?
כן, אם בסביבה כלשהי מותקנת Brotli בגרסה 1.2.0 ומטה או brotlicffi בגרסה 1.2.0.x. לעתים קרובות הן נמשכות בעקיפין דרך requests ו-urllib3, httpx, aiohttp או Scrapy. יש לעדכן ל-Brotli 1.2.1 או ל-brotlicffi 1.2.1.0, ולבדוק ידנית, כי pip-audit, Dependabot ו-Safety לא סימנו את הגרסאות הפגיעות נכון ל-23 באוקטובר.
האם Nginx ו-Apache פגיעים?
לפי Aikido, Nginx ו-Apache לא מפענחים Brotli כברירת מחדל. עם זאת, כשהם משמשים כ-reverse proxy הם מעבירים את הבקשה הדחוסה כמו שהיא לאפליקציה שמאחוריהם, ולכן הם לא מגנים על שירות Node או Python פגיע.
מה עושים אם אין טלאי לספרייה שבשימוש?
Aikido ממליצה לבטל את פענוח Brotli עד שיהיו טלאים זמינים, ובמקביל לעקוב אחרי עדכוני תלות ל-Brotli 1.2.1. בפועל, אפשר לחסום בקשות עם Content-Encoding: br ברמת האפליקציה או ה-proxy, ולבודד שירותים שפונים לכתובות חיצוניות.
סיכום
http2shell היא דוגמה מובהקת לחולשה בשרשרת האספקה של תוכנה: באג אחד בספריית דחיסה משותפת שמתפשט ל-Node.js, ל-Bun, ל-Python, ל-C++ ול-Envoy. השם מטעה, כי הבעיה לא בפרוטוקול HTTP/2 אלא בפענוח Brotli, אבל ההשפעה אמיתית: לפי Aikido מדובר ב-pre-auth RCE, ולפחות בקריסה או בדליפת זיכרון שתוקף יכול להפעיל מבחוץ.
הצעדים ברורים: עדכון Node.js ל-22.23.4, 24.22.1 או 26.12.1, עדכון Bun ל-1.4.4, עדכון Brotli ל-1.2.1 ו-brotlicffi ל-1.2.1.0, ובנייה מחדש של כל אימג' שננעץ על גרסה ישנה. שירותים על Node 20, 23 או 25 חייבים לעבור לקו נתמך. בסביבות Python, אסור לסמוך על הסורקים האוטומטיים בשלב זה.
לצוותים שמריצים Next.js ו-backend מבוסס Node, העדיפות הראשונה היא שירותים שחשופים לאינטרנט ומריצים Express 5, ומיד אחריהם שירותים שמבצעים קריאות יוצאות לכתובות שמשתמשים מגדירים, כמו webhooks ואינטגרציות. כיסוי הטלאים עדיין מתפתח, ולכן כדאי לעקוב אחרי עדכונים נוספים בימים הקרובים ולחזור על הבדיקה כשיגיעו תיקונים לספריות נוספות.






