diff --git a/dsa/examples/export.rs b/dsa/examples/export.rs
index 7e9face..03fa5fb 100644
--- a/dsa/examples/export.rs
+++ b/dsa/examples/export.rs
@@ -1,21 +1,21 @@
-use dsa::{consts::DSA_2048_256, Components, PrivateKey};
+use dsa::{consts::DSA_2048_256, Components, SigningKey};
 use pkcs8::{EncodePrivateKey, EncodePublicKey, LineEnding};
 use std::{fs::File, io::Write};
 
 fn main() {
     let mut rng = rand::thread_rng();
     let components = Components::generate(&mut rng, DSA_2048_256);
-    let private_key = PrivateKey::generate(&mut rng, components);
-    let public_key = private_key.public_key();
+    let signing_key = SigningKey::generate(&mut rng, components);
+    let verifying_key = signing_key.verifying_key();
 
-    let private_key_bytes = private_key.to_pkcs8_pem(LineEnding::LF).unwrap();
-    let public_key_bytes = public_key.to_public_key_pem(LineEnding::LF).unwrap();
+    let signing_key_bytes = signing_key.to_pkcs8_pem(LineEnding::LF).unwrap();
+    let verifying_key_bytes = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
 
     let mut file = File::create("public.pem").unwrap();
-    file.write_all(public_key_bytes.as_bytes()).unwrap();
+    file.write_all(verifying_key_bytes.as_bytes()).unwrap();
     file.flush().unwrap();
 
     let mut file = File::create("private.pem").unwrap();
-    file.write_all(private_key_bytes.as_bytes()).unwrap();
+    file.write_all(signing_key_bytes.as_bytes()).unwrap();
     file.flush().unwrap();
 }
diff --git a/dsa/examples/generate.rs b/dsa/examples/generate.rs
index 03b47d0..744da91 100644
--- a/dsa/examples/generate.rs
+++ b/dsa/examples/generate.rs
@@ -1,8 +1,8 @@
-use dsa::{consts::DSA_2048_256, Components, PrivateKey};
+use dsa::{consts::DSA_2048_256, Components, SigningKey};
 
 fn main() {
     let mut rng = rand::thread_rng();
     let components = Components::generate(&mut rng, DSA_2048_256);
-    let private_key = PrivateKey::generate(&mut rng, components);
-    let _public_key = private_key.public_key();
+    let signing_key = SigningKey::generate(&mut rng, components);
+    let _verifying_key = signing_key.verifying_key();
 }
diff --git a/dsa/examples/sign.rs b/dsa/examples/sign.rs
index 27c3853..f0e80f1 100644
--- a/dsa/examples/sign.rs
+++ b/dsa/examples/sign.rs
@@ -1,5 +1,5 @@
 use digest::Digest;
-use dsa::{consts::DSA_2048_256, Components, PrivateKey};
+use dsa::{consts::DSA_2048_256, Components, SigningKey};
 use pkcs8::{EncodePrivateKey, EncodePublicKey, LineEnding};
 use sha1::Sha1;
 use signature::{RandomizedDigestSigner, Signature};
@@ -8,17 +8,17 @@ use std::{fs::File, io::Write};
 fn main() {
     let mut rng = rand::thread_rng();
     let components = Components::generate(&mut rng, DSA_2048_256);
-    let private_key = PrivateKey::generate(&mut rng, components);
-    let public_key = private_key.public_key();
+    let signing_key = SigningKey::generate(&mut rng, components);
+    let verifying_key = signing_key.verifying_key();
 
-    let signature = private_key
+    let signature = signing_key
         .sign_digest_with_rng(rand::thread_rng(), Sha1::new().chain_update(b"hello world"));
 
-    let private_key_bytes = private_key.to_pkcs8_pem(LineEnding::LF).unwrap();
-    let public_key_bytes = public_key.to_public_key_pem(LineEnding::LF).unwrap();
+    let signing_key_bytes = signing_key.to_pkcs8_pem(LineEnding::LF).unwrap();
+    let verifying_key_bytes = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
 
     let mut file = File::create("public.pem").unwrap();
-    file.write_all(public_key_bytes.as_bytes()).unwrap();
+    file.write_all(verifying_key_bytes.as_bytes()).unwrap();
     file.flush().unwrap();
 
     let mut file = File::create("signature.der").unwrap();
@@ -26,6 +26,6 @@ fn main() {
     file.flush().unwrap();
 
     let mut file = File::create("private.pem").unwrap();
-    file.write_all(private_key_bytes.as_bytes()).unwrap();
+    file.write_all(signing_key_bytes.as_bytes()).unwrap();
     file.flush().unwrap();
 }
diff --git a/dsa/src/generate/keypair.rs b/dsa/src/generate/keypair.rs
index 7587545..79b77c9 100644
--- a/dsa/src/generate/keypair.rs
+++ b/dsa/src/generate/keypair.rs
@@ -2,20 +2,20 @@
 //! Generate a DSA keypair
 //!
 
-use crate::{generate::components, Components, PrivateKey, PublicKey};
+use crate::{generate::components, Components, SigningKey, VerifyingKey};
 use num_bigint::{BigUint, RandBigInt};
 use num_traits::One;
 use rand::{CryptoRng, RngCore};
 
 /// Generate a new keypair
 #[inline]
-pub fn keypair<R>(rng: &mut R, components: Components) -> PrivateKey
+pub fn keypair<R>(rng: &mut R, components: Components) -> SigningKey
 where
     R: CryptoRng + RngCore + ?Sized,
 {
     let x = rng.gen_biguint_range(&BigUint::one(), components.q());
     let y = components::public(&components, &x);
 
-    let public_key = PublicKey::from_components(components, y);
-    PrivateKey::from_components(public_key, x)
+    let verifying_key = VerifyingKey::from_components(components, y);
+    SigningKey::from_components(verifying_key, x)
 }
diff --git a/dsa/src/generate/secret_number.rs b/dsa/src/generate/secret_number.rs
index 8a35855..04838c9 100644
--- a/dsa/src/generate/secret_number.rs
+++ b/dsa/src/generate/secret_number.rs
@@ -2,7 +2,7 @@
 //! Generate a per-message secret number
 //!
 
-use crate::{Components, PrivateKey};
+use crate::{Components, SigningKey};
 use alloc::{vec, vec::Vec};
 use core::cmp::min;
 use digest::{
@@ -42,7 +42,7 @@ fn reduce_hash(q: &BigUint, hash: &[u8]) -> Vec<u8> {
 ///
 /// Secret number k and its modular multiplicative inverse with q
 #[inline]
-pub fn secret_number_rfc6979<D>(private_key: &PrivateKey, hash: &[u8]) -> (BigUint, BigUint)
+pub fn secret_number_rfc6979<D>(signing_key: &SigningKey, hash: &[u8]) -> (BigUint, BigUint)
 where
     D: CoreProxy + FixedOutput,
     D::Core: BlockSizeUser
@@ -55,11 +55,11 @@ where
     <D::Core as BlockSizeUser>::BlockSize: IsLess<U256>,
     Le<<D::Core as BlockSizeUser>::BlockSize, U256>: NonZero,
 {
-    let q = private_key.public_key().components().q();
+    let q = signing_key.verifying_key().components().q();
     let k_size = q.bits() / 8;
     let hash = reduce_hash(q, hash);
 
-    let mut x_bytes = private_key.x().to_bytes_be();
+    let mut x_bytes = signing_key.x().to_bytes_be();
     let mut hmac = HmacDrbg::<D>::new(&x_bytes, &hash, &[]);
     x_bytes.zeroize();
 
diff --git a/dsa/src/lib.rs b/dsa/src/lib.rs
index 8b329ca..6212942 100644
--- a/dsa/src/lib.rs
+++ b/dsa/src/lib.rs
@@ -11,17 +11,17 @@
 //! Generate a DSA keypair
 //!
 //! ```
-//! # use dsa::{consts::DSA_2048_256, Components, PrivateKey};
+//! # use dsa::{consts::DSA_2048_256, Components, SigningKey};
 //! let mut csprng = rand::thread_rng();
 //! let components = Components::generate(&mut csprng, DSA_2048_256);
-//! let private_key = PrivateKey::generate(&mut csprng, components);
-//! let public_key = private_key.public_key();
+//! let signing_key = SigningKey::generate(&mut csprng, components);
+//! let verifying_key = signing_key.verifying_key();
 //! ```
 //!
 //! Create keypair from existing components
 //!
 //! ```
-//! # use dsa::{Components, PrivateKey, PublicKey};
+//! # use dsa::{Components, SigningKey, VerifyingKey};
 //! # use num_bigint::BigUint;
 //! # use num_traits::One;
 //! # let read_common_parameters = || (BigUint::one(), BigUint::one(), BigUint::one());
@@ -31,10 +31,10 @@
 //! let components = Components::from_components(p, q, g);
 //!
 //! let x = read_public_component();
-//! let public_key = PublicKey::from_components(components, x);
+//! let verifying_key = VerifyingKey::from_components(components, x);
 //!
 //! let y = read_private_component();
-//! let private_key = PrivateKey::from_components(public_key, y);
+//! let signing_key = SigningKey::from_components(verifying_key, y);
 //! ```
 //!
 
@@ -43,10 +43,9 @@ extern crate alloc;
 /// DSA object identifier as defined by RFC-3279, section 2.3.2
 const DSA_OID: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.10040.4.1");
 
-pub use self::components::Components;
-pub use self::private_key::PrivateKey;
-pub use self::public_key::PublicKey;
-pub use self::sig::Signature;
+pub use crate::{
+    components::Components, sig::Signature, signing_key::SigningKey, verifying_key::VerifyingKey,
+};
 
 pub use pkcs8;
 pub use signature;
@@ -58,9 +57,9 @@ use pkcs8::spki::ObjectIdentifier;
 
 mod components;
 mod generate;
-mod private_key;
-mod public_key;
 mod sig;
+mod signing_key;
+mod verifying_key;
 
 /// Returns a `BigUint` with the value 2
 #[inline]
diff --git a/dsa/src/private_key.rs b/dsa/src/signing_key.rs
similarity index 77%
rename from dsa/src/private_key.rs
rename to dsa/src/signing_key.rs
index 65cabde..a1c3c04 100644
--- a/dsa/src/private_key.rs
+++ b/dsa/src/signing_key.rs
@@ -2,7 +2,7 @@
 //! Module containing the definition of the private key container
 //!
 
-use crate::{sig::Signature, Components, PublicKey, DSA_OID};
+use crate::{sig::Signature, Components, VerifyingKey, DSA_OID};
 use core::cmp::min;
 use digest::{
     block_buffer::Eager,
@@ -21,29 +21,29 @@ use rand::{CryptoRng, RngCore};
 use signature::{DigestSigner, RandomizedDigestSigner};
 use zeroize::Zeroizing;
 
-/// DSA private key
+/// DSA private key.
 ///
 /// The [`(try_)sign_digest_with_rng`](::signature::RandomizedDigestSigner) API uses regular non-deterministic signatures,
 /// while the [`(try_)sign_digest`](::signature::DigestSigner) API uses deterministic signatures as described in RFC 6979
 #[derive(Clone, PartialEq)]
 #[must_use]
-pub struct PrivateKey {
+pub struct SigningKey {
     /// Public key
-    public_key: PublicKey,
+    verifying_key: VerifyingKey,
 
     /// Private component x
     x: Zeroizing<BigUint>,
 }
 
-opaque_debug::implement!(PrivateKey);
+opaque_debug::implement!(SigningKey);
 
-impl PrivateKey {
+impl SigningKey {
     /// Construct a new private key from the public key and private component
     ///
     /// These values are not getting verified for validity
-    pub fn from_components(public_key: PublicKey, x: BigUint) -> Self {
+    pub fn from_components(verifying_key: VerifyingKey, x: BigUint) -> Self {
         Self {
-            public_key,
+            verifying_key,
             x: Zeroizing::new(x),
         }
     }
@@ -53,13 +53,13 @@ impl PrivateKey {
     pub fn generate<R: CryptoRng + RngCore + ?Sized>(
         rng: &mut R,
         components: Components,
-    ) -> PrivateKey {
+    ) -> SigningKey {
         crate::generate::keypair(rng, components)
     }
 
     /// DSA public key
-    pub const fn public_key(&self) -> &PublicKey {
-        &self.public_key
+    pub const fn verifying_key(&self) -> &VerifyingKey {
+        &self.verifying_key
     }
 
     /// DSA private component
@@ -73,11 +73,11 @@ impl PrivateKey {
     /// Check whether the private key is valid
     #[must_use]
     pub fn is_valid(&self) -> bool {
-        if !self.public_key().is_valid() {
+        if !self.verifying_key().is_valid() {
             return false;
         }
 
-        *self.x() >= BigUint::one() && self.x() < self.public_key().components().q()
+        *self.x() >= BigUint::one() && self.x() < self.verifying_key().components().q()
     }
 
     /// Sign some pre-hashed data
@@ -87,7 +87,7 @@ impl PrivateKey {
             return None;
         }
 
-        let components = self.public_key().components();
+        let components = self.verifying_key().components();
         let (p, q, g) = (components.p(), components.q(), components.g());
         let x = self.x();
 
@@ -105,7 +105,7 @@ impl PrivateKey {
     }
 }
 
-impl<D> DigestSigner<D, Signature> for PrivateKey
+impl<D> DigestSigner<D, Signature> for SigningKey
 where
     D: Digest + CoreProxy + FixedOutput,
     D::Core: BlockSizeUser
@@ -127,7 +127,7 @@ where
     }
 }
 
-impl<D> RandomizedDigestSigner<D, Signature> for PrivateKey
+impl<D> RandomizedDigestSigner<D, Signature> for SigningKey
 where
     D: Digest,
 {
@@ -136,7 +136,7 @@ where
         mut rng: impl CryptoRng + RngCore,
         digest: D,
     ) -> Result<Signature, signature::Error> {
-        let ks = crate::generate::secret_number(&mut rng, self.public_key().components())
+        let ks = crate::generate::secret_number(&mut rng, self.verifying_key().components())
             .ok_or_else(signature::Error::new)?;
         let hash = digest.finalize();
 
@@ -145,9 +145,9 @@ where
     }
 }
 
-impl EncodePrivateKey for PrivateKey {
+impl EncodePrivateKey for SigningKey {
     fn to_pkcs8_der(&self) -> pkcs8::Result<SecretDocument> {
-        let parameters = self.public_key().components().to_vec()?;
+        let parameters = self.verifying_key().components().to_vec()?;
         let parameters = AnyRef::from_der(&parameters)?;
         let algorithm = AlgorithmIdentifier {
             oid: DSA_OID,
@@ -156,14 +156,14 @@ impl EncodePrivateKey for PrivateKey {
 
         let x_bytes = self.x.to_bytes_be();
         let x = UIntRef::new(&x_bytes)?;
-        let private_key = x.to_vec()?;
+        let signing_key = x.to_vec()?;
 
-        let private_key_info = PrivateKeyInfo::new(algorithm, &private_key);
-        private_key_info.try_into()
+        let signing_key_info = PrivateKeyInfo::new(algorithm, &signing_key);
+        signing_key_info.try_into()
     }
 }
 
-impl<'a> TryFrom<PrivateKeyInfo<'a>> for PrivateKey {
+impl<'a> TryFrom<PrivateKeyInfo<'a>> for SigningKey {
     type Error = pkcs8::Error;
 
     fn try_from(value: PrivateKeyInfo<'a>) -> Result<Self, Self::Error> {
@@ -186,15 +186,15 @@ impl<'a> TryFrom<PrivateKeyInfo<'a>> for PrivateKey {
             crate::generate::public_component(&components, &x)
         };
 
-        let public_key = PublicKey::from_components(components, y);
-        let private_key = PrivateKey::from_components(public_key, x);
+        let verifying_key = VerifyingKey::from_components(components, y);
+        let signing_key = SigningKey::from_components(verifying_key, x);
 
-        if !private_key.is_valid() {
+        if !signing_key.is_valid() {
             return Err(pkcs8::Error::KeyMalformed);
         }
 
-        Ok(private_key)
+        Ok(signing_key)
     }
 }
 
-impl DecodePrivateKey for PrivateKey {}
+impl DecodePrivateKey for SigningKey {}
diff --git a/dsa/src/public_key.rs b/dsa/src/verifying_key.rs
similarity index 90%
rename from dsa/src/public_key.rs
rename to dsa/src/verifying_key.rs
index 537bc72..45fb66b 100644
--- a/dsa/src/public_key.rs
+++ b/dsa/src/verifying_key.rs
@@ -13,10 +13,10 @@ use pkcs8::{
 };
 use signature::DigestVerifier;
 
-/// DSA public key
+/// DSA public key.
 #[derive(Clone, PartialEq, PartialOrd)]
 #[must_use]
-pub struct PublicKey {
+pub struct VerifyingKey {
     /// common components
     components: Components,
 
@@ -24,9 +24,9 @@ pub struct PublicKey {
     y: BigUint,
 }
 
-opaque_debug::implement!(PublicKey);
+opaque_debug::implement!(VerifyingKey);
 
-impl PublicKey {
+impl VerifyingKey {
     /// Construct a new public key from the common components and the public component
     ///
     /// These values are not getting verified for validity
@@ -85,7 +85,7 @@ impl PublicKey {
     }
 }
 
-impl<D> DigestVerifier<D, Signature> for PublicKey
+impl<D> DigestVerifier<D, Signature> for VerifyingKey
 where
     D: Digest,
 {
@@ -104,7 +104,7 @@ where
     }
 }
 
-impl EncodePublicKey for PublicKey {
+impl EncodePublicKey for VerifyingKey {
     fn to_public_key_der(&self) -> spki::Result<spki::Document> {
         let parameters = self.components.to_vec()?;
         let parameters = AnyRef::from_der(&parameters)?;
@@ -117,16 +117,15 @@ impl EncodePublicKey for PublicKey {
         let y = UIntRef::new(&y_bytes)?;
         let public_key = y.to_vec()?;
 
-        let public_key_info = SubjectPublicKeyInfo {
+        SubjectPublicKeyInfo {
             algorithm,
             subject_public_key: &public_key,
-        };
-
-        public_key_info.try_into()
+        }
+        .try_into()
     }
 }
 
-impl<'a> TryFrom<SubjectPublicKeyInfo<'a>> for PublicKey {
+impl<'a> TryFrom<SubjectPublicKeyInfo<'a>> for VerifyingKey {
     type Error = spki::Error;
 
     fn try_from(value: SubjectPublicKeyInfo<'a>) -> Result<Self, Self::Error> {
@@ -142,4 +141,4 @@ impl<'a> TryFrom<SubjectPublicKeyInfo<'a>> for PublicKey {
     }
 }
 
-impl DecodePublicKey for PublicKey {}
+impl DecodePublicKey for VerifyingKey {}
diff --git a/dsa/tests/deterministic.rs b/dsa/tests/deterministic.rs
index 1b21d4d..8143bb8 100644
--- a/dsa/tests/deterministic.rs
+++ b/dsa/tests/deterministic.rs
@@ -5,7 +5,7 @@ use digest::{
     typenum::{IsLess, Le, NonZero},
     Digest, FixedOutput, HashMarker, OutputSizeUser,
 };
-use dsa::{Components, PrivateKey, PublicKey, Signature};
+use dsa::{Components, Signature, SigningKey, VerifyingKey};
 use num_bigint::BigUint;
 use num_traits::Num;
 use sha1::Sha1;
@@ -15,7 +15,7 @@ use signature::DigestSigner;
 const MESSAGE: &[u8] = b"sample";
 const MESSAGE_2: &[u8] = b"test";
 
-fn dsa_1024_private_key() -> PrivateKey {
+fn dsa_1024_signing_key() -> SigningKey {
     let p = BigUint::from_str_radix(
         "86F5CA03DCFEB225063FF830A0C769B9DD9D6153AD91D7CE27F787C43278B447\
                 E6533B86B18BED6E8A48B784A14C252C5BE0DBF60B86D6385BD2F12FB763ED88\
@@ -45,12 +45,12 @@ fn dsa_1024_private_key() -> PrivateKey {
     .unwrap();
 
     let components = Components::from_components(p, q, g);
-    let public_key = PublicKey::from_components(components, y);
+    let verifying_key = VerifyingKey::from_components(components, y);
 
-    PrivateKey::from_components(public_key, x)
+    SigningKey::from_components(verifying_key, x)
 }
 
-fn dsa_2048_private_key() -> PrivateKey {
+fn dsa_2048_signing_key() -> SigningKey {
     let p = BigUint::from_str_radix(
         "9DB6FB5951B66BB6FE1E140F1D2CE5502374161FD6538DF1648218642F0B5C48\
         C8F7A41AADFA187324B87674FA1822B00F1ECF8136943D7C55757264E5A1A44F\
@@ -100,13 +100,13 @@ fn dsa_2048_private_key() -> PrivateKey {
     .unwrap();
 
     let components = Components::from_components(p, q, g);
-    let public_key = PublicKey::from_components(components, y);
+    let verifying_key = VerifyingKey::from_components(components, y);
 
-    PrivateKey::from_components(public_key, x)
+    SigningKey::from_components(verifying_key, x)
 }
 
 /// Generate a signature given the unhashed message and a private key
-fn generate_signature<D>(private_key: PrivateKey, data: &[u8]) -> Signature
+fn generate_signature<D>(signing_key: SigningKey, data: &[u8]) -> Signature
 where
     D: Digest + CoreProxy + FixedOutput,
     D::Core: BlockSizeUser
@@ -119,7 +119,7 @@ where
     <D::Core as BlockSizeUser>::BlockSize: IsLess<U256>,
     Le<<D::Core as BlockSizeUser>::BlockSize, U256>: NonZero,
 {
-    private_key.sign_digest(<D as Digest>::new().chain_update(data))
+    signing_key.sign_digest(<D as Digest>::new().chain_update(data))
 }
 
 /// Generate a signature using the 1024-bit DSA key
@@ -136,7 +136,7 @@ where
     <D::Core as BlockSizeUser>::BlockSize: IsLess<U256>,
     Le<<D::Core as BlockSizeUser>::BlockSize, U256>: NonZero,
 {
-    generate_signature::<D>(dsa_1024_private_key(), data)
+    generate_signature::<D>(dsa_1024_signing_key(), data)
 }
 
 /// Generate a signature using the 2048-bit DSA key
@@ -153,7 +153,7 @@ where
     <D::Core as BlockSizeUser>::BlockSize: IsLess<U256>,
     Le<<D::Core as BlockSizeUser>::BlockSize, U256>: NonZero,
 {
-    generate_signature::<D>(dsa_2048_private_key(), data)
+    generate_signature::<D>(dsa_2048_signing_key(), data)
 }
 
 /// Create a signature container from the two components in their textual hexadecimal form
diff --git a/dsa/tests/private_key.rs b/dsa/tests/private_key.rs
index 837c244..d8803a5 100644
--- a/dsa/tests/private_key.rs
+++ b/dsa/tests/private_key.rs
@@ -3,7 +3,7 @@
 #![allow(deprecated)]
 
 use digest::Digest;
-use dsa::{consts::DSA_1024_160, Components, PrivateKey};
+use dsa::{consts::DSA_1024_160, Components, SigningKey};
 use num_bigint::BigUint;
 use num_traits::Zero;
 use pkcs8::{DecodePrivateKey, EncodePrivateKey, LineEnding};
@@ -12,61 +12,61 @@ use signature::{DigestVerifier, RandomizedDigestSigner};
 
 const OPENSSL_PEM_PRIVATE_KEY: &str = include_str!("pems/private.pem");
 
-fn generate_keypair() -> PrivateKey {
+fn generate_keypair() -> SigningKey {
     let mut rng = rand::thread_rng();
     let components = Components::generate(&mut rng, DSA_1024_160);
-    PrivateKey::generate(&mut rng, components)
+    SigningKey::generate(&mut rng, components)
 }
 
 #[test]
-fn decode_encode_openssl_private_key() {
-    let private_key = PrivateKey::from_pkcs8_pem(OPENSSL_PEM_PRIVATE_KEY)
+fn decode_encode_openssl_signing_key() {
+    let signing_key = SigningKey::from_pkcs8_pem(OPENSSL_PEM_PRIVATE_KEY)
         .expect("Failed to decode PEM encoded OpenSSL key");
-    assert!(private_key.is_valid());
+    assert!(signing_key.is_valid());
 
-    let reencoded_private_key = private_key
+    let reencoded_signing_key = signing_key
         .to_pkcs8_pem(LineEnding::LF)
         .expect("Failed to encode private key into PEM representation");
 
-    assert_eq!(*reencoded_private_key, OPENSSL_PEM_PRIVATE_KEY);
+    assert_eq!(*reencoded_signing_key, OPENSSL_PEM_PRIVATE_KEY);
 }
 
 #[test]
-fn encode_decode_private_key() {
-    let private_key = generate_keypair();
-    let encoded_private_key = private_key.to_pkcs8_pem(LineEnding::LF).unwrap();
-    let decoded_private_key = PrivateKey::from_pkcs8_pem(&encoded_private_key).unwrap();
+fn encode_decode_signing_key() {
+    let signing_key = generate_keypair();
+    let encoded_signing_key = signing_key.to_pkcs8_pem(LineEnding::LF).unwrap();
+    let decoded_signing_key = SigningKey::from_pkcs8_pem(&encoded_signing_key).unwrap();
 
-    assert_eq!(private_key, decoded_private_key);
+    assert_eq!(signing_key, decoded_signing_key);
 }
 
 #[test]
 fn sign_and_verify() {
     const DATA: &[u8] = b"SIGN AND VERIFY THOSE BYTES";
 
-    let private_key = generate_keypair();
-    let public_key = private_key.public_key();
+    let signing_key = generate_keypair();
+    let verifying_key = signing_key.verifying_key();
 
     let signature =
-        private_key.sign_digest_with_rng(rand::thread_rng(), Sha1::new().chain_update(DATA));
+        signing_key.sign_digest_with_rng(rand::thread_rng(), Sha1::new().chain_update(DATA));
 
-    assert!(public_key
+    assert!(verifying_key
         .verify_digest(Sha1::new().chain_update(DATA), &signature)
         .is_ok());
 }
 
 #[test]
 fn verify_validity() {
-    let private_key = generate_keypair();
-    let components = private_key.public_key().components();
+    let signing_key = generate_keypair();
+    let components = signing_key.verifying_key().components();
 
     assert!(
-        BigUint::zero() < *private_key.x() && private_key.x() < components.q(),
+        BigUint::zero() < *signing_key.x() && signing_key.x() < components.q(),
         "Requirement 0<x<q not met"
     );
     assert_eq!(
-        *private_key.public_key().y(),
-        components.g().modpow(private_key.x(), components.p()),
+        *signing_key.verifying_key().y(),
+        components.g().modpow(signing_key.x(), components.p()),
         "Requirement y=(g^x)%p not met"
     );
 }
diff --git a/dsa/tests/public_key.rs b/dsa/tests/public_key.rs
index 5a9ad41..293436b 100644
--- a/dsa/tests/public_key.rs
+++ b/dsa/tests/public_key.rs
@@ -2,49 +2,49 @@
 // But we want to use those small key sizes for fast tests
 #![allow(deprecated)]
 
-use dsa::{consts::DSA_1024_160, Components, PrivateKey, PublicKey};
+use dsa::{consts::DSA_1024_160, Components, SigningKey, VerifyingKey};
 use num_bigint::BigUint;
 use num_traits::One;
 use pkcs8::{DecodePublicKey, EncodePublicKey, LineEnding};
 
 const OPENSSL_PEM_PUBLIC_KEY: &str = include_str!("pems/public.pem");
 
-fn generate_public_key() -> PublicKey {
+fn generate_verifying_key() -> VerifyingKey {
     let mut rng = rand::thread_rng();
     let components = Components::generate(&mut rng, DSA_1024_160);
-    let private_key = PrivateKey::generate(&mut rng, components);
+    let signing_key = SigningKey::generate(&mut rng, components);
 
-    private_key.public_key().clone()
+    signing_key.verifying_key().clone()
 }
 
 #[test]
-fn decode_encode_openssl_public_key() {
-    let public_key = PublicKey::from_public_key_pem(OPENSSL_PEM_PUBLIC_KEY)
+fn decode_encode_openssl_verifying_key() {
+    let verifying_key = VerifyingKey::from_public_key_pem(OPENSSL_PEM_PUBLIC_KEY)
         .expect("Failed to decode PEM encoded OpenSSL public key");
-    assert!(public_key.is_valid());
+    assert!(verifying_key.is_valid());
 
-    let reencoded_public_key = public_key
+    let reencoded_verifying_key = verifying_key
         .to_public_key_pem(LineEnding::LF)
         .expect("Failed to encode public key into PEM representation");
 
-    assert_eq!(reencoded_public_key, OPENSSL_PEM_PUBLIC_KEY);
+    assert_eq!(reencoded_verifying_key, OPENSSL_PEM_PUBLIC_KEY);
 }
 
 #[test]
-fn encode_decode_public_key() {
-    let public_key = generate_public_key();
-    let encoded_public_key = public_key.to_public_key_pem(LineEnding::LF).unwrap();
-    let decoded_public_key = PublicKey::from_public_key_pem(&encoded_public_key).unwrap();
+fn encode_decode_verifying_key() {
+    let verifying_key = generate_verifying_key();
+    let encoded_verifying_key = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
+    let decoded_verifying_key = VerifyingKey::from_public_key_pem(&encoded_verifying_key).unwrap();
 
-    assert_eq!(public_key, decoded_public_key);
+    assert_eq!(verifying_key, decoded_verifying_key);
 }
 
 #[test]
-fn validate_public_key() {
-    let public_key = generate_public_key();
-    let p = public_key.components().p();
-    let q = public_key.components().q();
+fn validate_verifying_key() {
+    let verifying_key = generate_verifying_key();
+    let p = verifying_key.components().p();
+    let q = verifying_key.components().q();
 
     // Taken from the parameter validation from bouncy castle
-    assert_eq!(public_key.y().modpow(q, p), BigUint::one());
+    assert_eq!(verifying_key.y().modpow(q, p), BigUint::one());
 }
diff --git a/dsa/tests/signature.rs b/dsa/tests/signature.rs
index 8d4634f..829b98b 100644
--- a/dsa/tests/signature.rs
+++ b/dsa/tests/signature.rs
@@ -1,7 +1,7 @@
 #![allow(deprecated)]
 
 use digest::Digest;
-use dsa::{consts::DSA_1024_160, Components, PrivateKey, Signature};
+use dsa::{consts::DSA_1024_160, Components, Signature, SigningKey};
 use pkcs8::der::{Decode, Encode};
 use rand::{CryptoRng, RngCore, SeedableRng};
 use rand_chacha::ChaCha8Rng;
@@ -38,10 +38,10 @@ fn seeded_csprng() -> impl CryptoRng + RngCore {
 }
 
 /// Generate a DSA keypair using a seeded CSPRNG
-fn generate_deterministic_keypair() -> PrivateKey {
+fn generate_deterministic_keypair() -> SigningKey {
     let mut rng = seeded_csprng();
     let components = Components::generate(&mut rng, DSA_1024_160);
-    PrivateKey::generate(&mut rng, components)
+    SigningKey::generate(&mut rng, components)
 }
 
 #[test]
@@ -65,9 +65,9 @@ fn decode_encode_signature() {
 
 #[test]
 fn sign_message() {
-    let private_key = generate_deterministic_keypair();
+    let signing_key = generate_deterministic_keypair();
     let generated_signature =
-        private_key.sign_digest_with_rng(seeded_csprng(), Sha256::new().chain_update(MESSAGE));
+        signing_key.sign_digest_with_rng(seeded_csprng(), Sha256::new().chain_update(MESSAGE));
 
     let expected_signature =
         Signature::from_der(MESSAGE_SIGNATURE_CRATE_ASN1).expect("Failed to decode signature");
@@ -77,13 +77,13 @@ fn sign_message() {
 
 #[test]
 fn verify_signature() {
-    let private_key = generate_deterministic_keypair();
-    let public_key = private_key.public_key();
+    let signing_key = generate_deterministic_keypair();
+    let verifying_key = signing_key.verifying_key();
 
     let signature = Signature::from_der(MESSAGE_SIGNATURE_OPENSSL_ASN1)
         .expect("Failed to parse ASN.1 representation of the test signature");
 
-    assert!(public_key
+    assert!(verifying_key
         .verify_digest(Sha256::new().chain_update(MESSAGE), &signature)
         .is_ok());
 }