Digestable signatures

signature-crate/src/digest/digestable.rs

@@ -0,0 +1,40 @@
+use crate::{
+    digest::{self, Digest},
+    error::Error,
+    signature::Signature,
+    signer::Signer,
+    verifier::Verifier,
+};
+
+/// Marker trait for `Signature` types computable as `S(H(m))` where:
+///
+/// - `S`: signature algorithm
+/// - `H`: hash (a.k.a. digest) function
+/// - `m`: message
+///
+/// For signature types that implement this trait, a blanket impl of
+/// `Signer` will be provided for all types that `impl digest::Signer`.
+pub trait Digestable: Signature {
+    /// Preferred `Digest` algorithm to use when computing this signature type.
+    type Digest: Digest;
+}
+
+impl<S, T> Signer<S> for T
+where
+    S: Digestable + Signature,
+    T: digest::Signer<S::Digest, S>,
+{
+    fn sign(&self, msg: &[u8]) -> Result<S, Error> {
+        self.sign_digest(S::Digest::digest(msg))
+    }
+}
+
+impl<S, T> Verifier<S> for T
+where
+    S: Digestable + Signature,
+    T: digest::Verifier<S::Digest, S>,
+{
+    fn verify(&self, msg: &[u8], signature: &S) -> Result<(), Error> {
+        self.verify_digest(S::Digest::digest(msg), signature)
+    }
+}

signature-crate/src/digest/mod.rs

@@ -1,11 +1,12 @@
 //! Support for using hash functions that impl the `Digest` trait in order
 //! to hash the input message in order to compute a signature.
 
+mod digestable;
 mod signer;
 mod verifier;
 
 /// Re-export the `Digest` trait from the `digest` crate, as it's the main
 /// trait this module depends on.
 pub use ::digest::Digest;
 
-pub use self::{signer::Signer, verifier::Verifier};
+pub use self::{digestable::Digestable, signer::Signer, verifier::Verifier};

signature-crate/src/digest/signer.rs

@@ -4,7 +4,9 @@
 //! For use signature algorithms that support an Initialize-Update-Finalize
 //! (IUF) API, such as ECDSA or Ed25519ph.
 
-use crate::{digest::Digest, error::Error, Signature};
+use super::Digest;
+use crate::{error::Error, signature::Signature};
+use digest::generic_array::GenericArray;
 
 /// Sign the given prehashed message `Digest` using `Self`.
 pub trait Signer<D, S>
@@ -13,5 +15,5 @@ where
     S: Signature,
 {
     /// Sign the given prehashed message `Digest`, returning a signature.
-    fn sign(&self, digest: D) -> Result<S, Error>;
+    fn sign_digest(&self, digest: GenericArray<u8, D::OutputSize>) -> Result<S, Error>;
 }

signature-crate/src/digest/verifier.rs

@@ -4,7 +4,9 @@
 //! For use signature algorithms that support an Initialize-Update-Finalize
 //! (IUF) API, such as ECDSA or Ed25519ph.
 
-use crate::{digest::Digest, error::Error, Signature};
+use super::Digest;
+use crate::{error::Error, signature::Signature};
+use digest::generic_array::GenericArray;
 
 /// Verify the provided signature for the given prehashed message `Digest`
 /// is authentic.
@@ -14,5 +16,9 @@ where
     S: Signature,
 {
     /// Verify the signature against the given `Digest`
-    fn verify(&self, digest: D, signature: &S) -> Result<(), Error>;
+    fn verify_digest(
+        &self,
+        digest: GenericArray<u8, D::OutputSize>,
+        signature: &S,
+    ) -> Result<(), Error>;
 }

signature-crate/src/lib.rs

@@ -19,11 +19,14 @@
 extern crate std;
 
 #[cfg(feature = "digest")]
-mod digest;
+pub mod digest;
 mod error;
 mod prelude;
 mod signature;
-pub mod signer;
-pub mod verifier;
+mod signer;
+mod verifier;
 
 pub use crate::{error::Error, signature::Signature, signer::Signer, verifier::Verifier};
+
+#[cfg(feature = "digest")]
+pub use crate::digest::Digestable;