blob: 95936a5e7c12cf78463b94ab34acc0f24386b093 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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)
Herbert Xu5cb14542005-11-05 16:58:14 +11006 * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
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
Herbert Xu6521f302006-08-06 20:28:44 +100020#include <asm/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/module.h>
22#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/list.h>
Herbert Xu79911102006-08-21 21:03:52 +100024#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/string.h>
Herbert Xu79911102006-08-21 21:03:52 +100026#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
28/*
29 * Algorithm masks and types.
30 */
Herbert Xu28259822006-08-06 21:23:26 +100031#define CRYPTO_ALG_TYPE_MASK 0x0000000f
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#define CRYPTO_ALG_TYPE_CIPHER 0x00000001
33#define CRYPTO_ALG_TYPE_DIGEST 0x00000002
Herbert Xu055bcee2006-08-19 22:24:23 +100034#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Herbert Xu28259822006-08-06 21:23:26 +100040#define CRYPTO_ALG_LARVAL 0x00000010
Herbert Xu6bfd4802006-09-21 11:39:29 +100041#define CRYPTO_ALG_DEAD 0x00000020
42#define CRYPTO_ALG_DYING 0x00000040
Herbert Xuf3f632d2006-08-06 23:12:59 +100043#define CRYPTO_ALG_ASYNC 0x00000080
Herbert Xu28259822006-08-06 21:23:26 +100044
Linus Torvalds1da177e2005-04-16 15:20:36 -070045/*
Herbert Xu60104392006-08-26 18:34:10 +100046 * 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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 * Transform masks and values (for crt_flags).
53 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#define CRYPTO_TFM_REQ_MASK 0x000fff00
55#define CRYPTO_TFM_RES_MASK 0xfff00000
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#define CRYPTO_TFM_REQ_WEAK_KEY 0x00000100
Herbert Xu64baf3c2005-09-01 17:43:05 -070058#define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#define CRYPTO_MAX_ALG_NAME 64
69
Herbert Xu79911102006-08-21 21:03:52 +100070/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070090struct scatterlist;
Herbert Xu5cde0af2006-08-22 00:07:53 +100091struct crypto_blkcipher;
Herbert Xu055bcee2006-08-19 22:24:23 +100092struct crypto_hash;
Herbert Xu40725182005-07-06 13:51:52 -070093struct crypto_tfm;
Herbert Xue853c3c2006-08-22 00:06:54 +100094struct crypto_type;
Herbert Xu40725182005-07-06 13:51:52 -070095
Herbert Xu5cde0af2006-08-22 00:07:53 +100096struct blkcipher_desc {
97 struct crypto_blkcipher *tfm;
98 void *info;
99 u32 flags;
100};
101
Herbert Xu40725182005-07-06 13:51:52 -0700102struct cipher_desc {
103 struct crypto_tfm *tfm;
Herbert Xu6c2bb982006-05-16 22:09:29 +1000104 void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
Herbert Xu40725182005-07-06 13:51:52 -0700105 unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,
106 const u8 *src, unsigned int nbytes);
107 void *info;
108};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Herbert Xu055bcee2006-08-19 22:24:23 +1000110struct hash_desc {
111 struct crypto_hash *tfm;
112 u32 flags;
113};
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115/*
116 * Algorithms: modular crypto algorithm implementations, managed
117 * via crypto_register_alg() and crypto_unregister_alg().
118 */
Herbert Xu5cde0af2006-08-22 00:07:53 +1000119struct 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134struct cipher_alg {
135 unsigned int cia_min_keysize;
136 unsigned int cia_max_keysize;
Herbert Xu6c2bb982006-05-16 22:09:29 +1000137 int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
Herbert Xu560c06a2006-08-13 14:16:39 +1000138 unsigned int keylen);
Herbert Xu6c2bb982006-05-16 22:09:29 +1000139 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141};
142
143struct digest_alg {
144 unsigned int dia_digestsize;
Herbert Xu6c2bb982006-05-16 22:09:29 +1000145 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,
Herbert Xu560c06a2006-08-13 14:16:39 +1000150 unsigned int keylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151};
152
Herbert Xu055bcee2006-08-19 22:24:23 +1000153struct 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166struct compress_alg {
Herbert Xu6c2bb982006-05-16 22:09:29 +1000167 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171};
172
Herbert Xu5cde0af2006-08-22 00:07:53 +1000173#define cra_blkcipher cra_u.blkcipher
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174#define cra_cipher cra_u.cipher
175#define cra_digest cra_u.digest
Herbert Xu055bcee2006-08-19 22:24:23 +1000176#define cra_hash cra_u.hash
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177#define cra_compress cra_u.compress
178
179struct crypto_alg {
180 struct list_head cra_list;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000181 struct list_head cra_users;
182
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 u32 cra_flags;
184 unsigned int cra_blocksize;
185 unsigned int cra_ctxsize;
Herbert Xu95477372005-07-06 13:52:09 -0700186 unsigned int cra_alignmask;
Herbert Xu5cb14542005-11-05 16:58:14 +1100187
188 int cra_priority;
Herbert Xu6521f302006-08-06 20:28:44 +1000189 atomic_t cra_refcnt;
Herbert Xu5cb14542005-11-05 16:58:14 +1100190
Herbert Xud913ea02006-05-21 08:45:26 +1000191 char cra_name[CRYPTO_MAX_ALG_NAME];
192 char cra_driver_name[CRYPTO_MAX_ALG_NAME];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Herbert Xue853c3c2006-08-22 00:06:54 +1000194 const struct crypto_type *cra_type;
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 union {
Herbert Xu5cde0af2006-08-22 00:07:53 +1000197 struct blkcipher_alg blkcipher;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 struct cipher_alg cipher;
199 struct digest_alg digest;
Herbert Xu055bcee2006-08-19 22:24:23 +1000200 struct hash_alg hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 struct compress_alg compress;
202 } cra_u;
Herbert Xuc7fc0592006-05-24 13:02:26 +1000203
204 int (*cra_init)(struct crypto_tfm *tfm);
205 void (*cra_exit)(struct crypto_tfm *tfm);
Herbert Xu6521f302006-08-06 20:28:44 +1000206 void (*cra_destroy)(struct crypto_alg *alg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
208 struct module *cra_module;
209};
210
211/*
212 * Algorithm registration interface.
213 */
214int crypto_register_alg(struct crypto_alg *alg);
215int crypto_unregister_alg(struct crypto_alg *alg);
216
217/*
218 * Algorithm query interface.
219 */
220#ifdef CONFIG_CRYPTO
Herbert Xufce32d72006-08-26 17:35:45 +1000221int crypto_has_alg(const char *name, u32 type, u32 mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222#else
Herbert Xufce32d72006-08-26 17:35:45 +1000223static inline int crypto_has_alg(const char *name, u32 type, u32 mask)
224{
225 return 0;
226}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227#endif
228
229/*
230 * Transforms: user-instantiated objects which encapsulate algorithms
Herbert Xu6d7d6842006-07-30 11:53:01 +1000231 * and core processing logic. Managed via crypto_alloc_*() and
232 * crypto_free_*(), as well as the various helpers below.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Herbert Xu5cde0af2006-08-22 00:07:53 +1000235struct 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245struct 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);
Herbert Xuf28776a2006-08-13 20:58:18 +1000268 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270};
271
Herbert Xu055bcee2006-08-19 22:24:23 +1000272struct 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);
Herbert Xu055bcee2006-08-19 22:24:23 +1000281 unsigned int digestsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282};
283
284struct 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
Herbert Xu5cde0af2006-08-22 00:07:53 +1000293#define crt_blkcipher crt_u.blkcipher
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294#define crt_cipher crt_u.cipher
Herbert Xu055bcee2006-08-19 22:24:23 +1000295#define crt_hash crt_u.hash
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296#define crt_compress crt_u.compress
297
298struct crypto_tfm {
299
300 u32 crt_flags;
301
302 union {
Herbert Xu5cde0af2006-08-22 00:07:53 +1000303 struct blkcipher_tfm blkcipher;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 struct cipher_tfm cipher;
Herbert Xu055bcee2006-08-19 22:24:23 +1000305 struct hash_tfm hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 struct compress_tfm compress;
307 } crt_u;
308
309 struct crypto_alg *__crt_alg;
Herbert Xuf10b7892006-01-25 22:34:01 +1100310
Herbert Xu79911102006-08-21 21:03:52 +1000311 void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312};
313
Herbert Xuf28776a2006-08-13 20:58:18 +1000314#define crypto_cipher crypto_tfm
Herbert Xufce32d72006-08-26 17:35:45 +1000315#define crypto_comp crypto_tfm
Herbert Xuf28776a2006-08-13 20:58:18 +1000316
Herbert Xu5cde0af2006-08-22 00:07:53 +1000317struct crypto_blkcipher {
318 struct crypto_tfm base;
319};
320
Herbert Xu055bcee2006-08-19 22:24:23 +1000321struct crypto_hash {
322 struct crypto_tfm base;
323};
324
Herbert Xu2b8c19d2006-09-21 11:31:44 +1000325enum {
326 CRYPTOA_UNSPEC,
327 CRYPTOA_ALG,
328};
329
330struct crypto_attr_alg {
331 char name[CRYPTO_MAX_ALG_NAME];
332};
333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334/*
335 * Transform user interface.
336 */
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000339struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340void crypto_free_tfm(struct crypto_tfm *tfm);
341
342/*
343 * Transform helpers which query the underlying algorithm.
344 */
345static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
346{
347 return tfm->__crt_alg->cra_name;
348}
349
Michal Ludvigb14cdd62006-07-09 09:02:24 +1000350static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm)
351{
352 return tfm->__crt_alg->cra_driver_name;
353}
354
355static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
356{
357 return tfm->__crt_alg->cra_priority;
358}
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
361{
362 return module_name(tfm->__crt_alg->cra_module);
363}
364
365static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
366{
367 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
368}
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
371{
372 return tfm->__crt_alg->cra_blocksize;
373}
374
Herbert Xufbdae9f2005-07-06 13:53:29 -0700375static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
376{
377 return tfm->__crt_alg->cra_alignmask;
378}
379
Herbert Xuf28776a2006-08-13 20:58:18 +1000380static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm)
381{
382 return tfm->crt_flags;
383}
384
385static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags)
386{
387 tfm->crt_flags |= flags;
388}
389
390static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags)
391{
392 tfm->crt_flags &= ~flags;
393}
394
Herbert Xu40725182005-07-06 13:51:52 -0700395static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
396{
Herbert Xuf10b7892006-01-25 22:34:01 +1100397 return tfm->__crt_ctx;
398}
399
400static inline unsigned int crypto_tfm_ctx_alignment(void)
401{
402 struct crypto_tfm *tfm;
403 return __alignof__(tfm->__crt_ctx);
Herbert Xu40725182005-07-06 13:51:52 -0700404}
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406/*
407 * API wrappers.
408 */
Herbert Xu5cde0af2006-08-22 00:07:53 +1000409static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
410 struct crypto_tfm *tfm)
411{
412 return (struct crypto_blkcipher *)tfm;
413}
414
415static inline struct crypto_blkcipher *crypto_blkcipher_cast(
416 struct crypto_tfm *tfm)
417{
418 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER);
419 return __crypto_blkcipher_cast(tfm);
420}
421
422static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
423 const char *alg_name, u32 type, u32 mask)
424{
425 type &= ~CRYPTO_ALG_TYPE_MASK;
426 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
427 mask |= CRYPTO_ALG_TYPE_MASK;
428
429 return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
430}
431
432static inline struct crypto_tfm *crypto_blkcipher_tfm(
433 struct crypto_blkcipher *tfm)
434{
435 return &tfm->base;
436}
437
438static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
439{
440 crypto_free_tfm(crypto_blkcipher_tfm(tfm));
441}
442
Herbert Xufce32d72006-08-26 17:35:45 +1000443static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
444{
445 type &= ~CRYPTO_ALG_TYPE_MASK;
446 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
447 mask |= CRYPTO_ALG_TYPE_MASK;
448
449 return crypto_has_alg(alg_name, type, mask);
450}
451
Herbert Xu5cde0af2006-08-22 00:07:53 +1000452static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm)
453{
454 return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm));
455}
456
457static inline struct blkcipher_tfm *crypto_blkcipher_crt(
458 struct crypto_blkcipher *tfm)
459{
460 return &crypto_blkcipher_tfm(tfm)->crt_blkcipher;
461}
462
463static inline struct blkcipher_alg *crypto_blkcipher_alg(
464 struct crypto_blkcipher *tfm)
465{
466 return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher;
467}
468
469static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm)
470{
471 return crypto_blkcipher_alg(tfm)->ivsize;
472}
473
474static inline unsigned int crypto_blkcipher_blocksize(
475 struct crypto_blkcipher *tfm)
476{
477 return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm));
478}
479
480static inline unsigned int crypto_blkcipher_alignmask(
481 struct crypto_blkcipher *tfm)
482{
483 return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm));
484}
485
486static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm)
487{
488 return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm));
489}
490
491static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm,
492 u32 flags)
493{
494 crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags);
495}
496
497static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm,
498 u32 flags)
499{
500 crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags);
501}
502
503static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
504 const u8 *key, unsigned int keylen)
505{
506 return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm),
507 key, keylen);
508}
509
510static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
511 struct scatterlist *dst,
512 struct scatterlist *src,
513 unsigned int nbytes)
514{
515 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
516 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
517}
518
519static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
520 struct scatterlist *dst,
521 struct scatterlist *src,
522 unsigned int nbytes)
523{
524 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
525}
526
527static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
528 struct scatterlist *dst,
529 struct scatterlist *src,
530 unsigned int nbytes)
531{
532 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
533 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
534}
535
536static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
537 struct scatterlist *dst,
538 struct scatterlist *src,
539 unsigned int nbytes)
540{
541 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
542}
543
544static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm,
545 const u8 *src, unsigned int len)
546{
547 memcpy(crypto_blkcipher_crt(tfm)->iv, src, len);
548}
549
550static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm,
551 u8 *dst, unsigned int len)
552{
553 memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len);
554}
555
Herbert Xuf28776a2006-08-13 20:58:18 +1000556static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm)
557{
558 return (struct crypto_cipher *)tfm;
559}
560
561static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm)
562{
563 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
564 return __crypto_cipher_cast(tfm);
565}
566
567static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
568 u32 type, u32 mask)
569{
570 type &= ~CRYPTO_ALG_TYPE_MASK;
571 type |= CRYPTO_ALG_TYPE_CIPHER;
572 mask |= CRYPTO_ALG_TYPE_MASK;
573
574 return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask));
575}
576
577static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm)
578{
579 return tfm;
580}
581
582static inline void crypto_free_cipher(struct crypto_cipher *tfm)
583{
584 crypto_free_tfm(crypto_cipher_tfm(tfm));
585}
586
Herbert Xufce32d72006-08-26 17:35:45 +1000587static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask)
588{
589 type &= ~CRYPTO_ALG_TYPE_MASK;
590 type |= CRYPTO_ALG_TYPE_CIPHER;
591 mask |= CRYPTO_ALG_TYPE_MASK;
592
593 return crypto_has_alg(alg_name, type, mask);
594}
595
Herbert Xuf28776a2006-08-13 20:58:18 +1000596static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm)
597{
598 return &crypto_cipher_tfm(tfm)->crt_cipher;
599}
600
601static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm)
602{
603 return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm));
604}
605
606static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm)
607{
608 return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm));
609}
610
611static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm)
612{
613 return crypto_tfm_get_flags(crypto_cipher_tfm(tfm));
614}
615
616static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm,
617 u32 flags)
618{
619 crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags);
620}
621
622static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,
623 u32 flags)
624{
625 crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags);
626}
627
Herbert Xu7226bc82006-08-21 21:40:49 +1000628static inline int crypto_cipher_setkey(struct crypto_cipher *tfm,
629 const u8 *key, unsigned int keylen)
630{
631 return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm),
632 key, keylen);
633}
634
Herbert Xuf28776a2006-08-13 20:58:18 +1000635static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
636 u8 *dst, const u8 *src)
637{
638 crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm),
639 dst, src);
640}
641
642static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
643 u8 *dst, const u8 *src)
644{
645 crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm),
646 dst, src);
647}
648
Herbert Xu055bcee2006-08-19 22:24:23 +1000649static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650{
Herbert Xu055bcee2006-08-19 22:24:23 +1000651 return (struct crypto_hash *)tfm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}
653
Herbert Xu055bcee2006-08-19 22:24:23 +1000654static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
Herbert Xu055bcee2006-08-19 22:24:23 +1000656 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_HASH) &
657 CRYPTO_ALG_TYPE_HASH_MASK);
658 return __crypto_hash_cast(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659}
660
Herbert Xu055bcee2006-08-19 22:24:23 +1000661static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name,
662 u32 type, u32 mask)
663{
664 type &= ~CRYPTO_ALG_TYPE_MASK;
665 type |= CRYPTO_ALG_TYPE_HASH;
666 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
667
668 return __crypto_hash_cast(crypto_alloc_base(alg_name, type, mask));
669}
670
671static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm)
672{
673 return &tfm->base;
674}
675
676static inline void crypto_free_hash(struct crypto_hash *tfm)
677{
678 crypto_free_tfm(crypto_hash_tfm(tfm));
679}
680
Herbert Xufce32d72006-08-26 17:35:45 +1000681static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask)
682{
683 type &= ~CRYPTO_ALG_TYPE_MASK;
684 type |= CRYPTO_ALG_TYPE_HASH;
685 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
686
687 return crypto_has_alg(alg_name, type, mask);
688}
689
Herbert Xu055bcee2006-08-19 22:24:23 +1000690static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm)
691{
692 return &crypto_hash_tfm(tfm)->crt_hash;
693}
694
695static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm)
696{
697 return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm));
698}
699
700static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm)
701{
702 return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm));
703}
704
705static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm)
706{
707 return crypto_hash_crt(tfm)->digestsize;
708}
709
710static inline u32 crypto_hash_get_flags(struct crypto_hash *tfm)
711{
712 return crypto_tfm_get_flags(crypto_hash_tfm(tfm));
713}
714
715static inline void crypto_hash_set_flags(struct crypto_hash *tfm, u32 flags)
716{
717 crypto_tfm_set_flags(crypto_hash_tfm(tfm), flags);
718}
719
720static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags)
721{
722 crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags);
723}
724
725static inline int crypto_hash_init(struct hash_desc *desc)
726{
727 return crypto_hash_crt(desc->tfm)->init(desc);
728}
729
730static inline int crypto_hash_update(struct hash_desc *desc,
731 struct scatterlist *sg,
732 unsigned int nbytes)
733{
734 return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes);
735}
736
737static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
738{
739 return crypto_hash_crt(desc->tfm)->final(desc, out);
740}
741
742static inline int crypto_hash_digest(struct hash_desc *desc,
743 struct scatterlist *sg,
744 unsigned int nbytes, u8 *out)
745{
746 return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out);
747}
748
749static inline int crypto_hash_setkey(struct crypto_hash *hash,
750 const u8 *key, unsigned int keylen)
751{
752 return crypto_hash_crt(hash)->setkey(hash, key, keylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753}
754
Herbert Xufce32d72006-08-26 17:35:45 +1000755static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm)
756{
757 return (struct crypto_comp *)tfm;
758}
759
760static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm)
761{
762 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) &
763 CRYPTO_ALG_TYPE_MASK);
764 return __crypto_comp_cast(tfm);
765}
766
767static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name,
768 u32 type, u32 mask)
769{
770 type &= ~CRYPTO_ALG_TYPE_MASK;
771 type |= CRYPTO_ALG_TYPE_COMPRESS;
772 mask |= CRYPTO_ALG_TYPE_MASK;
773
774 return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask));
775}
776
777static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm)
778{
779 return tfm;
780}
781
782static inline void crypto_free_comp(struct crypto_comp *tfm)
783{
784 crypto_free_tfm(crypto_comp_tfm(tfm));
785}
786
787static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask)
788{
789 type &= ~CRYPTO_ALG_TYPE_MASK;
790 type |= CRYPTO_ALG_TYPE_COMPRESS;
791 mask |= CRYPTO_ALG_TYPE_MASK;
792
793 return crypto_has_alg(alg_name, type, mask);
794}
795
Herbert Xue4d5b792006-08-26 18:12:40 +1000796static inline const char *crypto_comp_name(struct crypto_comp *tfm)
797{
798 return crypto_tfm_alg_name(crypto_comp_tfm(tfm));
799}
800
Herbert Xufce32d72006-08-26 17:35:45 +1000801static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm)
802{
803 return &crypto_comp_tfm(tfm)->crt_compress;
804}
805
806static inline int crypto_comp_compress(struct crypto_comp *tfm,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 const u8 *src, unsigned int slen,
808 u8 *dst, unsigned int *dlen)
809{
Herbert Xufce32d72006-08-26 17:35:45 +1000810 return crypto_comp_crt(tfm)->cot_compress(tfm, src, slen, dst, dlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
812
Herbert Xufce32d72006-08-26 17:35:45 +1000813static inline int crypto_comp_decompress(struct crypto_comp *tfm,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 const u8 *src, unsigned int slen,
815 u8 *dst, unsigned int *dlen)
816{
Herbert Xufce32d72006-08-26 17:35:45 +1000817 return crypto_comp_crt(tfm)->cot_decompress(tfm, src, slen, dst, dlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818}
819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820#endif /* _LINUX_CRYPTO_H */
821