Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_net/tests/tls_mint.rs

15.8 KiB, 1 run

created by r1870400018:74705, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1#![cfg(feature = "async")]
2//! `Mint`, the in-memory name-constrained CA: what it vouches for, what it refuses, and whether
3//! the constraints in its certificate hold against a client when the `Mint` itself is bypassed,
4//! for rustls and, where `gnutls-cli` is present, for GnuTLS.
5
6use oxedyne_fe2o3_core::prelude::*;
7use oxedyne_fe2o3_net::tls::{
8 ensure_crypto_provider,
9 parse_pem_certificates,
10 pem_certificate,
11 Mint,
12 NameRule,
13};
14
15use std::{
16 net::{
17 IpAddr,
18 Ipv4Addr,
19 },
20 process::{
21 Command,
22 Stdio,
23 },
24 sync::Arc,
25 time::Duration,
26};
27
28use rcgen::{
29 Certificate,
30 CertificateParams,
31 DistinguishedName,
32 DnType,
33 ExtendedKeyUsagePurpose,
34 IsCa,
35 KeyUsagePurpose,
36 SanType,
37};
38use tokio::{
39 io::{
40 AsyncReadExt,
41 AsyncWriteExt,
42 },
43 net::{
44 TcpListener,
45 TcpStream,
46 },
47};
48use tokio_rustls::{
49 rustls::{
50 client::ClientConfig,
51 pki_types::{
52 CertificateDer,
53 PrivateKeyDer,
54 PrivatePkcs8KeyDer,
55 ServerName,
56 },
57 server::{
58 ResolvesServerCert,
59 ServerConfig,
60 },
61 RootCertStore,
62 },
63 TlsAcceptor,
64 TlsConnector,
65};
66
67
68const WAIT: Duration = Duration::from_secs(10);
69
70fn rules() -> Vec<NameRule> {
71 vec![
72 NameRule::Exact("registry.test".to_string()),
73 NameRule::Suffix(".files.test".to_string()),
74 ]
75}
76
77/// A server taking one connection and completing (or failing) one handshake with `cfg`.
78async fn serve(cfg: ServerConfig) -> Outcome<u16> {
79 let lst = res!(TcpListener::bind("127.0.0.1:0").await);
80 let port = res!(lst.local_addr()).port();
81 let acc = TlsAcceptor::from(Arc::new(cfg));
82 tokio::spawn(async move {
83 if let Ok((tcp, _)) = lst.accept().await {
84 if let Ok(mut tls) = acc.accept(tcp).await {
85 let mut b = [0u8; 16];
86 let _ = tls.read(&mut b).await;
87 let _ = tls.shutdown().await;
88 }
89 }
90 });
91 Ok(port)
92}
93
94fn mint_server(mint: Arc<Mint>) -> ServerConfig {
95 ensure_crypto_provider();
96 let res: Arc<dyn ResolvesServerCert> = mint;
97 ServerConfig::builder().with_no_client_auth().with_cert_resolver(res)
98}
99
100fn fixed_server(chain: Vec<CertificateDer<'static>>, key: PrivateKeyDer<'static>)
101 -> Outcome<ServerConfig>
102{
103 ensure_crypto_provider();
104 Ok(res!(ServerConfig::builder().with_no_client_auth().with_single_cert(chain, key), Init))
105}
106
107/// A rustls client that trusts only the CA in `ca_pem`, completing a handshake as `name`.
108async fn handshake(port: u16, ca_pem: &str, name: ServerName<'static>) -> Outcome<()> {
109 ensure_crypto_provider();
110 let mut roots = RootCertStore::empty();
111 for der in parse_pem_certificates(ca_pem.as_bytes()) {
112 res!(roots.add(CertificateDer::from(der)), Init);
113 }
114 let cfg = ClientConfig::builder().with_root_certificates(roots).with_no_client_auth();
115 let tcp = res!(TcpStream::connect(("127.0.0.1", port)).await);
116 let con = TlsConnector::from(Arc::new(cfg));
117 match tokio::time::timeout(WAIT, con.connect(name, tcp)).await {
118 Ok(Ok(mut tls)) => {
119 let _ = tls.write_all(b"ping").await;
120 Ok(())
121 },
122 Ok(Err(e)) => Err(err!(e, "Handshake failed."; Network)),
123 Err(_) => Err(err!("Handshake timed out."; Network, Timeout)),
124 }
125}
126
127fn dns(name: &str) -> Outcome<ServerName<'static>> {
128 Ok(res!(ServerName::try_from(name.to_string()), Invalid, Input))
129}
130
131/// A leaf for `san`, signed by `ca`, that a `Mint` would never issue, and its key.
132fn signed(ca: &Certificate, san: SanType)
133 -> Outcome<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)>
134{
135 let mut p = CertificateParams::default();
136 p.subject_alt_names = vec![san];
137 let mut dn = DistinguishedName::new();
138 dn.push(DnType::CommonName, "leaf");
139 p.distinguished_name = dn;
140 p.is_ca = IsCa::ExplicitNoCa;
141 p.key_usages = vec![KeyUsagePurpose::DigitalSignature];
142 p.extended_key_usages = vec![ExtendedKeyUsagePurpose::ServerAuth];
143 p.use_authority_key_identifier_extension = true;
144 let leaf = res!(Certificate::from_params(p), Init);
145 let der = res!(leaf.serialize_der_with_signer(ca), Init);
146 let ca_der = res!(ca.serialize_der(), Init);
147 let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(leaf.serialize_private_key_der()));
148 Ok((vec![CertificateDer::from(der), CertificateDer::from(ca_der)], key))
149}
150
151fn contains(hay: &[u8], needle: &[u8]) -> bool {
152 hay.windows(needle.len()).any(|w| w == needle)
153}
154
155// ┌───────────────────────────────────────────────────────────────────────────┐
156// │ 1-2. WHAT THE MINT VOUCHES FOR │
157// └───────────────────────────────────────────────────────────────────────────┘
158
159#[tokio::test]
160async fn test_a_leaf_for_a_permitted_name_verifies_against_the_ca_alone() -> Outcome<()> {
161 let mint = Arc::new(res!(Mint::new(&rules(), 2)));
162 let pem = mint.ca_pem();
163 for name in ["registry.test", "a.files.test", "deep.b.files.test", "REGISTRY.test"] {
164 let port = res!(serve(mint_server(mint.clone())).await);
165 res!(handshake(port, &pem, res!(dns(name))).await);
166 }
167 // The chain is [leaf, CA], and the leaf is cached until it nears expiry.
168 let a = res!(mint.leaf("registry.test"));
169 let b = res!(mint.leaf("Registry.Test."));
170 assert!(Arc::ptr_eq(&a, &b), "a second request for one name re-issued its leaf");
171 assert_eq!(a.cert.len(), 2);
172 assert_eq!(a.cert[1], mint.ca_der());
173 assert!(!mint.expires_within(3_600), "a two-day CA reads as expiring within an hour");
174 assert!(mint.expires_within(3 * 86_400), "a two-day CA reads as lasting three days");
175 Ok(())
176}
177
178#[tokio::test]
179async fn test_a_name_outside_the_rules_is_refused() -> Outcome<()> {
180 let mint = Arc::new(res!(Mint::new(&rules(), 2)));
181 for name in ["evil.test", "files.test", "xregistry.test", "a.registry.test", "127.0.0.1",
182 "*.files.test", "a..files.test", "a.files.test.evil", ""]
183 {
184 assert!(mint.leaf(name).is_err(), "the Mint issued a leaf for {:?}", name);
185 }
186 let port = res!(serve(mint_server(mint.clone())).await);
187 assert!(handshake(port, &mint.ca_pem(), res!(dns("evil.test"))).await.is_err(),
188 "a client reached a handshake for a name the Mint refuses");
189 // Without SNI there is no name to vouch for.
190 let port = res!(serve(mint_server(mint.clone())).await);
191 let ip = ServerName::IpAddress(IpAddr::V4(Ipv4Addr::LOCALHOST).into());
192 assert!(handshake(port, &mint.ca_pem(), ip).await.is_err(),
193 "a client without SNI reached a handshake");
194 // Rules that would constrain nothing are refused.
195 assert!(Mint::new(&[], 2).is_err());
196 assert!(Mint::new(&[NameRule::Suffix("files.test".to_string())], 2).is_err());
197 assert!(Mint::new(&[NameRule::Exact("10.0.0.1".to_string())], 2).is_err());
198 assert!(Mint::new(&rules(), 0).is_err());
199 Ok(())
200}
201
202// ┌───────────────────────────────────────────────────────────────────────────┐
203// │ 3. THE CA CERTIFICATE │
204// └───────────────────────────────────────────────────────────────────────────┘
205
206#[test]
207fn test_the_ca_holds_no_key_and_a_critical_constraint_excluding_every_address() -> Outcome<()> {
208 let mint = res!(Mint::new(&rules(), 2));
209 let pem = mint.ca_pem();
210 assert!(!pem.contains("PRIVATE KEY"), "the CA PEM carries a key");
211 assert!(!fmt!("{:?}", mint).contains("PRIVATE"), "Debug shows a key");
212 let ders = parse_pem_certificates(pem.as_bytes());
213 assert_eq!(ders.len(), 1, "the CA PEM is not exactly one certificate");
214 let der = &ders[0];
215 assert_eq!(der.as_slice(), mint.ca_der().as_ref());
216 // Extension: OID 2.5.29.30, then critical BOOLEAN TRUE.
217 assert!(contains(der, &[0x06, 0x03, 0x55, 0x1d, 0x1e, 0x01, 0x01, 0xff]),
218 "no critical name-constraints extension");
219 // Permitted dNSName subtrees, [2] IA5String: the exact name, and the suffix's domain.
220 let mut exact = vec![0x82, 13];
221 exact.extend_from_slice(b"registry.test");
222 assert!(contains(der, &exact), "the exact rule is not a permitted subtree");
223 let mut suffix = vec![0x82, 10];
224 suffix.extend_from_slice(b"files.test");
225 assert!(contains(der, &suffix), "the suffix rule is not a permitted subtree");
226 // Excluded subtrees [1], holding iPAddress [7] 0.0.0.0/0 (8 bytes) and ::/0 (32 bytes).
227 let mut v4 = vec![0x30, 0x0a, 0x87, 0x08];
228 v4.extend_from_slice(&[0u8; 8]);
229 let mut v6 = vec![0x30, 0x22, 0x87, 0x20];
230 v6.extend_from_slice(&[0u8; 32]);
231 let mut excl = vec![0xa1, (v4.len() + v6.len()) as u8];
232 excl.extend_from_slice(&v4);
233 excl.extend_from_slice(&v6);
234 assert!(contains(der, &excl), "the excluded subtrees are not exactly 0.0.0.0/0 and ::/0");
235 // basicConstraints: critical, cA TRUE, pathLen 0.
236 assert!(contains(der, &[0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff,
237 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x00]),
238 "basicConstraints is not cA with pathLen 0");
239 // PEM round trip.
240 assert_eq!(pem_certificate(der), pem);
241 Ok(())
242}
243
244// ┌───────────────────────────────────────────────────────────────────────────┐
245// │ 5. RUSTLS HOLDS THE CONSTRAINTS WITHOUT THE MINT │
246// └───────────────────────────────────────────────────────────────────────────┘
247
248#[tokio::test]
249async fn test_rustls_refuses_an_address_or_foreign_name_under_the_constrained_ca()
250 -> Outcome<()>
251{
252 let ca = res!(Certificate::from_params(res!(Mint::ca_params(&rules(), 2))), Init);
253 let ca_pem = pem_certificate(&res!(ca.serialize_der(), Init));
254 let lo = IpAddr::V4(Ipv4Addr::LOCALHOST);
255
256 // A permitted name under this CA passes, so a refusal below is the constraints'.
257 let (chain, key) = res!(signed(&ca, SanType::DnsName("x.files.test".to_string())));
258 let port = res!(serve(res!(fixed_server(chain, key))).await);
259 res!(handshake(port, &ca_pem, res!(dns("x.files.test"))).await);
260
261 let (chain, key) = res!(signed(&ca, SanType::IpAddress(lo)));
262 let port = res!(serve(res!(fixed_server(chain, key))).await);
263 assert!(handshake(port, &ca_pem, ServerName::IpAddress(lo.into())).await.is_err(),
264 "rustls accepted an IP-SAN leaf under the constrained CA");
265
266 let (chain, key) = res!(signed(&ca, SanType::DnsName("evil.test".to_string())));
267 let port = res!(serve(res!(fixed_server(chain, key))).await);
268 assert!(handshake(port, &ca_pem, res!(dns("evil.test"))).await.is_err(),
269 "rustls accepted a leaf for a name outside the constraints");
270
271 // The break: the same IP leaf under a CA without the exclusions is accepted, so it is the
272 // exclusions, not the permitted dNSNames, that refuse an address.
273 let mut open = res!(Mint::ca_params(&rules(), 2));
274 if let Some(nc) = open.name_constraints.as_mut() {
275 nc.excluded_subtrees.clear();
276 }
277 let open = res!(Certificate::from_params(open), Init);
278 let open_pem = pem_certificate(&res!(open.serialize_der(), Init));
279 let (chain, key) = res!(signed(&open, SanType::IpAddress(lo)));
280 let port = res!(serve(res!(fixed_server(chain, key))).await);
281 res!(handshake(port, &open_pem, ServerName::IpAddress(lo.into())).await);
282 Ok(())
283}
284
285// ┌───────────────────────────────────────────────────────────────────────────┐
286// │ 4. GNUTLS │
287// └───────────────────────────────────────────────────────────────────────────┘
288
289/// `gnutls-cli`, or the program `GNUTLS_CLI` names, if it runs.
290fn gnutls_cli() -> Option<String> {
291 let bin = std::env::var("GNUTLS_CLI").unwrap_or_else(|_| "gnutls-cli".to_string());
292 match Command::new(&bin).arg("--version").stdout(Stdio::null()).stderr(Stdio::null()).status() {
293 Ok(s) if s.success() => Some(bin),
294 _ => None,
295 }
296}
297
298/// Does `gnutls-cli`, trusting only `ca_pem`, accept the server on `port` as `name`?
299async fn gnutls_accepts(bin: &str, port: u16, ca_pem: &str, name: &str, tag: &str)
300 -> Outcome<bool>
301{
302 let path = std::env::temp_dir().join(fmt!("tls_mint_{}_{}.pem", std::process::id(), tag));
303 res!(std::fs::write(&path, ca_pem));
304 let mut cmd = Command::new(bin);
305 cmd.arg("--x509cafile").arg(&path)
306 .arg("--port").arg(port.to_string())
307 .arg("--verify-hostname").arg(name);
308 if name.parse::<IpAddr>().is_err() {
309 cmd.arg("--sni-hostname").arg(name);
310 }
311 cmd.arg("127.0.0.1").stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
312 let out = res!(tokio::task::spawn_blocking(move || cmd.output()).await);
313 let _ = std::fs::remove_file(&path);
314 let out = res!(out);
315 let text = fmt!("{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
316 let ok = out.status.success() && !text.contains("NOT trusted");
317 eprintln!("gnutls-cli {} as {:?}: exit {:?}, {}", tag, name, out.status.code(),
318 if ok { "accepted" } else { "refused" });
319 for l in text.lines().filter(|l| l.contains("certificate") || l.contains("Status")) {
320 eprintln!(" {}", l.trim());
321 }
322 Ok(ok)
323}
324
325#[tokio::test]
326async fn test_gnutls_refuses_a_leaf_outside_its_cas_constraints() -> Outcome<()> {
327 let bin = match gnutls_cli() {
328 Some(b) => b,
329 None => {
330 eprintln!("SKIPPED: gnutls-cli is not installed (set GNUTLS_CLI to its path), so \
331 the GnuTLS arm of design §3 is unsettled by this run.");
332 return Ok(());
333 },
334 };
335 let ca = res!(Certificate::from_params(res!(Mint::ca_params(
336 &[NameRule::Exact("good.test".to_string())], 2))), Init);
337 let ca_pem = pem_certificate(&res!(ca.serialize_der(), Init));
338
339 let (chain, key) = res!(signed(&ca, SanType::DnsName("good.test".to_string())));
340 let port = res!(serve(res!(fixed_server(chain, key))).await);
341 assert!(res!(gnutls_accepts(&bin, port, &ca_pem, "good.test", "control").await),
342 "gnutls-cli refused a permitted leaf, so its refusals below prove nothing");
343
344 let (chain, key) = res!(signed(&ca, SanType::DnsName("evil.test".to_string())));
345 let port = res!(serve(res!(fixed_server(chain, key))).await);
346 assert!(!res!(gnutls_accepts(&bin, port, &ca_pem, "evil.test", "unpermitted").await),
347 "GnuTLS accepted a leaf for a name outside its CA's constraints");
348
349 let (chain, key) = res!(signed(&ca, SanType::IpAddress(IpAddr::V4(Ipv4Addr::LOCALHOST))));
350 let port = res!(serve(res!(fixed_server(chain, key))).await);
351 assert!(!res!(gnutls_accepts(&bin, port, &ca_pem, "127.0.0.1", "address").await),
352 "GnuTLS accepted an IP-SAN leaf under a CA excluding every address");
353 Ok(())
354}