master
1/* $NetBSD: cryptodev.h,v 1.50.4.1 2023/08/09 17:42:03 martin Exp $ */
2/* $FreeBSD: src/sys/opencrypto/cryptodev.h,v 1.2.2.6 2003/07/02 17:04:50 sam Exp $ */
3/* $OpenBSD: cryptodev.h,v 1.33 2002/07/17 23:52:39 art Exp $ */
4
5/*-
6 * Copyright (c) 2008 The NetBSD Foundation, Inc.
7 * All rights reserved.
8 *
9 * This code is derived from software contributed to The NetBSD Foundation
10 * by Coyote Point Systems, Inc.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/*
35 * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu)
36 *
37 * This code was written by Angelos D. Keromytis in Athens, Greece, in
38 * February 2000. Network Security Technologies Inc. (NSTI) kindly
39 * supported the development of this code.
40 *
41 * Copyright (c) 2000 Angelos D. Keromytis
42 *
43 * Permission to use, copy, and modify this software with or without fee
44 * is hereby granted, provided that this entire notice is included in
45 * all source code copies of any software which is or includes a copy or
46 * modification of this software.
47 *
48 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
49 * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
50 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
51 * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
52 * PURPOSE.
53 *
54 * Copyright (c) 2001 Theo de Raadt
55 *
56 * Redistribution and use in source and binary forms, with or without
57 * modification, are permitted provided that the following conditions
58 * are met:
59 *
60 * 1. Redistributions of source code must retain the above copyright
61 * notice, this list of conditions and the following disclaimer.
62 * 2. Redistributions in binary form must reproduce the above copyright
63 * notice, this list of conditions and the following disclaimer in the
64 * documentation and/or other materials provided with the distribution.
65 * 3. The name of the author may not be used to endorse or promote products
66 * derived from this software without specific prior written permission.
67 *
68 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
69 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
70 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
71 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
72 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
73 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
74 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
75 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
76 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
77 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
78 *
79 * Effort sponsored in part by the Defense Advanced Research Projects
80 * Agency (DARPA) and Air Force Research Laboratory, Air Force
81 * Materiel Command, USAF, under agreement number F30602-01-2-0537.
82 *
83 */
84
85#ifndef _CRYPTO_CRYPTO_H_
86#define _CRYPTO_CRYPTO_H_
87
88#include <sys/types.h>
89
90#include <sys/ioccom.h>
91#include <sys/time.h>
92
93#if defined(_KERNEL_OPT)
94#include "opt_ocf.h"
95#endif
96
97/* Some initial values */
98#define CRYPTO_DRIVERS_INITIAL 4
99#define CRYPTO_SW_SESSIONS 32
100
101/* HMAC values */
102#define HMAC_BLOCK_LEN 64 /* for compatibility */
103#define HMAC_IPAD_VAL 0x36
104#define HMAC_OPAD_VAL 0x5C
105
106/* Encryption algorithm block sizes */
107#define DES_BLOCK_LEN 8
108#define DES3_BLOCK_LEN 8
109#define BLOWFISH_BLOCK_LEN 8
110#define SKIPJACK_BLOCK_LEN 8
111#define CAST128_BLOCK_LEN 8
112#define RIJNDAEL128_BLOCK_LEN 16
113#define EALG_MAX_BLOCK_LEN 16 /* Keep this updated */
114
115/* Maximum hash algorithm result length */
116#define AALG_MAX_RESULT_LEN 64 /* Keep this updated */
117
118#define CRYPTO_ALGORITHM_MIN 1
119#define CRYPTO_DES_CBC 1
120#define CRYPTO_3DES_CBC 2
121#define CRYPTO_BLF_CBC 3
122#define CRYPTO_CAST_CBC 4
123#define CRYPTO_SKIPJACK_CBC 5
124#define CRYPTO_MD5_HMAC 6
125#define CRYPTO_SHA1_HMAC 7
126#define CRYPTO_RIPEMD160_HMAC 8
127#define CRYPTO_MD5_KPDK 9
128#define CRYPTO_SHA1_KPDK 10
129#define CRYPTO_RIJNDAEL128_CBC 11 /* 128 bit blocksize */
130#define CRYPTO_AES_CBC 11 /* 128 bit blocksize -- the same as above */
131#define CRYPTO_ARC4 12
132#define CRYPTO_MD5 13
133#define CRYPTO_SHA1 14
134#define CRYPTO_SHA2_256_HMAC 15
135#define CRYPTO_SHA2_HMAC CRYPTO_SHA2_256_HMAC /* for compatibility */
136#define CRYPTO_NULL_HMAC 16
137#define CRYPTO_NULL_CBC 17
138#define CRYPTO_DEFLATE_COMP 18 /* Deflate compression algorithm */
139#define CRYPTO_MD5_HMAC_96 19
140#define CRYPTO_SHA1_HMAC_96 20
141#define CRYPTO_RIPEMD160_HMAC_96 21
142#define CRYPTO_GZIP_COMP 22 /* gzip compression algorithm */
143#define CRYPTO_DEFLATE_COMP_NOGROW 23 /* Deflate, fail if not compressible */
144#define CRYPTO_SHA2_384_HMAC 24
145#define CRYPTO_SHA2_512_HMAC 25
146#define CRYPTO_CAMELLIA_CBC 26
147#define CRYPTO_AES_CTR 27
148#define CRYPTO_AES_XCBC_MAC_96 28
149#define CRYPTO_AES_GCM_16 29
150#define CRYPTO_AES_128_GMAC 30
151#define CRYPTO_AES_192_GMAC 31
152#define CRYPTO_AES_256_GMAC 32
153#define CRYPTO_AES_GMAC 33
154#define CRYPTO_ALGORITHM_MAX 33 /* Keep updated - see below */
155
156/* Algorithm flags */
157#define CRYPTO_ALG_FLAG_SUPPORTED 0x01 /* Algorithm is supported */
158#define CRYPTO_ALG_FLAG_RNG_ENABLE 0x02 /* Has HW RNG for DH/DSA */
159#define CRYPTO_ALG_FLAG_DSA_SHA 0x04 /* Can do SHA on msg */
160
161struct session_op {
162 u_int32_t cipher; /* ie. CRYPTO_DES_CBC */
163 u_int32_t mac; /* ie. CRYPTO_MD5_HMAC */
164 u_int32_t comp_alg; /* ie. CRYPTO_GZIP_COMP */
165
166 u_int32_t keylen; /* cipher key */
167 void * key;
168 int mackeylen; /* mac key */
169 void * mackey;
170
171 u_int32_t ses; /* returns: session # */
172};
173
174/* to support multiple session creation */
175
176struct session_n_op {
177 u_int32_t cipher; /* ie. CRYPTO_DES_CBC */
178 u_int32_t mac; /* ie. CRYPTO_MD5_HMAC */
179 u_int32_t comp_alg; /* ie. CRYPTO_GZIP_COMP */
180
181 u_int32_t keylen; /* cipher key */
182 void * key;
183 int mackeylen; /* mac key */
184 void * mackey;
185
186 u_int32_t ses; /* returns: session # */
187 int status;
188};
189
190struct crypt_op {
191 u_int32_t ses;
192 u_int16_t op; /* i.e. COP_ENCRYPT */
193#define COP_ENCRYPT 1
194#define COP_DECRYPT 2
195#define COP_COMP 3
196#define COP_DECOMP 4
197 u_int16_t flags;
198#define COP_F_BATCH 0x0008 /* Dispatch as quickly as possible */
199 u_int len; /* src len */
200 void * src, *dst; /* become iov[] inside kernel */
201 void * mac; /* must be big enough for chosen MAC */
202 void * iv;
203 u_int dst_len; /* dst len if not 0 */
204};
205
206/* to support multiple session creation */
207/*
208 *
209 * The reqid field is filled when the operation has
210 * been accepted and started, and can be used to later retrieve
211 * the operation results via CIOCNCRYPTRET or identify the
212 * request in the completion list returned by CIOCNCRYPTRETM.
213 *
214 * The opaque pointer can be set arbitrarily by the user
215 * and it is passed back in the crypt_result structure
216 * when the request completes. This field can be used for example
217 * to track context for the request and avoid lookups in the
218 * user application.
219 */
220
221struct crypt_n_op {
222 u_int32_t ses;
223 u_int16_t op; /* i.e. COP_ENCRYPT */
224#define COP_ENCRYPT 1
225#define COP_DECRYPT 2
226 u_int16_t flags;
227#define COP_F_BATCH 0x0008 /* Dispatch as quickly as possible */
228#define COP_F_MORE 0x0010 /* more data to follow */
229 u_int len; /* src len */
230
231 u_int32_t reqid; /* request id */
232 int status; /* status of request -accepted or not */
233 void *opaque; /* opaque pointer returned to user */
234 u_int32_t keylen; /* cipher key - optional */
235 void * key;
236 u_int32_t mackeylen; /* also optional */
237 void * mackey;
238
239 void * src, *dst; /* become iov[] inside kernel */
240 void * mac; /* must be big enough for chosen MAC */
241 void * iv;
242 u_int dst_len; /* dst len if not 0 */
243};
244
245/* CIOCNCRYPTM ioctl argument, supporting one or more asynchronous
246 * crypt_n_op operations.
247 * Each crypt_n_op will receive a request id which can be used to check its
248 * status via CIOCNCRYPTRET, or to watch for its completion in the list
249 * obtained via CIOCNCRYPTRETM.
250 */
251struct crypt_mop {
252 size_t count; /* how many */
253 struct crypt_n_op * reqs; /* where to get them */
254};
255
256struct crypt_sfop {
257 size_t count;
258 u_int32_t *sesid;
259};
260
261struct crypt_sgop {
262 size_t count;
263 struct session_n_op * sessions;
264};
265
266#define CRYPTO_MAX_MAC_LEN 32 /* Keep this updated */
267
268/* bignum parameter, in packed bytes, ... */
269struct crparam {
270 void * crp_p;
271 u_int crp_nbits;
272};
273
274#define CRK_MAXPARAM 8
275
276struct crypt_kop {
277 u_int crk_op; /* ie. CRK_MOD_EXP or other */
278 u_int crk_status; /* return status */
279 u_short crk_iparams; /* # of input parameters */
280 u_short crk_oparams; /* # of output parameters */
281 u_int crk_pad1;
282 struct crparam crk_param[CRK_MAXPARAM];
283};
284
285/*
286 * Used with the CIOCNFKEYM ioctl.
287 *
288 * This structure allows the OCF to return a request id
289 * for each of the kop operations specified in the CIOCNFKEYM call.
290 *
291 * The crk_opaque pointer can be arbitrarily set by the user
292 * and it is passed back in the crypt_result structure
293 * when the request completes. This field can be used for example
294 * to track context for the request and avoid lookups in the
295 * user application.
296 */
297struct crypt_n_kop {
298 u_int crk_op; /* ie. CRK_MOD_EXP or other */
299 u_int crk_status; /* return status */
300 u_short crk_iparams; /* # of input parameters */
301 u_short crk_oparams; /* # of output parameters */
302 u_int32_t crk_reqid; /* request id */
303 struct crparam crk_param[CRK_MAXPARAM];
304 void *crk_opaque; /* opaque pointer returned to user */
305};
306
307struct crypt_mkop {
308 size_t count; /* how many */
309 struct crypt_n_kop * reqs; /* where to get them */
310};
311
312/* Asynchronous key or crypto result.
313 * Note that the status will be set in the crypt_result structure,
314 * not in the original crypt_kop structure (crk_status).
315 */
316struct crypt_result {
317 u_int32_t reqid; /* request id */
318 u_int32_t status; /* status of request: 0 if successful */
319 void * opaque; /* Opaque pointer from the user, passed along */
320};
321
322struct cryptret {
323 size_t count; /* space for how many */
324 struct crypt_result * results; /* where to put them */
325};
326
327
328/* Asymmetric key operations */
329#define CRK_ALGORITHM_MIN 0
330#define CRK_MOD_EXP 0
331#define CRK_MOD_EXP_CRT 1
332#define CRK_DSA_SIGN 2
333#define CRK_DSA_VERIFY 3
334#define CRK_DH_COMPUTE_KEY 4
335#define CRK_MOD_ADD 5
336#define CRK_MOD_ADDINV 6
337#define CRK_MOD_SUB 7
338#define CRK_MOD_MULT 8
339#define CRK_MOD_MULTINV 9
340#define CRK_MOD 10
341#define CRK_ALGORITHM_MAX 10 /* Keep updated - see below */
342
343#define CRF_MOD_EXP (1 << CRK_MOD_EXP)
344#define CRF_MOD_EXP_CRT (1 << CRK_MOD_EXP_CRT)
345#define CRF_DSA_SIGN (1 << CRK_DSA_SIGN)
346#define CRF_DSA_VERIFY (1 << CRK_DSA_VERIFY)
347#define CRF_DH_COMPUTE_KEY (1 << CRK_DH_COMPUTE_KEY)
348#define CRF_MOD_ADD (1 << CRK_MOD_ADD)
349#define CRF_MOD_ADDINV (1 << CRK_MOD_ADDINV)
350#define CRF_MOD_SUB (1 << CRK_MOD_SUB)
351#define CRF_MOD_MULT (1 << CRK_MOD_MULT)
352#define CRF_MOD_MULTINV (1 << CRK_MOD_MULTINV)
353#define CRF_MOD (1 << CRK_MOD)
354
355/*
356 * A large comment here once held descriptions of the ioctl
357 * requests implemented by the device. This text has been moved
358 * to the crypto(4) manual page and, later, removed from this file
359 * as it was always a step behind the times.
360 */
361
362/*
363 * done against open of /dev/crypto, to get a cloned descriptor.
364 * Please use F_SETFD against the cloned descriptor. But this ioctl
365 * is obsolete (the device now clones): please, just don't use it.
366 */
367#define CRIOGET _IOWR('c', 100, u_int32_t)
368
369/* the following are done against the cloned descriptor */
370#define CIOCFSESSION _IOW('c', 102, u_int32_t)
371#define CIOCKEY _IOWR('c', 104, struct crypt_kop)
372#define CIOCNFKEYM _IOWR('c', 108, struct crypt_mkop)
373#define CIOCNFSESSION _IOW('c', 109, struct crypt_sfop)
374#define CIOCNCRYPTRETM _IOWR('c', 110, struct cryptret)
375#define CIOCNCRYPTRET _IOWR('c', 111, struct crypt_result)
376
377#define CIOCGSESSION _IOWR('c', 112, struct session_op)
378#define CIOCNGSESSION _IOWR('c', 113, struct crypt_sgop)
379#define CIOCCRYPT _IOWR('c', 114, struct crypt_op)
380#define CIOCNCRYPTM _IOWR('c', 115, struct crypt_mop)
381
382#define CIOCASYMFEAT _IOR('c', 105, u_int32_t)
383
384struct cryptotstat {
385 struct timespec acc; /* total accumulated time */
386 struct timespec min; /* max time */
387 struct timespec max; /* max time */
388 u_int32_t count; /* number of observations */
389};
390
391struct cryptostats {
392 u_int32_t cs_ops; /* symmetric crypto ops submitted */
393 u_int32_t cs_errs; /* symmetric crypto ops that failed */
394 u_int32_t cs_kops; /* asymmetric/key ops submitted */
395 u_int32_t cs_kerrs; /* asymmetric/key ops that failed */
396 u_int32_t cs_intrs; /* crypto swi thread activations */
397 u_int32_t cs_rets; /* crypto return thread activations */
398 u_int32_t cs_blocks; /* symmetric op driver block */
399 u_int32_t cs_kblocks; /* symmetric op driver block */
400 /*
401 * When CRYPTO_TIMING is defined at compile time and the
402 * sysctl debug.crypto is set to 1, the crypto system will
403 * accumulate statistics about how long it takes to process
404 * crypto requests at various points during processing.
405 */
406 struct cryptotstat cs_invoke; /* crypto_dispatch -> crypto_invoke */
407 struct cryptotstat cs_done; /* crypto_invoke -> crypto_done */
408 struct cryptotstat cs_cb; /* crypto_done -> callback */
409 struct cryptotstat cs_finis; /* callback -> callback return */
410};
411
412#ifdef _KERNEL
413
414#include <sys/condvar.h>
415#include <sys/malloc.h>
416#include <sys/mutex.h>
417#include <sys/queue.h>
418#include <sys/systm.h>
419
420struct cpu_info;
421struct uio;
422
423/* Standard initialization structure beginning */
424struct cryptoini {
425 int cri_alg; /* Algorithm to use */
426 int cri_klen; /* Key length, in bits */
427 int cri_rnd; /* Algorithm rounds, where relevant */
428 char *cri_key; /* key to use */
429 u_int8_t cri_iv[EALG_MAX_BLOCK_LEN]; /* IV to use */
430 struct cryptoini *cri_next;
431};
432
433/* Describe boundaries of a single crypto operation */
434struct cryptodesc {
435 int crd_skip; /* How many bytes to ignore from start */
436 int crd_len; /* How many bytes to process */
437 int crd_inject; /* Where to inject results, if applicable */
438 int crd_flags;
439
440#define CRD_F_ENCRYPT 0x01 /* Set when doing encryption */
441#define CRD_F_IV_PRESENT 0x02 /* When encrypting, IV is already in
442 place, so don't copy. */
443#define CRD_F_IV_EXPLICIT 0x04 /* IV explicitly provided */
444#define CRD_F_DSA_SHA_NEEDED 0x08 /* Compute SHA-1 of buffer for DSA */
445#define CRD_F_COMP 0x10 /* Set when doing compression */
446
447 struct cryptoini CRD_INI; /* Initialization/context data */
448#define crd_iv CRD_INI.cri_iv
449#define crd_key CRD_INI.cri_key
450#define crd_rnd CRD_INI.cri_rnd
451#define crd_alg CRD_INI.cri_alg
452#define crd_klen CRD_INI.cri_klen
453
454 struct cryptodesc *crd_next;
455};
456
457/* Structure describing complete operation */
458struct cryptop {
459 TAILQ_ENTRY(cryptop) crp_next;
460 u_int64_t crp_sid; /* Session ID */
461
462 int crp_ilen; /* Input data total length */
463 int crp_olen; /* Result total length */
464
465 int crp_etype; /*
466 * Error type (zero means no error).
467 * All error codes
468 * indicate possible data corruption (as in,
469 * the data have been touched). On all
470 * errors, the crp_sid may have changed
471 * (reset to a new one), so the caller
472 * should always check and use the new
473 * value on future requests.
474 */
475 int crp_flags; /*
476 * other than crypto.c must not write
477 * after crypto_dispatch().
478 */
479#define CRYPTO_F_IMBUF 0x0001 /* Input/output are mbuf chains */
480#define CRYPTO_F_IOV 0x0002 /* Input/output are uio */
481#define CRYPTO_F_REL 0x0004 /* Must return data in same place */
482#define CRYPTO_F_BATCH 0x0008 /* Batch op if possible possible */
483#define CRYPTO_F_UNUSED0 0x0010 /* was CRYPTO_F_CBIMM */
484#define CRYPTO_F_UNUSED1 0x0020 /* was CRYPTO_F_DONE */
485#define CRYPTO_F_UNUSED2 0x0040 /* was CRYPTO_F_CBIFSYNC */
486#define CRYPTO_F_ONRETQ 0x0080 /* Request is on return queue */
487#define CRYPTO_F_UNUSED3 0x0100 /* was CRYPTO_F_USER */
488#define CRYPTO_F_MORE 0x0200 /* more data to follow */
489
490 int crp_devflags; /* other than cryptodev.c must not use. */
491#define CRYPTODEV_F_RET 0x0001 /* return from crypto.c to cryptodev.c */
492
493 void * crp_buf; /* Data to be processed */
494 void * crp_opaque; /* Opaque pointer, passed along */
495 struct cryptodesc *crp_desc; /* Linked list of processing descriptors */
496
497 void (*crp_callback)(struct cryptop *); /*
498 * Callback function.
499 * That must not sleep as it is
500 * called in softint context.
501 */
502
503 void * crp_mac;
504
505 /*
506 * everything below is private to crypto(4)
507 */
508 u_int32_t crp_reqid; /* request id */
509 void * crp_usropaque; /* Opaque pointer from user, passed along */
510 struct timespec crp_tstamp; /* performance time stamp */
511 kcondvar_t crp_cv;
512 struct fcrypt *fcrp;
513 void * dst;
514 void * mac;
515 u_int len;
516 u_char tmp_iv[EALG_MAX_BLOCK_LEN];
517 u_char tmp_mac[CRYPTO_MAX_MAC_LEN];
518
519 struct iovec iovec[1];
520 struct uio uio;
521 uint32_t magic;
522 struct cpu_info *reqcpu; /*
523 * save requested CPU to do cryptoret
524 * softint in the same CPU.
525 */
526};
527
528#define CRYPTO_BUF_CONTIG 0x0
529#define CRYPTO_BUF_IOV 0x1
530#define CRYPTO_BUF_MBUF 0x2
531
532#define CRYPTO_OP_DECRYPT 0x0
533#define CRYPTO_OP_ENCRYPT 0x1
534
535/*
536 * Hints passed to process methods.
537 */
538#define CRYPTO_HINT_MORE 0x1 /* more ops coming shortly */
539
540struct cryptkop {
541 TAILQ_ENTRY(cryptkop) krp_next;
542
543 u_int32_t krp_reqid; /* request id */
544 void * krp_usropaque; /* Opaque pointer from user, passed along */
545
546 u_int krp_op; /* ie. CRK_MOD_EXP or other */
547 u_int krp_status; /* return status */
548 u_short krp_iparams; /* # of input parameters */
549 u_short krp_oparams; /* # of output parameters */
550 u_int32_t krp_hid;
551 struct crparam krp_param[CRK_MAXPARAM]; /* kvm */
552 void (*krp_callback)(struct cryptkop *); /*
553 * Callback function.
554 * That must not sleep as it is
555 * called in softint context.
556 */
557 int krp_flags; /* same values as crp_flags */
558 int krp_devflags; /* same values as crp_devflags */
559 kcondvar_t krp_cv;
560 struct fcrypt *fcrp;
561 struct crparam crk_param[CRK_MAXPARAM];
562 struct cpu_info *reqcpu;
563};
564
565/* Crypto capabilities structure */
566struct cryptocap {
567 u_int32_t cc_sessions;
568
569 /*
570 * Largest possible operator length (in bits) for each type of
571 * encryption algorithm.
572 */
573 u_int16_t cc_max_op_len[CRYPTO_ALGORITHM_MAX + 1];
574
575 u_int8_t cc_alg[CRYPTO_ALGORITHM_MAX + 1];
576
577 u_int8_t cc_kalg[CRK_ALGORITHM_MAX + 1];
578
579 u_int8_t cc_flags;
580 u_int8_t cc_qblocked; /* symmetric q blocked */
581 u_int8_t cc_kqblocked; /* asymmetric q blocked */
582#define CRYPTOCAP_F_CLEANUP 0x01 /* needs resource cleanup */
583#define CRYPTOCAP_F_SOFTWARE 0x02 /* software implementation */
584#define CRYPTOCAP_F_SYNC 0x04 /* operates synchronously */
585
586 void *cc_arg; /* callback argument */
587 int (*cc_newsession)(void*, u_int32_t*, struct cryptoini*);
588 int (*cc_process) (void*, struct cryptop *, int);
589 void (*cc_freesession) (void *, u_int64_t);
590 void *cc_karg; /* callback argument */
591 int (*cc_kprocess) (void*, struct cryptkop *, int);
592
593 kmutex_t cc_lock;
594};
595
596/*
597 * Session ids are 64 bits. The lower 32 bits contain a "local id" which
598 * is a driver-private session identifier. The upper 32 bits contain a
599 * "hardware id" used by the core crypto code to identify the driver and
600 * a copy of the driver's capabilities that can be used by client code to
601 * optimize operation.
602 */
603#define CRYPTO_SESID2HID(_sid) ((((_sid) >> 32) & 0xffffff) - 1)
604#define CRYPTO_SESID2CAPS(_sid) (((_sid) >> 56) & 0xff)
605#define CRYPTO_SESID2LID(_sid) (((u_int32_t) (_sid)) & 0xffffffff)
606
607MALLOC_DECLARE(M_CRYPTO_DATA);
608
609extern int crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int hard);
610extern void crypto_freesession(u_int64_t sid);
611extern int32_t crypto_get_driverid(u_int32_t flags);
612extern int crypto_register(u_int32_t driverid, int alg, u_int16_t maxoplen,
613 u_int32_t flags,
614 int (*newses)(void*, u_int32_t*, struct cryptoini*),
615 void (*freeses)(void *, u_int64_t),
616 int (*process)(void*, struct cryptop *, int),
617 void *arg);
618extern int crypto_kregister(u_int32_t, int, u_int32_t,
619 int (*)(void*, struct cryptkop *, int),
620 void *arg);
621extern int crypto_unregister(u_int32_t driverid, int alg);
622extern int crypto_unregister_all(u_int32_t driverid);
623extern void crypto_dispatch(struct cryptop *crp);
624extern void crypto_kdispatch(struct cryptkop *);
625#define CRYPTO_SYMQ 0x1
626#define CRYPTO_ASYMQ 0x2
627extern int crypto_unblock(u_int32_t, int);
628extern void crypto_done(struct cryptop *crp);
629extern void crypto_kdone(struct cryptkop *);
630extern int crypto_getfeat(int *);
631
632void cuio_copydata(struct uio *, int, int, void *);
633void cuio_copyback(struct uio *, int, int, void *);
634int cuio_apply(struct uio *, int, int,
635 int (*f)(void *, void *, unsigned int), void *);
636
637extern void crypto_freereq(struct cryptop *crp);
638extern struct cryptop *crypto_getreq(int num);
639
640extern void crypto_kfreereq(struct cryptkop *);
641extern struct cryptkop *crypto_kgetreq(int, int);
642
643extern int crypto_usercrypto; /* userland may do crypto requests */
644extern int crypto_userasymcrypto; /* userland may do asym crypto reqs */
645extern int crypto_devallowsoft; /* only use hardware crypto */
646
647/*
648 * initialize the crypto framework subsystem (not the pseudo-device).
649 * This must be called very early in boot, so the framework is ready
650 * to handle registration requests when crypto hardware is autoconfigured.
651 * (This declaration doesn't really belong here but there's no header
652 * for the raw framework.)
653 */
654int crypto_init(void);
655
656/*
657 * Crypto-related utility routines used mainly by drivers.
658 *
659 * XXX these don't really belong here; but for now they're
660 * kept apart from the rest of the system.
661 */
662struct uio;
663extern void cuio_copydata(struct uio* uio, int off, int len, void *cp);
664extern void cuio_copyback(struct uio* uio, int off, int len, void *cp);
665extern int cuio_getptr(struct uio *, int loc, int *off);
666
667#ifdef CRYPTO_DEBUG /* yuck, netipsec defines these differently */
668#ifndef DPRINTF
669#define DPRINTF(a, ...) printf("%s: " a, __func__, ##__VA_ARGS__)
670#endif
671#else
672#ifndef DPRINTF
673#define DPRINTF(a, ...)
674#endif
675#endif
676
677#endif /* _KERNEL */
678/*
679 * Locking notes:
680 * + crypto_drivers itself is protected by crypto_drv_mtx (an adaptive lock)
681 * + crypto_drivers[i] and its all members are protected by
682 * crypto_drivers[i].cc_lock (a spin lock)
683 * spin lock as crypto_unblock() can be called in interrupt context
684 * + percpu'ed crp_q and crp_kq are procted by splsoftnet.
685 * + crp_ret_q, crp_ret_kq and crypto_exit_flag that are members of
686 * struct crypto_crp_ret_qs are protected by crypto_crp_ret_qs.crp_ret_q_mtx
687 * (a spin lock)
688 * spin lock as crypto_done() can be called in interrupt context
689 * NOTE:
690 * It is not known whether crypto_done()(in interrupt context) is called
691 * in the same CPU as crypto_dispatch() is called.
692 * So, struct crypto_crp_ret_qs cannot be percpu(9).
693 *
694 * Locking order:
695 * - crypto_drv_mtx => crypto_drivers[i].cc_lock
696 */
697#endif /* _CRYPTO_CRYPTO_H_ */