der: clarify: add OneAsymmetricKey example

Author: dishmaker

der/src/writer/clarify.rs

@@ -263,9 +263,18 @@ impl Clarifier {
     }
 
     /// Writes hex bytes to debug output, for example "30 04 "
-    pub fn write_clarify_hex(&mut self, slice: &[u8]) {
+    pub fn write_clarify_hex(&mut self, bytes: &[u8]) {
         let indent = self.indent_str();
-        write!(&mut self.clarify_buf, "{}", HexDisplayLines(&slice, indent)).ok();
+        write!(
+            &mut self.clarify_buf,
+            "{}",
+            HexDisplayLines {
+                bytes,
+                indent,
+                space: self.comment_writer.needs_newline_space()
+            }
+        )
+        .ok();
     }
 
     /// Writes string to debug output, for example a comment "// SEQUENCE"
@@ -418,9 +427,9 @@ impl<'a> Writer for ClarifySliceWriter<'a> {
 fn strip_transparent_types(mut type_name: &str) -> Cow<'_, str> {
     let prefixes = [
         "EncodeValueRef<",
-        "ApplicationRef<",
-        "ContextSpecificRef<",
-        "PrivateRef<",
+        // "ApplicationRef<",
+        // "ContextSpecificRef<",
+        // "PrivateRef<",
     ];
 
     for prefix in prefixes {

der/src/writer/clarify/commentwriter.rs

@@ -6,6 +6,10 @@ pub trait CommentWriter {
     fn before_new_line(&mut self, w: &mut dyn Write);
 
     fn start_new_line(&mut self, _w: &mut dyn Write) {}
+
+    fn needs_newline_space(&self) -> bool {
+        false
+    }
 }
 
 #[derive(Default)]
@@ -72,8 +76,14 @@ impl CommentWriter for RustHexWriter {
         self.buf.clear();
         self.started_newline = false;
     }
+
     fn start_new_line(&mut self, w: &mut dyn Write) {
         self.started_newline = true;
         w.write_all(b"\"").ok();
     }
+
+    fn needs_newline_space(&self) -> bool {
+        // because '"' is in first line, next lines need to be moved by 1 character
+        true
+    }
 }

der/src/writer/clarify/hexdisplaylines.rs

@@ -1,14 +1,22 @@
+use core::fmt::Write;
 use std::fmt;
 
-/// (bytes, indent)
-pub struct HexDisplayLines<'a, 'i>(pub &'a [u8], pub &'i str);
+/// (bytes, indent, nl_ident)
+pub struct HexDisplayLines<'a, 'i> {
+    pub bytes: &'a [u8],
+    pub indent: &'i str,
+    pub space: bool,
+}
 
 impl fmt::Display for HexDisplayLines<'_, '_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut first = true;
-        for chunk in self.0.chunks(16) {
+        for chunk in self.bytes.chunks(16) {
             if !first {
-                write!(f, "\n{}", self.1)?;
+                write!(f, "\n{}", self.indent)?;
+                if self.space {
+                    f.write_char(' ').ok();
+                }
             } else {
                 first = false;
             }

der/tests/clarify.rs

@@ -2,11 +2,11 @@
 #![cfg(all(feature = "derive", feature = "alloc", feature = "clarify"))]
 
 pub mod sequence {
-    use std::println;
+    use std::{println, str::FromStr};
 
     use const_oid::ObjectIdentifier;
     use der::{
-        AnyRef, ClarifyFlavor, Decode, EncodeClarifyExt, Sequence, ValueOrd,
+        AnyRef, ClarifyFlavor, Decode, EncodeClarifyExt, Sequence, TagNumber, ValueOrd,
         asn1::{OctetString, SetOf},
     };
     use hex_literal::hex;
@@ -84,4 +84,68 @@ pub mod sequence {
             "\n\"04 11\" // tag: OCTET STRING len: 17 type: OctetString \n\t\"00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n\t01\"\n\"\" // end: OctetString "
         );
     }
+    #[test]
+    fn clarify_one_assymetric_key_rusthex() {
+        let obj = OneAsymmetricKey {
+            version: 1,
+            private_key_algorithm: AlgorithmIdentifier {
+                algorithm: ObjectIdentifier::from_str("1.2.3.4.5.6.7.8").expect("valid oid"),
+                parameters: Some(
+                    AnyRef::new(
+                        der::Tag::ContextSpecific {
+                            constructed: true,
+                            number: TagNumber(0),
+                        },
+                        &[0xAA, 0xBB],
+                    )
+                    .expect("valid length"),
+                ),
+            },
+            private_key: &[
+                0x00, 0x11, 0x22, 0x33, 0x00, 0x11, 0x22, 0x33, 0x00, 0x11, 0x22, 0x33, 0x00, 0x11,
+                0x22, 0x33, 0x00, 0x11, 0x22, 0x33, 0x00, 0x11, 0x22, 0x33, 0x00, 0x11, 0x22, 0x33,
+            ],
+            attributes: None,
+            public_key: Some(&[
+                0x44, 0x55, 0x66, 0x77, 0x44, 0x55, 0x66, 0x77, 0x44, 0x55, 0x66, 0x77, 0x44, 0x55,
+                0x66, 0x77, 0x44, 0x55, 0x66, 0x77, 0x44, 0x55, 0x66, 0x77, 0x44, 0x55, 0x66, 0x77,
+            ]),
+        };
+        let clarified = obj
+            .to_der_clarify(ClarifyFlavor::RustHex)
+            .expect("encoded DER");
+
+        //println!("clarified: {clarified}");
+
+        assert!(clarified.contains("type: OneAsymmetricKey"));
+        assert!(clarified.contains("tag: CONTEXT-SPECIFIC [0] (constructed)"));
+        assert!(clarified.contains("tag: CONTEXT-SPECIFIC [1] (constructed)"));
+        assert!(clarified.contains("type: AlgorithmIdentifier"));
+        assert!(clarified.contains("tag: OBJECT IDENTIFIER"));
+        assert!(clarified.contains("type: ObjectIdentifier"));
+        assert!(clarified.contains("end: OneAsymmetricKey"));
+
+        hex!(
+            "30 51" // tag: SEQUENCE len: 81 type: OneAsymmetricKey
+                "02 01" // tag: INTEGER type: u8
+                        "01"
+                "30 0D" // tag: SEQUENCE len: 13 type: AlgorithmIdentifier
+                        "06 07" // tag: OBJECT IDENTIFIER type: ObjectIdentifier
+                                "2A 03 04 05 06 07 08"
+                        "A0 02" // tag: CONTEXT-SPECIFIC [0] (constructed) type: AnyRef
+                                "AA BB"
+                "04 1C" // tag: OCTET STRING len: 28 type: OctetStringRef
+                        "00 11 22 33 00 11 22 33 00 11 22 33 00 11 22 33
+                         00 11 22 33 00 11 22 33 00 11 22 33"
+                "" // end: OctetStringRef
+                "A1 1F" // tag: CONTEXT-SPECIFIC [1] (constructed) len: 31 type: ContextSpecificRef<BitStringRef>
+                        "03 1D" // tag: BIT STRING len: 29 type: BitStringRef
+                                "00"
+                                "44 55 66 77 44 55 66 77 44 55 66 77 44 55 66 77
+                                 44 55 66 77 44 55 66 77 44 55 66 77"
+                        "" // end: BitStringRef
+                "" // end: ContextSpecificRef<BitStringRef>
+            "" // end: OneAsymmetricKey
+        );
+    }
 }