pub const TAG_INTEGER: u8 = 0x02;
pub const TAG_BIT_STRING: u8 = 0x03;
pub const TAG_OCTET_STRING: u8 = 0x04;
pub const TAG_GENERALIZED_TIME: u8 = 0x18;
pub const TAG_GENERAL_STRING: u8 = 0x1B;
pub const TAG_SEQUENCE: u8 = 0x30;
#[inline]
pub const fn context_tag(n: u8) -> u8 {
0xA0 | n
}
#[inline]
pub const fn application_tag(n: u8) -> u8 {
0x60 | n
}
pub fn encode_len(len: usize) -> Vec<u8> {
if len < 0x80 {
vec![len as u8]
} else {
let mut body = Vec::new();
let mut l = len;
while l > 0 {
body.insert(0, (l & 0xff) as u8);
l >>= 8;
}
let mut out = Vec::with_capacity(1 + body.len());
out.push(0x80 | body.len() as u8);
out.extend_from_slice(&body);
out
}
}
pub fn tlv(tag: u8, content: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(1 + content.len() + 2);
out.push(tag);
out.extend_from_slice(&encode_len(content.len()));
out.extend_from_slice(content);
out
}
pub fn encode_integer(value: i64) -> Vec<u8> {
let mut b = value.to_be_bytes().to_vec();
while b.len() > 1 && ((b[0] == 0x00 && b[1] & 0x80 == 0) || (b[0] == 0xff && b[1] & 0x80 != 0))
{
b.remove(0);
}
tlv(TAG_INTEGER, &b)
}
pub fn encode_octet_string(data: &[u8]) -> Vec<u8> {
tlv(TAG_OCTET_STRING, data)
}
pub fn encode_general_string(s: &str) -> Vec<u8> {
tlv(TAG_GENERAL_STRING, s.as_bytes())
}
pub fn encode_generalized_time(t: &str) -> Vec<u8> {
tlv(TAG_GENERALIZED_TIME, t.as_bytes())
}
pub fn encode_sequence(body: &[u8]) -> Vec<u8> {
tlv(TAG_SEQUENCE, body)
}
pub fn explicit(n: u8, inner_der: &[u8]) -> Vec<u8> {
tlv(context_tag(n), inner_der)
}
pub fn application(n: u8, inner_der: &[u8]) -> Vec<u8> {
tlv(application_tag(n), inner_der)
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum DerError {
Truncated,
BadLength,
TagMismatch { expected: u8, found: u8 },
IntTooLarge,
TrailingData,
BadProtocolVersion,
MsgTypeMismatch,
BadBitString,
}
impl core::fmt::Display for DerError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Truncated => write!(f, "DER: truncated"),
Self::BadLength => write!(f, "DER: bad length octets"),
Self::TagMismatch { expected, found } => {
write!(
f,
"DER: tag mismatch (expected 0x{expected:02x}, found 0x{found:02x})"
)
}
Self::IntTooLarge => write!(f, "DER: INTEGER out of range"),
Self::TrailingData => write!(f, "DER: unexpected trailing data"),
Self::BadProtocolVersion => write!(f, "DER: pvno/tkt-vno is not 5"),
Self::MsgTypeMismatch => write!(f, "DER: application tag disagrees with msg-type"),
Self::BadBitString => write!(f, "DER: non-canonical KerberosFlags BIT STRING"),
}
}
}
impl std::error::Error for DerError {}
pub fn one_or(der: &[u8], tag: u8) -> Result<&[u8], DerError> {
let mut r = Der::new(der);
let content = r.expect(tag)?;
r.finish()?;
Ok(content)
}
pub fn read_u32(der: &[u8]) -> Result<u32, DerError> {
let mut r = Der::new(der);
let v = r.read_integer()?;
r.finish()?;
u32::try_from(v).map_err(|_| DerError::IntTooLarge)
}
pub struct Der<'a> {
buf: &'a [u8],
pos: usize,
}
impl<'a> Der<'a> {
pub fn new(buf: &'a [u8]) -> Self {
Der { buf, pos: 0 }
}
pub fn is_empty(&self) -> bool {
self.pos >= self.buf.len()
}
pub fn peek_tag(&self) -> Option<u8> {
self.buf.get(self.pos).copied()
}
pub fn finish(&self) -> Result<(), DerError> {
if self.is_empty() {
Ok(())
} else {
Err(DerError::TrailingData)
}
}
fn read_len(&mut self) -> Result<usize, DerError> {
let first = *self.buf.get(self.pos).ok_or(DerError::Truncated)?;
self.pos += 1;
if first < 0x80 {
return Ok(first as usize);
}
let n = (first & 0x7f) as usize;
if n == 0 || n > core::mem::size_of::<usize>() {
return Err(DerError::BadLength);
}
let mut len = 0usize;
for _ in 0..n {
let b = *self.buf.get(self.pos).ok_or(DerError::Truncated)?;
self.pos += 1;
len = (len << 8) | b as usize;
}
Ok(len)
}
pub fn read_tlv(&mut self) -> Result<(u8, &'a [u8]), DerError> {
let tag = *self.buf.get(self.pos).ok_or(DerError::Truncated)?;
self.pos += 1;
let len = self.read_len()?;
let end = self.pos.checked_add(len).ok_or(DerError::BadLength)?;
if end > self.buf.len() {
return Err(DerError::Truncated);
}
let content = &self.buf[self.pos..end];
self.pos = end;
Ok((tag, content))
}
pub fn expect(&mut self, tag: u8) -> Result<&'a [u8], DerError> {
let (found, content) = self.read_tlv()?;
if found != tag {
return Err(DerError::TagMismatch {
expected: tag,
found,
});
}
Ok(content)
}
pub fn read_integer(&mut self) -> Result<i64, DerError> {
let content = self.expect(TAG_INTEGER)?;
if content.is_empty() || content.len() > 8 {
return Err(DerError::IntTooLarge);
}
let neg = content[0] & 0x80 != 0;
let mut v: i64 = if neg { -1 } else { 0 };
for &b in content {
v = (v << 8) | b as i64;
}
Ok(v)
}
pub fn read_octet_string(&mut self) -> Result<&'a [u8], DerError> {
self.expect(TAG_OCTET_STRING)
}
pub fn read_general_string(&mut self) -> Result<&'a [u8], DerError> {
self.expect(TAG_GENERAL_STRING)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn hexs(b: &[u8]) -> String {
b.iter().map(|x| format!("{x:02x}")).collect()
}
#[test]
fn integer_der_known_answers() {
assert_eq!(hexs(&encode_integer(0)), "020100");
assert_eq!(hexs(&encode_integer(127)), "02017f");
assert_eq!(hexs(&encode_integer(128)), "02020080");
assert_eq!(hexs(&encode_integer(255)), "020200ff");
assert_eq!(hexs(&encode_integer(256)), "02020100");
assert_eq!(hexs(&encode_integer(-1)), "0201ff");
assert_eq!(hexs(&encode_integer(-128)), "020180");
assert_eq!(hexs(&encode_integer(23)), "020117"); }
#[test]
fn length_encoding() {
assert_eq!(hexs(&encode_len(0)), "00");
assert_eq!(hexs(&encode_len(127)), "7f");
assert_eq!(hexs(&encode_len(128)), "8180");
assert_eq!(hexs(&encode_len(255)), "81ff");
assert_eq!(hexs(&encode_len(256)), "820100");
assert_eq!(hexs(&encode_len(300)), "82012c");
}
#[test]
fn integer_roundtrip() {
for v in [
0i64,
1,
-1,
127,
128,
255,
256,
-256,
65535,
i32::MAX as i64,
i32::MIN as i64,
] {
let der = encode_integer(v);
let mut r = Der::new(&der);
assert_eq!(r.read_integer().unwrap(), v, "int {v}");
assert!(r.finish().is_ok());
}
}
#[test]
fn nested_structure_roundtrips() {
let name_type = explicit(0, &encode_integer(1));
let mut strs = Vec::new();
strs.extend_from_slice(&encode_general_string("host"));
strs.extend_from_slice(&encode_general_string("dc.example"));
let name_string = explicit(1, &encode_sequence(&strs));
let mut body = name_type.clone();
body.extend_from_slice(&name_string);
let seq = encode_sequence(&body);
let mut r = Der::new(&seq);
let inner = r.expect(TAG_SEQUENCE).unwrap();
r.finish().unwrap();
let mut ir = Der::new(inner);
let nt = ir.expect(context_tag(0)).unwrap();
assert_eq!(Der::new(nt).read_integer().unwrap(), 1);
let ns = ir.expect(context_tag(1)).unwrap();
let mut nsr = Der::new(ir_seq(ns));
assert_eq!(nsr.read_general_string().unwrap(), b"host");
assert_eq!(nsr.read_general_string().unwrap(), b"dc.example");
assert!(nsr.is_empty());
}
fn ir_seq(bytes: &[u8]) -> &[u8] {
let mut r = Der::new(bytes);
r.expect(TAG_SEQUENCE).unwrap()
}
#[test]
fn malformed_input_never_panics() {
let cases: &[&[u8]] = &[
&[], &[0x02], &[0x02, 0x05], &[0x30, 0x80], &[0x02, 0x89, 0x01], &[0x02, 0x09, 0, 0, 0, 0, 0, 0, 0, 0, 0], &[0x02, 0x01, 0x00, 0xff], ];
for c in cases {
let mut r = Der::new(c);
let _ = r.read_tlv();
let mut r2 = Der::new(c);
let _ = r2.read_integer();
}
}
#[test]
fn tag_mismatch_reported() {
let der = encode_octet_string(b"x");
let mut r = Der::new(&der);
assert_eq!(
r.read_integer(),
Err(DerError::TagMismatch {
expected: TAG_INTEGER,
found: TAG_OCTET_STRING
})
);
}
}