2 * Scatterlist Cryptographic API.
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>
8 * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
9 * and Nettle, by Niels Möller.
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)
17 #ifndef _LINUX_CRYPTO_H
18 #define _LINUX_CRYPTO_H
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>
29 * Algorithm masks and types.
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
38 #define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e
40 #define CRYPTO_ALG_LARVAL 0x00000010
41 #define CRYPTO_ALG_DEAD 0x00000020
42 #define CRYPTO_ALG_DYING 0x00000040
43 #define CRYPTO_ALG_ASYNC 0x00000080
46 * Set this bit if and only if the algorithm requires another algorithm of
47 * the same type to handle corner cases.
49 #define CRYPTO_ALG_NEED_FALLBACK 0x00000100
52 * Transform masks and values (for crt_flags).
54 #define CRYPTO_TFM_REQ_MASK 0x000fff00
55 #define CRYPTO_TFM_RES_MASK 0xfff00000
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
66 * Miscellaneous stuff.
68 #define CRYPTO_MAX_ALG_NAME 64
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.
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
84 #ifdef CRYPTO_MINALIGN
85 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
87 #define CRYPTO_MINALIGN_ATTR
91 struct crypto_blkcipher;
96 struct blkcipher_desc {
97 struct crypto_blkcipher *tfm;
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);
111 struct crypto_hash *tfm;
116 * Algorithms: modular crypto algorithm implementations, managed
117 * via crypto_register_alg() and crypto_unregister_alg().
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);
129 unsigned int min_keysize;
130 unsigned int max_keysize;
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);
144 unsigned int dia_digestsize;
145 void (*dia_init)(struct crypto_tfm *tfm);
146 void (*dia_update)(struct crypto_tfm *tfm, const u8 *data,
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);
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);
163 unsigned int digestsize;
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);
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
180 struct list_head cra_list;
181 struct list_head cra_users;
184 unsigned int cra_blocksize;
185 unsigned int cra_ctxsize;
186 unsigned int cra_alignmask;
191 char cra_name[CRYPTO_MAX_ALG_NAME];
192 char cra_driver_name[CRYPTO_MAX_ALG_NAME];
194 const struct crypto_type *cra_type;
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;
204 int (*cra_init)(struct crypto_tfm *tfm);
205 void (*cra_exit)(struct crypto_tfm *tfm);
206 void (*cra_destroy)(struct crypto_alg *alg);
208 struct module *cra_module;
212 * Algorithm registration interface.
214 int crypto_register_alg(struct crypto_alg *alg);
215 int crypto_unregister_alg(struct crypto_alg *alg);
218 * Algorithm query interface.
221 int crypto_has_alg(const char *name, u32 type, u32 mask);
223 static inline int crypto_has_alg(const char *name, u32 type, u32 mask)
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.
235 struct blkcipher_tfm {
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);
247 unsigned int cit_ivsize;
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);
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;
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);
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
303 struct blkcipher_tfm blkcipher;
304 struct cipher_tfm cipher;
305 struct hash_tfm hash;
306 struct compress_tfm compress;
309 struct crypto_alg *__crt_alg;
311 void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
314 #define crypto_cipher crypto_tfm
315 #define crypto_comp crypto_tfm
317 struct crypto_blkcipher {
318 struct crypto_tfm base;
322 struct crypto_tfm base;
330 struct crypto_attr_alg {
331 char name[CRYPTO_MAX_ALG_NAME];
335 * Transform user interface.
338 struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags);
339 struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask);
340 void crypto_free_tfm(struct crypto_tfm *tfm);
343 * Transform helpers which query the underlying algorithm.
345 static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
347 return tfm->__crt_alg->cra_name;
350 static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm)
352 return tfm->__crt_alg->cra_driver_name;
355 static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
357 return tfm->__crt_alg->cra_priority;
360 static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
362 return module_name(tfm->__crt_alg->cra_module);
365 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
367 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
370 static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
372 return tfm->__crt_alg->cra_blocksize;
375 static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
377 return tfm->__crt_alg->cra_alignmask;
380 static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm)
382 return tfm->crt_flags;
385 static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags)
387 tfm->crt_flags |= flags;
390 static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags)
392 tfm->crt_flags &= ~flags;
395 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
397 return tfm->__crt_ctx;
400 static inline unsigned int crypto_tfm_ctx_alignment(void)
402 struct crypto_tfm *tfm;
403 return __alignof__(tfm->__crt_ctx);
409 static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
410 struct crypto_tfm *tfm)
412 return (struct crypto_blkcipher *)tfm;
415 static inline struct crypto_blkcipher *crypto_blkcipher_cast(
416 struct crypto_tfm *tfm)
418 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER);
419 return __crypto_blkcipher_cast(tfm);
422 static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
423 const char *alg_name, u32 type, u32 mask)
425 type &= ~CRYPTO_ALG_TYPE_MASK;
426 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
427 mask |= CRYPTO_ALG_TYPE_MASK;
429 return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
432 static inline struct crypto_tfm *crypto_blkcipher_tfm(
433 struct crypto_blkcipher *tfm)
438 static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
440 crypto_free_tfm(crypto_blkcipher_tfm(tfm));
443 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
445 type &= ~CRYPTO_ALG_TYPE_MASK;
446 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
447 mask |= CRYPTO_ALG_TYPE_MASK;
449 return crypto_has_alg(alg_name, type, mask);
452 static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm)
454 return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm));
457 static inline struct blkcipher_tfm *crypto_blkcipher_crt(
458 struct crypto_blkcipher *tfm)
460 return &crypto_blkcipher_tfm(tfm)->crt_blkcipher;
463 static inline struct blkcipher_alg *crypto_blkcipher_alg(
464 struct crypto_blkcipher *tfm)
466 return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher;
469 static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm)
471 return crypto_blkcipher_alg(tfm)->ivsize;
474 static inline unsigned int crypto_blkcipher_blocksize(
475 struct crypto_blkcipher *tfm)
477 return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm));
480 static inline unsigned int crypto_blkcipher_alignmask(
481 struct crypto_blkcipher *tfm)
483 return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm));
486 static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm)
488 return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm));
491 static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm,
494 crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags);
497 static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm,
500 crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags);
503 static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
504 const u8 *key, unsigned int keylen)
506 return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm),
510 static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
511 struct scatterlist *dst,
512 struct scatterlist *src,
515 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
516 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
519 static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
520 struct scatterlist *dst,
521 struct scatterlist *src,
524 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
527 static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
528 struct scatterlist *dst,
529 struct scatterlist *src,
532 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
533 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
536 static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
537 struct scatterlist *dst,
538 struct scatterlist *src,
541 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
544 static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm,
545 const u8 *src, unsigned int len)
547 memcpy(crypto_blkcipher_crt(tfm)->iv, src, len);
550 static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm,
551 u8 *dst, unsigned int len)
553 memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len);
556 static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm)
558 return (struct crypto_cipher *)tfm;
561 static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm)
563 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
564 return __crypto_cipher_cast(tfm);
567 static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
570 type &= ~CRYPTO_ALG_TYPE_MASK;
571 type |= CRYPTO_ALG_TYPE_CIPHER;
572 mask |= CRYPTO_ALG_TYPE_MASK;
574 return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask));
577 static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm)
582 static inline void crypto_free_cipher(struct crypto_cipher *tfm)
584 crypto_free_tfm(crypto_cipher_tfm(tfm));
587 static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask)
589 type &= ~CRYPTO_ALG_TYPE_MASK;
590 type |= CRYPTO_ALG_TYPE_CIPHER;
591 mask |= CRYPTO_ALG_TYPE_MASK;
593 return crypto_has_alg(alg_name, type, mask);
596 static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm)
598 return &crypto_cipher_tfm(tfm)->crt_cipher;
601 static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm)
603 return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm));
606 static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm)
608 return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm));
611 static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm)
613 return crypto_tfm_get_flags(crypto_cipher_tfm(tfm));
616 static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm,
619 crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags);
622 static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,
625 crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags);
628 static inline int crypto_cipher_setkey(struct crypto_cipher *tfm,
629 const u8 *key, unsigned int keylen)
631 return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm),
635 static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
636 u8 *dst, const u8 *src)
638 crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm),
642 static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
643 u8 *dst, const u8 *src)
645 crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm),
649 static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm)
651 return (struct crypto_hash *)tfm;
654 static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm)
656 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_HASH) &
657 CRYPTO_ALG_TYPE_HASH_MASK);
658 return __crypto_hash_cast(tfm);
661 static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name,
664 type &= ~CRYPTO_ALG_TYPE_MASK;
665 type |= CRYPTO_ALG_TYPE_HASH;
666 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
668 return __crypto_hash_cast(crypto_alloc_base(alg_name, type, mask));
671 static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm)
676 static inline void crypto_free_hash(struct crypto_hash *tfm)
678 crypto_free_tfm(crypto_hash_tfm(tfm));
681 static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask)
683 type &= ~CRYPTO_ALG_TYPE_MASK;
684 type |= CRYPTO_ALG_TYPE_HASH;
685 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
687 return crypto_has_alg(alg_name, type, mask);
690 static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm)
692 return &crypto_hash_tfm(tfm)->crt_hash;
695 static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm)
697 return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm));
700 static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm)
702 return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm));
705 static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm)
707 return crypto_hash_crt(tfm)->digestsize;
710 static inline u32 crypto_hash_get_flags(struct crypto_hash *tfm)
712 return crypto_tfm_get_flags(crypto_hash_tfm(tfm));
715 static inline void crypto_hash_set_flags(struct crypto_hash *tfm, u32 flags)
717 crypto_tfm_set_flags(crypto_hash_tfm(tfm), flags);
720 static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags)
722 crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags);
725 static inline int crypto_hash_init(struct hash_desc *desc)
727 return crypto_hash_crt(desc->tfm)->init(desc);
730 static inline int crypto_hash_update(struct hash_desc *desc,
731 struct scatterlist *sg,
734 return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes);
737 static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
739 return crypto_hash_crt(desc->tfm)->final(desc, out);
742 static inline int crypto_hash_digest(struct hash_desc *desc,
743 struct scatterlist *sg,
744 unsigned int nbytes, u8 *out)
746 return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out);
749 static inline int crypto_hash_setkey(struct crypto_hash *hash,
750 const u8 *key, unsigned int keylen)
752 return crypto_hash_crt(hash)->setkey(hash, key, keylen);
755 static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm)
757 return (struct crypto_comp *)tfm;
760 static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm)
762 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) &
763 CRYPTO_ALG_TYPE_MASK);
764 return __crypto_comp_cast(tfm);
767 static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name,
770 type &= ~CRYPTO_ALG_TYPE_MASK;
771 type |= CRYPTO_ALG_TYPE_COMPRESS;
772 mask |= CRYPTO_ALG_TYPE_MASK;
774 return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask));
777 static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm)
782 static inline void crypto_free_comp(struct crypto_comp *tfm)
784 crypto_free_tfm(crypto_comp_tfm(tfm));
787 static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask)
789 type &= ~CRYPTO_ALG_TYPE_MASK;
790 type |= CRYPTO_ALG_TYPE_COMPRESS;
791 mask |= CRYPTO_ALG_TYPE_MASK;
793 return crypto_has_alg(alg_name, type, mask);
796 static inline const char *crypto_comp_name(struct crypto_comp *tfm)
798 return crypto_tfm_alg_name(crypto_comp_tfm(tfm));
801 static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm)
803 return &crypto_comp_tfm(tfm)->crt_compress;
806 static inline int crypto_comp_compress(struct crypto_comp *tfm,
807 const u8 *src, unsigned int slen,
808 u8 *dst, unsigned int *dlen)
810 return crypto_comp_crt(tfm)->cot_compress(tfm, src, slen, dst, dlen);
813 static inline int crypto_comp_decompress(struct crypto_comp *tfm,
814 const u8 *src, unsigned int slen,
815 u8 *dst, unsigned int *dlen)
817 return crypto_comp_crt(tfm)->cot_decompress(tfm, src, slen, dst, dlen);
820 #endif /* _LINUX_CRYPTO_H */