nordisk/dwarves

crates/dwarves-slsa/tests/release_key.rs

//! The committed release key: the owner's YubiKey key (serial 34569904, PIV slot 9c,
//! P-256, PIN once, touch always), the same file as `slsa/release-signing-key.pub` in
//! holger and gunnar. A bundle signed with any other key, a test key included, is refused.

mod common;

use std::path::Path;
use std::process::{Command, Stdio};

use dwarves_slsa::dsse;
use dwarves_slsa::release_key::{self, RELEASE_KEY_ID, RELEASE_KEY_PEM};
use dwarves_slsa::statement;
use dwarves_slsa::verify::{verify_bundle, Expect};

/// The key id the owner's attestation was checked against (2026-10-29).
const OWNER_KEY_ID: &str = "d24d3785e8281bcd37e8f2c40a3a85e8152d3ce2200a5c929a1a5ca636e8249e";

fn fixture(name: &str) -> std::path::PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("tests/fixtures/openssl")
        .join(name)
}

#[test]
fn the_release_key_id_is_the_sha256_of_its_spki() {
    let spki = release_key::spki().unwrap();
    assert_eq!(spki, dsse::spki_from_pem(RELEASE_KEY_PEM).unwrap());
    assert_eq!(dsse::p256_point(&spki).unwrap().len(), 65);
    assert_eq!(dsse::keyid(&spki), OWNER_KEY_ID);
    assert_eq!(RELEASE_KEY_ID, OWNER_KEY_ID);
}

#[test]
fn the_key_file_is_the_one_committed_in_the_products() {
    let on_disk = std::fs::read_to_string(
        Path::new(env!("CARGO_MANIFEST_DIR")).join("keys/release-signing-key.pub"),
    )
    .unwrap();
    assert_eq!(on_disk, RELEASE_KEY_PEM);
}

#[test]
fn without_a_flag_or_variable_the_release_key_is_used() {
    assert_eq!(
        release_key::resolve(None, None).unwrap(),
        release_key::spki().unwrap()
    );
    let test_pub = fixture("release-test.pub");
    let p = test_pub.to_str().unwrap();
    let test_spki = dsse::spki_from_pem(&std::fs::read_to_string(&test_pub).unwrap()).unwrap();
    assert_eq!(release_key::resolve(Some(p), None).unwrap(), test_spki);
    assert_eq!(release_key::resolve(None, Some(p)).unwrap(), test_spki);
    // The flag wins over the variable.
    assert_eq!(
        release_key::resolve(Some(p), Some("/nonexistent/key.pub")).unwrap(),
        test_spki
    );
    assert!(release_key::resolve(Some("/nonexistent/key.pub"), None).is_err());
}

#[test]
fn the_throwaway_openssl_bundle_is_refused_with_the_release_key() {
    let bundle = std::fs::read_to_string(fixture("release.intoto.jsonl")).unwrap();
    let envs = dsse::parse_bundle(&bundle).unwrap();
    let test_spki =
        dsse::spki_from_pem(&std::fs::read_to_string(fixture("release-test.pub")).unwrap())
            .unwrap();
    assert_eq!(dsse::verify_p256(&envs[0], &test_spki).unwrap(), 0);
    let e = dsse::verify_p256(&envs[0], &release_key::spki().unwrap()).unwrap_err();
    assert!(e.0.contains(OWNER_KEY_ID), "{e}");
}

/// `sign-release.sh` with `SLSA_TEST_KEY` signs with a software key. The bundle names the
/// release key's id (the script writes it from the release key), yet it does not verify.
#[test]
fn a_bundle_signed_with_slsa_test_key_is_refused_with_the_release_key() {
    let d = tempfile::tempdir().unwrap();
    let key = d.path().join("test-key.pem");
    let ok = Command::new("openssl")
        .args([
            "ecparam",
            "-name",
            "prime256v1",
            "-genkey",
            "-noout",
            "-out",
        ])
        .arg(&key)
        .status()
        .expect("openssl is needed for this test");
    assert!(ok.success());
    let test_pub = d.path().join("test-key.pub");
    assert!(Command::new("openssl")
        .args(["ec", "-pubout", "-in"])
        .arg(&key)
        .arg("-out")
        .arg(&test_pub)
        .stderr(Stdio::null())
        .status()
        .unwrap()
        .success());

    let st = statement::statement(&common::subjects(), &common::provenance()).unwrap();
    let st_file = d.path().join("release.statement.json");
    std::fs::write(&st_file, statement::payload(&st)).unwrap();
    let out = d.path().join("release.intoto.jsonl");

    let script = Path::new(env!("CARGO_MANIFEST_DIR")).join("scripts/sign-release.sh");
    let mut child = Command::new("bash")
        .arg(&script)
        .arg(&st_file)
        .arg(&out)
        .current_dir(d.path())
        .env("HOME", d.path())
        .env_remove("SLSA_KEY")
        .env("SLSA_TEST_KEY", &key)
        .stdin(Stdio::piped())
        .stdout(Stdio::null())
        .spawn()
        .unwrap();
    {
        use std::io::Write as _;
        let mut stdin = child.stdin.take().unwrap();
        writeln!(stdin, "holger-2.0.1").unwrap();
    }
    assert!(child.wait().unwrap().success(), "sign-release.sh failed");

    let bundle = std::fs::read_to_string(&out).unwrap();
    let envs = dsse::parse_bundle(&bundle).unwrap();
    assert_eq!(envs[0].signatures[0].keyid, OWNER_KEY_ID);

    let test_spki = dsse::spki_from_pem(&std::fs::read_to_string(&test_pub).unwrap()).unwrap();
    verify_bundle(&bundle, &test_spki, &Expect::default())
        .expect("the bundle is well formed and verifies with the test key");
    let e = verify_bundle(&bundle, &release_key::spki().unwrap(), &Expect::default()).unwrap_err();
    assert!(e.0.contains("none of the envelope"), "{e}");
}