cryptosoft.c revision 1.41
1 /* $NetBSD: cryptosoft.c,v 1.41 2013/02/02 21:38:24 christos Exp $ */ 2 /* $FreeBSD: src/sys/opencrypto/cryptosoft.c,v 1.2.2.1 2002/11/21 23:34:23 sam Exp $ */ 3 /* $OpenBSD: cryptosoft.c,v 1.35 2002/04/26 08:43:50 deraadt Exp $ */ 4 5 /* 6 * The author of this code is Angelos D. Keromytis (angelos (at) cis.upenn.edu) 7 * 8 * This code was written by Angelos D. Keromytis in Athens, Greece, in 9 * February 2000. Network Security Technologies Inc. (NSTI) kindly 10 * supported the development of this code. 11 * 12 * Copyright (c) 2000, 2001 Angelos D. Keromytis 13 * 14 * Permission to use, copy, and modify this software with or without fee 15 * is hereby granted, provided that this entire notice is included in 16 * all source code copies of any software which is or includes a copy or 17 * modification of this software. 18 * 19 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR 20 * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY 21 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE 22 * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR 23 * PURPOSE. 24 */ 25 26 #include <sys/cdefs.h> 27 __KERNEL_RCSID(0, "$NetBSD: cryptosoft.c,v 1.41 2013/02/02 21:38:24 christos Exp $"); 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/malloc.h> 32 #include <sys/mbuf.h> 33 #include <sys/sysctl.h> 34 #include <sys/errno.h> 35 #include <sys/cprng.h> 36 37 #include "opt_ocf.h" 38 #include <opencrypto/cryptodev.h> 39 #include <opencrypto/cryptosoft.h> 40 #include <opencrypto/xform.h> 41 42 #include <opencrypto/cryptosoft_xform.c> 43 44 union authctx { 45 MD5_CTX md5ctx; 46 SHA1_CTX sha1ctx; 47 RMD160_CTX rmd160ctx; 48 SHA256_CTX sha256ctx; 49 SHA384_CTX sha384ctx; 50 SHA512_CTX sha512ctx; 51 aesxcbc_ctx aesxcbcctx; 52 AES_GMAC_CTX aesgmacctx; 53 }; 54 55 struct swcr_data **swcr_sessions = NULL; 56 u_int32_t swcr_sesnum = 0; 57 int32_t swcr_id = -1; 58 59 #define COPYBACK(x, a, b, c, d) \ 60 (x) == CRYPTO_BUF_MBUF ? m_copyback((struct mbuf *)a,b,c,d) \ 61 : cuio_copyback((struct uio *)a,b,c,d) 62 #define COPYDATA(x, a, b, c, d) \ 63 (x) == CRYPTO_BUF_MBUF ? m_copydata((struct mbuf *)a,b,c,d) \ 64 : cuio_copydata((struct uio *)a,b,c,d) 65 66 static int swcr_encdec(struct cryptodesc *, const struct swcr_data *, void *, int); 67 static int swcr_compdec(struct cryptodesc *, const struct swcr_data *, void *, int, int *); 68 static int swcr_combined(struct cryptop *, int); 69 static int swcr_process(void *, struct cryptop *, int); 70 static int swcr_newsession(void *, u_int32_t *, struct cryptoini *); 71 static int swcr_freesession(void *, u_int64_t); 72 73 /* 74 * Apply a symmetric encryption/decryption algorithm. 75 */ 76 static int 77 swcr_encdec(struct cryptodesc *crd, const struct swcr_data *sw, void *bufv, 78 int outtype) 79 { 80 char *buf = bufv; 81 unsigned char iv[EALG_MAX_BLOCK_LEN], blk[EALG_MAX_BLOCK_LEN], *idat; 82 unsigned char *ivp, piv[EALG_MAX_BLOCK_LEN]; 83 const struct swcr_enc_xform *exf; 84 int i, k, j, blks, ivlen; 85 int count, ind; 86 87 exf = sw->sw_exf; 88 blks = exf->enc_xform->blocksize; 89 ivlen = exf->enc_xform->ivsize; 90 KASSERT(exf->reinit ? ivlen <= blks : ivlen == blks); 91 92 /* Check for non-padded data */ 93 if (crd->crd_len % blks) 94 return EINVAL; 95 96 /* Initialize the IV */ 97 if (crd->crd_flags & CRD_F_ENCRYPT) { 98 /* IV explicitly provided ? */ 99 if (crd->crd_flags & CRD_F_IV_EXPLICIT) { 100 memcpy(iv, crd->crd_iv, ivlen); 101 if (exf->reinit) 102 exf->reinit(sw->sw_kschedule, iv, 0); 103 } else if (exf->reinit) { 104 exf->reinit(sw->sw_kschedule, 0, iv); 105 } else { 106 /* Get random IV */ 107 for (i = 0; 108 i + sizeof (u_int32_t) <= EALG_MAX_BLOCK_LEN; 109 i += sizeof (u_int32_t)) { 110 u_int32_t temp = cprng_fast32(); 111 112 memcpy(iv + i, &temp, sizeof(u_int32_t)); 113 } 114 /* 115 * What if the block size is not a multiple 116 * of sizeof (u_int32_t), which is the size of 117 * what arc4random() returns ? 118 */ 119 if (EALG_MAX_BLOCK_LEN % sizeof (u_int32_t) != 0) { 120 u_int32_t temp = cprng_fast32(); 121 122 bcopy (&temp, iv + i, 123 EALG_MAX_BLOCK_LEN - i); 124 } 125 } 126 127 /* Do we need to write the IV */ 128 if (!(crd->crd_flags & CRD_F_IV_PRESENT)) { 129 COPYBACK(outtype, buf, crd->crd_inject, ivlen, iv); 130 } 131 132 } else { /* Decryption */ 133 /* IV explicitly provided ? */ 134 if (crd->crd_flags & CRD_F_IV_EXPLICIT) 135 memcpy(iv, crd->crd_iv, ivlen); 136 else { 137 /* Get IV off buf */ 138 COPYDATA(outtype, buf, crd->crd_inject, ivlen, iv); 139 } 140 if (exf->reinit) 141 exf->reinit(sw->sw_kschedule, iv, 0); 142 } 143 144 ivp = iv; 145 146 if (outtype == CRYPTO_BUF_CONTIG) { 147 if (exf->reinit) { 148 for (i = crd->crd_skip; 149 i < crd->crd_skip + crd->crd_len; i += blks) { 150 if (crd->crd_flags & CRD_F_ENCRYPT) { 151 exf->encrypt(sw->sw_kschedule, buf + i); 152 } else { 153 exf->decrypt(sw->sw_kschedule, buf + i); 154 } 155 } 156 } else if (crd->crd_flags & CRD_F_ENCRYPT) { 157 for (i = crd->crd_skip; 158 i < crd->crd_skip + crd->crd_len; i += blks) { 159 /* XOR with the IV/previous block, as appropriate. */ 160 if (i == crd->crd_skip) 161 for (k = 0; k < blks; k++) 162 buf[i + k] ^= ivp[k]; 163 else 164 for (k = 0; k < blks; k++) 165 buf[i + k] ^= buf[i + k - blks]; 166 exf->encrypt(sw->sw_kschedule, buf + i); 167 } 168 } else { /* Decrypt */ 169 /* 170 * Start at the end, so we don't need to keep the encrypted 171 * block as the IV for the next block. 172 */ 173 for (i = crd->crd_skip + crd->crd_len - blks; 174 i >= crd->crd_skip; i -= blks) { 175 exf->decrypt(sw->sw_kschedule, buf + i); 176 177 /* XOR with the IV/previous block, as appropriate */ 178 if (i == crd->crd_skip) 179 for (k = 0; k < blks; k++) 180 buf[i + k] ^= ivp[k]; 181 else 182 for (k = 0; k < blks; k++) 183 buf[i + k] ^= buf[i + k - blks]; 184 } 185 } 186 187 return 0; 188 } else if (outtype == CRYPTO_BUF_MBUF) { 189 struct mbuf *m = (struct mbuf *) buf; 190 191 /* Find beginning of data */ 192 m = m_getptr(m, crd->crd_skip, &k); 193 if (m == NULL) 194 return EINVAL; 195 196 i = crd->crd_len; 197 198 while (i > 0) { 199 /* 200 * If there's insufficient data at the end of 201 * an mbuf, we have to do some copying. 202 */ 203 if (m->m_len < k + blks && m->m_len != k) { 204 m_copydata(m, k, blks, blk); 205 206 /* Actual encryption/decryption */ 207 if (exf->reinit) { 208 if (crd->crd_flags & CRD_F_ENCRYPT) { 209 exf->encrypt(sw->sw_kschedule, 210 blk); 211 } else { 212 exf->decrypt(sw->sw_kschedule, 213 blk); 214 } 215 } else if (crd->crd_flags & CRD_F_ENCRYPT) { 216 /* XOR with previous block */ 217 for (j = 0; j < blks; j++) 218 blk[j] ^= ivp[j]; 219 220 exf->encrypt(sw->sw_kschedule, blk); 221 222 /* 223 * Keep encrypted block for XOR'ing 224 * with next block 225 */ 226 memcpy(iv, blk, blks); 227 ivp = iv; 228 } else { /* decrypt */ 229 /* 230 * Keep encrypted block for XOR'ing 231 * with next block 232 */ 233 if (ivp == iv) 234 memcpy(piv, blk, blks); 235 else 236 memcpy(iv, blk, blks); 237 238 exf->decrypt(sw->sw_kschedule, blk); 239 240 /* XOR with previous block */ 241 for (j = 0; j < blks; j++) 242 blk[j] ^= ivp[j]; 243 244 if (ivp == iv) 245 memcpy(iv, piv, blks); 246 else 247 ivp = iv; 248 } 249 250 /* Copy back decrypted block */ 251 m_copyback(m, k, blks, blk); 252 253 /* Advance pointer */ 254 m = m_getptr(m, k + blks, &k); 255 if (m == NULL) 256 return EINVAL; 257 258 i -= blks; 259 260 /* Could be done... */ 261 if (i == 0) 262 break; 263 } 264 265 /* Skip possibly empty mbufs */ 266 if (k == m->m_len) { 267 for (m = m->m_next; m && m->m_len == 0; 268 m = m->m_next) 269 ; 270 k = 0; 271 } 272 273 /* Sanity check */ 274 if (m == NULL) 275 return EINVAL; 276 277 /* 278 * Warning: idat may point to garbage here, but 279 * we only use it in the while() loop, only if 280 * there are indeed enough data. 281 */ 282 idat = mtod(m, unsigned char *) + k; 283 284 while (m->m_len >= k + blks && i > 0) { 285 if (exf->reinit) { 286 if (crd->crd_flags & CRD_F_ENCRYPT) { 287 exf->encrypt(sw->sw_kschedule, 288 idat); 289 } else { 290 exf->decrypt(sw->sw_kschedule, 291 idat); 292 } 293 } else if (crd->crd_flags & CRD_F_ENCRYPT) { 294 /* XOR with previous block/IV */ 295 for (j = 0; j < blks; j++) 296 idat[j] ^= ivp[j]; 297 298 exf->encrypt(sw->sw_kschedule, idat); 299 ivp = idat; 300 } else { /* decrypt */ 301 /* 302 * Keep encrypted block to be used 303 * in next block's processing. 304 */ 305 if (ivp == iv) 306 memcpy(piv, idat, blks); 307 else 308 memcpy(iv, idat, blks); 309 310 exf->decrypt(sw->sw_kschedule, idat); 311 312 /* XOR with previous block/IV */ 313 for (j = 0; j < blks; j++) 314 idat[j] ^= ivp[j]; 315 316 if (ivp == iv) 317 memcpy(iv, piv, blks); 318 else 319 ivp = iv; 320 } 321 322 idat += blks; 323 k += blks; 324 i -= blks; 325 } 326 } 327 328 return 0; /* Done with mbuf encryption/decryption */ 329 } else if (outtype == CRYPTO_BUF_IOV) { 330 struct uio *uio = (struct uio *) buf; 331 332 /* Find beginning of data */ 333 count = crd->crd_skip; 334 ind = cuio_getptr(uio, count, &k); 335 if (ind == -1) 336 return EINVAL; 337 338 i = crd->crd_len; 339 340 while (i > 0) { 341 /* 342 * If there's insufficient data at the end, 343 * we have to do some copying. 344 */ 345 if (uio->uio_iov[ind].iov_len < k + blks && 346 uio->uio_iov[ind].iov_len != k) { 347 cuio_copydata(uio, k, blks, blk); 348 349 /* Actual encryption/decryption */ 350 if (exf->reinit) { 351 if (crd->crd_flags & CRD_F_ENCRYPT) { 352 exf->encrypt(sw->sw_kschedule, 353 blk); 354 } else { 355 exf->decrypt(sw->sw_kschedule, 356 blk); 357 } 358 } else if (crd->crd_flags & CRD_F_ENCRYPT) { 359 /* XOR with previous block */ 360 for (j = 0; j < blks; j++) 361 blk[j] ^= ivp[j]; 362 363 exf->encrypt(sw->sw_kschedule, blk); 364 365 /* 366 * Keep encrypted block for XOR'ing 367 * with next block 368 */ 369 memcpy(iv, blk, blks); 370 ivp = iv; 371 } else { /* decrypt */ 372 /* 373 * Keep encrypted block for XOR'ing 374 * with next block 375 */ 376 if (ivp == iv) 377 memcpy(piv, blk, blks); 378 else 379 memcpy(iv, blk, blks); 380 381 exf->decrypt(sw->sw_kschedule, blk); 382 383 /* XOR with previous block */ 384 for (j = 0; j < blks; j++) 385 blk[j] ^= ivp[j]; 386 387 if (ivp == iv) 388 memcpy(iv, piv, blks); 389 else 390 ivp = iv; 391 } 392 393 /* Copy back decrypted block */ 394 cuio_copyback(uio, k, blks, blk); 395 396 count += blks; 397 398 /* Advance pointer */ 399 ind = cuio_getptr(uio, count, &k); 400 if (ind == -1) 401 return (EINVAL); 402 403 i -= blks; 404 405 /* Could be done... */ 406 if (i == 0) 407 break; 408 } 409 410 /* 411 * Warning: idat may point to garbage here, but 412 * we only use it in the while() loop, only if 413 * there are indeed enough data. 414 */ 415 idat = ((char *)uio->uio_iov[ind].iov_base) + k; 416 417 while (uio->uio_iov[ind].iov_len >= k + blks && 418 i > 0) { 419 if (exf->reinit) { 420 if (crd->crd_flags & CRD_F_ENCRYPT) { 421 exf->encrypt(sw->sw_kschedule, 422 idat); 423 } else { 424 exf->decrypt(sw->sw_kschedule, 425 idat); 426 } 427 } else if (crd->crd_flags & CRD_F_ENCRYPT) { 428 /* XOR with previous block/IV */ 429 for (j = 0; j < blks; j++) 430 idat[j] ^= ivp[j]; 431 432 exf->encrypt(sw->sw_kschedule, idat); 433 ivp = idat; 434 } else { /* decrypt */ 435 /* 436 * Keep encrypted block to be used 437 * in next block's processing. 438 */ 439 if (ivp == iv) 440 memcpy(piv, idat, blks); 441 else 442 memcpy(iv, idat, blks); 443 444 exf->decrypt(sw->sw_kschedule, idat); 445 446 /* XOR with previous block/IV */ 447 for (j = 0; j < blks; j++) 448 idat[j] ^= ivp[j]; 449 450 if (ivp == iv) 451 memcpy(iv, piv, blks); 452 else 453 ivp = iv; 454 } 455 456 idat += blks; 457 count += blks; 458 k += blks; 459 i -= blks; 460 } 461 } 462 return 0; /* Done with mbuf encryption/decryption */ 463 } 464 465 /* Unreachable */ 466 return EINVAL; 467 } 468 469 /* 470 * Compute keyed-hash authenticator. 471 */ 472 int 473 swcr_authcompute(struct cryptop *crp, struct cryptodesc *crd, 474 const struct swcr_data *sw, void *buf, int outtype) 475 { 476 unsigned char aalg[AALG_MAX_RESULT_LEN]; 477 const struct swcr_auth_hash *axf; 478 union authctx ctx; 479 int err; 480 481 if (sw->sw_ictx == 0) 482 return EINVAL; 483 484 axf = sw->sw_axf; 485 486 memcpy(&ctx, sw->sw_ictx, axf->ctxsize); 487 488 switch (outtype) { 489 case CRYPTO_BUF_CONTIG: 490 axf->Update(&ctx, (char *)buf + crd->crd_skip, crd->crd_len); 491 break; 492 case CRYPTO_BUF_MBUF: 493 err = m_apply((struct mbuf *) buf, crd->crd_skip, crd->crd_len, 494 (int (*)(void*, void *, unsigned int)) axf->Update, 495 (void *) &ctx); 496 if (err) 497 return err; 498 break; 499 case CRYPTO_BUF_IOV: 500 err = cuio_apply((struct uio *) buf, crd->crd_skip, 501 crd->crd_len, 502 (int (*)(void *, void *, unsigned int)) axf->Update, 503 (void *) &ctx); 504 if (err) { 505 return err; 506 } 507 break; 508 default: 509 return EINVAL; 510 } 511 512 switch (sw->sw_alg) { 513 case CRYPTO_MD5_HMAC: 514 case CRYPTO_MD5_HMAC_96: 515 case CRYPTO_SHA1_HMAC: 516 case CRYPTO_SHA1_HMAC_96: 517 case CRYPTO_SHA2_256_HMAC: 518 case CRYPTO_SHA2_384_HMAC: 519 case CRYPTO_SHA2_512_HMAC: 520 case CRYPTO_RIPEMD160_HMAC: 521 case CRYPTO_RIPEMD160_HMAC_96: 522 if (sw->sw_octx == NULL) 523 return EINVAL; 524 525 axf->Final(aalg, &ctx); 526 memcpy(&ctx, sw->sw_octx, axf->ctxsize); 527 axf->Update(&ctx, aalg, axf->auth_hash->hashsize); 528 axf->Final(aalg, &ctx); 529 break; 530 531 case CRYPTO_MD5_KPDK: 532 case CRYPTO_SHA1_KPDK: 533 if (sw->sw_octx == NULL) 534 return EINVAL; 535 536 axf->Update(&ctx, sw->sw_octx, sw->sw_klen); 537 axf->Final(aalg, &ctx); 538 break; 539 540 case CRYPTO_NULL_HMAC: 541 case CRYPTO_MD5: 542 case CRYPTO_SHA1: 543 case CRYPTO_AES_XCBC_MAC_96: 544 axf->Final(aalg, &ctx); 545 break; 546 } 547 548 /* Inject the authentication data */ 549 switch (outtype) { 550 case CRYPTO_BUF_CONTIG: 551 (void)memcpy((char *)buf + crd->crd_inject, aalg, 552 axf->auth_hash->authsize); 553 break; 554 case CRYPTO_BUF_MBUF: 555 m_copyback((struct mbuf *) buf, crd->crd_inject, 556 axf->auth_hash->authsize, aalg); 557 break; 558 case CRYPTO_BUF_IOV: 559 memcpy(crp->crp_mac, aalg, axf->auth_hash->authsize); 560 break; 561 default: 562 return EINVAL; 563 } 564 return 0; 565 } 566 567 /* 568 * Apply a combined encryption-authentication transformation 569 */ 570 static int 571 swcr_combined(struct cryptop *crp, int outtype) 572 { 573 uint32_t blkbuf[howmany(EALG_MAX_BLOCK_LEN, sizeof(uint32_t))]; 574 u_char *blk = (u_char *)blkbuf; 575 u_char aalg[AALG_MAX_RESULT_LEN]; 576 u_char iv[EALG_MAX_BLOCK_LEN]; 577 union authctx ctx; 578 struct cryptodesc *crd, *crda = NULL, *crde = NULL; 579 struct swcr_data *sw, *swa, *swe = NULL; 580 const struct swcr_auth_hash *axf = NULL; 581 const struct swcr_enc_xform *exf = NULL; 582 void *buf = (void *)crp->crp_buf; 583 uint32_t *blkp; 584 int i, blksz = 0, ivlen = 0, len; 585 586 for (crd = crp->crp_desc; crd; crd = crd->crd_next) { 587 for (sw = swcr_sessions[crp->crp_sid & 0xffffffff]; 588 sw && sw->sw_alg != crd->crd_alg; 589 sw = sw->sw_next) 590 ; 591 if (sw == NULL) 592 return (EINVAL); 593 594 switch (sw->sw_alg) { 595 case CRYPTO_AES_GCM_16: 596 case CRYPTO_AES_GMAC: 597 swe = sw; 598 crde = crd; 599 exf = swe->sw_exf; 600 ivlen = exf->enc_xform->ivsize; 601 break; 602 case CRYPTO_AES_128_GMAC: 603 case CRYPTO_AES_192_GMAC: 604 case CRYPTO_AES_256_GMAC: 605 swa = sw; 606 crda = crd; 607 axf = swa->sw_axf; 608 if (swa->sw_ictx == 0) 609 return (EINVAL); 610 memcpy(&ctx, swa->sw_ictx, axf->ctxsize); 611 blksz = axf->auth_hash->blocksize; 612 break; 613 default: 614 return (EINVAL); 615 } 616 } 617 if (crde == NULL || crda == NULL) 618 return (EINVAL); 619 if (outtype == CRYPTO_BUF_CONTIG) 620 return (EINVAL); 621 622 /* Initialize the IV */ 623 if (crde->crd_flags & CRD_F_ENCRYPT) { 624 /* IV explicitly provided ? */ 625 if (crde->crd_flags & CRD_F_IV_EXPLICIT) { 626 memcpy(iv, crde->crd_iv, ivlen); 627 if (exf->reinit) 628 exf->reinit(swe->sw_kschedule, iv, 0); 629 } else if (exf->reinit) 630 exf->reinit(swe->sw_kschedule, 0, iv); 631 else 632 cprng_fast(iv, ivlen); 633 634 /* Do we need to write the IV */ 635 if (!(crde->crd_flags & CRD_F_IV_PRESENT)) 636 COPYBACK(outtype, buf, crde->crd_inject, ivlen, iv); 637 638 } else { /* Decryption */ 639 /* IV explicitly provided ? */ 640 if (crde->crd_flags & CRD_F_IV_EXPLICIT) 641 memcpy(iv, crde->crd_iv, ivlen); 642 else { 643 /* Get IV off buf */ 644 COPYDATA(outtype, buf, crde->crd_inject, ivlen, iv); 645 } 646 if (exf->reinit) 647 exf->reinit(swe->sw_kschedule, iv, 0); 648 } 649 650 /* Supply MAC with IV */ 651 if (axf->Reinit) 652 axf->Reinit(&ctx, iv, ivlen); 653 654 /* Supply MAC with AAD */ 655 for (i = 0; i < crda->crd_len; i += blksz) { 656 len = MIN(crda->crd_len - i, blksz); 657 COPYDATA(outtype, buf, crda->crd_skip + i, len, blk); 658 axf->Update(&ctx, blk, len); 659 } 660 661 /* Do encryption/decryption with MAC */ 662 for (i = 0; i < crde->crd_len; i += blksz) { 663 len = MIN(crde->crd_len - i, blksz); 664 if (len < blksz) 665 memset(blk, 0, blksz); 666 COPYDATA(outtype, buf, crde->crd_skip + i, len, blk); 667 if (crde->crd_flags & CRD_F_ENCRYPT) { 668 exf->encrypt(swe->sw_kschedule, blk); 669 axf->Update(&ctx, blk, len); 670 } else { 671 axf->Update(&ctx, blk, len); 672 exf->decrypt(swe->sw_kschedule, blk); 673 } 674 COPYBACK(outtype, buf, crde->crd_skip + i, len, blk); 675 } 676 677 /* Do any required special finalization */ 678 switch (crda->crd_alg) { 679 case CRYPTO_AES_128_GMAC: 680 case CRYPTO_AES_192_GMAC: 681 case CRYPTO_AES_256_GMAC: 682 /* length block */ 683 memset(blk, 0, blksz); 684 blkp = (uint32_t *)blk + 1; 685 *blkp = htobe32(crda->crd_len * 8); 686 blkp = (uint32_t *)blk + 3; 687 *blkp = htobe32(crde->crd_len * 8); 688 axf->Update(&ctx, blk, blksz); 689 break; 690 } 691 692 /* Finalize MAC */ 693 axf->Final(aalg, &ctx); 694 695 /* Inject the authentication data */ 696 if (outtype == CRYPTO_BUF_MBUF) 697 COPYBACK(outtype, buf, crda->crd_inject, axf->auth_hash->authsize, aalg); 698 else 699 memcpy(crp->crp_mac, aalg, axf->auth_hash->authsize); 700 701 return (0); 702 } 703 704 /* 705 * Apply a compression/decompression algorithm 706 */ 707 static int 708 swcr_compdec(struct cryptodesc *crd, const struct swcr_data *sw, 709 void *buf, int outtype, int *res_size) 710 { 711 u_int8_t *data, *out; 712 const struct swcr_comp_algo *cxf; 713 int adj; 714 u_int32_t result; 715 716 cxf = sw->sw_cxf; 717 718 /* We must handle the whole buffer of data in one time 719 * then if there is not all the data in the mbuf, we must 720 * copy in a buffer. 721 */ 722 723 data = malloc(crd->crd_len, M_CRYPTO_DATA, M_NOWAIT); 724 if (data == NULL) 725 return (EINVAL); 726 COPYDATA(outtype, buf, crd->crd_skip, crd->crd_len, data); 727 728 if (crd->crd_flags & CRD_F_COMP) 729 result = cxf->compress(data, crd->crd_len, &out); 730 else 731 result = cxf->decompress(data, crd->crd_len, &out, 732 *res_size); 733 734 free(data, M_CRYPTO_DATA); 735 if (result == 0) 736 return EINVAL; 737 738 /* Copy back the (de)compressed data. m_copyback is 739 * extending the mbuf as necessary. 740 */ 741 *res_size = (int)result; 742 /* Check the compressed size when doing compression */ 743 if (crd->crd_flags & CRD_F_COMP && 744 sw->sw_alg == CRYPTO_DEFLATE_COMP_NOGROW && 745 result >= crd->crd_len) { 746 /* Compression was useless, we lost time */ 747 free(out, M_CRYPTO_DATA); 748 return 0; 749 } 750 751 COPYBACK(outtype, buf, crd->crd_skip, result, out); 752 if (result < crd->crd_len) { 753 adj = result - crd->crd_len; 754 if (outtype == CRYPTO_BUF_MBUF) { 755 adj = result - crd->crd_len; 756 m_adj((struct mbuf *)buf, adj); 757 } 758 /* Don't adjust the iov_len, it breaks the kmem_free */ 759 } 760 free(out, M_CRYPTO_DATA); 761 return 0; 762 } 763 764 /* 765 * Generate a new software session. 766 */ 767 static int 768 swcr_newsession(void *arg, u_int32_t *sid, struct cryptoini *cri) 769 { 770 struct swcr_data **swd; 771 const struct swcr_auth_hash *axf; 772 const struct swcr_enc_xform *txf; 773 const struct swcr_comp_algo *cxf; 774 u_int32_t i; 775 int k, error; 776 777 if (sid == NULL || cri == NULL) 778 return EINVAL; 779 780 if (swcr_sessions) { 781 for (i = 1; i < swcr_sesnum; i++) 782 if (swcr_sessions[i] == NULL) 783 break; 784 } else 785 i = 1; /* NB: to silence compiler warning */ 786 787 if (swcr_sessions == NULL || i == swcr_sesnum) { 788 if (swcr_sessions == NULL) { 789 i = 1; /* We leave swcr_sessions[0] empty */ 790 swcr_sesnum = CRYPTO_SW_SESSIONS; 791 } else 792 swcr_sesnum *= 2; 793 794 swd = malloc(swcr_sesnum * sizeof(struct swcr_data *), 795 M_CRYPTO_DATA, M_NOWAIT); 796 if (swd == NULL) { 797 /* Reset session number */ 798 if (swcr_sesnum == CRYPTO_SW_SESSIONS) 799 swcr_sesnum = 0; 800 else 801 swcr_sesnum /= 2; 802 return ENOBUFS; 803 } 804 805 memset(swd, 0, swcr_sesnum * sizeof(struct swcr_data *)); 806 807 /* Copy existing sessions */ 808 if (swcr_sessions) { 809 memcpy(swd, swcr_sessions, 810 (swcr_sesnum / 2) * sizeof(struct swcr_data *)); 811 free(swcr_sessions, M_CRYPTO_DATA); 812 } 813 814 swcr_sessions = swd; 815 } 816 817 swd = &swcr_sessions[i]; 818 *sid = i; 819 820 while (cri) { 821 *swd = malloc(sizeof **swd, M_CRYPTO_DATA, M_NOWAIT); 822 if (*swd == NULL) { 823 swcr_freesession(NULL, i); 824 return ENOBUFS; 825 } 826 memset(*swd, 0, sizeof(struct swcr_data)); 827 828 switch (cri->cri_alg) { 829 case CRYPTO_DES_CBC: 830 txf = &swcr_enc_xform_des; 831 goto enccommon; 832 case CRYPTO_3DES_CBC: 833 txf = &swcr_enc_xform_3des; 834 goto enccommon; 835 case CRYPTO_BLF_CBC: 836 txf = &swcr_enc_xform_blf; 837 goto enccommon; 838 case CRYPTO_CAST_CBC: 839 txf = &swcr_enc_xform_cast5; 840 goto enccommon; 841 case CRYPTO_SKIPJACK_CBC: 842 txf = &swcr_enc_xform_skipjack; 843 goto enccommon; 844 case CRYPTO_RIJNDAEL128_CBC: 845 txf = &swcr_enc_xform_rijndael128; 846 goto enccommon; 847 case CRYPTO_CAMELLIA_CBC: 848 txf = &swcr_enc_xform_camellia; 849 goto enccommon; 850 case CRYPTO_AES_CTR: 851 txf = &swcr_enc_xform_aes_ctr; 852 goto enccommon; 853 case CRYPTO_AES_GCM_16: 854 txf = &swcr_enc_xform_aes_gcm; 855 goto enccommon; 856 case CRYPTO_AES_GMAC: 857 txf = &swcr_enc_xform_aes_gmac; 858 goto enccommon; 859 case CRYPTO_NULL_CBC: 860 txf = &swcr_enc_xform_null; 861 goto enccommon; 862 enccommon: 863 error = txf->setkey(&((*swd)->sw_kschedule), 864 cri->cri_key, cri->cri_klen / 8); 865 if (error) { 866 swcr_freesession(NULL, i); 867 return error; 868 } 869 (*swd)->sw_exf = txf; 870 break; 871 872 case CRYPTO_MD5_HMAC: 873 axf = &swcr_auth_hash_hmac_md5; 874 goto authcommon; 875 case CRYPTO_MD5_HMAC_96: 876 axf = &swcr_auth_hash_hmac_md5_96; 877 goto authcommon; 878 case CRYPTO_SHA1_HMAC: 879 axf = &swcr_auth_hash_hmac_sha1; 880 goto authcommon; 881 case CRYPTO_SHA1_HMAC_96: 882 axf = &swcr_auth_hash_hmac_sha1_96; 883 goto authcommon; 884 case CRYPTO_SHA2_256_HMAC: 885 axf = &swcr_auth_hash_hmac_sha2_256; 886 goto authcommon; 887 case CRYPTO_SHA2_384_HMAC: 888 axf = &swcr_auth_hash_hmac_sha2_384; 889 goto authcommon; 890 case CRYPTO_SHA2_512_HMAC: 891 axf = &swcr_auth_hash_hmac_sha2_512; 892 goto authcommon; 893 case CRYPTO_NULL_HMAC: 894 axf = &swcr_auth_hash_null; 895 goto authcommon; 896 case CRYPTO_RIPEMD160_HMAC: 897 axf = &swcr_auth_hash_hmac_ripemd_160; 898 goto authcommon; 899 case CRYPTO_RIPEMD160_HMAC_96: 900 axf = &swcr_auth_hash_hmac_ripemd_160_96; 901 goto authcommon; /* leave this for safety */ 902 authcommon: 903 (*swd)->sw_ictx = malloc(axf->ctxsize, 904 M_CRYPTO_DATA, M_NOWAIT); 905 if ((*swd)->sw_ictx == NULL) { 906 swcr_freesession(NULL, i); 907 return ENOBUFS; 908 } 909 910 (*swd)->sw_octx = malloc(axf->ctxsize, 911 M_CRYPTO_DATA, M_NOWAIT); 912 if ((*swd)->sw_octx == NULL) { 913 swcr_freesession(NULL, i); 914 return ENOBUFS; 915 } 916 917 for (k = 0; k < cri->cri_klen / 8; k++) 918 cri->cri_key[k] ^= HMAC_IPAD_VAL; 919 920 axf->Init((*swd)->sw_ictx); 921 axf->Update((*swd)->sw_ictx, cri->cri_key, 922 cri->cri_klen / 8); 923 axf->Update((*swd)->sw_ictx, hmac_ipad_buffer, 924 axf->auth_hash->blocksize - (cri->cri_klen / 8)); 925 926 for (k = 0; k < cri->cri_klen / 8; k++) 927 cri->cri_key[k] ^= (HMAC_IPAD_VAL ^ HMAC_OPAD_VAL); 928 929 axf->Init((*swd)->sw_octx); 930 axf->Update((*swd)->sw_octx, cri->cri_key, 931 cri->cri_klen / 8); 932 axf->Update((*swd)->sw_octx, hmac_opad_buffer, 933 axf->auth_hash->blocksize - (cri->cri_klen / 8)); 934 935 for (k = 0; k < cri->cri_klen / 8; k++) 936 cri->cri_key[k] ^= HMAC_OPAD_VAL; 937 (*swd)->sw_axf = axf; 938 break; 939 940 case CRYPTO_MD5_KPDK: 941 axf = &swcr_auth_hash_key_md5; 942 goto auth2common; 943 944 case CRYPTO_SHA1_KPDK: 945 axf = &swcr_auth_hash_key_sha1; 946 auth2common: 947 (*swd)->sw_ictx = malloc(axf->ctxsize, 948 M_CRYPTO_DATA, M_NOWAIT); 949 if ((*swd)->sw_ictx == NULL) { 950 swcr_freesession(NULL, i); 951 return ENOBUFS; 952 } 953 954 /* Store the key so we can "append" it to the payload */ 955 (*swd)->sw_octx = malloc(cri->cri_klen / 8, M_CRYPTO_DATA, 956 M_NOWAIT); 957 if ((*swd)->sw_octx == NULL) { 958 swcr_freesession(NULL, i); 959 return ENOBUFS; 960 } 961 962 (*swd)->sw_klen = cri->cri_klen / 8; 963 memcpy((*swd)->sw_octx, cri->cri_key, cri->cri_klen / 8); 964 axf->Init((*swd)->sw_ictx); 965 axf->Update((*swd)->sw_ictx, cri->cri_key, 966 cri->cri_klen / 8); 967 axf->Final(NULL, (*swd)->sw_ictx); 968 (*swd)->sw_axf = axf; 969 break; 970 971 case CRYPTO_MD5: 972 axf = &swcr_auth_hash_md5; 973 goto auth3common; 974 975 case CRYPTO_SHA1: 976 axf = &swcr_auth_hash_sha1; 977 auth3common: 978 (*swd)->sw_ictx = malloc(axf->ctxsize, 979 M_CRYPTO_DATA, M_NOWAIT); 980 if ((*swd)->sw_ictx == NULL) { 981 swcr_freesession(NULL, i); 982 return ENOBUFS; 983 } 984 985 axf->Init((*swd)->sw_ictx); 986 (*swd)->sw_axf = axf; 987 break; 988 989 case CRYPTO_AES_XCBC_MAC_96: 990 axf = &swcr_auth_hash_aes_xcbc_mac; 991 goto auth4common; 992 case CRYPTO_AES_128_GMAC: 993 axf = &swcr_auth_hash_gmac_aes_128; 994 goto auth4common; 995 case CRYPTO_AES_192_GMAC: 996 axf = &swcr_auth_hash_gmac_aes_192; 997 goto auth4common; 998 case CRYPTO_AES_256_GMAC: 999 axf = &swcr_auth_hash_gmac_aes_256; 1000 auth4common: 1001 (*swd)->sw_ictx = malloc(axf->ctxsize, 1002 M_CRYPTO_DATA, M_NOWAIT); 1003 if ((*swd)->sw_ictx == NULL) { 1004 swcr_freesession(NULL, i); 1005 return ENOBUFS; 1006 } 1007 axf->Init((*swd)->sw_ictx); 1008 axf->Setkey((*swd)->sw_ictx, 1009 cri->cri_key, cri->cri_klen / 8); 1010 (*swd)->sw_axf = axf; 1011 break; 1012 1013 case CRYPTO_DEFLATE_COMP: 1014 cxf = &swcr_comp_algo_deflate; 1015 (*swd)->sw_cxf = cxf; 1016 break; 1017 1018 case CRYPTO_DEFLATE_COMP_NOGROW: 1019 cxf = &swcr_comp_algo_deflate_nogrow; 1020 (*swd)->sw_cxf = cxf; 1021 break; 1022 1023 case CRYPTO_GZIP_COMP: 1024 cxf = &swcr_comp_algo_gzip; 1025 (*swd)->sw_cxf = cxf; 1026 break; 1027 default: 1028 swcr_freesession(NULL, i); 1029 return EINVAL; 1030 } 1031 1032 (*swd)->sw_alg = cri->cri_alg; 1033 cri = cri->cri_next; 1034 swd = &((*swd)->sw_next); 1035 } 1036 return 0; 1037 } 1038 1039 /* 1040 * Free a session. 1041 */ 1042 static int 1043 swcr_freesession(void *arg, u_int64_t tid) 1044 { 1045 struct swcr_data *swd; 1046 const struct swcr_enc_xform *txf; 1047 const struct swcr_auth_hash *axf; 1048 const struct swcr_comp_algo *cxf; 1049 u_int32_t sid = ((u_int32_t) tid) & 0xffffffff; 1050 1051 if (sid > swcr_sesnum || swcr_sessions == NULL || 1052 swcr_sessions[sid] == NULL) 1053 return EINVAL; 1054 1055 /* Silently accept and return */ 1056 if (sid == 0) 1057 return 0; 1058 1059 while ((swd = swcr_sessions[sid]) != NULL) { 1060 swcr_sessions[sid] = swd->sw_next; 1061 1062 switch (swd->sw_alg) { 1063 case CRYPTO_DES_CBC: 1064 case CRYPTO_3DES_CBC: 1065 case CRYPTO_BLF_CBC: 1066 case CRYPTO_CAST_CBC: 1067 case CRYPTO_SKIPJACK_CBC: 1068 case CRYPTO_RIJNDAEL128_CBC: 1069 case CRYPTO_CAMELLIA_CBC: 1070 case CRYPTO_AES_CTR: 1071 case CRYPTO_AES_GCM_16: 1072 case CRYPTO_AES_GMAC: 1073 case CRYPTO_NULL_CBC: 1074 txf = swd->sw_exf; 1075 1076 if (swd->sw_kschedule) 1077 txf->zerokey(&(swd->sw_kschedule)); 1078 break; 1079 1080 case CRYPTO_MD5_HMAC: 1081 case CRYPTO_MD5_HMAC_96: 1082 case CRYPTO_SHA1_HMAC: 1083 case CRYPTO_SHA1_HMAC_96: 1084 case CRYPTO_SHA2_256_HMAC: 1085 case CRYPTO_SHA2_384_HMAC: 1086 case CRYPTO_SHA2_512_HMAC: 1087 case CRYPTO_RIPEMD160_HMAC: 1088 case CRYPTO_RIPEMD160_HMAC_96: 1089 case CRYPTO_NULL_HMAC: 1090 axf = swd->sw_axf; 1091 1092 if (swd->sw_ictx) { 1093 explicit_bzero(swd->sw_ictx, axf->ctxsize); 1094 free(swd->sw_ictx, M_CRYPTO_DATA); 1095 } 1096 if (swd->sw_octx) { 1097 explicit_bzero(swd->sw_octx, axf->ctxsize); 1098 free(swd->sw_octx, M_CRYPTO_DATA); 1099 } 1100 break; 1101 1102 case CRYPTO_MD5_KPDK: 1103 case CRYPTO_SHA1_KPDK: 1104 axf = swd->sw_axf; 1105 1106 if (swd->sw_ictx) { 1107 explicit_bzero(swd->sw_ictx, axf->ctxsize); 1108 free(swd->sw_ictx, M_CRYPTO_DATA); 1109 } 1110 if (swd->sw_octx) { 1111 explicit_bzero(swd->sw_octx, swd->sw_klen); 1112 free(swd->sw_octx, M_CRYPTO_DATA); 1113 } 1114 break; 1115 1116 case CRYPTO_MD5: 1117 case CRYPTO_SHA1: 1118 case CRYPTO_AES_XCBC_MAC_96: 1119 case CRYPTO_AES_128_GMAC: 1120 case CRYPTO_AES_192_GMAC: 1121 case CRYPTO_AES_256_GMAC: 1122 axf = swd->sw_axf; 1123 1124 if (swd->sw_ictx) { 1125 explicit_bzero(swd->sw_ictx, axf->ctxsize); 1126 free(swd->sw_ictx, M_CRYPTO_DATA); 1127 } 1128 break; 1129 1130 case CRYPTO_DEFLATE_COMP: 1131 case CRYPTO_DEFLATE_COMP_NOGROW: 1132 case CRYPTO_GZIP_COMP: 1133 cxf = swd->sw_cxf; 1134 break; 1135 } 1136 1137 free(swd, M_CRYPTO_DATA); 1138 } 1139 return 0; 1140 } 1141 1142 /* 1143 * Process a software request. 1144 */ 1145 static int 1146 swcr_process(void *arg, struct cryptop *crp, int hint) 1147 { 1148 struct cryptodesc *crd; 1149 struct swcr_data *sw; 1150 u_int32_t lid; 1151 int type; 1152 1153 /* Sanity check */ 1154 if (crp == NULL) 1155 return EINVAL; 1156 1157 if (crp->crp_desc == NULL || crp->crp_buf == NULL) { 1158 crp->crp_etype = EINVAL; 1159 goto done; 1160 } 1161 1162 lid = crp->crp_sid & 0xffffffff; 1163 if (lid >= swcr_sesnum || lid == 0 || swcr_sessions[lid] == NULL) { 1164 crp->crp_etype = ENOENT; 1165 goto done; 1166 } 1167 1168 if (crp->crp_flags & CRYPTO_F_IMBUF) { 1169 type = CRYPTO_BUF_MBUF; 1170 } else if (crp->crp_flags & CRYPTO_F_IOV) { 1171 type = CRYPTO_BUF_IOV; 1172 } else { 1173 type = CRYPTO_BUF_CONTIG; 1174 } 1175 1176 /* Go through crypto descriptors, processing as we go */ 1177 for (crd = crp->crp_desc; crd; crd = crd->crd_next) { 1178 /* 1179 * Find the crypto context. 1180 * 1181 * XXX Note that the logic here prevents us from having 1182 * XXX the same algorithm multiple times in a session 1183 * XXX (or rather, we can but it won't give us the right 1184 * XXX results). To do that, we'd need some way of differentiating 1185 * XXX between the various instances of an algorithm (so we can 1186 * XXX locate the correct crypto context). 1187 */ 1188 for (sw = swcr_sessions[lid]; 1189 sw && sw->sw_alg != crd->crd_alg; 1190 sw = sw->sw_next) 1191 ; 1192 1193 /* No such context ? */ 1194 if (sw == NULL) { 1195 crp->crp_etype = EINVAL; 1196 goto done; 1197 } 1198 1199 switch (sw->sw_alg) { 1200 case CRYPTO_DES_CBC: 1201 case CRYPTO_3DES_CBC: 1202 case CRYPTO_BLF_CBC: 1203 case CRYPTO_CAST_CBC: 1204 case CRYPTO_SKIPJACK_CBC: 1205 case CRYPTO_RIJNDAEL128_CBC: 1206 case CRYPTO_CAMELLIA_CBC: 1207 case CRYPTO_AES_CTR: 1208 if ((crp->crp_etype = swcr_encdec(crd, sw, 1209 crp->crp_buf, type)) != 0) 1210 goto done; 1211 break; 1212 case CRYPTO_NULL_CBC: 1213 crp->crp_etype = 0; 1214 break; 1215 case CRYPTO_MD5_HMAC: 1216 case CRYPTO_MD5_HMAC_96: 1217 case CRYPTO_SHA1_HMAC: 1218 case CRYPTO_SHA1_HMAC_96: 1219 case CRYPTO_SHA2_256_HMAC: 1220 case CRYPTO_SHA2_384_HMAC: 1221 case CRYPTO_SHA2_512_HMAC: 1222 case CRYPTO_RIPEMD160_HMAC: 1223 case CRYPTO_RIPEMD160_HMAC_96: 1224 case CRYPTO_NULL_HMAC: 1225 case CRYPTO_MD5_KPDK: 1226 case CRYPTO_SHA1_KPDK: 1227 case CRYPTO_MD5: 1228 case CRYPTO_SHA1: 1229 case CRYPTO_AES_XCBC_MAC_96: 1230 if ((crp->crp_etype = swcr_authcompute(crp, crd, sw, 1231 crp->crp_buf, type)) != 0) 1232 goto done; 1233 break; 1234 1235 case CRYPTO_AES_GCM_16: 1236 case CRYPTO_AES_GMAC: 1237 case CRYPTO_AES_128_GMAC: 1238 case CRYPTO_AES_192_GMAC: 1239 case CRYPTO_AES_256_GMAC: 1240 crp->crp_etype = swcr_combined(crp, type); 1241 goto done; 1242 1243 case CRYPTO_DEFLATE_COMP: 1244 case CRYPTO_DEFLATE_COMP_NOGROW: 1245 case CRYPTO_GZIP_COMP: 1246 DPRINTF(("swcr_process: compdec for %d\n", sw->sw_alg)); 1247 if ((crp->crp_etype = swcr_compdec(crd, sw, 1248 crp->crp_buf, type, &crp->crp_olen)) != 0) 1249 goto done; 1250 break; 1251 1252 default: 1253 /* Unknown/unsupported algorithm */ 1254 crp->crp_etype = EINVAL; 1255 goto done; 1256 } 1257 } 1258 1259 done: 1260 DPRINTF(("request %p done\n", crp)); 1261 crypto_done(crp); 1262 return 0; 1263 } 1264 1265 static void 1266 swcr_init(void) 1267 { 1268 swcr_id = crypto_get_driverid(CRYPTOCAP_F_SOFTWARE); 1269 if (swcr_id < 0) { 1270 /* This should never happen */ 1271 panic("Software crypto device cannot initialize!"); 1272 } 1273 1274 crypto_register(swcr_id, CRYPTO_DES_CBC, 1275 0, 0, swcr_newsession, swcr_freesession, swcr_process, NULL); 1276 #define REGISTER(alg) \ 1277 crypto_register(swcr_id, alg, 0, 0, NULL, NULL, NULL, NULL) 1278 1279 REGISTER(CRYPTO_3DES_CBC); 1280 REGISTER(CRYPTO_BLF_CBC); 1281 REGISTER(CRYPTO_CAST_CBC); 1282 REGISTER(CRYPTO_SKIPJACK_CBC); 1283 REGISTER(CRYPTO_CAMELLIA_CBC); 1284 REGISTER(CRYPTO_AES_CTR); 1285 REGISTER(CRYPTO_AES_GCM_16); 1286 REGISTER(CRYPTO_AES_GMAC); 1287 REGISTER(CRYPTO_NULL_CBC); 1288 REGISTER(CRYPTO_MD5_HMAC); 1289 REGISTER(CRYPTO_MD5_HMAC_96); 1290 REGISTER(CRYPTO_SHA1_HMAC); 1291 REGISTER(CRYPTO_SHA1_HMAC_96); 1292 REGISTER(CRYPTO_SHA2_256_HMAC); 1293 REGISTER(CRYPTO_SHA2_384_HMAC); 1294 REGISTER(CRYPTO_SHA2_512_HMAC); 1295 REGISTER(CRYPTO_RIPEMD160_HMAC); 1296 REGISTER(CRYPTO_RIPEMD160_HMAC_96); 1297 REGISTER(CRYPTO_NULL_HMAC); 1298 REGISTER(CRYPTO_MD5_KPDK); 1299 REGISTER(CRYPTO_SHA1_KPDK); 1300 REGISTER(CRYPTO_MD5); 1301 REGISTER(CRYPTO_SHA1); 1302 REGISTER(CRYPTO_AES_XCBC_MAC_96); 1303 REGISTER(CRYPTO_AES_128_GMAC); 1304 REGISTER(CRYPTO_AES_192_GMAC); 1305 REGISTER(CRYPTO_AES_256_GMAC); 1306 REGISTER(CRYPTO_RIJNDAEL128_CBC); 1307 REGISTER(CRYPTO_DEFLATE_COMP); 1308 REGISTER(CRYPTO_DEFLATE_COMP_NOGROW); 1309 REGISTER(CRYPTO_GZIP_COMP); 1310 #undef REGISTER 1311 } 1312 1313 1314 /* 1315 * Pseudo-device init routine for software crypto. 1316 */ 1317 void swcryptoattach(int); 1318 1319 void 1320 swcryptoattach(int num) 1321 { 1322 1323 swcr_init(); 1324 } 1325
Indexes created Tue Sep 23 02:09:52 GMT 2025