From 64707007b91de98079b7500438cdc0421e1bfc16 Mon Sep 17 00:00:00 2001 From: Tony Arcieri Date: Sun, 8 May 2022 07:42:07 -0600 Subject: [PATCH] der: rename `SliceReader`/`SliceWriter` Renames the following types: - `Decoder` => `SliceReader` - `Encoder` => `SliceWriter` --- der/src/asn1/any.rs | 16 ++++----- der/src/asn1/context_specific.rs | 26 +++++++------- der/src/asn1/generalized_time.rs | 4 +-- der/src/asn1/integer.rs | 8 ++--- der/src/asn1/integer/bigint.rs | 4 +-- der/src/asn1/utc_time.rs | 4 +-- der/src/decode.rs | 12 +++---- der/src/document.rs | 6 ++-- der/src/encode.rs | 16 ++++----- der/src/length.rs | 6 ++-- der/src/lib.rs | 21 ++++------- der/src/reader.rs | 2 +- der/src/{decoder.rs => reader/slice.rs} | 46 ++++++++++++------------- der/src/writer.rs | 1 + der/src/{encoder.rs => writer/slice.rs} | 34 +++++++----------- der/tests/datetime.rs | 2 +- der/tests/derive.rs | 18 +++++----- pkcs5/tests/pbes2.rs | 6 ++-- pkcs7/src/content_info.rs | 8 ++--- pkcs7/tests/content_tests.rs | 4 +-- x509-cert/tests/trust_anchor_format.rs | 10 +++--- 21 files changed, 119 insertions(+), 135 deletions(-) rename der/src/{decoder.rs => reader/slice.rs} (79%) rename der/src/{encoder.rs => writer/slice.rs} (80%) diff --git a/der/src/asn1/any.rs b/der/src/asn1/any.rs index 865dc7868..717d666b8 100644 --- a/der/src/asn1/any.rs +++ b/der/src/asn1/any.rs @@ -1,8 +1,8 @@ //! ASN.1 `ANY` type. use crate::{ - asn1::*, ByteSlice, Choice, Decode, DecodeValue, Decoder, DerOrd, EncodeValue, Error, - ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, Tagged, ValueOrd, Writer, + asn1::*, ByteSlice, Choice, Decode, DecodeValue, DerOrd, EncodeValue, Error, ErrorKind, + FixedTag, Header, Length, Reader, Result, SliceReader, Tag, Tagged, ValueOrd, Writer, }; use core::cmp::Ordering; @@ -66,7 +66,7 @@ impl<'a> AnyRef<'a> { length: self.value.len(), }; - let mut decoder = Decoder::new(self.value())?; + let mut decoder = SliceReader::new(self.value())?; let result = T::decode_value(&mut decoder, header)?; decoder.finish(result) } @@ -129,15 +129,15 @@ impl<'a> AnyRef<'a> { } /// Attempt to decode this value an ASN.1 `SEQUENCE`, creating a new - /// nested [`Decoder`] and calling the provided argument with it. + /// nested reader and calling the provided argument with it. pub fn sequence(self, f: F) -> Result where - F: FnOnce(&mut Decoder<'a>) -> Result, + F: FnOnce(&mut SliceReader<'a>) -> Result, { self.tag.assert_eq(Tag::Sequence)?; - let mut seq_decoder = Decoder::new(self.value.as_slice())?; - let result = f(&mut seq_decoder)?; - seq_decoder.finish(result) + let mut reader = SliceReader::new(self.value.as_slice())?; + let result = f(&mut reader)?; + reader.finish(result) } /// Attempt to decode an ASN.1 `UTCTime`. diff --git a/der/src/asn1/context_specific.rs b/der/src/asn1/context_specific.rs index 7f0f36188..311b5fe74 100644 --- a/der/src/asn1/context_specific.rs +++ b/der/src/asn1/context_specific.rs @@ -256,7 +256,7 @@ where #[cfg(test)] mod tests { use super::ContextSpecific; - use crate::{asn1::BitStringRef, Decode, Decoder, Encode, TagMode, TagNumber}; + use crate::{asn1::BitStringRef, Decode, Encode, SliceReader, TagMode, TagNumber}; use hex_literal::hex; // Public key data from `pkcs8` crate's `ed25519-pkcs8-v2.der` @@ -282,22 +282,22 @@ mod tests { let tag_number = TagNumber::new(0); // Empty message - let mut decoder = Decoder::new(&[]).unwrap(); + let mut reader = SliceReader::new(&[]).unwrap(); assert_eq!( - ContextSpecific::::decode_explicit(&mut decoder, tag_number).unwrap(), + ContextSpecific::::decode_explicit(&mut reader, tag_number).unwrap(), None ); // Message containing a non-context-specific type - let mut decoder = Decoder::new(&hex!("020100")).unwrap(); + let mut reader = SliceReader::new(&hex!("020100")).unwrap(); assert_eq!( - ContextSpecific::::decode_explicit(&mut decoder, tag_number).unwrap(), + ContextSpecific::::decode_explicit(&mut reader, tag_number).unwrap(), None ); // Message containing an EXPLICIT context-specific field - let mut decoder = Decoder::new(&hex!("A003020100")).unwrap(); - let field = ContextSpecific::::decode_explicit(&mut decoder, tag_number) + let mut reader = SliceReader::new(&hex!("A003020100")).unwrap(); + let field = ContextSpecific::::decode_explicit(&mut reader, tag_number) .unwrap() .unwrap(); @@ -319,8 +319,8 @@ mod tests { let tag_number = TagNumber::new(1); - let mut decoder = Decoder::new(&context_specific_implicit_bytes).unwrap(); - let field = ContextSpecific::>::decode_implicit(&mut decoder, tag_number) + let mut reader = SliceReader::new(&context_specific_implicit_bytes).unwrap(); + let field = ContextSpecific::>::decode_implicit(&mut reader, tag_number) .unwrap() .unwrap(); @@ -335,8 +335,8 @@ mod tests { #[test] fn context_specific_skipping_unknown_field() { let tag = TagNumber::new(1); - let mut decoder = Decoder::new(&hex!("A003020100A103020101")).unwrap(); - let field = ContextSpecific::::decode_explicit(&mut decoder, tag) + let mut reader = SliceReader::new(&hex!("A003020100A103020101")).unwrap(); + let field = ContextSpecific::::decode_explicit(&mut reader, tag) .unwrap() .unwrap(); assert_eq!(field.value, 1); @@ -345,9 +345,9 @@ mod tests { #[test] fn context_specific_returns_none_on_greater_tag_number() { let tag = TagNumber::new(0); - let mut decoder = Decoder::new(&hex!("A103020101")).unwrap(); + let mut reader = SliceReader::new(&hex!("A103020101")).unwrap(); assert_eq!( - ContextSpecific::::decode_explicit(&mut decoder, tag).unwrap(), + ContextSpecific::::decode_explicit(&mut reader, tag).unwrap(), None ); } diff --git a/der/src/asn1/generalized_time.rs b/der/src/asn1/generalized_time.rs index c7a35545c..9950e368e 100644 --- a/der/src/asn1/generalized_time.rs +++ b/der/src/asn1/generalized_time.rs @@ -331,7 +331,7 @@ impl TryFrom for PrimitiveDateTime { #[cfg(test)] mod tests { use super::GeneralizedTime; - use crate::{Decode, Encode, Encoder}; + use crate::{Decode, Encode, SliceWriter}; use hex_literal::hex; #[test] @@ -341,7 +341,7 @@ mod tests { assert_eq!(utc_time.to_unix_duration().as_secs(), 673573540); let mut buf = [0u8; 128]; - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); utc_time.encode(&mut encoder).unwrap(); assert_eq!(example_bytes, encoder.finish().unwrap()); } diff --git a/der/src/asn1/integer.rs b/der/src/asn1/integer.rs index 1fc506958..20e2f018f 100644 --- a/der/src/asn1/integer.rs +++ b/der/src/asn1/integer.rs @@ -5,8 +5,8 @@ pub(super) mod int; pub(super) mod uint; use crate::{ - asn1::AnyRef, ByteSlice, DecodeValue, EncodeValue, Encoder, Error, FixedTag, Header, Length, - Reader, Result, Tag, ValueOrd, Writer, + asn1::AnyRef, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, Length, Reader, + Result, SliceWriter, Tag, ValueOrd, Writer, }; use core::{cmp::Ordering, mem}; @@ -140,11 +140,11 @@ where debug_assert!(mem::size_of::() <= MAX_INT_SIZE); let mut buf1 = [0u8; MAX_INT_SIZE]; - let mut encoder1 = Encoder::new(&mut buf1); + let mut encoder1 = SliceWriter::new(&mut buf1); a.encode_value(&mut encoder1)?; let mut buf2 = [0u8; MAX_INT_SIZE]; - let mut encoder2 = Encoder::new(&mut buf2); + let mut encoder2 = SliceWriter::new(&mut buf2); b.encode_value(&mut encoder2)?; Ok(encoder1.finish()?.cmp(encoder2.finish()?)) diff --git a/der/src/asn1/integer/bigint.rs b/der/src/asn1/integer/bigint.rs index a42d3e6be..7a73c480a 100644 --- a/der/src/asn1/integer/bigint.rs +++ b/der/src/asn1/integer/bigint.rs @@ -97,7 +97,7 @@ mod tests { use super::UIntRef; use crate::{ asn1::{integer::tests::*, AnyRef}, - Decode, Encode, Encoder, ErrorKind, Tag, + Decode, Encode, ErrorKind, SliceWriter, Tag, }; #[test] @@ -131,7 +131,7 @@ mod tests { let uint = UIntRef::from_der(example).unwrap(); let mut buf = [0u8; 128]; - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); uint.encode(&mut encoder).unwrap(); let result = encoder.finish().unwrap(); diff --git a/der/src/asn1/utc_time.rs b/der/src/asn1/utc_time.rs index 02755c010..7c2381155 100644 --- a/der/src/asn1/utc_time.rs +++ b/der/src/asn1/utc_time.rs @@ -198,7 +198,7 @@ impl TryFrom> for UtcTime { #[cfg(test)] mod tests { use super::UtcTime; - use crate::{Decode, Encode, Encoder}; + use crate::{Decode, Encode, SliceWriter}; use hex_literal::hex; #[test] @@ -208,7 +208,7 @@ mod tests { assert_eq!(utc_time.to_unix_duration().as_secs(), 673573540); let mut buf = [0u8; 128]; - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); utc_time.encode(&mut encoder).unwrap(); assert_eq!(example_bytes, encoder.finish().unwrap()); } diff --git a/der/src/decode.rs b/der/src/decode.rs index a84c2115b..1c63b322a 100644 --- a/der/src/decode.rs +++ b/der/src/decode.rs @@ -1,6 +1,6 @@ //! Trait definition for [`Decode`]. -use crate::{Decoder, FixedTag, Header, Reader, Result}; +use crate::{FixedTag, Header, Reader, Result, SliceReader}; #[cfg(feature = "pem")] use crate::{pem::PemLabel, PemReader}; @@ -18,9 +18,9 @@ pub trait Decode<'a>: Sized { /// Parse `Self` from the provided DER-encoded byte slice. fn from_der(bytes: &'a [u8]) -> Result { - let mut decoder = Decoder::new(bytes)?; - let result = Self::decode(&mut decoder)?; - decoder.finish(result) + let mut reader = SliceReader::new(bytes)?; + let result = Self::decode(&mut reader)?; + reader.finish(result) } } @@ -71,6 +71,6 @@ impl DecodePem for T { /// Decode the value part of a Tag-Length-Value encoded field, sans the [`Tag`] /// and [`Length`]. pub trait DecodeValue<'a>: Sized { - /// Attempt to decode this message using the provided [`Decoder`]. - fn decode_value>(decoder: &mut R, header: Header) -> Result; + /// Attempt to decode this message using the provided [`Reader`]. + fn decode_value>(reader: &mut R, header: Header) -> Result; } diff --git a/der/src/document.rs b/der/src/document.rs index 5c44103d5..aa953cd46 100644 --- a/der/src/document.rs +++ b/der/src/document.rs @@ -1,6 +1,6 @@ //! ASN.1 DER-encoded documents stored on the heap. -use crate::{Decode, Decoder, Encode, Error, FixedTag, Length, Reader, Result, Tag, Writer}; +use crate::{Decode, Encode, Error, FixedTag, Length, Reader, Result, SliceReader, Tag, Writer}; use alloc::vec::Vec; use core::fmt::{self, Debug}; @@ -187,7 +187,7 @@ impl TryFrom> for Document { type Error = Error; fn try_from(der_bytes: Vec) -> Result { - let mut decoder = Decoder::new(&der_bytes)?; + let mut decoder = SliceReader::new(&der_bytes)?; decode_sequence(&mut decoder)?; decoder.finish(())?; @@ -331,7 +331,7 @@ impl ZeroizeOnDrop for SecretDocument {} /// Attempt to decode a ASN.1 `SEQUENCE` from the given decoder, returning the /// entire sequence including the header. -fn decode_sequence<'a>(decoder: &mut Decoder<'a>) -> Result<&'a [u8]> { +fn decode_sequence<'a>(decoder: &mut SliceReader<'a>) -> Result<&'a [u8]> { let header = decoder.peek_header()?; header.tag.assert_eq(Tag::Sequence)?; diff --git a/der/src/encode.rs b/der/src/encode.rs index e092d3e38..4db2c342d 100644 --- a/der/src/encode.rs +++ b/der/src/encode.rs @@ -1,6 +1,6 @@ //! Trait definition for [`Encode`]. -use crate::{Encoder, Header, Length, Result, Tagged, Writer}; +use crate::{Header, Length, Result, SliceWriter, Tagged, Writer}; #[cfg(feature = "alloc")] use {alloc::vec::Vec, core::iter}; @@ -23,15 +23,15 @@ pub trait Encode { /// Compute the length of this value in bytes when encoded as ASN.1 DER. fn encoded_len(&self) -> Result; - /// Encode this value as ASN.1 DER using the provided [`Encoder`]. + /// Encode this value as ASN.1 DER using the provided [`Writer`]. fn encode(&self, encoder: &mut dyn Writer) -> Result<()>; /// Encode this value to the provided byte slice, returning a sub-slice /// containing the encoded message. fn encode_to_slice<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8]> { - let mut encoder = Encoder::new(buf); - self.encode(&mut encoder)?; - encoder.finish() + let mut writer = SliceWriter::new(buf); + self.encode(&mut writer)?; + writer.finish() } /// Encode this message as ASN.1 DER, appending it to the provided @@ -43,7 +43,7 @@ pub trait Encode { buf.reserve(expected_len); buf.extend(iter::repeat(0).take(expected_len)); - let mut encoder = Encoder::new(buf); + let mut encoder = SliceWriter::new(buf); self.encode(&mut encoder)?; let actual_len = encoder.finish()?.len(); @@ -77,7 +77,7 @@ where self.value_len().and_then(|len| len.for_tlv()) } - /// Encode this value as ASN.1 DER using the provided [`Encoder`]. + /// Encode this value as ASN.1 DER using the provided [`Writer`]. fn encode(&self, writer: &mut dyn Writer) -> Result<()> { self.header()?.encode(writer)?; self.encode_value(writer) @@ -128,6 +128,6 @@ pub trait EncodeValue { fn value_len(&self) -> Result; /// Encode value (sans [`Tag`]+[`Length`] header) as ASN.1 DER using the - /// provided [`Encoder`]. + /// provided [`Writer`]. fn encode_value(&self, encoder: &mut dyn Writer) -> Result<()>; } diff --git a/der/src/length.rs b/der/src/length.rs index fb6162bc8..76ee0e997 100644 --- a/der/src/length.rs +++ b/der/src/length.rs @@ -1,6 +1,6 @@ //! Length calculations for encoded ASN.1 DER values -use crate::{Decode, DerOrd, Encode, Encoder, Error, ErrorKind, Reader, Result, Writer}; +use crate::{Decode, DerOrd, Encode, Error, ErrorKind, Reader, Result, SliceWriter, Writer}; use core::{ cmp::Ordering, fmt, @@ -270,10 +270,10 @@ impl DerOrd for Length { let mut buf1 = [0u8; MAX_DER_OCTETS]; let mut buf2 = [0u8; MAX_DER_OCTETS]; - let mut encoder1 = Encoder::new(&mut buf1); + let mut encoder1 = SliceWriter::new(&mut buf1); encoder1.encode(self)?; - let mut encoder2 = Encoder::new(&mut buf2); + let mut encoder2 = SliceWriter::new(&mut buf2); encoder2.encode(other)?; Ok(encoder1.finish()?.cmp(encoder2.finish()?)) diff --git a/der/src/lib.rs b/der/src/lib.rs index d569287f4..be04147c0 100644 --- a/der/src/lib.rs +++ b/der/src/lib.rs @@ -27,9 +27,9 @@ //! # Usage //! ## [`Decode`] and [`Encode`] traits -//! The [`Decode`] and [`Encode`] traits are the core abstractions on -//! which this crate is built and control what types can be (de)serialized -//! as ASN.1 DER. +//! The [`Decode`] and [`Encode`] traits provide the decoding/encoding API +//! respectively, and are designed to work in conjunction with concrete ASN.1 +//! types, including all types which impl the [`Sequence`] trait. //! //! The traits are impl'd for the following Rust core types: //! - `()`: ASN.1 `NULL`. See also [`Null`]. @@ -81,11 +81,6 @@ //! of the [`Encode`] trait, so any type which impls [`Sequence`] can be //! used for both decoding and encoding. //! -//! The [`Decoder`] and [`Encoder`] types provide the decoding/encoding API -//! respectively, and are designed to work in conjunction with concrete ASN.1 -//! types which impl the [`Decode`] and [`Encode`] traits, including -//! all types which impl the [`Sequence`] trait. -//! //! The following code example shows how to define a struct which maps to the //! above schema, as well as impl the [`Sequence`] trait for that struct: //! @@ -97,7 +92,7 @@ //! // "heapless" usage when the `alloc` feature is disabled. //! use der::{ //! asn1::{AnyRef, ObjectIdentifier}, -//! DecodeValue, Decode, Decoder, Encode, Header, Reader, Sequence +//! DecodeValue, Decode, SliceReader, Encode, Header, Reader, Sequence //! }; //! //! /// X.509 `AlgorithmIdentifier`. @@ -347,10 +342,8 @@ pub(crate) mod arrayvec; mod byte_slice; mod datetime; mod decode; -mod decoder; mod encode; mod encode_ref; -mod encoder; mod error; mod header; mod length; @@ -367,17 +360,15 @@ pub use crate::{ asn1::{AnyRef, Choice, Sequence}, datetime::DateTime, decode::{Decode, DecodeOwned, DecodeValue}, - decoder::Decoder, encode::{Encode, EncodeValue}, encode_ref::{EncodeRef, EncodeValueRef}, - encoder::Encoder, error::{Error, ErrorKind, Result}, header::Header, length::Length, ord::{DerOrd, ValueOrd}, - reader::Reader, + reader::{slice::SliceReader, Reader}, tag::{Class, FixedTag, Tag, TagMode, TagNumber, Tagged}, - writer::Writer, + writer::{slice::SliceWriter, Writer}, }; #[cfg(feature = "alloc")] diff --git a/der/src/reader.rs b/der/src/reader.rs index 1d6fcf800..b917323c2 100644 --- a/der/src/reader.rs +++ b/der/src/reader.rs @@ -1,9 +1,9 @@ //! Reader trait. mod nested; - #[cfg(feature = "pem")] pub(crate) mod pem; +pub(crate) mod slice; pub(crate) use nested::NestedReader; diff --git a/der/src/decoder.rs b/der/src/reader/slice.rs similarity index 79% rename from der/src/decoder.rs rename to der/src/reader/slice.rs index 71271e0da..6bab091f3 100644 --- a/der/src/decoder.rs +++ b/der/src/reader/slice.rs @@ -1,10 +1,10 @@ -//! DER decoder. +//! Slice reader. use crate::{ByteSlice, Decode, Error, ErrorKind, Header, Length, Reader, Result, Tag}; -/// DER decoder. +/// [`Reader`] which consumes an input byte slice. #[derive(Clone, Debug)] -pub struct Decoder<'a> { +pub struct SliceReader<'a> { /// Byte slice being decoded. bytes: ByteSlice<'a>, @@ -15,8 +15,8 @@ pub struct Decoder<'a> { position: Length, } -impl<'a> Decoder<'a> { - /// Create a new decoder for the given byte slice. +impl<'a> SliceReader<'a> { + /// Create a new slice reader for the given byte slice. pub fn new(bytes: &'a [u8]) -> Result { Ok(Self { bytes: ByteSlice::new(bytes)?, @@ -42,7 +42,7 @@ impl<'a> Decoder<'a> { self.failed } - /// Obtain the remaining bytes in this decoder from the current cursor + /// Obtain the remaining bytes in this slice reader from the current cursor /// position. fn remaining(&self) -> Result<&'a [u8]> { if self.is_failed() { @@ -56,7 +56,7 @@ impl<'a> Decoder<'a> { } } -impl<'a> Reader<'a> for Decoder<'a> { +impl<'a> Reader<'a> for SliceReader<'a> { fn input_len(&self) -> Length { self.bytes.len() } @@ -130,7 +130,7 @@ impl<'a> Reader<'a> for Decoder<'a> { #[cfg(test)] mod tests { - use super::Decoder; + use super::SliceReader; use crate::{Decode, ErrorKind, Length, Reader, Tag}; use hex_literal::hex; @@ -139,8 +139,8 @@ mod tests { #[test] fn empty_message() { - let mut decoder = Decoder::new(&[]).unwrap(); - let err = bool::decode(&mut decoder).err().unwrap(); + let mut reader = SliceReader::new(&[]).unwrap(); + let err = bool::decode(&mut reader).err().unwrap(); assert_eq!(Some(Length::ZERO), err.position()); match err.kind() { @@ -159,8 +159,8 @@ mod tests { fn invalid_field_length() { const MSG_LEN: usize = 2; - let mut decoder = Decoder::new(&EXAMPLE_MSG[..MSG_LEN]).unwrap(); - let err = i8::decode(&mut decoder).err().unwrap(); + let mut reader = SliceReader::new(&EXAMPLE_MSG[..MSG_LEN]).unwrap(); + let err = i8::decode(&mut reader).err().unwrap(); assert_eq!(Some(Length::from(2u8)), err.position()); match err.kind() { @@ -177,11 +177,11 @@ mod tests { #[test] fn trailing_data() { - let mut decoder = Decoder::new(EXAMPLE_MSG).unwrap(); - let x = i8::decode(&mut decoder).unwrap(); + let mut reader = SliceReader::new(EXAMPLE_MSG).unwrap(); + let x = i8::decode(&mut reader).unwrap(); assert_eq!(42i8, x); - let err = decoder.finish(x).err().unwrap(); + let err = reader.finish(x).err().unwrap(); assert_eq!(Some(Length::from(3u8)), err.position()); assert_eq!( @@ -195,20 +195,20 @@ mod tests { #[test] fn peek_tag() { - let decoder = Decoder::new(EXAMPLE_MSG).unwrap(); - assert_eq!(decoder.position(), Length::ZERO); - assert_eq!(decoder.peek_tag().unwrap(), Tag::Integer); - assert_eq!(decoder.position(), Length::ZERO); // Position unchanged + let reader = SliceReader::new(EXAMPLE_MSG).unwrap(); + assert_eq!(reader.position(), Length::ZERO); + assert_eq!(reader.peek_tag().unwrap(), Tag::Integer); + assert_eq!(reader.position(), Length::ZERO); // Position unchanged } #[test] fn peek_header() { - let decoder = Decoder::new(EXAMPLE_MSG).unwrap(); - assert_eq!(decoder.position(), Length::ZERO); + let reader = SliceReader::new(EXAMPLE_MSG).unwrap(); + assert_eq!(reader.position(), Length::ZERO); - let header = decoder.peek_header().unwrap(); + let header = reader.peek_header().unwrap(); assert_eq!(header.tag, Tag::Integer); assert_eq!(header.length, Length::ONE); - assert_eq!(decoder.position(), Length::ZERO); // Position unchanged + assert_eq!(reader.position(), Length::ZERO); // Position unchanged } } diff --git a/der/src/writer.rs b/der/src/writer.rs index 76f72ecc0..5e9774413 100644 --- a/der/src/writer.rs +++ b/der/src/writer.rs @@ -2,6 +2,7 @@ #[cfg(feature = "pem")] pub(crate) mod pem; +pub(crate) mod slice; use crate::Result; diff --git a/der/src/encoder.rs b/der/src/writer/slice.rs similarity index 80% rename from der/src/encoder.rs rename to der/src/writer/slice.rs index d3bf9f1ca..5dafe99a8 100644 --- a/der/src/encoder.rs +++ b/der/src/writer/slice.rs @@ -1,13 +1,13 @@ -//! DER encoder. +//! Slice writer. use crate::{ - asn1::*, Encode, EncodeValue, Error, ErrorKind, Header, Length, Result, Tag, TagMode, - TagNumber, Tagged, Writer, + asn1::*, Encode, EncodeValue, ErrorKind, Header, Length, Result, Tag, TagMode, TagNumber, + Tagged, Writer, }; -/// DER encoder. +/// [`Writer`] which encodes DER into a mutable output byte slice. #[derive(Debug)] -pub struct Encoder<'a> { +pub struct SliceWriter<'a> { /// Buffer into which DER-encoded message is written bytes: &'a mut [u8], @@ -18,7 +18,7 @@ pub struct Encoder<'a> { position: Length, } -impl<'a> Encoder<'a> { +impl<'a> SliceWriter<'a> { /// Create a new encoder with the given byte slice as a backing buffer. pub fn new(bytes: &'a mut [u8]) -> Self { Self { @@ -42,19 +42,11 @@ impl<'a> Encoder<'a> { /// Return an error with the given [`ErrorKind`], annotating it with /// context about where the error occurred. - // TODO(tarcieri): change return type to `Error` pub fn error(&mut self, kind: ErrorKind) -> Result { self.failed = true; Err(kind.at(self.position)) } - /// Return an error for an invalid value with the given tag. - // TODO(tarcieri): compose this with `Encoder::error` after changing its return type - pub fn value_error(&mut self, tag: Tag) -> Error { - self.failed = true; - tag.value_error().kind().at(self.position) - } - /// Did the decoding operation fail due to an error? pub fn is_failed(&self) -> bool { self.failed @@ -94,15 +86,15 @@ impl<'a> Encoder<'a> { /// Encode an ASN.1 `SEQUENCE` of the given length. /// - /// Spawns a nested [`Encoder`] which is expected to be exactly the + /// Spawns a nested slice writer which is expected to be exactly the /// specified length upon completion. pub fn sequence(&mut self, length: Length, f: F) -> Result<()> where - F: FnOnce(&mut Encoder<'_>) -> Result<()>, + F: FnOnce(&mut SliceWriter<'_>) -> Result<()>, { Header::new(Tag::Sequence, length).and_then(|header| header.encode(self))?; - let mut nested_encoder = Encoder::new(self.reserve(length)?); + let mut nested_encoder = SliceWriter::new(self.reserve(length)?); f(&mut nested_encoder)?; if nested_encoder.finish()?.len() == usize::try_from(length)? { @@ -134,7 +126,7 @@ impl<'a> Encoder<'a> { } } -impl<'a> Writer for Encoder<'a> { +impl<'a> Writer for SliceWriter<'a> { fn write(&mut self, slice: &[u8]) -> Result<()> { self.reserve(slice.len())?.copy_from_slice(slice); Ok(()) @@ -143,14 +135,14 @@ impl<'a> Writer for Encoder<'a> { #[cfg(test)] mod tests { - use super::Encoder; + use super::SliceWriter; use crate::{Encode, ErrorKind, Length}; #[test] fn overlength_message() { let mut buffer = []; - let mut encoder = Encoder::new(&mut buffer); - let err = false.encode(&mut encoder).err().unwrap(); + let mut writer = SliceWriter::new(&mut buffer); + let err = false.encode(&mut writer).err().unwrap(); assert_eq!(err.kind(), ErrorKind::Overlength); assert_eq!(err.position(), Some(Length::ONE)); } diff --git a/der/tests/datetime.rs b/der/tests/datetime.rs index 3a91b456a..454c1f0e4 100644 --- a/der/tests/datetime.rs +++ b/der/tests/datetime.rs @@ -31,7 +31,7 @@ proptest! { let utc_time1 = UtcTime::try_from(datetime).unwrap(); let mut buf = [0u8; 128]; - let mut encoder = der::Encoder::new(&mut buf); + let mut encoder = der::SliceWriter::new(&mut buf); utc_time1.encode(&mut encoder).unwrap(); let der_bytes = encoder.finish().unwrap(); diff --git a/der/tests/derive.rs b/der/tests/derive.rs index e0d0b4e8a..dac14f816 100644 --- a/der/tests/derive.rs +++ b/der/tests/derive.rs @@ -15,7 +15,7 @@ mod choice { mod explicit { use der::{ asn1::{GeneralizedTime, UtcTime}, - Choice, Decode, Encode, Encoder, + Choice, Decode, Encode, SliceWriter, }; use hex_literal::hex; use std::time::Duration; @@ -67,12 +67,12 @@ mod choice { let mut buf = [0u8; 128]; let utc_time = Time::from_der(UTC_TIMESTAMP_DER).unwrap(); - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); utc_time.encode(&mut encoder).unwrap(); assert_eq!(UTC_TIMESTAMP_DER, encoder.finish().unwrap()); let general_time = Time::from_der(GENERAL_TIMESTAMP_DER).unwrap(); - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); general_time.encode(&mut encoder).unwrap(); assert_eq!(GENERAL_TIMESTAMP_DER, encoder.finish().unwrap()); } @@ -82,7 +82,7 @@ mod choice { mod implicit { use der::{ asn1::{BitStringRef, GeneralizedTime}, - Choice, Decode, Encode, Encoder, + Choice, Decode, Encode, SliceWriter, }; use hex_literal::hex; @@ -139,12 +139,12 @@ mod choice { let mut buf = [0u8; 128]; let cs_bit_string = ImplicitChoice::from_der(BITSTRING_DER).unwrap(); - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); cs_bit_string.encode(&mut encoder).unwrap(); assert_eq!(BITSTRING_DER, encoder.finish().unwrap()); let cs_time = ImplicitChoice::from_der(TIME_DER).unwrap(); - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); cs_time.encode(&mut encoder).unwrap(); assert_eq!(TIME_DER, encoder.finish().unwrap()); } @@ -153,7 +153,7 @@ mod choice { /// Custom derive test cases for the `Enumerated` macro. mod enumerated { - use der::{Decode, Encode, Encoder, Enumerated}; + use der::{Decode, Encode, Enumerated, SliceWriter}; use hex_literal::hex; /// X.509 `CRLReason`. @@ -188,11 +188,11 @@ mod enumerated { fn encode() { let mut buf = [0u8; 128]; - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); CrlReason::Unspecified.encode(&mut encoder).unwrap(); assert_eq!(UNSPECIFIED_DER, encoder.finish().unwrap()); - let mut encoder = Encoder::new(&mut buf); + let mut encoder = SliceWriter::new(&mut buf); CrlReason::KeyCompromise.encode(&mut encoder).unwrap(); assert_eq!(KEY_COMPROMISE_DER, encoder.finish().unwrap()); } diff --git a/pkcs5/tests/pbes2.rs b/pkcs5/tests/pbes2.rs index a63bc8ebd..bb280d031 100644 --- a/pkcs5/tests/pbes2.rs +++ b/pkcs5/tests/pbes2.rs @@ -165,7 +165,7 @@ fn encode_pbes2_pbkdf2_sha1_aes128cbc() { let mut buffer = [0u8; 1024]; let scheme = pkcs5::EncryptionScheme::try_from(PBES2_PBKDF2_SHA1_AES128CBC_ALG_ID).unwrap(); - let mut encoder = der::Encoder::new(&mut buffer); + let mut encoder = der::SliceWriter::new(&mut buffer); scheme.encode(&mut encoder).unwrap(); let encoded_der = encoder.finish().unwrap(); @@ -178,7 +178,7 @@ fn encode_pbes2_pbkdf2_sha256_aes256cbc() { let mut buffer = [0u8; 1024]; let scheme = pkcs5::EncryptionScheme::try_from(PBES2_PBKDF2_SHA256_AES256CBC_ALG_ID).unwrap(); - let mut encoder = der::Encoder::new(&mut buffer); + let mut encoder = der::SliceWriter::new(&mut buffer); scheme.encode(&mut encoder).unwrap(); let encoded_der = encoder.finish().unwrap(); @@ -191,7 +191,7 @@ fn encode_pbes2_scrypt_aes256cbc() { let mut buffer = [0u8; 1024]; let scheme = pkcs5::EncryptionScheme::try_from(PBES2_SCRYPT_AES256CBC_ALG_ID).unwrap(); - let mut encoder = der::Encoder::new(&mut buffer); + let mut encoder = der::SliceWriter::new(&mut buffer); scheme.encode(&mut encoder).unwrap(); let encoded_der = encoder.finish().unwrap(); diff --git a/pkcs7/src/content_info.rs b/pkcs7/src/content_info.rs index 3c28b8364..ec906b1dc 100644 --- a/pkcs7/src/content_info.rs +++ b/pkcs7/src/content_info.rs @@ -124,13 +124,13 @@ impl<'a> Sequence<'a> for ContentInfo<'a> { mod tests { use super::{ContentInfo, DataContent}; use core::convert::TryFrom; - use der::{asn1::OctetStringRef, Decode, Encode, Encoder, Length, TagMode, TagNumber}; + use der::{asn1::OctetStringRef, Decode, Encode, Length, SliceWriter, TagMode, TagNumber}; #[test] fn empty_data() -> der::Result<()> { let mut in_buf = [0u8; 32]; - let mut encoder = Encoder::new(&mut in_buf); + let mut encoder = SliceWriter::new(&mut in_buf); encoder.sequence(crate::PKCS_7_DATA_OID.encoded_len()?, |encoder| { crate::PKCS_7_DATA_OID.encode(encoder) })?; @@ -154,7 +154,7 @@ mod tests { fn empty_encrypted_data() -> der::Result<()> { let mut in_buf = [0u8; 32]; - let mut encoder = Encoder::new(&mut in_buf); + let mut encoder = SliceWriter::new(&mut in_buf); encoder.sequence(crate::PKCS_7_ENCRYPTED_DATA_OID.encoded_len()?, |encoder| { (crate::PKCS_7_ENCRYPTED_DATA_OID).encode(encoder) })?; @@ -193,7 +193,7 @@ mod tests { let inner_len = (oid_len + tagged_hello_len)?; assert_eq!(Length::new(20), inner_len); - let mut encoder = Encoder::new(&mut in_buf); + let mut encoder = SliceWriter::new(&mut in_buf); encoder.sequence(inner_len, |encoder| { crate::PKCS_7_DATA_OID.encode(encoder)?; encoder.context_specific( diff --git a/pkcs7/tests/content_tests.rs b/pkcs7/tests/content_tests.rs index c60e44139..b542e8139 100644 --- a/pkcs7/tests/content_tests.rs +++ b/pkcs7/tests/content_tests.rs @@ -2,7 +2,7 @@ use der::{ asn1::{ObjectIdentifier, OctetStringRef}, - Decode, Encoder, + Decode, SliceWriter, }; use hex_literal::hex; use pkcs7::{ @@ -13,7 +13,7 @@ use spki::AlgorithmIdentifier; use std::fs; fn encode_content_info<'a>(content_info: &ContentInfo<'a>, buf: &'a mut [u8]) -> &'a [u8] { - let mut encoder = Encoder::new(buf); + let mut encoder = SliceWriter::new(buf); encoder.encode(content_info).expect("encoded content info"); encoder.finish().expect("encoding success") } diff --git a/x509-cert/tests/trust_anchor_format.rs b/x509-cert/tests/trust_anchor_format.rs index 40d5adaa9..bcc3e6933 100644 --- a/x509-cert/tests/trust_anchor_format.rs +++ b/x509-cert/tests/trust_anchor_format.rs @@ -1,4 +1,4 @@ -use der::{Decode, Decoder, Encode}; +use der::{Decode, Encode, SliceReader}; use hex_literal::hex; use x509_cert::anchor::{CertPolicies, TrustAnchorChoice}; use x509_cert::ext::pkix::name::GeneralName; @@ -10,7 +10,7 @@ fn decode_ta1() { let der_encoded_tac = include_bytes!("examples/eca_policies.ta"); let der_encoded_cert = include_bytes!("examples/eca.der"); - let mut decoder = Decoder::new(der_encoded_tac).unwrap(); + let mut decoder = SliceReader::new(der_encoded_tac).unwrap(); let tac = TrustAnchorChoice::decode(&mut decoder).unwrap(); let reencoded_tac = tac.to_vec().unwrap(); println!("Original : {:02X?}", der_encoded_cert); @@ -125,7 +125,7 @@ fn decode_ta2() { let der_encoded_tac = include_bytes!("examples/entrust_dnConstraint.ta"); let der_encoded_cert = include_bytes!("examples/entrust.der"); - let mut decoder = Decoder::new(der_encoded_tac).unwrap(); + let mut decoder = SliceReader::new(der_encoded_tac).unwrap(); let tac = TrustAnchorChoice::decode(&mut decoder).unwrap(); let reencoded_tac = tac.to_vec().unwrap(); println!("Original : {:02X?}", der_encoded_cert); @@ -228,7 +228,7 @@ fn decode_ta3() { let der_encoded_tac = include_bytes!("examples/exostar_policyFlags.ta"); let der_encoded_cert = include_bytes!("examples/exostar.der"); - let mut decoder = Decoder::new(der_encoded_tac).unwrap(); + let mut decoder = SliceReader::new(der_encoded_tac).unwrap(); let tac = TrustAnchorChoice::decode(&mut decoder).unwrap(); let reencoded_tac = tac.to_vec().unwrap(); println!("Original : {:02X?}", der_encoded_cert); @@ -338,7 +338,7 @@ fn decode_ta4() { let der_encoded_tac = include_bytes!("examples/raytheon_pathLenConstraint.ta"); let der_encoded_cert = include_bytes!("examples/raytheon.der"); - let mut decoder = Decoder::new(der_encoded_tac).unwrap(); + let mut decoder = SliceReader::new(der_encoded_tac).unwrap(); let tac = TrustAnchorChoice::decode(&mut decoder).unwrap(); let reencoded_tac = tac.to_vec().unwrap(); println!("Original : {:02X?}", der_encoded_cert);