AI ומציאת חולשות
איך בינה מלאכותית מגלה פגיעויות — ואיך מתגוננים ומתעדכנים
בשנים 2025–2026 מודלים וסוכני AI התחילו למצוא חולשות אבטחה אמיתיות בתוכנה בשימוש נרחב — ובאותה נשימה גם להציף את ערוצי הדיווח ברעש. המדריך מסביר את שני הצדדים עם מקרים מתועדים, ובעיקר מה המשמעות המעשית למי שצריך להגן, לתעדף ולהתעדכן.
הדף הזה נועד למי שבונה מערכות AI וצריך להגן עליהן. הוא מסביר כיצד תוקפים משתמשים ב-AI, וכיצד הצד המגן נערך — מפני שאי אפשר להתגונן מפני מנגנון שלא מבינים — ורוב התוכן שלו עוסק באמצעי ההגנה: מה לבדוק, מה לחסום, ומה לתעד. אין כאן כלים לתקיפה ואין רשימת ניסוחים לשימוש נגד מערכת של מישהו אחר. תקיפה של מערכת שאינה שלכם, או שלא קיבלתם עליה אישור מפורש בכתב, אסורה על פי חוק המחשבים, התשנ"ה-1995.
נכתב על ידי בבוש — אנליסט סייבר ומומחה לוחמת סייבר, העוסק באבטחת מידע בארגון פיננסי. עוד על הכותב
מסגרת השימוש. המדריך עוסק בהגנה: להבין איך AI מוצא חולשות, כדי לתעדף תיקונים ולהגן על המערכות שלכם. אין כאן מטענים, אין הוראות ניצול, ואין כלים לתקיפה. בדיקת חולשות מותרת רק על מערכת שלכם או שקיבלתם עליה אישור מפורש בכתב.
מה השתנה: ה-AI עבר לצד של מי שמוצא חולשות
במשך שנים מציאת חולשות אבטחה הייתה עבודת אדם: חוקר שקורא קוד, מריץ fuzzer ומצליב ממצאים. בשנים 2025–2026 התמונה השתנתה — מודלים וסוכני AI התחילו למצוא חולשות אמיתיות, שלא היו ידועות, בתוכנה בשימוש נרחב. במקביל, אותה יכולת הציפה את ערוצי הדיווח בהמון רעש. המדריך מסביר את שני הצדדים, ובעיקר — מה המשמעות המעשית למי שצריך להגן על מערכת.
הערה על שמות, כי היא קריטית: לא כל "חולשה" עם שם קליט היא אמיתית, ובוודאי שלא כל אחת נמצאה בידי AI. חולשת ה-RCE המפורסמת ב-OpenSSH מ-2024, regreSSHion (CVE-2024-6387), נמצאה בידי חוקרי Qualys — בני אדם. היא דוגמה טובה לכך ששם מהדהד אינו מעיד על מקור או על אמינות. הסיפורים של ה-AI הם אחרים, והם מתועדים למטה.
ציר זמן קצר: איך הגענו לכאן
המעבר של ה-AI מכלי עזר לחוקר שמוצא חולשות בעצמו קרה מהר, ושווה לראות אותו כרצף:
- יוני 2024 — Project Naptime. Google מציגה מסגרת מחקר חולשות בעזרת LLM.
- נובמבר 2024 — Big Sleep מוצא 0-day ראשון ב-SQLite. הצאצא של Naptime מוצא פגיעות זיכרון אמיתית ש-fuzzing פספס — ציון דרך ראשון מסוגו.
- מאי 2025 — o3 מוצא use-after-free בליבת לינוקס (CVE-2025-37899).
- יוני 2025 — XBOW ראשון בטבלת HackerOne בארה"ב.
- יולי 2025 — Big Sleep מוצא 0-day נוסף ב-SQLite (CVE-2025-6965).
- אוגוסט 2025 — גמר DARPA AIxCC ב-DEF CON. מערכות אוטונומיות מוצאות ומתקנות חולשות בלי אדם בלולאה.
- ינואר 2026 — curl סוגר את ה-bug bounty בגלל הצפת דיווחי-AI שגויים.
- 2026 — גל שמות "...2Shell" ועליית דיווחי מודיעין רבעוניים.
שתי מגמות מנוגדות על אותו ציר: היכולת למצוא חולשות אמיתיות משתפרת, ובמקביל כמות הרעש גדלה. המדריך נוגע בשתיהן.
הצד האמיתי: AI שמצא חולשות שלא היו ידועות
שלושה מקרים מתועדים, לא הייפ:
Google "Big Sleep" — שני ממצאים אמיתיים ב-SQLite
Big Sleep, סוכן ה-AI של Project Zero ו-DeepMind, רשום על שני ממצאים במנוע SQLite. הראשון (נובמבר 2024) היה חולשת זיכרון מסוג stack buffer underflow — הפעם הראשונה שפורסמה שבה סוכן AI מוצא פגיעות זיכרון ניתנת-לניצול בקוד אמיתי, ודווקא כזו שה-fuzzing הקיים — כולל OSS-Fuzz — פספס. השני, CVE-2025-6965 (יולי 2025), היה 0-day ש-Google מסרה שסוכן ה-AI סיכל את ניצולו בטבע — טענה שראוי לסייג, כי לא נחשפו פרטים ולא אומתה חיצונית. בשני המקרים מדובר במנוע שרץ על מיליארדי מכשירים.
OpenAI o3 — use-after-free בליבת לינוקס
החוקר Sean Heelan מצא את CVE-2025-37899, חולשת use-after-free ברכיב שרת ה-SMB (ksmbd) של ליבת לינוקס (מאי 2025). מה שהפך את זה למעניין: הוא השתמש ב-API של המודל בלבד, בלי כלים ובלי scaffolding, והזין אליו כ-12 אלף שורות קוד. הנתון שאסור לדלג עליו הוא שיעור ההצלחה הנמוך — לפי הדיווחים המודל תפס את הבאג רק בחלק קטן מהריצות, לצד הרבה התרעות שווא. כלומר ה-AI מסייע לחוקר מיומן, לא מחליף אותו.
XBOW — ראשון בטבלת HackerOne
XBOW, פנטסטר AI אוטונומי, הגיע למקום הראשון בטבלת HackerOne בארה"ב (יוני 2025). לפי הדיווח הוא הגיש מעל 1,000 דיווחים — אבל רק כ-132 אושרו ותוקנו בפועל, בעוד מאות סומנו ככפילויות או כ"אינפורמטיביים". המספר הגדול הוא נפח, לא בהכרח ערך — נקודה שנחזור אליה.
המשותף לשלושת המקרים: ה-AI אכן הגיע לממצא אמיתי שחוקרים אנושיים לא תפסו — אבל בכל אחד מהם האדם נשאר במעגל, בין כסינון של התרעות שווא ובין כמי שמאשר, משחזר ומדווח באחריות.
אוטומציה מלאה: אתגר ה-AI של DARPA
המקרים למעלה הם מוצא יחיד. השאלה הגדולה יותר היא אם אפשר לבנות מערכת שמוצאת ומתקנת חולשות בלי אדם בלולאה — וזו בדיוק הייתה המטרה של AI Cyber Challenge (AIxCC) של DARPA, שהגמר שלו נערך ב-DEF CON 33 (אוגוסט 2025).
הקבוצות בנו "מערכות היסק סייבר" (Cyber Reasoning Systems) שרצות אוטונומית על קוד פתוח. לפי הסיכום של DARPA, בגמר הן התמודדו עם כ-54 מיליון שורות קוד ו-63 אתגרים, גילו 54 חולשות ייחודיות (סינתטיות, שהוזרקו לגרסאות מפוצלות של פרויקטים אמיתיים), וגם הציעו להן תיקונים. התוצאות:
- Team Atlanta (Georgia Tech, Samsung Research, KAIST, POSTECH) — מקום ראשון, פרס 4 מיליון דולר.
- Trail of Bits (מערכת בשם Buttercup) — מקום שני, 3 מיליון דולר.
- Theori — מקום שלישי, 1.5 מיליון דולר.
הספירות המדויקות נבדלות בין המקורות (DARPA אף תיקנה מספר קודם), ולכן אני מביא את נתוני DARPA עצמם ונמנע מנתונים משניים שלא אומתו. המסקנה המהותית אינה תלויה בספירה: מערכת אוטומטית כבר יכולה לעבור מגילוי לתיקון בלי אדם — וזה משנה את לוח הזמנים של שני הצדדים.
איך AI מוצא חולשה — ברמה העקרונית
בלי מתכונים לתקיפה, כדאי להבין את המנגנון כדי להעריך נכון גם את האיום וגם את ההגנה. שלוש גישות מרכזיות:
- ניתוח וריאנטים (variant analysis). נותנים למודל חולשה ידועה ומבקשים למצוא מופעים דומים בקוד אחר. כאן ה-AI חזק במיוחד — הוא סורק כמות גדולה של קוד ומזהה את אותו דפוס שגיאה במקומות שאדם לא היה מגיע אליהם ידנית.
- Fuzzing מונחה-LLM. שילוב של fuzzing קלאסי (הזנת קלט רב ומגוון) עם מודל שמנחה לאן כדאי "לדחוף", כדי להגיע לנתיבי קוד עמוקים מהר יותר.
- קריאת קוד והיסק. מודל קורא פונקציה ומסיק שרצף מסוים של קריאות מוביל למצב לא-תקין — שימוש-אחרי-שחרור, גלישת חוצץ וכדומה. כאן בולט יחס האות-לרעש: הרבה השערות, מעט אמת.
המשותף לשלושתן: ה-AI מייצר השערות בכמות גדולה. מה שהופך השערה לחולשה מאומתת הוא עדיין אימות — הרצה, שחזור, ולעיתים הוכחת-היתכנות — וזה שלב שנשאר אנושי. זו גם הסיבה שהנתון "כמה חולשות ה-AI מצא" כמעט תמיד מטעה בלי הנתון המשלים: כמה מתוכן אושרו.
איך מערכת כזו בנויה — המקרה של Big Sleep
כדי להעריך נכון גם את האיום וגם את הפוטנציאל ההגנתי, שווה להבין איך סוכן מחקר חולשות עובד. לפי Google, Big Sleep (שהתפתח מ-Project Naptime, ומבוסס לפי הדיווחים על Gemini 1.5 Pro) נותן למודל ארגז כלים במקום רק טקסט: כלי לניווט בקוד, סביבת Python מבודדת לייצור קלטי fuzzing, ו-debugger לבחון מה קורה בפועל בזמן ריצה. המודל מריץ לולאת היסק — משער, בודק ומתקן את עצמו — כמו חוקר אנושי, רק מהר יותר ועל יותר קוד.
הממצא ב-SQLite הגיע דרך ניתוח וריאנטים: נתנו למודל חולשה שתוקנה לאחרונה וביקשו לחפש מופעים דומים שאולי לא תוקנו. זו הסיבה שזה רלוונטי ישירות למגן — אותה שיטה עובדת על הקוד שלכם: בכל פעם שמתפרסם תיקון בספרייה שאתם מריצים, כדאי לבדוק אם אותו דפוס חוזר אצלכם.
במה ה-AI חזק, ובמה פחות
הבנה מפוכחת של היכולת עוזרת לתעדף גם בדיקה וגם הגנה:
- חזק: פגיעויות זיכרון ודפוסים חוזרים. שימוש-אחרי-שחרור, גלישות חוצץ, ווריאנטים של באג ידוע — כאן ה-AI סורק הרבה קוד ומזהה את אותו דפוס שגיאה. שני הממצאים ב-SQLite ושל ליבת לינוקס הם בדיוק מהסוג הזה.
- חזק: כיסוי רוחב. מודל יכול לעבור על הרבה יותר קוד ממה שחוקר בודד מספיק, ולהצביע על מקומות חשודים לבדיקה ממוקדת.
- חלש: לוגיקה עסקית ופגמי תכנון. חולשה שנובעת מהבנת ההקשר ("קוד ההנחה הזה רגיש", "התהליך הזה מניח אמון") קשה הרבה יותר למודל, כי היא דורשת ידע שאינו כתוב בקוד.
- חלש: אימות ודיוק. היחס אות-לרעש נמוך — הרבה השערות שגויות על כל ממצא אמיתי, ולכן האימות האנושי הוא צוואר הבקבוק.
המשמעות המעשית: הפעילו AI על מה שהוא טוב בו — סריקת דפוסים רחבה — והשאירו לאדם את מה שדורש הקשר והכרעה.
הצד השני: הצפת רעש ("AI slop")
אותה יכולת שמוצאת באג אמיתי מייצרת גם המון דיווחי-סרק משכנעים למראית עין:
- פרויקט curl סגר את תוכנית ה-bug bounty שלו (31 בינואר 2026) אחרי שלפי המתחזק Daniel Stenberg כ-20% מהדיווחים ב-2025 היו "זבל" שנוצר ב-AI, בעוד רק כ-5% היו חולשות אמיתיות. ובכל זאת — AI בליווי אדם הוביל שם לתיקון של עשרות באגים אמיתיים. ההבחנה חדה: AI מאומת בידי אדם אינו הגשה אוטומטית סיטונאית.
- אינפלציה של שמות. ב-2026 צצו גלים של שמות דומים בסגנון "...2Shell", עד כדי כותרת "This2Shell, That2Shell, Everything's an RCE?". חלקם חולשות אמיתיות, וחלקם פרודיה גמורה (למשל "Terminal2Shell" הוא מתיחה מתוכננת). המסקנה המעשית: שם מפחיד אינו ראיה. לפני שמגיבים — בודקים מקור, מספר CVE ואסמכתה.
הרעש אינו מטרד בלבד; הוא עלות. כל דיווח-סרק גוזל זמן triage אמיתי, ומסיט קשב מהחולשה שבאמת מסכנת אתכם.
מה זה משנה למי שמגן
שתי מסקנות ישירות:
- חלון התיקון מתקצר. אם ה-AI מוצא מהר יותר, גם הצד התוקף נעזר באותם כלים. ההנחה הנכונה היא שהזמן בין פרסום חולשה לניצולה הולך ומתקצר — ולכן תעדוף נכון של patching חשוב מאי-פעם.
- אוריינות רעש היא מיומנות הגנתית. צוות שמטביע כל התרעה אוטומטית יבזבז את זמנו על slop ויפספס את האמת. צריך triage ממושמע, לא עוד כלי שמייצר התרעות.
שימו לב לסימטריה: אותו כלי שמסייע לתוקף הוא גם הכלי שמסייע לכם. מי שמפעיל variant analysis על הקוד של עצמו לפני התוקף — מרוויח את חלון הזמן במקום להפסיד אותו.
יש כאן גם א-סימטריה שחשוב להכיר: לתוקף מספיק למצוא חולשה אחת, ולמגן צריך לכסות את כל השטח. כשהעלות של סריקה אוטומטית יורדת, הצד התוקף מרוויח קנה-מידה — ובמיוחד בקוד פתוח, שבו מתחזק יחיד מתמודד מול הרבה סורקים. זה בדיוק מה שראינו ב-curl: לא מתקפה מתוחכמת, אלא עומס. ההגנה אינה "AI חזק יותר" אלא תהליך: תעדוף לפי ניצול, אוטומציה של העבודה החוזרת, ושמירת תשומת הלב האנושית למקום שבו היא באמת נחוצה.
איך להתגונן — מעשי
- תעדוף לפי ניצול בפועל. אל תרדפו אחרי כל CVE לפי CVSS בלבד. הירשמו ל-CISA KEV (Known Exploited Vulnerabilities) ותקנו קודם את מה שמנוצל בשטח.
- סריקת תלויות ב-CI. Dependabot או
osv-scannerבכל build, כדי לתפוס רכיב פגיע לפני פריסה. נהלו SBOM כדי בכלל לדעת מה רץ אצלכם — אי אפשר לתקן מה שלא יודעים שקיים. - AI הגנתי — עם אדם בלולאה. code scanning מבוסס-מודל שימושי לניתוח וריאנטים, אבל הניחו שיעור התרעות-שווא גבוה; האימות האנושי הוא חובה, לא רשות. אל תפתחו טיקט אוטומטית מכל ממצא.
- triage לדיווחים נכנסים. אם אתם מקבלים דיווחי חולשות, דרשו PoC שניתן לשחזור וסננו slop — זה בדיוק מה שהפיל את curl. דיווח בלי שחזור אינו ממצא.
- אל תסתמכו על סירוב המודל כגבול אבטחה. שלבו בקרות טכניות: הרשאות מינימליות, בידוד, ולוגים בלתי-ניתנים-לעריכה.
בניית תוכנית ניהול חולשות בעידן ה-AI
אם חלון התיקון מתקצר, "נתקן כשנראה" כבר לא מספיק. תוכנית מסודרת נשענת על חמישה אבני-יסוד:
- אינוונטר נכסים + SBOM. אי אפשר לתקן מה שלא יודעים שקיים. נהלו רשימת רכיבים (Software Bill of Materials) מעודכנת לכל שירות, כולל תלויות עקיפות.
- תעדוף לפי ניצול, לא רק חומרה. הצליבו כל CVE מול CISA KEV ומול החשיפה האמיתית שלכם. חולשה "קריטית" ברכיב שאינו נגיש מהרשת פחות דחופה מ"בינונית" בשירות חשוף שמנוצל בטבע.
- VEX — מה באמת רלוונטי. לא כל CVE ברכיב משפיע עליכם. תיעוד VEX (Vulnerability Exploitability eXchange) מאפשר לומר "הרכיב פגיע אבל איננו מושפעים כי..." — ולחסוך מרדף אחרי רעש.
- SLA לתיקון וארכיטקטורת הפצה. הגדירו זמן יעד לפי דחיפות, ודאגו שתוכלו לפרוס תיקון מהר (CI/CD, גלגול מבוקר).
- זיהוי, לא רק מניעה. הניחו שתיקון יאחר לפעמים. ניטור ולוגים מאפשרים לזהות ניצול עוד לפני שהספקתם לתקן.
שום שלב כאן אינו "AI" בפני עצמו — אבל AI יכול להאיץ כל אחד מהם: לסכם advisory, להצליב מול ה-SBOM, או להציע patch לבדיקה. העיקרון נשאר: המכונה מאיצה, האדם מכריע.
AI בצד המגן, לא רק ככלי תקיפה
המסקנה אינה "להיזהר מ-AI" אלא להשתמש בו נכון, לפני שמישהו אחר יעשה זאת נגדכם:
- הריצו variant analysis על הקוד שלכם. כשמתפרסמת חולשה בספרייה שאתם משתמשים בה, אותו דפוס עלול לחזור בקוד שלכם. מודל טוב בלמצוא את המופעים הדומים — בתנאי שאדם יאמת כל אחד.
- סיכום מודיעין אוטומטי. אפשר לבנות צינור שאוסף advisories ומתעדף אותם מול הנכסים שלכם. ראו את מדריך מודיעין האיומים מבוסס AI — אותו עיקרון בדיוק: חילוץ עובדות דטרמיניסטי, והמודל לא מקבל את ההחלטה הסופית.
- בדיקה יזומה. אם אתם בונים מערכת AI, בדקו אותה לפני הפריסה. המדריך Red Teaming ל-LLM מראה איך — threat model, מיפוי OWASP, ואוטומציה עם כלים ייעודיים.
איך להתעדכן — מקורות אמינים
עדיף מקור סמכותי על פני ציוץ עם שם קליט:
- CISA KEV — מה מנוצל בפועל, לתעדוף.
- NVD / CVE — רישום החולשות הרשמי.
- GitHub Security Advisories (GHSA) ו-OSV / OSS-Fuzz — במיוחד לתלויות קוד פתוח.
- Advisories ישירות מהספקים שאתם מריצים — OpenSSH, SQLite, הפצת הלינוקס שלכם, ספקי הענן.
הגדירו ערוץ אחד שבו הדברים האלה נאספים — מייל, Slack או צינור אוטומטי — כדי שלא תהיו תלויים בזיכרון של מישהו. עדכון עקבי שווה יותר ממאמץ גדול וחד-פעמי.
שגרה שבועית פשוטה: פעם בשבוע עברו על עדכוני KEV וה-advisories של הספקים שלכם, הצליבו מול ה-SBOM ותעדפו. פעם ברבעון קראו דיווח מגמות (כמו ה-exploit roundups) כדי לראות מה באמת מנוצל בשטח. הקבוע החשוב הוא עקביות, לא היקף.
שאלות נפוצות
האם AI מחליף פנטסטרים וחוקרי אבטחה?
לא, נכון להיום. בכל המקרים המתועדים ה-AI הגיע לממצא אמיתי, אבל עם שיעור אות נמוך והרבה התרעות שווא — והאדם נשאר מי שמאמת, משחזר ומחליט. המודל מרחיב את ההספק של חוקר מיומן; הוא לא מייתר אותו.
האם הקוד שלי בסיכון גבוה יותר עכשיו?
הסיכון לא נולד עכשיו — הוא פשוט מתגלה מהר יותר, גם בידי מגנים וגם בידי תוקפים. המסקנה המעשית היא לקצר את חלון התיקון: תעדוף לפי KEV, סריקת תלויות, ו-SBOM מעודכן.
אפשר לסמוך על סורק חולשות מבוסס-AI?
כעזר — כן; כפוסק אחרון — לא. הניחו שיעור התרעות-שווא גבוה, ואל תפתחו טיקט או תמזגו patch בלי אימות אנושי.
מה זה "AI slop"?
דיווחי חולשות שנוצרו ב-AI ונראים משכנעים אבל חסרי ביסוס. הם הציפו פרויקטים כמו curl עד שסגרו את ה-bug bounty. ההגנה: לדרוש PoC שניתן לשחזור בכל דיווח.
סיכום מעשי
- AI כבר מוצא חולשות אמיתיות (SQLite, ליבת לינוקס) — אבל כמסייע לחוקר, עם שיעור אות נמוך.
- אותה יכולת מציפה רעש; נפח דיווחים אינו ערך, ורק מה שאומת ותוקן נחשב.
- למגן: חלון התיקון מתקצר, ואוריינות רעש היא מיומנות.
- תעדפו לפי KEV, סרקו תלויות, נהלו SBOM, ואמתו כל ממצא AI אנושית.
- שם מפחיד אינו ראיה — בדקו מקור לפני שמגיבים.
- השתמשו ב-AI גם בצד המגן: variant analysis על הקוד שלכם, ובדיקה יזומה לפני פריסה.
המשך באשכול האבטחה
המשיכו באשכול האבטחה — מהחולשות עצמן ועד להגנה ולבדיקה יזומה.