use thiserror::Error;
use crate::utils::{byte_count, int_to_bin};
#[derive(Debug, Error, PartialEq, Eq)]
pub enum TlvError {
#[error("Can't encode negative or greater than 16 777 215 length")]
LengthTooLarge,
#[error("Can't decode empty encodedTag")]
EmptyTag,
#[error("Invalid encoded tag")]
InvalidTag,
#[error("Can't decode empty encodedLength")]
EmptyLength,
#[error("Invalid encoded length")]
InvalidLength,
#[error("Encoded length is too big")]
LengthTooBig,
#[error("Indefinite length (0x80) is not allowed")]
IndefiniteLength,
#[error("Not enough data to decode TLV value")]
NotEnoughData,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DecodedTag {
pub value: u32,
pub encoded_len: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DecodedLen {
pub value: usize,
pub encoded_len: usize,
}
#[derive(Debug, Clone)]
pub struct DecodedTv {
pub tag: DecodedTag,
pub value: Vec<u8>,
pub encoded_len: usize,
}
#[derive(Debug, Clone)]
pub struct DecodedTl {
pub tag: DecodedTag,
pub length: DecodedLen,
pub encoded_len: usize,
}
pub struct TlvEmpty {
pub tag: u32,
}
impl TlvEmpty {
pub fn new(tag: u32) -> Self {
Self { tag }
}
pub fn to_bytes(&self) -> Vec<u8> {
Tlv::encode(self.tag, &[])
}
}
pub struct Tlv {
pub tag: u32,
pub value: Vec<u8>,
}
impl Tlv {
pub fn new(tag: u32, value: Vec<u8>) -> Self {
Self { tag, value }
}
pub fn from_bytes(encoded_tlv: &[u8]) -> Result<Self, TlvError> {
let tv = Self::decode(encoded_tlv)?;
Ok(Self::new(tv.tag.value, tv.value))
}
pub fn from_int_value(tag: u32, n: u64) -> Self {
Self::new(tag, int_to_bin(n, 1))
}
pub fn to_bytes(&self) -> Vec<u8> {
Self::encode(self.tag, &self.value)
}
pub fn encode(tag: u32, data: &[u8]) -> Vec<u8> {
let t = Self::encode_tag(tag);
let l = Self::encode_length(data.len())
.expect("data length exceeds maximum BER-TLV encodable length (16 777 215)");
let mut out = Vec::with_capacity(t.len() + l.len() + data.len());
out.extend_from_slice(&t);
out.extend_from_slice(&l);
out.extend_from_slice(data);
out
}
pub fn encode_int_value(tag: u32, n: u64) -> Vec<u8> {
Self::from_int_value(tag, n).to_bytes()
}
pub fn decode(encoded_tlv: &[u8]) -> Result<DecodedTv, TlvError> {
let tl = Self::decode_tag_and_length(encoded_tlv)?;
let end = tl.encoded_len + tl.length.value;
if end > encoded_tlv.len() {
return Err(TlvError::NotEnoughData);
}
let data = encoded_tlv[tl.encoded_len..end].to_vec();
Ok(DecodedTv {
tag: tl.tag,
value: data,
encoded_len: end,
})
}
pub fn decode_tag_and_length(encoded: &[u8]) -> Result<DecodedTl, TlvError> {
let tag = Self::decode_tag(encoded)?;
let len = Self::decode_length(&encoded[tag.encoded_len..])?;
let total = tag.encoded_len + len.encoded_len;
Ok(DecodedTl {
tag,
length: len,
encoded_len: total,
})
}
pub fn encode_tag(tag: u32) -> Vec<u8> {
let n = tag as u64;
let bc = byte_count(n);
let count = if bc == 0 { 1 } else { bc };
let mut out = vec![0u8; count];
for (i, byte) in out.iter_mut().enumerate().take(bc) {
let pos = 8 * (bc - i - 1);
*byte = ((n >> pos) & 0xFF) as u8;
}
out
}
pub fn decode_tag(encoded_tag: &[u8]) -> Result<DecodedTag, TlvError> {
if encoded_tag.is_empty() {
return Err(TlvError::EmptyTag);
}
let first_byte = encoded_tag[0];
let mut offset = 1usize;
let tag_value: u32 = if (first_byte & 0x1F) == 0x1F {
if offset >= encoded_tag.len() {
return Err(TlvError::InvalidTag);
}
let mut tag = first_byte as u32; let mut b = encoded_tag[offset];
offset += 1;
while (b & 0x80) == 0x80 {
if offset >= encoded_tag.len() {
return Err(TlvError::InvalidTag);
}
if tag > (u32::MAX >> 8) {
return Err(TlvError::InvalidTag);
}
tag = (tag << 8) | (b as u32);
b = encoded_tag[offset];
offset += 1;
}
if tag > (u32::MAX >> 8) {
return Err(TlvError::InvalidTag);
}
tag = (tag << 8) | (b as u32);
tag
} else {
first_byte as u32
};
Ok(DecodedTag {
value: tag_value,
encoded_len: offset,
})
}
pub fn encode_length(length: usize) -> Result<Vec<u8>, TlvError> {
if length > 0xFF_FFFF {
return Err(TlvError::LengthTooLarge);
}
let bc = byte_count(length as u64);
let size = bc + if bc == 0 || length >= 0x80 { 1 } else { 0 };
let mut out = vec![0u8; size];
if length < 0x80 {
out[0] = length as u8;
} else {
out[0] = (bc as u8) | 0x80;
for i in 0..bc {
let pos = 8 * (bc - i - 1);
out[i + 1] = ((length >> pos) & 0xFF) as u8;
}
}
Ok(out)
}
pub fn decode_length(encoded_length: &[u8]) -> Result<DecodedLen, TlvError> {
if encoded_length.is_empty() {
return Err(TlvError::EmptyLength);
}
let first = encoded_length[0];
if (first & 0x80) == 0x80 {
let num_len_bytes = (first & 0x7F) as usize;
if num_len_bytes == 0 {
return Err(TlvError::IndefiniteLength);
}
if num_len_bytes > 3 {
return Err(TlvError::LengthTooBig);
}
let total_bytes = 1 + num_len_bytes;
if total_bytes > encoded_length.len() {
return Err(TlvError::InvalidLength);
}
let mut length = 0usize;
for byte in &encoded_length[1..total_bytes] {
length = length * 0x100 + (*byte as usize);
}
Ok(DecodedLen {
value: length,
encoded_len: total_bytes,
})
} else {
Ok(DecodedLen {
value: first as usize,
encoded_len: 1,
})
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn encode_length_zero() {
assert_eq!(Tlv::encode_length(0).unwrap(), vec![0x00]);
}
#[test]
fn encode_length_short_form_0x7f() {
assert_eq!(Tlv::encode_length(0x7F).unwrap(), vec![0x7F]);
}
#[test]
fn encode_length_long_form_0x80() {
assert_eq!(Tlv::encode_length(0x80).unwrap(), vec![0x81, 0x80]);
}
#[test]
fn encode_length_long_form_1999() {
assert_eq!(Tlv::encode_length(1999).unwrap(), vec![0x82, 0x07, 0xCF]);
}
#[test]
fn encode_length_long_form_0x8000() {
assert_eq!(Tlv::encode_length(0x8000).unwrap(), vec![0x82, 0x80, 0x00]);
}
#[test]
fn encode_length_long_form_0x800000() {
assert_eq!(
Tlv::encode_length(0x80_0000).unwrap(),
vec![0x83, 0x80, 0x00, 0x00]
);
}
#[test]
fn encode_length_too_large_errors() {
assert_eq!(
Tlv::encode_length(0x1000_0000).unwrap_err(),
TlvError::LengthTooLarge
);
}
#[test]
fn decode_length_short_form_zero() {
let dl = Tlv::decode_length(&[0x00]).unwrap();
assert_eq!(dl.value, 0x00);
assert_eq!(dl.encoded_len, 1);
}
#[test]
fn decode_length_short_form_0x0f() {
let dl = Tlv::decode_length(&[0x0F]).unwrap();
assert_eq!(dl.value, 0x0F);
assert_eq!(dl.encoded_len, 1);
}
#[test]
fn decode_length_short_form_0x10() {
let dl = Tlv::decode_length(&[0x10]).unwrap();
assert_eq!(dl.value, 0x10);
assert_eq!(dl.encoded_len, 1);
}
#[test]
fn decode_length_short_form_0x7f() {
let dl = Tlv::decode_length(&[0x7F]).unwrap();
assert_eq!(dl.value, 0x7F);
assert_eq!(dl.encoded_len, 1);
}
#[test]
fn decode_length_long_form_0x80() {
let dl = Tlv::decode_length(&[0x81, 0x80]).unwrap();
assert_eq!(dl.value, 0x80);
assert_eq!(dl.encoded_len, 2);
}
#[test]
fn decode_length_long_form_0x8000() {
let dl = Tlv::decode_length(&[0x82, 0x80, 0x00]).unwrap();
assert_eq!(dl.value, 0x8000);
assert_eq!(dl.encoded_len, 3);
}
#[test]
fn decode_length_long_form_0x800000() {
let dl = Tlv::decode_length(&[0x83, 0x80, 0x00, 0x00]).unwrap();
assert_eq!(dl.value, 0x80_0000);
assert_eq!(dl.encoded_len, 4);
}
#[test]
fn decode_length_empty_errors() {
assert_eq!(Tlv::decode_length(&[]).unwrap_err(), TlvError::EmptyLength);
}
#[test]
fn decode_length_indefinite_0x80_is_rejected() {
assert_eq!(
Tlv::decode_length(&[0x80]).unwrap_err(),
TlvError::IndefiniteLength
);
assert_eq!(
Tlv::decode_length(&[0x80, 0x01, 0x02]).unwrap_err(),
TlvError::IndefiniteLength
);
}
#[test]
fn decode_length_truncated_long_form_errors() {
assert_eq!(
Tlv::decode_length(&[0x82]).unwrap_err(),
TlvError::InvalidLength
);
}
#[test]
fn decode_length_too_many_bytes_errors() {
assert_eq!(
Tlv::decode_length(&[0x84, 0x10, 0x00, 0x00, 0x00]).unwrap_err(),
TlvError::LengthTooBig
);
}
#[test]
fn encode_tag_zero() {
assert_eq!(Tlv::encode_tag(0), vec![0x00]);
}
#[test]
fn encode_tag_single_byte() {
assert_eq!(Tlv::encode_tag(0x87), vec![0x87]);
assert_eq!(Tlv::encode_tag(0x8E), vec![0x8E]);
assert_eq!(Tlv::encode_tag(0x99), vec![0x99]);
}
#[test]
fn decode_tag_single_byte() {
let dt = Tlv::decode_tag(&[0x00]).unwrap();
assert_eq!(dt.value, 0x00);
assert_eq!(dt.encoded_len, 1);
let dt = Tlv::decode_tag(&[0x87]).unwrap();
assert_eq!(dt.value, 0x87);
assert_eq!(dt.encoded_len, 1);
}
#[test]
fn decode_tag_empty_errors() {
assert_eq!(Tlv::decode_tag(&[]).unwrap_err(), TlvError::EmptyTag);
}
#[test]
fn decode_tag_truncated_multibyte_errors() {
assert_eq!(Tlv::decode_tag(&[0x1F]).unwrap_err(), TlvError::InvalidTag);
assert_eq!(
Tlv::decode_tag(&[0x1F, 0x80]).unwrap_err(),
TlvError::InvalidTag
);
}
#[test]
fn decode_tag_multibyte_roundtrips() {
for raw in [
vec![0x5F, 0x81, 0x7F],
vec![0x7F, 0x81, 0x01],
vec![0x1F, 0x82, 0x00],
] {
let dt = Tlv::decode_tag(&raw).unwrap();
assert_eq!(dt.encoded_len, raw.len());
assert_eq!(
Tlv::encode_tag(dt.value),
raw,
"round-trip failed for {raw:02X?}"
);
}
}
#[test]
fn decode_tag_overflow_errors() {
assert_eq!(
Tlv::decode_tag(&[0x1F, 0x81, 0x82, 0x83, 0x04]).unwrap_err(),
TlvError::InvalidTag
);
}
#[test]
fn encode_int_value_icao_9303_p10() {
assert_eq!(
Tlv::encode_int_value(0x54, 0x0001),
hex::decode("540101").unwrap()
);
assert_eq!(
Tlv::encode_int_value(0x54, 0xFFFF),
hex::decode("5402FFFF").unwrap()
);
}
#[test]
fn encode_int_value_icao_9303_p11() {
assert_eq!(
Tlv::encode_int_value(0x97, 0x04),
hex::decode("970104").unwrap()
);
assert_eq!(
Tlv::encode_int_value(0x97, 0x12),
hex::decode("970112").unwrap()
);
}
#[test]
fn encode_icao_9303_p11_d4() {
assert_eq!(
Tlv::encode(0x87, &hex::decode("016375432908C044F6").unwrap()),
hex::decode("8709016375432908C044F6").unwrap()
);
assert_eq!(
Tlv::encode(0x8E, &hex::decode("BF8B92D635FF24F8").unwrap()),
hex::decode("8E08BF8B92D635FF24F8").unwrap()
);
assert_eq!(
Tlv::encode(0x8E, &hex::decode("ED6705417E96BA55").unwrap()),
hex::decode("8E08ED6705417E96BA55").unwrap()
);
assert_eq!(
Tlv::encode(0x8E, &hex::decode("2EA28A70F3C7B535").unwrap()),
hex::decode("8E082EA28A70F3C7B535").unwrap()
);
}
#[test]
fn encode_empty_value() {
assert_eq!(Tlv::encode(0x00, &[]), vec![0x00, 0x00]);
}
#[test]
fn decode_tag_0_len_0() {
let tv = Tlv::decode(&[0x00, 0x00]).unwrap();
assert_eq!(tv.tag.value, 0);
assert_eq!(tv.tag.encoded_len, 1);
assert_eq!(tv.encoded_len, 2);
assert!(tv.value.is_empty());
}
#[test]
fn decode_tag_1_len_0() {
let tv = Tlv::decode(&[0x01, 0x00]).unwrap();
assert_eq!(tv.tag.value, 1);
assert_eq!(tv.tag.encoded_len, 1);
assert_eq!(tv.encoded_len, 2);
assert!(tv.value.is_empty());
}
#[test]
fn decode_tag_0x10_len_0() {
let tv = Tlv::decode(&[0x10, 0x00]).unwrap();
assert_eq!(tv.tag.value, 0x10);
assert_eq!(tv.tag.encoded_len, 1);
assert_eq!(tv.encoded_len, 2);
assert!(tv.value.is_empty());
}
#[test]
fn decode_tag_0x11_len_0() {
let tv = Tlv::decode(&[0x11, 0x00]).unwrap();
assert_eq!(tv.tag.value, 0x11);
assert_eq!(tv.tag.encoded_len, 1);
assert_eq!(tv.encoded_len, 2);
assert!(tv.value.is_empty());
}
#[test]
fn decode_tag_0x11_value_0x00() {
let tv = Tlv::decode(&[0x11, 0x01, 0x00]).unwrap();
assert_eq!(tv.tag.value, 0x11);
assert_eq!(tv.tag.encoded_len, 1);
assert_eq!(tv.encoded_len, 3);
assert_eq!(tv.value, vec![0x00]);
}
#[test]
fn decode_tag_0x11_value_0x01() {
let tv = Tlv::decode(&[0x11, 0x01, 0x01]).unwrap();
assert_eq!(tv.tag.value, 0x11);
assert_eq!(tv.encoded_len, 3);
assert_eq!(tv.value, vec![0x01]);
}
#[test]
fn decode_tag_0x11_value_0x0f() {
let tv = Tlv::decode(&[0x11, 0x01, 0x0F]).unwrap();
assert_eq!(tv.tag.value, 0x11);
assert_eq!(tv.encoded_len, 3);
assert_eq!(tv.value, vec![0x0F]);
}
#[test]
fn decode_tag_0x11_value_0xff() {
let tv = Tlv::decode(&[0x11, 0x01, 0xFF]).unwrap();
assert_eq!(tv.tag.value, 0x11);
assert_eq!(tv.tag.encoded_len, 1);
assert_eq!(tv.encoded_len, 3);
assert_eq!(tv.value, vec![0xFF]);
}
#[test]
fn decode_icao_p11_d4_case1() {
let data = hex::decode("990290008E08FA855A5D4C50A8ED").unwrap();
let do99 = Tlv::decode(&data).unwrap();
let do8e = Tlv::decode(&data[do99.encoded_len..]).unwrap();
assert_eq!(do99.encoded_len + do8e.encoded_len, data.len());
assert_eq!(do99.tag.value, 0x99);
assert_eq!(do99.value, hex::decode("9000").unwrap());
assert_eq!(do8e.tag.value, 0x8E);
assert_eq!(do8e.value, hex::decode("FA855A5D4C50A8ED").unwrap());
}
#[test]
fn decode_icao_p11_d4_case2() {
let data = hex::decode("8709019FF0EC34F9922651990290008E08AD55CC17140B2DED").unwrap();
let do87 = Tlv::decode(&data).unwrap();
let do99 = Tlv::decode(&data[do87.encoded_len..]).unwrap();
let do8e = Tlv::decode(&data[do87.encoded_len + do99.encoded_len..]).unwrap();
assert_eq!(
do87.encoded_len + do99.encoded_len + do8e.encoded_len,
data.len()
);
assert_eq!(do87.tag.value, 0x87);
assert_eq!(do87.value, hex::decode("019FF0EC34F9922651").unwrap());
let dec_do87_tl = Tlv::decode_tag_and_length(&hex::decode("60145F01").unwrap()).unwrap();
assert_eq!(dec_do87_tl.tag.value, 0x60);
assert_eq!(dec_do87_tl.length.value, 0x14);
assert_eq!(do99.tag.value, 0x99);
assert_eq!(do99.value, hex::decode("9000").unwrap());
assert_eq!(do8e.tag.value, 0x8E);
assert_eq!(do8e.value, hex::decode("AD55CC17140B2DED").unwrap());
}
#[test]
fn decode_icao_p11_d4_case3() {
let data = hex::decode(
"871901FB9235F4E4037F2327DCC8964F1F9B8C30F42C8E2FFF224A990290008E08C8B2787EAEA07D74",
)
.unwrap();
let do87 = Tlv::decode(&data).unwrap();
let do99 = Tlv::decode(&data[do87.encoded_len..]).unwrap();
let do8e = Tlv::decode(&data[do87.encoded_len + do99.encoded_len..]).unwrap();
assert_eq!(
do87.encoded_len + do99.encoded_len + do8e.encoded_len,
data.len()
);
assert_eq!(do87.tag.value, 0x87);
assert_eq!(
do87.value,
hex::decode("01FB9235F4E4037F2327DCC8964F1F9B8C30F42C8E2FFF224A").unwrap()
);
assert_eq!(do99.tag.value, 0x99);
assert_eq!(do99.value, hex::decode("9000").unwrap());
assert_eq!(do8e.tag.value, 0x8E);
assert_eq!(do8e.value, hex::decode("C8B2787EAEA07D74").unwrap());
}
#[test]
fn decode_empty_errors_empty_tag() {
assert_eq!(Tlv::decode(&[]).unwrap_err(), TlvError::EmptyTag);
}
#[test]
fn decode_single_byte_tag_no_length_errors() {
assert_eq!(Tlv::decode(&[0x00]).unwrap_err(), TlvError::EmptyLength);
}
#[test]
fn decode_multibyte_tag_truncated_errors() {
assert_eq!(Tlv::decode(&[0x1F]).unwrap_err(), TlvError::InvalidTag);
assert_eq!(
Tlv::decode(&[0x1F, 0x80]).unwrap_err(),
TlvError::InvalidTag
);
}
#[test]
fn decode_truncated_long_length_errors() {
assert_eq!(
Tlv::decode(&[0x00, 0x82]).unwrap_err(),
TlvError::InvalidLength
);
}
#[test]
fn decode_length_too_big_errors() {
assert_eq!(
Tlv::decode(&[0x00, 0x84, 0x10, 0x00, 0x00, 0x00]).unwrap_err(),
TlvError::LengthTooBig
);
}
#[test]
fn decode_value_out_of_bounds_errors() {
assert_eq!(
Tlv::decode(&[0x00, 0x01]).unwrap_err(),
TlvError::NotEnoughData
);
}
#[test]
fn encode_decode_roundtrip() {
let original = vec![0xDE, 0xAD, 0xBE, 0xEF];
let encoded = Tlv::encode(0x87, &original);
let tv = Tlv::decode(&encoded).unwrap();
assert_eq!(tv.tag.value, 0x87);
assert_eq!(tv.value, original);
assert_eq!(tv.encoded_len, encoded.len());
}
#[test]
fn tlv_empty_to_bytes() {
let empty = TlvEmpty::new(0x87);
assert_eq!(empty.to_bytes(), vec![0x87, 0x00]);
}
#[test]
fn byte_count_values() {
assert_eq!(byte_count(0), 0);
assert_eq!(byte_count(1), 1);
assert_eq!(byte_count(0xFF), 1);
assert_eq!(byte_count(0x100), 2);
assert_eq!(byte_count(0xFFFF), 2);
assert_eq!(byte_count(0x10000), 3);
}
#[test]
fn int_to_bin_min_len_1() {
assert_eq!(int_to_bin(0, 1), vec![0x00]);
assert_eq!(int_to_bin(1, 1), vec![0x01]);
assert_eq!(int_to_bin(0xFF, 1), vec![0xFF]);
assert_eq!(int_to_bin(0x100, 1), vec![0x01, 0x00]);
assert_eq!(int_to_bin(0xFFFF, 1), vec![0xFF, 0xFF]);
}
#[test]
fn int_to_bin_min_len_0_zero_is_empty() {
assert_eq!(int_to_bin(0, 0), Vec::<u8>::new());
assert_eq!(int_to_bin(1, 0), vec![0x01]);
}
}