dsa: add from_components_unchecked APIs (#1059)

Adds support for any size of keys, either larger or older/weak keys.

The API is only available under the `hazmat` feature-flag, and the
consumer is responsible for checking the security of what they're using
it for.

Fixes #1058

* dsa: compare key sizes aligned to limb

This allows to compare key sizes after a back and forth through
serialization which could lose the exact key size.

Author: baloo

dsa/src/components.rs

@@ -31,6 +31,44 @@ pub struct Components {
 impl Components {
     /// Construct the common components container from its inner values (p, q and g)
     pub fn from_components(p: BoxedUint, q: BoxedUint, g: BoxedUint) -> signature::Result<Self> {
+        let (p, q, g) = Self::adapt_components(p, q, g)?;
+
+        let key_size = match (p.bits_precision(), q.bits_precision()) {
+            #[allow(deprecated)]
+            (p, q) if KeySize::DSA_1024_160.matches(p, q) => KeySize::DSA_1024_160,
+            (p, q) if KeySize::DSA_2048_224.matches(p, q) => KeySize::DSA_2048_224,
+            (p, q) if KeySize::DSA_2048_256.matches(p, q) => KeySize::DSA_2048_256,
+            (p, q) if KeySize::DSA_3072_256.matches(p, q) => KeySize::DSA_3072_256,
+            _ => return Err(signature::Error::new()),
+        };
+
+        Ok(Self { p, q, g, key_size })
+    }
+
+    /// Construct the common components container from its inner values (p, q and g)
+    ///
+    /// # Safety
+    ///
+    /// Any length of keys may be used, no checks are to be performed. You are responsible for
+    /// checking the key strengths.
+    #[cfg(feature = "hazmat")]
+    pub fn from_components_unchecked(
+        p: BoxedUint,
+        q: BoxedUint,
+        g: BoxedUint,
+    ) -> signature::Result<Self> {
+        let (p, q, g) = Self::adapt_components(p, q, g)?;
+        let key_size = KeySize::other(p.bits_precision(), q.bits_precision());
+
+        Ok(Self { p, q, g, key_size })
+    }
+
+    /// Helper method to build a [`Components`]
+    fn adapt_components(
+        p: BoxedUint,
+        q: BoxedUint,
+        g: BoxedUint,
+    ) -> signature::Result<(Odd<BoxedUint>, NonZero<BoxedUint>, NonZero<BoxedUint>)> {
         let p = Odd::new(p)
             .into_option()
             .ok_or_else(signature::Error::new)?;
@@ -45,16 +83,7 @@ impl Components {
             return Err(signature::Error::new());
         }
 
-        let key_size = match (p.bits_precision(), q.bits_precision()) {
-            #[allow(deprecated)]
-            (p, q) if KeySize::DSA_1024_160.matches(p, q) => KeySize::DSA_1024_160,
-            (p, q) if KeySize::DSA_2048_224.matches(p, q) => KeySize::DSA_2048_224,
-            (p, q) if KeySize::DSA_2048_256.matches(p, q) => KeySize::DSA_2048_256,
-            (p, q) if KeySize::DSA_3072_256.matches(p, q) => KeySize::DSA_3072_256,
-            _ => return Err(signature::Error::new()),
-        };
-
-        Ok(Self { p, q, g, key_size })
+        Ok((p, q, g))
     }
 
     /// Generate a new pair of common components

dsa/src/size.rs

@@ -1,7 +1,8 @@
+use core::cmp::Ordering;
 use crypto_bigint::Limb;
 
 /// DSA key size
-#[derive(Clone, Debug, Copy, PartialEq, PartialOrd)]
+#[derive(Clone, Debug, Copy)]
 pub struct KeySize {
     /// Bit size of p
     pub(crate) l: u32,
@@ -25,6 +26,14 @@ impl KeySize {
 
     /// DSA parameter size constant: L = 3072, N = 256
     pub const DSA_3072_256: Self = Self { l: 3072, n: 256 };
+
+    /// Create a KeySize from other, potentially unsafe, key lengths
+    ///
+    /// This aims at supporting non-standard or older/weak keys.
+    #[cfg(feature = "hazmat")]
+    pub(crate) fn other(l: u32, n: u32) -> Self {
+        Self { l, n }
+    }
 }
 
 impl KeySize {
@@ -40,3 +49,18 @@ impl KeySize {
         l == self.l_aligned() && n == self.n_aligned()
     }
 }
+
+impl PartialEq for KeySize {
+    fn eq(&self, other: &Self) -> bool {
+        self.l_aligned() == other.l_aligned() && self.n_aligned() == other.n_aligned()
+    }
+}
+
+impl PartialOrd for KeySize {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        let l = self.l_aligned().partial_cmp(&other.l_aligned())?;
+        let n = self.n_aligned().partial_cmp(&other.n_aligned())?;
+
+        Some(l.then(n))
+    }
+}