באוקטובר 2026 נחשפה שרשרת חולשות בממשק הווב של ChatGPT. השרשרת אפשרה לתוקף להריץ JavaScript משלו בתוך סשן מחובר של קורבן, ונדרש לשם כך רק קישור שיתוף ציבורי. הבאג לא ישב במנגנון ההתחברות וגם לא ב-OAuth. הוא ישב במקום הרבה פחות צפוי: מאזין message שספריית המקלדת המתמטית MathLive התקינה בדף הראשי. המקרה הזה הוא שיעור מרוכז באבטחת postMessage, ובעיקר בשאלה מי בכלל מאזין להודעות בדף שלכם.
OpenAI דירגה את הבעיה בחומרה P1, תיקנה אותה ב-26 באוקטובר 2026 ושילמה באונטי של 5,000 דולר (HyperAI). לא הוקצה CVE ואין דיווח על ניצול בפועל (Ostorlab). עם זאת, הדפוס עצמו נפוץ הרבה מעבר ל-ChatGPT: ספריית צד שלישי מוסיפה מאזין גלובלי, מקבלת הודעות מכל שולח ומכניסה HTML לדף.
המאמר מפרק את השרשרת שלב אחר שלב ומסביר למה אף אחת מהשכבות לא עצרה אותה, לא ה-sandbox, לא ה-CSP ולא אבטחת ההתחברות. בסופו מופיע צ'קליסט מעשי לבדיקת מאזיני postMessage, הגדרות iframe sandbox ו-Content Security Policy באפליקציות Next.js ו-React ובווידג'טים של צד שלישי.
מה קרה: קישור שיתוף אחד, גישה מלאה לחשבון
לפי HyperAI, קישור שיתוף ציבורי זדוני של ChatGPT יכול היה להריץ JavaScript של התוקף תחת הדומיין chatgpt.com, בתוך הסשן של משתמש מחובר. מבחינת הדפדפן, הקוד של התוקף היה קוד של ChatGPT לכל דבר. לכן הוא נהנה מאותן הרשאות שיש לממשק עצמו.
ציר הזמן של הגילוי והתיקון היה קצר יחסית:
- 18 באוקטובר 2026: חברת Parameter Security דיווחה על השרשרת ל-OpenAI (HyperAI).
- 21 באוקטובר 2026: הבעיה שוחזרה והחומרה הועלתה ל-P1.
- 26 באוקטובר 2026: הבעיה נפתרה במלואה (Ostorlab).
- באונטי: 5,000 דולר.
מה הקוד המוזרק יכול היה לעשות
לפי הניתוח של SamCodeMan, הקוד המוזרק יכול היה לשלוף את רשימת השיחות של הקורבן ולמשוך שיחה פרטית שמעולם לא שותפה עם התוקף. החוקרים שלחו החוצה רק פיסת מידע קטנה כהוכחת היתכנות, אבל הקוד היה מסוגל לקרוא את כל המידע.
לארגונים שבהם עובדים מדביקים ל-ChatGPT מסמכים, קוד או נתוני לקוחות, זה התרחיש הגרוע ביותר. היסטוריית השיחות היא לעיתים קרובות מאגר מידע רגיש יותר מתיבת המייל.
כמה אינטראקציה נדרשה מהקורבן
בגרסה האמינה ביותר של המתקפה, הקורבן היה צריך ללחוץ פעם אחת על Preview. בגרסה מאוחרת יותר עצם פתיחת הקישור הספיקה. Parameter שחזרה את המסלול האוטומטי שלוש פעמים, כולל אחרי hard refresh (Ostorlab). לפי SamCodeMan, בגרסה האוטומטית עברו כ-4.5 שניות עד שהופיעה התראת ההוכחה.
כדאי לשים לב שהמקורות המשניים מתארים את רמת האינטראקציה באופן מעט שונה. כולם מסכימים שקיימת גרסה אוטומטית. הפוסט המקורי של Parameter לא נכלל בחומרים שפורסמו בדיווחים האלה.
אנטומיה של השרשרת: Preview, MathLive, srcdoc ו-JSONP
מה שמעניין בשרשרת הוא שכל רכיב בה סביר לחלוטין כשבוחנים אותו לבד. תצוגה מקדימה של HTML בארגז חול היא רעיון טוב, וכך גם גרף אינטראקטיבי עם מקלדת מתמטית. רשימת היתר ב-CSP שכוללת את YouTube נשמעת הגיונית. הבעיה נוצרה מהשילוב ביניהם.
שלב 1: HTML Preview בארגז חול
לפי HyperAI, ChatGPT מציע תכונת HTML Preview שמרנדרת HTML בתוך frame מבודד, על origin נפרד משלו. התוקף שולט בתוכן הזה דרך השיחה ששותפה, ולכן יש לו נקודת אחיזה ראשונית. נקודת האחיזה הזאת מבודדת מ-chatgpt.com.
שלב 2: גרף אינטראקטיבי שטוען את MathLive
בדף הראשי של ChatGPT הופיע גרף אינטראקטיבי שטען את ספריית MathLive. MathLive התקינה בדף הראשי מאזין postMessage שנועד להגדרות המקלדת הווירטואלית (HyperAI). זו נקודת המפתח: לא מפתחי ChatGPT כתבו את המאזין, אלא ספרייה חיצונית.
שלב 3: הודעה בלי אימות שולח, HTML ישר ל-innerHTML
המאזין של MathLive לא אימת את השולח כשהגיעה הודעה לעדכון הגדרה מרכזית. הוא קיבל HTML גולמי בתור נתוני פריסת מקלדת, וה-HTML הוזרק לדף הראשי באמצעות innerHTML (HyperAI). כלומר, frame ה-Preview על ה-origin המבודד שלו יכול היה לגרום לדף הראשי להזריק markup לבחירת התוקף.
שלב 4: iframe עם srcdoc שיורש את ה-origin של chatgpt.com
תגיות <script> שמוכנסות דרך innerHTML לא רצות, ולכן התוקפים עקפו את המגבלה. ה-payload יצר בתוך הדף הראשי iframe עם srcdoc וללא sandbox. ה-iframe הזה ירש את ה-origin של chatgpt.com, וכך התוקף קיבל דריסת רגל באותו origin (HyperAI).
שלב 5: עקיפת CSP עם JSONP של YouTube
מדיניות ה-CSP של ChatGPT חסמה JavaScript מסוג inline, אבל החוקרים עקפו אותה עם תגובת oEmbed של YouTube שמכילה JSONP callback. YouTube היה ברשימת ההיתר של מדיניות הסקריפטים, ולכן ה-callback הריץ JavaScript שרירותי כ-chatgpt.com (HyperAI).
למה אבטחת ההתחברות לא שיחקה תפקיד
המתקפה לא נגעה ב-login, ב-SSO או ב-OAuth. הסקריפט המוזרק פשוט קרא לנקודות קצה בצד השרת, למשל GET /backend-api/conversations עם הפרמטרים limit ו-offset, והשתמש בסשן הקיים של הקורבן (SamCodeMan). בדיון ב-Hacker News מגיב אחד פירש את הבעיה ככשל OAuth. תגובה אחרת הבהירה שמדובר בהזרקת HTML דרך מקבל postMessage שלא בדק את השולח.
הלקח כאן חד: אימות דו-שלבי, מפתחות passkey וזרימות התחברות מוקשחות לא עוזרים כשהתוקף כבר מריץ קוד בתוך ה-origin שלכם. חולשת XSS באפליקציה שמשתמשת בעוגיות סשן היא פריצה לחשבון בפועל, גם בלי לגעת בסיסמה.
ה-sandbox החזיק, הדף הראשי נפל
לפי SamCodeMan, ארגז החול של HTML Preview עצמו לא נפרץ. השבירה הגיעה ממאזין MathLive בדף הראשי, שקיבל הודעות מכל origin ורינדר את ה-HTML שסופק לו. הבידוד עבד כמתוכנן, אבל הדף שמעליו פתח לו דלת.
זה דפוס שחוזר שוב ושוב בבעיות postMessage: צוותים משקיעים בבידוד התוכן הלא-מהימן, ושוכחים שערוץ התקשורת בין המבודד לבין הדף הראשי הוא בדיוק המקום שבו הבידוד נגמר. SecureLayer7 מתארת את חוסר בדיקת המקור ואת השימוש בנתוני הודעה בתוך sinks מסוכנים כשתי הטעויות הנפוצות ביותר בתחום.
צ'קליסט אבטחת postMessage: בדיקת origin, source ו-isTrusted
OpenAI תיקנה את הבעיה בצד השרת. התיקון דוחה את הודעות ה-MathLive שמגיעות בין frames, בשתי גרסאות ה-frontend של האתר (Ostorlab). צוותים אחרים לא יכולים לסמוך על תיקון כזה, וצריכים לבדוק את האפליקציות שלהם.
מה הדפדפן מבטיח ומה לא
כשהודעה נשלחת דרך postMessage, הדפדפן מגדיר את השדה origin של ה-MessageEvent לפי ה-origin של השולח, ואי אפשר לזייף אותו מבחוץ. עם זאת, קוד שרץ באותו origin יכול לשגר MessageEvent מזויף עם כל origin שירצה. לכן TEKNKL ממליצים לבדוק גם את isTrusted ולא רק את origin.
בנוסף, origin מזהה רק את הדומיין של השולח ולא את החלון המדויק. אם יש בדף כמה frames מאותו origin, או אם תוקף מצליח לפתוח חלון משלו על origin מורשה, בדיקת origin לבדה לא מספיקה. כאן נכנס event.source.
שלוש בדיקות בכל מאזין
Ostorlab ממליצים לבדוק גם את event.origin וגם את event.source. בצירוף ההמלצה של TEKNKL לגבי isTrusted, מאזין בטוח נראה בערך כך:
const WIDGET_ORIGIN = 'https://widget.example.com';
function createMessageHandler(frame: HTMLIFrameElement) {
return (event: MessageEvent) => {
// 1. דחיית אירועים שנוצרו ידנית בקוד
if (!event.isTrusted) return;
// 2. רק origin מוכר ומדויק, לא includes ולא endsWith
if (event.origin !== WIDGET_ORIGIN) return;
// 3. רק החלון הספציפי שאנחנו מצפים לו
if (event.source !== frame.contentWindow) return;
const message = parseWidgetMessage(event.data);
if (!message) return;
handleWidgetMessage(message);
};
}כמה הערות חשובות על הקוד:
- השוואה מדויקת: בדיקות כמו
origin.includes('example.com')אוorigin.endsWith('example.com')נופלות מול דומיינים כמוexample.com.attacker.netאוevil-example.com. - בדיקה לפני כל לוגיקה: הבדיקות צריכות לרוץ לפני כל פעולה שמשנה state, ולא רק לפני חלק מסוגי ההודעות. במקרה של MathLive, דווקא עדכון הגדרה מרכזי עבר ללא אימות (HyperAI).
- אין sinks של HTML: גם אחרי כל הבדיקות, אין להעביר נתונים מההודעה ל-
innerHTML, ל-outerHTML, ל-insertAdjacentHTMLאו ל-dangerouslySetInnerHTML.
אל תשלחו עם targetOrigin של כוכבית
הבעיה קיימת גם בכיוון השני. שימוש ב-"*" בתור targetOrigin בשליחת postMessage מסיר כל הגבלה על מי שיכול לקבל את ההודעה. הפתרון המומלץ הוא origin מפורש ומהימן (Orbis AppSec):
// לא טוב: כל חלון שנמצא כרגע ב-frame יקבל את הטוקן
frame.contentWindow?.postMessage({ token }, '*');
// טוב: ההודעה תגיע רק אם ה-frame באמת נמצא על ה-origin הצפוי
frame.contentWindow?.postMessage({ token }, 'https://widget.example.com');ולידציית מטען: סכימה לפני לוגיקה
השדה event.data הוא קלט חיצוני לכל דבר. גם כשהשולח מאומת, עדיף לאכוף מבנה צפוי עם סכימה ולדחות כל דבר אחר. ספריות כמו Zod או Valibot מתאימות לזה במיוחד, ויש השוואה מפורטת בין ספריות ולידציה ל-TypeScript שעוזרת לבחור ביניהן. הכלל הוא לאפשר רשימה סגורה של סוגי הודעות ושדות, ולא לקבל אובייקט פתוח שמועבר הלאה כמו שהוא.
השוואת גישות הגנה
גישה | יתרונות | חסרונות |
|---|---|---|
בדיקת | סטנדרטית, פשוטה ומומלצת בהרבה מדריכים. הדפדפן מבטיח את ה-origin בהודעות postMessage אמיתיות (TEKNKL) | קוד באותו origin יכול לזייף MessageEvent עם כל origin, והבדיקה לא מזהה את החלון המדויק ששלח |
בדיקת origin, source ו-isTrusted | | חוסם גם אירועים סינתטיים לגיטימיים, אם כי לא ברור שיש להם הרבה שימושים. לא עוזר אם ה-handler עדיין כותב נתונים ל-innerHTML |
CSP כהגנה מרכזית | חסם את ה-inline script במקרה הזה, ושימושי כשכבת גיבוי (SamCodeMan) | נקודת קצה JSONP אחת ברשימת ההיתר הספיקה להרצת קוד שרירותי, והוא לא יכול להיות המחסום היחיד אחרי ש-HTML של תוקף הגיע לדף |
הצ'קליסט המלא
- מפו כל קריאה ל-
addEventListener('message', ...)ול-onmessage, גם בקוד שלכם וגם בספריות. - ודאו שכל מאזין בודק
event.originמול רשימה סגורה בהשוואה מדויקת. - ודאו שכל מאזין שמקבל הודעות מ-frame מוגדר בודק
event.sourceמול ה-contentWindowשלו. - הוסיפו בדיקת
event.isTrustedלמאזינים שמשנים state. - אכפו סכימה על
event.dataלפני כל שימוש. - אסרו העברה של נתוני הודעה ל-
innerHTMLולכל sink אחר של HTML או קוד, כוללeval,new Functionו-setTimeoutעם מחרוזת. - בכל קריאה ל-
postMessageהחליפו"*"ב-origin מפורש. - הסירו מאזינים כשהקומפוננטה יורדת מהמסך, כדי שלא יישארו מאזינים יתומים.
iframe sandbox ו-srcdoc: ה-origin שעובר בירושה
השלב הרביעי בשרשרת הוא אולי הפחות מוכר למפתחים. iframe עם srcdoc וללא sandbox ירש את ה-origin של chatgpt.com (HyperAI). לכן הוא לא היה מבודד בכלל, אלא עוד חלון באותו origin עם גישה לאותו סשן.
למה srcdoc מסוכן בלי sandbox
מסמך שנטען דרך srcdoc (וגם about:blank) לא מגיע מכתובת רשת משלו, ולכן הדפדפן משייך אותו ל-origin של המסמך שיצר אותו. מכאן שכל HTML שנכנס ל-srcdoc בלי sandbox מקבל בדיוק אותן הרשאות כמו הדף הראשי. מנקודת המבט של אבטחה, זה שקול להכנסת אותו HTML ישירות לדף.
Ostorlab ממליצים לשמור כל מסמך דינמי בתוך sandbox. בפועל זה אומר כמה כללים:
- תמיד להגדיר
sandboxעל iframe שמציג תוכן שנוצר דינמית או שמגיע ממשתמש או ממודל שפה. - לא לשלב
allow-scriptsעםallow-same-originעל תוכן לא מהימן מאותו origin. השילוב הזה מאפשר לתוכן להסיר את ה-sandbox מעצמו ומבטל בפועל את הבידוד. - להעדיף origin נפרד: תוכן לא מהימן עדיף לארח על דומיין ייעודי, כפי ש-ChatGPT עשתה עם Preview, ולא על הדומיין הראשי.
- להוסיף הרשאות במשורה:
allow-popups,allow-formsו-allow-top-navigationרק כשיש צורך מוכח.
iframe מבודד ב-React
type PreviewProps = { html: string };
export function SafePreview({ html }: PreviewProps) {
return (
<iframe
title="תצוגה מקדימה"
srcDoc={html}
// סקריפטים מותרים, אבל המסמך מקבל origin אטום (opaque)
sandbox="allow-scripts"
referrerPolicy="no-referrer"
loading="lazy"
/>
);
}בזכות sandbox="allow-scripts" בלי allow-same-origin, המסמך מקבל origin אטום. גם אם ירוץ בו קוד זדוני, הוא לא יוכל לגשת לעוגיות, ל-localStorage או ל-DOM של הדף הראשי. אבל כפי שהמקרה של ChatGPT מראה, ההגנה הזאת תקפה רק אם הדף הראשי לא מאזין להודעות מה-frame בלי לבדוק אותן.
Content Security Policy: רשימות היתר, JSONP והגנה לעומק
במקרה של ChatGPT, ה-CSP דווקא עשה את מה שהוא אמור לעשות: הוא חסם JavaScript מסוג inline. אבל ברשימת ההיתר הופיע YouTube, ונקודת קצה של oEmbed שמחזירה JSONP callback הספיקה כדי להריץ קוד שרירותי כ-chatgpt.com (HyperAI). זו הסיבה ש-Ostorlab ממליצים להתייחס ל-CSP כשכבת גיבוי בלבד.
למה רשימות היתר לפי דומיין נשברות
Content Security Policy שמתירה דומיין שלם ב-script-src מתירה גם כל קובץ ונקודת קצה בדומיין הזה. אם יש בדומיין נקודת קצה כלשהי שמחזירה JavaScript שהתוקף שולט בחלק ממנו, למשל JSONP עם פרמטר callback, רשימת ההיתר הופכת לכלי עקיפה. דומיינים גדולים של פלטפורמות ושל CDN ציבוריים הם המועמדים הקלאסיים לבעיה הזאת.
כמה עקרונות לבניית מדיניות קשוחה יותר:
- nonce ו-
strict-dynamicבמקום רשימות של דומיינים ב-script-src. כך רק סקריפטים שהשרת סימן במפורש יכולים לרוץ. - הפרדה בין
script-srcל-frame-src: הטמעת וידאו של YouTube דורשת בדרך כלל רקframe-src, לא היתר להריץ סקריפטים מהדומיין. object-src 'none'ו-base-uri 'none'כדי לסגור וקטורי עקיפה מוכרים.frame-ancestorsכדי לשלוט במי שיכול להטמיע את האפליקציה שלכם.
Trusted Types: לחסום את ה-sink עצמו
השורש של השרשרת הוא השמה ל-innerHTML. ההנחיה require-trusted-types-for 'script' ב-CSP, שנתמכת בדפדפנים מבוססי Chromium, גורמת לדפדפן לדחות השמת מחרוזות רגילות ל-sinks כמו innerHTML, אלא אם הן עברו דרך policy מוגדרת. זו הגנה שמכוונת בדיוק לסוג הבאג שהתגלה ב-MathLive. כדאי להפעיל אותה קודם במצב Content-Security-Policy-Report-Only כדי לגלות אילו ספריות מפרות אותה.
דוגמת כותרות ב-Next.js
// next.config.js
const csp = [
"default-src 'self'",
"script-src 'self'",
"frame-src https://www.youtube-nocookie.com",
"object-src 'none'",
"base-uri 'none'",
"frame-ancestors 'self'",
"require-trusted-types-for 'script'",
].join('; ');
module.exports = {
async headers() {
return [
{
source: '/(.*)',
headers: [
{ key: 'Content-Security-Policy-Report-Only', value: csp },
],
},
];
},
};באפליקציות Next.js שמשתמשות ב-App Router, מדיניות מבוססת nonce נבנית בדרך כלל ב-middleware, שמייצר nonce חדש בכל בקשה ומעביר אותו לרינדור. הדוגמה למעלה סטטית ומיועדת להמחשה. כדאי להריץ אותה קודם במצב Report-Only ורק אחר כך לאכוף.
יישום ב-Next.js, React ווידג'טים של צד שלישי
הלקח המרכזי מהמקרה הוא שספריות צד שלישי מוסיפות מאזיני הודעות לדף הראשי, והמאזינים האלה צריכים לעבור את אותה בדיקה כמו הקוד שלכם. במקרה של ChatGPT, המאזין הבעייתי בכלל לא נכתב על ידי הצוות שתחזק את האפליקציה.
למצוא את כל מאזיני ה-message בדף
יש שלוש דרכים משלימות למפות מאזינים:
- DevTools: בקונסולה של Chrome, הפקודה
getEventListeners(window).messageמציגה את כל מאזיני ה-message שרשומים על window. גם לשונית Event Listeners בחלונית Elements מציגה אותם, כולל הקובץ שממנו הגיעו. - חיפוש סטטי: חיפוש בקוד המקור ובחבילות שבשימוש.
- מעקב בזמן ריצה: עטיפה זמנית של
addEventListenerבסביבת פיתוח בלבד.
# חיפוש מאזיני message בספריות שנכללות בבאנדל
rg -n "addEventListener\(.message" node_modules --glob '*.js' | head -50
# חיפוש sinks של HTML בספרייה ספציפית
rg -n "innerHTML|insertAdjacentHTML" node_modules/mathlive/dist// סביבת פיתוח בלבד: הדפסת stack trace לכל מאזין message שנרשם
if (process.env.NODE_ENV === 'development' && typeof window !== 'undefined') {
const original = window.addEventListener;
window.addEventListener = function (type: string, listener: any, options?: any) {
if (type === 'message') {
console.trace('[audit] message listener registered', listener);
}
return original.call(this, type, listener, options);
} as typeof window.addEventListener;
}ה-stack trace מראה בדיוק איזו ספרייה רשמה כל מאזין. מכאן אפשר לפתוח את הקוד שלה ולבדוק אם היא מאמתת origin ו-source ולאן הנתונים זורמים.
מאזין בטוח כ-hook ב-React
import { useEffect, type RefObject } from 'react';
export function useFrameMessages(
frameRef: RefObject<HTMLIFrameElement>,
allowedOrigin: string,
onMessage: (data: unknown) => void,
) {
useEffect(() => {
function handler(event: MessageEvent) {
if (!event.isTrusted) return;
if (event.origin !== allowedOrigin) return;
if (event.source !== frameRef.current?.contentWindow) return;
onMessage(event.data); // ולידציה עם סכימה בתוך onMessage
}
window.addEventListener('message', handler);
return () => window.removeEventListener('message', handler);
}, [frameRef, allowedOrigin, onMessage]);
}ה-hook מרכז את שלוש הבדיקות במקום אחד, ומונע מצב שבו כל קומפוננטה מממשת אותן מחדש, ולפעמים שוכחת אחת מהן. פונקציית הניקוי ב-useEffect מבטיחה שהמאזין לא יישאר פעיל אחרי שה-iframe הוסר.
אבטחת ספריות צד שלישי: מה בודקים לפני הטמעה
אבטחת ספריות צד שלישי לא מסתכמת בבדיקת CVE ידועים. לפני שמכניסים ווידג'ט, עורך עשיר, מקלדת וירטואלית או רכיב צ'אט, כדאי לבדוק:
- האם הספרייה רושמת מאזינים על
windowאו עלdocument, ולאילו אירועים. - האם יש לה API להגדרה דרך postMessage, ואם כן, האם אפשר לכבות אותו.
- האם היא משתמשת ב-
innerHTMLעם נתונים שמגיעים מבחוץ, כמו הגדרות, תבניות ופריסות. - האם היא יוצרת iframes, ואם כן, עם אילו הרשאות sandbox.
הבדיקות האלה משתלבות בתהליך רחב יותר של ניהול תלויות, כמו זה שמתואר בצ'קליסט לאבטחת שרשרת האספקה בתוכנה לצוותים קטנים. ההבדל הוא שכאן מדובר בהתנהגות לגיטימית לכאורה של ספרייה, לא בחבילה זדונית. אירועים כמו תוסף ה-VS Code הזדוני שהתחזה ל-Claude Code מזכירים שגם כלי הפיתוח עצמם הם חלק מאותו משטח תקיפה.
MathLive: שדרוג לא בהכרח פותר את הבעיה
הגילוי הפומבי לא מציין גרסת MathLive שבה הבעיה תוקנה ב-upstream. ב-npm הגרסה האחרונה המופיעה היא v0.111.1, בעוד שב-GitHub Releases מסומנת v0.100.0 כ-latest. לכן Ostorlab מזהירים שלא כדאי להניח ששדרוג יפתור את השרשרת. התיקון של OpenAI היה בצד שלה, ולא בספרייה.
צוותים שמשתמשים ב-MathLive צריכים לבדוק בעצמם איך המקלדת הווירטואלית מקבלת הגדרות בגרסה שבשימוש. במקביל כדאי ליישם את הבקרות בצד האפליקציה: לא לטעון את הספרייה בדף שמכיל frames עם תוכן לא מהימן, או לסנן הודעות בין frames לפני שהן מגיעות אליה.
הזווית הישראלית
המקורות לא מתייחסים לישראל ספציפית, אבל הרלוונטיות ברורה. חברות edtech ישראליות שבונות כלים לתרגול מתמטיקה, עורכי טקסט עם תמיכה בעברית ו-RTL שכוללים מקלדות על המסך, ומוצרי Next.js שמטמיעים ווידג'טים של צד שלישי חשופים כולם לאותו סיכון של מאזין postMessage גלובלי. ספריות כמו MathLive עלולות להיות מושפעות כשהן מוטמעות בדף שמכיל גם תוכן לא מהימן.
בנוסף, צוותים שבונים ממשקי צ'אט מבוססי LLM עם תצוגה מקדימה של HTML, גרפים או ארטיפקטים נמצאים בדיוק בארכיטקטורה של ChatGPT. מי שעוסק בהנדסת קונטקסט ובבניית סוכני AI צריך להתייחס לכל פלט של המודל שמרונדר בדפדפן כקלט לא מהימן. ולארגונים ישראליים שבהם עובדים מדביקים מידע רגיש ל-ChatGPT, זו הזדמנות טובה לרענן את הנהלים לגבי פתיחת קישורי שיתוף ממקורות לא מוכרים.
שאלות נפוצות
האם מנגנון ההתחברות או ה-OAuth של ChatGPT נפרצו?
לא. הניתוחים לא מתארים שום פגם ב-login, ב-SSO או ב-OAuth. ה-payload השתמש מחדש בסשן הקיים של הקורבן, כי הוא הריץ JavaScript תחת chatgpt.com (SamCodeMan).
האם משתמשי ChatGPT עדיין בסיכון?
לא. התיקון נפרס בצד השרת, ומשתמשים לא צריכים להתקין דבר או לאפס סיסמה. פתיחה של קישור שיתוף זדוני היום לא מריצה את ה-payload (Ostorlab).
האם ה-sandbox של HTML Preview נכשל?
לא. הבידוד של Preview החזיק. השבירה הגיעה ממאזין נפרד של MathLive בדף הראשי, שקיבל הודעות בין frames בלי לבדוק את השולח (SamCodeMan).
איך התוקף עקף את ה-CSP?
באמצעות טעינת תגובת oEmbed של YouTube עם JSONP callback. YouTube היה מותר במדיניות הסקריפטים, ולכן ה-callback הריץ JavaScript של התוקף כ-chatgpt.com (HyperAI).
מה כדאי לבדוק באפליקציה שלי?
לוודא event.origin ו-event.source לפני כל הודעה שמשנה state, לא להכניס נתוני הודעה ל-innerHTML, לשמור iframes דינמיים עם srcdoc בתוך sandbox ולהתייחס ל-CSP כשכבת גיבוי (Ostorlab).
למה לבדוק גם את isTrusted?
קוד שרץ באותו origin יכול לשגר MessageEvent מזויף עם origin לבחירתו. עבור אירועים כאלה isTrusted הוא false, ולכן הבדיקה חוסמת אותם (TEKNKL).
סיכום
פרשת ChatGPT ו-MathLive היא דוגמה מובהקת לכך שפריצה לחשבונות ChatGPT, ולחשבונות בכל אפליקציית ווב, לא חייבת לעבור דרך מסך ההתחברות. היא נבנתה מארבע החלטות סבירות: Preview מבודד, גרף עם מקלדת מתמטית, iframe עם srcdoc ו-CSP שמתיר את YouTube. החוליה החלשה הייתה מאזין postMessage אחד, של ספרייה חיצונית, שקיבל הודעות מכל שולח והכניס HTML לדף.
המסקנות המעשיות פשוטות לניסוח, אבל דורשות עבודה שיטתית. כל מאזין message בדף, גם של ספרייה, חייב לבדוק origin, source ו-isTrusted. נתוני הודעה לא נכנסים ל-sinks של HTML. כל מסמך דינמי נשאר ב-sandbox, ו-CSP הוא רשת ביטחון ולא קו ההגנה הראשון. אבטחת postMessage היא לא סעיף שמסמנים פעם אחת, אלא בדיקה שצריך לחזור עליה בכל פעם שנוספת לאפליקציה תלות שמתקשרת עם חלונות אחרים.
כדאי להתחיל עוד השבוע: להריץ getEventListeners(window).message על הדפים המרכזיים באפליקציה, למפות מאיפה כל מאזין הגיע ולבדוק לאן זורמים הנתונים שלו. במקרה של ChatGPT, בדיקה כזאת הייתה מגלה את הבעיה לפני החוקרים.
מקורות
- Malicious Public ChatGPT Share Lets Attackers Hijack Accounts and Steal Data – HyperAI
- The ChatGPT account takeover came from a math keyboard, not the login flow – SamCodeMan
- ChatGPT Shared-Link Account Takeover via MathLive Sandbox Escape – Ostorlab
- You should probably be checking isTrusted in postMessage() listeners – TEKNKL
- Wildcard postMessage Origins – Orbis AppSec
- postMessage Security: Common Flaws and Mitigation Steps – SecureLayer7
- How a Single ChatGPT Link Could Hand Attackers Your Private Conversations – Aviatrix






