| /* |
| * 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.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/>. |
| * |
| */ |
| |
| #include "qemu/osdep.h" |
| #include "crypto/tlssession.h" |
| #include "crypto/tlscredsanon.h" |
| #include "crypto/tlscredspsk.h" |
| #include "crypto/tlscredsx509.h" |
| #include "qapi/error.h" |
| #include "authz/base.h" |
| #include "tlscredspriv.h" |
| #include "trace.h" |
| |
| #ifdef CONFIG_GNUTLS |
| |
| |
| #include <gnutls/x509.h> |
| |
| |
| struct QCryptoTLSSession { |
| QCryptoTLSCreds *creds; |
| gnutls_session_t handle; |
| char *hostname; |
| char *authzid; |
| 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->authzid); |
| 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); |
| } |
| |
| #define TLS_PRIORITY_ADDITIONAL_ANON "+ANON-DH" |
| #define TLS_PRIORITY_ADDITIONAL_PSK "+ECDHE-PSK:+DHE-PSK:+PSK" |
| |
| QCryptoTLSSession * |
| qcrypto_tls_session_new(QCryptoTLSCreds *creds, |
| const char *hostname, |
| const char *authzid, |
| QCryptoTLSCredsEndpoint endpoint, |
| Error **errp) |
| { |
| QCryptoTLSSession *session; |
| int ret; |
| |
| session = g_new0(QCryptoTLSSession, 1); |
| trace_qcrypto_tls_session_new( |
| session, creds, hostname ? hostname : "<none>", |
| authzid ? authzid : "<none>", endpoint); |
| |
| if (hostname) { |
| session->hostname = g_strdup(hostname); |
| } |
| if (authzid) { |
| session->authzid = g_strdup(authzid); |
| } |
| 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:%s", |
| creds->priority, |
| TLS_PRIORITY_ADDITIONAL_ANON); |
| } else { |
| prio = g_strdup(CONFIG_TLS_PRIORITY ":" |
| TLS_PRIORITY_ADDITIONAL_ANON); |
| } |
| |
| 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_PSK)) { |
| QCryptoTLSCredsPSK *pcreds = QCRYPTO_TLS_CREDS_PSK(creds); |
| char *prio; |
| |
| if (creds->priority != NULL) { |
| prio = g_strdup_printf("%s:%s", |
| creds->priority, |
| TLS_PRIORITY_ADDITIONAL_PSK); |
| } else { |
| prio = g_strdup(CONFIG_TLS_PRIORITY ":" |
| TLS_PRIORITY_ADDITIONAL_PSK); |
| } |
| |
| 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_PSK, |
| pcreds->data.server); |
| } else { |
| ret = gnutls_credentials_set(session->handle, |
| GNUTLS_CRD_PSK, |
| pcreds->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; |
| Error *err = 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->authzid) { |
| bool allow; |
| |
| allow = qauthz_is_allowed_by_id(session->authzid, |
| session->peername, &err); |
| if (err) { |
| error_propagate(errp, err); |
| goto error; |
| } |
| if (!allow) { |
| error_setg(errp, "TLS x509 authz 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_PSK)) { |
| 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; |
| case GNUTLS_E_PREMATURE_TERMINATION: |
| errno = ECONNABORTED; |
| 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 *authzid 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 |