]>
Commit | Line | Data |
---|---|---|
cc110a0a | 1 | /* |
5b24990b | 2 | * Copyright 2018-2022 The OpenSSL Project Authors. All Rights Reserved. |
cc110a0a MC |
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 <openssl/evp.h> | |
11 | #include <openssl/core_names.h> | |
5b24990b | 12 | #include <openssl/rand.h> |
cc110a0a MC |
13 | #include "../../ssl_local.h" |
14 | #include "../record_local.h" | |
15 | #include "recmethod_local.h" | |
5b24990b MC |
16 | #include "internal/ktls.h" |
17 | ||
5b24990b MC |
18 | #if defined(__FreeBSD__) |
19 | # include "crypto/cryptodev.h" | |
20 | ||
7f2f0ac7 MC |
21 | /* |
22 | * TODO(RECLAYER): This is essentially a copy of ktls_int_check_supported_cipher | |
23 | * but using an SSL object instead of an OSSL_RECORD_LAYER object. Once | |
4564b47d | 24 | * the write side has been moved to the record layer this can be deleted |
5b24990b MC |
25 | */ |
26 | int ktls_check_supported_cipher(const SSL_CONNECTION *s, const EVP_CIPHER *c, | |
7f2f0ac7 | 27 | const EVP_MD *md, size_t taglen) |
5b24990b MC |
28 | { |
29 | ||
30 | switch (s->version) { | |
31 | case TLS1_VERSION: | |
32 | case TLS1_1_VERSION: | |
33 | case TLS1_2_VERSION: | |
34 | case TLS1_3_VERSION: | |
35 | break; | |
36 | default: | |
37 | return 0; | |
38 | } | |
39 | ||
7f2f0ac7 | 40 | if (EVP_CIPHER_is_a(c, "AES-128-GCM") |
1704961c | 41 | || EVP_CIPHER_is_a(c, "AES-256-GCM") |
5b24990b | 42 | # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 |
1704961c | 43 | || EVP_CIPHER_is_a(c, "CHACHA20-POLY1305") |
5b24990b | 44 | # endif |
7f2f0ac7 | 45 | ) |
1704961c | 46 | return 1; |
7f2f0ac7 MC |
47 | |
48 | if (!EVP_CIPHER_is_a(c, "AES-128-CBC") | |
49 | && !EVP_CIPHER_is_a(c, "AES-256-CBC")) | |
50 | return 0; | |
51 | ||
52 | if (s->ext.use_etm) | |
53 | return 0; | |
54 | ||
55 | if (md == NULL | |
56 | || EVP_MD_is_a(md, "SHA1") | |
57 | || EVP_MD_is_a(md, "SHA2-256") | |
58 | || EVP_MD_is_a(md, "SHA2-384")) | |
59 | return 1; | |
60 | ||
61 | return 0; | |
62 | } | |
63 | ||
64 | /*- | |
65 | * Check if a given cipher is supported by the KTLS interface. | |
66 | * The kernel might still fail the setsockopt() if no suitable | |
67 | * provider is found, but this checks if the socket option | |
68 | * supports the cipher suite used at all. | |
69 | */ | |
70 | static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl, | |
71 | const EVP_CIPHER *c, | |
72 | const EVP_MD *md, | |
73 | size_t taglen) | |
74 | { | |
75 | switch (rl->version) { | |
76 | case TLS1_VERSION: | |
77 | case TLS1_1_VERSION: | |
78 | case TLS1_2_VERSION: | |
79 | case TLS1_3_VERSION: | |
80 | break; | |
5b24990b MC |
81 | default: |
82 | return 0; | |
83 | } | |
7f2f0ac7 MC |
84 | |
85 | if (EVP_CIPHER_is_a(c, "AES-128-GCM") | |
1704961c | 86 | || EVP_CIPHER_is_a(c, "AES-256-GCM") |
7f2f0ac7 | 87 | # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 |
1704961c | 88 | || EVP_CIPHER_is_a(c, "CHACHA20-POLY1305") |
7f2f0ac7 MC |
89 | # endif |
90 | ) | |
1704961c | 91 | return 1; |
7f2f0ac7 MC |
92 | |
93 | if (!EVP_CIPHER_is_a(c, "AES-128-CBC") | |
94 | && !EVP_CIPHER_is_a(c, "AES-256-CBC")) | |
95 | return 0; | |
96 | ||
97 | if (rl->use_etm) | |
98 | return 0; | |
99 | ||
1704961c MC |
100 | if (md == NULL) |
101 | return 0; | |
102 | ||
103 | if (EVP_MD_is_a(md, "SHA1") | |
7f2f0ac7 MC |
104 | || EVP_MD_is_a(md, "SHA2-256") |
105 | || EVP_MD_is_a(md, "SHA2-384")) | |
106 | return 1; | |
107 | ||
108 | return 0; | |
5b24990b MC |
109 | } |
110 | ||
111 | /* Function to configure kernel TLS structure */ | |
8124ab56 MC |
112 | int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c, |
113 | EVP_MD *md, void *rl_sequence, | |
114 | ktls_crypto_info_t *crypto_info, int is_tx, | |
115 | unsigned char *iv, size_t ivlen, | |
5b24990b MC |
116 | unsigned char *key, size_t keylen, |
117 | unsigned char *mac_key, size_t mac_secret_size) | |
118 | { | |
119 | memset(crypto_info, 0, sizeof(*crypto_info)); | |
8124ab56 MC |
120 | if (EVP_CIPHER_is_a(c, "AES-128-GCM") |
121 | || EVP_CIPHER_is_a(c, "AES-256-GCM")) { | |
5b24990b MC |
122 | crypto_info->cipher_algorithm = CRYPTO_AES_NIST_GCM_16; |
123 | crypto_info->iv_len = ivlen; | |
8124ab56 | 124 | } else |
5b24990b | 125 | # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 |
8124ab56 | 126 | if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) { |
5b24990b MC |
127 | crypto_info->cipher_algorithm = CRYPTO_CHACHA20_POLY1305; |
128 | crypto_info->iv_len = ivlen; | |
8124ab56 | 129 | } else |
5b24990b | 130 | # endif |
8124ab56 | 131 | if (EVP_CIPHER_is_a(c, "AES-128-CBC") || EVP_CIPHER_is_a(c, "AES-256-CBC")) { |
1704961c MC |
132 | if (md == NULL) |
133 | return 0; | |
8124ab56 | 134 | if (EVP_MD_is_a(md, "SHA1")) |
5b24990b | 135 | crypto_info->auth_algorithm = CRYPTO_SHA1_HMAC; |
8124ab56 | 136 | else if (EVP_MD_is_a(md, "SHA2-256")) { |
5b24990b | 137 | crypto_info->auth_algorithm = CRYPTO_SHA2_256_HMAC; |
8124ab56 | 138 | else if (EVP_MD_is_a(md, "SHA2-384")) |
5b24990b | 139 | crypto_info->auth_algorithm = CRYPTO_SHA2_384_HMAC; |
8124ab56 | 140 | else |
5b24990b | 141 | return 0; |
5b24990b MC |
142 | crypto_info->cipher_algorithm = CRYPTO_AES_CBC; |
143 | crypto_info->iv_len = ivlen; | |
144 | crypto_info->auth_key = mac_key; | |
145 | crypto_info->auth_key_len = mac_secret_size; | |
8124ab56 | 146 | } else { |
5b24990b MC |
147 | return 0; |
148 | } | |
149 | crypto_info->cipher_key = key; | |
150 | crypto_info->cipher_key_len = keylen; | |
151 | crypto_info->iv = iv; | |
8124ab56 MC |
152 | crypto_info->tls_vmajor = (version >> 8) & 0x000000ff; |
153 | crypto_info->tls_vminor = (version & 0x000000ff); | |
5b24990b MC |
154 | # ifdef TCP_RXTLS_ENABLE |
155 | memcpy(crypto_info->rec_seq, rl_sequence, sizeof(crypto_info->rec_seq)); | |
5b24990b MC |
156 | # else |
157 | if (!is_tx) | |
158 | return 0; | |
159 | # endif | |
160 | return 1; | |
161 | }; | |
162 | ||
163 | #endif /* __FreeBSD__ */ | |
164 | ||
165 | #if defined(OPENSSL_SYS_LINUX) | |
166 | ||
7f2f0ac7 MC |
167 | /* |
168 | * TODO(RECLAYER): This is essentially a copy of ktls_int_check_supported_cipher | |
169 | * but using an SSL object instead of an OSSL_RECORD_LAYER object. Once | |
4564b47d | 170 | * the write side has been moved to the record layer this can be deleted |
7f2f0ac7 | 171 | */ |
5b24990b | 172 | int ktls_check_supported_cipher(const SSL_CONNECTION *s, const EVP_CIPHER *c, |
7f2f0ac7 | 173 | const EVP_MD *md, size_t taglen) |
5b24990b MC |
174 | { |
175 | switch (s->version) { | |
176 | case TLS1_2_VERSION: | |
177 | case TLS1_3_VERSION: | |
178 | break; | |
179 | default: | |
180 | return 0; | |
181 | } | |
182 | ||
1704961c MC |
183 | /* |
184 | * Check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128 | |
5b24990b MC |
185 | * or Chacha20-Poly1305 |
186 | */ | |
187 | # ifdef OPENSSL_KTLS_AES_CCM_128 | |
188 | if (EVP_CIPHER_is_a(c, "AES-128-CCM")) { | |
189 | if (s->version == TLS_1_3_VERSION /* broken on 5.x kernels */ | |
190 | || taglen != EVP_CCM_TLS_TAG_LEN) | |
191 | return 0; | |
192 | return 1; | |
193 | } else | |
194 | # endif | |
195 | if (0 | |
196 | # ifdef OPENSSL_KTLS_AES_GCM_128 | |
197 | || EVP_CIPHER_is_a(c, "AES-128-GCM") | |
198 | # endif | |
199 | # ifdef OPENSSL_KTLS_AES_GCM_256 | |
200 | || EVP_CIPHER_is_a(c, "AES-256-GCM") | |
201 | # endif | |
202 | # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 | |
203 | || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305") | |
204 | # endif | |
205 | ) { | |
206 | return 1; | |
207 | } | |
208 | return 0; | |
209 | } | |
210 | ||
7f2f0ac7 MC |
211 | /* Function to check supported ciphers in Linux */ |
212 | static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl, | |
213 | const EVP_CIPHER *c, | |
214 | const EVP_MD *md, | |
215 | size_t taglen) | |
216 | { | |
217 | switch (rl->version) { | |
218 | case TLS1_2_VERSION: | |
219 | case TLS1_3_VERSION: | |
220 | break; | |
221 | default: | |
222 | return 0; | |
223 | } | |
224 | ||
1704961c MC |
225 | /* |
226 | * Check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128 | |
7f2f0ac7 MC |
227 | * or Chacha20-Poly1305 |
228 | */ | |
229 | # ifdef OPENSSL_KTLS_AES_CCM_128 | |
230 | if (EVP_CIPHER_is_a(c, "AES-128-CCM")) { | |
231 | if (rl->version == TLS_1_3_VERSION /* broken on 5.x kernels */ | |
232 | || taglen != EVP_CCM_TLS_TAG_LEN) | |
233 | return 0; | |
234 | return 1; | |
235 | } else | |
236 | # endif | |
237 | if (0 | |
238 | # ifdef OPENSSL_KTLS_AES_GCM_128 | |
239 | || EVP_CIPHER_is_a(c, "AES-128-GCM") | |
240 | # endif | |
241 | # ifdef OPENSSL_KTLS_AES_GCM_256 | |
242 | || EVP_CIPHER_is_a(c, "AES-256-GCM") | |
243 | # endif | |
244 | # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 | |
245 | || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305") | |
246 | # endif | |
247 | ) { | |
248 | return 1; | |
249 | } | |
250 | return 0; | |
251 | } | |
252 | ||
5b24990b | 253 | /* Function to configure kernel TLS structure */ |
8124ab56 MC |
254 | int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c, |
255 | const EVP_MD *md, void *rl_sequence, | |
256 | ktls_crypto_info_t *crypto_info, int is_tx, | |
257 | unsigned char *iv, size_t ivlen, | |
5b24990b MC |
258 | unsigned char *key, size_t keylen, |
259 | unsigned char *mac_key, size_t mac_secret_size) | |
260 | { | |
261 | unsigned char geniv[EVP_GCM_TLS_EXPLICIT_IV_LEN]; | |
262 | unsigned char *eiv = NULL; | |
5b24990b MC |
263 | |
264 | # ifdef OPENSSL_NO_KTLS_RX | |
265 | if (!is_tx) | |
266 | return 0; | |
267 | # endif | |
268 | ||
269 | if (EVP_CIPHER_get_mode(c) == EVP_CIPH_GCM_MODE | |
270 | || EVP_CIPHER_get_mode(c) == EVP_CIPH_CCM_MODE) { | |
271 | if (!ossl_assert(EVP_GCM_TLS_FIXED_IV_LEN == EVP_CCM_TLS_FIXED_IV_LEN) | |
272 | || !ossl_assert(EVP_GCM_TLS_EXPLICIT_IV_LEN | |
273 | == EVP_CCM_TLS_EXPLICIT_IV_LEN)) | |
274 | return 0; | |
8124ab56 | 275 | if (version == TLS1_2_VERSION) { |
5b24990b MC |
276 | if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN)) |
277 | return 0; | |
278 | if (is_tx) { | |
8124ab56 | 279 | if (RAND_bytes_ex(libctx, geniv, |
5b24990b MC |
280 | EVP_GCM_TLS_EXPLICIT_IV_LEN, 0) <= 0) |
281 | return 0; | |
282 | } else { | |
283 | memset(geniv, 0, EVP_GCM_TLS_EXPLICIT_IV_LEN); | |
284 | } | |
285 | eiv = geniv; | |
286 | } else { | |
287 | if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN | |
288 | + EVP_GCM_TLS_EXPLICIT_IV_LEN)) | |
289 | return 0; | |
290 | eiv = iv + TLS_CIPHER_AES_GCM_128_SALT_SIZE; | |
291 | } | |
292 | } | |
293 | ||
294 | memset(crypto_info, 0, sizeof(*crypto_info)); | |
1704961c | 295 | switch (EVP_CIPHER_get_nid(c)) { |
5b24990b MC |
296 | # ifdef OPENSSL_KTLS_AES_GCM_128 |
297 | case NID_aes_128_gcm: | |
1704961c MC |
298 | if (!ossl_assert(TLS_CIPHER_AES_GCM_128_SALT_SIZE |
299 | == EVP_GCM_TLS_FIXED_IV_LEN) | |
300 | || !ossl_assert(TLS_CIPHER_AES_GCM_128_IV_SIZE | |
301 | == EVP_GCM_TLS_EXPLICIT_IV_LEN)) | |
5b24990b MC |
302 | return 0; |
303 | crypto_info->gcm128.info.cipher_type = TLS_CIPHER_AES_GCM_128; | |
8124ab56 | 304 | crypto_info->gcm128.info.version = version; |
5b24990b MC |
305 | crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm128); |
306 | memcpy(crypto_info->gcm128.iv, eiv, TLS_CIPHER_AES_GCM_128_IV_SIZE); | |
307 | memcpy(crypto_info->gcm128.salt, iv, TLS_CIPHER_AES_GCM_128_SALT_SIZE); | |
308 | memcpy(crypto_info->gcm128.key, key, keylen); | |
309 | memcpy(crypto_info->gcm128.rec_seq, rl_sequence, | |
310 | TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE); | |
5b24990b MC |
311 | return 1; |
312 | # endif | |
313 | # ifdef OPENSSL_KTLS_AES_GCM_256 | |
314 | case NID_aes_256_gcm: | |
1704961c MC |
315 | if (!ossl_assert(TLS_CIPHER_AES_GCM_256_SALT_SIZE |
316 | == EVP_GCM_TLS_FIXED_IV_LEN) | |
317 | || !ossl_assert(TLS_CIPHER_AES_GCM_256_IV_SIZE | |
318 | == EVP_GCM_TLS_EXPLICIT_IV_LEN)) | |
5b24990b MC |
319 | return 0; |
320 | crypto_info->gcm256.info.cipher_type = TLS_CIPHER_AES_GCM_256; | |
8124ab56 | 321 | crypto_info->gcm256.info.version = version; |
5b24990b MC |
322 | crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm256); |
323 | memcpy(crypto_info->gcm256.iv, eiv, TLS_CIPHER_AES_GCM_256_IV_SIZE); | |
324 | memcpy(crypto_info->gcm256.salt, iv, TLS_CIPHER_AES_GCM_256_SALT_SIZE); | |
325 | memcpy(crypto_info->gcm256.key, key, keylen); | |
326 | memcpy(crypto_info->gcm256.rec_seq, rl_sequence, | |
327 | TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE); | |
5b24990b MC |
328 | |
329 | return 1; | |
330 | # endif | |
331 | # ifdef OPENSSL_KTLS_AES_CCM_128 | |
332 | case NID_aes_128_ccm: | |
1704961c MC |
333 | if (!ossl_assert(TLS_CIPHER_AES_CCM_128_SALT_SIZE |
334 | == EVP_CCM_TLS_FIXED_IV_LEN) | |
335 | || !ossl_assert(TLS_CIPHER_AES_CCM_128_IV_SIZE | |
336 | == EVP_CCM_TLS_EXPLICIT_IV_LEN)) | |
5b24990b MC |
337 | return 0; |
338 | crypto_info->ccm128.info.cipher_type = TLS_CIPHER_AES_CCM_128; | |
8124ab56 | 339 | crypto_info->ccm128.info.version = version; |
5b24990b MC |
340 | crypto_info->tls_crypto_info_len = sizeof(crypto_info->ccm128); |
341 | memcpy(crypto_info->ccm128.iv, eiv, TLS_CIPHER_AES_CCM_128_IV_SIZE); | |
342 | memcpy(crypto_info->ccm128.salt, iv, TLS_CIPHER_AES_CCM_128_SALT_SIZE); | |
343 | memcpy(crypto_info->ccm128.key, key, keylen); | |
344 | memcpy(crypto_info->ccm128.rec_seq, rl_sequence, | |
345 | TLS_CIPHER_AES_CCM_128_REC_SEQ_SIZE); | |
5b24990b MC |
346 | return 1; |
347 | # endif | |
348 | # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 | |
349 | case NID_chacha20_poly1305: | |
350 | if (!ossl_assert(ivlen == TLS_CIPHER_CHACHA20_POLY1305_IV_SIZE)) | |
351 | return 0; | |
1704961c MC |
352 | crypto_info->chacha20poly1305.info.cipher_type |
353 | = TLS_CIPHER_CHACHA20_POLY1305; | |
8124ab56 | 354 | crypto_info->chacha20poly1305.info.version = version; |
5b24990b MC |
355 | crypto_info->tls_crypto_info_len = sizeof(crypto_info->chacha20poly1305); |
356 | memcpy(crypto_info->chacha20poly1305.iv, iv, ivlen); | |
357 | memcpy(crypto_info->chacha20poly1305.key, key, keylen); | |
358 | memcpy(crypto_info->chacha20poly1305.rec_seq, rl_sequence, | |
359 | TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE); | |
5b24990b MC |
360 | return 1; |
361 | # endif | |
362 | default: | |
363 | return 0; | |
364 | } | |
365 | ||
366 | } | |
367 | ||
368 | #endif /* OPENSSL_SYS_LINUX */ | |
cc110a0a | 369 | |
cc110a0a MC |
370 | static int ktls_set_crypto_state(OSSL_RECORD_LAYER *rl, int level, |
371 | unsigned char *key, size_t keylen, | |
372 | unsigned char *iv, size_t ivlen, | |
373 | unsigned char *mackey, size_t mackeylen, | |
374 | const EVP_CIPHER *ciph, | |
375 | size_t taglen, | |
cc110a0a MC |
376 | int mactype, |
377 | const EVP_MD *md, | |
1e76110b | 378 | COMP_METHOD *comp) |
cc110a0a | 379 | { |
cc110a0a MC |
380 | ktls_crypto_info_t crypto_info; |
381 | ||
7c293999 MC |
382 | /* |
383 | * Check if we are suitable for KTLS. If not suitable we return | |
384 | * OSSL_RECORD_RETURN_NON_FATAL_ERR so that other record layers can be tried | |
385 | * instead | |
386 | */ | |
cc110a0a MC |
387 | |
388 | if (comp != NULL) | |
7c293999 | 389 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; |
cc110a0a MC |
390 | |
391 | /* ktls supports only the maximum fragment size */ | |
ffbd6e67 MC |
392 | if (rl->max_frag_len > 0 && rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH) |
393 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; | |
394 | #if 0 | |
395 | /* | |
396 | * TODO(RECLAYER): We will need to reintroduce the check of the send | |
397 | * fragment for KTLS once we do the record write side implementation | |
398 | */ | |
cc110a0a | 399 | if (ssl_get_max_send_fragment(s) != SSL3_RT_MAX_PLAIN_LENGTH) |
7c293999 | 400 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; |
ffbd6e67 | 401 | #endif |
cc110a0a MC |
402 | |
403 | /* check that cipher is supported */ | |
7f2f0ac7 | 404 | if (!ktls_int_check_supported_cipher(rl, ciph, md, taglen)) |
7c293999 | 405 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; |
cc110a0a | 406 | |
cc110a0a MC |
407 | /* All future data will get encrypted by ktls. Flush the BIO or skip ktls */ |
408 | if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) { | |
eb7d6c2a MC |
409 | if (BIO_flush(rl->bio) <= 0) |
410 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; | |
411 | ||
412 | /* KTLS does not support record padding */ | |
413 | if (rl->padding != NULL || rl->block_padding > 0) | |
414 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; | |
cc110a0a MC |
415 | } |
416 | ||
8124ab56 MC |
417 | if (!ktls_configure_crypto(rl->libctx, rl->version, ciph, md, rl->sequence, |
418 | &crypto_info, | |
cc110a0a MC |
419 | rl->direction == OSSL_RECORD_DIRECTION_WRITE, |
420 | iv, ivlen, key, keylen, mackey, mackeylen)) | |
7c293999 | 421 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; |
cc110a0a MC |
422 | |
423 | if (!BIO_set_ktls(rl->bio, &crypto_info, rl->direction)) | |
7c293999 | 424 | return OSSL_RECORD_RETURN_NON_FATAL_ERR; |
cc110a0a | 425 | |
7c293999 | 426 | return OSSL_RECORD_RETURN_SUCCESS; |
cc110a0a MC |
427 | } |
428 | ||
1853d20a MC |
429 | static int ktls_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend, |
430 | int clearold, size_t *readbytes) | |
431 | { | |
432 | int ret; | |
433 | ||
434 | ret = tls_default_read_n(rl, n, max, extend, clearold, readbytes); | |
435 | ||
436 | if (ret < OSSL_RECORD_RETURN_RETRY) { | |
437 | switch (errno) { | |
438 | case EBADMSG: | |
439 | RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, | |
440 | SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); | |
441 | break; | |
442 | case EMSGSIZE: | |
443 | RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, | |
444 | SSL_R_PACKET_LENGTH_TOO_LONG); | |
445 | break; | |
446 | case EINVAL: | |
447 | RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, | |
448 | SSL_R_WRONG_VERSION_NUMBER); | |
449 | break; | |
450 | default: | |
451 | break; | |
452 | } | |
453 | } | |
454 | ||
455 | return ret; | |
456 | } | |
457 | ||
cc110a0a | 458 | static int ktls_cipher(OSSL_RECORD_LAYER *rl, SSL3_RECORD *inrecs, size_t n_recs, |
8124ab56 | 459 | int sending, SSL_MAC_BUF *mac, size_t macsize) |
cc110a0a MC |
460 | { |
461 | return 1; | |
462 | } | |
463 | ||
1853d20a MC |
464 | static int ktls_validate_record_header(OSSL_RECORD_LAYER *rl, SSL3_RECORD *rec) |
465 | { | |
466 | if (rec->rec_version != TLS1_2_VERSION) { | |
467 | RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_WRONG_VERSION_NUMBER); | |
468 | return 0; | |
469 | } | |
470 | ||
471 | return 1; | |
472 | } | |
473 | ||
8124ab56 | 474 | static int ktls_post_process_record(OSSL_RECORD_LAYER *rl, SSL3_RECORD *rec) |
1853d20a MC |
475 | { |
476 | if (rl->version == TLS1_3_VERSION) | |
8124ab56 | 477 | return tls13_common_post_process_record(rl, rec); |
1853d20a MC |
478 | |
479 | return 1; | |
480 | } | |
481 | ||
482 | static struct record_functions_st ossl_ktls_funcs = { | |
cc110a0a MC |
483 | ktls_set_crypto_state, |
484 | ktls_cipher, | |
1853d20a MC |
485 | NULL, |
486 | tls_default_set_protocol_version, | |
bafe524b MC |
487 | ktls_read_n, |
488 | tls_get_more_records, | |
1853d20a | 489 | ktls_validate_record_header, |
bafe524b MC |
490 | ktls_post_process_record, |
491 | tls_get_max_records_default, | |
492 | tls_write_records_default | |
1853d20a MC |
493 | }; |
494 | ||
495 | static int | |
496 | ktls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers, | |
279754d4 | 497 | int role, int direction, int level, uint16_t epoch, |
222cf410 MC |
498 | unsigned char *key, size_t keylen, unsigned char *iv, |
499 | size_t ivlen, unsigned char *mackey, size_t mackeylen, | |
1853d20a | 500 | const EVP_CIPHER *ciph, size_t taglen, |
1853d20a | 501 | int mactype, |
1e76110b | 502 | const EVP_MD *md, COMP_METHOD *comp, BIO *prev, |
359affde | 503 | BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer, |
1853d20a | 504 | const OSSL_PARAM *settings, const OSSL_PARAM *options, |
9dd90232 | 505 | const OSSL_DISPATCH *fns, void *cbarg, |
8124ab56 | 506 | OSSL_RECORD_LAYER **retrl) |
1853d20a MC |
507 | { |
508 | int ret; | |
509 | ||
510 | ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level, | |
511 | key, keylen, iv, ivlen, mackey, mackeylen, | |
359affde MC |
512 | ciph, taglen, mactype, md, comp, prev, |
513 | transport, next, local, peer, settings, | |
8124ab56 | 514 | options, fns, cbarg, retrl); |
1853d20a MC |
515 | |
516 | if (ret != OSSL_RECORD_RETURN_SUCCESS) | |
517 | return ret; | |
518 | ||
519 | (*retrl)->funcs = &ossl_ktls_funcs; | |
520 | ||
b5cf81f7 MC |
521 | /* |
522 | * TODO(RECLAYER): We're not ready to set the crypto state for the write | |
1e76110b | 523 | * record layer in TLSv1.3. Fix this once we are |
b5cf81f7 | 524 | */ |
1e76110b | 525 | if (direction == OSSL_RECORD_DIRECTION_WRITE && vers == TLS1_3_VERSION) |
b5cf81f7 | 526 | return 1; |
1e76110b | 527 | |
1853d20a MC |
528 | ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv, |
529 | ivlen, mackey, mackeylen, ciph, | |
8124ab56 | 530 | taglen, mactype, md, comp); |
1853d20a MC |
531 | |
532 | if (ret != OSSL_RECORD_RETURN_SUCCESS) { | |
533 | OPENSSL_free(*retrl); | |
534 | *retrl = NULL; | |
535 | } else { | |
536 | /* | |
537 | * With KTLS we always try and read as much as possible and fill the | |
538 | * buffer | |
539 | */ | |
540 | (*retrl)->read_ahead = 1; | |
541 | } | |
542 | return ret; | |
543 | } | |
544 | ||
545 | const OSSL_RECORD_METHOD ossl_ktls_record_method = { | |
546 | ktls_new_record_layer, | |
547 | tls_free, | |
548 | tls_reset, | |
549 | tls_unprocessed_read_pending, | |
550 | tls_processed_read_pending, | |
551 | tls_app_data_pending, | |
552 | tls_write_pending, | |
553 | tls_get_max_record_len, | |
554 | tls_get_max_records, | |
555 | tls_write_records, | |
2b71b042 | 556 | tls_retry_write_records, |
1853d20a MC |
557 | tls_read_record, |
558 | tls_release_record, | |
559 | tls_get_alert_code, | |
560 | tls_set1_bio, | |
561 | tls_set_protocol_version, | |
562 | tls_set_plain_alerts, | |
563 | tls_set_first_handshake, | |
8124ab56 | 564 | tls_set_max_pipelines, |
d0b17ea0 | 565 | NULL, |
4566dae7 | 566 | tls_get_state, |
1e76110b MC |
567 | tls_set_options, |
568 | tls_get_compression | |
cc110a0a | 569 | }; |