Skip to main content

qualia_core_db/net/qdnf/crypto/handshake/
identity.rs

1//! UKS, identity misbinding, and X25519 reflection checks.
2
3use crate::crypto::network::digest::sha384;
4use crate::crypto::network::errors::CryptoError;
5use crate::crypto::network::transcript::Transcript;
6use crate::net::qdnf::types::StrongDigest;
7
8/// Reject a peer X25519 public that equals the local public (reflection).
9pub 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
17/// SHA-384(`initiator || responder`). Zero or equal identities are Unauthorized.
18pub 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
45/// Transcript must already contain both identity digests as 48-byte windows.
46pub 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
61/// Fail closed on zero identities, equal roles, or missing transcript binding.
62pub 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
71/// Unknown-key-share: claimed peer must match the transcript-bound peer.
72pub 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}