use crate::error::{PackageError, Result};
use olpc_cjson::CanonicalFormatter;
use serde::{Deserialize, Serialize};
use serde_json::Serializer;
use sha2::{Digest as _, Sha256};
use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct ManifestDigest(String);
impl ManifestDigest {
pub fn from_bytes(bytes: &[u8]) -> Self {
let hash = Sha256::digest(bytes);
ManifestDigest(format!("sha256:{}", hex::encode(hash)))
}
pub fn parse(s: &str) -> Result<Self> {
let hex_part = s
.strip_prefix("sha256:")
.ok_or_else(|| PackageError::MalformedDigest {
reason: format!("missing 'sha256:' prefix: {s:?}"),
})?;
if !is_lowercase_sha256_hex(hex_part) {
return Err(PackageError::MalformedDigest {
reason: format!(
"expected 64 lowercase hex chars after 'sha256:', got: {hex_part:?}"
),
});
}
Ok(ManifestDigest(s.to_string()))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Display for ManifestDigest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
impl TryFrom<String> for ManifestDigest {
type Error = PackageError;
fn try_from(s: String) -> Result<Self> {
Self::parse(&s)
}
}
impl From<ManifestDigest> for String {
fn from(digest: ManifestDigest) -> String {
digest.0
}
}
impl TryFrom<&oci_spec::image::Digest> for ManifestDigest {
type Error = PackageError;
fn try_from(digest: &oci_spec::image::Digest) -> Result<Self> {
if digest.algorithm() != &oci_spec::image::DigestAlgorithm::Sha256 {
return Err(PackageError::MalformedDigest {
reason: format!("expected sha256 algorithm, got: {}", digest.algorithm()),
});
}
Self::parse(&format!("sha256:{}", digest.digest()))
}
}
fn is_lowercase_sha256_hex(s: &str) -> bool {
s.len() == 64 && s.bytes().all(|b| matches!(b, b'0'..=b'9' | b'a'..=b'f'))
}
pub fn canonicalize<T: Serialize>(value: &T) -> Result<Vec<u8>> {
let mut buf = Vec::new();
let mut ser = Serializer::with_formatter(&mut buf, CanonicalFormatter::new());
value.serialize(&mut ser).map_err(PackageError::Serialize)?;
Ok(buf)
}
pub fn manifest_digest<T: Serialize>(value: &T) -> Result<ManifestDigest> {
let bytes = canonicalize(value)?;
Ok(ManifestDigest::from_bytes(&bytes))
}
#[cfg(test)]
mod tests {
use super::*;
use proptest::prelude::*;
use std::collections::BTreeMap;
use std::str::FromStr;
#[derive(Serialize)]
struct Sample {
b: i32,
a: String,
}
#[derive(Serialize)]
struct MapSample {
name: String,
values: BTreeMap<String, i64>,
}
#[test]
fn canonicalize_is_byte_stable_across_repeated_calls() {
let s = Sample {
b: 1,
a: "x".to_string(),
};
let first = canonicalize(&s).unwrap();
let second = canonicalize(&s).unwrap();
assert_eq!(first, second);
}
#[test]
fn canonicalize_sorts_object_keys_independent_of_declaration_order() {
let s = Sample {
b: 1,
a: "x".to_string(),
};
let bytes = canonicalize(&s).unwrap();
let text = String::from_utf8(bytes).unwrap();
assert_eq!(text, r#"{"a":"x","b":1}"#);
}
proptest! {
#[test]
fn canonicalize_is_stable_regardless_of_map_insertion_order(
mut pairs in prop::collection::vec(("[a-z]{1,8}", any::<i64>()), 0..8)
) {
pairs.sort_by(|a, b| a.0.cmp(&b.0));
pairs.dedup_by(|a, b| a.0 == b.0);
let mut forward = BTreeMap::new();
for (k, v) in pairs.iter() {
forward.insert(k.clone(), *v);
}
let mut backward = BTreeMap::new();
for (k, v) in pairs.iter().rev() {
backward.insert(k.clone(), *v);
}
let sample_a = MapSample { name: "x".to_string(), values: forward };
let sample_b = MapSample { name: "x".to_string(), values: backward };
let bytes_a = canonicalize(&sample_a).unwrap();
let bytes_b = canonicalize(&sample_b).unwrap();
prop_assert_eq!(bytes_a, bytes_b);
}
}
#[test]
fn from_bytes_yields_sha256_lowercase_hex_form() {
let digest = ManifestDigest::from_bytes(b"hello world");
let s = digest.as_str();
assert!(s.starts_with("sha256:"));
let hex_part = s.strip_prefix("sha256:").unwrap();
assert_eq!(hex_part.len(), 64);
assert!(hex_part
.bytes()
.all(|b| matches!(b, b'0'..=b'9' | b'a'..=b'f')));
}
#[test]
fn parse_accepts_well_formed_digest() {
let hex = "a".repeat(64);
let s = format!("sha256:{hex}");
let digest = ManifestDigest::parse(&s).unwrap();
assert_eq!(digest.as_str(), s);
}
#[test]
fn parse_rejects_missing_prefix() {
let err = ManifestDigest::parse(&"a".repeat(64)).unwrap_err();
assert!(matches!(err, PackageError::MalformedDigest { .. }));
}
#[test]
fn parse_rejects_wrong_length() {
let err = ManifestDigest::parse("sha256:zz").unwrap_err();
assert!(matches!(err, PackageError::MalformedDigest { .. }));
}
#[test]
fn parse_rejects_non_hex() {
let bad = format!("sha256:{}", "g".repeat(64));
let err = ManifestDigest::parse(&bad).unwrap_err();
assert!(matches!(err, PackageError::MalformedDigest { .. }));
}
#[test]
fn parse_rejects_uppercase_hex() {
let bad = format!("sha256:{}", "A".repeat(64));
let err = ManifestDigest::parse(&bad).unwrap_err();
assert!(matches!(err, PackageError::MalformedDigest { .. }));
}
#[test]
fn manifest_digest_is_stable_across_repeated_calls() {
let s = Sample {
b: 1,
a: "x".to_string(),
};
let first = manifest_digest(&s).unwrap();
let second = manifest_digest(&s).unwrap();
assert_eq!(first, second);
}
#[test]
fn manifest_digest_canonicalizes_then_hashes() {
let s = Sample {
b: 1,
a: "x".to_string(),
};
let canonical_bytes = canonicalize(&s).unwrap();
let expected = ManifestDigest::from_bytes(&canonical_bytes);
let actual = manifest_digest(&s).unwrap();
assert_eq!(actual, expected);
}
#[test]
fn deserialize_routes_through_parse() {
let hex = "a".repeat(64);
let json = format!("\"sha256:{hex}\"");
let digest: ManifestDigest = serde_json::from_str(&json).unwrap();
assert_eq!(digest.as_str(), format!("sha256:{hex}"));
}
#[test]
fn deserialize_rejects_malformed_string_via_parse() {
let result = serde_json::from_str::<ManifestDigest>("\"not-a-digest\"");
assert!(
result.is_err(),
"malformed digest string must fail to deserialize"
);
}
#[test]
fn serialize_emits_plain_sha256_hex_string() {
let digest = ManifestDigest::from_bytes(b"hello");
let json = serde_json::to_string(&digest).unwrap();
assert!(json.starts_with("\"sha256:"));
assert!(json.ends_with('"'));
assert_eq!(json.matches('"').count(), 2);
}
#[test]
fn manifest_digest_construction_only_via_parse_or_from_bytes() {
let digest_str = format!("sha256:{}", "0".repeat(64));
let _from_parse: ManifestDigest = ManifestDigest::parse(&digest_str).unwrap();
let _from_bytes: ManifestDigest = ManifestDigest::from_bytes(b"anything");
}
#[test]
fn try_from_oci_digest_succeeds_for_sha256() {
let hex = "b".repeat(64);
let oci_digest = oci_spec::image::Digest::from_str(&format!("sha256:{hex}")).unwrap();
let md = ManifestDigest::try_from(&oci_digest).unwrap();
assert_eq!(md.as_str(), format!("sha256:{hex}"));
}
#[test]
fn try_from_oci_digest_rejects_non_sha256_algorithm() {
let hex = "c".repeat(128);
let oci_digest = oci_spec::image::Digest::from_str(&format!("sha512:{hex}")).unwrap();
let err = ManifestDigest::try_from(&oci_digest).unwrap_err();
assert!(matches!(err, PackageError::MalformedDigest { .. }));
}
}