#[cfg(feature = "pack-signing")]
use identity::{Ed25519Keypair, Ed25519PublicKey, Ed25519Signature};
use serde::{Deserialize, Serialize};
use crate::schema::{ManifestId, SchemaRef};
#[cfg(feature = "pack-signing")]
use crate::schema::{SignatureRef, TrustEnvelope};
use crate::typed::TypedPayload;
pub const PACK_SCHEMA: &str = "mere.pack/v1";
pub const PACK_SIG_PREFIX: &str = "personae:ed25519:";
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PackPartRole {
ScenarioSource,
WasmComponent,
Asset,
#[serde(other)]
Unknown,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PackPart {
pub name: String,
pub role: PackPartRole,
pub blob: ManifestId,
pub bytes: u64,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PackManifest {
pub name: String,
pub version: String,
pub author: String,
pub requested_scopes: Vec<String>,
pub parts: Vec<PackPart>,
}
impl TypedPayload for PackManifest {
fn schema_ref() -> SchemaRef {
SchemaRef::from_id(ManifestId::of_blob(b"schema:mere.pack/v1"))
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PackVerdict {
Trusted,
Unsigned,
Broken,
}
pub fn canonical_bytes(manifest: &PackManifest) -> Vec<u8> {
serde_json::to_vec(manifest).unwrap_or_default()
}
#[cfg(feature = "pack-signing")]
pub fn sign_pack(manifest: &PackManifest, keypair: &Ed25519Keypair) -> SignatureRef {
let signature = keypair.sign(&canonical_bytes(manifest));
SignatureRef(format!(
"{PACK_SIG_PREFIX}{}:{}",
hex(&keypair.public_key().to_bytes()),
hex(&signature.to_bytes()),
))
}
#[cfg(feature = "pack-signing")]
pub fn verify_pack(manifest: &PackManifest, envelope: &TrustEnvelope) -> PackVerdict {
for sig in &envelope.signatures {
let Some(rest) = sig.0.strip_prefix(PACK_SIG_PREFIX) else {
continue; };
let Some((pub_hex, sig_hex)) = rest.split_once(':') else {
return PackVerdict::Broken;
};
if pub_hex != manifest.author {
return PackVerdict::Broken;
}
let (Some(pub_bytes), Some(sig_bytes)) = (unhex::<32>(pub_hex), unhex::<64>(sig_hex))
else {
return PackVerdict::Broken;
};
let Ok(public) = Ed25519PublicKey::from_bytes(&pub_bytes) else {
return PackVerdict::Broken;
};
let signature = Ed25519Signature::from_bytes(&sig_bytes);
if public.verify(&canonical_bytes(manifest), &signature) {
return PackVerdict::Trusted;
}
return PackVerdict::Broken;
}
PackVerdict::Unsigned
}
#[cfg(feature = "pack-signing")]
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
#[cfg(feature = "pack-signing")]
fn unhex<const N: usize>(hex: &str) -> Option<[u8; N]> {
if hex.len() != N * 2 {
return None;
}
let mut out = [0u8; N];
for (i, chunk) in hex.as_bytes().chunks(2).enumerate() {
let s = std::str::from_utf8(chunk).ok()?;
out[i] = u8::from_str_radix(s, 16).ok()?;
}
Some(out)
}
#[cfg(all(test, feature = "pack-signing"))]
mod tests {
use super::*;
use crate::schema::{
ModerationState, PrivacyClass, ProvenanceOrigin, ProvenanceRecord, Timestamp, TrustLevel,
};
use crate::typed::{load_typed, save_typed};
use muniment::MemoryBackend;
fn keypair() -> Ed25519Keypair {
Ed25519Keypair::from_seed([11u8; 32])
}
fn manifest(author: &Ed25519Keypair) -> PackManifest {
PackManifest {
name: "trail-keeper".to_string(),
version: "0.1.0".to_string(),
author: hex(&author.public_key().to_bytes()),
requested_scopes: vec!["scenario/".to_string(), "app/".to_string()],
parts: vec![PackPart {
name: "main.lua".to_string(),
role: PackPartRole::ScenarioSource,
blob: ManifestId::of_blob(b"mere.open('mere://kept/note')"),
bytes: 29,
}],
}
}
fn envelope_with(sig: SignatureRef) -> TrustEnvelope {
TrustEnvelope {
level: TrustLevel::SelfAsserted,
signatures: vec![sig],
moderation_state: ModerationState::Unreviewed,
}
}
#[test]
fn a_signed_pack_round_trips_and_verifies() {
pollster::block_on(async {
let kp = keypair();
let pack = manifest(&kp);
let sig = sign_pack(&pack, &kp);
assert_eq!(
verify_pack(&pack, &envelope_with(sig.clone())),
PackVerdict::Trusted
);
let mut store = MemoryBackend::default();
let at = Timestamp(1);
let id = save_typed(
&mut store,
&pack,
Vec::new(),
PrivacyClass::LocalOnly,
ProvenanceRecord {
origin: ProvenanceOrigin::Generated,
upstream: Vec::new(),
tooling: Some(PACK_SCHEMA.to_string()),
generated_at: at,
},
envelope_with(sig.clone()),
at,
)
.await
.unwrap();
let mut fetcher = crate::manifest::NoFetcher;
let restored: PackManifest = load_typed(&mut store, &mut fetcher, id)
.await
.unwrap()
.expect("the pack manifest resolves locally");
assert_eq!(restored, pack, "the manifest round-trips bit-equal");
assert_eq!(
verify_pack(&restored, &envelope_with(sig)),
PackVerdict::Trusted,
"the restored pack still verifies"
);
});
}
#[test]
fn a_tampered_pack_is_broken() {
let kp = keypair();
let pack = manifest(&kp);
let envelope = envelope_with(sign_pack(&pack, &kp));
let mut renamed = pack.clone();
renamed.version = "9.9.9".to_string();
assert_eq!(verify_pack(&renamed, &envelope), PackVerdict::Broken);
let mut swapped_part = pack.clone();
swapped_part.parts[0].blob = ManifestId::of_blob(b"os.execute('rm -rf /')");
assert_eq!(verify_pack(&swapped_part, &envelope), PackVerdict::Broken);
let mut widened = pack.clone();
widened.requested_scopes.push("wallet/".to_string());
assert_eq!(
verify_pack(&widened, &envelope),
PackVerdict::Broken,
"a widened ask cannot ride an old signature"
);
}
#[test]
fn wrong_author_is_broken_and_no_claim_is_unsigned() {
let kp = keypair();
let intruder = Ed25519Keypair::from_seed([99u8; 32]);
let pack = manifest(&kp);
let forged = sign_pack(&pack, &intruder);
assert_eq!(
verify_pack(&pack, &envelope_with(forged)),
PackVerdict::Broken
);
let malformed = SignatureRef(format!("{PACK_SIG_PREFIX}nonsense"));
assert_eq!(
verify_pack(&pack, &envelope_with(malformed)),
PackVerdict::Broken
);
let unsigned = TrustEnvelope::self_asserted();
assert_eq!(verify_pack(&pack, &unsigned), PackVerdict::Unsigned);
let foreign = envelope_with(SignatureRef("did:web:example#sig".to_string()));
assert_eq!(verify_pack(&pack, &foreign), PackVerdict::Unsigned);
}
}