cryptodev.c revision 1.102 1 1.102 hikaru /* $NetBSD: cryptodev.c,v 1.102 2019/11/29 08:30:30 hikaru Exp $ */
2 1.4 jonathan /* $FreeBSD: src/sys/opencrypto/cryptodev.c,v 1.4.2.4 2003/06/03 00:09:02 sam Exp $ */
3 1.1 jonathan /* $OpenBSD: cryptodev.c,v 1.53 2002/07/10 22:21:30 mickey Exp $ */
4 1.1 jonathan
5 1.36 tls /*-
6 1.36 tls * Copyright (c) 2008 The NetBSD Foundation, Inc.
7 1.36 tls * All rights reserved.
8 1.36 tls *
9 1.36 tls * This code is derived from software contributed to The NetBSD Foundation
10 1.36 tls * by Coyote Point Systems, Inc.
11 1.36 tls *
12 1.36 tls * Redistribution and use in source and binary forms, with or without
13 1.36 tls * modification, are permitted provided that the following conditions
14 1.36 tls * are met:
15 1.36 tls * 1. Redistributions of source code must retain the above copyright
16 1.36 tls * notice, this list of conditions and the following disclaimer.
17 1.36 tls * 2. Redistributions in binary form must reproduce the above copyright
18 1.36 tls * notice, this list of conditions and the following disclaimer in the
19 1.36 tls * documentation and/or other materials provided with the distribution.
20 1.36 tls *
21 1.36 tls * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22 1.36 tls * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23 1.36 tls * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 1.36 tls * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25 1.36 tls * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 1.36 tls * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 1.36 tls * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 1.36 tls * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 1.36 tls * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 1.36 tls * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 1.36 tls * POSSIBILITY OF SUCH DAMAGE.
32 1.36 tls */
33 1.36 tls
34 1.1 jonathan /*
35 1.1 jonathan * Copyright (c) 2001 Theo de Raadt
36 1.1 jonathan *
37 1.1 jonathan * Redistribution and use in source and binary forms, with or without
38 1.1 jonathan * modification, are permitted provided that the following conditions
39 1.1 jonathan * are met:
40 1.1 jonathan *
41 1.1 jonathan * 1. Redistributions of source code must retain the above copyright
42 1.1 jonathan * notice, this list of conditions and the following disclaimer.
43 1.1 jonathan * 2. Redistributions in binary form must reproduce the above copyright
44 1.1 jonathan * notice, this list of conditions and the following disclaimer in the
45 1.1 jonathan * documentation and/or other materials provided with the distribution.
46 1.1 jonathan * 3. The name of the author may not be used to endorse or promote products
47 1.1 jonathan * derived from this software without specific prior written permission.
48 1.1 jonathan *
49 1.1 jonathan * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
50 1.1 jonathan * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
51 1.1 jonathan * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
52 1.1 jonathan * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
53 1.1 jonathan * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
54 1.1 jonathan * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
55 1.1 jonathan * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
56 1.1 jonathan * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
57 1.1 jonathan * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
58 1.1 jonathan * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 1.1 jonathan *
60 1.1 jonathan * Effort sponsored in part by the Defense Advanced Research Projects
61 1.1 jonathan * Agency (DARPA) and Air Force Research Laboratory, Air Force
62 1.1 jonathan * Materiel Command, USAF, under agreement number F30602-01-2-0537.
63 1.1 jonathan *
64 1.1 jonathan */
65 1.1 jonathan
66 1.1 jonathan #include <sys/cdefs.h>
67 1.102 hikaru __KERNEL_RCSID(0, "$NetBSD: cryptodev.c,v 1.102 2019/11/29 08:30:30 hikaru Exp $");
68 1.1 jonathan
69 1.1 jonathan #include <sys/param.h>
70 1.1 jonathan #include <sys/systm.h>
71 1.36 tls #include <sys/kmem.h>
72 1.1 jonathan #include <sys/malloc.h>
73 1.1 jonathan #include <sys/mbuf.h>
74 1.29 tls #include <sys/pool.h>
75 1.1 jonathan #include <sys/sysctl.h>
76 1.1 jonathan #include <sys/file.h>
77 1.1 jonathan #include <sys/filedesc.h>
78 1.1 jonathan #include <sys/errno.h>
79 1.2 jonathan #include <sys/md5.h>
80 1.1 jonathan #include <sys/sha1.h>
81 1.1 jonathan #include <sys/conf.h>
82 1.1 jonathan #include <sys/device.h>
83 1.21 elad #include <sys/kauth.h>
84 1.36 tls #include <sys/select.h>
85 1.36 tls #include <sys/poll.h>
86 1.37 dogcow #include <sys/atomic.h>
87 1.48 christos #include <sys/stat.h>
88 1.70 pgoyette #include <sys/module.h>
89 1.99 pgoyette #include <sys/compat_stub.h>
90 1.1 jonathan
91 1.70 pgoyette #ifdef _KERNEL_OPT
92 1.33 tls #include "opt_ocf.h"
93 1.55 drochner #include "opt_compat_netbsd.h"
94 1.70 pgoyette #endif
95 1.70 pgoyette
96 1.1 jonathan #include <opencrypto/cryptodev.h>
97 1.99 pgoyette #include <opencrypto/ocryptodev.h>
98 1.55 drochner #include <opencrypto/cryptodev_internal.h>
99 1.1 jonathan #include <opencrypto/xform.h>
100 1.1 jonathan
101 1.84 christos #include "ioconf.h"
102 1.84 christos
103 1.92 knakahar kmutex_t cryptodev_mtx;
104 1.89 knakahar
105 1.1 jonathan struct csession {
106 1.1 jonathan TAILQ_ENTRY(csession) next;
107 1.1 jonathan u_int64_t sid;
108 1.1 jonathan u_int32_t ses;
109 1.1 jonathan
110 1.46 darran u_int32_t cipher; /* note: shares name space in crd_alg */
111 1.54 drochner const struct enc_xform *txform;
112 1.46 darran u_int32_t mac; /* note: shares name space in crd_alg */
113 1.54 drochner const struct auth_hash *thash;
114 1.46 darran u_int32_t comp_alg; /* note: shares name space in crd_alg */
115 1.54 drochner const struct comp_algo *tcomp;
116 1.1 jonathan
117 1.26 christos void * key;
118 1.1 jonathan int keylen;
119 1.1 jonathan u_char tmp_iv[EALG_MAX_BLOCK_LEN];
120 1.1 jonathan
121 1.26 christos void * mackey;
122 1.1 jonathan int mackeylen;
123 1.1 jonathan u_char tmp_mac[CRYPTO_MAX_MAC_LEN];
124 1.1 jonathan
125 1.29 tls struct iovec iovec[1]; /* user requests never have more */
126 1.1 jonathan struct uio uio;
127 1.1 jonathan int error;
128 1.1 jonathan };
129 1.1 jonathan
130 1.1 jonathan struct fcrypt {
131 1.1 jonathan TAILQ_HEAD(csessionlist, csession) csessions;
132 1.36 tls TAILQ_HEAD(crprethead, cryptop) crp_ret_mq;
133 1.36 tls TAILQ_HEAD(krprethead, cryptkop) crp_ret_mkq;
134 1.1 jonathan int sesn;
135 1.36 tls struct selinfo sinfo;
136 1.36 tls u_int32_t requestid;
137 1.48 christos struct timespec atime;
138 1.48 christos struct timespec mtime;
139 1.48 christos struct timespec btime;
140 1.1 jonathan };
141 1.1 jonathan
142 1.29 tls /* For our fixed-size allocations */
143 1.38 rmind static struct pool fcrpl;
144 1.38 rmind static struct pool csepl;
145 1.1 jonathan
146 1.1 jonathan /* Declaration of master device (fd-cloning/ctxt-allocating) entrypoints */
147 1.16 christos static int cryptoopen(dev_t dev, int flag, int mode, struct lwp *l);
148 1.1 jonathan static int cryptoread(dev_t dev, struct uio *uio, int ioflag);
149 1.1 jonathan static int cryptowrite(dev_t dev, struct uio *uio, int ioflag);
150 1.16 christos static int cryptoselect(dev_t dev, int rw, struct lwp *l);
151 1.1 jonathan
152 1.74 pgoyette static int crypto_refcount = 0; /* Prevent detaching while in use */
153 1.74 pgoyette
154 1.1 jonathan /* Declaration of cloned-device (per-ctxt) entrypoints */
155 1.36 tls static int cryptof_read(struct file *, off_t *, struct uio *,
156 1.42 christos kauth_cred_t, int);
157 1.36 tls static int cryptof_write(struct file *, off_t *, struct uio *,
158 1.42 christos kauth_cred_t, int);
159 1.36 tls static int cryptof_ioctl(struct file *, u_long, void *);
160 1.36 tls static int cryptof_close(struct file *);
161 1.36 tls static int cryptof_poll(struct file *, int);
162 1.48 christos static int cryptof_stat(struct file *, struct stat *);
163 1.1 jonathan
164 1.12 christos static const struct fileops cryptofops = {
165 1.97 christos .fo_name = "cryptof",
166 1.47 ad .fo_read = cryptof_read,
167 1.47 ad .fo_write = cryptof_write,
168 1.47 ad .fo_ioctl = cryptof_ioctl,
169 1.47 ad .fo_fcntl = fnullop_fcntl,
170 1.47 ad .fo_poll = cryptof_poll,
171 1.48 christos .fo_stat = cryptof_stat,
172 1.47 ad .fo_close = cryptof_close,
173 1.47 ad .fo_kqfilter = fnullop_kqfilter,
174 1.51 dsl .fo_restart = fnullop_restart,
175 1.1 jonathan };
176 1.1 jonathan
177 1.46 darran struct csession *cryptodev_csefind(struct fcrypt *, u_int);
178 1.1 jonathan static struct csession *csefind(struct fcrypt *, u_int);
179 1.1 jonathan static int csedelete(struct fcrypt *, struct csession *);
180 1.1 jonathan static struct csession *cseadd(struct fcrypt *, struct csession *);
181 1.42 christos static struct csession *csecreate(struct fcrypt *, u_int64_t, void *,
182 1.46 darran u_int64_t, void *, u_int64_t, u_int32_t, u_int32_t, u_int32_t,
183 1.54 drochner const struct enc_xform *, const struct auth_hash *,
184 1.54 drochner const struct comp_algo *);
185 1.1 jonathan static int csefree(struct csession *);
186 1.1 jonathan
187 1.1 jonathan static int cryptodev_key(struct crypt_kop *);
188 1.36 tls static int cryptodev_mkey(struct fcrypt *, struct crypt_n_kop *, int);
189 1.36 tls static int cryptodev_msessionfin(struct fcrypt *, int, u_int32_t *);
190 1.1 jonathan
191 1.1 jonathan static int cryptodev_cb(void *);
192 1.1 jonathan static int cryptodevkey_cb(void *);
193 1.1 jonathan
194 1.36 tls static int cryptodev_mcb(void *);
195 1.36 tls static int cryptodevkey_mcb(void *);
196 1.36 tls
197 1.36 tls static int cryptodev_getmstatus(struct fcrypt *, struct crypt_result *,
198 1.42 christos int);
199 1.36 tls static int cryptodev_getstatus(struct fcrypt *, struct crypt_result *);
200 1.36 tls
201 1.9 jonathan /*
202 1.9 jonathan * sysctl-able control variables for /dev/crypto now defined in crypto.c:
203 1.9 jonathan * crypto_usercrypto, crypto_userasmcrypto, crypto_devallowsoft.
204 1.9 jonathan */
205 1.1 jonathan
206 1.1 jonathan /* ARGSUSED */
207 1.1 jonathan int
208 1.35 ad cryptof_read(file_t *fp, off_t *poff,
209 1.25 christos struct uio *uio, kauth_cred_t cred, int flags)
210 1.1 jonathan {
211 1.42 christos return EIO;
212 1.1 jonathan }
213 1.1 jonathan
214 1.1 jonathan /* ARGSUSED */
215 1.1 jonathan int
216 1.35 ad cryptof_write(file_t *fp, off_t *poff,
217 1.25 christos struct uio *uio, kauth_cred_t cred, int flags)
218 1.1 jonathan {
219 1.42 christos return EIO;
220 1.1 jonathan }
221 1.1 jonathan
222 1.1 jonathan /* ARGSUSED */
223 1.1 jonathan int
224 1.36 tls cryptof_ioctl(struct file *fp, u_long cmd, void *data)
225 1.1 jonathan {
226 1.81 matt struct fcrypt *fcr = fp->f_fcrypt;
227 1.1 jonathan struct csession *cse;
228 1.1 jonathan struct session_op *sop;
229 1.36 tls struct session_n_op *snop;
230 1.1 jonathan struct crypt_op *cop;
231 1.36 tls struct crypt_mop *mop;
232 1.36 tls struct crypt_mkop *mkop;
233 1.36 tls struct crypt_n_op *cnop;
234 1.36 tls struct crypt_n_kop *knop;
235 1.36 tls struct crypt_sgop *sgop;
236 1.36 tls struct crypt_sfop *sfop;
237 1.36 tls struct cryptret *crypt_ret;
238 1.36 tls struct crypt_result *crypt_res;
239 1.1 jonathan u_int32_t ses;
240 1.36 tls u_int32_t *sesid;
241 1.1 jonathan int error = 0;
242 1.36 tls size_t count;
243 1.1 jonathan
244 1.29 tls /* backwards compatibility */
245 1.35 ad file_t *criofp;
246 1.29 tls struct fcrypt *criofcr;
247 1.29 tls int criofd;
248 1.29 tls
249 1.92 knakahar mutex_enter(&cryptodev_mtx);
250 1.48 christos getnanotime(&fcr->atime);
251 1.92 knakahar mutex_exit(&cryptodev_mtx);
252 1.48 christos
253 1.36 tls switch (cmd) {
254 1.29 tls case CRIOGET: /* XXX deprecated, remove after 5.0 */
255 1.36 tls if ((error = fd_allocfile(&criofp, &criofd)) != 0)
256 1.36 tls return error;
257 1.36 tls criofcr = pool_get(&fcrpl, PR_WAITOK);
258 1.92 knakahar mutex_enter(&cryptodev_mtx);
259 1.36 tls TAILQ_INIT(&criofcr->csessions);
260 1.36 tls TAILQ_INIT(&criofcr->crp_ret_mq);
261 1.36 tls TAILQ_INIT(&criofcr->crp_ret_mkq);
262 1.36 tls selinit(&criofcr->sinfo);
263 1.36 tls
264 1.29 tls /*
265 1.29 tls * Don't ever return session 0, to allow detection of
266 1.29 tls * failed creation attempts with multi-create ioctl.
267 1.29 tls */
268 1.36 tls criofcr->sesn = 1;
269 1.36 tls criofcr->requestid = 1;
270 1.74 pgoyette crypto_refcount++;
271 1.92 knakahar mutex_exit(&cryptodev_mtx);
272 1.36 tls (void)fd_clone(criofp, criofd, (FREAD|FWRITE),
273 1.29 tls &cryptofops, criofcr);
274 1.36 tls *(u_int32_t *)data = criofd;
275 1.29 tls return error;
276 1.36 tls break;
277 1.1 jonathan case CIOCGSESSION:
278 1.1 jonathan sop = (struct session_op *)data;
279 1.36 tls error = cryptodev_session(fcr, sop);
280 1.36 tls break;
281 1.36 tls case CIOCNGSESSION:
282 1.36 tls sgop = (struct crypt_sgop *)data;
283 1.93 knakahar if (sgop->count <= 0
284 1.93 knakahar || SIZE_MAX / sizeof(struct session_n_op) <= sgop->count) {
285 1.93 knakahar error = EINVAL;
286 1.93 knakahar break;
287 1.93 knakahar }
288 1.36 tls snop = kmem_alloc((sgop->count *
289 1.36 tls sizeof(struct session_n_op)), KM_SLEEP);
290 1.36 tls error = copyin(sgop->sessions, snop, sgop->count *
291 1.36 tls sizeof(struct session_n_op));
292 1.36 tls if (error) {
293 1.36 tls goto mbail;
294 1.1 jonathan }
295 1.1 jonathan
296 1.92 knakahar mutex_enter(&cryptodev_mtx);
297 1.48 christos fcr->mtime = fcr->atime;
298 1.92 knakahar mutex_exit(&cryptodev_mtx);
299 1.36 tls error = cryptodev_msession(fcr, snop, sgop->count);
300 1.36 tls if (error) {
301 1.36 tls goto mbail;
302 1.1 jonathan }
303 1.1 jonathan
304 1.36 tls error = copyout(snop, sgop->sessions, sgop->count *
305 1.42 christos sizeof(struct session_n_op));
306 1.36 tls mbail:
307 1.39 tls kmem_free(snop, sgop->count * sizeof(struct session_n_op));
308 1.1 jonathan break;
309 1.1 jonathan case CIOCFSESSION:
310 1.92 knakahar mutex_enter(&cryptodev_mtx);
311 1.48 christos fcr->mtime = fcr->atime;
312 1.1 jonathan ses = *(u_int32_t *)data;
313 1.1 jonathan cse = csefind(fcr, ses);
314 1.56 drochner if (cse == NULL) {
315 1.92 knakahar mutex_exit(&cryptodev_mtx);
316 1.42 christos return EINVAL;
317 1.56 drochner }
318 1.1 jonathan csedelete(fcr, cse);
319 1.92 knakahar mutex_exit(&cryptodev_mtx);
320 1.1 jonathan error = csefree(cse);
321 1.1 jonathan break;
322 1.36 tls case CIOCNFSESSION:
323 1.92 knakahar mutex_enter(&cryptodev_mtx);
324 1.48 christos fcr->mtime = fcr->atime;
325 1.92 knakahar mutex_exit(&cryptodev_mtx);
326 1.36 tls sfop = (struct crypt_sfop *)data;
327 1.93 knakahar if (sfop->count <= 0
328 1.93 knakahar || SIZE_MAX / sizeof(u_int32_t) <= sfop->count) {
329 1.93 knakahar error = EINVAL;
330 1.93 knakahar break;
331 1.93 knakahar }
332 1.36 tls sesid = kmem_alloc((sfop->count * sizeof(u_int32_t)),
333 1.42 christos KM_SLEEP);
334 1.42 christos error = copyin(sfop->sesid, sesid,
335 1.42 christos (sfop->count * sizeof(u_int32_t)));
336 1.36 tls if (!error) {
337 1.36 tls error = cryptodev_msessionfin(fcr, sfop->count, sesid);
338 1.36 tls }
339 1.36 tls kmem_free(sesid, (sfop->count * sizeof(u_int32_t)));
340 1.36 tls break;
341 1.1 jonathan case CIOCCRYPT:
342 1.92 knakahar mutex_enter(&cryptodev_mtx);
343 1.48 christos fcr->mtime = fcr->atime;
344 1.1 jonathan cop = (struct crypt_op *)data;
345 1.1 jonathan cse = csefind(fcr, cop->ses);
346 1.92 knakahar mutex_exit(&cryptodev_mtx);
347 1.18 christos if (cse == NULL) {
348 1.90 knakahar DPRINTF("csefind failed\n");
349 1.42 christos return EINVAL;
350 1.18 christos }
351 1.35 ad error = cryptodev_op(cse, cop, curlwp);
352 1.90 knakahar DPRINTF("cryptodev_op error = %d\n", error);
353 1.1 jonathan break;
354 1.36 tls case CIOCNCRYPTM:
355 1.92 knakahar mutex_enter(&cryptodev_mtx);
356 1.48 christos fcr->mtime = fcr->atime;
357 1.92 knakahar mutex_exit(&cryptodev_mtx);
358 1.36 tls mop = (struct crypt_mop *)data;
359 1.93 knakahar if (mop->count <= 0
360 1.93 knakahar || SIZE_MAX / sizeof(struct crypt_n_op) <= mop->count) {
361 1.93 knakahar error = EINVAL;
362 1.93 knakahar break;
363 1.93 knakahar }
364 1.36 tls cnop = kmem_alloc((mop->count * sizeof(struct crypt_n_op)),
365 1.42 christos KM_SLEEP);
366 1.42 christos error = copyin(mop->reqs, cnop,
367 1.42 christos (mop->count * sizeof(struct crypt_n_op)));
368 1.36 tls if(!error) {
369 1.42 christos error = cryptodev_mop(fcr, cnop, mop->count, curlwp);
370 1.36 tls if (!error) {
371 1.36 tls error = copyout(cnop, mop->reqs,
372 1.42 christos (mop->count * sizeof(struct crypt_n_op)));
373 1.36 tls }
374 1.36 tls }
375 1.36 tls kmem_free(cnop, (mop->count * sizeof(struct crypt_n_op)));
376 1.85 msaitoh break;
377 1.1 jonathan case CIOCKEY:
378 1.1 jonathan error = cryptodev_key((struct crypt_kop *)data);
379 1.90 knakahar DPRINTF("cryptodev_key error = %d\n", error);
380 1.1 jonathan break;
381 1.36 tls case CIOCNFKEYM:
382 1.92 knakahar mutex_enter(&cryptodev_mtx);
383 1.48 christos fcr->mtime = fcr->atime;
384 1.92 knakahar mutex_exit(&cryptodev_mtx);
385 1.36 tls mkop = (struct crypt_mkop *)data;
386 1.93 knakahar if (mkop->count <= 0
387 1.93 knakahar || SIZE_MAX / sizeof(struct crypt_n_kop) <= mkop->count) {
388 1.93 knakahar error = EINVAL;
389 1.93 knakahar break;
390 1.93 knakahar }
391 1.36 tls knop = kmem_alloc((mkop->count * sizeof(struct crypt_n_kop)),
392 1.42 christos KM_SLEEP);
393 1.36 tls error = copyin(mkop->reqs, knop,
394 1.42 christos (mkop->count * sizeof(struct crypt_n_kop)));
395 1.36 tls if (!error) {
396 1.36 tls error = cryptodev_mkey(fcr, knop, mkop->count);
397 1.36 tls if (!error)
398 1.36 tls error = copyout(knop, mkop->reqs,
399 1.42 christos (mkop->count * sizeof(struct crypt_n_kop)));
400 1.36 tls }
401 1.36 tls kmem_free(knop, (mkop->count * sizeof(struct crypt_n_kop)));
402 1.36 tls break;
403 1.1 jonathan case CIOCASYMFEAT:
404 1.1 jonathan error = crypto_getfeat((int *)data);
405 1.1 jonathan break;
406 1.36 tls case CIOCNCRYPTRETM:
407 1.92 knakahar mutex_enter(&cryptodev_mtx);
408 1.48 christos fcr->mtime = fcr->atime;
409 1.92 knakahar mutex_exit(&cryptodev_mtx);
410 1.36 tls crypt_ret = (struct cryptret *)data;
411 1.36 tls count = crypt_ret->count;
412 1.93 knakahar if (count <= 0
413 1.93 knakahar || SIZE_MAX / sizeof(struct crypt_result) <= count) {
414 1.93 knakahar error = EINVAL;
415 1.93 knakahar break;
416 1.93 knakahar }
417 1.42 christos crypt_res = kmem_alloc((count * sizeof(struct crypt_result)),
418 1.42 christos KM_SLEEP);
419 1.36 tls error = copyin(crypt_ret->results, crypt_res,
420 1.42 christos (count * sizeof(struct crypt_result)));
421 1.36 tls if (error)
422 1.36 tls goto reterr;
423 1.36 tls crypt_ret->count = cryptodev_getmstatus(fcr, crypt_res,
424 1.42 christos crypt_ret->count);
425 1.36 tls /* sanity check count */
426 1.36 tls if (crypt_ret->count > count) {
427 1.37 dogcow printf("%s.%d: error returned count %zd > original "
428 1.42 christos " count %zd\n",
429 1.42 christos __FILE__, __LINE__, crypt_ret->count, count);
430 1.36 tls crypt_ret->count = count;
431 1.36 tls
432 1.36 tls }
433 1.36 tls error = copyout(crypt_res, crypt_ret->results,
434 1.42 christos (crypt_ret->count * sizeof(struct crypt_result)));
435 1.36 tls reterr:
436 1.42 christos kmem_free(crypt_res, (count * sizeof(struct crypt_result)));
437 1.36 tls break;
438 1.36 tls case CIOCNCRYPTRET:
439 1.85 msaitoh error = cryptodev_getstatus(fcr, (struct crypt_result *)data);
440 1.36 tls break;
441 1.1 jonathan default:
442 1.46 darran /* Check for backward compatible commands */
443 1.99 pgoyette
444 1.100 pgoyette MODULE_HOOK_CALL(ocryptof_50_hook, (fp, cmd, data),
445 1.99 pgoyette enosys(), error);
446 1.99 pgoyette if (error == ENOSYS)
447 1.99 pgoyette error = EINVAL;
448 1.99 pgoyette return error;
449 1.1 jonathan }
450 1.42 christos return error;
451 1.1 jonathan }
452 1.1 jonathan
453 1.46 darran int
454 1.25 christos cryptodev_op(struct csession *cse, struct crypt_op *cop, struct lwp *l)
455 1.1 jonathan {
456 1.1 jonathan struct cryptop *crp = NULL;
457 1.46 darran struct cryptodesc *crde = NULL, *crda = NULL, *crdc = NULL;
458 1.33 tls int error;
459 1.46 darran int iov_len = cop->len;
460 1.46 darran int flags=0;
461 1.46 darran int dst_len; /* copyout size */
462 1.1 jonathan
463 1.1 jonathan if (cop->len > 256*1024-4)
464 1.42 christos return E2BIG;
465 1.1 jonathan
466 1.13 jonathan if (cse->txform) {
467 1.58 drochner if (cop->len < cse->txform->blocksize
468 1.58 drochner + (cop->iv ? 0 : cse->txform->ivsize) ||
469 1.58 drochner (cop->len - (cop->iv ? 0 : cse->txform->ivsize))
470 1.58 drochner % cse->txform->blocksize != 0)
471 1.42 christos return EINVAL;
472 1.13 jonathan }
473 1.1 jonathan
474 1.90 knakahar DPRINTF("cryptodev_op[%u]: iov_len %d\n",
475 1.90 knakahar CRYPTO_SESID2LID(cse->sid), iov_len);
476 1.46 darran if ((cse->tcomp) && cop->dst_len) {
477 1.46 darran if (iov_len < cop->dst_len) {
478 1.46 darran /* Need larger iov to deal with decompress */
479 1.46 darran iov_len = cop->dst_len;
480 1.46 darran }
481 1.90 knakahar DPRINTF("cryptodev_op: iov_len -> %d for decompress\n", iov_len);
482 1.46 darran }
483 1.46 darran
484 1.42 christos (void)memset(&cse->uio, 0, sizeof(cse->uio));
485 1.1 jonathan cse->uio.uio_iovcnt = 1;
486 1.1 jonathan cse->uio.uio_resid = 0;
487 1.1 jonathan cse->uio.uio_rw = UIO_WRITE;
488 1.1 jonathan cse->uio.uio_iov = cse->iovec;
489 1.17 yamt UIO_SETUP_SYSSPACE(&cse->uio);
490 1.29 tls memset(&cse->iovec, 0, sizeof(cse->iovec));
491 1.46 darran
492 1.46 darran /* the iov needs to be big enough to handle the uncompressed
493 1.46 darran * data.... */
494 1.46 darran cse->uio.uio_iov[0].iov_len = iov_len;
495 1.64 drochner if (iov_len > 0)
496 1.64 drochner cse->uio.uio_iov[0].iov_base = kmem_alloc(iov_len, KM_SLEEP);
497 1.29 tls cse->uio.uio_resid = cse->uio.uio_iov[0].iov_len;
498 1.90 knakahar DPRINTF("lid[%u]: uio.iov_base %p malloced %d bytes\n",
499 1.53 jakllsch CRYPTO_SESID2LID(cse->sid),
500 1.90 knakahar cse->uio.uio_iov[0].iov_base, iov_len);
501 1.1 jonathan
502 1.46 darran crp = crypto_getreq((cse->tcomp != NULL) + (cse->txform != NULL) + (cse->thash != NULL));
503 1.1 jonathan if (crp == NULL) {
504 1.1 jonathan error = ENOMEM;
505 1.1 jonathan goto bail;
506 1.1 jonathan }
507 1.90 knakahar DPRINTF("lid[%u]: crp %p\n", CRYPTO_SESID2LID(cse->sid), crp);
508 1.46 darran
509 1.46 darran /* crds are always ordered tcomp, thash, then txform */
510 1.46 darran /* with optional missing links */
511 1.46 darran
512 1.46 darran /* XXX: If we're going to compress then hash or encrypt, we need
513 1.46 darran * to be able to pass on the new size of the data.
514 1.46 darran */
515 1.46 darran
516 1.46 darran if (cse->tcomp) {
517 1.46 darran crdc = crp->crp_desc;
518 1.46 darran }
519 1.1 jonathan
520 1.1 jonathan if (cse->thash) {
521 1.46 darran crda = crdc ? crdc->crd_next : crp->crp_desc;
522 1.44 christos if (cse->txform && crda)
523 1.1 jonathan crde = crda->crd_next;
524 1.1 jonathan } else {
525 1.46 darran if (cse->txform) {
526 1.46 darran crde = crdc ? crdc->crd_next : crp->crp_desc;
527 1.46 darran } else if (!cse->tcomp) {
528 1.1 jonathan error = EINVAL;
529 1.1 jonathan goto bail;
530 1.1 jonathan }
531 1.1 jonathan }
532 1.1 jonathan
533 1.90 knakahar DPRINTF("ocf[%u]: iov_len %zu, cop->len %u\n",
534 1.53 jakllsch CRYPTO_SESID2LID(cse->sid),
535 1.46 darran cse->uio.uio_iov[0].iov_len,
536 1.90 knakahar cop->len);
537 1.46 darran
538 1.1 jonathan if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, cop->len)))
539 1.36 tls {
540 1.36 tls printf("copyin failed %s %d \n", (char *)cop->src, error);
541 1.1 jonathan goto bail;
542 1.36 tls }
543 1.1 jonathan
544 1.46 darran if (crdc) {
545 1.46 darran switch (cop->op) {
546 1.46 darran case COP_COMP:
547 1.46 darran crdc->crd_flags |= CRD_F_COMP;
548 1.46 darran break;
549 1.46 darran case COP_DECOMP:
550 1.46 darran crdc->crd_flags &= ~CRD_F_COMP;
551 1.46 darran break;
552 1.46 darran default:
553 1.46 darran break;
554 1.46 darran }
555 1.46 darran /* more data to follow? */
556 1.46 darran if (cop->flags & COP_F_MORE) {
557 1.46 darran flags |= CRYPTO_F_MORE;
558 1.46 darran }
559 1.46 darran crdc->crd_len = cop->len;
560 1.46 darran crdc->crd_inject = 0;
561 1.46 darran
562 1.46 darran crdc->crd_alg = cse->comp_alg;
563 1.46 darran crdc->crd_key = NULL;
564 1.46 darran crdc->crd_klen = 0;
565 1.90 knakahar DPRINTF("lid[%u]: crdc setup for comp_alg %d.\n",
566 1.90 knakahar CRYPTO_SESID2LID(cse->sid), crdc->crd_alg);
567 1.46 darran }
568 1.46 darran
569 1.1 jonathan if (crda) {
570 1.1 jonathan crda->crd_skip = 0;
571 1.1 jonathan crda->crd_len = cop->len;
572 1.1 jonathan crda->crd_inject = 0; /* ??? */
573 1.1 jonathan
574 1.1 jonathan crda->crd_alg = cse->mac;
575 1.1 jonathan crda->crd_key = cse->mackey;
576 1.1 jonathan crda->crd_klen = cse->mackeylen * 8;
577 1.90 knakahar DPRINTF("crda setup for mac %d.\n", crda->crd_alg);
578 1.1 jonathan }
579 1.1 jonathan
580 1.1 jonathan if (crde) {
581 1.46 darran switch (cop->op) {
582 1.46 darran case COP_ENCRYPT:
583 1.1 jonathan crde->crd_flags |= CRD_F_ENCRYPT;
584 1.46 darran break;
585 1.46 darran case COP_DECRYPT:
586 1.1 jonathan crde->crd_flags &= ~CRD_F_ENCRYPT;
587 1.46 darran break;
588 1.46 darran default:
589 1.46 darran break;
590 1.46 darran }
591 1.1 jonathan crde->crd_len = cop->len;
592 1.1 jonathan crde->crd_inject = 0;
593 1.1 jonathan
594 1.66 drochner if (cse->cipher == CRYPTO_AES_GCM_16 && crda)
595 1.66 drochner crda->crd_len = 0;
596 1.66 drochner else if (cse->cipher == CRYPTO_AES_GMAC)
597 1.66 drochner crde->crd_len = 0;
598 1.66 drochner
599 1.1 jonathan crde->crd_alg = cse->cipher;
600 1.1 jonathan crde->crd_key = cse->key;
601 1.1 jonathan crde->crd_klen = cse->keylen * 8;
602 1.90 knakahar DPRINTF("crde setup for cipher %d.\n", crde->crd_alg);
603 1.1 jonathan }
604 1.1 jonathan
605 1.46 darran
606 1.1 jonathan crp->crp_ilen = cop->len;
607 1.86 knakahar /*
608 1.86 knakahar * The request is flagged as CRYPTO_F_USER as long as it is running
609 1.86 knakahar * in the user IOCTL thread. However, whether the request completes
610 1.86 knakahar * immediately or belatedly is depends on the used encryption driver.
611 1.45 darran */
612 1.46 darran crp->crp_flags = CRYPTO_F_IOV | (cop->flags & COP_F_BATCH) | CRYPTO_F_USER |
613 1.46 darran flags;
614 1.26 christos crp->crp_buf = (void *)&cse->uio;
615 1.1 jonathan crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_cb;
616 1.1 jonathan crp->crp_sid = cse->sid;
617 1.1 jonathan crp->crp_opaque = (void *)cse;
618 1.1 jonathan
619 1.1 jonathan if (cop->iv) {
620 1.1 jonathan if (crde == NULL) {
621 1.1 jonathan error = EINVAL;
622 1.1 jonathan goto bail;
623 1.1 jonathan }
624 1.62 drochner if (cse->txform->ivsize == 0) {
625 1.1 jonathan error = EINVAL;
626 1.1 jonathan goto bail;
627 1.1 jonathan }
628 1.36 tls if ((error = copyin(cop->iv, cse->tmp_iv,
629 1.58 drochner cse->txform->ivsize)))
630 1.1 jonathan goto bail;
631 1.58 drochner (void)memcpy(crde->crd_iv, cse->tmp_iv, cse->txform->ivsize);
632 1.1 jonathan crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
633 1.1 jonathan crde->crd_skip = 0;
634 1.1 jonathan } else if (crde) {
635 1.62 drochner if (cse->txform->ivsize == 0) {
636 1.20 christos crde->crd_skip = 0;
637 1.20 christos } else {
638 1.61 drochner if (!(crde->crd_flags & CRD_F_ENCRYPT))
639 1.61 drochner crde->crd_flags |= CRD_F_IV_PRESENT;
640 1.58 drochner crde->crd_skip = cse->txform->ivsize;
641 1.58 drochner crde->crd_len -= cse->txform->ivsize;
642 1.20 christos }
643 1.1 jonathan }
644 1.1 jonathan
645 1.1 jonathan if (cop->mac) {
646 1.1 jonathan if (crda == NULL) {
647 1.1 jonathan error = EINVAL;
648 1.1 jonathan goto bail;
649 1.1 jonathan }
650 1.1 jonathan crp->crp_mac=cse->tmp_mac;
651 1.1 jonathan }
652 1.1 jonathan
653 1.67 drochner cv_init(&crp->crp_cv, "crydev");
654 1.67 drochner
655 1.33 tls /*
656 1.33 tls * XXX there was a comment here which said that we went to
657 1.33 tls * XXX splcrypto() but needed to only if CRYPTO_F_CBIMM,
658 1.33 tls * XXX disabled on NetBSD since 1.6O due to a race condition.
659 1.33 tls * XXX But crypto_dispatch went to splcrypto() itself! (And
660 1.92 knakahar * XXX now takes the cryptodev_mtx mutex itself). We do, however,
661 1.33 tls * XXX need to hold the mutex across the call to cv_wait().
662 1.33 tls * XXX (should we arrange for crypto_dispatch to return to
663 1.33 tls * XXX us with it held? it seems quite ugly to do so.)
664 1.33 tls */
665 1.36 tls #ifdef notyet
666 1.36 tls eagain:
667 1.36 tls #endif
668 1.1 jonathan error = crypto_dispatch(crp);
669 1.92 knakahar mutex_enter(&cryptodev_mtx);
670 1.36 tls
671 1.45 darran /*
672 1.98 dholland * Don't touch crp before returned by any error or received
673 1.86 knakahar * cv_signal(&crp->crp_cv). It is required to restructure locks.
674 1.45 darran */
675 1.45 darran
676 1.36 tls switch (error) {
677 1.36 tls #ifdef notyet /* don't loop forever -- but EAGAIN not possible here yet */
678 1.36 tls case EAGAIN:
679 1.92 knakahar mutex_exit(&cryptodev_mtx);
680 1.36 tls goto eagain;
681 1.36 tls break;
682 1.36 tls #endif
683 1.36 tls case 0:
684 1.36 tls break;
685 1.36 tls default:
686 1.90 knakahar DPRINTF("not waiting, error.\n");
687 1.92 knakahar mutex_exit(&cryptodev_mtx);
688 1.67 drochner cv_destroy(&crp->crp_cv);
689 1.1 jonathan goto bail;
690 1.1 jonathan }
691 1.45 darran
692 1.95 knakahar while (!(crp->crp_devflags & CRYPTODEV_F_RET)) {
693 1.90 knakahar DPRINTF("cse->sid[%d]: sleeping on cv %p for crp %p\n",
694 1.90 knakahar (uint32_t)cse->sid, &crp->crp_cv, crp);
695 1.92 knakahar cv_wait(&crp->crp_cv, &cryptodev_mtx); /* XXX cv_wait_sig? */
696 1.33 tls }
697 1.92 knakahar mutex_exit(&cryptodev_mtx);
698 1.67 drochner cv_destroy(&crp->crp_cv);
699 1.1 jonathan
700 1.1 jonathan if (crp->crp_etype != 0) {
701 1.90 knakahar DPRINTF("crp_etype %d\n", crp->crp_etype);
702 1.1 jonathan error = crp->crp_etype;
703 1.1 jonathan goto bail;
704 1.1 jonathan }
705 1.1 jonathan
706 1.1 jonathan if (cse->error) {
707 1.90 knakahar DPRINTF("cse->error %d\n", cse->error);
708 1.1 jonathan error = cse->error;
709 1.1 jonathan goto bail;
710 1.1 jonathan }
711 1.1 jonathan
712 1.46 darran dst_len = crp->crp_ilen;
713 1.46 darran /* let the user know how much data was returned */
714 1.46 darran if (crp->crp_olen) {
715 1.64 drochner if (crp->crp_olen > (cop->dst_len ? cop->dst_len : cop->len)) {
716 1.82 christos error = ENOSPC;
717 1.64 drochner goto bail;
718 1.64 drochner }
719 1.46 darran dst_len = cop->dst_len = crp->crp_olen;
720 1.46 darran }
721 1.46 darran
722 1.46 darran if (cop->dst) {
723 1.90 knakahar DPRINTF("copyout %d bytes to %p\n", dst_len, cop->dst);
724 1.46 darran }
725 1.1 jonathan if (cop->dst &&
726 1.46 darran (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, dst_len)))
727 1.36 tls {
728 1.90 knakahar DPRINTF("copyout error %d\n", error);
729 1.1 jonathan goto bail;
730 1.34 tls }
731 1.1 jonathan
732 1.1 jonathan if (cop->mac &&
733 1.34 tls (error = copyout(crp->crp_mac, cop->mac, cse->thash->authsize))) {
734 1.90 knakahar DPRINTF("mac copyout error %d\n", error);
735 1.1 jonathan goto bail;
736 1.34 tls }
737 1.1 jonathan
738 1.46 darran
739 1.1 jonathan bail:
740 1.45 darran if (crp) {
741 1.1 jonathan crypto_freereq(crp);
742 1.45 darran }
743 1.46 darran if (cse->uio.uio_iov[0].iov_base) {
744 1.46 darran kmem_free(cse->uio.uio_iov[0].iov_base,iov_len);
745 1.46 darran }
746 1.1 jonathan
747 1.42 christos return error;
748 1.1 jonathan }
749 1.1 jonathan
750 1.1 jonathan static int
751 1.1 jonathan cryptodev_cb(void *op)
752 1.1 jonathan {
753 1.1 jonathan struct cryptop *crp = (struct cryptop *) op;
754 1.1 jonathan struct csession *cse = (struct csession *)crp->crp_opaque;
755 1.33 tls int error = 0;
756 1.1 jonathan
757 1.92 knakahar mutex_enter(&cryptodev_mtx);
758 1.1 jonathan cse->error = crp->crp_etype;
759 1.33 tls if (crp->crp_etype == EAGAIN) {
760 1.33 tls /* always drop mutex to call dispatch routine */
761 1.92 knakahar mutex_exit(&cryptodev_mtx);
762 1.33 tls error = crypto_dispatch(crp);
763 1.92 knakahar mutex_enter(&cryptodev_mtx);
764 1.33 tls }
765 1.33 tls if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
766 1.95 knakahar crp->crp_devflags |= CRYPTODEV_F_RET;
767 1.33 tls cv_signal(&crp->crp_cv);
768 1.33 tls }
769 1.92 knakahar mutex_exit(&cryptodev_mtx);
770 1.42 christos return 0;
771 1.1 jonathan }
772 1.1 jonathan
773 1.1 jonathan static int
774 1.36 tls cryptodev_mcb(void *op)
775 1.36 tls {
776 1.36 tls struct cryptop *crp = (struct cryptop *) op;
777 1.36 tls struct csession *cse = (struct csession *)crp->crp_opaque;
778 1.36 tls int error=0;
779 1.36 tls
780 1.92 knakahar mutex_enter(&cryptodev_mtx);
781 1.36 tls cse->error = crp->crp_etype;
782 1.36 tls if (crp->crp_etype == EAGAIN) {
783 1.92 knakahar mutex_exit(&cryptodev_mtx);
784 1.36 tls error = crypto_dispatch(crp);
785 1.92 knakahar mutex_enter(&cryptodev_mtx);
786 1.36 tls }
787 1.36 tls if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
788 1.36 tls cv_signal(&crp->crp_cv);
789 1.36 tls }
790 1.36 tls
791 1.36 tls TAILQ_INSERT_TAIL(&crp->fcrp->crp_ret_mq, crp, crp_next);
792 1.38 rmind selnotify(&crp->fcrp->sinfo, 0, 0);
793 1.92 knakahar mutex_exit(&cryptodev_mtx);
794 1.42 christos return 0;
795 1.36 tls }
796 1.36 tls
797 1.36 tls static int
798 1.1 jonathan cryptodevkey_cb(void *op)
799 1.1 jonathan {
800 1.42 christos struct cryptkop *krp = op;
801 1.36 tls
802 1.92 knakahar mutex_enter(&cryptodev_mtx);
803 1.95 knakahar krp->krp_devflags |= CRYPTODEV_F_RET;
804 1.36 tls cv_signal(&krp->krp_cv);
805 1.92 knakahar mutex_exit(&cryptodev_mtx);
806 1.42 christos return 0;
807 1.36 tls }
808 1.36 tls
809 1.36 tls static int
810 1.36 tls cryptodevkey_mcb(void *op)
811 1.36 tls {
812 1.42 christos struct cryptkop *krp = op;
813 1.1 jonathan
814 1.92 knakahar mutex_enter(&cryptodev_mtx);
815 1.33 tls cv_signal(&krp->krp_cv);
816 1.36 tls TAILQ_INSERT_TAIL(&krp->fcrp->crp_ret_mkq, krp, krp_next);
817 1.38 rmind selnotify(&krp->fcrp->sinfo, 0, 0);
818 1.92 knakahar mutex_exit(&cryptodev_mtx);
819 1.42 christos return 0;
820 1.1 jonathan }
821 1.1 jonathan
822 1.1 jonathan static int
823 1.1 jonathan cryptodev_key(struct crypt_kop *kop)
824 1.1 jonathan {
825 1.1 jonathan struct cryptkop *krp = NULL;
826 1.1 jonathan int error = EINVAL;
827 1.1 jonathan int in, out, size, i;
828 1.1 jonathan
829 1.42 christos if (kop->crk_iparams + kop->crk_oparams > CRK_MAXPARAM)
830 1.42 christos return EFBIG;
831 1.1 jonathan
832 1.1 jonathan in = kop->crk_iparams;
833 1.1 jonathan out = kop->crk_oparams;
834 1.1 jonathan switch (kop->crk_op) {
835 1.1 jonathan case CRK_MOD_EXP:
836 1.1 jonathan if (in == 3 && out == 1)
837 1.1 jonathan break;
838 1.42 christos return EINVAL;
839 1.1 jonathan case CRK_MOD_EXP_CRT:
840 1.1 jonathan if (in == 6 && out == 1)
841 1.1 jonathan break;
842 1.42 christos return EINVAL;
843 1.1 jonathan case CRK_DSA_SIGN:
844 1.1 jonathan if (in == 5 && out == 2)
845 1.1 jonathan break;
846 1.42 christos return EINVAL;
847 1.1 jonathan case CRK_DSA_VERIFY:
848 1.1 jonathan if (in == 7 && out == 0)
849 1.1 jonathan break;
850 1.42 christos return EINVAL;
851 1.1 jonathan case CRK_DH_COMPUTE_KEY:
852 1.1 jonathan if (in == 3 && out == 1)
853 1.1 jonathan break;
854 1.42 christos return EINVAL;
855 1.27 tls case CRK_MOD_ADD:
856 1.27 tls if (in == 3 && out == 1)
857 1.27 tls break;
858 1.42 christos return EINVAL;
859 1.27 tls case CRK_MOD_ADDINV:
860 1.27 tls if (in == 2 && out == 1)
861 1.27 tls break;
862 1.42 christos return EINVAL;
863 1.27 tls case CRK_MOD_SUB:
864 1.27 tls if (in == 3 && out == 1)
865 1.27 tls break;
866 1.42 christos return EINVAL;
867 1.27 tls case CRK_MOD_MULT:
868 1.27 tls if (in == 3 && out == 1)
869 1.27 tls break;
870 1.42 christos return EINVAL;
871 1.27 tls case CRK_MOD_MULTINV:
872 1.27 tls if (in == 2 && out == 1)
873 1.27 tls break;
874 1.42 christos return EINVAL;
875 1.27 tls case CRK_MOD:
876 1.27 tls if (in == 2 && out == 1)
877 1.27 tls break;
878 1.42 christos return EINVAL;
879 1.1 jonathan default:
880 1.42 christos return EINVAL;
881 1.1 jonathan }
882 1.1 jonathan
883 1.91 knakahar krp = crypto_kgetreq(1, PR_WAITOK);
884 1.91 knakahar if (krp == NULL) {
885 1.91 knakahar /* limited by opencrypto.crypto_ret_kq.maxlen */
886 1.91 knakahar return ENOMEM;
887 1.91 knakahar }
888 1.42 christos (void)memset(krp, 0, sizeof *krp);
889 1.33 tls cv_init(&krp->krp_cv, "crykdev");
890 1.1 jonathan krp->krp_op = kop->crk_op;
891 1.1 jonathan krp->krp_status = kop->crk_status;
892 1.1 jonathan krp->krp_iparams = kop->crk_iparams;
893 1.1 jonathan krp->krp_oparams = kop->crk_oparams;
894 1.1 jonathan krp->krp_status = 0;
895 1.1 jonathan krp->krp_callback = (int (*) (struct cryptkop *)) cryptodevkey_cb;
896 1.1 jonathan
897 1.1 jonathan for (i = 0; i < CRK_MAXPARAM; i++)
898 1.1 jonathan krp->krp_param[i].crp_nbits = kop->crk_param[i].crp_nbits;
899 1.1 jonathan for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
900 1.1 jonathan size = (krp->krp_param[i].crp_nbits + 7) / 8;
901 1.1 jonathan if (size == 0)
902 1.1 jonathan continue;
903 1.36 tls krp->krp_param[i].crp_p = kmem_alloc(size, KM_SLEEP);
904 1.1 jonathan if (i >= krp->krp_iparams)
905 1.1 jonathan continue;
906 1.42 christos error = copyin(kop->crk_param[i].crp_p,
907 1.42 christos krp->krp_param[i].crp_p, size);
908 1.1 jonathan if (error)
909 1.1 jonathan goto fail;
910 1.1 jonathan }
911 1.1 jonathan
912 1.1 jonathan error = crypto_kdispatch(krp);
913 1.33 tls if (error != 0) {
914 1.1 jonathan goto fail;
915 1.33 tls }
916 1.33 tls
917 1.92 knakahar mutex_enter(&cryptodev_mtx);
918 1.95 knakahar while (!(krp->krp_devflags & CRYPTODEV_F_RET)) {
919 1.92 knakahar cv_wait(&krp->krp_cv, &cryptodev_mtx); /* XXX cv_wait_sig? */
920 1.33 tls }
921 1.92 knakahar mutex_exit(&cryptodev_mtx);
922 1.1 jonathan
923 1.1 jonathan if (krp->krp_status != 0) {
924 1.90 knakahar DPRINTF("krp->krp_status 0x%08x\n", krp->krp_status);
925 1.1 jonathan error = krp->krp_status;
926 1.1 jonathan goto fail;
927 1.1 jonathan }
928 1.1 jonathan
929 1.42 christos for (i = krp->krp_iparams; i < krp->krp_iparams + krp->krp_oparams;
930 1.42 christos i++) {
931 1.1 jonathan size = (krp->krp_param[i].crp_nbits + 7) / 8;
932 1.1 jonathan if (size == 0)
933 1.1 jonathan continue;
934 1.42 christos error = copyout(krp->krp_param[i].crp_p,
935 1.42 christos kop->crk_param[i].crp_p, size);
936 1.34 tls if (error) {
937 1.90 knakahar DPRINTF("copyout oparam %d failed, "
938 1.90 knakahar "error=%d\n", i-krp->krp_iparams, error);
939 1.1 jonathan goto fail;
940 1.34 tls }
941 1.1 jonathan }
942 1.1 jonathan
943 1.1 jonathan fail:
944 1.43 christos kop->crk_status = krp->krp_status;
945 1.43 christos for (i = 0; i < CRK_MAXPARAM; i++) {
946 1.43 christos struct crparam *kp = &(krp->krp_param[i]);
947 1.43 christos if (krp->krp_param[i].crp_p) {
948 1.43 christos size = (kp->crp_nbits + 7) / 8;
949 1.43 christos KASSERT(size > 0);
950 1.43 christos (void)memset(kp->crp_p, 0, size);
951 1.43 christos kmem_free(kp->crp_p, size);
952 1.1 jonathan }
953 1.1 jonathan }
954 1.45 darran cv_destroy(&krp->krp_cv);
955 1.91 knakahar crypto_kfreereq(krp);
956 1.90 knakahar DPRINTF("error=0x%08x\n", error);
957 1.42 christos return error;
958 1.1 jonathan }
959 1.1 jonathan
960 1.1 jonathan /* ARGSUSED */
961 1.1 jonathan static int
962 1.36 tls cryptof_close(struct file *fp)
963 1.1 jonathan {
964 1.81 matt struct fcrypt *fcr = fp->f_fcrypt;
965 1.1 jonathan struct csession *cse;
966 1.1 jonathan
967 1.92 knakahar mutex_enter(&cryptodev_mtx);
968 1.1 jonathan while ((cse = TAILQ_FIRST(&fcr->csessions))) {
969 1.1 jonathan TAILQ_REMOVE(&fcr->csessions, cse, next);
970 1.92 knakahar mutex_exit(&cryptodev_mtx);
971 1.1 jonathan (void)csefree(cse);
972 1.92 knakahar mutex_enter(&cryptodev_mtx);
973 1.1 jonathan }
974 1.36 tls seldestroy(&fcr->sinfo);
975 1.81 matt fp->f_fcrypt = NULL;
976 1.74 pgoyette crypto_refcount--;
977 1.92 knakahar mutex_exit(&cryptodev_mtx);
978 1.1 jonathan
979 1.38 rmind pool_put(&fcrpl, fcr);
980 1.1 jonathan return 0;
981 1.1 jonathan }
982 1.1 jonathan
983 1.46 darran /* needed for compatibility module */
984 1.46 darran struct csession *cryptodev_csefind(struct fcrypt *fcr, u_int ses)
985 1.46 darran {
986 1.46 darran return csefind(fcr, ses);
987 1.46 darran }
988 1.46 darran
989 1.92 knakahar /* csefind: call with cryptodev_mtx held. */
990 1.1 jonathan static struct csession *
991 1.1 jonathan csefind(struct fcrypt *fcr, u_int ses)
992 1.1 jonathan {
993 1.45 darran struct csession *cse, *cnext, *ret = NULL;
994 1.1 jonathan
995 1.92 knakahar KASSERT(mutex_owned(&cryptodev_mtx));
996 1.45 darran TAILQ_FOREACH_SAFE(cse, &fcr->csessions, next, cnext)
997 1.1 jonathan if (cse->ses == ses)
998 1.33 tls ret = cse;
999 1.36 tls
1000 1.42 christos return ret;
1001 1.1 jonathan }
1002 1.1 jonathan
1003 1.92 knakahar /* csedelete: call with cryptodev_mtx held. */
1004 1.1 jonathan static int
1005 1.1 jonathan csedelete(struct fcrypt *fcr, struct csession *cse_del)
1006 1.1 jonathan {
1007 1.45 darran struct csession *cse, *cnext;
1008 1.33 tls int ret = 0;
1009 1.1 jonathan
1010 1.92 knakahar KASSERT(mutex_owned(&cryptodev_mtx));
1011 1.45 darran TAILQ_FOREACH_SAFE(cse, &fcr->csessions, next, cnext) {
1012 1.1 jonathan if (cse == cse_del) {
1013 1.1 jonathan TAILQ_REMOVE(&fcr->csessions, cse, next);
1014 1.33 tls ret = 1;
1015 1.1 jonathan }
1016 1.1 jonathan }
1017 1.42 christos return ret;
1018 1.1 jonathan }
1019 1.1 jonathan
1020 1.1 jonathan static struct csession *
1021 1.1 jonathan cseadd(struct fcrypt *fcr, struct csession *cse)
1022 1.1 jonathan {
1023 1.92 knakahar mutex_enter(&cryptodev_mtx);
1024 1.33 tls /* don't let session ID wrap! */
1025 1.33 tls if (fcr->sesn + 1 == 0) return NULL;
1026 1.1 jonathan TAILQ_INSERT_TAIL(&fcr->csessions, cse, next);
1027 1.1 jonathan cse->ses = fcr->sesn++;
1028 1.92 knakahar mutex_exit(&cryptodev_mtx);
1029 1.42 christos return cse;
1030 1.1 jonathan }
1031 1.1 jonathan
1032 1.1 jonathan static struct csession *
1033 1.26 christos csecreate(struct fcrypt *fcr, u_int64_t sid, void *key, u_int64_t keylen,
1034 1.26 christos void *mackey, u_int64_t mackeylen, u_int32_t cipher, u_int32_t mac,
1035 1.54 drochner u_int32_t comp_alg, const struct enc_xform *txform,
1036 1.54 drochner const struct auth_hash *thash, const struct comp_algo *tcomp)
1037 1.1 jonathan {
1038 1.1 jonathan struct csession *cse;
1039 1.1 jonathan
1040 1.29 tls cse = pool_get(&csepl, PR_NOWAIT);
1041 1.1 jonathan if (cse == NULL)
1042 1.1 jonathan return NULL;
1043 1.1 jonathan cse->key = key;
1044 1.1 jonathan cse->keylen = keylen/8;
1045 1.1 jonathan cse->mackey = mackey;
1046 1.1 jonathan cse->mackeylen = mackeylen/8;
1047 1.1 jonathan cse->sid = sid;
1048 1.1 jonathan cse->cipher = cipher;
1049 1.1 jonathan cse->mac = mac;
1050 1.46 darran cse->comp_alg = comp_alg;
1051 1.1 jonathan cse->txform = txform;
1052 1.1 jonathan cse->thash = thash;
1053 1.46 darran cse->tcomp = tcomp;
1054 1.34 tls cse->error = 0;
1055 1.28 tls if (cseadd(fcr, cse))
1056 1.42 christos return cse;
1057 1.28 tls else {
1058 1.33 tls pool_put(&csepl, cse);
1059 1.28 tls return NULL;
1060 1.28 tls }
1061 1.1 jonathan }
1062 1.1 jonathan
1063 1.92 knakahar /* csefree: call with cryptodev_mtx held. */
1064 1.1 jonathan static int
1065 1.1 jonathan csefree(struct csession *cse)
1066 1.1 jonathan {
1067 1.1 jonathan int error;
1068 1.1 jonathan
1069 1.1 jonathan error = crypto_freesession(cse->sid);
1070 1.1 jonathan if (cse->key)
1071 1.36 tls free(cse->key, M_XDATA);
1072 1.1 jonathan if (cse->mackey)
1073 1.36 tls free(cse->mackey, M_XDATA);
1074 1.29 tls pool_put(&csepl, cse);
1075 1.42 christos return error;
1076 1.1 jonathan }
1077 1.1 jonathan
1078 1.1 jonathan static int
1079 1.25 christos cryptoopen(dev_t dev, int flag, int mode,
1080 1.25 christos struct lwp *l)
1081 1.1 jonathan {
1082 1.35 ad file_t *fp;
1083 1.29 tls struct fcrypt *fcr;
1084 1.29 tls int fd, error;
1085 1.29 tls
1086 1.1 jonathan if (crypto_usercrypto == 0)
1087 1.42 christos return ENXIO;
1088 1.29 tls
1089 1.35 ad if ((error = fd_allocfile(&fp, &fd)) != 0)
1090 1.29 tls return error;
1091 1.29 tls
1092 1.29 tls fcr = pool_get(&fcrpl, PR_WAITOK);
1093 1.48 christos getnanotime(&fcr->btime);
1094 1.48 christos fcr->atime = fcr->mtime = fcr->btime;
1095 1.92 knakahar mutex_enter(&cryptodev_mtx);
1096 1.29 tls TAILQ_INIT(&fcr->csessions);
1097 1.36 tls TAILQ_INIT(&fcr->crp_ret_mq);
1098 1.36 tls TAILQ_INIT(&fcr->crp_ret_mkq);
1099 1.36 tls selinit(&fcr->sinfo);
1100 1.29 tls /*
1101 1.29 tls * Don't ever return session 0, to allow detection of
1102 1.29 tls * failed creation attempts with multi-create ioctl.
1103 1.29 tls */
1104 1.29 tls fcr->sesn = 1;
1105 1.36 tls fcr->requestid = 1;
1106 1.74 pgoyette crypto_refcount++;
1107 1.92 knakahar mutex_exit(&cryptodev_mtx);
1108 1.35 ad return fd_clone(fp, fd, flag, &cryptofops, fcr);
1109 1.1 jonathan }
1110 1.1 jonathan
1111 1.1 jonathan static int
1112 1.25 christos cryptoread(dev_t dev, struct uio *uio, int ioflag)
1113 1.1 jonathan {
1114 1.42 christos return EIO;
1115 1.1 jonathan }
1116 1.1 jonathan
1117 1.1 jonathan static int
1118 1.25 christos cryptowrite(dev_t dev, struct uio *uio, int ioflag)
1119 1.1 jonathan {
1120 1.42 christos return EIO;
1121 1.1 jonathan }
1122 1.1 jonathan
1123 1.1 jonathan int
1124 1.25 christos cryptoselect(dev_t dev, int rw, struct lwp *l)
1125 1.1 jonathan {
1126 1.42 christos return 0;
1127 1.1 jonathan }
1128 1.1 jonathan
1129 1.1 jonathan /*static*/
1130 1.1 jonathan struct cdevsw crypto_cdevsw = {
1131 1.78 dholland .d_open = cryptoopen,
1132 1.78 dholland .d_close = noclose,
1133 1.78 dholland .d_read = cryptoread,
1134 1.78 dholland .d_write = cryptowrite,
1135 1.78 dholland .d_ioctl = noioctl,
1136 1.78 dholland .d_stop = nostop,
1137 1.78 dholland .d_tty = notty,
1138 1.78 dholland .d_poll = cryptoselect /*nopoll*/,
1139 1.78 dholland .d_mmap = nommap,
1140 1.78 dholland .d_kqfilter = nokqfilter,
1141 1.79 dholland .d_discard = nodiscard,
1142 1.78 dholland .d_flag = D_OTHER
1143 1.1 jonathan };
1144 1.1 jonathan
1145 1.46 darran int
1146 1.36 tls cryptodev_mop(struct fcrypt *fcr,
1147 1.36 tls struct crypt_n_op * cnop,
1148 1.36 tls int count, struct lwp *l)
1149 1.36 tls {
1150 1.36 tls struct cryptop *crp = NULL;
1151 1.46 darran struct cryptodesc *crde = NULL, *crda = NULL, *crdc = NULL;
1152 1.36 tls int req, error=0;
1153 1.36 tls struct csession *cse;
1154 1.46 darran int flags=0;
1155 1.46 darran int iov_len;
1156 1.36 tls
1157 1.36 tls for (req = 0; req < count; req++) {
1158 1.92 knakahar mutex_enter(&cryptodev_mtx);
1159 1.36 tls cse = csefind(fcr, cnop[req].ses);
1160 1.36 tls if (cse == NULL) {
1161 1.90 knakahar DPRINTF("csefind failed\n");
1162 1.36 tls cnop[req].status = EINVAL;
1163 1.92 knakahar mutex_exit(&cryptodev_mtx);
1164 1.36 tls continue;
1165 1.36 tls }
1166 1.92 knakahar mutex_exit(&cryptodev_mtx);
1167 1.36 tls
1168 1.36 tls if (cnop[req].len > 256*1024-4) {
1169 1.90 knakahar DPRINTF("length failed\n");
1170 1.36 tls cnop[req].status = EINVAL;
1171 1.36 tls continue;
1172 1.36 tls }
1173 1.36 tls if (cse->txform) {
1174 1.58 drochner if (cnop[req].len < cse->txform->blocksize -
1175 1.58 drochner (cnop[req].iv ? 0 : cse->txform->ivsize) ||
1176 1.58 drochner (cnop[req].len -
1177 1.58 drochner (cnop[req].iv ? 0 : cse->txform->ivsize))
1178 1.58 drochner % cse->txform->blocksize) {
1179 1.36 tls cnop[req].status = EINVAL;
1180 1.36 tls continue;
1181 1.36 tls }
1182 1.36 tls }
1183 1.36 tls
1184 1.94 knakahar /* sanitize */
1185 1.94 knakahar if (cnop[req].len <= 0) {
1186 1.94 knakahar cnop[req].status = ENOMEM;
1187 1.94 knakahar goto bail;
1188 1.94 knakahar }
1189 1.94 knakahar
1190 1.42 christos crp = crypto_getreq((cse->txform != NULL) +
1191 1.46 darran (cse->thash != NULL) +
1192 1.46 darran (cse->tcomp != NULL));
1193 1.36 tls if (crp == NULL) {
1194 1.36 tls cnop[req].status = ENOMEM;
1195 1.36 tls goto bail;
1196 1.36 tls }
1197 1.36 tls
1198 1.46 darran iov_len = cnop[req].len;
1199 1.46 darran /* got a compression/decompression max size? */
1200 1.46 darran if ((cse->tcomp) && cnop[req].dst_len) {
1201 1.46 darran if (iov_len < cnop[req].dst_len) {
1202 1.46 darran /* Need larger iov to deal with decompress */
1203 1.46 darran iov_len = cnop[req].dst_len;
1204 1.46 darran }
1205 1.90 knakahar DPRINTF("iov_len -> %d for decompress\n", iov_len);
1206 1.46 darran }
1207 1.46 darran
1208 1.42 christos (void)memset(&crp->uio, 0, sizeof(crp->uio));
1209 1.36 tls crp->uio.uio_iovcnt = 1;
1210 1.36 tls crp->uio.uio_resid = 0;
1211 1.36 tls crp->uio.uio_rw = UIO_WRITE;
1212 1.36 tls crp->uio.uio_iov = crp->iovec;
1213 1.36 tls UIO_SETUP_SYSSPACE(&crp->uio);
1214 1.36 tls memset(&crp->iovec, 0, sizeof(crp->iovec));
1215 1.46 darran crp->uio.uio_iov[0].iov_len = iov_len;
1216 1.90 knakahar DPRINTF("kmem_alloc(%d) for iov \n", iov_len);
1217 1.46 darran crp->uio.uio_iov[0].iov_base = kmem_alloc(iov_len, KM_SLEEP);
1218 1.36 tls crp->uio.uio_resid = crp->uio.uio_iov[0].iov_len;
1219 1.36 tls
1220 1.46 darran if (cse->tcomp) {
1221 1.46 darran crdc = crp->crp_desc;
1222 1.46 darran }
1223 1.46 darran
1224 1.36 tls if (cse->thash) {
1225 1.46 darran crda = crdc ? crdc->crd_next : crp->crp_desc;
1226 1.44 christos if (cse->txform && crda)
1227 1.36 tls crde = crda->crd_next;
1228 1.36 tls } else {
1229 1.46 darran if (cse->txform) {
1230 1.46 darran crde = crdc ? crdc->crd_next : crp->crp_desc;
1231 1.46 darran } else if (!cse->tcomp) {
1232 1.46 darran error = EINVAL;
1233 1.46 darran goto bail;
1234 1.36 tls }
1235 1.36 tls }
1236 1.36 tls
1237 1.36 tls if ((copyin(cnop[req].src,
1238 1.36 tls crp->uio.uio_iov[0].iov_base, cnop[req].len))) {
1239 1.36 tls cnop[req].status = EINVAL;
1240 1.36 tls goto bail;
1241 1.36 tls }
1242 1.46 darran
1243 1.46 darran if (crdc) {
1244 1.46 darran switch (cnop[req].op) {
1245 1.46 darran case COP_COMP:
1246 1.46 darran crdc->crd_flags |= CRD_F_COMP;
1247 1.46 darran break;
1248 1.46 darran case COP_DECOMP:
1249 1.46 darran crdc->crd_flags &= ~CRD_F_COMP;
1250 1.46 darran break;
1251 1.46 darran default:
1252 1.46 darran break;
1253 1.46 darran }
1254 1.46 darran /* more data to follow? */
1255 1.46 darran if (cnop[req].flags & COP_F_MORE) {
1256 1.46 darran flags |= CRYPTO_F_MORE;
1257 1.46 darran }
1258 1.46 darran crdc->crd_len = cnop[req].len;
1259 1.46 darran crdc->crd_inject = 0;
1260 1.46 darran
1261 1.46 darran crdc->crd_alg = cse->comp_alg;
1262 1.46 darran crdc->crd_key = NULL;
1263 1.46 darran crdc->crd_klen = 0;
1264 1.90 knakahar DPRINTF("cse->sid[%d]: crdc setup for comp_alg %d"
1265 1.46 darran " len %d.\n",
1266 1.46 darran (uint32_t)cse->sid, crdc->crd_alg,
1267 1.90 knakahar crdc->crd_len);
1268 1.46 darran }
1269 1.36 tls
1270 1.36 tls if (crda) {
1271 1.36 tls crda->crd_skip = 0;
1272 1.36 tls crda->crd_len = cnop[req].len;
1273 1.36 tls crda->crd_inject = 0; /* ??? */
1274 1.36 tls
1275 1.36 tls crda->crd_alg = cse->mac;
1276 1.36 tls crda->crd_key = cse->mackey;
1277 1.36 tls crda->crd_klen = cse->mackeylen * 8;
1278 1.36 tls }
1279 1.36 tls
1280 1.36 tls if (crde) {
1281 1.36 tls if (cnop[req].op == COP_ENCRYPT)
1282 1.36 tls crde->crd_flags |= CRD_F_ENCRYPT;
1283 1.36 tls else
1284 1.36 tls crde->crd_flags &= ~CRD_F_ENCRYPT;
1285 1.36 tls crde->crd_len = cnop[req].len;
1286 1.36 tls crde->crd_inject = 0;
1287 1.36 tls
1288 1.36 tls crde->crd_alg = cse->cipher;
1289 1.36 tls #ifdef notyet /* XXX must notify h/w driver new key, drain */
1290 1.36 tls if(cnop[req].key && cnop[req].keylen) {
1291 1.36 tls crde->crd_key = malloc(cnop[req].keylen,
1292 1.36 tls M_XDATA, M_WAITOK);
1293 1.36 tls if((error = copyin(cnop[req].key,
1294 1.36 tls crde->crd_key, cnop[req].keylen))) {
1295 1.36 tls cnop[req].status = EINVAL;
1296 1.36 tls goto bail;
1297 1.36 tls }
1298 1.36 tls crde->crd_klen = cnop[req].keylen * 8;
1299 1.36 tls } else { ... }
1300 1.36 tls #endif
1301 1.36 tls crde->crd_key = cse->key;
1302 1.36 tls crde->crd_klen = cse->keylen * 8;
1303 1.36 tls }
1304 1.36 tls
1305 1.36 tls crp->crp_ilen = cnop[req].len;
1306 1.42 christos crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM |
1307 1.46 darran (cnop[req].flags & COP_F_BATCH) | flags;
1308 1.36 tls crp->crp_buf = (void *)&crp->uio;
1309 1.36 tls crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_mcb;
1310 1.36 tls crp->crp_sid = cse->sid;
1311 1.36 tls crp->crp_opaque = (void *)cse;
1312 1.36 tls crp->fcrp = fcr;
1313 1.36 tls crp->dst = cnop[req].dst;
1314 1.46 darran crp->len = cnop[req].len; /* input len, iov may be larger */
1315 1.36 tls crp->mac = cnop[req].mac;
1316 1.90 knakahar DPRINTF("iov_base %p dst %p len %d mac %p\n",
1317 1.46 darran crp->uio.uio_iov[0].iov_base, crp->dst, crp->len,
1318 1.90 knakahar crp->mac);
1319 1.36 tls
1320 1.36 tls if (cnop[req].iv) {
1321 1.36 tls if (crde == NULL) {
1322 1.36 tls cnop[req].status = EINVAL;
1323 1.36 tls goto bail;
1324 1.36 tls }
1325 1.36 tls if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
1326 1.36 tls cnop[req].status = EINVAL;
1327 1.36 tls goto bail;
1328 1.36 tls }
1329 1.36 tls if ((error = copyin(cnop[req].iv, crp->tmp_iv,
1330 1.58 drochner cse->txform->ivsize))) {
1331 1.36 tls cnop[req].status = EINVAL;
1332 1.36 tls goto bail;
1333 1.36 tls }
1334 1.42 christos (void)memcpy(crde->crd_iv, crp->tmp_iv,
1335 1.58 drochner cse->txform->ivsize);
1336 1.36 tls crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
1337 1.36 tls crde->crd_skip = 0;
1338 1.36 tls } else if (crde) {
1339 1.36 tls if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
1340 1.36 tls crde->crd_skip = 0;
1341 1.36 tls } else {
1342 1.61 drochner if (!(crde->crd_flags & CRD_F_ENCRYPT))
1343 1.61 drochner crde->crd_flags |= CRD_F_IV_PRESENT;
1344 1.58 drochner crde->crd_skip = cse->txform->ivsize;
1345 1.58 drochner crde->crd_len -= cse->txform->ivsize;
1346 1.36 tls }
1347 1.36 tls }
1348 1.36 tls
1349 1.36 tls if (cnop[req].mac) {
1350 1.36 tls if (crda == NULL) {
1351 1.36 tls cnop[req].status = EINVAL;
1352 1.36 tls goto bail;
1353 1.36 tls }
1354 1.36 tls crp->crp_mac=cse->tmp_mac;
1355 1.36 tls }
1356 1.36 tls cnop[req].reqid = atomic_inc_32_nv(&(fcr->requestid));
1357 1.36 tls crp->crp_reqid = cnop[req].reqid;
1358 1.36 tls crp->crp_usropaque = cnop[req].opaque;
1359 1.67 drochner cv_init(&crp->crp_cv, "crydev");
1360 1.36 tls #ifdef notyet
1361 1.36 tls eagain:
1362 1.36 tls #endif
1363 1.36 tls cnop[req].status = crypto_dispatch(crp);
1364 1.92 knakahar mutex_enter(&cryptodev_mtx); /* XXX why mutex? */
1365 1.36 tls
1366 1.36 tls switch (cnop[req].status) {
1367 1.36 tls #ifdef notyet /* don't loop forever -- but EAGAIN not possible here yet */
1368 1.36 tls case EAGAIN:
1369 1.92 knakahar mutex_exit(&cryptodev_mtx);
1370 1.36 tls goto eagain;
1371 1.36 tls break;
1372 1.36 tls #endif
1373 1.36 tls case 0:
1374 1.36 tls break;
1375 1.36 tls default:
1376 1.90 knakahar DPRINTF("not waiting, error.\n");
1377 1.92 knakahar mutex_exit(&cryptodev_mtx);
1378 1.67 drochner cv_destroy(&crp->crp_cv);
1379 1.36 tls goto bail;
1380 1.36 tls }
1381 1.36 tls
1382 1.92 knakahar mutex_exit(&cryptodev_mtx);
1383 1.67 drochner cv_destroy(&crp->crp_cv);
1384 1.36 tls bail:
1385 1.36 tls if (cnop[req].status) {
1386 1.36 tls if (crp) {
1387 1.46 darran if (crp->uio.uio_iov[0].iov_base) {
1388 1.46 darran kmem_free(crp->uio.uio_iov[0].iov_base,
1389 1.46 darran crp->uio.uio_iov[0].iov_len);
1390 1.46 darran }
1391 1.36 tls crypto_freereq(crp);
1392 1.36 tls }
1393 1.36 tls error = 0;
1394 1.36 tls }
1395 1.36 tls }
1396 1.42 christos return error;
1397 1.36 tls }
1398 1.36 tls
1399 1.36 tls static int
1400 1.36 tls cryptodev_mkey(struct fcrypt *fcr, struct crypt_n_kop *kop, int count)
1401 1.36 tls {
1402 1.36 tls struct cryptkop *krp = NULL;
1403 1.36 tls int error = EINVAL;
1404 1.36 tls int in, out, size, i, req;
1405 1.36 tls
1406 1.36 tls for (req = 0; req < count; req++) {
1407 1.42 christos if (kop[req].crk_iparams + kop[req].crk_oparams > CRK_MAXPARAM)
1408 1.42 christos return EFBIG;
1409 1.36 tls
1410 1.36 tls in = kop[req].crk_iparams;
1411 1.36 tls out = kop[req].crk_oparams;
1412 1.36 tls switch (kop[req].crk_op) {
1413 1.36 tls case CRK_MOD_EXP:
1414 1.36 tls if (in == 3 && out == 1)
1415 1.36 tls break;
1416 1.36 tls kop[req].crk_status = EINVAL;
1417 1.36 tls continue;
1418 1.36 tls case CRK_MOD_EXP_CRT:
1419 1.36 tls if (in == 6 && out == 1)
1420 1.36 tls break;
1421 1.36 tls kop[req].crk_status = EINVAL;
1422 1.36 tls continue;
1423 1.36 tls case CRK_DSA_SIGN:
1424 1.36 tls if (in == 5 && out == 2)
1425 1.36 tls break;
1426 1.36 tls kop[req].crk_status = EINVAL;
1427 1.36 tls continue;
1428 1.36 tls case CRK_DSA_VERIFY:
1429 1.36 tls if (in == 7 && out == 0)
1430 1.36 tls break;
1431 1.36 tls kop[req].crk_status = EINVAL;
1432 1.36 tls continue;
1433 1.36 tls case CRK_DH_COMPUTE_KEY:
1434 1.36 tls if (in == 3 && out == 1)
1435 1.36 tls break;
1436 1.36 tls kop[req].crk_status = EINVAL;
1437 1.36 tls continue;
1438 1.36 tls case CRK_MOD_ADD:
1439 1.36 tls if (in == 3 && out == 1)
1440 1.36 tls break;
1441 1.36 tls kop[req].crk_status = EINVAL;
1442 1.36 tls continue;
1443 1.36 tls case CRK_MOD_ADDINV:
1444 1.36 tls if (in == 2 && out == 1)
1445 1.36 tls break;
1446 1.36 tls kop[req].crk_status = EINVAL;
1447 1.36 tls continue;
1448 1.36 tls case CRK_MOD_SUB:
1449 1.36 tls if (in == 3 && out == 1)
1450 1.36 tls break;
1451 1.36 tls kop[req].crk_status = EINVAL;
1452 1.36 tls continue;
1453 1.36 tls case CRK_MOD_MULT:
1454 1.36 tls if (in == 3 && out == 1)
1455 1.85 msaitoh break;
1456 1.36 tls kop[req].crk_status = EINVAL;
1457 1.36 tls continue;
1458 1.36 tls case CRK_MOD_MULTINV:
1459 1.36 tls if (in == 2 && out == 1)
1460 1.36 tls break;
1461 1.36 tls kop[req].crk_status = EINVAL;
1462 1.36 tls continue;
1463 1.36 tls case CRK_MOD:
1464 1.36 tls if (in == 2 && out == 1)
1465 1.36 tls break;
1466 1.36 tls kop[req].crk_status = EINVAL;
1467 1.36 tls continue;
1468 1.36 tls default:
1469 1.36 tls kop[req].crk_status = EINVAL;
1470 1.36 tls continue;
1471 1.36 tls }
1472 1.36 tls
1473 1.91 knakahar krp = crypto_kgetreq(1, PR_WAITOK);
1474 1.91 knakahar if (krp == NULL) {
1475 1.91 knakahar /* limited by opencrypto.crypto_ret_kq.maxlen */
1476 1.91 knakahar continue;
1477 1.91 knakahar }
1478 1.42 christos (void)memset(krp, 0, sizeof *krp);
1479 1.36 tls cv_init(&krp->krp_cv, "crykdev");
1480 1.36 tls krp->krp_op = kop[req].crk_op;
1481 1.36 tls krp->krp_status = kop[req].crk_status;
1482 1.36 tls krp->krp_iparams = kop[req].crk_iparams;
1483 1.36 tls krp->krp_oparams = kop[req].crk_oparams;
1484 1.36 tls krp->krp_status = 0;
1485 1.36 tls krp->krp_callback =
1486 1.36 tls (int (*) (struct cryptkop *)) cryptodevkey_mcb;
1487 1.42 christos (void)memcpy(krp->crk_param, kop[req].crk_param,
1488 1.42 christos sizeof(kop[req].crk_param));
1489 1.36 tls
1490 1.36 tls krp->krp_flags = CRYPTO_F_CBIMM;
1491 1.36 tls
1492 1.36 tls for (i = 0; i < CRK_MAXPARAM; i++)
1493 1.36 tls krp->krp_param[i].crp_nbits =
1494 1.36 tls kop[req].crk_param[i].crp_nbits;
1495 1.36 tls for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
1496 1.36 tls size = (krp->krp_param[i].crp_nbits + 7) / 8;
1497 1.36 tls if (size == 0)
1498 1.36 tls continue;
1499 1.36 tls krp->krp_param[i].crp_p =
1500 1.36 tls kmem_alloc(size, KM_SLEEP);
1501 1.36 tls if (i >= krp->krp_iparams)
1502 1.36 tls continue;
1503 1.42 christos kop[req].crk_status =
1504 1.42 christos copyin(kop[req].crk_param[i].crp_p,
1505 1.42 christos krp->krp_param[i].crp_p, size);
1506 1.36 tls if (kop[req].crk_status)
1507 1.36 tls goto fail;
1508 1.36 tls }
1509 1.36 tls krp->fcrp = fcr;
1510 1.36 tls
1511 1.36 tls kop[req].crk_reqid = atomic_inc_32_nv(&(fcr->requestid));
1512 1.36 tls krp->krp_reqid = kop[req].crk_reqid;
1513 1.36 tls krp->krp_usropaque = kop[req].crk_opaque;
1514 1.36 tls
1515 1.36 tls kop[req].crk_status = crypto_kdispatch(krp);
1516 1.36 tls if (kop[req].crk_status != 0) {
1517 1.36 tls goto fail;
1518 1.36 tls }
1519 1.36 tls
1520 1.36 tls fail:
1521 1.36 tls if(kop[req].crk_status) {
1522 1.36 tls if (krp) {
1523 1.36 tls kop[req].crk_status = krp->krp_status;
1524 1.36 tls for (i = 0; i < CRK_MAXPARAM; i++) {
1525 1.36 tls struct crparam *kp =
1526 1.36 tls &(krp->krp_param[i]);
1527 1.36 tls if (kp->crp_p) {
1528 1.36 tls size = (kp->crp_nbits + 7) / 8;
1529 1.36 tls KASSERT(size > 0);
1530 1.36 tls memset(kp->crp_p, 0, size);
1531 1.36 tls kmem_free(kp->crp_p, size);
1532 1.36 tls }
1533 1.36 tls }
1534 1.45 darran cv_destroy(&krp->krp_cv);
1535 1.91 knakahar crypto_kfreereq(krp);
1536 1.36 tls }
1537 1.36 tls }
1538 1.36 tls error = 0;
1539 1.36 tls }
1540 1.90 knakahar DPRINTF("error=0x%08x\n", error);
1541 1.42 christos return error;
1542 1.36 tls }
1543 1.36 tls
1544 1.46 darran int
1545 1.45 darran cryptodev_session(struct fcrypt *fcr, struct session_op *sop)
1546 1.45 darran {
1547 1.36 tls struct cryptoini cria, crie;
1548 1.46 darran struct cryptoini cric; /* compressor */
1549 1.46 darran struct cryptoini *crihead = NULL;
1550 1.54 drochner const struct enc_xform *txform = NULL;
1551 1.54 drochner const struct auth_hash *thash = NULL;
1552 1.54 drochner const struct comp_algo *tcomp = NULL;
1553 1.36 tls struct csession *cse;
1554 1.36 tls u_int64_t sid;
1555 1.36 tls int error = 0;
1556 1.36 tls
1557 1.90 knakahar DPRINTF("cipher=%d, mac=%d\n", sop->cipher, sop->mac);
1558 1.46 darran
1559 1.36 tls /* XXX there must be a way to not embed the list of xforms here */
1560 1.36 tls switch (sop->cipher) {
1561 1.36 tls case 0:
1562 1.36 tls break;
1563 1.36 tls case CRYPTO_DES_CBC:
1564 1.36 tls txform = &enc_xform_des;
1565 1.36 tls break;
1566 1.36 tls case CRYPTO_3DES_CBC:
1567 1.36 tls txform = &enc_xform_3des;
1568 1.36 tls break;
1569 1.36 tls case CRYPTO_BLF_CBC:
1570 1.36 tls txform = &enc_xform_blf;
1571 1.36 tls break;
1572 1.36 tls case CRYPTO_CAST_CBC:
1573 1.36 tls txform = &enc_xform_cast5;
1574 1.52 hubertf break;
1575 1.36 tls case CRYPTO_SKIPJACK_CBC:
1576 1.36 tls txform = &enc_xform_skipjack;
1577 1.36 tls break;
1578 1.36 tls case CRYPTO_AES_CBC:
1579 1.36 tls txform = &enc_xform_rijndael128;
1580 1.36 tls break;
1581 1.60 drochner case CRYPTO_CAMELLIA_CBC:
1582 1.60 drochner txform = &enc_xform_camellia;
1583 1.60 drochner break;
1584 1.59 drochner case CRYPTO_AES_CTR:
1585 1.59 drochner txform = &enc_xform_aes_ctr;
1586 1.59 drochner break;
1587 1.66 drochner case CRYPTO_AES_GCM_16:
1588 1.66 drochner txform = &enc_xform_aes_gcm;
1589 1.66 drochner break;
1590 1.66 drochner case CRYPTO_AES_GMAC:
1591 1.66 drochner txform = &enc_xform_aes_gmac;
1592 1.66 drochner break;
1593 1.36 tls case CRYPTO_NULL_CBC:
1594 1.36 tls txform = &enc_xform_null;
1595 1.36 tls break;
1596 1.36 tls case CRYPTO_ARC4:
1597 1.36 tls txform = &enc_xform_arc4;
1598 1.36 tls break;
1599 1.36 tls default:
1600 1.90 knakahar DPRINTF("Invalid cipher %d\n", sop->cipher);
1601 1.36 tls return EINVAL;
1602 1.36 tls }
1603 1.36 tls
1604 1.46 darran switch (sop->comp_alg) {
1605 1.46 darran case 0:
1606 1.46 darran break;
1607 1.46 darran case CRYPTO_DEFLATE_COMP:
1608 1.46 darran tcomp = &comp_algo_deflate;
1609 1.46 darran break;
1610 1.46 darran case CRYPTO_GZIP_COMP:
1611 1.46 darran tcomp = &comp_algo_gzip;
1612 1.90 knakahar DPRINTF("tcomp for GZIP\n");
1613 1.46 darran break;
1614 1.46 darran default:
1615 1.90 knakahar DPRINTF("Invalid compression alg %d\n", sop->comp_alg);
1616 1.46 darran return EINVAL;
1617 1.46 darran }
1618 1.46 darran
1619 1.36 tls switch (sop->mac) {
1620 1.36 tls case 0:
1621 1.36 tls break;
1622 1.36 tls case CRYPTO_MD5_HMAC:
1623 1.36 tls thash = &auth_hash_hmac_md5;
1624 1.36 tls break;
1625 1.36 tls case CRYPTO_SHA1_HMAC:
1626 1.36 tls thash = &auth_hash_hmac_sha1;
1627 1.36 tls break;
1628 1.36 tls case CRYPTO_MD5_HMAC_96:
1629 1.36 tls thash = &auth_hash_hmac_md5_96;
1630 1.36 tls break;
1631 1.36 tls case CRYPTO_SHA1_HMAC_96:
1632 1.36 tls thash = &auth_hash_hmac_sha1_96;
1633 1.36 tls break;
1634 1.36 tls case CRYPTO_SHA2_HMAC:
1635 1.36 tls /* XXX switching on key length seems questionable */
1636 1.36 tls if (sop->mackeylen == auth_hash_hmac_sha2_256.keysize) {
1637 1.36 tls thash = &auth_hash_hmac_sha2_256;
1638 1.36 tls } else if (sop->mackeylen == auth_hash_hmac_sha2_384.keysize) {
1639 1.36 tls thash = &auth_hash_hmac_sha2_384;
1640 1.36 tls } else if (sop->mackeylen == auth_hash_hmac_sha2_512.keysize) {
1641 1.36 tls thash = &auth_hash_hmac_sha2_512;
1642 1.36 tls } else {
1643 1.90 knakahar DPRINTF("Invalid mackeylen %d\n", sop->mackeylen);
1644 1.36 tls return EINVAL;
1645 1.36 tls }
1646 1.36 tls break;
1647 1.102 hikaru case CRYPTO_SHA2_384_HMAC:
1648 1.102 hikaru thash = &auth_hash_hmac_sha2_384;
1649 1.102 hikaru break;
1650 1.102 hikaru case CRYPTO_SHA2_512_HMAC:
1651 1.102 hikaru thash = &auth_hash_hmac_sha2_512;
1652 1.102 hikaru break;
1653 1.36 tls case CRYPTO_RIPEMD160_HMAC:
1654 1.36 tls thash = &auth_hash_hmac_ripemd_160;
1655 1.36 tls break;
1656 1.36 tls case CRYPTO_RIPEMD160_HMAC_96:
1657 1.36 tls thash = &auth_hash_hmac_ripemd_160_96;
1658 1.36 tls break;
1659 1.36 tls case CRYPTO_MD5:
1660 1.36 tls thash = &auth_hash_md5;
1661 1.36 tls break;
1662 1.36 tls case CRYPTO_SHA1:
1663 1.36 tls thash = &auth_hash_sha1;
1664 1.36 tls break;
1665 1.63 drochner case CRYPTO_AES_XCBC_MAC_96:
1666 1.63 drochner thash = &auth_hash_aes_xcbc_mac_96;
1667 1.63 drochner break;
1668 1.66 drochner case CRYPTO_AES_128_GMAC:
1669 1.66 drochner thash = &auth_hash_gmac_aes_128;
1670 1.66 drochner break;
1671 1.66 drochner case CRYPTO_AES_192_GMAC:
1672 1.66 drochner thash = &auth_hash_gmac_aes_192;
1673 1.66 drochner break;
1674 1.66 drochner case CRYPTO_AES_256_GMAC:
1675 1.66 drochner thash = &auth_hash_gmac_aes_256;
1676 1.66 drochner break;
1677 1.36 tls case CRYPTO_NULL_HMAC:
1678 1.36 tls thash = &auth_hash_null;
1679 1.36 tls break;
1680 1.36 tls default:
1681 1.90 knakahar DPRINTF("Invalid mac %d\n", sop->mac);
1682 1.42 christos return EINVAL;
1683 1.36 tls }
1684 1.36 tls
1685 1.36 tls memset(&crie, 0, sizeof(crie));
1686 1.36 tls memset(&cria, 0, sizeof(cria));
1687 1.46 darran memset(&cric, 0, sizeof(cric));
1688 1.46 darran
1689 1.46 darran if (tcomp) {
1690 1.46 darran cric.cri_alg = tcomp->type;
1691 1.46 darran cric.cri_klen = 0;
1692 1.90 knakahar DPRINTF("tcomp->type = %d\n", tcomp->type);
1693 1.46 darran
1694 1.46 darran crihead = &cric;
1695 1.65 drochner if (txform) {
1696 1.65 drochner cric.cri_next = &crie;
1697 1.65 drochner } else if (thash) {
1698 1.46 darran cric.cri_next = &cria;
1699 1.46 darran }
1700 1.46 darran }
1701 1.36 tls
1702 1.36 tls if (txform) {
1703 1.36 tls crie.cri_alg = txform->type;
1704 1.36 tls crie.cri_klen = sop->keylen * 8;
1705 1.36 tls if (sop->keylen > txform->maxkey ||
1706 1.36 tls sop->keylen < txform->minkey) {
1707 1.90 knakahar DPRINTF("keylen %d not in [%d,%d]\n",
1708 1.90 knakahar sop->keylen, txform->minkey, txform->maxkey);
1709 1.42 christos error = EINVAL;
1710 1.36 tls goto bail;
1711 1.36 tls }
1712 1.36 tls
1713 1.36 tls crie.cri_key = malloc(crie.cri_klen / 8, M_XDATA, M_WAITOK);
1714 1.42 christos if ((error = copyin(sop->key, crie.cri_key, crie.cri_klen / 8)))
1715 1.36 tls goto bail;
1716 1.46 darran if (!crihead) {
1717 1.46 darran crihead = &crie;
1718 1.46 darran }
1719 1.65 drochner if (thash)
1720 1.65 drochner crie.cri_next = &cria;
1721 1.46 darran }
1722 1.36 tls
1723 1.36 tls if (thash) {
1724 1.36 tls cria.cri_alg = thash->type;
1725 1.36 tls cria.cri_klen = sop->mackeylen * 8;
1726 1.36 tls if (sop->mackeylen != thash->keysize) {
1727 1.90 knakahar DPRINTF("mackeylen %d != keysize %d\n",
1728 1.90 knakahar sop->mackeylen, thash->keysize);
1729 1.36 tls error = EINVAL;
1730 1.36 tls goto bail;
1731 1.36 tls }
1732 1.36 tls if (cria.cri_klen) {
1733 1.36 tls cria.cri_key = malloc(cria.cri_klen / 8, M_XDATA,
1734 1.42 christos M_WAITOK);
1735 1.36 tls if ((error = copyin(sop->mackey, cria.cri_key,
1736 1.42 christos cria.cri_klen / 8))) {
1737 1.36 tls goto bail;
1738 1.36 tls }
1739 1.36 tls }
1740 1.46 darran if (!crihead) {
1741 1.46 darran crihead = &cria;
1742 1.46 darran }
1743 1.36 tls }
1744 1.46 darran
1745 1.46 darran error = crypto_newsession(&sid, crihead, crypto_devallowsoft);
1746 1.36 tls if (!error) {
1747 1.90 knakahar DPRINTF("got session %d\n", (uint32_t)sid);
1748 1.36 tls cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen,
1749 1.46 darran cria.cri_key, cria.cri_klen, (txform ? sop->cipher : 0), sop->mac,
1750 1.46 darran (tcomp ? sop->comp_alg : 0), txform, thash, tcomp);
1751 1.36 tls if (cse != NULL) {
1752 1.36 tls sop->ses = cse->ses;
1753 1.36 tls } else {
1754 1.90 knakahar DPRINTF("csecreate failed\n");
1755 1.36 tls crypto_freesession(sid);
1756 1.36 tls error = EINVAL;
1757 1.36 tls }
1758 1.36 tls } else {
1759 1.90 knakahar DPRINTF("SIOCSESSION violates kernel parameters %d\n", error);
1760 1.36 tls }
1761 1.36 tls bail:
1762 1.36 tls if (error) {
1763 1.36 tls if (crie.cri_key) {
1764 1.36 tls memset(crie.cri_key, 0, crie.cri_klen / 8);
1765 1.36 tls free(crie.cri_key, M_XDATA);
1766 1.36 tls }
1767 1.36 tls if (cria.cri_key) {
1768 1.36 tls memset(cria.cri_key, 0, cria.cri_klen / 8);
1769 1.36 tls free(cria.cri_key, M_XDATA);
1770 1.36 tls }
1771 1.36 tls }
1772 1.36 tls return error;
1773 1.36 tls }
1774 1.36 tls
1775 1.46 darran int
1776 1.36 tls cryptodev_msession(struct fcrypt *fcr, struct session_n_op *sn_ops,
1777 1.36 tls int count)
1778 1.36 tls {
1779 1.36 tls int i;
1780 1.36 tls
1781 1.36 tls for (i = 0; i < count; i++, sn_ops++) {
1782 1.36 tls struct session_op s_op;
1783 1.36 tls s_op.cipher = sn_ops->cipher;
1784 1.36 tls s_op.mac = sn_ops->mac;
1785 1.94 knakahar s_op.comp_alg = sn_ops->comp_alg;
1786 1.36 tls s_op.keylen = sn_ops->keylen;
1787 1.36 tls s_op.key = sn_ops->key;
1788 1.36 tls s_op.mackeylen = sn_ops->mackeylen;
1789 1.36 tls s_op.mackey = sn_ops->mackey;
1790 1.36 tls
1791 1.36 tls sn_ops->status = cryptodev_session(fcr, &s_op);
1792 1.94 knakahar
1793 1.36 tls sn_ops->ses = s_op.ses;
1794 1.36 tls }
1795 1.36 tls
1796 1.36 tls return 0;
1797 1.36 tls }
1798 1.36 tls
1799 1.36 tls static int
1800 1.36 tls cryptodev_msessionfin(struct fcrypt *fcr, int count, u_int32_t *sesid)
1801 1.36 tls {
1802 1.36 tls struct csession *cse;
1803 1.36 tls int req, error = 0;
1804 1.36 tls
1805 1.92 knakahar mutex_enter(&cryptodev_mtx);
1806 1.36 tls for(req = 0; req < count; req++) {
1807 1.36 tls cse = csefind(fcr, sesid[req]);
1808 1.36 tls if (cse == NULL)
1809 1.36 tls continue;
1810 1.36 tls csedelete(fcr, cse);
1811 1.92 knakahar mutex_exit(&cryptodev_mtx);
1812 1.36 tls error = csefree(cse);
1813 1.92 knakahar mutex_enter(&cryptodev_mtx);
1814 1.36 tls }
1815 1.92 knakahar mutex_exit(&cryptodev_mtx);
1816 1.69 martin return error;
1817 1.36 tls }
1818 1.36 tls
1819 1.36 tls /*
1820 1.42 christos * collect as many completed requests as are availble, or count completed
1821 1.42 christos * requests whichever is less.
1822 1.36 tls * return the number of requests.
1823 1.36 tls */
1824 1.36 tls static int
1825 1.36 tls cryptodev_getmstatus(struct fcrypt *fcr, struct crypt_result *crypt_res,
1826 1.42 christos int count)
1827 1.36 tls {
1828 1.36 tls struct cryptop *crp = NULL;
1829 1.36 tls struct cryptkop *krp = NULL;
1830 1.36 tls struct csession *cse;
1831 1.36 tls int i, size, req = 0;
1832 1.36 tls int completed=0;
1833 1.36 tls
1834 1.46 darran /* On queue so nobody else can grab them
1835 1.46 darran * and copyout can be delayed-- no locking */
1836 1.46 darran TAILQ_HEAD(, cryptop) crp_delfree_q =
1837 1.46 darran TAILQ_HEAD_INITIALIZER(crp_delfree_q);
1838 1.46 darran TAILQ_HEAD(, cryptkop) krp_delfree_q =
1839 1.46 darran TAILQ_HEAD_INITIALIZER(krp_delfree_q);
1840 1.36 tls
1841 1.36 tls /* at this point we do not know which response user is requesting for
1842 1.36 tls * (symmetric or asymmetric) so we copyout one from each i.e if the
1843 1.36 tls * count is 2 then 1 from symmetric and 1 from asymmetric queue and
1844 1.36 tls * if 3 then 2 symmetric and 1 asymmetric and so on */
1845 1.46 darran
1846 1.46 darran /* pull off a list of requests while protected from changes */
1847 1.92 knakahar mutex_enter(&cryptodev_mtx);
1848 1.46 darran while (req < count) {
1849 1.36 tls crp = TAILQ_FIRST(&fcr->crp_ret_mq);
1850 1.46 darran if (crp) {
1851 1.46 darran TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
1852 1.46 darran TAILQ_INSERT_TAIL(&crp_delfree_q, crp, crp_next);
1853 1.36 tls cse = (struct csession *)crp->crp_opaque;
1854 1.46 darran
1855 1.46 darran /* see if the session is still valid */
1856 1.36 tls cse = csefind(fcr, cse->ses);
1857 1.46 darran if (cse != NULL) {
1858 1.46 darran crypt_res[req].status = 0;
1859 1.46 darran } else {
1860 1.90 knakahar DPRINTF("csefind failed\n");
1861 1.36 tls crypt_res[req].status = EINVAL;
1862 1.46 darran }
1863 1.46 darran req++;
1864 1.46 darran }
1865 1.46 darran if(req < count) {
1866 1.46 darran crypt_res[req].status = 0;
1867 1.46 darran krp = TAILQ_FIRST(&fcr->crp_ret_mkq);
1868 1.46 darran if (krp) {
1869 1.46 darran TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
1870 1.46 darran TAILQ_INSERT_TAIL(&krp_delfree_q, krp, krp_next);
1871 1.46 darran req++;
1872 1.46 darran }
1873 1.46 darran }
1874 1.46 darran }
1875 1.92 knakahar mutex_exit(&cryptodev_mtx);
1876 1.46 darran
1877 1.46 darran /* now do all the work outside the mutex */
1878 1.46 darran for(req=0; req < count ;) {
1879 1.46 darran crp = TAILQ_FIRST(&crp_delfree_q);
1880 1.46 darran if (crp) {
1881 1.46 darran if (crypt_res[req].status != 0) {
1882 1.46 darran /* csefind failed during collection */
1883 1.36 tls goto bail;
1884 1.36 tls }
1885 1.46 darran cse = (struct csession *)crp->crp_opaque;
1886 1.46 darran crypt_res[req].reqid = crp->crp_reqid;
1887 1.46 darran crypt_res[req].opaque = crp->crp_usropaque;
1888 1.46 darran completed++;
1889 1.36 tls
1890 1.36 tls if (crp->crp_etype != 0) {
1891 1.36 tls crypt_res[req].status = crp->crp_etype;
1892 1.36 tls goto bail;
1893 1.36 tls }
1894 1.36 tls
1895 1.36 tls if (cse->error) {
1896 1.36 tls crypt_res[req].status = cse->error;
1897 1.36 tls goto bail;
1898 1.36 tls }
1899 1.36 tls
1900 1.42 christos if (crp->dst && (crypt_res[req].status =
1901 1.42 christos copyout(crp->uio.uio_iov[0].iov_base, crp->dst,
1902 1.42 christos crp->len)))
1903 1.36 tls goto bail;
1904 1.36 tls
1905 1.42 christos if (crp->mac && (crypt_res[req].status =
1906 1.42 christos copyout(crp->crp_mac, crp->mac,
1907 1.42 christos cse->thash->authsize)))
1908 1.36 tls goto bail;
1909 1.46 darran
1910 1.36 tls bail:
1911 1.46 darran TAILQ_REMOVE(&crp_delfree_q, crp, crp_next);
1912 1.46 darran kmem_free(crp->uio.uio_iov[0].iov_base,
1913 1.46 darran crp->uio.uio_iov[0].iov_len);
1914 1.46 darran crypto_freereq(crp);
1915 1.36 tls req++;
1916 1.36 tls }
1917 1.36 tls
1918 1.46 darran if (req < count) {
1919 1.46 darran krp = TAILQ_FIRST(&krp_delfree_q);
1920 1.36 tls if (krp) {
1921 1.36 tls crypt_res[req].reqid = krp->krp_reqid;
1922 1.36 tls crypt_res[req].opaque = krp->krp_usropaque;
1923 1.36 tls completed++;
1924 1.36 tls if (krp->krp_status != 0) {
1925 1.90 knakahar DPRINTF("krp->krp_status 0x%08x\n",
1926 1.90 knakahar krp->krp_status);
1927 1.42 christos crypt_res[req].status = krp->krp_status;
1928 1.36 tls goto fail;
1929 1.36 tls }
1930 1.36 tls
1931 1.36 tls for (i = krp->krp_iparams; i < krp->krp_iparams
1932 1.42 christos + krp->krp_oparams; i++) {
1933 1.36 tls size = (krp->krp_param[i].crp_nbits
1934 1.42 christos + 7) / 8;
1935 1.36 tls if (size == 0)
1936 1.36 tls continue;
1937 1.36 tls crypt_res[req].status = copyout
1938 1.36 tls (krp->krp_param[i].crp_p,
1939 1.36 tls krp->crk_param[i].crp_p, size);
1940 1.36 tls if (crypt_res[req].status) {
1941 1.90 knakahar DPRINTF("copyout oparam %d failed, "
1942 1.42 christos "error=%d\n",
1943 1.42 christos i - krp->krp_iparams,
1944 1.90 knakahar crypt_res[req].status);
1945 1.36 tls goto fail;
1946 1.36 tls }
1947 1.36 tls }
1948 1.36 tls fail:
1949 1.46 darran TAILQ_REMOVE(&krp_delfree_q, krp, krp_next);
1950 1.36 tls /* not sure what to do for this */
1951 1.36 tls /* kop[req].crk_status = krp->krp_status; */
1952 1.46 darran for (i = 0; i < CRK_MAXPARAM; i++) {
1953 1.46 darran struct crparam *kp = &(krp->krp_param[i]);
1954 1.46 darran if (kp->crp_p) {
1955 1.46 darran size = (kp->crp_nbits + 7) / 8;
1956 1.46 darran KASSERT(size > 0);
1957 1.46 darran (void)memset(kp->crp_p, 0, size);
1958 1.46 darran kmem_free(kp->crp_p, size);
1959 1.46 darran }
1960 1.46 darran }
1961 1.46 darran cv_destroy(&krp->krp_cv);
1962 1.91 knakahar crypto_kfreereq(krp);
1963 1.46 darran req++;
1964 1.36 tls }
1965 1.36 tls }
1966 1.36 tls }
1967 1.36 tls
1968 1.85 msaitoh return completed;
1969 1.36 tls }
1970 1.36 tls
1971 1.36 tls static int
1972 1.36 tls cryptodev_getstatus (struct fcrypt *fcr, struct crypt_result *crypt_res)
1973 1.36 tls {
1974 1.45 darran struct cryptop *crp = NULL, *cnext;
1975 1.45 darran struct cryptkop *krp = NULL, *knext;
1976 1.36 tls struct csession *cse;
1977 1.36 tls int i, size, req = 0;
1978 1.36 tls
1979 1.92 knakahar mutex_enter(&cryptodev_mtx);
1980 1.36 tls /* Here we dont know for which request the user is requesting the
1981 1.36 tls * response so checking in both the queues */
1982 1.45 darran TAILQ_FOREACH_SAFE(crp, &fcr->crp_ret_mq, crp_next, cnext) {
1983 1.36 tls if(crp && (crp->crp_reqid == crypt_res->reqid)) {
1984 1.36 tls cse = (struct csession *)crp->crp_opaque;
1985 1.36 tls crypt_res->opaque = crp->crp_usropaque;
1986 1.36 tls cse = csefind(fcr, cse->ses);
1987 1.36 tls if (cse == NULL) {
1988 1.90 knakahar DPRINTF("csefind failed\n");
1989 1.36 tls crypt_res->status = EINVAL;
1990 1.36 tls goto bail;
1991 1.36 tls }
1992 1.36 tls
1993 1.36 tls if (crp->crp_etype != 0) {
1994 1.36 tls crypt_res->status = crp->crp_etype;
1995 1.36 tls goto bail;
1996 1.36 tls }
1997 1.36 tls
1998 1.36 tls if (cse->error) {
1999 1.36 tls crypt_res->status = cse->error;
2000 1.36 tls goto bail;
2001 1.36 tls }
2002 1.36 tls
2003 1.42 christos if (crp->dst && (crypt_res->status =
2004 1.42 christos copyout(crp->uio.uio_iov[0].iov_base,
2005 1.42 christos crp->dst, crp->len)))
2006 1.36 tls goto bail;
2007 1.36 tls
2008 1.42 christos if (crp->mac && (crypt_res->status =
2009 1.42 christos copyout(crp->crp_mac, crp->mac,
2010 1.42 christos cse->thash->authsize)))
2011 1.36 tls goto bail;
2012 1.36 tls bail:
2013 1.36 tls TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
2014 1.36 tls
2015 1.92 knakahar mutex_exit(&cryptodev_mtx);
2016 1.36 tls crypto_freereq(crp);
2017 1.36 tls return 0;
2018 1.36 tls }
2019 1.36 tls }
2020 1.36 tls
2021 1.45 darran TAILQ_FOREACH_SAFE(krp, &fcr->crp_ret_mkq, krp_next, knext) {
2022 1.36 tls if(krp && (krp->krp_reqid == crypt_res->reqid)) {
2023 1.36 tls crypt_res[req].opaque = krp->krp_usropaque;
2024 1.36 tls if (krp->krp_status != 0) {
2025 1.90 knakahar DPRINTF("krp->krp_status 0x%08x\n",
2026 1.90 knakahar krp->krp_status);
2027 1.36 tls crypt_res[req].status = krp->krp_status;
2028 1.36 tls goto fail;
2029 1.36 tls }
2030 1.36 tls
2031 1.42 christos for (i = krp->krp_iparams; i < krp->krp_iparams +
2032 1.42 christos krp->krp_oparams; i++) {
2033 1.36 tls size = (krp->krp_param[i].crp_nbits + 7) / 8;
2034 1.36 tls if (size == 0)
2035 1.36 tls continue;
2036 1.42 christos crypt_res[req].status = copyout(
2037 1.42 christos krp->krp_param[i].crp_p,
2038 1.42 christos krp->crk_param[i].crp_p, size);
2039 1.36 tls if (crypt_res[req].status) {
2040 1.90 knakahar DPRINTF("copyout oparam "
2041 1.42 christos "%d failed, error=%d\n",
2042 1.42 christos i - krp->krp_iparams,
2043 1.90 knakahar crypt_res[req].status);
2044 1.36 tls goto fail;
2045 1.36 tls }
2046 1.36 tls }
2047 1.36 tls fail:
2048 1.36 tls TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
2049 1.92 knakahar mutex_exit(&cryptodev_mtx);
2050 1.36 tls /* not sure what to do for this */
2051 1.36 tls /* kop[req].crk_status = krp->krp_status; */
2052 1.36 tls for (i = 0; i < CRK_MAXPARAM; i++) {
2053 1.36 tls struct crparam *kp = &(krp->krp_param[i]);
2054 1.36 tls if (kp->crp_p) {
2055 1.36 tls size = (kp->crp_nbits + 7) / 8;
2056 1.36 tls KASSERT(size > 0);
2057 1.36 tls memset(kp->crp_p, 0, size);
2058 1.36 tls kmem_free(kp->crp_p, size);
2059 1.36 tls }
2060 1.36 tls }
2061 1.45 darran cv_destroy(&krp->krp_cv);
2062 1.91 knakahar crypto_kfreereq(krp);
2063 1.36 tls return 0;
2064 1.36 tls }
2065 1.36 tls }
2066 1.92 knakahar mutex_exit(&cryptodev_mtx);
2067 1.85 msaitoh return EINPROGRESS;
2068 1.36 tls }
2069 1.36 tls
2070 1.36 tls static int
2071 1.48 christos cryptof_stat(struct file *fp, struct stat *st)
2072 1.48 christos {
2073 1.81 matt struct fcrypt *fcr = fp->f_fcrypt;
2074 1.48 christos
2075 1.68 joerg (void)memset(st, 0, sizeof(*st));
2076 1.49 christos
2077 1.92 knakahar mutex_enter(&cryptodev_mtx);
2078 1.48 christos st->st_dev = makedev(cdevsw_lookup_major(&crypto_cdevsw), fcr->sesn);
2079 1.48 christos st->st_atimespec = fcr->atime;
2080 1.48 christos st->st_mtimespec = fcr->mtime;
2081 1.48 christos st->st_ctimespec = st->st_birthtimespec = fcr->btime;
2082 1.49 christos st->st_uid = kauth_cred_geteuid(fp->f_cred);
2083 1.49 christos st->st_gid = kauth_cred_getegid(fp->f_cred);
2084 1.92 knakahar mutex_exit(&cryptodev_mtx);
2085 1.49 christos
2086 1.48 christos return 0;
2087 1.48 christos }
2088 1.48 christos
2089 1.48 christos static int
2090 1.36 tls cryptof_poll(struct file *fp, int events)
2091 1.36 tls {
2092 1.81 matt struct fcrypt *fcr = fp->f_fcrypt;
2093 1.38 rmind int revents = 0;
2094 1.36 tls
2095 1.36 tls if (!(events & (POLLIN | POLLRDNORM))) {
2096 1.36 tls /* only support read and POLLIN */
2097 1.36 tls return 0;
2098 1.36 tls }
2099 1.36 tls
2100 1.92 knakahar mutex_enter(&cryptodev_mtx);
2101 1.36 tls if (TAILQ_EMPTY(&fcr->crp_ret_mq) && TAILQ_EMPTY(&fcr->crp_ret_mkq)) {
2102 1.38 rmind /* no completed requests pending, save the poll for later */
2103 1.36 tls selrecord(curlwp, &fcr->sinfo);
2104 1.36 tls } else {
2105 1.36 tls /* let the app(s) know that there are completed requests */
2106 1.38 rmind revents = events & (POLLIN | POLLRDNORM);
2107 1.36 tls }
2108 1.92 knakahar mutex_exit(&cryptodev_mtx);
2109 1.38 rmind
2110 1.38 rmind return revents;
2111 1.36 tls }
2112 1.36 tls
2113 1.15 thorpej /*
2114 1.15 thorpej * Pseudo-device initialization routine for /dev/crypto
2115 1.15 thorpej */
2116 1.15 thorpej void
2117 1.25 christos cryptoattach(int num)
2118 1.15 thorpej {
2119 1.96 christos int error;
2120 1.96 christos
2121 1.80 skrll crypto_init();
2122 1.80 skrll
2123 1.92 knakahar mutex_init(&cryptodev_mtx, MUTEX_DEFAULT, IPL_NONE);
2124 1.89 knakahar
2125 1.29 tls pool_init(&fcrpl, sizeof(struct fcrypt), 0, 0, 0, "fcrpl",
2126 1.42 christos NULL, IPL_NET); /* XXX IPL_NET ("splcrypto") */
2127 1.29 tls pool_init(&csepl, sizeof(struct csession), 0, 0, 0, "csepl",
2128 1.42 christos NULL, IPL_NET); /* XXX IPL_NET ("splcrypto") */
2129 1.29 tls
2130 1.29 tls /*
2131 1.29 tls * Preallocate space for 64 users, with 5 sessions each.
2132 1.29 tls * (consider that a TLS protocol session requires at least
2133 1.29 tls * 3DES, MD5, and SHA1 (both hashes are used in the PRF) for
2134 1.29 tls * the negotiation, plus HMAC_SHA1 for the actual SSL records,
2135 1.29 tls * consuming one session here for each algorithm.
2136 1.29 tls */
2137 1.96 christos if ((error = pool_prime(&fcrpl, 64)) != 0 ||
2138 1.96 christos (error = pool_prime(&csepl, 64 * 5)) != 0)
2139 1.96 christos panic("%s: can't prime pool: %d", __func__, error);
2140 1.15 thorpej }
2141 1.70 pgoyette
2142 1.70 pgoyette void crypto_attach(device_t, device_t, void *);
2143 1.70 pgoyette
2144 1.70 pgoyette void
2145 1.70 pgoyette crypto_attach(device_t parent, device_t self, void * opaque)
2146 1.70 pgoyette {
2147 1.70 pgoyette
2148 1.70 pgoyette cryptoattach(0);
2149 1.70 pgoyette }
2150 1.70 pgoyette
2151 1.70 pgoyette int crypto_detach(device_t, int);
2152 1.70 pgoyette
2153 1.70 pgoyette int
2154 1.70 pgoyette crypto_detach(device_t self, int num)
2155 1.70 pgoyette {
2156 1.73 pgoyette
2157 1.70 pgoyette pool_destroy(&fcrpl);
2158 1.70 pgoyette pool_destroy(&csepl);
2159 1.70 pgoyette
2160 1.92 knakahar mutex_destroy(&cryptodev_mtx);
2161 1.89 knakahar
2162 1.70 pgoyette return 0;
2163 1.70 pgoyette }
2164 1.70 pgoyette
2165 1.70 pgoyette int crypto_match(device_t, cfdata_t, void *);
2166 1.70 pgoyette
2167 1.70 pgoyette int
2168 1.70 pgoyette crypto_match(device_t parent, cfdata_t data, void *opaque)
2169 1.70 pgoyette {
2170 1.70 pgoyette
2171 1.70 pgoyette return 1;
2172 1.70 pgoyette }
2173 1.70 pgoyette
2174 1.71 pgoyette MODULE(MODULE_CLASS_DRIVER, crypto, "opencrypto");
2175 1.70 pgoyette
2176 1.70 pgoyette CFDRIVER_DECL(crypto, DV_DULL, NULL);
2177 1.70 pgoyette
2178 1.70 pgoyette CFATTACH_DECL2_NEW(crypto, 0, crypto_match, crypto_attach, crypto_detach,
2179 1.70 pgoyette NULL, NULL, NULL);
2180 1.70 pgoyette
2181 1.71 pgoyette #ifdef _MODULE
2182 1.77 pgoyette static int cryptoloc[] = { -1, -1 };
2183 1.77 pgoyette
2184 1.77 pgoyette static struct cfdata crypto_cfdata[] = {
2185 1.77 pgoyette {
2186 1.77 pgoyette .cf_name = "crypto",
2187 1.77 pgoyette .cf_atname = "crypto",
2188 1.77 pgoyette .cf_unit = 0,
2189 1.77 pgoyette .cf_fstate = 0,
2190 1.77 pgoyette .cf_loc = cryptoloc,
2191 1.77 pgoyette .cf_flags = 0,
2192 1.77 pgoyette .cf_pspec = NULL,
2193 1.77 pgoyette },
2194 1.77 pgoyette { NULL, NULL, 0, 0, NULL, 0, NULL }
2195 1.77 pgoyette };
2196 1.71 pgoyette #endif
2197 1.70 pgoyette
2198 1.70 pgoyette static int
2199 1.70 pgoyette crypto_modcmd(modcmd_t cmd, void *arg)
2200 1.70 pgoyette {
2201 1.71 pgoyette int error = 0;
2202 1.71 pgoyette #ifdef _MODULE
2203 1.70 pgoyette devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR;
2204 1.71 pgoyette #endif
2205 1.70 pgoyette
2206 1.70 pgoyette switch (cmd) {
2207 1.70 pgoyette case MODULE_CMD_INIT:
2208 1.71 pgoyette #ifdef _MODULE
2209 1.77 pgoyette
2210 1.77 pgoyette error = config_cfdriver_attach(&crypto_cd);
2211 1.77 pgoyette if (error) {
2212 1.70 pgoyette return error;
2213 1.77 pgoyette }
2214 1.77 pgoyette
2215 1.77 pgoyette error = config_cfattach_attach(crypto_cd.cd_name, &crypto_ca);
2216 1.77 pgoyette if (error) {
2217 1.77 pgoyette config_cfdriver_detach(&crypto_cd);
2218 1.77 pgoyette aprint_error("%s: unable to register cfattach\n",
2219 1.77 pgoyette crypto_cd.cd_name);
2220 1.77 pgoyette
2221 1.77 pgoyette return error;
2222 1.77 pgoyette }
2223 1.77 pgoyette
2224 1.77 pgoyette error = config_cfdata_attach(crypto_cfdata, 1);
2225 1.77 pgoyette if (error) {
2226 1.77 pgoyette config_cfattach_detach(crypto_cd.cd_name, &crypto_ca);
2227 1.77 pgoyette config_cfdriver_detach(&crypto_cd);
2228 1.77 pgoyette aprint_error("%s: unable to register cfdata\n",
2229 1.77 pgoyette crypto_cd.cd_name);
2230 1.77 pgoyette
2231 1.77 pgoyette return error;
2232 1.77 pgoyette }
2233 1.70 pgoyette
2234 1.70 pgoyette error = devsw_attach(crypto_cd.cd_name, NULL, &bmajor,
2235 1.77 pgoyette &crypto_cdevsw, &cmajor);
2236 1.70 pgoyette if (error) {
2237 1.77 pgoyette error = config_cfdata_detach(crypto_cfdata);
2238 1.77 pgoyette if (error) {
2239 1.77 pgoyette return error;
2240 1.77 pgoyette }
2241 1.77 pgoyette config_cfattach_detach(crypto_cd.cd_name, &crypto_ca);
2242 1.77 pgoyette config_cfdriver_detach(&crypto_cd);
2243 1.70 pgoyette aprint_error("%s: unable to register devsw\n",
2244 1.70 pgoyette crypto_cd.cd_name);
2245 1.70 pgoyette
2246 1.70 pgoyette return error;
2247 1.70 pgoyette }
2248 1.70 pgoyette
2249 1.77 pgoyette (void)config_attach_pseudo(crypto_cfdata);
2250 1.71 pgoyette #endif
2251 1.70 pgoyette
2252 1.71 pgoyette return error;
2253 1.70 pgoyette case MODULE_CMD_FINI:
2254 1.71 pgoyette #ifdef _MODULE
2255 1.101 christos if (crypto_refcount != 0)
2256 1.101 christos return EBUSY;
2257 1.77 pgoyette error = config_cfdata_detach(crypto_cfdata);
2258 1.70 pgoyette if (error) {
2259 1.70 pgoyette return error;
2260 1.70 pgoyette }
2261 1.77 pgoyette
2262 1.77 pgoyette config_cfattach_detach(crypto_cd.cd_name, &crypto_ca);
2263 1.77 pgoyette config_cfdriver_detach(&crypto_cd);
2264 1.77 pgoyette devsw_detach(NULL, &crypto_cdevsw);
2265 1.71 pgoyette #endif
2266 1.70 pgoyette
2267 1.71 pgoyette return error;
2268 1.74 pgoyette #ifdef _MODULE
2269 1.74 pgoyette case MODULE_CMD_AUTOUNLOAD:
2270 1.75 pgoyette #if 0 /*
2271 1.75 pgoyette * XXX Completely disable auto-unload for now, since there is still
2272 1.75 pgoyette * XXX a (small) window where in-module ref-counting doesn't help
2273 1.75 pgoyette */
2274 1.74 pgoyette if (crypto_refcount != 0)
2275 1.75 pgoyette #endif
2276 1.74 pgoyette return EBUSY;
2277 1.74 pgoyette /* FALLTHROUGH */
2278 1.74 pgoyette #endif
2279 1.70 pgoyette default:
2280 1.70 pgoyette return ENOTTY;
2281 1.70 pgoyette }
2282 1.70 pgoyette }
2283