use crate::network::types::{MqttInfo, MqttPacketType, MqttVersion};
use log::debug;
pub(super) fn is_mqtt_packet(payload: &[u8]) -> bool {
if payload.len() < 2 {
return false;
}
let packet_type = payload[0] >> 4;
let flags = payload[0] & 0x0F;
if !(1..=15).contains(&packet_type) {
return false;
}
if packet_type != 3 {
let expected = match packet_type {
6 | 8 | 10 => 0x02,
_ => 0x00,
};
if flags != expected {
return false;
}
}
let Some((remaining_len, header_bytes)) = decode_remaining_length(payload, 1) else {
return false;
};
let total = 1 + header_bytes + remaining_len;
if total > payload.len() + 4 {
return false;
}
packet_type == 1 && has_mqtt_protocol_name(payload)
}
pub(super) fn analyze_mqtt(payload: &[u8]) -> Option<MqttInfo> {
if payload.len() < 2 {
return None;
}
let type_byte = payload[0] >> 4;
let flags = payload[0] & 0x0F;
let (remaining_len, header_len) = decode_remaining_length(payload, 1)?;
let packet_type = match type_byte {
1 => MqttPacketType::Connect,
2 => MqttPacketType::Connack,
3 => MqttPacketType::Publish,
4 => MqttPacketType::Puback,
5 => MqttPacketType::Pubrec,
6 => MqttPacketType::Pubrel,
7 => MqttPacketType::Pubcomp,
8 => MqttPacketType::Subscribe,
9 => MqttPacketType::Suback,
10 => MqttPacketType::Unsubscribe,
11 => MqttPacketType::Unsuback,
12 => MqttPacketType::Pingreq,
13 => MqttPacketType::Pingresp,
14 => MqttPacketType::Disconnect,
15 => MqttPacketType::Auth,
_ => return None,
};
let var_start = 1 + header_len;
let packet_end = var_start + remaining_len;
let available = &payload[..payload.len().min(packet_end)];
let mut info = MqttInfo {
version: None,
packet_type,
client_id: None,
topic: None,
qos: None,
};
match packet_type {
MqttPacketType::Connect => {
parse_connect(available, var_start, &mut info);
}
MqttPacketType::Publish => {
let qos = (flags >> 1) & 0x03;
info.qos = Some(qos);
parse_publish_topic(available, var_start, &mut info);
}
MqttPacketType::Subscribe => {
info.qos = Some(1); }
MqttPacketType::Pingreq | MqttPacketType::Pingresp => {
}
_ => {}
}
debug!("MQTT analysis result: {:?}", info);
Some(info)
}
fn decode_remaining_length(payload: &[u8], offset: usize) -> Option<(usize, usize)> {
let mut multiplier: usize = 1;
let mut value: usize = 0;
for i in 0..4 {
let idx = offset + i;
if idx >= payload.len() {
return None;
}
let byte = payload[idx] as usize;
value += (byte & 0x7F) * multiplier;
multiplier *= 128;
if byte & 0x80 == 0 {
return Some((value, i + 1));
}
}
None }
fn has_mqtt_protocol_name(payload: &[u8]) -> bool {
if payload.len() < 8 {
return false;
}
let (_, header_len) = decode_remaining_length(payload, 1).unwrap_or((0, 1));
let var_start = 1 + header_len;
matches!(
read_mqtt_string(payload, var_start),
Some((b"MQTT" | b"MQIsdp", _))
)
}
fn read_mqtt_string(payload: &[u8], offset: usize) -> Option<(&[u8], usize)> {
let len_bytes = payload.get(offset..offset + 2)?;
let len = u16::from_be_bytes([len_bytes[0], len_bytes[1]]) as usize;
let start = offset + 2;
let end = start + len;
Some((payload.get(start..end)?, end))
}
fn read_mqtt_str(payload: &[u8], offset: usize) -> Option<(String, usize)> {
let (bytes, end) = read_mqtt_string(payload, offset)?;
let s = std::str::from_utf8(bytes).ok()?;
(!s.is_empty()).then(|| (s.to_string(), end))
}
fn parse_connect(payload: &[u8], var_start: usize, info: &mut MqttInfo) {
let Some((_, after_name)) = read_mqtt_string(payload, var_start) else {
return;
};
if after_name >= payload.len() {
return;
}
let level = payload[after_name];
info.version = match level {
3 => Some(MqttVersion::V31),
4 => Some(MqttVersion::V311),
5 => Some(MqttVersion::V50),
_ => None,
};
let payload_start = after_name + 4;
let payload_start = if level == 5 {
skip_mqtt5_properties(payload, payload_start)
} else {
payload_start
};
if let Some((client_id, _)) = read_mqtt_str(payload, payload_start) {
info.client_id = Some(client_id);
}
}
fn parse_publish_topic(payload: &[u8], var_start: usize, info: &mut MqttInfo) {
if let Some((topic, _)) = read_mqtt_str(payload, var_start) {
info.topic = Some(topic);
}
}
fn skip_mqtt5_properties(payload: &[u8], offset: usize) -> usize {
if let Some((prop_len, consumed)) = decode_remaining_length(payload, offset) {
offset + consumed + prop_len
} else {
offset
}
}
#[cfg(test)]
mod tests {
use super::*;
fn build_connect(protocol_name: &[u8], level: u8, client_id: &str) -> Vec<u8> {
let name_len = protocol_name.len();
let var_len = 2 + name_len + 1 + 1 + 2 + 2 + client_id.len();
let mut pkt = Vec::new();
pkt.push(0x10); pkt.push(var_len as u8);
pkt.extend_from_slice(&(name_len as u16).to_be_bytes());
pkt.extend_from_slice(protocol_name);
pkt.push(level);
pkt.push(0x02);
pkt.extend_from_slice(&60u16.to_be_bytes());
pkt.extend_from_slice(&(client_id.len() as u16).to_be_bytes());
pkt.extend_from_slice(client_id.as_bytes());
pkt
}
fn build_publish(topic: &str, qos: u8, payload_data: &[u8]) -> Vec<u8> {
let flags = (qos & 0x03) << 1;
let packet_id_len = if qos > 0 { 2 } else { 0 };
let var_len = 2 + topic.len() + packet_id_len + payload_data.len();
let mut pkt = Vec::new();
pkt.push(0x30 | flags); pkt.push(var_len as u8);
pkt.extend_from_slice(&(topic.len() as u16).to_be_bytes());
pkt.extend_from_slice(topic.as_bytes());
if qos > 0 {
pkt.extend_from_slice(&1u16.to_be_bytes());
}
pkt.extend_from_slice(payload_data);
pkt
}
#[test]
fn test_empty_payload_safe() {
assert!(analyze_mqtt(&[]).is_none());
}
#[test]
fn test_connect_v311() {
let pkt = build_connect(b"MQTT", 4, "my-client");
assert!(is_mqtt_packet(&pkt));
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Connect);
assert_eq!(info.version, Some(MqttVersion::V311));
assert_eq!(info.client_id.as_deref(), Some("my-client"));
}
#[test]
fn test_connect_v31_mqisdp() {
let pkt = build_connect(b"MQIsdp", 3, "old-device");
assert!(is_mqtt_packet(&pkt));
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Connect);
assert_eq!(info.version, Some(MqttVersion::V31));
assert_eq!(info.client_id.as_deref(), Some("old-device"));
}
#[test]
fn test_connect_v50() {
let mut pkt = Vec::new();
pkt.push(0x10); let var_header_start = pkt.len();
pkt.push(0);
pkt.extend_from_slice(&4u16.to_be_bytes());
pkt.extend_from_slice(b"MQTT");
pkt.push(5);
pkt.push(0x02);
pkt.extend_from_slice(&60u16.to_be_bytes());
pkt.push(0);
let client = "v5-client";
pkt.extend_from_slice(&(client.len() as u16).to_be_bytes());
pkt.extend_from_slice(client.as_bytes());
pkt[var_header_start] = (pkt.len() - var_header_start - 1) as u8;
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.version, Some(MqttVersion::V50));
assert_eq!(info.client_id.as_deref(), Some("v5-client"));
}
#[test]
fn test_connack() {
let pkt = vec![0x20, 0x02, 0x00, 0x00];
assert!(!is_mqtt_packet(&pkt));
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Connack);
}
#[test]
fn test_publish_qos0() {
let pkt = build_publish("home/temp", 0, b"22.5");
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Publish);
assert_eq!(info.topic.as_deref(), Some("home/temp"));
assert_eq!(info.qos, Some(0));
}
#[test]
fn test_publish_qos1() {
let pkt = build_publish("sensors/humidity", 1, b"65");
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Publish);
assert_eq!(info.topic.as_deref(), Some("sensors/humidity"));
assert_eq!(info.qos, Some(1));
}
#[test]
fn test_subscribe() {
let topic = "home/#";
let var_len = 2 + 2 + topic.len() + 1; let mut pkt = vec![0x82, var_len as u8];
pkt.extend_from_slice(&1u16.to_be_bytes()); pkt.extend_from_slice(&(topic.len() as u16).to_be_bytes());
pkt.extend_from_slice(topic.as_bytes());
pkt.push(0x01);
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Subscribe);
assert_eq!(info.qos, Some(1));
}
#[test]
fn test_pingreq() {
let pkt = vec![0xC0, 0x00];
assert!(!is_mqtt_packet(&pkt));
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Pingreq);
}
#[test]
fn test_pingresp() {
let pkt = vec![0xD0, 0x00];
assert!(!is_mqtt_packet(&pkt));
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Pingresp);
}
#[test]
fn test_disconnect() {
let pkt = vec![0xE0, 0x00];
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Disconnect);
}
#[test]
fn test_invalid_type() {
let pkt = vec![0x00, 0x00];
assert!(!is_mqtt_packet(&pkt));
assert!(analyze_mqtt(&pkt).is_none());
}
#[test]
fn test_type_15_auth() {
let pkt = vec![0xF0, 0x00];
assert!(!is_mqtt_packet(&pkt));
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Auth);
}
#[test]
fn test_qos2_flow_packets() {
let pubrec = vec![0x50, 0x02, 0x00, 0x01];
assert_eq!(
analyze_mqtt(&pubrec).unwrap().packet_type,
MqttPacketType::Pubrec
);
let pubrel = vec![0x62, 0x02, 0x00, 0x01];
assert_eq!(
analyze_mqtt(&pubrel).unwrap().packet_type,
MqttPacketType::Pubrel
);
let pubcomp = vec![0x70, 0x02, 0x00, 0x01];
assert_eq!(
analyze_mqtt(&pubcomp).unwrap().packet_type,
MqttPacketType::Pubcomp
);
}
#[test]
fn test_too_short() {
assert!(!is_mqtt_packet(&[]));
assert!(!is_mqtt_packet(&[0x10]));
assert!(analyze_mqtt(&[]).is_none());
}
#[test]
fn test_connect_without_mqtt_name_rejected() {
let pkt = vec![0x10, 0x08, 0x00, 0x04, b'X', b'Y', b'Z', b'W', 4, 0];
assert!(!is_mqtt_packet(&pkt));
}
#[test]
fn test_non_connect_not_detected_by_signature() {
let pkt = vec![0x20, 0x02, 0x00, 0x00]; assert!(!is_mqtt_packet(&pkt));
}
#[test]
fn test_multibyte_remaining_length() {
let mut pkt = vec![0xC0, 0xC8, 0x01]; pkt.extend(vec![0; 200]);
assert!(!is_mqtt_packet(&pkt));
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Pingreq);
}
#[test]
fn test_invalid_remaining_length() {
let pkt = vec![0x20, 0x80, 0x80, 0x80, 0x80, 0x01];
assert!(!is_mqtt_packet(&pkt));
}
#[test]
fn test_connect_empty_client_id() {
let pkt = build_connect(b"MQTT", 4, "");
let info = analyze_mqtt(&pkt).unwrap();
assert_eq!(info.packet_type, MqttPacketType::Connect);
assert_eq!(info.client_id, None); }
#[test]
fn test_http_not_mqtt() {
let payload = b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
assert!(!is_mqtt_packet(payload));
}
#[test]
fn test_binary_data_not_false_positive_mqtt() {
assert!(!is_mqtt_packet(&[0xC0, 0x00]));
assert!(!is_mqtt_packet(&[0xC0, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]));
assert!(!is_mqtt_packet(&[0xA2, 0x05, 0x00, 0x01, 0x00, 0x01, 0x00]));
assert!(!is_mqtt_packet(&[
0x30, 0x0A, 0x00, 0x04, b't', b'e', b's', b't'
]));
assert!(!is_mqtt_packet(&[0xE0, 0x00]));
}
}