1use std::{fmt::Display, pin::Pin, str::FromStr};
2
3use bitwarden_encoding::{B64, FromStrVisitor};
4use ciborium::{Value, value::Integer};
5use coset::iana::{EnumI64, KeyParameter, KeyType, RsaKeyParameter};
6use rsa::{RsaPrivateKey, RsaPublicKey, pkcs8::DecodePublicKey, traits::PublicKeyParts};
7use serde::{Deserialize, Serialize};
8use serde_repr::{Deserialize_repr, Serialize_repr};
9
10use super::key_encryptable::CryptoKey;
11use crate::{
12 CoseKeyThumbprint, Pkcs8PrivateKeyBytes, SpkiPublicKeyBytes,
13 cose::{CoseKeyThumbprintExt, thumbprint_from_required_params},
14 error::{CryptoError, Result},
15 slow_crypto_span::{SlowCryptoOp, SlowCryptoSpan},
16};
17
18#[cfg(feature = "wasm")]
19#[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
20const TS_CUSTOM_TYPES: &'static str = r#"
21export type PublicKey = Tagged<string, "PublicKey">;
22"#;
23
24bitwarden_ffi::impl_wire_string!(
25 PublicKey,
26 parse = |wire: String| {
27 let bytes: Vec<u8> = wire
28 .parse::<bitwarden_encoding::B64>()
29 .map_err(|err| err.to_string())?
30 .into();
31 PublicKey::from_der(&SpkiPublicKeyBytes::from(bytes)).map_err(|err| err.to_string())
32 },
33);
34
35#[derive(Debug, Serialize_repr, Deserialize_repr)]
37#[repr(u8)]
38pub enum PublicKeyEncryptionAlgorithm {
39 RsaOaepSha1 = 0,
41}
42
43#[derive(Clone, PartialEq)]
44pub(crate) enum RawPublicKey {
45 RsaOaepSha1(RsaPublicKey),
46}
47
48#[derive(Clone, PartialEq)]
51pub struct PublicKey {
52 inner: RawPublicKey,
53}
54
55impl std::fmt::Debug for PublicKey {
56 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
57 let key_suffix = match &self.inner {
58 RawPublicKey::RsaOaepSha1(_) => "RsaOaepSha1",
59 };
60 let mut debug_struct = f.debug_struct(format!("PublicKey::{}", key_suffix).as_str());
61 match &self.inner {
62 RawPublicKey::RsaOaepSha1(_) => {
63 if let Ok(der) = self.to_der() {
64 debug_struct.field("key", &hex::encode(der.as_ref()));
65 }
66 }
67 }
68 debug_struct.finish()
69 }
70}
71
72impl PublicKey {
73 pub(crate) fn inner(&self) -> &RawPublicKey {
74 &self.inner
75 }
76
77 #[bitwarden_logging::instrument(err)]
79 pub fn from_der(der: &SpkiPublicKeyBytes) -> Result<Self> {
80 Ok(PublicKey {
81 inner: RawPublicKey::RsaOaepSha1(
82 RsaPublicKey::from_public_key_der(der.as_ref())
83 .map_err(|_| CryptoError::InvalidKey)?,
84 ),
85 })
86 }
87
88 #[bitwarden_logging::instrument(err)]
90 pub fn to_der(&self) -> Result<SpkiPublicKeyBytes> {
91 use rsa::pkcs8::EncodePublicKey;
92 match &self.inner {
93 RawPublicKey::RsaOaepSha1(public_key) => Ok(public_key
94 .to_public_key_der()
95 .map_err(|_| CryptoError::InvalidKey)?
96 .as_bytes()
97 .to_owned()
98 .into()),
99 }
100 }
101}
102
103impl CoseKeyThumbprintExt for PublicKey {
104 fn thumbprint(&self) -> Result<CoseKeyThumbprint> {
105 let params = match &self.inner {
106 RawPublicKey::RsaOaepSha1(key) => vec![
107 (
108 KeyParameter::Kty.to_i64(),
109 Value::Integer(Integer::from(KeyType::RSA.to_i64())),
110 ),
111 (
115 RsaKeyParameter::N.to_i64(),
116 Value::Bytes(key.n().to_be_bytes_trimmed_vartime().into_vec()),
117 ),
118 (
119 RsaKeyParameter::E.to_i64(),
120 Value::Bytes(key.e().to_be_bytes_trimmed_vartime().into_vec()),
121 ),
122 ],
123 };
124 Ok(thumbprint_from_required_params(params))
125 }
126}
127
128impl FromStr for PublicKey {
129 type Err = ();
130
131 fn from_str(s: &str) -> Result<Self, Self::Err> {
132 let bytes: Vec<u8> = s.parse::<B64>().map_err(|_| ())?.into();
133 Self::from_der(&SpkiPublicKeyBytes::from(bytes)).map_err(|_| ())
134 }
135}
136
137impl Display for PublicKey {
138 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
139 match self.to_der() {
140 Ok(der) => write!(f, "{}", B64::from(der.as_ref())),
141 Err(_) => write!(f, "[INVALID PUBLIC KEY]"),
142 }
143 }
144}
145
146impl<'de> Deserialize<'de> for PublicKey {
147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
148 where
149 D: serde::Deserializer<'de>,
150 {
151 deserializer.deserialize_str(FromStrVisitor::new())
152 }
153}
154
155impl Serialize for PublicKey {
156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
157 where
158 S: serde::Serializer,
159 {
160 let der = self.to_der().map_err(serde::ser::Error::custom)?;
161 serializer.serialize_str(&B64::from(der.as_ref()).to_string())
162 }
163}
164
165#[derive(Clone)]
166pub(crate) enum RawPrivateKey {
167 RsaOaepSha1(Pin<Box<RsaPrivateKey>>),
172}
173
174#[derive(Clone)]
177pub struct PrivateKey {
178 inner: RawPrivateKey,
179}
180
181const _: fn() = || {
184 fn assert_zeroize_on_drop<T: zeroize::ZeroizeOnDrop>() {}
185 assert_zeroize_on_drop::<RsaPrivateKey>();
186};
187impl zeroize::ZeroizeOnDrop for PrivateKey {}
188impl CryptoKey for PrivateKey {}
189
190impl PrivateKey {
191 pub fn make(algorithm: PublicKeyEncryptionAlgorithm) -> Self {
193 Self::make_internal(algorithm, &mut bitwarden_random::rng())
194 }
195
196 fn make_internal<R: rand::CryptoRng + rand::Rng>(
197 algorithm: PublicKeyEncryptionAlgorithm,
198 rng: &mut R,
199 ) -> Self {
200 match algorithm {
201 PublicKeyEncryptionAlgorithm::RsaOaepSha1 => {
202 let _span = SlowCryptoSpan::start(SlowCryptoOp::RsaKeyGeneration);
203 Self {
204 inner: RawPrivateKey::RsaOaepSha1(Box::pin(
205 RsaPrivateKey::new(rng, 2048).expect("failed to generate a key"),
206 )),
207 }
208 }
209 }
210 }
211
212 #[allow(missing_docs)]
213 #[cfg_attr(
218 feature = "dangerous-crypto-debug",
219 allow(unknown_lints, tracing_instrument)
220 )]
221 #[cfg_attr(feature = "dangerous-crypto-debug", tracing::instrument(err))]
222 #[cfg_attr(
223 not(feature = "dangerous-crypto-debug"),
224 bitwarden_logging::instrument(err)
225 )]
226 pub fn from_pem(pem: &str) -> Result<Self> {
227 use rsa::pkcs8::DecodePrivateKey;
228 Ok(Self {
229 inner: RawPrivateKey::RsaOaepSha1(Box::pin(
230 RsaPrivateKey::from_pkcs8_pem(pem).map_err(|_| CryptoError::InvalidKey)?,
231 )),
232 })
233 }
234
235 #[allow(missing_docs)]
236 #[cfg_attr(
237 feature = "dangerous-crypto-debug",
238 allow(unknown_lints, tracing_instrument)
239 )]
240 #[cfg_attr(feature = "dangerous-crypto-debug", tracing::instrument(err))]
241 #[cfg_attr(
242 not(feature = "dangerous-crypto-debug"),
243 bitwarden_logging::instrument(err)
244 )]
245 pub fn from_der(der: &Pkcs8PrivateKeyBytes) -> Result<Self> {
246 use rsa::pkcs8::DecodePrivateKey;
247 Ok(Self {
248 inner: RawPrivateKey::RsaOaepSha1(Box::pin(
249 RsaPrivateKey::from_pkcs8_der(der.as_ref()).map_err(|_| CryptoError::InvalidKey)?,
250 )),
251 })
252 }
253
254 #[allow(missing_docs)]
255 #[cfg_attr(
256 feature = "dangerous-crypto-debug",
257 allow(unknown_lints, tracing_instrument)
258 )]
259 #[cfg_attr(feature = "dangerous-crypto-debug", tracing::instrument(err))]
260 #[cfg_attr(
261 not(feature = "dangerous-crypto-debug"),
262 bitwarden_logging::instrument(err)
263 )]
264 pub fn to_der(&self) -> Result<Pkcs8PrivateKeyBytes> {
265 match &self.inner {
266 RawPrivateKey::RsaOaepSha1(private_key) => {
267 use rsa::pkcs8::EncodePrivateKey;
268 Ok(private_key
269 .to_pkcs8_der()
270 .map_err(|_| CryptoError::InvalidKey)?
271 .as_bytes()
272 .to_owned()
273 .into())
274 }
275 }
276 }
277
278 pub fn to_public_key(&self) -> PublicKey {
281 match &self.inner {
282 RawPrivateKey::RsaOaepSha1(private_key) => PublicKey {
283 inner: RawPublicKey::RsaOaepSha1(private_key.to_public_key()),
284 },
285 }
286 }
287
288 pub(crate) fn inner(&self) -> &RawPrivateKey {
289 &self.inner
290 }
291}
292
293impl CoseKeyThumbprintExt for PrivateKey {
294 fn thumbprint(&self) -> Result<CoseKeyThumbprint> {
295 self.to_public_key().thumbprint()
296 }
297}
298
299impl std::fmt::Debug for PrivateKey {
301 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
302 let key_suffix = match &self.inner {
303 RawPrivateKey::RsaOaepSha1(_) => "RsaOaepSha1",
304 };
305 let mut debug_struct = f.debug_struct(format!("PrivateKey::{}", key_suffix).as_str());
306 #[cfg(feature = "dangerous-crypto-debug")]
307 match &self.inner {
308 RawPrivateKey::RsaOaepSha1(_) => {
309 if let Ok(der) = self.to_der() {
310 debug_struct.field("key", &hex::encode(der.as_ref()));
311 }
312 }
313 }
314 debug_struct.finish()
315 }
316}
317
318#[cfg(test)]
319mod tests {
320
321 use bitwarden_encoding::B64;
322
323 use crate::{
324 CoseKeyThumbprintExt, Pkcs8PrivateKeyBytes, PrivateKey, PublicKey,
325 PublicKeyEncryptionAlgorithm, SpkiPublicKeyBytes, SymmetricCryptoKey, UnsignedSharedKey,
326 content_format::{Bytes, Pkcs8PrivateKeyDerContentFormat},
327 };
328
329 #[test]
330 #[ignore = "Manual test to verify debug format"]
331 fn test_debug() {
332 let private_key = PrivateKey::make(PublicKeyEncryptionAlgorithm::RsaOaepSha1);
333 println!("{:?}", private_key);
334 let public_key = private_key.to_public_key();
335 println!("{:?}", public_key);
336 }
337
338 #[test]
339 fn test_asymmetric_crypto_key() {
340 let pem_key_str = "-----BEGIN PRIVATE KEY-----
341MIIEwAIBADANBgkqhkiG9w0BAQEFAASCBKowggSmAgEAAoIBAQDiTQVuzhdygFz5
342qv14i+XFDGTnDravzUQT1hPKPGUZOUSZ1gwdNgkWqOIaOnR65BHEnL0sp4bnuiYc
343afeK2JAW5Sc8Z7IxBNSuAwhQmuKx3RochMIiuCkI2/p+JvUQoJu6FBNm8OoJ4Cwm
344qqHGZESMfnpQDCuDrB3JdJEdXhtmnl0C48sGjOk3WaBMcgGqn8LbJDUlyu1zdqyv
345b0waJf0iV4PJm2fkUl7+57D/2TkpbCqURVnZK1FFIEg8mr6FzSN1F2pOfktkNYZw
346P7MSNR7o81CkRSCMr7EkIVa+MZYMBx106BMK7FXgWB7nbSpsWKxBk7ZDHkID2fam
347rEcVtrzDAgMBAAECggEBAKwq9OssGGKgjhvUnyrLJHAZ0dqIMyzk+dotkLjX4gKi
348szJmyqiep6N5sStLNbsZMPtoU/RZMCW0VbJgXFhiEp2YkZU/Py5UAoqw++53J+kx
3490d/IkPphKbb3xUec0+1mg5O6GljDCQuiZXS1dIa/WfeZcezclW6Dz9WovY6ePjJ+
3508vEBR1icbNKzyeINd6MtPtpcgQPHtDwHvhPyUDbKDYGbLvjh9nui8h4+ZUlXKuVR
351jB0ChxiKV1xJRjkrEVoulOOicd5r597WfB2ghax3pvRZ4MdXemCXm3gQYqPVKach
352vGU+1cPQR/MBJZpxT+EZA97xwtFS3gqwbxJaNFcoE8ECgYEA9OaeYZhQPDo485tI
3531u/Z7L/3PNape9hBQIXoW7+MgcQ5NiWqYh8Jnj43EIYa0wM/ECQINr1Za8Q5e6KR
354J30FcU+kfyjuQ0jeXdNELGU/fx5XXNg/vV8GevHwxRlwzqZTCg6UExUZzbYEQqd7
355l+wPyETGeua5xCEywA1nX/D101kCgYEA7I6aMFjhEjO71RmzNhqjKJt6DOghoOfQ
356TjhaaanNEhLYSbenFz1mlb21mW67ulmz162saKdIYLxQNJIP8ZPmxh4ummOJI8w9
357ClHfo8WuCI2hCjJ19xbQJocSbTA5aJg6lA1IDVZMDbQwsnAByPRGpaLHBT/Q9Bye
358KvCMB+9amXsCgYEAx65yXSkP4sumPBrVHUub6MntERIGRxBgw/drKcPZEMWp0FiN
359wEuGUBxyUWrG3F69QK/gcqGZE6F/LSu0JvptQaKqgXQiMYJsrRvhbkFvsHpQyUcZ
360UZL1ebFjm5HOxPAgrQaN/bEqxOwwNRjSUWEMzUImg3c06JIZCzbinvudtKECgYEA
361kY3JF/iIPI/yglP27lKDlCfeeHSYxI3+oTKRhzSAxx8rUGidenJAXeDGDauR/T7W
362pt3pGNfddBBK9Z3uC4Iq3DqUCFE4f/taj7ADAJ1Q0Vh7/28/IJM77ojr8J1cpZwN
363Zy2o6PPxhfkagaDjqEeN9Lrs5LD4nEvDkr5CG1vOjmMCgYEAvIBFKRm31NyF8jLi
364CVuPwC5PzrW5iThDmsWTaXFpB3esUsbICO2pEz872oeQS+Em4GO5vXUlpbbFPzup
365PFhA8iMJ8TAvemhvc7oM0OZqpU6p3K4seHf6BkwLxumoA3vDJfovu9RuXVcJVOnf
366DnqOsltgPomWZ7xVfMkm9niL2OA=
367-----END PRIVATE KEY-----";
368
369 let der_key: B64 = "MIIEwAIBADANBgkqhkiG9w0BAQEFAASCBKowggSmAgEAAoIBAQDiTQVuzhdygFz5qv14i+XFDGTnDravzUQT1hPKPGUZOUSZ1gwdNgkWqOIaOnR65BHEnL0sp4bnuiYcafeK2JAW5Sc8Z7IxBNSuAwhQmuKx3RochMIiuCkI2/p+JvUQoJu6FBNm8OoJ4CwmqqHGZESMfnpQDCuDrB3JdJEdXhtmnl0C48sGjOk3WaBMcgGqn8LbJDUlyu1zdqyvb0waJf0iV4PJm2fkUl7+57D/2TkpbCqURVnZK1FFIEg8mr6FzSN1F2pOfktkNYZwP7MSNR7o81CkRSCMr7EkIVa+MZYMBx106BMK7FXgWB7nbSpsWKxBk7ZDHkID2famrEcVtrzDAgMBAAECggEBAKwq9OssGGKgjhvUnyrLJHAZ0dqIMyzk+dotkLjX4gKiszJmyqiep6N5sStLNbsZMPtoU/RZMCW0VbJgXFhiEp2YkZU/Py5UAoqw++53J+kx0d/IkPphKbb3xUec0+1mg5O6GljDCQuiZXS1dIa/WfeZcezclW6Dz9WovY6ePjJ+8vEBR1icbNKzyeINd6MtPtpcgQPHtDwHvhPyUDbKDYGbLvjh9nui8h4+ZUlXKuVRjB0ChxiKV1xJRjkrEVoulOOicd5r597WfB2ghax3pvRZ4MdXemCXm3gQYqPVKachvGU+1cPQR/MBJZpxT+EZA97xwtFS3gqwbxJaNFcoE8ECgYEA9OaeYZhQPDo485tI1u/Z7L/3PNape9hBQIXoW7+MgcQ5NiWqYh8Jnj43EIYa0wM/ECQINr1Za8Q5e6KRJ30FcU+kfyjuQ0jeXdNELGU/fx5XXNg/vV8GevHwxRlwzqZTCg6UExUZzbYEQqd7l+wPyETGeua5xCEywA1nX/D101kCgYEA7I6aMFjhEjO71RmzNhqjKJt6DOghoOfQTjhaaanNEhLYSbenFz1mlb21mW67ulmz162saKdIYLxQNJIP8ZPmxh4ummOJI8w9ClHfo8WuCI2hCjJ19xbQJocSbTA5aJg6lA1IDVZMDbQwsnAByPRGpaLHBT/Q9ByeKvCMB+9amXsCgYEAx65yXSkP4sumPBrVHUub6MntERIGRxBgw/drKcPZEMWp0FiNwEuGUBxyUWrG3F69QK/gcqGZE6F/LSu0JvptQaKqgXQiMYJsrRvhbkFvsHpQyUcZUZL1ebFjm5HOxPAgrQaN/bEqxOwwNRjSUWEMzUImg3c06JIZCzbinvudtKECgYEAkY3JF/iIPI/yglP27lKDlCfeeHSYxI3+oTKRhzSAxx8rUGidenJAXeDGDauR/T7Wpt3pGNfddBBK9Z3uC4Iq3DqUCFE4f/taj7ADAJ1Q0Vh7/28/IJM77ojr8J1cpZwNZy2o6PPxhfkagaDjqEeN9Lrs5LD4nEvDkr5CG1vOjmMCgYEAvIBFKRm31NyF8jLiCVuPwC5PzrW5iThDmsWTaXFpB3esUsbICO2pEz872oeQS+Em4GO5vXUlpbbFPzupPFhA8iMJ8TAvemhvc7oM0OZqpU6p3K4seHf6BkwLxumoA3vDJfovu9RuXVcJVOnfDnqOsltgPomWZ7xVfMkm9niL2OA=".parse().unwrap();
370 let der_key_vec: Vec<u8> = der_key.into();
371
372 let pem_key = PrivateKey::from_pem(pem_key_str).unwrap();
374 let der_key = PrivateKey::from_der(&Bytes::<Pkcs8PrivateKeyDerContentFormat>::from(
375 der_key_vec.clone(),
376 ))
377 .unwrap();
378 assert_eq!(pem_key.to_der().unwrap(), der_key.to_der().unwrap());
379
380 assert_eq!(der_key.to_der().unwrap().to_vec(), der_key_vec.clone());
383 assert_eq!(pem_key.to_der().unwrap().to_vec(), der_key_vec);
384 }
385
386 #[test]
387 fn test_encrypt_public_decrypt_private() {
388 let private_key: B64 = concat!(
389 "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCu9xd+vmkIPoqH",
390 "NejsFZzkd1xuCn1TqGTT7ANhAEnbI/yaVt3caI30kwUC2WIToFpNgu7Ej0x2TteY",
391 "OgrLrdcC4jy1SifmKYv/v3ZZxrd/eqttmH2k588panseRwHK3LVk7xA+URhQ/bjL",
392 "gPM59V0uR1l+z1fmooeJPFz5WSXNObc9Jqnh45FND+U/UYHXTLSomTn7jgZFxJBK",
393 "veS7q6Lat7wAnYZCF2dnPmhZoJv+SKPltA8HAGsgQGWBF1p5qxV1HrAUk8kBBnG2",
394 "paj0w8p5UM6RpDdCuvKH7j1LiuWffn3b9Z4dgzmE7jsMmvzoQtypzIKaSxhqzvFO",
395 "od9V8dJdAgMBAAECggEAGGIYjOIB1rOKkDHP4ljXutI0mCRPl3FMDemiBeppoIfZ",
396 "G/Q3qpAKmndDt0Quwh/yfcNdvZhf1kwCCTWri/uPz5fSUIyDV3TaTRu0ZWoHaBVj",
397 "Hxylg+4HRZUQj+Vi50/PWr/jQmAAVMcrMfcoTl82q2ynmP/R1vM3EsXOCjTliv5B",
398 "XlMPRjj/9PDBH0dnnVcAPDOpflzOTL2f4HTFEMlmg9/tZBnd96J/cmfhjAv9XpFL",
399 "FBAFZzs5pz0rwCNSR8QZNonnK7pngVUlGDLORK58y84tGmxZhGdne3CtCWey/sJ4",
400 "7QF0Pe8YqWBU56926IY6DcSVBuQGZ6vMCNlU7J8D2QKBgQDXyh3t2TicM/n1QBLk",
401 "zLoGmVUmxUGziHgl2dnJiGDtyOAU3+yCorPgFaCie29s5qm4b0YEGxUxPIrRrEro",
402 "h0FfKn9xmr8CdmTPTcjJW1+M7bxxq7oBoU/QzKXgIHlpeCjjnvPJt0PcNkNTjCXv",
403 "shsrINh2rENoe/x79eEfM/N5eQKBgQDPkYSmYyALoNq8zq0A4BdR+F5lb5Fj5jBH",
404 "Jk68l6Uti+0hRbJ2d1tQTLkU+eCPQLGBl6fuc1i4K5FV7v14jWtRPdD7wxrkRi3j",
405 "ilqQwLBOU6Bj3FK4DvlLF+iYTuBWj2/KcxflXECmsjitKHLK6H7kFEiuJql+NAHU",
406 "U9EFXepLBQKBgQDQ+HCnZ1bFHiiP8m7Zl9EGlvK5SwlnPV9s+F1KJ4IGhCNM09UM",
407 "ZVfgR9F5yCONyIrPiyK40ylgtwqQJlOcf281I8irUXpsfg7+Gou5Q31y0r9NLUpC",
408 "Td8niyePtqMdGjouxD2+OHXFCd+FRxFt4IMi7vnxYr0csAVAXkqWlw7PsQKBgH/G",
409 "/PnQm7GM3BrOwAGB8dksJDAddkshMScblezTDYP0V43b8firkTLliCo5iNum357/",
410 "VQmdSEhXyag07yR/Kklg3H2fpbZQ3X7tdMMXW3FcWagfwWw9C4oGtdDM/Z1Lv23J",
411 "XDR9je8QV4OBGul+Jl8RfYx3kG94ZIfo8Qt0vP5hAoGARjAzdCGYz42NwaUk8n94",
412 "W2RuKHtTV9vtjaAbfPFbZoGkT7sXNJVlrA0C+9f+H9rOTM3mX59KrjmLVzde4Vhs",
413 "avWMShuK4vpAiDQLU7GyABvi5CR6Ld+AT+LSzxHhVe0ASOQPNCA2SOz3RQvgPi7R",
414 "GDgRMUB6cL3IRVzcR0dC6cY=",
415 )
416 .parse()
417 .unwrap();
418
419 let public_key: B64 = concat!(
420 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArvcXfr5pCD6KhzXo7BWc",
421 "5Hdcbgp9U6hk0+wDYQBJ2yP8mlbd3GiN9JMFAtliE6BaTYLuxI9Mdk7XmDoKy63X",
422 "AuI8tUon5imL/792Wca3f3qrbZh9pOfPKWp7HkcByty1ZO8QPlEYUP24y4DzOfVd",
423 "LkdZfs9X5qKHiTxc+VklzTm3PSap4eORTQ/lP1GB10y0qJk5+44GRcSQSr3ku6ui",
424 "2re8AJ2GQhdnZz5oWaCb/kij5bQPBwBrIEBlgRdaeasVdR6wFJPJAQZxtqWo9MPK",
425 "eVDOkaQ3Qrryh+49S4rln3592/WeHYM5hO47DJr86ELcqcyCmksYas7xTqHfVfHS",
426 "XQIDAQAB",
427 )
428 .parse()
429 .unwrap();
430
431 let private_key = Pkcs8PrivateKeyBytes::from(private_key.as_bytes());
432 let private_key = PrivateKey::from_der(&private_key).unwrap();
433 let public_key = PublicKey::from_der(&SpkiPublicKeyBytes::from(&public_key)).unwrap();
434
435 let raw_key = SymmetricCryptoKey::make_aes256_cbc_hmac_key();
436 #[expect(deprecated)]
437 let encrypted = UnsignedSharedKey::encapsulate_key_unsigned(&raw_key, &public_key).unwrap();
438 #[expect(deprecated)]
439 let decrypted = encrypted.decapsulate_key_unsigned(&private_key).unwrap();
440
441 assert_eq!(raw_key, decrypted);
442 }
443
444 #[test]
445 fn test_asymmetric_public_crypto_key_from_str() {
446 let public_key_b64 = concat!(
447 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArvcXfr5pCD6KhzXo7BWc",
448 "5Hdcbgp9U6hk0+wDYQBJ2yP8mlbd3GiN9JMFAtliE6BaTYLuxI9Mdk7XmDoKy63X",
449 "AuI8tUon5imL/792Wca3f3qrbZh9pOfPKWp7HkcByty1ZO8QPlEYUP24y4DzOfVd",
450 "LkdZfs9X5qKHiTxc+VklzTm3PSap4eORTQ/lP1GB10y0qJk5+44GRcSQSr3ku6ui",
451 "2re8AJ2GQhdnZz5oWaCb/kij5bQPBwBrIEBlgRdaeasVdR6wFJPJAQZxtqWo9MPK",
452 "eVDOkaQ3Qrryh+49S4rln3592/WeHYM5hO47DJr86ELcqcyCmksYas7xTqHfVfHS",
453 "XQIDAQAB",
454 );
455
456 let parsed_key: PublicKey = public_key_b64.parse().expect("should parse");
458
459 let der = parsed_key.to_der().expect("should convert to DER");
461 let b64_str = B64::from(der.as_ref()).to_string();
462 assert_eq!(b64_str, public_key_b64);
463 }
464
465 #[test]
466 fn test_asymmetric_public_crypto_key_from_str_invalid() {
467 let result: Result<PublicKey, _> = "not-valid-base64!!!".parse();
469 assert!(result.is_err());
470
471 let result: Result<PublicKey, _> = "aGVsbG8gd29ybGQ=".parse();
473 assert!(result.is_err());
474 }
475
476 #[test]
477 fn test_asymmetric_public_crypto_key_serialize_deserialize() {
478 let public_key_b64 = concat!(
479 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArvcXfr5pCD6KhzXo7BWc",
480 "5Hdcbgp9U6hk0+wDYQBJ2yP8mlbd3GiN9JMFAtliE6BaTYLuxI9Mdk7XmDoKy63X",
481 "AuI8tUon5imL/792Wca3f3qrbZh9pOfPKWp7HkcByty1ZO8QPlEYUP24y4DzOfVd",
482 "LkdZfs9X5qKHiTxc+VklzTm3PSap4eORTQ/lP1GB10y0qJk5+44GRcSQSr3ku6ui",
483 "2re8AJ2GQhdnZz5oWaCb/kij5bQPBwBrIEBlgRdaeasVdR6wFJPJAQZxtqWo9MPK",
484 "eVDOkaQ3Qrryh+49S4rln3592/WeHYM5hO47DJr86ELcqcyCmksYas7xTqHfVfHS",
485 "XQIDAQAB",
486 );
487
488 let key: PublicKey = public_key_b64.parse().expect("should parse");
490
491 let serialized = serde_json::to_string(&key).expect("should serialize");
493 assert_eq!(serialized, format!("\"{}\"", public_key_b64));
494
495 let deserialized: PublicKey =
497 serde_json::from_str(&serialized).expect("should deserialize");
498
499 assert_eq!(
501 key.to_der().expect("should convert to DER"),
502 deserialized.to_der().expect("should convert to DER")
503 );
504 }
505
506 #[test]
507 fn test_asymmetric_public_crypto_key_deserialize_invalid() {
508 let result: Result<PublicKey, _> = serde_json::from_str("\"not-valid-base64!!!\"");
510 assert!(result.is_err());
511
512 let result: Result<PublicKey, _> = serde_json::from_str("\"aGVsbG8gd29ybGQ=\"");
514 assert!(result.is_err());
515
516 let result: Result<PublicKey, _> = serde_json::from_str("123");
518 assert!(result.is_err());
519 }
520
521 const RSA_PRIVATE_KEY_B64: &str = concat!(
523 "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCu9xd+vmkIPoqH",
524 "NejsFZzkd1xuCn1TqGTT7ANhAEnbI/yaVt3caI30kwUC2WIToFpNgu7Ej0x2TteY",
525 "OgrLrdcC4jy1SifmKYv/v3ZZxrd/eqttmH2k588panseRwHK3LVk7xA+URhQ/bjL",
526 "gPM59V0uR1l+z1fmooeJPFz5WSXNObc9Jqnh45FND+U/UYHXTLSomTn7jgZFxJBK",
527 "veS7q6Lat7wAnYZCF2dnPmhZoJv+SKPltA8HAGsgQGWBF1p5qxV1HrAUk8kBBnG2",
528 "paj0w8p5UM6RpDdCuvKH7j1LiuWffn3b9Z4dgzmE7jsMmvzoQtypzIKaSxhqzvFO",
529 "od9V8dJdAgMBAAECggEAGGIYjOIB1rOKkDHP4ljXutI0mCRPl3FMDemiBeppoIfZ",
530 "G/Q3qpAKmndDt0Quwh/yfcNdvZhf1kwCCTWri/uPz5fSUIyDV3TaTRu0ZWoHaBVj",
531 "Hxylg+4HRZUQj+Vi50/PWr/jQmAAVMcrMfcoTl82q2ynmP/R1vM3EsXOCjTliv5B",
532 "XlMPRjj/9PDBH0dnnVcAPDOpflzOTL2f4HTFEMlmg9/tZBnd96J/cmfhjAv9XpFL",
533 "FBAFZzs5pz0rwCNSR8QZNonnK7pngVUlGDLORK58y84tGmxZhGdne3CtCWey/sJ4",
534 "7QF0Pe8YqWBU56926IY6DcSVBuQGZ6vMCNlU7J8D2QKBgQDXyh3t2TicM/n1QBLk",
535 "zLoGmVUmxUGziHgl2dnJiGDtyOAU3+yCorPgFaCie29s5qm4b0YEGxUxPIrRrEro",
536 "h0FfKn9xmr8CdmTPTcjJW1+M7bxxq7oBoU/QzKXgIHlpeCjjnvPJt0PcNkNTjCXv",
537 "shsrINh2rENoe/x79eEfM/N5eQKBgQDPkYSmYyALoNq8zq0A4BdR+F5lb5Fj5jBH",
538 "Jk68l6Uti+0hRbJ2d1tQTLkU+eCPQLGBl6fuc1i4K5FV7v14jWtRPdD7wxrkRi3j",
539 "ilqQwLBOU6Bj3FK4DvlLF+iYTuBWj2/KcxflXECmsjitKHLK6H7kFEiuJql+NAHU",
540 "U9EFXepLBQKBgQDQ+HCnZ1bFHiiP8m7Zl9EGlvK5SwlnPV9s+F1KJ4IGhCNM09UM",
541 "ZVfgR9F5yCONyIrPiyK40ylgtwqQJlOcf281I8irUXpsfg7+Gou5Q31y0r9NLUpC",
542 "Td8niyePtqMdGjouxD2+OHXFCd+FRxFt4IMi7vnxYr0csAVAXkqWlw7PsQKBgH/G",
543 "/PnQm7GM3BrOwAGB8dksJDAddkshMScblezTDYP0V43b8firkTLliCo5iNum357/",
544 "VQmdSEhXyag07yR/Kklg3H2fpbZQ3X7tdMMXW3FcWagfwWw9C4oGtdDM/Z1Lv23J",
545 "XDR9je8QV4OBGul+Jl8RfYx3kG94ZIfo8Qt0vP5hAoGARjAzdCGYz42NwaUk8n94",
546 "W2RuKHtTV9vtjaAbfPFbZoGkT7sXNJVlrA0C+9f+H9rOTM3mX59KrjmLVzde4Vhs",
547 "avWMShuK4vpAiDQLU7GyABvi5CR6Ld+AT+LSzxHhVe0ASOQPNCA2SOz3RQvgPi7R",
548 "GDgRMUB6cL3IRVzcR0dC6cY=",
549 );
550 const RSA_PUBLIC_KEY_B64: &str = concat!(
551 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArvcXfr5pCD6KhzXo7BWc",
552 "5Hdcbgp9U6hk0+wDYQBJ2yP8mlbd3GiN9JMFAtliE6BaTYLuxI9Mdk7XmDoKy63X",
553 "AuI8tUon5imL/792Wca3f3qrbZh9pOfPKWp7HkcByty1ZO8QPlEYUP24y4DzOfVd",
554 "LkdZfs9X5qKHiTxc+VklzTm3PSap4eORTQ/lP1GB10y0qJk5+44GRcSQSr3ku6ui",
555 "2re8AJ2GQhdnZz5oWaCb/kij5bQPBwBrIEBlgRdaeasVdR6wFJPJAQZxtqWo9MPK",
556 "eVDOkaQ3Qrryh+49S4rln3592/WeHYM5hO47DJr86ELcqcyCmksYas7xTqHfVfHS",
557 "XQIDAQAB",
558 );
559
560 #[test]
561 fn test_thumbprint_private_matches_public() {
562 let private_key = PrivateKey::make(PublicKeyEncryptionAlgorithm::RsaOaepSha1);
563 assert_eq!(
564 private_key.thumbprint().unwrap(),
565 private_key.to_public_key().thumbprint().unwrap()
566 );
567 }
568
569 #[test]
570 fn test_thumbprint_rsa_vector() {
571 let private_key_bytes: B64 = RSA_PRIVATE_KEY_B64.parse().unwrap();
572 let private_key =
573 PrivateKey::from_der(&Pkcs8PrivateKeyBytes::from(private_key_bytes.as_bytes()))
574 .unwrap();
575 let public_key = PublicKey::from_der(&SpkiPublicKeyBytes::from(
576 RSA_PUBLIC_KEY_B64.parse::<B64>().unwrap().as_bytes(),
577 ))
578 .unwrap();
579
580 assert_eq!(
581 private_key.thumbprint().unwrap(),
582 public_key.thumbprint().unwrap()
583 );
584 assert_eq!(
585 public_key.thumbprint().unwrap().to_hex(),
586 "04fbcfa50c5805171304cc5b4794c25d77f7359d8a201828a5d7ef89162463aa"
587 );
588 }
589}