build.rs

/*++

Licensed under the Apache-2.0 license.

File Name:

    build.rs

Abstract:

    Build script for Caliptra Runtime.

--*/

/*++

Licensed under the Apache-2.0 license.

File Name:

    build.rs

Abstract:

    Build script for Caliptra Runtime.

--*/

use caliptra_ocp_eat::cbor::{CborEncoder, TaggedOid};
use caliptra_ocp_eat::cose::{CoseSign1, ProtectedHeader};
use caliptra_ocp_eat::csr_eat::{
    derivation_components, oids, CsrEatClaims, KeyAttributeEntry, KeyPairInventoryClaims,
    KeyPairInventoryEntry,
};
use caliptra_ocp_eat::{cbor_bstr_header, cbor_tags};
use std::env;
use std::fs;
use std::path::{Path, PathBuf};

fn find_subslice(haystack: &[u8], needle: &[u8]) -> Option<usize> {
    haystack.windows(needle.len()).position(|w| w == needle)
}

fn write_bytes_const(out: &mut String, name: &str, bytes: &[u8]) {
    out.push_str(&format!("pub const {name}: [u8; {}] = [", bytes.len()));
    for (i, byte) in bytes.iter().enumerate() {
        if i % 12 == 0 {
            out.push_str("\n    ");
        }
        out.push_str(&format!("0x{byte:02x}, "));
    }
    out.push_str("\n];\n\n");
}

fn generate_attested_csr_templates(out_dir: &Path) {
    let mut generated = String::new();
    generated.push_str("// Licensed under the Apache-2.0 license\n");
    generated.push_str("// AUTO-GENERATED FILE. DO NOT EDIT.\n");
    generated.push_str("// Generated by runtime build.rs from caliptra-ocp-eat\n\n");

    generated.push_str(&format!(
        "pub const CBOR_MAX_INLINE_LEN: usize = {};\n\
         pub const CBOR_BYTE_STRING_TINY_BASE: u8 = 0x{:02x};\n\
         pub const CBOR_BYTE_STRING_1BYTE_LEN: u8 = 0x{:02x};\n\
         pub const CBOR_BYTE_STRING_2BYTE_LEN: u8 = 0x{:02x};\n\n",
        cbor_bstr_header::MAX_INLINE_LEN,
        cbor_bstr_header::TINY_BASE,
        cbor_bstr_header::LEN_1BYTE,
        cbor_bstr_header::LEN_2BYTE,
    ));

    let marker_nonce = [0xa5u8; 32];
    let ldevid_kda = TaggedOid::new(oids::OCP_SECURITY_OID_KDA);
    let fmc_kda = TaggedOid::new(oids::OCP_SECURITY_OID_KDA);
    let rt_kda = TaggedOid::new(oids::OCP_SECURITY_OID_KDA);

    let ldevid_attrs = [KeyAttributeEntry::new(
        ldevid_kda,
        derivation_components::UDS | derivation_components::FIELD_ENTROPY,
    )];
    let fmc_attrs = [KeyAttributeEntry::new(
        fmc_kda,
        derivation_components::UDS
            | derivation_components::FIELD_ENTROPY
            | derivation_components::FIRST_MUTABLE_CODE,
    )];
    let rt_attrs = [KeyAttributeEntry::new(
        rt_kda,
        derivation_components::UDS
            | derivation_components::FIELD_ENTROPY
            | derivation_components::FIRST_MUTABLE_CODE
            | derivation_components::RUNTIME_FIRMWARE,
    )];

    // 1. Discovery KeyPair Inventory template (key_id == 0)
    let entries = [
        KeyPairInventoryEntry::new(1, &ldevid_attrs),
        KeyPairInventoryEntry::new(2, &fmc_attrs),
        KeyPairInventoryEntry::new(3, &rt_attrs),
    ];
    let inventory = KeyPairInventoryClaims::with_nonce(&entries, &marker_nonce).unwrap();
    let mut inv_buf = [0u8; 512];
    let inv_len = {
        let mut inv_enc = CborEncoder::new(&mut inv_buf);
        inventory.encode(&mut inv_enc).unwrap();
        inv_enc.len()
    };
    let inv_encoded = &inv_buf[..inv_len];
    let inv_nonce_pos = find_subslice(inv_encoded, &marker_nonce).expect("inventory nonce marker");
    write_bytes_const(
        &mut generated,
        "KEYPAIR_INVENTORY_PREFIX",
        &inv_encoded[..inv_nonce_pos],
    );
    write_bytes_const(
        &mut generated,
        "KEYPAIR_INVENTORY_SUFFIX",
        &inv_encoded[inv_nonce_pos + 32..],
    );

    // 2. CSR EAT templates (key_id == 1, 2, 3)
    const MARKER_BSTR_HEADER_LEN: usize = 3; // 3-byte CBOR header (0x59, len_hi, len_lo) for 300-byte markers
    let marker_csr = [0x5cu8; 300]; // 300 bytes ensures 3-byte bstr header (0x59, 0x01, 0x2c)
    let ldevid_claims = CsrEatClaims::with_nonce(&marker_csr, &ldevid_attrs, &marker_nonce);
    let mut csr_buf = [0u8; 1024];
    let csr_len = {
        let mut csr_enc = CborEncoder::new(&mut csr_buf);
        ldevid_claims.encode(&mut csr_enc).unwrap();
        csr_enc.len()
    };
    let csr_encoded = &csr_buf[..csr_len];
    let csr_nonce_pos = find_subslice(csr_encoded, &marker_nonce).expect("csr nonce marker");
    let csr_data_pos = find_subslice(csr_encoded, &marker_csr).expect("csr data marker");
    assert_eq!(
        csr_encoded[csr_data_pos - MARKER_BSTR_HEADER_LEN],
        0x59,
        "marker_csr must have a 3-byte CBOR byte string header"
    );

    write_bytes_const(
        &mut generated,
        "CSR_EAT_PREFIX",
        &csr_encoded[..csr_nonce_pos],
    );
    // bytes between nonce and CSR bstr header (the CLAIM_KEY_ATTESTED_CSR key)
    write_bytes_const(
        &mut generated,
        "CSR_EAT_CLAIM_KEY_CSR",
        &csr_encoded[csr_nonce_pos + 32..csr_data_pos - MARKER_BSTR_HEADER_LEN],
    );
    write_bytes_const(
        &mut generated,
        "CSR_EAT_SUFFIX_LDEVID",
        &csr_encoded[csr_data_pos + 300..],
    );

    // FMC Alias suffix
    let fmc_claims = CsrEatClaims::with_nonce(&marker_csr, &fmc_attrs, &marker_nonce);
    let mut fmc_buf = [0u8; 1024];
    let fmc_len = {
        let mut fmc_enc = CborEncoder::new(&mut fmc_buf);
        fmc_claims.encode(&mut fmc_enc).unwrap();
        fmc_enc.len()
    };
    let fmc_encoded = &fmc_buf[..fmc_len];
    let fmc_csr_pos = find_subslice(fmc_encoded, &marker_csr).expect("fmc csr marker");
    write_bytes_const(
        &mut generated,
        "CSR_EAT_SUFFIX_FMC_ALIAS",
        &fmc_encoded[fmc_csr_pos + 300..],
    );

    // RT Alias suffix
    let rt_claims = CsrEatClaims::with_nonce(&marker_csr, &rt_attrs, &marker_nonce);
    let mut rt_buf = [0u8; 1024];
    let rt_len = {
        let mut rt_enc = CborEncoder::new(&mut rt_buf);
        rt_claims.encode(&mut rt_enc).unwrap();
        rt_enc.len()
    };
    let rt_encoded = &rt_buf[..rt_len];
    let rt_csr_pos = find_subslice(rt_encoded, &marker_csr).expect("rt csr marker");
    write_bytes_const(
        &mut generated,
        "CSR_EAT_SUFFIX_RT_ALIAS",
        &rt_encoded[rt_csr_pos + 300..],
    );

    // 3. COSE Sign1 and Sig_structure templates for ECC (ES384)
    let marker_kid = [0x7du8; 20];
    let marker_payload = [0x8eu8; 300];
    let marker_sig_ecc = [0x9fu8; 96];

    let mut protected_header_ecc = ProtectedHeader::new_es384();
    protected_header_ecc.kid = Some(&marker_kid);

    // Sig_structure ECC
    let mut sig_buf = vec![0u8; 2048];
    let cose_sign1_sig_ecc = CoseSign1::new(&mut sig_buf)
        .protected_header(&protected_header_ecc)
        .payload(&marker_payload);
    let mut sig_ctx_ecc = vec![0u8; 2048];
    let sig_ctx_len = cose_sign1_sig_ecc
        .get_signature_context(&mut sig_ctx_ecc)
        .unwrap();
    let sig_ctx_ecc = &sig_ctx_ecc[..sig_ctx_len];
    let sig_kid_pos_ecc = find_subslice(sig_ctx_ecc, &marker_kid).expect("sig kid marker");
    let sig_payload_pos_ecc =
        find_subslice(sig_ctx_ecc, &marker_payload).expect("sig payload marker");
    assert_eq!(
        sig_ctx_ecc[sig_payload_pos_ecc - MARKER_BSTR_HEADER_LEN],
        0x59,
        "marker_payload in sig_ctx_ecc must have 3-byte CBOR byte string header"
    );
    write_bytes_const(
        &mut generated,
        "SIG_PREAMBLE_ECC_BEFORE_KID",
        &sig_ctx_ecc[..sig_kid_pos_ecc],
    );
    write_bytes_const(
        &mut generated,
        "SIG_ECC_AFTER_KID_BEFORE_PAYLOAD_LEN",
        &sig_ctx_ecc[sig_kid_pos_ecc + 20..sig_payload_pos_ecc - MARKER_BSTR_HEADER_LEN],
    );

    // COSE Sign1 ECC envelope
    let mut cose_ecc_buf = vec![0u8; 2048];
    let cose_ecc = CoseSign1::new(&mut cose_ecc_buf)
        .protected_header(&protected_header_ecc)
        .payload(&marker_payload)
        .signature(&marker_sig_ecc);
    let cose_ecc_len = cose_ecc.encode(Some(&[cbor_tags::CWT])).unwrap();
    let cose_ecc = &cose_ecc_buf[..cose_ecc_len];
    let cose_kid_pos_ecc = find_subslice(cose_ecc, &marker_kid).expect("cose kid marker");
    let cose_payload_pos_ecc =
        find_subslice(cose_ecc, &marker_payload).expect("cose payload marker");
    let cose_sig_pos_ecc = find_subslice(cose_ecc, &marker_sig_ecc).expect("cose sig marker");
    assert_eq!(
        cose_ecc[cose_payload_pos_ecc - MARKER_BSTR_HEADER_LEN],
        0x59,
        "marker_payload in cose_ecc must have 3-byte CBOR byte string header"
    );
    write_bytes_const(
        &mut generated,
        "COSE_PREAMBLE_ECC_BEFORE_KID",
        &cose_ecc[..cose_kid_pos_ecc],
    );
    write_bytes_const(
        &mut generated,
        "COSE_ECC_AFTER_KID_BEFORE_PAYLOAD_LEN",
        &cose_ecc[cose_kid_pos_ecc + 20..cose_payload_pos_ecc - MARKER_BSTR_HEADER_LEN],
    );
    write_bytes_const(
        &mut generated,
        "COSE_ECC_SIG_BSTR_HEADER",
        &cose_ecc[cose_payload_pos_ecc + 300..cose_sig_pos_ecc],
    );

    // 4. COSE Sign1 and Sig_structure templates for ML-DSA-87
    let marker_sig_mldsa = [0x9fu8; 4627];
    let mut protected_header_mldsa = ProtectedHeader::new_mldsa87();
    protected_header_mldsa.kid = Some(&marker_kid);

    // Sig_structure ML-DSA
    let mut sig_mldsa_buf = vec![0u8; 8192];
    let cose_sign1_sig_mldsa = CoseSign1::new(&mut sig_mldsa_buf)
        .protected_header(&protected_header_mldsa)
        .payload(&marker_payload);
    let mut sig_ctx_mldsa = vec![0u8; 8192];
    let sig_mldsa_len = cose_sign1_sig_mldsa
        .get_signature_context(&mut sig_ctx_mldsa)
        .unwrap();
    let sig_ctx_mldsa = &sig_ctx_mldsa[..sig_mldsa_len];
    let sig_kid_pos_mldsa = find_subslice(sig_ctx_mldsa, &marker_kid).expect("sig kid marker");
    let sig_payload_pos_mldsa =
        find_subslice(sig_ctx_mldsa, &marker_payload).expect("sig payload marker");
    assert_eq!(
        sig_ctx_mldsa[sig_payload_pos_mldsa - MARKER_BSTR_HEADER_LEN],
        0x59,
        "marker_payload in sig_ctx_mldsa must have 3-byte CBOR byte string header"
    );
    write_bytes_const(
        &mut generated,
        "SIG_PREAMBLE_MLDSA_BEFORE_KID",
        &sig_ctx_mldsa[..sig_kid_pos_mldsa],
    );
    write_bytes_const(
        &mut generated,
        "SIG_MLDSA_AFTER_KID_BEFORE_PAYLOAD_LEN",
        &sig_ctx_mldsa[sig_kid_pos_mldsa + 20..sig_payload_pos_mldsa - MARKER_BSTR_HEADER_LEN],
    );

    // COSE Sign1 ML-DSA envelope
    let mut cose_mldsa_buf = vec![0u8; 8192];
    let cose_mldsa = CoseSign1::new(&mut cose_mldsa_buf)
        .protected_header(&protected_header_mldsa)
        .payload(&marker_payload)
        .signature(&marker_sig_mldsa);
    let cose_mldsa_len = cose_mldsa.encode(Some(&[cbor_tags::CWT])).unwrap();
    let cose_mldsa = &cose_mldsa_buf[..cose_mldsa_len];
    let cose_kid_pos_mldsa = find_subslice(cose_mldsa, &marker_kid).expect("cose kid marker");
    let cose_payload_pos_mldsa =
        find_subslice(cose_mldsa, &marker_payload).expect("cose payload marker");
    let cose_sig_pos_mldsa = find_subslice(cose_mldsa, &marker_sig_mldsa).expect("cose sig marker");
    assert_eq!(
        cose_mldsa[cose_payload_pos_mldsa - MARKER_BSTR_HEADER_LEN],
        0x59,
        "marker_payload in cose_mldsa must have 3-byte CBOR byte string header"
    );
    write_bytes_const(
        &mut generated,
        "COSE_PREAMBLE_MLDSA_BEFORE_KID",
        &cose_mldsa[..cose_kid_pos_mldsa],
    );
    write_bytes_const(
        &mut generated,
        "COSE_MLDSA_AFTER_KID_BEFORE_PAYLOAD_LEN",
        &cose_mldsa[cose_kid_pos_mldsa + 20..cose_payload_pos_mldsa - MARKER_BSTR_HEADER_LEN],
    );
    write_bytes_const(
        &mut generated,
        "COSE_MLDSA_SIG_BSTR_HEADER",
        &cose_mldsa[cose_payload_pos_mldsa + 300..cose_sig_pos_mldsa],
    );

    fs::write(out_dir.join("attested_csr_template.rs"), generated)
        .expect("Failed to write attested_csr_template.rs");
}

fn main() {
    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
    generate_attested_csr_templates(&out_dir);

    cfg_if::cfg_if! {
        if #[cfg(not(feature = "std"))] {
            use caliptra_gen_linker_scripts::gen_memory_x;

            fs::write(out_dir.join("memory.x"), gen_memory_x(caliptra_common::RUNTIME_ORG, caliptra_common::RUNTIME_SIZE)
            .as_bytes())
            .expect("Unable to generate memory.x");

            println!("cargo:rustc-link-search={}", out_dir.display());

            println!("cargo:rerun-if-changed=memory.x");
            println!("cargo:rustc-link-arg=-Tmemory.x");

            println!("cargo:rustc-link-arg=-Tlink.x");
            println!("cargo:rerun-if-changed=build.rs");
        }
    }
}