cryptodev.c revision 1.38 1 1.38 rmind /* $NetBSD: cryptodev.c,v 1.38 2008/04/11 10:28:10 rmind 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 * 3. All advertising materials mentioning features or use of this software
21 1.36 tls * must display the following acknowledgement:
22 1.36 tls * This product includes software developed by the NetBSD
23 1.36 tls * Foundation, Inc. and its contributors.
24 1.36 tls * 4. Neither the name of The NetBSD Foundation nor the names of its
25 1.36 tls * contributors may be used to endorse or promote products derived
26 1.36 tls * from this software without specific prior written permission.
27 1.36 tls *
28 1.36 tls * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29 1.36 tls * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30 1.36 tls * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31 1.36 tls * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32 1.36 tls * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33 1.36 tls * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34 1.36 tls * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35 1.36 tls * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36 1.36 tls * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37 1.36 tls * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38 1.36 tls * POSSIBILITY OF SUCH DAMAGE.
39 1.36 tls */
40 1.36 tls
41 1.1 jonathan /*
42 1.1 jonathan * Copyright (c) 2001 Theo de Raadt
43 1.1 jonathan *
44 1.1 jonathan * Redistribution and use in source and binary forms, with or without
45 1.1 jonathan * modification, are permitted provided that the following conditions
46 1.1 jonathan * are met:
47 1.1 jonathan *
48 1.1 jonathan * 1. Redistributions of source code must retain the above copyright
49 1.1 jonathan * notice, this list of conditions and the following disclaimer.
50 1.1 jonathan * 2. Redistributions in binary form must reproduce the above copyright
51 1.1 jonathan * notice, this list of conditions and the following disclaimer in the
52 1.1 jonathan * documentation and/or other materials provided with the distribution.
53 1.1 jonathan * 3. The name of the author may not be used to endorse or promote products
54 1.1 jonathan * derived from this software without specific prior written permission.
55 1.1 jonathan *
56 1.1 jonathan * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
57 1.1 jonathan * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
58 1.1 jonathan * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
59 1.1 jonathan * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
60 1.1 jonathan * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
61 1.1 jonathan * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
62 1.1 jonathan * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
63 1.1 jonathan * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
64 1.1 jonathan * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
65 1.1 jonathan * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
66 1.1 jonathan *
67 1.1 jonathan * Effort sponsored in part by the Defense Advanced Research Projects
68 1.1 jonathan * Agency (DARPA) and Air Force Research Laboratory, Air Force
69 1.1 jonathan * Materiel Command, USAF, under agreement number F30602-01-2-0537.
70 1.1 jonathan *
71 1.1 jonathan */
72 1.1 jonathan
73 1.1 jonathan #include <sys/cdefs.h>
74 1.38 rmind __KERNEL_RCSID(0, "$NetBSD: cryptodev.c,v 1.38 2008/04/11 10:28:10 rmind Exp $");
75 1.1 jonathan
76 1.1 jonathan #include <sys/param.h>
77 1.1 jonathan #include <sys/systm.h>
78 1.36 tls #include <sys/kmem.h>
79 1.1 jonathan #include <sys/malloc.h>
80 1.1 jonathan #include <sys/mbuf.h>
81 1.29 tls #include <sys/pool.h>
82 1.1 jonathan #include <sys/sysctl.h>
83 1.1 jonathan #include <sys/file.h>
84 1.1 jonathan #include <sys/filedesc.h>
85 1.1 jonathan #include <sys/errno.h>
86 1.2 jonathan #include <sys/md5.h>
87 1.1 jonathan #include <sys/sha1.h>
88 1.1 jonathan #include <sys/conf.h>
89 1.1 jonathan #include <sys/device.h>
90 1.21 elad #include <sys/kauth.h>
91 1.36 tls #include <sys/select.h>
92 1.36 tls #include <sys/poll.h>
93 1.37 dogcow #include <sys/atomic.h>
94 1.1 jonathan
95 1.33 tls #include "opt_ocf.h"
96 1.1 jonathan #include <opencrypto/cryptodev.h>
97 1.1 jonathan #include <opencrypto/xform.h>
98 1.1 jonathan
99 1.1 jonathan struct csession {
100 1.1 jonathan TAILQ_ENTRY(csession) next;
101 1.1 jonathan u_int64_t sid;
102 1.1 jonathan u_int32_t ses;
103 1.1 jonathan
104 1.1 jonathan u_int32_t cipher;
105 1.1 jonathan struct enc_xform *txform;
106 1.1 jonathan u_int32_t mac;
107 1.1 jonathan struct auth_hash *thash;
108 1.1 jonathan
109 1.26 christos void * key;
110 1.1 jonathan int keylen;
111 1.1 jonathan u_char tmp_iv[EALG_MAX_BLOCK_LEN];
112 1.1 jonathan
113 1.26 christos void * mackey;
114 1.1 jonathan int mackeylen;
115 1.1 jonathan u_char tmp_mac[CRYPTO_MAX_MAC_LEN];
116 1.1 jonathan
117 1.29 tls struct iovec iovec[1]; /* user requests never have more */
118 1.1 jonathan struct uio uio;
119 1.1 jonathan int error;
120 1.1 jonathan };
121 1.1 jonathan
122 1.1 jonathan struct fcrypt {
123 1.1 jonathan TAILQ_HEAD(csessionlist, csession) csessions;
124 1.36 tls TAILQ_HEAD(crprethead, cryptop) crp_ret_mq;
125 1.36 tls TAILQ_HEAD(krprethead, cryptkop) crp_ret_mkq;
126 1.1 jonathan int sesn;
127 1.36 tls struct selinfo sinfo;
128 1.36 tls u_int32_t requestid;
129 1.1 jonathan };
130 1.1 jonathan
131 1.29 tls /* For our fixed-size allocations */
132 1.38 rmind static struct pool fcrpl;
133 1.38 rmind static struct pool csepl;
134 1.1 jonathan
135 1.1 jonathan /* Declaration of master device (fd-cloning/ctxt-allocating) entrypoints */
136 1.16 christos static int cryptoopen(dev_t dev, int flag, int mode, struct lwp *l);
137 1.1 jonathan static int cryptoread(dev_t dev, struct uio *uio, int ioflag);
138 1.1 jonathan static int cryptowrite(dev_t dev, struct uio *uio, int ioflag);
139 1.16 christos static int cryptoselect(dev_t dev, int rw, struct lwp *l);
140 1.1 jonathan
141 1.1 jonathan /* Declaration of cloned-device (per-ctxt) entrypoints */
142 1.36 tls static int cryptof_read(struct file *, off_t *, struct uio *,
143 1.36 tls kauth_cred_t, int);
144 1.36 tls static int cryptof_write(struct file *, off_t *, struct uio *,
145 1.36 tls kauth_cred_t, int);
146 1.36 tls static int cryptof_ioctl(struct file *, u_long, void *);
147 1.36 tls static int cryptof_close(struct file *);
148 1.36 tls static int cryptof_poll(struct file *, int);
149 1.1 jonathan
150 1.12 christos static const struct fileops cryptofops = {
151 1.1 jonathan cryptof_read,
152 1.1 jonathan cryptof_write,
153 1.1 jonathan cryptof_ioctl,
154 1.12 christos fnullop_fcntl,
155 1.36 tls cryptof_poll,
156 1.12 christos fbadop_stat,
157 1.1 jonathan cryptof_close,
158 1.12 christos fnullop_kqfilter
159 1.1 jonathan };
160 1.1 jonathan
161 1.1 jonathan static struct csession *csefind(struct fcrypt *, u_int);
162 1.1 jonathan static int csedelete(struct fcrypt *, struct csession *);
163 1.1 jonathan static struct csession *cseadd(struct fcrypt *, struct csession *);
164 1.26 christos static struct csession *csecreate(struct fcrypt *, u_int64_t, void *, u_int64_t,
165 1.26 christos void *, u_int64_t, u_int32_t, u_int32_t, struct enc_xform *,
166 1.1 jonathan struct auth_hash *);
167 1.1 jonathan static int csefree(struct csession *);
168 1.1 jonathan
169 1.16 christos static int cryptodev_op(struct csession *, struct crypt_op *, struct lwp *);
170 1.36 tls static int cryptodev_mop(struct fcrypt *, struct crypt_n_op *, int, struct
171 1.36 tls lwp *);
172 1.1 jonathan static int cryptodev_key(struct crypt_kop *);
173 1.36 tls static int cryptodev_mkey(struct fcrypt *, struct crypt_n_kop *, int);
174 1.36 tls static int cryptodev_session(struct fcrypt *, struct session_op *);
175 1.36 tls static int cryptodev_msession(struct fcrypt *, struct session_n_op *,
176 1.36 tls int);
177 1.36 tls static int cryptodev_msessionfin(struct fcrypt *, int, u_int32_t *);
178 1.1 jonathan
179 1.1 jonathan static int cryptodev_cb(void *);
180 1.1 jonathan static int cryptodevkey_cb(void *);
181 1.1 jonathan
182 1.36 tls static int cryptodev_mcb(void *);
183 1.36 tls static int cryptodevkey_mcb(void *);
184 1.36 tls
185 1.36 tls static int cryptodev_getmstatus(struct fcrypt *, struct crypt_result *,
186 1.36 tls int);
187 1.36 tls static int cryptodev_getstatus(struct fcrypt *, struct crypt_result *);
188 1.36 tls
189 1.9 jonathan /*
190 1.9 jonathan * sysctl-able control variables for /dev/crypto now defined in crypto.c:
191 1.9 jonathan * crypto_usercrypto, crypto_userasmcrypto, crypto_devallowsoft.
192 1.9 jonathan */
193 1.1 jonathan
194 1.1 jonathan /* ARGSUSED */
195 1.1 jonathan int
196 1.35 ad cryptof_read(file_t *fp, off_t *poff,
197 1.25 christos struct uio *uio, kauth_cred_t cred, int flags)
198 1.1 jonathan {
199 1.1 jonathan return (EIO);
200 1.1 jonathan }
201 1.1 jonathan
202 1.1 jonathan /* ARGSUSED */
203 1.1 jonathan int
204 1.35 ad cryptof_write(file_t *fp, off_t *poff,
205 1.25 christos struct uio *uio, kauth_cred_t cred, int flags)
206 1.1 jonathan {
207 1.1 jonathan return (EIO);
208 1.1 jonathan }
209 1.1 jonathan
210 1.1 jonathan /* ARGSUSED */
211 1.1 jonathan int
212 1.36 tls cryptof_ioctl(struct file *fp, u_long cmd, void *data)
213 1.1 jonathan {
214 1.35 ad struct fcrypt *fcr = fp->f_data;
215 1.1 jonathan struct csession *cse;
216 1.1 jonathan struct session_op *sop;
217 1.36 tls struct session_n_op *snop;
218 1.1 jonathan struct crypt_op *cop;
219 1.36 tls struct crypt_mop *mop;
220 1.36 tls struct crypt_mkop *mkop;
221 1.36 tls struct crypt_n_op *cnop;
222 1.36 tls struct crypt_n_kop *knop;
223 1.36 tls struct crypt_sgop *sgop;
224 1.36 tls struct crypt_sfop *sfop;
225 1.36 tls struct cryptret *crypt_ret;
226 1.36 tls struct crypt_result *crypt_res;
227 1.1 jonathan u_int32_t ses;
228 1.36 tls u_int32_t *sesid;
229 1.1 jonathan int error = 0;
230 1.36 tls size_t count;
231 1.1 jonathan
232 1.29 tls /* backwards compatibility */
233 1.35 ad file_t *criofp;
234 1.29 tls struct fcrypt *criofcr;
235 1.29 tls int criofd;
236 1.29 tls
237 1.36 tls switch (cmd) {
238 1.29 tls case CRIOGET: /* XXX deprecated, remove after 5.0 */
239 1.36 tls if ((error = fd_allocfile(&criofp, &criofd)) != 0)
240 1.36 tls return error;
241 1.36 tls criofcr = pool_get(&fcrpl, PR_WAITOK);
242 1.36 tls if (criofcr == NULL) {
243 1.36 tls fd_abort(curproc, criofp, criofd);
244 1.36 tls return ENOMEM;
245 1.36 tls }
246 1.33 tls mutex_spin_enter(&crypto_mtx);
247 1.36 tls TAILQ_INIT(&criofcr->csessions);
248 1.36 tls TAILQ_INIT(&criofcr->crp_ret_mq);
249 1.36 tls TAILQ_INIT(&criofcr->crp_ret_mkq);
250 1.36 tls selinit(&criofcr->sinfo);
251 1.36 tls
252 1.29 tls /*
253 1.29 tls * Don't ever return session 0, to allow detection of
254 1.29 tls * failed creation attempts with multi-create ioctl.
255 1.29 tls */
256 1.36 tls criofcr->sesn = 1;
257 1.36 tls criofcr->requestid = 1;
258 1.33 tls mutex_spin_exit(&crypto_mtx);
259 1.36 tls (void)fd_clone(criofp, criofd, (FREAD|FWRITE),
260 1.29 tls &cryptofops, criofcr);
261 1.36 tls *(u_int32_t *)data = criofd;
262 1.29 tls return error;
263 1.36 tls break;
264 1.1 jonathan case CIOCGSESSION:
265 1.1 jonathan sop = (struct session_op *)data;
266 1.36 tls error = cryptodev_session(fcr, sop);
267 1.36 tls break;
268 1.36 tls case CIOCNGSESSION:
269 1.36 tls sgop = (struct crypt_sgop *)data;
270 1.36 tls snop = kmem_alloc((sgop->count *
271 1.36 tls sizeof(struct session_n_op)), KM_SLEEP);
272 1.36 tls if (!snop) {
273 1.36 tls error = EINVAL;
274 1.36 tls goto mbail;
275 1.1 jonathan }
276 1.36 tls error = copyin(sgop->sessions, snop, sgop->count *
277 1.36 tls sizeof(struct session_n_op));
278 1.36 tls if (error) {
279 1.36 tls goto mbail;
280 1.1 jonathan }
281 1.1 jonathan
282 1.36 tls error = cryptodev_msession(fcr, snop, sgop->count);
283 1.36 tls if (error) {
284 1.36 tls goto mbail;
285 1.1 jonathan }
286 1.1 jonathan
287 1.36 tls error = copyout(snop, sgop->sessions, sgop->count *
288 1.36 tls sizeof(struct session_n_op));
289 1.36 tls mbail:
290 1.36 tls if(snop) {
291 1.36 tls kmem_free(snop, sgop->count *
292 1.36 tls sizeof(struct session_n_op));
293 1.1 jonathan }
294 1.1 jonathan break;
295 1.1 jonathan case CIOCFSESSION:
296 1.33 tls mutex_spin_enter(&crypto_mtx);
297 1.1 jonathan ses = *(u_int32_t *)data;
298 1.1 jonathan cse = csefind(fcr, ses);
299 1.1 jonathan if (cse == NULL)
300 1.1 jonathan return (EINVAL);
301 1.1 jonathan csedelete(fcr, cse);
302 1.1 jonathan error = csefree(cse);
303 1.33 tls mutex_spin_exit(&crypto_mtx);
304 1.1 jonathan break;
305 1.36 tls case CIOCNFSESSION:
306 1.36 tls sfop = (struct crypt_sfop *)data;
307 1.36 tls sesid = kmem_alloc((sfop->count * sizeof(u_int32_t)),
308 1.36 tls KM_SLEEP);
309 1.36 tls if (!sesid)
310 1.36 tls return (EINVAL);
311 1.36 tls error = copyin(sfop->sesid, sesid,
312 1.36 tls (sfop->count * sizeof(u_int32_t)));
313 1.36 tls if (!error) {
314 1.36 tls error = cryptodev_msessionfin(fcr, sfop->count, sesid);
315 1.36 tls }
316 1.36 tls kmem_free(sesid, (sfop->count * sizeof(u_int32_t)));
317 1.36 tls break;
318 1.1 jonathan case CIOCCRYPT:
319 1.33 tls mutex_spin_enter(&crypto_mtx);
320 1.1 jonathan cop = (struct crypt_op *)data;
321 1.1 jonathan cse = csefind(fcr, cop->ses);
322 1.33 tls mutex_spin_exit(&crypto_mtx);
323 1.18 christos if (cse == NULL) {
324 1.18 christos DPRINTF(("csefind failed\n"));
325 1.1 jonathan return (EINVAL);
326 1.18 christos }
327 1.35 ad error = cryptodev_op(cse, cop, curlwp);
328 1.34 tls DPRINTF(("cryptodev_op error = %d\n", error));
329 1.1 jonathan break;
330 1.36 tls case CIOCNCRYPTM:
331 1.36 tls mop = (struct crypt_mop *)data;
332 1.36 tls cnop = kmem_alloc((mop->count * sizeof(struct crypt_n_op)),
333 1.36 tls KM_SLEEP);
334 1.36 tls if(!cnop) {
335 1.36 tls return(EINVAL);
336 1.36 tls }
337 1.36 tls error = copyin(mop->reqs, cnop,
338 1.36 tls (mop->count * sizeof(struct crypt_n_op)));
339 1.36 tls if(!error) {
340 1.36 tls error = cryptodev_mop(fcr, cnop, mop->count,
341 1.36 tls curlwp);
342 1.36 tls if (!error) {
343 1.36 tls error = copyout(cnop, mop->reqs,
344 1.36 tls (mop->count *
345 1.36 tls sizeof(struct crypt_n_op)));
346 1.36 tls }
347 1.36 tls }
348 1.36 tls kmem_free(cnop, (mop->count * sizeof(struct crypt_n_op)));
349 1.36 tls break;
350 1.1 jonathan case CIOCKEY:
351 1.1 jonathan error = cryptodev_key((struct crypt_kop *)data);
352 1.34 tls DPRINTF(("cryptodev_key error = %d\n", error));
353 1.1 jonathan break;
354 1.36 tls case CIOCNFKEYM:
355 1.36 tls mkop = (struct crypt_mkop *)data;
356 1.36 tls knop = kmem_alloc((mkop->count * sizeof(struct crypt_n_kop)),
357 1.36 tls KM_SLEEP);
358 1.36 tls if (!knop) {
359 1.36 tls return(EINVAL);
360 1.36 tls }
361 1.36 tls error = copyin(mkop->reqs, knop,
362 1.36 tls (mkop->count * sizeof(struct crypt_n_kop)));
363 1.36 tls if (!error) {
364 1.36 tls error = cryptodev_mkey(fcr, knop, mkop->count);
365 1.36 tls if (!error)
366 1.36 tls error = copyout(knop, mkop->reqs,
367 1.36 tls (mkop->count *
368 1.36 tls sizeof(struct crypt_n_kop)));
369 1.36 tls }
370 1.36 tls kmem_free(knop, (mkop->count * sizeof(struct crypt_n_kop)));
371 1.36 tls break;
372 1.1 jonathan case CIOCASYMFEAT:
373 1.1 jonathan error = crypto_getfeat((int *)data);
374 1.1 jonathan break;
375 1.36 tls case CIOCNCRYPTRETM:
376 1.36 tls crypt_ret = (struct cryptret *)data;
377 1.36 tls count = crypt_ret->count;
378 1.36 tls crypt_res = kmem_alloc((count *
379 1.36 tls sizeof(struct crypt_result)),
380 1.36 tls KM_SLEEP);
381 1.36 tls if(!crypt_res)
382 1.36 tls return(EINVAL);
383 1.36 tls error = copyin(crypt_ret->results, crypt_res,
384 1.36 tls (count * sizeof(struct crypt_result)));
385 1.36 tls if (error)
386 1.36 tls goto reterr;
387 1.36 tls crypt_ret->count = cryptodev_getmstatus(fcr, crypt_res,
388 1.36 tls crypt_ret->count);
389 1.36 tls /* sanity check count */
390 1.36 tls if (crypt_ret->count > count) {
391 1.37 dogcow printf("%s.%d: error returned count %zd > original "
392 1.37 dogcow " count %zd\n",
393 1.36 tls __FILE__, __LINE__, crypt_ret->count, count);
394 1.36 tls crypt_ret->count = count;
395 1.36 tls
396 1.36 tls }
397 1.36 tls error = copyout(crypt_res, crypt_ret->results,
398 1.36 tls (crypt_ret->count * sizeof(struct crypt_result)));
399 1.36 tls reterr:
400 1.36 tls kmem_free(crypt_res,
401 1.36 tls (count * sizeof(struct crypt_result)));
402 1.36 tls break;
403 1.36 tls case CIOCNCRYPTRET:
404 1.36 tls error = cryptodev_getstatus(fcr, (struct crypt_result *)data);
405 1.36 tls break;
406 1.1 jonathan default:
407 1.18 christos DPRINTF(("invalid ioctl cmd %ld\n", cmd));
408 1.1 jonathan error = EINVAL;
409 1.1 jonathan }
410 1.1 jonathan return (error);
411 1.1 jonathan }
412 1.1 jonathan
413 1.1 jonathan static int
414 1.25 christos cryptodev_op(struct csession *cse, struct crypt_op *cop, struct lwp *l)
415 1.1 jonathan {
416 1.1 jonathan struct cryptop *crp = NULL;
417 1.1 jonathan struct cryptodesc *crde = NULL, *crda = NULL;
418 1.33 tls int error;
419 1.1 jonathan
420 1.1 jonathan if (cop->len > 256*1024-4)
421 1.1 jonathan return (E2BIG);
422 1.1 jonathan
423 1.13 jonathan if (cse->txform) {
424 1.13 jonathan if (cop->len == 0 || (cop->len % cse->txform->blocksize) != 0)
425 1.13 jonathan return (EINVAL);
426 1.13 jonathan }
427 1.1 jonathan
428 1.1 jonathan bzero(&cse->uio, sizeof(cse->uio));
429 1.1 jonathan cse->uio.uio_iovcnt = 1;
430 1.1 jonathan cse->uio.uio_resid = 0;
431 1.1 jonathan cse->uio.uio_rw = UIO_WRITE;
432 1.1 jonathan cse->uio.uio_iov = cse->iovec;
433 1.17 yamt UIO_SETUP_SYSSPACE(&cse->uio);
434 1.29 tls memset(&cse->iovec, 0, sizeof(cse->iovec));
435 1.1 jonathan cse->uio.uio_iov[0].iov_len = cop->len;
436 1.36 tls cse->uio.uio_iov[0].iov_base = kmem_alloc(cop->len, KM_SLEEP);
437 1.29 tls cse->uio.uio_resid = cse->uio.uio_iov[0].iov_len;
438 1.1 jonathan
439 1.1 jonathan crp = crypto_getreq((cse->txform != NULL) + (cse->thash != NULL));
440 1.1 jonathan if (crp == NULL) {
441 1.1 jonathan error = ENOMEM;
442 1.1 jonathan goto bail;
443 1.1 jonathan }
444 1.1 jonathan
445 1.1 jonathan if (cse->thash) {
446 1.1 jonathan crda = crp->crp_desc;
447 1.1 jonathan if (cse->txform)
448 1.1 jonathan crde = crda->crd_next;
449 1.1 jonathan } else {
450 1.1 jonathan if (cse->txform)
451 1.1 jonathan crde = crp->crp_desc;
452 1.1 jonathan else {
453 1.1 jonathan error = EINVAL;
454 1.1 jonathan goto bail;
455 1.1 jonathan }
456 1.1 jonathan }
457 1.1 jonathan
458 1.1 jonathan if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, cop->len)))
459 1.36 tls {
460 1.36 tls printf("copyin failed %s %d \n", (char *)cop->src, error);
461 1.1 jonathan goto bail;
462 1.36 tls }
463 1.1 jonathan
464 1.1 jonathan if (crda) {
465 1.1 jonathan crda->crd_skip = 0;
466 1.1 jonathan crda->crd_len = cop->len;
467 1.1 jonathan crda->crd_inject = 0; /* ??? */
468 1.1 jonathan
469 1.1 jonathan crda->crd_alg = cse->mac;
470 1.1 jonathan crda->crd_key = cse->mackey;
471 1.1 jonathan crda->crd_klen = cse->mackeylen * 8;
472 1.1 jonathan }
473 1.1 jonathan
474 1.1 jonathan if (crde) {
475 1.1 jonathan if (cop->op == COP_ENCRYPT)
476 1.1 jonathan crde->crd_flags |= CRD_F_ENCRYPT;
477 1.1 jonathan else
478 1.1 jonathan crde->crd_flags &= ~CRD_F_ENCRYPT;
479 1.1 jonathan crde->crd_len = cop->len;
480 1.1 jonathan crde->crd_inject = 0;
481 1.1 jonathan
482 1.1 jonathan crde->crd_alg = cse->cipher;
483 1.1 jonathan crde->crd_key = cse->key;
484 1.1 jonathan crde->crd_klen = cse->keylen * 8;
485 1.1 jonathan }
486 1.1 jonathan
487 1.1 jonathan crp->crp_ilen = cop->len;
488 1.36 tls crp->crp_flags = CRYPTO_F_IOV | (cop->flags & COP_F_BATCH);
489 1.26 christos crp->crp_buf = (void *)&cse->uio;
490 1.1 jonathan crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_cb;
491 1.1 jonathan crp->crp_sid = cse->sid;
492 1.1 jonathan crp->crp_opaque = (void *)cse;
493 1.1 jonathan
494 1.1 jonathan if (cop->iv) {
495 1.1 jonathan if (crde == NULL) {
496 1.1 jonathan error = EINVAL;
497 1.1 jonathan goto bail;
498 1.1 jonathan }
499 1.1 jonathan if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
500 1.1 jonathan error = EINVAL;
501 1.1 jonathan goto bail;
502 1.1 jonathan }
503 1.36 tls if ((error = copyin(cop->iv, cse->tmp_iv,
504 1.36 tls cse->txform->blocksize)))
505 1.1 jonathan goto bail;
506 1.1 jonathan bcopy(cse->tmp_iv, crde->crd_iv, cse->txform->blocksize);
507 1.1 jonathan crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
508 1.1 jonathan crde->crd_skip = 0;
509 1.1 jonathan } else if (crde) {
510 1.20 christos if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
511 1.20 christos crde->crd_skip = 0;
512 1.20 christos } else {
513 1.20 christos crde->crd_flags |= CRD_F_IV_PRESENT;
514 1.20 christos crde->crd_skip = cse->txform->blocksize;
515 1.20 christos crde->crd_len -= cse->txform->blocksize;
516 1.20 christos }
517 1.1 jonathan }
518 1.1 jonathan
519 1.1 jonathan if (cop->mac) {
520 1.1 jonathan if (crda == NULL) {
521 1.1 jonathan error = EINVAL;
522 1.1 jonathan goto bail;
523 1.1 jonathan }
524 1.1 jonathan crp->crp_mac=cse->tmp_mac;
525 1.1 jonathan }
526 1.1 jonathan
527 1.33 tls /*
528 1.33 tls * XXX there was a comment here which said that we went to
529 1.33 tls * XXX splcrypto() but needed to only if CRYPTO_F_CBIMM,
530 1.33 tls * XXX disabled on NetBSD since 1.6O due to a race condition.
531 1.33 tls * XXX But crypto_dispatch went to splcrypto() itself! (And
532 1.33 tls * XXX now takes the crypto_mtx mutex itself). We do, however,
533 1.33 tls * XXX need to hold the mutex across the call to cv_wait().
534 1.33 tls * XXX (should we arrange for crypto_dispatch to return to
535 1.33 tls * XXX us with it held? it seems quite ugly to do so.)
536 1.33 tls */
537 1.36 tls #ifdef notyet
538 1.36 tls eagain:
539 1.36 tls #endif
540 1.1 jonathan error = crypto_dispatch(crp);
541 1.33 tls mutex_spin_enter(&crypto_mtx);
542 1.36 tls
543 1.36 tls switch (error) {
544 1.36 tls #ifdef notyet /* don't loop forever -- but EAGAIN not possible here yet */
545 1.36 tls case EAGAIN:
546 1.36 tls mutex_spin_exit(&crypto_mtx);
547 1.36 tls goto eagain;
548 1.36 tls break;
549 1.36 tls #endif
550 1.36 tls case 0:
551 1.36 tls break;
552 1.36 tls default:
553 1.33 tls DPRINTF(("cryptodev_op: not waiting, error.\n"));
554 1.33 tls mutex_spin_exit(&crypto_mtx);
555 1.1 jonathan goto bail;
556 1.1 jonathan }
557 1.36 tls
558 1.33 tls while (!(crp->crp_flags & CRYPTO_F_DONE)) {
559 1.33 tls DPRINTF(("cryptodev_op: sleeping on cv %08x for crp %08x\n", \
560 1.33 tls (uint32_t)&crp->crp_cv, (uint32_t)crp));
561 1.33 tls cv_wait(&crp->crp_cv, &crypto_mtx); /* XXX cv_wait_sig? */
562 1.33 tls }
563 1.33 tls if (crp->crp_flags & CRYPTO_F_ONRETQ) {
564 1.33 tls DPRINTF(("cryptodev_op: DONE, not woken by cryptoret.\n"));
565 1.33 tls (void)crypto_ret_q_remove(crp);
566 1.33 tls }
567 1.33 tls mutex_spin_exit(&crypto_mtx);
568 1.1 jonathan
569 1.1 jonathan if (crp->crp_etype != 0) {
570 1.34 tls DPRINTF(("cryptodev_op: crp_etype %d\n", crp->crp_etype));
571 1.1 jonathan error = crp->crp_etype;
572 1.1 jonathan goto bail;
573 1.1 jonathan }
574 1.1 jonathan
575 1.1 jonathan if (cse->error) {
576 1.34 tls DPRINTF(("cryptodev_op: cse->error %d\n", cse->error));
577 1.1 jonathan error = cse->error;
578 1.1 jonathan goto bail;
579 1.1 jonathan }
580 1.1 jonathan
581 1.1 jonathan if (cop->dst &&
582 1.36 tls (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, cop->len)))
583 1.36 tls {
584 1.34 tls DPRINTF(("cryptodev_op: copyout error %d\n", error));
585 1.1 jonathan goto bail;
586 1.34 tls }
587 1.1 jonathan
588 1.1 jonathan if (cop->mac &&
589 1.34 tls (error = copyout(crp->crp_mac, cop->mac, cse->thash->authsize))) {
590 1.34 tls DPRINTF(("cryptodev_op: mac copyout error %d\n", error));
591 1.1 jonathan goto bail;
592 1.34 tls }
593 1.1 jonathan
594 1.1 jonathan bail:
595 1.1 jonathan if (crp)
596 1.1 jonathan crypto_freereq(crp);
597 1.1 jonathan if (cse->uio.uio_iov[0].iov_base)
598 1.36 tls kmem_free(cse->uio.uio_iov[0].iov_base,
599 1.36 tls cse->uio.uio_iov[0].iov_len);
600 1.1 jonathan
601 1.1 jonathan return (error);
602 1.1 jonathan }
603 1.1 jonathan
604 1.1 jonathan static int
605 1.1 jonathan cryptodev_cb(void *op)
606 1.1 jonathan {
607 1.1 jonathan struct cryptop *crp = (struct cryptop *) op;
608 1.1 jonathan struct csession *cse = (struct csession *)crp->crp_opaque;
609 1.33 tls int error = 0;
610 1.1 jonathan
611 1.33 tls mutex_spin_enter(&crypto_mtx);
612 1.1 jonathan cse->error = crp->crp_etype;
613 1.33 tls if (crp->crp_etype == EAGAIN) {
614 1.33 tls /* always drop mutex to call dispatch routine */
615 1.33 tls mutex_spin_exit(&crypto_mtx);
616 1.33 tls error = crypto_dispatch(crp);
617 1.33 tls mutex_spin_enter(&crypto_mtx);
618 1.33 tls }
619 1.33 tls if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
620 1.33 tls cv_signal(&crp->crp_cv);
621 1.33 tls }
622 1.33 tls mutex_spin_exit(&crypto_mtx);
623 1.1 jonathan return (0);
624 1.1 jonathan }
625 1.1 jonathan
626 1.1 jonathan static int
627 1.36 tls cryptodev_mcb(void *op)
628 1.36 tls {
629 1.36 tls struct cryptop *crp = (struct cryptop *) op;
630 1.36 tls struct csession *cse = (struct csession *)crp->crp_opaque;
631 1.36 tls int error=0;
632 1.36 tls
633 1.36 tls mutex_spin_enter(&crypto_mtx);
634 1.36 tls cse->error = crp->crp_etype;
635 1.36 tls if (crp->crp_etype == EAGAIN) {
636 1.36 tls mutex_spin_exit(&crypto_mtx);
637 1.36 tls error = crypto_dispatch(crp);
638 1.36 tls mutex_spin_enter(&crypto_mtx);
639 1.36 tls }
640 1.36 tls if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
641 1.36 tls cv_signal(&crp->crp_cv);
642 1.36 tls }
643 1.36 tls
644 1.36 tls TAILQ_INSERT_TAIL(&crp->fcrp->crp_ret_mq, crp, crp_next);
645 1.38 rmind selnotify(&crp->fcrp->sinfo, 0, 0);
646 1.36 tls mutex_spin_exit(&crypto_mtx);
647 1.36 tls return (0);
648 1.36 tls }
649 1.36 tls
650 1.36 tls static int
651 1.1 jonathan cryptodevkey_cb(void *op)
652 1.1 jonathan {
653 1.1 jonathan struct cryptkop *krp = (struct cryptkop *) op;
654 1.36 tls
655 1.36 tls mutex_spin_enter(&crypto_mtx);
656 1.36 tls cv_signal(&krp->krp_cv);
657 1.36 tls mutex_spin_exit(&crypto_mtx);
658 1.36 tls return (0);
659 1.36 tls }
660 1.36 tls
661 1.36 tls static int
662 1.36 tls cryptodevkey_mcb(void *op)
663 1.36 tls {
664 1.36 tls struct cryptkop *krp = (struct cryptkop *) op;
665 1.1 jonathan
666 1.33 tls mutex_spin_enter(&crypto_mtx);
667 1.33 tls cv_signal(&krp->krp_cv);
668 1.36 tls TAILQ_INSERT_TAIL(&krp->fcrp->crp_ret_mkq, krp, krp_next);
669 1.38 rmind selnotify(&krp->fcrp->sinfo, 0, 0);
670 1.33 tls mutex_spin_exit(&crypto_mtx);
671 1.1 jonathan return (0);
672 1.1 jonathan }
673 1.1 jonathan
674 1.1 jonathan static int
675 1.1 jonathan cryptodev_key(struct crypt_kop *kop)
676 1.1 jonathan {
677 1.1 jonathan struct cryptkop *krp = NULL;
678 1.1 jonathan int error = EINVAL;
679 1.1 jonathan int in, out, size, i;
680 1.1 jonathan
681 1.1 jonathan if (kop->crk_iparams + kop->crk_oparams > CRK_MAXPARAM) {
682 1.1 jonathan return (EFBIG);
683 1.1 jonathan }
684 1.1 jonathan
685 1.1 jonathan in = kop->crk_iparams;
686 1.1 jonathan out = kop->crk_oparams;
687 1.1 jonathan switch (kop->crk_op) {
688 1.1 jonathan case CRK_MOD_EXP:
689 1.1 jonathan if (in == 3 && out == 1)
690 1.1 jonathan break;
691 1.1 jonathan return (EINVAL);
692 1.1 jonathan case CRK_MOD_EXP_CRT:
693 1.1 jonathan if (in == 6 && out == 1)
694 1.1 jonathan break;
695 1.1 jonathan return (EINVAL);
696 1.1 jonathan case CRK_DSA_SIGN:
697 1.1 jonathan if (in == 5 && out == 2)
698 1.1 jonathan break;
699 1.1 jonathan return (EINVAL);
700 1.1 jonathan case CRK_DSA_VERIFY:
701 1.1 jonathan if (in == 7 && out == 0)
702 1.1 jonathan break;
703 1.1 jonathan return (EINVAL);
704 1.1 jonathan case CRK_DH_COMPUTE_KEY:
705 1.1 jonathan if (in == 3 && out == 1)
706 1.1 jonathan break;
707 1.1 jonathan return (EINVAL);
708 1.27 tls case CRK_MOD_ADD:
709 1.27 tls if (in == 3 && out == 1)
710 1.27 tls break;
711 1.27 tls return (EINVAL);
712 1.27 tls case CRK_MOD_ADDINV:
713 1.27 tls if (in == 2 && out == 1)
714 1.27 tls break;
715 1.27 tls return (EINVAL);
716 1.27 tls case CRK_MOD_SUB:
717 1.27 tls if (in == 3 && out == 1)
718 1.27 tls break;
719 1.27 tls return (EINVAL);
720 1.27 tls case CRK_MOD_MULT:
721 1.27 tls if (in == 3 && out == 1)
722 1.27 tls break;
723 1.27 tls return (EINVAL);
724 1.27 tls case CRK_MOD_MULTINV:
725 1.27 tls if (in == 2 && out == 1)
726 1.27 tls break;
727 1.27 tls return (EINVAL);
728 1.27 tls case CRK_MOD:
729 1.27 tls if (in == 2 && out == 1)
730 1.27 tls break;
731 1.27 tls return (EINVAL);
732 1.1 jonathan default:
733 1.1 jonathan return (EINVAL);
734 1.1 jonathan }
735 1.1 jonathan
736 1.33 tls krp = pool_get(&cryptkop_pool, PR_WAITOK);
737 1.1 jonathan if (!krp)
738 1.1 jonathan return (ENOMEM);
739 1.1 jonathan bzero(krp, sizeof *krp);
740 1.33 tls cv_init(&krp->krp_cv, "crykdev");
741 1.1 jonathan krp->krp_op = kop->crk_op;
742 1.1 jonathan krp->krp_status = kop->crk_status;
743 1.1 jonathan krp->krp_iparams = kop->crk_iparams;
744 1.1 jonathan krp->krp_oparams = kop->crk_oparams;
745 1.1 jonathan krp->krp_status = 0;
746 1.1 jonathan krp->krp_callback = (int (*) (struct cryptkop *)) cryptodevkey_cb;
747 1.1 jonathan
748 1.1 jonathan for (i = 0; i < CRK_MAXPARAM; i++)
749 1.1 jonathan krp->krp_param[i].crp_nbits = kop->crk_param[i].crp_nbits;
750 1.1 jonathan for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
751 1.1 jonathan size = (krp->krp_param[i].crp_nbits + 7) / 8;
752 1.1 jonathan if (size == 0)
753 1.1 jonathan continue;
754 1.36 tls krp->krp_param[i].crp_p = kmem_alloc(size, KM_SLEEP);
755 1.1 jonathan if (i >= krp->krp_iparams)
756 1.1 jonathan continue;
757 1.1 jonathan error = copyin(kop->crk_param[i].crp_p, krp->krp_param[i].crp_p, size);
758 1.1 jonathan if (error)
759 1.1 jonathan goto fail;
760 1.1 jonathan }
761 1.1 jonathan
762 1.1 jonathan error = crypto_kdispatch(krp);
763 1.33 tls if (error != 0) {
764 1.1 jonathan goto fail;
765 1.33 tls }
766 1.33 tls
767 1.33 tls mutex_spin_enter(&crypto_mtx);
768 1.33 tls while (!(krp->krp_flags & CRYPTO_F_DONE)) {
769 1.33 tls cv_wait(&krp->krp_cv, &crypto_mtx); /* XXX cv_wait_sig? */
770 1.33 tls }
771 1.33 tls if (krp->krp_flags & CRYPTO_F_ONRETQ) {
772 1.33 tls DPRINTF(("cryptodev_key: DONE early, not via cryptoret.\n"));
773 1.33 tls (void)crypto_ret_kq_remove(krp);
774 1.33 tls }
775 1.33 tls mutex_spin_exit(&crypto_mtx);
776 1.1 jonathan
777 1.1 jonathan if (krp->krp_status != 0) {
778 1.34 tls DPRINTF(("cryptodev_key: krp->krp_status 0x%08x\n", krp->krp_status));
779 1.1 jonathan error = krp->krp_status;
780 1.1 jonathan goto fail;
781 1.1 jonathan }
782 1.1 jonathan
783 1.1 jonathan for (i = krp->krp_iparams; i < krp->krp_iparams + krp->krp_oparams; i++) {
784 1.1 jonathan size = (krp->krp_param[i].crp_nbits + 7) / 8;
785 1.1 jonathan if (size == 0)
786 1.1 jonathan continue;
787 1.1 jonathan error = copyout(krp->krp_param[i].crp_p, kop->crk_param[i].crp_p, size);
788 1.34 tls if (error) {
789 1.34 tls DPRINTF(("cryptodev_key: copyout oparam %d failed, error=%d\n", i-krp->krp_iparams, error));
790 1.1 jonathan goto fail;
791 1.34 tls }
792 1.1 jonathan }
793 1.1 jonathan
794 1.1 jonathan fail:
795 1.1 jonathan if (krp) {
796 1.1 jonathan kop->crk_status = krp->krp_status;
797 1.1 jonathan for (i = 0; i < CRK_MAXPARAM; i++) {
798 1.36 tls struct crparam *kp = &(krp->krp_param[i]);
799 1.36 tls if (krp->krp_param[i].crp_p) {
800 1.36 tls size = (kp->crp_nbits + 7) / 8;
801 1.36 tls KASSERT(size > 0);
802 1.36 tls memset(kp->crp_p, 0, size);
803 1.36 tls kmem_free(kp->crp_p, size);
804 1.36 tls }
805 1.1 jonathan }
806 1.33 tls pool_put(&cryptkop_pool, krp);
807 1.1 jonathan }
808 1.34 tls DPRINTF(("cryptodev_key: error=0x%08x\n", error));
809 1.1 jonathan return (error);
810 1.1 jonathan }
811 1.1 jonathan
812 1.1 jonathan /* ARGSUSED */
813 1.1 jonathan static int
814 1.36 tls cryptof_close(struct file *fp)
815 1.1 jonathan {
816 1.35 ad struct fcrypt *fcr = fp->f_data;
817 1.1 jonathan struct csession *cse;
818 1.1 jonathan
819 1.33 tls mutex_spin_enter(&crypto_mtx);
820 1.1 jonathan while ((cse = TAILQ_FIRST(&fcr->csessions))) {
821 1.1 jonathan TAILQ_REMOVE(&fcr->csessions, cse, next);
822 1.1 jonathan (void)csefree(cse);
823 1.1 jonathan }
824 1.36 tls seldestroy(&fcr->sinfo);
825 1.1 jonathan fp->f_data = NULL;
826 1.33 tls mutex_spin_exit(&crypto_mtx);
827 1.1 jonathan
828 1.38 rmind pool_put(&fcrpl, fcr);
829 1.1 jonathan return 0;
830 1.1 jonathan }
831 1.1 jonathan
832 1.33 tls /* csefind: call with crypto_mtx held. */
833 1.1 jonathan static struct csession *
834 1.1 jonathan csefind(struct fcrypt *fcr, u_int ses)
835 1.1 jonathan {
836 1.33 tls struct csession *cse, *ret = NULL;
837 1.1 jonathan
838 1.33 tls KASSERT(mutex_owned(&crypto_mtx));
839 1.1 jonathan TAILQ_FOREACH(cse, &fcr->csessions, next)
840 1.1 jonathan if (cse->ses == ses)
841 1.33 tls ret = cse;
842 1.36 tls
843 1.33 tls return (ret);
844 1.1 jonathan }
845 1.1 jonathan
846 1.33 tls /* csedelete: call with crypto_mtx held. */
847 1.1 jonathan static int
848 1.1 jonathan csedelete(struct fcrypt *fcr, struct csession *cse_del)
849 1.1 jonathan {
850 1.1 jonathan struct csession *cse;
851 1.33 tls int ret = 0;
852 1.1 jonathan
853 1.33 tls KASSERT(mutex_owned(&crypto_mtx));
854 1.1 jonathan TAILQ_FOREACH(cse, &fcr->csessions, next) {
855 1.1 jonathan if (cse == cse_del) {
856 1.1 jonathan TAILQ_REMOVE(&fcr->csessions, cse, next);
857 1.33 tls ret = 1;
858 1.1 jonathan }
859 1.1 jonathan }
860 1.33 tls return (ret);
861 1.1 jonathan }
862 1.1 jonathan
863 1.33 tls /* cseadd: call with crypto_mtx held. */
864 1.1 jonathan static struct csession *
865 1.1 jonathan cseadd(struct fcrypt *fcr, struct csession *cse)
866 1.1 jonathan {
867 1.33 tls KASSERT(mutex_owned(&crypto_mtx));
868 1.33 tls /* don't let session ID wrap! */
869 1.33 tls if (fcr->sesn + 1 == 0) return NULL;
870 1.1 jonathan TAILQ_INSERT_TAIL(&fcr->csessions, cse, next);
871 1.1 jonathan cse->ses = fcr->sesn++;
872 1.1 jonathan return (cse);
873 1.1 jonathan }
874 1.1 jonathan
875 1.33 tls /* csecreate: call with crypto_mtx held. */
876 1.1 jonathan static struct csession *
877 1.26 christos csecreate(struct fcrypt *fcr, u_int64_t sid, void *key, u_int64_t keylen,
878 1.26 christos void *mackey, u_int64_t mackeylen, u_int32_t cipher, u_int32_t mac,
879 1.1 jonathan struct enc_xform *txform, struct auth_hash *thash)
880 1.1 jonathan {
881 1.1 jonathan struct csession *cse;
882 1.1 jonathan
883 1.33 tls KASSERT(mutex_owned(&crypto_mtx));
884 1.29 tls cse = pool_get(&csepl, PR_NOWAIT);
885 1.1 jonathan if (cse == NULL)
886 1.1 jonathan return NULL;
887 1.1 jonathan cse->key = key;
888 1.1 jonathan cse->keylen = keylen/8;
889 1.1 jonathan cse->mackey = mackey;
890 1.1 jonathan cse->mackeylen = mackeylen/8;
891 1.1 jonathan cse->sid = sid;
892 1.1 jonathan cse->cipher = cipher;
893 1.1 jonathan cse->mac = mac;
894 1.1 jonathan cse->txform = txform;
895 1.1 jonathan cse->thash = thash;
896 1.34 tls cse->error = 0;
897 1.28 tls if (cseadd(fcr, cse))
898 1.28 tls return (cse);
899 1.28 tls else {
900 1.33 tls pool_put(&csepl, cse);
901 1.28 tls return NULL;
902 1.28 tls }
903 1.1 jonathan }
904 1.1 jonathan
905 1.33 tls /* csefree: call with crypto_mtx held. */
906 1.1 jonathan static int
907 1.1 jonathan csefree(struct csession *cse)
908 1.1 jonathan {
909 1.1 jonathan int error;
910 1.1 jonathan
911 1.33 tls KASSERT(mutex_owned(&crypto_mtx));
912 1.1 jonathan error = crypto_freesession(cse->sid);
913 1.1 jonathan if (cse->key)
914 1.36 tls free(cse->key, M_XDATA);
915 1.1 jonathan if (cse->mackey)
916 1.36 tls free(cse->mackey, M_XDATA);
917 1.29 tls pool_put(&csepl, cse);
918 1.1 jonathan return (error);
919 1.1 jonathan }
920 1.1 jonathan
921 1.1 jonathan static int
922 1.25 christos cryptoopen(dev_t dev, int flag, int mode,
923 1.25 christos struct lwp *l)
924 1.1 jonathan {
925 1.35 ad file_t *fp;
926 1.29 tls struct fcrypt *fcr;
927 1.29 tls int fd, error;
928 1.29 tls
929 1.1 jonathan if (crypto_usercrypto == 0)
930 1.1 jonathan return (ENXIO);
931 1.29 tls
932 1.35 ad if ((error = fd_allocfile(&fp, &fd)) != 0)
933 1.29 tls return error;
934 1.29 tls
935 1.29 tls fcr = pool_get(&fcrpl, PR_WAITOK);
936 1.36 tls if (fcr == NULL) {
937 1.36 tls fd_abort(curproc, fp, fd);
938 1.36 tls return ENOMEM;
939 1.36 tls }
940 1.33 tls mutex_spin_enter(&crypto_mtx);
941 1.29 tls TAILQ_INIT(&fcr->csessions);
942 1.36 tls TAILQ_INIT(&fcr->crp_ret_mq);
943 1.36 tls TAILQ_INIT(&fcr->crp_ret_mkq);
944 1.36 tls selinit(&fcr->sinfo);
945 1.29 tls /*
946 1.29 tls * Don't ever return session 0, to allow detection of
947 1.29 tls * failed creation attempts with multi-create ioctl.
948 1.29 tls */
949 1.29 tls fcr->sesn = 1;
950 1.36 tls fcr->requestid = 1;
951 1.33 tls mutex_spin_exit(&crypto_mtx);
952 1.35 ad return fd_clone(fp, fd, flag, &cryptofops, fcr);
953 1.1 jonathan }
954 1.1 jonathan
955 1.1 jonathan static int
956 1.25 christos cryptoread(dev_t dev, struct uio *uio, int ioflag)
957 1.1 jonathan {
958 1.1 jonathan return (EIO);
959 1.1 jonathan }
960 1.1 jonathan
961 1.1 jonathan static int
962 1.25 christos cryptowrite(dev_t dev, struct uio *uio, int ioflag)
963 1.1 jonathan {
964 1.1 jonathan return (EIO);
965 1.1 jonathan }
966 1.1 jonathan
967 1.1 jonathan int
968 1.25 christos cryptoselect(dev_t dev, int rw, struct lwp *l)
969 1.1 jonathan {
970 1.1 jonathan return (0);
971 1.1 jonathan }
972 1.1 jonathan
973 1.1 jonathan /*static*/
974 1.1 jonathan struct cdevsw crypto_cdevsw = {
975 1.1 jonathan /* open */ cryptoopen,
976 1.29 tls /* close */ noclose,
977 1.1 jonathan /* read */ cryptoread,
978 1.1 jonathan /* write */ cryptowrite,
979 1.29 tls /* ioctl */ noioctl,
980 1.1 jonathan /* ttstop?*/ nostop,
981 1.1 jonathan /* ??*/ notty,
982 1.1 jonathan /* poll */ cryptoselect /*nopoll*/,
983 1.1 jonathan /* mmap */ nommap,
984 1.1 jonathan /* kqfilter */ nokqfilter,
985 1.23 christos /* type */ D_OTHER,
986 1.1 jonathan };
987 1.1 jonathan
988 1.36 tls static int
989 1.36 tls cryptodev_mop(struct fcrypt *fcr,
990 1.36 tls struct crypt_n_op * cnop,
991 1.36 tls int count, struct lwp *l)
992 1.36 tls {
993 1.36 tls struct cryptop *crp = NULL;
994 1.36 tls struct cryptodesc *crde = NULL, *crda = NULL;
995 1.36 tls int req, error=0;
996 1.36 tls struct csession *cse;
997 1.36 tls
998 1.36 tls for (req = 0; req < count; req++) {
999 1.36 tls mutex_spin_enter(&crypto_mtx);
1000 1.36 tls cse = csefind(fcr, cnop[req].ses);
1001 1.36 tls if (cse == NULL) {
1002 1.36 tls DPRINTF(("csefind failed\n"));
1003 1.36 tls cnop[req].status = EINVAL;
1004 1.36 tls mutex_spin_exit(&crypto_mtx);
1005 1.36 tls continue;
1006 1.36 tls }
1007 1.36 tls mutex_spin_exit(&crypto_mtx);
1008 1.36 tls
1009 1.36 tls if (cnop[req].len > 256*1024-4) {
1010 1.36 tls DPRINTF(("length failed\n"));
1011 1.36 tls cnop[req].status = EINVAL;
1012 1.36 tls continue;
1013 1.36 tls }
1014 1.36 tls if (cse->txform) {
1015 1.36 tls if (cnop[req].len == 0 ||
1016 1.36 tls (cnop[req].len % cse->txform->blocksize) != 0) {
1017 1.36 tls cnop[req].status = EINVAL;
1018 1.36 tls continue;
1019 1.36 tls }
1020 1.36 tls }
1021 1.36 tls
1022 1.36 tls crp = crypto_getreq((cse->txform != NULL) + (cse->thash != NULL));
1023 1.36 tls if (crp == NULL) {
1024 1.36 tls cnop[req].status = ENOMEM;
1025 1.36 tls goto bail;
1026 1.36 tls }
1027 1.36 tls
1028 1.36 tls bzero(&crp->uio, sizeof(crp->uio));
1029 1.36 tls crp->uio.uio_iovcnt = 1;
1030 1.36 tls crp->uio.uio_resid = 0;
1031 1.36 tls crp->uio.uio_rw = UIO_WRITE;
1032 1.36 tls crp->uio.uio_iov = crp->iovec;
1033 1.36 tls UIO_SETUP_SYSSPACE(&crp->uio);
1034 1.36 tls memset(&crp->iovec, 0, sizeof(crp->iovec));
1035 1.36 tls crp->uio.uio_iov[0].iov_len = cnop[req].len;
1036 1.36 tls crp->uio.uio_iov[0].iov_base = kmem_alloc(cnop[req].len,
1037 1.36 tls KM_SLEEP);
1038 1.36 tls crp->uio.uio_resid = crp->uio.uio_iov[0].iov_len;
1039 1.36 tls
1040 1.36 tls if (cse->thash) {
1041 1.36 tls crda = crp->crp_desc;
1042 1.36 tls if (cse->txform)
1043 1.36 tls crde = crda->crd_next;
1044 1.36 tls } else {
1045 1.36 tls if (cse->txform)
1046 1.36 tls crde = crp->crp_desc;
1047 1.36 tls else {
1048 1.36 tls cnop[req].status = EINVAL;
1049 1.36 tls goto bail;
1050 1.36 tls }
1051 1.36 tls }
1052 1.36 tls
1053 1.36 tls if ((copyin(cnop[req].src,
1054 1.36 tls crp->uio.uio_iov[0].iov_base, cnop[req].len))) {
1055 1.36 tls cnop[req].status = EINVAL;
1056 1.36 tls goto bail;
1057 1.36 tls }
1058 1.36 tls
1059 1.36 tls if (crda) {
1060 1.36 tls crda->crd_skip = 0;
1061 1.36 tls crda->crd_len = cnop[req].len;
1062 1.36 tls crda->crd_inject = 0; /* ??? */
1063 1.36 tls
1064 1.36 tls crda->crd_alg = cse->mac;
1065 1.36 tls crda->crd_key = cse->mackey;
1066 1.36 tls crda->crd_klen = cse->mackeylen * 8;
1067 1.36 tls }
1068 1.36 tls
1069 1.36 tls if (crde) {
1070 1.36 tls if (cnop[req].op == COP_ENCRYPT)
1071 1.36 tls crde->crd_flags |= CRD_F_ENCRYPT;
1072 1.36 tls else
1073 1.36 tls crde->crd_flags &= ~CRD_F_ENCRYPT;
1074 1.36 tls crde->crd_len = cnop[req].len;
1075 1.36 tls crde->crd_inject = 0;
1076 1.36 tls
1077 1.36 tls crde->crd_alg = cse->cipher;
1078 1.36 tls #ifdef notyet /* XXX must notify h/w driver new key, drain */
1079 1.36 tls if(cnop[req].key && cnop[req].keylen) {
1080 1.36 tls crde->crd_key = malloc(cnop[req].keylen,
1081 1.36 tls M_XDATA, M_WAITOK);
1082 1.36 tls if((error = copyin(cnop[req].key,
1083 1.36 tls crde->crd_key, cnop[req].keylen))) {
1084 1.36 tls cnop[req].status = EINVAL;
1085 1.36 tls goto bail;
1086 1.36 tls }
1087 1.36 tls crde->crd_klen = cnop[req].keylen * 8;
1088 1.36 tls } else { ... }
1089 1.36 tls #endif
1090 1.36 tls crde->crd_key = cse->key;
1091 1.36 tls crde->crd_klen = cse->keylen * 8;
1092 1.36 tls }
1093 1.36 tls
1094 1.36 tls crp->crp_ilen = cnop[req].len;
1095 1.36 tls crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM
1096 1.36 tls | (cnop[req].flags & COP_F_BATCH);
1097 1.36 tls crp->crp_buf = (void *)&crp->uio;
1098 1.36 tls crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_mcb;
1099 1.36 tls crp->crp_sid = cse->sid;
1100 1.36 tls crp->crp_opaque = (void *)cse;
1101 1.36 tls crp->fcrp = fcr;
1102 1.36 tls crp->dst = cnop[req].dst;
1103 1.36 tls /* we can use the crp_ilen in cryptop(crp) for this */
1104 1.36 tls crp->len = cnop[req].len;
1105 1.36 tls crp->mac = cnop[req].mac;
1106 1.36 tls
1107 1.36 tls if (cnop[req].iv) {
1108 1.36 tls if (crde == NULL) {
1109 1.36 tls cnop[req].status = EINVAL;
1110 1.36 tls goto bail;
1111 1.36 tls }
1112 1.36 tls if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
1113 1.36 tls cnop[req].status = EINVAL;
1114 1.36 tls goto bail;
1115 1.36 tls }
1116 1.36 tls if ((error = copyin(cnop[req].iv, crp->tmp_iv,
1117 1.36 tls cse->txform->blocksize))) {
1118 1.36 tls cnop[req].status = EINVAL;
1119 1.36 tls goto bail;
1120 1.36 tls }
1121 1.36 tls bcopy(crp->tmp_iv, crde->crd_iv, cse->txform->blocksize);
1122 1.36 tls crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
1123 1.36 tls crde->crd_skip = 0;
1124 1.36 tls } else if (crde) {
1125 1.36 tls if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
1126 1.36 tls crde->crd_skip = 0;
1127 1.36 tls } else {
1128 1.36 tls crde->crd_flags |= CRD_F_IV_PRESENT;
1129 1.36 tls crde->crd_skip = cse->txform->blocksize;
1130 1.36 tls crde->crd_len -= cse->txform->blocksize;
1131 1.36 tls }
1132 1.36 tls }
1133 1.36 tls
1134 1.36 tls if (cnop[req].mac) {
1135 1.36 tls if (crda == NULL) {
1136 1.36 tls cnop[req].status = EINVAL;
1137 1.36 tls goto bail;
1138 1.36 tls }
1139 1.36 tls crp->crp_mac=cse->tmp_mac;
1140 1.36 tls }
1141 1.36 tls cnop[req].reqid = atomic_inc_32_nv(&(fcr->requestid));
1142 1.36 tls crp->crp_reqid = cnop[req].reqid;
1143 1.36 tls crp->crp_usropaque = cnop[req].opaque;
1144 1.36 tls #ifdef notyet
1145 1.36 tls eagain:
1146 1.36 tls #endif
1147 1.36 tls cnop[req].status = crypto_dispatch(crp);
1148 1.36 tls mutex_spin_enter(&crypto_mtx); /* XXX why mutex? */
1149 1.36 tls
1150 1.36 tls switch (cnop[req].status) {
1151 1.36 tls #ifdef notyet /* don't loop forever -- but EAGAIN not possible here yet */
1152 1.36 tls case EAGAIN:
1153 1.36 tls mutex_spin_exit(&crypto_mtx);
1154 1.36 tls goto eagain;
1155 1.36 tls break;
1156 1.36 tls #endif
1157 1.36 tls case 0:
1158 1.36 tls break;
1159 1.36 tls default:
1160 1.36 tls DPRINTF(("cryptodev_op: not waiting, error.\n"));
1161 1.36 tls mutex_spin_exit(&crypto_mtx);
1162 1.36 tls goto bail;
1163 1.36 tls }
1164 1.36 tls
1165 1.36 tls mutex_spin_exit(&crypto_mtx);
1166 1.36 tls bail:
1167 1.36 tls if (cnop[req].status) {
1168 1.36 tls if (crp) {
1169 1.36 tls crypto_freereq(crp);
1170 1.36 tls if(cse->uio.uio_iov[0].iov_base) {
1171 1.36 tls kmem_free(cse->uio.uio_iov[0].iov_base,
1172 1.36 tls cse->uio.uio_iov[0].iov_len);
1173 1.36 tls }
1174 1.36 tls }
1175 1.36 tls error = 0;
1176 1.36 tls }
1177 1.36 tls }
1178 1.36 tls return (error);
1179 1.36 tls }
1180 1.36 tls
1181 1.36 tls static int
1182 1.36 tls cryptodev_mkey(struct fcrypt *fcr, struct crypt_n_kop *kop, int count)
1183 1.36 tls {
1184 1.36 tls struct cryptkop *krp = NULL;
1185 1.36 tls int error = EINVAL;
1186 1.36 tls int in, out, size, i, req;
1187 1.36 tls
1188 1.36 tls for (req = 0; req < count; req++) {
1189 1.36 tls if (kop[req].crk_iparams + kop[req].crk_oparams > CRK_MAXPARAM) {
1190 1.36 tls return (EFBIG);
1191 1.36 tls }
1192 1.36 tls
1193 1.36 tls in = kop[req].crk_iparams;
1194 1.36 tls out = kop[req].crk_oparams;
1195 1.36 tls switch (kop[req].crk_op) {
1196 1.36 tls case CRK_MOD_EXP:
1197 1.36 tls if (in == 3 && out == 1)
1198 1.36 tls break;
1199 1.36 tls kop[req].crk_status = EINVAL;
1200 1.36 tls continue;
1201 1.36 tls case CRK_MOD_EXP_CRT:
1202 1.36 tls if (in == 6 && out == 1)
1203 1.36 tls break;
1204 1.36 tls kop[req].crk_status = EINVAL;
1205 1.36 tls continue;
1206 1.36 tls case CRK_DSA_SIGN:
1207 1.36 tls if (in == 5 && out == 2)
1208 1.36 tls break;
1209 1.36 tls kop[req].crk_status = EINVAL;
1210 1.36 tls continue;
1211 1.36 tls case CRK_DSA_VERIFY:
1212 1.36 tls if (in == 7 && out == 0)
1213 1.36 tls break;
1214 1.36 tls kop[req].crk_status = EINVAL;
1215 1.36 tls continue;
1216 1.36 tls case CRK_DH_COMPUTE_KEY:
1217 1.36 tls if (in == 3 && out == 1)
1218 1.36 tls break;
1219 1.36 tls kop[req].crk_status = EINVAL;
1220 1.36 tls continue;
1221 1.36 tls case CRK_MOD_ADD:
1222 1.36 tls if (in == 3 && out == 1)
1223 1.36 tls break;
1224 1.36 tls kop[req].crk_status = EINVAL;
1225 1.36 tls continue;
1226 1.36 tls case CRK_MOD_ADDINV:
1227 1.36 tls if (in == 2 && out == 1)
1228 1.36 tls break;
1229 1.36 tls kop[req].crk_status = EINVAL;
1230 1.36 tls continue;
1231 1.36 tls case CRK_MOD_SUB:
1232 1.36 tls if (in == 3 && out == 1)
1233 1.36 tls break;
1234 1.36 tls kop[req].crk_status = EINVAL;
1235 1.36 tls continue;
1236 1.36 tls case CRK_MOD_MULT:
1237 1.36 tls if (in == 3 && out == 1)
1238 1.36 tls break;
1239 1.36 tls kop[req].crk_status = EINVAL;
1240 1.36 tls continue;
1241 1.36 tls case CRK_MOD_MULTINV:
1242 1.36 tls if (in == 2 && out == 1)
1243 1.36 tls break;
1244 1.36 tls kop[req].crk_status = EINVAL;
1245 1.36 tls continue;
1246 1.36 tls case CRK_MOD:
1247 1.36 tls if (in == 2 && out == 1)
1248 1.36 tls break;
1249 1.36 tls kop[req].crk_status = EINVAL;
1250 1.36 tls continue;
1251 1.36 tls default:
1252 1.36 tls kop[req].crk_status = EINVAL;
1253 1.36 tls continue;
1254 1.36 tls }
1255 1.36 tls
1256 1.36 tls krp = pool_get(&cryptkop_pool, PR_WAITOK);
1257 1.36 tls if (!krp) {
1258 1.36 tls kop[req].crk_status = ENOMEM;
1259 1.36 tls goto fail;
1260 1.36 tls }
1261 1.36 tls bzero(krp, sizeof *krp);
1262 1.36 tls cv_init(&krp->krp_cv, "crykdev");
1263 1.36 tls krp->krp_op = kop[req].crk_op;
1264 1.36 tls krp->krp_status = kop[req].crk_status;
1265 1.36 tls krp->krp_iparams = kop[req].crk_iparams;
1266 1.36 tls krp->krp_oparams = kop[req].crk_oparams;
1267 1.36 tls krp->krp_status = 0;
1268 1.36 tls krp->krp_callback =
1269 1.36 tls (int (*) (struct cryptkop *)) cryptodevkey_mcb;
1270 1.36 tls bcopy(kop[req].crk_param,
1271 1.36 tls krp->crk_param,
1272 1.36 tls sizeof(kop[req].crk_param));
1273 1.36 tls
1274 1.36 tls krp->krp_flags = CRYPTO_F_CBIMM;
1275 1.36 tls
1276 1.36 tls for (i = 0; i < CRK_MAXPARAM; i++)
1277 1.36 tls krp->krp_param[i].crp_nbits =
1278 1.36 tls kop[req].crk_param[i].crp_nbits;
1279 1.36 tls for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
1280 1.36 tls size = (krp->krp_param[i].crp_nbits + 7) / 8;
1281 1.36 tls if (size == 0)
1282 1.36 tls continue;
1283 1.36 tls krp->krp_param[i].crp_p =
1284 1.36 tls kmem_alloc(size, KM_SLEEP);
1285 1.36 tls if (i >= krp->krp_iparams)
1286 1.36 tls continue;
1287 1.36 tls kop[req].crk_status = copyin(kop[req].crk_param[i].crp_p,
1288 1.36 tls krp->krp_param[i].crp_p, size);
1289 1.36 tls if (kop[req].crk_status)
1290 1.36 tls goto fail;
1291 1.36 tls }
1292 1.36 tls krp->fcrp = fcr;
1293 1.36 tls
1294 1.36 tls kop[req].crk_reqid = atomic_inc_32_nv(&(fcr->requestid));
1295 1.36 tls krp->krp_reqid = kop[req].crk_reqid;
1296 1.36 tls krp->krp_usropaque = kop[req].crk_opaque;
1297 1.36 tls
1298 1.36 tls kop[req].crk_status = crypto_kdispatch(krp);
1299 1.36 tls if (kop[req].crk_status != 0) {
1300 1.36 tls goto fail;
1301 1.36 tls }
1302 1.36 tls
1303 1.36 tls fail:
1304 1.36 tls if(kop[req].crk_status) {
1305 1.36 tls if (krp) {
1306 1.36 tls kop[req].crk_status = krp->krp_status;
1307 1.36 tls for (i = 0; i < CRK_MAXPARAM; i++) {
1308 1.36 tls struct crparam *kp =
1309 1.36 tls &(krp->krp_param[i]);
1310 1.36 tls if (kp->crp_p) {
1311 1.36 tls size = (kp->crp_nbits + 7) / 8;
1312 1.36 tls KASSERT(size > 0);
1313 1.36 tls memset(kp->crp_p, 0, size);
1314 1.36 tls kmem_free(kp->crp_p, size);
1315 1.36 tls }
1316 1.36 tls }
1317 1.36 tls pool_put(&cryptkop_pool, krp);
1318 1.36 tls }
1319 1.36 tls }
1320 1.36 tls error = 0;
1321 1.36 tls }
1322 1.36 tls DPRINTF(("cryptodev_key: error=0x%08x\n", error));
1323 1.36 tls return (error);
1324 1.36 tls }
1325 1.36 tls
1326 1.36 tls static int
1327 1.36 tls cryptodev_session(struct fcrypt *fcr, struct session_op *sop) {
1328 1.36 tls struct cryptoini cria, crie;
1329 1.36 tls struct enc_xform *txform = NULL;
1330 1.36 tls struct auth_hash *thash = NULL;
1331 1.36 tls struct csession *cse;
1332 1.36 tls u_int64_t sid;
1333 1.36 tls int error = 0;
1334 1.36 tls
1335 1.36 tls /* XXX there must be a way to not embed the list of xforms here */
1336 1.36 tls switch (sop->cipher) {
1337 1.36 tls case 0:
1338 1.36 tls break;
1339 1.36 tls case CRYPTO_DES_CBC:
1340 1.36 tls txform = &enc_xform_des;
1341 1.36 tls break;
1342 1.36 tls case CRYPTO_3DES_CBC:
1343 1.36 tls txform = &enc_xform_3des;
1344 1.36 tls break;
1345 1.36 tls case CRYPTO_BLF_CBC:
1346 1.36 tls txform = &enc_xform_blf;
1347 1.36 tls break;
1348 1.36 tls case CRYPTO_CAST_CBC:
1349 1.36 tls txform = &enc_xform_cast5;
1350 1.36 tls case CRYPTO_SKIPJACK_CBC:
1351 1.36 tls txform = &enc_xform_skipjack;
1352 1.36 tls break;
1353 1.36 tls case CRYPTO_AES_CBC:
1354 1.36 tls txform = &enc_xform_rijndael128;
1355 1.36 tls break;
1356 1.36 tls case CRYPTO_NULL_CBC:
1357 1.36 tls txform = &enc_xform_null;
1358 1.36 tls break;
1359 1.36 tls case CRYPTO_ARC4:
1360 1.36 tls txform = &enc_xform_arc4;
1361 1.36 tls break;
1362 1.36 tls default:
1363 1.36 tls DPRINTF(("Invalid cipher %d\n", sop->cipher));
1364 1.36 tls return EINVAL;
1365 1.36 tls }
1366 1.36 tls
1367 1.36 tls switch (sop->mac) {
1368 1.36 tls case 0:
1369 1.36 tls break;
1370 1.36 tls case CRYPTO_MD5_HMAC:
1371 1.36 tls thash = &auth_hash_hmac_md5;
1372 1.36 tls break;
1373 1.36 tls case CRYPTO_SHA1_HMAC:
1374 1.36 tls thash = &auth_hash_hmac_sha1;
1375 1.36 tls break;
1376 1.36 tls case CRYPTO_MD5_HMAC_96:
1377 1.36 tls thash = &auth_hash_hmac_md5_96;
1378 1.36 tls break;
1379 1.36 tls case CRYPTO_SHA1_HMAC_96:
1380 1.36 tls thash = &auth_hash_hmac_sha1_96;
1381 1.36 tls break;
1382 1.36 tls case CRYPTO_SHA2_HMAC:
1383 1.36 tls /* XXX switching on key length seems questionable */
1384 1.36 tls if (sop->mackeylen == auth_hash_hmac_sha2_256.keysize) {
1385 1.36 tls thash = &auth_hash_hmac_sha2_256;
1386 1.36 tls } else if (sop->mackeylen == auth_hash_hmac_sha2_384.keysize) {
1387 1.36 tls thash = &auth_hash_hmac_sha2_384;
1388 1.36 tls } else if (sop->mackeylen == auth_hash_hmac_sha2_512.keysize) {
1389 1.36 tls thash = &auth_hash_hmac_sha2_512;
1390 1.36 tls } else {
1391 1.36 tls DPRINTF(("Invalid mackeylen %d\n", sop->mackeylen));
1392 1.36 tls return EINVAL;
1393 1.36 tls }
1394 1.36 tls break;
1395 1.36 tls case CRYPTO_RIPEMD160_HMAC:
1396 1.36 tls thash = &auth_hash_hmac_ripemd_160;
1397 1.36 tls break;
1398 1.36 tls case CRYPTO_RIPEMD160_HMAC_96:
1399 1.36 tls thash = &auth_hash_hmac_ripemd_160_96;
1400 1.36 tls break;
1401 1.36 tls case CRYPTO_MD5:
1402 1.36 tls thash = &auth_hash_md5;
1403 1.36 tls break;
1404 1.36 tls case CRYPTO_SHA1:
1405 1.36 tls thash = &auth_hash_sha1;
1406 1.36 tls break;
1407 1.36 tls case CRYPTO_NULL_HMAC:
1408 1.36 tls thash = &auth_hash_null;
1409 1.36 tls break;
1410 1.36 tls default:
1411 1.36 tls DPRINTF(("Invalid mac %d\n", sop->mac));
1412 1.36 tls return (EINVAL);
1413 1.36 tls }
1414 1.36 tls
1415 1.36 tls memset(&crie, 0, sizeof(crie));
1416 1.36 tls memset(&cria, 0, sizeof(cria));
1417 1.36 tls
1418 1.36 tls if (txform) {
1419 1.36 tls crie.cri_alg = txform->type;
1420 1.36 tls crie.cri_klen = sop->keylen * 8;
1421 1.36 tls if (sop->keylen > txform->maxkey ||
1422 1.36 tls sop->keylen < txform->minkey) {
1423 1.36 tls DPRINTF(("keylen %d not in [%d,%d]\n",
1424 1.36 tls sop->keylen, txform->minkey,
1425 1.36 tls txform->maxkey));
1426 1.36 tls error = EINVAL ;
1427 1.36 tls goto bail;
1428 1.36 tls }
1429 1.36 tls
1430 1.36 tls crie.cri_key = malloc(crie.cri_klen / 8, M_XDATA, M_WAITOK);
1431 1.36 tls if ((error = copyin(sop->key, crie.cri_key,
1432 1.36 tls crie.cri_klen / 8))) {
1433 1.36 tls goto bail;
1434 1.36 tls }
1435 1.36 tls if (thash) {
1436 1.36 tls crie.cri_next = &cria; /* XXX forces enc then hash? */
1437 1.36 tls }
1438 1.36 tls }
1439 1.36 tls
1440 1.36 tls if (thash) {
1441 1.36 tls cria.cri_alg = thash->type;
1442 1.36 tls cria.cri_klen = sop->mackeylen * 8;
1443 1.36 tls if (sop->mackeylen != thash->keysize) {
1444 1.36 tls DPRINTF(("mackeylen %d != keysize %d\n",
1445 1.36 tls sop->mackeylen, thash->keysize));
1446 1.36 tls error = EINVAL;
1447 1.36 tls goto bail;
1448 1.36 tls }
1449 1.36 tls if (cria.cri_klen) {
1450 1.36 tls cria.cri_key = malloc(cria.cri_klen / 8, M_XDATA,
1451 1.36 tls M_WAITOK);
1452 1.36 tls if ((error = copyin(sop->mackey, cria.cri_key,
1453 1.36 tls cria.cri_klen / 8))) {
1454 1.36 tls goto bail;
1455 1.36 tls }
1456 1.36 tls }
1457 1.36 tls }
1458 1.36 tls /* crypto_newsession requires that we hold the mutex. */
1459 1.36 tls mutex_spin_enter(&crypto_mtx);
1460 1.36 tls error = crypto_newsession(&sid, (txform ? &crie : &cria),
1461 1.36 tls crypto_devallowsoft);
1462 1.36 tls if (!error) {
1463 1.36 tls cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen,
1464 1.36 tls cria.cri_key, cria.cri_klen, sop->cipher,
1465 1.36 tls sop->mac, txform, thash);
1466 1.36 tls if (cse != NULL) {
1467 1.36 tls sop->ses = cse->ses;
1468 1.36 tls } else {
1469 1.36 tls DPRINTF(("csecreate failed\n"));
1470 1.36 tls crypto_freesession(sid);
1471 1.36 tls error = EINVAL;
1472 1.36 tls }
1473 1.36 tls } else {
1474 1.36 tls DPRINTF(("SIOCSESSION violates kernel parameters %d\n",
1475 1.36 tls error));
1476 1.36 tls }
1477 1.36 tls mutex_spin_exit(&crypto_mtx);
1478 1.36 tls bail:
1479 1.36 tls if (error) {
1480 1.36 tls if (crie.cri_key) {
1481 1.36 tls memset(crie.cri_key, 0, crie.cri_klen / 8);
1482 1.36 tls free(crie.cri_key, M_XDATA);
1483 1.36 tls }
1484 1.36 tls if (cria.cri_key) {
1485 1.36 tls memset(cria.cri_key, 0, cria.cri_klen / 8);
1486 1.36 tls free(cria.cri_key, M_XDATA);
1487 1.36 tls }
1488 1.36 tls }
1489 1.36 tls return error;
1490 1.36 tls }
1491 1.36 tls
1492 1.36 tls static int
1493 1.36 tls cryptodev_msession(struct fcrypt *fcr, struct session_n_op *sn_ops,
1494 1.36 tls int count)
1495 1.36 tls {
1496 1.36 tls int i;
1497 1.36 tls
1498 1.36 tls for (i = 0; i < count; i++, sn_ops++) {
1499 1.36 tls struct session_op s_op;
1500 1.36 tls s_op.cipher = sn_ops->cipher;
1501 1.36 tls s_op.mac = sn_ops->mac;
1502 1.36 tls s_op.keylen = sn_ops->keylen;
1503 1.36 tls s_op.key = sn_ops->key;
1504 1.36 tls s_op.mackeylen = sn_ops->mackeylen;
1505 1.36 tls s_op.mackey = sn_ops->mackey;
1506 1.36 tls
1507 1.36 tls sn_ops->status = cryptodev_session(fcr, &s_op);
1508 1.36 tls sn_ops->ses = s_op.ses;
1509 1.36 tls }
1510 1.36 tls
1511 1.36 tls return 0;
1512 1.36 tls }
1513 1.36 tls
1514 1.36 tls static int
1515 1.36 tls cryptodev_msessionfin(struct fcrypt *fcr, int count, u_int32_t *sesid)
1516 1.36 tls {
1517 1.36 tls struct csession *cse;
1518 1.36 tls int req, error = 0;
1519 1.36 tls
1520 1.36 tls mutex_spin_enter(&crypto_mtx);
1521 1.36 tls for(req = 0; req < count; req++) {
1522 1.36 tls cse = csefind(fcr, sesid[req]);
1523 1.36 tls if (cse == NULL)
1524 1.36 tls continue;
1525 1.36 tls csedelete(fcr, cse);
1526 1.36 tls error = csefree(cse);
1527 1.36 tls }
1528 1.36 tls mutex_spin_exit(&crypto_mtx);
1529 1.36 tls return 0;
1530 1.36 tls }
1531 1.36 tls
1532 1.36 tls /*
1533 1.36 tls * collect as many completed requests as are availble, or count completed requests
1534 1.36 tls * whichever is less.
1535 1.36 tls * return the number of requests.
1536 1.36 tls */
1537 1.36 tls static int
1538 1.36 tls cryptodev_getmstatus(struct fcrypt *fcr, struct crypt_result *crypt_res,
1539 1.36 tls int count)
1540 1.36 tls {
1541 1.36 tls struct cryptop *crp = NULL;
1542 1.36 tls struct cryptkop *krp = NULL;
1543 1.36 tls struct csession *cse;
1544 1.36 tls int i, size, req = 0;
1545 1.36 tls int completed=0;
1546 1.36 tls
1547 1.36 tls /* On stack so nobody else can grab them -- no locking */
1548 1.36 tls SLIST_HEAD(, cryptop) crp_delfree_l =
1549 1.36 tls SLIST_HEAD_INITIALIZER(crp_delfree_l);
1550 1.36 tls SLIST_HEAD(, cryptkop) krp_delfree_l =
1551 1.36 tls SLIST_HEAD_INITIALIZER(krp_delfree_l);
1552 1.36 tls
1553 1.36 tls mutex_spin_enter(&crypto_mtx);
1554 1.36 tls
1555 1.36 tls /* at this point we do not know which response user is requesting for
1556 1.36 tls * (symmetric or asymmetric) so we copyout one from each i.e if the
1557 1.36 tls * count is 2 then 1 from symmetric and 1 from asymmetric queue and
1558 1.36 tls * if 3 then 2 symmetric and 1 asymmetric and so on */
1559 1.36 tls for(; req < count ;) {
1560 1.36 tls crp = TAILQ_FIRST(&fcr->crp_ret_mq);
1561 1.36 tls if(crp) {
1562 1.36 tls cse = (struct csession *)crp->crp_opaque;
1563 1.36 tls crypt_res[req].reqid = crp->crp_reqid;
1564 1.36 tls crypt_res[req].opaque = crp->crp_usropaque;
1565 1.36 tls completed++;
1566 1.36 tls cse = csefind(fcr, cse->ses);
1567 1.36 tls if (cse == NULL) {
1568 1.36 tls DPRINTF(("csefind failed\n"));
1569 1.36 tls crypt_res[req].status = EINVAL;
1570 1.36 tls goto bail;
1571 1.36 tls }
1572 1.36 tls
1573 1.36 tls if (crp->crp_etype != 0) {
1574 1.36 tls crypt_res[req].status = crp->crp_etype;
1575 1.36 tls goto bail;
1576 1.36 tls }
1577 1.36 tls
1578 1.36 tls if (cse->error) {
1579 1.36 tls crypt_res[req].status = cse->error;
1580 1.36 tls goto bail;
1581 1.36 tls }
1582 1.36 tls
1583 1.36 tls if (crp->dst &&
1584 1.36 tls (crypt_res[req].status = copyout
1585 1.36 tls (crp->uio.uio_iov[0].iov_base,
1586 1.36 tls crp->dst, crp->len)))
1587 1.36 tls goto bail;
1588 1.36 tls
1589 1.36 tls if (crp->mac &&
1590 1.36 tls (crypt_res[req].status = copyout
1591 1.36 tls (crp->crp_mac, crp->mac,
1592 1.36 tls cse->thash->authsize)))
1593 1.36 tls goto bail;
1594 1.36 tls bail:
1595 1.36 tls TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
1596 1.36 tls SLIST_INSERT_HEAD(&crp_delfree_l, crp,
1597 1.36 tls crp_qun.crp_lnext);
1598 1.36 tls req++;
1599 1.36 tls }
1600 1.36 tls
1601 1.36 tls if(req < count) {
1602 1.36 tls krp = TAILQ_FIRST(&fcr->crp_ret_mkq);
1603 1.36 tls if (krp) {
1604 1.36 tls crypt_res[req].reqid = krp->krp_reqid;
1605 1.36 tls crypt_res[req].opaque = krp->krp_usropaque;
1606 1.36 tls completed++;
1607 1.36 tls if (krp->krp_status != 0) {
1608 1.36 tls DPRINTF(("cryptodev_key: "
1609 1.36 tls "krp->krp_status"
1610 1.36 tls "0x%08x\n", krp->krp_status));
1611 1.36 tls crypt_res[req].status =
1612 1.36 tls krp->krp_status;
1613 1.36 tls goto fail;
1614 1.36 tls }
1615 1.36 tls
1616 1.36 tls for (i = krp->krp_iparams; i < krp->krp_iparams
1617 1.36 tls + krp->krp_oparams; i++) {
1618 1.36 tls size = (krp->krp_param[i].crp_nbits
1619 1.36 tls + 7) / 8;
1620 1.36 tls if (size == 0)
1621 1.36 tls continue;
1622 1.36 tls crypt_res[req].status = copyout
1623 1.36 tls (krp->krp_param[i].crp_p,
1624 1.36 tls krp->crk_param[i].crp_p, size);
1625 1.36 tls if (crypt_res[req].status) {
1626 1.36 tls DPRINTF(("cryptodev_key: "
1627 1.36 tls "copyout oparam "
1628 1.36 tls "%d failed, "
1629 1.36 tls "error=%d\n",
1630 1.36 tls i-krp->krp_iparams,
1631 1.36 tls crypt_res[req].status));
1632 1.36 tls goto fail;
1633 1.36 tls }
1634 1.36 tls }
1635 1.36 tls fail:
1636 1.36 tls TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
1637 1.36 tls /* not sure what to do for this */
1638 1.36 tls /* kop[req].crk_status = krp->krp_status; */
1639 1.36 tls SLIST_INSERT_HEAD(&krp_delfree_l, krp,
1640 1.36 tls krp_qun.krp_lnext);
1641 1.36 tls }
1642 1.36 tls req++;
1643 1.36 tls }
1644 1.36 tls }
1645 1.36 tls mutex_spin_exit(&crypto_mtx);
1646 1.36 tls
1647 1.36 tls while(!SLIST_EMPTY(&crp_delfree_l)) {
1648 1.36 tls crp = SLIST_FIRST(&crp_delfree_l);
1649 1.36 tls SLIST_REMOVE_HEAD(&crp_delfree_l, crp_qun.crp_lnext);
1650 1.36 tls kmem_free(crp->uio.uio_iov[0].iov_base,
1651 1.36 tls crp->uio.uio_iov[0].iov_len);
1652 1.36 tls crypto_freereq(crp);
1653 1.36 tls }
1654 1.36 tls
1655 1.36 tls while(!SLIST_EMPTY(&krp_delfree_l)) {
1656 1.36 tls krp = SLIST_FIRST(&krp_delfree_l);
1657 1.36 tls for (i = 0; i < CRK_MAXPARAM; i++) {
1658 1.36 tls struct crparam *kp = &(krp->krp_param[i]);
1659 1.36 tls if (kp->crp_p) {
1660 1.36 tls size = (kp->crp_nbits + 7) / 8;
1661 1.36 tls KASSERT(size > 0);
1662 1.36 tls memset(kp->crp_p, 0, size);
1663 1.36 tls kmem_free(kp->crp_p, size);
1664 1.36 tls }
1665 1.36 tls }
1666 1.36 tls SLIST_REMOVE_HEAD(&krp_delfree_l, krp_qun.krp_lnext);
1667 1.36 tls pool_put(&cryptkop_pool, krp);
1668 1.36 tls }
1669 1.36 tls return completed;
1670 1.36 tls }
1671 1.36 tls
1672 1.36 tls static int
1673 1.36 tls cryptodev_getstatus (struct fcrypt *fcr, struct crypt_result *crypt_res)
1674 1.36 tls {
1675 1.36 tls struct cryptop *crp = NULL;
1676 1.36 tls struct cryptkop *krp = NULL;
1677 1.36 tls struct csession *cse;
1678 1.36 tls int i, size, req = 0;
1679 1.36 tls
1680 1.36 tls mutex_spin_enter(&crypto_mtx);
1681 1.36 tls /* Here we dont know for which request the user is requesting the
1682 1.36 tls * response so checking in both the queues */
1683 1.36 tls TAILQ_FOREACH(crp, &fcr->crp_ret_mq, crp_next) {
1684 1.36 tls if(crp && (crp->crp_reqid == crypt_res->reqid)) {
1685 1.36 tls cse = (struct csession *)crp->crp_opaque;
1686 1.36 tls crypt_res->opaque = crp->crp_usropaque;
1687 1.36 tls cse = csefind(fcr, cse->ses);
1688 1.36 tls if (cse == NULL) {
1689 1.36 tls DPRINTF(("csefind failed\n"));
1690 1.36 tls crypt_res->status = EINVAL;
1691 1.36 tls goto bail;
1692 1.36 tls }
1693 1.36 tls
1694 1.36 tls if (crp->crp_etype != 0) {
1695 1.36 tls crypt_res->status = crp->crp_etype;
1696 1.36 tls goto bail;
1697 1.36 tls }
1698 1.36 tls
1699 1.36 tls if (cse->error) {
1700 1.36 tls crypt_res->status = cse->error;
1701 1.36 tls goto bail;
1702 1.36 tls }
1703 1.36 tls
1704 1.36 tls if (crp->dst &&
1705 1.36 tls (crypt_res->status = copyout
1706 1.36 tls (crp->uio.uio_iov[0].iov_base,
1707 1.36 tls crp->dst, crp->len)))
1708 1.36 tls goto bail;
1709 1.36 tls
1710 1.36 tls if (crp->mac &&
1711 1.36 tls (crypt_res->status = copyout(crp->crp_mac,
1712 1.36 tls crp->mac, cse->thash->authsize)))
1713 1.36 tls goto bail;
1714 1.36 tls bail:
1715 1.36 tls TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
1716 1.36 tls
1717 1.36 tls mutex_spin_exit(&crypto_mtx);
1718 1.36 tls crypto_freereq(crp);
1719 1.36 tls return 0;
1720 1.36 tls }
1721 1.36 tls }
1722 1.36 tls
1723 1.36 tls TAILQ_FOREACH(krp, &fcr->crp_ret_mkq, krp_next) {
1724 1.36 tls if(krp && (krp->krp_reqid == crypt_res->reqid)) {
1725 1.36 tls crypt_res[req].opaque = krp->krp_usropaque;
1726 1.36 tls if (krp->krp_status != 0) {
1727 1.36 tls DPRINTF(("cryptodev_key: "
1728 1.36 tls "krp->krp_status 0x%08x\n",
1729 1.36 tls krp->krp_status));
1730 1.36 tls crypt_res[req].status = krp->krp_status;
1731 1.36 tls goto fail;
1732 1.36 tls }
1733 1.36 tls
1734 1.36 tls for (i = krp->krp_iparams; i < krp->krp_iparams
1735 1.36 tls + krp->krp_oparams; i++) {
1736 1.36 tls size = (krp->krp_param[i].crp_nbits + 7) / 8;
1737 1.36 tls if (size == 0)
1738 1.36 tls continue;
1739 1.36 tls crypt_res[req].status = copyout
1740 1.36 tls (krp->krp_param[i].crp_p,
1741 1.36 tls krp->crk_param[i].crp_p, size);
1742 1.36 tls if (crypt_res[req].status) {
1743 1.36 tls DPRINTF(("cryptodev_key: copyout oparam"
1744 1.36 tls "%d failed, error=%d\n",
1745 1.36 tls i-krp->krp_iparams,
1746 1.36 tls crypt_result[req].status));
1747 1.36 tls goto fail;
1748 1.36 tls }
1749 1.36 tls }
1750 1.36 tls fail:
1751 1.36 tls TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
1752 1.36 tls mutex_spin_exit(&crypto_mtx);
1753 1.36 tls /* not sure what to do for this */
1754 1.36 tls /* kop[req].crk_status = krp->krp_status; */
1755 1.36 tls for (i = 0; i < CRK_MAXPARAM; i++) {
1756 1.36 tls struct crparam *kp = &(krp->krp_param[i]);
1757 1.36 tls if (kp->crp_p) {
1758 1.36 tls size = (kp->crp_nbits + 7) / 8;
1759 1.36 tls KASSERT(size > 0);
1760 1.36 tls memset(kp->crp_p, 0, size);
1761 1.36 tls kmem_free(kp->crp_p, size);
1762 1.36 tls }
1763 1.36 tls }
1764 1.36 tls pool_put(&cryptkop_pool, krp);
1765 1.36 tls return 0;
1766 1.36 tls }
1767 1.36 tls }
1768 1.36 tls mutex_spin_exit(&crypto_mtx);
1769 1.36 tls return EINPROGRESS;
1770 1.36 tls }
1771 1.36 tls
1772 1.36 tls static int
1773 1.36 tls cryptof_poll(struct file *fp, int events)
1774 1.36 tls {
1775 1.36 tls struct fcrypt *fcr = (struct fcrypt *)fp->f_data;
1776 1.38 rmind int revents = 0;
1777 1.36 tls
1778 1.36 tls if (!(events & (POLLIN | POLLRDNORM))) {
1779 1.36 tls /* only support read and POLLIN */
1780 1.36 tls return 0;
1781 1.36 tls }
1782 1.36 tls
1783 1.38 rmind mutex_spin_enter(&crypto_mtx);
1784 1.36 tls if (TAILQ_EMPTY(&fcr->crp_ret_mq) && TAILQ_EMPTY(&fcr->crp_ret_mkq)) {
1785 1.38 rmind /* no completed requests pending, save the poll for later */
1786 1.36 tls selrecord(curlwp, &fcr->sinfo);
1787 1.36 tls } else {
1788 1.36 tls /* let the app(s) know that there are completed requests */
1789 1.38 rmind revents = events & (POLLIN | POLLRDNORM);
1790 1.36 tls }
1791 1.38 rmind mutex_spin_exit(&crypto_mtx);
1792 1.38 rmind
1793 1.38 rmind return revents;
1794 1.36 tls }
1795 1.36 tls
1796 1.15 thorpej /*
1797 1.15 thorpej * Pseudo-device initialization routine for /dev/crypto
1798 1.15 thorpej */
1799 1.15 thorpej void cryptoattach(int);
1800 1.15 thorpej
1801 1.15 thorpej void
1802 1.25 christos cryptoattach(int num)
1803 1.15 thorpej {
1804 1.29 tls pool_init(&fcrpl, sizeof(struct fcrypt), 0, 0, 0, "fcrpl",
1805 1.29 tls NULL, IPL_NET); /* XXX IPL_NET ("splcrypto") */
1806 1.29 tls pool_init(&csepl, sizeof(struct csession), 0, 0, 0, "csepl",
1807 1.29 tls NULL, IPL_NET); /* XXX IPL_NET ("splcrypto") */
1808 1.29 tls
1809 1.29 tls /*
1810 1.29 tls * Preallocate space for 64 users, with 5 sessions each.
1811 1.29 tls * (consider that a TLS protocol session requires at least
1812 1.29 tls * 3DES, MD5, and SHA1 (both hashes are used in the PRF) for
1813 1.29 tls * the negotiation, plus HMAC_SHA1 for the actual SSL records,
1814 1.29 tls * consuming one session here for each algorithm.
1815 1.29 tls */
1816 1.29 tls pool_prime(&fcrpl, 64);
1817 1.29 tls pool_prime(&csepl, 64 * 5);
1818 1.15 thorpej }
1819