sharing/

crypto.rs

/*
 * Authors: Jorge.A Duran & Mario Gónzalez
 * Company: pispas Technologies SL
 * Date: April 23, 2023
 * Description: Cryptography module for sharing
 */
use anyhow::anyhow;
use chacha20poly1305::KeyInit;
use chacha20poly1305::{aead::stream, XChaCha20Poly1305};
use rand::{rngs::OsRng, RngCore};
use zeroize::Zeroize;
use std::fs::File;
use std::io::{Read, Write};
use base64::{Engine as _, engine::general_purpose};
use crate::{PisPasResult, KEY_FILE_NAME};

const SALT_SIZE: usize = 32;
const NONCE_SIZE: usize = 19;

fn argon2_config<'a>() -> argon2::Config<'a> {
    argon2::Config {
        variant: argon2::Variant::Argon2id,
        hash_length: 32,
        lanes: 8,
        mem_cost: 16 * 1024,
        time_cost: 8,
        ..Default::default()
    }
}

pub fn encrypt(data: &Vec<u8>, password: &str) -> Result<Vec<u8>, anyhow::Error> {
    let argon2_config = argon2_config();

    let mut salt = [0u8; SALT_SIZE];
    let mut nonce = [0u8; NONCE_SIZE];
    OsRng.fill_bytes(&mut salt);
    OsRng.fill_bytes(&mut nonce);

    let mut key = argon2::hash_raw(password.as_bytes(), &salt, &argon2_config)?;

    let aead = XChaCha20Poly1305::new(key[..SALT_SIZE].as_ref().into());
    let mut stream_encryptor = stream::EncryptorBE32::from_aead(aead, nonce.as_ref().into());

    let mut target_vec: Vec<u8> = Vec::new();
    target_vec.append(&mut salt.to_vec());
    target_vec.append(&mut nonce.to_vec());

    let mut ciphertext = stream_encryptor
        .encrypt_next(data.as_slice())
        .map_err(|err| anyhow!("Encrypting large file: {}", err))?;
    target_vec.append(&mut ciphertext);

    salt.zeroize();
    nonce.zeroize();
    key.zeroize();

    Ok(target_vec)
}

pub fn decrypt(encrypted: &Vec<u8>, password: &str) -> Result<Vec<u8>, anyhow::Error> {
    let mut salt = encrypted[0..SALT_SIZE].to_vec();
    if SALT_SIZE != salt.len() {
        return Err(anyhow!("Error reading salt."));
    }

    let mut nonce = encrypted[SALT_SIZE..SALT_SIZE + NONCE_SIZE].to_vec();
    if NONCE_SIZE != nonce.len() {
        return Err(anyhow!("Error reading nonce."));
    }

    let argon2_config = argon2_config();

    let mut key = argon2::hash_raw(password.as_bytes(), &salt, &argon2_config)?;
    let aead = XChaCha20Poly1305::new(key[..32].as_ref().into());
    let mut stream_decryptor =
        stream::DecryptorBE32::from_aead(aead, nonce.as_slice().as_ref().into());

    let plaintext = stream_decryptor
        .decrypt_next(encrypted[SALT_SIZE + NONCE_SIZE..].to_vec().as_slice())
        .map_err(|err| anyhow!("Decrypting bytes: {}", err))?;

    salt.zeroize();
    nonce.zeroize();
    key.zeroize();

    Ok(plaintext)
}

pub fn encrypt_text(data: &str, password: &str) -> Result<Vec<u8>, anyhow::Error> {
    Ok(encrypt(&data.as_bytes().to_vec(), password)?)
}

pub fn decrypt_text(encrypted: &Vec<u8>, password: &str) -> Result<String, anyhow::Error> {
    let decrypted = decrypt(encrypted, password)?;
    Ok(String::from_utf8(decrypted)?)
}

pub fn encrypt_text_to_base64(data: &str, password: &str) -> Result<String, anyhow::Error> {
    let encrypted = encrypt_text(data, password)?;
    Ok(general_purpose::STANDARD_NO_PAD.encode(&encrypted))
}

pub fn decrypt_text_from_base64(encrypted: &str, password: &str) -> Result<String, anyhow::Error> {
    let encrypted = general_purpose::STANDARD_NO_PAD.decode(encrypted.as_bytes())?;
    Ok(decrypt_text(&encrypted, password)?)
}


pub struct Crypter {
    key: String,
}

impl Default for Crypter {
    fn default() -> Self {
       Crypter::load().expect("Error loading encryption key")
    }
}

impl Crypter {

    pub fn load() -> PisPasResult<Self> {
        Ok(Self {
            key: load_encryption_key()?,
        })
    }

    pub fn decrypt(&self, encrypted_password: &str) -> PisPasResult<String> {
        decrypt_text_from_base64(encrypted_password, &self.key)
    }

    pub fn encrypt(&self, password: &str) -> PisPasResult<String> {
        encrypt_text_to_base64(password, &self.key)
    }
}


#[allow(dead_code)]
pub fn load_encryption_key() -> PisPasResult<String> {
    let mut file = match File::open(KEY_FILE_NAME) {
        Ok(file) => file,
        Err(_) => return create_key_in_file(),
    };

    let mut key = String::new();
    if file.read_to_string(&mut key).is_ok() {
        Ok(key)
    } else {
        create_key_in_file()
    }
}

fn create_key_in_file() -> PisPasResult<String> {

    // Load from environment variable if exists
    if let Ok(key) = std::env::var("SIGNER_ENCRYPTION_KEY") {
        return Ok(key);
    }

    // Create new key
    let new_key = generate_random_key_128();
    save_encryption_key(&new_key)?;
    Ok(new_key)
}

fn save_encryption_key(key: &str) -> PisPasResult<()> {
    let mut file = File::create(KEY_FILE_NAME)?;
    file.write_all(key.as_bytes())?;
    Ok(())
}

pub fn generate_random_key_128() -> String {
    crate::string::generate_random_string(128)
}

#[cfg(test)]
mod tests {
    use super::*;
    use lipsum::lipsum;
    const TEST_PWD: &str = "test password";

    #[test]
    fn decode_and_encode() {
        let text = lipsum(1024);
        let encoded = encrypt(&text.as_bytes().to_vec(), TEST_PWD);
        assert!(encoded.is_ok());
        let encoded = encoded.unwrap();
        let decoded = decrypt(&encoded, TEST_PWD);
        assert!(decoded.is_ok());
        let decoded_text = String::from_utf8(decoded.unwrap()).unwrap();
        assert_eq!(text, decoded_text);
    }

    #[test]
    fn should_fail_when_wrong_password() {
        let text = lipsum(1024);
        let encoded = encrypt(&text.as_bytes().to_vec(), TEST_PWD);
        assert!(encoded.is_ok());
        let encoded = encoded.unwrap();
        let decoded = decrypt(&encoded, format!("{}asd", TEST_PWD).as_str());
        assert!(!decoded.is_ok());
    }


    #[test]
    fn test_crypter() {
        let crypter = Crypter::load().unwrap();
        let text = lipsum(1024);
        let encoded = crypter.encrypt(&text).unwrap();
        let decoded = crypter.decrypt(&encoded).unwrap();
        assert_eq!(text, decoded);
    }
}