‫שיעור ‪1‬‬

‫עקרונות שעלינו לשמור עליהם בעת העברת מידע‪:‬‬

‫סודיות – לדאוג שהמידע יגיע רק למי שהוא מיועד‪ .‬כשלים‪ :‬מידע שדלף למישהו‬
‫שלישי וכו'‪ .‬דרכים להשגה ‪ -‬קריפטוגרפיה‬
‫שלמות – שהמידע לא יוכל להשתנות בדרך או שאם ישתנה זה יוודע לצדדים‪.‬‬
‫‪ .Tamparing‬כשלים‪ :‬מישהו זדוני שינה את המידע‪ .‬דרכים להשגה – חתימה‬
‫דיגיטלית‪mac ,‬‬
‫זמינות – אליס רוצה שירות מבוב‪ .‬טוד ימנע מאליס את השירותים של בוב‪.Dos .‬‬
‫כשלים‪ :‬תוקף מפיל שרת‪ ,‬מוחק בסיס נתונים‪ ddos ..‬וכו'‪.‬‬
‫‪ - Authenticity‬אותנטיות – אליס שלחה הודעה לבוב וגם מרתה‪ .‬בוב אמור לדעת‬
‫לייחס כל הודעה למי ששלח אותה‪ .‬מרתה מבצעת התחזות‪.masquerading -‬‬
‫כשלים‪ :‬באתר של הילרי הושתל מידע לטובת אובמה‪ .‬ציטוטים מהאינטרנט‬
‫‪ - - Accountability‬לדעת לזהות מי עשה את ההתקפה‪ .‬אפשר למצוא מי עשה‬
‫אבל אי אפשר להאשים אותו‪ .‬כדי להאשים צריך ‪.non repudation‬‬
‫‪ – Access control‬ניהול הרשאות ‪ .‬זום יודעים קצת על המייל שלי אבל לא הכל הם‬
‫יודעים‬
‫‪ -Non repudiation‬אף אחד לא יוכל לטעון שלא הוא ביקש שירות מסויים או עשה‬
‫משהו‪.‬‬

‫סוגי תוקפים –‬
‫‪.1‬‬
‫משתמש בלי ידע רחב – משתמש עשה משהו בטעות‪.‬‬
‫‪ .2‬ילדי סקריפטים‪ -‬אנשים שלמדו בעצמם ‪ ,‬ישתמשו בדברים מהרשת‪ ,‬בשבילם‬
‫זה משחק‪..‬‬
‫‪ .3‬כובע שחור – תוקף מקצועי למטרות כסף וכו'‬
‫‪ 4‬אקטיביסטים – בין ילדי סקריפטים ל כובע שחור – תוקפים למטרות אקטיביסטיות‪.‬‬
‫‪ .5‬כובע לבן – חוקרי אבטחה למטרות עבודה‪ .‬אנשים טובים שמועסקים בחברות‬
‫על מנת להגן על המידע‪.‬‬

‫שיעור ‪2‬‬
‫הצפנה סימטרית‬
 ‫איך נעזור למה שמחפשים‪:‬‬
‫‪ - - Confidentiality‬הצפנה‪ ,‬החלפת מפתח‪,‬‬
‫‪ - - Integrity‬פונקציית הש קריפטוגרפית‬
‫‪ - Authenticity‬חתימה דיגיטלית‬
‫‪ - - Authentication‬אימות באפס מידע‪ ,‬אלגוריתמים‬
‫‪ - Non repudiation‬חתימה דיגיטלית‪ ,‬טביעה דיגיטלית‬

‫‪ - - Plain text‬המידע הגלוי המקורי‬

‫‪- Cipher text‬המידע לאחר המוצפן‬
‫בהצפנה סימטרית לשולח ולמקבל יש אותו מפתח ואפשר להעביר את ההודעה‬
‫המוצפנת ברשת גלויה‪ .‬איך ישתפו מפתח? או שפעם אחת הם יפגשו או עם‬
‫הצפנה אסימטרית‪.‬‬
‫המקבל יכול להצפין בחזרה ולשלוח גם‪.‬‬
‫האלגוריתמים ידועים לכולם‪ .‬זוהי הצפנה שאפשר להתגבר עליה רק עם ‪brute‬‬
‫‪. force‬‬
‫בהצפנה סימטרית יש ‪ 2‬סוגים – סטרים ובלוק‪.‬‬
‫חוזק של הצפנה – אם במפתח יש ‪ 10‬ביטים אז יש ‪ 2‬בחזקת ‪ 10‬סיסמאות‬
‫אפשריים‪.‬‬
‫איך התוקף יתקוף? יוריד את מרחב הסיסמאות‪ ,‬יגלה תבנית בהודעה המוצפנת‪,‬‬
‫יזהה חלקים של בלבד של ההודעה המקורית‪ ,‬ישנה קצת את המוצפן ואז יפענח‪.‬‬
‫סוגי התקפות –‬
‫לתוקף יש רק הודעה מוצפנת ואת האלגוריתם‬ ‫‪.1‬‬
‫לתוקף יש הודעות מוצפנות וגם מקוריות‪ .‬האם זה יעזור לו למצוא הודעה‬ ‫‪.2‬‬
‫אחרת?‬
‫לתוקף יש את ההודעה המוצפנת ויש לו גם אפשרות להצפין הודעה‬ ‫‪.3‬‬
‫כלשהי‪.‬‬
‫לתוקף יש את ההודעה המוצפנת והוא יכול לפענח איזה הודעה שהוא רוצה‬ ‫‪.4‬‬
‫חוץ מהמוצפנת‪.‬‬
‫לתוקף יש את ההודעה המוצפנת והוא יכול גם לפענח וגם להצפין מה‬ ‫‪.5‬‬
‫שהוא רוצה‪ .‬האם הוא יכול ללמוד מזה משהו על המפתח?‬
‫צופן קיסר – מזיזים כל אות ב ‪ n‬צעדים‪ 26 .‬מפתחות‪.‬‬
 ‫מונואלפאביתיכ ‪ -‬משתמשים בפרמוטציה סודית‪ .‬כמה מפתחות? ‪ 26‬עצרת‪.‬‬
‫הבעיה? אפשר לתקוף באמצעות הסוג הכי פשוט של ההתקפה ) מס ‪ )1‬באמצעות‬
‫חישוב תדירויות‪.‬‬
‫ורנהם – הפליין טקסט הוא אוסף ביטים ונעשה לו ‪ xor‬עם מחרוזת רנדומלית של‬
‫ביטים‪ .‬אפילו ‪ brute force‬לא יעזור לפרוץ פה כי הפורץ לא ידע מה הגיע‬
‫מהמפתח‪ .‬הבעיה‪ :‬קשה לנהל כי צריך לייצר מפתח שונה עבור כל הודעה ושאורך‬
‫המפתח צריך להיות כאורך ההודעה‪.‬‬
‫סוג נוסף – פרמוטציה של המילה והמפתח יהיה הסדר האמיתי של האותיות‬
‫אניגמה‪ -‬שרשור של פרמוטציות‪ .‬המפתח – איזה רוטורים באיזה מקום ובאיזה סדר‪.‬‬
‫הגדרה – מהי סכמת הצפנה טובה? שהקשר בין המקורי למוצפן עובר רק דרך‬
‫המפתח‪.‬‬
‫בנוסף – שהמוצפן יתנהג כמו משהו רנדומלי‪.‬‬
‫בלוק – כל בלוק מוצפן בפני עצמו‪ .‬אם הבלוק האחרון לא בגודל המוקצב ? נרפד‬
‫באפסים ובבית האחרון נגיד כמה לזרוק בכל הודעה‪ .‬במקרה זה אם החלוקה‬
‫מסתדרת בדיוק אז צריך להוסיף בלוק מיוחד ולכתוב בו שזורקים את כולו‪ .‬אפשר‬
‫גם לשלוח יחד עם ההודעה את כמה לזרוק אבל לא להצפין את זה עם ההודעה‬
‫כי צריך לדעת את זה לפני הפענוח‪.‬‬
‫בלוק בגודל ‪ n‬ביטים יש לו מפתח בגודל( ‪ 2‬בחזקת ‪ ) n‬עצרת‪ .‬בפועל קובעים‬
‫בלוק לפי המפתח הרצוי‪ .‬לוקחים הודעה ומחלקים לחלקים בגודל ‪ n‬ביטים‬
‫ומצפינים כל בלוק‪ .‬מפתח בגודל ‪ k‬ונקבל בלוק מוצפן בגודל ‪ .n‬הבעיה שאם יש‬
‫טעות בביט אחד זה ידפוק הכל?‬
‫להצפנת בלוק יש כמה חלקים – החלפה – מקבל אוסף ביטים ומחזיר אוסף ביטים‬
‫אחר שנקבע מראש‪ .‬פרמוטציה – אותם ביטים שקיבלת תחזיר בסדר אחר‪ .‬דיפיוזן‬
‫– כל ביט מתפזר על כל ההודעה כלומר אם שיניתי ביט אחד בהודעה המקורית‬
‫כל ההודעה המוצפנת תשתנה‪ .‬קונפיוזן – שלא יהיה קשר בין הפליין לסייפר‪.‬‬
‫סטרים יותר מהיר אבל יש בו חולשות ולכן משתמשים יותר בבלוק‪.‬‬

‫שיעור ‪3‬‬
‫נמשיך עם בלוקס – אם יש שאריות ‪ :‬כמו שראינו לעיל‪.‬‬
‫‪ :Ecb‬המודל הכי פשוט‪ .‬מחלקים לבלוקים מצפינים‪ .‬וגם המקבל מפענח כל אחד‬
‫בנפרד‪ .‬הבעיה‪ :‬אם יש חזרות אז גם בקובץ המוצפן יהיה חזרות כלומר הרבה‬
‫בלוקים מוצפנים יחזרו על עצמם‪ .‬כמו עם הפינגווין‪ .‬מתי כן אפשר להתשמש?‬
‫כששולחים רק בלוק אחד למשל שאז אין חזרות‪ ..‬או אם המידע הוא רנדומלי‬
‫לחלוטין‪ .‬כדי להתגבר על זה נשתמש ב ‪ cbc‬שיודע למנוע חזרות‪.‬‬
‫‪ - :Cbc‬שרשור בלוקים‪ .‬לפני שמצפינים עושים ‪ xor‬עם הבלוק המוצפן הקודם ואת‬
‫מה שיצא מצפינים‪ .‬לבלוק הראשון נותנים דאטה חיצוני לעשות איתו ‪ .xor‬הוא לא‬
‫חייב להיות רנדומלי ולא חייב להיות סודי‪ .‬הוא צריך להיות שונה בכל הודעה‪ ,‬אבל‬
‫המקבל צריך לדעת אותו‪ .‬המקבל בהתאמה לוקח את ההודעה המוצפנת מפענח‬
‫ועושה לה ‪ xor‬עם ‪ iv‬ומקבל את ההודעה הראשונה‪ .‬ואז מקבל את ההודעה‬
‫המוצפנת השנייה‪ ,‬מפענח ועושה לה ‪xor‬‬
‫עם ההודעה המוצפנת הקודמת וכך מקבל את ההודעה השנייה וכן הלאה‪.‬‬
‫חסרונות‪ :‬אין הצפנה במקביל‪ ,‬כי חייב בכל שלב לחכות להודעה הקודמת‪ .‬אבל‬
‫ניתן לפענח במקביל‪ .‬אם יש ביט אחד דפוק זה משפיע גם בביט אחד על ההודעה‬
‫הבאה‪ .‬ניתן לפענח גם מאמצע הדיסק‪ .‬נשים לב שאפילו בבלוק אחד ‪ cbc‬עדיף‬
‫על ‪ ebc‬כי יש לו ‪.iv‬‬
‫‪ - :Ctr‬גם פה יש ‪ iv‬שמשתנה מהודעה להודעה‪ .‬הוא מתפקד כמו מונה‪ .‬מצפינים‬
‫את ה ‪ iv‬כלומר בכל בלוק מצפינים את ‪ iv +1‬ומקבלים הודעות חדשות שעושים‬
‫להם ‪ xor‬עם ההודעה המקורית וכך מקבלים הודעה מוצפנת‪ .‬המקבל עובד‬
‫בהתאמה קודם כל מצפין את ‪ iv‬ואז עושה ‪ xor‬עם ההודעה המוצפנת ומקבל את‬
‫ההודעה המקורית‪ .‬מי שמתבונן מהצד אמנת יודע את ‪ iv‬ואת האלגוריתם אבל אין‬
‫לו את המפתח‪ .‬יתרונות‪ :‬מהיר כי המקבל לא צריך את הסייפר כדי להתחיל‬
‫לפענח‪ .‬אלגוריתם הפענוח ואלגוריתם הפענוח הם אותו האלגוריתם‪ .‬בגלל שזה‬
‫מהיר ואפשר להתחיל לפענח מהאמצע זה טוב להזרמת וידאו‪ .‬טעויות הן מינימלות‬
‫רק מה שהשתנה ישתנה‪ .‬ניתן להצפין ולפענח בצורה מקבילה‪.‬‬
‫עד עכשיו דיברנו על השילוב של כמה בלוקים אבל איך מצפינים כל בלוק בנפרד?‬

‫רשתות פייסטל – צריך לדעת? הפונקציה ‪ f‬לא צריכה להיות הפיכה כי יש ‪.xor‬‬
‫מחלקים את הבלוק לשני חלקים שווים ימין ושמאל‪ .‬כל בלוק מוצפן בנפרד‪ .‬איך‬
‫נצפין? באמצעות רשתות פייסטל‪ .‬ניתן לקבוע גדלים שונים לבלוקים ככל‬
‫שהבלוק יותר גדול זה יותר מאובטח אבל יותר איטי‪ .‬ניתן לקבוע גדלי מפתחות‬
‫אבל ככל שהמפתח יותר גדול המערכת יותר איטית והמערכת יותר בטוחה‪ .‬ניתן‬
‫לקבוע את מספר הסיבובים וככל שיהיה יותר גדול יהיה יותר מאובטח אבל יותר‬
‫איטי‪ .‬ניתן לשנות את ‪. f‬‬
‫סוגי הצפנת בלוק‪:‬‬
‫‪ - - Des‬כיום נחשב פרוץ וחלש‪ .‬בלוק ‪ 64‬ביט מפתח ‪ 56‬ביט מבוסס על פייסטל‪ .‬יש‬
‫‪ 16‬סיבובים ויש פרמוטציה התחלתית שניתן להפוך אותה‪ .‬יש פרמוטציה בסוף‪ .‬זה‬
‫לא עוזר לאבטחה וזה לא סוד אלא רק המפתח הוא הסוד‪ .‬המפתח מחולק לשתי‬
‫מפתחות של ‪ 28‬ביט ועם כל מיני תזוזות בכל סיבוב יש מפתח של ‪ 48‬ביט‪ .‬בכל‬
‫סיבוב לפונקציה מכניסים את המפתח ומריצים את ‪ f‬על החצי בלוק‪ .‬חולשות‪:‬‬
‫מפתח קטן‪ .‬יש מפתחות חלשים וחצי חלשים‪ .‬מה הפתרון למפתח חלש? להגדיל‬
‫ופה נכנס ה ‪.double des‬‬
 ‫‪ - Double – des‬חסרון‪ :‬כמו בכל דאבל של הצפנה סימטרית‪ :‬ניתן לפרוץ את‬
‫המפתחות כך‪ :‬בהנחה שיש שלך הודעה מוצפנת אחת ואת הפענוח שלה‪ ,‬קח את‬
‫כל האפשרויות למפתח הראשון והצפן את הפליין עם כל אחד מהמפתחות ושמור‬
‫את כל האפשרויות בטבלה‪ .‬כעת פענח את ההודעה המוצפנת באמצעות כל אחד‬
‫מהאפשרויות למפתח השני‪ .‬עבור כל תוצאה השווה ובדוק האם היא נמצאת‬
‫בטבלה‪ .‬אם היא נמצאת אז מצאת את המפתח הראשון והשני‪.‬‬
‫מה הפתרון?‬
‫‪ Triple -des : 168‬ביטים‪ .‬מצפינים עם הראשון מפענחים עם השני ומצפינים שוב עם‬
‫השלישי‪ .‬כך ניתן להשתמש במפתח אחד לכולם ולדמות ‪ des‬רגיל במקרה‬
‫הצורך‪.‬‬

‫‪ -- Aes‬מחליף את ‪ .des‬ריינדל‪ :‬עובד עם סיבובים‪ ,‬פרמוטציות‪ ,‬סיבובים‪ .‬מפתחות –‬

‫‪ .256 ,192 ,128‬מהמפתח הראשי גוזרים מפתח עבור כל סיבוב‪ N .‬סיבובים‪ .‬הסיבוב‬
‫האחרון שונה מהראשונים‪ .‬מס הסיבובים נקבע לפי גודל המפתח‪ .‬יש כמה שלבים‪:‬‬
‫כל בייט נכנס לטבלה ויוצא בייט אחר במקומו כמו ‪ .sbox‬השלב הבא החלפת‬
‫שורות כלומר בכל שורה מזיזים בייט אחד יותר מהשורה הקודמת‪ .‬השלב הבא‬
‫הכפלה של עמודה בווקטור קבוע‪ .‬השלב הבא עשוים ‪ xor‬לכל בייט עם הבייט‬
‫המתאים במפתח‪ .‬צריך לראות סרטון‪ .‬לדעת איך להריץ?‬

‫שיעור ‪4‬‬
‫הצפנה סימטרית – כעת נעבור לסטרים סייפר‪.‬‬
‫ורנהם – עושים לכל ביט ‪ xor‬עם ביט אחד במפתח‪ .‬ניתן להשתמש במפתח אחד‬
‫אינסופי שאף פעם לא חוזר על עצמו וזה נקרא ‪ . one time pad‬במקרה זה אסור‬
‫להשתמש פעמיים באותו מפתח כי אז אפשר לעשות ‪ xor‬לשתי הודעות מוצפנות‬
‫אחד עם השני ולקבל שילוב של שתי ההודעות המקוריות כלומר המפתח נעלם‪.‬‬
‫ניתן גם להשתמש בפסאודו אקראי שזה אומר בהינתן סיד קצר מקבלים מספר‬
‫ארוך שנראה כמו אקראי אבל הוא לא באמת אקראי כי הוא תוצאה של הסיד‬
‫ומישהו אחר שיכניס אותו סיד יקבל אותו מספר ארוך‪ .‬אז מכניסים סיד ומקבלים‬
‫מספר ארוך פסאודו אקראי שעושים לו ‪ xor‬עם ההודעה המקורית ומקבלים הודעה‬
‫מוצפנת‪.‬‬
‫מחולל פסאודו אקראיים‪:‬‬
‫הדרישה היא שלא נוכל לחזות את הביט הבא‪.‬‬

‫סטרים סייפר הוא יותר פשוט ומהיר מבלוק סייפר‪.‬‬

‫‪ - Rc4‬לא נדבר עליו‪.‬‬
 ‫הצפנה אסימטרית‬
‫הבעיה בסימטרית היה מודל הפצת המפתחות‪ .‬להרבה אנשים צריך המון מפתחות‪.‬‬
‫אסימטרית‪:‬‬
‫פונקצית הצפנה ‪ e‬פונקציית פענוח ‪ . d‬מפתח ‪ 1‬ומפתח ‪ .2‬מצפינים עם מפתח ‪1‬‬
‫ומפענחים עם מפתח ‪ .2‬זה אומר שאם המצפין איבד את ההודעה המקורית ואיבד‬
‫אותה הוא לא יכול לפענח את ההודעה של עצמו‪ .‬בוב מייצר מפתח ‪ 1‬ומפתח ‪2‬‬
‫והוא רוצה שאליס תשלח לו הודעה‪ .‬אז הוא נותן לה מפתח ‪ ( .1‬אפשר בצורה‬
‫גלויה כלומר אפשר שאנשים אחרים ידעו אותו)‪ .‬אליס מצפינה עם מפתח ‪ 1‬ועכשיו‬
‫רק בוב יכול לפענח את ההודעה כי רק לו יש את מפתח ‪ .2‬אם לתוקף יש את‬
‫מפתח ‪ 1‬ואת הסייפר זה לא עוזר לו‪ .‬מפתח ‪ 1‬זה המפתח הציבורי ומפתח ‪ 2‬זה‬
‫המפתח הפרטי‪ .‬אם בוב רוצה לדבר עם מישהו אחר הוא יכול לתת לו את אותו‬
‫מפתח שהוא נתן לאליס‪ .‬זה שלאליס יש את המפתח של מישהו אחר ואת הסייפר‬
‫שלו זה לא עוזר לה כי היא לא יכולה לפענח עם במפתח הציבורי‪ .‬ולכן ל ‪ n‬אנשים‬
‫מספיק ‪ n‬זוגות מפתחות ולא ‪ n‬בריבוע ‪.‬‬
‫האינטרנט וכל עולם הקניות ברשת מבוסס על אסימטרית‪.‬‬
‫פעולות אסימטריות‬
‫קל לעשות בכיוון אחד קשה לעשות בכיוון השני‪ .‬למשל להכפיל זה קל אבל‬
‫פקטורינג זה קשה‪ .‬משתמשים באריתמטיקה של מודולו‪ .‬כמו בשעון שזה מודול‬
‫‪.12‬‬
‫‪ - - Dsl‬אם נתון ‪ g,x,p‬אז קל למצוא את ‪ : y‬מכפילים את ‪ g‬בעצמו ‪ x‬פעמים‪.‬‬
‫ועושים מודולו ‪ p‬ומצאנו את ‪.Y‬‬
‫הבעיה אם נתון ‪ g,p,y‬וצריך למצוא את ‪ : x‬זה קשה‪ .‬נאיבי‪ :‬לנסות את כל‬
‫האפשרויות‪ .‬יותר טוב‪ :‬יש אלגוריתם כלשהו לזה‪.‬‬
‫לכן תכלס ‪ dsl‬זה בעיה קשה‪ .‬גם בגרף ניתן לראות שזה בעיה קשה‪.‬‬

‫דוגמא ראשונה‪ :‬דיפי – הלמן‪ -‬זהו לא אלגוריתם הצפנה אלא סכמה לקביעת‬
‫מפתח סימטרי משותף בין ‪ 2‬אנשים כלומר להחלפת מפתח וזה מבוסס על ‪. dsl‬‬
‫אליס ובוב מעוניינים להחליף מפתח ביניהם מבלי להיפגש כלומר עוברים ג=דרך‬
‫משהו לא סודי‪ .‬אז הם קובעים צבע צהוב משותף‪ .‬כל מי שרוצה יכול לדעת אותו‪.‬‬
‫בנוסף לבוב יש צבע סודי שרק הוא יודע – טורקיז‪ .‬וגם לאליס יש מפתח סודי שרק‬
‫היא יודעת – אדום‪ .‬בוב מערבב את הפומבי עם הסודי שלו ושולח את המעורבב‬
‫דרך הערוץ הפומבי לאליס‪ .‬אותו דבר אליס עושה‪ .‬כעת כל אחד מהם מוסיף‬
‫לצבע שקיבל את הצבע הסודי שלו‪ .‬יצא שלשניהם יצא אותו צבע חום‪ .‬כי סך הכל‬
‫שני הצדדים חיברו את אותם הצבעים‪.‬‬
‫למה מי שראה בדרך לא יצליח לפרוץ? הוא יודע את צהוב‪ .‬הוא לא יודע את‬
‫הסודי אבל רואה בערוץ המשותף את הצבע שהם שלחו אחד לשני‪ .‬הוא לא יגיע‬
‫לעולם לחום כי אין לו את הסודי שמשולב בחום‪ .‬נזכיר שקשה להפריד צבעים‪ ,‬כמו‬
‫בעיית ה ‪.dsl‬‬
‫בעולם המספרים ‪:‬‬
‫אליס ובוב מסכימים על ‪ g‬ו ‪ p‬שכולם יודעים‪ .‬אליס בוחרת מספר סודי ‪ a‬ובוב בוחר‬
‫מספר סודי ‪ . b‬אליס שולחת לבוב ‪ g‬בחזקת ‪ a‬מודולו ‪ P‬ובוב שולח לאליס ‪g‬‬
‫בחזקת ‪ b‬מודולו ‪ . p‬כעת אליס מחשבת ‪ k :‬היא לוקחת מה שקיבלה מבוב‬
‫ומעלה אותו בחזקת המספר הסודי שלה‪ .‬אותו הדבר בוב עושה עם המספר הסודי‬
‫שלו וככה הם קיבלו שניהם את אותו המספר ובעצם החליפו סיסמא בינהם מבלי‬
‫להיפגש‪.‬‬
‫למה זה עובד? זה שיש לפורץ את ‪ g‬בחזקת ‪ a‬מודולו ‪ p‬ואת השני זה לא עוזר לו‬
‫למצוא את ‪ a‬או ‪ b‬כי זה בעיית ‪.dsl‬‬
‫השאלה האם בהינתן שתי ההודעות הגלויות הוא יכול לשלב ולמצוא את‬
‫הסיסמא? לא‪ .‬אבל זה שהוא לא יכול זה לא בגלל ‪ dsl‬אלא בגלל הנחה אחרת‬
‫שקוראים לה ‪ cdh‬שאנו מניחים שהיא קשה‪.‬‬
‫בעיה בדיפי הלמן ‪ -‬אמנם בטוח מפני האזנות אבל אין זיהוי‪- ))autentucation‬‬
‫כלומר בוב לא יודע בוודאות שאליס נמצאת בצד השני‪ .‬כלומר יש בעיה של איש‬
‫באמצע כך‪ :‬אליס פונה לבוב ולמעשה מדברת עם הפורץ ובהתאמה כך גם בוב‪.‬‬
‫אליס שולחת לבוב את ‪ g‬בחזקת ‪ a‬מודול ‪ P‬והתוקף שומר את זה לעצמו ובמקום‬
‫זה שולח לבוב את ‪ g‬בחזרת ‪ e‬מודול ‪P‬‬
‫‪ .‬אותו הדבר עם בוב‪ .‬כעת לתוקף יש מפתח משותף עם אליס ועוד מפתח נפרד‬
‫משותף עם בוב‪ .‬כעת כל שאליס שולחת לבוב התוקף יכול לפענח לקרוא ואז‬
‫להצפין מחדש במפתח שלו ושל בוב ולשלוח לבוב‪ .‬מה הפתרון? מנגנון אימות ‪.‬‬

‫‪ - Rsa‬מבוסס על בעיות קשות של פקטורינג ועל גילוי שורש בעולם של מודלו‪ .‬זה‬
‫מתבסס על הרעיון שלמצוא שורש בעולם של מודולו זה קל אם יודעים את‬
‫הפקטורינג של המודולו אבל קשה אם לא‪ .‬מנגנון‪ :‬אליס רוצה שבוב יוכל לשלוח‬
‫לה הודעות‪ .‬היא לוקחת ‪ 2‬מספרים ראשוניים ‪ p‬ו ‪ q‬סודיים‪ .‬מחשבת מכפלתם‬
‫שתהיה ‪ n. N‬הוא המפתח הפומבי‪ P .‬ן ‪ q‬הם סודיים‪ .‬כעת אם בוב רוצה לשלוח לה‬
‫הודעה הוא מעלה את הפליין טקסט בחזקת ‪ d( d‬גם ידוע לכולם) מודלו ‪ n‬ומקבל‬
‫סייפר ‪ .c‬איך צפענחים? צריך להוציא שורש מסדר ‪ d‬של ‪ .n‬רק אליס יכולה לעשות‬
‫את זה כי רק היא יודעת את הפקטורינג של ‪.n‬‬
‫אוילר‪ :‬פי של ‪ n‬הוא מספר המספרים שקטנים מ‪ n‬וזרים לו‪ .‬עבור ‪ n‬ראשוני פי יהיה‬
 ‫‪.n-1‬‬
‫נשים לב גם ש עבור ‪ n=pq‬כאשר ‪ p,q‬ראשוניים נקבל שפי של ‪ n‬יהיה‬
‫‪ p-1‬כפול ‪.q-1‬‬

‫באלגוריתם לןקחים ‪ e‬שצריך להיות זר לפי של ‪ n‬כלומר זר ל ‪ p-1‬כפול ‪. q-1‬‬

‫‪ E‬יהיה בדרך כלל מספר ראשוני קטן‪.‬‬
‫כעת צריך למצוא את ‪ d‬שהוא ההופכי של ‪ e‬מודולו פי של ‪ . n‬כלומר ‪ e‬כפול ‪d‬‬
‫יהיה שווה ‪ 1‬מודולו ‪ n‬והרעיון הוא שאם יש לנו את פי של ‪ n‬אז נוכל למצוא את ‪d‬‬
‫בעזרת אוקלידס כלומר אנו צריכים לדעת את ‪ p‬ו ‪. q‬‬
‫אז כרגע המפתח הציבורי הוא ‪ n,e‬והמפתח הפרטי הוא ‪.d‬‬
‫הנחה‪ :‬אם יש את ‪ n,e‬קשה למצוא את ‪ d‬ואת ‪ p‬ואת ‪ q‬ואת פי של ‪.n‬‬
‫אז איך מצפינים? לוקחים את הפליין ומעלים בחזקת ‪ e‬ועושים מודולו ‪ n‬ומקבלים‬
‫את ‪. c‬‬
‫איך מפענחים? לוקחים את ‪ c‬מעלים בחזקת ‪ d‬ועושים מודולו ‪. n‬‬
‫למה זה מאובטח? מפני ‪ : known plain text‬זוהי למעשה בעיית ה ‪ dsl‬שהראינו‬
‫שהיא קשה‪.‬‬
‫בהינתן המפתח הפומבי ‪ :‬זו בעיה קשה כי צריך את פי של ‪.n‬‬

‫מה שראינו עד עכשיו נקרא ‪ plain rsa‬ויש בזה בעיות‪:‬‬

‫אם נצפין הודעה ‪ 1‬והודעה ‪ 2‬ונכפיל את התוצאות ואז נצפין נקבל הודעה חוקית‬
‫אחרת שהוצפנה‪ .‬כלומר יש פה בעיה שבעזרת ‪ 2‬הודעות מוצפנות ניתן לייצר‬
‫הודעה חדשה מוצפנת ללא שום גישה למפתח‪.‬‬
‫בעיה ‪ :2‬אם יש שרת שלא מוכן לפענח חלק מההודעות‪ ,‬ניתן לתחמן אותו בצורה‬
‫מתמטית כך שהוא יחשוב שאת ההודעה הזו הוא אמור לפענח‪.‬‬
‫בעיה ‪ rsa :3‬זה דטרמניסטי ואפשר לקחת הודעה מוצפנת ולשלוח לשרת ולראות‬
‫למה השרת הצפין ולהשוות למוצפן שלי כלומר חסר פה רכיב של אקראיות ‪.‬‬

‫הפתרון לכל הבעיות הללו זה להוסיף פדינג כלומר להודעה שאני רוצה להצפין‬
‫אני יוסיף קבוע ותבנית ומספר רנדומלי‪ .‬איך התוספות הללו עוזרות? לראות‪.‬‬
‫סטנדרטים – לדלג‪.‬‬
 ‫איך עובד ‪ rsa‬בפועל? מפתח בגודל ‪ 1024‬עד ‪ 2048‬ביט‪ .‬כלומר זה הסדר גודל‬
‫של ‪ n‬ושל ‪ . d‬איך לייצר מפתח? מגרילים ‪ 1023‬ביטים ובודקים אם המספר הוא‬
‫ראשוני‪ .‬כך עבור ‪ 2‬המספרים‪.‬‬
‫‪:Authentication‬‬
‫איך בשימוש ב ‪ rsa‬אליס יכולה לדעת שהיא מתקשרת עם בוב? בהינתן ‪ n,e‬יש רק‬
‫‪ d‬אחד שאותו רק בוב יודע‪ .‬אז אליס שולחת לבוב מספר רנדומלי ‪ r‬שקבעה‬
‫עכשיו ובוב מפענח כלומר מעלה אותו בחזקת ‪ d‬מודלו ‪ . n‬ושלוח את התשובה‬
‫לאליס וכעת אליס מפענחת עם המפתח הציבורי כלומר להעלות את התשובה‬
‫בחזקת ‪ e‬מודולו ‪ n‬ולצפות לקבל את ‪ .r‬אם באמת קיבלה את ‪ r‬אז בוב הוא בוב‬
‫באמת‪.‬‬
‫אל – גמל ‪ :‬לדלג‪.‬‬

‫שיעור ‪5‬‬

‫בהצפנה סימטרית אם יש ‪ n‬אנשים שרוצים לתקשר כולם עם כולם אז צריך ‪n‬‬

‫כפול ‪ n-1‬לחלק לשתיים ‪ .‬כלומר כל אחד מהאנשים צריך לתקשר עם ‪n-1‬‬
‫אנשים‪ .‬כלומר כל אחד צריך להחזיק ‪ n-1‬מפתחות‪ .‬באסימטרית עבור ‪ n‬אנשים‬
‫צריך ‪ n‬זוגות מפתחות כלומר ‪ n‬פומביים ו ‪ n‬פרטיים ‪ .‬כל אחד יחזיק מפתח פרטי‬
‫לעצמו לפענוח ומפרסם את הפומבי שלו להצפנה ‪ .‬כל מי שרוצה לדבר איתי יצפין‬
‫לי באמצעות אותו מפתח ציבורי‪.‬‬
‫סודיות כיסינו בהצפנה סימטרית‪ /‬אסימטרית ‪ .‬היום נדבר על שלמות ‪ .‬ועל‬
‫‪.authenticity‬‬
‫לשלמות נשתמש בהש קריפטוגרפית ובחתימות דיגיטליות‪.‬‬
‫נדבר על שלמות‪:‬‬
‫אליס רוצה לשלוח לבוב הודעה‪ .‬איך נדאג שבוב יוכל לוודא שההודעה הגיע‬
‫בשלמות כלומר שלא שינו אותה אלא מה שנשלח הגיע?‬
‫נעשה תג שאליס תחשב באמצעות פונקציה ואותו תשלח עם ההודעה‪ .‬כאשר בוב‬
‫יקבל הודעה הוא יריץ אלגוריתם לבדיקה אוקיי או לא‪ .‬אנו רוצים שהתג יהיה קטן‬
‫יחסית ומצד שני בטוח‪.‬‬
‫פונקציית הש מקבלת מספר מאורך כלשהו מ ‪ n‬ומחזירה משהו קבוע מתחום קטן‬
‫יותר‪ .‬זוהי פונקציה לא הפיכה כי בוודאות שתי דברים ימופו לאותו קבוע אז‬
‫הפונקציה לא חד חד ערכית‪.‬‬
 ‫מה נדרוש מהש קריפטוגרפית? שיהיה קל לחשב‪ .‬שבהינתן תוצאה של הש לא‬
‫נוכל למצוא עוד קלט שיתן אותו תוצאה לאחר שנריץ עליו את ההש‪ .‬שבהינתן‬
‫קלט ופלט לא נוכל למצוא קלט נוסף שיתן אותו פלט‪ .‬שלא יהיה ניתן למצוא שתי‬
‫קלטים שיתנו אותו פלט‪ .‬שהפלט יראה כמספר רנדומלי‪ .‬שיהיה ‪ diffusion‬ו‬
‫‪.confusion‬‬
‫‪ – Check sum‬זה לא הש! כי הוא לינארי כלומר אפשר לעשות ‪ xor‬ולשבור אותו‪.‬‬
‫וגם בהינתן קלט ופלט ניתן למצוא קלט נוסף שיתן אותו פלט‪.‬‬
‫איך בונים הש? צריך לדחוס הודעה ארוכה לגודל קבוע וצריך לבנות סכמת מיפוי‪.‬‬
‫מרקל ‪-‬דמגרד – חילקו את ההש לחלקים‪ .‬הפונקציה מקבלת חלק מהקלט בכל‬
‫שלב ונותנת חלק מהפלט‪.‬‬
‫איך משתמשים בהש?אם בוב רוצה לוודא שההודעה הגיעה כמו שצריך‪ :‬אליס‬
‫תחשב הש על ההודעה ותוסיף אותו להודעה ותשלח לבוב‪ .‬בוב יחשב הש על‬
‫ההודעה ומצפה לקבל כמו שאליס שלחה‪ .‬אם מתאים ההודעה לא השתנתה‪.‬‬
‫איך אפשר לתקוף?‬
‫ברוט פורס‪ :‬טווח קלטים אינסופי‪ ,‬יהיו התנגשויות כתלות באורך הפלט‪ .‬אם יש ‪2‬‬
‫ביטים יש ‪ 4‬אפשרויות ובאופן כללי צריך עבור ‪ m‬ביטים בפלט ‪ ,‬צריך ‪ 2‬בחזקת ‪m‬‬
‫אופציות כדי לקבל התנגשות וודאית‪.‬‬
‫סוג אחר של התקפה – למצוא שני הודעות עם אותו פלט ‪ :‬התוקף יכול למצוא‬
‫הודעה שנותנת אותו הש ואז לשלוח אותה עם ההש והמקבל לא ידע שמשהו‬
‫ישתנה‪ .‬כמה קשה למצוא הודעה כזו? בעקבות פרדוקס יום ההולדת – שורש של‬
‫‪ 2‬בחזקת ‪. m‬‬
‫לכן כדי לדמות חוזק של ‪ 128‬ביט צריך פלט בגודל ‪ 256‬ביט‪.‬‬
‫סוגי התקפה‪ :‬להבין מהאלגוריתם תכנות מסוימות‪ .‬להוריד את הזמן של ברוט‬
‫פורס‪ ,‬לתקוף את הפונקציית דחיסה‪ .‬לתקוף את המבנה של מרקל – דמגרד‪.‬‬
‫סוגי הש‪ - - md5 :‬לא מעניין‪.‬‬
‫‪ : Sha -0‬היתה בעייתית‬
‫‪ Sha – 1 – 160‬ביט‪ 80 .‬סיבובים‪ .‬נפרצה באמצעות הורדה של ברוט פורס‪.‬‬
‫‪ - Sha – 2‬יש התקפות אבל לא פרקטיות‪.‬‬
‫‪ - Sha – 3‬אין התקפות ידועות‪.‬‬

‫הצפנה לא מבטיחה שלמות!!!‬

‫האם הש מספיק טוב לשלמות?‬
 ‫התוקף יכול לשנות גם את ההודעה וגם את התג עצמו איך מתגוננים מזה? נאמר‬
‫שלאליס ובוב יש מפתח משותף‪ .‬אליס הצפינה ושלחה לבוב‪ .‬איך בוב ידע אם‬
‫אליס באמת שלחה? האם ההצפנה מספיקה לכך כלומר לשלמות? לא‪ .‬כי אז‬
‫התוקף יכול להחליף ביטים‪ .‬אז איך נדאג לשלמות?‬
‫דרכים‪:‬‬
‫אימות השולח באמצעות מפתח משותף‪ .‬כך רק הוא יכול לייצר את ההודעה עם‬
‫התג המתאים וכך גם אפשר לוודא שתוכן ההודעה לא השתנה מאז נוצר‪Non – .‬‬
‫‪ repudiation‬נקבל רק באופן חלקי כי יש גם לצד השני את המפתח אז אולי הוא‬
‫האשם!‪ .‬איך נשיג את זה?‬
‫‪ - Mac‬מנגנון סימטרי מבוסס על מפתח משותף ‪ .‬אליס רוצה לשלוח הודעה לבוב‬
‫אז היא שולחת את ההודעה יחד עם פלט של אלגוריתם שהורץ על ההודעה‬
‫והמפתח(חייב גם את ההודעה באלגוריתם כי תג יכול להתאים להודעה אחת‬
‫בלבד ואם ההודעה לא היתה מצטרפת לאלגוריתם אז לכל ההודעות שלי יהיה‬
‫אותו תג ואז מישהו יכול לייצר הודעה אחרת ולהצמיד אותו תג) ‪ .‬בוב מקבל ומריץ‬
‫את אותו האלגוריתם ומשווה לתג שקיבל מאליס‪ .‬תוקף לא יכול לשנות גם את‬
‫ההודעה וגם את התג כי אין לו את המפתח‪ .‬יש כמה דרכים לייצר ‪: mac‬‬
‫‪ – Hmac‬עושים הש על ההודעה והמפתח והפלט הוא התג‪ .‬המקבל מוודא‬
‫באמצעות חישוב התג‪ .‬כך עובד‪ - - opad,ipad :‬זה דטה ידוע מראש שמשמש‬
‫כפדינג‪ .‬עושים למפתח ‪ xor‬עם ‪ ipad‬ומשרשרים לזה את ההודעה ולכל זה‬
‫עושים הש‪ .‬בנוסף למפתח עושים ‪ xor‬עם ‪ opad‬ומשרשרים את זה משמאל לפלט‬
‫ההש שמקודם‪ .‬לכל מה שקיבלנו עושים הש‪ .‬וזה התג‪.‬‬
‫כלומר למעשה ‪ :‬שלמות מקבלים מהש‪ Authentication .‬כלומר שההודעה הגיעה‬
‫באמת ממי שמחזיק את המפתח‪ ,‬מקבלים מ ‪. mac‬‬
‫אז התקדמנו אבל עדיין אנחנו לא יודעים מי שלח כי אולי האדם השני הפיץ את‬
‫המפתח אז איך נשיג את זה? כלומר איך נשיג ‪( identity‬שאם אני מקבל הודעה‬
‫שכתוב בה אמזון אני יודע שאמזון שלח ולא מישהו אחר) ו ‪? non- redudiation‬‬
‫הפתרון הוא חתימות דיגיטליות‪.‬‬
‫זה מבוסס על אסימטרי כלומר כולם יכולים לוודא אבל רק אחד יכול לייצר – מי‬
‫שמחזיק את המפתח הפרטי‪.‬‬
‫אליס רוצה לשלוח הודעה‪ .‬היא עושה הש ואת הפלט היא מצפינה עם המפתח‬
‫הפרטי וזה התג שאותו היא שולחת יחד עם ההודעה המקורית ‪ .‬בוב עושה הש על‬
‫ההודעה ואת התג מפענח עם המפתח הציבורי ומשווה את התוצאה עם התוצאה‬
‫של ההש‪.‬‬
‫כלומר הקטע פה הוא איך מייצרים את התג‪ .‬מקודם עשינו עם מפתח משותף‬
‫ועכשיו עושים שונה‪.‬‬
 ‫מימושים‪ :‬נראה רק את ‪ : rsa‬קודם מפענחים את ההודעה – מי שמחזיק את‬
‫המפתח הפרטי‪ ,‬קודם מצפין את ההודעה ומי שמוודא מפענח עם המפתח הציבורי‪.‬‬
‫מה קורה כשההודעה ארוכה ? אז ראשית מחשבים את ההש על ההודעה ועל זה‬
‫חותמים‪ .‬ואז המפענח מחשב הש ומפענח את התג ואז משווה‪ .‬איך אפשר לתקוף?‬
‫אליס שולחת לבוב‪ .‬אם התוקף יחליף את ההודעה להודעה אחרת שההש שלה‬
‫אותו דבר כמו ההש של ההודעה המקורית‪ .‬ואז החתימה גם תהיה אותו דבר‪ ...‬ולכן‬
‫הפתרון הוא שנדאג שלא יהיה קל למצוא הודעה נוספת עם אותו הש‪ .‬כבר אמרנו‬
‫שזו תכונה חשובה מאוד‪..‬‬
‫איך עושים בתכלס תוך שימוש ב ‪ ?rsa‬ניתן לראות בסוף שיעור ‪ .5‬את החלק של‬
‫פדינג אפשר לדלג‪.‬‬

‫שיעור ‪6‬‬
‫שימושים לקריפטוגרפיה אסימטרית‪.‬‬
‫דיברנו על בעיית שיתוף מפתחות – איך לשתף מפתח בצורה סודית‪.‬‬
‫נדבר על מפתחות – איך מייצרים מפתח טוב? צריך מפתח שהתוקף לא יוכל‬
‫לנחש‪.‬‬
‫איך שומרים מפתחות ? צריך במקום מאובטח‪ .‬איך מפיצים? צריך בצורה סודית‪..‬‬
‫איך לחדש מפתחות?‬
‫איך מייצרים‪ :‬קוד לייצור מפתחות‪ .‬הקוד מייצר פסאודו רנדומלי ורכיב חומרה מייצר‬
‫רנדומלי לגמרי‪ .‬יש רנדום ויש יורנדום אחד חוסם ואחד לא‪ .‬מי שחוסם זה רנדום כי‬
‫הוא מחכה שיהיה מספר אקראי מספיק טוב ואילו יורנדום לא תוקע את המערכת כי‬
‫הוא נותן משהו גם לא הכי אקראי‪.‬‬
‫איך מאחסנים ? אפשר פיזית‪ .‬אפשר לתקוף באמצעות ניתוח צריכת חשמל‪.‬‬
‫אפשר לתקוף באמצעות שמירת זיכרון של תהליך כשעושים ריסט‪ .‬צריך לדאוג‬
‫לאופציות גיבוי‪.‬‬
‫איך מפיצים מפתחות באמצעות מנגנון סימטרי? אם אליס רוצה לדבר עם בוב זה‬
‫לא יעיל לדבר ביניהם‪ .‬אפשר בכל פעם לשלוח מפתח חדש כשהוא מוצפן עם‬
‫המפתח הקודם אבל יש לזה חסרונות כי צריך נקודת התחלה וכי אם הסיבה‬
‫להחלפה היא שהמפתח הקודם נפרץ אז זה לא עוזר‪ .‬אפשר לפנות לגורם שלישי‬
‫שיתן לשניהם מפתח אבל זה מצריך תקשורת משניהם עם הגורם השלישי‪.‬‬
‫מבנה המפתח‪ :‬יש מפתח סשן ויש מפתח ראשי‪ .‬הסשן הוא שמוחלף בכל פעם‬
‫והוא מתקבל באמצעות המפתח הראשי‪ .‬ואז אם הסשן ייפרץ אפשר להשתמש‬
‫בראשי להחליף‪.‬‬
 ‫הפצה‪ :‬אליס פונה לבוב‪ .‬אנו מניחים שלאליס ובוב יש מפתח משותף עם המרכז‬
‫‪ . , Ka,kb‬מדובר בהצפנה סימטרית‪ .‬אליס אומרת לסנטר אני רוצה לדבר עם בוב‬
‫וזה הזהות שלי והיא נותנת נונס ייחודי לסשן הזה‪ .‬הסנטר שולח לאליס בתשובה ‪2‬‬
‫הודעות מוצפנות‪ .‬אחת מוצפנת עם המפתח של אליס ויש בה המפתח המשותף‬
‫שהמרכז מייצר עכשיו לאליס ובוב‪ ,‬ויש את הזהות של אליס ושל בוב ואת הנונס‬
‫כדי שידעו על איזה הודעה הסנטר הגיב‪ .‬בהודעה השנייה היא מוצפנת עם המפתח‬
‫של בוב ויש בה את המפתח שהסנטר מייצר עכשיו לאליס ובוב‪ ,‬ואת הזהות של‬
‫אליס‪.‬‬
‫למעשה ההודעה השנייה מיועדת עבור בוב אבל נשלחת לאליס‪ .‬אליס מקבלת‬
‫את ההודעה הראשונה ומפענחת ומקבלת את הסשן קי ומוודאת שהנונס הוא‬
‫באמת מה השיא שלחה‪ .‬את ההודעה השנייה היא מעבירה ישירות לבוב‪ .‬בוב‬
‫מפענח ורק הוא יכול לפענח‪ .‬למה הסנטר לא שלח ישירות לבוב? כי בוב לא פנה‬
‫לסנטר עדיין‪ ,‬ואז גם הסנטר צריך לזכור מצבים‪ .‬כעת בוב רוצה לוודא שהוא מדבר‬
‫עם אליס אז הוא מגריל מספר נונס חדש ומצפין אותו עם המפתח של הסשן‬
‫שאליס יודעת ושולח לאליס‪ .‬אליס מפענחת ושולחת תגובה מוצפנת עם המפתח‬
‫של הסשן‪ .‬התגובה תהיה משהו שהוסכם מראש‪ .‬בוב מקבל ומפענח ובודק שהוא‬
‫מקבל את התגובה שהוא מצפה‪.‬‬

‫איך עוד אפשר להפיץ מפתח סימטרי? באמצעות הצפנה אסימטרית‪ ,‬כך‪:‬‬
‫אליס מייצרת מפתח ציבורי ומפתח פרטי ושולחת את הציבורי לבוב ובוב יצפין סשן‬
‫קי עם הציבורי וישלח לאליס ואליס היחידה שיודעת לפענח את ההודעה וכך תשיג‬
‫את הסשן קי‪ .‬מה הבעיה? איש באמצע‪ .‬בוב לא יכול לוודא שהמפתח הציבורי‬
‫שייך לאליס‪ .‬כלומר אפשר לתקוף כך ‪ :‬אליס שולחת לבוב‪ ,‬התוקף חוסם את‬
‫התקשורת ושולח לבוב מפתח ציבורי של התוקף ‪ .‬בוב מקבל ומצפין באמצעות‬
‫המפתח הציבורי הזדוני את הסשן קי שהוא הגריל ושולח אותו לתוקף‪ .‬התוקף‬
‫מקבל ומפענח וכך מקבל את הסשן קי ואז מצפין את הסשן קי עם המפתח הציבורי‬
‫האמיתי של אליס ושולח אותו לאליס‪ .‬אליס תפענח ותקבל את המפתח‬
‫שלמעשה הוא של התוקף‪ .‬הפתרון‪ :‬אפשר לשלוח את הציבורי באופן פיזי‪ .‬אפשר‬
‫להפיץ ברבים‪ .‬אפשר דרך סנטר שהוא תמיד מאובטח‪ .‬אפשר באמצעות‬
‫סרטיפיקציות של גורם שלישי‪.‬‬
‫נרחיב על סרטי‪ :‬קובץ בינארי עם דטה ‪ :‬מעיד על זהות ‪ .‬מחזיק תאריך תפוגה‪,‬‬
‫מפתח ציבורי‪ ,‬וחתימה כדי לוודא שהסרטי אמיתי ולא התוקף כתב אותו וגם לדאוג‬
‫לשלמות‪.‬‬
‫זה עובד בשרשראות של סרטיפיקציות עד שמגיעים למי שמכירים וסומכים על‬
‫המפתח הציבורי שלו‪.‬‬
‫מה המנגנון שעומד מאחורי זה? ‪ - Pki‬יש רוט ויש את השרשרת שמתחת‪.‬‬
 ‫‪ Tls - https‬משתמש בזה‪ .‬מה זה נותן ? סודיות‪ .‬כשאני מדבר עם גוגל כשאני‬
‫משתמש בסרטי אז ההודעות שלי מוצפנות כל הדרך עד לשרתים של גוגל כל‬
‫עוד אין תקלות‪ .‬זה נותן גם שלמות באמצעות ‪ . mac‬זה נותן גם ‪ . authenticity‬זה‬
‫שקוף לרמת האפליקציה‪ .‬מתחת ל ‪ tls‬יש פרוטוקולים קטנים‪.‬‬
‫איך עובד הפרוטוקול? לחיצת ידיים – מחליפים הודעות על כל מיני פרטים‬
‫לתקשורת למשל באיזה אלגוריתם משתמשים להחלפת מפתחות או להצפנה‪.‬‬
‫שלב ‪ – 2‬השרת שולח סרטי ללקוח והלקוח מאמת את הסרטי באמצעות‬
‫השרשרת‪ ,‬מחליפים מפתחות‪.‬‬
‫שלב ‪ – 3‬הלקוח שולח את הצד שלו בהחלפת המפתחות כמו בדיפי הלמן‪.‬‬
‫שלב ‪ – 4‬כבר עשינו אימות והחלפנו מפתח‪ ,‬כעת כל אחד שולח באיזה אלגוריתם‬
‫הוא תומך‪ .‬ועכשיו מתחילים לתקשר‪.‬‬

‫איך תוקפים ‪- tls‬‬

‫רולבק – אם יש הש ישנים או פרוצים או סיסמאות חלשות וכו‪ .,‬או אפילו אם הם‬
‫תומכים באלגוריתמים חזקים התוקף יכול להתערב ולהגיד לאחד הצדדים שהשני‬
‫רוצה אלגוריתם חלש וכך הם יתקשרו באלגוריתם חלש‪ .‬לכן לא כדאי לתמוך‬
‫באלגוריתמים חלשים‪ .‬או שאפילו השלב של ההחלטה על האלגוריתמים תהיה‬
‫עם שלמות‪.‬‬
‫‪ – Heartbleed‬הלקוח אומר לשרת תדפיס לי חזרה מה ששלחתי לך ‪ .‬אז אם‬
‫שלחת רק קצת מידע אבל כתבת שאתה מבקש הרבה אז אולי השרת ישלח עוד‬
‫הרבה מידע חסוי מהזיכרון‪.‬‬
‫הדוגמא הבאה – ניצול של מנגנון הדחיסה‪.‬‬
‫פודל – לא הוסבר היטב‪.‬‬

‫שיעור ‪7‬‬
‫סיכום על קריפטוגרפיה‪.‬‬
‫בקרת גישה – מחולק ל‪ autentication‬כלומר לוודא זהות שמי שטוען שניגש זה‬
‫באמת הוא‪ ,‬ול ‪ authorization‬כלומר אחרי שהשתכנענו שאתה זה אתה בוא‬
‫נראה איזה הרשאות יש לך ‪.‬‬
‫‪ - Autentication‬איך לוודא שאני זה באמת אני? סיסמאות‪ 3 .‬חלקים ‪ :‬משהו‬
‫שאתה יודע – סיסמא‪ ,‬מספר ת‪.‬ז‪ ,.‬ת‪.‬ל‪ .‬הבעיה שזה לא תמיד סודי‪ ..‬וגם יש‬
‫קצת מדי אפשרויות‪ ,‬בנוסף אם זה סיסמאות אז קשה לזכור ויש נטיה לבחור‬
‫סיסמאות קלות‪ .‬גם קשה לזכור הרבה סיסמאות‪ .‬יש קונפליקט – האדמין רוצה‬
‫סיסמאות מסובכות והלקוח רוצה סיסמא קלה‪ .‬סיסמאות ביחס למפתח קריפטוגרפי‬
 ‫– אותו דבר אבל בסיסמא לוקחים תווים מתחום קטן יותר ‪ ..‬בערך ‪ 32‬ולא ‪. 256‬‬
‫בנוסף אנשים בוחרים דברים די קלים ‪ . ..‬איך תוקפים ? אפשר לנסות לנחש‪.‬‬
‫אפשר לנסות את התקפת מילון‪ .‬אפשר לנסות להאזין לתקשורת ולראות את‬
‫הסיסמא‪ .‬אפשר לשלוח מחדש את אותה הודעה שנשלחה מקודם מוצפנת ואם‬
‫אין הגנה על ריפליי אצליח להיכנס עם ההודעה הישנה שהיא כבר חתומה טוב‪.‬‬
‫אפשר לעשות פישינג – להידמות לאתר‪ .‬הבעיה שצריך לגרום לך להגיע לאתר‬
‫של הפישינג ולא לאמיתי‪ .‬לפעמים הסיסמא היא דיפולטית‪ .‬לפעמים הסיסמא‬
‫מודפסת כחלק מלוגים‪ .‬יש תוכנה שמקליטה את ההקלדות‪ .‬התחזות ל‪ . it‬איך‬
‫אפשר להתמודד? להגביל את מספר האפשרויות לניסיון כניסה‪ .‬אפשר לא‬
‫לאפשר סיסמאות חלשות‪ .‬או לא לאפשר לשנות בצורה שדומה להודעה‬
‫הקודמת‪ .‬להשתמש בהש‪.‬‬
‫משהו שיש לך – מפתח פיזי‪ ,‬כרטיס אשראי‪ ,‬כרטיס ציפ‪ ,‬מפתח קריפטוגרפי‪,‬‬
‫חתיכת חומרה‪ .‬איך משתמשים? יש מפתח שמוטמע בחומרה והצד השני מנסה‬
‫לאמת את המפתח שלנו‪ .‬אליס תחשב ‪ hmac‬על הנונס שקיבלה מהשרת עם‬
‫המפתח הסימטרי ושולחת את התשובה לשרת שגם מחשב ‪ hmac‬על הנונס‬
‫בעזרת המפתח המשותף‪ .‬ואז משווה‪ .‬צריך שיהיה נונס ושיהיה רנדומלי כדי למנוע‬
‫התקפת ריפליי כי אם הנונס היה קבוע התוקף יכול להעתיק את ההודעה של אליס‬
‫עם ה ‪ hmac‬ולהזדהות כאליס בפעם הבאה‪ .‬את כל זה אפשר לעשות באמצעות‬
‫אסימטרי‪ .‬אפשר כמו ‪ ssh-1‬ואפשר כמו ‪ . ssh-2‬אפשר גם לבצע אימות באמצעות‬
‫הוכחה ללא ידע‪.‬‬
‫יתרונות לחומרה ‪ :‬יותר קשה לתקוף‪ ,‬מוגן פיזית‪ ,‬צריך ידע ספציפי לפרוץ‪ .‬חסרון‪:‬‬
‫אפשר לגנוב פיזית‪ .‬זה יקר יותר‪.‬‬
‫אפשר לשלב את משהו שיש לך יחד עם משהו שאתה יודע למשל כספומט או‬
‫אשראי‪.‬‬

‫משהו שהוא אתה – טביעת אצבע‪ ,‬חתימה על האשראי‪ ,‬זיהוי פנים‪ ,‬זיהוי קולי‪ ,‬זיהוי‬
‫קשתית קצת בעייתית כי קל לזייף ‪ .‬נרצה ‪ :‬שיש לכולם‪ ,‬שהוא ייחודי לכל אחד‪,‬‬
‫שהוא קבוע ולא משתנה‪ ,‬שניתן לאסוף אותו כלומר להשתמש בו בקלות‪.‬‬

‫כעת נעבור ל ‪ : : authorization‬מה מותר לך לעשות ‪ .‬זה מחולק לשתיים ‪:‬‬

‫‪ - - Acl‬לכל משאב מוצמד מי האנשים שמותר להם לגשת אליו‪.‬‬
‫מסוגלות – לכל אדם יש משאבים שמותר לו לגשת אליהם‪.‬‬
‫הטבלה של למפסון‪ .‬קריאה‪ ,‬כתיבה‪ ,‬הרצה‪ .‬זה בזבזני במקום כי לפעמים יהיו‬
‫עמודות כמעט ריקות‪.‬‬
 ‫בטבלה השורות יהיו האנשים והעמודות יהיו המשאבים‪ .‬אם אין הרשאות לבוב‬
‫עבור משהו אפשר להעלים את הקוביה‪ .‬ההבדל בין מסוגלות ל‪ acl‬זה על מה‬
‫הפוקוס על שורה או על עמודה‪ .‬בלינוקס לכל קובץ יש בעלים‪ ,‬קבוצה ואז רשימת‬
‫הרשאות לכל אחד מהם כלומר הרשאות צמודות לקובץ כלומר עובדים ב ‪. acl‬‬
‫אבל למשל בשירות ‪ tv‬לכל יוזר כתוב למה מותר לו לגשת כלומר עובדים עם‬
‫מסוגלות‪.‬‬

‫עקרון – עבור משתמש ומערכת עם ‪ N‬משאבים אז ליוזר צריך להיות גישה רק‬
‫למה שהוא צריך ‪ .‬הרעיון הוא בטיחות כלומר אם מישהו פרץ למשהו עם הרשאות‬
‫נמוכות אז זה לא נורא‪ .‬החסרון הוא שקשה לתחזק והמשתמשים לא מרוצים מזה‪.‬‬
‫בעיית הפקיד המבולבל‪ -‬עובד על ‪. acl‬‬
‫אליס רוצה להשתמש בשירותי קומפילציה‪( .‬המחשב הוא הפקיד) והיא צריכה‬
‫לשלם‪ .‬אז יש קובץ שאותו היא רוצה לקמפל שהרשאותיו ‪ :‬אליס יכולה לקרוא‬
‫ולכתוב והמחשב יכול רק לכתוב‪ .‬יש גם קובץ פלט שגם אליס וגם המחשב יכולים‬
‫לקורא ולכתוב‪ .‬יש גם את השירות קומפילציה שגם אליס וגם המחשב יכולים‬
‫לקרוא ולהריץ‪ .‬יש גם בסיס נתונים של התשלומים שהמחשב בלבד יכול לקרוא‬
‫ולכתבו‪ .‬אליס יכולה לתקוף כך‪ :‬היא תגיד למחשב לקמפל קובץ ואת התוצאה‬
‫לכתוב לקובץ של התשלומים! אז יוצא שלאליס נהיתה גישה למשהו שלא אמור‬
‫להיות לה גישה‪.‬‬
‫זה נקרא ‪ .privilege escalation‬ויש בזה ‪ 2‬סוגים‪ .‬אחד זה שאתה משיג הרשאות‬
‫של יוזר אחר שיש לו יותר הרשאות ממך‪ .‬השני זה שאתה משיג הרשאות של סתם‬
‫משתמש אחר‪.‬‬
‫הפתרון הוא להשתמש במסוגלות ואז זה טוב כי כשאליס תבקש משאב היא‬
‫תצמיד את ההרשאות שלה‪ .‬ואז הקומפיילר לא יוכל לגשת לבסיס נתונים‪.‬‬
‫אז יש יתרונות וחסרונות ל ‪ acl‬לעומת מסוגלות‪ .‬ואלו הן‪ :‬עמוד ‪.43‬‬
‫‪ : Blp‬הגנה רמת שלבים‪ :‬לכל משאב יש סיווג‪ .‬מחולק לארבע רמות ‪ .‬יוזרים‬
‫מקבלים רמה באמצעות בדיקת רקע‪ .‬מי שיש לו רמה מסויימת יכול לגשת לקרוא‬
‫אך ורק מדברים שהם ברמה שווה או פחותה ממנו‪ .‬אבל לגשת לכתוב אתה יכול‬
‫לגשת לכתוב רק לדברים שהם ברמה גבוהה ממנו או שווה לו כדי שלא יכתוב‬
‫דברים מסווגים לקבצים ברמה נמוכה‪.‬‬

‫שיעור ‪8‬‬
‫אבטחת רשתות‬
‫השכבה הפיזית –‬
 ‫חוטים‪ .‬איך לתקוף‪ :‬להאזין לחוטים‪ .‬להתערב בתקשורת‪ .‬להזריק מידע‪ .‬קשה‬
‫לתקוף צריך ידע ספציפי וציוד מיוחד וצריך להיות קרוב בדרך כלל‪.‬‬
‫ללא חוטים – וויפי‪ ,‬בלוטוס‪ ,‬וכו‪ ,‬בד"כ יש נקודת קצה ויש ראוטר כלשהו‪ .‬אז יותר‬
‫קל להאזין לרשת‪ .‬וגם להזריק‪ .‬אפשר לזייף כתובת ‪ . mac‬יש התנגשויות של‬
‫רשתות כלומר רשתות חופפות‪ .‬יש גישה זדונית של מישהו רשע שמנסה להתחבר‬
‫אז הוא לא צריך ממש להתחבר לחוטים‪ .‬אפשר לעשות נקודת גישה זדונית‪.‬‬
‫אפשר לעשות איש באמצע כלומר התוקף משמש הן כנקודת גישה והן כנקודת‬
‫קצה‪ .‬אפשר לתקוף ‪ dos‬באמצעות שליחת הרבה בקשות‪ .‬אפשר ‪ ad hoc‬כלומר‬
‫כאשר אין נקודה מרכזית שמנהלת את הרשת אז המערכת יותר פגיעה‪.‬‬
‫איך נגן? אפשר להסתיר את הקיום של הרשת‪ .‬זה לא מספיק ‪ .‬אנחנו יודעים מה‬
‫נדרש מהגנה‪.‬‬
‫יש סטנדרט של הגנה – ‪ 802.11‬מגן על רשת פנימית ללא חוטים ‪.‬יש בו מנגנוני‬
‫הגנה‪ .‬יש בו ‪ wep‬שנפרץ‪ .‬יש בו גם את ‪ wpa‬שזה יותר בטוח ‪ ,‬משתמש ב ‪mac‬‬
‫של ‪ .intergrity‬זוהי בעצם הגנה בין המחשב לנקודת גישה ולא מעבר‪ .‬מהראוטר‬
‫‪ 802.11‬בטוח יחסית‪.‬‬ ‫והלאה זה לא מוצפן‪ .‬סכמה איך ‪ 802.11‬עובד‪ :‬עמוד ‪.10‬‬

‫שכבת הרשת –‬
‫למה צריך שכבת רשת אם הפיזית מספקת הגנה? בגלל שמתקשרים בין רשתות‬
‫גם ולא רק בתוך הרשת עד הראוטר‪ .‬גם בגלל שיש בעיה של הגנת עומק כלומר‬
‫תמיד צריך כמה רמות של הגנה כדי שאם משהו יפול לא תיפול כל המערכת‪.‬‬
‫קוראים לזה ‪.defense in depth‬‬
‫איך נראה פקט של ‪ ? ip‬יש ‪ check sum‬לזיהוי שגיאות ולא נגד התקפה‪ .‬שולחים‬
‫כמידע את כתובת השולח ותכלס אפשר לכתוב משהו אחר וכך להתחזות למישהו‬
‫אחר‪.‬‬
‫מבנה הרשת – חיבור של רשתות שמחוברות כולם אחד לשני‪ .‬יש פה בעיה של‬
‫אבטחה ולכן המציאו את החומת אש שחוסמת את התקשורת ושולטת על מה‬
‫שנכנס ויוצא מהרשת הפנימית לרשת הגדולה‪ .‬עושים את זה באמצעות תמיכה‬
‫בפורטים מסויימים רק מה שנדרש‪ .‬גם בתוך הרשת הפנימית יש חומות כדי לאשר‬
‫רק חלק מהתקשורת‪.‬‬
‫חומת אש – לחברה יש חומה כדי שהתקשורת שיוצאת מהמחשבים של החברה‬
‫החוצה‪ ,‬תנוטר דרך החומה כדי שתאפשר רק תקשורת מסויימת‪ .‬כך גם בכניסה‬
‫של תקשורת לארגון‪.‬‬
‫‪ – Scada‬רשת תעשייתית – אפשר להתחבר מרחוק אבל אין צורך להוציא מידע אז‬
‫החומה תחסום כל יציאה החוצה ותאפשר רק פורט מסויים פנימה‪.‬‬
 ‫עם הזמן ראו שצריך חומה בכמה מקומות לאותה חברה בשביל אנשים שעובדים‬
‫מהבית וכו‪ ,‬אז המציאו מבנה חדש שבו יש ‪ lan‬ויש ‪ dmz‬של רשתות הפנימיות אי‬
‫אפשר להגיע מבחוץ אבל ל ‪ dmz‬כן אפשר כלומר מחלקים את הרשת‬
‫לסגמנטים‪.‬‬
‫סינון אתרים – לחסום ‪ url‬מסויימים מתוך ‪ .db‬איך זה מתגבר על ‪ ? https‬כי ה ‪url‬‬
‫תמיד גלוי ‪.‬‬
‫בדיקת הפקט – צריך לנתח אי אפשר להסתמך רק על פורט היעד כדי לדעת את‬
‫המטרה‪.‬‬
‫איך תוקפים חומת אש? בעיות בקונפיגורציה‪ .‬לעבור דרך דברים חוקיים‪ .‬לתקוף‬
‫חלקים לא מוגנים ופרצות‪ .‬לזיף כתובות ‪ . ip‬לתקוף פיזית‪.‬‬

‫שכבת הטרנספורט –‬
‫‪ - Vpn‬יש רשת פנימית ורוצים תקשורת החוצה מוגנת אז אם מישהו לגיטימי רוצה‬
‫לעבוד מהבית צריך לאפשר‪ .‬אז ‪ vpn‬מדמה כאילו מכשירים מחוברים פיזית אבל‬
‫באמת זה וירטואלי‪ .‬נרצה ‪ :‬סודיות‪ ,‬שלמות‪ ,‬אימות‪ .‬איך עושים אימות ? אפשר‬
‫סיסמא ואפשר מפתח פרטי ואפשר משהו פיזי‪ Vpn .‬מבוסס על ‪ - ipsec‬יש ערוץ‬
‫שדרכו הפרוטוקול עובר‪ .‬האפליקציה לא מודעת אליו אלא ברמות מתחת‬
‫מקבלים אבטחה ‪.‬‬
‫‪ - Tcp‬פגיע ל ‪. dos‬‬
‫‪ Tls‬עובד עם ‪ . tcp‬זהו מנגנון לקוח שרת‪.‬‬
‫‪ – Dos‬לתקוף שירות ולגרום שהוא לא יהיה זמין ‪ .‬למנוע מהשרת גישה לרשת‪,‬‬
‫לשנות קונפיגורציה‪ ,‬לקפוא באמצעות שליחת מידע לא תקין וכו‪.,‬‬
‫‪ 2‬סוגים ‪ :‬הצפה – שליחת הרבה הודעות ‪ ,‬או ‪ .ddos‬השני – שליחת מידע לא תקין‪.‬‬
‫למשל דוגמא להצפה – הצפה של ‪ – syn‬שולחים הודעה שרוצים להתחבר אבל‬
‫אל מתחברים ואז השרת מקצה המון משאבים‪.‬‬
‫‪ – Ddos‬בוטנט – לתוקף יש הרבה מכשירים עם חיבור לרשת והוא נותן להם הוראה‬
‫לפנות למנהלים שלהם מדי פעם ולראות אם יש הוראה לשלוח בקשה‪ .‬ואז הם‬
‫שולחים יחד בקשות בזמן שנקבע‪.‬‬

‫שרת הוא מחשב שמתחברים אליו דרך פורט‪ .‬תוקף יכול להתחבר לפורט פתוח אז‬
‫כדאי לא לפתוח סתם פורטים ‪ – mmap .‬מזהה איזה פורטים פתוחים‪ .‬אז התוקף‬
‫ישתמש בזה לבדוק מה פתוח ולתקוף דרכו‪ - Metaspoit .‬יודע על חולשות‬
‫בתוכנות ואף עוזר לשלוח אותן‪.‬‬
 ‫שיעור ‪9‬‬
‫שכבת האפליקציה –‬
‫‪ – https‬פרוטוקול ‪ http‬בטוח ‪ .‬מבוסס על ‪ . tls‬נותן העברת מידע בטוחה בין ‪2‬‬
‫צדדים – הדפדפן והשרת‪ .‬קובעים מפתח משותף ‪ ,‬משתמשים בהצפנה של ‪. aes‬‬
‫עושים שלמות עם ‪ sha-256‬ואמינות עם סרפי‪.‬‬
‫איך עובד האמינות עם סרפי? לאליס יש מפתח ציבורי שעליו היא סומכת שמתאים‬
‫למפתח הפרטי של ה ‪ . ca‬גם לבוב יש כזה‪.‬לבוב יש גם זוג מפתחות פרטי וציבורי‬
‫שלו‪ .‬כעת היא רוצה לדבר עם השרת בוב‪ .‬בוב כבר ווידא בצורה פיזית את זהותו‬
‫מול ה ‪ . ca‬וה ‪ ca‬אמר אוקיי אתה בוב וה ‪ ca‬חותמים לו חתימה דיגיטלית עם‬
‫המפתח הפרטי שלהם‪ .‬בוב שומר את זה אצלו להרבה זמן ‪ .‬כעת שאליס פונה אל‬
‫בוב בוב אומר לה אני ישלח לך הודעות עם המפתח הציבורי שלי והנה הסרפי שלי‪.‬‬
‫תוכלי לוודא שזה אני באמצעות השוואה של המפתח הציבורי שלי עם המפתח‬
‫הציבורי של ה ‪ ca .‬מעתה והלאה בוב ישלח לאליס הודעות שחתומות עם‬
‫המפתח הפרטי שלו‪ .‬ואליס תוודא עם המפתח הציבורי שקיבלה מבוב‪.‬‬
‫בעיות אבטחה‪ - ssl stripping :‬כאשר אני חושב שאני מתקשר עם השרת ב ‪https‬‬
‫אבל יש תוקף שמשנה את התקשורת ל ‪ http‬מולי אבל עם השרת הוא מדבר‬
‫‪. https‬‬
‫בעיה נוספת ‪ :‬סרטי לא חוקי‪ Common name .‬לא תקין‪ .‬סרפי חתום על ידי ‪ ca‬לא‬
‫מוכר‪ .‬במקרים אלו אנו חשופים לאיש באמצע‪ .‬כך ‪ :‬הדפדפן פונה לבנק ב ‪https‬‬
‫כראוי‪ .‬התוקף יוצר את אותה בקשה ושולח לבנק‪ .‬הבנק עונה לתוקף ושולח‬
‫לתוקף את הסרפי שלו‪ .‬התוקף יוצר אותו סרפי ומצמיד לו את המפתח הציבורי שלו‬
‫עצמו‪ ,‬וחותם את הסרפי עם מפתח שהדפדפן מוכן לקבל למרות שהוא לא אמור‬
‫לקבל‪ .‬כעת כשהדפדפן ייצר מפתח משותף הוא למעשה ייצר מפתח משותף עם‬
‫התוקף ומכאן והלאה התוקף עובר דרך כל התקשורת‪ .‬זה גם מה שרימון עושים‪,‬‬
‫רק שהם נותנים ללקוח להתקין בעצמו את ה ‪ root‬סרפי‪.‬‬
‫בעיה נוספת‪ :‬כאשר יש עמודים שמערבים ‪ http‬עם ‪.https‬‬
‫אימייל ‪ :‬ארכיטקטורה‪ Smtp .‬לא בטוחה‪ .‬אז המציאו את ‪ – pgp‬מאובטח‪ .‬עובד כך ‪:‬‬
‫אימות‪ :‬מחשבים הש על ההודעה ואת הפלט חותמים חתימה דיגיטלית עם המפתח‬
‫הפרטי של השולח‪ .‬משרשרים את המייל‪ ,‬מכניסים לזיפ את המייל והחתימה‬
‫ושולחים‪ .‬הצד המקבל מחלץ מחשב הש על המייל מפענחים את החתימה ומשווה‪.‬‬
‫איך משיגים סודיות? מייצרים סשן קי – ‪ 128‬ביט ומצפינים את ההודעה עם הסשן קי‪.‬‬
‫מצפינים את הסשן קי עם המפתח הציבורי של המקבל ושולחם את ההודעה עם‬
‫הסשן קי‪ .‬המקבל מפענח את הסשן קי ומפענח את ההודעה המוצפנת עם הסשן‬
‫קי ועושה אנזיפ‪ .‬כלומר הרעיון הוא להצפין את המפתח הסימטרי באמצעות‬
‫הצפנה אסימטרית ‪ .‬למה שלא נצפין את ההודעה ישירות עם המפתח הציבורי של‬
‫המקבל? כי הצפנה אסימטרית היא איטית אז להודעה ארוכה זה בעיה ולכן‬
 ‫מצפינים רק את ההודעה עם מפתח סימטרי‪ .‬לפרוטוקול הוסיפו דחיסה כלומר‬
‫לפני השליחה דוחסים אבל רק אחרי הדחיסה מצפינים‪ .‬כלומר חתימה דחיסה‬
‫הצפנה ‪ ,‬ובצד המקבל פענוח ‪ ,‬חילוץ ‪ ,‬וידוא‪ .‬למה קודם דוחסים ואז חותמים ? כי‬
‫הדחיסה היא פעולה לא דטרמניסטית ‪ .‬ואז החתימה לא תהיה טובה‪ .‬לאחר כל זה‬
‫משתמשים ב ‪ . smtp‬מאיפה כל צד יודע את המפתח הציבורי של הצד השני?‬
‫אפשר באמצעות מזהה של ‪ 64‬ביט עבור המפתח ואז שולחים את המפתח פעם‬
‫אחת‪ .‬פה אין סרטי אז איך סומכים על המפתחות? ‪ . Key-rings‬הפומבי מכיל את כל‬
‫המפתחות הציבוריים שהמשתמש מכיר‪ .‬והפרטי מכיל את המפתח הפרטי והציבורי‬
‫של המשתמש והוא מוגן באמצעות סיסמא‪ .‬אז איך מנהלים מפתחות? לכל ‪pgp‬‬
‫יש את ה ‪ ca‬שלו שמנהל את המפתחות ‪.‬‬
‫מודל האמון ‪ :‬אני סומך על המפתח שלי וכל מפתח שאני סומך עליו אני חותם‬
‫עליו עם המפתח שלי‪ .‬יש בו נקודה באמצע‪ .‬חץ ממשהו אלי אומר שהמפתח שלי‬
‫חתם על המשהו‪ .‬אם חתמתי על מישהו ואני גם סומך עליו שיחתום על אחרים אז‬
‫אני מסמן אותו באפור‪ .‬אפשר לסמוך חלקית ואז צובעים חצי באפור‪.‬‬
‫‪: Web-mail‬‬
‫משתמש ב ‪ https‬כלומר מאובטח עם ‪. tls‬‬
‫‪ Dns‬לדלג‪.‬‬
‫הפקטור האנושי – קונפיגורציות ‪ ,‬סיסמא דיפולטית‪ ,‬רשלנות‪ ,‬תוקפים‪..‬‬
‫פישינג‪. Social engineering .‬‬

‫שיעור ‪10‬‬
‫אבטחת תוכנה‬
‫רוצים שלתוקף לא תהיה גישה לקוד אלא רק לקלט‪ .‬בשפות נמוכות יש התקפות‬
‫על הזכרון‪.‬‬
‫אנו מניחים שהתוקף יודע איזו תוכנה רצה ולהשתמש בה‪.‬‬
‫בעיות לוגיות – אופטימיזציות לדוגמא אם לא בודקים תמונות שהוא מעלה‪ ,‬לא‬
‫בודקים את הקלט שהוא תקין‪ ,‬בקדורס‪ ,‬טעויות בחשיפת מידע‪..‬‬
‫התקפות מבוססות זכרון – מטרת התוקף היא לעשות מניפולציות על התוכנה‬
‫באמצעות קלט‪ .‬נניח שלתוך ‪ 3‬בפרים צמודים התכנית כותבת את השם משתמש‬
‫ואז הקלט של הסיסמא ואז הסיסמא האמיתית והיא משווה את ‪ 2‬הבפרים‬
‫האחרונים‪ .‬אז התוקף שלמעשה שולט על ‪ 2‬הבפרים הראשונים ייתן את השם‬
‫משתמש ואז סיסמא יותר ארוכה מגודל הבפר השני כדי שהיא תיכתב על הבפר‬
‫השלישי ‪ .‬זה נקרא ‪ Buffer overflow‬והבעיה בזה שהתכנה אחר כך כותבת‬
‫מהבסיס נתונים את הסיסמא האמיתית ודורסת את מה שהיה בבפר השלישי ואז‬
 ‫למעשה התכנה משווה את ‪ 2‬הבפרים ומדפיסה שזה לא טוב אבל היא מדפיסה‬
‫עד ה‪ null‬אז היא מדפיסה גם את מה שכתוב בבפר השלישי אז היא גילתה את‬
‫הסיסמא האמיתית‪.‬‬
‫עוד סוג של ‪ : buffer overflow‬כאשר במקום שבבפר השלישי יהיה כתוב הסיסמא‬
‫האמיתית‪ ,‬יש שם מצביע לפונקציה שנקראת עם הפרמטרים שהם הבפר הראשון‬
‫והשני‪ .‬והפונקציה הזו נקראת בהמשך‪ .‬אז במקום ‪ user name‬התוקף יכניס את‬
‫הכתובת של השל‪ .‬ובבפר השני התוקף יכניס משהו גדול מאורך הבפר‪ .‬אז‬
‫במקום הכתובת של המצביע לפונקציה בבפר השלישי יהיה כתובת שהתוקף יכניס‬
‫והוא יכניס את הכתובת של הפונקציה ‪ system‬וכך יוצא שבפרמטרים של‬
‫הפונקציה יהיה השל וכך השל ייפתח בשביל התוקף‪ .‬נשים לב שזה עובד רק כי‬
‫בקוד יש מצביע לפונקציה שזה בעצם דטה ולכן ניתן לכתוב עליו‪.‬‬
‫התקפות על כתובת חזרה מפונקציה ‪:‬‬
‫בעקבות מבנה המחסנית‪ ,‬לאחר המשתנים הלוקליים בזכרון תהיה כתובה כתובת‬
‫החזרה מהפונקציה שאליה התכנית תעבור כשתחזור מהפונקציה‪ .‬אז אפשר שוב‬
‫לכתוב מעבר לגודל הבפר ואז לדרוס את כתובת החזרה לפונקציה ולהשים‬
‫במקומה כתובת אחרת למשל כתובת של משהו שמכיל ‪ shellcode‬וכך התכנית‬
‫תריץ מה שהתוקף רוצה‪.‬‬
‫הגנות מפני התקפות על זכרון‪:‬‬
‫לא לכתוב לגודל לא מוגבל‪ .‬לדאוג למעברים בין ‪ 32-64‬ביט ‪ overflow .‬של‬
‫‪ . integer‬להיזהר מספריות ופונקציות לא בטוחות‪.‬‬
‫הגנה על המחסנית ‪ :‬ברמת הקומפיילר‪ : canary :‬יש לנו מספר סודי שכותבים אותו‬
‫‪ return‬דואגים‬ ‫בזכרון לאחר המשתנים ולפני הכתובת חזרה‪ .‬לפני שעושים‬
‫לבדוק שהוא לא השתנה ואז אם התוקף כתב משהו גדול אז לפני שכתובת‬
‫החזרה תידרס גם הסודי יידרס ואז נגלה את זה כשנשווה‪ .‬הסודי צריך להיקבע‬
‫בזמן ריצה כי אם לא אז התוקף ישנה בדריסה וישמור על הקנרי בדריסה‪ .‬יתרונות‪:‬‬
‫שקוף למתכנת‪ .‬חסרונות ‪ :‬מגן רק על כתובת חזרה‪ ,‬רק על מחסנית‪ ,‬והוא מאיט‬
‫את המערכת וגם אם הסודי יתגלה נהיה בבעיה‪.‬‬
‫הגנה נוספת ‪ : : dep :‬מיועד למנוע את האפשרות להריץ קוד באזור של דטה‪.‬‬
‫מחלקים את הזיכרון לאזורים שמיועדים לקוד שירוץ ולאזורים שמיועדים לדטה‪ .‬כך‬
‫אי אפשר להטמיע ‪ . shellcode‬חסרונות‪ :‬זה לא מגן מפני התקפות של הזרקת‬
‫מידע ולא הרצת קוד‪ .‬זה לא מגן מפני קוד שכבר קיים לרוץ‪ .‬אפשר להגן מפני זה‬
‫עם כתיבת מידע באיזורים רנדומליים‪ .‬קוראים לזה ‪.asr‬‬