x509-cert: wip: owned api

der/derive/src/attributes.rs

@@ -1,11 +1,11 @@
 //! Attribute-related types used by the proc macro
 
 use crate::{Asn1Type, Tag, TagMode, TagNumber};
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use proc_macro_error::{abort, abort_call_site};
 use quote::quote;
 use std::{fmt::Debug, str::FromStr};
-use syn::{Attribute, Lit, LitStr, Meta, MetaList, MetaNameValue, NestedMeta, Path};
+use syn::{Attribute, Ident, Lit, LitStr, Meta, MetaList, MetaNameValue, NestedMeta, Path};
 
 /// Attribute name.
 pub(crate) const ATTR_NAME: &str = "asn1";
@@ -21,12 +21,22 @@ pub(crate) struct TypeAttrs {
     ///
     /// The default value is `EXPLICIT`.
     pub tag_mode: TagMode,
+
+    /// The type parameters that needs to implement `der::Choice<'_>`
+    pub choice: Vec<Ident>,
+    /// The type parameters that needs to implement `der::Encode`
+    pub encode: Vec<Ident>,
+    /// The type parameters that needs to implement `der::asn1::BitStringLike<'_>`
+    pub bitstringlike: Vec<Ident>,
 }
 
 impl TypeAttrs {
     /// Parse attributes from a struct field or enum variant.
     pub fn parse(attrs: &[Attribute]) -> Self {
         let mut tag_mode = None;
+        let mut choice = Vec::new();
+        let mut encode = Vec::new();
+        let mut bitstringlike = Vec::new();
 
         let mut parsed_attrs = Vec::new();
         AttrNameValue::from_attributes(attrs, &mut parsed_attrs);
@@ -39,6 +49,12 @@ impl TypeAttrs {
                 }
 
                 tag_mode = Some(mode);
+            } else if let Some(ident) = attr.parse_value::<String>("choice") {
+                choice.push(Ident::new(&ident, Span::call_site()));
+            } else if let Some(ident) = attr.parse_value::<String>("encode") {
+                encode.push(Ident::new(&ident, Span::call_site()));
+            } else if let Some(ident) = attr.parse_value::<String>("bitstringlike") {
+                bitstringlike.push(Ident::new(&ident, Span::call_site()));
             } else {
                 abort!(
                     attr.name,
@@ -49,6 +65,9 @@ impl TypeAttrs {
 
         Self {
             tag_mode: tag_mode.unwrap_or_default(),
+            bitstringlike,
+            encode,
+            choice,
         }
     }
 }

der/derive/src/sequence.rs

@@ -8,6 +8,7 @@ use field::SequenceField;
 use proc_macro2::TokenStream;
 use proc_macro_error::abort;
 use quote::quote;
+use std::cmp::Ordering;
 use syn::{DeriveInput, Ident, Lifetime};
 
 /// Derive the `Sequence` trait for a struct
@@ -20,6 +21,12 @@ pub(crate) struct DeriveSequence {
 
     /// Fields of the struct.
     fields: Vec<SequenceField>,
+
+    /// Type parameters of the struct.
+    type_parameters: Vec<Ident>,
+
+    /// Type attributes of the struct.
+    type_attrs: TypeAttrs,
 }
 
 impl DeriveSequence {
@@ -33,6 +40,12 @@ impl DeriveSequence {
             ),
         };
 
+        let type_parameters = input
+            .generics
+            .type_params()
+            .map(|g| g.ident.clone())
+            .collect::<Vec<_>>();
+
         // TODO(tarcieri): properly handle multiple lifetimes
         let lifetime = input
             .generics
@@ -52,6 +65,8 @@ impl DeriveSequence {
             ident: input.ident,
             lifetime,
             fields,
+            type_parameters,
+            type_attrs,
         }
     }
 
@@ -82,8 +97,27 @@ impl DeriveSequence {
             encode_body.push(field.to_encode_tokens());
         }
 
+        let mut type_parameters = Vec::new();
+        let mut type_parameters_bounds = Vec::new();
+        for param in &self.type_parameters {
+            type_parameters.push(param.clone());
+
+            if let Some(bound) = param.to_bind_tokens(&lifetime, &self.type_attrs) {
+                type_parameters_bounds.push(bound);
+            }
+        }
+
+        let maybe_where_token = if !self.type_parameters.is_empty() {
+            quote! {where}
+        } else {
+            quote! {}
+        };
+
         quote! {
-            impl<#lifetime> ::der::DecodeValue<#lifetime> for #ident<#lt_params> {
+            impl<#lifetime, #(#type_parameters),*> ::der::DecodeValue<#lifetime> for #ident<#lt_params #(#type_parameters),*>
+                #maybe_where_token
+                #(#type_parameters_bounds),*
+            {
                 fn decode_value<R: ::der::Reader<#lifetime>>(
                     reader: &mut R,
                     header: ::der::Header,
@@ -100,7 +134,10 @@ impl DeriveSequence {
                 }
             }
 
-            impl<#lifetime> ::der::Sequence<#lifetime> for #ident<#lt_params> {
+            impl<#lifetime, #(#type_parameters),*> ::der::Sequence<#lifetime> for #ident<#lt_params #(#type_parameters),*>
+                #maybe_where_token
+                #(#type_parameters_bounds),*
+            {
                 fn fields<F, T>(&self, f: F) -> ::der::Result<T>
                 where
                     F: FnOnce(&[&dyn der::Encode]) -> ::der::Result<T>,
@@ -114,6 +151,55 @@ impl DeriveSequence {
     }
 }
 
+/// Trait for extending `syn::Ident` with a helper to generate the TokenStream for binding the type
+trait BindToken {
+    fn to_bind_tokens(&self, lifetime: &TokenStream, attrs: &TypeAttrs) -> Option<TokenStream>;
+}
+
+impl BindToken for Ident {
+    fn to_bind_tokens(&self, lifetime: &TokenStream, attrs: &TypeAttrs) -> Option<TokenStream> {
+        let ident = self;
+
+        let mut bounds = Vec::new();
+
+        if attrs.choice.iter().any(|i| ident.ident_eq(i)) {
+            bounds.push(quote! {
+                ::der::Choice<#lifetime>
+            });
+        }
+        if attrs.encode.iter().any(|i| ident.ident_eq(i)) {
+            bounds.push(quote! {
+                ::der::Encode
+            });
+        }
+        if attrs.bitstringlike.iter().any(|i| ident.ident_eq(i)) {
+            bounds.push(quote! {
+                ::der::asn1::BitStringLike<#lifetime>
+            });
+        }
+
+        if !bounds.is_empty() {
+            Some(quote! {
+                #ident: #(#bounds)+*
+            })
+        } else {
+            None
+        }
+    }
+}
+
+/// A small helper for `Ident` to do comparison of `Ident` ignoring its callsite
+trait IdentEq {
+    fn ident_eq(&self, ident: &Ident) -> bool;
+}
+
+impl IdentEq for Ident {
+    fn ident_eq(&self, ident: &Ident) -> bool {
+        // Implementation detail, ordering comparison only compares the name
+        self.cmp(ident) == Ordering::Equal
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::DeriveSequence;

der/src/asn1.rs

@@ -27,7 +27,7 @@ mod videotex_string;
 
 pub use self::{
     any::AnyRef,
-    bit_string::{BitStringIter, BitStringRef},
+    bit_string::{BitStringIter, BitStringLike, BitStringRef},
     choice::Choice,
     context_specific::{ContextSpecific, ContextSpecificRef},
     generalized_time::GeneralizedTime,
@@ -47,7 +47,11 @@ pub use self::{
 
 #[cfg(feature = "alloc")]
 #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-pub use self::{any::Any, bit_string::BitString, octet_string::OctetString, set_of::SetOfVec};
+pub use self::{
+    any::Any, bit_string::BitString, ia5_string::Ia5String, integer::bigint::UInt,
+    octet_string::OctetString, printable_string::PrintableString, set_of::SetOfVec,
+    teletex_string::TeletexString,
+};
 
 #[cfg(feature = "oid")]
 #[cfg_attr(docsrs, doc(cfg(feature = "oid")))]

der/src/asn1/any.rs

@@ -7,7 +7,7 @@ use crate::{
 use core::cmp::Ordering;
 
 #[cfg(feature = "alloc")]
-use alloc::vec::Vec;
+use crate::Bytes;
 
 #[cfg(feature = "oid")]
 use crate::asn1::ObjectIdentifier;
@@ -94,11 +94,6 @@ impl<'a> AnyRef<'a> {
         self.try_into()
     }
 
-    /// Attempt to decode an ASN.1 `IA5String`.
-    pub fn ia5_string(self) -> Result<Ia5StringRef<'a>> {
-        self.try_into()
-    }
-
     /// Attempt to decode an ASN.1 `OCTET STRING`.
     pub fn octet_string(self) -> Result<OctetStringRef<'a>> {
         self.try_into()
@@ -123,21 +118,6 @@ impl<'a> AnyRef<'a> {
         }
     }
 
-    /// Attempt to decode an ASN.1 `PrintableString`.
-    pub fn printable_string(self) -> Result<PrintableStringRef<'a>> {
-        self.try_into()
-    }
-
-    /// Attempt to decode an ASN.1 `TeletexString`.
-    pub fn teletex_string(self) -> Result<TeletexStringRef<'a>> {
-        self.try_into()
-    }
-
-    /// Attempt to decode an ASN.1 `VideotexString`.
-    pub fn videotex_string(self) -> Result<VideotexStringRef<'a>> {
-        self.try_into()
-    }
-
     /// Attempt to decode this value an ASN.1 `SEQUENCE`, creating a new
     /// nested reader and calling the provided argument with it.
     pub fn sequence<F, T>(self, f: F) -> Result<T>
@@ -154,11 +134,6 @@ impl<'a> AnyRef<'a> {
     pub fn utc_time(self) -> Result<UtcTime> {
         self.try_into()
     }
-
-    /// Attempt to decode an ASN.1 `UTF8String`.
-    pub fn utf8_string(self) -> Result<Utf8StringRef<'a>> {
-        self.try_into()
-    }
 }
 
 impl<'a> Choice<'a> for AnyRef<'a> {
@@ -194,6 +169,13 @@ impl Tagged for AnyRef<'_> {
     }
 }
 
+#[cfg(feature = "alloc")]
+impl ValueOrd for Any {
+    fn value_cmp(&self, other: &Self) -> Result<Ordering> {
+        self.value.der_cmp(&other.value)
+    }
+}
+
 impl ValueOrd for AnyRef<'_> {
     fn value_cmp(&self, other: &Self) -> Result<Ordering> {
         self.value.der_cmp(&other.value)
@@ -226,19 +208,35 @@ pub struct Any {
     tag: Tag,
 
     /// Inner value encoded as bytes.
-    value: Vec<u8>,
+    value: Bytes,
 }
 
 #[cfg(feature = "alloc")]
 impl Any {
     /// Create a new [`Any`] from the provided [`Tag`] and DER bytes.
-    pub fn new(tag: Tag, bytes: impl Into<Vec<u8>>) -> Result<Self> {
-        let value = bytes.into();
+    pub fn new(tag: Tag, bytes: &[u8]) -> Result<Self> {
+        let value = Bytes::new(bytes)?;
 
         // Ensure the tag and value are a valid `AnyRef`.
-        AnyRef::new(tag, &value)?;
+        AnyRef::new(tag, value.as_slice())?;
         Ok(Self { tag, value })
     }
+
+    /// Attempt to decode this [`Any`] type into the inner value.
+    pub fn decode_into<'a, T>(&'a self) -> Result<T>
+    where
+        T: DecodeValue<'a> + FixedTag,
+    {
+        self.tag.assert_eq(T::TAG)?;
+        let header = Header {
+            tag: self.tag,
+            length: self.value.len(),
+        };
+
+        let mut decoder = SliceReader::new(self.value.as_slice())?;
+        let result = T::decode_value(&mut decoder, header)?;
+        decoder.finish(result)
+    }
 }
 
 #[cfg(feature = "alloc")]
@@ -253,26 +251,26 @@ impl<'a> Decode<'a> for Any {
     fn decode<R: Reader<'a>>(reader: &mut R) -> Result<Self> {
         let header = Header::decode(reader)?;
         let value = reader.read_vec(header.length)?;
-        Self::new(header.tag, value)
+        Self::new(header.tag, &value)
     }
 }
 
 #[cfg(feature = "alloc")]
 impl EncodeValue for Any {
     fn value_len(&self) -> Result<Length> {
-        self.value.len().try_into()
+        Ok(self.value.len())
     }
 
     fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
-        writer.write(&self.value)
+        writer.write(self.value.as_slice())
     }
 }
 
 #[cfg(feature = "alloc")]
 impl<'a> From<&'a Any> for AnyRef<'a> {
     fn from(any: &'a Any) -> AnyRef<'a> {
         // Ensured to parse successfully in constructor
-        AnyRef::new(any.tag, &any.value).expect("invalid ANY")
+        AnyRef::new(any.tag, any.value.as_slice()).expect("invalid ANY")
     }
 }
 
@@ -282,3 +280,17 @@ impl Tagged for Any {
         self.tag
     }
 }
+
+#[cfg(feature = "alloc")]
+impl<'a, T> From<T> for Any
+where
+    T: Into<AnyRef<'a>>,
+{
+    fn from(input: T) -> Any {
+        let anyref: AnyRef<'a> = input.into();
+        Self {
+            tag: anyref.tag(),
+            value: Bytes::from(anyref.value),
+        }
+    }
+}