1#![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}