use crate::{keys, keys::Keypair, SigError};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Envelope {
pub artifact_sig: Vec<u8>,
pub publisher_pubkey: Vec<u8>,
pub root_countersig: Vec<u8>,
}
impl Envelope {
pub fn to_mpack(&self) -> Result<Vec<u8>, SigError> {
rmp_serde::to_vec_named(self).map_err(|e| SigError::Json(e.to_string()))
}
pub fn from_mpack(b: &[u8]) -> Result<Envelope, SigError> {
rmp_serde::from_slice(b).map_err(|e| SigError::Json(e.to_string()))
}
}
pub fn countersign(root: &Keypair, publisher_pubkey: &[u8; 32]) -> [u8; 64] {
root.sign(publisher_pubkey)
}
fn arr32(v: &[u8]) -> Result<[u8; 32], SigError> {
v.try_into().map_err(|_| SigError::BadLength)
}
fn arr64(v: &[u8]) -> Result<[u8; 64], SigError> {
v.try_into().map_err(|_| SigError::BadLength)
}
pub fn verify_chain(
root_pubkey: &[u8; 32],
env: &Envelope,
digest: &[u8; 32],
) -> Result<(), SigError> {
let pubkey = arr32(&env.publisher_pubkey)?;
let countersig = arr64(&env.root_countersig)?;
let artifact_sig = arr64(&env.artifact_sig)?;
keys::verify(root_pubkey, &pubkey, &countersig).map_err(|_| SigError::UntrustedKey)?;
keys::verify(&pubkey, digest, &artifact_sig)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::digest;
fn envelope(root: &Keypair, publisher: &Keypair, d: &[u8; 32]) -> Envelope {
Envelope {
artifact_sig: publisher.sign(d).to_vec(),
publisher_pubkey: publisher.public().to_vec(),
root_countersig: countersign(root, &publisher.public()).to_vec(),
}
}
#[test]
fn full_chain_verifies() {
let root = Keypair::from_seed([1u8; 32]);
let pubr = Keypair::from_seed([2u8; 32]);
let d = digest(b"wasm", b"mpack", b"release");
let env = envelope(&root, &pubr, &d);
assert!(verify_chain(&root.public(), &env, &d).is_ok());
}
#[test]
fn uncountersigned_key_is_untrusted() {
let root = Keypair::from_seed([1u8; 32]);
let attacker = Keypair::from_seed([2u8; 32]);
let d = digest(b"wasm", b"mpack", b"release");
let env = Envelope {
artifact_sig: attacker.sign(&d).to_vec(),
publisher_pubkey: attacker.public().to_vec(),
root_countersig: attacker.sign(&attacker.public()).to_vec(), };
assert_eq!(
verify_chain(&root.public(), &env, &d),
Err(SigError::UntrustedKey)
);
}
#[test]
fn tampered_digest_is_bad_signature() {
let root = Keypair::from_seed([1u8; 32]);
let pubr = Keypair::from_seed([2u8; 32]);
let d = digest(b"wasm", b"mpack", b"release");
let env = envelope(&root, &pubr, &d);
let d2 = digest(b"wasm", b"mpack", b"TAMPERED");
assert_eq!(
verify_chain(&root.public(), &env, &d2),
Err(SigError::BadSignature)
);
}
#[test]
fn envelope_mpack_round_trips() {
let root = Keypair::from_seed([1u8; 32]);
let pubr = Keypair::from_seed([2u8; 32]);
let d = digest(b"a", b"b", b"c");
let env = envelope(&root, &pubr, &d);
assert_eq!(Envelope::from_mpack(&env.to_mpack().unwrap()).unwrap(), env);
}
}