1 /* $FreeBSD: src/sys/opencrypto/cryptodev.c,v 1.41 2009/09/04 09:48:18 pjd Exp $ */ 2 /* $OpenBSD: cryptodev.c,v 1.52 2002/06/19 07:22:46 deraadt Exp $ */ 3 4 /*- 5 * Copyright (c) 2001 Theo de Raadt 6 * Copyright (c) 2002-2006 Sam Leffler, Errno Consulting 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 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/malloc.h> 39 #include <sys/device.h> 40 #include <sys/mbuf.h> 41 #include <sys/lock.h> 42 #include <sys/sysctl.h> 43 #include <sys/file.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/module.h> 50 #include <sys/kernel.h> 51 #include <sys/fcntl.h> 52 #include <sys/proc.h> 53 54 #include <sys/file2.h> 55 #include <sys/thread2.h> 56 #include <sys/mplock2.h> 57 58 #include <opencrypto/cryptodev.h> 59 #include <opencrypto/xform.h> 60 61 struct csession { 62 TAILQ_ENTRY(csession) next; 63 u_int64_t sid; 64 u_int32_t ses; 65 struct lock lock; 66 67 u_int32_t cipher; 68 struct enc_xform *txform; 69 u_int32_t mac; 70 struct auth_hash *thash; 71 72 caddr_t key; 73 int keylen; 74 u_char tmp_iv[EALG_MAX_BLOCK_LEN]; 75 76 caddr_t mackey; 77 int mackeylen; 78 79 struct iovec iovec; 80 struct uio uio; 81 int error; 82 }; 83 84 struct fcrypt { 85 TAILQ_HEAD(csessionlist, csession) csessions; 86 int sesn; 87 }; 88 89 static int cryptof_rw(struct file *fp, struct uio *uio, 90 struct ucred *cred, int flags); 91 static int cryptof_ioctl(struct file *, u_long, caddr_t, 92 struct ucred *, struct sysmsg *); 93 static int cryptof_kqfilter(struct file *, struct knote *); 94 static int cryptof_stat(struct file *, struct stat *, struct ucred *); 95 static int cryptof_close(struct file *); 96 97 static struct fileops cryptofops = { 98 .fo_read = cryptof_rw, 99 .fo_write = cryptof_rw, 100 .fo_ioctl = cryptof_ioctl, 101 .fo_kqfilter = cryptof_kqfilter, 102 .fo_stat = cryptof_stat, 103 .fo_close = cryptof_close, 104 .fo_shutdown = 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 *, struct ucred *); 116 static int cryptodev_key(struct crypt_kop *); 117 static int cryptodev_find(struct crypt_find_op *); 118 119 static int 120 cryptof_rw( 121 struct file *fp, 122 struct uio *uio, 123 struct ucred *active_cred, 124 int flags) 125 { 126 return (EIO); 127 } 128 129 /* 130 * Check a crypto identifier to see if it requested 131 * a software device/driver. This can be done either 132 * by device name/class or through search constraints. 133 */ 134 static int 135 checkforsoftware(int crid) 136 { 137 if (crid & CRYPTOCAP_F_SOFTWARE) 138 return EINVAL; /* XXX */ 139 if ((crid & CRYPTOCAP_F_HARDWARE) == 0 && 140 (crypto_getcaps(crid) & CRYPTOCAP_F_HARDWARE) == 0) 141 return EINVAL; /* XXX */ 142 return 0; 143 } 144 145 /* ARGSUSED */ 146 static int 147 cryptof_ioctl(struct file *fp, u_long cmd, caddr_t data, 148 struct ucred *cred, struct sysmsg *msg) 149 { 150 #define SES2(p) ((struct session2_op *)p) 151 struct cryptoini cria, crie; 152 struct fcrypt *fcr = fp->f_data; 153 struct csession *cse; 154 struct session_op *sop; 155 struct crypt_op *cop; 156 struct enc_xform *txform = NULL; 157 struct auth_hash *thash = NULL; 158 struct crypt_kop *kop; 159 u_int64_t sid; 160 u_int32_t ses; 161 int error = 0, crid; 162 163 switch (cmd) { 164 case CIOCGSESSION: 165 case CIOCGSESSION2: 166 sop = (struct session_op *)data; 167 switch (sop->cipher) { 168 case 0: 169 break; 170 case CRYPTO_DES_CBC: 171 txform = &enc_xform_des; 172 break; 173 case CRYPTO_3DES_CBC: 174 txform = &enc_xform_3des; 175 break; 176 case CRYPTO_BLF_CBC: 177 txform = &enc_xform_blf; 178 break; 179 case CRYPTO_CAST_CBC: 180 txform = &enc_xform_cast5; 181 break; 182 case CRYPTO_SKIPJACK_CBC: 183 txform = &enc_xform_skipjack; 184 break; 185 case CRYPTO_AES_CBC: 186 txform = &enc_xform_rijndael128; 187 break; 188 case CRYPTO_AES_XTS: 189 txform = &enc_xform_aes_xts; 190 break; 191 case CRYPTO_AES_CTR: 192 txform = &enc_xform_aes_ctr; 193 break; 194 case CRYPTO_NULL_CBC: 195 txform = &enc_xform_null; 196 break; 197 case CRYPTO_ARC4: 198 txform = &enc_xform_arc4; 199 break; 200 case CRYPTO_CAMELLIA_CBC: 201 txform = &enc_xform_camellia; 202 break; 203 default: 204 return (EINVAL); 205 } 206 207 switch (sop->mac) { 208 case 0: 209 break; 210 case CRYPTO_MD5_HMAC: 211 thash = &auth_hash_hmac_md5; 212 break; 213 case CRYPTO_SHA1_HMAC: 214 thash = &auth_hash_hmac_sha1; 215 break; 216 case CRYPTO_SHA2_256_HMAC: 217 thash = &auth_hash_hmac_sha2_256; 218 break; 219 case CRYPTO_SHA2_384_HMAC: 220 thash = &auth_hash_hmac_sha2_384; 221 break; 222 case CRYPTO_SHA2_512_HMAC: 223 thash = &auth_hash_hmac_sha2_512; 224 break; 225 case CRYPTO_RIPEMD160_HMAC: 226 thash = &auth_hash_hmac_ripemd_160; 227 break; 228 #ifdef notdef 229 case CRYPTO_MD5: 230 thash = &auth_hash_md5; 231 break; 232 case CRYPTO_SHA1: 233 thash = &auth_hash_sha1; 234 break; 235 #endif 236 case CRYPTO_NULL_HMAC: 237 thash = &auth_hash_null; 238 break; 239 default: 240 return (EINVAL); 241 } 242 243 bzero(&crie, sizeof(crie)); 244 bzero(&cria, sizeof(cria)); 245 246 if (txform) { 247 crie.cri_alg = txform->type; 248 crie.cri_klen = sop->keylen * 8; 249 if (sop->keylen > txform->maxkey || 250 sop->keylen < txform->minkey) { 251 error = EINVAL; 252 goto bail; 253 } 254 255 crie.cri_key = kmalloc(crie.cri_klen / 8, 256 M_XDATA, M_WAITOK); 257 if ((error = copyin(sop->key, crie.cri_key, 258 crie.cri_klen / 8))) 259 goto bail; 260 if (thash) 261 crie.cri_next = &cria; 262 } 263 264 if (thash) { 265 cria.cri_alg = thash->type; 266 cria.cri_klen = sop->mackeylen * 8; 267 if (sop->mackeylen != thash->keysize) { 268 error = EINVAL; 269 goto bail; 270 } 271 272 if (cria.cri_klen) { 273 cria.cri_key = kmalloc(cria.cri_klen / 8, 274 M_XDATA, M_WAITOK); 275 if ((error = copyin(sop->mackey, cria.cri_key, 276 cria.cri_klen / 8))) 277 goto bail; 278 } 279 } 280 281 /* NB: CIOGSESSION2 has the crid */ 282 if (cmd == CIOCGSESSION2) { 283 crid = SES2(sop)->crid; 284 error = checkforsoftware(crid); 285 if (error) 286 goto bail; 287 } else { 288 crid = CRYPTOCAP_F_HARDWARE; 289 if (crypto_devallowsoft) 290 crid |= CRYPTOCAP_F_SOFTWARE; 291 } 292 error = crypto_newsession(&sid, (txform ? &crie : &cria), crid); 293 if (error) 294 goto bail; 295 296 cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen, 297 cria.cri_key, cria.cri_klen, sop->cipher, sop->mac, txform, 298 thash); 299 300 if (cse == NULL) { 301 crypto_freesession(sid); 302 error = EINVAL; 303 goto bail; 304 } 305 sop->ses = cse->ses; 306 if (cmd == CIOCGSESSION2) { 307 /* return hardware/driver id */ 308 SES2(sop)->crid = CRYPTO_SESID2HID(cse->sid); 309 } 310 bail: 311 if (error) { 312 if (crie.cri_key) 313 kfree(crie.cri_key, M_XDATA); 314 if (cria.cri_key) 315 kfree(cria.cri_key, M_XDATA); 316 } 317 break; 318 case CIOCFSESSION: 319 ses = *(u_int32_t *)data; 320 cse = csefind(fcr, ses); 321 if (cse == NULL) 322 return (EINVAL); 323 csedelete(fcr, cse); 324 error = csefree(cse); 325 break; 326 case CIOCCRYPT: 327 cop = (struct crypt_op *)data; 328 cse = csefind(fcr, cop->ses); 329 if (cse == NULL) 330 return (EINVAL); 331 error = cryptodev_op(cse, cop, cred); 332 break; 333 case CIOCKEY: 334 case CIOCKEY2: 335 if (!crypto_userasymcrypto) 336 return (EPERM); /* XXX compat? */ 337 get_mplock(); 338 kop = (struct crypt_kop *)data; 339 if (cmd == CIOCKEY) { 340 /* NB: crypto core enforces s/w driver use */ 341 kop->crk_crid = 342 CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE; 343 } 344 error = cryptodev_key(kop); 345 rel_mplock(); 346 break; 347 case CIOCASYMFEAT: 348 if (!crypto_userasymcrypto) { 349 /* 350 * NB: if user asym crypto operations are 351 * not permitted return "no algorithms" 352 * so well-behaved applications will just 353 * fallback to doing them in software. 354 */ 355 *(int *)data = 0; 356 } else 357 error = crypto_getfeat((int *)data); 358 break; 359 case CIOCFINDDEV: 360 error = cryptodev_find((struct crypt_find_op *)data); 361 break; 362 default: 363 error = EINVAL; 364 break; 365 } 366 return (error); 367 #undef SES2 368 } 369 370 static int cryptodev_cb(void *); 371 372 373 static int 374 cryptodev_op(struct csession *cse, struct crypt_op *cop, 375 struct ucred *active_cred) 376 { 377 struct cryptop *crp = NULL; 378 struct cryptodesc *crde = NULL, *crda = NULL; 379 int error; 380 381 if (cop->len > 256*1024-4) 382 return (E2BIG); 383 384 if (cse->txform) { 385 if (cop->len == 0 || (cop->len % cse->txform->blocksize) != 0) 386 return (EINVAL); 387 } 388 389 bzero(&cse->uio, sizeof(cse->uio)); 390 cse->uio.uio_iov = &cse->iovec; 391 cse->uio.uio_iovcnt = 1; 392 cse->uio.uio_offset = 0; 393 cse->uio.uio_resid = cop->len; 394 cse->uio.uio_segflg = UIO_SYSSPACE; 395 cse->uio.uio_rw = UIO_WRITE; 396 /* XXX: not sure, was td, now curthread? */ 397 cse->uio.uio_td = curthread; 398 cse->uio.uio_iov[0].iov_len = cop->len; 399 if (cse->thash) { 400 cse->uio.uio_iov[0].iov_len += cse->thash->hashsize; 401 cse->uio.uio_resid += cse->thash->hashsize; 402 } 403 cse->uio.uio_iov[0].iov_base = kmalloc(cse->uio.uio_iov[0].iov_len, 404 M_XDATA, M_WAITOK); 405 406 crp = crypto_getreq((cse->txform != NULL) + (cse->thash != NULL)); 407 if (crp == NULL) { 408 error = ENOMEM; 409 goto bail; 410 } 411 412 if (cse->thash) { 413 crda = crp->crp_desc; 414 if (cse->txform) 415 crde = crda->crd_next; 416 } else { 417 if (cse->txform) 418 crde = crp->crp_desc; 419 else { 420 error = EINVAL; 421 goto bail; 422 } 423 } 424 425 if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, cop->len))) 426 goto bail; 427 428 if (crda) { 429 crda->crd_skip = 0; 430 crda->crd_len = cop->len; 431 crda->crd_inject = cop->len; 432 433 crda->crd_alg = cse->mac; 434 crda->crd_key = cse->mackey; 435 crda->crd_klen = cse->mackeylen * 8; 436 } 437 438 if (crde) { 439 if (cop->op == COP_ENCRYPT) 440 crde->crd_flags |= CRD_F_ENCRYPT; 441 else 442 crde->crd_flags &= ~CRD_F_ENCRYPT; 443 crde->crd_len = cop->len; 444 crde->crd_inject = 0; 445 446 crde->crd_alg = cse->cipher; 447 crde->crd_key = cse->key; 448 crde->crd_klen = cse->keylen * 8; 449 } 450 451 crp->crp_ilen = cop->len; 452 crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM 453 | (cop->flags & COP_F_BATCH); 454 crp->crp_buf = (caddr_t)&cse->uio; 455 crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_cb; 456 crp->crp_sid = cse->sid; 457 crp->crp_opaque = (void *)cse; 458 459 if (cop->iv) { 460 if (crde == NULL) { 461 error = EINVAL; 462 goto bail; 463 } 464 if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */ 465 error = EINVAL; 466 goto bail; 467 } 468 if ((error = copyin(cop->iv, cse->tmp_iv, cse->txform->blocksize))) 469 goto bail; 470 bcopy(cse->tmp_iv, crde->crd_iv, cse->txform->blocksize); 471 crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT; 472 crde->crd_skip = 0; 473 } else if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */ 474 crde->crd_skip = 0; 475 } else if (crde) { 476 crde->crd_flags |= CRD_F_IV_PRESENT; 477 crde->crd_skip = cse->txform->blocksize; 478 crde->crd_len -= cse->txform->blocksize; 479 } 480 481 if (cop->mac && crda == NULL) { 482 error = EINVAL; 483 goto bail; 484 } 485 486 again: 487 /* 488 * Let the dispatch run unlocked, then, interlock against the 489 * callback before checking if the operation completed and going 490 * to sleep. This insures drivers don't inherit our lock which 491 * results in a lock order reversal between crypto_dispatch forced 492 * entry and the crypto_done callback into us. 493 */ 494 error = crypto_dispatch(crp); 495 lockmgr(&cse->lock, LK_EXCLUSIVE); 496 if (error == 0 && (crp->crp_flags & CRYPTO_F_DONE) == 0) 497 error = lksleep(crp, &cse->lock, 0, "crydev", 0); 498 lockmgr(&cse->lock, LK_RELEASE); 499 500 if (error != 0) 501 goto bail; 502 503 if (crp->crp_etype == EAGAIN) { 504 crp->crp_etype = 0; 505 crp->crp_flags &= ~CRYPTO_F_DONE; 506 goto again; 507 } 508 509 if (crp->crp_etype != 0) { 510 error = crp->crp_etype; 511 goto bail; 512 } 513 514 if (cse->error) { 515 error = cse->error; 516 goto bail; 517 } 518 519 if (cop->dst && 520 (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, cop->len))) 521 goto bail; 522 523 if (cop->mac && 524 (error = copyout((caddr_t)cse->uio.uio_iov[0].iov_base + cop->len, 525 cop->mac, cse->thash->hashsize))) 526 goto bail; 527 528 bail: 529 if (crp) 530 crypto_freereq(crp); 531 if (cse->uio.uio_iov[0].iov_base) 532 kfree(cse->uio.uio_iov[0].iov_base, M_XDATA); 533 534 return (error); 535 } 536 537 static int 538 cryptodev_cb(void *op) 539 { 540 struct cryptop *crp = (struct cryptop *) op; 541 struct csession *cse = (struct csession *)crp->crp_opaque; 542 543 lockmgr(&cse->lock, LK_EXCLUSIVE); 544 cse->error = crp->crp_etype; 545 wakeup_one(crp); 546 lockmgr(&cse->lock, LK_RELEASE); 547 return (0); 548 } 549 550 static int 551 cryptodevkey_cb(void *op) 552 { 553 struct cryptkop *krp = (struct cryptkop *) op; 554 555 wakeup_one(krp); 556 return (0); 557 } 558 559 static int 560 cryptodev_key(struct crypt_kop *kop) 561 { 562 struct cryptkop *krp = NULL; 563 int error = EINVAL; 564 int in, out, size, i; 565 566 if (kop->crk_iparams + kop->crk_oparams > CRK_MAXPARAM) { 567 return (EFBIG); 568 } 569 570 in = kop->crk_iparams; 571 out = kop->crk_oparams; 572 switch (kop->crk_op) { 573 case CRK_MOD_EXP: 574 if (in == 3 && out == 1) 575 break; 576 return (EINVAL); 577 case CRK_MOD_EXP_CRT: 578 if (in == 6 && out == 1) 579 break; 580 return (EINVAL); 581 case CRK_DSA_SIGN: 582 if (in == 5 && out == 2) 583 break; 584 return (EINVAL); 585 case CRK_DSA_VERIFY: 586 if (in == 7 && out == 0) 587 break; 588 return (EINVAL); 589 case CRK_DH_COMPUTE_KEY: 590 if (in == 3 && out == 1) 591 break; 592 return (EINVAL); 593 default: 594 return (EINVAL); 595 } 596 597 krp = (struct cryptkop *)kmalloc(sizeof *krp, M_XDATA, M_WAITOK | M_ZERO); 598 krp->krp_op = kop->crk_op; 599 krp->krp_status = kop->crk_status; 600 krp->krp_iparams = kop->crk_iparams; 601 krp->krp_oparams = kop->crk_oparams; 602 krp->krp_crid = kop->crk_crid; 603 krp->krp_status = 0; 604 krp->krp_callback = (int (*) (struct cryptkop *)) cryptodevkey_cb; 605 606 for (i = 0; i < CRK_MAXPARAM; i++) { 607 if (kop->crk_param[i].crp_nbits > 65536) 608 /* Limit is the same as in OpenBSD */ 609 goto fail; 610 krp->krp_param[i].crp_nbits = kop->crk_param[i].crp_nbits; 611 } 612 for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) { 613 size = (krp->krp_param[i].crp_nbits + 7) / 8; 614 if (size == 0) 615 continue; 616 krp->krp_param[i].crp_p = kmalloc(size, M_XDATA, M_WAITOK); 617 if (i >= krp->krp_iparams) 618 continue; 619 error = copyin(kop->crk_param[i].crp_p, krp->krp_param[i].crp_p, size); 620 if (error) 621 goto fail; 622 } 623 624 error = crypto_kdispatch(krp); 625 if (error) 626 goto fail; 627 error = tsleep(krp, 0, "crydev", 0); 628 if (error) { 629 /* XXX can this happen? if so, how do we recover? */ 630 goto fail; 631 } 632 633 kop->crk_crid = krp->krp_crid; /* device that did the work */ 634 if (krp->krp_status != 0) { 635 error = krp->krp_status; 636 goto fail; 637 } 638 639 for (i = krp->krp_iparams; i < krp->krp_iparams + krp->krp_oparams; i++) { 640 size = (krp->krp_param[i].crp_nbits + 7) / 8; 641 if (size == 0) 642 continue; 643 error = copyout(krp->krp_param[i].crp_p, kop->crk_param[i].crp_p, size); 644 if (error) 645 goto fail; 646 } 647 648 fail: 649 if (krp) { 650 kop->crk_status = krp->krp_status; 651 for (i = 0; i < CRK_MAXPARAM; i++) { 652 if (krp->krp_param[i].crp_p) 653 kfree(krp->krp_param[i].crp_p, M_XDATA); 654 } 655 kfree(krp, M_XDATA); 656 } 657 return (error); 658 } 659 660 static int 661 cryptodev_find(struct crypt_find_op *find) 662 { 663 device_t dev; 664 665 if (find->crid != -1) { 666 dev = crypto_find_device_byhid(find->crid); 667 if (dev == NULL) 668 return (ENOENT); 669 strlcpy(find->name, device_get_nameunit(dev), 670 sizeof(find->name)); 671 } else { 672 find->crid = crypto_find_driver(find->name); 673 if (find->crid == -1) 674 return (ENOENT); 675 } 676 return (0); 677 } 678 679 /* 680 * MPSAFE 681 */ 682 static int 683 cryptof_kqfilter(struct file *fp, struct knote *kn) 684 { 685 686 return (0); 687 } 688 689 /* 690 * MPSAFE 691 */ 692 static int 693 cryptof_stat(struct file *fp, struct stat *sb, struct ucred *cred) 694 { 695 return (EOPNOTSUPP); 696 } 697 698 /* 699 * MPALMOSTSAFE - acquires mplock 700 */ 701 static int 702 cryptof_close(struct file *fp) 703 { 704 struct fcrypt *fcr = fp->f_data; 705 struct csession *cse; 706 707 get_mplock(); 708 fcr = (struct fcrypt *)fp->f_data; 709 while ((cse = TAILQ_FIRST(&fcr->csessions))) { 710 TAILQ_REMOVE(&fcr->csessions, cse, next); 711 (void)csefree(cse); 712 } 713 fp->f_data = NULL; 714 rel_mplock(); 715 716 kfree(fcr, M_XDATA); 717 return (0); 718 } 719 720 static struct csession * 721 csefind(struct fcrypt *fcr, u_int ses) 722 { 723 struct csession *cse; 724 725 TAILQ_FOREACH(cse, &fcr->csessions, next) 726 if (cse->ses == ses) 727 return (cse); 728 return (NULL); 729 } 730 731 static int 732 csedelete(struct fcrypt *fcr, struct csession *cse_del) 733 { 734 struct csession *cse; 735 736 TAILQ_FOREACH(cse, &fcr->csessions, next) { 737 if (cse == cse_del) { 738 TAILQ_REMOVE(&fcr->csessions, cse, next); 739 return (1); 740 } 741 } 742 return (0); 743 } 744 745 static struct csession * 746 cseadd(struct fcrypt *fcr, struct csession *cse) 747 { 748 TAILQ_INSERT_TAIL(&fcr->csessions, cse, next); 749 cse->ses = fcr->sesn++; 750 return (cse); 751 } 752 753 struct csession * 754 csecreate(struct fcrypt *fcr, u_int64_t sid, caddr_t key, u_int64_t keylen, 755 caddr_t mackey, u_int64_t mackeylen, u_int32_t cipher, u_int32_t mac, 756 struct enc_xform *txform, struct auth_hash *thash) 757 { 758 struct csession *cse; 759 760 cse = kmalloc(sizeof(struct csession), M_XDATA, M_WAITOK | M_ZERO); 761 if (cse == NULL) 762 return NULL; 763 lockinit(&cse->lock, "cryptodev", 0, LK_CANRECURSE); 764 cse->key = key; 765 cse->keylen = keylen/8; 766 cse->mackey = mackey; 767 cse->mackeylen = mackeylen/8; 768 cse->sid = sid; 769 cse->cipher = cipher; 770 cse->mac = mac; 771 cse->txform = txform; 772 cse->thash = thash; 773 cseadd(fcr, cse); 774 return (cse); 775 } 776 777 static int 778 csefree(struct csession *cse) 779 { 780 int error; 781 782 error = crypto_freesession(cse->sid); 783 lockuninit(&cse->lock); 784 if (cse->key) 785 kfree(cse->key, M_XDATA); 786 if (cse->mackey) 787 kfree(cse->mackey, M_XDATA); 788 kfree(cse, M_XDATA); 789 return (error); 790 } 791 792 static int 793 cryptoopen(struct dev_open_args *ap) 794 { 795 return (0); 796 } 797 798 static int 799 cryptoread(struct dev_read_args *ap) 800 { 801 return (EIO); 802 } 803 804 static int 805 cryptowrite(struct dev_write_args *ap) 806 { 807 return (EIO); 808 } 809 810 static int 811 cryptoioctl(struct dev_ioctl_args *ap) 812 { 813 struct thread *td = curthread; 814 struct file *f; 815 struct fcrypt *fcr; 816 int fd, error; 817 818 switch (ap->a_cmd) { 819 case CRIOGET: 820 fcr = kmalloc(sizeof(struct fcrypt), M_XDATA, M_WAITOK); 821 TAILQ_INIT(&fcr->csessions); 822 fcr->sesn = 0; 823 824 KKASSERT(td->td_lwp); 825 error = falloc(td->td_lwp, &f, &fd); 826 827 if (error) { 828 kfree(fcr, M_XDATA); 829 return (error); 830 } 831 /* falloc automatically provides an extra reference to 'f'. */ 832 f->f_flag = FREAD | FWRITE; 833 f->f_type = DTYPE_CRYPTO; 834 f->f_ops = &cryptofops; 835 f->f_data = fcr; 836 fsetfd(td->td_proc->p_fd, f, fd); 837 *(u_int32_t *)ap->a_data = fd; 838 fdrop(f); 839 840 break; 841 case CRIOFINDDEV: 842 error = cryptodev_find((struct crypt_find_op *)ap->a_data); 843 break; 844 case CRIOASYMFEAT: 845 error = crypto_getfeat((int *)ap->a_data); 846 break; 847 default: 848 error = EINVAL; 849 break; 850 } 851 return (error); 852 } 853 854 static struct dev_ops crypto_ops = { 855 { "crypto", 0, D_MPSAFE }, 856 .d_open = cryptoopen, 857 .d_read = cryptoread, 858 .d_write = cryptowrite, 859 .d_ioctl = cryptoioctl, 860 }; 861 862 /* 863 * Initialization code, both for static and dynamic loading. 864 */ 865 static int 866 cryptodev_modevent(module_t mod, int type, void *unused) 867 { 868 switch (type) { 869 case MOD_LOAD: 870 if (bootverbose) 871 kprintf("crypto: <crypto device>\n"); 872 make_dev(&crypto_ops, 0, UID_ROOT, GID_WHEEL, 873 0666, "crypto"); 874 return 0; 875 case MOD_UNLOAD: 876 /*XXX disallow if active sessions */ 877 //dev_ops_remove(&crypto_ops, 0, 0); 878 dev_ops_remove_all(&crypto_ops); 879 return 0; 880 } 881 return EINVAL; 882 } 883 884 static moduledata_t cryptodev_mod = { 885 "cryptodev", 886 cryptodev_modevent, 887 0 888 }; 889 MODULE_VERSION(cryptodev, 1); 890 DECLARE_MODULE(cryptodev, cryptodev_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 891 MODULE_DEPEND(cryptodev, crypto, 1, 1, 1); 892 MODULE_DEPEND(cryptodev, zlib, 1, 1, 1); 893