Skip to main content

minco_release/
lib.rs

1//! Immutable release manifests and artifact verification.
2#![forbid(unsafe_code)]
3
4use serde::{Deserialize, Serialize};
5use sha2::{Digest, Sha256};
6use std::{
7    collections::BTreeSet,
8    fs::File,
9    io::{self, Read, Write},
10    path::Path,
11};
12use thiserror::Error;
13
14#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
15pub struct FileDigest {
16    pub path: String,
17    pub sha256: String,
18    pub bytes: u64,
19}
20
21impl FileDigest {
22    pub fn from_path(path: impl AsRef<Path>) -> Result<Self, ReleaseError> {
23        let path = path.as_ref();
24        let mut file = File::open(path)?;
25        let mut hasher = Sha256::new();
26        let mut buffer = vec![0_u8; 64 * 1024];
27        let mut bytes = 0_u64;
28        loop {
29            let read = file.read(&mut buffer)?;
30            if read == 0 {
31                break;
32            }
33            hasher.update(&buffer[..read]);
34            bytes += read as u64;
35        }
36        Ok(Self {
37            path: path.display().to_string(),
38            sha256: hex::encode(hasher.finalize()),
39            bytes,
40        })
41    }
42
43    pub fn verify(&self) -> Result<(), ReleaseError> {
44        let actual = Self::from_path(&self.path)?;
45        if actual.sha256 != self.sha256 || actual.bytes != self.bytes {
46            return Err(ReleaseError::DigestMismatch {
47                path: self.path.clone(),
48                expected: self.sha256.clone(),
49                actual: actual.sha256,
50            });
51        }
52        Ok(())
53    }
54
55    pub fn from_rooted_path(
56        root: impl AsRef<Path>,
57        path: impl AsRef<Path>,
58    ) -> Result<Self, ReleaseError> {
59        let root = root.as_ref().canonicalize()?;
60        let path = path.as_ref().canonicalize()?;
61        let relative = path
62            .strip_prefix(&root)
63            .map_err(|_| ReleaseError::PathOutsideRoot(path.display().to_string()))?;
64        let mut digest = Self::from_path(&path)?;
65        digest.path = relative
66            .iter()
67            .map(|component| {
68                component
69                    .to_str()
70                    .ok_or_else(|| ReleaseError::NonUtf8Path(path.display().to_string()))
71            })
72            .collect::<Result<Vec<_>, _>>()?
73            .join("/");
74        Ok(digest)
75    }
76
77    pub fn verify_at(&self, root: impl AsRef<Path>) -> Result<(), ReleaseError> {
78        let root = root.as_ref().canonicalize()?;
79        let path = Path::new(&self.path);
80        if !is_normalized_relative_path(path) {
81            return Err(ReleaseError::InvalidManifestPath(self.path.clone()));
82        }
83        let path = root.join(path).canonicalize()?;
84        path.strip_prefix(&root)
85            .map_err(|_| ReleaseError::PathOutsideRoot(path.display().to_string()))?;
86        let actual = Self::from_path(path)?;
87        if actual.sha256 != self.sha256 || actual.bytes != self.bytes {
88            return Err(ReleaseError::DigestMismatch {
89                path: self.path.clone(),
90                expected: self.sha256.clone(),
91                actual: actual.sha256,
92            });
93        }
94        Ok(())
95    }
96}
97
98#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
99pub struct ReleaseEnvironment {
100    pub application: String,
101    pub environment: String,
102    pub region: String,
103}
104
105#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
106pub struct ToolchainIdentity {
107    pub rustc: String,
108    pub cargo_minco: String,
109    pub artifact_builder: Option<String>,
110}
111
112#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
113pub struct FunctionArtifact {
114    pub function_id: String,
115    pub file: FileDigest,
116}
117
118#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
119pub struct DatabaseSourceDigests {
120    pub migration_catalog: String,
121    pub seed_catalog: String,
122}
123
124#[derive(Debug, Clone, PartialEq, Eq)]
125pub struct ReleaseManifestInput {
126    pub source_change: String,
127    pub environment: ReleaseEnvironment,
128    pub toolchain: ToolchainIdentity,
129    pub artifacts: Vec<FunctionArtifact>,
130    pub contract: FileDigest,
131    pub configuration_digest: String,
132    pub database_sources: DatabaseSourceDigests,
133    pub cargo_lock: Option<FileDigest>,
134    pub deployment_plan: FileDigest,
135    pub deployment_template: FileDigest,
136    pub attestations: Vec<FileDigest>,
137}
138
139#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
140pub struct ReleaseManifest {
141    pub schema_version: u32,
142    pub release_id: String,
143    pub release_digest: String,
144    pub source_change: String,
145    pub environment: ReleaseEnvironment,
146    pub toolchain: ToolchainIdentity,
147    pub artifacts: Vec<FunctionArtifact>,
148    pub contract: FileDigest,
149    pub configuration_digest: String,
150    pub database_sources: DatabaseSourceDigests,
151    pub cargo_lock: Option<FileDigest>,
152    pub deployment_plan: FileDigest,
153    pub deployment_template: FileDigest,
154    pub attestations: Vec<FileDigest>,
155}
156
157impl ReleaseManifest {
158    pub fn seal(mut input: ReleaseManifestInput) -> Result<Self, ReleaseError> {
159        input
160            .artifacts
161            .sort_by(|left, right| left.function_id.cmp(&right.function_id));
162        input
163            .attestations
164            .sort_by(|left, right| left.path.cmp(&right.path));
165        validate_release_input(&input)?;
166        let mut manifest = Self {
167            schema_version: 3,
168            release_id: String::new(),
169            release_digest: String::new(),
170            source_change: input.source_change,
171            environment: input.environment,
172            toolchain: input.toolchain,
173            artifacts: input.artifacts,
174            contract: input.contract,
175            configuration_digest: input.configuration_digest,
176            database_sources: input.database_sources,
177            cargo_lock: input.cargo_lock,
178            deployment_plan: input.deployment_plan,
179            deployment_template: input.deployment_template,
180            attestations: input.attestations,
181        };
182        manifest.release_digest = manifest.calculate_release_digest()?;
183        manifest.release_id = format!("minco.{}", &manifest.release_digest[..24]);
184        Ok(manifest)
185    }
186
187    pub fn verify(&self) -> Result<(), ReleaseError> {
188        self.verify_at(".")
189    }
190
191    pub fn verify_at(&self, root: impl AsRef<Path>) -> Result<(), ReleaseError> {
192        self.verify_structure()?;
193        let root = root.as_ref();
194        for artifact in &self.artifacts {
195            artifact.file.verify_at(root)?;
196        }
197        self.contract.verify_at(root)?;
198        self.deployment_plan.verify_at(root)?;
199        self.deployment_template.verify_at(root)?;
200        if let Some(lock) = &self.cargo_lock {
201            lock.verify_at(root)?;
202        }
203        for attestation in &self.attestations {
204            attestation.verify_at(root)?;
205        }
206        Ok(())
207    }
208
209    fn verify_structure(&self) -> Result<(), ReleaseError> {
210        if self.schema_version != 3 {
211            return Err(ReleaseError::UnsupportedSchemaVersion(self.schema_version));
212        }
213        validate_release_manifest(self)?;
214        let actual_digest = self.calculate_release_digest()?;
215        if actual_digest != self.release_digest {
216            return Err(ReleaseError::ReleaseDigestMismatch {
217                expected: self.release_digest.clone(),
218                actual: actual_digest,
219            });
220        }
221        let expected_id = format!("minco.{}", &self.release_digest[..24]);
222        if self.release_id != expected_id {
223            return Err(ReleaseError::InvalidRelease(format!(
224                "release ID {} does not match digest-derived ID {expected_id}",
225                self.release_id
226            )));
227        }
228        Ok(())
229    }
230
231    fn calculate_release_digest(&self) -> Result<String, ReleaseError> {
232        #[derive(Serialize)]
233        struct DigestPayload<'a> {
234            schema_version: u32,
235            source_change: &'a str,
236            environment: &'a ReleaseEnvironment,
237            toolchain: &'a ToolchainIdentity,
238            artifacts: &'a [FunctionArtifact],
239            contract: &'a FileDigest,
240            configuration_digest: &'a str,
241            database_sources: &'a DatabaseSourceDigests,
242            cargo_lock: &'a Option<FileDigest>,
243            deployment_plan: &'a FileDigest,
244            deployment_template: &'a FileDigest,
245            attestations: &'a [FileDigest],
246        }
247        let payload = DigestPayload {
248            schema_version: self.schema_version,
249            source_change: &self.source_change,
250            environment: &self.environment,
251            toolchain: &self.toolchain,
252            artifacts: &self.artifacts,
253            contract: &self.contract,
254            configuration_digest: &self.configuration_digest,
255            database_sources: &self.database_sources,
256            cargo_lock: &self.cargo_lock,
257            deployment_plan: &self.deployment_plan,
258            deployment_template: &self.deployment_template,
259            attestations: &self.attestations,
260        };
261        Ok(hex::encode(Sha256::digest(serde_json::to_vec(&payload)?)))
262    }
263
264    pub fn write_json(&self, path: impl AsRef<Path>) -> Result<(), ReleaseError> {
265        self.verify_structure()?;
266        let path = path.as_ref();
267        let mut rendered = serde_json::to_vec_pretty(self)?;
268        rendered.push(b'\n');
269        if path.exists() {
270            if std::fs::read(path)? == rendered {
271                return Ok(());
272            }
273            return Err(ReleaseError::ReleaseManifestConflict(
274                path.display().to_string(),
275            ));
276        }
277        write_new_file(path, &rendered)
278    }
279
280    pub fn read_json(path: impl AsRef<Path>) -> Result<Self, ReleaseError> {
281        let source = std::fs::read(path)?;
282        let value: serde_json::Value = serde_json::from_slice(&source)?;
283        let schema_version = value
284            .get("schema_version")
285            .and_then(serde_json::Value::as_u64)
286            .and_then(|value| u32::try_from(value).ok())
287            .ok_or_else(|| {
288                ReleaseError::InvalidRelease(
289                    "release manifest has no supported integer schema_version".into(),
290                )
291            })?;
292        if schema_version != 3 {
293            return Err(ReleaseError::UnsupportedSchemaVersion(schema_version));
294        }
295        Ok(serde_json::from_value(value)?)
296    }
297}
298
299#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
300#[serde(rename_all = "snake_case")]
301pub enum DatabasePlanKind {
302    Migration,
303    Seed,
304}
305
306#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
307pub struct DatabasePlanBinding {
308    pub kind: DatabasePlanKind,
309    pub schema_version: u32,
310    pub catalog_digest: String,
311    pub plan_digest: String,
312    pub file: FileDigest,
313    pub selected_set: Option<String>,
314    pub environment: Option<String>,
315}
316
317#[derive(Debug, Clone, PartialEq, Eq)]
318pub struct DeploymentReceiptInput {
319    pub attempt_id: String,
320    pub release_manifest: FileDigest,
321    pub release_id: String,
322    pub release_digest: String,
323    pub environment: ReleaseEnvironment,
324    pub configuration_digest: String,
325    pub database_plans: Vec<DatabasePlanBinding>,
326    pub attestations: Vec<FileDigest>,
327}
328
329#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
330pub struct VerificationEvidence {
331    pub kind: String,
332    pub file: FileDigest,
333}
334
335#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
336#[serde(rename_all = "snake_case")]
337pub enum DeploymentOutcome {
338    Started,
339    Failed,
340    Succeeded,
341}
342
343#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
344pub struct DeploymentReceipt {
345    pub schema_version: u32,
346    pub receipt_digest: String,
347    pub attempt_id: String,
348    pub release_manifest: FileDigest,
349    pub release_id: String,
350    pub release_digest: String,
351    pub environment: ReleaseEnvironment,
352    pub configuration_digest: String,
353    pub database_plans: Vec<DatabasePlanBinding>,
354    pub attestations: Vec<FileDigest>,
355    outcome: DeploymentOutcome,
356    failure_code: Option<String>,
357    verification: Vec<VerificationEvidence>,
358}
359
360impl DeploymentReceipt {
361    pub fn start(mut input: DeploymentReceiptInput) -> Result<Self, ReleaseError> {
362        input.database_plans.sort();
363        input
364            .attestations
365            .sort_by(|left, right| left.path.cmp(&right.path));
366        validate_identifier(&input.attempt_id, "deployment attempt ID")?;
367        validate_sha256(&input.release_manifest.sha256, "release manifest digest")?;
368        validate_sha256(&input.release_digest, "release digest")?;
369        validate_sha256(&input.configuration_digest, "configuration digest")?;
370        for plan in &input.database_plans {
371            if plan.schema_version == 0 {
372                return Err(ReleaseError::InvalidDeploymentReceipt(
373                    "database plan schema version must be greater than zero".into(),
374                ));
375            }
376            validate_sha256(&plan.catalog_digest, "database catalog digest")?;
377            validate_sha256(&plan.plan_digest, "database plan digest")?;
378        }
379        let mut receipt = Self {
380            schema_version: 1,
381            receipt_digest: String::new(),
382            attempt_id: input.attempt_id,
383            release_manifest: input.release_manifest,
384            release_id: input.release_id,
385            release_digest: input.release_digest,
386            environment: input.environment,
387            configuration_digest: input.configuration_digest,
388            database_plans: input.database_plans,
389            attestations: input.attestations,
390            outcome: DeploymentOutcome::Started,
391            failure_code: None,
392            verification: Vec::new(),
393        };
394        receipt.refresh_digest()?;
395        receipt.verify_structure()?;
396        Ok(receipt)
397    }
398
399    pub const fn outcome(&self) -> DeploymentOutcome {
400        self.outcome
401    }
402
403    pub fn failure_code(&self) -> Option<&str> {
404        self.failure_code.as_deref()
405    }
406
407    pub fn verification(&self) -> &[VerificationEvidence] {
408        &self.verification
409    }
410
411    pub fn fail(&mut self, failure_code: impl Into<String>) -> Result<(), ReleaseError> {
412        self.require_started()?;
413        let failure_code = failure_code.into();
414        validate_identifier(&failure_code, "deployment failure code")?;
415        self.outcome = DeploymentOutcome::Failed;
416        self.failure_code = Some(failure_code);
417        self.refresh_digest()?;
418        self.verify_structure()
419    }
420
421    pub fn succeed(
422        &mut self,
423        mut verification: Vec<VerificationEvidence>,
424    ) -> Result<(), ReleaseError> {
425        self.require_started()?;
426        if verification.is_empty() {
427            return Err(ReleaseError::InvalidDeploymentReceipt(
428                "successful deployment requires verification evidence".into(),
429            ));
430        }
431        verification.sort_by(|left, right| {
432            left.kind
433                .cmp(&right.kind)
434                .then_with(|| left.file.path.cmp(&right.file.path))
435        });
436        for evidence in &verification {
437            validate_identifier(&evidence.kind, "verification evidence kind")?;
438            validate_sha256(&evidence.file.sha256, "verification evidence digest")?;
439        }
440        self.outcome = DeploymentOutcome::Succeeded;
441        self.verification = verification;
442        self.refresh_digest()?;
443        self.verify_structure()
444    }
445
446    pub fn verify(&self) -> Result<(), ReleaseError> {
447        self.verify_at(".")
448    }
449
450    pub fn verify_at(&self, root: impl AsRef<Path>) -> Result<(), ReleaseError> {
451        self.verify_structure()?;
452        let root = root.as_ref();
453        self.release_manifest.verify_at(root)?;
454        let release = ReleaseManifest::read_json(root.join(&self.release_manifest.path))?;
455        release.verify_at(root)?;
456        if release.release_id != self.release_id
457            || release.release_digest != self.release_digest
458            || release.environment != self.environment
459            || release.configuration_digest != self.configuration_digest
460        {
461            return Err(ReleaseError::InvalidDeploymentReceipt(
462                "deployment binding does not match the verified release manifest".into(),
463            ));
464        }
465        for plan in &self.database_plans {
466            plan.file.verify_at(root)?;
467            let value: serde_json::Value =
468                serde_json::from_slice(&std::fs::read(root.join(&plan.file.path))?)?;
469            let schema_version = value
470                .get("schema_version")
471                .and_then(serde_json::Value::as_u64);
472            let catalog_digest = value
473                .get("catalog_digest")
474                .and_then(serde_json::Value::as_str);
475            let plan_digest = value.get("digest").and_then(serde_json::Value::as_str);
476            if schema_version != Some(u64::from(plan.schema_version))
477                || catalog_digest != Some(plan.catalog_digest.as_str())
478                || plan_digest != Some(plan.plan_digest.as_str())
479            {
480                return Err(ReleaseError::InvalidDeploymentReceipt(format!(
481                    "{:?} plan binding does not match {}",
482                    plan.kind, plan.file.path
483                )));
484            }
485        }
486        for attestation in &self.attestations {
487            attestation.verify_at(root)?;
488        }
489        for evidence in &self.verification {
490            evidence.file.verify_at(root)?;
491        }
492        Ok(())
493    }
494
495    pub fn write_json(&self, path: impl AsRef<Path>) -> Result<(), ReleaseError> {
496        self.verify_structure()?;
497        let path = path.as_ref();
498        let _transition_lock = lock_deployment_receipt(path)?;
499        let mut rendered = serde_json::to_vec_pretty(self)?;
500        rendered.push(b'\n');
501        if !path.exists() {
502            return write_new_file(path, &rendered);
503        }
504        let existing = Self::read_json(path)?;
505        if existing == *self {
506            return Ok(());
507        }
508        if existing.attempt_id != self.attempt_id || !existing.same_binding(self) {
509            return Err(ReleaseError::DeploymentReceiptConflict(
510                self.attempt_id.clone(),
511            ));
512        }
513        if existing.outcome != DeploymentOutcome::Started
514            || self.outcome == DeploymentOutcome::Started
515        {
516            return Err(ReleaseError::TerminalDeploymentReceipt {
517                attempt_id: existing.attempt_id,
518                outcome: existing.outcome,
519            });
520        }
521        replace_file(path, &rendered, &self.receipt_digest)
522    }
523
524    pub fn read_json(path: impl AsRef<Path>) -> Result<Self, ReleaseError> {
525        let receipt: Self = serde_json::from_slice(&std::fs::read(path)?)?;
526        receipt.verify_structure()?;
527        Ok(receipt)
528    }
529
530    fn require_started(&self) -> Result<(), ReleaseError> {
531        if self.outcome != DeploymentOutcome::Started {
532            return Err(ReleaseError::TerminalDeploymentReceipt {
533                attempt_id: self.attempt_id.clone(),
534                outcome: self.outcome,
535            });
536        }
537        Ok(())
538    }
539
540    fn same_binding(&self, other: &Self) -> bool {
541        self.schema_version == other.schema_version
542            && self.attempt_id == other.attempt_id
543            && self.release_manifest == other.release_manifest
544            && self.release_id == other.release_id
545            && self.release_digest == other.release_digest
546            && self.environment == other.environment
547            && self.configuration_digest == other.configuration_digest
548            && self.database_plans == other.database_plans
549            && self.attestations == other.attestations
550    }
551
552    fn refresh_digest(&mut self) -> Result<(), ReleaseError> {
553        self.receipt_digest = self.calculate_receipt_digest()?;
554        Ok(())
555    }
556
557    fn verify_structure(&self) -> Result<(), ReleaseError> {
558        if self.schema_version != 1 {
559            return Err(ReleaseError::UnsupportedDeploymentReceiptSchema(
560                self.schema_version,
561            ));
562        }
563        validate_identifier(&self.attempt_id, "deployment attempt ID")?;
564        validate_sha256(&self.receipt_digest, "deployment receipt digest")?;
565        validate_sha256(&self.release_manifest.sha256, "release manifest digest")?;
566        validate_sha256(&self.release_digest, "release digest")?;
567        validate_sha256(&self.configuration_digest, "configuration digest")?;
568        validate_file_digest(&self.release_manifest, "release manifest")?;
569        let expected_release_id = format!("minco.{}", &self.release_digest[..24]);
570        if self.release_id != expected_release_id {
571            return Err(ReleaseError::InvalidDeploymentReceipt(
572                "release ID does not match its digest".into(),
573            ));
574        }
575        for plan in &self.database_plans {
576            if plan.schema_version == 0 {
577                return Err(ReleaseError::InvalidDeploymentReceipt(
578                    "database plan schema version must be greater than zero".into(),
579                ));
580            }
581            validate_sha256(&plan.catalog_digest, "database catalog digest")?;
582            validate_sha256(&plan.plan_digest, "database plan digest")?;
583            validate_file_digest(&plan.file, "database plan")?;
584            if let Some(selected_set) = &plan.selected_set {
585                validate_identifier(selected_set, "database plan selected set")?;
586            }
587            if let Some(environment) = &plan.environment {
588                validate_identifier(environment, "database plan environment")?;
589            }
590        }
591        for attestation in &self.attestations {
592            validate_file_digest(attestation, "attestation")?;
593        }
594        for evidence in &self.verification {
595            validate_identifier(&evidence.kind, "verification evidence kind")?;
596            validate_file_digest(&evidence.file, "verification evidence")?;
597        }
598        if self
599            .database_plans
600            .windows(2)
601            .any(|plans| plans[0] == plans[1])
602        {
603            return Err(ReleaseError::InvalidDeploymentReceipt(
604                "deployment receipt repeats a database plan binding".into(),
605            ));
606        }
607        if self
608            .attestations
609            .windows(2)
610            .any(|attestations| attestations[0].path == attestations[1].path)
611        {
612            return Err(ReleaseError::InvalidDeploymentReceipt(
613                "deployment receipt repeats an attestation path".into(),
614            ));
615        }
616        let state_is_valid = match self.outcome {
617            DeploymentOutcome::Started => {
618                self.failure_code.is_none() && self.verification.is_empty()
619            }
620            DeploymentOutcome::Failed => {
621                self.failure_code.is_some() && self.verification.is_empty()
622            }
623            DeploymentOutcome::Succeeded => {
624                self.failure_code.is_none() && !self.verification.is_empty()
625            }
626        };
627        if !state_is_valid {
628            return Err(ReleaseError::InvalidDeploymentReceipt(
629                "deployment outcome, failure, and verification fields are inconsistent".into(),
630            ));
631        }
632        if let Some(failure_code) = &self.failure_code {
633            validate_identifier(failure_code, "deployment failure code")?;
634        }
635        let actual = self.calculate_receipt_digest()?;
636        if actual != self.receipt_digest {
637            return Err(ReleaseError::DeploymentReceiptDigestMismatch {
638                expected: self.receipt_digest.clone(),
639                actual,
640            });
641        }
642        Ok(())
643    }
644
645    fn calculate_receipt_digest(&self) -> Result<String, ReleaseError> {
646        #[derive(Serialize)]
647        struct DigestPayload<'a> {
648            schema_version: u32,
649            attempt_id: &'a str,
650            release_manifest: &'a FileDigest,
651            release_id: &'a str,
652            release_digest: &'a str,
653            environment: &'a ReleaseEnvironment,
654            configuration_digest: &'a str,
655            database_plans: &'a [DatabasePlanBinding],
656            attestations: &'a [FileDigest],
657            outcome: DeploymentOutcome,
658            failure_code: &'a Option<String>,
659            verification: &'a [VerificationEvidence],
660        }
661        let payload = DigestPayload {
662            schema_version: self.schema_version,
663            attempt_id: &self.attempt_id,
664            release_manifest: &self.release_manifest,
665            release_id: &self.release_id,
666            release_digest: &self.release_digest,
667            environment: &self.environment,
668            configuration_digest: &self.configuration_digest,
669            database_plans: &self.database_plans,
670            attestations: &self.attestations,
671            outcome: self.outcome,
672            failure_code: &self.failure_code,
673            verification: &self.verification,
674        };
675        Ok(hex::encode(Sha256::digest(serde_json::to_vec(&payload)?)))
676    }
677}
678
679fn lock_deployment_receipt(path: &Path) -> Result<File, ReleaseError> {
680    let parent = path.parent().unwrap_or_else(|| Path::new("."));
681    let name = path
682        .file_name()
683        .and_then(|name| name.to_str())
684        .ok_or_else(|| ReleaseError::NonUtf8Path(path.display().to_string()))?;
685    let lock_path = parent.join(format!(".{name}.lock"));
686    let lock = std::fs::OpenOptions::new()
687        .read(true)
688        .write(true)
689        .create(true)
690        .truncate(false)
691        .open(lock_path)?;
692    lock.lock()?;
693    Ok(lock)
694}
695
696fn write_new_file(path: &Path, contents: &[u8]) -> Result<(), ReleaseError> {
697    let mut file = std::fs::OpenOptions::new()
698        .write(true)
699        .create_new(true)
700        .open(path)?;
701    file.write_all(contents)?;
702    file.sync_all()?;
703    Ok(())
704}
705
706fn replace_file(path: &Path, contents: &[u8], digest: &str) -> Result<(), ReleaseError> {
707    let parent = path.parent().unwrap_or_else(|| Path::new("."));
708    let name = path
709        .file_name()
710        .and_then(|name| name.to_str())
711        .ok_or_else(|| ReleaseError::NonUtf8Path(path.display().to_string()))?;
712    let temporary = parent.join(format!(".{name}.{}.tmp", &digest[..16]));
713    write_new_file(&temporary, contents)?;
714    if let Err(error) = std::fs::rename(&temporary, path) {
715        let _ = std::fs::remove_file(&temporary);
716        return Err(error.into());
717    }
718    Ok(())
719}
720
721fn validate_release_input(input: &ReleaseManifestInput) -> Result<(), ReleaseError> {
722    if !matches!(input.source_change.len(), 40 | 64)
723        || !input
724            .source_change
725            .bytes()
726            .all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase())
727    {
728        return Err(ReleaseError::InvalidRelease(
729            "source change must be a lowercase 40- or 64-character VCS commit ID".into(),
730        ));
731    }
732    for (value, label) in [
733        (input.environment.application.as_str(), "application"),
734        (input.environment.environment.as_str(), "environment"),
735        (input.environment.region.as_str(), "region"),
736        (input.toolchain.rustc.as_str(), "rustc toolchain"),
737        (
738            input.toolchain.cargo_minco.as_str(),
739            "cargo-minco toolchain",
740        ),
741    ] {
742        validate_release_text(value, label)?;
743    }
744    if let Some(builder) = &input.toolchain.artifact_builder {
745        validate_release_text(builder, "artifact builder toolchain")?;
746    }
747    if input.artifacts.is_empty() {
748        return Err(ReleaseError::InvalidRelease(
749            "release must bind at least one function artifact".into(),
750        ));
751    }
752    let function_ids = input
753        .artifacts
754        .iter()
755        .map(|artifact| artifact.function_id.as_str())
756        .collect::<BTreeSet<_>>();
757    if function_ids.len() != input.artifacts.len() {
758        return Err(ReleaseError::InvalidRelease(
759            "release repeats a function artifact ID".into(),
760        ));
761    }
762    for artifact in &input.artifacts {
763        validate_release_text(&artifact.function_id, "function artifact ID")?;
764        validate_file_digest(&artifact.file, "function artifact")?;
765    }
766    validate_file_digest(&input.contract, "contract")?;
767    validate_file_digest(&input.deployment_plan, "deployment plan")?;
768    validate_file_digest(&input.deployment_template, "deployment template")?;
769    if let Some(lock) = &input.cargo_lock {
770        validate_file_digest(lock, "Cargo.lock")?;
771    }
772    for attestation in &input.attestations {
773        validate_file_digest(attestation, "attestation")?;
774    }
775    if input
776        .attestations
777        .windows(2)
778        .any(|attestations| attestations[0].path == attestations[1].path)
779    {
780        return Err(ReleaseError::InvalidRelease(
781            "release repeats an attestation path".into(),
782        ));
783    }
784    validate_sha256(&input.configuration_digest, "configuration digest")?;
785    validate_sha256(
786        &input.database_sources.migration_catalog,
787        "migration catalog digest",
788    )?;
789    validate_sha256(&input.database_sources.seed_catalog, "seed catalog digest")?;
790    Ok(())
791}
792
793fn validate_release_text(value: &str, label: &str) -> Result<(), ReleaseError> {
794    if value.is_empty()
795        || value.len() > 256
796        || value
797            .chars()
798            .any(|character| character.is_control() || character == '\u{7f}')
799    {
800        return Err(ReleaseError::InvalidRelease(format!(
801            "{label} must contain 1 to 256 non-control characters"
802        )));
803    }
804    Ok(())
805}
806
807fn validate_file_digest(file: &FileDigest, label: &str) -> Result<(), ReleaseError> {
808    if !is_normalized_relative_path(Path::new(&file.path)) {
809        return Err(ReleaseError::InvalidManifestPath(file.path.clone()));
810    }
811    validate_sha256(&file.sha256, &format!("{label} digest"))
812}
813
814fn is_normalized_relative_path(path: &Path) -> bool {
815    !path.as_os_str().is_empty()
816        && !path.is_absolute()
817        && path
818            .components()
819            .all(|component| matches!(component, std::path::Component::Normal(_)))
820}
821
822fn validate_release_manifest(manifest: &ReleaseManifest) -> Result<(), ReleaseError> {
823    validate_release_input(&ReleaseManifestInput {
824        source_change: manifest.source_change.clone(),
825        environment: manifest.environment.clone(),
826        toolchain: manifest.toolchain.clone(),
827        artifacts: manifest.artifacts.clone(),
828        contract: manifest.contract.clone(),
829        configuration_digest: manifest.configuration_digest.clone(),
830        database_sources: manifest.database_sources.clone(),
831        cargo_lock: manifest.cargo_lock.clone(),
832        deployment_plan: manifest.deployment_plan.clone(),
833        deployment_template: manifest.deployment_template.clone(),
834        attestations: manifest.attestations.clone(),
835    })?;
836    validate_sha256(&manifest.release_digest, "release digest")
837}
838
839fn validate_sha256(value: &str, label: &str) -> Result<(), ReleaseError> {
840    if value.len() != 64 || !value.bytes().all(|byte| byte.is_ascii_hexdigit()) {
841        return Err(ReleaseError::InvalidRelease(format!(
842            "{label} must be a lowercase SHA-256 hex digest"
843        )));
844    }
845    if value.bytes().any(|byte| byte.is_ascii_uppercase()) {
846        return Err(ReleaseError::InvalidRelease(format!(
847            "{label} must be a lowercase SHA-256 hex digest"
848        )));
849    }
850    Ok(())
851}
852
853fn validate_identifier(value: &str, label: &str) -> Result<(), ReleaseError> {
854    if value.is_empty()
855        || value.len() > 128
856        || !value
857            .bytes()
858            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.'))
859    {
860        return Err(ReleaseError::InvalidDeploymentReceipt(format!(
861            "{label} must contain 1 to 128 ASCII letters, digits, dots, dashes, or underscores"
862        )));
863    }
864    Ok(())
865}
866
867#[derive(Debug, Error)]
868pub enum ReleaseError {
869    #[error("I/O error: {0}")]
870    Io(#[from] io::Error),
871    #[error("release JSON error: {0}")]
872    Json(#[from] serde_json::Error),
873    #[error("release input is outside the repository root: {0}")]
874    PathOutsideRoot(String),
875    #[error("release manifest path must be a normalized repository-relative UTF-8 path: {0}")]
876    InvalidManifestPath(String),
877    #[error("release input path is not valid UTF-8: {0}")]
878    NonUtf8Path(String),
879    #[error("unsupported release manifest schema version {0}; expected 3")]
880    UnsupportedSchemaVersion(u32),
881    #[error("invalid release manifest: {0}")]
882    InvalidRelease(String),
883    #[error("refusing to replace a different release manifest at {0}")]
884    ReleaseManifestConflict(String),
885    #[error("invalid deployment receipt: {0}")]
886    InvalidDeploymentReceipt(String),
887    #[error("unsupported deployment receipt schema version {0}; expected 1")]
888    UnsupportedDeploymentReceiptSchema(u32),
889    #[error("deployment receipt {0} conflicts with an existing attempt binding")]
890    DeploymentReceiptConflict(String),
891    #[error("deployment receipt digest mismatch: expected {expected}, found {actual}")]
892    DeploymentReceiptDigestMismatch { expected: String, actual: String },
893    #[error("deployment attempt {attempt_id} is already terminal with outcome {outcome:?}")]
894    TerminalDeploymentReceipt {
895        attempt_id: String,
896        outcome: DeploymentOutcome,
897    },
898    #[error("release digest mismatch: expected {expected}, found {actual}")]
899    ReleaseDigestMismatch { expected: String, actual: String },
900    #[error("digest mismatch for {path}: expected {expected}, found {actual}")]
901    DigestMismatch {
902        path: String,
903        expected: String,
904        actual: String,
905    },
906}
907
908#[cfg(test)]
909mod tests {
910    use super::*;
911
912    #[test]
913    fn sealed_release_is_deterministic_and_detects_manifest_tampering() {
914        let directory =
915            std::env::temp_dir().join(format!("minco-release-seal-{}", uuid::Uuid::new_v4()));
916        std::fs::create_dir_all(directory.join("target")).unwrap();
917        std::fs::create_dir_all(directory.join("openapi")).unwrap();
918        std::fs::create_dir_all(directory.join("infra")).unwrap();
919        for (path, contents) in [
920            ("target/api.zip", b"artifact".as_slice()),
921            ("openapi/openapi.yaml", b"openapi: 3.1.0".as_slice()),
922            ("infra/plan.json", b"{}".as_slice()),
923            ("infra/template.yaml", b"Resources: {}".as_slice()),
924        ] {
925            std::fs::write(directory.join(path), contents).unwrap();
926        }
927
928        let input = ReleaseManifestInput {
929            source_change: "a".repeat(40),
930            environment: ReleaseEnvironment {
931                application: "orders".into(),
932                environment: "staging".into(),
933                region: "ap-southeast-2".into(),
934            },
935            toolchain: ToolchainIdentity {
936                rustc: "rustc 1.97.1".into(),
937                cargo_minco: "0.3.1".into(),
938                artifact_builder: Some("cargo-lambda 1.9.1".into()),
939            },
940            artifacts: vec![FunctionArtifact {
941                function_id: "api".into(),
942                file: FileDigest::from_rooted_path(&directory, directory.join("target/api.zip"))
943                    .unwrap(),
944            }],
945            contract: FileDigest::from_rooted_path(
946                &directory,
947                directory.join("openapi/openapi.yaml"),
948            )
949            .unwrap(),
950            configuration_digest: "b".repeat(64),
951            database_sources: DatabaseSourceDigests {
952                migration_catalog: "c".repeat(64),
953                seed_catalog: "d".repeat(64),
954            },
955            cargo_lock: None,
956            deployment_plan: FileDigest::from_rooted_path(
957                &directory,
958                directory.join("infra/plan.json"),
959            )
960            .unwrap(),
961            deployment_template: FileDigest::from_rooted_path(
962                &directory,
963                directory.join("infra/template.yaml"),
964            )
965            .unwrap(),
966            attestations: Vec::new(),
967        };
968
969        let first = ReleaseManifest::seal(input.clone()).unwrap();
970        let second = ReleaseManifest::seal(input.clone()).unwrap();
971        assert_eq!(first, second);
972        assert_eq!(first.schema_version, 3);
973        assert!(first.release_id.starts_with("minco."));
974        first.verify_at(&directory).unwrap();
975
976        let mut tampered = first.clone();
977        tampered.configuration_digest = "e".repeat(64);
978        assert!(matches!(
979            tampered.verify_at(&directory),
980            Err(ReleaseError::ReleaseDigestMismatch { .. })
981        ));
982
983        let manifest_path = directory.join("release.json");
984        first.write_json(&manifest_path).unwrap();
985        let mut replacement_input = input;
986        replacement_input.configuration_digest = "f".repeat(64);
987        let replacement = ReleaseManifest::seal(replacement_input).unwrap();
988        assert!(matches!(
989            replacement.write_json(&manifest_path),
990            Err(ReleaseError::ReleaseManifestConflict(_))
991        ));
992        assert_eq!(ReleaseManifest::read_json(&manifest_path).unwrap(), first);
993
994        let _ = std::fs::remove_dir_all(directory);
995    }
996
997    #[test]
998    fn failed_deployment_receipt_is_terminal() {
999        let receipt = FileDigest {
1000            path: "target/minco/release.json".into(),
1001            sha256: "a".repeat(64),
1002            bytes: 512,
1003        };
1004        let mut deployment = DeploymentReceipt::start(DeploymentReceiptInput {
1005            attempt_id: "attempt-001".into(),
1006            release_manifest: receipt,
1007            release_id: format!("minco.{}", "b".repeat(24)),
1008            release_digest: "b".repeat(64),
1009            environment: ReleaseEnvironment {
1010                application: "orders".into(),
1011                environment: "staging".into(),
1012                region: "ap-southeast-2".into(),
1013            },
1014            configuration_digest: "c".repeat(64),
1015            database_plans: vec![DatabasePlanBinding {
1016                kind: DatabasePlanKind::Migration,
1017                schema_version: 1,
1018                catalog_digest: "d".repeat(64),
1019                plan_digest: "e".repeat(64),
1020                file: FileDigest {
1021                    path: "target/minco/migration-plan.json".into(),
1022                    sha256: "e".repeat(64),
1023                    bytes: 256,
1024                },
1025                selected_set: Some("orders-postgres".into()),
1026                environment: None,
1027            }],
1028            attestations: Vec::new(),
1029        })
1030        .unwrap();
1031
1032        deployment.fail("cloudformation_apply_failed").unwrap();
1033        assert_eq!(deployment.outcome(), DeploymentOutcome::Failed);
1034        assert!(deployment.succeed(Vec::new()).is_err());
1035        assert_eq!(deployment.outcome(), DeploymentOutcome::Failed);
1036        assert_eq!(
1037            deployment.failure_code(),
1038            Some("cloudformation_apply_failed")
1039        );
1040    }
1041
1042    #[test]
1043    fn recorded_failed_deployment_cannot_be_replaced_with_success() {
1044        let directory =
1045            std::env::temp_dir().join(format!("minco-deployment-{}", uuid::Uuid::new_v4()));
1046        std::fs::create_dir_all(&directory).unwrap();
1047        let path = directory.join("attempt-001.json");
1048        let input = DeploymentReceiptInput {
1049            attempt_id: "attempt-001".into(),
1050            release_manifest: FileDigest {
1051                path: "target/minco/release.json".into(),
1052                sha256: "a".repeat(64),
1053                bytes: 512,
1054            },
1055            release_id: format!("minco.{}", "b".repeat(24)),
1056            release_digest: "b".repeat(64),
1057            environment: ReleaseEnvironment {
1058                application: "orders".into(),
1059                environment: "staging".into(),
1060                region: "ap-southeast-2".into(),
1061            },
1062            configuration_digest: "c".repeat(64),
1063            database_plans: vec![DatabasePlanBinding {
1064                kind: DatabasePlanKind::Migration,
1065                schema_version: 1,
1066                catalog_digest: "d".repeat(64),
1067                plan_digest: "e".repeat(64),
1068                file: FileDigest {
1069                    path: "target/minco/migration-plan.json".into(),
1070                    sha256: "e".repeat(64),
1071                    bytes: 256,
1072                },
1073                selected_set: Some("orders-postgres".into()),
1074                environment: None,
1075            }],
1076            attestations: Vec::new(),
1077        };
1078        let mut failed = DeploymentReceipt::start(input.clone()).unwrap();
1079        failed.write_json(&path).unwrap();
1080        failed.fail("cloudformation_apply_failed").unwrap();
1081        failed.write_json(&path).unwrap();
1082
1083        let mut forged_success = DeploymentReceipt::start(input).unwrap();
1084        forged_success
1085            .succeed(vec![VerificationEvidence {
1086                kind: "http_smoke".into(),
1087                file: FileDigest {
1088                    path: "target/minco/http-smoke.json".into(),
1089                    sha256: "f".repeat(64),
1090                    bytes: 128,
1091                },
1092            }])
1093            .unwrap();
1094        assert!(matches!(
1095            forged_success.write_json(&path),
1096            Err(ReleaseError::TerminalDeploymentReceipt { .. })
1097        ));
1098        assert_eq!(
1099            DeploymentReceipt::read_json(&path).unwrap().outcome(),
1100            DeploymentOutcome::Failed
1101        );
1102
1103        let _ = std::fs::remove_dir_all(directory);
1104    }
1105
1106    #[test]
1107    fn deployment_receipt_terminal_transition_is_serialized_across_writers() {
1108        let directory = std::env::temp_dir().join(format!(
1109            "minco-deployment-serialized-{}",
1110            uuid::Uuid::new_v4()
1111        ));
1112        std::fs::create_dir_all(&directory).unwrap();
1113        let path = directory.join("attempt-001.json");
1114        let lock_path = directory.join(".attempt-001.json.lock");
1115        let input = DeploymentReceiptInput {
1116            attempt_id: "attempt-001".into(),
1117            release_manifest: FileDigest {
1118                path: "target/minco/release.json".into(),
1119                sha256: "a".repeat(64),
1120                bytes: 512,
1121            },
1122            release_id: format!("minco.{}", "b".repeat(24)),
1123            release_digest: "b".repeat(64),
1124            environment: ReleaseEnvironment {
1125                application: "orders".into(),
1126                environment: "staging".into(),
1127                region: "ap-southeast-2".into(),
1128            },
1129            configuration_digest: "c".repeat(64),
1130            database_plans: Vec::new(),
1131            attestations: Vec::new(),
1132        };
1133        let started = DeploymentReceipt::start(input.clone()).unwrap();
1134        started.write_json(&path).unwrap();
1135
1136        let lock_file = std::fs::OpenOptions::new()
1137            .read(true)
1138            .write(true)
1139            .open(&lock_path)
1140            .unwrap();
1141        lock_file.lock().unwrap();
1142
1143        let mut failed = DeploymentReceipt::start(input.clone()).unwrap();
1144        failed.fail("cloudformation_apply_failed").unwrap();
1145        let writer_path = path.clone();
1146        let (sender, receiver) = std::sync::mpsc::channel();
1147        let writer = std::thread::spawn(move || {
1148            sender.send(failed.write_json(writer_path)).unwrap();
1149        });
1150
1151        assert!(matches!(
1152            receiver.recv_timeout(std::time::Duration::from_millis(100)),
1153            Err(std::sync::mpsc::RecvTimeoutError::Timeout)
1154        ));
1155        lock_file.unlock().unwrap();
1156        receiver
1157            .recv_timeout(std::time::Duration::from_secs(5))
1158            .unwrap()
1159            .unwrap();
1160        writer.join().unwrap();
1161
1162        let mut forged_success = DeploymentReceipt::start(input).unwrap();
1163        forged_success
1164            .succeed(vec![VerificationEvidence {
1165                kind: "http_smoke".into(),
1166                file: FileDigest {
1167                    path: "target/minco/http-smoke.json".into(),
1168                    sha256: "f".repeat(64),
1169                    bytes: 128,
1170                },
1171            }])
1172            .unwrap();
1173        assert!(matches!(
1174            forged_success.write_json(&path),
1175            Err(ReleaseError::TerminalDeploymentReceipt { .. })
1176        ));
1177
1178        let _ = std::fs::remove_dir_all(directory);
1179    }
1180
1181    #[test]
1182    fn deployment_receipt_independently_verifies_release_plan_and_evidence() {
1183        let directory =
1184            std::env::temp_dir().join(format!("minco-deployment-verify-{}", uuid::Uuid::new_v4()));
1185        for relative in ["target/minco", "target/lambda", "openapi"] {
1186            std::fs::create_dir_all(directory.join(relative)).unwrap();
1187        }
1188        for (path, contents) in [
1189            ("target/lambda/api.zip", b"artifact".as_slice()),
1190            ("openapi/openapi.yaml", b"openapi: 3.1.0".as_slice()),
1191            ("target/minco/plan.json", b"{}".as_slice()),
1192            ("target/minco/template.yaml", b"Resources: {}".as_slice()),
1193            (
1194                "target/minco/http-smoke.json",
1195                b"{\"verified\":true}".as_slice(),
1196            ),
1197        ] {
1198            std::fs::write(directory.join(path), contents).unwrap();
1199        }
1200        let environment = ReleaseEnvironment {
1201            application: "orders".into(),
1202            environment: "staging".into(),
1203            region: "ap-southeast-2".into(),
1204        };
1205        let release = ReleaseManifest::seal(ReleaseManifestInput {
1206            source_change: "a".repeat(40),
1207            environment: environment.clone(),
1208            toolchain: ToolchainIdentity {
1209                rustc: "rustc 1.97.1".into(),
1210                cargo_minco: "0.3.1".into(),
1211                artifact_builder: None,
1212            },
1213            artifacts: vec![FunctionArtifact {
1214                function_id: "api".into(),
1215                file: FileDigest::from_rooted_path(
1216                    &directory,
1217                    directory.join("target/lambda/api.zip"),
1218                )
1219                .unwrap(),
1220            }],
1221            contract: FileDigest::from_rooted_path(
1222                &directory,
1223                directory.join("openapi/openapi.yaml"),
1224            )
1225            .unwrap(),
1226            configuration_digest: "b".repeat(64),
1227            database_sources: DatabaseSourceDigests {
1228                migration_catalog: "c".repeat(64),
1229                seed_catalog: "d".repeat(64),
1230            },
1231            cargo_lock: None,
1232            deployment_plan: FileDigest::from_rooted_path(
1233                &directory,
1234                directory.join("target/minco/plan.json"),
1235            )
1236            .unwrap(),
1237            deployment_template: FileDigest::from_rooted_path(
1238                &directory,
1239                directory.join("target/minco/template.yaml"),
1240            )
1241            .unwrap(),
1242            attestations: Vec::new(),
1243        })
1244        .unwrap();
1245        let release_path = directory.join("target/minco/release.json");
1246        release.write_json(&release_path).unwrap();
1247
1248        let migration_plan_path = directory.join("target/minco/migration-plan.json");
1249        std::fs::write(
1250            &migration_plan_path,
1251            serde_json::to_vec_pretty(&serde_json::json!({
1252                "schema_version": 1,
1253                "catalog_digest": "c".repeat(64),
1254                "digest": "e".repeat(64),
1255                "sets": [],
1256            }))
1257            .unwrap(),
1258        )
1259        .unwrap();
1260        let mut receipt = DeploymentReceipt::start(DeploymentReceiptInput {
1261            attempt_id: "attempt-verified".into(),
1262            release_manifest: FileDigest::from_rooted_path(&directory, &release_path).unwrap(),
1263            release_id: release.release_id.clone(),
1264            release_digest: release.release_digest.clone(),
1265            environment,
1266            configuration_digest: release.configuration_digest,
1267            database_plans: vec![DatabasePlanBinding {
1268                kind: DatabasePlanKind::Migration,
1269                schema_version: 1,
1270                catalog_digest: "c".repeat(64),
1271                plan_digest: "e".repeat(64),
1272                file: FileDigest::from_rooted_path(&directory, &migration_plan_path).unwrap(),
1273                selected_set: None,
1274                environment: None,
1275            }],
1276            attestations: Vec::new(),
1277        })
1278        .unwrap();
1279        receipt
1280            .succeed(vec![VerificationEvidence {
1281                kind: "http_smoke".into(),
1282                file: FileDigest::from_rooted_path(
1283                    &directory,
1284                    directory.join("target/minco/http-smoke.json"),
1285                )
1286                .unwrap(),
1287            }])
1288            .unwrap();
1289        receipt.verify_at(&directory).unwrap();
1290
1291        std::fs::write(migration_plan_path, b"{\"tampered\":true}").unwrap();
1292        assert!(matches!(
1293            receipt.verify_at(&directory),
1294            Err(ReleaseError::DigestMismatch { .. })
1295        ));
1296        let _ = std::fs::remove_dir_all(directory);
1297    }
1298
1299    #[test]
1300    fn detects_file_changes() {
1301        let directory =
1302            std::env::temp_dir().join(format!("minco-release-{}", uuid::Uuid::new_v4()));
1303        std::fs::create_dir_all(&directory).unwrap();
1304        let path = directory.join("artifact");
1305        std::fs::write(&path, b"one").unwrap();
1306        let digest = FileDigest::from_rooted_path(&directory, &path).unwrap();
1307        std::fs::write(&path, b"two").unwrap();
1308        assert!(matches!(
1309            digest.verify_at(&directory),
1310            Err(ReleaseError::DigestMismatch { .. })
1311        ));
1312        let _ = std::fs::remove_dir_all(directory);
1313    }
1314
1315    #[test]
1316    fn file_digest_rejects_independent_hash_and_size_mismatches() {
1317        let directory =
1318            std::env::temp_dir().join(format!("minco-release-digest-{}", uuid::Uuid::new_v4()));
1319        std::fs::create_dir_all(&directory).unwrap();
1320        let path = directory.join("artifact");
1321        std::fs::write(&path, b"one").unwrap();
1322        let digest = FileDigest::from_path(&path).unwrap();
1323
1324        let mut wrong_hash = digest.clone();
1325        wrong_hash.sha256 = "a".repeat(64);
1326        assert!(matches!(
1327            wrong_hash.verify(),
1328            Err(ReleaseError::DigestMismatch { .. })
1329        ));
1330
1331        let mut wrong_size = digest;
1332        wrong_size.bytes += 1;
1333        assert!(matches!(
1334            wrong_size.verify(),
1335            Err(ReleaseError::DigestMismatch { .. })
1336        ));
1337
1338        let _ = std::fs::remove_dir_all(directory);
1339    }
1340
1341    #[test]
1342    fn deployment_start_rejects_every_non_lowercase_sha256_shape() {
1343        let valid = DeploymentReceiptInput {
1344            attempt_id: "attempt-digest".into(),
1345            release_manifest: FileDigest {
1346                path: "target/minco/release.json".into(),
1347                sha256: "a".repeat(64),
1348                bytes: 512,
1349            },
1350            release_id: format!("minco.{}", "b".repeat(24)),
1351            release_digest: "b".repeat(64),
1352            environment: ReleaseEnvironment {
1353                application: "orders".into(),
1354                environment: "staging".into(),
1355                region: "ap-southeast-2".into(),
1356            },
1357            configuration_digest: "c".repeat(64),
1358            database_plans: Vec::new(),
1359            attestations: Vec::new(),
1360        };
1361
1362        for invalid in ["c".repeat(63), "g".repeat(64), "C".repeat(64)] {
1363            let mut input = valid.clone();
1364            input.configuration_digest = invalid;
1365            assert!(matches!(
1366                DeploymentReceipt::start(input),
1367                Err(ReleaseError::InvalidRelease(_))
1368            ));
1369        }
1370    }
1371
1372    #[test]
1373    fn rooted_digests_are_portable_and_verify_from_the_repository_root() {
1374        let directory =
1375            std::env::temp_dir().join(format!("minco-release-root-{}", uuid::Uuid::new_v4()));
1376        std::fs::create_dir_all(directory.join("target")).unwrap();
1377        let path = directory.join("target/artifact.zip");
1378        std::fs::write(&path, b"artifact").unwrap();
1379
1380        let digest = FileDigest::from_rooted_path(&directory, &path).unwrap();
1381        assert_eq!(digest.path, "target/artifact.zip");
1382        digest.verify_at(&directory).unwrap();
1383
1384        let outside = std::env::temp_dir().join(format!("minco-outside-{}", uuid::Uuid::new_v4()));
1385        std::fs::write(&outside, b"outside").unwrap();
1386        assert!(matches!(
1387            FileDigest::from_rooted_path(&directory, &outside),
1388            Err(ReleaseError::PathOutsideRoot(_))
1389        ));
1390        let outside_digest = FileDigest::from_path(&outside).unwrap();
1391        assert!(matches!(
1392            outside_digest.verify_at(&directory),
1393            Err(ReleaseError::InvalidManifestPath(_))
1394        ));
1395        let parent_digest = FileDigest {
1396            path: "../artifact.zip".into(),
1397            sha256: digest.sha256.clone(),
1398            bytes: digest.bytes,
1399        };
1400        assert!(matches!(
1401            parent_digest.verify_at(&directory),
1402            Err(ReleaseError::InvalidManifestPath(_))
1403        ));
1404
1405        let _ = std::fs::remove_file(outside);
1406        let _ = std::fs::remove_dir_all(directory);
1407    }
1408}