dsa: make pkcs8 feature optional (#1014)

It's not needed in applications which define their own key encodings,
for example SSH.

The feature is still enabled by-default.

Author: tarcieri

dsa/Cargo.toml

@@ -16,14 +16,17 @@ keywords = ["crypto", "nist", "signature"]
 rust-version = "1.85"
 
 [dependencies]
+der = { version = "0.8.0-rc.7", features = ["alloc"] }
 digest = "0.11.0-rc.0"
 crypto-bigint = { version = "=0.7.0-pre.6", default-features = false, features = ["alloc", "zeroize"] }
 crypto-primes = { version = "=0.7.0-pre.1", default-features = false }
-pkcs8 = { version = "0.11.0-rc.5", default-features = false, features = ["alloc"] }
 rfc6979 = { version = "0.5.0-rc.0" }
 sha2 = { version = "0.11.0-rc.0", default-features = false }
 signature = { version = "3.0.0-rc.1", default-features = false, features = ["alloc", "digest", "rand_core"] }
-zeroize = { version = "1", default-features = false }
+zeroize = { version = "1", default-features = false, features = ["alloc"] }
+
+# optional dependencies
+pkcs8 = { version = "0.11.0-rc.5", optional = true, default-features = false, features = ["alloc"] }
 
 [dev-dependencies]
 hex = "0.4.3"
@@ -36,19 +39,20 @@ sha1 = "0.11.0-rc.0"
 der = { version = "0.8.0-rc.6", features = ["derive"] }
 
 [features]
+default = ["pkcs8"]
 hazmat = []
 
 [package.metadata.docs.rs]
 all-features = true
 
 [[example]]
 name = "sign"
-required-features = ["hazmat"]
+required-features = ["hazmat", "pkcs8"]
 
 [[example]]
 name = "generate"
 required-features = ["hazmat"]
 
 [[example]]
 name = "export"
-required-features = ["hazmat"]
+required-features = ["hazmat", "pkcs8"]

dsa/examples/sign.rs

@@ -1,5 +1,3 @@
-#![cfg(feature = "hazmat")]
-
 use digest::Digest;
 use dsa::{Components, KeySize, SigningKey};
 use pkcs8::{EncodePrivateKey, EncodePublicKey, LineEnding};

dsa/src/components.rs

@@ -4,7 +4,7 @@
 
 use crate::{size::KeySize, two};
 use crypto_bigint::{BoxedUint, NonZero, Odd};
-use pkcs8::der::{
+use der::{
     self, DecodeValue, Encode, EncodeValue, Header, Length, Reader, Sequence, Tag, Writer,
     asn1::UintRef,
 };

dsa/src/generate.rs

@@ -4,14 +4,19 @@ use signature::rand_core::CryptoRng;
 
 mod components;
 mod keypair;
+#[cfg(feature = "hazmat")]
 mod secret_number;
 
-pub use self::components::{common as common_components, public as public_component};
+pub use self::components::common as common_components;
+#[cfg(feature = "hazmat")]
 pub use self::secret_number::{secret_number, secret_number_rfc6979};
 
 #[cfg(feature = "hazmat")]
 pub use self::keypair::keypair;
 
+#[cfg(all(feature = "hazmat", feature = "pkcs8"))]
+pub use self::components::public as public_component;
+
 /// Calculate the upper and lower bounds for generating values like p or q
 #[inline]
 fn calculate_bounds(size: u32) -> (NonZero<BoxedUint>, NonZero<BoxedUint>) {

dsa/src/generate/components.rs

@@ -3,19 +3,20 @@
 //!
 
 use crate::{
-    Components,
     generate::{calculate_bounds, generate_prime},
     size::KeySize,
     two,
 };
 use crypto_bigint::{
     BoxedUint, NonZero, Odd, RandomBits, Resize,
     modular::{BoxedMontyForm, BoxedMontyParams},
-    subtle::CtOption,
 };
 use crypto_primes::{Flavor, is_prime};
 use signature::rand_core::CryptoRng;
 
+#[cfg(feature = "hazmat")]
+use {crate::Components, crypto_bigint::subtle::CtOption};
+
 /// Generate the common components p, q, and g
 ///
 /// # Returns
@@ -85,6 +86,7 @@ pub fn common<R: CryptoRng + ?Sized>(
 }
 
 /// Calculate the public component from the common components and the private component
+#[cfg(feature = "hazmat")]
 #[inline]
 pub fn public(components: &Components, x: &NonZero<BoxedUint>) -> CtOption<NonZero<BoxedUint>> {
     let p = components.p();

dsa/src/lib.rs

@@ -58,30 +58,35 @@ pub use crate::signing_key::SigningKey;
 pub use crate::{components::Components, size::KeySize, verifying_key::VerifyingKey};
 
 pub use crypto_bigint::BoxedUint;
-pub use pkcs8;
 pub use signature;
 
+#[cfg(feature = "pkcs8")]
+pub use pkcs8;
+
 use crypto_bigint::NonZero;
-use pkcs8::spki::ObjectIdentifier;
 
 mod components;
 mod generate;
 mod signing_key;
 mod size;
 mod verifying_key;
 
+use alloc::{boxed::Box, vec::Vec};
+use der::{
+    Decode, DecodeValue, Encode, EncodeValue, FixedTag, Length, Reader, Sequence, Writer,
+    asn1::UintRef,
+};
+use signature::SignatureEncoding;
+
+#[cfg(feature = "pkcs8")]
+use pkcs8::ObjectIdentifier;
+
 /// DSA object identifier as defined by [RFC3279 § 2.3.2].
 ///
 /// [RFC3279 2.3.2]: https://www.rfc-editor.org/rfc/rfc3279#section-2.3.2
+#[cfg(feature = "pkcs8")]
 pub const OID: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.10040.4.1");
 
-use alloc::{boxed::Box, vec::Vec};
-use pkcs8::der::{
-    self, Decode, DecodeValue, Encode, EncodeValue, FixedTag, Header, Length, Reader, Sequence,
-    Writer, asn1::UintRef,
-};
-use signature::SignatureEncoding;
-
 /// Container of the DSA signature
 #[derive(Clone, Debug)]
 #[must_use]
@@ -117,7 +122,7 @@ impl Signature {
 impl<'a> DecodeValue<'a> for Signature {
     type Error = der::Error;
 
-    fn decode_value<R: Reader<'a>>(reader: &mut R, _header: Header) -> der::Result<Self> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, _header: der::Header) -> der::Result<Self> {
         let r = UintRef::decode(reader)?;
         let s = UintRef::decode(reader)?;
 

dsa/src/signing_key.rs

@@ -2,7 +2,9 @@
 //! Module containing the definition of the private key container
 //!
 
-use crate::{Components, OID, Signature, VerifyingKey};
+#![cfg(feature = "hazmat")]
+
+use crate::{Signature, VerifyingKey};
 use core::{
     cmp::min,
     fmt::{self, Debug},
@@ -12,21 +14,27 @@ use crypto_bigint::{
     modular::{BoxedMontyForm, BoxedMontyParams},
 };
 use digest::{Digest, FixedOutputReset, block_api::BlockSizeUser};
-use pkcs8::{
-    AlgorithmIdentifierRef, EncodePrivateKey, PrivateKeyInfoRef, SecretDocument,
-    der::{
-        AnyRef, Decode, Encode,
-        asn1::{OctetStringRef, UintRef},
-    },
-};
-#[cfg(feature = "hazmat")]
-use signature::rand_core::CryptoRng;
 use signature::{
     DigestSigner, MultipartSigner, RandomizedDigestSigner, Signer,
     hazmat::{PrehashSigner, RandomizedPrehashSigner},
     rand_core::TryCryptoRng,
 };
-use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};
+use zeroize::{ZeroizeOnDrop, Zeroizing};
+
+#[cfg(feature = "hazmat")]
+use {crate::Components, signature::rand_core::CryptoRng};
+#[cfg(feature = "pkcs8")]
+use {
+    crate::OID,
+    pkcs8::{
+        AlgorithmIdentifierRef, EncodePrivateKey, PrivateKeyInfoRef, SecretDocument,
+        der::{
+            AnyRef, Decode, Encode,
+            asn1::{OctetStringRef, UintRef},
+        },
+    },
+    zeroize::Zeroize,
+};
 
 /// DSA private key.
 ///
@@ -208,6 +216,7 @@ where
     }
 }
 
+#[cfg(feature = "pkcs8")]
 impl EncodePrivateKey for SigningKey {
     fn to_pkcs8_der(&self) -> pkcs8::Result<SecretDocument> {
         let parameters = self.verifying_key().components().to_der()?;
@@ -232,6 +241,7 @@ impl EncodePrivateKey for SigningKey {
     }
 }
 
+#[cfg(feature = "pkcs8")]
 impl<'a> TryFrom<PrivateKeyInfoRef<'a>> for SigningKey {
     type Error = pkcs8::Error;
 

dsa/src/verifying_key.rs

@@ -2,22 +2,27 @@
 //! Module containing the definition of the public key container
 //!
 
-use crate::{Components, OID, Signature, two};
+use crate::{Components, Signature, two};
 use core::cmp::min;
 use crypto_bigint::{
     BoxedUint, NonZero, Resize,
     modular::{BoxedMontyForm, BoxedMontyParams},
 };
 use digest::Digest;
-use pkcs8::{
-    AlgorithmIdentifierRef, EncodePublicKey, SubjectPublicKeyInfoRef,
-    der::{
-        AnyRef, Decode, Encode,
-        asn1::{BitStringRef, UintRef},
+use signature::{DigestVerifier, MultipartVerifier, Verifier, hazmat::PrehashVerifier};
+
+#[cfg(feature = "pkcs8")]
+use {
+    crate::OID,
+    pkcs8::{
+        AlgorithmIdentifierRef, EncodePublicKey, SubjectPublicKeyInfoRef,
+        der::{
+            AnyRef, Decode, Encode,
+            asn1::{BitStringRef, UintRef},
+        },
+        spki,
     },
-    spki,
 };
-use signature::{DigestVerifier, MultipartVerifier, Verifier, hazmat::PrehashVerifier};
 
 /// DSA public key.
 #[derive(Clone, Debug, PartialEq, PartialOrd)]
@@ -158,6 +163,7 @@ where
     }
 }
 
+#[cfg(feature = "pkcs8")]
 impl EncodePublicKey for VerifyingKey {
     fn to_public_key_der(&self) -> spki::Result<spki::Document> {
         let parameters = self.components.to_der()?;
@@ -179,6 +185,7 @@ impl EncodePublicKey for VerifyingKey {
     }
 }
 
+#[cfg(feature = "pkcs8")]
 impl<'a> TryFrom<SubjectPublicKeyInfoRef<'a>> for VerifyingKey {
     type Error = spki::Error;
 

dsa/tests/proptest.rs

@@ -1,4 +1,4 @@
-#![cfg(feature = "hazmat")]
+#![cfg(all(feature = "hazmat", feature = "pkcs8"))]
 //! Property-based tests.
 
 use der::{Decode, Encode, Sequence, asn1::Uint};

dsa/tests/signing_key.rs

@@ -1,4 +1,4 @@
-#![cfg(feature = "hazmat")]
+#![cfg(all(feature = "hazmat", feature = "pkcs8"))]
 // We abused the deprecated attribute for unsecure key sizes
 // But we want to use those small key sizes for fast tests
 #![allow(deprecated)]