RustCrypto · tarcieri · Apr 25, 2022 · Apr 24, 2022
diff --git a/der/derive/src/choice.rs b/der/derive/src/choice.rs
@@ -109,7 +109,7 @@ impl DeriveChoice {
             }
 
             impl<#lt_params> ::der::EncodeValue for #ident<#lt_params> {
-                fn encode_value(&self, encoder: &mut ::der::Encoder<'_>) -> ::der::Result<()> {
+                fn encode_value(&self, encoder: &mut dyn ::der::Writer) -> ::der::Result<()> {
                     match self {
                         #(#encode_body)*
                     }

diff --git a/der/derive/src/enumerated.rs b/der/derive/src/enumerated.rs
@@ -129,7 +129,7 @@ impl DeriveEnumerated {
                     ::der::EncodeValue::value_len(&(*self as #repr))
                 }
 
-                fn encode_value(&self, encoder: &mut ::der::Encoder<'_>) -> ::der::Result<()> {
+                fn encode_value(&self, encoder: &mut dyn ::der::Writer) -> ::der::Result<()> {
                     ::der::EncodeValue::encode_value(&(*self as #repr), encoder)
                 }
             }

diff --git a/der/derive/src/newtype.rs b/der/derive/src/newtype.rs
@@ -103,7 +103,7 @@ impl DeriveNewtype {
             }
 
             #limpl ::der::EncodeValue for #ltype {
-                fn encode_value(&self, encoder: &mut ::der::Encoder<'_>) -> ::der::Result<()> {
+                fn encode_value(&self, encoder: &mut dyn ::der::Writer) -> ::der::Result<()> {
                     self.0.encode_value(encoder)
                 }
 

diff --git a/der/src/asn1/any.rs b/der/src/asn1/any.rs
@@ -1,7 +1,7 @@
 //! ASN.1 `ANY` type.
 
 use crate::{
-    asn1::*, ByteSlice, Choice, Decode, DecodeValue, Decoder, DerOrd, EncodeValue, Encoder, Error,
+    asn1::*, ByteSlice, Choice, Decode, DecodeValue, Decoder, DerOrd, EncodeValue, Error,
     ErrorKind, FixedTag, Header, Length, Result, Tag, Tagged, ValueOrd, Writer,
 };
 use core::cmp::Ordering;
@@ -167,8 +167,8 @@ impl EncodeValue for Any<'_> {
         Ok(self.value.len())
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        encoder.write(self.value())
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        writer.write(self.value())
     }
 }
 

diff --git a/der/src/asn1/bit_string.rs b/der/src/asn1/bit_string.rs
@@ -1,8 +1,8 @@
 //! ASN.1 `BIT STRING` support.
 
 use crate::{
-    asn1::Any, ByteSlice, DecodeValue, Decoder, DerOrd, EncodeValue, Encoder, Error, ErrorKind,
-    FixedTag, Header, Length, Reader, Result, Tag, ValueOrd, Writer,
+    asn1::Any, ByteSlice, DecodeValue, Decoder, DerOrd, EncodeValue, Error, ErrorKind, FixedTag,
+    Header, Length, Reader, Result, Tag, ValueOrd, Writer,
 };
 use core::{cmp::Ordering, iter::FusedIterator};
 
@@ -133,9 +133,9 @@ impl EncodeValue for BitString<'_> {
         self.byte_len() + Length::ONE
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        encoder.write_byte(self.unused_bits)?;
-        encoder.write(self.raw_bytes())
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        writer.write_byte(self.unused_bits)?;
+        writer.write(self.raw_bytes())
     }
 }
 
@@ -290,10 +290,10 @@ where
         BitString::new((lead % 8) as u8, buff)?.value_len()
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
         let (lead, buff) = encode_flagset(self);
         let buff = &buff[..buff.len() - lead / 8];
-        BitString::new((lead % 8) as u8, buff)?.encode_value(encoder)
+        BitString::new((lead % 8) as u8, buff)?.encode_value(writer)
     }
 }
 

diff --git a/der/src/asn1/boolean.rs b/der/src/asn1/boolean.rs
@@ -1,8 +1,8 @@
 //! ASN.1 `BOOLEAN` support.
 
 use crate::{
-    asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error,
-    ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, Writer,
+    asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Error, ErrorKind,
+    FixedTag, Header, Length, Reader, Result, Tag, Writer,
 };
 
 /// Byte used to encode `true` in ASN.1 DER. From X.690 Section 11.1:
@@ -33,8 +33,8 @@ impl EncodeValue for bool {
         Ok(Length::ONE)
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        encoder.write_byte(if *self { TRUE_OCTET } else { FALSE_OCTET })
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        writer.write_byte(if *self { TRUE_OCTET } else { FALSE_OCTET })
     }
 }
 

diff --git a/der/src/asn1/context_specific.rs b/der/src/asn1/context_specific.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     asn1::Any, Choice, Decode, DecodeValue, Decoder, DerOrd, Encode, EncodeValue, EncodeValueRef,
-    Encoder, Error, Header, Length, Reader, Result, Tag, TagMode, TagNumber, Tagged, ValueOrd,
+    Error, Header, Length, Reader, Result, Tag, TagMode, TagNumber, Tagged, ValueOrd, Writer,
 };
 use core::cmp::Ordering;
 
@@ -141,10 +141,10 @@ where
         }
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
         match self.tag_mode {
-            TagMode::Explicit => self.value.encode(encoder),
-            TagMode::Implicit => self.value.encode_value(encoder),
+            TagMode::Explicit => self.value.encode(writer),
+            TagMode::Implicit => self.value.encode_value(writer),
         }
     }
 }
@@ -235,8 +235,8 @@ where
         self.encoder().value_len()
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        self.encoder().encode_value(encoder)
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        self.encoder().encode_value(writer)
     }
 }
 

diff --git a/der/src/asn1/generalized_time.rs b/der/src/asn1/generalized_time.rs
@@ -4,8 +4,8 @@ use crate::{
     asn1::Any,
     datetime::{self, DateTime},
     ord::OrdIsValueOrd,
-    ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, ErrorKind, FixedTag, Header,
-    Length, Result, Tag, Writer,
+    ByteSlice, DecodeValue, Decoder, EncodeValue, Error, ErrorKind, FixedTag, Header, Length,
+    Result, Tag, Writer,
 };
 use core::time::Duration;
 
@@ -104,18 +104,18 @@ impl EncodeValue for GeneralizedTime {
         Ok(Self::LENGTH)
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
         let year_hi = u8::try_from(self.0.year() / 100)?;
         let year_lo = u8::try_from(self.0.year() % 100)?;
 
-        datetime::encode_decimal(encoder, Self::TAG, year_hi)?;
-        datetime::encode_decimal(encoder, Self::TAG, year_lo)?;
-        datetime::encode_decimal(encoder, Self::TAG, self.0.month())?;
-        datetime::encode_decimal(encoder, Self::TAG, self.0.day())?;
-        datetime::encode_decimal(encoder, Self::TAG, self.0.hour())?;
-        datetime::encode_decimal(encoder, Self::TAG, self.0.minutes())?;
-        datetime::encode_decimal(encoder, Self::TAG, self.0.seconds())?;
-        encoder.write_byte(b'Z')
+        datetime::encode_decimal(writer, Self::TAG, year_hi)?;
+        datetime::encode_decimal(writer, Self::TAG, year_lo)?;
+        datetime::encode_decimal(writer, Self::TAG, self.0.month())?;
+        datetime::encode_decimal(writer, Self::TAG, self.0.day())?;
+        datetime::encode_decimal(writer, Self::TAG, self.0.hour())?;
+        datetime::encode_decimal(writer, Self::TAG, self.0.minutes())?;
+        datetime::encode_decimal(writer, Self::TAG, self.0.seconds())?;
+        writer.write_byte(b'Z')
     }
 }
 
@@ -174,8 +174,8 @@ impl EncodeValue for DateTime {
         GeneralizedTime::from(self).value_len()
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        GeneralizedTime::from(self).encode_value(encoder)
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        GeneralizedTime::from(self).encode_value(writer)
     }
 }
 
@@ -200,8 +200,8 @@ impl EncodeValue for SystemTime {
         GeneralizedTime::try_from(self)?.value_len()
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        GeneralizedTime::try_from(self)?.encode_value(encoder)
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        GeneralizedTime::try_from(self)?.encode_value(writer)
     }
 }
 
@@ -276,8 +276,8 @@ impl EncodeValue for PrimitiveDateTime {
         GeneralizedTime::try_from(self)?.value_len()
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        GeneralizedTime::try_from(self)?.encode_value(encoder)
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        GeneralizedTime::try_from(self)?.encode_value(writer)
     }
 }
 

diff --git a/der/src/asn1/ia5_string.rs b/der/src/asn1/ia5_string.rs
@@ -1,8 +1,8 @@
 //! ASN.1 `IA5String` support.
 
 use crate::{
-    asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error,
-    FixedTag, Header, Length, Result, StrSlice, Tag,
+    asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Error, FixedTag,
+    Header, Length, Result, StrSlice, Tag, Writer,
 };
 use core::{fmt, str};
 
@@ -84,8 +84,8 @@ impl EncodeValue for Ia5String<'_> {
         self.inner.value_len()
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        self.inner.encode_value(encoder)
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+        self.inner.encode_value(writer)
     }
 }
 

diff --git a/der/src/asn1/integer.rs b/der/src/asn1/integer.rs
@@ -6,7 +6,7 @@ pub(super) mod uint;
 
 use crate::{
     asn1::Any, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, FixedTag, Header,
-    Length, Result, Tag, ValueOrd,
+    Length, Result, Tag, ValueOrd, Writer,
 };
 use core::{cmp::Ordering, mem};
 
@@ -41,11 +41,11 @@ macro_rules! impl_int_encoding {
                     }
                 }
 
-                fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
+                fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
                     if *self < 0 {
-                        int::encode_bytes(encoder, &(*self as $uint).to_be_bytes())
+                        int::encode_bytes(writer, &(*self as $uint).to_be_bytes())
                     } else {
-                        uint::encode_bytes(encoder, &self.to_be_bytes())
+                        uint::encode_bytes(writer, &self.to_be_bytes())
                     }
                 }
             }
@@ -93,8 +93,8 @@ macro_rules! impl_uint_encoding {
                     uint::encoded_len(&self.to_be_bytes())
                 }
 
-                fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-                    uint::encode_bytes(encoder, &self.to_be_bytes())
+                fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
+                    uint::encode_bytes(writer, &self.to_be_bytes())
                 }
             }
 

diff --git a/der/src/asn1/integer/bigint.rs b/der/src/asn1/integer/bigint.rs
@@ -2,8 +2,8 @@
 
 use super::uint;
 use crate::{
-    asn1::Any, ByteSlice, DecodeValue, Decoder, EncodeValue, Encoder, Error, ErrorKind, FixedTag,
-    Header, Length, Result, Tag, Writer,
+    asn1::Any, ByteSlice, DecodeValue, Decoder, EncodeValue, Error, ErrorKind, FixedTag, Header,
+    Length, Result, Tag, Writer,
 };
 
 /// "Big" unsigned ASN.1 `INTEGER` type.
@@ -64,13 +64,13 @@ impl<'a> EncodeValue for UIntBytes<'a> {
         uint::encoded_len(self.inner.as_slice())
     }
 
-    fn encode_value(&self, encoder: &mut Encoder<'_>) -> Result<()> {
+    fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> {
         // Add leading `0x00` byte if required
         if self.value_len()? > self.len() {
-            encoder.write_byte(0)?;
+            writer.write_byte(0)?;
         }
 
-        encoder.write(self.as_bytes())
+        writer.write(self.as_bytes())
     }
 }
 

diff --git a/der/src/asn1/integer/int.rs b/der/src/asn1/integer/int.rs
@@ -1,7 +1,7 @@
 //! Support for encoding negative integers
 
 use super::is_highest_bit_set;
-use crate::{Encoder, ErrorKind, Length, Result, Writer};
+use crate::{ErrorKind, Length, Result, Writer};
 
 /// Decode an unsigned integer of the specified size.
 ///
@@ -27,8 +27,11 @@ pub(super) fn decode_to_array<const N: usize>(bytes: &[u8]) -> Result<[u8; N]> {
 }
 
 /// Encode the given big endian bytes representing an integer as ASN.1 DER.
-pub(super) fn encode_bytes(encoder: &mut Encoder<'_>, bytes: &[u8]) -> Result<()> {
-    encoder.write(strip_leading_ones(bytes))
+pub(super) fn encode_bytes<W>(writer: &mut W, bytes: &[u8]) -> Result<()>
+where
+    W: Writer + ?Sized,
+{
+    writer.write(strip_leading_ones(bytes))
 }
 
 /// Get the encoded length for the given unsigned integer serialized as bytes.

diff --git a/der/src/asn1/integer/uint.rs b/der/src/asn1/integer/uint.rs
@@ -1,6 +1,6 @@
 //! Unsigned integer decoders/encoders.
 
-use crate::{Encoder, Length, Result, Tag, Writer};
+use crate::{Length, Result, Tag, Writer};
 
 /// Decode an unsigned integer into a big endian byte slice with all leading
 /// zeroes removed.
@@ -40,7 +40,10 @@ pub(super) fn decode_to_array<const N: usize>(bytes: &[u8]) -> Result<[u8; N]> {
 }
 
 /// Encode the given big endian bytes representing an integer as ASN.1 DER.
-pub(crate) fn encode_bytes(encoder: &mut Encoder<'_>, bytes: &[u8]) -> Result<()> {
+pub(crate) fn encode_bytes<W>(encoder: &mut W, bytes: &[u8]) -> Result<()>
+where
+    W: Writer + ?Sized,
+{
     let bytes = strip_leading_zeroes(bytes);
 
     if needs_leading_zero(bytes) {

diff --git a/der/src/asn1/null.rs b/der/src/asn1/null.rs
@@ -1,8 +1,8 @@
 //! ASN.1 `NULL` support.
 
 use crate::{
-    asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, Encode, EncodeValue, Encoder,
-    Error, ErrorKind, FixedTag, Header, Length, Result, Tag,
+    asn1::Any, ord::OrdIsValueOrd, ByteSlice, DecodeValue, Decoder, EncodeValue, Error, ErrorKind,
+    FixedTag, Header, Length, Result, Tag, Writer,
 };
 
 /// ASN.1 `NULL` type.
@@ -24,7 +24,7 @@ impl EncodeValue for Null {
         Ok(Length::ZERO)
     }
 
-    fn encode_value(&self, _encoder: &mut Encoder<'_>) -> Result<()> {
+    fn encode_value(&self, _writer: &mut dyn Writer) -> Result<()> {
         Ok(())
     }
 }
@@ -70,13 +70,13 @@ impl DecodeValue<'_> for () {
     }
 }
 
-impl Encode for () {
-    fn encoded_len(&self) -> Result<Length> {
-        Null.encoded_len()
+impl EncodeValue for () {
+    fn value_len(&self) -> Result<Length> {
+        Ok(Length::ZERO)
     }
 
-    fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> {
-        Null.encode(encoder)
+    fn encode_value(&self, _writer: &mut dyn Writer) -> Result<()> {
+        Ok(())
     }
 }