use std::collections::BTreeMap;
use super::attest::AppAttestError;
use super::ensure;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CborValue {
Unsigned(u64),
ByteString(Vec<u8>),
TextString(String),
Array(Vec<CborValue>),
Map(BTreeMap<String, CborValue>),
}
impl CborValue {
#[must_use]
pub fn map_value(&self) -> Option<&BTreeMap<String, CborValue>> {
match *self {
Self::Map(ref map) => Some(map),
_ => None,
}
}
#[must_use]
pub fn array_value(&self) -> Option<&Vec<CborValue>> {
match *self {
Self::Array(ref items) => Some(items),
_ => None,
}
}
#[must_use]
pub fn bytes_value(&self) -> Option<&Vec<u8>> {
match *self {
Self::ByteString(ref bytes) => Some(bytes),
_ => None,
}
}
}
pub const MAX_ATTEST_BYTES: usize = 65_536;
const MAX_DEPTH: usize = 128;
pub fn decode_attestation(bytes: &[u8]) -> Result<CborValue, AppAttestError> {
ensure(bytes.len() <= MAX_ATTEST_BYTES, || {
AppAttestError::Truncated
})?;
let mut reader = CborReader { bytes, position: 0 };
let value = reader.decode_value(0)?;
ensure(reader.position == bytes.len(), || {
AppAttestError::UnexpectedType(String::from("trailing bytes"))
})?;
Ok(value)
}
struct CborReader<'a> {
bytes: &'a [u8],
position: usize,
}
impl CborReader<'_> {
fn decode_value(&mut self, depth: usize) -> Result<CborValue, AppAttestError> {
ensure(depth <= MAX_DEPTH, || AppAttestError::Truncated)?;
let initial = self.read_byte()?;
let major = initial.wrapping_shr(5);
let info = initial & 0x1f;
match major {
0 => Ok(CborValue::Unsigned(self.read_uint(info)?)),
2 => {
let length = self.read_length(info)?;
Ok(CborValue::ByteString(self.read_bytes(length)?))
}
3 => {
let length = self.read_length(info)?;
let bytes = self.read_bytes(length)?;
String::from_utf8(bytes)
.map(CborValue::TextString)
.map_err(AppAttestError::InvalidUtf8)
}
4 => {
let count = self.read_length(info)?;
self.check_count(count)?;
let mut items = Vec::new();
for _ in 0..count {
items.push(self.decode_value(depth.saturating_add(1))?);
}
Ok(CborValue::Array(items))
}
5 => {
let count = self.read_length(info)?;
self.check_count(count)?;
let mut map = BTreeMap::new();
for _ in 0..count {
let key = self.decode_value(depth.saturating_add(1))?;
let value = self.decode_value(depth.saturating_add(1))?;
let text = match key {
CborValue::TextString(text) => Ok(text),
_ => Err(AppAttestError::UnexpectedType(String::from("map key"))),
}?;
ensure(map.insert(text, value).is_none(), || {
AppAttestError::UnexpectedType(String::from("duplicate map key"))
})?;
}
Ok(CborValue::Map(map))
}
_ => Err(AppAttestError::UnsupportedMajorType(major)),
}
}
fn read_uint(&mut self, info: u8) -> Result<u64, AppAttestError> {
match info {
0..=23 => Ok(u64::from(info)),
24 => Ok(u64::from(self.read_byte()?)),
25 => self.read_big_endian(2),
26 => self.read_big_endian(4),
27 => self.read_big_endian(8),
_ => Err(AppAttestError::UnsupportedAdditionalInfo(info)),
}
}
fn read_length(&mut self, info: u8) -> Result<usize, AppAttestError> {
let length = self.read_uint(info)?;
Ok(usize::try_from(length)?)
}
fn check_count(&self, count: usize) -> Result<(), AppAttestError> {
let remaining = self.bytes.len().saturating_sub(self.position);
ensure(count <= remaining, || AppAttestError::Truncated)
}
fn read_big_endian(&mut self, count: usize) -> Result<u64, AppAttestError> {
let mut value: u64 = 0;
for _ in 0..count {
value = value.wrapping_shl(8) | u64::from(self.read_byte()?);
}
Ok(value)
}
fn read_byte(&mut self) -> Result<u8, AppAttestError> {
let byte = self
.bytes
.get(self.position)
.copied()
.ok_or(AppAttestError::Truncated)?;
self.position = self.position.saturating_add(1);
Ok(byte)
}
fn read_bytes(&mut self, count: usize) -> Result<Vec<u8>, AppAttestError> {
let end = self.position.saturating_add(count);
ensure(end <= self.bytes.len(), || AppAttestError::Truncated)?;
let bytes = self.bytes[self.position..end].to_vec();
self.position = end;
Ok(bytes)
}
}