Skip to main content

bitwarden_vault/cipher/blob/
v1.rs

1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3
4use crate::cipher::{
5    field::FieldType, linked_id::LinkedIdType, login::UriMatchType, secure_note::SecureNoteType,
6};
7
8#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
9#[serde(rename_all = "camelCase")]
10pub(crate) struct CipherBlobV1 {
11    pub name: String,
12    pub notes: Option<String>,
13    pub type_data: CipherTypeDataV1,
14    #[serde(default, skip_serializing_if = "Vec::is_empty")]
15    pub fields: Vec<FieldDataV1>,
16    #[serde(default, skip_serializing_if = "Vec::is_empty")]
17    pub password_history: Vec<PasswordHistoryDataV1>,
18}
19
20impl bitwarden_crypto::safe::SealableData for CipherBlobV1 {}
21
22// IdentityDataV1 is significantly larger than other variants (432 bytes vs ~144 bytes).
23// Boxing could be considered if this becomes a performance concern, but since these types are
24// only constructed during deserialization from encrypted blobs, the stack size is acceptable.
25#[allow(clippy::large_enum_variant)]
26#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
27#[serde(tag = "type", rename_all = "camelCase")]
28pub(crate) enum CipherTypeDataV1 {
29    Login(LoginDataV1),
30    Card(CardDataV1),
31    Identity(IdentityDataV1),
32    SecureNote(SecureNoteDataV1),
33    SshKey(SshKeyDataV1),
34    BankAccount(BankAccountDataV1),
35    Passport(PassportDataV1),
36    DriversLicense(DriversLicenseDataV1),
37}
38
39#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
40#[serde(rename_all = "camelCase")]
41pub(crate) struct LoginDataV1 {
42    pub username: Option<String>,
43    pub password: Option<String>,
44    pub password_revision_date: Option<DateTime<Utc>>,
45    #[serde(default, skip_serializing_if = "Vec::is_empty")]
46    pub uris: Vec<LoginUriDataV1>,
47    pub totp: Option<String>,
48    pub autofill_on_page_load: Option<bool>,
49    /// Defaults to `false` for blobs sealed before the setting existed.
50    #[serde(default)]
51    pub http_authentication_enabled: bool,
52    #[serde(default, skip_serializing_if = "Vec::is_empty")]
53    pub fido2_credentials: Vec<Fido2CredentialDataV1>,
54}
55
56#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
57#[serde(rename_all = "camelCase")]
58pub(crate) struct LoginUriDataV1 {
59    pub uri: Option<String>,
60    pub r#match: Option<UriMatchType>,
61}
62
63#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
64#[serde(rename_all = "camelCase")]
65pub(crate) struct Fido2CredentialDataV1 {
66    pub credential_id: String,
67    pub key_type: String,
68    pub key_algorithm: String,
69    pub key_curve: String,
70    pub key_value: String,
71    pub rp_id: String,
72    pub user_handle: Option<String>,
73    pub user_name: Option<String>,
74    pub counter: u64,
75    pub rp_name: Option<String>,
76    pub user_display_name: Option<String>,
77    pub discoverable: bool,
78    pub creation_date: DateTime<Utc>,
79}
80
81#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
82#[serde(rename_all = "camelCase")]
83pub(crate) struct CardDataV1 {
84    pub cardholder_name: Option<String>,
85    pub exp_month: Option<String>,
86    pub exp_year: Option<String>,
87    pub code: Option<String>,
88    pub brand: Option<String>,
89    pub number: Option<String>,
90}
91
92#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
93#[serde(rename_all = "camelCase")]
94pub(crate) struct IdentityDataV1 {
95    pub title: Option<String>,
96    pub first_name: Option<String>,
97    pub middle_name: Option<String>,
98    pub last_name: Option<String>,
99    pub address1: Option<String>,
100    pub address2: Option<String>,
101    pub address3: Option<String>,
102    pub city: Option<String>,
103    pub state: Option<String>,
104    pub postal_code: Option<String>,
105    pub country: Option<String>,
106    pub company: Option<String>,
107    pub email: Option<String>,
108    pub phone: Option<String>,
109    pub ssn: Option<String>,
110    pub username: Option<String>,
111    pub passport_number: Option<String>,
112    pub license_number: Option<String>,
113}
114
115#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
116#[serde(rename_all = "camelCase")]
117pub(crate) struct SecureNoteDataV1 {
118    #[serde(rename = "secureNoteType")]
119    pub r#type: SecureNoteType,
120}
121
122#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
123#[serde(rename_all = "camelCase")]
124pub(crate) struct SshKeyDataV1 {
125    pub private_key: String,
126    pub public_key: String,
127    pub fingerprint: String,
128}
129
130#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
131#[serde(rename_all = "camelCase")]
132pub(crate) struct PassportDataV1 {
133    pub surname: Option<String>,
134    pub given_name: Option<String>,
135    pub date_of_birth: Option<String>,
136    pub sex: Option<String>,
137    pub birth_place: Option<String>,
138    pub nationality: Option<String>,
139    pub issuing_country: Option<String>,
140    pub passport_number: Option<String>,
141    pub passport_type: Option<String>,
142    pub national_identification_number: Option<String>,
143    pub issuing_authority: Option<String>,
144    pub issue_date: Option<String>,
145    pub expiration_date: Option<String>,
146}
147
148#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
149#[serde(rename_all = "camelCase")]
150pub(crate) struct DriversLicenseDataV1 {
151    pub first_name: Option<String>,
152    pub middle_name: Option<String>,
153    pub last_name: Option<String>,
154    pub date_of_birth: Option<String>,
155    pub license_number: Option<String>,
156    pub issuing_country: Option<String>,
157    pub issuing_state: Option<String>,
158    pub issue_date: Option<String>,
159    pub expiration_date: Option<String>,
160    pub issuing_authority: Option<String>,
161    pub license_class: Option<String>,
162}
163
164#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
165#[serde(rename_all = "camelCase")]
166pub(crate) struct BankAccountDataV1 {
167    pub bank_name: Option<String>,
168    pub name_on_account: Option<String>,
169    pub account_type: Option<String>,
170    pub account_number: Option<String>,
171    pub routing_number: Option<String>,
172    pub branch_number: Option<String>,
173    pub pin: Option<String>,
174    pub swift_code: Option<String>,
175    pub iban: Option<String>,
176    pub bank_contact_phone: Option<String>,
177}
178
179#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
180#[serde(rename_all = "camelCase")]
181pub(crate) struct FieldDataV1 {
182    pub name: Option<String>,
183    pub value: Option<String>,
184    pub r#type: FieldType,
185    pub linked_id: Option<LinkedIdType>,
186}
187
188#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
189#[serde(rename_all = "camelCase")]
190pub(crate) struct PasswordHistoryDataV1 {
191    pub password: String,
192    pub last_used_date: DateTime<Utc>,
193}
194
195#[cfg(test)]
196mod tests {
197    use bitwarden_core::key_management::KeySlotIds;
198    use bitwarden_crypto::{KeyStore, SymmetricCryptoKey, safe::DataEnvelope};
199    use bitwarden_encoding::B64;
200    use chrono::TimeZone;
201
202    use super::*;
203    use crate::cipher::{
204        blob::CipherBlob, linked_id::LoginLinkedIdType, secure_note::SecureNoteType,
205    };
206
207    const TEST_VECTOR_SECURE_NOTE_CEK: &str =
208        "pQEEAlApYxU9rgfIc9v9sHuglhkKAzoAARFvBIEEIFggDKYmieFA7a0UoOMAt4BErOpk7VfwZI8Dk0Yc9FxFzWIB";
209    const TEST_VECTOR_SECURE_NOTE_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFApYxU9rgfIc9v9sHuglhkKOgABOIECOgABOIABoQVYGMihknYX7mrmC03/w0V7rTMij2+q237p21h2H2Sq0hnlzZ4ka8yMW1yFOOMSt5ZS3tNQxzT07qeeY10tAeczgizA2g5AvmIQJdXK+7KR5mP3zk5VaVfGjC9mZUUFXwIAXsxC16HUII7Z1Iwhpd+MrJDf+itZGFVd07ExaXkH5+MjfaXhJqXBSxAStCG5zLGsEg==";
210
211    const TEST_VECTOR_LOGIN_CEK: &str =
212        "pQEEAlClJ9tO9x8fN2JVe5N8uzAaAzoAARFvBIEEIFggZwJXkLK7A6Sy5Y9+dacJrzCg9bo4RMRxXaRGDWYfbTYB";
213    const TEST_VECTOR_LOGIN_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFClJ9tO9x8fN2JVe5N8uzAaOgABOIECOgABOIABoQVYGNYP1rgAT3D2T6q2lGTRjIPHR2IELUDWE1kC2erlZM4Dqyeew1VlDkdXnZIE+t2g4SJh8IFSHo9WuzmyY+qC+V9cuGW3QHt+sg7pfZ5kQBh40U9uxUcxOHdVF3jQhcAmgB9abShR68u41NMDwwLSafG8PLzsUfhhxpCG0+ZuOda3tFVM1y5TyiDPJBBoJECuYK/K/1RLNAWAy5AU98yI0RgdK0MHxpoOqdSC8dXXu6fGgON7XLQWkkceFWILp0o51/c7OvdJ3B1nCiCIZjwAyS96+oWOzLrsPaGkBjqedBCi5iwelzLOttXk6nrzE/FfC0PkeeSsPSr9UdXBbeuUSK7wKtir9Lx/gtJ4sMPFidtTNdXCcDT9RA7y21h+3+wHQgGSlOGRigXFgXWi5ajSPCs9zLn7ERoG4BZ4IHa6EMSJbGH1pANW+Ibg4aadBF7LzOi/BZx2oZ/6z54XfAfqb44FR3/XXdNFHosPH9IH7CkKbNvLTuGrOTk9S998qFDNkWeGthrDYclaYSFktSHULvmHhSPadRL4uM6254HTmSjTAG6FDhhqdJU3SvoifrvBeHqjEP7F5R+zjVQol+JUcs/ExwmlrxXETOTzGyC/++FflZyPIUnH9U7ZqXhiYGd0ZvcyrnrnieehYToWFdwFR9ho+6h9hB/SCjhGudP5CRPZDL9GkNAUS5+pAd4ZC19fDjWpwMnEbgPTuthXKl6YRHxxCV+xpc9jncVQt9zF31e0bSIP7kVcdmlgjXaV6Nmd3aZ+PqeJnj27gCxG2tZkMimdJmEgxkL/cfvNHENg43+rpnV2mCTrCAO/X+RDGKdi7SIzsLesPVXVHEZCM4UBv2v+S/vpDFC3ie09cz525PCgt/7Je68k8S5WsTwKVeL0+T/ysqDo7wJvFSToY2G/LOGnBYMUYcCLfJGQbD8g2xI3oC+go8kcyVDJv+936/MkAYSxnvZDrMr30zEZaNm5YBh8cRqKr4MxOjJBk1XWjwDNsSQrDw==";
214
215    const TEST_VECTOR_CARD_CEK: &str =
216        "pQEEAlBqeNyImi1f1pMtJVlvDuV1AzoAARFvBIEEIFggyyOmMlDBj/oRic4qPjXnnKXGf4QGYMq7KvztZO3it+cB";
217    const TEST_VECTOR_CARD_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFBqeNyImi1f1pMtJVlvDuV1OgABOIECOgABOIABoQVYGHZO47yxMBN7r8jgWNJ8c+1bfUld0uzdNli2xQgFm6X0chG+qNdkiROVAUxi75+cN4jiTOzt41pG7bXyo7U4D8R38zR+l7jePi39w3YV4tnmxIenwBPK/0qdO8pLKUMwi8PMIBqJ2UxanLqRhP6Ru2i43rpVZMgAmasGgzGG8hhJttii1CidG8ntNP/zRvRl38F/7bphlN1a08/FeycdIAfQUf7tgzoaj1JegSwEs1M7/+ONHlPtlkmovN/zJTP0ZHL7U7NAt/JBIWbeScbGP6E=";
218
219    const TEST_VECTOR_IDENTITY_CEK: &str =
220        "pQEEAlBKyRoZr3LVRJsXJQ1msUhQAzoAARFvBIEEIFggVf/R4MMZFsa5DDtjjTG/1GozhF9jNQACFt9KpMpA9D8B";
221    const TEST_VECTOR_IDENTITY_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFBKyRoZr3LVRJsXJQ1msUhQOgABOIECOgABOIABoQVYGNZ9Ckqt+ftCL1eTn3LHTP/bLQVSiT2nFFkBl2ON9MRyKHrBCGlRlKxcGgMhFQhf3LY7kiDTjvvUhbZr3/rbc/fA8+7HS2UYu/SMOnxF4fg5AlBDc2kwE5iPqwJAJU4fnMqlQm+0jBAE2MS7oppPwHYh8cxDE9pqEa7Ehz1XygUgmUWtEpgGo2Nia+mdCnltws2X+uLCeAf6x5Ioc+HvFUIzFiYEN4WQ+NLmaCNrES9Zw9TXQTSh0drdPqaW7SSMjpBLk1TRtKX4hnSqE+tlRcfG24hPf214jG8On9tw1cdMQbF9GeC2FidfX+snjrU5psmje2bCcExfnvL7pgPeTV/R6+Fct0Jx5pKFXdTQM3SM1Ms8I+sq22sSc9Bu++V9nXFlLIyvWF9H/9FMYXrUR6HfBzSMJk7BSSin4wk/BKTEE59uaW+MtT/sDsW76aRo29VUqymbd5aezHCNxM8CFYaRGEXqWmakwXOPkqZh6CRhT3IZ6MjMQw2GbmDG+qv/KcbJatlKT1ZE6LUos/zpErOf0AT16D1WkS+9QwIeTP5QLv6F291nlBR2xDPg9v/cuauw";
222
223    const TEST_VECTOR_SSH_KEY_CEK: &str =
224        "pQEEAlApE2RsnNwb3+3FyIr/kcfWAzoAARFvBIEEIFggDk3igU6wYnicl6jRSYILSaPlDWYCjnRUqMLdqfPkVKAB";
225    const TEST_VECTOR_SSH_KEY_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFApE2RsnNwb3+3FyIr/kcfWOgABOIECOgABOIABoQVYGHPwqnuSuDHdwTg3twT5B0b3AXKVK+cySVkBSzorjdnfAdt1aNM32x3BPUg4QMkR99SQum3yc4eIT5eqi2FZjHyvEVPMwxfcWqg26g8UTc3dsRW57RYRF4ajx4+MGcJj+wWTrI8jPmthhLAnEHT11eC2YjYIW1INWKGFJTKnTjwHw1LTVJvEzA9MAZRk2y2NC+qkkdDM3wKmhl4PqoEPmt/x6qBjlR5+rlA4rUqkm9ja+NqqEbz8McGXBw8QWOh99/xE1PorFk7S+o9LW1Kcv1/GL+1wv6X7tTo1dYVYa2uCo9Hp9C8D5zXz/iVLm9w98NQFZQlteO8yibEOp+F/VNpgpsmZjOQzJ6wf0hKabFF2eXIUJ2RT1vJT+zUdcfc+TMkypaBbJEagmAiEBnZFcxVEhQ3tn1ZyJFRUcMzm91azIHQMmQ9cS6h/SqTGFF3z+q0H4+8w2S+yl+D5/OVWQHKcSOFvsPA=";
226
227    const TEST_VECTOR_BANK_ACCOUNT_CEK: &str =
228        "pQEEAlCz1mvOGP9yRKdx0pA5WbP7AzoAARFvBIEEIFggF30KGp58Duu4VcVvoFJ+Lhw1yEpfQvTUW2dvOP+WMd0B";
229    const TEST_VECTOR_BANK_ACCOUNT_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFCz1mvOGP9yRKdx0pA5WbP7OgABOIECOgABOIABoQVYGDbBFtW702QwCdi03+f9Uahq4Xf0bJ8i7VkBQxZB8XgvwLS13sHp8iz3VmTVcWJCyoxp6ycEUNSllpzURnZtfTsm9hkHCM0iFvMAXgDHBamHpI+8cX4sZ1qyjrGx4JDkGL1wDPUKMY7pLIN6alssjgYNl/6ijicWk2uNDneAGVgJdAHmxVKYPKbwYp0e8bLeAjgj6FOSFHaXv1a6TdF82iRCF/r5Uh/Ohx1FEbtRnaCSMJ4tLsf8YC9oq3duarJzSB2aINL9EnGAqqUlJ8cy8lyfkopUxV0OMnRWiHpja4CrEphhNeKKPoFRezsVoDYQ3f7kjryVAQ661gVxsEG3FB03+CcvVsT849QfrDcERxsQoKwy1E9yHaoE2kgWiYTHS+6gCH/gikDw1t4GBBUdjeJhP3bqQJbmM4cgRxWMgyswfFAfZok25kcA15EpHabkczydiPtnG2UW9qfu+bfw";
230
231    const TEST_VECTOR_PASSPORT_CEK: &str =
232        "pQEEAlBt4j9Ll1AOH1qIRqCdCyTpAzoAARFvBIEEIFggQRD5JRuLW/LBh6tOH9pwzI79EH/uwnkc1g7MmHnQxjsB";
233    const TEST_VECTOR_PASSPORT_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFBt4j9Ll1AOH1qIRqCdCyTpOgABOIECOgABOIABoQVYGMtbFi7dX35y8b7HfGSBUkExZu9xbwLdTVkBfk+53EwDwOJqa1BTtHaKepq8gpn3PD6tX7WmcgM/fMM9g1bqVlKEa9zAuAsjXXqc1jsTmy9J8+y6b9ExcP7JCCTZTNrNDpyghuQc+Xm4URgJMrXryg4aEi5rVD4bI6iI20IsM70ZA0jpvz0rNz6IcyL9zwL6f6aZRtIKAHxQ4AzmBnNItuZShM4UEDDgxGVpkOqTBhfh2DBogQMOAE8DNNbI91gMrj4SVf8zJXIIQhjHCeDJYWp4assoI+3kMyLuoPXSPCLqmvWMtQnQMU3BdONVl/WDtw2GUMp0PpuFVToc6IfieSRVJaFWxqRZpK4GNLECkR6YkZjz9kHg2tXFSi+77RWUg6ZkJ7zYX+vQ1GnnLQ0cWJtt2obwyHVpg8ejz83gAZHFaKN+LLdGW/wt/G188au4zpXjJTxxPSoy1/rd55mGoiwV/cc049L44cbmhjUkdaaiPv2Gtx1MhuM2bJaC2fdUqe4luzTwhzSCcPphwGkFcNM/mANHYwvdXiQ=";
234
235    const TEST_VECTOR_DRIVERS_LICENSE_CEK: &str =
236        "pQEEAlAAl+WJTHKGitbdU9BlEgYOAzoAARFvBIEEIFggvuVlFL4NaxQ6mc2tROVjCg20rDmr8CFy3+dmADa+1JsB";
237    const TEST_VECTOR_DRIVERS_LICENSE_ENVELOPE: &str = "g1hLpQE6AAERbwN4I2FwcGxpY2F0aW9uL3guYml0d2FyZGVuLmNib3ItcGFkZGVkBFAAl+WJTHKGitbdU9BlEgYOOgABOIECOgABOIABoQVYGJYtxnw1bOqtBrpNsa5PLUa6b21jEHl7zFkBUcdN1jS6PfqOuYVrIfqU73+jrZlq7jxK2Hcp8iGsnInC+wyXpWJety8XfWs2X3CfFSVmnO5nc58LWagfY6AAr66GWuE+HCJJ30QinqQ7NbjInJpOvGysXGnu1f5Mjk9Ow4cUobh4Nxp0rsrznwaUTskR0RJVdzoelutqBWLSvkrM1z81syz9QLdhbBRmv4A18/Bc1U85RWYUYhvxCCxsydp1HFmBNsNk3tS3wd/4svgNjpjnrvDLNxuN2o4cyQDdkTLPvQa98Ld0RCzh1D62zFxLlJ634NV6ROEstYN8CHaat3LIyaCzXjqMiEhP0v3JRWTsrJm6FwjZF8TULif4jrJcMdSdxXn7l6GGHwLBMvXRdYdfPqpgIc2CjPJUj62fa9Wx5aBVcDJRriznuaAWmeapcaxOeSOyG1QMpmYMRXJK8pqnkMH5mT4OGJTVeuLkrXM=";
238
239    fn test_blob_secure_note() -> CipherBlobV1 {
240        CipherBlobV1 {
241            name: "Test Secure Note".to_string(),
242            notes: Some("Some notes".to_string()),
243            type_data: CipherTypeDataV1::SecureNote(SecureNoteDataV1 {
244                r#type: SecureNoteType::Generic,
245            }),
246            fields: Vec::new(),
247            password_history: Vec::new(),
248        }
249    }
250
251    fn test_blob_login() -> CipherBlobV1 {
252        CipherBlobV1 {
253            name: "Test Login".to_string(),
254            notes: Some("Login notes".to_string()),
255            type_data: CipherTypeDataV1::Login(LoginDataV1 {
256                username: Some("[email protected]".to_string()),
257                password: Some("p@ssw0rd123".to_string()),
258                password_revision_date: Some(Utc.with_ymd_and_hms(2024, 1, 15, 12, 0, 0).unwrap()),
259                uris: vec![LoginUriDataV1 {
260                    uri: Some("https://example.com/login".to_string()),
261                    r#match: Some(UriMatchType::Domain),
262                }],
263                totp: Some("otpauth://totp/test?secret=JBSWY3DPEHPK3PXP".to_string()),
264                autofill_on_page_load: Some(true),
265                http_authentication_enabled: false,
266                fido2_credentials: vec![Fido2CredentialDataV1 {
267                    credential_id: "credential-id-123".to_string(),
268                    key_type: "public-key".to_string(),
269                    key_algorithm: "ECDSA".to_string(),
270                    key_curve: "P-256".to_string(),
271                    key_value: "key-value-base64".to_string(),
272                    rp_id: "example.com".to_string(),
273                    user_handle: Some("user-handle-456".to_string()),
274                    user_name: Some("testuser".to_string()),
275                    counter: 42,
276                    rp_name: Some("Example".to_string()),
277                    user_display_name: Some("Test User".to_string()),
278                    discoverable: true,
279                    creation_date: Utc.with_ymd_and_hms(2024, 6, 1, 10, 30, 0).unwrap(),
280                }],
281            }),
282            fields: vec![FieldDataV1 {
283                name: Some("Custom Field".to_string()),
284                value: Some("custom-value".to_string()),
285                r#type: FieldType::Linked,
286                linked_id: Some(LinkedIdType::Login(LoginLinkedIdType::Username)),
287            }],
288            password_history: vec![PasswordHistoryDataV1 {
289                password: "old-password-1".to_string(),
290                last_used_date: Utc.with_ymd_and_hms(2023, 12, 1, 8, 0, 0).unwrap(),
291            }],
292        }
293    }
294
295    fn test_blob_card() -> CipherBlobV1 {
296        CipherBlobV1 {
297            name: "Test Card".to_string(),
298            notes: Some("Card notes".to_string()),
299            type_data: CipherTypeDataV1::Card(CardDataV1 {
300                cardholder_name: Some("John Doe".to_string()),
301                exp_month: Some("12".to_string()),
302                exp_year: Some("2028".to_string()),
303                code: Some("123".to_string()),
304                brand: Some("Visa".to_string()),
305                number: Some("4111111111111111".to_string()),
306            }),
307            fields: Vec::new(),
308            password_history: Vec::new(),
309        }
310    }
311
312    fn test_blob_identity() -> CipherBlobV1 {
313        CipherBlobV1 {
314            name: "Test Identity".to_string(),
315            notes: Some("Identity notes".to_string()),
316            type_data: CipherTypeDataV1::Identity(IdentityDataV1 {
317                title: Some("Mr".to_string()),
318                first_name: Some("John".to_string()),
319                middle_name: Some("Michael".to_string()),
320                last_name: Some("Doe".to_string()),
321                address1: Some("123 Main St".to_string()),
322                address2: Some("Apt 4B".to_string()),
323                address3: Some("Building C".to_string()),
324                city: Some("New York".to_string()),
325                state: Some("NY".to_string()),
326                postal_code: Some("10001".to_string()),
327                country: Some("US".to_string()),
328                company: Some("Acme Corp".to_string()),
329                email: Some("[email protected]".to_string()),
330                phone: Some("555-0123".to_string()),
331                ssn: Some("123-45-6789".to_string()),
332                username: Some("johndoe".to_string()),
333                passport_number: Some("P12345678".to_string()),
334                license_number: Some("DL-987654".to_string()),
335            }),
336            fields: Vec::new(),
337            password_history: Vec::new(),
338        }
339    }
340
341    fn test_blob_ssh_key() -> CipherBlobV1 {
342        CipherBlobV1 {
343            name: "Test SSH Key".to_string(),
344            notes: Some("SSH key notes".to_string()),
345            type_data: CipherTypeDataV1::SshKey(SshKeyDataV1 {
346                private_key: "-----BEGIN OPENSSH PRIVATE KEY-----\nb3BlbnNzaC1rZXktdjEA\n-----END OPENSSH PRIVATE KEY-----".to_string(),
347                public_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI [email protected]".to_string(),
348                fingerprint: "SHA256:abcdefghijklmnopqrstuvwxyz012345678901234567".to_string(),
349            }),
350            fields: Vec::new(),
351            password_history: Vec::new(),
352        }
353    }
354
355    fn test_blob_bank_account() -> CipherBlobV1 {
356        CipherBlobV1 {
357            name: "Test Bank Account".to_string(),
358            notes: Some("Bank account notes".to_string()),
359            type_data: CipherTypeDataV1::BankAccount(BankAccountDataV1 {
360                bank_name: Some("Test Bank".to_string()),
361                name_on_account: Some("John Doe".to_string()),
362                account_type: Some("Checking".to_string()),
363                account_number: Some("1234567890".to_string()),
364                routing_number: Some("021000021".to_string()),
365                branch_number: Some("001".to_string()),
366                pin: Some("1234".to_string()),
367                swift_code: Some("TESTUS33".to_string()),
368                iban: Some("US12345678901234567890".to_string()),
369                bank_contact_phone: Some("555-0123".to_string()),
370            }),
371            fields: Vec::new(),
372            password_history: Vec::new(),
373        }
374    }
375
376    fn test_blob_passport() -> CipherBlobV1 {
377        CipherBlobV1 {
378            name: "Test Passport".to_string(),
379            notes: Some("Passport notes".to_string()),
380            type_data: CipherTypeDataV1::Passport(PassportDataV1 {
381                surname: Some("Doe".to_string()),
382                given_name: Some("Jane".to_string()),
383                date_of_birth: Some("1990-01-01".to_string()),
384                sex: Some("F".to_string()),
385                birth_place: Some("New York".to_string()),
386                nationality: Some("American".to_string()),
387                issuing_country: Some("US".to_string()),
388                passport_number: Some("P12345678".to_string()),
389                passport_type: Some("P".to_string()),
390                national_identification_number: Some("123-45-6789".to_string()),
391                issuing_authority: Some("US State Department".to_string()),
392                issue_date: Some("2020-01-01".to_string()),
393                expiration_date: Some("2030-01-01".to_string()),
394            }),
395            fields: Vec::new(),
396            password_history: Vec::new(),
397        }
398    }
399
400    fn test_blob_drivers_license() -> CipherBlobV1 {
401        CipherBlobV1 {
402            name: "Test Driver's License".to_string(),
403            notes: Some("Driver's license notes".to_string()),
404            type_data: CipherTypeDataV1::DriversLicense(DriversLicenseDataV1 {
405                first_name: Some("John".to_string()),
406                middle_name: Some("Michael".to_string()),
407                last_name: Some("Doe".to_string()),
408                date_of_birth: Some("1985-06-15".to_string()),
409                license_number: Some("DL-987654".to_string()),
410                issuing_country: Some("US".to_string()),
411                issuing_state: Some("NY".to_string()),
412                issue_date: Some("2020-01-01".to_string()),
413                expiration_date: Some("2028-01-01".to_string()),
414                issuing_authority: Some("NY DMV".to_string()),
415                license_class: Some("D".to_string()),
416            }),
417            fields: Vec::new(),
418            password_history: Vec::new(),
419        }
420    }
421
422    #[test]
423    #[ignore]
424    fn generate_test_vectors() {
425        let blobs: Vec<(&str, CipherBlobV1)> = vec![
426            ("LOGIN", test_blob_login()),
427            ("CARD", test_blob_card()),
428            ("IDENTITY", test_blob_identity()),
429            ("SECURE_NOTE", test_blob_secure_note()),
430            ("SSH_KEY", test_blob_ssh_key()),
431            ("BANK_ACCOUNT", test_blob_bank_account()),
432            ("DRIVERS_LICENSE", test_blob_drivers_license()),
433            ("PASSPORT", test_blob_passport()),
434        ];
435
436        for (name, blob) in blobs {
437            let data: CipherBlob = blob.into();
438            let store: KeyStore<KeySlotIds> = KeyStore::default();
439            let mut ctx = store.context_mut();
440            let (envelope, cek_id) = DataEnvelope::seal(data, &mut ctx).unwrap();
441
442            #[allow(deprecated)]
443            let cek = ctx.dangerous_get_symmetric_key(cek_id).unwrap();
444            println!(
445                "const TEST_VECTOR_{}_CEK: &str = \"{}\";",
446                name,
447                cek.to_base64()
448            );
449            println!(
450                "const TEST_VECTOR_{}_ENVELOPE: &str = \"{}\";",
451                name,
452                String::from(envelope)
453            );
454            println!();
455        }
456    }
457
458    fn verify_test_vector(cek_str: &str, envelope_str: &str, expected: CipherBlobV1) {
459        let cek = SymmetricCryptoKey::try_from(B64::try_from(cek_str).unwrap()).unwrap();
460
461        let store: KeyStore<KeySlotIds> = KeyStore::default();
462        let mut ctx = store.context_mut();
463        let cek_id = ctx.add_local_symmetric_key(cek);
464
465        let envelope: DataEnvelope = envelope_str.parse().unwrap();
466        let unsealed: CipherBlob = envelope
467            .unseal(cek_id, &mut ctx)
468            .expect("CipherBlobV1 has changed in a backwards-incompatible way. Existing encrypted data must remain deserializable. If a new format is needed, create a new version instead of modifying V1.");
469        assert_eq!(unsealed, expected.into());
470    }
471
472    #[test]
473    fn test_recorded_secure_note_test_vector() {
474        verify_test_vector(
475            TEST_VECTOR_SECURE_NOTE_CEK,
476            TEST_VECTOR_SECURE_NOTE_ENVELOPE,
477            test_blob_secure_note(),
478        );
479    }
480
481    #[test]
482    fn test_recorded_login_test_vector() {
483        verify_test_vector(
484            TEST_VECTOR_LOGIN_CEK,
485            TEST_VECTOR_LOGIN_ENVELOPE,
486            test_blob_login(),
487        );
488    }
489
490    #[test]
491    fn test_recorded_card_test_vector() {
492        verify_test_vector(
493            TEST_VECTOR_CARD_CEK,
494            TEST_VECTOR_CARD_ENVELOPE,
495            test_blob_card(),
496        );
497    }
498
499    #[test]
500    fn test_recorded_identity_test_vector() {
501        verify_test_vector(
502            TEST_VECTOR_IDENTITY_CEK,
503            TEST_VECTOR_IDENTITY_ENVELOPE,
504            test_blob_identity(),
505        );
506    }
507
508    #[test]
509    fn test_recorded_ssh_key_test_vector() {
510        verify_test_vector(
511            TEST_VECTOR_SSH_KEY_CEK,
512            TEST_VECTOR_SSH_KEY_ENVELOPE,
513            test_blob_ssh_key(),
514        );
515    }
516
517    #[test]
518    fn test_recorded_bank_account_test_vector() {
519        verify_test_vector(
520            TEST_VECTOR_BANK_ACCOUNT_CEK,
521            TEST_VECTOR_BANK_ACCOUNT_ENVELOPE,
522            test_blob_bank_account(),
523        );
524    }
525
526    #[test]
527    fn test_recorded_passport_test_vector() {
528        verify_test_vector(
529            TEST_VECTOR_PASSPORT_CEK,
530            TEST_VECTOR_PASSPORT_ENVELOPE,
531            test_blob_passport(),
532        );
533    }
534
535    #[test]
536    fn test_recorded_drivers_license_test_vector() {
537        verify_test_vector(
538            TEST_VECTOR_DRIVERS_LICENSE_CEK,
539            TEST_VECTOR_DRIVERS_LICENSE_ENVELOPE,
540            test_blob_drivers_license(),
541        );
542    }
543
544    #[test]
545    fn test_login_data_without_http_authentication_enabled_defaults_to_off() {
546        let login_data: LoginDataV1 = serde_json::from_value(serde_json::json!({
547            "username": "[email protected]",
548            "password": null,
549            "passwordRevisionDate": null,
550            "totp": null,
551            "autofillOnPageLoad": null,
552        }))
553        .unwrap();
554
555        assert!(!login_data.http_authentication_enabled);
556    }
557}