[qemu.git] / crypto / tlssession.c

/*
 * QEMU crypto TLS session support
 *
 * 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 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/>.
 *
 */

#include "qemu/osdep.h"
#include "crypto/tlssession.h"
#include "crypto/tlscredsanon.h"
#include "crypto/tlscredsx509.h"
#include "qapi/error.h"
#include "qemu/acl.h"
#include "trace.h"

#ifdef CONFIG_GNUTLS


#include <gnutls/x509.h>


struct QCryptoTLSSession {
    QCryptoTLSCreds *creds;
    gnutls_session_t handle;
    char *hostname;
    char *aclname;
    bool handshakeComplete;
    QCryptoTLSSessionWriteFunc writeFunc;
    QCryptoTLSSessionReadFunc readFunc;
    void *opaque;
    char *peername;
};


void
qcrypto_tls_session_free(QCryptoTLSSession *session)
{
    if (!session) {
        return;
    }

    gnutls_deinit(session->handle);
    g_free(session->hostname);
    g_free(session->peername);
    g_free(session->aclname);
    object_unref(OBJECT(session->creds));
    g_free(session);
}


static ssize_t
qcrypto_tls_session_push(void *opaque, const void *buf, size_t len)
{
    QCryptoTLSSession *session = opaque;

    if (!session->writeFunc) {
        errno = EIO;
        return -1;
    };

    return session->writeFunc(buf, len, session->opaque);
}


static ssize_t
qcrypto_tls_session_pull(void *opaque, void *buf, size_t len)
{
    QCryptoTLSSession *session = opaque;

    if (!session->readFunc) {
        errno = EIO;
        return -1;
    };

    return session->readFunc(buf, len, session->opaque);
}


QCryptoTLSSession *
qcrypto_tls_session_new(QCryptoTLSCreds *creds,
                        const char *hostname,
                        const char *aclname,
                        QCryptoTLSCredsEndpoint endpoint,
                        Error **errp)
{
    QCryptoTLSSession *session;
    int ret;

    session = g_new0(QCryptoTLSSession, 1);
    trace_qcrypto_tls_session_new(
        session, creds, hostname ? hostname : "<none>",
        aclname ? aclname : "<none>", endpoint);

    if (hostname) {
        session->hostname = g_strdup(hostname);
    }
    if (aclname) {
        session->aclname = g_strdup(aclname);
    }
    session->creds = creds;
    object_ref(OBJECT(creds));

    if (creds->endpoint != endpoint) {
        error_setg(errp, "Credentials endpoint doesn't match session");
        goto error;
    }

    if (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
        ret = gnutls_init(&session->handle, GNUTLS_SERVER);
    } else {
        ret = gnutls_init(&session->handle, GNUTLS_CLIENT);
    }
    if (ret < 0) {
        error_setg(errp, "Cannot initialize TLS session: %s",
                   gnutls_strerror(ret));
        goto error;
    }

    if (object_dynamic_cast(OBJECT(creds),
                            TYPE_QCRYPTO_TLS_CREDS_ANON)) {
        QCryptoTLSCredsAnon *acreds = QCRYPTO_TLS_CREDS_ANON(creds);
        char *prio;

        if (creds->priority != NULL) {
            prio = g_strdup_printf("%s:+ANON-DH", creds->priority);
        } else {
            prio = g_strdup(CONFIG_TLS_PRIORITY ":+ANON-DH");
        }

        ret = gnutls_priority_set_direct(session->handle, prio, NULL);
        if (ret < 0) {
            error_setg(errp, "Unable to set TLS session priority %s: %s",
                       prio, gnutls_strerror(ret));
            g_free(prio);
            goto error;
        }
        g_free(prio);
        if (creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
            ret = gnutls_credentials_set(session->handle,
                                         GNUTLS_CRD_ANON,
                                         acreds->data.server);
        } else {
            ret = gnutls_credentials_set(session->handle,
                                         GNUTLS_CRD_ANON,
                                         acreds->data.client);
        }
        if (ret < 0) {
            error_setg(errp, "Cannot set session credentials: %s",
                       gnutls_strerror(ret));
            goto error;
        }
    } else if (object_dynamic_cast(OBJECT(creds),
                                   TYPE_QCRYPTO_TLS_CREDS_X509)) {
        QCryptoTLSCredsX509 *tcreds = QCRYPTO_TLS_CREDS_X509(creds);
        const char *prio = creds->priority;
        if (!prio) {
            prio = CONFIG_TLS_PRIORITY;
        }

        ret = gnutls_priority_set_direct(session->handle, prio, NULL);
        if (ret < 0) {
            error_setg(errp, "Cannot set default TLS session priority %s: %s",
                       prio, gnutls_strerror(ret));
            goto error;
        }
        ret = gnutls_credentials_set(session->handle,
                                     GNUTLS_CRD_CERTIFICATE,
                                     tcreds->data);
        if (ret < 0) {
            error_setg(errp, "Cannot set session credentials: %s",
                       gnutls_strerror(ret));
            goto error;
        }

        if (creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
            /* This requests, but does not enforce a client cert.
             * The cert checking code later does enforcement */
            gnutls_certificate_server_set_request(session->handle,
                                                  GNUTLS_CERT_REQUEST);
        }
    } else {
        error_setg(errp, "Unsupported TLS credentials type %s",
                   object_get_typename(OBJECT(creds)));
        goto error;
    }

    gnutls_transport_set_ptr(session->handle, session);
    gnutls_transport_set_push_function(session->handle,
                                       qcrypto_tls_session_push);
    gnutls_transport_set_pull_function(session->handle,
                                       qcrypto_tls_session_pull);

    return session;

 error:
    qcrypto_tls_session_free(session);
    return NULL;
}

static int
qcrypto_tls_session_check_certificate(QCryptoTLSSession *session,
                                      Error **errp)
{
    int ret;
    unsigned int status;
    const gnutls_datum_t *certs;
    unsigned int nCerts, i;
    time_t now;
    gnutls_x509_crt_t cert = NULL;

    now = time(NULL);
    if (now == ((time_t)-1)) {
        error_setg_errno(errp, errno, "Cannot get current time");
        return -1;
    }

    ret = gnutls_certificate_verify_peers2(session->handle, &status);
    if (ret < 0) {
        error_setg(errp, "Verify failed: %s", gnutls_strerror(ret));
        return -1;
    }

    if (status != 0) {
        const char *reason = "Invalid certificate";

        if (status & GNUTLS_CERT_INVALID) {
            reason = "The certificate is not trusted";
        }

        if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
            reason = "The certificate hasn't got a known issuer";
        }

        if (status & GNUTLS_CERT_REVOKED) {
            reason = "The certificate has been revoked";
        }

        if (status & GNUTLS_CERT_INSECURE_ALGORITHM) {
            reason = "The certificate uses an insecure algorithm";
        }

        error_setg(errp, "%s", reason);
        return -1;
    }

    certs = gnutls_certificate_get_peers(session->handle, &nCerts);
    if (!certs) {
        error_setg(errp, "No certificate peers");
        return -1;
    }

    for (i = 0; i < nCerts; i++) {
        ret = gnutls_x509_crt_init(&cert);
        if (ret < 0) {
            error_setg(errp, "Cannot initialize certificate: %s",
                       gnutls_strerror(ret));
            return -1;
        }

        ret = gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER);
        if (ret < 0) {
            error_setg(errp, "Cannot import certificate: %s",
                       gnutls_strerror(ret));
            goto error;
        }

        if (gnutls_x509_crt_get_expiration_time(cert) < now) {
            error_setg(errp, "The certificate has expired");
            goto error;
        }

        if (gnutls_x509_crt_get_activation_time(cert) > now) {
            error_setg(errp, "The certificate is not yet activated");
            goto error;
        }

        if (gnutls_x509_crt_get_activation_time(cert) > now) {
            error_setg(errp, "The certificate is not yet activated");
            goto error;
        }

        if (i == 0) {
            size_t dnameSize = 1024;
            session->peername = g_malloc(dnameSize);
        requery:
            ret = gnutls_x509_crt_get_dn(cert, session->peername, &dnameSize);
            if (ret < 0) {
                if (ret == GNUTLS_E_SHORT_MEMORY_BUFFER) {
                    session->peername = g_realloc(session->peername,
                                                  dnameSize);
                    goto requery;
                }
                error_setg(errp, "Cannot get client distinguished name: %s",
                           gnutls_strerror(ret));
                goto error;
            }
            if (session->aclname) {
                qemu_acl *acl = qemu_acl_find(session->aclname);
                int allow;
                if (!acl) {
                    error_setg(errp, "Cannot find ACL %s",
                               session->aclname);
                    goto error;
                }

                allow = qemu_acl_party_is_allowed(acl, session->peername);

                if (!allow) {
                    error_setg(errp, "TLS x509 ACL check for %s is denied",
                               session->peername);
                    goto error;
                }
            }
            if (session->hostname) {
                if (!gnutls_x509_crt_check_hostname(cert, session->hostname)) {
                    error_setg(errp,
                               "Certificate does not match the hostname %s",
                               session->hostname);
                    goto error;
                }
            }
        }

        gnutls_x509_crt_deinit(cert);
    }

    return 0;

 error:
    gnutls_x509_crt_deinit(cert);
    return -1;
}


int
qcrypto_tls_session_check_credentials(QCryptoTLSSession *session,
                                      Error **errp)
{
    if (object_dynamic_cast(OBJECT(session->creds),
                            TYPE_QCRYPTO_TLS_CREDS_ANON)) {
        trace_qcrypto_tls_session_check_creds(session, "nop");
        return 0;
    } else if (object_dynamic_cast(OBJECT(session->creds),
                            TYPE_QCRYPTO_TLS_CREDS_X509)) {
        if (session->creds->verifyPeer) {
            int ret = qcrypto_tls_session_check_certificate(session,
                                                            errp);
            trace_qcrypto_tls_session_check_creds(session,
                                                  ret == 0 ? "pass" : "fail");
            return ret;
        } else {
            trace_qcrypto_tls_session_check_creds(session, "skip");
            return 0;
        }
    } else {
        trace_qcrypto_tls_session_check_creds(session, "error");
        error_setg(errp, "Unexpected credential type %s",
                   object_get_typename(OBJECT(session->creds)));
        return -1;
    }
}


void
qcrypto_tls_session_set_callbacks(QCryptoTLSSession *session,
                                  QCryptoTLSSessionWriteFunc writeFunc,
                                  QCryptoTLSSessionReadFunc readFunc,
                                  void *opaque)
{
    session->writeFunc = writeFunc;
    session->readFunc = readFunc;
    session->opaque = opaque;
}


ssize_t
qcrypto_tls_session_write(QCryptoTLSSession *session,
                          const char *buf,
                          size_t len)
{
    ssize_t ret = gnutls_record_send(session->handle, buf, len);

    if (ret < 0) {
        switch (ret) {
        case GNUTLS_E_AGAIN:
            errno = EAGAIN;
            break;
        case GNUTLS_E_INTERRUPTED:
            errno = EINTR;
            break;
        default:
            errno = EIO;
            break;
        }
        ret = -1;
    }

    return ret;
}


ssize_t
qcrypto_tls_session_read(QCryptoTLSSession *session,
                         char *buf,
                         size_t len)
{
    ssize_t ret = gnutls_record_recv(session->handle, buf, len);

    if (ret < 0) {
        switch (ret) {
        case GNUTLS_E_AGAIN:
            errno = EAGAIN;
            break;
        case GNUTLS_E_INTERRUPTED:
            errno = EINTR;
            break;
        default:
            errno = EIO;
            break;
        }
        ret = -1;
    }

    return ret;
}


int
qcrypto_tls_session_handshake(QCryptoTLSSession *session,
                              Error **errp)
{
    int ret = gnutls_handshake(session->handle);
    if (ret == 0) {
        session->handshakeComplete = true;
    } else {
        if (ret == GNUTLS_E_INTERRUPTED ||
            ret == GNUTLS_E_AGAIN) {
            ret = 1;
        } else {
            error_setg(errp, "TLS handshake failed: %s",
                       gnutls_strerror(ret));
            ret = -1;
        }
    }

    return ret;
}


QCryptoTLSSessionHandshakeStatus
qcrypto_tls_session_get_handshake_status(QCryptoTLSSession *session)
{
    if (session->handshakeComplete) {
        return QCRYPTO_TLS_HANDSHAKE_COMPLETE;
    } else if (gnutls_record_get_direction(session->handle) == 0) {
        return QCRYPTO_TLS_HANDSHAKE_RECVING;
    } else {
        return QCRYPTO_TLS_HANDSHAKE_SENDING;
    }
}


int
qcrypto_tls_session_get_key_size(QCryptoTLSSession *session,
                                 Error **errp)
{
    gnutls_cipher_algorithm_t cipher;
    int ssf;

    cipher = gnutls_cipher_get(session->handle);
    ssf = gnutls_cipher_get_key_size(cipher);
    if (!ssf) {
        error_setg(errp, "Cannot get TLS cipher key size");
        return -1;
    }
    return ssf;
}


char *
qcrypto_tls_session_get_peer_name(QCryptoTLSSession *session)
{
    if (session->peername) {
        return g_strdup(session->peername);
    }
    return NULL;
}


#else /* ! CONFIG_GNUTLS */


QCryptoTLSSession *
qcrypto_tls_session_new(QCryptoTLSCreds *creds G_GNUC_UNUSED,
                        const char *hostname G_GNUC_UNUSED,
                        const char *aclname G_GNUC_UNUSED,
                        QCryptoTLSCredsEndpoint endpoint G_GNUC_UNUSED,
                        Error **errp)
{
    error_setg(errp, "TLS requires GNUTLS support");
    return NULL;
}


void
qcrypto_tls_session_free(QCryptoTLSSession *sess G_GNUC_UNUSED)
{
}


int
qcrypto_tls_session_check_credentials(QCryptoTLSSession *sess G_GNUC_UNUSED,
                                      Error **errp)
{
    error_setg(errp, "TLS requires GNUTLS support");
    return -1;
}


void
qcrypto_tls_session_set_callbacks(
    QCryptoTLSSession *sess G_GNUC_UNUSED,
    QCryptoTLSSessionWriteFunc writeFunc G_GNUC_UNUSED,
    QCryptoTLSSessionReadFunc readFunc G_GNUC_UNUSED,
    void *opaque G_GNUC_UNUSED)
{
}


ssize_t
qcrypto_tls_session_write(QCryptoTLSSession *sess,
                          const char *buf,
                          size_t len)
{
    errno = -EIO;
    return -1;
}


ssize_t
qcrypto_tls_session_read(QCryptoTLSSession *sess,
                         char *buf,
                         size_t len)
{
    errno = -EIO;
    return -1;
}


int
qcrypto_tls_session_handshake(QCryptoTLSSession *sess,
                              Error **errp)
{
    error_setg(errp, "TLS requires GNUTLS support");
    return -1;
}


QCryptoTLSSessionHandshakeStatus
qcrypto_tls_session_get_handshake_status(QCryptoTLSSession *sess)
{
    return QCRYPTO_TLS_HANDSHAKE_COMPLETE;
}


int
qcrypto_tls_session_get_key_size(QCryptoTLSSession *sess,
                                 Error **errp)
{
    error_setg(errp, "TLS requires GNUTLS support");
    return -1;
}


char *
qcrypto_tls_session_get_peer_name(QCryptoTLSSession *sess)
{
    return NULL;
}

#endif
Commit	Line	Data
d321e1e5 DB	1	/*
	2	* QEMU crypto TLS session support
	3	*
	4	* Copyright (c) 2015 Red Hat, Inc.
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2 of the License, or (at your option) any later version.
	10	*
	11	* This library is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	18	*
	19	*/
	20
42f7a448	21	#include "qemu/osdep.h"
d321e1e5 DB	22	#include "crypto/tlssession.h"
	23	#include "crypto/tlscredsanon.h"
	24	#include "crypto/tlscredsx509.h"
da34e65c	25	#include "qapi/error.h"
d321e1e5 DB	26	#include "qemu/acl.h"
	27	#include "trace.h"
	28
	29	#ifdef CONFIG_GNUTLS
	30
	31
	32	#include <gnutls/x509.h>
	33
	34
	35	struct QCryptoTLSSession {
	36	QCryptoTLSCreds *creds;
	37	gnutls_session_t handle;
	38	char *hostname;
	39	char *aclname;
	40	bool handshakeComplete;
	41	QCryptoTLSSessionWriteFunc writeFunc;
	42	QCryptoTLSSessionReadFunc readFunc;
	43	void *opaque;
	44	char *peername;
	45	};
	46
	47
	48	void
	49	qcrypto_tls_session_free(QCryptoTLSSession *session)
	50	{
	51	if (!session) {
	52	return;
	53	}
	54
	55	gnutls_deinit(session->handle);
	56	g_free(session->hostname);
	57	g_free(session->peername);
	58	g_free(session->aclname);
	59	object_unref(OBJECT(session->creds));
	60	g_free(session);
	61	}
	62
	63
	64	static ssize_t
	65	qcrypto_tls_session_push(void opaque, const void buf, size_t len)
	66	{
	67	QCryptoTLSSession *session = opaque;
	68
	69	if (!session->writeFunc) {
	70	errno = EIO;
	71	return -1;
	72	};
	73
	74	return session->writeFunc(buf, len, session->opaque);
	75	}
	76
	77
	78	static ssize_t
	79	qcrypto_tls_session_pull(void opaque, void buf, size_t len)
	80	{
	81	QCryptoTLSSession *session = opaque;
	82
	83	if (!session->readFunc) {
	84	errno = EIO;
	85	return -1;
	86	};
	87
	88	return session->readFunc(buf, len, session->opaque);
	89	}
90
91
92	QCryptoTLSSession *
93	qcrypto_tls_session_new(QCryptoTLSCreds *creds,
94	const char *hostname,
95	const char *aclname,
96	QCryptoTLSCredsEndpoint endpoint,
97	Error **errp)
98	{
99	QCryptoTLSSession *session;
100	int ret;
101
102	session = g_new0(QCryptoTLSSession, 1);
103	trace_qcrypto_tls_session_new(
104	session, creds, hostname ? hostname : "<none>",
105	aclname ? aclname : "<none>", endpoint);
106
107	if (hostname) {
108	session->hostname = g_strdup(hostname);
109	}
110	if (aclname) {
111	session->aclname = g_strdup(aclname);
112	}
113	session->creds = creds;
114	object_ref(OBJECT(creds));
115
116	if (creds->endpoint != endpoint) {
117	error_setg(errp, "Credentials endpoint doesn't match session");
118	goto error;
119	}
120
121	if (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
122	ret = gnutls_init(&session->handle, GNUTLS_SERVER);
123	} else {
124	ret = gnutls_init(&session->handle, GNUTLS_CLIENT);
125	}
126	if (ret < 0) {
127	error_setg(errp, "Cannot initialize TLS session: %s",
128	gnutls_strerror(ret));
129	goto error;
130	}
131
132	if (object_dynamic_cast(OBJECT(creds),
133	TYPE_QCRYPTO_TLS_CREDS_ANON)) {
134	QCryptoTLSCredsAnon *acreds = QCRYPTO_TLS_CREDS_ANON(creds);
13f12430	135	char *prio;
d321e1e5	136
13f12430 DB	137	if (creds->priority != NULL) {
	138	prio = g_strdup_printf("%s:+ANON-DH", creds->priority);
	139	} else {
a1c5e949	140	prio = g_strdup(CONFIG_TLS_PRIORITY ":+ANON-DH");
13f12430 DB	141	}
	142
	143	ret = gnutls_priority_set_direct(session->handle, prio, NULL);
d321e1e5	144	if (ret < 0) {
13f12430 DB	145	error_setg(errp, "Unable to set TLS session priority %s: %s",
	146	prio, gnutls_strerror(ret));
	147	g_free(prio);
d321e1e5 DB	148	goto error;
d321e1e5 DB	149	}
13f12430	150	g_free(prio);
d321e1e5 DB	151	if (creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
	152	ret = gnutls_credentials_set(session->handle,
	153	GNUTLS_CRD_ANON,
	154	acreds->data.server);
	155	} else {
	156	ret = gnutls_credentials_set(session->handle,
	157	GNUTLS_CRD_ANON,
	158	acreds->data.client);
	159	}
	160	if (ret < 0) {
	161	error_setg(errp, "Cannot set session credentials: %s",
	162	gnutls_strerror(ret));
	163	goto error;
	164	}
	165	} else if (object_dynamic_cast(OBJECT(creds),
	166	TYPE_QCRYPTO_TLS_CREDS_X509)) {
	167	QCryptoTLSCredsX509 *tcreds = QCRYPTO_TLS_CREDS_X509(creds);
13f12430 DB	168	const char *prio = creds->priority;
13f12430 DB	169	if (!prio) {
a1c5e949	170	prio = CONFIG_TLS_PRIORITY;
13f12430	171	}
d321e1e5	172
13f12430	173	ret = gnutls_priority_set_direct(session->handle, prio, NULL);
d321e1e5	174	if (ret < 0) {
13f12430 DB	175	error_setg(errp, "Cannot set default TLS session priority %s: %s",
13f12430 DB	176	prio, gnutls_strerror(ret));
d321e1e5 DB	177	goto error;
	178	}
	179	ret = gnutls_credentials_set(session->handle,
	180	GNUTLS_CRD_CERTIFICATE,
	181	tcreds->data);
	182	if (ret < 0) {
	183	error_setg(errp, "Cannot set session credentials: %s",
	184	gnutls_strerror(ret));
	185	goto error;
	186	}
	187
	188	if (creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
	189	/* This requests, but does not enforce a client cert.
	190	* The cert checking code later does enforcement */
	191	gnutls_certificate_server_set_request(session->handle,
	192	GNUTLS_CERT_REQUEST);
	193	}
	194	} else {
	195	error_setg(errp, "Unsupported TLS credentials type %s",
	196	object_get_typename(OBJECT(creds)));
	197	goto error;
	198	}
	199
	200	gnutls_transport_set_ptr(session->handle, session);
	201	gnutls_transport_set_push_function(session->handle,
	202	qcrypto_tls_session_push);
	203	gnutls_transport_set_pull_function(session->handle,
	204	qcrypto_tls_session_pull);
	205
	206	return session;
	207
	208	error:
	209	qcrypto_tls_session_free(session);
	210	return NULL;
	211	}
	212
	213	static int
	214	qcrypto_tls_session_check_certificate(QCryptoTLSSession *session,
	215	Error **errp)
	216	{
	217	int ret;
	218	unsigned int status;
	219	const gnutls_datum_t *certs;
	220	unsigned int nCerts, i;
	221	time_t now;
	222	gnutls_x509_crt_t cert = NULL;
	223
	224	now = time(NULL);
	225	if (now == ((time_t)-1)) {
	226	error_setg_errno(errp, errno, "Cannot get current time");
	227	return -1;
	228	}
	229
	230	ret = gnutls_certificate_verify_peers2(session->handle, &status);
	231	if (ret < 0) {
	232	error_setg(errp, "Verify failed: %s", gnutls_strerror(ret));
	233	return -1;
	234	}
	235
	236	if (status != 0) {
	237	const char *reason = "Invalid certificate";
	238
	239	if (status & GNUTLS_CERT_INVALID) {
	240	reason = "The certificate is not trusted";
241	}
242
243	if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
244	reason = "The certificate hasn't got a known issuer";
245	}
246
247	if (status & GNUTLS_CERT_REVOKED) {
248	reason = "The certificate has been revoked";
249	}
250
251	if (status & GNUTLS_CERT_INSECURE_ALGORITHM) {
252	reason = "The certificate uses an insecure algorithm";
253	}
254
255	error_setg(errp, "%s", reason);
256	return -1;
257	}
258
259	certs = gnutls_certificate_get_peers(session->handle, &nCerts);
260	if (!certs) {
261	error_setg(errp, "No certificate peers");
262	return -1;
263	}
264
265	for (i = 0; i < nCerts; i++) {
266	ret = gnutls_x509_crt_init(&cert);
267	if (ret < 0) {
268	error_setg(errp, "Cannot initialize certificate: %s",
269	gnutls_strerror(ret));
270	return -1;
271	}
272
273	ret = gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER);
274	if (ret < 0) {
275	error_setg(errp, "Cannot import certificate: %s",
276	gnutls_strerror(ret));
277	goto error;
278	}
279
280	if (gnutls_x509_crt_get_expiration_time(cert) < now) {
281	error_setg(errp, "The certificate has expired");
282	goto error;
283	}
284
285	if (gnutls_x509_crt_get_activation_time(cert) > now) {
286	error_setg(errp, "The certificate is not yet activated");
287	goto error;
288	}
289
290	if (gnutls_x509_crt_get_activation_time(cert) > now) {
291	error_setg(errp, "The certificate is not yet activated");
292	goto error;
293	}
294
295	if (i == 0) {
296	size_t dnameSize = 1024;
297	session->peername = g_malloc(dnameSize);
298	requery:
299	ret = gnutls_x509_crt_get_dn(cert, session->peername, &dnameSize);
300	if (ret < 0) {
301	if (ret == GNUTLS_E_SHORT_MEMORY_BUFFER) {
302	session->peername = g_realloc(session->peername,
303	dnameSize);
304	goto requery;
305	}
306	error_setg(errp, "Cannot get client distinguished name: %s",
307	gnutls_strerror(ret));
308	goto error;
309	}
310	if (session->aclname) {
311	qemu_acl *acl = qemu_acl_find(session->aclname);
312	int allow;
313	if (!acl) {
314	error_setg(errp, "Cannot find ACL %s",
315	session->aclname);
316	goto error;
317	}
318
319	allow = qemu_acl_party_is_allowed(acl, session->peername);
320
d321e1e5	321	if (!allow) {
6ef8cd7a DB	322	error_setg(errp, "TLS x509 ACL check for %s is denied",
6ef8cd7a DB	323	session->peername);
d321e1e5 DB	324	goto error;
	325	}
	326	}
	327	if (session->hostname) {
	328	if (!gnutls_x509_crt_check_hostname(cert, session->hostname)) {
	329	error_setg(errp,
	330	"Certificate does not match the hostname %s",
	331	session->hostname);
	332	goto error;
	333	}
	334	}
	335	}
	336
	337	gnutls_x509_crt_deinit(cert);
	338	}
	339
	340	return 0;
	341
	342	error:
	343	gnutls_x509_crt_deinit(cert);
	344	return -1;
	345	}
	346
	347
	348	int
	349	qcrypto_tls_session_check_credentials(QCryptoTLSSession *session,
	350	Error **errp)
	351	{
	352	if (object_dynamic_cast(OBJECT(session->creds),
	353	TYPE_QCRYPTO_TLS_CREDS_ANON)) {
b57482d7	354	trace_qcrypto_tls_session_check_creds(session, "nop");
d321e1e5 DB	355	return 0;
	356	} else if (object_dynamic_cast(OBJECT(session->creds),
	357	TYPE_QCRYPTO_TLS_CREDS_X509)) {
	358	if (session->creds->verifyPeer) {
b57482d7 DB	359	int ret = qcrypto_tls_session_check_certificate(session,
	360	errp);
	361	trace_qcrypto_tls_session_check_creds(session,
	362	ret == 0 ? "pass" : "fail");
	363	return ret;
d321e1e5	364	} else {
b57482d7	365	trace_qcrypto_tls_session_check_creds(session, "skip");
d321e1e5 DB	366	return 0;
	367	}
	368	} else {
b57482d7	369	trace_qcrypto_tls_session_check_creds(session, "error");
d321e1e5 DB	370	error_setg(errp, "Unexpected credential type %s",
	371	object_get_typename(OBJECT(session->creds)));
	372	return -1;
	373	}
	374	}
	375
	376
	377	void
	378	qcrypto_tls_session_set_callbacks(QCryptoTLSSession *session,
	379	QCryptoTLSSessionWriteFunc writeFunc,
	380	QCryptoTLSSessionReadFunc readFunc,
	381	void *opaque)
	382	{
	383	session->writeFunc = writeFunc;
	384	session->readFunc = readFunc;
	385	session->opaque = opaque;
	386	}
	387
	388
	389	ssize_t
	390	qcrypto_tls_session_write(QCryptoTLSSession *session,
	391	const char *buf,
	392	size_t len)
	393	{
	394	ssize_t ret = gnutls_record_send(session->handle, buf, len);
	395
	396	if (ret < 0) {
	397	switch (ret) {
	398	case GNUTLS_E_AGAIN:
	399	errno = EAGAIN;
	400	break;
	401	case GNUTLS_E_INTERRUPTED:
	402	errno = EINTR;
	403	break;
	404	default:
	405	errno = EIO;
	406	break;
	407	}
	408	ret = -1;
	409	}
	410
	411	return ret;
	412	}
	413
	414
	415	ssize_t
	416	qcrypto_tls_session_read(QCryptoTLSSession *session,
	417	char *buf,
	418	size_t len)
	419	{
	420	ssize_t ret = gnutls_record_recv(session->handle, buf, len);
	421
	422	if (ret < 0) {
	423	switch (ret) {
	424	case GNUTLS_E_AGAIN:
	425	errno = EAGAIN;
	426	break;
	427	case GNUTLS_E_INTERRUPTED:
	428	errno = EINTR;
	429	break;
	430	default:
	431	errno = EIO;
	432	break;
	433	}
434	ret = -1;
435	}
436
437	return ret;
438	}
439
440
441	int
442	qcrypto_tls_session_handshake(QCryptoTLSSession *session,
443	Error **errp)
444	{
445	int ret = gnutls_handshake(session->handle);
446	if (ret == 0) {
447	session->handshakeComplete = true;
448	} else {
449	if (ret == GNUTLS_E_INTERRUPTED \|\|
450	ret == GNUTLS_E_AGAIN) {
451	ret = 1;
452	} else {
453	error_setg(errp, "TLS handshake failed: %s",
454	gnutls_strerror(ret));
455	ret = -1;
456	}
457	}
458
459	return ret;
460	}
461
462
463	QCryptoTLSSessionHandshakeStatus
464	qcrypto_tls_session_get_handshake_status(QCryptoTLSSession *session)
465	{
466	if (session->handshakeComplete) {
467	return QCRYPTO_TLS_HANDSHAKE_COMPLETE;
468	} else if (gnutls_record_get_direction(session->handle) == 0) {
469	return QCRYPTO_TLS_HANDSHAKE_RECVING;
470	} else {
471	return QCRYPTO_TLS_HANDSHAKE_SENDING;
472	}
473	}
474
475
476	int
477	qcrypto_tls_session_get_key_size(QCryptoTLSSession *session,
478	Error **errp)
479	{
480	gnutls_cipher_algorithm_t cipher;
481	int ssf;
482
483	cipher = gnutls_cipher_get(session->handle);
484	ssf = gnutls_cipher_get_key_size(cipher);
485	if (!ssf) {
486	error_setg(errp, "Cannot get TLS cipher key size");
487	return -1;
488	}
489	return ssf;
490	}
491
492
493	char *
494	qcrypto_tls_session_get_peer_name(QCryptoTLSSession *session)
495	{
496	if (session->peername) {
497	return g_strdup(session->peername);
498	}
499	return NULL;
500	}
501
502
503	#else /* ! CONFIG_GNUTLS */
504
505
506	QCryptoTLSSession *
507	qcrypto_tls_session_new(QCryptoTLSCreds *creds G_GNUC_UNUSED,
508	const char *hostname G_GNUC_UNUSED,
509	const char *aclname G_GNUC_UNUSED,
510	QCryptoTLSCredsEndpoint endpoint G_GNUC_UNUSED,
511	Error **errp)
512	{
513	error_setg(errp, "TLS requires GNUTLS support");
514	return NULL;
515	}
516
517
518	void
519	qcrypto_tls_session_free(QCryptoTLSSession *sess G_GNUC_UNUSED)
520	{
521	}
522
523
524	int
525	qcrypto_tls_session_check_credentials(QCryptoTLSSession *sess G_GNUC_UNUSED,
526	Error **errp)
527	{
528	error_setg(errp, "TLS requires GNUTLS support");
529	return -1;
530	}
531
532
533	void
534	qcrypto_tls_session_set_callbacks(
535	QCryptoTLSSession *sess G_GNUC_UNUSED,
536	QCryptoTLSSessionWriteFunc writeFunc G_GNUC_UNUSED,
537	QCryptoTLSSessionReadFunc readFunc G_GNUC_UNUSED,
538	void *opaque G_GNUC_UNUSED)
539	{
540	}
541
542
543	ssize_t
544	qcrypto_tls_session_write(QCryptoTLSSession *sess,
545	const char *buf,
546	size_t len)
547	{
548	errno = -EIO;
549	return -1;
550	}
551
552
553	ssize_t
554	qcrypto_tls_session_read(QCryptoTLSSession *sess,
555	char *buf,
556	size_t len)
557	{
558	errno = -EIO;
559	return -1;
560	}
561
562
563	int
564	qcrypto_tls_session_handshake(QCryptoTLSSession *sess,
565	Error **errp)
566	{
567	error_setg(errp, "TLS requires GNUTLS support");
568	return -1;
569	}
570
571
572	QCryptoTLSSessionHandshakeStatus
573	qcrypto_tls_session_get_handshake_status(QCryptoTLSSession *sess)
574	{
575	return QCRYPTO_TLS_HANDSHAKE_COMPLETE;
576	}
577
578
579	int
580	qcrypto_tls_session_get_key_size(QCryptoTLSSession *sess,
581	Error **errp)
582	{
583	error_setg(errp, "TLS requires GNUTLS support");
584	return -1;
585	}
586
587
588	char *
589	qcrypto_tls_session_get_peer_name(QCryptoTLSSession *sess)
590	{
591	return NULL;
592	}
593
594	#endif