优化数据对象decode + profile validate；benchmark对比routinator geomean 0.8

src/data_model/aspa.rs

@@ -1,10 +1,9 @@
 use crate::data_model::oid::OID_CT_ASPA;
+use crate::data_model::common::{DerReader, der_take_tlv};
 use crate::data_model::rc::ResourceCertificate;
 use crate::data_model::signed_object::{
     RpkiSignedObject, RpkiSignedObjectParsed, SignedObjectParseError, SignedObjectValidateError,
 };
-use der_parser::ber::Class;
-use der_parser::der::{DerObject, Tag, parse_der};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct AspaObject {
@@ -203,7 +202,7 @@ impl AspaObject {
 impl AspaEContent {
     /// Parse step of scheme A (`parse → validate → verify`).
     pub fn parse_der(der: &[u8]) -> Result<AspaEContentParsed, AspaParseError> {
-        let (rem, _obj) = parse_der(der).map_err(|e| AspaParseError::Parse(e.to_string()))?;
+        let (_tag, _value, rem) = der_take_tlv(der).map_err(AspaParseError::Parse)?;
         if !rem.is_empty() {
             return Err(AspaParseError::TrailingBytes(rem.len()));
         }
@@ -292,47 +291,66 @@ impl AspaObjectParsed {
 
 impl AspaEContentParsed {
     pub fn validate_profile(self) -> Result<AspaEContent, AspaProfileError> {
-        let (_rem, obj) =
-            parse_der(&self.der).map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
+        fn count_elements(mut r: DerReader<'_>) -> Result<usize, String> {
+            let mut n = 0usize;
+            while !r.is_empty() {
+                r.skip_any()?;
+                n += 1;
+            }
+            Ok(n)
+        }
 
-        let seq = obj
-            .as_sequence()
-            .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
-        if seq.len() != 3 {
+        let mut r = DerReader::new(&self.der);
+        let mut seq = r
+            .take_sequence()
+            .map_err(|e| AspaProfileError::ProfileDecode(e))?;
+        if !r.is_empty() {
+            return Err(AspaProfileError::ProfileDecode(
+                "trailing bytes after ASProviderAttestation".into(),
+            ));
+        }
+
+        let elem_count =
+            count_elements(seq).map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
+        if elem_count != 3 {
             return Err(AspaProfileError::InvalidAttestationSequence);
         }
 
         // version [0] EXPLICIT INTEGER MUST be present and MUST be 1.
-        let v_obj = &seq[0];
-        if v_obj.class() != Class::ContextSpecific || v_obj.tag() != Tag(0) {
+        if seq
+            .peek_tag()
+            .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?
+            != 0xA0
+        {
             return Err(AspaProfileError::VersionMustBeExplicitOne);
         }
-        let inner_der = v_obj
-            .as_slice()
+        let (inner_tag, inner_val) = seq
+            .take_explicit(0xA0)
             .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
-        let (rem, inner) =
-            parse_der(inner_der).map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
-        if !rem.is_empty() {
-            return Err(AspaProfileError::ProfileDecode(
-                "trailing bytes inside ASProviderAttestation.version".into(),
-            ));
+        if inner_tag != 0x02 {
+            return Err(AspaProfileError::VersionMustBeExplicitOne);
         }
-        let v = inner
-            .as_u64()
+        let v = crate::data_model::common::der_uint_from_bytes(inner_val)
             .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
         if v != 1 {
             return Err(AspaProfileError::VersionMustBeExplicitOne);
         }
 
-        let customer_u64 = seq[1]
-            .as_u64()
+        let customer_u64 = seq
+            .take_uint_u64()
             .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
         if customer_u64 > u32::MAX as u64 {
             return Err(AspaProfileError::CustomerAsIdOutOfRange(customer_u64));
         }
         let customer_as_id = customer_u64 as u32;
 
-        let providers = parse_providers(&seq[2], customer_as_id)?;
+        let providers_seq = seq
+            .take_sequence()
+            .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
+        if !seq.is_empty() {
+            return Err(AspaProfileError::InvalidAttestationSequence);
+        }
+        let providers = parse_providers_cursor(providers_seq, customer_as_id)?;
 
         Ok(AspaEContent {
             version: 1,
@@ -342,19 +360,19 @@ impl AspaEContentParsed {
     }
 }
 
-fn parse_providers(obj: &DerObject<'_>, customer_as_id: u32) -> Result<Vec<u32>, AspaProfileError> {
-    let seq = obj
-        .as_sequence()
-        .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
+fn parse_providers_cursor(
+    mut seq: DerReader<'_>,
+    customer_as_id: u32,
+) -> Result<Vec<u32>, AspaProfileError> {
     if seq.is_empty() {
         return Err(AspaProfileError::EmptyProviders);
     }
 
-    let mut out: Vec<u32> = Vec::with_capacity(seq.len());
+    let mut out: Vec<u32> = Vec::new();
     let mut prev: Option<u32> = None;
-    for item in seq {
-        let v = item
-            .as_u64()
+    while !seq.is_empty() {
+        let v = seq
+            .take_uint_u64()
             .map_err(|e| AspaProfileError::ProfileDecode(e.to_string()))?;
         if v > u32::MAX as u64 {
             return Err(AspaProfileError::ProviderAsIdOutOfRange(v));