ssl/ssl_rsa.c

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