ಪಾಠದ ವೀಡಿಯೋ ಅನ್ನು ನೋಡಿರಿ: ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ರಸೀದಿಗಳೊಂದಿಗೆ AI ಏಜೆಂಟ್ಗಳನ್ನು ಸುರಕ್ಷಿತಗೊಳಿಸುವುದು
(ಪಾಠ ವೀಡಿಯೋ ಮತ್ತು ಥಂಬ್ನೆಲ್ ಅನ್ನು ಮೈಕ್ರೋಸಾಫ್ಟ್ ವಿಷಯ ತಂಡವು ಮерж್ ಆದ ನಂತರ ಸೇರಿಸಲಾಗುವುದು, ಪಾಠ 14/15 ಮಾದರಿಯನ್ನು ಹೊಂದುತ್ತವೆ.)
ಈ ಪಾಠವು ಇವುಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:
ಈ ಪಾಠವನ್ನು ಮುಗಿಸಿದ ನಂತರ ನೀವು ತಿಳಿಯಬಹುದು:
ನೀವು Contoso ಟ್ರಾವೆಲ್ಗೆ ಒಂದು AI ಏಜೆಂಟ್ ಅನ್ನು ನಿಯೋಜಿಸಿದ್ದೀರಂತೆ. ಏಜೆಂಟ್ ಗ್ರಾಹಕರ ವಿನಂತಿಗಳನ್ನು ಓದಿ, ಫ್ಲೈಟ್ಗಳ API ಅನ್ನು ಕರೆ ಮಾಡಿ ಆಯ್ಕೆಗಳನ್ನು ಹುಡುಕಿ, ಮತ್ತು ಗ್ರಾಹಕರ ಪರವಾಗಿ ಸೀಟುಗಳನ್ನು ಬುಕ್ ಮಾಡುತ್ತದೆ. ಕಳೆದ ತ್ರೈಮಾಸಿಕದಲ್ಲಿ, ಏಜೆಂಟ್ 50,000 ಬುಕ್ಕಿಂಗ್ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಮಾಡಿತು.
ಇಂದು ಒಂದು ಆಡಿಯಟರ್ ಬರುವರು. ಅವರು ಸರಳ ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳುತ್ತಾರೆ: “ನಿಮ್ಮ ಏಜೆಂಟ್ ಏನು ಮಾಡಿದೆಯೋ ತೋರಿಸಿ.”
ನೀವು ನಿಮ್ಮ ಲಾಗ್ ಕಡತಗಳನ್ನು ನೀಡುತ್ತೀರಿ. ಆಡಿಯಟರ್ ಅವುಗಳನ್ನು ನೋಡುತ್ತಾನೆ ಮತ್ತು ಗಟ್ಟಿಯಾದ ಪ್ರಶ್ನೆ ಕೇಳುತ್ತಾನೆ: “ನಾನು ಹೇಗೆ ತಿಳಿದುಕೊಳ್ಳಬೇಕೆಂದು ಈ ಲಾಗ್ಗಳನ್ನು ಸಂಪಾದಿಸಲಾಗಿದೆ ಎಂದು?”
ಇದು ಆಡಿಯಟ್-ಟ್ರೇಲ್ ಸಮಸ್ಯೆ. ಇಂದಿನ ಬಹುತೇಕ ಏಜೆಂಟ್ ನಿಯೋಜನೆಗಳು ಇವುಗಳನ್ನು ಅವಲಂಬಿಸುತ್ತವೆ:
ಆಡಿಯಟರ್ ಯಾರನ್ನು ನಂಬಬೇಕೆಂಬುದಿಲ್ಲದೆ ಆಡಿಯಟರ್ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸುವುದಿಲ್ಲ. ಆಂತರಿಕ ಬಳಕೆಗೆ ಆ ನಂಬಿಕೆ ಸಾಮಾನ್ಯವಾಗಿ ಸ್ವೀಕಾರಾರ್ಹ. ನಿಯಂತ್ರಿತ ಕಾರ್ಯಗಳಿಗೆ (ಹಣಕಾಸು, ಆರೋಗ್ಯ ಸೇವೆ, EU AI ಅಧಿನಿಯಮಕ್ಕೆ ಒಳಪಟ್ಟ ಯಾವುದೇ ಕಾರ್ಯ), ಅದು ಸಾಧ್ಯವಿಲ್ಲ.
ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ರಿಸೀಟ್ಗಳು ಸಹಿ ಮಾಡಲಾದ ಹೇಳಿಕೆಯನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದಾಗಿಸುವ ಮೂಲಕ ಈ ಸಮಸ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಆಡಿಟರ್ಗೆ ಸಹಿ ಕೀಯನ್ನು ಮತ್ತು ಹೇಳಿಕೆಯನ್ನು ಉತ್ಪಾದಿಸಿದ ಘಟಕವನ್ನು ವಿಶ್ವಾಸಿಸಲು ಹೊರಗಿನ ಕಾರಣ ಇನ್ನೂ ಬೇಕಾಗುತ್ತದೆ. ಒಳಸೇರಿದ ಕೀ ಸ್ವಯಂ-ಸಂಗತತೆಯನ್ನು ದೃಢಪಡಿಸುತ್ತದೆ, ಅದು ಪ್ರಕಟಕರ ಗುರುತು ಅಥವಾ ಜಾರಿಗೆ ಬರುವ ಸ್ಥಳವಲ್ಲ.
ರಸೀದಿ ಅಂದರೆ ಏಜೆಂಟ್ ಏನ್ ಮಾಡಿದೆಯೋ ದಾಖಲಿಸುವ 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 ಇತ್ತೀಚಿನ ಸ್ವಚ್ಛ ಕಾರ್ಯಾಚರಣೆಯಿಂದ ನಿಖರವಾದ ನೋಟ್ಬುಕ್ ಹ್ಯಾಶ್, Python ಪರಿಸರ, ಸೆಲ್ ಎಣಿಕೆ ಮತ್ತು ತಪಾಸಣೆಗಳನ್ನೂ ದಾಖಲಿಸುತ್ತದೆ ಮತ್ತು ಪಾಠದ ಉಳಿಸಿರುವ ಔಟ್ಪುಟ್ಗಳನ್ನು ಬದಲಾಯಿಸದೆ ಇಡುತ್ತದೆ. ಸಾರಾಂಶ ಆವೃತ್ತಿ:
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:
padding = "=" * ((4 - len(s) % 4) % 4)
return base64.b64decode(s + padding, altchars=b"-_", validate=True)
def verify_receipt(receipt: dict, trusted_public_keys: set[str]) -> bool:
# The signature is a structured object: {"alg", "sig", "public_key"}.
if not isinstance(receipt, dict):
return False
sig_obj = receipt.get("signature")
if not isinstance(sig_obj, dict) or sig_obj.get("alg") != "EdDSA":
return False
try:
# An inline key proves only self-consistency. Trust is configured out of band.
public_key = sig_obj.get("public_key")
signature = sig_obj.get("sig")
if not isinstance(public_key, str) or not isinstance(signature, str):
return False
if public_key not in trusted_public_keys:
return False
payload = {k: v for k, v in receipt.items() if k != "signature"}
canonical_bytes = canonicalize(payload)
verify_key = signing.VerifyKey(b64url_decode(public_key))
verify_key.verify(canonical_bytes, b64url_decode(signature))
return True
except (CryptoError, TypeError, ValueError, KeyError, OverflowError):
return False
ಈ ಕಾರ್ಯವು ಒಂದು ರಸೀದಿಯನ್ನು ಮತ್ತು ಅವಲಂಬಿಸುವ ಪಕ್ಷದ ಪಿನ್ ಮಾಡಲಾದ ಕೀ ಸೆಟ್ ಅನ್ನು ತೆಗೆದು ಮತ್ತು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
True ಮಾತ್ರ ಸಹಿ ಸ್ವೀಕೃತ ಕೀ ಅಡಿಯಲ್ಲಿ ಮಾನ್ಯವಾಗಿದ್ದರೆ. ಪರಿಶೀಲನೆಗೆ ಯಾವುದೇ
നെಟ್ವರ್ಕ್ ಕರೆ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಕೀ ಮೇಲಿನ ನಂಬಿಕೆ ಇನ್ನೂ ಬಾಹ್ಯ ಸಂರಚನಾ ನಿರ್ಧಾರವಾಗಿದೆ.
ತತ್ತರಿಸುವಿಕೆ ಪತ್ತೆಚೆಗೆ ನೋಟ್ಬುಕ್ನಲ್ಲಿ ಇವುಗಳು ನಡೆಯುತ್ತವೆ:
tool_args_hash ಕ್ಷೇತ್ರದ ಒಂದೊಂದು ಬೈಟ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು.ಇದು ರಸೀದಿಗಳು ತತ್ತರಿಸುವಿಕೆ-ಸೂಚಿತವಾಗಿದ್ದಾರೆಯೆಂದು ವೈಯಕ್ತಿಕವಾಗಿ ಪ್ರದರ್ಶಿಸುವುದು: ಯಾವುದೇ ಬದಲಾವಣೆ ಸಹಿ ಮುರಿಯುತ್ತದೆ.
ಒಂದು ಸಹಿ ಮಾಡಿದ ರಸೀದಿ ಒಂದು ಕ್ರಿಯೆಯನ್ನು ರಕ್ಷಿಸುತ್ತದೆ. ರಸೀದಿಗಳ ಸರಪಳಿ ಕ್ರಮವನ್ನು ರಕ್ಷಿಸುತ್ತದೆ.
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ನ ಸಹಿಯನ್ನು ಮುರಿಯುತ್ತದೆ), ಅಥವಾಗೌಪ್ಯ ಕೀ ರಕ್ಷಿತವಾಗಿದ್ದರೆ ಮತ್ತು ಪರಿಶೀಲಕನು ಸ್ವತಂತ್ರವಾಗಿ ಸಾಕ್ಷ್ಯ ಹೊಂದಿರುವ ಸರಣಿಯ ತುದಿಯನ್ನು ಲಗತ್ತಿಸಿದರೆ, ಈ ದಾಳಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಬಹುದು. ಪ್ರತಿ ರಸೀದಿಯ ಒಳಗೆ ಕಿಯನ್ನು ಪ್ರಕಟಿಸುವುದು ಸಾಕಾಗುವುದಿಲ್ಲ: ಸಹಿ ಮಾಡುವವನು ಅಥವಾ ದಾಳಿ ನಡೆಸುವವನು ಬೇರೆ ಕೀಯನ್ನು ನೀಡಬಹುದು, ಉಪಸರಣಿಯನ್ನು ಮರುಬರೆದಬಹುದು, ಅಥವಾ ಸರಣಿಯನ್ನು ಕಡಿತಗೊಳಿಸಬಹುದು, ಅವಲಂಬಿಸುವ ಪಕ್ಷಕ್ಕೆ ಬಾಹ್ಯ ನಂಬಿಕೆ ಮತ್ತು ಪೂರ್ಣತೆಯ ಆಂಕರ್ ಇಲ್ಲದಿದ್ದರೆ.
ನೋಟ್ಬುಕ್ ಮುಂದುವರಿದಿದೆ:
previous_receipt_hash ಹಿಂದಿನ ರಸೀದಿಯ ನಿಜವಾದ ಹ್ಯಾಶ್ಗೂ ಹೊಂದಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು.ಇದು ನೀವು ಆಡಿಟ್ ಟ್ರೇಲ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವಿರಿ ಎಂಬುದು, ಹೊರಗಿನ ಪರಿಶೋಧಕವು ತನ್ನ ಅಡಿಯಲ್ಲಿ ಸ್ವಂತ ನಿಗದಿಪಡಿಸಿದ ಜಾರಿ ಮಾಡುವವರ ಕೀಲಿಗಳು ಮತ್ತು ಸರಪಳಿ ಚೆಕ್ಪಾಯಿಂಟ್ಗಳು, ನಿಮ್ಮ ಬದಲಾಯಿಸಬಹುದಾದ ಲಾಗ್ ಸಂಗ್ರಹವನ್ನು ನಂಬದೆ.
ಈ ಪಾಠದ ಅತ್ಯಂತ ಮುಖ್ಯ ವಿಭಾಗ. ರಸೀದಿಗಳು ಶಕ್ತಿಶಾಲಿ ಆದರೆ ಆ ಶಕ್ತಿ ಮಿತವಾಗಿದೆ.
ರಸೀದಿಗಳು ಮೂರು ವಿಷಯಗಳನ್ನು ಸಾಬೀತು ಮಾಡುತ್ತವೆ:
ರಸೀದಿಗಳು ಸಾಬೀತು ಮಾಡದೆ ಇರುತ್ತವೆ:
policy_id ನಲ್ಲಿ ಸೂಚಿಸಲ್ಪಟ್ಟ ನಿಯತಿಯನ್ನು ಸತ್ಯವಾಗಿಯೇ ಮೌಲ್ಯಾಂಕನ ಮಾಡಲಾಯಿತು ಅಥವಾ ಯಾವುದಾದರೂ ಕ್ರಿಯೆಯನ್ನು ಅನುಮತಿಸಿತೇ ಎಂಬುದನ್ನು. ರಸೀದಿ ಹೇಳುವುದು ಪ್ರವೇಶ ವಾದವು, ಅಳವಡಿಸಿಕೊಂಡಿಲ್ಲ.ಈ ಅಗ್ಗುಲು ಎರಡು ಕಾರಣಗಳಿಂದ ಮುಖ್ಯ:
ಸಾಮಾನ್ಯ ತಪ್ಪು “ನಾವು ರಸೀದಿಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ” ಎಂದರೆ “ನಾವು ಆಡಳಿತাধীন” ಎಂದು ಭಾವಿಸುವುದು. ಅಲ್ಲ. ರಸೀದಿಗಳು അടിസ്ഥാനಚೌಕಟ್ಟು. ಆಡಳಿತ ವ್ಯವಸ್ಥೆಯು ನೀವು ನಿರ್ಮಿಸುವ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ.
ಮೇಲಿನ ಐಟಂ 3 ತನ್ನದೇ ವಿಭಾಗಕ್ಕೆ ಯೋಗ್ಯವಾಗಿದೆ: ಕ್ರಿಯೆಯ ರಶೀದಿ “ಈ ಕೀ ಈ ವಿಷಯವನ್ನು ಸಹಿ ಮಾಡಿದೆ,” ಎಂದಿಗೂ “ಮಾನವನು ಇದಕ್ಕೆ ಅನುಮೋದನೆ ನೀಡಿದನು.” ಎಂದು ಹೇಳುವುದಿಲ್ಲ. ಉನ್ನತ-ಅಪಾಯ ಕ್ರಿಯೆಗಳಿಗೆ (ಹಣ ಮರಳಿಸುವಿಕೆಗಳು, ಅಳಿಕೆಗಳು, ವೈರ್ ವರ್ಗಾವಣೆಗಳು), ಪ್ರತ್ಯೇಕ ಅನುಮೋದಕನ ಸಹಿ ನಿಖರ ಕ್ರಿಯೆಯನ್ನು ಬದ್ಧಗೊಳಿಸಬಹುದು. ಆ ಕೀಲಿಯನ್ನು ಮಾನವನೊಂದಿಗೆ ಕೊಂಡಿಡುವುದು ಮತ್ತು ಮಾನವ ಹಾಜರಾತಿಯನ್ನು ಪರಿಶೀಲಿಸುವುದು ಪ್ರತ್ಯೇಕ ಜವಾಬ್ದಾರಿಗಳಾಗಿಯೇ ಉಳಿಯುತ್ತವೆ.
ಮುಂದುವರಿದ ನೋಟ್ಬುಕ್ code_samples/human-authorization-receipts.ipynb ಪಾಠದ ರಸೀದಿಗಳೇ ಆಗಿರುವ ಅದೇ ಎನ್ವಲಪ್ ಆಕಾರದಲ್ಲಿ ಎರಡನೇ ರಸೀದಿ ವಿಧವಾದ human.approval.v1 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ (ಕ್ಯಾನೋನಿಕಲ್ JCS ಬೈಟ್ಗಳ ಮೇಲಿನ Ed25519 ಸಹಿ ಮಾಡಲಾದ ಟೈಪ್ಡ್ ಪೇಲೋಡ್, ಜೊತೆಗೆ 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) ಪ್ಯಾಕೇಜುಗಳು ನೋಡ್ ಆಧಾರಿತ ರಸೀದಿ ಸಹಿ ಮತ್ತು ಆಫ್ಲೈನ್ ಪರಿಶೀಲನೆ ಕಾರ್ಯಾನುಷ್ಠಾನವನ್ನು ಒದಗಿಸುತ್ತವೆ, ಎಲ್ಲ MCP ಸರ್ವರ್ಗಳನ್ನು ತತ್ತರಸೂಚಕ ಆಡಿಯಟ್ ಟ್ರೇಲ್ನೊಂದಿಗೆ ಸಾಧಿಸಲು, ರದ್ದು ಮಾಡಿ ಕಾಯ್ದಿರಿಸುವ ಕಾರ್ಯದಲ್ಲಿ ವೀಕ್ಷಣೆ ಅನುಮೋದನಾ ರಸೀದಿಯನ್ನು ಹೊರಡಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಒಳಗೊಂಡಿದೆ (ಡೆಸ್ಕ್ಟಾಪ್ ಹರಿವುಗಳಲ್ಲಿ ವೆಬ್ ಆಥ್ನ್ ಬೆಂಬಲಿತ), ಮೇಲಿನ ಮಾನವ-ಅನುಮೋದನೆ ನೋಟ್ಬುಕ್ನಂತೆ.pip install nobulex) Ed25519 + JCS ಸಹಿ ಮಾದರಿಯನ್ನು ಪೈಥಾನ್ನಲ್ಲಿ LangChain ಮತ್ತು CrewAI ಸಂಯೋಜನೆಗಳೊಂದಿಗೆ ಒದಗಿಸುತ್ತದೆ, ಪ್ರಕಟಿತ ಪರಸ್ಪರ-ಪರಿಶೀಲನೆ ಪರೀಕ್ಷಾ ಕಿಕ್ಕುಗಳು ಮತ್ತು OWASP PR #2210 ಮೂಲಕ ಕೊಡುಗೆ ಹೊಂದಿದೆ.
- EMILIA ಪ್ರೋಟೋಕಾಲ್ ಪೂರಕ ನಿಖರ-ಕ್ರಿಯೆ ಜಾರಿಗೊಳಿಸುವ ಪದರವನ್ನು ಒದಗಿಸುತ್ತದೆ: ಆಫ್ಲೈನ್-ಪರಿಶೀಲಿಸಬಹುದಾದ ಅನುಮೋದನಾ ರಸೀದಿಗಳು, ನಿಗದಿಗೊಳಿಸಿದ WebAuthn ಅಥವಾ ಕ್ವೋರಮ್ ಪ್ರಾಧಿಕಾರ, ನಿರ್ವಾಹಕ ಗಡಿಯಲ್ಲಿನ ಒಮ್ಮೆ ಮಾತ್ರ ಬಳಕೆ, ಮತ್ತು ಸ್ಪಷ್ಟ ಅನಿಶ್ಚಿತ ಫಲಿತಾಂಶ ಮಾರ್ಗ. ಅದರ ಫ್ರೇಮ್ವರ್ಕ್ ಅಡಾಪ್ಟರ್ಗಳು ರಸೀದಿಯನ್ನು ಬಾಹ್ಯ ಪರಿಣಾಮ ಸಂಭವಿಸಿತೇ ಎಂಬುದನ್ನು ಸಾಬೀತುಪಡಿಸುವುದರ ಬದಲು ಅಗತ್ಯವಾದ ಸಾಕ್ಷ್ಯವಾಗಿ ಪರಿಗಣಿಸುತ್ತವೆ.ನಿಮ್ಮದೇ JWT ಗ್ರಂಥಾಲಯವನ್ನು ಬರೆಯುವುದು ಅಥವಾ ಪರೀಕ್ಷಿತ ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸದಿರುವುದರೊಳಗಿನ ಭೇದದಲ್ಲಿಯೇ, ನಿಮ್ಮದೇ ರಸೀದಿ ಗ್ರಂಥಾಲಯವನ್ನು ರಚಿಸುವ ಅಥವಾ ಬಳಸದಿರುವ ನಿರ್ಧಾರ. ಎರಡೂ ಸಮಂಜಸ; ಗ್ರಂಥಾಲಯ ಸಮಯ ಉಳಿಸುತ್ತದೆ ಮತ್ತು ಪರಿಶೀಲನೆ ಸೌಕರ್ಯ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ; ಆರಂಭದಿಂದ ಬರೆಸುವುದು ಪ್ರತಿಯೊಂದು ಮೂಲಭೂತವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕೈಪಿಡಿ. ಈ ಪಾಠ ಆರಂಭದಿಂದಲೂ ಮಾರ್ಗವನ್ನು ಕಲಿಸುವುದರಿಂದ ಯಾವುದೇ ಆಯ್ಕೆಗೆ ಮೂಲಸೌಕರ್ಯ ಸಿಗುತ್ತದೆ.
ಅಭ್ಯಾಸ ವ್ಯಾಯಾಮಕ್ಕೆ ಮುಂದುವರಿಯುವ ಮುನ್ನ ನಿಮ್ಮ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸಿ.
1. ರಸೀದಿಯನ್ನು ಏಜೆಂಟ್ ಖಾಸಗಿ Ed25519 ಕೀಲಿನೊಂದಿಗೆ ಸಹಿ ಮಾಡಲಾಗಿದೆ. ಆಡಿಯಟರ್ಗೆ ಸಾರ್ವಜನಿಕ ಕೀ ಮಾತ್ರ ಇದೆ. ಆಡಿಯಟರ್ ಆಫ್ಲೈನ್ನಲ್ಲಿ ರಸೀದಿಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದೇ?
2. ದಾಳಿ ಮಾಡುವವರು ರಸೀದಿ policy_id ಕ್ಷೇತ್ರವನ್ನು ಬದಲಾಯಿಸಿ ಅದেকেಗಿಂತ ಹೆಚ್ಚು ಅನುಮತಿಸುವ ನೀತಿಯಿಂದ ಸಂಚಾಲಿತವಂತೆ ಹೇಳುತ್ತಾರೆ. ಸಹಿ ಆ ಮೂಲ ಪೇಲೋಡ್ ಮೇಲೆ ಆಗಿತ್ತು. ಪರಿಶೀಲನೆ ಸಮಯದಲ್ಲಿ ಏನಾಗುತ್ತದೆ?
3. ರಸೀದಿ ಕಚ್ಚಾ ಆರ್ಗುಮೆಂಟ್ಗಳ ಮತ್ತು ಫಲಿತಾಂಶದ ಬದಲು tool_args_hash ಮತ್ತು result_hash ಅನ್ನು ಏಕೆ ಒಳಗೊಂಡಿದೆ?
4. previous_receipt_hash ಕ್ಷೇತ್ರವು ಪ್ರತಿ ರಸೀದಿಯನ್ನು ಅದರ ಪೂರ್ವ ಅವರೊಂದಿಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ. ದಾಳಿಕಾರನು ಸರಣಿಯ ಮಧ್ಯಭಾಗದಲ್ಲಿ ಒಂದು ರಸೀದಿ ಮೌನವಾಗಿ ಅಳಿಸಿದರೆ, ಯಾವುದು ಅಮಾನ್ಯವಾಗುತ್ತದೆ?
5. ರಸೀದಿ ಸ್ಪಷ್ಟವಾಗಿ ಪರಿಶೀಲನೆಗೊಂಡಿದೆ. ಇದು ಏಜೆಂಟ್ನ ಕ್ರಿಯೆ ಸರಿಯಾದುದು, ಧ್ವನಿಪೂರ್ಣ ಅಥವಾ ನೀತಿ ಅನುಕೂಲವಾಗಿದೆ ಎಂದು ಸಾಬೀತಾಗುತ್ತದೆಯೇ?
code_samples/18-signed-receipts.ipynb ಓದಿ ನಾಲ್ಕು ವಿಭಾಗಗಳನ್ನೂ ಪೂರ್ಣಗೊಳಿಸಿ:
ಸ್ಟ್ರೆಚ್ ಸವಾಲು 1: ಇಚ್ಛಿತ ಕ್ಷೇತ್ರ ಒಂದು ಹೆಚ್ಚಿಸಿ (ಉದಾಹರಣೆಗೆ ಟ್ರೇಸಿಂಗ್ಗಾಗಿ ವಿನಂತಿ ID), ಮಾನಕ ಸಹಿ ಲಾಜಿಕ್ ಅನ್ನು ಅದರಲ್ಲಿ ಸೇರಿಸಿ, ಮತ್ತು ರಸೀದಿ ಪರಿಶೀಲನೆಯ ಮೂಲಕ ಮತ್ತೆ ಸುತ್ತುಹೋಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿ. ನಂತರ ಸಹಿ ನಂತರ ಕ್ಷೇತ್ರವನ್ನು ಬದಲಿಸಿ ಮತ್ತು ಪರಿಶೀಲನೆ ವಿಫಲವಾಗುತ್ತದೆ ಎಂದು ದೃಢಪಡಿಸಿ. ಇದು ಮಾನಕ ಎನ್ಕೋಡಿಂಗ್ನ ಪ್ರತಿಯೊಂದು ಬೈಟ್ ಸಹಿಗೆ ಹೇಗೆ ಕೊಡುಗೆ ನೀಡುತ್ತದೆ ಎಂದು ತಿಳಿಯಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಸ್ಟ್ರೆಚ್ ಸವಾಲು 2: ನಿಮ್ಮ երկու ರಸೀದಿಗಳನ್ನು SHA-256 ಹ್ಯಾಷ್ ಮಾಡಿ (ಮೌಲ್ಯಮಾನ ನಿಯೋಜಿತ ಕ್ರಮದಲ್ಲಿ ಮಾನಕ ಬೈಟುಗಳನ್ನು Concatenate ಮಾಡಿ) ಮತ್ತು ಹಿನ್ನೀಲಿ ಒಂದು ಮೂರನೇ ರಸೀದಿಯಲ್ಲಿ ಹೊಸ ಕ್ಷೇತ್ರವಾಗಿ ಹೇರಿಸಿ. ಎಲ್ಲಾ ಮೂರು ರಸೀದಿಗಳು ಇನ್ನೂ ಸುತ್ತುಹೋಗುತ್ತವೆ ಎಂದು ಪರಿಶೀಲಿಸಿ. ನೀವು ಇತ್ತೀಚೆಗೆ ಒಂದು ಹಂತದ ಒಳಗೊಂಡಿರುವುದು ಸಾಬೀತು ಮಾಡುವುದನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ: ಮೂರನೇ ರಸೀದಿ ಹೊಂದಿರುವೆವರು ಮೊದಲ ಎರಡು ಸಹಿ ಆಗಿದ್ದಾಗ ಇದ್ದವು ಎಂದು ಸಾಬೀತು ಮಾಡುವುವು, ವಿಷಯಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸದೆ. ಇದು ಆಯ್ಕೆಮಾಡಿದ ಬಹಿರಂಗ ಪಟ್ಟಿ ರಸೀದಿಗಳು ವ್ಯಾಪಕವಾಗಿ ಬಳಸುವ ಮಾದರಿ (Merkle ಬದ್ಧತೆಗಳು, RFC 6962).
ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ರಸೀದಿಗಳು AI ಏಜೆಂಟ್ಗಳಿಗೆ ಈ ರೀತಿಯ ಪರಿಶೀಲನಾ ಹಾದಿಯನ್ನು ನೀಡುತ್ತವೆ:
ಅವುಗಳು ಇನ್ಪುಟ್ ಮಾನ್ಯತೆ, ನೀತಿ ಅನುಷ್ಠಾನ, ಕಾರ್ಯನಿರ್ವಾಹಕರ ಪ್ರವೇಶಕ್ಕೆ ಪರ್ಯಾಯವಲ್ಲ, ಫಲಿತಾಂಶದ ಸಾಬೀತುಗಳು, ಸಂಪೂರ್ಣತೆ ನಿಯಂತ್ರಣೆಗಳು, ಅಥವಾ ಗುರುತಿನ ಮೂಲಸೌಕರ್ಯ. ಅವುಗಳು ಆಧಾರವಾಗಿವೆ ಆ ಪದರಗಳಿಗಾಗಿ. ನಿಯಂತ್ರಿತ ಅಥವಾ ಬಹು-ಸಂಸ್ಥಾ ಕಾರ್ಯಪ್ರವಾಹಗಳಲ್ಲಿ, ರಸೀದಿಗಳು ನಿರ್ದಿಷ್ಟ ಇಶ್ಯೂಯರ್ ಹೇಳಿಕೆಗಳನ್ನು ಆಡಿಟರ್ನ ಸ್ವಂತ ನಂಬಿಕೆಯ ಸಂರಚನೆಯಡಿ ಸ್ವತಂತ್ರವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದಾಗಿಸುತ್ತವೆ.
ಅತ್ಯಂತ ಪ್ರಮುಖ ಉಪಸಂಹಾರ: ರಸೀದುಗಳು ಸಾಬೀತುಪಡಿಸುತ್ತವೆ ಎಂದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಕೀ ಒಂದು ನಿರ್ದಿಷ್ಟ ವಿಷಯವನ್ನು. ಒಟ್ಟಿಗೆ ಸಾಗಿಸಲಾದ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪ್ರತ್ಯೇಕವಾಗಿ ಸಮಯದ ಮೂಲಕ ದೃಢೀಕರಿಸದಿದ್ದರೆ ಸಹಿ ಮಾಡುವವರ ಘೋಷಣೆಯಾಗಿದೆ. ಒಂದು ರಸೀದು ಅದರ ವಿಷಯವು ಸತ್ಯವೆಂದು, ಯಾವುದೇ ಕ್ರಮವು ಕಾರ್ಯಗತವಾಯಿತು ಎಂದು, ಅಥವಾ ಆ ದಾಖಲೆಗಳ ಸೆಟ್ ಸಂಪೂರ್ಣವಾಗಿದೆ ಎಂಬುದನ್ನು ಸಾಬೀತುಪಡಿಸುವುದಿಲ್ಲ. ಆ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಹಿಡಿದುಕೊಳ್ಳಿ.
ನೀವು ಈ ಪಾಠವನ್ನು ಮುಗಿಸಿ ತಾಂತ್ರಿಕ ವಾಸ್ತವಿಕ ಪರಿಸರದಲ್ಲಿ ರಸೀದಿ-ಸಹಿತ ಏಜೆಂಟ್ ಗಳನ್ನು ನಿಯೋಜಿಸಲು ಸಿದ್ಧರಾಗಿರುವಾಗ:
Microsoft Foundry Discord ನಲ್ಲಿ ಸೇರಿ, ಇತರ ಕಲಿಯುವವರನ್ನು ಭೇಟಿ ಮಾಡಿ, ಕಾರ್ಯಾಲಯ ಸಮಯಗಳಲ್ಲಿ ಭಾಗವಹಿಸಿ ಮತ್ತು ನಿಮ್ಮ AI ಏಜೆಂಟ್ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಗಳನ್ನು ಪಡೆಯಿರಿ.
ಈ ಪಾಠವು ಒಬ್ಬೊಬ್ಬ ರಸೀದಿ ಸಹಿ ಮತ್ತು ಹ್ಯಾಶ್ ಸರಣಿಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಇದೇ ಮೂಲಭೂತಗಳು ನೀವು ಮುಂದುವರೆದ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗೆ ಬರುತ್ತಿರುವಾಗ ಹಲವುಂತೆ ಉತ್ತುಂಗ ಮಾದರಿಗಳಲ್ಲಿ ನಾಡಿ ಬೀಳಬಹುದು:
authorization_*) ಮತ್ತು ನಂತರ-ನಿರ್ವಹಣೆ (result_*) ಭಾಗಗಳಲ್ಲಿ ವಿಭಜಿಸಿ ಸ್ವತಂತ್ರ ಸಹಿಗಳೊಂದಿಗೆ ಬಳಸುತ್ತವೆ, ಅಥಾರೈಸೇಶನ್ ನಿರ್ಧಾರ ಮತ್ತು ಕಂಡುಬಂದ ಫಲಿತಾಂಶ ವಿಭಿನ್ನ ಪಾತ್ರದವರು ಅಥವಾ ಸಮಯದಲ್ಲಿ ಸೃಷ್ಟಿಸಿದಾಗ ಉಪಯುಕ್ತ. ಇದು ಈ ಪಾಠದಲ್ಲಿ ಕಲಿಸುವ ರಸೀದಿ ರೂಪರೇಖೆಯ ಮೇಲೆ ಸೇರಿಸಲಾಗುತ್ತದೆ.result_hash ಒಳಗೊಂಡ ಯಾವುದೇ ಬೈಟುಗಳನ್ನು ರಸೀದಿ ಮೊಟ್ಟುಮುದ್ರಣ ಮಾಡುತ್ತದೆ. ವಾಸ್ತವಿಕ ಪೇಲೋಡ್ಗಳು ಹಲವು ಆಯ್ಕೆ-ಅನುಕೂಲನೆಗಳ ಹಾಗೂ ಪೂರ್ವ-ನಿರ್ಧಾರ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ಸಮೃದ್ಧವಾಗಿರಬಹುದು: ಮೊದಲನೆಯ ಆಗಾಗ ಮತ್ತು ಅದರ ಪೂರ್ಣತೆ, ಅಪಾಯ ಸ್ಥಿತಿ, ಹೊಣೆಗಾರಿಕೆ ಸರಣಿ, ಗೇಟ್ ಫಲಿತಾಂಶ ಇत्यಾದಿ. ಇದರಿಂದ ರಸೀದಿ ಸ್ವರೂಪವನ್ನು ಕನಿಷ್ಠವಾಗಿಟ್ಟುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಪೇಲೋಡ್ ವ್ಯಾಕ್ಯಸಗಳು ಕ್ಷೇತ್ರ-ಪ್ರಕಾರವಾಗಿ ಬೆಳೆಯಬಹುದು.alg ಲೇಬಲ್ ಮಾತ್ರವೇ ಸ್ಥಳಾಂತರವಲ್ಲ: ಒಂದು ಪ್ರೊಫೈಲ್ ML-DSA ಕೀ ಎನ್ಕೋಡಿಂಗ್, ಕ್ಯಾನೋನಿಕಲ್ ಸಹಿ ಮಾಡಲಾದ ಬೈಟ್ಸ್, ಪರಿಶೀಲನೆ, ಆಧಾರಿತ ಪಕ್ಷದ ನೀತಿ, ಡೌನ್ಗ್ರೇಡ್ ಪ್ರತಿರೋಧಕತೆ ಮತ್ತು ಪರಿವರ್ತನೆಯ ಅರ್ಥಶಾಸ್ತ್ರವನ್ನು ನಿರ್ಧರಿಸಬೇಕು. ಅನುಕೂಲತೆ ಸಂಬಂಧಿ ದಾವೆಗಳನ್ನು ಮಾಡುವ ಮೊದಲು ಹಂಚಿಕೊಂಡಿರುವ ವೆಕ್ಟರ್ಗಳ ವಿರುದ್ಧ ದ್ವಿ-ಸಹಿ ಪರಿವರ್ತನೆಯನ್ನು ಯೋಜಿಸಿ ಮತ್ತು ಪರೀಕ್ಷಿಸಿ.ಸ್ಥಳೀಯ AI ಏಜೆಂಟ್ಗಳನ್ನು ಸೃಷ್ಟಿಸಲಾಗುತ್ತಿದೆ
ಅಸ್ವೀಕಾರ: ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸಡ್ಡೆಗಳು ಇರಬಹುದು. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜು ಪ್ರಾಮಾಣಿಕ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸುವ ಮೂಲಕ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಗಳ ಅಥವಾ ತಪ್ಪು ವ್ಯಾಖ್ಯಾನಗಳ ಬಗ್ಗೆ ನಾವು ಹೊಣೆಗಾರರಲ್ಲ.