Skip to main content

qualia_core_db/p2p/connectivity/
wss_tls.rs

1//! rustls-backed WSS. Certificate verification is mandatory.
2
3#![cfg(not(target_arch = "wasm32"))]
4
5use std::io::{Read, Write};
6use std::net::{TcpListener, TcpStream};
7use std::sync::Arc;
8use std::time::Duration;
9
10use base64::engine::general_purpose::STANDARD;
11use base64::Engine;
12use rcgen::{
13    BasicConstraints, Certificate, CertificateParams, DnType, ExtendedKeyUsagePurpose, IsCa,
14    Issuer, KeyPair, KeyUsagePurpose,
15};
16use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer, ServerName};
17use rustls::StreamOwned;
18use rustls::{ClientConfig, ClientConnection, RootCertStore, ServerConfig, ServerConnection};
19
20use super::wss;
21#[cfg(test)]
22use super::wss::send_datagram;
23
24fn install_ring() {
25    let _ = rustls::crypto::ring::default_provider().install_default();
26}
27
28pub struct LocalCa {
29    cert: Certificate,
30    issuer: Issuer<'static, KeyPair>,
31}
32
33/// Mints a local CA cert+key for dev TLS.
34pub fn mint_ca() -> Result<LocalCa, String> {
35    let mut params = CertificateParams::new(Vec::<String>::new()).map_err(|e| e.to_string())?;
36    params
37        .distinguished_name
38        .push(DnType::CommonName, "qdnf-local-ca");
39    params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
40    params.key_usages = vec![
41        KeyUsagePurpose::KeyCertSign,
42        KeyUsagePurpose::DigitalSignature,
43        KeyUsagePurpose::CrlSign,
44    ];
45    let key = KeyPair::generate().map_err(|e| e.to_string())?;
46    let cert = params.self_signed(&key).map_err(|e| e.to_string())?;
47    let issuer = Issuer::new(params, key);
48    Ok(LocalCa { cert, issuer })
49}
50
51/// Mints a server cert signed by `ca`.
52pub fn mint_server(ca: &LocalCa) -> Result<(Certificate, KeyPair), String> {
53    let mut params = CertificateParams::new(vec!["localhost".into()]).map_err(|e| e.to_string())?;
54    params
55        .distinguished_name
56        .push(DnType::CommonName, "localhost");
57    params.is_ca = IsCa::NoCa;
58    params.key_usages = vec![KeyUsagePurpose::DigitalSignature];
59    params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ServerAuth];
60    let key = KeyPair::generate().map_err(|e| e.to_string())?;
61    let cert = params
62        .signed_by(&key, &ca.issuer)
63        .map_err(|e| e.to_string())?;
64    Ok((cert, key))
65}
66
67/// Builds a rustls `ServerConfig` from cert+key.
68pub fn server_config(cert: &Certificate, key: &KeyPair) -> Result<Arc<ServerConfig>, String> {
69    install_ring();
70    let der = CertificateDer::from(cert.der().to_vec());
71    let pk = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(key.serialize_der()));
72    let provider = rustls::crypto::ring::default_provider();
73    let cfg = ServerConfig::builder_with_provider(provider.into())
74        .with_safe_default_protocol_versions()
75        .map_err(|e| e.to_string())?
76        .with_no_client_auth()
77        .with_single_cert(vec![der], pk)
78        .map_err(|e| e.to_string())?;
79    Ok(Arc::new(cfg))
80}
81
82/// Builds a `ClientConfig` trusting `ca`.
83pub fn client_config(ca: &LocalCa) -> Result<Arc<ClientConfig>, String> {
84    install_ring();
85    let mut roots = RootCertStore::empty();
86    roots
87        .add(CertificateDer::from(ca.cert.der().to_vec()))
88        .map_err(|e| e.to_string())?;
89    let provider = rustls::crypto::ring::default_provider();
90    Ok(Arc::new(
91        ClientConfig::builder_with_provider(provider.into())
92            .with_safe_default_protocol_versions()
93            .map_err(|e| e.to_string())?
94            .with_root_certificates(roots)
95            .with_no_client_auth(),
96    ))
97}
98
99pub enum TlsStream {
100    Client(StreamOwned<ClientConnection, TcpStream>),
101    Server(StreamOwned<ServerConnection, TcpStream>),
102}
103
104impl Read for TlsStream {
105    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
106        match self {
107            Self::Client(s) => s.read(buf),
108            Self::Server(s) => s.read(buf),
109        }
110    }
111}
112
113impl Write for TlsStream {
114    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
115        match self {
116            Self::Client(s) => s.write(buf),
117            Self::Server(s) => s.write(buf),
118        }
119    }
120
121    fn flush(&mut self) -> std::io::Result<()> {
122        match self {
123            Self::Client(s) => s.flush(),
124            Self::Server(s) => s.flush(),
125        }
126    }
127}
128
129fn wrap_client(tcp: TcpStream, cfg: Arc<ClientConfig>) -> Result<TlsStream, String> {
130    let name = ServerName::try_from("localhost").map_err(|e| e.to_string())?;
131    let conn = ClientConnection::new(cfg, name).map_err(|e| e.to_string())?;
132    Ok(TlsStream::Client(StreamOwned::new(conn, tcp)))
133}
134
135fn wrap_server(tcp: TcpStream, cfg: Arc<ServerConfig>) -> Result<TlsStream, String> {
136    let conn = ServerConnection::new(cfg).map_err(|e| e.to_string())?;
137    Ok(TlsStream::Server(StreamOwned::new(conn, tcp)))
138}
139
140/// TLS + WebSocket upgrade. Client verifies the server certificate against `ca`.
141pub fn loopback_tls_wss(ca: &LocalCa) -> Result<(TlsStream, TlsStream), String> {
142    let (srv_cert, srv_key) = mint_server(ca)?;
143    let server_cfg = server_config(&srv_cert, &srv_key)?;
144    let client_cfg = client_config(ca)?;
145    let listener = TcpListener::bind("127.0.0.1:0").map_err(|e| e.to_string())?;
146    let addr = listener.local_addr().map_err(|e| e.to_string())?;
147    let raw_c = TcpStream::connect(addr).map_err(|e| e.to_string())?;
148    let (raw_s, _) = listener.accept().map_err(|e| e.to_string())?;
149    raw_c
150        .set_read_timeout(Some(Duration::from_secs(8)))
151        .map_err(|e| e.to_string())?;
152    raw_s
153        .set_read_timeout(Some(Duration::from_secs(8)))
154        .map_err(|e| e.to_string())?;
155    let mut server = wrap_server(raw_s, server_cfg)?;
156    let mut client = wrap_client(raw_c, client_cfg)?;
157    let key = STANDARD.encode([7u8; 16]);
158    let th = std::thread::spawn(move || {
159        wss::client_handshake(&mut client, &key)?;
160        Ok::<_, std::io::Error>(client)
161    });
162    wss::server_handshake(&mut server).map_err(|e| e.to_string())?;
163    let client = th.join().map_err(|_| "join")?.map_err(|e| e.to_string())?;
164    Ok((client, server))
165}
166
167/// Probe: `true` when a client built against a different CA is rejected — verifies pinning.
168pub fn wrong_ca_is_rejected() -> bool {
169    let ca_good = match mint_ca() {
170        Ok(c) => c,
171        Err(_) => return false,
172    };
173    let ca_other = match mint_ca() {
174        Ok(c) => c,
175        Err(_) => return false,
176    };
177    let (srv_cert, srv_key) = match mint_server(&ca_good) {
178        Ok(v) => v,
179        Err(_) => return false,
180    };
181    let server_cfg = match server_config(&srv_cert, &srv_key) {
182        Ok(c) => c,
183        Err(_) => return false,
184    };
185    let client_cfg = match client_config(&ca_other) {
186        Ok(c) => c,
187        Err(_) => return false,
188    };
189    let listener = match TcpListener::bind("127.0.0.1:0") {
190        Ok(l) => l,
191        Err(_) => return false,
192    };
193    let addr = match listener.local_addr() {
194        Ok(a) => a,
195        Err(_) => return false,
196    };
197    let raw_c = match TcpStream::connect(addr) {
198        Ok(s) => s,
199        Err(_) => return false,
200    };
201    let (raw_s, _) = match listener.accept() {
202        Ok(s) => s,
203        Err(_) => return false,
204    };
205    let mut server = match wrap_server(raw_s, server_cfg) {
206        Ok(s) => s,
207        Err(_) => return false,
208    };
209    let mut client = match wrap_client(raw_c, client_cfg) {
210        Ok(s) => s,
211        Err(_) => return false,
212    };
213    let th = std::thread::spawn(move || {
214        let mut buf = [0u8; 8];
215        let _ = server.read(&mut buf);
216    });
217    let mut buf = [0u8; 8];
218    let failed = client.read(&mut buf).is_err();
219    let _ = th.join();
220    failed
221}
222
223/// `Write::plain_tcp_is_not_tls`.
224pub const fn plain_tcp_is_not_tls() -> bool {
225    true
226}
227
228#[cfg(test)]
229mod tests {
230    use super::*;
231
232    #[test]
233    fn tls_wss_verifies_cert_and_carries_256() {
234        let ca = mint_ca().unwrap();
235        let (mut c, mut s) = loopback_tls_wss(&ca).unwrap();
236        let payload = [0x3cu8; 256];
237        send_datagram(&mut c, 1, 1, &payload, true).unwrap();
238        let (_, _, got) = wss::recv_datagram(&mut s).unwrap();
239        assert_eq!(got, payload);
240        assert!(wrong_ca_is_rejected());
241        assert!(plain_tcp_is_not_tls());
242    }
243}