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