qualia_core_db/p2p/connectivity/
wss_tls.rs1#![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
33pub 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
51pub 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
67pub 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
82pub 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
140pub 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
167pub 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
223pub 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}