SUDP — Secret-Use Delegation Protocol

Utilisation de secrets au niveau du protocole pour les systèmes agentiques.

Implémentation de référence de arXiv:2604.24920 — voir Citer cet article.

sudp permet à un Requester (R) autonome de proposer une opération adossée à un secret, à un Authorizer (A) d'autoriser exactement cette opération, et à un Custodian (T) de l'exécuter. L'unité de délégation est un usage, et non le secret.

                  ┌─────────────────────────┐
                  │  Authorizer  A          │
                  │  (passkey on a device)  │
                  └────────────┬────────────┘
                               │  signs β over (DS ‖ r ‖ H(o))
                               ▼
   ┌──────────────┐      ┌───────────────┐       ┌──────────────┐
   │ Requester R  │ ─o─▶ │  Custodian T  │ ─s─▶  │ Environment  │
   │   (agent)    │      │               │       │      E       │
   │              │◀ρ────│ holds sealed Σ│       │              │
   └──────────────┘      └───────────────┘       └──────────────┘

R ne voit jamais s et n'obtient aucune autorité réutilisable sur celui-ci — même si R est entièrement compromis (injection de prompt, shim d'exécution, etc.).

Citer cet article

@misc{yu2026sudp,
  title         = {SUDP: Secret-Use Delegation Protocol for Agentic Systems},
  author        = {Xiaohang Yu and Hejia Geng and Xinmeng Zeng and William Knottenbelt},
  year          = {2026},
  eprint        = {2604.24920},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CR},
  url           = {https://arxiv.org/abs/2604.24920}
}

Xiaohang Yu, Hejia Geng, Xinmeng Zeng et William Knottenbelt. « SUDP: Secret-Use Delegation Protocol for Agentic Systems. » Prépublication arXiv arXiv:2604.24920 (2026).

Paquets

Rôle	Source	Publié sous
Custodian (T)	`custodian/rust`	`sudp` sur crates.io
Authorizer (A)	`authorizer/ts`	`@sudp-protocol/authorizer` sur npm
Requester (R)	`requester/ts`	`@sudp-protocol/requester` sur npm

Essayez-le

Prérequis : Rust 1.85+ (via rustup) et Node.js 20+.

git clone https://github.com/xhyumiracle/sudp
cd sudp/examples/protocol-demo
./run.sh

Construit les trois paquets, lance le Custodian, exécute R + A dans un script Node, affiche chaque interaction sur le fil avec un code couleur par rôle, et termine par une vérification adversariale (R falsifie o après que A a signé → T rejette).

Pour une utilisation au niveau de l'API : custodian/rust · authorizer/ts · requester/ts.

Construire un agent

Les auteurs d'agents n'ont généralement besoin que de @sudp-protocol/requester — des constructeurs Operation typés et des validateurs de forme, sans transport, sans adaptateurs de framework. Le Requester est la couche la plus remplaçable ; chaque framework d'agent câble sa propre glue.

Alignement inter-langages

Les vecteurs de conformité verrouillent les octets de l'Authorizer par rapport au Custodian au niveau de l'octet — les formes composites restent alignées par construction.

Surface	Ancre Rust	Ancre TS
`canonical(o)`	tests unitaires `Operation::canonical_bytes`	`conformance.test.ts: canonical: nested ordering`
`β` + `DS_BIND`	`beta_matches_ts_authorizer_conformance_vector`	`conformance.test.ts: β: matches Rust...`
`β` par lot (`H(canonical(ops))`)	`batch_beta_matches_ts_authorizer_conformance_vector`	`conformance.test.ts: batch β: matches Rust...`
`derive_wrapping_key`	`derive_wrapping_key_matches_ts_authorizer_conformance_vector`	`conformance.test.ts: deriveWrappingKey: matches Rust...`
chiffrement AEAD (nonce fixe)	`aead_matches_ts_authorizer_conformance_vector`	`conformance.test.ts: aeadEncrypt: matches Rust...`
disposition `wrap_ad`	tests `WrapBinding::to_canonical_ad`	`conformance.test.ts: wrap_ad: DS_WRAP ‖ cid ‖ ver_be`
disposition `seal_ad`	`phases::setup::seal_ad` (tests de setup)	`conformance.test.ts: seal_ad: DS_SEAL ‖ ver_be`
sceau par enregistrement (`record_aad` / `K_aead` / cadrage scellé)	`state::record::tests::conformance_*`	`conformance.test.ts: per-record conformance vectors`
`WRAP_VERSION` ↔ `CURRENT_VERSION`	`state::CURRENT_VERSION = 1`	`conformance.test.ts: WRAP_VERSION matches Rust...`

La CI exécute les deux moitiés à chaque push :

cd custodian/rust && cargo test
cd authorizer/ts  && npm test
cd requester/ts   && npm test

Pré-1.0

Le format de transmission et la forme des traits peuvent encore évoluer avant la 1.0. Épinglez les versions mineures en production :

# Cargo.toml
sudp = "~0.1"

// package.json
"@sudp-protocol/authorizer": "~0.1.0",
"@sudp-protocol/requester":  "~0.1.0"

Sécurité

Voir SECURITY.md.

Licence

Apache-2.0. Voir LICENSE.

sudp

Populaires