use crate::error::{Error, Result};
use crate::util::bytes::{Reader, Writer};
pub mod tag {
pub const METHOD: u8 = 0x00;
pub const IDENTIFIER: u8 = 0x01;
pub const SALT: u8 = 0x02;
pub const PUBLIC_KEY: u8 = 0x03;
pub const PROOF: u8 = 0x04;
pub const ENCRYPTED_DATA: u8 = 0x05;
pub const STATE: u8 = 0x06;
pub const ERROR: u8 = 0x07;
pub const RETRY_DELAY: u8 = 0x08;
pub const CERTIFICATE: u8 = 0x09;
pub const SIGNATURE: u8 = 0x0a;
pub const PERMISSIONS: u8 = 0x0b;
pub const FRAGMENT_DATA: u8 = 0x0c;
pub const FRAGMENT_LAST: u8 = 0x0d;
pub const FLAGS: u8 = 0x13;
pub const SEPARATOR: u8 = 0xff;
}
pub mod method {
pub const PAIR_SETUP: u8 = 0;
pub const PAIR_SETUP_WITH_AUTH: u8 = 1;
pub const PAIR_VERIFY: u8 = 2;
pub const ADD_PAIRING: u8 = 3;
pub const REMOVE_PAIRING: u8 = 4;
pub const LIST_PAIRINGS: u8 = 5;
}
pub mod errors {
pub const UNKNOWN: u8 = 0x01;
pub const AUTHENTICATION: u8 = 0x02;
pub const BACKOFF: u8 = 0x03;
pub const MAX_PEERS: u8 = 0x04;
pub const MAX_TRIES: u8 = 0x05;
pub const UNAVAILABLE: u8 = 0x06;
pub const BUSY: u8 = 0x07;
pub fn name(code: u8) -> &'static str {
match code {
UNKNOWN => "unknown",
AUTHENTICATION => "authentication failed",
BACKOFF => "too many attempts, back off",
MAX_PEERS => "no room for more pairings",
MAX_TRIES => "too many authentication attempts",
UNAVAILABLE => "pairing unavailable",
BUSY => "busy with another pairing",
_ => "unrecognized error",
}
}
}
const MAX_FRAGMENT: usize = 255;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Tlv8 {
items: Vec<(u8, Vec<u8>)>,
}
impl Tlv8 {
pub fn new() -> Tlv8 {
Tlv8::default()
}
pub fn push(&mut self, tag: u8, value: impl Into<Vec<u8>>) -> &mut Self {
self.items.push((tag, value.into()));
self
}
pub fn push_u8(&mut self, tag: u8, value: u8) -> &mut Self {
self.push(tag, vec![value])
}
pub fn with(mut self, tag: u8, value: impl Into<Vec<u8>>) -> Tlv8 {
self.push(tag, value);
self
}
pub fn with_u8(mut self, tag: u8, value: u8) -> Tlv8 {
self.push_u8(tag, value);
self
}
pub fn items(&self) -> &[(u8, Vec<u8>)] {
&self.items
}
pub fn iter(&self) -> impl Iterator<Item = (u8, &[u8])> {
self.items.iter().map(|(t, v)| (*t, v.as_slice()))
}
pub fn len(&self) -> usize {
self.items.len()
}
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
pub fn get(&self, tag: u8) -> Option<&[u8]> {
self.iter().find(|(t, _)| *t == tag).map(|(_, v)| v)
}
pub fn get_all(&self, tag: u8) -> impl Iterator<Item = &[u8]> {
self.iter().filter(move |(t, _)| *t == tag).map(|(_, v)| v)
}
pub fn get_u8(&self, tag: u8) -> Option<u8> {
match self.get(tag) {
Some([b]) => Some(*b),
_ => None,
}
}
pub fn require(&self, tag: u8) -> Result<&[u8]> {
self.get(tag)
.ok_or_else(|| Error::protocol(format!("tlv8: missing item of type 0x{tag:02x}")))
}
pub fn require_u8(&self, tag: u8) -> Result<u8> {
self.get_u8(tag).ok_or_else(|| {
Error::protocol(format!("tlv8: missing one-byte item of type 0x{tag:02x}"))
})
}
pub fn state(&self) -> Option<u8> {
self.get_u8(tag::STATE)
}
pub fn check_error(&self) -> Result<()> {
match self.get(tag::ERROR) {
None => Ok(()),
Some(v) => {
let code = v.first().copied().unwrap_or(0);
let mut msg = format!("tlv8: peer error {code}: {}", errors::name(code));
if let Some(delay) = self.get(tag::RETRY_DELAY) {
let secs = delay
.iter()
.rev()
.fold(0u64, |acc, &b| (acc << 8) | b as u64);
msg.push_str(&format!(" (retry in {secs} s)"));
}
Err(Error::auth(msg))
}
}
}
pub fn encode(&self) -> Vec<u8> {
let mut w = Writer::with_capacity(self.items.iter().map(|(_, v)| v.len() + 2).sum());
for (tag, value) in &self.items {
if value.is_empty() {
w.u8(*tag).u8(0);
continue;
}
for chunk in value.chunks(MAX_FRAGMENT) {
w.u8(*tag).u8(chunk.len() as u8).bytes(chunk);
}
}
w.into_vec()
}
pub fn decode(data: &[u8]) -> Result<Tlv8> {
let mut r = Reader::new(data, "tlv8");
let mut items: Vec<(u8, Vec<u8>)> = Vec::new();
let mut open = false;
while !r.is_at_end() {
let tag = r.u8()?;
let len = r.u8()? as usize;
let value = r.bytes(len)?;
match items.last_mut() {
Some((last, buf)) if open && *last == tag => buf.extend_from_slice(value),
_ => items.push((tag, value.to_vec())),
}
open = len == MAX_FRAGMENT;
}
Ok(Tlv8 { items })
}
}
impl FromIterator<(u8, Vec<u8>)> for Tlv8 {
fn from_iter<I: IntoIterator<Item = (u8, Vec<u8>)>>(iter: I) -> Tlv8 {
Tlv8 {
items: iter.into_iter().collect(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::codec::fuzz::Rng;
use crate::util::vectors;
fn items_of(b: &vectors::Block) -> Vec<(u8, Vec<u8>)> {
let mut out = Vec::new();
for i in 0.. {
let Some(t) = b.get(&format!("t{i}")) else {
break;
};
let t = u8::from_str_radix(t, 16).expect("tag hex");
let v = b.get(&format!("v{i}")).unwrap_or("");
let v = crate::util::hex::decode(v).expect("value hex");
out.push((t, v));
}
out
}
#[test]
fn vectors() {
let blocks = vectors::load("codec/tlv8.txt");
assert!(blocks.len() >= 5);
for b in blocks {
let name = b.name();
let items = items_of(&b);
let encoded = b.hex("encoded");
let tlv: Tlv8 = items.clone().into_iter().collect();
if b.get("decode_only").is_none() {
assert_eq!(tlv.encode(), encoded, "{name}: encode");
}
let decoded = Tlv8::decode(&encoded).unwrap();
assert_eq!(decoded.items(), &items[..], "{name}: decode");
}
}
#[test]
fn getters() {
let t = Tlv8::new()
.with_u8(tag::STATE, 2)
.with(tag::PUBLIC_KEY, vec![1, 2, 3])
.with(tag::SEPARATOR, Vec::new())
.with(tag::PUBLIC_KEY, vec![4]);
assert_eq!(t.state(), Some(2));
assert_eq!(t.get(tag::PUBLIC_KEY), Some(&[1u8, 2, 3][..]));
assert_eq!(t.get_all(tag::PUBLIC_KEY).count(), 2);
assert!(t.require(tag::SALT).is_err());
assert_eq!(t.get_u8(tag::PUBLIC_KEY), None);
assert!(t.check_error().is_ok());
let back = Tlv8::decode(&t.encode()).unwrap();
assert_eq!(back, t);
}
#[test]
fn peer_error() {
let t = Tlv8::new()
.with_u8(tag::STATE, 4)
.with_u8(tag::ERROR, errors::BACKOFF)
.with(tag::RETRY_DELAY, vec![0x3c, 0x00]);
let err = t.check_error().unwrap_err();
assert_eq!(err.kind(), crate::error::ErrorKind::Auth);
assert_eq!(
err.to_string(),
"tlv8: peer error 3: too many attempts, back off (retry in 60 s)"
);
}
#[test]
fn fragment_boundaries() {
for len in [0usize, 1, 254, 255, 256, 510, 511, 765, 1000] {
let value: Vec<u8> = (0..len).map(|i| i as u8).collect();
let t = Tlv8::new()
.with(tag::ENCRYPTED_DATA, value.clone())
.with_u8(tag::STATE, 5);
let enc = t.encode();
let frags = if len == 0 { 1 } else { len.div_ceil(255) };
assert_eq!(enc.len(), len + 2 * frags + 3, "len {len}");
assert_eq!(Tlv8::decode(&enc).unwrap(), t, "len {len}");
}
}
#[test]
fn truncated() {
assert!(Tlv8::decode(&[0x06]).is_err());
assert!(Tlv8::decode(&[0x06, 0x02, 0x01]).is_err());
assert!(Tlv8::decode(&[]).unwrap().is_empty());
}
#[test]
fn fuzz_smoke() {
let seeds: Vec<Vec<u8>> = vectors::load("codec/tlv8.txt")
.iter()
.map(|b| b.hex("encoded"))
.collect();
let mut rng = Rng::new(0x7174_3800);
for _ in 0..10_000 {
let input = rng.mutate_any(&seeds);
if let Ok(t) = Tlv8::decode(&input) {
assert_eq!(Tlv8::decode(&t.encode()).unwrap(), t);
}
}
}
}