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