diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/login/mod.rs | 289 | ||||
| -rw-r--r-- | src/login/static_provider.rs | 2 |
2 files changed, 280 insertions, 11 deletions
diff --git a/src/login/mod.rs b/src/login/mod.rs index 4130496..90aaede 100644 --- a/src/login/mod.rs +++ b/src/login/mod.rs @@ -1,9 +1,10 @@ pub mod ldap_provider; pub mod static_provider; -use anyhow::Result; +use anyhow::{anyhow, bail, Result}; use async_trait::async_trait; -use k2v_client::K2vClient; +use k2v_client::{BatchInsertOp, BatchReadOp, CausalityToken, Filter, K2vClient, K2vValue}; +use rand::prelude::*; use rusoto_core::HttpClient; use rusoto_credential::{AwsCredentials, StaticProvider}; use rusoto_s3::S3Client; @@ -88,27 +89,151 @@ impl StorageCredentials { impl CryptoKeys { pub async fn init(storage: &StorageCredentials, password: &str) -> Result<Self> { - unimplemented!() + // Check that salt and public don't exist already + let k2v = storage.k2v_client()?; + Self::check_uninitialized(&k2v).await?; + + // Generate salt for password identifiers + let mut ident_salt = [0u8; 32]; + thread_rng().fill(&mut ident_salt); + + // Generate (public, private) key pair and master key + let (public, secret) = gen_keypair(); + let master = gen_key(); + let keys = CryptoKeys { + master, + secret, + public, + }; + + // Generate short password digest (= password identity) + let ident = argon2_kdf(&ident_salt, password.as_bytes(), 16)?; + + // Generate salt for KDF + let mut kdf_salt = [0u8; 32]; + 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(); + + // Seal a secret box that contains our crypto keys + let password_sealed = seal(&keys.serialize(), &password_key)?; + + let password_sortkey = format!("password:{}", hex::encode(&ident)); + let password_blob = [&kdf_salt[..], &password_sealed].concat(); + + // Write values to storage + k2v.insert_batch(&[ + k2v_insert_single_key("keys", "salt", None, &ident_salt), + k2v_insert_single_key("keys", "public", None, &keys.public), + k2v_insert_single_key("keys", &password_sortkey, None, &password_blob), + ]) + .await?; + + Ok(keys) } pub async fn init_without_password( storage: &StorageCredentials, - master_key: &Key, - secret_key: &SecretKey, + master: &Key, + secret: &SecretKey, ) -> Result<Self> { - unimplemented!() + // Check that salt and public don't exist already + let k2v = storage.k2v_client()?; + Self::check_uninitialized(&k2v).await?; + + // Generate salt for password identifiers + let mut ident_salt = [0u8; 32]; + thread_rng().fill(&mut ident_salt); + + // Create CryptoKeys struct from given keys + let public = secret.public_key(); + let keys = CryptoKeys { + master: master.clone(), + secret: secret.clone(), + public, + }; + + // Write values to storage + k2v.insert_batch(&[ + k2v_insert_single_key("keys", "salt", None, &ident_salt), + k2v_insert_single_key("keys", "public", None, &keys.public), + ]) + .await?; + + Ok(keys) } pub async fn open(storage: &StorageCredentials, password: &str) -> Result<Self> { - unimplemented!() + let k2v = storage.k2v_client()?; + let (ident_salt, expected_public) = Self::load_salt_and_public(&k2v).await?; + + // Generate short password digest (= password identity) + let ident = argon2_kdf(&ident_salt, password.as_bytes(), 16)?; + + // Lookup password blob + let password_sortkey = format!("password:{}", hex::encode(&ident)); + + let password_blob = { + let mut params = k2v + .read_batch(&[k2v_read_single_key("keys", &password_sortkey)]) + .await?; + if params.len() != 1 { + bail!( + "Invalid response from k2v storage: {:?} (expected one item)", + params + ); + } + if params[0].items.len() != 1 { + bail!("given password does not exist in storage."); + } + let vals = &mut params[0].items.iter_mut().next().unwrap().1.value; + if vals.len() != 1 { + bail!("Multiple values for password in storage"); + } + match &mut vals[0] { + K2vValue::Value(v) => std::mem::take(v), + K2vValue::Tombstone => bail!("password is a tombstone"), + } + }; + + // 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 keys = Self::deserialize(&password_openned)?; + if keys.public != expected_public { + bail!("Password public key doesn't match stored public key"); + } + + Ok(keys) } pub async fn open_without_password( storage: &StorageCredentials, - master_key: &Key, - secret_key: &SecretKey, + master: &Key, + secret: &SecretKey, ) -> Result<Self> { - unimplemented!() + let k2v = storage.k2v_client()?; + let (_ident_salt, expected_public) = Self::load_salt_and_public(&k2v).await?; + + // Create CryptoKeys struct from given keys + let public = secret.public_key(); + let keys = CryptoKeys { + master: master.clone(), + secret: secret.clone(), + public, + }; + + // Check public key matches + if keys.public != expected_public { + bail!("Given public key doesn't match stored public key"); + } + + Ok(keys) } pub async fn add_password(&self, storage: &StorageCredentials, password: &str) -> Result<()> { @@ -123,4 +248,148 @@ impl CryptoKeys { ) -> Result<()> { unimplemented!() } + + // ---- STORAGE UTIL ---- + + async fn check_uninitialized(k2v: &K2vClient) -> Result<()> { + let params = k2v + .read_batch(&[ + k2v_read_single_key("keys", "salt"), + k2v_read_single_key("keys", "public"), + ]) + .await?; + if params.len() != 2 { + bail!( + "Invalid response from k2v storage: {:?} (expected two items)", + params + ); + } + if !params[0].items.is_empty() || !params[1].items.is_empty() { + bail!("`salt` or `public` already exists in keys storage."); + } + + Ok(()) + } + + async fn load_salt_and_public(k2v: &K2vClient) -> Result<([u8; 32], PublicKey)> { + let mut params = k2v + .read_batch(&[ + k2v_read_single_key("keys", "salt"), + k2v_read_single_key("keys", "public"), + ]) + .await?; + if params.len() != 2 { + bail!( + "Invalid response from k2v storage: {:?} (expected two items)", + params + ); + } + if params[0].items.len() != 1 || params[1].items.len() != 1 { + bail!("`salt` or `public` do not exist in storage."); + } + + // Retrieve salt from given response + let salt_vals = &mut params[0].items.iter_mut().next().unwrap().1.value; + if salt_vals.len() != 1 { + bail!("Multiple values for `salt`"); + } + let salt: Vec<u8> = match &mut salt_vals[0] { + K2vValue::Value(v) => std::mem::take(v), + K2vValue::Tombstone => bail!("salt is a tombstone"), + }; + if salt.len() != 32 { + bail!("`salt` is not 32 bytes long"); + } + let mut salt_constlen = [0u8; 32]; + salt_constlen.copy_from_slice(&salt); + + // Retrieve public from given response + let public_vals = &mut params[1].items.iter_mut().next().unwrap().1.value; + if public_vals.len() != 1 { + bail!("Multiple values for `public`"); + } + let public: Vec<u8> = match &mut public_vals[0] { + K2vValue::Value(v) => std::mem::take(v), + K2vValue::Tombstone => bail!("public is a tombstone"), + }; + let public = PublicKey::from_slice(&public).ok_or(anyhow!("Invalid public key length"))?; + + Ok((salt_constlen, public)) + } + + fn serialize(&self) -> [u8; 64] { + let mut res = [0u8; 64]; + res[..32].copy_from_slice(self.master.as_ref()); + res[32..].copy_from_slice(self.secret.as_ref()); + res + } + + fn deserialize(bytes: &[u8]) -> Result<Self> { + if bytes.len() != 64 { + bail!("Invalid length: {}, expected 64", bytes.len()); + } + let master = Key::from_slice(&bytes[..32]).unwrap(); + let secret = SecretKey::from_slice(&bytes[32..]).unwrap(); + let public = secret.public_key(); + Ok(Self { + master, + secret, + public, + }) + } +} + +// ---- UTIL ---- + +pub fn argon2_kdf(salt: &[u8], password: &[u8], output_len: usize) -> Result<Vec<u8>> { + use argon2::{Algorithm, Argon2, ParamsBuilder, PasswordHasher, Version}; + + let mut params = ParamsBuilder::new(); + params + .output_len(output_len) + .map_err(|e| anyhow!("Invalid output length: {}", e))?; + + let params = params + .params() + .map_err(|e| anyhow!("Invalid argon2 params: {}", e))?; + let argon2 = Argon2::new(Algorithm::default(), Version::default(), params); + + let salt = base64::encode(salt); + let hash = argon2 + .hash_password(password, &salt) + .map_err(|e| anyhow!("Unable to hash: {}", e))?; + + let hash = hash.hash.ok_or(anyhow!("Missing output"))?; + assert!(hash.len() == output_len); + Ok(hash.as_bytes().to_vec()) +} + +pub fn k2v_read_single_key<'a>(partition_key: &'a str, sort_key: &'a str) -> BatchReadOp<'a> { + BatchReadOp { + partition_key: partition_key, + filter: Filter { + start: Some(sort_key), + end: None, + prefix: None, + limit: None, + reverse: false, + }, + conflicts_only: false, + tombstones: false, + single_item: true, + } +} + +pub fn k2v_insert_single_key<'a>( + partition_key: &'a str, + sort_key: &'a str, + causality: Option<CausalityToken>, + value: impl AsRef<[u8]>, +) -> BatchInsertOp<'a> { + BatchInsertOp { + partition_key, + sort_key, + causality, + value: K2vValue::Value(value.as_ref().to_vec()), + } } diff --git a/src/login/static_provider.rs b/src/login/static_provider.rs index 74a6c14..fb8ec68 100644 --- a/src/login/static_provider.rs +++ b/src/login/static_provider.rs @@ -86,7 +86,7 @@ pub fn hash_password(password: &str) -> Result<String> { pub fn verify_password(password: &str, hash: &str) -> Result<bool> { use argon2::{ - password_hash::{rand_core::OsRng, PasswordHash, PasswordVerifier}, + password_hash::{PasswordHash, PasswordVerifier}, Argon2, }; let parsed_hash = |