use std::path::PathBuf;
use anyhow::{bail, Context};
use clap::Args;
use crate::ffi;
#[derive(Args, Debug)]
pub struct VerifyArgs {
#[arg(value_name = "REFERENCE")]
pub reference: String,
#[arg(long = "key", value_name = "PATH")]
pub keys: Vec<String>,
#[arg(long)]
pub json: bool,
}
pub fn run(args: &VerifyArgs) -> anyhow::Result<()> {
crate::shortnames::validate_reference(&args.reference)?;
let reference = crate::shortnames::resolve(&args.reference)?;
let decision = crate::verify::decide(&reference)?;
let (keys, claims, identity) =
select_trust(&args.keys, decision, crate::verify::all_configured_keys)?;
let keys: Vec<String> = keys
.iter()
.map(|p| p.to_string_lossy().into_owned())
.collect();
if keys.is_empty() && identity.is_none() {
bail!(
"no trusted public keys to check {reference} against — pass --key PATH, \
or add a [[verify.trust]] rule to llmman.conf"
);
}
if keys.is_empty()
&& identity
.as_ref()
.is_some_and(|identity| identity.trusted_root.is_none())
{
bail!(
"cannot verify {reference}: the matching [[verify.trust]] rule names an identity \
but no `trusted_root` is configured under [verify]"
);
}
let report = ffi::verify(&reference, "", &keys, &claims, identity.as_ref())
.with_context(|| format!("verify {reference}"))?;
if args.json {
println!(
"{}",
serde_json::to_string_pretty(&JsonReport::from(&report))?
);
} else {
print_human(&report);
}
if report.verified {
Ok(())
} else if report.signatures_found == 0 {
bail!("{reference} is not signed")
} else {
bail!("{reference} is not signed by a trusted key")
}
}
fn select_trust(
explicit_keys: &[String],
decision: crate::verify::Decision,
all_keys: impl FnOnce() -> anyhow::Result<Vec<PathBuf>>,
) -> anyhow::Result<(Vec<PathBuf>, String, Option<ffi::Identity>)> {
if !explicit_keys.is_empty() {
let keys = explicit_keys.iter().map(PathBuf::from).collect();
return Ok((keys, decision.claims.unwrap_or_default(), None));
}
let identity = decision.identity();
let claims = decision.claims.unwrap_or_default();
let keys = if decision.keys.is_empty() && identity.is_none() {
all_keys()?
} else {
decision.keys
};
Ok((keys, claims, identity))
}
fn print_human(report: &ffi::VerifyReport) {
println!("Reference: {}", report.reference);
println!("Digest: {}", report.digest);
println!("Signatures: {}", report.signatures_found);
if report.verified {
println!("Verified: yes");
for m in &report.matches {
println!(" signed by {} claiming {}", m.signer, m.identity);
}
} else {
println!("Verified: no");
if !report.reason.is_empty() {
println!("Reason: {}", report.reason);
}
}
}
#[derive(serde::Serialize)]
#[serde(rename_all = "camelCase")]
struct JsonReport<'a> {
reference: &'a str,
digest: &'a str,
verified: bool,
signatures_found: u32,
matches: Vec<JsonMatch<'a>>,
#[serde(skip_serializing_if = "str::is_empty")]
reason: &'a str,
}
#[derive(serde::Serialize)]
#[serde(rename_all = "camelCase")]
struct JsonMatch<'a> {
signer: &'a str,
#[serde(skip_serializing_if = "str::is_empty")]
key_path: &'a str,
identity: &'a str,
}
impl<'a> From<&'a ffi::VerifyReport> for JsonReport<'a> {
fn from(r: &'a ffi::VerifyReport) -> Self {
Self {
reference: &r.reference,
digest: &r.digest,
verified: r.verified,
signatures_found: r.signatures_found,
matches: r
.matches
.iter()
.map(|m| JsonMatch {
signer: &m.signer,
key_path: &m.key_path,
identity: &m.identity,
})
.collect(),
reason: &r.reason,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::verify::{Decision, Mode};
#[test]
fn select_trust_keeps_claims_when_falling_back_to_all_keys() {
let decision = Decision {
mode: Mode::Warn,
keys: vec![],
claims: Some("docker.io/myorg/**".into()),
issuer: None,
subject: None,
trusted_root: None,
};
let (keys, claims, identity) =
select_trust(&[], decision, || Ok(vec![PathBuf::from("/k.pub")])).unwrap();
assert_eq!(keys, vec![PathBuf::from("/k.pub")]);
assert_eq!(claims, "docker.io/myorg/**");
assert_eq!(identity, None);
let decision = Decision {
mode: Mode::Warn,
keys: vec![PathBuf::from("/rule.pub")],
claims: None,
issuer: None,
subject: None,
trusted_root: None,
};
let (keys, claims, identity) =
select_trust(&[], decision, || panic!("fallback consulted")).unwrap();
assert_eq!(keys, vec![PathBuf::from("/rule.pub")]);
assert_eq!(claims, "");
assert_eq!(identity, None);
}
#[test]
fn select_trust_passes_an_identity_rule_through_without_widening_to_all_keys() {
let decision = Decision {
mode: Mode::Enforce,
keys: vec![],
claims: None,
issuer: Some("https://issuer".into()),
subject: Some("me@example.com".into()),
trusted_root: Some(PathBuf::from("/etc/llmman/root.json")),
};
let (keys, claims, identity) =
select_trust(&[], decision, || panic!("fallback consulted")).unwrap();
assert!(keys.is_empty());
assert_eq!(claims, "");
assert_eq!(
identity,
Some(ffi::Identity {
issuer: Some("https://issuer".into()),
subject: Some("me@example.com".into()),
trusted_root: Some("/etc/llmman/root.json".into()),
})
);
}
#[test]
fn select_trust_with_explicit_keys_checks_only_those_keys() {
for trusted_root in [Some(PathBuf::from("/etc/llmman/root.json")), None] {
let decision = Decision {
mode: Mode::Enforce,
keys: vec![PathBuf::from("/rule.pub")],
claims: Some("docker.io/myorg/**".into()),
issuer: Some("https://issuer".into()),
subject: Some("me@example.com".into()),
trusted_root,
};
let (keys, claims, identity) =
select_trust(&["/other.pub".to_string()], decision, || {
panic!("fallback consulted")
})
.unwrap();
assert_eq!(keys, vec![PathBuf::from("/other.pub")]);
assert_eq!(claims, "docker.io/myorg/**");
assert_eq!(identity, None);
}
}
}