דליפת סודות Claude Code היא כבר לא תרחיש תיאורטי. מחקר של חברת האבטחה Apiiro, שפורסם ב-5 בנובמבר, מצא 1,122 קבצים ציבוריים ב-GitHub שבהם אישורי "Yes, and don't ask again" של Claude Code שמרו פקודות שכוללות סיסמאות למסדי נתונים, מפתחות AWS, טוקנים של Supabase ופרטי התחברות SSH. הקבצים האלה הגיעו לריפוזיטוריז ציבוריים, ומשם לכל מי שמחפש.
הבעיה לא נובעת מבאג קלאסי אלא משילוב של התנהגות מתועדת ומהרגלי עבודה. כשמאשרים פקודת Bash לצמיתות, Claude Code שומר את הפקודה המילולית כחוק הרשאה בקובץ .claude/settings.local.json. אם בפקודה הייתה סיסמה, היא נשמרת בטקסט גלוי. הקובץ אמור להישאר מקומי, אבל ההגנה שמונעת ממנו להיכנס ל-git לא תמיד עוברת עם הפרויקט.
המאמר הזה מפרק את המנגנון, מסביר למה מחיקת הקובץ לא מספיקה, ומציג תהליך מעשי: בדיקת הריפוזיטוריז והיסטוריית git, רוטציית מפתחות API וסיסמאות, הגדרת Claude Code הרשאות ו-gitignore נכון, והוספת סריקת סודות ב-GitHub שמותאמת לסוכני קוד AI.
מה Apiiro מצאה: המספרים מאחורי דליפת סודות Claude Code
החוקרים של Apiiro בחנו 104,185 עותקים ציבוריים של הקובץ .claude/settings.local.json ב-103,617 ריפוזיטוריז. ב-1,122 מהם נמצאו 1,379 סודות ייחודיים. אחוז הקבצים הבעייתיים נשמע נמוך, אבל במונחים מוחלטים מדובר באלפי נקודות כניסה פוטנציאליות לתשתיות אמיתיות.
ההיקף המלא, כולל היסטוריה ותמלילים
כשהחוקרים הרחיבו את הבדיקה גם להיסטוריית git, לקבצי settings.json המשותפים ולתמלילי סוכנים שנשמרו בריפוזיטוריז, המספר קפץ ל-2,539 סודות ייחודיים ב-1,994 ריפוזיטוריז ציבוריים, שנוגעים ל-63 ארגונים. אחד הארגונים אישר שהמפתח שנחשף אצלו היה פעיל.
אילו סודות נחשפו
התמהיל מלמד הרבה על האופן שבו מפתחים עובדים עם סוכני AI בפועל: הרבה עבודה ישירה מול מסדי נתונים ושרתים. לפי הסיכום של GBHackers, בין הממצאים:
- 379 סיסמאות למסדי נתונים
- 122 מפתחות service-role של Supabase
- 103 טוקנים של חשבונות Supabase
- 43 פרטי התחברות SSH, כולל התחברויות root בתוך פקודות
sshpass - 23 מפתחות AWS
- שישה מפתחות פרטיים
בחלוקה אחרת, הקבצים הכילו 636 מפתחות בפורמט מוכר של ספק ו-743 סיסמאות וטוקנים שקשורים לשרתים ציבוריים. הנתון השני חשוב במיוחד, וחוזר אליו בהמשך בהקשר של סורקי סודות.
מדד | ערך |
|---|---|
עותקי settings.local.json שנבדקו | 104,185 ב-103,617 ריפוזיטוריז |
קבצים עם סודות | 1,122 קבצים, 1,379 סודות ייחודיים |
כולל היסטוריה, הגדרות משותפות ותמלילים | 2,539 סודות ב-1,994 ריפוזיטוריז, 63 ארגונים |
סודות שקיימים רק בהיסטוריה | 734 |
התפשטות דרך forks | סודות מ-74 ריפוזיטוריז הועתקו ל-211 עותקים נוספים |
זיהוי בסורקים | Gitleaks: 564 קבצים, TruffleHog: 643, אף אחד לא זיהה 215 |
הסתייגויות שחשוב להכיר
כמה דברים כדאי לשים על השולחן לפני שמסיקים מסקנות. ראשית, Apiiro לא בדקה את תקפות הסודות ולא פנתה לשרתים. הסיווג "סוד אמיתי" פירושו חומר שנראה כמו פרטי גישה אמינים, לא אימות שהם עדיין עובדים. שנית, הנתונים כאן מגיעים מסיקור משני ב-GBHackers, CellCog ו-The Hacker News, ולא מהפוסט המקורי של Apiiro.
עם זאת, מבחינה הגנתית ההסתייגויות האלה לא משנות הרבה. סוד שנחשף בפומבי צריך להיחשב שרוף, בין אם הוא עדיין פעיל ובין אם לא.
איך 'Don't Ask Again' שומר סודות ב-settings.local.json
כדי להבין את הדליפה צריך להבין את מערכת ההרשאות של Claude Code. כברירת מחדל, הסוכן מבקש אישור לפני הרצת פקודות. המשתמש יכול לאשר פעם אחת, או לבחור באפשרות שחוסכת את השאלה בפעם הבאה.
מה קורה כשבוחרים "Yes, and don't ask again"
לפי התיעוד הרשמי של Claude Code, בחירה ב-"Yes, and don't ask again" על פקודת Bash שומרת חוק קבוע לכל ריפוזיטורי ולכל פקודה בקובץ .claude/settings.local.json בשורש הריפוזיטורי. כשעובדים עם worktrees, הנתיב מנותב ל-checkout הראשי.
הנקודה הקריטית: האישור שומר את הפקודה המילולית כחוק ב-allowlist בלי להסיר ארגומנטים רגישים. כלומר, אם הפקודה כללה סיסמה, הסיסמה נשמרת בטקסט גלוי. כך עשוי להיראות קובץ כזה:
{
"permissions": {
"allow": [
"Bash(npm run test)",
"Bash(PGPASSWORD=S3cr3tProdPass psql -h db.example.com -U admin -d prod -c 'select 1')",
"Bash(sshpass -p RootPass123 ssh root@203.0.113.10 'systemctl restart app')"
]
}
}הדוגמה מומצאת, אבל התבנית תואמת בדיוק את סוגי הממצאים שתוארו במחקר: סיסמאות אחרי PGPASSWORD=, אחרי sshpass -p או בתוך פקודות mysql -p.
מה נשמר לצמיתות ומה לא
לא כל אישור נשמר בקובץ. התיעוד מבחין בין סוגי פעולות:
סוג אישור | התנהגות |
|---|---|
פקודות Bash | נשמר לצמיתות, לכל ריפוזיטורי ולכל פקודה |
דומיינים ב-WebFetch | נשמר לצמיתות לכל ריפוזיטורי |
WebSearch | נשמר לצמיתות לכל ריפוזיטורי |
שינוי קבצים | תקף רק עד סוף הסשן, לא נשמר בקובץ |
המקור: Configure permissions - Claude Code Docs. המשמעות היא שהסיכון מתרכז בפקודות טרמינל, ושם בדיוק מפתחים נוטים להדביק פרטי התחברות.
איך סיסמה מגיעה לתוך פקודה מלכתחילה
יש כמה תרחישים נפוצים. מפתח מדבג בעיית חיבור למסד נתונים ומבקש מהסוכן להריץ שאילתה. הסוכן קורא קובץ קונפיגורציה, שולף ממנו את הסיסמה ומשבץ אותה בפקודת psql. המפתח, שרוצה להמשיך הלאה, מאשר לצמיתות. לפי הרקע שמתאר CellCog, סודות נכנסים לפקודות בדיוק כך: בזמן troubleshooting או מתוך קבצי הגדרות שהסוכן קרא.
זה גם מזכיר עד כמה סוכני קוד נוגעים בנתונים רגישים בלי שהמשתמש שם לב. תופעה דומה של מידע אישי שזולג מכלי פיתוח נסקרה במאמר על דליפת האימייל ב-User-Agent של Claude Code.
למה הגנת ה-gitignore לא מספיקה
הקובץ settings.local.json לא אמור להגיע ל-git בכלל. התיעוד מגדיר אותו כקובץ אישי ומקומי לפרויקט, ומציין ש-Claude Code שומר אותו מחוץ ל-git כשהוא יוצר אותו. אם יוצרים את הקובץ ידנית, צריך להוסיף אותו ל-.gitignore בעצמכם.
הגנה שחיה על מכונה אחת
לפי Apiiro, Claude Code מוסיף את הקובץ לרשימת ה-ignore הגלובלית של git אצל המפתח. ההגנה הזו נשארת על מחשב אחד ולא עוברת עם הפרויקט. הנה כמה דרכים שבהן הקובץ יכול בכל זאת להגיע לריפוזיטורי:
- מפתח אחר משכפל את הריפו למכונה שבה אין את חוק ה-ignore הגלובלי.
- הקובץ נוצר ידנית או הועתק מפרויקט אחר, ואף אחד לא הוסיף אותו ל-
.gitignore. - סביבת CI, קונטיינר או מכונה וירטואלית מריצים פקודות
git add -Aבלי ההגדרות הגלובליות של המפתח. - מישהו מוסיף את הקובץ בכוונה כדי לשתף הרשאות עם הצוות, בלי לבדוק מה יש בו.
חשוב לציין שהמנגנון המדויק לא לגמרי חד בין המקורות: התיעוד מדבר על שמירת הקובץ מחוץ ל-git ביצירה, ו-GBHackers מתאר רשימת ignore גלובלית. ההתנהגות ב-Windows או מחוץ לריפוזיטורי git לא מפורטת. לכן ההמלצה המעשית פשוטה: לא להסתמך על מה שהכלי עושה, ולהוסיף חוק ignore ברמת הריפו.
settings.local.json מול settings.json המשותף
Claude Code תומך בכמה רמות הגדרות. לפי רפרנס ההגדרות קיימות ארבע: משתמש (~/.claude/settings.json), פרויקט משותף (.claude/settings.json, שמיועד ל-commit), פרויקט מקומי (.claude/settings.local.json) ו-managed, שמנוהלת ברמת הארגון.
קובץ | ייעוד | סיכון |
|---|---|---|
| הגדרות אישיות, לא אמור להיכנס ל-git | הגנת ה-ignore מקומית למכונה; קובץ שנוצר ידנית דורש |
| הרשאות, hooks ופלאגינים משותפים לצוות, נכנס ל-git בכוונה | כל סוד שנכנס לכאן חשוף מעצם ההגדרה |
לפי ההשוואה בתיעוד והממצאים של Apiiro, גם קבצי ההגדרות המשותפים הגדילו את ספירת הסודות. מי שמעתיק חוקי allow מהקובץ המקומי לקובץ המשותף כדי לחסוך לצוות אישורים, עלול להעתיק גם סיסמאות.
היסטוריה ו-forks: למה מחיקה לא פותרת
זה אולי הממצא החשוב ביותר מבחינה מעשית. גרסאות היסטוריות של הקבצים הכילו 734 סודות שלא הופיעו בעותקים הנוכחיים. כלומר, מישהו כבר מחק או ערך את הקובץ, אבל הסוד נשאר זמין בהיסטוריית git לכל מי שמשכפל את הריפו.
בנוסף, forks העתיקו פרטי גישה מ-74 ריפוזיטוריז ל-211 עותקים נוספים. גם אם בעל הריפו המקורי ינקה את ההיסטוריה שלו, העותקים ב-forks לא בשליטתו. המסקנה: ברגע שסוד הגיע לריפו ציבורי, הדרך היחידה לנטרל אותו היא להחליף אותו.
איך בודקים את הריפוזיטוריז ואת היסטוריית git
לפני שמתקנים צריך לדעת מה חשוף. הבדיקה כוללת ארבעה רבדים: הקובץ הנוכחי, ההיסטוריה, קבצי ההגדרות המשותפים ותמלילים או לוגים של סוכנים שנשמרו בריפו.
שלב 1: האם הקובץ נמצא במעקב
הפקודות הבאות בודקות אם קבצי Claude Code נמצאים ב-git, ואם כן, למה הם לא מסוננים:
# אילו קבצים בתיקיית .claude נמצאים במעקב
git ls-files .claude/
# האם הקובץ מסונן, ועל ידי איזה חוק (מקומי או גלובלי)
git check-ignore -v .claude/settings.local.json
# איפה נמצא קובץ ה-ignore הגלובלי במכונה הזו
git config --global core.excludesFileאם git check-ignore מחזיר חוק מקובץ גלובלי ולא מ-.gitignore של הריפו, ההגנה תקפה רק למכונה הזו.
שלב 2: סריקת ההיסטוריה
גם אם הקובץ לא קיים היום, הוא עשוי להופיע בקומיטים ישנים, בכל ענף:
# כל הקומיטים בכל הענפים שנגעו בקבצי ההגדרות
git log --all --oneline -- .claude/settings.local.json .claude/settings.json
# הצגת התוכן המלא של כל הגרסאות ההיסטוריות
git log --all -p -- .claude/settings.local.json .claude/settings.json
# חיפוש תבניות של סיסמאות ומפתחות בכל הגרסאות של תיקיית .claude
git grep -n -E 'PGPASSWORD=|sshpass -p|mysql .*-p[^ ]|AKIA|service_role' $(git rev-list --all) -- .claude/בריפוזיטוריז גדולים הפקודה האחרונה עשויה להיות איטית, אבל היא מכסה בדיוק את המקרים שסורקים אוטומטיים מפספסים.
שלב 3: בדיקה ברמת הארגון ב-GitHub
לארגונים עם עשרות או מאות ריפוזיטוריז, חיפוש הקוד של GitHub מאפשר לאתר במהירות קבצים שנכנסו למעקב. חיפוש כמו path:.claude/settings.local.json org:your-org יחזיר את כל המופעים בענפי ברירת המחדל. כדאי לבצע את החיפוש גם על ריפוזיטוריז אישיים של עובדים שעבדו על פרויקטים של הארגון, ולזכור שחיפוש קוד לא מכסה את ההיסטוריה המלאה, ולכן שלב 2 עדיין נדרש.
שלב 4: הגדרות משותפות, תמלילים ו-allowlists מקומיים
ההמלצות של Apiiro כוללות בדיקה של היסטוריה, הגדרות משותפות, תמלילים ו-allowlists מקומיים. בפועל:
- לעבור על
.claude/settings.jsonולוודא שאין בו פקודות עם ערכים רגישים. - לבדוק אם תמלילי שיחה או לוגים של סוכנים נכנסו לריפו, למשל בתיקיות דיבאג או בקבצי export.
- לפתוח את
settings.local.jsonהמקומי בכל מכונת פיתוח ולמחוק חוקי allow שמכילים סודות, גם אם הקובץ מעולם לא נכנס ל-git. סוד בטקסט גלוי על דיסק הוא עדיין סיכון.
רוטציית מפתחות API וסיסמאות: לפני הניקוי, לא אחריו
הטעות הנפוצה ביותר אחרי גילוי דליפה היא להתחיל בניקוי: למחוק את הקובץ, לשכתב את ההיסטוריה, לעשות force push, ורק אז לחשוב על החלפת הסיסמה. ההמלצה של Apiiro הפוכה: קודם רוטציה, אחר כך ניקוי.
למה הסדר קריטי
הסיבה פשוטה. הסוד כבר חשוף, ייתכן שכבר הועתק ל-forks או לקלונים מקומיים, וייתכן שכבר נאסף על ידי בוטים שסורקים את GitHub. ניקוי ההיסטוריה לא מבטל אף אחד מהעותקים האלה. רק החלפת הסוד הופכת את המידע שנחשף לחסר ערך. CellCog מנסח זאת כהחלפה של כל credential שהקובץ אי פעם הכיל, לא רק מה שמופיע בו כרגע.
סדר פעולות מומלץ
- מיפוי: לרשום כל סוד שמופיע בכל הגרסאות של הקובץ, כולל ההיסטוריה.
- רוטציה: להנפיק סיסמה או מפתח חדש לכל אחד, לעדכן את השירותים שמשתמשים בו ולבטל את הישן. ב-Supabase, למשל, מפתח service-role עוקף מדיניות הרשאות ברמת השורה, ולכן הוא בעדיפות עליונה.
- בדיקת שימוש: לעבור על לוגי גישה של מסדי הנתונים, השרתים וחשבונות הענן ולחפש פעילות חריגה מאז מועד החשיפה הראשון.
- הסרה ממעקב: להוציא את הקובץ מ-git ולהוסיף חוק ignore ברמת הריפו.
- ניקוי היסטוריה (אופציונלי): לשכתב את ההיסטוריה עם כלי כמו
git filter-repo, תוך הבנה שזה לא משפיע על forks וקלונים קיימים.
לגבי שלב 3: Apiiro עצמה לא אימתה את הסודות, אבל ארגון אחד אישר שהמפתח שלו היה פעיל. אין דרך לדעת מראש באיזו קבוצה נמצאים.
הוצאת הקובץ ממעקב
# הסרה מ-git בלי למחוק את הקובץ מהדיסק
git rm --cached .claude/settings.local.json
# הוספת חוק ignore ברמת הריפו, שעובר עם הפרויקט לכל מכונה
echo ".claude/settings.local.json" >> .gitignore
git add .gitignore
git commit -m "Stop tracking Claude Code local settings"תהליך רוטציה מסודר אחרי דליפה של משתני סביבה נסקר בפירוט במאמר על דליפת משתני הסביבה ב-Trigger.dev, ורוב העקרונות שם רלוונטיים גם כאן.
הגדרת Claude Code הרשאות ו-gitignore לסוכני AI בצורה בטוחה
אחרי הטיפול באירוע, המטרה היא למנוע את הפעם הבאה. יש כאן שלוש שכבות: מה נכנס ל-git, מה נשמר כהרשאה, ואיך סודות מגיעים לפקודות.
gitignore לסוכני AI ברמת הריפו
כל ריפוזיטורי שבו עובדים עם Claude Code, או עם כל סוכן קוד אחר, צריך חוקי ignore מפורשים, בלי להסתמך על הגדרות גלובליות:
# Claude Code: הגדרות אישיות, לא נכנסות לריפו
.claude/settings.local.json
# קבצי סביבה וסודות
.env
.env.*
!.env.exampleבאופן מכוון, .claude/settings.json לא מופיע כאן, כי הוא נועד לשיתוף. במקום לחסום אותו, צריך לבדוק אותו ב-code review כמו כל קובץ קונפיגורציה אחר.
להעדיף אישור חד-פעמי לפקודות רגישות
התיעוד מציין שחוקי הרשאה נכתבים כרשומות allow, ask ו-deny, וניתן לנהל אותם דרך הפקודה /permissions. לפעמים ההנחיה מציעה רק אישור חד-פעמי, ואז אפשר לאשר פעם אחת או להוסיף את החוק ידנית.
הכלל המעשי: כל פקודה שמכילה סיסמה, טוקן או מחרוזת חיבור מקבלת אישור חד-פעמי בלבד. אם יש צורך בחוק קבוע, עדיף לכתוב אותו ידנית בצורה כללית שלא כוללת את הערך הרגיש. דוגמה לקובץ משותף שמגדיר מדיניות זהירה:
{
"permissions": {
"deny": [
"Read(./.env)",
"Read(./.env.*)"
],
"ask": [
"Bash(psql *)",
"Bash(mysql *)",
"Bash(sshpass *)"
]
}
}תחביר התבניות עשוי להשתנות בין גרסאות, ולכן כדאי לאמת אותו מול דף ההרשאות בתיעוד לפני הטמעה.
הפניות למשתני סביבה במקום ערכים מילוליים
אחת ההמלצות של Apiiro היא להשתמש בהפניות למשתני סביבה שמגובים במנהל סודות. ההבדל נראה כך:
# מסוכן: הסיסמה חלק מהפקודה, ואם תאושר לצמיתות היא תישמר בקובץ
PGPASSWORD=S3cr3tProdPass psql -h db.example.com -U admin -d prod
# בטוח יותר: הפקודה מכילה רק שם של משתנה, הערך נטען בזמן ריצה
psql "$DATABASE_URL"במקרה השני, גם אם הפקודה תאושר לצמיתות, הקובץ יכיל רק את שם המשתנה. חשוב לוודא שהסוכן לא "עוזר" על ידי קריאת קובץ .env והדבקת הערך עצמו לתוך הפקודה. כאן נכנסים לתמונה חוקי ה-deny על קריאת קבצי סביבה.
מדיניות ארגונית עם managed settings
לארגונים שרוצים שליטה מרכזית, רפרנס ההגדרות מתאר אפשרות שזמינה רק ב-managed settings: allowManagedPermissionRulesOnly, שמגבילה את חוקי ההרשאה לאלה שמוגדרים ברמה המנוהלת. המשמעות המעשית היא שמפתחים לא יוכלו ליצור חוקי allow מקומיים, ובפרט לא חוקים שמכילים סודות. זה מגיע במחיר של חיכוך בעבודה היומיומית, ולכן מתאים בעיקר לצוותים שעובדים מול סביבות ייצור או נתוני לקוחות.
אבטחת סוכני קוד AI לא נעצרת בהרשאות. סוכן שמקבל הרשאות רחבות חשוף גם להוראות זדוניות שמוסתרות בקבצים שהוא קורא, נושא שמפורט במאמר על הזרקת פרומפט עקיפה לסוכני קוד.
סריקת סודות ב-GitHub ו-push protection לסוכני AI
השכבה האחרונה היא זיהוי אוטומטי: לתפוס סודות לפני שהם נכנסים לקומיט, ולוודא שגם אם משהו חמק, הוא לא יגיע לריפו המרוחק.
למה הסורקים הרגילים מפספסים
המחקר של Apiiro בדק גם את כלי הסריקה הנפוצים. Gitleaks זיהה 564 קבצים עם סודות ו-TruffleHog זיהה 643. אף אחד מהם לא זיהה 215 קבצים.
הסיבה טכנית ומובנת. סורקי סודות עובדים טוב מאוד על מפתחות עם פורמט מוכר: מפתחות AWS שמתחילים בקידומת קבועה, טוקנים של GitHub, מפתחות של ספקי SaaS. אבל סיסמה שמופיעה אחרי PGPASSWORD=, sshpass -p או mysql -p לרוב חסרה קידומת מזהה של ספק. מבחינת הסורק זו סתם מחרוזת. ונזכיר: 743 מהסודות בקבצים היו בדיוק מהסוג הזה, סיסמאות וטוקנים שקשורים לשרתים.
כלי | חוזקות | חולשות |
|---|---|---|
Gitleaks | זיהה 564 קבצים; מצוין במפתחות בפורמט ספק; ניתן להרחבה עם חוקים מותאמים | פספס סיסמאות בפקודות ללא קידומת מזהה |
TruffleHog | זיהה 643 קבצים, הכי הרבה מבין השניים | אותה מגבלה על סיסמאות בשורת פקודה |
GitHub MCP Server secret scanning | הסוכן סורק שינויים לפני commit או PR; תוצאות מובנות עם מיקומים | Public preview; דורש GitHub Secret Protection; רץ לפי בקשה של הסוכן, לא אוטומטית |
מקורות הטבלה: GBHackers, GitHub Changelog.
pre-commit עם חוקים מותאמים לסיסמאות בפקודות
הפתרון הוא להוסיף חוקים שמחפשים את ההקשר, לא את פורמט הסוד. הנה דוגמה לקובץ .gitleaks.toml שמרחיב את חוקי ברירת המחדל:
[extend]
useDefault = true
[[rules]]
id = "cli-password-in-command"
description = "Password passed directly on the command line"
regex = '''(?i)(PGPASSWORD=\S+|sshpass\s+-p\s*\S+|mysql\s+[^\n]*\s-p\S+)'''ואת ההרצה כדאי לחבר ל-pre-commit hook, כך שכל קומיט נבדק מקומית:
# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.x.x # להצמיד לגרסה עדכנית ספציפית
hooks:
- id: gitleaksאותה בדיקה צריכה לרוץ גם ב-CI, כי hook מקומי אפשר לעקוף או פשוט לא להתקין. ההמלצה של Apiiro כוללת סריקה גם ב-pre-commit וגם ב-CI. כדאי להימנע מהגדרה שמדווחת רק על סודות מאומתים, כי סיסמה למסד נתונים פרטי לא תעבור אימות אוטומטי מול ספק.
GitHub Secret Protection ו-push protection
בצד של GitHub, Secret Protection, שכולל סריקת סודות ו-push protection, זמין בתוכניות Team ו-Enterprise Cloud. חלק מיכולות הסריקה זמינות בחינם לריפוזיטוריז ציבוריים. Push protection חוסם push שמכיל סוד מזוהה, אבל כפוף לאותה מגבלה: הוא מזהה בעיקר דפוסים מוכרים.
סריקה מתוך הסוכן דרך GitHub MCP Server
במרץ 2026 השיקה GitHub, כ-public preview, סריקת סודות לסוכני קוד AI דרך ה-GitHub MCP Server. היכולת מאפשרת לסוכן לסרוק שינויים לפני commit ולקבל תוצאות מובנות עם מיקום כל ממצא. הדרישה היא ריפוזיטורי עם GitHub Secret Protection מופעל.
המגבלה החשובה: הסריקה רצה כשהסוכן מתבקש להפעיל אותה, לא באופן אוטומטי. אפשר להנחות את הסוכן בהוראות הפרויקט לסרוק לפני כל commit, אבל זו שכבת עזר ולא תחליף ל-hook ול-CI.
צ'קליסט לצוותים: מה עושים השבוע
הממצאים של Apiiro רלוונטיים לכל צוות שעובד עם Claude Code, ובמיוחד לסטארטאפים ולסוכנויות פיתוח בישראל שעובדים על ריפוזיטוריז ציבוריים או על ריפוזיטוריז של לקוחות. סוכנות שמחזיקה עשרות פרויקטים של לקוחות, כל אחד עם מסד נתונים ושרת משלו, חשופה במיוחד לתרחיש של סיסמאות למסדי נתונים ופרטי SSH. צוותים עם מחויבויות רגולטוריות סביב נתוני לקוחות צריכים להכניס את קבצי ההגדרות של סוכני AI לביקורות האבטחה הקבועות.
פעולות מיידיות
- להריץ
git ls-files .claude/בכל ריפו פעיל. - לחפש ברמת הארגון ב-GitHub את
path:.claude/settings.local.json. - לסרוק את ההיסטוריה של קבצי
.claude/בכל הענפים. - להחליף כל סוד שנמצא, כולל סודות שקיימים רק בהיסטוריה.
- לבדוק לוגי גישה לשירותים שהסודות שלהם נחשפו.
תיקונים מבניים
- להוסיף
.claude/settings.local.jsonל-.gitignoreשל כל ריפו, כולל תבניות פרויקט. - לעבור על
.claude/settings.jsonהמשותף ולהסיר ערכים רגישים. - להגדיר חוקי deny לקריאת קבצי
.envוחוקי ask לפקודות מסדי נתונים ו-SSH. - להעביר סודות למשתני סביבה שמגובים במנהל סודות.
- לנקות חוקי allow מסוכנים מקבצי ההגדרות המקומיים בכל מכונת פיתוח.
שכבות זיהוי
- Gitleaks או TruffleHog ב-pre-commit וב-CI, עם חוקים מותאמים לסיסמאות בפקודות.
- הפעלת push protection היכן שזמין.
- שקילת סריקה דרך GitHub MCP Server עבור צוותים עם Secret Protection.
- לארגונים: שקילת
allowManagedPermissionRulesOnlyבסביבות רגישות.
מי שרוצה למסגר את כל זה בתוך תהליך רחב יותר של אבטחת כלי פיתוח ותלויות, ימצא מסגרת מתאימה בצ'קליסט אבטחת שרשרת האספקה לצוותים קטנים.
שאלות נפוצות
למה סיסמה בכלל מגיעה לקובץ settings.local.json?
כשמאשרים פקודה עם "Yes, and don't ask again", Claude Code שומר את הפקודה המילולית כחוק allow. אם הפקודה כללה סיסמה, מפתח או טוקן, הם נשמרים יחד איתה בטקסט גלוי.
האם Claude Code לא מוסיף את הקובץ ל-gitignore?
לפי התיעוד, Claude Code שומר את הקובץ מחוץ ל-git כשהוא יוצר אותו, ולפי Apiiro זה נעשה דרך רשימת ה-ignore הגלובלית. ההגנה הזו תקפה רק למכונה אחת. קובץ שנוצר ידנית דורש הוספה ידנית ל-.gitignore.
מספיק למחוק את הקובץ מהריפו?
לא. גרסאות היסטוריות הכילו 734 סודות שלא הופיעו בעותקים הנוכחיים, ו-forks העתיקו פרטי גישה לעותקים נוספים. מחיקה לא מבטלת את החשיפה. רק רוטציה עושה זאת.
מה הצעד הראשון אחרי שמגלים סוד בקובץ?
להחליף כל credential שהקובץ הכיל אי פעם, ורק אחר כך להוציא את הקובץ ממעקב, להוסיף חוקי ignore ולבדוק היסטוריה, הגדרות משותפות ותמלילים.
סורקי סודות יתפסו את זה?
רק חלקית. Gitleaks ו-TruffleHog פספסו יחד 215 מתוך 1,122 הקבצים, בעיקר סיסמאות בתוך פקודות. צריך להוסיף חוקים שמזהים סיסמאות לפי ההקשר בשורת הפקודה.
האם כל האישורים נשמרים לצמיתות?
לא. לפי התיעוד, אישורים לפקודות Bash, לדומיינים ב-WebFetch ול-WebSearch נשמרים לצמיתות לכל ריפו. אישורים לשינוי קבצים תקפים רק עד סוף הסשן.
סיכום
דליפת סודות Claude Code שחשפה Apiiro היא דוגמה לכך שנוחות בעבודה עם סוכני AI יכולה להפוך לסיכון אבטחה בלי שאף אחד שם לב. כפתור שנועד לחסוך אישורים חוזרים שומר פקודות מילוליות, כולל הסיסמאות שבתוכן, בקובץ שההגנה עליו מקומית למכונה אחת. התוצאה: 1,122 קבצים ציבוריים עם סודות, ו-2,539 סודות כשמביאים בחשבון היסטוריה, הגדרות משותפות ותמלילים.
התיקון לא מסובך, אבל הסדר חשוב. קודם רוטציה של כל סוד שנחשף, כולל כאלה שקיימים רק בהיסטוריה. אחר כך הוצאת הקובץ ממעקב וחוק ignore ברמת הריפו. ולבסוף, מניעה: אישורים חד-פעמיים לפקודות רגישות, משתני סביבה במקום ערכים מילוליים, וסריקת סודות ב-pre-commit וב-CI עם חוקים שמזהים סיסמאות בשורת הפקודה, ולא רק מפתחות בפורמט מוכר.
הלקח הרחב יותר נוגע לכל סוכן קוד: קבצי ההגדרות, ההרשאות והתמלילים שהוא מייצר הם חלק ממשטח התקיפה, וצריכים לקבל את אותה תשומת לב כמו כל קובץ קונפיגורציה בפרויקט.
מקורות
- Configure permissions - Claude Code Docs
- Settings files and precedence - Claude Code Docs
- All settings - Claude Code Docs
- Claude Code's Don't Ask Again Feature Exposes 2,539 Secrets Across 1,994 GitHub Repositories - GBHackers
- Claude Code's settings.local.json Is Leaking Secrets - CellCog
- Claude Code's Don't Ask Again File Exposes Passwords and Keys in 1,122 Public Copies on GitHub - The Hacker News
- Secret scanning in AI coding agents via the GitHub MCP Server - GitHub Changelog
- About GitHub Advanced Security - GitHub Docs






