use crate::network::dpi::tls_common::{
self, TlsParseOptions, is_partial_sni, parse_sni_extension, parse_sni_header,
};
use crate::network::types::{CryptoFrameReassembler, TlsInfo};
use log::debug;
use super::salvage::{try_parse_unencrypted_crypto_frames, try_reconstruct_sni_from_fragments};
fn is_complete_sni(sni: &Option<String>) -> bool {
match sni {
Some(s) => !is_partial_sni(s),
None => false,
}
}
fn try_extract_from_contiguous(reassembled: &[u8], allow_partial: bool) -> Option<TlsInfo> {
debug!(
"QUIC: Attempting to parse {} bytes of contiguous crypto data (allow_partial={})",
reassembled.len(),
allow_partial
);
let tls_info = parse_partial_tls_handshake(reassembled, allow_partial)?;
if tls_info.sni.is_none() && tls_info.alpn.is_empty() {
return None;
}
let sni_is_complete = is_complete_sni(&tls_info.sni);
debug!(
"QUIC: Found TLS info from contiguous data (complete={})",
sni_is_complete
);
Some(tls_info)
}
fn try_extract_from_fragments(
reassembler: &CryptoFrameReassembler,
allow_partial: bool,
) -> Option<TlsInfo> {
debug!("QUIC: Trying to parse individual crypto fragments with proper TLS headers");
for (offset, fragment_data) in reassembler.get_fragments() {
debug!(
"QUIC: Trying fragment at offset {} with {} bytes",
offset,
fragment_data.len()
);
if fragment_data.len() >= 4
&& fragment_data[0] == 0x01
&& let Some(tls_info) = parse_partial_tls_handshake(fragment_data, allow_partial)
&& (tls_info.sni.is_some() || !tls_info.alpn.is_empty())
{
let sni_is_complete = is_complete_sni(&tls_info.sni);
debug!(
"QUIC: Found TLS info from individual fragment at offset {} (complete={})",
offset, sni_is_complete
);
return Some(tls_info);
}
if fragment_data.len() >= 6
&& fragment_data[0] == 0x16
&& let Some(tls_info) = try_parse_unencrypted_crypto_frames(fragment_data)
&& (tls_info.sni.is_some() || !tls_info.alpn.is_empty())
{
let sni_is_complete = is_complete_sni(&tls_info.sni);
debug!(
"QUIC: Found TLS info from pattern matching in fragment at offset {} (complete={})",
offset, sni_is_complete
);
return Some(tls_info);
}
debug!(
"QUIC: Skipping fragment at offset {} - doesn't start with TLS header",
offset
);
}
None
}
fn try_extract_greedy_from_reassembler(
reassembler: &CryptoFrameReassembler,
contiguous: Option<&[u8]>,
allow_partial: bool,
) -> Option<TlsInfo> {
debug!("QUIC: Attempting greedy SNI extraction as final fallback");
for (_, fragment_data) in reassembler.get_fragments() {
if let Some(sni) =
scan_for_sni_extension(fragment_data, allow_partial, SniScanStrictness::Lenient)
{
debug!("QUIC: Greedy extraction succeeded from fragment");
return Some(TlsInfo::with_sni(sni));
}
}
if let Some(contiguous) = contiguous
&& let Some(sni) =
scan_for_sni_extension(contiguous, allow_partial, SniScanStrictness::Lenient)
{
debug!("QUIC: Greedy extraction succeeded from contiguous data");
return Some(TlsInfo::with_sni(sni));
}
None
}
pub fn try_extract_tls_from_reassembler(
reassembler: &mut CryptoFrameReassembler,
allow_partial: bool,
) -> Option<TlsInfo> {
if reassembler.extraction_finished() {
return reassembler.get_cached_tls_info().cloned();
}
let contiguous = reassembler.get_contiguous_data();
if let Some(data) = &contiguous
&& data.len() >= 4
&& data[0] == 0x01
{
let handshake_end = 4 + u32::from_be_bytes([0, data[1], data[2], data[3]]) as usize;
let inspected_end = handshake_end.min(CryptoFrameReassembler::MAX_BUFFER_SIZE);
if data.len() >= inspected_end {
let tls_info = if handshake_end <= CryptoFrameReassembler::MAX_BUFFER_SIZE {
parse_partial_tls_handshake(&data[..inspected_end], allow_partial)
} else {
extract_provisional_tls(reassembler, contiguous.as_deref(), allow_partial)
};
reassembler.finish_extraction(tls_info.clone());
return tls_info;
}
}
extract_provisional_tls(reassembler, contiguous.as_deref(), allow_partial)
}
fn extract_provisional_tls(
reassembler: &CryptoFrameReassembler,
contiguous: Option<&[u8]>,
allow_partial: bool,
) -> Option<TlsInfo> {
if let Some(tls_info) = contiguous
.and_then(|data| try_extract_from_contiguous(data, allow_partial))
.or_else(|| try_extract_from_fragments(reassembler, allow_partial))
{
return Some(tls_info);
}
let total_fragment_size: usize = reassembler.get_fragments().map(|(_, v)| v.len()).sum();
if total_fragment_size >= 100 {
debug!(
"QUIC: Have {} total bytes in fragments, attempting reconstruction",
total_fragment_size
);
if let Some(sni) = try_reconstruct_sni_from_fragments(reassembler)
&& (allow_partial || !is_partial_sni(&sni))
{
let sni_is_complete = !is_partial_sni(&sni);
let tls_info = TlsInfo::with_sni(sni);
debug!(
"QUIC: Reconstructed SNI from fragmented data (complete={})",
sni_is_complete
);
return Some(tls_info);
}
} else {
debug!(
"QUIC: Only {} total bytes in fragments, not enough for reliable SNI extraction",
total_fragment_size
);
}
if let Some(tls_info) =
try_extract_greedy_from_reassembler(reassembler, contiguous, allow_partial)
{
return Some(tls_info);
}
debug!("QUIC: No TLS info could be extracted from reassembler");
None
}
pub(super) fn parse_partial_tls_handshake(data: &[u8], allow_partial: bool) -> Option<TlsInfo> {
let mut info = TlsInfo::new();
if !tls_common::parse_handshake(data, &mut info, TlsParseOptions::quic(allow_partial)) {
return None;
}
debug!(
"QUIC: Parsed TLS info - SNI={:?}, ALPN={:?}, version={:?}",
info.sni, info.alpn, info.version
);
if info.sni.is_some() || !info.alpn.is_empty() || info.version.is_some() {
Some(info)
} else {
debug!("QUIC: No useful TLS info extracted");
None
}
}
#[derive(Clone, Copy)]
pub(super) enum SniScanStrictness {
Lenient,
Moderate,
Strict,
}
pub(super) fn match_sni_extension_at(
data: &[u8],
i: usize,
allow_partial: bool,
strictness: SniScanStrictness,
) -> Option<String> {
let min_tail = match strictness {
SniScanStrictness::Lenient => 9,
SniScanStrictness::Moderate => 10,
SniScanStrictness::Strict => 20,
};
if i + min_tail >= data.len() {
return None;
}
if data[i] != 0x00 || data[i + 1] != 0x00 {
return None;
}
let ext_len = u16::from_be_bytes([data[i + 2], data[i + 3]]) as usize;
if !(5..=300).contains(&ext_len) {
return None;
}
let ext_data = match strictness {
SniScanStrictness::Lenient => &data[i + 4..],
SniScanStrictness::Moderate => {
if i + 4 + ext_len <= data.len() {
&data[i + 4..i + 4 + ext_len]
} else {
&data[i + 4..]
}
}
SniScanStrictness::Strict => {
if i + 4 + ext_len > data.len() {
return None;
}
&data[i + 4..i + 4 + ext_len]
}
};
let header = parse_sni_header(ext_data)?;
let list_len = header.list_len as usize;
let header_plausible = match strictness {
SniScanStrictness::Lenient => list_len <= ext_len,
SniScanStrictness::Moderate => (3..=256).contains(&list_len),
SniScanStrictness::Strict => {
(3..=256).contains(&list_len) && list_len == header.name_len as usize + 3
}
};
if !header_plausible {
return None;
}
parse_sni_extension(ext_data, allow_partial)
}
pub(super) fn scan_for_sni_extension(
data: &[u8],
allow_partial: bool,
strictness: SniScanStrictness,
) -> Option<String> {
(0..data.len()).find_map(|i| match_sni_extension_at(data, i, allow_partial, strictness))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::network::dpi::tls_common::test_fixtures::build_sni_extension;
#[test]
fn full_client_hello_releases_bytes_only_after_late_metadata_is_parsed() {
use crate::network::dpi::tls_common::test_fixtures::{RFC9001_CLIENT_HELLO, from_hex};
use crate::network::types::TlsVersion;
let hello = from_hex(RFC9001_CLIENT_HELLO);
let split = hello
.windows(11)
.position(|bytes| bytes == b"example.com")
.unwrap()
+ 11;
let mut reassembler = CryptoFrameReassembler::new();
reassembler
.add_fragment(0, hello[..split].to_vec())
.unwrap();
let provisional = try_extract_tls_from_reassembler(&mut reassembler, false).unwrap();
assert_eq!(provisional.sni.as_deref(), Some("example.com"));
assert!(provisional.alpn.is_empty());
assert!(!reassembler.extraction_finished());
reassembler
.add_fragment(split as u64, hello[split..].to_vec())
.unwrap();
let complete = try_extract_tls_from_reassembler(&mut reassembler, false).unwrap();
assert_eq!(complete.sni.as_deref(), Some("example.com"));
assert_eq!(complete.alpn, vec!["alpn"]);
assert_eq!(complete.version, Some(TlsVersion::Tls13));
assert!(reassembler.extraction_finished());
assert!(reassembler.get_fragments().next().is_none());
reassembler.add_fragment(0, hello).unwrap();
assert!(reassembler.get_fragments().next().is_none());
assert_eq!(
try_extract_tls_from_reassembler(&mut reassembler, false)
.unwrap()
.alpn,
vec!["alpn"]
);
}
#[test]
fn client_hello_without_sni_finishes_and_releases_bytes() {
use crate::network::dpi::tls_common::test_fixtures::build_client_hello;
let hello = build_client_hello(&[0, 16, 0, 5, 0, 3, 2, b'h', b'3']);
let mut reassembler = CryptoFrameReassembler::new();
reassembler.add_fragment(0, hello).unwrap();
let info = try_extract_tls_from_reassembler(&mut reassembler, false).unwrap();
assert!(info.sni.is_none());
assert_eq!(info.alpn, vec!["h3"]);
assert!(reassembler.extraction_finished());
assert!(reassembler.get_fragments().next().is_none());
}
#[test]
fn oversized_client_hello_stops_at_the_inspection_window() {
use crate::network::dpi::tls_common::test_fixtures::build_client_hello;
let mut hello = build_client_hello(&build_sni_extension("example.com"));
hello[1..4].copy_from_slice(&[1, 0, 1]);
hello.resize(CryptoFrameReassembler::MAX_BUFFER_SIZE + 10, 0);
let mut reassembler = CryptoFrameReassembler::new();
reassembler.add_fragment(0, hello).unwrap();
let info = try_extract_tls_from_reassembler(&mut reassembler, false).unwrap();
assert_eq!(info.sni.as_deref(), Some("example.com"));
assert!(reassembler.extraction_finished());
assert!(reassembler.get_fragments().next().is_none());
}
#[test]
fn partial_salvage_is_not_cached_as_complete() {
let mut fragment = build_sni_extension("example.com");
fragment.truncate(fragment.len() - 3);
let mut reassembler = CryptoFrameReassembler::new();
reassembler.add_fragment(10, fragment).unwrap();
assert!(try_extract_tls_from_reassembler(&mut reassembler, false).is_none());
let partial = try_extract_tls_from_reassembler(&mut reassembler, true).unwrap();
assert_eq!(partial.sni.as_deref(), Some("example.[PARTIAL]"));
assert!(!reassembler.extraction_finished());
assert!(reassembler.get_cached_tls_info().is_none());
assert!(reassembler.get_fragments().next().is_some());
}
#[test]
fn test_greedy_sni_extraction_complete() {
let sni_ext = build_sni_extension("www.example.com");
let result = scan_for_sni_extension(&sni_ext, false, SniScanStrictness::Lenient);
assert_eq!(result, Some("www.example.com".to_string()));
}
#[test]
fn test_greedy_sni_extraction_with_prefix() {
let mut data = vec![0x01, 0x02, 0x03, 0x04, 0x05];
data.extend(build_sni_extension("api.google.com"));
let result = scan_for_sni_extension(&data, false, SniScanStrictness::Lenient);
assert_eq!(result, Some("api.google.com".to_string()));
}
#[test]
fn test_greedy_sni_extraction_partial() {
let mut data = Vec::new();
data.push(0x00); data.push(0x00);
data.extend_from_slice(&20u16.to_be_bytes()); data.extend_from_slice(&18u16.to_be_bytes()); data.push(0x00); data.extend_from_slice(&15u16.to_be_bytes()); data.extend_from_slice(b"www.examp");
let result = scan_for_sni_extension(&data, false, SniScanStrictness::Lenient);
assert_eq!(result, None);
let result = scan_for_sni_extension(&data, true, SniScanStrictness::Lenient);
assert_eq!(result, Some("www.examp[PARTIAL]".to_string()));
}
#[test]
fn test_greedy_extraction_ignores_invalid_patterns() {
let data = vec![0x00, 0x00, 0x00, 0x01, 0x00]; let result = scan_for_sni_extension(&data, true, SniScanStrictness::Lenient);
assert_eq!(result, None);
}
#[test]
fn test_greedy_extraction_multiple_zeros() {
let mut data = vec![0x00, 0x00, 0x00, 0x02, 0xFF]; data.extend(build_sni_extension("valid.example.com"));
let result = scan_for_sni_extension(&data, false, SniScanStrictness::Lenient);
assert_eq!(result, Some("valid.example.com".to_string()));
}
}