Security
MD5, RSA, Certificate
פונקציות גיבוב כמו MD5, הצפנת RSA, תעודות דיגיטליות, רשויות מאשרות ושרשרת אמון.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
MD5, RSA, Certificate: גיבוב, הצפנה אסימטרית ותעודות דיגיטליות
תקשורת מאובטחת ברשת נשענת על שלושה יסודות משלימים: פונקציות גיבוב כמו MD5 ו-SHA-256, הצפנה אסימטרית באמצעות RSA, ותעודות דיגיטליות שמאמתות זהות מול רשות מאשרת. בפרק הזה נכיר כל אחד מהמנגנונים מהבסיס ונראה כיצד הם מתחברים יחד בהגנה על נתונים, סיסמאות וחיבורי HTTPS.
- גיבוב ו-MD5: מדוע גיבוב אינו הצפנה, מהם אורך הפלט ואפקט המפולת, למה MD5 נפסל לחתימות ולתעודות בעקבות התנגשויות, ומתי הוא עדיין מתאים.
- סיסמאות ו-Salt: למה מהירות החישוב של MD5 מסכנת מאגרי סיסמאות, מה Salt פותר ומה לא, ואילו פונקציות איטיות מחליפות אותו.
- RSA במפתח ציבורי: זוג המפתחות והבעיה המתמטית מאחוריהם, ההבדל בין הצפנה לסודיות לבין חתימה דיגיטלית, הצפנה היברידית, אורך מפתח וריווח.
- תעודות דיגיטליות ורשויות מאשרות (CA): תוכן התעודה, שרשרת האמון, חמש הבדיקות של הדפדפן, תעודה חתומה עצמית, ביטול תעודות והגנה על המפתח הפרטי.
השאלות בנושאים האלה בודקות בעיקר הבחנה מדויקת בין מושגים דומים: איזה מפתח מתאים להצפנה ואיזה לחתימה, למה גיבוב בלי סוד לא עוצר תוקף בתווך, ומה בדיוק מונע כל מנגנון הגנה.
hashlib ו-hmac) ובמעטפת Linux, והפלט המוצג הוא מה שהתקבל.גיבוב ו-MD5
מהי פונקציית גיבוב
דמיינו טביעת אצבע דיגיטלית של מסמך: פונקציית גיבוב (Hash function) לוקחת קלט בכל גודל, ממילה בודדת ועד קובץ התקנה של כמה גיגה-בייט, ומפיקה ממנו מחרוזת קצרה באורך קבוע. לתוצאה הזו קוראים גיבוב, תקציר או Digest.
כל פונקציית גיבוב קריפטוגרפית מתאפיינת בארבע תכונות יסוד:
- דטרמיניסטית: קלט זהה יניב תמיד את אותו תקציר בדיוק, בכל מערכת הפעלה ובכל זמן.
- אורך פלט קבוע: גודל התוצאה קבוע מראש ואינו מושפע מאורך הקלט.
- חד-כיוונית: חישוב התקציר מהקלט מהיר ופשוט, אך אין דרך מעשית לשחזר את הקלט מתוך התקציר.
- ללא מפתח סודי: האלגוריתם גלוי לכול, וכל אדם יכול להריץ אותו על כל קלט.
נניח שחבר מראה לכם מחרוזת של 32 תווים ושואל איך "פותחים" אותה כדי לראות את הקובץ. השאלה מבולבלת מהיסוד: פותחים רק מה שננעל במפתח, וגיבוב לא נועל דבר.
הצפנה היא הפיכה עבור מי שמחזיק במפתח, ולכן הפלט שלה גדל עם הקלט וכולל את כל המידע. גיבוב, לעומת זאת, זורק מידע בכוונה ושומר רק טביעה קצרה; אין לו פעולת פענוח, והביטוי "לפענח MD5" מתאר משהו שאינו קיים.
בגלל זה גם אין טעם לראות בתקציר גרסה מכווצת של הקובץ, כמו ZIP שאפשר לפרוס בחזרה. התקציר נשלח לצד הנתונים כדי לבדוק אותם, ולא במקומם.
| מאפיין | פונקציית גיבוב | הצפנה |
|---|---|---|
| מפתח סודי | אין מפתח, פונקציה ציבורית | יש מפתח (סימטרי או זוג מפתחות) |
| שחזור הקלט המקורי | בלתי אפשרי מעשית (חד-כיווני) | אפשרי באמצעות המפתח המתאים |
| גודל הפלט | קבוע לכל קלט | גדל בהתאם לגודל הקלט |
| שימוש עיקרי | בדיקת תקינות, השוואת נתונים, חתימות וסיסמאות | שמירה על סודיות המידע |
טעויות נפוצות
- גיבוב MD5 מצפין את המידע בצורה קומפקטית. הצפנה מבוססת על מפתח ומאפשרת פענוח. גיבוב הוא פעולה חד-כיוונית ללא מפתח.
- אפשר להפוך את ערך הגיבוב בחזרה לקלט המקורי בעזרת האלגוריתם ההפוך. אין אלגוריתם הפוך; פונקציית גיבוב מתוכננת כך שחזרה מהפלט אל הקלט אינה מעשית.
- פונקציית גיבוב מוסיפה אקראיות, ולכן אותו קלט נותן תוצאה שונה בכל הרצה. גיבוב הוא דטרמיניסטי לחלוטין; בלי דטרמיניסטיות אי אפשר היה להשוות תקצירים.
- הגיבוב דוחס קבצים גדולים ל-128 ביט כדי לחסוך מקום בדיסק. מדובר בטביעת אצבע לבדיקה ולא בדחיסה; לא ניתן לשחזר את הקובץ מהתקציר.
בדקו את עצמכם
שני שרתים, האחד בלונדון והשני בתל אביב, מריצים MD5 על אותו קובץ קונפיגורציה בדיוק. האם התקצירים יהיו זהים?
כן. גיבוב הוא דטרמיניסטי ואינו תלוי במפתח או בבחירה אקראית.
מדוע ידיעת שם האלגוריתם (למשל MD5) אינה מאפשרת לפענח את התקציר?
משום שהאלגוריתם חד-כיווני ואינו משתמש במפתח פענוח; מידע אבד בדרך ואין פעולה הפוכה.
MD5: אורך הפלט ואפקט המפולת
את MD5 פיתח רון ריבסט בשנת 1991. הפונקציה מפיקה תמיד תקציר באורך של 128 סיביות, שהן 16 בתים.
בהצגה טקסטואלית נהוג לכתוב את התקציר בבסיס הקסדצימלי (בסיס 16). מאחר שכל תו הקסדצימלי מייצג 4 סיביות (חצי בית), תקציר MD5 נכתב תמיד כרצף של 32 תווים הקסדצימליים (128 חלקי 4, או 16 בתים כפול 2).
| אלגוריתם | אורך בסיביות | אורך בבתים | ספרות הקסדצימליות |
|---|---|---|---|
| MD5 | 128 | 16 | 32 |
| SHA-1 | 160 | 20 | 40 |
| SHA-256 | 256 | 32 | 64 |
תכונה נוספת היא אפקט המפולת (Avalanche effect, ובעברית גם אפקט הסחף): שינוי זעיר בקלט, כמו אות שהפכה מקטנה לגדולה או ביט שהתהפך, משנה כמעט את כל התקציר. בדרך כלל כמחצית מהסיביות מתהפכות, ולכן התוצאה נראית כמחרוזת חדשה.
השינוי אינו מקומי, כך שאי אפשר להשוות שני תקצירים ולנחש באיזה מקום בקלט תוקן תו. גם קלט ריק לגמרי מפיק תקציר מלא של 32 תווים, והקוד הבא מראה זאת וסופר כמה סיביות השתנו:
import hashlib
for text in ["ledger-07", "ledger-08", "Ledger-07", ""]:
h = hashlib.md5(text.encode()).hexdigest()
print(f"{text!r:11} {h} len={len(h)}")
a = hashlib.md5(b"ledger-07").digest()
b = hashlib.md5(b"ledger-08").digest()
diff = sum(bin(x ^ y).count("1") for x, y in zip(a, b))
print("bits that differ out of 128:", diff)'ledger-07' 4723eecbb247f22fae1c7c6ea526ff55 len=32
'ledger-08' b84f120df1fd7a555f30bcfd0c99e9a2 len=32
'Ledger-07' c2f3f96a21e67e3b1981c6680c8dba55 len=32
'' d41d8cd98f00b204e9800998ecf8427e len=32
bits that differ out of 128: 72תרחיש 1: האם מחרוזת של 40 תווים יכולה להיות MD5
בעמוד הורדה כתוב "MD5" ולידו מחרוזת הקסדצימלית בת 40 תווים. נבדוק את הטענה בספירה: 40 תווים כפול 4 סיביות הם 160 סיביות, כלומר 20 בתים.
תקציר MD5 הוא תמיד 128 סיביות, 16 בתים, 32 תווים, ולכן הערך המוצג אינו MD5. האורך מתאים ל-SHA-1, והתווית בעמוד שגויה או מטעה.
טעויות נפוצות
- תקציר MD5 מורכב מרצף של 128 תווים הקסדצימליים. 128 הוא אורך הפלט בסיביות. בחלוקה ל-4 סיביות לתו מתקבלים 32 תווים בלבד.
- מחרוזת MD5 מכילה 16 תווים הקסדצימליים. 16 הוא מספר הבתים, וכל בית נכתב בשתי ספרות הקסדצימליות, כלומר 32 תווים.
- שינוי של אות אחת בקלט משנה רק תו אחד או שניים בתקציר. אפקט המפולת מערבב את כל הסיביות, כך שהתקציר משתנה כמעט לחלוטין.
- קלט ארוך יותר מוסיף תווים לתקציר כדי לייצג את המידע הנוסף. אורך התקציר קבוע תמיד על 128 סיביות, אפילו עבור קובץ של עשרות גיגה-בייט.
בדקו את עצמכם
כמה ספרות הקסדצימליות יהיו בפלט של פונקציית גיבוב באורך 160 סיביות?
40 ספרות, משום שכל ספרה מייצגת 4 סיביות (160 חלקי 4 שווה 40).
בקובץ תמונה בנפח 2 GB התהפך ביט בודד. מה יקרה לאורך תקציר ה-MD5 שלו ולערכו?
האורך יישאר קבוע (128 סיביות / 32 תווי הקס), אך הערך עצמו ישתנה כמעט לגמרי.
התנגשות: למה MD5 שבור
דמיינו אינסוף קלטים אפשריים שנדחסים לכמות סופית של תקצירים (ב-MD5, 2 בחזקת 128 ערכים): בהכרח יש קלטים שונים שנוחתים על אותו ערך. מצב כזה נקרא התנגשות (Hash collision), והוא קיים בכל פונקציית גיבוב.
מכאן שאורך של 128 סיביות לא מבטיח היעדר התנגשויות. ההבדל בין פונקציה טובה לרעה הוא אם אפשר למצוא זוג כזה בפועל: בפונקציה חזקה אין שיטה מעשית, ו-MD5 כבר אינו כזה.
מאז 2004 חוקרים מייצרים התנגשויות ב-MD5 במהירות ובפועל. לכן הצהרה ש"MD5 שבור" פירושה שנפגעה תכונת העמידות להתנגשויות (Collision resistance).
כדי להבין מה בדיוק קרס, הציבו זה לצד זה שני אתגרים. באתגר הראשון נמסר לכם תקציר, ועליכם לבנות קלט כלשהו שמניב אותו, וזה נקרא Preimage. באתגר השני אתם בוחרים בעצמכם זוג קלטים שנוחתים על אותו ערך, וזו התנגשות.
רק האתגר השני נפל ב-MD5. הפונקציה עדיין חד-כיוונית בפועל, ולכן הבעיה אינה שהפלט קצר מדי ואפשר לנחש ממנו את הקלט, וגם לא מפתח שדלף, כי אין מפתח.
חמורה עוד יותר היא התקפת התנגשות עם קידומת נבחרת (Chosen-prefix collision). התוקף בוחר שני מסמכים שונים בעלי משמעות שונה, כמו חוזה תמים ומסמך זדוני, ומוסיף לכל אחד מהם רצף בתים מחושב עד ששניהם מקבלים אותו MD5 בדיוק.
שתי פרשות מראות שזה לא רק רעיון תיאורטי. בשנת 2008 חוקרים הציגו תעודה מזויפת של רשות מאשרת, שנולדה מכך שרשות שעדיין חתמה ב-MD5 אישרה תעודה תמימה שחולקת תקציר עם התעודה המסוכנת. ב-2012 נוזקת Flame נעזרה באותו עיקרון כדי להשיג תעודה מזויפת של Microsoft שאיפשרה לה לחתום על קוד זדוני.
הכלל המעשי: מול יריב אין להשתמש ב-MD5 לחתימות, לתעודות או לכל מנגנון הגנה אחר.
תרחיש 2: שתי תוכנות באתר היצרן עם אותו MD5
אתר של יצרן מפרט שתי גרסאות של תוכנת התקנה, שגודלן זהה בדיוק ובשתיהן מופיע אותו ערך MD5. לקוח מסיק מכך שמדובר בקובץ אחד שהועלה פעמיים.
השאלה מה הצוות צריך לבדוק עכשיו מראה למה ה-MD5 לבדו לא מספיק. מכיוון שאפשר לבנות בכוונה שני קבצים שונים עם אותו ערך, ההתאמה מעידה רק שאין סתירה, ולא שהתכנים שווים.
הצעד הבא הוא השוואת בתים ישירה, או חישוב SHA-256 לכל אחד מהם: אם יתקבלו שני ערכים שונים, הקבצים שונים. ואם מישהו תוהה מדוע הערך חוזר, התשובה אינה מקריות, תקלה או חתימה דיגיטלית; כל פונקציה דטרמיניסטית שנתקלה בשני תכנים מתנגשים מחזירה בהכרח אותו פלט.
טעויות נפוצות
- לכל קלט יש תקציר MD5 ייחודי שאין לו מקבילה. מרחב הקלטים אינסופי ומרחב הפלטים סופי, ולכן בהכרח קיימות אינסוף התנגשויות.
- MD5 נחשב שבור כי אפשר לשחזר ממנו את הטקסט המקורי. החולשה שנשברה היא עמידות להתנגשויות; מציאת Preimage עדיין אינה מעשית.
- התנגשות היא תקלת אחסון שבה שני קבצים נכתבים לאותו מקום בדיסק. זו תכונה מתמטית של הפונקציה ולא של האחסון: שני קלטים שונים מניבים תקציר זהה.
בדקו את עצמכם
חוקר מצליח להפיק שני מסמכים שונים, שבחר בעצמו, בעלי MD5 זהה. איזו חולשה הדגים, ומה עדיין לא הצליח לעשות?
הוא הדגים התנגשות. עדיין אין דרך מעשית לקחת תקציר נתון ולמצוא קלט שמניב אותו (Preimage).
סטודנט טוען ש-MD5 שבור כי התקציר קצר, וכך אפשר לנחש את הקלט. מה שגוי בטענה?
החולשה שנחשפה היא בהתנגשויות. האורך אינו הבעיה, ושחזור קלט מתוך תקציר נתון עדיין אינו מעשי.
SHA-256 ו-SHA-1 לעומת MD5
כשמחפשים תחליף ל-MD5, פונים בדרך כלל אל SHA-256, חברה במשפחת SHA-2. הפלט שלה מונה 256 סיביות, כלומר 64 תווי הקס, והעיקר: לא ידועה דרך מעשית ליצור בה התנגשות. משום כך משתמשים בה היום לחתימות ולבדיקות שלמות, וגם משפחת SHA-3 נחשבת תקפה.
בהשוואה ל-MD5, SHA-256 דומה בכך שגם היא פונקציה פומבית ללא מפתח סודי, ואינה הצפנה סימטרית. היא אינה קצרה יותר: הפלט שלה ארוך פי שניים. הפרשי המהירות בין השתיים קטנים ותלויים במעבד, ולכן אינם הסיבה למעבר; היתרון שמצדיק אותו הוא עמידות להתנגשויות.
SHA-1 מפיקה 160 סיביות (40 תווי הקס) ושלטה בעבר בתעודות הרשת. לאחר שנמצאו דרכים מעשיות לייצר בה התנגשויות בעלות סבירה, דפדפנים ורשויות מאשרות פסלו תעודות חתומות ב-SHA-1 ועברו ל-SHA-256.
נימוק הפסילה של SHA-1 הוא התנגשות שהודגמה בפועל, ולא גילה של האלגוריתם. החולשה אינה בשחזור קלט (Preimage), וכמו ב-MD5 אין כאן סוד שדלף, כי אין מפתח.
תרחיש 3: הוכחת קדימות של המצאה בשירות חותמות זמן
מפתחת מפקידה בשירות חותמות זמן את התקציר של תיאור ההמצאה שלה, והשירות מחתים אותו בתאריך ובשעה. חודשים אחר כך היא תצטרך להראות שהתיאור המדויק הזה כבר היה בידיה אז.
אם השירות מבוסס MD5, מתחרה שהכין מראש שני תיאורים שונים בעלי תקציר זהה יכול להפקיד את התמים, ובמחלוקת להציג את השני ולטעון שהחותמת שלו. השאלה שהחותמת אמורה לפתור, מה בדיוק היה קיים ומתי, נשארת בלי מענה.
עם SHA-256 לא ידועה כיום שום דרך מעשית לבנות זוג כזה, ולכן החותמת נשארת ראיה אמינה. הנימוק הוא עמידות להתנגשויות, ולא אורך הפלט ולא יכולת שחזור.
טעויות נפוצות
- SHA-256 עדיפה כי היא מפיקה תקציר קצר ומהיר יותר. הפלט של SHA-256 כפול באורכו (256 סיביות מול 128), והפרשי המהירות קטנים ותלויי מעבד. היתרון שלה הוא עמידות להתנגשויות.
- SHA-256 היא הצפנה סימטרית עם מפתח סודי. SHA-256 היא פונקציית גיבוב ללא מפתח, בדיוק כמו MD5.
- SHA-1 נפסלה רק מפני שהיא ותיקה, או מפני שאפשר לשחזר ממנה את הקלט. היא נפסלה בגלל התנגשויות מעשיות שהודגמו בה, ולא בגלל שחזור קלט.
בדקו את עצמכם
רשות מאשרת מחליטה להפסיק לחתום בשני האלגוריתמים, MD5 ו-SHA-1, למרות שאיש לא הצליח לשחזר מהם קלט. מה הנימוק, ומדוע לא די לומר שהם ישנים?
בשניהם הודגמו התנגשויות מעשיות, ולכן חתימה על תקציר של תעודה אחת תתאים גם לתעודה אחרת שחולקת אותו. גיל לבדו אינו סיבה: הפסילה נובעת מחולשה שהוכחה.
מתי MD5 עדיין מקובל: בדיקת תקינות
MD5 לא נזרק לגמרי. כשאין יריב אלא רק רעש, כמו חבילה שנפגמה, סקטור פגום או העתקה שנקטעה, טביעת אצבע מהירה מספיקה, ולכן נהוג לקרוא לשימוש הזה בדיקת תקינות (Checksum).
printf 'backup-set-2026-03\nrows=48210\n' > published.dat
cp published.dat received.dat
sed -i 's/rows=48210/rows=48211/' received.dat # one character flipped in transit
wc -c published.dat received.dat | head -2
md5sum published.dat received.dat30 published.dat
30 received.dat
334031ec9e19dcd3a12c27a54bcf77b1 published.dat
bff22932b176e94ee3b60ea9b2a8244e received.datבמצב אמיתי, המפרסם מחשב את הערך על הקובץ המקורי ומציג אותו ליד הקישור, והמוריד מחשב אותו על העותק שנחת אצלו. כל הבדל בין שני הערכים מעיד שמשהו השתנה, גם אם גודל הקובץ נשאר בדיוק כפי שהיה, כמו בפלט למעלה.
התקציר מתריע בלבד: הוא אינו מתקן בתים פגומים ואינו מזרז הורדה. תפקיד נוסף שלו הוא איתור קבצים כפולים באחסון (Deduplication), כי חישובו זול.
מדוע לא להשוות גודל או תאריך? תקלה אופיינית מחליפה ערכי סיביות בלי לשנות את האורך, ותאריך יצירה אינו אומר דבר על התוכן. מי שבונה בדיקה חדשה היום יבחר ב-SHA-256 גם למטרה תמימה כזו.
| תרחיש שימוש | האם MD5 מתאים? | הסיבה |
|---|---|---|
| בדיקת שגיאות אקראיות בהורדה או בהעתקה | כן (אך SHA-256 עדיף) | אין תוקף מכוון, רק רעש או תקלה מקרית |
| איתור קבצים כפולים באחסון | כן | חישוב מהיר ללא איום זדוני |
| חתימה דיגיטלית על חוזה או עדכון | לא | התנגשויות מאפשרות זיוף מסמך |
| חתימת CA על תעודת אתר | לא | תוקף עלול לזייף תעודה תקפה |
| שמירת סיסמאות במסד נתונים | לא | חישוב מהיר מדי שמקל על ניחוש המוני |
טעויות נפוצות
- אם הורדתי קובץ וגודלו זהה לגודל שכתוב באתר, הוא בוודאות תקין. תקלה שמחליפה ערך של ביט אינה משנה את אורך הקובץ בבתים.
- MD5 מתקן שגיאות העברה בקובץ פגום. פונקציית גיבוב היא כלי גילוי בלבד ואינה כוללת מידע לתיקון שגיאות.
בדקו את עצמכם
הורדתם קובץ ISO וזיהיתם שה-MD5 שלו שונה מזה שפורסם באתר. מה המשמעות?
הקובץ שבידכם שונה מהקובץ המקורי, גם אם רק ביט אחד נפגם בדרך, ואין להשתמש בו.
מתווך פעיל, הרחבת הודעה והפתרון עם HMAC
שליחת נתונים לצד תקציר MD5 בערוץ לא מאובטח אינה עוצרת תוקף פעיל. תוקף אדם בתווך (MITM) יושב בין השולח למקבל, מחליף את הנתונים, מחשב בעצמו תקציר חדש לנתונים המזויפים ושולח את החבילה.
מבחינת המקבל הכול נראה תקין: הערך שחישב זהה לזה שהגיע, ואין סימן לזיוף. הסיבה אינה התנגשות ב-MD5, ולכן גם SHA-256 הייתה נכשלת באותו אופן; כל מי שמשנה את הנתונים יכול לחשב לגיבוב פשוט ערך חדש, כי אין בו מפתח סודי.
כדי להגן על שלמות מול יריב צריך להכניס סוד לתמונה. אפשר להשתמש בחתימה דיגיטלית, שרק בעל המפתח הפרטי מסוגל ליצור, או ב-MAC: קוד אימות שנשען על מפתח סודי המשותף לשני הצדדים, שמימושו התקני הוא HMAC.
פיתוי נפוץ הוא לחבר סוד לפני ההודעה, כך: hash(secret + message). מבנה כזה חשוף להתקפת Length Extension.
דמיינו מכונה שקוראת את ההודעה קטע אחר קטע ובכל קטע מעדכנת מונה פנימי. התקציר שמודפס בסוף הוא פשוט מצב המונה אחרי הקטע האחרון, בלי שום עיבוד נוסף.
מי שרואה את התקציר מקבל בעצם את המונה הזה, ואם הוא יודע גם כמה ארוך הסוד, הוא יכול לטעון את המצב, להוסיף עוד קטעים ולהפיק תקציר תקף להודעה הארוכה יותר. הוא אינו צריך את הסוד עצמו, ואינו משנה אף תו בהודעה המקורית.
זו אינה התנגשות: לא נוצרו שני קלטים עם אותו תקציר, אלא הודעה חדשה שהתקציר שלה חושב כראוי. החולשה נובעת ממבנה הבלוקים, ולכן היא קיימת ב-MD5, ב-SHA-1 וגם ב-SHA-256.
ה-HMAC (בדרך כלל HMAC-SHA256) מערב את המפתח בשני מעברי גיבוב מקוננים, כך שהתקציר הסופי אינו מצב שאפשר להמשיך ממנו. הקוד הבא מחשב תגי HMAC לשתי הודעות קרובות:
import hashlib, hmac
key = b"billing-team-key"
orders = [b"invoice=4410&total=250", b"invoice=4410&total=2500"]
for m in orders:
tag = hmac.new(key, m, hashlib.sha256).hexdigest()
print(m.decode(), "->", tag[:24] + "...")
wrong = hmac.new(b"guessed-key", orders[0], hashlib.sha256).hexdigest()
real = hmac.new(key, orders[0], hashlib.sha256).hexdigest()
print("same tag without the key:", hmac.compare_digest(wrong, real))invoice=4410&total=250 -> 1e050f9c50359b1715378285...
invoice=4410&total=2500 -> 922eaa9b61d480ed8f68b6f4...
same tag without the key: Falseהתג משתנה כשההודעה משתנה, וניחוש מפתח שגוי מניב תג אחר. מי שאינו מחזיק במפתח אינו יכול לחשב תג תקף, וזו בדיוק היכולת שחסרה בגיבוב פשוט.
תרחיש 4: סקריפט הגדרות וקובץ MD5 באותה תיקייה ציבורית
מנהל רשת מוריד סקריפט הגדרות דרך חיבור לא מוצפן, ומשווה אותו לקובץ md5 שמפורסם באותה תיקייה. תוקף בתווך מחליף את שני הקבצים: סקריפט זדוני וערך MD5 שחישב לו.
ההשוואה עוברת והסקריפט רץ. התוקף לא ניחש מפתח, לא יצר התנגשות, וגם לא החליף מפתח ציבורי של שרת.
כשתוקף מציג לקורבן מפתח ציבורי משלו במקום מפתח השרת, זו מתקפה שונה: היא מכוונת לערוץ מוצפן ודורשת שהקורבן יקבל מפתח של התוקף במקום זה של השרת. כאן אין הצפנה כלל, ולכן אין מה להחליף: מספיק לשנות את הקבצים ולחשב ערך מחדש.
ההגנה היא חתימה של היצרן על הסקריפט, שהמנהל מאמת במפתח הציבורי של היצרן שהגיע אליו בדרך אמינה.
טעויות נפוצות
- בהתקפת Length Extension התוקף חושף קודם את ה-secret ואז מחשב גיבוב חדש. התוקף ממשיך מהמצב הפנימי המגולם בתקציר הקיים, בלי לדעת את תוכן ה-secret כלל.
- Length Extension היא פשוט יצירת התנגשות בין שני קבצים. זו תוספת נתונים בסוף הודעה קיימת יחד עם חישוב המשך, לא מציאת התנגשות.
- כדי לתקן
MD5(secret + message)מספיק להחליף את MD5 ב-SHA-256. גם SHA-256 בנוי מבלוקים וחשוף ל-Length Extension; הפתרון הנכון הוא HMAC.
בדקו את עצמכם
מדוע גיבוב SHA-256 רגיל ליד הודעה אינו מונע מתוקף בתווך לזייף אותה?
כי לכל גיבוב בלי מפתח סודי כל אחד יכול לחשב מחדש ערך תקין עבור ההודעה המזויפת.
סיסמאות ו-MD5
מה פירוש "לפצח" גיבוב של סיסמה
מערכות אמינות אינן שומרות סיסמאות כטקסט גלוי. בעת ההרשמה נשמר תקציר הסיסמה, ובכל התחברות המערכת מחשבת את התקציר של הקלט ומשווה לשמור, בזכות הדטרמיניסטיות של הגיבוב.
כאשר מאגר תקצירי MD5 נגנב, התוקף אינו "מפענח" או "הופך" את הגיבובים. במקום זאת הוא מבצע ניחושים במחשב שלו: בוחר מועמדות מרשימת סיסמאות נפוצות (התקפת מילון) או סורק צירופים (כוח גס), מחשב לכל מועמדת את ה-MD5 ומשווה למאגר הגנוב.
כדי לקצר תהליכים מול גיבובים ללא Salt, תוקפים נעזרים גם בטבלאות מחושבות מראש (Rainbow tables): מאגרים ענקיים של סיסמאות נפוצות והתקצירים שלהן שהוכנו מראש, כך שמציאת הסיסמה הופכת לחיפוש מיידי.
החיסרון הקריטי של MD5 בשמירת סיסמאות הוא מהירות החישוב הגבוהה שלו. כרטיסי מסך מודרניים (GPU) מחשבים מיליארדי תקצירי MD5 בשנייה, ולכן סיסמאות חלשות ובינוניות מתגלות במהירות עצומה.
שימו לב להיפוך התפקידים: המהירות שהופכת את MD5 לנוח בבדיקת קבצים היא בדיוק הסיבה שהוא מסוכן לסיסמאות. הבעיה כאן אינה התנגשויות אלא קצב הניחושים האפשרי.
טעויות נפוצות
- MD5 אינו מתאים לסיסמאות כי הוא איטי ומכביד על שרתי ההזדהות. להפך: הבעיה היא שהוא מהיר מדי, מה שמאפשר לתוקף לבדוק מיליארדי ניחושים בשנייה.
- גניבת המפתח של MD5 מאפשרת לפענח את כל הסיסמאות בבת אחת. ל-MD5 אין מפתח ואין פענוח; התוקף מגלה סיסמאות רק באמצעות ניחוש והשוואה.
- אימות סיסמה מול MD5 מחייב תקשורת רשת לשרת מרכזי של האלגוריתם. חישוב התקציר מתבצע מקומית לחלוטין על המחשב או השרת שמבצע את הבדיקה.
בדקו את עצמכם
תוקף גנב קובץ גיבובי MD5 ושחזר תוך דקה את הסיסמה של מנהל המערכת. איזו פעולה ביצע בפועל?
הוא גיבב סיסמאות מועמדות והשווה לתקציר הגנוב (או חיפש בטבלה מחושבת מראש), ולא פענח את הגיבוב.
Salt: מה הוא עושה ומה לא
Salt (מלח) הוא רצף תווים אקראי וייחודי שנוצר עבור כל משתמש בנפרד. לפני הגיבוב מצמידים אותו לסיסמה, ושומרים אותו בגלוי בעמודה ליד התקציר במסד הנתונים:
user salt stored hash
maya d41f07aa hash(d41f07aa + password)
omer 5e92c0b3 hash(5e92c0b3 + password)הדרך הנוחה להבין את Salt היא לשאול מה רוצה תוקף שגנב את הטבלה, ומה המלח משנה בכל מטרה שלו:
| מטרת התוקף | האם Salt מפריע? | הסבר |
|---|---|---|
| לזהות אילו משתמשים בחרו אותה סיסמה | כן | לכל משתמש תקציר אחר, גם כשהסיסמה זהה |
| לחפש תקצירים בטבלה שחושבה מראש | כן | הטבלה לא נבנתה עם המלח האקראי של אותו משתמש |
| לנחש סיסמה של חשבון אחד | לא | התוקף מצמיד לכל מועמדת את המלח שנחשף במסד |
| לגלות את המלח עצמו | לא | המלח אינו סוד: הוא שמור בגלוי ליד התקציר |
| לשחזר סיסמה שנשכחה | לא | Salt אינו הצפנה, והגיבוב נשאר חד-כיווני |
| לנצל את התנגשויות MD5 | לא | המלח אינו מתקן את חולשת האלגוריתם |
מלח זהה לכל המשתמשים מחטיא את המטרה, כי סיסמאות זהות שוב מניבות תקציר זהה. וגם עם מלח ייחודי, MD5(salt + password) נשאר מהיר מדי לשמירת סיסמאות.
תרחיש 5: חישוב עלות הפיצוח אחרי דליפה עם Salt
חנות מקוונת איבדה טבלה של 50,000 משתמשים, כל אחד עם מלח ייחודי ותקציר של MD5(salt + password). תוקף מחזיק רשימה של 100 מיליון סיסמאות נפוצות, והמלחים כבר גלויים לו.
נניח, להמחשה, שהמאיץ שלו בודק מיליארד ניחושים בשנייה. מול משתמש אחד זה עשירית שנייה לכל הרשימה, ומול כל 50,000 המשתמשים כשעה ו-23 דקות.
המלח הרחיק את הקיצור של טבלה מוכנה, אבל העבודה על כל משתמש בנפרד נשארה זולה. לכן סיסמה נפוצה תיפול, ו-MD5 עם Salt עדיין אינו בטוח.
טעויות נפוצות
- ה-Salt נשמר בסוד מוחלט ולכן תוקף שגונב את מסד הנתונים לא יכול לנחש סיסמאות. ה-Salt אינו סוד; הוא נשמר לצד התקציר כדי שהשרת יוכל לאמת כניסות.
- הוספת Salt מאיטה את פונקציית הגיבוב והופכת את MD5 לבטוח לסיסמאות. צירוף מחרוזת קצרה אינו משנה את מהירות החישוב של MD5.
- אם התוקף רואה את ה-Salt, הסיסמה נחשפת מיידית. התוקף עדיין צריך לנחש סיסמאות ולהריץ גיבוב על כל מועמדת.
בדקו את עצמכם
שני משתמשים בחרו את אותה סיסמה והמסד משתמש במלח אקראי לכל אחד. האם התקצירים שלהם זהים, ומה זה אומר לתוקף שרואה את הטבלה?
לא, הם שונים, ולכן התוקף אינו מסוגל להסיק מהטבלה שהשניים בחרו אותה סיסמה.
מפתח מודאג שמשתמש שאיבד סיסמה יוכל לשחזר אותה מהמלח ומהתקציר השמורים בטבלה. האם הדאגה מוצדקת?
לא. המלח והתקציר אינם הצפנה, ולא ניתן לשחזר מהם את הסיסמה אלא רק לבדוק ניחוש מול התקציר.
איך שומרים סיסמאות נכון
הכלל הברור הוא: את MD5 לא מתקנים, אלא מחליפים. לשמירת סיסמאות בוחרים בפונקציית גיבוב ייעודית שהיא איטית בכוונה ומשלבת Salt ייחודי לכל משתמש.
התקנים המקובלים היום הם Argon2, bcrypt, scrypt ו-PBKDF2. פונקציות אלו צורכות זמן חישוב ניכר (וחלקן גם נפח זיכרון משמעותי) בכל בדיקה.
עבור משתמש לגיטימי שמתחבר פעם אחת, עיכוב של עשרות מילישניות אינו מורגש כלל. עבור תוקף שמנסה להריץ מיליארדי ניחושים, העלות הופכת את ההתקפה לבלתי מעשית:
import hashlib
pw = b"Spring!Roses9"
for salt_hex in ("0f3e5d7a91c2b4d6", "c8a1f0e27b9d3546"):
d = hashlib.pbkdf2_hmac("sha256", pw, bytes.fromhex(salt_hex), 150000)
print("salt", salt_hex, "->", d.hex()[:32] + "...")salt 0f3e5d7a91c2b4d6 -> f803e242d4278b5fc4e786dbbd0450fc...
salt c8a1f0e27b9d3546 -> 73490cd97cf6549b168ea7ff2ad266b7...אותה סיסמה עם שני מלחים נותנת שתי תוצאות שונות לגמרי. ו-150000 החזרות הן מה שמאט כל ניחוש בודד: משתמש לגיטימי משלם את המחיר פעם אחת, ותוקף משלם אותו על כל ניחוש.
| הצעה אחרי דליפת MD5 | האם מאטה ניחוש על הקובץ הגנוב? | הערה |
|---|---|---|
| הגבלת קצב או נעילה בטופס ההתחברות | לא | פועלת רק מול ניסיונות באתר, ואילו הניחוש על הקובץ קורה אצל התוקף |
| חישוב MD5 פעמיים או יותר ברצף | לא | נשאר מהיר מאוד, והחזרה אינה מרפאת גם את חולשת ההתנגשויות |
| הוספת Salt על גבי MD5 | לא | מבטל טבלאות מוכנות אך אינו מאט ניחוש מול חשבון אחד |
| הצפנת כל התקצירים במפתח סימטרי אחד שבשרת | לא | המפתח שמור ליד המסד, ואם הוא דולף ההצפנה נפתחת בבת אחת |
| Argon2, bcrypt, scrypt או PBKDF2 עם Salt ייחודי | כן | כל ניחוש יקר, וטבלאות מוכנות אינן שימושיות |
תרחיש 6: ישיבת תגובה אחרי יציאת קובץ הסיסמאות
בישיבת תגובה לאירוע מתברר שקובץ משתמשים עם תקצירי MD5 כבר נמצא בידי גורם זר. עולות שתי הצעות: לנעול חשבון אחרי חמש טעויות בהתחברות, או להחליף את שיטת האחסון.
הנעילה מגינה רק על ניסיונות מול האתר. את הקובץ הגנוב אפשר לפצח במחשב של התוקף, בלי שהאתר יראה ניסיון אחד.
לכן מחליפים לפונקציה איטית עם Salt ייחודי, ומחייבים איפוס סיסמאות, כי הערכים הישנים כבר חשופים לפיצוח.
טעויות נפוצות
- הרצת MD5 פעמיים ברצף מכפילה את האבטחה ופותרות את החולשה. שני חישובים מהירים עדיין ניתנים להרצה בקצב של מיליארדים בשנייה.
- הגבלת ניסיונות כניסה באתר מגינה על גיבובים שכבר נגנבו. תוקף שמחזיק בקובץ הדלף בודק ניחושים מקומית ואינו פונה לטופס האתר.
בדקו את עצמכם
מפתח מציע לשמור את הסיסמאות כ-MD5 כפול עם מלח ייחודי. מה הצעד הזה משיג, ומה עדיין חסר?
המלח מבטל טבלאות מוכנות ומפריד בין סיסמאות זהות, אך החישוב נשאר מהיר מאוד ולכן ניחוש מול חשבון אחד עדיין זול.
מדוע פונקציית אחסון סיסמאות צריכה גם להיות איטית וגם להשתמש במלח ייחודי, ומה כל אחד מהם פותר?
האיטיות מייקרת כל ניחוש, והמלח הייחודי מנטרל טבלאות מוכנות ומסתיר משתמשים שבחרו אותה סיסמה.
RSA: הצפנה במפתח ציבורי
סימטרי מול אסימטרי: זוג מפתחות
הצפנה סימטרית כמו AES עובדת במהירות גבוהה מאוד, אך מציבה מכשול תיאום: שני הצדדים חייבים להחזיק באותו מפתח סודי מראש, וכל זוג מתקשרים נדרש לסוד נפרד. העברת המפתח הסודי בפעם הראשונה דורשת ערוץ מאובטח שכבר קיים.
הצפנה אסימטרית עוקפת את הצורך בתיאום מוקדם באמצעות הפרדה לשני מפתחות בעלי קשר מתמטי. כל צד מפרסם בגלוי את המפתח הציבורי שלו, ושומר אצלו בלבד את המפתח הפרטי בלי לחשוף אותו לאף גורם.
האלגוריתם האסימטרי המוכר ביותר הוא RSA (ראשי התיבות של ממציאיו Rivest, Shamir ו-Adleman משנת 1977). מכיוון שכל אחד יכול להשיג את המפתח הציבורי ולהצפין בעזרתו הודעה שרק המפתח הפרטי התואם פותח, אין צורך בסוד משותף מראש - אך המחיר הוא מהירות נמוכה בהרבה מהצפנה סימטרית, מה שמונע שימוש ישיר ב-RSA לנפחי מידע גדולים.
| נושא | סימטרי (AES) | אסימטרי (RSA) |
|---|---|---|
| מה מחזיק כל צד | אותו סוד בדיוק אצל שני הצדדים | שני ערכים שונים: אחד לפרסום ואחד שנשאר אצל הבעלים |
| איך מתחילים לתקשר | קודם צריך להעביר את הסוד בערוץ בטוח | מספיק להשיג את המפתח הציבורי, גם בערוץ פתוח |
| קצב העבודה | מהיר מאוד ומתאים לנתונים רבים | איטי בהרבה ומתאים לכמות קטנה של מידע |
| חתימה על מסמך | לא אפשרית, כי גם המקבל מחזיק באותו מפתח ויכול לייצר אותה | אפשרית, כי רק הבעלים מחזיק במפתח הפרטי |
המפתח הפרטי אינו גיבוי של המפתח הציבורי, ולכל אחד מהם תפקיד קבוע שאינו מתחלף:
- פעולות במפתח הפרטי: פתיחת הודעות שהוצפנו לבעלים, ויצירת חתימות דיגיטליות.
- פעולות במפתח הציבורי: הצפנת הודעות עבור הבעלים, ובדיקת חתימות שהבעלים יצר.
טעויות נפוצות
- בשיטה אסימטרית אין מפתח פרטי, אלא רק ציבורי. השיטה בנויה על זוג מפתחות; בלי המפתח הפרטי לא ניתן לפענח או לחתום.
- RSA מהיר יותר מהצפנה סימטרית. חישובים על מספרים של אלפי סיביות איטיים בהרבה מפעולות סימטריות כמו AES.
- השולח חייב להעביר את המפתח הפרטי שלו למקבל לפני תחילת השיחה. המפתח הפרטי אינו יוצא מרשות בעליו לעולם; העברתו תבטל את האבטחה.
- אפשר להשתמש במפתח סימטרי אחד במקום בזוג אסימטרי ועדיין להפיק חתימה דיגיטלית. כששני צדדים מחזיקים באותו סוד, אי אפשר להוכיח לצד שלישי מי יצר את ההודעה.
- תפקיד המפתח הפרטי הוא להוכיח מול רשות מאשרת שהמפתח הציבורי הונפק כחוק. אימות הנפקה מתבצע באמצעות התעודה הדיגיטלית וחתימת ה-CA, לא דרך המפתח הפרטי.
בדקו את עצמכם
בקבוצה של 8 סטודנטים כל זוג רוצה ערוץ מוצפן פרטי. כמה מפתחות פרטיים נדרשים ב-RSA, וכמה סודות משותפים היו נדרשים בשיטה סימטרית?
ב-RSA נדרשים שמונה מפתחות פרטיים, אחד לכל סטודנט, והמפתחות הציבוריים מתפרסמים בחופשיות. בשיטה סימטרית צריך סוד נפרד לכל זוג, כלומר 28 סודות (8 כפול 7 חלקי 2), וכל אחד מהם צריך לעבור בערוץ מאובטח.
המתמטיקה: n = p x q ופירוק לגורמים
הכפלת שני מספרים ראשוניים גדולים היא פעולה מיידית במחשב, אך פירוק התוצאה חזרה לשני הגורמים המקוריים הוא בעיה חישובית קשה מאוד כאשר המספרים גדולים דיים (2048 סיביות ומעלה). הפער הזה בין כיוון ההכפלה לכיוון הפירוק הוא היסוד שעליו נשען ביטחון RSA.
הפקת זוג המפתחות נשענת על ארבעה שלבים:
- הגרלת שני מספרים ראשוניים גדולים מאוד,
pו-q, שנשמרים בסוד. - חישוב המודולוס
n = p * q, שנכנס למפתח הציבורי. - בחירת מעריך ציבורי
e(במימושים מעשיים כמעט תמיד65537). - גזירת המעריך הפרטי
dמתוך ערכיpו-q.
המפתח הציבורי מורכב אפוא מהזוג (n, e), ואילו d (לצד p ו-q) מרכיב את המפתח הפרטי. מי שמנסה לחלץ את d מתוך המידע הפומבי חייב להשיג תחילה את p ו-q, כלומר לפרק את n.
מותר לחשוף את (n, e) בפומבי משום שהקשר המתמטי בין שני המפתחות אינו שמיש לתוקף כל עוד n לא פורק: e הוא ערך ציבורי, n אינו משתנה מהצפנה להצפנה, והמפתח הציבורי אינו תוצאת גיבוב של המפתח הפרטי ואינו מוגן בסיסמה. שימו לב שגם בדיקת ראשוניות וגם העלאה בחזקה מודולרית הן פעולות מהירות ואינן מקור הקושי, ובעיית הלוגריתם הבדיד שייכת לאלגוריתמים אחרים ואינה הבסיס של RSA.
בקוד שלהלן מופיע גם הערך phi, והוא (p - 1) * (q - 1). המעריך הפרטי d נבחר כך ש-e * d מותיר שארית 1 בחילוק ב-phi. מי שמכיר את phi מגיע מיד גם ל-p ול-q, ולכן במפתח אמיתי הוא נשאר סודי בדיוק כמו d; התוכנית מדפיסה אותו רק לצורכי הדגמה.
#include <stdio.h>
/* Educational RSA with tiny primes: real keys require 2048+ bits. */
static unsigned long long mod_exp(unsigned long long base,
unsigned long long exp,
unsigned long long mod) {
unsigned long long acc = 1;
base %= mod;
while (exp > 0) {
if (exp & 1ULL) {
acc = (acc * base) % mod;
}
base = (base * base) % mod;
exp >>= 1;
}
return acc;
}
int main(void) {
unsigned long long p = 47, q = 71;
unsigned long long n = p * q;
unsigned long long phi = (p - 1) * (q - 1);
unsigned long long e = 13, d = 2477;
printf("n = %llu, phi = %llu, (e * d) mod phi = %llu\n",
n, phi, (e * d) % phi);
unsigned long long msg = 73;
unsigned long long enc_first = mod_exp(msg, e, n);
unsigned long long enc_second = mod_exp(msg, e, n);
unsigned long long dec = mod_exp(enc_first, d, n);
printf("encrypt %llu -> %llu, repeat -> %llu, decrypt -> %llu\n",
msg, enc_first, enc_second, dec);
unsigned long long digest = 211;
unsigned long long sig = mod_exp(digest, d, n);
unsigned long long verified = mod_exp(sig, e, n);
printf("sign %llu -> %llu, verify -> %llu\n", digest, sig, verified);
unsigned long long sig_a = mod_exp(4, d, n);
unsigned long long sig_b = mod_exp(5, d, n);
unsigned long long combined = (sig_a * sig_b) % n;
unsigned long long sig_prod = mod_exp(20, d, n);
printf("sig(4) = %llu, sig(5) = %llu, product mod n = %llu, sig(20) = %llu\n",
sig_a, sig_b, combined, sig_prod);
return 0;
}n = 3337, phi = 3220, (e * d) mod phi = 1
encrypt 73 -> 1873, repeat -> 1873, decrypt -> 73
sign 211 -> 530, verify -> 211
sig(4) = 2580, sig(5) = 735, product mod n = 884, sig(20) = 884הקוד ממחיש את הפעולה בשני הכיוונים: העלאה בחזקת e מודולו n הופכת את 73 ל-1873 וחזקה ב-d משחזרת 73, ואילו בחתימה d מפיק 530 ו-e מחזיר 211. בדוגמה המוקטנת הזו n = 3337 מתפרק מיד ל-47 * 71, בעוד שבמפתח תקני של 2048 סיביות (617 ספרות עשרוניות) הפירוק בלתי אפשרי מעשית במחשבים רגילים; על השורה האחרונה בפלט נעמוד בחלק על ריווח.
טעויות נפוצות
- הביטחון של RSA נובע מקושי החישוב של חזקות גדולות או מבדיקת ראשוניות. שתי הפעולות הללו יעילות מאוד; הקושי הוא פירוק המכפלה
nלגורמים. - האלגוריתם נשען על בעיית הלוגריתם הבדיד. לוגריתם בדיד שייך לשיטות אחרות; RSA נשען על קושי הפירוק לגורמים.
- כיוון ש-
eגלוי לכול, אפשר לנחש ממנו אתd. המעריךeציבורי במכוון ואינו מאפשר חישוב שלdבלי פירוקn. - אין שום קשר מתמטי בין המפתח הציבורי לפרטי. קיים קשר מתמטי מדויק ביניהם, אך מימושו דורש ידיעה של
pו-q. - המפתח הפרטי שמור אצל רשות האישורים כדי למנוע את חשיפתו. המפתח הפרטי נשמר אצל בעליו בלבד ואינו מופקד אצל ה-CA.
בדקו את עצמכם
בידי תוקף נמצא המפתח הציבורי (n, e). מהי הפעולה שעליו להשלים כדי לגזור את d?
לפרק את n לגורמיו הראשוניים p ו-q, שמתוכם מחושב המעריך הפרטי d.
הצפנה לסודיות: המפתח הציבורי של הנמען
כאשר המטרה היא שרק הנמען יוכל לקרוא את המסר, מצפינים במפתח הציבורי של הנמען, והנמען פותח את הצופן במפתח הפרטי שלו. מפתח ציבורי לעולם אינו מסוגל לפענח טקסט שהוצפן בו עצמו.
Maya -> Tomer (confidential payload)
Encrypt with: Tomer's PUBLIC key
Decrypt with: Tomer's PRIVATE key
Result: Only Tomer can read it; Maya cannot decrypt the ciphertext herself.טבלת האפשרויות מבהירה מדוע כל בחירה אחרת של מפתח הצפנה נכשלת בהשגת סודיות לנמען:
| המפתח שנבחר להצפנה | מה קורה בפועל |
|---|---|
| הציבורי של הנמען | תקין: רק הנמען פותח בעזרת המפתח הפרטי שלו |
| הפרטי של השולח | נחשף לכול: כל מי שמחזיק בציבורי של השולח יפענח (זו חתימה, לא סודיות) |
| הציבורי של השולח | ננעל אצל השולח: הנמען אינו יכול לפענח כי אין לו את הפרטי של השולח |
| הפרטי של הנמען | לא ישים: המפתח אינו בידי השולח ואסור להעביר אותו |
תרחיש 7: ספק אינטרנט שומר עותק של כל החבילות
אפליקציה פותחת חיבור לשרת בדרך שהזכירה את HTTPS הוותיק: היא מגרילה סוד אקראי, מצפינה אותו במפתח הציבורי של השרת ושולחת את הצופן. מנהל רשת שמקליט את כל התעבורה מחזיק אפוא בשני דברים: הצופן, והמפתח הציבורי שבו הוצפן.
כדי להחזיר את הצופן לסוד, המנהל זקוק למפתח הפרטי של השרת, והוא אינו עובר ברשת. לגזור אותו מהמפתח הציבורי אפשר רק על ידי פירוק n, ולכן ההקלטה חסרת תועלת בידיו.
הפרט המפתיע הוא שגם האפליקציה עצמה אינה יכולה לפתוח את הצופן שהפיקה. היא לא צריכה לעשות זאת: הסוד האקראי המקורי עדיין אצלה, והיא משתמשת בו ישירות.
טעויות נפוצות
- לשמירת סודיות מצפינים במפתח הפרטי של השולח. המפתח הציבורי של השולח זמין לכולם, ולכן כל מאזין יוכל לפתוח את המסר.
- הנמען מפענח הודעה שהוצפנה אליו בעזרת המפתח הציבורי שלו. מפתח ציבורי אינו מפענח מה שהוצפן בו; רק המפתח הפרטי התואם מפענח.
- המפתח הציבורי של השרת נחשב מידע חסוי שאסור לפרסם. המפתח הציבורי מופץ בגלוי לכל לקוח; הסודיות תלויה אך ורק במפתח הפרטי.
- מי שהפעיל את ההצפנה על ההודעה יכול גם לפתוח את הצופן כי יצר אותו. פענוח הצופן עצמו אפשרי רק בעזרת המפתח הפרטי של הנמען.
בדקו את עצמכם
בודק אבטחה גילה שאפליקציה מצפינה הודעות לשרת במפתח הפרטי של האפליקציה עצמה, ומחשיבה זאת הצפנה לסודיות. מה הפגם?
את המפתח הציבורי של האפליקציה אפשר להשיג בקלות, ולכן כל מאזין יכול לפתוח את ההודעות. מה שנוצר כך הוא בעצם חתימה ולא סודיות. לסודיות צריך להצפין במפתח הציבורי של השרת, שרק השרת פותח בפרטי שלו.
חתימה דיגיטלית: המפתח הפרטי של החותם
חתימה דיגיטלית עונה על צורך שונה מהצפנה: לא להסתיר את התוכן, אלא להוכיח מי הפיק אותו ולוודא שלא השתנה בדרך. הכלל הפוך מהצפנה: חותמים במפתח הפרטי של החותם, וכל אחד מאמת במפתח הציבורי שלו.
מכיוון ש-RSA איטי ומוגבל באורך הקלט, לא מפעילים אותו על המסמך כולו. קודם מחשבים גיבוב (Hash, כיום SHA-256) של המסמך, וחותמים רק עליו. המקבל לוקח את המפתח הציבורי מהתעודה של החותם, מחשב בעצמו גיבוב של מה שהתקבל, ומשווה אותו לגיבוב שנחשף מהחתימה.
- אצל החותם: מחשבים גיבוב
SHA-256של המסמך ומפעילים עליו את המפתח הפרטי, וכך מתקבלת החתימה. - שולחים למקבל את המסמך הגלוי יחד עם החתימה.
- אצל המקבל: מחשבים גיבוב עצמאי של המסמך, ומפעילים את המפתח הציבורי של החותם על החתימה.
- מאשרים רק אם שני הגיבובים זהים לגמרי.
נניח שמישהו משנה תו אחד במסמך החתום. הגיבוב שיתקבל אצל המקבל יהיה שונה לחלוטין מהמקורי, ובלי המפתח הפרטי אי אפשר להפיק חתימה שמתאימה לו. לכן אימות מוצלח מראה גם שהחותם הוא בעל המפתח וגם שהתוכן לא נגע, והמפתח עצמו אינו נחשף לאיש.
חתימה דיגיטלית מספקת שלוש תכונות אבטחה:
- אימות מקור (Authenticity): רק בעל המפתח הפרטי יכול היה להפיק את החתימה.
- שלמות (Integrity): התוכן לא עבר שינוי מרגע החתימה.
- מניעת הכחשה (
Non-repudiation): החותם אינו יכול להתנער בדיעבד מהחתימה, מפני שהמפתח הפרטי נמצא רק ברשותו.
אין דרך לקבל מניעת הכחשה מסוד משותף. כשהסוד אצל שני הצדדים, כל אחד מהם יכול היה לכתוב את ההודעה, ושופט חיצוני לא יוכל להכריע מי עשה זאת. ומה חתימה תקפה כן ולא מוכיחה, בכל אחת מהטענות הבאות?
| הטענה | האם חתימה תקפה מוכיחה אותה? |
|---|---|
| המסמך הוסתר מפני מאזינים | לא: הטקסט נשאר גלוי אלא אם הוצפן בנפרד |
| אי אפשר היה לערוך את הקובץ בדרך | לא: אפשר לערוך אותו, אבל העריכה מתגלה כי הגיבוב כבר אינו מתאים לחתימה |
| מי שמחזיק במפתח הציבורי יכול לחתום | לא: המפתח הציבורי רק מאמת, והחתימה דורשת את הפרטי |
| החותם הוא מי שהוא טוען שהוא | לא לבדה: צריך גם לוודא שהתעודה של החותם תקפה ומהימנה |
| המסמך לא שונה והחותם מחזיק במפתח הפרטי | כן, וזה בדיוק מה שחתימה נועדה להראות |
תרחיש 8: חבילת עדכון שעוברת דרך שרתי מראה
קובץ התקנה חתום מועבר דרך ארבעה שרתי ביניים עד ליעד. תחנת היעד מחשבת SHA-256 של הקובץ, פותחת את החתימה בעזרת המפתח הציבורי מתעודת היצרן, ומוודאת התאמה מלאה.
השוואת גודל הקובץ בלבד הייתה מחמיצה שינוי של פקודה באותו אורך, ואילו בדיקת הגיבוב והחתימה הייתה נכשלת מיד כי לשרת ביניים אין המפתח הפרטי לחתום מחדש. כמו כן, התחנה אינה מפענחת דבר במפתח הפרטי של היצרן שאינו יוצא ממנו לעולם.
טעויות נפוצות
- חתימה דיגיטלית מסתירה את תוכן המסמך מפני מאזינים. חתימה מוודאת מקור ושלמות בלבד; המסמך נשאר גלוי אלא אם מוצפן בנפרד.
- באימות חתימה, הנמען מפעיל הצפנה על המסמך בעזרת המפתח הציבורי של השולח ומשווה לתוצאה. הפעלת המפתח הציבורי נעשית על החתימה עצמה כדי לחלץ את הגיבוב ולהשוותו לגיבוב המסמך.
- גודל המפתח הפרטי חוסם עריכה במסמך אחרי החתימה. חתימה אינה מנעול על הקובץ: מי שרוצה יכול לשנות אותו. מה שהיא עושה הוא לגרום לשינוי כזה להיכשל באימות. את הגיבוב מחשבים כי RSA לא מסוגל לעבד קלט ארוך, וזה לא מנגנון הגנה על המסמך.
- צירוף תעודת ה-CA של השולח להודעה מוכיח מי יצר את ההודעה. התעודה גלויה לכול ומוכיחה רק למי שייך המפתח הציבורי; ההוכחה שהשולח יצר את ההודעה היא החתימה במפתח הפרטי שלו.
- החתימה עובדת כי החותם מוסר מראש סיסמה למקבל, והמקבל מזין אותה בבדיקה. שום סוד אינו עובר למקבל. הוא זקוק רק למפתח הציבורי של החותם, והשינוי מתגלה כי הגיבוב שחישב אינו מתאים לחתימה.
בדקו את עצמכם
מקבלים קובץ וחתימה שלו. מה מחשבים בצד המקבל, ואיפה מופעל המפתח הפרטי בתהליך כולו?
המקבל מחשב גיבוב של הקובץ ומפעיל את המפתח הציבורי של החותם על החתימה, כדי לקבל את הגיבוב שהחותם חתם עליו. אם שניהם זהים החתימה תקפה. המפתח הפרטי מופעל רק אצל החותם, ורק על הגיבוב ולא על המסמך כולו.
מסמך נחתם ונשלח יחד עם החתימה, ובדרך מישהו משנה בו ספרה אחת. מה יקרה באימות, ומדוע התוקף אינו יכול לתקן את החתימה?
הגיבוב שהמקבל יחשב ישתנה לגמרי ולא יתאים לגיבוב שנחשף מהחתימה, ולכן האימות ייכשל. כדי ליצור חתימה חדשה לגיבוב החדש נדרש המפתח הפרטי של החותם, ואין לתוקף גישה אליו.
גם חתימה וגם הצפנה באותה הודעה
כאשר נדרשות גם סודיות וגם הוכחת זהות ושלמות יחד, משלבים שני זוגות מפתחות: הזוג של השולח והזוג של הנמען.
| מטרה | פעולה אצל השולח | באיזה מפתח | פעולה אצל הנמען |
|---|---|---|---|
| זהות ושלמות | חתימה על הגיבוב | הפרטי של השולח | אימות בציבורי של השולח |
| סודיות | הצפנת התוכן (או המפתח הסימטרי) | הציבורי של הנמען | פענוח בפרטי של הנמען |
תרחיש 9: עומר ויעל מחליפים פקודה רגישה
עומר מעוניין לשלוח ליעל הוראה חסויה שתוודא גם את זהותו. הוא מפיק גיבוב להוראה וחותם עליו במפתח הפרטי של עומר, ואז מצפין את החבילה (או את מפתח ההפעלה הסימטרי) במפתח הציבורי של יעל.
בצד המקבל יעל פותחת את הצופן במפתח הפרטי שלה ומאמתת את החתימה בעזרת המפתח הציבורי של עומר. אילו עומר היה מחליף בין המפתחות - חותם בציבורי של עצמו או מצפין בפרטי של עצמו - החתימה הייתה חסרת ערך והסודיות הייתה נחשפת לכל מאזין, ולמפתח הפרטי של יעל אין לו גישה כלל.
בדקו את עצמכם
שירה שולחת לעידו קובץ שהוא צריך לדעת שהיא שלחה, ושאיש לא יקרא בדרך. אילו פעולות מתבצעות ובאיזה מפתח כל אחת?
שירה חותמת בעזרת המפתח הפרטי שלה, ומצפינה בעזרת המפתח הציבורי של עידו. עידו מפענח בעזרת המפתח הפרטי שלו, ומאמת בעזרת הציבורי של שירה. כך משתתפים שני זוגות מפתחות, ולכל צד נחוצים הפרטי שלו והציבורי של הצד האחר.
הצפנה היברידית: למה לא מצפינים קובץ שלם ב-RSA
הצפנה ישירה של קובץ גדול ב-RSA אינה ישימה משתי סיבות טכניות: חישובי החזקות המודולריות איטיים בסדרי גודל מהצפנה סימטרית כמו AES, ובלוק קלט יחיד ב-RSA מוגבל לאורך קטן מ-n (ואף פחות מכך אחרי ריווח).
לכן התקשורת המודרנית פועלת בשיטה היברידית:
- השולח מפיק מפתח סימטרי אקראי וחד-פעמי (למשל מפתח
AES). - השולח מצפין את כל הנתונים במפתח הסימטרי המהיר.
- השולח מצפין ב-RSA רק את המפתח הסימטרי הקצר, בעזרת המפתח הציבורי של הנמען.
- הנמען מפענח בפרטי שלו את המפתח הסימטרי, ובעזרתו מפענח את הקובץ כולו.
הארכיטקטורה הזו משלבת בין מהירות ה-AES לבין העברת מפתח ללא סוד מוקדם. חשוב להדגיש ש-AES חזק דיו בפני עצמו ואינו נעזר ב-RSA כדי "להתחזק", וכן שהמפתח הסימטרי אחראי להצפנת המידע בלבד ואינו מאמת את זהות השולח (תפקיד השמור לחתימה דיגיטלית).
הסיבה לשימוש בהצפנה היברידית היא ביצועים ואורך בלוק, ולא מגבלות תוכן: RSA מטפל גם בקבצים בינאריים, מתאים גם לכמה נמענים (כל אחד עם מפתחו הציבורי), אינו מחייב תעודה חדשה לכל מסר, ומשמש הן להצפנה והן לחתימה.
תרחיש 10: גיבוי ארכיוני של 2 GB לשרת מרוחק
גיבוי שבועי בנפח 2 GB צריך להישלח לשרת מרוחק שהמפתח הציבורי שלו ידוע. חלוקת הנפח למיליוני בלוקים והצפנתם ב-RSA הייתה מכבידה על המעבד וגוזלת זמן רב.
בשיטה היברידית המערכת מייצרת מפתח AES אקראי להצפנת הגיבוי כולו, ומצרפת לתוצאה כמה מאות בתים בלבד של המפתח הסימטרי כשהוא מוצפן ב-RSA.
טעויות נפוצות
- כיוון ש-AES חלש יותר מ-RSA, עוטפים את המפתח הסימטרי ב-RSA לשם חיזוק. מפתח AES אקראי חזק מאוד; RSA נדרש רק להעברתו הבטוחה, ולא לחיזוק האלגוריתם.
- RSA מסוגל להצפין טקסט רגיל בלבד ולא קבצים בינאריים. האלגוריתם פועל על מספרים, ולכן מצפין כל מידע בינארי באותה מידה.
- המפתח הסימטרי בהצפנה היברידית מאמת את זהות השולח. הוא נועד להצפנת התוכן בלבד; אימות זהות מבוצע בחתימה דיגיטלית.
- RSA נועד לחתימות בלבד ואינו מצפין נתונים. RSA תומך בשני השימושים, ובהצפנה היברידית הוא מצפין את מפתח ההפעלה.
בדקו את עצמכם
מערכת גיבוי מצפינה כל קובץ ב-AES ומצרפת אליו בלוק קטן של כ-256 בתים שהוצפן ב-RSA. מה מוצפן בבלוק הקטן, ומדוע לא מצפינים ב-RSA את הקובץ עצמו?
בבלוק הקטן מוצפן המפתח הסימטרי שבו הוצפן הקובץ. את הקובץ עצמו לא מצפינים ב-RSA כי הוא איטי ומוגבל באורך הקלט. הנמען פותח את הבלוק במפתח הפרטי שלו, ובעזרת המפתח שקיבל מפענח את הקובץ.
אורך המפתח
אורך מפתח RSA נמדד במספר הסיביות של המודולוס n. ככל ש-n ארוך יותר, פירוקו ל-p ו-q קשה יותר, אך חישובי ההצפנה והחתימה הופכים איטיים יותר.
| אורך מפתח RSA | מעמד אבטחתי כיום |
|---|---|
| 512 סיביות | פרוץ לחלוטין, אסור לשימוש |
| 1024 סיביות | חלש מדי, ניתן לפירוק בעזרת כוח חישוב רב |
| 2048 סיביות | המינימום המקובל כיום |
| 3072 סיביות ומעלה | מומלץ להגנה לטווח ארוך |
| 4096 סיביות | נבחר למערכות רגישות במיוחד |
השוואה ישירה בין אורכי מפתחות של אלגוריתמים סימטריים לאסימטריים מטעה מאוד. שבירת מפתח AES באורך 128 סיביות מחייבת חיפוש ממצה על פני כל הערכים האקראיים (פעולה בלתי מעשית), בעוד תקיפת RSA מתבצעת בפירוק n לגורמיו שהוא יעיל בהרבה ממעבר על כל האפשרויות.
RSA-3072 שקול ברמת ההגנה בקירוב ל-AES-128, אבל מכאן אין להסיק שמספר הסיביות ב-RSA דומה לזה שב-AES. מודולוס של 128 סיביות מתפרק בשניות בודדות, ומודולוס של 256 סיביות בדקות על מחשב רגיל, ולכן מפתחות כאלה אינם מגינים כלל.
טעויות נפוצות
- 128 סיביות מספיקות ב-RSA בדיוק כמו ב-AES. הבעיות המתמטיות שונות לגמרי; מודולוס של 128 סיביות ב-RSA מתפרק בשניות.
- מפתח ארוך יותר מאיץ את החתימה הדיגיטלית. מפתח ארוך מגדיל את עלות החישוב ומאט את ההצפנה ואת החתימה.
- אורך המפתח משפיע על הביצועים בלבד, והביטחון תלוי רק באלגוריתם. האורך קובע את גודל
nואת קושי הפירוק לגורמים. - 1024 סיביות חלש להצפנה אבל בטוח לחתימות. ברגע שמפרקים את
nלגורמיו, התוקף משחזר אתdויכול גם לחתום וגם לפענח. - מפתח קצר מסוכן כי הצופן נושא עמו רמזים על המפתח הפרטי. הצופן הוא תוצאת החזקה בלבד ואינו כולל נתונים על המפתח הפרטי; מה שמסכן מפתח קצר הוא האפשרות לפרק את
nהפומבי.
בדקו את עצמכם
חברה שומרת מפתח RSA של 1024 סיביות בכספת חומרה שאיש לא פרץ אליה. האם אורך המפתח עדיין בעיה?
כן. התקיפה אינה דורשת גישה לכספת, אלא פירוק של n הפומבי בכוח חישוב. הכספת מגינה מפני גניבת המפתח, לא מפני פירוק של מפתח קצר מדי.
ריווח (Padding): OAEP ו-PSS
הפעלת חזקה מודולרית גולמית על הודעה ללא תוספות נקראת Textbook RSA, והיא פגיעה לשני כשלים חמורים גם בלי שהמפתח הפרטי ייחשף.
בהצפנה ללא ריווח התוצאה דטרמיניסטית: בתוכנית הדוגמה שראינו, הצפנת 73 החזירה 1873 פעם אחר פעם. כאשר מרחב האפשרויות מצומצם (למשל "כן" או "לא"), תוקף המאזין לרשת מנצל את המפתח הציבורי הגלוי לביצוע התקפת Chosen Plaintext - מצפין בעצמו את הניחושים האפשריים ומשווה לצופן שיירט.
התרופה בהצפנה היא תקן הריווח OAEP, שמערבב רכיב אקראי בהודעה לפני החזקה כך שכל הצפנה מפיקה תוצאה שונה.
בחתימה ללא ריווח מתגלה תכונה כפלית מסוכנת: בפלט התוכנית ראינו כי sig(4) * sig(5) mod 3337 שווה בדיוק ל-sig(20) (884). המבנה האלגברי הזה מאפשר לתוקף להרכיב חתימה תקפה למספר חדש מתוך חתימות קיימות ללא גישה למפתח הפרטי, והמענה לכך הוא ריווח PSS (או התקן הוותיק PKCS#1 v1.5) בשילוב חתימה על גיבוב ההודעה.
| פעולה | תקן ריווח | איזו פגיעות נמנעת |
|---|---|---|
| הצפנה | OAEP | הצפנה דטרמיניסטית והשוואת צפנים מול ניחושים |
| חתימה | PSS (או PKCS#1 v1.5) | זיוף חתימות על סמך מבנה מתמטי וחתימות קודמות |
כדי לזהות Textbook RSA בבדיקת קוד, מחפשים חזקה מודולרית שמופעלת ישירות על ההודעה או על הגיבוב, בלי שלב ריווח לפניה. אין לכך סימן חיצוני של תקלה: החישוב רץ בלי שגיאה, בקצב רגיל, והמפתח הפרטי אינו נחשף. מה שנפגע הוא סודיות של הודעות חוזרות ואמינות של חתימות.
טעויות נפוצות
- בלי ריווח המפתח הפרטי נחשף לאחר כמה חתימות. הבעיה היא זיוף חתימות וניחוש הודעות, ללא חשיפה של המפתח הפרטי עצמו.
- בלי ריווח החישוב נכשל בגלל חוסר התאמה לאורך המפתח. החזקה המודולרית עובדת טכנית, אך התוצאה אינה בטוחה.
- ריווח קיים רק בחתימות ואין לו תפקיד בהצפנה. להצפנה יש ריווח ייעודי (
OAEP) שתפקידו למנוע דטרמיניסטיות. - התקפת Chosen Plaintext חושפת את המפתח המשותף כי RSA סימטרי. בהתקפה הזו אין שום מפתח משותף לחלץ: התוקף מצפין ניחושים משלו במפתח הציבורי ומשווה אותם לצופן שהקליט.
בדקו את עצמכם
מערכת הצבעה מצפינה ללא ריווח את התשובה 'בעד' או 'נגד' במפתח הציבורי של השרת. איך מאזין יכול לדעת מה הצביע משתמש, ומה התיקון?
המאזין מצפין בעצמו את שתי התשובות במפתח הציבורי ומשווה כל תוצאה לצופן שהקליט, כי ההצפנה דטרמיניסטית. התיקון הוא ריווח OAEP, שמוסיף רכיב אקראי כך שאותה תשובה מניבה צופן שונה בכל פעם.
תעודה דיגיטלית ורשות מאשרת
מה יש בתעודה ומה אין בה
כל אחד יכול להפיק זוג מפתחות ולהכריז שהמפתח הציבורי שלו שייך לרשת בתי חולים מסוימת. הצפנה אסימטרית לבדה אינה מבררת מי באמת עומד מאחורי מפתח, ולכן צריך עדות של גורם שסומכים עליו. העדות היא תעודה דיגיטלית (X.509): מסמך שבו רשות מאשרת (CA) חותמת על הקשר בין מפתח ציבורי לזהות, שיכולה להיות דומיין, אדם או ארגון.
| שדה בתעודה | משמעות |
|---|---|
| Subject | זהות הבעלים שעבורו הונפקה התעודה |
| Subject Public Key | המפתח הציבורי של הבעלים |
| Issuer | הרשות המאשרת שהנפיקה וחתמה |
| Serial Number | מזהה סידורי ייחודי אצל הרשות |
| Not Before / Not After | חלון התאריכים שבהם התעודה תקפה |
| Subject Alternative Name (SAN) | רשימת שמות המתחם שהתעודה מכסה |
| Signature | חתימת ה-CA על כל תוכן התעודה |
חשוב לא פחות להכיר מה לא נמצא בתעודה:
- אין בה מפתח פרטי: הוא נשמר אצל בעל האתר בלבד.
- זיהוי לפי שם, לא לפי IP: בחיבור רגיל לאתר, הדפדפן מאמת את שם המתחם שבתעודה ולא מחפש בה את כתובת ה-IP של השרת.
- היא אינה מצפינה תעבורה: התעודה מאמתת זהות, בעוד התעבורה עצמה מוצפנת במפתחות סימטריים שמוסכמים בפתיחת החיבור.
נניח שתוקף לוקח תעודה אמיתית ומשנה בה רק את שדה המפתח הציבורי כך שיהיה המפתח שלו. חתימת ה-CA חושבה על התעודה כולה, ולכן היא כבר לא תתאים לתוכן ותיפסל. מכאן שהחתימה קושרת יחד את כל השדות, ולא רק את שם המתחם.
טעויות נפוצות
- התעודה כוללת את המפתח הפרטי של השרת. התעודה גלויה לכל גולש ומכילה את המפתח הציבורי בלבד.
- זהות השרת נקבעת לפי כתובת ה-IP בתעודה. בגלישה רגילה האימות מבוסס על שמות המתחם (DNS) שמופיעים ב-SAN.
- התעודה מצפינה את המידע העובר בין הדפדפן לשרת. ההצפנה מבוצעת במפתחות סשן סימטריים; התעודה מיועדת לאימות זהות.
- ה-CA חותמת רק על שם הדומיין ומשאירה את המפתח הציבורי מחוץ לחתימה. החתימה מכסה את כל התעודה כדי לקשור את השם למפתח הציבורי הספציפי.
בדקו את עצמכם
בידיכם קובץ התעודה של אתר. איזה מפתח של האתר מופיע בו, ואיזה לא יופיע בו לעולם?
מופיע המפתח הציבורי, והוא קשור לזהות בחתימת ה-CA. המפתח הפרטי אינו מופיע בתעודה, והוא נשאר רק אצל בעל האתר.
תפקיד ה-CA
דפדפנים ומערכות הפעלה סומכים מראש על צד שלישי המכונה רשות מאשרת (Certificate Authority, ובקיצור CA). עבודתה מסתכמת בשני שלבים: אימות שלבקשת התעודה יש בסיס (כגון הוכחת שליטה בדומיין), וחתימה דיגיטלית הקושרת את הזהות למפתח הציבורי.
ה-CA אינה צריכה להחזיק בבעלות על הדומיין עצמו כדי להנפיק לו תעודה, ודי בכך שהמבקש הוכיח שליטה בו. מעבר להנפקה, קיימות כמה פעולות שהרשות אינה מבצעת כלל:
| נושא | מי אחראי עליו |
|---|---|
| המפתח הפרטי של האתר | בעל האתר בלבד; ל-CA אין עותק, ולכן אם המפתח אובד היא לא יכולה לשחזר אותו |
| הצפנת התעבורה | הדפדפן והשרת ישירות ביניהם; ה-CA אינה נמצאת בקו |
| טיב התוכן ויושרו של המפעיל | איש לא בודק אותם: ה-CA אינה סורקת נוזקות ואינה מתחייבת שהאתר הגון |
| חידוש התעודה והתראה על אתרים מזויפים | חידוש דורש פנייה של הבעלים, וה-CA אינה שולחת לגולשים התראות |
טעויות נפוצות
- ה-CA מטמיעה עותק של המפתח הפרטי בתעודה ושומרת אותו לגיבוי. המפתח הפרטי אינו נמסר ל-CA כלל ונשאר אצל המבקש.
- ה-CA מתווכת בהצפנת התעבורה מול כל גולש. השרת והדפדפן מסכמים מפתחות סשן ישירות ביניהם בלחיצת היד.
- חתימת CA מאשרת שהאתר נקי מקוד זדוני. הרשות מאשרת זהות או שליטה בדומיין בלבד, לא את תוכן האתר.
CSR: הבקשה לתעודה
תהליך הנפקת התעודה בנוי כך שהמפתח הפרטי לעולם לא יעזוב את שרת הבעלים. הכלי שמאפשר זאת הוא קובץ בקשת חתימה, CSR (Certificate Signing Request).
- בשרת של הבעלים נוצר זוג מפתחות, והמפתח הפרטי נשאר בו.
- מרכיבים קובץ CSR מפרטי הארגון והדומיין ומהמפתח הציבורי, וחותמים עליו במפתח הפרטי כדי להראות שהמבקש מחזיק בו. זו אינה חתימת CA: ה-CSR אינו נושא חתימה של הרשות.
- הקובץ נשלח אל הרשות המאשרת. אין בו סוד, ולכן אפשר להעביר אותו בערוץ רגיל.
- הרשות בודקת את הפרטים, ואם הכול תקין היא מחזירה תעודה הנושאת את חתימת ה-CA.
| מאפיין | קובץ CSR | תעודה דיגיטלית |
|---|---|---|
| מי מפיק | בעל האתר | הרשות המאשרת (CA) |
| מכיל מפתח ציבורי | כן | כן |
| מכיל מפתח פרטי | לא | לא |
| נושא חתימת CA | לא | כן |
טעויות נפוצות
- ה-CSR כולל את המפתח הפרטי כדי שה-CA תחתום עליו. רק המפתח הציבורי נכלל בבקשה; המפתח הפרטי נשאר מקומי.
- ה-CA יוצרת את ה-CSR ושולחת אותו לבעל האתר. הכיוון הפוך: בעל האתר יוצר את הבקשה ושולח אותה אל ה-CA.
- ה-CSR נועד להעברת מפתחות סימטריים. הוא מיועד למפתח ציבורי ולפרטי זהות בלבד.
בדקו את עצמכם
חברה מבקשת מכם לשלוח לה את קובץ ה-CSR בדואר אלקטרוני רגיל. האם זה מסכן את המפתח הפרטי?
לא. ה-CSR מכיל רק את המפתח הציבורי ופרטי זהות, והחתימה שבו היא של המבקש ולא של ה-CA. המפתח הפרטי נשאר אצל הבעלים.
שרשרת האמון: שורש, ביניים, אתר
יש מיליוני אתרים, ואי אפשר לשמור במכשיר תעודה לכל אחד מהם. לכן הדפדפן מחזיק רשימה קצרה של רשויות שורש שהוא סומך עליהן מראש, ומאשר כל תעודה אחרת רק אם אפשר להגיע ממנה אל אחת מהן דרך שרשרת חתימות. זו שרשרת האמון (Chain of Trust).
Root CA certificate (self-signed, preinstalled in OS/browser trust store)
|
+-- signs --> Intermediate CA certificate
|
+-- signs --> Leaf / Server certificate (clinic.example.org)במבנה ההיררכי הזה, תעודת השרת (Leaf) מקבלת חתימה מרשות ביניים (Intermediate CA), וזו בתורה חתומה בידי רשות השורש (Root CA). בראש הפירמידה אין גורם בכיר יותר, ולכן תעודת השורש חתומה בחתימה עצמית (Self-signed).
האמון אינו יכול להתחיל מהרשת, כי תעודה שמגיעה מהשרת אינה מעידה על עצמה. תעודות השורש מגיעות יחד עם מערכת ההפעלה או הדפדפן ושמורות במאגר האמון (Trust store) המקומי. אילו שרת היה יכול לצרף שורש משלו, כל תוקף היה מצרף שורש שיצר בעצמו.
שימו לב שמאגר האמון מכיל רשויות ולא רשימה של אתרים מאושרים.
| איזה מפתח דולף | מה צריך לעשות כדי להתאושש |
|---|---|
| מפתח השורש | לעדכן את מאגר האמון בכל מכשיר בעולם, וזה כמעט בלתי אפשרי |
| מפתח של רשות ביניים | לבטל רק אותה, ולהנפיק מחדש את התעודות שחתמה |
| מפתח של אתר | הבעלים מבטל ומנפיק תעודה חדשה על זוג מפתחות חדש |
מכאן ההרגל להחזיק את מפתח השורש לא מקוון (Offline) ולהשתמש בו רק לחתימה על רשויות ביניים, שהן שמנפיקות את התעודות היומיומיות. לכן רשות ביניים בשרשרת היא מצב רגיל לגמרי.
תחשבו על השרשרת כעל מערכת שעונה לשאלה אחת: למי שייך המפתח הזה? נושאי ההצפנה וחידוש התעודה נמצאים מחוץ לה. מי שמעדיף לבנות אמון בלי רשות מרכזית משתמש ב-PGP, שם נהוג Web of Trust: אנשים חותמים על מפתחות של מי שהם מכירים.
תרחיש 11: מעקב אחר שרשרת אחת ומה קורה בה כשמפתח ביניים דולף
הדפדפן מקבל תעודה של pay.lotus.example. נלך אחריה מהעלה אל השורש, ונבדוק בכל חוליה מה נבדק ומה משתנה כשהמפתח של רשות הביניים דלף.
| התעודה | מי חתם עליה | מה הדפדפן בודק בחוליה | אחרי דליפת מפתח הביניים |
|---|---|---|---|
pay.lotus.example (עלה) | רשות הביניים Atlas | חתימה מול המפתח הציבורי של הביניים, שם ב-SAN, תוקף | תעודה אמיתית ותעודה מזויפת נראות אותו דבר, כי שתיהן חתומות במפתח הביניים |
| Atlas Issuing CA (ביניים) | רשות השורש | חתימה מול מפתח השורש וסטטוס ביטול | זו החוליה שמבטלים (CRL או OCSP) |
| Lotus Root CA (שורש) | עצמו (חתימה עצמית) | נמצא במאגר האמון המקומי | נשאר נקי ואינו דורש החלפה |
הטיפול נובע מהטבלה. קודם מבטלים את חוליית הביניים, אחר כך השורש הנקי מנפיק רשות ביניים חדשה עם מפתח חדש, ורק אז מונפקות מחדש התעודות של האתרים. תעודה שחתומה בידי עצמה היא שרשרת בת חוליה אחת: הדפדפן יכול לוודא שהחתימה מתאימה למפתח שבתוכה, אך אין בה קישור לשורש שבמאגר האמון, ולכן אין לו על מה להישען כדי להאמין לשם שבה.
טעויות נפוצות
- תעודת השורש חתומה בידי רשות בכירה עוד יותר. השורש הוא ראש ההיררכיה ולכן חתום בחתימה עצמית.
- הדפדפן סומך על השורש כי השרת שולח לו אותו בחיבור. שורש שמגיע מהאתר אינו מעיד על דבר, כי כל תוקף יכול לשלוח שורש שיצר; המכשיר סומך רק על שורשים שהותקנו בו מראש.
- השרשרת מצפינה את התעבורה שכבה אחרי שכבה. השרשרת עוסקת באימות זהות; ההצפנה מתבצעת בנפרד במפתחות סשן.
- תעודה שחתומה בידי רשות ביניים נדחית כי לא נחתמה ישירות בידי השורש. הנפקה דרך רשות ביניים היא התקן הרגיל להגנה על מפתח השורש.
- על כל תעודה חדשה הדפדפן מציג למשתמש בקשת אישור ידנית. שרשרת האמון אוטומטית וחוסכת אישור ידני כל עוד השורש נמצא במאגר האמון.
בדקו את עצמכם
שרת שולח לדפדפן את תעודת האתר ואת תעודת רשות הביניים, אך לא את תעודת השורש. האם השרשרת נכשלת?
לא. תעודת השורש כבר נמצאת במאגר האמון של המכשיר, והדפדפן סוגר בה את השרשרת בעצמו. מה שחשוב הוא שהשרשרת מובילה לשורש שמופיע במאגר.
מה היה הנזק אילו רשות שורש הייתה חותמת ישירות על תעודות אתרים, ומפתחה היה דולף?
תעודת השורש הייתה צריכה לצאת מהמאגר של כל מכשיר ומכשיר, ולא ניתן לבצע זאת בקלות. כשיש רשות ביניים, החלפה מוגבלת לשכבה היומיומית בלבד.
חתימת ה-CA והגיבוב: למה MD5 ו-SHA-1 נדחים
מה בדיוק חותמת הרשות? לא את קובץ התעודה הגולמי אלא את הגיבוב שלו (כיום SHA-256 יחד עם RSA או ECDSA).
תלות זו בגיבוב הופכת פונקציות חלשות כמו MD5 ו-SHA-1 לפרצה קריטית: תוקף יכול לייצר שתי תעודות שונות בעלות אותו גיבוב בדיוק - אחת תמימה ואחת המעניקה לו הרשאת CA מזויפת - ולהגיש לרשות את התעודה התמימה. כיוון שהחתימה חלה על הגיבוב הזהה, היא תקפה אוטומטית גם לתעודה המזויפת.
תקיפה זו אינה תיאורטית: ב-2008 זויפה בעזרת התנגשות MD5 תעודת CA אמיתית, וב-2012 ניצלה הנוזקה Flame שיטה דומה לזיוף תעודת חתימת קוד של Microsoft. כתוצאה מכך דפדפנים חוסמים כיום תעודות החתומות ב-MD5 או ב-SHA-1.
בניתוח התקיפה חשוב להפריד בין מה שהתוקף מרוויח לבין מה שנשאר מחוץ להישג ידו. הוא מרוויח חתימה אחת שתקפה לשני קבצים שונים. הוא אינו מקבל את המפתח הפרטי של האתר או של הרשות, ואינו מצליח להוריד את החיבור ל-HTTP.
אורך הפלט אינו מציל את המצב: ל-MD5 יש 128 סיביות, אבל הפונקציה עצמה שבורה ואפשר לייצר בה התנגשויות במאמץ קטן בהרבה מחיפוש על כל האפשרויות.
טעויות נפוצות
- גיבוב חלש בתעודה מאפשר לשחזר את המפתח הפרטי של ה-CA. החולשה היא התנגשויות בין שני קלטים שונים, ללא גישה למפתח הפרטי.
- ה-CA בודקת וחותמת רק את שם הדומיין, ולכן הגיבוב אינו חשוב. החתימה מופקת על גיבוב התעודה כולה.
- בגלל ש-MD5 מפיקה 128 סיביות, התנגשות לא תשפיע על חתימת ה-CA. אורך הפלט אינו עוזר כשהפונקציה עצמה שבורה; אפשר לייצר התנגשויות ללא חיפוש ממצה.
- שימוש בגיבוב חלש מאלץ את הדפדפן לעבור לחיבור HTTP לא מוצפן. הדפדפן דוחה את התעודה ומציג אזהרה, לא ירידה שקטה ל-HTTP.
בדקו את עצמכם
תוקף מחזיק בשתי תעודות שונות בעלות אותו גיבוב, והרשות חתמה על הראשונה. מה הוא עושה עם השנייה, והאם הוא זקוק למפתח של הרשות?
הוא מצרף לשנייה את החתימה שניתנה לראשונה. היא תקפה כי החתימה חלה על הגיבוב, ולכן הוא אינו זקוק למפתח של הרשות.
מדוע אורך הפלט של MD5 אינו מצדיק להשאיר אותה בחתימות של CA?
כי החולשה היא בפונקציה עצמה: אפשר לייצר בה התנגשויות בקלות, ולכן אורך הפלט אינו נותן הגנה.
מה הדפדפן בודק בתעודה
חמש הבדיקות
בפתיחת חיבור HTTPS, הדפדפן מעביר את התעודה סדרת בדיקות משלימות שכל אחת מהן בוחנת היבט אחר:
- שרשרת אמון: התעודה מתחברת דרך רשויות ביניים אל תעודת שורש המופיעה במאגר האמון.
- תקינות חתימות: כל חתימה לאורך השרשרת מאומתת בהצלחה.
- חלון תוקף: התאריך הנוכחי נמצא בין
Not Beforeל-Not After. - התאמת שם: שם המתחם המבוקש מופיע בשדה
Subject Alternative Name(דפדפנים עדכניים אינם מסתפקים ב-CN). - סטטוס ביטול: התעודה לא בוטלה מוקדם מהצפוי (
CRLאוOCSP).
מעבר של ארבע בדיקות אינו פוטר מהחמישית, ואף בדיקה אינה מכסה במקום אחרת. חתימה תקינה על תעודה שפג תוקפה אינה הופכת אותה לתקפה, ותעודה שתקפה לדומיין אחד אינה מכשירה אתר אחר.
כשבדיקה נכשלת, הדפדפן עוצר ומציג אזהרה. הוא אינו מבצע שום פעולה אוטומטית שמצילה את המצב: אין מעבר ל-HTTP, אין פנייה ל-CA לחידוש ואין קבלה של תעודה אחרת. ההחלטה עוברת לגולש, ובחירה ב"המשך" מוותרת על ההגנה מפני תוקף שמתיישב בין הדפדפן לשרת.
תרחיש 12: בדיקת תעודה של חנות שפג תוקפה
הדפדפן מקבל תעודה עבור shop.tulip.example ב-2 במרץ 2026. התעודה נקבעה לתוקף מ-1 בפברואר 2025 ועד 31 בינואר 2026.
| הבדיקה | התוצאה |
|---|---|
| שרשרת אמון | עוברת: מובילה לשורש שבמאגר האמון |
| חתימות | עוברות: כולן תקינות |
| חלון תוקף | נכשלת: התאריך מאוחר מ-Not After |
| שם ב-SAN | עוברת: shop.tulip.example מופיע ברשימה |
| ביטול | עוברת: התעודה לא בוטלה |
התוצאה היא אזהרת פקיעה. את התיקון עושה בעל האתר בלבד, שמבקש תעודה חדשה מה-CA.
תרחיש 13: דומיין חסר בשדה SAN
גולש פונה אל files.archive.example. השרת מציג תעודה בתוקף החתומה בידי CA מהימן, אך בשדה Subject Alternative Name מופיע רק auth.campus.example.
הדפדפן מתריע מפני אי-התאמה בשם המתחם כי השם המבוקש נעדר מה-SAN. האזהרה אינה קשורה להשוואת כתובת IP, ותעודה בעלת שם יחיד אינה הופכת לתעודה חתומה עצמית כל עוד CA חתמה עליה.
טעויות נפוצות
- תעודה שפגה נשארת מאושרת כל עוד חתימת ה-CA עליה תקינה. תאריכי התוקף נבדקים בנפרד, ותעודה שפגה אינה מהימנה.
- אם התעודה פגה, הדפדפן פונה ל-CA לחדש אותה או עובר ל-HTTP. רק בעל האתר מחדש תעודה מול ה-CA; הדפדפן מציג אזהרה למשתמש.
- הדפדפן בודק התאמה בין כתובת ה-IP של השרת לזו הרשומה בתעודה. הבדיקה היא מול שמות המתחם שב-SAN.
- אפשר ללחוץ על המשך באזהרת תעודה בבטחה כי התעבורה מוצפנת. ייתכן שהתעבורה מוצפנת ישירות מול תוקף אדם בתווך.
בדקו את עצמכם
שרשרת האמון תקינה, החתימות תקינות, התאריכים בתוקף והשם מופיע ב-SAN. ה-CA ביטלה את התעודה אחרי גניבת המפתח. איזו בדיקה תתפוס זאת, ומדוע בדיקות החתימה והתאריכים לא יתפסו?
בדיקת סטטוס הביטול (CRL או OCSP). החתימה נשארת תקינה מתמטית והתאריכים עדיין בתוקף, ורק בדיקה נפרדת מול ה-CA מגלה שהתעודה בוטלה מוקדם מהצפוי.
תעודה חתומה עצמית
רבים מניחים שאזהרה על תעודה חתומה עצמית פירושה שהחיבור גלוי לכולם, וזה אינו נכון. תעודה חתומה עצמית (Self-signed) נוצרת ונחתמת במפתח הפרטי של השרת עצמו, בלי רשות מהימנה. מבחינת ההצפנה אין הבדל: מפתחות הסשן הסימטריים מוסכמים כרגיל, והשרת מצליח לחתום בלחיצת היד, כלומר המפתח הפרטי אכן אצלו.
מה שחסר הוא עד חיצוני. כל אחד יכול להפיק תעודה כזו בפקודה אחת לכל שם שיבחר, ולכן בדיקת החתימה שלה מול המפתח שבתוכה דומה למכתב המלצה שאדם כתב לעצמו: הוא עקבי אך אינו מעיד על דבר. הכלל זהה ברשת ארגונית פנימית, ומשתנה רק אם הארגון מפעיל CA משלו ומתקין את תעודת השורש שלה במאגר האמון של המכשירים.
תרחיש 14: שער ה-VPN של החברה ברשת של שדה תעופה
עובד מתחבר מרשת האורחים של שדה תעופה לשער הגישה של חברתו, vpn.firm.example. תוקף ברשת מציג לו תעודה שיצר בעצמו עם אותו שם, כי אף CA מהימן לא יסכים להנפיק תעודה כזו למי שאינו שולט בדומיין.
על המסך של העובד מופיעה אזהרה: השרשרת אינה מגיעה לשורש שבמאגר האמון. השם תואם והחיבור מוצפן, אבל ההצפנה היא מול התוקף. מי שלוחץ "המשך" מוסר את הסיסמה ישירות לצד הלא נכון.
טעויות נפוצות
- ללא חתימת CA, התקשורת עוברת בטקסט גלוי ללא הצפנה. התקשורת מוצפנת, אך זהות השרת שמולכם אינה מאומתת.
- בתוך רשת ארגונית פנימית תעודה חתומה עצמית מתקבלת בלי אזהרה. שרשרת האמון נדרשת בכל רשת, אלא אם שורש פנימי הותקן מראש במכשירים.
- תעודה חתומה עצמית חושפת את המפתח הפרטי של השרת. המפתח הפרטי אינו נמצא בתעודה.
- השרת אינו מוכיח החזקה במפתח הפרטי בתעודה חתומה עצמית. ההוכחה קיימת, והחיבור אכן מגיע לבעל המפתח. הבעיה היא שאין עד חיצוני שיאשר מי האדם או הארגון שמאחורי המפתח הזה.
מה התעודה מוכיחה ב-HTTPS ומה לא
תעודה היא מידע פומבי שאפשר להעתיק, ולכן עצם הצגתה בתחילת TLS Handshake אינו מוכיח שהשרת הוא הבעלים. ההוכחה היא חתימה: השרת חותם במפתח הפרטי על נתוני לחיצת היד, ובתוכם ערך אקראי שהלקוח שלח, והלקוח מאמת במפתח הציבורי שבתעודה. אין בכך שליחה של גיבוב המפתח הפרטי, ואין דרישת סיסמה מהגולש.
רק לאחר השלמת האימות מסכמים הצדדים מפתחות סימטריים להצפנת התעבורה. רמת הבדיקה של ה-CA משתנה לפי סוג התעודה:
| רמת התעודה | מה בדקה הרשות המאשרת |
|---|---|
| DV (Domain Validated) | שליטה בדומיין בלבד |
| OV (Organization Validated) | שליטה בדומיין ואימות זהות הארגון |
| EV (Extended Validation) | בדיקה מורחבת של הארגון ורישומו |
כל רמות האימות מעידות רק על מה שנבדק בהנפקה: אף אחת מהן אינה מבטיחה שהאתר הגון או חף מנוזקות, והתעודה אינה חתימה על תוכן הדפים המוצגים בו.
תרחיש 15: מנעול סגור על דומיין שנרשם הבוקר
הודעת SMS מפנה ל-track-my-parcel.example. בעל הדומיין הוכיח ל-CA ששליטה בו בידיו, קיבל תעודת DV, והאתר, שמחקה חברת משלוחים, מציג מנעול סגור.
המנעול אומר שני דברים בלבד: החיבור לדומיין הזה מוצפן, ומי שמפעיל אותו שולט בו. הוא אינו אומר שהחברה אמיתית, כי רמת DV לא בדקה זהות ארגונית ואיש לא סרק את תוכן הדף.
טעויות נפוצות
- סמל המנעול בדפדפן מבטיח שהאתר אמין וחף מדיוג. תעודת DV מוכיחה רק הצפנה ושליטה בדומיין המסוים שבכתובת.
- בתעודת DV הרשות מאמתת את זהות החברה הרשומה. אימות זהות ארגונית מתבצע בתעודות OV ו-EV בלבד.
- הצגת התעודה עצמה מוכיחה שלשרת יש המפתח הפרטי. התעודה פומבית וניתנת להעתקה; ההוכחה היא חתימה על אתגר בלחיצת היד.
בדקו את עצמכם
מה ההבדל בין התעודה שהדפדפן מקבל מהשרת בתחילת לחיצת היד לבין מה שמוכיח לו שהשרת הוא הבעלים שלה?
התעודה היא מידע פומבי שכל אחד יכול להעתיק. ההוכחה היא חתימה על נתוני לחיצת היד והערך האקראי של הלקוח, שרק מחזיק המפתח הפרטי מסוגל להפיק והלקוח מאמת במפתח הציבורי שבתעודה.
ביטול, דליפות והגנה על המפתח הפרטי
ביטול תעודה: CRL ו-OCSP
לפעמים נדרש לפסול תעודה עוד לפני מועד הפקיעה שלה, למשל עקב גניבת מפתח פרטי. במצב כזה הבעלים מבקש מה-CA לבטל (Revoke) את התעודה, והדפדפנים מבררים זאת בשתי שיטות נפרדות מבדיקת התאריכים (שכן תעודה בתוקף עלולה להיות מבוטלת):
- CRL (
Certificate Revocation List): רשימה מרוכזת של כלל התעודות המבוטלות שהרשות מפרסמת והלקוח מוריד במלואה. - OCSP (
Online Certificate Status Protocol): שאילתה ממוקדת בזמן אמת מול שרת ייעודי (OCSP Responder) לגבי סטטוס של תעודה אחת בלבד, החוסכת הורדת רשימה שלמה ומספקת מצב עדכני.
התשובה של OCSP היא מצב אחד של תעודה אחת: תקינה, מבוטלת או לא ידועה. שאלות אחרות בתהליך האימות מטופלות במקום אחר:
| השאלה | מי עונה עליה |
|---|---|
| הנפקת תעודה חדשה ועדכון תאריכים | בעל האתר וה-CA, בהנפקה מחדש |
| האם השורש מהימן | מאגר האמון שמותקן מקומית |
| הצפנת התעבורה והגיבוב | לחיצת היד ופונקציות הגיבוב, לא פרוטוקול הסטטוס |
| התאמה בין שם לכתובת | בדיקת ה-SAN בדפדפן, ולא השוואת IP מול DNS |
טעויות נפוצות
- OCSP מוריד לדפדפן את רשימת כל התעודות שבוטלו. הורדת הרשימה המלאה היא CRL; ב-OCSP שואלים בזמן אמת על תעודה בודדת.
- שאילתת OCSP מחדשת אוטומטית תעודה שפגה. הפרוטוקול בודק סטטוס ביטול בלבד ואינו מנפיק תעודות.
- OCSP מוודא שתעודת השורש קיימת במאגר האמון. האמון בשורש נובע מהתקנה מקומית מוקדמת במערכת.
בדקו את עצמכם
דפדפן בודק תעודה רק לפי התאריכים שבה. מדוע זה לא מספיק, ואילו שני מנגנונים סוגרים את הפער?
תעודה שעדיין בתוקף עלולה להיות מבוטלת, למשל אחרי גניבת המפתח. מנגנון CRL מוריד רשימה מלאה של תעודות מבוטלות, ו-OCSP שואל בזמן אמת על תעודה אחת.
מפתח פרטי של שרת דלף
ברגע שמפתח פרטי של שרת נחשף לתוקף, נשמטות שתי הגנות מרכזיות: התוקף יכול להתחזות לשרת בלחיצת היד עם התעודה התקפה ולפענח הודעות שהוצפנו למפתח הציבורי התואם. מנגד, מפתח של שרת אינו מפתח של CA ולכן אינו מאפשר לתוקף להנפיק תעודות לאתרים אחרים.
הטיפול בדליפה כולל שלושה צעדים:
- מבקשים מה-CA לבטל את התעודה הקיימת, כך שתסומן ב-
CRLאו ב-OCSP. - יוצרים זוג מפתחות חדש.
- מנפיקים תעודה חדשה עבור המפתח הציבורי החדש.
| צעד חלקי או שגוי | מדוע אינו פותר את הדליפה |
|---|---|
| הנפקת תעודה חדשה לאותו מפתח שדלף | התוקף עדיין מחזיק במפתח הפרטי וימשיך להתחזות |
| הפקת תעודה חדשה בלי ביטול הישנה | התעודה הישנה נשארת תקינה בדפדפנים עד תפוגתה |
| המתנה לפקיעת התעודה | משאירה חלון תקיפה ארוך, והמפתח עצמו אינו פג עם התעודה |
| שינוי סיסמת ניהול או החלפת פורט מ-443 | אינם מבטלים את המפתח שכבר הועתק |
תרחיש 16: מפתח שנדחף בטעות למאגר קוד ציבורי
מפתחת מעלה בטעות את קובץ המפתח הפרטי של שרת האתר למאגר קוד פומבי, ומוחקת אותו בקומיט הבא. ההיסטוריה של המאגר עדיין מחזיקה אותו, ומישהו כבר הספיק לשכפל אותה.
מרגע זה המפתח נחשב דלוף: מי שמחזיק בו יכול להתחזות לאתר בלחיצת היד ולפענח תעבורה שהוצפנה למפתח הציבורי התואם. מחיקת הקובץ אינה מחזירה את הסוד, ולכן מבטלים את התעודה ומנפיקים חדשה על זוג מפתחות חדש.
טעויות נפוצות
- כשתוקף התעודה פג, הסיכון מהמפתח שדלף נעלם מעצמו. המפתח אינו פג עם התעודה, והשארתה פעילה עד הפקיעה מפקירה את המשתמשים.
- בעזרת מפתח שרת שדלף אפשר להפיק מה-CA תעודות לאתרים אחרים. מפתח השרת אינו מפתח חתימה של רשות מאשרת.
- הצפנה ב-RSA נשארת בטוחה גם לאחר העתקת המפתח הפרטי כי היא נשענת על הציבורי. כל ביטחון הפענוח והאימות תלוי בשמירת סודיות המפתח הפרטי.
בדקו את עצמכם
מדוע הנפקת תעודה חדשה על אותו זוג מפתחות אינה מתקנת דליפת מפתח פרטי?
מפני שהתעודה החדשה ממשיכה לקשר את הדומיין לאותו מפתח ציבורי, והמפתח הפרטי התואם כבר נמצא בידי התוקף.
CA שנפרץ ותעודות מזויפות
כאשר רשות מאשרת נפרצת, התוקפים מסוגלים להנפיק בשמה תעודות מזויפות לכל אתר לגיטימי, והדפדפנים מקבלים אותן בלי התראה עד שיצרני הדפדפנים ומערכות ההפעלה שוללים את האמון בתעודות או ברשות כולה.
אירוע כזה פוגע באמון השרשרת, לא במתמטיקה של RSA: מפתחות ארוכים אינם מונעים זיוף תעודה, המפתח הפרטי של הבנק אינו נחשף (ה-CA אינה מחזיקה בו כלל), ואין מדובר בפריצה ל-DNS. גולש שמקבל תעודה מזויפת כזו לא מקבל שום התראה מה-CA ועלול למסור סיסמאות ופרטי חשבון לתוקף.
מקרים של תעודות מזויפות בהיסטוריה נגרמו משלושה גורמים עיקריים: התנגשויות MD5 (2008 והנוזקה Flame ב-2012), פריצה למערכות של רשויות מאשרות, וטעויות הנפקה מצד רשויות.
טעויות נפוצות
- פריצה ל-CA מאפשרת לתוקף לגנוב את המפתחות הפרטיים של כל האתרים החתומים אצלה. המפתחות הפרטיים של האתרים אינם מוחזקים אצל ה-CA.
- תעודה מזויפת שוברת את הצפנת ה-RSA של הבנק. RSA אינו נשבר; התעודה מאפשרת התחזות מול הגולשים דרך שרשרת האמון.
- ה-CA שולחת התראה אוטומטית לגולשים על תעודה מזויפת. אין מנגנון התראה כזה מצד הרשות למשתמשי הקצה.
איפה שומרים מפתח פרטי
כיוון שגישה למפתח הפרטי מאפשרת פענוח והתחזות, אופן האחסון שלו מכריע את רמת האבטחה בפועל:
| מקום האחסון | ההערכה |
|---|---|
| תיקיית האתר שהשרת מגיש לציבור | החמור ביותר: מי שמבקש את הקובץ בכתובת הנכונה יוריד אותו |
| מאגר קוד משותף | מסוכן: כל מי שיש לו גישה לקוד או עותק שלו מקבל גם את המפתח |
| אותו מפתח בכל שרתי הארגון | מסוכן: חדירה לשרת אחד חושפת את כולם |
| קובץ מוצפן עם הרשאות לתהליך השרת בלבד | הרף הסביר בסביבת תוכנה רגילה |
| התקן HSM עם גישה מוגבלת | הטוב ביותר: המפתח פועל בתוך ההתקן, שמבצע חתימה ופענוח בלי להוציא אותו החוצה בטקסט גלוי |
החלפת מפתחות מחזורית (Key Rotation)
Key Rotation היא החלפה מתוכננת של מפתחות ותעודות בלוח זמנים קבוע, גם כשלא קרה דבר. מפתח שנשאר בשימוש שנים צובר הזדמנויות להיגנב, ועותק שלו עלול כבר להימצא אצל מי שלא אמור להחזיק בו: תמונת דיסק ישנה בענן, מחשב נייד של עובד שעזב, שרת שלא עודכן שנים. עם הזמן גם כוח החישוב של תוקפים גדל, ומפתח ישן עלול להפוך לפריץ.
מהחלפה קבועה מרוויחים שני דברים: חשיפה שקטה משפיעה על תקופה קצרה בלבד, וכל סבב מאלץ מעבר לאלגוריתם ולאורך עדכניים. היא אינה מאריכה את המפתח מעצמה, ואינה נחוצה רק לרגולציה או רק למפתחות קצרים. גם החפיפה הקצרה, שבה המפתח הישן והחדש פועלים יחד, זולה בהרבה משנים של מפתח אחד.
טעויות נפוצות
- Key Rotation נועד לרגולציה בלבד בלי תרומה אמיתית לאבטחה. הוא מצמצם בפועל את היקף המידע והזמן החשופים במקרה של דליפה.
- כל סבב החלפה מגדיל אוטומטית את אורך המפתח. אורך המפתח החדש נקבע בעת יצירתו ואינו גדל מעצמו.
- חלון החפיפה בין המפתח הישן לחדש מבטל את יתרון ההחלפה. החפיפה קצרה ומבוקרת, והסכנה שבמפתח קבוע לאורך שנים גדולה ממנה בהרבה.
- מטרת ההחלפה המחזורית היא שמערכות חדשות ימשיכו לעבוד מול פרוטוקול מיושן כמו SSL. המטרה הפוכה: ההחלפה מקרבת מערכות לאלגוריתמים ולגרסאות עדכניים, ואינה שומרת על תאימות לפרוטוקולים מיושנים.
Certificate Pinning
אפליקציית בנקאות בנייד יודעת בדיוק מול איזה שרת היא אמורה לדבר, ולכן היא יכולה לשמור בתוכה מראש את המפתח הציבורי של השרת (או את התעודה שלו). בכל חיבור היא משווה את מה שהגיע לערך השמור. הטכניקה נקראת Certificate Pinning.
מכשיר סומך על עשרות רשויות שורש, ואם אחת מהן נפרצה או טעתה, היא עלולה להנפיק תעודה לדומיין של הבנק. דפדפן רגיל יקבל תעודה כזו כי היא חתומה כדין, ואילו האפליקציה תחסום או תתריע כי המפתח שבה שונה מזה ששמרה.
Pinning מגן מפני תעודה שחתומה כדין אבל הונפקה למי שלא היה אמור לקבל אותה, בגלל פריצה לרשות או טעות הנפקה. ההגנה פועלת ברמת המפתח: הלקוח יודע איזה מפתח הוא מצפה לראות מהדומיין, וכל מפתח אחר נדחה גם אם שרשרת החתימות שלו תקינה. זו שכבה נוספת לבדיקה הרגילה ולא תחליף לה.
בדקו את עצמכם
מדוע דפדפן רגיל מקבל תעודה מזויפת שחתמה עליה CA פרוצה, ואפליקציה עם Pinning אינה מקבלת אותה?
הדפדפן מאמת רק שהשרשרת מובילה לשורש מהימן, ולכן תעודה חתומה כדין עוברת. האפליקציה משווה את המפתח הציבורי שהגיע לזה ששמרה מראש, ומפתח שונה נדחה גם כשהחתימה תקינה.
סיכום
פרק זה חיבר בין שלוש אבני היסוד של אבטחת התקשורת והמידע: פונקציות גיבוב, הצפנה אסימטרית ותעודות דיגיטליות.
גיבוב ו-MD5
- פונקציית גיבוב היא דטרמיניסטית, חד-כיוונית, ללא מפתח ובאורך פלט קבוע, והיא אינה הצפנה.
MD5מפיקה128סיביות (16בתים,32תווי הקס) ומפגינה אפקט מפולת.- היא שבורה להתנגשויות מאז 2004, ושימשה לזיוף תעודה ב-2008 ובנוזקת
Flameב-2012; מציאתPreimageעדיין אינה מעשית. - לכן
MD5מתאימה רק לגילוי שגיאות מקריות ולא מול תוקף. מול תוקף משתמשים ב-SHA-256(256סיביות, ללא התנגשויות מעשיות) או ב-SHA-3, כי גםSHA-1נפסלה בגלל התנגשויות.
גיבוב עם סוד וסיסמאות
- גיבוב גלוי אינו עוצר
MITM. שרשור סוד לפני ההודעה פגיע להתקפתLength Extension, וההגנה התקנית היאHMACאו חתימה דיגיטלית. - באחסון סיסמאות
MD5פסולה כי היא מהירה מדי ומאפשרת מיליארדי ניחושים בשנייה. Saltאקראי וגלוי לכל משתמש מונע טבלאות מוכנות מראש והשוואת סיסמאות זהות, אך אינו מאט ניחוש בודד.- לכן משתמשים באלגוריתמים איטיים:
bcrypt,scrypt,Argon2אוPBKDF2.
RSA
RSA(1977) היא מערכת אסימטרית: מפתח ציבורי(n, e), לרוב עםe = 65537, ומפתח פרטיdשנגזר מ-pו-q.- הביטחון נשען על קושי פירוק
n = p * q, ולכן אפשר לפרסם את המפתח הציבורי בלי חשש.1024סיביות חלש מדי, וממליצים על2048לפחות (3072+לטווח ארוך), בלי להשוות לאורך מפתח סימטרי. - לסודיות מצפינים במפתח הציבורי של הנמען ומפענחים בפרטי שלו.
- לחתימה חותמים על הגיבוב במפתח הפרטי של החותם ומאמתים בציבורי שלו: מקור, שלמות ואי-הכחשה, ללא הצפנה.
- בגלל איטיות ומגבלת אורך משתמשים בהצפנה היברידית:
AESלנתונים ו-RSAלמפתח. Textbook RSAדטרמיניסטי ומאפשר זיוף חתימות, ולכן משתמשים ב-OAEPלהצפנה וב-PSS(אוPKCS#1 v1.5) לחתימה.
תעודות דיגיטליות ושרשרת האמון
- תעודת
X.509קושרת מפתח ציבורי לזהות בחתימתCA. אין בה מפתח פרטי, והיא אינה מצפינה תעבורה. - הבעלים שולח ל-CA קובץ
CSRעם המפתח הציבורי ופרטי הזהות, ללא חתימת CA. החתימה מתווספת רק בתעודה שחוזרת. - האמון נשען על שרשרת: אתר, רשות ביניים ושורש חתום עצמית שמותקן מראש במאגר האמון. מפתח השורש נשמר לא מקוון.
- הדפדפן בודק שרשרת, חתימות, תוקף, שם ב-
SANוביטול (CRLכרשימה מלאה אוOCSPכשאילתה בזמן אמת). כשל מוביל לאזהרה. - תעודה חתומה עצמית מצפינה אך אינה מאמתת זהות, ותעודת
DVמעידה על שליטה בדומיין בלבד.
תפעול מפתחות והגנה עליהם
- אם מפתח של רשות ביניים דולף, מבטלים רק אותה. אם
CAנפרצת, עלולות להיווצר תעודות מזויפות לכל אתר. - דליפת מפתח של שרת מחייבת ביטול התעודה והנפקה של תעודה חדשה על זוג מפתחות חדש.
- על המפתח הפרטי מגינים באמצעות
HSMוהרשאות גישה מצומצמות. Key Rotationמקטינה את חלון הנזק בדליפה שקטה.Certificate Pinningגורמת ללקוח לדחות מפתח לא צפוי, למשל בתעודה מזויפת.