sys/opencrypto/cryptodev.c

   1 /*      $FreeBSD: src/sys/opencrypto/cryptodev.c,v 1.4.2.4 2003/06/03 00:09:02 sam Exp $        */
   2 /*      $DragonFly: src/sys/opencrypto/cryptodev.c,v 1.17 2006/05/26 15:55:13 dillon Exp $      */
   3 /*      $OpenBSD: cryptodev.c,v 1.52 2002/06/19 07:22:46 deraadt Exp $  */
   4
   5 /*
   6  * Copyright (c) 2001 Theo de Raadt
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *   notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *   notice, this list of conditions and the following disclaimer in the
  16  *   documentation and/or other materials provided with the distribution.
  17  * 3. The name of the author may not be used to endorse or promote products
  18  *   derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * Effort sponsored in part by the Defense Advanced Research Projects
  32  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  33  * Materiel Command, USAF, under agreement number F30602-01-2-0537.
  34  *
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/malloc.h>
  40 #include <sys/mbuf.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/file.h>
  43 #include <sys/lock.h>
  44 #include <sys/filedesc.h>
  45 #include <sys/errno.h>
  46 #include <sys/uio.h>
  47 #include <sys/random.h>
  48 #include <sys/conf.h>
  49 #include <sys/kernel.h>
  50 #include <sys/fcntl.h>
  51 #include <sys/proc.h>
  52 #include <sys/file2.h>
  53 #include <sys/thread2.h>
  54
  55 #include <opencrypto/cryptodev.h>
  56 #include <opencrypto/xform.h>
  57
  58 struct csession {
  59         TAILQ_ENTRY(csession) next;
  60         u_int64_t       sid;
  61         u_int32_t       ses;
  62
  63         u_int32_t       cipher;
  64         struct enc_xform *txform;
  65         u_int32_t       mac;
  66         struct auth_hash *thash;
  67
  68         caddr_t         key;
  69         int             keylen;
  70         u_char          tmp_iv[EALG_MAX_BLOCK_LEN];
  71
  72         caddr_t         mackey;
  73         int             mackeylen;
  74         u_char          tmp_mac[CRYPTO_MAX_MAC_LEN];
  75
  76         struct iovec    iovec[UIO_MAXIOV];
  77         struct uio      uio;
  78         int             error;
  79 };
  80
  81 struct fcrypt {
  82         TAILQ_HEAD(csessionlist, csession) csessions;
  83         int             sesn;
  84 };
  85
  86 static  int cryptof_rw(struct file *fp, struct uio *uio,
  87                     struct ucred *cred, int flags);
  88 static  int cryptof_ioctl(struct file *, u_long, caddr_t, struct ucred *);
  89 static  int cryptof_poll(struct file *, int, struct ucred *);
  90 static  int cryptof_kqfilter(struct file *, struct knote *);
  91 static  int cryptof_stat(struct file *, struct stat *, struct ucred *);
  92 static  int cryptof_close(struct file *);
  93
  94 static struct fileops cryptofops = {
  95     NULL,       /* port */
  96     NULL,       /* clone */
  97     cryptof_rw,
  98     cryptof_rw,
  99     cryptof_ioctl,
 100     cryptof_poll,
 101     cryptof_kqfilter,
 102     cryptof_stat,
 103     cryptof_close,
 104     nofo_shutdown
 105 };
 106
 107 static struct csession *csefind(struct fcrypt *, u_int);
 108 static int csedelete(struct fcrypt *, struct csession *);
 109 static struct csession *cseadd(struct fcrypt *, struct csession *);
 110 static struct csession *csecreate(struct fcrypt *, u_int64_t, caddr_t,
 111     u_int64_t, caddr_t, u_int64_t, u_int32_t, u_int32_t, struct enc_xform *,
 112     struct auth_hash *);
 113 static int csefree(struct csession *);
 114
 115 static  int cryptodev_op(struct csession *, struct crypt_op *);
 116 static  int cryptodev_key(struct crypt_kop *);
 117
 118 /*
 119  * MPSAFE
 120  */
 121 static int
 122 cryptof_rw(
 123         struct file *fp,
 124         struct uio *uio,
 125         struct ucred *active_cred,
 126         int flags)
 127 {
 128         return (EIO);
 129 }
 130
 131 /*
 132  * MPALMOSTSAFE - acquires mplock
 133  */
 134 static int
 135 cryptof_ioctl(
 136         struct file *fp,
 137         u_long cmd,
 138         caddr_t data,
 139         struct ucred *cred)
 140 {
 141         struct cryptoini cria, crie;
 142         struct fcrypt *fcr;
 143         struct csession *cse;
 144         struct session_op *sop;
 145         struct crypt_op *cop;
 146         struct enc_xform *txform = NULL;
 147         struct auth_hash *thash = NULL;
 148         u_int64_t sid;
 149         u_int32_t ses;
 150         int error = 0;
 151
 152         get_mplock();
 153         fcr = (struct fcrypt *)fp->f_data;
 154
 155         switch (cmd) {
 156         case CIOCGSESSION:
 157                 sop = (struct session_op *)data;
 158                 switch (sop->cipher) {
 159                 case 0:
 160                         break;
 161                 case CRYPTO_DES_CBC:
 162                         txform = &enc_xform_des;
 163                         break;
 164                 case CRYPTO_3DES_CBC:
 165                         txform = &enc_xform_3des;
 166                         break;
 167                 case CRYPTO_BLF_CBC:
 168                         txform = &enc_xform_blf;
 169                         break;
 170                 case CRYPTO_CAST_CBC:
 171                         txform = &enc_xform_cast5;
 172                         break;
 173                 case CRYPTO_SKIPJACK_CBC:
 174                         txform = &enc_xform_skipjack;
 175                         break;
 176                 case CRYPTO_AES_CBC:
 177                         txform = &enc_xform_rijndael128;
 178                         break;
 179                 case CRYPTO_NULL_CBC:
 180                         txform = &enc_xform_null;
 181                         break;
 182                 case CRYPTO_ARC4:
 183                         txform = &enc_xform_arc4;
 184                         break;
 185                 default:
 186                         error = EINVAL;
 187                         break;
 188                 }
 189                 if (error)
 190                         break;
 191
 192                 switch (sop->mac) {
 193                 case 0:
 194                         break;
 195                 case CRYPTO_MD5_HMAC:
 196                         thash = &auth_hash_hmac_md5_96;
 197                         break;
 198                 case CRYPTO_SHA1_HMAC:
 199                         thash = &auth_hash_hmac_sha1_96;
 200                         break;
 201                 case CRYPTO_SHA2_HMAC:
 202                         if (sop->mackeylen == auth_hash_hmac_sha2_256.keysize)
 203                                 thash = &auth_hash_hmac_sha2_256;
 204                         else if (sop->mackeylen == auth_hash_hmac_sha2_384.keysize)
 205                                 thash = &auth_hash_hmac_sha2_384;
 206                         else if (sop->mackeylen == auth_hash_hmac_sha2_512.keysize)
 207                                 thash = &auth_hash_hmac_sha2_512;
 208                         else {
 209                                 error = EINVAL;
 210                                 break;
 211                         }
 212                         break;
 213                 case CRYPTO_RIPEMD160_HMAC:
 214                         thash = &auth_hash_hmac_ripemd_160_96;
 215                         break;
 216 #ifdef notdef
 217                 case CRYPTO_MD5:
 218                         thash = &auth_hash_md5;
 219                         break;
 220                 case CRYPTO_SHA1:
 221                         thash = &auth_hash_sha1;
 222                         break;
 223 #endif
 224                 case CRYPTO_NULL_HMAC:
 225                         thash = &auth_hash_null;
 226                         break;
 227                 default:
 228                         error = EINVAL;
 229                         break;
 230                 }
 231                 if (error)
 232                         break;
 233
 234                 bzero(&crie, sizeof(crie));
 235                 bzero(&cria, sizeof(cria));
 236
 237                 if (txform) {
 238                         crie.cri_alg = txform->type;
 239                         crie.cri_klen = sop->keylen * 8;
 240                         if (sop->keylen > txform->maxkey ||
 241                             sop->keylen < txform->minkey) {
 242                                 error = EINVAL;
 243                                 goto bail;
 244                         }
 245
 246                         MALLOC(crie.cri_key, u_int8_t *,
 247                             crie.cri_klen / 8, M_XDATA, M_WAITOK);
 248                         if ((error = copyin(sop->key, crie.cri_key,
 249                             crie.cri_klen / 8)))
 250                                 goto bail;
 251                         if (thash)
 252                                 crie.cri_next = &cria;
 253                 }
 254
 255                 if (thash) {
 256                         cria.cri_alg = thash->type;
 257                         cria.cri_klen = sop->mackeylen * 8;
 258                         if (sop->mackeylen != thash->keysize) {
 259                                 error = EINVAL;
 260                                 goto bail;
 261                         }
 262
 263                         if (cria.cri_klen) {
 264                                 MALLOC(cria.cri_key, u_int8_t *,
 265                                     cria.cri_klen / 8, M_XDATA, M_WAITOK);
 266                                 if ((error = copyin(sop->mackey, cria.cri_key,
 267                                     cria.cri_klen / 8)))
 268                                         goto bail;
 269                         }
 270                 }
 271
 272                 error = crypto_newsession(&sid, (txform ? &crie : &cria), 1);
 273                 if (error)
 274                         goto bail;
 275
 276                 cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen,
 277                     cria.cri_key, cria.cri_klen, sop->cipher, sop->mac, txform,
 278                     thash);
 279
 280                 if (cse == NULL) {
 281                         crypto_freesession(sid);
 282                         error = EINVAL;
 283                         goto bail;
 284                 }
 285                 sop->ses = cse->ses;
 286
 287 bail:
 288                 if (error) {
 289                         if (crie.cri_key)
 290                                 FREE(crie.cri_key, M_XDATA);
 291                         if (cria.cri_key)
 292                                 FREE(cria.cri_key, M_XDATA);
 293                 }
 294                 break;
 295         case CIOCFSESSION:
 296                 ses = *(u_int32_t *)data;
 297                 cse = csefind(fcr, ses);
 298                 if (cse == NULL) {
 299                         error = EINVAL;
 300                         break;
 301                 }
 302                 csedelete(fcr, cse);
 303                 error = csefree(cse);
 304                 break;
 305         case CIOCCRYPT:
 306                 cop = (struct crypt_op *)data;
 307                 cse = csefind(fcr, cop->ses);
 308                 if (cse == NULL) {
 309                         error = EINVAL;
 310                         break;
 311                 }
 312                 error = cryptodev_op(cse, cop);
 313                 break;
 314         case CIOCKEY:
 315                 error = cryptodev_key((struct crypt_kop *)data);
 316                 break;
 317         case CIOCASYMFEAT:
 318                 error = crypto_getfeat((int *)data);
 319                 break;
 320         default:
 321                 error = EINVAL;
 322                 break;
 323         }
 324         rel_mplock();
 325         return (error);
 326 }
 327
 328 static int cryptodev_cb(void *);
 329
 330
 331 static int
 332 cryptodev_op(struct csession *cse, struct crypt_op *cop)
 333 {
 334         struct cryptop *crp = NULL;
 335         struct cryptodesc *crde = NULL, *crda = NULL;
 336         int i, error;
 337
 338         if (cop->len > 256*1024-4)
 339                 return (E2BIG);
 340
 341         if (cse->txform && (cop->len % cse->txform->blocksize) != 0)
 342                 return (EINVAL);
 343
 344         bzero(&cse->uio, sizeof(cse->uio));
 345         cse->uio.uio_iovcnt = 1;
 346         cse->uio.uio_resid = 0;
 347         cse->uio.uio_segflg = UIO_SYSSPACE;
 348         cse->uio.uio_rw = UIO_WRITE;
 349         cse->uio.uio_td = curthread;
 350         cse->uio.uio_iov = cse->iovec;
 351         bzero(&cse->iovec, sizeof(cse->iovec));
 352         cse->uio.uio_iov[0].iov_len = cop->len;
 353         cse->uio.uio_iov[0].iov_base = malloc(cop->len, M_XDATA, M_WAITOK);
 354         for (i = 0; i < cse->uio.uio_iovcnt; i++)
 355                 cse->uio.uio_resid += cse->uio.uio_iov[0].iov_len;
 356
 357         crp = crypto_getreq((cse->txform != NULL) + (cse->thash != NULL));
 358         if (crp == NULL) {
 359                 error = ENOMEM;
 360                 goto bail;
 361         }
 362
 363         if (cse->thash) {
 364                 crda = crp->crp_desc;
 365                 if (cse->txform)
 366                         crde = crda->crd_next;
 367         } else {
 368                 if (cse->txform)
 369                         crde = crp->crp_desc;
 370                 else {
 371                         error = EINVAL;
 372                         goto bail;
 373                 }
 374         }
 375
 376         if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, cop->len)))
 377                 goto bail;
 378
 379         if (crda) {
 380                 crda->crd_skip = 0;
 381                 crda->crd_len = cop->len;
 382                 crda->crd_inject = 0;   /* ??? */
 383
 384                 crda->crd_alg = cse->mac;
 385                 crda->crd_key = cse->mackey;
 386                 crda->crd_klen = cse->mackeylen * 8;
 387         }
 388
 389         if (crde) {
 390                 if (cop->op == COP_ENCRYPT)
 391                         crde->crd_flags |= CRD_F_ENCRYPT;
 392                 else
 393                         crde->crd_flags &= ~CRD_F_ENCRYPT;
 394                 crde->crd_len = cop->len;
 395                 crde->crd_inject = 0;
 396
 397                 crde->crd_alg = cse->cipher;
 398                 crde->crd_key = cse->key;
 399                 crde->crd_klen = cse->keylen * 8;
 400         }
 401
 402         crp->crp_ilen = cop->len;
 403         crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM
 404                        | (cop->flags & COP_F_BATCH);
 405         crp->crp_buf = (caddr_t)&cse->uio;
 406         crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_cb;
 407         crp->crp_sid = cse->sid;
 408         crp->crp_opaque = (void *)cse;
 409
 410         if (cop->iv) {
 411                 if (crde == NULL) {
 412                         error = EINVAL;
 413                         goto bail;
 414                 }
 415                 if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
 416                         error = EINVAL;
 417                         goto bail;
 418                 }
 419                 if ((error = copyin(cop->iv, cse->tmp_iv, cse->txform->blocksize)))
 420                         goto bail;
 421                 bcopy(cse->tmp_iv, crde->crd_iv, cse->txform->blocksize);
 422                 crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
 423                 crde->crd_skip = 0;
 424         } else if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
 425                 crde->crd_skip = 0;
 426         } else if (crde) {
 427                 crde->crd_flags |= CRD_F_IV_PRESENT;
 428                 crde->crd_skip = cse->txform->blocksize;
 429                 crde->crd_len -= cse->txform->blocksize;
 430         }
 431
 432         if (cop->mac) {
 433                 if (crda == NULL) {
 434                         error = EINVAL;
 435                         goto bail;
 436                 }
 437                 crp->crp_mac=cse->tmp_mac;
 438         }
 439
 440         crit_enter();
 441         error = crypto_dispatch(crp);
 442         if (error == 0 && (crp->crp_flags & CRYPTO_F_DONE) == 0)
 443                 error = tsleep(crp, 0, "crydev", 0);
 444         crit_exit();
 445         if (error)
 446                 goto bail;
 447
 448         if (crp->crp_etype != 0) {
 449                 error = crp->crp_etype;
 450                 goto bail;
 451         }
 452
 453         if (cse->error) {
 454                 error = cse->error;
 455                 goto bail;
 456         }
 457
 458         if (cop->dst &&
 459             (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, cop->len)))
 460                 goto bail;
 461
 462         if (cop->mac &&
 463             (error = copyout(crp->crp_mac, cop->mac, cse->thash->authsize)))
 464                 goto bail;
 465
 466 bail:
 467         if (crp)
 468                 crypto_freereq(crp);
 469         if (cse->uio.uio_iov[0].iov_base)
 470                 free(cse->uio.uio_iov[0].iov_base, M_XDATA);
 471
 472         return (error);
 473 }
 474
 475 static int
 476 cryptodev_cb(void *op)
 477 {
 478         struct cryptop *crp = (struct cryptop *) op;
 479         struct csession *cse = (struct csession *)crp->crp_opaque;
 480
 481         cse->error = crp->crp_etype;
 482         if (crp->crp_etype == EAGAIN)
 483                 return crypto_dispatch(crp);
 484         wakeup_one(crp);
 485         return (0);
 486 }
 487
 488 static int
 489 cryptodevkey_cb(void *op)
 490 {
 491         struct cryptkop *krp = (struct cryptkop *) op;
 492
 493         wakeup_one(krp);
 494         return (0);
 495 }
 496
 497 static int
 498 cryptodev_key(struct crypt_kop *kop)
 499 {
 500         struct cryptkop *krp = NULL;
 501         int error = EINVAL;
 502         int in, out, size, i;
 503
 504         if (kop->crk_iparams + kop->crk_oparams > CRK_MAXPARAM) {
 505                 return (EFBIG);
 506         }
 507
 508         in = kop->crk_iparams;
 509         out = kop->crk_oparams;
 510         switch (kop->crk_op) {
 511         case CRK_MOD_EXP:
 512                 if (in == 3 && out == 1)
 513                         break;
 514                 return (EINVAL);
 515         case CRK_MOD_EXP_CRT:
 516                 if (in == 6 && out == 1)
 517                         break;
 518                 return (EINVAL);
 519         case CRK_DSA_SIGN:
 520                 if (in == 5 && out == 2)
 521                         break;
 522                 return (EINVAL);
 523         case CRK_DSA_VERIFY:
 524                 if (in == 7 && out == 0)
 525                         break;
 526                 return (EINVAL);
 527         case CRK_DH_COMPUTE_KEY:
 528                 if (in == 3 && out == 1)
 529                         break;
 530                 return (EINVAL);
 531         default:
 532                 return (EINVAL);
 533         }
 534
 535         krp = (struct cryptkop *)malloc(sizeof *krp, M_XDATA, M_WAITOK);
 536         if (!krp)
 537                 return (ENOMEM);
 538         bzero(krp, sizeof *krp);
 539         krp->krp_op = kop->crk_op;
 540         krp->krp_status = kop->crk_status;
 541         krp->krp_iparams = kop->crk_iparams;
 542         krp->krp_oparams = kop->crk_oparams;
 543         krp->krp_status = 0;
 544         krp->krp_callback = (int (*) (struct cryptkop *)) cryptodevkey_cb;
 545
 546         for (i = 0; i < CRK_MAXPARAM; i++)
 547                 krp->krp_param[i].crp_nbits = kop->crk_param[i].crp_nbits;
 548         for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
 549                 size = (krp->krp_param[i].crp_nbits + 7) / 8;
 550                 if (size == 0)
 551                         continue;
 552                 MALLOC(krp->krp_param[i].crp_p, caddr_t, size, M_XDATA, M_WAITOK);
 553                 if (i >= krp->krp_iparams)
 554                         continue;
 555                 error = copyin(kop->crk_param[i].crp_p, krp->krp_param[i].crp_p, size);
 556                 if (error)
 557                         goto fail;
 558         }
 559
 560         error = crypto_kdispatch(krp);
 561         if (error == 0)
 562                 error = tsleep(krp, 0, "crydev", 0);
 563         if (error)
 564                 goto fail;
 565
 566         if (krp->krp_status != 0) {
 567                 error = krp->krp_status;
 568                 goto fail;
 569         }
 570
 571         for (i = krp->krp_iparams; i < krp->krp_iparams + krp->krp_oparams; i++) {
 572                 size = (krp->krp_param[i].crp_nbits + 7) / 8;
 573                 if (size == 0)
 574                         continue;
 575                 error = copyout(krp->krp_param[i].crp_p, kop->crk_param[i].crp_p, size);
 576                 if (error)
 577                         goto fail;
 578         }
 579
 580 fail:
 581         if (krp) {
 582                 kop->crk_status = krp->krp_status;
 583                 for (i = 0; i < CRK_MAXPARAM; i++) {
 584                         if (krp->krp_param[i].crp_p)
 585                                 FREE(krp->krp_param[i].crp_p, M_XDATA);
 586                 }
 587                 free(krp, M_XDATA);
 588         }
 589         return (error);
 590 }
 591
 592 /*
 593  * MPSAFE
 594  */
 595 static int
 596 cryptof_poll(struct file *fp, int events, struct ucred *active_cred)
 597 {
 598         return (0);
 599 }
 600
 601 /*
 602  * MPSAFE
 603  */
 604 static int
 605 cryptof_kqfilter(struct file *fp, struct knote *kn)
 606 {
 607
 608         return (0);
 609 }
 610
 611 /*
 612  * MPSAFE
 613  */
 614 static int
 615 cryptof_stat(struct file *fp, struct stat *sb, struct ucred *cred)
 616 {
 617         return (EOPNOTSUPP);
 618 }
 619
 620 /*
 621  * MPALMOSTSAFE - acquires mplock
 622  */
 623 static int
 624 cryptof_close(struct file *fp)
 625 {
 626         struct fcrypt *fcr;
 627         struct csession *cse;
 628
 629         get_mplock();
 630         fcr = (struct fcrypt *)fp->f_data;
 631         while ((cse = TAILQ_FIRST(&fcr->csessions))) {
 632                 TAILQ_REMOVE(&fcr->csessions, cse, next);
 633                 (void)csefree(cse);
 634         }
 635         fp->f_data = NULL;
 636         rel_mplock();
 637
 638         FREE(fcr, M_XDATA);
 639         return (0);
 640 }
 641
 642 static struct csession *
 643 csefind(struct fcrypt *fcr, u_int ses)
 644 {
 645         struct csession *cse;
 646
 647         TAILQ_FOREACH(cse, &fcr->csessions, next)
 648                 if (cse->ses == ses)
 649                         return (cse);
 650         return (NULL);
 651 }
 652
 653 static int
 654 csedelete(struct fcrypt *fcr, struct csession *cse_del)
 655 {
 656         struct csession *cse;
 657
 658         TAILQ_FOREACH(cse, &fcr->csessions, next) {
 659                 if (cse == cse_del) {
 660                         TAILQ_REMOVE(&fcr->csessions, cse, next);
 661                         return (1);
 662                 }
 663         }
 664         return (0);
 665 }
 666
 667 static struct csession *
 668 cseadd(struct fcrypt *fcr, struct csession *cse)
 669 {
 670         TAILQ_INSERT_TAIL(&fcr->csessions, cse, next);
 671         cse->ses = fcr->sesn++;
 672         return (cse);
 673 }
 674
 675 struct csession *
 676 csecreate(struct fcrypt *fcr, u_int64_t sid, caddr_t key, u_int64_t keylen,
 677     caddr_t mackey, u_int64_t mackeylen, u_int32_t cipher, u_int32_t mac,
 678     struct enc_xform *txform, struct auth_hash *thash)
 679 {
 680         struct csession *cse;
 681
 682         MALLOC(cse, struct csession *, sizeof(struct csession),
 683             M_XDATA, M_NOWAIT);
 684         if (cse == NULL)
 685                 return NULL;
 686         cse->key = key;
 687         cse->keylen = keylen/8;
 688         cse->mackey = mackey;
 689         cse->mackeylen = mackeylen/8;
 690         cse->sid = sid;
 691         cse->cipher = cipher;
 692         cse->mac = mac;
 693         cse->txform = txform;
 694         cse->thash = thash;
 695         cseadd(fcr, cse);
 696         return (cse);
 697 }
 698
 699 static int
 700 csefree(struct csession *cse)
 701 {
 702         int error;
 703
 704         error = crypto_freesession(cse->sid);
 705         if (cse->key)
 706                 FREE(cse->key, M_XDATA);
 707         if (cse->mackey)
 708                 FREE(cse->mackey, M_XDATA);
 709         FREE(cse, M_XDATA);
 710         return (error);
 711 }
 712
 713 static int
 714 cryptoopen(dev_t dev, int oflags, int devtype, struct thread *td)
 715 {
 716         if (crypto_usercrypto == 0)
 717                 return (ENXIO);
 718         return (0);
 719 }
 720
 721 static int
 722 cryptoread(dev_t dev, struct uio *uio, int ioflag)
 723 {
 724         return (EIO);
 725 }
 726
 727 static int
 728 cryptowrite(dev_t dev, struct uio *uio, int ioflag)
 729 {
 730         return (EIO);
 731 }
 732
 733 static int
 734 cryptoioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)
 735 {
 736         struct file *f;
 737         struct fcrypt *fcr;
 738         int fd, error;
 739         switch (cmd) {
 740         case CRIOGET:
 741                 MALLOC(fcr, struct fcrypt *,
 742                     sizeof(struct fcrypt), M_XDATA, M_WAITOK);
 743                 TAILQ_INIT(&fcr->csessions);
 744                 fcr->sesn = 0;
 745
 746                 KKASSERT(td->td_proc);
 747                 error = falloc(td->td_proc, &f, &fd);
 748
 749                 if (error) {
 750                         FREE(fcr, M_XDATA);
 751                         return (error);
 752                 }
 753                 f->f_type = DTYPE_CRYPTO;
 754                 f->f_flag = FREAD | FWRITE;
 755                 f->f_ops = &cryptofops;
 756                 f->f_data = fcr;
 757                 fsetfd(td->td_proc, f, fd);
 758                 *(u_int32_t *)data = fd;
 759                 fdrop(f);
 760                 break;
 761         default:
 762                 error = EINVAL;
 763                 break;
 764         }
 765         return (error);
 766 }
 767
 768 #define CRYPTO_MAJOR    70              /* from openbsd */
 769 static struct cdevsw crypto_cdevsw = {
 770         /* dev name */  "crypto",
 771         /* dev major */ CRYPTO_MAJOR,
 772         /* flags */     0,
 773         /* port */      NULL,
 774         /* clone */     NULL,
 775
 776         /* open */      cryptoopen,
 777         /* close */     nullclose,
 778         /* read */      cryptoread,
 779         /* write */     cryptowrite,
 780         /* ioctl */     cryptoioctl,
 781         /* poll */      nopoll,
 782         /* mmap */      nommap,
 783         /* strategy */  nostrategy,
 784         /* dump */      nodump,
 785         /* psize */     nopsize,
 786         /* kqfilter */  NULL
 787 };
 788
 789 /*
 790  * Initialization code, both for static and dynamic loading.
 791  */
 792 static int
 793 cryptodev_modevent(module_t mod, int type, void *unused)
 794 {
 795         switch (type) {
 796         case MOD_LOAD:
 797                 if (bootverbose)
 798                         printf("crypto: <crypto device>\n");
 799                 cdevsw_add(&crypto_cdevsw, 0, 0);
 800                 make_dev(&crypto_cdevsw, 0, UID_ROOT, GID_WHEEL,
 801                         0666, "crypto");
 802                 return 0;
 803         case MOD_UNLOAD:
 804                 /*XXX disallow if active sessions */
 805                 cdevsw_remove(&crypto_cdevsw, 0, 0);
 806                 return 0;
 807         }
 808         return EINVAL;
 809 }
 810
 811 static moduledata_t cryptodev_mod = {
 812         "cryptodev",
 813         cryptodev_modevent,
 814         0
 815 };
 816 MODULE_VERSION(cryptodev, 1);
 817 DECLARE_MODULE(cryptodev, cryptodev_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
 818 #if 0
 819 MODULE_DEPEND(cryptodev, crypto, 1, 1, 1);
 820 #endif