use crate::network::merge::merge_tls_info;
use crate::network::types::{QuicConnectionState, QuicInfo, QuicPacketType, TlsInfo};
use crate::network::util::hex_encode;
use log::{debug, warn};
use std::ops::Range;
use super::crypto::decrypt_client_initial_packet;
use super::tls::try_extract_tls_from_reassembler;
pub(super) const INITIAL_SALT_V1: &[u8] = &[
0x38, 0x76, 0x2c, 0xf7, 0xf5, 0x59, 0x34, 0xb3, 0x4d, 0x17, 0x9a, 0xe6, 0xa4, 0xc8, 0x0c, 0xad,
0xcc, 0xbb, 0x7f, 0x0a,
];
const INITIAL_SALT_V2: &[u8] = &[
0x0d, 0xed, 0xe3, 0xde, 0xf7, 0x00, 0xa6, 0xdb, 0x81, 0x93, 0x81, 0xbe, 0x6e, 0x26, 0x9d, 0xcb,
0xf9, 0xbd, 0x2e, 0xd9,
];
const INITIAL_SALT_DRAFT_29: &[u8] = &[
0xaf, 0xbf, 0xec, 0x28, 0x99, 0x93, 0xd2, 0x4c, 0x9e, 0x97, 0x86, 0xf1, 0x9c, 0x61, 0x11, 0xe0,
0x43, 0x90, 0xa8, 0x99,
];
const INITIAL_SALT_DRAFT_23: &[u8] = &[
0xc3, 0xee, 0xf7, 0x12, 0xc7, 0x2e, 0xbb, 0x5a, 0x11, 0xa7, 0xd2, 0x43, 0x2b, 0xb4, 0x63, 0x65,
0xbe, 0xf9, 0xf5, 0x02,
];
pub(super) fn initial_salt_for_version(version: u32) -> &'static [u8] {
if is_quic_v2(version) {
return INITIAL_SALT_V2;
}
match version {
0xff00_001d..=0xff00_0020 => INITIAL_SALT_DRAFT_29, 0xff00_0017..=0xff00_001c | 0xface_b002 => INITIAL_SALT_DRAFT_23, _ => INITIAL_SALT_V1, }
}
pub(in crate::network::dpi) fn parse_quic_packet(payload: &[u8]) -> Option<QuicInfo> {
if payload.is_empty() {
debug!("QUIC: Empty payload");
return None;
}
let mut combined_info: Option<QuicInfo> = None;
let mut offset = 0;
let mut packet_count = 0;
while offset < payload.len() {
let remaining = &payload[offset..];
if remaining.is_empty() {
break;
}
let first_byte = remaining[0];
let is_long_header = (first_byte & 0x80) != 0;
debug!(
"QUIC: Parsing packet {} at offset {} - first_byte=0x{:02x}, is_long_header={}, remaining_len={}",
packet_count + 1,
offset,
first_byte,
is_long_header,
remaining.len()
);
let (packet_info, packet_len) = if is_long_header {
parse_long_header_packet_with_length(remaining)
} else {
let info = parse_short_header_packet(remaining);
(info, remaining.len())
};
if let Some(info) = packet_info {
combined_info = Some(merge_quic_packet_info(combined_info, info));
}
if packet_len == 0 {
break;
}
offset += packet_len;
packet_count += 1;
if packet_count >= 10 {
debug!("QUIC: Reached coalesced packet limit (10), stopping");
break;
}
}
if packet_count > 1 {
debug!(
"QUIC: Processed {} coalesced packets in UDP datagram",
packet_count
);
}
combined_info
}
fn merge_quic_packet_info(existing: Option<QuicInfo>, new: QuicInfo) -> QuicInfo {
match existing {
None => new,
Some(mut existing) => {
if new.connection_state.priority() > existing.connection_state.priority() {
existing.connection_state = new.connection_state;
}
merge_tls_info(&mut existing.tls_info, &new.tls_info);
if existing.connection_id.is_empty() && !new.connection_id.is_empty() {
existing.connection_id = new.connection_id;
existing.connection_id_hex = new.connection_id_hex;
}
if existing.version_string.is_none() && new.version_string.is_some() {
existing.version_string = new.version_string;
}
match (&mut existing.crypto_reassembler, new.crypto_reassembler) {
(None, Some(new_reassembler)) => {
existing.crypto_reassembler = Some(new_reassembler);
}
(Some(existing_reassembler), Some(new_reassembler)) => {
if !existing_reassembler.extraction_finished() {
if new_reassembler.extraction_finished() {
existing_reassembler
.finish_extraction(new_reassembler.get_cached_tls_info().cloned());
} else {
for (frag_offset, data) in new_reassembler.get_fragments() {
if let Err(e) =
existing_reassembler.add_fragment(frag_offset, data.to_vec())
{
warn!("QUIC: Failed to merge coalesced CRYPTO fragment: {}", e);
}
}
}
}
let extracted = try_extract_tls_from_reassembler(existing_reassembler, false);
merge_tls_info(&mut existing.tls_info, &extracted);
}
_ => {}
}
existing
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) struct PacketLayout {
pub pn_offset: usize,
pub packet_length: usize,
}
pub(super) struct LongHeader {
pub version: u32,
pub packet_type: QuicPacketType,
pub dcid: Range<usize>,
pub layout: Option<PacketLayout>,
}
pub(super) fn parse_long_header(payload: &[u8]) -> Option<LongHeader> {
if payload.len() < 6 {
return None;
}
let first_byte = payload[0];
let version = u32::from_be_bytes([payload[1], payload[2], payload[3], payload[4]]);
let packet_type = if version == 0 {
QuicPacketType::VersionNegotiation
} else {
get_long_packet_type(first_byte, version)
};
let mut offset = 5;
if offset >= payload.len() {
debug!(
"QUIC: Payload too short to read DCID length at offset {}",
offset
);
return None;
}
let dcid_len = payload[offset] as usize;
offset += 1;
debug!(
"QUIC: Parsing long header packet - version=0x{:08x}, DCID length={}",
version, dcid_len
);
if offset + dcid_len > payload.len() {
debug!(
"QUIC: Payload too short for DCID, need {} bytes, have {}",
offset + dcid_len,
payload.len()
);
return None;
}
let dcid = offset..offset + dcid_len;
offset += dcid_len;
if offset >= payload.len() {
debug!(
"QUIC: Payload too short for SCID length at offset {}",
offset
);
return None;
}
let scid_len = payload[offset] as usize;
offset += 1;
if offset + scid_len > payload.len() {
debug!(
"QUIC: Payload too short for SCID, need {} bytes, have {}",
offset + scid_len,
payload.len()
);
return None;
}
offset += scid_len;
let mut header = LongHeader {
version,
packet_type,
dcid,
layout: None,
};
if matches!(
packet_type,
QuicPacketType::Retry | QuicPacketType::VersionNegotiation
) {
return Some(header);
}
if packet_type == QuicPacketType::Initial {
let Some(token_len) = read_varint(payload, &mut offset) else {
return Some(header); };
match usize::try_from(token_len)
.ok()
.and_then(|len| len.checked_add(offset))
{
Some(new_offset) if new_offset <= payload.len() => offset = new_offset,
_ => {
debug!("QUIC: token_len pushed offset past end of packet");
return Some(header);
}
}
}
let Some(packet_length) = read_varint(payload, &mut offset) else {
return Some(header);
};
let Ok(packet_length) = usize::try_from(packet_length) else {
return Some(header);
};
header.layout = Some(PacketLayout {
pn_offset: offset,
packet_length,
});
Some(header)
}
pub(super) fn parse_long_header_packet_with_length(payload: &[u8]) -> (Option<QuicInfo>, usize) {
let Some(header) = parse_long_header(payload) else {
return (None, 0);
};
let mut quic_info = QuicInfo::new(header.version);
quic_info.packet_type = header.packet_type;
quic_info.connection_id = payload[header.dcid.clone()].to_vec();
quic_info.connection_id_hex = None;
let Some(layout) = header.layout else {
if matches!(
header.packet_type,
QuicPacketType::Retry | QuicPacketType::VersionNegotiation
) {
extract_tls_from_long_header_packet(payload, &mut quic_info, &header);
}
return (Some(quic_info), payload.len());
};
let Some(total_packet_size) = layout.pn_offset.checked_add(layout.packet_length) else {
return (Some(quic_info), payload.len());
};
debug!(
"QUIC: Long header packet - header_len={}, packet_length={}, total={}",
layout.pn_offset, layout.packet_length, total_packet_size
);
let packet_data = if total_packet_size <= payload.len() {
&payload[..total_packet_size]
} else {
payload };
extract_tls_from_long_header_packet(packet_data, &mut quic_info, &header);
(Some(quic_info), total_packet_size.min(payload.len()))
}
fn extract_tls_from_long_header_packet(
payload: &[u8],
quic_info: &mut QuicInfo,
header: &LongHeader,
) {
let LongHeader {
version,
packet_type,
layout,
..
} = *header;
let dcid = &payload[header.dcid.clone()];
let dcid_len = dcid.len();
quic_info.connection_state = match packet_type {
QuicPacketType::Initial => QuicConnectionState::Initial,
QuicPacketType::Handshake => QuicConnectionState::Handshaking,
QuicPacketType::Retry => QuicConnectionState::Initial,
QuicPacketType::VersionNegotiation => QuicConnectionState::Initial,
QuicPacketType::ZeroRtt => QuicConnectionState::Handshaking,
_ => QuicConnectionState::Unknown,
};
match packet_type {
QuicPacketType::Initial if dcid_len > 0 => {
debug!("QUIC: Processing Initial packet with DCID len={}", dcid_len);
if let Some(decrypted_payload) = layout
.and_then(|layout| decrypt_client_initial_packet(payload, dcid, version, layout))
{
debug!("QUIC: Successfully decrypted Client Initial packet");
if let Some(tls_info) =
process_crypto_frames_in_packet(&decrypted_payload, quic_info)
{
quic_info.tls_info = Some(tls_info);
quic_info.connection_id_hex = Some(hex_encode(dcid, ":"));
debug!(
"QUIC: Marking Client Initial packet with DCID {} for connection tracking",
hex_encode(dcid, ":")
);
}
} else {
debug!(
"QUIC: Failed to decrypt Initial packet as client first flight - DCID={:02x?}, version=0x{:08x}, payload_len={}",
dcid,
version,
payload.len()
);
}
}
QuicPacketType::Handshake if dcid_len > 0 => {
debug!("QUIC: Processing Handshake packet - encrypted, cannot extract TLS info");
}
QuicPacketType::Initial => {
debug!("QUIC: Initial packet has zero-length DCID - cannot derive decryption keys");
debug!(
"QUIC: Packet details - version=0x{:08x}, payload_len={}, packet_type={:?}",
version,
payload.len(),
packet_type
);
}
_ => {
debug!(
"QUIC: Packet type {:?} not processed for TLS extraction",
packet_type
);
}
}
}
fn parse_short_header_packet(payload: &[u8]) -> Option<QuicInfo> {
if payload.is_empty() {
return None;
}
if (payload[0] & 0xc0) != 0x40 {
return None;
}
let mut quic_info = QuicInfo::new(0);
quic_info.packet_type = QuicPacketType::OneRtt;
quic_info.connection_state = QuicConnectionState::Connected;
quic_info.connection_id = if payload.len() >= 9 {
payload[1..9].to_vec()
} else {
payload[1..].to_vec()
};
quic_info.connection_id_hex = None;
Some(quic_info)
}
fn process_crypto_frames_in_packet(payload: &[u8], quic_info: &mut QuicInfo) -> Option<TlsInfo> {
quic_info.ensure_reassembler();
let mut found_crypto_frames = false;
if scan_packet_frames(payload, quic_info, &mut found_crypto_frames).is_none() {
debug!("QUIC: Frame walk stopped early on malformed or truncated frame");
}
if found_crypto_frames
&& let Some(reassembler) = &mut quic_info.crypto_reassembler
&& let Some(tls_info) = try_extract_tls_from_reassembler(reassembler, false)
{
debug!(
"QUIC: Successfully extracted TLS info: SNI={:?}",
tls_info.sni
);
quic_info.tls_info = Some(tls_info.clone());
return Some(tls_info);
}
None
}
fn scan_packet_frames(
payload: &[u8],
quic_info: &mut QuicInfo,
found_crypto_frames: &mut bool,
) -> Option<()> {
let mut offset = 0;
while offset < payload.len() {
let frame_type_byte = payload[offset];
offset += 1;
match frame_type_byte {
0x00 => {
while offset < payload.len() && payload[offset] == 0x00 {
offset += 1;
}
}
0x01 => {
debug!("QUIC: Found PING frame");
}
0x02 | 0x03 => {
debug!("QUIC: Found ACK frame");
skip_varints(payload, &mut offset, 2)?;
let ack_range_count = read_varint(payload, &mut offset)?;
read_varint(payload, &mut offset)?;
skip_varints(payload, &mut offset, ack_range_count.saturating_mul(2))?;
if frame_type_byte == 0x03 {
skip_varints(payload, &mut offset, 3)?;
}
}
0x04 => {
skip_varints(payload, &mut offset, 3)?;
}
0x05 => {
skip_varints(payload, &mut offset, 2)?;
}
0x06 => {
debug!("QUIC: Found CRYPTO frame");
*found_crypto_frames = true;
quic_info.has_crypto_frame = true;
let crypto_offset = read_varint(payload, &mut offset)?;
let crypto_length = read_varint(payload, &mut offset)?;
debug!(
"QUIC: CRYPTO frame - offset={}, length={}",
crypto_offset, crypto_length
);
let crypto_len = usize::try_from(crypto_length).ok()?;
let available = (payload.len() - offset).min(crypto_len);
if available > 0 {
let crypto_data = payload[offset..offset + available].to_vec();
if let Some(reassembler) = &mut quic_info.crypto_reassembler
&& let Err(e) = reassembler.add_fragment(crypto_offset, crypto_data)
{
warn!("QUIC: Failed to add CRYPTO fragment: {}", e);
}
}
offset += available;
}
0x07 => {
let token_length = read_varint(payload, &mut offset)?;
offset = offset.checked_add(usize::try_from(token_length).ok()?)?;
if offset > payload.len() {
break;
}
}
0x08..=0x0f => {
let has_offset = (frame_type_byte & 0x04) != 0;
let has_length = (frame_type_byte & 0x02) != 0;
read_varint(payload, &mut offset)?;
if has_offset {
read_varint(payload, &mut offset)?;
}
let stream_data_len = if has_length {
usize::try_from(read_varint(payload, &mut offset)?).ok()?
} else {
payload.len() - offset
};
offset = offset.checked_add(stream_data_len)?;
if offset > payload.len() {
break;
}
}
0x10..=0x17 => {
let num_vars = match frame_type_byte {
0x10 | 0x12 | 0x13 | 0x14 | 0x16 | 0x17 => 1,
0x11 | 0x15 => 2,
_ => 0,
};
skip_varints(payload, &mut offset, num_vars)?;
}
0x18 => {
skip_varints(payload, &mut offset, 2)?;
if offset >= payload.len() {
break;
}
let cid_length = payload[offset] as usize;
offset = offset.checked_add(1 + cid_length + 16)?; if offset > payload.len() {
break;
}
}
0x19 => {
read_varint(payload, &mut offset)?;
}
0x1a | 0x1b => {
offset += 8;
}
0x1c | 0x1d => {
let error_code = read_varint(payload, &mut offset)?;
if frame_type_byte == 0x1c {
read_varint(payload, &mut offset)?;
}
let reason_length = read_varint(payload, &mut offset)?;
let reason_len = usize::try_from(reason_length).ok()?;
let reason_end = offset.checked_add(reason_len)?;
let reason = if reason_length > 0 && reason_end <= payload.len() {
let reason_bytes = &payload[offset..reason_end];
String::from_utf8(reason_bytes.to_vec()).ok()
} else {
None
};
quic_info.connection_close = Some(crate::network::types::QuicCloseInfo {
frame_type: frame_type_byte,
error_code,
});
quic_info.connection_state = if error_code == 0 {
crate::network::types::QuicConnectionState::Draining
} else {
crate::network::types::QuicConnectionState::Closed
};
debug!(
"QUIC: Detected CONNECTION_CLOSE frame type 0x{:02x}, error_code: {}, reason: {:?}",
frame_type_byte, error_code, reason
);
offset = reason_end;
if offset > payload.len() {
break;
}
}
0x1e => {
debug!("QUIC: Found HANDSHAKE_DONE frame");
}
_ => {
warn!(
"QUIC: Unknown frame type 0x{:02x}, stopping",
frame_type_byte
);
break;
}
}
if offset > payload.len() {
warn!("QUIC: Frame parsing exceeded payload length");
break;
}
}
Some(())
}
fn read_varint(payload: &[u8], offset: &mut usize) -> Option<u64> {
let (value, bytes_read) = parse_variable_length_int(payload.get(*offset..)?)?;
*offset += bytes_read;
Some(value)
}
fn skip_varints(payload: &[u8], offset: &mut usize, count: u64) -> Option<()> {
for _ in 0..count {
read_varint(payload, offset)?;
}
Some(())
}
fn parse_variable_length_int(data: &[u8]) -> Option<(u64, usize)> {
if data.is_empty() {
return None;
}
let first_byte = data[0];
let len = match first_byte >> 6 {
0 => 1,
1 => 2,
2 => 4,
3 => 8,
_ => return None,
};
if data.len() < len {
return None;
}
let value = match len {
1 => (first_byte & 0x3f) as u64,
2 => {
let val = u16::from_be_bytes([data[0] & 0x3f, data[1]]);
val as u64
}
4 => {
let val = u32::from_be_bytes([data[0] & 0x3f, data[1], data[2], data[3]]);
val as u64
}
8 => u64::from_be_bytes([
data[0] & 0x3f,
data[1],
data[2],
data[3],
data[4],
data[5],
data[6],
data[7],
]),
_ => return None,
};
Some((value, len))
}
fn get_long_packet_type(first_byte: u8, version: u32) -> QuicPacketType {
let type_bits = (first_byte & 0x30) >> 4;
if is_quic_v2(version) {
match type_bits {
0 => QuicPacketType::Retry,
1 => QuicPacketType::Initial,
2 => QuicPacketType::ZeroRtt,
3 => QuicPacketType::Handshake,
_ => QuicPacketType::Unknown,
}
} else {
match type_bits {
0 => QuicPacketType::Initial,
1 => QuicPacketType::ZeroRtt,
2 => QuicPacketType::Handshake,
3 => QuicPacketType::Retry,
_ => QuicPacketType::Unknown,
}
}
}
pub(super) fn is_quic_v2(version: u32) -> bool {
version == 0x6b3343cf
}
pub(in crate::network::dpi) fn is_quic_packet(payload: &[u8]) -> bool {
if payload.len() < 5 {
return false;
}
let first_byte = payload[0];
if (first_byte & 0x80) != 0 {
let version = u32::from_be_bytes([payload[1], payload[2], payload[3], payload[4]]);
let known_versions = [
0x00000001, 0x6b3343cf, 0xff00001d, 0xff00001c, 0xff00001b, 0x51303530, 0x51303433, 0x54303530, 0xfaceb001, 0xfaceb002, 0, ];
if known_versions.contains(&version) {
return true;
}
if (version >> 8) == 0xff0000 {
return true;
}
if (version & 0x0F0F0F0F) == 0x0a0a0a0a {
return true;
}
}
if (first_byte & 0xc0) == 0x40 {
return payload.len() >= 20;
}
false
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn oversized_frame_lengths_do_not_wrap_into_following_frames() {
for length in [u32::MAX as u64, 1u64 << 32, (1u64 << 62) - 1] {
for prefix in [&[0x07][..], &[0x0a, 0], &[0x1c, 0, 0], &[0x1d, 0]] {
let mut bytes = prefix.to_vec();
bytes.extend_from_slice(&(length | (3u64 << 62)).to_be_bytes());
bytes.extend_from_slice(&[0x06, 0, 1, 0x01]);
let mut info = QuicInfo::new(1);
info.ensure_reassembler();
let mut found_crypto = false;
let _ = scan_packet_frames(&bytes, &mut info, &mut found_crypto);
assert!(!found_crypto);
assert!(
info.crypto_reassembler
.unwrap()
.get_fragments()
.next()
.is_none()
);
}
}
}
#[test]
fn test_long_header_huge_token_length_does_not_panic() {
let mut pkt = Vec::new();
pkt.push(0xC0);
pkt.extend_from_slice(&0x0000_0001u32.to_be_bytes());
pkt.push(0); pkt.push(0); pkt.extend_from_slice(&[0xC8, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0xCA, 0x67]);
pkt.extend(std::iter::repeat_n(0u8, 64));
let (info, consumed) = parse_long_header_packet_with_length(&pkt);
assert!(info.is_some(), "should still surface a QuicInfo");
assert_eq!(
consumed,
pkt.len(),
"unparseable token length should cause us to treat the rest of the datagram as consumed"
);
}
#[test]
fn test_initial_packet_oversized_token_len_does_not_panic() {
let mut packet = Vec::new();
packet.push(0xC0); packet.extend_from_slice(&1u32.to_be_bytes()); packet.push(0); packet.push(0); let token_varint: u16 = 1000 | 0x4000;
packet.extend_from_slice(&token_varint.to_be_bytes());
let header = parse_long_header(&packet).expect("fixed fields should parse");
assert_eq!(header.packet_type, QuicPacketType::Initial);
assert!(header.layout.is_none());
let (info, consumed) = parse_long_header_packet_with_length(&packet);
assert!(
info.expect("should still surface a QuicInfo")
.tls_info
.is_none()
);
assert_eq!(consumed, packet.len());
}
#[test]
fn test_version_negotiation_consumes_rest_of_datagram() {
let mut pkt = vec![0x80u8]; pkt.extend_from_slice(&0u32.to_be_bytes()); pkt.push(8);
pkt.extend_from_slice(&[0xaa; 8]); pkt.push(0); pkt.extend_from_slice(&1u32.to_be_bytes());
pkt.extend_from_slice(&0x6b3343cfu32.to_be_bytes());
let (info, consumed) = parse_long_header_packet_with_length(&pkt);
let info = info.expect("Version Negotiation packet should parse");
assert_eq!(info.packet_type, QuicPacketType::VersionNegotiation);
assert_eq!(consumed, pkt.len());
}
#[test]
fn test_short_header_requires_fixed_bit() {
assert!(parse_short_header_packet(&[0x00; 30]).is_none());
assert!(parse_short_header_packet(&[0x41; 30]).is_some());
}
#[test]
fn test_initial_salt_for_version_mapping() {
assert_eq!(initial_salt_for_version(0x00000001), INITIAL_SALT_V1);
assert_eq!(initial_salt_for_version(0x6b3343cf), INITIAL_SALT_V2);
assert_eq!(initial_salt_for_version(0xff00001d), INITIAL_SALT_DRAFT_29); assert_eq!(initial_salt_for_version(0xff000020), INITIAL_SALT_DRAFT_29); assert_eq!(initial_salt_for_version(0xff00001b), INITIAL_SALT_DRAFT_23); assert_eq!(initial_salt_for_version(0xfaceb002), INITIAL_SALT_DRAFT_23); assert_eq!(initial_salt_for_version(0xff000022), INITIAL_SALT_V1); }
}