550 lines
19 KiB
Rust
550 lines
19 KiB
Rust
|
#![cfg(feature = "std")]
|
||
|
|
|
||
|
|
use asn1_rs::*;
|
||
|
|
use hex_literal::hex;
|
||
|
|
// use nom::HexDisplay;
|
||
|
|
use std::collections::BTreeSet;
|
||
|
|
use std::convert::{TryFrom, TryInto};
|
||
|
|
use std::iter::FromIterator;
|
||
|
|
|
||
|
|
macro_rules! test_simple_string {
|
||
|
|
($t:ty, $s:expr) => {
|
||
|
|
let t = <$t>::from($s);
|
||
|
|
let v = t.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(v[0] as u32, t.tag().0);
|
||
|
|
assert_eq!(v[1] as usize, t.as_ref().len());
|
||
|
|
assert_eq!(&v[2..], $s.as_bytes());
|
||
|
|
let (_, t2) = <$t>::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(t.eq(&t2));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
macro_rules! test_string_invalid_charset {
|
||
|
|
($t:ty, $s:expr) => {
|
||
|
|
<$t>::test_valid_charset($s.as_bytes()).expect_err("should reject charset");
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_length() {
|
||
|
|
// indefinite length
|
||
|
|
let length = Length::Indefinite;
|
||
|
|
let v = length.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x80]);
|
||
|
|
// definite, short form
|
||
|
|
let length = Length::Definite(3);
|
||
|
|
let v = length.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x03]);
|
||
|
|
// definite, long form
|
||
|
|
let length = Length::Definite(250);
|
||
|
|
let v = length.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x81, 0xfa]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_length_long() {
|
||
|
|
let s = core::str::from_utf8(&[0x41; 256]).unwrap();
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v[..4], &[0x0c, 0x82, 0x01, 0x00]);
|
||
|
|
assert_eq!(&v[4..], s.as_bytes());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_tag() {
|
||
|
|
// short tag, UNIVERSAL
|
||
|
|
let v = (Class::Universal, false, Tag(0x1a))
|
||
|
|
.to_der_vec()
|
||
|
|
.expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x1a]);
|
||
|
|
// short tag, APPLICATION
|
||
|
|
let v = (Class::Application, false, Tag(0x1a))
|
||
|
|
.to_der_vec()
|
||
|
|
.expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x1a | (0b01 << 6)]);
|
||
|
|
// short tag, constructed
|
||
|
|
let v = (Class::Universal, true, Tag(0x10))
|
||
|
|
.to_der_vec()
|
||
|
|
.expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x30]);
|
||
|
|
// long tag, UNIVERSAL
|
||
|
|
let v = (Class::Universal, false, Tag(0x1a1a))
|
||
|
|
.to_der_vec()
|
||
|
|
.expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0b1_1111, 0xb4, 0x1a]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_header() {
|
||
|
|
// simple header
|
||
|
|
let header = Header::new_simple(Tag::Integer);
|
||
|
|
let v = header.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x2, 0x0]);
|
||
|
|
// indefinite length
|
||
|
|
let header = Header::new(Class::Universal, false, Tag::Integer, Length::Indefinite);
|
||
|
|
let v = header.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x2, 0x80]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_any() {
|
||
|
|
let header = Header::new_simple(Tag::Integer);
|
||
|
|
let any = Any::new(header, &hex!("02"));
|
||
|
|
assert_eq!(any.to_der_len(), Ok(3));
|
||
|
|
let v = any.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x02, 0x01, 0x02]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_any_raw() {
|
||
|
|
let header = Header::new(Class::Universal, false, Tag::Integer, Length::Definite(3));
|
||
|
|
let any = Any::new(header, &hex!("02"));
|
||
|
|
// to_vec should compute the length
|
||
|
|
let v = any.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x02, 0x01, 0x02]);
|
||
|
|
// to_vec_raw will use the header as provided
|
||
|
|
let v = any.to_der_vec_raw().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x02, 0x03, 0x02]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_bitstring() {
|
||
|
|
let bitstring = BitString::new(6, &hex!("6e 5d c0"));
|
||
|
|
let v = bitstring.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("03 04 06 6e 5d c0"));
|
||
|
|
let (_, result) = BitString::from_der(&v).expect("parsing failed");
|
||
|
|
assert!(bitstring.eq(&result));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_bmpstring() {
|
||
|
|
let bmpstring = BmpString::new("User");
|
||
|
|
assert_eq!(bmpstring.to_der_len(), Ok(10));
|
||
|
|
let v = bmpstring.to_der_vec().expect("serialization failed");
|
||
|
|
let expected = &hex!("1e 08 00 55 00 73 00 65 00 72");
|
||
|
|
assert_eq!(&v, expected);
|
||
|
|
assert!(BmpString::test_valid_charset(&v[2..]).is_ok());
|
||
|
|
let (_, result) = BmpString::from_der(&v).expect("parsing failed");
|
||
|
|
assert!(bmpstring.eq(&result));
|
||
|
|
// for coverage
|
||
|
|
let b1 = BmpString::from("s");
|
||
|
|
let s = b1.string();
|
||
|
|
let b2 = BmpString::from(s);
|
||
|
|
assert_eq!(b1, b2);
|
||
|
|
// long string
|
||
|
|
let sz = 256;
|
||
|
|
let s = str::repeat("a", sz);
|
||
|
|
let bmpstring = BmpString::new(&s);
|
||
|
|
assert_eq!(bmpstring.to_der_len(), Ok(4 + 2 * s.len()));
|
||
|
|
let _v = bmpstring.to_der_vec().expect("serialization failed");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_bool() {
|
||
|
|
let v = Boolean::new(0xff)
|
||
|
|
.to_der_vec()
|
||
|
|
.expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x01, 0x01, 0xff]);
|
||
|
|
//
|
||
|
|
let v = false.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x01, 0x01, 0x00]);
|
||
|
|
//
|
||
|
|
let v = true.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x01, 0x01, 0xff]);
|
||
|
|
// raw value (not 0 of 0xff)
|
||
|
|
let v = Boolean::new(0x8a)
|
||
|
|
.to_der_vec_raw()
|
||
|
|
.expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x01, 0x01, 0x8a]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_enumerated() {
|
||
|
|
let v = Enumerated(2).to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(Enumerated(2).to_der_len(), Ok(3));
|
||
|
|
assert_eq!(&v, &[0x0a, 0x01, 0x02]);
|
||
|
|
//
|
||
|
|
let (_, result) = Enumerated::from_der(&v).expect("parsing failed");
|
||
|
|
assert_eq!(result, Enumerated(2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_generalizedtime() {
|
||
|
|
// date without millisecond
|
||
|
|
let dt = ASN1DateTime::new(1999, 12, 31, 23, 59, 59, None, ASN1TimeZone::Z);
|
||
|
|
let time = GeneralizedTime::new(dt);
|
||
|
|
let v = time.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v[..2], &hex!("18 0f"));
|
||
|
|
assert_eq!(&v[2..], b"19991231235959Z");
|
||
|
|
let (_, time2) = GeneralizedTime::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(time.eq(&time2));
|
||
|
|
assert_eq!(time.to_der_len(), Ok(0x11));
|
||
|
|
//
|
||
|
|
// date with millisecond
|
||
|
|
let dt = ASN1DateTime::new(1999, 12, 31, 23, 59, 59, Some(123), ASN1TimeZone::Z);
|
||
|
|
let time = GeneralizedTime::new(dt);
|
||
|
|
let v = time.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v[..2], &hex!("18 13"));
|
||
|
|
assert_eq!(&v[2..], b"19991231235959.123Z");
|
||
|
|
let (_, time2) = GeneralizedTime::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(time.eq(&time2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_graphicstring() {
|
||
|
|
test_simple_string!(GraphicString, "123456");
|
||
|
|
test_string_invalid_charset!(GraphicString, "é23456");
|
||
|
|
}
|
||
|
|
|
||
|
|
fn encode_decode_assert_int<T>(t: T, expected: &[u8])
|
||
|
|
where
|
||
|
|
T: ToDer + std::fmt::Debug + Eq,
|
||
|
|
for<'a> T: TryFrom<Integer<'a>, Error = Error>,
|
||
|
|
{
|
||
|
|
let v = t.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, expected);
|
||
|
|
let (_, obj) = Integer::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
let t2: T = obj.try_into().unwrap();
|
||
|
|
assert_eq!(t, t2);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_integer() {
|
||
|
|
let int = Integer::new(&hex!("02"));
|
||
|
|
let v = int.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x02, 0x01, 0x02]);
|
||
|
|
// from_u32
|
||
|
|
let int = Integer::from_u32(2);
|
||
|
|
let v = int.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &[0x02, 0x01, 0x02]);
|
||
|
|
// impl ToDer for primitive types
|
||
|
|
encode_decode_assert_int(2u32, &[0x02, 0x01, 0x02]);
|
||
|
|
// signed i32 (> 0)
|
||
|
|
encode_decode_assert_int(4, &[0x02, 0x01, 0x04]);
|
||
|
|
// signed i32 (< 0)
|
||
|
|
encode_decode_assert_int(-4, &[0x02, 0x01, 0xfc]);
|
||
|
|
// negative number
|
||
|
|
encode_decode_assert_int(-1i8, &[0x02, 0x01, 0xff]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_null() {
|
||
|
|
let bytes: &[u8] = &hex!("05 00");
|
||
|
|
let s = Null::new();
|
||
|
|
assert_eq!(s.to_der_len(), Ok(2));
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, bytes);
|
||
|
|
// unit
|
||
|
|
assert_eq!(().to_der_len(), Ok(2));
|
||
|
|
let (_, s2) = <()>::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(().eq(&s2));
|
||
|
|
let v2 = ().to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v2, bytes);
|
||
|
|
// invalid null encodings
|
||
|
|
let bytes: &[u8] = &hex!("05 01 00");
|
||
|
|
let _ = Null::from_ber(bytes).expect_err("should fail");
|
||
|
|
let _ = <()>::from_ber(bytes).expect_err("should fail");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_numericstring() {
|
||
|
|
test_simple_string!(NumericString, "123456");
|
||
|
|
test_string_invalid_charset!(NumericString, "abcdef");
|
||
|
|
test_string_invalid_charset!(NumericString, "1a");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_objectdescriptor() {
|
||
|
|
test_simple_string!(ObjectDescriptor, "abcdef");
|
||
|
|
test_string_invalid_charset!(ObjectDescriptor, "abcdéf");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_octetstring() {
|
||
|
|
let bytes: &[u8] = &hex!("01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f");
|
||
|
|
let s = OctetString::from(bytes);
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(s.to_der_len(), Ok(bytes.len() + 2));
|
||
|
|
assert_eq!(&v[..2], &hex!("04 0f"));
|
||
|
|
assert_eq!(&v[2..], bytes);
|
||
|
|
let (_, s2) = OctetString::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(s.eq(&s2));
|
||
|
|
//
|
||
|
|
let v = bytes.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(bytes.to_der_len(), Ok(bytes.len() + 2));
|
||
|
|
assert_eq!(&v[..2], &hex!("04 0f"));
|
||
|
|
assert_eq!(&v[2..], bytes);
|
||
|
|
let (_, s2) = OctetString::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(s.eq(&s2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_real_binary() {
|
||
|
|
// base = 2, value = 4
|
||
|
|
let r = Real::binary(2.0, 2, 1);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("09 03 80 02 01"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!((r.f64() - result.f64()).abs() < f64::EPSILON);
|
||
|
|
//
|
||
|
|
// base = 2, value = 0.5
|
||
|
|
let r = Real::binary(0.5, 2, 0);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("09 03 80 ff 01"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!((r.f64() - result.f64()).abs() < f64::EPSILON);
|
||
|
|
//
|
||
|
|
// base = 2, value = 3.25, but change encoding base (8)
|
||
|
|
let r = Real::binary(3.25, 2, 0).with_enc_base(8);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
// note: this encoding has a scale factor (not DER compliant)
|
||
|
|
assert_eq!(&v, &hex!("09 03 94 ff 0d"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!((r.f64() - result.f64()).abs() < f64::EPSILON);
|
||
|
|
//
|
||
|
|
// base = 2, value = 0.00390625, but change encoding base (16)
|
||
|
|
let r = Real::binary(0.00390625, 2, 0).with_enc_base(16);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
// note: this encoding has a scale factor (not DER compliant)
|
||
|
|
assert_eq!(&v, &hex!("09 03 a0 fe 01"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!((r.f64() - result.f64()).abs() < f64::EPSILON);
|
||
|
|
//
|
||
|
|
// 2 octets for exponent, negative exponent and abs(exponent) is all 1's and fills the whole octet(s)
|
||
|
|
let r = Real::binary(3.0, 2, -1020);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("09 04 81 fc 04 03"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!((r.f64() - result.f64()).abs() < f64::EPSILON);
|
||
|
|
//
|
||
|
|
// 3 octets for exponent, and
|
||
|
|
// check that first 9 bits for exponent are not all 1's
|
||
|
|
let r = Real::binary(1.0, 2, 262140);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("09 05 82 03 ff fc 01"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
// XXX value cannot be represented as f64 (inf)
|
||
|
|
assert!(result.f64().is_infinite());
|
||
|
|
//
|
||
|
|
// >3 octets for exponent, and
|
||
|
|
// mantissa < 0
|
||
|
|
let r = Real::binary(-1.0, 2, 76354972);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert_eq!(&v, &hex!("09 07 c3 04 04 8d 15 9c 01"));
|
||
|
|
// XXX value cannot be represented as f64 (-inf)
|
||
|
|
assert!(result.f64().is_infinite());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_real_special() {
|
||
|
|
// ZERO
|
||
|
|
let r = Real::Zero;
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("09 00"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!(r.eq(&result));
|
||
|
|
// INFINITY
|
||
|
|
let r = Real::Infinity;
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("09 01 40"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!(r.eq(&result));
|
||
|
|
// MINUS INFINITY
|
||
|
|
let r = Real::NegInfinity;
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("09 01 41"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!(r.eq(&result));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_real_string() {
|
||
|
|
// non-zero value, base 10
|
||
|
|
let r = Real::new(1.2345);
|
||
|
|
let v = r.to_der_vec().expect("serialization failed");
|
||
|
|
// assert_eq!(&v, &hex!("09 00"));
|
||
|
|
let (_, result) = Real::from_der(&v).expect("parsing failed");
|
||
|
|
assert!(r.eq(&result));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_sequence() {
|
||
|
|
let it = [2, 3, 4].iter();
|
||
|
|
let seq = Sequence::from_iter_to_der(it).unwrap();
|
||
|
|
let v = seq.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("30 09 02 01 02 02 01 03 02 01 04"));
|
||
|
|
let (_, seq2) = Sequence::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert_eq!(seq, seq2);
|
||
|
|
// Vec<T>::ToDer
|
||
|
|
let v = vec![2, 3, 4].to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("30 09 02 01 02 02 01 03 02 01 04"));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_sequenceof() {
|
||
|
|
let seq = SequenceOf::from_iter([2, 3, 4]);
|
||
|
|
let v = seq.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("30 09 02 01 02 02 01 03 02 01 04"));
|
||
|
|
let (_, seq2) = SequenceOf::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert_eq!(seq, seq2);
|
||
|
|
// Vec<T>::ToDer
|
||
|
|
let v = vec![2, 3, 4].to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("30 09 02 01 02 02 01 03 02 01 04"));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_set() {
|
||
|
|
let it = [2u8, 3, 4].iter();
|
||
|
|
let set = Set::from_iter_to_der(it).unwrap();
|
||
|
|
let v = set.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("31 09 02 01 02 02 01 03 02 01 04"));
|
||
|
|
// let (_, set2) = Set::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
// assert_eq!(set, set2);
|
||
|
|
// BTreeSet<T>::ToDer
|
||
|
|
let set2 = BTreeSet::from_iter(vec![2, 3, 4]);
|
||
|
|
let v = set2.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("31 09 02 01 02 02 01 03 02 01 04"));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_set_of() {
|
||
|
|
let seq = SetOf::from_iter([2, 3, 4]);
|
||
|
|
let v = seq.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("31 09 02 01 02 02 01 03 02 01 04"));
|
||
|
|
let (_, seq2) = SetOf::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert_eq!(seq, seq2);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_str() {
|
||
|
|
let s = "abcdef";
|
||
|
|
assert_eq!(s.to_der_len(), Ok(2 + s.len()));
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v[..2], &hex!("0c 06"));
|
||
|
|
assert_eq!(&v[2..], b"abcdef");
|
||
|
|
let (_, s2) = Utf8String::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(s.eq(s2.as_ref()));
|
||
|
|
// long string
|
||
|
|
let sz = 256;
|
||
|
|
let s = str::repeat("a", sz);
|
||
|
|
let s = s.as_str();
|
||
|
|
assert_eq!(s.to_der_len(), Ok(4 + sz));
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(v.len(), 4 + sz);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_string() {
|
||
|
|
let s = "abcdef".to_string();
|
||
|
|
assert_eq!(s.to_der_len(), Ok(2 + s.len()));
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v[..2], &hex!("0c 06"));
|
||
|
|
assert_eq!(&v[2..], b"abcdef");
|
||
|
|
let (_, s2) = Utf8String::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(s.eq(s2.as_ref()));
|
||
|
|
// long string
|
||
|
|
let sz = 256;
|
||
|
|
let s = str::repeat("a", sz);
|
||
|
|
assert_eq!(s.to_der_len(), Ok(4 + sz));
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(v.len(), 4 + sz);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_tagged_explicit() {
|
||
|
|
let tagged = TaggedParser::new_explicit(Class::ContextSpecific, 1, 2u32);
|
||
|
|
let v = tagged.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("a1 03 02 01 02"));
|
||
|
|
let (_, t2) =
|
||
|
|
TaggedParser::<Explicit, u32>::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(tagged.eq(&t2));
|
||
|
|
// TaggedValue API
|
||
|
|
let tagged = TaggedValue::explicit(2u32);
|
||
|
|
let v = tagged.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("a1 03 02 01 02"));
|
||
|
|
let (_, t2) =
|
||
|
|
TaggedExplicit::<u32, Error, 1>::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(tagged.eq(&t2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_tagged_implicit() {
|
||
|
|
let tagged = TaggedParser::new_implicit(Class::ContextSpecific, false, 1, 2u32);
|
||
|
|
let v = tagged.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("81 01 02"));
|
||
|
|
let (_, t2) =
|
||
|
|
TaggedParser::<Implicit, u32>::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(tagged.eq(&t2));
|
||
|
|
// TaggedValue API
|
||
|
|
let tagged = TaggedValue::implicit(2u32);
|
||
|
|
let v = tagged.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("81 01 02"));
|
||
|
|
let (_, t2) =
|
||
|
|
TaggedImplicit::<u32, Error, 1>::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(tagged.eq(&t2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_tagged_implicit_optional() {
|
||
|
|
// TaggedValue API
|
||
|
|
let tagged = Some(TaggedValue::implicit(Integer::from(2)));
|
||
|
|
let v = tagged.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v, &hex!("81 01 02"));
|
||
|
|
let (_, t2) = OptTaggedImplicit::<Integer, Error, 1>::from_der(&v)
|
||
|
|
.expect("decoding serialized object failed");
|
||
|
|
assert!(tagged.eq(&t2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_teletexstring() {
|
||
|
|
test_simple_string!(TeletexString, "abcdef");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_utctime() {
|
||
|
|
let dt = ASN1DateTime::new(99, 12, 31, 23, 59, 59, None, ASN1TimeZone::Z);
|
||
|
|
let time = UtcTime::new(dt);
|
||
|
|
let v = time.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(&v[..2], &hex!("17 0d"));
|
||
|
|
assert_eq!(&v[2..], b"991231235959Z");
|
||
|
|
let (_, time2) = UtcTime::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(time.eq(&time2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_universalstring() {
|
||
|
|
const S: &str = "abcdef";
|
||
|
|
let s = UniversalString::from(S);
|
||
|
|
assert_eq!(s.to_der_len(), Ok(2 + 4 * S.len()));
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(
|
||
|
|
&v,
|
||
|
|
&hex!("1c 18 00000061 00000062 00000063 00000064 00000065 00000066")
|
||
|
|
);
|
||
|
|
let (_, s2) = UniversalString::from_der(&v).expect("decoding serialized object failed");
|
||
|
|
assert!(s.eq(&s2));
|
||
|
|
// long string
|
||
|
|
let sz = 256;
|
||
|
|
let s = str::repeat("a", sz);
|
||
|
|
let s = UniversalString::from(s);
|
||
|
|
assert_eq!(s.to_der_len(), Ok(4 + 4 * sz));
|
||
|
|
let v = s.to_der_vec().expect("serialization failed");
|
||
|
|
assert_eq!(v.len(), 4 + 4 * sz);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_utf8string() {
|
||
|
|
test_simple_string!(Utf8String, "abcdef");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_visiblestring() {
|
||
|
|
test_simple_string!(VisibleString, "abcdef");
|
||
|
|
test_string_invalid_charset!(VisibleString, "abcdéf");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn to_der_videotexstring() {
|
||
|
|
test_simple_string!(VideotexString, "abcdef");
|
||
|
|
}
|