argone-signing 0.1.1

Sign Argone packages and verify their trust chain (Ed25519 + BLAKE3).
Documentation
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)?;
    // 1. root must have countersigned the publisher's key.
    keys::verify(root_pubkey, &pubkey, &countersig).map_err(|_| SigError::UntrustedKey)?;
    // 2. publisher must have signed the artifact digest.
    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");
        // attacker self-signs the artifact but the root never countersigned attacker's key
        let env = Envelope {
            artifact_sig: attacker.sign(&d).to_vec(),
            publisher_pubkey: attacker.public().to_vec(),
            root_countersig: attacker.sign(&attacker.public()).to_vec(), // signed by attacker, not root
        };
        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);
    }
}