auger 0.2.0

Load test, discover and inspect HTTP endpoints from the terminal
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};

use colored::Colorize;
use rustls::pki_types::ServerName;
use serde::Serialize;
use tokio_rustls::TlsConnector;
use x509_parser::extensions::GeneralName;
use x509_parser::prelude::*;
use x509_parser::signature_algorithm::SignatureAlgorithm;

#[derive(Serialize)]
struct CertInfo {
    host: String,
    port: u16,
    tls: String,
    chain: usize,
    subject: String,
    issuer: String,
    key: String,
    sig: String,
    not_before: String,
    not_after: String,
    days_left: i64,
    sans: Vec<String>,
}

pub async fn run(target: &str, json: bool) -> anyhow::Result<()> {
    let (host, port) = parse_target(target)?;
    let info = fetch(&host, port).await?;
    if json {
        println!("{}", serde_json::to_string_pretty(&info)?);
    } else {
        print_info(&info);
    }
    if info.days_left < 0 {
        anyhow::bail!(
            "certificate expired {} day(s) ago on {}",
            -info.days_left,
            info.not_after
        );
    }
    if info.days_left < 30 {
        eprintln!(
            "  {} expires in {} days, renew soon",
            "warning".yellow().bold(),
            info.days_left
        );
    }
    Ok(())
}

fn print_info(i: &CertInfo) {
    let host = if i.port == 443 {
        i.host.clone()
    } else {
        format!("{}:{}", i.host, i.port)
    };
    println!("  {} {}", "auger cert".bold().cyan(), host);
    println!("  subject  {}", i.subject);
    println!("  issuer   {}", i.issuer);
    println!("  tls      {}", i.tls);
    println!("  key      {}", i.key);
    println!("  sig      {}", i.sig);
    println!("  chain    {} certs", i.chain);
    println!("  valid    {} to {}", i.not_before, i.not_after);
    if i.days_left < 0 {
        println!("  expired  {} days ago", -i.days_left);
    } else {
        println!("  expires  in {} days", i.days_left);
    }
    if !i.sans.is_empty() {
        println!("  san      {}", i.sans.join(", "));
    }
    println!();
}

fn parse_target(target: &str) -> anyhow::Result<(String, u16)> {
    let rest = target.split("://").last().unwrap_or(target);
    let host_part = rest.split('/').next().unwrap_or("").trim_end_matches('/');
    let (host, port) = match host_part.rsplit_once(':') {
        Some((h, p)) if !h.is_empty() && p.chars().all(|c| c.is_ascii_digit()) => {
            (h.to_string(), p.parse::<u16>()?)
        }
        _ => (host_part.to_string(), 443),
    };
    let host = host.trim_start_matches('[').trim_end_matches(']');
    if host.is_empty() {
        anyhow::bail!("no host in '{}'", target);
    }
    Ok((host.to_string(), port))
}

async fn fetch(host: &str, port: u16) -> anyhow::Result<CertInfo> {
    let mut roots = rustls::RootCertStore::empty();
    roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(roots)
        .with_no_client_auth();
    let connector = TlsConnector::from(Arc::new(config));
    let stream = tokio::net::TcpStream::connect((host, port)).await?;
    let name = ServerName::try_from(host.to_string())
        .map_err(|_| anyhow::anyhow!("invalid hostname '{}'", host))?;
    let tls = connector.connect(name, stream).await?;

    let conn = tls.get_ref().1;
    let certs = conn
        .peer_certificates()
        .ok_or_else(|| anyhow::anyhow!("server sent no certificate"))?;
    let der = certs
        .first()
        .ok_or_else(|| anyhow::anyhow!("empty certificate chain"))?;
    let (_, cert) = parse_x509_certificate(der.as_ref())
        .map_err(|_| anyhow::anyhow!("could not parse certificate"))?;

    let now = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
    let not_after = cert.validity().not_after.timestamp();
    let days_left = (not_after - now) / 86400;

    let key_size = cert.public_key().parsed().map(|k| k.key_size()).unwrap_or(0);
    let key = if key_size > 0 {
        format!("{} bits", key_size)
    } else {
        "unknown".into()
    };
    let sig = match SignatureAlgorithm::try_from(&cert.signature_algorithm) {
        Ok(SignatureAlgorithm::RSA) | Ok(SignatureAlgorithm::RSASSA_PSS(_)) => "RSA".into(),
        Ok(SignatureAlgorithm::DSA) => "DSA".into(),
        Ok(SignatureAlgorithm::ECDSA) => "ECDSA".into(),
        Ok(SignatureAlgorithm::ED25519) => "Ed25519".into(),
        Ok(SignatureAlgorithm::RSAAES_OAEP(_)) => "RSA-OAEP".into(),
        Err(_) => "unknown".into(),
    };

    let mut sans = Vec::new();
    if let Ok(Some(ext)) = cert.subject_alternative_name() {
        for gn in &ext.value.general_names {
            if let GeneralName::DNSName(d) = gn {
                sans.push((*d).to_string());
            }
        }
    }

    let tls = match conn.protocol_version() {
        Some(rustls::ProtocolVersion::TLSv1_3) => "1.3",
        Some(rustls::ProtocolVersion::TLSv1_2) => "1.2",
        _ => "older",
    }
    .to_string();

    Ok(CertInfo {
        host: host.to_string(),
        port,
        tls,
        chain: certs.len(),
        subject: common_name(cert.subject()),
        issuer: common_name(cert.issuer()),
        key,
        sig,
        not_before: ymd(cert.validity().not_before.timestamp()),
        not_after: ymd(not_after),
        days_left,
        sans,
    })
}

fn common_name(name: &X509Name) -> String {
    name.iter_common_name()
        .find_map(|atv| atv.as_str().ok().map(|s| s.to_string()))
        .unwrap_or_else(|| name.to_string())
}

// civil-from-days, no chrono dep
fn ymd(secs: i64) -> String {
    let z = secs.div_euclid(86400) + 719468;
    let era = z.div_euclid(146097);
    let doe = z.rem_euclid(146097);
    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let d = doy - (153 * mp + 2) / 5 + 1;
    let m = if mp < 10 { mp + 3 } else { mp - 9 };
    format!(
        "{:04}-{:02}-{:02}",
        if m <= 2 { y + 1 } else { y },
        m,
        d
    )
}

#[cfg(test)]
mod tests {
    use super::{parse_target, ymd};

    #[test]
    fn target_default_port() {
        assert_eq!(parse_target("example.com").unwrap(), ("example.com".into(), 443));
        assert_eq!(
            parse_target("https://example.com/").unwrap(),
            ("example.com".into(), 443)
        );
    }

    #[test]
    fn target_custom_port() {
        assert_eq!(parse_target("example.com:8443").unwrap(), ("example.com".into(), 8443));
        assert_eq!(
            parse_target("https://example.com:9443/x").unwrap(),
            ("example.com".into(), 9443)
        );
    }

    #[test]
    fn target_ipv6() {
        assert_eq!(parse_target("[::1]:8443").unwrap(), ("::1".into(), 8443));
    }

    #[test]
    fn ymd_known_dates() {
        assert_eq!(ymd(0), "1970-01-01");
        assert_eq!(ymd(1609459200), "2021-01-01");
        assert_eq!(ymd(1752710400), "2025-07-17");
    }
}