പാഠം വീഡിയോ കാണുക: ക്രിപ്റ്റോഗ്രാഫിക് റസീപ്പ്റ്റുകളിലൂടെ AI ഏജന്റുകളെ സുരക്ഷിതമാക്കൽ
(പാഠം വീഡിയോയും തംബ്നെയിലും മൈക്രോസോഫ്റ്റ് ഉള്ളടക്കം സംഘത്തെഴുതിയതായി ലയിപ്പിച്ചതിന് ശേഷം കൂട്ടിച്ചേർക്കും, പാഠം 14 / 15 മാതൃകയോട് പൊരുത്തപ്പെടുന്ന വിധം.)
ഈ പാഠം ഉൾക്കൊള്ളുന്നതാണ്:
ഈ പാഠം പൂർത്തിയാക്കിയ ശേഷം, നിങ്ങൾ അറിയുകയും ചെയ്യുകയും ചെയ്യുക:
ഉപമ ചെയ്യുക നിങ്ങൾ കണ്ടോസോ ട്രാവലിനു വേണ്ടി ഒരു AI ഏജന്റ് വിന്യസിച്ചു. ഏജന്റ് ഉപഭോക്തൃ അഭ്യർഥനകൾ വായിച്ചും, ഫ്‌ലൈറ്റ് API-ൽ കോളുകൾ നടത്തിയും, ഉപഭോക്താവിന് വേണ്ടി സീറ്റുകൾ ബുക്ക് ചെയ്യുന്നതും ചെയ്യുന്നു. കഴിഞ്ഞ കോളിഫോറിനിടെ ഏജന്റ് 50,000 ബുക്കിംഗുകൾ പ്രോസസ്സ് ചെയ്തു.
ഇന്ന് ഒരാൾ ഓഡിറ്ററായെത്തുന്നു. അവർ ഒരു ലളിതമായ ചോദ്യം ചോദിക്കുന്നു: “നിങ്ങളുടെ ഏജന്റ് എന്തു ചെയ്തത് കാണിക്കുമോ?”
നിങ്ങൾ ലോഗ് ഫയലുകൾ കൈമാറുന്നു. ഓഡിറ്റർ അവ പരിശോധിക്കുകയും ഒരു ബുദ്ധിമുട്ടുള്ള ചോദ്യം ചോദിക്കുകയും ചെയ്യുന്നു: “ഈ ലോഗുകൾ തിരുത്തപ്പെട്ടതല്ലെന്ന് എങ്ങിനെ എനിക്ക് അറിയാം?”
ഇത് ഓഡിറ്റ്-ട്രെയിൽ പ്രശ്നമാണ്. ഇന്ന് വ്യാപകമായി ഏജന്റ് വിന്യാസങ്ങൾ അടിസ്ഥാനമാക്കുന്നത്:
ഇവയിൽ ഒന്നും ഓഡിറ്ററുടെ ചോദ്യം മറുപടി നൽകാൻ കഴിയില്ല അതിനായി ഓഡിറ്റർ ആരെയോ വിശ്വസിക്കണം (നിങ്ങളോ, ക്ലൗഡ് പ്രൊവൈഡറോ, ഡാറ്റാബേസ് വിൽപ്പനക്കാരോ). ആന്തരിക ഉപയോഗത്തിന് അത് അനുവദനീയമാണ്. നിയമാനുസൃത ജോലികൾക്ക് (ഫിനാൻസ്, ഹെൽത്ത്‌കെയർ, EU AI നിയമം ബാധിക്കുന്ന ഏതെങ്കിലും) അത് ബാധകമല്ല.
ക്രിപ്റ്റോഗ്രാഫിക് റസീപ്പ്റ്റുകൾ ഓരോ ഏജന്റ് പ്രവർത്തനവും സ്വതന്ത്രമായി പരിശോധിക്കാനാകുന്ന വിധം പരിഹരിക്കുന്നു. ഓഡിറ്റർ നിങ്ങളെ വിശ്വസിക്കേണ്ടതില്ല. അവർത്തീ ലീ പബ്ലിക് കീയും റസീപ്പ് ഒറ്റപ്പെട്ടും ആവശ്യമാണ്.
റസീപ്പ് AEജന്റ് എന്തു ചെയ്തു എന്നതിന്റെ രേഖപ്പെടുത്തുന്ന JSON ഒബ്ജക്ടാണ്, ഡിജിറ്റൽ ഒപ്പുമായി ഒപ്പ് വെച്ചതും.
flowchart LR
A[ഏജന്റ് ഒരു ടൂൾ വിളിക്കുന്നു] --> B[രസീത് പേലോഡ് നിർമ്മിക്കുക]
B --> C[JSON RFC 8785 കാനോണിക്കൽ ആക്കുക]
C --> E[Ed25519 കാനോണിക്കൽ ബൈറ്റുകൾ അപേക്ഷിക്കുക]
E --> F[ഒപ്പ് കൂടിയ രസീത്]
F --> G[ഓഡിറ്റർ ഓഫ്ലൈൻ പരിശോധന നടത്തുന്നു]
G --> H{ഒപ്പ് സാധുവാണോ?}
H -- yes --> I[തരിപ്പിന് തെളിവ്]
H -- no --> J[രസീത് നിരസിച്ചു]
ഏറ്റവും ലഘുവായ ഒരു റസീപ്പ് ഇപ്രകാരമാണ്:
{
"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 Canonicalization Scheme (JCS, RFC 8785) ഉപയോഗിച്ച് സീരിയലൈസ് ചെയ്യുന്നു. ഇതു മൂലം രണ്ട് സാദൃശ്യമായ റസീപ്പുകൾ ബൈനറി സമാനമായി ഉണ്ടാകും. കാനോണിക്കൽ ചെയ്യാതിരുന്നാൽ വിവിധ JSON സീരിയലൈസറുകൾക്ക് വ്യത്യസ്ത ഒപ്പുകൾ ഉണ്ടാകുമായിരുന്നു.
ഹാഷ്-ചെയിനിംഗ്. previous_receipt_hash ഫീൽഡ് ഓരോ റസീപ്പിനെയും മുൻവരെയുമായി ബന്ധിപ്പിക്കുന്നു. ഒരു റസീപ്പ് നീക്കം ചെയ്യുകയോ ക്രമം മാറ്റുകയോ ചെയ്താൽ അതിനുശേഷമുള്ള എല്ലാ റസീപ്പുകളും അസാധുവാകും. വ്യക്തിഗത ഒപ്പുകൾ മറികടന്നാലും അത്യന്ത ചെറിയവിവരങ്ങൾ പോലും ചെയിൻ തലത്തിലേക്ക് എളുപ്പത്തിൽ ശ്രദ്ധിക്കപ്പെടും.
ഈ ലക്‌ഷണങ്ങൾ ചേർന്ന് മൂന്ന് ഉറപ്പുകൾ നൽകുന്നു:
റസീപ്പ് സൃഷ്‌ടിക്കാൻ പ്രത്യേക ലൈബ്രറി ആവശ്യമില്ല. ക്രിപ്റ്റോഗ്രാഫിക് പ്രിമിറ്റിവുകൾ ലഭ്യമാണ്, ലജിക് Python-ന്റെ കുറച്ചു വരികളിൽ തീർക്കാം.
code_samples/18-signed-receipts.ipynb യിലെ ഹാൻഡ്‌സ്-ഓൺ വ്യായാമങ്ങൾ സമ്പൂർണ്ണ ഫ്ളോ വിശദീകരിക്കുന്നു. സംഗ്രഹം ഇപ്രകാരം:
import json
import hashlib
import base64
from nacl import signing
from jcs import canonicalize # RFC 8785 കാനോണിക്കൽ 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()}"
# സൈൻ ചെയ്യാനുള്ള കീ സൃഷ്ടിക്കുക അല്ലെങ്കിൽ ലോഡ് ചെയ്യുക (പ്രൊഡക്ഷനിൽ, കീ വാൾട്ടിൽ സൂക്ഷിക്കുക)
signing_key = signing.SigningKey.generate()
verify_key = signing_key.verify_key
# ലഭിപ്പ് പേലോഡ് നിർമ്മിക്കുക (ഇപ്പോൾ സൈൻ ചെയ്യണം)
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,
}
# JCS ബൈറ്റുകൾ നേരിട്ട് കാനോണീകലൈസ് ചെയ്ത് സൈൻ ചെയ്യുക. PureEdDSA ആന്തരികമായി ഹാഷുകൾ ചെയ്യുന്നു.
canonical_bytes = canonicalize(payload)
signature_bytes = signing_key.sign(canonical_bytes).signature
# ഘടിത സൈൻചെയ്യലിന്റെ ഓബ്ജക്ട് ചേർക്കുക.
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 BadSignatureError
from jcs import canonicalize
def b64url_decode(s: str) -> bytes:
padding = "=" * ((4 - len(s) % 4) % 4)
return base64.urlsafe_b64decode(s + padding)
def verify_receipt(receipt: dict) -> bool:
# ഒപ്പു ഒരു ഘടനാത്മക ഇനമാണ്: {"alg", "sig", "public_key"}.
sig_obj = receipt.get("signature")
if not sig_obj or sig_obj.get("alg") != "EdDSA":
return False
# യഥാർത്ഥത്തിൽ ഒപ്പിട്ട പേയ്ലോഡ് പുനരേധരിപ്പിക്കുക (ഒപ്പു ഒഴികെയുള്ള എല്ലാം).
payload = {k: v for k, v in receipt.items() if k != "signature"}
canonical_bytes = canonicalize(payload)
try:
verify_key = signing.VerifyKey(b64url_decode(sig_obj["public_key"]))
verify_key.verify(canonical_bytes, b64url_decode(sig_obj["sig"]))
return True
except BadSignatureError:
return False
ഈ ഫംഗ്ഷൻ ഒരു റസീപ്പ് സ്വീകരിക്കുകയും ഒപ്പു സാധുവാണെങ്കിൽ True മടങ്ങിക്കും, അല്ലെങ്കിൽ False. ന്െറ്റ്‌വർക്ക് കോളോ സേവന ആശ്രിതത്വമോ ഇല്ല. മൂന്നാംകക്ഷി വിശ്വാസത്തിനും ആവശ്യമില്ല.
മാറ്റം കണ്ടെത്തൽ പ്രദർശിപ്പിക്കാൻ നോട്ട്‌ബുക്ക് നിർദേശിക്കുന്നത്:
tool_args_hash ഫീൽഡിലെ ഒരു ബൈറ്റ് മാറ്റുക.ഇത് പ്രായോഗികമായി തെളിയിക്കുന്നത് റസീപ്റ്റുകൾ ട്യാംപർ-ഒളിഞ്ഞതാണ്: ഏതെങ്കിലും ചെറിയ മാറ്റവും ഒപ്പു തകർക്കും.
ഏകദേശം ഒപ്പ് വെച്ച റസീപ്പ് ഒരേ പ്രവർത്തനത്തെ സംരക്ഷിക്കുന്നു. റസീപ്പുകളുടെ ഒരു ചെയിൻ പരമ്പരയെ സംരക്ഷിക്കുന്നു.
flowchart LR
R0[സ്വീകരണം 0<br/>ആരംഭം] --> R1[സ്വീകരണം 1]
R1 --> R2[സ്വീകരണം 2]
R2 --> R3[സ്വീകരണം 3]
R1 -. previous_receipt_hash .-> R0
R2 -. previous_receipt_hash .-> R1
R3 -. previous_receipt_hash .-> R2
ഓരോ റസീപ്പും മുൻവരെയുള്ള റസീപ്പിന്റെ ഹാഷ് രേഖപ്പെടുത്തുന്നു. റസീപ്പ് 2 സൈലന്റായി ആപേക്ഷിച്ച് നീക്കം ചെയ്യുന്നതിനുവേണ്ടി ആക്രമകന് ഡോ രണ്ടു വഴികളിലൊന്നിലോ ആയിരിക്കും ശ്രമിക്കുക:
previous_receipt_hash ഫീൽഡ് മാറ്റുക (റസീപ്പ് 3 ഒപ്പിന് അപാകത വരും), അല്ലെങ്കിൽപ്രൈവറ്റ് കീ ഹാർഡ്വയർ കീ വാൾട്ടിൽ സൂക്ഷിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ ഓരോ റസീപ്പിനും പബ്ലിക് കീ പ്രസിദ്ധീകരിച്ചാൽ, ഈ ആക്രമണങ്ങളിൽ ഒന്നും കണ്ടെത്തപ്പെടാതെ നടത്താനാവില്ല.
നോട്ട്‌ബുക്ക് വിശദീകരിക്കുന്നത്:
previous_receipt_hash മുൻവരെയുള്ള റസീപ്പിന്റെ യഥാർത്ഥ ഹാഷ് ആയി യോജിച്ചതാണോ എന്ന് പരിശോധിക്കുക.ഇതു പുറത്തുള്ള ഒരു ഓഡിറ്റർ നിങ്ങൾ വിശ്വസിക്കാതെയും ഇതു പരിശോധിക്കാനാകും വിധത്തിലുളള ഓഡിറ്റ് ട്രെയിൽ തയ്യാറാക്കലാണ്.
ഇതു ഈ പാഠത്തിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ഭാഗമാണ്. റസീപ്പുകൾ ശക്തിയുള്ളവയാണ്, എന്നാൽ അവയുടെ ശക്തിക്ക് പരിധിയുണ്ട്.
റസീപ്പുകൾ മൂന്ന് കാര്യങ്ങൾ തെളിയിക്കുന്നു:
റസീപ്പുകൾ തെളിയിക്കാത്ത കാര്യങ്ങൾ:
policy_id-ൽ നൽകിയ നയം വിലയിരുത്തിയതോ, നീലവയ്പ്പുമുണ്ടായിരുന്നുവോ എന്ന കാര്യങ്ങൾ. റസീപ്പ് കണ്ടത് നൽകുന്നു, നടപ്പിലാക്കിയത് അല്ല.ഈ അതിരുകൾ രണ്ട് കാരണങ്ങൾക്കു പ്രധാനമാണ്:
സാധാരണ പിഴവ് “നമുക്ക് റസീപ്പുകൾ ഉണ്ട്” എന്നതിന്റെ അർത്ഥം “നാം ഭരണഘടനയാൽ നിയന്ത്രിക്കപ്പെടുന്നു” എന്നാക്കി കരുതലാണ്. അത്തരം കാര്യങ്ങളല്ല. റസീപ്പുകള്‍ അടിസ്ഥാനം മാത്രമാണ്. ഭരണത്തിന് മേൽനോട്ട സ്ഥാപനമാണ്.
മുകളിൽപ്പെട്ട ഇനം 3 സ്വന്തം ഒരു വിഭാഗമായി വർക്കു: ഒരു പ്രവർത്തന റസീപ്പ് പറയുന്നു “ഈ കീ ഈ ഉള്ളടക്കം ഒപ്പിട്ടു”, “ഒരു മനുഷ്യൻ അത് അംഗീകരിച്ചു” അല്ല. ഉയർന്ന അപകട പ്രവർത്തനങ്ങൾക്കു (റീഫണ്ടുകൾ, മുളയൽ, വൈർ ട്രാൻസ്‌ഫറുകൾ) ഭരണം ചട്ടങ്ങൾ ഇതു വേണമെന്ന ആവശ്യങ്ങൾ വർധിക്കുകയും, ഇതേ സങ്കേതങ്ങൾ ഉപയോഗിച്ച് നിർമ്മിക്കാം.
തുടർന്നുള്ള നോട്ട്‌ബുക്ക് code_samples/human-authorization-receipts.ipynb രണ്ടാമത്തെ റസീപ്പ് തരമായ human.approval.v1 സെറ്റ് ചെയ്യുന്നു, പാഠത്തിലെ റസീപ്പുകൾപോലെ സാംമുഖ്യ പേരിലുള്ള പെയ്‌ലോഡ് Ed25519 ഒപ്പിട്ട, canonical JCS ബൈറ്റുകൾക്ക് പുറത്ത് signature ഓബ്‌ജക്റ്റുള്ളത്. ഒരു പേരിട്ട അംഗീകർത്താവ് സമ്പൂർണ്ണ കാനോണിക്കൽ പ്രവർത്തനം അതിന്റെ ഡൈജസ്റ്റ് ഒപ്പിടുന്നു മുൻകൂട്ടി; ഏജന്റിന്റെ പ്രവർത്തന റസീപ്പ് അതേ പ്രവർത്തന ഡൈജസ്റ്റ് കരുതുന്നു, parent_approval_ref കൂടാതെ, അംഗീകത്തിന്റെ receipt_hash ആണ്, മുകളിൽനിര്‍മ്മിച്ച ചെയിനിലെ previous_receipt_hash പോലെ. verify_chain ഒരേ സമയം ഇരട്ട ആർ‌ടി‌ഫാക്ടുകൾ വ്യത്യസ്ത കീ രജിസ്ട്രിയിലും ഉറപ്പുവരുത്തുന്നു (അംഗീകർത്താക്കളുടെ കീകൾ എങ്കിലും ഏജന്റ് കീകൾ എങ്കിലും), കോഡ് വഴിയും പൊതുവായതാണ്, അധികാരങ്ങൾ പങ്കിടുന്നില്ല.
ഈ സ്വഭാവം സൂക്ഷ്മമായി പറയുന്നത്: മനുഷ്യൻ ഈ സമയത്തെ പ്രവർത്തനം അംഗീകരിച്ചു, ഏജന്റ് അങ്ങനെ അംഗീകരിക്കപ്പെട്ട പ്രവർത്തനം തന്നെ നടപ്പാക്കി. നോട്ട്‌ബുക്കിന്റെ നിരാകരണ ഘടകങ്ങൾ ഈ സ്വഭാവം സത്യസന്ധമാക്കുന്നു:
ഓരോ പരാജയവും വ്യത്യസ്ത കാരണം നൽകി മാറ്റുന്നു, അതുകൊണ്ട് ഓഡിറ്റര്‍ നിരാകരണം വായിക്കുമ്പോള്‍ അധികാരം കാലഹരണപ്പെട്ടോ പ്രവർത്തനം മാറിയോ എന്ന് മനസ്സിലാക്കാം. നോട്ട്‌ബുക്ക് പഠിപ്പിക്കുന്നത്: ഒപ്പ് വെച്ച അംഗീകാരം അതേ രീതിയില്‍ അധികാരമല്ല. രണ്ട് റസീപ്പുകൾ ഒരേ കാനോണിക്കൽ പ്രവർത്തനത്തിൽ ചേരുമ്പോഴേ अधिकारം ഉണ്ടാകൂ. മനുഷ്യ അംഗീകാരം റസീപ്പ് ഈ പാഠം നിർവചിച്ച ഒരു വിദ്യാഭ്യാസ സമാഹാരമാണു്, draft-farley-acta-signed-receipts നിർവചിച്ച റസീപ്പ് തരം അല്ല.
ഈ പാഠത്തിലെ Python കോഡ് ഉദ്ദേശം കുറഞ്ഞതായതിനാൽ ഓരോ വരിയിൽനിന്നും നിങ്ങൾ മനസ്സിലാക്കണം. നിർമ്മാണംവേള, നിങ്ങൾക്കുള്ള രണ്ട് തിരഞ്ഞെടുപ്പുകൾ ഉണ്ട്:
ക്രിപ്റ്റോഗ്രാഫിക് പ്രിമിറ്റിവുകളിൽ നേരിട്ട് നിർമ്മിക്കുക. മുകളിൽ കാണിച്ച 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 സെർവർ ട്രെയിൽ സുരക്ഷിതമാക്കുക, കൂടാതെ human-authorization സമാനമായ കൂടക്കണ്ടിച്ചെയ്യലുള്ള ഹോൾഡ്-ഫോർ-കോ-സൈൻ പ്രവർത്തനത്തിനും.pip install nobulex) Python-ში Ed25519 + JCS ഒപ്പ് ശൈലി LangChain, CrewAI സംയോജനങ്ങളോടും വാണിജ്യപരമായ മാപ്പിങ്ങും OWASP PR #2210 വഴി സംഭാവനകളും ഉൾപ്പെടെ.സ്വയം നിർമ്മിക്കയിലെ തിരഞ്ഞെടുപ്പ് ഒരു JWT ലൈബ്രറി എഴുതുന്നതുമായ സമാനമാണ്: ഇരaduതും സാക്ഷരമാണ്; ലൈബ്രറി സമയവും പരിശോധന ഭീതിയും കുറയ്ക്കുന്നു; സ്വയം തുടങ്ങുന്നത് എല്ലാ പ്രാഥമികവസ്തുക്കൾ മനസ്സിലാക്കണം. ഈ പാഠം സ്വതന്ത്ര മാർഗ്ഗം പഠിപ്പിക്കുന്നു അതിനാൽ നിങ്ങൾക്ക് ഏതു തിരഞ്ഞെടുപ്പ് വരും.
പ്രായോഗിക വ്യായാമത്തിലേക്ക് പോകുന്നതിന് മുമ്പ് നിങ്ങളുടെ മനസ്സിലാക്കൽ ടെസ്റ്റ് ചെയ്യുക.
1. റസീപ്പ് ഏജന്റിന്റെ സ്വകാര്യ Ed25519 കീ ഉപയോഗിച്ച് ഒപ്പിട്ടിരിക്കുന്നു. ഓഡിറ്ററിന് പൊതുഭവകീ മാത്രമേ ഉണ്ടാകൂ. ഓഡിറ്റർ റസീപ്പ് ഓഫ്ലൈൻ പരിശോധിക്കാനാകുമോ?
2. ഒരു ആക്രമകൻ റസീപ്പിൻറെ policy_id ഫീൽഡ് മാറ്റി കൂടുതലാണ് അനുവാദമുള്ള നയം പറഞ്ഞതായി വ്യാജമാക്കി. ഒപ്പ് ആദ്യ പെയ്‌ലോഡിൽ നിർമ്മിക്കപ്പെട്ടതാണ്. പരിശോധന സമയത്ത് സംഭവിക്കുന്നത് എന്ത്?
3. അസംയോജ്യമായ (raw) ആർമാനുകളും ഫലവും പകരം, റെസിപ്പിയിൽ tool_args_hash ഉം result_hash ഉം ഉൾ‍പ്പെടുത്തുന്നത് എന്തുകൊണ്ട്?
4. previous_receipt_hash ഫീൽഡ് ഓരോ റെസിപ്പിനെയും മുൻതലമുറയിലേക്ക് ബന്ധിപ്പിക്കുന്നു. ഒരു ചൈനിൽ മധ്യേ നിന്ന് ഒരു റെസിപ്പ് പതിവായി ഇല്ലാതാക്കുകയാണെങ്കിൽ എന്ത് അസാധുവാകും?
5. ഒരു റെസിപ്പ് ക്ലീനായി സ്ഥിരീകരിക്കുന്നു. അതിനാൽ ഏജന്റിന്റെ പ്രവർത്തനം ശരിയാണെന്ന്, സംശേധനരഹിതമാണെന്ന്, അല്ലെങ്കിൽ നയവുമായി അനുഗമിക്കുന്നുണ്ടെന്ന് തെളിയിക്കുമോ?
code_samples/18-signed-receipts.ipynb തുറന്ന് എല്ലാ നാല് വിഭാഗങ്ങളും പൂര്‍ത്തിയാക്കുക:
ബാഹ്യ പരീക്ഷണം 1: നിങ്ങളുടെ ഇഷ്ടാനുസൃതമായ ഒരു ഫീൽഡ് ചേർത്ത് റെസിപ്പ് സ്കീമ വിസ്തരിച്ചു (ഉദാ: ട്രേസിംഗ് jaoks रिक്വസ്റ്റ് ഐഡി), കാനോണിക്കൽ ഒപ്പിടലിന്റെ ലജിക് അപ്ഡേറ്റ് ചെയ്ത് അത് ഉൾപ്പെടുത്തുക, പിന്നീട് റെസിപ്പ് സ്ഥിതി ശരിയാണെന്ന് പരിശോധന നടത്തുക. ഒപ്പിടലിനുശേഷം ഫീൽഡ് മാറ്റുകയും സ്ഥിരീകരണം പരാജയപ്പെടുന്നത് ഉറപ്പാക്കുകയും ചെയ്യുക. ഇതിലൂടെ കാനോണിക്കൽ എൻകോഡിങ്ങിന്റെ ഓരോ ബাইটും സിഗ്നേച്ചറിന്റെ ഭാഗമാണെന്ന് മനസ്സിലാക്കണം.
ബാഹ്യ പരീക്ഷണം 2: നിങ്ങളുടെ രണ്ട് റെസിപ്പുകളുടെ കാനോണിക്കൽ ബൈറ്റുകൾ ക്രമത്തിൽ ചേർത്ത് SHA-256 ഹാഷ് നിർമ്മിച്ച്, ഫലമായ ഡൈജസ്റ്റ് മൂന്നാം റെസിപ്പിൽ പുതിയ ഫീൽഡ് ആയി ഉൾപ്പെടുത്തുക, അത് ഒപ്പിടുക. മൂന്ന് റെസിപ്പുകൾ മുഴുവനും ശുദ്ധമായ തിരിച്ചറിയൽ കടന്നുപോകുന്നത് പരിശോധിക്കുക. ഇത് ഒരു ഘട്ടത്തെ ഉൾക്കൊള്ളൽ സാക്ഷ്യപത്രം ആണ്: മൂന്നാം റെസിപ്പ് കൈവശമുള്ളയാൾ ആദ്യ രണ്ട് റെസിപ്പുകൾ ഒപ്പിട്ട സമയത്തെ തെളിയിക്കാം, അവരുടെ ഉള്ളടക്കം വെളിപ്പെടുത്താതെ. ഇത് ചെറിയ വിവര പരസ്യങ്ങൾ ഉള്ള റെസിപ്പുകൾ വലുതായി പ്രയോഗിക്കുന്ന പാറ്റേണാണ് (Merkle commitments, RFC 6962).
ക്രിപ്റ്റോഗ്രാഫിക് റെസിപ്പുകൾ AI ഏജന്റുകൾക്ക് നൽകുന്നു ഒരു ഓഡിറ്റ് ട്രെയിൽ:
അവ ഇൻപുട്ട് സാധുവാക്കൽ, നയം നടപ്പാക്കൽ, അല്ലെങ്കിൽ ഐഡന്റിറ്റി ഇൻഫ്രാസ്ട്രക്ചർ ഇനങ്ങൾക്ക് പകരം വയ്ക്കുന്നവയല്ല. അവ അവ കെട്ടിടം നിർമ്മിക്കുന്ന അടിസ്ഥാനം മാത്രമാണ്. നിയമിതമായ ജോലി, ബഹുസംഘടന പ്രവർത്തനങ്ങൾ, അല്ലെങ്കിൽ ഭാവിയിലെ ഓഡിറ്റർ നിങ്ങൾക്കു വിശ്വാസമില്ലാത്ത സാഹചര്യങ്ങളിൽ ഏജന്റുകൾ വിന്യസിക്കുമ്പോൾ, റെസിപ്പുകൾ ഓഡിറ്റ് ട്രെയിൽ വിശ്വസ്തമാക്കുന്നത് ആണ്.
ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യമാണ്: റെസിപ്പുകൾ വിജയിച്ച കീ ആ 사람이 എന്ത് പറഞ്ഞുവെന്ന്, എപ്പോൾ എന്നതിനെ തെളിയിക്കുന്നു. പറയപ്പെട്ടത് ശരിയാണോ അല്ലയോ എന്ന് തെളിയിക്കുന്നില്ല. ആ വ്യത്യാസം ശക്തമായി പിടിച്ച് നിർത്തുക. അത് സത്യസന്ധമായ ഒരു പ്രൊവനൻസ് സിസ്റ്റവും തെറ്റിദ്ധരിപ്പിക്കുന്ന സിസ്റ്റവും തമ്മിലുള്ള വ്യത്യാസമാണ്.
ഈ പാഠം അവസാനിപ്പിച്ച് യാഥാർത്ഥ്യപരമായ വാതവരണത്തിൽ റെസിപ്പ് ഒപ്പിട്ട ഏജന്റുകൾ വിന്യസിക്കാൻ തയ്യാറാകുമ്പോൾ:
https://your-org.example.com/.well-known/agent-keys.json.മറ്റ് പഠനാർത്ഥികളുമായി കൂടാൻ, ഓഫീസ് മണിക്കൂറുകളിൽ പങ്കെടുക്കാൻ, AI ഏജന്റുകളുടെ ചോദ്യങ്ങൾക്കുള്ള മറുപടി നേടാൻ Microsoft Foundry Discord ചേർക്കുക.
ഈ പാഠം ഏക റെസിപ്പ് ഒപ്പിടലും ഹാഷ്-ചെയിനുചെയ്യലുകളും ഉൾക്കൊള്ളുന്നു. അവ യഥാർത്ഥത്തിൽ നിരവധി മികവുറ്റ പാറ്റേണുകളിൽ നിർമിക്കപ്പെടുന്നു, നിങ്ങളുടെ ഗവർണൻസ് വളരുന്നതിനൊപ്പം നിങ്ങൾ കാണാം:
authorization_*) എങ്കിലും ശേഷീകൃത പ്രവർത്തനം (result_*) എന്നിങ്ങനെ വിഭജിച്ചും സ്വതന്ത്ര ഒപ്പുകളായും സമയം വ്യത്യാസം ഉള്ളവയായി നിലനിൽക്കുന്നു. ഇതേ പാഠത്തിൽ പഠിച്ച റെസിപ്പ് ഫോർമാറ്റിനു മുകളിൽ കൂട്ടിച്ചേർക്കാം.result_hash-ൽ ഉൾപ്പെടുത്തിയ ബൈറ്റുകളെല്ലാം ഒരു റെസിപ്പ് മുദ്രസ്സുചെയ്യുന്നു. യഥാർത്ഥ ലോകം പലതു നന്നായി സമൃദ്ധമാണ് ഒറ്റ ഉപകരണം വിളിപ്പലഫലം ഇനത്തിൽ പെടാത്തവ: മുൻ നിഗമന ചിന്തന (മോഡൽ പ്രവചനം, പരിഗണിച്ച ഓപ്ഷനുകൾ, തെളിവും അതിന്റെ പൂർണ്ണതയും, റിസ്‌ക് നില, ഉത്തരവാദിത്വം, ഗേറ്റ് ഫലം) എല്ലാം ബൈറ്റുകളായി ഒറ്റ റെസിപ്പിൽ അടച്ചുപൂട്ടാം. ഇത് റെസിപ്പ് ഫോർമാറ്റ് ലഘുവാക്കി ഡൊമെയ്ൻ അനുസരിച്ച് പേലോഡ് സ്കീമുകൾ വികസിപ്പിക്കാം.signature.alg ഫീൽഡിൽ ML-DSA-65 (NIST പോസ്റ്റ്-ക്വാണ്ടം ഒപ്പിടൽ സ്റ്റാൻഡേഡ്) വയ്ക്കാം, മാറ്റിസ്ഥാപിക്കേണ്ടപ്പോൾ. ഇരട്ട ഒപ്പിടൽ ഉപയോഗിച്ച് മാറ്റക്കാലം ആസൂത്രണം ചെയ്യുക.അറിയിപ്പ്: ഈ രേഖ AI പരിഭാഷാ സേവനം Co-op Translator ഉപയോഗിച്ച് പരിഭാഷപ്പെടുത്തിയതാണ്. ഞങ്ങൾ കൃത്യതയ്ക്കായി ശ്രമിക്കുന്നുവെങ്കിലും, ഓട്ടോമേറ്റഡ് പരിഭാഷകളിൽ പിഴവുകൾ അല്ലെങ്കിൽ തെറ്റായ വിവരങ്ങൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. അതിന്റെ സ്വാഭാവിക ഭാഷയിലുള്ള അസൽ രേഖയാണ് പ്രാമാണികമായ ഉറവിടമായി പരിഗണിക്കേണ്ടത്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ ശുപാർശ ചെയ്യുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ച് ഉണ്ടാകുന്ന തെറ്റിദ്ധാരണകൾ അല്ലെങ്കിൽ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കായി ഞങ്ങൾ ഉത്തരവാദികളല്ല.