ssl_rsa.c@ 104031

Last change on this file since 104031 was 102863, checked in by vboxsync, 11 months ago
openssl-3.1.4: Applied and adjusted our OpenSSL changes to 3.1.3. bugref:10577
File size: 30.8 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.1.4/ssl/ssl_rsa.c@ 104031

Download in other formats: