#![cfg(all(
feature = "turnloop",
not(all(target_arch = "wasm32", target_os = "unknown"))
))]
use std::{
future::Future,
pin::Pin,
task::{Context, Poll, Waker},
time::Duration,
};
use turnloop_io::{
turnloop::{Config, LocalExecutor, Timeout, backend::Platform},
*,
};
use turnloop_tls::{
ClientConfig, ClientOptions, ServerConfig, TlsStream,
rustls::pki_types::{PrivatePkcs8KeyDer, ServerName},
};
const NOW: u64 = 1_789_344_000;
fn finish<T>(task: &mut turnloop::executor::JoinHandle<T>) -> T {
match Pin::new(task).poll(&mut Context::from_waker(Waker::noop())) {
Poll::Ready(Ok(v)) => v,
_ => panic!("task must complete successfully"),
}
}
#[test]
fn async_tls_alpn_fragmented_plaintext_and_close_notify() {
let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).expect("certificate");
let server = ServerConfig::new(
vec![cert.cert.der().clone()],
PrivatePkcs8KeyDer::from(cert.key_pair.serialize_der()).into(),
vec![b"h2".to_vec()],
NOW,
)
.expect("server config");
let client = ClientConfig::new(
ClientOptions {
ca: Some(vec![cert.cert.der().clone()]),
alpn: vec![b"h2".to_vec()],
..Default::default()
},
NOW,
)
.expect("client config");
let mut executor = LocalExecutor::<Platform>::new(Config::default()).expect("executor");
let h = executor.handle();
let h2 = h.clone();
let listener = Listener::bind(&h, "127.0.0.1:0".parse().expect("address")).expect("listener");
let address = listener.local_addr().expect("address");
let end = h.now() + Duration::from_secs(5);
let mut s = executor
.spawn_local(async move {
let stream = listener.accept().await.expect("accept");
let mut tls = TlsStream::accept(stream, &server, &h, end, NOW)
.await
.expect("server handshake");
assert_eq!(tls.alpn_protocol(), Some(b"h2".as_slice()));
let mut data = [0; 1];
let mut count = 0;
while count < 32768 {
let n = read(&mut tls, &mut data).await.expect("TLS read");
assert_eq!((n, data[0]), (1, b'x'), "early EOF or corrupt plaintext");
count += n;
}
write_all(&mut tls, b"k").await.expect("acknowledge");
flush(&mut tls).await.expect("acknowledge flush");
assert_eq!(read(&mut tls, &mut data).await.expect("close notify"), 0);
count
})
.expect("spawn");
let mut c = executor
.spawn_local(async move {
let stream = h2
.connect(address, Default::default())
.await
.expect("connect");
let mut tls = TlsStream::connect(
stream,
&client,
ServerName::try_from("localhost").expect("name"),
&h2,
end,
NOW,
)
.await
.expect("client handshake");
assert_eq!(tls.alpn_protocol(), Some(b"h2".as_slice()));
write_all(&mut tls, &[b'x'; 32768])
.await
.expect("TLS write");
flush(&mut tls).await.expect("TLS flush");
let mut ack = [0; 1];
assert_eq!(read(&mut tls, &mut ack).await.expect("acknowledgement"), 1);
assert_eq!(ack[0], b'k');
close(&mut tls).await.expect("close notify");
32768
})
.expect("spawn");
while !s.is_finished() || !c.is_finished() {
assert!(executor.driver().now() < end);
executor.turn(Timeout::Until(end)).expect("turn");
}
assert_eq!(finish(&mut s), finish(&mut c));
}
#[test]
fn tls_half_close_sends_close_notify_and_keeps_decrypting() {
let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).expect("certificate");
let server = ServerConfig::new(
vec![cert.cert.der().clone()],
PrivatePkcs8KeyDer::from(cert.key_pair.serialize_der()).into(),
vec![b"h2".to_vec()],
NOW,
)
.expect("server config");
let client = ClientConfig::new(
ClientOptions {
ca: Some(vec![cert.cert.der().clone()]),
alpn: vec![b"h2".to_vec()],
..Default::default()
},
NOW,
)
.expect("client config");
let mut executor = LocalExecutor::<Platform>::new(Config::default()).expect("executor");
let h = executor.handle();
let h2 = h.clone();
let listener = Listener::bind(&h, "127.0.0.1:0".parse().expect("address")).expect("listener");
let address = listener.local_addr().expect("address");
let end = h.now() + Duration::from_secs(5);
async fn read_to_end<S: Stream>(stream: &mut S) -> Vec<u8> {
let mut received = Vec::new();
let mut bytes = [0; 256];
loop {
let n = read(stream, &mut bytes).await.expect("clean TLS EOF");
if n == 0 {
return received;
}
received.extend_from_slice(&bytes[..n]);
}
}
let mut s = executor
.spawn_local(async move {
let stream = listener.accept().await.expect("accept");
let mut tls = TlsStream::accept(stream, &server, &h, end, NOW)
.await
.expect("server handshake");
write_all(&mut tls, b"final").await.expect("write");
shutdown(&mut tls).await.expect("TLS half-close");
shutdown(&mut tls).await.expect("repeated half-close");
assert!(tls.get_ref().is_write_shut());
assert!(write_all(&mut tls, b"x").await.is_err());
let late = read_to_end(&mut tls).await;
close(&mut tls).await.expect("close");
late
})
.expect("spawn");
let mut c = executor
.spawn_local(async move {
let stream = h2
.connect(address, Default::default())
.await
.expect("connect");
let mut tls = TlsStream::connect(
stream,
&client,
ServerName::try_from("localhost").expect("name"),
&h2,
end,
NOW,
)
.await
.expect("client handshake");
let response = read_to_end(&mut tls).await;
write_all(&mut tls, b"late")
.await
.expect("write to a half-closed peer");
close(&mut tls).await.expect("close notify");
response
})
.expect("spawn");
while !s.is_finished() || !c.is_finished() {
assert!(executor.driver().now() < end);
executor.turn(Timeout::Until(end)).expect("turn");
}
assert_eq!(finish(&mut c), b"final");
assert_eq!(finish(&mut s), b"late");
}
#[test]
fn silent_peer_handshake_deadline() {
let mut executor = LocalExecutor::<Platform>::new(Config::default()).expect("executor");
let h = executor.handle();
let listener = Listener::bind(&h, "127.0.0.1:0".parse().expect("address")).expect("listener");
let address = listener.local_addr().expect("address");
let server = executor
.spawn_local(async move {
let _s = listener.accept().await.expect("accept");
std::future::pending::<()>().await
})
.expect("spawn");
let mut c = executor
.spawn_local(async move {
let stream = h
.connect(address, Default::default())
.await
.expect("connect");
let config = ClientConfig::new(ClientOptions::default(), NOW).expect("config");
let end = h.now() + Duration::from_millis(5);
let result = TlsStream::connect(
stream,
&config,
ServerName::try_from("localhost").expect("name"),
&h,
end,
NOW,
)
.await;
assert_eq!(
result.err().expect("timeout").kind(),
std::io::ErrorKind::TimedOut
);
assert!(h.now() >= end);
})
.expect("spawn");
let end = executor.driver().now() + Duration::from_secs(5);
while !c.is_finished() {
assert!(executor.driver().now() < end);
executor.turn(Timeout::Until(end)).expect("turn");
}
finish(&mut c);
drop(server);
executor.turn(Timeout::Now).expect("cancel turn");
}