WS-I: native TLS (optional, default off) with SIGHUP cert reload
server.tls.{enabled,cert_file,key_file}; rustls (ring, explicit provider) via
tokio-rustls + hyper-util; https:// MCP origins when enabled; non-loopback
plain-HTTP startup warning; tests/tls.rs; README TLS section.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
c83a5fa1ac
commit
c5972b762f
11 files changed
+835
-15
No files matched your search
@@ -109,7 +109,33 @@ curl -si -X POST http://127.0.0.1:9109/mcp \
|
||||
|
||||
### Origin and Host checks
|
||||
|
||||
`/mcp` validates `Origin` and `Host` to defend against DNS rebinding from browsers. Loopback names, `server.bind` and the configured port are accepted by default. Requests without an `Origin` header (non-browser clients) pass this check, so the bearer token remains the real gate. If you bind to `0.0.0.0` or serve behind a name, add the names clients use to `server.allowed_hosts` (for example `["monitor.lan:9109"]`) and any browser origins to `server.allowed_origins`. With `auth.enabled = false` (loopback only), REST requests are checked against a Host allowlist (loopback names, `server.bind` and `server.allowed_hosts`) and get `403` otherwise, to blunt DNS rebinding. There is no Origin check on REST and no token in that mode, so keep auth enabled on any multi-user host. Terminate TLS in a reverse proxy if the host is reachable beyond a trusted network; the server itself speaks plain HTTP.
|
||||
`/mcp` validates `Origin` and `Host` to defend against DNS rebinding from browsers. Loopback names, `server.bind` and the configured port are accepted by default. Requests without an `Origin` header (non-browser clients) pass this check, so the bearer token remains the real gate. If you bind to `0.0.0.0` or serve behind a name, add the names clients use to `server.allowed_hosts` (for example `["monitor.lan:9109"]`) and any browser origins to `server.allowed_origins`. With `auth.enabled = false` (loopback only), REST requests are checked against a Host allowlist (loopback names, `server.bind` and `server.allowed_hosts`) and get `403` otherwise, to blunt DNS rebinding. There is no Origin check on REST and no token in that mode, so keep auth enabled on any multi-user host. If the host is reachable beyond a trusted network, enable native TLS (see the TLS section) or terminate TLS in a reverse proxy.
|
||||
|
||||
## TLS
|
||||
|
||||
TLS is optional and off by default. With `server.tls.enabled = false` (the default) the server speaks plain HTTP exactly as before, the certificate paths are ignored and never read, and no TLS code runs. A non-loopback `bind` without TLS logs a startup warning (it is not refused).
|
||||
|
||||
Enable it in the config file or the environment (`SKYG_SERVER__TLS__ENABLED=true`, `SKYG_SERVER__TLS__CERT_FILE`, `SKYG_SERVER__TLS__KEY_FILE`):
|
||||
|
||||
```toml
|
||||
[server.tls]
|
||||
enabled = true
|
||||
cert_file = "/etc/skyg/tls/cert.pem" # PEM chain, leaf first
|
||||
key_file = "/etc/skyg/tls/key.pem" # PEM, PKCS#8, PKCS#1 or SEC1
|
||||
```
|
||||
|
||||
Both files are required and checked at startup; a missing, unparsable or mismatched pair stops the server with an error naming the file (key contents are never logged). REST and `/mcp` are then served over HTTPS only (plain HTTP on that port fails), and the default MCP `Origin` allowlist uses `https://` instead of `http://`. Add your public names to `server.allowed_hosts` and `server.allowed_origins` as before. TLS is rustls with the ring provider; openssl is not used.
|
||||
|
||||
Self-signed example:
|
||||
|
||||
```sh
|
||||
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes -days 365 \
|
||||
-keyout key.pem -out cert.pem -subj '/CN=monitor.lan' \
|
||||
-addext 'subjectAltName=DNS:monitor.lan,DNS:localhost,IP:127.0.0.1'
|
||||
curl --cacert cert.pem -H "Authorization: Bearer $TOKEN" https://localhost:9109/api/v1/systemd/units
|
||||
```
|
||||
|
||||
Rotation: replace the files and send `SIGHUP` (`kill -HUP $(pidof slinuxm)`, or `systemctl kill -s HUP <unit>`). New connections get the new certificate; established ones are not dropped. If the new pair is unreadable or mismatched, the old certificate stays and an error is logged. For ACME, point `cert_file` and `key_file` at the client's output (for example certbot's `live/<name>/fullchain.pem` and `privkey.pem`, or the NixOS `security.acme` directory) and send SIGHUP from the renewal hook. For sops-nix or systemd `LoadCredential`, point at the decrypted or credential path (`/run/credentials/<unit>/...`) so the service user needs no access to the original key file.
|
||||
|
||||
## Docker access
|
||||
|
||||
|
||||
@@ -106,14 +106,14 @@ Design: [`plan.md`](plan.md) · Review fixes: [`plan/review.md`](plan/review.md)
|
||||
## Phase 4 — TLS and NixOS packaging
|
||||
|
||||
### WS-I TLS · [card](plan/workstreams/WS-I-tls.md)
|
||||
- [ ] **T1** Config `server.tls.{enabled,cert_file,key_file}` with validation and documented example keys
|
||||
- [ ] **T2** Serve over rustls with a single pinned crypto provider. No openssl.
|
||||
- [ ] **T3** Reload cert and key on SIGHUP without dropping connections. A bad cert keeps the old one.
|
||||
- [ ] **T4** MCP allowed origins use `https://` when TLS is on
|
||||
- [ ] **T5** Startup warning for non-loopback bind without TLS
|
||||
- [ ] **T6** Tests with a generated self-signed cert: HTTPS, 401/200 over TLS, plain HTTP rejected, SIGHUP reload, bad files, bounded shutdown
|
||||
- [ ] **T7** README TLS section
|
||||
- [ ] **T8** Live check with `curl --cacert` and an `/mcp` initialize over HTTPS
|
||||
- [x] **T1** Config `server.tls.{enabled,cert_file,key_file}` with validation and documented example keys
|
||||
- [x] **T2** Serve over rustls with a single pinned crypto provider. No openssl.
|
||||
- [x] **T3** Reload cert and key on SIGHUP without dropping connections. A bad cert keeps the old one.
|
||||
- [x] **T4** MCP allowed origins use `https://` when TLS is on
|
||||
- [x] **T5** Startup warning for non-loopback bind without TLS
|
||||
- [x] **T6** Tests with a generated self-signed cert: HTTPS, 401/200 over TLS, plain HTTP rejected, SIGHUP reload, bad files, bounded shutdown
|
||||
- [x] **T7** README TLS section
|
||||
- [x] **T8** Live check with `curl --cacert` and an `/mcp` initialize over HTTPS
|
||||
|
||||
### WS-H NixOS · [card](plan/workstreams/WS-H-nixos.md)
|
||||
- [ ] **H1** `nix/package.nix`: `buildRustPackage` from `Cargo.lock` with pkg-config, cmake, systemd. Binary `slinuxm`.
|
||||
|
||||
@@ -12,6 +12,14 @@ port = 9109 # listen port; SKYG_SERVER__PORT
|
||||
allowed_hosts = [] # extra Host header values accepted on /mcp, added to loopback names and bind; SKYG_SERVER__ALLOWED_HOSTS
|
||||
allowed_origins = [] # extra Origin values accepted on /mcp, must include scheme, e.g. "https://app.example.com"; SKYG_SERVER__ALLOWED_ORIGINS
|
||||
|
||||
# Native TLS for REST and /mcp. Optional and off by default: when enabled = false the
|
||||
# server speaks plain HTTP and the file paths are ignored and never read.
|
||||
# Certificate and key are re-read on SIGHUP (a bad new pair is rejected and the old one kept).
|
||||
[server.tls]
|
||||
enabled = false # serve HTTPS; requires cert_file and key_file; SKYG_SERVER__TLS__ENABLED
|
||||
cert_file = "" # PEM certificate chain, leaf first; SKYG_SERVER__TLS__CERT_FILE
|
||||
key_file = "" # PEM private key (PKCS#8, PKCS#1 or SEC1); SKYG_SERVER__TLS__KEY_FILE
|
||||
|
||||
[auth]
|
||||
enabled = true # false is rejected at startup unless server.bind is loopback; SKYG_AUTH__ENABLED
|
||||
db_path = "/var/lib/skyg-linux-tracker/db.sqlite" # SQLite database holding hashed API tokens; SKYG_AUTH__DB_PATH
|
||||
|
||||
+1
-1
@@ -58,4 +58,4 @@ Move a card by cutting its row into another column. Keep the card's own **Status
|
||||
| M2 Surfaces | Verification #3, #4 and #5 pass | 🟨 #3 and #4 verified live on 2026-10-15; #5 (OTel smoke test) not run, no otelcol-contrib binary |
|
||||
| M3 Release | Verification #1–#6 pass. Unit file and README shipped. | ⬜ |
|
||||
| M4 NixOS | `nix flake check` passes including the VM test. `:1984` serves and a token is minted with the system-installed CLI. | ⬜ |
|
||||
| M5 TLS | HTTPS serves REST and `/mcp`, SIGHUP reloads certs, no openssl. | ⬜ |
|
||||
| M5 TLS | HTTPS serves REST and `/mcp`, SIGHUP reloads certs, no openssl. Verified on `ws-i/tls` (unmerged). | ✅ |
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
| Field | Value |
|
||||
|---|---|
|
||||
| Status | Backlog |
|
||||
| Status | Done on `ws-i/tls` (not merged) |
|
||||
| Owner | — |
|
||||
| Phase | 4 (single track, after P3, before WS-H) |
|
||||
| Depends on | P3 |
|
||||
@@ -39,3 +39,4 @@ Tick these in [`TODO.md`](../../TODO.md).
|
||||
## Log
|
||||
|
||||
- 2026-10-16: Card created from design discussion.
|
||||
- 2026-10-16: Implemented on `ws-i/tls`, T1-T8 done. **TLS is optional, default off** (user requirement): with `server.tls.enabled = false` the plain path is unchanged, the cert/key paths are ignored and never read, no rustls code runs, no provider is built, MCP origins stay `http://`; env (`SKYG_SERVER__TLS__*`) and `--print-config` cover the block. Design: `src/tls.rs` uses `tokio-rustls` + `hyper-util` (auto builder, HTTP/1.1 ALPN) with an accept loop and a `ReloadableCert` (`ResolvesServerCert` behind an RwLock) so SIGHUP swaps the cert for new handshakes without touching live connections; a bad pair logs an error and keeps the old one. The `ring` provider is passed explicitly to `ServerConfig::builder_with_provider`; no process-wide default is installed (aws-lc-rs was already in the tree via reqwest/OTLP; this adds no new provider or openssl). Cargo.toml: rustls, tokio-rustls, hyper-util (separate commit), rcgen dev-dependency. Shutdown: accept stops, each connection gets `graceful_shutdown`, bounded by the existing 10s drain (test: SIGTERM with an idle keep-alive and an open SSE stream over TLS exits 0). T5 warning is logged only when TLS is off and bind is non-loopback. Tests: 3 new unit tests (config validation, env, origins) and 8 in `tests/tls.rs`. Live check (debug binary, openssl-generated certs, curl): healthz, 401/200 REST, MCP initialize over HTTPS, plain HTTP rejected, SIGHUP changed the served fingerprint, a junk cert + SIGHUP kept the rotated one, SIGTERM exit 0.
|
||||
@@ -42,6 +42,20 @@ pub struct ServerConfig {
|
||||
/// Extra `Origin` values accepted on `/mcp`, added to the defaults
|
||||
/// (loopback origins plus `bind`). Entries include a scheme.
|
||||
pub allowed_origins: Vec<String>,
|
||||
/// Optional native TLS (off by default).
|
||||
pub tls: TlsConfig,
|
||||
}
|
||||
|
||||
/// Native TLS for REST and `/mcp`. Optional: when `enabled` is false the
|
||||
/// paths are ignored and never read.
|
||||
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(default)]
|
||||
pub struct TlsConfig {
|
||||
pub enabled: bool,
|
||||
/// PEM certificate chain (leaf first).
|
||||
pub cert_file: PathBuf,
|
||||
/// PEM private key (PKCS#8, PKCS#1 or SEC1).
|
||||
pub key_file: PathBuf,
|
||||
}
|
||||
|
||||
impl Default for ServerConfig {
|
||||
@@ -51,6 +65,7 @@ impl Default for ServerConfig {
|
||||
port: 9109,
|
||||
allowed_hosts: Vec::new(),
|
||||
allowed_origins: Vec::new(),
|
||||
tls: TlsConfig::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -254,6 +269,15 @@ impl Config {
|
||||
"server.port must be greater than zero".into(),
|
||||
));
|
||||
}
|
||||
let tls = &self.server.tls;
|
||||
if tls.enabled
|
||||
&& (tls.cert_file.as_os_str().is_empty() || tls.key_file.as_os_str().is_empty())
|
||||
{
|
||||
return Err(ConfigError::Invalid(
|
||||
"server.tls.enabled = true requires both server.tls.cert_file and server.tls.key_file"
|
||||
.into(),
|
||||
));
|
||||
}
|
||||
if !self.auth.enabled && !self.server.bind.is_loopback() {
|
||||
return Err(ConfigError::Invalid(format!(
|
||||
"auth.enabled = false is only allowed on a loopback bind address (server.bind = {})",
|
||||
@@ -402,6 +426,37 @@ mod tests {
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tls_enabled_requires_both_paths() {
|
||||
let mut c = Config::default();
|
||||
assert!(!c.server.tls.enabled);
|
||||
c.validate().unwrap();
|
||||
c.server.tls.enabled = true;
|
||||
assert!(c.validate().is_err());
|
||||
c.server.tls.cert_file = "/c.pem".into();
|
||||
assert!(c.validate().is_err());
|
||||
c.server.tls.key_file = "/k.pem".into();
|
||||
c.validate().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tls_disabled_ignores_paths_and_env_overrides() {
|
||||
let mut c = Config::default();
|
||||
c.server.tls.cert_file = "/nonexistent/c.pem".into();
|
||||
c.server.tls.key_file = "/nonexistent/k.pem".into();
|
||||
c.validate().unwrap();
|
||||
Jail::expect_with(|jail| {
|
||||
jail.set_env("SKYG_SERVER__TLS__ENABLED", "true");
|
||||
jail.set_env("SKYG_SERVER__TLS__CERT_FILE", "/c.pem");
|
||||
jail.set_env("SKYG_SERVER__TLS__KEY_FILE", "/k.pem");
|
||||
let c = load(None, &CliOverrides::default()).unwrap();
|
||||
assert!(c.server.tls.enabled);
|
||||
assert_eq!(c.server.tls.cert_file, Path::new("/c.pem"));
|
||||
assert!(c.to_toml_redacted().unwrap().contains("[server.tls]"));
|
||||
Ok(())
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn example_file_matches_defaults() {
|
||||
let c: Config = toml::from_str(include_str!("../config.example.toml")).unwrap();
|
||||
|
||||
@@ -13,3 +13,4 @@ pub mod server;
|
||||
pub mod sources;
|
||||
pub mod state;
|
||||
pub mod telemetry;
|
||||
pub mod tls;
|
||||
+23
-2
@@ -12,7 +12,7 @@ use tokio_util::sync::CancellationToken;
|
||||
use skyg_linux_tracker::auth::tokens::{self, TokenCmd};
|
||||
use skyg_linux_tracker::config::{CliOverrides, Config};
|
||||
use skyg_linux_tracker::state::AppState;
|
||||
use skyg_linux_tracker::{db, server, telemetry};
|
||||
use skyg_linux_tracker::{db, server, telemetry, tls};
|
||||
|
||||
#[derive(Debug, Parser)]
|
||||
#[command(name = "slinuxm", version, about = "Read-only Linux system monitor")]
|
||||
@@ -113,6 +113,20 @@ async fn serve(config: Config) -> Result<()> {
|
||||
None
|
||||
};
|
||||
let addr = SocketAddr::new(config.server.bind, config.server.port);
|
||||
// TLS is optional: nothing from the tls module runs unless enabled.
|
||||
let tls = if config.server.tls.enabled {
|
||||
let cert = tls::ReloadableCert::load(&config.server.tls)
|
||||
.context("loading TLS certificate and key")?;
|
||||
Some((tls::acceptor(cert.clone())?, cert))
|
||||
} else {
|
||||
if !config.server.bind.is_loopback() {
|
||||
tracing::warn!(
|
||||
bind = %config.server.bind,
|
||||
"listening on a non-loopback address without TLS: bearer tokens travel in cleartext (set server.tls.enabled or terminate TLS in front)"
|
||||
);
|
||||
}
|
||||
None
|
||||
};
|
||||
let listener = tokio::net::TcpListener::bind(addr)
|
||||
.await
|
||||
.with_context(|| format!("binding {addr}"))?;
|
||||
@@ -122,6 +136,9 @@ async fn serve(config: Config) -> Result<()> {
|
||||
let exporters = telemetry::spawn_exporters(state.clone());
|
||||
let pool = state.db.clone();
|
||||
let app = server::build_router(state);
|
||||
if let Some((_, cert)) = &tls {
|
||||
tls::spawn_sighup_reload(cert.clone(), shutdown.clone());
|
||||
}
|
||||
|
||||
let signal_token = shutdown.clone();
|
||||
tokio::spawn(async move {
|
||||
@@ -133,7 +150,11 @@ async fn serve(config: Config) -> Result<()> {
|
||||
// `serve_listener` returns once the shutdown token fires and connections
|
||||
// drain. If the token has not fired it is a server error, so return
|
||||
// immediately. Bound the drain so a stuck client cannot hang SIGTERM.
|
||||
let serving = server::serve_listener(listener, app, shutdown.clone());
|
||||
let serving: std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send>> = match tls
|
||||
{
|
||||
Some((acceptor, _)) => Box::pin(tls::serve_tls(listener, acceptor, app, shutdown.clone())),
|
||||
None => Box::pin(server::serve_listener(listener, app, shutdown.clone())),
|
||||
};
|
||||
tokio::pin!(serving);
|
||||
let result = tokio::select! {
|
||||
r = &mut serving => r,
|
||||
|
||||
+15
-2
@@ -412,7 +412,8 @@ fn allowed_hosts(state: &AppState) -> Vec<String> {
|
||||
}
|
||||
|
||||
/// Allowed `Origin` values: loopback origins and `server.bind` on the
|
||||
/// configured port, plus configured extras.
|
||||
/// configured port, plus configured extras. The scheme is `https` when
|
||||
/// `server.tls.enabled`, otherwise `http`.
|
||||
fn allowed_origins(state: &AppState) -> Vec<String> {
|
||||
let s = &state.config.server;
|
||||
let mut hosts = vec![
|
||||
@@ -423,9 +424,10 @@ fn allowed_origins(state: &AppState) -> Vec<String> {
|
||||
if !s.bind.is_unspecified() {
|
||||
hosts.push(authority(s.bind));
|
||||
}
|
||||
let scheme = if s.tls.enabled { "https" } else { "http" };
|
||||
let mut v: Vec<String> = hosts
|
||||
.into_iter()
|
||||
.map(|h| format!("http://{h}:{}", s.port))
|
||||
.map(|h| format!("{scheme}://{h}:{}", s.port))
|
||||
.collect();
|
||||
v.extend(s.allowed_origins.iter().cloned());
|
||||
v
|
||||
@@ -783,6 +785,17 @@ mod tests {
|
||||
let _svc = service(st);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tls_switches_default_origins_to_https() {
|
||||
let mut cfg = Config::default();
|
||||
cfg.server.tls.enabled = true;
|
||||
let st = fake_state(cfg);
|
||||
let o = allowed_origins(&st);
|
||||
assert!(o.contains(&"https://localhost:9109".to_string()));
|
||||
assert!(o.contains(&"https://127.0.0.1:9109".to_string()));
|
||||
assert!(!o.iter().any(|x| x.starts_with("http://")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ipv6_non_loopback_bind_allowlists() {
|
||||
let mut cfg = Config::default();
|
||||
|
||||
+196
@@ -0,0 +1,196 @@
|
||||
//! Native TLS (DEC-12): rustls with the `ring` provider passed explicitly to
|
||||
//! the config builder (nothing is installed process-wide, so the OTLP
|
||||
//! clients' provider choice is unaffected). Only used when
|
||||
//! `server.tls.enabled`; the plain path never touches this module.
|
||||
//!
|
||||
//! The certificate lives behind a [`ResolvesServerCert`] that can be swapped
|
||||
//! at runtime, so SIGHUP reload leaves established connections untouched and
|
||||
//! new handshakes pick up the new certificate. Key material is never logged.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::{Arc, RwLock};
|
||||
use std::time::Duration;
|
||||
|
||||
use anyhow::{anyhow, Context, Result};
|
||||
use axum::Router;
|
||||
use hyper_util::rt::{TokioExecutor, TokioIo};
|
||||
use hyper_util::server::conn::auto::Builder;
|
||||
use hyper_util::service::TowerToHyperService;
|
||||
use rustls::crypto::ring as provider;
|
||||
use rustls::pki_types::pem::PemObject;
|
||||
use rustls::pki_types::{CertificateDer, PrivateKeyDer};
|
||||
use rustls::server::{ClientHello, ResolvesServerCert};
|
||||
use rustls::sign::CertifiedKey;
|
||||
use rustls::ServerConfig;
|
||||
use tokio::task::JoinSet;
|
||||
use tokio_rustls::TlsAcceptor;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::config::TlsConfig;
|
||||
|
||||
const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);
|
||||
|
||||
/// Hot-swappable server certificate.
|
||||
#[derive(Debug)]
|
||||
pub struct ReloadableCert {
|
||||
current: RwLock<Arc<CertifiedKey>>,
|
||||
cert_file: PathBuf,
|
||||
key_file: PathBuf,
|
||||
}
|
||||
|
||||
impl ReloadableCert {
|
||||
/// Load the initial pair; fails with a clear error naming the file.
|
||||
pub fn load(cfg: &TlsConfig) -> Result<Arc<Self>> {
|
||||
let key = load_certified_key(&cfg.cert_file, &cfg.key_file)?;
|
||||
Ok(Arc::new(Self {
|
||||
current: RwLock::new(Arc::new(key)),
|
||||
cert_file: cfg.cert_file.clone(),
|
||||
key_file: cfg.key_file.clone(),
|
||||
}))
|
||||
}
|
||||
|
||||
/// Re-read the files. On error the previous certificate stays in use.
|
||||
pub fn reload(&self) -> Result<()> {
|
||||
let key = load_certified_key(&self.cert_file, &self.key_file)?;
|
||||
*self.current.write().unwrap_or_else(|e| e.into_inner()) = Arc::new(key);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ResolvesServerCert for ReloadableCert {
|
||||
fn resolve(&self, _hello: ClientHello<'_>) -> Option<Arc<CertifiedKey>> {
|
||||
Some(
|
||||
self.current
|
||||
.read()
|
||||
.unwrap_or_else(|e| e.into_inner())
|
||||
.clone(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn load_certified_key(cert_file: &Path, key_file: &Path) -> Result<CertifiedKey> {
|
||||
let certs = CertificateDer::pem_file_iter(cert_file)
|
||||
.map_err(|e| anyhow!("reading server.tls.cert_file {}: {e}", cert_file.display()))?
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map_err(|e| anyhow!("parsing server.tls.cert_file {}: {e}", cert_file.display()))?;
|
||||
if certs.is_empty() {
|
||||
return Err(anyhow!(
|
||||
"server.tls.cert_file {} contains no PEM certificates",
|
||||
cert_file.display()
|
||||
));
|
||||
}
|
||||
let key = PrivateKeyDer::from_pem_file(key_file)
|
||||
.map_err(|e| anyhow!("reading server.tls.key_file {}: {e}", key_file.display()))?;
|
||||
let signing = provider::sign::any_supported_type(&key).map_err(|_| {
|
||||
anyhow!(
|
||||
"server.tls.key_file {}: unsupported or invalid private key",
|
||||
key_file.display()
|
||||
)
|
||||
})?;
|
||||
let ck = CertifiedKey::new(certs, signing);
|
||||
ck.keys_match()
|
||||
.map_err(|_| anyhow!("server.tls.key_file does not match server.tls.cert_file"))?;
|
||||
Ok(ck)
|
||||
}
|
||||
|
||||
/// Build the acceptor around a reloadable certificate.
|
||||
pub fn acceptor(cert: Arc<ReloadableCert>) -> Result<TlsAcceptor> {
|
||||
let mut cfg = ServerConfig::builder_with_provider(Arc::new(provider::default_provider()))
|
||||
.with_safe_default_protocol_versions()
|
||||
.context("TLS protocol versions")?
|
||||
.with_no_client_auth()
|
||||
.with_cert_resolver(cert);
|
||||
// HTTP/1.1 only, matching the plain listener.
|
||||
cfg.alpn_protocols = vec![b"http/1.1".to_vec()];
|
||||
Ok(TlsAcceptor::from(Arc::new(cfg)))
|
||||
}
|
||||
|
||||
/// Reload on every SIGHUP until `shutdown`. Failures are logged, never fatal.
|
||||
pub fn spawn_sighup_reload(cert: Arc<ReloadableCert>, shutdown: CancellationToken) {
|
||||
use tokio::signal::unix::{signal, SignalKind};
|
||||
let mut hup = match signal(SignalKind::hangup()) {
|
||||
Ok(s) => s,
|
||||
Err(e) => {
|
||||
tracing::error!(error = %e, "cannot install SIGHUP handler; TLS reload disabled");
|
||||
return;
|
||||
}
|
||||
};
|
||||
tokio::spawn(async move {
|
||||
loop {
|
||||
tokio::select! {
|
||||
_ = shutdown.cancelled() => break,
|
||||
r = hup.recv() => if r.is_none() { break },
|
||||
}
|
||||
match cert.reload() {
|
||||
Ok(()) => tracing::info!("TLS certificate reloaded"),
|
||||
Err(e) => tracing::error!(
|
||||
error = %format!("{e:#}"),
|
||||
"TLS reload failed; keeping previous certificate"
|
||||
),
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Serve `app` over TLS until `shutdown` is cancelled, then drain: stop
|
||||
/// accepting, ask each connection to finish gracefully, and wait. The caller
|
||||
/// bounds the drain by dropping this future (which aborts the connections).
|
||||
pub async fn serve_tls(
|
||||
listener: tokio::net::TcpListener,
|
||||
acceptor: TlsAcceptor,
|
||||
app: Router,
|
||||
shutdown: CancellationToken,
|
||||
) -> Result<()> {
|
||||
let addr = listener.local_addr().context("local_addr")?;
|
||||
tracing::info!(%addr, tls = true, "listening");
|
||||
let mut conns: JoinSet<()> = JoinSet::new();
|
||||
loop {
|
||||
tokio::select! {
|
||||
_ = shutdown.cancelled() => break,
|
||||
Some(_) = conns.join_next(), if !conns.is_empty() => {}
|
||||
r = listener.accept() => {
|
||||
let (tcp, peer) = match r {
|
||||
Ok(x) => x,
|
||||
Err(e) => {
|
||||
tracing::warn!(error = %e, "accept failed");
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let acceptor = acceptor.clone();
|
||||
let svc = TowerToHyperService::new(app.clone());
|
||||
let stop = shutdown.clone();
|
||||
conns.spawn(async move {
|
||||
let tls = match tokio::time::timeout(HANDSHAKE_TIMEOUT, acceptor.accept(tcp)).await {
|
||||
Ok(Ok(t)) => t,
|
||||
Ok(Err(e)) => {
|
||||
tracing::debug!(%peer, error = %e, "TLS handshake failed");
|
||||
return;
|
||||
}
|
||||
Err(_) => {
|
||||
tracing::debug!(%peer, "TLS handshake timed out");
|
||||
return;
|
||||
}
|
||||
};
|
||||
let builder = Builder::new(TokioExecutor::new());
|
||||
let conn = builder.serve_connection_with_upgrades(TokioIo::new(tls), svc);
|
||||
tokio::pin!(conn);
|
||||
tokio::select! {
|
||||
r = conn.as_mut() => {
|
||||
if let Err(e) = r { tracing::debug!(%peer, error = %e, "connection error"); }
|
||||
}
|
||||
_ = stop.cancelled() => {
|
||||
conn.as_mut().graceful_shutdown();
|
||||
if let Err(e) = conn.as_mut().await {
|
||||
tracing::debug!(%peer, error = %e, "connection error");
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
drop(listener);
|
||||
while conns.join_next().await.is_some() {}
|
||||
Ok(())
|
||||
}
|
||||
+499
@@ -0,0 +1,499 @@
|
||||
//! Native TLS tests (WS-I T6): the real `slinuxm` binary serving HTTPS with
|
||||
//! generated self-signed certificates.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Child, Command, Stdio};
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use rustls::pki_types::pem::PemObject;
|
||||
use rustls::pki_types::{CertificateDer, ServerName};
|
||||
use sha2::{Digest, Sha256};
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
use tokio::net::TcpStream;
|
||||
use tokio_rustls::TlsConnector;
|
||||
|
||||
const BIN: &str = env!("CARGO_BIN_EXE_slinuxm");
|
||||
|
||||
struct Pair {
|
||||
cert_pem: String,
|
||||
key_pem: String,
|
||||
}
|
||||
|
||||
fn gen_pair() -> Pair {
|
||||
let ck = rcgen::generate_simple_self_signed(vec!["localhost".to_owned(), "127.0.0.1".into()])
|
||||
.unwrap();
|
||||
Pair {
|
||||
cert_pem: ck.cert.pem(),
|
||||
key_pem: ck.signing_key.serialize_pem(),
|
||||
}
|
||||
}
|
||||
|
||||
fn write_pair(dir: &Path, p: &Pair) -> (PathBuf, PathBuf) {
|
||||
let (c, k) = (dir.join("cert.pem"), dir.join("key.pem"));
|
||||
std::fs::write(&c, &p.cert_pem).unwrap();
|
||||
std::fs::write(&k, &p.key_pem).unwrap();
|
||||
(c, k)
|
||||
}
|
||||
|
||||
fn free_port() -> u16 {
|
||||
let l = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
l.local_addr().unwrap().port()
|
||||
}
|
||||
|
||||
struct Server {
|
||||
child: Child,
|
||||
port: u16,
|
||||
token: String,
|
||||
dir: tempdir::Dir,
|
||||
}
|
||||
|
||||
mod tempdir {
|
||||
use std::path::PathBuf;
|
||||
pub struct Dir(pub PathBuf);
|
||||
impl Dir {
|
||||
pub fn new(tag: &str) -> Self {
|
||||
static N: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
let p = std::env::temp_dir().join(format!(
|
||||
"slinuxm-tls-{tag}-{}-{}",
|
||||
std::process::id(),
|
||||
N.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
|
||||
));
|
||||
std::fs::create_dir_all(&p).unwrap();
|
||||
Self(p)
|
||||
}
|
||||
}
|
||||
impl Drop for Dir {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Server {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.child.kill();
|
||||
let _ = self.child.wait();
|
||||
}
|
||||
}
|
||||
|
||||
fn config_toml(dir: &Path, port: u16, cert: &Path, key: &Path) -> PathBuf {
|
||||
let f = dir.join("config.toml");
|
||||
std::fs::write(
|
||||
&f,
|
||||
format!(
|
||||
"[server]\nport = {port}\n[server.tls]\nenabled = true\ncert_file = {:?}\nkey_file = {:?}\n[auth]\ndb_path = {:?}\n",
|
||||
cert.display().to_string(),
|
||||
key.display().to_string(),
|
||||
dir.join("db.sqlite").display().to_string(),
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
f
|
||||
}
|
||||
|
||||
fn mint_token(cfg: &Path) -> String {
|
||||
let out = Command::new(BIN)
|
||||
.args(["token", "create", "t", "--config"])
|
||||
.arg(cfg)
|
||||
.env_clear()
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
String::from_utf8(out.stdout).unwrap().trim().to_owned()
|
||||
}
|
||||
|
||||
fn start(pair: &Pair) -> Server {
|
||||
let dir = tempdir::Dir::new("srv");
|
||||
let (c, k) = write_pair(&dir.0, pair);
|
||||
let port = free_port();
|
||||
let cfg = config_toml(&dir.0, port, &c, &k);
|
||||
let token = mint_token(&cfg);
|
||||
let child = Command::new(BIN)
|
||||
.args(["serve", "--config"])
|
||||
.arg(&cfg)
|
||||
.env_clear()
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let s = Server {
|
||||
child,
|
||||
port,
|
||||
token,
|
||||
dir,
|
||||
};
|
||||
for _ in 0..100 {
|
||||
if std::net::TcpStream::connect(("127.0.0.1", port)).is_ok() {
|
||||
return s;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
panic!("server did not start");
|
||||
}
|
||||
|
||||
fn connector(trusted: &Pair) -> TlsConnector {
|
||||
let mut roots = rustls::RootCertStore::empty();
|
||||
for c in CertificateDer::pem_slice_iter(trusted.cert_pem.as_bytes()) {
|
||||
roots.add(c.unwrap()).unwrap();
|
||||
}
|
||||
let cfg = rustls::ClientConfig::builder_with_provider(Arc::new(
|
||||
rustls::crypto::ring::default_provider(),
|
||||
))
|
||||
.with_safe_default_protocol_versions()
|
||||
.unwrap()
|
||||
.with_root_certificates(roots)
|
||||
.with_no_client_auth();
|
||||
TlsConnector::from(Arc::new(cfg))
|
||||
}
|
||||
|
||||
struct Resp {
|
||||
status: u16,
|
||||
head: String,
|
||||
body: String,
|
||||
peer_fp: String,
|
||||
}
|
||||
|
||||
/// One HTTPS request with `Connection: close`.
|
||||
async fn https(
|
||||
port: u16,
|
||||
trusted: &Pair,
|
||||
method: &str,
|
||||
path: &str,
|
||||
headers: &[(&str, &str)],
|
||||
body: Option<&str>,
|
||||
) -> Resp {
|
||||
let tcp = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
|
||||
let mut tls = connector(trusted)
|
||||
.connect(ServerName::try_from("localhost").unwrap(), tcp)
|
||||
.await
|
||||
.expect("TLS handshake");
|
||||
let peer_fp = {
|
||||
let (_, conn) = tls.get_ref();
|
||||
let der = &conn.peer_certificates().unwrap()[0];
|
||||
hex(&Sha256::digest(der.as_ref()))
|
||||
};
|
||||
let mut req =
|
||||
format!("{method} {path} HTTP/1.1\r\nHost: localhost:{port}\r\nConnection: close\r\n");
|
||||
for (k, v) in headers {
|
||||
req.push_str(&format!("{k}: {v}\r\n"));
|
||||
}
|
||||
if let Some(b) = body {
|
||||
req.push_str(&format!("Content-Length: {}\r\n", b.len()));
|
||||
}
|
||||
req.push_str("\r\n");
|
||||
if let Some(b) = body {
|
||||
req.push_str(b);
|
||||
}
|
||||
tls.write_all(req.as_bytes()).await.unwrap();
|
||||
let mut buf = Vec::new();
|
||||
let mut chunk = [0u8; 4096];
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
while Instant::now() < deadline {
|
||||
match tokio::time::timeout(Duration::from_secs(2), tls.read(&mut chunk)).await {
|
||||
Ok(Ok(0)) | Ok(Err(_)) | Err(_) => break,
|
||||
Ok(Ok(n)) => buf.extend_from_slice(&chunk[..n]),
|
||||
}
|
||||
}
|
||||
let text = String::from_utf8_lossy(&buf).into_owned();
|
||||
let (head, body) = text.split_once("\r\n\r\n").unwrap_or((&text, ""));
|
||||
let status = head
|
||||
.split_whitespace()
|
||||
.nth(1)
|
||||
.and_then(|s| s.parse().ok())
|
||||
.unwrap_or(0);
|
||||
Resp {
|
||||
status,
|
||||
head: head.to_lowercase(),
|
||||
body: body.to_owned(),
|
||||
peer_fp,
|
||||
}
|
||||
}
|
||||
|
||||
fn hex(b: &[u8]) -> String {
|
||||
b.iter().map(|x| format!("{x:02x}")).collect()
|
||||
}
|
||||
|
||||
fn signal(child: &Child, sig: &str) {
|
||||
assert!(Command::new("kill")
|
||||
.args([sig, &child.id().to_string()])
|
||||
.status()
|
||||
.unwrap()
|
||||
.success());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn healthz_over_https() {
|
||||
let pair = gen_pair();
|
||||
let s = start(&pair);
|
||||
let r = https(s.port, &pair, "GET", "/healthz", &[], None).await;
|
||||
assert_eq!(r.status, 200, "{}", r.head);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn auth_over_tls() {
|
||||
let pair = gen_pair();
|
||||
let s = start(&pair);
|
||||
let r = https(s.port, &pair, "GET", "/api/v1/nope", &[], None).await;
|
||||
assert_eq!(r.status, 401);
|
||||
let auth = format!("Bearer {}", s.token);
|
||||
let r = https(
|
||||
s.port,
|
||||
&pair,
|
||||
"GET",
|
||||
"/api/v1/nope",
|
||||
&[("Authorization", &auth)],
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, 404, "token accepted, route unknown");
|
||||
let r = https(
|
||||
s.port,
|
||||
&pair,
|
||||
"GET",
|
||||
"/api/v1/systemd/units",
|
||||
&[("Authorization", "Bearer wrong")],
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, 401);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn plain_http_to_tls_port_fails() {
|
||||
let pair = gen_pair();
|
||||
let s = start(&pair);
|
||||
let mut c = TcpStream::connect(("127.0.0.1", s.port)).await.unwrap();
|
||||
c.write_all(b"GET /healthz HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
|
||||
.await
|
||||
.unwrap();
|
||||
let mut buf = Vec::new();
|
||||
let _ = tokio::time::timeout(Duration::from_secs(3), c.read_to_end(&mut buf)).await;
|
||||
assert!(
|
||||
!String::from_utf8_lossy(&buf).contains("200 OK"),
|
||||
"plain HTTP must not be served on the TLS port"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_initialize_over_https() {
|
||||
let pair = gen_pair();
|
||||
let s = start(&pair);
|
||||
let auth = format!("Bearer {}", s.token);
|
||||
let origin = format!("https://localhost:{}", s.port);
|
||||
let r = https(
|
||||
s.port,
|
||||
&pair,
|
||||
"POST",
|
||||
"/mcp",
|
||||
&[
|
||||
("Content-Type", "application/json"),
|
||||
("Accept", "application/json, text/event-stream"),
|
||||
("Authorization", &auth),
|
||||
("Origin", &origin),
|
||||
],
|
||||
Some(r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"it","version":"0"}}}"#),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, 200, "{}\n{}", r.head, r.body);
|
||||
assert!(r.body.contains("serverInfo"), "{}", r.body);
|
||||
// The http:// origin is no longer a default when TLS is on.
|
||||
let bad = format!("http://localhost:{}", s.port);
|
||||
let r = https(
|
||||
s.port,
|
||||
&pair,
|
||||
"POST",
|
||||
"/mcp",
|
||||
&[
|
||||
("Content-Type", "application/json"),
|
||||
("Accept", "application/json, text/event-stream"),
|
||||
("Authorization", &auth),
|
||||
("Origin", &bad),
|
||||
],
|
||||
Some("{}"),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, 403);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sighup_serves_new_cert_and_bad_cert_keeps_old() {
|
||||
let a = gen_pair();
|
||||
let b = gen_pair();
|
||||
let s = start(&a);
|
||||
let fp_a = https(s.port, &a, "GET", "/healthz", &[], None)
|
||||
.await
|
||||
.peer_fp;
|
||||
|
||||
// Hold a keep-alive connection across the reload.
|
||||
let tcp = TcpStream::connect(("127.0.0.1", s.port)).await.unwrap();
|
||||
let mut held = connector(&a)
|
||||
.connect(ServerName::try_from("localhost").unwrap(), tcp)
|
||||
.await
|
||||
.unwrap();
|
||||
held.write_all(b"GET /healthz HTTP/1.1\r\nHost: localhost\r\n\r\n")
|
||||
.await
|
||||
.unwrap();
|
||||
let mut buf = [0u8; 1024];
|
||||
assert!(held.read(&mut buf).await.unwrap() > 0);
|
||||
|
||||
// Corrupt cert: reload fails, old cert still served.
|
||||
std::fs::write(s.dir.0.join("cert.pem"), "not a certificate").unwrap();
|
||||
signal(&s.child, "-HUP");
|
||||
tokio::time::sleep(Duration::from_millis(500)).await;
|
||||
let r = https(s.port, &a, "GET", "/healthz", &[], None).await;
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.peer_fp, fp_a, "bad reload must keep the old certificate");
|
||||
|
||||
// Valid new pair: SIGHUP swaps it.
|
||||
write_pair(&s.dir.0, &b);
|
||||
signal(&s.child, "-HUP");
|
||||
let mut fp_b = String::new();
|
||||
for _ in 0..30 {
|
||||
tokio::time::sleep(Duration::from_millis(200)).await;
|
||||
fp_b = https(s.port, &b, "GET", "/healthz", &[], None)
|
||||
.await
|
||||
.peer_fp;
|
||||
if fp_b != fp_a {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_ne!(fp_b, fp_a, "SIGHUP should serve the new certificate");
|
||||
|
||||
// The pre-reload connection survived.
|
||||
held.write_all(b"GET /healthz HTTP/1.1\r\nHost: localhost\r\n\r\n")
|
||||
.await
|
||||
.unwrap();
|
||||
let n = held.read(&mut buf).await.unwrap();
|
||||
assert!(String::from_utf8_lossy(&buf[..n]).contains("200 OK"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_files_fail_startup() {
|
||||
let dir = tempdir::Dir::new("bad");
|
||||
let pair = gen_pair();
|
||||
let (c, k) = write_pair(&dir.0, &pair);
|
||||
let run = |cert: &Path, key: &Path, tag: &str| {
|
||||
let cfg = config_toml(&dir.0, free_port(), cert, key);
|
||||
let out = Command::new(BIN)
|
||||
.args(["serve", "--config"])
|
||||
.arg(&cfg)
|
||||
.env_clear()
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(!out.status.success(), "{tag}: should fail");
|
||||
String::from_utf8_lossy(&out.stderr).into_owned()
|
||||
};
|
||||
let missing = dir.0.join("missing.pem");
|
||||
assert!(run(&missing, &k, "missing cert").contains("cert_file"));
|
||||
assert!(run(&c, &missing, "missing key").contains("key_file"));
|
||||
let junk = dir.0.join("junk.pem");
|
||||
std::fs::write(&junk, "garbage").unwrap();
|
||||
assert!(run(&junk, &k, "junk cert").contains("cert_file"));
|
||||
assert!(run(&c, &junk, "junk key").contains("key_file"));
|
||||
// Mismatched pair.
|
||||
let other = gen_pair();
|
||||
let ok = dir.0.join("other-key.pem");
|
||||
std::fs::write(&ok, &other.key_pem).unwrap();
|
||||
assert!(run(&c, &ok, "mismatch").contains("does not match"));
|
||||
// No key material in the error output.
|
||||
let err = run(&c, &junk, "junk key");
|
||||
assert!(!err.contains("PRIVATE KEY") && !err.contains("garbage"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enabled_without_paths_fails_validation_and_disabled_ignores_paths() {
|
||||
let dir = tempdir::Dir::new("val");
|
||||
let f = dir.0.join("c.toml");
|
||||
std::fs::write(&f, "[server.tls]\nenabled = true\n").unwrap();
|
||||
let out = Command::new(BIN)
|
||||
.args(["serve", "--config"])
|
||||
.arg(&f)
|
||||
.env_clear()
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(!out.status.success());
|
||||
assert!(String::from_utf8_lossy(&out.stderr).contains("server.tls"));
|
||||
|
||||
// enabled = false with unreadable paths: startup proceeds on plain HTTP.
|
||||
let port = free_port();
|
||||
std::fs::write(
|
||||
&f,
|
||||
format!(
|
||||
"[server]\nport = {port}\n[server.tls]\nenabled = false\ncert_file = \"/nonexistent/c.pem\"\nkey_file = \"/nonexistent/k.pem\"\n[auth]\ndb_path = {:?}\n",
|
||||
dir.0.join("db.sqlite").display().to_string()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
let mut child = Command::new(BIN)
|
||||
.args(["serve", "--config"])
|
||||
.arg(&f)
|
||||
.env_clear()
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let mut up = false;
|
||||
for _ in 0..100 {
|
||||
if let Ok(mut c) = std::net::TcpStream::connect(("127.0.0.1", port)) {
|
||||
use std::io::{Read, Write};
|
||||
c.write_all(b"GET /healthz HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
|
||||
.unwrap();
|
||||
let mut s = String::new();
|
||||
let _ = c.read_to_string(&mut s);
|
||||
up = s.contains("200 OK");
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
assert!(up, "plain HTTP should serve with tls disabled");
|
||||
}
|
||||
|
||||
/// SIGTERM with an open (idle keep-alive) TLS connection and an in-flight
|
||||
/// long-poll still exits 0 within the existing bound.
|
||||
#[tokio::test]
|
||||
async fn sigterm_with_open_tls_connections_exits_promptly() {
|
||||
let pair = gen_pair();
|
||||
let mut s = start(&pair);
|
||||
let tcp = TcpStream::connect(("127.0.0.1", s.port)).await.unwrap();
|
||||
let mut idle = connector(&pair)
|
||||
.connect(ServerName::try_from("localhost").unwrap(), tcp)
|
||||
.await
|
||||
.unwrap();
|
||||
idle.write_all(b"GET /healthz HTTP/1.1\r\nHost: localhost\r\n\r\n")
|
||||
.await
|
||||
.unwrap();
|
||||
let mut buf = [0u8; 1024];
|
||||
let _ = idle.read(&mut buf).await.unwrap();
|
||||
|
||||
// Open SSE stream (journal follow) over TLS, left running.
|
||||
let tcp = TcpStream::connect(("127.0.0.1", s.port)).await.unwrap();
|
||||
let mut sse = connector(&pair)
|
||||
.connect(ServerName::try_from("localhost").unwrap(), tcp)
|
||||
.await
|
||||
.unwrap();
|
||||
let req = format!(
|
||||
"GET /api/v1/journal/follow HTTP/1.1\r\nHost: localhost\r\nAccept: text/event-stream\r\nAuthorization: Bearer {}\r\n\r\n",
|
||||
s.token
|
||||
);
|
||||
sse.write_all(req.as_bytes()).await.unwrap();
|
||||
let _ = tokio::time::timeout(Duration::from_millis(500), sse.read(&mut buf)).await;
|
||||
|
||||
signal(&s.child, "-TERM");
|
||||
let start = Instant::now();
|
||||
loop {
|
||||
if let Some(st) = s.child.try_wait().unwrap() {
|
||||
assert!(st.success(), "exit status {st}");
|
||||
break;
|
||||
}
|
||||
assert!(
|
||||
start.elapsed() < Duration::from_secs(15),
|
||||
"did not exit within the drain bound"
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user