Merge branch 'master' into dishmaker/der_clarify

dishmaker · web-flow · commit 1d8691dba4a3 · 2025-07-17T10:25:05.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/base64ct/benches/mod.rs b/base64ct/benches/mod.rs
@@ -6,7 +6,7 @@ extern crate test;
 use base64ct::{Base64Unpadded, Encoding};
 use test::Bencher;
 
-const B64_LEN: usize = 100_002;
+const B64_LEN: usize = 100_000;
 const RAW_LEN: usize = (3 * B64_LEN) / 4;
 
 #[inline(never)]
@@ -32,19 +32,19 @@ fn decode_bench(b: &mut Bencher) {
     let b64_data = get_b64_data();
     let mut buf = get_raw_data();
     b.iter(|| {
-        let out = Base64Unpadded::decode(&b64_data, &mut buf).unwrap();
+        let out = Base64Unpadded::decode(test::black_box(&b64_data), &mut buf).unwrap();
         test::black_box(out);
     });
     b.bytes = RAW_LEN as u64;
 }
 
 #[bench]
 fn decode_in_place_bench(b: &mut Bencher) {
-    let mut b64_data = get_b64_data().into_bytes();
+    let b64_data = get_b64_data().into_bytes();
+    let mut buf = b64_data.clone();
     b.iter(|| {
-        // since it works on the same buffer over and over,
-        // almost always `out` will be an error
-        let out = Base64Unpadded::decode_in_place(&mut b64_data);
+        buf.copy_from_slice(&b64_data[..]);
+        let out = Base64Unpadded::decode_in_place(&mut buf);
         let _ = test::black_box(out);
     });
     b.bytes = RAW_LEN as u64;
@@ -55,7 +55,7 @@ fn encode_bench(b: &mut Bencher) {
     let mut buf = get_b64_data().into_bytes();
     let raw_data = get_raw_data();
     b.iter(|| {
-        let out = Base64Unpadded::encode(&raw_data, &mut buf).unwrap();
+        let out = Base64Unpadded::encode(test::black_box(&raw_data), &mut buf).unwrap();
         test::black_box(out);
     });
     b.bytes = RAW_LEN as u64;
diff --git a/cms/Cargo.toml b/cms/Cargo.toml
@@ -16,7 +16,7 @@ rust-version = "1.85"
 
 [dependencies]
 const-oid = { version = "0.10", features = ["db"] }
-der = { version = "0.8.0-rc.7", features = ["alloc", "derive", "oid"] }
+der = { version = "0.8.0-rc.7", features = ["ber", "derive", "oid"] }
 spki = "0.8.0-rc.4"
 x509-cert = { version = "0.3.0-rc.0", default-features = false }
 
diff --git a/der/Cargo.toml b/der/Cargo.toml
@@ -42,6 +42,7 @@ derive = ["dep:der_derive"]
 oid = ["dep:const-oid"]
 pem = ["dep:pem-rfc7468", "alloc", "zeroize"]
 real = []
+ber = ["alloc"]
 clarify = ["dep:tynm", "std", "pem", "derive", "oid"]
 
 [package.metadata.docs.rs]
diff --git a/der/src/asn1/any.rs b/der/src/asn1/any.rs
@@ -8,9 +8,6 @@ use crate::{
 };
 use core::cmp::Ordering;
 
-#[cfg(feature = "alloc")]
-use crate::SliceWriter;
-
 /// ASN.1 `ANY`: represents any explicitly tagged ASN.1 value.
 ///
 /// This is a zero-copy reference type which borrows from the input data.
@@ -180,7 +177,7 @@ pub use self::allocating::Any;
 #[cfg(feature = "alloc")]
 mod allocating {
     use super::*;
-    use crate::{BytesOwned, reader::read_value, referenced::*};
+    use crate::{BytesOwned, encode::encode_value_to_slice, reader::read_value, referenced::*};
     use alloc::boxed::Box;
 
     /// ASN.1 `ANY`: represents any explicitly tagged ASN.1 value.
@@ -243,9 +240,7 @@ mod allocating {
         {
             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()?;
+            encode_value_to_slice(&mut buf, msg)?;
             Any::new(msg.tag(), buf)
         }
 
diff --git a/der/src/asn1/integer.rs b/der/src/asn1/integer.rs
@@ -5,7 +5,7 @@ pub(super) mod uint;
 
 use core::{cmp::Ordering, mem::size_of};
 
-use crate::{EncodeValue, Result, SliceWriter};
+use crate::{EncodeValue, Result, encode::encode_value_to_slice};
 
 /// Is the highest bit of the first byte in the slice set to `1`? (if present)
 #[inline]
@@ -25,14 +25,12 @@ where
     debug_assert!(size_of::<T>() <= MAX_INT_SIZE);
 
     let mut buf1 = [0u8; MAX_INT_SIZE];
-    let mut encoder1 = SliceWriter::new(&mut buf1);
-    a.encode_value(&mut encoder1)?;
-
     let mut buf2 = [0u8; MAX_INT_SIZE];
-    let mut encoder2 = SliceWriter::new(&mut buf2);
-    b.encode_value(&mut encoder2)?;
 
-    Ok(encoder1.finish()?.cmp(encoder2.finish()?))
+    let buf1 = encode_value_to_slice(&mut buf1, &a)?;
+    let buf2 = encode_value_to_slice(&mut buf2, &b)?;
+
+    Ok(buf1.cmp(buf2))
 }
 
 #[cfg(test)]
diff --git a/der/src/asn1/integer/int.rs b/der/src/asn1/integer/int.rs
@@ -311,9 +311,7 @@ mod allocating {
 
                     fn try_from(value: $int) -> $crate::Result<Self> {
                         let mut buf  = [0u8; 16];
-                        let mut writer = $crate::SliceWriter::new(&mut buf[..]);
-                        value.encode_value(&mut writer)?;
-                        let buf = writer.finish()?;
+                        let buf = $crate::encode::encode_value_to_slice(&mut buf, &value)?;
                         Int::new(buf)
                     }
                 }
diff --git a/der/src/asn1/integer/uint.rs b/der/src/asn1/integer/uint.rs
@@ -284,9 +284,7 @@ mod allocating {
 
                     fn try_from(value: $uint) -> $crate::Result<Self> {
                         let mut buf  = [0u8; 17];
-                        let mut writer = $crate::SliceWriter::new(&mut buf[..]);
-                        value.encode_value(&mut writer)?;
-                        let buf = writer.finish()?;
+                        let buf = $crate::encode::encode_value_to_slice(&mut buf, &value)?;
                         Uint::new(buf)
                     }
                 }
diff --git a/der/src/asn1/octet_string.rs b/der/src/asn1/octet_string.rs
@@ -374,7 +374,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "alloc")]
+    #[cfg(feature = "ber")]
     fn decode_ber() {
         use crate::{Decode, asn1::OctetString};
         use hex_literal::hex;
@@ -391,7 +391,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "alloc")]
+    #[cfg(feature = "ber")]
     fn decode_context_specific_ber_explicit() {
         use crate::{
             EncodingRules, SliceReader, TagNumber,
@@ -422,7 +422,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "alloc")]
+    #[cfg(feature = "ber")]
     fn decode_context_specific_ber_implicit() {
         use crate::{
             EncodingRules, SliceReader, TagNumber,
diff --git a/der/src/bytes.rs b/der/src/bytes.rs
@@ -117,10 +117,13 @@ impl<'a> arbitrary::Arbitrary<'a> for &'a BytesRef {
 #[cfg(feature = "alloc")]
 pub(crate) mod allocating {
     use super::BytesRef;
+    #[cfg(feature = "ber")]
+    use crate::{EncodingRules, length::indefinite::read_constructed_vec};
+
     use crate::{
-        DecodeValue, DerOrd, EncodeValue, EncodingRules, Error, Header, Length, Reader, Result,
-        Tag, Writer, length::indefinite::read_constructed_vec,
+        DecodeValue, DerOrd, EncodeValue, Error, Header, Length, Reader, Result, Tag, Writer,
     };
+
     use alloc::{borrow::ToOwned, boxed::Box, vec::Vec};
     use core::{borrow::Borrow, cmp::Ordering, ops::Deref};
 
@@ -152,13 +155,17 @@ pub(crate) mod allocating {
             inner_tag: Tag,
         ) -> Result<Self> {
             // Reassemble indefinite length string types
+            #[cfg(feature = "ber")]
             if reader.encoding_rules() == EncodingRules::Ber
                 && header.length.is_indefinite()
                 && !inner_tag.is_constructed()
             {
                 return Self::new(read_constructed_vec(reader, header.length, inner_tag)?);
             }
 
+            #[cfg(not(feature = "ber"))]
+            let _ = inner_tag;
+
             Self::decode_value(reader, header)
         }
     }
diff --git a/der/src/decode.rs b/der/src/decode.rs
@@ -1,6 +1,7 @@
 //! Trait definition for [`Decode`].
 
-use crate::{EncodingRules, Error, FixedTag, Header, Reader, SliceReader, reader::read_value};
+use crate::{Error, FixedTag, Header, Reader, SliceReader, reader::read_value};
+
 use core::marker::PhantomData;
 
 #[cfg(feature = "pem")]
@@ -12,6 +13,9 @@ use crate::{ErrorKind, Length, Tag};
 #[cfg(feature = "alloc")]
 use alloc::boxed::Box;
 
+#[cfg(feature = "ber")]
+use crate::EncodingRules;
+
 /// Decoding trait.
 ///
 /// This trait provides the core abstraction upon which all decoding operations
@@ -30,6 +34,7 @@ pub trait Decode<'a>: Sized + 'a {
     ///
     /// Note that most usages should probably use [`Decode::from_der`]. This method allows some
     /// BER productions which are not allowed under DER.
+    #[cfg(feature = "ber")]
     fn from_ber(bytes: &'a [u8]) -> Result<Self, Self::Error> {
         let mut reader = SliceReader::new_with_encoding_rules(bytes, EncodingRules::Ber)?;
         let result = Self::decode(&mut reader)?;
diff --git a/der/src/encode.rs b/der/src/encode.rs
@@ -183,3 +183,13 @@ where
         T::encode_value(self, writer)
     }
 }
+
+/// Encodes value only (without tag + length) to a slice.
+pub(crate) fn encode_value_to_slice<'a, T>(buf: &'a mut [u8], value: &T) -> Result<&'a [u8]>
+where
+    T: EncodeValue,
+{
+    let mut encoder = SliceWriter::new(buf);
+    value.encode_value(&mut encoder)?;
+    encoder.finish()
+}
diff --git a/der/src/encoding_rules.rs b/der/src/encoding_rules.rs
@@ -13,6 +13,7 @@ use core::{fmt, str::FromStr};
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
 pub enum EncodingRules {
     /// Basic Encoding Rules.
+    #[cfg(feature = "ber")]
     Ber,
 
     /// Distinguished Encoding Rules.
@@ -25,6 +26,7 @@ impl FromStr for EncodingRules {
 
     fn from_str(s: &str) -> Result<Self, Error> {
         match s {
+            #[cfg(feature = "ber")]
             "ber" | "BER" => Ok(EncodingRules::Ber),
             "der" | "DER" => Ok(EncodingRules::Der),
             _ => Err(ErrorKind::EncodingRules.into()),
@@ -35,6 +37,7 @@ impl FromStr for EncodingRules {
 impl fmt::Display for EncodingRules {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match self {
+            #[cfg(feature = "ber")]
             Self::Ber => "BER",
             Self::Der => "DER",
         })
@@ -50,13 +53,16 @@ mod tests {
     #[test]
     fn display() {
         use alloc::string::ToString;
+        #[cfg(feature = "ber")]
         assert_eq!(EncodingRules::Ber.to_string(), "BER");
         assert_eq!(EncodingRules::Der.to_string(), "DER");
     }
 
     #[test]
     fn parse() {
+        #[cfg(feature = "ber")]
         assert_eq!(EncodingRules::Ber, "ber".parse().unwrap());
+        #[cfg(feature = "ber")]
         assert_eq!(EncodingRules::Ber, "BER".parse().unwrap());
         assert_eq!(EncodingRules::Der, "der".parse().unwrap());
         assert_eq!(EncodingRules::Der, "DER".parse().unwrap());
diff --git a/der/src/header.rs b/der/src/header.rs
@@ -1,8 +1,9 @@
 //! ASN.1 DER headers.
 
-use crate::{
-    Decode, DerOrd, Encode, EncodingRules, Error, ErrorKind, Length, Reader, Result, Tag, Writer,
-};
+#[cfg(feature = "ber")]
+use crate::EncodingRules;
+use crate::{Decode, DerOrd, Encode, Error, ErrorKind, Length, Reader, Result, Tag, Writer};
+
 use core::cmp::Ordering;
 
 /// ASN.1 DER headers: tag + length component of TLV-encoded values
@@ -46,11 +47,15 @@ impl<'a> Decode<'a> for Header {
             }
         })?;
 
+        #[cfg(feature = "ber")]
         if length.is_indefinite() && !is_constructed {
             debug_assert_eq!(reader.encoding_rules(), EncodingRules::Ber);
             return Err(reader.error(ErrorKind::IndefiniteLength));
         }
 
+        #[cfg(not(feature = "ber"))]
+        debug_assert_eq!(is_constructed, tag.is_constructed());
+
         Ok(Self { tag, length })
     }
 }
diff --git a/der/src/length.rs b/der/src/length.rs
diff --git a/der/src/length/indefinite.rs b/der/src/length/indefinite.rs
diff --git a/der/src/reader.rs b/der/src/reader.rs
diff --git a/der/src/tag.rs b/der/src/tag.rs
diff --git a/spki/benches/mod.rs b/spki/benches/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -311,9 +311,7 @@ mod allocating {`
`311`	`311`
`312`	`312`	`fn try_from(value: $int) -> $crate::Result<Self> {`
`313`	`313`	`let mut buf = [0u8; 16];`
`314`		`- let mut writer = $crate::SliceWriter::new(&mut buf[..]);`
`315`		`- value.encode_value(&mut writer)?;`
`316`		`- let buf = writer.finish()?;`
	`314`	`+ let buf = $crate::encode::encode_value_to_slice(&mut buf, &value)?;`
`317`	`315`	`Int::new(buf)`
`318`	`316`	`}`
`319`	`317`	`}`
Original file line number	Diff line number	Diff line change
`@@ -284,9 +284,7 @@ mod allocating {`
`284`	`284`
`285`	`285`	`fn try_from(value: $uint) -> $crate::Result<Self> {`
`286`	`286`	`let mut buf = [0u8; 17];`
`287`		`- let mut writer = $crate::SliceWriter::new(&mut buf[..]);`
`288`		`- value.encode_value(&mut writer)?;`
`289`		`- let buf = writer.finish()?;`
	`287`	`+ let buf = $crate::encode::encode_value_to_slice(&mut buf, &value)?;`
`290`	`288`	`Uint::new(buf)`
`291`	`289`	`}`
`292`	`290`	`}`