Files
telemt/src/transport/socket/fragmented_send_wire_tests.rs
T
Andrey Osipuk 7e6fc15ef2 feat(client_mss): chunk only the start of the initial server response
With client_mss_bulk the whole authenticated FakeTLS response (ServerHello,
CCS, emulated certificate records, tickets - typically ~4 KiB) was written in
client_mss-sized chunks: about 50 segments at `tspu`. With ~2% loss at least
one segment is lost in ~64% of handshakes, and the burst takes several RTTs
to pass the initial congestion window.

- New server.client_mss_prefix (Linux, requires client_mss_bulk): `full`
  (default, current behavior), `server-hello` (through the end of the first
  TLS record, capped at 2048 bytes, falls back to `full` on unexpected input)
  or a byte count. Only that prefix is written in MSG_EOR chunks; the rest
  goes out in one write at the bulk MSS.
- Chunk payload accounts for TCP timestamps and never exceeds tcpi_snd_mss.
- Removed TcpMaxSegmentGuard: TCP_MAXSEG on an established socket does not
  change the MSS of outgoing segments on Linux, and its getsockopt/setsockopt
  failures no longer abort the handshake. TCP_NODELAY is set once.
- Docs (en/ru/de), API discovery metadata, strict keys, reload diff.
2026-11-09 15:36:29 +03:00

252 lines
9.3 KiB
Rust

use std::net::SocketAddr;
use std::os::fd::{AsRawFd, BorrowedFd};
use std::path::Path;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use crate::config::ProxyConfig;
use crate::crypto::{SecureRandom, sha256_hmac};
use crate::error::HandshakeResult;
use crate::protocol::constants::TLS_VERSION;
use crate::protocol::tls;
use crate::proxy::handshake::{
TlsResponseFragmentation, TlsResponseWriteOptions, handle_tls_handshake_with_shared_and_options,
};
use crate::proxy::shared_state::ProxySharedState;
use crate::stats::ReplayChecker;
use crate::transport::socket::{ListenOptions, create_listener};
const SECRET: [u8; 16] = [0x56; 16];
const SECRET_HEX: &str = "56565656565656565656565656565656";
const BULK_PAYLOAD_LEN: usize = 8192;
fn make_valid_tls_client_hello(tls_len: usize) -> Vec<u8> {
const TLS_AES_128_GCM_SHA256: [u8; 2] = [0x13, 0x01];
const TLS_EXTENSION_KEY_SHARE: u16 = 0x0033;
const TLS_EXTENSION_PADDING: u16 = 0x0015;
const X25519_KEY_SHARE_LEN: usize = 32;
let fill = 0x42_u8;
let session_id_len = 32_usize;
let mut extensions = Vec::new();
let mut key_share = Vec::new();
key_share.extend_from_slice(&tls::TLS_NAMED_GROUP_X25519.to_be_bytes());
key_share.extend_from_slice(&(X25519_KEY_SHARE_LEN as u16).to_be_bytes());
key_share.push(9);
key_share.resize(key_share.len() + X25519_KEY_SHARE_LEN - 1, 0);
let mut key_share_extension = Vec::new();
key_share_extension.extend_from_slice(&(key_share.len() as u16).to_be_bytes());
key_share_extension.extend_from_slice(&key_share);
extensions.extend_from_slice(&TLS_EXTENSION_KEY_SHARE.to_be_bytes());
extensions.extend_from_slice(&(key_share_extension.len() as u16).to_be_bytes());
extensions.extend_from_slice(&key_share_extension);
let base_tls_len = 4
+ 2
+ 32
+ 1
+ session_id_len
+ 2
+ TLS_AES_128_GCM_SHA256.len()
+ 1
+ 1
+ 2
+ extensions.len();
let padding_len = tls_len
.checked_sub(base_tls_len + 4)
.expect("wire ClientHello must leave room for padding");
extensions.extend_from_slice(&TLS_EXTENSION_PADDING.to_be_bytes());
extensions.extend_from_slice(&(padding_len as u16).to_be_bytes());
extensions.resize(extensions.len() + padding_len, fill);
let body_len = tls_len - 4;
let mut body = Vec::with_capacity(body_len);
body.extend_from_slice(&TLS_VERSION);
body.extend_from_slice(&[fill; 32]);
body.push(session_id_len as u8);
body.extend_from_slice(&[fill; 32]);
body.extend_from_slice(&(TLS_AES_128_GCM_SHA256.len() as u16).to_be_bytes());
body.extend_from_slice(&TLS_AES_128_GCM_SHA256);
body.push(1);
body.push(0);
body.extend_from_slice(&(extensions.len() as u16).to_be_bytes());
body.extend_from_slice(&extensions);
let mut handshake = Vec::with_capacity(5 + tls_len);
handshake.push(0x16);
handshake.extend_from_slice(&[0x03, 0x01]);
handshake.extend_from_slice(&(tls_len as u16).to_be_bytes());
handshake.push(0x01);
handshake.extend_from_slice(&(body_len as u32).to_be_bytes()[1..].as_ref());
handshake.extend_from_slice(&body);
handshake[tls::TLS_DIGEST_POS..tls::TLS_DIGEST_POS + tls::TLS_DIGEST_LEN].fill(0);
let digest = sha256_hmac(&SECRET, &handshake);
handshake[tls::TLS_DIGEST_POS..tls::TLS_DIGEST_POS + tls::TLS_DIGEST_LEN]
.copy_from_slice(&digest);
handshake
}
async fn wait_for_file(path: &Path) {
tokio::time::timeout(Duration::from_secs(10), async {
while !path.exists() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("wire-test release barrier timed out");
}
async fn run_server(
addr: SocketAddr,
fragmentation: TlsResponseFragmentation,
fake_cert_len: usize,
) {
let socket = create_listener(
addr,
&ListenOptions {
reuse_port: false,
client_mss: Some(1400),
..Default::default()
},
)
.unwrap();
let listener = TcpListener::from_std(socket.into()).unwrap();
let (mut server, peer) = listener.accept().await.unwrap();
let mut header = [0_u8; 5];
server.read_exact(&mut header).await.unwrap();
let body_len = u16::from_be_bytes([header[3], header[4]]) as usize;
let mut client_hello = Vec::with_capacity(5 + body_len);
client_hello.extend_from_slice(&header);
client_hello.resize(5 + body_len, 0);
server.read_exact(&mut client_hello[5..]).await.unwrap();
let barrier = std::env::var("TELEMT_WIRE_BARRIER").unwrap();
let release = std::env::var("TELEMT_WIRE_RELEASE").unwrap();
std::fs::write(&barrier, b"ready").unwrap();
wait_for_file(Path::new(&release)).await;
let raw_fd = server.as_raw_fd();
let mss_before = socket2::SockRef::from(&server).tcp_mss().unwrap();
let (read_half, write_half) = server.into_split();
let mut config = ProxyConfig::default();
config.general.beobachten = false;
config.access.ignore_time_skew = true;
config.censorship.fake_cert_len = fake_cert_len;
config
.access
.users
.insert("wire".to_string(), SECRET_HEX.to_string());
let replay_checker = ReplayChecker::new(128, Duration::from_secs(60));
let rng = SecureRandom::new();
let shared = ProxySharedState::new();
let (tls_reader, mut tls_writer, user) = match handle_tls_handshake_with_shared_and_options(
&client_hello,
read_half,
write_half,
peer,
&config,
&replay_checker,
&rng,
None,
&shared,
TlsResponseWriteOptions::tcp(raw_fd, Some(fragmentation)),
)
.await
{
HandshakeResult::Success(result) => result,
_ => panic!("wire-test FakeTLS authentication failed"),
};
assert_eq!(user, "wire");
tls_writer
.write_all(&vec![0xA5; BULK_PAYLOAD_LEN])
.await
.unwrap();
tls_writer.shutdown().await.unwrap();
drop(tls_reader);
// SAFETY: the write half still owns the accepted socket while it is borrowed.
let borrowed_fd = unsafe { BorrowedFd::borrow_raw(raw_fd) };
let mss_after = socket2::SockRef::from(&borrowed_fd).tcp_mss().unwrap();
let metadata = std::env::var("TELEMT_WIRE_SERVER_META").unwrap();
std::fs::write(
metadata,
format!("configured_bulk_mss=1400\nmss_before={mss_before}\nmss_after={mss_after}\n"),
)
.unwrap();
}
async fn run_client(addr: SocketAddr) {
let mut client = loop {
match TcpStream::connect(addr).await {
Ok(stream) => break stream,
Err(_) => tokio::time::sleep(Duration::from_millis(20)).await,
}
};
client
.write_all(&make_valid_tls_client_hello(600))
.await
.unwrap();
let mut response = Vec::new();
client.read_to_end(&mut response).await.unwrap();
let mut offset = 0;
let mut bulk_record_start = None;
while offset < response.len() {
assert!(response.len() - offset >= 5, "truncated TLS record header");
let payload_len = u16::from_be_bytes([response[offset + 3], response[offset + 4]]) as usize;
let end = offset + 5 + payload_len;
assert!(end <= response.len(), "truncated TLS record payload");
if response[offset] == 0x17
&& payload_len == BULK_PAYLOAD_LEN
&& response[offset + 5..end].iter().all(|byte| *byte == 0xA5)
{
bulk_record_start = Some(offset);
}
offset = end;
}
let initial_response_bytes = bulk_record_start.expect("bulk TLS record missing");
let metadata = std::env::var("TELEMT_WIRE_CLIENT_META").unwrap();
std::fs::write(
metadata,
format!(
"initial_response_bytes={initial_response_bytes}\ntotal_response_bytes={}\n",
response.len()
),
)
.unwrap();
}
#[tokio::test]
#[ignore = "requires privileged netns/veth packet-capture harness"]
async fn fake_tls_fragmentation_wire_role() {
let role = std::env::var("TELEMT_WIRE_ROLE").expect("TELEMT_WIRE_ROLE is required");
let addr = std::env::var("TELEMT_WIRE_ADDR")
.unwrap_or_else(|_| "198.18.0.1:24443".to_string())
.parse()
.unwrap();
match role.as_str() {
"server" => {
let fragment_size = std::env::var("TELEMT_WIRE_FRAGMENT")
.unwrap()
.parse()
.unwrap();
let fake_cert_len = std::env::var("TELEMT_WIRE_FAKE_CERT_LEN")
.unwrap()
.parse()
.unwrap();
// Optional `server.client_mss_prefix` value; omitted keeps "full".
let server = crate::config::ServerConfig {
client_mss_prefix: std::env::var("TELEMT_WIRE_PREFIX").ok(),
..Default::default()
};
let prefix = server
.client_mss_prefix_value()
.expect("TELEMT_WIRE_PREFIX must be a valid client_mss_prefix")
.unwrap_or_default();
let fragmentation = TlsResponseFragmentation {
fragment_size,
prefix,
};
run_server(addr, fragmentation, fake_cert_len).await;
}
"client" => run_client(addr).await,
_ => panic!("TELEMT_WIRE_ROLE must be server or client"),
}
}