1 /*
2 * Copyright 2018-2022 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 #include "ssl_local.h"
11 #include "internal/ktls.h"
12
13 #if defined(__FreeBSD__)
14 # include "crypto/cryptodev.h"
15
16 /*-
17 * Check if a given cipher is supported by the KTLS interface.
18 * The kernel might still fail the setsockopt() if no suitable
19 * provider is found, but this checks if the socket option
20 * supports the cipher suite used at all.
21 */
ktls_check_supported_cipher(const SSL * s,const EVP_CIPHER * c,const EVP_CIPHER_CTX * dd)22 int ktls_check_supported_cipher(const SSL *s, const EVP_CIPHER *c,
23 const EVP_CIPHER_CTX *dd)
24 {
25
26 switch (s->version) {
27 case TLS1_VERSION:
28 case TLS1_1_VERSION:
29 case TLS1_2_VERSION:
30 case TLS1_3_VERSION:
31 break;
32 default:
33 return 0;
34 }
35
36 switch (s->s3.tmp.new_cipher->algorithm_enc) {
37 case SSL_AES128GCM:
38 case SSL_AES256GCM:
39 return 1;
40 case SSL_AES128:
41 case SSL_AES256:
42 if (s->ext.use_etm)
43 return 0;
44 switch (s->s3.tmp.new_cipher->algorithm_mac) {
45 case SSL_SHA1:
46 case SSL_SHA256:
47 case SSL_SHA384:
48 return 1;
49 default:
50 return 0;
51 }
52 default:
53 return 0;
54 }
55 }
56
57 /* Function to configure kernel TLS structure */
ktls_configure_crypto(const SSL * s,const EVP_CIPHER * c,EVP_CIPHER_CTX * dd,void * rl_sequence,ktls_crypto_info_t * crypto_info,unsigned char ** rec_seq,unsigned char * iv,unsigned char * key,unsigned char * mac_key,size_t mac_secret_size)58 int ktls_configure_crypto(const SSL *s, const EVP_CIPHER *c, EVP_CIPHER_CTX *dd,
59 void *rl_sequence, ktls_crypto_info_t *crypto_info,
60 unsigned char **rec_seq, unsigned char *iv,
61 unsigned char *key, unsigned char *mac_key,
62 size_t mac_secret_size)
63 {
64 memset(crypto_info, 0, sizeof(*crypto_info));
65 switch (s->s3.tmp.new_cipher->algorithm_enc) {
66 case SSL_AES128GCM:
67 case SSL_AES256GCM:
68 crypto_info->cipher_algorithm = CRYPTO_AES_NIST_GCM_16;
69 if (s->version == TLS1_3_VERSION) {
70 crypto_info->iv_len = EVP_CIPHER_CTX_get_iv_length(dd);
71 if (crypto_info->iv_len < 0)
72 return 0;
73 }
74 else
75 crypto_info->iv_len = EVP_GCM_TLS_FIXED_IV_LEN;
76 break;
77 case SSL_AES128:
78 case SSL_AES256:
79 switch (s->s3.tmp.new_cipher->algorithm_mac) {
80 case SSL_SHA1:
81 crypto_info->auth_algorithm = CRYPTO_SHA1_HMAC;
82 break;
83 case SSL_SHA256:
84 crypto_info->auth_algorithm = CRYPTO_SHA2_256_HMAC;
85 break;
86 case SSL_SHA384:
87 crypto_info->auth_algorithm = CRYPTO_SHA2_384_HMAC;
88 break;
89 default:
90 return 0;
91 }
92 crypto_info->cipher_algorithm = CRYPTO_AES_CBC;
93 crypto_info->iv_len = EVP_CIPHER_get_iv_length(c);
94 crypto_info->auth_key = mac_key;
95 crypto_info->auth_key_len = mac_secret_size;
96 break;
97 default:
98 return 0;
99 }
100 crypto_info->cipher_key = key;
101 crypto_info->cipher_key_len = EVP_CIPHER_get_key_length(c);
102 crypto_info->iv = iv;
103 crypto_info->tls_vmajor = (s->version >> 8) & 0x000000ff;
104 crypto_info->tls_vminor = (s->version & 0x000000ff);
105 # ifdef TCP_RXTLS_ENABLE
106 memcpy(crypto_info->rec_seq, rl_sequence, sizeof(crypto_info->rec_seq));
107 if (rec_seq != NULL)
108 *rec_seq = crypto_info->rec_seq;
109 # else
110 if (rec_seq != NULL)
111 *rec_seq = NULL;
112 # endif
113 return 1;
114 };
115
116 #endif /* __FreeBSD__ */
117
118 #if defined(OPENSSL_SYS_LINUX)
119
120 /* Function to check supported ciphers in Linux */
ktls_check_supported_cipher(const SSL * s,const EVP_CIPHER * c,const EVP_CIPHER_CTX * dd)121 int ktls_check_supported_cipher(const SSL *s, const EVP_CIPHER *c,
122 const EVP_CIPHER_CTX *dd)
123 {
124 switch (s->version) {
125 case TLS1_2_VERSION:
126 case TLS1_3_VERSION:
127 break;
128 default:
129 return 0;
130 }
131
132 /* check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128
133 * or Chacha20-Poly1305
134 */
135 # ifdef OPENSSL_KTLS_AES_CCM_128
136 if (EVP_CIPHER_is_a(c, "AES-128-CCM")) {
137 if (s->version == TLS_1_3_VERSION /* broken on 5.x kernels */
138 || EVP_CIPHER_CTX_get_tag_length(dd) != EVP_CCM_TLS_TAG_LEN)
139 return 0;
140 return 1;
141 } else
142 # endif
143 if (0
144 # ifdef OPENSSL_KTLS_AES_GCM_128
145 || EVP_CIPHER_is_a(c, "AES-128-GCM")
146 # endif
147 # ifdef OPENSSL_KTLS_AES_GCM_256
148 || EVP_CIPHER_is_a(c, "AES-256-GCM")
149 # endif
150 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
151 || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305")
152 # endif
153 ) {
154 return 1;
155 }
156 return 0;
157 }
158
159 /* Function to configure kernel TLS structure */
ktls_configure_crypto(const SSL * s,const EVP_CIPHER * c,EVP_CIPHER_CTX * dd,void * rl_sequence,ktls_crypto_info_t * crypto_info,unsigned char ** rec_seq,unsigned char * iv,unsigned char * key,unsigned char * mac_key,size_t mac_secret_size)160 int ktls_configure_crypto(const SSL *s, const EVP_CIPHER *c, EVP_CIPHER_CTX *dd,
161 void *rl_sequence, ktls_crypto_info_t *crypto_info,
162 unsigned char **rec_seq, unsigned char *iv,
163 unsigned char *key, unsigned char *mac_key,
164 size_t mac_secret_size)
165 {
166 unsigned char geniv[12];
167 unsigned char *iiv = iv;
168
169 if (s->version == TLS1_2_VERSION &&
170 EVP_CIPHER_get_mode(c) == EVP_CIPH_GCM_MODE) {
171 if (!EVP_CIPHER_CTX_get_updated_iv(dd, geniv,
172 EVP_GCM_TLS_FIXED_IV_LEN
173 + EVP_GCM_TLS_EXPLICIT_IV_LEN))
174 return 0;
175 iiv = geniv;
176 }
177
178 memset(crypto_info, 0, sizeof(*crypto_info));
179 switch (EVP_CIPHER_get_nid(c))
180 {
181 # ifdef OPENSSL_KTLS_AES_GCM_128
182 case NID_aes_128_gcm:
183 crypto_info->gcm128.info.cipher_type = TLS_CIPHER_AES_GCM_128;
184 crypto_info->gcm128.info.version = s->version;
185 crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm128);
186 memcpy(crypto_info->gcm128.iv, iiv + EVP_GCM_TLS_FIXED_IV_LEN,
187 TLS_CIPHER_AES_GCM_128_IV_SIZE);
188 memcpy(crypto_info->gcm128.salt, iiv, TLS_CIPHER_AES_GCM_128_SALT_SIZE);
189 memcpy(crypto_info->gcm128.key, key, EVP_CIPHER_get_key_length(c));
190 memcpy(crypto_info->gcm128.rec_seq, rl_sequence,
191 TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE);
192 if (rec_seq != NULL)
193 *rec_seq = crypto_info->gcm128.rec_seq;
194 return 1;
195 # endif
196 # ifdef OPENSSL_KTLS_AES_GCM_256
197 case NID_aes_256_gcm:
198 crypto_info->gcm256.info.cipher_type = TLS_CIPHER_AES_GCM_256;
199 crypto_info->gcm256.info.version = s->version;
200 crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm256);
201 memcpy(crypto_info->gcm256.iv, iiv + EVP_GCM_TLS_FIXED_IV_LEN,
202 TLS_CIPHER_AES_GCM_256_IV_SIZE);
203 memcpy(crypto_info->gcm256.salt, iiv, TLS_CIPHER_AES_GCM_256_SALT_SIZE);
204 memcpy(crypto_info->gcm256.key, key, EVP_CIPHER_get_key_length(c));
205 memcpy(crypto_info->gcm256.rec_seq, rl_sequence,
206 TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE);
207 if (rec_seq != NULL)
208 *rec_seq = crypto_info->gcm256.rec_seq;
209 return 1;
210 # endif
211 # ifdef OPENSSL_KTLS_AES_CCM_128
212 case NID_aes_128_ccm:
213 crypto_info->ccm128.info.cipher_type = TLS_CIPHER_AES_CCM_128;
214 crypto_info->ccm128.info.version = s->version;
215 crypto_info->tls_crypto_info_len = sizeof(crypto_info->ccm128);
216 memcpy(crypto_info->ccm128.iv, iiv + EVP_CCM_TLS_FIXED_IV_LEN,
217 TLS_CIPHER_AES_CCM_128_IV_SIZE);
218 memcpy(crypto_info->ccm128.salt, iiv, TLS_CIPHER_AES_CCM_128_SALT_SIZE);
219 memcpy(crypto_info->ccm128.key, key, EVP_CIPHER_get_key_length(c));
220 memcpy(crypto_info->ccm128.rec_seq, rl_sequence,
221 TLS_CIPHER_AES_CCM_128_REC_SEQ_SIZE);
222 if (rec_seq != NULL)
223 *rec_seq = crypto_info->ccm128.rec_seq;
224 return 1;
225 # endif
226 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
227 case NID_chacha20_poly1305:
228 crypto_info->chacha20poly1305.info.cipher_type = TLS_CIPHER_CHACHA20_POLY1305;
229 crypto_info->chacha20poly1305.info.version = s->version;
230 crypto_info->tls_crypto_info_len = sizeof(crypto_info->chacha20poly1305);
231 memcpy(crypto_info->chacha20poly1305.iv, iiv,
232 TLS_CIPHER_CHACHA20_POLY1305_IV_SIZE);
233 memcpy(crypto_info->chacha20poly1305.key, key,
234 EVP_CIPHER_get_key_length(c));
235 memcpy(crypto_info->chacha20poly1305.rec_seq, rl_sequence,
236 TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE);
237 if (rec_seq != NULL)
238 *rec_seq = crypto_info->chacha20poly1305.rec_seq;
239 return 1;
240 # endif
241 default:
242 return 0;
243 }
244
245 }
246
247 #endif /* OPENSSL_SYS_LINUX */
248