sys/opencrypto/ktls_ocf.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2019 Netflix Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/counter.h>
  35 #include <sys/endian.h>
  36 #include <sys/kernel.h>
  37 #include <sys/ktls.h>
  38 #include <sys/lock.h>
  39 #include <sys/malloc.h>
  40 #include <sys/module.h>
  41 #include <sys/mutex.h>
  42 #include <sys/sysctl.h>
  43 #include <sys/uio.h>
  44 #include <opencrypto/cryptodev.h>
  45
  46 struct ocf_session {
  47         crypto_session_t sid;
  48         struct mtx lock;
  49 };
  50
  51 struct ocf_operation {
  52         struct ocf_session *os;
  53         bool done;
  54         struct iovec iov[0];
  55 };
  56
  57 static MALLOC_DEFINE(M_KTLS_OCF, "ktls_ocf", "OCF KTLS");
  58
  59 SYSCTL_DECL(_kern_ipc_tls);
  60 SYSCTL_DECL(_kern_ipc_tls_stats);
  61
  62 static SYSCTL_NODE(_kern_ipc_tls_stats, OID_AUTO, ocf,
  63     CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
  64     "Kernel TLS offload via OCF stats");
  65
  66 static counter_u64_t ocf_tls12_gcm_crypts;
  67 SYSCTL_COUNTER_U64(_kern_ipc_tls_stats_ocf, OID_AUTO, tls12_gcm_crypts,
  68     CTLFLAG_RD, &ocf_tls12_gcm_crypts,
  69     "Total number of OCF TLS 1.2 GCM encryption operations");
  70
  71 static counter_u64_t ocf_tls13_gcm_crypts;
  72 SYSCTL_COUNTER_U64(_kern_ipc_tls_stats_ocf, OID_AUTO, tls13_gcm_crypts,
  73     CTLFLAG_RD, &ocf_tls13_gcm_crypts,
  74     "Total number of OCF TLS 1.3 GCM encryption operations");
  75
  76 static counter_u64_t ocf_retries;
  77 SYSCTL_COUNTER_U64(_kern_ipc_tls_stats_ocf, OID_AUTO, retries, CTLFLAG_RD,
  78     &ocf_retries,
  79     "Number of OCF encryption operation retries");
  80
  81 static int
  82 ktls_ocf_callback(struct cryptop *crp)
  83 {
  84         struct ocf_operation *oo;
  85
  86         oo = crp->crp_opaque;
  87         mtx_lock(&oo->os->lock);
  88         oo->done = true;
  89         mtx_unlock(&oo->os->lock);
  90         wakeup(oo);
  91         return (0);
  92 }
  93
  94 static int
  95 ktls_ocf_tls12_gcm_encrypt(struct ktls_session *tls,
  96     const struct tls_record_layer *hdr, uint8_t *trailer, struct iovec *iniov,
  97     struct iovec *outiov, int iovcnt, uint64_t seqno,
  98     uint8_t record_type __unused)
  99 {
 100         struct uio uio;
 101         struct tls_aead_data ad;
 102         struct cryptop *crp;
 103         struct ocf_session *os;
 104         struct ocf_operation *oo;
 105         struct iovec *iov;
 106         int i, error;
 107         uint16_t tls_comp_len;
 108
 109         os = tls->cipher;
 110
 111         oo = malloc(sizeof(*oo) + (iovcnt + 2) * sizeof(*iov), M_KTLS_OCF,
 112             M_WAITOK | M_ZERO);
 113         oo->os = os;
 114         iov = oo->iov;
 115
 116         crp = crypto_getreq(os->sid, M_WAITOK);
 117
 118         /* Setup the IV. */
 119         memcpy(crp->crp_iv, tls->params.iv, TLS_AEAD_GCM_LEN);
 120         memcpy(crp->crp_iv + TLS_AEAD_GCM_LEN, hdr + 1, sizeof(uint64_t));
 121
 122         /* Setup the AAD. */
 123         tls_comp_len = ntohs(hdr->tls_length) -
 124             (AES_GMAC_HASH_LEN + sizeof(uint64_t));
 125         ad.seq = htobe64(seqno);
 126         ad.type = hdr->tls_type;
 127         ad.tls_vmajor = hdr->tls_vmajor;
 128         ad.tls_vminor = hdr->tls_vminor;
 129         ad.tls_length = htons(tls_comp_len);
 130         iov[0].iov_base = &ad;
 131         iov[0].iov_len = sizeof(ad);
 132         uio.uio_resid = sizeof(ad);
 133
 134         /*
 135          * OCF always does encryption in place, so copy the data if
 136          * needed.  Ugh.
 137          */
 138         for (i = 0; i < iovcnt; i++) {
 139                 iov[i + 1] = outiov[i];
 140                 if (iniov[i].iov_base != outiov[i].iov_base)
 141                         memcpy(outiov[i].iov_base, iniov[i].iov_base,
 142                             outiov[i].iov_len);
 143                 uio.uio_resid += outiov[i].iov_len;
 144         }
 145
 146         iov[iovcnt + 1].iov_base = trailer;
 147         iov[iovcnt + 1].iov_len = AES_GMAC_HASH_LEN;
 148         uio.uio_resid += AES_GMAC_HASH_LEN;
 149
 150         uio.uio_iov = iov;
 151         uio.uio_iovcnt = iovcnt + 2;
 152         uio.uio_offset = 0;
 153         uio.uio_segflg = UIO_SYSSPACE;
 154         uio.uio_td = curthread;
 155
 156         crp->crp_op = CRYPTO_OP_ENCRYPT | CRYPTO_OP_COMPUTE_DIGEST;
 157         crp->crp_flags = CRYPTO_F_CBIMM | CRYPTO_F_IV_SEPARATE;
 158         crypto_use_uio(crp, &uio);
 159         crp->crp_opaque = oo;
 160         crp->crp_callback = ktls_ocf_callback;
 161
 162         crp->crp_aad_start = 0;
 163         crp->crp_aad_length = sizeof(ad);
 164         crp->crp_payload_start = sizeof(ad);
 165         crp->crp_payload_length = uio.uio_resid -
 166             (sizeof(ad) + AES_GMAC_HASH_LEN);
 167         crp->crp_digest_start = uio.uio_resid - AES_GMAC_HASH_LEN;
 168
 169         counter_u64_add(ocf_tls12_gcm_crypts, 1);
 170         for (;;) {
 171                 error = crypto_dispatch(crp);
 172                 if (error)
 173                         break;
 174
 175                 mtx_lock(&os->lock);
 176                 while (!oo->done)
 177                         mtx_sleep(oo, &os->lock, 0, "ocfktls", 0);
 178                 mtx_unlock(&os->lock);
 179
 180                 if (crp->crp_etype != EAGAIN) {
 181                         error = crp->crp_etype;
 182                         break;
 183                 }
 184
 185                 crp->crp_etype = 0;
 186                 crp->crp_flags &= ~CRYPTO_F_DONE;
 187                 oo->done = false;
 188                 counter_u64_add(ocf_retries, 1);
 189         }
 190
 191         crypto_freereq(crp);
 192         free(oo, M_KTLS_OCF);
 193         return (error);
 194 }
 195
 196 static int
 197 ktls_ocf_tls13_gcm_encrypt(struct ktls_session *tls,
 198     const struct tls_record_layer *hdr, uint8_t *trailer, struct iovec *iniov,
 199     struct iovec *outiov, int iovcnt, uint64_t seqno, uint8_t record_type)
 200 {
 201         struct uio uio;
 202         struct tls_aead_data_13 ad;
 203         char nonce[12];
 204         struct cryptop *crp;
 205         struct ocf_session *os;
 206         struct ocf_operation *oo;
 207         struct iovec *iov;
 208         int i, error;
 209
 210         os = tls->cipher;
 211
 212         oo = malloc(sizeof(*oo) + (iovcnt + 2) * sizeof(*iov), M_KTLS_OCF,
 213             M_WAITOK | M_ZERO);
 214         oo->os = os;
 215         iov = oo->iov;
 216
 217         crp = crypto_getreq(os->sid, M_WAITOK);
 218
 219         /* Setup the nonce. */
 220         memcpy(nonce, tls->params.iv, tls->params.iv_len);
 221         *(uint64_t *)(nonce + 4) ^= htobe64(seqno);
 222
 223         /* Setup the AAD. */
 224         ad.type = hdr->tls_type;
 225         ad.tls_vmajor = hdr->tls_vmajor;
 226         ad.tls_vminor = hdr->tls_vminor;
 227         ad.tls_length = hdr->tls_length;
 228         iov[0].iov_base = &ad;
 229         iov[0].iov_len = sizeof(ad);
 230         uio.uio_resid = sizeof(ad);
 231
 232         /*
 233          * OCF always does encryption in place, so copy the data if
 234          * needed.  Ugh.
 235          */
 236         for (i = 0; i < iovcnt; i++) {
 237                 iov[i + 1] = outiov[i];
 238                 if (iniov[i].iov_base != outiov[i].iov_base)
 239                         memcpy(outiov[i].iov_base, iniov[i].iov_base,
 240                             outiov[i].iov_len);
 241                 uio.uio_resid += outiov[i].iov_len;
 242         }
 243
 244         trailer[0] = record_type;
 245         iov[iovcnt + 1].iov_base = trailer;
 246         iov[iovcnt + 1].iov_len = AES_GMAC_HASH_LEN + 1;
 247         uio.uio_resid += AES_GMAC_HASH_LEN + 1;
 248
 249         uio.uio_iov = iov;
 250         uio.uio_iovcnt = iovcnt + 2;
 251         uio.uio_offset = 0;
 252         uio.uio_segflg = UIO_SYSSPACE;
 253         uio.uio_td = curthread;
 254
 255         crp->crp_op = CRYPTO_OP_ENCRYPT | CRYPTO_OP_COMPUTE_DIGEST;
 256         crp->crp_flags = CRYPTO_F_CBIMM | CRYPTO_F_IV_SEPARATE;
 257         crypto_use_uio(crp, &uio);
 258         crp->crp_opaque = oo;
 259         crp->crp_callback = ktls_ocf_callback;
 260
 261         crp->crp_aad_start = 0;
 262         crp->crp_aad_length = sizeof(ad);
 263         crp->crp_payload_start = sizeof(ad);
 264         crp->crp_payload_length = uio.uio_resid -
 265             (sizeof(ad) + AES_GMAC_HASH_LEN);
 266         crp->crp_digest_start = uio.uio_resid - AES_GMAC_HASH_LEN;
 267         memcpy(crp->crp_iv, nonce, sizeof(nonce));
 268
 269         counter_u64_add(ocf_tls13_gcm_crypts, 1);
 270         for (;;) {
 271                 error = crypto_dispatch(crp);
 272                 if (error)
 273                         break;
 274
 275                 mtx_lock(&os->lock);
 276                 while (!oo->done)
 277                         mtx_sleep(oo, &os->lock, 0, "ocfktls", 0);
 278                 mtx_unlock(&os->lock);
 279
 280                 if (crp->crp_etype != EAGAIN) {
 281                         error = crp->crp_etype;
 282                         break;
 283                 }
 284
 285                 crp->crp_etype = 0;
 286                 crp->crp_flags &= ~CRYPTO_F_DONE;
 287                 oo->done = false;
 288                 counter_u64_add(ocf_retries, 1);
 289         }
 290
 291         crypto_freereq(crp);
 292         free(oo, M_KTLS_OCF);
 293         return (error);
 294 }
 295
 296 static void
 297 ktls_ocf_free(struct ktls_session *tls)
 298 {
 299         struct ocf_session *os;
 300
 301         os = tls->cipher;
 302         crypto_freesession(os->sid);
 303         mtx_destroy(&os->lock);
 304         explicit_bzero(os, sizeof(*os));
 305         free(os, M_KTLS_OCF);
 306 }
 307
 308 static int
 309 ktls_ocf_try(struct socket *so, struct ktls_session *tls)
 310 {
 311         struct crypto_session_params csp;
 312         struct ocf_session *os;
 313         int error;
 314
 315         memset(&csp, 0, sizeof(csp));
 316
 317         switch (tls->params.cipher_algorithm) {
 318         case CRYPTO_AES_NIST_GCM_16:
 319                 switch (tls->params.cipher_key_len) {
 320                 case 128 / 8:
 321                 case 256 / 8:
 322                         break;
 323                 default:
 324                         return (EINVAL);
 325                 }
 326                 csp.csp_mode = CSP_MODE_AEAD;
 327                 csp.csp_cipher_alg = CRYPTO_AES_NIST_GCM_16;
 328                 csp.csp_cipher_key = tls->params.cipher_key;
 329                 csp.csp_cipher_klen = tls->params.cipher_key_len;
 330                 csp.csp_ivlen = AES_GCM_IV_LEN;
 331                 break;
 332         default:
 333                 return (EPROTONOSUPPORT);
 334         }
 335
 336         /* Only TLS 1.2 and 1.3 are supported. */
 337         if (tls->params.tls_vmajor != TLS_MAJOR_VER_ONE ||
 338             tls->params.tls_vminor < TLS_MINOR_VER_TWO ||
 339             tls->params.tls_vminor > TLS_MINOR_VER_THREE)
 340                 return (EPROTONOSUPPORT);
 341
 342         os = malloc(sizeof(*os), M_KTLS_OCF, M_NOWAIT | M_ZERO);
 343         if (os == NULL)
 344                 return (ENOMEM);
 345
 346         error = crypto_newsession(&os->sid, &csp,
 347             CRYPTO_FLAG_HARDWARE | CRYPTO_FLAG_SOFTWARE);
 348         if (error) {
 349                 free(os, M_KTLS_OCF);
 350                 return (error);
 351         }
 352
 353         mtx_init(&os->lock, "ktls_ocf", NULL, MTX_DEF);
 354         tls->cipher = os;
 355         if (tls->params.tls_vminor == TLS_MINOR_VER_THREE)
 356                 tls->sw_encrypt = ktls_ocf_tls13_gcm_encrypt;
 357         else
 358                 tls->sw_encrypt = ktls_ocf_tls12_gcm_encrypt;
 359         tls->free = ktls_ocf_free;
 360         return (0);
 361 }
 362
 363 struct ktls_crypto_backend ocf_backend = {
 364         .name = "OCF",
 365         .prio = 5,
 366         .api_version = KTLS_API_VERSION,
 367         .try = ktls_ocf_try,
 368 };
 369
 370 static int
 371 ktls_ocf_modevent(module_t mod, int what, void *arg)
 372 {
 373         int error;
 374
 375         switch (what) {
 376         case MOD_LOAD:
 377                 ocf_tls12_gcm_crypts = counter_u64_alloc(M_WAITOK);
 378                 ocf_tls13_gcm_crypts = counter_u64_alloc(M_WAITOK);
 379                 ocf_retries = counter_u64_alloc(M_WAITOK);
 380                 return (ktls_crypto_backend_register(&ocf_backend));
 381         case MOD_UNLOAD:
 382                 error = ktls_crypto_backend_deregister(&ocf_backend);
 383                 if (error)
 384                         return (error);
 385                 counter_u64_free(ocf_tls12_gcm_crypts);
 386                 counter_u64_free(ocf_tls13_gcm_crypts);
 387                 counter_u64_free(ocf_retries);
 388                 return (0);
 389         default:
 390                 return (EOPNOTSUPP);
 391         }
 392 }
 393
 394 static moduledata_t ktls_ocf_moduledata = {
 395         "ktls_ocf",
 396         ktls_ocf_modevent,
 397         NULL
 398 };
 399
 400 DECLARE_MODULE(ktls_ocf, ktls_ocf_moduledata, SI_SUB_PROTO_END, SI_ORDER_ANY);