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(®ular, 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(®ular, 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(®ular, &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(®ular, b"same"); 4279 assert_eq!( 4280 read_bounded_regular(®ular, 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(®ular, &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(®ular).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(®ular, &device_metadata), 4329 Err(ReleaseArtifactError::InvalidInputArtifact) 4330 ); 4331 4332 let same_inode = fs::symlink_metadata(®ular).expect("same-inode metadata"); 4333 write_file(®ular, b"changed length"); 4334 assert_eq!( 4335 validate_unchanged_input(®ular, &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 }