include/linux/crypto.h

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