auths_cli/commands/device/

verify_attestation.rs

use crate::ux::format::is_json_mode;
use anyhow::{Context, Result, anyhow};
use auths_keri::witness::SignedReceipt;
use auths_sdk::ports::IdentityStorage;
use auths_sdk::trust::{PinnedIdentity, PinnedIdentityStore, RootsFile, TrustLevel, TrustPolicy};
use auths_verifier::core::Attestation;
use auths_verifier::verify::{verify_chain_with_witnesses, verify_with_keys};
use auths_verifier::witness::WitnessVerifyConfig;
use chrono::Utc;
use clap::{Parser, ValueEnum};
use serde::Serialize;
use std::fs;
use std::io::{self, IsTerminal, Read};
use std::path::PathBuf;
use std::process;

/// Trust policy for identity verification.
#[derive(Debug, Clone, Copy, Default, ValueEnum)]
pub enum CliTrustPolicy {
    /// Trust-on-first-use: prompt interactively on first encounter.
    #[default]
    Tofu,
    /// Explicit trust: require identity in pinned store or roots.json.
    Explicit,
}

#[derive(Parser, Debug, Clone)]
#[command(about = "Verify device authorization signatures.")]
pub struct VerifyCommand {
    /// Path to authorization JSON file, or "-" to read from stdin.
    #[arg(long, value_parser, required = true)]
    pub attestation: String,

    /// Signer public key in hex format (64 hex chars = 32 bytes).
    ///
    /// If provided, bypasses trust resolution and uses this key directly.
    /// Takes precedence over --signer and trust policy.
    #[arg(long = "signer-key", value_parser)]
    pub issuer_pk: Option<String>,

    /// Signer identity ID for trust-based key resolution.
    ///
    /// Looks up the public key from pinned identity store or roots.json.
    /// Uses --trust policy to determine behavior for unknown identities.
    #[arg(long = "signer", visible_alias = "issuer-did", value_parser)]
    pub issuer_did: Option<String>,

    /// Trust policy for unknown identities.
    ///
    /// Resolution precedence:
    ///   1. --issuer-pk (direct key, bypasses trust)
    ///   2. Pinned identity store (~/.auths/known_identities.json)
    ///   3. Repository roots.json (.auths/roots.json)
    ///   4. TOFU prompt (if TTY) or explicit rejection (if non-TTY)
    ///
    /// Defaults: tofu on TTY, explicit on non-TTY (CI).
    #[arg(long, value_enum)]
    pub trust: Option<CliTrustPolicy>,

    /// Path to roots.json file for explicit trust.
    ///
    /// Overrides default .auths/roots.json lookup.
    #[arg(long = "roots-file", value_parser)]
    pub roots_file: Option<PathBuf>,

    /// Path to witness signatures JSON file.
    #[arg(long = "witness-signatures")]
    pub witness_receipts: Option<PathBuf>,

    /// Number of witnesses required (default: 1).
    #[arg(long = "witnesses-required", default_value = "1")]
    pub witness_threshold: usize,

    /// Witness public keys as DID:hex pairs (e.g., "did:key:z6Mk...:abcd1234...").
    #[arg(long, num_args = 1..)]
    pub witness_keys: Vec<String>,
}

#[derive(Serialize)]
struct VerifyResult {
    valid: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    issuer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    subject: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    witness_quorum: Option<auths_verifier::witness::WitnessQuorum>,
    /// The verdict's surfaced freshness (ADR 009) — present only on a honored verdict. An
    /// offline attestation verify cannot confirm freshness, so it names `Unknown`, never a
    /// bare success that reads as real-time fresh.
    #[serde(skip_serializing_if = "Option::is_none")]
    freshness: Option<auths_verifier::Freshness>,
}

/// Handle verify command. Returns Ok(()) on success, Err on error.
/// Uses exit codes: 0=valid, 1=invalid, 2=error
pub async fn handle_verify(cmd: VerifyCommand) -> Result<()> {
    #[allow(clippy::disallowed_methods)]
    let now = Utc::now();
    let result = run_verify(now, &cmd).await;

    match result {
        Ok(verify_result) => {
            if is_json_mode() {
                println!("{}", serde_json::to_string(&verify_result)?);
            }

            if verify_result.valid {
                // Exit code 0 for valid
                Ok(())
            } else {
                // Exit code 1 for invalid attestation
                if !is_json_mode() {
                    eprintln!(
                        "Attestation verification failed: {}",
                        verify_result.error.as_deref().unwrap_or("unknown error")
                    );
                }
                process::exit(1);
            }
        }
        Err(e) => {
            // Exit code 2 for errors (file not found, parse error, etc.)
            if is_json_mode() {
                let error_result = VerifyResult {
                    valid: false,
                    error: Some(e.to_string()),
                    issuer: None,
                    subject: None,
                    witness_quorum: None,
                    freshness: None,
                };
                println!("{}", serde_json::to_string(&error_result)?);
            } else {
                eprintln!("Error: {}", e);
            }
            process::exit(2);
        }
    }
}

/// Determine effective trust policy.
///
/// If explicitly set via --trust, use that.
/// Otherwise: TOFU on TTY, Explicit on non-TTY (CI).
fn effective_trust_policy(cmd: &VerifyCommand) -> TrustPolicy {
    match cmd.trust {
        Some(CliTrustPolicy::Tofu) => TrustPolicy::Tofu,
        Some(CliTrustPolicy::Explicit) => TrustPolicy::Explicit,
        None => {
            if io::stdin().is_terminal() {
                TrustPolicy::Tofu
            } else {
                TrustPolicy::Explicit
            }
        }
    }
}

/// Wrap raw pubkey bytes into a curve-tagged `DevicePublicKey`.
fn bytes_to_device_public_key(
    bytes: &[u8],
    curve: auths_crypto::CurveType,
    source: &str,
) -> Result<auths_verifier::DevicePublicKey> {
    auths_verifier::DevicePublicKey::try_new(curve, bytes)
        .map_err(|e| anyhow!("Invalid {} public key: {e}", source))
}

/// Resolve the issuer key via self-trust: when the issuer is the verifier's own
/// local identity, replay its KEL from the local registry for the current key.
///
/// Self-trust is the floor of the trust model — a verifier always trusts keys it
/// itself controls, so signing and verifying your own attestation needs zero
/// pinning ceremony. Returns `None` for any other issuer (normal trust
/// resolution applies).
fn resolve_self_issuer_key(did: &str) -> Option<auths_verifier::DevicePublicKey> {
    let auths_home = auths_sdk::paths::auths_home().ok()?;
    let local = auths_sdk::storage::RegistryIdentityStorage::new(auths_home.clone())
        .load_identity()
        .ok()?;
    if local.controller_did.as_str() != did {
        return None;
    }
    let registry = auths_sdk::storage::GitRegistryBackend::from_config_unchecked(
        auths_sdk::storage::RegistryConfig::single_tenant(&auths_home),
    );
    let (pk, curve) = auths_sdk::keri::resolve_current_public_key(&registry, did).ok()?;
    auths_verifier::DevicePublicKey::try_new(curve, &pk).ok()
}

/// Resolve the issuer public key from various sources.
///
/// Resolution precedence:
/// 1. `--issuer-pk` (direct key, bypasses trust)
/// 2. Self-trust (the verifier's own identity, resolved from its local KEL)
/// 3. Pinned identity store
/// 4. `roots.json` file
/// 5. Trust policy (TOFU prompt or explicit rejection)
fn resolve_issuer_key(
    now: chrono::DateTime<Utc>,
    cmd: &VerifyCommand,
    att: &Attestation,
) -> Result<auths_verifier::DevicePublicKey> {
    // 1. Direct key takes precedence
    if let Some(ref pk_hex) = cmd.issuer_pk {
        let pk_bytes =
            hex::decode(pk_hex).context("Invalid hex string provided for issuer public key")?;
        let issuer_did = cmd.issuer_did.as_deref().unwrap_or(att.issuer.as_str());
        let curve = auths_crypto::did_key_decode(issuer_did)
            .map(|d| d.curve())
            .unwrap_or_default();
        return auths_verifier::DevicePublicKey::try_new(curve, &pk_bytes)
            .map_err(|e| anyhow!("Invalid issuer public key: {e}"));
    }

    // Determine the DID to look up
    let did = cmd.issuer_did.as_deref().unwrap_or(att.issuer.as_str());

    // 2. Self-trust: the verifier's own identity resolves from its local KEL.
    if let Some(pk) = resolve_self_issuer_key(did) {
        if !is_json_mode() {
            println!("Using local identity (self-trust): {}", did);
        }
        return Ok(pk);
    }

    // Get trust policy
    let policy = effective_trust_policy(cmd);
    let store = PinnedIdentityStore::new(PinnedIdentityStore::default_path());

    // 2. Check pinned identity store first
    if let Some(pin) = store.lookup(did)? {
        if !is_json_mode() {
            println!("Using pinned identity: {}", did);
        }
        return bytes_to_device_public_key(&pin.public_key_bytes()?, pin.curve, "pinned identity");
    }

    // 3. Check roots.json file
    let roots_path = cmd.roots_file.clone().unwrap_or_else(|| {
        std::env::current_dir()
            .unwrap_or_default()
            .join(".auths/roots.json")
    });

    if roots_path.exists() {
        let roots = RootsFile::load(&roots_path)?;
        if let Some(root) = roots.find(did) {
            if !is_json_mode() {
                println!(
                    "Using root from {}: {}",
                    roots_path.display(),
                    root.note.as_deref().unwrap_or(did)
                );
            }
            // Pin from roots.json for future use
            let pin = PinnedIdentity {
                did: did.to_string(),
                public_key_hex: root.public_key_hex.clone(),
                curve: root.curve,
                kel_tip_said: root.kel_tip_said.clone(),
                kel_sequence: None,
                first_seen: now,
                origin: format!("roots.json:{}", roots_path.display()),
                trust_level: TrustLevel::OrgPolicy,
            };
            store.pin(pin)?;
            return bytes_to_device_public_key(&root.public_key_bytes()?, root.curve, "roots.json");
        }
    }

    // 4. Apply trust policy
    match policy {
        TrustPolicy::Tofu => {
            // Need to extract key from attestation for TOFU
            // The attestation itself doesn't contain the issuer's public key directly,
            // so we need it from --issuer-pk or the user needs to provide it
            anyhow::bail!(
                "Unknown identity '{}'. Provide --signer-key to trust on first use, \
                 or add to .auths/roots.json for explicit trust.",
                did
            );
        }
        TrustPolicy::Explicit => {
            anyhow::bail!(
                "Unknown identity '{}' and trust policy is 'explicit'.\n\
                 Options:\n  \
                 1. Add to .auths/roots.json in the repository\n  \
                 2. Pin manually: auths trust pin --did {} --key <hex>\n  \
                 3. Provide --signer-key <hex> to bypass trust resolution",
                did,
                did
            );
        }
    }
}

use crate::commands::verify_helpers::parse_witness_keys;

async fn run_verify(now: chrono::DateTime<Utc>, cmd: &VerifyCommand) -> Result<VerifyResult> {
    // 1. Read attestation from file or stdin
    let attestation_bytes = if cmd.attestation == "-" {
        let mut buffer = Vec::new();
        io::stdin()
            .read_to_end(&mut buffer)
            .context("Failed to read attestation from stdin")?;
        buffer
    } else {
        let path = PathBuf::from(&cmd.attestation);
        fs::read(&path).with_context(|| format!("Failed to read attestation file: {:?}", path))?
    };

    // 2. Deserialize attestation JSON
    let att: Attestation =
        serde_json::from_slice(&attestation_bytes).context("Failed to parse JSON attestation")?;

    if !is_json_mode() {
        println!(
            "Verifying attestation: issuer={}, subject={}",
            att.issuer, att.subject
        );
    }

    // 3. Resolve issuer public key
    let issuer_pk = resolve_issuer_key(now, cmd, &att)?;

    // 4. Verify the attestation's authenticity (signatures, expiry, linkage).
    //    Capability authority is no longer gated here: a capability grant must come
    //    from a holder-verified ACDC credential, not the attestation's caps field.
    let verify_result = verify_with_keys(&att, &issuer_pk).await;

    match verify_result {
        Ok(_) => {
            // An offline attestation verify consults no fresher source, so the honest default
            // is `Unknown` (ADR 009); the witness path below upgrades it from the report it
            // already computes. The verdict is never surfaced as a bare success.
            let mut verdict_freshness = auths_verifier::Freshness::Unknown;
            // 6. If witness receipts are provided, do witness chain verification
            let witness_quorum = if let Some(ref receipts_path) = cmd.witness_receipts {
                let receipts_bytes = fs::read(receipts_path).with_context(|| {
                    format!("Failed to read witness receipts: {:?}", receipts_path)
                })?;
                let receipts: Vec<SignedReceipt> = serde_json::from_slice(&receipts_bytes)
                    .context("Failed to parse witness receipts JSON")?;
                let witness_keys = parse_witness_keys(&cmd.witness_keys)?;

                let config = WitnessVerifyConfig {
                    receipts: &receipts,
                    witness_keys: &witness_keys,
                    threshold: cmd.witness_threshold,
                };

                let report =
                    verify_chain_with_witnesses(std::slice::from_ref(&att), &issuer_pk, &config)
                        .await
                        .context("Witness chain verification failed")?;

                verdict_freshness = report.freshness();
                if !report.is_valid() {
                    if !is_json_mode()
                        && let auths_verifier::VerificationStatus::InsufficientWitnesses {
                            required,
                            verified,
                        } = &report.status
                    {
                        eprintln!("Witness quorum not met: {}/{} verified", verified, required);
                    }
                    return Ok(VerifyResult {
                        valid: false,
                        error: Some(format!(
                            "Witness quorum not met: {}/{} verified",
                            report.witness_quorum.as_ref().map_or(0, |q| q.verified),
                            cmd.witness_threshold
                        )),
                        issuer: Some(att.issuer.to_string()),
                        subject: Some(att.subject.to_string()),
                        witness_quorum: report.witness_quorum,
                        freshness: None,
                    });
                }

                if !is_json_mode()
                    && let Some(ref q) = report.witness_quorum
                {
                    println!("Witness quorum met: {}/{} verified", q.verified, q.required);
                }

                report.witness_quorum
            } else {
                None
            };

            if !is_json_mode() {
                println!(
                    "Attestation verified successfully (freshness {}).",
                    crate::commands::verify_helpers::freshness_label(verdict_freshness)
                );
            }
            Ok(VerifyResult {
                valid: true,
                error: None,
                issuer: Some(att.issuer.to_string()),
                subject: Some(att.subject.to_string()),
                witness_quorum,
                freshness: Some(verdict_freshness),
            })
        }
        Err(e) => Ok(VerifyResult {
            valid: false,
            error: Some(e.to_string()),
            issuer: Some(att.issuer.to_string()),
            subject: Some(att.subject.to_string()),
            witness_quorum: None,
            freshness: None,
        }),
    }
}

/// Legacy handler for backward compatibility (kept for potential internal use).
pub async fn handle_verify_attestation(
    attestation_path: &PathBuf,
    issuer_pubkey_hex: &str,
) -> Result<()> {
    println!("Verifying attestation from file: {:?}", attestation_path);
    println!(
        "   Using issuer public key (hex): {}...",
        &issuer_pubkey_hex[..8.min(issuer_pubkey_hex.len())]
    );

    let attestation_bytes = fs::read(attestation_path)
        .with_context(|| format!("Failed to read attestation file: {:?}", attestation_path))?;

    let att: Attestation = serde_json::from_slice(&attestation_bytes).with_context(|| {
        format!(
            "Failed to parse JSON attestation from file: {:?}",
            attestation_path
        )
    })?;
    println!(
        "   Attestation loaded successfully. Issuer: {}, Subject: {}",
        att.issuer, att.subject
    );

    let issuer_pk_bytes = hex::decode(issuer_pubkey_hex)
        .context("Invalid hex string provided for issuer public key")?;
    let issuer_curve = auths_crypto::did_key_decode(att.issuer.as_str())
        .map(|d| d.curve())
        .unwrap_or_default();
    let issuer_pk = bytes_to_device_public_key(&issuer_pk_bytes, issuer_curve, "issuer")?;

    match verify_with_keys(&att, &issuer_pk).await {
        Ok(_) => {
            println!("Attestation verified successfully.");
            Ok(())
        }
        Err(e) => Err(anyhow!("Attestation verification failed: {}", e)),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn verify_result_serializes_correctly() {
        let result = VerifyResult {
            valid: true,
            error: None,
            issuer: Some("did:key:issuer".to_string()),
            subject: Some("did:key:subject".to_string()),
            witness_quorum: None,
            freshness: Some(auths_verifier::Freshness::Unknown),
        };
        let json = serde_json::to_string(&result).unwrap();
        assert!(json.contains("\"valid\":true"));
        assert!(json.contains("\"issuer\":\"did:key:issuer\""));
        assert!(
            json.contains("\"freshness\":\"unknown\""),
            "a honored verdict surfaces its freshness, never a bare valid: {json}"
        );
    }

    #[test]
    fn verify_result_error_serializes_correctly() {
        let result = VerifyResult {
            valid: false,
            error: Some("signature mismatch".to_string()),
            issuer: None,
            subject: None,
            witness_quorum: None,
            freshness: None,
        };
        let json = serde_json::to_string(&result).unwrap();
        assert!(json.contains("\"valid\":false"));
        assert!(json.contains("\"error\":\"signature mismatch\""));
        assert!(
            !json.contains("freshness"),
            "a failed verdict carries no freshness to surface: {json}"
        );
    }
}