generic_ec/
serde.rs

1//! Serde support
2//!
3//! ## Default serialization format
4//!
5//! By default, serialization format is excessive. Points are serialized without compression.
6//! Points and scalars have an extra field "curve" that specifies which curve this point/scalar
7//! belongs to.
8//!
9//! ```rust
10//! # fn main() -> Result<(), serde_json::Error> {
11//! use generic_ec::{Curve, Point, Scalar, curves::Secp256k1};
12//! use serde::{Serialize, Deserialize};
13//!
14//! #[derive(Serialize, Deserialize)]
15//! #[serde(bound = "")]
16//! pub struct ZkProof<E: Curve> {
17//!     some_point: Point<E>,
18//!     some_scalar: Scalar<E>,
19//! }
20//!
21//! let proof = ZkProof::<Secp256k1> {
22//!     some_point: Point::generator().to_point(),
23//!     some_scalar: Scalar::one(),
24//! };
25//! assert_eq!(serde_json::to_string_pretty(&proof)?, r#"{
26//!   "some_point": {
27//!     "curve": "secp256k1",
28//!     "point": "0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
29//!   },
30//!   "some_scalar": {
31//!     "curve": "secp256k1",
32//!     "scalar": "0000000000000000000000000000000000000000000000000000000000000001"
33//!   }
34//! }"#);
35//! # Ok(()) }
36//! ```
37//!
38//! Excessive serialization format enables better security as it makes it harder to misuse the library.
39//! E.g. if by some mistake you parse a point that was initially generated on another curve, you'll get
40//! instant error. Without this field, behavior is uncertain and difficult to debug: point from one curve
41//! can happen to be a valid point on another curve.
42//!
43//! ## Compact serialization format
44//!
45//! You may opt for compact serialization format. If you do that, points are seialized in compressed form, and
46//! extra "curve" field is dropped.
47//!
48//! Compact serialization format can be enabled using [serde_with] crate and [`Compact`] helper struct:
49//!
50//! ```rust
51//! # fn main() -> Result<(), serde_json::Error> {
52//! use generic_ec::{Curve, Point, Scalar, curves::Secp256k1};
53//! use serde::{Serialize, Deserialize};
54//! use serde_with::serde_as;
55//!
56//! #[serde_as]
57//! #[derive(Serialize, Deserialize)]
58//! #[serde(bound = "")]
59//! pub struct ZkProof<E: Curve> {
60//!     #[serde_as(as = "generic_ec::serde::Compact")]
61//!     some_point: Point<E>,
62//!     #[serde_as(as = "generic_ec::serde::Compact")]
63//!     some_scalar: Scalar<E>,
64//! }
65//!
66//! let proof = ZkProof::<Secp256k1> {
67//!     some_point: Point::generator().to_point(),
68//!     some_scalar: Scalar::one(),
69//! };
70//! assert_eq!(serde_json::to_string_pretty(&proof)?, r#"{
71//!   "some_point": "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
72//!   "some_scalar": "0000000000000000000000000000000000000000000000000000000000000001"
73//! }"#);
74//! # Ok(()) }
75//! ```
76
77use phantom_type::PhantomType;
78
79use crate::core::Curve;
80
81/// A guard type asserting that deserialized value belongs to curve `E`
82///
83/// It implements [serde::Serialize] and [serde::Deserialize] traits if `serde` feature is
84/// enabled. When serialized, `CurveName` is converted into string containing curve name.
85/// When deserialized, it parses a string and requires it to match curve name, otherwise
86/// deserialization error is returned.
87///
88/// This structure is present even if `serde` feature is disabled.
89///
90/// ## Example
91///
92/// ```rust
93/// # fn main() -> Result<(), serde_json::Error> {
94/// use generic_ec::{serde::CurveName, curves::{Secp256k1, Secp256r1}};
95/// use serde_json::Value;
96///
97/// let curve_name = CurveName::<Secp256k1>::new();
98/// let value = serde_json::to_value(&curve_name)?;
99/// assert_eq!(value, Value::String("secp256k1".into()));
100///
101/// // `value` can be deserialized back to `CurveName<Secp256k1>`
102/// let _curve_name: CurveName<Secp256k1> = serde_json::from_value(value.clone())?;
103///
104/// // but it can't be deserialized to `CurveName<Secp256r1>`
105/// let serialization_fails = serde_json::from_value::<CurveName<Secp256r1>>(value);
106/// assert!(serialization_fails.is_err());
107/// # Ok(()) }
108/// ```
109#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
110pub struct CurveName<E: Curve>(PhantomType<E>);
111
112impl<E: Curve> CurveName<E> {
113    /// Construct a `CurveName` guard
114    pub fn new() -> Self {
115        Self(PhantomType::new())
116    }
117}
118
119impl<E: Curve> Default for CurveName<E> {
120    fn default() -> Self {
121        Self::new()
122    }
123}
124
125#[cfg(feature = "serde")]
126impl<E: Curve> serde::Serialize for CurveName<E> {
127    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
128    where
129        S: serde::Serializer,
130    {
131        serializer.serialize_str(E::CURVE_NAME)
132    }
133}
134
135#[cfg(feature = "serde")]
136impl<'de, E: Curve> serde::Deserialize<'de> for CurveName<E> {
137    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
138    where
139        D: serde::Deserializer<'de>,
140    {
141        pub struct CurveNameVisitor<E: Curve>(PhantomType<E>);
142        impl<E: Curve> serde::de::Visitor<'_> for CurveNameVisitor<E> {
143            type Value = CurveName<E>;
144            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
145                write!(f, "curve {name}", name = E::CURVE_NAME)
146            }
147            fn visit_str<Error>(self, v: &str) -> Result<Self::Value, Error>
148            where
149                Error: serde::de::Error,
150            {
151                if v == E::CURVE_NAME {
152                    Ok(CurveName::default())
153                } else {
154                    Err(Error::custom(optional::error_msg::ExpectedCurve {
155                        expected: E::CURVE_NAME,
156                        got: v,
157                    }))
158                }
159            }
160        }
161        deserializer.deserialize_str(CurveNameVisitor(PhantomType::new()))
162    }
163}
164
165#[cfg(feature = "serde")]
166pub use optional::*;
167#[cfg(feature = "serde")]
168mod optional {
169    use crate::{core::Curve, Point, Scalar, SecretPoint, SecretScalar};
170
171    use super::CurveName;
172
173    impl<E: Curve> serde::Serialize for Point<E> {
174        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
175        where
176            S: serde::Serializer,
177        {
178            models::PointUncompressed::from(self).serialize(serializer)
179        }
180    }
181
182    impl<'de, E: Curve> serde::Deserialize<'de> for Point<E> {
183        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
184        where
185            D: serde::Deserializer<'de>,
186        {
187            models::PointUncompressed::deserialize(deserializer)?
188                .try_into()
189                .map_err(<D::Error as serde::de::Error>::custom)
190        }
191    }
192
193    impl<E: Curve> serde::Serialize for SecretPoint<E> {
194        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
195        where
196            S: serde::Serializer,
197        {
198            self.as_ref().serialize(serializer)
199        }
200    }
201
202    impl<'de, E: Curve> serde::Deserialize<'de> for SecretPoint<E> {
203        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
204        where
205            D: serde::Deserializer<'de>,
206        {
207            Ok(SecretPoint::new(&mut Point::deserialize(deserializer)?))
208        }
209    }
210
211    impl<E: Curve> serde::Serialize for Scalar<E> {
212        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
213        where
214            S: serde::Serializer,
215        {
216            models::ScalarUncompressed::from(self).serialize(serializer)
217        }
218    }
219
220    impl<'de, E: Curve> serde::Deserialize<'de> for Scalar<E> {
221        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
222        where
223            D: serde::Deserializer<'de>,
224        {
225            models::ScalarUncompressed::deserialize(deserializer)?
226                .try_into()
227                .map_err(<D::Error as serde::de::Error>::custom)
228        }
229    }
230
231    impl<E: Curve> serde::Serialize for SecretScalar<E> {
232        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
233        where
234            S: serde::Serializer,
235        {
236            self.as_ref().serialize(serializer)
237        }
238    }
239
240    impl<'de, E: Curve> serde::Deserialize<'de> for SecretScalar<E> {
241        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
242        where
243            D: serde::Deserializer<'de>,
244        {
245            Ok(SecretScalar::new(&mut Scalar::deserialize(deserializer)?))
246        }
247    }
248
249    /// Compact serialization format
250    pub struct Compact;
251
252    impl<E: Curve> serde_with::SerializeAs<Point<E>> for Compact {
253        fn serialize_as<S>(source: &Point<E>, serializer: S) -> Result<S::Ok, S::Error>
254        where
255            S: serde::Serializer,
256        {
257            use serde::Serialize;
258            models::PointCompact::from(source).serialize(serializer)
259        }
260    }
261
262    impl<'de, E: Curve> serde_with::DeserializeAs<'de, Point<E>> for Compact {
263        fn deserialize_as<D>(deserializer: D) -> Result<Point<E>, D::Error>
264        where
265            D: serde::Deserializer<'de>,
266        {
267            use serde::Deserialize;
268            models::PointCompact::deserialize(deserializer)?
269                .try_into()
270                .map_err(<D::Error as serde::de::Error>::custom)
271        }
272    }
273
274    impl<E: Curve> serde_with::SerializeAs<SecretPoint<E>> for Compact {
275        fn serialize_as<S>(source: &SecretPoint<E>, serializer: S) -> Result<S::Ok, S::Error>
276        where
277            S: serde::Serializer,
278        {
279            use serde::Serialize;
280            models::PointCompact::from(source.as_ref()).serialize(serializer)
281        }
282    }
283
284    impl<'de, E: Curve> serde_with::DeserializeAs<'de, SecretPoint<E>> for Compact {
285        fn deserialize_as<D>(deserializer: D) -> Result<SecretPoint<E>, D::Error>
286        where
287            D: serde::Deserializer<'de>,
288        {
289            let mut point = <Compact as serde_with::DeserializeAs<'de, Point<E>>>::deserialize_as(
290                deserializer,
291            )?;
292            Ok(SecretPoint::new(&mut point))
293        }
294    }
295
296    impl<E: Curve> serde_with::SerializeAs<Scalar<E>> for Compact {
297        fn serialize_as<S>(source: &Scalar<E>, serializer: S) -> Result<S::Ok, S::Error>
298        where
299            S: serde::Serializer,
300        {
301            use serde::Serialize;
302            models::ScalarCompact::from(source).serialize(serializer)
303        }
304    }
305
306    impl<'de, E: Curve> serde_with::DeserializeAs<'de, Scalar<E>> for Compact {
307        fn deserialize_as<D>(deserializer: D) -> Result<Scalar<E>, D::Error>
308        where
309            D: serde::Deserializer<'de>,
310        {
311            use serde::Deserialize;
312            models::ScalarCompact::deserialize(deserializer)?
313                .try_into()
314                .map_err(<D::Error as serde::de::Error>::custom)
315        }
316    }
317
318    impl<E: Curve> serde_with::SerializeAs<SecretScalar<E>> for Compact {
319        fn serialize_as<S>(source: &SecretScalar<E>, serializer: S) -> Result<S::Ok, S::Error>
320        where
321            S: serde::Serializer,
322        {
323            use serde::Serialize;
324            models::ScalarCompact::from(source.as_ref()).serialize(serializer)
325        }
326    }
327
328    impl<'de, E: Curve> serde_with::DeserializeAs<'de, SecretScalar<E>> for Compact {
329        fn deserialize_as<D>(deserializer: D) -> Result<SecretScalar<E>, D::Error>
330        where
331            D: serde::Deserializer<'de>,
332        {
333            let mut scalar =
334                <Compact as serde_with::DeserializeAs<'de, Scalar<E>>>::deserialize_as(
335                    deserializer,
336                )?;
337            Ok(SecretScalar::new(&mut scalar))
338        }
339    }
340
341    impl<T> serde_with::SerializeAs<crate::NonZero<T>> for Compact
342    where
343        Compact: serde_with::SerializeAs<T>,
344    {
345        fn serialize_as<S>(source: &crate::NonZero<T>, serializer: S) -> Result<S::Ok, S::Error>
346        where
347            S: serde::Serializer,
348        {
349            Compact::serialize_as(source.as_ref(), serializer)
350        }
351    }
352
353    impl<'de, T> serde_with::DeserializeAs<'de, crate::NonZero<T>> for Compact
354    where
355        Compact: serde_with::DeserializeAs<'de, T>,
356        crate::NonZero<T>: TryFrom<T>,
357        <crate::NonZero<T> as TryFrom<T>>::Error: core::fmt::Display,
358    {
359        fn deserialize_as<D>(deserializer: D) -> Result<crate::NonZero<T>, D::Error>
360        where
361            D: serde::Deserializer<'de>,
362        {
363            let value = Compact::deserialize_as(deserializer)?;
364            crate::NonZero::try_from(value).map_err(<D::Error as serde::de::Error>::custom)
365        }
366    }
367
368    impl<'a, T> serde_with::SerializeAs<&'a T> for Compact
369    where
370        Compact: serde_with::SerializeAs<T>,
371    {
372        fn serialize_as<S>(source: &&'a T, serializer: S) -> Result<S::Ok, S::Error>
373        where
374            S: serde::Serializer,
375        {
376            Compact::serialize_as(*source, serializer)
377        }
378    }
379
380    /// Serializes point/scalar compactly. Deserializes both compact
381    /// and non-compact points/scalars.
382    ///
383    /// It can be used when some data used to be serialized in default serialization
384    /// format, and at some point you decided to use a compact serialization format.
385    /// `PreferCompact` serializes points/scalar in compact format, but at deserialization
386    /// it accepts both compact and non-compact forms.
387    ///
388    /// `PreferCompact` does not work on `serde` backends which serialize structs as
389    /// lists, such as `bincode`. Notably, (de)serialization of points/scalars in compact
390    /// format will still work, but deserialization from non-compact form will produce
391    /// an error.
392    pub struct PreferCompact;
393
394    impl<T> serde_with::SerializeAs<T> for PreferCompact
395    where
396        Compact: serde_with::SerializeAs<T>,
397    {
398        fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
399        where
400            S: serde::Serializer,
401        {
402            <Compact as serde_with::SerializeAs<T>>::serialize_as(source, serializer)
403        }
404    }
405
406    impl<'de, T> serde_with::DeserializeAs<'de, T> for PreferCompact
407    where
408        T: serde::Deserialize<'de>,
409        Compact: serde_with::DeserializeAs<'de, T>,
410    {
411        fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
412        where
413            D: serde::Deserializer<'de>,
414        {
415            use serde_with::DeserializeAs;
416
417            struct Visitor<T> {
418                is_human_readable: bool,
419                _out: core::marker::PhantomData<T>,
420            }
421            impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
422            where
423                T: serde::Deserialize<'de>,
424                Compact: serde_with::DeserializeAs<'de, T>,
425            {
426                type Value = T;
427                fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
428                    f.write_str("preferably compact point/scalar")
429                }
430
431                fn visit_bytes<Err>(self, v: &[u8]) -> Result<Self::Value, Err>
432                where
433                    Err: serde::de::Error,
434                {
435                    Compact::deserialize_as(NewTypeDeserializer::new(OverrideHumanReadable {
436                        deserializer: serde::de::value::BytesDeserializer::<Err>::new(v),
437                        is_human_readable: self.is_human_readable,
438                    }))
439                }
440                fn visit_str<Err>(self, v: &str) -> Result<Self::Value, Err>
441                where
442                    Err: serde::de::Error,
443                {
444                    Compact::deserialize_as(NewTypeDeserializer::new(OverrideHumanReadable {
445                        deserializer: serde::de::value::StrDeserializer::<Err>::new(v),
446                        is_human_readable: self.is_human_readable,
447                    }))
448                }
449
450                fn visit_seq<A>(self, _seq: A) -> Result<Self::Value, A::Error>
451                where
452                    A: serde::de::SeqAccess<'de>,
453                {
454                    Err(<A::Error as serde::de::Error>::custom(
455                        "cannot deserialize in `PreferCompact` mode \
456                        from sequence: it's ambiguous",
457                    ))
458                }
459                fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
460                where
461                    A: serde::de::MapAccess<'de>,
462                {
463                    T::deserialize(OverrideHumanReadable {
464                        deserializer: serde::de::value::MapAccessDeserializer::new(map),
465                        is_human_readable: self.is_human_readable,
466                    })
467                }
468
469                fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
470                where
471                    D: serde::Deserializer<'de>,
472                {
473                    Compact::deserialize_as(NewTypeDeserializer::new(OverrideHumanReadable {
474                        deserializer,
475                        is_human_readable: self.is_human_readable,
476                    }))
477                }
478            }
479
480            let is_human_readable = deserializer.is_human_readable();
481            deserializer.deserialize_any(Visitor {
482                is_human_readable,
483                _out: core::marker::PhantomData::<T>,
484            })
485        }
486    }
487
488    /// Wraps a [`serde::Deserializer`] and overrides `fn is_human_readable()`
489    struct OverrideHumanReadable<D> {
490        is_human_readable: bool,
491        deserializer: D,
492    }
493    impl<'de, D> serde::Deserializer<'de> for OverrideHumanReadable<D>
494    where
495        D: serde::Deserializer<'de>,
496    {
497        type Error = <D as serde::Deserializer<'de>>::Error;
498
499        fn is_human_readable(&self) -> bool {
500            self.is_human_readable
501        }
502
503        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
504        where
505            V: serde::de::Visitor<'de>,
506        {
507            self.deserializer.deserialize_any(visitor)
508        }
509
510        serde::forward_to_deserialize_any! {
511            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
512            bytes byte_buf option unit unit_struct newtype_struct seq tuple
513            tuple_struct map struct enum identifier ignored_any
514        }
515    }
516
517    /// See [`serde::de::value`]. New type deserializer is missing in the `serde` crate.
518    struct NewTypeDeserializer<D> {
519        deserializer: D,
520    }
521    impl<D> NewTypeDeserializer<D> {
522        pub fn new(deserializer: D) -> Self {
523            Self { deserializer }
524        }
525    }
526    impl<'de, D> serde::Deserializer<'de> for NewTypeDeserializer<D>
527    where
528        D: serde::Deserializer<'de>,
529    {
530        type Error = D::Error;
531        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
532        where
533            V: serde::de::Visitor<'de>,
534        {
535            visitor.visit_newtype_struct(self.deserializer)
536        }
537        fn is_human_readable(&self) -> bool {
538            self.deserializer.is_human_readable()
539        }
540        serde::forward_to_deserialize_any! {
541            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
542            bytes byte_buf option unit unit_struct newtype_struct seq tuple
543            tuple_struct map struct enum identifier ignored_any
544        }
545    }
546
547    mod models {
548        use core::convert::TryFrom;
549
550        use serde::{Deserialize, Serialize};
551        use serde_with::serde_as;
552
553        use crate::core::{CompressedEncoding, IntegerEncoding, UncompressedEncoding};
554        use crate::{as_raw::AsRaw, Curve, Point, Scalar};
555
556        use super::{
557            error_msg::{InvalidPoint, InvalidScalar},
558            CurveName,
559        };
560
561        #[serde_as]
562        #[derive(Serialize, Deserialize)]
563        #[serde(bound = "")]
564        pub struct PointUncompressed<E: Curve> {
565            curve: CurveName<E>,
566            #[serde_as(as = "super::utils::Bytes")]
567            point: E::UncompressedPointArray,
568        }
569        impl<E: Curve> From<&Point<E>> for PointUncompressed<E> {
570            fn from(p: &Point<E>) -> Self {
571                let bytes = p.as_raw().to_bytes_uncompressed();
572                Self {
573                    curve: CurveName::new(),
574                    point: bytes,
575                }
576            }
577        }
578        impl<E: Curve> TryFrom<PointUncompressed<E>> for Point<E> {
579            type Error = InvalidPoint;
580            fn try_from(value: PointUncompressed<E>) -> Result<Self, Self::Error> {
581                Point::from_bytes(value.point).or(Err(InvalidPoint))
582            }
583        }
584
585        #[serde_as]
586        #[derive(Serialize, Deserialize)]
587        #[serde(bound = "")]
588        pub struct PointCompact<E: Curve>(
589            #[serde_as(as = "super::utils::Bytes")] E::CompressedPointArray,
590        );
591        impl<E: Curve> From<&Point<E>> for PointCompact<E> {
592            fn from(p: &Point<E>) -> Self {
593                let bytes = p.as_raw().to_bytes_compressed();
594                Self(bytes)
595            }
596        }
597        impl<E: Curve> TryFrom<PointCompact<E>> for Point<E> {
598            type Error = InvalidPoint;
599            fn try_from(value: PointCompact<E>) -> Result<Self, Self::Error> {
600                Point::from_bytes(value.0).or(Err(InvalidPoint))
601            }
602        }
603
604        #[serde_as]
605        #[derive(Serialize, Deserialize)]
606        #[serde(bound = "")]
607        pub struct ScalarUncompressed<E: Curve> {
608            curve: CurveName<E>,
609            #[serde_as(as = "super::utils::Bytes")]
610            scalar: E::ScalarArray,
611        }
612        impl<E: Curve> From<&Scalar<E>> for ScalarUncompressed<E> {
613            fn from(s: &Scalar<E>) -> Self {
614                let bytes = s.as_raw().to_be_bytes();
615                Self {
616                    curve: CurveName::new(),
617                    scalar: bytes,
618                }
619            }
620        }
621        impl<E: Curve> TryFrom<ScalarUncompressed<E>> for Scalar<E> {
622            type Error = InvalidScalar;
623            fn try_from(value: ScalarUncompressed<E>) -> Result<Self, Self::Error> {
624                Scalar::from_be_bytes(value.scalar).or(Err(InvalidScalar))
625            }
626        }
627
628        #[serde_as]
629        #[derive(Serialize, Deserialize)]
630        #[serde(bound = "")]
631        pub struct ScalarCompact<E: Curve>(#[serde_as(as = "super::utils::Bytes")] E::ScalarArray);
632        impl<E: Curve> From<&Scalar<E>> for ScalarCompact<E> {
633            fn from(s: &Scalar<E>) -> Self {
634                let bytes = s.as_raw().to_be_bytes();
635                Self(bytes)
636            }
637        }
638        impl<E: Curve> TryFrom<ScalarCompact<E>> for Scalar<E> {
639            type Error = InvalidScalar;
640            fn try_from(value: ScalarCompact<E>) -> Result<Self, Self::Error> {
641                Scalar::from_be_bytes(&value.0).or(Err(InvalidScalar))
642            }
643        }
644    }
645
646    mod utils {
647        use core::fmt;
648
649        use serde::de::{self, Visitor};
650        use serde_with::{DeserializeAs, SerializeAs};
651
652        use crate::core::ByteArray;
653
654        pub struct Bytes;
655
656        impl<T> SerializeAs<T> for Bytes
657        where
658            T: AsRef<[u8]>,
659        {
660            fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
661            where
662                S: serde::Serializer,
663            {
664                if serializer.is_human_readable() {
665                    // We only support serialization of byte arrays up to 128 bytes. It can be generalized when
666                    // Rust has better support of const generics
667                    let mut buf = [0u8; 256];
668
669                    if source.as_ref().len() * 2 > buf.len() {
670                        return Err(<S::Error as serde::ser::Error>::custom(
671                            super::error_msg::ByteArrayTooLarge {
672                                len: source.as_ref().len(),
673                                supported_len: buf.len() / 2,
674                            },
675                        ));
676                    }
677                    let buf = &mut buf[..2 * source.as_ref().len()];
678                    hex::encode_to_slice(source, buf)
679                        .map_err(<S::Error as serde::ser::Error>::custom)?;
680                    let buf_str = core::str::from_utf8(buf).map_err(|e| {
681                        <S::Error as serde::ser::Error>::custom(super::error_msg::MalformedHex(e))
682                    })?;
683                    serializer.serialize_str(buf_str)
684                } else {
685                    serializer.serialize_bytes(source.as_ref())
686                }
687            }
688        }
689
690        impl<'de, T> DeserializeAs<'de, T> for Bytes
691        where
692            T: ByteArray,
693        {
694            fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
695            where
696                D: serde::Deserializer<'de>,
697            {
698                pub struct BytesVisitor<T>(T);
699                impl<'de, T: AsMut<[u8]>> Visitor<'de> for BytesVisitor<T> {
700                    type Value = T;
701                    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
702                        write!(f, "bytes")
703                    }
704                    fn visit_str<E>(mut self, v: &str) -> Result<Self::Value, E>
705                    where
706                        E: serde::de::Error,
707                    {
708                        hex::decode_to_slice(v, self.0.as_mut()).map_err(E::custom)?;
709                        Ok(self.0)
710                    }
711                    fn visit_bytes<E>(mut self, v: &[u8]) -> Result<Self::Value, E>
712                    where
713                        E: serde::de::Error,
714                    {
715                        let expected_len = self.0.as_mut().len();
716                        if v.len() != expected_len {
717                            return Err(E::invalid_length(
718                                v.len(),
719                                &super::error_msg::ExpectedLen(expected_len),
720                            ));
721                        }
722                        self.0.as_mut().copy_from_slice(v);
723                        Ok(self.0)
724                    }
725                    fn visit_seq<A>(mut self, mut seq: A) -> Result<Self::Value, A::Error>
726                    where
727                        A: serde::de::SeqAccess<'de>,
728                    {
729                        let expected_len = self.0.as_mut().len();
730                        let bytes = self.0.as_mut().iter_mut().enumerate();
731
732                        for (i, byte_i) in bytes {
733                            let byte_parsed = seq.next_element()?.ok_or_else(|| {
734                                <A::Error as de::Error>::invalid_length(
735                                    i,
736                                    &super::error_msg::ExpectedLen(expected_len),
737                                )
738                            })?;
739                            *byte_i = byte_parsed;
740                        }
741
742                        let mut unparsed_bytes = 0;
743                        while seq.next_element::<serde::de::IgnoredAny>()?.is_some() {
744                            unparsed_bytes += 1
745                        }
746
747                        if unparsed_bytes > 0 {
748                            Err(<A::Error as de::Error>::invalid_length(
749                                expected_len + unparsed_bytes,
750                                &super::error_msg::ExpectedLen(expected_len),
751                            ))
752                        } else {
753                            Ok(self.0)
754                        }
755                    }
756                }
757                let visitor = BytesVisitor(T::zeroes());
758                if deserializer.is_human_readable() {
759                    deserializer.deserialize_str(visitor)
760                } else {
761                    deserializer.deserialize_bytes(visitor)
762                }
763            }
764        }
765    }
766
767    pub(super) mod error_msg {
768        use core::fmt;
769
770        use serde::de::Expected;
771
772        pub struct ExpectedCurve<'g> {
773            pub expected: &'static str,
774            pub got: &'g str,
775        }
776
777        impl fmt::Display for ExpectedCurve<'_> {
778            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
779                write!(
780                    f,
781                    "expected {e} curve, got {g}",
782                    e = self.expected,
783                    g = self.got
784                )
785            }
786        }
787
788        pub struct ExpectedLen(pub usize);
789
790        impl Expected for ExpectedLen {
791            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
792                write!(f, "{} bytes", self.0)
793            }
794        }
795
796        pub struct InvalidPoint;
797        impl fmt::Display for InvalidPoint {
798            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
799                write!(f, "invalid point")
800            }
801        }
802
803        pub struct InvalidScalar;
804        impl fmt::Display for InvalidScalar {
805            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
806                write!(f, "invalid scalar")
807            }
808        }
809
810        pub struct MalformedHex(pub core::str::Utf8Error);
811        impl fmt::Display for MalformedHex {
812            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
813                write!(f, "malformed hex: {}", self.0)
814            }
815        }
816
817        pub struct ByteArrayTooLarge {
818            pub len: usize,
819            pub supported_len: usize,
820        }
821        impl fmt::Display for ByteArrayTooLarge {
822            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
823                write!(f, "byte array is too large: its length is {} bytes, but only up to {} bytes can be serialized", self.len, self.supported_len)
824            }
825        }
826    }
827}
generic_ec/serde.rs

generic_ec/
serde.rs
