[qemu.git] / tests / test-crypto-tlssession.c

/*
 * Copyright (C) 2015 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * Author: Daniel P. Berrange <[email protected]>
 */

#include "qemu/osdep.h"

#include "crypto-tls-x509-helpers.h"
#include "crypto/tlscredsx509.h"
#include "crypto/tlssession.h"
#include "qom/object_interfaces.h"
#include "qapi/error.h"
#include "qemu/sockets.h"
#include "qemu/acl.h"

#ifdef QCRYPTO_HAVE_TLS_TEST_SUPPORT

#define WORKDIR "tests/test-crypto-tlssession-work/"
#define KEYFILE WORKDIR "key-ctx.pem"

struct QCryptoTLSSessionTestData {
    const char *servercacrt;
    const char *clientcacrt;
    const char *servercrt;
    const char *clientcrt;
    bool expectServerFail;
    bool expectClientFail;
    const char *hostname;
    const char *const *wildcards;
};


static ssize_t testWrite(const char *buf, size_t len, void *opaque)
{
    int *fd = opaque;

    return write(*fd, buf, len);
}

static ssize_t testRead(char *buf, size_t len, void *opaque)
{
    int *fd = opaque;

    return read(*fd, buf, len);
}

static QCryptoTLSCreds *test_tls_creds_create(QCryptoTLSCredsEndpoint endpoint,
                                              const char *certdir,
                                              Error **errp)
{
    Error *err = NULL;
    Object *parent = object_get_objects_root();
    Object *creds = object_new_with_props(
        TYPE_QCRYPTO_TLS_CREDS_X509,
        parent,
        (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ?
         "testtlscredsserver" : "testtlscredsclient"),
        &err,
        "endpoint", (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ?
                     "server" : "client"),
        "dir", certdir,
        "verify-peer", "yes",
        /* We skip initial sanity checks here because we
         * want to make sure that problems are being
         * detected at the TLS session validation stage,
         * and the test-crypto-tlscreds test already
         * validate the sanity check code.
         */
        "sanity-check", "no",
        NULL
        );

    if (err) {
        error_propagate(errp, err);
        return NULL;
    }
    return QCRYPTO_TLS_CREDS(creds);
}


/*
 * This tests validation checking of peer certificates
 *
 * This is replicating the checks that are done for an
 * active TLS session after handshake completes. To
 * simulate that we create our TLS contexts, skipping
 * sanity checks. We then get a socketpair, and
 * initiate a TLS session across them. Finally do
 * do actual cert validation tests
 */
static void test_crypto_tls_session(const void *opaque)
{
    struct QCryptoTLSSessionTestData *data =
        (struct QCryptoTLSSessionTestData *)opaque;
    QCryptoTLSCreds *clientCreds;
    QCryptoTLSCreds *serverCreds;
    QCryptoTLSSession *clientSess = NULL;
    QCryptoTLSSession *serverSess = NULL;
    qemu_acl *acl;
    const char * const *wildcards;
    int channel[2];
    bool clientShake = false;
    bool serverShake = false;
    Error *err = NULL;
    int ret;

    /* We'll use this for our fake client-server connection */
    ret = socketpair(AF_UNIX, SOCK_STREAM, 0, channel);
    g_assert(ret == 0);

    /*
     * We have an evil loop to do the handshake in a single
     * thread, so we need these non-blocking to avoid deadlock
     * of ourselves
     */
    qemu_set_nonblock(channel[0]);
    qemu_set_nonblock(channel[1]);

#define CLIENT_CERT_DIR "tests/test-crypto-tlssession-client/"
#define SERVER_CERT_DIR "tests/test-crypto-tlssession-server/"
    mkdir(CLIENT_CERT_DIR, 0700);
    mkdir(SERVER_CERT_DIR, 0700);

    unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
    unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT);
    unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY);

    unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
    unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
    unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);

    g_assert(link(data->servercacrt,
                  SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT) == 0);
    g_assert(link(data->servercrt,
                  SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT) == 0);
    g_assert(link(KEYFILE,
                  SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY) == 0);

    g_assert(link(data->clientcacrt,
                  CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT) == 0);
    g_assert(link(data->clientcrt,
                  CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT) == 0);
    g_assert(link(KEYFILE,
                  CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY) == 0);

    clientCreds = test_tls_creds_create(
        QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT,
        CLIENT_CERT_DIR,
        &err);
    g_assert(clientCreds != NULL);

    serverCreds = test_tls_creds_create(
        QCRYPTO_TLS_CREDS_ENDPOINT_SERVER,
        SERVER_CERT_DIR,
        &err);
    g_assert(serverCreds != NULL);

    acl = qemu_acl_init("tlssessionacl");
    qemu_acl_reset(acl);
    wildcards = data->wildcards;
    while (wildcards && *wildcards) {
        qemu_acl_append(acl, 0, *wildcards);
        wildcards++;
    }

    /* Now the real part of the test, setup the sessions */
    clientSess = qcrypto_tls_session_new(
        clientCreds, data->hostname, NULL,
        QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT, &err);
    serverSess = qcrypto_tls_session_new(
        serverCreds, NULL,
        data->wildcards ? "tlssessionacl" : NULL,
        QCRYPTO_TLS_CREDS_ENDPOINT_SERVER, &err);

    g_assert(clientSess != NULL);
    g_assert(serverSess != NULL);

    /* For handshake to work, we need to set the I/O callbacks
     * to read/write over the socketpair
     */
    qcrypto_tls_session_set_callbacks(serverSess,
                                      testWrite, testRead,
                                      &channel[0]);
    qcrypto_tls_session_set_callbacks(clientSess,
                                      testWrite, testRead,
                                      &channel[1]);

    /*
     * Finally we loop around & around doing handshake on each
     * session until we get an error, or the handshake completes.
     * This relies on the socketpair being nonblocking to avoid
     * deadlocking ourselves upon handshake
     */
    do {
        int rv;
        if (!serverShake) {
            rv = qcrypto_tls_session_handshake(serverSess,
                                               &err);
            g_assert(rv >= 0);
            if (qcrypto_tls_session_get_handshake_status(serverSess) ==
                QCRYPTO_TLS_HANDSHAKE_COMPLETE) {
                serverShake = true;
            }
        }
        if (!clientShake) {
            rv = qcrypto_tls_session_handshake(clientSess,
                                               &err);
            g_assert(rv >= 0);
            if (qcrypto_tls_session_get_handshake_status(clientSess) ==
                QCRYPTO_TLS_HANDSHAKE_COMPLETE) {
                clientShake = true;
            }
        }
    } while (!clientShake && !serverShake);


    /* Finally make sure the server validation does what
     * we were expecting
     */
    if (qcrypto_tls_session_check_credentials(serverSess, &err) < 0) {
        g_assert(data->expectServerFail);
        error_free(err);
        err = NULL;
    } else {
        g_assert(!data->expectServerFail);
    }

    /*
     * And the same for the client validation check
     */
    if (qcrypto_tls_session_check_credentials(clientSess, &err) < 0) {
        g_assert(data->expectClientFail);
        error_free(err);
        err = NULL;
    } else {
        g_assert(!data->expectClientFail);
    }

    unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
    unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT);
    unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY);

    unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
    unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
    unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);

    rmdir(CLIENT_CERT_DIR);
    rmdir(SERVER_CERT_DIR);

    object_unparent(OBJECT(serverCreds));
    object_unparent(OBJECT(clientCreds));

    qcrypto_tls_session_free(serverSess);
    qcrypto_tls_session_free(clientSess);

    close(channel[0]);
    close(channel[1]);
}


int main(int argc, char **argv)
{
    int ret;

    module_call_init(MODULE_INIT_QOM);
    g_test_init(&argc, &argv, NULL);
    setenv("GNUTLS_FORCE_FIPS_MODE", "2", 1);

    mkdir(WORKDIR, 0700);

    test_tls_init(KEYFILE);

# define TEST_SESS_REG(name, caCrt,                                     \
                       serverCrt, clientCrt,                            \
                       expectServerFail, expectClientFail,              \
                       hostname, wildcards)                             \
    struct QCryptoTLSSessionTestData name = {                           \
        caCrt, caCrt, serverCrt, clientCrt,                             \
        expectServerFail, expectClientFail,                             \
        hostname, wildcards                                             \
    };                                                                  \
    g_test_add_data_func("/qcrypto/tlssession/" # name,                 \
                         &name, test_crypto_tls_session);               \


# define TEST_SESS_REG_EXT(name, serverCaCrt, clientCaCrt,              \
                           serverCrt, clientCrt,                        \
                           expectServerFail, expectClientFail,          \
                           hostname, wildcards)                         \
    struct QCryptoTLSSessionTestData name = {                           \
        serverCaCrt, clientCaCrt, serverCrt, clientCrt,                 \
        expectServerFail, expectClientFail,                             \
        hostname, wildcards                                             \
    };                                                                  \
    g_test_add_data_func("/qcrypto/tlssession/" # name,                 \
                         &name, test_crypto_tls_session);               \

    /* A perfect CA, perfect client & perfect server */

    /* Basic:CA:critical */
    TLS_ROOT_REQ(cacertreq,
                 "UK", "qemu CA", NULL, NULL, NULL, NULL,
                 true, true, true,
                 true, true, GNUTLS_KEY_KEY_CERT_SIGN,
                 false, false, NULL, NULL,
                 0, 0);

    TLS_ROOT_REQ(altcacertreq,
                 "UK", "qemu CA 1", NULL, NULL, NULL, NULL,
                 true, true, true,
                 false, false, 0,
                 false, false, NULL, NULL,
                 0, 0);

    TLS_CERT_REQ(servercertreq, cacertreq,
                 "UK", "qemu.org", NULL, NULL, NULL, NULL,
                 true, true, false,
                 true, true,
                 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
                 true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
                 0, 0);
    TLS_CERT_REQ(clientcertreq, cacertreq,
                 "UK", "qemu", NULL, NULL, NULL, NULL,
                 true, true, false,
                 true, true,
                 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
                 true, true, GNUTLS_KP_TLS_WWW_CLIENT, NULL,
                 0, 0);

    TLS_CERT_REQ(clientcertaltreq, altcacertreq,
                 "UK", "qemu", NULL, NULL, NULL, NULL,
                 true, true, false,
                 true, true,
                 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
                 true, true, GNUTLS_KP_TLS_WWW_CLIENT, NULL,
                 0, 0);

    TEST_SESS_REG(basicca, cacertreq.filename,
                  servercertreq.filename, clientcertreq.filename,
                  false, false, "qemu.org", NULL);
    TEST_SESS_REG_EXT(differentca, cacertreq.filename,
                      altcacertreq.filename, servercertreq.filename,
                      clientcertaltreq.filename, true, true, "qemu.org", NULL);


    /* When an altname is set, the CN is ignored, so it must be duplicated
     * as an altname for it to match */
    TLS_CERT_REQ(servercertalt1req, cacertreq,
                 "UK", "qemu.org", "www.qemu.org", "qemu.org",
                 "192.168.122.1", "fec0::dead:beaf",
                 true, true, false,
                 true, true,
                 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
                 true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
                 0, 0);
    /* This intentionally doesn't replicate */
    TLS_CERT_REQ(servercertalt2req, cacertreq,
                 "UK", "qemu.org", "www.qemu.org", "wiki.qemu.org",
                 "192.168.122.1", "fec0::dead:beaf",
                 true, true, false,
                 true, true,
                 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
                 true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
                 0, 0);

    TEST_SESS_REG(altname1, cacertreq.filename,
                  servercertalt1req.filename, clientcertreq.filename,
                  false, false, "qemu.org", NULL);
    TEST_SESS_REG(altname2, cacertreq.filename,
                  servercertalt1req.filename, clientcertreq.filename,
                  false, false, "www.qemu.org", NULL);
    TEST_SESS_REG(altname3, cacertreq.filename,
                  servercertalt1req.filename, clientcertreq.filename,
                  false, true, "wiki.qemu.org", NULL);

    TEST_SESS_REG(altname4, cacertreq.filename,
                  servercertalt2req.filename, clientcertreq.filename,
                  false, true, "qemu.org", NULL);
    TEST_SESS_REG(altname5, cacertreq.filename,
                  servercertalt2req.filename, clientcertreq.filename,
                  false, false, "www.qemu.org", NULL);
    TEST_SESS_REG(altname6, cacertreq.filename,
                  servercertalt2req.filename, clientcertreq.filename,
                  false, false, "wiki.qemu.org", NULL);

    const char *const wildcards1[] = {
        "C=UK,CN=dogfood",
        NULL,
    };
    const char *const wildcards2[] = {
        "C=UK,CN=qemu",
        NULL,
    };
    const char *const wildcards3[] = {
        "C=UK,CN=dogfood",
        "C=UK,CN=qemu",
        NULL,
    };
    const char *const wildcards4[] = {
        "C=UK,CN=qemustuff",
        NULL,
    };
    const char *const wildcards5[] = {
        "C=UK,CN=qemu*",
        NULL,
    };
    const char *const wildcards6[] = {
        "C=UK,CN=*emu*",
        NULL,
    };

    TEST_SESS_REG(wildcard1, cacertreq.filename,
                  servercertreq.filename, clientcertreq.filename,
                  true, false, "qemu.org", wildcards1);
    TEST_SESS_REG(wildcard2, cacertreq.filename,
                  servercertreq.filename, clientcertreq.filename,
                  false, false, "qemu.org", wildcards2);
    TEST_SESS_REG(wildcard3, cacertreq.filename,
                  servercertreq.filename, clientcertreq.filename,
                  false, false, "qemu.org", wildcards3);
    TEST_SESS_REG(wildcard4, cacertreq.filename,
                  servercertreq.filename, clientcertreq.filename,
                  true, false, "qemu.org", wildcards4);
    TEST_SESS_REG(wildcard5, cacertreq.filename,
                  servercertreq.filename, clientcertreq.filename,
                  false, false, "qemu.org", wildcards5);
    TEST_SESS_REG(wildcard6, cacertreq.filename,
                  servercertreq.filename, clientcertreq.filename,
                  false, false, "qemu.org", wildcards6);

    TLS_ROOT_REQ(cacertrootreq,
                 "UK", "qemu root", NULL, NULL, NULL, NULL,
                 true, true, true,
                 true, true, GNUTLS_KEY_KEY_CERT_SIGN,
                 false, false, NULL, NULL,
                 0, 0);
    TLS_CERT_REQ(cacertlevel1areq, cacertrootreq,
                 "UK", "qemu level 1a", NULL, NULL, NULL, NULL,
                 true, true, true,
                 true, true, GNUTLS_KEY_KEY_CERT_SIGN,
                 false, false, NULL, NULL,
                 0, 0);
    TLS_CERT_REQ(cacertlevel1breq, cacertrootreq,
                 "UK", "qemu level 1b", NULL, NULL, NULL, NULL,
                 true, true, true,
                 true, true, GNUTLS_KEY_KEY_CERT_SIGN,
                 false, false, NULL, NULL,
                 0, 0);
    TLS_CERT_REQ(cacertlevel2areq, cacertlevel1areq,
                 "UK", "qemu level 2a", NULL, NULL, NULL, NULL,
                 true, true, true,
                 true, true, GNUTLS_KEY_KEY_CERT_SIGN,
                 false, false, NULL, NULL,
                 0, 0);
    TLS_CERT_REQ(servercertlevel3areq, cacertlevel2areq,
                 "UK", "qemu.org", NULL, NULL, NULL, NULL,
                 true, true, false,
                 true, true,
                 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
                 true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
                 0, 0);
    TLS_CERT_REQ(clientcertlevel2breq, cacertlevel1breq,
                 "UK", "qemu client level 2b", NULL, NULL, NULL, NULL,
                 true, true, false,
                 true, true,
                 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
                 true, true, GNUTLS_KP_TLS_WWW_CLIENT, NULL,
                 0, 0);

    gnutls_x509_crt_t certchain[] = {
        cacertrootreq.crt,
        cacertlevel1areq.crt,
        cacertlevel1breq.crt,
        cacertlevel2areq.crt,
    };

    test_tls_write_cert_chain(WORKDIR "cacertchain-sess.pem",
                              certchain,
                              G_N_ELEMENTS(certchain));

    TEST_SESS_REG(cachain, WORKDIR "cacertchain-sess.pem",
                  servercertlevel3areq.filename, clientcertlevel2breq.filename,
                  false, false, "qemu.org", NULL);

    ret = g_test_run();

    test_tls_discard_cert(&clientcertreq);
    test_tls_discard_cert(&clientcertaltreq);

    test_tls_discard_cert(&servercertreq);
    test_tls_discard_cert(&servercertalt1req);
    test_tls_discard_cert(&servercertalt2req);

    test_tls_discard_cert(&cacertreq);
    test_tls_discard_cert(&altcacertreq);

    test_tls_discard_cert(&cacertrootreq);
    test_tls_discard_cert(&cacertlevel1areq);
    test_tls_discard_cert(&cacertlevel1breq);
    test_tls_discard_cert(&cacertlevel2areq);
    test_tls_discard_cert(&servercertlevel3areq);
    test_tls_discard_cert(&clientcertlevel2breq);
    unlink(WORKDIR "cacertchain-sess.pem");

    test_tls_cleanup(KEYFILE);
    rmdir(WORKDIR);

    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}

#else /* ! QCRYPTO_HAVE_TLS_TEST_SUPPORT */

int
main(void)
{
    return EXIT_SUCCESS;
}

#endif /* ! QCRYPTO_HAVE_TLS_TEST_SUPPORT */
Commit	Line	Data
d321e1e5 DB	1	/*
	2	* Copyright (C) 2015 Red Hat, Inc.
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Lesser General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2.1 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Lesser General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Lesser General Public
	15	* License along with this library. If not, see
	16	* <http://www.gnu.org/licenses/>.
	17	*
	18	* Author: Daniel P. Berrange <[email protected]>
	19	*/
	20
681c28a3	21	#include "qemu/osdep.h"
d321e1e5	22
d321e1e5 DB	23	#include "crypto-tls-x509-helpers.h"
	24	#include "crypto/tlscredsx509.h"
	25	#include "crypto/tlssession.h"
	26	#include "qom/object_interfaces.h"
da34e65c	27	#include "qapi/error.h"
d321e1e5 DB	28	#include "qemu/sockets.h"
	29	#include "qemu/acl.h"
	30
	31	#ifdef QCRYPTO_HAVE_TLS_TEST_SUPPORT
	32
	33	#define WORKDIR "tests/test-crypto-tlssession-work/"
	34	#define KEYFILE WORKDIR "key-ctx.pem"
	35
	36	struct QCryptoTLSSessionTestData {
	37	const char *servercacrt;
	38	const char *clientcacrt;
	39	const char *servercrt;
	40	const char *clientcrt;
	41	bool expectServerFail;
	42	bool expectClientFail;
	43	const char *hostname;
	44	const char const wildcards;
	45	};
	46
	47
	48	static ssize_t testWrite(const char buf, size_t len, void opaque)
	49	{
	50	int *fd = opaque;
	51
	52	return write(*fd, buf, len);
	53	}
	54
	55	static ssize_t testRead(char buf, size_t len, void opaque)
	56	{
	57	int *fd = opaque;
	58
	59	return read(*fd, buf, len);
	60	}
	61
	62	static QCryptoTLSCreds *test_tls_creds_create(QCryptoTLSCredsEndpoint endpoint,
	63	const char *certdir,
	64	Error **errp)
	65	{
	66	Error *err = NULL;
	67	Object *parent = object_get_objects_root();
	68	Object *creds = object_new_with_props(
	69	TYPE_QCRYPTO_TLS_CREDS_X509,
	70	parent,
	71	(endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ?
	72	"testtlscredsserver" : "testtlscredsclient"),
	73	&err,
	74	"endpoint", (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ?
	75	"server" : "client"),
	76	"dir", certdir,
	77	"verify-peer", "yes",
	78	/* We skip initial sanity checks here because we
	79	* want to make sure that problems are being
	80	* detected at the TLS session validation stage,
	81	* and the test-crypto-tlscreds test already
	82	* validate the sanity check code.
	83	*/
	84	"sanity-check", "no",
	85	NULL
	86	);
	87
	88	if (err) {
	89	error_propagate(errp, err);
	90	return NULL;
	91	}
92	return QCRYPTO_TLS_CREDS(creds);
93	}
94
95
96	/*
97	* This tests validation checking of peer certificates
98	*
99	* This is replicating the checks that are done for an
100	* active TLS session after handshake completes. To
101	* simulate that we create our TLS contexts, skipping
102	* sanity checks. We then get a socketpair, and
103	* initiate a TLS session across them. Finally do
104	* do actual cert validation tests
105	*/
106	static void test_crypto_tls_session(const void *opaque)
107	{
108	struct QCryptoTLSSessionTestData *data =
109	(struct QCryptoTLSSessionTestData *)opaque;
110	QCryptoTLSCreds *clientCreds;
111	QCryptoTLSCreds *serverCreds;
112	QCryptoTLSSession *clientSess = NULL;
113	QCryptoTLSSession *serverSess = NULL;
114	qemu_acl *acl;
115	const char * const *wildcards;
116	int channel[2];
117	bool clientShake = false;
118	bool serverShake = false;
119	Error *err = NULL;
120	int ret;
121
122	/* We'll use this for our fake client-server connection */
123	ret = socketpair(AF_UNIX, SOCK_STREAM, 0, channel);
124	g_assert(ret == 0);
125
126	/*
127	* We have an evil loop to do the handshake in a single
128	* thread, so we need these non-blocking to avoid deadlock
129	* of ourselves
130	*/
131	qemu_set_nonblock(channel[0]);
132	qemu_set_nonblock(channel[1]);
133
134	#define CLIENT_CERT_DIR "tests/test-crypto-tlssession-client/"
135	#define SERVER_CERT_DIR "tests/test-crypto-tlssession-server/"
136	mkdir(CLIENT_CERT_DIR, 0700);
137	mkdir(SERVER_CERT_DIR, 0700);
138
139	unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
140	unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT);
141	unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY);
142
143	unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
144	unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
145	unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);
146
147	g_assert(link(data->servercacrt,
148	SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT) == 0);
149	g_assert(link(data->servercrt,
150	SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT) == 0);
151	g_assert(link(KEYFILE,
152	SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY) == 0);
153
154	g_assert(link(data->clientcacrt,
155	CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT) == 0);
156	g_assert(link(data->clientcrt,
157	CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT) == 0);
158	g_assert(link(KEYFILE,
159	CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY) == 0);
160
161	clientCreds = test_tls_creds_create(
162	QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT,
163	CLIENT_CERT_DIR,
164	&err);
165	g_assert(clientCreds != NULL);
166
167	serverCreds = test_tls_creds_create(
168	QCRYPTO_TLS_CREDS_ENDPOINT_SERVER,
169	SERVER_CERT_DIR,
170	&err);
171	g_assert(serverCreds != NULL);
172
173	acl = qemu_acl_init("tlssessionacl");
174	qemu_acl_reset(acl);
175	wildcards = data->wildcards;
176	while (wildcards && *wildcards) {
177	qemu_acl_append(acl, 0, *wildcards);
178	wildcards++;
179	}
180
181	/* Now the real part of the test, setup the sessions */
182	clientSess = qcrypto_tls_session_new(
183	clientCreds, data->hostname, NULL,
184	QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT, &err);
185	serverSess = qcrypto_tls_session_new(
186	serverCreds, NULL,
187	data->wildcards ? "tlssessionacl" : NULL,
188	QCRYPTO_TLS_CREDS_ENDPOINT_SERVER, &err);
189
190	g_assert(clientSess != NULL);
191	g_assert(serverSess != NULL);
192
193	/* For handshake to work, we need to set the I/O callbacks
194	* to read/write over the socketpair
195	*/
196	qcrypto_tls_session_set_callbacks(serverSess,
197	testWrite, testRead,
198	&channel[0]);
199	qcrypto_tls_session_set_callbacks(clientSess,
200	testWrite, testRead,
201	&channel[1]);
202
203	/*
204	* Finally we loop around & around doing handshake on each
205	* session until we get an error, or the handshake completes.
206	* This relies on the socketpair being nonblocking to avoid
207	* deadlocking ourselves upon handshake
208	*/
209	do {
210	int rv;
211	if (!serverShake) {
212	rv = qcrypto_tls_session_handshake(serverSess,
213	&err);
214	g_assert(rv >= 0);
215	if (qcrypto_tls_session_get_handshake_status(serverSess) ==
216	QCRYPTO_TLS_HANDSHAKE_COMPLETE) {
217	serverShake = true;
218	}
219	}
220	if (!clientShake) {
221	rv = qcrypto_tls_session_handshake(clientSess,
222	&err);
223	g_assert(rv >= 0);
224	if (qcrypto_tls_session_get_handshake_status(clientSess) ==
225	QCRYPTO_TLS_HANDSHAKE_COMPLETE) {
226	clientShake = true;
227	}
228	}
229	} while (!clientShake && !serverShake);
230
231
232	/* Finally make sure the server validation does what
233	* we were expecting
234	*/
235	if (qcrypto_tls_session_check_credentials(serverSess, &err) < 0) {
236	g_assert(data->expectServerFail);
237	error_free(err);
238	err = NULL;
239	} else {
240	g_assert(!data->expectServerFail);
241	}
242
243	/*
244	* And the same for the client validation check
245	*/
246	if (qcrypto_tls_session_check_credentials(clientSess, &err) < 0) {
247	g_assert(data->expectClientFail);
248	error_free(err);
249	err = NULL;
250	} else {
251	g_assert(!data->expectClientFail);
252	}
253
254	unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
255	unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT);
256	unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY);
257
258	unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT);
259	unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
260	unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);
261
262	rmdir(CLIENT_CERT_DIR);
263	rmdir(SERVER_CERT_DIR);
264
265	object_unparent(OBJECT(serverCreds));
266	object_unparent(OBJECT(clientCreds));
267
268	qcrypto_tls_session_free(serverSess);
269	qcrypto_tls_session_free(clientSess);
270
271	close(channel[0]);
272	close(channel[1]);
273	}
274
275
276	int main(int argc, char **argv)
277	{
278	int ret;
279
280	module_call_init(MODULE_INIT_QOM);
281	g_test_init(&argc, &argv, NULL);
282	setenv("GNUTLS_FORCE_FIPS_MODE", "2", 1);
283
284	mkdir(WORKDIR, 0700);
285
286	test_tls_init(KEYFILE);
287
288	# define TEST_SESS_REG(name, caCrt, \
289	serverCrt, clientCrt, \
290	expectServerFail, expectClientFail, \
291	hostname, wildcards) \
292	struct QCryptoTLSSessionTestData name = { \
293	caCrt, caCrt, serverCrt, clientCrt, \
294	expectServerFail, expectClientFail, \
295	hostname, wildcards \
296	}; \
297	g_test_add_data_func("/qcrypto/tlssession/" # name, \
298	&name, test_crypto_tls_session); \
299
300
301	# define TEST_SESS_REG_EXT(name, serverCaCrt, clientCaCrt, \
302	serverCrt, clientCrt, \
303	expectServerFail, expectClientFail, \
304	hostname, wildcards) \
305	struct QCryptoTLSSessionTestData name = { \
306	serverCaCrt, clientCaCrt, serverCrt, clientCrt, \
307	expectServerFail, expectClientFail, \
308	hostname, wildcards \
309	}; \
310	g_test_add_data_func("/qcrypto/tlssession/" # name, \
311	&name, test_crypto_tls_session); \
312
313	/* A perfect CA, perfect client & perfect server */
314
315	/* Basic:CA:critical */
316	TLS_ROOT_REQ(cacertreq,
317	"UK", "qemu CA", NULL, NULL, NULL, NULL,
318	true, true, true,
319	true, true, GNUTLS_KEY_KEY_CERT_SIGN,
320	false, false, NULL, NULL,
321	0, 0);
322
323	TLS_ROOT_REQ(altcacertreq,
324	"UK", "qemu CA 1", NULL, NULL, NULL, NULL,
325	true, true, true,
326	false, false, 0,
327	false, false, NULL, NULL,
328	0, 0);
329
330	TLS_CERT_REQ(servercertreq, cacertreq,
331	"UK", "qemu.org", NULL, NULL, NULL, NULL,
332	true, true, false,
333	true, true,
334	GNUTLS_KEY_DIGITAL_SIGNATURE \| GNUTLS_KEY_KEY_ENCIPHERMENT,
335	true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
336	0, 0);
337	TLS_CERT_REQ(clientcertreq, cacertreq,
338	"UK", "qemu", NULL, NULL, NULL, NULL,
339	true, true, false,
340	true, true,
341	GNUTLS_KEY_DIGITAL_SIGNATURE \| GNUTLS_KEY_KEY_ENCIPHERMENT,
342	true, true, GNUTLS_KP_TLS_WWW_CLIENT, NULL,
343	0, 0);
344
345	TLS_CERT_REQ(clientcertaltreq, altcacertreq,
346	"UK", "qemu", NULL, NULL, NULL, NULL,
347	true, true, false,
348	true, true,
349	GNUTLS_KEY_DIGITAL_SIGNATURE \| GNUTLS_KEY_KEY_ENCIPHERMENT,
350	true, true, GNUTLS_KP_TLS_WWW_CLIENT, NULL,
351	0, 0);
352
353	TEST_SESS_REG(basicca, cacertreq.filename,
354	servercertreq.filename, clientcertreq.filename,
355	false, false, "qemu.org", NULL);
356	TEST_SESS_REG_EXT(differentca, cacertreq.filename,
357	altcacertreq.filename, servercertreq.filename,
358	clientcertaltreq.filename, true, true, "qemu.org", NULL);
359
360
361	/* When an altname is set, the CN is ignored, so it must be duplicated
362	* as an altname for it to match */
363	TLS_CERT_REQ(servercertalt1req, cacertreq,
364	"UK", "qemu.org", "www.qemu.org", "qemu.org",
365	"192.168.122.1", "fec0::dead:beaf",
366	true, true, false,
367	true, true,
368	GNUTLS_KEY_DIGITAL_SIGNATURE \| GNUTLS_KEY_KEY_ENCIPHERMENT,
369	true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
370	0, 0);
371	/* This intentionally doesn't replicate */
372	TLS_CERT_REQ(servercertalt2req, cacertreq,
373	"UK", "qemu.org", "www.qemu.org", "wiki.qemu.org",
374	"192.168.122.1", "fec0::dead:beaf",
375	true, true, false,
376	true, true,
377	GNUTLS_KEY_DIGITAL_SIGNATURE \| GNUTLS_KEY_KEY_ENCIPHERMENT,
378	true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
379	0, 0);
380
381	TEST_SESS_REG(altname1, cacertreq.filename,
382	servercertalt1req.filename, clientcertreq.filename,
383	false, false, "qemu.org", NULL);
384	TEST_SESS_REG(altname2, cacertreq.filename,
385	servercertalt1req.filename, clientcertreq.filename,
386	false, false, "www.qemu.org", NULL);
387	TEST_SESS_REG(altname3, cacertreq.filename,
388	servercertalt1req.filename, clientcertreq.filename,
389	false, true, "wiki.qemu.org", NULL);
390
391	TEST_SESS_REG(altname4, cacertreq.filename,
392	servercertalt2req.filename, clientcertreq.filename,
393	false, true, "qemu.org", NULL);
394	TEST_SESS_REG(altname5, cacertreq.filename,
395	servercertalt2req.filename, clientcertreq.filename,
396	false, false, "www.qemu.org", NULL);
397	TEST_SESS_REG(altname6, cacertreq.filename,
398	servercertalt2req.filename, clientcertreq.filename,
399	false, false, "wiki.qemu.org", NULL);
400
401	const char *const wildcards1[] = {
402	"C=UK,CN=dogfood",
403	NULL,
404	};
405	const char *const wildcards2[] = {
406	"C=UK,CN=qemu",
407	NULL,
408	};
409	const char *const wildcards3[] = {
410	"C=UK,CN=dogfood",
411	"C=UK,CN=qemu",
412	NULL,
413	};
414	const char *const wildcards4[] = {
415	"C=UK,CN=qemustuff",
416	NULL,
417	};
418	const char *const wildcards5[] = {
419	"C=UK,CN=qemu*",
420	NULL,
421	};
422	const char *const wildcards6[] = {
423	"C=UK,CN=emu",
424	NULL,
425	};
426
427	TEST_SESS_REG(wildcard1, cacertreq.filename,
428	servercertreq.filename, clientcertreq.filename,
429	true, false, "qemu.org", wildcards1);
430	TEST_SESS_REG(wildcard2, cacertreq.filename,
431	servercertreq.filename, clientcertreq.filename,
432	false, false, "qemu.org", wildcards2);
433	TEST_SESS_REG(wildcard3, cacertreq.filename,
434	servercertreq.filename, clientcertreq.filename,
435	false, false, "qemu.org", wildcards3);
436	TEST_SESS_REG(wildcard4, cacertreq.filename,
437	servercertreq.filename, clientcertreq.filename,
438	true, false, "qemu.org", wildcards4);
439	TEST_SESS_REG(wildcard5, cacertreq.filename,
440	servercertreq.filename, clientcertreq.filename,
441	false, false, "qemu.org", wildcards5);
442	TEST_SESS_REG(wildcard6, cacertreq.filename,
443	servercertreq.filename, clientcertreq.filename,
444	false, false, "qemu.org", wildcards6);
445
446	TLS_ROOT_REQ(cacertrootreq,
447	"UK", "qemu root", NULL, NULL, NULL, NULL,
448	true, true, true,
449	true, true, GNUTLS_KEY_KEY_CERT_SIGN,
450	false, false, NULL, NULL,
451	0, 0);
452	TLS_CERT_REQ(cacertlevel1areq, cacertrootreq,
453	"UK", "qemu level 1a", NULL, NULL, NULL, NULL,
454	true, true, true,
455	true, true, GNUTLS_KEY_KEY_CERT_SIGN,
456	false, false, NULL, NULL,
457	0, 0);
458	TLS_CERT_REQ(cacertlevel1breq, cacertrootreq,
459	"UK", "qemu level 1b", NULL, NULL, NULL, NULL,
460	true, true, true,
461	true, true, GNUTLS_KEY_KEY_CERT_SIGN,
462	false, false, NULL, NULL,
463	0, 0);
464	TLS_CERT_REQ(cacertlevel2areq, cacertlevel1areq,
465	"UK", "qemu level 2a", NULL, NULL, NULL, NULL,
466	true, true, true,
467	true, true, GNUTLS_KEY_KEY_CERT_SIGN,
468	false, false, NULL, NULL,
469	0, 0);
470	TLS_CERT_REQ(servercertlevel3areq, cacertlevel2areq,
471	"UK", "qemu.org", NULL, NULL, NULL, NULL,
472	true, true, false,
473	true, true,
474	GNUTLS_KEY_DIGITAL_SIGNATURE \| GNUTLS_KEY_KEY_ENCIPHERMENT,
475	true, true, GNUTLS_KP_TLS_WWW_SERVER, NULL,
476	0, 0);
477	TLS_CERT_REQ(clientcertlevel2breq, cacertlevel1breq,
478	"UK", "qemu client level 2b", NULL, NULL, NULL, NULL,
479	true, true, false,
480	true, true,
481	GNUTLS_KEY_DIGITAL_SIGNATURE \| GNUTLS_KEY_KEY_ENCIPHERMENT,
482	true, true, GNUTLS_KP_TLS_WWW_CLIENT, NULL,
483	0, 0);
484
485	gnutls_x509_crt_t certchain[] = {
486	cacertrootreq.crt,
487	cacertlevel1areq.crt,
488	cacertlevel1breq.crt,
489	cacertlevel2areq.crt,
490	};
491
492	test_tls_write_cert_chain(WORKDIR "cacertchain-sess.pem",
493	certchain,
494	G_N_ELEMENTS(certchain));
495
496	TEST_SESS_REG(cachain, WORKDIR "cacertchain-sess.pem",
497	servercertlevel3areq.filename, clientcertlevel2breq.filename,
498	false, false, "qemu.org", NULL);
499
500	ret = g_test_run();
501
502	test_tls_discard_cert(&clientcertreq);
503	test_tls_discard_cert(&clientcertaltreq);
504
505	test_tls_discard_cert(&servercertreq);
506	test_tls_discard_cert(&servercertalt1req);
507	test_tls_discard_cert(&servercertalt2req);
508
509	test_tls_discard_cert(&cacertreq);
510	test_tls_discard_cert(&altcacertreq);
511
512	test_tls_discard_cert(&cacertrootreq);
513	test_tls_discard_cert(&cacertlevel1areq);
514	test_tls_discard_cert(&cacertlevel1breq);
515	test_tls_discard_cert(&cacertlevel2areq);
516	test_tls_discard_cert(&servercertlevel3areq);
517	test_tls_discard_cert(&clientcertlevel2breq);
518	unlink(WORKDIR "cacertchain-sess.pem");
519
520	test_tls_cleanup(KEYFILE);
521	rmdir(WORKDIR);
522
523	return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
524	}
525
526	#else /* ! QCRYPTO_HAVE_TLS_TEST_SUPPORT */
527
528	int
529	main(void)
530	{
531	return EXIT_SUCCESS;
532	}
533
534	#endif /* ! QCRYPTO_HAVE_TLS_TEST_SUPPORT */