Debian Codegraph @

third_party/rust/mls-rs-crypto-hpke/src/dhkem.rs

raw
1 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 // Copyright by contributors to this project.
3 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
4
5 use mls_rs_crypto_traits::{DhType, KdfType, KemResult, KemType, SamplingMethod};
6
7 use mls_rs_core::{
8 crypto::{HpkePublicKey, HpkeSecretKey},
9 error::{AnyError, IntoAnyError},
10 };
11 use zeroize::Zeroizing;
12
13 use crate::kdf::HpkeKdf;
14
15 use alloc::vec::Vec;
16
17 #[derive(Debug)]
18 #[cfg_attr(feature = "std", derive(thiserror::Error))]
19 pub enum DhKemError {
20 #[cfg_attr(feature = "std", error(transparent))]
21 KdfError(AnyError),
22 #[cfg_attr(feature = "std", error(transparent))]
23 DhError(AnyError),
24 /// NIST key derivation from bytes failure. This is statistically unlikely
25 #[cfg_attr(
26 feature = "std",
27 error("Failed to derive nist keypair from raw bytes after 255 attempts")
28 )]
29 KeyDerivationError,
30 }
31
32 impl IntoAnyError for DhKemError {
33 #[cfg(feature = "std")]
34 fn into_dyn_error(self) -> Result<Box<dyn std::error::Error + Send + Sync>, Self> {
35 Ok(self.into())
36 }
37 }
38
39 #[derive(Clone, Debug, Eq, PartialEq)]
40 pub struct DhKem<DH: DhType, KDF: KdfType> {
41 dh: DH,
42 kdf: HpkeKdf<KDF>,
43 kem_id: u16,
44 n_secret: usize,
45 #[cfg(feature = "test_utils")]
46 test_key_data: Vec<u8>,
47 }
48
49 impl<DH: DhType, KDF: KdfType> DhKem<DH, KDF> {
50 pub fn new(dh: DH, kdf: KDF, kem_id: u16, n_secret: usize) -> Self {
51 let suite_id = [b"KEM", &kem_id.to_be_bytes() as &[u8]].concat();
52 let kdf = HpkeKdf::new(suite_id, kdf);
53
54 Self {
55 dh,
56 kdf,
57 kem_id,
58 n_secret,
59 #[cfg(feature = "test_utils")]
60 test_key_data: alloc::vec![],
61 }
62 }
63 }
64
65 #[cfg_attr(not(mls_build_async), maybe_async::must_be_sync)]
66 #[cfg_attr(all(target_arch = "wasm32", mls_build_async), maybe_async::must_be_async(?Send))]
67 #[cfg_attr(
68 all(not(target_arch = "wasm32"), mls_build_async),
69 maybe_async::must_be_async
70 )]
71 impl<DH: DhType, KDF: KdfType> KemType for DhKem<DH, KDF> {
72 type Error = DhKemError;
73
74 fn kem_id(&self) -> u16 {
75 self.kem_id
76 }
77
78 async fn generate_deterministic(
79 &self,
80 seed: &[u8],
81 ) -> Result<(HpkeSecretKey, HpkePublicKey), DhKemError> {
82 match self.dh.bitmask_for_rejection_sampling() {
83 SamplingMethod::HpkeWithBitmask(bitmask) => {
84 self.derive_with_rejection_sampling(seed, bitmask).await
85 }
86 SamplingMethod::HpkeWithoutBitmask => {
87 self.derive_without_rejection_sampling(seed).await
88 }
89 SamplingMethod::Raw => self.derive_raw(seed.to_vec()).await,
90 }
91 }
92
93 async fn generate(&self) -> Result<(HpkeSecretKey, HpkePublicKey), Self::Error> {
94 #[cfg(feature = "test_utils")]
95 if !self.test_key_data.is_empty() {
96 let dkp_prk = self
97 .kdf
98 .labeled_extract(&[], b"dkp_prk", &self.test_key_data)
99 .await
100 .map_err(|e| DhKemError::KdfError(e.into_any_error()))?;
101
102 return self.generate_deterministic(&dkp_prk).await;
103 }
104
105 self.dh
106 .generate()
107 .await
108 .map_err(|e| DhKemError::DhError(e.into_any_error()))
109 }
110
111 async fn encap(&self, remote_pk: &HpkePublicKey) -> Result<KemResult, Self::Error> {
112 let (ephemeral_sk, ephemeral_pk) = self.generate().await?;
113
114 let ecdh_ss = self
115 .dh
116 .dh(&ephemeral_sk, remote_pk)
117 .await
118 .map(Zeroizing::new)
119 .map_err(|e| DhKemError::DhError(e.into_any_error()))?;
120
121 let kem_context = [ephemeral_pk.as_ref(), remote_pk.as_ref()].concat();
122
123 let shared_secret = self
124 .kdf
125 .labeled_extract_then_expand(&ecdh_ss, &kem_context, self.n_secret)
126 .await
127 .map_err(|e| DhKemError::KdfError(e.into_any_error()))?;
128
129 Ok(KemResult::new(shared_secret, ephemeral_pk.into()))
130 }
131
132 async fn decap(
133 &self,
134 enc: &[u8],
135 secret_key: &HpkeSecretKey,
136 public_key: &HpkePublicKey,
137 ) -> Result<Vec<u8>, Self::Error> {
138 let remote_pk = enc.to_vec().into();
139
140 let ecdh_ss = self
141 .dh
142 .dh(secret_key, &remote_pk)
143 .await
144 .map(Zeroizing::new)
145 .map_err(|e| DhKemError::DhError(e.into_any_error()))?;
146
147 let kem_context = [enc, public_key].concat();
148
149 self.kdf
150 .labeled_extract_then_expand(&ecdh_ss, &kem_context, self.n_secret)
151 .await
152 .map_err(|e| DhKemError::KdfError(e.into_any_error()))
153 }
154
155 fn public_key_validate(&self, key: &HpkePublicKey) -> Result<(), Self::Error> {
156 self.dh
157 .public_key_validate(key)
158 .map_err(|e| DhKemError::DhError(e.into_any_error()))
159 }
160
161 fn seed_length_for_derive(&self) -> usize {
162 self.n_secret
163 }
164
165 fn public_key_size(&self) -> usize {
166 self.dh.public_key_size()
167 }
168 fn secret_key_size(&self) -> usize {
169 self.dh.secret_key_size()
170 }
171 }
172
173 impl<DH: DhType, KDF: KdfType> DhKem<DH, KDF> {
174 #[cfg_attr(not(mls_build_async), maybe_async::must_be_sync)]
175 async fn derive_with_rejection_sampling(
176 &self,
177 dkp_prk: &[u8],
178 bitmask: u8,
179 ) -> Result<(HpkeSecretKey, HpkePublicKey), DhKemError> {
180 // The RFC specifies we get 255 chances to generate bytes that will be within range of the order for the curve
181 for i in 0u8..255 {
182 let mut secret_key = self
183 .kdf
184 .labeled_expand(dkp_prk, b"candidate", &[i], self.dh.secret_key_size())
185 .await
186 .map_err(|e| DhKemError::KdfError(e.into_any_error()))?;
187
188 secret_key[0] &= bitmask;
189 let secret_key = secret_key.into();
190
191 // Compute the public key and if it succeeds, return the key pair
192 if let Ok(pair) = self
193 .dh
194 .to_public(&secret_key)
195 .await
196 .map(|pk| (secret_key, pk))
197 {
198 return Ok(pair);
199 }
200 }
201
202 // If we never generate bytes that work, throw an error
203 Err(DhKemError::KeyDerivationError)
204 }
205
206 #[cfg_attr(not(mls_build_async), maybe_async::must_be_sync)]
207 async fn derive_without_rejection_sampling(
208 &self,
209 dkp_prk: &[u8],
210 ) -> Result<(HpkeSecretKey, HpkePublicKey), DhKemError> {
211 let sk = self
212 .kdf
213 .labeled_expand(dkp_prk, b"sk", &[], self.dh.secret_key_size())
214 .await
215 .map_err(|e| DhKemError::KdfError(e.into_any_error()))?;
216
217 self.derive_raw(sk).await
218 }
219
220 #[cfg_attr(not(mls_build_async), maybe_async::must_be_sync)]
221 async fn derive_raw(
222 &self,
223 seed: Vec<u8>,
224 ) -> Result<(HpkeSecretKey, HpkePublicKey), DhKemError> {
225 let sk = seed.into();
226
227 let pk = self
228 .dh
229 .to_public(&sk)
230 .await
231 .map_err(|e| DhKemError::DhError(e.into_any_error()))?;
232
233 Ok((sk, pk))
234 }
235
236 #[cfg(feature = "test_utils")]
237 pub fn set_test_data(&mut self, test_data: Vec<u8>) {
238 self.test_key_data = test_data
239 }
240 }