feat: add tests asn1-der-test

__crypto/asn1-der-test/src/bin/test1.rs

@@ -0,0 +1,86 @@
+use std::str::FromStr;
+
+use asn1_rs::{
+    BitString, Class, Error, Explicit, Integer,
+    OctetString, Oid, Sequence, TaggedValue, ToDer,
+};
+use base64::{Engine, engine::GeneralPurpose};
+
+const BASE64: GeneralPurpose = base64::engine::general_purpose::STANDARD;
+
+// -----BEGIN PRIVATE KEY-----
+// MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDB0n4af3g3zaB67WD+/
+// Xe+FNOkwvuoDd/YUPh0y5ZfoBlkqG1WGNkZN2/d4EYqrNrahZANiAAR2vgKLjiAd
+// I6l4EAyxGKwGBJ6pAdYZvNlBi8X9kKlCj6aYi5kSKqUfAMaQAX9+0WPoQ6Cy/gzi
+// bPPmlPRMa4SdTKgZvvw5nuyNXZQU/wN69Opz/hCqxZHKYx5zSznj4/g=
+// -----END PRIVATE KEY-----
+//   0 182: SEQUENCE {
+//   3   1:   INTEGER 0
+//   6  16:   SEQUENCE {
+//   8   7:     OBJECT IDENTIFIER ecPublicKey (1 2 840 10045 2 1)
+//  17   5:     OBJECT IDENTIFIER secp384r1 (1 3 132 0 34)
+//        :     }
+//  24 158:   OCTET STRING, encapsulates {
+//  27 155:     SEQUENCE {
+//  30   1:       INTEGER 1
+//  33  48:       OCTET STRING
+//        :         74 9F 86 9F DE 0D F3 68 1E BB 58 3F BF 5D EF 85
+//        :         34 E9 30 BE EA 03 77 F6 14 3E 1D 32 E5 97 E8 06
+//        :         59 2A 1B 55 86 36 46 4D DB F7 78 11 8A AB 36 B6
+//  83 100:       [1] {
+//  85  98:         BIT STRING
+//        :           04 76 BE 02 8B 8E 20 1D 23 A9 78 10 0C B1 18 AC
+//        :           06 04 9E A9 01 D6 19 BC D9 41 8B C5 FD 90 A9 42
+//        :           8F A6 98 8B 99 12 2A A5 1F 00 C6 90 01 7F 7E D1
+//        :           63 E8 43 A0 B2 FE 0C E2 6C F3 E6 94 F4 4C 6B 84
+//        :           9D 4C A8 19 BE FC 39 9E EC 8D 5D 94 14 FF 03 7A
+//        :           F4 EA 73 FE 10 AA C5 91 CA 63 1E 73 4B 39 E3 E3
+//        :           F8
+//        :         }
+//        :       }
+//        :     }
+//        :   }
+fn main() {
+    let ec_public_key = Oid::from_str("1.2.840.10045.2.1").unwrap();
+    let secp_384_r1 = Oid::from_str("1.3.132.0.34").unwrap();
+    let mut v = Vec::new();
+    ec_public_key.write_der(&mut v).unwrap();
+    secp_384_r1.write_der(&mut v).unwrap();
+    let seq = Sequence::new(v.into());
+
+    let hex1 = hex::decode("749F869FDE0DF3681EBB583FBF5DEF8534E930BEEA0377F6143E1D32E597E806592A1B558636464DDBF778118AAB36B6").unwrap();
+    let hex2 = hex::decode("0476BE028B8E201D23A978100CB118AC06049EA901D619BCD9418BC5FD90A9428FA6988B99122AA51F00C690017F7ED163E843A0B2FE0CE26CF3E694F44C6B849D4CA819BEFC399EEC8D5D9414FF037AF4EA73FE10AAC591CA631E734B39E3E3F8").unwrap();
+    let seq3 = {
+        let i1 = Integer::from_i8(1);
+        let oct = OctetString::new(&hex1);
+
+        let bit = BitString::new(0, &hex2);
+        // let mut vb = Vec::new();
+        // bit.write_der(&mut vb).unwrap();
+        // let set = Set::new(vb.into());
+
+        let mut vv = Vec::new();
+        i1.write_der(&mut vv).unwrap();
+        oct.write_der(&mut vv).unwrap();
+
+        type TaggedValueContextSpecific<'a> = TaggedValue<BitString<'a>, Error, Explicit, { Class::CONTEXT_SPECIFIC }, 1>;
+        let tag = TaggedValueContextSpecific::explicit(bit);
+        tag.write_der(&mut vv).unwrap();
+
+        Sequence::new(vv.into())
+    };
+    let btss = seq3.to_der_vec().unwrap();
+    let bts = OctetString::new(&btss);
+
+    let mut vp = Vec::new();
+    let i0 = Integer::from_i8(0);
+    i0.write_der(&mut vp).unwrap();
+    seq.write_der(&mut vp).unwrap();
+    bts.write_der(&mut vp).unwrap();
+
+    let seqlast = Sequence::new(vp.into());
+
+
+    println!("BASED64:\n{}", BASE64.encode(seqlast.to_der_vec().unwrap()));
+    println!("HEX:\n{}", hex::encode(seqlast.to_der_vec().unwrap()));
+}

__crypto/asn1-der-test/src/bin/test2.rs

@@ -0,0 +1,52 @@
+use asn1_rs::{BitString, Class, Error, Explicit, Integer, OctetString, Oid, ParseResult, Sequence, TaggedValue};
+use asn1_rs::FromDer;
+use base64::Engine;
+use base64::engine::GeneralPurpose;
+
+const BASE64: GeneralPurpose = base64::engine::general_purpose::STANDARD;
+
+fn main() {
+    let private_key = "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgakRmuDPA8pr1kqmY\
+    PxjoMJSJzMeWllw0qbKWzrbEfzehRANCAAQs2XCluo7NF7Y0tL6Pp2GWz2fw5llF\
+    dRvIpq0j8kVQjNOIYZqlBG6OOMQql3U95HsJJY0YzkoXEcdcJmoIV0zn";
+
+    let private_key_der = BASE64.decode(private_key).unwrap();
+
+    let r: ParseResult<()> = Sequence::from_der_and_then(&private_key_der, |i| {
+        let (i, i0) = Integer::from_der(i)?;
+        println!("INTEGER0: {}", i0.as_i8().unwrap());
+        let r: ParseResult<()> = Sequence::from_der_and_then(i, |i| {
+            let (i, oid1) = Oid::from_der(i)?;
+            let (i, oid2) = Oid::from_der(i)?;
+
+            println!("OID1: {}", oid1);
+            println!("OID2: {}", oid2);
+            Ok((i, ()))
+        });
+
+        let (i, _) = r.unwrap();
+
+        let (i, octet) = OctetString::from_der(i).unwrap();
+        let octet = octet.as_ref();
+
+        let r: ParseResult<()> = Sequence::from_der_and_then(octet, |i| {
+            let (i, i1) = Integer::from_der(i).unwrap();
+            println!("INTEGER1: {}", i1.as_i8().unwrap());
+            let (i, oct) = OctetString::from_der(i)?;
+            println!("PRIVATE KEY: {}", hex::encode(oct.as_ref()));
+
+            type TaggedValueContextSpecific<'a> = TaggedValue<BitString<'a>, Error, Explicit, { Class::CONTEXT_SPECIFIC }, 1>;
+            let tagged_value = TaggedValueContextSpecific::from_der(i);
+            let _ = tagged_value.map(|(_i, tagged_value)| {
+                println!("Tagged value [{}]", tagged_value.tag().0);
+                let tagged_value_inner = tagged_value.into_inner();
+                println!("Tagged value: {}, unused: {}", hex::encode(tagged_value_inner.as_ref()), tagged_value_inner.unused_bits);
+            });
+
+            Ok((i, ()))
+        });
+        r.unwrap();
+        Ok((i, ()))
+    });
+    r.unwrap();
+}