qualia_core_db/net/qdnf/crypto/handshake/
identity.rs1use crate::crypto::network::digest::sha384;
4use crate::crypto::network::errors::CryptoError;
5use crate::crypto::network::transcript::Transcript;
6use crate::net::qdnf::types::StrongDigest;
7
8pub fn reject_reflected_share(local_pk: &[u8; 32], peer_pk: &[u8; 32]) -> Result<(), CryptoError> {
10 if local_pk == peer_pk {
11 Err(CryptoError::Unauthorized)
12 } else {
13 Ok(())
14 }
15}
16
17pub fn identity_binding(
19 initiator: &StrongDigest,
20 responder: &StrongDigest,
21) -> Result<StrongDigest, CryptoError> {
22 if initiator.is_zero() || responder.is_zero() || initiator == responder {
23 return Err(CryptoError::Unauthorized);
24 }
25 let mut concat = [0u8; 96];
26 concat[..48].copy_from_slice(&initiator.0);
27 concat[48..].copy_from_slice(&responder.0);
28 Ok(sha384(&concat))
29}
30
31fn contains_window(haystack: &[u8], needle: &[u8; 48]) -> bool {
32 if haystack.len() < 48 {
33 return false;
34 }
35 let mut i = 0usize;
36 while i + 48 <= haystack.len() {
37 if &haystack[i..i + 48] == needle.as_slice() {
38 return true;
39 }
40 i += 1;
41 }
42 false
43}
44
45pub fn require_identity_binding(
47 transcript: &Transcript,
48 initiator: &StrongDigest,
49 responder: &StrongDigest,
50) -> Result<(), CryptoError> {
51 if initiator.is_zero() || responder.is_zero() || initiator.0 == responder.0 {
52 return Err(CryptoError::Unauthorized);
53 }
54 let bytes = transcript.as_bytes();
55 if !contains_window(bytes, &initiator.0) || !contains_window(bytes, &responder.0) {
56 return Err(CryptoError::Unauthorized);
57 }
58 Ok(())
59}
60
61pub fn require_bound_identities(
63 transcript: &Transcript,
64 initiator: &StrongDigest,
65 responder: &StrongDigest,
66) -> Result<(), CryptoError> {
67 let _ = identity_binding(initiator, responder)?;
68 require_identity_binding(transcript, initiator, responder)
69}
70
71pub fn reject_unknown_key_share(
73 claimed_peer: StrongDigest,
74 transcript_bound_peer: StrongDigest,
75) -> Result<(), CryptoError> {
76 if claimed_peer.is_zero() || transcript_bound_peer.is_zero() {
77 return Err(CryptoError::Unauthorized);
78 }
79 if claimed_peer != transcript_bound_peer {
80 Err(CryptoError::Unauthorized)
81 } else {
82 Ok(())
83 }
84}
85
86#[cfg(test)]
87mod tests {
88 use super::*;
89 use crate::crypto::network::kem::MlKem768Secret;
90 use crate::net::qdnf::crypto::handshake::{initiator_share, responder_complete};
91
92 fn digest_fill(b: u8) -> StrongDigest {
93 StrongDigest([b; 48])
94 }
95
96 #[test]
97 fn reflected_x25519_publics_are_unauthorized() {
98 let pk = [0x11u8; 32];
99 assert_eq!(
100 reject_reflected_share(&pk, &pk),
101 Err(CryptoError::Unauthorized)
102 );
103 assert_eq!(reject_reflected_share(&[0x11u8; 32], &[0x22u8; 32]), Ok(()));
104
105 let (_sk, kem_pk) = MlKem768Secret::generate().unwrap();
106 let same = [11u8; 32];
107 let ishare = initiator_share(&same, &kem_pk).unwrap();
108 match responder_complete(&ishare, &same) {
109 Err(e) => assert_eq!(e, CryptoError::Unauthorized),
110 Ok(_) => panic!("reflected X25519 share was accepted"),
111 }
112 }
113
114 #[test]
115 fn swapped_identities_produce_different_binding_digests() {
116 let initiator = digest_fill(0xA1);
117 let responder = digest_fill(0xB2);
118 let fwd = identity_binding(&initiator, &responder).unwrap();
119 let rev = identity_binding(&responder, &initiator).unwrap();
120 assert_ne!(fwd, rev);
121 assert_eq!(
122 identity_binding(&StrongDigest::ZERO, &responder),
123 Err(CryptoError::Unauthorized)
124 );
125 assert_eq!(
126 identity_binding(&initiator, &initiator),
127 Err(CryptoError::Unauthorized)
128 );
129 }
130
131 #[test]
132 fn require_identity_binding_fails_if_transcript_lacks_initiator() {
133 let initiator = digest_fill(0x11);
134 let responder = digest_fill(0x22);
135 let mut missing = Transcript::new();
136 missing.append(b"responder", &responder.0).unwrap();
137 assert_eq!(
138 require_identity_binding(&missing, &initiator, &responder),
139 Err(CryptoError::Unauthorized)
140 );
141 assert_eq!(
142 require_bound_identities(&missing, &initiator, &responder),
143 Err(CryptoError::Unauthorized)
144 );
145
146 let mut bound = Transcript::new();
147 bound.append(b"initiator", &initiator.0).unwrap();
148 bound.append(b"responder", &responder.0).unwrap();
149 assert_eq!(
150 require_identity_binding(&bound, &initiator, &responder),
151 Ok(())
152 );
153 assert_eq!(
154 require_bound_identities(&bound, &initiator, &responder),
155 Ok(())
156 );
157 assert_eq!(
158 require_bound_identities(&bound, &StrongDigest::ZERO, &responder),
159 Err(CryptoError::Unauthorized)
160 );
161 }
162
163 #[test]
164 fn reject_unknown_key_share_mismatch_is_unauthorized() {
165 let claimed = digest_fill(0x31);
166 let bound = digest_fill(0x32);
167 assert_eq!(
168 reject_unknown_key_share(claimed, bound),
169 Err(CryptoError::Unauthorized)
170 );
171 assert_eq!(reject_unknown_key_share(claimed, claimed), Ok(()));
172 assert_eq!(
173 reject_unknown_key_share(StrongDigest::ZERO, claimed),
174 Err(CryptoError::Unauthorized)
175 );
176 }
177}