Skip to main content

qualia_core_db/net/qdnf/crypto/
schedule.rs

1//! Transcript-bound handshake key schedule (E02.1).
2
3#[cfg(not(target_arch = "wasm32"))]
4#[path = "schedule/endpoint.rs"]
5pub mod endpoint;
6
7use crate::crypto::network::errors::CryptoError;
8use crate::crypto::network::kdf::hkdf_sha384;
9use crate::crypto::network::transcript::Transcript;
10use crate::crypto::network::types::AEAD_KEY_LEN;
11use crate::net::qdnf::types::StrongDigest;
12use zeroize::Zeroize;
13
14pub const INFO_I2R: &[u8] = b"qpr-pq-1/qlink/i2r/transcript";
15pub const INFO_R2I: &[u8] = b"qpr-pq-1/qlink/r2i/transcript";
16
17#[repr(C)]
18#[derive(Clone, Copy)]
19pub struct HandshakeKeys {
20    pub initiator_to_responder: [u8; AEAD_KEY_LEN],
21    pub responder_to_initiator: [u8; AEAD_KEY_LEN],
22    pub transcript_digest: StrongDigest,
23}
24
25/// Derive directional keys. Transcript digest is the HKDF salt (binding).
26pub fn derive_handshake_keys(
27    ml_kem_ss: &[u8; 32],
28    x25519_ss: &[u8; 32],
29    transcript: &Transcript,
30) -> Result<HandshakeKeys, CryptoError> {
31    if ml_kem_ss.iter().all(|b| *b == 0) || x25519_ss.iter().all(|b| *b == 0) {
32        return Err(CryptoError::CryptoFailure);
33    }
34    let digest = transcript.digest();
35    let mut ikm = [0u8; 64];
36    ikm[..32].copy_from_slice(ml_kem_ss);
37    ikm[32..].copy_from_slice(x25519_ss);
38    let mut i2r = [0u8; AEAD_KEY_LEN];
39    let mut r2i = [0u8; AEAD_KEY_LEN];
40    let i2r_res = hkdf_sha384(Some(&digest.0), &ikm, INFO_I2R, &mut i2r);
41    let r2i_res = hkdf_sha384(Some(&digest.0), &ikm, INFO_R2I, &mut r2i);
42    ikm.zeroize();
43    i2r_res?;
44    r2i_res?;
45    if i2r == r2i || i2r == [0u8; AEAD_KEY_LEN] || r2i == [0u8; AEAD_KEY_LEN] {
46        i2r.zeroize();
47        r2i.zeroize();
48        return Err(CryptoError::CryptoFailure);
49    }
50    Ok(HandshakeKeys {
51        initiator_to_responder: i2r,
52        responder_to_initiator: r2i,
53        transcript_digest: digest,
54    })
55}
56
57pub const INFO_TRAFFIC_SEND: &[u8] = b"qpr-pq-1/traffic-update/send";
58pub const INFO_TRAFFIC_RECV: &[u8] = b"qpr-pq-1/traffic-update/recv";
59
60/// Derive the next traffic keys from the current pair. Not a hybrid recovery.
61pub fn derive_traffic_update(
62    send: &[u8; AEAD_KEY_LEN],
63    recv: &[u8; AEAD_KEY_LEN],
64    next_generation: u64,
65) -> Result<([u8; AEAD_KEY_LEN], [u8; AEAD_KEY_LEN]), CryptoError> {
66    if send == &[0u8; AEAD_KEY_LEN] || recv == &[0u8; AEAD_KEY_LEN] || send == recv {
67        return Err(CryptoError::CryptoFailure);
68    }
69    if next_generation == 0 {
70        return Err(CryptoError::Unauthorized);
71    }
72    let mut salt = [0u8; 8];
73    salt.copy_from_slice(&next_generation.to_be_bytes());
74    let mut ikm = [0u8; 64];
75    ikm[..32].copy_from_slice(send);
76    ikm[32..].copy_from_slice(recv);
77    let mut next_send = [0u8; AEAD_KEY_LEN];
78    let mut next_recv = [0u8; AEAD_KEY_LEN];
79    let send_res = hkdf_sha384(Some(&salt), &ikm, INFO_TRAFFIC_SEND, &mut next_send);
80    let recv_res = hkdf_sha384(Some(&salt), &ikm, INFO_TRAFFIC_RECV, &mut next_recv);
81    ikm.zeroize();
82    send_res?;
83    recv_res?;
84    if next_send == next_recv
85        || next_send == *send
86        || next_recv == *recv
87        || next_send == [0u8; AEAD_KEY_LEN]
88        || next_recv == [0u8; AEAD_KEY_LEN]
89    {
90        next_send.zeroize();
91        next_recv.zeroize();
92        return Err(CryptoError::CryptoFailure);
93    }
94    Ok((next_send, next_recv))
95}
96
97#[cfg(test)]
98mod tests {
99    use super::*;
100    use crate::crypto::network::transcript::Transcript;
101
102    #[test]
103    fn changed_transcript_changes_keys() {
104        let kem = [3u8; 32];
105        let x = [4u8; 32];
106        let mut t1 = Transcript::new();
107        t1.append(b"suite", b"qpr-pq-1").unwrap();
108        t1.append(b"id", b"a").unwrap();
109        let mut t2 = Transcript::new();
110        t2.append(b"suite", b"qpr-pq-1").unwrap();
111        t2.append(b"id", b"b").unwrap();
112        let k1 = derive_handshake_keys(&kem, &x, &t1).unwrap();
113        let k2 = derive_handshake_keys(&kem, &x, &t2).unwrap();
114        assert_ne!(k1.initiator_to_responder, k2.initiator_to_responder);
115        assert_ne!(k1.transcript_digest, k2.transcript_digest);
116    }
117
118    #[test]
119    fn all_zero_dh_is_rejected() {
120        let mut t = Transcript::new();
121        t.append(b"suite", b"qpr-pq-1").unwrap();
122        assert!(derive_handshake_keys(&[0u8; 32], &[1u8; 32], &t).is_err());
123        assert!(derive_handshake_keys(&[1u8; 32], &[0u8; 32], &t).is_err());
124    }
125
126    #[test]
127    fn traffic_update_changes_keys_and_is_not_identity() {
128        let send = [5u8; AEAD_KEY_LEN];
129        let recv = [6u8; AEAD_KEY_LEN];
130        let (s2, r2) = derive_traffic_update(&send, &recv, 2).unwrap();
131        assert_ne!(s2, send);
132        assert_ne!(r2, recv);
133        assert_ne!(s2, r2);
134        let (s3, r3) = derive_traffic_update(&s2, &r2, 3).unwrap();
135        assert_ne!(s3, s2);
136        assert_ne!(r3, r2);
137    }
138
139    #[test]
140    fn r03_handshake_schedule_binds_full_transcript_and_finished_key() {
141        use crate::net::qdnf::crypto::finished::{finished_mac, verify_finished};
142        let kem = [0x11u8; 32];
143        let x = [0x22u8; 32];
144        let mut t = Transcript::new();
145        t.append(b"suite", b"qpr-pq-1").unwrap();
146        t.append(b"init", b"did:qi:alice").unwrap();
147        t.append(b"resp", b"did:qi:bob").unwrap();
148        let keys = derive_handshake_keys(&kem, &x, &t).unwrap();
149        assert_ne!(keys.initiator_to_responder, keys.responder_to_initiator);
150        let i2r_tag =
151            finished_mac(&keys.initiator_to_responder, &keys.transcript_digest, true).unwrap();
152        let r2i_tag =
153            finished_mac(&keys.responder_to_initiator, &keys.transcript_digest, false).unwrap();
154        assert!(verify_finished(
155            &keys.initiator_to_responder,
156            &keys.transcript_digest,
157            true,
158            &i2r_tag
159        )
160        .is_ok());
161        assert!(verify_finished(
162            &keys.responder_to_initiator,
163            &keys.transcript_digest,
164            false,
165            &r2i_tag
166        )
167        .is_ok());
168        assert!(verify_finished(
169            &keys.initiator_to_responder,
170            &keys.transcript_digest,
171            true,
172            &r2i_tag
173        )
174        .is_err());
175    }
176}