mithril_stm/single_signature/
signature_registered_party.rs

1use blake2::digest::{Digest, FixedOutput};
2use serde::{Deserialize, Serialize, Serializer, ser::SerializeTuple};
3
4use crate::key_registration::RegisteredParty;
5use crate::{SingleSignature, StmSignatureError};
6
7/// Signature with its registered party.
8#[derive(Debug, Clone, Hash, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
9pub struct SingleSignatureWithRegisteredParty {
10    /// Stm signature
11    pub sig: SingleSignature,
12    /// Registered party
13    pub reg_party: RegisteredParty,
14}
15
16impl SingleSignatureWithRegisteredParty {
17    /// Convert `SingleSignatureWithRegisteredParty` to bytes
18    /// # Layout
19    /// * RegParty
20    /// * Signature
21    pub fn to_bytes(&self) -> Vec<u8> {
22        let mut out = Vec::new();
23        out.extend_from_slice(&self.reg_party.to_bytes());
24        out.extend_from_slice(&self.sig.to_bytes());
25
26        out
27    }
28    ///Extract a `SingleSignatureWithRegisteredParty` from a byte slice.
29    pub fn from_bytes<D: Digest + Clone + FixedOutput>(
30        bytes: &[u8],
31    ) -> Result<SingleSignatureWithRegisteredParty, StmSignatureError> {
32        let reg_party = RegisteredParty::from_bytes(
33            bytes.get(0..104).ok_or(StmSignatureError::SerializationError)?,
34        )?;
35        let sig = SingleSignature::from_bytes::<D>(
36            bytes.get(104..).ok_or(StmSignatureError::SerializationError)?,
37        )?;
38
39        Ok(SingleSignatureWithRegisteredParty { sig, reg_party })
40    }
41}
42
43impl Serialize for SingleSignatureWithRegisteredParty {
44    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
45    where
46        S: Serializer,
47    {
48        let mut tuple = serializer.serialize_tuple(2)?;
49        tuple.serialize_element(&self.sig)?;
50        tuple.serialize_element(&self.reg_party)?;
51        tuple.end()
52    }
53}
54
55#[cfg(test)]
56mod tests {
57    mod golden {
58        use blake2::{Blake2b, digest::consts::U32};
59        use rand_chacha::ChaCha20Rng;
60        use rand_core::SeedableRng;
61
62        use crate::bls_multi_signature::{BlsSigningKey, BlsVerificationKeyProofOfPossession};
63        use crate::{
64            ClosedKeyRegistration, KeyRegistration, Parameters, Signer,
65            SingleSignatureWithRegisteredParty,
66        };
67
68        type D = Blake2b<U32>;
69
70        const GOLDEN_JSON: &str = r#"
71        [
72            {
73                "sigma": [
74                149, 157, 201, 187, 140, 54, 0, 128, 209, 88, 16, 203, 61, 78, 77, 98,
75                161, 133, 58, 152, 29, 74, 217, 113, 64, 100, 10, 161, 186, 167, 133, 114,
76                211, 153, 218, 56, 223, 84, 105, 242, 41, 54, 224, 170, 208, 185, 126, 83
77                ],
78                "indexes": [1, 4, 5, 8],
79                "signer_index": 1
80            },
81            [
82                [
83                143, 161, 255, 48, 78, 57, 204, 220, 25, 221, 164, 252, 248, 14, 56, 126,
84                186, 135, 228, 188, 145, 181, 52, 200, 97, 99, 213, 46, 0, 199, 193, 89,
85                187, 88, 29, 135, 173, 244, 86, 36, 83, 54, 67, 164, 6, 137, 94, 72, 6,
86                105, 128, 128, 93, 48, 176, 11, 4, 246, 138, 48, 180, 133, 90, 142, 192,
87                24, 193, 111, 142, 31, 76, 111, 110, 234, 153, 90, 208, 192, 31, 124, 95,
88                102, 49, 158, 99, 52, 220, 165, 94, 251, 68, 69, 121, 16, 224, 194
89                ],
90                1
91            ]
92        ]
93        "#;
94
95        fn golden_value() -> SingleSignatureWithRegisteredParty {
96            let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
97            let msg = [0u8; 16];
98            let params = Parameters {
99                m: 10,
100                k: 5,
101                phi_f: 0.8,
102            };
103            let sk_1 = BlsSigningKey::generate(&mut rng);
104            let sk_2 = BlsSigningKey::generate(&mut rng);
105            let pk_1 = BlsVerificationKeyProofOfPossession::from(&sk_1);
106            let pk_2 = BlsVerificationKeyProofOfPossession::from(&sk_2);
107            let mut key_reg = KeyRegistration::init();
108            key_reg.register(1, pk_1).unwrap();
109            key_reg.register(1, pk_2).unwrap();
110            let closed_key_reg: ClosedKeyRegistration<D> = key_reg.close();
111            let signer = Signer::set_signer(1, 1, params, sk_1, pk_1.vk, closed_key_reg.clone());
112            let signature = signer.sign(&msg).unwrap();
113            SingleSignatureWithRegisteredParty {
114                sig: signature,
115                reg_party: closed_key_reg.reg_parties[0],
116            }
117        }
118
119        #[test]
120        fn golden_conversions() {
121            let value = serde_json::from_str(GOLDEN_JSON)
122                .expect("This JSON deserialization should not fail");
123            assert_eq!(golden_value(), value);
124
125            let serialized =
126                serde_json::to_string(&value).expect("This JSON serialization should not fail");
127            let golden_serialized = serde_json::to_string(&golden_value())
128                .expect("This JSON serialization should not fail");
129            assert_eq!(golden_serialized, serialized);
130        }
131    }
132}
mithril_stm/single_signature/signature_registered_party.rs

mithril_stm/single_signature/
signature_registered_party.rs
