Skip to main content

bitwarden_crypto/keys/
public_key_encryption.rs

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/// Algorithm / public key encryption scheme used for encryption/decryption.
36#[derive(Debug, Serialize_repr, Deserialize_repr)]
37#[repr(u8)]
38pub enum PublicKeyEncryptionAlgorithm {
39    /// RSA with OAEP padding and SHA-1 hashing.
40    RsaOaepSha1 = 0,
41}
42
43#[derive(Clone, PartialEq)]
44pub(crate) enum RawPublicKey {
45    RsaOaepSha1(RsaPublicKey),
46}
47
48/// Public key of a key pair used in a public key encryption scheme. It is used for
49/// encrypting data.
50#[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    /// Build a public key from the SubjectPublicKeyInfo DER.
78    #[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    /// Makes a SubjectPublicKeyInfo DER serialized version of the public key.
89    #[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                // Per RFC 8230, `n` and `e` are unsigned big-endian byte strings with no leading
112                // zero or sign byte. `to_be_bytes_trimmed_vartime` yields exactly this minimal
113                // form; variable-time is acceptable as `n` and `e` are public.
114                (
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    // RsaPrivateKey is not a Copy type so this isn't completely necessary, but
168    // to keep the compiler from making stack copies when moving this struct around,
169    // we use a Box to keep the values on the heap. We also pin the box to make sure
170    // that the contents can't be pulled out of the box and moved
171    RsaOaepSha1(Pin<Box<RsaPrivateKey>>),
172}
173
174/// Private key of a key pair used in a public key encryption scheme. It is used for
175/// decrypting data that was encrypted with the corresponding public key.
176#[derive(Clone)]
177pub struct PrivateKey {
178    inner: RawPrivateKey,
179}
180
181// Note that RsaPrivateKey already implements ZeroizeOnDrop, so we don't need to do anything
182// We add this assertion to make sure that this is still true in the future
183const _: 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    /// Generate a random PrivateKey (RSA-2048).
192    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    // Under `dangerous-crypto-debug` we intentionally log key material, so this arm uses
214    // `tracing::instrument` directly (the `bitwarden_logging` wrapper enforces `skip_all`).
215    // The production arm goes through the wrapper. The `allow` only applies when the dangerous
216    // arm is active.
217    #[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    /// Derives the public key corresponding to this private key. This is deterministic
279    /// and always derives the same public key.
280    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
299// We manually implement these to make sure we don't print any sensitive data
300impl 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        // Load the two different formats and check they are the same key
373        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        // Check that the keys can be converted back to DER
381
382        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        // Test FromStr
457        let parsed_key: PublicKey = public_key_b64.parse().expect("should parse");
458
459        // Verify the key can be converted back to DER and then to B64
460        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        // Invalid base64
468        let result: Result<PublicKey, _> = "not-valid-base64!!!".parse();
469        assert!(result.is_err());
470
471        // Valid base64 but invalid key data
472        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        // Parse the key
489        let key: PublicKey = public_key_b64.parse().expect("should parse");
490
491        // Serialize to JSON
492        let serialized = serde_json::to_string(&key).expect("should serialize");
493        assert_eq!(serialized, format!("\"{}\"", public_key_b64));
494
495        // Deserialize from JSON
496        let deserialized: PublicKey =
497            serde_json::from_str(&serialized).expect("should deserialize");
498
499        // Verify the keys are equal by comparing their DER representations
500        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        // Invalid base64
509        let result: Result<PublicKey, _> = serde_json::from_str("\"not-valid-base64!!!\"");
510        assert!(result.is_err());
511
512        // Valid base64 but invalid key data
513        let result: Result<PublicKey, _> = serde_json::from_str("\"aGVsbG8gd29ybGQ=\"");
514        assert!(result.is_err());
515
516        // Not a string
517        let result: Result<PublicKey, _> = serde_json::from_str("123");
518        assert!(result.is_err());
519    }
520
521    // A fixed RSA-2048 key pair (PKCS#8 / SPKI base64), reused from the encrypt/decrypt test.
522    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}