~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/vuln-notif

0
0
main
330 lines · 11.3 KB Raw History
//! Canonical atprotoV1 refs: project grouping, channel/version strongRefs,
//! version labels, raw-field preservation, same-DID checks, determinism.

use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};

use serde_json::{Value, json};
use vuln_notif::identity::cve_refs::{
    ResolvedProject, StrongRef, build_cve_record, build_software_refs,
};
use vuln_notif::identity::{CanonicalIdentity, ObservedProduct, canonicalize_all};

const DID: &str = "did:plc:test";
const RHEL: &str = "red-hat-enterprise-linux";

fn fixtures_dir() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/identity/cve_refs")
}

fn load(name: &str) -> Value {
    let path = fixtures_dir().join(name);
    let text = fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {}: {e}", path.display()));
    serde_json::from_str(&text).unwrap_or_else(|e| panic!("parse {}: {e}", path.display()))
}

fn resolved_fixture() -> BTreeMap<String, ResolvedProject> {
    serde_json::from_value(load("resolved.json")).expect("resolved fixture")
}

fn observed(vendor: &str, product: &str) -> ObservedProduct {
    ObservedProduct {
        source: "test".to_owned(),
        part: Some("o".to_owned()),
        vendor: vendor.to_owned(),
        product: product.to_owned(),
        ..ObservedProduct::default()
    }
}

/// RHEL identities covering channels 8, 8-eus, and 9 plus version 9.4.
fn rhel_identities() -> Vec<CanonicalIdentity> {
    let versioned = ObservedProduct {
        version: Some("9.4".to_owned()),
        ..observed("redhat", "enterprise_linux")
    };
    canonicalize_all(&[
        observed("Red Hat", "Red Hat Enterprise Linux 8"),
        observed("Red Hat", "Red Hat Enterprise Linux 8 EUS"),
        observed("Red Hat", "Red Hat Enterprise Linux 9"),
        versioned,
    ])
}

fn uris(values: &[Value]) -> Vec<&str> {
    values
        .iter()
        .map(|value| value["uri"].as_str().expect("strongRef uri"))
        .collect()
}

fn fixture_record() -> (Value, Value) {
    let existing = load("existing_cve.json");
    let identities = rhel_identities();
    let refs = build_software_refs(
        existing["software"].as_array().expect("software array"),
        &identities,
        &resolved_fixture(),
    );
    let nvd: StrongRef = serde_json::from_value(existing["nvd"].clone()).expect("nvd strongRef");
    let record = build_cve_record(
        &existing,
        "CVE-2024-3094",
        &nvd,
        &refs,
        "2026-11-11T00:00:00Z",
    );
    (existing, record)
}

#[test]
fn rhel_variants_build_one_project_with_channels_and_version() {
    let refs = build_software_refs(&[], &rhel_identities(), &resolved_fixture());
    assert_eq!(refs.len(), 1, "one canonical project");
    let software = &refs[0];

    assert_eq!(
        software["project"]["uri"],
        format!("at://{DID}/software.release.project/{RHEL}")
    );
    assert_eq!(software["project"]["cid"], "bafyproject");
    // With no existing raw ref the canonical identity supplies the required
    // raw fields.
    assert_eq!(software["part"], "o");
    assert_eq!(software["vendor"], "red-hat");
    assert_eq!(software["product"], RHEL);

    let channels = software["channels"].as_array().expect("channels array");
    assert_eq!(
        uris(channels),
        vec![
            format!("at://{DID}/software.release.channel/{RHEL}:8"),
            format!("at://{DID}/software.release.channel/{RHEL}:8-eus"),
            format!("at://{DID}/software.release.channel/{RHEL}:9"),
        ]
    );
    let versions = software["versions"].as_array().expect("versions array");
    assert_eq!(
        uris(versions),
        vec![format!("at://{DID}/software.release.version/{RHEL}:9.4")]
    );
    let manifests = software["manifests"].as_array().expect("manifests array");
    assert_eq!(
        uris(manifests),
        vec![format!(
            "at://{DID}/software.release.manifest/3jzfcijpj2z2a"
        )]
    );
    // No duplicate refs.
    assert_eq!(channels.len(), 3);
    assert_eq!(versions.len(), 1);
    assert!(software.get("versionLabels").is_none());
    assert!(software.get("affectedRanges").is_none());
}

#[test]
fn fixture_record_matches_expected_and_preserves_raw_fields() {
    let (_existing, record) = fixture_record();
    assert_eq!(record, load("expected_cve.json"));

    let software = &record["software"][0];
    assert_eq!(software["part"], "o");
    assert_eq!(software["vendor"], "Red Hat");
    assert_eq!(software["product"], "Red Hat Enterprise Linux 8");
    assert_eq!(software["cpes"].as_array().expect("cpes").len(), 4);
    assert_eq!(
        software["purls"],
        json!([
            "pkg:rpm/redhat/enterprise-linux",
            "pkg:rpm/redhat/enterprise-linux-eus"
        ])
    );
    assert_eq!(software["channels"].as_array().expect("channels").len(), 3);
    assert_eq!(record["createdAt"], "2025-03-04T05:06:07Z");
    assert_eq!(record["$type"], "com.nahdig.cve.atprotoV1");
}

#[test]
fn missing_version_record_becomes_version_label() {
    let mut resolved = resolved_fixture();
    let project = resolved.get_mut(RHEL).expect("resolved RHEL");
    project.versions.clear();
    project.manifests.clear();

    let refs = build_software_refs(&[], &rhel_identities(), &resolved);
    assert_eq!(refs.len(), 1);
    let software = &refs[0];
    assert!(software.get("versions").is_none());
    assert!(software.get("manifests").is_none());
    assert_eq!(software["versionLabels"], json!(["9.4"]));
    assert_eq!(software["channels"].as_array().expect("channels").len(), 3);
}

#[test]
fn ranges_without_an_exact_version_become_affected_ranges() {
    let existing = json!([{
        "project": {"uri": format!("at://{DID}/software.release.project/{RHEL}"), "cid": "bafyproject"},
        "part": "o",
        "vendor": "Red Hat",
        "product": "Red Hat Enterprise Linux 9",
        "cpes": ["cpe:2.3:o:redhat:enterprise_linux:9.0:*:*:*:*:*:*:*"],
        "purls": ["pkg:rpm/redhat/enterprise-linux"],
        "affectedRanges": ["[9.0,9.5)", ">= 8.0, < 8.6", "[9.0,9.5)"]
    }]);
    let identities = canonicalize_all(&[observed("Red Hat", "Red Hat Enterprise Linux 9")]);

    let refs = build_software_refs(
        existing.as_array().expect("existing refs"),
        &identities,
        &resolved_fixture(),
    );
    assert_eq!(refs.len(), 1);
    let software = &refs[0];
    assert!(software.get("versions").is_none());
    assert!(software.get("versionLabels").is_none());
    assert_eq!(
        software["affectedRanges"],
        json!([">= 8.0, < 8.6", "[9.0,9.5)"])
    );
    assert_eq!(
        uris(software["channels"].as_array().expect("channels")),
        vec![format!("at://{DID}/software.release.channel/{RHEL}:9")]
    );
}

#[test]
fn legacy_project_refs_are_not_reused_without_a_canonical_project() {
    let existing = json!([{
        "project": {
            "uri": format!("at://{DID}/software.release.project/red-hat-red-hat-enterprise-linux-8"),
            "cid": "bafyold"
        },
        "part": "o",
        "vendor": "Red Hat",
        "product": "Red Hat Enterprise Linux 8"
    }]);
    let refs = build_software_refs(
        existing.as_array().expect("existing refs"),
        &rhel_identities(),
        &BTreeMap::new(),
    );
    assert!(
        refs.is_empty(),
        "legacy project URIs must never be emitted as canonical refs"
    );
}

#[test]
#[should_panic(expected = "cross-DID")]
fn cross_did_refs_are_rejected() {
    let mut resolved = resolved_fixture();
    resolved
        .get_mut(RHEL)
        .expect("resolved RHEL")
        .channels
        .get_mut("9")
        .expect("channel 9")
        .uri = format!("at://did:plc:other/software.release.channel/{RHEL}:9");
    let identities = canonicalize_all(&[observed("Red Hat", "Red Hat Enterprise Linux 9")]);
    build_software_refs(&[], &identities, &resolved);
}

#[test]
fn output_is_deterministic_regardless_of_input_order() {
    let existing = load("existing_cve.json");
    let resolved = resolved_fixture();
    let identities = rhel_identities();

    let forward = build_software_refs(
        existing["software"].as_array().expect("software array"),
        &identities,
        &resolved,
    );

    let mut reversed_identities = identities;
    reversed_identities.reverse();
    let mut reversed_existing = existing["software"]
        .as_array()
        .expect("software array")
        .clone();
    reversed_existing.reverse();
    let backward = build_software_refs(&reversed_existing, &reversed_identities, &resolved);

    assert_eq!(forward, backward);
    assert_eq!(forward.len(), 1);
    assert_eq!(
        uris(forward[0]["channels"].as_array().expect("channels")),
        vec![
            format!("at://{DID}/software.release.channel/{RHEL}:8"),
            format!("at://{DID}/software.release.channel/{RHEL}:8-eus"),
            format!("at://{DID}/software.release.channel/{RHEL}:9"),
        ]
    );
}

fn assert_strong_ref(value: &Value) {
    let uri = value["uri"].as_str().expect("strongRef uri");
    assert!(uri.starts_with("at://"), "not an at-uri: {uri}");
    assert!(
        value["cid"].as_str().is_some_and(|cid| !cid.is_empty()),
        "missing strongRef cid"
    );
}

#[test]
fn built_record_satisfies_atproto_v1_lexicon_properties() {
    let lexicon_path =
        Path::new(env!("CARGO_MANIFEST_DIR")).join("lexicons/com/nahdig/cve.atprotoV1.json");
    let lexicon: Value =
        serde_json::from_str(&fs::read_to_string(lexicon_path).expect("read lexicon"))
            .expect("parse lexicon");
    let main = &lexicon["defs"]["main"]["record"];
    let software_ref = &lexicon["defs"]["softwareRef"];

    let (_existing, record) = fixture_record();
    assert_eq!(record["$type"], lexicon["id"]);
    for field in main["required"].as_array().expect("main required") {
        let field = field.as_str().expect("field name");
        assert!(record.get(field).is_some(), "record missing {field}");
    }
    assert_strong_ref(&record["nvd"]);

    let required = software_ref["required"].as_array().expect("ref required");
    let properties = software_ref["properties"]
        .as_object()
        .expect("ref properties");
    let part_values = properties["part"]["knownValues"]
        .as_array()
        .expect("part knownValues");
    for reference in record["software"].as_array().expect("software array") {
        for field in required {
            let field = field.as_str().expect("field name");
            assert!(reference.get(field).is_some(), "ref missing {field}");
        }
        assert_strong_ref(&reference["project"]);
        let part = reference["part"].as_str().expect("part string");
        assert!(
            part_values.iter().any(|value| value == part),
            "unknown part {part}"
        );
        assert!(reference["vendor"].is_string());
        assert!(reference["product"].is_string());

        for name in ["versions", "channels", "manifests"] {
            if let Some(values) = reference.get(name) {
                let values = values.as_array().expect("strongRef array");
                for value in values {
                    assert_strong_ref(value);
                }
            }
        }
        for name in ["versionLabels", "affectedRanges"] {
            if let Some(values) = reference.get(name) {
                for value in values.as_array().expect("string array") {
                    assert!(value.is_string(), "{name} items must be strings");
                }
            }
        }
    }
}