Skip to main content

bitwarden_crypto/compat/
legacy_compat_symmetric_key_envelope.rs

1//! A wrapped symmetric key that is either a legacy [`EncString`] or a [`SymmetricKeyEnvelope`].
2//!
3//! Use it as the type of a stored wrapped-key field while migrating from [`EncString`] to
4//! [`SymmetricKeyEnvelope`]: both formats deserialize, [`LegacyCompatSymmetricKeyEnvelope::seal`]
5//! always produces the envelope, [`LegacyCompatSymmetricKeyEnvelope::seal_legacy`] the
6//! [`EncString`].
7//!
8//! In order to migrate, add support via `seal_legacy`, then three full releases later, switch to
9//! `seal`. This is a breaking change: older clients cannot read the envelope.
10//!
11//! ```text
12//!   stored field ──deserialize──► EncString ──────────────┐
13//!                               └► SymmetricKeyEnvelope ──┴─unseal─► key ─seal─► SymmetricKeyEnvelope
14//! ```
15
16use std::str::FromStr;
17
18use bitwarden_encoding::{B64, FromStrVisitor};
19use serde::{Deserialize, Serialize};
20
21use crate::{
22    CryptoError, EncString, KeySlotIds, KeyStoreContext,
23    keys::KeyId,
24    safe::{SymmetricKeyEnvelope, SymmetricKeyEnvelopeError, SymmetricKeyEnvelopeNamespace},
25};
26
27/// Separates the type prefix from the payload in an [`EncString`], e.g. `2.iv|data|mac`. Base64,
28/// used by [`SymmetricKeyEnvelope`], never contains it.
29const ENC_STRING_TYPE_SEPARATOR: char = '.';
30
31/// A symmetric key wrapped either as a legacy [`EncString`] or as a [`SymmetricKeyEnvelope`].
32///
33/// In order to migrate, add support via [`seal_legacy`](Self::seal_legacy), then three full
34/// releases later, switch to [`seal`](Self::seal). This is a breaking change.
35///
36/// See the [migration example](https://github.com/bitwarden/sdk-internal/blob/main/crates/bitwarden-crypto/examples/migrate_wrapped_symmetric_key_from_encstring.rs).
37#[allow(clippy::large_enum_variant)]
38#[derive(Clone, Debug)]
39pub enum LegacyCompatSymmetricKeyEnvelope {
40    /// Legacy format. Has no namespace, so the namespace is not validated on unseal.
41    EncString(EncString),
42    /// Current format.
43    SymmetricKeyEnvelope(SymmetricKeyEnvelope),
44}
45
46impl LegacyCompatSymmetricKeyEnvelope {
47    /// Seals a symmetric key with an XAES-256-GCM or AES-256-CBC-HMAC key from the key store.
48    /// Always produces the [`SymmetricKeyEnvelope`] variant.
49    pub fn seal<Ids: KeySlotIds>(
50        key_to_seal: Ids::Symmetric,
51        sealing_key: Ids::Symmetric,
52        namespace: SymmetricKeyEnvelopeNamespace,
53        ctx: &KeyStoreContext<Ids>,
54    ) -> Result<Self, SymmetricKeyEnvelopeError> {
55        SymmetricKeyEnvelope::seal(key_to_seal, sealing_key, namespace, ctx)
56            .map(Self::SymmetricKeyEnvelope)
57    }
58
59    /// Seals a symmetric key as a legacy [`EncString`], readable by clients that predate
60    /// [`SymmetricKeyEnvelope`]. Always produces the [`EncString`] variant. The `namespace` is
61    /// unused; it keeps the signature identical to [`seal`](Self::seal).
62    ///
63    /// In order to migrate, add support via `seal_legacy`, then three full releases later, switch
64    /// to `seal`. This is a breaking change.
65    pub fn seal_legacy<Ids: KeySlotIds>(
66        key_to_seal: Ids::Symmetric,
67        sealing_key: Ids::Symmetric,
68        _namespace: SymmetricKeyEnvelopeNamespace,
69        ctx: &KeyStoreContext<Ids>,
70    ) -> Result<Self, SymmetricKeyEnvelopeError> {
71        ctx.wrap_symmetric_key(sealing_key, key_to_seal)
72            .map(Self::EncString)
73            .map_err(map_legacy_error)
74    }
75
76    /// Unseals a symmetric key and stores it in the key store context.
77    ///
78    /// The `namespace` is only validated for the [`SymmetricKeyEnvelope`] variant.
79    pub fn unseal<Ids: KeySlotIds>(
80        &self,
81        wrapping_key: Ids::Symmetric,
82        namespace: SymmetricKeyEnvelopeNamespace,
83        ctx: &mut KeyStoreContext<Ids>,
84    ) -> Result<Ids::Symmetric, SymmetricKeyEnvelopeError> {
85        match self {
86            Self::SymmetricKeyEnvelope(envelope) => envelope.unseal(wrapping_key, namespace, ctx),
87            Self::EncString(enc_string) => ctx
88                .unwrap_symmetric_key(wrapping_key, enc_string)
89                .map_err(map_legacy_error),
90        }
91    }
92
93    /// Get the key ID of the contained key. Returns `None` for the [`EncString`]
94    pub fn contained_key_id(&self) -> Result<Option<KeyId>, SymmetricKeyEnvelopeError> {
95        match self {
96            Self::SymmetricKeyEnvelope(envelope) => envelope.contained_key_id(),
97            Self::EncString(_) => Ok(None),
98        }
99    }
100
101    /// Get the key ID of the key this was sealed with. Always present for the
102    /// [`SymmetricKeyEnvelope`] variant; for the [`EncString`] variant, see
103    /// [`EncString::key_id`].
104    pub fn encrypted_by_key_id(&self) -> Result<Option<KeyId>, SymmetricKeyEnvelopeError> {
105        match self {
106            Self::SymmetricKeyEnvelope(envelope) => envelope.encrypted_by_key_id().map(Some),
107            Self::EncString(enc_string) => Ok(enc_string.key_id()),
108        }
109    }
110}
111
112/// Maps key store [`EncString`] wrap/unwrap errors onto the envelope error type.
113fn map_legacy_error(error: CryptoError) -> SymmetricKeyEnvelopeError {
114    match error {
115        CryptoError::MissingKeyId(_) => SymmetricKeyEnvelopeError::KeyMissing,
116        CryptoError::ReadOnlyKeyStore => SymmetricKeyEnvelopeError::KeyStore,
117        CryptoError::InvalidKey
118        | CryptoError::WrongKeyType
119        | CryptoError::OperationNotSupported(_) => SymmetricKeyEnvelopeError::WrongKeyType,
120        _ => SymmetricKeyEnvelopeError::WrongKey,
121    }
122}
123
124impl FromStr for LegacyCompatSymmetricKeyEnvelope {
125    type Err = SymmetricKeyEnvelopeError;
126
127    fn from_str(s: &str) -> Result<Self, Self::Err> {
128        if !s.contains(ENC_STRING_TYPE_SEPARATOR) {
129            return SymmetricKeyEnvelope::from_str(s).map(Self::SymmetricKeyEnvelope);
130        }
131
132        // Lax parsing: malformed EncStrings become `EncString::Unparseable`, preserving the raw
133        // value on re-serialization. They fail on unseal instead.
134        Ok(Self::EncString(EncString::from(s)))
135    }
136}
137
138// `Display` is not implemented, matching [`EncString`]: `Debug` prints the decoded value,
139// `ToString` the serialized form.
140#[allow(clippy::to_string_trait_impl)]
141impl ToString for LegacyCompatSymmetricKeyEnvelope {
142    fn to_string(&self) -> String {
143        match self {
144            Self::EncString(enc_string) => enc_string.to_string(),
145            Self::SymmetricKeyEnvelope(envelope) => {
146                let serialized: Vec<u8> = envelope.into();
147                B64::from(serialized).to_string()
148            }
149        }
150    }
151}
152
153impl<'de> Deserialize<'de> for LegacyCompatSymmetricKeyEnvelope {
154    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
155    where
156        D: serde::Deserializer<'de>,
157    {
158        deserializer.deserialize_str(FromStrVisitor::new())
159    }
160}
161
162impl Serialize for LegacyCompatSymmetricKeyEnvelope {
163    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
164    where
165        S: serde::Serializer,
166    {
167        match self {
168            Self::EncString(enc_string) => enc_string.serialize(serializer),
169            Self::SymmetricKeyEnvelope(envelope) => envelope.serialize(serializer),
170        }
171    }
172}
173
174#[cfg(feature = "wasm")]
175#[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
176const TS_CUSTOM_TYPES: &'static str = r#"
177export type LegacyCompatSymmetricKeyEnvelope = Tagged<string, "LegacyCompatSymmetricKeyEnvelope">;
178"#;
179
180bitwarden_ffi::impl_wire_string!(LegacyCompatSymmetricKeyEnvelope);
181
182#[cfg(test)]
183mod tests {
184    use super::*;
185    use crate::{KeyStore, SymmetricCryptoKey, SymmetricKeyAlgorithm, traits::tests::TestIds};
186
187    const NAMESPACE: SymmetricKeyEnvelopeNamespace =
188        SymmetricKeyEnvelopeNamespace::ExampleNamespace;
189
190    /// A stored struct with a wrapped-key field, as a consumer would declare it.
191    #[derive(Serialize, Deserialize)]
192    #[serde(rename_all = "camelCase")]
193    struct WrappedKeyContainer {
194        wrapped_key: LegacyCompatSymmetricKeyEnvelope,
195    }
196
197    const TEST_VECTOR_KEY_TO_SEAL: &str =
198        "BcyEWu7YAzYvJ7yS2apoqVZnQAGaIcqJ7bF3gZ6+M+PZOFCySUQFgfSsasWzMZ3FvuW+Dfs2XCpcY6u7Pro8Ng==";
199
200    const TEST_VECTOR_ENCSTRING_AES256_CBC_HMAC_WRAPPING_KEY: &str =
201        "zJn720+PbyN69qSpCQsC2kU26ZculfxQsEbpsl7DV3PC1/4yCT6UF+iZJ9r9iguxQOxvXZuLSdcnwgcAke4oxA==";
202    const TEST_VECTOR_ENCSTRING_AES256_CBC_HMAC_JSON: &str = r#"{"wrappedKey":"2.hfUXMlC62NcbqULcned9JA==|Zs89DYhe9NvTI8cah/LqGZ11BmBNWlC+Xb/Oh7JtnbNCgSfcP816wFAf3OKR0ScLmZUE/AlgFqTp8ababErTloYGezAbt82OWHFdcw8ABhE=|ZqdshXwOPKOv8f/sRQTlu1Hym8ZJnvUoX7GCxxagOdc="}"#;
203
204    const TEST_VECTOR_ENCSTRING_XAES256_GCM_WRAPPING_KEY: &str = "pQEEAlD+ZvKs0+kPMMTp4ClHkzQwAzoAARF5BIQDBAUGIFgg4FkbxCaU91bbTVw3e1cUO6S2oTqSISiySl5LrSfwOt8B";
205    const TEST_VECTOR_ENCSTRING_XAES256_GCM_JSON: &str = r#"{"wrappedKey":"7.g1g+owE6AAEReQN4ImFwcGxpY2F0aW9uL3guYml0d2FyZGVuLmxlZ2FjeS1rZXkEUP5m8qzT6Q8wxOngKUeTNDChBVgYL4b8GbJ/8WekzkDiaijkGjFrpCco13sAWFDd+iZoFmFx6kspDvvpTpgtyyJ2z0pxISAEK7rnhK3YWoIiQ7O7kPgrM/tAU2juD2mUzdhbCF5kO7wQwhd54QJ91i2B3ySFccRAugZngAjKag=="}"#;
206
207    const TEST_VECTOR_ENVELOPE_AES256_CBC_HMAC_AEAD_WRAPPING_KEY: &str =
208        "+SsIO7+WtSM4LYvxoDTTCO8kU5uZ0UwDmjdsv8K/+dfHOfQV8pXJI3buVwtCZJAoAd+1teXUVckZeme9CkjDEQ==";
209    const TEST_VECTOR_ENVELOPE_AES256_CBC_HMAC_AEAD_JSON: &str = r#"{"wrappedKey":"g1hgpgE6AAERegN4ImFwcGxpY2F0aW9uL3guYml0d2FyZGVuLmxlZ2FjeS1rZXkEUMlGtgwr6Y+fKwZUHeZw2M86AAEVXFBOFUXyYMu3MZtMG0+1s6weOgABOIEDOgABOIAioQVQokk1hPwmXf8MTufSj/kmXlhwneWfBQhZIqbfTLYNcurzmH4R1WL3B3o+rlsCve9kUpEgGCdVyw/jE1oKF+wXKIfhnbmFOxj4vONQPR9/Gy4QCF8Jy0LrbXCX0rYSbMGN3cv2ZLxoma3GjHbYZaEvEmhazFq0pIq3wp0S7jGnv4+0/A=="}"#;
210
211    const TEST_VECTOR_ENVELOPE_XAES256_GCM_WRAPPING_KEY: &str = "pQEEAlDPARaWmpuJo+0BSEH+0Z8mAzoAARF5BIQDBAUGIFggQ95pSAOYnJtK9FggeIO8QBDtb/vr9LIM4wb+/W3pI8MB";
212    const TEST_VECTOR_ENVELOPE_XAES256_GCM_JSON: &str = r#"{"wrappedKey":"g1hgpgE6AAEReQN4ImFwcGxpY2F0aW9uL3guYml0d2FyZGVuLmxlZ2FjeS1rZXkEUM8BFpaam4mj7QFIQf7RnyY6AAEVXFBOFUXyYMu3MZtMG0+1s6weOgABOIEDOgABOIAioQVYGC3aRnWqCU2AKkSnIhnvuw0BL4U239v5iVhQ6RpmuYoqvK660Q17JeCRvywXvfM0fQ6OccdJBBQr/RxE5D4N4rwp2T1tPWLRP0K40wfL/pNb4nKdPVY4GBe4dSlT5RN+UKabC7oe8YbpUVU="}"#;
213
214    fn to_b64(ctx: &KeyStoreContext<TestIds>, key: <TestIds as KeySlotIds>::Symmetric) -> String {
215        B64::from(ctx.get_symmetric_key(key).unwrap().to_encoded().to_vec()).to_string()
216    }
217
218    fn to_json(wrapped_key: LegacyCompatSymmetricKeyEnvelope) -> String {
219        serde_json::to_string(&WrappedKeyContainer { wrapped_key }).unwrap()
220    }
221
222    #[test]
223    #[ignore = "Generates test vectors; run manually"]
224    fn generate_test_vectors() {
225        let key_store = KeyStore::<TestIds>::default();
226        let mut ctx = key_store.context_mut();
227
228        let key_to_seal = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
229        println!(
230            "const TEST_VECTOR_KEY_TO_SEAL: &str = \"{}\";",
231            to_b64(&ctx, key_to_seal)
232        );
233
234        // Legacy EncString vectors, produced the way existing clients wrap keys.
235        for (name, algorithm) in [
236            (
237                "ENCSTRING_AES256_CBC_HMAC",
238                SymmetricKeyAlgorithm::Aes256CbcHmac,
239            ),
240            ("ENCSTRING_XAES256_GCM", SymmetricKeyAlgorithm::XAes256Gcm),
241        ] {
242            let wrapping_key = ctx.make_symmetric_key(algorithm);
243            let wrapped = ctx.wrap_symmetric_key(wrapping_key, key_to_seal).unwrap();
244            print_vector(
245                name,
246                &to_b64(&ctx, wrapping_key),
247                &to_json(LegacyCompatSymmetricKeyEnvelope::EncString(wrapped)),
248            );
249        }
250
251        // SymmetricKeyEnvelope vectors.
252        for (name, algorithm) in [
253            (
254                "ENVELOPE_AES256_CBC_HMAC_AEAD",
255                SymmetricKeyAlgorithm::Aes256CbcHmac,
256            ),
257            ("ENVELOPE_XAES256_GCM", SymmetricKeyAlgorithm::XAes256Gcm),
258        ] {
259            let wrapping_key = ctx.make_symmetric_key(algorithm);
260            let sealed =
261                LegacyCompatSymmetricKeyEnvelope::seal(key_to_seal, wrapping_key, NAMESPACE, &ctx)
262                    .unwrap();
263            print_vector(name, &to_b64(&ctx, wrapping_key), &to_json(sealed));
264        }
265    }
266
267    fn print_vector(name: &str, wrapping_key: &str, json: &str) {
268        println!("const TEST_VECTOR_{name}_WRAPPING_KEY: &str = \"{wrapping_key}\";");
269        println!("const TEST_VECTOR_{name}_JSON: &str = r#\"{json}\"#;");
270    }
271
272    /// Deserializes a JSON test vector, checks the variant, unseals it, and checks it re-serializes
273    /// to the same JSON.
274    fn assert_test_vector(wrapping_key: &str, json: &str, expect_enc_string: bool) {
275        let key_store = KeyStore::<TestIds>::default();
276        let mut ctx = key_store.context_mut();
277
278        let wrapping_key = SymmetricCryptoKey::try_from(wrapping_key.to_string()).unwrap();
279        let wrapping_key = ctx.add_local_symmetric_key(wrapping_key);
280        let expected_key =
281            SymmetricCryptoKey::try_from(TEST_VECTOR_KEY_TO_SEAL.to_string()).unwrap();
282
283        let container: WrappedKeyContainer = serde_json::from_str(json).unwrap();
284        assert_eq!(
285            matches!(
286                container.wrapped_key,
287                LegacyCompatSymmetricKeyEnvelope::EncString(_)
288            ),
289            expect_enc_string
290        );
291
292        let unsealed = container
293            .wrapped_key
294            .unseal(wrapping_key, NAMESPACE, &mut ctx)
295            .unwrap();
296        assert_eq!(ctx.get_symmetric_key(unsealed).unwrap(), &expected_key);
297
298        assert_eq!(serde_json::to_string(&container).unwrap(), json);
299    }
300
301    #[test]
302    fn test_vector_encstring_aes256_cbc_hmac() {
303        assert_test_vector(
304            TEST_VECTOR_ENCSTRING_AES256_CBC_HMAC_WRAPPING_KEY,
305            TEST_VECTOR_ENCSTRING_AES256_CBC_HMAC_JSON,
306            true,
307        );
308    }
309
310    #[test]
311    fn test_vector_encstring_xaes256_gcm() {
312        assert_test_vector(
313            TEST_VECTOR_ENCSTRING_XAES256_GCM_WRAPPING_KEY,
314            TEST_VECTOR_ENCSTRING_XAES256_GCM_JSON,
315            true,
316        );
317    }
318
319    #[test]
320    fn test_vector_envelope_aes256_cbc_hmac_aead() {
321        assert_test_vector(
322            TEST_VECTOR_ENVELOPE_AES256_CBC_HMAC_AEAD_WRAPPING_KEY,
323            TEST_VECTOR_ENVELOPE_AES256_CBC_HMAC_AEAD_JSON,
324            false,
325        );
326    }
327
328    #[test]
329    fn test_vector_envelope_xaes256_gcm() {
330        assert_test_vector(
331            TEST_VECTOR_ENVELOPE_XAES256_GCM_WRAPPING_KEY,
332            TEST_VECTOR_ENVELOPE_XAES256_GCM_JSON,
333            false,
334        );
335    }
336
337    #[test]
338    fn test_vector_encrypted_by_key_id() {
339        // EncString type 2 carries no key ID; every other format names its wrapping key.
340        for (wrapping_key, json, has_key_id) in [
341            (
342                TEST_VECTOR_ENCSTRING_AES256_CBC_HMAC_WRAPPING_KEY,
343                TEST_VECTOR_ENCSTRING_AES256_CBC_HMAC_JSON,
344                false,
345            ),
346            (
347                TEST_VECTOR_ENCSTRING_XAES256_GCM_WRAPPING_KEY,
348                TEST_VECTOR_ENCSTRING_XAES256_GCM_JSON,
349                true,
350            ),
351            (
352                TEST_VECTOR_ENVELOPE_AES256_CBC_HMAC_AEAD_WRAPPING_KEY,
353                TEST_VECTOR_ENVELOPE_AES256_CBC_HMAC_AEAD_JSON,
354                true,
355            ),
356            (
357                TEST_VECTOR_ENVELOPE_XAES256_GCM_WRAPPING_KEY,
358                TEST_VECTOR_ENVELOPE_XAES256_GCM_JSON,
359                true,
360            ),
361        ] {
362            let wrapping_key = SymmetricCryptoKey::try_from(wrapping_key.to_string()).unwrap();
363            let container: WrappedKeyContainer = serde_json::from_str(json).unwrap();
364
365            let expected = has_key_id.then(|| wrapping_key.key_id()).flatten();
366            assert_eq!(
367                container.wrapped_key.encrypted_by_key_id().unwrap(),
368                expected
369            );
370        }
371    }
372
373    #[test]
374    fn test_seal_produces_envelope_and_unseals() {
375        let key_store = KeyStore::<TestIds>::default();
376        let mut ctx = key_store.context_mut();
377
378        let key_to_seal = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
379        let wrapping_key = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
380
381        let sealed =
382            LegacyCompatSymmetricKeyEnvelope::seal(key_to_seal, wrapping_key, NAMESPACE, &ctx)
383                .unwrap();
384        assert!(matches!(
385            sealed,
386            LegacyCompatSymmetricKeyEnvelope::SymmetricKeyEnvelope(_)
387        ));
388
389        let unsealed = sealed.unseal(wrapping_key, NAMESPACE, &mut ctx).unwrap();
390        ctx.assert_symmetric_keys_equal(unsealed, key_to_seal);
391    }
392
393    #[test]
394    fn test_seal_legacy_produces_encstring_and_unseals() {
395        let key_store = KeyStore::<TestIds>::default();
396        let mut ctx = key_store.context_mut();
397
398        let key_to_seal = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
399
400        for algorithm in [
401            SymmetricKeyAlgorithm::Aes256CbcHmac,
402            SymmetricKeyAlgorithm::XAes256Gcm,
403        ] {
404            let wrapping_key = ctx.make_symmetric_key(algorithm);
405
406            let sealed = LegacyCompatSymmetricKeyEnvelope::seal_legacy(
407                key_to_seal,
408                wrapping_key,
409                NAMESPACE,
410                &ctx,
411            )
412            .unwrap();
413            assert!(matches!(
414                sealed,
415                LegacyCompatSymmetricKeyEnvelope::EncString(_)
416            ));
417
418            let unsealed = sealed.unseal(wrapping_key, NAMESPACE, &mut ctx).unwrap();
419            ctx.assert_symmetric_keys_equal(unsealed, key_to_seal);
420        }
421    }
422
423    #[test]
424    fn test_string_round_trip_preserves_variant() {
425        let key_store = KeyStore::<TestIds>::default();
426        let mut ctx = key_store.context_mut();
427
428        let key_to_seal = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
429        let wrapping_key = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
430
431        let enc_string = LegacyCompatSymmetricKeyEnvelope::EncString(
432            ctx.wrap_symmetric_key(wrapping_key, key_to_seal).unwrap(),
433        );
434        let envelope =
435            LegacyCompatSymmetricKeyEnvelope::seal(key_to_seal, wrapping_key, NAMESPACE, &ctx)
436                .unwrap();
437
438        for wrapped in [enc_string, envelope] {
439            let is_enc_string = matches!(wrapped, LegacyCompatSymmetricKeyEnvelope::EncString(_));
440
441            let string = wrapped.to_string();
442            let parsed = LegacyCompatSymmetricKeyEnvelope::from_str(&string).unwrap();
443
444            assert_eq!(
445                matches!(parsed, LegacyCompatSymmetricKeyEnvelope::EncString(_)),
446                is_enc_string
447            );
448            let unsealed = parsed.unseal(wrapping_key, NAMESPACE, &mut ctx).unwrap();
449            ctx.assert_symmetric_keys_equal(unsealed, key_to_seal);
450        }
451    }
452
453    #[test]
454    fn test_encstring_wrong_key() {
455        let key_store = KeyStore::<TestIds>::default();
456        let mut ctx = key_store.context_mut();
457
458        let key_to_seal = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
459        let wrapping_key = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
460        let wrong_key = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
461
462        let wrapped = LegacyCompatSymmetricKeyEnvelope::EncString(
463            ctx.wrap_symmetric_key(wrapping_key, key_to_seal).unwrap(),
464        );
465
466        assert!(matches!(
467            wrapped.unseal(wrong_key, NAMESPACE, &mut ctx),
468            Err(SymmetricKeyEnvelopeError::WrongKey)
469        ));
470        assert_eq!(wrapped.contained_key_id().unwrap(), None);
471    }
472
473    #[test]
474    fn test_unparseable_input_errors() {
475        let key_store = KeyStore::<TestIds>::default();
476        let mut ctx = key_store.context_mut();
477        let wrapping_key = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
478
479        // Malformed EncStrings parse laxly, round-trip unchanged, and fail on unseal.
480        let unparseable = LegacyCompatSymmetricKeyEnvelope::from_str("9.garbage").unwrap();
481        assert_eq!(unparseable.to_string(), "9.garbage");
482        assert!(
483            unparseable
484                .unseal(wrapping_key, NAMESPACE, &mut ctx)
485                .is_err()
486        );
487
488        assert!(LegacyCompatSymmetricKeyEnvelope::from_str("not base64!").is_err());
489    }
490}