use crate::Error;
pub const TAG_INTEGER: u8 = 0x02;
pub const TAG_OCTET_STRING: u8 = 0x04;
pub const TAG_SEQUENCE: u8 = 0x30;
pub fn write_len(out: &mut Vec<u8>, len: usize) {
if len < 0x80 {
out.push(len as u8);
return;
}
let mut buf = [0u8; 8];
let mut n = 0usize;
let mut l = len;
while l > 0 {
buf[n] = (l & 0xff) as u8;
l >>= 8;
n += 1;
}
out.push(0x80 | (n as u8));
for i in (0..n).rev() {
out.push(buf[i]);
}
}
pub fn read_header(buf: &[u8]) -> Result<(u8, usize, usize), Error> {
if buf.is_empty() {
return Err(Error::Truncated);
}
let tag = buf[0];
if buf.len() < 2 {
return Err(Error::Truncated);
}
let first = buf[1];
if first & 0x80 == 0 {
return Ok((tag, first as usize, 2));
}
let n = (first & 0x7f) as usize;
if n == 0 || n > 4 {
return Err(Error::Malformed("unsupported length form"));
}
if buf.len() < 2 + n {
return Err(Error::Truncated);
}
let mut len = 0usize;
for &b in &buf[2..2 + n] {
len = (len << 8) | (b as usize);
}
Ok((tag, len, 2 + n))
}
pub fn write_u32(out: &mut Vec<u8>, v: u32) {
let mut bytes = v.to_be_bytes().to_vec();
while bytes.len() > 1 && bytes[0] == 0 && (bytes[1] & 0x80) == 0 {
bytes.remove(0);
}
if bytes[0] & 0x80 != 0 {
bytes.insert(0, 0x00);
}
out.push(TAG_INTEGER);
write_len(out, bytes.len());
out.extend_from_slice(&bytes);
}
pub fn read_u32(buf: &[u8]) -> Result<(u32, usize), Error> {
let (tag, len, hdr) = read_header(buf)?;
if tag != TAG_INTEGER {
return Err(Error::Malformed("expected INTEGER"));
}
if buf.len() < hdr + len {
return Err(Error::Truncated);
}
let bytes = &buf[hdr..hdr + len];
if bytes.is_empty() || bytes.len() > 5 {
return Err(Error::Malformed("INTEGER out of u32 range"));
}
if bytes.len() == 5 && bytes[0] != 0 {
return Err(Error::Malformed("INTEGER out of u32 range"));
}
let mut v: u64 = 0;
for &b in bytes {
v = (v << 8) | b as u64;
}
if v > u32::MAX as u64 {
return Err(Error::Malformed("INTEGER exceeds u32"));
}
Ok((v as u32, hdr + len))
}
pub fn write_octet_string(out: &mut Vec<u8>, v: &[u8]) {
out.push(TAG_OCTET_STRING);
write_len(out, v.len());
out.extend_from_slice(v);
}
pub fn read_octet_string(buf: &[u8]) -> Result<(&[u8], usize), Error> {
let (tag, len, hdr) = read_header(buf)?;
if tag != TAG_OCTET_STRING {
return Err(Error::Malformed("expected OCTET STRING"));
}
if buf.len() < hdr + len {
return Err(Error::Truncated);
}
Ok((&buf[hdr..hdr + len], hdr + len))
}
pub fn wrap_sequence(body: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(body.len() + 4);
out.push(TAG_SEQUENCE);
write_len(&mut out, body.len());
out.extend_from_slice(body);
out
}
pub fn read_sequence(buf: &[u8]) -> Result<(&[u8], usize), Error> {
let (tag, len, hdr) = read_header(buf)?;
if tag != TAG_SEQUENCE {
return Err(Error::Malformed("expected SEQUENCE"));
}
if buf.len() < hdr + len {
return Err(Error::Truncated);
}
Ok((&buf[hdr..hdr + len], hdr + len))
}