diff --git a/crates/limen-control-plane/src/caller.rs b/crates/limen-control-plane/src/caller.rs index 1f9b0919..5699458f 100644 --- a/crates/limen-control-plane/src/caller.rs +++ b/crates/limen-control-plane/src/caller.rs @@ -273,3 +273,366 @@ fn resolve_caller( } } } + +#[cfg(test)] +mod tests { + //! Who a request is from, with no database: the forwarding rules a proxy + //! relays under, and the role gates services call. + + use std::sync::Arc; + use std::time::Duration; + + use limen_ca::ssh::SshCa; + use limen_ca::{ + CaPurpose, CertificateAuthority, ComponentCertRequest, FileSigner, UserCertRequest, + }; + use rcgen::{CertificateParams, KeyPair, PKCS_ECDSA_P256_SHA256}; + use tonic::Code; + + use super::*; + + async fn ca(purpose: CaPurpose) -> CertificateAuthority { + CertificateAuthority::create_self_signed( + purpose, + Arc::new(FileSigner::generate().expect("key")), + ) + .await + .expect("ca") + } + + async fn cas() -> Cas { + let ssh = |purpose| { + SshCa::new(purpose, Arc::new(FileSigner::generate().expect("key"))).expect("ssh ca") + }; + Cas { + internal: ca(CaPurpose::Internal).await, + user: ca(CaPurpose::UserX509).await, + ssh_user: ssh(CaPurpose::UserSsh), + ssh_host: ssh(CaPurpose::HostSsh), + } + } + + fn csr() -> Vec { + let key = KeyPair::generate_for(&PKCS_ECDSA_P256_SHA256).expect("key"); + CertificateParams::default() + .serialize_request(&key) + .expect("csr") + .der() + .to_vec() + } + + async fn component( + ca: &CertificateAuthority, + kind: ComponentKind, + id: &str, + ) -> CertificateDer<'static> { + ca.issue_component(ComponentCertRequest { + csr_der: csr(), + kind, + id: id.into(), + dns_names: vec![], + labels: std::collections::BTreeMap::new(), + ttl: Duration::from_secs(300), + }) + .await + .expect("component cert") + .der + } + + async fn user( + ca: &CertificateAuthority, + name: &str, + roles: &[&str], + ) -> CertificateDer<'static> { + ca.issue_user(UserCertRequest { + csr_der: csr(), + username: name.into(), + roles: roles.iter().map(|r| (*r).to_owned()).collect(), + login_id: uuid::Uuid::now_v7(), + ttl: Duration::from_secs(300), + ci: None, + }) + .await + .expect("user cert") + .der + } + + fn b64(cert: &CertificateDer<'_>) -> String { + base64::engine::general_purpose::STANDARD.encode(cert.as_ref()) + } + + const PEER: &str = "198.51.100.1:443"; + const CLIENT: &str = "203.0.113.7:51000"; + + /// A request on a connection whose TLS peer presented `leaf`, optionally + /// marked as relayed and carrying a forwarded certificate. + fn request( + leaf: Option<&CertificateDer<'static>>, + forwarded: bool, + client_cert: Option<&str>, + ) -> tonic::Request<()> { + let mut req = tonic::Request::new(()); + req.extensions_mut().insert(PeerInfo { + remote_addr: Some(PEER.parse().expect("addr")), + server_name: None, + client_certs: leaf.cloned().into_iter().collect(), + }); + let md = req.metadata_mut(); + if forwarded { + md.insert(relay::FORWARDED, "1".parse().expect("ascii")); + md.insert(relay::CLIENT_ADDR, CLIENT.parse().expect("ascii")); + } + if let Some(cert) = client_cert { + md.insert(relay::CLIENT_CERT, cert.parse().expect("ascii")); + } + req + } + + fn refused(result: Result, code: Code, needle: &str) { + match result { + Ok(caller) => panic!("expected {code:?} ({needle}), resolved {caller:?}"), + Err(s) => { + assert_eq!(s.code(), code, "{s:?}"); + assert!(s.message().contains(needle), "{s:?} lacks {needle:?}"); + } + } + } + + #[tokio::test] + async fn direct_callers_resolve_from_the_tls_peer_only() { + let cas = cas().await; + let anon = resolve(&request(None, false, None), &cas).expect("anonymous"); + assert!(matches!(anon, Caller::Anonymous { .. })); + assert_eq!( + anon.addr(), + Some(PEER.parse::().expect("a").ip()) + ); + + let worker = component(&cas.internal, ComponentKind::Worker, "w1").await; + let caller = resolve(&request(Some(&worker), false, None), &cas).expect("worker"); + assert!( + matches!(&caller, Caller::Component { identity, via_proxy: false, .. } + if identity.kind == ComponentKind::Worker && identity.id == "w1"), + "{caller:?}" + ); + + // A client certificate the internal CA didn't issue is not a caller, + // even one from Limen's own user CA. + let rogue = ca(CaPurpose::Internal).await; + let stranger = component(&rogue, ComponentKind::Proxy, "p1").await; + refused( + resolve(&request(Some(&stranger), false, None), &cas), + Code::Unauthenticated, + "", + ); + let person = user(&cas.user, "ada", &[ADMIN_ROLE]).await; + refused( + resolve(&request(Some(&person), false, None), &cas), + Code::Unauthenticated, + "", + ); + // No peer info at all is a server bug, never an anonymous caller. + refused( + resolve(&tonic::Request::new(()), &cas), + Code::Internal, + "peer info", + ); + } + + #[tokio::test] + async fn only_a_direct_proxy_may_forward_a_request() { + let cas = cas().await; + let admin = b64(&user(&cas.user, "ada", &[ADMIN_ROLE]).await); + // No certificate, or a worker's or control plane's: the forwarded + // admin certificate must not be believed. + refused( + resolve(&request(None, true, Some(&admin)), &cas), + Code::PermissionDenied, + "only proxies may forward", + ); + for kind in [ComponentKind::Worker, ComponentKind::ControlPlane] { + let leaf = component(&cas.internal, kind, "c1").await; + refused( + resolve(&request(Some(&leaf), true, Some(&admin)), &cas), + Code::PermissionDenied, + "only proxies may forward", + ); + } + // The marker alone, without a forwarded certificate, is refused too. + refused( + resolve(&request(None, true, None), &cas), + Code::PermissionDenied, + "only proxies may forward", + ); + } + + #[tokio::test] + async fn a_proxy_forwards_users_and_workers_but_no_other_component() { + let cas = cas().await; + let proxy = component(&cas.internal, ComponentKind::Proxy, "p1").await; + let client_ip = CLIENT.parse::().expect("a").ip(); + + let person = b64(&user(&cas.user, "ada", &["dev"]).await); + let caller = resolve(&request(Some(&proxy), true, Some(&person)), &cas).expect("user"); + assert!( + matches!(&caller, Caller::User { identity, .. } if identity.username == "ada"), + "{caller:?}" + ); + assert_eq!( + caller.addr(), + Some(client_ip), + "the client's address, not the proxy's" + ); + + let worker = b64(&component(&cas.internal, ComponentKind::Worker, "w1").await); + let caller = resolve(&request(Some(&proxy), true, Some(&worker)), &cas).expect("worker"); + assert!( + matches!(&caller, Caller::Component { identity, via_proxy: true, .. } + if identity.kind == ComponentKind::Worker), + "{caller:?}" + ); + + // A proxy can't relay as another proxy or as the control plane. + for kind in [ComponentKind::Proxy, ComponentKind::ControlPlane] { + let other = b64(&component(&cas.internal, kind, "x1").await); + refused( + resolve(&request(Some(&proxy), true, Some(&other)), &cas), + Code::PermissionDenied, + "only worker certificates may be forwarded", + ); + } + + // Relayed with no client certificate (login through the proxy). + let caller = resolve(&request(Some(&proxy), true, None), &cas).expect("anonymous"); + assert!(matches!(caller, Caller::Anonymous { .. }), "{caller:?}"); + assert_eq!(caller.addr(), Some(client_ip)); + } + + #[tokio::test] + async fn a_forwarded_certificate_is_bounded_decoded_and_verified() { + let cas = cas().await; + let proxy = component(&cas.internal, ComponentKind::Proxy, "p1").await; + let via_proxy = |cert: &str| resolve(&request(Some(&proxy), true, Some(cert)), &cas); + + // At the limit the value is decoded and judged as a certificate; + // one byte over it is refused before decoding. + let at_limit = "A".repeat(MAX_FORWARDED_CERT_LEN); + refused( + via_proxy(&at_limit), + Code::Unauthenticated, + "forwarded certificate rejected", + ); + let over = "A".repeat(MAX_FORWARDED_CERT_LEN + 1); + refused(via_proxy(&over), Code::InvalidArgument, "too large"); + + refused( + via_proxy("not*base64!"), + Code::InvalidArgument, + "malformed forwarded certificate", + ); + + // Signed by CAs Limen doesn't use: neither a user nor a worker. + let rogue_user = ca(CaPurpose::UserX509).await; + let forged = b64(&user(&rogue_user, "ada", &[ADMIN_ROLE]).await); + refused( + via_proxy(&forged), + Code::Unauthenticated, + "forwarded certificate rejected", + ); + let rogue_internal = ca(CaPurpose::Internal).await; + let forged = b64(&component(&rogue_internal, ComponentKind::Worker, "w1").await); + refused( + via_proxy(&forged), + Code::Unauthenticated, + "forwarded certificate rejected", + ); + } + + #[tokio::test] + async fn role_gates_refuse_the_wrong_kind_of_caller() { + let cas = cas().await; + let proxy = component(&cas.internal, ComponentKind::Proxy, "p1").await; + let worker = component(&cas.internal, ComponentKind::Worker, "w1").await; + let as_user = |roles: &'static [&'static str]| { + let cas = &cas; + let proxy = &proxy; + async move { + let cert = b64(&user(&cas.user, "ada", roles).await); + resolve(&request(Some(proxy), true, Some(&cert)), cas).expect("user") + } + }; + let anonymous = resolve(&request(None, false, None), &cas).expect("anonymous"); + let direct_proxy = resolve(&request(Some(&proxy), false, None), &cas).expect("proxy"); + let direct_worker = resolve(&request(Some(&worker), false, None), &cas).expect("worker"); + let relayed_worker = + resolve(&request(Some(&proxy), true, Some(&b64(&worker))), &cas).expect("relayed"); + let plain = as_user(&["dev"]).await; + let auditor = as_user(&[AUDITOR_ROLE]).await; + let admin = as_user(&[ADMIN_ROLE]).await; + + // Only a proxy on its own connection is a direct proxy: not a worker, + // and not a worker the proxy relays for. + assert_eq!(direct_proxy.direct_proxy().expect("proxy").id, "p1"); + // `resolve` never yields a relayed proxy, but if a caller were one it + // must still not count as calling directly. + let relayed_proxy = Caller::Component { + identity: direct_proxy.component().expect("proxy").clone(), + addr: None, + via_proxy: true, + }; + for c in [ + &direct_worker, + &relayed_worker, + &relayed_proxy, + &anonymous, + &admin, + ] { + assert_eq!( + c.direct_proxy().expect_err("not a proxy").code(), + Code::PermissionDenied, + "{c:?}" + ); + } + + for c in [&anonymous, &direct_proxy, &relayed_worker] { + assert_eq!(c.user().expect_err("no user").code(), Code::Unauthenticated); + assert_eq!( + c.admin().expect_err("no user").code(), + Code::Unauthenticated + ); + assert_eq!( + c.reader().expect_err("no user").code(), + Code::Unauthenticated + ); + } + for c in [&anonymous, &plain] { + assert_eq!( + c.component().expect_err("no component").code(), + Code::Unauthenticated + ); + } + + assert_eq!( + plain.admin().expect_err("dev").code(), + Code::PermissionDenied + ); + assert_eq!( + plain.reader().expect_err("dev").code(), + Code::PermissionDenied + ); + assert_eq!( + auditor.admin().expect_err("auditor").code(), + Code::PermissionDenied + ); + assert!(auditor.reader().is_ok()); + assert!(admin.admin().is_ok() && admin.reader().is_ok()); + } + + #[test] + fn a_lock_wins_over_an_ended_login_and_neither_lets_a_call_through() { + assert_eq!(refusal(false, false), None); + assert_eq!(refusal(true, false).map(|r| r.0), Some("user locked")); + assert_eq!(refusal(true, true).map(|r| r.0), Some("user locked")); + assert_eq!(refusal(false, true).map(|r| r.0), Some("logged out")); + } +} diff --git a/crates/limen-tunnel/src/tls.rs b/crates/limen-tunnel/src/tls.rs index 4362d407..31c8a1ed 100644 --- a/crates/limen-tunnel/src/tls.rs +++ b/crates/limen-tunnel/src/tls.rs @@ -148,3 +148,64 @@ pub fn client_config( config.alpn_protocols = alpn.iter().map(|p| p.to_vec()).collect(); Ok(config) } + +#[cfg(test)] +mod tests { + use rcgen::{CertificateParams, KeyPair, PKCS_ECDSA_P256_SHA256}; + + use super::*; + + /// The 32-byte private scalar in a PKCS#8 P-256 key: the OCTET STRING + /// after `ECPrivateKey`'s version (`02 01 01 04 20`). The rest of the key + /// (OIDs, the public point) is also in the certificate, so it is public. + fn private_scalar(pkcs8: &[u8]) -> &[u8] { + let at = pkcs8 + .windows(5) + .position(|w| w == [0x02, 0x01, 0x01, 0x04, 0x20]) + .expect("an ECPrivateKey") + + 5; + &pkcs8[at..at + 32] + } + + /// Pieces of `secret` in `out`, as `Debug` prints a byte slice or as hex. + fn leaks(out: &str, secret: &[u8]) -> Vec { + let mut found = Vec::new(); + for window in secret.windows(6) { + let list = format!("{window:?}"); + let list = list[1..list.len() - 1].to_owned(); + let hex = window.iter().fold(String::new(), |mut s, b| { + use std::fmt::Write as _; + let _ = write!(s, "{b:02x}"); + s + }); + let upper = hex.to_uppercase(); + for needle in [list, hex, upper] { + if out.contains(&needle) { + found.push(needle); + } + } + } + found + } + + #[test] + fn debug_of_an_identity_never_shows_the_private_key() { + let key = KeyPair::generate_for(&PKCS_ECDSA_P256_SHA256).expect("key"); + let cert = CertificateParams::new(vec!["worker.limen.internal".to_owned()]) + .expect("params") + .self_signed(&key) + .expect("cert"); + let id = Identity::from_pem(&cert.pem(), &key.serialize_pem()).expect("identity"); + let der = key.serialize_der(); + let scalar = private_scalar(&der); + + // The check itself finds a scalar that is printed. + let printed = leaks(&format!("{scalar:?}"), scalar); + assert!(printed.len() > 1, "{printed:?}"); + + let out = format!("{id:?} {:?} {id:#?}", id.clone()); + assert!(out.contains("certs"), "{out}"); + let found = leaks(&out, scalar); + assert!(found.is_empty(), "private key in Debug output: {found:?}"); + } +}