lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

service_release_artifacts.rs (195852B)


      1 use std::{
      2     collections::{BTreeMap, BTreeSet},
      3     ffi::OsStr,
      4     fmt, fs,
      5     io::{Read as _, Write as _},
      6     path::{Component, Path, PathBuf},
      7     process::{Command, Stdio},
      8 };
      9 
     10 use flate2::{Compression, GzBuilder};
     11 use serde::{Deserialize, Serialize};
     12 use sha2::{Digest as _, Sha256};
     13 use tar::{Builder as TarBuilder, Header as TarHeader};
     14 use tempfile::TempDir;
     15 
     16 use crate::safe_artifact_io::{TarGzipLimits, TraversalLimits};
     17 use crate::service_source_lock::LIB_REPOSITORY;
     18 use crate::service_source_lock_nix::validate_bound_nix_material;
     19 use crate::service_source_lock_v4::{
     20     LOCK_FILENAME, MAX_LOCK_BYTES, PREDECESSOR_LOCK_FILENAMES, RUST_VERSION, ServiceSourceLockV4,
     21     validate_lib_compiler_inputs, validate_toolchain_bytes,
     22 };
     23 use crate::{artifact_admission, exact_tree_archive, safe_artifact_io};
     24 
     25 const CONTRACT_RELATIVE: &str =
     26     "contracts/architecture/decisions/services_hardening_release_artifacts.v5.json";
     27 const INPUT_NAMES: [&str; 6] = [
     28     "config.example.toml",
     29     "config.schema.json",
     30     "nixos-module.nix",
     31     "oci-image.tar.gz",
     32     "service-binary",
     33     "systemd.service",
     34 ];
     35 const OUTPUT_NAMES: [&str; 20] = [
     36     "LICENSE-APACHE",
     37     "LICENSE-MIT",
     38     "SHA256SUMS",
     39     "THIRD-PARTY-LICENSES.txt",
     40     "THIRD-PARTY-NOTICES.txt",
     41     "artifact-manifest.v2.json",
     42     "artifact-scan.v1.json",
     43     "binary.tar.gz",
     44     "config.example.toml",
     45     "config.schema.json",
     46     "lib-source.tar",
     47     "nixos-module.nix",
     48     "oci-image.tar.gz",
     49     "oci-image.v1.json",
     50     "provenance.intoto.jsonl",
     51     "radroots.service.source_lock.v4.toml",
     52     "sbom.cdx.json",
     53     "service-source.tar",
     54     "source-archives.v3.json",
     55     "systemd.service",
     56 ];
     57 const SUPPORTED_TARGETS: [&str; 2] = ["aarch64-apple-darwin", "x86_64-unknown-linux-gnu"];
     58 const SECRET_PATTERNS: [&[u8]; 7] = [
     59     b"-----BEGIN PRIVATE KEY-----",
     60     b"-----BEGIN RSA PRIVATE KEY-----",
     61     b"-----BEGIN EC PRIVATE KEY-----",
     62     b"-----BEGIN OPENSSH PRIVATE KEY-----",
     63     b"github_pat_",
     64     b"ghp_",
     65     b"xoxb-",
     66 ];
     67 const MAX_CONTRACT_BYTES: usize = 65_536;
     68 const MAX_MANIFEST_BYTES: usize = 1_048_576;
     69 const MAX_TEXT_INPUT_BYTES: u64 = 1_048_576;
     70 const MAX_GENERATED_DOCUMENT_BYTES: u64 = 16_777_216;
     71 const MAX_SOURCE_LOCK_BYTES: u64 = MAX_LOCK_BYTES as u64;
     72 const MAX_TOOLCHAIN_BYTES: usize = 65_536;
     73 const MAX_SERVICE_CARGO_LOCK_BYTES: u64 = 16_777_216;
     74 const MAX_SERVICE_FLAKE_LOCK_BYTES: u64 = 4_194_304;
     75 const MAX_BINARY_BYTES: u64 = 536_870_912;
     76 const MAX_SOURCE_ARCHIVE_BYTES: u64 = 1_073_741_824;
     77 const MAX_SOURCE_ARCHIVE_MEMBER_BYTES: u64 = 67_108_864;
     78 const MAX_SOURCE_ARCHIVE_MEMBERS: u64 = 65_536;
     79 const MAX_OCI_BYTES: u64 = 2_147_483_648;
     80 const MAX_METADATA_BYTES: usize = 33_554_432;
     81 const MAX_GIT_OUTPUT_BYTES: usize = 65_536;
     82 const MAX_PACKAGES: usize = 8_192;
     83 const MAX_WORKSPACE_PACKAGES: usize = 64;
     84 const MAX_TEXT_FIELD_BYTES: usize = 512;
     85 const MAX_ARCHIVE_EXPANDED_BYTES: u64 = 17_179_869_184;
     86 const MAX_ARCHIVE_PATH_BYTES: usize = 4_096;
     87 const MAX_RELEASE_TREE_BYTES: u64 = 68_719_476_736;
     88 const FILE_MODE: u32 = 0o644;
     89 const DIRECTORY_MODE: u32 = 0o755;
     90 const CANDIDATE_DIGEST_DOMAIN: &str = "sha256:";
     91 const SECRET_SCAN_OVERLAP_BYTES: usize = 131_072;
     92 
     93 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     94 pub(crate) enum CommandMode {
     95     Check,
     96     Write,
     97 }
     98 
     99 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
    100 enum ReleaseArtifactError {
    101     InvalidContract,
    102     InvalidServiceRoot,
    103     DirtyServiceSource,
    104     InvalidServiceMetadata,
    105     InvalidInputRoot,
    106     InvalidInputArtifact,
    107     InvalidSourceLock,
    108     InvalidSourceBundle,
    109     InvalidPackageInventory,
    110     ProtectedMaterialDetected,
    111     InvalidOutputRoot,
    112     StaleOutput,
    113     GenerationFailure,
    114 }
    115 
    116 impl ReleaseArtifactError {
    117     const fn code(self) -> &'static str {
    118         match self {
    119             Self::InvalidContract => "invalid_contract",
    120             Self::InvalidServiceRoot => "invalid_service_root",
    121             Self::DirtyServiceSource => "dirty_service_source",
    122             Self::InvalidServiceMetadata => "invalid_service_metadata",
    123             Self::InvalidInputRoot => "invalid_input_root",
    124             Self::InvalidInputArtifact => "invalid_input_artifact",
    125             Self::InvalidSourceLock => "invalid_source_lock",
    126             Self::InvalidSourceBundle => "invalid_source_bundle",
    127             Self::InvalidPackageInventory => "invalid_package_inventory",
    128             Self::ProtectedMaterialDetected => "protected_material_detected",
    129             Self::InvalidOutputRoot => "invalid_output_root",
    130             Self::StaleOutput => "stale_output",
    131             Self::GenerationFailure => "generation_failure",
    132         }
    133     }
    134 }
    135 
    136 impl fmt::Display for ReleaseArtifactError {
    137     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    138         formatter.write_str(match self {
    139             Self::InvalidContract => "service release artifact contract is invalid",
    140             Self::InvalidServiceRoot => "service release source root is invalid",
    141             Self::DirtyServiceSource => "service release source contains an ungoverned change",
    142             Self::InvalidServiceMetadata => "service release metadata is invalid",
    143             Self::InvalidInputRoot => "service release input root is invalid",
    144             Self::InvalidInputArtifact => "service release input artifact is invalid",
    145             Self::InvalidSourceLock => "service release source lock is invalid",
    146             Self::InvalidSourceBundle => "service release source bundle is invalid",
    147             Self::InvalidPackageInventory => "service release package inventory is invalid",
    148             Self::ProtectedMaterialDetected => "service release input contains protected material",
    149             Self::InvalidOutputRoot => "service release output root is invalid",
    150             Self::StaleOutput => "service release artifact set is stale",
    151             Self::GenerationFailure => "service release artifacts could not be generated",
    152         })
    153     }
    154 }
    155 
    156 impl std::error::Error for ReleaseArtifactError {}
    157 
    158 #[derive(Debug, Deserialize)]
    159 #[serde(deny_unknown_fields)]
    160 struct ReleaseMetadata {
    161     service: String,
    162     service_package: String,
    163     binary_name: String,
    164     version: String,
    165     #[serde(skip)]
    166     license: String,
    167 }
    168 
    169 #[derive(Debug, Deserialize)]
    170 struct CargoMetadata {
    171     packages: Vec<CargoPackage>,
    172     workspace_members: Vec<String>,
    173     resolve: Option<CargoResolve>,
    174 }
    175 
    176 #[derive(Debug, Deserialize)]
    177 struct CargoPackage {
    178     id: String,
    179     name: String,
    180     version: String,
    181     source: Option<String>,
    182     checksum: Option<String>,
    183     license: Option<String>,
    184     manifest_path: String,
    185     license_file: Option<String>,
    186     targets: Vec<CargoTarget>,
    187     #[serde(skip)]
    188     license_texts: Vec<DependencyLicenseText>,
    189 }
    190 
    191 #[derive(Clone, Debug)]
    192 struct DependencyLicenseText {
    193     filename: String,
    194     sha256: String,
    195     text: String,
    196 }
    197 
    198 #[derive(Debug, Deserialize)]
    199 struct CargoTarget {
    200     name: String,
    201     kind: Vec<String>,
    202 }
    203 
    204 #[derive(Debug, Deserialize)]
    205 struct CargoResolve {
    206     nodes: Vec<CargoNode>,
    207 }
    208 
    209 #[derive(Debug, Deserialize)]
    210 struct CargoNode {
    211     id: String,
    212     dependencies: Vec<String>,
    213 }
    214 
    215 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
    216 struct DigestValue {
    217     alg: &'static str,
    218     content: String,
    219 }
    220 
    221 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
    222 struct LicenseChoice {
    223     expression: String,
    224 }
    225 
    226 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
    227 struct SbomComponent {
    228     #[serde(rename = "type")]
    229     component_type: &'static str,
    230     #[serde(rename = "bom-ref")]
    231     bom_ref: String,
    232     name: String,
    233     version: String,
    234     #[serde(skip_serializing_if = "Option::is_none")]
    235     purl: Option<String>,
    236     licenses: Vec<LicenseChoice>,
    237     #[serde(skip_serializing_if = "Vec::is_empty")]
    238     hashes: Vec<DigestValue>,
    239     #[serde(skip_serializing_if = "Vec::is_empty")]
    240     properties: Vec<SbomProperty>,
    241 }
    242 
    243 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
    244 struct SbomProperty {
    245     name: String,
    246     value: String,
    247 }
    248 
    249 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
    250 struct SbomDependency {
    251     #[serde(rename = "ref")]
    252     reference: String,
    253     depends_on: Vec<String>,
    254 }
    255 
    256 #[derive(Debug, Serialize)]
    257 struct SbomMetadata {
    258     component: SbomComponent,
    259     properties: Vec<SbomProperty>,
    260 }
    261 
    262 #[derive(Debug, Serialize)]
    263 struct SbomComposition {
    264     aggregate: &'static str,
    265     assemblies: Vec<String>,
    266     dependencies: Vec<String>,
    267 }
    268 
    269 #[derive(Debug, Serialize)]
    270 struct CycloneDxSbom {
    271     #[serde(rename = "$schema")]
    272     json_schema: &'static str,
    273     #[serde(rename = "bomFormat")]
    274     bom_format: &'static str,
    275     #[serde(rename = "specVersion")]
    276     spec_version: &'static str,
    277     version: u32,
    278     metadata: SbomMetadata,
    279     components: Vec<SbomComponent>,
    280     dependencies: Vec<SbomDependency>,
    281     compositions: Vec<SbomComposition>,
    282 }
    283 
    284 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
    285 struct ArtifactRecord {
    286     path: String,
    287     byte_length: u64,
    288     sha256: String,
    289 }
    290 
    291 #[derive(Debug, Serialize)]
    292 struct ContractVersionsDocument {
    293     config: u32,
    294     state: u32,
    295     admin: u32,
    296     status: u32,
    297     provider: u32,
    298 }
    299 
    300 #[derive(Debug, Serialize)]
    301 struct SourceArchiveDocument {
    302     schema: &'static str,
    303     contract_version: u32,
    304     candidate_digest: String,
    305     service: String,
    306     service_revision: String,
    307     lib_repository: &'static str,
    308     lib_revision: String,
    309     service_source: ArtifactRecord,
    310     lib_source: ArtifactRecord,
    311     source_lock_sha256: String,
    312     workspace_catalog_sha256: String,
    313     cargo_lock_sha256: String,
    314     flake_lock_sha256: String,
    315     format: &'static str,
    316     compression: &'static str,
    317     git_history: &'static str,
    318 }
    319 
    320 #[derive(Debug, Serialize)]
    321 struct OciImageDocument {
    322     schema: &'static str,
    323     contract_version: u32,
    324     service: String,
    325     version: String,
    326     target: String,
    327     image: ArtifactRecord,
    328 }
    329 
    330 #[derive(Debug, Serialize)]
    331 struct ArtifactManifestDocument {
    332     schema: &'static str,
    333     contract_version: u32,
    334     candidate_digest: String,
    335     service: String,
    336     version: String,
    337     target: String,
    338     source_date_epoch: u32,
    339     service_revision: String,
    340     lib_revision: String,
    341     rust_version: &'static str,
    342     host_feature_profile: &'static str,
    343     contract_versions: ContractVersionsDocument,
    344     confidentiality: ConfidentialityDocument,
    345     artifacts: Vec<ArtifactRecord>,
    346 }
    347 
    348 #[derive(Debug, Serialize)]
    349 struct ConfidentialityDocument {
    350     state: &'static str,
    351     derived_from: ArtifactRecord,
    352     protected_material_included: bool,
    353 }
    354 
    355 #[derive(Debug, Serialize)]
    356 struct ScanDocument {
    357     schema: &'static str,
    358     contract_version: u32,
    359     candidate_digest: String,
    360     state: &'static str,
    361     ruleset_sha256: String,
    362     scanned_artifacts: Vec<ArtifactRecord>,
    363     nested_members_scanned: u64,
    364     expanded_bytes_scanned: u64,
    365 }
    366 
    367 #[derive(Debug, Serialize)]
    368 struct InTotoStatement {
    369     #[serde(rename = "_type")]
    370     statement_type: &'static str,
    371     subject: Vec<InTotoSubject>,
    372     #[serde(rename = "predicateType")]
    373     predicate_type: &'static str,
    374     predicate: SlsaPredicate,
    375 }
    376 
    377 #[derive(Debug, Serialize)]
    378 struct InTotoSubject {
    379     name: String,
    380     digest: BTreeMap<&'static str, String>,
    381 }
    382 
    383 #[derive(Debug, Serialize)]
    384 struct SlsaPredicate {
    385     #[serde(rename = "buildDefinition")]
    386     build_definition: SlsaBuildDefinition,
    387     #[serde(rename = "runDetails")]
    388     run_details: SlsaRunDetails,
    389 }
    390 
    391 #[derive(Debug, Serialize)]
    392 struct SlsaBuildDefinition {
    393     #[serde(rename = "buildType")]
    394     build_type: &'static str,
    395     #[serde(rename = "externalParameters")]
    396     external_parameters: SlsaExternalParameters,
    397     #[serde(rename = "internalParameters")]
    398     internal_parameters: BTreeMap<String, String>,
    399     #[serde(rename = "resolvedDependencies")]
    400     resolved_dependencies: Vec<SlsaResolvedDependency>,
    401 }
    402 
    403 #[derive(Debug, Serialize)]
    404 struct SlsaExternalParameters {
    405     candidate_digest: String,
    406     service: String,
    407     target: String,
    408     source_date_epoch: u32,
    409 }
    410 
    411 #[derive(Debug, Serialize)]
    412 struct SlsaResolvedDependency {
    413     uri: String,
    414     digest: BTreeMap<&'static str, String>,
    415 }
    416 
    417 #[derive(Debug, Serialize)]
    418 struct SlsaRunDetails {
    419     builder: SlsaBuilder,
    420     metadata: SlsaRunMetadata,
    421 }
    422 
    423 #[derive(Debug, Serialize)]
    424 struct SlsaBuilder {
    425     id: &'static str,
    426 }
    427 
    428 #[derive(Debug, Serialize)]
    429 struct SlsaRunMetadata {
    430     #[serde(rename = "invocationId")]
    431     invocation_id: String,
    432 }
    433 
    434 #[derive(Clone, Debug)]
    435 struct FileEvidence {
    436     byte_length: u64,
    437     sha256: String,
    438 }
    439 
    440 #[derive(Debug, Deserialize)]
    441 #[serde(deny_unknown_fields)]
    442 struct ReleaseDecision {
    443     schema: String,
    444     contract_version: u32,
    445     decision_state: String,
    446     implementation_scope: String,
    447     rust_version: String,
    448     edition: String,
    449     qualification_posture: String,
    450     predecessor: ReleasePredecessor,
    451     command: String,
    452     modes: Vec<String>,
    453     required_arguments: Vec<String>,
    454     service_metadata_path: String,
    455     service_metadata_fields: Vec<String>,
    456     service_license_path: String,
    457     source_lock_schema: String,
    458     source_lock_definition: String,
    459     artifact_contract_binding: String,
    460     artifact_admission_contract: String,
    461     supported_targets: Vec<String>,
    462     candidate_binding: String,
    463     lib_root_binding: String,
    464     binary_admission: String,
    465     oci_admission: String,
    466     input_inventory: Vec<String>,
    467     excluded_parent_owned_inputs: Vec<String>,
    468     service_root_inventory: Vec<String>,
    469     output_inventory: Vec<String>,
    470     canonical_json: String,
    471     checksum_format: String,
    472     source_archive_format: String,
    473     sbom_format: String,
    474     license_evidence: String,
    475     provenance_posture: String,
    476     protected_material_scan_scope: String,
    477     confidentiality_state: String,
    478     source_cleanliness: String,
    479     revision_stability: String,
    480     no_protected_material: bool,
    481     maximums: ReleaseMaximums,
    482     required_negative_vectors: Vec<String>,
    483     negative_error_codes: Vec<String>,
    484 }
    485 
    486 #[derive(Debug, Deserialize)]
    487 #[serde(deny_unknown_fields)]
    488 struct ReleasePredecessor {
    489     schema: String,
    490     filename: String,
    491     transition: String,
    492 }
    493 
    494 #[derive(Debug, Deserialize)]
    495 #[serde(deny_unknown_fields)]
    496 struct ReleaseMaximums {
    497     source_lock_bytes: u64,
    498     text_input_bytes: u64,
    499     generated_document_bytes: u64,
    500     service_cargo_lock_bytes: u64,
    501     service_flake_lock_bytes: u64,
    502     binary_bytes: u64,
    503     source_archive_bytes: u64,
    504     source_archive_member_bytes: u64,
    505     source_archive_members: u64,
    506     oci_bytes: u64,
    507     artifact_scan_expanded_bytes: u64,
    508     cargo_metadata_bytes: usize,
    509     packages: usize,
    510     workspace_packages: usize,
    511 }
    512 
    513 #[derive(Clone, Copy)]
    514 pub(crate) struct Arguments<'a> {
    515     pub(crate) mode: CommandMode,
    516     pub(crate) service_root: &'a Path,
    517     pub(crate) lib_root: &'a Path,
    518     pub(crate) input_root: &'a Path,
    519     pub(crate) output_root: &'a Path,
    520     pub(crate) target: &'a str,
    521     pub(crate) source_date_epoch: u32,
    522     pub(crate) candidate_digest: &'a str,
    523 }
    524 
    525 pub(crate) fn run(arguments: Arguments<'_>) -> Result<(), String> {
    526     run_inner(arguments).map_err(|error| error.to_string())
    527 }
    528 
    529 fn run_inner(arguments: Arguments<'_>) -> Result<(), ReleaseArtifactError> {
    530     let Arguments {
    531         mode,
    532         service_root,
    533         lib_root,
    534         input_root,
    535         output_root,
    536         target,
    537         source_date_epoch,
    538         candidate_digest,
    539     } = arguments;
    540     if !SUPPORTED_TARGETS.contains(&target)
    541         || source_date_epoch == 0
    542         || !valid_lower_hex(candidate_digest, 64)
    543     {
    544         return Err(ReleaseArtifactError::InvalidServiceMetadata);
    545     }
    546     let service_root = validate_git_root(service_root)?;
    547     let lib_root = validate_git_root(lib_root)?;
    548     if git_remote(&lib_root)? != "ssh://git@github.com/radrootslabs/lib.git"
    549         && git_remote(&lib_root)? != LIB_REPOSITORY
    550     {
    551         return Err(ReleaseArtifactError::InvalidServiceRoot);
    552     }
    553     let (input_root, input_snapshot) = validate_exact_input_root(input_root)?;
    554     let (output_parent, output_root) =
    555         validate_output_parent(output_root, &service_root, &input_root)?;
    556     let initial_head = git_head(&service_root)?;
    557     validate_clean_git(&service_root)?;
    558 
    559     let metadata = read_release_metadata(&service_root)?;
    560     let source_lock_bytes = read_bounded_regular(
    561         &service_root.join(LOCK_FILENAME),
    562         MAX_SOURCE_LOCK_BYTES,
    563         ReleaseArtifactError::InvalidSourceLock,
    564     )?;
    565     let source_lock = ServiceSourceLockV4::from_canonical_bytes(&source_lock_bytes)
    566         .map_err(|_| ReleaseArtifactError::InvalidSourceLock)?;
    567     if source_lock.service() != metadata.service {
    568         return Err(ReleaseArtifactError::InvalidSourceLock);
    569     }
    570     validate_source_lock_files(&service_root, &source_lock)?;
    571     let cargo_metadata = cargo_metadata(&service_root)?;
    572     let (sbom, notices, license_texts) = build_supply_chain_documents(&metadata, cargo_metadata)?;
    573 
    574     let staging = tempfile::Builder::new()
    575         .prefix(".radroots-service-release-")
    576         .tempdir_in(&output_parent)
    577         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
    578     set_directory_mode(staging.path())?;
    579 
    580     let static_inputs = [
    581         ("config.example.toml", "config.example.toml"),
    582         ("config.schema.json", "config.schema.json"),
    583         ("systemd.service", "systemd.service"),
    584         ("nixos-module.nix", "nixos-module.nix"),
    585     ];
    586     for (input, output) in static_inputs {
    587         copy_snapshot_file(
    588             &input_snapshot,
    589             input,
    590             &staging.path().join(output),
    591             MAX_TEXT_INPUT_BYTES,
    592         )?;
    593         validate_text_artifact(&staging.path().join(output), output)?;
    594     }
    595     copy_bounded(
    596         &service_root.join("LICENSE-APACHE"),
    597         &staging.path().join("LICENSE-APACHE"),
    598         MAX_TEXT_INPUT_BYTES,
    599     )?;
    600     validate_text_artifact(&staging.path().join("LICENSE-APACHE"), "LICENSE-APACHE")?;
    601     copy_bounded(
    602         &service_root.join("LICENSE-MIT"),
    603         &staging.path().join("LICENSE-MIT"),
    604         MAX_TEXT_INPUT_BYTES,
    605     )?;
    606     validate_text_artifact(&staging.path().join("LICENSE-MIT"), "LICENSE-MIT")?;
    607     write_generated(&staging.path().join(LOCK_FILENAME), &source_lock_bytes)?;
    608     create_binary_archive_from_snapshot(
    609         &input_snapshot,
    610         "service-binary",
    611         &staging.path().join("binary.tar.gz"),
    612         &metadata.binary_name,
    613         target,
    614         source_date_epoch,
    615     )?;
    616     let oci = copy_snapshot_file(
    617         &input_snapshot,
    618         "oci-image.tar.gz",
    619         &staging.path().join("oci-image.tar.gz"),
    620         MAX_OCI_BYTES,
    621     )?;
    622     let versions = source_lock.contract_versions();
    623     artifact_admission::admit_oci(
    624         &staging.path().join("oci-image.tar.gz"),
    625         staging.path(),
    626         &artifact_admission::OciExpectation {
    627             service: &metadata.service,
    628             binary_name: &metadata.binary_name,
    629             version: &metadata.version,
    630             service_revision: &initial_head,
    631             lib_revision: source_lock.revision(),
    632             license: &metadata.license,
    633             contract_versions: artifact_admission::ContractVersions {
    634                 admin: versions.admin(),
    635                 config: versions.config(),
    636                 provider: versions.provider(),
    637                 state: versions.state(),
    638                 status: versions.status(),
    639             },
    640         },
    641     )
    642     .map_err(|_error| {
    643         #[cfg(test)]
    644         eprintln!("OCI admission category: {_error}");
    645         ReleaseArtifactError::InvalidInputArtifact
    646     })?;
    647     input_snapshot
    648         .revalidate()
    649         .map_err(|_| ReleaseArtifactError::InvalidInputRoot)?;
    650     let service_source = exact_tree_archive::create(
    651         &service_root,
    652         &initial_head,
    653         &staging.path().join("service-source.tar"),
    654         u64::from(source_date_epoch),
    655     )
    656     .map_err(|_| ReleaseArtifactError::InvalidSourceBundle)?;
    657     let lib_mtime = exact_tree_archive::commit_timestamp(&lib_root, source_lock.revision())
    658         .map_err(|_| ReleaseArtifactError::InvalidSourceBundle)?;
    659     let lib_source = exact_tree_archive::create(
    660         &lib_root,
    661         source_lock.revision(),
    662         &staging.path().join("lib-source.tar"),
    663         lib_mtime,
    664     )
    665     .map_err(|_| ReleaseArtifactError::InvalidSourceBundle)?;
    666     if lib_source.sha256 != source_lock.source_archive_sha256() {
    667         return Err(ReleaseArtifactError::InvalidSourceBundle);
    668     }
    669     let catalog = exact_tree_archive::read_blob(
    670         &lib_root,
    671         source_lock.revision(),
    672         "contracts/crates/catalog.v2.toml",
    673         MAX_TEXT_INPUT_BYTES as usize,
    674     )
    675     .map_err(|_| ReleaseArtifactError::InvalidSourceBundle)?;
    676     let lib_manifest = exact_tree_archive::read_blob(
    677         &lib_root,
    678         source_lock.revision(),
    679         "Cargo.toml",
    680         MAX_TEXT_INPUT_BYTES as usize,
    681     )
    682     .map_err(|_| ReleaseArtifactError::InvalidSourceBundle)?;
    683     let lib_toolchain = exact_tree_archive::read_blob(
    684         &lib_root,
    685         source_lock.revision(),
    686         "rust-toolchain.toml",
    687         MAX_TOOLCHAIN_BYTES,
    688     )
    689     .map_err(|_| ReleaseArtifactError::InvalidSourceBundle)?;
    690     validate_lib_compiler_inputs(&lib_manifest, &lib_toolchain, &catalog)
    691         .map_err(|_| ReleaseArtifactError::InvalidSourceBundle)?;
    692     if sha256_bytes(&catalog) != source_lock.workspace_catalog_sha256() {
    693         return Err(ReleaseArtifactError::InvalidSourceBundle);
    694     }
    695 
    696     let oci_document = OciImageDocument {
    697         schema: "radroots.service.oci-image.v1",
    698         contract_version: 1,
    699         service: metadata.service.clone(),
    700         version: metadata.version.clone(),
    701         target: target.to_owned(),
    702         image: artifact_record("oci-image.tar.gz", &oci),
    703     };
    704     write_json(&staging.path().join("oci-image.v1.json"), &oci_document)?;
    705     let source_lock_sha256 = sha256_bytes(&source_lock_bytes);
    706     let source_document = SourceArchiveDocument {
    707         schema: "radroots.service.source-archives.v3",
    708         contract_version: 3,
    709         candidate_digest: candidate_digest.to_owned(),
    710         service: metadata.service.clone(),
    711         service_revision: initial_head.clone(),
    712         lib_repository: LIB_REPOSITORY,
    713         lib_revision: source_lock.revision().to_owned(),
    714         service_source: artifact_record_from_exact_tree("service-source.tar", &service_source),
    715         lib_source: artifact_record_from_exact_tree("lib-source.tar", &lib_source),
    716         source_lock_sha256: source_lock_sha256.clone(),
    717         workspace_catalog_sha256: source_lock.workspace_catalog_sha256().to_owned(),
    718         cargo_lock_sha256: source_lock.cargo_lock_sha256().to_owned(),
    719         flake_lock_sha256: source_lock.flake_lock_sha256().to_owned(),
    720         format: "ustar",
    721         compression: "none",
    722         git_history: "forbidden",
    723     };
    724     write_json(
    725         &staging.path().join("source-archives.v3.json"),
    726         &source_document,
    727     )?;
    728     write_generated(
    729         &staging.path().join("THIRD-PARTY-NOTICES.txt"),
    730         notices.as_bytes(),
    731     )?;
    732     write_generated(
    733         &staging.path().join("THIRD-PARTY-LICENSES.txt"),
    734         license_texts.as_bytes(),
    735     )?;
    736 
    737     let mut sbom = sbom;
    738     let sbom_artifacts = inventory_records(staging.path())?;
    739     reconcile_sbom_artifacts(&mut sbom, &sbom_artifacts);
    740     validate_cyclonedx_profile(&sbom, &sbom_artifacts)?;
    741     write_json(&staging.path().join("sbom.cdx.json"), &sbom)?;
    742     let scanned_artifacts = inventory_records(staging.path())?;
    743     let (nested_members_scanned, expanded_bytes_scanned) =
    744         scan_artifact_inventory(staging.path(), &scanned_artifacts)?;
    745     let scan = ScanDocument {
    746         schema: "radroots.service.artifact-scan.v1",
    747         contract_version: 1,
    748         candidate_digest: candidate_digest.to_owned(),
    749         state: "no_protected_material_detected",
    750         ruleset_sha256: scanner_ruleset_sha256(),
    751         scanned_artifacts,
    752         nested_members_scanned,
    753         expanded_bytes_scanned,
    754     };
    755     write_json(&staging.path().join("artifact-scan.v1.json"), &scan)?;
    756     let scan_evidence = hash_regular(
    757         &staging.path().join("artifact-scan.v1.json"),
    758         MAX_GENERATED_DOCUMENT_BYTES,
    759     )?;
    760 
    761     let payload = inventory_records(staging.path())?;
    762     let versions = source_lock.contract_versions();
    763     let manifest = ArtifactManifestDocument {
    764         schema: "radroots.service.release-artifacts.v2",
    765         contract_version: 2,
    766         candidate_digest: candidate_digest.to_owned(),
    767         service: metadata.service.clone(),
    768         version: metadata.version.clone(),
    769         target: target.to_owned(),
    770         source_date_epoch,
    771         service_revision: initial_head.clone(),
    772         lib_revision: source_lock.revision().to_owned(),
    773         rust_version: RUST_VERSION,
    774         host_feature_profile: "service-host",
    775         contract_versions: ContractVersionsDocument {
    776             config: versions.config(),
    777             state: versions.state(),
    778             admin: versions.admin(),
    779             status: versions.status(),
    780             provider: versions.provider(),
    781         },
    782         confidentiality: ConfidentialityDocument {
    783             state: scan.state,
    784             derived_from: artifact_record("artifact-scan.v1.json", &scan_evidence),
    785             protected_material_included: false,
    786         },
    787         artifacts: payload.clone(),
    788     };
    789     validate_confidentiality_binding(&manifest, &scan, &scan_evidence, &payload)?;
    790     write_json(&staging.path().join("artifact-manifest.v2.json"), &manifest)?;
    791     let manifest_evidence = hash_regular(
    792         &staging.path().join("artifact-manifest.v2.json"),
    793         MAX_TEXT_INPUT_BYTES,
    794     )?;
    795     let service_repository = git_remote(&service_root)?;
    796     let provenance = build_provenance(
    797         ProvenanceInput {
    798             candidate_digest,
    799             service: &metadata.service,
    800             target,
    801             source_date_epoch,
    802             service_repository: &service_repository,
    803             service_revision: &initial_head,
    804             lib_revision: source_lock.revision(),
    805             source_lock_sha256: &source_lock_sha256,
    806             manifest_sha256: &manifest_evidence.sha256,
    807         },
    808         &payload,
    809     );
    810     validate_provenance_subjects(&provenance, candidate_digest, &payload)?;
    811     write_json(&staging.path().join("provenance.intoto.jsonl"), &provenance)?;
    812     write_checksums(staging.path())?;
    813     validate_exact_output_inventory(staging.path())?;
    814     sync_directory(staging.path())?;
    815     let expected_output = inventory_records(staging.path())?;
    816 
    817     validate_clean_git(&service_root)?;
    818     if git_head(&service_root)? != initial_head {
    819         return Err(ReleaseArtifactError::DirtyServiceSource);
    820     }
    821 
    822     if output_root.exists() {
    823         compare_output(staging.path(), &output_root)?;
    824         return Ok(());
    825     }
    826     if mode == CommandMode::Check {
    827         return Err(ReleaseArtifactError::StaleOutput);
    828     }
    829     let staging_path = staging.keep();
    830     fs::rename(&staging_path, &output_root).map_err(|_| ReleaseArtifactError::GenerationFailure)?;
    831     sync_directory(&output_parent)?;
    832     validate_output_records(&output_root, &expected_output)
    833 }
    834 
    835 fn validate_confidentiality_binding(
    836     manifest: &ArtifactManifestDocument,
    837     scan: &ScanDocument,
    838     scan_evidence: &FileEvidence,
    839     payload: &[ArtifactRecord],
    840 ) -> Result<(), ReleaseArtifactError> {
    841     if manifest.candidate_digest != scan.candidate_digest
    842         || manifest.confidentiality.state != scan.state
    843         || manifest.confidentiality.protected_material_included
    844         || manifest.confidentiality.derived_from.path != "artifact-scan.v1.json"
    845         || manifest.confidentiality.derived_from.sha256 != scan_evidence.sha256
    846         || manifest.artifacts != payload
    847     {
    848         return Err(ReleaseArtifactError::GenerationFailure);
    849     }
    850     Ok(())
    851 }
    852 
    853 fn read_release_metadata(root: &Path) -> Result<ReleaseMetadata, ReleaseArtifactError> {
    854     let bytes = read_bounded_regular(
    855         &root.join("Cargo.toml"),
    856         MAX_MANIFEST_BYTES as u64,
    857         ReleaseArtifactError::InvalidServiceMetadata,
    858     )?;
    859     let text =
    860         std::str::from_utf8(&bytes).map_err(|_| ReleaseArtifactError::InvalidServiceMetadata)?;
    861     let value = toml::from_str::<toml::Value>(text)
    862         .map_err(|_| ReleaseArtifactError::InvalidServiceMetadata)?;
    863     let release = value
    864         .get("workspace")
    865         .and_then(|value| value.get("metadata"))
    866         .and_then(|value| value.get("radroots"))
    867         .and_then(|value| value.get("service_release"))
    868         .cloned()
    869         .ok_or(ReleaseArtifactError::InvalidServiceMetadata)?;
    870     let mut metadata = release
    871         .try_into::<ReleaseMetadata>()
    872         .map_err(|_| ReleaseArtifactError::InvalidServiceMetadata)?;
    873     metadata.license = value
    874         .get("workspace")
    875         .and_then(|workspace| workspace.get("package"))
    876         .or_else(|| value.get("package"))
    877         .and_then(|package| package.get("license"))
    878         .and_then(toml::Value::as_str)
    879         .ok_or(ReleaseArtifactError::InvalidServiceMetadata)?
    880         .to_owned();
    881     if !valid_snake_identifier(&metadata.service)
    882         || !valid_kebab_identifier(&metadata.service_package)
    883         || !valid_kebab_identifier(&metadata.binary_name)
    884         || metadata.version.len() > 128
    885         || metadata.license != "AGPL-3.0-or-later"
    886         || !matches!(
    887             semver::Version::parse(&metadata.version),
    888             Ok(version) if version.to_string() == metadata.version
    889         )
    890     {
    891         return Err(ReleaseArtifactError::InvalidServiceMetadata);
    892     }
    893     Ok(metadata)
    894 }
    895 
    896 fn validate_source_lock_files(
    897     root: &Path,
    898     source_lock: &ServiceSourceLockV4,
    899 ) -> Result<(), ReleaseArtifactError> {
    900     for name in PREDECESSOR_LOCK_FILENAMES {
    901         match fs::symlink_metadata(root.join(name)) {
    902             Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
    903             _ => return Err(ReleaseArtifactError::InvalidSourceLock),
    904         }
    905     }
    906     let toolchain = read_bounded_regular(
    907         &root.join("rust-toolchain.toml"),
    908         MAX_TOOLCHAIN_BYTES as u64,
    909         ReleaseArtifactError::InvalidSourceLock,
    910     )?;
    911     validate_toolchain_bytes(&toolchain).map_err(|_| ReleaseArtifactError::InvalidSourceLock)?;
    912     let cargo_lock = hash_regular(&root.join("Cargo.lock"), MAX_SERVICE_CARGO_LOCK_BYTES)
    913         .map_err(|_| ReleaseArtifactError::InvalidSourceLock)?;
    914     if cargo_lock.sha256 != source_lock.cargo_lock_sha256() {
    915         return Err(ReleaseArtifactError::InvalidSourceLock);
    916     }
    917     let flake_nix = read_bounded_regular(
    918         &root.join("flake.nix"),
    919         MAX_TEXT_INPUT_BYTES,
    920         ReleaseArtifactError::InvalidSourceLock,
    921     )?;
    922     let flake_lock = read_bounded_regular(
    923         &root.join("flake.lock"),
    924         MAX_SERVICE_FLAKE_LOCK_BYTES,
    925         ReleaseArtifactError::InvalidSourceLock,
    926     )?;
    927     let evidence = validate_bound_nix_material(&flake_nix, &flake_lock)
    928         .map_err(|_| ReleaseArtifactError::InvalidSourceLock)?;
    929     let artifact_contract = hash_regular(
    930         &root.join(source_lock.artifact_contract_path()),
    931         MAX_TEXT_INPUT_BYTES,
    932     )
    933     .map_err(|_| ReleaseArtifactError::InvalidSourceLock)?;
    934     if evidence.revision == source_lock.revision()
    935         && evidence.lock_sha256 == source_lock.flake_lock_sha256()
    936         && artifact_contract.sha256 == source_lock.artifact_contract_sha256()
    937     {
    938         Ok(())
    939     } else {
    940         Err(ReleaseArtifactError::InvalidSourceLock)
    941     }
    942 }
    943 
    944 #[cfg(test)]
    945 pub(crate) fn validate_writer_fixture(
    946     root: &Path,
    947     source_lock: &ServiceSourceLockV4,
    948 ) -> Result<(), String> {
    949     validate_source_lock_files(root, source_lock).map_err(|error| error.to_string())
    950 }
    951 
    952 fn cargo_metadata(root: &Path) -> Result<CargoMetadata, ReleaseArtifactError> {
    953     let mut command = Command::new("cargo");
    954     command
    955         .args(["metadata", "--format-version", "1", "--locked", "--offline"])
    956         .current_dir(root);
    957     let bytes = command_stdout(&mut command, MAX_METADATA_BYTES)
    958         .map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
    959     let mut metadata = serde_json::from_slice::<CargoMetadata>(&bytes)
    960         .map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
    961     for package in &mut metadata.packages {
    962         if package.source.is_some() {
    963             package.license_texts = dependency_license_texts(package)?;
    964         }
    965     }
    966     Ok(metadata)
    967 }
    968 
    969 fn dependency_license_texts(
    970     package: &CargoPackage,
    971 ) -> Result<Vec<DependencyLicenseText>, ReleaseArtifactError> {
    972     let manifest = Path::new(&package.manifest_path);
    973     if !manifest.is_absolute() || manifest.file_name() != Some(OsStr::new("Cargo.toml")) {
    974         return Err(ReleaseArtifactError::InvalidPackageInventory);
    975     }
    976     let package_root = manifest
    977         .parent()
    978         .ok_or(ReleaseArtifactError::InvalidPackageInventory)?
    979         .canonicalize()
    980         .map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
    981     let mut candidates = BTreeSet::new();
    982     if let Some(license_file) = package.license_file.as_deref() {
    983         let relative = Path::new(license_file);
    984         if relative.is_absolute()
    985             || relative
    986                 .components()
    987                 .any(|component| !matches!(component, Component::Normal(_)))
    988         {
    989             return Err(ReleaseArtifactError::InvalidPackageInventory);
    990         }
    991         candidates.insert(relative.to_path_buf());
    992     } else {
    993         let entries = fs::read_dir(&package_root)
    994             .map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
    995         for (index, entry) in entries.enumerate() {
    996             if index >= 256 {
    997                 return Err(ReleaseArtifactError::InvalidPackageInventory);
    998             }
    999             let entry = entry.map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
   1000             let filename = entry
   1001                 .file_name()
   1002                 .into_string()
   1003                 .map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
   1004             let uppercase = filename.to_ascii_uppercase();
   1005             if ["LICENSE", "COPYING", "COPYRIGHT", "NOTICE"]
   1006                 .iter()
   1007                 .any(|prefix| {
   1008                     uppercase == *prefix
   1009                         || uppercase.starts_with(&format!("{prefix}-"))
   1010                         || uppercase.starts_with(&format!("{prefix}."))
   1011                 })
   1012             {
   1013                 candidates.insert(PathBuf::from(filename));
   1014             }
   1015         }
   1016     }
   1017     if candidates.is_empty() || candidates.len() > 16 {
   1018         return Err(ReleaseArtifactError::InvalidPackageInventory);
   1019     }
   1020     let mut texts = Vec::with_capacity(candidates.len());
   1021     let mut total = 0_u64;
   1022     for relative in candidates {
   1023         let path = package_root.join(&relative);
   1024         let canonical = path
   1025             .canonicalize()
   1026             .map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
   1027         if canonical.parent() != Some(package_root.as_path()) {
   1028             return Err(ReleaseArtifactError::InvalidPackageInventory);
   1029         }
   1030         let bytes = read_bounded_regular(
   1031             &canonical,
   1032             MAX_TEXT_INPUT_BYTES,
   1033             ReleaseArtifactError::InvalidPackageInventory,
   1034         )?;
   1035         total = total
   1036             .checked_add(bytes.len() as u64)
   1037             .filter(|total| *total <= MAX_GENERATED_DOCUMENT_BYTES)
   1038             .ok_or(ReleaseArtifactError::InvalidPackageInventory)?;
   1039         scan_bytes(&bytes)?;
   1040         let text =
   1041             String::from_utf8(bytes).map_err(|_| ReleaseArtifactError::InvalidPackageInventory)?;
   1042         if text.trim().is_empty() {
   1043             return Err(ReleaseArtifactError::InvalidPackageInventory);
   1044         }
   1045         texts.push(DependencyLicenseText {
   1046             filename: relative
   1047                 .to_str()
   1048                 .ok_or(ReleaseArtifactError::InvalidPackageInventory)?
   1049                 .to_owned(),
   1050             sha256: sha256_bytes(text.as_bytes()),
   1051             text,
   1052         });
   1053     }
   1054     Ok(texts)
   1055 }
   1056 
   1057 fn build_supply_chain_documents(
   1058     metadata: &ReleaseMetadata,
   1059     cargo: CargoMetadata,
   1060 ) -> Result<(CycloneDxSbom, String, String), ReleaseArtifactError> {
   1061     if cargo.packages.is_empty()
   1062         || cargo.packages.len() > MAX_PACKAGES
   1063         || cargo.workspace_members.is_empty()
   1064         || cargo.workspace_members.len() > MAX_WORKSPACE_PACKAGES
   1065     {
   1066         return Err(ReleaseArtifactError::InvalidPackageInventory);
   1067     }
   1068     let workspace = cargo.workspace_members.into_iter().collect::<BTreeSet<_>>();
   1069     let mut by_id = BTreeMap::new();
   1070     let mut root_id = None;
   1071     for package in cargo.packages {
   1072         validate_metadata_package(&package, workspace.contains(&package.id))?;
   1073         if package.name == metadata.service_package
   1074             && (root_id.replace(package.id.clone()).is_some()
   1075                 || package.version != metadata.version
   1076                 || !package.targets.iter().any(|target| {
   1077                     target.name == metadata.binary_name
   1078                         && target.kind.iter().any(|kind| kind == "bin")
   1079                 })
   1080                 || !workspace.contains(&package.id))
   1081         {
   1082             return Err(ReleaseArtifactError::InvalidPackageInventory);
   1083         }
   1084         if by_id.insert(package.id.clone(), package).is_some() {
   1085             return Err(ReleaseArtifactError::InvalidPackageInventory);
   1086         }
   1087     }
   1088     let root_id = root_id.ok_or(ReleaseArtifactError::InvalidPackageInventory)?;
   1089     if by_id.len() > MAX_PACKAGES || !workspace.iter().all(|id| by_id.contains_key(id)) {
   1090         return Err(ReleaseArtifactError::InvalidPackageInventory);
   1091     }
   1092     let references = by_id
   1093         .values()
   1094         .map(|package| (package.id.clone(), package_reference(package)))
   1095         .collect::<BTreeMap<_, _>>();
   1096     let root_package = by_id
   1097         .get(&root_id)
   1098         .ok_or(ReleaseArtifactError::InvalidPackageInventory)?;
   1099     let root_component = sbom_component(root_package, "application")?;
   1100     let mut components = by_id
   1101         .values()
   1102         .filter(|package| package.id != root_id)
   1103         .map(|package| sbom_component(package, "library"))
   1104         .collect::<Result<Vec<_>, _>>()?;
   1105     components.sort();
   1106     let resolve = cargo
   1107         .resolve
   1108         .ok_or(ReleaseArtifactError::InvalidPackageInventory)?;
   1109     if resolve.nodes.len() != by_id.len() || resolve.nodes.len() > MAX_PACKAGES {
   1110         return Err(ReleaseArtifactError::InvalidPackageInventory);
   1111     }
   1112     let mut seen_nodes = BTreeSet::new();
   1113     let mut dependencies = Vec::with_capacity(resolve.nodes.len());
   1114     for node in resolve.nodes {
   1115         if !seen_nodes.insert(node.id.clone()) {
   1116             return Err(ReleaseArtifactError::InvalidPackageInventory);
   1117         }
   1118         let reference = references
   1119             .get(&node.id)
   1120             .ok_or(ReleaseArtifactError::InvalidPackageInventory)?
   1121             .clone();
   1122         let mut depends_on = node
   1123             .dependencies
   1124             .iter()
   1125             .map(|dependency| {
   1126                 references
   1127                     .get(dependency)
   1128                     .cloned()
   1129                     .ok_or(ReleaseArtifactError::InvalidPackageInventory)
   1130             })
   1131             .collect::<Result<Vec<_>, _>>()?;
   1132         depends_on.sort();
   1133         depends_on.dedup();
   1134         dependencies.push(SbomDependency {
   1135             reference,
   1136             depends_on,
   1137         });
   1138     }
   1139     dependencies.sort_by(|left, right| left.reference.cmp(&right.reference));
   1140     let sbom = CycloneDxSbom {
   1141         json_schema: "https://cyclonedx.org/schema/bom-1.6.schema.json",
   1142         bom_format: "CycloneDX",
   1143         spec_version: "1.6",
   1144         version: 1,
   1145         metadata: SbomMetadata {
   1146             component: root_component,
   1147             properties: vec![SbomProperty {
   1148                 name: "radroots:evidence:dependency-closure".to_owned(),
   1149                 value: "complete".to_owned(),
   1150             }],
   1151         },
   1152         components,
   1153         dependencies,
   1154         compositions: Vec::new(),
   1155     };
   1156 
   1157     let mut third_party = by_id
   1158         .values()
   1159         .filter(|package| !workspace.contains(&package.id))
   1160         .collect::<Vec<_>>();
   1161     third_party.sort_by(|left, right| {
   1162         (&left.name, &left.version, &left.source).cmp(&(&right.name, &right.version, &right.source))
   1163     });
   1164     let mut notices = String::from(
   1165         "Radroots service third-party notices v1\n\nThis inventory is generated from the locked Cargo dependency graph.\n",
   1166     );
   1167     let mut licenses = String::from(
   1168         "Radroots service third-party license texts v1\n\nThis file contains the exact bounded license texts admitted for each locked third-party Cargo package.\n",
   1169     );
   1170     if third_party.is_empty() {
   1171         notices.push_str("\nNo third-party Cargo packages are present.\n");
   1172         licenses.push_str("\nNo third-party Cargo packages are present.\n");
   1173     } else {
   1174         for package in third_party {
   1175             let license = package
   1176                 .license
   1177                 .as_deref()
   1178                 .ok_or(ReleaseArtifactError::InvalidPackageInventory)?;
   1179             let source = package
   1180                 .source
   1181                 .as_deref()
   1182                 .ok_or(ReleaseArtifactError::InvalidPackageInventory)?;
   1183             use fmt::Write as _;
   1184             writeln!(notices).map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1185             writeln!(notices, "Package: {} {}", package.name, package.version)
   1186                 .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1187             writeln!(notices, "License: {license}")
   1188                 .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1189             writeln!(notices, "Source: {source}")
   1190                 .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1191             if package.license_texts.is_empty() {
   1192                 return Err(ReleaseArtifactError::InvalidPackageInventory);
   1193             }
   1194             for license_text in &package.license_texts {
   1195                 if !valid_output_component(&license_text.filename)
   1196                     || license_text.text.trim().is_empty()
   1197                     || license_text.sha256 != sha256_bytes(license_text.text.as_bytes())
   1198                 {
   1199                     return Err(ReleaseArtifactError::InvalidPackageInventory);
   1200                 }
   1201                 writeln!(
   1202                     notices,
   1203                     "License-Text: {} sha256:{}",
   1204                     license_text.filename, license_text.sha256
   1205                 )
   1206                 .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1207                 writeln!(licenses).map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1208                 writeln!(
   1209                     licenses,
   1210                     "===== {} {} / {} / sha256:{} =====",
   1211                     package.name, package.version, license_text.filename, license_text.sha256
   1212                 )
   1213                 .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1214                 licenses.push_str(&license_text.text);
   1215                 if !license_text.text.ends_with('\n') {
   1216                     licenses.push('\n');
   1217                 }
   1218             }
   1219         }
   1220     }
   1221     scan_bytes(notices.as_bytes())?;
   1222     scan_bytes(licenses.as_bytes())?;
   1223     if licenses.len() as u64 > MAX_GENERATED_DOCUMENT_BYTES {
   1224         return Err(ReleaseArtifactError::InvalidPackageInventory);
   1225     }
   1226     Ok((sbom, notices, licenses))
   1227 }
   1228 
   1229 fn reconcile_sbom_artifacts(sbom: &mut CycloneDxSbom, artifacts: &[ArtifactRecord]) {
   1230     let root_reference = sbom.metadata.component.bom_ref.clone();
   1231     let mut assemblies = Vec::with_capacity(artifacts.len());
   1232     for artifact in artifacts {
   1233         let reference = format!("artifact:{}#{}", artifact.path, artifact.sha256);
   1234         assemblies.push(reference.clone());
   1235         sbom.components.push(SbomComponent {
   1236             component_type: "file",
   1237             bom_ref: reference.clone(),
   1238             name: artifact.path.clone(),
   1239             version: artifact.sha256.clone(),
   1240             purl: None,
   1241             licenses: sbom.metadata.component.licenses.clone(),
   1242             hashes: vec![DigestValue {
   1243                 alg: "SHA-256",
   1244                 content: artifact.sha256.clone(),
   1245             }],
   1246             properties: vec![
   1247                 SbomProperty {
   1248                     name: "radroots:artifact:byte-length".to_owned(),
   1249                     value: artifact.byte_length.to_string(),
   1250                 },
   1251                 SbomProperty {
   1252                     name: "radroots:ecosystem".to_owned(),
   1253                     value: artifact_ecosystem(&artifact.path).to_owned(),
   1254                 },
   1255             ],
   1256         });
   1257         sbom.dependencies.push(SbomDependency {
   1258             reference,
   1259             depends_on: vec![root_reference.clone()],
   1260         });
   1261     }
   1262     sbom.components.sort();
   1263     sbom.dependencies
   1264         .sort_by(|left, right| left.reference.cmp(&right.reference));
   1265     assemblies.sort();
   1266     let mut dependencies =
   1267         sbom.components
   1268             .iter()
   1269             .filter(|component| {
   1270                 component.properties.iter().any(|property| {
   1271                     property.name == "radroots:ecosystem" && property.value == "cargo"
   1272                 })
   1273             })
   1274             .map(|component| component.bom_ref.clone())
   1275             .collect::<Vec<_>>();
   1276     dependencies.push(root_reference);
   1277     dependencies.sort();
   1278     dependencies.dedup();
   1279     sbom.compositions = vec![SbomComposition {
   1280         aggregate: "complete",
   1281         assemblies,
   1282         dependencies,
   1283     }];
   1284 }
   1285 
   1286 fn validate_cyclonedx_profile(
   1287     sbom: &CycloneDxSbom,
   1288     artifacts: &[ArtifactRecord],
   1289 ) -> Result<(), ReleaseArtifactError> {
   1290     let schema = serde_json::json!({
   1291         "$schema": "https://json-schema.org/draft/2020-12/schema",
   1292         "type": "object",
   1293         "additionalProperties": false,
   1294         "required": ["$schema", "bomFormat", "specVersion", "version", "metadata", "components", "dependencies", "compositions"],
   1295         "properties": {
   1296             "$schema": {"const": "https://cyclonedx.org/schema/bom-1.6.schema.json"},
   1297             "bomFormat": {"const": "CycloneDX"},
   1298             "specVersion": {"const": "1.6"},
   1299             "version": {"const": 1},
   1300             "metadata": {"type": "object"},
   1301             "components": {"type": "array", "minItems": 1},
   1302             "dependencies": {"type": "array", "minItems": 1},
   1303             "compositions": {"type": "array", "minItems": 1, "maxItems": 1}
   1304         }
   1305     });
   1306     let validator =
   1307         jsonschema::validator_for(&schema).map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1308     let value = serde_json::to_value(sbom).map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1309     validator
   1310         .validate(&value)
   1311         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1312 
   1313     let component_references = sbom
   1314         .components
   1315         .iter()
   1316         .map(|component| component.bom_ref.as_str())
   1317         .chain(std::iter::once(sbom.metadata.component.bom_ref.as_str()))
   1318         .collect::<BTreeSet<_>>();
   1319     if component_references.len() != sbom.components.len() + 1
   1320         || sbom.dependencies.len() != component_references.len()
   1321         || sbom.dependencies.iter().any(|dependency| {
   1322             !component_references.contains(dependency.reference.as_str())
   1323                 || dependency
   1324                     .depends_on
   1325                     .iter()
   1326                     .any(|reference| !component_references.contains(reference.as_str()))
   1327         })
   1328     {
   1329         return Err(ReleaseArtifactError::GenerationFailure);
   1330     }
   1331     let composition = sbom
   1332         .compositions
   1333         .first()
   1334         .ok_or(ReleaseArtifactError::GenerationFailure)?;
   1335     let expected_artifacts = artifacts
   1336         .iter()
   1337         .map(|artifact| format!("artifact:{}#{}", artifact.path, artifact.sha256))
   1338         .collect::<BTreeSet<_>>();
   1339     if composition.aggregate != "complete"
   1340         || composition.assemblies.iter().collect::<BTreeSet<_>>()
   1341             != expected_artifacts.iter().collect::<BTreeSet<_>>()
   1342         || artifacts.iter().any(|artifact| {
   1343             sbom.components
   1344                 .iter()
   1345                 .filter(|component| {
   1346                     component.bom_ref == format!("artifact:{}#{}", artifact.path, artifact.sha256)
   1347                         && component.hashes
   1348                             == [DigestValue {
   1349                                 alg: "SHA-256",
   1350                                 content: artifact.sha256.clone(),
   1351                             }]
   1352                 })
   1353                 .count()
   1354                 != 1
   1355         })
   1356     {
   1357         return Err(ReleaseArtifactError::GenerationFailure);
   1358     }
   1359     Ok(())
   1360 }
   1361 
   1362 fn validate_provenance_subjects(
   1363     provenance: &InTotoStatement,
   1364     candidate_digest: &str,
   1365     artifacts: &[ArtifactRecord],
   1366 ) -> Result<(), ReleaseArtifactError> {
   1367     let expected = artifacts
   1368         .iter()
   1369         .map(|artifact| (artifact.path.as_str(), artifact.sha256.as_str()))
   1370         .collect::<BTreeSet<_>>();
   1371     let observed = provenance
   1372         .subject
   1373         .iter()
   1374         .filter_map(|subject| {
   1375             subject
   1376                 .digest
   1377                 .get("sha256")
   1378                 .map(|digest| (subject.name.as_str(), digest.as_str()))
   1379         })
   1380         .collect::<BTreeSet<_>>();
   1381     if provenance.statement_type != "https://in-toto.io/Statement/v1"
   1382         || provenance.predicate_type != "https://slsa.dev/provenance/v1"
   1383         || provenance
   1384             .predicate
   1385             .build_definition
   1386             .external_parameters
   1387             .candidate_digest
   1388             != format!("{CANDIDATE_DIGEST_DOMAIN}{candidate_digest}")
   1389         || observed != expected
   1390         || provenance.subject.len() != expected.len()
   1391     {
   1392         return Err(ReleaseArtifactError::GenerationFailure);
   1393     }
   1394     Ok(())
   1395 }
   1396 
   1397 fn artifact_ecosystem(path: &str) -> &'static str {
   1398     if path == "oci-image.tar.gz" || path == "nixos-module.nix" {
   1399         "nix"
   1400     } else if path.ends_with("-source.tar") {
   1401         "git"
   1402     } else if path == "binary.tar.gz" {
   1403         "native"
   1404     } else {
   1405         "release"
   1406     }
   1407 }
   1408 
   1409 struct ProvenanceInput<'a> {
   1410     candidate_digest: &'a str,
   1411     service: &'a str,
   1412     target: &'a str,
   1413     source_date_epoch: u32,
   1414     service_repository: &'a str,
   1415     service_revision: &'a str,
   1416     lib_revision: &'a str,
   1417     source_lock_sha256: &'a str,
   1418     manifest_sha256: &'a str,
   1419 }
   1420 
   1421 fn build_provenance(input: ProvenanceInput<'_>, artifacts: &[ArtifactRecord]) -> InTotoStatement {
   1422     let ProvenanceInput {
   1423         candidate_digest,
   1424         service,
   1425         target,
   1426         source_date_epoch,
   1427         service_repository,
   1428         service_revision,
   1429         lib_revision,
   1430         source_lock_sha256,
   1431         manifest_sha256,
   1432     } = input;
   1433     let mut subject = artifacts
   1434         .iter()
   1435         .map(|artifact| InTotoSubject {
   1436             name: artifact.path.clone(),
   1437             digest: BTreeMap::from([("sha256", artifact.sha256.clone())]),
   1438         })
   1439         .collect::<Vec<_>>();
   1440     subject.sort_by(|left, right| left.name.cmp(&right.name));
   1441     let mut resolved_dependencies = vec![
   1442         SlsaResolvedDependency {
   1443             uri: format!("git+{service_repository}@{service_revision}"),
   1444             digest: BTreeMap::from([("gitCommit", service_revision.to_owned())]),
   1445         },
   1446         SlsaResolvedDependency {
   1447             uri: format!("git+{LIB_REPOSITORY}@{lib_revision}"),
   1448             digest: BTreeMap::from([("gitCommit", lib_revision.to_owned())]),
   1449         },
   1450         SlsaResolvedDependency {
   1451             uri: format!("file:{LOCK_FILENAME}"),
   1452             digest: BTreeMap::from([("sha256", source_lock_sha256.to_owned())]),
   1453         },
   1454         SlsaResolvedDependency {
   1455             uri: "file:artifact-manifest.v2.json".to_owned(),
   1456             digest: BTreeMap::from([("sha256", manifest_sha256.to_owned())]),
   1457         },
   1458     ];
   1459     resolved_dependencies.sort_by(|left, right| left.uri.cmp(&right.uri));
   1460     let invocation_id = sha256_bytes(
   1461         format!(
   1462             "radroots.service.slsa.invocation.v1\0{candidate_digest}\0{service}\0{target}\0{manifest_sha256}"
   1463         )
   1464         .as_bytes(),
   1465     );
   1466     InTotoStatement {
   1467         statement_type: "https://in-toto.io/Statement/v1",
   1468         subject,
   1469         predicate_type: "https://slsa.dev/provenance/v1",
   1470         predicate: SlsaPredicate {
   1471             build_definition: SlsaBuildDefinition {
   1472                 build_type: "https://radroots.dev/contracts/service-release-artifacts/v2",
   1473                 external_parameters: SlsaExternalParameters {
   1474                     candidate_digest: format!("{CANDIDATE_DIGEST_DOMAIN}{candidate_digest}"),
   1475                     service: service.to_owned(),
   1476                     target: target.to_owned(),
   1477                     source_date_epoch,
   1478                 },
   1479                 internal_parameters: BTreeMap::new(),
   1480                 resolved_dependencies,
   1481             },
   1482             run_details: SlsaRunDetails {
   1483                 builder: SlsaBuilder {
   1484                     id: "https://radroots.dev/builders/service-release-artifacts/v2",
   1485                 },
   1486                 metadata: SlsaRunMetadata { invocation_id },
   1487             },
   1488         },
   1489     }
   1490 }
   1491 
   1492 fn scanner_ruleset_sha256() -> String {
   1493     let mut bytes = b"radroots.service.artifact-scan.rules.v1\0".to_vec();
   1494     for pattern in SECRET_PATTERNS {
   1495         bytes.extend_from_slice(pattern);
   1496         bytes.push(0);
   1497     }
   1498     sha256_bytes(&bytes)
   1499 }
   1500 
   1501 fn scan_artifact_inventory(
   1502     root: &Path,
   1503     artifacts: &[ArtifactRecord],
   1504 ) -> Result<(u64, u64), ReleaseArtifactError> {
   1505     let mut nested_members = 0_u64;
   1506     let mut expanded_bytes = 0_u64;
   1507     for artifact in artifacts {
   1508         let path = root.join(&artifact.path);
   1509         expanded_bytes = expanded_bytes
   1510             .checked_add(scan_regular_file(&path, artifact.byte_length)?)
   1511             .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1512         if artifact.path == "service-source.tar" || artifact.path == "lib-source.tar" {
   1513             let (members, bytes) = scan_tar_members(&path, false)?;
   1514             nested_members = nested_members
   1515                 .checked_add(members)
   1516                 .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1517             expanded_bytes = expanded_bytes
   1518                 .checked_add(bytes)
   1519                 .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1520         } else if artifact.path == "binary.tar.gz" {
   1521             let (members, bytes) = scan_tar_gzip_members(&path)?;
   1522             nested_members = nested_members
   1523                 .checked_add(members)
   1524                 .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1525             expanded_bytes = expanded_bytes
   1526                 .checked_add(bytes)
   1527                 .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1528         } else if artifact.path == "oci-image.tar.gz" {
   1529             let limits = TarGzipLimits {
   1530                 max_compressed_bytes: MAX_OCI_BYTES,
   1531                 max_expanded_bytes: MAX_ARCHIVE_EXPANDED_BYTES,
   1532                 max_members: 65_536,
   1533                 max_member_bytes: MAX_ARCHIVE_EXPANDED_BYTES,
   1534                 max_payload_bytes: MAX_ARCHIVE_EXPANDED_BYTES,
   1535                 max_depth: 64,
   1536                 max_path_bytes: MAX_ARCHIVE_PATH_BYTES,
   1537             };
   1538             let materialized =
   1539                 safe_artifact_io::materialize_tar_gzip_path(path.as_path(), root, limits)
   1540                     .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1541             for file in materialized.snapshot().files() {
   1542                 let relative = file
   1543                     .relative_path()
   1544                     .to_str()
   1545                     .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1546                 validate_scanned_path(relative)?;
   1547                 let evidence = materialized
   1548                     .snapshot()
   1549                     .hash(file, MAX_ARCHIVE_EXPANDED_BYTES)
   1550                     .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1551                 expanded_bytes = expanded_bytes
   1552                     .checked_add(scan_regular_file(
   1553                         &materialized.root().join(file.relative_path()),
   1554                         evidence.byte_length,
   1555                     )?)
   1556                     .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1557                 nested_members = nested_members
   1558                     .checked_add(1)
   1559                     .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1560                 if relative.ends_with("/layer.tar") {
   1561                     let (members, bytes) =
   1562                         scan_tar_members(&materialized.root().join(file.relative_path()), true)?;
   1563                     nested_members = nested_members
   1564                         .checked_add(members)
   1565                         .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1566                     expanded_bytes = expanded_bytes
   1567                         .checked_add(bytes)
   1568                         .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1569                 }
   1570             }
   1571             materialized
   1572                 .revalidate()
   1573                 .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1574         }
   1575     }
   1576     Ok((nested_members, expanded_bytes))
   1577 }
   1578 
   1579 fn scan_tar_gzip_members(path: &Path) -> Result<(u64, u64), ReleaseArtifactError> {
   1580     let file = fs::File::open(path).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1581     let decoder = flate2::read::GzDecoder::new(file);
   1582     let mut archive = tar::Archive::new(decoder);
   1583     let mut members = 0_u64;
   1584     let mut bytes = 0_u64;
   1585     for entry in archive
   1586         .entries()
   1587         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?
   1588     {
   1589         let mut entry = entry.map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1590         members = members
   1591             .checked_add(1)
   1592             .filter(|count| *count <= 4)
   1593             .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1594         let path = entry
   1595             .path()
   1596             .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1597         let path = path
   1598             .to_str()
   1599             .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1600         validate_scanned_path(path)?;
   1601         if entry.header().entry_type().is_file() {
   1602             let size = entry.size();
   1603             if size > MAX_BINARY_BYTES {
   1604                 return Err(ReleaseArtifactError::InvalidInputArtifact);
   1605             }
   1606             bytes = bytes
   1607                 .checked_add(scan_reader(&mut entry, size)?)
   1608                 .filter(|count| *count <= MAX_BINARY_BYTES)
   1609                 .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1610         } else if !entry.header().entry_type().is_dir() {
   1611             return Err(ReleaseArtifactError::InvalidInputArtifact);
   1612         }
   1613     }
   1614     if members == 0 {
   1615         Err(ReleaseArtifactError::InvalidInputArtifact)
   1616     } else {
   1617         Ok((members, bytes))
   1618     }
   1619 }
   1620 
   1621 fn scan_tar_members(path: &Path, links_allowed: bool) -> Result<(u64, u64), ReleaseArtifactError> {
   1622     let file = fs::File::open(path).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1623     let mut archive = tar::Archive::new(file);
   1624     let mut members = 0_u64;
   1625     let mut bytes = 0_u64;
   1626     for entry in archive
   1627         .entries()
   1628         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?
   1629     {
   1630         let mut entry = entry.map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1631         let path = entry
   1632             .path()
   1633             .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1634         let path = path
   1635             .to_str()
   1636             .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1637         validate_scanned_path(path)?;
   1638         members = members
   1639             .checked_add(1)
   1640             .filter(|count| *count <= MAX_SOURCE_ARCHIVE_MEMBERS)
   1641             .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1642         if entry.header().entry_type().is_file() {
   1643             let size = entry.size();
   1644             if !links_allowed && size > MAX_SOURCE_ARCHIVE_MEMBER_BYTES {
   1645                 return Err(ReleaseArtifactError::InvalidInputArtifact);
   1646             }
   1647             let scanned = scan_reader(&mut entry, size)?;
   1648             bytes = bytes
   1649                 .checked_add(scanned)
   1650                 .filter(|count| *count <= MAX_ARCHIVE_EXPANDED_BYTES)
   1651                 .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1652         } else if !links_allowed
   1653             || !(entry.header().entry_type().is_dir()
   1654                 || entry.header().entry_type().is_symlink()
   1655                 || entry.header().entry_type().is_hard_link())
   1656         {
   1657             return Err(ReleaseArtifactError::InvalidInputArtifact);
   1658         }
   1659     }
   1660     if members == 0 {
   1661         Err(ReleaseArtifactError::InvalidInputArtifact)
   1662     } else {
   1663         Ok((members, bytes))
   1664     }
   1665 }
   1666 
   1667 fn scan_regular_file(path: &Path, expected_length: u64) -> Result<u64, ReleaseArtifactError> {
   1668     let mut file = fs::File::open(path).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1669     scan_reader(&mut file, expected_length)
   1670 }
   1671 
   1672 fn scan_reader(
   1673     reader: &mut impl std::io::Read,
   1674     expected_length: u64,
   1675 ) -> Result<u64, ReleaseArtifactError> {
   1676     let mut scanner = SecretScanner::default();
   1677     let mut total = 0_u64;
   1678     let mut buffer = [0_u8; 64 * 1024];
   1679     loop {
   1680         let read = reader
   1681             .read(&mut buffer)
   1682             .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1683         if read == 0 {
   1684             break;
   1685         }
   1686         total = total
   1687             .checked_add(read as u64)
   1688             .filter(|value| *value <= expected_length)
   1689             .ok_or(ReleaseArtifactError::InvalidInputArtifact)?;
   1690         scanner.scan(&buffer[..read])?;
   1691     }
   1692     if total == expected_length {
   1693         Ok(total)
   1694     } else {
   1695         Err(ReleaseArtifactError::InvalidInputArtifact)
   1696     }
   1697 }
   1698 
   1699 fn validate_scanned_path(path: &str) -> Result<(), ReleaseArtifactError> {
   1700     let sensitive = Path::new(path).components().any(|component| {
   1701         let Component::Normal(value) = component else {
   1702             return true;
   1703         };
   1704         let value = value.to_string_lossy().to_ascii_lowercase();
   1705         matches!(
   1706             value.as_str(),
   1707             ".git"
   1708                 | ".ssh"
   1709                 | ".aws"
   1710                 | ".env"
   1711                 | "credentials"
   1712                 | "secrets"
   1713                 | "id_rsa"
   1714                 | "id_ed25519"
   1715                 | "private_key"
   1716         )
   1717     });
   1718     if sensitive || path.len() > MAX_ARCHIVE_PATH_BYTES {
   1719         Err(ReleaseArtifactError::ProtectedMaterialDetected)
   1720     } else {
   1721         Ok(())
   1722     }
   1723 }
   1724 
   1725 fn validate_metadata_package(
   1726     package: &CargoPackage,
   1727     workspace_member: bool,
   1728 ) -> Result<(), ReleaseArtifactError> {
   1729     for value in [&package.name, &package.version, &package.id] {
   1730         if value.is_empty() || value.len() > MAX_TEXT_FIELD_BYTES || value.contains(['\n', '\r']) {
   1731             return Err(ReleaseArtifactError::InvalidPackageInventory);
   1732         }
   1733     }
   1734     if package
   1735         .license
   1736         .as_ref()
   1737         .is_some_and(|value| !valid_metadata_text(value))
   1738         || package
   1739             .source
   1740             .as_ref()
   1741             .is_some_and(|value| !valid_public_source(value))
   1742         || (!workspace_member && (package.source.is_none() || package.license.is_none()))
   1743         || package
   1744             .checksum
   1745             .as_ref()
   1746             .is_some_and(|value| !valid_lower_hex(value, 64))
   1747     {
   1748         return Err(ReleaseArtifactError::InvalidPackageInventory);
   1749     }
   1750     Ok(())
   1751 }
   1752 
   1753 fn sbom_component(
   1754     package: &CargoPackage,
   1755     component_type: &'static str,
   1756 ) -> Result<SbomComponent, ReleaseArtifactError> {
   1757     let license = package
   1758         .license
   1759         .clone()
   1760         .unwrap_or_else(|| "NOASSERTION".to_owned());
   1761     let hashes = package
   1762         .checksum
   1763         .iter()
   1764         .map(|checksum| DigestValue {
   1765             alg: "SHA-256",
   1766             content: checksum.clone(),
   1767         })
   1768         .collect();
   1769     Ok(SbomComponent {
   1770         component_type,
   1771         bom_ref: package_reference(package),
   1772         name: package.name.clone(),
   1773         version: package.version.clone(),
   1774         purl: Some(format!("pkg:cargo/{}@{}", package.name, package.version)),
   1775         licenses: vec![LicenseChoice {
   1776             expression: license,
   1777         }],
   1778         hashes,
   1779         properties: vec![SbomProperty {
   1780             name: "radroots:ecosystem".to_owned(),
   1781             value: "cargo".to_owned(),
   1782         }],
   1783     })
   1784 }
   1785 
   1786 fn package_reference(package: &CargoPackage) -> String {
   1787     let source = package.source.as_deref().unwrap_or("workspace");
   1788     let source_digest = sha256_bytes(source.as_bytes());
   1789     format!(
   1790         "cargo:{}@{}#{}",
   1791         package.name,
   1792         package.version,
   1793         &source_digest[..16]
   1794     )
   1795 }
   1796 
   1797 fn validate_exact_input_root(
   1798     path: &Path,
   1799 ) -> Result<(PathBuf, safe_artifact_io::TraversalSnapshot), ReleaseArtifactError> {
   1800     let root = validate_absolute_directory(path, ReleaseArtifactError::InvalidInputRoot)?;
   1801     let snapshot = flat_directory_snapshot(&root, ReleaseArtifactError::InvalidInputRoot)?;
   1802     let inventory = snapshot_inventory(&snapshot, ReleaseArtifactError::InvalidInputRoot)?;
   1803     if inventory == INPUT_NAMES.into_iter().map(str::to_owned).collect() {
   1804         Ok((root, snapshot))
   1805     } else {
   1806         Err(ReleaseArtifactError::InvalidInputRoot)
   1807     }
   1808 }
   1809 
   1810 fn validate_output_parent(
   1811     output: &Path,
   1812     service_root: &Path,
   1813     input_root: &Path,
   1814 ) -> Result<(PathBuf, PathBuf), ReleaseArtifactError> {
   1815     if !output.is_absolute()
   1816         || output
   1817             .file_name()
   1818             .and_then(OsStr::to_str)
   1819             .is_none_or(|name| !valid_output_component(name))
   1820     {
   1821         return Err(ReleaseArtifactError::InvalidOutputRoot);
   1822     }
   1823     let parent = output
   1824         .parent()
   1825         .ok_or(ReleaseArtifactError::InvalidOutputRoot)?;
   1826     let parent = validate_absolute_directory(parent, ReleaseArtifactError::InvalidOutputRoot)?;
   1827     let output = parent.join(
   1828         output
   1829             .file_name()
   1830             .ok_or(ReleaseArtifactError::InvalidOutputRoot)?,
   1831     );
   1832     if output.starts_with(service_root)
   1833         || output.starts_with(input_root)
   1834         || service_root.starts_with(&output)
   1835         || input_root.starts_with(&output)
   1836     {
   1837         return Err(ReleaseArtifactError::InvalidOutputRoot);
   1838     }
   1839     if let Ok(metadata) = fs::symlink_metadata(&output)
   1840         && (metadata.file_type().is_symlink() || !metadata.is_dir())
   1841     {
   1842         return Err(ReleaseArtifactError::InvalidOutputRoot);
   1843     }
   1844     Ok((parent, output))
   1845 }
   1846 
   1847 fn validate_git_root(path: &Path) -> Result<PathBuf, ReleaseArtifactError> {
   1848     let root = validate_absolute_directory(path, ReleaseArtifactError::InvalidServiceRoot)?;
   1849     let top = git_stdout(
   1850         &root,
   1851         ["rev-parse", "--show-toplevel"],
   1852         MAX_GIT_OUTPUT_BYTES,
   1853     )
   1854     .map_err(|_| ReleaseArtifactError::InvalidServiceRoot)?;
   1855     let top = std::str::from_utf8(&top)
   1856         .map_err(|_| ReleaseArtifactError::InvalidServiceRoot)?
   1857         .trim();
   1858     let top = fs::canonicalize(top).map_err(|_| ReleaseArtifactError::InvalidServiceRoot)?;
   1859     if top == root {
   1860         Ok(root)
   1861     } else {
   1862         Err(ReleaseArtifactError::InvalidServiceRoot)
   1863     }
   1864 }
   1865 
   1866 fn validate_absolute_directory(
   1867     path: &Path,
   1868     error: ReleaseArtifactError,
   1869 ) -> Result<PathBuf, ReleaseArtifactError> {
   1870     if !path.is_absolute() {
   1871         return Err(error);
   1872     }
   1873     let metadata = fs::symlink_metadata(path).map_err(|_| error)?;
   1874     if metadata.file_type().is_symlink() || !metadata.is_dir() {
   1875         return Err(error);
   1876     }
   1877     fs::canonicalize(path).map_err(|_| error)
   1878 }
   1879 
   1880 fn validate_clean_git(root: &Path) -> Result<(), ReleaseArtifactError> {
   1881     let status = git_stdout(
   1882         root,
   1883         ["status", "--porcelain=v1", "-z", "--untracked-files=all"],
   1884         MAX_GIT_OUTPUT_BYTES,
   1885     )
   1886     .map_err(|_| ReleaseArtifactError::DirtyServiceSource)?;
   1887     if status.is_empty() {
   1888         Ok(())
   1889     } else {
   1890         Err(ReleaseArtifactError::DirtyServiceSource)
   1891     }
   1892 }
   1893 
   1894 fn git_head(root: &Path) -> Result<String, ReleaseArtifactError> {
   1895     let bytes = git_stdout(root, ["rev-parse", "HEAD"], 128)
   1896         .map_err(|_| ReleaseArtifactError::InvalidServiceRoot)?;
   1897     let value = std::str::from_utf8(&bytes)
   1898         .map_err(|_| ReleaseArtifactError::InvalidServiceRoot)?
   1899         .trim();
   1900     if valid_lower_hex(value, 40) {
   1901         Ok(value.to_owned())
   1902     } else {
   1903         Err(ReleaseArtifactError::InvalidServiceRoot)
   1904     }
   1905 }
   1906 
   1907 fn git_remote(root: &Path) -> Result<String, ReleaseArtifactError> {
   1908     let bytes = git_stdout(root, ["remote", "get-url", "origin"], MAX_GIT_OUTPUT_BYTES)
   1909         .map_err(|_| ReleaseArtifactError::InvalidServiceRoot)?;
   1910     let value = std::str::from_utf8(&bytes)
   1911         .map_err(|_| ReleaseArtifactError::InvalidServiceRoot)?
   1912         .trim();
   1913     if value.len() > MAX_TEXT_FIELD_BYTES
   1914         || !(value.starts_with("https://github.com/") || value.starts_with("ssh://git@github.com/"))
   1915         || value.contains(['\n', '\r'])
   1916     {
   1917         return Err(ReleaseArtifactError::InvalidServiceRoot);
   1918     }
   1919     Ok(value.to_owned())
   1920 }
   1921 
   1922 #[cfg(test)]
   1923 fn create_binary_archive(
   1924     source: &Path,
   1925     output: &Path,
   1926     binary_name: &str,
   1927     source_date_epoch: u32,
   1928 ) -> Result<FileEvidence, ReleaseArtifactError> {
   1929     let (_stable, stable_source) = binary_staging(output)?;
   1930     let source_evidence =
   1931         safe_artifact_io::copy_regular_to_new_path(source, &stable_source, MAX_BINARY_BYTES)
   1932             .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1933     if source_evidence.byte_length == 0 {
   1934         return Err(ReleaseArtifactError::InvalidInputArtifact);
   1935     }
   1936     write_binary_archive(
   1937         &stable_source,
   1938         output,
   1939         binary_name,
   1940         source_date_epoch,
   1941         source_evidence,
   1942     )
   1943 }
   1944 
   1945 fn create_binary_archive_from_snapshot(
   1946     snapshot: &safe_artifact_io::TraversalSnapshot,
   1947     source_name: &str,
   1948     output: &Path,
   1949     binary_name: &str,
   1950     target: &str,
   1951     source_date_epoch: u32,
   1952 ) -> Result<FileEvidence, ReleaseArtifactError> {
   1953     let source = snapshot_file(snapshot, source_name)?;
   1954     let (_stable, stable_source) = binary_staging(output)?;
   1955     let source_evidence = snapshot
   1956         .copy_to_new_path(source, &stable_source, MAX_BINARY_BYTES)
   1957         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   1958     if source_evidence.byte_length == 0 {
   1959         return Err(ReleaseArtifactError::InvalidInputArtifact);
   1960     }
   1961     artifact_admission::admit_binary(&stable_source, target, true).map_err(|_error| {
   1962         #[cfg(test)]
   1963         eprintln!("binary admission category: {_error}");
   1964         ReleaseArtifactError::InvalidInputArtifact
   1965     })?;
   1966     write_binary_archive(
   1967         &stable_source,
   1968         output,
   1969         binary_name,
   1970         source_date_epoch,
   1971         source_evidence,
   1972     )
   1973 }
   1974 
   1975 fn binary_staging(output: &Path) -> Result<(TempDir, PathBuf), ReleaseArtifactError> {
   1976     let parent = output
   1977         .parent()
   1978         .ok_or(ReleaseArtifactError::GenerationFailure)?;
   1979     let stable = tempfile::Builder::new()
   1980         .prefix(".radroots-binary-input-")
   1981         .tempdir_in(parent)
   1982         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1983     let stable_root = stable
   1984         .path()
   1985         .canonicalize()
   1986         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1987     Ok((stable, stable_root.join("admitted-binary")))
   1988 }
   1989 
   1990 fn write_binary_archive(
   1991     stable_source: &Path,
   1992     output: &Path,
   1993     binary_name: &str,
   1994     source_date_epoch: u32,
   1995     source_evidence: safe_artifact_io::FileEvidence,
   1996 ) -> Result<FileEvidence, ReleaseArtifactError> {
   1997     let mut source_file =
   1998         fs::File::open(stable_source).map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   1999     let output_file = fs::OpenOptions::new()
   2000         .create_new(true)
   2001         .write(true)
   2002         .open(output)
   2003         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2004     let encoder = GzBuilder::new()
   2005         .mtime(source_date_epoch)
   2006         .operating_system(255)
   2007         .write(output_file, Compression::best());
   2008     let mut archive = TarBuilder::new(encoder);
   2009     let mut header = TarHeader::new_gnu();
   2010     header.set_size(source_evidence.byte_length);
   2011     header.set_mode(0o755);
   2012     header.set_uid(0);
   2013     header.set_gid(0);
   2014     header.set_mtime(u64::from(source_date_epoch));
   2015     header.set_cksum();
   2016     archive
   2017         .append_data(&mut header, format!("bin/{binary_name}"), &mut source_file)
   2018         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2019     let encoder = archive
   2020         .into_inner()
   2021         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2022     let output_file = encoder
   2023         .finish()
   2024         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2025     output_file
   2026         .sync_all()
   2027         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2028     set_file_mode(output)?;
   2029     admit_binary_archive(output)?;
   2030     hash_regular(output, MAX_BINARY_BYTES + MAX_TEXT_INPUT_BYTES)
   2031 }
   2032 
   2033 fn snapshot_file<'a>(
   2034     snapshot: &'a safe_artifact_io::TraversalSnapshot,
   2035     name: &str,
   2036 ) -> Result<&'a safe_artifact_io::TraversedFile, ReleaseArtifactError> {
   2037     snapshot
   2038         .files()
   2039         .iter()
   2040         .find(|file| file.relative_path() == Path::new(name))
   2041         .ok_or(ReleaseArtifactError::InvalidInputRoot)
   2042 }
   2043 
   2044 fn copy_snapshot_file(
   2045     snapshot: &safe_artifact_io::TraversalSnapshot,
   2046     source_name: &str,
   2047     output: &Path,
   2048     maximum: u64,
   2049 ) -> Result<FileEvidence, ReleaseArtifactError> {
   2050     let evidence = snapshot
   2051         .copy_to_new_path(snapshot_file(snapshot, source_name)?, output, maximum)
   2052         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2053     set_file_mode(output)?;
   2054     Ok(FileEvidence {
   2055         byte_length: evidence.byte_length,
   2056         sha256: evidence.sha256,
   2057     })
   2058 }
   2059 
   2060 fn copy_bounded(
   2061     source: &Path,
   2062     output: &Path,
   2063     maximum: u64,
   2064 ) -> Result<FileEvidence, ReleaseArtifactError> {
   2065     let evidence = safe_artifact_io::copy_regular_to_new_path(source, output, maximum)
   2066         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2067     set_file_mode(output)?;
   2068     Ok(FileEvidence {
   2069         byte_length: evidence.byte_length,
   2070         sha256: evidence.sha256,
   2071     })
   2072 }
   2073 
   2074 fn admit_binary_archive(path: &Path) -> Result<(), ReleaseArtifactError> {
   2075     let limits = TarGzipLimits {
   2076         max_compressed_bytes: MAX_BINARY_BYTES + MAX_TEXT_INPUT_BYTES,
   2077         max_expanded_bytes: MAX_BINARY_BYTES + MAX_TEXT_INPUT_BYTES,
   2078         max_members: 4,
   2079         max_member_bytes: MAX_BINARY_BYTES,
   2080         max_payload_bytes: MAX_BINARY_BYTES,
   2081         max_depth: 4,
   2082         max_path_bytes: MAX_ARCHIVE_PATH_BYTES,
   2083     };
   2084     safe_artifact_io::admit_tar_gzip_path(path, limits)
   2085         .map(|_| ())
   2086         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)
   2087 }
   2088 
   2089 #[derive(Default)]
   2090 struct SecretScanner {
   2091     tail: Vec<u8>,
   2092 }
   2093 
   2094 impl SecretScanner {
   2095     fn scan(&mut self, bytes: &[u8]) -> Result<(), ReleaseArtifactError> {
   2096         let mut combined = Vec::with_capacity(self.tail.len() + bytes.len());
   2097         combined.extend_from_slice(&self.tail);
   2098         combined.extend_from_slice(bytes);
   2099         if contains_secret(&combined) {
   2100             return Err(ReleaseArtifactError::ProtectedMaterialDetected);
   2101         }
   2102         let retained = SECRET_SCAN_OVERLAP_BYTES.min(combined.len());
   2103         self.tail.clear();
   2104         self.tail
   2105             .extend_from_slice(&combined[combined.len() - retained..]);
   2106         Ok(())
   2107     }
   2108 }
   2109 
   2110 fn contains_secret(bytes: &[u8]) -> bool {
   2111     let pem = [
   2112         (
   2113             b"-----BEGIN PRIVATE KEY-----".as_slice(),
   2114             b"-----END PRIVATE KEY-----".as_slice(),
   2115         ),
   2116         (
   2117             b"-----BEGIN RSA PRIVATE KEY-----".as_slice(),
   2118             b"-----END RSA PRIVATE KEY-----".as_slice(),
   2119         ),
   2120         (
   2121             b"-----BEGIN EC PRIVATE KEY-----".as_slice(),
   2122             b"-----END EC PRIVATE KEY-----".as_slice(),
   2123         ),
   2124         (
   2125             b"-----BEGIN OPENSSH PRIVATE KEY-----".as_slice(),
   2126             b"-----END OPENSSH PRIVATE KEY-----".as_slice(),
   2127         ),
   2128     ]
   2129     .iter()
   2130     .any(|(begin, end)| contains_pem_secret(bytes, begin, end));
   2131     let github_pat = contains_prefixed_secret(bytes, b"github_pat_", 50, 128, is_token_byte);
   2132     let ghp = contains_prefixed_secret(bytes, b"ghp_", 36, 36, |byte| byte.is_ascii_alphanumeric());
   2133     let slack = contains_prefixed_secret(bytes, b"xoxb-", 20, 128, |byte| {
   2134         byte.is_ascii_digit() || byte == b'-'
   2135     });
   2136     pem || github_pat || ghp || slack
   2137 }
   2138 
   2139 fn contains_pem_secret(bytes: &[u8], begin: &[u8], end: &[u8]) -> bool {
   2140     let Some(begin_at) = bytes
   2141         .windows(begin.len())
   2142         .position(|window| window == begin)
   2143     else {
   2144         return false;
   2145     };
   2146     let body = &bytes[begin_at + begin.len()..];
   2147     if !body.starts_with(b"\n") && !body.starts_with(b"\r\n") {
   2148         return false;
   2149     }
   2150     let Some(end_at) = body.windows(end.len()).position(|window| window == end) else {
   2151         return false;
   2152     };
   2153     let encoded = &body[..end_at];
   2154     encoded.iter().all(|byte| {
   2155         byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/' | b'=' | b'\n' | b'\r')
   2156     }) && encoded
   2157         .iter()
   2158         .filter(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/' | b'='))
   2159         .count()
   2160         >= 32
   2161 }
   2162 
   2163 fn contains_prefixed_secret(
   2164     bytes: &[u8],
   2165     prefix: &[u8],
   2166     minimum_suffix: usize,
   2167     maximum_suffix: usize,
   2168     valid_suffix: impl Fn(u8) -> bool,
   2169 ) -> bool {
   2170     bytes
   2171         .windows(prefix.len())
   2172         .enumerate()
   2173         .any(|(index, window)| {
   2174             if window != prefix
   2175                 || index
   2176                     .checked_sub(1)
   2177                     .is_some_and(|prior| is_token_byte(bytes[prior]))
   2178             {
   2179                 return false;
   2180             }
   2181             let start = index + prefix.len();
   2182             let suffix = bytes[start..]
   2183                 .iter()
   2184                 .take_while(|byte| valid_suffix(**byte))
   2185                 .count();
   2186             (minimum_suffix..=maximum_suffix).contains(&suffix)
   2187                 && bytes
   2188                     .get(start + suffix)
   2189                     .is_none_or(|byte| !is_token_byte(*byte))
   2190         })
   2191 }
   2192 
   2193 fn is_token_byte(byte: u8) -> bool {
   2194     byte.is_ascii_alphanumeric() || byte == b'_'
   2195 }
   2196 
   2197 fn scan_bytes(bytes: &[u8]) -> Result<(), ReleaseArtifactError> {
   2198     let mut scanner = SecretScanner::default();
   2199     scanner.scan(bytes)
   2200 }
   2201 
   2202 fn validate_text_artifact(path: &Path, name: &str) -> Result<(), ReleaseArtifactError> {
   2203     let bytes = read_bounded_regular(
   2204         path,
   2205         MAX_TEXT_INPUT_BYTES,
   2206         ReleaseArtifactError::InvalidInputArtifact,
   2207     )?;
   2208     std::str::from_utf8(&bytes).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2209     if bytes.contains(&0) {
   2210         return Err(ReleaseArtifactError::InvalidInputArtifact);
   2211     }
   2212     scan_bytes(&bytes)?;
   2213     if name == "config.schema.json" {
   2214         serde_json::from_slice::<serde_json::Value>(&bytes)
   2215             .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2216     } else if name == "config.example.toml" {
   2217         toml::from_str::<toml::Value>(
   2218             std::str::from_utf8(&bytes).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?,
   2219         )
   2220         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2221     }
   2222     Ok(())
   2223 }
   2224 
   2225 fn write_json<T: Serialize>(path: &Path, value: &T) -> Result<(), ReleaseArtifactError> {
   2226     let mut bytes =
   2227         serde_json::to_vec(value).map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2228     bytes.push(b'\n');
   2229     write_generated(path, &bytes)
   2230 }
   2231 
   2232 fn write_generated(path: &Path, bytes: &[u8]) -> Result<(), ReleaseArtifactError> {
   2233     if bytes.is_empty() || bytes.len() as u64 > MAX_GENERATED_DOCUMENT_BYTES {
   2234         return Err(ReleaseArtifactError::GenerationFailure);
   2235     }
   2236     scan_bytes(bytes)?;
   2237     let mut file = fs::OpenOptions::new()
   2238         .create_new(true)
   2239         .write(true)
   2240         .open(path)
   2241         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2242     file.write_all(bytes)
   2243         .and_then(|()| file.sync_all())
   2244         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2245     set_file_mode(path)
   2246 }
   2247 
   2248 fn write_checksums(root: &Path) -> Result<(), ReleaseArtifactError> {
   2249     let mut records = inventory_records(root)?;
   2250     records.sort();
   2251     let mut checksums = String::new();
   2252     use fmt::Write as _;
   2253     for record in records {
   2254         writeln!(checksums, "{}  {}", record.sha256, record.path)
   2255             .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2256     }
   2257     write_generated(&root.join("SHA256SUMS"), checksums.as_bytes())
   2258 }
   2259 
   2260 fn inventory_records(root: &Path) -> Result<Vec<ArtifactRecord>, ReleaseArtifactError> {
   2261     inventory_records_impl(root, || {})
   2262 }
   2263 
   2264 fn inventory_records_impl<F>(
   2265     root: &Path,
   2266     after_snapshot: F,
   2267 ) -> Result<Vec<ArtifactRecord>, ReleaseArtifactError>
   2268 where
   2269     F: FnOnce(),
   2270 {
   2271     let snapshot = flat_directory_snapshot(root, ReleaseArtifactError::GenerationFailure)?;
   2272     let names = snapshot_inventory(&snapshot, ReleaseArtifactError::GenerationFailure)?;
   2273     after_snapshot();
   2274     if snapshot.root_permission_mode() != DIRECTORY_MODE {
   2275         return Err(ReleaseArtifactError::GenerationFailure);
   2276     }
   2277     let mut records = Vec::with_capacity(names.len());
   2278     for name in names {
   2279         let maximum = output_maximum(&name)?;
   2280         let file = snapshot
   2281             .files()
   2282             .iter()
   2283             .find(|file| file.relative_path() == Path::new(&name))
   2284             .ok_or(ReleaseArtifactError::GenerationFailure)?;
   2285         if file.permission_mode() != FILE_MODE {
   2286             return Err(ReleaseArtifactError::GenerationFailure);
   2287         }
   2288         let evidence = snapshot
   2289             .hash(file, maximum)
   2290             .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2291         records.push(artifact_record(
   2292             &name,
   2293             &FileEvidence {
   2294                 byte_length: evidence.byte_length,
   2295                 sha256: evidence.sha256,
   2296             },
   2297         ));
   2298     }
   2299     snapshot
   2300         .revalidate()
   2301         .map_err(|_| ReleaseArtifactError::GenerationFailure)?;
   2302     Ok(records)
   2303 }
   2304 
   2305 fn artifact_record(path: &str, evidence: &FileEvidence) -> ArtifactRecord {
   2306     ArtifactRecord {
   2307         path: path.to_owned(),
   2308         byte_length: evidence.byte_length,
   2309         sha256: evidence.sha256.clone(),
   2310     }
   2311 }
   2312 
   2313 fn artifact_record_from_exact_tree(
   2314     path: &str,
   2315     evidence: &exact_tree_archive::ExactTreeArchiveEvidence,
   2316 ) -> ArtifactRecord {
   2317     ArtifactRecord {
   2318         path: path.to_owned(),
   2319         byte_length: evidence.byte_length,
   2320         sha256: evidence.sha256.clone(),
   2321     }
   2322 }
   2323 
   2324 fn output_maximum(name: &str) -> Result<u64, ReleaseArtifactError> {
   2325     match name {
   2326         "binary.tar.gz" => Ok(MAX_BINARY_BYTES + MAX_TEXT_INPUT_BYTES),
   2327         "oci-image.tar.gz" => Ok(MAX_OCI_BYTES),
   2328         "service-source.tar" | "lib-source.tar" => Ok(MAX_SOURCE_ARCHIVE_BYTES),
   2329         "LICENSE-APACHE"
   2330         | "LICENSE-MIT"
   2331         | "config.example.toml"
   2332         | "config.schema.json"
   2333         | "nixos-module.nix"
   2334         | "radroots.service.source_lock.v4.toml"
   2335         | "systemd.service" => Ok(MAX_TEXT_INPUT_BYTES),
   2336         "SHA256SUMS"
   2337         | "THIRD-PARTY-LICENSES.txt"
   2338         | "THIRD-PARTY-NOTICES.txt"
   2339         | "artifact-manifest.v2.json"
   2340         | "artifact-scan.v1.json"
   2341         | "oci-image.v1.json"
   2342         | "provenance.intoto.jsonl"
   2343         | "sbom.cdx.json"
   2344         | "source-archives.v3.json" => Ok(MAX_GENERATED_DOCUMENT_BYTES),
   2345         _ => Err(ReleaseArtifactError::GenerationFailure),
   2346     }
   2347 }
   2348 
   2349 fn hash_regular(path: &Path, maximum: u64) -> Result<FileEvidence, ReleaseArtifactError> {
   2350     let evidence = safe_artifact_io::hash_regular_path(path, maximum)
   2351         .map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2352     Ok(FileEvidence {
   2353         byte_length: evidence.byte_length,
   2354         sha256: evidence.sha256,
   2355     })
   2356 }
   2357 
   2358 fn read_bounded_regular(
   2359     path: &Path,
   2360     maximum: u64,
   2361     error: ReleaseArtifactError,
   2362 ) -> Result<Vec<u8>, ReleaseArtifactError> {
   2363     safe_artifact_io::read_regular_path(path, maximum).map_err(|_| error)
   2364 }
   2365 
   2366 #[cfg(test)]
   2367 fn validate_regular_input(path: &Path, maximum: u64) -> Result<fs::Metadata, ReleaseArtifactError> {
   2368     let metadata =
   2369         fs::symlink_metadata(path).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2370     if metadata.file_type().is_symlink()
   2371         || !metadata.is_file()
   2372         || metadata.len() == 0
   2373         || metadata.len() > maximum
   2374     {
   2375         Err(ReleaseArtifactError::InvalidInputArtifact)
   2376     } else {
   2377         Ok(metadata)
   2378     }
   2379 }
   2380 
   2381 #[cfg(all(test, unix))]
   2382 fn validate_unchanged_input(
   2383     path: &Path,
   2384     expected: &fs::Metadata,
   2385 ) -> Result<(), ReleaseArtifactError> {
   2386     use std::os::unix::fs::MetadataExt as _;
   2387     let current =
   2388         fs::symlink_metadata(path).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2389     if current.file_type().is_symlink()
   2390         || !current.is_file()
   2391         || current.dev() != expected.dev()
   2392         || current.ino() != expected.ino()
   2393         || current.len() != expected.len()
   2394     {
   2395         Err(ReleaseArtifactError::InvalidInputArtifact)
   2396     } else {
   2397         Ok(())
   2398     }
   2399 }
   2400 
   2401 #[cfg(all(test, not(unix)))]
   2402 fn validate_unchanged_input(
   2403     path: &Path,
   2404     expected: &fs::Metadata,
   2405 ) -> Result<(), ReleaseArtifactError> {
   2406     let current =
   2407         fs::symlink_metadata(path).map_err(|_| ReleaseArtifactError::InvalidInputArtifact)?;
   2408     if current.file_type().is_symlink() || !current.is_file() || current.len() != expected.len() {
   2409         Err(ReleaseArtifactError::InvalidInputArtifact)
   2410     } else {
   2411         Ok(())
   2412     }
   2413 }
   2414 
   2415 #[cfg(test)]
   2416 fn directory_inventory(
   2417     root: &Path,
   2418     error: ReleaseArtifactError,
   2419 ) -> Result<BTreeSet<String>, ReleaseArtifactError> {
   2420     let snapshot = flat_directory_snapshot(root, error)?;
   2421     snapshot_inventory(&snapshot, error)
   2422 }
   2423 
   2424 fn flat_directory_snapshot(
   2425     root: &Path,
   2426     error: ReleaseArtifactError,
   2427 ) -> Result<safe_artifact_io::TraversalSnapshot, ReleaseArtifactError> {
   2428     let limits = TraversalLimits {
   2429         max_entries: (OUTPUT_NAMES.len() + 1) as u64,
   2430         max_files: (OUTPUT_NAMES.len() + 1) as u64,
   2431         max_total_bytes: MAX_RELEASE_TREE_BYTES,
   2432         max_file_bytes: MAX_ARCHIVE_EXPANDED_BYTES,
   2433         max_depth: 1,
   2434         max_path_bytes: MAX_ARCHIVE_PATH_BYTES,
   2435     };
   2436     safe_artifact_io::traverse_regular_files(root, limits, &[]).map_err(|_| error)
   2437 }
   2438 
   2439 fn snapshot_inventory(
   2440     snapshot: &safe_artifact_io::TraversalSnapshot,
   2441     error: ReleaseArtifactError,
   2442 ) -> Result<BTreeSet<String>, ReleaseArtifactError> {
   2443     if snapshot.entry_count() != snapshot.files().len() as u64 {
   2444         return Err(error);
   2445     }
   2446     let mut names = BTreeSet::new();
   2447     for entry in snapshot.files() {
   2448         let path = entry.relative_path();
   2449         if path.components().count() != 1 {
   2450             return Err(error);
   2451         }
   2452         let name = path
   2453             .file_name()
   2454             .and_then(OsStr::to_str)
   2455             .ok_or(error)?
   2456             .to_owned();
   2457         if !names.insert(name) || names.len() > OUTPUT_NAMES.len() {
   2458             return Err(error);
   2459         }
   2460     }
   2461     snapshot.revalidate().map_err(|_| error)?;
   2462     Ok(names)
   2463 }
   2464 
   2465 fn validate_exact_output_inventory(root: &Path) -> Result<(), ReleaseArtifactError> {
   2466     let expected = OUTPUT_NAMES.into_iter().map(str::to_owned).collect();
   2467     let actual = inventory_records(root)?
   2468         .into_iter()
   2469         .map(|record| record.path)
   2470         .collect::<BTreeSet<_>>();
   2471     if actual != expected {
   2472         return Err(ReleaseArtifactError::GenerationFailure);
   2473     }
   2474     Ok(())
   2475 }
   2476 
   2477 fn compare_output(expected: &Path, actual: &Path) -> Result<(), ReleaseArtifactError> {
   2478     let actual = validate_absolute_directory(actual, ReleaseArtifactError::StaleOutput)?;
   2479     let expected_records =
   2480         inventory_records(expected).map_err(|_| ReleaseArtifactError::StaleOutput)?;
   2481     let actual_records =
   2482         inventory_records(&actual).map_err(|_| ReleaseArtifactError::StaleOutput)?;
   2483     if expected_records != actual_records {
   2484         return Err(ReleaseArtifactError::StaleOutput);
   2485     }
   2486     Ok(())
   2487 }
   2488 
   2489 fn validate_output_records(
   2490     actual: &Path,
   2491     expected: &[ArtifactRecord],
   2492 ) -> Result<(), ReleaseArtifactError> {
   2493     let actual = validate_absolute_directory(actual, ReleaseArtifactError::StaleOutput)?;
   2494     validate_exact_output_inventory(&actual).map_err(|_| ReleaseArtifactError::StaleOutput)?;
   2495     let actual_records =
   2496         inventory_records(&actual).map_err(|_| ReleaseArtifactError::StaleOutput)?;
   2497     if actual_records == expected {
   2498         Ok(())
   2499     } else {
   2500         Err(ReleaseArtifactError::StaleOutput)
   2501     }
   2502 }
   2503 
   2504 #[cfg(unix)]
   2505 fn set_file_mode(path: &Path) -> Result<(), ReleaseArtifactError> {
   2506     use std::os::unix::fs::PermissionsExt as _;
   2507     fs::set_permissions(path, fs::Permissions::from_mode(FILE_MODE))
   2508         .map_err(|_| ReleaseArtifactError::GenerationFailure)
   2509 }
   2510 
   2511 #[cfg(not(unix))]
   2512 fn set_file_mode(_path: &Path) -> Result<(), ReleaseArtifactError> {
   2513     Ok(())
   2514 }
   2515 
   2516 #[cfg(unix)]
   2517 fn set_directory_mode(path: &Path) -> Result<(), ReleaseArtifactError> {
   2518     use std::os::unix::fs::PermissionsExt as _;
   2519     fs::set_permissions(path, fs::Permissions::from_mode(DIRECTORY_MODE))
   2520         .map_err(|_| ReleaseArtifactError::GenerationFailure)
   2521 }
   2522 
   2523 #[cfg(not(unix))]
   2524 fn set_directory_mode(_path: &Path) -> Result<(), ReleaseArtifactError> {
   2525     Ok(())
   2526 }
   2527 
   2528 #[cfg(all(test, unix))]
   2529 fn validate_file_mode(path: &Path) -> Result<(), ReleaseArtifactError> {
   2530     use std::os::unix::fs::PermissionsExt as _;
   2531     let mode = fs::symlink_metadata(path)
   2532         .map_err(|_| ReleaseArtifactError::StaleOutput)?
   2533         .permissions()
   2534         .mode()
   2535         & 0o7777;
   2536     if mode == FILE_MODE {
   2537         Ok(())
   2538     } else {
   2539         Err(ReleaseArtifactError::StaleOutput)
   2540     }
   2541 }
   2542 
   2543 #[cfg(all(test, not(unix)))]
   2544 fn validate_file_mode(_path: &Path) -> Result<(), ReleaseArtifactError> {
   2545     Ok(())
   2546 }
   2547 
   2548 #[cfg(all(test, unix))]
   2549 fn validate_directory_mode(path: &Path) -> Result<(), ReleaseArtifactError> {
   2550     use std::os::unix::fs::PermissionsExt as _;
   2551     let mode = fs::symlink_metadata(path)
   2552         .map_err(|_| ReleaseArtifactError::StaleOutput)?
   2553         .permissions()
   2554         .mode()
   2555         & 0o7777;
   2556     if mode == DIRECTORY_MODE {
   2557         Ok(())
   2558     } else {
   2559         Err(ReleaseArtifactError::StaleOutput)
   2560     }
   2561 }
   2562 
   2563 #[cfg(all(test, not(unix)))]
   2564 fn validate_directory_mode(_path: &Path) -> Result<(), ReleaseArtifactError> {
   2565     Ok(())
   2566 }
   2567 
   2568 fn sync_directory(path: &Path) -> Result<(), ReleaseArtifactError> {
   2569     fs::File::open(path)
   2570         .and_then(|directory| directory.sync_all())
   2571         .map_err(|_| ReleaseArtifactError::GenerationFailure)
   2572 }
   2573 
   2574 fn command_stdout(command: &mut Command, maximum: usize) -> Result<Vec<u8>, ()> {
   2575     let mut child = command
   2576         .stdin(Stdio::null())
   2577         .stdout(Stdio::piped())
   2578         .stderr(Stdio::null())
   2579         .spawn()
   2580         .map_err(|_| ())?;
   2581     let mut stdout = child.stdout.take().ok_or(())?;
   2582     let mut bytes = Vec::new();
   2583     if stdout
   2584         .by_ref()
   2585         .take(maximum as u64 + 1)
   2586         .read_to_end(&mut bytes)
   2587         .is_err()
   2588         || bytes.len() > maximum
   2589     {
   2590         let _ = child.kill();
   2591         let _ = child.wait();
   2592         return Err(());
   2593     }
   2594     let status = child.wait().map_err(|_| ())?;
   2595     if status.success() { Ok(bytes) } else { Err(()) }
   2596 }
   2597 
   2598 fn git_stdout<const N: usize>(root: &Path, args: [&str; N], maximum: usize) -> Result<Vec<u8>, ()> {
   2599     let mut command = Command::new("git");
   2600     command.args(args).current_dir(root);
   2601     command_stdout(&mut command, maximum)
   2602 }
   2603 
   2604 fn valid_metadata_text(value: &str) -> bool {
   2605     !value.is_empty()
   2606         && value.len() <= MAX_TEXT_FIELD_BYTES
   2607         && !value.contains(['\n', '\r'])
   2608         && !SECRET_PATTERNS.iter().any(|pattern| {
   2609             value
   2610                 .as_bytes()
   2611                 .windows(pattern.len())
   2612                 .any(|window| window == *pattern)
   2613         })
   2614         && scan_bytes(value.as_bytes()).is_ok()
   2615 }
   2616 
   2617 fn valid_public_source(value: &str) -> bool {
   2618     valid_metadata_text(value)
   2619         && (value.starts_with("registry+https://") || value.starts_with("git+https://"))
   2620         && !value.contains("@github.com")
   2621 }
   2622 
   2623 fn valid_snake_identifier(value: &str) -> bool {
   2624     value.len() <= 128
   2625         && value
   2626             .split('_')
   2627             .all(|segment| !segment.is_empty() && valid_lower_alphanumeric(segment))
   2628         && value.as_bytes().first().is_some_and(u8::is_ascii_lowercase)
   2629         && value
   2630             .as_bytes()
   2631             .last()
   2632             .is_some_and(u8::is_ascii_alphanumeric)
   2633 }
   2634 
   2635 fn valid_kebab_identifier(value: &str) -> bool {
   2636     value.len() <= 128
   2637         && value
   2638             .split('-')
   2639             .all(|segment| !segment.is_empty() && valid_lower_alphanumeric(segment))
   2640         && value.as_bytes().first().is_some_and(u8::is_ascii_lowercase)
   2641         && value
   2642             .as_bytes()
   2643             .last()
   2644             .is_some_and(u8::is_ascii_alphanumeric)
   2645 }
   2646 
   2647 fn valid_lower_alphanumeric(value: &str) -> bool {
   2648     value
   2649         .bytes()
   2650         .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit())
   2651 }
   2652 
   2653 fn valid_output_component(value: &str) -> bool {
   2654     let mut components = Path::new(value).components();
   2655     !value.is_empty()
   2656         && value.len() <= 128
   2657         && !value.contains(['/', '\\'])
   2658         && matches!(components.next(), Some(Component::Normal(_)))
   2659         && components.next().is_none()
   2660         && value != "."
   2661         && value != ".."
   2662 }
   2663 
   2664 fn valid_lower_hex(value: &str, length: usize) -> bool {
   2665     value.len() == length
   2666         && value
   2667             .bytes()
   2668             .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
   2669 }
   2670 
   2671 fn sha256_bytes(bytes: &[u8]) -> String {
   2672     hex::encode(Sha256::digest(bytes))
   2673 }
   2674 
   2675 pub(crate) fn validate_contract(workspace_root: &Path) -> Result<(), String> {
   2676     validate_contract_inner(workspace_root).map_err(|error| error.to_string())
   2677 }
   2678 
   2679 fn validate_contract_inner(workspace_root: &Path) -> Result<(), ReleaseArtifactError> {
   2680     let bytes = read_bounded_regular(
   2681         &workspace_root.join(CONTRACT_RELATIVE),
   2682         MAX_CONTRACT_BYTES as u64,
   2683         ReleaseArtifactError::InvalidContract,
   2684     )?;
   2685     let decision = serde_json::from_slice::<ReleaseDecision>(&bytes)
   2686         .map_err(|_| ReleaseArtifactError::InvalidContract)?;
   2687     validate_decision(&decision)
   2688 }
   2689 
   2690 fn validate_decision(decision: &ReleaseDecision) -> Result<(), ReleaseArtifactError> {
   2691     let errors = [
   2692         ReleaseArtifactError::InvalidContract,
   2693         ReleaseArtifactError::InvalidServiceRoot,
   2694         ReleaseArtifactError::DirtyServiceSource,
   2695         ReleaseArtifactError::InvalidServiceMetadata,
   2696         ReleaseArtifactError::InvalidInputRoot,
   2697         ReleaseArtifactError::InvalidInputArtifact,
   2698         ReleaseArtifactError::InvalidSourceLock,
   2699         ReleaseArtifactError::InvalidSourceBundle,
   2700         ReleaseArtifactError::InvalidPackageInventory,
   2701         ReleaseArtifactError::ProtectedMaterialDetected,
   2702         ReleaseArtifactError::InvalidOutputRoot,
   2703         ReleaseArtifactError::StaleOutput,
   2704         ReleaseArtifactError::GenerationFailure,
   2705     ];
   2706     if decision.schema != "radroots.service.release_artifacts.v5"
   2707         || decision.contract_version != 5
   2708         || decision.decision_state != "active_unsigned_preparation"
   2709         || decision.implementation_scope != "current_compiler_preparation"
   2710         || decision.rust_version != RUST_VERSION
   2711         || decision.edition != "2024"
   2712         || decision.qualification_posture
   2713             != "source_bound_preparation_requires_separate_executed_platform_and_release_evidence"
   2714         || decision.predecessor.schema
   2715             != "radroots.services-hardening.release-artifacts-decisions.v4"
   2716         || decision.predecessor.filename != "services_hardening_release_artifacts.v4.json"
   2717         || decision.predecessor.transition != "forward_only_replace"
   2718         || decision.command != "cargo xtask service-release-artifacts"
   2719         || decision.modes != ["check", "write"]
   2720         || decision.required_arguments
   2721             != [
   2722                 "mode",
   2723                 "service_root",
   2724                 "lib_root",
   2725                 "input_root",
   2726                 "output_root",
   2727                 "target",
   2728                 "source_date_epoch",
   2729                 "candidate_digest",
   2730             ]
   2731         || decision.service_metadata_path
   2732             != "Cargo.toml.workspace.metadata.radroots.service_release"
   2733         || decision.service_metadata_fields
   2734             != ["service", "service_package", "binary_name", "version"]
   2735         || decision.service_license_path
   2736             != "Cargo.toml.workspace.package.license_or_package.license"
   2737         || decision.source_lock_schema != "radroots.service.source_lock.v4"
   2738         || decision.source_lock_definition
   2739             != "contracts/architecture/decisions/services_hardening_source_lock.v4.json"
   2740         || decision.artifact_contract_binding
   2741             != "source_lock_exact_regular_file_bytes_in_same_service_revision"
   2742         || decision.artifact_admission_contract
   2743             != "contracts/architecture/decisions/services_hardening_artifact_admission.v1.json"
   2744         || decision.supported_targets != SUPPORTED_TARGETS
   2745         || decision.candidate_binding != "explicit_sha256_candidate_identity_digest"
   2746         || decision.lib_root_binding
   2747             != "canonical_public_lib_git_root_containing_the_locked_revision"
   2748         || decision.binary_admission
   2749             != "exact_format_architecture_linkage_structural_and_native_bounded_help_smoke"
   2750         || decision.oci_admission
   2751             != "safe_materialization_exact_manifest_config_AGPL_labels_layers_and_entrypoint"
   2752         || decision.input_inventory != INPUT_NAMES
   2753         || decision.excluded_parent_owned_inputs != ["backup_restore_runbook", "operator_runbook"]
   2754         || decision.service_root_inventory != ["LICENSE-APACHE", "LICENSE-MIT", LOCK_FILENAME]
   2755         || decision.output_inventory != OUTPUT_NAMES
   2756         || decision.canonical_json != "compact_utf8_json_with_one_final_lf"
   2757         || decision.checksum_format != "sha256_lower_hex_two_spaces_path_lf_sorted_by_path"
   2758         || decision.source_archive_format
   2759             != "canonical_uncompressed_ustar_exact_git_revision_tree_without_history"
   2760         || decision.sbom_format != "cyclonedx_json_1_6_complete_cargo_nix_and_artifact_closure"
   2761         || decision.license_evidence != "exact_dependency_attribution_with_bounded_license_texts"
   2762         || decision.provenance_posture
   2763             != "candidate_derived_unsigned_intoto_statement_slsa_v1_exact_manifest_subjects"
   2764         || decision.protected_material_scan_scope
   2765             != "all_artifact_bytes_and_bounded_nested_binary_oci_layer_and_source_archive_payloads"
   2766         || decision.confidentiality_state != "derived_only_from_the_exact_artifact_scan_record"
   2767         || decision.source_cleanliness != "no_tracked_staged_or_untracked_changes"
   2768         || decision.revision_stability != "same_service_head_before_and_after_generation"
   2769         || !decision.no_protected_material
   2770         || decision.maximums.source_lock_bytes != MAX_SOURCE_LOCK_BYTES
   2771         || decision.maximums.text_input_bytes != MAX_TEXT_INPUT_BYTES
   2772         || decision.maximums.generated_document_bytes != MAX_GENERATED_DOCUMENT_BYTES
   2773         || decision.maximums.service_cargo_lock_bytes != MAX_SERVICE_CARGO_LOCK_BYTES
   2774         || decision.maximums.service_flake_lock_bytes != MAX_SERVICE_FLAKE_LOCK_BYTES
   2775         || decision.maximums.binary_bytes != MAX_BINARY_BYTES
   2776         || decision.maximums.source_archive_bytes != MAX_SOURCE_ARCHIVE_BYTES
   2777         || decision.maximums.source_archive_member_bytes != MAX_SOURCE_ARCHIVE_MEMBER_BYTES
   2778         || decision.maximums.source_archive_members != MAX_SOURCE_ARCHIVE_MEMBERS
   2779         || decision.maximums.oci_bytes != MAX_OCI_BYTES
   2780         || decision.maximums.artifact_scan_expanded_bytes != MAX_ARCHIVE_EXPANDED_BYTES
   2781         || decision.maximums.cargo_metadata_bytes != MAX_METADATA_BYTES
   2782         || decision.maximums.packages != MAX_PACKAGES
   2783         || decision.maximums.workspace_packages != MAX_WORKSPACE_PACKAGES
   2784         || decision.required_negative_vectors
   2785             != [
   2786                 "cyclonedx_schema_drift",
   2787                 "missing_dependency_component",
   2788                 "unreconciled_artifact_subject",
   2789                 "missing_or_mismatched_license_text",
   2790                 "invented_candidate_digest",
   2791                 "git_history_bundle",
   2792                 "secret_in_binary",
   2793                 "secret_in_oci_layer",
   2794                 "secret_in_source_archive",
   2795                 "sensitive_archive_path",
   2796                 "scan_confidentiality_mismatch",
   2797             ]
   2798         || decision.negative_error_codes != errors.map(ReleaseArtifactError::code)
   2799     {
   2800         return Err(ReleaseArtifactError::InvalidContract);
   2801     }
   2802     Ok(())
   2803 }
   2804 
   2805 #[cfg(test)]
   2806 mod tests {
   2807     use serde_json::{Value, json};
   2808     use std::process::Command;
   2809 
   2810     use crate::service_source_lock::ContractVersions;
   2811     use crate::service_source_lock_v4::ServiceSourceLockV4Parts;
   2812 
   2813     use super::*;
   2814 
   2815     struct ReleaseFixture {
   2816         _root: TempDir,
   2817         service: PathBuf,
   2818         lib: PathBuf,
   2819         input: PathBuf,
   2820         output_a: PathBuf,
   2821         output_b: PathBuf,
   2822     }
   2823 
   2824     impl ReleaseFixture {
   2825         fn new() -> Self {
   2826             let root = TempDir::new().expect("fixture root");
   2827             let canonical_root = root.path().canonicalize().expect("canonical fixture root");
   2828             let service = canonical_root.join("service");
   2829             let lib = canonical_root.join("lib");
   2830             let input = canonical_root.join("input");
   2831             fs::create_dir_all(service.join("src")).expect("service source");
   2832             fs::create_dir_all(lib.join("contracts/crates")).expect("Lib contracts");
   2833             fs::create_dir(&input).expect("input root");
   2834 
   2835             write_file(
   2836                 &lib.join("contracts/crates/catalog.v2.toml"),
   2837                 b"schema_version = 2\nschema = \"radroots.workspace.catalog.v2\"\narchitecture = \"radroots.crates.release.v2\"\nversion = \"0.1.0-alpha\"\nrust_version = \"1.99.0\"\nedition = \"2024\"\nresolver = \"3\"\n",
   2838             );
   2839             write_file(&lib.join("README.md"), b"fixture Lib source\n");
   2840             write_file(&lib.join("Cargo.toml"),
   2841                 b"[workspace]\nresolver = \"3\"\n[workspace.package]\nversion = \"0.1.0-alpha\"\nrust-version = \"1.99.0\"\nedition = \"2024\"\n");
   2842             write_file(
   2843                 &lib.join("rust-toolchain.toml"),
   2844                 b"[toolchain]\nchannel = \"1.99.0\"\n",
   2845             );
   2846             initialize_git(&lib, "https://github.com/radrootslabs/lib");
   2847             let lib_revision = git_output(&lib, &["rev-parse", "HEAD"]);
   2848             let lib_archive_path = canonical_root.join("lib-source.tar");
   2849             let lib_archive = exact_tree_archive::create(
   2850                 &lib,
   2851                 &lib_revision,
   2852                 &lib_archive_path,
   2853                 exact_tree_archive::commit_timestamp(&lib, &lib_revision)
   2854                     .expect("Lib commit timestamp"),
   2855             )
   2856             .expect("Lib source archive");
   2857             let catalog =
   2858                 fs::read(lib.join("contracts/crates/catalog.v2.toml")).expect("workspace catalog");
   2859 
   2860             write_file(
   2861                 &service.join("Cargo.toml"),
   2862                 br#"[package]
   2863 name = "fixture-service"
   2864 version = "0.1.0-alpha"
   2865 edition = "2024"
   2866 rust-version = "1.99.0"
   2867 license = "AGPL-3.0-or-later"
   2868 
   2869 [[bin]]
   2870 name = "fixture-service"
   2871 path = "src/main.rs"
   2872 
   2873 [workspace]
   2874 resolver = "3"
   2875 
   2876 [workspace.metadata.radroots.service_release]
   2877 service = "myc"
   2878 service_package = "fixture-service"
   2879 binary_name = "fixture-service"
   2880 version = "0.1.0-alpha"
   2881 "#,
   2882             );
   2883             write_file(&service.join("src/main.rs"), b"fn main() {}\n");
   2884             write_file(
   2885                 &service.join("rust-toolchain.toml"),
   2886                 b"[toolchain]\nchannel = \"1.99.0\"\n",
   2887             );
   2888             write_file(
   2889                 &service.join("Cargo.lock"),
   2890                 br#"# This file is automatically @generated by Cargo.
   2891 # It is not intended for manual editing.
   2892 version = 4
   2893 
   2894 [[package]]
   2895 name = "fixture-service"
   2896 version = "0.1.0-alpha"
   2897 "#,
   2898             );
   2899             write_file(
   2900                 &service.join("flake.nix"),
   2901                 format!(
   2902                     "{{\n  inputs.lib = {{\n    url = \"github:radrootslabs/lib/{lib_revision}\";\n    flake = false;\n  }};\n  outputs = {{ ... }}: {{ }};\n}}\n"
   2903                 )
   2904                 .as_bytes(),
   2905             );
   2906             write_file(
   2907                 &service.join("flake.lock"),
   2908                 format!(
   2909                     "{{\"nodes\":{{\"root\":{{\"inputs\":{{\"lib\":\"lib\"}}}},\"lib\":{{\"locked\":{{\"lastModified\":1,\"narHash\":\"sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\",\"owner\":\"radrootslabs\",\"repo\":\"lib\",\"rev\":\"{lib_revision}\",\"type\":\"github\"}},\"original\":{{\"owner\":\"radrootslabs\",\"repo\":\"lib\",\"rev\":\"{lib_revision}\",\"type\":\"github\"}}}}}},\"root\":\"root\",\"version\":7}}\n"
   2910                 )
   2911                 .as_bytes(),
   2912             );
   2913             write_file(
   2914                 &service.join("LICENSE-APACHE"),
   2915                 b"Apache-2.0 fixture license\n",
   2916             );
   2917             write_file(&service.join("LICENSE-MIT"), b"MIT fixture license\n");
   2918             let artifact_contract_path =
   2919                 service.join("contracts/release/myc-artifact-contract.v4.json");
   2920             fs::create_dir_all(
   2921                 artifact_contract_path
   2922                     .parent()
   2923                     .expect("artifact contract parent"),
   2924             )
   2925             .expect("artifact contract directory");
   2926             write_file(&artifact_contract_path, b"{}\n");
   2927             let cargo_lock = fs::read(service.join("Cargo.lock")).expect("Cargo lock");
   2928             let flake_lock = fs::read(service.join("flake.lock")).expect("flake lock");
   2929             let artifact_contract = fs::read(&artifact_contract_path).expect("artifact contract");
   2930             let source_lock = ServiceSourceLockV4::new(ServiceSourceLockV4Parts {
   2931                 service: "myc",
   2932                 revision: &lib_revision,
   2933                 workspace_catalog_sha256: &sha256_bytes(&catalog),
   2934                 source_archive_sha256: &lib_archive.sha256,
   2935                 cargo_lock_sha256: &sha256_bytes(&cargo_lock),
   2936                 flake_lock_sha256: &sha256_bytes(&flake_lock),
   2937                 artifact_contract_sha256: &sha256_bytes(&artifact_contract),
   2938                 contract_versions: ContractVersions::new(1, 1, 1, 1, 1),
   2939             })
   2940             .expect("source lock");
   2941             write_file(&service.join(LOCK_FILENAME), source_lock.canonical_bytes());
   2942             initialize_git(&service, "https://github.com/radrootslabs/fixture-service");
   2943             let service_revision = git_output(&service, &["rev-parse", "HEAD"]);
   2944             for (name, bytes) in [
   2945                 ("config.example.toml", b"enabled = true\n".as_slice()),
   2946                 ("config.schema.json", b"{\"type\":\"object\"}\n".as_slice()),
   2947                 ("nixos-module.nix", b"{ ... }: {}\n".as_slice()),
   2948                 (
   2949                     "systemd.service",
   2950                     b"[Service]\nExecStart=/usr/bin/fixture-service\n".as_slice(),
   2951                 ),
   2952             ] {
   2953                 write_file(&input.join(name), bytes);
   2954             }
   2955             let status = Command::new("rustc")
   2956                 .args(["--edition=2024", "src/main.rs", "-o"])
   2957                 .arg(input.join("service-binary"))
   2958                 .current_dir(&service)
   2959                 .status()
   2960                 .expect("compile fixture service binary");
   2961             assert!(status.success(), "compile fixture service binary");
   2962             create_oci_fixture(
   2963                 &input.join("oci-image.tar.gz"),
   2964                 &service_revision,
   2965                 &lib_revision,
   2966             );
   2967 
   2968             Self {
   2969                 output_a: canonical_root.join("release-a"),
   2970                 output_b: canonical_root.join("release-b"),
   2971                 _root: root,
   2972                 service,
   2973                 lib,
   2974                 input,
   2975             }
   2976         }
   2977 
   2978         fn write(&self, output: &Path) -> Result<(), ReleaseArtifactError> {
   2979             run_inner(Arguments {
   2980                 mode: CommandMode::Write,
   2981                 service_root: &self.service,
   2982                 lib_root: &self.lib,
   2983                 input_root: &self.input,
   2984                 output_root: output,
   2985                 target: native_fixture_target(),
   2986                 source_date_epoch: 1_700_000_000,
   2987                 candidate_digest: &"a".repeat(64),
   2988             })
   2989         }
   2990 
   2991         fn check(&self, output: &Path) -> Result<(), ReleaseArtifactError> {
   2992             run_inner(Arguments {
   2993                 mode: CommandMode::Check,
   2994                 service_root: &self.service,
   2995                 lib_root: &self.lib,
   2996                 input_root: &self.input,
   2997                 output_root: output,
   2998                 target: native_fixture_target(),
   2999                 source_date_epoch: 1_700_000_000,
   3000                 candidate_digest: &"a".repeat(64),
   3001             })
   3002         }
   3003     }
   3004 
   3005     fn write_file(path: &Path, bytes: &[u8]) {
   3006         fs::write(path, bytes).expect("write fixture file");
   3007     }
   3008 
   3009     fn git(root: &Path, args: &[&str]) {
   3010         let status = Command::new("git")
   3011             .args(args)
   3012             .current_dir(root)
   3013             .status()
   3014             .expect("run Git");
   3015         assert!(status.success(), "git {args:?}");
   3016     }
   3017 
   3018     fn git_output(root: &Path, args: &[&str]) -> String {
   3019         let output = Command::new("git")
   3020             .args(args)
   3021             .current_dir(root)
   3022             .output()
   3023             .expect("run Git");
   3024         assert!(output.status.success(), "git {args:?}");
   3025         String::from_utf8(output.stdout)
   3026             .expect("Git UTF-8")
   3027             .trim()
   3028             .to_owned()
   3029     }
   3030 
   3031     fn initialize_git(root: &Path, remote: &str) {
   3032         git(root, &["init", "--quiet"]);
   3033         git(root, &["config", "user.email", "fixture@radroots.test"]);
   3034         git(root, &["config", "user.name", "Radroots Fixture"]);
   3035         git(root, &["remote", "add", "origin", remote]);
   3036         git(root, &["add", "."]);
   3037         git(root, &["commit", "--quiet", "-m", "fixture"]);
   3038         git(root, &["branch", "-M", "archive"]);
   3039     }
   3040 
   3041     fn native_fixture_target() -> &'static str {
   3042         if cfg!(all(target_os = "macos", target_arch = "aarch64")) {
   3043             "aarch64-apple-darwin"
   3044         } else {
   3045             "x86_64-unknown-linux-gnu"
   3046         }
   3047     }
   3048 
   3049     fn create_oci_fixture(output: &Path, service_revision: &str, lib_revision: &str) {
   3050         let entrypoint =
   3051             "/nix/store/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-fixture-service/bin/fixture-service";
   3052         let mut layer = Vec::new();
   3053         {
   3054             let mut tar = TarBuilder::new(&mut layer);
   3055             let bytes = b"fixture executable";
   3056             let mut header = TarHeader::new_gnu();
   3057             header.set_size(bytes.len() as u64);
   3058             header.set_mode(0o755);
   3059             header.set_uid(0);
   3060             header.set_gid(0);
   3061             header.set_mtime(0);
   3062             header.set_cksum();
   3063             tar.append_data(
   3064                 &mut header,
   3065                 entrypoint.trim_start_matches('/'),
   3066                 bytes.as_slice(),
   3067             )
   3068             .expect("write layer entrypoint");
   3069             tar.finish().expect("finish layer");
   3070         }
   3071         let layer_digest = sha256_bytes(&layer);
   3072         let layer_name = format!("{layer_digest}/layer.tar");
   3073         let labels = artifact_admission::OciExpectation {
   3074             service: "myc",
   3075             binary_name: "fixture-service",
   3076             version: "0.1.0-alpha",
   3077             service_revision,
   3078             lib_revision,
   3079             license: "AGPL-3.0-or-later",
   3080             contract_versions: artifact_admission::ContractVersions {
   3081                 admin: 1,
   3082                 config: 1,
   3083                 provider: 1,
   3084                 state: 1,
   3085                 status: 1,
   3086             },
   3087         };
   3088         let labels = artifact_admission::fixture_labels(&labels);
   3089         let config = serde_json::to_vec(&serde_json::json!({
   3090             "architecture": "amd64",
   3091             "config": {
   3092                 "Entrypoint": [entrypoint],
   3093                 "Env": ["SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"],
   3094                 "Labels": labels,
   3095                 "StopSignal": "SIGTERM",
   3096                 "User": "65532:65532",
   3097                 "WorkingDir": "/"
   3098             },
   3099             "created": "1970-01-01T00:00:01+00:00",
   3100             "os": "linux",
   3101             "rootfs": {"diff_ids": [format!("sha256:{layer_digest}")], "type": "layers"}
   3102         }))
   3103         .expect("serialize config");
   3104         let config_name = format!("{}.json", sha256_bytes(&config));
   3105         let manifest = serde_json::to_vec(&serde_json::json!([{
   3106             "Config": config_name,
   3107             "Layers": [layer_name],
   3108             "RepoTags": ["myc:0.1.0-alpha"]
   3109         }]))
   3110         .expect("serialize manifest");
   3111         let repositories = serde_json::to_vec(&serde_json::json!({
   3112             "myc": {"0.1.0-alpha": layer_digest}
   3113         }))
   3114         .expect("serialize repositories");
   3115         let mut members = vec![
   3116             (config_name, false, config),
   3117             (format!("{layer_digest}/"), true, Vec::new()),
   3118             (format!("{layer_digest}/VERSION"), false, b"1.0".to_vec()),
   3119             (format!("{layer_digest}/json"), false, b"{}".to_vec()),
   3120             (layer_name, false, layer),
   3121             ("manifest.json".to_owned(), false, manifest),
   3122             ("repositories".to_owned(), false, repositories),
   3123         ];
   3124         members.sort_by(|left, right| left.0.as_bytes().cmp(right.0.as_bytes()));
   3125         let output_file = fs::File::create(output).expect("create OCI fixture");
   3126         let encoder = GzBuilder::new()
   3127             .mtime(0)
   3128             .operating_system(255)
   3129             .write(output_file, Compression::best());
   3130         let mut archive = TarBuilder::new(encoder);
   3131         for (name, directory, bytes) in members {
   3132             let mut header = TarHeader::new_gnu();
   3133             header.set_entry_type(if directory {
   3134                 tar::EntryType::Directory
   3135             } else {
   3136                 tar::EntryType::Regular
   3137             });
   3138             header.set_size(bytes.len() as u64);
   3139             header.set_mode(if directory { 0o755 } else { 0o644 });
   3140             header.set_uid(0);
   3141             header.set_gid(0);
   3142             header.set_mtime(0);
   3143             header.set_cksum();
   3144             archive
   3145                 .append_data(&mut header, name, bytes.as_slice())
   3146                 .expect("write OCI member");
   3147         }
   3148         let encoder = archive.into_inner().expect("finish OCI fixture tar");
   3149         let file = encoder.finish().expect("finish OCI fixture gzip");
   3150         file.sync_all().expect("sync OCI fixture");
   3151     }
   3152 
   3153     fn sample_metadata() -> ReleaseMetadata {
   3154         ReleaseMetadata {
   3155             service: "fixture_service".to_owned(),
   3156             service_package: "fixture-service".to_owned(),
   3157             binary_name: "fixture-service".to_owned(),
   3158             version: "0.1.0-alpha".to_owned(),
   3159             license: "AGPL-3.0-or-later".to_owned(),
   3160         }
   3161     }
   3162 
   3163     fn package(
   3164         id: &str,
   3165         name: &str,
   3166         source: Option<&str>,
   3167         checksum: Option<&str>,
   3168         license: Option<&str>,
   3169         binary: bool,
   3170     ) -> CargoPackage {
   3171         CargoPackage {
   3172             id: id.to_owned(),
   3173             name: name.to_owned(),
   3174             version: "0.1.0-alpha".to_owned(),
   3175             source: source.map(str::to_owned),
   3176             checksum: checksum.map(str::to_owned),
   3177             license: license.map(str::to_owned),
   3178             manifest_path: format!("/fixture/{name}/Cargo.toml"),
   3179             license_file: None,
   3180             targets: if binary {
   3181                 vec![CargoTarget {
   3182                     name: name.to_owned(),
   3183                     kind: vec!["bin".to_owned()],
   3184                 }]
   3185             } else {
   3186                 Vec::new()
   3187             },
   3188             license_texts: source
   3189                 .map(|_| {
   3190                     let text = "fixture dependency license text\n".to_owned();
   3191                     vec![DependencyLicenseText {
   3192                         filename: "LICENSE".to_owned(),
   3193                         sha256: sha256_bytes(text.as_bytes()),
   3194                         text,
   3195                     }]
   3196                 })
   3197                 .unwrap_or_default(),
   3198         }
   3199     }
   3200 
   3201     fn sample_cargo_metadata() -> CargoMetadata {
   3202         let root_id = "path+file:///fixture#fixture-service@0.1.0-alpha";
   3203         let dependency_id = "registry+https://example.invalid#index@0.1.0-alpha";
   3204         CargoMetadata {
   3205             packages: vec![
   3206                 package(root_id, "fixture-service", None, None, Some("MIT"), true),
   3207                 package(
   3208                     dependency_id,
   3209                     "dependency",
   3210                     Some("registry+https://github.com/rust-lang/crates.io-index"),
   3211                     Some(&"a".repeat(64)),
   3212                     Some("Apache-2.0"),
   3213                     false,
   3214                 ),
   3215             ],
   3216             workspace_members: vec![root_id.to_owned()],
   3217             resolve: Some(CargoResolve {
   3218                 nodes: vec![
   3219                     CargoNode {
   3220                         id: dependency_id.to_owned(),
   3221                         dependencies: Vec::new(),
   3222                     },
   3223                     CargoNode {
   3224                         id: root_id.to_owned(),
   3225                         dependencies: vec![dependency_id.to_owned()],
   3226                     },
   3227                 ],
   3228             }),
   3229         }
   3230     }
   3231 
   3232     #[test]
   3233     fn oci_admission_reconciles_manifest_config_and_layer_content() {
   3234         let temporary = TempDir::new().unwrap();
   3235         let root = temporary.path().canonicalize().unwrap();
   3236         let original = root.join("original.tar.gz");
   3237         let revision = "a".repeat(40);
   3238         create_oci_fixture(&original, &revision, &revision);
   3239         let expected = artifact_admission::OciExpectation {
   3240             service: "myc",
   3241             binary_name: "fixture-service",
   3242             version: "0.1.0-alpha",
   3243             service_revision: &revision,
   3244             lib_revision: &revision,
   3245             license: "AGPL-3.0-or-later",
   3246             contract_versions: artifact_admission::ContractVersions {
   3247                 admin: 1,
   3248                 config: 1,
   3249                 provider: 1,
   3250                 state: 1,
   3251                 status: 1,
   3252             },
   3253         };
   3254         artifact_admission::admit_oci(&original, &root, &expected).unwrap();
   3255         let decoder = flate2::read::GzDecoder::new(fs::File::open(&original).unwrap());
   3256         let mut archive = tar::Archive::new(decoder);
   3257         let mut original_members = BTreeMap::new();
   3258         let mut directories = BTreeSet::new();
   3259         for entry in archive.entries().unwrap() {
   3260             let mut entry = entry.unwrap();
   3261             let name = entry.path().unwrap().to_str().unwrap().to_owned();
   3262             if entry.header().entry_type().is_dir() {
   3263                 directories.insert(name.clone());
   3264             }
   3265             let mut bytes = Vec::new();
   3266             entry.read_to_end(&mut bytes).unwrap();
   3267             original_members.insert(name, bytes);
   3268         }
   3269         for case in 0..14 {
   3270             let mut members = original_members.clone();
   3271             let mut manifest: Value = serde_json::from_slice(&members["manifest.json"]).unwrap();
   3272             match case {
   3273                 0 => manifest = json!([]),
   3274                 1 => manifest[0]["Config"] = json!("wrong.extension"),
   3275                 2 => manifest[0]["Config"] = json!("invalid.json"),
   3276                 3 => manifest[0]["RepoTags"] = json!(["wrong:tag"]),
   3277                 4 => manifest[0]["Layers"] = json!([]),
   3278                 5 => manifest[0]["Layers"] = json!(["one", "two", "three"]),
   3279                 6 => {
   3280                     manifest[0]["Layers"] = json!([
   3281                         manifest[0]["Layers"][0].clone(),
   3282                         manifest[0]["Layers"][0].clone()
   3283                     ])
   3284                 }
   3285                 7 => {
   3286                     members
   3287                         .get_mut(manifest[0]["Config"].as_str().unwrap())
   3288                         .unwrap()
   3289                         .push(b' ');
   3290                 }
   3291                 8..=10 => {
   3292                     let old_name = manifest[0]["Config"].as_str().unwrap().to_owned();
   3293                     let mut config: Value =
   3294                         serde_json::from_slice(&members.remove(&old_name).unwrap()).unwrap();
   3295                     match case {
   3296                         8 => config["rootfs"]["type"] = json!("unknown"),
   3297                         9 => config["rootfs"]["diff_ids"] = json!([]),
   3298                         _ => {
   3299                             config["rootfs"]["diff_ids"] =
   3300                                 json!([format!("sha256:{}", "0".repeat(64))])
   3301                         }
   3302                     }
   3303                     let bytes = serde_json::to_vec(&config).unwrap();
   3304                     let name = format!("{}.json", sha256_bytes(&bytes));
   3305                     members.insert(name.clone(), bytes);
   3306                     manifest[0]["Config"] = json!(name);
   3307                 }
   3308                 11 => {
   3309                     members.remove(manifest[0]["Layers"][0].as_str().unwrap());
   3310                 }
   3311                 12 => {
   3312                     members.insert("unexpected".to_owned(), b"extra".to_vec());
   3313                 }
   3314                 _ => {}
   3315             }
   3316             members.insert(
   3317                 "manifest.json".to_owned(),
   3318                 serde_json::to_vec(&manifest).unwrap(),
   3319             );
   3320             let path = root.join(format!("invalid-{case}.tar.gz"));
   3321             let encoder = GzBuilder::new()
   3322                 .mtime(0)
   3323                 .operating_system(255)
   3324                 .write(fs::File::create(&path).unwrap(), Compression::best());
   3325             let mut archive = TarBuilder::new(encoder);
   3326             for (name, bytes) in members {
   3327                 let mut header = TarHeader::new_gnu();
   3328                 let directory = directories.contains(&name);
   3329                 header.set_entry_type(if directory {
   3330                     tar::EntryType::Directory
   3331                 } else {
   3332                     tar::EntryType::Regular
   3333                 });
   3334                 header.set_size(bytes.len() as u64);
   3335                 header.set_mode(if directory { 0o755 } else { 0o644 });
   3336                 header.set_uid(0);
   3337                 header.set_gid(0);
   3338                 header.set_mtime(0);
   3339                 header.set_cksum();
   3340                 archive
   3341                     .append_data(&mut header, name, bytes.as_slice())
   3342                     .unwrap();
   3343             }
   3344             archive.into_inner().unwrap().finish().unwrap();
   3345             let admitted = artifact_admission::admit_oci(&path, &root, &expected);
   3346             if case == 13 {
   3347                 admitted.expect("rewritten unmodified OCI fixture remains valid");
   3348             } else {
   3349                 assert!(admitted.is_err(), "OCI case {case}");
   3350             }
   3351         }
   3352         for case in 0..5 {
   3353             let mut changed = artifact_admission::OciExpectation { ..expected };
   3354             match case {
   3355                 0 => changed.license = "MIT",
   3356                 1 => changed.service = "../escape",
   3357                 2 => changed.binary_name = "../escape",
   3358                 3 => changed.service_revision = "invalid",
   3359                 _ => changed.lib_revision = "invalid",
   3360             }
   3361             assert!(artifact_admission::admit_oci(&original, &root, &changed).is_err());
   3362         }
   3363     }
   3364 
   3365     #[test]
   3366     fn dependency_license_admission_retains_complete_domain_data_material() {
   3367         let root = crate::workspace_root();
   3368         let mut dependency = package(
   3369             "domain",
   3370             "radroots_domain",
   3371             Some("git+https://github.com/radrootslabs/lib"),
   3372             None,
   3373             Some("MIT OR Apache-2.0"),
   3374             false,
   3375         );
   3376         dependency.manifest_path = root
   3377             .join("crates/domain/Cargo.toml")
   3378             .to_str()
   3379             .unwrap()
   3380             .to_owned();
   3381         let texts = dependency_license_texts(&dependency).unwrap();
   3382         let notice = texts.iter().find(|v| v.filename == "NOTICE").unwrap();
   3383         assert_eq!(
   3384             notice.text,
   3385             crate::generate::data_notices::render(&root).unwrap()
   3386         );
   3387         assert_eq!(notice.sha256, sha256_bytes(notice.text.as_bytes()));
   3388         assert!(
   3389             notice
   3390                 .text
   3391                 .contains("Copyright 2023-2026 rust_iso4217 contributors")
   3392         );
   3393         assert!(notice.text.contains("IANA time zone database 2026c"));
   3394     }
   3395 
   3396     #[test]
   3397     fn dependency_license_admission_preserves_exact_text_and_rejects_missing_or_unsafe_paths() {
   3398         let temporary = TempDir::new().unwrap();
   3399         let root = temporary.path().canonicalize().unwrap();
   3400         let mut dependency = package(
   3401             "fixture",
   3402             "fixture",
   3403             Some("registry+https://github.com/rust-lang/crates.io-index"),
   3404             Some(&"a".repeat(64)),
   3405             Some("MIT"),
   3406             false,
   3407         );
   3408         dependency.manifest_path = root.join("Cargo.toml").to_str().unwrap().to_owned();
   3409         fs::write(root.join("Cargo.toml"), b"fixture").unwrap();
   3410         assert!(dependency_license_texts(&dependency).is_err());
   3411         let text = "Fixture copyright\nPermission is granted.\n";
   3412         fs::write(root.join("LICENSE"), text).unwrap();
   3413         fs::write(root.join("COPYING-MIT"), "Copying terms\n").unwrap();
   3414         fs::write(root.join("NOTICE.txt"), "Notice terms\n").unwrap();
   3415         let texts = dependency_license_texts(&dependency).unwrap();
   3416         assert_eq!(
   3417             texts
   3418                 .iter()
   3419                 .map(|row| row.filename.as_str())
   3420                 .collect::<Vec<_>>(),
   3421             ["COPYING-MIT", "LICENSE", "NOTICE.txt"]
   3422         );
   3423         assert_eq!(texts[1].text, text);
   3424         assert_eq!(texts[1].sha256, sha256_bytes(text.as_bytes()));
   3425         dependency.license_file = Some("LICENSE".to_owned());
   3426         assert_eq!(dependency_license_texts(&dependency).unwrap().len(), 1);
   3427         for path in ["../outside", "/absolute", "./LICENSE", "missing"] {
   3428             dependency.license_file = Some(path.to_owned());
   3429             assert!(dependency_license_texts(&dependency).is_err(), "{path}");
   3430         }
   3431         for path in [
   3432             "relative/Cargo.toml".to_owned(),
   3433             root.join("not-a-manifest").to_str().unwrap().to_owned(),
   3434         ] {
   3435             dependency.manifest_path = path;
   3436             assert!(dependency_license_texts(&dependency).is_err());
   3437         }
   3438     }
   3439 
   3440     #[test]
   3441     fn dependency_license_content_and_inventory_are_bounded() {
   3442         let temporary = TempDir::new().unwrap();
   3443         let root = temporary.path().canonicalize().unwrap();
   3444         let mut dependency = package(
   3445             "fixture",
   3446             "fixture",
   3447             Some("registry+https://github.com/rust-lang/crates.io-index"),
   3448             Some(&"a".repeat(64)),
   3449             Some("MIT"),
   3450             false,
   3451         );
   3452         dependency.manifest_path = root.join("Cargo.toml").to_str().unwrap().to_owned();
   3453         dependency.license_file = Some("LICENSE".to_owned());
   3454         for bytes in [
   3455             b" \n\t".as_slice(),
   3456             &[255, 254],
   3457             b"-----BEGIN PRIVATE KEY-----\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n-----END PRIVATE KEY-----",
   3458         ] {
   3459             fs::write(root.join("LICENSE"), bytes).unwrap();
   3460             assert!(dependency_license_texts(&dependency).is_err());
   3461         }
   3462         let file = fs::File::create(root.join("LICENSE")).unwrap();
   3463         file.set_len(MAX_TEXT_INPUT_BYTES + 1).unwrap();
   3464         assert!(dependency_license_texts(&dependency).is_err());
   3465         drop(file);
   3466         fs::write(root.join("LICENSE"), b"Valid terms\n").unwrap();
   3467         dependency.license_file = None;
   3468         for index in 0..16 {
   3469             fs::write(root.join(format!("LICENSE-{index}")), b"Terms\n").unwrap();
   3470         }
   3471         assert!(dependency_license_texts(&dependency).is_err());
   3472         for index in 0..256 {
   3473             fs::write(root.join(format!("ordinary-{index}")), b"").unwrap();
   3474         }
   3475         assert!(dependency_license_texts(&dependency).is_err());
   3476     }
   3477 
   3478     #[cfg(unix)]
   3479     #[test]
   3480     fn dependency_license_paths_cannot_escape_the_package_root() {
   3481         use std::os::unix::fs::symlink;
   3482         let temporary = TempDir::new().unwrap();
   3483         let root = temporary.path().canonicalize().unwrap();
   3484         let package_root = root.join("package");
   3485         fs::create_dir(&package_root).unwrap();
   3486         let mut dependency = package(
   3487             "fixture",
   3488             "fixture",
   3489             Some("registry+https://github.com/rust-lang/crates.io-index"),
   3490             Some(&"a".repeat(64)),
   3491             Some("MIT"),
   3492             false,
   3493         );
   3494         dependency.manifest_path = package_root.join("Cargo.toml").to_str().unwrap().to_owned();
   3495         fs::write(root.join("outside"), b"Outside terms\n").unwrap();
   3496         symlink(root.join("outside"), package_root.join("LICENSE")).unwrap();
   3497         assert!(dependency_license_texts(&dependency).is_err());
   3498         fs::create_dir(package_root.join("nested")).unwrap();
   3499         fs::write(package_root.join("nested/terms"), b"Nested terms\n").unwrap();
   3500         dependency.license_file = Some("nested/terms".to_owned());
   3501         assert!(dependency_license_texts(&dependency).is_err());
   3502         assert_eq!(fs::read(root.join("outside")).unwrap(), b"Outside terms\n");
   3503     }
   3504 
   3505     #[test]
   3506     fn contract_matches_the_checked_in_decision() {
   3507         let root = Path::new(env!("CARGO_MANIFEST_DIR"))
   3508             .parent()
   3509             .and_then(Path::parent)
   3510             .expect("workspace root");
   3511         validate_contract_inner(root).expect("release decision");
   3512     }
   3513 
   3514     #[test]
   3515     fn contract_rejects_every_independent_governed_field_drift() {
   3516         let root = Path::new(env!("CARGO_MANIFEST_DIR"))
   3517             .parent()
   3518             .and_then(Path::parent)
   3519             .expect("workspace root");
   3520         let bytes = fs::read(root.join(CONTRACT_RELATIVE)).expect("decision");
   3521         let canonical = serde_json::from_slice::<serde_json::Value>(&bytes).expect("decision json");
   3522         for (pointer, replacement) in [
   3523             ("/schema", serde_json::json!("other")),
   3524             ("/contract_version", serde_json::json!(1)),
   3525             ("/decision_state", serde_json::json!("draft")),
   3526             ("/implementation_scope", serde_json::json!("other")),
   3527             ("/rust_version", serde_json::json!("1.97.1")),
   3528             ("/edition", serde_json::json!("2021")),
   3529             ("/qualification_posture", serde_json::json!("qualified")),
   3530             ("/maximums/source_lock_bytes", serde_json::json!(1)),
   3531             ("/predecessor/schema", serde_json::json!("other")),
   3532             ("/predecessor/filename", serde_json::json!("other")),
   3533             ("/predecessor/transition", serde_json::json!("other")),
   3534             ("/command", serde_json::json!("other")),
   3535             ("/modes", serde_json::json!([])),
   3536             ("/required_arguments", serde_json::json!([])),
   3537             ("/service_metadata_path", serde_json::json!("other")),
   3538             ("/service_metadata_fields", serde_json::json!([])),
   3539             ("/service_license_path", serde_json::json!("other")),
   3540             ("/source_lock_schema", serde_json::json!("other")),
   3541             ("/source_lock_definition", serde_json::json!("other")),
   3542             ("/artifact_contract_binding", serde_json::json!("other")),
   3543             ("/artifact_admission_contract", serde_json::json!("other")),
   3544             ("/supported_targets", serde_json::json!([])),
   3545             ("/candidate_binding", serde_json::json!("other")),
   3546             ("/lib_root_binding", serde_json::json!("other")),
   3547             ("/binary_admission", serde_json::json!("other")),
   3548             ("/oci_admission", serde_json::json!("other")),
   3549             ("/input_inventory", serde_json::json!([])),
   3550             ("/excluded_parent_owned_inputs", serde_json::json!([])),
   3551             ("/service_root_inventory", serde_json::json!([])),
   3552             ("/output_inventory", serde_json::json!([])),
   3553             ("/canonical_json", serde_json::json!("other")),
   3554             ("/checksum_format", serde_json::json!("other")),
   3555             ("/source_archive_format", serde_json::json!("other")),
   3556             ("/sbom_format", serde_json::json!("other")),
   3557             ("/license_evidence", serde_json::json!("other")),
   3558             ("/provenance_posture", serde_json::json!("other")),
   3559             ("/protected_material_scan_scope", serde_json::json!("other")),
   3560             ("/confidentiality_state", serde_json::json!("other")),
   3561             ("/source_cleanliness", serde_json::json!("other")),
   3562             ("/revision_stability", serde_json::json!("other")),
   3563             ("/no_protected_material", serde_json::json!(false)),
   3564             ("/maximums/text_input_bytes", serde_json::json!(1)),
   3565             ("/maximums/generated_document_bytes", serde_json::json!(1)),
   3566             ("/maximums/service_cargo_lock_bytes", serde_json::json!(1)),
   3567             ("/maximums/service_flake_lock_bytes", serde_json::json!(1)),
   3568             ("/maximums/binary_bytes", serde_json::json!(1)),
   3569             ("/maximums/source_archive_bytes", serde_json::json!(1)),
   3570             (
   3571                 "/maximums/source_archive_member_bytes",
   3572                 serde_json::json!(1),
   3573             ),
   3574             ("/maximums/source_archive_members", serde_json::json!(1)),
   3575             ("/maximums/oci_bytes", serde_json::json!(1)),
   3576             (
   3577                 "/maximums/artifact_scan_expanded_bytes",
   3578                 serde_json::json!(1),
   3579             ),
   3580             ("/maximums/cargo_metadata_bytes", serde_json::json!(1)),
   3581             ("/maximums/packages", serde_json::json!(1)),
   3582             ("/maximums/workspace_packages", serde_json::json!(1)),
   3583             ("/required_negative_vectors", serde_json::json!([])),
   3584             ("/negative_error_codes", serde_json::json!([])),
   3585         ] {
   3586             let mut drifted = canonical.clone();
   3587             *drifted.pointer_mut(pointer).expect("governed field") = replacement;
   3588             let decision = serde_json::from_value::<ReleaseDecision>(drifted)
   3589                 .expect("structurally valid drift");
   3590             assert_eq!(
   3591                 validate_decision(&decision),
   3592                 Err(ReleaseArtifactError::InvalidContract),
   3593                 "accepted drift at {pointer}"
   3594             );
   3595         }
   3596     }
   3597 
   3598     #[test]
   3599     fn exact_inventory_and_limits_are_literal() {
   3600         assert_eq!(INPUT_NAMES.len(), 6);
   3601         assert_eq!(OUTPUT_NAMES.len(), 20);
   3602         assert_eq!(MAX_TEXT_INPUT_BYTES, 1_048_576);
   3603         assert_eq!(MAX_GENERATED_DOCUMENT_BYTES, 16_777_216);
   3604         assert_eq!(MAX_SERVICE_CARGO_LOCK_BYTES, 16_777_216);
   3605         assert_eq!(MAX_SERVICE_FLAKE_LOCK_BYTES, 4_194_304);
   3606         assert_eq!(MAX_BINARY_BYTES, 536_870_912);
   3607         assert_eq!(MAX_SOURCE_ARCHIVE_BYTES, 1_073_741_824);
   3608         assert_eq!(MAX_SOURCE_ARCHIVE_MEMBER_BYTES, 67_108_864);
   3609         assert_eq!(MAX_SOURCE_ARCHIVE_MEMBERS, 65_536);
   3610         assert_eq!(MAX_OCI_BYTES, 2_147_483_648);
   3611         assert_eq!(MAX_METADATA_BYTES, 33_554_432);
   3612         assert_eq!(MAX_PACKAGES, 8_192);
   3613         assert_eq!(MAX_WORKSPACE_PACKAGES, 64);
   3614     }
   3615 
   3616     #[test]
   3617     fn supply_chain_documents_are_deterministic_and_complete() {
   3618         let root_id = "path+file:///fixture#fixture-service@0.1.0-alpha";
   3619         let dependency_id = "registry+https://example.invalid#index@0.1.0-alpha";
   3620         let cargo = CargoMetadata {
   3621             packages: vec![
   3622                 package(
   3623                     dependency_id,
   3624                     "dependency",
   3625                     Some("registry+https://github.com/rust-lang/crates.io-index"),
   3626                     Some(&"a".repeat(64)),
   3627                     Some("Apache-2.0"),
   3628                     false,
   3629                 ),
   3630                 package(root_id, "fixture-service", None, None, Some("MIT"), true),
   3631             ],
   3632             workspace_members: vec![root_id.to_owned()],
   3633             resolve: Some(CargoResolve {
   3634                 nodes: vec![
   3635                     CargoNode {
   3636                         id: dependency_id.to_owned(),
   3637                         dependencies: Vec::new(),
   3638                     },
   3639                     CargoNode {
   3640                         id: root_id.to_owned(),
   3641                         dependencies: vec![dependency_id.to_owned()],
   3642                     },
   3643                 ],
   3644             }),
   3645         };
   3646         let (sbom, notices, licenses) =
   3647             build_supply_chain_documents(&sample_metadata(), cargo).expect("documents");
   3648         let bytes = serde_json::to_vec(&sbom).expect("SBOM JSON");
   3649         assert_eq!(serde_json::to_vec(&sbom).expect("SBOM JSON"), bytes);
   3650         assert_eq!(sbom.bom_format, "CycloneDX");
   3651         assert_eq!(sbom.spec_version, "1.6");
   3652         assert_eq!(sbom.metadata.component.name, "fixture-service");
   3653         assert_eq!(sbom.components.len(), 1);
   3654         assert_eq!(sbom.dependencies.len(), 2);
   3655         assert!(notices.contains("Package: dependency 0.1.0-alpha"));
   3656         assert!(notices.contains("License: Apache-2.0"));
   3657         assert!(notices.contains("registry+https://github.com/rust-lang/crates.io-index"));
   3658         assert!(notices.contains("License-Text: LICENSE sha256:"));
   3659         assert!(licenses.contains("fixture dependency license text"));
   3660     }
   3661 
   3662     #[test]
   3663     fn license_documents_require_exact_bounded_nonempty_text_and_safe_filenames() {
   3664         build_supply_chain_documents(&sample_metadata(), sample_cargo_metadata()).unwrap();
   3665         for case in ["missing", "filename", "empty", "oversized"] {
   3666             let mut changed = sample_cargo_metadata();
   3667             let package = &mut changed.packages[1];
   3668             match case {
   3669                 "missing" => package.license_texts.clear(),
   3670                 "filename" => package.license_texts[0].filename = "../LICENSE".into(),
   3671                 "empty" => package.license_texts[0].text = " \n".into(),
   3672                 "oversized" => {
   3673                     package.license_texts[0].text =
   3674                         "x".repeat(MAX_GENERATED_DOCUMENT_BYTES as usize + 1)
   3675                 }
   3676                 _ => unreachable!(),
   3677             }
   3678             if let Some(text) = package.license_texts.first_mut() {
   3679                 text.sha256 = sha256_bytes(text.text.as_bytes());
   3680             }
   3681             assert!(
   3682                 matches!(
   3683                     build_supply_chain_documents(&sample_metadata(), changed),
   3684                     Err(ReleaseArtifactError::InvalidPackageInventory)
   3685                 ),
   3686                 "{case}"
   3687             );
   3688         }
   3689         let mut without_newline = sample_cargo_metadata();
   3690         let text = &mut without_newline.packages[1].license_texts[0];
   3691         text.text = "Exact license terms".into();
   3692         text.sha256 = sha256_bytes(text.text.as_bytes());
   3693         let (_, _, document) =
   3694             build_supply_chain_documents(&sample_metadata(), without_newline).unwrap();
   3695         assert!(document.ends_with("Exact license terms\n"));
   3696     }
   3697 
   3698     #[test]
   3699     fn private_or_incomplete_dependency_evidence_is_rejected() {
   3700         let root_id = "root";
   3701         for dependency in [
   3702             package(
   3703                 "dep",
   3704                 "dep",
   3705                 Some("git+ssh://git@github.com/private/repo"),
   3706                 Some(&"a".repeat(64)),
   3707                 Some("MIT"),
   3708                 false,
   3709             ),
   3710             package(
   3711                 "dep",
   3712                 "dep",
   3713                 Some("registry+https://github.com/rust-lang/crates.io-index"),
   3714                 Some(&"a".repeat(64)),
   3715                 None,
   3716                 false,
   3717             ),
   3718         ] {
   3719             let cargo = CargoMetadata {
   3720                 packages: vec![
   3721                     package(root_id, "fixture-service", None, None, Some("MIT"), true),
   3722                     dependency,
   3723                 ],
   3724                 workspace_members: vec![root_id.to_owned()],
   3725                 resolve: Some(CargoResolve {
   3726                     nodes: vec![
   3727                         CargoNode {
   3728                             id: root_id.to_owned(),
   3729                             dependencies: vec!["dep".to_owned()],
   3730                         },
   3731                         CargoNode {
   3732                             id: "dep".to_owned(),
   3733                             dependencies: Vec::new(),
   3734                         },
   3735                     ],
   3736                 }),
   3737             };
   3738             assert!(matches!(
   3739                 build_supply_chain_documents(&sample_metadata(), cargo),
   3740                 Err(ReleaseArtifactError::InvalidPackageInventory)
   3741             ));
   3742         }
   3743     }
   3744 
   3745     #[test]
   3746     fn package_metadata_rejects_each_independent_field_drift() {
   3747         let invalid = |package: CargoPackage, workspace_member| {
   3748             assert_eq!(
   3749                 validate_metadata_package(&package, workspace_member),
   3750                 Err(ReleaseArtifactError::InvalidPackageInventory)
   3751             );
   3752         };
   3753         for field in ["name", "version", "id"] {
   3754             for value in [
   3755                 String::new(),
   3756                 "x".repeat(MAX_TEXT_FIELD_BYTES + 1),
   3757                 "x\ny".into(),
   3758             ] {
   3759                 let mut candidate =
   3760                     package("root", "fixture-service", None, None, Some("MIT"), true);
   3761                 match field {
   3762                     "name" => candidate.name = value,
   3763                     "version" => candidate.version = value,
   3764                     "id" => candidate.id = value,
   3765                     _ => unreachable!(),
   3766                 }
   3767                 invalid(candidate, true);
   3768             }
   3769         }
   3770 
   3771         for license in [
   3772             Some(""),
   3773             Some("bad\nlicense"),
   3774             Some("-----BEGIN PRIVATE KEY-----"),
   3775         ] {
   3776             invalid(
   3777                 package("root", "fixture-service", None, None, license, true),
   3778                 true,
   3779             );
   3780         }
   3781         for source in [
   3782             Some(""),
   3783             Some("path+file:///private"),
   3784             Some("git+ssh://git@github.com/private/repo"),
   3785         ] {
   3786             invalid(
   3787                 package(
   3788                     "dep",
   3789                     "dep",
   3790                     source,
   3791                     Some(&"a".repeat(64)),
   3792                     Some("MIT"),
   3793                     false,
   3794                 ),
   3795                 false,
   3796             );
   3797         }
   3798         invalid(
   3799             package(
   3800                 "dep",
   3801                 "dep",
   3802                 None,
   3803                 Some(&"a".repeat(64)),
   3804                 Some("MIT"),
   3805                 false,
   3806             ),
   3807             false,
   3808         );
   3809         invalid(
   3810             package(
   3811                 "dep",
   3812                 "dep",
   3813                 Some("registry+https://github.com/rust-lang/crates.io-index"),
   3814                 Some(&"a".repeat(64)),
   3815                 None,
   3816                 false,
   3817             ),
   3818             false,
   3819         );
   3820         for checksum in ["a".repeat(63), "g".repeat(64)] {
   3821             invalid(
   3822                 package(
   3823                     "root",
   3824                     "fixture-service",
   3825                     None,
   3826                     Some(&checksum),
   3827                     Some("MIT"),
   3828                     true,
   3829                 ),
   3830                 true,
   3831             );
   3832         }
   3833     }
   3834 
   3835     #[test]
   3836     fn supply_chain_graph_rejects_each_independent_structural_drift() {
   3837         let invalid = |cargo| {
   3838             assert!(matches!(
   3839                 build_supply_chain_documents(&sample_metadata(), cargo),
   3840                 Err(ReleaseArtifactError::InvalidPackageInventory)
   3841             ));
   3842         };
   3843 
   3844         let mut cargo = sample_cargo_metadata();
   3845         cargo.packages.clear();
   3846         invalid(cargo);
   3847         let mut cargo = sample_cargo_metadata();
   3848         cargo.workspace_members.clear();
   3849         invalid(cargo);
   3850         let mut cargo = sample_cargo_metadata();
   3851         cargo.packages[0].version = "0.2.0".into();
   3852         invalid(cargo);
   3853         let mut cargo = sample_cargo_metadata();
   3854         cargo.packages[0].targets.clear();
   3855         invalid(cargo);
   3856         let mut cargo = sample_cargo_metadata();
   3857         cargo.packages[0].name = "other".into();
   3858         invalid(cargo);
   3859         let mut cargo = sample_cargo_metadata();
   3860         cargo.packages.push(package(
   3861             "second-root",
   3862             "fixture-service",
   3863             None,
   3864             None,
   3865             Some("MIT"),
   3866             true,
   3867         ));
   3868         cargo.workspace_members.push("second-root".into());
   3869         invalid(cargo);
   3870         let mut cargo = sample_cargo_metadata();
   3871         cargo.packages[1].id = cargo.packages[0].id.clone();
   3872         invalid(cargo);
   3873         let mut cargo = sample_cargo_metadata();
   3874         cargo.workspace_members.push("missing".into());
   3875         invalid(cargo);
   3876         let mut cargo = sample_cargo_metadata();
   3877         cargo.resolve = None;
   3878         invalid(cargo);
   3879         let mut cargo = sample_cargo_metadata();
   3880         cargo.resolve.as_mut().expect("resolve").nodes.clear();
   3881         invalid(cargo);
   3882         let mut cargo = sample_cargo_metadata();
   3883         let duplicate = cargo.resolve.as_ref().expect("resolve").nodes[0].id.clone();
   3884         cargo.resolve.as_mut().expect("resolve").nodes[1].id = duplicate;
   3885         invalid(cargo);
   3886         let mut cargo = sample_cargo_metadata();
   3887         cargo.resolve.as_mut().expect("resolve").nodes[0].id = "missing".into();
   3888         invalid(cargo);
   3889         let mut cargo = sample_cargo_metadata();
   3890         cargo.resolve.as_mut().expect("resolve").nodes[1]
   3891             .dependencies
   3892             .push("missing".into());
   3893         invalid(cargo);
   3894 
   3895         let root_id = "path+file:///fixture#fixture-service@0.1.0-alpha";
   3896         let root_only = CargoMetadata {
   3897             packages: vec![package(
   3898                 root_id,
   3899                 "fixture-service",
   3900                 None,
   3901                 None,
   3902                 Some("MIT"),
   3903                 true,
   3904             )],
   3905             workspace_members: vec![root_id.into()],
   3906             resolve: Some(CargoResolve {
   3907                 nodes: vec![CargoNode {
   3908                     id: root_id.into(),
   3909                     dependencies: Vec::new(),
   3910                 }],
   3911             }),
   3912         };
   3913         let (_, notices, licenses) =
   3914             build_supply_chain_documents(&sample_metadata(), root_only).expect("root-only graph");
   3915         assert!(notices.contains("No third-party Cargo packages are present."));
   3916         assert!(licenses.contains("No third-party Cargo packages are present."));
   3917     }
   3918 
   3919     #[test]
   3920     fn file_admission_predicates_reject_each_independent_drift() {
   3921         let root = TempDir::new().expect("file fixture");
   3922         let regular = root.path().join("regular");
   3923         write_file(&regular, b"bytes");
   3924         let empty = root.path().join("empty");
   3925         write_file(&empty, b"");
   3926         let oversized = root.path().join("oversized");
   3927         fs::File::create(&oversized)
   3928             .and_then(|file| file.set_len(6))
   3929             .expect("sparse file");
   3930         assert!(matches!(
   3931             hash_regular(root.path(), 5),
   3932             Err(ReleaseArtifactError::InvalidInputArtifact)
   3933         ));
   3934         assert!(matches!(
   3935             hash_regular(&oversized, 5),
   3936             Err(ReleaseArtifactError::InvalidInputArtifact)
   3937         ));
   3938         assert!(matches!(
   3939             validate_regular_input(&empty, 5),
   3940             Err(ReleaseArtifactError::InvalidInputArtifact)
   3941         ));
   3942         assert!(matches!(
   3943             validate_regular_input(root.path(), 5),
   3944             Err(ReleaseArtifactError::InvalidInputArtifact)
   3945         ));
   3946         assert!(matches!(
   3947             validate_regular_input(&oversized, 5),
   3948             Err(ReleaseArtifactError::InvalidInputArtifact)
   3949         ));
   3950         assert_eq!(
   3951             validate_absolute_directory(&regular, ReleaseArtifactError::InvalidInputRoot),
   3952             Err(ReleaseArtifactError::InvalidInputRoot)
   3953         );
   3954         assert_eq!(
   3955             validate_absolute_directory(
   3956                 Path::new("relative"),
   3957                 ReleaseArtifactError::InvalidInputRoot
   3958             ),
   3959             Err(ReleaseArtifactError::InvalidInputRoot)
   3960         );
   3961         assert_eq!(
   3962             output_maximum("unknown"),
   3963             Err(ReleaseArtifactError::GenerationFailure)
   3964         );
   3965 
   3966         #[cfg(unix)]
   3967         {
   3968             let symlink = root.path().join("symlink");
   3969             std::os::unix::fs::symlink(&regular, &symlink).expect("symlink");
   3970             assert!(matches!(
   3971                 hash_regular(&symlink, 5),
   3972                 Err(ReleaseArtifactError::InvalidInputArtifact)
   3973             ));
   3974             assert!(matches!(
   3975                 validate_regular_input(&symlink, 5),
   3976                 Err(ReleaseArtifactError::InvalidInputArtifact)
   3977             ));
   3978             assert_eq!(
   3979                 validate_absolute_directory(&symlink, ReleaseArtifactError::InvalidInputRoot),
   3980                 Err(ReleaseArtifactError::InvalidInputRoot)
   3981             );
   3982         }
   3983     }
   3984 
   3985     #[test]
   3986     fn release_metadata_and_text_admission_reject_each_field_drift() {
   3987         let root = TempDir::new().expect("metadata fixture");
   3988         let canonical = r#"[workspace.metadata.radroots.service_release]
   3989 service = "fixture_service"
   3990 service_package = "fixture-service"
   3991 binary_name = "fixture-service"
   3992 version = "0.1.0-alpha"
   3993 "#;
   3994         for (from, to) in [
   3995             ("fixture_service", "Fixture"),
   3996             (
   3997                 "service_package = \"fixture-service\"",
   3998                 "service_package = \"fixture--service\"",
   3999             ),
   4000             (
   4001                 "binary_name = \"fixture-service\"",
   4002                 "binary_name = \"fixture--service\"",
   4003             ),
   4004             ("version = \"0.1.0-alpha\"", "version = \"invalid\""),
   4005         ] {
   4006             write_file(
   4007                 &root.path().join("Cargo.toml"),
   4008                 canonical.replacen(from, to, 1).as_bytes(),
   4009             );
   4010             assert!(matches!(
   4011                 read_release_metadata(root.path()),
   4012                 Err(ReleaseArtifactError::InvalidServiceMetadata)
   4013             ));
   4014         }
   4015         write_file(
   4016             &root.path().join("Cargo.toml"),
   4017             canonical
   4018                 .replacen("0.1.0-alpha", &"a".repeat(129), 1)
   4019                 .as_bytes(),
   4020         );
   4021         assert!(matches!(
   4022             read_release_metadata(root.path()),
   4023             Err(ReleaseArtifactError::InvalidServiceMetadata)
   4024         ));
   4025 
   4026         for (name, bytes) in [
   4027             ("plain.txt", b"contains\0nul".as_slice()),
   4028             ("config.schema.json", b"not json".as_slice()),
   4029             ("config.example.toml", b"not = [toml".as_slice()),
   4030         ] {
   4031             let path = root.path().join(name);
   4032             write_file(&path, bytes);
   4033             assert_eq!(
   4034                 validate_text_artifact(&path, name),
   4035                 Err(ReleaseArtifactError::InvalidInputArtifact)
   4036             );
   4037         }
   4038         assert_eq!(
   4039             write_generated(&root.path().join("empty-generated"), b""),
   4040             Err(ReleaseArtifactError::GenerationFailure)
   4041         );
   4042     }
   4043 
   4044     #[test]
   4045     fn output_scope_remote_and_inventory_reject_each_drift() {
   4046         let root = TempDir::new().expect("output fixture");
   4047         let service = root.path().join("service");
   4048         let input = root.path().join("input");
   4049         let output_parent = root.path().join("output");
   4050         fs::create_dir(&service).expect("service");
   4051         fs::create_dir(&input).expect("input");
   4052         fs::create_dir(&output_parent).expect("output");
   4053         assert_eq!(
   4054             validate_output_parent(Path::new("relative"), &service, &input),
   4055             Err(ReleaseArtifactError::InvalidOutputRoot)
   4056         );
   4057         assert_eq!(
   4058             validate_output_parent(root.path(), &service, &input),
   4059             Err(ReleaseArtifactError::InvalidOutputRoot)
   4060         );
   4061         let file_output = output_parent.join("file");
   4062         write_file(&file_output, b"file");
   4063         assert_eq!(
   4064             validate_output_parent(&file_output, &service, &input),
   4065             Err(ReleaseArtifactError::InvalidOutputRoot)
   4066         );
   4067 
   4068         let inventory = root.path().join("inventory");
   4069         fs::create_dir(&inventory).expect("inventory");
   4070         fs::create_dir(inventory.join("directory-entry")).expect("directory entry");
   4071         assert_eq!(
   4072             directory_inventory(&inventory, ReleaseArtifactError::InvalidInputRoot),
   4073             Err(ReleaseArtifactError::InvalidInputRoot)
   4074         );
   4075         fs::remove_dir(inventory.join("directory-entry")).expect("remove entry");
   4076         for index in 0..=OUTPUT_NAMES.len() {
   4077             write_file(&inventory.join(format!("file-{index}")), b"x");
   4078         }
   4079         assert_eq!(
   4080             directory_inventory(&inventory, ReleaseArtifactError::InvalidInputRoot),
   4081             Err(ReleaseArtifactError::InvalidInputRoot)
   4082         );
   4083 
   4084         write_file(&service.join("fixture"), b"fixture");
   4085         initialize_git(&service, "https://example.invalid/service");
   4086         assert_eq!(
   4087             git_remote(&service),
   4088             Err(ReleaseArtifactError::InvalidServiceRoot)
   4089         );
   4090         git(
   4091             &service,
   4092             &[
   4093                 "remote",
   4094                 "set-url",
   4095                 "origin",
   4096                 "ssh://git@github.com/user/repo\nbad",
   4097             ],
   4098         );
   4099         assert_eq!(
   4100             git_remote(&service),
   4101             Err(ReleaseArtifactError::InvalidServiceRoot)
   4102         );
   4103         git(
   4104             &service,
   4105             &[
   4106                 "remote",
   4107                 "set-url",
   4108                 "origin",
   4109                 &format!("https://github.com/{}", "a".repeat(MAX_TEXT_FIELD_BYTES)),
   4110             ],
   4111         );
   4112         assert_eq!(
   4113             git_remote(&service),
   4114             Err(ReleaseArtifactError::InvalidServiceRoot)
   4115         );
   4116     }
   4117 
   4118     #[cfg(unix)]
   4119     #[test]
   4120     fn snapshot_backed_inventory_rejects_file_and_root_mode_races() {
   4121         use std::os::unix::fs::PermissionsExt as _;
   4122 
   4123         let directory = TempDir::new().expect("inventory fixture");
   4124         let root = directory
   4125             .path()
   4126             .canonicalize()
   4127             .expect("canonical inventory fixture");
   4128         set_directory_mode(&root).expect("directory mode");
   4129         let file = root.join("LICENSE-MIT");
   4130         write_file(&file, b"license\n");
   4131         set_file_mode(&file).expect("file mode");
   4132 
   4133         assert_eq!(
   4134             inventory_records_impl(&root, || {
   4135                 fs::set_permissions(&file, fs::Permissions::from_mode(0o600))
   4136                     .expect("change file mode");
   4137             }),
   4138             Err(ReleaseArtifactError::GenerationFailure)
   4139         );
   4140         set_file_mode(&file).expect("restore file mode");
   4141         assert_eq!(
   4142             inventory_records_impl(&root, || {
   4143                 fs::set_permissions(&root, fs::Permissions::from_mode(0o700))
   4144                     .expect("change root mode");
   4145             }),
   4146             Err(ReleaseArtifactError::GenerationFailure)
   4147         );
   4148         set_directory_mode(&root).expect("restore directory mode");
   4149         fs::set_permissions(&file, fs::Permissions::from_mode(0o4644))
   4150             .expect("add file special mode bit");
   4151         assert_eq!(
   4152             inventory_records(&root),
   4153             Err(ReleaseArtifactError::GenerationFailure)
   4154         );
   4155         set_file_mode(&file).expect("restore file mode");
   4156         fs::set_permissions(&root, fs::Permissions::from_mode(0o1755))
   4157             .expect("add directory special mode bit");
   4158         assert_eq!(
   4159             inventory_records(&root),
   4160             Err(ReleaseArtifactError::GenerationFailure)
   4161         );
   4162     }
   4163 
   4164     #[test]
   4165     fn remaining_release_boundaries_fail_closed() {
   4166         let fixture = ReleaseFixture::new();
   4167         assert_eq!(
   4168             fixture.check(&fixture.output_a),
   4169             Err(ReleaseArtifactError::StaleOutput)
   4170         );
   4171 
   4172         let source_lock = ServiceSourceLockV4::from_canonical_bytes(
   4173             &fs::read(fixture.service.join(LOCK_FILENAME)).expect("source lock"),
   4174         )
   4175         .expect("source lock");
   4176         fs::write(fixture.service.join("flake.lock"), b"different").expect("flake drift");
   4177         assert_eq!(
   4178             validate_source_lock_files(&fixture.service, &source_lock),
   4179             Err(ReleaseArtifactError::InvalidSourceLock)
   4180         );
   4181 
   4182         let mut packages = sample_cargo_metadata();
   4183         packages.packages = (0..=MAX_PACKAGES)
   4184             .map(|index| {
   4185                 package(
   4186                     &format!("id-{index}"),
   4187                     "dep",
   4188                     None,
   4189                     None,
   4190                     Some("MIT"),
   4191                     false,
   4192                 )
   4193             })
   4194             .collect();
   4195         assert!(matches!(
   4196             build_supply_chain_documents(&sample_metadata(), packages),
   4197             Err(ReleaseArtifactError::InvalidPackageInventory)
   4198         ));
   4199         let mut workspace = sample_cargo_metadata();
   4200         workspace.workspace_members = (0..=MAX_WORKSPACE_PACKAGES)
   4201             .map(|index| format!("member-{index}"))
   4202             .collect();
   4203         assert!(matches!(
   4204             build_supply_chain_documents(&sample_metadata(), workspace),
   4205             Err(ReleaseArtifactError::InvalidPackageInventory)
   4206         ));
   4207         for (target_name, kind) in [("other", "bin"), ("fixture-service", "lib")] {
   4208             let mut cargo = sample_cargo_metadata();
   4209             cargo.packages[0].targets = vec![CargoTarget {
   4210                 name: target_name.into(),
   4211                 kind: vec![kind.into()],
   4212             }];
   4213             assert!(matches!(
   4214                 build_supply_chain_documents(&sample_metadata(), cargo),
   4215                 Err(ReleaseArtifactError::InvalidPackageInventory)
   4216             ));
   4217         }
   4218         let mut outside_workspace = sample_cargo_metadata();
   4219         outside_workspace.workspace_members = vec!["other".into()];
   4220         assert!(matches!(
   4221             build_supply_chain_documents(&sample_metadata(), outside_workspace),
   4222             Err(ReleaseArtifactError::InvalidPackageInventory)
   4223         ));
   4224 
   4225         let scope = TempDir::new().expect("scope fixture");
   4226         let service = scope.path().join("service");
   4227         let input_parent = TempDir::new().expect("input scope");
   4228         let input = input_parent.path().join("input");
   4229         fs::create_dir(&service).expect("service");
   4230         fs::create_dir(&input).expect("input");
   4231         assert_eq!(
   4232             validate_output_parent(&scope.path().join("bad\\name"), &service, &input),
   4233             Err(ReleaseArtifactError::InvalidOutputRoot)
   4234         );
   4235         assert_eq!(
   4236             validate_output_parent(input_parent.path(), &service, &input),
   4237             Err(ReleaseArtifactError::InvalidOutputRoot)
   4238         );
   4239         #[cfg(unix)]
   4240         {
   4241             let foreign = scope.path().join("foreign");
   4242             fs::create_dir(&foreign).expect("foreign");
   4243             let output = scope.path().join("output-link");
   4244             std::os::unix::fs::symlink(&foreign, &output).expect("output symlink");
   4245             assert_eq!(
   4246                 validate_output_parent(&output, &service, &input),
   4247                 Err(ReleaseArtifactError::InvalidOutputRoot)
   4248             );
   4249         }
   4250 
   4251         write_file(&service.join("tracked"), b"tracked");
   4252         initialize_git(&service, "https://github.com/radrootslabs/service");
   4253         let child = service.join("child");
   4254         fs::create_dir(&child).expect("child");
   4255         assert_eq!(
   4256             validate_git_root(&child),
   4257             Err(ReleaseArtifactError::InvalidServiceRoot)
   4258         );
   4259         write_file(&service.join("untracked"), b"dirty");
   4260         assert_eq!(
   4261             validate_clean_git(&service),
   4262             Err(ReleaseArtifactError::DirtyServiceSource)
   4263         );
   4264 
   4265         assert_eq!(
   4266             write_generated(
   4267                 &scope.path().join("oversized-generated"),
   4268                 &vec![b'x'; MAX_GENERATED_DOCUMENT_BYTES as usize + 1]
   4269             ),
   4270             Err(ReleaseArtifactError::GenerationFailure)
   4271         );
   4272     }
   4273 
   4274     #[test]
   4275     fn low_level_release_admission_and_comparison_branches_are_qualified() {
   4276         let root = TempDir::new().expect("low-level release fixture");
   4277         let regular = root.path().join("regular");
   4278         write_file(&regular, b"same");
   4279         assert_eq!(
   4280             read_bounded_regular(&regular, 4, ReleaseArtifactError::InvalidInputArtifact)
   4281                 .expect("bounded regular file"),
   4282             b"same"
   4283         );
   4284         let directory = root.path().join("directory");
   4285         fs::create_dir(&directory).expect("directory fixture");
   4286         assert_eq!(
   4287             read_bounded_regular(&directory, 4, ReleaseArtifactError::InvalidInputArtifact),
   4288             Err(ReleaseArtifactError::InvalidInputArtifact)
   4289         );
   4290         let oversized = root.path().join("oversized");
   4291         write_file(&oversized, b"12345");
   4292         assert_eq!(
   4293             read_bounded_regular(&oversized, 4, ReleaseArtifactError::InvalidInputArtifact),
   4294             Err(ReleaseArtifactError::InvalidInputArtifact)
   4295         );
   4296 
   4297         #[cfg(unix)]
   4298         {
   4299             use std::os::unix::fs::{MetadataExt as _, PermissionsExt as _};
   4300 
   4301             let symlink = root.path().join("regular-link");
   4302             std::os::unix::fs::symlink(&regular, &symlink).expect("regular symlink");
   4303             assert_eq!(
   4304                 read_bounded_regular(&symlink, 4, ReleaseArtifactError::InvalidInputArtifact),
   4305                 Err(ReleaseArtifactError::InvalidInputArtifact)
   4306             );
   4307 
   4308             let expected = fs::symlink_metadata(&regular).expect("regular metadata");
   4309             assert_eq!(
   4310                 validate_unchanged_input(&symlink, &expected),
   4311                 Err(ReleaseArtifactError::InvalidInputArtifact)
   4312             );
   4313             assert_eq!(
   4314                 validate_unchanged_input(&directory, &expected),
   4315                 Err(ReleaseArtifactError::InvalidInputArtifact)
   4316             );
   4317 
   4318             let other = root.path().join("other");
   4319             write_file(&other, b"same");
   4320             assert_eq!(
   4321                 validate_unchanged_input(&other, &expected),
   4322                 Err(ReleaseArtifactError::InvalidInputArtifact)
   4323             );
   4324 
   4325             let device_metadata = fs::symlink_metadata("/dev/null").expect("device metadata");
   4326             assert_ne!(device_metadata.dev(), expected.dev());
   4327             assert_eq!(
   4328                 validate_unchanged_input(&regular, &device_metadata),
   4329                 Err(ReleaseArtifactError::InvalidInputArtifact)
   4330             );
   4331 
   4332             let same_inode = fs::symlink_metadata(&regular).expect("same-inode metadata");
   4333             write_file(&regular, b"changed length");
   4334             assert_eq!(
   4335                 validate_unchanged_input(&regular, &same_inode),
   4336                 Err(ReleaseArtifactError::InvalidInputArtifact)
   4337             );
   4338 
   4339             let inventory = root.path().join("symlink-inventory");
   4340             fs::create_dir(&inventory).expect("symlink inventory");
   4341             std::os::unix::fs::symlink(&other, inventory.join("entry")).expect("inventory symlink");
   4342             assert_eq!(
   4343                 directory_inventory(&inventory, ReleaseArtifactError::InvalidInputRoot),
   4344                 Err(ReleaseArtifactError::InvalidInputRoot)
   4345             );
   4346 
   4347             let mode_file = root.path().join("mode-file");
   4348             write_file(&mode_file, b"mode");
   4349             fs::set_permissions(&mode_file, fs::Permissions::from_mode(0o600))
   4350                 .expect("set invalid file mode");
   4351             assert_eq!(
   4352                 validate_file_mode(&mode_file),
   4353                 Err(ReleaseArtifactError::StaleOutput)
   4354             );
   4355             fs::set_permissions(&directory, fs::Permissions::from_mode(0o700))
   4356                 .expect("set invalid directory mode");
   4357             assert_eq!(
   4358                 validate_directory_mode(&directory),
   4359                 Err(ReleaseArtifactError::StaleOutput)
   4360             );
   4361         }
   4362 
   4363         let incomplete = root.path().join("incomplete-output");
   4364         fs::create_dir(&incomplete).expect("incomplete output");
   4365         write_file(&incomplete.join("LICENSE-MIT"), b"x");
   4366         assert_eq!(
   4367             validate_exact_output_inventory(&incomplete),
   4368             Err(ReleaseArtifactError::GenerationFailure)
   4369         );
   4370 
   4371         let expected = root.path().join("expected-output");
   4372         let actual = root.path().join("actual-output");
   4373         fs::create_dir(&expected).expect("expected output");
   4374         fs::create_dir(&actual).expect("actual output");
   4375         set_directory_mode(&expected).expect("expected directory mode");
   4376         set_directory_mode(&actual).expect("actual directory mode");
   4377         for name in OUTPUT_NAMES {
   4378             write_file(&expected.join(name), b"a");
   4379             write_file(&actual.join(name), b"a");
   4380             set_file_mode(&expected.join(name)).expect("expected file mode");
   4381             set_file_mode(&actual.join(name)).expect("actual file mode");
   4382         }
   4383         compare_output(&expected, &actual).expect("matching output");
   4384         let records = inventory_records(&actual).expect("actual records");
   4385         validate_output_records(&actual, &records).expect("matching records");
   4386         write_file(&actual.join("LICENSE-MIT"), b"b");
   4387         set_file_mode(&actual.join("LICENSE-MIT")).expect("restored file mode");
   4388         assert_eq!(
   4389             compare_output(&expected, &actual),
   4390             Err(ReleaseArtifactError::StaleOutput)
   4391         );
   4392 
   4393         let mut oversized_stdout = Command::new("sh");
   4394         oversized_stdout.args(["-c", "printf 12345"]);
   4395         assert_eq!(command_stdout(&mut oversized_stdout, 4), Err(()));
   4396         let mut failed_stdout = Command::new("sh");
   4397         failed_stdout.args(["-c", "exit 7"]);
   4398         assert_eq!(command_stdout(&mut failed_stdout, 4), Err(()));
   4399     }
   4400 
   4401     #[test]
   4402     fn release_service_and_workspace_binding_fail_closed() {
   4403         let fixture = ReleaseFixture::new();
   4404         let mismatched = fs::read_to_string(fixture.service.join(LOCK_FILENAME))
   4405             .expect("source lock")
   4406             .replace("service = \"myc\"", "service = \"rhi\"");
   4407         write_file(&fixture.service.join(LOCK_FILENAME), mismatched.as_bytes());
   4408         git(&fixture.service, &["add", LOCK_FILENAME]);
   4409         git(
   4410             &fixture.service,
   4411             &["commit", "--quiet", "-m", "mismatched service lock"],
   4412         );
   4413         assert_eq!(
   4414             fixture.check(&fixture.output_a),
   4415             Err(ReleaseArtifactError::InvalidSourceLock)
   4416         );
   4417 
   4418         let mut cargo = sample_cargo_metadata();
   4419         let dependency_id = cargo.packages[1].id.clone();
   4420         cargo.packages[0].source =
   4421             Some("registry+https://github.com/rust-lang/crates.io-index".into());
   4422         cargo.packages[0].checksum = Some("a".repeat(64));
   4423         cargo.workspace_members = vec![dependency_id];
   4424         assert!(matches!(
   4425             build_supply_chain_documents(&sample_metadata(), cargo),
   4426             Err(ReleaseArtifactError::InvalidPackageInventory)
   4427         ));
   4428     }
   4429 
   4430     #[test]
   4431     fn identifier_predicates_reject_each_independent_boundary() {
   4432         for value in ["", "1service", "service_", "service__name", "service-name"] {
   4433             assert!(!valid_snake_identifier(value), "{value}");
   4434         }
   4435         assert!(!valid_snake_identifier(&"a".repeat(129)));
   4436         for value in ["", "1service", "service-", "service--name", "service_name"] {
   4437             assert!(!valid_kebab_identifier(value), "{value}");
   4438         }
   4439         assert!(!valid_kebab_identifier(&"a".repeat(129)));
   4440         assert!(!valid_metadata_text(""));
   4441         assert!(!valid_metadata_text(&"a".repeat(MAX_TEXT_FIELD_BYTES + 1)));
   4442         assert!(!valid_metadata_text("bad\rvalue"));
   4443         assert!(!valid_metadata_text("-----BEGIN PRIVATE KEY-----"));
   4444         assert!(!valid_public_source("registry+http://example.invalid"));
   4445         assert!(!valid_public_source(
   4446             "registry+https://user@github.com/private"
   4447         ));
   4448         assert!(!valid_lower_hex("a", 2));
   4449         assert!(!valid_lower_hex("ag", 2));
   4450     }
   4451 
   4452     #[test]
   4453     fn binary_archive_is_reproducible_and_metadata_is_fixed() {
   4454         let root = TempDir::new().expect("archive fixture");
   4455         let root = root
   4456             .path()
   4457             .canonicalize()
   4458             .expect("canonical archive fixture");
   4459         let source = root.join("service");
   4460         let first = root.join("first.tar.gz");
   4461         let second = root.join("second.tar.gz");
   4462         write_file(&source, b"exact executable bytes");
   4463         create_binary_archive(&source, &first, "fixture-service", 1_700_000_000)
   4464             .expect("first archive");
   4465         create_binary_archive(&source, &second, "fixture-service", 1_700_000_000)
   4466             .expect("second archive");
   4467         assert_eq!(
   4468             fs::read(&first).expect("first"),
   4469             fs::read(&second).expect("second")
   4470         );
   4471 
   4472         let decoder = flate2::read::GzDecoder::new(fs::File::open(first).expect("archive"));
   4473         let mut archive = tar::Archive::new(decoder);
   4474         let mut entries = archive.entries().expect("entries");
   4475         let mut entry = entries.next().expect("one entry").expect("entry");
   4476         assert_eq!(
   4477             entry.path().expect("path").as_ref(),
   4478             Path::new("bin/fixture-service")
   4479         );
   4480         assert_eq!(entry.header().mode().expect("mode"), 0o755);
   4481         assert_eq!(entry.header().mtime().expect("mtime"), 1_700_000_000);
   4482         let mut bytes = Vec::new();
   4483         entry.read_to_end(&mut bytes).expect("archive bytes");
   4484         assert_eq!(bytes, b"exact executable bytes");
   4485         assert!(entries.next().is_none());
   4486     }
   4487 
   4488     #[test]
   4489     fn full_artifact_set_is_reproducible_immutable_and_verifiable() {
   4490         let fixture = ReleaseFixture::new();
   4491         fixture.write(&fixture.output_a).expect("first release");
   4492         fixture.write(&fixture.output_b).expect("second release");
   4493         fixture.check(&fixture.output_a).expect("check release");
   4494         assert_eq!(
   4495             directory_inventory(&fixture.output_a, ReleaseArtifactError::StaleOutput)
   4496                 .expect("first inventory"),
   4497             OUTPUT_NAMES.into_iter().map(str::to_owned).collect()
   4498         );
   4499         for name in OUTPUT_NAMES {
   4500             assert_eq!(
   4501                 fs::read(fixture.output_a.join(name)).expect("first output"),
   4502                 fs::read(fixture.output_b.join(name)).expect("second output"),
   4503                 "{name}"
   4504             );
   4505         }
   4506 
   4507         let manifest: serde_json::Value = serde_json::from_slice(
   4508             &fs::read(fixture.output_a.join("artifact-manifest.v2.json")).expect("manifest"),
   4509         )
   4510         .expect("manifest JSON");
   4511         assert_eq!(manifest["rust_version"], "1.99.0");
   4512         let produced_lock = ServiceSourceLockV4::from_canonical_bytes(
   4513             &fs::read(fixture.output_a.join(LOCK_FILENAME)).expect("output source lock"),
   4514         )
   4515         .expect("current canonical output");
   4516         assert!(
   4517             std::str::from_utf8(produced_lock.canonical_bytes())
   4518                 .expect("UTF-8")
   4519                 .contains("material = \"bound\"")
   4520         );
   4521         let sums =
   4522             fs::read_to_string(fixture.output_a.join("SHA256SUMS")).expect("checksum inventory");
   4523         let mut prior = "";
   4524         let mut count = 0;
   4525         for line in sums.lines() {
   4526             let (digest, name) = line.split_once("  ").expect("checksum line");
   4527             assert!(prior < name);
   4528             assert!(valid_lower_hex(digest, 64));
   4529             assert_eq!(
   4530                 digest,
   4531                 hash_regular(
   4532                     &fixture.output_a.join(name),
   4533                     output_maximum(name).expect("known output")
   4534                 )
   4535                 .expect("artifact hash")
   4536                 .sha256
   4537             );
   4538             prior = name;
   4539             count += 1;
   4540         }
   4541         assert_eq!(count, OUTPUT_NAMES.len() - 1);
   4542 
   4543         for name in [
   4544             "artifact-manifest.v2.json",
   4545             "artifact-scan.v1.json",
   4546             "oci-image.v1.json",
   4547             "provenance.intoto.jsonl",
   4548             "sbom.cdx.json",
   4549             "source-archives.v3.json",
   4550         ] {
   4551             let bytes = fs::read(fixture.output_a.join(name)).expect("JSON output");
   4552             assert_eq!(bytes.last(), Some(&b'\n'));
   4553             assert_eq!(bytes.iter().filter(|byte| **byte == b'\n').count(), 1);
   4554             serde_json::from_slice::<serde_json::Value>(&bytes).expect("valid JSON");
   4555         }
   4556         let provenance: serde_json::Value = serde_json::from_slice(
   4557             &fs::read(fixture.output_a.join("provenance.intoto.jsonl")).expect("provenance"),
   4558         )
   4559         .expect("provenance JSON");
   4560         assert_eq!(provenance["_type"], "https://in-toto.io/Statement/v1");
   4561         assert_eq!(
   4562             provenance["predicateType"],
   4563             "https://slsa.dev/provenance/v1"
   4564         );
   4565         assert_eq!(
   4566             provenance["predicate"]["buildDefinition"]["externalParameters"]["candidate_digest"],
   4567             format!("sha256:{}", "a".repeat(64))
   4568         );
   4569 
   4570         write_file(
   4571             &fixture.output_a.join("config.example.toml"),
   4572             b"tampered = true\n",
   4573         );
   4574         assert_eq!(
   4575             fixture.check(&fixture.output_a),
   4576             Err(ReleaseArtifactError::StaleOutput)
   4577         );
   4578         assert_eq!(
   4579             fixture.write(&fixture.output_a),
   4580             Err(ReleaseArtifactError::StaleOutput)
   4581         );
   4582     }
   4583 
   4584     #[test]
   4585     fn bound_nix_inputs_are_required_and_preserved_without_qualification_claim() {
   4586         let fixture = ReleaseFixture::new();
   4587         fixture
   4588             .write(&fixture.output_a)
   4589             .expect("bound-input preparation");
   4590 
   4591         let document: serde_json::Value = serde_json::from_slice(
   4592             &fs::read(fixture.output_a.join("source-archives.v3.json"))
   4593                 .expect("source archive document"),
   4594         )
   4595         .expect("source archive JSON");
   4596         assert_eq!(document["schema"], "radroots.service.source-archives.v3");
   4597         assert_eq!(document["contract_version"], 3);
   4598         assert!(valid_lower_hex(
   4599             document["flake_lock_sha256"]
   4600                 .as_str()
   4601                 .expect("flake digest"),
   4602             64
   4603         ));
   4604 
   4605         let lock = ServiceSourceLockV4::from_canonical_bytes(
   4606             &fs::read(fixture.service.join(LOCK_FILENAME)).expect("source lock"),
   4607         )
   4608         .expect("valid source lock");
   4609         for name in ["flake.nix", "flake.lock"] {
   4610             let path = fixture.service.join(name);
   4611             let original = fs::read(&path).expect("bound Nix file");
   4612             fs::remove_file(&path).expect("remove bound Nix file");
   4613             assert_eq!(
   4614                 validate_source_lock_files(&fixture.service, &lock),
   4615                 Err(ReleaseArtifactError::InvalidSourceLock),
   4616                 "accepted missing bound-Nix file {name}"
   4617             );
   4618             write_file(&path, &original);
   4619         }
   4620         write_file(
   4621             &fixture.service.join(PREDECESSOR_LOCK_FILENAMES[2]),
   4622             b"unexpected",
   4623         );
   4624         assert_eq!(
   4625             validate_source_lock_files(&fixture.service, &lock),
   4626             Err(ReleaseArtifactError::InvalidSourceLock)
   4627         );
   4628     }
   4629 
   4630     #[test]
   4631     fn protected_text_and_invalid_inventory_fail_closed() {
   4632         let fixture = ReleaseFixture::new();
   4633         let mut secret = b"-----BEGIN PRIVATE KEY-----\n".to_vec();
   4634         secret.extend_from_slice(&[b'A'; 48]);
   4635         secret.extend_from_slice(b"\n-----END PRIVATE KEY-----\n");
   4636         write_file(&fixture.input.join("config.example.toml"), &secret);
   4637         assert_eq!(
   4638             fixture.write(&fixture.output_a),
   4639             Err(ReleaseArtifactError::ProtectedMaterialDetected)
   4640         );
   4641         write_file(
   4642             &fixture.input.join("config.example.toml"),
   4643             b"enabled = true\n",
   4644         );
   4645         write_file(&fixture.input.join("unexpected"), b"unexpected\n");
   4646         assert_eq!(
   4647             fixture.write(&fixture.output_a),
   4648             Err(ReleaseArtifactError::InvalidInputRoot)
   4649         );
   4650     }
   4651 
   4652     #[test]
   4653     fn source_lock_and_source_archive_drift_fail_closed() {
   4654         let fixture = ReleaseFixture::new();
   4655         write_file(
   4656             &fixture.service.join("Cargo.lock"),
   4657             b"version = 4\n# changed after source lock\n",
   4658         );
   4659         git(&fixture.service, &["add", "Cargo.lock"]);
   4660         git(
   4661             &fixture.service,
   4662             &["commit", "--quiet", "-m", "change lock"],
   4663         );
   4664         assert_eq!(
   4665             fixture.write(&fixture.output_a),
   4666             Err(ReleaseArtifactError::InvalidSourceLock)
   4667         );
   4668 
   4669         let fixture = ReleaseFixture::new();
   4670         let current = ServiceSourceLockV4::from_canonical_bytes(
   4671             &fs::read(fixture.service.join(LOCK_FILENAME)).expect("source lock"),
   4672         )
   4673         .expect("source lock");
   4674         let drifted = String::from_utf8(current.canonical_bytes().to_vec())
   4675             .expect("UTF-8 lock")
   4676             .replace(current.source_archive_sha256(), &"0".repeat(64));
   4677         write_file(&fixture.service.join(LOCK_FILENAME), drifted.as_bytes());
   4678         git(&fixture.service, &["add", LOCK_FILENAME]);
   4679         git(
   4680             &fixture.service,
   4681             &["commit", "--quiet", "-m", "drift source archive digest"],
   4682         );
   4683         create_oci_fixture(
   4684             &fixture.input.join("oci-image.tar.gz"),
   4685             &git_output(&fixture.service, &["rev-parse", "HEAD"]),
   4686             current.revision(),
   4687         );
   4688         assert_eq!(
   4689             fixture.write(&fixture.output_a),
   4690             Err(ReleaseArtifactError::InvalidSourceBundle)
   4691         );
   4692     }
   4693 
   4694     #[test]
   4695     fn output_name_is_one_bounded_component() {
   4696         assert!(valid_output_component("release-v1"));
   4697         for value in ["", ".", "..", "a/b", "/absolute", "a\\b"] {
   4698             assert!(!valid_output_component(value), "{value}");
   4699         }
   4700         assert!(!valid_output_component(&"a".repeat(129)));
   4701     }
   4702 
   4703     #[test]
   4704     fn output_scope_and_target_admission_are_fail_closed() {
   4705         let fixture = ReleaseFixture::new();
   4706         assert_eq!(
   4707             fixture.write(&fixture.service.join("release")),
   4708             Err(ReleaseArtifactError::InvalidOutputRoot)
   4709         );
   4710         assert_eq!(
   4711             fixture.write(&fixture.input.join("release")),
   4712             Err(ReleaseArtifactError::InvalidOutputRoot)
   4713         );
   4714         assert_eq!(
   4715             run_inner(Arguments {
   4716                 mode: CommandMode::Write,
   4717                 service_root: &fixture.service,
   4718                 lib_root: &fixture.lib,
   4719                 input_root: &fixture.input,
   4720                 output_root: &fixture.output_a,
   4721                 target: "x86_64-apple-darwin",
   4722                 source_date_epoch: 1_700_000_000,
   4723                 candidate_digest: &"a".repeat(64),
   4724             }),
   4725             Err(ReleaseArtifactError::InvalidServiceMetadata)
   4726         );
   4727         assert_eq!(
   4728             run_inner(Arguments {
   4729                 mode: CommandMode::Write,
   4730                 service_root: &fixture.service,
   4731                 lib_root: &fixture.lib,
   4732                 input_root: &fixture.input,
   4733                 output_root: &fixture.output_a,
   4734                 target: "x86_64-unknown-linux-gnu",
   4735                 source_date_epoch: 0,
   4736                 candidate_digest: &"a".repeat(64),
   4737             }),
   4738             Err(ReleaseArtifactError::InvalidServiceMetadata)
   4739         );
   4740         assert_eq!(
   4741             run_inner(Arguments {
   4742                 mode: CommandMode::Write,
   4743                 service_root: &fixture.service,
   4744                 lib_root: &fixture.lib,
   4745                 input_root: &fixture.input,
   4746                 output_root: &fixture.output_a,
   4747                 target: native_fixture_target(),
   4748                 source_date_epoch: 1_700_000_000,
   4749                 candidate_digest: &"A".repeat(64),
   4750             }),
   4751             Err(ReleaseArtifactError::InvalidServiceMetadata)
   4752         );
   4753     }
   4754 
   4755     #[test]
   4756     fn secret_scanner_detects_a_pattern_across_chunk_boundaries() {
   4757         let mut scanner = SecretScanner::default();
   4758         scanner.scan(b"prefix -----BEGIN OPENSSH").expect("prefix");
   4759         assert_eq!(
   4760             scanner.scan(
   4761                 b" PRIVATE KEY-----\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n-----END OPENSSH PRIVATE KEY----- suffix"
   4762             ),
   4763             Err(ReleaseArtifactError::ProtectedMaterialDetected)
   4764         );
   4765     }
   4766 
   4767     #[test]
   4768     fn release_metadata_rejects_well_typed_but_invalid_identifiers_and_versions() {
   4769         let temporary = TempDir::new().unwrap();
   4770         let original: toml::Value = toml::from_str(
   4771             r#"
   4772             [workspace.package]
   4773             license = "AGPL-3.0-or-later"
   4774             [workspace.metadata.radroots.service_release]
   4775             service = "myc"
   4776             service_package = "fixture-service"
   4777             binary_name = "fixture-service"
   4778             version = "0.1.0-alpha"
   4779         "#,
   4780         )
   4781         .unwrap();
   4782         let manifest = temporary.path().join("Cargo.toml");
   4783         fs::write(&manifest, toml::to_string(&original).unwrap()).unwrap();
   4784         read_release_metadata(temporary.path()).unwrap();
   4785         for (field, replacement) in [
   4786             ("service", "Invalid".to_owned()),
   4787             ("service_package", "Invalid".to_owned()),
   4788             ("binary_name", "../escape".to_owned()),
   4789             ("version", "x".repeat(129)),
   4790             ("version", "invalid".to_owned()),
   4791             ("version", "01.0.0".to_owned()),
   4792         ] {
   4793             let mut value = original.clone();
   4794             value["workspace"]["metadata"]["radroots"]["service_release"][field] =
   4795                 toml::Value::String(replacement);
   4796             fs::write(&manifest, toml::to_string(&value).unwrap()).unwrap();
   4797             assert!(matches!(
   4798                 read_release_metadata(temporary.path()),
   4799                 Err(ReleaseArtifactError::InvalidServiceMetadata)
   4800             ));
   4801         }
   4802         let mut value = original;
   4803         value["workspace"]["package"]["license"] = toml::Value::String("MIT".to_owned());
   4804         fs::write(&manifest, toml::to_string(&value).unwrap()).unwrap();
   4805         assert!(matches!(
   4806             read_release_metadata(temporary.path()),
   4807             Err(ReleaseArtifactError::InvalidServiceMetadata)
   4808         ));
   4809     }
   4810 
   4811     #[test]
   4812     fn sbom_dependency_edges_composition_and_artifact_hashes_are_exact() {
   4813         let artifacts = vec![ArtifactRecord {
   4814             path: "binary.tar.gz".to_owned(),
   4815             byte_length: 42,
   4816             sha256: "a".repeat(64),
   4817         }];
   4818         for case in 0..7 {
   4819             let (mut sbom, _, _) =
   4820                 build_supply_chain_documents(&sample_metadata(), sample_cargo_metadata()).unwrap();
   4821             reconcile_sbom_artifacts(&mut sbom, &artifacts);
   4822             validate_cyclonedx_profile(&sbom, &artifacts).unwrap();
   4823             match case {
   4824                 0 => sbom.components[0].bom_ref = sbom.metadata.component.bom_ref.clone(),
   4825                 1 => {
   4826                     sbom.dependencies.pop();
   4827                 }
   4828                 2 => sbom.dependencies[0].reference = "unknown".to_owned(),
   4829                 3 => sbom.dependencies[0].depends_on.push("unknown".to_owned()),
   4830                 4 => sbom.compositions[0].aggregate = "incomplete",
   4831                 5 => sbom.compositions[0].assemblies.clear(),
   4832                 _ => {
   4833                     let artifact = sbom
   4834                         .components
   4835                         .iter_mut()
   4836                         .find(|row| row.bom_ref.starts_with("artifact:"))
   4837                         .unwrap();
   4838                     artifact.hashes[0].content = "b".repeat(64);
   4839                 }
   4840             }
   4841             assert_eq!(
   4842                 validate_cyclonedx_profile(&sbom, &artifacts),
   4843                 Err(ReleaseArtifactError::GenerationFailure),
   4844                 "SBOM case {case}"
   4845             );
   4846         }
   4847     }
   4848 
   4849     #[test]
   4850     fn schema_reconciliation_attribution_and_subjects_fail_closed() {
   4851         let (mut sbom, _, _) =
   4852             build_supply_chain_documents(&sample_metadata(), sample_cargo_metadata())
   4853                 .expect("supply-chain documents");
   4854         let artifacts = vec![ArtifactRecord {
   4855             path: "binary.tar.gz".to_owned(),
   4856             byte_length: 42,
   4857             sha256: "a".repeat(64),
   4858         }];
   4859         reconcile_sbom_artifacts(&mut sbom, &artifacts);
   4860         validate_cyclonedx_profile(&sbom, &artifacts).expect("CycloneDX profile");
   4861         sbom.spec_version = "1.5";
   4862         assert_eq!(
   4863             validate_cyclonedx_profile(&sbom, &artifacts),
   4864             Err(ReleaseArtifactError::GenerationFailure)
   4865         );
   4866         sbom.spec_version = "1.6";
   4867         sbom.components.pop();
   4868         assert_eq!(
   4869             validate_cyclonedx_profile(&sbom, &artifacts),
   4870             Err(ReleaseArtifactError::GenerationFailure)
   4871         );
   4872 
   4873         let mut cargo = sample_cargo_metadata();
   4874         cargo.packages[1].license_texts[0].sha256 = "b".repeat(64);
   4875         assert!(matches!(
   4876             build_supply_chain_documents(&sample_metadata(), cargo),
   4877             Err(ReleaseArtifactError::InvalidPackageInventory)
   4878         ));
   4879 
   4880         let mut provenance = build_provenance(
   4881             ProvenanceInput {
   4882                 candidate_digest: &"a".repeat(64),
   4883                 service: "myc",
   4884                 target: native_fixture_target(),
   4885                 source_date_epoch: 1_700_000_000,
   4886                 service_repository: "https://github.com/radrootslabs/mycelium",
   4887                 service_revision: &"1".repeat(40),
   4888                 lib_revision: &"2".repeat(40),
   4889                 source_lock_sha256: &"3".repeat(64),
   4890                 manifest_sha256: &"4".repeat(64),
   4891             },
   4892             &artifacts,
   4893         );
   4894         validate_provenance_subjects(&provenance, &"a".repeat(64), &artifacts)
   4895             .expect("exact provenance subjects");
   4896         provenance.statement_type = "unknown";
   4897         assert!(validate_provenance_subjects(&provenance, &"a".repeat(64), &artifacts).is_err());
   4898         provenance.statement_type = "https://in-toto.io/Statement/v1";
   4899         provenance.predicate_type = "unknown";
   4900         assert!(validate_provenance_subjects(&provenance, &"a".repeat(64), &artifacts).is_err());
   4901         provenance.predicate_type = "https://slsa.dev/provenance/v1";
   4902         assert!(validate_provenance_subjects(&provenance, &"b".repeat(64), &artifacts).is_err());
   4903         provenance.subject.clear();
   4904         assert_eq!(
   4905             validate_provenance_subjects(&provenance, &"a".repeat(64), &artifacts),
   4906             Err(ReleaseArtifactError::GenerationFailure)
   4907         );
   4908 
   4909         let scan_evidence = FileEvidence {
   4910             byte_length: 7,
   4911             sha256: "5".repeat(64),
   4912         };
   4913         let scan = ScanDocument {
   4914             schema: "radroots.service.artifact-scan.v1",
   4915             contract_version: 1,
   4916             candidate_digest: "a".repeat(64),
   4917             state: "no_protected_material_detected",
   4918             ruleset_sha256: "6".repeat(64),
   4919             scanned_artifacts: artifacts.clone(),
   4920             nested_members_scanned: 1,
   4921             expanded_bytes_scanned: 42,
   4922         };
   4923         for case in 0..6 {
   4924             let mut manifest = ArtifactManifestDocument {
   4925                 schema: "radroots.service.release-artifacts.v2",
   4926                 contract_version: 2,
   4927                 candidate_digest: "a".repeat(64),
   4928                 service: "myc".to_owned(),
   4929                 version: "0.1.0-alpha".to_owned(),
   4930                 target: native_fixture_target().to_owned(),
   4931                 source_date_epoch: 1_700_000_000,
   4932                 service_revision: "1".repeat(40),
   4933                 lib_revision: "2".repeat(40),
   4934                 rust_version: RUST_VERSION,
   4935                 host_feature_profile: "service-host",
   4936                 contract_versions: ContractVersionsDocument {
   4937                     config: 1,
   4938                     state: 1,
   4939                     admin: 1,
   4940                     status: 1,
   4941                     provider: 1,
   4942                 },
   4943                 confidentiality: ConfidentialityDocument {
   4944                     state: scan.state,
   4945                     derived_from: artifact_record("artifact-scan.v1.json", &scan_evidence),
   4946                     protected_material_included: false,
   4947                 },
   4948                 artifacts: artifacts.clone(),
   4949             };
   4950             validate_confidentiality_binding(&manifest, &scan, &scan_evidence, &artifacts)
   4951                 .expect("derived confidentiality");
   4952             match case {
   4953                 0 => manifest.confidentiality.state = "invented_clean_state",
   4954                 1 => manifest.candidate_digest = "b".repeat(64),
   4955                 2 => manifest.confidentiality.protected_material_included = true,
   4956                 3 => manifest.confidentiality.derived_from.path = "unknown".to_owned(),
   4957                 4 => manifest.confidentiality.derived_from.sha256 = "b".repeat(64),
   4958                 _ => manifest.artifacts.clear(),
   4959             }
   4960             assert_eq!(
   4961                 validate_confidentiality_binding(&manifest, &scan, &scan_evidence, &artifacts),
   4962                 Err(ReleaseArtifactError::GenerationFailure)
   4963             );
   4964         }
   4965     }
   4966 
   4967     #[test]
   4968     fn secret_path_and_history_archive_vectors_fail_closed() {
   4969         let root = TempDir::new().expect("archive vector root");
   4970         let mut token = b"ghp_".to_vec();
   4971         token.extend(std::iter::repeat_n(b'A', 36));
   4972 
   4973         let source = root.path().join("source.tar");
   4974         write_tar_fixture(&source, "src/value.bin", &token, false);
   4975         assert_eq!(
   4976             scan_tar_members(&source, false),
   4977             Err(ReleaseArtifactError::ProtectedMaterialDetected)
   4978         );
   4979 
   4980         let sensitive = root.path().join("sensitive.tar");
   4981         write_tar_fixture(&sensitive, ".git/config", b"clean", false);
   4982         assert_eq!(
   4983             scan_tar_members(&sensitive, false),
   4984             Err(ReleaseArtifactError::ProtectedMaterialDetected)
   4985         );
   4986 
   4987         let binary = root.path().join("binary.tar.gz");
   4988         write_tar_fixture(&binary, "bin/service", &token, true);
   4989         assert_eq!(
   4990             scan_tar_gzip_members(&binary),
   4991             Err(ReleaseArtifactError::ProtectedMaterialDetected)
   4992         );
   4993 
   4994         let layer = root.path().join("layer.tar");
   4995         write_tar_fixture(&layer, "nix/store/service", &token, false);
   4996         assert_eq!(
   4997             scan_tar_members(&layer, true),
   4998             Err(ReleaseArtifactError::ProtectedMaterialDetected)
   4999         );
   5000 
   5001         let bundle = root.path().join("history.bundle");
   5002         write_file(&bundle, b"not an exact-tree archive");
   5003         assert_eq!(
   5004             scan_tar_members(&bundle, false),
   5005             Err(ReleaseArtifactError::InvalidInputArtifact)
   5006         );
   5007     }
   5008 
   5009     #[test]
   5010     fn archive_scanning_enforces_member_types_counts_lengths_and_protected_paths() {
   5011         let root = TempDir::new().unwrap();
   5012         let path = root.path().join("input.tar");
   5013         for kind in [
   5014             tar::EntryType::Directory,
   5015             tar::EntryType::Symlink,
   5016             tar::EntryType::Link,
   5017             tar::EntryType::Fifo,
   5018         ] {
   5019             let mut builder = TarBuilder::new(Vec::new());
   5020             let mut header = TarHeader::new_gnu();
   5021             header.set_path("member").unwrap();
   5022             header.set_entry_type(kind);
   5023             header.set_size(0);
   5024             if kind.is_symlink() || kind.is_hard_link() {
   5025                 header.set_link_name("target").unwrap();
   5026             }
   5027             header.set_cksum();
   5028             builder.append(&header, &[][..]).unwrap();
   5029             let bytes = builder.into_inner().unwrap();
   5030             fs::write(&path, &bytes).unwrap();
   5031             assert!(scan_tar_members(&path, false).is_err());
   5032             assert_eq!(
   5033                 scan_tar_members(&path, true).is_ok(),
   5034                 kind != tar::EntryType::Fifo
   5035             );
   5036             let gzip = root.path().join("binary.tar.gz");
   5037             let mut encoder = GzBuilder::new().write(Vec::new(), Compression::best());
   5038             encoder.write_all(&bytes).unwrap();
   5039             fs::write(&gzip, encoder.finish().unwrap()).unwrap();
   5040             assert_eq!(scan_tar_gzip_members(&gzip).is_ok(), kind.is_dir());
   5041         }
   5042         let empty = TarBuilder::new(Vec::new()).into_inner().unwrap();
   5043         fs::write(&path, &empty).unwrap();
   5044         assert!(scan_tar_members(&path, true).is_err());
   5045         let mut encoder = GzBuilder::new().write(Vec::new(), Compression::best());
   5046         encoder.write_all(&empty).unwrap();
   5047         fs::write(&path, encoder.finish().unwrap()).unwrap();
   5048         assert!(scan_tar_gzip_members(&path).is_err());
   5049         for length in [2, 4] {
   5050             assert!(scan_reader(&mut &b"abc"[..], length).is_err());
   5051         }
   5052         assert_eq!(scan_reader(&mut &b"abc"[..], 3).unwrap(), 3);
   5053         for path in [
   5054             "/absolute",
   5055             "../escape",
   5056             "src/.ssh/config",
   5057             &"a".repeat(MAX_ARCHIVE_PATH_BYTES + 1),
   5058         ] {
   5059             assert_eq!(
   5060                 validate_scanned_path(path),
   5061                 Err(ReleaseArtifactError::ProtectedMaterialDetected)
   5062             );
   5063         }
   5064     }
   5065 
   5066     fn write_tar_fixture(path: &Path, member: &str, bytes: &[u8], gzip: bool) {
   5067         let mut header = TarHeader::new_gnu();
   5068         header.set_entry_type(tar::EntryType::Regular);
   5069         header.set_size(bytes.len() as u64);
   5070         header.set_mode(0o644);
   5071         header.set_uid(0);
   5072         header.set_gid(0);
   5073         header.set_mtime(1);
   5074         header.set_cksum();
   5075         if gzip {
   5076             let output = fs::File::create(path).expect("gzip tar fixture");
   5077             let encoder = GzBuilder::new()
   5078                 .mtime(1)
   5079                 .operating_system(255)
   5080                 .write(output, Compression::best());
   5081             let mut archive = TarBuilder::new(encoder);
   5082             archive
   5083                 .append_data(&mut header, member, bytes)
   5084                 .expect("gzip tar member");
   5085             let encoder = archive.into_inner().expect("gzip tar archive");
   5086             encoder.finish().expect("gzip tar finish");
   5087         } else {
   5088             let output = fs::File::create(path).expect("tar fixture");
   5089             let mut archive = TarBuilder::new(output);
   5090             archive
   5091                 .append_data(&mut header, member, bytes)
   5092                 .expect("tar member");
   5093             archive.finish().expect("tar finish");
   5094         }
   5095     }
   5096 
   5097     #[test]
   5098     fn identifiers_and_sources_are_closed() {
   5099         assert!(valid_snake_identifier("fixture_service"));
   5100         assert!(!valid_snake_identifier("fixture__service"));
   5101         assert!(valid_kebab_identifier("fixture-service"));
   5102         assert!(!valid_kebab_identifier("fixture--service"));
   5103         assert!(valid_public_source(
   5104             "registry+https://github.com/rust-lang/crates.io-index"
   5105         ));
   5106         assert!(valid_public_source(
   5107             "git+https://github.com/radrootslabs/lib?rev=1111111111111111111111111111111111111111#1111111111111111111111111111111111111111"
   5108         ));
   5109         assert!(!valid_public_source(
   5110             "git+ssh://git@github.com/private/repo"
   5111         ));
   5112         assert!(!valid_public_source("path+file:///secret"));
   5113     }
   5114 
   5115     #[test]
   5116     fn errors_are_stable_and_source_free() {
   5117         let errors = [
   5118             ReleaseArtifactError::InvalidContract,
   5119             ReleaseArtifactError::InvalidServiceRoot,
   5120             ReleaseArtifactError::DirtyServiceSource,
   5121             ReleaseArtifactError::InvalidServiceMetadata,
   5122             ReleaseArtifactError::InvalidInputRoot,
   5123             ReleaseArtifactError::InvalidInputArtifact,
   5124             ReleaseArtifactError::InvalidSourceLock,
   5125             ReleaseArtifactError::InvalidSourceBundle,
   5126             ReleaseArtifactError::InvalidPackageInventory,
   5127             ReleaseArtifactError::ProtectedMaterialDetected,
   5128             ReleaseArtifactError::InvalidOutputRoot,
   5129             ReleaseArtifactError::StaleOutput,
   5130             ReleaseArtifactError::GenerationFailure,
   5131         ];
   5132         for error in errors {
   5133             let display = error.to_string();
   5134             let debug = format!("{error:?}");
   5135             assert!(!display.contains('/'));
   5136             assert!(!display.contains("secret"));
   5137             assert!(!debug.contains('/'));
   5138             assert!(std::error::Error::source(&error).is_none());
   5139         }
   5140     }
   5141 }