צפו בסרטון השיעור: אבטחת סוכני AI עם קבלות קריפטוגרפיות
(סרטון השיעור והתמונה הממוזערת יתווספו על ידי צוות תוכן מיקרוסופט לאחר המיזוג, בהתאם לדפוס של שיעור 14 / 15.)
שיעור זה יכסה:
עם סיום שיעור זה, תוכלו לדעת כיצד:
דמיינו שהפעלתם סוכן AI עבור Contoso Travel. הסוכן קורא בקשות לקוחות, קורא ל-API של טיסות לחיפוש אפשרויות ומזמין כיסאות בשם הלקוח. ברבעון האחרון, הסוכן עיבד 50,000 הזמנות.
היום מגיע בודק חשבונות. הוא שואל שאלה פשוטה: “הראה לי מה הסוכן שלך עשה.”
אתם מספקים את קבצי היומן שלכם. הבודק מסתכל עליהם ושואל את השאלה הקשה יותר: “איך אני יודע שיומנים אלו לא נערכו?”
זו בעיית עקבות הביקורת. רוב פריסות הסוכנים היום מסתמכות על:
אף אחד מהם אינו יכול לענות לשאלה של הבודק מבלי שהבודק יצטרך לסמוך על מישהו (עליכם, ספק הענן שלכם, ספק מסד הנתונים שלכם). לשימוש פנימי, אמון זה מקובל לרוב. בעומסים מפוקחים (פיננסים, בריאות, כל דבר לפי תקנות ה-EU AI Act), זה אינו מקובל.
קבלות קריפטוגרפיות מצמצמות את הבעיה על ידי יצירת הצהרה חתומה שניתנת לאימות באופן עצמאי. הבודק עדיין זקוק לסיבה מחוץ לערוץ לסמוך על מפתח החתימה ועל הרכיב שיצר את ההצהרה. מפתח מוטמע מוכיח עקביות פנימית, לא זהות המנפיק או מיקום האכיפה.
קבלה היא אובייקט JSON המתעד מה עשה הסוכן, וחתום בחתימה דיגיטלית.
flowchart LR
A[Agent invokes a tool] --> B[Build receipt payload]
B --> C[Canonicalize JSON RFC 8785]
C --> E[Ed25519 sign canonical bytes]
E --> F[Receipt with signature]
F --> G[Auditor verifies offline]
G --> H{Signature valid?}
H -- yes --> I[Signed statement is intact]
H -- no --> J[Receipt rejected]
קבלה מינימלית נראית כך:
{
"type": "agent.tool_call.v1",
"agent_id": "contoso-travel-bot",
"tool_name": "lookup_flights",
"tool_args_hash": "sha256:a3f9c1...",
"result_hash": "sha256:7b2e1d...",
"policy_id": "contoso-travel-policy-v3",
"timestamp": "2026-04-25T14:30:00Z",
"sequence": 47,
"previous_receipt_hash": "sha256:9d4e6a...",
"signature": {
"alg": "EdDSA",
"sig": "c5af83...",
"public_key": "8f3b2c..."
}
}
שלושה מאפיינים עושים את העבודה:
החתימה. הקבלה חתומה על-ידי שער הסוכן באמצעות מפתח פרטי Ed25519. כל מי שיש לו את המפתח הציבורי התואם יכול לאמת את החתימה בצורה לא מקוונת. צד המבוסס חייב לקבע את המפתח או לפתור אותו מרישום אמין מחוץ לקבלה. זיוף כל שדה חתום מבטל את החתימה.
קידוד קנוני. לפני החתימה, הקבלה מעובדת לפי תוכנית הקנוניזציה של JSON (JCS, RFC 8785). זה מבטיח ששתי יישומים המייצרים את אותו תוכן קבלה יפיקו פלט זהה בבית. ללא קנוניזציה, מאכילי JSON שונים היו מייצרים חתימות שונות על אותו תוכן.
שרשור חשיש. השדה previous_receipt_hash מקשר כל קבלה לזו שלפניה. הסרה או שינוי סדר של קבלה שוברים את הרצף המוצג. גילוי קיצור או עריכה מבוקרת על ידי החותם דורש גם נקודת ביקורת עם ראש שרשרת קבוע, עדות עצמאית, או התחייבות מאומתת באוכלוסייה סגורה.
יחד מאפיינים אלו מספקים שלוש הבטחות:
אין צורך בספרייה מיוחדת להפקת קבלה. הפרימיטיבים הקריפטוגרפיים זמינים באופן נרחב והלוגיקה היא כמה עשרות שורות קוד בפייתון.
התרגילים המעשי ב-code_samples/18-signed-receipts.ipynb מראים את התהליך המלא. ספריית המקור שבשליטת גרסה code_samples/18-signed-receipts.execution-receipt.json מתעדת את ה-hash המדויק של הפנקס, סביבת הפייתון, ספירת התאים והבדיקות מהריצה האחרונה הנקייה ללא שינוי הפלטים של השיעור. הגרסה המסכמת:
import json
import hashlib
import base64
from nacl import signing
from jcs import canonicalize # RFC 8785 canonical JSON
def b64url_nopad(data: bytes) -> str:
return base64.urlsafe_b64encode(data).decode("ascii").rstrip("=")
def sha256_canonical(obj) -> str:
"""SHA-256 of a Python object's JCS-canonical JSON form."""
return f"sha256:{hashlib.sha256(canonicalize(obj)).hexdigest()}"
# Generate or load a signing key (in production, store in a key vault)
signing_key = signing.SigningKey.generate()
verify_key = signing_key.verify_key
TRUSTED_PUBLIC_KEYS = {b64url_nopad(bytes(verify_key))} # pinned out of band by the verifier
# Build the receipt payload (no signature yet)
tool_args = {"origin": "SYD", "destination": "LAX"}
tool_result = [{"flight": "QF11", "price": 1850, "stops": 0}]
payload = {
"type": "agent.tool_call.v1",
"agent_id": "contoso-travel-bot",
"tool_name": "lookup_flights",
"tool_args_hash": sha256_canonical(tool_args),
"result_hash": sha256_canonical(tool_result),
"policy_id": "contoso-travel-policy-v3",
"timestamp": "2026-04-25T14:30:00Z",
"sequence": 0,
"previous_receipt_hash": None,
}
# Canonicalize and sign the JCS bytes directly. PureEdDSA hashes internally.
canonical_bytes = canonicalize(payload)
signature_bytes = signing_key.sign(canonical_bytes).signature
# Attach a structured signature object.
receipt = {
**payload,
"signature": {
"alg": "EdDSA",
"sig": b64url_nopad(signature_bytes),
"public_key": b64url_nopad(bytes(verify_key)),
},
}
זה כל צינור החתימה. התרגילים בפנקס עוברים כל שלב.
האימות הוא הפעולה ההפוכה:
import base64
import hashlib
from nacl import signing
from nacl.exceptions import CryptoError
from jcs import canonicalize
def b64url_decode(s: str) -> bytes:
# Strict: Python's decoder skips characters outside the alphabet and also
# accepts padding, the standard +/ alphabet and non-zero spare bits.
# Re-encoding and comparing accepts only the one unpadded base64url form.
padding = "=" * ((4 - len(s) % 4) % 4)
data = base64.urlsafe_b64decode(s + padding)
if base64.urlsafe_b64encode(data).decode("ascii").rstrip("=") != s:
raise ValueError("not canonical unpadded base64url")
return data
def verify_receipt(receipt: dict, trusted_public_key: str) -> bool:
# trusted_public_key is the issuer's key, obtained from somewhere other
# than this receipt. Never use receipt["signature"]["public_key"] here:
# see "What Receipts Prove (and What They Do Not)" below.
# Fails closed: anything malformed returns False instead of raising.
if not isinstance(receipt, dict) or not isinstance(trusted_public_key, str):
return False
sig_obj = receipt.get("signature")
if not isinstance(sig_obj, dict) or sig_obj.get("alg") != "EdDSA":
return False
sig_b64 = sig_obj.get("sig")
if not isinstance(sig_b64, str):
return False
try:
# Reconstruct the payload that was actually signed (everything except signature).
payload = {k: v for k, v in receipt.items() if k != "signature"}
canonical_bytes = canonicalize(payload)
verify_key = signing.VerifyKey(b64url_decode(trusted_public_key))
verify_key.verify(canonical_bytes, b64url_decode(sig_b64))
return True
except (CryptoError, TypeError, ValueError, KeyError, OverflowError):
return False
except Exception:
# An undecodable key or signature, or a payload that cannot be
# canonicalized: fail closed rather than raise.
return False
פונקציה זו מקבלת קבלה ומפתח ציבורי של המנפיק, ומחזירה True אם החתימה תקפה ו-False אחרת, כולל כאשר הקלט לקוי. אין צורך בקריאה לרשת או שירות אימות: ברגע שמחזיקים במפתח המנפיק, האימות הוא באופן מלא מקומי ולא מקוון. מה שעדיין דרוש הוא מפתח זה, המושג ממקור אחר מאשר הקבלה עצמה.
לצפייה בזיהוי זיופים בפעולה, הפנקס מראה:
tool_args_hash.שלב 4 הוא זה שכדאי לשבת איתו. קבלה זו עקבית פנימית: החתימה אמיתית לתוכנה ולמפתח שהיא נושאת, ולכן מאומתת אל מול אותו מפתח. היא נכשלת רק כשהיא נבדקת מול המפתח האמיתי של המנפיק. שלבים 2 ו-3 תופסים את מי שלא טרח לחתום מחדש; שלב 4 תופס את זה שכן.
זו ההדגמה המעשי לכך שקבלות מתועדות לזיופים: כל שינוי בשדה חתום שוברת את החתימה, בתנאי שמבצעים אימות מול מפתח שהמתקיף לא סיפק. האובייקט signature עצמו מחוץ לבייטים החתומים, ולכן המפתח לאימות חייב להגיע ממקור חיצוני לקבלה.
קבלה בודדת חתומה מגנה על פעולה אחת. שרשרת של קבלות מגנה על רצף.
flowchart LR
R0[Receipt 0<br/>genesis] --> R1[Receipt 1]
R1 --> R2[Receipt 2]
R2 --> R3[Receipt 3]
R1 -. previous_receipt_hash .-> R0
R2 -. previous_receipt_hash .-> R1
R3 -. previous_receipt_hash .-> R2
כל קבלה מתעדת את החשיש של הקבלה הקודמת לה. כדי להסיר בשקט את הקבלה 2, על התוקף:
previous_receipt_hash בקבלה 3 (שובר את החתימה של קבלה 3), אואם המפתח הפרטי נמצא בכספת חומרה והמאמתים בודקים כל קבלה מול מפתח ציבורי של המנפיק, שהושג באופן עצמאי (ערכת JWK מפורסמת או ערך קונפיג קבוע), אין אף התקפה מוצלחת ללא גילוי. פרסום המפתח בתוך כל קבלה בלבד אינו מספק: תוקף יכול לחתום מחדש עם המפתח שלו ולהטמיע אותו במקום, שהוא המקרה 04_resigned_receipt.json.
הפנקס מראה:
previous_receipt_hash של כל קבלה תואם לחשיש האמיתי של הקבלה הקודמת.כך מייצרים עקבות ביקורת שניתן לאמת על ידי בודק חיצוני תחת מפתחות מנפיקים מקובעים ונקודות ביקורת בשרשרת, מבלי לסמוך על מאגר יומנים משתנים שלכם.
זה החלק החשוב ביותר בשיעור זה. הקבלות הן עוצמתיות אך בכוחן יש גבול.
קבלות מוכיחות שלושה דברים:
קבלות אינן מוכיחות:
policy_id אומתה בפועל, או שהייתה מאפשרת פעולה זו אם הייתה נבדקת. הקבלה מתעדת את הטענה, לא את האכיפה.המפתח בקבלה אינו המפתח איתו מאמתים. זה נובע מנקודה 3, וזו הנקודה היחידה שבה ההבחנה צריכה להשפיע על קודכם ולא רק על הבנתכם. ה-public_key בדוגמה למעלה קיים כדי שהדוגמה תהיה עצמאית. מאמת אף פעם לא צריך לסמוך עליו. כל אחד יכול לקחת קבלה, לשנותה, לחתום עליה במפתח שיצר, ולהטמיע את המפתח; התוצאה מאומתת באופן מושלם אל עצמה. זו התרחיש 04_resigned_receipt.json ב-sample_receipts/, ולכן verify_receipt למעלה מקבל את המפתח כארגומנט במקום לקרוא אותו מהקבלה. השיגו את מפתח המנפיק באופן עצמאי, מערכת JWK ברשימת הבדיקות למטה או עוגן אחר שקבעתם מראש, ואמתו עמו. חתימה שנבדקה בעזרת מפתח שהגיע באותה מעטפה מוכיחה רק שהמעטפה עקבית פנימית.
גבול זה חשוב משני טעמים:
טעות נפוצה היא להניח ש”יש לנו קבלות” פירושו “יש לנו ממשל.” זה לא כך. הקבלות הן בסיס. הממשל הוא המערכת שבונים מעליו.
סעיף 3 למעלה ראוי לפרק משלו: קבלת פעולה אומרת “מפתח זה חתום על תוכן זה,” לעולם לא “אדם אישר זאת.” לפעולות בסיכון גבוה (החזרים, מחיקות, העברות כספים), חתימת מאשר נפרדת יכולה לקשר לפעולה המדויקת. חיבור המפתח לאדם ובדיקת נוכחות האדם נשארות באחריות נפרדת.
הפנקס ההמשך code_samples/human-authorization-receipts.ipynb מוסיף סוג קבלה שני, human.approval.v1, באותו מבנה מעטפה כמו קבלות השיעור (מטען ממוין חתום Ed25519 על הבייטים הקנוניים של JCS, עם אובייקט signature מחוץ לבייטים החתומים). מפתח המאשר חותם על הפעולה הקנונית המלאה ועיכול שלה; מפתח הסוכן חותם על טענה הכוללת את אותו עיכול פעולה ו-parent_approval_ref, ה-receipt_hash של האישור, ההסכמה היא כפי ב-previous_receipt_hash בשרשרת שבניתם למעלה. אחד מ-verify_chain מאמת את שני הקבצים תחת רשומות מפתחות מקובעות נפרדות (מפתחות מאשרים מול מפתחות סוכן), כך שקוד המסלול משותף אך הרשויות לעולם לא.
המאפיין שנרכש בזהירות: מפתח המאשר המקובע חתם על הפעולה המדויקת הזו, ומפתח הסוכן לאחר מכן חתם על הצהרה הנושאת את אותו עיכול פעולה. זהו ראיה שימושית, אך איננו הוכחה בפני עצמם שהפעולה בוצעה. לשלוט בביצוע, האישור המדויק חייב להיות שמור ונצרך פעם אחת בגבול המבצע האמיתי; תוצאות ספק לא מוכרות חייבות להישאר לא מוכרות ולא לנסות שוב בעיוורון. מערכות דחיית הפנקס בודקות את שכבת שרשרת הקבלות:
סמכות פגה: חתימה שעדיין מאומתת, נדחתה בכל זאת כי גרסת המדיניות השתנתה, מפתח המאשר הוסר מרשימת הנעילה, או שהאישור פג תוקף לפני זמן האימות שסופק; ניסה שוב בעיוורון. פיקסציית סירוב המחברת בוחנת את שכבת שרשרת הקבלה:
כל כישלון מסרב מסיבה מובחנת, כך שבודק המתעד את הסירוב יכול לדעת אם הסמכות הפכה מיושנת או שהפעולה המתועדת השתנתה. האימות הוא קריאה בלבד וחזרתי: הוא אינו צורך את האישור ואינו מפעיל ספק שירות. מבצע נפרד זקוק להגנה על השמעה חוזרת עמידה, אטומית, ותוצאות מפורשות של הצלחה, כישלון ובלתי חד-משמעי. קבלת האישור האנושי היא קומפוזיציה חינוכית המוגדרת בשיעור זה, ולא סוג קבלה המוגדר על ידי draft-farley-acta-signed-receipts.
קוד הפייתון בשיעור זה הוא בזירות בכוונה כך שתוכל לקרוא כל שורה ולהבין בדיוק מה קורה. בפרודקשן, יש לך שתי אפשרויות:
לבנות ישירות על הפרימיטיבים הקריפטוגרפיים. 50 השורות שראיתם למעלה מספיקות להרבה שימושים. PyNaCl (Ed25519) ו-jcs החבילה (JSON קנוניקלית) הן ספריות המתוחזקות ובעלות ביקורת.
להשתמש בספריית קבלות לפרודקשן. כמה פרויקטים בקוד פתוח מממשים את אותו דפוס עם תכונות נוספות (סיבוב מפתחות, אימות באצווה, הפצת סט JWK, אינטגרציה עם מנועי מדיניות):
draft-farley-acta-signed-receipts, גרסה 02). הקבלה הפלטית החינוכית בשיעור זה שונה מקופסית ה{payload, signature} שבטיוטה ואינה מוצגת כמימוש תואם. הטיוטה מפרסמת ערכת תאימות משותפת (agent-governance-testvectors) למימושים המכוונים לפורמט הכבל שלה.protect-mcp (npm) ו-@veritasacta/verify (npm) מספקות מימוש מבוסס Node של חתימת קבלה ואימות לא מקוון, מיועדות לעטוף כל שרת MCP עם מסלול ביקורת המגלה מניפולציה, כולל תהליך החזקת חתימה משותפת שבו פעולה מושהית מפיקה קבלת אישור הקשורה לסיכום הפעולה (מתמך על WebAuthn בזרימת שולחן העבודה), אותו דפוס קבלת אישור כפי במחברת ההרשאה האנושית לעיל.pip install nobulex) מספק את אותו דפוס חתימה Ed25519 + JCS בפייתון עם אינטגרציות LangChain ו-CrewAI, כולל וקטורי בדיקה מפרסמים לבחינת חוצי-אימות ומיפוי תאימות שוּתף דרך OWASP PR #2210.ההחלטה בין לפתח לבד לבין להשתמש בספרייה משקפת את ההחלטה בין לכתוב ספריית JWT משלך ולהשתמש באחת שנבדקה: שניהם הגיוניים; הספרייה חוסכת זמן ומפחיתה את שטח הבדיקה; הגישה מהיסוד מאלצת אותך להבין כל פרימיטיב. שיעור זה מלמד את המסלול מהיסוד כדי שיהיה לך בסיס לכל אחת מהבחירות.
בדוק את הבנתך לפני המעבר לתרגיל המעשי.
1. קבלה נחתמת עם מפתח Ed25519 פרטי של הסוכן. למבקר יש רק את המפתח הציבורי. האם המבקר יכול לאמת את הקבלה במצב לא מקוון?
2. תוקף משנה את השדה policy_id של קבלה כדי לטעון שהיא נשלטה על ידי מדיניות סלחנית יותר. החתימה הייתה על המטען המקורי. מה קורה במהלך האימות?
3. מדוע הקבלה כוללת tool_args_hash ו-result_hash במקום הפרמטרים התורניים והתוצאה הגולמיים?
4. שדה previous_receipt_hash מקשר כל קבלה ל”קבלה הקודמת” שלה. אם תוקף מוחק בשקט קבלה אחת מתוך אמצע השרשרת, מה יהפוך ללא תקף?
5. קבלה מאומתת נכונה. האם זה מוכיח שהפעולה של הסוכן הייתה נכונה, תקפה או בהתאם למדיניות?
פתח את code_samples/18-signed-receipts.ipynb והשלים את כל ארבעת החלקים:
אתגר נוסף 1: הרחב את סכימת הקבלה עם שדה נוסף שבחרת (למשל, מזהה בקשה למעקב), עדכן את הלוגיקה לחתימה הקנונית כדי לכלול אותו, ואמת שהקבלה עוברת את תהליך האימות בשלמותה. לאחר מכן שנה את השדה לאחר החתימה ואמת שהאימות נכשל. זה מאלץ אותך להבין כיצד כל בית בקידוד הקנוני תורם לחתימה.
אתגר מתיחה 2: חשב SHA-256-Hash לשני הקבלות שלך יחד (שלב את הבתים הקנוניים שלהם בסדר דטרמיניסטי) ותשלב את הסיכום המתקבל כשדה חדש בקבלה שלישית לפני החתימה שלה. אמת שכל שלוש הקבלות עדיין עוברות סיבוב. הרגע יצרת הוכחת הכללה שלב אחד: כל מי שמחזיק בקבלה השלישית יכול להראות ששתי הראשונות היו קיימות בזמן שחתמו עליה, מבלי להזדקק לחשוף את תוכנן. זהו התבנית שבה משתמשות קבלות של גילוי סלקטיבי בקנה מידה (מחויבות מרקל, RFC 6962).
קבלות קריפטוגרפיות מעניקות לסוכני AI מסלול ביקורת שהוא:
הם אינם תחליף לבדיקה של קלט, אכיפת מדיניות, קבלת מבצעים, ראיות לתוצאה, בקרות שלמות, או תשתית זהות. הם בסיס לשכבות אלה. בעבודות מסודרות או רב-ארגוניות, קבלות מאפשרות לבדוק באופן עצמאי הצהרות ספציפיות של המנפיק תחת תצורת האמון של המבקר.
התובנה החשובה ביותר: קבלות מוכיחות שמפתח מסוים חתם תוכן ספציפי. חותם עם חותמת זמן נחשב לאישור חתימה אלא אם צוינה חותמת זמן נפרדת. קבלה אינה מוכיחה שהתוכן שלה היה נכון, שהפעולה בוצעה, או שסט הרשומות שלם. שמור על ההבחנות האלה בקפדנות.
הצטרפו ל-Microsoft Foundry Discord כדי לפגוש לומדים אחרים, להשתתף בשעות קבלה ולקבל מענה לשאלות שלכם על סוכני AI.
שיעור זה מכסה חתימה על קבלה בודדת ורצפים בשרשרת גיבוב. אותם פרימיטיבים מתארגנים למספר דפוסים מתקדמים נוספים שתיתקלו בהם ככל שעמדת הממשל שלכם תתפתח:
authorization_*) ואחרי ביצוע (result_*) עם חתימות עצמאיות, שימושי כשחלטת האישור והתוצאה הנצפית מיוצרים על ידי שחקנים שונים או בזמנים שונים. זה מצטבר על פורמט הקבלה שנלמד בשיעור זה.result_hash. מטענים בעולם האמיתי לרוב עשירים מתוצאות קריאה של כלי יחיד: נימוקים לפני החלטה (תחזית מודל, אפשרויות שנבדקו, ראיות ושלימותן, סיכון, שרשרת אחריות, תוצאת שער) יכולים להתקיים בתוך המטען, הכל חתם בקבלה אחת. זה שומר על פורמט הקבלה מינימלי ומאפשר לסכמות מטען להתפתח תחום אחר תחום.alg לבדה אינה מעבר: פרופיל חייב להגדיר קידוד מפתחות ML-DSA, בתים חתומים קאנוניים, אימות, מדיניות לקוחות, עמידות להורדה והמשמעויות במעבר. תכננו ובדקו מעבר עם חתימה כפולה מול וקטורים משותפים לפני שתטענו לתאימות.יצירת סוכני בינה מלאכותית מקומיים
כתב ויתור: מסמך זה תורגם באמצעות שירות תרגום אוטומטי Co-op Translator. למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עלולים להכיל שגיאות או אי-דיוקים. יש להחשיב את המסמך המקורי בשפתו הטבעית כמקור הסמכות. למידע קריטי מומלץ להשתמש בתרגום מקצועי על ידי מתרגם אדם. אנו לא אחראים לכל אי-הבנה או פירוש שגוי הנובע מהשימוש בתרגום זה.