vwh-core 1.0.0

Cryptographic accountability tool for verifying digital presence.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use crate::{Error, KeyFingerprint, Result};
use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};

/// Sign bytes with Ed25519 signing key
pub fn sign(signing_key: &SigningKey, message: &[u8]) -> [u8; 64] {
    let signature = signing_key.sign(message);
    signature.to_bytes()
}

/// Verify Ed25519 signature
pub fn verify(
    public_key: &[u8; 32],
    message: &[u8],
    signature: &[u8; 64],
) -> Result<()> {
    let verifying_key = VerifyingKey::from_bytes(public_key)
        .map_err(|_| Error::SignatureInvalid)?;
    
    let sig = Signature::from_bytes(signature);
    
    verifying_key
        .verify(message, &sig)
        .map_err(|_| Error::SignatureInvalid)
}

/// Calculate fingerprint of a public key
pub fn fingerprint(public_key: &[u8; 32]) -> KeyFingerprint {
    KeyFingerprint::new(public_key)
}

#[cfg(test)]
mod tests {
    use super::*;
    use ed25519_dalek::SigningKey;
    use rand::rngs::OsRng;

    #[test]
    fn test_sign_and_verify() {
        let signing_key = SigningKey::generate(&mut OsRng);
        let public_key = signing_key.verifying_key().to_bytes();
        let message = b"test message";

        let signature = sign(&signing_key, message);
        assert!(verify(&public_key, message, &signature).is_ok());
    }

    #[test]
    fn test_verify_invalid_signature() {
        let signing_key = SigningKey::generate(&mut OsRng);
        let public_key = signing_key.verifying_key().to_bytes();
        let message = b"test message";
        let wrong_signature = [0u8; 64];

        assert!(verify(&public_key, message, &wrong_signature).is_err());
    }

    #[test]
    fn test_verify_wrong_message() {
        let signing_key = SigningKey::generate(&mut OsRng);
        let public_key = signing_key.verifying_key().to_bytes();
        let message = b"test message";
        let wrong_message = b"wrong message";

        let signature = sign(&signing_key, message);
        assert!(verify(&public_key, wrong_message, &signature).is_err());
    }
}