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