use std::net::SocketAddr;
use std::sync::Arc;
use rustls::pki_types::ServerName;
use rustls::ClientConfig;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;
#[derive(Debug)]
struct NoVerifier;
impl rustls::client::danger::ServerCertVerifier for NoVerifier {
fn verify_server_cert(
&self,
_end_entity: &rustls::pki_types::CertificateDer<'_>,
_intermediates: &[rustls::pki_types::CertificateDer<'_>],
_server_name: &ServerName<'_>,
_ocsp_response: &[u8],
_now: rustls::pki_types::UnixTime,
) -> Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
Ok(rustls::client::danger::ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
_message: &[u8],
_cert: &rustls::pki_types::CertificateDer<'_>,
_dss: &rustls::DigitallySignedStruct,
) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
}
fn verify_tls13_signature(
&self,
_message: &[u8],
_cert: &rustls::pki_types::CertificateDer<'_>,
_dss: &rustls::DigitallySignedStruct,
) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
}
fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
vec![
rustls::SignatureScheme::ECDSA_NISTP256_SHA256,
rustls::SignatureScheme::ECDSA_NISTP384_SHA384,
rustls::SignatureScheme::ECDSA_NISTP521_SHA512,
rustls::SignatureScheme::ED25519,
rustls::SignatureScheme::RSA_PSS_SHA256,
rustls::SignatureScheme::RSA_PSS_SHA384,
rustls::SignatureScheme::RSA_PSS_SHA512,
rustls::SignatureScheme::RSA_PKCS1_SHA256,
rustls::SignatureScheme::RSA_PKCS1_SHA384,
rustls::SignatureScheme::RSA_PKCS1_SHA512,
]
}
}
#[tokio::test]
async fn echo_server_reports_client_hello_ja3_ja4_and_alpn() {
let _ = rustls::crypto::ring::default_provider().install_default();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr: SocketAddr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
guise_echo::accept_one_for_test(stream).await.unwrap()
});
let mut config = ClientConfig::builder()
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier))
.with_no_client_auth();
config.alpn_protocols = vec![b"http/1.1".to_vec()];
let connector = TlsConnector::from(Arc::new(config));
let stream = TcpStream::connect(addr).await.unwrap();
let server_name = ServerName::try_from("localhost").unwrap();
let mut tls_stream = connector.connect(server_name, stream).await.unwrap();
tls_stream
.write_all(b"GET /echo HTTP/1.1\r\nHost: localhost\r\n\r\n")
.await
.unwrap();
let mut response = Vec::new();
tls_stream.read_to_end(&mut response).await.unwrap();
let body_start = response
.windows(4)
.position(|w| w == b"\r\n\r\n")
.expect("HTTP response has a body separator");
let body = &response[body_start + 4..];
let info: serde_json::Value = serde_json::from_slice(body).expect("response body is JSON");
let tls = info.get("tls").expect("response has tls field");
assert!(
tls.get("ja3")
.and_then(|v| v.as_str())
.map(|s| !s.is_empty())
.unwrap_or(false),
"ja3 must be a non-empty string"
);
assert!(
tls.get("ja4")
.and_then(|v| v.as_str())
.map(|s| !s.is_empty())
.unwrap_or(false),
"ja4 must be a non-empty string"
);
let alpn = tls.get("alpn").expect("alpn field present");
assert_eq!(
alpn,
&serde_json::json!([[104, 116, 116, 112, 47, 49, 46, 49]]),
"client advertised http/1.1, server must report it"
);
let ja4 = tls.get("ja4").unwrap().as_str().unwrap();
assert!(
ja4.starts_with("t13"),
"TLS 1.3 client JA4 must start with t13: {ja4}"
);
assert!(
info.get("h2").map(|v| v.is_null()).unwrap_or(true),
"http/1.1 negotiation must not produce H2 frame info"
);
let tcp = info.get("tcp").expect("tcp field present");
if cfg!(target_os = "linux") {
assert!(
tcp["host_ttl"].as_u64().is_some(),
"Linux host TTL must be reported"
);
}
let _info = server.await.unwrap();
}
#[tokio::test]
async fn echo_server_reports_h2_preface_settings_and_window_update() {
let _ = rustls::crypto::ring::default_provider().install_default();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr: SocketAddr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
guise_echo::accept_one_for_test(stream).await.unwrap()
});
let mut config = ClientConfig::builder()
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier))
.with_no_client_auth();
config.alpn_protocols = vec![b"h2".to_vec()];
let connector = TlsConnector::from(Arc::new(config));
let stream = TcpStream::connect(addr).await.unwrap();
let server_name = ServerName::try_from("localhost").unwrap();
let mut tls_stream = connector.connect(server_name, stream).await.unwrap();
tls_stream
.write_all(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
.await
.unwrap();
let settings = [
(0x01u16, 65_536u32), (0x03, 100), (0x04, 6_291_456), ];
tls_stream
.write_all(&encode_h2_settings(&settings))
.await
.unwrap();
tls_stream
.write_all(&encode_h2_window_update(0, 1_000_000))
.await
.unwrap();
tls_stream.shutdown().await.unwrap();
let mut response = Vec::new();
tls_stream.read_to_end(&mut response).await.unwrap();
let body_start = response
.windows(4)
.position(|w| w == b"\r\n\r\n")
.expect("HTTP response has a body separator");
let body = &response[body_start + 4..];
let info: serde_json::Value = serde_json::from_slice(body).expect("response body is JSON");
let h2 = info.get("h2").expect("h2 field present").clone();
assert!(
h2["preface_seen"].as_bool().unwrap(),
"server must see H2 preface"
);
let tls = info.get("tls").expect("tls field present");
assert_eq!(
tls["alpn"],
serde_json::json!([[104, 50]]),
"client advertised h2"
);
let tcp = info.get("tcp").expect("tcp field present");
if cfg!(target_os = "linux") {
assert!(
tcp["host_ttl"].as_u64().is_some_and(|v| v > 0),
"Linux host TTL must be a positive byte"
);
assert!(
tcp["timestamps_enabled"].is_boolean()
&& tcp["sack_enabled"].is_boolean()
&& tcp["window_scaling_enabled"].is_boolean(),
"Linux TCP option knobs must be reported as booleans"
);
}
let settings_json = h2["settings"].as_array().expect("settings array");
assert_eq!(settings_json.len(), 3, "server must capture all SETTINGS");
assert_eq!(settings_json[0]["id"], 1);
assert_eq!(settings_json[0]["value"], 65_536);
assert_eq!(settings_json[1]["id"], 3);
assert_eq!(settings_json[1]["value"], 100);
assert_eq!(settings_json[2]["id"], 4);
assert_eq!(settings_json[2]["value"], 6_291_456);
let windows_json = h2["window_updates"]
.as_array()
.expect("window_updates array");
assert_eq!(windows_json.len(), 1);
assert_eq!(windows_json[0], 1_000_000);
let _info = server.await.unwrap();
}
fn encode_h2_settings(settings: &[(u16, u32)]) -> Vec<u8> {
let length = settings.len() * 6;
let mut frame = Vec::with_capacity(9 + length);
frame.extend_from_slice(&((length as u32).to_be_bytes()[1..])); frame.push(0x04); frame.push(0x00); frame.extend_from_slice(&0u32.to_be_bytes()); for (id, value) in settings {
frame.extend_from_slice(&id.to_be_bytes());
frame.extend_from_slice(&value.to_be_bytes());
}
frame
}
fn encode_h2_window_update(stream_id: u32, increment: u32) -> Vec<u8> {
let mut frame = Vec::with_capacity(13);
frame.extend_from_slice(&4u32.to_be_bytes()[1..]); frame.push(0x08); frame.push(0x00); frame.extend_from_slice(&(stream_id & 0x7fff_ffff).to_be_bytes());
frame.extend_from_slice(&(increment & 0x7fff_ffff).to_be_bytes());
frame
}
fn encode_h2_priority(stream_id: u32, dependency: u32, exclusive: bool, weight: u8) -> Vec<u8> {
let mut frame = Vec::with_capacity(14);
frame.extend_from_slice(&5u32.to_be_bytes()[1..]); frame.push(0x02); frame.push(0x00); frame.extend_from_slice(&(stream_id & 0x7fff_ffff).to_be_bytes());
let dep = dependency & 0x7fff_ffff | if exclusive { 0x8000_0000 } else { 0 };
frame.extend_from_slice(&dep.to_be_bytes());
frame.push(weight);
frame
}
#[tokio::test]
async fn echo_server_captures_h2_priority_frame() {
let _ = rustls::crypto::ring::default_provider().install_default();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr: SocketAddr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
guise_echo::accept_one_for_test(stream).await.unwrap()
});
let mut config = ClientConfig::builder()
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier))
.with_no_client_auth();
config.alpn_protocols = vec![b"h2".to_vec()];
let connector = TlsConnector::from(Arc::new(config));
let stream = TcpStream::connect(addr).await.unwrap();
let server_name = ServerName::try_from("localhost").unwrap();
let mut tls_stream = connector.connect(server_name, stream).await.unwrap();
tls_stream
.write_all(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
.await
.unwrap();
let settings = [(0x04u16, 6_291_456u32)];
tls_stream
.write_all(&encode_h2_settings(&settings))
.await
.unwrap();
tls_stream
.write_all(&encode_h2_priority(0x0d, 0x00, true, 110))
.await
.unwrap();
tls_stream.shutdown().await.unwrap();
let mut response = Vec::new();
tls_stream.read_to_end(&mut response).await.unwrap();
let body_start = response
.windows(4)
.position(|w| w == b"\r\n\r\n")
.expect("HTTP response has a body separator");
let body = &response[body_start + 4..];
let info: serde_json::Value = serde_json::from_slice(body).expect("response body is JSON");
let h2 = info.get("h2").expect("h2 field present");
assert!(h2["preface_seen"].as_bool().unwrap());
let priorities = h2["priorities"].as_array().expect("priorities array");
assert_eq!(priorities.len(), 1);
assert_eq!(priorities[0]["stream_id"], 0x0d);
assert_eq!(priorities[0]["exclusive"], true);
assert_eq!(priorities[0]["dependency"], 0);
assert_eq!(priorities[0]["weight"], 110);
let _info = server.await.unwrap();
}
#[tokio::test]
async fn echo_server_reports_missing_h2_preface() {
let _ = rustls::crypto::ring::default_provider().install_default();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr: SocketAddr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
guise_echo::accept_one_for_test(stream).await.unwrap()
});
let mut config = ClientConfig::builder()
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier))
.with_no_client_auth();
config.alpn_protocols = vec![b"h2".to_vec()];
let connector = TlsConnector::from(Arc::new(config));
let stream = TcpStream::connect(addr).await.unwrap();
let server_name = ServerName::try_from("localhost").unwrap();
let mut tls_stream = connector.connect(server_name, stream).await.unwrap();
tls_stream.shutdown().await.unwrap();
let mut response = Vec::new();
tls_stream.read_to_end(&mut response).await.unwrap();
let body_start = response
.windows(4)
.position(|w| w == b"\r\n\r\n")
.expect("HTTP response has a body separator");
let body = &response[body_start + 4..];
let info: serde_json::Value = serde_json::from_slice(body).expect("response body is JSON");
let h2 = info.get("h2").expect("h2 field present");
assert!(
!h2["preface_seen"].as_bool().unwrap(),
"missing preface must be reported"
);
let _info = server.await.unwrap();
}
#[tokio::test]
async fn echo_server_preserves_non_utf8_alpn_and_sni_bytes() {
let _ = rustls::crypto::ring::default_provider().install_default();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr: SocketAddr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
guise_echo::accept_one_for_test(stream).await.unwrap()
});
let non_utf8_alpn = vec![0x80u8, 0x81, 0x82];
let mut config = ClientConfig::builder()
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier))
.with_no_client_auth();
config.alpn_protocols = vec![non_utf8_alpn.clone(), b"http/1.1".to_vec()];
let connector = TlsConnector::from(Arc::new(config));
let stream = TcpStream::connect(addr).await.unwrap();
let server_name = ServerName::try_from("localhost").unwrap();
let mut tls_stream = connector.connect(server_name, stream).await.unwrap();
tls_stream
.write_all(b"GET /echo HTTP/1.1\r\nHost: localhost\r\n\r\n")
.await
.unwrap();
let mut response = Vec::new();
tls_stream.read_to_end(&mut response).await.unwrap();
let body_start = response
.windows(4)
.position(|w| w == b"\r\n\r\n")
.expect("HTTP response has a body separator");
let body = &response[body_start + 4..];
let info: serde_json::Value = serde_json::from_slice(body).expect("response body is JSON");
let tls = info.get("tls").expect("response has tls field");
assert_eq!(
tls["alpn"],
serde_json::json!([[128, 129, 130], [104, 116, 116, 112, 47, 49, 46, 49]]),
"non-UTF8 ALPN bytes must be retained as raw wire bytes"
);
assert_eq!(
tls["sni"],
serde_json::json!([108, 111, 99, 97, 108, 104, 111, 115, 116]),
"SNI hostname must be retained as raw wire bytes"
);
let _info = server.await.unwrap();
}