דיווח קצר שעלה ל-Hacker News טוען ש-ChatGPT Desktop מבצע SSH agent forwarding אל המכונה המרוחקת שבה רץ סוכן הקוד שלו. לפי הטענה, הסוכן יכול להזדהות עם מפתחות ה-SSH המקומיים של המשתמש, למשל כדי לבצע push ל-repositories פרטיים ב-GitHub. הפוסט צבר 3 נקודות בלבד בזמן שנבדק, אבל הוא נוגע במנגנון ותיק ורגיש במיוחד: היכולת של מכונה מרוחקת לבקש חתימות מהמפתחות שלכם.
הסיבה שהנושא חשוב דווקא עכשיו פשוטה. סוכני קוד מבוססי AI כבר לא רק מציעים שורות קוד. הם מריצים פקודות, מושכים תלויות, מתחברים לשרתים ודוחפים קוד. כשסוכן כזה רץ על מכונה מרוחקת ומקבל גישה ל-ssh-agent שלכם, הוא מקבל בפועל יכולת להזדהות בשמכם לכל אורך החיבור. זו שאלה של אבטחת סוכני AI לא פחות משאלה של הגדרות SSH.
המאמר מפריד בין מה שמאומת לבין מה שעדיין בגדר טענה, מסביר איך agent forwarding עובד ולמה הוא מסוכן, ומציע צ'קליסט מעשי לבדיקת ~/.ssh/config, SSH_AUTH_SOCK, ForwardAgent ו-ProxyJump. לצד זה מוצגות דרכי הקשחה: מפתחות עם זמן חיים מוגבל, אישור בכל שימוש, מפתחות חומרה ומפתחות ממוקדי מטרה.
מה דווח על ChatGPT Desktop ו-Codex
הפוסט ב-Hacker News, שכותרתו "ChatGPT Desktop forwards your SSH agent to remote machines", טוען שהסוכן שרץ על המכונה המרוחקת יכול להזדהות עם אישורי ה-SSH המקומיים, ומפנה כראיה ל-Pull Request מספר 28131 ב-repository הציבורי openai/codex.
כתבה מפורטת יותר שפורסמה ב-DEV Community מוסיפה פרטים. לפיה, [ה-PR נקרא "codex] Refresh SSH agent for app-server proxy", ובתגובות הסקירה שלו מופיע הנתיב SSH_AUTH_SOCK=~/.codex/app-server-control/forwarded-ssh-agent.sock. באותה כתבה מוזכר גם issue נלווה שעוסק בלקוחות דסקטופ שדורסים את ה-SSH agent המשותף, וכן דגל בשם --forward-ssh-agent.
איך הכותבים עצמם מגדירים את זה
חשוב לשים לב לניסוח. כותב הכתבה ב-DEV מתאר את ההתנהגות כפיצ'ר שמתועד בקוד, שהתוצאה שלו היא capability transfer. הכוונה ב"העברת יכולת" היא שהיכולת לחתום בשם המשתמש, שבדרך כלל שמורה למחשב המקומי שלו, עוברת לגורם אחר. במקרה הזה, לסוכן שרץ על מכונה מרוחקת.
אותו כותב קובע במפורש שאף אחד לא הראה נוזקה שמנצלת את היכולת הזו. כלומר, הטענה איננה שנמצאה חולשה, אלא שקיימת יכולת שמשתמשים לא בהכרח מודעים לה.
אתר Privacy Affairs מסכם זאת כך: אם הגדרות ה-SSH שלכם מעבירות את ה-agent, אפליקציית הדסקטופ של ChatGPT מעבירה אותו הלאה לסוכן הקוד שהיא מריצה על המכונה המרוחקת. הניסוח הזה מרמז שההתנהגות תלויה בהגדרות הקיימות של המשתמש, ולא בהכרח מופעלת אצל כולם. יש לציין שהסיכום של Privacy Affairs קצר, והפרטים בו לא אומתו באופן עצמאי.
מה מאומת ומה לא
כדי לקבל החלטות נכונות צריך להפריד בין שכבות המידע:
- מאומת היטב: הסיכון הכללי של SSH agent forwarding. מקורות רבים ובלתי תלויים, ביניהם Teleport, InfoWorld ו-Smallstep, מתארים אותו באופן עקבי, והוא מוכר כבר שנים.
- נתמך חלקית: קיומו של PR ב-
openai/codexשעוסק בסוקט בשםforwarded-ssh-agent.sockובדגל--forward-ssh-agent, כפי שמצוטט בכתבה ב-DEV. התוכן המלא של ה-PR לא נבדק באופן עצמאי, והפרטים מבוססים על הציטוטים שפורסמו. - לא ברור: האם ההעברה מופעלת כברירת מחדל, רק באישור מפורש של המשתמש (opt-in), או רק כשההגדרות הקיימות כבר כוללות
ForwardAgent. - לא ידוע: אילו מערכות הפעלה וגרסאות מושפעות, מתי השינוי נכנס, והאם OpenAI הגיבה, תיעדה או שינתה את ההתנהגות. בדיווחים הזמינים לא מופיעה הצהרה רשמית.
הערה על תאריכים ועדכניות
לפוסט ב-Hacker News ולכתבה ב-DEV לא מצוין תאריך פרסום מלא בגרסאות הזמינות. המשמעות היא שקשה לקבוע לאיזו גרסה של האפליקציה הם מתייחסים, וייתכן שההתנהגות השתנתה מאז, שנוסף לה תיעוד או ש-OpenAI התייחסה אליה.
לכן, לפני קבלת החלטות, כדאי לבדוק את מצב ה-repository הציבורי, את התיעוד העדכני של האפליקציה ואת ההתנהגות בפועל בסביבה שלכם. הבדיקה העצמאית, שמפורטת בהמשך, אמינה יותר מכל דיווח משני.
המסקנה המעשית: אין צורך לחכות לאישור רשמי כדי לפעול. גם אם ההתנהגות הספציפית של ChatGPT Desktop תתברר כשונה ממה שתואר, הצעדים שבהמשך הם היגיינת SSH בסיסית שכדאי ליישם בכל מקרה.
איך SSH agent forwarding עובד
ssh-agent הוא תהליך שרץ ברקע על המחשב המקומי ומחזיק בזיכרון את המפתחות הפרטיים אחרי שפתחתם אותם עם ה-passphrase. כשמתחברים לשרת, לקוח ה-SSH מבקש מה-agent לחתום על אתגר ההזדהות, והמפתח עצמו לא יוצא מה-agent.
כשמפעילים forwarding, באמצעות ssh -A או ForwardAgent yes בקובץ התצורה, לקוח ה-ssh יוצר Unix socket על המכונה המרוחקת ומפנה אליו את משתנה הסביבה SSH_AUTH_SOCK. כל תהליך על המכונה המרוחקת שמדבר עם הסוקט הזה מדבר בפועל עם ה-agent במחשב שלכם, דרך מנהרה בתוך חיבור ה-SSH.
איך נראה סוקט מועבר
על מכונה מרוחקת, סוקט של agent מועבר נמצא בדרך כלל בנתיב בסגנון /tmp/ssh-XXXXX/agent.NNNN. במקרה של Codex, הנתיב המדווח שונה: ~/.codex/app-server-control/forwarded-ssh-agent.sock, כפי שמופיע בדיון ב-PR. המשמעות זהה: מי שיכול לגשת לסוקט, יכול לבקש חתימות.
למה משתמשים בזה בכלל
agent forwarding לא נולד כטעות. הוא פותר בעיה אמיתית: הוא מאפשר לא לשמור מפתחות פרטיים על שרתים מרוחקים. התבנית הנפוצה היא ForwardAgent yes על שרת bastion, לעיתים בשילוב עם ProxyJump, כדי שאפשר יהיה להמשיך הלאה לשרתים פנימיים או לבצע git pull מ-GitHub מתוך השרת בלי להעתיק אליו מפתח.
זו בדיוק הנוחות שהופכת אותו למסוכן: היכולת להשתמש במפתח בלי שהמפתח נמצא שם. גם התיעוד הרשמי של OpenSSH מזהיר, בתיאור ההנחיה ForwardAgent, שיש להפעיל agent forwarding בזהירות.
למה שרת מרוחק יכול להשתמש במפתחות שלכם
הנקודה הקריטית ביותר להבנה: agent forwarding לא מעתיק את המפתח הפרטי, אבל נותן למכונה המרוחקת את היכולת לבקש מה-agent המקומי לחתום על בקשות כל עוד החיבור פתוח. יותר מזה, כל מפתח שטעון ב-agent הופך לנגיש, לא רק המפתח ששימש להתחברות.
מי יכול לנצל את הסוקט
לפי Termique, כל מי שיש לו הרשאות של אותו משתמש או root על המכונה המרוחקת יכול לשלוח בקשות חתימה בלי passphrase ובלי קובץ המפתח. Teleport מנסחת זאת באופן חד: כל מי שיש לו root על שרת ה-jump יכול לגשת ל-agent המועבר ולהשתמש בו כדי להזדהות לשרתי SSH בשמכם.
כתבה ב-InfoWorld ממאי 2021 הולכת צעד נוסף: כל מי שיש לו root בכל נקודה בשרשרת יכול לחטוף את ה-agent המועבר, וה-forwarding שקול בפועל לשיתוף מפתח פרטי עם כל מי שיש לו root על אותה מכונה.
מה זה אומר כשהצד המרוחק הוא סוכן AI
בתרחיש הקלאסי, האיום הוא תוקף שהשיג root על bastion. בתרחיש של סוכן קוד, הצד המרוחק הוא תוכנה שמריצה פקודות באופן אוטונומי.
הטענה שמופיעה בפועל במקור היא מצומצמת וברורה: לפי הפוסט ב-Hacker News, הסוכן שרץ על המכונה המרוחקת יכול להזדהות עם אישורי ה-SSH המקומיים, למשל כדי לבצע push ל-repositories פרטיים ב-GitHub. זה כל מה שהפוסט טוען.
מעבר לטענה הזו יש תרחיש היפותטי שכדאי לשקול, והוא אינו מופיע בדיווחים. סוכני קוד פועלים לעיתים על בסיס תוכן שהם קוראים מה-repository, מקבצי תיעוד או מלוגים. סוכן שנחשף להזרקת פרומפט עקיפה דרך README או לוג עלול, בתיאוריה, להשתמש ביכולת החתימה למטרות שהמשתמש לא התכוון אליהן.
חשוב להדגיש: מדובר בתרחיש תיאורטי בלבד. אין עדות שהוא התרחש, וגם הכתבה ב-DEV מציינת שלא הוצגה נוזקה שמנצלת את היכולת. התרחיש רק מסביר למה העברת יכולת היא נושא אבטחה גם בלי חולשה מוכחת. שאלת הגישה של סוכני קוד לסודות עולה גם בהקשרים נוספים, ונדונה למשל במאמר על ניהול סודות מול Claude Code.
החלון הזמני
היכולת קיימת רק כל עוד החיבור פתוח וה-agent מחזיק מפתחות. זו נקודה חשובה להקשחה: ככל שהחלון קצר יותר וככל שפחות מפתחות טעונים, כך הנזק האפשרי קטן יותר. סוכן קוד שרץ שעות על מכונה מרוחקת יוצר חלון ארוך במיוחד, ארוך בהרבה מסשן SSH ידני טיפוסי.
צ'קליסט ביקורת: ~/.ssh/config, SSH_AUTH_SOCK, ForwardAgent ו-ProxyJump
לפני שמשנים משהו, כדאי לדעת מה המצב הנוכחי. הצ'קליסט הבא מתאים ל-macOS וללינוקס, ורוב הפקודות רלוונטיות גם ל-WSL.
שלב 1: חיפוש ForwardAgent בקובץ התצורה
Termique ממליצה לבדוק את קובץ התצורה כדי לאתר forwarding שהופעל בטעות על wildcard, ומציינת שקבצי dotfiles מועתקים או מדריכים ישנים עם Host * ForwardAgent yes הם גורם נפוץ:
# חיפוש כל הופעה של ForwardAgent (לא תלוי רישיות)
grep -ri forwardagent ~/.ssh/config
# אם קובץ התצורה מפוצל עם Include, חפשו בכל התיקייה
grep -rin forwardagent ~/.ssh/כל שורה של ForwardAgent yes תחת Host * היא דגל אדום, כי Host * מחיל את ההגדרה על כל השרתים.
שלב 2: בדיקת התצורה האפקטיבית לכל שרת
קובץ התצורה יכול להיות מורכב, עם כמה בלוקים שחלים על אותו שרת. לפי התיעוד של OpenSSH, הדגל -G גורם ל-ssh להדפיס את התצורה שלו אחרי עיבוד בלוקי Host ו-Match, ולצאת בלי להתחבר:
# הצגת הערך האפקטיבי של forwardagent עבור שרת מסוים
ssh -G my-server | grep -i forwardagentאם הפלט הוא forwardagent yes עבור שרת שלא אמור לקבל את ה-agent, יש למצוא איזה בלוק גורם לכך.
שלב 3: חיפוש ssh -A בסקריפטים ובכינויים
הדגל -A מפעיל forwarding בדיוק כמו ForwardAgent yes, ולכן כדאי לחפש אותו גם בקבצי ה-shell:
grep -nE "ssh.* -A( |$)" ~/.bashrc ~/.zshrc ~/.bash_aliases ~/.profile 2>/dev/null
grep -rnE "ssh.* -A( |$)" ~/bin ~/scripts 2>/dev/nullשלב 4: בדיקת SSH_AUTH_SOCK במכונה המרוחקת
התחברו למכונה המרוחקת שבה רץ סוכן הקוד, ובדקו אם קיים סוקט מועבר:
# האם יש agent זמין בסשן הנוכחי?
echo "$SSH_AUTH_SOCK"
# אילו מפתחות נגישים דרכו?
ssh-add -l
# האם קיים הסוקט המדווח של Codex?
ls -la ~/.codex/app-server-control/ 2>/dev/nullאם ssh-add -l על המכונה המרוחקת מציג את טביעות האצבע של המפתחות המקומיים שלכם, ה-agent מועבר. אם מופיע הסוקט forwarded-ssh-agent.sock בתיקיית ~/.codex, זה תואם את הנתיב שמתואר בדיון על ה-PR. הבדיקה הזו היא הדרך הטובה ביותר לאמת את הטענה בסביבה שלכם במקום להסתמך על דיווחים.
שלב 5: ספירת המפתחות הטעונים מקומית
ssh-add -lכל מפתח ברשימה הוא מפתח שיהיה נגיש לכל צד שמקבל את ה-agent. אם מופיעים מפתחות ישנים, מפתחות של לקוחות קודמים או מפתחות פרודקשן שלא בשימוש שוטף, זה הזמן לפנות אותם.
מה עושים אם מתגלה forwarding לא מכוון
אם אחד השלבים חשף forwarding שלא תכננתם, סדר הפעולות הסביר הוא:
- לסגור את הסשנים הפתוחים מול המכונה המרוחקת, כדי לסגור את החלון.
- להסיר או לשנות את השורה הבעייתית בקובץ התצורה, ולוודא עם
ssh -Gשהשינוי נקלט. - לפנות מה-agent המקומי מפתחות שלא נדרשים כרגע.
- אם המכונה המרוחקת אינה בשליטה מלאה שלכם, לבחון את יומני הגישה של השירותים שהמפתחות פותחים, כמו GitHub או שרתי פרודקשן, ולשקול החלפת מפתחות.
סיכום הצ'קליסט
ForwardAgent yesלא מופיע תחתHost *.ssh -Gמראהforwardagent noלכל שרת שלא דורש forwarding במפורש.- אין
ssh -Aבכינויים ובסקריפטים בלי הצדקה. - במכונות שמריצות סוכני AI,
ssh-add -lלא מחזיר את המפתחות המקומיים, אלא אם זה מכוון. - ב-agent המקומי טעונים רק המפתחות שבאמת נדרשים כרגע.
הקשחה: זמני חיים, אישור בכל שימוש, מפתחות ממוקדים ו-ProxyJump
הגנה על מפתחות SSH לא מסתכמת בכיבוי forwarding. לפעמים יש צורך אמיתי בו, ואז המטרה היא לצמצם את מה שאפשר לעשות דרכו ולמשך כמה זמן. במקרים אחרים אפשר להחליף אותו לגמרי בחלופה בטוחה יותר.
הגבלת זמן חיים למפתחות
Teleport ממליצה להשתמש ב-ssh-add -t כדי לקבוע זמן חיים למפתח, ב-ssh-add -D או -d כדי להסיר מפתחות שלא בשימוש, ולסגור את ה-agent כשאין בו צורך:
# טעינת מפתח לשעה אחת בלבד (3600 שניות)
ssh-add -t 3600 ~/.ssh/id_ed25519_github
# הסרת מפתח ספציפי
ssh-add -d ~/.ssh/id_ed25519_old_client
# הסרת כל המפתחות מה-agent
ssh-add -D
# סגירת ה-agent לגמרי
eval "$(ssh-agent -k)"זמן חיים קצר מצמצם את החלון שבו צד מרוחק יכול לבקש חתימות. אם סוכן קוד ממשיך לרוץ אחרי שהמפתח פג, הוא כבר לא יוכל להשתמש בו.
אישור בכל שימוש (confirm-on-use)
לפי Smallstep, פרוטוקול ה-agent תומך במפתחות מוגבלים (constrained keys): מפתחות עם זמן חיים מוגבל או כאלה שדורשים אישור מפורש של המשתמש בכל שימוש. כך כל חתימה הופכת לפעולה מודעת, ובקשת חתימה לא צפויה ממכונה מרוחקת תקפוץ כחלון אישור.
לפי התיעוד של ssh-add, הדגל -c מסמן שמפתחות שנוספו ידרשו אישור לפני כל שימוש בהם להזדהות, והאישור מתבצע באמצעות תוכנית ssh-askpass. בסביבה בלי תוכנית askpass מתאימה, בקשת החתימה עלולה להיכשל, ולכן כדאי לבדוק את ההתנהגות במערכת שלכם לפני שמסתמכים עליה:
# אישור בכל שימוש + זמן חיים של 30 דקות
ssh-add -c -t 1800 ~/.ssh/id_ed25519_githubהמחיר הוא חיכוך: כל git push של הסוכן ידרוש אישור. מבחינה אבטחתית זה בדיוק העניין, כי זה הופך פעולה שקטה לפעולה גלויה.
מפתחות חומרה
Smallstep מציינת שפרוטוקול ה-agent תומך גם בהוספת מפתחות מכרטיס חכם. מפתח חומרה מוסיף שכבה פיזית: במקרים רבים החתימה דורשת נגיעה במכשיר, כך שגם סוקט מועבר לא יאפשר חתימה בלי נוכחות פיזית של המשתמש.
לפי התיעוד של ssh-keygen, OpenSSH תומך בסוגי מפתחות מבוססי FIDO, ecdsa-sk ו-ed25519-sk. לפני פריסה בצוות כדאי לבדוק את התמיכה בגרסת OpenSSH שמותקנת בכל המחשבים ואת ההנחיות של יצרן המכשיר.
מפתחות ממוקדי מטרה
מכיוון שכל מפתח שטעון ב-agent נחשף, לא רק זה ששימש להתחברות, כדאי להפריד מפתחות לפי מטרה:
- מפתח נפרד ל-GitHub, נפרד לשרתי פרודקשן ונפרד לכל לקוח.
- מפתח ייעודי עם הרשאות מצומצמות לסוכן הקוד, למשל גישה ל-repository אחד בלבד.
- טעינה ל-agent רק של המפתח הרלוונטי למשימה הנוכחית.
בקובץ התצורה אפשר לקשור מפתח לשרת. לפי התיעוד של ssh_config, ההנחיה IdentitiesOnly yes גורמת ל-ssh להשתמש רק בקבצי הזהות שהוגדרו במפורש, גם אם ה-agent מציע זהויות נוספות:
Host github.com
IdentityFile ~/.ssh/id_ed25519_github
IdentitiesOnly yesחשוב להבין את גבול ההגנה: IdentitiesOnly קובע באילו מפתחות הלקוח המקומי ינסה להשתמש, אבל לא מונע מצד מרוחק שמחזיק סוקט מועבר לבקש חתימה מכל מפתח שטעון ב-agent. לכן ההפרדה האמיתית היא מה שטוענים ל-agent.
agent נפרד לסוכן
גישה נוספת היא להריץ agent ייעודי שמחזיק רק את המפתח המצומצם, ולהפנות אליו את SSH_AUTH_SOCK בסביבה שממנה מופעל הכלי. האם ChatGPT Desktop מכבד משתנה סביבה שהוגדר בהפעלתו, ואיך הוא מתנהג מול ה-issue המדווח על דריסת ה-agent המשותף, לא פורט בדיווחים ודורש בדיקה בפועל.
# agent ייעודי עם מפתח מצומצם בלבד
eval "$(ssh-agent -s)"
ssh-add -t 3600 ~/.ssh/id_ed25519_agent_scoped
ssh-add -l # אמור להציג מפתח אחד בלבדProxyJump במקום agent forwarding
חלק גדול מהשימוש ב-agent forwarding נובע מתרחיש אחד: מעבר דרך bastion לשרת פנימי. לתרחיש הזה יש פתרון בטוח יותר. ProxyJump מעביר את ה-stdin וה-stdout של הלקוח אל שרת היעד, כך ששרתי ה-jump לא צריכים גישה ישירה ל-agent. לפי אותו מקור, האפשרות זמינה מאז 2017.
כלומר, ההזדהות מול שרת היעד מתבצעת מהמחשב המקומי, דרך מנהרה, וה-bastion רק מעביר תעבורה מוצפנת. כך גם InfoWorld מסכמת: ProxyJump בטוח יותר מ-agent forwarding.
דוגמת תצורה עם ProxyJump
# שרת ה-bastion
Host bastion
HostName bastion.example.com
User deploy
ForwardAgent no
# שרת פנימי שנגיש רק דרך ה-bastion
Host app-internal
HostName 10.0.1.20
User deploy
ProxyJump bastion
ForwardAgent no
# ברירת מחדל לכל השאר: בסוף הקובץ
Host *
ForwardAgent no
IdentitiesOnly yesלפי התיעוד של ssh_config, עבור כל פרמטר נקבע הערך הראשון שנמצא. לכן בלוק Host * עם ברירות מחדל ממוקם בדרך כלל בסוף הקובץ, אחרי הבלוקים הספציפיים. משורת הפקודה אפשר להשתמש בדגל -J, שלפי התיעוד של ssh הוא קיצור להנחיה ProxyJump:
ssh -J bastion app-internalטבלת השוואה
גישה | יתרונות | חסרונות |
|---|---|---|
ForwardAgent | המפתח לא מועתק לשרת; נוח למעבר דרך bastion ול-git משרת מרוחק | root או תהליכים של אותו משתמש יכולים לבקש חתימות; כל המפתחות הטעונים חשופים; קל להפעיל בטעות דרך |
ProxyJump | לא עוזר כשכלי על השרת המרוחק צריך להזדהות מול שירות חיצוני, למשל | |
מפתחות מוגבלים (זמן חיים / אישור) | מוסיפים חיכוך; דורשים הגדרה ותחזוקה |
המגבלה של ProxyJump מול סוכני קוד
ProxyJump פותר את בעיית ה-bastion, אבל לא את התרחיש של סוכן הקוד. כשהסוכן רץ על מכונה מרוחקת וצריך לבצע git push משם, הוא צריך יכולת הזדהות על המכונה הזו. כאן הבחירה היא בין שלוש אפשרויות:
- forwarding מוגבל: מפתח ממוקד, זמן חיים קצר ואישור בכל שימוש.
- מפתח ייעודי על המכונה המרוחקת: מפתח עם הרשאות מצומצמות, למשל ל-repository אחד, שנמצא על המכונה עצמה ולא קשור ל-agent המקומי.
- push ידני: הסוכן מבצע commit, וה-push מתבצע מהמחשב המקומי אחרי סקירת השינויים.
בצוותים גדולים כדאי לבחון גם תעודות SSH עם תוקף קצר, שמאפשרות לתת גישה מוגבלת בזמן בלי לנהל מפתחות קבועים. ההגדרה שלהן חורגת מהיקף המאמר, והתיעוד של ssh-keygen הוא נקודת פתיחה טובה.
אבטחת ChatGPT Desktop: מה לשאול את OpenAI ואיך לבדוק בעצמכם
בהיעדר הצהרה רשמית בדיווחים הזמינים, ההחלטה נשארת אצל המשתמש. כמה שאלות שכדאי לברר, מול התיעוד הרשמי, מול ה-repository הציבורי או מול התמיכה:
- האם העברת ה-agent מופעלת כברירת מחדל, או רק כשהדגל
--forward-ssh-agentפעיל או כש-ForwardAgentמוגדר? - האם יש בממשק אינדיקציה גלויה לכך שה-agent מועבר, ותיעוד של כל בקשת חתימה?
- אילו מפתחות נחשפים: כל מה שב-agent, או רק מפתח מסוים?
- האם אפשר להגביל את ה-forwarding לפעולות git בלבד או לשרתים מסוימים?
- מה קורה לסוקט
forwarded-ssh-agent.sockאחרי שהסשן מסתיים?
במקביל, הבדיקה העצמאית פשוטה: הריצו ssh-add -l ו-echo $SSH_AUTH_SOCK בתוך הסביבה שבה סוכן הקוד רץ, וחפשו את הסוקט בתיקיית ~/.codex. התוצאה תגיד יותר מכל דיווח, וכדאי לחזור עליה אחרי כל עדכון משמעותי של האפליקציה, כי ההתנהגות עשויה להשתנות בין גרסאות.
הזווית הישראלית
הדיווחים אינם מתייחסים לישראל באופן ספציפי, אבל התבנית רלוונטית במיוחד לשוק המקומי. מפתחים, סטארטאפים וסוכנויות בישראל עובדים פעמים רבות עם כמה לקוחות במקביל, מתחברים בתדירות גבוהה לשרתי ענן ולסביבות של לקוחות, ומאמצים מהר סוכני קוד מבוססי AI. ב-agent אחד יכולים להיות טעונים בו-זמנית מפתחות ל-repositories של כמה לקוחות ולשרתי פרודקשן.
במצב כזה, agent שמועבר בשקט חושף לא רק את הקוד של הצוות אלא גם נכסים של לקוחות. צוותים שעובדים מול לקוחות עם דרישות אבטחה או רגולציה כדאי שיתעדו מדיניות ברורה לגבי agent forwarding, שתכלול לפחות:
- באילו מכונות ובאילו כלים מותר להעביר agent, ובאילו אסור.
- אילו מפתחות מותר לטעון ל-agent בזמן עבודה עם סוכני AI.
- זמן חיים מקסימלי למפתחות טעונים.
- הפרדה בין מפתחות של לקוחות שונים.
מסמך כזה מקל גם על מענה לשאלוני אבטחה של לקוחות, שבהם עולות לעיתים קרובות שאלות על ניהול גישה לשרתים ול-repositories.
שאלות נפוצות
האם ההתנהגות של ChatGPT Desktop אושרה כחולשת אבטחה?
לא. הכתבה ב-DEV מתארת אותה כפיצ'ר שהתוצאה שלו היא העברת יכולת, וקובעת שלא הוצג ניצול שלה. השאלה המרכזית היא האם המשתמשים מבינים אותה ויכולים לראות כל שימוש במפתחות.
האם agent forwarding מוסר את המפתח הפרטי?
לא, קובץ המפתח לא מועתק. אבל הצד המרוחק יכול לבקש חתימות מה-agent כל עוד החיבור פתוח, ובפועל זה מספיק כדי להזדהות בשם המשתמש.
איך בודקים אם ה-agent מועבר כברירת מחדל?
חפשו ForwardAgent בקובץ ~/.ssh/config, במיוחד תחת בלוקים של Host *. בדקו גם כינויים וסקריפטים שמשתמשים ב-ssh -A, והריצו ssh-add -l בתוך סשן מרוחק כדי לראות אילו מפתחות נגישים.
במה כדאי להשתמש במקום forwarding בשרתי bastion?
ב-ProxyJump, שמעביר את החיבור בלי לחשוף את ה-agent לשרת ה-jump. משורת הפקודה זה הדגל -J, ובקובץ התצורה ההנחיה ProxyJump.
איך מגבילים את מה ש-agent מועבר יכול לעשות?
השתמשו במפתחות מוגבלים: זמן חיים קצר או אישור בכל שימוש, הסירו מפתחות שלא בשימוש עם ssh-add -d או ssh-add -D, והשאירו טעונים רק את המפתחות שנחוצים למשימה הנוכחית.
האם סוכן מרוחק יכול לבצע push ל-repositories ב-GitHub?
לפי הפוסט ב-Hacker News, כן, אם המפתחות המועברים מורשים ב-GitHub. מדובר בטענה שמבוססת על דיון ב-PR, ולכן הדרך הבטוחה היא לבדוק בסביבה שלכם עם ssh-add -l על המכונה המרוחקת.
סיכום
הדיווח על ChatGPT Desktop ו-Codex מבוסס כרגע על פוסט קצר ב-Hacker News, פרשנות בבלוג ודיון ב-PR ציבורי, ולא על הצהרה רשמית. לא ברור אם ההעברה מופעלת כברירת מחדל, אילו גרסאות מושפעות והאם OpenAI שינתה משהו מאז. גם תאריכי הפרסום המדויקים אינם ידועים, ולכן כדאי להתייחס למידע בזהירות ולאמת אותו בסביבה שלכם.
מה שכן ברור הוא שהמנגנון עצמו, SSH agent forwarding, מסוכן כשהוא פעיל מול מכונה שאינה בשליטה מלאה של המשתמש, וסוכן AI אוטונומי הוא בדיוק מכונה כזו.
הצעדים המעשיים לא תלויים בבירור הסופי של הטענה: לכבות ForwardAgent כברירת מחדל, לעבור ל-ProxyJump לתרחישי bastion, לטעון מפתחות עם זמן חיים קצר ואישור בכל שימוש, להפריד מפתחות לפי מטרה ולשקול מפתחות חומרה. בסופו של דבר, ההגנה הטובה ביותר מפני העברת יכולת לא מכוונת היא שלא תהיה יכולת רחבה להעביר מלכתחילה.
מקורות
- ChatGPT Desktop forwards your SSH agent to remote machines | Hacker News
- ChatGPT Desktop forwards your SSH agent to the machines its agent runs on (DEV)
- ChatGPT Desktop App Gives Codex Your Forwarded SSH Agent (Privacy Affairs)
- SSH agent forwarding: security risks explained (Termique)
- How to Use SSH Agent Safely (Teleport)
- ProxyJump is safer than SSH agent forwarding (InfoWorld)
- SSH Agent Explained (Smallstep)
- SSH Agent Forwarding vs ProxyJump (DEV)
- Understanding SSH Agent Forwarding and Its Security Implications (DoHost)
- Agent Forwarding (Sebos Technology)
- OpenSSH: ssh(1) manual page
- OpenSSH: ssh_config(5) manual page
- OpenSSH: ssh-add(1) manual page
- OpenSSH: ssh-keygen(1) manual page






