otplus_core/header/
wraps.rs

1use serde::{Serialize, Deserialize, Serializer, Deserializer};
2use serde::ser::SerializeStruct;
3use crate::helpers::Helpers;
4
5#[derive(Debug)]
6pub struct WrapsWithUserPassphrase {
7  pub dek_wrapped: Vec<u8>,
8  pub nonce: Vec<u8>,
9}
10
11impl WrapsWithUserPassphrase {
12  pub fn new(dek_wrapped: Vec<u8>, nonce: Vec<u8>) -> Self {
13    Self { dek_wrapped, nonce }
14  }
15}
16
17impl Serialize for WrapsWithUserPassphrase {
18  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
19  where
20    S: Serializer,
21  {
22    let mut state = serializer.serialize_struct("WrapsWithUserPassphrase", 2)?;
23    state.serialize_field("dek_wrapped", &Helpers::base64_encode(&self.dek_wrapped))?;
24    state.serialize_field("nonce", &Helpers::base64_encode(&self.nonce))?;
25    state.end()
26  }
27}
28
29impl<'de> Deserialize<'de> for WrapsWithUserPassphrase {
30  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
31  where
32    D: Deserializer<'de>,
33  {
34    #[derive(Deserialize)]
35    struct WrapsWithUserPassphraseHelper {
36      dek_wrapped: String,
37      nonce: String,
38    }
39
40    let helper = WrapsWithUserPassphraseHelper::deserialize(deserializer)?;
41    Ok(WrapsWithUserPassphrase::new(Helpers::base64_decode(&helper.dek_wrapped).unwrap(), Helpers::base64_decode(&helper.nonce).unwrap()))
42  }
43}
44
45#[derive(Debug)]
46pub struct WrapsWithOsKeychain {
47  pub dek_wrapped: Vec<u8>,
48  pub nonce: Vec<u8>,
49}
50
51impl WrapsWithOsKeychain {
52  pub fn new(dek_wrapped: Vec<u8>, nonce: Vec<u8>) -> Self {
53    Self { dek_wrapped, nonce }
54  }
55}
56
57impl Serialize for WrapsWithOsKeychain {
58  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
59  where
60    S: Serializer,
61  {
62    let mut state = serializer.serialize_struct("WrapsWithOsKeychain", 2)?;
63    state.serialize_field("dek_wrapped", &Helpers::base64_encode(&self.dek_wrapped))?;
64    state.serialize_field("nonce", &Helpers::base64_encode(&self.nonce))?;
65    state.end()
66  }
67}
68
69impl<'de> Deserialize<'de> for WrapsWithOsKeychain {
70  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71  where
72    D: Deserializer<'de>,
73  {
74    #[derive(Deserialize)]
75    struct WrapsWithOsKeychainHelper {
76      dek_wrapped: String,
77      nonce: String,
78    }
79
80    let helper = WrapsWithOsKeychainHelper::deserialize(deserializer)?;
81    Ok(WrapsWithOsKeychain::new(Helpers::base64_decode(&helper.dek_wrapped).unwrap(), Helpers::base64_decode(&helper.nonce).unwrap()))
82  }
83}
84
85#[derive(Debug)]
86pub struct Wraps {
87  pub from_user_passphrase: WrapsWithUserPassphrase,
88  pub from_os_keychain: WrapsWithOsKeychain,
89}
90
91impl Wraps {
92  pub fn new(from_user_passphrase: WrapsWithUserPassphrase, from_os_keychain: WrapsWithOsKeychain) -> Self {
93    Self { from_user_passphrase, from_os_keychain }
94  }
95}
96
97impl Serialize for Wraps {
98  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
99  where
100    S: Serializer,
101  {
102    let mut state = serializer.serialize_struct("Wraps", 2)?;
103    state.serialize_field("from_user_passphrase", &self.from_user_passphrase)?;
104    state.serialize_field("from_os_keychain", &self.from_os_keychain)?;
105    state.end()
106  }
107}
108
109impl<'de> Deserialize<'de> for Wraps {
110  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
111  where
112    D: Deserializer<'de>,
113  {
114    #[derive(Deserialize)]
115    struct WrapsHelper {
116      from_user_passphrase: WrapsWithUserPassphrase,
117      from_os_keychain: WrapsWithOsKeychain,
118    }
119
120    let helper = WrapsHelper::deserialize(deserializer)?;
121    Ok(Wraps::new(helper.from_user_passphrase, helper.from_os_keychain))
122  }
123}
otplus_core/header/wraps.rs

otplus_core/header/
wraps.rs
