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_ABLKCIPHER 0x00000005
37 #define CRYPTO_ALG_TYPE_GIVCIPHER 0x00000006
38 #define CRYPTO_ALG_TYPE_COMPRESS 0x00000008
39 #define CRYPTO_ALG_TYPE_AEAD 0x00000009
41 #define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e
42 #define CRYPTO_ALG_TYPE_BLKCIPHER_MASK 0x0000000c
44 #define CRYPTO_ALG_LARVAL 0x00000010
45 #define CRYPTO_ALG_DEAD 0x00000020
46 #define CRYPTO_ALG_DYING 0x00000040
47 #define CRYPTO_ALG_ASYNC 0x00000080
50 * Set this bit if and only if the algorithm requires another algorithm of
51 * the same type to handle corner cases.
53 #define CRYPTO_ALG_NEED_FALLBACK 0x00000100
56 * Transform masks and values (for crt_flags).
58 #define CRYPTO_TFM_REQ_MASK 0x000fff00
59 #define CRYPTO_TFM_RES_MASK 0xfff00000
61 #define CRYPTO_TFM_REQ_WEAK_KEY 0x00000100
62 #define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200
63 #define CRYPTO_TFM_REQ_MAY_BACKLOG 0x00000400
64 #define CRYPTO_TFM_RES_WEAK_KEY 0x00100000
65 #define CRYPTO_TFM_RES_BAD_KEY_LEN 0x00200000
66 #define CRYPTO_TFM_RES_BAD_KEY_SCHED 0x00400000
67 #define CRYPTO_TFM_RES_BAD_BLOCK_LEN 0x00800000
68 #define CRYPTO_TFM_RES_BAD_FLAGS 0x01000000
71 * Miscellaneous stuff.
73 #define CRYPTO_MAX_ALG_NAME 64
76 * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual
77 * declaration) is used to ensure that the crypto_tfm context structure is
78 * aligned correctly for the given architecture so that there are no alignment
79 * faults for C data types. In particular, this is required on platforms such
80 * as arm where pointers are 32-bit aligned but there are data types such as
81 * u64 which require 64-bit alignment.
83 #if defined(ARCH_KMALLOC_MINALIGN)
84 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
85 #elif defined(ARCH_SLAB_MINALIGN)
86 #define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN
89 #ifdef CRYPTO_MINALIGN
90 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
92 #define CRYPTO_MINALIGN_ATTR
96 struct crypto_ablkcipher;
97 struct crypto_async_request;
99 struct crypto_blkcipher;
103 struct skcipher_givcrypt_request;
105 typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
107 struct crypto_async_request {
108 struct list_head list;
109 crypto_completion_t complete;
111 struct crypto_tfm *tfm;
116 struct ablkcipher_request {
117 struct crypto_async_request base;
123 struct scatterlist *src;
124 struct scatterlist *dst;
126 void *__ctx[] CRYPTO_MINALIGN_ATTR;
130 * struct aead_request - AEAD request
131 * @base: Common attributes for async crypto requests
132 * @assoclen: Length in bytes of associated data for authentication
133 * @cryptlen: Length of data to be encrypted or decrypted
134 * @iv: Initialisation vector
135 * @assoc: Associated data
137 * @dst: Destination data
138 * @__ctx: Start of private context data
140 struct aead_request {
141 struct crypto_async_request base;
143 unsigned int assoclen;
144 unsigned int cryptlen;
148 struct scatterlist *assoc;
149 struct scatterlist *src;
150 struct scatterlist *dst;
152 void *__ctx[] CRYPTO_MINALIGN_ATTR;
155 struct blkcipher_desc {
156 struct crypto_blkcipher *tfm;
162 struct crypto_tfm *tfm;
163 void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
164 unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,
165 const u8 *src, unsigned int nbytes);
170 struct crypto_hash *tfm;
175 * Algorithms: modular crypto algorithm implementations, managed
176 * via crypto_register_alg() and crypto_unregister_alg().
178 struct ablkcipher_alg {
179 int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
180 unsigned int keylen);
181 int (*encrypt)(struct ablkcipher_request *req);
182 int (*decrypt)(struct ablkcipher_request *req);
183 int (*givencrypt)(struct skcipher_givcrypt_request *req);
184 int (*givdecrypt)(struct skcipher_givcrypt_request *req);
188 unsigned int min_keysize;
189 unsigned int max_keysize;
194 int (*setkey)(struct crypto_aead *tfm, const u8 *key,
195 unsigned int keylen);
196 int (*setauthsize)(struct crypto_aead *tfm, unsigned int authsize);
197 int (*encrypt)(struct aead_request *req);
198 int (*decrypt)(struct aead_request *req);
201 unsigned int maxauthsize;
204 struct blkcipher_alg {
205 int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
206 unsigned int keylen);
207 int (*encrypt)(struct blkcipher_desc *desc,
208 struct scatterlist *dst, struct scatterlist *src,
209 unsigned int nbytes);
210 int (*decrypt)(struct blkcipher_desc *desc,
211 struct scatterlist *dst, struct scatterlist *src,
212 unsigned int nbytes);
216 unsigned int min_keysize;
217 unsigned int max_keysize;
222 unsigned int cia_min_keysize;
223 unsigned int cia_max_keysize;
224 int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
225 unsigned int keylen);
226 void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
227 void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
231 unsigned int dia_digestsize;
232 void (*dia_init)(struct crypto_tfm *tfm);
233 void (*dia_update)(struct crypto_tfm *tfm, const u8 *data,
235 void (*dia_final)(struct crypto_tfm *tfm, u8 *out);
236 int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key,
237 unsigned int keylen);
241 int (*init)(struct hash_desc *desc);
242 int (*update)(struct hash_desc *desc, struct scatterlist *sg,
243 unsigned int nbytes);
244 int (*final)(struct hash_desc *desc, u8 *out);
245 int (*digest)(struct hash_desc *desc, struct scatterlist *sg,
246 unsigned int nbytes, u8 *out);
247 int (*setkey)(struct crypto_hash *tfm, const u8 *key,
248 unsigned int keylen);
250 unsigned int digestsize;
253 struct compress_alg {
254 int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,
255 unsigned int slen, u8 *dst, unsigned int *dlen);
256 int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src,
257 unsigned int slen, u8 *dst, unsigned int *dlen);
260 #define cra_ablkcipher cra_u.ablkcipher
261 #define cra_aead cra_u.aead
262 #define cra_blkcipher cra_u.blkcipher
263 #define cra_cipher cra_u.cipher
264 #define cra_digest cra_u.digest
265 #define cra_hash cra_u.hash
266 #define cra_compress cra_u.compress
269 struct list_head cra_list;
270 struct list_head cra_users;
273 unsigned int cra_blocksize;
274 unsigned int cra_ctxsize;
275 unsigned int cra_alignmask;
280 char cra_name[CRYPTO_MAX_ALG_NAME];
281 char cra_driver_name[CRYPTO_MAX_ALG_NAME];
283 const struct crypto_type *cra_type;
286 struct ablkcipher_alg ablkcipher;
287 struct aead_alg aead;
288 struct blkcipher_alg blkcipher;
289 struct cipher_alg cipher;
290 struct digest_alg digest;
291 struct hash_alg hash;
292 struct compress_alg compress;
295 int (*cra_init)(struct crypto_tfm *tfm);
296 void (*cra_exit)(struct crypto_tfm *tfm);
297 void (*cra_destroy)(struct crypto_alg *alg);
299 struct module *cra_module;
303 * Algorithm registration interface.
305 int crypto_register_alg(struct crypto_alg *alg);
306 int crypto_unregister_alg(struct crypto_alg *alg);
309 * Algorithm query interface.
312 int crypto_has_alg(const char *name, u32 type, u32 mask);
314 static inline int crypto_has_alg(const char *name, u32 type, u32 mask)
321 * Transforms: user-instantiated objects which encapsulate algorithms
322 * and core processing logic. Managed via crypto_alloc_*() and
323 * crypto_free_*(), as well as the various helpers below.
326 struct ablkcipher_tfm {
327 int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
328 unsigned int keylen);
329 int (*encrypt)(struct ablkcipher_request *req);
330 int (*decrypt)(struct ablkcipher_request *req);
331 int (*givencrypt)(struct skcipher_givcrypt_request *req);
332 int (*givdecrypt)(struct skcipher_givcrypt_request *req);
335 unsigned int reqsize;
339 int (*setkey)(struct crypto_aead *tfm, const u8 *key,
340 unsigned int keylen);
341 int (*encrypt)(struct aead_request *req);
342 int (*decrypt)(struct aead_request *req);
344 unsigned int authsize;
345 unsigned int reqsize;
348 struct blkcipher_tfm {
350 int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
351 unsigned int keylen);
352 int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,
353 struct scatterlist *src, unsigned int nbytes);
354 int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,
355 struct scatterlist *src, unsigned int nbytes);
359 int (*cit_setkey)(struct crypto_tfm *tfm,
360 const u8 *key, unsigned int keylen);
361 void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
362 void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
366 int (*init)(struct hash_desc *desc);
367 int (*update)(struct hash_desc *desc,
368 struct scatterlist *sg, unsigned int nsg);
369 int (*final)(struct hash_desc *desc, u8 *out);
370 int (*digest)(struct hash_desc *desc, struct scatterlist *sg,
371 unsigned int nsg, u8 *out);
372 int (*setkey)(struct crypto_hash *tfm, const u8 *key,
373 unsigned int keylen);
374 unsigned int digestsize;
377 struct compress_tfm {
378 int (*cot_compress)(struct crypto_tfm *tfm,
379 const u8 *src, unsigned int slen,
380 u8 *dst, unsigned int *dlen);
381 int (*cot_decompress)(struct crypto_tfm *tfm,
382 const u8 *src, unsigned int slen,
383 u8 *dst, unsigned int *dlen);
386 #define crt_ablkcipher crt_u.ablkcipher
387 #define crt_aead crt_u.aead
388 #define crt_blkcipher crt_u.blkcipher
389 #define crt_cipher crt_u.cipher
390 #define crt_hash crt_u.hash
391 #define crt_compress crt_u.compress
398 struct ablkcipher_tfm ablkcipher;
399 struct aead_tfm aead;
400 struct blkcipher_tfm blkcipher;
401 struct cipher_tfm cipher;
402 struct hash_tfm hash;
403 struct compress_tfm compress;
406 struct crypto_alg *__crt_alg;
408 void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
411 struct crypto_ablkcipher {
412 struct crypto_tfm base;
416 struct crypto_tfm base;
419 struct crypto_blkcipher {
420 struct crypto_tfm base;
423 struct crypto_cipher {
424 struct crypto_tfm base;
428 struct crypto_tfm base;
432 struct crypto_tfm base;
443 #define CRYPTOA_MAX (__CRYPTOA_MAX - 1)
445 /* Maximum number of (rtattr) parameters for each template. */
446 #define CRYPTO_MAX_ATTRS 32
448 struct crypto_attr_alg {
449 char name[CRYPTO_MAX_ALG_NAME];
452 struct crypto_attr_type {
457 struct crypto_attr_u32 {
462 * Transform user interface.
465 struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags);
466 struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask);
467 void crypto_free_tfm(struct crypto_tfm *tfm);
470 * Transform helpers which query the underlying algorithm.
472 static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
474 return tfm->__crt_alg->cra_name;
477 static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm)
479 return tfm->__crt_alg->cra_driver_name;
482 static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
484 return tfm->__crt_alg->cra_priority;
487 static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
489 return module_name(tfm->__crt_alg->cra_module);
492 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
494 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
497 static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
499 return tfm->__crt_alg->cra_blocksize;
502 static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
504 return tfm->__crt_alg->cra_alignmask;
507 static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm)
509 return tfm->crt_flags;
512 static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags)
514 tfm->crt_flags |= flags;
517 static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags)
519 tfm->crt_flags &= ~flags;
522 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
524 return tfm->__crt_ctx;
527 static inline unsigned int crypto_tfm_ctx_alignment(void)
529 struct crypto_tfm *tfm;
530 return __alignof__(tfm->__crt_ctx);
536 static inline struct crypto_ablkcipher *__crypto_ablkcipher_cast(
537 struct crypto_tfm *tfm)
539 return (struct crypto_ablkcipher *)tfm;
542 static inline u32 crypto_skcipher_type(u32 type)
544 type &= ~CRYPTO_ALG_TYPE_MASK;
545 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
549 static inline u32 crypto_skcipher_mask(u32 mask)
551 mask &= ~CRYPTO_ALG_TYPE_MASK;
552 mask |= CRYPTO_ALG_TYPE_BLKCIPHER_MASK;
556 static inline struct crypto_ablkcipher *crypto_alloc_ablkcipher(
557 const char *alg_name, u32 type, u32 mask)
559 return __crypto_ablkcipher_cast(
560 crypto_alloc_base(alg_name, crypto_skcipher_type(type),
561 crypto_skcipher_mask(mask)));
564 static inline struct crypto_tfm *crypto_ablkcipher_tfm(
565 struct crypto_ablkcipher *tfm)
570 static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm)
572 crypto_free_tfm(crypto_ablkcipher_tfm(tfm));
575 static inline int crypto_has_ablkcipher(const char *alg_name, u32 type,
578 return crypto_has_alg(alg_name, crypto_skcipher_type(type),
579 crypto_skcipher_mask(mask));
582 static inline struct ablkcipher_tfm *crypto_ablkcipher_crt(
583 struct crypto_ablkcipher *tfm)
585 return &crypto_ablkcipher_tfm(tfm)->crt_ablkcipher;
588 static inline unsigned int crypto_ablkcipher_ivsize(
589 struct crypto_ablkcipher *tfm)
591 return crypto_ablkcipher_crt(tfm)->ivsize;
594 static inline unsigned int crypto_ablkcipher_blocksize(
595 struct crypto_ablkcipher *tfm)
597 return crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(tfm));
600 static inline unsigned int crypto_ablkcipher_alignmask(
601 struct crypto_ablkcipher *tfm)
603 return crypto_tfm_alg_alignmask(crypto_ablkcipher_tfm(tfm));
606 static inline u32 crypto_ablkcipher_get_flags(struct crypto_ablkcipher *tfm)
608 return crypto_tfm_get_flags(crypto_ablkcipher_tfm(tfm));
611 static inline void crypto_ablkcipher_set_flags(struct crypto_ablkcipher *tfm,
614 crypto_tfm_set_flags(crypto_ablkcipher_tfm(tfm), flags);
617 static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm,
620 crypto_tfm_clear_flags(crypto_ablkcipher_tfm(tfm), flags);
623 static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
624 const u8 *key, unsigned int keylen)
626 return crypto_ablkcipher_crt(tfm)->setkey(tfm, key, keylen);
629 static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
630 struct ablkcipher_request *req)
632 return __crypto_ablkcipher_cast(req->base.tfm);
635 static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
637 struct ablkcipher_tfm *crt =
638 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
639 return crt->encrypt(req);
642 static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
644 struct ablkcipher_tfm *crt =
645 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
646 return crt->decrypt(req);
649 static inline unsigned int crypto_ablkcipher_reqsize(
650 struct crypto_ablkcipher *tfm)
652 return crypto_ablkcipher_crt(tfm)->reqsize;
655 static inline void ablkcipher_request_set_tfm(
656 struct ablkcipher_request *req, struct crypto_ablkcipher *tfm)
658 req->base.tfm = crypto_ablkcipher_tfm(tfm);
661 static inline struct ablkcipher_request *ablkcipher_request_cast(
662 struct crypto_async_request *req)
664 return container_of(req, struct ablkcipher_request, base);
667 static inline struct ablkcipher_request *ablkcipher_request_alloc(
668 struct crypto_ablkcipher *tfm, gfp_t gfp)
670 struct ablkcipher_request *req;
672 req = kmalloc(sizeof(struct ablkcipher_request) +
673 crypto_ablkcipher_reqsize(tfm), gfp);
676 ablkcipher_request_set_tfm(req, tfm);
681 static inline void ablkcipher_request_free(struct ablkcipher_request *req)
686 static inline void ablkcipher_request_set_callback(
687 struct ablkcipher_request *req,
688 u32 flags, crypto_completion_t complete, void *data)
690 req->base.complete = complete;
691 req->base.data = data;
692 req->base.flags = flags;
695 static inline void ablkcipher_request_set_crypt(
696 struct ablkcipher_request *req,
697 struct scatterlist *src, struct scatterlist *dst,
698 unsigned int nbytes, void *iv)
702 req->nbytes = nbytes;
706 static inline struct crypto_aead *__crypto_aead_cast(struct crypto_tfm *tfm)
708 return (struct crypto_aead *)tfm;
711 static inline struct crypto_aead *crypto_alloc_aead(const char *alg_name,
714 type &= ~CRYPTO_ALG_TYPE_MASK;
715 type |= CRYPTO_ALG_TYPE_AEAD;
716 mask |= CRYPTO_ALG_TYPE_MASK;
718 return __crypto_aead_cast(crypto_alloc_base(alg_name, type, mask));
721 static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm)
726 static inline void crypto_free_aead(struct crypto_aead *tfm)
728 crypto_free_tfm(crypto_aead_tfm(tfm));
731 static inline struct aead_tfm *crypto_aead_crt(struct crypto_aead *tfm)
733 return &crypto_aead_tfm(tfm)->crt_aead;
736 static inline unsigned int crypto_aead_ivsize(struct crypto_aead *tfm)
738 return crypto_aead_crt(tfm)->ivsize;
741 static inline unsigned int crypto_aead_authsize(struct crypto_aead *tfm)
743 return crypto_aead_crt(tfm)->authsize;
746 static inline unsigned int crypto_aead_blocksize(struct crypto_aead *tfm)
748 return crypto_tfm_alg_blocksize(crypto_aead_tfm(tfm));
751 static inline unsigned int crypto_aead_alignmask(struct crypto_aead *tfm)
753 return crypto_tfm_alg_alignmask(crypto_aead_tfm(tfm));
756 static inline u32 crypto_aead_get_flags(struct crypto_aead *tfm)
758 return crypto_tfm_get_flags(crypto_aead_tfm(tfm));
761 static inline void crypto_aead_set_flags(struct crypto_aead *tfm, u32 flags)
763 crypto_tfm_set_flags(crypto_aead_tfm(tfm), flags);
766 static inline void crypto_aead_clear_flags(struct crypto_aead *tfm, u32 flags)
768 crypto_tfm_clear_flags(crypto_aead_tfm(tfm), flags);
771 static inline int crypto_aead_setkey(struct crypto_aead *tfm, const u8 *key,
774 return crypto_aead_crt(tfm)->setkey(tfm, key, keylen);
777 int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize);
779 static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
781 return __crypto_aead_cast(req->base.tfm);
784 static inline int crypto_aead_encrypt(struct aead_request *req)
786 return crypto_aead_crt(crypto_aead_reqtfm(req))->encrypt(req);
789 static inline int crypto_aead_decrypt(struct aead_request *req)
791 return crypto_aead_crt(crypto_aead_reqtfm(req))->decrypt(req);
794 static inline unsigned int crypto_aead_reqsize(struct crypto_aead *tfm)
796 return crypto_aead_crt(tfm)->reqsize;
799 static inline void aead_request_set_tfm(struct aead_request *req,
800 struct crypto_aead *tfm)
802 req->base.tfm = crypto_aead_tfm(tfm);
805 static inline struct aead_request *aead_request_alloc(struct crypto_aead *tfm,
808 struct aead_request *req;
810 req = kmalloc(sizeof(*req) + crypto_aead_reqsize(tfm), gfp);
813 aead_request_set_tfm(req, tfm);
818 static inline void aead_request_free(struct aead_request *req)
823 static inline void aead_request_set_callback(struct aead_request *req,
825 crypto_completion_t complete,
828 req->base.complete = complete;
829 req->base.data = data;
830 req->base.flags = flags;
833 static inline void aead_request_set_crypt(struct aead_request *req,
834 struct scatterlist *src,
835 struct scatterlist *dst,
836 unsigned int cryptlen, u8 *iv)
840 req->cryptlen = cryptlen;
844 static inline void aead_request_set_assoc(struct aead_request *req,
845 struct scatterlist *assoc,
846 unsigned int assoclen)
849 req->assoclen = assoclen;
852 static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
853 struct crypto_tfm *tfm)
855 return (struct crypto_blkcipher *)tfm;
858 static inline struct crypto_blkcipher *crypto_blkcipher_cast(
859 struct crypto_tfm *tfm)
861 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER);
862 return __crypto_blkcipher_cast(tfm);
865 static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
866 const char *alg_name, u32 type, u32 mask)
868 type &= ~CRYPTO_ALG_TYPE_MASK;
869 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
870 mask |= CRYPTO_ALG_TYPE_MASK;
872 return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
875 static inline struct crypto_tfm *crypto_blkcipher_tfm(
876 struct crypto_blkcipher *tfm)
881 static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
883 crypto_free_tfm(crypto_blkcipher_tfm(tfm));
886 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
888 type &= ~CRYPTO_ALG_TYPE_MASK;
889 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
890 mask |= CRYPTO_ALG_TYPE_MASK;
892 return crypto_has_alg(alg_name, type, mask);
895 static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm)
897 return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm));
900 static inline struct blkcipher_tfm *crypto_blkcipher_crt(
901 struct crypto_blkcipher *tfm)
903 return &crypto_blkcipher_tfm(tfm)->crt_blkcipher;
906 static inline struct blkcipher_alg *crypto_blkcipher_alg(
907 struct crypto_blkcipher *tfm)
909 return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher;
912 static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm)
914 return crypto_blkcipher_alg(tfm)->ivsize;
917 static inline unsigned int crypto_blkcipher_blocksize(
918 struct crypto_blkcipher *tfm)
920 return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm));
923 static inline unsigned int crypto_blkcipher_alignmask(
924 struct crypto_blkcipher *tfm)
926 return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm));
929 static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm)
931 return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm));
934 static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm,
937 crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags);
940 static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm,
943 crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags);
946 static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
947 const u8 *key, unsigned int keylen)
949 return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm),
953 static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
954 struct scatterlist *dst,
955 struct scatterlist *src,
958 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
959 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
962 static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
963 struct scatterlist *dst,
964 struct scatterlist *src,
967 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
970 static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
971 struct scatterlist *dst,
972 struct scatterlist *src,
975 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
976 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
979 static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
980 struct scatterlist *dst,
981 struct scatterlist *src,
984 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
987 static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm,
988 const u8 *src, unsigned int len)
990 memcpy(crypto_blkcipher_crt(tfm)->iv, src, len);
993 static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm,
994 u8 *dst, unsigned int len)
996 memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len);
999 static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm)
1001 return (struct crypto_cipher *)tfm;
1004 static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm)
1006 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
1007 return __crypto_cipher_cast(tfm);
1010 static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
1013 type &= ~CRYPTO_ALG_TYPE_MASK;
1014 type |= CRYPTO_ALG_TYPE_CIPHER;
1015 mask |= CRYPTO_ALG_TYPE_MASK;
1017 return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask));
1020 static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm)
1025 static inline void crypto_free_cipher(struct crypto_cipher *tfm)
1027 crypto_free_tfm(crypto_cipher_tfm(tfm));
1030 static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask)
1032 type &= ~CRYPTO_ALG_TYPE_MASK;
1033 type |= CRYPTO_ALG_TYPE_CIPHER;
1034 mask |= CRYPTO_ALG_TYPE_MASK;
1036 return crypto_has_alg(alg_name, type, mask);
1039 static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm)
1041 return &crypto_cipher_tfm(tfm)->crt_cipher;
1044 static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm)
1046 return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm));
1049 static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm)
1051 return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm));
1054 static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm)
1056 return crypto_tfm_get_flags(crypto_cipher_tfm(tfm));
1059 static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm,
1062 crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags);
1065 static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,
1068 crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags);
1071 static inline int crypto_cipher_setkey(struct crypto_cipher *tfm,
1072 const u8 *key, unsigned int keylen)
1074 return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm),
1078 static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
1079 u8 *dst, const u8 *src)
1081 crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm),
1085 static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
1086 u8 *dst, const u8 *src)
1088 crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm),
1092 static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm)
1094 return (struct crypto_hash *)tfm;
1097 static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm)
1099 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_HASH) &
1100 CRYPTO_ALG_TYPE_HASH_MASK);
1101 return __crypto_hash_cast(tfm);
1104 static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name,
1107 type &= ~CRYPTO_ALG_TYPE_MASK;
1108 mask &= ~CRYPTO_ALG_TYPE_MASK;
1109 type |= CRYPTO_ALG_TYPE_HASH;
1110 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
1112 return __crypto_hash_cast(crypto_alloc_base(alg_name, type, mask));
1115 static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm)
1120 static inline void crypto_free_hash(struct crypto_hash *tfm)
1122 crypto_free_tfm(crypto_hash_tfm(tfm));
1125 static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask)
1127 type &= ~CRYPTO_ALG_TYPE_MASK;
1128 mask &= ~CRYPTO_ALG_TYPE_MASK;
1129 type |= CRYPTO_ALG_TYPE_HASH;
1130 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
1132 return crypto_has_alg(alg_name, type, mask);
1135 static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm)
1137 return &crypto_hash_tfm(tfm)->crt_hash;
1140 static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm)
1142 return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm));
1145 static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm)
1147 return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm));
1150 static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm)
1152 return crypto_hash_crt(tfm)->digestsize;
1155 static inline u32 crypto_hash_get_flags(struct crypto_hash *tfm)
1157 return crypto_tfm_get_flags(crypto_hash_tfm(tfm));
1160 static inline void crypto_hash_set_flags(struct crypto_hash *tfm, u32 flags)
1162 crypto_tfm_set_flags(crypto_hash_tfm(tfm), flags);
1165 static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags)
1167 crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags);
1170 static inline int crypto_hash_init(struct hash_desc *desc)
1172 return crypto_hash_crt(desc->tfm)->init(desc);
1175 static inline int crypto_hash_update(struct hash_desc *desc,
1176 struct scatterlist *sg,
1177 unsigned int nbytes)
1179 return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes);
1182 static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
1184 return crypto_hash_crt(desc->tfm)->final(desc, out);
1187 static inline int crypto_hash_digest(struct hash_desc *desc,
1188 struct scatterlist *sg,
1189 unsigned int nbytes, u8 *out)
1191 return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out);
1194 static inline int crypto_hash_setkey(struct crypto_hash *hash,
1195 const u8 *key, unsigned int keylen)
1197 return crypto_hash_crt(hash)->setkey(hash, key, keylen);
1200 static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm)
1202 return (struct crypto_comp *)tfm;
1205 static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm)
1207 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) &
1208 CRYPTO_ALG_TYPE_MASK);
1209 return __crypto_comp_cast(tfm);
1212 static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name,
1215 type &= ~CRYPTO_ALG_TYPE_MASK;
1216 type |= CRYPTO_ALG_TYPE_COMPRESS;
1217 mask |= CRYPTO_ALG_TYPE_MASK;
1219 return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask));
1222 static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm)
1227 static inline void crypto_free_comp(struct crypto_comp *tfm)
1229 crypto_free_tfm(crypto_comp_tfm(tfm));
1232 static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask)
1234 type &= ~CRYPTO_ALG_TYPE_MASK;
1235 type |= CRYPTO_ALG_TYPE_COMPRESS;
1236 mask |= CRYPTO_ALG_TYPE_MASK;
1238 return crypto_has_alg(alg_name, type, mask);
1241 static inline const char *crypto_comp_name(struct crypto_comp *tfm)
1243 return crypto_tfm_alg_name(crypto_comp_tfm(tfm));
1246 static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm)
1248 return &crypto_comp_tfm(tfm)->crt_compress;
1251 static inline int crypto_comp_compress(struct crypto_comp *tfm,
1252 const u8 *src, unsigned int slen,
1253 u8 *dst, unsigned int *dlen)
1255 return crypto_comp_crt(tfm)->cot_compress(crypto_comp_tfm(tfm),
1256 src, slen, dst, dlen);
1259 static inline int crypto_comp_decompress(struct crypto_comp *tfm,
1260 const u8 *src, unsigned int slen,
1261 u8 *dst, unsigned int *dlen)
1263 return crypto_comp_crt(tfm)->cot_decompress(crypto_comp_tfm(tfm),
1264 src, slen, dst, dlen);
1267 #endif /* _LINUX_CRYPTO_H */