Coverage Report

Created: 2026-11-16 07:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl/ssl/ssl_ciph.c
Line
Count
Source
1
/*
2
 * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
3
 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
4
 * Copyright 2005 Nokia. All rights reserved.
5
 *
6
 * Licensed under the Apache License 2.0 (the "License").  You may not use
7
 * this file except in compliance with the License.  You can obtain a copy
8
 * in the file LICENSE in the source distribution or at
9
 * https://www.openssl.org/source/license.html
10
 */
11
12
/*
13
 * Because of *asn1_*
14
 */
15
#define OPENSSL_SUPPRESS_DEPRECATED
16
17
#include <stdio.h>
18
#include <ctype.h>
19
#include <openssl/objects.h>
20
#include <openssl/comp.h>
21
#include <openssl/crypto.h>
22
#include <openssl/conf.h>
23
#include <openssl/trace.h>
24
#include "internal/nelem.h"
25
#include "ssl_local.h"
26
#include "internal/thread_once.h"
27
#include "internal/cryptlib.h"
28
#include "internal/comp.h"
29
#include "internal/ssl_unwrap.h"
30
31
/* NB: make sure indices in these tables match values above */
32
33
typedef struct {
34
    uint32_t mask;
35
    int nid;
36
} ssl_cipher_table;
37
38
/* Table of NIDs for each cipher */
39
static const ssl_cipher_table ssl_cipher_table_cipher[SSL_ENC_NUM_IDX] = {
40
    { SSL_3DES, NID_des_ede3_cbc },
41
    { SSL_RC4, NID_rc4 },
42
    { SSL_IDEA, NID_idea_cbc },
43
    { SSL_eNULL, NID_undef },
44
    { SSL_AES128, NID_aes_128_cbc },
45
    { SSL_AES256, NID_aes_256_cbc },
46
    { SSL_CAMELLIA128, NID_camellia_128_cbc },
47
    { SSL_CAMELLIA256, NID_camellia_256_cbc },
48
    { SSL_eGOST2814789CNT, NID_gost89_cnt },
49
    { SSL_SEED, NID_seed_cbc },
50
    { SSL_AES128GCM, NID_aes_128_gcm },
51
    { SSL_AES256GCM, NID_aes_256_gcm },
52
    { SSL_AES128CCM, NID_aes_128_ccm },
53
    { SSL_AES256CCM, NID_aes_256_ccm },
54
    { SSL_AES128CCM8, NID_aes_128_ccm },
55
    { SSL_AES256CCM8, NID_aes_256_ccm },
56
    { SSL_eGOST2814789CNT12, NID_gost89_cnt_12 },
57
    { SSL_CHACHA20POLY1305, NID_chacha20_poly1305 },
58
    { SSL_ARIA128GCM, NID_aria_128_gcm },
59
    { SSL_ARIA256GCM, NID_aria_256_gcm },
60
    { SSL_MAGMA, NID_magma_ctr_acpkm },
61
    { SSL_KUZNYECHIK, NID_kuznyechik_ctr_acpkm },
62
    { SSL_SM4GCM, NID_sm4_gcm },
63
    { SSL_SM4CCM, NID_sm4_ccm },
64
};
65
66
/* NB: make sure indices in this table matches values above */
67
static const ssl_cipher_table ssl_cipher_table_mac[SSL_MD_NUM_IDX] = {
68
    { SSL_MD5, NID_md5 }, /* SSL_MD_MD5_IDX 0 */
69
    { SSL_SHA1, NID_sha1 }, /* SSL_MD_SHA1_IDX 1 */
70
    { SSL_GOST94, NID_id_GostR3411_94 }, /* SSL_MD_GOST94_IDX 2 */
71
    { SSL_GOST89MAC, NID_id_Gost28147_89_MAC }, /* SSL_MD_GOST89MAC_IDX 3 */
72
    { SSL_SHA256, NID_sha256 }, /* SSL_MD_SHA256_IDX 4 */
73
    { SSL_SHA384, NID_sha384 }, /* SSL_MD_SHA384_IDX 5 */
74
    { SSL_GOST12_256, NID_id_GostR3411_2012_256 }, /* SSL_MD_GOST12_256_IDX 6 */
75
    { SSL_GOST89MAC12, NID_gost_mac_12 }, /* SSL_MD_GOST89MAC12_IDX 7 */
76
    { SSL_GOST12_512, NID_id_GostR3411_2012_512 }, /* SSL_MD_GOST12_512_IDX 8 */
77
    { 0, NID_md5_sha1 }, /* SSL_MD_MD5_SHA1_IDX 9 */
78
    { 0, NID_sha224 }, /* SSL_MD_SHA224_IDX 10 */
79
    { 0, NID_sha512 }, /* SSL_MD_SHA512_IDX 11 */
80
    { SSL_MAGMAOMAC, NID_magma_mac }, /* sSL_MD_MAGMAOMAC_IDX 12 */
81
    { SSL_KUZNYECHIKOMAC, NID_kuznyechik_mac }, /* SSL_MD_KUZNYECHIKOMAC_IDX 13 */
82
    { 0, NID_sm3 }, /* SSL_MD_SM3_IDX 14 */
83
};
84
85
/* *INDENT-OFF* */
86
static const ssl_cipher_table ssl_cipher_table_kx[] = {
87
    { SSL_kRSA, NID_kx_rsa },
88
    { SSL_kECDHE, NID_kx_ecdhe },
89
    { SSL_kDHE, NID_kx_dhe },
90
    { SSL_kECDHEPSK, NID_kx_ecdhe_psk },
91
    { SSL_kDHEPSK, NID_kx_dhe_psk },
92
    { SSL_kRSAPSK, NID_kx_rsa_psk },
93
    { SSL_kPSK, NID_kx_psk },
94
    { SSL_kSRP, NID_kx_srp },
95
    { SSL_kGOST, NID_kx_gost },
96
    { SSL_kGOST18, NID_kx_gost18 },
97
    { SSL_kANY, NID_kx_any }
98
};
99
100
static const ssl_cipher_table ssl_cipher_table_auth[] = {
101
    { SSL_aRSA, NID_auth_rsa },
102
    { SSL_aECDSA, NID_auth_ecdsa },
103
    { SSL_aPSK, NID_auth_psk },
104
    { SSL_aDSS, NID_auth_dss },
105
    { SSL_aGOST01, NID_auth_gost01 },
106
    { SSL_aGOST12, NID_auth_gost12 },
107
    { SSL_aSRP, NID_auth_srp },
108
    { SSL_aNULL, NID_auth_null },
109
    { SSL_aANY, NID_auth_any }
110
};
111
/* *INDENT-ON* */
112
113
/* Utility function for table lookup */
114
static int ssl_cipher_info_find(const ssl_cipher_table *table,
115
    size_t table_cnt, uint32_t mask)
116
0
{
117
0
    size_t i;
118
0
    for (i = 0; i < table_cnt; i++, table++) {
119
0
        if (table->mask == mask)
120
0
            return (int)i;
121
0
    }
122
0
    return -1;
123
0
}
124
125
#define ssl_cipher_info_lookup(table, x) \
126
0
    ssl_cipher_info_find(table, OSSL_NELEM(table), x)
127
128
static const int default_mac_pkey_id[SSL_MD_NUM_IDX] = {
129
    /* MD5, SHA, GOST94, MAC89 */
130
    EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef,
131
    /* SHA256, SHA384, GOST2012_256, MAC89-12 */
132
    EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef,
133
    /* GOST2012_512 */
134
    EVP_PKEY_HMAC,
135
    /* MD5/SHA1, SHA224, SHA512, MAGMAOMAC, KUZNYECHIKOMAC */
136
    NID_undef, NID_undef, NID_undef, NID_undef, NID_undef
137
};
138
139
0
#define CIPHER_ADD 1
140
0
#define CIPHER_KILL 2
141
0
#define CIPHER_DEL 3
142
0
#define CIPHER_ORD 4
143
0
#define CIPHER_SPECIAL 5
144
/*
145
 * Bump the ciphers to the top of the list.
146
 * This rule isn't currently supported by the public cipherstring API.
147
 */
148
0
#define CIPHER_BUMP 6
149
150
typedef struct cipher_order_st {
151
    const SSL_CIPHER *cipher;
152
    int active;
153
    struct cipher_order_st *next, *prev;
154
} CIPHER_ORDER;
155
156
static const SSL_CIPHER cipher_aliases[] = {
157
    /* "ALL" doesn't include eNULL (must be specifically enabled) */
158
    { 0, SSL_TXT_ALL, NULL, 0, 0, 0, ~SSL_eNULL },
159
    /* "COMPLEMENTOFALL" */
160
    { 0, SSL_TXT_CMPALL, NULL, 0, 0, 0, SSL_eNULL },
161
162
    /*
163
     * "COMPLEMENTOFDEFAULT" (does *not* include ciphersuites not found in
164
     * ALL!)
165
     */
166
    { 0, SSL_TXT_CMPDEF, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_NOT_DEFAULT },
167
168
    /*
169
     * key exchange aliases (some of those using only a single bit here
170
     * combine multiple key exchange algs according to the RFCs, e.g. kDHE
171
     * combines DHE_DSS and DHE_RSA)
172
     */
173
    { 0, SSL_TXT_kRSA, NULL, 0, SSL_kRSA },
174
175
    { 0, SSL_TXT_kEDH, NULL, 0, SSL_kDHE },
176
    { 0, SSL_TXT_kDHE, NULL, 0, SSL_kDHE },
177
    { 0, SSL_TXT_DH, NULL, 0, SSL_kDHE },
178
179
    { 0, SSL_TXT_kEECDH, NULL, 0, SSL_kECDHE },
180
    { 0, SSL_TXT_kECDHE, NULL, 0, SSL_kECDHE },
181
    { 0, SSL_TXT_ECDH, NULL, 0, SSL_kECDHE },
182
183
    { 0, SSL_TXT_kPSK, NULL, 0, SSL_kPSK },
184
    { 0, SSL_TXT_kRSAPSK, NULL, 0, SSL_kRSAPSK },
185
    { 0, SSL_TXT_kECDHEPSK, NULL, 0, SSL_kECDHEPSK },
186
    { 0, SSL_TXT_kDHEPSK, NULL, 0, SSL_kDHEPSK },
187
    { 0, SSL_TXT_kSRP, NULL, 0, SSL_kSRP },
188
    { 0, SSL_TXT_kGOST, NULL, 0, SSL_kGOST },
189
    { 0, SSL_TXT_kGOST18, NULL, 0, SSL_kGOST18 },
190
191
    /* server authentication aliases */
192
    { 0, SSL_TXT_aRSA, NULL, 0, 0, SSL_aRSA },
193
    { 0, SSL_TXT_aDSS, NULL, 0, 0, SSL_aDSS },
194
    { 0, SSL_TXT_DSS, NULL, 0, 0, SSL_aDSS },
195
    { 0, SSL_TXT_aNULL, NULL, 0, 0, SSL_aNULL },
196
    { 0, SSL_TXT_aECDSA, NULL, 0, 0, SSL_aECDSA },
197
    { 0, SSL_TXT_ECDSA, NULL, 0, 0, SSL_aECDSA },
198
    { 0, SSL_TXT_aPSK, NULL, 0, 0, SSL_aPSK },
199
    { 0, SSL_TXT_aGOST01, NULL, 0, 0, SSL_aGOST01 },
200
    { 0, SSL_TXT_aGOST12, NULL, 0, 0, SSL_aGOST12 },
201
    { 0, SSL_TXT_aGOST, NULL, 0, 0, SSL_aGOST01 | SSL_aGOST12 },
202
    { 0, SSL_TXT_aSRP, NULL, 0, 0, SSL_aSRP },
203
204
    /* aliases combining key exchange and server authentication */
205
    { 0, SSL_TXT_EDH, NULL, 0, SSL_kDHE, ~SSL_aNULL },
206
    { 0, SSL_TXT_DHE, NULL, 0, SSL_kDHE, ~SSL_aNULL },
207
    { 0, SSL_TXT_EECDH, NULL, 0, SSL_kECDHE, ~SSL_aNULL },
208
    { 0, SSL_TXT_ECDHE, NULL, 0, SSL_kECDHE, ~SSL_aNULL },
209
    { 0, SSL_TXT_NULL, NULL, 0, 0, 0, SSL_eNULL },
210
    { 0, SSL_TXT_RSA, NULL, 0, SSL_kRSA, SSL_aRSA },
211
    { 0, SSL_TXT_ADH, NULL, 0, SSL_kDHE, SSL_aNULL },
212
    { 0, SSL_TXT_AECDH, NULL, 0, SSL_kECDHE, SSL_aNULL },
213
    { 0, SSL_TXT_PSK, NULL, 0, SSL_PSK },
214
    { 0, SSL_TXT_SRP, NULL, 0, SSL_kSRP },
215
216
    /* symmetric encryption aliases */
217
    { 0, SSL_TXT_3DES, NULL, 0, 0, 0, SSL_3DES },
218
    { 0, SSL_TXT_RC4, NULL, 0, 0, 0, SSL_RC4 },
219
    { 0, SSL_TXT_IDEA, NULL, 0, 0, 0, SSL_IDEA },
220
    { 0, SSL_TXT_SEED, NULL, 0, 0, 0, SSL_SEED },
221
    { 0, SSL_TXT_eNULL, NULL, 0, 0, 0, SSL_eNULL },
222
    { 0, SSL_TXT_GOST, NULL, 0, 0, 0,
223
        SSL_eGOST2814789CNT | SSL_eGOST2814789CNT12 | SSL_MAGMA | SSL_KUZNYECHIK },
224
    { 0, SSL_TXT_AES128, NULL, 0, 0, 0,
225
        SSL_AES128 | SSL_AES128GCM | SSL_AES128CCM | SSL_AES128CCM8 },
226
    { 0, SSL_TXT_AES256, NULL, 0, 0, 0,
227
        SSL_AES256 | SSL_AES256GCM | SSL_AES256CCM | SSL_AES256CCM8 },
228
    { 0, SSL_TXT_AES, NULL, 0, 0, 0, SSL_AES },
229
    { 0, SSL_TXT_AES_GCM, NULL, 0, 0, 0, SSL_AES128GCM | SSL_AES256GCM },
230
    { 0, SSL_TXT_AES_CCM, NULL, 0, 0, 0,
231
        SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8 },
232
    { 0, SSL_TXT_AES_CCM_8, NULL, 0, 0, 0, SSL_AES128CCM8 | SSL_AES256CCM8 },
233
    { 0, SSL_TXT_CAMELLIA128, NULL, 0, 0, 0, SSL_CAMELLIA128 },
234
    { 0, SSL_TXT_CAMELLIA256, NULL, 0, 0, 0, SSL_CAMELLIA256 },
235
    { 0, SSL_TXT_CAMELLIA, NULL, 0, 0, 0, SSL_CAMELLIA },
236
    { 0, SSL_TXT_CHACHA20, NULL, 0, 0, 0, SSL_CHACHA20 },
237
    { 0, SSL_TXT_GOST2012_GOST8912_GOST8912, NULL, 0, 0, 0, SSL_eGOST2814789CNT12 },
238
239
    { 0, SSL_TXT_ARIA, NULL, 0, 0, 0, SSL_ARIA },
240
    { 0, SSL_TXT_ARIA_GCM, NULL, 0, 0, 0, SSL_ARIA128GCM | SSL_ARIA256GCM },
241
    { 0, SSL_TXT_ARIA128, NULL, 0, 0, 0, SSL_ARIA128GCM },
242
    { 0, SSL_TXT_ARIA256, NULL, 0, 0, 0, SSL_ARIA256GCM },
243
    { 0, SSL_TXT_CBC, NULL, 0, 0, 0, SSL_CBC },
244
245
    /* MAC aliases */
246
    { 0, SSL_TXT_MD5, NULL, 0, 0, 0, 0, SSL_MD5 },
247
    { 0, SSL_TXT_SHA1, NULL, 0, 0, 0, 0, SSL_SHA1 },
248
    { 0, SSL_TXT_SHA, NULL, 0, 0, 0, 0, SSL_SHA1 },
249
    { 0, SSL_TXT_GOST94, NULL, 0, 0, 0, 0, SSL_GOST94 },
250
    { 0, SSL_TXT_GOST89MAC, NULL, 0, 0, 0, 0, SSL_GOST89MAC | SSL_GOST89MAC12 },
251
    { 0, SSL_TXT_SHA256, NULL, 0, 0, 0, 0, SSL_SHA256 },
252
    { 0, SSL_TXT_SHA384, NULL, 0, 0, 0, 0, SSL_SHA384 },
253
    { 0, SSL_TXT_GOST12, NULL, 0, 0, 0, 0, SSL_GOST12_256 },
254
255
    /* protocol version aliases */
256
    { 0, SSL_TXT_TLSV1, NULL, 0, 0, 0, 0, 0, TLS1_VERSION },
257
    { 0, "TLSv1.0", NULL, 0, 0, 0, 0, 0, TLS1_VERSION },
258
    { 0, SSL_TXT_TLSV1_2, NULL, 0, 0, 0, 0, 0, TLS1_2_VERSION },
259
260
    /* strength classes */
261
    { 0, SSL_TXT_LOW, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_LOW },
262
    { 0, SSL_TXT_MEDIUM, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_MEDIUM },
263
    { 0, SSL_TXT_HIGH, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_HIGH },
264
265
    /* "EDH-" aliases to "DHE-" labels (for backward compatibility) */
266
    { 0, SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA, NULL, 0,
267
        SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH },
268
    { 0, SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA, NULL, 0,
269
        SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH },
270
271
};
272
273
int ssl_load_ciphers(SSL_CTX *ctx)
274
0
{
275
0
    size_t i;
276
0
    const ssl_cipher_table *t;
277
0
    EVP_KEYEXCH *kex = NULL;
278
0
    EVP_SIGNATURE *sig = NULL;
279
280
0
    ctx->disabled_enc_mask = 0;
281
0
    for (i = 0, t = ssl_cipher_table_cipher; i < SSL_ENC_NUM_IDX; i++, t++) {
282
0
        const EVP_CIPHER *cipher = NULL;
283
0
        const char *sn = NULL;
284
285
0
        if (t->mask == SSL_eNULL)
286
0
            sn = "NULL";
287
0
        else if (ossl_assert(t->nid != NID_undef))
288
0
            sn = OBJ_nid2sn(t->nid);
289
290
0
        if (sn != NULL)
291
0
            cipher = ssl_evp_cipher_fetch(ctx->libctx, sn, ctx->propq);
292
293
0
        ctx->ssl_cipher_methods[i] = cipher;
294
0
        if (cipher == NULL)
295
0
            ctx->disabled_enc_mask |= t->mask;
296
0
    }
297
0
    ctx->disabled_mac_mask = 0;
298
0
    for (i = 0, t = ssl_cipher_table_mac; i < SSL_MD_NUM_IDX; i++, t++) {
299
        /*
300
         * We ignore any errors from the fetch below. It is expected to fail
301
         * if these algorithms are not available.
302
         */
303
0
        ERR_set_mark();
304
0
        const EVP_MD *md = EVP_MD_fetch(ctx->libctx,
305
0
            OBJ_nid2sn(t->nid),
306
0
            ctx->propq);
307
0
        ERR_pop_to_mark();
308
309
0
        ctx->ssl_digest_methods[i] = md;
310
0
        if (md == NULL) {
311
0
            ctx->disabled_mac_mask |= t->mask;
312
0
        } else {
313
0
            int tmpsize = EVP_MD_get_size(md);
314
315
0
            if (!ossl_assert(tmpsize > 0))
316
0
                return 0;
317
0
            ctx->ssl_mac_secret_size[i] = tmpsize;
318
0
        }
319
0
    }
320
321
0
    ctx->disabled_mkey_mask = 0;
322
0
    ctx->disabled_auth_mask = 0;
323
324
    /*
325
     * We ignore any errors from the fetches below. They are expected to fail
326
     * if these algorithms are not available.
327
     */
328
0
    ERR_set_mark();
329
0
    sig = EVP_SIGNATURE_fetch(ctx->libctx, "DSA", ctx->propq);
330
0
    if (sig == NULL)
331
0
        ctx->disabled_auth_mask |= SSL_aDSS;
332
0
    else
333
0
        EVP_SIGNATURE_free(sig);
334
0
    kex = EVP_KEYEXCH_fetch(ctx->libctx, "DH", ctx->propq);
335
0
    if (kex == NULL)
336
0
        ctx->disabled_mkey_mask |= SSL_kDHE | SSL_kDHEPSK;
337
0
    else
338
0
        EVP_KEYEXCH_free(kex);
339
0
    kex = EVP_KEYEXCH_fetch(ctx->libctx, "ECDH", ctx->propq);
340
0
    if (kex == NULL)
341
0
        ctx->disabled_mkey_mask |= SSL_kECDHE | SSL_kECDHEPSK;
342
0
    else
343
0
        EVP_KEYEXCH_free(kex);
344
0
    sig = EVP_SIGNATURE_fetch(ctx->libctx, "ECDSA", ctx->propq);
345
0
    if (sig == NULL)
346
0
        ctx->disabled_auth_mask |= SSL_aECDSA;
347
0
    else
348
0
        EVP_SIGNATURE_free(sig);
349
0
    ERR_pop_to_mark();
350
351
#ifdef OPENSSL_NO_PSK
352
    ctx->disabled_mkey_mask |= SSL_PSK;
353
    ctx->disabled_auth_mask |= SSL_aPSK;
354
#endif
355
#ifdef OPENSSL_NO_SRP
356
    ctx->disabled_mkey_mask |= SSL_kSRP;
357
#endif
358
359
    /*
360
     * Check for presence of GOST 34.10 algorithms, and if they are not
361
     * present, disable appropriate auth and key exchange
362
     */
363
0
    memcpy(ctx->ssl_mac_pkey_id, default_mac_pkey_id,
364
0
        sizeof(ctx->ssl_mac_pkey_id));
365
366
0
    ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX] = 0;
367
0
    if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX])
368
0
        ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC_IDX] = 32;
369
0
    else
370
0
        ctx->disabled_mac_mask |= SSL_GOST89MAC;
371
372
0
    ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX] = 0;
373
0
    if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX])
374
0
        ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC12_IDX] = 32;
375
0
    else
376
0
        ctx->disabled_mac_mask |= SSL_GOST89MAC12;
377
378
0
    ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX] = 0;
379
0
    if (ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX])
380
0
        ctx->ssl_mac_secret_size[SSL_MD_MAGMAOMAC_IDX] = 32;
381
0
    else
382
0
        ctx->disabled_mac_mask |= SSL_MAGMAOMAC;
383
384
0
    ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX] = 0;
385
0
    if (ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX])
386
0
        ctx->ssl_mac_secret_size[SSL_MD_KUZNYECHIKOMAC_IDX] = 32;
387
0
    else
388
0
        ctx->disabled_mac_mask |= SSL_KUZNYECHIKOMAC;
389
390
0
    ctx->disabled_auth_mask |= SSL_aGOST01 | SSL_aGOST12;
391
0
    ctx->disabled_auth_mask |= SSL_aGOST12;
392
0
    ctx->disabled_auth_mask |= SSL_aGOST12;
393
    /*
394
     * Disable GOST key exchange if no GOST signature algs are available *
395
     */
396
0
    if ((ctx->disabled_auth_mask & (SSL_aGOST01 | SSL_aGOST12)) == (SSL_aGOST01 | SSL_aGOST12))
397
0
        ctx->disabled_mkey_mask |= SSL_kGOST;
398
399
0
    if ((ctx->disabled_auth_mask & SSL_aGOST12) == SSL_aGOST12)
400
0
        ctx->disabled_mkey_mask |= SSL_kGOST18;
401
402
0
    return 1;
403
0
}
404
405
int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc,
406
    const EVP_CIPHER **enc)
407
0
{
408
0
    int i = ssl_cipher_info_lookup(ssl_cipher_table_cipher,
409
0
        sslc->algorithm_enc);
410
411
0
    if (i == -1) {
412
0
        *enc = NULL;
413
0
    } else {
414
0
        const EVP_CIPHER *cipher = ctx->ssl_cipher_methods[i];
415
416
0
        if (cipher == NULL
417
0
            || !ssl_evp_cipher_up_ref(cipher))
418
0
            return 0;
419
0
        *enc = ctx->ssl_cipher_methods[i];
420
0
    }
421
0
    return 1;
422
0
}
423
424
int ssl_cipher_get_evp_md_mac(SSL_CTX *ctx, const SSL_CIPHER *sslc,
425
    const EVP_MD **md,
426
    int *mac_pkey_type, size_t *mac_secret_size)
427
0
{
428
0
    int i = ssl_cipher_info_lookup(ssl_cipher_table_mac, sslc->algorithm_mac);
429
430
0
    if (i == -1) {
431
0
        *md = NULL;
432
0
        if (mac_pkey_type != NULL)
433
0
            *mac_pkey_type = NID_undef;
434
0
        if (mac_secret_size != NULL)
435
0
            *mac_secret_size = 0;
436
0
    } else {
437
0
        const EVP_MD *digest = ctx->ssl_digest_methods[i];
438
439
0
        if (digest == NULL || !ssl_evp_md_up_ref(digest))
440
0
            return 0;
441
442
0
        *md = digest;
443
0
        if (mac_pkey_type != NULL)
444
0
            *mac_pkey_type = ctx->ssl_mac_pkey_id[i];
445
0
        if (mac_secret_size != NULL)
446
0
            *mac_secret_size = ctx->ssl_mac_secret_size[i];
447
0
    }
448
0
    return 1;
449
0
}
450
451
int ssl_cipher_get_evp_cipher_sn(SSL_CTX *ctx, const SSL_CIPHER *sslc,
452
    const EVP_CIPHER **enc)
453
0
{
454
0
    int i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, sslc->algorithm_enc);
455
456
0
    if (i == -1) {
457
0
        *enc = NULL;
458
0
    } else {
459
0
        const char *sn = NULL;
460
461
0
        *enc = NULL;
462
463
0
        if ((sslc->algorithm_enc & SSL_AES128_ANY) != 0)
464
0
            sn = OBJ_nid2sn(NID_aes_128_ecb);
465
0
        else if ((sslc->algorithm_enc & SSL_AES256_ANY) != 0)
466
0
            sn = OBJ_nid2sn(NID_aes_256_ecb);
467
0
        else if (sslc->algorithm_enc == SSL_eNULL)
468
0
            sn = "NULL";
469
0
        else if (ossl_assert((sslc->algorithm_enc & SSL_CHACHA20) != 0))
470
0
            sn = OBJ_nid2sn(NID_chacha20);
471
0
        else
472
0
            return 0;
473
474
0
        *enc = ssl_evp_cipher_fetch(ctx->libctx, sn, ctx->propq);
475
476
0
        if (*enc == NULL)
477
0
            return 0;
478
0
    }
479
0
    return 1;
480
0
}
481
482
int ssl_cipher_get_evp(SSL_CTX *ctx, const SSL_SESSION *s,
483
    const EVP_CIPHER **snenc,
484
    const EVP_CIPHER **enc,
485
    const EVP_MD **md,
486
    int *mac_pkey_type, size_t *mac_secret_size,
487
    SSL_COMP **comp, int use_etm)
488
0
{
489
0
    int i;
490
0
    const SSL_CIPHER *c;
491
492
0
    c = s->cipher;
493
0
    if (c == NULL)
494
0
        return 0;
495
0
    if (comp != NULL) {
496
0
        SSL_COMP ctmp;
497
0
        STACK_OF(SSL_COMP) *comp_methods;
498
499
0
        *comp = NULL;
500
0
        ctmp.id = s->compress_meth;
501
0
        comp_methods = SSL_COMP_get_compression_methods();
502
0
        if (comp_methods != NULL) {
503
0
            i = sk_SSL_COMP_find(comp_methods, &ctmp);
504
0
            if (i >= 0)
505
0
                *comp = sk_SSL_COMP_value(comp_methods, i);
506
0
        }
507
        /* If were only interested in comp then return success */
508
0
        if ((enc == NULL) && (md == NULL))
509
0
            return 1;
510
0
    }
511
512
0
    if ((enc == NULL) || (md == NULL))
513
0
        return 0;
514
515
0
    if (!ssl_cipher_get_evp_cipher(ctx, c, enc)
516
0
        || (snenc != NULL
517
0
            && !ssl_cipher_get_evp_cipher_sn(ctx, c, snenc)))
518
0
        return 0;
519
520
0
    if (!ssl_cipher_get_evp_md_mac(ctx, c, md, mac_pkey_type,
521
0
            mac_secret_size)) {
522
0
        ssl_evp_cipher_free(*enc);
523
524
0
        if (snenc != NULL)
525
0
            ssl_evp_cipher_free(*snenc);
526
527
0
        return 0;
528
0
    }
529
530
0
    if ((*enc != NULL)
531
0
        && (*md != NULL
532
0
            || (EVP_CIPHER_get_flags(*enc) & EVP_CIPH_FLAG_AEAD_CIPHER))
533
0
        && (c->algorithm_mac == SSL_AEAD
534
0
            || mac_pkey_type == NULL || *mac_pkey_type != NID_undef)) {
535
0
        const EVP_CIPHER *evp = NULL;
536
537
0
        if (use_etm
538
0
            || s->ssl_version >> 8 != TLS1_VERSION_MAJOR)
539
0
            return 1;
540
541
0
        if (c->algorithm_enc == SSL_RC4
542
0
            && c->algorithm_mac == SSL_MD5)
543
0
            evp = ssl_evp_cipher_fetch(ctx->libctx,
544
0
                "RC4-HMAC-MD5",
545
0
                ctx->propq);
546
0
        else if (c->algorithm_enc == SSL_AES128
547
0
            && c->algorithm_mac == SSL_SHA1)
548
0
            evp = ssl_evp_cipher_fetch(ctx->libctx,
549
0
                "AES-128-CBC-HMAC-SHA1",
550
0
                ctx->propq);
551
0
        else if (c->algorithm_enc == SSL_AES256
552
0
            && c->algorithm_mac == SSL_SHA1)
553
0
            evp = ssl_evp_cipher_fetch(ctx->libctx,
554
0
                "AES-256-CBC-HMAC-SHA1",
555
0
                ctx->propq);
556
0
        else if (c->algorithm_enc == SSL_AES128
557
0
            && c->algorithm_mac == SSL_SHA256)
558
0
            evp = ssl_evp_cipher_fetch(ctx->libctx,
559
0
                "AES-128-CBC-HMAC-SHA256",
560
0
                ctx->propq);
561
0
        else if (c->algorithm_enc == SSL_AES256
562
0
            && c->algorithm_mac == SSL_SHA256)
563
0
            evp = ssl_evp_cipher_fetch(ctx->libctx,
564
0
                "AES-256-CBC-HMAC-SHA256",
565
0
                ctx->propq);
566
567
0
        if (evp != NULL) {
568
0
            ssl_evp_cipher_free(*enc);
569
0
            ssl_evp_md_free(*md);
570
0
            *enc = evp;
571
0
            *md = NULL;
572
0
        }
573
0
        return 1;
574
0
    }
575
576
0
    return 0;
577
0
}
578
579
const EVP_MD *ssl_md(SSL_CTX *ctx, int idx)
580
0
{
581
0
    idx &= SSL_HANDSHAKE_MAC_MASK;
582
0
    if (idx < 0 || idx >= SSL_MD_NUM_IDX)
583
0
        return NULL;
584
0
    return ctx->ssl_digest_methods[idx];
585
0
}
586
587
const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s)
588
0
{
589
0
    return ssl_md(SSL_CONNECTION_GET_CTX(s), ssl_get_algorithm2(s));
590
0
}
591
592
const EVP_MD *ssl_prf_md(SSL_CONNECTION *s)
593
0
{
594
0
    return ssl_md(SSL_CONNECTION_GET_CTX(s),
595
0
        ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT);
596
0
}
597
598
#define ITEM_SEP(a) \
599
0
    (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))
600
601
static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
602
    CIPHER_ORDER **tail)
603
0
{
604
0
    if (curr == *tail)
605
0
        return;
606
0
    if (curr == *head)
607
0
        *head = curr->next;
608
0
    if (curr->prev != NULL)
609
0
        curr->prev->next = curr->next;
610
0
    if (curr->next != NULL)
611
0
        curr->next->prev = curr->prev;
612
0
    (*tail)->next = curr;
613
0
    curr->prev = *tail;
614
0
    curr->next = NULL;
615
0
    *tail = curr;
616
0
}
617
618
static void ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr,
619
    CIPHER_ORDER **tail)
620
0
{
621
0
    if (curr == *head)
622
0
        return;
623
0
    if (curr == *tail)
624
0
        *tail = curr->prev;
625
0
    if (curr->next != NULL)
626
0
        curr->next->prev = curr->prev;
627
0
    if (curr->prev != NULL)
628
0
        curr->prev->next = curr->next;
629
0
    (*head)->prev = curr;
630
0
    curr->next = *head;
631
0
    curr->prev = NULL;
632
0
    *head = curr;
633
0
}
634
635
static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,
636
    int num_of_ciphers,
637
    uint32_t disabled_mkey,
638
    uint32_t disabled_auth,
639
    uint32_t disabled_enc,
640
    uint32_t disabled_mac,
641
    CIPHER_ORDER *co_list,
642
    CIPHER_ORDER **head_p,
643
    CIPHER_ORDER **tail_p)
644
0
{
645
0
    int i, co_list_num;
646
0
    const SSL_CIPHER *c;
647
648
    /*
649
     * We have num_of_ciphers descriptions compiled in, depending on the
650
     * method selected (TLSv1, etc.).
651
     * These will later be sorted in a linked list with at most num
652
     * entries.
653
     */
654
655
    /* Get the initial list of ciphers */
656
0
    co_list_num = 0; /* actual count of ciphers */
657
0
    for (i = 0; i < num_of_ciphers; i++) {
658
0
        c = ssl_method->get_cipher(i);
659
        /* drop those that use any of that is not available */
660
0
        if (c == NULL || !c->valid)
661
0
            continue;
662
0
        if ((c->algorithm_mkey & disabled_mkey) || (c->algorithm_auth & disabled_auth) || (c->algorithm_enc & disabled_enc) || (c->algorithm_mac & disabled_mac))
663
0
            continue;
664
0
        if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) == 0) && c->min_tls == 0)
665
0
            continue;
666
0
        if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) != 0) && c->min_dtls == 0)
667
0
            continue;
668
669
0
        co_list[co_list_num].cipher = c;
670
0
        co_list[co_list_num].next = NULL;
671
0
        co_list[co_list_num].prev = NULL;
672
0
        co_list[co_list_num].active = 0;
673
0
        co_list_num++;
674
0
    }
675
676
    /*
677
     * Prepare linked list from list entries
678
     */
679
0
    if (co_list_num > 0) {
680
0
        co_list[0].prev = NULL;
681
682
0
        if (co_list_num > 1) {
683
0
            co_list[0].next = &co_list[1];
684
685
0
            for (i = 1; i < co_list_num - 1; i++) {
686
0
                co_list[i].prev = &co_list[i - 1];
687
0
                co_list[i].next = &co_list[i + 1];
688
0
            }
689
690
0
            co_list[co_list_num - 1].prev = &co_list[co_list_num - 2];
691
0
        }
692
693
0
        co_list[co_list_num - 1].next = NULL;
694
695
0
        *head_p = &co_list[0];
696
0
        *tail_p = &co_list[co_list_num - 1];
697
0
    }
698
0
}
699
700
static void ssl_cipher_collect_aliases(const SSL_CIPHER **ca_list,
701
    int num_of_group_aliases,
702
    uint32_t disabled_mkey,
703
    uint32_t disabled_auth,
704
    uint32_t disabled_enc,
705
    uint32_t disabled_mac,
706
    CIPHER_ORDER *head)
707
0
{
708
0
    CIPHER_ORDER *ciph_curr;
709
0
    const SSL_CIPHER **ca_curr;
710
0
    int i;
711
0
    uint32_t mask_mkey = ~disabled_mkey;
712
0
    uint32_t mask_auth = ~disabled_auth;
713
0
    uint32_t mask_enc = ~disabled_enc;
714
0
    uint32_t mask_mac = ~disabled_mac;
715
716
    /*
717
     * First, add the real ciphers as already collected
718
     */
719
0
    ciph_curr = head;
720
0
    ca_curr = ca_list;
721
0
    while (ciph_curr != NULL) {
722
0
        *ca_curr = ciph_curr->cipher;
723
0
        ca_curr++;
724
0
        ciph_curr = ciph_curr->next;
725
0
    }
726
727
    /*
728
     * Now we add the available ones from the cipher_aliases[] table.
729
     * They represent either one or more algorithms, some of which
730
     * in any affected category must be supported (set in enabled_mask),
731
     * or represent a cipher strength value (will be added in any case because algorithms=0).
732
     */
733
0
    for (i = 0; i < num_of_group_aliases; i++) {
734
0
        uint32_t algorithm_mkey = cipher_aliases[i].algorithm_mkey;
735
0
        uint32_t algorithm_auth = cipher_aliases[i].algorithm_auth;
736
0
        uint32_t algorithm_enc = cipher_aliases[i].algorithm_enc;
737
0
        uint32_t algorithm_mac = cipher_aliases[i].algorithm_mac;
738
739
0
        if (algorithm_mkey)
740
0
            if ((algorithm_mkey & mask_mkey) == 0)
741
0
                continue;
742
743
0
        if (algorithm_auth)
744
0
            if ((algorithm_auth & mask_auth) == 0)
745
0
                continue;
746
747
0
        if (algorithm_enc)
748
0
            if ((algorithm_enc & mask_enc) == 0)
749
0
                continue;
750
751
0
        if (algorithm_mac)
752
0
            if ((algorithm_mac & mask_mac) == 0)
753
0
                continue;
754
755
0
        *ca_curr = (SSL_CIPHER *)(cipher_aliases + i);
756
0
        ca_curr++;
757
0
    }
758
759
0
    *ca_curr = NULL; /* end of list */
760
0
}
761
762
static void ssl_cipher_apply_rule(uint32_t cipher_id, uint32_t alg_mkey,
763
    uint32_t alg_auth, uint32_t alg_enc,
764
    uint32_t alg_mac, int min_tls,
765
    uint32_t algo_strength, int rule,
766
    int32_t strength_bits, CIPHER_ORDER **head_p,
767
    CIPHER_ORDER **tail_p)
768
0
{
769
0
    CIPHER_ORDER *head, *tail, *curr, *next, *last;
770
0
    const SSL_CIPHER *cp;
771
0
    int reverse = 0;
772
773
0
    OSSL_TRACE_BEGIN(TLS_CIPHER)
774
0
    {
775
0
        BIO_printf(trc_out,
776
0
            "Applying rule %d with %08x/%08x/%08x/%08x/%08x %08x (%d)\n",
777
0
            rule, (unsigned int)alg_mkey, (unsigned int)alg_auth,
778
0
            (unsigned int)alg_enc, (unsigned int)alg_mac, min_tls,
779
0
            (unsigned int)algo_strength, (int)strength_bits);
780
0
    }
781
782
0
    if (rule == CIPHER_DEL || rule == CIPHER_BUMP)
783
0
        reverse = 1; /* needed to maintain sorting between currently
784
                      * deleted ciphers */
785
786
0
    head = *head_p;
787
0
    tail = *tail_p;
788
789
0
    if (reverse) {
790
0
        next = tail;
791
0
        last = head;
792
0
    } else {
793
0
        next = head;
794
0
        last = tail;
795
0
    }
796
797
0
    curr = NULL;
798
0
    for (;;) {
799
0
        if (curr == last)
800
0
            break;
801
802
0
        curr = next;
803
804
0
        if (curr == NULL)
805
0
            break;
806
807
0
        next = reverse ? curr->prev : curr->next;
808
809
0
        cp = curr->cipher;
810
811
        /*
812
         * Selection criteria is either the value of strength_bits
813
         * or the algorithms used.
814
         */
815
0
        if (strength_bits >= 0) {
816
0
            if (strength_bits != cp->strength_bits)
817
0
                continue;
818
0
        } else {
819
0
            if (trc_out != NULL) {
820
0
                BIO_printf(trc_out,
821
0
                    "\nName: %s:"
822
0
                    "\nAlgo = %08x/%08x/%08x/%08x/%08x Algo_strength = %08x\n",
823
0
                    cp->name,
824
0
                    (unsigned int)cp->algorithm_mkey,
825
0
                    (unsigned int)cp->algorithm_auth,
826
0
                    (unsigned int)cp->algorithm_enc,
827
0
                    (unsigned int)cp->algorithm_mac,
828
0
                    cp->min_tls,
829
0
                    (unsigned int)cp->algo_strength);
830
0
            }
831
0
            if (cipher_id != 0 && (cipher_id != cp->id))
832
0
                continue;
833
0
            if (alg_mkey && !(alg_mkey & cp->algorithm_mkey))
834
0
                continue;
835
0
            if (alg_auth && !(alg_auth & cp->algorithm_auth))
836
0
                continue;
837
0
            if (alg_enc && !(alg_enc & cp->algorithm_enc))
838
0
                continue;
839
0
            if (alg_mac && !(alg_mac & cp->algorithm_mac))
840
0
                continue;
841
0
            if (min_tls && (min_tls != cp->min_tls))
842
0
                continue;
843
0
            if ((algo_strength & SSL_STRONG_MASK)
844
0
                && !(algo_strength & SSL_STRONG_MASK & cp->algo_strength))
845
0
                continue;
846
0
            if ((algo_strength & SSL_DEFAULT_MASK)
847
0
                && !(algo_strength & SSL_DEFAULT_MASK & cp->algo_strength))
848
0
                continue;
849
0
        }
850
851
0
        if (trc_out != NULL)
852
0
            BIO_printf(trc_out, "Action = %d\n", rule);
853
854
        /* add the cipher if it has not been added yet. */
855
0
        if (rule == CIPHER_ADD) {
856
            /* reverse == 0 */
857
0
            if (!curr->active) {
858
0
                ll_append_tail(&head, curr, &tail);
859
0
                curr->active = 1;
860
0
            }
861
0
        }
862
        /* Move the added cipher to this location */
863
0
        else if (rule == CIPHER_ORD) {
864
            /* reverse == 0 */
865
0
            if (curr->active) {
866
0
                ll_append_tail(&head, curr, &tail);
867
0
            }
868
0
        } else if (rule == CIPHER_DEL) {
869
            /* reverse == 1 */
870
0
            if (curr->active) {
871
                /*
872
                 * most recently deleted ciphersuites get best positions for
873
                 * any future CIPHER_ADD (note that the CIPHER_DEL loop works
874
                 * in reverse to maintain the order)
875
                 */
876
0
                ll_append_head(&head, curr, &tail);
877
0
                curr->active = 0;
878
0
            }
879
0
        } else if (rule == CIPHER_BUMP) {
880
0
            if (curr->active)
881
0
                ll_append_head(&head, curr, &tail);
882
0
        } else if (rule == CIPHER_KILL) {
883
            /* reverse == 0 */
884
0
            if (head == curr)
885
0
                head = curr->next;
886
0
            else
887
0
                curr->prev->next = curr->next;
888
0
            if (tail == curr)
889
0
                tail = curr->prev;
890
0
            curr->active = 0;
891
0
            if (curr->next != NULL)
892
0
                curr->next->prev = curr->prev;
893
0
            if (curr->prev != NULL)
894
0
                curr->prev->next = curr->next;
895
0
            curr->next = NULL;
896
0
            curr->prev = NULL;
897
0
        }
898
0
    }
899
900
0
    *head_p = head;
901
0
    *tail_p = tail;
902
903
0
    OSSL_TRACE_END(TLS_CIPHER);
904
0
}
905
906
static int ssl_cipher_strength_sort(CIPHER_ORDER **head_p,
907
    CIPHER_ORDER **tail_p)
908
0
{
909
0
    int32_t max_strength_bits;
910
0
    int i, *number_uses;
911
0
    CIPHER_ORDER *curr;
912
913
    /*
914
     * This routine sorts the ciphers with descending strength. The sorting
915
     * must keep the pre-sorted sequence, so we apply the normal sorting
916
     * routine as '+' movement to the end of the list.
917
     */
918
0
    max_strength_bits = 0;
919
0
    curr = *head_p;
920
0
    while (curr != NULL) {
921
0
        if (curr->active && (curr->cipher->strength_bits > max_strength_bits))
922
0
            max_strength_bits = curr->cipher->strength_bits;
923
0
        curr = curr->next;
924
0
    }
925
926
0
    number_uses = OPENSSL_calloc(max_strength_bits + 1, sizeof(int));
927
0
    if (number_uses == NULL)
928
0
        return 0;
929
930
    /*
931
     * Now find the strength_bits values actually used
932
     */
933
0
    curr = *head_p;
934
0
    while (curr != NULL) {
935
0
        if (curr->active)
936
0
            number_uses[curr->cipher->strength_bits]++;
937
0
        curr = curr->next;
938
0
    }
939
    /*
940
     * Go through the list of used strength_bits values in descending
941
     * order.
942
     */
943
0
    for (i = max_strength_bits; i >= 0; i--)
944
0
        if (number_uses[i] > 0)
945
0
            ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ORD, i, head_p,
946
0
                tail_p);
947
948
0
    OPENSSL_free(number_uses);
949
0
    return 1;
950
0
}
951
952
static int ssl_cipher_process_rulestr(const char *rule_str,
953
    CIPHER_ORDER **head_p,
954
    CIPHER_ORDER **tail_p,
955
    const SSL_CIPHER **ca_list, CERT *c)
956
0
{
957
0
    uint32_t alg_mkey, alg_auth, alg_enc, alg_mac, algo_strength;
958
0
    int min_tls;
959
0
    const char *l, *buf;
960
0
    int j, multi, found, rule, retval, ok, buflen;
961
0
    uint32_t cipher_id = 0;
962
0
    char ch;
963
964
0
    retval = 1;
965
0
    l = rule_str;
966
0
    for (;;) {
967
0
        ch = *l;
968
969
0
        if (ch == '\0')
970
0
            break; /* done */
971
0
        if (ch == '-') {
972
0
            rule = CIPHER_DEL;
973
0
            l++;
974
0
        } else if (ch == '+') {
975
0
            rule = CIPHER_ORD;
976
0
            l++;
977
0
        } else if (ch == '!') {
978
0
            rule = CIPHER_KILL;
979
0
            l++;
980
0
        } else if (ch == '@') {
981
0
            rule = CIPHER_SPECIAL;
982
0
            l++;
983
0
        } else {
984
0
            rule = CIPHER_ADD;
985
0
        }
986
987
0
        if (ITEM_SEP(ch)) {
988
0
            l++;
989
0
            continue;
990
0
        }
991
992
0
        alg_mkey = 0;
993
0
        alg_auth = 0;
994
0
        alg_enc = 0;
995
0
        alg_mac = 0;
996
0
        min_tls = 0;
997
0
        algo_strength = 0;
998
999
0
        for (;;) {
1000
0
            ch = *l;
1001
0
            buf = l;
1002
0
            buflen = 0;
1003
0
#ifndef CHARSET_EBCDIC
1004
0
            while (((ch >= 'A') && (ch <= 'Z')) || ((ch >= '0') && (ch <= '9')) || ((ch >= 'a') && (ch <= 'z')) || (ch == '-') || (ch == '_') || (ch == '.') || (ch == '='))
1005
#else
1006
            while (isalnum((unsigned char)ch) || (ch == '-') || (ch == '_') || (ch == '.')
1007
                || (ch == '='))
1008
#endif
1009
0
            {
1010
0
                ch = *(++l);
1011
0
                buflen++;
1012
0
            }
1013
1014
0
            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
0
                ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND);
1021
0
                return 0;
1022
0
            }
1023
1024
0
            if (rule == CIPHER_SPECIAL) {
1025
0
                found = 0; /* unused -- avoid compiler warning */
1026
0
                break; /* special treatment */
1027
0
            }
1028
1029
            /* check for multi-part specification */
1030
0
            if (ch == '+') {
1031
0
                multi = 1;
1032
0
                l++;
1033
0
            } else {
1034
0
                multi = 0;
1035
0
            }
1036
1037
            /*
1038
             * Now search for the cipher alias in the ca_list. Be careful
1039
             * with the strncmp, because the "buflen" limitation
1040
             * will make the rule "ADH:SOME" and the cipher
1041
             * "ADH-MY-CIPHER" look like a match for buflen=3.
1042
             * So additionally check whether the cipher name found
1043
             * has the correct length. We can save a strlen() call:
1044
             * just checking for the '\0' at the right place is
1045
             * sufficient, we have to strncmp() anyway. (We cannot
1046
             * use strcasecmp(), because buf is not '\0' terminated.)
1047
             */
1048
0
            j = found = 0;
1049
0
            cipher_id = 0;
1050
0
            while (ca_list[j]) {
1051
0
                if (OPENSSL_strncasecmp(buf, ca_list[j]->name, buflen) == 0
1052
0
                    && (ca_list[j]->name[buflen] == '\0')) {
1053
0
                    found = 1;
1054
0
                    break;
1055
0
                } else if (ca_list[j]->stdname != NULL
1056
0
                    && OPENSSL_strncasecmp(buf, ca_list[j]->stdname, buflen) == 0
1057
0
                    && ca_list[j]->stdname[buflen] == '\0') {
1058
0
                    found = 1;
1059
0
                    break;
1060
0
                } else
1061
0
                    j++;
1062
0
            }
1063
1064
0
            if (!found)
1065
0
                break; /* ignore this entry */
1066
1067
0
            if (ca_list[j]->algorithm_mkey) {
1068
0
                if (alg_mkey) {
1069
0
                    alg_mkey &= ca_list[j]->algorithm_mkey;
1070
0
                    if (!alg_mkey) {
1071
0
                        found = 0;
1072
0
                        break;
1073
0
                    }
1074
0
                } else {
1075
0
                    alg_mkey = ca_list[j]->algorithm_mkey;
1076
0
                }
1077
0
            }
1078
1079
0
            if (ca_list[j]->algorithm_auth) {
1080
0
                if (alg_auth) {
1081
0
                    alg_auth &= ca_list[j]->algorithm_auth;
1082
0
                    if (!alg_auth) {
1083
0
                        found = 0;
1084
0
                        break;
1085
0
                    }
1086
0
                } else {
1087
0
                    alg_auth = ca_list[j]->algorithm_auth;
1088
0
                }
1089
0
            }
1090
1091
0
            if (ca_list[j]->algorithm_enc) {
1092
0
                if (alg_enc) {
1093
0
                    alg_enc &= ca_list[j]->algorithm_enc;
1094
0
                    if (!alg_enc) {
1095
0
                        found = 0;
1096
0
                        break;
1097
0
                    }
1098
0
                } else {
1099
0
                    alg_enc = ca_list[j]->algorithm_enc;
1100
0
                }
1101
0
            }
1102
1103
0
            if (ca_list[j]->algorithm_mac) {
1104
0
                if (alg_mac) {
1105
0
                    alg_mac &= ca_list[j]->algorithm_mac;
1106
0
                    if (!alg_mac) {
1107
0
                        found = 0;
1108
0
                        break;
1109
0
                    }
1110
0
                } else {
1111
0
                    alg_mac = ca_list[j]->algorithm_mac;
1112
0
                }
1113
0
            }
1114
1115
0
            if (ca_list[j]->algo_strength & SSL_STRONG_MASK) {
1116
0
                if (algo_strength & SSL_STRONG_MASK) {
1117
0
                    algo_strength &= (ca_list[j]->algo_strength & SSL_STRONG_MASK) | ~SSL_STRONG_MASK;
1118
0
                    if (!(algo_strength & SSL_STRONG_MASK)) {
1119
0
                        found = 0;
1120
0
                        break;
1121
0
                    }
1122
0
                } else {
1123
0
                    algo_strength = ca_list[j]->algo_strength & SSL_STRONG_MASK;
1124
0
                }
1125
0
            }
1126
1127
0
            if (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) {
1128
0
                if (algo_strength & SSL_DEFAULT_MASK) {
1129
0
                    algo_strength &= (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) | ~SSL_DEFAULT_MASK;
1130
0
                    if (!(algo_strength & SSL_DEFAULT_MASK)) {
1131
0
                        found = 0;
1132
0
                        break;
1133
0
                    }
1134
0
                } else {
1135
0
                    algo_strength |= ca_list[j]->algo_strength & SSL_DEFAULT_MASK;
1136
0
                }
1137
0
            }
1138
1139
0
            if (ca_list[j]->valid) {
1140
                /*
1141
                 * explicit ciphersuite found; its protocol version does not
1142
                 * become part of the search pattern!
1143
                 */
1144
1145
0
                cipher_id = ca_list[j]->id;
1146
0
            } else {
1147
                /*
1148
                 * not an explicit ciphersuite; only in this case, the
1149
                 * protocol version is considered part of the search pattern
1150
                 */
1151
1152
0
                if (ca_list[j]->min_tls) {
1153
0
                    if (min_tls != 0 && min_tls != ca_list[j]->min_tls) {
1154
0
                        found = 0;
1155
0
                        break;
1156
0
                    } else {
1157
0
                        min_tls = ca_list[j]->min_tls;
1158
0
                    }
1159
0
                }
1160
0
            }
1161
1162
0
            if (!multi)
1163
0
                break;
1164
0
        }
1165
1166
        /*
1167
         * Ok, we have the rule, now apply it
1168
         */
1169
0
        if (rule == CIPHER_SPECIAL) { /* special command */
1170
0
            ok = 0;
1171
0
            if ((buflen == 8) && HAS_CASE_PREFIX(buf, "STRENGTH")) {
1172
0
                ok = ssl_cipher_strength_sort(head_p, tail_p);
1173
0
            } else if (buflen == 10
1174
0
                && CHECK_AND_SKIP_CASE_PREFIX(buf, "SECLEVEL=")) {
1175
0
                int level = *buf - '0';
1176
0
                if (level < 0 || level > 5) {
1177
0
                    ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND);
1178
0
                } else {
1179
0
                    c->sec_level = level;
1180
0
                    ok = 1;
1181
0
                }
1182
0
            } else {
1183
0
                ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND);
1184
0
            }
1185
0
            if (ok == 0)
1186
0
                retval = 0;
1187
            /*
1188
             * We do not support any "multi" options
1189
             * together with "@", so throw away the
1190
             * rest of the command, if any left, until
1191
             * end or ':' is found.
1192
             */
1193
0
            while ((*l != '\0') && !ITEM_SEP(*l))
1194
0
                l++;
1195
0
        } else if (found) {
1196
0
            ssl_cipher_apply_rule(cipher_id,
1197
0
                alg_mkey, alg_auth, alg_enc, alg_mac,
1198
0
                min_tls, algo_strength, rule, -1, head_p,
1199
0
                tail_p);
1200
0
        } else {
1201
0
            while ((*l != '\0') && !ITEM_SEP(*l))
1202
0
                l++;
1203
0
        }
1204
0
        if (*l == '\0')
1205
0
            break; /* done */
1206
0
    }
1207
1208
0
    return retval;
1209
0
}
1210
1211
static int check_suiteb_cipher_list(const SSL_METHOD *meth, CERT *c,
1212
    const char **prule_str)
1213
0
{
1214
0
    unsigned int suiteb_flags = 0, suiteb_comb2 = 0;
1215
0
    if (HAS_CASE_PREFIX(*prule_str, "SUITEB128ONLY")) {
1216
0
        suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS_ONLY;
1217
0
    } else if (HAS_CASE_PREFIX(*prule_str, "SUITEB128C2")) {
1218
0
        suiteb_comb2 = 1;
1219
0
        suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS;
1220
0
    } else if (HAS_CASE_PREFIX(*prule_str, "SUITEB128")) {
1221
0
        suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS;
1222
0
    } else if (HAS_CASE_PREFIX(*prule_str, "SUITEB192")) {
1223
0
        suiteb_flags = SSL_CERT_FLAG_SUITEB_192_LOS;
1224
0
    }
1225
1226
0
    if (suiteb_flags) {
1227
0
        c->cert_flags &= ~SSL_CERT_FLAG_SUITEB_128_LOS;
1228
0
        c->cert_flags |= suiteb_flags;
1229
0
    } else {
1230
0
        suiteb_flags = c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS;
1231
0
    }
1232
1233
0
    if (!suiteb_flags)
1234
0
        return 1;
1235
    /* Check version: if TLS 1.2 ciphers allowed we can use Suite B */
1236
1237
0
    if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)) {
1238
0
        ERR_raise(ERR_LIB_SSL, SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE);
1239
0
        return 0;
1240
0
    }
1241
1242
0
    switch (suiteb_flags) {
1243
0
    case SSL_CERT_FLAG_SUITEB_128_LOS:
1244
0
        if (suiteb_comb2)
1245
0
            *prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384";
1246
0
        else
1247
0
            *prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384";
1248
0
        break;
1249
0
    case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
1250
0
        *prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256";
1251
0
        break;
1252
0
    case SSL_CERT_FLAG_SUITEB_192_LOS:
1253
0
        *prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384";
1254
0
        break;
1255
0
    }
1256
0
    return 1;
1257
0
}
1258
1259
static int ciphersuite_cb(const char *elem, int len, void *arg)
1260
0
{
1261
0
    STACK_OF(SSL_CIPHER) *ciphersuites = (STACK_OF(SSL_CIPHER) *)arg;
1262
0
    const SSL_CIPHER *cipher;
1263
    /* Arbitrary sized temp buffer for the cipher name. Should be big enough */
1264
0
    char name[80];
1265
1266
    /* CONF_parse_list signals empty elements with elem == NULL; skip them */
1267
0
    if (elem == NULL || len == 0)
1268
0
        return 1;
1269
1270
0
    if (len > (int)(sizeof(name) - 1))
1271
        /* Anyway return 1 so we can parse rest of the list */
1272
0
        return 1;
1273
1274
0
    memcpy(name, elem, len);
1275
0
    name[len] = '\0';
1276
1277
0
    cipher = ssl3_get_tls13_cipher_by_std_name(name);
1278
0
    if (cipher == NULL)
1279
        /* Ciphersuite not found but return 1 to parse rest of the list */
1280
0
        return 1;
1281
1282
    /* Suppress duplicates */
1283
0
    for (int i = 0; i < sk_SSL_CIPHER_num(ciphersuites); ++i)
1284
0
        if (sk_SSL_CIPHER_value(ciphersuites, i)->id == cipher->id)
1285
0
            return 1;
1286
1287
0
    if (!sk_SSL_CIPHER_push(ciphersuites, cipher)) {
1288
0
        ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
1289
0
        return 0;
1290
0
    }
1291
1292
0
    return 1;
1293
0
}
1294
1295
static __owur int set_ciphersuites(STACK_OF(SSL_CIPHER) **currciphers, const char *str)
1296
0
{
1297
0
    STACK_OF(SSL_CIPHER) *newciphers = sk_SSL_CIPHER_new_null();
1298
1299
0
    if (newciphers == NULL)
1300
0
        return 0;
1301
1302
    /* Parse the list. We explicitly allow an empty list */
1303
0
    if (*str != '\0'
1304
0
        && (CONF_parse_list(str, ':', 1, ciphersuite_cb, newciphers) <= 0
1305
0
            || sk_SSL_CIPHER_num(newciphers) == 0)) {
1306
0
        ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH);
1307
0
        sk_SSL_CIPHER_free(newciphers);
1308
0
        return 0;
1309
0
    }
1310
0
    sk_SSL_CIPHER_free(*currciphers);
1311
0
    *currciphers = newciphers;
1312
1313
0
    return 1;
1314
0
}
1315
1316
static int update_cipher_list_by_id(STACK_OF(SSL_CIPHER) **cipher_list_by_id,
1317
    STACK_OF(SSL_CIPHER) *cipherstack)
1318
0
{
1319
0
    STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack);
1320
1321
0
    if (tmp_cipher_list == NULL) {
1322
0
        return 0;
1323
0
    }
1324
1325
0
    sk_SSL_CIPHER_free(*cipher_list_by_id);
1326
0
    *cipher_list_by_id = tmp_cipher_list;
1327
1328
0
    (void)sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id, ssl_cipher_ptr_id_cmp);
1329
0
    sk_SSL_CIPHER_sort(*cipher_list_by_id);
1330
1331
0
    return 1;
1332
0
}
1333
1334
static int update_cipher_list(SSL_CTX *ctx,
1335
    STACK_OF(SSL_CIPHER) **cipher_list,
1336
    STACK_OF(SSL_CIPHER) **cipher_list_by_id,
1337
    STACK_OF(SSL_CIPHER) *tls13_ciphersuites)
1338
0
{
1339
0
    int i;
1340
0
    STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(*cipher_list);
1341
1342
0
    if (tmp_cipher_list == NULL)
1343
0
        return 0;
1344
1345
    /*
1346
     * Delete any existing (D)TLSv1.3 ciphersuites. These are always first in the
1347
     * list.
1348
     */
1349
1350
0
    while (sk_SSL_CIPHER_num(tmp_cipher_list) > 0) {
1351
0
        const SSL_CIPHER *cipher = sk_SSL_CIPHER_value(tmp_cipher_list, 0);
1352
0
        const int version1_3 = SSL_CTX_IS_DTLS(ctx) ? DTLS1_3_VERSION
1353
0
                                                    : TLS1_3_VERSION;
1354
0
        const int minversion = SSL_CTX_IS_DTLS(ctx) ? cipher->min_dtls
1355
0
                                                    : cipher->min_tls;
1356
1357
0
        if (minversion != version1_3)
1358
0
            break;
1359
0
        (void)sk_SSL_CIPHER_delete(tmp_cipher_list, 0);
1360
0
    }
1361
1362
    /* Insert the new (D)TLSv1.3 ciphersuites */
1363
0
    for (i = sk_SSL_CIPHER_num(tls13_ciphersuites) - 1; i >= 0; i--) {
1364
0
        const SSL_CIPHER *sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i);
1365
1366
        /* Don't include any TLSv1.3 ciphersuites that are disabled */
1367
0
        if ((sslc->algorithm_enc & ctx->disabled_enc_mask) == 0
1368
0
            && (ssl_cipher_table_mac[sslc->algorithm2
1369
0
                    & SSL_HANDSHAKE_MAC_MASK]
1370
0
                       .mask
1371
0
                   & ctx->disabled_mac_mask)
1372
0
                == 0) {
1373
0
            sk_SSL_CIPHER_unshift(tmp_cipher_list, sslc);
1374
0
        }
1375
0
    }
1376
1377
0
    if (!update_cipher_list_by_id(cipher_list_by_id, tmp_cipher_list)) {
1378
0
        sk_SSL_CIPHER_free(tmp_cipher_list);
1379
0
        return 0;
1380
0
    }
1381
1382
0
    sk_SSL_CIPHER_free(*cipher_list);
1383
0
    *cipher_list = tmp_cipher_list;
1384
1385
0
    return 1;
1386
0
}
1387
1388
int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str)
1389
0
{
1390
0
    int ret = set_ciphersuites(&(ctx->tls13_ciphersuites), str);
1391
1392
0
    if (ret && ctx->cipher_list != NULL)
1393
0
        return update_cipher_list(ctx, &ctx->cipher_list, &ctx->cipher_list_by_id,
1394
0
            ctx->tls13_ciphersuites);
1395
1396
0
    return ret;
1397
0
}
1398
1399
int SSL_set_ciphersuites(SSL *s, const char *str)
1400
0
{
1401
0
    STACK_OF(SSL_CIPHER) *cipher_list;
1402
0
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1403
0
    int ret;
1404
1405
0
    if (sc == NULL)
1406
0
        return 0;
1407
1408
0
    ret = set_ciphersuites(&(sc->tls13_ciphersuites), str);
1409
1410
0
    if (sc->cipher_list == NULL) {
1411
0
        if ((cipher_list = SSL_get_ciphers(s)) != NULL)
1412
0
            sc->cipher_list = sk_SSL_CIPHER_dup(cipher_list);
1413
0
    }
1414
0
    if (ret && sc->cipher_list != NULL)
1415
0
        return update_cipher_list(s->ctx, &sc->cipher_list,
1416
0
            &sc->cipher_list_by_id,
1417
0
            sc->tls13_ciphersuites);
1418
1419
0
    return ret;
1420
0
}
1421
1422
STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
1423
    STACK_OF(SSL_CIPHER) *tls13_ciphersuites,
1424
    STACK_OF(SSL_CIPHER) **cipher_list,
1425
    STACK_OF(SSL_CIPHER) **cipher_list_by_id,
1426
    const char *rule_str,
1427
    CERT *c)
1428
0
{
1429
0
    int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases, i;
1430
0
    uint32_t disabled_mkey, disabled_auth, disabled_enc, disabled_mac;
1431
0
    STACK_OF(SSL_CIPHER) *cipherstack;
1432
0
    const char *rule_p;
1433
0
    CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr;
1434
0
    const SSL_CIPHER **ca_list = NULL;
1435
0
    const SSL_METHOD *ssl_method = ctx->method;
1436
1437
    /*
1438
     * Return with error if nothing to do.
1439
     */
1440
0
    if (rule_str == NULL || cipher_list == NULL || cipher_list_by_id == NULL)
1441
0
        return NULL;
1442
1443
0
    if (!check_suiteb_cipher_list(ssl_method, c, &rule_str))
1444
0
        return NULL;
1445
1446
    /*
1447
     * To reduce the work to do we only want to process the compiled
1448
     * in algorithms, so we first get the mask of disabled ciphers.
1449
     */
1450
1451
0
    disabled_mkey = ctx->disabled_mkey_mask;
1452
0
    disabled_auth = ctx->disabled_auth_mask;
1453
0
    disabled_enc = ctx->disabled_enc_mask;
1454
0
    disabled_mac = ctx->disabled_mac_mask;
1455
1456
    /*
1457
     * Now we have to collect the available ciphers from the compiled
1458
     * in ciphers. We cannot get more than the number compiled in, so
1459
     * it is used for allocation.
1460
     */
1461
0
    num_of_ciphers = ssl_method->num_ciphers();
1462
1463
0
    if (num_of_ciphers > 0) {
1464
0
        co_list = OPENSSL_malloc_array(num_of_ciphers, sizeof(*co_list));
1465
0
        if (co_list == NULL)
1466
0
            return NULL; /* Failure */
1467
0
    }
1468
1469
0
    ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers,
1470
0
        disabled_mkey, disabled_auth, disabled_enc,
1471
0
        disabled_mac, co_list, &head, &tail);
1472
1473
    /* Now arrange all ciphers by preference. */
1474
1475
    /*
1476
     * Everything else being equal, prefer ephemeral ECDH over other key
1477
     * exchange mechanisms.
1478
     * For consistency, prefer ECDSA over RSA (though this only matters if the
1479
     * server has both certificates, and is using the DEFAULT, or a client
1480
     * preference).
1481
     */
1482
0
    ssl_cipher_apply_rule(0, SSL_kECDHE, SSL_aECDSA, 0, 0, 0, 0, CIPHER_ADD,
1483
0
        -1, &head, &tail);
1484
0
    ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head,
1485
0
        &tail);
1486
0
    ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head,
1487
0
        &tail);
1488
1489
    /* Within each strength group, we prefer GCM over CHACHA... */
1490
0
    ssl_cipher_apply_rule(0, 0, 0, SSL_AESGCM, 0, 0, 0, CIPHER_ADD, -1,
1491
0
        &head, &tail);
1492
0
    ssl_cipher_apply_rule(0, 0, 0, SSL_CHACHA20, 0, 0, 0, CIPHER_ADD, -1,
1493
0
        &head, &tail);
1494
1495
    /*
1496
     * ...and generally, our preferred cipher is AES.
1497
     * Note that AEADs will be bumped to take preference after sorting by
1498
     * strength.
1499
     */
1500
0
    ssl_cipher_apply_rule(0, 0, 0, SSL_AES ^ SSL_AESGCM, 0, 0, 0, CIPHER_ADD,
1501
0
        -1, &head, &tail);
1502
1503
    /* Temporarily enable everything else for sorting */
1504
0
    ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail);
1505
1506
    /* Low priority for MD5 */
1507
0
    ssl_cipher_apply_rule(0, 0, 0, 0, SSL_MD5, 0, 0, CIPHER_ORD, -1, &head,
1508
0
        &tail);
1509
1510
    /*
1511
     * Move anonymous ciphers to the end.  Usually, these will remain
1512
     * disabled. (For applications that allow them, they aren't too bad, but
1513
     * we prefer authenticated ciphers.)
1514
     */
1515
0
    ssl_cipher_apply_rule(0, 0, SSL_aNULL, 0, 0, 0, 0, CIPHER_ORD, -1, &head,
1516
0
        &tail);
1517
1518
0
    ssl_cipher_apply_rule(0, SSL_kRSA, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head,
1519
0
        &tail);
1520
0
    ssl_cipher_apply_rule(0, SSL_kPSK, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head,
1521
0
        &tail);
1522
1523
    /* RC4 is sort-of broken -- move to the end */
1524
0
    ssl_cipher_apply_rule(0, 0, 0, SSL_RC4, 0, 0, 0, CIPHER_ORD, -1, &head,
1525
0
        &tail);
1526
1527
    /*
1528
     * Now sort by symmetric encryption strength.  The above ordering remains
1529
     * in force within each class
1530
     */
1531
0
    if (!ssl_cipher_strength_sort(&head, &tail)) {
1532
0
        OPENSSL_free(co_list);
1533
0
        return NULL;
1534
0
    }
1535
1536
    /*
1537
     * Partially overrule strength sort to prefer TLS 1.2 ciphers/PRFs.
1538
     */
1539
0
    ssl_cipher_apply_rule(0, 0, 0, 0, 0, TLS1_2_VERSION, 0, CIPHER_BUMP, -1,
1540
0
        &head, &tail);
1541
1542
    /*
1543
     * Irrespective of strength, enforce the following order:
1544
     * (EC)DHE + AEAD > (EC)DHE > rest of AEAD > rest.
1545
     * Within each group, ciphers remain sorted by strength and previous
1546
     * preference, i.e.,
1547
     * 1) ECDHE > DHE
1548
     * 2) GCM > CHACHA
1549
     * 3) AES > rest
1550
     * 4) TLS 1.2 > legacy
1551
     *
1552
     * Because we now bump ciphers to the top of the list, we proceed in
1553
     * reverse order of preference.
1554
     */
1555
0
    ssl_cipher_apply_rule(0, 0, 0, 0, SSL_AEAD, 0, 0, CIPHER_BUMP, -1,
1556
0
        &head, &tail);
1557
0
    ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, 0, 0, 0,
1558
0
        CIPHER_BUMP, -1, &head, &tail);
1559
0
    ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, SSL_AEAD, 0, 0,
1560
0
        CIPHER_BUMP, -1, &head, &tail);
1561
1562
    /* Now disable everything (maintaining the ordering!) */
1563
0
    ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail);
1564
1565
    /*
1566
     * We also need cipher aliases for selecting based on the rule_str.
1567
     * There might be two types of entries in the rule_str: 1) names
1568
     * of ciphers themselves 2) aliases for groups of ciphers.
1569
     * For 1) we need the available ciphers and for 2) the cipher
1570
     * groups of cipher_aliases added together in one list (otherwise
1571
     * we would be happy with just the cipher_aliases table).
1572
     */
1573
0
    num_of_group_aliases = OSSL_NELEM(cipher_aliases);
1574
0
    num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;
1575
0
    ca_list = OPENSSL_malloc_array(num_of_alias_max, sizeof(*ca_list));
1576
0
    if (ca_list == NULL) {
1577
0
        OPENSSL_free(co_list);
1578
0
        return NULL; /* Failure */
1579
0
    }
1580
0
    ssl_cipher_collect_aliases(ca_list, num_of_group_aliases,
1581
0
        disabled_mkey, disabled_auth, disabled_enc,
1582
0
        disabled_mac, head);
1583
1584
    /*
1585
     * If the rule_string begins with DEFAULT, apply the default rule
1586
     * before using the (possibly available) additional rules.
1587
     */
1588
0
    ok = 1;
1589
0
    rule_p = rule_str;
1590
0
    if (HAS_CASE_PREFIX(rule_str, "DEFAULT")) {
1591
0
        ok = ssl_cipher_process_rulestr(OSSL_default_cipher_list(),
1592
0
            &head, &tail, ca_list, c);
1593
0
        rule_p += 7;
1594
0
        if (*rule_p == ':')
1595
0
            rule_p++;
1596
0
    }
1597
1598
0
    if (ok && (rule_p[0] != '\0'))
1599
0
        ok = ssl_cipher_process_rulestr(rule_p, &head, &tail, ca_list, c);
1600
1601
0
    OPENSSL_free(ca_list); /* Not needed anymore */
1602
1603
0
    if (!ok) { /* Rule processing failure */
1604
0
        OPENSSL_free(co_list);
1605
0
        return NULL;
1606
0
    }
1607
1608
    /*
1609
     * Allocate new "cipherstack" for the result, return with error
1610
     * if we cannot get one.
1611
     */
1612
0
    if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) {
1613
0
        OPENSSL_free(co_list);
1614
0
        return NULL;
1615
0
    }
1616
1617
    /* Add TLSv1.3 ciphers first - we always prefer those if possible */
1618
0
    for (i = 0; i < sk_SSL_CIPHER_num(tls13_ciphersuites); i++) {
1619
0
        const SSL_CIPHER *sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i);
1620
1621
        /* Don't include any TLSv1.3 ciphers that are disabled */
1622
0
        if ((sslc->algorithm_enc & disabled_enc) != 0
1623
0
            || (ssl_cipher_table_mac[sslc->algorithm2
1624
0
                    & SSL_HANDSHAKE_MAC_MASK]
1625
0
                       .mask
1626
0
                   & ctx->disabled_mac_mask)
1627
0
                != 0) {
1628
0
            sk_SSL_CIPHER_delete(tls13_ciphersuites, i);
1629
0
            i--;
1630
0
            continue;
1631
0
        }
1632
1633
0
        if (!sk_SSL_CIPHER_push(cipherstack, sslc)) {
1634
0
            OPENSSL_free(co_list);
1635
0
            sk_SSL_CIPHER_free(cipherstack);
1636
0
            return NULL;
1637
0
        }
1638
0
    }
1639
1640
0
    OSSL_TRACE_BEGIN(TLS_CIPHER)
1641
0
    {
1642
0
        BIO_printf(trc_out, "cipher selection:\n");
1643
0
    }
1644
    /*
1645
     * The cipher selection for the list is done. The ciphers are added
1646
     * to the resulting precedence to the STACK_OF(SSL_CIPHER).
1647
     */
1648
0
    for (curr = head; curr != NULL; curr = curr->next) {
1649
0
        if (curr->active) {
1650
0
            if (!sk_SSL_CIPHER_push(cipherstack, curr->cipher)) {
1651
0
                OPENSSL_free(co_list);
1652
0
                sk_SSL_CIPHER_free(cipherstack);
1653
0
                OSSL_TRACE_CANCEL(TLS_CIPHER);
1654
0
                return NULL;
1655
0
            }
1656
0
            if (trc_out != NULL)
1657
0
                BIO_printf(trc_out, "<%s>\n", curr->cipher->name);
1658
0
        }
1659
0
    }
1660
0
    OPENSSL_free(co_list); /* Not needed any longer */
1661
0
    OSSL_TRACE_END(TLS_CIPHER);
1662
1663
0
    if (!update_cipher_list_by_id(cipher_list_by_id, cipherstack)) {
1664
0
        sk_SSL_CIPHER_free(cipherstack);
1665
0
        return NULL;
1666
0
    }
1667
0
    sk_SSL_CIPHER_free(*cipher_list);
1668
0
    *cipher_list = cipherstack;
1669
1670
0
    return cipherstack;
1671
0
}
1672
1673
char *SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
1674
0
{
1675
0
    const char *ver;
1676
0
    const char *kx, *au, *enc, *mac;
1677
0
    uint32_t alg_mkey, alg_auth, alg_enc, alg_mac;
1678
0
    static const char *const format = "%-30s %-7s Kx=%-8s Au=%-5s Enc=%-22s Mac=%-4s\n";
1679
1680
0
    if (buf == NULL) {
1681
0
        len = 128;
1682
0
        if ((buf = OPENSSL_malloc(len)) == NULL)
1683
0
            return NULL;
1684
0
    } else if (len < 128) {
1685
0
        return NULL;
1686
0
    }
1687
1688
0
    alg_mkey = cipher->algorithm_mkey;
1689
0
    alg_auth = cipher->algorithm_auth;
1690
0
    alg_enc = cipher->algorithm_enc;
1691
0
    alg_mac = cipher->algorithm_mac;
1692
1693
0
    ver = ssl_protocol_to_string(cipher->min_tls);
1694
1695
0
    switch (alg_mkey) {
1696
0
    case SSL_kRSA:
1697
0
        kx = "RSA";
1698
0
        break;
1699
0
    case SSL_kDHE:
1700
0
        kx = "DH";
1701
0
        break;
1702
0
    case SSL_kECDHE:
1703
0
        kx = "ECDH";
1704
0
        break;
1705
0
    case SSL_kPSK:
1706
0
        kx = "PSK";
1707
0
        break;
1708
0
    case SSL_kRSAPSK:
1709
0
        kx = "RSAPSK";
1710
0
        break;
1711
0
    case SSL_kECDHEPSK:
1712
0
        kx = "ECDHEPSK";
1713
0
        break;
1714
0
    case SSL_kDHEPSK:
1715
0
        kx = "DHEPSK";
1716
0
        break;
1717
0
    case SSL_kSRP:
1718
0
        kx = "SRP";
1719
0
        break;
1720
0
    case SSL_kGOST:
1721
0
        kx = "GOST";
1722
0
        break;
1723
0
    case SSL_kGOST18:
1724
0
        kx = "GOST18";
1725
0
        break;
1726
0
    case SSL_kANY:
1727
0
        kx = "any";
1728
0
        break;
1729
0
    default:
1730
0
        kx = "unknown";
1731
0
    }
1732
1733
0
    switch (alg_auth) {
1734
0
    case SSL_aRSA:
1735
0
        au = "RSA";
1736
0
        break;
1737
0
    case SSL_aDSS:
1738
0
        au = "DSS";
1739
0
        break;
1740
0
    case SSL_aNULL:
1741
0
        au = "None";
1742
0
        break;
1743
0
    case SSL_aECDSA:
1744
0
        au = "ECDSA";
1745
0
        break;
1746
0
    case SSL_aPSK:
1747
0
        au = "PSK";
1748
0
        break;
1749
0
    case SSL_aSRP:
1750
0
        au = "SRP";
1751
0
        break;
1752
0
    case SSL_aGOST01:
1753
0
        au = "GOST01";
1754
0
        break;
1755
    /* New GOST ciphersuites have both SSL_aGOST12 and SSL_aGOST01 bits */
1756
0
    case (SSL_aGOST12 | SSL_aGOST01):
1757
0
        au = "GOST12";
1758
0
        break;
1759
0
    case SSL_aANY:
1760
0
        au = "any";
1761
0
        break;
1762
0
    default:
1763
0
        au = "unknown";
1764
0
        break;
1765
0
    }
1766
1767
0
    switch (alg_enc) {
1768
0
    case SSL_3DES:
1769
0
        enc = "3DES(168)";
1770
0
        break;
1771
0
    case SSL_RC4:
1772
0
        enc = "RC4(128)";
1773
0
        break;
1774
0
    case SSL_IDEA:
1775
0
        enc = "IDEA(128)";
1776
0
        break;
1777
0
    case SSL_eNULL:
1778
0
        enc = "None";
1779
0
        break;
1780
0
    case SSL_AES128:
1781
0
        enc = "AES(128)";
1782
0
        break;
1783
0
    case SSL_AES256:
1784
0
        enc = "AES(256)";
1785
0
        break;
1786
0
    case SSL_AES128GCM:
1787
0
        enc = "AESGCM(128)";
1788
0
        break;
1789
0
    case SSL_AES256GCM:
1790
0
        enc = "AESGCM(256)";
1791
0
        break;
1792
0
    case SSL_AES128CCM:
1793
0
        enc = "AESCCM(128)";
1794
0
        break;
1795
0
    case SSL_AES256CCM:
1796
0
        enc = "AESCCM(256)";
1797
0
        break;
1798
0
    case SSL_AES128CCM8:
1799
0
        enc = "AESCCM8(128)";
1800
0
        break;
1801
0
    case SSL_AES256CCM8:
1802
0
        enc = "AESCCM8(256)";
1803
0
        break;
1804
0
    case SSL_CAMELLIA128:
1805
0
        enc = "Camellia(128)";
1806
0
        break;
1807
0
    case SSL_CAMELLIA256:
1808
0
        enc = "Camellia(256)";
1809
0
        break;
1810
0
    case SSL_ARIA128GCM:
1811
0
        enc = "ARIAGCM(128)";
1812
0
        break;
1813
0
    case SSL_ARIA256GCM:
1814
0
        enc = "ARIAGCM(256)";
1815
0
        break;
1816
0
    case SSL_SEED:
1817
0
        enc = "SEED(128)";
1818
0
        break;
1819
0
    case SSL_eGOST2814789CNT:
1820
0
    case SSL_eGOST2814789CNT12:
1821
0
        enc = "GOST89(256)";
1822
0
        break;
1823
0
    case SSL_MAGMA:
1824
0
        enc = "MAGMA";
1825
0
        break;
1826
0
    case SSL_KUZNYECHIK:
1827
0
        enc = "KUZNYECHIK";
1828
0
        break;
1829
0
    case SSL_CHACHA20POLY1305:
1830
0
        enc = "CHACHA20/POLY1305(256)";
1831
0
        break;
1832
0
    case SSL_SM4GCM:
1833
0
        enc = "SM4GCM";
1834
0
        break;
1835
0
    case SSL_SM4CCM:
1836
0
        enc = "SM4CCM";
1837
0
        break;
1838
0
    default:
1839
0
        enc = "unknown";
1840
0
        break;
1841
0
    }
1842
1843
0
    switch (alg_mac) {
1844
0
    case SSL_MD5:
1845
0
        mac = "MD5";
1846
0
        break;
1847
0
    case SSL_SHA1:
1848
0
        mac = "SHA1";
1849
0
        break;
1850
0
    case SSL_SHA256:
1851
0
        mac = "SHA256";
1852
0
        break;
1853
0
    case SSL_SHA384:
1854
0
        mac = "SHA384";
1855
0
        break;
1856
0
    case SSL_AEAD:
1857
0
        mac = "AEAD";
1858
0
        break;
1859
0
    case SSL_GOST89MAC:
1860
0
    case SSL_GOST89MAC12:
1861
0
        mac = "GOST89";
1862
0
        break;
1863
0
    case SSL_GOST94:
1864
0
        mac = "GOST94";
1865
0
        break;
1866
0
    case SSL_GOST12_256:
1867
0
    case SSL_GOST12_512:
1868
0
        mac = "GOST2012";
1869
0
        break;
1870
0
    default:
1871
0
        mac = "unknown";
1872
0
        break;
1873
0
    }
1874
1875
0
    snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac);
1876
1877
0
    return buf;
1878
0
}
1879
1880
const char *SSL_CIPHER_get_version(const SSL_CIPHER *c)
1881
0
{
1882
0
    if (c == NULL)
1883
0
        return "(NONE)";
1884
1885
    /*
1886
     * Backwards-compatibility crutch.  In almost all contexts we report TLS
1887
     * 1.0 as "TLSv1", but for ciphers we report "TLSv1.0".
1888
     */
1889
0
    if (c->min_tls == TLS1_VERSION)
1890
0
        return "TLSv1.0";
1891
0
    return ssl_protocol_to_string(c->min_tls);
1892
0
}
1893
1894
/* return the actual cipher being used */
1895
const char *SSL_CIPHER_get_name(const SSL_CIPHER *c)
1896
0
{
1897
0
    if (c != NULL)
1898
0
        return c->name;
1899
0
    return "(NONE)";
1900
0
}
1901
1902
/* return the actual cipher being used in RFC standard name */
1903
const char *SSL_CIPHER_standard_name(const SSL_CIPHER *c)
1904
0
{
1905
0
    if (c != NULL)
1906
0
        return c->stdname;
1907
0
    return "(NONE)";
1908
0
}
1909
1910
/* return the OpenSSL name based on given RFC standard name */
1911
const char *OPENSSL_cipher_name(const char *stdname)
1912
0
{
1913
0
    const SSL_CIPHER *c;
1914
1915
0
    if (stdname == NULL)
1916
0
        return "(NONE)";
1917
0
    if ((c = ssl3_get_tls13_cipher_by_std_name(stdname)) == NULL)
1918
0
        c = ssl3_get_cipher_by_std_name(stdname);
1919
0
    return SSL_CIPHER_get_name(c);
1920
0
}
1921
1922
/* number of bits for symmetric cipher */
1923
int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits)
1924
0
{
1925
0
    int ret = 0;
1926
1927
0
    if (c != NULL) {
1928
0
        if (alg_bits != NULL)
1929
0
            *alg_bits = (int)c->alg_bits;
1930
0
        ret = (int)c->strength_bits;
1931
0
    }
1932
0
    return ret;
1933
0
}
1934
1935
uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c)
1936
0
{
1937
0
    return c->id;
1938
0
}
1939
1940
uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER *c)
1941
0
{
1942
0
    return c->id & 0xFFFF;
1943
0
}
1944
1945
SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n)
1946
0
{
1947
0
    SSL_COMP *ctmp;
1948
0
    SSL_COMP srch_key;
1949
0
    int i;
1950
1951
0
    if ((n == 0) || (sk == NULL))
1952
0
        return NULL;
1953
0
    srch_key.id = n;
1954
0
    i = sk_SSL_COMP_find(sk, &srch_key);
1955
0
    if (i >= 0)
1956
0
        ctmp = sk_SSL_COMP_value(sk, i);
1957
0
    else
1958
0
        ctmp = NULL;
1959
1960
0
    return ctmp;
1961
0
}
1962
1963
#ifdef OPENSSL_NO_COMP
1964
STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
1965
{
1966
    return NULL;
1967
}
1968
1969
STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP)
1970
        *meths)
1971
{
1972
    return meths;
1973
}
1974
1975
int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm)
1976
{
1977
    return 1;
1978
}
1979
1980
#else
1981
STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
1982
16
{
1983
16
    STACK_OF(SSL_COMP) **rv;
1984
1985
16
    rv = (STACK_OF(SSL_COMP) **)OSSL_LIB_CTX_get_data(NULL,
1986
16
        OSSL_LIB_CTX_COMP_METHODS);
1987
16
    if (rv != NULL)
1988
16
        return *rv;
1989
0
    else
1990
0
        return NULL;
1991
16
}
1992
1993
STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP)
1994
        *meths)
1995
0
{
1996
0
    STACK_OF(SSL_COMP) **comp_methods;
1997
0
    STACK_OF(SSL_COMP) *old_meths;
1998
1999
0
    comp_methods = (STACK_OF(SSL_COMP) **)OSSL_LIB_CTX_get_data(NULL,
2000
0
        OSSL_LIB_CTX_COMP_METHODS);
2001
0
    if (comp_methods == NULL) {
2002
0
        old_meths = meths;
2003
0
    } else {
2004
0
        old_meths = *comp_methods;
2005
0
        *comp_methods = meths;
2006
0
    }
2007
2008
0
    return old_meths;
2009
0
}
2010
2011
int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm)
2012
0
{
2013
0
    STACK_OF(SSL_COMP) *comp_methods;
2014
0
    SSL_COMP *comp;
2015
2016
0
    comp_methods = SSL_COMP_get_compression_methods();
2017
2018
0
    if (comp_methods == NULL)
2019
0
        return 1;
2020
2021
0
    if (cm == NULL || COMP_get_type(cm) == NID_undef)
2022
0
        return 1;
2023
2024
    /*-
2025
     * According to draft-ietf-tls-compression-04.txt, the
2026
     * compression number ranges should be the following:
2027
     *
2028
     *   0 to  63:  methods defined by the IETF
2029
     *  64 to 192:  external party methods assigned by IANA
2030
     * 193 to 255:  reserved for private use
2031
     */
2032
0
    if (id < 193 || id > 255) {
2033
0
        ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE);
2034
0
        return 1;
2035
0
    }
2036
2037
0
    comp = OPENSSL_malloc(sizeof(*comp));
2038
0
    if (comp == NULL)
2039
0
        return 1;
2040
2041
0
    comp->id = id;
2042
0
    if (sk_SSL_COMP_find(comp_methods, comp) >= 0) {
2043
0
        OPENSSL_free(comp);
2044
0
        ERR_raise(ERR_LIB_SSL, SSL_R_DUPLICATE_COMPRESSION_ID);
2045
0
        return 1;
2046
0
    }
2047
0
    if (!sk_SSL_COMP_push(comp_methods, comp)) {
2048
0
        OPENSSL_free(comp);
2049
0
        ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
2050
0
        return 1;
2051
0
    }
2052
2053
0
    return 0;
2054
0
}
2055
#endif
2056
2057
const char *SSL_COMP_get_name(const COMP_METHOD *comp)
2058
0
{
2059
0
#ifndef OPENSSL_NO_COMP
2060
0
    return comp ? COMP_get_name(comp) : NULL;
2061
#else
2062
    return NULL;
2063
#endif
2064
0
}
2065
2066
const char *SSL_COMP_get0_name(const SSL_COMP *comp)
2067
0
{
2068
0
#ifndef OPENSSL_NO_COMP
2069
0
    return comp->name;
2070
#else
2071
    return NULL;
2072
#endif
2073
0
}
2074
2075
int SSL_COMP_get_id(const SSL_COMP *comp)
2076
0
{
2077
0
#ifndef OPENSSL_NO_COMP
2078
0
    return comp->id;
2079
#else
2080
    return -1;
2081
#endif
2082
0
}
2083
2084
const SSL_CIPHER *ssl_get_cipher_by_char(SSL_CONNECTION *s,
2085
    const unsigned char *ptr,
2086
    int all)
2087
0
{
2088
0
    const SSL_CIPHER *c = SSL_CONNECTION_GET_SSL(s)->method->get_cipher_by_char(ptr);
2089
2090
0
    if (c == NULL || (!all && c->valid == 0))
2091
0
        return NULL;
2092
0
    return c;
2093
0
}
2094
2095
const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr)
2096
0
{
2097
0
    return ssl->method->get_cipher_by_char(ptr);
2098
0
}
2099
2100
int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c)
2101
0
{
2102
0
    int i;
2103
0
    if (c == NULL)
2104
0
        return NID_undef;
2105
0
    i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, c->algorithm_enc);
2106
0
    if (i == -1)
2107
0
        return NID_undef;
2108
0
    return ssl_cipher_table_cipher[i].nid;
2109
0
}
2110
2111
int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c)
2112
0
{
2113
0
    int i = ssl_cipher_info_lookup(ssl_cipher_table_mac, c->algorithm_mac);
2114
2115
0
    if (i == -1)
2116
0
        return NID_undef;
2117
0
    return ssl_cipher_table_mac[i].nid;
2118
0
}
2119
2120
int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c)
2121
0
{
2122
0
    int i = ssl_cipher_info_lookup(ssl_cipher_table_kx, c->algorithm_mkey);
2123
2124
0
    if (i == -1)
2125
0
        return NID_undef;
2126
0
    return ssl_cipher_table_kx[i].nid;
2127
0
}
2128
2129
int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c)
2130
0
{
2131
0
    int i = ssl_cipher_info_lookup(ssl_cipher_table_auth, c->algorithm_auth);
2132
2133
0
    if (i == -1)
2134
0
        return NID_undef;
2135
0
    return ssl_cipher_table_auth[i].nid;
2136
0
}
2137
2138
int ssl_get_md_idx(int md_nid)
2139
0
{
2140
0
    int i;
2141
2142
0
    for (i = 0; i < SSL_MD_NUM_IDX; i++) {
2143
0
        if (md_nid == ssl_cipher_table_mac[i].nid)
2144
0
            return i;
2145
0
    }
2146
0
    return -1;
2147
0
}
2148
2149
int ssl_cipher_get_handshake_digest_nid(const SSL_CIPHER *c)
2150
0
{
2151
0
    int idx = c->algorithm2 & SSL_HANDSHAKE_MAC_MASK;
2152
2153
0
    if (idx < 0 || idx >= SSL_MD_NUM_IDX)
2154
0
        return NID_undef;
2155
0
    return ssl_cipher_table_mac[idx].nid;
2156
0
}
2157
2158
const EVP_MD *SSL_CIPHER_get_handshake_digest(const SSL_CIPHER *c)
2159
0
{
2160
0
    int nid = ssl_cipher_get_handshake_digest_nid(c);
2161
2162
0
    if (nid == NID_undef)
2163
0
        return NULL;
2164
0
    return EVP_get_digestbynid(nid);
2165
0
}
2166
2167
int SSL_CIPHER_is_aead(const SSL_CIPHER *c)
2168
0
{
2169
0
    return (c->algorithm_mac & SSL_AEAD) ? 1 : 0;
2170
0
}
2171
2172
int ssl_cipher_get_overhead(const SSL_CIPHER *c, int version,
2173
    size_t *mac_overhead, size_t *int_overhead,
2174
    size_t *blocksize, size_t *ext_overhead)
2175
0
{
2176
0
    int mac = 0, in = 0, blk = 0, out = 0;
2177
2178
    /* Some hard-coded numbers for the CCM/Poly1305 MAC overhead
2179
     * because there are no handy #defines for those. */
2180
0
    if (c->algorithm_enc & (SSL_AESGCM | SSL_ARIAGCM)) {
2181
0
        out = EVP_GCM_TLS_TAG_LEN;
2182
        /* DTLS 1.3 uses an implicit nonce, so no explicit IV on the wire. */
2183
0
        if (version != DTLS1_3_VERSION)
2184
0
            out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
2185
0
    } else if (c->algorithm_enc & (SSL_AES128CCM | SSL_AES256CCM)) {
2186
0
        out = 16;
2187
        /* DTLS 1.3 uses an implicit nonce, so no explicit IV on the wire. */
2188
0
        if (version != DTLS1_3_VERSION)
2189
0
            out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
2190
0
    } else if (c->algorithm_enc & (SSL_AES128CCM8 | SSL_AES256CCM8)) {
2191
0
        out = 8;
2192
        /* DTLS 1.3 uses an implicit nonce, so no explicit IV on the wire. */
2193
0
        if (version != DTLS1_3_VERSION)
2194
0
            out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
2195
0
    } else if (c->algorithm_enc & SSL_CHACHA20POLY1305) {
2196
0
        out = 16;
2197
0
    } else if (c->algorithm_mac & SSL_AEAD) {
2198
        /* We're supposed to have handled all the AEAD modes above */
2199
0
        return 0;
2200
0
    } else {
2201
        /* Non-AEAD modes. Calculate MAC/cipher overhead separately */
2202
0
        int digest_nid = SSL_CIPHER_get_digest_nid(c);
2203
0
        const EVP_MD *e_md = EVP_get_digestbynid(digest_nid);
2204
2205
0
        if (e_md == NULL)
2206
0
            return 0;
2207
2208
0
        mac = EVP_MD_get_size(e_md);
2209
0
        if (mac <= 0)
2210
0
            return 0;
2211
0
        if (c->algorithm_enc != SSL_eNULL) {
2212
0
            int cipher_nid = SSL_CIPHER_get_cipher_nid(c);
2213
0
            const EVP_CIPHER *e_ciph = EVP_get_cipherbynid(cipher_nid);
2214
2215
            /* If it wasn't AEAD or SSL_eNULL, we expect it to be a
2216
               known CBC cipher. */
2217
0
            if (e_ciph == NULL || EVP_CIPHER_get_mode(e_ciph) != EVP_CIPH_CBC_MODE)
2218
0
                return 0;
2219
2220
0
            in = 1; /* padding length byte */
2221
0
            out = EVP_CIPHER_get_iv_length(e_ciph);
2222
0
            if (out < 0)
2223
0
                return 0;
2224
0
            blk = EVP_CIPHER_get_block_size(e_ciph);
2225
0
            if (blk <= 0)
2226
0
                return 0;
2227
0
        }
2228
0
    }
2229
2230
0
    *mac_overhead = (size_t)mac;
2231
0
    *int_overhead = (size_t)in;
2232
0
    *blocksize = (size_t)blk;
2233
0
    *ext_overhead = (size_t)out;
2234
2235
0
    return 1;
2236
0
}
2237
2238
int ssl_cert_is_disabled(SSL_CTX *ctx, size_t idx)
2239
0
{
2240
0
    const SSL_CERT_LOOKUP *cl;
2241
2242
    /* A provider-loaded key type is always enabled */
2243
0
    if (idx >= SSL_PKEY_NUM)
2244
0
        return 0;
2245
2246
0
    cl = ssl_cert_lookup_by_idx(idx, ctx);
2247
0
    if (cl == NULL || (cl->amask & ctx->disabled_auth_mask) != 0)
2248
0
        return 1;
2249
0
    return 0;
2250
0
}
2251
2252
/*
2253
 * Default list of TLSv1.2 (and earlier) ciphers
2254
 * SSL_DEFAULT_CIPHER_LIST deprecated in 3.0.0
2255
 * Update both macro and function simultaneously
2256
 */
2257
const char *OSSL_default_cipher_list(void)
2258
0
{
2259
0
    return "ALL:!COMPLEMENTOFDEFAULT:!eNULL";
2260
0
}
2261
2262
/*
2263
 * Default list of TLSv1.3 (and later) ciphers
2264
 * TLS_DEFAULT_CIPHERSUITES deprecated in 3.0.0
2265
 * Update both macro and function simultaneously
2266
 */
2267
const char *OSSL_default_ciphersuites(void)
2268
0
{
2269
0
    return "TLS_AES_256_GCM_SHA384:"
2270
0
           "TLS_CHACHA20_POLY1305_SHA256:"
2271
0
           "TLS_AES_128_GCM_SHA256";
2272
0
}
2273
2274
int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
2275
    WPACKET *pkt)
2276
0
{
2277
0
    int i;
2278
0
    size_t totlen = 0, len, maxlen, maxverok = 0;
2279
0
    int empty_reneg_info_scsv = !s->renegotiate
2280
0
        && !SSL_CONNECTION_IS_DTLS(s)
2281
0
        && ssl_security(s, SSL_SECOP_VERSION, 0, TLS1_VERSION, NULL)
2282
0
        && s->min_proto_version <= TLS1_VERSION;
2283
0
    SSL *ssl = SSL_CONNECTION_GET_SSL(s);
2284
2285
    /* Set disabled masks for this session */
2286
0
    if (!ssl_set_client_disabled(s)) {
2287
0
        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_PROTOCOLS_AVAILABLE);
2288
0
        return 0;
2289
0
    }
2290
2291
0
    if (sk == NULL) {
2292
0
        SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2293
0
        return 0;
2294
0
    }
2295
2296
#ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
2297
#if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6
2298
#error Max cipher length too short
2299
#endif
2300
    /*
2301
     * Some servers hang if client hello > 256 bytes as hack workaround
2302
     * chop number of supported ciphers to keep it well below this if we
2303
     * use TLS v1.2
2304
     */
2305
    if (TLS1_get_version(ssl) >= TLS1_2_VERSION)
2306
        maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
2307
    else
2308
#endif
2309
        /* Maximum length that can be stored in 2 bytes. Length must be even */
2310
0
        maxlen = 0xfffe;
2311
2312
0
    if (empty_reneg_info_scsv)
2313
0
        maxlen -= 2;
2314
0
    if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV)
2315
0
        maxlen -= 2;
2316
2317
    /* RFC 8701: prepend a GREASE cipher suite value */
2318
0
    if ((s->options & SSL_OP_GREASE) && !s->server) {
2319
0
        uint16_t grease_cs = ossl_grease_value(s, OSSL_GREASE_CIPHER);
2320
2321
0
        if (!WPACKET_put_bytes_u16(pkt, grease_cs)) {
2322
0
            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2323
0
            return 0;
2324
0
        }
2325
0
        totlen += 2;
2326
0
    }
2327
2328
0
    for (i = 0; i < sk_SSL_CIPHER_num(sk) && totlen < maxlen; i++) {
2329
0
        const SSL_CIPHER *c;
2330
2331
0
        c = sk_SSL_CIPHER_value(sk, i);
2332
        /* Skip disabled ciphers */
2333
0
        if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED))
2334
0
            continue;
2335
2336
0
        if (!ssl->method->put_cipher_by_char(c, pkt, &len)) {
2337
0
            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2338
0
            return 0;
2339
0
        }
2340
2341
        /* Sanity check that the maximum version we offer has ciphers enabled */
2342
0
        if (!maxverok) {
2343
0
            int minproto = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls;
2344
0
            int maxproto = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls;
2345
2346
0
            if (ssl_version_cmp(s, maxproto, s->s3.tmp.max_ver) >= 0
2347
0
                && ssl_version_cmp(s, minproto, s->s3.tmp.max_ver) <= 0)
2348
0
                maxverok = 1;
2349
0
        }
2350
2351
0
        totlen += len;
2352
0
    }
2353
2354
0
    if (totlen == 0 || !maxverok) {
2355
0
        const char *maxvertext = !maxverok
2356
0
            ? "No ciphers enabled for max supported SSL/TLS version"
2357
0
            : NULL;
2358
2359
0
        SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_CIPHERS_AVAILABLE,
2360
0
            maxvertext);
2361
0
        return 0;
2362
0
    }
2363
2364
0
    if (totlen != 0) {
2365
0
        if (empty_reneg_info_scsv) {
2366
0
            static const SSL_CIPHER scsv = {
2367
0
                0, NULL, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
2368
0
            };
2369
0
            if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) {
2370
0
                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2371
0
                return 0;
2372
0
            }
2373
0
        }
2374
0
        if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) {
2375
0
            static const SSL_CIPHER scsv = {
2376
0
                0, NULL, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
2377
0
            };
2378
0
            if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) {
2379
0
                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2380
0
                return 0;
2381
0
            }
2382
0
        }
2383
0
    }
2384
2385
0
    return 1;
2386
0
}