Fix compatibility with legacy secrets (#14)

Fix compatibility with legacy secrets

We have secrets in our vaults, where it seems that the encrypted key is bigger than a standard AES256 key. We need to allow for such keys to stay compatible. The OpenSSL documentation says that keys are of fixed size, but it seems we rely on an undocumented/undefined behavior.

Author: hasenbanck

src/crypto/mod.rs

@@ -12,17 +12,17 @@ const IV_SIZE: usize = 128 / 8;
 
 #[derive(Clone)]
 pub struct CryptedFileContent {
-    crypted_password: Vec<u8>,
-    content: Vec<u8>,
+    encrypted_key: Vec<u8>,
+    encrypted_content: Vec<u8>,
 }
 
 impl CryptedFileContent {
-    pub fn get_crypted_password(&self) -> &[u8] {
-        self.crypted_password.as_slice()
+    pub fn get_encrypted_key(&self) -> &[u8] {
+        self.encrypted_key.as_slice()
     }
 
-    pub fn get_content(&self) -> &[u8] {
-        self.content.as_slice()
+    pub fn get_encrypted_content(&self) -> &[u8] {
+        self.encrypted_content.as_slice()
     }
 }
 
@@ -48,22 +48,22 @@ impl Crypto {
         public_key: &PublicKey,
         uncrypted_vault_file: &UncryptedVaultFile,
     ) -> Result<CryptedFileContent> {
-        // at first, we need a password, we store the password in the "key"
-        let mut password = [0; KEY_SIZE];
-        rand_priv_bytes(&mut password)
+        // at first, we need an AES key, we store the AES key using RSA
+        let mut aes_key = [0; KEY_SIZE];
+        rand_priv_bytes(&mut aes_key)
             .context("could not create random bytes to encrypt vault_file.")?;
 
         let mut iv = vec![0; IV_SIZE];
         rand_bytes(&mut iv).context("could not create random bytes for iv.")?;
 
-        let key = Crypto::key_encrypt(public_key, &password)
-            .context("could not encrypt using public_key")?;
+        let key = Crypto::key_encrypt(public_key, &aes_key)
+            .context("could not encrypt the AES key using the public RSA key")?;
 
         let cipher = Cipher::aes_256_cbc();
 
         let mut content = encrypt(
             cipher,
-            &password,
+            &aes_key,
             Some(&iv),
             uncrypted_vault_file.get_content(),
         )
@@ -74,29 +74,29 @@ impl Crypto {
         content_with_iv.append(&mut content);
 
         Ok(CryptedFileContent {
-            crypted_password: key,
-            content: content_with_iv,
+            encrypted_key: key,
+            encrypted_content: content_with_iv,
         })
     }
 
     pub fn decrypt(pem: &Pem, crypted_vault_file: &VaultFile) -> Result<UncryptedVaultFile> {
-        // at first, we need to extract the password using the private key.
-        let password = Self::key_decrypt(
+        // at first, we need to extract the AES key using the private RSA key.
+        let aes_key = Self::key_decrypt(
             pem.get_private_key(),
             crypted_vault_file.get_keyfile_content(),
         )
-        .context("could not decrypt password using private key")?;
+        .context("could not decrypt AES key using the private RSA key")?;
 
         let cipher = Cipher::aes_256_cbc();
 
         ensure!(
             crypted_vault_file.get_secret_content().len() >= IV_SIZE,
-            "crypted size is to small, couldnt read enought for IV"
+            "crypted size is to small, couldnt read enough for IV"
         );
 
         let (iv, content) = crypted_vault_file.get_secret_content().split_at(IV_SIZE);
 
-        let content = decrypt(cipher, password.as_slice(), Some(iv), content)
+        let content = decrypt(cipher, aes_key.as_slice(), Some(iv), content)
             .context("could not encrypt using content")?;
 
         Ok(UncryptedVaultFile { content })
@@ -123,7 +123,7 @@ impl Crypto {
         Ok(encrypted_data)
     }
 
-    pub fn key_decrypt(private_key: &PrivateKey, encrypted_key: &[u8]) -> Result<[u8; KEY_SIZE]> {
+    pub fn key_decrypt(private_key: &PrivateKey, encrypted_key: &[u8]) -> Result<Vec<u8>> {
         let rsa = Rsa::private_key_from_pem(private_key.get_data())
             .with_context(|| format!("invalid private key {}", &private_key.get_name()))?;
 
@@ -136,13 +136,13 @@ impl Crypto {
             .private_decrypt(encrypted_key, decrypted_data.as_mut_slice(), Padding::PKCS1)
             .context("could not decrypt")?;
 
-        assert!(size >= KEY_SIZE);
-
-        let mut key = [0; KEY_SIZE];
-
-        key.copy_from_slice(&decrypted_data[..KEY_SIZE]);
+        // Older versions of vault seem to have created files, which produced keys that are bigger
+        // than the expected KEY_SIZE. For compatibility reasons, we have to allow keys that
+        // are bigger than KEY_SIZE. The OpenSSL documentation says that keys are of fixed size,
+        // but it seems we rely on an undocumented/undefined behavior.
+        let decrypted_key = decrypted_data[..size].to_vec();
 
-        Ok(key)
+        Ok(decrypted_key)
     }
 }
 

src/main.rs

@@ -31,7 +31,7 @@ type Result<T> = anyhow::Result<T>;
 
 fn main() {
     if let Err(error) = run() {
-        eprintln!("Vault error: {error}");
+        eprintln!("Vault error: {error:?}");
         std::process::exit(1);
     }
 }

src/proto/mod.rs

@@ -28,8 +28,8 @@ impl<'a> VaultFile<'a> {
 
     pub fn from_crypted_file_content(file_content: &'a CryptedFileContent) -> Self {
         VaultFile {
-            keyfile_content: Cow::Borrowed(file_content.get_crypted_password()),
-            secret_content: Cow::Borrowed(file_content.get_content()),
+            keyfile_content: Cow::Borrowed(file_content.get_encrypted_key()),
+            secret_content: Cow::Borrowed(file_content.get_encrypted_content()),
         }
     }