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

johnandersen777.bsky.social/vuln-notif

0
0
main
564 lines · 17.0 KB Raw History
//! CVE-to-release ref linking: resolved strongRefs, idempotent writes, link
//! indexing, `release_cve_links` rows, same-DID rejection, and PDS failure
//! isolation.
//!
//! `src/release/cve_links.rs` is compiled into `release` by the integration
//! wave; until that wiring lands this test includes the module directly and
//! provides the `crate::` paths it uses.

use std::path::{Path, PathBuf};
use std::sync::Arc;

use serde_json::{Value, json};
use tempfile::TempDir;
use vuln_notif::constants::{
    ATPROTO_COLLECTION, CHANNEL_COLLECTION, MANIFEST_COLLECTION, PROJECT_COLLECTION,
    VERSION_COLLECTION,
};
use vuln_notif::db::DbHandle;
use vuln_notif::db::model::{ReleaseChannelMark, ReleaseProjectMark, ReleaseVersionMark};
use vuln_notif::identity::{CanonicalIdentity, ObservedProduct, canonicalize_all};
use vuln_notif::pds::Publisher;

mod common;

mod constants {
    pub use vuln_notif::constants::*;
}
mod db {
    pub use vuln_notif::db::*;
}
mod identity {
    pub use vuln_notif::identity::*;
}
mod links {
    pub use vuln_notif::links::*;
}
mod pds {
    pub use vuln_notif::pds::*;
}
mod time {
    pub use vuln_notif::time::*;
}

#[path = "../src/release/cve_links.rs"]
mod cve_links;

const DID: &str = "did:plc:test";
const OTHER_DID: &str = "did:plc:other";
const RHEL: &str = "red-hat-enterprise-linux";
const CVE: &str = "CVE-2024-3094";

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

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

fn fs_read(path: &Path) -> String {
    std::fs::read_to_string(path).unwrap_or_else(|error| panic!("read {}: {error}", path.display()))
}

async fn test_db() -> (DbHandle, TempDir) {
    let dir = tempfile::tempdir().expect("tempdir");
    let db = DbHandle::open(dir.path().join("cache.db"))
        .await
        .expect("open db");
    (db, dir)
}

/// A logged-in publisher: the fake PDS echoes the session DID in write URIs.
async fn test_publisher(api: Arc<common::FakePds>, db: &DbHandle) -> Publisher {
    let publisher = common::make_publisher(api, db);
    publisher.login().await.expect("login");
    publisher
}

fn text(value: &Value, key: &str) -> String {
    value
        .get(key)
        .and_then(Value::as_str)
        .unwrap_or_else(|| panic!("missing {key} in {value}"))
        .to_owned()
}

async fn seed_release_rows(db: &DbHandle, rows: &Value) {
    let project = &rows["project"];
    db.mark_release_project(ReleaseProjectMark {
        repo_did: DID.to_owned(),
        slug: text(project, "slug"),
        purl: text(project, "purl"),
        system: text(project, "system"),
        latest_version: text(project, "latest_version"),
        latest_version_raw: text(project, "latest_version_raw"),
        project_uri: text(project, "project_uri"),
        project_cid: text(project, "project_cid"),
        manifest_uri: text(project, "manifest_uri"),
        manifest_cid: text(project, "manifest_cid"),
        version_uri: text(project, "version_uri"),
        version_cid: text(project, "version_cid"),
        channel_uri: text(project, "channel_uri"),
        channel_cid: text(project, "channel_cid"),
    })
    .await
    .expect("mark project");
    for version in rows["versions"].as_array().expect("versions array") {
        db.mark_release_version(ReleaseVersionMark {
            repo_did: DID.to_owned(),
            project_slug: text(project, "slug"),
            version: text(version, "version"),
            version_raw: text(version, "version_raw"),
            rkey: text(version, "rkey"),
            uri: text(version, "uri"),
            cid: text(version, "cid"),
            manifest_uri: text(version, "manifest_uri"),
            manifest_cid: text(version, "manifest_cid"),
        })
        .await
        .expect("mark version");
    }
    for channel in rows["channels"].as_array().expect("channels array") {
        db.mark_release_channel(ReleaseChannelMark {
            repo_did: DID.to_owned(),
            project_slug: text(project, "slug"),
            name: text(channel, "name"),
            rkey: text(channel, "rkey"),
            uri: text(channel, "uri"),
            cid: text(channel, "cid"),
            version_uri: text(channel, "version_uri"),
            version_cid: text(channel, "version_cid"),
        })
        .await
        .expect("mark channel");
    }
    db.commit().await.expect("commit rows");
}

fn versioned_identities() -> Vec<CanonicalIdentity> {
    let identities = canonicalize_all(&[ObservedProduct {
        source: "test".to_owned(),
        part: Some("o".to_owned()),
        vendor: "redhat".to_owned(),
        product: "enterprise_linux".to_owned(),
        version: Some("9.4".to_owned()),
        ..ObservedProduct::default()
    }]);
    assert_eq!(identities.len(), 1);
    assert_eq!(identities[0].slug, RHEL);
    assert_eq!(identities[0].channel.as_deref(), Some("9"));
    assert_eq!(identities[0].version.as_deref(), Some("9.4"));
    identities
}

fn channel_identities() -> Vec<CanonicalIdentity> {
    canonicalize_all(&[ObservedProduct {
        source: "test".to_owned(),
        part: Some("o".to_owned()),
        vendor: "redhat".to_owned(),
        product: "enterprise_linux".to_owned(),
        version: Some("9".to_owned()),
        ..ObservedProduct::default()
    }])
}

fn record_without_software() -> Value {
    json!({
        "$type": "com.nahdig.cve.atprotoV1",
        "createdAt": "2025-03-04T05:06:07Z",
        "cve": CVE,
        "nvd": {
            "uri": format!("at://{DID}/com.nahdig.cve.nvdV2/{CVE}"),
            "cid": "bafynvd"
        },
        "software": []
    })
}

fn uris(references: &[Value]) -> Vec<String> {
    references
        .iter()
        .map(|reference| reference["uri"].as_str().expect("uri").to_owned())
        .collect()
}

#[tokio::test]
async fn one_project_version_and_channel_get_refs_and_a_changed_write() {
    let (db, _dir) = test_db().await;
    seed_release_rows(&db, &load("release_rows.json")).await;
    let api = common::FakePds::new();
    let publisher = test_publisher(api.clone(), &db).await;

    let outcome = cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &load("existing_cve.json"),
        &versioned_identities(),
        None,
    )
    .await
    .expect("link cve");

    assert!(outcome.changed);
    assert_eq!(
        (outcome.refs, outcome.channels, outcome.versions),
        (1, 1, 1)
    );
    assert_eq!(outcome.error, None);

    let puts = api.puts();
    assert_eq!(puts.len(), 1);
    assert_eq!(puts[0].collection, ATPROTO_COLLECTION);
    assert_eq!(puts[0].rkey, CVE);
    let record = api
        .record(ATPROTO_COLLECTION, CVE)
        .expect("stored atproto record");
    assert_eq!(record, load("expected_cve.json"));

    let software = &record["software"][0];
    assert_eq!(
        uris(software["channels"].as_array().expect("channels")),
        vec![format!("at://{DID}/{CHANNEL_COLLECTION}/{RHEL}:9")]
    );
    assert_eq!(
        uris(software["versions"].as_array().expect("versions")),
        vec![format!("at://{DID}/{VERSION_COLLECTION}/{RHEL}:9.4")]
    );
    assert_eq!(
        uris(software["manifests"].as_array().expect("manifests")),
        vec![format!("at://{DID}/{MANIFEST_COLLECTION}/3jzfcijpj2z2a")]
    );
    assert_eq!(
        software["project"]["uri"],
        format!("at://{DID}/{PROJECT_COLLECTION}/{RHEL}")
    );
}

#[tokio::test]
async fn identical_content_makes_no_second_pds_write() {
    let (db, _dir) = test_db().await;
    seed_release_rows(&db, &load("release_rows.json")).await;
    let api = common::FakePds::new();
    let publisher = test_publisher(api.clone(), &db).await;
    let identities = versioned_identities();

    let first = cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &load("existing_cve.json"),
        &identities,
        None,
    )
    .await
    .expect("first link");
    assert!(first.changed);

    let stored = api.record(ATPROTO_COLLECTION, CVE).expect("stored record");
    let second = cve_links::link_cve(&publisher, &db, DID, CVE, &stored, &identities, None)
        .await
        .expect("second link");

    assert!(!second.changed);
    assert_eq!(second.error, None);
    assert_eq!((second.refs, second.channels, second.versions), (1, 1, 1));
    assert_eq!(api.puts().len(), 1, "identical content must not be re-put");
}

#[tokio::test]
async fn missing_version_record_becomes_a_version_label() {
    let (db, _dir) = test_db().await;
    let mut rows = load("release_rows.json");
    rows["versions"] = json!([]);
    seed_release_rows(&db, &rows).await;
    let api = common::FakePds::new();
    let publisher = test_publisher(api.clone(), &db).await;

    let outcome = cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &load("existing_cve.json"),
        &versioned_identities(),
        None,
    )
    .await
    .expect("link cve");

    assert!(outcome.changed);
    assert_eq!(outcome.versions, 0, "no fabricated version strongRef");
    assert_eq!(outcome.channels, 1);
    let record = api.record(ATPROTO_COLLECTION, CVE).expect("stored record");
    let software = &record["software"][0];
    assert!(software.get("versions").is_none());
    assert!(software.get("manifests").is_none());
    assert_eq!(software["versionLabels"], json!(["9.4"]));
    assert_eq!(
        uris(software["channels"].as_array().expect("channels")),
        vec![format!("at://{DID}/{CHANNEL_COLLECTION}/{RHEL}:9")]
    );
}

#[tokio::test]
async fn legacy_and_cross_did_refs_are_never_emitted() {
    let (db, _dir) = test_db().await;
    let mut rows = load("release_rows.json");
    rows["project"]["project_uri"] = json!(format!("at://{OTHER_DID}/{PROJECT_COLLECTION}/{RHEL}"));
    seed_release_rows(&db, &rows).await;

    let resolved = cve_links::ResolvedReleaseSet::load(&db, DID, &[RHEL.to_owned()])
        .await
        .expect("resolve");
    assert!(
        resolved.projects.is_empty(),
        "cross-DID project row must be skipped"
    );

    let api = common::FakePds::new();
    let publisher = test_publisher(api.clone(), &db).await;
    let existing = load("existing_cve.json");
    let outcome = cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &existing,
        &versioned_identities(),
        None,
    )
    .await
    .expect("link cve");

    assert_eq!(outcome.refs, 0);
    assert_eq!(outcome.channels, 0);
    assert_eq!(outcome.versions, 0);
    let record = api.record(ATPROTO_COLLECTION, CVE).expect("stored record");
    assert_eq!(record["software"], json!([]));
    let encoded = record.to_string();
    assert!(!encoded.contains(OTHER_DID), "cross-DID ref leaked");
    assert!(
        !encoded.contains("red-hat-red-hat-enterprise-linux"),
        "legacy project ref leaked"
    );
}

#[tokio::test]
async fn links_are_indexed_under_channel_and_version_paths() {
    let (db, _dir) = test_db().await;
    seed_release_rows(&db, &load("release_rows.json")).await;
    let api = common::FakePds::new();
    let publisher = test_publisher(api.clone(), &db).await;

    cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &load("existing_cve.json"),
        &versioned_identities(),
        None,
    )
    .await
    .expect("link cve");

    let channel_uri = format!("at://{DID}/{CHANNEL_COLLECTION}/{RHEL}:9");
    let version_uri = format!("at://{DID}/{VERSION_COLLECTION}/{RHEL}:9.4");
    let channel_links = db
        .backlinks(
            DID,
            &channel_uri,
            Some(ATPROTO_COLLECTION),
            Some("software[].channels[].uri"),
            10,
        )
        .await
        .expect("channel backlinks");
    assert_eq!(channel_links.len(), 1);
    assert_eq!(
        channel_links[0].src_uri,
        format!("at://{DID}/{ATPROTO_COLLECTION}/{CVE}")
    );
    let version_links = db
        .backlinks(
            DID,
            &version_uri,
            Some(ATPROTO_COLLECTION),
            Some("software[].versions[].uri"),
            10,
        )
        .await
        .expect("version backlinks");
    assert_eq!(version_links.len(), 1);
}

#[tokio::test]
async fn release_cve_link_rows_are_persisted() {
    let (db, _dir) = test_db().await;
    seed_release_rows(&db, &load("release_rows.json")).await;
    let api = common::FakePds::new();
    let publisher = test_publisher(api.clone(), &db).await;

    cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &load("existing_cve.json"),
        &versioned_identities(),
        None,
    )
    .await
    .expect("link cve");

    let row = db
        .get_release_cve_link(DID, CVE, RHEL)
        .await
        .expect("get link row")
        .expect("link row exists");
    assert_eq!(
        row.version_uri.as_deref(),
        Some(format!("at://{DID}/{VERSION_COLLECTION}/{RHEL}:9.4").as_str())
    );
    assert_eq!(
        row.channel_uri.as_deref(),
        Some(format!("at://{DID}/{CHANNEL_COLLECTION}/{RHEL}:9").as_str())
    );
    assert_eq!(
        row.manifest_uri.as_deref(),
        Some(format!("at://{DID}/{MANIFEST_COLLECTION}/3jzfcijpj2z2a").as_str())
    );
    assert_eq!(
        db.list_release_cve_links(DID, CVE)
            .await
            .expect("list link rows")
            .len(),
        1
    );
}

#[tokio::test]
async fn pds_failure_leaves_local_state_unmarked() {
    let (db, _dir) = test_db().await;
    seed_release_rows(&db, &load("release_rows.json")).await;
    let api = common::FakePds::new();
    for _ in 0..vuln_notif::constants::MAX_ATTEMPTS {
        api.push_put(common::response(
            500,
            json!({"error": "InternalServerError"}),
        ));
    }
    let publisher = test_publisher(api.clone(), &db).await;

    let outcome = cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &load("existing_cve.json"),
        &versioned_identities(),
        None,
    )
    .await
    .expect("link cve");

    assert!(!outcome.changed);
    assert!(outcome.error.is_some(), "PDS failure must surface");
    assert!(api.record(ATPROTO_COLLECTION, CVE).is_none());
    assert!(
        db.list_release_cve_links(DID, CVE)
            .await
            .expect("list link rows")
            .is_empty()
    );
    let channel_uri = format!("at://{DID}/{CHANNEL_COLLECTION}/{RHEL}:9");
    assert!(
        db.backlinks(DID, &channel_uri, None, None, 10)
            .await
            .expect("backlinks")
            .is_empty()
    );
}

#[tokio::test]
async fn plan_versions_fill_refs_and_labels_and_ranges_fall_back() {
    let (db, _dir) = test_db().await;
    seed_release_rows(&db, &load("release_rows.json")).await;
    let api = common::FakePds::new();
    let publisher = test_publisher(api.clone(), &db).await;

    // The identity only knows channel 9; the plan supplies the pinned version.
    let versioned = cve_links::VersionSelection {
        project_slug: RHEL.to_owned(),
        versions: vec!["9.4".to_owned()],
        ..cve_links::VersionSelection::default()
    };
    let outcome = cve_links::link_cve(
        &publisher,
        &db,
        DID,
        CVE,
        &record_without_software(),
        &channel_identities(),
        Some(&versioned),
    )
    .await
    .expect("link planned version");
    assert!(outcome.changed);
    assert_eq!(outcome.versions, 1);
    let record = api.record(ATPROTO_COLLECTION, CVE).expect("stored record");
    assert_eq!(
        uris(
            record["software"][0]["versions"]
                .as_array()
                .expect("versions")
        ),
        vec![format!("at://{DID}/{VERSION_COLLECTION}/{RHEL}:9.4")]
    );

    // Labels and ranges are used when the plan pins no resolvable version.
    let fallback = cve_links::VersionSelection {
        project_slug: RHEL.to_owned(),
        versions: Vec::new(),
        labels: vec!["9.4.1".to_owned()],
        ranges: vec!["[9.0,9.5)".to_owned()],
    };
    let second = cve_links::link_cve(
        &publisher,
        &db,
        DID,
        "CVE-2024-9999",
        &json!({
            "$type": "com.nahdig.cve.atprotoV1",
            "createdAt": "2025-03-04T05:06:07Z",
            "cve": "CVE-2024-9999",
            "nvd": {
                "uri": format!("at://{DID}/com.nahdig.cve.nvdV2/CVE-2024-9999"),
                "cid": "bafynvd"
            },
            "software": []
        }),
        &channel_identities(),
        Some(&fallback),
    )
    .await
    .expect("link fallback selection");
    assert!(second.changed);
    assert_eq!(second.versions, 0);
    let record = api
        .record(ATPROTO_COLLECTION, "CVE-2024-9999")
        .expect("stored fallback record");
    let software = &record["software"][0];
    assert_eq!(software["versionLabels"], json!(["9.4.1"]));
    assert_eq!(software["affectedRanges"], json!(["[9.0,9.5)"]));
    assert_eq!(
        uris(software["channels"].as_array().expect("channels")),
        vec![format!("at://{DID}/{CHANNEL_COLLECTION}/{RHEL}:9")]
    );
}