acw/simple_asn1
1
0
Fork 0
Code Issues 5 Pull Requests 2 Actions Packages Projects Releases Wiki Activity

Make this subject to rustfmt.

Browse Source
This commit is contained in:
Adam Wick
2020-06-14 16:38:23 -07:00
parent ce2bf1407c
commit 5bb01ae0e4
1 changed files with 168 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

297
src/lib.rs
View File

@@ -152,62 +152,43 @@ impl ASN1Block {
impl PartialEq for ASN1Block { impl PartialEq for ASN1Block {
fn eq(&self, other: &ASN1Block) -> bool { fn eq(&self, other: &ASN1Block) -> bool {
match (self, other) { match (self, other) {
(&ASN1Block::Boolean(_,a1), (&ASN1Block::Boolean(_, a1), &ASN1Block::Boolean(_, a2)) => (a1 == a2),
&ASN1Block::Boolean(_,a2)) => (&ASN1Block::Integer(_, ref a1), &ASN1Block::Integer(_, ref a2)) => (a1 == a2),
(a1 == a2), (&ASN1Block::BitString(_, a1, ref b1), &ASN1Block::BitString(_, a2, ref b2)) => {
(&ASN1Block::Integer(_,ref a1), (a1 == a2) && (b1 == b2)
&ASN1Block::Integer(_,ref a2)) => }
(a1 == a2), (&ASN1Block::OctetString(_, ref a1), &ASN1Block::OctetString(_, ref a2)) => (a1 == a2),
(&ASN1Block::BitString(_,a1,ref b1), (&ASN1Block::Null(_), &ASN1Block::Null(_)) => true,
&ASN1Block::BitString(_,a2,ref b2)) => (&ASN1Block::ObjectIdentifier(_, ref a1), &ASN1Block::ObjectIdentifier(_, ref a2)) => {
(a1 == a2) && (b1 == b2), (a1 == a2)
(&ASN1Block::OctetString(_,ref a1), }
&ASN1Block::OctetString(_,ref a2)) => (&ASN1Block::UTF8String(_, ref a1), &ASN1Block::UTF8String(_, ref a2)) => (a1 == a2),
(a1 == a2), (&ASN1Block::PrintableString(_, ref a1), &ASN1Block::PrintableString(_, ref a2)) => {
(&ASN1Block::Null(_), (a1 == a2)
&ASN1Block::Null(_)) => }
true, (&ASN1Block::TeletexString(_, ref a1), &ASN1Block::TeletexString(_, ref a2)) => {
(&ASN1Block::ObjectIdentifier(_,ref a1), (a1 == a2)
&ASN1Block::ObjectIdentifier(_,ref a2)) => }
(a1 == a2), (&ASN1Block::IA5String(_, ref a1), &ASN1Block::IA5String(_, ref a2)) => (a1 == a2),
(&ASN1Block::UTF8String(_,ref a1), (&ASN1Block::UTCTime(_, ref a1), &ASN1Block::UTCTime(_, ref a2)) => (a1 == a2),
&ASN1Block::UTF8String(_,ref a2)) => (&ASN1Block::GeneralizedTime(_, ref a1), &ASN1Block::GeneralizedTime(_, ref a2)) => {
(a1 == a2), (a1 == a2)
(&ASN1Block::PrintableString(_,ref a1), }
&ASN1Block::PrintableString(_,ref a2)) => (&ASN1Block::UniversalString(_, ref a1), &ASN1Block::UniversalString(_, ref a2)) => {
(a1 == a2), (a1 == a2)
(&ASN1Block::TeletexString(_,ref a1), }
&ASN1Block::TeletexString(_,ref a2)) => (&ASN1Block::BMPString(_, ref a1), &ASN1Block::BMPString(_, ref a2)) => (a1 == a2),
(a1 == a2), (&ASN1Block::Sequence(_, ref a1), &ASN1Block::Sequence(_, ref a2)) => (a1 == a2),
(&ASN1Block::IA5String(_,ref a1), (&ASN1Block::Set(_, ref a1), &ASN1Block::Set(_, ref a2)) => (a1 == a2),
&ASN1Block::IA5String(_,ref a2)) => (
(a1 == a2), &ASN1Block::Explicit(a1, _, ref b1, ref c1),
(&ASN1Block::UTCTime(_,ref a1), &ASN1Block::Explicit(a2, _, ref b2, ref c2),
&ASN1Block::UTCTime(_,ref a2)) => ) => (a1 == a2) && (b1 == b2) && (c1 == c2),
(a1 == a2), (
(&ASN1Block::GeneralizedTime(_,ref a1), &ASN1Block::Unknown(a1, b1, _, ref c1, ref d1),
&ASN1Block::GeneralizedTime(_,ref a2)) => &ASN1Block::Unknown(a2, b2, _, ref c2, ref d2),
(a1 == a2), ) => (a1 == a2) && (b1 == b2) && (c1 == c2) && (d1 == d2),
(&ASN1Block::UniversalString(_,ref a1), _ => false,
&ASN1Block::UniversalString(_,ref a2)) =>
(a1 == a2),
(&ASN1Block::BMPString(_,ref a1),
&ASN1Block::BMPString(_,ref a2)) =>
(a1 == a2),
(&ASN1Block::Sequence(_,ref a1),
&ASN1Block::Sequence(_,ref a2)) =>
(a1 == a2),
(&ASN1Block::Set(_,ref a1),
&ASN1Block::Set(_,ref a2)) =>
(a1 == a2),
(&ASN1Block::Explicit(a1,_,ref b1,ref c1),
&ASN1Block::Explicit(a2,_,ref b2,ref c2)) =>
(a1 == a2) && (b1 == b2) && (c1 == c2),
(&ASN1Block::Unknown(a1,b1,_,ref c1,ref d1),
&ASN1Block::Unknown(a2,b2,_,ref c2,ref d2)) =>
(a1 == a2) && (b1 == b2) && (c1 == c2) && (d1 == d2),
_ =>
false
} }
} }
} }
@@ -321,24 +302,27 @@ pub enum ASN1DecodeErr {
impl fmt::Display for ASN1DecodeErr { impl fmt::Display for ASN1DecodeErr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
ASN1DecodeErr::EmptyBuffer => ASN1DecodeErr::EmptyBuffer => {
write!(f, "Encountered an empty buffer decoding ASN1 block."), write!(f, "Encountered an empty buffer decoding ASN1 block.")
ASN1DecodeErr::BadBooleanLength(x) => }
write!(f, "Bad length field in boolean block: {}", x), ASN1DecodeErr::BadBooleanLength(x) => {
ASN1DecodeErr::LengthTooLarge(x) => write!(f, "Bad length field in boolean block: {}", x)
write!(f, "Length field too large for object type: {}", x), }
ASN1DecodeErr::UTF8DecodeFailure(x) => ASN1DecodeErr::LengthTooLarge(x) => {
write!(f, "UTF8 string failed to properly decode: {}", x), write!(f, "Length field too large for object type: {}", x)
ASN1DecodeErr::PrintableStringDecodeFailure => }
write!(f, "Printable string failed to properly decode."), ASN1DecodeErr::UTF8DecodeFailure(x) => {
ASN1DecodeErr::InvalidDateValue(x) => write!(f, "UTF8 string failed to properly decode: {}", x)
write!(f, "Invalid date value: {}", x), }
ASN1DecodeErr::InvalidBitStringLength(i) => ASN1DecodeErr::PrintableStringDecodeFailure => {
write!(f, "Invalid length of bit string: {}", i), write!(f, "Printable string failed to properly decode.")
ASN1DecodeErr::InvalidClass(i) => }
write!(f, "Invalid class value: {}", i), ASN1DecodeErr::InvalidDateValue(x) => write!(f, "Invalid date value: {}", x),
ASN1DecodeErr::Incomplete => ASN1DecodeErr::InvalidBitStringLength(i) => {
write!(f, "Incomplete data or invalid ASN1"), write!(f, "Invalid length of bit string: {}", i)
}
ASN1DecodeErr::InvalidClass(i) => write!(f, "Invalid class value: {}", i),
ASN1DecodeErr::Incomplete => write!(f, "Incomplete data or invalid ASN1"),
} }
} }
} }
@@ -354,12 +338,15 @@ pub enum ASN1EncodeErr {
impl fmt::Display for ASN1EncodeErr { impl fmt::Display for ASN1EncodeErr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
ASN1EncodeErr::ObjectIdentHasTooFewFields => ASN1EncodeErr::ObjectIdentHasTooFewFields => {
write!(f,"ASN1 object identifier has too few fields."), write!(f, "ASN1 object identifier has too few fields.")
ASN1EncodeErr::ObjectIdentVal1TooLarge => }
write!(f,"First value in ASN1 OID is too big."), ASN1EncodeErr::ObjectIdentVal1TooLarge => {
ASN1EncodeErr::ObjectIdentVal2TooLarge => write!(f, "First value in ASN1 OID is too big.")
write!(f,"Second value in ASN1 OID is too big."), }
ASN1EncodeErr::ObjectIdentVal2TooLarge => {
write!(f, "Second value in ASN1 OID is too big.")
}
} }
} }
} }
@@ -432,9 +419,7 @@ fn from_der_(i: &[u8], start_offset: usize) -> Result<Vec<ASN1Block>, ASN1Decode
result.push(ASN1Block::Integer(soff, res)); result.push(ASN1Block::Integer(soff, res));
} }
// BIT STRING // BIT STRING
Some(0x03) if body.len() == 0 => { Some(0x03) if body.len() == 0 => result.push(ASN1Block::BitString(soff, 0, Vec::new())),
result.push(ASN1Block::BitString(soff, 0, Vec::new()))
}
Some(0x03) => { Some(0x03) => {
let bits = (&body[1..]).to_vec(); let bits = (&body[1..]).to_vec();
let bitcount = bits.len() * 8; let bitcount = bits.len() * 8;
@@ -449,9 +434,7 @@ fn from_der_(i: &[u8], start_offset: usize) -> Result<Vec<ASN1Block>, ASN1Decode
result.push(ASN1Block::BitString(soff, nbits, bits)) result.push(ASN1Block::BitString(soff, nbits, bits))
} }
// OCTET STRING // OCTET STRING
Some(0x04) => { Some(0x04) => result.push(ASN1Block::OctetString(soff, body.to_vec())),
result.push(ASN1Block::OctetString(soff, body.to_vec()))
}
// NULL // NULL
Some(0x05) => { Some(0x05) => {
result.push(ASN1Block::Null(soff)); result.push(ASN1Block::Null(soff));
@@ -486,32 +469,20 @@ fn from_der_(i: &[u8], start_offset: usize) -> Result<Vec<ASN1Block>, ASN1Decode
result.push(ASN1Block::ObjectIdentifier(soff, res)) result.push(ASN1Block::ObjectIdentifier(soff, res))
} }
// UTF8STRING // UTF8STRING
Some(0x0C) => { Some(0x0C) => match String::from_utf8(body.to_vec()) {
match String::from_utf8(body.to_vec()) { Ok(v) => result.push(ASN1Block::UTF8String(soff, v)),
Ok(v) => Err(e) => return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error())),
result.push(ASN1Block::UTF8String(soff, v)), },
Err(e) =>
return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error()))
}
}
// SEQUENCE // SEQUENCE
Some(0x10) => { Some(0x10) => match from_der_(body, start_offset + index) {
match from_der_(body, start_offset + index) { Ok(items) => result.push(ASN1Block::Sequence(soff, items)),
Ok(items) => Err(e) => return Err(e),
result.push(ASN1Block::Sequence(soff, items)), },
Err(e) =>
return Err(e)
}
}
// SET // SET
Some(0x11) => { Some(0x11) => match from_der_(body, start_offset + index) {
match from_der_(body, start_offset + index) { Ok(items) => result.push(ASN1Block::Set(soff, items)),
Ok(items) => Err(e) => return Err(e),
result.push(ASN1Block::Set(soff, items)), },
Err(e) =>
return Err(e)
}
}
// PRINTABLE STRING // PRINTABLE STRING
Some(0x13) => { Some(0x13) => {
let mut res = String::new(); let mut res = String::new();
@@ -527,14 +498,10 @@ fn from_der_(i: &[u8], start_offset: usize) -> Result<Vec<ASN1Block>, ASN1Decode
result.push(ASN1Block::PrintableString(soff, res)); result.push(ASN1Block::PrintableString(soff, res));
} }
// TELETEX STRINGS // TELETEX STRINGS
Some(0x14) => { Some(0x14) => match String::from_utf8(body.to_vec()) {
match String::from_utf8(body.to_vec()) { Ok(v) => result.push(ASN1Block::TeletexString(soff, v)),
Ok(v) => Err(e) => return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error())),
result.push(ASN1Block::TeletexString(soff, v)), },
Err(e) =>
return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error()))
}
}
// IA5 (ASCII) STRING // IA5 (ASCII) STRING
Some(0x16) => { Some(0x16) => {
let val = body.iter().map(|x| *x as char); let val = body.iter().map(|x| *x as char);
@@ -549,11 +516,8 @@ fn from_der_(i: &[u8], start_offset: usize) -> Result<Vec<ASN1Block>, ASN1Decode
let v = String::from_iter(body.iter().map(|x| *x as char)); let v = String::from_iter(body.iter().map(|x| *x as char));
match Utc.datetime_from_str(&v, "%y%m%d%H%M%SZ") { match Utc.datetime_from_str(&v, "%y%m%d%H%M%SZ") {
Err(_) => Err(_) => return Err(ASN1DecodeErr::InvalidDateValue(v)),
return Err(ASN1DecodeErr::InvalidDateValue(v)), Ok(t) => result.push(ASN1Block::UTCTime(soff, t)),
Ok(t) => {
result.push(ASN1Block::UTCTime(soff, t))
}
} }
} }
// GeneralizedTime // GeneralizedTime
@@ -579,34 +543,29 @@ fn from_der_(i: &[u8], start_offset: usize) -> Result<Vec<ASN1Block>, ASN1Decode
v.insert(idx, '0'); v.insert(idx, '0');
} }
match Utc.datetime_from_str(&v, "%Y%m%d%H%M%S.%fZ") { match Utc.datetime_from_str(&v, "%Y%m%d%H%M%S.%fZ") {
Err(_) => Err(_) => return Err(ASN1DecodeErr::InvalidDateValue(v)),
return Err(ASN1DecodeErr::InvalidDateValue(v)), Ok(t) => result.push(ASN1Block::GeneralizedTime(soff, t)),
Ok(t) => {
result.push(ASN1Block::GeneralizedTime(soff, t))
}
}
}
// UNIVERSAL STRINGS
Some(0x1C) => {
match String::from_utf8(body.to_vec()) {
Ok(v) =>
result.push(ASN1Block::UniversalString(soff, v)),
Err(e) =>
return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error()))
} }
} }
// UNIVERSAL STRINGS // UNIVERSAL STRINGS
Some(0x1E) => { Some(0x1C) => match String::from_utf8(body.to_vec()) {
match String::from_utf8(body.to_vec()) { Ok(v) => result.push(ASN1Block::UniversalString(soff, v)),
Ok(v) => Err(e) => return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error())),
result.push(ASN1Block::BMPString(soff, v)), },
Err(e) => // UNIVERSAL STRINGS
return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error())) Some(0x1E) => match String::from_utf8(body.to_vec()) {
} Ok(v) => result.push(ASN1Block::BMPString(soff, v)),
} Err(e) => return Err(ASN1DecodeErr::UTF8DecodeFailure(e.utf8_error())),
},
// Dunno. // Dunno.
_ => { _ => {
result.push(ASN1Block::Unknown(class, constructed, soff, tag, body.to_vec())); result.push(ASN1Block::Unknown(
class,
constructed,
soff,
tag,
body.to_vec(),
));
} }
} }
index += len; index += len;
@@ -775,7 +734,7 @@ pub fn to_der(i: &ASN1Block) -> Result<Vec<u8>, ASN1EncodeErr> {
// first, validate that the first two items meet spec // first, validate that the first two items meet spec
if v1 > &two { if v1 > &two {
return Err(ASN1EncodeErr::ObjectIdentVal1TooLarge) return Err(ASN1EncodeErr::ObjectIdentVal1TooLarge);
} }
let u175 = BigUint::from_u8(175).unwrap(); let u175 = BigUint::from_u8(175).unwrap();
@@ -809,9 +768,7 @@ pub fn to_der(i: &ASN1Block) -> Result<Vec<u8>, ASN1EncodeErr> {
Ok(result) Ok(result)
} }
_ => { _ => Err(ASN1EncodeErr::ObjectIdentHasTooFewFields),
Err(ASN1EncodeErr::ObjectIdentHasTooFewFields)
}
} }
} }
// SEQUENCE // SEQUENCE
@@ -886,18 +843,24 @@ pub fn to_der(i: &ASN1Block) -> Result<Vec<u8>, ASN1EncodeErr> {
res.append(&mut body); res.append(&mut body);
Ok(res) Ok(res)
} }
&ASN1Block::UTF8String(_, ref str) => &ASN1Block::UTF8String(_, ref str) => {
encode_asn1_string(0x0c, false, ASN1Class::Universal, str), encode_asn1_string(0x0c, false, ASN1Class::Universal, str)
&ASN1Block::PrintableString(_, ref str) => }
encode_asn1_string(0x13, true, ASN1Class::Universal, str), &ASN1Block::PrintableString(_, ref str) => {
&ASN1Block::TeletexString(_, ref str) => encode_asn1_string(0x13, true, ASN1Class::Universal, str)
encode_asn1_string(0x14, false, ASN1Class::Universal, str), }
&ASN1Block::UniversalString(_, ref str) => &ASN1Block::TeletexString(_, ref str) => {
encode_asn1_string(0x1c, false, ASN1Class::Universal, str), encode_asn1_string(0x14, false, ASN1Class::Universal, str)
&ASN1Block::IA5String(_, ref str) => }
encode_asn1_string(0x16, true, ASN1Class::Universal, str), &ASN1Block::UniversalString(_, ref str) => {
&ASN1Block::BMPString(_, ref str) => encode_asn1_string(0x1c, false, ASN1Class::Universal, str)
encode_asn1_string(0x1e, false, ASN1Class::Universal, str), }
&ASN1Block::IA5String(_, ref str) => {
encode_asn1_string(0x16, true, ASN1Class::Universal, str)
}
&ASN1Block::BMPString(_, ref str) => {
encode_asn1_string(0x1e, false, ASN1Class::Universal, str)
}
&ASN1Block::Explicit(class, _, ref tag, ref item) => { &ASN1Block::Explicit(class, _, ref tag, ref item) => {
let mut tagbytes = encode_tag(class, true, tag); let mut tagbytes = encode_tag(class, true, tag);
let mut bytes = to_der(item)?; let mut bytes = to_der(item)?;
@@ -991,12 +954,9 @@ fn encode_base127(v: &BigUint) -> Vec<u8> {
acc = acc >> 7; acc = acc >> 7;
match digit.to_u8() { match digit.to_u8() {
None => None => panic!("7 bits don't fit into 8, cause ..."),
panic!("7 bits don't fit into 8, cause ..."), Some(x) if res.is_empty() => res.push(x),
Some(x) if res.is_empty() => Some(x) => res.push(x | 0x80),
res.push(x),
Some(x) =>
res.push(x | 0x80)
} }
} }
@@ -1013,7 +973,6 @@ fn encode_class(c: ASN1Class) -> u8 {
} }
} }
fn encode_len(x: usize) -> Vec<u8> { fn encode_len(x: usize) -> Vec<u8> {
if x < 128 { if x < 128 {
vec![x as u8] vec![x as u8]