use crate::messages::{
RawSimulcryptMessage,
emmg::{
EMMG_MSG_CHANNEL_CLOSE,
EMMG_MSG_CHANNEL_SETUP,
EMMG_MSG_CHANNEL_TEST,
EMMG_MSG_DATA_PROVISION,
EMMG_MSG_STREAM_BW_REQUEST,
EMMG_MSG_STREAM_CLOSE_REQUEST,
EMMG_MSG_STREAM_SETUP,
EMMG_MSG_STREAM_TEST,
EMMG_VAR_BANDWIDTH,
EMMG_VAR_CHANNEL_ID,
EMMG_VAR_DATA_ID,
EMMG_VAR_DATA_TYPE,
EMMG_VAR_DATAGRAM,
EMMG_VAR_SECTION_TS_PKT_FLAG,
EMMG_VAR_STREAM_ID,
EMMG_VAR_SUPER_CAS_ID,
},
tlv::Tlv,
};
#[derive(Debug)]
pub enum EmmgMessage {
ChannelSetup(ChannelSetupMessage),
ChannelTest(ChannelTestMessage),
ChannelClose(ChannelCloseMessage),
StreamSetup(StreamSetupMessage),
StreamTest(StreamTestMessage),
StreamCloseRequest(StreamCloseRequestMessage),
StreamBwRequest(StreamBwRequestMessage),
DataProvision(DataProvisionMessage),
}
impl TryFrom<RawSimulcryptMessage> for EmmgMessage {
type Error = EmmgMessageError;
fn try_from(raw: RawSimulcryptMessage) -> Result<Self, Self::Error> {
ParsedFields::parse(raw.vars)?.into_message(raw.message_type)
}
}
fn parse_u8(value: &[u8], field: &'static str) -> Result<u8, EmmgMessageError> {
if value.len() != 1 {
return Err(EmmgMessageError::InvalidFieldLength {
field,
expected: 1,
actual: value.len(),
});
}
Ok(value[0])
}
fn parse_u16(value: &[u8], field: &'static str) -> Result<u16, EmmgMessageError> {
if value.len() != 2 {
return Err(EmmgMessageError::InvalidFieldLength {
field,
expected: 2,
actual: value.len(),
});
}
Ok(u16::from_be_bytes([value[0], value[1]]))
}
fn parse_u32(value: &[u8], field: &'static str) -> Result<u32, EmmgMessageError> {
if value.len() != 4 {
return Err(EmmgMessageError::InvalidFieldLength {
field,
expected: 4,
actual: value.len(),
});
}
Ok(u32::from_be_bytes([value[0], value[1], value[2], value[3]]))
}
fn parse_bool(value: &[u8], field: &'static str) -> Result<bool, EmmgMessageError> {
match parse_u8(value, field)? {
0 => Ok(false),
1 => Ok(true),
other => Err(EmmgMessageError::InvalidFieldValue {
field,
value: other.to_string(),
}),
}
}
#[derive(Default)]
pub(super) struct ParsedFields {
pub(super) super_cas_id: Option<u32>,
pub(super) channel_id: Option<u16>,
section_ts_pkt_flag: Option<bool>,
pub(super) stream_id: Option<u16>,
pub(super) data_id: Option<u16>,
data_type: Option<u8>,
bandwidth: Option<u16>,
pub(super) datagram: Option<Vec<u8>>,
}
impl ParsedFields {
pub(super) fn parse(vars: Vec<Tlv>) -> Result<Self, EmmgMessageError> {
let mut fields = Self::default();
for var in vars {
let value = &var.value;
match var.tag {
EMMG_VAR_SUPER_CAS_ID => {
if fields.super_cas_id.is_some() {
return Err(EmmgMessageError::DuplicateField("super_cas_id"));
}
fields.super_cas_id = Some(parse_u32(value, "super_cas_id")?);
}
EMMG_VAR_SECTION_TS_PKT_FLAG => {
if fields.section_ts_pkt_flag.is_some() {
return Err(EmmgMessageError::DuplicateField("section_ts_pkt_flag"));
}
fields.section_ts_pkt_flag = Some(parse_bool(value, "section_ts_pkt_flag")?);
}
EMMG_VAR_CHANNEL_ID => {
if fields.channel_id.is_some() {
return Err(EmmgMessageError::DuplicateField("channel_id"));
}
fields.channel_id = Some(parse_u16(value, "channel_id")?);
}
EMMG_VAR_STREAM_ID => {
if fields.stream_id.is_some() {
return Err(EmmgMessageError::DuplicateField("stream_id"));
}
fields.stream_id = Some(parse_u16(value, "stream_id")?);
}
EMMG_VAR_DATAGRAM => {
if fields.datagram.is_some() {
return Err(EmmgMessageError::DuplicateField("datagram"));
}
fields.datagram = Some(var.value);
}
EMMG_VAR_BANDWIDTH => {
if fields.bandwidth.is_some() {
return Err(EmmgMessageError::DuplicateField("bandwidth"));
}
fields.bandwidth = Some(parse_u16(value, "bandwidth")?);
}
EMMG_VAR_DATA_TYPE => {
if fields.data_type.is_some() {
return Err(EmmgMessageError::DuplicateField("data_type"));
}
fields.data_type = Some(parse_u8(value, "data_type")?);
}
EMMG_VAR_DATA_ID => {
if fields.data_id.is_some() {
return Err(EmmgMessageError::DuplicateField("data_id"));
}
fields.data_id = Some(parse_u16(value, "data_id")?);
}
_ => {}
}
}
Ok(fields)
}
fn into_message(self, message_type: u16) -> Result<EmmgMessage, EmmgMessageError> {
match message_type {
EMMG_MSG_CHANNEL_SETUP => Ok(EmmgMessage::ChannelSetup(ChannelSetupMessage {
super_cas_id: self
.super_cas_id
.ok_or(EmmgMessageError::MissingField("super_cas_id"))?,
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
section_ts_pkt_flag: self
.section_ts_pkt_flag
.ok_or(EmmgMessageError::MissingField("section_ts_pkt_flag"))?,
})),
EMMG_MSG_CHANNEL_TEST => Ok(EmmgMessage::ChannelTest(ChannelTestMessage {
super_cas_id: self
.super_cas_id
.ok_or(EmmgMessageError::MissingField("super_cas_id"))?,
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
})),
EMMG_MSG_CHANNEL_CLOSE => Ok(EmmgMessage::ChannelClose(ChannelCloseMessage {
super_cas_id: self
.super_cas_id
.ok_or(EmmgMessageError::MissingField("super_cas_id"))?,
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
})),
EMMG_MSG_STREAM_SETUP => Ok(EmmgMessage::StreamSetup(StreamSetupMessage {
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
stream_id: self
.stream_id
.ok_or(EmmgMessageError::MissingField("stream_id"))?,
data_id: self
.data_id
.ok_or(EmmgMessageError::MissingField("data_id"))?,
data_type: self
.data_type
.ok_or(EmmgMessageError::MissingField("data_type"))?,
})),
EMMG_MSG_STREAM_TEST => Ok(EmmgMessage::StreamTest(StreamTestMessage {
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
stream_id: self
.stream_id
.ok_or(EmmgMessageError::MissingField("stream_id"))?,
})),
EMMG_MSG_STREAM_CLOSE_REQUEST => {
Ok(EmmgMessage::StreamCloseRequest(StreamCloseRequestMessage {
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
stream_id: self
.stream_id
.ok_or(EmmgMessageError::MissingField("stream_id"))?,
}))
}
EMMG_MSG_STREAM_BW_REQUEST => {
Ok(EmmgMessage::StreamBwRequest(StreamBwRequestMessage {
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
stream_id: self
.stream_id
.ok_or(EmmgMessageError::MissingField("stream_id"))?,
bandwidth: self
.bandwidth
.ok_or(EmmgMessageError::MissingField("bandwidth"))?,
}))
}
EMMG_MSG_DATA_PROVISION => Ok(EmmgMessage::DataProvision(DataProvisionMessage {
channel_id: self
.channel_id
.ok_or(EmmgMessageError::MissingField("channel_id"))?,
stream_id: self
.stream_id
.ok_or(EmmgMessageError::MissingField("stream_id"))?,
data: self
.datagram
.ok_or(EmmgMessageError::MissingField("datagram"))?,
})),
_ => Err(EmmgMessageError::UnknownMessageType(message_type)),
}
}
}
#[derive(Debug)]
pub struct ChannelSetupMessage {
pub super_cas_id: u32,
pub channel_id: u16,
pub section_ts_pkt_flag: bool,
}
#[derive(Debug)]
pub struct ChannelTestMessage {
pub super_cas_id: u32,
pub channel_id: u16,
}
#[derive(Debug)]
pub struct ChannelCloseMessage {
pub super_cas_id: u32,
pub channel_id: u16,
}
#[derive(Debug)]
pub struct StreamSetupMessage {
pub channel_id: u16,
pub stream_id: u16,
pub data_id: u16,
pub data_type: u8,
}
#[derive(Debug)]
pub struct StreamTestMessage {
pub channel_id: u16,
pub stream_id: u16,
}
#[derive(Debug)]
pub struct StreamCloseRequestMessage {
pub channel_id: u16,
pub stream_id: u16,
}
#[derive(Debug)]
pub struct StreamBwRequestMessage {
pub channel_id: u16,
pub stream_id: u16,
pub bandwidth: u16,
}
#[derive(Debug)]
pub struct DataProvisionMessage {
pub channel_id: u16,
pub stream_id: u16,
pub data: Vec<u8>,
}
#[derive(Debug, thiserror::Error)]
pub enum EmmgMessageError {
#[error("unknown EMMG message type: {0:#06x}")]
UnknownMessageType(u16),
#[error("missing required field: {0}")]
MissingField(&'static str),
#[error("duplicate field: {0}")]
DuplicateField(&'static str),
#[error("invalid length for {field}: expected {expected}, got {actual}")]
InvalidFieldLength {
field: &'static str,
expected: usize,
actual: usize,
},
#[error("invalid value for {field}: {value}")]
InvalidFieldValue {
field: &'static str,
value: String,
},
}
#[cfg(test)]
mod tests {
use super::*;
use crate::messages::{
RawSimulcryptMessage,
RawSimulcryptMessageError,
emmg::{
EMMG_MSG_CHANNEL_SETUP,
EMMG_MSG_DATA_PROVISION,
EMMG_MSG_STREAM_TEST,
EMMG_VAR_CHANNEL_ID,
EMMG_VAR_DATAGRAM,
EMMG_VAR_SECTION_TS_PKT_FLAG,
EMMG_VAR_STREAM_ID,
EMMG_VAR_SUPER_CAS_ID,
},
};
fn raw_message(message_type: u16, vars: Vec<(u16, Vec<u8>)>) -> RawSimulcryptMessage {
let mut raw = RawSimulcryptMessage::new(message_type);
for (tag, value) in vars {
raw.add_var(tag, value);
}
raw
}
#[test]
fn decode_channel_setup_success() {
let raw = raw_message(
EMMG_MSG_CHANNEL_SETUP,
vec![
(EMMG_VAR_SUPER_CAS_ID, 0x1122_3344u32.to_be_bytes().to_vec()),
(EMMG_VAR_CHANNEL_ID, 0x0102u16.to_be_bytes().to_vec()),
(EMMG_VAR_SECTION_TS_PKT_FLAG, vec![1]),
],
);
let decoded = EmmgMessage::try_from(raw).expect("channel setup should decode");
match decoded {
EmmgMessage::ChannelSetup(msg) => {
assert_eq!(msg.super_cas_id, 0x1122_3344);
assert_eq!(msg.channel_id, 0x0102);
assert!(msg.section_ts_pkt_flag);
}
_ => panic!("expected ChannelSetup"),
}
}
#[test]
fn decode_data_provision_success() {
let datagram = vec![0x47, 0x40, 0x11, 0x10, 0x00, 0xAA];
let raw = raw_message(
EMMG_MSG_DATA_PROVISION,
vec![
(EMMG_VAR_CHANNEL_ID, 0x0010u16.to_be_bytes().to_vec()),
(EMMG_VAR_STREAM_ID, 0x0020u16.to_be_bytes().to_vec()),
(EMMG_VAR_DATAGRAM, datagram.clone()),
],
);
let decoded = EmmgMessage::try_from(raw).expect("data provision should decode");
match decoded {
EmmgMessage::DataProvision(msg) => {
assert_eq!(msg.channel_id, 0x0010);
assert_eq!(msg.stream_id, 0x0020);
assert_eq!(msg.data, datagram);
}
_ => panic!("expected DataProvision"),
}
}
#[test]
fn decode_unknown_message_type_fails() {
let raw = raw_message(
0x9999,
vec![(EMMG_VAR_CHANNEL_ID, 0x0001u16.to_be_bytes().to_vec())],
);
let err = EmmgMessage::try_from(raw).expect_err("unknown message must fail");
match err {
EmmgMessageError::UnknownMessageType(value) => assert_eq!(value, 0x9999),
_ => panic!("expected UnknownMessageType"),
}
}
#[test]
fn decode_missing_required_field_fails() {
let raw = raw_message(
EMMG_MSG_STREAM_TEST,
vec![(EMMG_VAR_CHANNEL_ID, 0x0001u16.to_be_bytes().to_vec())],
);
let err = EmmgMessage::try_from(raw).expect_err("missing stream_id must fail");
match err {
EmmgMessageError::MissingField(field) => assert_eq!(field, "stream_id"),
_ => panic!("expected MissingField(stream_id)"),
}
}
#[test]
fn decode_duplicate_stream_id_fails() {
let raw = raw_message(
EMMG_MSG_STREAM_TEST,
vec![
(EMMG_VAR_CHANNEL_ID, 0x0001u16.to_be_bytes().to_vec()),
(EMMG_VAR_STREAM_ID, 0x0010u16.to_be_bytes().to_vec()),
(EMMG_VAR_STREAM_ID, 0x0011u16.to_be_bytes().to_vec()),
],
);
let err = EmmgMessage::try_from(raw).expect_err("duplicate stream_id must fail");
match err {
EmmgMessageError::DuplicateField(field) => assert_eq!(field, "stream_id"),
_ => panic!("expected DuplicateField(stream_id)"),
}
}
#[test]
fn parse_truncated_tlv_value_fails() {
let bytes = [
0x02, 0x00, 0x12, 0x00, 0x06, 0x00, 0x03, 0x00, 0x04, 0x00, 0x01, ];
let err = RawSimulcryptMessage::unmarshal(&bytes).expect_err("broken tlv length must fail");
match err {
RawSimulcryptMessageError::TruncatedTlvValue => {}
_ => panic!("expected TruncatedTlvValue"),
}
}
}