qualia_core_db/net/qdnf/crypto/
schedule.rs1#[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
25pub 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
60pub 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}