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

johnandersen777.bsky.social/vuln-notif

0
0
main
545 lines · 18.3 KB Raw History
//! OSV source and version comparator tests: query parsing, querybatch limit,
//! alias matching, retry policy, offline bulk dumps, cache round-trip, and the
//! per-scheme comparator table.

use std::cmp::Ordering;
use std::collections::{HashMap, VecDeque};
use std::sync::{Arc, Mutex};

use async_trait::async_trait;
use serde_json::{Value, json};
use wiremock::matchers::{body_json, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

use vuln_notif::db::DbHandle;
use vuln_notif::release::http::{RegistryHttp, ReqwestRegistryHttp};
use vuln_notif::release::sources::osv::{
    Advisory, OSV_QUERYBATCH_LIMIT, OsvClient, OsvQuery, advisory_matches_cve,
};
use vuln_notif::release::versioning::{VersionScheme, compare, satisfies};

const QUERY_FIXTURE: &str = include_str!("fixtures/osv/query.json");
const QUERYBATCH_FIXTURE: &str = include_str!("fixtures/osv/querybatch.json");
const OSV_AFFECTED_FIXTURE: &str = include_str!("fixtures/osv/osv-affected.json");

fn fixture(raw: &str) -> Value {
    serde_json::from_str(raw).expect("fixture JSON")
}

fn advisory_fixture() -> Advisory {
    serde_json::from_str(OSV_AFFECTED_FIXTURE).expect("advisory fixture")
}

// ---------------------------------------------------------------------------
// Scripted RegistryHttp fake
// ---------------------------------------------------------------------------

#[derive(Debug, Clone)]
struct HttpCall {
    method: &'static str,
    url: String,
    body: Option<Value>,
}

#[derive(Default)]
struct FakeHttp {
    replies: Mutex<HashMap<String, VecDeque<Value>>>,
    calls: Mutex<Vec<HttpCall>>,
}

impl FakeHttp {
    fn enqueue(&self, url: &str, value: Value) {
        self.replies
            .lock()
            .unwrap()
            .entry(url.to_owned())
            .or_default()
            .push_back(value);
    }

    fn calls(&self) -> Vec<HttpCall> {
        self.calls.lock().unwrap().clone()
    }

    fn posts(&self) -> Vec<HttpCall> {
        self.calls()
            .into_iter()
            .filter(|call| call.method == "POST")
            .collect()
    }

    fn take(&self, method: &'static str, url: &str, body: Option<Value>) -> anyhow::Result<Value> {
        self.calls.lock().unwrap().push(HttpCall {
            method,
            url: url.to_owned(),
            body,
        });
        self.replies
            .lock()
            .unwrap()
            .get_mut(url)
            .and_then(VecDeque::pop_front)
            .ok_or_else(|| anyhow::anyhow!("unexpected {method} {url}"))
    }
}

#[async_trait]
impl RegistryHttp for FakeHttp {
    async fn get_json(&self, url: &str) -> anyhow::Result<Value> {
        self.take("GET", url, None)
    }

    async fn get_text(&self, url: &str) -> anyhow::Result<String> {
        Err(anyhow::anyhow!("unexpected text GET {url}"))
    }

    async fn head_size(&self, url: &str) -> anyhow::Result<u64> {
        Err(anyhow::anyhow!("unexpected HEAD {url}"))
    }

    async fn download(&self, url: &str) -> anyhow::Result<Vec<u8>> {
        Err(anyhow::anyhow!("unexpected download {url}"))
    }

    async fn post_json(&self, url: &str, body: &Value) -> anyhow::Result<Value> {
        self.take("POST", url, Some(body.clone()))
    }
}

fn client() -> (Arc<FakeHttp>, OsvClient) {
    let fake = Arc::new(FakeHttp::default());
    let http: Arc<dyn RegistryHttp> = fake.clone();
    (fake, OsvClient::with_base_url(http, "https://osv.test/"))
}

// ---------------------------------------------------------------------------
// Query, querybatch, bulk
// ---------------------------------------------------------------------------

#[tokio::test]
async fn query_posts_purl_and_parses_advisory() {
    let (fake, client) = client();
    fake.enqueue("https://osv.test/v1/query", fixture(QUERY_FIXTURE));

    let advisories = client
        .query("pkg:pypi/acme-widget", Some("1.5.0"))
        .await
        .expect("query");
    assert_eq!(advisories.len(), 1);
    let advisory = &advisories[0];
    assert_eq!(advisory.id, "OSV-2024-100");
    assert_eq!(
        advisory.aliases,
        vec!["CVE-2024-1234".to_owned(), "GHSA-xxxx-yyyy-zzzz".to_owned()]
    );
    assert_eq!(advisory.modified.as_deref(), Some("2024-05-01T00:00:00Z"));
    assert_eq!(
        advisory.summary.as_deref(),
        Some("Acme widget snippet injection")
    );
    assert_eq!(advisory.severity.len(), 1);

    let affected = &advisory.affected[0];
    assert_eq!(affected.package.ecosystem, "PyPI");
    assert_eq!(affected.package.name, "acme-widget");
    assert_eq!(
        affected.package.purl.as_deref(),
        Some("pkg:pypi/acme-widget")
    );
    assert_eq!(affected.ranges[0].kind, "ECOSYSTEM");
    assert_eq!(
        affected.ranges[0].events[0].introduced.as_deref(),
        Some("0")
    );
    assert_eq!(affected.ranges[0].events[1].fixed.as_deref(), Some("2.0.0"));
    assert_eq!(
        affected.versions,
        vec!["1.0.0".to_owned(), "1.5.0".to_owned()]
    );
    assert_eq!(affected.ecosystem_specific["severity"], "HIGH");

    let posts = fake.posts();
    assert_eq!(posts.len(), 1);
    assert_eq!(posts[0].url, "https://osv.test/v1/query");
    let body = posts[0].body.as_ref().expect("POST body");
    assert_eq!(body["package"]["purl"], "pkg:pypi/acme-widget");
    assert_eq!(body["version"], "1.5.0");
}

#[tokio::test]
async fn query_without_version_omits_the_field() {
    let (fake, client) = client();
    fake.enqueue("https://osv.test/v1/query", json!({}));

    let advisories = client
        .query("pkg:pypi/acme-widget", None)
        .await
        .expect("query");
    assert!(advisories.is_empty());
    let body = fake.posts()[0].body.clone().expect("POST body");
    assert!(body.get("version").is_none());
    assert_eq!(body["package"]["purl"], "pkg:pypi/acme-widget");
}

#[tokio::test]
async fn querybatch_parses_results_in_query_order() {
    let (fake, client) = client();
    fake.enqueue(
        "https://osv.test/v1/querybatch",
        fixture(QUERYBATCH_FIXTURE),
    );

    let queries = vec![
        OsvQuery {
            purl: "pkg:pypi/acme-widget".to_owned(),
            version: None,
        },
        OsvQuery {
            purl: "pkg:pypi/other".to_owned(),
            version: Some("2.0".to_owned()),
        },
        OsvQuery {
            purl: "pkg:npm/widget".to_owned(),
            version: None,
        },
    ];
    let results = client.querybatch(&queries).await.expect("querybatch");
    assert_eq!(results.len(), 3);
    assert_eq!(results[0][0].id, "OSV-2024-100");
    assert_eq!(results[0][0].aliases, vec!["CVE-2024-1234".to_owned()]);
    assert!(results[1].is_empty());
    assert_eq!(results[2][0].id, "GHSA-aaaa-bbbb-cccc");

    let body = fake.posts()[0].body.clone().expect("POST body");
    let posted = body["queries"].as_array().expect("queries array");
    assert_eq!(posted.len(), 3);
    assert!(posted[0].get("version").is_none());
    assert_eq!(posted[1]["version"], "2.0");
}

#[tokio::test]
async fn querybatch_splits_at_the_1000_query_limit() {
    assert_eq!(OSV_QUERYBATCH_LIMIT, 1000);
    let (fake, client) = client();
    let first_batch = json!({
        "results": (0..OSV_QUERYBATCH_LIMIT)
            .map(|_| json!({"vulns": []}))
            .collect::<Vec<_>>(),
    });
    fake.enqueue("https://osv.test/v1/querybatch", first_batch);
    fake.enqueue(
        "https://osv.test/v1/querybatch",
        json!({"results": [{"vulns": []}]}),
    );

    let queries = (0..=OSV_QUERYBATCH_LIMIT)
        .map(|index| OsvQuery {
            purl: format!("pkg:pypi/pkg-{index}"),
            version: None,
        })
        .collect::<Vec<_>>();
    let results = client.querybatch(&queries).await.expect("batched query");
    assert_eq!(results.len(), OSV_QUERYBATCH_LIMIT + 1);

    let posts = fake.posts();
    assert_eq!(posts.len(), 2);
    assert_eq!(
        posts[0].body.as_ref().unwrap()["queries"]
            .as_array()
            .unwrap()
            .len(),
        OSV_QUERYBATCH_LIMIT
    );
    assert_eq!(
        posts[1].body.as_ref().unwrap()["queries"]
            .as_array()
            .unwrap()
            .len(),
        1
    );
}

#[tokio::test]
async fn get_vuln_parses_introduced_fixed_and_last_affected() {
    let (fake, client) = client();
    fake.enqueue(
        "https://osv.test/v1/vulns/OSV-2024-200",
        fixture(OSV_AFFECTED_FIXTURE),
    );

    let advisory = client.get_vuln("OSV-2024-200").await.expect("get_vuln");
    assert_eq!(advisory.id, "OSV-2024-200");
    let ranges = &advisory.affected[0].ranges;
    assert_eq!(ranges.len(), 3);
    assert_eq!(ranges[0].kind, "ECOSYSTEM");
    assert_eq!(ranges[0].events[0].introduced.as_deref(), Some("1.0.0"));
    assert_eq!(ranges[0].events[1].fixed.as_deref(), Some("1.2.0"));
    assert_eq!(ranges[1].events[0].introduced.as_deref(), Some("2.0.0"));
    assert_eq!(ranges[1].events[1].last_affected.as_deref(), Some("2.1.0"));
    assert_eq!(ranges[2].kind, "GIT");
    assert_eq!(ranges[2].events[1].limit.as_deref(), Some("2222222"));
    assert_eq!(
        advisory.affected[0].database_specific["source"],
        "debian-test"
    );
    assert_eq!(fake.calls().len(), 1);
}

#[tokio::test]
async fn get_vuln_rejects_path_metacharacters() {
    let (fake, client) = client();
    let error = client
        .get_vuln("../v1/other")
        .await
        .expect_err("invalid id");
    assert!(error.to_string().contains("invalid OSV advisory id"));
    assert!(fake.calls().is_empty());
}

#[test]
fn bulk_dir_loads_sorted_json_files_without_network() {
    let (fake, client) = client();
    let dir = tempfile::tempdir().expect("tempdir");
    std::fs::write(dir.path().join("a.json"), OSV_AFFECTED_FIXTURE).expect("write a");
    std::fs::write(
        dir.path().join("b.json"),
        json!({
            "id": "OSV-2024-201",
            "aliases": ["CVE-2024-0001"],
            "affected": [],
        })
        .to_string(),
    )
    .expect("write b");
    std::fs::write(dir.path().join("ignored.txt"), "{}").expect("write ignored");

    let advisories = client.load_bulk_dir(dir.path()).expect("bulk dir");
    assert_eq!(advisories.len(), 2);
    assert_eq!(advisories[0].id, "OSV-2024-200");
    assert_eq!(advisories[1].id, "OSV-2024-201");
    assert!(fake.calls().is_empty());
}

#[test]
fn advisory_aliases_match_case_insensitively() {
    let advisory = advisory_fixture();
    assert!(advisory_matches_cve(&advisory, "CVE-2024-5678"));
    assert!(advisory_matches_cve(&advisory, "cve-2024-5678"));
    assert!(advisory_matches_cve(&advisory, "GHSA-DDDD-EEEE-FFFF"));
    assert!(advisory_matches_cve(&advisory, "OSV-2024-200"));
    assert!(!advisory_matches_cve(&advisory, "CVE-2024-0000"));
    assert!(!advisory_matches_cve(&advisory, "   "));
}

// ---------------------------------------------------------------------------
// Cache round-trip
// ---------------------------------------------------------------------------

#[tokio::test]
async fn hydrate_and_cached_round_trip_release_osv_rows() {
    let (_fake, client) = client();
    let db = DbHandle::open_in_memory().await.expect("in-memory db");
    let advisory = advisory_fixture();
    let advisories = vec![advisory.clone()];

    client
        .hydrate(&db, "did:plc:test", "pkg:deb/debian/acme", &advisories)
        .await
        .expect("hydrate");
    let cached = client
        .cached(&db, "did:plc:test", "pkg:deb/debian/acme")
        .await
        .expect("cached");
    assert_eq!(cached.len(), 1);
    assert_eq!(cached[0].id, advisory.id);
    assert_eq!(cached[0].aliases, advisory.aliases);
    assert_eq!(cached[0].modified, advisory.modified);
    assert_eq!(cached[0].affected, advisory.affected);

    // Upsert is idempotent.
    client
        .hydrate(&db, "did:plc:test", "pkg:deb/debian/acme", &advisories)
        .await
        .expect("re-hydrate");
    assert_eq!(
        client
            .cached(&db, "did:plc:test", "pkg:deb/debian/acme")
            .await
            .expect("cached again")
            .len(),
        1
    );
    assert!(
        client
            .cached(&db, "did:plc:test", "pkg:pypi/other")
            .await
            .expect("empty cache")
            .is_empty()
    );
}

// ---------------------------------------------------------------------------
// Retry policy
// ---------------------------------------------------------------------------

#[tokio::test]
async fn post_json_retries_429_and_5xx_then_succeeds() {
    let server = MockServer::start().await;
    let expected = json!({
        "package": {"purl": "pkg:pypi/acme-widget"},
        "version": "1.5.0",
    });
    Mock::given(method("POST"))
        .and(path("/v1/query"))
        .and(body_json(expected.clone()))
        .respond_with(ResponseTemplate::new(429))
        .up_to_n_times(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/v1/query"))
        .and(body_json(expected.clone()))
        .respond_with(ResponseTemplate::new(503))
        .up_to_n_times(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/v1/query"))
        .and(body_json(expected))
        .respond_with(ResponseTemplate::new(200).set_body_json(fixture(QUERY_FIXTURE)))
        .mount(&server)
        .await;

    let http = Arc::new(ReqwestRegistryHttp::new().expect("http client"));
    let client = OsvClient::with_base_url(http, server.uri());
    let advisories = client
        .query("pkg:pypi/acme-widget", Some("1.5.0"))
        .await
        .expect("retry succeeds");
    assert_eq!(advisories.len(), 1);
    assert_eq!(server.received_requests().await.expect("requests").len(), 3);
}

// ---------------------------------------------------------------------------
// Comparator table
// ---------------------------------------------------------------------------

#[test]
fn version_scheme_comparator_table() {
    use Ordering::{Greater, Less};

    let less_cases: &[(VersionScheme, &str, &str)] = &[
        (VersionScheme::Semver, "1.0.0-alpha", "1.0.0"),
        (VersionScheme::Semver, "1.0.0-alpha.1", "1.0.0-alpha.2"),
        (VersionScheme::Semver, "1.0.0-rc.1", "1.0.0"),
        (VersionScheme::Semver, "1.2.3", "1.10.0"),
        (VersionScheme::Pep440, "1.0.dev1", "1.0a1"),
        (VersionScheme::Pep440, "1.0a1", "1.0b1"),
        (VersionScheme::Pep440, "1.0b1", "1.0rc1"),
        (VersionScheme::Pep440, "1.0rc1", "1.0"),
        (VersionScheme::Pep440, "1.0", "1.0.post1"),
        (VersionScheme::Pep440, "1.0a1.dev1", "1.0a1"),
        (VersionScheme::Pep440, "2023.12", "2024.1"),
        (VersionScheme::Maven, "1.0-alpha", "1.0-beta"),
        (VersionScheme::Maven, "1.0-rc1", "1.0"),
        (VersionScheme::Maven, "1.0", "1.0.1"),
        (VersionScheme::Maven, "1.0", "1.0-sp1"),
        (VersionScheme::Nuget, "1.0.0-alpha", "1.0.0"),
        (VersionScheme::Nuget, "1.0.0", "1.0.0.1"),
        (VersionScheme::Nuget, "1.0.0-alpha", "1.0.0-beta"),
        (VersionScheme::Go, "v1.2.3-rc.1", "v1.2.3"),
        (VersionScheme::Go, "v1.2.3", "v1.2.4"),
        (
            VersionScheme::Go,
            "v0.0.0-20240101120000-aaaaaaaaaaaa",
            "v0.0.0-20240201120000-bbbbbbbbbbbb",
        ),
        (VersionScheme::RubyGems, "1.0.0.pre", "1.0.0"),
        (VersionScheme::RubyGems, "1.0.0.rc1", "1.0.0"),
        (VersionScheme::RubyGems, "1.0.0.pre.1", "1.0.0.pre.2"),
        (VersionScheme::RubyGems, "1.0.0", "1.0.1"),
        (VersionScheme::Debian, "1.2~rc1-1", "1.2-1"),
        (VersionScheme::Debian, "1.2-3", "1.2-4"),
        (VersionScheme::Debian, "2.3-5", "1:2.3-4"),
        (VersionScheme::Rpm, "1.2-3.el9", "1.2-4.el9"),
        (VersionScheme::Rpm, "1.2~rc1-1", "1.2-1"),
        (VersionScheme::Rpm, "2.0-1", "1:1.0-1"),
        (VersionScheme::Lexical, "2.0", "10.0"),
        (VersionScheme::Lexical, "1.0-alpha", "1.0-beta"),
    ];
    for &(scheme, low, high) in less_cases {
        assert_eq!(
            compare(scheme, low, high),
            Less,
            "{scheme:?}: {low} < {high}"
        );
        assert_eq!(
            compare(scheme, high, low),
            Greater,
            "{scheme:?}: {high} > {low}"
        );
    }

    let equal_cases: &[(VersionScheme, &str, &str)] = &[
        (VersionScheme::Semver, "1.0.0", "1.0.0+build.5"),
        (VersionScheme::Semver, "v1.2.3", "1.2.3"),
        (VersionScheme::Pep440, "1.0", "1.0.0"),
        (VersionScheme::Pep440, "1.0+local.1", "1.0"),
        (VersionScheme::Maven, "1.0", "1.0.0"),
        (VersionScheme::Nuget, "1.0.0-ALPHA", "1.0.0-alpha"),
        (VersionScheme::Go, "v1.0.0", "1.0.0"),
        (VersionScheme::RubyGems, "1.0", "1.0.0"),
        (VersionScheme::Debian, "1.0", "1.0-0"),
        (VersionScheme::Rpm, "1.02", "1.2"),
    ];
    for &(scheme, left, right) in equal_cases {
        assert_eq!(
            compare(scheme, left, right),
            Ordering::Equal,
            "{scheme:?}: {left} == {right}"
        );
    }
}

#[test]
fn satisfies_handles_comparators_caret_tilde_and_hyphen_ranges() {
    assert!(satisfies(VersionScheme::Semver, "1.5.0", ">=1.0.0, <2.0.0"));
    assert!(!satisfies(
        VersionScheme::Semver,
        "2.0.0",
        ">=1.0.0, <2.0.0"
    ));
    assert!(satisfies(VersionScheme::Semver, "1.9.9", "^1.2.3"));
    assert!(!satisfies(VersionScheme::Semver, "2.0.0", "^1.2.3"));
    assert!(satisfies(VersionScheme::Semver, "1.2.9", "~1.2.3"));
    assert!(!satisfies(VersionScheme::Semver, "1.3.0", "~1.2.3"));
    assert!(satisfies(VersionScheme::Semver, "1.5.0", ">=1.0.0 <2.0.0"));
    assert!(satisfies(VersionScheme::Semver, "1.5.0", "1.0.0 - 2.0.0"));
    assert!(!satisfies(VersionScheme::Semver, "2.5.0", "1.0.0 - 2.0.0"));
    assert!(satisfies(
        VersionScheme::Semver,
        "3.1.0",
        "1.0.0 - 2.0.0 || >=3.0.0"
    ));
    assert!(satisfies(VersionScheme::Debian, "1:2.3-4", ">=1:2.3-4"));
    assert!(!satisfies(VersionScheme::Debian, "1:2.3-3", ">=1:2.3-4"));
}

#[test]
fn unknown_ecosystems_use_the_lexical_order_and_never_panic() {
    assert_eq!(
        VersionScheme::from_ecosystem("MysteryOS"),
        VersionScheme::Lexical
    );
    assert_eq!(VersionScheme::from_ecosystem("PyPI"), VersionScheme::Pep440);
    assert_eq!(VersionScheme::from_ecosystem("Go"), VersionScheme::Go);
    assert_eq!(
        compare(VersionScheme::Lexical, "2.0", "10.0"),
        Ordering::Less
    );
    // Malformed inputs fall back instead of panicking.
    assert_eq!(compare(VersionScheme::Semver, "", ""), Ordering::Equal);
    let _ = compare(VersionScheme::Pep440, "?!", "1.0");
    let _ = compare(VersionScheme::Debian, ":::", "---");
    let _ = compare(VersionScheme::Rpm, ":::", "---");
}