diff options
Diffstat (limited to 'vendor/der/src')
48 files changed, 2645 insertions, 1308 deletions
diff --git a/vendor/der/src/asn1.rs b/vendor/der/src/asn1.rs index 34d692b67..dead9ae02 100644 --- a/vendor/der/src/asn1.rs +++ b/vendor/der/src/asn1.rs @@ -1,6 +1,9 @@ //! Module containing all of the various ASN.1 built-in types supported by //! this library. +#[macro_use] +mod internal_macros; + mod any; mod bit_string; mod boolean; @@ -32,7 +35,7 @@ pub use self::{ context_specific::{ContextSpecific, ContextSpecificRef}, generalized_time::GeneralizedTime, ia5_string::Ia5StringRef, - integer::bigint::UIntRef, + integer::{int::IntRef, uint::UintRef}, null::Null, octet_string::OctetStringRef, printable_string::PrintableStringRef, @@ -46,9 +49,16 @@ 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::{int::Int, uint::Uint}, + octet_string::OctetString, + printable_string::PrintableString, + set_of::SetOfVec, + teletex_string::TeletexString, +}; #[cfg(feature = "oid")] -#[cfg_attr(docsrs, doc(cfg(feature = "oid")))] pub use const_oid::ObjectIdentifier; diff --git a/vendor/der/src/asn1/any.rs b/vendor/der/src/asn1/any.rs index cb65f2391..017a90908 100644 --- a/vendor/der/src/asn1/any.rs +++ b/vendor/der/src/asn1/any.rs @@ -1,16 +1,15 @@ //! ASN.1 `ANY` type. +#![cfg_attr(feature = "arbitrary", allow(clippy::integer_arithmetic))] + use crate::{ - asn1::*, ByteSlice, Choice, Decode, DecodeValue, DerOrd, EncodeValue, Error, ErrorKind, - FixedTag, Header, Length, Reader, Result, SliceReader, Tag, Tagged, ValueOrd, Writer, + BytesRef, Choice, Decode, DecodeValue, DerOrd, EncodeValue, Error, ErrorKind, Header, Length, + Reader, Result, SliceReader, Tag, Tagged, ValueOrd, Writer, }; use core::cmp::Ordering; #[cfg(feature = "alloc")] -use alloc::vec::Vec; - -#[cfg(feature = "oid")] -use crate::asn1::ObjectIdentifier; +use crate::SliceWriter; /// ASN.1 `ANY`: represents any explicitly tagged ASN.1 value. /// @@ -23,30 +22,31 @@ use crate::asn1::ObjectIdentifier; /// Nevertheless, this crate defines an `ANY` type as it remains a familiar /// and useful concept which is still extensively used in things like /// PKI-related RFCs. +#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))] #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] pub struct AnyRef<'a> { /// Tag representing the type of the encoded value. tag: Tag, /// Inner value encoded as bytes. - value: ByteSlice<'a>, + value: BytesRef<'a>, } impl<'a> AnyRef<'a> { /// [`AnyRef`] representation of the ASN.1 `NULL` type. pub const NULL: Self = Self { tag: Tag::Null, - value: ByteSlice::EMPTY, + value: BytesRef::EMPTY, }; /// Create a new [`AnyRef`] from the provided [`Tag`] and DER bytes. pub fn new(tag: Tag, bytes: &'a [u8]) -> Result<Self> { - let value = ByteSlice::new(bytes).map_err(|_| ErrorKind::Length { tag })?; + let value = BytesRef::new(bytes).map_err(|_| ErrorKind::Length { tag })?; Ok(Self { tag, value }) } - /// Infallible creation of an [`AnyRef`] from a [`ByteSlice`]. - pub(crate) fn from_tag_and_value(tag: Tag, value: ByteSlice<'a>) -> Self { + /// Infallible creation of an [`AnyRef`] from a [`BytesRef`]. + pub(crate) fn from_tag_and_value(tag: Tag, value: BytesRef<'a>) -> Self { Self { tag, value } } @@ -56,11 +56,14 @@ impl<'a> AnyRef<'a> { } /// Attempt to decode this [`AnyRef`] type into the inner value. - pub fn decode_into<T>(self) -> Result<T> + pub fn decode_as<T>(self) -> Result<T> where - T: DecodeValue<'a> + FixedTag, + T: Choice<'a> + DecodeValue<'a>, { - self.tag.assert_eq(T::TAG)?; + if !T::can_decode(self.tag) { + return Err(self.tag.unexpected_error(None)); + } + let header = Header { tag: self.tag, length: self.value.len(), @@ -76,68 +79,6 @@ impl<'a> AnyRef<'a> { self == Self::NULL } - /// Attempt to decode an ASN.1 `BIT STRING`. - pub fn bit_string(self) -> Result<BitStringRef<'a>> { - self.try_into() - } - - /// Attempt to decode an ASN.1 `CONTEXT-SPECIFIC` field. - pub fn context_specific<T>(self) -> Result<ContextSpecific<T>> - where - T: Decode<'a>, - { - self.try_into() - } - - /// Attempt to decode an ASN.1 `GeneralizedTime`. - pub fn generalized_time(self) -> Result<GeneralizedTime> { - 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() - } - - /// Attempt to decode an ASN.1 `OBJECT IDENTIFIER`. - #[cfg(feature = "oid")] - #[cfg_attr(docsrs, doc(cfg(feature = "oid")))] - pub fn oid(self) -> Result<ObjectIdentifier> { - self.try_into() - } - - /// Attempt to decode an ASN.1 `OPTIONAL` value. - pub fn optional<T>(self) -> Result<Option<T>> - where - T: Choice<'a> + TryFrom<Self, Error = Error>, - { - if T::can_decode(self.tag) { - T::try_from(self).map(Some) - } else { - Ok(None) - } - } - - /// 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> @@ -149,16 +90,6 @@ impl<'a> AnyRef<'a> { let result = f(&mut reader)?; reader.finish(result) } - - /// Attempt to decode an ASN.1 `UTCTime`. - 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> { @@ -170,10 +101,15 @@ impl<'a> Choice<'a> for AnyRef<'a> { impl<'a> Decode<'a> for AnyRef<'a> { fn decode<R: Reader<'a>>(reader: &mut R) -> Result<AnyRef<'a>> { let header = Header::decode(reader)?; + Self::decode_value(reader, header) + } +} +impl<'a> DecodeValue<'a> for AnyRef<'a> { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { Ok(Self { tag: header.tag, - value: ByteSlice::decode_value(reader, header)?, + value: BytesRef::decode_value(reader, header)?, }) } } @@ -183,7 +119,7 @@ impl EncodeValue for AnyRef<'_> { Ok(self.value.len()) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { writer.write(self.value()) } } @@ -200,8 +136,8 @@ impl ValueOrd for AnyRef<'_> { } } -impl<'a> From<AnyRef<'a>> for ByteSlice<'a> { - fn from(any: AnyRef<'a>) -> ByteSlice<'a> { +impl<'a> From<AnyRef<'a>> for BytesRef<'a> { + fn from(any: AnyRef<'a>) -> BytesRef<'a> { any.value } } @@ -214,71 +150,166 @@ impl<'a> TryFrom<&'a [u8]> for AnyRef<'a> { } } -/// ASN.1 `ANY`: represents any explicitly tagged ASN.1 value. -/// -/// This type provides the same functionality as [`AnyRef`] but owns the -/// backing data. #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] -#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] -pub struct Any { - /// Tag representing the type of the encoded value. - tag: Tag, - - /// Inner value encoded as bytes. - value: Vec<u8>, -} +pub use self::allocating::Any; #[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(); +mod allocating { + use super::*; + use crate::{referenced::*, BytesOwned}; + use alloc::boxed::Box; + + /// ASN.1 `ANY`: represents any explicitly tagged ASN.1 value. + /// + /// This type provides the same functionality as [`AnyRef`] but owns the + /// backing data. + #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))] + #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] + pub struct Any { + /// Tag representing the type of the encoded value. + tag: Tag, + + /// Inner value encoded as bytes. + value: BytesOwned, + } + + impl Any { + /// Create a new [`Any`] from the provided [`Tag`] and DER bytes. + pub fn new(tag: Tag, bytes: impl Into<Box<[u8]>>) -> Result<Self> { + let value = BytesOwned::new(bytes)?; + + // Ensure the tag and value are a valid `AnyRef`. + AnyRef::new(tag, value.as_slice())?; + Ok(Self { tag, value }) + } - // Ensure the tag and value are a valid `AnyRef`. - AnyRef::new(tag, &value)?; - Ok(Self { tag, value }) + /// Allow access to value + pub fn value(&self) -> &[u8] { + self.value.as_slice() + } + + /// Attempt to decode this [`Any`] type into the inner value. + pub fn decode_as<'a, T>(&'a self) -> Result<T> + where + T: Choice<'a> + DecodeValue<'a>, + { + AnyRef::from(self).decode_as() + } + + /// Encode the provided type as an [`Any`] value. + pub fn encode_from<T>(msg: &T) -> Result<Self> + where + T: Tagged + EncodeValue, + { + let encoded_len = usize::try_from(msg.value_len()?)?; + let mut buf = vec![0u8; encoded_len]; + let mut writer = SliceWriter::new(&mut buf); + msg.encode_value(&mut writer)?; + writer.finish()?; + Any::new(msg.tag(), buf) + } + + /// Attempt to decode this value an ASN.1 `SEQUENCE`, creating a new + /// nested reader and calling the provided argument with it. + pub fn sequence<'a, F, T>(&'a self, f: F) -> Result<T> + where + F: FnOnce(&mut SliceReader<'a>) -> Result<T>, + { + AnyRef::from(self).sequence(f) + } + + /// [`Any`] representation of the ASN.1 `NULL` type. + pub fn null() -> Self { + Self { + tag: Tag::Null, + value: BytesOwned::default(), + } + } } -} -#[cfg(feature = "alloc")] -impl Choice<'_> for Any { - fn can_decode(_: Tag) -> bool { - true + impl Choice<'_> for Any { + fn can_decode(_: Tag) -> bool { + true + } } -} -#[cfg(feature = "alloc")] -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) + impl<'a> Decode<'a> for Any { + fn decode<R: Reader<'a>>(reader: &mut R) -> Result<Self> { + let header = Header::decode(reader)?; + Self::decode_value(reader, header) + } } -} -#[cfg(feature = "alloc")] -impl EncodeValue for Any { - fn value_len(&self) -> Result<Length> { - self.value.len().try_into() + impl<'a> DecodeValue<'a> for Any { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + let value = reader.read_vec(header.length)?; + Self::new(header.tag, value) + } } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - writer.write(&self.value) + impl EncodeValue for Any { + fn value_len(&self) -> Result<Length> { + Ok(self.value.len()) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + 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") + 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.as_slice()).expect("invalid ANY") + } } -} -#[cfg(feature = "alloc")] -impl Tagged for Any { - fn tag(&self) -> Tag { - self.tag + impl Tagged for Any { + fn tag(&self) -> Tag { + self.tag + } + } + + impl ValueOrd for Any { + fn value_cmp(&self, other: &Self) -> Result<Ordering> { + self.value.der_cmp(&other.value) + } + } + + 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: BytesOwned::from(anyref.value), + } + } + } + + impl<'a> RefToOwned<'a> for AnyRef<'a> { + type Owned = Any; + fn ref_to_owned(&self) -> Self::Owned { + Any { + tag: self.tag(), + value: BytesOwned::from(self.value), + } + } + } + + impl OwnedToRef for Any { + type Borrowed<'a> = AnyRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + self.into() + } + } + + impl Any { + /// Is this value an ASN.1 `NULL` value? + pub fn is_null(&self) -> bool { + self.owned_to_ref() == AnyRef::NULL + } } } diff --git a/vendor/der/src/asn1/bit_string.rs b/vendor/der/src/asn1/bit_string.rs index eed14e456..bf3371c40 100644 --- a/vendor/der/src/asn1/bit_string.rs +++ b/vendor/der/src/asn1/bit_string.rs @@ -1,14 +1,11 @@ //! ASN.1 `BIT STRING` support. use crate::{ - asn1::AnyRef, ByteSlice, DecodeValue, DerOrd, EncodeValue, Error, ErrorKind, FixedTag, Header, - Length, Reader, Result, Tag, ValueOrd, Writer, + BytesRef, DecodeValue, DerOrd, EncodeValue, Error, ErrorKind, FixedTag, Header, Length, Reader, + Result, Tag, ValueOrd, Writer, }; use core::{cmp::Ordering, iter::FusedIterator}; -#[cfg(feature = "alloc")] -use alloc::vec::Vec; - /// ASN.1 `BIT STRING` type. /// /// This type contains a sequence of any number of bits, modeled internally as @@ -24,7 +21,7 @@ pub struct BitStringRef<'a> { bit_length: usize, /// Bitstring represented as a slice of bytes. - inner: ByteSlice<'a>, + inner: BytesRef<'a>, } impl<'a> BitStringRef<'a> { @@ -40,7 +37,7 @@ impl<'a> BitStringRef<'a> { return Err(Self::TAG.value_error()); } - let inner = ByteSlice::new(bytes).map_err(|_| Self::TAG.length_error())?; + let inner = BytesRef::new(bytes).map_err(|_| Self::TAG.length_error())?; let bit_length = usize::try_from(inner.len())? .checked_mul(8) @@ -120,6 +117,8 @@ impl<'a> BitStringRef<'a> { } } +impl_any_conversions!(BitStringRef<'a>, 'a); + impl<'a> DecodeValue<'a> for BitStringRef<'a> { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { let header = Header { @@ -128,7 +127,7 @@ impl<'a> DecodeValue<'a> for BitStringRef<'a> { }; let unused_bits = reader.read_byte()?; - let inner = ByteSlice::decode_value(reader, header)?; + let inner = BytesRef::decode_value(reader, header)?; Self::new(unused_bits, inner.as_slice()) } } @@ -138,7 +137,7 @@ impl EncodeValue for BitStringRef<'_> { self.byte_len() + Length::ONE } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { writer.write_byte(self.unused_bits)?; writer.write(self.raw_bytes()) } @@ -159,14 +158,6 @@ impl<'a> From<&BitStringRef<'a>> for BitStringRef<'a> { } } -impl<'a> TryFrom<AnyRef<'a>> for BitStringRef<'a> { - type Error = Error; - - fn try_from(any: AnyRef<'a>) -> Result<BitStringRef<'a>> { - any.decode_into() - } -} - impl<'a> TryFrom<&'a [u8]> for BitStringRef<'a> { type Error = Error; @@ -180,7 +171,7 @@ impl<'a> TryFrom<&&'a [u8]> for BitStringRef<'a> { type Error = Error; fn try_from(bytes: &&'a [u8]) -> Result<BitStringRef<'a>> { - BitStringRef::from_bytes(*bytes) + BitStringRef::from_bytes(bytes) } } @@ -198,141 +189,198 @@ impl<'a> FixedTag for BitStringRef<'a> { const TAG: Tag = Tag::BitString; } -/// Owned form of ASN.1 `BIT STRING` type. -/// -/// This type provides the same functionality as [`BitStringRef`] but owns the -/// backing data. -#[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] -#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] -pub struct BitString { - /// Number of unused bits in the final octet. - unused_bits: u8, - - /// Length of this `BIT STRING` in bits. - bit_length: usize, +// Implement by hand because the derive would create invalid values. +// Use the constructor to create a valid value. +#[cfg(feature = "arbitrary")] +impl<'a> arbitrary::Arbitrary<'a> for BitStringRef<'a> { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + Self::new( + u.int_in_range(0..=Self::MAX_UNUSED_BITS)?, + BytesRef::arbitrary(u)?.as_slice(), + ) + .map_err(|_| arbitrary::Error::IncorrectFormat) + } - /// Bitstring represented as a slice of bytes. - inner: Vec<u8>, + fn size_hint(depth: usize) -> (usize, Option<usize>) { + arbitrary::size_hint::and(u8::size_hint(depth), BytesRef::size_hint(depth)) + } } #[cfg(feature = "alloc")] -impl BitString { - /// Maximum number of unused bits allowed. - pub const MAX_UNUSED_BITS: u8 = 7; +pub use self::allocating::BitString; - /// Create a new ASN.1 `BIT STRING` from a byte slice. +#[cfg(feature = "alloc")] +mod allocating { + use super::*; + use crate::referenced::*; + use alloc::vec::Vec; + + /// Owned form of ASN.1 `BIT STRING` type. /// - /// Accepts an optional number of "unused bits" (0-7) which are omitted - /// from the final octet. This number is 0 if the value is octet-aligned. - pub fn new(unused_bits: u8, bytes: impl Into<Vec<u8>>) -> Result<Self> { - let inner = bytes.into(); + /// This type provides the same functionality as [`BitStringRef`] but owns the + /// backing data. + #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] + pub struct BitString { + /// Number of unused bits in the final octet. + unused_bits: u8, + + /// Length of this `BIT STRING` in bits. + bit_length: usize, + + /// Bitstring represented as a slice of bytes. + inner: Vec<u8>, + } + + impl BitString { + /// Maximum number of unused bits allowed. + pub const MAX_UNUSED_BITS: u8 = 7; + + /// Create a new ASN.1 `BIT STRING` from a byte slice. + /// + /// Accepts an optional number of "unused bits" (0-7) which are omitted + /// from the final octet. This number is 0 if the value is octet-aligned. + pub fn new(unused_bits: u8, bytes: impl Into<Vec<u8>>) -> Result<Self> { + let inner = bytes.into(); + + // Ensure parameters parse successfully as a `BitStringRef`. + let bit_length = BitStringRef::new(unused_bits, &inner)?.bit_length; + + Ok(BitString { + unused_bits, + bit_length, + inner, + }) + } - // Ensure parameters parse successfully as a `BitStringRef`. - let bit_length = BitStringRef::new(unused_bits, &inner)?.bit_length; + /// Create a new ASN.1 `BIT STRING` from the given bytes. + /// + /// The "unused bits" are set to 0. + pub fn from_bytes(bytes: &[u8]) -> Result<Self> { + Self::new(0, bytes) + } - Ok(BitString { - unused_bits, - bit_length, - inner, - }) - } + /// Get the number of unused bits in the octet serialization of this + /// `BIT STRING`. + pub fn unused_bits(&self) -> u8 { + self.unused_bits + } - /// Create a new ASN.1 `BIT STRING` from the given bytes. - /// - /// The "unused bits" are set to 0. - pub fn from_bytes(bytes: &[u8]) -> Result<Self> { - Self::new(0, bytes) - } + /// Is the number of unused bits a value other than 0? + pub fn has_unused_bits(&self) -> bool { + self.unused_bits != 0 + } - /// Get the number of unused bits in the octet serialization of this - /// `BIT STRING`. - pub fn unused_bits(&self) -> u8 { - self.unused_bits - } + /// Get the length of this `BIT STRING` in bits. + pub fn bit_len(&self) -> usize { + self.bit_length + } - /// Is the number of unused bits a value other than 0? - pub fn has_unused_bits(&self) -> bool { - self.unused_bits != 0 - } + /// Is the inner byte slice empty? + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } - /// Get the length of this `BIT STRING` in bits. - pub fn bit_len(&self) -> usize { - self.bit_length - } + /// Borrow the inner byte slice. + /// + /// Returns `None` if the number of unused bits is *not* equal to zero, + /// i.e. if the `BIT STRING` is not octet aligned. + /// + /// Use [`BitString::raw_bytes`] to obtain access to the raw value + /// regardless of the presence of unused bits. + pub fn as_bytes(&self) -> Option<&[u8]> { + if self.has_unused_bits() { + None + } else { + Some(self.raw_bytes()) + } + } - /// Is the inner byte slice empty? - pub fn is_empty(&self) -> bool { - self.inner.is_empty() - } + /// Borrow the raw bytes of this `BIT STRING`. + pub fn raw_bytes(&self) -> &[u8] { + self.inner.as_slice() + } - /// Borrow the inner byte slice. - /// - /// Returns `None` if the number of unused bits is *not* equal to zero, - /// i.e. if the `BIT STRING` is not octet aligned. - /// - /// Use [`BitString::raw_bytes`] to obtain access to the raw value - /// regardless of the presence of unused bits. - pub fn as_bytes(&self) -> Option<&[u8]> { - if self.has_unused_bits() { - None - } else { - Some(self.raw_bytes()) + /// Iterator over the bits of this `BIT STRING`. + pub fn bits(&self) -> BitStringIter<'_> { + BitStringRef::from(self).bits() } } - /// Borrow the raw bytes of this `BIT STRING`. - pub fn raw_bytes(&self) -> &[u8] { - self.inner.as_slice() + impl_any_conversions!(BitString); + + impl<'a> DecodeValue<'a> for BitString { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + let inner_len = (header.length - Length::ONE)?; + let unused_bits = reader.read_byte()?; + let inner = reader.read_vec(inner_len)?; + Self::new(unused_bits, inner) + } } - /// Iterator over the bits of this `BIT STRING`. - pub fn bits(&self) -> BitStringIter<'_> { - BitStringRef::from(self).bits() + impl EncodeValue for BitString { + fn value_len(&self) -> Result<Length> { + Length::ONE + Length::try_from(self.inner.len())? + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + writer.write_byte(self.unused_bits)?; + writer.write(&self.inner) + } } -} -#[cfg(feature = "alloc")] -impl<'a> DecodeValue<'a> for BitString { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - let inner_len = (header.length - Length::ONE)?; - let unused_bits = reader.read_byte()?; - let inner = reader.read_vec(inner_len)?; - Self::new(unused_bits, inner) + impl FixedTag for BitString { + const TAG: Tag = Tag::BitString; } -} -#[cfg(feature = "alloc")] -impl EncodeValue for BitString { - fn value_len(&self) -> Result<Length> { - Length::ONE + Length::try_from(self.inner.len())? + impl<'a> From<&'a BitString> for BitStringRef<'a> { + fn from(bit_string: &'a BitString) -> BitStringRef<'a> { + // Ensured to parse successfully in constructor + BitStringRef::new(bit_string.unused_bits, &bit_string.inner) + .expect("invalid BIT STRING") + } } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - writer.write_byte(self.unused_bits)?; - writer.write(&self.inner) + impl ValueOrd for BitString { + fn value_cmp(&self, other: &Self) -> Result<Ordering> { + match self.unused_bits.cmp(&other.unused_bits) { + Ordering::Equal => self.inner.der_cmp(&other.inner), + ordering => Ok(ordering), + } + } } -} -#[cfg(feature = "alloc")] -impl FixedTag for BitString { - const TAG: Tag = Tag::BitString; -} + // Implement by hand because the derive would create invalid values. + // Use the constructor to create a valid value. + #[cfg(feature = "arbitrary")] + impl<'a> arbitrary::Arbitrary<'a> for BitString { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + Self::new( + u.int_in_range(0..=Self::MAX_UNUSED_BITS)?, + BytesRef::arbitrary(u)?.as_slice(), + ) + .map_err(|_| arbitrary::Error::IncorrectFormat) + } -#[cfg(feature = "alloc")] -impl<'a> From<&'a BitString> for BitStringRef<'a> { - fn from(bit_string: &'a BitString) -> BitStringRef<'a> { - // Ensured to parse successfully in constructor - BitStringRef::new(bit_string.unused_bits, &bit_string.inner).expect("invalid BIT STRING") + fn size_hint(depth: usize) -> (usize, Option<usize>) { + arbitrary::size_hint::and(u8::size_hint(depth), BytesRef::size_hint(depth)) + } } -} -#[cfg(feature = "alloc")] -impl ValueOrd for BitString { - fn value_cmp(&self, other: &Self) -> Result<Ordering> { - match self.unused_bits.cmp(&other.unused_bits) { - Ordering::Equal => self.inner.der_cmp(&other.inner), - ordering => Ok(ordering), + impl<'a> RefToOwned<'a> for BitStringRef<'a> { + type Owned = BitString; + fn ref_to_owned(&self) -> Self::Owned { + BitString { + unused_bits: self.unused_bits, + bit_length: self.bit_length, + inner: Vec::from(self.inner.as_slice()), + } + } + } + + impl OwnedToRef for BitString { + type Borrowed<'a> = BitStringRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + self.into() } } } @@ -445,7 +493,7 @@ where BitStringRef::new((lead % 8) as u8, buff)?.value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { let (lead, buff) = encode_flagset(self); let buff = &buff[..buff.len() - lead / 8]; BitStringRef::new((lead % 8) as u8, buff)?.encode_value(writer) @@ -486,7 +534,7 @@ mod tests { assert_eq!(bits.len(), 18); for bit in [0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1] { - assert_eq!(bits.next().unwrap() as u8, bit) + assert_eq!(u8::from(bits.next().unwrap()), bit) } // Ensure `None` is returned on successive calls diff --git a/vendor/der/src/asn1/boolean.rs b/vendor/der/src/asn1/boolean.rs index e03218120..3eb0f2e68 100644 --- a/vendor/der/src/asn1/boolean.rs +++ b/vendor/der/src/asn1/boolean.rs @@ -1,8 +1,8 @@ //! ASN.1 `BOOLEAN` support. use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, ErrorKind, - FixedTag, Header, Length, Reader, Result, Tag, Writer, + asn1::AnyRef, ord::OrdIsValueOrd, DecodeValue, 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,7 +33,7 @@ impl EncodeValue for bool { Ok(Length::ONE) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { writer.write_byte(if *self { TRUE_OCTET } else { FALSE_OCTET }) } } @@ -44,17 +44,6 @@ impl FixedTag for bool { impl OrdIsValueOrd for bool {} -impl From<bool> for AnyRef<'static> { - fn from(value: bool) -> AnyRef<'static> { - let value = ByteSlice::from(match value { - false => &[FALSE_OCTET], - true => &[TRUE_OCTET], - }); - - AnyRef::from_tag_and_value(Tag::Boolean, value) - } -} - impl TryFrom<AnyRef<'_>> for bool { type Error = Error; diff --git a/vendor/der/src/asn1/context_specific.rs b/vendor/der/src/asn1/context_specific.rs index 311b5fe74..101ddf022 100644 --- a/vendor/der/src/asn1/context_specific.rs +++ b/vendor/der/src/asn1/context_specific.rs @@ -145,7 +145,7 @@ where } } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { match self.tag_mode { TagMode::Explicit => self.value.encode(writer), TagMode::Implicit => self.value.encode_value(writer), @@ -239,7 +239,7 @@ where self.encoder().value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { self.encoder().encode_value(writer) } } diff --git a/vendor/der/src/asn1/generalized_time.rs b/vendor/der/src/asn1/generalized_time.rs index 9950e368e..f7b6f180f 100644 --- a/vendor/der/src/asn1/generalized_time.rs +++ b/vendor/der/src/asn1/generalized_time.rs @@ -1,16 +1,18 @@ //! ASN.1 `GeneralizedTime` support. +#![cfg_attr(feature = "arbitrary", allow(clippy::integer_arithmetic))] use crate::{ - asn1::AnyRef, datetime::{self, DateTime}, ord::OrdIsValueOrd, - DecodeValue, EncodeValue, Error, ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, - Writer, + DecodeValue, EncodeValue, ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, Writer, }; use core::time::Duration; #[cfg(feature = "std")] -use std::time::SystemTime; +use { + crate::{asn1::AnyRef, Error}, + std::time::SystemTime, +}; #[cfg(feature = "time")] use time::PrimitiveDateTime; @@ -26,6 +28,7 @@ use time::PrimitiveDateTime; /// > is zero. GeneralizedTime values MUST NOT include fractional seconds. /// /// [1]: https://tools.ietf.org/html/rfc5280#section-4.1.2.5.2 +#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))] #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] pub struct GeneralizedTime(DateTime); @@ -58,7 +61,6 @@ impl GeneralizedTime { /// Instantiate from [`SystemTime`]. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn from_system_time(time: SystemTime) -> Result<Self> { DateTime::try_from(time) .map(Into::into) @@ -67,12 +69,13 @@ impl GeneralizedTime { /// Convert to [`SystemTime`]. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn to_system_time(&self) -> SystemTime { self.0.to_system_time() } } +impl_any_conversions!(GeneralizedTime); + impl<'a> DecodeValue<'a> for GeneralizedTime { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { if Self::LENGTH != usize::try_from(header.length)? { @@ -111,7 +114,7 @@ impl EncodeValue for GeneralizedTime { Self::LENGTH.try_into() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { let year_hi = u8::try_from(self.0.year() / 100)?; let year_lo = u8::try_from(self.0.year() % 100)?; @@ -162,14 +165,6 @@ impl From<&DateTime> for GeneralizedTime { } } -impl TryFrom<AnyRef<'_>> for GeneralizedTime { - type Error = Error; - - fn try_from(any: AnyRef<'_>) -> Result<GeneralizedTime> { - any.decode_into() - } -} - impl<'a> DecodeValue<'a> for DateTime { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { Ok(GeneralizedTime::decode_value(reader, header)?.into()) @@ -181,7 +176,7 @@ impl EncodeValue for DateTime { GeneralizedTime::from(self).value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { GeneralizedTime::from(self).encode_value(writer) } } @@ -193,7 +188,6 @@ impl FixedTag for DateTime { impl OrdIsValueOrd for DateTime {} #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl<'a> DecodeValue<'a> for SystemTime { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { Ok(GeneralizedTime::decode_value(reader, header)?.into()) @@ -201,19 +195,17 @@ impl<'a> DecodeValue<'a> for SystemTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl EncodeValue for SystemTime { fn value_len(&self) -> Result<Length> { GeneralizedTime::try_from(self)?.value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { GeneralizedTime::try_from(self)?.encode_value(writer) } } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl From<GeneralizedTime> for SystemTime { fn from(time: GeneralizedTime) -> SystemTime { time.to_system_time() @@ -221,7 +213,6 @@ impl From<GeneralizedTime> for SystemTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl From<&GeneralizedTime> for SystemTime { fn from(time: &GeneralizedTime) -> SystemTime { time.to_system_time() @@ -229,7 +220,6 @@ impl From<&GeneralizedTime> for SystemTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl TryFrom<SystemTime> for GeneralizedTime { type Error = Error; @@ -239,7 +229,6 @@ impl TryFrom<SystemTime> for GeneralizedTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl TryFrom<&SystemTime> for GeneralizedTime { type Error = Error; @@ -249,7 +238,6 @@ impl TryFrom<&SystemTime> for GeneralizedTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl<'a> TryFrom<AnyRef<'a>> for SystemTime { type Error = Error; @@ -259,17 +247,14 @@ impl<'a> TryFrom<AnyRef<'a>> for SystemTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl FixedTag for SystemTime { const TAG: Tag = Tag::GeneralizedTime; } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl OrdIsValueOrd for SystemTime {} #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl<'a> DecodeValue<'a> for PrimitiveDateTime { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { GeneralizedTime::decode_value(reader, header)?.try_into() @@ -277,29 +262,25 @@ impl<'a> DecodeValue<'a> for PrimitiveDateTime { } #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl EncodeValue for PrimitiveDateTime { fn value_len(&self) -> Result<Length> { GeneralizedTime::try_from(self)?.value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { GeneralizedTime::try_from(self)?.encode_value(writer) } } #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl FixedTag for PrimitiveDateTime { const TAG: Tag = Tag::GeneralizedTime; } #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl OrdIsValueOrd for PrimitiveDateTime {} #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl TryFrom<PrimitiveDateTime> for GeneralizedTime { type Error = Error; @@ -309,7 +290,6 @@ impl TryFrom<PrimitiveDateTime> for GeneralizedTime { } #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl TryFrom<&PrimitiveDateTime> for GeneralizedTime { type Error = Error; @@ -319,7 +299,6 @@ impl TryFrom<&PrimitiveDateTime> for GeneralizedTime { } #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl TryFrom<GeneralizedTime> for PrimitiveDateTime { type Error = Error; diff --git a/vendor/der/src/asn1/ia5_string.rs b/vendor/der/src/asn1/ia5_string.rs index 3971270a8..c3f24f01c 100644 --- a/vendor/der/src/asn1/ia5_string.rs +++ b/vendor/der/src/asn1/ia5_string.rs @@ -1,10 +1,26 @@ //! ASN.1 `IA5String` support. -use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, - Length, Reader, Result, StrSlice, Tag, Writer, -}; -use core::{fmt, ops::Deref, str}; +use crate::{asn1::AnyRef, FixedTag, Result, StrRef, Tag}; +use core::{fmt, ops::Deref}; + +macro_rules! impl_ia5_string { + ($type: ty) => { + impl_ia5_string!($type,); + }; + ($type: ty, $($li: lifetime)?) => { + impl_string_type!($type, $($li),*); + + impl<$($li),*> FixedTag for $type { + const TAG: Tag = Tag::Ia5String; + } + + impl<$($li),*> fmt::Debug for $type { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Ia5String({:?})", self.as_str()) + } + } + }; +} /// ASN.1 `IA5String` type. /// @@ -21,7 +37,7 @@ use core::{fmt, ops::Deref, str}; #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)] pub struct Ia5StringRef<'a> { /// Inner value - inner: StrSlice<'a>, + inner: StrRef<'a>, } impl<'a> Ia5StringRef<'a> { @@ -37,83 +53,117 @@ impl<'a> Ia5StringRef<'a> { return Err(Self::TAG.value_error()); } - StrSlice::from_bytes(input) + StrRef::from_bytes(input) .map(|inner| Self { inner }) .map_err(|_| Self::TAG.value_error()) } } +impl_ia5_string!(Ia5StringRef<'a>, 'a); + impl<'a> Deref for Ia5StringRef<'a> { - type Target = StrSlice<'a>; + type Target = StrRef<'a>; fn deref(&self) -> &Self::Target { &self.inner } } -impl AsRef<str> for Ia5StringRef<'_> { - fn as_ref(&self) -> &str { - self.as_str() +impl<'a> From<&Ia5StringRef<'a>> for Ia5StringRef<'a> { + fn from(value: &Ia5StringRef<'a>) -> Ia5StringRef<'a> { + *value } } -impl AsRef<[u8]> for Ia5StringRef<'_> { - fn as_ref(&self) -> &[u8] { - self.as_bytes() +impl<'a> From<Ia5StringRef<'a>> for AnyRef<'a> { + fn from(internationalized_string: Ia5StringRef<'a>) -> AnyRef<'a> { + AnyRef::from_tag_and_value(Tag::Ia5String, internationalized_string.inner.into()) } } -impl<'a> DecodeValue<'a> for Ia5StringRef<'a> { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - Self::new(ByteSlice::decode_value(reader, header)?.as_slice()) - } -} +#[cfg(feature = "alloc")] +pub use self::allocation::Ia5String; -impl EncodeValue for Ia5StringRef<'_> { - fn value_len(&self) -> Result<Length> { - self.inner.value_len() +#[cfg(feature = "alloc")] +mod allocation { + use super::Ia5StringRef; + use crate::{ + asn1::AnyRef, + referenced::{OwnedToRef, RefToOwned}, + FixedTag, Result, StrOwned, Tag, + }; + use core::{fmt, ops::Deref}; + + /// ASN.1 `IA5String` type. + /// + /// Supports the [International Alphabet No. 5 (IA5)] character encoding, i.e. + /// the lower 128 characters of the ASCII alphabet. (Note: IA5 is now + /// technically known as the International Reference Alphabet or IRA as + /// specified in the ITU-T's T.50 recommendation). + /// + /// For UTF-8, use [`String`][`alloc::string::String`]. + /// + /// [International Alphabet No. 5 (IA5)]: https://en.wikipedia.org/wiki/T.50_%28standard%29 + #[derive(Clone, Eq, PartialEq, PartialOrd, Ord)] + pub struct Ia5String { + /// Inner value + inner: StrOwned, } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - self.inner.encode_value(writer) + impl Ia5String { + /// Create a new `IA5String`. + pub fn new<T>(input: &T) -> Result<Self> + where + T: AsRef<[u8]> + ?Sized, + { + let input = input.as_ref(); + Ia5StringRef::new(input)?; + + StrOwned::from_bytes(input) + .map(|inner| Self { inner }) + .map_err(|_| Self::TAG.value_error()) + } } -} -impl<'a> FixedTag for Ia5StringRef<'a> { - const TAG: Tag = Tag::Ia5String; -} + impl_ia5_string!(Ia5String); -impl OrdIsValueOrd for Ia5StringRef<'_> {} + impl Deref for Ia5String { + type Target = StrOwned; -impl<'a> From<&Ia5StringRef<'a>> for Ia5StringRef<'a> { - fn from(value: &Ia5StringRef<'a>) -> Ia5StringRef<'a> { - *value + fn deref(&self) -> &Self::Target { + &self.inner + } } -} - -impl<'a> TryFrom<AnyRef<'a>> for Ia5StringRef<'a> { - type Error = Error; - fn try_from(any: AnyRef<'a>) -> Result<Ia5StringRef<'a>> { - any.decode_into() + impl<'a> From<Ia5StringRef<'a>> for Ia5String { + fn from(international_string: Ia5StringRef<'a>) -> Ia5String { + let inner = international_string.inner.into(); + Self { inner } + } } -} -impl<'a> From<Ia5StringRef<'a>> for AnyRef<'a> { - fn from(printable_string: Ia5StringRef<'a>) -> AnyRef<'a> { - AnyRef::from_tag_and_value(Tag::Ia5String, printable_string.inner.into()) + impl<'a> From<&'a Ia5String> for AnyRef<'a> { + fn from(international_string: &'a Ia5String) -> AnyRef<'a> { + AnyRef::from_tag_and_value(Tag::Ia5String, (&international_string.inner).into()) + } } -} -impl<'a> fmt::Display for Ia5StringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(self.as_str()) + impl<'a> RefToOwned<'a> for Ia5StringRef<'a> { + type Owned = Ia5String; + fn ref_to_owned(&self) -> Self::Owned { + Ia5String { + inner: self.inner.ref_to_owned(), + } + } } -} -impl<'a> fmt::Debug for Ia5StringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "Ia5String({:?})", self.as_str()) + impl OwnedToRef for Ia5String { + type Borrowed<'a> = Ia5StringRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + Ia5StringRef { + inner: self.inner.owned_to_ref(), + } + } } } @@ -126,7 +176,7 @@ mod tests { #[test] fn parse_bytes() { let example_bytes = hex!("16 0d 74 65 73 74 31 40 72 73 61 2e 63 6f 6d"); - let printable_string = Ia5StringRef::from_der(&example_bytes).unwrap(); - assert_eq!(printable_string.as_str(), "test1@rsa.com"); + let internationalized_string = Ia5StringRef::from_der(&example_bytes).unwrap(); + assert_eq!(internationalized_string.as_str(), "test1@rsa.com"); } } diff --git a/vendor/der/src/asn1/integer.rs b/vendor/der/src/asn1/integer.rs index 20e2f018f..a6e913d66 100644 --- a/vendor/der/src/asn1/integer.rs +++ b/vendor/der/src/asn1/integer.rs @@ -1,132 +1,17 @@ //! ASN.1 `INTEGER` support. -pub(super) mod bigint; pub(super) mod int; pub(super) mod uint; -use crate::{ - asn1::AnyRef, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, Length, Reader, - Result, SliceWriter, Tag, ValueOrd, Writer, -}; use core::{cmp::Ordering, mem}; -macro_rules! impl_int_encoding { - ($($int:ty => $uint:ty),+) => { - $( - impl<'a> DecodeValue<'a> for $int { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - let bytes = ByteSlice::decode_value(reader, header)?.as_slice(); +use crate::{EncodeValue, Result, SliceWriter}; - let result = if is_highest_bit_set(bytes) { - <$uint>::from_be_bytes(int::decode_to_array(bytes)?) as $int - } else { - Self::from_be_bytes(uint::decode_to_array(bytes)?) - }; - - // Ensure we compute the same encoded length as the original any value - if header.length != result.value_len()? { - return Err(Self::TAG.non_canonical_error()); - } - - Ok(result) - } - } - - impl EncodeValue for $int { - fn value_len(&self) -> Result<Length> { - if *self < 0 { - int::encoded_len(&(*self as $uint).to_be_bytes()) - } else { - uint::encoded_len(&self.to_be_bytes()) - } - } - - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - if *self < 0 { - int::encode_bytes(writer, &(*self as $uint).to_be_bytes()) - } else { - uint::encode_bytes(writer, &self.to_be_bytes()) - } - } - } - - impl FixedTag for $int { - const TAG: Tag = Tag::Integer; - } - - impl ValueOrd for $int { - fn value_cmp(&self, other: &Self) -> Result<Ordering> { - value_cmp(*self, *other) - } - } - - impl TryFrom<AnyRef<'_>> for $int { - type Error = Error; - - fn try_from(any: AnyRef<'_>) -> Result<Self> { - any.decode_into() - } - } - )+ - }; -} - -macro_rules! impl_uint_encoding { - ($($uint:ty),+) => { - $( - impl<'a> DecodeValue<'a> for $uint { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - let bytes = ByteSlice::decode_value(reader, header)?.as_slice(); - let result = Self::from_be_bytes(uint::decode_to_array(bytes)?); - - // Ensure we compute the same encoded length as the original any value - if header.length != result.value_len()? { - return Err(Self::TAG.non_canonical_error()); - } - - Ok(result) - } - } - - impl EncodeValue for $uint { - fn value_len(&self) -> Result<Length> { - uint::encoded_len(&self.to_be_bytes()) - } - - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - uint::encode_bytes(writer, &self.to_be_bytes()) - } - } - - impl FixedTag for $uint { - const TAG: Tag = Tag::Integer; - } - - impl ValueOrd for $uint { - fn value_cmp(&self, other: &Self) -> Result<Ordering> { - value_cmp(*self, *other) - } - } - - impl TryFrom<AnyRef<'_>> for $uint { - type Error = Error; - - fn try_from(any: AnyRef<'_>) -> Result<Self> { - any.decode_into() - } - } - )+ - }; -} - -impl_int_encoding!(i8 => u8, i16 => u16, i32 => u32, i64 => u64, i128 => u128); -impl_uint_encoding!(u8, u16, u32, u64, u128); - -/// Is the highest bit of the first byte in the slice 1? (if present) +/// Is the highest bit of the first byte in the slice set to `1`? (if present) #[inline] fn is_highest_bit_set(bytes: &[u8]) -> bool { bytes - .get(0) + .first() .map(|byte| byte & 0b10000000 != 0) .unwrap_or(false) } diff --git a/vendor/der/src/asn1/integer/bigint.rs b/vendor/der/src/asn1/integer/bigint.rs deleted file mode 100644 index f896406a6..000000000 --- a/vendor/der/src/asn1/integer/bigint.rs +++ /dev/null @@ -1,152 +0,0 @@ -//! "Big" ASN.1 `INTEGER` types. - -use super::uint; -use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, ErrorKind, - FixedTag, Header, Length, Reader, Result, Tag, Writer, -}; - -/// "Big" unsigned ASN.1 `INTEGER` type. -/// -/// Provides direct access to the underlying big endian bytes which comprise an -/// unsigned integer value. -/// -/// Intended for use cases like very large integers that are used in -/// cryptographic applications (e.g. keys, signatures). -#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] -pub struct UIntRef<'a> { - /// Inner value - inner: ByteSlice<'a>, -} - -impl<'a> UIntRef<'a> { - /// Create a new [`UIntRef`] from a byte slice. - pub fn new(bytes: &'a [u8]) -> Result<Self> { - let inner = ByteSlice::new(uint::strip_leading_zeroes(bytes)) - .map_err(|_| ErrorKind::Length { tag: Self::TAG })?; - - Ok(Self { inner }) - } - - /// Borrow the inner byte slice which contains the least significant bytes - /// of a big endian integer value with all leading zeros stripped. - pub fn as_bytes(&self) -> &'a [u8] { - self.inner.as_slice() - } - - /// Get the length of this [`UIntRef`] in bytes. - pub fn len(&self) -> Length { - self.inner.len() - } - - /// Is the inner byte slice empty? - pub fn is_empty(&self) -> bool { - self.inner.is_empty() - } -} - -impl<'a> DecodeValue<'a> for UIntRef<'a> { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - let bytes = ByteSlice::decode_value(reader, header)?.as_slice(); - 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()? != header.length { - return Err(Self::TAG.non_canonical_error()); - } - - Ok(result) - } -} - -impl<'a> EncodeValue for UIntRef<'a> { - fn value_len(&self) -> Result<Length> { - uint::encoded_len(self.inner.as_slice()) - } - - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - // Add leading `0x00` byte if required - if self.value_len()? > self.len() { - writer.write_byte(0)?; - } - - writer.write(self.as_bytes()) - } -} - -impl<'a> From<&UIntRef<'a>> for UIntRef<'a> { - fn from(value: &UIntRef<'a>) -> UIntRef<'a> { - *value - } -} - -impl<'a> TryFrom<AnyRef<'a>> for UIntRef<'a> { - type Error = Error; - - fn try_from(any: AnyRef<'a>) -> Result<UIntRef<'a>> { - any.decode_into() - } -} - -impl<'a> FixedTag for UIntRef<'a> { - const TAG: Tag = Tag::Integer; -} - -impl<'a> OrdIsValueOrd for UIntRef<'a> {} - -#[cfg(test)] -mod tests { - use super::UIntRef; - use crate::{ - asn1::{integer::tests::*, AnyRef}, - Decode, Encode, ErrorKind, SliceWriter, Tag, - }; - - #[test] - fn decode_uint_bytes() { - assert_eq!(&[0], UIntRef::from_der(I0_BYTES).unwrap().as_bytes()); - assert_eq!(&[127], UIntRef::from_der(I127_BYTES).unwrap().as_bytes()); - assert_eq!(&[128], UIntRef::from_der(I128_BYTES).unwrap().as_bytes()); - assert_eq!(&[255], UIntRef::from_der(I255_BYTES).unwrap().as_bytes()); - - assert_eq!( - &[0x01, 0x00], - UIntRef::from_der(I256_BYTES).unwrap().as_bytes() - ); - - assert_eq!( - &[0x7F, 0xFF], - UIntRef::from_der(I32767_BYTES).unwrap().as_bytes() - ); - } - - #[test] - fn encode_uint_bytes() { - for &example in &[ - I0_BYTES, - I127_BYTES, - I128_BYTES, - I255_BYTES, - I256_BYTES, - I32767_BYTES, - ] { - let uint = UIntRef::from_der(example).unwrap(); - - let mut buf = [0u8; 128]; - let mut encoder = SliceWriter::new(&mut buf); - uint.encode(&mut encoder).unwrap(); - - let result = encoder.finish().unwrap(); - assert_eq!(example, result); - } - } - - #[test] - fn reject_oversize_without_extra_zero() { - let err = UIntRef::try_from(AnyRef::new(Tag::Integer, &[0x81]).unwrap()) - .err() - .unwrap(); - - assert_eq!(err.kind(), ErrorKind::Value { tag: Tag::Integer }); - } -} diff --git a/vendor/der/src/asn1/integer/int.rs b/vendor/der/src/asn1/integer/int.rs index a9fe43890..bccc5210c 100644 --- a/vendor/der/src/asn1/integer/int.rs +++ b/vendor/der/src/asn1/integer/int.rs @@ -1,12 +1,310 @@ -//! Support for encoding negative integers +//! Support for encoding signed integers -use super::is_highest_bit_set; -use crate::{ErrorKind, Length, Result, Writer}; +use super::{is_highest_bit_set, uint, value_cmp}; +use crate::{ + ord::OrdIsValueOrd, AnyRef, BytesRef, DecodeValue, EncodeValue, Error, ErrorKind, FixedTag, + Header, Length, Reader, Result, Tag, ValueOrd, Writer, +}; +use core::cmp::Ordering; -/// Decode an unsigned integer of the specified size. +#[cfg(feature = "alloc")] +pub use allocating::Int; + +macro_rules! impl_encoding_traits { + ($($int:ty => $uint:ty),+) => { + $( + impl<'a> DecodeValue<'a> for $int { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + let mut buf = [0u8; Self::BITS as usize / 8]; + let max_length = u32::from(header.length) as usize; + + if max_length > buf.len() { + return Err(Self::TAG.non_canonical_error()); + } + + let bytes = reader.read_into(&mut buf[..max_length])?; + + let result = if is_highest_bit_set(bytes) { + <$uint>::from_be_bytes(decode_to_array(bytes)?) as $int + } else { + Self::from_be_bytes(uint::decode_to_array(bytes)?) + }; + + // Ensure we compute the same encoded length as the original any value + if header.length != result.value_len()? { + return Err(Self::TAG.non_canonical_error()); + } + + Ok(result) + } + } + + impl EncodeValue for $int { + fn value_len(&self) -> Result<Length> { + if *self < 0 { + negative_encoded_len(&(*self as $uint).to_be_bytes()) + } else { + uint::encoded_len(&self.to_be_bytes()) + } + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + if *self < 0 { + encode_bytes(writer, &(*self as $uint).to_be_bytes()) + } else { + uint::encode_bytes(writer, &self.to_be_bytes()) + } + } + } + + impl FixedTag for $int { + const TAG: Tag = Tag::Integer; + } + + impl ValueOrd for $int { + fn value_cmp(&self, other: &Self) -> Result<Ordering> { + value_cmp(*self, *other) + } + } + + impl TryFrom<AnyRef<'_>> for $int { + type Error = Error; + + fn try_from(any: AnyRef<'_>) -> Result<Self> { + any.decode_as() + } + } + )+ + }; +} + +impl_encoding_traits!(i8 => u8, i16 => u16, i32 => u32, i64 => u64, i128 => u128); + +/// Signed arbitrary precision ASN.1 `INTEGER` reference type. +/// +/// Provides direct access to the underlying big endian bytes which comprise +/// an signed integer value. +/// +/// Intended for use cases like very large integers that are used in +/// cryptographic applications (e.g. keys, signatures). +#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] +pub struct IntRef<'a> { + /// Inner value + inner: BytesRef<'a>, +} + +impl<'a> IntRef<'a> { + /// Create a new [`IntRef`] from a byte slice. + pub fn new(bytes: &'a [u8]) -> Result<Self> { + let inner = BytesRef::new(strip_leading_ones(bytes)) + .map_err(|_| ErrorKind::Length { tag: Self::TAG })?; + + Ok(Self { inner }) + } + + /// Borrow the inner byte slice which contains the least significant bytes + /// of a big endian integer value with all leading ones stripped. + pub fn as_bytes(&self) -> &'a [u8] { + self.inner.as_slice() + } + + /// Get the length of this [`IntRef`] in bytes. + pub fn len(&self) -> Length { + self.inner.len() + } + + /// Is the inner byte slice empty? + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } +} + +impl_any_conversions!(IntRef<'a>, 'a); + +impl<'a> DecodeValue<'a> for IntRef<'a> { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + let bytes = BytesRef::decode_value(reader, header)?; + validate_canonical(bytes.as_slice())?; + + let result = Self::new(bytes.as_slice())?; + + // Ensure we compute the same encoded length as the original any value. + if result.value_len()? != header.length { + return Err(Self::TAG.non_canonical_error()); + } + + Ok(result) + } +} + +impl<'a> EncodeValue for IntRef<'a> { + fn value_len(&self) -> Result<Length> { + // Signed integers always hold their full encoded form. + Ok(self.inner.len()) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + writer.write(self.as_bytes()) + } +} + +impl<'a> From<&IntRef<'a>> for IntRef<'a> { + fn from(value: &IntRef<'a>) -> IntRef<'a> { + *value + } +} + +impl<'a> FixedTag for IntRef<'a> { + const TAG: Tag = Tag::Integer; +} + +impl<'a> OrdIsValueOrd for IntRef<'a> {} + +#[cfg(feature = "alloc")] +mod allocating { + use super::{strip_leading_ones, validate_canonical, IntRef}; + use crate::{ + asn1::Uint, + ord::OrdIsValueOrd, + referenced::{OwnedToRef, RefToOwned}, + BytesOwned, DecodeValue, EncodeValue, ErrorKind, FixedTag, Header, Length, Reader, Result, + Tag, Writer, + }; + use alloc::vec::Vec; + + /// Signed arbitrary precision ASN.1 `INTEGER` type. + /// + /// Provides heap-allocated storage for big endian bytes which comprise an + /// signed integer value. + /// + /// Intended for use cases like very large integers that are used in + /// cryptographic applications (e.g. keys, signatures). + #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] + pub struct Int { + /// Inner value + inner: BytesOwned, + } + + impl Int { + /// Create a new [`Int`] from a byte slice. + pub fn new(bytes: &[u8]) -> Result<Self> { + let inner = BytesOwned::new(strip_leading_ones(bytes)) + .map_err(|_| ErrorKind::Length { tag: Self::TAG })?; + + Ok(Self { inner }) + } + + /// Borrow the inner byte slice which contains the least significant bytes + /// of a big endian integer value with all leading ones stripped. + pub fn as_bytes(&self) -> &[u8] { + self.inner.as_slice() + } + + /// Get the length of this [`Int`] in bytes. + pub fn len(&self) -> Length { + self.inner.len() + } + + /// Is the inner byte slice empty? + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } + } + + impl_any_conversions!(Int); + + impl<'a> DecodeValue<'a> for Int { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + let bytes = BytesOwned::decode_value(reader, header)?; + validate_canonical(bytes.as_slice())?; + + let result = Self::new(bytes.as_slice())?; + + // Ensure we compute the same encoded length as the original any value. + if result.value_len()? != header.length { + return Err(Self::TAG.non_canonical_error()); + } + + Ok(result) + } + } + + impl EncodeValue for Int { + fn value_len(&self) -> Result<Length> { + // Signed integers always hold their full encoded form. + Ok(self.inner.len()) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + writer.write(self.as_bytes()) + } + } + + impl<'a> From<&IntRef<'a>> for Int { + fn from(value: &IntRef<'a>) -> Int { + let inner = BytesOwned::new(value.as_bytes()).expect("Invalid Int"); + Int { inner } + } + } + + impl From<Uint> for Int { + fn from(value: Uint) -> Self { + let mut inner: Vec<u8> = Vec::new(); + + // Add leading `0x00` byte if required + if value.value_len().expect("invalid Uint") > value.len() { + inner.push(0x00); + } + + inner.extend_from_slice(value.as_bytes()); + let inner = BytesOwned::new(inner).expect("invalid Uint"); + + Int { inner } + } + } + + impl FixedTag for Int { + const TAG: Tag = Tag::Integer; + } + + impl OrdIsValueOrd for Int {} + + impl<'a> RefToOwned<'a> for IntRef<'a> { + type Owned = Int; + fn ref_to_owned(&self) -> Self::Owned { + let inner = self.inner.ref_to_owned(); + + Int { inner } + } + } + + impl OwnedToRef for Int { + type Borrowed<'a> = IntRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + let inner = self.inner.owned_to_ref(); + + IntRef { inner } + } + } +} + +/// Ensure `INTEGER` is canonically encoded. +fn validate_canonical(bytes: &[u8]) -> Result<()> { + // The `INTEGER` type always encodes a signed value and we're decoding + // as signed here, so we allow a zero extension or sign extension byte, + // but only as permitted under DER canonicalization. + match bytes { + [] => Err(Tag::Integer.non_canonical_error()), + [0x00, byte, ..] if *byte < 0x80 => Err(Tag::Integer.non_canonical_error()), + [0xFF, byte, ..] if *byte >= 0x80 => Err(Tag::Integer.non_canonical_error()), + _ => Ok(()), + } +} + +/// Decode an signed integer of the specified size. /// /// Returns a byte array of the requested size containing a big endian integer. -pub(super) fn decode_to_array<const N: usize>(bytes: &[u8]) -> Result<[u8; N]> { +fn decode_to_array<const N: usize>(bytes: &[u8]) -> Result<[u8; N]> { match N.checked_sub(bytes.len()) { Some(offset) => { let mut output = [0xFFu8; N]; @@ -27,21 +325,21 @@ 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<W>(writer: &mut W, bytes: &[u8]) -> Result<()> +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. +/// Get the encoded length for the given **negative** integer serialized as bytes. #[inline] -pub(super) fn encoded_len(bytes: &[u8]) -> Result<Length> { +fn negative_encoded_len(bytes: &[u8]) -> Result<Length> { Length::try_from(strip_leading_ones(bytes).len()) } /// Strip the leading all-ones bytes from the given byte slice. -fn strip_leading_ones(mut bytes: &[u8]) -> &[u8] { +pub(crate) fn strip_leading_ones(mut bytes: &[u8]) -> &[u8] { while let Some((byte, rest)) = bytes.split_first() { if *byte == 0xFF && is_highest_bit_set(rest) { bytes = rest; @@ -53,3 +351,92 @@ fn strip_leading_ones(mut bytes: &[u8]) -> &[u8] { bytes } + +#[cfg(test)] +mod tests { + use super::{validate_canonical, IntRef}; + use crate::{asn1::integer::tests::*, Decode, Encode, SliceWriter}; + + #[test] + fn validate_canonical_ok() { + assert_eq!(validate_canonical(&[0x00]), Ok(())); + assert_eq!(validate_canonical(&[0x01]), Ok(())); + assert_eq!(validate_canonical(&[0x00, 0x80]), Ok(())); + assert_eq!(validate_canonical(&[0xFF, 0x00]), Ok(())); + } + + #[test] + fn validate_canonical_err() { + // Empty integers are always non-canonical. + assert!(validate_canonical(&[]).is_err()); + + // Positives with excessive zero extension are non-canonical. + assert!(validate_canonical(&[0x00, 0x00]).is_err()); + + // Negatives with excessive sign extension are non-canonical. + assert!(validate_canonical(&[0xFF, 0x80]).is_err()); + } + + #[test] + fn decode_intref() { + // Positive numbers decode, but have zero extensions as necessary + // (to distinguish them from negative representations). + assert_eq!(&[0], IntRef::from_der(I0_BYTES).unwrap().as_bytes()); + assert_eq!(&[127], IntRef::from_der(I127_BYTES).unwrap().as_bytes()); + assert_eq!(&[0, 128], IntRef::from_der(I128_BYTES).unwrap().as_bytes()); + assert_eq!(&[0, 255], IntRef::from_der(I255_BYTES).unwrap().as_bytes()); + + assert_eq!( + &[0x01, 0x00], + IntRef::from_der(I256_BYTES).unwrap().as_bytes() + ); + + assert_eq!( + &[0x7F, 0xFF], + IntRef::from_der(I32767_BYTES).unwrap().as_bytes() + ); + + // Negative integers decode. + assert_eq!(&[128], IntRef::from_der(INEG128_BYTES).unwrap().as_bytes()); + assert_eq!( + &[255, 127], + IntRef::from_der(INEG129_BYTES).unwrap().as_bytes() + ); + assert_eq!( + &[128, 0], + IntRef::from_der(INEG32768_BYTES).unwrap().as_bytes() + ); + } + + #[test] + fn encode_intref() { + for &example in &[ + I0_BYTES, + I127_BYTES, + I128_BYTES, + I255_BYTES, + I256_BYTES, + I32767_BYTES, + ] { + let uint = IntRef::from_der(example).unwrap(); + + let mut buf = [0u8; 128]; + let mut encoder = SliceWriter::new(&mut buf); + uint.encode(&mut encoder).unwrap(); + + let result = encoder.finish().unwrap(); + assert_eq!(example, result); + } + + for &example in &[INEG128_BYTES, INEG129_BYTES, INEG32768_BYTES] { + let uint = IntRef::from_der(example).unwrap(); + + let mut buf = [0u8; 128]; + let mut encoder = SliceWriter::new(&mut buf); + uint.encode(&mut encoder).unwrap(); + + let result = encoder.finish().unwrap(); + assert_eq!(example, result); + } + } +} diff --git a/vendor/der/src/asn1/integer/uint.rs b/vendor/der/src/asn1/integer/uint.rs index e45a72f2a..95c6297c2 100644 --- a/vendor/der/src/asn1/integer/uint.rs +++ b/vendor/der/src/asn1/integer/uint.rs @@ -1,6 +1,270 @@ //! Unsigned integer decoders/encoders. -use crate::{Length, Result, Tag, Writer}; +use super::value_cmp; +use crate::{ + ord::OrdIsValueOrd, AnyRef, BytesRef, DecodeValue, EncodeValue, Error, ErrorKind, FixedTag, + Header, Length, Reader, Result, Tag, ValueOrd, Writer, +}; +use core::cmp::Ordering; + +#[cfg(feature = "alloc")] +pub use allocating::Uint; + +macro_rules! impl_encoding_traits { + ($($uint:ty),+) => { + $( + impl<'a> DecodeValue<'a> for $uint { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + // Integers always encodes as a signed value, unsigned gets a leading 0x00 that + // needs to be stripped off. We need to provide room for it. + const UNSIGNED_HEADROOM: usize = 1; + + let mut buf = [0u8; (Self::BITS as usize / 8) + UNSIGNED_HEADROOM]; + let max_length = u32::from(header.length) as usize; + + if max_length > buf.len() { + return Err(Self::TAG.non_canonical_error()); + } + + let bytes = reader.read_into(&mut buf[..max_length])?; + + let result = Self::from_be_bytes(decode_to_array(bytes)?); + + // Ensure we compute the same encoded length as the original any value + if header.length != result.value_len()? { + return Err(Self::TAG.non_canonical_error()); + } + + Ok(result) + } + } + + impl EncodeValue for $uint { + fn value_len(&self) -> Result<Length> { + encoded_len(&self.to_be_bytes()) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + encode_bytes(writer, &self.to_be_bytes()) + } + } + + impl FixedTag for $uint { + const TAG: Tag = Tag::Integer; + } + + impl ValueOrd for $uint { + fn value_cmp(&self, other: &Self) -> Result<Ordering> { + value_cmp(*self, *other) + } + } + + impl TryFrom<AnyRef<'_>> for $uint { + type Error = Error; + + fn try_from(any: AnyRef<'_>) -> Result<Self> { + any.decode_as() + } + } + )+ + }; +} + +impl_encoding_traits!(u8, u16, u32, u64, u128); + +/// Unsigned arbitrary precision ASN.1 `INTEGER` reference type. +/// +/// Provides direct access to the underlying big endian bytes which comprise an +/// unsigned integer value. +/// +/// Intended for use cases like very large integers that are used in +/// cryptographic applications (e.g. keys, signatures). +#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] +pub struct UintRef<'a> { + /// Inner value + inner: BytesRef<'a>, +} + +impl<'a> UintRef<'a> { + /// Create a new [`UintRef`] from a byte slice. + pub fn new(bytes: &'a [u8]) -> Result<Self> { + let inner = BytesRef::new(strip_leading_zeroes(bytes)) + .map_err(|_| ErrorKind::Length { tag: Self::TAG })?; + + Ok(Self { inner }) + } + + /// Borrow the inner byte slice which contains the least significant bytes + /// of a big endian integer value with all leading zeros stripped. + pub fn as_bytes(&self) -> &'a [u8] { + self.inner.as_slice() + } + + /// Get the length of this [`UintRef`] in bytes. + pub fn len(&self) -> Length { + self.inner.len() + } + + /// Is the inner byte slice empty? + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } +} + +impl_any_conversions!(UintRef<'a>, 'a); + +impl<'a> DecodeValue<'a> for UintRef<'a> { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + let bytes = BytesRef::decode_value(reader, header)?.as_slice(); + let result = Self::new(decode_to_slice(bytes)?)?; + + // Ensure we compute the same encoded length as the original any value. + if result.value_len()? != header.length { + return Err(Self::TAG.non_canonical_error()); + } + + Ok(result) + } +} + +impl<'a> EncodeValue for UintRef<'a> { + fn value_len(&self) -> Result<Length> { + encoded_len(self.inner.as_slice()) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + // Add leading `0x00` byte if required + if self.value_len()? > self.len() { + writer.write_byte(0)?; + } + + writer.write(self.as_bytes()) + } +} + +impl<'a> From<&UintRef<'a>> for UintRef<'a> { + fn from(value: &UintRef<'a>) -> UintRef<'a> { + *value + } +} + +impl<'a> FixedTag for UintRef<'a> { + const TAG: Tag = Tag::Integer; +} + +impl<'a> OrdIsValueOrd for UintRef<'a> {} + +#[cfg(feature = "alloc")] +mod allocating { + use super::{decode_to_slice, encoded_len, strip_leading_zeroes, UintRef}; + use crate::{ + ord::OrdIsValueOrd, + referenced::{OwnedToRef, RefToOwned}, + BytesOwned, DecodeValue, EncodeValue, ErrorKind, FixedTag, Header, Length, Reader, Result, + Tag, Writer, + }; + + /// Unsigned arbitrary precision ASN.1 `INTEGER` type. + /// + /// Provides heap-allocated storage for big endian bytes which comprise an + /// unsigned integer value. + /// + /// Intended for use cases like very large integers that are used in + /// cryptographic applications (e.g. keys, signatures). + #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] + pub struct Uint { + /// Inner value + inner: BytesOwned, + } + + impl Uint { + /// Create a new [`Uint`] from a byte slice. + pub fn new(bytes: &[u8]) -> Result<Self> { + let inner = BytesOwned::new(strip_leading_zeroes(bytes)) + .map_err(|_| ErrorKind::Length { tag: Self::TAG })?; + + Ok(Self { inner }) + } + + /// Borrow the inner byte slice which contains the least significant bytes + /// of a big endian integer value with all leading zeros stripped. + pub fn as_bytes(&self) -> &[u8] { + self.inner.as_slice() + } + + /// Get the length of this [`Uint`] in bytes. + pub fn len(&self) -> Length { + self.inner.len() + } + + /// Is the inner byte slice empty? + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } + } + + impl_any_conversions!(Uint); + + impl<'a> DecodeValue<'a> for Uint { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + let bytes = BytesOwned::decode_value(reader, header)?; + let result = Self::new(decode_to_slice(bytes.as_slice())?)?; + + // Ensure we compute the same encoded length as the original any value. + if result.value_len()? != header.length { + return Err(Self::TAG.non_canonical_error()); + } + + Ok(result) + } + } + + impl EncodeValue for Uint { + fn value_len(&self) -> Result<Length> { + encoded_len(self.inner.as_slice()) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + // Add leading `0x00` byte if required + if self.value_len()? > self.len() { + writer.write_byte(0)?; + } + + writer.write(self.as_bytes()) + } + } + + impl<'a> From<&UintRef<'a>> for Uint { + fn from(value: &UintRef<'a>) -> Uint { + let inner = BytesOwned::new(value.as_bytes()).expect("Invalid Uint"); + Uint { inner } + } + } + + impl FixedTag for Uint { + const TAG: Tag = Tag::Integer; + } + + impl OrdIsValueOrd for Uint {} + + impl<'a> RefToOwned<'a> for UintRef<'a> { + type Owned = Uint; + fn ref_to_owned(&self) -> Self::Owned { + let inner = self.inner.ref_to_owned(); + + Uint { inner } + } + } + + impl OwnedToRef for Uint { + type Borrowed<'a> = UintRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + let inner = self.inner.owned_to_ref(); + + UintRef { inner } + } + } +} /// Decode an unsigned integer into a big endian byte slice with all leading /// zeroes removed. @@ -75,13 +339,13 @@ pub(crate) fn strip_leading_zeroes(mut bytes: &[u8]) -> &[u8] { /// Does the given integer need a leading zero? fn needs_leading_zero(bytes: &[u8]) -> bool { - matches!(bytes.get(0), Some(byte) if *byte >= 0x80) + matches!(bytes.first(), Some(byte) if *byte >= 0x80) } #[cfg(test)] mod tests { - use super::decode_to_array; - use crate::{ErrorKind, Tag}; + use super::{decode_to_array, UintRef}; + use crate::{asn1::integer::tests::*, AnyRef, Decode, Encode, ErrorKind, SliceWriter, Tag}; #[test] fn decode_to_array_no_leading_zero() { @@ -113,4 +377,52 @@ mod tests { let err = decode_to_array::<1>(&[1, 2, 3]).err().unwrap(); assert_eq!(err.kind(), ErrorKind::Length { tag: Tag::Integer }); } + + #[test] + fn decode_uintref() { + assert_eq!(&[0], UintRef::from_der(I0_BYTES).unwrap().as_bytes()); + assert_eq!(&[127], UintRef::from_der(I127_BYTES).unwrap().as_bytes()); + assert_eq!(&[128], UintRef::from_der(I128_BYTES).unwrap().as_bytes()); + assert_eq!(&[255], UintRef::from_der(I255_BYTES).unwrap().as_bytes()); + + assert_eq!( + &[0x01, 0x00], + UintRef::from_der(I256_BYTES).unwrap().as_bytes() + ); + + assert_eq!( + &[0x7F, 0xFF], + UintRef::from_der(I32767_BYTES).unwrap().as_bytes() + ); + } + + #[test] + fn encode_uintref() { + for &example in &[ + I0_BYTES, + I127_BYTES, + I128_BYTES, + I255_BYTES, + I256_BYTES, + I32767_BYTES, + ] { + let uint = UintRef::from_der(example).unwrap(); + + let mut buf = [0u8; 128]; + let mut encoder = SliceWriter::new(&mut buf); + uint.encode(&mut encoder).unwrap(); + + let result = encoder.finish().unwrap(); + assert_eq!(example, result); + } + } + + #[test] + fn reject_oversize_without_extra_zero() { + let err = UintRef::try_from(AnyRef::new(Tag::Integer, &[0x81]).unwrap()) + .err() + .unwrap(); + + assert_eq!(err.kind(), ErrorKind::Value { tag: Tag::Integer }); + } } diff --git a/vendor/der/src/asn1/internal_macros.rs b/vendor/der/src/asn1/internal_macros.rs new file mode 100644 index 000000000..10ad99d23 --- /dev/null +++ b/vendor/der/src/asn1/internal_macros.rs @@ -0,0 +1,75 @@ +macro_rules! impl_any_conversions { + ($type: ty) => { + impl_any_conversions!($type, ); + }; + ($type: ty, $($li: lifetime)?) => { + impl<'__der: $($li),*, $($li),*> TryFrom<$crate::AnyRef<'__der>> for $type { + type Error = $crate::Error; + + fn try_from(any: $crate::AnyRef<'__der>) -> Result<$type> { + any.decode_as() + } + } + + #[cfg(feature = "alloc")] + impl<'__der: $($li),*, $($li),*> TryFrom<&'__der $crate::Any> for $type { + type Error = $crate::Error; + + fn try_from(any: &'__der $crate::Any) -> Result<$type> { + any.decode_as() + } + } + }; +} + +macro_rules! impl_string_type { + ($type: ty, $($li: lifetime)?) => { + impl_any_conversions!($type, $($li),*); + + mod __impl_string { + use super::*; + + use crate::{ + ord::OrdIsValueOrd, BytesRef, DecodeValue, EncodeValue, Header, Length, Reader, + Result, Writer, + }; + use core::{fmt, str}; + + impl<$($li),*> AsRef<str> for $type { + fn as_ref(&self) -> &str { + self.as_str() + } + } + + impl<$($li),*> AsRef<[u8]> for $type { + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } + } + + impl<'__der: $($li),*, $($li),*> DecodeValue<'__der> for $type { + fn decode_value<R: Reader<'__der>>(reader: &mut R, header: Header) -> Result<Self> { + Self::new(BytesRef::decode_value(reader, header)?.as_slice()) + } + } + + impl<$($li),*> EncodeValue for $type { + fn value_len(&self) -> Result<Length> { + self.inner.value_len() + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + self.inner.encode_value(writer) + } + } + + impl<$($li),*> OrdIsValueOrd for $type {} + + impl<$($li),*> fmt::Display for $type { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(self.as_str()) + } + } + } + }; +} diff --git a/vendor/der/src/asn1/null.rs b/vendor/der/src/asn1/null.rs index e87729f18..7c1e2058a 100644 --- a/vendor/der/src/asn1/null.rs +++ b/vendor/der/src/asn1/null.rs @@ -1,7 +1,7 @@ //! ASN.1 `NULL` support. use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, ErrorKind, + asn1::AnyRef, ord::OrdIsValueOrd, BytesRef, DecodeValue, EncodeValue, Error, ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, Writer, }; @@ -9,6 +9,8 @@ use crate::{ #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] pub struct Null; +impl_any_conversions!(Null); + impl<'a> DecodeValue<'a> for Null { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { if header.length.is_zero() { @@ -24,7 +26,7 @@ impl EncodeValue for Null { Ok(Length::ZERO) } - fn encode_value(&self, _writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, _writer: &mut impl Writer) -> Result<()> { Ok(()) } } @@ -37,15 +39,7 @@ impl OrdIsValueOrd for Null {} impl<'a> From<Null> for AnyRef<'a> { fn from(_: Null) -> AnyRef<'a> { - AnyRef::from_tag_and_value(Tag::Null, ByteSlice::default()) - } -} - -impl TryFrom<AnyRef<'_>> for Null { - type Error = Error; - - fn try_from(any: AnyRef<'_>) -> Result<Null> { - any.decode_into() + AnyRef::from_tag_and_value(Tag::Null, BytesRef::default()) } } @@ -75,7 +69,7 @@ impl EncodeValue for () { Ok(Length::ZERO) } - fn encode_value(&self, _writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, _writer: &mut impl Writer) -> Result<()> { Ok(()) } } diff --git a/vendor/der/src/asn1/octet_string.rs b/vendor/der/src/asn1/octet_string.rs index 6f5b91a3d..d5eb0dd0f 100644 --- a/vendor/der/src/asn1/octet_string.rs +++ b/vendor/der/src/asn1/octet_string.rs @@ -1,13 +1,10 @@ //! ASN.1 `OCTET STRING` support. use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, ErrorKind, + asn1::AnyRef, ord::OrdIsValueOrd, BytesRef, Decode, DecodeValue, EncodeValue, ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, Writer, }; -#[cfg(feature = "alloc")] -use alloc::vec::Vec; - /// ASN.1 `OCTET STRING` type: borrowed form. /// /// Octet strings represent contiguous sequences of octets, a.k.a. bytes. @@ -16,13 +13,13 @@ use alloc::vec::Vec; #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] pub struct OctetStringRef<'a> { /// Inner value - inner: ByteSlice<'a>, + inner: BytesRef<'a>, } impl<'a> OctetStringRef<'a> { /// Create a new ASN.1 `OCTET STRING` from a byte slice. pub fn new(slice: &'a [u8]) -> Result<Self> { - ByteSlice::new(slice) + BytesRef::new(slice) .map(|inner| Self { inner }) .map_err(|_| ErrorKind::Length { tag: Self::TAG }.into()) } @@ -41,8 +38,15 @@ impl<'a> OctetStringRef<'a> { pub fn is_empty(&self) -> bool { self.inner.is_empty() } + + /// Parse `T` from this `OCTET STRING`'s contents. + pub fn decode_into<T: Decode<'a>>(&self) -> Result<T> { + Decode::from_der(self.as_bytes()) + } } +impl_any_conversions!(OctetStringRef<'a>, 'a); + impl AsRef<[u8]> for OctetStringRef<'_> { fn as_ref(&self) -> &[u8] { self.as_bytes() @@ -51,7 +55,7 @@ impl AsRef<[u8]> for OctetStringRef<'_> { impl<'a> DecodeValue<'a> for OctetStringRef<'a> { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - let inner = ByteSlice::decode_value(reader, header)?; + let inner = BytesRef::decode_value(reader, header)?; Ok(Self { inner }) } } @@ -61,7 +65,7 @@ impl EncodeValue for OctetStringRef<'_> { self.inner.value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { self.inner.encode_value(writer) } } @@ -78,14 +82,6 @@ impl<'a> From<&OctetStringRef<'a>> for OctetStringRef<'a> { } } -impl<'a> TryFrom<AnyRef<'a>> for OctetStringRef<'a> { - type Error = Error; - - fn try_from(any: AnyRef<'a>) -> Result<OctetStringRef<'a>> { - any.decode_into() - } -} - impl<'a> From<OctetStringRef<'a>> for AnyRef<'a> { fn from(octet_string: OctetStringRef<'a>) -> AnyRef<'a> { AnyRef::from_tag_and_value(Tag::OctetString, octet_string.inner) @@ -98,85 +94,137 @@ impl<'a> From<OctetStringRef<'a>> for &'a [u8] { } } -/// ASN.1 `OCTET STRING` type: owned form.. -/// -/// Octet strings represent contiguous sequences of octets, a.k.a. bytes. -/// -/// This type provides the same functionality as [`OctetStringRef`] but owns -/// the backing data. #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] -#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] -pub struct OctetString { - /// Bitstring represented as a slice of bytes. - inner: Vec<u8>, -} +pub use self::allocating::OctetString; #[cfg(feature = "alloc")] -impl OctetString { - /// Create a new ASN.1 `OCTET STRING`. - pub fn new(bytes: impl Into<Vec<u8>>) -> Result<Self> { - let inner = bytes.into(); +mod allocating { + use super::*; + use crate::referenced::*; + use alloc::vec::Vec; - // Ensure the bytes parse successfully as an `OctetStringRef` - OctetStringRef::new(&inner)?; + /// ASN.1 `OCTET STRING` type: owned form.. + /// + /// Octet strings represent contiguous sequences of octets, a.k.a. bytes. + /// + /// This type provides the same functionality as [`OctetStringRef`] but owns + /// the backing data. + #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] + pub struct OctetString { + /// Bitstring represented as a slice of bytes. + inner: Vec<u8>, + } - Ok(Self { inner }) + impl OctetString { + /// Create a new ASN.1 `OCTET STRING`. + pub fn new(bytes: impl Into<Vec<u8>>) -> Result<Self> { + let inner = bytes.into(); + + // Ensure the bytes parse successfully as an `OctetStringRef` + OctetStringRef::new(&inner)?; + + Ok(Self { inner }) + } + + /// Borrow the inner byte slice. + pub fn as_bytes(&self) -> &[u8] { + self.inner.as_slice() + } + + /// Take ownership of the octet string. + pub fn into_bytes(self) -> Vec<u8> { + self.inner + } + + /// Get the length of the inner byte slice. + pub fn len(&self) -> Length { + self.value_len().expect("invalid OCTET STRING length") + } + + /// Is the inner byte slice empty? + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } } - /// Borrow the inner byte slice. - pub fn as_bytes(&self) -> &[u8] { - self.inner.as_slice() + impl_any_conversions!(OctetString); + + impl AsRef<[u8]> for OctetString { + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } } - /// Get the length of the inner byte slice. - pub fn len(&self) -> Length { - self.value_len().expect("invalid OCTET STRING length") + impl<'a> DecodeValue<'a> for OctetString { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + Self::new(reader.read_vec(header.length)?) + } } - /// Is the inner byte slice empty? - pub fn is_empty(&self) -> bool { - self.inner.is_empty() + impl EncodeValue for OctetString { + fn value_len(&self) -> Result<Length> { + self.inner.len().try_into() + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + writer.write(&self.inner) + } } -} -#[cfg(feature = "alloc")] -impl AsRef<[u8]> for OctetString { - fn as_ref(&self) -> &[u8] { - self.as_bytes() + impl FixedTag for OctetString { + const TAG: Tag = Tag::OctetString; } -} -#[cfg(feature = "alloc")] -impl<'a> DecodeValue<'a> for OctetString { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - Self::new(reader.read_vec(header.length)?) + impl<'a> From<&'a OctetString> for OctetStringRef<'a> { + fn from(octet_string: &'a OctetString) -> OctetStringRef<'a> { + // Ensured to parse successfully in constructor + OctetStringRef::new(&octet_string.inner).expect("invalid OCTET STRING") + } } -} -#[cfg(feature = "alloc")] -impl EncodeValue for OctetString { - fn value_len(&self) -> Result<Length> { - self.inner.len().try_into() + impl OrdIsValueOrd for OctetString {} + + impl<'a> RefToOwned<'a> for OctetStringRef<'a> { + type Owned = OctetString; + fn ref_to_owned(&self) -> Self::Owned { + OctetString { + inner: Vec::from(self.inner.as_slice()), + } + } } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - writer.write(&self.inner) + impl OwnedToRef for OctetString { + type Borrowed<'a> = OctetStringRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + self.into() + } } -} -#[cfg(feature = "alloc")] -impl FixedTag for OctetString { - const TAG: Tag = Tag::OctetString; -} + // Implement by hand because the derive would create invalid values. + // Use the constructor to create a valid value. + #[cfg(feature = "arbitrary")] + impl<'a> arbitrary::Arbitrary<'a> for OctetString { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + Self::new(Vec::arbitrary(u)?).map_err(|_| arbitrary::Error::IncorrectFormat) + } -#[cfg(feature = "alloc")] -impl<'a> From<&'a OctetString> for OctetStringRef<'a> { - fn from(octet_string: &'a OctetString) -> OctetStringRef<'a> { - // Ensured to parse successfully in constructor - OctetStringRef::new(&octet_string.inner).expect("invalid OCTET STRING") + fn size_hint(depth: usize) -> (usize, Option<usize>) { + arbitrary::size_hint::and(u8::size_hint(depth), Vec::<u8>::size_hint(depth)) + } } } -#[cfg(feature = "alloc")] -impl OrdIsValueOrd for OctetString {} +#[cfg(test)] +mod tests { + use crate::asn1::{OctetStringRef, PrintableStringRef}; + + #[test] + fn octet_string_decode_into() { + // PrintableString "hi" + let der = b"\x13\x02\x68\x69"; + let oct = OctetStringRef::new(der).unwrap(); + + let res = oct.decode_into::<PrintableStringRef<'_>>().unwrap(); + assert_eq!(AsRef::<str>::as_ref(&res), "hi"); + } +} diff --git a/vendor/der/src/asn1/oid.rs b/vendor/der/src/asn1/oid.rs index 8b287183d..3daa452b2 100644 --- a/vendor/der/src/asn1/oid.rs +++ b/vendor/der/src/asn1/oid.rs @@ -6,6 +6,9 @@ use crate::{ }; use const_oid::ObjectIdentifier; +#[cfg(feature = "alloc")] +use super::Any; + impl<'a> DecodeValue<'a> for ObjectIdentifier { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { let mut buf = [0u8; ObjectIdentifier::MAX_SIZE]; @@ -24,7 +27,7 @@ impl EncodeValue for ObjectIdentifier { Length::try_from(self.as_bytes().len()) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { writer.write(self.as_bytes()) } } @@ -50,6 +53,13 @@ impl<'a> From<&'a ObjectIdentifier> for AnyRef<'a> { } } +#[cfg(feature = "alloc")] +impl From<ObjectIdentifier> for Any { + fn from(oid: ObjectIdentifier) -> Any { + AnyRef::from(&oid).into() + } +} + impl TryFrom<AnyRef<'_>> for ObjectIdentifier { type Error = Error; diff --git a/vendor/der/src/asn1/optional.rs b/vendor/der/src/asn1/optional.rs index a9b923ccc..ecda4f8ec 100644 --- a/vendor/der/src/asn1/optional.rs +++ b/vendor/der/src/asn1/optional.rs @@ -41,7 +41,7 @@ where (&self).encoded_len() } - fn encode(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode(&self, writer: &mut impl Writer) -> Result<()> { (&self).encode(writer) } } @@ -57,7 +57,7 @@ where } } - fn encode(&self, encoder: &mut dyn Writer) -> Result<()> { + fn encode(&self, encoder: &mut impl Writer) -> Result<()> { match self { Some(encodable) => encodable.encode(encoder), None => Ok(()), diff --git a/vendor/der/src/asn1/printable_string.rs b/vendor/der/src/asn1/printable_string.rs index d48f90f09..651c5ba23 100644 --- a/vendor/der/src/asn1/printable_string.rs +++ b/vendor/der/src/asn1/printable_string.rs @@ -1,10 +1,26 @@ //! ASN.1 `PrintableString` support. -use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, - Length, Reader, Result, StrSlice, Tag, Writer, -}; -use core::{fmt, ops::Deref, str}; +use crate::{asn1::AnyRef, FixedTag, Result, StrRef, Tag}; +use core::{fmt, ops::Deref}; + +macro_rules! impl_printable_string { + ($type: ty) => { + impl_printable_string!($type,); + }; + ($type: ty, $($li: lifetime)?) => { + impl_string_type!($type, $($li),*); + + impl<$($li),*> FixedTag for $type { + const TAG: Tag = Tag::PrintableString; + } + + impl<$($li),*> fmt::Debug for $type { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "PrintableString({:?})", self.as_str()) + } + } + }; +} /// ASN.1 `PrintableString` type. /// @@ -38,7 +54,7 @@ use core::{fmt, ops::Deref, str}; #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)] pub struct PrintableStringRef<'a> { /// Inner value - inner: StrSlice<'a>, + inner: StrRef<'a>, } impl<'a> PrintableStringRef<'a> { @@ -71,83 +87,138 @@ impl<'a> PrintableStringRef<'a> { } } - StrSlice::from_bytes(input) + StrRef::from_bytes(input) .map(|inner| Self { inner }) .map_err(|_| Self::TAG.value_error()) } } +impl_printable_string!(PrintableStringRef<'a>, 'a); + impl<'a> Deref for PrintableStringRef<'a> { - type Target = StrSlice<'a>; + type Target = StrRef<'a>; fn deref(&self) -> &Self::Target { &self.inner } } - -impl AsRef<str> for PrintableStringRef<'_> { - fn as_ref(&self) -> &str { - self.as_str() +impl<'a> From<&PrintableStringRef<'a>> for PrintableStringRef<'a> { + fn from(value: &PrintableStringRef<'a>) -> PrintableStringRef<'a> { + *value } } -impl AsRef<[u8]> for PrintableStringRef<'_> { - fn as_ref(&self) -> &[u8] { - self.as_bytes() +impl<'a> From<PrintableStringRef<'a>> for AnyRef<'a> { + fn from(printable_string: PrintableStringRef<'a>) -> AnyRef<'a> { + AnyRef::from_tag_and_value(Tag::PrintableString, printable_string.inner.into()) } } -impl<'a> DecodeValue<'a> for PrintableStringRef<'a> { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - Self::new(ByteSlice::decode_value(reader, header)?.as_slice()) - } -} +#[cfg(feature = "alloc")] +pub use self::allocation::PrintableString; -impl<'a> EncodeValue for PrintableStringRef<'a> { - fn value_len(&self) -> Result<Length> { - self.inner.value_len() +#[cfg(feature = "alloc")] +mod allocation { + use super::PrintableStringRef; + + use crate::{ + asn1::AnyRef, + referenced::{OwnedToRef, RefToOwned}, + BytesRef, FixedTag, Result, StrOwned, Tag, + }; + use core::{fmt, ops::Deref}; + + /// ASN.1 `PrintableString` type. + /// + /// Supports a subset the ASCII character set (described below). + /// + /// For UTF-8, use [`Utf8StringRef`][`crate::asn1::Utf8StringRef`] instead. + /// For the full ASCII character set, use + /// [`Ia5StringRef`][`crate::asn1::Ia5StringRef`]. + /// + /// # Supported characters + /// + /// The following ASCII characters/ranges are supported: + /// + /// - `A..Z` + /// - `a..z` + /// - `0..9` + /// - "` `" (i.e. space) + /// - `\` + /// - `(` + /// - `)` + /// - `+` + /// - `,` + /// - `-` + /// - `.` + /// - `/` + /// - `:` + /// - `=` + /// - `?` + #[derive(Clone, Eq, PartialEq, PartialOrd, Ord)] + pub struct PrintableString { + /// Inner value + inner: StrOwned, } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - self.inner.encode_value(writer) + impl PrintableString { + /// Create a new ASN.1 `PrintableString`. + pub fn new<T>(input: &T) -> Result<Self> + where + T: AsRef<[u8]> + ?Sized, + { + let input = input.as_ref(); + PrintableStringRef::new(input)?; + + StrOwned::from_bytes(input) + .map(|inner| Self { inner }) + .map_err(|_| Self::TAG.value_error()) + } } -} -impl FixedTag for PrintableStringRef<'_> { - const TAG: Tag = Tag::PrintableString; -} + impl_printable_string!(PrintableString); -impl OrdIsValueOrd for PrintableStringRef<'_> {} + impl Deref for PrintableString { + type Target = StrOwned; -impl<'a> From<&PrintableStringRef<'a>> for PrintableStringRef<'a> { - fn from(value: &PrintableStringRef<'a>) -> PrintableStringRef<'a> { - *value + fn deref(&self) -> &Self::Target { + &self.inner + } } -} - -impl<'a> TryFrom<AnyRef<'a>> for PrintableStringRef<'a> { - type Error = Error; - fn try_from(any: AnyRef<'a>) -> Result<PrintableStringRef<'a>> { - any.decode_into() + impl<'a> From<PrintableStringRef<'a>> for PrintableString { + fn from(value: PrintableStringRef<'a>) -> PrintableString { + let inner = + StrOwned::from_bytes(value.inner.as_bytes()).expect("Invalid PrintableString"); + Self { inner } + } } -} -impl<'a> From<PrintableStringRef<'a>> for AnyRef<'a> { - fn from(printable_string: PrintableStringRef<'a>) -> AnyRef<'a> { - AnyRef::from_tag_and_value(Tag::PrintableString, printable_string.inner.into()) + impl<'a> From<&'a PrintableString> for AnyRef<'a> { + fn from(printable_string: &'a PrintableString) -> AnyRef<'a> { + AnyRef::from_tag_and_value( + Tag::PrintableString, + BytesRef::new(printable_string.inner.as_bytes()).expect("Invalid PrintableString"), + ) + } } -} -impl<'a> fmt::Display for PrintableStringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(self.as_str()) + impl<'a> RefToOwned<'a> for PrintableStringRef<'a> { + type Owned = PrintableString; + fn ref_to_owned(&self) -> Self::Owned { + PrintableString { + inner: self.inner.ref_to_owned(), + } + } } -} -impl<'a> fmt::Debug for PrintableStringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "PrintableString({:?})", self.as_str()) + impl OwnedToRef for PrintableString { + type Borrowed<'a> = PrintableStringRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + PrintableStringRef { + inner: self.inner.owned_to_ref(), + } + } } } diff --git a/vendor/der/src/asn1/real.rs b/vendor/der/src/asn1/real.rs index f872d2d0b..b9f2e67f5 100644 --- a/vendor/der/src/asn1/real.rs +++ b/vendor/der/src/asn1/real.rs @@ -8,22 +8,21 @@ )] use crate::{ - str_slice::StrSlice, ByteSlice, DecodeValue, EncodeValue, FixedTag, Header, Length, Reader, - Result, Tag, Writer, + BytesRef, DecodeValue, EncodeValue, FixedTag, Header, Length, Reader, Result, StrRef, Tag, + Writer, }; use super::integer::uint::strip_leading_zeroes; -#[cfg_attr(docsrs, doc(cfg(feature = "real")))] impl<'a> DecodeValue<'a> for f64 { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - let bytes = ByteSlice::decode_value(reader, header)?.as_slice(); + let bytes = BytesRef::decode_value(reader, header)?.as_slice(); if header.length == Length::ZERO { Ok(0.0) } else if is_nth_bit_one::<7>(bytes) { // Binary encoding from section 8.5.7 applies - let sign: u64 = if is_nth_bit_one::<6>(bytes) { 1 } else { 0 }; + let sign: u64 = u64::from(is_nth_bit_one::<6>(bytes)); // Section 8.5.7.2: Check the base -- the DER specs say that only base 2 should be supported in DER let base = mnth_bits_to_u8::<5, 4>(bytes); @@ -74,7 +73,7 @@ impl<'a> DecodeValue<'a> for f64 { _ => Err(Tag::Real.value_error()), } } else { - let astr = StrSlice::from_bytes(&bytes[1..])?; + let astr = StrRef::from_bytes(&bytes[1..])?; match astr.inner.parse::<f64>() { Ok(val) => Ok(val), // Real related error: encoding not supported or malformed @@ -84,7 +83,6 @@ impl<'a> DecodeValue<'a> for f64 { } } -#[cfg_attr(docsrs, doc(cfg(feature = "real")))] impl EncodeValue for f64 { fn value_len(&self) -> Result<Length> { if self.is_sign_positive() && (*self) < f64::MIN_POSITIVE { @@ -120,7 +118,7 @@ impl EncodeValue for f64 { } } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { // Check if special value // Encode zero first, if it's zero // Special value from section 8.5.9 if non zero @@ -194,7 +192,6 @@ impl EncodeValue for f64 { } } -#[cfg_attr(docsrs, doc(cfg(feature = "real")))] impl FixedTag for f64 { const TAG: Tag = Tag::Real; } @@ -204,7 +201,7 @@ impl FixedTag for f64 { pub(crate) fn is_nth_bit_one<const N: usize>(bytes: &[u8]) -> bool { if N < 8 { bytes - .get(0) + .first() .map(|byte| byte & (1 << N) != 0) .unwrap_or(false) } else { diff --git a/vendor/der/src/asn1/sequence.rs b/vendor/der/src/asn1/sequence.rs index d2f6bc5d1..ad4a5d52e 100644 --- a/vendor/der/src/asn1/sequence.rs +++ b/vendor/der/src/asn1/sequence.rs @@ -2,69 +2,40 @@ //! `SEQUENCE`s to Rust structs. use crate::{ - ByteSlice, Decode, DecodeValue, Encode, EncodeValue, FixedTag, Header, Length, Reader, Result, - Tag, Writer, + BytesRef, DecodeValue, EncodeValue, FixedTag, Header, Length, Reader, Result, Tag, Writer, }; -/// ASN.1 `SEQUENCE` trait. -/// -/// Types which impl this trait receive blanket impls for the [`Decode`], -/// [`Encode`], and [`FixedTag`] traits. -pub trait Sequence<'a>: Decode<'a> { - /// Call the provided function with a slice of [`Encode`] trait objects - /// representing the fields of this `SEQUENCE`. - /// - /// This method uses a callback because structs with fields which aren't - /// directly [`Encode`] may need to construct temporary values from - /// their fields prior to encoding. - fn fields<F, T>(&self, f: F) -> Result<T> - where - F: FnOnce(&[&dyn Encode]) -> Result<T>; -} - -impl<'a, M> EncodeValue for M -where - M: Sequence<'a>, -{ - fn value_len(&self) -> Result<Length> { - self.fields(|fields| { - fields - .iter() - .try_fold(Length::ZERO, |acc, field| acc + field.encoded_len()?) - }) - } +#[cfg(feature = "alloc")] +use alloc::boxed::Box; - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - self.fields(|fields| { - for &field in fields { - field.encode(writer)?; - } - - Ok(()) - }) - } -} +/// Marker trait for ASN.1 `SEQUENCE`s. +/// +/// This is mainly used for custom derive. +pub trait Sequence<'a>: DecodeValue<'a> + EncodeValue {} -impl<'a, M> FixedTag for M +impl<'a, S> FixedTag for S where - M: Sequence<'a>, + S: Sequence<'a>, { const TAG: Tag = Tag::Sequence; } +#[cfg(feature = "alloc")] +impl<'a, T> Sequence<'a> for Box<T> where T: Sequence<'a> {} + /// The [`SequenceRef`] type provides raw access to the octets which comprise a /// DER-encoded `SEQUENCE`. /// /// This is a zero-copy reference type which borrows from the input data. pub struct SequenceRef<'a> { /// Body of the `SEQUENCE`. - body: ByteSlice<'a>, + body: BytesRef<'a>, } impl<'a> DecodeValue<'a> for SequenceRef<'a> { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { Ok(Self { - body: ByteSlice::decode_value(reader, header)?, + body: BytesRef::decode_value(reader, header)?, }) } } @@ -74,11 +45,9 @@ impl EncodeValue for SequenceRef<'_> { Ok(self.body.len()) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { self.body.encode_value(writer) } } -impl<'a> FixedTag for SequenceRef<'a> { - const TAG: Tag = Tag::Sequence; -} +impl<'a> Sequence<'a> for SequenceRef<'a> {} diff --git a/vendor/der/src/asn1/sequence_of.rs b/vendor/der/src/asn1/sequence_of.rs index 6334d7197..42c2a9ca8 100644 --- a/vendor/der/src/asn1/sequence_of.rs +++ b/vendor/der/src/asn1/sequence_of.rs @@ -88,7 +88,7 @@ where .fold(Ok(Length::ZERO), |len, elem| len + elem.encoded_len()?) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { for elem in self.iter() { elem.encode(writer)?; } @@ -155,7 +155,7 @@ where .fold(Ok(Length::ZERO), |len, elem| len + elem.encoded_len()?) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { for elem in self { elem.encode(writer)?; } @@ -178,7 +178,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<'a, T> DecodeValue<'a> for Vec<T> where T: Decode<'a>, @@ -197,7 +196,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> EncodeValue for Vec<T> where T: Encode, @@ -207,7 +205,7 @@ where .fold(Ok(Length::ZERO), |len, elem| len + elem.encoded_len()?) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { for elem in self { elem.encode(writer)?; } @@ -217,13 +215,11 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> FixedTag for Vec<T> { const TAG: Tag = Tag::Sequence; } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> ValueOrd for Vec<T> where T: DerOrd, diff --git a/vendor/der/src/asn1/set_of.rs b/vendor/der/src/asn1/set_of.rs index b8c4b0da4..e8f20e9c3 100644 --- a/vendor/der/src/asn1/set_of.rs +++ b/vendor/der/src/asn1/set_of.rs @@ -119,7 +119,7 @@ where .fold(Ok(Length::ZERO), |len, elem| len + elem.encoded_len()?) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { for elem in self.iter() { elem.encode(writer)?; } @@ -185,7 +185,6 @@ impl<'a, T> ExactSizeIterator for SetOfIter<'a, T> {} /// This type implements an append-only `SET OF` type which is heap-backed /// and depends on `alloc` support. #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] pub struct SetOfVec<T> where @@ -195,7 +194,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T: DerOrd> Default for SetOfVec<T> { fn default() -> Self { Self { @@ -205,7 +203,6 @@ impl<T: DerOrd> Default for SetOfVec<T> { } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> SetOfVec<T> where T: DerOrd, @@ -265,7 +262,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> AsRef<[T]> for SetOfVec<T> where T: DerOrd, @@ -276,7 +272,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<'a, T> DecodeValue<'a> for SetOfVec<T> where T: Decode<'a> + DerOrd, @@ -297,7 +292,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<'a, T> EncodeValue for SetOfVec<T> where T: 'a + Decode<'a> + Encode + DerOrd, @@ -307,7 +301,7 @@ where .fold(Ok(Length::ZERO), |len, elem| len + elem.encoded_len()?) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { for elem in self.iter() { elem.encode(writer)?; } @@ -317,7 +311,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> FixedTag for SetOfVec<T> where T: DerOrd, @@ -326,7 +319,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> From<SetOfVec<T>> for Vec<T> where T: DerOrd, @@ -337,7 +329,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> TryFrom<Vec<T>> for SetOfVec<T> where T: DerOrd, @@ -352,7 +343,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T, const N: usize> TryFrom<[T; N]> for SetOfVec<T> where T: DerOrd, @@ -365,7 +355,6 @@ where } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<T> ValueOrd for SetOfVec<T> where T: DerOrd, @@ -375,6 +364,26 @@ where } } +// Implement by hand because the derive would create invalid values. +// Use the conversion from Vec to create a valid value. +#[cfg(feature = "arbitrary")] +impl<'a, T> arbitrary::Arbitrary<'a> for SetOfVec<T> +where + T: DerOrd + arbitrary::Arbitrary<'a>, +{ + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + Self::try_from( + u.arbitrary_iter()? + .collect::<std::result::Result<Vec<_>, _>>()?, + ) + .map_err(|_| arbitrary::Error::IncorrectFormat) + } + + fn size_hint(_depth: usize) -> (usize, Option<usize>) { + (0, None) + } +} + /// Sort a mut slice according to its [`DerOrd`], returning any errors which /// might occur during the comparison. /// diff --git a/vendor/der/src/asn1/teletex_string.rs b/vendor/der/src/asn1/teletex_string.rs index 7d6621d2d..cedf727db 100644 --- a/vendor/der/src/asn1/teletex_string.rs +++ b/vendor/der/src/asn1/teletex_string.rs @@ -1,10 +1,26 @@ //! ASN.1 `TeletexString` support. +//! +use crate::{asn1::AnyRef, FixedTag, Result, StrRef, Tag}; +use core::{fmt, ops::Deref}; + +macro_rules! impl_teletex_string { + ($type: ty) => { + impl_teletex_string!($type,); + }; + ($type: ty, $($li: lifetime)?) => { + impl_string_type!($type, $($li),*); + + impl<$($li),*> FixedTag for $type { + const TAG: Tag = Tag::TeletexString; + } -use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, - Length, Reader, Result, StrSlice, Tag, Writer, -}; -use core::{fmt, ops::Deref, str}; + impl<$($li),*> fmt::Debug for $type { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "TeletexString({:?})", self.as_str()) + } + } + }; +} /// ASN.1 `TeletexString` type. /// @@ -25,7 +41,7 @@ use core::{fmt, ops::Deref, str}; #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)] pub struct TeletexStringRef<'a> { /// Inner value - inner: StrSlice<'a>, + inner: StrRef<'a>, } impl<'a> TeletexStringRef<'a> { @@ -41,83 +57,127 @@ impl<'a> TeletexStringRef<'a> { return Err(Self::TAG.value_error()); } - StrSlice::from_bytes(input) + StrRef::from_bytes(input) .map(|inner| Self { inner }) .map_err(|_| Self::TAG.value_error()) } } +impl_teletex_string!(TeletexStringRef<'a>, 'a); + impl<'a> Deref for TeletexStringRef<'a> { - type Target = StrSlice<'a>; + type Target = StrRef<'a>; fn deref(&self) -> &Self::Target { &self.inner } } -impl AsRef<str> for TeletexStringRef<'_> { - fn as_ref(&self) -> &str { - self.as_str() +impl<'a> From<&TeletexStringRef<'a>> for TeletexStringRef<'a> { + fn from(value: &TeletexStringRef<'a>) -> TeletexStringRef<'a> { + *value } } -impl AsRef<[u8]> for TeletexStringRef<'_> { - fn as_ref(&self) -> &[u8] { - self.as_bytes() +impl<'a> From<TeletexStringRef<'a>> for AnyRef<'a> { + fn from(teletex_string: TeletexStringRef<'a>) -> AnyRef<'a> { + AnyRef::from_tag_and_value(Tag::TeletexString, teletex_string.inner.into()) } } -impl<'a> DecodeValue<'a> for TeletexStringRef<'a> { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - Self::new(ByteSlice::decode_value(reader, header)?.as_slice()) - } -} +#[cfg(feature = "alloc")] +pub use self::allocation::TeletexString; -impl<'a> EncodeValue for TeletexStringRef<'a> { - fn value_len(&self) -> Result<Length> { - self.inner.value_len() - } +#[cfg(feature = "alloc")] +mod allocation { + use super::TeletexStringRef; - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - self.inner.encode_value(writer) + use crate::{ + asn1::AnyRef, + referenced::{OwnedToRef, RefToOwned}, + BytesRef, FixedTag, Result, StrOwned, Tag, + }; + use core::{fmt, ops::Deref}; + + /// ASN.1 `TeletexString` type. + /// + /// Supports a subset the ASCII character set (described below). + /// + /// For UTF-8, use [`Utf8StringRef`][`crate::asn1::Utf8StringRef`] instead. + /// For the full ASCII character set, use + /// [`Ia5StringRef`][`crate::asn1::Ia5StringRef`]. + /// + /// # Supported characters + /// + /// The standard defines a complex character set allowed in this type. However, quoting the ASN.1 + /// mailing list, "a sizable volume of software in the world treats TeletexString (T61String) as a + /// simple 8-bit string with mostly Windows Latin 1 (superset of iso-8859-1) encoding". + /// + #[derive(Clone, Eq, PartialEq, PartialOrd, Ord)] + pub struct TeletexString { + /// Inner value + inner: StrOwned, } -} -impl FixedTag for TeletexStringRef<'_> { - const TAG: Tag = Tag::TeletexString; -} + impl TeletexString { + /// Create a new ASN.1 `TeletexString`. + pub fn new<T>(input: &T) -> Result<Self> + where + T: AsRef<[u8]> + ?Sized, + { + let input = input.as_ref(); -impl OrdIsValueOrd for TeletexStringRef<'_> {} + TeletexStringRef::new(input)?; -impl<'a> From<&TeletexStringRef<'a>> for TeletexStringRef<'a> { - fn from(value: &TeletexStringRef<'a>) -> TeletexStringRef<'a> { - *value + StrOwned::from_bytes(input) + .map(|inner| Self { inner }) + .map_err(|_| Self::TAG.value_error()) + } } -} -impl<'a> TryFrom<AnyRef<'a>> for TeletexStringRef<'a> { - type Error = Error; + impl_teletex_string!(TeletexString); - fn try_from(any: AnyRef<'a>) -> Result<TeletexStringRef<'a>> { - any.decode_into() + impl Deref for TeletexString { + type Target = StrOwned; + + fn deref(&self) -> &Self::Target { + &self.inner + } } -} -impl<'a> From<TeletexStringRef<'a>> for AnyRef<'a> { - fn from(teletex_string: TeletexStringRef<'a>) -> AnyRef<'a> { - AnyRef::from_tag_and_value(Tag::TeletexString, teletex_string.inner.into()) + impl<'a> From<TeletexStringRef<'a>> for TeletexString { + fn from(value: TeletexStringRef<'a>) -> TeletexString { + let inner = + StrOwned::from_bytes(value.inner.as_bytes()).expect("Invalid TeletexString"); + Self { inner } + } } -} -impl<'a> fmt::Display for TeletexStringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(self.as_str()) + impl<'a> From<&'a TeletexString> for AnyRef<'a> { + fn from(teletex_string: &'a TeletexString) -> AnyRef<'a> { + AnyRef::from_tag_and_value( + Tag::TeletexString, + BytesRef::new(teletex_string.inner.as_bytes()).expect("Invalid TeletexString"), + ) + } } -} -impl<'a> fmt::Debug for TeletexStringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "TeletexString({:?})", self.as_str()) + impl<'a> RefToOwned<'a> for TeletexStringRef<'a> { + type Owned = TeletexString; + fn ref_to_owned(&self) -> Self::Owned { + TeletexString { + inner: self.inner.ref_to_owned(), + } + } + } + + impl OwnedToRef for TeletexString { + type Borrowed<'a> = TeletexStringRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + TeletexStringRef { + inner: self.inner.owned_to_ref(), + } + } } } diff --git a/vendor/der/src/asn1/utc_time.rs b/vendor/der/src/asn1/utc_time.rs index 7c2381155..0c10e3aff 100644 --- a/vendor/der/src/asn1/utc_time.rs +++ b/vendor/der/src/asn1/utc_time.rs @@ -1,7 +1,6 @@ //! ASN.1 `UTCTime` support. use crate::{ - asn1::AnyRef, datetime::{self, DateTime}, ord::OrdIsValueOrd, DecodeValue, EncodeValue, Error, ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, @@ -12,9 +11,6 @@ use core::time::Duration; #[cfg(feature = "std")] use std::time::SystemTime; -/// Maximum year that can be represented as a `UTCTime`. -pub const MAX_YEAR: u16 = 2049; - /// ASN.1 `UTCTime` type. /// /// This type implements the validity requirements specified in @@ -37,9 +33,12 @@ impl UtcTime { /// Length of an RFC 5280-flavored ASN.1 DER-encoded [`UtcTime`]. pub const LENGTH: usize = 13; + /// Maximum year that can be represented as a `UTCTime`. + pub const MAX_YEAR: u16 = 2049; + /// Create a [`UtcTime`] from a [`DateTime`]. pub fn from_date_time(datetime: DateTime) -> Result<Self> { - if datetime.year() <= MAX_YEAR { + if datetime.year() <= UtcTime::MAX_YEAR { Ok(Self(datetime)) } else { Err(Self::TAG.value_error()) @@ -64,7 +63,6 @@ impl UtcTime { /// Instantiate from [`SystemTime`]. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn from_system_time(time: SystemTime) -> Result<Self> { DateTime::try_from(time) .map_err(|_| Self::TAG.value_error())? @@ -73,12 +71,13 @@ impl UtcTime { /// Convert to [`SystemTime`]. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn to_system_time(&self) -> SystemTime { self.0.to_system_time() } } +impl_any_conversions!(UtcTime); + impl<'a> DecodeValue<'a> for UtcTime { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { if Self::LENGTH != usize::try_from(header.length)? { @@ -120,7 +119,7 @@ impl EncodeValue for UtcTime { Self::LENGTH.try_into() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { let year = match self.0.year() { y @ 1950..=1999 => y.checked_sub(1900), y @ 2000..=2049 => y.checked_sub(2000), @@ -180,18 +179,43 @@ impl TryFrom<&DateTime> for UtcTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl From<UtcTime> for SystemTime { fn from(utc_time: UtcTime) -> SystemTime { utc_time.to_system_time() } } -impl TryFrom<AnyRef<'_>> for UtcTime { - type Error = Error; - - fn try_from(any: AnyRef<'_>) -> Result<UtcTime> { - any.decode_into() +// Implement by hand because the derive would create invalid values. +// Use the conversion from DateTime to create a valid value. +// The DateTime type has a way bigger range of valid years than UtcTime, +// so the DateTime year is mapped into a valid range to throw away less inputs. +#[cfg(feature = "arbitrary")] +impl<'a> arbitrary::Arbitrary<'a> for UtcTime { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + const MIN_YEAR: u16 = 1970; + const VALID_YEAR_COUNT: u16 = UtcTime::MAX_YEAR - MIN_YEAR + 1; + const AVERAGE_SECONDS_IN_YEAR: u64 = 31_556_952; + + let datetime = DateTime::arbitrary(u)?; + let year = datetime.year(); + let duration = datetime.unix_duration(); + + // Clamp the year into a valid range to not throw away too much input + let valid_year = (year.saturating_sub(MIN_YEAR)) + .rem_euclid(VALID_YEAR_COUNT) + .saturating_add(MIN_YEAR); + let year_to_remove = year.saturating_sub(valid_year); + let valid_duration = duration + - Duration::from_secs( + u64::from(year_to_remove).saturating_mul(AVERAGE_SECONDS_IN_YEAR), + ); + + Self::from_date_time(DateTime::from_unix_duration(valid_duration).expect("supported range")) + .map_err(|_| arbitrary::Error::IncorrectFormat) + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + DateTime::size_hint(depth) } } diff --git a/vendor/der/src/asn1/utf8_string.rs b/vendor/der/src/asn1/utf8_string.rs index 1a0641172..6018750a0 100644 --- a/vendor/der/src/asn1/utf8_string.rs +++ b/vendor/der/src/asn1/utf8_string.rs @@ -1,13 +1,16 @@ //! ASN.1 `UTF8String` support. use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, - Length, Reader, Result, StrSlice, Tag, Writer, + asn1::AnyRef, ord::OrdIsValueOrd, EncodeValue, Error, FixedTag, Length, Result, StrRef, Tag, + Writer, }; use core::{fmt, ops::Deref, str}; #[cfg(feature = "alloc")] -use alloc::{borrow::ToOwned, string::String}; +use { + crate::{DecodeValue, Header, Reader}, + alloc::{borrow::ToOwned, string::String}, +}; /// ASN.1 `UTF8String` type. /// @@ -26,7 +29,7 @@ use alloc::{borrow::ToOwned, string::String}; #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)] pub struct Utf8StringRef<'a> { /// Inner value - inner: StrSlice<'a>, + inner: StrRef<'a>, } impl<'a> Utf8StringRef<'a> { @@ -35,75 +38,33 @@ impl<'a> Utf8StringRef<'a> { where T: AsRef<[u8]> + ?Sized, { - StrSlice::from_bytes(input.as_ref()).map(|inner| Self { inner }) + StrRef::from_bytes(input.as_ref()).map(|inner| Self { inner }) } } +impl_string_type!(Utf8StringRef<'a>, 'a); + impl<'a> Deref for Utf8StringRef<'a> { - type Target = StrSlice<'a>; + type Target = StrRef<'a>; fn deref(&self) -> &Self::Target { &self.inner } } -impl AsRef<str> for Utf8StringRef<'_> { - fn as_ref(&self) -> &str { - self.as_str() - } -} - -impl AsRef<[u8]> for Utf8StringRef<'_> { - fn as_ref(&self) -> &[u8] { - self.as_bytes() - } -} - -impl<'a> DecodeValue<'a> for Utf8StringRef<'a> { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - Self::new(ByteSlice::decode_value(reader, header)?.as_slice()) - } -} - -impl EncodeValue for Utf8StringRef<'_> { - fn value_len(&self) -> Result<Length> { - self.inner.value_len() - } - - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - self.inner.encode_value(writer) - } -} - impl FixedTag for Utf8StringRef<'_> { const TAG: Tag = Tag::Utf8String; } -impl OrdIsValueOrd for Utf8StringRef<'_> {} - impl<'a> From<&Utf8StringRef<'a>> for Utf8StringRef<'a> { fn from(value: &Utf8StringRef<'a>) -> Utf8StringRef<'a> { *value } } -impl<'a> TryFrom<AnyRef<'a>> for Utf8StringRef<'a> { - type Error = Error; - - fn try_from(any: AnyRef<'a>) -> Result<Utf8StringRef<'a>> { - any.decode_into() - } -} - impl<'a> From<Utf8StringRef<'a>> for AnyRef<'a> { - fn from(printable_string: Utf8StringRef<'a>) -> AnyRef<'a> { - AnyRef::from_tag_and_value(Tag::Utf8String, printable_string.inner.into()) - } -} - -impl<'a> fmt::Display for Utf8StringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(self.as_str()) + fn from(utf_string: Utf8StringRef<'a>) -> AnyRef<'a> { + AnyRef::from_tag_and_value(Tag::Utf8String, utf_string.inner.into()) } } @@ -126,7 +87,7 @@ impl EncodeValue for str { Utf8StringRef::new(self)?.value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { Utf8StringRef::new(self)?.encode_value(writer) } } @@ -138,7 +99,6 @@ impl FixedTag for str { impl OrdIsValueOrd for str {} #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<'a> From<Utf8StringRef<'a>> for String { fn from(s: Utf8StringRef<'a>) -> String { s.as_str().to_owned() @@ -146,7 +106,6 @@ impl<'a> From<Utf8StringRef<'a>> for String { } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<'a> TryFrom<AnyRef<'a>> for String { type Error = Error; @@ -156,7 +115,6 @@ impl<'a> TryFrom<AnyRef<'a>> for String { } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl<'a> DecodeValue<'a> for String { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { Ok(String::from_utf8(reader.read_vec(header.length)?)?) @@ -164,25 +122,22 @@ impl<'a> DecodeValue<'a> for String { } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl EncodeValue for String { fn value_len(&self) -> Result<Length> { Utf8StringRef::new(self)?.value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { Utf8StringRef::new(self)?.encode_value(writer) } } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl FixedTag for String { const TAG: Tag = Tag::Utf8String; } #[cfg(feature = "alloc")] -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] impl OrdIsValueOrd for String {} #[cfg(test)] diff --git a/vendor/der/src/asn1/videotex_string.rs b/vendor/der/src/asn1/videotex_string.rs index b758a22e6..55b1a49cf 100644 --- a/vendor/der/src/asn1/videotex_string.rs +++ b/vendor/der/src/asn1/videotex_string.rs @@ -1,10 +1,7 @@ //! ASN.1 `VideotexString` support. -use crate::{ - asn1::AnyRef, ord::OrdIsValueOrd, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, - Length, Reader, Result, StrSlice, Tag, Writer, -}; -use core::{fmt, ops::Deref, str}; +use crate::{asn1::AnyRef, FixedTag, Result, StrRef, Tag}; +use core::{fmt, ops::Deref}; /// ASN.1 `VideotexString` type. /// @@ -23,7 +20,7 @@ use core::{fmt, ops::Deref, str}; #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)] pub struct VideotexStringRef<'a> { /// Inner value - inner: StrSlice<'a>, + inner: StrRef<'a>, } impl<'a> VideotexStringRef<'a> { @@ -40,68 +37,32 @@ impl<'a> VideotexStringRef<'a> { return Err(Self::TAG.value_error()); } - StrSlice::from_bytes(input) + StrRef::from_bytes(input) .map(|inner| Self { inner }) .map_err(|_| Self::TAG.value_error()) } } +impl_string_type!(VideotexStringRef<'a>, 'a); + impl<'a> Deref for VideotexStringRef<'a> { - type Target = StrSlice<'a>; + type Target = StrRef<'a>; fn deref(&self) -> &Self::Target { &self.inner } } -impl AsRef<str> for VideotexStringRef<'_> { - fn as_ref(&self) -> &str { - self.as_str() - } -} - -impl AsRef<[u8]> for VideotexStringRef<'_> { - fn as_ref(&self) -> &[u8] { - self.as_bytes() - } -} - -impl<'a> DecodeValue<'a> for VideotexStringRef<'a> { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - Self::new(ByteSlice::decode_value(reader, header)?.as_slice()) - } -} - -impl<'a> EncodeValue for VideotexStringRef<'a> { - fn value_len(&self) -> Result<Length> { - self.inner.value_len() - } - - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - self.inner.encode_value(writer) - } -} - impl FixedTag for VideotexStringRef<'_> { const TAG: Tag = Tag::VideotexString; } -impl OrdIsValueOrd for VideotexStringRef<'_> {} - impl<'a> From<&VideotexStringRef<'a>> for VideotexStringRef<'a> { fn from(value: &VideotexStringRef<'a>) -> VideotexStringRef<'a> { *value } } -impl<'a> TryFrom<AnyRef<'a>> for VideotexStringRef<'a> { - type Error = Error; - - fn try_from(any: AnyRef<'a>) -> Result<VideotexStringRef<'a>> { - any.decode_into() - } -} - impl<'a> From<VideotexStringRef<'a>> for AnyRef<'a> { fn from(printable_string: VideotexStringRef<'a>) -> AnyRef<'a> { AnyRef::from_tag_and_value(Tag::VideotexString, printable_string.inner.into()) @@ -114,12 +75,6 @@ impl<'a> From<VideotexStringRef<'a>> for &'a [u8] { } } -impl<'a> fmt::Display for VideotexStringRef<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(self.as_str()) - } -} - impl<'a> fmt::Debug for VideotexStringRef<'a> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "VideotexString({:?})", self.as_str()) diff --git a/vendor/der/src/byte_slice.rs b/vendor/der/src/byte_slice.rs deleted file mode 100644 index 00d46d0f1..000000000 --- a/vendor/der/src/byte_slice.rs +++ /dev/null @@ -1,116 +0,0 @@ -//! Common handling for types backed by byte slices with enforcement of a -//! library-level length limitation i.e. `Length::max()`. - -use crate::{ - str_slice::StrSlice, DecodeValue, DerOrd, EncodeValue, Error, Header, Length, Reader, Result, - Writer, -}; -use core::cmp::Ordering; - -/// Byte slice newtype which respects the `Length::max()` limit. -#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] -pub(crate) struct ByteSlice<'a> { - /// Precomputed `Length` (avoids possible panicking conversions) - length: Length, - - /// Inner value - inner: &'a [u8], -} - -impl<'a> ByteSlice<'a> { - /// Constant value representing an empty byte slice. - pub const EMPTY: Self = Self { - length: Length::ZERO, - inner: &[], - }; - - /// Create a new [`ByteSlice`], ensuring that the provided `slice` value - /// is shorter than `Length::max()`. - pub fn new(slice: &'a [u8]) -> Result<Self> { - Ok(Self { - length: Length::try_from(slice.len())?, - inner: slice, - }) - } - - /// Borrow the inner byte slice - pub fn as_slice(&self) -> &'a [u8] { - self.inner - } - - /// Get the [`Length`] of this [`ByteSlice`] - pub fn len(self) -> Length { - self.length - } - - /// Is this [`ByteSlice`] empty? - pub fn is_empty(self) -> bool { - self.len() == Length::ZERO - } -} - -impl AsRef<[u8]> for ByteSlice<'_> { - fn as_ref(&self) -> &[u8] { - self.as_slice() - } -} - -impl<'a> DecodeValue<'a> for ByteSlice<'a> { - fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - reader.read_slice(header.length).and_then(Self::new) - } -} - -impl EncodeValue for ByteSlice<'_> { - fn value_len(&self) -> Result<Length> { - Ok(self.length) - } - - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { - writer.write(self.as_ref()) - } -} - -impl Default for ByteSlice<'_> { - fn default() -> Self { - Self { - length: Length::ZERO, - inner: &[], - } - } -} - -impl DerOrd for ByteSlice<'_> { - fn der_cmp(&self, other: &Self) -> Result<Ordering> { - Ok(self.as_slice().cmp(other.as_slice())) - } -} - -impl<'a> From<&'a [u8; 1]> for ByteSlice<'a> { - fn from(byte: &'a [u8; 1]) -> ByteSlice<'a> { - Self { - length: Length::ONE, - inner: byte, - } - } -} - -impl<'a> From<StrSlice<'a>> for ByteSlice<'a> { - fn from(s: StrSlice<'a>) -> ByteSlice<'a> { - let bytes = s.as_bytes(); - debug_assert_eq!(bytes.len(), usize::try_from(s.length).expect("overflow")); - - ByteSlice { - inner: bytes, - length: s.length, - } - } -} - -impl<'a> TryFrom<&'a [u8]> for ByteSlice<'a> { - type Error = Error; - - fn try_from(slice: &'a [u8]) -> Result<Self> { - Self::new(slice) - } -} diff --git a/vendor/der/src/bytes_owned.rs b/vendor/der/src/bytes_owned.rs new file mode 100644 index 000000000..a9f67b21a --- /dev/null +++ b/vendor/der/src/bytes_owned.rs @@ -0,0 +1,156 @@ +//! Common handling for types backed by byte allocation with enforcement of a +//! library-level length limitation i.e. `Length::max()`. + +use crate::{ + referenced::OwnedToRef, BytesRef, DecodeValue, DerOrd, EncodeValue, Error, Header, Length, + Reader, Result, StrRef, Writer, +}; +use alloc::{boxed::Box, vec::Vec}; +use core::cmp::Ordering; + +/// Byte slice newtype which respects the `Length::max()` limit. +#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] +pub(crate) struct BytesOwned { + /// Precomputed `Length` (avoids possible panicking conversions) + length: Length, + + /// Inner value + inner: Box<[u8]>, +} + +impl BytesOwned { + /// Create a new [`BytesOwned`], ensuring that the provided `slice` value + /// is shorter than `Length::max()`. + pub fn new(data: impl Into<Box<[u8]>>) -> Result<Self> { + let inner: Box<[u8]> = data.into(); + + Ok(Self { + length: Length::try_from(inner.len())?, + inner, + }) + } + + /// Borrow the inner byte slice + pub fn as_slice(&self) -> &[u8] { + &self.inner + } + + /// Get the [`Length`] of this [`BytesRef`] + pub fn len(&self) -> Length { + self.length + } + + /// Is this [`BytesOwned`] empty? + pub fn is_empty(&self) -> bool { + self.len() == Length::ZERO + } +} + +impl AsRef<[u8]> for BytesOwned { + fn as_ref(&self) -> &[u8] { + self.as_slice() + } +} + +impl<'a> DecodeValue<'a> for BytesOwned { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + reader.read_vec(header.length).and_then(Self::new) + } +} + +impl EncodeValue for BytesOwned { + fn value_len(&self) -> Result<Length> { + Ok(self.length) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + writer.write(self.as_ref()) + } +} + +impl Default for BytesOwned { + fn default() -> Self { + Self { + length: Length::ZERO, + inner: Box::new([]), + } + } +} + +impl DerOrd for BytesOwned { + fn der_cmp(&self, other: &Self) -> Result<Ordering> { + Ok(self.as_slice().cmp(other.as_slice())) + } +} + +impl From<StrRef<'_>> for BytesOwned { + fn from(s: StrRef<'_>) -> BytesOwned { + let bytes = s.as_bytes(); + debug_assert_eq!(bytes.len(), usize::try_from(s.length).expect("overflow")); + + BytesOwned { + inner: Box::from(bytes), + length: s.length, + } + } +} + +impl OwnedToRef for BytesOwned { + type Borrowed<'a> = BytesRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + BytesRef { + length: self.length, + inner: self.inner.as_ref(), + } + } +} + +impl From<BytesRef<'_>> for BytesOwned { + fn from(s: BytesRef<'_>) -> BytesOwned { + BytesOwned { + length: s.length, + inner: Box::from(s.inner), + } + } +} + +impl TryFrom<&[u8]> for BytesOwned { + type Error = Error; + + fn try_from(bytes: &[u8]) -> Result<Self> { + Self::new(bytes) + } +} + +impl TryFrom<Box<[u8]>> for BytesOwned { + type Error = Error; + + fn try_from(bytes: Box<[u8]>) -> Result<Self> { + Self::new(bytes) + } +} + +impl TryFrom<Vec<u8>> for BytesOwned { + type Error = Error; + + fn try_from(bytes: Vec<u8>) -> Result<Self> { + Self::new(bytes) + } +} + +// Implement by hand because the derive would create invalid values. +// Make sure the length and the inner.len matches. +#[cfg(feature = "arbitrary")] +impl<'a> arbitrary::Arbitrary<'a> for BytesOwned { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + let length = u.arbitrary()?; + Ok(Self { + length, + inner: Box::from(u.bytes(u32::from(length) as usize)?), + }) + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + arbitrary::size_hint::and(Length::size_hint(depth), (0, None)) + } +} diff --git a/vendor/der/src/bytes_ref.rs b/vendor/der/src/bytes_ref.rs new file mode 100644 index 000000000..2cee4076e --- /dev/null +++ b/vendor/der/src/bytes_ref.rs @@ -0,0 +1,152 @@ +//! Common handling for types backed by byte slices with enforcement of a +//! library-level length limitation i.e. `Length::max()`. + +use crate::{ + DecodeValue, DerOrd, EncodeValue, Error, Header, Length, Reader, Result, StrRef, Writer, +}; +use core::cmp::Ordering; + +#[cfg(feature = "alloc")] +use crate::StrOwned; + +/// Byte slice newtype which respects the `Length::max()` limit. +#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] +pub(crate) struct BytesRef<'a> { + /// Precomputed `Length` (avoids possible panicking conversions) + pub length: Length, + + /// Inner value + pub inner: &'a [u8], +} + +impl<'a> BytesRef<'a> { + /// Constant value representing an empty byte slice. + pub const EMPTY: Self = Self { + length: Length::ZERO, + inner: &[], + }; + + /// Create a new [`BytesRef`], ensuring that the provided `slice` value + /// is shorter than `Length::max()`. + pub fn new(slice: &'a [u8]) -> Result<Self> { + Ok(Self { + length: Length::try_from(slice.len())?, + inner: slice, + }) + } + + /// Borrow the inner byte slice + pub fn as_slice(&self) -> &'a [u8] { + self.inner + } + + /// Get the [`Length`] of this [`BytesRef`] + pub fn len(self) -> Length { + self.length + } + + /// Is this [`BytesRef`] empty? + pub fn is_empty(self) -> bool { + self.len() == Length::ZERO + } +} + +impl AsRef<[u8]> for BytesRef<'_> { + fn as_ref(&self) -> &[u8] { + self.as_slice() + } +} + +impl<'a> DecodeValue<'a> for BytesRef<'a> { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + reader.read_slice(header.length).and_then(Self::new) + } +} + +impl EncodeValue for BytesRef<'_> { + fn value_len(&self) -> Result<Length> { + Ok(self.length) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + writer.write(self.as_ref()) + } +} + +impl Default for BytesRef<'_> { + fn default() -> Self { + Self { + length: Length::ZERO, + inner: &[], + } + } +} + +impl DerOrd for BytesRef<'_> { + fn der_cmp(&self, other: &Self) -> Result<Ordering> { + Ok(self.as_slice().cmp(other.as_slice())) + } +} + +impl<'a> From<StrRef<'a>> for BytesRef<'a> { + fn from(s: StrRef<'a>) -> BytesRef<'a> { + let bytes = s.as_bytes(); + debug_assert_eq!(bytes.len(), usize::try_from(s.length).expect("overflow")); + + BytesRef { + inner: bytes, + length: s.length, + } + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<&'a StrOwned> for BytesRef<'a> { + fn from(s: &'a StrOwned) -> BytesRef<'a> { + let bytes = s.as_bytes(); + debug_assert_eq!(bytes.len(), usize::try_from(s.length).expect("overflow")); + + BytesRef { + inner: bytes, + length: s.length, + } + } +} + +impl<'a> TryFrom<&'a [u8]> for BytesRef<'a> { + type Error = Error; + + fn try_from(slice: &'a [u8]) -> Result<Self> { + Self::new(slice) + } +} + +// Implement by hand because the derive would create invalid values. +// Make sure the length and the inner.len matches. +#[cfg(feature = "arbitrary")] +impl<'a> arbitrary::Arbitrary<'a> for BytesRef<'a> { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + let length = u.arbitrary()?; + Ok(Self { + length, + inner: u.bytes(u32::from(length) as usize)?, + }) + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + arbitrary::size_hint::and(Length::size_hint(depth), (0, None)) + } +} + +#[cfg(feature = "alloc")] +mod allocating { + use super::BytesRef; + use crate::{referenced::RefToOwned, BytesOwned}; + + impl<'a> RefToOwned<'a> for BytesRef<'a> { + type Owned = BytesOwned; + fn ref_to_owned(&self) -> Self::Owned { + BytesOwned::from(*self) + } + } +} diff --git a/vendor/der/src/datetime.rs b/vendor/der/src/datetime.rs index 2b4c504bf..de28d53bb 100644 --- a/vendor/der/src/datetime.rs +++ b/vendor/der/src/datetime.rs @@ -240,7 +240,6 @@ impl DateTime { /// Instantiate from [`SystemTime`]. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn from_system_time(time: SystemTime) -> Result<Self> { time.duration_since(UNIX_EPOCH) .map_err(|_| ErrorKind::DateTime.into()) @@ -249,7 +248,6 @@ impl DateTime { /// Convert to [`SystemTime`]. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn to_system_time(&self) -> SystemTime { UNIX_EPOCH + self.unix_duration() } @@ -258,19 +256,12 @@ impl DateTime { impl FromStr for DateTime { type Err = Error; - // TODO(tarcieri): checked arithmetic - #[allow(clippy::integer_arithmetic)] fn from_str(s: &str) -> Result<Self> { match *s.as_bytes() { [year1, year2, year3, year4, b'-', month1, month2, b'-', day1, day2, b'T', hour1, hour2, b':', min1, min2, b':', sec1, sec2, b'Z'] => { let tag = Tag::GeneralizedTime; - let year = - u16::from(decode_decimal(tag, year1, year2).map_err(|_| ErrorKind::DateTime)?) - * 100 - + u16::from( - decode_decimal(tag, year3, year4).map_err(|_| ErrorKind::DateTime)?, - ); + let year = decode_year(&[year1, year2, year3, year4])?; let month = decode_decimal(tag, month1, month2).map_err(|_| ErrorKind::DateTime)?; let day = decode_decimal(tag, day1, day2).map_err(|_| ErrorKind::DateTime)?; let hour = decode_decimal(tag, hour1, hour2).map_err(|_| ErrorKind::DateTime)?; @@ -294,7 +285,6 @@ impl fmt::Display for DateTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl From<DateTime> for SystemTime { fn from(time: DateTime) -> SystemTime { time.to_system_time() @@ -302,7 +292,6 @@ impl From<DateTime> for SystemTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl From<&DateTime> for SystemTime { fn from(time: &DateTime) -> SystemTime { time.to_system_time() @@ -310,7 +299,6 @@ impl From<&DateTime> for SystemTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl TryFrom<SystemTime> for DateTime { type Error = Error; @@ -320,7 +308,6 @@ impl TryFrom<SystemTime> for DateTime { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl TryFrom<&SystemTime> for DateTime { type Error = Error; @@ -330,12 +317,11 @@ impl TryFrom<&SystemTime> for DateTime { } #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl TryFrom<DateTime> for PrimitiveDateTime { type Error = Error; fn try_from(time: DateTime) -> Result<PrimitiveDateTime> { - let month = (time.month() as u8).try_into()?; + let month = time.month().try_into()?; let date = time::Date::from_calendar_date(i32::from(time.year()), month, time.day())?; let time = time::Time::from_hms(time.hour(), time.minutes(), time.seconds())?; @@ -344,7 +330,6 @@ impl TryFrom<DateTime> for PrimitiveDateTime { } #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] impl TryFrom<PrimitiveDateTime> for DateTime { type Error = Error; @@ -360,11 +345,28 @@ impl TryFrom<PrimitiveDateTime> for DateTime { } } +// Implement by hand because the derive would create invalid values. +// Use the conversion from Duration to create a valid value. +#[cfg(feature = "arbitrary")] +impl<'a> arbitrary::Arbitrary<'a> for DateTime { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + Self::from_unix_duration(Duration::new( + u.int_in_range(0..=MAX_UNIX_DURATION.as_secs().saturating_sub(1))?, + u.int_in_range(0..=999_999_999)?, + )) + .map_err(|_| arbitrary::Error::IncorrectFormat) + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + arbitrary::size_hint::and(u64::size_hint(depth), u32::size_hint(depth)) + } +} + /// Decode 2-digit decimal value // TODO(tarcieri): checked arithmetic #[allow(clippy::integer_arithmetic)] pub(crate) fn decode_decimal(tag: Tag, hi: u8, lo: u8) -> Result<u8> { - if (b'0'..=b'9').contains(&hi) && (b'0'..=b'9').contains(&lo) { + if hi.is_ascii_digit() && lo.is_ascii_digit() { Ok((hi - b'0') * 10 + (lo - b'0')) } else { Err(tag.value_error()) @@ -386,6 +388,16 @@ where writer.write_byte(b'0'.checked_add(value % 10).ok_or(ErrorKind::Overflow)?) } +/// Decode 4-digit year. +// TODO(tarcieri): checked arithmetic +#[allow(clippy::integer_arithmetic)] +fn decode_year(year: &[u8; 4]) -> Result<u16> { + let tag = Tag::GeneralizedTime; + let hi = decode_decimal(tag, year[0], year[1]).map_err(|_| ErrorKind::DateTime)?; + let lo = decode_decimal(tag, year[2], year[3]).map_err(|_| ErrorKind::DateTime)?; + Ok(u16::from(hi) * 100 + u16::from(lo)) +} + #[cfg(test)] mod tests { use super::DateTime; diff --git a/vendor/der/src/decode.rs b/vendor/der/src/decode.rs index 1c63b322a..0efcae69f 100644 --- a/vendor/der/src/decode.rs +++ b/vendor/der/src/decode.rs @@ -8,6 +8,9 @@ use crate::{pem::PemLabel, PemReader}; #[cfg(doc)] use crate::{Length, Tag}; +#[cfg(feature = "alloc")] +use alloc::boxed::Box; + /// Decoding trait. /// /// This trait provides the core abstraction upon which all decoding operations @@ -52,14 +55,12 @@ impl<T> DecodeOwned for T where T: for<'a> Decode<'a> {} /// This trait is automatically impl'd for any type which impls both /// [`DecodeOwned`] and [`PemLabel`]. #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub trait DecodePem: DecodeOwned + PemLabel { /// Try to decode this type from PEM. fn from_pem(pem: impl AsRef<[u8]>) -> Result<Self>; } #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] impl<T: DecodeOwned + PemLabel> DecodePem for T { fn from_pem(pem: impl AsRef<[u8]>) -> Result<Self> { let mut reader = PemReader::new(pem.as_ref())?; @@ -74,3 +75,13 @@ pub trait DecodeValue<'a>: Sized { /// Attempt to decode this message using the provided [`Reader`]. fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self>; } + +#[cfg(feature = "alloc")] +impl<'a, T> DecodeValue<'a> for Box<T> +where + T: DecodeValue<'a>, +{ + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + Ok(Box::new(T::decode_value(reader, header)?)) + } +} diff --git a/vendor/der/src/document.rs b/vendor/der/src/document.rs index aa953cd46..78355a67a 100644 --- a/vendor/der/src/document.rs +++ b/vendor/der/src/document.rs @@ -27,7 +27,6 @@ use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing}; /// /// The [`SecretDocument`] provides a wrapper for this type with additional /// hardening applied. -#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] #[derive(Clone, Eq, PartialEq)] pub struct Document { /// ASN.1 DER encoded bytes. @@ -45,7 +44,6 @@ impl Document { /// Convert to a [`SecretDocument`]. #[cfg(feature = "zeroize")] - #[cfg_attr(docsrs, doc(cfg(feature = "zeroize")))] pub fn into_secret(self) -> SecretDocument { SecretDocument(self) } @@ -74,14 +72,13 @@ impl Document { /// Encode the provided type as ASN.1 DER, storing the resulting encoded DER /// as a [`Document`]. pub fn encode_msg<T: Encode>(msg: &T) -> Result<Self> { - msg.to_vec()?.try_into() + msg.to_der()?.try_into() } /// Decode ASN.1 DER document from PEM. /// /// Returns the PEM label and decoded [`Document`] on success. #[cfg(feature = "pem")] - #[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub fn from_pem(pem: &str) -> Result<(&str, Self)> { let (label, der_bytes) = pem::decode_vec(pem.as_bytes())?; Ok((label, der_bytes.try_into()?)) @@ -90,35 +87,30 @@ impl Document { /// Encode ASN.1 DER document as a PEM string with encapsulation boundaries /// containing the provided PEM type `label` (e.g. `CERTIFICATE`). #[cfg(feature = "pem")] - #[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub fn to_pem(&self, label: &'static str, line_ending: pem::LineEnding) -> Result<String> { Ok(pem::encode_string(label, line_ending, self.as_bytes())?) } /// Read ASN.1 DER document from a file. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn read_der_file(path: impl AsRef<Path>) -> Result<Self> { fs::read(path)?.try_into() } /// Write ASN.1 DER document to a file. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn write_der_file(&self, path: impl AsRef<Path>) -> Result<()> { Ok(fs::write(path, self.as_bytes())?) } /// Read PEM-encoded ASN.1 DER document from a file. #[cfg(all(feature = "pem", feature = "std"))] - #[cfg_attr(docsrs, doc(cfg(all(feature = "pem", feature = "std"))))] pub fn read_pem_file(path: impl AsRef<Path>) -> Result<(String, Self)> { Self::from_pem(&fs::read_to_string(path)?).map(|(label, doc)| (label.to_owned(), doc)) } /// Write PEM-encoded ASN.1 DER document to a file. #[cfg(all(feature = "pem", feature = "std"))] - #[cfg_attr(docsrs, doc(cfg(all(feature = "pem", feature = "std"))))] pub fn write_pem_file( &self, path: impl AsRef<Path>, @@ -166,7 +158,7 @@ impl Encode for Document { Ok(self.len()) } - fn encode(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode(&self, writer: &mut impl Writer) -> Result<()> { writer.write(self.as_bytes()) } } @@ -205,7 +197,6 @@ impl TryFrom<Vec<u8>> for Document { /// are zeroized-on-drop, and also using more restrictive file permissions when /// writing files to disk. #[cfg(feature = "zeroize")] -#[cfg_attr(docsrs, doc(cfg(all(feature = "alloc", feature = "zeroize"))))] #[derive(Clone)] pub struct SecretDocument(Document); @@ -238,14 +229,12 @@ impl SecretDocument { /// Decode ASN.1 DER document from PEM. #[cfg(feature = "pem")] - #[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub fn from_pem(pem: &str) -> Result<(&str, Self)> { Document::from_pem(pem).map(|(label, doc)| (label, Self(doc))) } /// Encode ASN.1 DER document as a PEM string. #[cfg(feature = "pem")] - #[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub fn to_pem( &self, label: &'static str, @@ -256,28 +245,24 @@ impl SecretDocument { /// Read ASN.1 DER document from a file. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn read_der_file(path: impl AsRef<Path>) -> Result<Self> { Document::read_der_file(path).map(Self) } /// Write ASN.1 DER document to a file. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn write_der_file(&self, path: impl AsRef<Path>) -> Result<()> { write_secret_file(path, self.as_bytes()) } /// Read PEM-encoded ASN.1 DER document from a file. #[cfg(all(feature = "pem", feature = "std"))] - #[cfg_attr(docsrs, doc(cfg(all(feature = "pem", feature = "std"))))] pub fn read_pem_file(path: impl AsRef<Path>) -> Result<(String, Self)> { Document::read_pem_file(path).map(|(label, doc)| (label, Self(doc))) } /// Write PEM-encoded ASN.1 DER document to a file. #[cfg(all(feature = "pem", feature = "std"))] - #[cfg_attr(docsrs, doc(cfg(all(feature = "pem", feature = "std"))))] pub fn write_pem_file( &self, path: impl AsRef<Path>, diff --git a/vendor/der/src/encode.rs b/vendor/der/src/encode.rs index 51fc13d8b..d480b7bbd 100644 --- a/vendor/der/src/encode.rs +++ b/vendor/der/src/encode.rs @@ -3,7 +3,7 @@ use crate::{Header, Length, Result, SliceWriter, Tagged, Writer}; #[cfg(feature = "alloc")] -use {alloc::vec::Vec, core::iter}; +use {alloc::boxed::Box, alloc::vec::Vec, core::iter}; #[cfg(feature = "pem")] use { @@ -24,7 +24,7 @@ pub trait Encode { fn encoded_len(&self) -> Result<Length>; /// Encode this value as ASN.1 DER using the provided [`Writer`]. - fn encode(&self, encoder: &mut dyn Writer) -> Result<()>; + fn encode(&self, encoder: &mut impl Writer) -> Result<()>; /// Encode this value to the provided byte slice, returning a sub-slice /// containing the encoded message. @@ -37,7 +37,6 @@ pub trait Encode { /// Encode this message as ASN.1 DER, appending it to the provided /// byte vector. #[cfg(feature = "alloc")] - #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] fn encode_to_vec(&self, buf: &mut Vec<u8>) -> Result<Length> { let expected_len = usize::try_from(self.encoded_len()?)?; buf.reserve(expected_len); @@ -58,10 +57,9 @@ pub trait Encode { actual_len.try_into() } - /// Serialize this message as a byte vector. + /// Encode this type as DER, returning a byte vector. #[cfg(feature = "alloc")] - #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] - fn to_vec(&self) -> Result<Vec<u8>> { + fn to_der(&self) -> Result<Vec<u8>> { let mut buf = Vec::new(); self.encode_to_vec(&mut buf)?; Ok(buf) @@ -78,7 +76,7 @@ where } /// Encode this value as ASN.1 DER using the provided [`Writer`]. - fn encode(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode(&self, writer: &mut impl Writer) -> Result<()> { self.header()?.encode(writer)?; self.encode_value(writer) } @@ -89,14 +87,12 @@ where /// This trait is automatically impl'd for any type which impls both /// [`Encode`] and [`PemLabel`]. #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub trait EncodePem: Encode + PemLabel { /// Try to encode this type as PEM. fn to_pem(&self, line_ending: LineEnding) -> Result<String>; } #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] impl<T: Encode + PemLabel> EncodePem for T { fn to_pem(&self, line_ending: LineEnding) -> Result<String> { let der_len = usize::try_from(self.encoded_len()?)?; @@ -129,5 +125,18 @@ pub trait EncodeValue { /// Encode value (sans [`Tag`]+[`Length`] header) as ASN.1 DER using the /// provided [`Writer`]. - fn encode_value(&self, encoder: &mut dyn Writer) -> Result<()>; + fn encode_value(&self, encoder: &mut impl Writer) -> Result<()>; +} + +#[cfg(feature = "alloc")] +impl<T> EncodeValue for Box<T> +where + T: EncodeValue, +{ + fn value_len(&self) -> Result<Length> { + T::value_len(self) + } + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + T::encode_value(self, writer) + } } diff --git a/vendor/der/src/encode_ref.rs b/vendor/der/src/encode_ref.rs index c1e4f03f4..8a60a933f 100644 --- a/vendor/der/src/encode_ref.rs +++ b/vendor/der/src/encode_ref.rs @@ -22,7 +22,7 @@ where self.0.encoded_len() } - fn encode(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode(&self, writer: &mut impl Writer) -> Result<()> { self.0.encode(writer) } } @@ -47,7 +47,7 @@ where self.0.value_len() } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { self.0.encode_value(writer) } } diff --git a/vendor/der/src/error.rs b/vendor/der/src/error.rs index 5e492a48d..94378ef71 100644 --- a/vendor/der/src/error.rs +++ b/vendor/der/src/error.rs @@ -174,7 +174,6 @@ pub enum ErrorKind { /// File not found error. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] FileNotFound, /// Message is incomplete and does not contain all of the expected data. @@ -194,9 +193,11 @@ pub enum ErrorKind { /// I/O errors. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] Io(std::io::ErrorKind), + /// Indefinite length disallowed. + IndefiniteLength, + /// Incorrect length for a given field. Length { /// Tag of the value being decoded. @@ -221,7 +222,6 @@ pub enum ErrorKind { /// to determine which OID(s) are causing the error (and then potentially /// contribute upstream support for algorithms they care about). #[cfg(feature = "oid")] - #[cfg_attr(docsrs, doc(cfg(feature = "oid")))] OidUnknown { /// OID value that was unrecognized by a parser for a DER-based format. oid: ObjectIdentifier, @@ -238,12 +238,10 @@ pub enum ErrorKind { /// PEM encoding errors. #[cfg(feature = "pem")] - #[cfg_attr(docsrs, doc(cfg(feature = "pem")))] Pem(pem::Error), /// Permission denied reading file. #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] PermissionDenied, /// Reader does not support the requested operation. @@ -321,6 +319,7 @@ impl fmt::Display for ErrorKind { ), #[cfg(feature = "std")] ErrorKind::Io(err) => write!(f, "I/O error: {:?}", err), + ErrorKind::IndefiniteLength => write!(f, "indefinite length disallowed"), ErrorKind::Length { tag } => write!(f, "incorrect length for {}", tag), ErrorKind::Noncanonical { tag } => { write!(f, "ASN.1 {} not canonically encoded as DER", tag) diff --git a/vendor/der/src/header.rs b/vendor/der/src/header.rs index ddb484ee7..ad303810c 100644 --- a/vendor/der/src/header.rs +++ b/vendor/der/src/header.rs @@ -44,7 +44,7 @@ impl Encode for Header { self.tag.encoded_len()? + self.length.encoded_len()? } - fn encode(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode(&self, writer: &mut impl Writer) -> Result<()> { self.tag.encode(writer)?; self.length.encode(writer) } diff --git a/vendor/der/src/length.rs b/vendor/der/src/length.rs index 76ee0e997..d183a69fe 100644 --- a/vendor/der/src/length.rs +++ b/vendor/der/src/length.rs @@ -14,6 +14,13 @@ const MAX_DER_OCTETS: usize = 5; /// Maximum length as a `u32` (256 MiB). const MAX_U32: u32 = 0xfff_ffff; +/// Octet identifying an indefinite length as described in X.690 Section +/// 8.1.3.6.1: +/// +/// > The single octet shall have bit 8 set to one, and bits 7 to +/// > 1 set to zero. +const INDEFINITE_LENGTH_OCTET: u8 = 0b10000000; // 0x80 + /// ASN.1-encoded length. /// /// Maximum length is defined by the [`Length::MAX`] constant (256 MiB). @@ -204,7 +211,8 @@ impl<'a> Decode<'a> for Length { match reader.read_byte()? { // Note: per X.690 Section 8.1.3.6.1 the byte 0x80 encodes indefinite // lengths, which are not allowed in DER, so disallow that byte. - len if len < 0x80 => Ok(len.into()), + len if len < INDEFINITE_LENGTH_OCTET => Ok(len.into()), + INDEFINITE_LENGTH_OCTET => Err(ErrorKind::IndefiniteLength.into()), // 1-4 byte variable-sized length prefix tag @ 0x81..=0x84 => { let nbytes = tag.checked_sub(0x80).ok_or(ErrorKind::Overlength)? as usize; @@ -246,7 +254,7 @@ impl Encode for Length { } } - fn encode(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode(&self, writer: &mut impl Writer) -> Result<()> { match self.initial_octet() { Some(tag_byte) => { writer.write_byte(tag_byte)?; @@ -286,9 +294,126 @@ impl fmt::Display for Length { } } +// Implement by hand because the derive would create invalid values. +// Generate a u32 with a valid range. +#[cfg(feature = "arbitrary")] +impl<'a> arbitrary::Arbitrary<'a> for Length { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + Ok(Self(u.int_in_range(0..=MAX_U32)?)) + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + u32::size_hint(depth) + } +} + +/// Length type with support for indefinite lengths as used by ASN.1 BER, +/// as described in X.690 Section 8.1.3.6: +/// +/// > 8.1.3.6 For the indefinite form, the length octets indicate that the +/// > contents octets are terminated by end-of-contents +/// > octets (see 8.1.5), and shall consist of a single octet. +/// > +/// > 8.1.3.6.1 The single octet shall have bit 8 set to one, and bits 7 to +/// > 1 set to zero. +/// > +/// > 8.1.3.6.2 If this form of length is used, then end-of-contents octets +/// > (see 8.1.5) shall be present in the encoding following the contents +/// > octets. +/// +/// Indefinite lengths are non-canonical and therefore invalid DER, however +/// there are interoperability corner cases where we have little choice but to +/// tolerate some BER productions where this is helpful. +#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] +pub struct IndefiniteLength(Option<Length>); + +impl IndefiniteLength { + /// Length of `0`. + pub const ZERO: Self = Self(Some(Length::ZERO)); + + /// Length of `1`. + pub const ONE: Self = Self(Some(Length::ONE)); + + /// Indefinite length. + pub const INDEFINITE: Self = Self(None); +} + +impl IndefiniteLength { + /// Create a definite length from a type which can be converted into a + /// `Length`. + pub fn new(length: impl Into<Length>) -> Self { + Self(Some(length.into())) + } + + /// Is this length definite? + pub fn is_definite(self) -> bool { + self.0.is_some() + } + /// Is this length indefinite? + pub fn is_indefinite(self) -> bool { + self.0.is_none() + } +} + +impl<'a> Decode<'a> for IndefiniteLength { + fn decode<R: Reader<'a>>(reader: &mut R) -> Result<IndefiniteLength> { + if reader.peek_byte() == Some(INDEFINITE_LENGTH_OCTET) { + // Consume the byte we already peeked at. + let byte = reader.read_byte()?; + debug_assert_eq!(byte, INDEFINITE_LENGTH_OCTET); + + Ok(Self::INDEFINITE) + } else { + Length::decode(reader).map(Into::into) + } + } +} + +impl Encode for IndefiniteLength { + fn encoded_len(&self) -> Result<Length> { + match self.0 { + Some(length) => length.encoded_len(), + None => Ok(Length::ONE), + } + } + + fn encode(&self, writer: &mut impl Writer) -> Result<()> { + match self.0 { + Some(length) => length.encode(writer), + None => writer.write_byte(INDEFINITE_LENGTH_OCTET), + } + } +} + +impl From<Length> for IndefiniteLength { + fn from(length: Length) -> IndefiniteLength { + Self(Some(length)) + } +} + +impl From<Option<Length>> for IndefiniteLength { + fn from(length: Option<Length>) -> IndefiniteLength { + IndefiniteLength(length) + } +} + +impl From<IndefiniteLength> for Option<Length> { + fn from(length: IndefiniteLength) -> Option<Length> { + length.0 + } +} + +impl TryFrom<IndefiniteLength> for Length { + type Error = Error; + + fn try_from(length: IndefiniteLength) -> Result<Length> { + length.0.ok_or_else(|| ErrorKind::IndefiniteLength.into()) + } +} + #[cfg(test)] mod tests { - use super::Length; + use super::{IndefiniteLength, Length}; use crate::{Decode, DerOrd, Encode, ErrorKind}; use core::cmp::Ordering; @@ -355,8 +480,22 @@ mod tests { } #[test] - fn reject_indefinite_lengths() { + fn indefinite_lengths() { + // DER disallows indefinite lengths assert!(Length::from_der(&[0x80]).is_err()); + + // The `IndefiniteLength` type supports them + let indefinite_length = IndefiniteLength::from_der(&[0x80]).unwrap(); + assert!(indefinite_length.is_indefinite()); + assert_eq!(indefinite_length, IndefiniteLength::INDEFINITE); + + // It also supports definite lengths. + let length = IndefiniteLength::from_der(&[0x83, 0x01, 0x00, 0x00]).unwrap(); + assert!(length.is_definite()); + assert_eq!( + Length::try_from(0x10000u32).unwrap(), + length.try_into().unwrap() + ); } #[test] diff --git a/vendor/der/src/lib.rs b/vendor/der/src/lib.rs index 413b2e4af..dcd5097d4 100644 --- a/vendor/der/src/lib.rs +++ b/vendor/der/src/lib.rs @@ -1,5 +1,5 @@ #![no_std] -#![cfg_attr(docsrs, feature(doc_cfg))] +#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![doc = include_str!("../README.md")] #![doc( html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg", @@ -15,6 +15,7 @@ clippy::checked_conversions, clippy::implicit_saturating_sub, clippy::integer_arithmetic, + clippy::mod_module_files, clippy::panic, clippy::panic_in_result_fn, clippy::unwrap_used, @@ -56,7 +57,7 @@ //! - [`VideotexStringRef`]: ASN.1 `VideotexString`. //! - [`SequenceOf`]: ASN.1 `SEQUENCE OF`. //! - [`SetOf`], [`SetOfVec`]: ASN.1 `SET OF`. -//! - [`UIntRef`]: ASN.1 unsigned `INTEGER` with raw access to encoded bytes. +//! - [`UintRef`]: ASN.1 unsigned `INTEGER` with raw access to encoded bytes. //! - [`UtcTime`]: ASN.1 `UTCTime`. //! - [`Utf8StringRef`]: ASN.1 `UTF8String`. //! @@ -139,33 +140,20 @@ //! } //! } //! -//! impl<'a> Sequence<'a> for AlgorithmIdentifier<'a> { -//! // The `Sequence::fields` method is used for encoding and functions as -//! // a visitor for all of the fields in a message. -//! // -//! // To implement it, you must define a slice containing `Encode` -//! // trait objects, then pass it to the provided `field_encoder` -//! // function, which is implemented by the `der` crate and handles -//! // message serialization. -//! // -//! // Trait objects are used because they allow for slices containing -//! // heterogeneous field types, and a callback is used to allow for the -//! // construction of temporary field encoder types. The latter means -//! // that the fields of your Rust struct don't necessarily need to -//! // impl the `Encode` trait, but if they don't you must construct -//! // a temporary wrapper value which does. -//! // -//! // Types which impl the `Sequence` trait receive blanket impls of both -//! // the `Encode` and `Tagged` traits (where the latter is impl'd as -//! // `Tagged::TAG = der::Tag::Sequence`. -//! fn fields<F, T>(&self, field_encoder: F) -> der::Result<T> -//! where -//! F: FnOnce(&[&dyn Encode]) -> der::Result<T>, -//! { -//! field_encoder(&[&self.algorithm, &self.parameters]) +//! impl<'a> ::der::EncodeValue for AlgorithmIdentifier<'a> { +//! fn value_len(&self) -> ::der::Result<::der::Length> { +//! self.algorithm.encoded_len()? + self.parameters.encoded_len()? +//! } +//! +//! fn encode_value(&self, writer: &mut impl ::der::Writer) -> ::der::Result<()> { +//! self.algorithm.encode(writer)?; +//! self.parameters.encode(writer)?; +//! Ok(()) //! } //! } //! +//! impl<'a> Sequence<'a> for AlgorithmIdentifier<'a> {} +//! //! // Example parameters value: OID for the NIST P-256 elliptic curve. //! let parameters = "1.2.840.10045.3.1.7".parse::<ObjectIdentifier>().unwrap(); //! @@ -182,7 +170,7 @@ //! // If you would prefer to avoid allocations, you can create a byte array //! // as backing storage instead, pass that to `der::Encoder::new`, and then //! // encode the `parameters` value using `encoder.encode(parameters)`. -//! let der_encoded_parameters = parameters.to_vec().unwrap(); +//! let der_encoded_parameters = parameters.to_der().unwrap(); //! //! let algorithm_identifier = AlgorithmIdentifier { //! // OID for `id-ecPublicKey`, if you're curious @@ -201,7 +189,7 @@ //! // reference to it, then encode the message using //! // `encoder.encode(algorithm_identifier)`, then finally `encoder.finish()` //! // to obtain a byte slice containing the encoded message. -//! let der_encoded_algorithm_identifier = algorithm_identifier.to_vec().unwrap(); +//! let der_encoded_algorithm_identifier = algorithm_identifier.to_der().unwrap(); //! //! // Deserialize the `AlgorithmIdentifier` we just serialized from ASN.1 DER //! // using `der::Decode::from_bytes`. @@ -255,7 +243,7 @@ //! }; //! //! // Encode -//! let der_encoded_algorithm_identifier = algorithm_identifier.to_vec().unwrap(); +//! let der_encoded_algorithm_identifier = algorithm_identifier.to_der().unwrap(); //! //! // Decode //! let decoded_algorithm_identifier = AlgorithmIdentifier::from_der( @@ -328,7 +316,7 @@ //! [`SequenceOf`]: asn1::SequenceOf //! [`SetOf`]: asn1::SetOf //! [`SetOfVec`]: asn1::SetOfVec -//! [`UIntRef`]: asn1::UIntRef +//! [`UintRef`]: asn1::UintRef //! [`UtcTime`]: asn1::UtcTime //! [`Utf8StringRef`]: asn1::Utf8StringRef @@ -340,9 +328,10 @@ extern crate alloc; extern crate std; pub mod asn1; +pub mod referenced; pub(crate) mod arrayvec; -mod byte_slice; +mod bytes_ref; mod datetime; mod decode; mod encode; @@ -352,12 +341,16 @@ mod header; mod length; mod ord; mod reader; -mod str_slice; +mod str_ref; mod tag; mod writer; #[cfg(feature = "alloc")] +mod bytes_owned; +#[cfg(feature = "alloc")] mod document; +#[cfg(feature = "alloc")] +mod str_owned; pub use crate::{ asn1::{AnyRef, Choice, Sequence}, @@ -367,37 +360,35 @@ pub use crate::{ encode_ref::{EncodeRef, EncodeValueRef}, error::{Error, ErrorKind, Result}, header::Header, - length::Length, + length::{IndefiniteLength, Length}, ord::{DerOrd, ValueOrd}, - reader::{slice::SliceReader, Reader}, + reader::{nested::NestedReader, slice::SliceReader, Reader}, tag::{Class, FixedTag, Tag, TagMode, TagNumber, Tagged}, writer::{slice::SliceWriter, Writer}, }; #[cfg(feature = "alloc")] -pub use crate::document::Document; +pub use crate::{asn1::Any, document::Document}; #[cfg(feature = "bigint")] -#[cfg_attr(docsrs, doc(cfg(feature = "bigint")))] pub use crypto_bigint as bigint; #[cfg(feature = "derive")] -#[cfg_attr(docsrs, doc(cfg(feature = "derive")))] pub use der_derive::{Choice, Enumerated, Sequence, ValueOrd}; +#[cfg(feature = "flagset")] +pub use flagset; + #[cfg(feature = "oid")] -#[cfg_attr(docsrs, doc(cfg(feature = "oid")))] pub use const_oid as oid; #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub use { crate::{decode::DecodePem, encode::EncodePem, reader::pem::PemReader, writer::pem::PemWriter}, pem_rfc7468 as pem, }; #[cfg(feature = "time")] -#[cfg_attr(docsrs, doc(cfg(feature = "time")))] pub use time; #[cfg(feature = "zeroize")] @@ -406,4 +397,6 @@ pub use zeroize; #[cfg(all(feature = "alloc", feature = "zeroize"))] pub use crate::document::SecretDocument; -pub(crate) use crate::{arrayvec::ArrayVec, byte_slice::ByteSlice, str_slice::StrSlice}; +pub(crate) use crate::{arrayvec::ArrayVec, bytes_ref::BytesRef, str_ref::StrRef}; +#[cfg(feature = "alloc")] +pub(crate) use crate::{bytes_owned::BytesOwned, str_owned::StrOwned}; diff --git a/vendor/der/src/reader.rs b/vendor/der/src/reader.rs index b917323c2..ea52f7bde 100644 --- a/vendor/der/src/reader.rs +++ b/vendor/der/src/reader.rs @@ -1,6 +1,6 @@ //! Reader trait. -mod nested; +pub(crate) mod nested; #[cfg(feature = "pem")] pub(crate) mod pem; pub(crate) mod slice; @@ -135,7 +135,6 @@ pub trait Reader<'r>: Sized { /// Read a byte vector of the given length. #[cfg(feature = "alloc")] - #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] fn read_vec(&mut self, len: Length) -> Result<Vec<u8>> { let mut bytes = vec![0u8; usize::try_from(len)?]; self.read_into(&mut bytes)?; diff --git a/vendor/der/src/reader/pem.rs b/vendor/der/src/reader/pem.rs index 01bb4f20e..f11341aa6 100644 --- a/vendor/der/src/reader/pem.rs +++ b/vendor/der/src/reader/pem.rs @@ -1,16 +1,134 @@ //! Streaming PEM reader. use super::Reader; -use crate::{ErrorKind, Header, Length, Result}; -use pem_rfc7468::Decoder; +use crate::{Decode, Error, ErrorKind, Header, Length, Result}; +use core::cell::RefCell; + +#[allow(clippy::integer_arithmetic)] +mod utils { + use crate::{Error, Length, Result}; + use pem_rfc7468::Decoder; + + #[derive(Clone)] + pub(super) struct BufReader<'i> { + /// Inner PEM decoder. + decoder: Decoder<'i>, + + /// Remaining after base64 decoding + remaining: usize, + + /// Read buffer + buf: [u8; BufReader::CAPACITY], + + /// Position of the head in the buffer, + pos: usize, + + /// Position of the tail in the buffer, + cap: usize, + } + + impl<'i> BufReader<'i> { + const CAPACITY: usize = 256; + + pub fn new(pem: &'i [u8]) -> Result<Self> { + let decoder = Decoder::new(pem)?; + let remaining = decoder.remaining_len(); + + Ok(Self { + decoder, + remaining, + buf: [0u8; 256], + pos: 0, + cap: 0, + }) + } + + pub fn remaining_len(&self) -> usize { + self.decoder.remaining_len() + self.cap - self.pos + } + + fn fill_buffer(&mut self) -> Result<()> { + debug_assert!(self.pos <= self.cap); + + if self.is_empty() { + self.pos = 0; + self.cap = 0; + } + + let end = (self.cap + self.remaining).min(Self::CAPACITY); + let writable_slice = &mut self.buf[self.cap..end]; + if writable_slice.is_empty() { + return Ok(()); + } + + let wrote = self.decoder.decode(writable_slice)?.len(); + if wrote == 0 { + return Err(Error::incomplete(Length::try_from(self.pos)?)); + } + + self.cap += wrote; + self.remaining -= wrote; + debug_assert!(self.cap <= Self::CAPACITY); + + Ok(()) + } + + /// Get the PEM label which will be used in the encapsulation boundaries + /// for this document. + pub fn type_label(&self) -> &'i str { + self.decoder.type_label() + } + + fn is_empty(&self) -> bool { + self.pos == self.cap + } + + fn as_slice(&self) -> &[u8] { + &self.buf[self.pos..self.cap] + } + } + + impl<'i> BufReader<'i> { + pub fn peek_byte(&self) -> Option<u8> { + let s = self.as_slice(); + s.first().copied() + } + + pub fn copy_to_slice<'o>(&mut self, buf: &'o mut [u8]) -> Result<&'o [u8]> { + let mut output_pos = 0; + + while output_pos < buf.len() { + if self.is_empty() { + self.fill_buffer()?; + } + + let available = &self.buf[self.pos..self.cap]; + let window_len = (buf.len() - output_pos).min(available.len()); + let window = &mut buf[output_pos..output_pos + window_len]; + + window.copy_from_slice(&available[..window_len]); + self.pos += window_len; + output_pos += window_len; + } + + // Don't leave the read buffer empty for peek_byte() + if self.is_empty() && self.decoder.remaining_len() != 0 { + self.fill_buffer()? + } + + debug_assert_eq!(output_pos, buf.len()); + + Ok(buf) + } + } +} /// `Reader` type which decodes PEM on-the-fly. #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] #[derive(Clone)] pub struct PemReader<'i> { - /// Inner PEM decoder. - decoder: Decoder<'i>, + /// Inner PEM decoder wrapped in a BufReader. + reader: RefCell<utils::BufReader<'i>>, /// Input length (in bytes after Base64 decoding). input_len: Length, @@ -20,17 +138,16 @@ pub struct PemReader<'i> { } #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] impl<'i> PemReader<'i> { /// Create a new PEM reader which decodes data on-the-fly. /// /// Uses the default 64-character line wrapping. pub fn new(pem: &'i [u8]) -> Result<Self> { - let decoder = Decoder::new(pem)?; - let input_len = Length::try_from(decoder.remaining_len())?; + let reader = utils::BufReader::new(pem)?; + let input_len = Length::try_from(reader.remaining_len())?; Ok(Self { - decoder, + reader: RefCell::new(reader), input_len, position: Length::ZERO, }) @@ -39,25 +156,30 @@ impl<'i> PemReader<'i> { /// Get the PEM label which will be used in the encapsulation boundaries /// for this document. pub fn type_label(&self) -> &'i str { - self.decoder.type_label() + self.reader.borrow().type_label() } } #[cfg(feature = "pem")] -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] impl<'i> Reader<'i> for PemReader<'i> { fn input_len(&self) -> Length { self.input_len } fn peek_byte(&self) -> Option<u8> { - // TODO(tarcieri): lookahead buffer - None + if self.is_finished() { + None + } else { + self.reader.borrow().peek_byte() + } } fn peek_header(&self) -> Result<Header> { - // TODO(tarcieri): lookahead buffer - Err(ErrorKind::Reader.into()) + if self.is_finished() { + Err(Error::incomplete(self.offset())) + } else { + Header::decode(&mut self.clone()) + } } fn position(&self) -> Length { @@ -70,12 +192,13 @@ impl<'i> Reader<'i> for PemReader<'i> { } fn read_into<'o>(&mut self, buf: &'o mut [u8]) -> Result<&'o [u8]> { - let bytes = self.decoder.decode(buf)?; + let bytes = self.reader.borrow_mut().copy_to_slice(buf)?; + self.position = (self.position + bytes.len())?; debug_assert_eq!( self.position, - (self.input_len - Length::try_from(self.decoder.remaining_len())?)? + (self.input_len - Length::try_from(self.reader.borrow().remaining_len())?)? ); Ok(bytes) diff --git a/vendor/der/src/reader/slice.rs b/vendor/der/src/reader/slice.rs index 6bab091f3..e78468fed 100644 --- a/vendor/der/src/reader/slice.rs +++ b/vendor/der/src/reader/slice.rs @@ -1,12 +1,12 @@ //! Slice reader. -use crate::{ByteSlice, Decode, Error, ErrorKind, Header, Length, Reader, Result, Tag}; +use crate::{BytesRef, Decode, Error, ErrorKind, Header, Length, Reader, Result, Tag}; /// [`Reader`] which consumes an input byte slice. #[derive(Clone, Debug)] pub struct SliceReader<'a> { /// Byte slice being decoded. - bytes: ByteSlice<'a>, + bytes: BytesRef<'a>, /// Did the decoding operation fail? failed: bool, @@ -19,7 +19,7 @@ impl<'a> SliceReader<'a> { /// Create a new slice reader for the given byte slice. pub fn new(bytes: &'a [u8]) -> Result<Self> { Ok(Self { - bytes: ByteSlice::new(bytes)?, + bytes: BytesRef::new(bytes)?, failed: false, position: Length::ZERO, }) @@ -64,7 +64,7 @@ impl<'a> Reader<'a> for SliceReader<'a> { fn peek_byte(&self) -> Option<u8> { self.remaining() .ok() - .and_then(|bytes| bytes.get(0).cloned()) + .and_then(|bytes| bytes.first().cloned()) } fn peek_header(&self) -> Result<Header> { diff --git a/vendor/der/src/referenced.rs b/vendor/der/src/referenced.rs new file mode 100644 index 000000000..bb920db3a --- /dev/null +++ b/vendor/der/src/referenced.rs @@ -0,0 +1,47 @@ +//! A module for working with referenced data. + +/// A trait for borrowing data from an owned struct +pub trait OwnedToRef { + /// The resulting type referencing back to Self + type Borrowed<'a> + where + Self: 'a; + + /// Creates a new object referencing back to the self for storage + fn owned_to_ref(&self) -> Self::Borrowed<'_>; +} + +/// A trait for cloning a referenced structure and getting owned objects +/// +/// This is the pendant to [`OwnedToRef`] +pub trait RefToOwned<'a> { + /// The resulting type after obtaining ownership. + type Owned: OwnedToRef<Borrowed<'a> = Self> + where + Self: 'a; + + /// Creates a new object taking ownership of the data + fn ref_to_owned(&self) -> Self::Owned; +} + +impl<T> OwnedToRef for Option<T> +where + T: OwnedToRef, +{ + type Borrowed<'a> = Option<T::Borrowed<'a>> where T: 'a; + + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + self.as_ref().map(|o| o.owned_to_ref()) + } +} + +impl<'a, T> RefToOwned<'a> for Option<T> +where + T: RefToOwned<'a> + 'a, + T::Owned: OwnedToRef, +{ + type Owned = Option<T::Owned>; + fn ref_to_owned(&self) -> Self::Owned { + self.as_ref().map(|o| o.ref_to_owned()) + } +} diff --git a/vendor/der/src/str_owned.rs b/vendor/der/src/str_owned.rs new file mode 100644 index 000000000..25c258e4f --- /dev/null +++ b/vendor/der/src/str_owned.rs @@ -0,0 +1,105 @@ +//! Common handling for types backed by `String` with enforcement of a +//! library-level length limitation i.e. `Length::max()`. + +use crate::{ + referenced::OwnedToRef, BytesRef, DecodeValue, EncodeValue, Header, Length, Reader, Result, + StrRef, Writer, +}; +use alloc::string::String; +use core::str; + +/// String newtype which respects the [`Length::max`] limit. +#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] +pub struct StrOwned { + /// Inner value + pub(crate) inner: String, + + /// Precomputed `Length` (avoids possible panicking conversions) + pub(crate) length: Length, +} + +impl StrOwned { + /// Create a new [`StrOwned`], ensuring that the byte representation of + /// the provided `str` value is shorter than `Length::max()`. + pub fn new(s: &str) -> Result<Self> { + Ok(Self { + inner: String::from(s), + length: Length::try_from(s.as_bytes().len())?, + }) + } + + /// Parse a [`String`] from UTF-8 encoded bytes. + pub fn from_bytes(bytes: &[u8]) -> Result<Self> { + Ok(Self { + inner: String::from_utf8(bytes.to_vec())?, + length: Length::try_from(bytes.len())?, + }) + } + + /// Borrow the inner `str` + pub fn as_str(&self) -> &str { + &self.inner + } + + /// Borrow the inner byte slice + pub fn as_bytes(&self) -> &[u8] { + self.inner.as_bytes() + } + + /// Get the [`Length`] of this [`StrOwned`] + pub fn len(&self) -> Length { + self.length + } + + /// Is this [`StrOwned`] empty? + pub fn is_empty(&self) -> bool { + self.len() == Length::ZERO + } +} + +impl AsRef<str> for StrOwned { + fn as_ref(&self) -> &str { + self.as_str() + } +} + +impl AsRef<[u8]> for StrOwned { + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + +impl<'a> DecodeValue<'a> for StrOwned { + fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { + Self::from_bytes(BytesRef::decode_value(reader, header)?.as_slice()) + } +} + +impl EncodeValue for StrOwned { + fn value_len(&self) -> Result<Length> { + Ok(self.length) + } + + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { + writer.write(self.as_ref()) + } +} + +impl From<StrRef<'_>> for StrOwned { + fn from(s: StrRef<'_>) -> StrOwned { + Self { + inner: String::from(s.inner), + length: s.length, + } + } +} + +impl OwnedToRef for StrOwned { + type Borrowed<'a> = StrRef<'a>; + fn owned_to_ref(&self) -> Self::Borrowed<'_> { + StrRef { + length: self.length, + inner: self.inner.as_ref(), + } + } +} diff --git a/vendor/der/src/str_slice.rs b/vendor/der/src/str_ref.rs index 8c94528aa..899c7506b 100644 --- a/vendor/der/src/str_slice.rs +++ b/vendor/der/src/str_ref.rs @@ -1,12 +1,12 @@ //! Common handling for types backed by `str` slices with enforcement of a //! library-level length limitation i.e. `Length::max()`. -use crate::{ByteSlice, DecodeValue, EncodeValue, Header, Length, Reader, Result, Writer}; +use crate::{BytesRef, DecodeValue, EncodeValue, Header, Length, Reader, Result, Writer}; use core::str; /// String slice newtype which respects the [`Length::max`] limit. #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] -pub struct StrSlice<'a> { +pub struct StrRef<'a> { /// Inner value pub(crate) inner: &'a str, @@ -14,8 +14,8 @@ pub struct StrSlice<'a> { pub(crate) length: Length, } -impl<'a> StrSlice<'a> { - /// Create a new [`StrSlice`], ensuring that the byte representation of +impl<'a> StrRef<'a> { + /// Create a new [`StrRef`], ensuring that the byte representation of /// the provided `str` value is shorter than `Length::max()`. pub fn new(s: &'a str) -> Result<Self> { Ok(Self { @@ -24,7 +24,7 @@ impl<'a> StrSlice<'a> { }) } - /// Parse a [`StrSlice`] from UTF-8 encoded bytes. + /// Parse a [`StrRef`] from UTF-8 encoded bytes. pub fn from_bytes(bytes: &'a [u8]) -> Result<Self> { Self::new(str::from_utf8(bytes)?) } @@ -39,41 +39,54 @@ impl<'a> StrSlice<'a> { self.inner.as_bytes() } - /// Get the [`Length`] of this [`StrSlice`] + /// Get the [`Length`] of this [`StrRef`] pub fn len(self) -> Length { self.length } - /// Is this [`StrSlice`] empty? + /// Is this [`StrRef`] empty? pub fn is_empty(self) -> bool { self.len() == Length::ZERO } } -impl AsRef<str> for StrSlice<'_> { +impl AsRef<str> for StrRef<'_> { fn as_ref(&self) -> &str { self.as_str() } } -impl AsRef<[u8]> for StrSlice<'_> { +impl AsRef<[u8]> for StrRef<'_> { fn as_ref(&self) -> &[u8] { self.as_bytes() } } -impl<'a> DecodeValue<'a> for StrSlice<'a> { +impl<'a> DecodeValue<'a> for StrRef<'a> { fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> { - Self::from_bytes(ByteSlice::decode_value(reader, header)?.as_slice()) + Self::from_bytes(BytesRef::decode_value(reader, header)?.as_slice()) } } -impl<'a> EncodeValue for StrSlice<'a> { +impl<'a> EncodeValue for StrRef<'a> { fn value_len(&self) -> Result<Length> { Ok(self.length) } - fn encode_value(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode_value(&self, writer: &mut impl Writer) -> Result<()> { writer.write(self.as_ref()) } } + +#[cfg(feature = "alloc")] +mod allocating { + use super::StrRef; + use crate::{referenced::RefToOwned, StrOwned}; + + impl<'a> RefToOwned<'a> for StrRef<'a> { + type Owned = StrOwned; + fn ref_to_owned(&self) -> Self::Owned { + StrOwned::from(*self) + } + } +} diff --git a/vendor/der/src/tag.rs b/vendor/der/src/tag.rs index 0e7bf2013..b0853a846 100644 --- a/vendor/der/src/tag.rs +++ b/vendor/der/src/tag.rs @@ -1,4 +1,5 @@ //! ASN.1 tags. +#![cfg_attr(feature = "arbitrary", allow(clippy::integer_arithmetic))] mod class; mod mode; @@ -46,6 +47,7 @@ impl<T: FixedTag> Tagged for T { /// - Bits 8/7: [`Class`] /// - Bit 6: primitive (0) or constructed (1) /// - Bits 5-1: tag number +#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))] #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)] #[non_exhaustive] pub enum Tag { @@ -323,7 +325,7 @@ impl Encode for Tag { Ok(Length::ONE) } - fn encode(&self, writer: &mut dyn Writer) -> Result<()> { + fn encode(&self, writer: &mut impl Writer) -> Result<()> { writer.write_byte(self.into()) } } diff --git a/vendor/der/src/tag/mode.rs b/vendor/der/src/tag/mode.rs index 892ce3d81..ecdaf023a 100644 --- a/vendor/der/src/tag/mode.rs +++ b/vendor/der/src/tag/mode.rs @@ -4,11 +4,12 @@ use crate::{Error, ErrorKind, Result}; use core::{fmt, str::FromStr}; /// Tagging modes: `EXPLICIT` versus `IMPLICIT`. -#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] +#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)] pub enum TagMode { /// `EXPLICIT` tagging. /// /// Tag is added in addition to the inner tag of the type. + #[default] Explicit, /// `IMPLICIT` tagging. @@ -17,12 +18,6 @@ pub enum TagMode { Implicit, } -impl Default for TagMode { - fn default() -> TagMode { - TagMode::Explicit - } -} - impl FromStr for TagMode { type Err = Error; diff --git a/vendor/der/src/tag/number.rs b/vendor/der/src/tag/number.rs index 1930e9436..6a7eaae22 100644 --- a/vendor/der/src/tag/number.rs +++ b/vendor/der/src/tag/number.rs @@ -186,3 +186,16 @@ impl fmt::Display for TagNumber { write!(f, "{}", self.0) } } + +// Implement by hand because the derive would create invalid values. +// Use the constructor to create a valid value. +#[cfg(feature = "arbitrary")] +impl<'a> arbitrary::Arbitrary<'a> for TagNumber { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> { + Ok(Self::new(u.int_in_range(0..=Self::MAX)?)) + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + u8::size_hint(depth) + } +} diff --git a/vendor/der/src/writer.rs b/vendor/der/src/writer.rs index 5e9774413..164b215f7 100644 --- a/vendor/der/src/writer.rs +++ b/vendor/der/src/writer.rs @@ -21,7 +21,6 @@ pub trait Writer { } #[cfg(feature = "std")] -#[cfg_attr(docsrs, doc(cfg(feature = "std")))] impl<W: io::Write> Writer for W { fn write(&mut self, slice: &[u8]) -> Result<()> { <Self as io::Write>::write(self, slice)?; diff --git a/vendor/der/src/writer/pem.rs b/vendor/der/src/writer/pem.rs index c554632a8..87a6f8fd8 100644 --- a/vendor/der/src/writer/pem.rs +++ b/vendor/der/src/writer/pem.rs @@ -5,7 +5,6 @@ use crate::Result; use pem_rfc7468::{Encoder, LineEnding}; /// `Writer` type which outputs PEM-encoded data. -#[cfg_attr(docsrs, doc(cfg(feature = "pem")))] pub struct PemWriter<'w>(Encoder<'static, 'w>); impl<'w> PemWriter<'w> { |