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 | |
| 6 | use oxedyne_fe2o3_core::prelude::*; |
| 7 | use oxedyne_fe2o3_net::tls::{ |
| 8 | ensure_crypto_provider, |
| 9 | parse_pem_certificates, |
| 10 | pem_certificate, |
| 11 | Mint, |
| 12 | NameRule, |
| 13 | }; |
| 14 | |
| 15 | use std::{ |
| 16 | net::{ |
| 17 | IpAddr, |
| 18 | Ipv4Addr, |
| 19 | }, |
| 20 | process::{ |
| 21 | Command, |
| 22 | Stdio, |
| 23 | }, |
| 24 | sync::Arc, |
| 25 | time::Duration, |
| 26 | }; |
| 27 | |
| 28 | use rcgen::{ |
| 29 | Certificate, |
| 30 | CertificateParams, |
| 31 | DistinguishedName, |
| 32 | DnType, |
| 33 | ExtendedKeyUsagePurpose, |
| 34 | IsCa, |
| 35 | KeyUsagePurpose, |
| 36 | SanType, |
| 37 | }; |
| 38 | use tokio::{ |
| 39 | io::{ |
| 40 | AsyncReadExt, |
| 41 | AsyncWriteExt, |
| 42 | }, |
| 43 | net::{ |
| 44 | TcpListener, |
| 45 | TcpStream, |
| 46 | }, |
| 47 | }; |
| 48 | use 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 | |
| 68 | const WAIT: Duration = Duration::from_secs(10); |
| 69 | |
| 70 | fn 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`. |
| 78 | async 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 | |
| 94 | fn 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 | |
| 100 | fn 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`. |
| 108 | async 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 | |
| 127 | fn 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. |
| 132 | fn 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 | |
| 151 | fn 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] |
| 160 | async 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] |
| 179 | async 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] |
| 207 | fn 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] |
| 249 | async 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. |
| 290 | fn 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`? |
| 299 | async 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] |
| 326 | async 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 | } |