diff --git a/ecdsa/src/der.rs b/ecdsa/src/der.rs
index 1d13c5b0..5103b081 100644
--- a/ecdsa/src/der.rs
+++ b/ecdsa/src/der.rs
@@ -159,6 +159,17 @@ where
     }
 }
 
+impl<C> From<crate::Signature<C>> for Signature<C>
+where
+    C: PrimeCurve,
+    MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<MaxOverhead> + ArrayLength<u8>,
+{
+    fn from(sig: crate::Signature<C>) -> Signature<C> {
+        sig.to_der()
+    }
+}
+
 impl<C> TryFrom<&[u8]> for Signature<C>
 where
     C: PrimeCurve,
@@ -192,7 +203,7 @@ where
     }
 }
 
-impl<C> TryFrom<Signature<C>> for super::Signature<C>
+impl<C> TryFrom<Signature<C>> for crate::Signature<C>
 where
     C: PrimeCurve,
     MaxSize<C>: ArrayLength<u8>,
diff --git a/ecdsa/src/sign.rs b/ecdsa/src/sign.rs
index 546f1415..6386b894 100644
--- a/ecdsa/src/sign.rs
+++ b/ecdsa/src/sign.rs
@@ -22,6 +22,9 @@ use signature::{
     DigestSigner, RandomizedDigestSigner, RandomizedSigner, Signer,
 };
 
+#[cfg(feature = "der")]
+use {crate::der, core::ops::Add};
+
 #[cfg(feature = "pem")]
 use {
     crate::elliptic_curve::pkcs8::{EncodePrivateKey, SecretDocument},
@@ -100,239 +103,303 @@ where
     }
 }
 
-#[cfg(feature = "verify")]
-#[cfg_attr(docsrs, doc(cfg(feature = "verify")))]
-impl<C> AsRef<VerifyingKey<C>> for SigningKey<C>
+//
+// `*Signer` trait impls
+//
+
+impl<C, D> DigestSigner<D, Signature<C>> for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
+    C::UInt: for<'a> From<&'a Scalar<C>>,
+    D: Digest + BlockSizeUser + FixedOutput<OutputSize = FieldSize<C>> + FixedOutputReset,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
+
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn as_ref(&self) -> &VerifyingKey<C> {
-        &self.verifying_key
+    /// Sign message digest using a deterministic ephemeral scalar (`k`)
+    /// computed using the algorithm described in [RFC6979 § 3.2].
+    ///
+    /// [RFC6979 § 3.2]: https://tools.ietf.org/html/rfc6979#section-3
+    fn try_sign_digest(&self, msg_digest: D) -> Result<Signature<C>> {
+        Ok(self
+            .secret_scalar
+            .try_sign_digest_rfc6979::<D>(msg_digest, &[])?
+            .0)
     }
 }
 
-impl<C> ConstantTimeEq for SigningKey<C>
+impl<C> PrehashSigner<Signature<C>> for SigningKey<C>
 where
-    C: PrimeCurve + ProjectiveArithmetic,
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
+    C::Digest: FixedOutput<OutputSize = FieldSize<C>>,
+    C::UInt: for<'a> From<&'a Scalar<C>>,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn ct_eq(&self, other: &Self) -> Choice {
-        self.secret_scalar.ct_eq(&other.secret_scalar)
+    fn sign_prehash(&self, prehash: &[u8]) -> Result<Signature<C>> {
+        let prehash = C::prehash_to_field_bytes(prehash)?;
+
+        Ok(self
+            .secret_scalar
+            .try_sign_prehashed_rfc6979::<C::Digest>(prehash, &[])?
+            .0)
     }
 }
 
-impl<C> Debug for SigningKey<C>
+impl<C> Signer<Signature<C>> for SigningKey<C>
 where
-    C: PrimeCurve + ProjectiveArithmetic,
+    Self: DigestSigner<C::Digest, Signature<C>>,
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("SigningKey").finish_non_exhaustive()
+    fn try_sign(&self, msg: &[u8]) -> Result<Signature<C>> {
+        self.try_sign_digest(C::Digest::new_with_prefix(msg))
     }
 }
 
-impl<C> Drop for SigningKey<C>
+impl<C, D> RandomizedDigestSigner<D, Signature<C>> for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
+    C::UInt: for<'a> From<&'a Scalar<C>>,
+    D: Digest + BlockSizeUser + FixedOutput<OutputSize = FieldSize<C>> + FixedOutputReset,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn drop(&mut self) {
-        self.secret_scalar.zeroize();
+    /// Sign message prehash using an ephemeral scalar (`k`) derived according
+    /// to a variant of RFC 6979 (Section 3.6) which supplies additional
+    /// entropy from an RNG.
+    fn try_sign_digest_with_rng(
+        &self,
+        mut rng: impl CryptoRng + RngCore,
+        msg_digest: D,
+    ) -> Result<Signature<C>> {
+        let mut ad = FieldBytes::<C>::default();
+        rng.fill_bytes(&mut ad);
+        Ok(self
+            .secret_scalar
+            .try_sign_digest_rfc6979::<D>(msg_digest, &ad)?
+            .0)
     }
 }
 
-impl<C> ZeroizeOnDrop for SigningKey<C>
+impl<C> RandomizedSigner<Signature<C>> for SigningKey<C>
 where
-    C: PrimeCurve + ProjectiveArithmetic,
+    Self: RandomizedDigestSigner<C::Digest, Signature<C>>,
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
+    fn try_sign_with_rng(&self, rng: impl CryptoRng + RngCore, msg: &[u8]) -> Result<Signature<C>> {
+        self.try_sign_digest_with_rng(rng, C::Digest::new_with_prefix(msg))
+    }
 }
 
-/// Constant-time comparison
-impl<C> Eq for SigningKey<C>
+#[cfg(feature = "der")]
+#[cfg_attr(docsrs, doc(cfg(feature = "der")))]
+impl<C> PrehashSigner<der::Signature<C>> for SigningKey<C>
 where
-    C: PrimeCurve + ProjectiveArithmetic,
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
+    C::Digest: BlockSizeUser + FixedOutput<OutputSize = FieldSize<C>> + FixedOutputReset,
+    C::UInt: for<'a> From<&'a Scalar<C>>,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
+    der::MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<der::MaxOverhead> + ArrayLength<u8>,
 {
+    fn sign_prehash(&self, prehash: &[u8]) -> Result<der::Signature<C>> {
+        PrehashSigner::<Signature<C>>::sign_prehash(self, prehash).map(Into::into)
+    }
 }
 
-/// Constant-time comparison
-impl<C> PartialEq for SigningKey<C>
+#[cfg(feature = "der")]
+#[cfg_attr(docsrs, doc(cfg(feature = "der")))]
+impl<C> Signer<der::Signature<C>> for SigningKey<C>
 where
-    C: PrimeCurve + ProjectiveArithmetic,
+    Self: DigestSigner<C::Digest, Signature<C>>,
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
+    der::MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<der::MaxOverhead> + ArrayLength<u8>,
 {
-    fn eq(&self, other: &SigningKey<C>) -> bool {
-        self.ct_eq(other).into()
+    fn try_sign(&self, msg: &[u8]) -> Result<der::Signature<C>> {
+        Signer::<Signature<C>>::try_sign(self, msg).map(Into::into)
     }
 }
 
-impl<C> From<SecretKey<C>> for SigningKey<C>
+#[cfg(feature = "der")]
+#[cfg_attr(docsrs, doc(cfg(feature = "der")))]
+impl<C, D> RandomizedDigestSigner<D, der::Signature<C>> for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
+    C::UInt: for<'a> From<&'a Scalar<C>>,
+    D: Digest + BlockSizeUser + FixedOutput<OutputSize = FieldSize<C>> + FixedOutputReset,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
+    der::MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<der::MaxOverhead> + ArrayLength<u8>,
 {
-    fn from(secret_key: SecretKey<C>) -> Self {
-        Self::from(&secret_key)
+    fn try_sign_digest_with_rng(
+        &self,
+        rng: impl CryptoRng + RngCore,
+        msg_digest: D,
+    ) -> Result<der::Signature<C>> {
+        RandomizedDigestSigner::<D, Signature<C>>::try_sign_digest_with_rng(self, rng, msg_digest)
+            .map(Into::into)
     }
 }
 
-impl<C> From<&SecretKey<C>> for SigningKey<C>
+#[cfg(feature = "der")]
+#[cfg_attr(docsrs, doc(cfg(feature = "der")))]
+impl<C> RandomizedSigner<der::Signature<C>> for SigningKey<C>
 where
-    C: PrimeCurve + ProjectiveArithmetic,
+    Self: RandomizedDigestSigner<C::Digest, Signature<C>>,
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
+    der::MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<der::MaxOverhead> + ArrayLength<u8>,
 {
-    fn from(secret_key: &SecretKey<C>) -> Self {
-        secret_key.to_nonzero_scalar().into()
+    fn try_sign_with_rng(
+        &self,
+        rng: impl CryptoRng + RngCore,
+        msg: &[u8],
+    ) -> Result<der::Signature<C>> {
+        RandomizedSigner::<Signature<C>>::try_sign_with_rng(self, rng, msg).map(Into::into)
     }
 }
 
-impl<C> From<SigningKey<C>> for SecretKey<C>
+//
+// Other trait impls
+//
+
+#[cfg(feature = "verify")]
+#[cfg_attr(docsrs, doc(cfg(feature = "verify")))]
+impl<C> AsRef<VerifyingKey<C>> for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn from(key: SigningKey<C>) -> Self {
-        key.secret_scalar.into()
+    fn as_ref(&self) -> &VerifyingKey<C> {
+        &self.verifying_key
     }
 }
 
-impl<C> From<&SigningKey<C>> for SecretKey<C>
+impl<C> ConstantTimeEq for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn from(secret_key: &SigningKey<C>) -> Self {
-        secret_key.secret_scalar.into()
+    fn ct_eq(&self, other: &Self) -> Choice {
+        self.secret_scalar.ct_eq(&other.secret_scalar)
     }
 }
 
-impl<C, D> DigestSigner<D, Signature<C>> for SigningKey<C>
+impl<C> Debug for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
-    C::UInt: for<'a> From<&'a Scalar<C>>,
-    D: Digest + BlockSizeUser + FixedOutput<OutputSize = FieldSize<C>> + FixedOutputReset,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
-
     SignatureSize<C>: ArrayLength<u8>,
 {
-    /// Sign message digest using a deterministic ephemeral scalar (`k`)
-    /// computed using the algorithm described in [RFC6979 § 3.2].
-    ///
-    /// [RFC6979 § 3.2]: https://tools.ietf.org/html/rfc6979#section-3
-    fn try_sign_digest(&self, msg_digest: D) -> Result<Signature<C>> {
-        Ok(self
-            .secret_scalar
-            .try_sign_digest_rfc6979::<D>(msg_digest, &[])?
-            .0)
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SigningKey").finish_non_exhaustive()
     }
 }
 
-#[cfg(feature = "verify")]
-#[cfg_attr(docsrs, doc(cfg(feature = "verify")))]
-impl<C> KeypairRef for SigningKey<C>
+impl<C> Drop for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    type VerifyingKey = VerifyingKey<C>;
+    fn drop(&mut self) {
+        self.secret_scalar.zeroize();
+    }
 }
 
-impl<C> PrehashSigner<Signature<C>> for SigningKey<C>
+/// Constant-time comparison
+impl<C> Eq for SigningKey<C>
 where
-    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
-    C::Digest: FixedOutput<OutputSize = FieldSize<C>>,
-    C::UInt: for<'a> From<&'a Scalar<C>>,
+    C: PrimeCurve + ProjectiveArithmetic,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn sign_prehash(&self, prehash: &[u8]) -> Result<Signature<C>> {
-        let prehash = C::prehash_to_field_bytes(prehash)?;
+}
 
-        Ok(self
-            .secret_scalar
-            .try_sign_prehashed_rfc6979::<C::Digest>(prehash, &[])?
-            .0)
+/// Constant-time comparison
+impl<C> PartialEq for SigningKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic,
+    Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
+    SignatureSize<C>: ArrayLength<u8>,
+{
+    fn eq(&self, other: &SigningKey<C>) -> bool {
+        self.ct_eq(other).into()
     }
 }
 
-impl<C> Signer<Signature<C>> for SigningKey<C>
+impl<C> From<NonZeroScalar<C>> for SigningKey<C>
 where
-    Self: DigestSigner<C::Digest, Signature<C>>,
-    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
+    C: PrimeCurve + ProjectiveArithmetic,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn try_sign(&self, msg: &[u8]) -> Result<Signature<C>> {
-        self.try_sign_digest(C::Digest::new_with_prefix(msg))
+    fn from(secret_scalar: NonZeroScalar<C>) -> Self {
+        #[cfg(feature = "verify")]
+        let public_key = PublicKey::from_secret_scalar(&secret_scalar);
+
+        Self {
+            secret_scalar,
+            #[cfg(feature = "verify")]
+            verifying_key: public_key.into(),
+        }
     }
 }
 
-impl<C, D> RandomizedDigestSigner<D, Signature<C>> for SigningKey<C>
+impl<C> From<SecretKey<C>> for SigningKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
-    C::UInt: for<'a> From<&'a Scalar<C>>,
-    D: Digest + BlockSizeUser + FixedOutput<OutputSize = FieldSize<C>> + FixedOutputReset,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    /// Sign message prehash using an ephemeral scalar (`k`) derived according
-    /// to a variant of RFC 6979 (Section 3.6) which supplies additional
-    /// entropy from an RNG.
-    fn try_sign_digest_with_rng(
-        &self,
-        mut rng: impl CryptoRng + RngCore,
-        msg_digest: D,
-    ) -> Result<Signature<C>> {
-        let mut ad = FieldBytes::<C>::default();
-        rng.fill_bytes(&mut ad);
-        Ok(self
-            .secret_scalar
-            .try_sign_digest_rfc6979::<D>(msg_digest, &ad)?
-            .0)
+    fn from(secret_key: SecretKey<C>) -> Self {
+        Self::from(&secret_key)
     }
 }
 
-impl<C> RandomizedSigner<Signature<C>> for SigningKey<C>
+impl<C> From<&SecretKey<C>> for SigningKey<C>
 where
-    Self: RandomizedDigestSigner<C::Digest, Signature<C>>,
-    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
+    C: PrimeCurve + ProjectiveArithmetic,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn try_sign_with_rng(&self, rng: impl CryptoRng + RngCore, msg: &[u8]) -> Result<Signature<C>> {
-        self.try_sign_digest_with_rng(rng, C::Digest::new_with_prefix(msg))
+    fn from(secret_key: &SecretKey<C>) -> Self {
+        secret_key.to_nonzero_scalar().into()
     }
 }
 
-impl<C> From<NonZeroScalar<C>> for SigningKey<C>
+impl<C> From<SigningKey<C>> for SecretKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    fn from(secret_scalar: NonZeroScalar<C>) -> Self {
-        #[cfg(feature = "verify")]
-        let public_key = PublicKey::from_secret_scalar(&secret_scalar);
+    fn from(key: SigningKey<C>) -> Self {
+        key.secret_scalar.into()
+    }
+}
 
-        Self {
-            secret_scalar,
-            #[cfg(feature = "verify")]
-            verifying_key: public_key.into(),
-        }
+impl<C> From<&SigningKey<C>> for SecretKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic,
+    Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
+    SignatureSize<C>: ArrayLength<u8>,
+{
+    fn from(secret_key: &SigningKey<C>) -> Self {
+        secret_key.secret_scalar.into()
     }
 }
 
@@ -349,6 +416,14 @@ where
     }
 }
 
+impl<C> ZeroizeOnDrop for SigningKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic,
+    Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
+    SignatureSize<C>: ArrayLength<u8>,
+{
+}
+
 #[cfg(feature = "verify")]
 impl<C> From<SigningKey<C>> for VerifyingKey<C>
 where
@@ -373,6 +448,17 @@ where
     }
 }
 
+#[cfg(feature = "verify")]
+#[cfg_attr(docsrs, doc(cfg(feature = "verify")))]
+impl<C> KeypairRef for SigningKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic,
+    Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
+    SignatureSize<C>: ArrayLength<u8>,
+{
+    type VerifyingKey = VerifyingKey<C>;
+}
+
 #[cfg(feature = "pkcs8")]
 #[cfg_attr(docsrs, doc(cfg(feature = "pkcs8")))]
 impl<C> TryFrom<pkcs8::PrivateKeyInfo<'_>> for SigningKey<C>
@@ -405,9 +491,9 @@ where
     }
 }
 
-#[cfg(feature = "pkcs8")]
-#[cfg_attr(docsrs, doc(cfg(feature = "pkcs8")))]
-impl<C> DecodePrivateKey for SigningKey<C>
+#[cfg(feature = "pem")]
+#[cfg_attr(docsrs, doc(cfg(feature = "pem")))]
+impl<C> FromStr for SigningKey<C>
 where
     C: PrimeCurve + AssociatedOid + ProjectiveArithmetic,
     AffinePoint<C>: FromEncodedPoint<C> + ToEncodedPoint<C>,
@@ -415,11 +501,16 @@ where
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        Self::from_pkcs8_pem(s).map_err(|_| Error::new())
+    }
 }
 
-#[cfg(feature = "pem")]
-#[cfg_attr(docsrs, doc(cfg(feature = "pem")))]
-impl<C> FromStr for SigningKey<C>
+#[cfg(feature = "pkcs8")]
+#[cfg_attr(docsrs, doc(cfg(feature = "pkcs8")))]
+impl<C> DecodePrivateKey for SigningKey<C>
 where
     C: PrimeCurve + AssociatedOid + ProjectiveArithmetic,
     AffinePoint<C>: FromEncodedPoint<C> + ToEncodedPoint<C>,
@@ -427,9 +518,4 @@ where
     Scalar<C>: Invert<Output = CtOption<Scalar<C>>> + Reduce<C::UInt> + SignPrimitive<C>,
     SignatureSize<C>: ArrayLength<u8>,
 {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self> {
-        Self::from_pkcs8_pem(s).map_err(|_| Error::new())
-    }
 }
diff --git a/ecdsa/src/verify.rs b/ecdsa/src/verify.rs
index 5aa8bcb8..a3f4015e 100644
--- a/ecdsa/src/verify.rs
+++ b/ecdsa/src/verify.rs
@@ -17,6 +17,9 @@ use signature::{
     DigestVerifier, Verifier,
 };
 
+#[cfg(feature = "der")]
+use {crate::der, core::ops::Add};
+
 #[cfg(feature = "pkcs8")]
 use elliptic_curve::pkcs8::{self, AssociatedOid, DecodePublicKey};
 
@@ -94,18 +97,9 @@ where
     }
 }
 
-impl<C> AsRef<AffinePoint<C>> for VerifyingKey<C>
-where
-    C: PrimeCurve + ProjectiveArithmetic,
-    AffinePoint<C>: FromEncodedPoint<C> + ToEncodedPoint<C>,
-    FieldSize<C>: sec1::ModulusSize,
-{
-    fn as_ref(&self) -> &AffinePoint<C> {
-        self.as_affine()
-    }
-}
-
-impl<C> Copy for VerifyingKey<C> where C: PrimeCurve + ProjectiveArithmetic {}
+//
+// `*Verifier` trait impls
+//
 
 impl<C, D> DigestVerifier<D, Signature<C>> for VerifyingKey<C>
 where
@@ -146,6 +140,76 @@ where
     }
 }
 
+#[cfg(feature = "der")]
+#[cfg_attr(docsrs, doc(cfg(feature = "der")))]
+impl<C, D> DigestVerifier<D, der::Signature<C>> for VerifyingKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic,
+    D: Digest + FixedOutput<OutputSize = FieldSize<C>>,
+    AffinePoint<C>: VerifyPrimitive<C>,
+    Scalar<C>: Reduce<C::UInt>,
+    SignatureSize<C>: ArrayLength<u8>,
+    der::MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<der::MaxOverhead> + ArrayLength<u8>,
+{
+    fn verify_digest(&self, msg_digest: D, signature: &der::Signature<C>) -> Result<()> {
+        let signature = Signature::<C>::try_from(signature.clone())?;
+        DigestVerifier::<D, Signature<C>>::verify_digest(self, msg_digest, &signature)
+    }
+}
+
+#[cfg(feature = "der")]
+#[cfg_attr(docsrs, doc(cfg(feature = "der")))]
+impl<C> PrehashVerifier<der::Signature<C>> for VerifyingKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
+    AffinePoint<C>: VerifyPrimitive<C>,
+    Scalar<C>: Reduce<C::UInt>,
+    SignatureSize<C>: ArrayLength<u8>,
+    der::MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<der::MaxOverhead> + ArrayLength<u8>,
+{
+    fn verify_prehash(&self, prehash: &[u8], signature: &der::Signature<C>) -> Result<()> {
+        let signature = Signature::<C>::try_from(signature.clone())?;
+        PrehashVerifier::<Signature<C>>::verify_prehash(self, prehash, &signature)
+    }
+}
+
+#[cfg(feature = "der")]
+#[cfg_attr(docsrs, doc(cfg(feature = "der")))]
+impl<C> Verifier<der::Signature<C>> for VerifyingKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic + DigestPrimitive,
+    C::Digest: FixedOutput<OutputSize = FieldSize<C>>,
+    AffinePoint<C>: VerifyPrimitive<C>,
+    Scalar<C>: Reduce<C::UInt>,
+    SignatureSize<C>: ArrayLength<u8>,
+    der::MaxSize<C>: ArrayLength<u8>,
+    <FieldSize<C> as Add>::Output: Add<der::MaxOverhead> + ArrayLength<u8>,
+{
+    fn verify(&self, msg: &[u8], signature: &der::Signature<C>) -> Result<()> {
+        let signature = Signature::<C>::try_from(signature.clone())?;
+        Verifier::<Signature<C>>::verify(self, msg, &signature)
+    }
+}
+
+//
+// Other trait impls
+//
+
+impl<C> AsRef<AffinePoint<C>> for VerifyingKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic,
+    AffinePoint<C>: FromEncodedPoint<C> + ToEncodedPoint<C>,
+    FieldSize<C>: sec1::ModulusSize,
+{
+    fn as_ref(&self) -> &AffinePoint<C> {
+        self.as_affine()
+    }
+}
+
+impl<C> Copy for VerifyingKey<C> where C: PrimeCurve + ProjectiveArithmetic {}
+
 impl<C> From<&VerifyingKey<C>> for EncodedPoint<C>
 where
     C: PrimeCurve + ProjectiveArithmetic + PointCompression,
@@ -157,6 +221,17 @@ where
     }
 }
 
+impl<C> Eq for VerifyingKey<C> where C: PrimeCurve + ProjectiveArithmetic {}
+
+impl<C> PartialEq for VerifyingKey<C>
+where
+    C: PrimeCurve + ProjectiveArithmetic,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.eq(&other.inner)
+    }
+}
+
 impl<C> From<PublicKey<C>> for VerifyingKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,
@@ -193,17 +268,6 @@ where
     }
 }
 
-impl<C> Eq for VerifyingKey<C> where C: PrimeCurve + ProjectiveArithmetic {}
-
-impl<C> PartialEq for VerifyingKey<C>
-where
-    C: PrimeCurve + ProjectiveArithmetic,
-{
-    fn eq(&self, other: &Self) -> bool {
-        self.inner.eq(&other.inner)
-    }
-}
-
 impl<C> PartialOrd for VerifyingKey<C>
 where
     C: PrimeCurve + ProjectiveArithmetic,