bitwarden_vault/cipher/
field.rs

1use std::collections::HashMap;
2
3use bitwarden_api_api::models::CipherFieldModel;
4use bitwarden_core::{
5    MissingFieldError,
6    key_management::{KeyIds, SymmetricKeyId},
7    require,
8};
9use bitwarden_crypto::{
10    CompositeEncryptable, CryptoError, Decryptable, EncString, KeyStoreContext,
11    PrimitiveEncryptable,
12};
13use serde::{Deserialize, Serialize};
14use serde_repr::{Deserialize_repr, Serialize_repr};
15#[cfg(feature = "wasm")]
16use tsify::Tsify;
17#[cfg(feature = "wasm")]
18use wasm_bindgen::prelude::wasm_bindgen;
19
20use super::linked_id::LinkedIdType;
21use crate::{PasswordHistoryView, VaultParseError};
22
23/// Represents the type of a [FieldView].
24#[derive(Clone, Copy, Serialize_repr, Deserialize_repr, Debug, PartialEq, Eq)]
25#[repr(u8)]
26#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
27#[cfg_attr(feature = "wasm", wasm_bindgen)]
28pub enum FieldType {
29    /// Text field
30    Text = 0,
31    /// Hidden text field
32    Hidden = 1,
33    /// Boolean field
34    Boolean = 2,
35    /// Linked field
36    Linked = 3,
37}
38
39impl TryFrom<u8> for FieldType {
40    type Error = MissingFieldError;
41
42    fn try_from(value: u8) -> Result<Self, Self::Error> {
43        match value {
44            0 => Ok(FieldType::Text),
45            1 => Ok(FieldType::Hidden),
46            2 => Ok(FieldType::Boolean),
47            3 => Ok(FieldType::Linked),
48            _ => Err(MissingFieldError("FieldType")),
49        }
50    }
51}
52
53#[derive(Serialize, Deserialize, Debug, Clone)]
54#[serde(rename_all = "camelCase", deny_unknown_fields)]
55#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
56#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
57pub struct Field {
58    name: Option<EncString>,
59    value: Option<EncString>,
60    r#type: FieldType,
61
62    linked_id: Option<LinkedIdType>,
63}
64
65#[allow(missing_docs)]
66#[derive(Serialize, Deserialize, Debug, Clone)]
67#[serde(rename_all = "camelCase", deny_unknown_fields)]
68#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
69#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
70pub struct FieldView {
71    pub name: Option<String>,
72    pub value: Option<String>,
73    pub r#type: FieldType,
74
75    pub linked_id: Option<LinkedIdType>,
76}
77
78impl CompositeEncryptable<KeyIds, SymmetricKeyId, Field> for FieldView {
79    fn encrypt_composite(
80        &self,
81        ctx: &mut KeyStoreContext<KeyIds>,
82        key: SymmetricKeyId,
83    ) -> Result<Field, CryptoError> {
84        Ok(Field {
85            name: self.name.encrypt(ctx, key)?,
86            value: self.value.encrypt(ctx, key)?,
87            r#type: self.r#type,
88            linked_id: self.linked_id,
89        })
90    }
91}
92
93impl FieldView {
94    /// Compares two sets of FieldView and detects changes in hidden fields, for building password
95    /// history.
96    pub(crate) fn detect_hidden_field_changes(
97        fields: &[FieldView],
98        original: &[FieldView],
99    ) -> Vec<PasswordHistoryView> {
100        let current_fields = Self::extract_hidden_fields(fields);
101        let original_fields = Self::extract_hidden_fields(original);
102
103        original_fields
104            .into_iter()
105            .filter_map(|(field_name, original_value)| {
106                let current_value = current_fields.get(&field_name);
107                if current_value != Some(&original_value) {
108                    Some(PasswordHistoryView::new_field(&field_name, &original_value))
109                } else {
110                    None
111                }
112            })
113            .collect()
114    }
115
116    fn extract_hidden_fields(fields: &[FieldView]) -> HashMap<String, String> {
117        fields
118            .iter()
119            .filter_map(|f| match (&f.r#type, &f.name, &f.value) {
120                (FieldType::Hidden, Some(name), Some(value))
121                    if !name.is_empty() && !value.is_empty() =>
122                {
123                    Some((name.clone(), value.clone()))
124                }
125                _ => None,
126            })
127            .collect()
128    }
129}
130
131impl Decryptable<KeyIds, SymmetricKeyId, FieldView> for Field {
132    fn decrypt(
133        &self,
134        ctx: &mut KeyStoreContext<KeyIds>,
135        key: SymmetricKeyId,
136    ) -> Result<FieldView, CryptoError> {
137        Ok(FieldView {
138            name: self.name.decrypt(ctx, key).ok().flatten(),
139            value: self.value.decrypt(ctx, key).ok().flatten(),
140            r#type: self.r#type,
141            linked_id: self.linked_id,
142        })
143    }
144}
145
146impl TryFrom<CipherFieldModel> for Field {
147    type Error = VaultParseError;
148
149    fn try_from(model: CipherFieldModel) -> Result<Self, Self::Error> {
150        Ok(Self {
151            name: EncString::try_from_optional(model.name)?,
152            value: EncString::try_from_optional(model.value)?,
153            r#type: require!(model.r#type).into(),
154            linked_id: model
155                .linked_id
156                .map(|id| (id as u32).try_into())
157                .transpose()?,
158        })
159    }
160}
161
162impl From<bitwarden_api_api::models::FieldType> for FieldType {
163    fn from(model: bitwarden_api_api::models::FieldType) -> Self {
164        match model {
165            bitwarden_api_api::models::FieldType::Text => FieldType::Text,
166            bitwarden_api_api::models::FieldType::Hidden => FieldType::Hidden,
167            bitwarden_api_api::models::FieldType::Boolean => FieldType::Boolean,
168            bitwarden_api_api::models::FieldType::Linked => FieldType::Linked,
169        }
170    }
171}
172
173impl From<Field> for bitwarden_api_api::models::CipherFieldModel {
174    fn from(field: Field) -> Self {
175        Self {
176            name: field.name.map(|n| n.to_string()),
177            value: field.value.map(|v| v.to_string()),
178            r#type: Some(field.r#type.into()),
179            linked_id: field.linked_id.map(|id| u32::from(id) as i32),
180        }
181    }
182}
183
184impl From<FieldType> for bitwarden_api_api::models::FieldType {
185    fn from(field_type: FieldType) -> Self {
186        match field_type {
187            FieldType::Text => bitwarden_api_api::models::FieldType::Text,
188            FieldType::Hidden => bitwarden_api_api::models::FieldType::Hidden,
189            FieldType::Boolean => bitwarden_api_api::models::FieldType::Boolean,
190            FieldType::Linked => bitwarden_api_api::models::FieldType::Linked,
191        }
192    }
193}
194
195#[cfg(test)]
196mod tests {
197    use super::*;
198
199    #[test]
200    fn test_field_type_try_from_u8_valid() {
201        assert_eq!(FieldType::try_from(0).unwrap(), FieldType::Text);
202        assert_eq!(FieldType::try_from(1).unwrap(), FieldType::Hidden);
203        assert_eq!(FieldType::try_from(2).unwrap(), FieldType::Boolean);
204        assert_eq!(FieldType::try_from(3).unwrap(), FieldType::Linked);
205    }
206
207    #[test]
208    fn test_field_type_try_from_u8_invalid() {
209        assert!(FieldType::try_from(4).is_err());
210        assert!(FieldType::try_from(255).is_err());
211    }
212}
bitwarden_vault/cipher/field.rs

bitwarden_vault/cipher/
field.rs
