Bump elliptic-curve crate to v0.14.0-pre.2

Cargo.toml

@@ -16,3 +16,7 @@ members = [
 
 [profile.dev]
 opt-level = 2
+
+[patch.crates-io.ecdsa]
+#git = "https://github.com/RustCrypto/signatures.git"
+path = "../signatures/ecdsa"

bign256/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bign256"
-version = "0.13.1"
+version = "0.14.0-pre"
 description = """
 Pure Rust implementation of the Bign P-256 (a.k.a. bign-curve256v1)
 elliptic curve as defined in STB 34.101.45-2013, with
@@ -14,17 +14,16 @@ readme = "README.md"
 categories = ["cryptography", "no-std"]
 keywords = ["crypto", "ecc", "stb", "bign-curve256v1", "bignp256"]
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.73"
 
 [dependencies]
-elliptic-curve = { version = "0.13.8", features = ["hazmat", "sec1"] }
+elliptic-curve = { version = "=0.14.0-pre.1", features = ["hazmat", "sec1"] }
 
 # optional dependencies
-primeorder = { version = "0.13.5", optional = true, path = "../primeorder" }
-signature = { version = "2", optional = true }
-belt-hash = { version = "0.1.0", optional = true, default-features = false }
-crypto-bigint = { version = "0.5.5", optional = true }
-rfc6979 = { version = "0.4", optional = true }
+primeorder = { version = "=0.14.0-pre", optional = true, path = "../primeorder" }
+signature = { version = "=2.3.0-pre.1", optional = true }
+belt-hash = { version = "=0.2.0-pre.1", optional = true, default-features = false }
+rfc6979 = { version = "=0.5.0-pre.1", optional = true }
 
 [dev-dependencies]
 criterion = "0.5"
@@ -38,7 +37,7 @@ default = ["arithmetic", "pkcs8", "std", "dsa"]
 alloc = ["elliptic-curve/alloc", "primeorder?/alloc"]
 std = ["alloc", "elliptic-curve/std", "signature?/std"]
 
-dsa = ["arithmetic", "dep:rfc6979", "dep:signature", "dep:belt-hash", "dep:crypto-bigint"]
+dsa = ["arithmetic", "dep:rfc6979", "dep:signature", "dep:belt-hash"]
 arithmetic = ["dep:primeorder", "elliptic-curve/arithmetic"]
 pkcs8 = ["elliptic-curve/pkcs8"]
 

bign256/src/arithmetic/scalar.rs

@@ -125,8 +125,8 @@ impl Scalar {
     /// Right shifts the scalar.
     ///
     /// Note: not constant-time with respect to the `shift` parameter.
-    pub const fn shr_vartime(&self, shift: usize) -> Scalar {
-        Self(self.0.shr_vartime(shift))
+    pub const fn shr_vartime(&self, shift: u32) -> Scalar {
+        Self(self.0.wrapping_shr_vartime(shift))
     }
 }
 
@@ -154,7 +154,7 @@ impl Invert for Scalar {
 
 impl IsHigh for Scalar {
     fn is_high(&self) -> Choice {
-        const MODULUS_SHR1: U256 = BignP256::ORDER.shr_vartime(1);
+        const MODULUS_SHR1: U256 = BignP256::ORDER.wrapping_shr_vartime(1);
         self.to_canonical().ct_gt(&MODULUS_SHR1)
     }
 }
@@ -163,15 +163,15 @@ impl Shr<usize> for Scalar {
     type Output = Self;
 
     fn shr(self, rhs: usize) -> Self::Output {
-        self.shr_vartime(rhs)
+        self.shr_vartime(rhs as u32)
     }
 }
 
 impl Shr<usize> for &Scalar {
     type Output = Scalar;
 
     fn shr(self, rhs: usize) -> Self::Output {
-        self.shr_vartime(rhs)
+        self.shr_vartime(rhs as u32)
     }
 }
 

bign256/src/dsa.rs

@@ -43,9 +43,9 @@ pub use self::{signing::SigningKey, verifying::VerifyingKey};
 
 use crate::{BignP256, FieldBytes, NonZeroScalar, Scalar};
 use core::fmt::{self, Debug};
-use crypto_bigint::{
+use elliptic_curve::{
+    array::Array,
     consts::{U32, U48},
-    generic_array::GenericArray,
 };
 use signature::{Error, Result, SignatureEncoding};
 
@@ -76,7 +76,7 @@ impl Signature {
     /// Parse an BignP256 signature from a byte array.
     pub fn from_bytes(bytes: &SignatureBytes) -> Result<Self> {
         let (s0, s1) = bytes.split_at(Self::BYTE_SIZE / 3);
-        let mut s0_bytes: GenericArray<u8, U32> = Default::default();
+        let mut s0_bytes: Array<u8, U32> = Default::default();
         s0_bytes[..16].copy_from_slice(s0);
 
         let s0 = ScalarPrimitive::from_slice(&s0_bytes).map_err(|_| Error::new())?;
@@ -106,7 +106,7 @@ impl Signature {
         s0.reverse();
         s1.reverse();
 
-        let mut s: GenericArray<u8, U48> = Default::default();
+        let mut s: Array<u8, U48> = Default::default();
         s[..Self::BYTE_SIZE / 3].copy_from_slice(s0);
         s[Self::BYTE_SIZE / 3..Self::BYTE_SIZE].copy_from_slice(&s1);
 

bign256/src/dsa/signing.rs

@@ -16,19 +16,17 @@
 
 use super::{Signature, VerifyingKey, BELT_OID};
 use crate::{BignP256, FieldBytes, NonZeroScalar, ProjectivePoint, PublicKey, Scalar, SecretKey};
+use belt_hash::{BeltHash, Digest};
 use core::fmt::{self, Debug};
 use elliptic_curve::{
-    generic_array::typenum::Unsigned,
+    array::{consts::U32, typenum::Unsigned, Array},
     ops::{MulByGenerator, Reduce},
     point::AffineCoordinates,
     subtle::{Choice, ConstantTimeEq},
     Curve, Field, FieldBytesEncoding, PrimeField,
 };
 use signature::{hazmat::PrehashSigner, Error, KeypairRef, Result, Signer};
 
-use belt_hash::{BeltHash, Digest};
-use crypto_bigint::{consts::U32, generic_array::GenericArray};
-
 /// BignP256 secret key used for signing messages and producing signatures.
 ///
 /// ## Usage
@@ -107,7 +105,7 @@ impl PrehashSigner<Signature> for SigningKey {
         if prehash.len() != <BignP256 as Curve>::FieldBytesSize::USIZE {
             return Err(Error::new());
         }
-        let mut h_word: GenericArray<u8, U32> = GenericArray::clone_from_slice(prehash);
+        let mut h_word: Array<u8, U32> = Array::clone_from_slice(prehash);
         h_word.reverse();
 
         let h = Scalar::reduce_bytes(&h_word);
@@ -122,7 +120,7 @@ impl PrehashSigner<Signature> for SigningKey {
         .unwrap();
 
         // 3. Set 𝑅 ← 𝑘𝐺.
-        let mut R: GenericArray<u8, _> = ProjectivePoint::mul_by_generator(&k).to_affine().x();
+        let mut R: Array<u8, _> = ProjectivePoint::mul_by_generator(&k).to_affine().x();
         R.reverse();
 
         // 4. Set 𝑆0 ← ⟨︀belt-hash(OID(ℎ) ‖ ⟨𝑅⟩2𝑙 ‖ 𝐻)⟩︀_𝑙.

bign256/src/dsa/verifying.rs

@@ -22,9 +22,8 @@ use belt_hash::{
     digest::{Digest, FixedOutput},
     BeltHash,
 };
-use crypto_bigint::{consts::U32, generic_array::GenericArray};
 use elliptic_curve::{
-    generic_array::typenum::Unsigned,
+    array::{consts::U32, typenum::Unsigned, Array},
     group::GroupEncoding,
     ops::{LinearCombination, Reduce},
     sec1::ToEncodedPoint,
@@ -122,7 +121,7 @@ impl PrehashVerifier<Signature> for VerifyingKey {
         // 3. If 𝑆1 ⩾ 𝑞, return NO.
         let s1 = signature.s1();
 
-        let mut hash: GenericArray<u8, U32> = GenericArray::clone_from_slice(prehash);
+        let mut hash: Array<u8, U32> = Array::clone_from_slice(prehash);
         hash.reverse();
 
         let hw = Scalar::reduce_bytes(FieldBytes::from_slice(&hash));

bign256/src/lib.rs

@@ -48,9 +48,9 @@ pub use arithmetic::{scalar::Scalar, AffinePoint, ProjectivePoint};
 pub use elliptic_curve::pkcs8;
 
 use elliptic_curve::{
+    array::Array,
     bigint::ArrayEncoding,
     consts::{U32, U33},
-    generic_array::GenericArray,
     FieldBytesEncoding,
 };
 
@@ -107,7 +107,7 @@ impl pkcs8::AssociatedOid for BignP256 {
 }
 
 /// Compressed SEC1-encoded BIGN P256 curve point.
-pub type CompressedPoint = GenericArray<u8, U33>;
+pub type CompressedPoint = Array<u8, U33>;
 
 /// BIGN P-256 field element serialized as bytes.
 ///

bp256/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bp256"
-version = "0.6.1"
+version = "0.7.0-pre"
 description = "Brainpool P-256 (brainpoolP256r1 and brainpoolP256t1) elliptic curves"
 authors = ["RustCrypto Developers"]
 license = "Apache-2.0 OR MIT"
@@ -10,15 +10,15 @@ readme = "README.md"
 categories = ["cryptography", "no-std"]
 keywords = ["brainpool", "crypto", "ecc"]
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.73"
 
 [dependencies]
-elliptic-curve = { version = "0.13", default-features = false, features = ["hazmat", "sec1"] }
+elliptic-curve = { version = "=0.14.0-pre.1", default-features = false, features = ["hazmat", "sec1"] }
 
 # optional dependencies
-ecdsa = { version = "0.16", optional = true, default-features = false, features = ["der"] }
-primeorder = { version = "0.13.5", optional = true, path = "../primeorder" }
-sha2 = { version = "0.10", optional = true, default-features = false }
+ecdsa = { version = "=0.17.0-pre.1", optional = true, default-features = false, features = ["der"] }
+primeorder = { version = "=0.14.0-pre", optional = true, path = "../primeorder" }
+sha2 = { version = "=0.11.0-pre.1", optional = true, default-features = false }
 
 [features]
 default = ["pkcs8", "std"]

bp256/src/arithmetic/scalar.rs

@@ -174,8 +174,8 @@ impl Scalar {
     /// Right shifts the scalar.
     ///
     /// Note: not constant-time with respect to the `shift` parameter.
-    pub const fn shr_vartime(&self, shift: usize) -> Scalar {
-        Self(self.0.shr_vartime(shift))
+    pub const fn shr_vartime(&self, shift: u32) -> Scalar {
+        Self(self.0.wrapping_shr_vartime(shift))
     }
 
     /// Compute modular square.
@@ -296,7 +296,7 @@ impl Invert for Scalar {
 
 impl IsHigh for Scalar {
     fn is_high(&self) -> Choice {
-        const MODULUS_SHR1: U256 = ORDER.shr_vartime(1);
+        const MODULUS_SHR1: U256 = ORDER.wrapping_shr_vartime(1);
         self.to_canonical().ct_gt(&MODULUS_SHR1)
     }
 }
@@ -305,15 +305,15 @@ impl Shr<usize> for Scalar {
     type Output = Self;
 
     fn shr(self, rhs: usize) -> Self::Output {
-        self.shr_vartime(rhs)
+        self.shr_vartime(rhs as u32)
     }
 }
 
 impl Shr<usize> for &Scalar {
     type Output = Scalar;
 
     fn shr(self, rhs: usize) -> Self::Output {
-        self.shr_vartime(rhs)
+        self.shr_vartime(rhs as u32)
     }
 }
 

bp256/src/lib.rs

@@ -30,13 +30,13 @@ pub use crate::arithmetic::scalar::Scalar;
 #[cfg(feature = "pkcs8")]
 pub use elliptic_curve::pkcs8;
 
-use elliptic_curve::generic_array::{typenum::U32, GenericArray};
+use elliptic_curve::array::{typenum::U32, Array};
 
 #[cfg(feature = "wip-arithmetic-do-not-use")]
 pub(crate) use crate::arithmetic::field::FieldElement;
 
 /// Byte representation of a base/scalar field element of a given curve.
-pub type FieldBytes = GenericArray<u8, U32>;
+pub type FieldBytes = Array<u8, U32>;
 
 const ORDER_HEX: &str = "a9fb57dba1eea9bc3e660a909d838d718c397aa3b561a6f7901e0e82974856a7";
 const ORDER: U256 = U256::from_be_hex(ORDER_HEX);

bp384/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bp384"
-version = "0.6.1"
+version = "0.7.0-pre"
 description = "Brainpool P-384 (brainpoolP384r1 and brainpoolP384t1) elliptic curves"
 authors = ["RustCrypto Developers"]
 license = "Apache-2.0 OR MIT"
@@ -10,15 +10,15 @@ readme = "README.md"
 categories = ["cryptography", "no-std"]
 keywords = ["brainpool", "crypto", "ecc"]
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.73"
 
 [dependencies]
-elliptic-curve = { version = "0.13", default-features = false, features = ["hazmat", "sec1"] }
+elliptic-curve = { version = "=0.14.0-pre.1", default-features = false, features = ["hazmat", "sec1"] }
 
 # optional dependencies
-ecdsa = { version = "0.16", optional = true, default-features = false, features = ["der"] }
-primeorder = { version = "0.13.5", optional = true, path = "../primeorder" }
-sha2 = { version = "0.10", optional = true, default-features = false }
+ecdsa = { version = "=0.17.0-pre.1", optional = true, default-features = false, features = ["der"] }
+primeorder = { version = "=0.14.0-pre", optional = true, path = "../primeorder" }
+sha2 = { version = "=0.11.0-pre.1", optional = true, default-features = false }
 
 [features]
 default = ["pkcs8", "std"]

bp384/src/arithmetic/scalar.rs

@@ -174,8 +174,8 @@ impl Scalar {
     /// Right shifts the scalar.
     ///
     /// Note: not constant-time with respect to the `shift` parameter.
-    pub const fn shr_vartime(&self, shift: usize) -> Scalar {
-        Self(self.0.shr_vartime(shift))
+    pub const fn shr_vartime(&self, shift: u32) -> Scalar {
+        Self(self.0.wrapping_shr_vartime(shift))
     }
 
     /// Compute modular square.
@@ -303,7 +303,7 @@ impl Invert for Scalar {
 
 impl IsHigh for Scalar {
     fn is_high(&self) -> Choice {
-        const MODULUS_SHR1: U384 = ORDER.shr_vartime(1);
+        const MODULUS_SHR1: U384 = ORDER.wrapping_shr_vartime(1);
         self.to_canonical().ct_gt(&MODULUS_SHR1)
     }
 }
@@ -312,15 +312,15 @@ impl Shr<usize> for Scalar {
     type Output = Self;
 
     fn shr(self, rhs: usize) -> Self::Output {
-        self.shr_vartime(rhs)
+        self.shr_vartime(rhs as u32)
     }
 }
 
 impl Shr<usize> for &Scalar {
     type Output = Scalar;
 
     fn shr(self, rhs: usize) -> Self::Output {
-        self.shr_vartime(rhs)
+        self.shr_vartime(rhs as u32)
     }
 }
 

bp384/src/lib.rs

@@ -30,13 +30,13 @@ pub use crate::arithmetic::scalar::Scalar;
 #[cfg(feature = "pkcs8")]
 pub use elliptic_curve::pkcs8;
 
-use elliptic_curve::generic_array::{typenum::U48, GenericArray};
+use elliptic_curve::array::{typenum::U48, Array};
 
 #[cfg(feature = "wip-arithmetic-do-not-use")]
 pub(crate) use crate::arithmetic::field::FieldElement;
 
 /// Byte representation of a base/scalar field element of a given curve.
-pub type FieldBytes = GenericArray<u8, U48>;
+pub type FieldBytes = Array<u8, U48>;
 
 const ORDER_HEX: &str = "8cb91e82a3386d280f5d6f7e50e641df152f7109ed5456b31f166e6cac0425a7cf3ab6af6b7fc3103b883202e9046565";
 const ORDER: U384 = U384::from_be_hex(ORDER_HEX);