#![forbid(unsafe_code)]
use bergshamra_core::Error;
use bergshamra_keys::key::{Key, KeyData, KeyUsage};
use bergshamra_keys::KeysManager;
use clap::{Parser, Subcommand};
use std::path::PathBuf;
use std::process;
#[derive(Parser)]
#[command(
name = "bergshamra",
about = "Bergshamra — Pure Rust XML Security (XML-DSig, XML-Enc, C14N)",
version
)]
struct Cli {
#[command(subcommand)]
command: Commands,
}
#[derive(Subcommand)]
enum Commands {
Verify {
file: PathBuf,
#[arg(short = 'k', long)]
key: Option<PathBuf>,
#[arg(short = 'K', long = "key-name")]
key_name: Vec<String>,
#[arg(long)]
cert: Vec<PathBuf>,
#[arg(long)]
trusted: Vec<PathBuf>,
#[arg(long)]
pkcs12: Option<PathBuf>,
#[arg(long)]
pwd: Option<String>,
#[arg(long = "hmac-key")]
hmac_key: Option<PathBuf>,
#[arg(long = "keys-file")]
keys_file: Option<PathBuf>,
#[arg(long = "url-map")]
url_map: Vec<String>,
#[arg(long = "id-attr")]
id_attr: Vec<String>,
#[arg(long = "hmac-min-out-len")]
hmac_min_out_len: Option<usize>,
#[arg(long)]
debug: bool,
#[arg(short, long)]
verbose: bool,
#[arg(long)]
insecure: bool,
#[arg(
long = "require-reference-digests",
conflicts_with = "allow_missing_reference_digests"
)]
require_reference_digests: bool,
#[arg(
long = "allow-missing-reference-digests",
conflicts_with = "require_reference_digests"
)]
allow_missing_reference_digests: bool,
#[arg(long = "verify-keys")]
verify_keys: bool,
#[arg(long = "verification-gmt-time")]
verification_gmt_time: Option<String>,
#[arg(long = "x509-skip-time-checks")]
x509_skip_time_checks: bool,
#[arg(long = "x509-skip-strict-checks")]
x509_skip_strict_checks: bool,
#[arg(long = "enabled-key-data")]
enabled_key_data: Option<String>,
#[arg(long)]
strict: bool,
#[arg(long = "trusted-keys-only")]
trusted_keys_only: bool,
#[arg(long)]
untrusted: Vec<PathBuf>,
#[arg(long)]
crl: Vec<PathBuf>,
},
Sign {
template: PathBuf,
#[arg(short = 'k', long)]
key: Option<PathBuf>,
#[arg(short = 'K', long = "key-name")]
key_name: Vec<String>,
#[arg(long)]
cert: Vec<PathBuf>,
#[arg(long)]
trusted: Vec<PathBuf>,
#[arg(long)]
pkcs12: Option<PathBuf>,
#[arg(long)]
pwd: Option<String>,
#[arg(long = "hmac-key")]
hmac_key: Option<PathBuf>,
#[arg(long = "keys-file")]
keys_file: Option<PathBuf>,
#[arg(long = "url-map")]
url_map: Vec<String>,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long = "id-attr")]
id_attr: Vec<String>,
#[arg(long = "session-key")]
session_key: Option<String>,
#[arg(long)]
debug: bool,
#[arg(short, long)]
verbose: bool,
},
Decrypt {
file: PathBuf,
#[arg(short = 'k', long)]
key: Option<PathBuf>,
#[arg(short = 'K', long = "key-name")]
key_name: Vec<String>,
#[arg(long)]
pkcs12: Option<PathBuf>,
#[arg(long)]
pwd: Option<String>,
#[arg(long = "hmac-key")]
hmac_key: Option<PathBuf>,
#[arg(long = "aes-key")]
aes_key: Option<PathBuf>,
#[arg(long = "keys-file")]
keys_file: Option<PathBuf>,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long = "id-attr")]
id_attr: Vec<String>,
#[arg(long = "no-cipher-reference")]
no_cipher_reference: bool,
#[arg(short, long)]
verbose: bool,
},
Encrypt {
template: PathBuf,
#[arg(long)]
data: PathBuf,
#[arg(long)]
cert: Vec<PathBuf>,
#[arg(short = 'K', long = "key-name")]
key_name: Vec<String>,
#[arg(long)]
pkcs12: Option<PathBuf>,
#[arg(long)]
pwd: Option<String>,
#[arg(long = "aes-key")]
aes_key: Option<PathBuf>,
#[arg(long = "keys-file")]
keys_file: Option<PathBuf>,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long = "id-attr")]
id_attr: Vec<String>,
#[arg(long = "node-name")]
node_name: Option<String>,
#[arg(long = "node-id")]
node_id: Option<String>,
#[arg(short, long)]
verbose: bool,
},
Info,
}
fn main() {
let cli = Cli::parse();
let result = match cli.command {
Commands::Verify {
file,
key,
key_name,
cert,
trusted,
pkcs12,
pwd,
hmac_key,
keys_file,
url_map,
id_attr,
hmac_min_out_len,
debug,
verbose,
insecure,
require_reference_digests,
allow_missing_reference_digests,
verify_keys,
verification_gmt_time,
x509_skip_time_checks,
x509_skip_strict_checks,
enabled_key_data,
strict,
trusted_keys_only,
untrusted,
crl,
} => cmd_verify(
file,
key,
key_name,
cert,
trusted,
pkcs12,
pwd,
hmac_key,
keys_file,
url_map,
id_attr,
hmac_min_out_len,
debug,
verbose,
insecure,
require_reference_digests,
allow_missing_reference_digests,
verify_keys,
verification_gmt_time,
x509_skip_time_checks,
x509_skip_strict_checks,
enabled_key_data,
strict,
trusted_keys_only,
untrusted,
crl,
),
Commands::Sign {
template,
key,
key_name,
cert,
trusted,
pkcs12,
pwd,
hmac_key,
keys_file,
url_map,
output,
id_attr,
session_key,
debug,
verbose,
} => cmd_sign(
template,
key,
key_name,
cert,
trusted,
pkcs12,
pwd,
hmac_key,
keys_file,
url_map,
output,
id_attr,
session_key,
debug,
verbose,
),
Commands::Decrypt {
file,
key,
key_name,
pkcs12,
pwd,
hmac_key,
aes_key,
keys_file,
output,
id_attr,
no_cipher_reference,
verbose,
} => cmd_decrypt(
file,
key,
key_name,
pkcs12,
pwd,
hmac_key,
aes_key,
keys_file,
output,
id_attr,
no_cipher_reference,
verbose,
),
Commands::Encrypt {
template,
data,
cert,
key_name,
pkcs12,
pwd,
aes_key,
keys_file,
output,
id_attr,
node_name,
node_id,
verbose,
} => cmd_encrypt(
template, data, cert, key_name, pkcs12, pwd, aes_key, keys_file, output, id_attr,
node_name, node_id, verbose,
),
Commands::Info => cmd_info(),
};
if let Err(e) = result {
eprintln!("Error: {e}");
process::exit(1);
}
}
#[allow(clippy::too_many_arguments)]
fn cmd_verify(
file: PathBuf,
key: Option<PathBuf>,
key_name: Vec<String>,
certs: Vec<PathBuf>,
trusted: Vec<PathBuf>,
pkcs12: Option<PathBuf>,
pwd: Option<String>,
hmac_key: Option<PathBuf>,
keys_file: Option<PathBuf>,
url_map: Vec<String>,
id_attr: Vec<String>,
hmac_min_out_len: Option<usize>,
debug: bool,
verbose: bool,
insecure: bool,
require_reference_digests: bool,
allow_missing_reference_digests: bool,
verify_keys: bool,
verification_gmt_time: Option<String>,
x509_skip_time_checks: bool,
x509_skip_strict_checks: bool,
enabled_key_data: Option<String>,
strict: bool,
trusted_keys_only: bool,
untrusted: Vec<PathBuf>,
crl: Vec<PathBuf>,
) -> Result<(), Error> {
let xml = read_file(&file)?;
let mut all_certs = certs;
all_certs.extend(untrusted.iter().cloned());
let mut mgr = build_keys_manager(
key,
key_name,
all_certs,
trusted.clone(),
pkcs12,
pwd.as_deref(),
hmac_key,
None,
keys_file,
)?;
for path in &trusted {
let der_certs = load_certs_as_der(path)?;
for der in der_certs {
mgr.add_trusted_cert(der);
}
}
for path in &untrusted {
let der_certs = load_certs_as_der(path)?;
for der in der_certs {
mgr.add_untrusted_cert(der);
}
}
for path in &crl {
let der_crls = load_crl_as_der(path)?;
for der in der_crls {
mgr.add_crl(der);
}
}
let mut ctx = bergshamra_dsig::DsigContext::new_permissive(mgr);
for attr in &id_attr {
ctx.add_id_attr(attr);
}
for spec in &url_map {
if let Some((url, file_path)) = spec.split_once('=') {
ctx.add_url_map(url, file_path);
}
}
if let Some(min_len) = hmac_min_out_len {
ctx.hmac_min_out_len = min_len;
}
ctx.debug = debug;
if let Some(parent) = file.parent() {
ctx.base_dir = Some(parent.to_string_lossy().into_owned());
}
ctx.insecure = insecure;
ctx.verify_keys = verify_keys;
ctx.require_reference_digests = require_reference_digests || !allow_missing_reference_digests;
ctx.verification_time = verification_gmt_time;
ctx.skip_time_checks = x509_skip_time_checks;
ctx.enabled_key_data_x509 = enabled_key_data
.as_deref()
.map(|s| s.split(',').any(|part| part.trim() == "x509"))
.unwrap_or(false);
if !trusted.is_empty() && !x509_skip_strict_checks {
ctx.enabled_key_data_x509 = true;
}
ctx.allow_raw_inline_keyinfo_with_trust_anchors = x509_skip_strict_checks;
ctx.strict_verification = strict;
ctx.trusted_keys_only = trusted_keys_only;
if verbose {
eprintln!("Verifying: {}", file.display());
}
let result = bergshamra_dsig::verify::verify(&ctx, &xml)?;
match &result {
bergshamra_dsig::verify::VerifyResult::Valid { references, .. } => {
if verbose {
if let Some(reason) = reference_digest_warning_reason(references) {
eprintln!("Warning: {reason}");
}
}
println!("OK");
Ok(())
}
bergshamra_dsig::verify::VerifyResult::Invalid { reason } => {
eprintln!("INVALID: {reason}");
process::exit(1);
}
}
}
fn reference_digest_warning_reason(
references: &[bergshamra_dsig::verify::VerifiedReference],
) -> Option<&'static str> {
let verified_count = references
.iter()
.filter(|reference| reference.digest_verified)
.count();
reference_digest_warning_reason_from_counts(references.len(), verified_count)
}
fn reference_digest_warning_reason_from_counts(
reference_count: usize,
verified_count: usize,
) -> Option<&'static str> {
if reference_count == 0 || verified_count == 0 {
Some("no Reference digests were verified locally")
} else if verified_count < reference_count {
Some("one or more Reference digests were not verified locally")
} else {
None
}
}
#[allow(clippy::too_many_arguments)]
fn cmd_sign(
template: PathBuf,
key: Option<PathBuf>,
key_name: Vec<String>,
certs: Vec<PathBuf>,
trusted: Vec<PathBuf>,
pkcs12: Option<PathBuf>,
pwd: Option<String>,
hmac_key: Option<PathBuf>,
keys_file: Option<PathBuf>,
url_map: Vec<String>,
output: Option<PathBuf>,
id_attr: Vec<String>,
session_key: Option<String>,
debug: bool,
verbose: bool,
) -> Result<(), Error> {
let template_xml = read_file(&template)?;
let mut mgr = build_keys_manager(
key,
key_name,
certs,
trusted,
pkcs12,
pwd.as_deref(),
hmac_key,
None,
keys_file,
)?;
if let Some(ref spec) = session_key {
let key = generate_session_key(spec)?;
mgr.insert_key_first(key);
}
let mut ctx = bergshamra_dsig::DsigContext::new_permissive(mgr);
for attr in &id_attr {
ctx.add_id_attr(attr);
}
for spec in &url_map {
if let Some((url, file_path)) = spec.split_once('=') {
ctx.add_url_map(url, file_path);
}
}
ctx.debug = debug;
if let Some(parent) = template.parent() {
ctx.base_dir = Some(parent.to_string_lossy().into_owned());
}
if verbose {
eprintln!("Signing: {}", template.display());
}
let signed = bergshamra_dsig::sign::sign(&ctx, &template_xml)?;
write_output(output, signed.as_bytes())
}
#[allow(clippy::too_many_arguments)]
fn cmd_decrypt(
file: PathBuf,
key: Option<PathBuf>,
key_name: Vec<String>,
pkcs12: Option<PathBuf>,
pwd: Option<String>,
hmac_key: Option<PathBuf>,
aes_key: Option<PathBuf>,
keys_file: Option<PathBuf>,
output: Option<PathBuf>,
id_attr: Vec<String>,
no_cipher_reference: bool,
verbose: bool,
) -> Result<(), Error> {
let xml = read_file(&file)?;
let mgr = build_keys_manager(
key,
key_name,
vec![],
vec![],
pkcs12,
pwd.as_deref(),
hmac_key,
aes_key,
keys_file,
)?;
let mut ctx = bergshamra_enc::EncContext::new(mgr);
for attr in &id_attr {
ctx.add_id_attr(attr);
}
ctx.disable_cipher_reference = no_cipher_reference;
if verbose {
eprintln!("Decrypting: {}", file.display());
}
let decrypted = bergshamra_enc::decrypt::decrypt_to_bytes(&ctx, &xml)?;
write_output(output, &decrypted)
}
#[allow(clippy::too_many_arguments)]
fn cmd_encrypt(
template: PathBuf,
data_file: PathBuf,
certs: Vec<PathBuf>,
key_name: Vec<String>,
pkcs12: Option<PathBuf>,
pwd: Option<String>,
aes_key: Option<PathBuf>,
keys_file: Option<PathBuf>,
output: Option<PathBuf>,
id_attr: Vec<String>,
node_name: Option<String>,
node_id: Option<String>,
verbose: bool,
) -> Result<(), Error> {
let template_xml = read_file(&template)?;
let data = std::fs::read(&data_file)
.map_err(|e| Error::Other(format!("{}: {e}", data_file.display())))?;
let data = if template_has_wrapper(&template_xml) {
extract_node_data(&data, node_name.as_deref(), node_id.as_deref(), &id_attr)?
} else {
data
};
let mgr = build_keys_manager(
None,
key_name,
certs,
vec![],
pkcs12,
pwd.as_deref(),
None,
aes_key,
keys_file,
)?;
let mut ctx = bergshamra_enc::EncContext::new(mgr);
for attr in &id_attr {
ctx.add_id_attr(attr);
}
if verbose {
eprintln!("Encrypting: {}", data_file.display());
}
let encrypted = bergshamra_enc::encrypt::encrypt(&ctx, &template_xml, &data)?;
write_output(output, encrypted.as_bytes())
}
fn template_has_wrapper(template_xml: &str) -> bool {
if let Ok(doc) = uppsala::parse(template_xml) {
if let Some(root_id) = doc.document_element() {
if let Some(elem) = doc.element(root_id) {
return &*elem.name.local_name != "EncryptedData";
}
}
false
} else {
false
}
}
fn extract_node_data(
data: &[u8],
node_name: Option<&str>,
node_id: Option<&str>,
id_attrs: &[String],
) -> Result<Vec<u8>, Error> {
if node_name.is_none() && node_id.is_none() {
return Ok(data.to_vec());
}
let xml_str = std::str::from_utf8(data)
.map_err(|e| Error::Other(format!("data is not valid UTF-8: {e}")))?;
let doc = uppsala::parse(xml_str).map_err(|e| Error::XmlParse(e.to_string()))?;
let target_node_id = if let Some(name) = node_name {
let (ns_uri, local_name) = if let Some(colon_pos) = name.rfind(':') {
(&name[..colon_pos], &name[colon_pos + 1..])
} else {
("", name)
};
doc.descendants(doc.root())
.into_iter()
.find(|&nid| {
if let Some(elem) = doc.element(nid) {
&*elem.name.local_name == local_name
&& (ns_uri.is_empty()
|| elem.name.namespace_uri.as_deref().unwrap_or("") == ns_uri)
} else {
false
}
})
.ok_or_else(|| Error::MissingElement(format!("element matching --node-name {name}")))?
} else if let Some(id) = node_id {
let mut id_attr_names: Vec<&str> = vec!["Id", "ID", "id"];
let extra: Vec<&str> = id_attrs.iter().map(|s| s.as_str()).collect();
id_attr_names.extend(extra);
doc.descendants(doc.root())
.into_iter()
.find(|&nid| {
if let Some(elem) = doc.element(nid) {
id_attr_names
.iter()
.any(|attr| elem.get_attribute(attr) == Some(id))
} else {
false
}
})
.ok_or_else(|| Error::MissingElement(format!("element with ID={id}")))?
} else {
unreachable!()
};
let range = doc
.node_range(target_node_id)
.ok_or_else(|| Error::Other("could not determine source range for node".into()))?;
Ok(xml_str.as_bytes()[range.start..range.end].to_vec())
}
fn cmd_info() -> Result<(), Error> {
println!("Bergshamra — Pure Rust XML Security Library");
println!();
println!("Supported digest algorithms:");
println!(" SHA-1, SHA-224, SHA-256, SHA-384, SHA-512");
println!(" SHA3-224, SHA3-256, SHA3-384, SHA3-512");
println!();
println!("Supported signature algorithms:");
println!(" RSA PKCS#1 v1.5 (SHA-1, SHA-224, SHA-256, SHA-384, SHA-512)");
println!(" RSA-PSS (SHA-1, SHA-224, SHA-256, SHA-384, SHA-512)");
println!(" ECDSA P-256/P-384 (SHA-1, SHA-256, SHA-384, SHA-512)");
println!(" HMAC (SHA-1, SHA-256, SHA-384, SHA-512)");
println!(" EdDSA Ed25519");
println!();
println!("Supported encryption algorithms:");
println!(" AES-128/192/256-CBC, AES-128/256-GCM, 3DES-CBC");
println!();
println!("Supported key wrap algorithms:");
println!(" AES-KW 128/192/256");
println!();
println!("Supported key transport algorithms:");
println!(" RSA PKCS#1 v1.5, RSA-OAEP (SHA-1)");
println!();
println!("Supported key agreement algorithms:");
println!(" ECDH-ES (P-256, P-384, P-521), DH-ES (X9.42), X25519");
println!();
println!("Supported key derivation functions:");
println!(" ConcatKDF, PBKDF2, HKDF (SHA-256/384/512)");
println!();
println!("Supported canonicalization:");
println!(" C14N 1.0 (±comments)");
println!(" C14N 1.1 (±comments)");
println!(" Exclusive C14N 1.0 (±comments)");
println!();
println!("Supported key formats:");
println!(" PEM, DER (RSA, EC, Ed25519, X25519), raw binary (HMAC, AES)");
Ok(())
}
fn read_file(path: &PathBuf) -> Result<String, Error> {
std::fs::read_to_string(path).map_err(|e| Error::Other(format!("{}: {e}", path.display())))
}
fn load_certs_as_der(path: &PathBuf) -> Result<Vec<Vec<u8>>, Error> {
let data = std::fs::read(path).map_err(|e| Error::Other(format!("{}: {e}", path.display())))?;
if data.starts_with(b"-----") {
let text = std::str::from_utf8(&data)
.map_err(|e| Error::Other(format!("{}: invalid UTF-8: {e}", path.display())))?;
let certs = pem_decode_all(text, "CERTIFICATE")?;
if certs.is_empty() {
return Err(Error::Other(format!(
"{}: no CERTIFICATE found in PEM",
path.display()
)));
}
Ok(certs)
} else {
Ok(vec![data])
}
}
fn load_crl_as_der(path: &PathBuf) -> Result<Vec<Vec<u8>>, Error> {
let data = std::fs::read(path).map_err(|e| Error::Other(format!("{}: {e}", path.display())))?;
if data.starts_with(b"-----") {
let text = std::str::from_utf8(&data)
.map_err(|e| Error::Other(format!("{}: invalid UTF-8: {e}", path.display())))?;
let crls = pem_decode_all(text, "X509 CRL")?;
if crls.is_empty() {
return Err(Error::Other(format!(
"{}: no X509 CRL found in PEM",
path.display()
)));
}
Ok(crls)
} else {
Ok(vec![data])
}
}
fn pem_decode_all(text: &str, label: &str) -> Result<Vec<Vec<u8>>, Error> {
use base64::Engine;
let engine = base64::engine::general_purpose::STANDARD;
let begin_marker = format!("-----BEGIN {}-----", label);
let end_marker = format!("-----END {}-----", label);
let mut results = Vec::new();
let mut remaining = text;
while let Some(start) = remaining.find(&begin_marker) {
let after_begin = &remaining[start + begin_marker.len()..];
if let Some(end) = after_begin.find(&end_marker) {
let b64_content: String = after_begin[..end]
.chars()
.filter(|c| !c.is_whitespace())
.collect();
let der = engine
.decode(&b64_content)
.map_err(|e| Error::Other(format!("PEM base64 decode error: {e}")))?;
results.push(der);
remaining = &after_begin[end + end_marker.len()..];
} else {
break;
}
}
Ok(results)
}
fn write_output(path: Option<PathBuf>, data: &[u8]) -> Result<(), Error> {
match path {
Some(p) => {
std::fs::write(&p, data).map_err(|e| Error::Other(format!("{}: {e}", p.display())))
}
None => {
use std::io::Write;
std::io::stdout()
.write_all(data)
.map_err(|e| Error::Other(format!("stdout: {e}")))
}
}
}
fn generate_session_key(spec: &str) -> Result<Key, Error> {
let parts: Vec<&str> = spec.splitn(2, '-').collect();
if parts.len() != 2 {
return Err(Error::Other(format!(
"invalid session-key spec: {spec} (expected TYPE-BITS, e.g. hmac-192)"
)));
}
let key_type = parts[0];
let bits: usize = parts[1]
.parse()
.map_err(|_| Error::Other(format!("invalid bit size in session-key spec: {spec}")))?;
if !bits.is_multiple_of(8) || bits == 0 {
return Err(Error::Other(format!(
"session-key bit size must be a positive multiple of 8: {bits}"
)));
}
let byte_len = bits / 8;
let key_bytes =
kryptering::random_bytes(byte_len).map_err(|err| Error::Crypto(err.to_string()))?;
let key_data = match key_type {
"hmac" => KeyData::from_symmetric_bytes(kryptering::KeyAlgorithm::Hmac, &key_bytes)?,
"aes" => KeyData::from_symmetric_bytes(kryptering::KeyAlgorithm::Aes, &key_bytes)?,
"des" | "des3" | "tripledes" => {
KeyData::from_symmetric_bytes(kryptering::KeyAlgorithm::TripleDes, &key_bytes)?
}
_ => {
return Err(Error::Other(format!(
"unsupported session-key type: {key_type}"
)))
}
};
Ok(Key::new(key_data, KeyUsage::Any))
}
#[allow(clippy::too_many_arguments)]
fn build_keys_manager(
key_path: Option<PathBuf>,
key_names: Vec<String>,
cert_paths: Vec<PathBuf>,
trusted_paths: Vec<PathBuf>,
pkcs12_path: Option<PathBuf>,
password: Option<&str>,
hmac_key_spec: Option<PathBuf>,
aes_key_path: Option<PathBuf>,
keys_file_path: Option<PathBuf>,
) -> Result<KeysManager, Error> {
let mut mgr = KeysManager::new();
if let Some(path) = keys_file_path {
let keys = bergshamra_keys::keysxml::load_keys_file(&path)?;
for key in keys {
mgr.add_key(key);
}
}
if let Some(path) = key_path {
let key = bergshamra_keys::loader::load_key_file_with_password(&path, password)?;
mgr.add_key(key);
}
for spec in &key_names {
if let Some((name, file_str)) = spec.split_once(':') {
let path = PathBuf::from(file_str);
let mut key =
match bergshamra_keys::loader::load_key_file_with_password(&path, password) {
Ok(key) => key,
Err(error) => match path.extension().and_then(|value| value.to_str()) {
Some("bin") => {
let bytes = std::fs::read(&path)
.map_err(|e| Error::Other(format!("{}: {e}", path.display())))?;
Key::new(
KeyData::from_symmetric_bytes(
kryptering::KeyAlgorithm::Hmac,
&bytes,
)?,
KeyUsage::Any,
)
}
Some("key") => {
let bytes = std::fs::read(&path)
.map_err(|e| Error::Other(format!("{}: {e}", path.display())))?;
Key::new(
KeyData::from_symmetric_bytes(
kryptering::KeyAlgorithm::Aes,
&bytes,
)?,
KeyUsage::Any,
)
}
_ => return Err(error),
},
};
key.name = Some(name.to_owned());
mgr.add_key(key);
} else {
return Err(Error::Other(format!(
"invalid key-name format: {spec} (expected NAME:FILE)"
)));
}
}
if let Some(path) = pkcs12_path {
let data =
std::fs::read(&path).map_err(|e| Error::Other(format!("{}: {e}", path.display())))?;
let key = bergshamra_keys::loader::load_pkcs12(&data, password.unwrap_or(""))?;
mgr.add_key(key);
}
for path in &cert_paths {
let key = bergshamra_keys::loader::load_key_file_with_password(path, password)?;
mgr.add_key(key);
}
for path in &trusted_paths {
let key = bergshamra_keys::loader::load_key_file_with_password(path, password)?;
mgr.add_key(key);
}
if let Some(spec) = hmac_key_spec {
let spec_str = spec.to_string_lossy();
let (name, path) = if let Some((n, f)) = spec_str.split_once(':') {
if !n.contains('/') && !n.contains('\\') && !f.is_empty() {
(Some(n.to_owned()), PathBuf::from(f))
} else {
(None, spec.clone())
}
} else {
(None, spec.clone())
};
let bytes =
std::fs::read(&path).map_err(|e| Error::Other(format!("{}: {e}", path.display())))?;
let mut key = Key::new(
KeyData::from_symmetric_bytes(kryptering::KeyAlgorithm::Hmac, &bytes)?,
KeyUsage::Any,
);
key.name = name;
mgr.add_key(key);
}
if let Some(path) = aes_key_path {
let bytes =
std::fs::read(&path).map_err(|e| Error::Other(format!("{}: {e}", path.display())))?;
let key = Key::new(
KeyData::from_symmetric_bytes(kryptering::KeyAlgorithm::Aes, &bytes)?,
KeyUsage::Any,
);
mgr.add_key(key);
}
Ok(mgr)
}
#[cfg(test)]
mod tests {
fn should_validate_inline_x509(
has_trusted: bool,
x509_skip_strict_checks: bool,
enabled_key_data: Option<&str>,
) -> bool {
let enabled_key_data_x509 = enabled_key_data
.map(|s| s.split(',').any(|part| part.trim() == "x509"))
.unwrap_or(false);
enabled_key_data_x509 || (has_trusted && !x509_skip_strict_checks)
}
#[test]
fn trusted_roots_enable_inline_x509_validation_by_default() {
assert!(should_validate_inline_x509(true, false, None));
}
#[test]
fn skip_strict_checks_preserves_xmlsec_compat_mode() {
assert!(!should_validate_inline_x509(true, true, None));
}
#[test]
fn explicit_enabled_key_data_x509_still_wins() {
assert!(should_validate_inline_x509(
false,
true,
Some("key-name,x509")
));
}
#[test]
fn reference_warning_reports_no_digests_for_zero_references() {
assert_eq!(
super::reference_digest_warning_reason_from_counts(0, 0),
Some("no Reference digests were verified locally")
);
}
#[test]
fn reference_warning_reports_no_digests_for_all_unverified_references() {
assert_eq!(
super::reference_digest_warning_reason_from_counts(2, 0),
Some("no Reference digests were verified locally")
);
}
#[test]
fn reference_warning_reports_some_missing_digests_for_mixed_references() {
assert_eq!(
super::reference_digest_warning_reason_from_counts(2, 1),
Some("one or more Reference digests were not verified locally")
);
}
#[test]
fn reference_warning_is_absent_when_all_digests_are_verified() {
assert_eq!(
super::reference_digest_warning_reason_from_counts(2, 2),
None
);
}
}