summaryrefslogtreecommitdiff
path: root/src/lib/libssl/ssl_ciph.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libssl/ssl_ciph.c')
-rw-r--r--src/lib/libssl/ssl_ciph.c1768
1 files changed, 0 insertions, 1768 deletions
diff --git a/src/lib/libssl/ssl_ciph.c b/src/lib/libssl/ssl_ciph.c
deleted file mode 100644
index b735cd7b30..0000000000
--- a/src/lib/libssl/ssl_ciph.c
+++ /dev/null
@@ -1,1768 +0,0 @@
1/* $OpenBSD: ssl_ciph.c,v 1.136 2023/07/08 16:40:13 beck Exp $ */
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 * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
60 *
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
63 * are met:
64 *
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
67 *
68 * 2. Redistributions in binary form must reproduce the above copyright
69 * notice, this list of conditions and the following disclaimer in
70 * the documentation and/or other materials provided with the
71 * distribution.
72 *
73 * 3. All advertising materials mentioning features or use of this
74 * software must display the following acknowledgment:
75 * "This product includes software developed by the OpenSSL Project
76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77 *
78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 * endorse or promote products derived from this software without
80 * prior written permission. For written permission, please contact
81 * openssl-core@openssl.org.
82 *
83 * 5. Products derived from this software may not be called "OpenSSL"
84 * nor may "OpenSSL" appear in their names without prior written
85 * permission of the OpenSSL Project.
86 *
87 * 6. Redistributions of any form whatsoever must retain the following
88 * acknowledgment:
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91 *
92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 * OF THE POSSIBILITY OF SUCH DAMAGE.
104 * ====================================================================
105 *
106 * This product includes cryptographic software written by Eric Young
107 * (eay@cryptsoft.com). This product includes software written by Tim
108 * Hudson (tjh@cryptsoft.com).
109 *
110 */
111/* ====================================================================
112 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 * ECC cipher suite support in OpenSSL originally developed by
114 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
115 */
116/* ====================================================================
117 * Copyright 2005 Nokia. All rights reserved.
118 *
119 * The portions of the attached software ("Contribution") is developed by
120 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
121 * license.
122 *
123 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
124 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
125 * support (see RFC 4279) to OpenSSL.
126 *
127 * No patent licenses or other rights except those expressly stated in
128 * the OpenSSL open source license shall be deemed granted or received
129 * expressly, by implication, estoppel, or otherwise.
130 *
131 * No assurances are provided by Nokia that the Contribution does not
132 * infringe the patent or other intellectual property rights of any third
133 * party or that the license provides you with all the necessary rights
134 * to make use of the Contribution.
135 *
136 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
137 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
138 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
139 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
140 * OTHERWISE.
141 */
142
143#include <stdio.h>
144
145#include <openssl/objects.h>
146#include <openssl/opensslconf.h>
147
148#ifndef OPENSSL_NO_ENGINE
149#include <openssl/engine.h>
150#endif
151
152#include "ssl_local.h"
153
154#define CIPHER_ADD 1
155#define CIPHER_KILL 2
156#define CIPHER_DEL 3
157#define CIPHER_ORD 4
158#define CIPHER_SPECIAL 5
159
160typedef struct cipher_order_st {
161 const SSL_CIPHER *cipher;
162 int active;
163 int dead;
164 struct cipher_order_st *next, *prev;
165} CIPHER_ORDER;
166
167static const SSL_CIPHER cipher_aliases[] = {
168
169 /* "ALL" doesn't include eNULL (must be specifically enabled) */
170 {
171 .name = SSL_TXT_ALL,
172 .algorithm_enc = ~SSL_eNULL,
173 },
174
175 /* "COMPLEMENTOFALL" */
176 {
177 .name = SSL_TXT_CMPALL,
178 .algorithm_enc = SSL_eNULL,
179 },
180
181 /*
182 * "COMPLEMENTOFDEFAULT"
183 * (does *not* include ciphersuites not found in ALL!)
184 */
185 {
186 .name = SSL_TXT_CMPDEF,
187 .algorithm_mkey = SSL_kDHE|SSL_kECDHE,
188 .algorithm_auth = SSL_aNULL,
189 .algorithm_enc = ~SSL_eNULL,
190 },
191
192 /*
193 * key exchange aliases
194 * (some of those using only a single bit here combine multiple key
195 * exchange algs according to the RFCs, e.g. kEDH combines DHE_DSS
196 * and DHE_RSA)
197 */
198 {
199 .name = SSL_TXT_kRSA,
200 .algorithm_mkey = SSL_kRSA,
201 },
202 {
203 .name = SSL_TXT_kEDH,
204 .algorithm_mkey = SSL_kDHE,
205 },
206 {
207 .name = SSL_TXT_DH,
208 .algorithm_mkey = SSL_kDHE,
209 },
210 {
211 .name = SSL_TXT_kEECDH,
212 .algorithm_mkey = SSL_kECDHE,
213 },
214 {
215 .name = SSL_TXT_ECDH,
216 .algorithm_mkey = SSL_kECDHE,
217 },
218 {
219 .name = SSL_TXT_kGOST,
220 .algorithm_mkey = SSL_kGOST,
221 },
222
223 /* server authentication aliases */
224 {
225 .name = SSL_TXT_aRSA,
226 .algorithm_auth = SSL_aRSA,
227 },
228 {
229 .name = SSL_TXT_aDSS,
230 .algorithm_auth = SSL_aDSS,
231 },
232 {
233 .name = SSL_TXT_DSS,
234 .algorithm_auth = SSL_aDSS,
235 },
236 {
237 .name = SSL_TXT_aNULL,
238 .algorithm_auth = SSL_aNULL,
239 },
240 {
241 .name = SSL_TXT_aECDSA,
242 .algorithm_auth = SSL_aECDSA,
243 },
244 {
245 .name = SSL_TXT_ECDSA,
246 .algorithm_auth = SSL_aECDSA,
247 },
248 {
249 .name = SSL_TXT_aGOST01,
250 .algorithm_auth = SSL_aGOST01,
251 },
252 {
253 .name = SSL_TXT_aGOST,
254 .algorithm_auth = SSL_aGOST01,
255 },
256
257 /* aliases combining key exchange and server authentication */
258 {
259 .name = SSL_TXT_DHE,
260 .algorithm_mkey = SSL_kDHE,
261 .algorithm_auth = ~SSL_aNULL,
262 },
263 {
264 .name = SSL_TXT_EDH,
265 .algorithm_mkey = SSL_kDHE,
266 .algorithm_auth = ~SSL_aNULL,
267 },
268 {
269 .name = SSL_TXT_ECDHE,
270 .algorithm_mkey = SSL_kECDHE,
271 .algorithm_auth = ~SSL_aNULL,
272 },
273 {
274 .name = SSL_TXT_EECDH,
275 .algorithm_mkey = SSL_kECDHE,
276 .algorithm_auth = ~SSL_aNULL,
277 },
278 {
279 .name = SSL_TXT_NULL,
280 .algorithm_enc = SSL_eNULL,
281 },
282 {
283 .name = SSL_TXT_RSA,
284 .algorithm_mkey = SSL_kRSA,
285 .algorithm_auth = SSL_aRSA,
286 },
287 {
288 .name = SSL_TXT_ADH,
289 .algorithm_mkey = SSL_kDHE,
290 .algorithm_auth = SSL_aNULL,
291 },
292 {
293 .name = SSL_TXT_AECDH,
294 .algorithm_mkey = SSL_kECDHE,
295 .algorithm_auth = SSL_aNULL,
296 },
297
298 /* symmetric encryption aliases */
299 {
300 .name = SSL_TXT_3DES,
301 .algorithm_enc = SSL_3DES,
302 },
303 {
304 .name = SSL_TXT_RC4,
305 .algorithm_enc = SSL_RC4,
306 },
307 {
308 .name = SSL_TXT_eNULL,
309 .algorithm_enc = SSL_eNULL,
310 },
311 {
312 .name = SSL_TXT_AES128,
313 .algorithm_enc = SSL_AES128|SSL_AES128GCM,
314 },
315 {
316 .name = SSL_TXT_AES256,
317 .algorithm_enc = SSL_AES256|SSL_AES256GCM,
318 },
319 {
320 .name = SSL_TXT_AES,
321 .algorithm_enc = SSL_AES,
322 },
323 {
324 .name = SSL_TXT_AES_GCM,
325 .algorithm_enc = SSL_AES128GCM|SSL_AES256GCM,
326 },
327 {
328 .name = SSL_TXT_CAMELLIA128,
329 .algorithm_enc = SSL_CAMELLIA128,
330 },
331 {
332 .name = SSL_TXT_CAMELLIA256,
333 .algorithm_enc = SSL_CAMELLIA256,
334 },
335 {
336 .name = SSL_TXT_CAMELLIA,
337 .algorithm_enc = SSL_CAMELLIA128|SSL_CAMELLIA256,
338 },
339 {
340 .name = SSL_TXT_CHACHA20,
341 .algorithm_enc = SSL_CHACHA20POLY1305,
342 },
343
344 /* MAC aliases */
345 {
346 .name = SSL_TXT_AEAD,
347 .algorithm_mac = SSL_AEAD,
348 },
349 {
350 .name = SSL_TXT_MD5,
351 .algorithm_mac = SSL_MD5,
352 },
353 {
354 .name = SSL_TXT_SHA1,
355 .algorithm_mac = SSL_SHA1,
356 },
357 {
358 .name = SSL_TXT_SHA,
359 .algorithm_mac = SSL_SHA1,
360 },
361 {
362 .name = SSL_TXT_GOST94,
363 .algorithm_mac = SSL_GOST94,
364 },
365 {
366 .name = SSL_TXT_GOST89MAC,
367 .algorithm_mac = SSL_GOST89MAC,
368 },
369 {
370 .name = SSL_TXT_SHA256,
371 .algorithm_mac = SSL_SHA256,
372 },
373 {
374 .name = SSL_TXT_SHA384,
375 .algorithm_mac = SSL_SHA384,
376 },
377 {
378 .name = SSL_TXT_STREEBOG256,
379 .algorithm_mac = SSL_STREEBOG256,
380 },
381
382 /* protocol version aliases */
383 {
384 .name = SSL_TXT_SSLV3,
385 .algorithm_ssl = SSL_SSLV3,
386 },
387 {
388 .name = SSL_TXT_TLSV1,
389 .algorithm_ssl = SSL_TLSV1,
390 },
391 {
392 .name = SSL_TXT_TLSV1_2,
393 .algorithm_ssl = SSL_TLSV1_2,
394 },
395 {
396 .name = SSL_TXT_TLSV1_3,
397 .algorithm_ssl = SSL_TLSV1_3,
398 },
399
400 /* cipher suite aliases */
401#ifdef LIBRESSL_HAS_TLS1_3
402 {
403 .valid = 1,
404 .name = "TLS_AES_128_GCM_SHA256",
405 .id = TLS1_3_CK_AES_128_GCM_SHA256,
406 .algorithm_ssl = SSL_TLSV1_3,
407 },
408 {
409 .valid = 1,
410 .name = "TLS_AES_256_GCM_SHA384",
411 .id = TLS1_3_CK_AES_256_GCM_SHA384,
412 .algorithm_ssl = SSL_TLSV1_3,
413 },
414 {
415 .valid = 1,
416 .name = "TLS_CHACHA20_POLY1305_SHA256",
417 .id = TLS1_3_CK_CHACHA20_POLY1305_SHA256,
418 .algorithm_ssl = SSL_TLSV1_3,
419 },
420#endif
421
422 /* strength classes */
423 {
424 .name = SSL_TXT_LOW,
425 .algo_strength = SSL_LOW,
426 },
427 {
428 .name = SSL_TXT_MEDIUM,
429 .algo_strength = SSL_MEDIUM,
430 },
431 {
432 .name = SSL_TXT_HIGH,
433 .algo_strength = SSL_HIGH,
434 },
435};
436
437int
438ssl_cipher_get_evp(const SSL_SESSION *ss, const EVP_CIPHER **enc,
439 const EVP_MD **md, int *mac_pkey_type, int *mac_secret_size)
440{
441 *enc = NULL;
442 *md = NULL;
443 *mac_pkey_type = NID_undef;
444 *mac_secret_size = 0;
445
446 if (ss->cipher == NULL)
447 return 0;
448
449 /*
450 * This function does not handle EVP_AEAD.
451 * See ssl_cipher_get_evp_aead instead.
452 */
453 if (ss->cipher->algorithm_mac & SSL_AEAD)
454 return 0;
455
456 switch (ss->cipher->algorithm_enc) {
457 case SSL_3DES:
458 *enc = EVP_des_ede3_cbc();
459 break;
460 case SSL_RC4:
461 *enc = EVP_rc4();
462 break;
463 case SSL_eNULL:
464 *enc = EVP_enc_null();
465 break;
466 case SSL_AES128:
467 *enc = EVP_aes_128_cbc();
468 break;
469 case SSL_AES256:
470 *enc = EVP_aes_256_cbc();
471 break;
472 case SSL_CAMELLIA128:
473 *enc = EVP_camellia_128_cbc();
474 break;
475 case SSL_CAMELLIA256:
476 *enc = EVP_camellia_256_cbc();
477 break;
478#ifndef OPENSSL_NO_GOST
479 case SSL_eGOST2814789CNT:
480 *enc = EVP_gost2814789_cnt();
481 break;
482#endif
483 }
484
485 switch (ss->cipher->algorithm_mac) {
486 case SSL_MD5:
487 *md = EVP_md5();
488 break;
489 case SSL_SHA1:
490 *md = EVP_sha1();
491 break;
492 case SSL_SHA256:
493 *md = EVP_sha256();
494 break;
495 case SSL_SHA384:
496 *md = EVP_sha384();
497 break;
498#ifndef OPENSSL_NO_GOST
499 case SSL_GOST89MAC:
500 *md = EVP_gost2814789imit();
501 break;
502 case SSL_GOST94:
503 *md = EVP_gostr341194();
504 break;
505 case SSL_STREEBOG256:
506 *md = EVP_streebog256();
507 break;
508#endif
509 }
510 if (*enc == NULL || *md == NULL)
511 return 0;
512
513 /*
514 * EVP_CIPH_FLAG_AEAD_CIPHER and EVP_CIPH_GCM_MODE ciphers are not
515 * supported via EVP_CIPHER (they should be using EVP_AEAD instead).
516 */
517 if (EVP_CIPHER_flags(*enc) & EVP_CIPH_FLAG_AEAD_CIPHER)
518 return 0;
519 if (EVP_CIPHER_mode(*enc) == EVP_CIPH_GCM_MODE)
520 return 0;
521#ifndef OPENSSL_NO_GOST
522 /* XXX JFC. die in fire already */
523 if (ss->cipher->algorithm_mac == SSL_GOST89MAC) {
524 *mac_pkey_type = EVP_PKEY_GOSTIMIT;
525 *mac_secret_size = 32; /* XXX */
526 } else {
527#endif
528 *mac_pkey_type = EVP_PKEY_HMAC;
529 *mac_secret_size = EVP_MD_size(*md);
530#ifndef OPENSSL_NO_GOST
531 }
532#endif
533 return 1;
534}
535
536/*
537 * ssl_cipher_get_evp_aead sets aead to point to the correct EVP_AEAD object
538 * for s->cipher. It returns 1 on success and 0 on error.
539 */
540int
541ssl_cipher_get_evp_aead(const SSL_SESSION *ss, const EVP_AEAD **aead)
542{
543 *aead = NULL;
544
545 if (ss->cipher == NULL)
546 return 0;
547 if ((ss->cipher->algorithm_mac & SSL_AEAD) == 0)
548 return 0;
549
550 switch (ss->cipher->algorithm_enc) {
551 case SSL_AES128GCM:
552 *aead = EVP_aead_aes_128_gcm();
553 return 1;
554 case SSL_AES256GCM:
555 *aead = EVP_aead_aes_256_gcm();
556 return 1;
557 case SSL_CHACHA20POLY1305:
558 *aead = EVP_aead_chacha20_poly1305();
559 return 1;
560 default:
561 break;
562 }
563 return 0;
564}
565
566int
567ssl_get_handshake_evp_md(SSL *s, const EVP_MD **md)
568{
569 unsigned long handshake_mac;
570
571 *md = NULL;
572
573 if (s->s3->hs.cipher == NULL)
574 return 0;
575
576 handshake_mac = s->s3->hs.cipher->algorithm2 &
577 SSL_HANDSHAKE_MAC_MASK;
578
579 /* For TLSv1.2 we upgrade the default MD5+SHA1 MAC to SHA256. */
580 if (SSL_USE_SHA256_PRF(s) && handshake_mac == SSL_HANDSHAKE_MAC_DEFAULT)
581 handshake_mac = SSL_HANDSHAKE_MAC_SHA256;
582
583 switch (handshake_mac) {
584 case SSL_HANDSHAKE_MAC_DEFAULT:
585 *md = EVP_md5_sha1();
586 return 1;
587#ifndef OPENSSL_NO_GOST
588 case SSL_HANDSHAKE_MAC_GOST94:
589 *md = EVP_gostr341194();
590 return 1;
591 case SSL_HANDSHAKE_MAC_STREEBOG256:
592 *md = EVP_streebog256();
593 return 1;
594#endif
595 case SSL_HANDSHAKE_MAC_SHA256:
596 *md = EVP_sha256();
597 return 1;
598 case SSL_HANDSHAKE_MAC_SHA384:
599 *md = EVP_sha384();
600 return 1;
601 default:
602 break;
603 }
604
605 return 0;
606}
607
608#define ITEM_SEP(a) \
609 (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))
610
611static void
612ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
613 CIPHER_ORDER **tail)
614{
615 if (curr == *tail)
616 return;
617 if (curr == *head)
618 *head = curr->next;
619 if (curr->prev != NULL)
620 curr->prev->next = curr->next;
621 if (curr->next != NULL)
622 curr->next->prev = curr->prev;
623 (*tail)->next = curr;
624 curr->prev= *tail;
625 curr->next = NULL;
626 *tail = curr;
627}
628
629static void
630ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr,
631 CIPHER_ORDER **tail)
632{
633 if (curr == *head)
634 return;
635 if (curr == *tail)
636 *tail = curr->prev;
637 if (curr->next != NULL)
638 curr->next->prev = curr->prev;
639 if (curr->prev != NULL)
640 curr->prev->next = curr->next;
641 (*head)->prev = curr;
642 curr->next= *head;
643 curr->prev = NULL;
644 *head = curr;
645}
646
647static void
648ssl_cipher_get_disabled(unsigned long *mkey, unsigned long *auth,
649 unsigned long *enc, unsigned long *mac, unsigned long *ssl)
650{
651 *mkey = 0;
652 *auth = 0;
653 *enc = 0;
654 *mac = 0;
655 *ssl = 0;
656
657 /*
658 * Check for the availability of GOST 34.10 public/private key
659 * algorithms. If they are not available disable the associated
660 * authentication and key exchange algorithms.
661 */
662 if (EVP_PKEY_meth_find(NID_id_GostR3410_2001) == NULL) {
663 *auth |= SSL_aGOST01;
664 *mkey |= SSL_kGOST;
665 }
666
667#ifdef SSL_FORBID_ENULL
668 *enc |= SSL_eNULL;
669#endif
670}
671
672static void
673ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method, int num_of_ciphers,
674 unsigned long disabled_mkey, unsigned long disabled_auth,
675 unsigned long disabled_enc, unsigned long disabled_mac,
676 unsigned long disabled_ssl, CIPHER_ORDER *co_list,
677 CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)
678{
679 int i, co_list_num;
680 const SSL_CIPHER *c;
681
682 /*
683 * We have num_of_ciphers descriptions compiled in, depending on the
684 * method selected (SSLv3, TLSv1, etc). These will later be sorted in
685 * a linked list with at most num entries.
686 */
687
688 /* Get the initial list of ciphers */
689 co_list_num = 0; /* actual count of ciphers */
690 for (i = 0; i < num_of_ciphers; i++) {
691 c = ssl_method->get_cipher(i);
692 /*
693 * Drop any invalid ciphers and any which use unavailable
694 * algorithms.
695 */
696 if ((c != NULL) && c->valid &&
697 !(c->algorithm_mkey & disabled_mkey) &&
698 !(c->algorithm_auth & disabled_auth) &&
699 !(c->algorithm_enc & disabled_enc) &&
700 !(c->algorithm_mac & disabled_mac) &&
701 !(c->algorithm_ssl & disabled_ssl)) {
702 co_list[co_list_num].cipher = c;
703 co_list[co_list_num].next = NULL;
704 co_list[co_list_num].prev = NULL;
705 co_list[co_list_num].active = 0;
706 co_list_num++;
707 }
708 }
709
710 /*
711 * Prepare linked list from list entries
712 */
713 if (co_list_num > 0) {
714 co_list[0].prev = NULL;
715
716 if (co_list_num > 1) {
717 co_list[0].next = &co_list[1];
718
719 for (i = 1; i < co_list_num - 1; i++) {
720 co_list[i].prev = &co_list[i - 1];
721 co_list[i].next = &co_list[i + 1];
722 }
723
724 co_list[co_list_num - 1].prev =
725 &co_list[co_list_num - 2];
726 }
727
728 co_list[co_list_num - 1].next = NULL;
729
730 *head_p = &co_list[0];
731 *tail_p = &co_list[co_list_num - 1];
732 }
733}
734
735static void
736ssl_cipher_collect_aliases(const SSL_CIPHER **ca_list, int num_of_group_aliases,
737 unsigned long disabled_mkey, unsigned long disabled_auth,
738 unsigned long disabled_enc, unsigned long disabled_mac,
739 unsigned long disabled_ssl, CIPHER_ORDER *head)
740{
741 CIPHER_ORDER *ciph_curr;
742 const SSL_CIPHER **ca_curr;
743 int i;
744 unsigned long mask_mkey = ~disabled_mkey;
745 unsigned long mask_auth = ~disabled_auth;
746 unsigned long mask_enc = ~disabled_enc;
747 unsigned long mask_mac = ~disabled_mac;
748 unsigned long mask_ssl = ~disabled_ssl;
749
750 /*
751 * First, add the real ciphers as already collected
752 */
753 ciph_curr = head;
754 ca_curr = ca_list;
755 while (ciph_curr != NULL) {
756 *ca_curr = ciph_curr->cipher;
757 ca_curr++;
758 ciph_curr = ciph_curr->next;
759 }
760
761 /*
762 * Now we add the available ones from the cipher_aliases[] table.
763 * They represent either one or more algorithms, some of which
764 * in any affected category must be supported (set in enabled_mask),
765 * or represent a cipher strength value (will be added in any case because algorithms=0).
766 */
767 for (i = 0; i < num_of_group_aliases; i++) {
768 unsigned long algorithm_mkey = cipher_aliases[i].algorithm_mkey;
769 unsigned long algorithm_auth = cipher_aliases[i].algorithm_auth;
770 unsigned long algorithm_enc = cipher_aliases[i].algorithm_enc;
771 unsigned long algorithm_mac = cipher_aliases[i].algorithm_mac;
772 unsigned long algorithm_ssl = cipher_aliases[i].algorithm_ssl;
773
774 if (algorithm_mkey)
775 if ((algorithm_mkey & mask_mkey) == 0)
776 continue;
777
778 if (algorithm_auth)
779 if ((algorithm_auth & mask_auth) == 0)
780 continue;
781
782 if (algorithm_enc)
783 if ((algorithm_enc & mask_enc) == 0)
784 continue;
785
786 if (algorithm_mac)
787 if ((algorithm_mac & mask_mac) == 0)
788 continue;
789
790 if (algorithm_ssl)
791 if ((algorithm_ssl & mask_ssl) == 0)
792 continue;
793
794 *ca_curr = (SSL_CIPHER *)(cipher_aliases + i);
795 ca_curr++;
796 }
797
798 *ca_curr = NULL; /* end of list */
799}
800
801static void
802ssl_cipher_apply_rule(unsigned long cipher_id, unsigned long alg_mkey,
803 unsigned long alg_auth, unsigned long alg_enc, unsigned long alg_mac,
804 unsigned long alg_ssl, unsigned long algo_strength, int rule,
805 int strength_bits, CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)
806{
807 CIPHER_ORDER *head, *tail, *curr, *next, *last;
808 const SSL_CIPHER *cp;
809 int reverse = 0;
810
811 if (rule == CIPHER_DEL)
812 reverse = 1; /* needed to maintain sorting between currently deleted ciphers */
813
814 head = *head_p;
815 tail = *tail_p;
816
817 if (reverse) {
818 next = tail;
819 last = head;
820 } else {
821 next = head;
822 last = tail;
823 }
824
825 curr = NULL;
826 for (;;) {
827 if (curr == last)
828 break;
829 curr = next;
830 next = reverse ? curr->prev : curr->next;
831
832 cp = curr->cipher;
833
834 if (cipher_id && cp->id != cipher_id)
835 continue;
836
837 /*
838 * Selection criteria is either the value of strength_bits
839 * or the algorithms used.
840 */
841 if (strength_bits >= 0) {
842 if (strength_bits != cp->strength_bits)
843 continue;
844 } else {
845 if (alg_mkey && !(alg_mkey & cp->algorithm_mkey))
846 continue;
847 if (alg_auth && !(alg_auth & cp->algorithm_auth))
848 continue;
849 if (alg_enc && !(alg_enc & cp->algorithm_enc))
850 continue;
851 if (alg_mac && !(alg_mac & cp->algorithm_mac))
852 continue;
853 if (alg_ssl && !(alg_ssl & cp->algorithm_ssl))
854 continue;
855 if ((algo_strength & SSL_STRONG_MASK) && !(algo_strength & SSL_STRONG_MASK & cp->algo_strength))
856 continue;
857 }
858
859 /* add the cipher if it has not been added yet. */
860 if (rule == CIPHER_ADD) {
861 /* reverse == 0 */
862 if (!curr->active) {
863 ll_append_tail(&head, curr, &tail);
864 curr->active = 1;
865 }
866 }
867 /* Move the added cipher to this location */
868 else if (rule == CIPHER_ORD) {
869 /* reverse == 0 */
870 if (curr->active) {
871 ll_append_tail(&head, curr, &tail);
872 }
873 } else if (rule == CIPHER_DEL) {
874 /* reverse == 1 */
875 if (curr->active) {
876 /* most recently deleted ciphersuites get best positions
877 * for any future CIPHER_ADD (note that the CIPHER_DEL loop
878 * works in reverse to maintain the order) */
879 ll_append_head(&head, curr, &tail);
880 curr->active = 0;
881 }
882 } else if (rule == CIPHER_KILL) {
883 /* reverse == 0 */
884 if (head == curr)
885 head = curr->next;
886 else
887 curr->prev->next = curr->next;
888 if (tail == curr)
889 tail = curr->prev;
890 curr->active = 0;
891 if (curr->next != NULL)
892 curr->next->prev = curr->prev;
893 if (curr->prev != NULL)
894 curr->prev->next = curr->next;
895 curr->next = NULL;
896 curr->prev = NULL;
897 }
898 }
899
900 *head_p = head;
901 *tail_p = tail;
902}
903
904static int
905ssl_cipher_strength_sort(CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)
906{
907 int max_strength_bits, i, *number_uses;
908 CIPHER_ORDER *curr;
909
910 /*
911 * This routine sorts the ciphers with descending strength. The sorting
912 * must keep the pre-sorted sequence, so we apply the normal sorting
913 * routine as '+' movement to the end of the list.
914 */
915 max_strength_bits = 0;
916 curr = *head_p;
917 while (curr != NULL) {
918 if (curr->active &&
919 (curr->cipher->strength_bits > max_strength_bits))
920 max_strength_bits = curr->cipher->strength_bits;
921 curr = curr->next;
922 }
923
924 number_uses = calloc((max_strength_bits + 1), sizeof(int));
925 if (!number_uses) {
926 SSLerrorx(ERR_R_MALLOC_FAILURE);
927 return (0);
928 }
929
930 /*
931 * Now find the strength_bits values actually used
932 */
933 curr = *head_p;
934 while (curr != NULL) {
935 if (curr->active)
936 number_uses[curr->cipher->strength_bits]++;
937 curr = curr->next;
938 }
939 /*
940 * Go through the list of used strength_bits values in descending
941 * order.
942 */
943 for (i = max_strength_bits; i >= 0; i--)
944 if (number_uses[i] > 0)
945 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ORD, i, head_p, tail_p);
946
947 free(number_uses);
948 return (1);
949}
950
951static int
952ssl_cipher_process_rulestr(const char *rule_str, CIPHER_ORDER **head_p,
953 CIPHER_ORDER **tail_p, const SSL_CIPHER **ca_list, SSL_CERT *cert,
954 int *tls13_seen)
955{
956 unsigned long alg_mkey, alg_auth, alg_enc, alg_mac, alg_ssl;
957 unsigned long algo_strength;
958 int j, multi, found, rule, retval, ok, buflen;
959 unsigned long cipher_id = 0;
960 const char *l, *buf;
961 char ch;
962
963 *tls13_seen = 0;
964
965 retval = 1;
966 l = rule_str;
967 for (;;) {
968 ch = *l;
969
970 if (ch == '\0')
971 break;
972
973 if (ch == '-') {
974 rule = CIPHER_DEL;
975 l++;
976 } else if (ch == '+') {
977 rule = CIPHER_ORD;
978 l++;
979 } else if (ch == '!') {
980 rule = CIPHER_KILL;
981 l++;
982 } else if (ch == '@') {
983 rule = CIPHER_SPECIAL;
984 l++;
985 } else {
986 rule = CIPHER_ADD;
987 }
988
989 if (ITEM_SEP(ch)) {
990 l++;
991 continue;
992 }
993
994 alg_mkey = 0;
995 alg_auth = 0;
996 alg_enc = 0;
997 alg_mac = 0;
998 alg_ssl = 0;
999 algo_strength = 0;
1000
1001 for (;;) {
1002 ch = *l;
1003 buf = l;
1004 buflen = 0;
1005 while (((ch >= 'A') && (ch <= 'Z')) ||
1006 ((ch >= '0') && (ch <= '9')) ||
1007 ((ch >= 'a') && (ch <= 'z')) ||
1008 (ch == '-') || (ch == '.') ||
1009 (ch == '_') || (ch == '=')) {
1010 ch = *(++l);
1011 buflen++;
1012 }
1013
1014 if (buflen == 0) {
1015 /*
1016 * We hit something we cannot deal with,
1017 * it is no command or separator nor
1018 * alphanumeric, so we call this an error.
1019 */
1020 SSLerrorx(SSL_R_INVALID_COMMAND);
1021 return 0;
1022 }
1023
1024 if (rule == CIPHER_SPECIAL) {
1025 /* unused -- avoid compiler warning */
1026 found = 0;
1027 /* special treatment */
1028 break;
1029 }
1030
1031 /* check for multi-part specification */
1032 if (ch == '+') {
1033 multi = 1;
1034 l++;
1035 } else
1036 multi = 0;
1037
1038 /*
1039 * Now search for the cipher alias in the ca_list.
1040 * Be careful with the strncmp, because the "buflen"
1041 * limitation will make the rule "ADH:SOME" and the
1042 * cipher "ADH-MY-CIPHER" look like a match for
1043 * buflen=3. So additionally check whether the cipher
1044 * name found has the correct length. We can save a
1045 * strlen() call: just checking for the '\0' at the
1046 * right place is sufficient, we have to strncmp()
1047 * anyway (we cannot use strcmp(), because buf is not
1048 * '\0' terminated.)
1049 */
1050 j = found = 0;
1051 cipher_id = 0;
1052 while (ca_list[j]) {
1053 if (!strncmp(buf, ca_list[j]->name, buflen) &&
1054 (ca_list[j]->name[buflen] == '\0')) {
1055 found = 1;
1056 break;
1057 } else
1058 j++;
1059 }
1060
1061 if (!found)
1062 break; /* ignore this entry */
1063
1064 if (ca_list[j]->algorithm_mkey) {
1065 if (alg_mkey) {
1066 alg_mkey &= ca_list[j]->algorithm_mkey;
1067 if (!alg_mkey) {
1068 found = 0;
1069 break;
1070 }
1071 } else
1072 alg_mkey = ca_list[j]->algorithm_mkey;
1073 }
1074
1075 if (ca_list[j]->algorithm_auth) {
1076 if (alg_auth) {
1077 alg_auth &= ca_list[j]->algorithm_auth;
1078 if (!alg_auth) {
1079 found = 0;
1080 break;
1081 }
1082 } else
1083 alg_auth = ca_list[j]->algorithm_auth;
1084 }
1085
1086 if (ca_list[j]->algorithm_enc) {
1087 if (alg_enc) {
1088 alg_enc &= ca_list[j]->algorithm_enc;
1089 if (!alg_enc) {
1090 found = 0;
1091 break;
1092 }
1093 } else
1094 alg_enc = ca_list[j]->algorithm_enc;
1095 }
1096
1097 if (ca_list[j]->algorithm_mac) {
1098 if (alg_mac) {
1099 alg_mac &= ca_list[j]->algorithm_mac;
1100 if (!alg_mac) {
1101 found = 0;
1102 break;
1103 }
1104 } else
1105 alg_mac = ca_list[j]->algorithm_mac;
1106 }
1107
1108 if (ca_list[j]->algo_strength & SSL_STRONG_MASK) {
1109 if (algo_strength & SSL_STRONG_MASK) {
1110 algo_strength &=
1111 (ca_list[j]->algo_strength &
1112 SSL_STRONG_MASK) | ~SSL_STRONG_MASK;
1113 if (!(algo_strength &
1114 SSL_STRONG_MASK)) {
1115 found = 0;
1116 break;
1117 }
1118 } else
1119 algo_strength |=
1120 ca_list[j]->algo_strength &
1121 SSL_STRONG_MASK;
1122 }
1123
1124 if (ca_list[j]->valid) {
1125 /*
1126 * explicit ciphersuite found; its protocol
1127 * version does not become part of the search
1128 * pattern!
1129 */
1130 cipher_id = ca_list[j]->id;
1131 if (ca_list[j]->algorithm_ssl == SSL_TLSV1_3)
1132 *tls13_seen = 1;
1133 } else {
1134 /*
1135 * not an explicit ciphersuite; only in this
1136 * case, the protocol version is considered
1137 * part of the search pattern
1138 */
1139 if (ca_list[j]->algorithm_ssl) {
1140 if (alg_ssl) {
1141 alg_ssl &=
1142 ca_list[j]->algorithm_ssl;
1143 if (!alg_ssl) {
1144 found = 0;
1145 break;
1146 }
1147 } else
1148 alg_ssl =
1149 ca_list[j]->algorithm_ssl;
1150 }
1151 }
1152
1153 if (!multi)
1154 break;
1155 }
1156
1157 /*
1158 * Ok, we have the rule, now apply it
1159 */
1160 if (rule == CIPHER_SPECIAL) {
1161 /* special command */
1162 ok = 0;
1163 if (buflen == 8 && strncmp(buf, "STRENGTH", 8) == 0) {
1164 ok = ssl_cipher_strength_sort(head_p, tail_p);
1165 } else if (buflen == 10 &&
1166 strncmp(buf, "SECLEVEL=", 9) == 0) {
1167 int level = buf[9] - '0';
1168
1169 if (level >= 0 && level <= 5) {
1170 cert->security_level = level;
1171 ok = 1;
1172 } else {
1173 SSLerrorx(SSL_R_INVALID_COMMAND);
1174 }
1175 } else {
1176 SSLerrorx(SSL_R_INVALID_COMMAND);
1177 }
1178 if (ok == 0)
1179 retval = 0;
1180
1181 while ((*l != '\0') && !ITEM_SEP(*l))
1182 l++;
1183 } else if (found) {
1184 if (alg_ssl == SSL_TLSV1_3)
1185 *tls13_seen = 1;
1186 ssl_cipher_apply_rule(cipher_id, alg_mkey, alg_auth,
1187 alg_enc, alg_mac, alg_ssl, algo_strength, rule,
1188 -1, head_p, tail_p);
1189 } else {
1190 while ((*l != '\0') && !ITEM_SEP(*l))
1191 l++;
1192 }
1193 if (*l == '\0')
1194 break; /* done */
1195 }
1196
1197 return (retval);
1198}
1199
1200static inline int
1201ssl_aes_is_accelerated(void)
1202{
1203#if defined(__i386__) || defined(__x86_64__)
1204 return ((OPENSSL_cpu_caps() & (1ULL << 57)) != 0);
1205#else
1206 return (0);
1207#endif
1208}
1209
1210STACK_OF(SSL_CIPHER) *
1211ssl_create_cipher_list(const SSL_METHOD *ssl_method,
1212 STACK_OF(SSL_CIPHER) **cipher_list,
1213 STACK_OF(SSL_CIPHER) *cipher_list_tls13,
1214 const char *rule_str, SSL_CERT *cert)
1215{
1216 int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases;
1217 unsigned long disabled_mkey, disabled_auth, disabled_enc, disabled_mac, disabled_ssl;
1218 STACK_OF(SSL_CIPHER) *cipherstack = NULL, *ret = NULL;
1219 const char *rule_p;
1220 CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr;
1221 const SSL_CIPHER **ca_list = NULL;
1222 const SSL_CIPHER *cipher;
1223 int tls13_seen = 0;
1224 int any_active;
1225 int i;
1226
1227 /*
1228 * Return with error if nothing to do.
1229 */
1230 if (rule_str == NULL || cipher_list == NULL)
1231 goto err;
1232
1233 /*
1234 * To reduce the work to do we only want to process the compiled
1235 * in algorithms, so we first get the mask of disabled ciphers.
1236 */
1237 ssl_cipher_get_disabled(&disabled_mkey, &disabled_auth, &disabled_enc, &disabled_mac, &disabled_ssl);
1238
1239 /*
1240 * Now we have to collect the available ciphers from the compiled
1241 * in ciphers. We cannot get more than the number compiled in, so
1242 * it is used for allocation.
1243 */
1244 num_of_ciphers = ssl3_num_ciphers();
1245 co_list = reallocarray(NULL, num_of_ciphers, sizeof(CIPHER_ORDER));
1246 if (co_list == NULL) {
1247 SSLerrorx(ERR_R_MALLOC_FAILURE);
1248 goto err;
1249 }
1250
1251 ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers,
1252 disabled_mkey, disabled_auth, disabled_enc, disabled_mac, disabled_ssl,
1253 co_list, &head, &tail);
1254
1255
1256 /* Now arrange all ciphers by preference: */
1257
1258 /* Everything else being equal, prefer ephemeral ECDH over other key exchange mechanisms */
1259 ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail);
1260 ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail);
1261
1262 if (ssl_aes_is_accelerated()) {
1263 /*
1264 * We have hardware assisted AES - prefer AES as a symmetric
1265 * cipher, with CHACHA20 second.
1266 */
1267 ssl_cipher_apply_rule(0, 0, 0, SSL_AES, 0, 0, 0,
1268 CIPHER_ADD, -1, &head, &tail);
1269 ssl_cipher_apply_rule(0, 0, 0, SSL_CHACHA20POLY1305,
1270 0, 0, 0, CIPHER_ADD, -1, &head, &tail);
1271 } else {
1272 /*
1273 * CHACHA20 is fast and safe on all hardware and is thus our
1274 * preferred symmetric cipher, with AES second.
1275 */
1276 ssl_cipher_apply_rule(0, 0, 0, SSL_CHACHA20POLY1305,
1277 0, 0, 0, CIPHER_ADD, -1, &head, &tail);
1278 ssl_cipher_apply_rule(0, 0, 0, SSL_AES, 0, 0, 0,
1279 CIPHER_ADD, -1, &head, &tail);
1280 }
1281
1282 /* Temporarily enable everything else for sorting */
1283 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail);
1284
1285 /* Low priority for MD5 */
1286 ssl_cipher_apply_rule(0, 0, 0, 0, SSL_MD5, 0, 0, CIPHER_ORD, -1, &head, &tail);
1287
1288 /* Move anonymous ciphers to the end. Usually, these will remain disabled.
1289 * (For applications that allow them, they aren't too bad, but we prefer
1290 * authenticated ciphers.) */
1291 ssl_cipher_apply_rule(0, 0, SSL_aNULL, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail);
1292
1293 /* Move ciphers without forward secrecy to the end */
1294 ssl_cipher_apply_rule(0, SSL_kRSA, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail);
1295
1296 /* RC4 is sort of broken - move it to the end */
1297 ssl_cipher_apply_rule(0, 0, 0, SSL_RC4, 0, 0, 0, CIPHER_ORD, -1, &head, &tail);
1298
1299 /* Now sort by symmetric encryption strength. The above ordering remains
1300 * in force within each class */
1301 if (!ssl_cipher_strength_sort(&head, &tail))
1302 goto err;
1303
1304 /* Now disable everything (maintaining the ordering!) */
1305 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail);
1306
1307 /* TLSv1.3 first. */
1308 ssl_cipher_apply_rule(0, 0, 0, 0, 0, SSL_TLSV1_3, 0, CIPHER_ADD, -1, &head, &tail);
1309 ssl_cipher_apply_rule(0, 0, 0, 0, 0, SSL_TLSV1_3, 0, CIPHER_DEL, -1, &head, &tail);
1310
1311 /*
1312 * We also need cipher aliases for selecting based on the rule_str.
1313 * There might be two types of entries in the rule_str: 1) names
1314 * of ciphers themselves 2) aliases for groups of ciphers.
1315 * For 1) we need the available ciphers and for 2) the cipher
1316 * groups of cipher_aliases added together in one list (otherwise
1317 * we would be happy with just the cipher_aliases table).
1318 */
1319 num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER);
1320 num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;
1321 ca_list = reallocarray(NULL, num_of_alias_max, sizeof(SSL_CIPHER *));
1322 if (ca_list == NULL) {
1323 SSLerrorx(ERR_R_MALLOC_FAILURE);
1324 goto err;
1325 }
1326 ssl_cipher_collect_aliases(ca_list, num_of_group_aliases, disabled_mkey,
1327 disabled_auth, disabled_enc, disabled_mac, disabled_ssl, head);
1328
1329 /*
1330 * If the rule_string begins with DEFAULT, apply the default rule
1331 * before using the (possibly available) additional rules.
1332 */
1333 ok = 1;
1334 rule_p = rule_str;
1335 if (strncmp(rule_str, "DEFAULT", 7) == 0) {
1336 ok = ssl_cipher_process_rulestr(SSL_DEFAULT_CIPHER_LIST,
1337 &head, &tail, ca_list, cert, &tls13_seen);
1338 rule_p += 7;
1339 if (*rule_p == ':')
1340 rule_p++;
1341 }
1342
1343 if (ok && (strlen(rule_p) > 0))
1344 ok = ssl_cipher_process_rulestr(rule_p, &head, &tail, ca_list,
1345 cert, &tls13_seen);
1346
1347 if (!ok) {
1348 /* Rule processing failure */
1349 goto err;
1350 }
1351
1352 /*
1353 * Allocate new "cipherstack" for the result, return with error
1354 * if we cannot get one.
1355 */
1356 if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) {
1357 SSLerrorx(ERR_R_MALLOC_FAILURE);
1358 goto err;
1359 }
1360
1361 /* Prefer TLSv1.3 cipher suites. */
1362 if (cipher_list_tls13 != NULL) {
1363 for (i = 0; i < sk_SSL_CIPHER_num(cipher_list_tls13); i++) {
1364 cipher = sk_SSL_CIPHER_value(cipher_list_tls13, i);
1365 if (!sk_SSL_CIPHER_push(cipherstack, cipher)) {
1366 SSLerrorx(ERR_R_MALLOC_FAILURE);
1367 goto err;
1368 }
1369 }
1370 tls13_seen = 1;
1371 }
1372
1373 /*
1374 * The cipher selection for the list is done. The ciphers are added
1375 * to the resulting precedence to the STACK_OF(SSL_CIPHER).
1376 *
1377 * If the rule string did not contain any references to TLSv1.3 and
1378 * TLSv1.3 cipher suites have not been configured separately,
1379 * include inactive TLSv1.3 cipher suites. This avoids attempts to
1380 * use TLSv1.3 with an older rule string that does not include
1381 * TLSv1.3 cipher suites. If the rule string resulted in no active
1382 * cipher suites then we return an empty stack.
1383 */
1384 any_active = 0;
1385 for (curr = head; curr != NULL; curr = curr->next) {
1386 if (curr->active ||
1387 (!tls13_seen && curr->cipher->algorithm_ssl == SSL_TLSV1_3)) {
1388 if (!sk_SSL_CIPHER_push(cipherstack, curr->cipher)) {
1389 SSLerrorx(ERR_R_MALLOC_FAILURE);
1390 goto err;
1391 }
1392 }
1393 any_active |= curr->active;
1394 }
1395 if (!any_active)
1396 sk_SSL_CIPHER_zero(cipherstack);
1397
1398 sk_SSL_CIPHER_free(*cipher_list);
1399 *cipher_list = cipherstack;
1400 cipherstack = NULL;
1401
1402 ret = *cipher_list;
1403
1404 err:
1405 sk_SSL_CIPHER_free(cipherstack);
1406 free((void *)ca_list);
1407 free(co_list);
1408
1409 return ret;
1410}
1411
1412const SSL_CIPHER *
1413SSL_CIPHER_get_by_id(unsigned int id)
1414{
1415 return ssl3_get_cipher_by_id(id);
1416}
1417LSSL_ALIAS(SSL_CIPHER_get_by_id);
1418
1419const SSL_CIPHER *
1420SSL_CIPHER_get_by_value(uint16_t value)
1421{
1422 return ssl3_get_cipher_by_value(value);
1423}
1424LSSL_ALIAS(SSL_CIPHER_get_by_value);
1425
1426char *
1427SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
1428{
1429 unsigned long alg_mkey, alg_auth, alg_enc, alg_mac, alg_ssl, alg2;
1430 const char *ver, *kx, *au, *enc, *mac;
1431 char *ret;
1432 int l;
1433
1434 alg_mkey = cipher->algorithm_mkey;
1435 alg_auth = cipher->algorithm_auth;
1436 alg_enc = cipher->algorithm_enc;
1437 alg_mac = cipher->algorithm_mac;
1438 alg_ssl = cipher->algorithm_ssl;
1439
1440 alg2 = cipher->algorithm2;
1441
1442 if (alg_ssl & SSL_SSLV3)
1443 ver = "SSLv3";
1444 else if (alg_ssl & SSL_TLSV1_2)
1445 ver = "TLSv1.2";
1446 else if (alg_ssl & SSL_TLSV1_3)
1447 ver = "TLSv1.3";
1448 else
1449 ver = "unknown";
1450
1451 switch (alg_mkey) {
1452 case SSL_kRSA:
1453 kx = "RSA";
1454 break;
1455 case SSL_kDHE:
1456 kx = "DH";
1457 break;
1458 case SSL_kECDHE:
1459 kx = "ECDH";
1460 break;
1461 case SSL_kGOST:
1462 kx = "GOST";
1463 break;
1464 case SSL_kTLS1_3:
1465 kx = "TLSv1.3";
1466 break;
1467 default:
1468 kx = "unknown";
1469 }
1470
1471 switch (alg_auth) {
1472 case SSL_aRSA:
1473 au = "RSA";
1474 break;
1475 case SSL_aDSS:
1476 au = "DSS";
1477 break;
1478 case SSL_aNULL:
1479 au = "None";
1480 break;
1481 case SSL_aECDSA:
1482 au = "ECDSA";
1483 break;
1484 case SSL_aGOST01:
1485 au = "GOST01";
1486 break;
1487 case SSL_aTLS1_3:
1488 au = "TLSv1.3";
1489 break;
1490 default:
1491 au = "unknown";
1492 break;
1493 }
1494
1495 switch (alg_enc) {
1496 case SSL_3DES:
1497 enc = "3DES(168)";
1498 break;
1499 case SSL_RC4:
1500 enc = alg2 & SSL2_CF_8_BYTE_ENC ? "RC4(64)" : "RC4(128)";
1501 break;
1502 case SSL_eNULL:
1503 enc = "None";
1504 break;
1505 case SSL_AES128:
1506 enc = "AES(128)";
1507 break;
1508 case SSL_AES256:
1509 enc = "AES(256)";
1510 break;
1511 case SSL_AES128GCM:
1512 enc = "AESGCM(128)";
1513 break;
1514 case SSL_AES256GCM:
1515 enc = "AESGCM(256)";
1516 break;
1517 case SSL_CAMELLIA128:
1518 enc = "Camellia(128)";
1519 break;
1520 case SSL_CAMELLIA256:
1521 enc = "Camellia(256)";
1522 break;
1523 case SSL_CHACHA20POLY1305:
1524 enc = "ChaCha20-Poly1305";
1525 break;
1526 case SSL_eGOST2814789CNT:
1527 enc = "GOST-28178-89-CNT";
1528 break;
1529 default:
1530 enc = "unknown";
1531 break;
1532 }
1533
1534 switch (alg_mac) {
1535 case SSL_MD5:
1536 mac = "MD5";
1537 break;
1538 case SSL_SHA1:
1539 mac = "SHA1";
1540 break;
1541 case SSL_SHA256:
1542 mac = "SHA256";
1543 break;
1544 case SSL_SHA384:
1545 mac = "SHA384";
1546 break;
1547 case SSL_AEAD:
1548 mac = "AEAD";
1549 break;
1550 case SSL_GOST94:
1551 mac = "GOST94";
1552 break;
1553 case SSL_GOST89MAC:
1554 mac = "GOST89IMIT";
1555 break;
1556 case SSL_STREEBOG256:
1557 mac = "STREEBOG256";
1558 break;
1559 default:
1560 mac = "unknown";
1561 break;
1562 }
1563
1564 if (asprintf(&ret, "%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s\n",
1565 cipher->name, ver, kx, au, enc, mac) == -1)
1566 return "OPENSSL_malloc Error";
1567
1568 if (buf != NULL) {
1569 l = strlcpy(buf, ret, len);
1570 free(ret);
1571 ret = buf;
1572 if (l >= len)
1573 ret = "Buffer too small";
1574 }
1575
1576 return (ret);
1577}
1578LSSL_ALIAS(SSL_CIPHER_description);
1579
1580const char *
1581SSL_CIPHER_get_version(const SSL_CIPHER *c)
1582{
1583 if (c == NULL)
1584 return("(NONE)");
1585 if ((c->id >> 24) == 3)
1586 return("TLSv1/SSLv3");
1587 else
1588 return("unknown");
1589}
1590LSSL_ALIAS(SSL_CIPHER_get_version);
1591
1592/* return the actual cipher being used */
1593const char *
1594SSL_CIPHER_get_name(const SSL_CIPHER *c)
1595{
1596 if (c != NULL)
1597 return (c->name);
1598 return("(NONE)");
1599}
1600LSSL_ALIAS(SSL_CIPHER_get_name);
1601
1602/* number of bits for symmetric cipher */
1603int
1604SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits)
1605{
1606 int ret = 0;
1607
1608 if (c != NULL) {
1609 if (alg_bits != NULL)
1610 *alg_bits = c->alg_bits;
1611 ret = c->strength_bits;
1612 }
1613 return (ret);
1614}
1615LSSL_ALIAS(SSL_CIPHER_get_bits);
1616
1617unsigned long
1618SSL_CIPHER_get_id(const SSL_CIPHER *c)
1619{
1620 return c->id;
1621}
1622LSSL_ALIAS(SSL_CIPHER_get_id);
1623
1624uint16_t
1625SSL_CIPHER_get_value(const SSL_CIPHER *c)
1626{
1627 return ssl3_cipher_get_value(c);
1628}
1629LSSL_ALIAS(SSL_CIPHER_get_value);
1630
1631const SSL_CIPHER *
1632SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr)
1633{
1634 uint16_t cipher_value;
1635 CBS cbs;
1636
1637 /* This API is documented with ptr being an array of length two. */
1638 CBS_init(&cbs, ptr, 2);
1639 if (!CBS_get_u16(&cbs, &cipher_value))
1640 return NULL;
1641
1642 return ssl3_get_cipher_by_value(cipher_value);
1643}
1644LSSL_ALIAS(SSL_CIPHER_find);
1645
1646int
1647SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c)
1648{
1649 switch (c->algorithm_enc) {
1650 case SSL_eNULL:
1651 return NID_undef;
1652 case SSL_3DES:
1653 return NID_des_ede3_cbc;
1654 case SSL_AES128:
1655 return NID_aes_128_cbc;
1656 case SSL_AES128GCM:
1657 return NID_aes_128_gcm;
1658 case SSL_AES256:
1659 return NID_aes_256_cbc;
1660 case SSL_AES256GCM:
1661 return NID_aes_256_gcm;
1662 case SSL_CAMELLIA128:
1663 return NID_camellia_128_cbc;
1664 case SSL_CAMELLIA256:
1665 return NID_camellia_256_cbc;
1666 case SSL_CHACHA20POLY1305:
1667 return NID_chacha20_poly1305;
1668 case SSL_DES:
1669 return NID_des_cbc;
1670 case SSL_RC4:
1671 return NID_rc4;
1672 case SSL_eGOST2814789CNT:
1673 return NID_gost89_cnt;
1674 default:
1675 return NID_undef;
1676 }
1677}
1678LSSL_ALIAS(SSL_CIPHER_get_cipher_nid);
1679
1680int
1681SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c)
1682{
1683 switch (c->algorithm_mac) {
1684 case SSL_AEAD:
1685 return NID_undef;
1686 case SSL_GOST89MAC:
1687 return NID_id_Gost28147_89_MAC;
1688 case SSL_GOST94:
1689 return NID_id_GostR3411_94;
1690 case SSL_MD5:
1691 return NID_md5;
1692 case SSL_SHA1:
1693 return NID_sha1;
1694 case SSL_SHA256:
1695 return NID_sha256;
1696 case SSL_SHA384:
1697 return NID_sha384;
1698 case SSL_STREEBOG256:
1699 return NID_id_tc26_gost3411_2012_256;
1700 default:
1701 return NID_undef;
1702 }
1703}
1704LSSL_ALIAS(SSL_CIPHER_get_digest_nid);
1705
1706int
1707SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c)
1708{
1709 switch (c->algorithm_mkey) {
1710 case SSL_kDHE:
1711 return NID_kx_dhe;
1712 case SSL_kECDHE:
1713 return NID_kx_ecdhe;
1714 case SSL_kGOST:
1715 return NID_kx_gost;
1716 case SSL_kRSA:
1717 return NID_kx_rsa;
1718 default:
1719 return NID_undef;
1720 }
1721}
1722LSSL_ALIAS(SSL_CIPHER_get_kx_nid);
1723
1724int
1725SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c)
1726{
1727 switch (c->algorithm_auth) {
1728 case SSL_aNULL:
1729 return NID_auth_null;
1730 case SSL_aECDSA:
1731 return NID_auth_ecdsa;
1732 case SSL_aGOST01:
1733 return NID_auth_gost01;
1734 case SSL_aRSA:
1735 return NID_auth_rsa;
1736 default:
1737 return NID_undef;
1738 }
1739}
1740LSSL_ALIAS(SSL_CIPHER_get_auth_nid);
1741
1742int
1743SSL_CIPHER_is_aead(const SSL_CIPHER *c)
1744{
1745 return (c->algorithm_mac & SSL_AEAD) == SSL_AEAD;
1746}
1747LSSL_ALIAS(SSL_CIPHER_is_aead);
1748
1749void *
1750SSL_COMP_get_compression_methods(void)
1751{
1752 return NULL;
1753}
1754LSSL_ALIAS(SSL_COMP_get_compression_methods);
1755
1756int
1757SSL_COMP_add_compression_method(int id, void *cm)
1758{
1759 return 1;
1760}
1761LSSL_ALIAS(SSL_COMP_add_compression_method);
1762
1763const char *
1764SSL_COMP_get_name(const void *comp)
1765{
1766 return NULL;
1767}
1768LSSL_ALIAS(SSL_COMP_get_name);
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2026-02-12 22:31:31 +0000