sys/opencrypto/cryptosoft.c

   1 /*      $OpenBSD: cryptosoft.c,v 1.35 2002/04/26 08:43:50 deraadt Exp $ */
   2
   3 /*-
   4  * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu)
   5  * Copyright (c) 2002-2006 Sam Leffler, Errno Consulting
   6  *
   7  * This code was written by Angelos D. Keromytis in Athens, Greece, in
   8  * February 2000. Network Security Technologies Inc. (NSTI) kindly
   9  * supported the development of this code.
  10  *
  11  * Copyright (c) 2000, 2001 Angelos D. Keromytis
  12  * Copyright (c) 2014 The FreeBSD Foundation
  13  * All rights reserved.
  14  *
  15  * Portions of this software were developed by John-Mark Gurney
  16  * under sponsorship of the FreeBSD Foundation and
  17  * Rubicon Communications, LLC (Netgate).
  18  *
  19  * Permission to use, copy, and modify this software with or without fee
  20  * is hereby granted, provided that this entire notice is included in
  21  * all source code copies of any software which is or includes a copy or
  22  * modification of this software.
  23  *
  24  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
  25  * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
  26  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
  27  * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
  28  * PURPOSE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/malloc.h>
  37 #include <sys/mbuf.h>
  38 #include <sys/module.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/errno.h>
  41 #include <sys/random.h>
  42 #include <sys/kernel.h>
  43 #include <sys/uio.h>
  44 #include <sys/lock.h>
  45 #include <sys/rwlock.h>
  46 #include <sys/endian.h>
  47 #include <sys/limits.h>
  48 #include <sys/mutex.h>
  49
  50 #include <crypto/sha1.h>
  51 #include <opencrypto/rmd160.h>
  52
  53 #include <opencrypto/cryptodev.h>
  54 #include <opencrypto/xform.h>
  55
  56 #include <sys/kobj.h>
  57 #include <sys/bus.h>
  58 #include "cryptodev_if.h"
  59
  60 struct swcr_auth {
  61         void            *sw_ictx;
  62         void            *sw_octx;
  63         struct auth_hash *sw_axf;
  64         uint16_t        sw_mlen;
  65 };
  66
  67 struct swcr_encdec {
  68         void            *sw_kschedule;
  69         struct enc_xform *sw_exf;
  70 };
  71
  72 struct swcr_compdec {
  73         struct comp_algo *sw_cxf;
  74 };
  75
  76 struct swcr_session {
  77         struct mtx      swcr_lock;
  78         int     (*swcr_process)(struct swcr_session *, struct cryptop *);
  79
  80         struct swcr_auth swcr_auth;
  81         struct swcr_encdec swcr_encdec;
  82         struct swcr_compdec swcr_compdec;
  83 };
  84
  85 static  int32_t swcr_id;
  86
  87 static  void swcr_freesession(device_t dev, crypto_session_t cses);
  88
  89 /* Used for CRYPTO_NULL_CBC. */
  90 static int
  91 swcr_null(struct swcr_session *ses, struct cryptop *crp)
  92 {
  93
  94         return (0);
  95 }
  96
  97 /*
  98  * Apply a symmetric encryption/decryption algorithm.
  99  */
 100 static int
 101 swcr_encdec(struct swcr_session *ses, struct cryptop *crp)
 102 {
 103         unsigned char iv[EALG_MAX_BLOCK_LEN], blk[EALG_MAX_BLOCK_LEN];
 104         unsigned char *ivp, *nivp, iv2[EALG_MAX_BLOCK_LEN];
 105         const struct crypto_session_params *csp;
 106         struct swcr_encdec *sw;
 107         struct enc_xform *exf;
 108         int i, blks, inlen, ivlen, outlen, resid;
 109         struct crypto_buffer_cursor cc_in, cc_out;
 110         const unsigned char *inblk;
 111         unsigned char *outblk;
 112         int error;
 113         bool encrypting;
 114
 115         error = 0;
 116
 117         sw = &ses->swcr_encdec;
 118         exf = sw->sw_exf;
 119         ivlen = exf->ivsize;
 120
 121         if (exf->native_blocksize == 0) {
 122                 /* Check for non-padded data */
 123                 if ((crp->crp_payload_length % exf->blocksize) != 0)
 124                         return (EINVAL);
 125
 126                 blks = exf->blocksize;
 127         } else
 128                 blks = exf->native_blocksize;
 129
 130         if (exf == &enc_xform_aes_icm &&
 131             (crp->crp_flags & CRYPTO_F_IV_SEPARATE) == 0)
 132                 return (EINVAL);
 133
 134         if (crp->crp_cipher_key != NULL) {
 135                 csp = crypto_get_params(crp->crp_session);
 136                 error = exf->setkey(sw->sw_kschedule,
 137                     crp->crp_cipher_key, csp->csp_cipher_klen);
 138                 if (error)
 139                         return (error);
 140         }
 141
 142         crypto_read_iv(crp, iv);
 143
 144         if (exf->reinit) {
 145                 /*
 146                  * xforms that provide a reinit method perform all IV
 147                  * handling themselves.
 148                  */
 149                 exf->reinit(sw->sw_kschedule, iv);
 150         }
 151
 152         ivp = iv;
 153
 154         crypto_cursor_init(&cc_in, &crp->crp_buf);
 155         crypto_cursor_advance(&cc_in, crp->crp_payload_start);
 156         inlen = crypto_cursor_seglen(&cc_in);
 157         inblk = crypto_cursor_segbase(&cc_in);
 158         if (CRYPTO_HAS_OUTPUT_BUFFER(crp)) {
 159                 crypto_cursor_init(&cc_out, &crp->crp_obuf);
 160                 crypto_cursor_advance(&cc_out, crp->crp_payload_output_start);
 161         } else
 162                 cc_out = cc_in;
 163         outlen = crypto_cursor_seglen(&cc_out);
 164         outblk = crypto_cursor_segbase(&cc_out);
 165
 166         resid = crp->crp_payload_length;
 167         encrypting = CRYPTO_OP_IS_ENCRYPT(crp->crp_op);
 168
 169         /*
 170          * Loop through encrypting blocks.  'inlen' is the remaining
 171          * length of the current segment in the input buffer.
 172          * 'outlen' is the remaining length of current segment in the
 173          * output buffer.
 174          */
 175         while (resid >= blks) {
 176                 /*
 177                  * If the current block is not contained within the
 178                  * current input/output segment, use 'blk' as a local
 179                  * buffer.
 180                  */
 181                 if (inlen < blks) {
 182                         crypto_cursor_copydata(&cc_in, blks, blk);
 183                         inblk = blk;
 184                 }
 185                 if (outlen < blks)
 186                         outblk = blk;
 187
 188                 /*
 189                  * Ciphers without a 'reinit' hook are assumed to be
 190                  * used in CBC mode where the chaining is done here.
 191                  */
 192                 if (exf->reinit != NULL) {
 193                         if (encrypting)
 194                                 exf->encrypt(sw->sw_kschedule, inblk, outblk);
 195                         else
 196                                 exf->decrypt(sw->sw_kschedule, inblk, outblk);
 197                 } else if (encrypting) {
 198                         /* XOR with previous block */
 199                         for (i = 0; i < blks; i++)
 200                                 outblk[i] = inblk[i] ^ ivp[i];
 201
 202                         exf->encrypt(sw->sw_kschedule, outblk, outblk);
 203
 204                         /*
 205                          * Keep encrypted block for XOR'ing
 206                          * with next block
 207                          */
 208                         memcpy(iv, outblk, blks);
 209                         ivp = iv;
 210                 } else {        /* decrypt */
 211                         /*
 212                          * Keep encrypted block for XOR'ing
 213                          * with next block
 214                          */
 215                         nivp = (ivp == iv) ? iv2 : iv;
 216                         memcpy(nivp, inblk, blks);
 217
 218                         exf->decrypt(sw->sw_kschedule, inblk, outblk);
 219
 220                         /* XOR with previous block */
 221                         for (i = 0; i < blks; i++)
 222                                 outblk[i] ^= ivp[i];
 223
 224                         ivp = nivp;
 225                 }
 226
 227                 if (inlen < blks) {
 228                         inlen = crypto_cursor_seglen(&cc_in);
 229                         inblk = crypto_cursor_segbase(&cc_in);
 230                 } else {
 231                         crypto_cursor_advance(&cc_in, blks);
 232                         inlen -= blks;
 233                         inblk += blks;
 234                 }
 235
 236                 if (outlen < blks) {
 237                         crypto_cursor_copyback(&cc_out, blks, blk);
 238                         outlen = crypto_cursor_seglen(&cc_out);
 239                         outblk = crypto_cursor_segbase(&cc_out);
 240                 } else {
 241                         crypto_cursor_advance(&cc_out, blks);
 242                         outlen -= blks;
 243                         outblk += blks;
 244                 }
 245
 246                 resid -= blks;
 247         }
 248
 249         /* Handle trailing partial block for stream ciphers. */
 250         if (resid > 0) {
 251                 KASSERT(exf->native_blocksize != 0,
 252                     ("%s: partial block of %d bytes for cipher %s",
 253                     __func__, i, exf->name));
 254                 KASSERT(exf->reinit != NULL,
 255                     ("%s: partial block cipher %s without reinit hook",
 256                     __func__, exf->name));
 257                 KASSERT(resid < blks, ("%s: partial block too big", __func__));
 258
 259                 inlen = crypto_cursor_seglen(&cc_in);
 260                 outlen = crypto_cursor_seglen(&cc_out);
 261                 if (inlen < resid) {
 262                         crypto_cursor_copydata(&cc_in, resid, blk);
 263                         inblk = blk;
 264                 } else
 265                         inblk = crypto_cursor_segbase(&cc_in);
 266                 if (outlen < resid)
 267                         outblk = blk;
 268                 else
 269                         outblk = crypto_cursor_segbase(&cc_out);
 270                 if (encrypting)
 271                         exf->encrypt_last(sw->sw_kschedule, inblk, outblk,
 272                             resid);
 273                 else
 274                         exf->decrypt_last(sw->sw_kschedule, inblk, outblk,
 275                             resid);
 276                 if (outlen < resid)
 277                         crypto_cursor_copyback(&cc_out, resid, blk);
 278         }
 279
 280         explicit_bzero(blk, sizeof(blk));
 281         explicit_bzero(iv, sizeof(iv));
 282         explicit_bzero(iv2, sizeof(iv2));
 283         return (0);
 284 }
 285
 286 static void
 287 swcr_authprepare(struct auth_hash *axf, struct swcr_auth *sw,
 288     const uint8_t *key, int klen)
 289 {
 290
 291         switch (axf->type) {
 292         case CRYPTO_SHA1_HMAC:
 293         case CRYPTO_SHA2_224_HMAC:
 294         case CRYPTO_SHA2_256_HMAC:
 295         case CRYPTO_SHA2_384_HMAC:
 296         case CRYPTO_SHA2_512_HMAC:
 297         case CRYPTO_NULL_HMAC:
 298         case CRYPTO_RIPEMD160_HMAC:
 299                 hmac_init_ipad(axf, key, klen, sw->sw_ictx);
 300                 hmac_init_opad(axf, key, klen, sw->sw_octx);
 301                 break;
 302         case CRYPTO_POLY1305:
 303         case CRYPTO_BLAKE2B:
 304         case CRYPTO_BLAKE2S:
 305                 axf->Setkey(sw->sw_ictx, key, klen);
 306                 axf->Init(sw->sw_ictx);
 307                 break;
 308         default:
 309                 panic("%s: algorithm %d doesn't use keys", __func__, axf->type);
 310         }
 311 }
 312
 313 /*
 314  * Compute or verify hash.
 315  */
 316 static int
 317 swcr_authcompute(struct swcr_session *ses, struct cryptop *crp)
 318 {
 319         u_char aalg[HASH_MAX_LEN];
 320         const struct crypto_session_params *csp;
 321         struct swcr_auth *sw;
 322         struct auth_hash *axf;
 323         union authctx ctx;
 324         int err;
 325
 326         sw = &ses->swcr_auth;
 327
 328         axf = sw->sw_axf;
 329
 330         csp = crypto_get_params(crp->crp_session);
 331         if (crp->crp_auth_key != NULL) {
 332                 swcr_authprepare(axf, sw, crp->crp_auth_key,
 333                     csp->csp_auth_klen);
 334         }
 335
 336         bcopy(sw->sw_ictx, &ctx, axf->ctxsize);
 337
 338         if (crp->crp_aad != NULL)
 339                 err = axf->Update(&ctx, crp->crp_aad, crp->crp_aad_length);
 340         else
 341                 err = crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
 342                     axf->Update, &ctx);
 343         if (err)
 344                 goto out;
 345
 346         if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
 347             CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
 348                 err = crypto_apply_buf(&crp->crp_obuf,
 349                     crp->crp_payload_output_start, crp->crp_payload_length,
 350                     axf->Update, &ctx);
 351         else
 352                 err = crypto_apply(crp, crp->crp_payload_start,
 353                     crp->crp_payload_length, axf->Update, &ctx);
 354         if (err)
 355                 goto out;
 356
 357         if (csp->csp_flags & CSP_F_ESN)
 358                 axf->Update(&ctx, crp->crp_esn, 4);
 359
 360         axf->Final(aalg, &ctx);
 361         if (sw->sw_octx != NULL) {
 362                 bcopy(sw->sw_octx, &ctx, axf->ctxsize);
 363                 axf->Update(&ctx, aalg, axf->hashsize);
 364                 axf->Final(aalg, &ctx);
 365         }
 366
 367         if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
 368                 u_char uaalg[HASH_MAX_LEN];
 369
 370                 crypto_copydata(crp, crp->crp_digest_start, sw->sw_mlen, uaalg);
 371                 if (timingsafe_bcmp(aalg, uaalg, sw->sw_mlen) != 0)
 372                         err = EBADMSG;
 373                 explicit_bzero(uaalg, sizeof(uaalg));
 374         } else {
 375                 /* Inject the authentication data */
 376                 crypto_copyback(crp, crp->crp_digest_start, sw->sw_mlen, aalg);
 377         }
 378         explicit_bzero(aalg, sizeof(aalg));
 379 out:
 380         explicit_bzero(&ctx, sizeof(ctx));
 381         return (err);
 382 }
 383
 384 CTASSERT(INT_MAX <= (1ll<<39) - 256);   /* GCM: plain text < 2^39-256 */
 385 CTASSERT(INT_MAX <= (uint64_t)-1);      /* GCM: associated data <= 2^64-1 */
 386
 387 static int
 388 swcr_gmac(struct swcr_session *ses, struct cryptop *crp)
 389 {
 390         uint32_t blkbuf[howmany(AES_BLOCK_LEN, sizeof(uint32_t))];
 391         u_char *blk = (u_char *)blkbuf;
 392         u_char tag[GMAC_DIGEST_LEN];
 393         u_char iv[AES_BLOCK_LEN];
 394         struct crypto_buffer_cursor cc;
 395         const u_char *inblk;
 396         union authctx ctx;
 397         struct swcr_auth *swa;
 398         struct auth_hash *axf;
 399         uint32_t *blkp;
 400         int blksz, error, ivlen, len, resid;
 401
 402         swa = &ses->swcr_auth;
 403         axf = swa->sw_axf;
 404
 405         bcopy(swa->sw_ictx, &ctx, axf->ctxsize);
 406         blksz = GMAC_BLOCK_LEN;
 407         KASSERT(axf->blocksize == blksz, ("%s: axf block size mismatch",
 408             __func__));
 409
 410         /* Initialize the IV */
 411         ivlen = AES_GCM_IV_LEN;
 412         crypto_read_iv(crp, iv);
 413
 414         axf->Reinit(&ctx, iv, ivlen);
 415         crypto_cursor_init(&cc, &crp->crp_buf);
 416         crypto_cursor_advance(&cc, crp->crp_payload_start);
 417         for (resid = crp->crp_payload_length; resid >= blksz; resid -= len) {
 418                 len = crypto_cursor_seglen(&cc);
 419                 if (len >= blksz) {
 420                         inblk = crypto_cursor_segbase(&cc);
 421                         len = rounddown(MIN(len, resid), blksz);
 422                         crypto_cursor_advance(&cc, len);
 423                 } else {
 424                         len = blksz;
 425                         crypto_cursor_copydata(&cc, len, blk);
 426                         inblk = blk;
 427                 }
 428                 axf->Update(&ctx, inblk, len);
 429         }
 430         if (resid > 0) {
 431                 memset(blk, 0, blksz);
 432                 crypto_cursor_copydata(&cc, resid, blk);
 433                 axf->Update(&ctx, blk, blksz);
 434         }
 435
 436         /* length block */
 437         memset(blk, 0, blksz);
 438         blkp = (uint32_t *)blk + 1;
 439         *blkp = htobe32(crp->crp_payload_length * 8);
 440         axf->Update(&ctx, blk, blksz);
 441
 442         /* Finalize MAC */
 443         axf->Final(tag, &ctx);
 444
 445         error = 0;
 446         if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
 447                 u_char tag2[GMAC_DIGEST_LEN];
 448
 449                 crypto_copydata(crp, crp->crp_digest_start, swa->sw_mlen,
 450                     tag2);
 451                 if (timingsafe_bcmp(tag, tag2, swa->sw_mlen) != 0)
 452                         error = EBADMSG;
 453                 explicit_bzero(tag2, sizeof(tag2));
 454         } else {
 455                 /* Inject the authentication data */
 456                 crypto_copyback(crp, crp->crp_digest_start, swa->sw_mlen, tag);
 457         }
 458         explicit_bzero(blkbuf, sizeof(blkbuf));
 459         explicit_bzero(tag, sizeof(tag));
 460         explicit_bzero(iv, sizeof(iv));
 461         return (error);
 462 }
 463
 464 static int
 465 swcr_gcm(struct swcr_session *ses, struct cryptop *crp)
 466 {
 467         uint32_t blkbuf[howmany(AES_BLOCK_LEN, sizeof(uint32_t))];
 468         u_char *blk = (u_char *)blkbuf;
 469         u_char tag[GMAC_DIGEST_LEN];
 470         u_char iv[AES_BLOCK_LEN];
 471         struct crypto_buffer_cursor cc_in, cc_out;
 472         const u_char *inblk;
 473         u_char *outblk;
 474         union authctx ctx;
 475         struct swcr_auth *swa;
 476         struct swcr_encdec *swe;
 477         struct auth_hash *axf;
 478         struct enc_xform *exf;
 479         uint32_t *blkp;
 480         int blksz, error, ivlen, len, r, resid;
 481
 482         swa = &ses->swcr_auth;
 483         axf = swa->sw_axf;
 484
 485         bcopy(swa->sw_ictx, &ctx, axf->ctxsize);
 486         blksz = GMAC_BLOCK_LEN;
 487         KASSERT(axf->blocksize == blksz, ("%s: axf block size mismatch",
 488             __func__));
 489
 490         swe = &ses->swcr_encdec;
 491         exf = swe->sw_exf;
 492         KASSERT(axf->blocksize == exf->native_blocksize,
 493             ("%s: blocksize mismatch", __func__));
 494
 495         if ((crp->crp_flags & CRYPTO_F_IV_SEPARATE) == 0)
 496                 return (EINVAL);
 497
 498         /* Initialize the IV */
 499         ivlen = AES_GCM_IV_LEN;
 500         bcopy(crp->crp_iv, iv, ivlen);
 501
 502         /* Supply MAC with IV */
 503         axf->Reinit(&ctx, iv, ivlen);
 504
 505         /* Supply MAC with AAD */
 506         if (crp->crp_aad != NULL) {
 507                 len = rounddown(crp->crp_aad_length, blksz);
 508                 if (len != 0)
 509                         axf->Update(&ctx, crp->crp_aad, len);
 510                 if (crp->crp_aad_length != len) {
 511                         memset(blk, 0, blksz);
 512                         memcpy(blk, (char *)crp->crp_aad + len,
 513                             crp->crp_aad_length - len);
 514                         axf->Update(&ctx, blk, blksz);
 515                 }
 516         } else {
 517                 crypto_cursor_init(&cc_in, &crp->crp_buf);
 518                 crypto_cursor_advance(&cc_in, crp->crp_aad_start);
 519                 for (resid = crp->crp_aad_length; resid >= blksz;
 520                      resid -= len) {
 521                         len = crypto_cursor_seglen(&cc_in);
 522                         if (len >= blksz) {
 523                                 inblk = crypto_cursor_segbase(&cc_in);
 524                                 len = rounddown(MIN(len, resid), blksz);
 525                                 crypto_cursor_advance(&cc_in, len);
 526                         } else {
 527                                 len = blksz;
 528                                 crypto_cursor_copydata(&cc_in, len, blk);
 529                                 inblk = blk;
 530                         }
 531                         axf->Update(&ctx, inblk, len);
 532                 }
 533                 if (resid > 0) {
 534                         memset(blk, 0, blksz);
 535                         crypto_cursor_copydata(&cc_in, resid, blk);
 536                         axf->Update(&ctx, blk, blksz);
 537                 }
 538         }
 539
 540         exf->reinit(swe->sw_kschedule, iv);
 541
 542         /* Do encryption with MAC */
 543         crypto_cursor_init(&cc_in, &crp->crp_buf);
 544         crypto_cursor_advance(&cc_in, crp->crp_payload_start);
 545         if (CRYPTO_HAS_OUTPUT_BUFFER(crp)) {
 546                 crypto_cursor_init(&cc_out, &crp->crp_obuf);
 547                 crypto_cursor_advance(&cc_out, crp->crp_payload_output_start);
 548         } else
 549                 cc_out = cc_in;
 550         for (resid = crp->crp_payload_length; resid >= blksz; resid -= blksz) {
 551                 if (crypto_cursor_seglen(&cc_in) < blksz) {
 552                         crypto_cursor_copydata(&cc_in, blksz, blk);
 553                         inblk = blk;
 554                 } else {
 555                         inblk = crypto_cursor_segbase(&cc_in);
 556                         crypto_cursor_advance(&cc_in, blksz);
 557                 }
 558                 if (CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
 559                         if (crypto_cursor_seglen(&cc_out) < blksz)
 560                                 outblk = blk;
 561                         else
 562                                 outblk = crypto_cursor_segbase(&cc_out);
 563                         exf->encrypt(swe->sw_kschedule, inblk, outblk);
 564                         axf->Update(&ctx, outblk, blksz);
 565                         if (outblk == blk)
 566                                 crypto_cursor_copyback(&cc_out, blksz, blk);
 567                         else
 568                                 crypto_cursor_advance(&cc_out, blksz);
 569                 } else {
 570                         axf->Update(&ctx, inblk, blksz);
 571                 }
 572         }
 573         if (resid > 0) {
 574                 crypto_cursor_copydata(&cc_in, resid, blk);
 575                 if (CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
 576                         exf->encrypt_last(swe->sw_kschedule, blk, blk, resid);
 577                         crypto_cursor_copyback(&cc_out, resid, blk);
 578                 }
 579                 axf->Update(&ctx, blk, resid);
 580         }
 581
 582         /* length block */
 583         memset(blk, 0, blksz);
 584         blkp = (uint32_t *)blk + 1;
 585         *blkp = htobe32(crp->crp_aad_length * 8);
 586         blkp = (uint32_t *)blk + 3;
 587         *blkp = htobe32(crp->crp_payload_length * 8);
 588         axf->Update(&ctx, blk, blksz);
 589
 590         /* Finalize MAC */
 591         axf->Final(tag, &ctx);
 592
 593         /* Validate tag */
 594         error = 0;
 595         if (!CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
 596                 u_char tag2[GMAC_DIGEST_LEN];
 597
 598                 crypto_copydata(crp, crp->crp_digest_start, swa->sw_mlen, tag2);
 599
 600                 r = timingsafe_bcmp(tag, tag2, swa->sw_mlen);
 601                 explicit_bzero(tag2, sizeof(tag2));
 602                 if (r != 0) {
 603                         error = EBADMSG;
 604                         goto out;
 605                 }
 606
 607                 /* tag matches, decrypt data */
 608                 crypto_cursor_init(&cc_in, &crp->crp_buf);
 609                 crypto_cursor_advance(&cc_in, crp->crp_payload_start);
 610                 for (resid = crp->crp_payload_length; resid > blksz;
 611                      resid -= blksz) {
 612                         if (crypto_cursor_seglen(&cc_in) < blksz) {
 613                                 crypto_cursor_copydata(&cc_in, blksz, blk);
 614                                 inblk = blk;
 615                         } else {
 616                                 inblk = crypto_cursor_segbase(&cc_in);
 617                                 crypto_cursor_advance(&cc_in, blksz);
 618                         }
 619                         if (crypto_cursor_seglen(&cc_out) < blksz)
 620                                 outblk = blk;
 621                         else
 622                                 outblk = crypto_cursor_segbase(&cc_out);
 623                         exf->decrypt(swe->sw_kschedule, inblk, outblk);
 624                         if (outblk == blk)
 625                                 crypto_cursor_copyback(&cc_out, blksz, blk);
 626                         else
 627                                 crypto_cursor_advance(&cc_out, blksz);
 628                 }
 629                 if (resid > 0) {
 630                         crypto_cursor_copydata(&cc_in, resid, blk);
 631                         exf->decrypt_last(swe->sw_kschedule, blk, blk, resid);
 632                         crypto_cursor_copyback(&cc_out, resid, blk);
 633                 }
 634         } else {
 635                 /* Inject the authentication data */
 636                 crypto_copyback(crp, crp->crp_digest_start, swa->sw_mlen, tag);
 637         }
 638
 639 out:
 640         explicit_bzero(blkbuf, sizeof(blkbuf));
 641         explicit_bzero(tag, sizeof(tag));
 642         explicit_bzero(iv, sizeof(iv));
 643
 644         return (error);
 645 }
 646
 647 static int
 648 swcr_ccm_cbc_mac(struct swcr_session *ses, struct cryptop *crp)
 649 {
 650         u_char tag[AES_CBC_MAC_HASH_LEN];
 651         u_char iv[AES_BLOCK_LEN];
 652         union authctx ctx;
 653         struct swcr_auth *swa;
 654         struct auth_hash *axf;
 655         int error, ivlen;
 656
 657         swa = &ses->swcr_auth;
 658         axf = swa->sw_axf;
 659
 660         bcopy(swa->sw_ictx, &ctx, axf->ctxsize);
 661
 662         /* Initialize the IV */
 663         ivlen = AES_CCM_IV_LEN;
 664         crypto_read_iv(crp, iv);
 665
 666         /*
 667          * AES CCM-CBC-MAC needs to know the length of both the auth
 668          * data and payload data before doing the auth computation.
 669          */
 670         ctx.aes_cbc_mac_ctx.authDataLength = crp->crp_payload_length;
 671         ctx.aes_cbc_mac_ctx.cryptDataLength = 0;
 672
 673         axf->Reinit(&ctx, iv, ivlen);
 674         if (crp->crp_aad != NULL)
 675                 error = axf->Update(&ctx, crp->crp_aad, crp->crp_aad_length);
 676         else
 677                 error = crypto_apply(crp, crp->crp_payload_start,
 678                     crp->crp_payload_length, axf->Update, &ctx);
 679         if (error)
 680                 return (error);
 681
 682         /* Finalize MAC */
 683         axf->Final(tag, &ctx);
 684
 685         if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
 686                 u_char tag2[AES_CBC_MAC_HASH_LEN];
 687
 688                 crypto_copydata(crp, crp->crp_digest_start, swa->sw_mlen,
 689                     tag2);
 690                 if (timingsafe_bcmp(tag, tag2, swa->sw_mlen) != 0)
 691                         error = EBADMSG;
 692                 explicit_bzero(tag2, sizeof(tag));
 693         } else {
 694                 /* Inject the authentication data */
 695                 crypto_copyback(crp, crp->crp_digest_start, swa->sw_mlen, tag);
 696         }
 697         explicit_bzero(tag, sizeof(tag));
 698         explicit_bzero(iv, sizeof(iv));
 699         return (error);
 700 }
 701
 702 static int
 703 swcr_ccm(struct swcr_session *ses, struct cryptop *crp)
 704 {
 705         uint32_t blkbuf[howmany(AES_BLOCK_LEN, sizeof(uint32_t))];
 706         u_char *blk = (u_char *)blkbuf;
 707         u_char tag[AES_CBC_MAC_HASH_LEN];
 708         u_char iv[AES_BLOCK_LEN];
 709         struct crypto_buffer_cursor cc_in, cc_out;
 710         const u_char *inblk;
 711         u_char *outblk;
 712         union authctx ctx;
 713         struct swcr_auth *swa;
 714         struct swcr_encdec *swe;
 715         struct auth_hash *axf;
 716         struct enc_xform *exf;
 717         int blksz, error, ivlen, r, resid;
 718
 719         swa = &ses->swcr_auth;
 720         axf = swa->sw_axf;
 721
 722         bcopy(swa->sw_ictx, &ctx, axf->ctxsize);
 723         blksz = AES_BLOCK_LEN;
 724         KASSERT(axf->blocksize == blksz, ("%s: axf block size mismatch",
 725             __func__));
 726
 727         swe = &ses->swcr_encdec;
 728         exf = swe->sw_exf;
 729         KASSERT(axf->blocksize == exf->native_blocksize,
 730             ("%s: blocksize mismatch", __func__));
 731
 732         if ((crp->crp_flags & CRYPTO_F_IV_SEPARATE) == 0)
 733                 return (EINVAL);
 734
 735         /* Initialize the IV */
 736         ivlen = AES_CCM_IV_LEN;
 737         bcopy(crp->crp_iv, iv, ivlen);
 738
 739         /*
 740          * AES CCM-CBC-MAC needs to know the length of both the auth
 741          * data and payload data before doing the auth computation.
 742          */
 743         ctx.aes_cbc_mac_ctx.authDataLength = crp->crp_aad_length;
 744         ctx.aes_cbc_mac_ctx.cryptDataLength = crp->crp_payload_length;
 745
 746         /* Supply MAC with IV */
 747         axf->Reinit(&ctx, iv, ivlen);
 748
 749         /* Supply MAC with AAD */
 750         if (crp->crp_aad != NULL)
 751                 error = axf->Update(&ctx, crp->crp_aad, crp->crp_aad_length);
 752         else
 753                 error = crypto_apply(crp, crp->crp_aad_start,
 754                     crp->crp_aad_length, axf->Update, &ctx);
 755         if (error)
 756                 return (error);
 757
 758         exf->reinit(swe->sw_kschedule, iv);
 759
 760         /* Do encryption/decryption with MAC */
 761         crypto_cursor_init(&cc_in, &crp->crp_buf);
 762         crypto_cursor_advance(&cc_in, crp->crp_payload_start);
 763         if (CRYPTO_HAS_OUTPUT_BUFFER(crp)) {
 764                 crypto_cursor_init(&cc_out, &crp->crp_obuf);
 765                 crypto_cursor_advance(&cc_out, crp->crp_payload_output_start);
 766         } else
 767                 cc_out = cc_in;
 768         for (resid = crp->crp_payload_length; resid >= blksz; resid -= blksz) {
 769                 if (crypto_cursor_seglen(&cc_in) < blksz) {
 770                         crypto_cursor_copydata(&cc_in, blksz, blk);
 771                         inblk = blk;
 772                 } else {
 773                         inblk = crypto_cursor_segbase(&cc_in);
 774                         crypto_cursor_advance(&cc_in, blksz);
 775                 }
 776                 if (CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
 777                         if (crypto_cursor_seglen(&cc_out) < blksz)
 778                                 outblk = blk;
 779                         else
 780                                 outblk = crypto_cursor_segbase(&cc_out);
 781                         axf->Update(&ctx, inblk, blksz);
 782                         exf->encrypt(swe->sw_kschedule, inblk, outblk);
 783                         if (outblk == blk)
 784                                 crypto_cursor_copyback(&cc_out, blksz, blk);
 785                         else
 786                                 crypto_cursor_advance(&cc_out, blksz);
 787                 } else {
 788                         /*
 789                          * One of the problems with CCM+CBC is that
 790                          * the authentication is done on the
 791                          * unencrypted data.  As a result, we have to
 792                          * decrypt the data twice: once to generate
 793                          * the tag and a second time after the tag is
 794                          * verified.
 795                          */
 796                         exf->decrypt(swe->sw_kschedule, inblk, blk);
 797                         axf->Update(&ctx, blk, blksz);
 798                 }
 799         }
 800         if (resid > 0) {
 801                 crypto_cursor_copydata(&cc_in, resid, blk);
 802                 if (CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
 803                         axf->Update(&ctx, blk, resid);
 804                         exf->encrypt_last(swe->sw_kschedule, blk, blk, resid);
 805                         crypto_cursor_copyback(&cc_out, resid, blk);
 806                 } else {
 807                         exf->decrypt_last(swe->sw_kschedule, blk, blk, resid);
 808                         axf->Update(&ctx, blk, resid);
 809                 }
 810         }
 811
 812         /* Finalize MAC */
 813         axf->Final(tag, &ctx);
 814
 815         /* Validate tag */
 816         error = 0;
 817         if (!CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
 818                 u_char tag2[AES_CBC_MAC_HASH_LEN];
 819
 820                 crypto_copydata(crp, crp->crp_digest_start, swa->sw_mlen,
 821                     tag2);
 822
 823                 r = timingsafe_bcmp(tag, tag2, swa->sw_mlen);
 824                 explicit_bzero(tag2, sizeof(tag2));
 825                 if (r != 0) {
 826                         error = EBADMSG;
 827                         goto out;
 828                 }
 829
 830                 /* tag matches, decrypt data */
 831                 exf->reinit(swe->sw_kschedule, iv);
 832                 crypto_cursor_init(&cc_in, &crp->crp_buf);
 833                 crypto_cursor_advance(&cc_in, crp->crp_payload_start);
 834                 for (resid = crp->crp_payload_length; resid > blksz;
 835                      resid -= blksz) {
 836                         if (crypto_cursor_seglen(&cc_in) < blksz) {
 837                                 crypto_cursor_copydata(&cc_in, blksz, blk);
 838                                 inblk = blk;
 839                         } else {
 840                                 inblk = crypto_cursor_segbase(&cc_in);
 841                                 crypto_cursor_advance(&cc_in, blksz);
 842                         }
 843                         if (crypto_cursor_seglen(&cc_out) < blksz)
 844                                 outblk = blk;
 845                         else
 846                                 outblk = crypto_cursor_segbase(&cc_out);
 847                         exf->decrypt(swe->sw_kschedule, inblk, outblk);
 848                         if (outblk == blk)
 849                                 crypto_cursor_copyback(&cc_out, blksz, blk);
 850                         else
 851                                 crypto_cursor_advance(&cc_out, blksz);
 852                 }
 853                 if (resid > 0) {
 854                         crypto_cursor_copydata(&cc_in, resid, blk);
 855                         exf->decrypt_last(swe->sw_kschedule, blk, blk, resid);
 856                         crypto_cursor_copyback(&cc_out, resid, blk);
 857                 }
 858         } else {
 859                 /* Inject the authentication data */
 860                 crypto_copyback(crp, crp->crp_digest_start, swa->sw_mlen, tag);
 861         }
 862
 863 out:
 864         explicit_bzero(blkbuf, sizeof(blkbuf));
 865         explicit_bzero(tag, sizeof(tag));
 866         explicit_bzero(iv, sizeof(iv));
 867         return (error);
 868 }
 869
 870 /*
 871  * Apply a cipher and a digest to perform EtA.
 872  */
 873 static int
 874 swcr_eta(struct swcr_session *ses, struct cryptop *crp)
 875 {
 876         int error;
 877
 878         if (CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
 879                 error = swcr_encdec(ses, crp);
 880                 if (error == 0)
 881                         error = swcr_authcompute(ses, crp);
 882         } else {
 883                 error = swcr_authcompute(ses, crp);
 884                 if (error == 0)
 885                         error = swcr_encdec(ses, crp);
 886         }
 887         return (error);
 888 }
 889
 890 /*
 891  * Apply a compression/decompression algorithm
 892  */
 893 static int
 894 swcr_compdec(struct swcr_session *ses, struct cryptop *crp)
 895 {
 896         uint8_t *data, *out;
 897         struct comp_algo *cxf;
 898         int adj;
 899         uint32_t result;
 900
 901         cxf = ses->swcr_compdec.sw_cxf;
 902
 903         /* We must handle the whole buffer of data in one time
 904          * then if there is not all the data in the mbuf, we must
 905          * copy in a buffer.
 906          */
 907
 908         data = malloc(crp->crp_payload_length, M_CRYPTO_DATA,  M_NOWAIT);
 909         if (data == NULL)
 910                 return (EINVAL);
 911         crypto_copydata(crp, crp->crp_payload_start, crp->crp_payload_length,
 912             data);
 913
 914         if (CRYPTO_OP_IS_COMPRESS(crp->crp_op))
 915                 result = cxf->compress(data, crp->crp_payload_length, &out);
 916         else
 917                 result = cxf->decompress(data, crp->crp_payload_length, &out);
 918
 919         free(data, M_CRYPTO_DATA);
 920         if (result == 0)
 921                 return (EINVAL);
 922         crp->crp_olen = result;
 923
 924         /* Check the compressed size when doing compression */
 925         if (CRYPTO_OP_IS_COMPRESS(crp->crp_op)) {
 926                 if (result >= crp->crp_payload_length) {
 927                         /* Compression was useless, we lost time */
 928                         free(out, M_CRYPTO_DATA);
 929                         return (0);
 930                 }
 931         }
 932
 933         /* Copy back the (de)compressed data. m_copyback is
 934          * extending the mbuf as necessary.
 935          */
 936         crypto_copyback(crp, crp->crp_payload_start, result, out);
 937         if (result < crp->crp_payload_length) {
 938                 switch (crp->crp_buf.cb_type) {
 939                 case CRYPTO_BUF_MBUF:
 940                         adj = result - crp->crp_payload_length;
 941                         m_adj(crp->crp_buf.cb_mbuf, adj);
 942                         break;
 943                 case CRYPTO_BUF_UIO: {
 944                         struct uio *uio = crp->crp_buf.cb_uio;
 945                         int ind;
 946
 947                         adj = crp->crp_payload_length - result;
 948                         ind = uio->uio_iovcnt - 1;
 949
 950                         while (adj > 0 && ind >= 0) {
 951                                 if (adj < uio->uio_iov[ind].iov_len) {
 952                                         uio->uio_iov[ind].iov_len -= adj;
 953                                         break;
 954                                 }
 955
 956                                 adj -= uio->uio_iov[ind].iov_len;
 957                                 uio->uio_iov[ind].iov_len = 0;
 958                                 ind--;
 959                                 uio->uio_iovcnt--;
 960                         }
 961                         }
 962                         break;
 963                 case CRYPTO_BUF_VMPAGE:
 964                         adj = crp->crp_payload_length - result;
 965                         crp->crp_buf.cb_vm_page_len -= adj;
 966                         break;
 967                 default:
 968                         break;
 969                 }
 970         }
 971         free(out, M_CRYPTO_DATA);
 972         return 0;
 973 }
 974
 975 static int
 976 swcr_setup_cipher(struct swcr_session *ses,
 977     const struct crypto_session_params *csp)
 978 {
 979         struct swcr_encdec *swe;
 980         struct enc_xform *txf;
 981         int error;
 982
 983         swe = &ses->swcr_encdec;
 984         txf = crypto_cipher(csp);
 985         MPASS(txf->ivsize == csp->csp_ivlen);
 986         if (txf->ctxsize != 0) {
 987                 swe->sw_kschedule = malloc(txf->ctxsize, M_CRYPTO_DATA,
 988                     M_NOWAIT);
 989                 if (swe->sw_kschedule == NULL)
 990                         return (ENOMEM);
 991         }
 992         if (csp->csp_cipher_key != NULL) {
 993                 error = txf->setkey(swe->sw_kschedule,
 994                     csp->csp_cipher_key, csp->csp_cipher_klen);
 995                 if (error)
 996                         return (error);
 997         }
 998         swe->sw_exf = txf;
 999         return (0);
1000 }
1001
1002 static int
1003 swcr_setup_auth(struct swcr_session *ses,
1004     const struct crypto_session_params *csp)
1005 {
1006         struct swcr_auth *swa;
1007         struct auth_hash *axf;
1008
1009         swa = &ses->swcr_auth;
1010
1011         axf = crypto_auth_hash(csp);
1012         swa->sw_axf = axf;
1013         if (csp->csp_auth_mlen < 0 || csp->csp_auth_mlen > axf->hashsize)
1014                 return (EINVAL);
1015         if (csp->csp_auth_mlen == 0)
1016                 swa->sw_mlen = axf->hashsize;
1017         else
1018                 swa->sw_mlen = csp->csp_auth_mlen;
1019         swa->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, M_NOWAIT);
1020         if (swa->sw_ictx == NULL)
1021                 return (ENOBUFS);
1022
1023         switch (csp->csp_auth_alg) {
1024         case CRYPTO_SHA1_HMAC:
1025         case CRYPTO_SHA2_224_HMAC:
1026         case CRYPTO_SHA2_256_HMAC:
1027         case CRYPTO_SHA2_384_HMAC:
1028         case CRYPTO_SHA2_512_HMAC:
1029         case CRYPTO_NULL_HMAC:
1030         case CRYPTO_RIPEMD160_HMAC:
1031                 swa->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA,
1032                     M_NOWAIT);
1033                 if (swa->sw_octx == NULL)
1034                         return (ENOBUFS);
1035
1036                 if (csp->csp_auth_key != NULL) {
1037                         swcr_authprepare(axf, swa, csp->csp_auth_key,
1038                             csp->csp_auth_klen);
1039                 }
1040
1041                 if (csp->csp_mode == CSP_MODE_DIGEST)
1042                         ses->swcr_process = swcr_authcompute;
1043                 break;
1044         case CRYPTO_SHA1:
1045         case CRYPTO_SHA2_224:
1046         case CRYPTO_SHA2_256:
1047         case CRYPTO_SHA2_384:
1048         case CRYPTO_SHA2_512:
1049                 axf->Init(swa->sw_ictx);
1050                 if (csp->csp_mode == CSP_MODE_DIGEST)
1051                         ses->swcr_process = swcr_authcompute;
1052                 break;
1053         case CRYPTO_AES_NIST_GMAC:
1054                 axf->Init(swa->sw_ictx);
1055                 axf->Setkey(swa->sw_ictx, csp->csp_auth_key,
1056                     csp->csp_auth_klen);
1057                 if (csp->csp_mode == CSP_MODE_DIGEST)
1058                         ses->swcr_process = swcr_gmac;
1059                 break;
1060         case CRYPTO_POLY1305:
1061         case CRYPTO_BLAKE2B:
1062         case CRYPTO_BLAKE2S:
1063                 /*
1064                  * Blake2b and Blake2s support an optional key but do
1065                  * not require one.
1066                  */
1067                 if (csp->csp_auth_klen == 0 || csp->csp_auth_key != NULL)
1068                         axf->Setkey(swa->sw_ictx, csp->csp_auth_key,
1069                             csp->csp_auth_klen);
1070                 axf->Init(swa->sw_ictx);
1071                 if (csp->csp_mode == CSP_MODE_DIGEST)
1072                         ses->swcr_process = swcr_authcompute;
1073                 break;
1074         case CRYPTO_AES_CCM_CBC_MAC:
1075                 axf->Init(swa->sw_ictx);
1076                 axf->Setkey(swa->sw_ictx, csp->csp_auth_key,
1077                     csp->csp_auth_klen);
1078                 if (csp->csp_mode == CSP_MODE_DIGEST)
1079                         ses->swcr_process = swcr_ccm_cbc_mac;
1080                 break;
1081         }
1082
1083         return (0);
1084 }
1085
1086 static int
1087 swcr_setup_gcm(struct swcr_session *ses,
1088     const struct crypto_session_params *csp)
1089 {
1090         struct swcr_auth *swa;
1091         struct auth_hash *axf;
1092
1093         if (csp->csp_ivlen != AES_GCM_IV_LEN)
1094                 return (EINVAL);
1095
1096         /* First, setup the auth side. */
1097         swa = &ses->swcr_auth;
1098         switch (csp->csp_cipher_klen * 8) {
1099         case 128:
1100                 axf = &auth_hash_nist_gmac_aes_128;
1101                 break;
1102         case 192:
1103                 axf = &auth_hash_nist_gmac_aes_192;
1104                 break;
1105         case 256:
1106                 axf = &auth_hash_nist_gmac_aes_256;
1107                 break;
1108         default:
1109                 return (EINVAL);
1110         }
1111         swa->sw_axf = axf;
1112         if (csp->csp_auth_mlen < 0 || csp->csp_auth_mlen > axf->hashsize)
1113                 return (EINVAL);
1114         if (csp->csp_auth_mlen == 0)
1115                 swa->sw_mlen = axf->hashsize;
1116         else
1117                 swa->sw_mlen = csp->csp_auth_mlen;
1118         swa->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, M_NOWAIT);
1119         if (swa->sw_ictx == NULL)
1120                 return (ENOBUFS);
1121         axf->Init(swa->sw_ictx);
1122         if (csp->csp_cipher_key != NULL)
1123                 axf->Setkey(swa->sw_ictx, csp->csp_cipher_key,
1124                     csp->csp_cipher_klen);
1125
1126         /* Second, setup the cipher side. */
1127         return (swcr_setup_cipher(ses, csp));
1128 }
1129
1130 static int
1131 swcr_setup_ccm(struct swcr_session *ses,
1132     const struct crypto_session_params *csp)
1133 {
1134         struct swcr_auth *swa;
1135         struct auth_hash *axf;
1136
1137         if (csp->csp_ivlen != AES_CCM_IV_LEN)
1138                 return (EINVAL);
1139
1140         /* First, setup the auth side. */
1141         swa = &ses->swcr_auth;
1142         switch (csp->csp_cipher_klen * 8) {
1143         case 128:
1144                 axf = &auth_hash_ccm_cbc_mac_128;
1145                 break;
1146         case 192:
1147                 axf = &auth_hash_ccm_cbc_mac_192;
1148                 break;
1149         case 256:
1150                 axf = &auth_hash_ccm_cbc_mac_256;
1151                 break;
1152         default:
1153                 return (EINVAL);
1154         }
1155         swa->sw_axf = axf;
1156         if (csp->csp_auth_mlen < 0 || csp->csp_auth_mlen > axf->hashsize)
1157                 return (EINVAL);
1158         if (csp->csp_auth_mlen == 0)
1159                 swa->sw_mlen = axf->hashsize;
1160         else
1161                 swa->sw_mlen = csp->csp_auth_mlen;
1162         swa->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, M_NOWAIT);
1163         if (swa->sw_ictx == NULL)
1164                 return (ENOBUFS);
1165         axf->Init(swa->sw_ictx);
1166         if (csp->csp_cipher_key != NULL)
1167                 axf->Setkey(swa->sw_ictx, csp->csp_cipher_key,
1168                     csp->csp_cipher_klen);
1169
1170         /* Second, setup the cipher side. */
1171         return (swcr_setup_cipher(ses, csp));
1172 }
1173
1174 static bool
1175 swcr_auth_supported(const struct crypto_session_params *csp)
1176 {
1177         struct auth_hash *axf;
1178
1179         axf = crypto_auth_hash(csp);
1180         if (axf == NULL)
1181                 return (false);
1182         switch (csp->csp_auth_alg) {
1183         case CRYPTO_SHA1_HMAC:
1184         case CRYPTO_SHA2_224_HMAC:
1185         case CRYPTO_SHA2_256_HMAC:
1186         case CRYPTO_SHA2_384_HMAC:
1187         case CRYPTO_SHA2_512_HMAC:
1188         case CRYPTO_NULL_HMAC:
1189         case CRYPTO_RIPEMD160_HMAC:
1190                 break;
1191         case CRYPTO_AES_NIST_GMAC:
1192                 switch (csp->csp_auth_klen * 8) {
1193                 case 128:
1194                 case 192:
1195                 case 256:
1196                         break;
1197                 default:
1198                         return (false);
1199                 }
1200                 if (csp->csp_auth_key == NULL)
1201                         return (false);
1202                 if (csp->csp_ivlen != AES_GCM_IV_LEN)
1203                         return (false);
1204                 break;
1205         case CRYPTO_POLY1305:
1206                 if (csp->csp_auth_klen != POLY1305_KEY_LEN)
1207                         return (false);
1208                 break;
1209         case CRYPTO_AES_CCM_CBC_MAC:
1210                 switch (csp->csp_auth_klen * 8) {
1211                 case 128:
1212                 case 192:
1213                 case 256:
1214                         break;
1215                 default:
1216                         return (false);
1217                 }
1218                 if (csp->csp_auth_key == NULL)
1219                         return (false);
1220                 if (csp->csp_ivlen != AES_CCM_IV_LEN)
1221                         return (false);
1222                 break;
1223         }
1224         return (true);
1225 }
1226
1227 static bool
1228 swcr_cipher_supported(const struct crypto_session_params *csp)
1229 {
1230         struct enc_xform *txf;
1231
1232         txf = crypto_cipher(csp);
1233         if (txf == NULL)
1234                 return (false);
1235         if (csp->csp_cipher_alg != CRYPTO_NULL_CBC &&
1236             txf->ivsize != csp->csp_ivlen)
1237                 return (false);
1238         return (true);
1239 }
1240
1241 #define SUPPORTED_SES (CSP_F_SEPARATE_OUTPUT | CSP_F_SEPARATE_AAD | CSP_F_ESN)
1242
1243 static int
1244 swcr_probesession(device_t dev, const struct crypto_session_params *csp)
1245 {
1246         if ((csp->csp_flags & ~(SUPPORTED_SES)) != 0)
1247                 return (EINVAL);
1248         switch (csp->csp_mode) {
1249         case CSP_MODE_COMPRESS:
1250                 switch (csp->csp_cipher_alg) {
1251                 case CRYPTO_DEFLATE_COMP:
1252                         break;
1253                 default:
1254                         return (EINVAL);
1255                 }
1256                 break;
1257         case CSP_MODE_CIPHER:
1258                 switch (csp->csp_cipher_alg) {
1259                 case CRYPTO_AES_NIST_GCM_16:
1260                 case CRYPTO_AES_CCM_16:
1261                         return (EINVAL);
1262                 default:
1263                         if (!swcr_cipher_supported(csp))
1264                                 return (EINVAL);
1265                         break;
1266                 }
1267                 break;
1268         case CSP_MODE_DIGEST:
1269                 if (!swcr_auth_supported(csp))
1270                         return (EINVAL);
1271                 break;
1272         case CSP_MODE_AEAD:
1273                 switch (csp->csp_cipher_alg) {
1274                 case CRYPTO_AES_NIST_GCM_16:
1275                 case CRYPTO_AES_CCM_16:
1276                         break;
1277                 default:
1278                         return (EINVAL);
1279                 }
1280                 break;
1281         case CSP_MODE_ETA:
1282                 /* AEAD algorithms cannot be used for EtA. */
1283                 switch (csp->csp_cipher_alg) {
1284                 case CRYPTO_AES_NIST_GCM_16:
1285                 case CRYPTO_AES_CCM_16:
1286                         return (EINVAL);
1287                 }
1288                 switch (csp->csp_auth_alg) {
1289                 case CRYPTO_AES_NIST_GMAC:
1290                 case CRYPTO_AES_CCM_CBC_MAC:
1291                         return (EINVAL);
1292                 }
1293
1294                 if (!swcr_cipher_supported(csp) ||
1295                     !swcr_auth_supported(csp))
1296                         return (EINVAL);
1297                 break;
1298         default:
1299                 return (EINVAL);
1300         }
1301
1302         return (CRYPTODEV_PROBE_SOFTWARE);
1303 }
1304
1305 /*
1306  * Generate a new software session.
1307  */
1308 static int
1309 swcr_newsession(device_t dev, crypto_session_t cses,
1310     const struct crypto_session_params *csp)
1311 {
1312         struct swcr_session *ses;
1313         struct swcr_encdec *swe;
1314         struct swcr_auth *swa;
1315         struct comp_algo *cxf;
1316         int error;
1317
1318         ses = crypto_get_driver_session(cses);
1319         mtx_init(&ses->swcr_lock, "swcr session lock", NULL, MTX_DEF);
1320
1321         error = 0;
1322         swe = &ses->swcr_encdec;
1323         swa = &ses->swcr_auth;
1324         switch (csp->csp_mode) {
1325         case CSP_MODE_COMPRESS:
1326                 switch (csp->csp_cipher_alg) {
1327                 case CRYPTO_DEFLATE_COMP:
1328                         cxf = &comp_algo_deflate;
1329                         break;
1330 #ifdef INVARIANTS
1331                 default:
1332                         panic("bad compression algo");
1333 #endif
1334                 }
1335                 ses->swcr_compdec.sw_cxf = cxf;
1336                 ses->swcr_process = swcr_compdec;
1337                 break;
1338         case CSP_MODE_CIPHER:
1339                 switch (csp->csp_cipher_alg) {
1340                 case CRYPTO_NULL_CBC:
1341                         ses->swcr_process = swcr_null;
1342                         break;
1343 #ifdef INVARIANTS
1344                 case CRYPTO_AES_NIST_GCM_16:
1345                 case CRYPTO_AES_CCM_16:
1346                         panic("bad cipher algo");
1347 #endif
1348                 default:
1349                         error = swcr_setup_cipher(ses, csp);
1350                         if (error == 0)
1351                                 ses->swcr_process = swcr_encdec;
1352                 }
1353                 break;
1354         case CSP_MODE_DIGEST:
1355                 error = swcr_setup_auth(ses, csp);
1356                 break;
1357         case CSP_MODE_AEAD:
1358                 switch (csp->csp_cipher_alg) {
1359                 case CRYPTO_AES_NIST_GCM_16:
1360                         error = swcr_setup_gcm(ses, csp);
1361                         if (error == 0)
1362                                 ses->swcr_process = swcr_gcm;
1363                         break;
1364                 case CRYPTO_AES_CCM_16:
1365                         error = swcr_setup_ccm(ses, csp);
1366                         if (error == 0)
1367                                 ses->swcr_process = swcr_ccm;
1368                         break;
1369 #ifdef INVARIANTS
1370                 default:
1371                         panic("bad aead algo");
1372 #endif
1373                 }
1374                 break;
1375         case CSP_MODE_ETA:
1376 #ifdef INVARIANTS
1377                 switch (csp->csp_cipher_alg) {
1378                 case CRYPTO_AES_NIST_GCM_16:
1379                 case CRYPTO_AES_CCM_16:
1380                         panic("bad eta cipher algo");
1381                 }
1382                 switch (csp->csp_auth_alg) {
1383                 case CRYPTO_AES_NIST_GMAC:
1384                 case CRYPTO_AES_CCM_CBC_MAC:
1385                         panic("bad eta auth algo");
1386                 }
1387 #endif
1388
1389                 error = swcr_setup_auth(ses, csp);
1390                 if (error)
1391                         break;
1392                 if (csp->csp_cipher_alg == CRYPTO_NULL_CBC) {
1393                         /* Effectively degrade to digest mode. */
1394                         ses->swcr_process = swcr_authcompute;
1395                         break;
1396                 }
1397
1398                 error = swcr_setup_cipher(ses, csp);
1399                 if (error == 0)
1400                         ses->swcr_process = swcr_eta;
1401                 break;
1402         default:
1403                 error = EINVAL;
1404         }
1405
1406         if (error)
1407                 swcr_freesession(dev, cses);
1408         return (error);
1409 }
1410
1411 static void
1412 swcr_freesession(device_t dev, crypto_session_t cses)
1413 {
1414         struct swcr_session *ses;
1415
1416         ses = crypto_get_driver_session(cses);
1417
1418         mtx_destroy(&ses->swcr_lock);
1419
1420         zfree(ses->swcr_encdec.sw_kschedule, M_CRYPTO_DATA);
1421         zfree(ses->swcr_auth.sw_ictx, M_CRYPTO_DATA);
1422         zfree(ses->swcr_auth.sw_octx, M_CRYPTO_DATA);
1423 }
1424
1425 /*
1426  * Process a software request.
1427  */
1428 static int
1429 swcr_process(device_t dev, struct cryptop *crp, int hint)
1430 {
1431         struct swcr_session *ses;
1432
1433         ses = crypto_get_driver_session(crp->crp_session);
1434         mtx_lock(&ses->swcr_lock);
1435
1436         crp->crp_etype = ses->swcr_process(ses, crp);
1437
1438         mtx_unlock(&ses->swcr_lock);
1439         crypto_done(crp);
1440         return (0);
1441 }
1442
1443 static void
1444 swcr_identify(driver_t *drv, device_t parent)
1445 {
1446         /* NB: order 10 is so we get attached after h/w devices */
1447         if (device_find_child(parent, "cryptosoft", -1) == NULL &&
1448             BUS_ADD_CHILD(parent, 10, "cryptosoft", 0) == 0)
1449                 panic("cryptosoft: could not attach");
1450 }
1451
1452 static int
1453 swcr_probe(device_t dev)
1454 {
1455         device_set_desc(dev, "software crypto");
1456         return (BUS_PROBE_NOWILDCARD);
1457 }
1458
1459 static int
1460 swcr_attach(device_t dev)
1461 {
1462
1463         swcr_id = crypto_get_driverid(dev, sizeof(struct swcr_session),
1464                         CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_SYNC);
1465         if (swcr_id < 0) {
1466                 device_printf(dev, "cannot initialize!");
1467                 return (ENXIO);
1468         }
1469
1470         return (0);
1471 }
1472
1473 static int
1474 swcr_detach(device_t dev)
1475 {
1476         crypto_unregister_all(swcr_id);
1477         return 0;
1478 }
1479
1480 static device_method_t swcr_methods[] = {
1481         DEVMETHOD(device_identify,      swcr_identify),
1482         DEVMETHOD(device_probe,         swcr_probe),
1483         DEVMETHOD(device_attach,        swcr_attach),
1484         DEVMETHOD(device_detach,        swcr_detach),
1485
1486         DEVMETHOD(cryptodev_probesession, swcr_probesession),
1487         DEVMETHOD(cryptodev_newsession, swcr_newsession),
1488         DEVMETHOD(cryptodev_freesession,swcr_freesession),
1489         DEVMETHOD(cryptodev_process,    swcr_process),
1490
1491         {0, 0},
1492 };
1493
1494 static driver_t swcr_driver = {
1495         "cryptosoft",
1496         swcr_methods,
1497         0,              /* NB: no softc */
1498 };
1499 static devclass_t swcr_devclass;
1500
1501 /*
1502  * NB: We explicitly reference the crypto module so we
1503  * get the necessary ordering when built as a loadable
1504  * module.  This is required because we bundle the crypto
1505  * module code together with the cryptosoft driver (otherwise
1506  * normal module dependencies would handle things).
1507  */
1508 extern int crypto_modevent(struct module *, int, void *);
1509 /* XXX where to attach */
1510 DRIVER_MODULE(cryptosoft, nexus, swcr_driver, swcr_devclass, crypto_modevent,0);
1511 MODULE_VERSION(cryptosoft, 1);
1512 MODULE_DEPEND(cryptosoft, crypto, 1, 1, 1);