use bytes::{
BufMut,
Bytes,
BytesMut,
};
use tokio::io::{
AsyncRead,
AsyncReadExt,
AsyncWrite,
AsyncWriteExt,
};
use crate::messages::tlv::Tlv;
pub mod ecmg;
pub mod emmg;
pub mod tlv;
pub const SIMULCRYPT_VERSION: u8 = 0x02;
pub const SIMULCRYPT_MESSAGE_HEADER: usize = 5;
#[derive(Debug, thiserror::Error)]
pub enum ReadMessageError {
#[error("I/O error while reading SimulCrypt message")]
Io(#[source] std::io::Error),
#[error("failed to parse SimulCrypt message")]
Parse(#[source] RawSimulcryptMessageError),
}
#[derive(Clone, Debug)]
pub struct RawSimulcryptMessage {
pub version: u8,
pub message_type: u16,
pub vars: Vec<Tlv>,
}
impl RawSimulcryptMessage {
#[must_use]
pub fn new(message_type: u16) -> Self {
Self {
version: SIMULCRYPT_VERSION,
message_type,
vars: Vec::new(),
}
}
pub fn marshal(&self) -> Result<Bytes, RawSimulcryptMessageError> {
for v in &self.vars {
if v.value.len() > u16::MAX as usize {
return Err(RawSimulcryptMessageError::ValueTooLong {
tag: v.tag,
len: v.value.len(),
});
}
}
let payload_len: usize = self.vars.iter().map(|v| 4 + v.value.len()).sum();
if payload_len > u16::MAX as usize {
return Err(RawSimulcryptMessageError::PayloadTooLong { len: payload_len });
}
let mut out = BytesMut::with_capacity(SIMULCRYPT_MESSAGE_HEADER + payload_len);
out.put_u8(self.version);
out.put_u16(self.message_type);
out.put_u16(u16::try_from(payload_len).expect("payload_len checked above"));
for v in &self.vars {
out.put_u16(v.tag);
out.put_u16(u16::try_from(v.value.len()).expect("v.value.len() checked above"));
out.put_slice(&v.value);
}
Ok(out.freeze())
}
pub fn unmarshal(data: &[u8]) -> Result<Self, RawSimulcryptMessageError> {
if data.len() < SIMULCRYPT_MESSAGE_HEADER {
return Err(RawSimulcryptMessageError::TooShort);
}
let version = data[0];
let message_type = u16::from_be_bytes([data[1], data[2]]);
let payload_len = u16::from_be_bytes([data[3], data[4]]) as usize;
if data.len() < SIMULCRYPT_MESSAGE_HEADER + payload_len {
return Err(RawSimulcryptMessageError::PayloadTooShort);
}
let mut vars = Vec::new();
let mut offset = SIMULCRYPT_MESSAGE_HEADER;
while offset < SIMULCRYPT_MESSAGE_HEADER + payload_len {
if offset + 4 > data.len() {
return Err(RawSimulcryptMessageError::TruncatedTlvHeader);
}
let tag = u16::from_be_bytes([data[offset], data[offset + 1]]);
let len = u16::from_be_bytes([data[offset + 2], data[offset + 3]]) as usize;
offset += 4;
if offset + len > data.len() {
return Err(RawSimulcryptMessageError::TruncatedTlvValue);
}
let value = data[offset .. offset + len].to_vec();
offset += len;
vars.push(Tlv { tag, value });
}
Ok(Self {
version,
message_type,
vars,
})
}
pub async fn read_from<R: AsyncRead + Unpin>(reader: &mut R) -> Result<Self, ReadMessageError> {
let mut header = [0u8; SIMULCRYPT_MESSAGE_HEADER];
reader
.read_exact(&mut header)
.await
.map_err(ReadMessageError::Io)?;
let payload_len = u16::from_be_bytes([header[3], header[4]]) as usize;
let mut data = vec![0u8; SIMULCRYPT_MESSAGE_HEADER + payload_len];
data[.. SIMULCRYPT_MESSAGE_HEADER].copy_from_slice(&header);
reader
.read_exact(&mut data[SIMULCRYPT_MESSAGE_HEADER ..])
.await
.map_err(ReadMessageError::Io)?;
RawSimulcryptMessage::unmarshal(&data).map_err(ReadMessageError::Parse)
}
pub async fn write_to<W: AsyncWrite + Unpin>(
&self,
writer: &mut W,
) -> Result<(), std::io::Error> {
let bytes = self.marshal().map_err(std::io::Error::other)?;
writer.write_all(&bytes).await
}
pub fn get_u8(&self, tag: u16) -> Option<u8> {
self.vars
.iter()
.find(|var| var.tag == tag)
.and_then(Tlv::as_u8)
}
pub fn get_u16(&self, tag: u16) -> Option<u16> {
self.vars
.iter()
.find(|var| var.tag == tag)
.and_then(Tlv::as_u16)
}
pub fn get_u32(&self, tag: u16) -> Option<u32> {
self.vars
.iter()
.find(|var| var.tag == tag)
.and_then(Tlv::as_u32)
}
pub fn set_u8(&mut self, tag: u16, value: u8) {
self.set_value(tag, vec![value]);
}
pub fn set_u16(&mut self, tag: u16, value: u16) {
self.set_value(tag, value.to_be_bytes().to_vec());
}
pub fn set_u32(&mut self, tag: u16, value: u32) {
self.set_value(tag, value.to_be_bytes().to_vec());
}
pub fn add_var(&mut self, tag: u16, value: Vec<u8>) {
self.vars.push(Tlv { tag, value });
}
#[must_use]
pub fn find_var(&self, tag: u16) -> Option<&Tlv> {
self.vars.iter().find(|var| var.tag == tag)
}
fn set_value(&mut self, tag: u16, value: Vec<u8>) {
if let Some(var) = self.vars.iter_mut().find(|var| var.tag == tag) {
var.value = value;
return;
}
self.vars.push(Tlv { tag, value });
}
}
#[derive(Debug, thiserror::Error)]
pub enum RawSimulcryptMessageError {
#[error("message is shorter than the SimulCrypt header")]
TooShort,
#[error("declared payload length exceeds available data")]
PayloadTooShort,
#[error("truncated TLV header")]
TruncatedTlvHeader,
#[error("truncated TLV value")]
TruncatedTlvValue,
#[error("TLV value for tag=0x{tag:04x} is {len} bytes long, exceeds the 65535-byte wire limit")]
ValueTooLong {
tag: u16,
len: usize,
},
#[error("message payload is {len} bytes long, exceeds the 65535-byte wire limit")]
PayloadTooLong {
len: usize,
},
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn marshal_roundtrips_a_normal_message() {
let mut msg = RawSimulcryptMessage::new(0x1234);
msg.add_var(0x0001, vec![1, 2, 3]);
let bytes = msg.marshal().expect("small message must marshal");
let decoded = RawSimulcryptMessage::unmarshal(&bytes).expect("must unmarshal back");
assert_eq!(decoded.message_type, 0x1234);
assert_eq!(decoded.vars.len(), 1);
assert_eq!(decoded.vars[0].value, vec![1, 2, 3]);
}
#[test]
fn marshal_rejects_oversized_tlv_value_instead_of_truncating_the_length_prefix() {
let mut msg = RawSimulcryptMessage::new(0x1234);
msg.add_var(0x0001, vec![0u8; u16::MAX as usize + 1]);
let error = msg
.marshal()
.expect_err("value over 65535 bytes must be rejected");
assert!(matches!(
error,
RawSimulcryptMessageError::ValueTooLong { tag: 0x0001, .. }
));
}
#[test]
fn marshal_rejects_oversized_total_payload() {
let mut msg = RawSimulcryptMessage::new(0x1234);
for tag in 0 .. 3u16 {
msg.add_var(tag, vec![0u8; 30_000]);
}
let error = msg
.marshal()
.expect_err("total payload over 65535 bytes must be rejected");
assert!(matches!(
error,
RawSimulcryptMessageError::PayloadTooLong { .. }
));
}
}