a.tolmachev
275 lines
9.6 KiB
Rust
275 lines
9.6 KiB
Rust
use aes_gcm::{
|
|
Aes256Gcm, KeyInit, Nonce,
|
|
aead::{Aead, OsRng, rand_core::RngCore},
|
|
};
|
|
use base64::{Engine as _, engine::general_purpose::STANDARD};
|
|
use hkdf::Hkdf;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::Value;
|
|
use sha2::{Digest, Sha256};
|
|
|
|
use crate::RuntimeError;
|
|
|
|
const LEGACY_KEY_VERSION: &str = "v1";
|
|
const CURRENT_KEY_VERSION: &str = "v2";
|
|
const SECRET_ENVELOPE_INFO: &[u8] = b"crank.secret-envelope.v2";
|
|
|
|
#[derive(Clone)]
|
|
pub struct SecretCrypto {
|
|
current_cipher: Aes256Gcm,
|
|
legacy_cipher: Aes256Gcm,
|
|
key_version: String,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
struct CipherEnvelope {
|
|
nonce_b64: String,
|
|
ciphertext_b64: String,
|
|
}
|
|
|
|
impl SecretCrypto {
|
|
pub fn new(master_key: &str) -> Result<Self, RuntimeError> {
|
|
let trimmed = master_key.trim();
|
|
if trimmed.is_empty() {
|
|
return Err(RuntimeError::SecretCrypto {
|
|
operation: "initialize secret crypto",
|
|
details: "CRANK_MASTER_KEY must not be empty".to_owned(),
|
|
});
|
|
}
|
|
|
|
Ok(Self {
|
|
current_cipher: derive_hkdf_cipher(trimmed)?,
|
|
legacy_cipher: derive_legacy_cipher(trimmed)?,
|
|
key_version: CURRENT_KEY_VERSION.to_owned(),
|
|
})
|
|
}
|
|
|
|
pub fn key_version(&self) -> &str {
|
|
&self.key_version
|
|
}
|
|
|
|
pub fn encrypt(&self, value: &Value) -> Result<String, RuntimeError> {
|
|
encrypt_value_with_cipher(&self.current_cipher, value, "encrypt secret value")
|
|
}
|
|
|
|
pub fn decrypt(&self, key_version: &str, ciphertext: &str) -> Result<Value, RuntimeError> {
|
|
let envelope: CipherEnvelope =
|
|
serde_json::from_str(ciphertext).map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "decode secret envelope",
|
|
details: format!("failed to decode secret envelope: {error}"),
|
|
})?;
|
|
let nonce_bytes =
|
|
STANDARD
|
|
.decode(envelope.nonce_b64)
|
|
.map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "decode secret nonce",
|
|
details: format!("failed to decode secret nonce: {error}"),
|
|
})?;
|
|
let ciphertext_bytes = STANDARD.decode(envelope.ciphertext_b64).map_err(|error| {
|
|
RuntimeError::SecretCrypto {
|
|
operation: "decode secret payload",
|
|
details: format!("failed to decode secret payload: {error}"),
|
|
}
|
|
})?;
|
|
let cipher = self.cipher_for_version(key_version)?;
|
|
let plaintext = cipher
|
|
.decrypt(Nonce::from_slice(&nonce_bytes), ciphertext_bytes.as_ref())
|
|
.map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "decrypt secret value",
|
|
details: format!("failed to decrypt secret value: {error}"),
|
|
})?;
|
|
|
|
serde_json::from_slice(&plaintext).map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "deserialize secret value",
|
|
details: format!("failed to deserialize secret value: {error}"),
|
|
})
|
|
}
|
|
|
|
fn cipher_for_version(&self, key_version: &str) -> Result<&Aes256Gcm, RuntimeError> {
|
|
match key_version {
|
|
LEGACY_KEY_VERSION => Ok(&self.legacy_cipher),
|
|
CURRENT_KEY_VERSION => Ok(&self.current_cipher),
|
|
other => Err(RuntimeError::SecretCrypto {
|
|
operation: "select secret key version",
|
|
details: format!("unsupported secret key version: {other}"),
|
|
}),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn derive_legacy_cipher(master_key: &str) -> Result<Aes256Gcm, RuntimeError> {
|
|
let digest = Sha256::digest(master_key.as_bytes());
|
|
Aes256Gcm::new_from_slice(digest.as_slice()).map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "initialize legacy secret crypto",
|
|
details: format!("failed to initialize legacy secret crypto: {error}"),
|
|
})
|
|
}
|
|
|
|
fn derive_hkdf_cipher(master_key: &str) -> Result<Aes256Gcm, RuntimeError> {
|
|
let hkdf = Hkdf::<Sha256>::new(None, master_key.as_bytes());
|
|
let mut key_bytes = [0_u8; 32];
|
|
hkdf.expand(SECRET_ENVELOPE_INFO, &mut key_bytes)
|
|
.map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "derive secret key with hkdf",
|
|
details: format!("failed to derive secret key with HKDF: {error}"),
|
|
})?;
|
|
Aes256Gcm::new_from_slice(&key_bytes).map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "initialize secret crypto",
|
|
details: format!("failed to initialize secret crypto: {error}"),
|
|
})
|
|
}
|
|
|
|
fn encrypt_value_with_cipher(
|
|
cipher: &Aes256Gcm,
|
|
value: &Value,
|
|
action: &str,
|
|
) -> Result<String, RuntimeError> {
|
|
let plaintext = serde_json::to_vec(value).map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "serialize secret value",
|
|
details: format!("failed to serialize secret value: {error}"),
|
|
})?;
|
|
let mut nonce_bytes = [0_u8; 12];
|
|
OsRng.fill_bytes(&mut nonce_bytes);
|
|
let nonce = Nonce::from_slice(&nonce_bytes);
|
|
let ciphertext =
|
|
cipher
|
|
.encrypt(nonce, plaintext.as_ref())
|
|
.map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "encrypt secret value",
|
|
details: format!("failed to {action}: {error}"),
|
|
})?;
|
|
let envelope = CipherEnvelope {
|
|
nonce_b64: STANDARD.encode(nonce_bytes),
|
|
ciphertext_b64: STANDARD.encode(ciphertext),
|
|
};
|
|
|
|
serde_json::to_string(&envelope).map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "encode secret ciphertext",
|
|
details: format!("failed to encode secret ciphertext: {error}"),
|
|
})
|
|
}
|
|
|
|
#[cfg(test)]
|
|
fn encrypt_with_legacy_scheme(master_key: &str, value: &Value) -> Result<String, RuntimeError> {
|
|
let cipher = derive_legacy_cipher(master_key)?;
|
|
encrypt_value_with_cipher(&cipher, value, "encrypt secret value with legacy scheme")
|
|
}
|
|
|
|
#[cfg(test)]
|
|
fn current_key_bytes(master_key: &str) -> Result<[u8; 32], RuntimeError> {
|
|
let hkdf = Hkdf::<Sha256>::new(None, master_key.as_bytes());
|
|
let mut key_bytes = [0_u8; 32];
|
|
hkdf.expand(SECRET_ENVELOPE_INFO, &mut key_bytes)
|
|
.map_err(|error| RuntimeError::SecretCrypto {
|
|
operation: "derive secret key with hkdf",
|
|
details: format!("failed to derive secret key with HKDF: {error}"),
|
|
})?;
|
|
Ok(key_bytes)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
fn legacy_key_bytes(master_key: &str) -> [u8; 32] {
|
|
let digest = Sha256::digest(master_key.as_bytes());
|
|
let mut key_bytes = [0_u8; 32];
|
|
key_bytes.copy_from_slice(digest.as_slice());
|
|
key_bytes
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::RuntimeError;
|
|
use serde_json::json;
|
|
|
|
use super::{
|
|
CURRENT_KEY_VERSION, LEGACY_KEY_VERSION, SecretCrypto, current_key_bytes,
|
|
encrypt_with_legacy_scheme, legacy_key_bytes,
|
|
};
|
|
|
|
#[test]
|
|
fn roundtrips_secret_payload_with_current_scheme() {
|
|
let crypto = SecretCrypto::new("test-master-key").unwrap();
|
|
let plaintext = json!({
|
|
"token": "top-secret",
|
|
"username": "demo"
|
|
});
|
|
|
|
let ciphertext = crypto.encrypt(&plaintext).unwrap();
|
|
let decrypted = crypto.decrypt(CURRENT_KEY_VERSION, &ciphertext).unwrap();
|
|
|
|
assert_eq!(decrypted, plaintext);
|
|
assert_eq!(crypto.key_version(), CURRENT_KEY_VERSION);
|
|
}
|
|
|
|
#[test]
|
|
fn decrypts_legacy_v1_payloads() {
|
|
let plaintext = json!({
|
|
"token": "top-secret",
|
|
"username": "demo"
|
|
});
|
|
let ciphertext = encrypt_with_legacy_scheme("test-master-key", &plaintext).unwrap();
|
|
let crypto = SecretCrypto::new("test-master-key").unwrap();
|
|
|
|
let decrypted = crypto.decrypt(LEGACY_KEY_VERSION, &ciphertext).unwrap();
|
|
|
|
assert_eq!(decrypted, plaintext);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_empty_master_key() {
|
|
let error = SecretCrypto::new(" ").err().unwrap();
|
|
match error {
|
|
RuntimeError::SecretCrypto { operation, details } => {
|
|
assert_eq!(operation, "initialize secret crypto");
|
|
assert_eq!(details, "CRANK_MASTER_KEY must not be empty");
|
|
}
|
|
other => panic!("unexpected error: {other}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn same_master_key_derives_stable_hkdf_key() {
|
|
let lhs = current_key_bytes("test-master-key").unwrap();
|
|
let rhs = current_key_bytes("test-master-key").unwrap();
|
|
|
|
assert_eq!(lhs, rhs);
|
|
}
|
|
|
|
#[test]
|
|
fn current_scheme_key_differs_from_legacy_scheme() {
|
|
let current = current_key_bytes("test-master-key").unwrap();
|
|
let legacy = legacy_key_bytes("test-master-key");
|
|
|
|
assert_ne!(current, legacy);
|
|
}
|
|
|
|
#[test]
|
|
fn different_master_keys_produce_different_ciphertexts() {
|
|
let plaintext = json!({
|
|
"token": "top-secret",
|
|
"username": "demo"
|
|
});
|
|
let left = SecretCrypto::new("test-master-key-a").unwrap();
|
|
let right = SecretCrypto::new("test-master-key-b").unwrap();
|
|
|
|
let left_ciphertext = left.encrypt(&plaintext).unwrap();
|
|
let right_ciphertext = right.encrypt(&plaintext).unwrap();
|
|
|
|
assert_ne!(left_ciphertext, right_ciphertext);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_unknown_key_version() {
|
|
let crypto = SecretCrypto::new("test-master-key").unwrap();
|
|
let ciphertext = crypto.encrypt(&json!({"token": "top-secret"})).unwrap();
|
|
let error = crypto.decrypt("v999", &ciphertext).unwrap_err();
|
|
|
|
match error {
|
|
RuntimeError::SecretCrypto { operation, details } => {
|
|
assert_eq!(operation, "select secret key version");
|
|
assert!(details.contains("unsupported secret key version"));
|
|
}
|
|
other => panic!("unexpected error: {other}"),
|
|
}
|
|
}
|
|
}
|