crypto/tlssession.c

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