use super::reader::{MAX_DEPTH, TlvReader, Value};
use super::types::{ContainerKind, Tag};
use crate::error::{Result, bail};
pub fn validate_canonical(buf: &[u8]) -> Result<usize> {
let mut r = TlvReader::new(buf);
let mut last: [Option<Tag>; MAX_DEPTH] = [None; MAX_DEPTH];
let mut is_struct = [false; MAX_DEPTH];
let mut count = 0usize;
while let Some(element) = r.next_element()? {
count = count.saturating_add(1);
let level = match element.value {
Value::Container(_) => r.depth().saturating_sub(1),
Value::EndOfContainer => {
if let Some(slot) = last.get_mut(r.depth()) {
*slot = None;
}
continue;
}
_ => r.depth(),
};
if let Some(&parent_is_struct) = level.checked_sub(1).and_then(|i| is_struct.get(i))
&& parent_is_struct
&& let Some(previous) = level
.checked_sub(1)
.and_then(|i| last.get(i))
.copied()
.flatten()
&& element.tag.canonical_cmp(previous) != core::cmp::Ordering::Greater
{
bail!(TlvInvalidTag)
}
if let Some(slot) = level.checked_sub(1).and_then(|i| last.get_mut(i)) {
*slot = Some(element.tag);
}
if let Value::Container(kind) = element.value
&& let Some(slot) = is_struct.get_mut(level)
{
*slot = matches!(kind, ContainerKind::Structure);
if let Some(slot) = last.get_mut(level) {
*slot = None;
}
}
}
r.finish()?;
Ok(count)
}
pub fn re_encode_is_identical(buf: &[u8], out: &mut [u8]) -> Result<bool> {
use super::writer::TlvWriter;
let mut r = TlvReader::new(buf);
let mut w = TlvWriter::new(out);
while let Some(element) = r.next_element()? {
match element.value {
Value::Signed(v) => w.signed(element.tag, v)?,
Value::Unsigned(v) => w.unsigned(element.tag, v)?,
Value::Bool(v) => w.bool(element.tag, v)?,
Value::Float(v) => w.float(element.tag, v)?,
Value::Double(v) => w.double(element.tag, v)?,
Value::Utf8(v) => w.utf8(element.tag, v)?,
Value::Octets(v) => w.octets(element.tag, v)?,
Value::Null => w.null(element.tag)?,
Value::Container(kind) => w.start(element.tag, kind)?,
Value::EndOfContainer => w.end_container()?,
}
}
r.finish()?;
let written = w.finish()?;
Ok(written == buf)
}
#[cfg(test)]
#[allow(clippy::arithmetic_side_effects, clippy::indexing_slicing)]
mod tests {
use super::*;
#[test]
fn canonical_structure_passes() {
assert!(validate_canonical(&[0x15, 0x20, 0x00, 0x2a, 0x20, 0x01, 0xef, 0x18]).is_ok());
}
#[test]
fn duplicate_structure_tags_are_refused() {
assert!(validate_canonical(&[0x15, 0x20, 0x00, 0x2a, 0x20, 0x00, 0xef, 0x18]).is_err());
}
#[test]
fn out_of_order_structure_tags_are_refused() {
let buf = [0x15, 0x20, 0x01, 0xef, 0x20, 0x00, 0x2a, 0x18];
assert!(TlvReader::validate(&buf).is_ok(), "still valid TLV");
assert!(validate_canonical(&buf).is_err(), "but not canonical");
}
#[test]
fn list_order_is_data_not_a_rule() {
let buf = [
0x17, 0x00, 0x01, 0x20, 0x00, 0x2a, 0x00, 0x02, 0x00, 0x03, 0x20, 0x00, 0xef, 0x18,
];
assert!(validate_canonical(&buf).is_ok());
}
#[test]
fn sibling_containers_do_not_share_history() {
let buf = [
0x16, 0x15, 0x24, 0x00, 0x01, 0x18, 0x15, 0x24, 0x00, 0x01, 0x18, 0x18,
];
assert!(validate_canonical(&buf).is_ok());
}
#[test]
fn non_minimal_widths_are_not_fixed_points() {
let mut out = [0u8; 64];
assert!(!re_encode_is_identical(&[0x01, 0x2a, 0x00], &mut out).unwrap());
assert!(re_encode_is_identical(&[0x00, 0x2a], &mut out).unwrap());
}
#[test]
fn round_trip_of_every_spec_vector_is_a_fixed_point() {
let mut out = [0u8; 128];
for v in [
&[0x08][..],
&[0x09][..],
&[0x00, 0x2a][..],
&[0x00, 0xef][..],
&[0x04, 0x2a][..],
&[0x02, 0xf0, 0x67, 0xfd, 0xff][..],
&[0x03, 0x00, 0x90, 0x2f, 0x50, 0x09, 0x00, 0x00, 0x00][..],
&[0x0c, 0x06, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21][..],
&[0x10, 0x05, 0x00, 0x01, 0x02, 0x03, 0x04][..],
&[0x14][..],
&[0x0a, 0x33, 0x33, 0x8f, 0x41][..],
&[0x0b, 0x66, 0x66, 0x66, 0x66, 0x66, 0xe6, 0x31, 0x40][..],
&[0x15, 0x18][..],
&[0x16, 0x18][..],
&[0x17, 0x18][..],
&[0x15, 0x20, 0x00, 0x2a, 0x20, 0x01, 0xef, 0x18][..],
] {
assert!(
re_encode_is_identical(v, &mut out).unwrap(),
"spec vector {v:02x?} is not a fixed point"
);
}
}
}