Add sanity check to PRF
[openssl.git] / ssl / ssl_rsa.c
1 /* ssl/ssl_rsa.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include "ssl_locl.h"
61 #include <openssl/bio.h>
62 #include <openssl/objects.h>
63 #include <openssl/evp.h>
64 #include <openssl/x509.h>
65 #include <openssl/pem.h>
66
67 static int ssl_set_cert(CERT *c, X509 *x509);
68 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey);
69 int SSL_use_certificate(SSL *ssl, X509 *x)
70 {
71     if (x == NULL) {
72         SSLerr(SSL_F_SSL_USE_CERTIFICATE, ERR_R_PASSED_NULL_PARAMETER);
73         return (0);
74     }
75     if (!ssl_cert_inst(&ssl->cert)) {
76         SSLerr(SSL_F_SSL_USE_CERTIFICATE, ERR_R_MALLOC_FAILURE);
77         return (0);
78     }
79     return (ssl_set_cert(ssl->cert, x));
80 }
81
82 #ifndef OPENSSL_NO_STDIO
83 int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
84 {
85     int j;
86     BIO *in;
87     int ret = 0;
88     X509 *x = NULL;
89
90     in = BIO_new(BIO_s_file_internal());
91     if (in == NULL) {
92         SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE, ERR_R_BUF_LIB);
93         goto end;
94     }
95
96     if (BIO_read_filename(in, file) <= 0) {
97         SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE, ERR_R_SYS_LIB);
98         goto end;
99     }
100     if (type == SSL_FILETYPE_ASN1) {
101         j = ERR_R_ASN1_LIB;
102         x = d2i_X509_bio(in, NULL);
103     } else if (type == SSL_FILETYPE_PEM) {
104         j = ERR_R_PEM_LIB;
105         x = PEM_read_bio_X509(in, NULL, ssl->ctx->default_passwd_callback,
106                               ssl->ctx->default_passwd_callback_userdata);
107     } else {
108         SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE, SSL_R_BAD_SSL_FILETYPE);
109         goto end;
110     }
111
112     if (x == NULL) {
113         SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE, j);
114         goto end;
115     }
116
117     ret = SSL_use_certificate(ssl, x);
118  end:
119     if (x != NULL)
120         X509_free(x);
121     if (in != NULL)
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 (!ssl_cert_inst(&ssl->cert)) {
154         SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY, ERR_R_MALLOC_FAILURE);
155         return (0);
156     }
157     if ((pkey = EVP_PKEY_new()) == NULL) {
158         SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY, ERR_R_EVP_LIB);
159         return (0);
160     }
161
162     RSA_up_ref(rsa);
163     EVP_PKEY_assign_RSA(pkey, rsa);
164
165     ret = ssl_set_pkey(ssl->cert, pkey);
166     EVP_PKEY_free(pkey);
167     return (ret);
168 }
169 #endif
170
171 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey)
172 {
173     int i;
174
175     i = ssl_cert_type(NULL, pkey);
176     if (i < 0) {
177         SSLerr(SSL_F_SSL_SET_PKEY, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
178         return (0);
179     }
180
181     if (c->pkeys[i].x509 != NULL) {
182         EVP_PKEY *pktmp;
183         pktmp = X509_get_pubkey(c->pkeys[i].x509);
184         EVP_PKEY_copy_parameters(pktmp, pkey);
185         EVP_PKEY_free(pktmp);
186         ERR_clear_error();
187
188 #ifndef OPENSSL_NO_RSA
189         /*
190          * Don't check the public/private key, this is mostly for smart
191          * cards.
192          */
193         if ((pkey->type == EVP_PKEY_RSA) &&
194             (RSA_flags(pkey->pkey.rsa) & RSA_METHOD_FLAG_NO_CHECK)) ;
195         else
196 #endif
197         if (!X509_check_private_key(c->pkeys[i].x509, pkey)) {
198             X509_free(c->pkeys[i].x509);
199             c->pkeys[i].x509 = NULL;
200             return 0;
201         }
202     }
203
204     if (c->pkeys[i].privatekey != NULL)
205         EVP_PKEY_free(c->pkeys[i].privatekey);
206     CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
207     c->pkeys[i].privatekey = pkey;
208     c->key = &(c->pkeys[i]);
209
210     c->valid = 0;
211     return (1);
212 }
213
214 #ifndef OPENSSL_NO_RSA
215 # ifndef OPENSSL_NO_STDIO
216 int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type)
217 {
218     int j, ret = 0;
219     BIO *in;
220     RSA *rsa = NULL;
221
222     in = BIO_new(BIO_s_file_internal());
223     if (in == NULL) {
224         SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE, ERR_R_BUF_LIB);
225         goto end;
226     }
227
228     if (BIO_read_filename(in, file) <= 0) {
229         SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE, ERR_R_SYS_LIB);
230         goto end;
231     }
232     if (type == SSL_FILETYPE_ASN1) {
233         j = ERR_R_ASN1_LIB;
234         rsa = d2i_RSAPrivateKey_bio(in, NULL);
235     } else if (type == SSL_FILETYPE_PEM) {
236         j = ERR_R_PEM_LIB;
237         rsa = PEM_read_bio_RSAPrivateKey(in, NULL,
238                                          ssl->ctx->default_passwd_callback,
239                                          ssl->
240                                          ctx->default_passwd_callback_userdata);
241     } else {
242         SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE, SSL_R_BAD_SSL_FILETYPE);
243         goto end;
244     }
245     if (rsa == NULL) {
246         SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE, j);
247         goto end;
248     }
249     ret = SSL_use_RSAPrivateKey(ssl, rsa);
250     RSA_free(rsa);
251  end:
252     if (in != NULL)
253         BIO_free(in);
254     return (ret);
255 }
256 # endif
257
258 int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len)
259 {
260     int ret;
261     const unsigned char *p;
262     RSA *rsa;
263
264     p = d;
265     if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) {
266         SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
267         return (0);
268     }
269
270     ret = SSL_use_RSAPrivateKey(ssl, rsa);
271     RSA_free(rsa);
272     return (ret);
273 }
274 #endif                          /* !OPENSSL_NO_RSA */
275
276 int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey)
277 {
278     int ret;
279
280     if (pkey == NULL) {
281         SSLerr(SSL_F_SSL_USE_PRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
282         return (0);
283     }
284     if (!ssl_cert_inst(&ssl->cert)) {
285         SSLerr(SSL_F_SSL_USE_PRIVATEKEY, ERR_R_MALLOC_FAILURE);
286         return (0);
287     }
288     ret = ssl_set_pkey(ssl->cert, pkey);
289     return (ret);
290 }
291
292 #ifndef OPENSSL_NO_STDIO
293 int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type)
294 {
295     int j, ret = 0;
296     BIO *in;
297     EVP_PKEY *pkey = NULL;
298
299     in = BIO_new(BIO_s_file_internal());
300     if (in == NULL) {
301         SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE, ERR_R_BUF_LIB);
302         goto end;
303     }
304
305     if (BIO_read_filename(in, file) <= 0) {
306         SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE, ERR_R_SYS_LIB);
307         goto end;
308     }
309     if (type == SSL_FILETYPE_PEM) {
310         j = ERR_R_PEM_LIB;
311         pkey = PEM_read_bio_PrivateKey(in, NULL,
312                                        ssl->ctx->default_passwd_callback,
313                                        ssl->
314                                        ctx->default_passwd_callback_userdata);
315     } else if (type == SSL_FILETYPE_ASN1) {
316         j = ERR_R_ASN1_LIB;
317         pkey = d2i_PrivateKey_bio(in, NULL);
318     } else {
319         SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE, SSL_R_BAD_SSL_FILETYPE);
320         goto end;
321     }
322     if (pkey == NULL) {
323         SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE, j);
324         goto end;
325     }
326     ret = SSL_use_PrivateKey(ssl, pkey);
327     EVP_PKEY_free(pkey);
328  end:
329     if (in != NULL)
330         BIO_free(in);
331     return (ret);
332 }
333 #endif
334
335 int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, const unsigned char *d,
336                             long len)
337 {
338     int ret;
339     const unsigned char *p;
340     EVP_PKEY *pkey;
341
342     p = d;
343     if ((pkey = d2i_PrivateKey(type, NULL, &p, (long)len)) == NULL) {
344         SSLerr(SSL_F_SSL_USE_PRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
345         return (0);
346     }
347
348     ret = SSL_use_PrivateKey(ssl, pkey);
349     EVP_PKEY_free(pkey);
350     return (ret);
351 }
352
353 int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x)
354 {
355     if (x == NULL) {
356         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE, ERR_R_PASSED_NULL_PARAMETER);
357         return (0);
358     }
359     if (!ssl_cert_inst(&ctx->cert)) {
360         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE, ERR_R_MALLOC_FAILURE);
361         return (0);
362     }
363     return (ssl_set_cert(ctx->cert, x));
364 }
365
366 static int ssl_set_cert(CERT *c, X509 *x)
367 {
368     EVP_PKEY *pkey;
369     int i;
370
371     pkey = X509_get_pubkey(x);
372     if (pkey == NULL) {
373         SSLerr(SSL_F_SSL_SET_CERT, SSL_R_X509_LIB);
374         return (0);
375     }
376
377     i = ssl_cert_type(x, pkey);
378     if (i < 0) {
379         SSLerr(SSL_F_SSL_SET_CERT, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
380         EVP_PKEY_free(pkey);
381         return (0);
382     }
383
384     if (c->pkeys[i].privatekey != NULL) {
385         EVP_PKEY_copy_parameters(pkey, c->pkeys[i].privatekey);
386         ERR_clear_error();
387
388 #ifndef OPENSSL_NO_RSA
389         /*
390          * Don't check the public/private key, this is mostly for smart
391          * cards.
392          */
393         if ((c->pkeys[i].privatekey->type == EVP_PKEY_RSA) &&
394             (RSA_flags(c->pkeys[i].privatekey->pkey.rsa) &
395              RSA_METHOD_FLAG_NO_CHECK)) ;
396         else
397 #endif                          /* OPENSSL_NO_RSA */
398         if (!X509_check_private_key(x, c->pkeys[i].privatekey)) {
399             /*
400              * don't fail for a cert/key mismatch, just free current private
401              * key (when switching to a different cert & key, first this
402              * function should be used, then ssl_set_pkey
403              */
404             EVP_PKEY_free(c->pkeys[i].privatekey);
405             c->pkeys[i].privatekey = NULL;
406             /* clear error queue */
407             ERR_clear_error();
408         }
409     }
410
411     EVP_PKEY_free(pkey);
412
413     if (c->pkeys[i].x509 != NULL)
414         X509_free(c->pkeys[i].x509);
415     CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
416     c->pkeys[i].x509 = x;
417     c->key = &(c->pkeys[i]);
418
419     c->valid = 0;
420     return (1);
421 }
422
423 #ifndef OPENSSL_NO_STDIO
424 int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type)
425 {
426     int j;
427     BIO *in;
428     int ret = 0;
429     X509 *x = NULL;
430
431     in = BIO_new(BIO_s_file_internal());
432     if (in == NULL) {
433         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE, ERR_R_BUF_LIB);
434         goto end;
435     }
436
437     if (BIO_read_filename(in, file) <= 0) {
438         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE, ERR_R_SYS_LIB);
439         goto end;
440     }
441     if (type == SSL_FILETYPE_ASN1) {
442         j = ERR_R_ASN1_LIB;
443         x = d2i_X509_bio(in, NULL);
444     } else if (type == SSL_FILETYPE_PEM) {
445         j = ERR_R_PEM_LIB;
446         x = PEM_read_bio_X509(in, NULL, ctx->default_passwd_callback,
447                               ctx->default_passwd_callback_userdata);
448     } else {
449         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE, SSL_R_BAD_SSL_FILETYPE);
450         goto end;
451     }
452
453     if (x == NULL) {
454         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE, j);
455         goto end;
456     }
457
458     ret = SSL_CTX_use_certificate(ctx, x);
459  end:
460     if (x != NULL)
461         X509_free(x);
462     if (in != NULL)
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 (!ssl_cert_inst(&ctx->cert)) {
496         SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY, ERR_R_MALLOC_FAILURE);
497         return (0);
498     }
499     if ((pkey = EVP_PKEY_new()) == NULL) {
500         SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY, ERR_R_EVP_LIB);
501         return (0);
502     }
503
504     RSA_up_ref(rsa);
505     EVP_PKEY_assign_RSA(pkey, rsa);
506
507     ret = ssl_set_pkey(ctx->cert, pkey);
508     EVP_PKEY_free(pkey);
509     return (ret);
510 }
511
512 # ifndef OPENSSL_NO_STDIO
513 int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type)
514 {
515     int j, ret = 0;
516     BIO *in;
517     RSA *rsa = NULL;
518
519     in = BIO_new(BIO_s_file_internal());
520     if (in == NULL) {
521         SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE, ERR_R_BUF_LIB);
522         goto end;
523     }
524
525     if (BIO_read_filename(in, file) <= 0) {
526         SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE, ERR_R_SYS_LIB);
527         goto end;
528     }
529     if (type == SSL_FILETYPE_ASN1) {
530         j = ERR_R_ASN1_LIB;
531         rsa = d2i_RSAPrivateKey_bio(in, NULL);
532     } else if (type == SSL_FILETYPE_PEM) {
533         j = ERR_R_PEM_LIB;
534         rsa = PEM_read_bio_RSAPrivateKey(in, NULL,
535                                          ctx->default_passwd_callback,
536                                          ctx->default_passwd_callback_userdata);
537     } else {
538         SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE, SSL_R_BAD_SSL_FILETYPE);
539         goto end;
540     }
541     if (rsa == NULL) {
542         SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE, j);
543         goto end;
544     }
545     ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa);
546     RSA_free(rsa);
547  end:
548     if (in != NULL)
549         BIO_free(in);
550     return (ret);
551 }
552 # endif
553
554 int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d,
555                                    long len)
556 {
557     int ret;
558     const unsigned char *p;
559     RSA *rsa;
560
561     p = d;
562     if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) {
563         SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
564         return (0);
565     }
566
567     ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa);
568     RSA_free(rsa);
569     return (ret);
570 }
571 #endif                          /* !OPENSSL_NO_RSA */
572
573 int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey)
574 {
575     if (pkey == NULL) {
576         SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
577         return (0);
578     }
579     if (!ssl_cert_inst(&ctx->cert)) {
580         SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY, ERR_R_MALLOC_FAILURE);
581         return (0);
582     }
583     return (ssl_set_pkey(ctx->cert, pkey));
584 }
585
586 #ifndef OPENSSL_NO_STDIO
587 int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type)
588 {
589     int j, ret = 0;
590     BIO *in;
591     EVP_PKEY *pkey = NULL;
592
593     in = BIO_new(BIO_s_file_internal());
594     if (in == NULL) {
595         SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE, ERR_R_BUF_LIB);
596         goto end;
597     }
598
599     if (BIO_read_filename(in, file) <= 0) {
600         SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE, ERR_R_SYS_LIB);
601         goto end;
602     }
603     if (type == SSL_FILETYPE_PEM) {
604         j = ERR_R_PEM_LIB;
605         pkey = PEM_read_bio_PrivateKey(in, NULL,
606                                        ctx->default_passwd_callback,
607                                        ctx->default_passwd_callback_userdata);
608     } else if (type == SSL_FILETYPE_ASN1) {
609         j = ERR_R_ASN1_LIB;
610         pkey = d2i_PrivateKey_bio(in, NULL);
611     } else {
612         SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE, SSL_R_BAD_SSL_FILETYPE);
613         goto end;
614     }
615     if (pkey == NULL) {
616         SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE, j);
617         goto end;
618     }
619     ret = SSL_CTX_use_PrivateKey(ctx, pkey);
620     EVP_PKEY_free(pkey);
621  end:
622     if (in != NULL)
623         BIO_free(in);
624     return (ret);
625 }
626 #endif
627
628 int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx,
629                                 const unsigned char *d, long len)
630 {
631     int ret;
632     const unsigned char *p;
633     EVP_PKEY *pkey;
634
635     p = d;
636     if ((pkey = d2i_PrivateKey(type, NULL, &p, (long)len)) == NULL) {
637         SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
638         return (0);
639     }
640
641     ret = SSL_CTX_use_PrivateKey(ctx, pkey);
642     EVP_PKEY_free(pkey);
643     return (ret);
644 }
645
646 #ifndef OPENSSL_NO_STDIO
647 /*
648  * Read a file that contains our certificate in "PEM" format, possibly
649  * followed by a sequence of CA certificates that should be sent to the peer
650  * in the Certificate message.
651  */
652 int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file)
653 {
654     BIO *in;
655     int ret = 0;
656     X509 *x = NULL;
657
658     ERR_clear_error();          /* clear error stack for
659                                  * SSL_CTX_use_certificate() */
660
661     in = BIO_new(BIO_s_file_internal());
662     if (in == NULL) {
663         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_BUF_LIB);
664         goto end;
665     }
666
667     if (BIO_read_filename(in, file) <= 0) {
668         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_SYS_LIB);
669         goto end;
670     }
671
672     x = PEM_read_bio_X509_AUX(in, NULL, ctx->default_passwd_callback,
673                               ctx->default_passwd_callback_userdata);
674     if (x == NULL) {
675         SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_PEM_LIB);
676         goto end;
677     }
678
679     ret = SSL_CTX_use_certificate(ctx, x);
680
681     if (ERR_peek_error() != 0)
682         ret = 0;                /* Key/certificate mismatch doesn't imply
683                                  * ret==0 ... */
684     if (ret) {
685         /*
686          * If we could set up our certificate, now proceed to the CA
687          * certificates.
688          */
689         X509 *ca;
690         int r;
691         unsigned long err;
692
693         if (ctx->extra_certs != NULL) {
694             sk_X509_pop_free(ctx->extra_certs, X509_free);
695             ctx->extra_certs = NULL;
696         }
697
698         while ((ca = PEM_read_bio_X509(in, NULL,
699                                        ctx->default_passwd_callback,
700                                        ctx->default_passwd_callback_userdata))
701                != NULL) {
702             r = SSL_CTX_add_extra_chain_cert(ctx, ca);
703             if (!r) {
704                 X509_free(ca);
705                 ret = 0;
706                 goto end;
707             }
708             /*
709              * Note that we must not free r if it was successfully added to
710              * the chain (while we must free the main certificate, since its
711              * reference count is increased by SSL_CTX_use_certificate).
712              */
713         }
714         /* When the while loop ends, it's usually just EOF. */
715         err = ERR_peek_last_error();
716         if (ERR_GET_LIB(err) == ERR_LIB_PEM
717             && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)
718             ERR_clear_error();
719         else
720             ret = 0;            /* some real error */
721     }
722
723  end:
724     if (x != NULL)
725         X509_free(x);
726     if (in != NULL)
727         BIO_free(in);
728     return (ret);
729 }
730 #endif