Bump p256 to v0.10; p384 to v0.9

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ring-compat"
-version = "0.3.2"
+version = "0.4.0-pre"
 description = """
 Compatibility crate for using RustCrypto's traits with the cryptographic
 algorithm implementations from *ring*
@@ -17,12 +17,12 @@ keywords = ["aead", "digest", "crypto", "ring", "signature"]
 [dependencies]
 aead = { version = "0.4", optional = true, default-features = false }
 digest = { version = "0.9", optional = true }
-ecdsa = { version = "0.12", optional = true, default-features = false }
+ecdsa = { version = "0.13", optional = true, default-features = false }
 ed25519 = { version = "1.3", optional = true, default-features = false }
 generic-array = { version = "0.14", default-features = false }
 opaque-debug = "0.3"
-p256 = { version = "0.9", optional = true, default-features = false, features = ["ecdsa-core"] }
-p384 = { version = "0.8", optional = true, default-features = false, features = ["ecdsa"] }
+p256 = { version = "0.10", optional = true, default-features = false, features = ["ecdsa-core"] }
+p384 = { version = "0.9", optional = true, default-features = false, features = ["ecdsa"] }
 ring = { version = "0.16", default-features = false }
 zeroize = { version = "1", default-features = false }
 

src/signature/ecdsa.rs

@@ -9,13 +9,13 @@ mod signing_key;
 mod verifying_key;
 
 pub use self::{signing_key::SigningKey, verifying_key::VerifyingKey};
-pub use ::ecdsa::{der, elliptic_curve::weierstrass::Curve, Signature};
+pub use ::ecdsa::{der, elliptic_curve::PrimeCurve, Signature};
 
 use ring::signature::{EcdsaSigningAlgorithm, EcdsaVerificationAlgorithm};
 
 /// Trait for associating a *ring* [`EcdsaSigningAlgorithm`] with an
 /// elliptic curve
-pub trait CurveAlg: Curve {
+pub trait CurveAlg: PrimeCurve {
     /// *ring* signing algorithm
     fn signing_alg() -> &'static EcdsaSigningAlgorithm;
 

src/signature/ecdsa/signing_key.rs

@@ -1,14 +1,13 @@
 //! ECDSA signing key
 
-use super::{Curve, CurveAlg, Signature, VerifyingKey};
+use super::{CurveAlg, PrimeCurve, Signature, VerifyingKey};
 use crate::signature::{Error, Signature as _, Signer};
 use ::ecdsa::{
-    elliptic_curve::sec1::{UncompressedPointSize, UntaggedPointSize},
+    elliptic_curve::{sec1, FieldSize},
     SignatureSize,
 };
 use core::marker::PhantomData;
-use core::ops::Add;
-use generic_array::{typenum::U1, ArrayLength};
+use generic_array::ArrayLength;
 use ring::{
     self,
     rand::SystemRandom,
@@ -18,7 +17,7 @@ use ring::{
 /// ECDSA signing key. Generic over elliptic curves.
 pub struct SigningKey<C>
 where
-    C: Curve + CurveAlg,
+    C: PrimeCurve + CurveAlg,
     SignatureSize<C>: ArrayLength<u8>,
 {
     /// *ring* ECDSA keypair
@@ -33,7 +32,7 @@ where
 
 impl<C> SigningKey<C>
 where
-    C: Curve + CurveAlg,
+    C: PrimeCurve + CurveAlg,
     SignatureSize<C>: ArrayLength<u8>,
 {
     /// Initialize a [`SigningKey`] from a PKCS#8-encoded private key
@@ -61,16 +60,15 @@ where
     /// Get the [`VerifyingKey`] for this [`SigningKey`]
     pub fn verify_key(&self) -> VerifyingKey<C>
     where
-        UntaggedPointSize<C>: Add<U1> + ArrayLength<u8>,
-        UncompressedPointSize<C>: ArrayLength<u8>,
+        FieldSize<C>: sec1::ModulusSize,
     {
         VerifyingKey::new(self.keypair.public_key().as_ref()).unwrap()
     }
 }
 
 impl<C> Signer<Signature<C>> for SigningKey<C>
 where
-    C: Curve + CurveAlg,
+    C: PrimeCurve + CurveAlg,
     SignatureSize<C>: ArrayLength<u8>,
 {
     fn try_sign(&self, msg: &[u8]) -> Result<Signature<C>, Error> {

src/signature/ecdsa/verifying_key.rs

@@ -1,42 +1,37 @@
 //! ECDSA verifying key
 
-use super::{Curve, CurveAlg, Signature};
+use super::{CurveAlg, PrimeCurve, Signature};
 use crate::signature::{Error, Verifier};
 use ::ecdsa::{
-    elliptic_curve::{
-        bigint::Encoding as _,
-        sec1::{self, UncompressedPointSize, UntaggedPointSize},
-    },
+    elliptic_curve::{bigint::Encoding as _, sec1, FieldSize},
     SignatureSize,
 };
-use core::{convert::TryInto, ops::Add};
-use generic_array::{typenum::U1, ArrayLength};
+use core::convert::TryInto;
+use generic_array::ArrayLength;
 use ring::signature::UnparsedPublicKey;
 
 /// ECDSA verifying key. Generic over elliptic curves.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct VerifyingKey<C>(sec1::EncodedPoint<C>)
 where
-    C: Curve + CurveAlg,
-    SignatureSize<C>: ArrayLength<u8>,
-    UntaggedPointSize<C>: Add<U1> + ArrayLength<u8>,
-    UncompressedPointSize<C>: ArrayLength<u8>;
+    C: PrimeCurve + CurveAlg,
+    FieldSize<C>: sec1::ModulusSize,
+    SignatureSize<C>: ArrayLength<u8>;
 
 impl<C> VerifyingKey<C>
 where
-    C: Curve + CurveAlg,
+    C: PrimeCurve + CurveAlg,
+    FieldSize<C>: sec1::ModulusSize,
     SignatureSize<C>: ArrayLength<u8>,
-    UntaggedPointSize<C>: Add<U1> + ArrayLength<u8>,
-    UncompressedPointSize<C>: ArrayLength<u8>,
 {
     /// Initialize [`VerifyingKey`] from a SEC1-encoded public key
     pub fn new(bytes: &[u8]) -> Result<Self, Error> {
         let point_result = if bytes.len() == C::UInt::BYTE_SIZE * 2 {
-            Ok(sec1::EncodedPoint::from_untagged_bytes(
+            Ok(sec1::EncodedPoint::<C>::from_untagged_bytes(
                 bytes.try_into().unwrap(),
             ))
         } else {
-            sec1::EncodedPoint::from_bytes(bytes)
+            sec1::EncodedPoint::<C>::from_bytes(bytes)
         };
 
         point_result.map(VerifyingKey).map_err(|_| Error::new())
@@ -48,12 +43,11 @@ where
     }
 }
 
-impl<C: Curve> Verifier<Signature<C>> for VerifyingKey<C>
+impl<C: PrimeCurve> Verifier<Signature<C>> for VerifyingKey<C>
 where
-    C: Curve + CurveAlg,
+    C: PrimeCurve + CurveAlg,
+    FieldSize<C>: sec1::ModulusSize,
     SignatureSize<C>: ArrayLength<u8>,
-    UntaggedPointSize<C>: Add<U1> + ArrayLength<u8>,
-    UncompressedPointSize<C>: ArrayLength<u8>,
 {
     fn verify(&self, msg: &[u8], sig: &Signature<C>) -> Result<(), Error> {
         UnparsedPublicKey::new(C::verify_alg(), self.0.as_ref())