pegase 0.2.0

Cli to generate secret config files from yaml recipe
Documentation
use std::{
    fmt::Display,
    io::Write,
    path::Path,
    process::{Command, Stdio},
    string::FromUtf8Error,
};

use itertools::chain;
use serde::{Deserialize, Serialize};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum SopsError {
    #[error("Invalid file name")]
    InvalidFileName,
    #[error("Io error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Sops error: {0}")]
    Sops(String),
    #[error("thread error")]
    Thread,
    #[error("Output error: {0}")]
    Output(#[from] FromUtf8Error),
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct SopsCreationRule {
    #[serde(default)]
    pub enable: bool,
    #[serde(default)]
    pub kms: Vec<String>,
    #[serde(default)]
    pub aws_profile: Option<String>,
    #[serde(default)]
    pub age: Vec<String>,
    #[serde(default)]
    pub pgp: Vec<String>,
    #[serde(default)]
    pub gcp_kms: Vec<String>,
    #[serde(default)]
    pub hckms: Vec<String>,
    #[serde(default)]
    pub azure_keyvault: Vec<String>,
    #[serde(default)]
    pub hc_vault_transit: Vec<String>,
    #[serde(default)]
    pub shamir_threshold: Option<i32>,
    #[serde(default)]
    pub unencrypted_suffix: Option<String>,
    #[serde(default)]
    pub encrypted_suffix: Option<String>,
    #[serde(default)]
    pub unencrypted_regex: Option<String>,
    #[serde(default)]
    pub encrypted_regex: Option<String>,
}

impl SopsCreationRule {
    pub fn sops_args(&self) -> Vec<String> {
        chain!(
            self.kms
                .iter()
                .flat_map(|value| ["--kms".to_string(), value.to_string()]),
            self.aws_profile
                .iter()
                .flat_map(|value| vec!["--aws-profile".to_string(), value.to_string()]),
            self.gcp_kms
                .iter()
                .flat_map(|value| ["--gcp-kms".to_string(), value.to_string()]),
            self.hckms
                .iter()
                .flat_map(|value| ["--hckms".to_string(), value.to_string()]),
            self.azure_keyvault
                .iter()
                .flat_map(|value| ["--azure-kv".to_string(), value.to_string()]),
            self.hc_vault_transit
                .iter()
                .flat_map(|value| ["--hc-vault-transit".to_string(), value.to_string()]),
            self.pgp
                .iter()
                .flat_map(|value| ["--pgp".to_string(), value.to_string()]),
            self.age
                .iter()
                .flat_map(|value| ["--age".to_string(), value.to_string()]),
            self.unencrypted_suffix
                .iter()
                .flat_map(|value| ["--unencrypted-suffix".to_string(), value.to_string()]),
            self.encrypted_suffix
                .iter()
                .flat_map(|value| ["--encrypted-suffix".to_string(), value.to_string()]),
            self.unencrypted_regex
                .iter()
                .flat_map(|value| ["--unencrypted-regex".to_string(), value.to_string()]),
            self.encrypted_regex
                .iter()
                .flat_map(|value| ["--encrypted-regex".to_string(), value.to_string()]),
            self.shamir_threshold.iter().flat_map(|value| [
                "--shamir-secret-sharing-threshold".to_string(),
                value.to_string()
            ]),
        )
        .collect()
    }
}

#[derive(Debug)]
pub enum SopsFormat {
    Binary,
    Env,
    Json,
    Yaml,
}

impl Display for SopsFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Binary => write!(f, "binary"),
            Self::Env => write!(f, "dotenv"),
            Self::Json => write!(f, "json"),
            Self::Yaml => write!(f, "yaml"),
        }
    }
}

pub fn encrypt(
    filename: &Path,
    data: String,
    config: &SopsCreationRule,
    file_format: SopsFormat,
) -> Result<String, SopsError> {
    let Some(filename_str) = filename.to_str() else {
        return Err(SopsError::InvalidFileName);
    };

    let mut sops_child = Command::new("sops")
        .args(["encrypt", "--filename-override", filename_str])
        .args(["--input-type", &file_format.to_string()])
        .args(["--output-type", &file_format.to_string()])
        .args(config.sops_args())
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()?;

    let Some(mut stdin) = sops_child.stdin.take() else {
        unreachable!()
    };

    std::thread::spawn(move || stdin.write_all(data.as_bytes()))
        .join()
        .map_err(|_| SopsError::Thread)??;

    let output = sops_child.wait_with_output()?;

    if output.status.success() {
        Ok(String::from_utf8(output.stdout)?)
    } else {
        Err(SopsError::Sops(
            String::from_utf8_lossy(&output.stderr).to_string(),
        ))
    }
}

#[cfg(test)]
#[allow(unsafe_code)]
mod tests {
    use std::{
        io::Write,
        path::Path,
        process::{Command, Stdio},
    };

    use crate::internal::sops::{SopsCreationRule, SopsFormat, encrypt};

    const AGE_PUBLIC: &str = "age1cspxn98ah526gd886g55u7dakrdjuljmsf4ervalav3kfqrwv3js5w5405";
    const AGE_PRIVATE: &str =
        "AGE-SECRET-KEY-17DK2NA9HSLUNKTN7SET75JXVK7NEU7LD0YFL7F5MGP5FRNKYLEAQPLKNSK";

    #[test]
    fn encrypt_basic_age() {
        let config = SopsCreationRule {
            enable: true,
            age: vec![AGE_PUBLIC.to_string()],
            ..Default::default()
        };
        let input = "my secret data".to_string();

        // encrypt
        let encrypted = encrypt(
            Path::new("test"),
            input.clone(),
            &config,
            SopsFormat::Binary,
        )
        .expect("encrypt failed");

        // verify encryption
        assert!(encrypted.starts_with("{\n\t\"data\": \"ENC["));
        assert!(encrypted.contains("\"sops\": {\n\t\t\"age\""));
        assert!(encrypted.contains(AGE_PUBLIC));

        // decrypt
        let mut sops_child = Command::new("sops")
            .args(["decrypt", "--filename-override", "test"])
            .env("SOPS_AGE_KEY", AGE_PRIVATE)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .unwrap();

        let Some(mut stdin) = sops_child.stdin.take() else {
            unreachable!()
        };

        std::thread::spawn(move || stdin.write_all(encrypted.as_bytes()))
            .join()
            .unwrap()
            .unwrap();

        let output = sops_child.wait_with_output().unwrap();

        // verify decryption
        assert_eq!(String::from_utf8_lossy(&output.stderr), "");
        assert!(output.status.success());

        let decrypted = String::from_utf8(output.stdout).unwrap();

        assert_eq!(input, decrypted);
    }
}