סריקה של 159,041 פרויקטים שנבנו ב-Lovable מצאה מידע רגיש שאפשר לקרוא בלי להתחבר בכלל: מספרי דרכון, פרטי תשלום ויותר מ-200 אלף הודעות צ'אט (Cybernews). מבחינת כל מי שמשיק מוצר שנבנה בפרומפטים, אבטחת אפליקציות Lovable הפסיקה להיות דיון תיאורטי בפורומים של מפתחים והפכה לשאלה של חשיפה משפטית, אמון לקוחות ונזק תדמיתי.
הנקודה החשובה ביותר בסיפור הזה היא שהפלטפורמה עצמה לא נפרצה. לפי החוקרים, הבעיה נמצאת בכללי הגישה של מסדי הנתונים של האפליקציות, לא בפריצה ל-Lovable (Cybernews). כלומר, האחריות לתקלה, וגם היכולת לתקן אותה, נמצאות אצל מי שבנה את האפליקציה: היזם, הסטארטאפ או הסוכנות שמסרה את המוצר ללקוח.
המאמר מפרק את מה שידוע על המחקר, מסביר את שורש הבעיה הטכני (Row Level Security חסר או מוגדר בצורה רחבה מדי ב-Supabase), מראה למה דווקא אפליקציות שנבנו עם AI חוזרות על אותה טעות, ומציע צ'קליסט מעשי לבדיקת אבטחה לפני השקה, כולל קטעי SQL, בדיקת שני חשבונות והשוואה בין כלי סריקה.
מה מצא המחקר על אפליקציות Lovable
חברת האבטחה הגרמנית Crissy Field סרקה 159,041 פרויקטים שנבנו ב-Lovable ומצאה מידע רגיש שניתן לקריאה ללא התחברות (Cybernews). הממצאים פורסמו לראשונה בעיתון הכלכלי הגרמני Handelsblatt (International Cyber Digest), ובתחילת נובמבר 2026 התפשטו לכלי תקשורת טכנולוגיים ברחבי העולם, בהם India Today ו-Cybernews.
הנתון המטריד ביותר נוגע לאפליקציות שמשתמשות ב-Supabase כ-backend. מתוך 34,545 פרויקטים כאלה, 24,664 שלחו רשומות ממסד הנתונים כבר בטעינת העמוד, בלי שום התחברות (daily.dev). מדובר בכ-71% מהפרויקטים מבוססי Supabase שנבדקו.
בנוסף, כתובות אימייל נמצאו ב-10,560 טבלאות ב-7,403 אתרים, כ-30% מהמדגם שנבדק לעומק (daily.dev).
מה בדיוק נחשף
לפי הסיכומים של המחקר, סוגי המידע שנחשפו כוללים (LinkedIn):
- יותר מ-1,000 רשומות דרכון, כולל לאום ותאריכי תפוגה.
- יותר מ-80,000 פרופילים של משתמשי פורומים, עם שמות ותאריכי לידה.
- יותר מ-200,000 הודעות צ'אט פרטיות (India Today).
- חוזים וחשבוניות.
- נתוני תשלום של אירועים ומסעדות.
זו לא רשימה של מטא-דאטה טכני. אלה בדיוק סוגי המידע שמשמשים לגניבת זהות, להונאות פישינג ממוקדות ולסחיטה, ובמקרה של דרכונים, מדובר במסמך שאי אפשר פשוט להחליף כמו סיסמה.
הסתייגויות לגבי הנתונים
כדי לקרוא את המספרים נכון, כדאי להכיר כמה מגבלות:
- הדוח המקורי של Crissy Field לא נבדק ישירות; הנתונים מגיעים מסיקור משני (Cybernews, daily.dev, פוסטים ב-LinkedIn וב-X) וייתכן שעברו סיכום או עיגול.
- הנתון על 7,403 אתרים ו-10,560 טבלאות מתייחס לתת-מדגם ולא לכלל האפליקציות, והמכנה מתואר בצורה שונה במקורות שונים.
- לפי daily.dev, בקהילה התנהל ויכוח סוער על המתודולוגיה של החוקרים, ובפרט על האתיות והחוקיות של שליפת הנתונים (daily.dev).
- המנגנון המדויק בכל אפליקציה לא פורט; ההסבר של RLS חסר או מתירני מדי הוא מסקנה שעולה מהמקורות, לא ניתוח אפליקציה-אחר-אפליקציה.
גם עם ההסתייגויות האלה, התמונה הכללית ברורה: מספר גדול מאוד של אפליקציות פרודקשן חושף מידע אישי לכל מי שיודע איפה לחפש.
לא פריצה ל-Lovable: Supabase RLS כשורש הבעיה
החוקרים מדגישים ש-Lovable עצמה לא נפרצה, ומייחסים את החשיפה לכללי גישה חסרים במסדי הנתונים של האפליקציות (Cybernews). כדי להבין למה זה קורה בהיקף כזה, צריך להבין איך הארכיטקטורה בנויה.
איך הדפדפן מדבר עם מסד הנתונים
Lovable הופכת תיאור בשפה טבעית לאפליקציית ווב עובדת, ומשתמשת ב-Supabase (Postgres עם שכבת אימות) כ-backend ברירת מחדל. בארכיטקטורה הזו אין בדרך כלל שרת API ביניים שבודק הרשאות: קוד ה-frontend בדפדפן פונה ישירות למסד הנתונים באמצעות מפתח ציבורי שנקרא anon key.
המשמעות היא שמדיניות Row Level Security היא שכבת ההרשאות היחידה שעומדת בין האינטרנט לבין הטבלאות. אם RLS כבוי, או שהמדיניות רחבה מדי, כל מי שמחזיק במפתח יכול לקרוא את הטבלאות (Vibe App Scanner).
למה מפתח ה-anon ציבורי, ולמה זה משנה
טעות נפוצה היא לחשוב שהבעיה היא שהמפתח "דלף". בפועל, מפתח ה-anon של Supabase תוכנן מלכתחילה להיות ציבורי. האבטחה נשענת על מדיניות RLS; בלי RLS, המפתח הזה מעניק גישת קריאה מלאה (Vibe App Scanner).
ב-Lovable, כל משתנה שמתחיל בקידומת VITE_ נחשף לדפדפן. כתובת ה-URL של Supabase ומפתח ה-anon שייכים לשם; מפתח ה-service_role לעולם לא (vibe-eval). זה ההבדל הקריטי:
מפתח | מיועד ל | עוקף RLS? | מותר ב-frontend? |
|---|---|---|---|
anon key | קוד צד לקוח | לא | כן, בתנאי ש-RLS מוגדר נכון |
service_role key | קוד צד שרת בלבד | כן | לעולם לא |
מכאן נובע שאין טעם לנסות "להסתיר" את מפתח ה-anon. מה שצריך לעשות הוא לוודא שגם מי שמחזיק בו לא יכול לקרוא שום דבר שלא שייך לו.
זה לא חדש: CVE-2025-48757
הבעיה תועדה כבר ב-2025. החולשה CVE-2025-48757 עסקה ב-RLS חסר או לא מספק בפרויקטים שנוצרו ב-Lovable, וסריקה של החוקר Matt Palmer מצאה 303 נקודות קצה ב-170 פרויקטים ללא RLS תקין (Superblocks). ראוי לציין שהמקור הזה הוא חברה מתחרה, ולכן פרטי ציר הזמן ותגובת Lovable עשויים להיות שנויים במחלוקת.
וגם לא רק Lovable
לפי דיווח של UpGuard מספטמבר 2026, מתוך כ-300,000 דומיינים שנבדקו נמצאו 16,326 מסדי נתונים של Supabase שניתן לקרוא רק באמצעות האישור הציבורי (Hard2bit). הממצא הזה מראה שהבעיה רחבה יותר מכלי אחד. הקשר הישיר בין הממצאים של UpGuard לאפליקציות Lovable דווקא אינו ברור מהמקור, אבל הדפוס זהה: מפתח ציבורי, RLS חסר, מידע חשוף.
Vibe coding אבטחה: למה אפליקציות AI חוזרות על אותה טעות
אם הבעיה ידועה לפחות מ-2025, למה היא ממשיכה לחזור באלפי אפליקציות? המקורות ממסגרים את שורש הבעיה כשאלה של תצורה וממשל: אף אחד לא מחליט מי רשאי לראות איזה מידע, וכלי AI בונים את מה שמבקשים מהם ולעיתים רחוקות מוסיפים בדיקות בעלות (Hard2bit).
ה-AI בונה את מה שביקשו, לא את מה שצריך
פרומפט טיפוסי נשמע כמו "תבנה לי מערכת הזמנות עם צ'אט בין לקוח לספק". הוא מתאר פונקציונליות, לא מודל הרשאות. המודל יבנה טבלת הודעות, ממשק צ'אט וזרימת הרשמה, והאפליקציה תעבוד מצוין בדמו. מה שלא יופיע מעצמו הוא ההחלטה שלקוח א' לא יכול לקרוא את ההודעות של לקוח ב'.
בדמו, עם משתמש אחד, אין שום סימן לבעיה. היא מתגלה רק כשמישהו מנסה במכוון לגשת למידע שאינו שלו, וזה בדיוק מה שסורקים אוטומטיים עושים בהיקפים של מאות אלפי אתרים. תופעה דומה של סוכני קוד ששחזרים דפוסים מוכרים בלי להבין הקשר מתוארת גם במאמר על סוכני קוד AI וקוד JavaScript מיושן.
דפוסים חוזרים מאפשרים התקפה בקנה מידה
לפי החוקרים, דפוסי האינטגרציה החוזרים של Lovable מול מסד הנתונים מאפשרים לקחת פגם בבקרת גישה שנמצא באפליקציה אחת ולהשתמש בו נגד אפליקציות רבות אחרות (daily.dev). מבחינת תוקף, זה אומר שאין צורך לחקור כל אפליקציה בנפרד: מספיק להבין את התבנית פעם אחת ולהריץ סריקה.
זה גם ההסבר לכך שהחוקרים ממליצים על סקירת אבטחה של מומחה לפני שאפליקציה כזו מטפלת במידע אמיתי של לקוחות (daily.dev).
סריקת האבטחה המובנית לא מספיקה
ב-Lovable 2.0, שהושקה ב-24 באפריל 2025, נוספה "סריקת אבטחה". לפי Superblocks, הסריקה בדקה רק אם RLS קיים, ולא אם המדיניות באמת חוסמת גישה לא מורשית (Superblocks). ייתכן שהכלי השתנה מאז, אבל העיקרון נשאר: טבלה עם RLS פעיל ומדיניות using (true) תעבור בדיקת "האם RLS קיים" ועדיין תהיה פתוחה לכולם.
זו הסיבה המרכזית לכך שבדיקת אבטחה לפני השקה חייבת לכלול גם בדיקה של תוכן המדיניות וגם בדיקה התנהגותית, ולא רק סימון וי בדשבורד.
צ'קליסט אבטחת אפליקציות Lovable לפני השקה: RLS ומדיניות
הצ'קליסט הבא מבוסס על ההמלצות שמופיעות במקורות ומתאים לכל אפליקציה שנבנתה ב-vibe coding על Supabase, לא רק ב-Lovable. מומלץ להריץ אותו לפני כל השקה ולפני כל מסירה ללקוח.
שלב 1: מיפוי הטבלאות ובדיקת מצב RLS
אפשר לבדוק את מצב RLS בדשבורד של Supabase תחת Database > Tables, או להריץ שאילתה ישירה (Vibe App Scanner):
SELECT tablename, rowsecurity
FROM pg_tables
WHERE schemaname = 'public';כל שורה שבה rowsecurity הוא false היא טבלה שפתוחה לכל מי שמחזיק במפתח ה-anon. הכלל הוא RLS פעיל על כל טבלה בסכמה חשופה (ScanMySaaS), ולא רק על הטבלאות ש"נראות רגישות".
שלב 2: הפעלת RLS יחד עם מדיניות, באותו סשן
הפעלת RLS בלי מדיניות חוסמת את כל הגישה, ולכן יש להוסיף את המדיניות באותו סשן, אחרת האפליקציה תישבר (vibe-eval). דוגמה למדיניות בעלות בסיסית לטבלת הודעות:
ALTER TABLE public.messages ENABLE ROW LEVEL SECURITY;
CREATE POLICY "owner_select" ON public.messages
FOR SELECT USING (auth.uid() = user_id);
CREATE POLICY "owner_insert" ON public.messages
FOR INSERT WITH CHECK (auth.uid() = user_id);
CREATE POLICY "owner_update" ON public.messages
FOR UPDATE USING (auth.uid() = user_id)
WITH CHECK (auth.uid() = user_id);
CREATE POLICY "owner_delete" ON public.messages
FOR DELETE USING (auth.uid() = user_id);באפליקציית צ'אט בין שני צדדים, המדיניות תצטרך לבדוק שהמשתמש הוא השולח או הנמען, או חבר בשיחה. העיקרון זהה: ההרשאה נגזרת מ-auth.uid(), כלומר מהמשתמש המחובר בפועל, ולא מערך שהלקוח שולח.
שלב 3: ציד מדיניות מתירנית מדי
מדיניות using (true) על טבלה עם מידע של משתמשים היא שקולה, בפועל, ל-RLS כבוי (ScanMySaaS). כך מוצאים אותה:
SELECT tablename, policyname, cmd, roles, qual, with_check
FROM pg_policies
WHERE schemaname = 'public'
ORDER BY tablename;יש לעבור על כל שורה ולחפש:
qualאוwith_checkשערכםtrue.- מדיניות שמוגדרת ל-role
anonעל טבלה שאמורה להיות פרטית. - מדיניות SELECT שאין לה תנאי בעלות או שיוך לארגון.
- טבלאות עם מדיניות ל-SELECT בלבד, בלי התייחסות ל-INSERT, UPDATE ו-DELETE.
שלב 4: פונקציות SECURITY DEFINER
פונקציות שמוגדרות כ-SECURITY DEFINER רצות עם ההרשאות של מי שיצר אותן, ולכן עוקפות בפועל את ה-RLS של המשתמש הקורא. כל פונקציה כזו חייבת לבדוק auth.uid() בעצמה (ScanMySaaS). פונקציות RPC שנוצרו על ידי AI כדי "לפתור" שגיאת הרשאה הן חשודות מיידיות.
שלב 5: בדיקה מבחוץ עם מפתח ה-anon
אחרי התיקון, כדאי לבדוק כמו שתוקף היה בודק: לפנות ל-REST API של Supabase עם מפתח ה-anon בלבד, בלי טוקן של משתמש מחובר.
curl "https://<project-ref>.supabase.co/rest/v1/messages?select=*" \
-H "apikey: <ANON_KEY>" \
-H "Authorization: Bearer <ANON_KEY>"התוצאה הצפויה בטבלה פרטית היא מערך ריק. כל שורה שחוזרת היא מידע שנגיש לכל העולם. את הבדיקה הזו יש להריץ על כל טבלה ברשימה משלב 1.
צ'קליסט מפתחות, אימות, אחסון ובדיקת BOLA
RLS הוא הלב, אבל אפליקציה שנבנתה ב-vibe coding יכולה לדלוף גם דרך מפתחות, קבצים ולוגיקת הרשאות. החלק הזה של בדיקת האבטחה לפני השקה משלים את התמונה.
מפתחות ומשתני סביבה
מפתח ה-service_role עוקף RLS ולעולם אסור שיופיע בקוד ה-frontend. אם הוא נמצא שם, יש לבצע לו רוטציה ב-Supabase (Settings > API) לפני שמסירים אותו מהקוד (vibe-eval). הסדר חשוב: מחיקה מהקוד בלבד לא מבטלת את המפתח, שכבר קיים בהיסטוריית ה-Git, בבאנדלים שנפרסו ובמטמונים.
בדיקה מהירה של הבאנדל אחרי build:
npm run build
grep -rn "service_role" dist/
grep -rn "VITE_" .env* יש לוודא שרק כתובת ה-Supabase ומפתח ה-anon מופיעים במשתנים עם קידומת VITE_. כל סוד אחר (מפתחות תשלום, מפתחות API של צד שלישי, service_role) שייך לצד שרת, למשל ל-Edge Function. תהליך רוטציה מסודר מתואר בהרחבה במאמר על דליפת משתני סביבה ב-Trigger.dev ורוטציית סודות, ותרחיש שבו כלי AI עצמו חושף סודות מתואר במאמר על דליפת סודות ב-Claude Code.
אחסון קבצים
סריקות דרכון, חוזים וחשבוניות נשמרים לרוב ב-Storage ולא בטבלאות. ההמלצה היא buckets פרטיים עם מדיניות בעלים (ScanMySaaS). דפוס נפוץ הוא לשמור כל קובץ תחת תיקייה בשם מזהה המשתמש ולאכוף זאת במדיניות:
CREATE POLICY "owner_read_files" ON storage.objects
FOR SELECT USING (
bucket_id = 'documents'
AND (storage.foldername(name))[1] = auth.uid()::text
);בנוסף, כדאי לבדוק שאין bucket שהוגדר כ-public רק כדי שתמונה תיטען בדמו, ושקישורים לקבצים רגישים הם signed URLs עם תוקף קצר.
אימות וזהות המשתמש
מזהי משתמש וארגון (user ID ו-tenant ID) צריכים להיגזר מהסשן, לא מגוף הבקשה (ScanMySaaS). קוד שנוצר ב-AI נוטה לשלוח user_id מהלקוח כפרמטר, ומשם הדרך לשינוי הערך ידנית בכלי המפתחים של הדפדפן קצרה מאוד.
נקודות נוספות לבדיקה:
- האם הרשמה פתוחה לכל אחד, ואם כן, האם זה מכוון.
- האם אימות אימייל נדרש לפני גישה למידע.
- האם תפקידים (admin, editor) נשמרים בטבלה שהמשתמש יכול לעדכן בעצמו.
- האם ממשקי ניהול מוגנים רק בהסתרת כפתור ב-UI, או גם ברמת מסד הנתונים.
בדיקת שני חשבונות (BOLA)
הבדיקה הפשוטה והאפקטיבית ביותר היא בדיקת שני חשבונות, שתופסת Broken Object Level Authorization: משתמש ב' פותח מזהה משאב של משתמש א', והגישה אמורה להידחות (ScanMySaaS). שלבי הבדיקה:
- יוצרים שני חשבונות נפרדים, בשני דפדפנים או בחלון גלישה פרטית.
- בחשבון א' יוצרים נתונים: הודעה, הזמנה, מסמך, פרופיל.
- רושמים את מזהי המשאבים מכתובת ה-URL או מלשונית Network.
- בחשבון ב' מנסים לגשת לאותם מזהים, דרך ה-UI וגם ישירות דרך ה-API.
- מנסים גם לעדכן ולמחוק, לא רק לקרוא.
- מתעדים כל הצלחה כחולשה שיש לתקן לפני השקה.
כלים: השוואת גישות
גישה | יתרונות | חסרונות |
|---|---|---|
RLS עם מדיניות בעלים ( | הופך את מפתח ה-anon לבטוח לשימוש; מדיניות בסיס פשוטה; ניתן לאימות ב-SQL ובבדיקת שני חשבונות | הפעלה בלי מדיניות שוברת את האפליקציה; מדיניות עלולה להיות רחבה מדי; דורש בדיקה ידנית (vibe-eval) |
סריקת האבטחה המובנית של Lovable | מהירה ואוטומטית; מסמנת טבלאות בלי RLS | לפי הדיווחים בודקת שקיים RLS, לא שהמדיניות עובדת; עלולה ליצור תחושת ביטחון כוזבת (Superblocks) |
סורקי צד שלישי ובדיקה ידנית | שאילתות לטבלאות עם מפתח ה-anon וסריקת באנדלים לאיתור service_role; בדיקת פונקציות RPC והגדרות אימות; בדיקת שני חשבונות תופסת BOLA | הכלים נמכרים על ידי המקורות עצמם ולכן הטענות אינטרסנטיות; לא כל בדיקה ניתנת לאוטומציה (Vibe App Scanner) |
המסקנה המעשית: סורק אוטומטי הוא נקודת פתיחה טובה, אבל הוא לא מחליף קריאה של מדיניות ה-RLS ובדיקת שני חשבונות ידנית.
מי אחראי: התנאים של Lovable וההשלכות לסוכנויות ומייסדים בישראל
בתגובה ל-Handelsblatt, Lovable מסרה שהבעיה היא בעיה של כל התעשייה, והתנאים שלה מטילים על הלקוחות את האחריות לאפליקציות ולנתונים שלהם (International Cyber Digest). במילים אחרות, מבחינה חוזית, מי שלחץ על Publish הוא מי שאחראי למה שנחשף.
זה לא אומר שהפלטפורמות פטורות מביקורת. ברירות מחדל, אזהרות וכלי סריקה משפיעים מאוד על התוצאה, והוויכוח על תגובת Lovable ל-CVE-2025-48757 מראה שהשאלה הזו רחוקה מלהיות סגורה. אבל מבחינה מעשית, מי שבונה אפליקציה לא יכול להניח שמישהו אחר דאג לאבטחה.
הזווית הישראלית
המקורות שעליהם מבוסס המאמר אינם עוסקים בישראל, ולכן החלק הזה הוא ניתוח ולא דיווח. סטארטאפים וסוכנויות בישראל משתמשים ב-Lovable, ב-Supabase ובכלים דומים כדי לבנות MVP במהירות, לעיתים קרובות עבור לקוחות שמחזיקים מידע אישי: מספרי תעודת זהות, צילומי דרכון לשירותי תיירות ונסיעות, פרטי תשלום והודעות בין לקוחות לנותני שירות.
אפליקציות בעברית שומרות לרוב שמות, מספרי ת״ז וטלפונים בטבלאות מותאמות שנוצרו במיוחד עבור הלקוח, ואלה בדיוק הטבלאות שזקוקות ל-RLS. ממשק RTL מלוטש לא אומר דבר על מצב ההרשאות מאחוריו.
במישור המשפטי, חוק הגנת הפרטיות ותקנות אבטחת המידע בישראל עשויים לחול על אפליקציות כאלה, ו-GDPR עשוי לחול כשיש משתמשים מהאיחוד האירופי. ההיקף המדויק של החובות תלוי בסוג המידע, בכמות ובאופי הפעילות, ולכן יש לבדוק את הנושא מול ייעוץ משפטי ולא להסתמך על הנחות.
מה לכלול במסירה ללקוח
סוכנות שמוסרת אפליקציה שנבנתה ב-vibe coding יכולה לצמצם סיכון משמעותי באמצעות תיעוד מסודר של בדיקת האבטחה כחלק מהמסירה:
- רשימת כל הטבלאות בסכמה החשופה, עם מצב RLS ונוסח המדיניות.
- תוצאות בדיקת ה-curl עם מפתח ה-anon לכל טבלה.
- תוצאות בדיקת שני חשבונות, כולל קריאה, עדכון ומחיקה.
- אישור שאין service_role או סודות אחרים בבאנדל, ותיעוד רוטציה אם נדרשה.
- רשימת buckets ומדיניות האחסון שלהם.
- רשימת פונקציות SECURITY DEFINER ובדיקת
auth.uid()בכל אחת. - הגדרה ברורה של מי אחראי לאבטחה אחרי המסירה, ומה קורה כשהלקוח ממשיך לשנות את האפליקציה בפרומפטים.
הסעיף האחרון חשוב במיוחד: כל פרומפט חדש יכול ליצור טבלה חדשה בלי RLS. לכן הבדיקה צריכה להיות חלק מתהליך קבוע ולא אירוע חד-פעמי, בדומה לגישה שמתוארת בצ'קליסט אבטחת שרשרת אספקה לצוותים קטנים.
שאלות נפוצות
האם Lovable נפרצה?
לא. לפי החוקרים, Lovable עצמה לא נפרצה; למסדי הנתונים של האפליקציות חסרו כללי גישה מתאימים (Cybernews). החשיפה נובעת מתצורה של כל אפליקציה, לא מפריצה לתשתית המשותפת.
האם מפתח ה-anon של Supabase בקוד ה-frontend הוא חולשה?
לא. המפתח תוכנן להיות ציבורי. הסיכון נוצר כש-RLS כבוי או כשהמדיניות מתירנית מדי (Vibe App Scanner). המפתח שאסור שיופיע בדפדפן הוא service_role.
איך בודקים אם RLS מופעל?
בדשבורד של Supabase תחת Database > Tables, או בהרצת השאילתה SELECT tablename, rowsecurity FROM pg_tables WHERE schemaname = 'public' (Vibe App Scanner). חשוב לזכור ש-RLS פעיל אינו מספיק; צריך לבדוק גם את תוכן המדיניות ב-pg_policies.
מה עושים אם מפתח service_role מופיע בבאנדל?
קודם מבצעים רוטציה למפתח ב-Supabase (Settings > API), ורק אחר כך מסירים אותו מהקוד ומעבירים את השימוש בו לצד השרת (vibe-eval). מחיקה מהקוד בלי רוטציה משאירה את המפתח הישן תקף.
מי אחראי לאבטחה של אפליקציה שנבנתה ב-Lovable?
לפי התנאים של Lovable, הלקוחות אחראים לאפליקציות ולנתונים שלהם, ו-Lovable מסרה ל-Handelsblatt שמדובר בבעיה של כל התעשייה (International Cyber Digest). בפרויקט שנבנה עבור לקוח, כדאי להגדיר בחוזה במפורש מי אחראי לאבטחה לאורך זמן.
איך בודקים Broken Object Level Authorization?
יוצרים נתונים כמשתמש א', ואז מבקשים את אותו מזהה משאב כמשתמש ב'. הבקשה של ב' צריכה להידחות, ובדיקות הבעלות צריכות לרוץ בצד השרת או במסד הנתונים (ScanMySaaS).
סיכום
המחקר של Crissy Field לא חשף חולשה חדשה ומתוחכמת. הוא חשף את ההיקף של בעיה ידועה: אפליקציות שבהן הדפדפן מדבר ישירות עם מסד הנתונים, מפתח ציבורי שתוכנן להיות ציבורי, ושכבת הרשאות אחת, Row Level Security, שחסרה או מוגדרת בצורה רחבה מדי. כש-24,664 מתוך 34,545 אפליקציות מבוססות Supabase שנבדקו שלחו רשומות בלי התחברות, קשה לראות בזה מקרה נקודתי.
הלקח המרכזי לגבי אבטחת אפליקציות Lovable, ולגבי vibe coding בכלל, הוא שמהירות הבנייה לא כוללת החלטות הרשאה. ה-AI בונה את מה שמבקשים ממנו, והשאלה מי רשאי לראות מה נשארת אצל מי שבונה. סריקה אוטומטית שבודקת רק אם RLS קיים לא מספיקה; צריך לקרוא את המדיניות, לבדוק עם מפתח ה-anon מבחוץ ולהריץ בדיקת שני חשבונות.
עבור מייסדים וסוכנויות בישראל שמחזיקים מידע אישי של לקוחות, הצ'קליסט שבמאמר הוא מינימום לפני השקה ולפני מסירה: RLS על כל טבלה, אפס מדיניות using (true) על מידע משתמשים, אפס service_role בדפדפן, buckets פרטיים, מזהים מהסשן ולא מהבקשה, ותיעוד של כל אלה. אפליקציה שעוברת את הבדיקות האלה עדיין לא בהכרח מאובטחת לחלוטין, אבל היא כבר לא חלק מהסטטיסטיקה של המחקר הבא.
מקורות
- Cybernews: Apps built on Lovable AI expose passport details and 200,000 chat messages
- daily.dev: סיכום מחקר Crissy Field
- India Today: Lovable apps expose personal details
- International Cyber Digest ב-X
- Superblocks: Lovable Vulnerability Explained (CVE-2025-48757)
- vibe-eval: How to Secure a Lovable App
- ScanMySaaS: Vibe coding security checklist
- Vibe App Scanner: Lovable + Supabase Security
- Hard2bit: 16,326 Supabase databases anyone could read
- Krisann McDonnell ב-LinkedIn






