ssl/ssl_rsa.c

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