Added OctetStringEncoded to allow representing structures like OCSPResponse or X.509 Extensions that encode a TLV inside of an OCTET STRING (#339)

Author: alex

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asn1"
-version = "0.12.2"
+version = "0.12.3"
 authors = ["Alex Gaynor <[email protected]>"]
 repository = "https://github.com/alex/rust-asn1"
 keywords = ["asn1"]
@@ -17,7 +17,7 @@ derive = ["asn1_derive"]
 
 [dependencies]
 chrono = { version = "0.4.20", default-features = false, features = ["alloc"] }
-asn1_derive = { path = "asn1_derive/", version = "0.12.2", optional = true }
+asn1_derive = { path = "asn1_derive/", version = "0.12.3", optional = true }
 
 [dev-dependencies]
 libc = "0.2.11"

asn1_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asn1_derive"
-version = "0.12.2"
+version = "0.12.3"
 authors = ["Alex Gaynor <[email protected]>"]
 repository = "https://github.com/alex/rust-asn1"
 license = "BSD-3-Clause"

src/lib.rs

@@ -123,9 +123,9 @@ pub use crate::parser::{
 pub use crate::tag::Tag;
 pub use crate::types::{
     Asn1Readable, Asn1Writable, BMPString, BigInt, BigUint, Choice1, Choice2, Choice3, Enumerated,
-    GeneralizedTime, IA5String, Null, PrintableString, Sequence, SequenceOf, SequenceOfWriter,
-    SequenceWriter, SetOf, SetOfWriter, SimpleAsn1Readable, SimpleAsn1Writable, Tlv,
-    UniversalString, UtcTime, Utf8String, VisibleString,
+    GeneralizedTime, IA5String, Null, OctetStringEncoded, PrintableString, Sequence, SequenceOf,
+    SequenceOfWriter, SequenceWriter, SetOf, SetOfWriter, SimpleAsn1Readable, SimpleAsn1Writable,
+    Tlv, UniversalString, UtcTime, Utf8String, VisibleString,
 };
 #[cfg(feature = "const-generics")]
 pub use crate::types::{Explicit, Implicit};

src/parser.rs

@@ -344,9 +344,9 @@ mod tests {
     use crate::types::Asn1Readable;
     use crate::{
         BMPString, BigInt, BigUint, BitString, Choice1, Choice2, Choice3, Enumerated,
-        GeneralizedTime, IA5String, ObjectIdentifier, OwnedBitString, ParseError, ParseErrorKind,
-        ParseLocation, ParseResult, PrintableString, Sequence, SequenceOf, SetOf, Tag, Tlv,
-        UniversalString, UtcTime, Utf8String, VisibleString,
+        GeneralizedTime, IA5String, ObjectIdentifier, OctetStringEncoded, OwnedBitString,
+        ParseError, ParseErrorKind, ParseLocation, ParseResult, PrintableString, Sequence,
+        SequenceOf, SetOf, Tag, Tlv, UniversalString, UtcTime, Utf8String, VisibleString,
     };
     #[cfg(feature = "const-generics")]
     use crate::{Explicit, Implicit};
@@ -674,6 +674,26 @@ mod tests {
         ]);
     }
 
+    #[test]
+    fn test_octet_string_encoded() {
+        assert_parses::<OctetStringEncoded<bool>>(&[
+            (Ok(OctetStringEncoded::new(true)), b"\x04\x03\x01\x01\xff"),
+            (Ok(OctetStringEncoded::new(false)), b"\x04\x03\x01\x01\x00"),
+            (
+                Err(ParseError::new(ParseErrorKind::UnexpectedTag {
+                    actual: Tag::primitive(0x03),
+                })),
+                b"\x03\x00",
+            ),
+            (
+                Err(ParseError::new(ParseErrorKind::UnexpectedTag {
+                    actual: Tag::primitive(0x02),
+                })),
+                b"\x04\x02\x02\x00",
+            ),
+        ])
+    }
+
     #[test]
     fn test_parse_int_i64() {
         assert_parses::<i64>(&[

src/types.rs

@@ -179,6 +179,39 @@ impl<'a> SimpleAsn1Writable for &'a [u8] {
     }
 }
 
+/// Represents values that are encoded as an `OCTET STRING` containing an
+/// encoded TLV, of type `T`.
+#[derive(PartialEq, Debug)]
+pub struct OctetStringEncoded<T>(T);
+
+impl<T> OctetStringEncoded<T> {
+    pub fn new(v: T) -> OctetStringEncoded<T> {
+        OctetStringEncoded(v)
+    }
+
+    pub fn get(&self) -> &T {
+        &self.0
+    }
+
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+impl<'a, T: Asn1Readable<'a>> SimpleAsn1Readable<'a> for OctetStringEncoded<T> {
+    const TAG: Tag = Tag::primitive(0x04);
+    fn parse_data(data: &'a [u8]) -> ParseResult<Self> {
+        Ok(OctetStringEncoded::new(parse_single(data)?))
+    }
+}
+
+impl<T: Asn1Writable> SimpleAsn1Writable for OctetStringEncoded<T> {
+    const TAG: Tag = Tag::primitive(0x04);
+    fn write_data(&self, dest: &mut WriteBuf) -> WriteResult {
+        self.0.write(&mut Writer::new(dest))
+    }
+}
+
 /// Type for use with `Parser.read_element` and `Writer.write_element` for
 /// handling ASN.1 `PrintableString`.  A `PrintableString` contains an `&str`
 /// with only valid characers.
@@ -1463,9 +1496,9 @@ impl<'a, T: Asn1Writable, const TAG: u32> SimpleAsn1Writable for Explicit<'a, T,
 #[cfg(test)]
 mod tests {
     use crate::{
-        parse_single, BigInt, BigUint, Enumerated, GeneralizedTime, IA5String, ParseError,
-        ParseErrorKind, PrintableString, SequenceOf, SequenceOfWriter, SetOf, SetOfWriter, Tag,
-        Tlv, UtcTime, Utf8String, VisibleString,
+        parse_single, BigInt, BigUint, Enumerated, GeneralizedTime, IA5String, OctetStringEncoded,
+        ParseError, ParseErrorKind, PrintableString, SequenceOf, SequenceOfWriter, SetOf,
+        SetOfWriter, Tag, Tlv, UtcTime, Utf8String, VisibleString,
     };
     #[cfg(feature = "const-generics")]
     use crate::{Explicit, Implicit};
@@ -1477,6 +1510,12 @@ mod tests {
     #[cfg(feature = "std")]
     use std::collections::hash_map::DefaultHasher;
 
+    #[test]
+    fn test_octet_string_encoded() {
+        assert_eq!(OctetStringEncoded::new(12).get(), &12);
+        assert_eq!(OctetStringEncoded::new(12).into_inner(), 12);
+    }
+
     #[test]
     fn test_printable_string_new() {
         assert!(PrintableString::new("abc").is_some());

src/writer.rs

@@ -208,9 +208,9 @@ mod tests {
     use crate::types::Asn1Writable;
     use crate::{
         parse_single, BMPString, BigInt, BigUint, BitString, Choice1, Choice2, Choice3, Enumerated,
-        GeneralizedTime, IA5String, ObjectIdentifier, OwnedBitString, PrintableString, Sequence,
-        SequenceOf, SequenceOfWriter, SequenceWriter, SetOf, SetOfWriter, Tlv, UniversalString,
-        UtcTime, Utf8String, VisibleString, WriteError,
+        GeneralizedTime, IA5String, ObjectIdentifier, OctetStringEncoded, OwnedBitString,
+        PrintableString, Sequence, SequenceOf, SequenceOfWriter, SequenceWriter, SetOf,
+        SetOfWriter, Tlv, UniversalString, UtcTime, Utf8String, VisibleString, WriteError,
     };
     #[cfg(feature = "const-generics")]
     use crate::{Explicit, Implicit};
@@ -266,6 +266,14 @@ mod tests {
         ]);
     }
 
+    #[test]
+    fn test_write_octet_string_encoded() {
+        assert_writes::<OctetStringEncoded<bool>>(&[
+            (OctetStringEncoded::new(true), b"\x04\x03\x01\x01\xff"),
+            (OctetStringEncoded::new(false), b"\x04\x03\x01\x01\x00"),
+        ]);
+    }
+
     #[test]
     fn test_write_printable_string() {
         assert_writes::<PrintableString>(&[