[ טוען... ]

אישורי אבטחה שנפרצו ב-eMudhra: מה מפתחים צריכים לעשות עכשיו

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

שיתוף:

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

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

פרשת אישורי אבטחה שנפרצו של eMudhra היא אחד מאירועי האמון החמורים שנראו לאחרונה בתשתית ה-TLS. המפתחות הפרטיים של שמונה רשויות אישורים ביניים (Intermediate CA) של eMudhra נחשפו, וכולן משתרשרות לשורשים שתוכניות האמון של Mozilla, Microsoft, Apple ו-Chrome סומכות עליהם (אתר הגילוי). בפשטות: מי שמחזיק במפתחות האלה יכול, תיאורטית, להנפיק אישור שייראה תקף עבור כל אתר שהוא.

הדפדפנים הגדולים הגיבו מהר וחסמו את האישורים בתוך ימים. אבל החלק המלמד באמת מתחיל אחרי זה: כלי שורת פקודה ב-macOS כמו git ו-curl המשיכו לסמוך על השרשראות שנפרצו גם אחרי ש-Apple הודיעה על חסימה (Apple Support), ודיווח של חוקר אבטחה מ-24 באוקטובר טען שגם עדכוני מערכת הפעלה לא סגרו את הפער (Ryan Shea). אותו דפוס חוזר בקונטיינרים, באפליקציות Electron ובספריות שמגיעות עם חנות אמון משלהן.

המאמר מפרק את האירוע לגורמים: מה קרה בדיוק, מה המשמעות של רשות אישורים CA ביניים שנפרצה, למה דפדפנים מוגנים ו-git לא, ואיזה צ'קליסט מעשי כדאי להריץ עכשיו על תחנות פיתוח, שרתים, צינורות CI ותמונות Docker. בסוף מוצעת מסגרת תגובה לאירוע ה-CA הבא, כי סביר מאוד שיהיה כזה.

מה קרה: שמונה מפתחות CA ביניים חלשים

ציר הזמן

לפי אתר הגילוי, חוקר שמזוהה בשם Wayne דיווח לתוכניות השורש (Root Programs) ב-17 באוקטובר 2026, והגילוי הפומבי מתוארך ל-20 באוקטובר (אתר הגילוי). באותו מקור מופיע גם 19 באוקטובר כמועד שבו המידע הועבר לגורמים במורד הזרם (Downstream): מפיצי לינוקס, מתחזקי ספריות ויצרני תוכנה שצריכים לעדכן חבילות.

ציר הזמן המלא, כפי שעולה מהמקורות:

  • 17 באוקטובר: דיווח לתוכניות השורש; Firefox ו-Chrome חוסמים את האישורים (אתר הגילוי)
  • 19 באוקטובר: העברת מידע לגורמי Downstream; לפי Apple, זה המועד שבו החלה לחסום (Apple Support)
  • 20 באוקטובר: גילוי פומבי; Microsoft חוסמת; Mozilla משחררת את Firefox 158.0.1 ועדכוני ESR (BleepingComputer)
  • 22 באוקטובר: מועד החסימה של Apple לפי אתר הגילוי
  • 23 באוקטובר: Apple מתחילה לחסום גם את השורש emSign ECC Root CA - G3 (Apple Support)
  • 24 באוקטובר: Ryan Shea מדווח שהקובץ /etc/ssl/cert.pem ב-macOS עדיין סומך על אישורים שניתן לזייף (Ryan Shea)

למה המפתחות היו חלשים

כל שמונת האישורים השתמשו במפתחות P-384 שנוצרו באפריל 2025, וערכי המפתח הפרטי שלהם היו קטנים מ-256. המשמעות: אפשר היה לשחזר אותם פשוט על ידי בדיקה של 256 מספרים. אחד המפתחות שפורסמו היה בעל הערך 4 (BleepingComputer).

כדי להבין כמה זה חמור, צריך לזכור איך עובדת קריפטוגרפיה של עקומים אליפטיים. המפתח הפרטי הוא מספר שלם שאמור להיבחר באקראי מתוך טווח עצום, בסדר גודל של 2 בחזקת 384. המפתח הציבורי מחושב מתוכו, ומופיע בגלוי בתוך האישור. כשהמספר הפרטי קטן מ-256, כל מי שמחזיק באישור הציבורי יכול לחשב את המפתח הציבורי עבור 1, 2, 3 וכן הלאה עד 255, ולמצוא התאמה בשבריר שנייה.

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

האם נעשה שימוש לרעה?

לפי eMudhra, רוב רשויות הביניים שנפגעו מעולם לא שימשו בסביבת ייצור, והחברה לא מצאה ראיות להנפקת אישורים למשתמשי קצה. עם זאת, אי אפשר לשלול שימוש לרעה מאז אפריל 2025, גם אם אין לכך ראיות (BleepingComputer). זו נקודה שכדאי להפנים: היעדר ראיות אינו ראיה להיעדר, במיוחד כשמדובר במפתחות שהיו חשופים קרוב לשנה וחצי.

מה זה אומר כשרשות אישורים CA ביניים נפרצת

שרשרת האמון בקצרה

כל חיבור HTTPS נשען על שרשרת: אישור השורש (Root) יושב בחנות האמון של מערכת ההפעלה או הדפדפן, אישור הביניים חתום על ידי השורש, ואישור העלה (Leaf) של האתר חתום על ידי אישור הביניים. הלקוח מאמת את השרשרת עד לשורש שהוא מכיר, ואם הכול תקין, החיבור נחשב מאובטח.

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

כך נראית אחת השרשראות שנפגעו, באופן סכמטי:

emSign ECC Root CA - G3          <- שורש בחנות האמון
   └── emSign Root TLS CA - G3
         └── CA ביניים (אחת מהשש שנפגעו)
               └── אישור עלה מזויף לכל דומיין שהוא

TLS מול חתימת קוד

מתוך שמונה רשויות הביניים, שש מנפיקות אישורי TLS ושתיים מנפיקות אישורי חתימת קוד. מי שמחזיק במפתחות של שש רשויות ה-TLS יכול ליצור אישורים שייראו תקפים עבור כל אתר (Apple Support).

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

12 אישורים ושתי שרשראות

לכל אחת משש רשויות ה-TLS יש שני אישורים, בסך הכול 12: אחד תחת emSign Root TLS CA - G3 שמשתרשר ל-emSign ECC Root CA - G3, ואחד בחתימה צולבת (Cross-sign) של Sectigo שמשתרשר ל-AAA Certificate Services (Apple Support).

לפרט הזה יש השלכה מעשית חשובה: הסרה של שורש emSign בלבד מחנות אמון לא חוסמת את המסלול דרך Sectigo. שרת זדוני יכול להציג את גרסת החתימה הצולבת של אישור הביניים, והשרשרת תאומת עד ל-AAA Certificate Services, שורש ותיק ונפוץ מאוד. הסרה של השורש הזה, מנגד, עלולה לשבור אתרים לגיטימיים רבים. זו בדיוק הסיבה שחסימה נכונה נעשית ברמת אישורי הביניים הספציפיים, ולא ברמת השורש.

למה דפדפנים מוגנו תוך ימים

ערוצי ביטול אישורים

לדפדפנים יש מנגנוני ביטול אישורים (Revocation) שהיצרן דוחף מרחוק: OneCRL ו-CRLite אצל Mozilla, ו-CRLSets אצל Chrome. הכלים האלה מגנים על הדפדפנים בלי לחכות לעדכון גרסה מלא (אתר הגילוי). ב-Apple, Safari, Mail ואפליקציות שמשתמשות במסגרות הרשת והאבטחה של המערכת נחסמות אוטומטית באמצעות עדכוני נתוני תצורה, בלי צורך בעדכון מערכת הפעלה (Apple Support).

יצרן

מועד חסימה

מנגנון עיקרי

Firefox

17 באוקטובר

OneCRL / CRLite, ובהמשך Firefox 158.0.1 ו-ESR

Chrome

17 באוקטובר

CRLSets

Microsoft

20 באוקטובר

עדכון חנות האמון של Windows

Apple

19 או 22 באוקטובר (המקורות חלוקים)

עדכוני נתוני תצורה

מקורות לטבלה: אתר הגילוי, Apple Support, BleepingComputer.

מחלוקת על תאריכים ועל השורש

אתר הגילוי ו-BleepingComputer מציינים את 22 באוקטובר כמועד החסימה של Apple, ואילו דף התמיכה של Apple עצמה טוען שהחסימה פעילה מאז 19 באוקטובר (Apple Support). בנוסף, SecurityOnline מדווח ש-Chrome ו-Firefox מתאמים הסרת אמון מהשורש עצמו (SecurityOnline), בעוד שדף התמיכה של Apple מזכיר רק את החסימה של emSign ECC Root CA - G3 מצד Apple ב-23 באוקטובר. הפערים האלה לא משנים את ההמלצות המעשיות, אבל כדאי לבדוק מקורות רשמיים לפני שמסתמכים על תאריך ספציפי.

הגבול של מנגנוני הביטול

כאן נמצא לב העניין. מנגנוני הביטול מגנים רק על מי שצורך אותם. לקוחות שלא צורכים נתוני ביטול זקוקים לעדכוני תוכנה, וזה כולל אפליקציות וספריות שמגיעות עם חבילת CA משלהן, ואפליקציות Electron כמו Slack ו-Discord (אתר הגילוי). הדפדפן במחשב מוגן, אבל אפליקציית הצ'אט שרצה לידו, שבנויה על Chromium מוטמע, לא בהכרח.

למה Git ו-curl ב-macOS עדיין סמכו על אישורי אבטחה שנפרצו

הקובץ /etc/ssl/cert.pem

ב-macOS, הכלים curl, git, python3, ruby, perl ו-openssl שמגיעים עם המערכת או עם Xcode Command Line Tools בודקים את הקובץ /etc/ssl/cert.pem. עבור שרשראות שמגיעות לשורשים שבקובץ הזה, הם לא בודקים את החסימה של Apple ולא את נתוני הביטול, ולכן עדיין עלולים לקבל את האישורים עד לעדכון עתידי (Apple Support).

במילים אחרות, ב-macOS יש בפועל שתי חנויות אמון. האחת היא מערכת האמון של Apple, שמקבלת עדכונים שקטים ומכבדת חסימות. השנייה היא קובץ PEM סטטי, שכלים מבוססי OpenSSL/LibreSSL קוראים ישירות. החסימה של Apple פשוט לא מגיעה לשם.

מה כן מוגן אוטומטית

לפי Apple, הרכיבים הבאים מוגנים בלי שום פעולה מצד המשתמש (Apple Support):

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

מי שמשתמש רק ב-Safari וב-Mail לא צריך לעשות דבר. מי שעובד בטרמינל, מריץ סקריפטים, מושך קוד ב-git דרך HTTPS או מתקין חבילות, נמצא בקטגוריה אחרת.

עדכוני מערכת שלא סגרו את הפער

Apple מסרה שעדכון עתידי של macOS יתקן את cert.pem, ושמשתמשים לא יצטרכו לערוך קבצים (Apple Support). מועד לא פורסם (SecurityOnline).

ב-24 באוקטובר דיווח החוקר Ryan Shea ש-/etc/ssl/cert.pem עדיין סמך על אישורים שניתן לזייף ב-macOS 26.7.1 וב-27.0.1. לדבריו, שני העדכונים אף החזירו שורשים שהסיר ידנית, והוא נאלץ להסיר אותם שוב (Ryan Shea). חשוב לציין שמדובר בדיווח של חוקר יחיד ברשת חברתית, וש-Apple טרם הגיבה לו בזמן הפרסום. הנושא עלה גם בשרשור Tell HN ב-Hacker News. כך או כך, התמונה ברורה: יותר משבוע אחרי הדיווח הראשון, כלי שורת הפקודה ב-macOS עדיין היו חשופים.

למה curl | sh הוא התרחיש המסוכן

הדפוס הנפוץ של התקנת כלים בפקודה אחת, כמו curl -fsSL ... | sh, הופך את הפער הזה לבעיה ממשית. אם תוקף נמצא בעמדת רשת ומחזיק באישור מזויף שהלקוח מקבל, הוא יכול להחליף את סקריפט ההתקנה בסקריפט משלו, וזה ירוץ עם ההרשאות של המשתמש, לעיתים עם sudo. אותו היגיון חל על git clone של מאגרים, הורדת בינאריים בסקריפטים של CI, וכל קריאת API שנעשית מ-python3 או מ-ruby של המערכת. תחנות פיתוח הן יעד מועדף בדיוק בגלל הגישה שיש להן למפתחות, לסודות ולמאגרי קוד, נושא שנדון גם במדריך על אבטחת Tailscale SSH וצ'קליסט הקשחה.

לערוך את /etc/ssl/cert.pem? שיקולים

Apple מציינת שמנהלי מערכות יכולים, באופן אופציונלי, להסיר את שורשי ה-CA מהקובץ, אבל מזהירה שזה עלול לשבור אתרים לגיטימיים שמשתמשים באישורי ביניים אחרים, שלא נפגעו, תחת אותם שורשים (Apple Support).

אפשרות

יתרונות

חסרונות

הסרה ידנית של שורשים מ-cert.pem

חוסמת מיד את השרשראות ב-curl, git, python3 וכלים דומים; הפיכה עם גיבוי

עלולה לשבור אתרים לגיטימיים; עדכון macOS עשוי להחזיר את השורשים; Apple ואנשי אבטחה ממליצים לרוב המשתמשים לחכות

המתנה לעדכון של Apple

תיקון רשמי בלי עריכת קבצים; Safari, Mail ואפליקציות מבוססות מסגרות כבר מוגנים

כלי שורת הפקודה נשארים חשופים בלי תאריך; לפי דיווח, 26.7.1 ו-27.0.1 לא תיקנו

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

סוגרת חשיפה בתמונות, ב-CI וב-runtime-ים שמתעלמים מביטול ברמת המערכת

דורשת מלאי של כל חנויות האמון, כולל נסתרות בתלויות

מקורות לטבלה: Apple Support, SecurityOnline, Cycle.io.

מי שבכל זאת בוחר לערוך את הקובץ, למשל בתחנות פיתוח רגישות, צריך לפחות לגבות אותו קודם, ולזכור את הפרט שתואר קודם: הסרת שורש emSign לא חוסמת את מסלול החתימה הצולבת של Sectigo. לכן אחרי כל שינוי חובה לבדוק בפועל מול מארחי הבדיקה (ראו בצ'קליסט בהמשך), ולבדוק שוב אחרי כל עדכון מערכת.

# גיבוי לפני כל שינוי
sudo cp /etc/ssl/cert.pem /etc/ssl/cert.pem.bak.$(date +%Y%m%d)

# שחזור במקרה של תקלה
sudo cp /etc/ssl/cert.pem.bak.YYYYMMDD /etc/ssl/cert.pem

חנויות האמון הנסתרות: קונטיינרים, Electron ו-runtime-ים

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

קונטיינרים וצינורות CI

קונטיינרים אופים את חבילת ה-CA לתוך התמונה בזמן הבנייה. תמונות שנבנו לפני שתמונת הבסיס עודכנה ממשיכות לסמוך על המפתחות שנפרצו. לכן יש לבנות מחדש ולפרוס מחדש תמונות, Runners של CI ותמונות בנייה (Cycle.io).

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

אפליקציות Electron

אפליקציות Electron מגיעות עם Chromium מוטמע, והן לא נהנות אוטומטית מעדכוני הדפדפן במחשב. אתר הגילוי מציין במפורש את Slack ו-Discord כדוגמאות לאפליקציות שזקוקות לעדכון (אתר הגילוי). גרסאות Electron המתוקנות הן 44.9.1, 43.8.1 ו-42.11.16 (BleepingComputer). צוותים שמפתחים אפליקציות Electron פנימיות צריכים לשדרג את התלות ולהפיץ גרסה חדשה בעצמם.

ספריות עם חנות שורשים קפואה

Endor Labs מגדירה ספריות שמגיעות עם חנות שורשים קפואה משלהן כסיכון לא ידוע: הן לא מצהירות על תלות בחבילת אישורים, ולכן הן לא מופיעות ברשימות העדכונים (Endor Labs). סורק תלויות שמחפש certifi או ca-certificates פשוט לא יזהה אותן.

דוגמה קונקרטית: לפי Shea, קובץ ה-lockfile של Codex 0.163.0 נעל את rustls-webpki בגרסה 0.103.15 ואת חבילות השורשים שעדיין יכלו לסמוך על האישורים שנפרצו (Ryan Shea). כלומר, גם כלי פיתוח מודרניים לגמרי, שנבנו בשנים האחרונות, נושאים איתם חנויות אמון שלא מתעדכנות עם מערכת ההפעלה.

גרסאות מתוקנות לפי אקוסיסטם

רכיב

גרסה מתוקנת

Firefox

158.0.1 ועדכוני ESR (20 באוקטובר)

Go

1.27.3 ו-1.26.10 (CVE-2026-111943)

Python certifi

2026.10.19

Rust rustls-webpki

0.103.16

Electron

44.9.1, 43.8.1, 42.11.16

מקור: BleepingComputer. לרכיבים שלא מופיעים בטבלה, כמו Node.js, Java או .NET, יש לבדוק את הודעות האבטחה הרשמיות של כל פרויקט.

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

צ'קליסט: בדיקת חנויות האמון שלכם

הצ'קליסט הבא מיועד למפתחים ולמנהלי מערכות, והוא רלוונטי לכל צוות שעובד עם macOS, Docker, CI מנוהל ו-stack של Go, Python, Rust או Electron. כך עובדים צוותי פיתוח רבים בישראל, בסטארטאפים ובחברות שירותים כאחד, והצ'קליסט חל עליהם כמות שהוא.

1. בדיקה התנהגותית מול מארחי הבדיקה

הדרך האמינה ביותר לדעת אם לקוח עדיין סומך על רשויות הביניים שנפרצו היא לנסות להתחבר. אתר הגילוי מפעיל מארחי בדיקה, למשל dv-g3b-emudhra.we-have-a-problem.com. שגיאת אישור משמעה שהלקוח בטוח (אתר הגילוי).

# שגיאת אישור = טוב. חיבור מוצלח = הלקוח עדיין סומך על השרשרת
curl -sv https://dv-g3b-emudhra.we-have-a-problem.com -o /dev/null

# אותה בדיקה עם git (דרך HTTPS)
git ls-remote https://dv-g3b-emudhra.we-have-a-problem.com 2>&1 | head -n 5

# python3 של המערכת
python3 -c "import urllib.request as u; u.urlopen('https://dv-g3b-emudhra.we-have-a-problem.com')"

כדאי להריץ את הבדיקה על כל לקוח בנפרד, כי לכל אחד עשויה להיות חנות אמון אחרת. בדיקה מוצלחת של curl לא אומרת דבר על python3 עם certifi, ולהפך.

2. בדיקת cert.pem ב-macOS

אפשר לראות אילו שורשים רלוונטיים נמצאים בקובץ:

openssl crl2pkcs7 -nocrl -certfile /etc/ssl/cert.pem \
  | openssl pkcs7 -print_certs -noout \
  | grep -i -E "emSign|AAA Certificate Services"

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

3. בדיקת runtime-ים וספריות

# Python: גרסת certifi ומיקום החבילה
python3 -c "import certifi; print(certifi.__version__, certifi.where())"

# Python: נתיבי האמון של מודול ssl
python3 -c "import ssl; print(ssl.get_default_verify_paths())"

# Go: נדרשת 1.27.3 או 1.26.10 ומעלה
go version

# Rust: איזו גרסה של rustls-webpki נעולה בפרויקט
grep -A1 'name = "rustls-webpki"' Cargo.lock
cargo tree -i rustls-webpki

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

4. איתור חבילות אמון מוטמעות

הסקריפט הבא סורק תיקייה (מאגר קוד, תמונה מחולצת או תיקיית התקנה) ומחפש קבצי PEM שמכילים שורשי emSign:

find . \( -name "*.pem" -o -name "*.crt" \) 2>/dev/null | while read -r f; do
  if openssl crl2pkcs7 -nocrl -certfile "$f" 2>/dev/null \
     | openssl pkcs7 -print_certs -noout 2>/dev/null \
     | grep -qi "emSign"; then
    echo "emSign root found in: $f"
  fi
done

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

5. בנייה מחדש של קונטיינרים ו-CI

# משיכה מפורשת של תמונת הבסיס וביטול Cache
docker build --pull --no-cache -t myapp:patched .

# בדיקה מתוך הקונטיינר (אם curl מותקן בתמונה)
docker run --rm myapp:patched \
  curl -sv https://dv-g3b-emudhra.we-have-a-problem.com -o /dev/null

אחרי הבנייה צריך לפרוס בפועל, ולוודא ש-Runners של CI ותמונות בנייה עודכנו גם הם (Cycle.io).

6. סיכום מהיר של הצ'קליסט

  • להריץ בדיקה התנהגותית מול מארחי הבדיקה בכל לקוח רלוונטי
  • לעדכן את Firefox, Chrome ומערכות ההפעלה (ההגנה הבסיסית)
  • לעדכן אפליקציות Electron, כולל Slack, Discord וכלים פנימיים
  • לשדרג certifi, Go, rustls-webpki ו-Electron לגרסאות המתוקנות
  • לבנות מחדש ולפרוס מחדש תמונות Docker, Runners ותמונות בנייה
  • לסרוק מאגרים ותמונות לאיתור חבילות אמון מוטמעות
  • ב-macOS: להחליט במודע בין המתנה לעדכון לבין עריכת cert.pem, ולבדוק שוב אחרי כל עדכון מערכת

צ'קליסט: ניטור Certificate Transparency

מה Certificate Transparency נותן, ומה לא

Certificate Transparency (CT) הוא מנגנון של יומנים ציבוריים שבהם רשויות אישורים רושמות כל אישור שהן מנפיקות. דפדפנים שאוכפים CT דורשים הוכחה שהאישור נרשם, ולכן אישור שהונפק בסתר לא יתקבל בהם. רוב הדפדפנים אוכפים CT, אבל לקוחות רבים שאינם דפדפנים, כולל curl, לא (אתר הגילוי).

זה הבדל מהותי באירוע הזה. תוקף שמחזיק במפתח ביניים יכול להנפיק אישור בלי לרשום אותו ב-CT. דפדפן מודרני ידחה אותו, אבל curl, git או סקריפט Python יקבלו אותו בשקט, ושום ניטור CT לא יראה אותו לעולם.

בדיקת אכיפת CT בלקוחות שלכם

בין מארחי הבדיקה באתר הגילוי יש שרשראות המסומנות noct, שאישורי העלה שלהן מעולם לא נרשמו ב-CT. חיבור מוצלח אליהן מעיד שהלקוח גם סומך על רשויות הביניים וגם לא אוכף CT (אתר הגילוי).

# החליפו בשם מארח noct מתוך רשימת המארחים באתר הגילוי
curl -sv https://<noct-host-from-disclosure-site> -o /dev/null

ניטור הדומיינים שלכם ביומני CT

גם אם CT לא מגן על curl, ניטור יומני CT הוא עדיין שכבת הגנה חשובה עבור הדומיינים שלכם. הוא מאפשר לזהות אישורים שהונפקו לדומיין שלכם על ידי רשות שאתם לא עובדים איתה, לפחות כשהתוקף מכוון לדפדפנים ולכן חייב לרשום את האישור. כלים ציבוריים כמו crt.sh מאפשרים שאילתה פשוטה:

# רשימת המנפיקים של אישורים שנרשמו עבור הדומיין
curl -s "https://crt.sh/?q=example.co.il&output=json" \
  | jq -r '.[] | [.not_before, .issuer_name, .name_value] | @tsv' \
  | sort -u | tail -n 20

פרקטיקות מומלצות לניטור:

  • להגדיר התראה על כל אישור חדש לדומיינים ולתת-דומיינים של הארגון
  • לנהל רשימה של רשויות האישורים שהארגון משתמש בהן בפועל, ולהתריע על כל מנפיק אחר
  • לכלול בניטור דומיינים פנימיים שנחשפים לאינטרנט, כמו סביבות Staging ו-API
  • לבדוק תקופתית שהבקרות האלה פועלות, ולא רק שהוגדרו

כדאי לזכור גם את המגבלה של רשומות CAA: הן מורות לרשויות אישורים אילו מהן רשאיות להנפיק לדומיין, אבל תוקף שמחזיק במפתח ביניים גנוב לא עובר דרך תהליך ההנפקה של הרשות ולכן לא מכבד אותן. CAA ו-CT הם שכבות חשובות, אבל אף אחת מהן לא מחליפה עדכון של חנויות האמון.

איך להגיב לאירוע ה-CA הבא

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

מיפוי שכבות האמון מראש

הטבלה הבאה מסכמת את שכבות האמון הטיפוסיות ואת אופן התגובה לכל אחת, על בסיס האירוע הנוכחי:

שכבה

דוגמאות

איך מגיעה ההגנה

פעולה נדרשת

דפדפנים

Firefox, Chrome

ערוצי ביטול (OneCRL, CRLite, CRLSets)

לוודא שהדפדפן מעודכן

מסגרות מערכת ההפעלה

Safari, Mail, אפליקציות מבוססות מסגרות Apple

עדכוני תצורה

בדרך כלל אין

כלי שורת פקודה של המערכת

curl, git, python3 ב-macOS

עדכון מערכת עתידי

לבדוק, להחליט על מיטיגציה

runtime-ים עם חבילה משלהם

certifi, Go, rustls-webpki

עדכון גרסה

לשדרג, לבנות ולפרוס מחדש

אפליקציות עם Chromium מוטמע

Electron, Slack, Discord

עדכון אפליקציה

לעדכן ולהפיץ

קונטיינרים ו-CI

תמונות Docker, Runners

בנייה מחדש

לבנות ולפרוס מחדש

חנויות קפואות בתלויות

ספריות עם שורשים מקומפלים

עדכון מהספק

לאתר ולעקוב

מקורות לטבלה: אתר הגילוי, Apple Support, Cycle.io, Endor Labs.

Playbook מעשי

  1. מלאי חנויות אמון: לתעד אילו רכיבים בארגון מגיעים עם חבילת CA משלהם, כולל בתוך תלויות. להוסיף את זה ל-SBOM אם קיים.
  2. בדיקה התנהגותית אוטומטית: להחזיק סקריפט שרץ ב-CI ובודק שכל לקוח מרכזי דוחה שרשרת שידועה כחסומה. כשמתפרסם אירוע חדש, מחליפים רק את כתובת הבדיקה.
  3. בנייה מחדש תקופתית: תמונות שנבנות מחדש באופן קבוע, גם בלי שינוי קוד, מקצרות דרמטית את זמן התגובה.
  4. מקורות מידע: לעקוב אחרי הודעות של תוכניות השורש, יצרני מערכות ההפעלה ומתחזקי הספריות שבשימוש.
  5. החלטות מיטיגציה מתועדות: אם מחליטים לערוך חנות אמון ידנית, לתעד מה שונה, איפה ולמה, ולבדוק שוב אחרי כל עדכון, כי כפי שדווח, עדכונים עלולים לבטל שינויים ידניים (Ryan Shea).
  6. סגירה: האירוע נגמר כשהבדיקה ההתנהגותית נכשלת בכל הלקוחות, לא כשהדפדפנים עודכנו.

אותו עיקרון של תגובה מהירה ושיטתית מופיע גם בחולשות אחרות, כפי שמתואר במדריך על חולשת http2shell ב-Node.js וב-Python: העדכון הראשון קל, הזנב הארוך של רכיבים שנשכחו הוא הקשה.

שאלות נפוצות

האם צריך לעשות משהו אם משתמשים רק ב-Safari וב-Mail ב-Mac?

לא. לפי Apple, האפליקציות האלה חוסמות את האישורים באופן אוטומטי באמצעות עדכוני נתוני תצורה, בלי צורך בעדכון מערכת (Apple Support).

איך בודקים אם לקוח מסוים עדיין סומך על רשויות ה-CA שנפרצו?

מריצים curl (או הלקוח הרלוונטי) מול מארחי הבדיקה באתר הגילוי, למשל dv-g3b-emudhra.we-have-a-problem.com. שגיאת אישור משמעה שהלקוח בטוח. כדאי לבדוק גם את מארחי ה-noct כדי לדעת אם הלקוח אוכף Certificate Transparency (אתר הגילוי).

למה Git ב-macOS עדיין סומך על האישורים אם Apple חסמה אותם?

החסימה של Apple חלה על המסגרות שלה. Git ו-curl קוראים את /etc/ssl/cert.pem, שעוקף את החסימה הזו ואת בדיקות הביטול (Apple Support).

האם עדכון מערכת ההפעלה או הדפדפן מספיק?

לא תמיד. אפליקציות Electron, ספריות עם חבילות CA מוטמעות ותמונות קונטיינר צריכות עדכונים או בנייה מחדש משלהן (אתר הגילוי, Cycle.io).

אילו כלים ב-macOS מושפעים?

curl, git, python3, ruby, perl ו-openssl שמגיעים עם macOS או עם Xcode Command Line Tools (Apple Support).

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

אין ראיות לכך. eMudhra לא מצאה עדות להנפקה למשתמשי קצה ומסרה שרוב רשויות הביניים לא היו בשימוש, אבל שימוש לרעה מאז אפריל 2025 אפשרי תיאורטית (BleepingComputer).

סיכום

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

הדפדפנים ומסגרות מערכות ההפעלה הוגנו תוך ימים בזכות ערוצי ביטול אישורים ועדכוני תצורה. אבל כל מה שקורא חבילת CA סטטית, מ-git ו-curl ב-macOS דרך תמונות Docker ועד אפליקציות Electron וספריות עם שורשים מקומפלים, נשאר חשוף עד שמישהו עדכן אותו במפורש. Certificate Transparency לא סוגר את הפער הזה, כי לקוחות כמו curl לא אוכפים אותו.

המסקנה המעשית: אבטחת TLS בארגון תלויה בחנות האמון החלשה ביותר שבו. בדיקה התנהגותית מול מארחי הבדיקה, מלאי של חנויות אמון, בנייה מחדש של תמונות ועדכון runtime-ים לגרסאות המתוקנות הם הצעדים שסוגרים את האירוע הנוכחי, ומכינים את הקרקע לאירוע ה-CA הבא.

מקורות

וואטסאפ