Adding upstream version 1:7.0.3.upstream/1%7.0.3

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 228 insertions, 0 deletions

diff --git a/rust/vendor/der-parser-6.0.1/tests/primitive.rs b/rust/vendor/der-parser-6.0.1/tests/primitive.rs
new file mode 100644
index 0000000..4c07b0a
--- /dev/null
+++ b/rust/vendor/der-parser-6.0.1/tests/primitive.rs
@@ -0,0 +1,228 @@
+extern crate alloc;
+use der_parser::ber::*;
+use der_parser::der::*;
+use der_parser::error::*;
+use der_parser::oid::Oid;
+use hex_literal::hex;
+use nom::*;
+
+#[test]
+fn test_flat_take() {
+    let empty = &b""[..];
+    assert_eq!(
+        parse_ber_bool(&[0x01, 0x01, 0xff]),
+        Ok((empty, BerObject::from_obj(BerObjectContent::Boolean(true))))
+    );
+    assert_eq!(
+        parse_ber_bool(&[0x01, 0x01, 0x00]),
+        Ok((empty, BerObject::from_obj(BerObjectContent::Boolean(false))))
+    );
+    assert_eq!(
+        ber_read_element_content_as(&[0xff], BerTag::Boolean, 0x01.into(), false, MAX_RECURSION),
+        Ok((empty, BerObjectContent::Boolean(true)))
+    );
+    assert_eq!(
+        ber_read_element_content_as(&[0x00], BerTag::Boolean, 0x01.into(), false, MAX_RECURSION),
+        Ok((empty, BerObjectContent::Boolean(false)))
+    );
+}
+
+#[test]
+fn test_oid() {
+    let empty = &b""[..];
+    assert_eq!(
+        parse_der(&[0x06, 0x06, 42, 129, 122, 1, 16, 9]),
+        Ok((
+            empty,
+            BerObject::from_obj(BerObjectContent::OID(
+                Oid::from(&[1, 2, 250, 1, 16, 9]).unwrap()
+            ))
+        ))
+    );
+    // Dubuisson 433
+    assert_eq!(
+        parse_der(&[0x0d, 0x05, 129, 122, 1, 16, 9]),
+        Ok((
+            empty,
+            BerObject::from_obj(BerObjectContent::RelativeOID(
+                Oid::from_relative(&[250, 1, 16, 9]).unwrap()
+            ))
+        ))
+    );
+}
+
+#[test]
+fn test_rel_oid() {
+    let empty = &b""[..];
+    assert_eq!(
+        parse_der(&[0x0d, 0x04, 0xc2, 0x7b, 0x03, 0x02]),
+        Ok((
+            empty,
+            BerObject::from_obj(BerObjectContent::RelativeOID(
+                Oid::from_relative(&[8571, 3, 2]).unwrap()
+            ))
+        ))
+    );
+}
+
+#[rustfmt::skip::macros(oid)]
+#[test]
+fn test_oid_iter_length_check() {
+    use der_parser::oid;
+    use std::borrow::Cow;
+    // empty
+    assert!(Oid::new(Cow::Borrowed(&[])).iter().is_some());
+    assert!(Oid::new_relative(Cow::Borrowed(&[])).iter().is_some());
+    // ok
+    assert!(oid!(0).iter().is_some());
+    assert!(oid!(1.2).iter().is_some());
+    assert!(oid!(1.2.3456.23.54).iter().is_some());
+    // too long
+    assert!(oid!(1.2.18445618199572250625).iter().is_none());
+    assert!(oid!(rel 18445618199572250625).iter().is_none());
+}
+
+#[test]
+fn test_unknown_tag() {
+    let bytes = hex!("1d 01 00");
+    let res = parse_ber(&bytes).expect("parsing failed");
+    assert!(res.0.is_empty());
+    assert_eq!(
+        res.1,
+        BerObject::from_obj(BerObjectContent::Unknown(
+            BerClass::Universal,
+            BerTag(0x1d),
+            &bytes[2..]
+        ))
+    );
+    let res = parse_der(&bytes).expect("parsing failed");
+    assert!(res.0.is_empty());
+    assert_eq!(
+        res.1,
+        BerObject::from_obj(BerObjectContent::Unknown(
+            BerClass::Universal,
+            BerTag(0x1d),
+            &bytes[2..]
+        ))
+    );
+}
+
+#[test]
+fn test_unknown_context_specific() {
+    let bytes = hex!("80 01 00");
+    let res = parse_ber(&bytes).expect("parsing failed");
+    assert!(res.0.is_empty());
+    assert_eq!(
+        res.1,
+        BerObject {
+            header: BerObjectHeader::new(BerClass::ContextSpecific, 0, BerTag(0), 1)
+                .with_raw_tag(Some(&[0x80])),
+            content: BerObjectContent::Unknown(BerClass::ContextSpecific, BerTag(0x0), &bytes[2..]),
+        }
+    );
+}
+
+#[test]
+fn test_unknown_long_tag() {
+    let bytes = hex!("9f 22 01 00");
+    let res = parse_ber(&bytes).expect("parsing failed");
+    assert!(res.0.is_empty());
+    assert_eq!(
+        res.1,
+        BerObject {
+            header: BerObjectHeader::new(BerClass::ContextSpecific, 0, BerTag(0x22), 1)
+                .with_raw_tag(Some(&[0x9f, 0x22])),
+            content: BerObjectContent::Unknown(
+                BerClass::ContextSpecific,
+                BerTag(0x22),
+                &bytes[3..]
+            ),
+        }
+    );
+}
+
+#[test]
+fn test_unknown_longer_tag() {
+    let bytes = hex!("9f a2 22 01 00");
+    let res = parse_ber(&bytes).expect("parsing failed");
+    assert!(res.0.is_empty());
+    assert_eq!(
+        res.1,
+        BerObject {
+            header: BerObjectHeader::new(BerClass::ContextSpecific, 0, BerTag(0x1122), 1)
+                .with_raw_tag(Some(&[0x9f, 0xa2, 0x22])),
+            content: BerObjectContent::Unknown(
+                BerClass::ContextSpecific,
+                BerTag(0x1122),
+                &bytes[4..]
+            ),
+        }
+    );
+}
+
+#[test]
+fn test_incomplete_tag() {
+    let bytes = hex!("9f a2 a2");
+    let res = parse_ber(&bytes);
+    assert!(res.is_err());
+}
+
+#[test]
+fn test_overflow_tag() {
+    let bytes = hex!("9f a2 a2 a2 a2 a2 22 01 00");
+    let res = parse_ber(&bytes);
+    assert!(res.is_err());
+}
+
+#[test]
+fn test_incomplete_length() {
+    let bytes = hex!("30");
+    let res = parse_ber(&bytes).err().expect("expected error");
+    assert_eq!(res, Err::Incomplete(Needed::new(1)));
+    let res = parse_der(&bytes).err().expect("expected error");
+    assert_eq!(res, Err::Incomplete(Needed::new(1)));
+    let bytes = hex!("02");
+    let res = parse_ber(&bytes).err().expect("expected error");
+    assert_eq!(res, Err::Incomplete(Needed::new(1)));
+    let bytes = hex!("02 05");
+    let _ = parse_ber(&bytes).err().expect("expected error");
+    let bytes = hex!("02 85");
+    let res = parse_ber(&bytes).err().expect("expected error");
+    assert_eq!(res, Err::Incomplete(Needed::new(5)));
+    let bytes = hex!("02 85 ff");
+    let res = parse_ber(&bytes).err().expect("expected error");
+    assert_eq!(res, Err::Incomplete(Needed::new(4)));
+}
+
+#[test]
+fn test_invalid_length() {
+    let bytes = hex!("02 ff 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10");
+    let _ = parse_ber(&bytes).err().expect("expected error");
+    let _ = ber_read_element_header(&bytes)
+        .err()
+        .expect("expected error");
+    let bytes = hex!("02 85 ff ff ff ff ff 00");
+    let res = parse_ber(&bytes).expect_err("parsing should have returned error");
+    // get error
+    match res {
+        Err::Error(e) => {
+            assert_eq!(e, BerError::InvalidLength);
+        }
+        _ => panic!("not the expected nom error kind {:?}", res),
+    }
+    let bytes = hex!("02 02 00");
+    let res = parse_der(&bytes).err().expect("expected error");
+    assert_eq!(res, Err::Incomplete(Needed::new(2)));
+}
+
+#[test]
+fn test_pretty_print() {
+    let bytes = hex!("01 01 ff");
+    let obj = parse_der(&bytes).map(|(_, b)| b).expect("expected error");
+    println!("{:?}", obj.as_pretty(0, 2));
+
+    // controlling the pretty-printer
+    let mut pp = obj.as_pretty(0, 4);
+    pp.set_flag(PrettyPrinterFlag::ShowHeader);
+    println!("{:?}", pp);
+}