#!/usr/bin/env python3 """ Tests for kxd and kxc --------------------- This file contains various integration and validation tests for kxc and kxd. It will create different test configurations and run the compiled server and client under various conditions, to make sure they behave as intended. """ # NOTE: Please run "black run_tests" after making changes, to to make sure the # file has a reasonably uniform coding style. import contextlib import http.client import os import shutil import socket import ssl import subprocess import tempfile import textwrap import threading import time import tracemalloc import unittest tracemalloc.start() ############################################################ # Test infrastructure. # # These functions and classes are used to make the individual tests easier to # write. For the individual test cases, see below. # Path to our built binaries; used to run the server and client for testing # purposes. BINS = os.path.abspath(os.path.dirname(os.path.realpath(__file__)) + "/../out") TEMPDIR = "/does/not/exist" # User the script is running as. Just informational, for troubleshooting # purposes, so we don't care if it's missing. LOGNAME = os.environ.get("LOGNAME", "unknown") def setUpModule(): # pylint: disable=invalid-name if not os.path.isfile(BINS + "/kxd"): raise RuntimeError("kxd not found at " + BINS + "/kxd") if not os.path.isfile(BINS + "/kxc"): raise RuntimeError("kxc not found at " + BINS + "/kxc") if not os.path.isfile(BINS + "/kxgencert"): raise RuntimeError("kxgencert not found at " + BINS + "/kxgencert") global TEMPDIR # pylint: disable=global-statement TEMPDIR = tempfile.mkdtemp(prefix="kxdtest-") def tearDownModule(): # pylint: disable=invalid-name # Remove the temporary directory only on success. # Be extra paranoid about removing. # TODO: Only remove on success. if os.environ.get("KEEPTMP"): return if len(TEMPDIR) > 10 and not TEMPDIR.startswith("/home"): shutil.rmtree(TEMPDIR) @contextlib.contextmanager def pushd(path): prev = os.getcwd() os.chdir(path) yield os.chdir(prev) class Config: def __init__(self, name, host=""): self.path = tempfile.mkdtemp(prefix="config-%s-" % name, dir=TEMPDIR) self.name = name self.host = host self.keys = {} def gen_cert(self): try: cmd = [ BINS + "/kxgencert", "-organization=kxd-tests-%s" % self.name, "-key=" + self.key_path(), "-cert=" + self.cert_path(), ] if self.host: cmd.append("-host=" + self.host) subprocess.check_output(cmd, stderr=subprocess.STDOUT) except subprocess.CalledProcessError as err: print("kxgencert call failed, output: %r" % err.output) raise def cert_path(self): return self.path + "/cert.pem" def key_path(self): return self.path + "/key.pem" def cert(self): return read_all(self.path + "/cert.pem") def new_key( self, name, allowed_clients=None, allowed_hosts=None, email_to=None ): self.keys[name] = os.urandom(1024) key_path = self.path + "/data/" + name + "/" if not os.path.isdir(key_path): os.makedirs(key_path) with open(key_path + "key", "bw") as key: key.write(self.keys[name]) if allowed_clients is not None: with open(key_path + "/allowed_clients", "a") as cfd: for cli in allowed_clients: cfd.write(cli) if allowed_hosts is not None: with open(key_path + "/allowed_hosts", "a") as hfd: for host in allowed_hosts: hfd.write(host + "\n") if email_to is not None: with open(key_path + "/email_to", "a") as efd: efd.write(email_to + "\n") def call(self, server_cert, url): args = [ BINS + "/kxc", "--client_cert=%s/cert.pem" % self.path, "--client_key=%s/key.pem" % self.path, "--server_cert=%s" % server_cert, url, ] try: print("Running client:", " ".join(args)) return subprocess.check_output(args, stderr=subprocess.STDOUT) except subprocess.CalledProcessError as err: print("Client call failed, output: %r" % err.output) raise class ServerConfig(Config): def __init__(self, name="server", host="localhost"): Config.__init__(self, name, host) self.gen_cert() def call(self, server_cert, url): # To prevent accidental calls and to enforce that the test cases # don't mix server and client. return NotImplementedError("ServerConfig does not support call") class ClientConfig(Config): def __init__(self, name="client", host="localhost"): Config.__init__(self, name, host) self.gen_cert() def new_key(self, name, allowed_clients=None, allowed_hosts=None): # To prevent accidental calls and to enforce that the test cases # don't mix server and client. raise NotImplementedError("ClientConfig does not support new_key") class StaticConfig(Config): def __init__(self, path): self.path = path self.host = "localhost" self.keys = {} def gen_cert(self): raise NotImplementedError("StaticConfig does not support gen_cert") def launch_daemon(cfg, smtp_addr=None): args = [ BINS + "/kxd", "--data_dir=%s/data" % cfg, "--key=%s/key.pem" % cfg, "--cert=%s/cert.pem" % cfg, "--logfile=%s/log" % cfg, "--hook=%s/hook" % cfg, ] if smtp_addr: args.append("--smtp_addr=%s:%s" % smtp_addr) print("Launching server: ", " ".join(args)) return subprocess.Popen(args) def read_all(fname): with open(fname) as fd: # pylint: disable=invalid-name return fd.read() def receive_emails(): """Receive emails from the server. Return: - The server address. - A list where we will put the emails: each email is a tuple of (destination addresses, body). """ server = socket.create_server(("localhost", 0)) server.listen(1) addr = server.getsockname() emails = [] def handler(): # Complete a simple SMTP transaction. sock, addr = server.accept() sock.sendall(b"220 localhost SMTP\n") body = b"" rcpt_to = [] while True: data = sock.recv(1024) if not data: break if data.startswith(b"HELO"): sock.sendall(b"250 localhost\n") elif data.startswith(b"MAIL FROM"): sock.sendall(b"250 OK\n") elif data.startswith(b"RCPT TO"): rcpt_to.append(data.split(b"<")[1].split(b">")[0].decode()) sock.sendall(b"250 OK\n") elif data.startswith(b"DATA"): sock.sendall(b"354 Start data\n") body = b"" while True: body += sock.recv(1024) if body.endswith(b"\r\n.\r\n"): sock.sendall(b"250 OK\n") break elif data.startswith(b"QUIT"): sock.sendall(b"221 Chau\n") break else: sock.sendall(b"500 Unknown command\n") emails.append((rcpt_to, body)) sock.close() server.close() server_thread = threading.Thread(target=handler, daemon=True) server_thread.start() return addr, emails class TestCase(unittest.TestCase): def setUp(self): self.server = ServerConfig() self.client = ClientConfig() self.daemon = None self.ca = None # pylint: disable=invalid-name self.launch_server(self.server) def tearDown(self): if self.daemon: self.daemon.terminate() self.daemon.wait() def launch_server(self, server, smtp_addr=None): self.daemon = launch_daemon(server.path, smtp_addr) # Wait for the server to start accepting connections. deadline = time.time() + 5 while time.time() < deadline: try: with socket.create_connection(("localhost", 19840), timeout=5): break except socket.error: continue else: self.fail("Timeout waiting for the server") # pylint: disable=invalid-name def assertClientFails(self, url, regexp, client=None, cert_path=None): if client is None: client = self.client if cert_path is None: cert_path = self.server.cert_path() try: client.call(cert_path, url) except subprocess.CalledProcessError as err: self.assertRegex(err.output.decode(), regexp) else: self.fail("Client call did not fail as expected") ############################################################ # Test cases. # class Simple(TestCase): """Simple test cases for common (mis)configurations.""" def test_simple(self): # There's no need to split these up; by doing all these within a # single test, we speed things up significantly, as we avoid the # overhead of creating the certificates and bringing up the server. server_url = "kxd://" + self.server.host # Normal successful case. self.server.new_key( "k1", allowed_clients=[self.client.cert()], # Depending on the self.server.host, the client may connect to it # from localhost or from another IP; since it is unpredictable we # should allow both. allowed_hosts=["localhost", self.server.host], ) key = self.client.call(self.server.cert_path(), server_url + "/k1") self.assertEqual(key, self.server.keys["k1"]) # Unknown key -> 404. self.assertClientFails(server_url + "/k2", "404 Not Found") # No certificates allowed -> 403. self.server.new_key("k3", allowed_hosts=["localhost", self.server.host]) self.assertClientFails( server_url + "/k3", "403 Forbidden.*No allowed certificate found" ) # Host not allowed -> 403. self.server.new_key( "k4", allowed_clients=[self.client.cert()], allowed_hosts=[] ) self.assertClientFails( server_url + "/k4", "403 Forbidden.*Host not allowed" ) # Nothing allowed -> 403. # We don't restrict the reason of failure, that's not defined in this # case, as it could be either the host or the cert that are validated # first. self.server.new_key("k5") self.assertClientFails(server_url + "/k5", "403 Forbidden") # We tell the client to expect the server certificate to be the client # one, which is never going to work. self.assertClientFails( server_url + "/k1", "certificate signed by unknown authority", cert_path=self.client.cert_path(), ) class WildcardHostnamesKxgencert(Simple): """Tests for certificates with DNSNames='*'. In kxd <= 0.16, by default kxgencert (and before than, the equivalent scripts) would generate certificates with DNSNames='*', and everything worked okay. But in Go 1.23, the Go TLS library started to reject such certificates (Go commit 375031d8dcec9ae74d2dbc437b201107dba3bb5f). We changed the defaults since then, but we still want to make sure that the server can handle such certificates, as they might still be in use in the wild. This test uses static certificates generated with the old defaults, to be absolutely sure they survive even through changes in the key generation code. """ _cert_dir = "wildcard_test_certs_kxgencert" def setUp(self): test_dir = os.path.dirname(os.path.realpath(__file__)) self.server = StaticConfig(test_dir + "/" + self._cert_dir + "/server") self.client = StaticConfig(test_dir + "/" + self._cert_dir + "/client") self.daemon = None self.ca = None # pylint: disable=invalid-name self.launch_server(self.server) def test_minimal(self): self.server.new_key( "k1", allowed_clients=[self.client.cert()], allowed_hosts=["localhost"], ) key = self.client.call(self.server.cert_path(), "kxd://localhost/k1") self.assertEqual(key, self.server.keys["k1"]) # Reuse the rest of the Simple test cases. class WildcardHostnamesOpenSSL(WildcardHostnamesKxgencert): """Tests for certificates with DNSNames='*' generated with OpenSSL.""" _cert_dir = "wildcard_test_certs_openssl" class SpecificHostnames(Simple): """Tests for certificates with specific hostnames. These tests check that the server ignores the client certificate's hostname, and that the client validates the server certificate's hostname in scenarios that it is different than `localhost`. """ def setUp(self): self.server = ServerConfig(host=socket.gethostname()) self.client = ClientConfig(host="client-" + os.urandom(8).hex()) self.daemon = None self.ca = None # pylint: disable=invalid-name self.launch_server(self.server) def test_minimal(self): self.server.new_key( "k1", allowed_clients=[self.client.cert()], allowed_hosts=["localhost", self.server.host], ) key = self.client.call( self.server.cert_path(), "kxd://" + self.server.host + "/k1" ) self.assertEqual(key, self.server.keys["k1"]) class CertFor127_0_0_1(Simple): """Tests for server certificate for 127.0.0.1 (instead of a name).""" def setUp(self): self.server = ServerConfig(host="127.0.0.1") self.client = ClientConfig(host="client-" + os.urandom(8).hex()) self.daemon = None self.ca = None # pylint: disable=invalid-name self.launch_server(self.server) def test_minimal(self): self.server.new_key( "k1", allowed_clients=[self.client.cert()], allowed_hosts=["localhost"], ) key = self.client.call( self.server.cert_path(), "kxd://" + self.server.host + "/k1" ) self.assertEqual(key, self.server.keys["k1"]) class CommonErrors(TestCase): """Simple test cases for common errors.""" def test_invalid_schema(self): self.assertClientFails("invalidschema://a/b", "unsupported URL schema") def test_invalid_url(self): self.assertClientFails( " http://invalid/url", "first path segment in URL cannot contain colon", ) def test_empty_server_cert(self): self.assertClientFails( "kxd://localhost/k1", "Failed to load server certs: error appending certificates", cert_path="/dev/null", ) def test_unknown_server_cert_file(self): self.assertClientFails( "kxd://localhost/k1", "open /does/not/exist: no such file or directory", cert_path="/does/not/exist", ) def test_bad_server_cert_file(self): test_dir = os.path.dirname(os.path.realpath(__file__)) self.assertClientFails( "kxd://localhost/k1", "x509: malformed certificate", cert_path=test_dir + "/bad_cert/cert.pem", ) class Multiples(TestCase): """Tests for multiple clients and keys.""" def setUp(self): TestCase.setUp(self) self.client2 = ClientConfig(name="client2") def test_two_clients(self): self.server.new_key( "k1", allowed_clients=[self.client.cert(), self.client2.cert()], allowed_hosts=["localhost"], ) key = self.client.call(self.server.cert_path(), "kxd://localhost/k1") self.assertEqual(key, self.server.keys["k1"]) key = self.client2.call(self.server.cert_path(), "kxd://localhost/k1") self.assertEqual(key, self.server.keys["k1"]) # Only one client allowed. self.server.new_key( "k2", allowed_clients=[self.client.cert()], allowed_hosts=["localhost"], ) key = self.client.call(self.server.cert_path(), "kxd://localhost/k2") self.assertEqual(key, self.server.keys["k2"]) self.assertClientFails( "kxd://localhost/k2", "403 Forbidden.*No allowed certificate found", client=self.client2, ) def test_many_keys(self): keys = ["a", "d/e", "a/b/c", "d/"] for key in keys: self.server.new_key( key, allowed_clients=[self.client.cert(), self.client2.cert()], allowed_hosts=["localhost"], ) for key in keys: data = self.client.call( self.server.cert_path(), "kxd://localhost/%s" % key ) self.assertEqual(data, self.server.keys[key]) data = self.client2.call( self.server.cert_path(), "kxd://localhost/%s" % key ) self.assertEqual(data, self.server.keys[key]) self.assertClientFails("kxd://localhost/a/b", "404 Not Found") def test_two_servers(self): server1 = self.server server1.new_key("k1", allowed_clients=[self.client.cert()]) server2 = ServerConfig(name="server2") server2.new_key("k1", allowed_clients=[self.client.cert()]) # Write a file containing the certs of both servers. server_certs_path = self.client.path + "/server_certs.pem" server_certs = open(server_certs_path, "w") server_certs.write(read_all(server1.cert_path())) server_certs.write(read_all(server2.cert_path())) server_certs.close() key = self.client.call(server_certs_path, "kxd://localhost/k1") self.assertEqual(key, server1.keys["k1"]) self.daemon.terminate() self.daemon.wait() time.sleep(0.5) self.launch_server(server2) key = self.client.call(server_certs_path, "kxd://localhost/k1") self.assertEqual(key, server2.keys["k1"]) class TrickyRequests(TestCase): """Tests for tricky requests.""" def https_connection(self, host, port, key_file=None, cert_file=None): # Get an SSL context that can validate our server certificate. context = ssl.create_default_context(cafile=self.server.cert_path()) context.check_hostname = False if cert_file: context.load_cert_chain(cert_file, key_file) return http.client.HTTPSConnection(host, port, context=context) def test_no_local_cert(self): """No local certificate.""" conn = self.https_connection("localhost", 19840) try: conn.request("GET", "/v1/") conn.getresponse() conn.close() except ssl.SSLError as err: # Expect one of these errors (the specific one can change # depending on the version of OpenSSL). self.assertIn( err.reason, [ "SSLV3_ALERT_BAD_CERTIFICATE", "TLSV13_ALERT_CERTIFICATE_REQUIRED", ], ) else: self.fail("Client call did not fail as expected") def test_path_with_dotdot(self): """Requests with '..'.""" conn = self.https_connection( "localhost", 19840, key_file=self.client.key_path(), cert_file=self.client.cert_path(), ) conn.request("GET", "/v1/a/../b") response = conn.getresponse() conn.close() # Go's http server intercepts these and gives us a 301 Moved # Permanently. self.assertEqual(response.status, 301) def test_invalid_path(self): conn = self.https_connection( "localhost", 19840, key_file=self.client.key_path(), cert_file=self.client.cert_path(), ) conn.request("GET", "/v1/a..b") response = conn.getresponse() conn.close() self.assertEqual(response.status, 406) def test_server_cert(self): rawsock = socket.create_connection(("localhost", 19840)) context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) context.load_verify_locations(self.server.cert_path()) context.check_hostname = False sock = context.wrap_socket(rawsock) # We don't check the cipher itself, as it depends on the environment, # but we should be using >= 128 bit secrets. self.assertTrue(sock.cipher()[2] >= 128) server_cert = ssl.DER_cert_to_PEM_cert( sock.getpeercert(binary_form=True) ) self.assertEqual(server_cert, self.server.cert()) sock.close() class BrokenServerConfig(TestCase): """Tests for a broken server config.""" def test_broken_client_certs(self): self.server.new_key( "k1", allowed_clients=[self.client.cert()], allowed_hosts=["localhost"], ) # Corrupt the client certificate. with open(self.server.path + "/data/k1/allowed_clients", "tr+") as cfd: cfd.seek(30) cfd.write("+/+BROKEN+/+") self.assertClientFails( "kxd://localhost/k1", "Error loading certs|No allowed certificate found", ) def test_missing_key(self): self.server.new_key( "k1", allowed_clients=[self.client.cert()], allowed_hosts=["localhost"], ) os.unlink(self.server.path + "/data/k1/key") self.assertClientFails("kxd://localhost/k1", "404 Not Found") EMAIL_TO_FILE = textwrap.dedent( """ # Comment. me@example.com you@test.net """.strip() ) class Hook(TestCase): """Test cases for hook support.""" HOOK_SCRIPT_TMPL = textwrap.dedent( """ #!/bin/sh pwd > hook-output env >> hook-output exit {exit_code} """.strip() ) def write_hook(self, exit_code): path = self.server.path + "/hook" script = self.HOOK_SCRIPT_TMPL.format(exit_code=exit_code) with open(path, "w") as hook: hook.write(script) os.chmod(path, 0o770) def test_simple(self): self.write_hook(exit_code=0) # Normal successful case. self.server.new_key( "k1", allowed_clients=[self.client.cert()], allowed_hosts=["localhost"], ) key = self.client.call(self.server.cert_path(), "kxd://localhost/k1") self.assertEqual(key, self.server.keys["k1"]) hook_out = read_all(self.server.path + "/data/hook-output") self.assertIn("CLIENT_CERT_SUBJECT=O=kxd-tests-client", hook_out) self.assertNotIn("EMAIL_TO=", hook_out) # Failure caused by the hook exiting with error. self.write_hook(exit_code=1) self.assertClientFails("kxd://localhost/k1", "Prevented by hook") # Failure caused by the hook not being executable. self.write_hook(exit_code=0) os.chmod(self.server.path + "/hook", 0o660) self.assertClientFails("kxd://localhost/k1", "Prevented by hook") def test_email_to(self): self.write_hook(exit_code=0) self.server.new_key( "k2", allowed_clients=[self.client.cert()], allowed_hosts=["localhost"], email_to=EMAIL_TO_FILE, ) key = self.client.call(self.server.cert_path(), "kxd://localhost/k2") self.assertEqual(key, self.server.keys["k2"]) hook_out = read_all(self.server.path + "/data/hook-output") self.assertIn("CLIENT_CERT_SUBJECT=O=kxd-tests-client", hook_out) self.assertIn("EMAIL_TO=me@example.com you@test.net", hook_out) class Emails(TestCase): """Tests for email notifications.""" def setUp(self): self.smtp_addr, self.emails = receive_emails() self.server = ServerConfig() self.client = ClientConfig() self.daemon = None self.ca = None # pylint: disable=invalid-name self.launch_server(self.server, smtp_addr=self.smtp_addr) def test_emails(self): self.server.new_key( "k1", allowed_clients=[self.client.cert()], allowed_hosts=["localhost", self.server.host], email_to=EMAIL_TO_FILE, ) key = self.client.call( self.server.cert_path(), "kxd://" + self.server.host + "/k1" ) self.assertEqual(key, self.server.keys["k1"]) self.assertEqual(len(self.emails), 1) self.assertEqual(self.emails[0][0], ["me@example.com", "you@test.net"]) self.assertRegex( self.emails[0][1].decode().replace("\r\n", "\n"), textwrap.dedent( """\ Date: .* From: Key Exchange Daemon To: me@example.com, you@test.net Subject: Access to key k1 Key: k1 Accessed by: .* On: .* Client certificate: Signature: .* Subject: O=kxd-tests-client Authorizing chains: .* """ ), ) def test_no_emails(self): self.server.new_key( "k2", allowed_clients=[self.client.cert()], allowed_hosts=["localhost", self.server.host], ) key = self.client.call( self.server.cert_path(), "kxd://" + self.server.host + "/k2" ) self.assertEqual(key, self.server.keys["k2"]) # Note that we did not set up email_to, so we don't expect any emails. self.assertEqual(self.emails, []) if __name__ == "__main__": unittest.main()