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