use std::net::SocketAddr;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::time::timeout;
use crate::config::limits::CONNECT_PROBE_TIMEOUT;
use crate::model::tls::{CipherSuite, TlsSupport, TlsVersion, VersionSupport};
use crate::protocols::tls::{self, Offer, RECORD_HEADER_LEN, ServerResponse};
use crate::warn;
pub const MAX_OFFERS_PER_VERSION: usize = 24;
pub const EXCHANGE_TIMEOUT: Duration = Duration::from_secs(2);
pub async fn enumerate_tls(addr: SocketAddr) -> TlsSupport {
let (ssl30, tls10, tls11, tls12, tls13) = tokio::join!(
walk(addr, TlsVersion::Ssl30),
walk(addr, TlsVersion::Tls10),
walk(addr, TlsVersion::Tls11),
walk(addr, TlsVersion::Tls12),
walk(addr, TlsVersion::Tls13),
);
let mut support = TlsSupport::new();
for found in [ssl30, tls10, tls11, tls12, tls13].into_iter().flatten() {
support.record(found);
}
support
}
async fn walk(addr: SocketAddr, version: TlsVersion) -> Option<VersionSupport> {
let mut remaining: Vec<CipherSuite> = CipherSuite::offered_under(version).collect();
let mut accepted: Vec<CipherSuite> = Vec::new();
let mut unrecognised: Vec<u16> = Vec::new();
for _ in 0..MAX_OFFERS_PER_VERSION {
if remaining.is_empty() {
break;
}
let offer = Offer {
version,
suites: &remaining,
server_name: None,
};
let Some(ServerResponse::Hello {
version: named,
suite,
..
}) = exchange(addr, &offer).await
else {
break;
};
if named != Some(version) {
break;
}
match remaining.iter().position(|held| held.code() == suite) {
Some(at) => accepted.push(remaining.remove(at)),
None => {
warn!(
verbosity = 2,
"{addr} selected cipher suite 0x{suite:04X} under {version}, which was not offered"
);
unrecognised.push(suite);
break;
}
}
}
(!accepted.is_empty() || !unrecognised.is_empty())
.then(|| VersionSupport::new(version, accepted, unrecognised))
}
async fn exchange(addr: SocketAddr, offer: &Offer<'_>) -> Option<ServerResponse> {
let hello = tls::client_hello(offer);
timeout(EXCHANGE_TIMEOUT, async {
let mut stream = timeout(CONNECT_PROBE_TIMEOUT, TcpStream::connect(addr))
.await
.ok()?
.ok()?;
stream.write_all(&hello).await.ok()?;
let record = first_record(&mut stream).await?;
tls::read_response(&record)
})
.await
.ok()?
}
async fn first_record(stream: &mut TcpStream) -> Option<Vec<u8>> {
let mut buffer = Vec::with_capacity(1024);
let mut chunk = [0u8; 1024];
loop {
match tls::record_length(&buffer) {
Some(total) if buffer.len() >= total => return Some(buffer),
Some(_) => {}
None if buffer.len() >= RECORD_HEADER_LEN => return None,
None => {}
}
let read = stream.read(&mut chunk).await.ok()?;
if read == 0 {
return (!buffer.is_empty()).then_some(buffer);
}
buffer.extend_from_slice(&chunk[..read]);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::BTreeSet;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::net::TcpListener;
use crate::protocols::tls::HELLO_RETRY_RANDOM;
struct FakeTlsServer {
version: u16,
accepts: BTreeSet<u16>,
retry: bool,
version_in_extension: bool,
ignores_the_offer: Option<u16>,
seen: Arc<AtomicUsize>,
}
impl FakeTlsServer {
fn new(version: u16, accepts: impl IntoIterator<Item = u16>) -> Self {
Self {
version,
accepts: accepts.into_iter().collect(),
retry: false,
version_in_extension: false,
ignores_the_offer: None,
seen: Arc::new(AtomicUsize::new(0)),
}
}
fn answering_in_the_extension(mut self) -> Self {
self.version_in_extension = true;
self
}
fn retrying(mut self) -> Self {
self.retry = true;
self
}
fn always_naming(mut self, suite: u16) -> Self {
self.ignores_the_offer = Some(suite);
self
}
async fn spawn(self) -> (SocketAddr, Arc<AtomicUsize>) {
let listener = TcpListener::bind("127.0.0.1:0").await.expect("binds");
let addr = listener.local_addr().expect("has an address");
let seen = Arc::clone(&self.seen);
tokio::spawn(async move {
loop {
let Ok((mut stream, _)) = listener.accept().await else {
return;
};
self.seen.fetch_add(1, Ordering::SeqCst);
let mut buffer = vec![0u8; 4096];
let Ok(read) = stream.read(&mut buffer).await else {
continue;
};
let answer = self.answer(&buffer[..read]);
let _ = stream.write_all(&answer).await;
}
});
(addr, seen)
}
fn answer(&self, hello: &[u8]) -> Vec<u8> {
if let Some(fixed) = self.ignores_the_offer {
return self.server_hello(fixed);
}
let Some(offered) = offered_suites(hello) else {
return alert();
};
let Some(chosen) = offered.iter().find(|code| self.accepts.contains(code)) else {
return alert();
};
self.server_hello(*chosen)
}
fn server_hello(&self, suite: u16) -> Vec<u8> {
let mut body = vec![2u8, 0, 0, 0];
let legacy = match self.version_in_extension {
true => 0x0303u16,
false => self.version,
};
body.extend_from_slice(&legacy.to_be_bytes());
match self.retry {
true => body.extend_from_slice(&HELLO_RETRY_RANDOM),
false => body.extend_from_slice(&[0x5A; 32]),
}
body.push(0); body.extend_from_slice(&suite.to_be_bytes());
body.push(0);
if self.version_in_extension {
let extensions = [
0x00,
0x2B,
0x00,
0x02,
(self.version >> 8) as u8,
self.version as u8,
];
body.extend_from_slice(&(extensions.len() as u16).to_be_bytes());
body.extend_from_slice(&extensions);
}
let length = (body.len() - 4) as u32;
body[1..4].copy_from_slice(&length.to_be_bytes()[1..]);
let mut record = vec![0x16, 0x03, 0x03];
record.extend_from_slice(&(body.len() as u16).to_be_bytes());
record.extend_from_slice(&body);
record
}
}
fn alert() -> Vec<u8> {
vec![0x15, 0x03, 0x03, 0x00, 0x02, 0x02, 0x28]
}
fn offered_suites(hello: &[u8]) -> Option<Vec<u16>> {
let after_random = 5 + 4 + 2 + 32;
let session_len = usize::from(*hello.get(after_random)?);
let rest = hello.get(after_random + 1 + session_len..)?;
let len = usize::from(u16::from_be_bytes([*rest.first()?, *rest.get(1)?]));
Some(
rest.get(2..2 + len)?
.as_chunks::<2>()
.0
.iter()
.map(|pair| u16::from_be_bytes(*pair))
.collect(),
)
}
#[tokio::test]
async fn every_accepted_suite_is_found_and_nothing_else_is() {
let accepted = [0xC02F, 0x009C, 0x000A];
let (addr, _) = FakeTlsServer::new(0x0303, accepted).spawn().await;
let support = enumerate_tls(addr).await;
assert!(support.accepts(TlsVersion::Tls12));
assert_eq!(support.floor(), Some(TlsVersion::Tls12));
assert_eq!(support.ceiling(), Some(TlsVersion::Tls12));
let found: BTreeSet<u16> = support.suites().iter().map(|suite| suite.code()).collect();
assert_eq!(found, accepted.into_iter().collect::<BTreeSet<_>>());
}
#[tokio::test]
async fn the_walk_costs_one_connection_per_suite_and_then_stops() {
let accepted = [0xC02F, 0x009C];
let (addr, seen) = FakeTlsServer::new(0x0303, accepted).spawn().await;
let support = enumerate_tls(addr).await;
assert_eq!(support.suites().len(), 2);
assert_eq!(
seen.load(Ordering::SeqCst),
3 + 4,
"the walk narrows and ends rather than repeating itself"
);
}
#[tokio::test]
async fn a_tls13_server_is_credited_to_thirteen_and_not_to_twelve() {
let (addr, _) = FakeTlsServer::new(0x0304, [0x1301, 0x1302])
.answering_in_the_extension()
.spawn()
.await;
let support = enumerate_tls(addr).await;
assert!(support.accepts(TlsVersion::Tls13));
assert!(
!support.accepts(TlsVersion::Tls12),
"the legacy field says 1.2 and means nothing"
);
assert_eq!(support.suites().len(), 2);
}
#[tokio::test]
async fn a_retrying_server_still_yields_its_suites() {
let (addr, _) = FakeTlsServer::new(0x0304, [0x1303])
.answering_in_the_extension()
.retrying()
.spawn()
.await;
let support = enumerate_tls(addr).await;
assert!(support.accepts(TlsVersion::Tls13));
assert_eq!(support.suites().len(), 1);
}
#[tokio::test]
async fn a_server_that_answers_with_another_version_is_not_credited_the_one_offered() {
let (addr, _) = FakeTlsServer::new(0x0303, [0x002F]).spawn().await;
let support = enumerate_tls(addr).await;
assert!(support.accepts(TlsVersion::Tls12));
for version in [TlsVersion::Ssl30, TlsVersion::Tls10, TlsVersion::Tls11] {
assert!(
!support.accepts(version),
"{version} was offered and answered with 1.2, which is a refusal"
);
}
assert!(support.deprecated_versions().next().is_none());
}
#[tokio::test]
async fn a_server_that_refuses_everything_yields_nothing() {
let (addr, _) = FakeTlsServer::new(0x0303, []).spawn().await;
let support = enumerate_tls(addr).await;
assert!(support.is_empty());
assert_eq!(support.floor(), None);
assert!(support.weakest().is_none());
}
#[tokio::test]
async fn a_closed_port_yields_nothing() {
let listener = TcpListener::bind("127.0.0.1:0").await.expect("binds");
let addr = listener.local_addr().expect("has an address");
drop(listener);
let support = enumerate_tls(addr).await;
assert!(support.is_empty());
}
#[tokio::test]
async fn a_server_still_speaking_tls_10_is_reported_as_such() {
let (addr, _) = FakeTlsServer::new(0x0301, [0x002F, 0x000A]).spawn().await;
let support = enumerate_tls(addr).await;
assert!(support.accepts(TlsVersion::Tls10));
assert_eq!(support.floor(), Some(TlsVersion::Tls10));
assert_eq!(
support.deprecated_versions().collect::<Vec<_>>(),
vec![TlsVersion::Tls10]
);
use crate::model::tls::{SuiteFault, SuiteStrength};
assert_eq!(support.weakest(), Some(SuiteStrength::Insecure));
assert!(support.faults().contains(&SuiteFault::SmallBlock));
}
#[tokio::test]
async fn a_server_naming_a_suite_it_was_not_offered_ends_the_walk() {
let (addr, seen) = FakeTlsServer::new(0x0303, [])
.always_naming(0xFF01)
.spawn()
.await;
let support = enumerate_tls(addr).await;
assert!(support.accepts(TlsVersion::Tls12));
assert!(
support.suites().is_empty(),
"nothing was graded, because nothing was recognised"
);
assert_eq!(
support.versions()[0].unrecognised(),
&[0xFF01],
"the number is kept rather than dropped"
);
assert!(
seen.load(Ordering::SeqCst) <= MAX_OFFERS_PER_VERSION,
"the walk ended on the first unoffered suite rather than looping"
);
}
#[tokio::test]
async fn a_peer_that_is_not_tls_settles_nothing() {
let listener = TcpListener::bind("127.0.0.1:0").await.expect("binds");
let addr = listener.local_addr().expect("has an address");
tokio::spawn(async move {
while let Ok((mut stream, _)) = listener.accept().await {
let mut scratch = [0u8; 1024];
let _ = stream.read(&mut scratch).await;
let _ = stream.write_all(b"HTTP/1.1 400 Bad Request\r\n\r\n").await;
}
});
let support = enumerate_tls(addr).await;
assert!(support.is_empty());
}
#[tokio::test]
async fn a_server_hello_arriving_in_pieces_is_still_read() {
let listener = TcpListener::bind("127.0.0.1:0").await.expect("binds");
let addr = listener.local_addr().expect("has an address");
let server = FakeTlsServer::new(0x0303, [0xC02F]);
tokio::spawn(async move {
while let Ok((mut stream, _)) = listener.accept().await {
let mut buffer = vec![0u8; 4096];
let Ok(read) = stream.read(&mut buffer).await else {
continue;
};
let answer = server.answer(&buffer[..read]);
let (head, tail) = answer.split_at(7);
let _ = stream.write_all(head).await;
tokio::time::sleep(Duration::from_millis(20)).await;
let _ = stream.write_all(tail).await;
}
});
let support = enumerate_tls(addr).await;
assert!(support.accepts(TlsVersion::Tls12));
assert_eq!(support.suites().len(), 1);
}
}