Add v2 encryption init

Author: quexten

crates/bitwarden-core/src/client/encryption_settings.rs

@@ -8,6 +8,8 @@ use thiserror::Error;
 #[cfg(any(feature = "internal", feature = "secrets"))]
 use uuid::Uuid;
 
+use bitwarden_crypto::CryptoError;
+
 #[cfg(any(feature = "internal", feature = "secrets"))]
 use crate::key_management::{KeyIds, SymmetricKeyId};
 use crate::{error::UserIdAlreadySetError, MissingPrivateKeyError, VaultLockedError};
@@ -28,6 +30,12 @@ pub enum EncryptionSettingsError {
     #[error("Invalid private key")]
     InvalidPrivateKey,
 
+    #[error("Invalid signing key")]
+    InvalidSigningKey,
+
+    #[error("Invalid security state")]
+    InvalidSecurityState,
+
     #[error(transparent)]
     MissingPrivateKey(#[from] MissingPrivateKeyError),
 
@@ -48,51 +56,86 @@ impl EncryptionSettings {
         user_key: SymmetricCryptoKey,
         private_key: EncString,
         signing_key: Option<EncString>,
-        _security_state: Option<SignedSecurityState>,
+        security_state: Option<SignedSecurityState>,
         store: &KeyStore<KeyIds>,
     ) -> Result<(), EncryptionSettingsError> {
-        use bitwarden_crypto::{
-            AsymmetricCryptoKey, CoseSerializable, CryptoError, KeyDecryptable, SigningKey,
-        };
+        use bitwarden_crypto::{AsymmetricCryptoKey, KeyDecryptable};
         use log::warn;
 
-        use crate::key_management::{AsymmetricKeyId, SigningKeyId, SymmetricKeyId};
-
-        let private_key = {
-            let dec: Vec<u8> = private_key.decrypt_with_key(&user_key)?;
-
-            // FIXME: [PM-11690] - Temporarily ignore invalid private keys until we have a recovery
-            // process in place.
-            AsymmetricCryptoKey::from_der(&dec)
-                .map_err(|_| {
-                    warn!("Invalid private key");
-                })
-                .ok()
+        use crate::key_management::{AsymmetricKeyId, SymmetricKeyId};
 
-            // Some(
-            //     AsymmetricCryptoKey::from_der(&dec)
-            //         .map_err(|_| EncryptionSettingsError::InvalidPrivateKey)?,
-            // )
+        // This is an all-or-nothing check. The server cannot pretend a signing key or security state to be missing, because they are *always* present when the
+        // user key is an XChaCha20Poly1305Key. Thus, the server or network cannot lie about the presence of these, because otherwise the entire user account will
+        // fail to decrypt.
+        let is_v2_user = if let SymmetricCryptoKey::XChaCha20Poly1305Key(_) = user_key {
+            true
+        } else {
+            false
         };
-        let signing_key = signing_key
-            .map(|key| {
-                let dec: Vec<u8> = key.decrypt_with_key(&user_key)?;
-                SigningKey::from_cose(dec.as_slice()).map_err(Into::<CryptoError>::into)
-            })
-            .transpose()?;
 
-        // FIXME: [PM-18098] When this is part of crypto we won't need to use deprecated methods
-        #[allow(deprecated)]
-        {
-            let mut ctx = store.context_mut();
-            ctx.set_symmetric_key(SymmetricKeyId::User, user_key)?;
-            if let Some(private_key) = private_key {
+        if is_v2_user {
+            // For v2 users, we mandate the signing key and security state to be present
+            // The private key must also be valid.
+
+            use bitwarden_crypto::{security_state::SecurityState, CoseSerializable, SigningKey};
+
+            // Both of these are required for v2 users
+            let signing_key = signing_key.ok_or(EncryptionSettingsError::Crypto(
+                CryptoError::SecurityDowngrade("Signing key is required for v2 users".to_string()),
+            ))?;
+            let security_state = security_state.ok_or(EncryptionSettingsError::Crypto(
+                CryptoError::SecurityDowngrade(
+                    "Security state is required for v2 users".to_string(),
+                ),
+            ))?;
+
+            // Everything MUST decrypt.
+            let signing_key: Vec<u8> = signing_key.decrypt_with_key(&user_key)?;
+            let signing_key = SigningKey::from_cose(&signing_key)
+                .map_err(|_| EncryptionSettingsError::InvalidSigningKey)?;
+            let private_key: Vec<u8> = private_key.decrypt_with_key(&user_key)?;
+            let private_key = AsymmetricCryptoKey::from_der(&private_key)
+                .map_err(|_| EncryptionSettingsError::InvalidPrivateKey)?;
+            let _security_state: SecurityState = security_state
+                .verify_and_unwrap(&signing_key.to_verifying_key())
+                .map_err(|_| EncryptionSettingsError::InvalidSecurityState)?;
+
+            #[allow(deprecated)]
+            {
+                use crate::key_management::SigningKeyId;
+
+                let mut ctx = store.context_mut();
+                ctx.set_symmetric_key(SymmetricKeyId::User, user_key)?;
                 ctx.set_asymmetric_key(AsymmetricKeyId::UserPrivateKey, private_key)?;
-            }
-
-            if let Some(signing_key) = signing_key {
                 ctx.set_signing_key(SigningKeyId::UserSigningKey, signing_key)?;
             }
+        } else {
+            let private_key = {
+                let dec: Vec<u8> = private_key.decrypt_with_key(&user_key)?;
+
+                // FIXME: [PM-11690] - Temporarily ignore invalid private keys until we have a recovery
+                // process in place.
+                AsymmetricCryptoKey::from_der(&dec)
+                    .map_err(|_| {
+                        warn!("Invalid private key");
+                    })
+                    .ok()
+
+                // Some(
+                //     AsymmetricCryptoKey::from_der(&dec)
+                //         .map_err(|_| EncryptionSettingsError::InvalidPrivateKey)?,
+                // )
+            };
+
+            // FIXME: [PM-18098] When this is part of crypto we won't need to use deprecated methods
+            #[allow(deprecated)]
+            {
+                let mut ctx = store.context_mut();
+                ctx.set_symmetric_key(SymmetricKeyId::User, user_key)?;
+                if let Some(private_key) = private_key {
+                    ctx.set_asymmetric_key(AsymmetricKeyId::UserPrivateKey, private_key)?;
+                }
+            }
         }
 
         Ok(())

crates/bitwarden-crypto/src/error.rs

@@ -69,6 +69,9 @@ pub enum CryptoError {
 
     #[error("Uninitialized error")]
     UninitializedError,
+
+    #[error("Attempted security downgrade {0}")]
+    SecurityDowngrade(String),
 }
 
 #[derive(Debug, Error)]