ssl/ssl_rsa.c

   1 /*
   2  * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include "ssl_local.h"
  12 #include "internal/packet.h"
  13 #include <openssl/bio.h>
  14 #include <openssl/objects.h>
  15 #include <openssl/evp.h>
  16 #include <openssl/x509.h>
  17 #include <openssl/x509v3.h>
  18 #include <openssl/pem.h>
  19
  20 static int ssl_set_cert(CERT *c, X509 *x509);
  21 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey);
  22
  23 #define  SYNTHV1CONTEXT     (SSL_EXT_TLS1_2_AND_BELOW_ONLY \
  24                              | SSL_EXT_CLIENT_HELLO \
  25                              | SSL_EXT_TLS1_2_SERVER_HELLO \
  26                              | SSL_EXT_IGNORE_ON_RESUMPTION)
  27
  28 #define NAME_PREFIX1 "SERVERINFO FOR "
  29 #define NAME_PREFIX2 "SERVERINFOV2 FOR "
  30
  31 int SSL_use_certificate(SSL *ssl, X509 *x)
  32 {
  33     int rv;
  34     if (x == NULL) {
  35         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
  36         return 0;
  37     }
  38
  39     rv = ssl_security_cert(ssl, NULL, x, 0, 1);
  40     if (rv != 1) {
  41         ERR_raise(ERR_LIB_SSL, rv);
  42         return 0;
  43     }
  44
  45     return ssl_set_cert(ssl->cert, x);
  46 }
  47
  48 int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
  49 {
  50     int j;
  51     BIO *in;
  52     int ret = 0;
  53     X509 *cert = NULL, *x = NULL;
  54
  55     in = BIO_new(BIO_s_file());
  56     if (in == NULL) {
  57         ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
  58         goto end;
  59     }
  60
  61     if (BIO_read_filename(in, file) <= 0) {
  62         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
  63         goto end;
  64     }
  65
  66     if (type != SSL_FILETYPE_ASN1 && type != SSL_FILETYPE_PEM) {
  67         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
  68         goto end;
  69     }
  70     x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq);
  71     if (x == NULL) {
  72         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
  73         goto end;
  74     }
  75     if (type == SSL_FILETYPE_ASN1) {
  76         j = ERR_R_ASN1_LIB;
  77         cert = d2i_X509_bio(in, &x);
  78     } else if (type == SSL_FILETYPE_PEM) {
  79         j = ERR_R_PEM_LIB;
  80         cert = PEM_read_bio_X509(in, &x, ssl->default_passwd_callback,
  81                                  ssl->default_passwd_callback_userdata);
  82     } else {
  83         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
  84         goto end;
  85     }
  86
  87     if (cert == NULL) {
  88         ERR_raise(ERR_LIB_SSL, j);
  89         goto end;
  90     }
  91
  92     ret = SSL_use_certificate(ssl, x);
  93  end:
  94     X509_free(x);
  95     BIO_free(in);
  96     return ret;
  97 }
  98
  99 int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len)
 100 {
 101     X509 *x;
 102     int ret;
 103
 104     x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq);
 105     if (x == NULL) {
 106         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 107         return 0;
 108     }
 109
 110     if (d2i_X509(&x, &d, (long)len)== NULL) {
 111         X509_free(x);
 112         ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
 113         return 0;
 114     }
 115
 116     ret = SSL_use_certificate(ssl, x);
 117     X509_free(x);
 118     return ret;
 119 }
 120
 121 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey)
 122 {
 123     size_t i;
 124
 125     if (ssl_cert_lookup_by_pkey(pkey, &i) == NULL) {
 126         ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
 127         return 0;
 128     }
 129
 130     if (c->pkeys[i].x509 != NULL
 131             && !X509_check_private_key(c->pkeys[i].x509, pkey))
 132         return 0;
 133
 134     EVP_PKEY_free(c->pkeys[i].privatekey);
 135     EVP_PKEY_up_ref(pkey);
 136     c->pkeys[i].privatekey = pkey;
 137     c->key = &c->pkeys[i];
 138     return 1;
 139 }
 140
 141 int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey)
 142 {
 143     int ret;
 144
 145     if (pkey == NULL) {
 146         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
 147         return 0;
 148     }
 149     ret = ssl_set_pkey(ssl->cert, pkey);
 150     return ret;
 151 }
 152
 153 int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type)
 154 {
 155     int j, ret = 0;
 156     BIO *in;
 157     EVP_PKEY *pkey = NULL;
 158
 159     in = BIO_new(BIO_s_file());
 160     if (in == NULL) {
 161         ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
 162         goto end;
 163     }
 164
 165     if (BIO_read_filename(in, file) <= 0) {
 166         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
 167         goto end;
 168     }
 169     if (type == SSL_FILETYPE_PEM) {
 170         j = ERR_R_PEM_LIB;
 171         pkey = PEM_read_bio_PrivateKey_ex(in, NULL,
 172                                           ssl->default_passwd_callback,
 173                                           ssl->default_passwd_callback_userdata,
 174                                           ssl->ctx->libctx,
 175                                           ssl->ctx->propq);
 176     } else if (type == SSL_FILETYPE_ASN1) {
 177         j = ERR_R_ASN1_LIB;
 178         pkey = d2i_PrivateKey_ex_bio(in, NULL, ssl->ctx->libctx,
 179                                      ssl->ctx->propq);
 180     } else {
 181         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
 182         goto end;
 183     }
 184     if (pkey == NULL) {
 185         ERR_raise(ERR_LIB_SSL, j);
 186         goto end;
 187     }
 188     ret = SSL_use_PrivateKey(ssl, pkey);
 189     EVP_PKEY_free(pkey);
 190  end:
 191     BIO_free(in);
 192     return ret;
 193 }
 194
 195 int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, const unsigned char *d,
 196                             long len)
 197 {
 198     int ret;
 199     const unsigned char *p;
 200     EVP_PKEY *pkey;
 201
 202     p = d;
 203     if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ssl->ctx->libctx,
 204                                   ssl->ctx->propq)) == NULL) {
 205         ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
 206         return 0;
 207     }
 208
 209     ret = SSL_use_PrivateKey(ssl, pkey);
 210     EVP_PKEY_free(pkey);
 211     return ret;
 212 }
 213
 214 int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x)
 215 {
 216     int rv;
 217     if (x == NULL) {
 218         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
 219         return 0;
 220     }
 221
 222     rv = ssl_security_cert(NULL, ctx, x, 0, 1);
 223     if (rv != 1) {
 224         ERR_raise(ERR_LIB_SSL, rv);
 225         return 0;
 226     }
 227     return ssl_set_cert(ctx->cert, x);
 228 }
 229
 230 static int ssl_set_cert(CERT *c, X509 *x)
 231 {
 232     EVP_PKEY *pkey;
 233     size_t i;
 234
 235     pkey = X509_get0_pubkey(x);
 236     if (pkey == NULL) {
 237         ERR_raise(ERR_LIB_SSL, SSL_R_X509_LIB);
 238         return 0;
 239     }
 240
 241     if (ssl_cert_lookup_by_pkey(pkey, &i) == NULL) {
 242         ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
 243         return 0;
 244     }
 245
 246     if (i == SSL_PKEY_ECC && !EVP_PKEY_can_sign(pkey)) {
 247         ERR_raise(ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_SIGNING);
 248         return 0;
 249     }
 250
 251     if (c->pkeys[i].privatekey != NULL) {
 252         /*
 253          * The return code from EVP_PKEY_copy_parameters is deliberately
 254          * ignored. Some EVP_PKEY types cannot do this.
 255          * coverity[check_return]
 256          */
 257         EVP_PKEY_copy_parameters(pkey, c->pkeys[i].privatekey);
 258         ERR_clear_error();
 259
 260         if (!X509_check_private_key(x, c->pkeys[i].privatekey)) {
 261             /*
 262              * don't fail for a cert/key mismatch, just free current private
 263              * key (when switching to a different cert & key, first this
 264              * function should be used, then ssl_set_pkey
 265              */
 266             EVP_PKEY_free(c->pkeys[i].privatekey);
 267             c->pkeys[i].privatekey = NULL;
 268             /* clear error queue */
 269             ERR_clear_error();
 270         }
 271     }
 272
 273     X509_free(c->pkeys[i].x509);
 274     X509_up_ref(x);
 275     c->pkeys[i].x509 = x;
 276     c->key = &(c->pkeys[i]);
 277
 278     return 1;
 279 }
 280
 281 int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type)
 282 {
 283     int j = SSL_R_BAD_VALUE;
 284     BIO *in;
 285     int ret = 0;
 286     X509 *x = NULL, *cert = NULL;
 287
 288     in = BIO_new(BIO_s_file());
 289     if (in == NULL) {
 290         ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
 291         goto end;
 292     }
 293
 294     if (BIO_read_filename(in, file) <= 0) {
 295         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
 296         goto end;
 297     }
 298     if (type != SSL_FILETYPE_ASN1 && type != SSL_FILETYPE_PEM) {
 299         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
 300         goto end;
 301     }
 302     x = X509_new_ex(ctx->libctx, ctx->propq);
 303     if (x == NULL) {
 304         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 305         goto end;
 306     }
 307     if (type == SSL_FILETYPE_ASN1) {
 308         j = ERR_R_ASN1_LIB;
 309         cert = d2i_X509_bio(in, &x);
 310     } else if (type == SSL_FILETYPE_PEM) {
 311         j = ERR_R_PEM_LIB;
 312         cert = PEM_read_bio_X509(in, &x, ctx->default_passwd_callback,
 313                                  ctx->default_passwd_callback_userdata);
 314     }
 315     if (cert == NULL) {
 316         ERR_raise(ERR_LIB_SSL, j);
 317         goto end;
 318     }
 319
 320     ret = SSL_CTX_use_certificate(ctx, x);
 321  end:
 322     X509_free(x);
 323     BIO_free(in);
 324     return ret;
 325 }
 326
 327 int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, const unsigned char *d)
 328 {
 329     X509 *x;
 330     int ret;
 331
 332     x = X509_new_ex(ctx->libctx, ctx->propq);
 333     if (x == NULL) {
 334         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 335         return 0;
 336     }
 337
 338     if (d2i_X509(&x, &d, (long)len) == NULL) {
 339         X509_free(x);
 340         ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
 341         return 0;
 342     }
 343
 344     ret = SSL_CTX_use_certificate(ctx, x);
 345     X509_free(x);
 346     return ret;
 347 }
 348
 349 int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey)
 350 {
 351     if (pkey == NULL) {
 352         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
 353         return 0;
 354     }
 355     return ssl_set_pkey(ctx->cert, pkey);
 356 }
 357
 358 int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type)
 359 {
 360     int j, ret = 0;
 361     BIO *in;
 362     EVP_PKEY *pkey = NULL;
 363
 364     in = BIO_new(BIO_s_file());
 365     if (in == NULL) {
 366         ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
 367         goto end;
 368     }
 369
 370     if (BIO_read_filename(in, file) <= 0) {
 371         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
 372         goto end;
 373     }
 374     if (type == SSL_FILETYPE_PEM) {
 375         j = ERR_R_PEM_LIB;
 376         pkey = PEM_read_bio_PrivateKey_ex(in, NULL,
 377                                        ctx->default_passwd_callback,
 378                                        ctx->default_passwd_callback_userdata,
 379                                        ctx->libctx, ctx->propq);
 380     } else if (type == SSL_FILETYPE_ASN1) {
 381         j = ERR_R_ASN1_LIB;
 382         pkey = d2i_PrivateKey_ex_bio(in, NULL, ctx->libctx, ctx->propq);
 383     } else {
 384         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
 385         goto end;
 386     }
 387     if (pkey == NULL) {
 388         ERR_raise(ERR_LIB_SSL, j);
 389         goto end;
 390     }
 391     ret = SSL_CTX_use_PrivateKey(ctx, pkey);
 392     EVP_PKEY_free(pkey);
 393  end:
 394     BIO_free(in);
 395     return ret;
 396 }
 397
 398 int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx,
 399                                 const unsigned char *d, long len)
 400 {
 401     int ret;
 402     const unsigned char *p;
 403     EVP_PKEY *pkey;
 404
 405     p = d;
 406     if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ctx->libctx,
 407                                   ctx->propq)) == NULL) {
 408         ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
 409         return 0;
 410     }
 411
 412     ret = SSL_CTX_use_PrivateKey(ctx, pkey);
 413     EVP_PKEY_free(pkey);
 414     return ret;
 415 }
 416
 417 /*
 418  * Read a file that contains our certificate in "PEM" format, possibly
 419  * followed by a sequence of CA certificates that should be sent to the peer
 420  * in the Certificate message.
 421  */
 422 static int use_certificate_chain_file(SSL_CTX *ctx, SSL *ssl, const char *file)
 423 {
 424     BIO *in;
 425     int ret = 0;
 426     X509 *x = NULL;
 427     pem_password_cb *passwd_callback;
 428     void *passwd_callback_userdata;
 429     SSL_CTX *real_ctx = (ssl == NULL) ? ctx : ssl->ctx;
 430
 431     if (ctx == NULL && ssl == NULL)
 432         return 0;
 433
 434     ERR_clear_error();          /* clear error stack for
 435                                  * SSL_CTX_use_certificate() */
 436
 437     if (ctx != NULL) {
 438         passwd_callback = ctx->default_passwd_callback;
 439         passwd_callback_userdata = ctx->default_passwd_callback_userdata;
 440     } else {
 441         passwd_callback = ssl->default_passwd_callback;
 442         passwd_callback_userdata = ssl->default_passwd_callback_userdata;
 443     }
 444
 445     in = BIO_new(BIO_s_file());
 446     if (in == NULL) {
 447         ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
 448         goto end;
 449     }
 450
 451     if (BIO_read_filename(in, file) <= 0) {
 452         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
 453         goto end;
 454     }
 455
 456     x = X509_new_ex(real_ctx->libctx, real_ctx->propq);
 457     if (x == NULL) {
 458         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 459         goto end;
 460     }
 461     if (PEM_read_bio_X509_AUX(in, &x, passwd_callback,
 462                               passwd_callback_userdata) == NULL) {
 463         ERR_raise(ERR_LIB_SSL, ERR_R_PEM_LIB);
 464         goto end;
 465     }
 466
 467     if (ctx)
 468         ret = SSL_CTX_use_certificate(ctx, x);
 469     else
 470         ret = SSL_use_certificate(ssl, x);
 471
 472     if (ERR_peek_error() != 0)
 473         ret = 0;                /* Key/certificate mismatch doesn't imply
 474                                  * ret==0 ... */
 475     if (ret) {
 476         /*
 477          * If we could set up our certificate, now proceed to the CA
 478          * certificates.
 479          */
 480         X509 *ca;
 481         int r;
 482         unsigned long err;
 483
 484         if (ctx)
 485             r = SSL_CTX_clear_chain_certs(ctx);
 486         else
 487             r = SSL_clear_chain_certs(ssl);
 488
 489         if (r == 0) {
 490             ret = 0;
 491             goto end;
 492         }
 493
 494         while (1) {
 495             ca = X509_new_ex(real_ctx->libctx, real_ctx->propq);
 496             if (ca == NULL) {
 497                 ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 498                 goto end;
 499             }
 500             if (PEM_read_bio_X509(in, &ca, passwd_callback,
 501                                   passwd_callback_userdata) != NULL) {
 502                 if (ctx)
 503                     r = SSL_CTX_add0_chain_cert(ctx, ca);
 504                 else
 505                     r = SSL_add0_chain_cert(ssl, ca);
 506                 /*
 507                  * Note that we must not free ca if it was successfully added to
 508                  * the chain (while we must free the main certificate, since its
 509                  * reference count is increased by SSL_CTX_use_certificate).
 510                  */
 511                 if (!r) {
 512                     X509_free(ca);
 513                     ret = 0;
 514                     goto end;
 515                 }
 516             } else {
 517                 X509_free(ca);
 518                 break;
 519             }
 520         }
 521         /* When the while loop ends, it's usually just EOF. */
 522         err = ERR_peek_last_error();
 523         if (ERR_GET_LIB(err) == ERR_LIB_PEM
 524             && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)
 525             ERR_clear_error();
 526         else
 527             ret = 0;            /* some real error */
 528     }
 529
 530  end:
 531     X509_free(x);
 532     BIO_free(in);
 533     return ret;
 534 }
 535
 536 int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file)
 537 {
 538     return use_certificate_chain_file(ctx, NULL, file);
 539 }
 540
 541 int SSL_use_certificate_chain_file(SSL *ssl, const char *file)
 542 {
 543     return use_certificate_chain_file(NULL, ssl, file);
 544 }
 545
 546 static int serverinfo_find_extension(const unsigned char *serverinfo,
 547                                      size_t serverinfo_length,
 548                                      unsigned int extension_type,
 549                                      const unsigned char **extension_data,
 550                                      size_t *extension_length)
 551 {
 552     PACKET pkt, data;
 553
 554     *extension_data = NULL;
 555     *extension_length = 0;
 556     if (serverinfo == NULL || serverinfo_length == 0)
 557         return -1;
 558
 559     if (!PACKET_buf_init(&pkt, serverinfo, serverinfo_length))
 560         return -1;
 561
 562     for (;;) {
 563         unsigned int type = 0;
 564         unsigned long context = 0;
 565
 566         /* end of serverinfo */
 567         if (PACKET_remaining(&pkt) == 0)
 568             return 0;           /* Extension not found */
 569
 570         if (!PACKET_get_net_4(&pkt, &context)
 571                 || !PACKET_get_net_2(&pkt, &type)
 572                 || !PACKET_get_length_prefixed_2(&pkt, &data))
 573             return -1;
 574
 575         if (type == extension_type) {
 576             *extension_data = PACKET_data(&data);
 577             *extension_length = PACKET_remaining(&data);
 578             return 1;           /* Success */
 579         }
 580     }
 581     /* Unreachable */
 582 }
 583
 584 static int serverinfoex_srv_parse_cb(SSL *s, unsigned int ext_type,
 585                                      unsigned int context,
 586                                      const unsigned char *in,
 587                                      size_t inlen, X509 *x, size_t chainidx,
 588                                      int *al, void *arg)
 589 {
 590
 591     if (inlen != 0) {
 592         *al = SSL_AD_DECODE_ERROR;
 593         return 0;
 594     }
 595
 596     return 1;
 597 }
 598
 599 static int serverinfo_srv_parse_cb(SSL *s, unsigned int ext_type,
 600                                    const unsigned char *in,
 601                                    size_t inlen, int *al, void *arg)
 602 {
 603     return serverinfoex_srv_parse_cb(s, ext_type, 0, in, inlen, NULL, 0, al,
 604                                      arg);
 605 }
 606
 607 static int serverinfoex_srv_add_cb(SSL *s, unsigned int ext_type,
 608                                    unsigned int context,
 609                                    const unsigned char **out,
 610                                    size_t *outlen, X509 *x, size_t chainidx,
 611                                    int *al, void *arg)
 612 {
 613     const unsigned char *serverinfo = NULL;
 614     size_t serverinfo_length = 0;
 615
 616     /* We only support extensions for the first Certificate */
 617     if ((context & SSL_EXT_TLS1_3_CERTIFICATE) != 0 && chainidx > 0)
 618         return 0;
 619
 620     /* Is there serverinfo data for the chosen server cert? */
 621     if ((ssl_get_server_cert_serverinfo(s, &serverinfo,
 622                                         &serverinfo_length)) != 0) {
 623         /* Find the relevant extension from the serverinfo */
 624         int retval = serverinfo_find_extension(serverinfo, serverinfo_length,
 625                                                ext_type, out, outlen);
 626         if (retval == -1) {
 627             *al = SSL_AD_INTERNAL_ERROR;
 628             return -1;          /* Error */
 629         }
 630         if (retval == 0)
 631             return 0;           /* No extension found, don't send extension */
 632         return 1;               /* Send extension */
 633     }
 634     return 0;                   /* No serverinfo data found, don't send
 635                                  * extension */
 636 }
 637
 638 static int serverinfo_srv_add_cb(SSL *s, unsigned int ext_type,
 639                                  const unsigned char **out, size_t *outlen,
 640                                  int *al, void *arg)
 641 {
 642     return serverinfoex_srv_add_cb(s, ext_type, 0, out, outlen, NULL, 0, al,
 643                                    arg);
 644 }
 645
 646 /*
 647  * With a NULL context, this function just checks that the serverinfo data
 648  * parses correctly.  With a non-NULL context, it registers callbacks for
 649  * the included extensions.
 650  */
 651 static int serverinfo_process_buffer(unsigned int version,
 652                                      const unsigned char *serverinfo,
 653                                      size_t serverinfo_length, SSL_CTX *ctx)
 654 {
 655     PACKET pkt;
 656
 657     if (serverinfo == NULL || serverinfo_length == 0)
 658         return 0;
 659
 660     if (version != SSL_SERVERINFOV1 && version != SSL_SERVERINFOV2)
 661         return 0;
 662
 663     if (!PACKET_buf_init(&pkt, serverinfo, serverinfo_length))
 664         return 0;
 665
 666     while (PACKET_remaining(&pkt)) {
 667         unsigned long context = 0;
 668         unsigned int ext_type = 0;
 669         PACKET data;
 670
 671         if ((version == SSL_SERVERINFOV2 && !PACKET_get_net_4(&pkt, &context))
 672                 || !PACKET_get_net_2(&pkt, &ext_type)
 673                 || !PACKET_get_length_prefixed_2(&pkt, &data))
 674             return 0;
 675
 676         if (ctx == NULL)
 677             continue;
 678
 679         /*
 680          * The old style custom extensions API could be set separately for
 681          * server/client, i.e. you could set one custom extension for a client,
 682          * and *for the same extension in the same SSL_CTX* you could set a
 683          * custom extension for the server as well. It seems quite weird to be
 684          * setting a custom extension for both client and server in a single
 685          * SSL_CTX - but theoretically possible. This isn't possible in the
 686          * new API. Therefore, if we have V1 serverinfo we use the old API. We
 687          * also use the old API even if we have V2 serverinfo but the context
 688          * looks like an old style <= TLSv1.2 extension.
 689          */
 690         if (version == SSL_SERVERINFOV1 || context == SYNTHV1CONTEXT) {
 691             if (!SSL_CTX_add_server_custom_ext(ctx, ext_type,
 692                                                serverinfo_srv_add_cb,
 693                                                NULL, NULL,
 694                                                serverinfo_srv_parse_cb,
 695                                                NULL))
 696                 return 0;
 697         } else {
 698             if (!SSL_CTX_add_custom_ext(ctx, ext_type, context,
 699                                         serverinfoex_srv_add_cb,
 700                                         NULL, NULL,
 701                                         serverinfoex_srv_parse_cb,
 702                                         NULL))
 703                 return 0;
 704         }
 705     }
 706
 707     return 1;
 708 }
 709
 710 int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
 711                               const unsigned char *serverinfo,
 712                               size_t serverinfo_length)
 713 {
 714     unsigned char *new_serverinfo;
 715
 716     if (ctx == NULL || serverinfo == NULL || serverinfo_length == 0) {
 717         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
 718         return 0;
 719     }
 720     if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length,
 721                                    NULL)) {
 722         ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA);
 723         return 0;
 724     }
 725     if (ctx->cert->key == NULL) {
 726         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
 727         return 0;
 728     }
 729     new_serverinfo = OPENSSL_realloc(ctx->cert->key->serverinfo,
 730                                      serverinfo_length);
 731     if (new_serverinfo == NULL) {
 732         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 733         return 0;
 734     }
 735     ctx->cert->key->serverinfo = new_serverinfo;
 736     memcpy(ctx->cert->key->serverinfo, serverinfo, serverinfo_length);
 737     ctx->cert->key->serverinfo_length = serverinfo_length;
 738
 739     /*
 740      * Now that the serverinfo is validated and stored, go ahead and
 741      * register callbacks.
 742      */
 743     if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length,
 744                                    ctx)) {
 745         ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA);
 746         return 0;
 747     }
 748     return 1;
 749 }
 750
 751 int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
 752                            size_t serverinfo_length)
 753 {
 754     return SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV1, serverinfo,
 755                                      serverinfo_length);
 756 }
 757
 758 int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file)
 759 {
 760     unsigned char *serverinfo = NULL;
 761     unsigned char *tmp;
 762     size_t serverinfo_length = 0;
 763     unsigned char *extension = 0;
 764     long extension_length = 0;
 765     char *name = NULL;
 766     char *header = NULL;
 767     unsigned int name_len;
 768     int ret = 0;
 769     BIO *bin = NULL;
 770     size_t num_extensions = 0, contextoff = 0;
 771
 772     if (ctx == NULL || file == NULL) {
 773         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
 774         goto end;
 775     }
 776
 777     bin = BIO_new(BIO_s_file());
 778     if (bin == NULL) {
 779         ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
 780         goto end;
 781     }
 782     if (BIO_read_filename(bin, file) <= 0) {
 783         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
 784         goto end;
 785     }
 786
 787     for (num_extensions = 0;; num_extensions++) {
 788         unsigned int version;
 789
 790         if (PEM_read_bio(bin, &name, &header, &extension, &extension_length)
 791             == 0) {
 792             /*
 793              * There must be at least one extension in this file
 794              */
 795             if (num_extensions == 0) {
 796                 ERR_raise(ERR_LIB_SSL, SSL_R_NO_PEM_EXTENSIONS);
 797                 goto end;
 798             } else              /* End of file, we're done */
 799                 break;
 800         }
 801         /* Check that PEM name starts with "BEGIN SERVERINFO FOR " */
 802         name_len = strlen(name);
 803         if (name_len < sizeof(NAME_PREFIX1) - 1) {
 804             ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_TOO_SHORT);
 805             goto end;
 806         }
 807         if (HAS_PREFIX(name, NAME_PREFIX1)) {
 808             version = SSL_SERVERINFOV1;
 809         } else {
 810             if (name_len < sizeof(NAME_PREFIX2) - 1) {
 811                 ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_TOO_SHORT);
 812                 goto end;
 813             }
 814             if (!HAS_PREFIX(name, NAME_PREFIX2)) {
 815                 ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_BAD_PREFIX);
 816                 goto end;
 817             }
 818             version = SSL_SERVERINFOV2;
 819         }
 820         /*
 821          * Check that the decoded PEM data is plausible (valid length field)
 822          */
 823         if (version == SSL_SERVERINFOV1) {
 824             /* 4 byte header: 2 bytes type, 2 bytes len */
 825             if (extension_length < 4
 826                     || (extension[2] << 8) + extension[3]
 827                        != extension_length - 4) {
 828                 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA);
 829                 goto end;
 830             }
 831             /*
 832              * File does not have a context value so we must take account of
 833              * this later.
 834              */
 835             contextoff = 4;
 836         } else {
 837             /* 8 byte header: 4 bytes context, 2 bytes type, 2 bytes len */
 838             if (extension_length < 8
 839                     || (extension[6] << 8) + extension[7]
 840                        != extension_length - 8) {
 841                 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA);
 842                 goto end;
 843             }
 844         }
 845         /* Append the decoded extension to the serverinfo buffer */
 846         tmp = OPENSSL_realloc(serverinfo, serverinfo_length + extension_length
 847                                           + contextoff);
 848         if (tmp == NULL) {
 849             ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 850             goto end;
 851         }
 852         serverinfo = tmp;
 853         if (contextoff > 0) {
 854             unsigned char *sinfo = serverinfo + serverinfo_length;
 855
 856             /* We know this only uses the last 2 bytes */
 857             sinfo[0] = 0;
 858             sinfo[1] = 0;
 859             sinfo[2] = (SYNTHV1CONTEXT >> 8) & 0xff;
 860             sinfo[3] = SYNTHV1CONTEXT & 0xff;
 861         }
 862         memcpy(serverinfo + serverinfo_length + contextoff,
 863                extension, extension_length);
 864         serverinfo_length += extension_length + contextoff;
 865
 866         OPENSSL_free(name);
 867         name = NULL;
 868         OPENSSL_free(header);
 869         header = NULL;
 870         OPENSSL_free(extension);
 871         extension = NULL;
 872     }
 873
 874     ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, serverinfo,
 875                                     serverinfo_length);
 876  end:
 877     /* SSL_CTX_use_serverinfo makes a local copy of the serverinfo. */
 878     OPENSSL_free(name);
 879     OPENSSL_free(header);
 880     OPENSSL_free(extension);
 881     OPENSSL_free(serverinfo);
 882     BIO_free(bin);
 883     return ret;
 884 }
 885
 886 static int ssl_set_cert_and_key(SSL *ssl, SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey,
 887                                 STACK_OF(X509) *chain, int override)
 888 {
 889     int ret = 0;
 890     size_t i;
 891     int j;
 892     int rv;
 893     CERT *c = ssl != NULL ? ssl->cert : ctx->cert;
 894     STACK_OF(X509) *dup_chain = NULL;
 895     EVP_PKEY *pubkey = NULL;
 896
 897     /* Do all security checks before anything else */
 898     rv = ssl_security_cert(ssl, ctx, x509, 0, 1);
 899     if (rv != 1) {
 900         ERR_raise(ERR_LIB_SSL, rv);
 901         goto out;
 902     }
 903     for (j = 0; j < sk_X509_num(chain); j++) {
 904         rv = ssl_security_cert(ssl, ctx, sk_X509_value(chain, j), 0, 0);
 905         if (rv != 1) {
 906             ERR_raise(ERR_LIB_SSL, rv);
 907             goto out;
 908         }
 909     }
 910
 911     pubkey = X509_get_pubkey(x509); /* bumps reference */
 912     if (pubkey == NULL)
 913         goto out;
 914     if (privatekey == NULL) {
 915         privatekey = pubkey;
 916     } else {
 917         /* For RSA, which has no parameters, missing returns 0 */
 918         if (EVP_PKEY_missing_parameters(privatekey)) {
 919             if (EVP_PKEY_missing_parameters(pubkey)) {
 920                 /* nobody has parameters? - error */
 921                 ERR_raise(ERR_LIB_SSL, SSL_R_MISSING_PARAMETERS);
 922                 goto out;
 923             } else {
 924                 /* copy to privatekey from pubkey */
 925                 if (!EVP_PKEY_copy_parameters(privatekey, pubkey)) {
 926                     ERR_raise(ERR_LIB_SSL, SSL_R_COPY_PARAMETERS_FAILED);
 927                     goto out;
 928                 }
 929             }
 930         } else if (EVP_PKEY_missing_parameters(pubkey)) {
 931             /* copy to pubkey from privatekey */
 932             if (!EVP_PKEY_copy_parameters(pubkey, privatekey)) {
 933                 ERR_raise(ERR_LIB_SSL, SSL_R_COPY_PARAMETERS_FAILED);
 934                 goto out;
 935             }
 936         } /* else both have parameters */
 937
 938         /* check that key <-> cert match */
 939         if (EVP_PKEY_eq(pubkey, privatekey) != 1) {
 940             ERR_raise(ERR_LIB_SSL, SSL_R_PRIVATE_KEY_MISMATCH);
 941             goto out;
 942         }
 943     }
 944     if (ssl_cert_lookup_by_pkey(pubkey, &i) == NULL) {
 945         ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
 946         goto out;
 947     }
 948
 949     if (!override && (c->pkeys[i].x509 != NULL
 950                       || c->pkeys[i].privatekey != NULL
 951                       || c->pkeys[i].chain != NULL)) {
 952         /* No override, and something already there */
 953         ERR_raise(ERR_LIB_SSL, SSL_R_NOT_REPLACING_CERTIFICATE);
 954         goto out;
 955     }
 956
 957     if (chain != NULL) {
 958         dup_chain = X509_chain_up_ref(chain);
 959         if  (dup_chain == NULL) {
 960             ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 961             goto out;
 962         }
 963     }
 964
 965     OSSL_STACK_OF_X509_free(c->pkeys[i].chain);
 966     c->pkeys[i].chain = dup_chain;
 967
 968     X509_free(c->pkeys[i].x509);
 969     X509_up_ref(x509);
 970     c->pkeys[i].x509 = x509;
 971
 972     EVP_PKEY_free(c->pkeys[i].privatekey);
 973     EVP_PKEY_up_ref(privatekey);
 974     c->pkeys[i].privatekey = privatekey;
 975
 976     c->key = &(c->pkeys[i]);
 977
 978     ret = 1;
 979  out:
 980     EVP_PKEY_free(pubkey);
 981     return ret;
 982 }
 983
 984 int SSL_use_cert_and_key(SSL *ssl, X509 *x509, EVP_PKEY *privatekey,
 985                          STACK_OF(X509) *chain, int override)
 986 {
 987     return ssl_set_cert_and_key(ssl, NULL, x509, privatekey, chain, override);
 988 }
 989
 990 int SSL_CTX_use_cert_and_key(SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey,
 991                              STACK_OF(X509) *chain, int override)
 992 {
 993     return ssl_set_cert_and_key(NULL, ctx, x509, privatekey, chain, override);
 994 }