105 lines
3.0 KiB
Rust
105 lines
3.0 KiB
Rust
use tokio_rboring as tokio_boring;
|
|
|
|
use boring::ssl::{SslOptions, SslRef, SslSession, SslSessionCacheMode, SslVersion};
|
|
use futures::future;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::OnceLock;
|
|
use tokio::net::TcpStream;
|
|
use tokio::task::yield_now;
|
|
use tokio_boring::BoxGetSessionFinish;
|
|
|
|
mod common;
|
|
|
|
use self::common::{create_acceptor, create_connector, create_listener};
|
|
|
|
#[tokio::test]
|
|
async fn test() {
|
|
static FOUND_SESSION: AtomicBool = AtomicBool::new(false);
|
|
static SERVER_SESSION_DER: OnceLock<Vec<u8>> = OnceLock::new();
|
|
static CLIENT_SESSION_DER: OnceLock<Vec<u8>> = OnceLock::new();
|
|
|
|
let (listener, addr) = create_listener();
|
|
|
|
let acceptor = create_acceptor(move |builder| {
|
|
builder
|
|
.set_max_proto_version(Some(SslVersion::TLS1_2))
|
|
.unwrap();
|
|
builder.set_options(SslOptions::NO_TICKET);
|
|
builder
|
|
.set_session_cache_mode(SslSessionCacheMode::SERVER | SslSessionCacheMode::NO_INTERNAL);
|
|
builder.set_new_session_callback(|_, session| {
|
|
SERVER_SESSION_DER.set(session.to_der().unwrap()).unwrap()
|
|
});
|
|
|
|
unsafe {
|
|
builder.set_async_get_session_callback(|_, _| {
|
|
let der = SERVER_SESSION_DER.get()?;
|
|
|
|
Some(Box::pin(async move {
|
|
yield_now().await;
|
|
|
|
FOUND_SESSION.store(true, Ordering::SeqCst);
|
|
|
|
Some(Box::new(|_: &mut SslRef, _: &[u8]| {
|
|
Some(SslSession::from_der(der).unwrap())
|
|
}) as BoxGetSessionFinish)
|
|
}))
|
|
});
|
|
}
|
|
});
|
|
|
|
let connector = create_connector(|builder| {
|
|
builder.set_session_cache_mode(SslSessionCacheMode::CLIENT);
|
|
builder.set_new_session_callback(|_, session| {
|
|
CLIENT_SESSION_DER.set(session.to_der().unwrap()).unwrap()
|
|
});
|
|
|
|
builder.set_ca_file("tests/cert.pem")
|
|
});
|
|
|
|
let server = async move {
|
|
tokio_boring::accept(&acceptor, listener.accept().await.unwrap().0)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(SERVER_SESSION_DER.get().is_some());
|
|
assert!(!FOUND_SESSION.load(Ordering::SeqCst));
|
|
|
|
tokio_boring::accept(&acceptor, listener.accept().await.unwrap().0)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(FOUND_SESSION.load(Ordering::SeqCst));
|
|
};
|
|
|
|
let client = async move {
|
|
tokio_boring::connect(
|
|
connector.configure().unwrap(),
|
|
"localhost",
|
|
TcpStream::connect(&addr).await.unwrap(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let der = CLIENT_SESSION_DER.get().unwrap();
|
|
|
|
let mut config = connector.configure().unwrap();
|
|
|
|
unsafe {
|
|
config
|
|
.set_session(&SslSession::from_der(der).unwrap())
|
|
.unwrap();
|
|
}
|
|
|
|
tokio_boring::connect(
|
|
config,
|
|
"localhost",
|
|
TcpStream::connect(&addr).await.unwrap(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
};
|
|
|
|
future::join(server, client).await;
|
|
}
|