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#[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 #[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}