p256: add serde Serialize/Deserialize impls (#465)

Adds impls of `serde` traits for the following types:

- `AffinePoint`
- `Scalar`

Author: tarcieri

p256/Cargo.toml

@@ -40,7 +40,7 @@ digest = ["ecdsa-core/digest", "ecdsa-core/hazmat"]
 ecdh = ["arithmetic", "elliptic-curve/ecdh"]
 ecdsa = ["arithmetic", "ecdsa-core/sign", "ecdsa-core/verify", "sha256"]
 jwk = ["elliptic-curve/jwk"]
-pem = ["elliptic-curve/pem", "pkcs8"]
+pem = ["elliptic-curve/pem", "ecdsa-core/pem", "pkcs8"]
 pkcs8 = ["elliptic-curve/pkcs8"]
 serde = ["ecdsa-core/serde", "elliptic-curve/serde", "sec1/serde"]
 sha256 = ["digest", "sha2"]

p256/src/arithmetic/affine.rs

@@ -11,9 +11,12 @@ use elliptic_curve::{
     sec1::{self, FromEncodedPoint, ToCompactEncodedPoint, ToEncodedPoint},
     subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption},
     zeroize::DefaultIsZeroes,
-    AffineArithmetic, AffineXCoordinate, Curve, DecompactPoint, DecompressPoint,
+    AffineArithmetic, AffineXCoordinate, Curve, DecompactPoint, DecompressPoint, Error, Result,
 };
 
+#[cfg(feature = "serde")]
+use elliptic_curve::serde::{de, ser, Deserialize, Serialize};
+
 impl AffineArithmetic for NistP256 {
     type AffinePoint = AffinePoint;
 }
@@ -251,6 +254,22 @@ impl ToCompactEncodedPoint<NistP256> for AffinePoint {
     }
 }
 
+impl TryFrom<EncodedPoint> for AffinePoint {
+    type Error = Error;
+
+    fn try_from(point: EncodedPoint) -> Result<AffinePoint> {
+        AffinePoint::try_from(&point)
+    }
+}
+
+impl TryFrom<&EncodedPoint> for AffinePoint {
+    type Error = Error;
+
+    fn try_from(point: &EncodedPoint) -> Result<AffinePoint> {
+        Option::from(AffinePoint::from_encoded_point(point)).ok_or(Error)
+    }
+}
+
 impl From<AffinePoint> for EncodedPoint {
     /// Returns the SEC1 compressed encoding of this point.
     fn from(affine_point: AffinePoint) -> EncodedPoint {
@@ -286,6 +305,30 @@ impl Neg for AffinePoint {
     }
 }
 
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+impl Serialize for AffinePoint {
+    fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        self.to_encoded_point(true).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+impl<'de> Deserialize<'de> for AffinePoint {
+    fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        EncodedPoint::deserialize(deserializer)?
+            .try_into()
+            .map_err(de::Error::custom)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::AffinePoint;

p256/src/arithmetic/scalar.rs

@@ -24,6 +24,9 @@ use elliptic_curve::{
 #[cfg(feature = "bits")]
 use {crate::ScalarBits, elliptic_curve::group::ff::PrimeFieldBits};
 
+#[cfg(feature = "serde")]
+use elliptic_curve::serde::{de, ser, Deserialize, Serialize};
+
 /// Array containing 4 x 64-bit unsigned integers.
 // TODO(tarcieri): replace this entirely with `U256`
 type U64x4 = [u64; 4];
@@ -573,6 +576,24 @@ impl From<ScalarCore<NistP256>> for Scalar {
     }
 }
 
+impl From<&ScalarCore<NistP256>> for Scalar {
+    fn from(scalar: &ScalarCore<NistP256>) -> Scalar {
+        Scalar(*scalar.as_uint())
+    }
+}
+
+impl From<Scalar> for ScalarCore<NistP256> {
+    fn from(scalar: Scalar) -> ScalarCore<NistP256> {
+        ScalarCore::from(&scalar)
+    }
+}
+
+impl From<&Scalar> for ScalarCore<NistP256> {
+    fn from(scalar: &Scalar) -> ScalarCore<NistP256> {
+        ScalarCore::new(scalar.0).unwrap()
+    }
+}
+
 impl From<Scalar> for U256 {
     fn from(scalar: Scalar) -> U256 {
         scalar.0
@@ -749,6 +770,28 @@ impl From<&SecretKey> for Scalar {
     }
 }
 
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+impl Serialize for Scalar {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        ScalarCore::from(self).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+impl<'de> Deserialize<'de> for Scalar {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        Ok(ScalarCore::deserialize(deserializer)?.into())
+    }
+}
+
 /// Convert to a [`U64x4`] array.
 // TODO(tarcieri): implement all algorithms in terms of `U256`?
 #[cfg(target_pointer_width = "32")]