Home /Modules/server-edition/test_tls_integration.py

test_tls_integration.py

server-edition/tests/test_tls_integration.py · 177 line(s) · py

#!/usr/bin/env python3
"""Local mTLS integration test. Uses temporary certificates and loopback only."""
from __future__ import annotations

import argparse
import os
import pathlib
import socket
import ssl
import struct
import subprocess
import tempfile
import time


def run(*args: str, cwd: pathlib.Path) -> None:
    subprocess.run(args, cwd=cwd, check=True, stdout=subprocess.DEVNULL,
                   stderr=subprocess.DEVNULL)


def make_certificates(root: pathlib.Path) -> dict[str, pathlib.Path]:
    paths = {name: root / name for name in (
        "ca.key", "ca.crt", "server.key", "server.csr", "server.crt",
        "client.key", "client.csr", "client.crt", "other-client.key",
        "other-client.csr", "other-client.crt", "other-ca.key",
        "other-ca.crt", "bad-client.key", "bad-client.csr", "bad-client.crt",
        "server-ext.cnf", "client-ext.cnf",
    )}
    run("openssl", "req", "-x509", "-newkey", "rsa:2048", "-nodes",
        "-keyout", str(paths["ca.key"]), "-out", str(paths["ca.crt"]),
        "-days", "2", "-subj", "/CN=SLeeLa-Test-CA", cwd=root)
    run("openssl", "req", "-newkey", "rsa:2048", "-nodes",
        "-keyout", str(paths["server.key"]), "-out", str(paths["server.csr"]),
        "-subj", "/CN=localhost", cwd=root)
    paths["server-ext.cnf"].write_text(
        "[server]\nsubjectAltName=DNS:localhost,IP:127.0.0.1\nextendedKeyUsage=serverAuth\n",
        encoding="utf-8")
    run("openssl", "x509", "-req", "-in", str(paths["server.csr"]),
        "-CA", str(paths["ca.crt"]), "-CAkey", str(paths["ca.key"]),
        "-CAcreateserial", "-out", str(paths["server.crt"]), "-days", "2",
        "-extfile", str(paths["server-ext.cnf"]), "-extensions", "server", cwd=root)
    run("openssl", "req", "-newkey", "rsa:2048", "-nodes",
        "-keyout", str(paths["client.key"]), "-out", str(paths["client.csr"]),
        "-subj", "/CN=integration-client", cwd=root)
    paths["client-ext.cnf"].write_text("[client]\nextendedKeyUsage=clientAuth\n", encoding="utf-8")
    run("openssl", "x509", "-req", "-in", str(paths["client.csr"]),
        "-CA", str(paths["ca.crt"]), "-CAkey", str(paths["ca.key"]),
        "-CAcreateserial", "-out", str(paths["client.crt"]), "-days", "2",
        "-extfile", str(paths["client-ext.cnf"]), "-extensions", "client", cwd=root)
    run("openssl", "req", "-newkey", "rsa:2048", "-nodes",
        "-keyout", str(paths["other-client.key"]), "-out", str(paths["other-client.csr"]),
        "-subj", "/CN=not-allowlisted", cwd=root)
    run("openssl", "x509", "-req", "-in", str(paths["other-client.csr"]),
        "-CA", str(paths["ca.crt"]), "-CAkey", str(paths["ca.key"]),
        "-CAcreateserial", "-out", str(paths["other-client.crt"]), "-days", "2",
        "-extfile", str(paths["client-ext.cnf"]), "-extensions", "client", cwd=root)
    run("openssl", "req", "-x509", "-newkey", "rsa:2048", "-nodes",
        "-keyout", str(paths["other-ca.key"]), "-out", str(paths["other-ca.crt"]),
        "-days", "2", "-subj", "/CN=Untrusted-Test-CA", cwd=root)
    run("openssl", "req", "-newkey", "rsa:2048", "-nodes",
        "-keyout", str(paths["bad-client.key"]), "-out", str(paths["bad-client.csr"]),
        "-subj", "/CN=integration-client", cwd=root)
    run("openssl", "x509", "-req", "-in", str(paths["bad-client.csr"]),
        "-CA", str(paths["other-ca.crt"]), "-CAkey", str(paths["other-ca.key"]),
        "-CAcreateserial", "-out", str(paths["bad-client.crt"]), "-days", "2",
        "-extfile", str(paths["client-ext.cnf"]), "-extensions", "client", cwd=root)
    return paths


def free_port() -> int:
    with socket.socket() as sock:
        sock.bind(("127.0.0.1", 0))
        return sock.getsockname()[1]


def context(ca: pathlib.Path, cert: pathlib.Path | None = None,
            key: pathlib.Path | None = None) -> ssl.SSLContext:
    ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=str(ca))
    ctx.minimum_version = ssl.TLSVersion.TLSv1_3
    ctx.maximum_version = ssl.TLSVersion.TLSv1_3
    if cert and key:
        ctx.load_cert_chain(str(cert), str(key))
    return ctx


def send_denied_request(sock: ssl.SSLSocket) -> str:
    headers = b"PROTOCOL-GRADE=1\nSERVICE-ID=health\nOP-ID=ping\nREQUEST-ID=42\n"
    fixed = struct.pack("!4sBBHIIQQQ", b"SLPK", 1, 1, 0, len(headers), 0, 1, 42, 1)
    sock.sendall(fixed + headers)
    return sock.recv(256).decode("ascii", errors="replace")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("server_binary", help="path to built sleelas executable")
    args = parser.parse_args()
    binary = pathlib.Path(args.server_binary).resolve()
    if not binary.exists():
        raise SystemExit(f"server binary does not exist: {binary}")
    with tempfile.TemporaryDirectory(prefix="sleela-mtls-test-") as temp:
        root = pathlib.Path(temp)
        cert = make_certificates(root)
        port = free_port()
        proc = subprocess.Popen([
            str(binary), "--bind", "127.0.0.1", "--port", str(port),
            "--tls-cert", str(cert["server.crt"]), "--tls-key", str(cert["server.key"]),
            "--tls-client-ca", str(cert["ca.crt"]), "--allow-peer", "integration-client",
            "--authorize", "integration-client:health:other",
        ], cwd=root, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        try:
            good = context(cert["ca.crt"], cert["client.crt"], cert["client.key"])
            response = None
            last_error = None
            for _ in range(50):
                if proc.poll() is not None:
                    raise RuntimeError(f"server exited early with code {proc.returncode}")
                try:
                    with socket.create_connection(("127.0.0.1", port), timeout=0.5) as raw:
                        with good.wrap_socket(raw, server_hostname="localhost") as tls:
                            response = send_denied_request(tls)
                    break
                except (OSError, ssl.SSLError) as exc:
                    last_error = exc
                    time.sleep(0.1)
            if response is None:
                raise RuntimeError(f"server TLS startup/handshake failed: {last_error}")
            if not response.startswith("SLPK/1 403 identity_not_authorized"):
                raise AssertionError(f"expected authorization denial, got {response!r}")

            # Offer only X25519: a successful TLS 1.3 handshake proves the server
            # supports this explicitly configured ephemeral DH group.
            group_probe = subprocess.run([
                "openssl", "s_client", "-connect", f"127.0.0.1:{port}",
                "-servername", "localhost", "-tls1_3", "-groups", "X25519",
                "-CAfile", str(cert["ca.crt"]), "-cert", str(cert["client.crt"]),
                "-key", str(cert["client.key"]), "-brief",
            ], cwd=root, input="", text=True, capture_output=True, timeout=5)
            group_output = group_probe.stdout + group_probe.stderr
            if group_probe.returncode != 0 or "TLSv1.3" not in group_output:
                raise AssertionError(f"TLS 1.3 X25519-only handshake failed: {group_output}")

            def assert_rejected(client_context: ssl.SSLContext, description: str) -> None:
                if proc.poll() is not None:
                    raise RuntimeError(f"server exited before rejection test: {proc.returncode}")
                try:
                    with socket.create_connection(("127.0.0.1", port), timeout=2) as raw:
                        with client_context.wrap_socket(raw, server_hostname="localhost") as tls:
                            tls.settimeout(2)
                            try:
                                data = tls.recv(1)
                            except ssl.SSLError:
                                return
                            except socket.timeout as exc:
                                raise AssertionError(f"server did not reject {description} after TLS handshake") from exc
                            if data:
                                raise AssertionError(f"server accepted {description}")
                except (OSError, ssl.SSLError):
                    return

            assert_rejected(context(cert["ca.crt"]), "a client without a certificate")
            assert_rejected(context(cert["ca.crt"], cert["other-client.crt"], cert["other-client.key"]), "a trusted but non-allowlisted identity")
            bad = context(cert["ca.crt"], cert["bad-client.crt"], cert["bad-client.key"])
            assert_rejected(bad, "a certificate from an untrusted CA")
        finally:
            proc.terminate()
            try:
                proc.wait(timeout=5)
            except subprocess.TimeoutExpired:
                proc.kill()
                proc.wait(timeout=5)
    print("TLS integration: PASS (TLS 1.3 X25519, trusted client, unauthorized operation denied, missing/non-allowlisted/untrusted client certificates rejected)")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())