אבטחה ברמת טיפוסים (Type Level Security): עתיד יצירת קוד AI מאובטח?
אמ;לק
מאמר זה בוחן את הפוטנציאל של 'אבטחה ברמת טיפוסים' (Type Level Security) למניעת פגיעויות בקוד שנוצר על ידי AI. באמצעות הגדרה קפדנית של טיפוסים, ניתן להפוך שגיאות נפוצות לשגיאות קומפילציה, ובכך להפחית סיכונים באופן יזום. גישה זו מציעה דרך לייצר קוד "מאובטח-לפי-תכנון" ולבנות חומת מגן מפני כשלים של מודלי AI.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: Type Level Security: The future of secure AI code generation?

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
הקדמה
כאשר קוד נכתב (ונוצר) מהר יותר מאי פעם, יש תופעת הלוואי המצערת שגם פרצות אבטחה מגיעות מהר יותר מאי פעם. לבקש מ-LLM שלך לא לכלול פרצות אבטחה בקוד שלו לא תמיד עובד. מתברר שהאופן שבו תוכנה נבנית כיום, באופן ידני או בסיוע, אינו מספיק בכל הנוגע לכתיבת קוד מאובטח בצורה מהימנה, עקבית ומוכחת.
העלייה בפופולריות של Rust הראתה כי ניתן להסיר לחלוטין מחלקות פגיעות שלמות בצורה סבירה וארגונומית. Rust ביטלה למעשה את כל (או רוב) פגיעויות השחתת הזיכרון (memory corruption) בזמן ההידור. מדוע, אם כן, עלינו להגביל את עצמנו רק למחלקת פגיעויות זו?
בפוסט זה, אדון כיצד ניתן לכתוב קוד בצורה כזו שפגיעויות אבטחה ביישומי אינטרנט לא יהיו ניתנות לקומפילציה (או לבדיקת טיפוסים), וכיצד שימוש בספריות מאובטחות לפי תכנון (secure-by-design) או בעטיפות (wrappers) ספריות הממוקמות היטב יכול לעצור לחלוטין מחלקות שלמות של פגיעויות, בין אם נכתבו ידנית ובין אם על ידי LLM. אציג דפוסי קוד ב-Python וב-Rust שיכולים לשמש למיגור מחלקות פגיעויות.
למה סוגים
בשימוש נכון, מערכות טיפוסים (type systems) יכולות להיות כלים חזקים להפליא. הן מאפשרות לך לקודד את האינווריאנטים של המערכת, כלומר את כל הכללים, המאפיינים והיחסים של כל פיסת נתונים בתוכנית שלך. במקום להסתמך על הערות קוד או ביצוע בדיקות (assertions) בזמן ריצה (שעשויות להתגלות רק כשהלקוח הראשון שלך ינסה לעשות משהו חשוב), אתה יכול להבטיח שכל קריאה לפונקציית הוספה מעבירה אך ורק שני טיפוסי int, בכל מקרה ובכל בסיס הקוד.
באופן אנקדוטי, קוד שאני כותב עם טיפוסים קפדניים ביותר מכיל הרבה פחות באגים בזמן ריצה מאשר קוד שאני כותב בלעדיהם, מכיוון שאני נאלץ לחשוב לעומק על כל פרמטר, כל פיסת נתונים וכל קלט. כאשר הקוד מקודד כראוי, אני עושה הרבה פחות טעויות, והבאגים שנותרים הם לוגיים-עסקיים בלבד, ולא מסוג 'אופס, העברתי מחרוזת לפונקציית חיבור של מספר שלם'.
פרצות אבטחה רבות הן רק סוג ספציפי של באג, ואם הטענה שלי לעיל נכונה, הרי שבאגים רבים כאלה אמורים להיות ניתנים לפתרון באמצעות מערכת טיפוסים גמישה מספיק.
טיפוסים מהימנים
הפוסט הזה נוצר, בחלקו, בהשראת ה-Trusted Types web API. ממשק זה מפחית למעשה את רוב סוגי ה-DOM XSS על ידי הבטחה שכיורי הזרקה (sinks) יקבלו רק ערכים בטוחים ידועים, כגון אלו שעברו חיטוי (sanitization) על ידי מנקה XSS מתאים. ניתן להדק את השימוש בממשק זה עוד יותר באמצעות CSP, כך שידרוש שימוש ב-Trusted Types API ויזרוק שגיאת TypeError אם הממשק לא בשימוש.
מנגנון דומה נמצא בשימוש בליבת ה-Linux Kernel עם המאקרו __user, המבטיח שמצביעים (pointers) המגיעים ממרחב המשתמש יטופלו כראוי.
בסעיפים הבאים, נבחן את ההכללה של טכניקה זו וכיצד תוכל ליישם אותה על מחלקות פרצות אבטחה שרירותיות.
פותרים IDOR
Insecure Direct Object Reference (IDOR) היא פגיעות מסוכנת הנובעת מהיעדר בדיקות אימות (authentication) ו/או הרשאות (authorization) בעת ביצוע פעולות API. הדוגמה הקלאסית לכך היא נקודת קצה של API המקבלת פרמטר של ID משתמש ומחזירה את נתוניו, אך כאשר משנים את ערך ה-ID, המערכת מחזירה נתונים של משתמש אחר ללא בדיקות הרשאות מתאימות.
סטטיסטית, סביר להניח שאתה, הקורא, משתמש ב-Python, לכן נחקור תחילה פגיעות זו ונראה כיצד לפתור אותה ב-Python באמצעות רמזים לטיפוסים (type hints) בלבד.
ב-Python
1 import sqlite3 2 3 from fastapi import FastAPI, Depends 4 5 app = FastAPI() 6 7 DATABASE = "app.db" 8 9 def get_db(): 10 conn = sqlite3.connect(DATABASE) 11 conn.row_factory = sqlite3.Row 12 try: 13 yield conn 14 finally: 15 conn.close() 16 17 @app.get("/balance/{user_id}") 18 def get_balance(user_id: int, db: sqlite3.Connection = Depends(get_db)): 19 cursor = db.execute(f"SELECT balance FROM accounts WHERE user_id = {user_id}") 20 row = cursor.fetchone() 21 return {"uid": user_id, "balance": row["balance"]}
זוהי קריאת API סטנדרטית למראה: אתה מעביר ID משתמש כ-integer, שואל את מסד הנתונים ומחזיר את התוצאה. אבל אופס! שכחנו להוסיף בדיקות אימות או הרשאות; כל משתמש יכול לבקש את היתרה של כל משתמש אחר (בהנחה שיש לו את ה-ID), וזהו IDOR קלאסי. אנחנו מקבלים את דוח הפגיעות, משלמים לחוקר את הפרס (bounty) ומעדכנים את הפונקציה כך:
1 @app.get("/balance/{user_id}") 2 def get_balance(user_id: int, db: sqlite3.Connection = Depends(get_db)): 3 if not (check_authentication() and check_authorization()): return 403 4 ...
מושלם, נתוני המשתמש בטוחים. אבל זו טעות קלה להחריד לעשות. שכחת בדיקת אישור אחת בנקודת קצה אחת API עלולה להוביל להשפעות משמעותיות. כעת, הבה נסתכל על אותה נקודת קצה, אך באמצעות מערכת הסוג כדי לוודא שפגיעות זו לא תחזור על עצמה:
1 import sqlite3 2 3 from fastapi import FastAPI, Depends 4 from typing import Never, NewType, Final 5 from collections.abc import Generator 6 from contextlib import contextmanager 7 8 app = FastAPI() 9 10 DATABASE = "app.db" 11 12 def get_db(): 13 ... 14 15 UserID = NewType("UserID", int) 16 17 class AuthenticationProvider: 18 def do_authn(self) -> "AuthenticationGuard": 19 # do something to check the auth 20 return AuthenticationGuard(guard=AuthenticationGuard._INSTANTIATION_TOKEN) # pyright: ignore[reportPrivateUsage, reportArgumentType] 21 22 class AuthenticationGuard: 23 _INSTANTIATION_TOKEN: Final = object() 24 25 def __init__(self, *, guard: Never): 26 # could also do some runtime checks to ensure caller 27 assert guard is self._INSTANTIATION_TOKEN 28 29 class UncheckedUserID: 30 __value: UserID 31 32 def __init__(self, user_id: UserID): 33 self.__value = user_id 34 35 @contextmanager 36 def ensure_authn(self, guard: AuthenticationGuard) -> Generator[UserID, None, None]: 37 assert guard 38 yield self.__value 39 40 41 @app.get("/balance/{user_id}") 42 def get_balance(unauth_user_id: UncheckedUserID = Depends(UncheckedUserID), db: sqlite3.Connection = Depends(get_db)): 43 authguard = AuthenticationProvider().do_authn() 44 with unauth_user_id.ensure_authn(authguard) as user_id: 45 cursor = db.execute(f"SELECT balance FROM accounts WHERE user_id = {user_id}") 46 row = cursor.fetchone() 47 return {"uid": user_id, "balance": row["balance"]}
יש כאן מעט יותר קוד, אך בראייה רחבה, הוא בכל מקרה היה נבלע בתוך קוד האימות וההרשאה שלך.
השינוי העיקרי בקוד החדש הוא שלעולם איננו מעבירים טיפוסים בסיסיים (כמו ה-user ID כ-int בדוגמאות הקודמות). נתוני הקלט מופשטים לתוך מחלקה אטומה, וניתן לגשת אליהם רק על ידי הוכחה שביצעת את שלבי האימות וההרשאה. על ידי הבטחה שהמחלקה UncheckedUserID שלך לא יכולה לעשות דבר מועיל (כמו שימוש בביטוי SQL), בודק הטיפוסים שלך ידווח על שגיאה אם תשכח לבצע את בדיקת האימות כדי לחלץ את ערך ה-user_id 'האמיתי'.
פייתון, בהיותו דינמי כל כך, מאפשר טכנית לעקוף את הבדיקה ולגשת לערך הפנימי מבלי לספק AuthenticationGuard חוקי, אך יש לקוות שזה ייתפס בסקירת ה-PR כקוד לא רצוי. שפות אחרות, כמו Rust, יכולות לספק ערבויות חזקות הרבה יותר, כך שאפילו עם קוד 'מכוער', לא ניתן לגשת ישירות לערך הפנימי של מחלקת ה-wrapper. ברור שהקוד עדיין רץ, כך שאפשר לנקוט באמצעים קיצוניים כמו השלכת זיכרון (memory dump), אך אם אתה רק רוצה לוודא שהאימות שלך עקבי, למה שתעשה זאת בכלל?
ב-Rust
מפרטי נראות (visibility specifiers) ב-Rust מספקים שליטה חזקה על הקוד שיכול לגשת לערך ה-user_id העטוף, מה שהופך זאת לדרך אמינה עוד יותר להבטיח בדיקות אימות והרשאות. בדוגמה שלמטה, אנו משתמשים ב-Axum עם extractor כדי להבטיח שערך הקלט עבר דה-סריאליזציה נכונה למחלקת העטיפה הבטוחה שלנו.
1 use axum::{response::IntoResponse, routing::get, Json, Router}; 2 3 mod unchecked_input { 4 use axum::extract::{FromRequestParts, Path}; 5 #[derive(serde::Deserialize, serde::Serialize, Debug)] 6 pub struct UserID(u32); 7 8 #[derive(FromRequestParts)] 9 pub struct UncheckedUserID { 10 #[from_request(via(Path))] 11 value: UserID, 12 } 13 14 impl UncheckedUserID { 15 pub const fn ensure_authn(self, _: super::authentication::AuthenticationGuard) -> UserID { 16 self.value 17 } 18 } 19 } 20 21 mod authentication { 22 use std::marker::PhantomData; 23 24 pub struct AuthenticationGuard { 25 _internal: PhantomData<()>, 26 } 27 28 pub struct AuthenticationProvider {} 29 impl AuthenticationProvider { 30 pub const fn do_auth() -> Option<AuthenticationGuard> { 31 // do something to check the auth 32 Some(AuthenticationGuard { 33 _internal: PhantomData, 34 }) 35 } 36 } 37 } 38 39 async fn get_balance(user_id: unchecked_input::UncheckedUserID) -> impl IntoResponse { 40 match authentication::AuthenticationProvider::do_auth() { 41 Some(guard) => { 42 let user_id = user_id.ensure_authn(guard); 43 // go and do some SQL 44 Json(serde_json::json!({"uid": user_id, "balance": 0.0})) 45 } 46 None => Json(serde_json::json!({"error": "auth failure"})), 47 } 48 } 49 50 #[tokio::main] 51 async fn main() { 52 let app = Router::new().route("/balance/{user_id}", get(get_balance)); 53 54 let listener = tokio::net::TcpListener::bind("127.0.0.1:8000") 55 .await 56 .unwrap(); 57 axum::serve(listener, app).await.unwrap(); 58 }
פּרַקטִיוּת
ברור ששיטה זו לצמצום פרצות אבטחה דורשת מחויבות משמעותית, במיוחד בפרויקט תוכנה מבוסס. תשתית קידוד תהיה הכרחית כדי להבטיח שדפוסים אלו מיושמים בעקביות. שתי הדרכים העיקריות להשיג זאת הן ספריות עטיפה (wrapper libraries) או כללי linter מותאמים אישית.
קחו לדוגמה את המקרה של Python. כארגון, תוכל לדרוש את ספריית MyOrgFastAPI, מעטפת קלת משקל מעל FastAPI, ולוודא שכל נקודות הקצה של ה-API משתמשות בטיפוסים מותאמים אישית המיישמים את דרישות האבטחה הללו. אין לאפשר לאף נקודת קצה לקבל ארגומנט str; זה חייב להיות מסוג כלשהו של UncheckedString.
לחלופין, אם אינך רוצה לתחזק ספריית עטיפה מותאמת אישית, ניתן ליישם כללים אלו ברמת ה-linter. למרות שזה לא מספק משוב למפתח בשלב מוקדם כזה, זה עדיין יכול לספק את אותה רשת ביטחון על ידי איסור על שימוש בטיפוסים בסיסיים.
בכל דרך שתבחר ליישם זאת, זה יבטיח שכל מקרה מטופל כראוי. זה מרחיב באופן טבעי את דפוס הקוד להגנה מפני כל מיני פגיעויות:
• יש לחטא (sanitize) UncheckedString כראוי כדי לקבל מחרוזת גולמית להחזרה למשתמש, מה שמפחית את הסיכון ל-XSS.
• לא ניתן לשרשר UncheckedString לתוך שאילתת SQL, מה שמפחית את פגיעויות ה-SQL הקלאסיות.
• לא ניתן לשרשר UncheckedString לתוך מחרוזת פקודה, מה שמפחית פגיעויות של הזרקת פקודות (command injection).
דפוסים כאלה יחולו במידה שווה גם על מפתחים אנושיים וגם על סוכני AI. לבקש מסוכן AI להבטיח אימות בכל מקום אולי לא יהיה מהימן ב-100%, אך אכיפת אימות בשלב ההידור או ה-linting יכולה להיות חזקה ביותר.
מַסְקָנָה
הטמעת אבטחה כזו ברמת הטיפוסים יכולה להיות כלי חזק להפליא עבור מפתחים אנושיים וסוכני AI באותה מידה. למרות שעשויה להיות תקורה ראשונית מסוימת, במיוחד בפרויקטי תוכנה קיימים, היתרונות יכולים להיות משמעותיים, שכן ניתן למחוק מחלקות שלמות של פגיעויות.
האופן שבו אתה מטפל בנתונים שלך יכול להיות מאוד ספציפי לפרויקט, אבל חשיבה על זה מוקדם יכולה לתת דיבידנדים עבור קוד מאובטח.
משבר האבטחה של AI בסביבת ה-Python שלך
כאשר מהירות הפיתוח מרקיעה שחקים, האם אתה באמת יודע למה סביבת ה-AI שלך יכולה לגשת?
קרא עוד
PHP2Shell לא יהיה האחרון. הנה איפה הבא בתור יופיע.