use crate::network::types::{TlsInfo, TlsVersion};
use log::debug;
const MAX_TLS_EXTENSIONS: usize = 100;
const MAX_HANDSHAKE_LENGTH: usize = 65536;
const PARTIAL_SNI_MIN_LENGTH: usize = 3;
const PARTIAL_SNI_MARKER: &str = "[PARTIAL]";
#[derive(Clone, Copy, PartialEq, Eq)]
pub(in crate::network::dpi) enum TlsTransport {
Tcp,
Quic,
}
#[derive(Clone, Copy)]
pub(in crate::network::dpi) struct TlsParseOptions {
pub transport: TlsTransport,
pub allow_partial: bool,
}
impl TlsParseOptions {
pub(super) fn tcp() -> Self {
Self {
transport: TlsTransport::Tcp,
allow_partial: true,
}
}
pub(super) fn quic(allow_partial: bool) -> Self {
Self {
transport: TlsTransport::Quic,
allow_partial,
}
}
fn clamp_truncated_extensions(&self) -> bool {
self.transport == TlsTransport::Tcp
}
fn use_legacy_version(&self) -> bool {
self.transport == TlsTransport::Tcp
}
fn assume_tls13(&self) -> bool {
self.transport == TlsTransport::Quic
}
fn emit_partial_alpn(&self) -> bool {
self.transport == TlsTransport::Tcp
}
}
pub(in crate::network::dpi) fn is_valid_hostname(hostname: &str) -> bool {
if hostname.len() < 4 || hostname.len() > 253 {
return false;
}
if !hostname.contains('.') {
return false;
}
if !hostname
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '-')
{
return false;
}
if hostname.starts_with('.')
|| hostname.ends_with('.')
|| hostname.starts_with('-')
|| hostname.ends_with('-')
{
return false;
}
if hostname.contains("..") {
return false;
}
if !hostname.chars().any(|c| c.is_ascii_alphabetic()) {
return false;
}
if !hostname
.split('.')
.all(|part| !part.is_empty() && part.len() <= 63)
{
return false;
}
true
}
fn is_valid_partial_hostname(hostname: &str) -> bool {
if hostname.len() < PARTIAL_SNI_MIN_LENGTH {
return false;
}
if !hostname
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '-')
{
return false;
}
if !hostname.chars().any(|c| c.is_ascii_alphabetic()) {
return false;
}
if hostname.starts_with('.') || hostname.starts_with('-') {
return false;
}
true
}
fn mark_partial_sni(hostname: &str) -> String {
format!("{}{}", hostname, PARTIAL_SNI_MARKER)
}
pub fn is_partial_sni(sni: &str) -> bool {
sni.ends_with(PARTIAL_SNI_MARKER)
}
pub(in crate::network::dpi) struct SniHeader {
pub list_len: u16,
pub name_len: u16,
}
pub(in crate::network::dpi) fn parse_sni_header(data: &[u8]) -> Option<SniHeader> {
if data.len() < 5 {
return None;
}
let list_len = u16::from_be_bytes([data[0], data[1]]);
let name_type = data[2];
let name_len = u16::from_be_bytes([data[3], data[4]]);
if name_type != 0x00 {
return None;
}
if name_len == 0 || name_len > 253 {
return None;
}
Some(SniHeader { list_len, name_len })
}
pub(in crate::network::dpi) fn version_from_bytes(major: u8, minor: u8) -> Option<TlsVersion> {
match (major, minor) {
(0x03, 0x01) => Some(TlsVersion::Tls10),
(0x03, 0x02) => Some(TlsVersion::Tls11),
(0x03, 0x03) => Some(TlsVersion::Tls12),
(0x03, 0x04) => Some(TlsVersion::Tls13),
_ => None,
}
}
fn version_to_priority(version: TlsVersion) -> u8 {
match version {
TlsVersion::Tls10 => 1,
TlsVersion::Tls11 => 2,
TlsVersion::Tls12 => 3,
TlsVersion::Tls13 => 4,
}
}
pub(in crate::network::dpi) fn parse_handshake(
data: &[u8],
info: &mut TlsInfo,
opts: TlsParseOptions,
) -> bool {
if data.len() < 4 {
return false;
}
let handshake_type = data[0];
let handshake_length = u32::from_be_bytes([0, data[1], data[2], data[3]]) as usize;
if handshake_length > MAX_HANDSHAKE_LENGTH {
debug!(
"TLS: Handshake length {} seems too large, skipping",
handshake_length
);
return false;
}
let available_data = &data[4..];
let parse_length = handshake_length.min(available_data.len());
if parse_length == 0 {
return false;
}
match handshake_type {
0x01 => {
parse_client_hello(&available_data[..parse_length], info, opts);
true
}
0x02 => {
parse_server_hello(&available_data[..parse_length], info, opts);
true
}
_ => false,
}
}
fn parse_client_hello(data: &[u8], info: &mut TlsInfo, opts: TlsParseOptions) {
if opts.use_legacy_version()
&& data.len() >= 2
&& let Some(version) = version_from_bytes(data[0], data[1])
{
info.version = Some(version);
}
let Some(mut offset) = skip_hello_prefix(data) else {
return;
};
if offset + 2 > data.len() {
return;
}
let cipher_suites_len = u16::from_be_bytes([data[offset], data[offset + 1]]) as usize;
offset += 2 + cipher_suites_len;
if offset >= data.len() {
return;
}
let compression_len = data[offset] as usize;
offset += 1 + compression_len;
parse_extensions_block(data, offset, info, true, opts);
}
fn skip_hello_prefix(data: &[u8]) -> Option<usize> {
if data.len() < 34 {
return None;
}
let offset = 34;
if offset >= data.len() {
return None;
}
let session_id_len = data[offset] as usize;
Some(offset + 1 + session_id_len)
}
fn parse_extensions_block(
data: &[u8],
offset: usize,
info: &mut TlsInfo,
is_client: bool,
opts: TlsParseOptions,
) {
if offset + 2 > data.len() {
return;
}
let extensions_len = u16::from_be_bytes([data[offset], data[offset + 1]]) as usize;
let offset = offset + 2;
let available_ext_len = (data.len() - offset).min(extensions_len);
if available_ext_len > 0 {
parse_extensions(
&data[offset..offset + available_ext_len],
info,
is_client,
opts,
);
}
}
fn parse_server_hello(data: &[u8], info: &mut TlsInfo, opts: TlsParseOptions) {
if opts.use_legacy_version() {
if data.len() < 2 {
return;
}
info.version = version_from_bytes(data[0], data[1]);
}
let Some(mut offset) = skip_hello_prefix(data) else {
return;
};
if offset + 2 > data.len() {
return;
}
let cipher = u16::from_be_bytes([data[offset], data[offset + 1]]);
info.cipher_suite = Some(cipher);
offset += 2;
if offset >= data.len() {
return;
}
offset += 1;
parse_extensions_block(data, offset, info, false, opts);
}
fn parse_extensions(data: &[u8], info: &mut TlsInfo, is_client: bool, opts: TlsParseOptions) {
let mut offset = 0;
let mut extensions_parsed = 0;
while offset + 4 <= data.len() {
extensions_parsed += 1;
if extensions_parsed > MAX_TLS_EXTENSIONS {
break;
}
let ext_type = u16::from_be_bytes([data[offset], data[offset + 1]]);
let ext_len = u16::from_be_bytes([data[offset + 2], data[offset + 3]]) as usize;
let available_ext_len = data.len() - offset - 4;
if ext_len > available_ext_len && !opts.clamp_truncated_extensions() {
if opts.allow_partial && ext_type == 0x0000 && is_client && available_ext_len > 5 {
debug!(
"TLS: SNI extension is incomplete (need {} bytes, have {}), attempting partial extraction",
ext_len, available_ext_len
);
if let Some(sni) = parse_sni_extension(&data[offset + 4..], true) {
info.sni = Some(sni);
}
}
break;
}
let ext_data_len = ext_len.min(available_ext_len);
if ext_data_len > 0 {
let ext_data = &data[offset + 4..offset + 4 + ext_data_len];
match ext_type {
0x0000 if is_client => {
if let Some(sni) = parse_sni_extension(ext_data, opts.allow_partial) {
info.sni = Some(sni);
}
}
0x0010 => {
if let Some(alpn) = parse_alpn_extension(ext_data, opts.emit_partial_alpn()) {
info.alpn = alpn;
}
}
0x002b => {
if opts.assume_tls13() {
info.version = Some(TlsVersion::Tls13);
} else if let Some(version) = parse_supported_versions(ext_data, is_client) {
info.version = Some(version);
}
}
_ => {}
}
}
offset += 4 + ext_len;
}
}
pub(in crate::network::dpi) fn parse_sni_extension(
data: &[u8],
allow_partial: bool,
) -> Option<String> {
let header = parse_sni_header(data)?;
let name_len = header.name_len as usize;
let hostname_start = 5;
if hostname_start + name_len <= data.len() {
let sni_data = &data[hostname_start..hostname_start + name_len];
match std::str::from_utf8(sni_data) {
Ok(sni) if is_valid_hostname(sni) => Some(sni.to_string()),
Ok(sni) => {
debug!("TLS: SNI doesn't look like a valid hostname: {}", sni);
None
}
Err(e) => {
debug!("TLS: SNI data is not valid UTF-8: {}", e);
None
}
}
} else if allow_partial && data.len() > hostname_start {
let available = &data[hostname_start..];
if let Ok(partial) = std::str::from_utf8(available)
&& is_valid_partial_hostname(partial)
{
return Some(mark_partial_sni(partial));
}
None
} else {
None
}
}
pub(in crate::network::dpi) fn parse_alpn_extension(
data: &[u8],
emit_partial: bool,
) -> Option<Vec<String>> {
if data.len() < 2 {
return None;
}
let mut protocols = Vec::new();
let alpn_len = u16::from_be_bytes([data[0], data[1]]) as usize;
let mut offset = 2;
let list_end = 2 + alpn_len.min(data.len() - 2);
while offset < list_end {
let proto_len = data[offset] as usize;
offset += 1;
let actual_len = proto_len.min(list_end - offset);
if actual_len > 0
&& let Ok(proto) = std::str::from_utf8(&data[offset..offset + actual_len])
{
if actual_len == proto_len {
protocols.push(proto.to_string());
} else if emit_partial {
protocols.push(mark_partial_sni(proto));
}
}
offset += proto_len;
}
if protocols.is_empty() {
None
} else {
Some(protocols)
}
}
fn parse_supported_versions(data: &[u8], is_client: bool) -> Option<TlsVersion> {
if is_client {
if data.is_empty() {
return None;
}
let list_len = data[0] as usize;
let mut offset = 1;
let mut best_version: Option<TlsVersion> = None;
while offset + 1 < data.len() && offset < 1 + list_len {
if let Some(version) = version_from_bytes(data[offset], data[offset + 1]) {
best_version = match best_version {
None => Some(version),
Some(current) => {
if version_to_priority(version) > version_to_priority(current) {
Some(version)
} else {
Some(current)
}
}
};
}
offset += 2;
}
best_version
} else {
if data.len() < 2 {
return None;
}
version_from_bytes(data[0], data[1])
}
}
#[cfg(test)]
pub(crate) mod test_fixtures {
pub(crate) const RFC9001_CLIENT_HELLO: &str = "
010000ed0303ebf8fa56f12939b9584a3896472ec40bb863cfd3e868
04fe3a47f06a2b69484c00000413011302010000c000000010000e00000b6578
616d706c652e636f6dff01000100000a00080006001d0017001800100007000504616c706e
0005000501000000000033002600
24001d00209370b2c9caa47fbabaf4559fedba753de171fa71f50f1ce15d43e9
94ec74d748002b0003020304000d0010000e04030503060302030804080508
06002d00020101001c00024001003900320408ffffffffffffffff0504800
0ffff07048000ffff0801100104800075300901100f088394c8f03e5157080
6048000ffff";
pub(crate) fn from_hex(s: &str) -> Vec<u8> {
let cleaned: Vec<u8> = s.bytes().filter(u8::is_ascii_hexdigit).collect();
cleaned
.chunks(2)
.map(|pair| u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap())
.collect()
}
pub(crate) fn build_sni_extension(hostname: &str) -> Vec<u8> {
let name_len = hostname.len() as u16;
let list_len = name_len + 3;
let mut ext = Vec::new();
ext.extend_from_slice(&0x0000u16.to_be_bytes()); ext.extend_from_slice(&(list_len + 2).to_be_bytes()); ext.extend_from_slice(&list_len.to_be_bytes());
ext.push(0x00); ext.extend_from_slice(&name_len.to_be_bytes());
ext.extend_from_slice(hostname.as_bytes());
ext
}
fn build_hello(handshake_type: u8, middle: &[u8], extensions: &[u8]) -> Vec<u8> {
let mut body = Vec::new();
body.extend_from_slice(&[0x03, 0x03]); body.extend_from_slice(&[0u8; 32]); body.push(0); body.extend_from_slice(middle);
body.extend_from_slice(&(extensions.len() as u16).to_be_bytes());
body.extend_from_slice(extensions);
let mut msg = vec![handshake_type];
msg.extend_from_slice(&(body.len() as u32).to_be_bytes()[1..]);
msg.extend_from_slice(&body);
msg
}
pub(crate) fn build_client_hello(extensions: &[u8]) -> Vec<u8> {
build_hello(0x01, &[0x00, 0x02, 0x13, 0x01, 0x01, 0x00], extensions)
}
pub(crate) fn build_server_hello(extensions: &[u8]) -> Vec<u8> {
build_hello(0x02, &[0x13, 0x01, 0x00], extensions)
}
}
#[cfg(test)]
mod tests {
use super::test_fixtures::{build_client_hello, build_server_hello, build_sni_extension};
use super::*;
#[test]
fn test_partial_sni_extraction() {
let partial_sni = vec![
0x00, 0x10, 0x00, 0x00, 0x0d, b'e', b'x', b'a', b'm', b'p', ];
let result = parse_sni_extension(&partial_sni, true);
assert_eq!(result, Some("examp[PARTIAL]".to_string()));
assert_eq!(parse_sni_extension(&partial_sni, false), None);
}
#[test]
fn test_partial_alpn_extraction() {
let partial_alpn = vec![
0x00, 0x0e, 0x08, b'h', b't', b't', b'p', ];
let result = parse_alpn_extension(&partial_alpn, true);
assert_eq!(result, Some(vec!["http[PARTIAL]".to_string()]));
assert_eq!(parse_alpn_extension(&partial_alpn, false), None);
}
#[test]
fn test_parse_sni_extension_complete() {
let hostname = "test.example.org";
let name_bytes = hostname.as_bytes();
let name_len = name_bytes.len() as u16;
let list_len = name_len + 3;
let mut data = Vec::new();
data.extend_from_slice(&list_len.to_be_bytes());
data.push(0x00); data.extend_from_slice(&name_len.to_be_bytes());
data.extend_from_slice(name_bytes);
let result = parse_sni_extension(&data, false);
assert_eq!(result, Some("test.example.org".to_string()));
}
#[test]
fn test_parse_sni_extension_partial() {
let mut data = Vec::new();
data.extend_from_slice(&20u16.to_be_bytes()); data.push(0x00); data.extend_from_slice(&15u16.to_be_bytes()); data.extend_from_slice(b"example.co");
let result = parse_sni_extension(&data, false);
assert_eq!(result, None);
let result = parse_sni_extension(&data, true);
assert_eq!(result, Some("example.co[PARTIAL]".to_string()));
}
#[test]
fn test_parse_alpn_extension() {
let mut data = Vec::new();
let protocols = vec!["h3", "h2"];
let mut proto_list = Vec::new();
for proto in &protocols {
proto_list.push(proto.len() as u8);
proto_list.extend_from_slice(proto.as_bytes());
}
data.extend_from_slice(&(proto_list.len() as u16).to_be_bytes());
data.extend_from_slice(&proto_list);
let result = parse_alpn_extension(&data, false);
assert_eq!(result, Some(vec!["h3".to_string(), "h2".to_string()]));
}
#[test]
fn test_is_valid_hostname() {
assert!(is_valid_hostname("example.com"));
assert!(is_valid_hostname("www.example.com"));
assert!(is_valid_hostname("sub.domain.example.org"));
assert!(is_valid_hostname("my-site.io"));
assert!(!is_valid_hostname("com")); assert!(!is_valid_hostname(".example.com")); assert!(!is_valid_hostname("example.com.")); assert!(!is_valid_hostname("-example.com")); assert!(!is_valid_hostname("example..com")); assert!(!is_valid_hostname("ab")); }
#[test]
fn test_truncated_extension_clamp_vs_wait() {
let mut ext = build_sni_extension("www.example.com");
ext.truncate(ext.len() - 6); let msg = build_client_hello(&ext);
let mut tcp_info = TlsInfo::new();
assert!(parse_handshake(&msg, &mut tcp_info, TlsParseOptions::tcp()));
assert_eq!(tcp_info.sni, Some("www.examp[PARTIAL]".to_string()));
let mut quic_wait = TlsInfo::new();
assert!(parse_handshake(
&msg,
&mut quic_wait,
TlsParseOptions::quic(false)
));
assert_eq!(quic_wait.sni, None);
let mut quic_partial = TlsInfo::new();
assert!(parse_handshake(
&msg,
&mut quic_partial,
TlsParseOptions::quic(true)
));
assert_eq!(quic_partial.sni, Some("www.examp[PARTIAL]".to_string()));
}
#[test]
fn test_extension_count_cap() {
let mut ext = Vec::new();
for _ in 0..200 {
ext.extend_from_slice(&0xffffu16.to_be_bytes());
ext.extend_from_slice(&0u16.to_be_bytes());
}
ext.extend_from_slice(&build_sni_extension("www.example.com"));
let msg = build_client_hello(&ext);
for opts in [TlsParseOptions::tcp(), TlsParseOptions::quic(true)] {
let mut info = TlsInfo::new();
assert!(parse_handshake(&msg, &mut info, opts));
assert_eq!(info.sni, None);
}
}
#[test]
fn test_large_handshake_accepted() {
let mut ext = build_sni_extension("www.example.com");
let padding_len = 20_000u16;
ext.extend_from_slice(&0x0015u16.to_be_bytes()); ext.extend_from_slice(&padding_len.to_be_bytes());
ext.extend_from_slice(&vec![0u8; padding_len as usize]);
let msg = build_client_hello(&ext);
assert!(msg.len() > 16384);
let mut info = TlsInfo::new();
assert!(parse_handshake(&msg, &mut info, TlsParseOptions::tcp()));
assert_eq!(info.sni, Some("www.example.com".to_string()));
}
fn assert_quic_tls13_tcp_tls12(msg: &[u8]) {
let mut quic_info = TlsInfo::new();
assert!(parse_handshake(
msg,
&mut quic_info,
TlsParseOptions::quic(false)
));
assert_eq!(quic_info.version, Some(TlsVersion::Tls13));
let mut tcp_info = TlsInfo::new();
assert!(parse_handshake(msg, &mut tcp_info, TlsParseOptions::tcp()));
assert_eq!(tcp_info.version, Some(TlsVersion::Tls12));
}
#[test]
fn test_supported_versions_assume_tls13_on_quic() {
let mut ext = Vec::new();
ext.extend_from_slice(&0x002bu16.to_be_bytes());
ext.extend_from_slice(&3u16.to_be_bytes());
ext.push(2); ext.extend_from_slice(&[0x7f, 0x1c]); assert_quic_tls13_tcp_tls12(&build_client_hello(&ext));
}
#[test]
fn test_quic_client_supported_versions_reports_tls13_for_older_value() {
let extensions = [
0x00, 0x2b, 0x00, 0x03, 0x02, 0x03, 0x03, ];
assert_quic_tls13_tcp_tls12(&build_client_hello(&extensions));
}
#[test]
fn test_quic_server_supported_versions_reports_tls13_for_older_value() {
let extensions = [
0x00, 0x2b, 0x00, 0x02, 0x03, 0x03, ];
assert_quic_tls13_tcp_tls12(&build_server_hello(&extensions));
}
#[test]
fn test_legacy_version_ignored_on_quic() {
let msg = build_client_hello(&build_sni_extension("www.example.com"));
let mut tcp_info = TlsInfo::new();
assert!(parse_handshake(&msg, &mut tcp_info, TlsParseOptions::tcp()));
assert_eq!(tcp_info.version, Some(TlsVersion::Tls12));
let mut quic_info = TlsInfo::new();
assert!(parse_handshake(
&msg,
&mut quic_info,
TlsParseOptions::quic(false)
));
assert_eq!(quic_info.version, None);
assert_eq!(quic_info.sni, Some("www.example.com".to_string()));
}
}