arcium-primitives 0.4.3

Arcium primitives
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
69
70
71
72
73
74
75
76
77

pub use ed25519_dalek::{Signature, SigningKey, VerifyingKey};
use ed25519_dalek::{Signer as DalekSigner, Verifier as DalekVerifier};
use itertools::chain;

use crate::{errors::PrimitiveError, types::SessionId};

/// Message identifier type: (SessionId, round, protocol tag)
pub type MessageId = (SessionId, u16, &'static [u8]);

// ------------------------------ Defaults ---------------------------------- //
// Set Ed25519 as the default signing scheme
pub trait Signer: UCSigner<Signature> {}
impl<SR: UCSigner<Signature>> Signer for SR {}

pub trait Verifier: UCVerifier<Signature> + Sync + Send {}
impl<VR: UCVerifier<Signature>> Verifier for VR {}

// -------------------------------- Traits ---------------------------------- //
/// Signer that signs messages alongside metadata (round, protocol tag and session ID)
/// to avoid replay attacks in UC protocols.
pub trait UCSigner<S>: DalekSigner<S> + Sync + Send {
    /// Signs a message for a protocol, uniquely identified by the triple (round, protocol tag,
    /// session ID) to avoid replay attacks.
    fn sign_with(&self, message: &[u8], id: &MessageId) -> Result<S, PrimitiveError> {
        let round = id.1.to_le_bytes();
        let message_with_id: Vec<u8> = chain!(message, &id.0, &round, id.2).copied().collect();
        let signature = self
            .try_sign(&message_with_id)
            .map_err(|e| PrimitiveError::WrongSignature(e.to_string()))?;
        Ok(signature)
    }
}

/// Verifier that verifies message signatures with metadata (round, protocol tag and session ID)
/// to avoid replay attacks in UC protocols.
pub trait UCVerifier<S>: DalekVerifier<S> + Sync + Send {
    /// Verifies a signature for a protocol, uniquely identified by the triple (round, protocol tag,
    /// session ID) to avoid replay attacks.
    fn verify_with(
        &self,
        message: &[u8],
        signature: &S,
        &id: &MessageId,
    ) -> Result<(), PrimitiveError> {
        let round = id.1.to_le_bytes();
        let message_with_id: Vec<u8> = chain!(message, &id.0, &round, id.2).copied().collect();
        self.verify(&message_with_id, signature)
            .map_err(|e| PrimitiveError::WrongSignature(e.to_string()))?;
        Ok(())
    }
}

impl<S, T: DalekSigner<S> + Sync + Send> UCSigner<S> for T {}
impl<S, T: DalekVerifier<S> + Sync + Send> UCVerifier<S> for T {}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        random::{self, Random},
        types::SessionId,
    };

    #[test]
    fn test_sign_protocol_message() {
        let mut rng = random::test_rng();
        let signing_key = SigningKey::generate(&mut rng);
        let message = b"Hello, protocol!";
        let protocol_id: &'static [u8] = &[2, 1];
        let message_id = (SessionId::random(&mut rng), 1, protocol_id);

        let signature = signing_key.sign_with(message, &message_id).unwrap();
        assert!(signing_key
            .verify_with(message, &signature, &message_id)
            .is_ok());
    }
}