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 super::crypto::decrypt_client_initial_packet;
use super::tls::try_extract_tls_from_reassembler;
use crate::network::dpi::tls_common::is_partial_sni;
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)) => {
for (&frag_offset, data) in new_reassembler.get_fragments() {
if let Err(e) = existing_reassembler.add_fragment(frag_offset, data.clone())
{
warn!("QUIC: Failed to merge coalesced CRYPTO fragment: {}", e);
}
}
let sni_missing_or_partial = existing
.tls_info
.as_ref()
.and_then(|tls| tls.sni.as_ref())
.is_none_or(|s| is_partial_sni(s));
if sni_missing_or_partial
&& let Some(tls_info) =
try_extract_tls_from_reassembler(existing_reassembler, false)
{
existing.tls_info = Some(tls_info);
}
}
_ => {}
}
existing
}
}
}
pub(super) fn parse_long_header_packet_with_length(payload: &[u8]) -> (Option<QuicInfo>, usize) {
if payload.len() < 6 {
return (None, 0);
}
let first_byte = payload[0];
let version = u32::from_be_bytes([payload[1], payload[2], payload[3], payload[4]]);
let mut quic_info = QuicInfo::new(version);
let packet_type = if version == 0 {
QuicPacketType::VersionNegotiation
} else {
get_long_packet_type(first_byte, version)
};
quic_info.packet_type = packet_type;
let mut offset = 5;
if offset >= payload.len() {
debug!(
"QUIC: Payload too short to read DCID length at offset {}",
offset
);
return (None, 0);
}
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, 0);
}
let dcid_range = offset..offset + dcid_len;
quic_info.connection_id = payload[dcid_range.clone()].to_vec();
quic_info.connection_id_hex = None;
offset += dcid_len;
if offset >= payload.len() {
debug!(
"QUIC: Payload too short for SCID length at offset {}",
offset
);
return (None, 0);
}
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, 0);
}
offset += scid_len;
if matches!(
packet_type,
QuicPacketType::Retry | QuicPacketType::VersionNegotiation
) {
extract_tls_from_long_header_packet(
payload,
&mut quic_info,
&payload[dcid_range],
version,
packet_type,
);
return (Some(quic_info), payload.len());
}
if packet_type == QuicPacketType::Initial {
if let Some((token_len, bytes_read)) = parse_variable_length_int(&payload[offset..]) {
offset += bytes_read;
match (token_len as usize).checked_add(offset) {
Some(new_offset) if new_offset <= payload.len() => offset = new_offset,
_ => return (Some(quic_info), payload.len()),
}
} else {
return (Some(quic_info), payload.len()); }
}
if offset >= payload.len() {
return (Some(quic_info), payload.len());
}
let packet_length =
if let Some((pkt_len, bytes_read)) = parse_variable_length_int(&payload[offset..]) {
offset += bytes_read;
pkt_len as usize
} else {
return (Some(quic_info), payload.len());
};
let total_packet_size = offset.checked_add(packet_length).unwrap_or(payload.len());
debug!(
"QUIC: Long header packet - header_len={}, packet_length={}, total={}",
offset, 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,
&payload[dcid_range],
version,
packet_type,
);
(Some(quic_info), total_packet_size.min(payload.len()))
}
fn extract_tls_from_long_header_packet(
payload: &[u8],
quic_info: &mut QuicInfo,
dcid: &[u8],
version: u32,
packet_type: QuicPacketType,
) {
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) = decrypt_client_initial_packet(payload, dcid, version) {
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");
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
let (ack_range_count, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
for _ in 0..ack_range_count {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
if frame_type_byte == 0x03 {
for _ in 0..3 {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
}
}
0x04 => {
for _ in 0..3 {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
}
0x05 => {
for _ in 0..2 {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
}
0x06 => {
debug!("QUIC: Found CRYPTO frame");
*found_crypto_frames = true;
quic_info.has_crypto_frame = true;
let (crypto_offset, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
let (crypto_length, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
debug!(
"QUIC: CRYPTO frame - offset={}, length={}",
crypto_offset, crypto_length
);
let crypto_len = crypto_length as usize;
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, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset = offset
.checked_add(bytes_read)?
.checked_add(token_length as usize)?;
if offset > payload.len() {
break;
}
}
0x08..=0x0f => {
let has_offset = (frame_type_byte & 0x04) != 0;
let has_length = (frame_type_byte & 0x02) != 0;
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
if has_offset {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
let stream_data_len = if has_length {
let (length, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
length as usize
} 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,
};
for _ in 0..num_vars {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
}
0x18 => {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
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 => {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
0x1a | 0x1b => {
offset += 8;
}
0x1c | 0x1d => {
let (error_code, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
if frame_type_byte == 0x1c {
let (_, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
}
let (reason_length, bytes_read) = parse_variable_length_int(&payload[offset..])?;
offset += bytes_read;
let reason_len = reason_length as usize;
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(())
}
pub(super) 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 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_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); }
}