diff options
Diffstat (limited to 'src/login')
| -rw-r--r-- | src/login/mod.rs | 88 | ||||
| -rw-r--r-- | src/login/static_provider.rs | 6 |
2 files changed, 81 insertions, 13 deletions
diff --git a/src/login/mod.rs b/src/login/mod.rs index 75a39f8..1ee0007 100644 --- a/src/login/mod.rs +++ b/src/login/mod.rs @@ -16,17 +16,27 @@ use rusoto_signature::Region; use crate::cryptoblob::*; +/// The trait LoginProvider defines the interface for a login provider that allows +/// to retrieve storage and cryptographic credentials for access to a user account +/// from their username and password. #[async_trait] pub trait LoginProvider { + /// The login method takes an account's password as an input to decypher + /// decryption keys and obtain full access to the user's account. async fn login(&self, username: &str, password: &str) -> Result<Credentials>; } +/// The struct Credentials represent all of the necessary information to interact +/// with a user account's data after they are logged in. #[derive(Clone, Debug)] pub struct Credentials { + /// The storage credentials are used to authenticate access to the underlying storage (S3, K2V) pub storage: StorageCredentials, + /// The cryptographic keys are used to encrypt and decrypt data stored in S3 and K2V pub keys: CryptoKeys, } +/// The struct StorageCredentials contains access key to an S3 and K2V bucket #[derive(Clone, Debug)] pub struct StorageCredentials { pub s3_region: Region, @@ -37,12 +47,28 @@ pub struct StorageCredentials { pub bucket: String, } +/// The struct UserSecrets represents intermediary secrets that are mixed in with the user's +/// password when decrypting the cryptographic keys that are stored in their bucket. +/// These secrets should be stored somewhere else (e.g. in the LDAP server or in the +/// local config file), as an additionnal authentification factor so that the password +/// isn't enough just alone to decrypt the content of a user's bucket. +pub struct UserSecrets { + /// The main user secret that will be used to encrypt keys when a new password is added + pub user_secret: String, + /// Alternative user secrets that will be tried when decrypting keys that were encrypted + /// with old passwords + pub alternate_user_secrets: Vec<String>, +} + +/// The struct CryptoKeys contains the cryptographic keys used to encrypt and decrypt +/// data in a user's mailbox. #[derive(Clone, Debug)] pub struct CryptoKeys { - // Master key for symmetric encryption of mailbox data + /// Master key for symmetric encryption of mailbox data pub master: Key, - // Public/private keypair for encryption of incomming emails + /// Public/private keypair for encryption of incomming emails (secret part) pub secret: SecretKey, + /// Public/private keypair for encryption of incomming emails (public part) pub public: PublicKey, } @@ -92,7 +118,11 @@ impl StorageCredentials { } impl CryptoKeys { - pub async fn init(storage: &StorageCredentials, password: &str) -> Result<Self> { + pub async fn init( + storage: &StorageCredentials, + user_secrets: &UserSecrets, + password: &str, + ) -> Result<Self> { // Check that salt and public don't exist already let k2v = storage.k2v_client()?; let (salt_ct, public_ct) = Self::check_uninitialized(&k2v).await?; @@ -118,8 +148,7 @@ impl CryptoKeys { thread_rng().fill(&mut kdf_salt); // Calculate key for password secret box - let password_key = - Key::from_slice(&argon2_kdf(&kdf_salt, password.as_bytes(), 32)?).unwrap(); + let password_key = user_secrets.derive_password_key(&kdf_salt, password)?; // Seal a secret box that contains our crypto keys let password_sealed = seal(&keys.serialize(), &password_key)?; @@ -171,7 +200,11 @@ impl CryptoKeys { Ok(keys) } - pub async fn open(storage: &StorageCredentials, password: &str) -> Result<Self> { + pub async fn open( + storage: &StorageCredentials, + user_secrets: &UserSecrets, + password: &str, + ) -> Result<Self> { let k2v = storage.k2v_client()?; let (ident_salt, expected_public) = Self::load_salt_and_public(&k2v).await?; @@ -199,9 +232,8 @@ impl CryptoKeys { // Try to open blob let kdf_salt = &password_blob[..32]; - let password_key = - Key::from_slice(&argon2_kdf(kdf_salt, password.as_bytes(), 32)?).unwrap(); - let password_openned = open(&password_blob[32..], &password_key)?; + let password_openned = + user_secrets.try_open_encrypted_keys(&kdf_salt, password, &password_blob[32..])?; let keys = Self::deserialize(&password_openned)?; if keys.public != expected_public { @@ -235,7 +267,12 @@ impl CryptoKeys { Ok(keys) } - pub async fn add_password(&self, storage: &StorageCredentials, password: &str) -> Result<()> { + pub async fn add_password( + &self, + storage: &StorageCredentials, + user_secrets: &UserSecrets, + password: &str, + ) -> Result<()> { let k2v = storage.k2v_client()?; let (ident_salt, _public) = Self::load_salt_and_public(&k2v).await?; @@ -247,8 +284,7 @@ impl CryptoKeys { thread_rng().fill(&mut kdf_salt); // Calculate key for password secret box - let password_key = - Key::from_slice(&argon2_kdf(&kdf_salt, password.as_bytes(), 32)?).unwrap(); + let password_key = user_secrets.derive_password_key(&kdf_salt, password)?; // Seal a secret box that contains our crypto keys let password_sealed = seal(&self.serialize(), &password_key)?; @@ -453,6 +489,34 @@ impl CryptoKeys { } } +impl UserSecrets { + fn derive_password_key_with(user_secret: &str, kdf_salt: &[u8], password: &str) -> Result<Key> { + let tmp = format!("{}\n\n{}", user_secret, password); + Ok(Key::from_slice(&argon2_kdf(&kdf_salt, tmp.as_bytes(), 32)?).unwrap()) + } + + fn derive_password_key(&self, kdf_salt: &[u8], password: &str) -> Result<Key> { + Self::derive_password_key_with(&self.user_secret, kdf_salt, password) + } + + fn try_open_encrypted_keys( + &self, + kdf_salt: &[u8], + password: &str, + encrypted_keys: &[u8], + ) -> Result<Vec<u8>> { + let secrets_to_try = + std::iter::once(&self.user_secret).chain(self.alternate_user_secrets.iter()); + for user_secret in secrets_to_try { + let password_key = Self::derive_password_key_with(user_secret, kdf_salt, password)?; + if let Ok(res) = open(encrypted_keys, &password_key) { + return Ok(res); + } + } + bail!("Unable to decrypt password blob."); + } +} + // ---- UTIL ---- pub fn argon2_kdf(salt: &[u8], password: &[u8], output_len: usize) -> Result<Vec<u8>> { diff --git a/src/login/static_provider.rs b/src/login/static_provider.rs index fb8ec68..cc6ffb6 100644 --- a/src/login/static_provider.rs +++ b/src/login/static_provider.rs @@ -60,7 +60,11 @@ impl LoginProvider for StaticLoginProvider { CryptoKeys::open_without_password(&storage, &master_key, &secret_key).await? } (None, None) => { - CryptoKeys::open(&storage, password).await? + let user_secrets = UserSecrets { + user_secret: u.user_secret.clone(), + alternate_user_secrets: u.alternate_user_secrets.clone(), + }; + CryptoKeys::open(&storage, &user_secrets, password).await? } _ => bail!("Either both master and secret key or none of them must be specified for user"), }; |