1use 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
27const ENC_STRING_TYPE_SEPARATOR: char = '.';
30
31#[allow(clippy::large_enum_variant)]
38#[derive(Clone, Debug)]
39pub enum LegacyCompatSymmetricKeyEnvelope {
40 EncString(EncString),
42 SymmetricKeyEnvelope(SymmetricKeyEnvelope),
44}
45
46impl LegacyCompatSymmetricKeyEnvelope {
47 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 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 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 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 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
112fn 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 Ok(Self::EncString(EncString::from(s)))
135 }
136}
137
138#[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 #[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 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 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 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 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 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}