1 /* $NetBSD: cryptodev.h,v 1.51 2023/07/11 10:42:16 riastradh 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 161 struct 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 176 struct 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 190 struct 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 221 struct 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 */ 251 struct crypt_mop { 252 size_t count; /* how many */ 253 struct crypt_n_op * reqs; /* where to get them */ 254 }; 255 256 struct crypt_sfop { 257 size_t count; 258 u_int32_t *sesid; 259 }; 260 261 struct 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, ... */ 269 struct crparam { 270 void * crp_p; 271 u_int crp_nbits; 272 }; 273 274 #define CRK_MAXPARAM 8 275 276 struct 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 */ 297 struct 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 307 struct 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 */ 316 struct 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 322 struct 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 384 struct 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 391 struct 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 420 struct cpu_info; 421 struct uio; 422 423 /* Standard initialization structure beginning */ 424 struct 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 */ 434 struct 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 */ 458 struct 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 540 struct 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 */ 566 struct 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 607 MALLOC_DECLARE(M_CRYPTO_DATA); 608 609 extern int crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int hard); 610 extern void crypto_freesession(u_int64_t sid); 611 extern int32_t crypto_get_driverid(u_int32_t flags); 612 extern 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); 618 extern int crypto_kregister(u_int32_t, int, u_int32_t, 619 int (*)(void*, struct cryptkop *, int), 620 void *arg); 621 extern int crypto_unregister(u_int32_t driverid, int alg); 622 extern int crypto_unregister_all(u_int32_t driverid); 623 extern void crypto_dispatch(struct cryptop *crp); 624 extern void crypto_kdispatch(struct cryptkop *); 625 #define CRYPTO_SYMQ 0x1 626 #define CRYPTO_ASYMQ 0x2 627 extern int crypto_unblock(u_int32_t, int); 628 extern void crypto_done(struct cryptop *crp); 629 extern void crypto_kdone(struct cryptkop *); 630 extern int crypto_getfeat(int *); 631 632 void cuio_copydata(struct uio *, int, int, void *); 633 void cuio_copyback(struct uio *, int, int, void *); 634 int cuio_apply(struct uio *, int, int, 635 int (*f)(void *, void *, unsigned int), void *); 636 637 extern void crypto_freereq(struct cryptop *crp); 638 extern struct cryptop *crypto_getreq(int num); 639 640 extern void crypto_kfreereq(struct cryptkop *); 641 extern struct cryptkop *crypto_kgetreq(int, int); 642 643 extern int crypto_usercrypto; /* userland may do crypto requests */ 644 extern int crypto_userasymcrypto; /* userland may do asym crypto reqs */ 645 extern 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 */ 654 int 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 */ 662 struct uio; 663 extern void cuio_copydata(struct uio* uio, int off, int len, void *cp); 664 extern void cuio_copyback(struct uio* uio, int off, int len, void *cp); 665 extern 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_ */ 698