Use FlagSet to provide an ergonomic experience with flag types

der/Cargo.toml

@@ -18,6 +18,7 @@ rust-version = "1.57"
 [dependencies]
 const-oid = { version = "0.8", optional = true, path = "../const-oid" }
 der_derive = { version = "=0.6.0-pre.1", optional = true, path = "derive" }
+flagset = { version = "0.4.3", optional = true }
 pem-rfc7468 = { version = "=0.4.0-pre.0", optional = true, path = "../pem-rfc7468" }
 time = { version = "0.3", optional = true, default-features = false }
 

der/src/asn1/bit_string.rs

@@ -225,6 +225,74 @@ impl<'a> ExactSizeIterator for BitStringIter<'a> {
 
 impl<'a> FusedIterator for BitStringIter<'a> {}
 
+#[cfg(feature = "flagset")]
+impl<T: flagset::Flags> FixedTag for flagset::FlagSet<T> {
+    const TAG: Tag = BitString::TAG;
+}
+
+#[cfg(feature = "flagset")]
+impl<'a, T> DecodeValue<'a> for flagset::FlagSet<T>
+where
+    T: flagset::Flags,
+    T::Type: From<bool>,
+    T::Type: core::ops::Shl<usize, Output = T::Type>,
+{
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+        let position = decoder.position();
+
+        let bits = BitString::decode_value(decoder, header)?;
+
+        let mut flags = T::none().bits();
+        if bits.bit_len() > core::mem::size_of_val(&flags) * 8 {
+            return Err(Error::new(ErrorKind::Overlength, position));
+        }
+
+        for (i, bit) in bits.bits().enumerate() {
+            flags |= T::Type::from(bit) << i;
+        }
+
+        Ok(Self::new_truncated(flags))
+    }
+}
+
+#[cfg(feature = "flagset")]
+#[inline(always)]
+fn encode<T>(set: &flagset::FlagSet<T>) -> (usize, [u8; 16])
+where
+    T: flagset::Flags,
+    u128: From<T::Type>,
+{
+    let bits: u128 = set.bits().into();
+    let mut swap = 0u128;
+
+    for i in 0..128 {
+        let on = bits & (1 << i);
+        swap |= on >> i << (128 - i - 1);
+    }
+
+    (bits.leading_zeros() as usize, swap.to_be_bytes())
+}
+
+#[cfg(feature = "flagset")]
+impl<T: flagset::Flags> EncodeValue for flagset::FlagSet<T>
+where
+    T::Type: From<bool>,
+    T::Type: core::ops::Shl<usize, Output = T::Type>,
+    u128: From<T::Type>,
+{
+    fn value_len(&self) -> Result<Length> {
+        let (lead, buff) = encode(self);
+        let buff = &buff[..buff.len() - lead / 8];
+        BitString::new((lead % 8) as u8, buff)?.value_len()
+    }
+
+    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
+        let (lead, buff) = encode(self);
+        let buff = &buff[..buff.len() - lead / 8];
+        BitString::new((lead % 8) as u8, buff)?.encode_value(encoder)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{BitString, Result, Tag};

x509/Cargo.toml

@@ -15,7 +15,8 @@ edition = "2021"
 rust-version = "1.56"
 
 [dependencies]
-der = { version = "=0.6.0-pre.1", features = ["derive", "alloc"], path = "../der" }
+der = { version = "=0.6.0-pre.1", features = ["derive", "alloc", "flagset"], path = "../der" }
+flagset = { version = "0.4.3" }
 spki = { version = "=0.6.0-pre.0", path = "../spki" }
 x501 = { version = "=0.1.0-pre.0", path = "../x501" }
 

x509/src/lib.rs

@@ -15,14 +15,11 @@ extern crate alloc;
 extern crate std;
 
 mod certificate;
-pub mod extensions_utils;
 mod general_name;
 pub mod pkix_extensions;
 pub mod pkix_oids;
 pub mod trust_anchor_format;
 
-pub use crate::{
-    certificate::*, extensions_utils::*, general_name::*, pkix_extensions::*, pkix_oids::*,
-};
+pub use crate::{certificate::*, general_name::*, pkix_extensions::*, pkix_oids::*};
 pub use der::{self, asn1::ObjectIdentifier};
 pub use spki::{self, AlgorithmIdentifier, SubjectPublicKeyInfo};