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_REQ_MASK 0x000fff00 55 #define CRYPTO_TFM_RES_MASK 0xfff00000 56 57 #define CRYPTO_TFM_REQ_WEAK_KEY 0x00000100 58 #define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200 59 #define CRYPTO_TFM_RES_WEAK_KEY 0x00100000 60 #define CRYPTO_TFM_RES_BAD_KEY_LEN 0x00200000 61 #define CRYPTO_TFM_RES_BAD_KEY_SCHED 0x00400000 62 #define CRYPTO_TFM_RES_BAD_BLOCK_LEN 0x00800000 63 #define CRYPTO_TFM_RES_BAD_FLAGS 0x01000000 64 65 /* 66 * Miscellaneous stuff. 67 */ 68 #define CRYPTO_MAX_ALG_NAME 64 69 70 /* 71 * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual 72 * declaration) is used to ensure that the crypto_tfm context structure is 73 * aligned correctly for the given architecture so that there are no alignment 74 * faults for C data types. In particular, this is required on platforms such 75 * as arm where pointers are 32-bit aligned but there are data types such as 76 * u64 which require 64-bit alignment. 77 */ 78 #if defined(ARCH_KMALLOC_MINALIGN) 79 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN 80 #elif defined(ARCH_SLAB_MINALIGN) 81 #define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN 82 #endif 83 84 #ifdef CRYPTO_MINALIGN 85 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN))) 86 #else 87 #define CRYPTO_MINALIGN_ATTR 88 #endif 89 90 struct scatterlist; 91 struct crypto_blkcipher; 92 struct crypto_hash; 93 struct crypto_tfm; 94 struct crypto_type; 95 96 struct blkcipher_desc { 97 struct crypto_blkcipher *tfm; 98 void *info; 99 u32 flags; 100 }; 101 102 struct cipher_desc { 103 struct crypto_tfm *tfm; 104 void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 105 unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst, 106 const u8 *src, unsigned int nbytes); 107 void *info; 108 }; 109 110 struct hash_desc { 111 struct crypto_hash *tfm; 112 u32 flags; 113 }; 114 115 /* 116 * Algorithms: modular crypto algorithm implementations, managed 117 * via crypto_register_alg() and crypto_unregister_alg(). 118 */ 119 struct blkcipher_alg { 120 int (*setkey)(struct crypto_tfm *tfm, const u8 *key, 121 unsigned int keylen); 122 int (*encrypt)(struct blkcipher_desc *desc, 123 struct scatterlist *dst, struct scatterlist *src, 124 unsigned int nbytes); 125 int (*decrypt)(struct blkcipher_desc *desc, 126 struct scatterlist *dst, struct scatterlist *src, 127 unsigned int nbytes); 128 129 unsigned int min_keysize; 130 unsigned int max_keysize; 131 unsigned int ivsize; 132 }; 133 134 struct cipher_alg { 135 unsigned int cia_min_keysize; 136 unsigned int cia_max_keysize; 137 int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key, 138 unsigned int keylen); 139 void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 140 void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 141 }; 142 143 struct digest_alg { 144 unsigned int dia_digestsize; 145 void (*dia_init)(struct crypto_tfm *tfm); 146 void (*dia_update)(struct crypto_tfm *tfm, const u8 *data, 147 unsigned int len); 148 void (*dia_final)(struct crypto_tfm *tfm, u8 *out); 149 int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key, 150 unsigned int keylen); 151 }; 152 153 struct hash_alg { 154 int (*init)(struct hash_desc *desc); 155 int (*update)(struct hash_desc *desc, struct scatterlist *sg, 156 unsigned int nbytes); 157 int (*final)(struct hash_desc *desc, u8 *out); 158 int (*digest)(struct hash_desc *desc, struct scatterlist *sg, 159 unsigned int nbytes, u8 *out); 160 int (*setkey)(struct crypto_hash *tfm, const u8 *key, 161 unsigned int keylen); 162 163 unsigned int digestsize; 164 }; 165 166 struct compress_alg { 167 int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src, 168 unsigned int slen, u8 *dst, unsigned int *dlen); 169 int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src, 170 unsigned int slen, u8 *dst, unsigned int *dlen); 171 }; 172 173 #define cra_blkcipher cra_u.blkcipher 174 #define cra_cipher cra_u.cipher 175 #define cra_digest cra_u.digest 176 #define cra_hash cra_u.hash 177 #define cra_compress cra_u.compress 178 179 struct crypto_alg { 180 struct list_head cra_list; 181 struct list_head cra_users; 182 183 u32 cra_flags; 184 unsigned int cra_blocksize; 185 unsigned int cra_ctxsize; 186 unsigned int cra_alignmask; 187 188 int cra_priority; 189 atomic_t cra_refcnt; 190 191 char cra_name[CRYPTO_MAX_ALG_NAME]; 192 char cra_driver_name[CRYPTO_MAX_ALG_NAME]; 193 194 const struct crypto_type *cra_type; 195 196 union { 197 struct blkcipher_alg blkcipher; 198 struct cipher_alg cipher; 199 struct digest_alg digest; 200 struct hash_alg hash; 201 struct compress_alg compress; 202 } cra_u; 203 204 int (*cra_init)(struct crypto_tfm *tfm); 205 void (*cra_exit)(struct crypto_tfm *tfm); 206 void (*cra_destroy)(struct crypto_alg *alg); 207 208 struct module *cra_module; 209 }; 210 211 /* 212 * Algorithm registration interface. 213 */ 214 int crypto_register_alg(struct crypto_alg *alg); 215 int crypto_unregister_alg(struct crypto_alg *alg); 216 217 /* 218 * Algorithm query interface. 219 */ 220 #ifdef CONFIG_CRYPTO 221 int crypto_has_alg(const char *name, u32 type, u32 mask); 222 #else 223 static inline int crypto_has_alg(const char *name, u32 type, u32 mask) 224 { 225 return 0; 226 } 227 #endif 228 229 /* 230 * Transforms: user-instantiated objects which encapsulate algorithms 231 * and core processing logic. Managed via crypto_alloc_*() and 232 * crypto_free_*(), as well as the various helpers below. 233 */ 234 235 struct blkcipher_tfm { 236 void *iv; 237 int (*setkey)(struct crypto_tfm *tfm, const u8 *key, 238 unsigned int keylen); 239 int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, 240 struct scatterlist *src, unsigned int nbytes); 241 int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, 242 struct scatterlist *src, unsigned int nbytes); 243 }; 244 245 struct cipher_tfm { 246 void *cit_iv; 247 unsigned int cit_ivsize; 248 u32 cit_mode; 249 int (*cit_setkey)(struct crypto_tfm *tfm, 250 const u8 *key, unsigned int keylen); 251 int (*cit_encrypt)(struct crypto_tfm *tfm, 252 struct scatterlist *dst, 253 struct scatterlist *src, 254 unsigned int nbytes); 255 int (*cit_encrypt_iv)(struct crypto_tfm *tfm, 256 struct scatterlist *dst, 257 struct scatterlist *src, 258 unsigned int nbytes, u8 *iv); 259 int (*cit_decrypt)(struct crypto_tfm *tfm, 260 struct scatterlist *dst, 261 struct scatterlist *src, 262 unsigned int nbytes); 263 int (*cit_decrypt_iv)(struct crypto_tfm *tfm, 264 struct scatterlist *dst, 265 struct scatterlist *src, 266 unsigned int nbytes, u8 *iv); 267 void (*cit_xor_block)(u8 *dst, const u8 *src); 268 void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 269 void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); 270 }; 271 272 struct hash_tfm { 273 int (*init)(struct hash_desc *desc); 274 int (*update)(struct hash_desc *desc, 275 struct scatterlist *sg, unsigned int nsg); 276 int (*final)(struct hash_desc *desc, u8 *out); 277 int (*digest)(struct hash_desc *desc, struct scatterlist *sg, 278 unsigned int nsg, u8 *out); 279 int (*setkey)(struct crypto_hash *tfm, const u8 *key, 280 unsigned int keylen); 281 unsigned int digestsize; 282 }; 283 284 struct compress_tfm { 285 int (*cot_compress)(struct crypto_tfm *tfm, 286 const u8 *src, unsigned int slen, 287 u8 *dst, unsigned int *dlen); 288 int (*cot_decompress)(struct crypto_tfm *tfm, 289 const u8 *src, unsigned int slen, 290 u8 *dst, unsigned int *dlen); 291 }; 292 293 #define crt_blkcipher crt_u.blkcipher 294 #define crt_cipher crt_u.cipher 295 #define crt_hash crt_u.hash 296 #define crt_compress crt_u.compress 297 298 struct crypto_tfm { 299 300 u32 crt_flags; 301 302 union { 303 struct blkcipher_tfm blkcipher; 304 struct cipher_tfm cipher; 305 struct hash_tfm hash; 306 struct compress_tfm compress; 307 } crt_u; 308 309 struct crypto_alg *__crt_alg; 310 311 void *__crt_ctx[] CRYPTO_MINALIGN_ATTR; 312 }; 313 314 struct crypto_blkcipher { 315 struct crypto_tfm base; 316 }; 317 318 struct crypto_cipher { 319 struct crypto_tfm base; 320 }; 321 322 struct crypto_comp { 323 struct crypto_tfm base; 324 }; 325 326 struct crypto_hash { 327 struct crypto_tfm base; 328 }; 329 330 enum { 331 CRYPTOA_UNSPEC, 332 CRYPTOA_ALG, 333 }; 334 335 struct crypto_attr_alg { 336 char name[CRYPTO_MAX_ALG_NAME]; 337 }; 338 339 /* 340 * Transform user interface. 341 */ 342 343 struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags); 344 struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask); 345 void crypto_free_tfm(struct crypto_tfm *tfm); 346 347 /* 348 * Transform helpers which query the underlying algorithm. 349 */ 350 static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm) 351 { 352 return tfm->__crt_alg->cra_name; 353 } 354 355 static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm) 356 { 357 return tfm->__crt_alg->cra_driver_name; 358 } 359 360 static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm) 361 { 362 return tfm->__crt_alg->cra_priority; 363 } 364 365 static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm) 366 { 367 return module_name(tfm->__crt_alg->cra_module); 368 } 369 370 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm) 371 { 372 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK; 373 } 374 375 static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm) 376 { 377 return tfm->__crt_alg->cra_blocksize; 378 } 379 380 static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm) 381 { 382 return tfm->__crt_alg->cra_alignmask; 383 } 384 385 static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm) 386 { 387 return tfm->crt_flags; 388 } 389 390 static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags) 391 { 392 tfm->crt_flags |= flags; 393 } 394 395 static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags) 396 { 397 tfm->crt_flags &= ~flags; 398 } 399 400 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm) 401 { 402 return tfm->__crt_ctx; 403 } 404 405 static inline unsigned int crypto_tfm_ctx_alignment(void) 406 { 407 struct crypto_tfm *tfm; 408 return __alignof__(tfm->__crt_ctx); 409 } 410 411 /* 412 * API wrappers. 413 */ 414 static inline struct crypto_blkcipher *__crypto_blkcipher_cast( 415 struct crypto_tfm *tfm) 416 { 417 return (struct crypto_blkcipher *)tfm; 418 } 419 420 static inline struct crypto_blkcipher *crypto_blkcipher_cast( 421 struct crypto_tfm *tfm) 422 { 423 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER); 424 return __crypto_blkcipher_cast(tfm); 425 } 426 427 static inline struct crypto_blkcipher *crypto_alloc_blkcipher( 428 const char *alg_name, u32 type, u32 mask) 429 { 430 type &= ~CRYPTO_ALG_TYPE_MASK; 431 type |= CRYPTO_ALG_TYPE_BLKCIPHER; 432 mask |= CRYPTO_ALG_TYPE_MASK; 433 434 return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask)); 435 } 436 437 static inline struct crypto_tfm *crypto_blkcipher_tfm( 438 struct crypto_blkcipher *tfm) 439 { 440 return &tfm->base; 441 } 442 443 static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm) 444 { 445 crypto_free_tfm(crypto_blkcipher_tfm(tfm)); 446 } 447 448 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask) 449 { 450 type &= ~CRYPTO_ALG_TYPE_MASK; 451 type |= CRYPTO_ALG_TYPE_BLKCIPHER; 452 mask |= CRYPTO_ALG_TYPE_MASK; 453 454 return crypto_has_alg(alg_name, type, mask); 455 } 456 457 static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm) 458 { 459 return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm)); 460 } 461 462 static inline struct blkcipher_tfm *crypto_blkcipher_crt( 463 struct crypto_blkcipher *tfm) 464 { 465 return &crypto_blkcipher_tfm(tfm)->crt_blkcipher; 466 } 467 468 static inline struct blkcipher_alg *crypto_blkcipher_alg( 469 struct crypto_blkcipher *tfm) 470 { 471 return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher; 472 } 473 474 static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm) 475 { 476 return crypto_blkcipher_alg(tfm)->ivsize; 477 } 478 479 static inline unsigned int crypto_blkcipher_blocksize( 480 struct crypto_blkcipher *tfm) 481 { 482 return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm)); 483 } 484 485 static inline unsigned int crypto_blkcipher_alignmask( 486 struct crypto_blkcipher *tfm) 487 { 488 return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm)); 489 } 490 491 static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm) 492 { 493 return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm)); 494 } 495 496 static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm, 497 u32 flags) 498 { 499 crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags); 500 } 501 502 static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm, 503 u32 flags) 504 { 505 crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags); 506 } 507 508 static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm, 509 const u8 *key, unsigned int keylen) 510 { 511 return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm), 512 key, keylen); 513 } 514 515 static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc, 516 struct scatterlist *dst, 517 struct scatterlist *src, 518 unsigned int nbytes) 519 { 520 desc->info = crypto_blkcipher_crt(desc->tfm)->iv; 521 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes); 522 } 523 524 static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc, 525 struct scatterlist *dst, 526 struct scatterlist *src, 527 unsigned int nbytes) 528 { 529 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes); 530 } 531 532 static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc, 533 struct scatterlist *dst, 534 struct scatterlist *src, 535 unsigned int nbytes) 536 { 537 desc->info = crypto_blkcipher_crt(desc->tfm)->iv; 538 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes); 539 } 540 541 static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc, 542 struct scatterlist *dst, 543 struct scatterlist *src, 544 unsigned int nbytes) 545 { 546 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes); 547 } 548 549 static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm, 550 const u8 *src, unsigned int len) 551 { 552 memcpy(crypto_blkcipher_crt(tfm)->iv, src, len); 553 } 554 555 static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm, 556 u8 *dst, unsigned int len) 557 { 558 memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len); 559 } 560 561 static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm) 562 { 563 return (struct crypto_cipher *)tfm; 564 } 565 566 static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm) 567 { 568 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); 569 return __crypto_cipher_cast(tfm); 570 } 571 572 static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name, 573 u32 type, u32 mask) 574 { 575 type &= ~CRYPTO_ALG_TYPE_MASK; 576 type |= CRYPTO_ALG_TYPE_CIPHER; 577 mask |= CRYPTO_ALG_TYPE_MASK; 578 579 return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask)); 580 } 581 582 static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm) 583 { 584 return &tfm->base; 585 } 586 587 static inline void crypto_free_cipher(struct crypto_cipher *tfm) 588 { 589 crypto_free_tfm(crypto_cipher_tfm(tfm)); 590 } 591 592 static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask) 593 { 594 type &= ~CRYPTO_ALG_TYPE_MASK; 595 type |= CRYPTO_ALG_TYPE_CIPHER; 596 mask |= CRYPTO_ALG_TYPE_MASK; 597 598 return crypto_has_alg(alg_name, type, mask); 599 } 600 601 static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm) 602 { 603 return &crypto_cipher_tfm(tfm)->crt_cipher; 604 } 605 606 static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm) 607 { 608 return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm)); 609 } 610 611 static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm) 612 { 613 return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm)); 614 } 615 616 static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm) 617 { 618 return crypto_tfm_get_flags(crypto_cipher_tfm(tfm)); 619 } 620 621 static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm, 622 u32 flags) 623 { 624 crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags); 625 } 626 627 static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm, 628 u32 flags) 629 { 630 crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags); 631 } 632 633 static inline int crypto_cipher_setkey(struct crypto_cipher *tfm, 634 const u8 *key, unsigned int keylen) 635 { 636 return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm), 637 key, keylen); 638 } 639 640 static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm, 641 u8 *dst, const u8 *src) 642 { 643 crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm), 644 dst, src); 645 } 646 647 static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm, 648 u8 *dst, const u8 *src) 649 { 650 crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm), 651 dst, src); 652 } 653 654 static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm) 655 { 656 return (struct crypto_hash *)tfm; 657 } 658 659 static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm) 660 { 661 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_HASH) & 662 CRYPTO_ALG_TYPE_HASH_MASK); 663 return __crypto_hash_cast(tfm); 664 } 665 666 static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name, 667 u32 type, u32 mask) 668 { 669 type &= ~CRYPTO_ALG_TYPE_MASK; 670 type |= CRYPTO_ALG_TYPE_HASH; 671 mask |= CRYPTO_ALG_TYPE_HASH_MASK; 672 673 return __crypto_hash_cast(crypto_alloc_base(alg_name, type, mask)); 674 } 675 676 static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm) 677 { 678 return &tfm->base; 679 } 680 681 static inline void crypto_free_hash(struct crypto_hash *tfm) 682 { 683 crypto_free_tfm(crypto_hash_tfm(tfm)); 684 } 685 686 static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask) 687 { 688 type &= ~CRYPTO_ALG_TYPE_MASK; 689 type |= CRYPTO_ALG_TYPE_HASH; 690 mask |= CRYPTO_ALG_TYPE_HASH_MASK; 691 692 return crypto_has_alg(alg_name, type, mask); 693 } 694 695 static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm) 696 { 697 return &crypto_hash_tfm(tfm)->crt_hash; 698 } 699 700 static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm) 701 { 702 return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm)); 703 } 704 705 static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm) 706 { 707 return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm)); 708 } 709 710 static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm) 711 { 712 return crypto_hash_crt(tfm)->digestsize; 713 } 714 715 static inline u32 crypto_hash_get_flags(struct crypto_hash *tfm) 716 { 717 return crypto_tfm_get_flags(crypto_hash_tfm(tfm)); 718 } 719 720 static inline void crypto_hash_set_flags(struct crypto_hash *tfm, u32 flags) 721 { 722 crypto_tfm_set_flags(crypto_hash_tfm(tfm), flags); 723 } 724 725 static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags) 726 { 727 crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags); 728 } 729 730 static inline int crypto_hash_init(struct hash_desc *desc) 731 { 732 return crypto_hash_crt(desc->tfm)->init(desc); 733 } 734 735 static inline int crypto_hash_update(struct hash_desc *desc, 736 struct scatterlist *sg, 737 unsigned int nbytes) 738 { 739 return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes); 740 } 741 742 static inline int crypto_hash_final(struct hash_desc *desc, u8 *out) 743 { 744 return crypto_hash_crt(desc->tfm)->final(desc, out); 745 } 746 747 static inline int crypto_hash_digest(struct hash_desc *desc, 748 struct scatterlist *sg, 749 unsigned int nbytes, u8 *out) 750 { 751 return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out); 752 } 753 754 static inline int crypto_hash_setkey(struct crypto_hash *hash, 755 const u8 *key, unsigned int keylen) 756 { 757 return crypto_hash_crt(hash)->setkey(hash, key, keylen); 758 } 759 760 static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm) 761 { 762 return (struct crypto_comp *)tfm; 763 } 764 765 static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm) 766 { 767 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) & 768 CRYPTO_ALG_TYPE_MASK); 769 return __crypto_comp_cast(tfm); 770 } 771 772 static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name, 773 u32 type, u32 mask) 774 { 775 type &= ~CRYPTO_ALG_TYPE_MASK; 776 type |= CRYPTO_ALG_TYPE_COMPRESS; 777 mask |= CRYPTO_ALG_TYPE_MASK; 778 779 return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask)); 780 } 781 782 static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm) 783 { 784 return &tfm->base; 785 } 786 787 static inline void crypto_free_comp(struct crypto_comp *tfm) 788 { 789 crypto_free_tfm(crypto_comp_tfm(tfm)); 790 } 791 792 static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask) 793 { 794 type &= ~CRYPTO_ALG_TYPE_MASK; 795 type |= CRYPTO_ALG_TYPE_COMPRESS; 796 mask |= CRYPTO_ALG_TYPE_MASK; 797 798 return crypto_has_alg(alg_name, type, mask); 799 } 800 801 static inline const char *crypto_comp_name(struct crypto_comp *tfm) 802 { 803 return crypto_tfm_alg_name(crypto_comp_tfm(tfm)); 804 } 805 806 static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm) 807 { 808 return &crypto_comp_tfm(tfm)->crt_compress; 809 } 810 811 static inline int crypto_comp_compress(struct crypto_comp *tfm, 812 const u8 *src, unsigned int slen, 813 u8 *dst, unsigned int *dlen) 814 { 815 return crypto_comp_crt(tfm)->cot_compress(crypto_comp_tfm(tfm), 816 src, slen, dst, dlen); 817 } 818 819 static inline int crypto_comp_decompress(struct crypto_comp *tfm, 820 const u8 *src, unsigned int slen, 821 u8 *dst, unsigned int *dlen) 822 { 823 return crypto_comp_crt(tfm)->cot_decompress(crypto_comp_tfm(tfm), 824 src, slen, dst, dlen); 825 } 826 827 #endif /* _LINUX_CRYPTO_H */ 828 829