2 * Copyright 2018-2022 The OpenSSL Project Authors. All Rights Reserved.
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
10 #include <openssl/evp.h>
11 #include <openssl/core_names.h>
12 #include <openssl/rand.h>
13 #include "../../ssl_local.h"
14 #include "../record_local.h"
15 #include "recmethod_local.h"
16 #include "internal/ktls.h"
18 #if defined(__FreeBSD__)
19 # include "crypto/cryptodev.h"
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
24 * the write side has been moved to the record layer this can be deleted
26 int ktls_check_supported_cipher(const SSL_CONNECTION *s, const EVP_CIPHER *c,
27 const EVP_MD *md, size_t taglen)
40 if (EVP_CIPHER_is_a(c, "AES-128-GCM")
41 || EVP_CIPHER_is_a(c, "AES-256-GCM")
42 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
43 || EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")
48 if (!EVP_CIPHER_is_a(c, "AES-128-CBC")
49 && !EVP_CIPHER_is_a(c, "AES-256-CBC"))
56 || EVP_MD_is_a(md, "SHA1")
57 || EVP_MD_is_a(md, "SHA2-256")
58 || EVP_MD_is_a(md, "SHA2-384"))
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.
70 static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
75 switch (rl->version) {
85 if (EVP_CIPHER_is_a(c, "AES-128-GCM")
86 || EVP_CIPHER_is_a(c, "AES-256-GCM")
87 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
88 || EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")
93 if (!EVP_CIPHER_is_a(c, "AES-128-CBC")
94 && !EVP_CIPHER_is_a(c, "AES-256-CBC"))
103 if (EVP_MD_is_a(md, "SHA1")
104 || EVP_MD_is_a(md, "SHA2-256")
105 || EVP_MD_is_a(md, "SHA2-384"))
111 /* Function to configure kernel TLS structure */
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,
116 unsigned char *key, size_t keylen,
117 unsigned char *mac_key, size_t mac_secret_size)
119 memset(crypto_info, 0, sizeof(*crypto_info));
120 if (EVP_CIPHER_is_a(c, "AES-128-GCM")
121 || EVP_CIPHER_is_a(c, "AES-256-GCM")) {
122 crypto_info->cipher_algorithm = CRYPTO_AES_NIST_GCM_16;
123 crypto_info->iv_len = ivlen;
125 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
126 if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) {
127 crypto_info->cipher_algorithm = CRYPTO_CHACHA20_POLY1305;
128 crypto_info->iv_len = ivlen;
131 if (EVP_CIPHER_is_a(c, "AES-128-CBC") || EVP_CIPHER_is_a(c, "AES-256-CBC")) {
134 if (EVP_MD_is_a(md, "SHA1"))
135 crypto_info->auth_algorithm = CRYPTO_SHA1_HMAC;
136 else if (EVP_MD_is_a(md, "SHA2-256")) {
137 crypto_info->auth_algorithm = CRYPTO_SHA2_256_HMAC;
138 else if (EVP_MD_is_a(md, "SHA2-384"))
139 crypto_info->auth_algorithm = CRYPTO_SHA2_384_HMAC;
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;
149 crypto_info->cipher_key = key;
150 crypto_info->cipher_key_len = keylen;
151 crypto_info->iv = iv;
152 crypto_info->tls_vmajor = (version >> 8) & 0x000000ff;
153 crypto_info->tls_vminor = (version & 0x000000ff);
154 # ifdef TCP_RXTLS_ENABLE
155 memcpy(crypto_info->rec_seq, rl_sequence, sizeof(crypto_info->rec_seq));
163 #endif /* __FreeBSD__ */
165 #if defined(OPENSSL_SYS_LINUX)
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
170 * the write side has been moved to the record layer this can be deleted
172 int ktls_check_supported_cipher(const SSL_CONNECTION *s, const EVP_CIPHER *c,
173 const EVP_MD *md, size_t taglen)
175 switch (s->version) {
184 * Check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128
185 * or Chacha20-Poly1305
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)
196 # ifdef OPENSSL_KTLS_AES_GCM_128
197 || EVP_CIPHER_is_a(c, "AES-128-GCM")
199 # ifdef OPENSSL_KTLS_AES_GCM_256
200 || EVP_CIPHER_is_a(c, "AES-256-GCM")
202 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
203 || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305")
211 /* Function to check supported ciphers in Linux */
212 static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
217 switch (rl->version) {
226 * Check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128
227 * or Chacha20-Poly1305
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)
238 # ifdef OPENSSL_KTLS_AES_GCM_128
239 || EVP_CIPHER_is_a(c, "AES-128-GCM")
241 # ifdef OPENSSL_KTLS_AES_GCM_256
242 || EVP_CIPHER_is_a(c, "AES-256-GCM")
244 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
245 || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305")
253 /* Function to configure kernel TLS structure */
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,
258 unsigned char *key, size_t keylen,
259 unsigned char *mac_key, size_t mac_secret_size)
261 unsigned char geniv[EVP_GCM_TLS_EXPLICIT_IV_LEN];
262 unsigned char *eiv = NULL;
264 # ifdef OPENSSL_NO_KTLS_RX
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))
275 if (version == TLS1_2_VERSION) {
276 if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN))
279 if (RAND_bytes_ex(libctx, geniv,
280 EVP_GCM_TLS_EXPLICIT_IV_LEN, 0) <= 0)
283 memset(geniv, 0, EVP_GCM_TLS_EXPLICIT_IV_LEN);
287 if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN
288 + EVP_GCM_TLS_EXPLICIT_IV_LEN))
290 eiv = iv + TLS_CIPHER_AES_GCM_128_SALT_SIZE;
294 memset(crypto_info, 0, sizeof(*crypto_info));
295 switch (EVP_CIPHER_get_nid(c)) {
296 # ifdef OPENSSL_KTLS_AES_GCM_128
297 case NID_aes_128_gcm:
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))
303 crypto_info->gcm128.info.cipher_type = TLS_CIPHER_AES_GCM_128;
304 crypto_info->gcm128.info.version = version;
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);
313 # ifdef OPENSSL_KTLS_AES_GCM_256
314 case NID_aes_256_gcm:
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))
320 crypto_info->gcm256.info.cipher_type = TLS_CIPHER_AES_GCM_256;
321 crypto_info->gcm256.info.version = version;
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);
331 # ifdef OPENSSL_KTLS_AES_CCM_128
332 case NID_aes_128_ccm:
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))
338 crypto_info->ccm128.info.cipher_type = TLS_CIPHER_AES_CCM_128;
339 crypto_info->ccm128.info.version = version;
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);
348 # ifdef OPENSSL_KTLS_CHACHA20_POLY1305
349 case NID_chacha20_poly1305:
350 if (!ossl_assert(ivlen == TLS_CIPHER_CHACHA20_POLY1305_IV_SIZE))
352 crypto_info->chacha20poly1305.info.cipher_type
353 = TLS_CIPHER_CHACHA20_POLY1305;
354 crypto_info->chacha20poly1305.info.version = version;
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);
368 #endif /* OPENSSL_SYS_LINUX */
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,
378 const SSL_COMP *comp)
380 ktls_crypto_info_t crypto_info;
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
389 return OSSL_RECORD_RETURN_NON_FATAL_ERR;
391 /* ktls supports only the maximum fragment size */
392 if (rl->max_frag_len > 0 && rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH)
393 return OSSL_RECORD_RETURN_NON_FATAL_ERR;
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
399 if (ssl_get_max_send_fragment(s) != SSL3_RT_MAX_PLAIN_LENGTH)
400 return OSSL_RECORD_RETURN_NON_FATAL_ERR;
403 /* check that cipher is supported */
404 if (!ktls_int_check_supported_cipher(rl, ciph, md, taglen))
405 return OSSL_RECORD_RETURN_NON_FATAL_ERR;
408 * TODO(RECLAYER): For the write side we need to add a check for
409 * use of s->record_padding_cb
412 /* All future data will get encrypted by ktls. Flush the BIO or skip ktls */
413 if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) {
414 if (BIO_flush(rl->bio) <= 0)
415 return OSSL_RECORD_RETURN_NON_FATAL_ERR;
418 if (!ktls_configure_crypto(rl->libctx, rl->version, ciph, md, rl->sequence,
420 rl->direction == OSSL_RECORD_DIRECTION_WRITE,
421 iv, ivlen, key, keylen, mackey, mackeylen))
422 return OSSL_RECORD_RETURN_NON_FATAL_ERR;
424 if (!BIO_set_ktls(rl->bio, &crypto_info, rl->direction))
425 return OSSL_RECORD_RETURN_NON_FATAL_ERR;
427 return OSSL_RECORD_RETURN_SUCCESS;
430 static int ktls_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
431 int clearold, size_t *readbytes)
435 ret = tls_default_read_n(rl, n, max, extend, clearold, readbytes);
437 if (ret < OSSL_RECORD_RETURN_RETRY) {
440 RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC,
441 SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
444 RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
445 SSL_R_PACKET_LENGTH_TOO_LONG);
448 RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION,
449 SSL_R_WRONG_VERSION_NUMBER);
459 static int ktls_cipher(OSSL_RECORD_LAYER *rl, SSL3_RECORD *inrecs, size_t n_recs,
460 int sending, SSL_MAC_BUF *mac, size_t macsize)
465 static int ktls_validate_record_header(OSSL_RECORD_LAYER *rl, SSL3_RECORD *rec)
467 if (rec->rec_version != TLS1_2_VERSION) {
468 RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_WRONG_VERSION_NUMBER);
475 static int ktls_post_process_record(OSSL_RECORD_LAYER *rl, SSL3_RECORD *rec)
477 if (rl->version == TLS1_3_VERSION)
478 return tls13_common_post_process_record(rl, rec);
483 static struct record_functions_st ossl_ktls_funcs = {
484 ktls_set_crypto_state,
486 tls_get_more_records,
489 tls_default_set_protocol_version,
490 ktls_validate_record_header,
491 ktls_post_process_record
495 ktls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
496 int role, int direction, int level, uint16_t epoch,
497 unsigned char *key, size_t keylen, unsigned char *iv,
498 size_t ivlen, unsigned char *mackey, size_t mackeylen,
499 const EVP_CIPHER *ciph, size_t taglen,
501 const EVP_MD *md, const SSL_COMP *comp, BIO *prev,
502 BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
503 const OSSL_PARAM *settings, const OSSL_PARAM *options,
504 const OSSL_DISPATCH *fns, void *cbarg,
505 OSSL_RECORD_LAYER **retrl)
509 ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level,
510 key, keylen, iv, ivlen, mackey, mackeylen,
511 ciph, taglen, mactype, md, comp, prev,
512 transport, next, local, peer, settings,
513 options, fns, cbarg, retrl);
515 if (ret != OSSL_RECORD_RETURN_SUCCESS)
518 (*retrl)->funcs = &ossl_ktls_funcs;
520 ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv,
521 ivlen, mackey, mackeylen, ciph,
522 taglen, mactype, md, comp);
524 if (ret != OSSL_RECORD_RETURN_SUCCESS) {
525 OPENSSL_free(*retrl);
529 * With KTLS we always try and read as much as possible and fill the
532 (*retrl)->read_ahead = 1;
537 const OSSL_RECORD_METHOD ossl_ktls_record_method = {
538 ktls_new_record_layer,
541 tls_unprocessed_read_pending,
542 tls_processed_read_pending,
543 tls_app_data_pending,
545 tls_get_max_record_len,
548 tls_retry_write_records,
553 tls_set_protocol_version,
554 tls_set_plain_alerts,
555 tls_set_first_handshake,
556 tls_set_max_pipelines,