concordium_base 10.0.0

A library that defines common types and functionality that are needed by Concordium Rust projects.
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::{common::*, curve_arithmetic::*, pedersen_commitment::Commitment};

use rand::*;
use std::ops::Deref;

use std::rc::Rc;

#[derive(Debug, Serialize)]
/// A message to sign. In contrast to [KnownMessage](super::KnownMessage) this
/// is a single group element that must be constructed in a special way. The
/// idea is that this message is a commitment to some values. The person signing
/// only knows the commitment, but does not know the values they are signing
/// directly.
pub struct UnknownMessage<C: Pairing>(pub C::G1);

impl<C: Pairing> PartialEq for UnknownMessage<C> {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

impl<C: Pairing> Eq for UnknownMessage<C> {}

/// This trait allows automatic conversion of `&Value<C>` to `&C::Scalar`.
impl<P: Pairing> Deref for UnknownMessage<P> {
    type Target = P::G1;

    fn deref(&self) -> &P::G1 {
        &self.0
    }
}

impl<P: Pairing> From<Commitment<P::G1>> for UnknownMessage<P> {
    fn from(cmm: Commitment<P::G1>) -> Self {
        UnknownMessage(cmm.0)
    }
}

/// Randomness used to retrieve signature on the message from signature on an
/// unknown message.
#[derive(Debug, Eq, PartialEq, Serialize)]
#[repr(transparent)]
pub struct SigRetrievalRandomness<P: Pairing> {
    pub randomness: Rc<Secret<P::ScalarField>>,
}

/// This trait allows automatic conversion of `&SigRetrievalRandomness<C>` to
/// `&C::Scalar`.
impl<C: Pairing> std::ops::Deref for SigRetrievalRandomness<C> {
    type Target = C::ScalarField;

    fn deref(&self) -> &C::ScalarField {
        &self.randomness
    }
}

impl<C: Pairing> AsRef<C::ScalarField> for SigRetrievalRandomness<C> {
    fn as_ref(&self) -> &C::ScalarField {
        &self.randomness
    }
}

impl<C: Pairing> SigRetrievalRandomness<C> {
    pub fn new(secret: C::ScalarField) -> Self {
        SigRetrievalRandomness {
            randomness: Rc::new(Secret::new(secret)),
        }
    }

    /// Generate a non-zero SigRetrievalRandomness `SigRetrievalRandomness` from
    /// a `csprng`.
    pub fn generate_non_zero<T: Rng>(csprng: &mut T) -> SigRetrievalRandomness<C> {
        SigRetrievalRandomness::new(C::generate_non_zero_scalar(csprng))
    }
}

impl<C: Pairing> UnknownMessage<C> {
    /// Generate a valid, but arbitrary message. Exposed because it can be used
    /// for testing protocols built on top of the signature scheme.
    pub fn arbitrary<T: Rng>(csprng: &mut T) -> UnknownMessage<C> {
        UnknownMessage(C::G1::generate(csprng))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    type Bls12 = ark_ec::models::bls12::Bls12<ark_bls12_381::Config>;

    macro_rules! macro_test_unknown_message_to_byte_conversion {
        ($function_name:ident, $pairing_type:path) => {
            #[test]
            pub fn $function_name() {
                let mut csprng = thread_rng();
                for _i in 0..20 {
                    let x = UnknownMessage::<$pairing_type>::arbitrary(&mut csprng);
                    let y = serialize_deserialize(&x);
                    assert!(y.is_ok());
                    assert_eq!(x, y.unwrap());
                }
            }
        };
    }
    macro_test_unknown_message_to_byte_conversion!(
        unknown_message_to_byte_conversion_bls12_381,
        Bls12
    );
}