1 /* 2 * Scatterlist Cryptographic API. 3 * 4 * Copyright (c) 2002 James Morris <[email protected]> 5 * Copyright (c) 2002 David S. Miller ([email protected]) 6 * Copyright (c) 2005 Herbert Xu <[email protected]> 7 * 8 * Portions derived from Cryptoapi, by Alexander Kjeldaas <[email protected]> 9 * and Nettle, by Niels M�ller. 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the Free 13 * Software Foundation; either version 2 of the License, or (at your option) 14 * any later version. 15 * 16 */ 17 #ifndef _LINUX_CRYPTO_H 18 #define _LINUX_CRYPTO_H 19 20 #include <asm/atomic.h> 21 #include <linux/module.h> 22 #include <linux/kernel.h> 23 #include <linux/list.h> 24 #include <linux/slab.h> 25 #include <linux/string.h> 26 #include <linux/uaccess.h> 27 28 /* 29 * Algorithm masks and types. 30 */ 31 #define CRYPTO_ALG_TYPE_MASK 0x0000000f 32 #define CRYPTO_ALG_TYPE_CIPHER 0x00000001 33 #define CRYPTO_ALG_TYPE_DIGEST 0x00000002 34 #define CRYPTO_ALG_TYPE_HASH 0x00000003 35 #define CRYPTO_ALG_TYPE_BLKCIPHER 0x00000004 36 #define CRYPTO_ALG_TYPE_COMPRESS 0x00000005 37 38 #define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e 39 40 #define CRYPTO_ALG_LARVAL 0x00000010 41 #define CRYPTO_ALG_DEAD 0x00000020 42 #define CRYPTO_ALG_DYING 0x00000040 43 #define CRYPTO_ALG_ASYNC 0x00000080 44 45 /* 46 * Set this bit if and only if the algorithm requires another algorithm of 47 * the same type to handle corner cases. 48 */ 49 #define CRYPTO_ALG_NEED_FALLBACK 0x00000100 50 51 /* 52 * Transform masks and values (for crt_flags). 53 */ 54 #define CRYPTO_TFM_MODE_MASK 0x000000ff 55 #define CRYPTO_TFM_REQ_MASK 0x000fff00 56 #define CRYPTO_TFM_RES_MASK 0xfff00000 57 58 #define CRYPTO_TFM_MODE_ECB 0x00000001 59 #define CRYPTO_TFM_MODE_CBC 0x00000002 60 #define CRYPTO_TFM_MODE_CFB 0x00000004 61 #define CRYPTO_TFM_MODE_CTR 0x00000008 62 63 #define CRYPTO_TFM_REQ_WEAK_KEY 0x00000100 64 #define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200 65 #define CRYPTO_TFM_RES_WEAK_KEY 0x00100000 66 #define CRYPTO_TFM_RES_BAD_KEY_LEN 0x00200000 67 #define CRYPTO_TFM_RES_BAD_KEY_SCHED 0x00400000 68 #define CRYPTO_TFM_RES_BAD_BLOCK_LEN 0x00800000 69 #define CRYPTO_TFM_RES_BAD_FLAGS 0x01000000 70 71 /* 72 * Miscellaneous stuff. 73 */ 74 #define CRYPTO_UNSPEC 0 75 #define CRYPTO_MAX_ALG_NAME 64 76 77 #define CRYPTO_DIR_ENCRYPT 1 78 #define CRYPTO_DIR_DECRYPT 0 79 80 /* 81 * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual 82 * declaration) is used to ensure that the crypto_tfm context structure is 83 * aligned correctly for the given architecture so that there are no alignment 84 * faults for C data types. In particular, this is required on platforms such 85 * as arm where pointers are 32-bit aligned but there are data types such as 86 * u64 which require 64-bit alignment. 87 */ 88 #if defined(ARCH_KMALLOC_MINALIGN) 89 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN 90 #elif defined(ARCH_SLAB_MINALIGN) 91 #define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN 92 #endif 93 94 #ifdef CRYPTO_MINALIGN 95 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN))) 96 #else 97 #define CRYPTO_MINALIGN_ATTR 98 #endif 99 100 struct scatterlist; 101 struct crypto_blkcipher; 102 struct crypto_hash; 103 struct crypto_tfm; 104 struct crypto_type; 105 106 struct blkcipher_desc { 107 struct crypto_blkcipher *tfm; 108 void *info; 109 u32 flags; 110 }; 111 112 struct cipher_desc { 113 struct crypto_tfm *tfm; 114 void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 115 unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst, 116 const u8 *src, unsigned int nbytes); 117 void *info; 118 }; 119 120 struct hash_desc { 121 struct crypto_hash *tfm; 122 u32 flags; 123 }; 124 125 /* 126 * Algorithms: modular crypto algorithm implementations, managed 127 * via crypto_register_alg() and crypto_unregister_alg(). 128 */ 129 struct blkcipher_alg { 130 int (*setkey)(struct crypto_tfm *tfm, const u8 *key, 131 unsigned int keylen); 132 int (*encrypt)(struct blkcipher_desc *desc, 133 struct scatterlist *dst, struct scatterlist *src, 134 unsigned int nbytes); 135 int (*decrypt)(struct blkcipher_desc *desc, 136 struct scatterlist *dst, struct scatterlist *src, 137 unsigned int nbytes); 138 139 unsigned int min_keysize; 140 unsigned int max_keysize; 141 unsigned int ivsize; 142 }; 143 144 struct cipher_alg { 145 unsigned int cia_min_keysize; 146 unsigned int cia_max_keysize; 147 int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key, 148 unsigned int keylen); 149 void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 150 void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 151 152 unsigned int (*cia_encrypt_ecb)(const struct cipher_desc *desc, 153 u8 *dst, const u8 *src, 154 unsigned int nbytes) __deprecated; 155 unsigned int (*cia_decrypt_ecb)(const struct cipher_desc *desc, 156 u8 *dst, const u8 *src, 157 unsigned int nbytes) __deprecated; 158 unsigned int (*cia_encrypt_cbc)(const struct cipher_desc *desc, 159 u8 *dst, const u8 *src, 160 unsigned int nbytes) __deprecated; 161 unsigned int (*cia_decrypt_cbc)(const struct cipher_desc *desc, 162 u8 *dst, const u8 *src, 163 unsigned int nbytes) __deprecated; 164 }; 165 166 struct digest_alg { 167 unsigned int dia_digestsize; 168 void (*dia_init)(struct crypto_tfm *tfm); 169 void (*dia_update)(struct crypto_tfm *tfm, const u8 *data, 170 unsigned int len); 171 void (*dia_final)(struct crypto_tfm *tfm, u8 *out); 172 int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key, 173 unsigned int keylen); 174 }; 175 176 struct hash_alg { 177 int (*init)(struct hash_desc *desc); 178 int (*update)(struct hash_desc *desc, struct scatterlist *sg, 179 unsigned int nbytes); 180 int (*final)(struct hash_desc *desc, u8 *out); 181 int (*digest)(struct hash_desc *desc, struct scatterlist *sg, 182 unsigned int nbytes, u8 *out); 183 int (*setkey)(struct crypto_hash *tfm, const u8 *key, 184 unsigned int keylen); 185 186 unsigned int digestsize; 187 }; 188 189 struct compress_alg { 190 int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src, 191 unsigned int slen, u8 *dst, unsigned int *dlen); 192 int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src, 193 unsigned int slen, u8 *dst, unsigned int *dlen); 194 }; 195 196 #define cra_blkcipher cra_u.blkcipher 197 #define cra_cipher cra_u.cipher 198 #define cra_digest cra_u.digest 199 #define cra_hash cra_u.hash 200 #define cra_compress cra_u.compress 201 202 struct crypto_alg { 203 struct list_head cra_list; 204 struct list_head cra_users; 205 206 u32 cra_flags; 207 unsigned int cra_blocksize; 208 unsigned int cra_ctxsize; 209 unsigned int cra_alignmask; 210 211 int cra_priority; 212 atomic_t cra_refcnt; 213 214 char cra_name[CRYPTO_MAX_ALG_NAME]; 215 char cra_driver_name[CRYPTO_MAX_ALG_NAME]; 216 217 const struct crypto_type *cra_type; 218 219 union { 220 struct blkcipher_alg blkcipher; 221 struct cipher_alg cipher; 222 struct digest_alg digest; 223 struct hash_alg hash; 224 struct compress_alg compress; 225 } cra_u; 226 227 int (*cra_init)(struct crypto_tfm *tfm); 228 void (*cra_exit)(struct crypto_tfm *tfm); 229 void (*cra_destroy)(struct crypto_alg *alg); 230 231 struct module *cra_module; 232 }; 233 234 /* 235 * Algorithm registration interface. 236 */ 237 int crypto_register_alg(struct crypto_alg *alg); 238 int crypto_unregister_alg(struct crypto_alg *alg); 239 240 /* 241 * Algorithm query interface. 242 */ 243 #ifdef CONFIG_CRYPTO 244 int crypto_alg_available(const char *name, u32 flags) 245 __deprecated_for_modules; 246 int crypto_has_alg(const char *name, u32 type, u32 mask); 247 #else 248 static int crypto_alg_available(const char *name, u32 flags); 249 __deprecated_for_modules; 250 static inline int crypto_alg_available(const char *name, u32 flags) 251 { 252 return 0; 253 } 254 255 static inline int crypto_has_alg(const char *name, u32 type, u32 mask) 256 { 257 return 0; 258 } 259 #endif 260 261 /* 262 * Transforms: user-instantiated objects which encapsulate algorithms 263 * and core processing logic. Managed via crypto_alloc_*() and 264 * crypto_free_*(), as well as the various helpers below. 265 */ 266 267 struct blkcipher_tfm { 268 void *iv; 269 int (*setkey)(struct crypto_tfm *tfm, const u8 *key, 270 unsigned int keylen); 271 int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, 272 struct scatterlist *src, unsigned int nbytes); 273 int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, 274 struct scatterlist *src, unsigned int nbytes); 275 }; 276 277 struct cipher_tfm { 278 void *cit_iv; 279 unsigned int cit_ivsize; 280 u32 cit_mode; 281 int (*cit_setkey)(struct crypto_tfm *tfm, 282 const u8 *key, unsigned int keylen); 283 int (*cit_encrypt)(struct crypto_tfm *tfm, 284 struct scatterlist *dst, 285 struct scatterlist *src, 286 unsigned int nbytes); 287 int (*cit_encrypt_iv)(struct crypto_tfm *tfm, 288 struct scatterlist *dst, 289 struct scatterlist *src, 290 unsigned int nbytes, u8 *iv); 291 int (*cit_decrypt)(struct crypto_tfm *tfm, 292 struct scatterlist *dst, 293 struct scatterlist *src, 294 unsigned int nbytes); 295 int (*cit_decrypt_iv)(struct crypto_tfm *tfm, 296 struct scatterlist *dst, 297 struct scatterlist *src, 298 unsigned int nbytes, u8 *iv); 299 void (*cit_xor_block)(u8 *dst, const u8 *src); 300 void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 301 void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 302 }; 303 304 struct hash_tfm { 305 int (*init)(struct hash_desc *desc); 306 int (*update)(struct hash_desc *desc, 307 struct scatterlist *sg, unsigned int nsg); 308 int (*final)(struct hash_desc *desc, u8 *out); 309 int (*digest)(struct hash_desc *desc, struct scatterlist *sg, 310 unsigned int nsg, u8 *out); 311 int (*setkey)(struct crypto_hash *tfm, const u8 *key, 312 unsigned int keylen); 313 unsigned int digestsize; 314 }; 315 316 struct compress_tfm { 317 int (*cot_compress)(struct crypto_tfm *tfm, 318 const u8 *src, unsigned int slen, 319 u8 *dst, unsigned int *dlen); 320 int (*cot_decompress)(struct crypto_tfm *tfm, 321 const u8 *src, unsigned int slen, 322 u8 *dst, unsigned int *dlen); 323 }; 324 325 #define crt_blkcipher crt_u.blkcipher 326 #define crt_cipher crt_u.cipher 327 #define crt_hash crt_u.hash 328 #define crt_compress crt_u.compress 329 330 struct crypto_tfm { 331 332 u32 crt_flags; 333 334 union { 335 struct blkcipher_tfm blkcipher; 336 struct cipher_tfm cipher; 337 struct hash_tfm hash; 338 struct compress_tfm compress; 339 } crt_u; 340 341 struct crypto_alg *__crt_alg; 342 343 void *__crt_ctx[] CRYPTO_MINALIGN_ATTR; 344 }; 345 346 #define crypto_cipher crypto_tfm 347 #define crypto_comp crypto_tfm 348 349 struct crypto_blkcipher { 350 struct crypto_tfm base; 351 }; 352 353 struct crypto_hash { 354 struct crypto_tfm base; 355 }; 356 357 enum { 358 CRYPTOA_UNSPEC, 359 CRYPTOA_ALG, 360 }; 361 362 struct crypto_attr_alg { 363 char name[CRYPTO_MAX_ALG_NAME]; 364 }; 365 366 /* 367 * Transform user interface. 368 */ 369 370 struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags); 371 struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask); 372 void crypto_free_tfm(struct crypto_tfm *tfm); 373 374 /* 375 * Transform helpers which query the underlying algorithm. 376 */ 377 static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm) 378 { 379 return tfm->__crt_alg->cra_name; 380 } 381 382 static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm) 383 { 384 return tfm->__crt_alg->cra_driver_name; 385 } 386 387 static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm) 388 { 389 return tfm->__crt_alg->cra_priority; 390 } 391 392 static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm) 393 { 394 return module_name(tfm->__crt_alg->cra_module); 395 } 396 397 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm) 398 { 399 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK; 400 } 401 402 static unsigned int crypto_tfm_alg_min_keysize(struct crypto_tfm *tfm) 403 __deprecated; 404 static inline unsigned int crypto_tfm_alg_min_keysize(struct crypto_tfm *tfm) 405 { 406 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 407 return tfm->__crt_alg->cra_cipher.cia_min_keysize; 408 } 409 410 static unsigned int crypto_tfm_alg_max_keysize(struct crypto_tfm *tfm) 411 __deprecated; 412 static inline unsigned int crypto_tfm_alg_max_keysize(struct crypto_tfm *tfm) 413 { 414 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 415 return tfm->__crt_alg->cra_cipher.cia_max_keysize; 416 } 417 418 static unsigned int crypto_tfm_alg_ivsize(struct crypto_tfm *tfm) __deprecated; 419 static inline unsigned int crypto_tfm_alg_ivsize(struct crypto_tfm *tfm) 420 { 421 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 422 return tfm->crt_cipher.cit_ivsize; 423 } 424 425 static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm) 426 { 427 return tfm->__crt_alg->cra_blocksize; 428 } 429 430 static inline unsigned int crypto_tfm_alg_digestsize(struct crypto_tfm *tfm) 431 { 432 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST); 433 return tfm->__crt_alg->cra_digest.dia_digestsize; 434 } 435 436 static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm) 437 { 438 return tfm->__crt_alg->cra_alignmask; 439 } 440 441 static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm) 442 { 443 return tfm->crt_flags; 444 } 445 446 static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags) 447 { 448 tfm->crt_flags |= flags; 449 } 450 451 static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags) 452 { 453 tfm->crt_flags &= ~flags; 454 } 455 456 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm) 457 { 458 return tfm->__crt_ctx; 459 } 460 461 static inline unsigned int crypto_tfm_ctx_alignment(void) 462 { 463 struct crypto_tfm *tfm; 464 return __alignof__(tfm->__crt_ctx); 465 } 466 467 /* 468 * API wrappers. 469 */ 470 static inline struct crypto_blkcipher *__crypto_blkcipher_cast( 471 struct crypto_tfm *tfm) 472 { 473 return (struct crypto_blkcipher *)tfm; 474 } 475 476 static inline struct crypto_blkcipher *crypto_blkcipher_cast( 477 struct crypto_tfm *tfm) 478 { 479 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER); 480 return __crypto_blkcipher_cast(tfm); 481 } 482 483 static inline struct crypto_blkcipher *crypto_alloc_blkcipher( 484 const char *alg_name, u32 type, u32 mask) 485 { 486 type &= ~CRYPTO_ALG_TYPE_MASK; 487 type |= CRYPTO_ALG_TYPE_BLKCIPHER; 488 mask |= CRYPTO_ALG_TYPE_MASK; 489 490 return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask)); 491 } 492 493 static inline struct crypto_tfm *crypto_blkcipher_tfm( 494 struct crypto_blkcipher *tfm) 495 { 496 return &tfm->base; 497 } 498 499 static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm) 500 { 501 crypto_free_tfm(crypto_blkcipher_tfm(tfm)); 502 } 503 504 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask) 505 { 506 type &= ~CRYPTO_ALG_TYPE_MASK; 507 type |= CRYPTO_ALG_TYPE_BLKCIPHER; 508 mask |= CRYPTO_ALG_TYPE_MASK; 509 510 return crypto_has_alg(alg_name, type, mask); 511 } 512 513 static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm) 514 { 515 return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm)); 516 } 517 518 static inline struct blkcipher_tfm *crypto_blkcipher_crt( 519 struct crypto_blkcipher *tfm) 520 { 521 return &crypto_blkcipher_tfm(tfm)->crt_blkcipher; 522 } 523 524 static inline struct blkcipher_alg *crypto_blkcipher_alg( 525 struct crypto_blkcipher *tfm) 526 { 527 return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher; 528 } 529 530 static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm) 531 { 532 return crypto_blkcipher_alg(tfm)->ivsize; 533 } 534 535 static inline unsigned int crypto_blkcipher_blocksize( 536 struct crypto_blkcipher *tfm) 537 { 538 return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm)); 539 } 540 541 static inline unsigned int crypto_blkcipher_alignmask( 542 struct crypto_blkcipher *tfm) 543 { 544 return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm)); 545 } 546 547 static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm) 548 { 549 return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm)); 550 } 551 552 static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm, 553 u32 flags) 554 { 555 crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags); 556 } 557 558 static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm, 559 u32 flags) 560 { 561 crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags); 562 } 563 564 static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm, 565 const u8 *key, unsigned int keylen) 566 { 567 return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm), 568 key, keylen); 569 } 570 571 static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc, 572 struct scatterlist *dst, 573 struct scatterlist *src, 574 unsigned int nbytes) 575 { 576 desc->info = crypto_blkcipher_crt(desc->tfm)->iv; 577 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes); 578 } 579 580 static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc, 581 struct scatterlist *dst, 582 struct scatterlist *src, 583 unsigned int nbytes) 584 { 585 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes); 586 } 587 588 static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc, 589 struct scatterlist *dst, 590 struct scatterlist *src, 591 unsigned int nbytes) 592 { 593 desc->info = crypto_blkcipher_crt(desc->tfm)->iv; 594 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes); 595 } 596 597 static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc, 598 struct scatterlist *dst, 599 struct scatterlist *src, 600 unsigned int nbytes) 601 { 602 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes); 603 } 604 605 static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm, 606 const u8 *src, unsigned int len) 607 { 608 memcpy(crypto_blkcipher_crt(tfm)->iv, src, len); 609 } 610 611 static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm, 612 u8 *dst, unsigned int len) 613 { 614 memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len); 615 } 616 617 static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm) 618 { 619 return (struct crypto_cipher *)tfm; 620 } 621 622 static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm) 623 { 624 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 625 return __crypto_cipher_cast(tfm); 626 } 627 628 static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name, 629 u32 type, u32 mask) 630 { 631 type &= ~CRYPTO_ALG_TYPE_MASK; 632 type |= CRYPTO_ALG_TYPE_CIPHER; 633 mask |= CRYPTO_ALG_TYPE_MASK; 634 635 return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask)); 636 } 637 638 static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm) 639 { 640 return tfm; 641 } 642 643 static inline void crypto_free_cipher(struct crypto_cipher *tfm) 644 { 645 crypto_free_tfm(crypto_cipher_tfm(tfm)); 646 } 647 648 static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask) 649 { 650 type &= ~CRYPTO_ALG_TYPE_MASK; 651 type |= CRYPTO_ALG_TYPE_CIPHER; 652 mask |= CRYPTO_ALG_TYPE_MASK; 653 654 return crypto_has_alg(alg_name, type, mask); 655 } 656 657 static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm) 658 { 659 return &crypto_cipher_tfm(tfm)->crt_cipher; 660 } 661 662 static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm) 663 { 664 return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm)); 665 } 666 667 static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm) 668 { 669 return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm)); 670 } 671 672 static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm) 673 { 674 return crypto_tfm_get_flags(crypto_cipher_tfm(tfm)); 675 } 676 677 static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm, 678 u32 flags) 679 { 680 crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags); 681 } 682 683 static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm, 684 u32 flags) 685 { 686 crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags); 687 } 688 689 static inline int crypto_cipher_setkey(struct crypto_cipher *tfm, 690 const u8 *key, unsigned int keylen) 691 { 692 return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm), 693 key, keylen); 694 } 695 696 static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm, 697 u8 *dst, const u8 *src) 698 { 699 crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm), 700 dst, src); 701 } 702 703 static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm, 704 u8 *dst, const u8 *src) 705 { 706 crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm), 707 dst, src); 708 } 709 710 void crypto_digest_init(struct crypto_tfm *tfm) __deprecated_for_modules; 711 void crypto_digest_update(struct crypto_tfm *tfm, 712 struct scatterlist *sg, unsigned int nsg) 713 __deprecated_for_modules; 714 void crypto_digest_final(struct crypto_tfm *tfm, u8 *out) 715 __deprecated_for_modules; 716 void crypto_digest_digest(struct crypto_tfm *tfm, 717 struct scatterlist *sg, unsigned int nsg, u8 *out) 718 __deprecated_for_modules; 719 720 static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm) 721 { 722 return (struct crypto_hash *)tfm; 723 } 724 725 static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm) 726 { 727 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_HASH) & 728 CRYPTO_ALG_TYPE_HASH_MASK); 729 return __crypto_hash_cast(tfm); 730 } 731 732 static int crypto_digest_setkey(struct crypto_tfm *tfm, const u8 *key, 733 unsigned int keylen) __deprecated; 734 static inline int crypto_digest_setkey(struct crypto_tfm *tfm, 735 const u8 *key, unsigned int keylen) 736 { 737 return tfm->crt_hash.setkey(crypto_hash_cast(tfm), key, keylen); 738 } 739 740 static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name, 741 u32 type, u32 mask) 742 { 743 type &= ~CRYPTO_ALG_TYPE_MASK; 744 type |= CRYPTO_ALG_TYPE_HASH; 745 mask |= CRYPTO_ALG_TYPE_HASH_MASK; 746 747 return __crypto_hash_cast(crypto_alloc_base(alg_name, type, mask)); 748 } 749 750 static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm) 751 { 752 return &tfm->base; 753 } 754 755 static inline void crypto_free_hash(struct crypto_hash *tfm) 756 { 757 crypto_free_tfm(crypto_hash_tfm(tfm)); 758 } 759 760 static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask) 761 { 762 type &= ~CRYPTO_ALG_TYPE_MASK; 763 type |= CRYPTO_ALG_TYPE_HASH; 764 mask |= CRYPTO_ALG_TYPE_HASH_MASK; 765 766 return crypto_has_alg(alg_name, type, mask); 767 } 768 769 static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm) 770 { 771 return &crypto_hash_tfm(tfm)->crt_hash; 772 } 773 774 static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm) 775 { 776 return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm)); 777 } 778 779 static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm) 780 { 781 return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm)); 782 } 783 784 static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm) 785 { 786 return crypto_hash_crt(tfm)->digestsize; 787 } 788 789 static inline u32 crypto_hash_get_flags(struct crypto_hash *tfm) 790 { 791 return crypto_tfm_get_flags(crypto_hash_tfm(tfm)); 792 } 793 794 static inline void crypto_hash_set_flags(struct crypto_hash *tfm, u32 flags) 795 { 796 crypto_tfm_set_flags(crypto_hash_tfm(tfm), flags); 797 } 798 799 static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags) 800 { 801 crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags); 802 } 803 804 static inline int crypto_hash_init(struct hash_desc *desc) 805 { 806 return crypto_hash_crt(desc->tfm)->init(desc); 807 } 808 809 static inline int crypto_hash_update(struct hash_desc *desc, 810 struct scatterlist *sg, 811 unsigned int nbytes) 812 { 813 return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes); 814 } 815 816 static inline int crypto_hash_final(struct hash_desc *desc, u8 *out) 817 { 818 return crypto_hash_crt(desc->tfm)->final(desc, out); 819 } 820 821 static inline int crypto_hash_digest(struct hash_desc *desc, 822 struct scatterlist *sg, 823 unsigned int nbytes, u8 *out) 824 { 825 return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out); 826 } 827 828 static inline int crypto_hash_setkey(struct crypto_hash *hash, 829 const u8 *key, unsigned int keylen) 830 { 831 return crypto_hash_crt(hash)->setkey(hash, key, keylen); 832 } 833 834 static int crypto_cipher_encrypt(struct crypto_tfm *tfm, 835 struct scatterlist *dst, 836 struct scatterlist *src, 837 unsigned int nbytes) __deprecated; 838 static inline int crypto_cipher_encrypt(struct crypto_tfm *tfm, 839 struct scatterlist *dst, 840 struct scatterlist *src, 841 unsigned int nbytes) 842 { 843 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 844 return tfm->crt_cipher.cit_encrypt(tfm, dst, src, nbytes); 845 } 846 847 static int crypto_cipher_encrypt_iv(struct crypto_tfm *tfm, 848 struct scatterlist *dst, 849 struct scatterlist *src, 850 unsigned int nbytes, u8 *iv) __deprecated; 851 static inline int crypto_cipher_encrypt_iv(struct crypto_tfm *tfm, 852 struct scatterlist *dst, 853 struct scatterlist *src, 854 unsigned int nbytes, u8 *iv) 855 { 856 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 857 return tfm->crt_cipher.cit_encrypt_iv(tfm, dst, src, nbytes, iv); 858 } 859 860 static int crypto_cipher_decrypt(struct crypto_tfm *tfm, 861 struct scatterlist *dst, 862 struct scatterlist *src, 863 unsigned int nbytes) __deprecated; 864 static inline int crypto_cipher_decrypt(struct crypto_tfm *tfm, 865 struct scatterlist *dst, 866 struct scatterlist *src, 867 unsigned int nbytes) 868 { 869 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 870 return tfm->crt_cipher.cit_decrypt(tfm, dst, src, nbytes); 871 } 872 873 static int crypto_cipher_decrypt_iv(struct crypto_tfm *tfm, 874 struct scatterlist *dst, 875 struct scatterlist *src, 876 unsigned int nbytes, u8 *iv) __deprecated; 877 static inline int crypto_cipher_decrypt_iv(struct crypto_tfm *tfm, 878 struct scatterlist *dst, 879 struct scatterlist *src, 880 unsigned int nbytes, u8 *iv) 881 { 882 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 883 return tfm->crt_cipher.cit_decrypt_iv(tfm, dst, src, nbytes, iv); 884 } 885 886 static void crypto_cipher_set_iv(struct crypto_tfm *tfm, 887 const u8 *src, unsigned int len) __deprecated; 888 static inline void crypto_cipher_set_iv(struct crypto_tfm *tfm, 889 const u8 *src, unsigned int len) 890 { 891 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 892 memcpy(tfm->crt_cipher.cit_iv, src, len); 893 } 894 895 static void crypto_cipher_get_iv(struct crypto_tfm *tfm, 896 u8 *dst, unsigned int len) __deprecated; 897 static inline void crypto_cipher_get_iv(struct crypto_tfm *tfm, 898 u8 *dst, unsigned int len) 899 { 900 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 901 memcpy(dst, tfm->crt_cipher.cit_iv, len); 902 } 903 904 static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm) 905 { 906 return (struct crypto_comp *)tfm; 907 } 908 909 static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm) 910 { 911 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) & 912 CRYPTO_ALG_TYPE_MASK); 913 return __crypto_comp_cast(tfm); 914 } 915 916 static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name, 917 u32 type, u32 mask) 918 { 919 type &= ~CRYPTO_ALG_TYPE_MASK; 920 type |= CRYPTO_ALG_TYPE_COMPRESS; 921 mask |= CRYPTO_ALG_TYPE_MASK; 922 923 return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask)); 924 } 925 926 static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm) 927 { 928 return tfm; 929 } 930 931 static inline void crypto_free_comp(struct crypto_comp *tfm) 932 { 933 crypto_free_tfm(crypto_comp_tfm(tfm)); 934 } 935 936 static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask) 937 { 938 type &= ~CRYPTO_ALG_TYPE_MASK; 939 type |= CRYPTO_ALG_TYPE_COMPRESS; 940 mask |= CRYPTO_ALG_TYPE_MASK; 941 942 return crypto_has_alg(alg_name, type, mask); 943 } 944 945 static inline const char *crypto_comp_name(struct crypto_comp *tfm) 946 { 947 return crypto_tfm_alg_name(crypto_comp_tfm(tfm)); 948 } 949 950 static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm) 951 { 952 return &crypto_comp_tfm(tfm)->crt_compress; 953 } 954 955 static inline int crypto_comp_compress(struct crypto_comp *tfm, 956 const u8 *src, unsigned int slen, 957 u8 *dst, unsigned int *dlen) 958 { 959 return crypto_comp_crt(tfm)->cot_compress(tfm, src, slen, dst, dlen); 960 } 961 962 static inline int crypto_comp_decompress(struct crypto_comp *tfm, 963 const u8 *src, unsigned int slen, 964 u8 *dst, unsigned int *dlen) 965 { 966 return crypto_comp_crt(tfm)->cot_decompress(tfm, src, slen, dst, dlen); 967 } 968 969 #endif /* _LINUX_CRYPTO_H */ 970 971