envio 0.7.0

A secure command-line tool for managing environment variables
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#[macro_use]
mod metadata;
mod v1;

use std::any::Any;
use zeroize::Zeroizing;

use crate::{
    EnvMap,
    cipher::{Cipher, CipherKind, EncryptedContent},
    error::Result,
};

use metadata::VersionedMetadata;

#[derive(Clone)]
pub struct PASSPHRASE {
    key: Zeroizing<String>,
    metadata: VersionedMetadata,
}

impl PASSPHRASE {
    pub fn new(key: Zeroizing<String>) -> Self {
        PASSPHRASE {
            key,
            metadata: VersionedMetadata::default(),
        }
    }

    pub fn set_key(&mut self, key: Zeroizing<String>) {
        self.key = key;
    }
}

impl Cipher for PASSPHRASE {
    fn kind(&self) -> CipherKind {
        CipherKind::PASSPHRASE
    }

    fn encrypt(&mut self, envs: &EnvMap) -> Result<EncryptedContent> {
        let data = envs.as_bytes()?;

        let (encrypted, metadata) = v1::encrypt(&self.key, &data)?;
        self.metadata = metadata.into();

        Ok(EncryptedContent::Bytes(encrypted))
    }

    fn decrypt(&self, encrypted_data: &EncryptedContent) -> Result<EnvMap> {
        let raw_data = encrypted_data.as_bytes()?;
        let decrypted = match &self.metadata {
            VersionedMetadata::V1(metadata) => v1::decrypt(&self.key, metadata, &raw_data)?,
        };
        Ok(decrypted.into())
    }

    fn export_metadata(&self) -> Option<serde_json::Value> {
        serde_json::to_value(self.metadata.clone()).ok()
    }

    fn import_metadata(&mut self, data: serde_json::Value) -> Result<()> {
        self.metadata = serde_json::from_value(data)?;

        Ok(())
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}