RustCrypto · tarcieri · Feb 7, 2022 · Feb 6, 2022
diff --git a/der/derive/src/enumerated.rs b/der/derive/src/enumerated.rs
@@ -98,9 +98,9 @@ impl DeriveEnumerated {
             impl ::der::DecodeValue<'_> for #ident {
                 fn decode_value(
                     decoder: &mut ::der::Decoder<'_>,
-                    length: ::der::Length
+                    header: ::der::Header
                 ) -> ::der::Result<Self> {
-                    <#repr as ::der::DecodeValue>::decode_value(decoder, length)?.try_into()
+                    <#repr as ::der::DecodeValue>::decode_value(decoder, header)?.try_into()
                 }
             }
 

diff --git a/der/derive/src/sequence.rs b/der/derive/src/sequence.rs
@@ -87,10 +87,10 @@ impl DeriveSequence {
             impl<#lt_params> ::der::DecodeValue<#lifetime> for #ident<#lt_params> {
                 fn decode_value(
                     decoder: &mut ::der::Decoder<#lifetime>,
-                    length: ::der::Length,
+                    header: ::der::Header,
                 ) -> ::der::Result<Self> {
                     use ::der::DecodeValue;
-                    ::der::asn1::SequenceRef::decode_value(decoder, length)?.decode_body(|decoder| {
+                    ::der::asn1::SequenceRef::decode_value(decoder, header)?.decode_body(|decoder| {
                         #(#decode_body)*
 
                         Ok(Self {

diff --git a/der/src/asn1/any.rs b/der/src/asn1/any.rs
@@ -56,8 +56,13 @@ impl<'a> Any<'a> {
         T: DecodeValue<'a> + FixedTag,
     {
         self.tag.assert_eq(T::TAG)?;
+        let header = Header {
+            tag: self.tag,
+            length: self.value.len(),
+        };
+
         let mut decoder = Decoder::new(self.value())?;
-        let result = T::decode_value(&mut decoder, self.value.len())?;
+        let result = T::decode_value(&mut decoder, header)?;
         decoder.finish(result)
     }
 
@@ -150,9 +155,10 @@ impl<'a> Choice<'a> for Any<'a> {
 impl<'a> Decodable<'a> for Any<'a> {
     fn decode(decoder: &mut Decoder<'a>) -> Result<Any<'a>> {
         let header = Header::decode(decoder)?;
-        let tag = header.tag;
-        let value = ByteSlice::decode_value(decoder, header.length)?;
-        Ok(Self { tag, value })
+        Ok(Self {
+            tag: header.tag,
+            value: ByteSlice::decode_value(decoder, header)?,
+        })
     }
 }
 

diff --git a/der/src/asn1/bit_string.rs b/der/src/asn1/bit_string.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     asn1::Any, ByteSlice, DecodeValue, Decoder, DerOrd, EncodeValue, Encoder, Error, ErrorKind,
-    FixedTag, Length, Result, Tag, ValueOrd,
+    FixedTag, Header, Length, Result, Tag, ValueOrd,
 };
 use core::{cmp::Ordering, iter::FusedIterator};
 
@@ -116,9 +116,14 @@ impl<'a> BitString<'a> {
 }
 
 impl<'a> DecodeValue<'a> for BitString<'a> {
-    fn decode_value(decoder: &mut Decoder<'a>, encoded_len: Length) -> Result<Self> {
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+        let header = Header {
+            tag: header.tag,
+            length: (header.length - Length::ONE)?,
+        };
+
         let unused_bits = decoder.byte()?;
-        let inner = ByteSlice::decode_value(decoder, (encoded_len - Length::ONE)?)?;
+        let inner = ByteSlice::decode_value(decoder, header)?;
         Self::new(unused_bits, inner.as_bytes())
     }
 }

diff --git a/der/src/asn1/boolean.rs b/der/src/asn1/boolean.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error,
-    ErrorKind, FixedTag, Length, Result, Tag,
+    ErrorKind, FixedTag, Header, Length, Result, Tag,
 };
 
 /// Byte used to encode `true` in ASN.1 DER. From X.690 Section 11.1:
@@ -15,8 +15,8 @@ const TRUE_OCTET: u8 = 0b11111111;
 const FALSE_OCTET: u8 = 0b00000000;
 
 impl<'a> DecodeValue<'a> for bool {
-    fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
-        if length != Length::ONE {
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+        if header.length != Length::ONE {
             return Err(decoder.error(ErrorKind::Length { tag: Self::TAG }));
         }
 

diff --git a/der/src/asn1/context_specific.rs b/der/src/asn1/context_specific.rs
@@ -72,7 +72,7 @@ impl<T> ContextSpecific<T> {
     {
         Self::decode_with(decoder, tag_number, |decoder| {
             let header = Header::decode(decoder)?;
-            let value = T::decode_value(decoder, header.length)?;
+            let value = T::decode_value(decoder, header)?;
 
             if header.tag.is_constructed() != value.tag().is_constructed() {
                 return Err(header.tag.non_canonical_error());

diff --git a/der/src/asn1/generalized_time.rs b/der/src/asn1/generalized_time.rs
@@ -4,7 +4,8 @@ use crate::{
     asn1::Any,
     datetime::{self, DateTime},
     ord::OrdIsValueOrd,
-    ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, FixedTag, Length, Result, Tag,
+    ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, FixedTag, Header, Length, Result,
+    Tag,
 };
 use core::time::Duration;
 
@@ -73,8 +74,8 @@ impl GeneralizedTime {
 }
 
 impl DecodeValue<'_> for GeneralizedTime {
-    fn decode_value(decoder: &mut Decoder<'_>, length: Length) -> Result<Self> {
-        match *ByteSlice::decode_value(decoder, length)?.as_bytes() {
+    fn decode_value(decoder: &mut Decoder<'_>, header: Header) -> Result<Self> {
+        match *ByteSlice::decode_value(decoder, header)?.as_bytes() {
             // RFC 5280 requires mandatory seconds and Z-normalized time zone
             [y1, y2, y3, y4, mon1, mon2, day1, day2, hour1, hour2, min1, min2, sec1, sec2, b'Z'] => {
                 let year = datetime::decode_decimal(Self::TAG, y1, y2)? as u16 * 100
@@ -159,8 +160,8 @@ impl TryFrom<Any<'_>> for GeneralizedTime {
 }
 
 impl DecodeValue<'_> for DateTime {
-    fn decode_value(decoder: &mut Decoder<'_>, length: Length) -> Result<Self> {
-        Ok(GeneralizedTime::decode_value(decoder, length)?.into())
+    fn decode_value(decoder: &mut Decoder<'_>, header: Header) -> Result<Self> {
+        Ok(GeneralizedTime::decode_value(decoder, header)?.into())
     }
 }
 
@@ -183,8 +184,8 @@ impl OrdIsValueOrd for DateTime {}
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl DecodeValue<'_> for SystemTime {
-    fn decode_value(decoder: &mut Decoder<'_>, length: Length) -> Result<Self> {
-        Ok(GeneralizedTime::decode_value(decoder, length)?.into())
+    fn decode_value(decoder: &mut Decoder<'_>, header: Header) -> Result<Self> {
+        Ok(GeneralizedTime::decode_value(decoder, header)?.into())
     }
 }
 
@@ -259,8 +260,8 @@ impl OrdIsValueOrd for SystemTime {}
 #[cfg(feature = "time")]
 #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
 impl DecodeValue<'_> for PrimitiveDateTime {
-    fn decode_value(decoder: &mut Decoder<'_>, length: Length) -> Result<Self> {
-        GeneralizedTime::decode_value(decoder, length)?.try_into()
+    fn decode_value(decoder: &mut Decoder<'_>, header: Header) -> Result<Self> {
+        GeneralizedTime::decode_value(decoder, header)?.try_into()
     }
 }
 

diff --git a/der/src/asn1/ia5_string.rs b/der/src/asn1/ia5_string.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error,
-    FixedTag, Length, Result, StrSlice, Tag,
+    FixedTag, Header, Length, Result, StrSlice, Tag,
 };
 use core::{fmt, str};
 
@@ -74,8 +74,8 @@ impl AsRef<[u8]> for Ia5String<'_> {
 }
 
 impl<'a> DecodeValue<'a> for Ia5String<'a> {
-    fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
-        Self::new(ByteSlice::decode_value(decoder, length)?.as_bytes())
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+        Self::new(ByteSlice::decode_value(decoder, header)?.as_bytes())
     }
 }
 

diff --git a/der/src/asn1/integer.rs b/der/src/asn1/integer.rs
@@ -5,17 +5,17 @@ mod int;
 mod uint;
 
 use crate::{
-    asn1::Any, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, FixedTag, Length,
-    Result, Tag, ValueOrd,
+    asn1::Any, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, FixedTag, Header,
+    Length, Result, Tag, ValueOrd,
 };
 use core::{cmp::Ordering, mem};
 
 macro_rules! impl_int_encoding {
     ($($int:ty => $uint:ty),+) => {
         $(
             impl<'a> DecodeValue<'a> for $int {
-                fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
-                    let bytes = ByteSlice::decode_value(decoder, length)?.as_bytes();
+                fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+                    let bytes = ByteSlice::decode_value(decoder, header)?.as_bytes();
 
                     let result = if is_highest_bit_set(bytes) {
                         <$uint>::from_be_bytes(int::decode_to_array(bytes)?) as $int
@@ -24,7 +24,7 @@ macro_rules! impl_int_encoding {
                     };
 
                     // Ensure we compute the same encoded length as the original any value
-                    if length != result.value_len()? {
+                    if header.length != result.value_len()? {
                         return Err(Self::TAG.non_canonical_error());
                     }
 
@@ -75,12 +75,12 @@ macro_rules! impl_uint_encoding {
     ($($uint:ty),+) => {
         $(
             impl<'a> DecodeValue<'a> for $uint {
-                fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
-                    let bytes = ByteSlice::decode_value(decoder, length)?.as_bytes();
+                fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+                    let bytes = ByteSlice::decode_value(decoder, header)?.as_bytes();
                     let result = Self::from_be_bytes(uint::decode_to_array(bytes)?);
 
                     // Ensure we compute the same encoded length as the original any value
-                    if length != result.value_len()? {
+                    if header.length != result.value_len()? {
                         return Err(Self::TAG.non_canonical_error());
                     }
 

diff --git a/der/src/asn1/integer/bigint.rs b/der/src/asn1/integer/bigint.rs
@@ -3,7 +3,7 @@
 use super::uint;
 use crate::{
     asn1::Any, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, ErrorKind, FixedTag,
-    Length, Result, Tag,
+    Header, Length, Result, Tag,
 };
 
 /// "Big" unsigned ASN.1 `INTEGER` type.
@@ -46,12 +46,12 @@ impl<'a> UIntBytes<'a> {
 }
 
 impl<'a> DecodeValue<'a> for UIntBytes<'a> {
-    fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
-        let bytes = ByteSlice::decode_value(decoder, length)?.as_bytes();
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+        let bytes = ByteSlice::decode_value(decoder, header)?.as_bytes();
         let result = Self::new(uint::decode_to_slice(bytes)?)?;
 
         // Ensure we compute the same encoded length as the original any value.
-        if result.value_len()? != length {
+        if result.value_len()? != header.length {
             return Err(Self::TAG.non_canonical_error());
         }
 

diff --git a/der/src/asn1/null.rs b/der/src/asn1/null.rs
@@ -2,16 +2,16 @@
 
 use crate::{
     asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, Encodable, EncodeValue,
-    Encoder, Error, ErrorKind, FixedTag, Length, Result, Tag,
+    Encoder, Error, ErrorKind, FixedTag, Header, Length, Result, Tag,
 };
 
 /// ASN.1 `NULL` type.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Null;
 
 impl DecodeValue<'_> for Null {
-    fn decode_value(decoder: &mut Decoder<'_>, length: Length) -> Result<Self> {
-        if length.is_zero() {
+    fn decode_value(decoder: &mut Decoder<'_>, header: Header) -> Result<Self> {
+        if header.length.is_zero() {
             Ok(Null)
         } else {
             Err(decoder.error(ErrorKind::Length { tag: Self::TAG }))
@@ -64,8 +64,8 @@ impl<'a> From<()> for Any<'a> {
 }
 
 impl DecodeValue<'_> for () {
-    fn decode_value(decoder: &mut Decoder<'_>, length: Length) -> Result<Self> {
-        Null::decode_value(decoder, length)?;
+    fn decode_value(decoder: &mut Decoder<'_>, header: Header) -> Result<Self> {
+        Null::decode_value(decoder, header)?;
         Ok(())
     }
 }

diff --git a/der/src/asn1/octet_string.rs b/der/src/asn1/octet_string.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error,
-    ErrorKind, FixedTag, Length, Result, Tag,
+    ErrorKind, FixedTag, Header, Length, Result, Tag,
 };
 
 /// ASN.1 `OCTET STRING` type.
@@ -43,10 +43,9 @@ impl AsRef<[u8]> for OctetString<'_> {
 }
 
 impl<'a> DecodeValue<'a> for OctetString<'a> {
-    fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
-        Ok(Self {
-            inner: ByteSlice::decode_value(decoder, length)?,
-        })
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+        let inner = ByteSlice::decode_value(decoder, header)?;
+        Ok(Self { inner })
     }
 }
 

diff --git a/der/src/asn1/oid.rs b/der/src/asn1/oid.rs
@@ -2,13 +2,13 @@
 
 use crate::{
     asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error,
-    FixedTag, Length, Result, Tag, Tagged,
+    FixedTag, Header, Length, Result, Tag, Tagged,
 };
 use const_oid::ObjectIdentifier;
 
 impl DecodeValue<'_> for ObjectIdentifier {
-    fn decode_value(decoder: &mut Decoder<'_>, length: Length) -> Result<Self> {
-        let bytes = ByteSlice::decode_value(decoder, length)?.as_bytes();
+    fn decode_value(decoder: &mut Decoder<'_>, header: Header) -> Result<Self> {
+        let bytes = ByteSlice::decode_value(decoder, header)?.as_bytes();
         Ok(Self::from_bytes(bytes)?)
     }
 }

diff --git a/der/src/asn1/printable_string.rs b/der/src/asn1/printable_string.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error,
-    FixedTag, Length, Result, StrSlice, Tag,
+    FixedTag, Header, Length, Result, StrSlice, Tag,
 };
 use core::{fmt, str};
 
@@ -107,8 +107,8 @@ impl AsRef<[u8]> for PrintableString<'_> {
 }
 
 impl<'a> DecodeValue<'a> for PrintableString<'a> {
-    fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
-        Self::new(ByteSlice::decode_value(decoder, length)?.as_bytes())
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
+        Self::new(ByteSlice::decode_value(decoder, header)?.as_bytes())
     }
 }
 

diff --git a/der/src/asn1/sequence.rs b/der/src/asn1/sequence.rs
@@ -2,8 +2,8 @@
 //! `SEQUENCE`s to Rust structs.
 
 use crate::{
-    ByteSlice, Decodable, DecodeValue, Decoder, Encodable, EncodeValue, Encoder, FixedTag, Length,
-    Result, Tag,
+    ByteSlice, Decodable, DecodeValue, Decoder, Encodable, EncodeValue, Encoder, FixedTag, Header,
+    Length, Result, Tag,
 };
 
 /// ASN.1 `SEQUENCE` trait.
@@ -75,9 +75,9 @@ impl<'a> SequenceRef<'a> {
 }
 
 impl<'a> DecodeValue<'a> for SequenceRef<'a> {
-    fn decode_value(decoder: &mut Decoder<'a>, length: Length) -> Result<Self> {
+    fn decode_value(decoder: &mut Decoder<'a>, header: Header) -> Result<Self> {
         let offset = decoder.position();
-        let body = ByteSlice::decode_value(decoder, length)?;
+        let body = ByteSlice::decode_value(decoder, header)?;
         Ok(Self { body, offset })
     }
 }