threshold_pairing/
serde_impl.rs

1//! Serialization and deserialization implementations for group and field elements.
2
3pub use self::field_vec::FieldWrap;
4
5use std::borrow::Cow;
6use std::ops::Deref;
7
8use bls12_381::G1Projective;
9use serde::de::Error as DeserializeError;
10use serde::{Deserialize, Deserializer, Serialize, Serializer};
11
12use crate::poly::{coeff_pos, BivarCommitment};
13use crate::serde_impl::serialize_secret_internal::SerializeSecret;
14
15const ERR_DEG: &str = "commitment degree does not match coefficients";
16
17#[doc(hidden)]
18mod serialize_secret_internal {
19    use serde::Serializer;
20
21    /// To avoid deriving [`Serialize`] automatically for structs containing secret keys this trait
22    /// should be implemented instead. It only enables explicit serialization through
23    /// [`SerdeSecret`](super::SerdeSecret).
24    pub trait SerializeSecret {
25        fn serialize_secret<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
26    }
27
28    impl<T: SerializeSecret> SerializeSecret for &T {
29        fn serialize_secret<S: Serializer>(
30            &self,
31            serializer: S,
32        ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> {
33            (*self).serialize_secret(serializer)
34        }
35    }
36}
37
38/// `SerdeSecret` is a wrapper struct for serializing and deserializing secret keys. Due to security
39/// concerns serialize shouldn't be implemented for secret keys to avoid accidental leakage.
40///
41/// Whenever this struct is used the integrity of security boundaries should be checked carefully.
42#[derive(Debug, Eq, PartialEq, Clone)]
43pub struct SerdeSecret<T>(pub T);
44
45impl<T> Deref for SerdeSecret<T> {
46    type Target = T;
47
48    fn deref(&self) -> &Self::Target {
49        self.inner()
50    }
51}
52
53impl<T> SerdeSecret<T> {
54    /// Returns the actual secret from the wrapper
55    pub fn into_inner(self) -> T {
56        self.0
57    }
58
59    /// Returns a reference to the actual secret contained in the wrapper
60    pub fn inner(&self) -> &T {
61        &self.0
62    }
63}
64
65impl<'de, T: Deserialize<'de>> Deserialize<'de> for SerdeSecret<T> {
66    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
67    where
68        D: Deserializer<'de>,
69    {
70        Ok(SerdeSecret(Deserialize::deserialize(deserializer)?))
71    }
72}
73
74impl<T: SerializeSecret> Serialize for SerdeSecret<T> {
75    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
76    where
77        S: Serializer,
78    {
79        self.0.serialize_secret(serializer)
80    }
81}
82
83impl<'de> Deserialize<'de> for crate::SecretKey {
84    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
85    where
86        D: Deserializer<'de>,
87    {
88        use crate::Scalar;
89        use serde::de;
90
91        let bytes: [u8; 32] = Deserialize::deserialize(deserializer)?;
92        match Option::from(Scalar::from_bytes(&bytes)) {
93            None => Err(de::Error::invalid_value(
94                de::Unexpected::Other("Invalid scalar value"),
95                &"Valid scalar value",
96            )),
97            Some(s) => Ok(crate::SecretKey(s)),
98        }
99    }
100}
101
102impl SerializeSecret for crate::SecretKey {
103    fn serialize_secret<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
104        use ff::PrimeField;
105
106        Serialize::serialize(&self.0.to_repr(), serializer)
107    }
108}
109
110impl<'de> Deserialize<'de> for crate::SecretKeyShare {
111    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
112    where
113        D: Deserializer<'de>,
114    {
115        let inner: crate::SecretKey = Deserialize::deserialize(deserializer)?;
116        Ok(crate::SecretKeyShare(inner))
117    }
118}
119
120impl SerializeSecret for crate::SecretKeyShare {
121    fn serialize_secret<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
122        self.0.serialize_secret(serializer)
123    }
124}
125
126/// A type with the same content as `BivarCommitment`, but that has not been validated yet.
127#[derive(Serialize, Deserialize)]
128struct WireBivarCommitment<'a> {
129    /// The polynomial's degree in each of the two variables.
130    degree: usize,
131    /// The commitments to the coefficients.
132    #[serde(with = "projective_vec")]
133    coeff: Cow<'a, [G1Projective]>,
134}
135
136impl Serialize for BivarCommitment {
137    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
138        WireBivarCommitment {
139            degree: self.degree,
140            coeff: Cow::Borrowed(&self.coeff),
141        }
142        .serialize(s)
143    }
144}
145
146impl<'de> Deserialize<'de> for BivarCommitment {
147    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
148        let WireBivarCommitment { degree, coeff } = Deserialize::deserialize(d)?;
149        if coeff_pos(degree, degree).and_then(|l| l.checked_add(1)) != Some(coeff.len()) {
150            return Err(D::Error::custom(ERR_DEG));
151        }
152        Ok(BivarCommitment {
153            degree,
154            coeff: coeff.into(),
155        })
156    }
157}
158
159/// Serialization and deserialization of a group element's compressed representation.
160pub(crate) mod projective {
161    use std::fmt;
162    use std::marker::PhantomData;
163
164    use group::prime::{PrimeCurve, PrimeCurveAffine};
165    use group::GroupEncoding;
166    use serde::de::{Error as DeserializeError, SeqAccess, Visitor};
167    use serde::{ser::SerializeTuple, Deserializer, Serializer};
168
169    const ERR_CODE: &str = "deserialized bytes don't encode a group element";
170
171    pub fn serialize<S, C>(c: &C, s: S) -> Result<S::Ok, S::Error>
172    where
173        S: Serializer,
174        C: PrimeCurve,
175    {
176        let bytes = c.to_affine().to_bytes();
177        let len = bytes.as_ref().len();
178        let mut tup = s.serialize_tuple(len)?;
179        for byte in bytes.as_ref() {
180            tup.serialize_element(byte)?;
181        }
182        tup.end()
183    }
184
185    pub fn deserialize<'de, D, C>(d: D) -> Result<C, D::Error>
186    where
187        D: Deserializer<'de>,
188        C: PrimeCurve,
189    {
190        struct TupleVisitor<C> {
191            _ph: PhantomData<C>,
192        }
193
194        impl<'de, C: PrimeCurve> Visitor<'de> for TupleVisitor<C> {
195            type Value = C;
196
197            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
198                let len = <C::Affine as GroupEncoding>::Repr::default().as_ref().len();
199                write!(f, "a tuple of size {}", len)
200            }
201
202            #[inline]
203            fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<C, A::Error> {
204                let mut compressed = <C::Affine as GroupEncoding>::Repr::default();
205                for (i, byte) in compressed.as_mut().iter_mut().enumerate() {
206                    let len_err = || DeserializeError::invalid_length(i, &self);
207                    *byte = seq.next_element()?.ok_or_else(len_err)?;
208                }
209
210                let option = <C::Affine as GroupEncoding>::from_bytes(&compressed);
211                if option.is_some().into() {
212                    let affine: C::Affine = option.unwrap();
213                    Ok(affine.to_curve())
214                } else {
215                    Err(DeserializeError::custom(ERR_CODE))
216                }
217            }
218        }
219
220        let len = <C::Affine as GroupEncoding>::Repr::default().as_ref().len();
221        d.deserialize_tuple(len, TupleVisitor { _ph: PhantomData })
222    }
223}
224
225/// Serialization and deserialization of vectors of projective curve elements.
226pub(crate) mod projective_vec {
227    use std::borrow::Borrow;
228    use std::iter::FromIterator;
229    use std::marker::PhantomData;
230
231    use group::prime::PrimeCurve;
232    use serde::{Deserialize, Deserializer, Serialize, Serializer};
233
234    use super::projective;
235
236    /// A wrapper type to facilitate serialization and deserialization of group elements.
237    struct CurveWrap<C, B>(B, PhantomData<C>);
238
239    impl<C, B> CurveWrap<C, B> {
240        fn new(c: B) -> Self {
241            CurveWrap(c, PhantomData)
242        }
243    }
244
245    impl<C: PrimeCurve, B: Borrow<C>> Serialize for CurveWrap<C, B> {
246        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
247            projective::serialize(self.0.borrow(), s)
248        }
249    }
250
251    impl<'de, C: PrimeCurve> Deserialize<'de> for CurveWrap<C, C> {
252        fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
253            Ok(CurveWrap::new(projective::deserialize(d)?))
254        }
255    }
256
257    pub fn serialize<S, C, T>(vec: T, s: S) -> Result<S::Ok, S::Error>
258    where
259        S: Serializer,
260        C: PrimeCurve,
261        T: AsRef<[C]>,
262    {
263        let wrap_vec: Vec<CurveWrap<C, &C>> = vec.as_ref().iter().map(CurveWrap::new).collect();
264        wrap_vec.serialize(s)
265    }
266
267    pub fn deserialize<'de, D, C, T>(d: D) -> Result<T, D::Error>
268    where
269        D: Deserializer<'de>,
270        C: PrimeCurve,
271        T: FromIterator<C>,
272    {
273        let wrap_vec = <Vec<CurveWrap<C, C>>>::deserialize(d)?;
274        Ok(wrap_vec.into_iter().map(|CurveWrap(c, _)| c).collect())
275    }
276}
277
278/// Serialization and deserialization of vectors of field elements.
279pub(crate) mod field_vec {
280    use std::borrow::Borrow;
281
282    use bls12_381::Scalar;
283    use ff::PrimeField;
284    use serde::de::Error as DeserializeError;
285    use serde::{Deserialize, Deserializer, Serialize, Serializer};
286
287    /// A wrapper type to facilitate serialization and deserialization of field elements.
288    pub struct FieldWrap<B>(pub B);
289
290    impl FieldWrap<Scalar> {
291        /// Returns the wrapped field element.
292        pub fn into_inner(self) -> Scalar {
293            self.0
294        }
295    }
296
297    impl<B: Borrow<Scalar>> Serialize for FieldWrap<B> {
298        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
299            self.0.borrow().to_repr().serialize(s)
300        }
301    }
302
303    impl<'de> Deserialize<'de> for FieldWrap<Scalar> {
304        fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
305            let s = Scalar::from_repr(Deserialize::deserialize(d)?);
306
307            if s.is_none().into() {
308                return Err(D::Error::custom("invalid field element representation"));
309            }
310
311            Ok(FieldWrap(s.unwrap()))
312        }
313    }
314
315    pub fn serialize<S: Serializer>(vec: &[Scalar], s: S) -> Result<S::Ok, S::Error> {
316        let wrap_vec: Vec<FieldWrap<&Scalar>> = vec.iter().map(FieldWrap).collect();
317        wrap_vec.serialize(s)
318    }
319
320    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<Scalar>, D::Error> {
321        let wrap_vec = <Vec<FieldWrap<Scalar>>>::deserialize(d)?;
322        Ok(wrap_vec.into_iter().map(FieldWrap::into_inner).collect())
323    }
324}
325
326#[cfg(test)]
327mod tests {
328
329    #[test]
330    #[cfg(feature = "bincode")]
331    fn vecs() {
332        use crate::G1Projective;
333        use bls12_381::Scalar;
334        use ff::Field;
335        use group::Group;
336        use serde::{Deserialize, Serialize};
337        use std::iter::repeat_with;
338
339        #[derive(Debug, Serialize, Deserialize)]
340        pub struct Vecs {
341            #[serde(with = "super::projective_vec")]
342            curve_points: Vec<G1Projective>,
343            #[serde(with = "super::field_vec")]
344            field_elements: Vec<Scalar>,
345        }
346
347        impl PartialEq for Vecs {
348            fn eq(&self, other: &Self) -> bool {
349                self.curve_points == other.curve_points
350                    && self.field_elements == other.field_elements
351            }
352        }
353
354        let mut rng = rand::thread_rng();
355        let vecs = Vecs {
356            curve_points: repeat_with(|| G1Projective::random(&mut rng))
357                .take(10)
358                .collect(),
359            field_elements: repeat_with(|| Scalar::random(&mut rng)).take(10).collect(),
360        };
361        let ser_vecs = bincode::serde::encode_to_vec(&vecs, bincode::config::legacy())
362            .expect("serialize vecs");
363        let (de_vecs, _) = bincode::serde::decode_from_slice(&ser_vecs, bincode::config::legacy())
364            .expect("deserialize vecs");
365        assert_eq!(vecs, de_vecs);
366    }
367
368    #[test]
369    #[cfg(feature = "bincode")]
370    fn bivar_commitment() {
371        use crate::poly::BivarPoly;
372
373        let mut rng = rand::thread_rng();
374        for deg in 1..8 {
375            let poly = BivarPoly::random(deg, &mut rng);
376            let comm = poly.commitment();
377            let ser_comm = bincode::serde::encode_to_vec(&comm, bincode::config::legacy())
378                .expect("serialize commitment");
379            let (de_comm, _) =
380                bincode::serde::decode_from_slice(&ser_comm, bincode::config::legacy())
381                    .expect("deserialize commitment");
382            assert_eq!(comm, de_comm);
383        }
384    }
385
386    #[test]
387    #[cfg(feature = "bincode")]
388    fn serde_secret_key() {
389        use crate::serde_impl::SerdeSecret;
390        use crate::SecretKey;
391        use rand::{thread_rng, Rng};
392
393        let mut rng = thread_rng();
394        for _ in 0..2048 {
395            let sk: SecretKey = rng.gen();
396            let ser_ref =
397                bincode::serde::encode_to_vec(SerdeSecret(&sk), bincode::config::legacy())
398                    .expect("serialize secret key");
399
400            let (de, _) = bincode::serde::decode_from_slice(&ser_ref, bincode::config::legacy())
401                .expect("deserialize secret key");
402            assert_eq!(sk, de);
403
404            let (de_serde_secret, _): (SerdeSecret<SecretKey>, _) =
405                bincode::serde::decode_from_slice(&ser_ref, bincode::config::legacy())
406                    .expect("deserialize secret key");
407            assert_eq!(sk, de_serde_secret.into_inner());
408
409            let ser_val = bincode::serde::encode_to_vec(SerdeSecret(sk), bincode::config::legacy())
410                .expect("serialize secret key");
411            assert_eq!(ser_ref, ser_val);
412        }
413    }
414
415    #[test]
416    #[cfg(feature = "bincode")]
417    fn serde_secret_key_share() {
418        use crate::serde_impl::SerdeSecret;
419        use crate::SecretKeyShare;
420        use rand::{thread_rng, Rng};
421
422        let mut rng = thread_rng();
423        for _ in 0..2048 {
424            let sk: SecretKeyShare = rng.gen();
425            let ser_ref =
426                bincode::serde::encode_to_vec(SerdeSecret(&sk), bincode::config::legacy())
427                    .expect("serialize secret key");
428
429            let (de, _) = bincode::serde::decode_from_slice(&ser_ref, bincode::config::legacy())
430                .expect("deserialize secret key");
431            assert_eq!(sk, de);
432
433            let (de_serde_secret, _): (SerdeSecret<SecretKeyShare>, _) =
434                bincode::serde::decode_from_slice(&ser_ref, bincode::config::legacy())
435                    .expect("deserialize secret key");
436            assert_eq!(sk, de_serde_secret.into_inner());
437
438            let ser_val = bincode::serde::encode_to_vec(SerdeSecret(sk), bincode::config::legacy())
439                .expect("serialize secret key");
440            assert_eq!(ser_ref, ser_val);
441            assert_eq!(ser_val.len(), 32);
442        }
443    }
444}
threshold_pairing/serde_impl.rs

threshold_pairing/
serde_impl.rs
