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();
let encrypted = encrypt(
Path::new("test"),
input.clone(),
&config,
SopsFormat::Binary,
)
.expect("encrypt failed");
assert!(encrypted.starts_with("{\n\t\"data\": \"ENC["));
assert!(encrypted.contains("\"sops\": {\n\t\t\"age\""));
assert!(encrypted.contains(AGE_PUBLIC));
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();
assert_eq!(String::from_utf8_lossy(&output.stderr), "");
assert!(output.status.success());
let decrypted = String::from_utf8(output.stdout).unwrap();
assert_eq!(input, decrypted);
}
}