ed448-goldilocks: don't rename signature crate (#1259)

Uses the original crate name and re-exports it under
`ed448_goldilocks::sign::signature`

Author: tarcieri

ed448-goldilocks/Cargo.toml

@@ -16,21 +16,23 @@ This crate also includes signing and verifying of Ed448 signatures.
 """
 
 [dependencies]
-crypto_signature = { version = "3.0.0-rc.0", default-features = false, features = ["digest", "rand_core"], optional = true, package = "signature" }
 elliptic-curve = { version = "0.14.0-rc.6", features = ["arithmetic", "hash2curve", "pkcs8"] }
-ed448 = { version = "=0.5.0-pre.0", default-features = false, optional = true }
 rand_core = { version = "0.9", default-features = false }
-serdect = { version = "0.3.0", optional = true }
 sha3 = { version = "0.11.0-rc.0", default-features = false }
 subtle = { version = "2.6", default-features = false }
 
+# optional dependencies
+ed448 = { version = "=0.5.0-pre.0", optional = true, default-features = false }
+serdect = { version = "0.3.0", optional = true }
+signature = { version = "3.0.0-rc.0", optional = true, default-features = false, features = ["digest", "rand_core"] }
+
 [features]
 default = ["std", "signing", "pkcs8"]
-alloc = ["crypto_signature/alloc", "ed448?/alloc", "elliptic-curve/alloc", "serdect/alloc"]
+alloc = ["ed448?/alloc", "elliptic-curve/alloc", "serdect?/alloc", "signature?/alloc"]
 std = ["alloc"]
 bits = ["elliptic-curve/bits"]
 pkcs8 = ["ed448?/pkcs8", "elliptic-curve/pkcs8"]
-signing = ["dep:crypto_signature", "ed448"]
+signing = ["dep:ed448", "dep:signature"]
 serde = ["dep:serdect", "ed448?/serde_bytes"]
 
 [dev-dependencies]

ed448-goldilocks/src/sign.rs

@@ -75,19 +75,21 @@
 mod context;
 mod error;
 mod expanded;
-mod signature;
 mod signing_key;
 mod verifying_key;
 
 pub use context::*;
-pub use crypto_signature;
+pub use ed448::Signature;
 #[cfg(feature = "pkcs8")]
 pub use elliptic_curve::pkcs8;
 pub use error::*;
-pub use signature::*;
+pub use signature;
 pub use signing_key::*;
 pub use verifying_key::*;
 
+use crate::{CompressedEdwardsY, EdwardsPoint, Scalar};
+use elliptic_curve::array::Array;
+
 /// Length of a secret key in bytes
 pub const SECRET_KEY_LENGTH: usize = 57;
 
@@ -111,3 +113,37 @@ pub const ALGORITHM_ID: pkcs8::AlgorithmIdentifierRef<'static> = pkcs8::Algorith
     oid: ALGORITHM_OID,
     parameters: None,
 };
+
+impl From<InnerSignature> for Signature {
+    fn from(inner: InnerSignature) -> Self {
+        let mut s = [0u8; SECRET_KEY_LENGTH];
+        s.copy_from_slice(&inner.s.to_bytes_rfc_8032());
+        Self::from_components(inner.r.compress(), s)
+    }
+}
+
+impl TryFrom<&Signature> for InnerSignature {
+    type Error = SigningError;
+
+    fn try_from(signature: &Signature) -> Result<Self, Self::Error> {
+        let s_bytes: &Array<u8, _> = (signature.s_bytes()).into();
+        let s = Option::from(Scalar::from_canonical_bytes(s_bytes))
+            .ok_or(SigningError::InvalidSignatureSComponent)?;
+        let r = Option::from(CompressedEdwardsY::from(*signature.r_bytes()).decompress())
+            .ok_or(SigningError::InvalidSignatureRComponent)?;
+        Ok(Self { r, s })
+    }
+}
+
+pub(crate) struct InnerSignature {
+    pub(crate) r: EdwardsPoint,
+    pub(crate) s: Scalar,
+}
+
+impl TryFrom<Signature> for InnerSignature {
+    type Error = SigningError;
+
+    fn try_from(signature: Signature) -> Result<Self, Self::Error> {
+        Self::try_from(&signature)
+    }
+}

ed448-goldilocks/src/sign/error.rs

@@ -41,14 +41,14 @@ impl Display for SigningError {
 
 impl Error for SigningError {}
 
-impl From<SigningError> for crypto_signature::Error {
+impl From<SigningError> for signature::Error {
     #[cfg(feature = "alloc")]
     fn from(err: SigningError) -> Self {
-        crypto_signature::Error::from_source(err)
+        signature::Error::from_source(err)
     }
 
     #[cfg(not(feature = "alloc"))]
     fn from(_err: SigningError) -> Self {
-        crypto_signature::Error::new()
+        signature::Error::new()
     }
 }

ed448-goldilocks/src/sign/signature.rs

@@ -4,13 +4,13 @@
 use crate::sign::expanded::ExpandedSecretKey;
 use crate::*;
 use core::fmt::{self, Debug, Formatter};
-use crypto_signature::Error;
 use elliptic_curve::zeroize::{Zeroize, ZeroizeOnDrop};
 use rand_core::CryptoRng;
 use sha3::digest::{
     Digest, ExtendableOutput, FixedOutput, FixedOutputReset, HashMarker, Update, XofReader,
     consts::U64, crypto_common::BlockSizeUser, typenum::IsEqual,
 };
+use signature::Error;
 use subtle::{Choice, ConstantTimeEq};
 
 #[cfg(feature = "pkcs8")]
@@ -212,7 +212,7 @@ impl TryFrom<Box<[u8]>> for SigningKey {
     }
 }
 
-impl<D> crypto_signature::DigestSigner<D, Signature> for SigningKey
+impl<D> signature::DigestSigner<D, Signature> for SigningKey
 where
     D: Digest,
 {
@@ -224,21 +224,21 @@ where
     }
 }
 
-impl crypto_signature::hazmat::PrehashSigner<Signature> for SigningKey {
+impl signature::hazmat::PrehashSigner<Signature> for SigningKey {
     fn sign_prehash(&self, prehash: &[u8]) -> Result<Signature, Error> {
         let sig = self.secret.sign_prehashed(&[], prehash)?;
         Ok(sig.into())
     }
 }
 
-impl crypto_signature::Signer<Signature> for SigningKey {
+impl signature::Signer<Signature> for SigningKey {
     fn try_sign(&self, msg: &[u8]) -> Result<Signature, Error> {
         let sig = self.secret.sign_raw(msg)?;
         Ok(sig.into())
     }
 }
 
-impl<D> crypto_signature::DigestSigner<D, Signature> for Context<'_, '_, SigningKey>
+impl<D> signature::DigestSigner<D, Signature> for Context<'_, '_, SigningKey>
 where
     D: Digest,
 {
@@ -253,34 +253,34 @@ where
     }
 }
 
-impl crypto_signature::hazmat::PrehashSigner<Signature> for Context<'_, '_, SigningKey> {
+impl signature::hazmat::PrehashSigner<Signature> for Context<'_, '_, SigningKey> {
     fn sign_prehash(&self, prehash: &[u8]) -> Result<Signature, Error> {
         let sig = self.key.secret.sign_prehashed(self.value, prehash)?;
         Ok(sig.into())
     }
 }
 
-impl crypto_signature::Signer<Signature> for Context<'_, '_, SigningKey> {
+impl signature::Signer<Signature> for Context<'_, '_, SigningKey> {
     fn try_sign(&self, msg: &[u8]) -> Result<Signature, Error> {
         let sig = self.key.secret.sign_ctx(self.value, msg)?;
         Ok(sig.into())
     }
 }
 
-impl<D> crypto_signature::DigestVerifier<D, Signature> for SigningKey
+impl<D> signature::DigestVerifier<D, Signature> for SigningKey
 where
     D: Digest,
 {
     fn verify_digest(&self, msg: D, signature: &Signature) -> Result<(), Error> {
-        <VerifyingKey as crypto_signature::DigestVerifier<D, Signature>>::verify_digest(
+        <VerifyingKey as signature::DigestVerifier<D, Signature>>::verify_digest(
             &self.secret.public_key,
             msg,
             signature,
         )
     }
 }
 
-impl crypto_signature::Verifier<Signature> for SigningKey {
+impl signature::Verifier<Signature> for SigningKey {
     fn verify(&self, msg: &[u8], signature: &Signature) -> Result<(), Error> {
         self.secret.public_key.verify_raw(signature, msg)
     }
@@ -474,7 +474,7 @@ impl SigningKey {
     }
 
     /// Create a signing context that can be used for Ed448ph with
-    /// [`crypto_signature::DigestSigner`]
+    /// [`signature::DigestSigner`]
     pub fn with_context<'k, 'v>(&'k self, context: &'v [u8]) -> Context<'k, 'v, Self> {
         Context {
             key: self,

ed448-goldilocks/src/sign/signing_key.rs

@@ -18,12 +18,12 @@ use core::{
     fmt::{self, Debug, Formatter},
     hash::{Hash, Hasher},
 };
-use crypto_signature::Error;
 use elliptic_curve::Group;
 use sha3::{
     Shake256,
     digest::{Digest, ExtendableOutput, Update, XofReader},
 };
+use signature::Error;
 
 /// Ed448 public key as defined in [RFC8032 § 5.2.5]
 #[derive(Copy, Clone, Default, Eq)]
@@ -56,13 +56,13 @@ impl PartialEq for VerifyingKey {
     }
 }
 
-impl crypto_signature::Verifier<Signature> for VerifyingKey {
+impl signature::Verifier<Signature> for VerifyingKey {
     fn verify(&self, msg: &[u8], signature: &Signature) -> Result<(), Error> {
         self.verify_raw(signature, msg)
     }
 }
 
-impl<D> crypto_signature::DigestVerifier<D, Signature> for VerifyingKey
+impl<D> signature::DigestVerifier<D, Signature> for VerifyingKey
 where
     D: Digest,
 {
@@ -73,13 +73,13 @@ where
     }
 }
 
-impl crypto_signature::Verifier<Signature> for Context<'_, '_, VerifyingKey> {
+impl signature::Verifier<Signature> for Context<'_, '_, VerifyingKey> {
     fn verify(&self, msg: &[u8], signature: &Signature) -> Result<(), Error> {
         self.key.verify_ctx(signature, self.value, msg)
     }
 }
 
-impl<D> crypto_signature::DigestVerifier<D, Signature> for Context<'_, '_, VerifyingKey>
+impl<D> signature::DigestVerifier<D, Signature> for Context<'_, '_, VerifyingKey>
 where
     D: Digest,
 {
@@ -186,7 +186,7 @@ impl VerifyingKey {
         Ok(Self { compressed, point })
     }
 
-    /// Create a context for this verifying key that can be used with [`crypto_signature::DigestVerifier`].
+    /// Create a context for this verifying key that can be used with [`signature::DigestVerifier`].
     pub fn with_context<'k, 'v>(&'k self, context: &'v [u8]) -> Context<'k, 'v, Self> {
         Context {
             key: self,