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