pub(crate) fn acceptor(hosts: &[String], alpn: &'static [u8]) -> (Vec<u8>, btls::ssl::SslAcceptor) {
let (ca, mut acceptor) = builder(hosts);
acceptor.set_alpn_select_callback(move |_, client| {
btls::ssl::select_next_proto(alpn, client).ok_or(btls::ssl::AlpnError::NOACK)
});
(ca, acceptor.build())
}
pub(crate) fn builder(hosts: &[String]) -> (Vec<u8>, btls::ssl::SslAcceptorBuilder) {
use btls::asn1::Asn1Time;
use btls::bn::BigNum;
use btls::ec::{EcGroup, EcKey};
use btls::hash::MessageDigest;
use btls::nid::Nid;
use btls::pkey::PKey;
use btls::ssl::{SslAcceptor, SslMethod};
use btls::x509::extension::{BasicConstraints, SubjectAlternativeName};
use btls::x509::{X509, X509NameBuilder};
let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap();
let key = |_: ()| PKey::from_ec_key(EcKey::generate(&group).unwrap()).unwrap();
let name = |cn: &str| {
let mut n = X509NameBuilder::new().unwrap();
n.append_entry_by_text("CN", cn).unwrap();
n.build()
};
let (ca_key, leaf_key) = (key(()), key(()));
let ca_name = name("cliproxy-rs Go replay CA");
let mut ca = X509::builder().unwrap();
ca.set_version(2).unwrap();
ca.set_serial_number(&BigNum::from_u32(1).unwrap().to_asn1_integer().unwrap())
.unwrap();
ca.set_subject_name(&ca_name).unwrap();
ca.set_issuer_name(&ca_name).unwrap();
ca.set_pubkey(&ca_key).unwrap();
ca.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
ca.set_not_after(&Asn1Time::days_from_now(2).unwrap()).unwrap();
ca.append_extension(&BasicConstraints::new().critical().ca().build().unwrap())
.unwrap();
ca.sign(&ca_key, MessageDigest::sha256()).unwrap();
let ca = ca.build();
let mut leaf = X509::builder().unwrap();
leaf.set_version(2).unwrap();
leaf.set_serial_number(&BigNum::from_u32(2).unwrap().to_asn1_integer().unwrap())
.unwrap();
leaf.set_subject_name(&name(&hosts[0])).unwrap();
leaf.set_issuer_name(&ca_name).unwrap();
leaf.set_pubkey(&leaf_key).unwrap();
leaf.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
leaf.set_not_after(&Asn1Time::days_from_now(2).unwrap()).unwrap();
let mut san = SubjectAlternativeName::new();
for host in hosts {
san.dns(host);
}
let san = san.build(&leaf.x509v3_context(Some(&ca), None)).unwrap();
leaf.append_extension(&san).unwrap();
leaf.sign(&ca_key, MessageDigest::sha256()).unwrap();
let leaf = leaf.build();
let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
acceptor.set_private_key(&leaf_key).unwrap();
acceptor.set_certificate(&leaf).unwrap();
(ca.to_pem().unwrap(), acceptor)
}
pub(crate) async fn counting_upstream(
host: &str,
alpn: &'static [u8],
) -> (
Vec<u8>,
std::net::SocketAddr,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
let (ca, acceptor) = acceptor(&[host.to_owned()], alpn);
let (acceptor, accepted) = (Arc::new(acceptor), Arc::new(AtomicUsize::new(0)));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let count = accepted.clone();
tokio::spawn(async move {
while let Ok((tcp, _)) = listener.accept().await {
count.fetch_add(1, Ordering::SeqCst);
let acceptor = acceptor.clone();
tokio::spawn(async move {
let ssl = btls::ssl::Ssl::new(acceptor.context()).unwrap();
let mut tls = tokio_btls::SslStream::new(ssl, tcp).unwrap();
if std::pin::Pin::new(&mut tls).accept().await.is_err() {
return;
}
if tls.ssl().selected_alpn_protocol() == Some(b"h2") {
let Ok(mut conn) = http2::server::handshake(tls).await else {
return;
};
while let Some(Ok((_, mut respond))) = conn.accept().await {
let response = http::Response::builder().status(200).body(()).unwrap();
let mut body = respond.send_response(response, false).unwrap();
body.send_data(bytes::Bytes::from_static(b"ok"), true).unwrap();
}
} else {
serve_h1(tls).await;
}
});
}
});
(ca, addr, accepted)
}
async fn serve_h1<S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin>(mut io: S) {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let mut buf = Vec::new();
loop {
let head_end = loop {
if let Some(at) = buf.windows(4).position(|w| w == b"\r\n\r\n") {
break at + 4;
}
let mut chunk = [0u8; 4096];
match io.read(&mut chunk).await {
Ok(0) | Err(_) => return,
Ok(n) => buf.extend_from_slice(&chunk[..n]),
}
};
let head = String::from_utf8_lossy(&buf[..head_end]).to_ascii_lowercase();
let length: usize = head
.lines()
.find_map(|l| l.strip_prefix("content-length:"))
.and_then(|v| v.trim().parse().ok())
.unwrap_or(0);
while buf.len() < head_end + length {
let mut chunk = [0u8; 4096];
match io.read(&mut chunk).await {
Ok(0) | Err(_) => return,
Ok(n) => buf.extend_from_slice(&chunk[..n]),
}
}
buf.drain(..head_end + length);
let reply = b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 2\r\n\r\nok";
if io.write_all(reply).await.is_err() {
return;
}
}
}