blsful 4.0.0

BLS signature implementation according to the IETF spec on the BLS12-381 curve.
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

use crate::*;
use subtle::CtOption;

/// Time-lock ciphertext for either supported BLS12-381 signature group.
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum TimeCryptCiphertextEnum {
    /// A ciphertext using signatures in G1 and public keys in G2.
    G1(TimeCryptCiphertext<Bls12381G1Impl>),
    /// A ciphertext using signatures in G2 and public keys in G1.
    G2(TimeCryptCiphertext<Bls12381G2Impl>),
}

impl Default for TimeCryptCiphertextEnum {
    fn default() -> Self {
        Self::G1(TimeCryptCiphertext::default())
    }
}

impl TimeCryptCiphertextEnum {
    /// Return the concrete BLS12-381 signature group for this ciphertext.
    pub fn curve(&self) -> Bls12381 {
        match self {
            Self::G1(_) => Bls12381::G1,
            Self::G2(_) => Bls12381::G2,
        }
    }

    /// Return the signature scheme used to create this ciphertext.
    pub const fn scheme(&self) -> SignatureSchemes {
        match self {
            Self::G1(ciphertext) => ciphertext.scheme(),
            Self::G2(ciphertext) => ciphertext.scheme(),
        }
    }

    /// Decrypt the time-lock ciphertext with a matching dynamic signature.
    pub fn decrypt(&self, sig: &SignatureEnum) -> CtOption<Vec<u8>> {
        match (self, sig) {
            (Self::G1(ciphertext), SignatureEnum::G1(sig)) => ciphertext.decrypt(sig),
            (Self::G2(ciphertext), SignatureEnum::G2(sig)) => ciphertext.decrypt(sig),
            _ => CtOption::new(vec![], 0u8.into()),
        }
    }
}

/// A time-lock encryption ciphertext.
#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct TimeCryptCiphertext<C: BlsSignatureImpl> {
    /// The `u` component
    #[serde(serialize_with = "traits::public_key::serialize::<C, _>")]
    #[serde(deserialize_with = "traits::public_key::deserialize::<C, _>")]
    pub u: <C as Pairing>::PublicKey,
    /// The `v` component
    pub v: [u8; 32],
    /// The `w` component
    pub w: Vec<u8>,
    /// The signature scheme used to generate this ciphertext
    pub scheme: SignatureSchemes,
}

impl<C: BlsSignatureImpl> TryFrom<&TimeCryptCiphertext<C>> for Vec<u8> {
    type Error = BlsError;

    fn try_from(value: &TimeCryptCiphertext<C>) -> BlsResult<Self> {
        serde_bare::to_vec(value).map_err(|e| BlsError::SerializationError(e.to_string()))
    }
}

impl<C: BlsSignatureImpl> TryFrom<&[u8]> for TimeCryptCiphertext<C> {
    type Error = BlsError;

    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
        let output = serde_bare::from_slice(value)?;
        Ok(output)
    }
}

impl_from_derivatives_generic!(TimeCryptCiphertext);

impl<C: BlsSignatureImpl> TimeCryptCiphertext<C> {
    /// Return the signature scheme used to create this ciphertext.
    pub const fn scheme(&self) -> SignatureSchemes {
        self.scheme
    }

    /// Decrypt the time-lock ciphertext using a signature over an identifier.
    pub fn decrypt(&self, sig: &Signature<C>) -> CtOption<Vec<u8>> {
        let (s, valid) = match (sig, self.scheme) {
            (Signature::Basic(s), SignatureSchemes::Basic) => (*s, 1u8.into()),
            (Signature::MessageAugmentation(s), SignatureSchemes::MessageAugmentation) => {
                (*s, 1u8.into())
            }
            (Signature::ProofOfPossession(s), SignatureSchemes::ProofOfPossession) => {
                (*s, 1u8.into())
            }
            (_, _) => (<C as Pairing>::Signature::default(), 0u8.into()),
        };
        <C as BlsTimeCrypt>::unseal(self.u, &self.v, &self.w, s, valid)
    }
}