הפצת מערכות ההפעלה OpenBSD בקוד פתוח ידועה בקרב מנהלי מערכת, במיוחד אלו המנהלים שרתים, בשל התמקדותה באבטחה על פני מהירות, תכונות וחזיתות מפוארות.
באופן הולם, אולי, הלוגו שלו הוא דג נפוח - מנופח, עם הדוקרנים שלו מוכנים להדוף כל האקרים ערמומיים שעלולים להגיע.
אבל צוות OpenBSD ידוע כנראה לא בשל כל ההפצה שלו, אלא בערכת הכלים לגישה מרחוק OpenSSH שנכתב בסוף שנות ה-1990 להכללה במערכת ההפעלה עצמה.
SSH, קיצור של מעטפת מאובטחת, נוצר במקור על ידי מדען מחשבים פיני טאטו ילנן באמצע שנות ה-1990 בתקווה לגמול מנהלי מערכת מההרגל המסוכן של שימוש בפרוטוקול Telnet.
הבעיה עם Telnet
Telnet הייתה פשוטה ויעילה להפליא: במקום לחבר חוטים פיזיים (או להשתמש במודם על קו טלפון) כדי ליצור חיבור טלטייפ לשרתים מרוחקים, השתמשת במקום זאת בחיבור TELetype NETwork.
בעיקרון, הנתונים שבדרך כלל היו זורמים הלוך ושוב דרך חיבור טורי או קו טלפון בחיוג ייעודי נשלחו והתקבלו דרך האינטרנט, באמצעות חיבור רשת TCP עם מיתוג מנות במקום קישור נקודה לנקודה עם מיתוג מעגל. .
אותה מערכת כניסה מוכרת, חיבורים זולים יותר, אין צורך בקווי נתונים ייעודיים!
הפגם הענק ב-Telnet, כמובן, היה היעדר ההצפנה המוחלט שלה, כך שהרחה של הפעלת הטרמינל המדויקת שלך הייתה טריוויאלית, ואפשרה לקרקרים לראות כל פקודה שהקלדת (אפילו את הטעויות שעשית, וכל הפעמים שפגעת [Backspace]
), וכל בייט של פלט שנוצר...
...וכמובן, שם המשתמש והסיסמה שלך בתחילת הפגישה.
כל אחד בנתיב הרשת שלך לא רק יכול לשחזר בקלות את הפעלות המנהל המערכת שלך בזמן אמת על המסך שלו, אלא כנראה גם להתעסק בהפעלה שלך על ידי שינוי הפקודות ששלחת לשרת המרוחק וזיוף התשובות שחוזרות כך שלא שמת לב. התחבולה.
הם יכולים אפילו להקים שרת מתחזים, לפתות אותך אליו ולהקשות עליך באופן מפתיע לזהות את ההונאה.
הצפנה חזקה FTW
מטרת ה-SSH של Ylönen היא להוסיף שכבה של הצפנה ואימות חזקות לכל קצה של הפעלה דמוית Telnet, וליצור מעטפת מאובטחת (זה מה שהשם מייצג, אם אי פעם תהיתם, למרות שכמעט כולם פשוט קוראים לזה ess-ess-aitch בימים אלה).
זה היה להיט מיידי, והפרוטוקול אומץ במהירות על ידי מנהלי מערכת בכל מקום.
OpenSSH הגיע עד מהרה, כפי שהזכרנו לעיל, והופיע לראשונה בסוף 1999 כחלק מה- OpenBSD 2.6 לשחרר.
צוות OpenBSD רצה ליצור יישום חינמי, אמין, בקוד פתוח של הפרוטוקול שהם ו כל אחד אחר יכול להשתמש, ללא כל הסיבוכים הרישוי או המסחריים שהכבידו על היישום המקורי של Ylönen בשנים מיד לאחר שחרורו.
ואכן, אם אתה מריץ את שרת Windows SSH ומתחבר אליו ממחשב לינוקס כרגע, כמעט בוודאות תסתמך על יישום OpenSSH בשני הקצוות.
פרוטוקול SSH משמש גם בשירותי שרת-לקוח פופולריים אחרים, כולל SCP ו-SFTP, קיצור של עותק מאובטח ו FTP מאובטח בהתאמה. SSH פירושו באופן רופף, "התחבר בצורה מאובטחת והפעל פקודה SHell בקצה השני", בדרך כלל עבור כניסות אינטראקטיביות, מכיוון שתוכנית יוניקס עבור מעטפת פקודה היא בדרך כלל /bin/sh
. SCP דומה, אבל עבור העתקת קבצים, מכיוון שהפקודה Unix file-copy נקראת בדרך כלל /bin/cp
, ו-SFTP נקרא בערך באותו אופן.
OpenSSH אינו ערכת הכלים SSH היחידה בעיר.
יישומים ידועים אחרים כוללים: libssh2, עבור מפתחים שרוצים לבנות תמיכת SSH ישירות לתוך האפליקציות שלהם; dropbear, שרת SSH מופשט מקודד אוסטרלי מאט ג'ונסטון זה נמצא באופן נרחב במכשירי IoT (האינטרנט של הדברים) כגון נתבים ביתיים ומדפסות; ו מרק, אוסף פופולרי וחינמי של כלים הקשורים ל-SSH עבור Windows ממפתחי קוד פתוח אינדי סיימון טאתם באנגליה.
אבל אם אתה משתמש SSH רגיל, כמעט בוודאות התחברת לשרת OpenSSH אחד לפחות היום, לא מעט בגלל שרוב הפצות הלינוקס העכשוויות כוללות אותו ככלי הגישה מרחוק הסטנדרטי שלהם, ומיקרוסופט מציעה גם לקוח OpenSSH וגם OpenSSH שרת כרכיבי Windows רשמיים בימים אלה.
תיקון באגים ללא כפול
OpenSSH גרסה 9.2 זה עתה יצא, וה מכתבי שחרור דווח באופן הבא:
מהדורה זו מכילה תיקונים עבור […] בעיית בטיחות זיכרון. [באג זה] אינו נחשב לניצול, אך אנו מדווחים על רוב תקלות הזיכרון הנגישות לרשת כבאגי אבטחה.
הבאג משפיע sshd
, שרת OpenSSH (ה -d
סיומת מייצגת דמון, שם ה-Unix עבור סוג תהליך הרקע ש-Windows קורא לו a שרות):
sshd(8): תקן תקלת זיכרון טרום אימות כפול חינם שהוצגה ב-OpenSSH 9.1. לא מאמינים שזה ניתן לניצול, והוא מתרחש בתהליך קדם-הרשאה חסר זכויות הכפוף ל-chroot(2) והוא נמצא בארגז חול נוסף ברוב הפלטפורמות הגדולות.
באג פנוי כפול פירושו שבלוק זיכרון שכבר החזרת למערכת ההפעלה לשימוש חוזר בחלקים אחרים של התוכנית שלך...
...אחר כך יחזירו אותו שוב על ידי חלק מהתוכנית שכבר לא "מחזיק" בזיכרון הזה, אבל לא יודע שהוא לא.
(או הוחזר בכוונה עם הנחיה של קוד שמנסה לעורר את הבאג בכוונה כדי להפוך פגיעות לתוך לנצל.)
זה יכול להוביל לבאגים עדינים וקשים לפענוח, במיוחד אם המערכת מסמנת את הבלוק שהתפנה כזמין כאשר הראשון free()
קורה, מאוחר יותר מקצה אותו לחלק אחר של הקוד שלך כאשר הוא מבקש זיכרון באמצעות malloc(
), ולאחר מכן מסמן שוב את הבלוק פנוי כאשר הקריאה המיותרת אל free()
מופיע.
זה משאיר אותך במצב שאתה חווה כשאתה עושה צ'ק לתוך מלון שאומר, "הו, חדשות טובות! חשבנו שאנחנו מלאים, אבל אורח אחר פשוט החליט לעשות צ'ק-אאוט מוקדם, כדי שתוכל לקבל את החדר שלו."
גם אם החדר מנוקה בצורה מסודרת ומוכן לדיירים חדשים בעת כניסתך, וכך נראה כאילו הוא הוקצה כראוי לשימושך הבלעדי, עדיין עליך לסמוך על כך שכרטיס המפתח של האורח הקודם אכן בוטל כהלכה, וכי " תשלום מוקדם" לא היה תחבולה ערמומית להתגנב אחורה מאוחר יותר באותו היום ולגנוב את המחשב הנייד שלך.
תיקון באג לתיקון באג
באופן אירוני, אם תסתכל על היסטוריית הקוד העדכנית של OpenSSH, תראה שלOpenSSH היה באג צנוע בפונקציה שנקראת compat_kex_proposal()
, משמש כדי לבדוק באיזה סוג של אלגוריתם להחלפת מפתחות להשתמש בעת הגדרת חיבור.
אבל תיקון הבאג הצנוע הזה הציג במקום פגיעות חמורה יותר.
אגב, הנוכחות של הבאג בחלק מהתוכנה שנמצאת בשימוש במהלך הגדרת החיבור היא מה שהופך את זה למה שנקרא אימות מראש הנגיש לרשת פגיעות (או באג טרום אישור בקצרה).
הבאג החינמי הכפול קורה בקוד שצריך לרוץ לאחר לקוח יזם הפעלה מרחוק, אבל לפני כל הסכם מפתח או אימות התרחש, כך שהפגיעות יכולה, בתיאוריה, להיות מופעלת לפני שסיסמאות או מפתחות קריפטוגרפיים כלשהם הוצגו לאימות.
ב-OpenSSH 9.0, compat_kex_proposal
נראה בערך כך (בפשטות רבה כאן):
char* compat_kex_proposal(char* suggestion) { if (condition1) { return suggestion; } if (condition2) { suggestion = allocatenewstring1(); } if (condition3) { suggestion = allocatenewstring2(); } if (isblank(suggestion)) { error(); } return suggestion; }
הרעיון הוא שהמתקשר עובר בבלוק זיכרון משלו שמכיל מחרוזת טקסט המציעה הגדרה של החלפת מפתחות, ומקבל בחזרה אישור להשתמש בהצעה ששלחה, או מחרוזת טקסט שהוקצתה לאחרונה עם הצעה מעודכנת. .
הבאג הוא שאם תנאי 1 שקרי אבל תנאים 2 ו-3 שניהם נכונים, הקוד מקצה שתיים מחרוזות טקסט חדשות, אבל רק חוזר אחד.
בלוק הזיכרון שהוקצה על ידי allocatenewstring1()
אף פעם לא מתפנה, וכשהפונקציה חוזרת, כתובת הזיכרון שלה אובדת לנצח, כך שאין שום דרך לקוד כלשהו free()
את זה בעתיד.
הבלוק הזה בעצם נטוש, מה שגורם למה שמכונה א דליפת זיכרון.
עם הזמן, זה עלול לגרום לבעיות, אולי אפילו לאלץ את השרת להיסגר כדי להתאושש מעומס יתר בזיכרון.
ב-OpenSSH 9.1, הקוד עודכן בניסיון להימנע מהקצאת שתי מחרוזות אך נטישת אחת מהן:
/* Always returns pointer to allocated memory, caller must free. */ char* compat_kex_proposal(char* suggestion){ char* previousone = NULL; if (condition1) { return newcopyof(suggestion); } if (condition2) { suggestion = allocatenewstring1(); } if (condition3) { previousone = suggestion; suggestion = allocatenewstring2(); } free(previousone); } if (isblank(suggestion()) { error(); } return suggestion; }
יש לזה את הבאג החופשי הכפול, מכיוון שאם תנאי 1 ותנאי 2 שניהם שקריים, אבל תנאי 3 הוא נכון, אז הקוד מקצה מחרוזת חדשה כדי לשלוח בחזרה בתור התשובה שלו...
...אבל משחרר באופן שגוי את המחרוזת שהמתקשר העביר בה במקור, בגלל הפונקציה allocatenewstring1()
אף פעם לא נקרא לעדכן את המשתנה suggestion
.
מחרוזת ההצעות שהועברו הוא זיכרון ששייך למתקשר, ושהמתקשר יפנה אפוא ערכות נושא בהמשך, מה שיוביל לסכנה כפולה חינם.
ב-OpenSSH 9.2, הקוד נעשה זהיר יותר, ועוקב אחר כל שלושת בלוקי הזיכרון האפשריים שבהם נעשה שימוש: המקור suggestion
(זיכרון בבעלות מישהו אחר), ושתי מחרוזות חדשות אפשריות שאולי יוקצו בדרך:
/* Always returns pointer to allocated memory, caller must free. */ char* compat_kex_proposal(char* suggestion) { char* newone = NULL; char* newtwo = NULL; if (condition1) { return newcopyof(suggestion); } if (condition2) { newone = allocatenewstring1(); } if (condition3) { newtwo = allocatenewstring2(); } free(newone); newone = newtwo; } if (isblank(newone)) { error(); } return newone; }
אם תנאי 1 נכון, נעשה שימוש בעותק חדש של המחרוזת המועברת, כך שהמתקשר יוכל מאוחר יותר free()
הזיכרון של המחרוזת המועברת שלהם מתי שהם רוצים.
אם נעבור את תנאי 1, ותנאי 2 נכון אבל תנאי 3 הוא שקר, אז ההצעה החלופית שנוצרה על ידי allocatenewstring1()
מוחזר, והמועבר suggestion
מחרוזת נשארת לבד.
אם תנאי 2 הוא שקר ותנאי 3 הוא אמיתי, מחרוזת חדשה נוצרת ומוחזרת, וההודעה המועברת suggestion
מחרוזת נשארת לבד.
אם גם תנאי 2 וגם תנאי 3 נכונים, אז שתי מחרוזות חדשות מוקצות לאורך הדרך; הראשון משתחרר כי אין בו צורך; השני מוחזר; והמועבר suggestion
מחרוזת נשארת לבד.
אתה יכול RTxM כדי לאשר את זה אם אתה מתקשר free(newone)
מתי newone
is NULL
, אז "לא מבוצעת פעולה", כי זה תמיד בטוח free(NULL)
. אף על פי כן, הרבה מתכנתים עדיין שומרים מפני זה בתוקף עם קוד כגון if (ptr != NULL) { free(ptr); }
.
מה לעשות?
כפי שצוות OpenSSH מציע, ניצול הבאג הזה יהיה קשה, לא מעט בגלל ההרשאות המוגבלות שה- sshd
לתוכנית יש בזמן שהיא מגדירה את החיבור לשימוש.
עם זאת, הם דיווחו על זה כחור אבטחה כי זה מה שזה, אז ודאו שעדכנתם ל- OpenSSH 9.2.
ואם אתה כותב קוד ב-C, זכור שלא משנה כמה ניסיון אתה מקבל, ניהול זיכרון קל לטעות...
... אז תיזהר שם בחוץ.
(כן, רוסט וחבריה המודרניים יעשו זאת לעזור לך לכתוב קוד נכון, אבל לפעמים עדיין תצטרך להשתמש ב-C, ואפילו Rust לא יכול להבטיח זאת להפסיק לכתוב קוד שגוי אם אתה מתכנת ללא שיקול דעת!)
- הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
- Platoblockchain. Web3 Metaverse Intelligence. ידע מוגבר. גישה כאן.
- מקור: https://nakedsecurity.sophos.com/2023/02/03/openssh-fixes-double-free-memory-bug-thats-pokable-over-the-network/
- 1
- 1999
- 9
- a
- מֵעַל
- מוּחלָט
- גישה
- למעשה
- כתובת
- מאומץ
- לאחר
- נגד
- אַלגוֹרִיתְם
- תעשיות
- מוּקצֶה
- מקצה
- מאפשר
- לבד
- כְּבָר
- חלופה
- למרות
- תמיד
- בין היתר
- ו
- אחר
- יישומים
- הסכמה
- אוסטרלי
- אימות
- מחבר
- המכונית
- זמין
- בחזרה
- רקע
- רקע תמונה
- כי
- להיות
- לפני
- האמין
- הטוב ביותר
- לחסום
- אבני
- גבול
- תַחתִית
- חרק
- באגים
- לִבנוֹת
- שיחה
- נקרא
- שיחה
- שיחות
- אשר
- לגרום
- גורם
- זהיר
- מרכז
- בהחלט
- זול יותר
- לבדוק
- לקוחות
- קוד
- מקודד
- אוסף
- צֶבַע
- COM
- איך
- מגיע
- מסחרי
- רכיבים
- המחשב
- מצב
- תנאים
- לאשר
- לְחַבֵּר
- מחובר
- מקשר
- הקשר
- חיבורי
- מכיל
- עכשווי
- הַעתָקָה
- יכול
- קורס
- לכסות
- לִיצוֹר
- נוצר
- יוצרים
- קריפטוגרפי
- סכנה
- נתונים
- יְוֹם
- ימים
- החליט
- מוקדש
- מפתח
- מפתחים
- התקנים
- DID
- למות
- קשה
- לְהַצִיג
- הפצה
- הפצות
- לא
- כפול חינם
- מטה
- בְּמַהֲלָך
- כל אחד
- מוקדם
- בקלות
- אפקטיבי
- או
- הצף
- מסתיים
- אַנְגלִיָה
- שלם
- במיוחד
- למעשה
- אֲפִילוּ
- אי פעם
- כל
- כולם
- בלעדי
- ניסיון
- מנוסה
- מוכר
- תכונות
- קבצים
- ראשון
- דג
- לסדר
- פגם
- תזרים
- להתמקד
- בעקבות
- כדלקמן
- לנצח
- מצא
- חופשי
- חברים
- החל מ-
- מלא
- פונקציה
- נוסף
- עתיד
- בדרך כלל
- נוצר
- לקבל
- ענק
- Go
- טוב
- מאוד
- אַחֲרָיוּת
- שומר
- אוֹרֵחַ
- האקרים
- קורה
- קשה
- גובה
- כאן
- היסטוריה
- מכה
- חור
- עמוד הבית
- לקוות
- מלון
- לרחף
- איך
- HTML
- HTTPS
- רעיון
- מיד
- הפעלה
- in
- באחר
- לכלול
- כולל
- הַכלָלָה
- לא נכון
- מיידי
- במקום
- אינטראקטיבי
- אינטרנט
- אינטרנט של דברים
- הציג
- IOT
- Iot (האינטרנט של הדברים)
- IT
- עצמו
- שמירה
- מפתחות
- לדעת
- ידוע
- חוסר
- מחשב נייד
- מְאוּחָר
- שכבה
- עוֹפֶרֶת
- מוביל
- רישוי
- מוגבל
- קו
- קשר
- לינוקס
- סֵמֶל
- עוד
- נראה
- נראה
- נראה
- עשוי
- גדול
- לעשות
- עושה
- לנהל
- ניהול
- שולים
- דבר
- max-width
- אומר
- זכרון
- מוּזְכָּר
- מיקרוסופט
- יכול
- טעויות
- מודרני
- יותר
- רוב
- שם
- שם
- צורך
- צרכי
- רשת
- אף על פי כן
- חדש
- נוֹרמָלִי
- המיוחדות שלנו
- רשמי
- ONE
- לפתוח
- קוד פתוח
- פועל
- מערכת הפעלה
- מבצע
- להזמין
- מְקוֹרִי
- בְּמָקוֹר
- אחר
- שֶׁלוֹ
- בבעלות
- חלק
- חלקים
- עבר
- מעברי
- סיסמה
- סיסמאות
- עבר
- נתיב
- פול
- אוּלַי
- טלפון
- גופני
- מקום
- פלטפורמות
- אפלטון
- מודיעין אפלטון
- אפלטון נתונים
- פופולרי
- עמדה
- אפשרי
- הודעות
- מוּכָן
- נוכחות
- מוצג
- קודם
- הרשאות
- כנראה
- בעיה
- תהליך
- תָכְנִית
- מתכנתים
- כמו שצריך
- פרוטוקול
- מטרה
- מהירות
- מוכן
- ממשי
- זמן אמת
- קיבלו
- לאחרונה
- להחלים
- רגיל
- לשחרר
- אָמִין
- לזכור
- מרחוק
- גישה מרחוק
- לדווח
- דווח
- לַחֲזוֹר
- החזרות
- מְסוּכָּן
- חֶדֶר
- הפעלה
- חלודה
- בטוח
- בְּטִיחוּת
- אותו
- מַדְעָן
- מסך
- שְׁנִיָה
- מאובטח
- אבטחה
- סידורי
- שרתים
- שירותים
- מושב
- הפעלות
- סט
- הצבה
- התקנה
- קשה
- פָּגָז
- קצר
- כבה
- דומה
- פָּשׁוּט
- פשוט
- מצב
- להתגנב
- So
- תוכנה
- מוצק
- מישהו
- משהו
- מָקוֹר
- מְהִירוּת
- קוצים
- מסחרי
- תֶקֶן
- עומד
- התחלה
- עוד
- חזק
- נושא
- כזה
- מציע
- תמיכה
- SVG
- מערכת
- לקחת
- נבחרת
- מסוף
- השמיים
- הבלוק
- שֶׁלָהֶם
- שם.
- לכן
- דברים
- מחשבה
- שְׁלוֹשָׁה
- זמן
- פִּי
- כותרת
- ל
- היום
- כלי
- ארגז כלים
- כלים
- חלק עליון
- סה"כ
- לעקוב
- מַעֲבָר
- שָׁקוּף
- מופעל
- צרה
- נָכוֹן
- סומך
- תור
- בדרך כלל
- יוניקס
- עדכון
- מְעוּדכָּן
- כתובת האתר
- להשתמש
- משתמש
- בְּדֶרֶך כְּלַל
- אימות
- גרסה
- באמצעות
- פגיעות
- רציתי
- מוכר
- מה
- בזמן
- מי
- באופן נרחב
- יצטרך
- חלונות
- לְלֹא
- היה
- לכתוב
- כתיבה
- כתוב
- שנים
- אתה
- זפירנט