test(rust/c509-certificate): Fix test for draft11

rust/c509-certificate/examples/cli/main.rs

@@ -8,7 +8,7 @@ use std::{
 
 use asn1_rs::{oid, Oid};
 use c509_certificate::{
-    attributes::Attributes,
+    attributes::attribute::Attribute,
     big_uint::UnwrappedBigUint,
     extensions::Extensions,
     issuer_sig_algo::IssuerSignatureAlgorithm,
@@ -108,15 +108,15 @@ struct C509Json {
     issuer_signature_algorithm: Option<IssuerSignatureAlgorithm>,
     /// Optional issuer of the certificate,
     /// if not provided, issuer is the same as subject.
-    issuer: Option<Attributes>,
+    issuer: Option<Vec<Attribute>>,
     /// Optional validity not before date,
     /// if not provided, set to current time.
     validity_not_before: Option<String>,
     /// Optional validity not after date,
     /// if not provided, set to no expire date 9999-12-31T23:59:59+00:00.
     validity_not_after: Option<String>,
     /// Attributes of the subject.
-    subject: Attributes,
+    subject: Vec<Attribute>,
     /// Optional subject public key algorithm of the certificate,
     /// if not provided, set to Ed25519.
     subject_public_key_algorithm: Option<SubjectPubKeyAlgorithm>,
@@ -184,10 +184,10 @@ fn generate(
         c509_json
             .issuer_signature_algorithm
             .unwrap_or(IssuerSignatureAlgorithm::new(key_type.0.clone(), ED25519.1)),
-        Some(Name::new(NameValue::Attributes(issuer))),
+        Some(Name::new(NameValue::Attribute(issuer))),
         Time::new(not_before),
         Time::new(not_after),
-        Name::new(NameValue::Attributes(c509_json.subject)),
+        Name::new(NameValue::Attribute(c509_json.subject)),
         c509_json
             .subject_public_key_algorithm
             .unwrap_or(SubjectPubKeyAlgorithm::new(key_type.0, key_type.1)),
@@ -219,8 +219,8 @@ fn write_to_output_file(output: PathBuf, data: &[u8]) -> anyhow::Result<()> {
 /// If self-signed is true, issuer is the same as subject.
 /// Otherwise, issuer must be present.
 fn determine_issuer(
-    self_signed: bool, issuer: Option<Attributes>, subject: Attributes,
-) -> anyhow::Result<Attributes> {
+    self_signed: bool, issuer: Option<Vec<Attribute>>, subject: Vec<Attribute>,
+) -> anyhow::Result<Vec<Attribute>> {
     if self_signed {
         Ok(subject)
     } else {
@@ -330,9 +330,9 @@ fn decode(file: &PathBuf, output: Option<PathBuf>) -> anyhow::Result<()> {
 }
 
 /// Extract a `Attributes` from a `Name`.
-fn extract_attributes(name: &Name) -> anyhow::Result<Attributes> {
+fn extract_attributes(name: &Name) -> anyhow::Result<Vec<Attribute>> {
     match name.value() {
-        NameValue::Attributes(attrs) => Ok(attrs.clone()),
+        NameValue::Attribute(attrs) => Ok(attrs.clone()),
         _ => Err(anyhow::anyhow!("Expected Attributes")),
     }
 }

rust/c509-certificate/src/attributes/attribute.rs

@@ -239,7 +239,8 @@ mod test_attribute {
         attribute
             .encode(&mut encoder, &mut ())
             .expect("Failed to encode Attribute");
-        // Email Address example@example.com: 0x00736578616d706c65406578616d706c652e636f6d
+        // 1.2.840 .113549 .1 .9 .1 in attribute int = 0x00
+        // Email Address example@example.com: 0x736578616d706c65406578616d706c652e636f6d
         assert_eq!(
             hex::encode(buffer.clone()),
             "00736578616d706c65406578616d706c652e636f6d"

rust/c509-certificate/src/attributes/mod.rs

@@ -111,7 +111,7 @@ mod test_attributes {
             .encode(&mut encoder, &mut ())
             .expect("Failed to encode Attributes");
         // 1 Attribute (array len 2 (attribute type + value)): 0x82
-        // Email Address: 0x00
+        // Email Address attribute int: 0x00
         // Attribute value (array len 2): 0x82
         // example@example.com: 0x736578616d706c65406578616d706c652e636f6d
         assert_eq!(

rust/c509-certificate/src/big_uint.rs

@@ -77,6 +77,7 @@ mod test_big_uint {
         b_uint
             .encode(&mut encoder, &mut ())
             .expect("Failed to encode UnwrappedBigUint");
+        // 128269 (h'01F50D'): CBOR 0x4301f50d
         assert_eq!(hex::encode(buffer.clone()), "4301f50d");
 
         let mut decoder = minicbor::Decoder::new(&buffer);
@@ -97,6 +98,7 @@ mod test_big_uint {
         b_uint
             .encode(&mut encoder, &mut ())
             .expect("Failed to encode UnwrappedBigUint");
+        // 9112578475118446130 (h'7E7661D7B54E4632'): CBOR 0x487e7661d7b54e4632
         assert_eq!(hex::encode(buffer.clone()), "487e7661d7b54e4632");
 
         let mut decoder = minicbor::Decoder::new(&buffer);

rust/c509-certificate/src/extensions/extension/mod.rs

@@ -307,7 +307,7 @@ mod test_extension {
         let mut buffer = Vec::new();
         let mut encoder = Encoder::new(&mut buffer);
 
-        // Not PEN OID and not in the registry table
+        // Not in the registry table
         // Value should be bytes
         let ext = Extension::new(
             oid!(2.16.840 .1 .101 .3 .4 .2 .1),

rust/c509-certificate/src/general_names/mod.rs

@@ -116,6 +116,16 @@ mod test_general_names {
         gns.encode(&mut encoder, &mut ())
             .expect("Failed to encode GeneralNames");
         // Array of 4 GeneralName (type, value) so 8 items: 0x88
+        // Unsigned int 2 for DNSName: 0x02
+        // DNSName with "example.com": 0x6b6578616d706c652e636f6d
+        // OtherNameHardwareModuleName negative 1: 0x20
+        // Array of 2 items: 0x82
+        // OID 2.16.840 .1 .101 .3 .4 .2 .1: 0x49608648016503040201
+        // vec![0x01, 0x02, 0x03, 0x04]: 0x4401020304
+        // IPAddress: 0x07
+        // IPAddress Value in bytes string 192, 168, 1, 1: 0x44c0a80101
+        // RegisteredID: 0x08
+        // OID 2.16.840 .1 .101 .3 .4 .2 .1: 0x49608648016503040201
         assert_eq!(hex::encode(buffer.clone()), "88026b6578616d706c652e636f6d20824960864801650304020144010203040744c0a801010849608648016503040201");
 
         let mut decoder = Decoder::new(&buffer);

rust/c509-certificate/src/helper/decode.rs

@@ -8,7 +8,7 @@ pub(crate) fn decode_helper<'a, T, C>(
 ) -> Result<T, decode::Error>
 where T: minicbor::Decode<'a, C> {
     T::decode(d, context).map_err(|e| {
-        decode::Error::message(&format!(
+        decode::Error::message(format!(
             "Failed to decode {:?} in {from}: {e}",
             std::any::type_name::<T>()
         ))
@@ -18,7 +18,7 @@ where T: minicbor::Decode<'a, C> {
 /// Helper function for decoding bytes.
 pub(crate) fn decode_bytes(d: &mut Decoder, from: &str) -> Result<Vec<u8>, decode::Error> {
     d.bytes().map(<[u8]>::to_vec).map_err(|e| {
-        decode::Error::message(&format!(
+        decode::Error::message(format!(
             "Failed to decode bytes in {from}:
             {e}"
         ))
@@ -29,20 +29,20 @@ pub(crate) fn decode_bytes(d: &mut Decoder, from: &str) -> Result<Vec<u8>, decod
 pub(crate) fn decode_array_len(d: &mut Decoder, from: &str) -> Result<u64, decode::Error> {
     d.array()
         .map_err(|e| {
-            decode::Error::message(&format!(
+            decode::Error::message(format!(
                 "Failed to decode array in {from}:
             {e}"
             ))
         })?
-        .ok_or(decode::Error::message(&format!(
+        .ok_or(decode::Error::message(format!(
             "Failed to decode array in {from}, unexpected indefinite length",
         )))
 }
 
 /// Helper function for decoding null.
 pub(crate) fn decode_null(d: &mut Decoder, from: &str) -> Result<(), decode::Error> {
     d.null().map_err(|e| {
-        decode::Error::message(&format!(
+        decode::Error::message(format!(
             "Failed to decode null in {from}:
             {e}"
         ))
@@ -54,7 +54,7 @@ pub(crate) fn decode_datatype(
     d: &mut Decoder, from: &str,
 ) -> Result<minicbor::data::Type, decode::Error> {
     d.datatype().map_err(|e| {
-        decode::Error::message(&format!(
+        decode::Error::message(format!(
             "Failed to decode datatype in {from}:
             {e}"
         ))

rust/c509-certificate/src/helper/encode.rs

@@ -13,7 +13,7 @@ where T: minicbor::Encode<C> {
     T::encode(value, e, ctx).map_err(|err| {
         encode::Error::with_message(
             err,
-            &format!(
+            format!(
                 "Failed to encode {:?} in {from}",
                 std::any::type_name::<T>()
             ),
@@ -28,7 +28,7 @@ pub(crate) fn encode_bytes<W: Write>(
     e: &mut Encoder<W>, from: &str, value: &[u8],
 ) -> Result<(), encode::Error<W::Error>> {
     e.bytes(value).map_err(|err| {
-        encode::Error::with_message(err, &format!("Failed to encode bytes in {from}"))
+        encode::Error::with_message(err, format!("Failed to encode bytes in {from}"))
     })?;
     Ok(())
 }
@@ -38,7 +38,7 @@ pub(crate) fn encode_null<W: Write>(
     e: &mut Encoder<W>, from: &str,
 ) -> Result<(), encode::Error<W::Error>> {
     e.null().map_err(|err| {
-        encode::Error::with_message(err, &format!("Failed to encode null in {from}"))
+        encode::Error::with_message(err, format!("Failed to encode null in {from}"))
     })?;
     Ok(())
 }
@@ -48,7 +48,7 @@ pub(crate) fn encode_array_len<W: Write>(
     e: &mut Encoder<W>, from: &str, len: u64,
 ) -> Result<(), encode::Error<W::Error>> {
     e.array(len).map_err(|err| {
-        encode::Error::with_message(err, &format!("Failed to encode array in {from}"))
+        encode::Error::with_message(err, format!("Failed to encode array in {from}"))
     })?;
     Ok(())
 }

rust/c509-certificate/src/lib.rs

@@ -117,13 +117,13 @@ mod test {
     use std::str::FromStr;
 
     use signing::tests::private_key_str;
-    use tbs_cert::test_tbs_cert::tbs;
+    use tbs_cert::test_tbs_cert::tbs_1;
 
     use super::*;
 
     #[test]
     fn test_generate_and_verify_signed_c509_cert() {
-        let tbs_cert = tbs();
+        let (tbs_cert, _) = tbs_1();
 
         let private_key = FromStr::from_str(&private_key_str()).expect(
             "Cannot create