use sha2::{Digest, Sha256};
pub fn parameter_store_parameter_name(vault_prefix: &str, secret_name: &str) -> String {
format!("{vault_prefix}-{secret_name}")
}
pub fn secret_manager_secret_id(vault_prefix: &str, secret_name: &str) -> String {
format!("{vault_prefix}-{secret_name}")
}
pub const VAULT_PREFIX_MARKER_KEY: &str = "alien-vault-prefix";
pub const VAULT_ID_MARKER_KEY: &str = "alien-vault";
fn sha256_hex(raw: &str) -> String {
Sha256::digest(raw.as_bytes())
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
pub fn vault_marker_value(raw: &str) -> String {
let fits = !raw.is_empty()
&& raw.len() <= 63
&& raw
.bytes()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_' || b == b'-');
if fits {
return raw.to_string();
}
format!("h-{}", &sha256_hex(raw)[..40])
}
pub fn key_vault_secret_name(secret_name: &str) -> String {
secret_name.replace('_', "-")
}
pub fn azure_deployer_vault_name(resource_prefix: &str, suffix: &str) -> String {
let prefix: String = resource_prefix
.chars()
.filter(|character| character.is_ascii_alphanumeric() || *character == '-')
.take(8)
.collect::<String>()
.trim_matches('-')
.to_ascii_lowercase();
format!("{prefix}-deployer-{suffix}")
}
pub fn is_azure_deployer_vault_name(resource_prefix: &str, name: &str) -> bool {
let stem = azure_deployer_vault_name(resource_prefix, "");
name.strip_prefix(&stem).is_some_and(|suffix| {
suffix.len() == 6
&& suffix
.chars()
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit())
})
}
pub const KUBERNETES_SECRET_NAME_MAX_CHARS: usize = 253;
pub fn kubernetes_secret_name_tail(secret_name: &str) -> String {
format!("-{secret_name}")
.chars()
.filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_')
.collect::<String>()
.to_lowercase()
.replace('_', "-")
}
pub fn kubernetes_secret_name(vault_prefix: &str, secret_name: &str) -> String {
let clean = format!("{vault_prefix}{}", kubernetes_secret_name_tail(secret_name));
let clean: String = clean
.chars()
.filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_')
.collect::<String>()
.to_lowercase()
.replace('_', "-");
clean
.chars()
.take(KUBERNETES_SECRET_NAME_MAX_CHARS)
.collect()
}
pub const KUBERNETES_SECRET_VALUE_KEY: &str = "value";
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn marker_values_that_fit_are_kept() {
assert_eq!(vault_marker_value("acme-1a2b-secrets"), "acme-1a2b-secrets");
assert_eq!(vault_marker_value("a_b-9"), "a_b-9");
let longest = "a".repeat(63);
assert_eq!(vault_marker_value(&longest), longest);
}
#[test]
fn marker_values_that_do_not_fit_are_hashed_to_a_valid_label() {
let too_long = "a".repeat(64);
for raw in [too_long.as_str(), "Upper", "dot.name", "", "ünï"] {
let value = vault_marker_value(raw);
assert_eq!(value, vault_marker_value(raw), "stable");
assert_eq!(value.len(), 42);
assert!(value.starts_with("h-"));
assert!(value
.bytes()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_' || b == b'-'));
}
assert_ne!(vault_marker_value("Upper"), vault_marker_value("upper2"));
assert_eq!(
vault_marker_value("Upper"),
"h-".to_string() + &sha256_hex("Upper")[..40]
);
}
#[test]
fn azure_deployer_vault_names_fit_and_vary_between_installations() {
for prefix in ["a", "a-very-long-stack-resource-prefix"] {
let first = azure_deployer_vault_name(prefix, "a1b2c3");
assert!((3..=24).contains(&first.len()));
assert!(first
.chars()
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-'));
assert_ne!(first, azure_deployer_vault_name(prefix, "d4e5f6"));
}
}
#[test]
fn only_this_installations_deployer_vault_name_matches() {
let name = azure_deployer_vault_name("acme-prod", "a1b2c3");
assert!(is_azure_deployer_vault_name("acme-prod", &name));
assert!(!is_azure_deployer_vault_name("acme-stage", &name));
assert!(!is_azure_deployer_vault_name(
"acme-prod",
"acme-pro-deployer-a1b2c3d4"
));
assert!(!is_azure_deployer_vault_name(
"acme-prod",
"acme-prod-signing-a1b2c3"
));
assert!(!is_azure_deployer_vault_name(
"acme-prod",
"acme-prod-deployer-secrets-A1B2C3"
));
}
#[test]
fn a_stack_vault_is_never_taken_for_the_deployer_vault() {
for prefix in ["acme", "acme-prod-eastus", "acme-prod-eastus1"] {
let orders = format!("{prefix}-orders");
assert!(!is_azure_deployer_vault_name(prefix, &orders), "{orders}");
let own = azure_deployer_vault_name(prefix, "a1b2c3");
assert!(is_azure_deployer_vault_name(prefix, &own), "{own}");
assert!(own.len() <= 24, "{own}");
}
}
#[test]
fn kubernetes_names_are_dns_safe() {
assert_eq!(
kubernetes_secret_name("Acme-Monitoring-secrets", "API_KEY"),
"acme-monitoring-secrets-api-key"
);
assert_eq!(kubernetes_secret_name("p", &"x".repeat(400)).len(), 253);
}
#[test]
fn key_vault_names_use_hyphens() {
assert_eq!(key_vault_secret_name("API_KEY"), "API-KEY");
}
}