ecdsa: Verifier facade (gated under verifier feature)

.github/workflows/ecdsa.yml

@@ -36,6 +36,7 @@ jobs:
           override: true
       - run: cargo build --no-default-features --release --target ${{ matrix.target }}
       - run: cargo build --no-default-features --features signer --release --target ${{ matrix.target }}
+      - run: cargo build --no-default-features --features verifier --release --target ${{ matrix.target }}
 
   test:
     runs-on: ubuntu-latest

ecdsa/Cargo.toml

@@ -31,6 +31,7 @@ hazmat = []
 rand = ["elliptic-curve/rand_core", "signature/rand-preview"]
 signer = ["digest", "hazmat", "rand", "zeroize"] # TODO(tarcieri): deterministic signing
 std = ["elliptic-curve/std", "signature/std"]
+verifier = ["digest", "hazmat"]
 zeroize = ["elliptic-curve/zeroize"]
 
 [package.metadata.docs.rs]

ecdsa/src/lib.rs

@@ -37,6 +37,10 @@ pub mod hazmat;
 #[cfg_attr(docsrs, doc(cfg(feature = "signer")))]
 pub mod signer;
 
+#[cfg(feature = "verifier")]
+#[cfg_attr(docsrs, doc(cfg(feature = "verifier")))]
+pub mod verifier;
+
 // Re-export the `elliptic-curve` crate (and select types)
 pub use elliptic_curve::{
     self, generic_array,
@@ -50,6 +54,9 @@ pub use signature::{self, Error};
 #[cfg(feature = "signer")]
 pub use signer::Signer;
 
+#[cfg(feature = "verifier")]
+pub use verifier::Verifier;
+
 use core::{
     convert::TryFrom,
     fmt::{self, Debug},

ecdsa/src/verifier.rs

@@ -0,0 +1,71 @@
+//! ECDSA verifier. Generic over elliptic curves.
+//!
+//! Requires an [`elliptic_curve::Arithmetic`] impl on the curve, and a
+//! [`VerifyPrimitive`] impl on its associated `AffinePoint` type.
+
+use crate::{
+    hazmat::{DigestPrimitive, VerifyPrimitive},
+    Error, Signature, SignatureSize,
+};
+use core::ops::Add;
+use elliptic_curve::{
+    consts::U1,
+    generic_array::ArrayLength,
+    weierstrass::{CompressedPointSize, Curve, FromPublicKey, PublicKey, UncompressedPointSize},
+    Arithmetic,
+};
+use signature::{digest::Digest, DigestVerifier};
+
+/// ECDSA verifier
+pub struct Verifier<C: Curve + Arithmetic> {
+    public_key: C::AffinePoint,
+}
+
+impl<C> Verifier<C>
+where
+    C: Curve + Arithmetic,
+    C::AffinePoint: VerifyPrimitive<C> + FromPublicKey<C>,
+    C::ElementSize: Add<U1>,
+    <C::ElementSize as Add>::Output: Add<U1>,
+    CompressedPointSize<C>: ArrayLength<u8>,
+    UncompressedPointSize<C>: ArrayLength<u8>,
+    SignatureSize<C>: ArrayLength<u8>,
+{
+    /// Create a new verifier
+    pub fn new(public_key: &PublicKey<C>) -> Result<Self, Error> {
+        let affine_point = C::AffinePoint::from_public_key(public_key);
+
+        if affine_point.is_some().into() {
+            Ok(Self {
+                public_key: affine_point.unwrap(),
+            })
+        } else {
+            Err(Error::new())
+        }
+    }
+}
+
+impl<C, D> DigestVerifier<D, Signature<C>> for Verifier<C>
+where
+    C: Curve + Arithmetic,
+    D: Digest<OutputSize = C::ElementSize>,
+    C::AffinePoint: VerifyPrimitive<C>,
+    SignatureSize<C>: ArrayLength<u8>,
+{
+    fn verify_digest(&self, digest: D, signature: &Signature<C>) -> Result<(), Error> {
+        self.public_key
+            .verify_prehashed(&digest.finalize(), signature)
+    }
+}
+
+impl<C> signature::Verifier<Signature<C>> for Verifier<C>
+where
+    C: Curve + Arithmetic + DigestPrimitive,
+    C::AffinePoint: VerifyPrimitive<C>,
+    C::Digest: Digest<OutputSize = C::ElementSize>,
+    SignatureSize<C>: ArrayLength<u8>,
+{
+    fn verify(&self, msg: &[u8], signature: &Signature<C>) -> Result<(), Error> {
+        self.verify_digest(C::Digest::new().chain(msg), signature)
+    }
+}