1use anyhow::{anyhow, Result};
22
23use hyprstream_rpc::crypto::pq::ml_dsa_vk_from_bytes;
24use hyprstream_rpc::identity_resolver::{At9pCapsuleResolver, VerifiedAt9pKeys};
25
26use crate::at9p::ED25519_PUBLIC_KEY_LEN;
27use crate::at9p_gate::verify_did_at9p;
28
29#[derive(Default)]
37pub struct At9pGateResolver;
38
39impl At9pGateResolver {
40 pub fn new() -> Self {
42 Self
43 }
44}
45
46impl At9pCapsuleResolver for At9pGateResolver {
47 fn verify_bytes(&self, did: &str, capsule_bytes: &[u8]) -> Result<VerifiedAt9pKeys> {
48 let verified = verify_did_at9p(did, capsule_bytes)
52 .map_err(|e| anyhow!("did:at9p {did} GATE rejected: {e}"))?;
53 let capsule = verified.capsule();
54
55 let keys = capsule
63 .body
64 .subject_keys
65 .iter()
66 .map(|subject| {
67 let ed25519: [u8; 32] =
68 subject.ed25519_pub.as_slice().try_into().map_err(|_| {
69 anyhow!("ed25519 subject key is not {ED25519_PUBLIC_KEY_LEN} bytes")
70 })?;
71 let ml_dsa_65 = ml_dsa_vk_from_bytes(&subject.mldsa65_pub)?;
72 Ok(VerifiedAt9pKeys::key(ed25519, ml_dsa_65))
73 })
74 .collect::<Result<Vec<_>>>()?;
75
76 VerifiedAt9pKeys::new_gate_verified_set(keys)
77 }
78
79 fn resolve(&self, did: &str) -> Result<VerifiedAt9pKeys> {
80 Err(anyhow!(
84 "did:at9p {did}: mainline locator fetch is not wired (#890) — resolve fails closed"
85 ))
86 }
87}
88
89#[cfg(test)]
90#[allow(
91 clippy::unwrap_used,
92 clippy::expect_used,
93 clippy::panic,
94 clippy::indexing_slicing
95)]
96mod tests {
97 use super::*;
98 use crate::at9p::{
99 Capsule, CapsuleBody, HybridKeyPair, ServiceEndpoint, ServiceEntry, ServiceType, Transport,
100 ED25519_SIGNATURE_LEN,
101 };
102 use crate::at9p_gate::DID_AT9P_PREFIX;
103 use crate::at9p_sign::sign_capsule;
104
105 use ed25519_dalek::SigningKey;
106 use hyprstream_crypto::pq::{ml_dsa_generate_keypair, ml_dsa_vk_bytes, MlDsaSigningKey};
107 use hyprstream_rpc::admission::{
108 admit_key_against_did, AdmissionTrustSurface, At9pAdmission, VerifiedApplicationSigner,
109 };
110 use hyprstream_rpc::envelope::{KeyedPqTrustStore, PqTrustStore};
111
112 use anyhow::Result as AnyResult;
113 use async_trait::async_trait;
114 use serde_json::Value;
115
116 struct Signer {
117 ed_sk: SigningKey,
118 pq_sk: MlDsaSigningKey,
119 keypair: HybridKeyPair,
120 }
121
122 fn signer(tag: u8) -> Signer {
123 let mut seed = [0u8; 32];
124 seed[0] = tag;
125 seed[31] = tag.wrapping_add(7);
126 let ed_sk = SigningKey::from_bytes(&seed);
127 let (pq_sk, pq_vk) = ml_dsa_generate_keypair();
128 let keypair = HybridKeyPair::new(
129 ed_sk.verifying_key().to_bytes().to_vec(),
130 ml_dsa_vk_bytes(&pq_vk),
131 )
132 .unwrap();
133 Signer {
134 ed_sk,
135 pq_sk,
136 keypair,
137 }
138 }
139
140 fn body_for(s: &Signer, tag: u8) -> CapsuleBody {
141 let endpoint = ServiceEndpoint::new(Transport::Iroh, format!("iroh://node{tag}")).unwrap();
142 let service = ServiceEntry::new("#ns", ServiceType::NinePExport, endpoint).unwrap();
143 CapsuleBody::new(vec![s.keypair.clone()], vec![service]).unwrap()
144 }
145
146 fn signed(tag: u8) -> (Capsule, Vec<u8>, String) {
148 let s = signer(tag);
149 let body = body_for(&s, tag);
150 let capsule = sign_capsule(body, &s.ed_sk, &s.pq_sk).unwrap();
151 let bytes = capsule.to_dag_cbor().unwrap();
152 let did = format!("{DID_AT9P_PREFIX}{}", capsule.cid512().unwrap());
153 (capsule, bytes, did)
154 }
155
156 struct NeverResolve;
158 #[async_trait]
159 impl hyprstream_rpc::admission::DidDocResolve for NeverResolve {
160 async fn resolve_doc(&self, did: &str) -> AnyResult<Value> {
161 panic!("did:at9p admission must not resolve a DID document (called for {did})");
162 }
163 }
164
165 #[test]
166 fn gate_resolver_returns_verified_subject_keys() {
167 let (capsule, bytes, did) = signed(1);
168 let primary = capsule.body.subject_keys[0].clone();
169 let verified = At9pGateResolver::new()
170 .verify_bytes(&did, &bytes)
171 .expect("GATE passes");
172 let ed_arr: [u8; 32] = primary.ed25519_pub.as_slice().try_into().unwrap();
173 let selected = verified
174 .for_ed25519(&ed_arr)
175 .expect("published subject key selectable by its Ed25519 identity");
176 assert_eq!(selected.ed25519().as_slice(), primary.ed25519_pub);
177 assert_eq!(ml_dsa_vk_bytes(selected.ml_dsa_65()), primary.mldsa65_pub);
178 }
179
180 #[test]
181 fn gate_resolver_rejects_bad_signature() {
182 let (mut capsule, _bytes, _did) = signed(2);
186 capsule.signatures.ed25519_signature = vec![0u8; ED25519_SIGNATURE_LEN];
187 let bytes = capsule.to_dag_cbor().unwrap();
188 let cid = Capsule::from_dag_cbor(&bytes).unwrap().cid512().unwrap();
189 let did = format!("{DID_AT9P_PREFIX}{cid}");
190 assert!(At9pGateResolver::new().verify_bytes(&did, &bytes).is_err());
191 }
192
193 #[test]
194 fn gate_resolver_rejects_wrong_cid() {
195 let (_c1, bytes1, did1) = signed(3);
198 let did_other = signed(4).2;
199 assert_ne!(did1, did_other);
200 assert!(At9pGateResolver::new()
201 .verify_bytes(&did_other, &bytes1)
202 .is_err());
203 }
204
205 #[tokio::test]
206 async fn admission_binds_hybrid_keys_from_gate_verified_capsule() {
207 let (capsule, bytes, did) = signed(5);
212 let ed = capsule.body.subject_keys[0].ed25519_pub.clone();
213 let primary_pq = capsule.body.subject_keys[0].mldsa65_pub.clone();
214 let ed_arr: [u8; 32] = ed.as_slice().try_into().unwrap();
215
216 let gate = At9pGateResolver::new();
217 let mut store = KeyedPqTrustStore::new();
218 assert!(store.is_empty());
219
220 let admitted = admit_key_against_did(
221 &NeverResolve,
222 "https://peer.example",
223 VerifiedApplicationSigner::pq_hybrid(ed_arr),
224 AdmissionTrustSurface::Native,
225 &did,
226 None,
227 Some(At9pAdmission {
228 capsule_bytes: &bytes,
229 gate: &gate,
230 pq_store: &mut store,
231 }),
232 )
233 .await
234 .expect("verified capsule admits and binds");
235
236 assert_eq!(admitted.did.as_deref(), Some(did.as_str()));
237 assert_eq!(admitted.key, ed_arr);
238 assert_eq!(store.len(), 1);
239 let bound = store
240 .ml_dsa_key_for(&ed_arr)
241 .expect("hybrid binding installed");
242 assert_eq!(ml_dsa_vk_bytes(&bound), primary_pq);
243 }
244
245 #[tokio::test]
254 async fn admission_admits_second_published_subject_key_and_binds_its_pair() {
255 let s1 = signer(8);
257 let s2 = signer(9);
258 let endpoint = ServiceEndpoint::new(Transport::Iroh, "iroh://node8").unwrap();
259 let service = ServiceEntry::new("#ns", ServiceType::NinePExport, endpoint).unwrap();
260 let body =
262 CapsuleBody::new(vec![s1.keypair.clone(), s2.keypair.clone()], vec![service]).unwrap();
263 let capsule = sign_capsule(body, &s1.ed_sk, &s1.pq_sk).unwrap();
265 let bytes = capsule.to_dag_cbor().unwrap();
266 let did = format!("{DID_AT9P_PREFIX}{}", capsule.cid512().unwrap());
267
268 let ed2: [u8; 32] = s2.keypair.ed25519_pub.as_slice().try_into().unwrap();
270 let ed1: [u8; 32] = s1.keypair.ed25519_pub.as_slice().try_into().unwrap();
271 assert_ne!(ed1, ed2);
272
273 let gate = At9pGateResolver::new();
274 let mut store = KeyedPqTrustStore::new();
275 let admitted = admit_key_against_did(
276 &NeverResolve,
277 "https://peer.example",
278 VerifiedApplicationSigner::pq_hybrid(ed2),
279 AdmissionTrustSurface::Native,
280 &did,
281 None,
282 Some(At9pAdmission {
283 capsule_bytes: &bytes,
284 gate: &gate,
285 pq_store: &mut store,
286 }),
287 )
288 .await
289 .expect("a peer presenting the second published subject key must be admitted");
290 assert_eq!(admitted.key, ed2);
291
292 assert_eq!(store.len(), 1);
294 let bound = store
295 .ml_dsa_key_for(&ed2)
296 .expect("s2 hybrid binding installed");
297 assert_eq!(ml_dsa_vk_bytes(&bound), s2.keypair.mldsa65_pub);
298 assert!(store.ml_dsa_key_for(&ed1).is_none());
300 }
301
302 #[tokio::test]
305 async fn admission_rejects_signer_absent_from_subject_key_set() {
306 let s1 = signer(10);
307 let s2 = signer(11);
308 let outsider = signer(12);
309 let endpoint = ServiceEndpoint::new(Transport::Iroh, "iroh://node10").unwrap();
310 let service = ServiceEntry::new("#ns", ServiceType::NinePExport, endpoint).unwrap();
311 let body =
312 CapsuleBody::new(vec![s1.keypair.clone(), s2.keypair.clone()], vec![service]).unwrap();
313 let capsule = sign_capsule(body, &s1.ed_sk, &s1.pq_sk).unwrap();
314 let bytes = capsule.to_dag_cbor().unwrap();
315 let did = format!("{DID_AT9P_PREFIX}{}", capsule.cid512().unwrap());
316 let ed_out: [u8; 32] = outsider.keypair.ed25519_pub.as_slice().try_into().unwrap();
317
318 let gate = At9pGateResolver::new();
319 let mut store = KeyedPqTrustStore::new();
320 let res = admit_key_against_did(
321 &NeverResolve,
322 "https://peer.example",
323 VerifiedApplicationSigner::pq_hybrid(ed_out),
324 AdmissionTrustSurface::Native,
325 &did,
326 None,
327 Some(At9pAdmission {
328 capsule_bytes: &bytes,
329 gate: &gate,
330 pq_store: &mut store,
331 }),
332 )
333 .await;
334 assert!(res.is_err(), "a non-member signer must be rejected");
335 assert!(store.is_empty(), "a rejected peer must bind nothing");
336 }
337
338 #[tokio::test]
339 async fn admission_rejects_gate_failure_and_binds_nothing() {
340 let (mut capsule, _bytes, _did) = signed(6);
343 capsule.signatures.ed25519_signature = vec![0u8; ED25519_SIGNATURE_LEN];
344 let bytes = capsule.to_dag_cbor().unwrap();
345 let cid = Capsule::from_dag_cbor(&bytes).unwrap().cid512().unwrap();
346 let did = format!("{DID_AT9P_PREFIX}{cid}");
347 let ed: [u8; 32] = capsule.body.subject_keys[0]
348 .ed25519_pub
349 .as_slice()
350 .try_into()
351 .unwrap();
352
353 let gate = At9pGateResolver::new();
354 let mut store = KeyedPqTrustStore::new();
355 let res = admit_key_against_did(
356 &NeverResolve,
357 "https://peer.example",
358 VerifiedApplicationSigner::pq_hybrid(ed),
359 AdmissionTrustSurface::Native,
360 &did,
361 None,
362 Some(At9pAdmission {
363 capsule_bytes: &bytes,
364 gate: &gate,
365 pq_store: &mut store,
366 }),
367 )
368 .await;
369 assert!(res.is_err(), "GATE failure must reject");
370 assert!(store.is_empty(), "a rejected capsule must bind nothing");
371 }
372
373 #[test]
374 fn resolve_fails_closed_until_locator_wired() {
375 let (_c, _bytes, did) = signed(7);
378 assert!(At9pGateResolver::new().resolve(&did).is_err());
379 }
380}