x509-cert: Create a CrlNumber from native types

Author: baloo

der/src/asn1/integer/int.rs

@@ -302,6 +302,75 @@ mod allocating {
             IntRef { inner }
         }
     }
+
+    macro_rules! impl_from_traits {
+        ($($int:ty),+) => {
+            $(
+                impl TryFrom<$int> for Int {
+                    type Error = $crate::Error;
+
+                    fn try_from(value: $int) -> $crate::Result<Self> {
+                        let mut buf  = [0u8; 16];
+                        let mut writer = $crate::SliceWriter::new(&mut buf[..]);
+                        value.encode_value(&mut writer)?;
+                        let buf = writer.finish()?;
+                        Int::new(buf)
+                    }
+                }
+            )+
+        };
+    }
+
+    impl_from_traits!(i8, i16, i32, i64, i128);
+
+    #[cfg(test)]
+    #[allow(clippy::unwrap_used)]
+    mod tests {
+        use super::Int;
+
+        #[test]
+        fn from_uint() {
+            assert_eq!(Int::try_from(i8::MIN).unwrap().as_bytes(), &[0x80]);
+            assert_eq!(Int::try_from(i8::MAX).unwrap().as_bytes(), &[0x7F]);
+            assert_eq!(Int::try_from(i16::MIN).unwrap().as_bytes(), &[0x80, 0]);
+            assert_eq!(Int::try_from(i16::MAX).unwrap().as_bytes(), &[0x7F, 0xFF]);
+            assert_eq!(
+                Int::try_from(i32::MIN).unwrap().as_bytes(),
+                &[0x80, 0, 0, 0]
+            );
+            assert_eq!(
+                Int::try_from(i32::MAX).unwrap().as_bytes(),
+                &[0x7F, 0xFF, 0xFF, 0xFF]
+            );
+            assert_eq!(
+                Int::try_from(i64::MIN).unwrap().as_bytes(),
+                &[
+                    0x80, 0, 0, 0, //
+                    0, 0, 0, 0
+                ]
+            );
+            assert_eq!(
+                Int::try_from(i64::MAX).unwrap().as_bytes(),
+                &[
+                    0x7F, 0xFF, 0xFF, 0xFF, //
+                    0xFF, 0xFF, 0xFF, 0xFF //
+                ]
+            );
+            assert_eq!(
+                Int::try_from(i128::MIN).unwrap().as_bytes(),
+                &[0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            );
+            assert_eq!(
+                Int::try_from(i128::MAX).unwrap().as_bytes(),
+                &[
+                    0x7F, 0xFF, 0xFF, 0xFF, //
+                    0xFF, 0xFF, 0xFF, 0xFF, //
+                    0xFF, 0xFF, 0xFF, 0xFF, //
+                    0xFF, 0xFF, 0xFF, 0xFF, //
+                ]
+            );
+        }
+    }
 }
 
 /// Ensure `INTEGER` is canonically encoded.

der/src/asn1/integer/uint.rs

@@ -273,6 +273,46 @@ mod allocating {
             UintRef { inner }
         }
     }
+
+    macro_rules! impl_from_traits {
+        ($($uint:ty),+) => {
+            $(
+                impl TryFrom<$uint> for Uint {
+                    type Error = $crate::Error;
+
+                    fn try_from(value: $uint) -> $crate::Result<Self> {
+                        let mut buf  = [0u8; 17];
+                        let mut writer = $crate::SliceWriter::new(&mut buf[..]);
+                        value.encode_value(&mut writer)?;
+                        let buf = writer.finish()?;
+                        Uint::new(buf)
+                    }
+                }
+            )+
+        };
+    }
+
+    impl_from_traits!(u8, u16, u32, u64, u128);
+
+    #[cfg(test)]
+    #[allow(clippy::unwrap_used)]
+    mod tests {
+        use super::Uint;
+
+        #[test]
+        fn from_uint() {
+            assert_eq!(Uint::try_from(u8::MIN).unwrap().as_bytes(), &[0]);
+            assert_eq!(Uint::try_from(u8::MAX).unwrap().as_bytes(), &[0xFF]);
+            assert_eq!(Uint::try_from(u16::MIN).unwrap().as_bytes(), &[0]);
+            assert_eq!(Uint::try_from(u16::MAX).unwrap().as_bytes(), &[0xFF; 2]);
+            assert_eq!(Uint::try_from(u32::MIN).unwrap().as_bytes(), &[0]);
+            assert_eq!(Uint::try_from(u32::MAX).unwrap().as_bytes(), &[0xFF; 4]);
+            assert_eq!(Uint::try_from(u64::MIN).unwrap().as_bytes(), &[0]);
+            assert_eq!(Uint::try_from(u64::MAX).unwrap().as_bytes(), &[0xFF; 8]);
+            assert_eq!(Uint::try_from(u128::MIN).unwrap().as_bytes(), &[0]);
+            assert_eq!(Uint::try_from(u128::MAX).unwrap().as_bytes(), &[0xFF; 16]);
+        }
+    }
 }
 
 /// Decode an unsigned integer into a big endian byte slice with all leading

x509-cert/src/ext/pkix/crl.rs

@@ -30,6 +30,22 @@ impl AssociatedOid for CrlNumber {
 impl_newtype!(CrlNumber, Uint);
 impl_extension!(CrlNumber, critical = false);
 
+macro_rules! impl_from_traits {
+    ($($uint:ty),+) => {
+        $(
+            impl TryFrom<$uint> for CrlNumber {
+                type Error = der::Error;
+
+                fn try_from(value: $uint) -> der::Result<Self> {
+                    Uint::try_from(value).map(Self)
+                }
+            }
+        )+
+    }
+}
+
+impl_from_traits!(u8, u16, u32, u64, u128);
+
 /// BaseCRLNumber as defined in [RFC 5280 Section 5.2.4].
 ///
 /// ```text