argone-signing 0.1.1

Sign Argone packages and verify their trust chain (Ed25519 + BLAKE3).
Documentation
use crate::SigError;
use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};

pub struct Keypair(SigningKey);

impl Keypair {
    pub fn generate() -> Keypair {
        Keypair(SigningKey::generate(&mut rand_core::OsRng))
    }
    pub fn from_seed(seed: [u8; 32]) -> Keypair {
        Keypair(SigningKey::from_bytes(&seed))
    }
    pub fn public(&self) -> [u8; 32] {
        self.0.verifying_key().to_bytes()
    }
    pub fn secret_seed(&self) -> [u8; 32] {
        self.0.to_bytes()
    }
    pub fn sign(&self, msg: &[u8]) -> [u8; 64] {
        self.0.sign(msg).to_bytes()
    }
}

pub fn verify(pubkey: &[u8; 32], msg: &[u8], sig: &[u8; 64]) -> Result<(), SigError> {
    let vk = VerifyingKey::from_bytes(pubkey).map_err(|_| SigError::UntrustedKey)?;
    let sig = Signature::from_bytes(sig);
    vk.verify(msg, &sig).map_err(|_| SigError::BadSignature)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn sign_then_verify_ok() {
        let kp = Keypair::from_seed([7u8; 32]);
        let sig = kp.sign(b"payload");
        assert!(verify(&kp.public(), b"payload", &sig).is_ok());
    }

    #[test]
    fn tampered_message_fails() {
        let kp = Keypair::from_seed([7u8; 32]);
        let sig = kp.sign(b"payload");
        assert_eq!(
            verify(&kp.public(), b"PAYLOAD", &sig),
            Err(crate::SigError::BadSignature)
        );
    }

    #[test]
    fn wrong_key_fails() {
        let kp = Keypair::from_seed([7u8; 32]);
        let other = Keypair::from_seed([9u8; 32]);
        let sig = kp.sign(b"payload");
        assert_eq!(
            verify(&other.public(), b"payload", &sig),
            Err(crate::SigError::BadSignature)
        );
    }

    #[test]
    fn from_seed_is_deterministic() {
        assert_eq!(
            Keypair::from_seed([1u8; 32]).public(),
            Keypair::from_seed([1u8; 32]).public()
        );
    }
}