KTLS adds support for in-kernel framing and encryption of Transport Layer Security (1.0-1.2) data on TCP sockets. KTLS only supports offload of TLS for transmitted data. Key negotation must still be performed in userland. Once completed, transmit session keys for a connection are provided to the kernel via a new TCP_TXTLS_ENABLE socket option. All subsequent data transmitted on the socket is placed into TLS frames and encrypted using the supplied keys. Any data written to a KTLS-enabled socket via write(2), aio_write(2), or sendfile(2) is assumed to be application data and is encoded in TLS frames with an application data type. Individual records can be sent with a custom type (e.g. handshake messages) via sendmsg(2) with a new control message (TLS_SET_RECORD_TYPE) specifying the record type. At present, rekeying is not supported though the in-kernel framework should support rekeying. KTLS makes use of the recently added unmapped mbufs to store TLS frames in the socket buffer. Each TLS frame is described by a single ext_pgs mbuf. The ext_pgs structure contains the header of the TLS record (and trailer for encrypted records) as well as references to the associated TLS session. KTLS supports two primary methods of encrypting TLS frames: software TLS and ifnet TLS. Software TLS marks mbufs holding socket data as not ready via M_NOTREADY similar to sendfile(2) when TLS framing information is added to an unmapped mbuf in ktls_frame(). ktls_enqueue() is then called to schedule TLS frames for encryption. In the case of sendfile_iodone() calls ktls_enqueue() instead of pru_ready() leaving the mbufs marked M_NOTREADY until encryption is completed. For other writes (vn_sendfile when pages are available, write(2), etc.), the PRUS_NOTREADY is set when invoking pru_send() along with invoking ktls_enqueue(). A pool of worker threads (the "KTLS" kernel process) encrypts TLS frames queued via ktls_enqueue(). Each TLS frame is temporarily mapped using the direct map and passed to a software encryption backend to perform the actual encryption. (Note: The use of PHYS_TO_DMAP could be replaced with sf_bufs if someone wished to make this work on architectures without a direct map.) KTLS supports pluggable software encryption backends. Internally, Netflix uses proprietary pure-software backends. This commit includes a simple backend in a new ktls_ocf.ko module that uses the kernel's OpenCrypto framework to provide AES-GCM encryption of TLS frames. As a result, software TLS is now a bit of a misnomer as it can make use of hardware crypto accelerators. Once software encryption has finished, the TLS frame mbufs are marked ready via pru_ready(). At this point, the encrypted data appears as regular payload to the TCP stack stored in unmapped mbufs. ifnet TLS permits a NIC to offload the TLS encryption and TCP segmentation. In this mode, a new send tag type (IF_SND_TAG_TYPE_TLS) is allocated on the interface a socket is routed over and associated with a TLS session. TLS records for a TLS session using ifnet TLS are not marked M_NOTREADY but are passed down the stack unencrypted. The ip_output_send() and ip6_output_send() helper functions that apply send tags to outbound IP packets verify that the send tag of the TLS record matches the outbound interface. If so, the packet is tagged with the TLS send tag and sent to the interface. The NIC device driver must recognize packets with the TLS send tag and schedule them for TLS encryption and TCP segmentation. If the the outbound interface does not match the interface in the TLS send tag, the packet is dropped. In addition, a task is scheduled to refresh the TLS send tag for the TLS session. If a new TLS send tag cannot be allocated, the connection is dropped. If a new TLS send tag is allocated, however, subsequent packets will be tagged with the correct TLS send tag. (This latter case has been tested by configuring both ports of a Chelsio T6 in a lagg and failing over from one port to another. As the connections migrated to the new port, new TLS send tags were allocated for the new port and connections resumed without being dropped.) ifnet TLS can be enabled and disabled on supported network interfaces via new '[-]txtls[46]' options to ifconfig(8). ifnet TLS is supported across both vlan devices and lagg interfaces using failover, lacp with flowid enabled, or lacp with flowid enabled. Applications may request the current KTLS mode of a connection via a new TCP_TXTLS_MODE socket option. They can also use this socket option to toggle between software and ifnet TLS modes. In addition, a testing tool is available in tools/tools/switch_tls. This is modeled on tcpdrop and uses similar syntax. However, instead of dropping connections, -s is used to force KTLS connections to switch to software TLS and -i is used to switch to ifnet TLS. Various sysctls and counters are available under the kern.ipc.tls sysctl node. The kern.ipc.tls.enable node must be set to true to enable KTLS (it is off by default). The use of unmapped mbufs must also be enabled via kern.ipc.mb_use_ext_pgs to enable KTLS. KTLS is enabled via the KERN_TLS kernel option. This patch is the culmination of years of work by several folks including Scott Long and Randall Stewart for the original design and implementation; Drew Gallatin for several optimizations including the use of ext_pgs mbufs, the M_NOTREADY mechanism for TLS records awaiting software encryption, and pluggable software crypto backends; and John Baldwin for modifications to support hardware TLS offload. Reviewed by: gallatin, hselasky, rrs Obtained from: Netflix Sponsored by: Netflix, Chelsio Communications Differential Revision: https://reviews.freebsd.org/D21277
309 lines
7.7 KiB
C
309 lines
7.7 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*
|
|
* Copyright (c) 2019 Netflix Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/counter.h>
|
|
#include <sys/endian.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/ktls.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/module.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/uio.h>
|
|
#include <opencrypto/cryptodev.h>
|
|
|
|
struct ocf_session {
|
|
crypto_session_t sid;
|
|
int crda_alg;
|
|
struct mtx lock;
|
|
};
|
|
|
|
struct ocf_operation {
|
|
struct ocf_session *os;
|
|
bool done;
|
|
struct iovec iov[0];
|
|
};
|
|
|
|
static MALLOC_DEFINE(M_KTLS_OCF, "ktls_ocf", "OCF KTLS");
|
|
|
|
SYSCTL_DECL(_kern_ipc_tls);
|
|
SYSCTL_DECL(_kern_ipc_tls_stats);
|
|
|
|
static counter_u64_t ocf_gcm_crypts;
|
|
SYSCTL_COUNTER_U64(_kern_ipc_tls_stats, OID_AUTO, ocf_gcm_crypts, CTLFLAG_RD,
|
|
&ocf_gcm_crypts,
|
|
"Total number of OCF GCM encryption operations");
|
|
|
|
static counter_u64_t ocf_retries;
|
|
SYSCTL_COUNTER_U64(_kern_ipc_tls_stats, OID_AUTO, ocf_retries, CTLFLAG_RD,
|
|
&ocf_retries,
|
|
"Number of OCF encryption operation retries");
|
|
|
|
static int
|
|
ktls_ocf_callback(struct cryptop *crp)
|
|
{
|
|
struct ocf_operation *oo;
|
|
|
|
oo = crp->crp_opaque;
|
|
mtx_lock(&oo->os->lock);
|
|
oo->done = true;
|
|
mtx_unlock(&oo->os->lock);
|
|
wakeup(oo);
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
ktls_ocf_encrypt(struct ktls_session *tls, const struct tls_record_layer *hdr,
|
|
uint8_t *trailer, struct iovec *iniov, struct iovec *outiov, int iovcnt,
|
|
uint64_t seqno)
|
|
{
|
|
struct uio uio;
|
|
struct tls_aead_data ad;
|
|
struct tls_nonce_data nd;
|
|
struct cryptodesc *crde, *crda;
|
|
struct cryptop *crp;
|
|
struct ocf_session *os;
|
|
struct ocf_operation *oo;
|
|
struct iovec *iov;
|
|
int i, error;
|
|
uint16_t tls_comp_len;
|
|
|
|
os = tls->cipher;
|
|
|
|
oo = malloc(sizeof(*oo) + (iovcnt + 2) * sizeof(*iov), M_KTLS_OCF,
|
|
M_WAITOK | M_ZERO);
|
|
oo->os = os;
|
|
iov = oo->iov;
|
|
|
|
crp = crypto_getreq(2);
|
|
if (crp == NULL) {
|
|
free(oo, M_KTLS_OCF);
|
|
return (ENOMEM);
|
|
}
|
|
|
|
/* Setup the IV. */
|
|
memcpy(nd.fixed, tls->params.iv, TLS_AEAD_GCM_LEN);
|
|
memcpy(&nd.seq, hdr + 1, sizeof(nd.seq));
|
|
|
|
/* Setup the AAD. */
|
|
tls_comp_len = ntohs(hdr->tls_length) -
|
|
(AES_GMAC_HASH_LEN + sizeof(nd.seq));
|
|
ad.seq = htobe64(seqno);
|
|
ad.type = hdr->tls_type;
|
|
ad.tls_vmajor = hdr->tls_vmajor;
|
|
ad.tls_vminor = hdr->tls_vminor;
|
|
ad.tls_length = htons(tls_comp_len);
|
|
iov[0].iov_base = &ad;
|
|
iov[0].iov_len = sizeof(ad);
|
|
uio.uio_resid = sizeof(ad);
|
|
|
|
/*
|
|
* OCF always does encryption in place, so copy the data if
|
|
* needed. Ugh.
|
|
*/
|
|
for (i = 0; i < iovcnt; i++) {
|
|
iov[i + 1] = outiov[i];
|
|
if (iniov[i].iov_base != outiov[i].iov_base)
|
|
memcpy(outiov[i].iov_base, iniov[i].iov_base,
|
|
outiov[i].iov_len);
|
|
uio.uio_resid += outiov[i].iov_len;
|
|
}
|
|
|
|
iov[iovcnt + 1].iov_base = trailer;
|
|
iov[iovcnt + 1].iov_len = AES_GMAC_HASH_LEN;
|
|
uio.uio_resid += AES_GMAC_HASH_LEN;
|
|
|
|
uio.uio_iov = iov;
|
|
uio.uio_iovcnt = iovcnt + 2;
|
|
uio.uio_offset = 0;
|
|
uio.uio_segflg = UIO_SYSSPACE;
|
|
uio.uio_td = curthread;
|
|
|
|
crp->crp_session = os->sid;
|
|
crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM;
|
|
crp->crp_uio = &uio;
|
|
crp->crp_ilen = uio.uio_resid;
|
|
crp->crp_opaque = oo;
|
|
crp->crp_callback = ktls_ocf_callback;
|
|
|
|
crde = crp->crp_desc;
|
|
crda = crde->crd_next;
|
|
|
|
crda->crd_alg = os->crda_alg;
|
|
crda->crd_skip = 0;
|
|
crda->crd_len = sizeof(ad);
|
|
crda->crd_inject = crp->crp_ilen - AES_GMAC_HASH_LEN;
|
|
|
|
crde->crd_alg = CRYPTO_AES_NIST_GCM_16;
|
|
crde->crd_skip = sizeof(ad);
|
|
crde->crd_len = crp->crp_ilen - (sizeof(ad) + AES_GMAC_HASH_LEN);
|
|
crde->crd_flags = CRD_F_ENCRYPT | CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
|
|
memcpy(crde->crd_iv, &nd, sizeof(nd));
|
|
|
|
counter_u64_add(ocf_gcm_crypts, 1);
|
|
for (;;) {
|
|
error = crypto_dispatch(crp);
|
|
if (error)
|
|
break;
|
|
|
|
mtx_lock(&os->lock);
|
|
while (!oo->done)
|
|
mtx_sleep(oo, &os->lock, 0, "ocfktls", 0);
|
|
mtx_unlock(&os->lock);
|
|
|
|
if (crp->crp_etype != EAGAIN) {
|
|
error = crp->crp_etype;
|
|
break;
|
|
}
|
|
|
|
crp->crp_etype = 0;
|
|
crp->crp_flags &= ~CRYPTO_F_DONE;
|
|
oo->done = false;
|
|
counter_u64_add(ocf_retries, 1);
|
|
}
|
|
|
|
crypto_freereq(crp);
|
|
free(oo, M_KTLS_OCF);
|
|
return (error);
|
|
}
|
|
|
|
static void
|
|
ktls_ocf_free(struct ktls_session *tls)
|
|
{
|
|
struct ocf_session *os;
|
|
|
|
os = tls->cipher;
|
|
mtx_destroy(&os->lock);
|
|
explicit_bzero(os, sizeof(*os));
|
|
free(os, M_KTLS_OCF);
|
|
}
|
|
|
|
static int
|
|
ktls_ocf_try(struct socket *so, struct ktls_session *tls)
|
|
{
|
|
struct cryptoini cria, crie;
|
|
struct ocf_session *os;
|
|
int error;
|
|
|
|
memset(&cria, 0, sizeof(cria));
|
|
memset(&crie, 0, sizeof(crie));
|
|
|
|
switch (tls->params.cipher_algorithm) {
|
|
case CRYPTO_AES_NIST_GCM_16:
|
|
if (tls->params.iv_len != TLS_AEAD_GCM_LEN)
|
|
return (EINVAL);
|
|
switch (tls->params.cipher_key_len) {
|
|
case 128 / 8:
|
|
cria.cri_alg = CRYPTO_AES_128_NIST_GMAC;
|
|
break;
|
|
case 256 / 8:
|
|
cria.cri_alg = CRYPTO_AES_256_NIST_GMAC;
|
|
break;
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
cria.cri_key = tls->params.cipher_key;
|
|
cria.cri_klen = tls->params.cipher_key_len * 8;
|
|
break;
|
|
default:
|
|
return (EPROTONOSUPPORT);
|
|
}
|
|
|
|
/* Only TLS 1.1 and TLS 1.2 are currently supported. */
|
|
if (tls->params.tls_vmajor != TLS_MAJOR_VER_ONE ||
|
|
tls->params.tls_vminor < TLS_MINOR_VER_ONE ||
|
|
tls->params.tls_vminor > TLS_MINOR_VER_TWO)
|
|
return (EPROTONOSUPPORT);
|
|
|
|
os = malloc(sizeof(*os), M_KTLS_OCF, M_NOWAIT | M_ZERO);
|
|
if (os == NULL)
|
|
return (ENOMEM);
|
|
|
|
crie.cri_alg = tls->params.cipher_algorithm;
|
|
crie.cri_key = tls->params.cipher_key;
|
|
crie.cri_klen = tls->params.cipher_key_len * 8;
|
|
|
|
crie.cri_next = &cria;
|
|
error = crypto_newsession(&os->sid, &crie,
|
|
CRYPTO_FLAG_HARDWARE | CRYPTO_FLAG_SOFTWARE);
|
|
if (error) {
|
|
free(os, M_KTLS_OCF);
|
|
return (error);
|
|
}
|
|
|
|
os->crda_alg = cria.cri_alg;
|
|
mtx_init(&os->lock, "ktls_ocf", NULL, MTX_DEF);
|
|
tls->cipher = os;
|
|
tls->sw_encrypt = ktls_ocf_encrypt;
|
|
tls->free = ktls_ocf_free;
|
|
return (0);
|
|
}
|
|
|
|
struct ktls_crypto_backend ocf_backend = {
|
|
.name = "OCF",
|
|
.prio = 5,
|
|
.api_version = KTLS_API_VERSION,
|
|
.try = ktls_ocf_try,
|
|
};
|
|
|
|
static int
|
|
ktls_ocf_modevent(module_t mod, int what, void *arg)
|
|
{
|
|
int error;
|
|
|
|
switch (what) {
|
|
case MOD_LOAD:
|
|
ocf_gcm_crypts = counter_u64_alloc(M_WAITOK);
|
|
ocf_retries = counter_u64_alloc(M_WAITOK);
|
|
return (ktls_crypto_backend_register(&ocf_backend));
|
|
case MOD_UNLOAD:
|
|
error = ktls_crypto_backend_deregister(&ocf_backend);
|
|
if (error)
|
|
return (error);
|
|
counter_u64_free(ocf_gcm_crypts);
|
|
counter_u64_free(ocf_retries);
|
|
return (0);
|
|
default:
|
|
return (EOPNOTSUPP);
|
|
}
|
|
}
|
|
|
|
static moduledata_t ktls_ocf_moduledata = {
|
|
"ktls_ocf",
|
|
ktls_ocf_modevent,
|
|
NULL
|
|
};
|
|
|
|
DECLARE_MODULE(ktls_ocf, ktls_ocf_moduledata, SI_SUB_PROTO_END, SI_ORDER_ANY);
|