impl to_be_bytes_trimmed and to_le_bytes_trimmed for BoxedUint (#824)

This helpers strips the leading zeroes from the serialization.

See:
 - RustCrypto/RSA#519
 - RustCrypto/RSA#518

Author: baloo

src/uint/boxed/encoding.rs

@@ -90,6 +90,14 @@ impl BoxedUint {
         out.into()
     }
 
+    /// Serialize this [`BoxedUint`] as big-endian without leading zeroes.
+    #[inline]
+    pub fn to_be_bytes_trimmed_vartime(&self) -> Box<[u8]> {
+        let zeroes = self.leading_zeros() as usize / 8;
+
+        (&self.to_be_bytes()[zeroes..]).into()
+    }
+
     /// Serialize this [`BoxedUint`] as little-endian.
     #[inline]
     pub fn to_le_bytes(&self) -> Box<[u8]> {
@@ -107,6 +115,16 @@ impl BoxedUint {
         out.into()
     }
 
+    /// Serialize this [`BoxedUint`] as little-endian without trailing zeroes.
+    #[inline]
+    pub fn to_le_bytes_trimmed_vartime(&self) -> Box<[u8]> {
+        let zeroes = self.leading_zeros() as usize / 8;
+
+        let bytes = self.to_le_bytes();
+
+        (&bytes[..bytes.len() - zeroes]).into()
+    }
+
     /// Create a new [`BoxedUint`] from the provided big endian hex string.
     pub fn from_be_hex(hex: &str, bits_precision: u32) -> CtOption<Self> {
         let nlimbs = (bits_precision / Limb::BITS) as usize;
@@ -425,13 +443,64 @@ mod tests {
         assert_eq!(bytes.as_slice(), &*n.to_be_bytes());
     }
 
+    #[test]
+    fn to_be_bytes_trimmed_vartime() {
+        let bytes = hex!("ff112233445566778899aabbccddeeff");
+        let n = BoxedUint::from_be_slice(&bytes, 128).unwrap();
+        assert_eq!(&bytes, &*n.to_be_bytes_trimmed_vartime());
+
+        let bytes = hex!("00112233445566778899aabbccddeeff");
+        let n = BoxedUint::from_be_slice(&bytes, 128).unwrap();
+        assert_eq!(&bytes.as_slice()[1..], &*n.to_be_bytes_trimmed_vartime());
+
+        let bytes: &[u8] = b"";
+        let n = BoxedUint::from_be_slice(bytes, 128).unwrap();
+        assert_eq!(
+            hex!("00000000000000000000000000000000"),
+            n.to_be_bytes().as_ref()
+        );
+        assert_eq!(bytes, n.to_be_bytes_trimmed_vartime().as_ref());
+
+        let bytes = hex!("00012233445566778899aabbccddeeff");
+        let n = BoxedUint::from_be_slice(&bytes, 128).unwrap();
+        assert_eq!(&bytes.as_slice()[1..], &*n.to_be_bytes_trimmed_vartime());
+
+        let bytes = hex!("00000000000000000000000000000001");
+        let n = BoxedUint::from_be_slice(&bytes, 128).unwrap();
+        assert_eq!(bytes, n.to_be_bytes().as_ref());
+        assert_eq!(&bytes.as_slice()[15..], &*n.to_be_bytes_trimmed_vartime());
+    }
+
     #[test]
     fn to_le_bytes() {
         let bytes = hex!("ffeeddccbbaa99887766554433221100");
         let n = BoxedUint::from_le_slice(&bytes, 128).unwrap();
         assert_eq!(bytes.as_slice(), &*n.to_le_bytes());
     }
 
+    #[test]
+    fn to_le_bytes_trimmed_vartime() {
+        let bytes = hex!("ffeeddccbbaa998877665544332211ff");
+        let n = BoxedUint::from_le_slice(&bytes, 128).unwrap();
+        assert_eq!(bytes.as_slice(), &*n.to_le_bytes_trimmed_vartime());
+
+        let bytes = hex!("ffeeddccbbaa99887766554433221100");
+        let n = BoxedUint::from_le_slice(&bytes, 128).unwrap();
+        assert_eq!(&bytes.as_slice()[..15], &*n.to_le_bytes_trimmed_vartime());
+
+        let bytes = hex!("ff000000000000000000000000000000");
+        let n = BoxedUint::from_le_slice(&bytes, 128).unwrap();
+        assert_eq!(&bytes.as_slice()[..1], &*n.to_le_bytes_trimmed_vartime());
+
+        let bytes = hex!("01000000000000000000000000000000");
+        let n = BoxedUint::from_le_slice(&bytes, 128).unwrap();
+        assert_eq!(&bytes.as_slice()[..1], &*n.to_le_bytes_trimmed_vartime());
+
+        let bytes = hex!("00000000000000000000000000000000");
+        let n = BoxedUint::from_le_slice(&bytes, 128).unwrap();
+        assert_eq!(b"", &*n.to_le_bytes_trimmed_vartime());
+    }
+
     #[test]
     fn from_str_radix_invalid() {
         assert_eq!(