blob: 425824bd49f308f64074943fd257bd69f512edce [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>
John Anthony Kazos Jr18735dd2007-10-19 23:07:36 +02009 * and Nettle, by Niels Möller.
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
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
Herbert Xu332f8842007-11-15 22:36:07 +080036#define CRYPTO_ALG_TYPE_ABLKCIPHER 0x00000005
Herbert Xu61da88e2007-12-17 21:51:27 +080037#define CRYPTO_ALG_TYPE_GIVCIPHER 0x00000006
Herbert Xu332f8842007-11-15 22:36:07 +080038#define CRYPTO_ALG_TYPE_COMPRESS 0x00000008
39#define CRYPTO_ALG_TYPE_AEAD 0x00000009
Herbert Xu055bcee2006-08-19 22:24:23 +100040
41#define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e
Herbert Xu332f8842007-11-15 22:36:07 +080042#define CRYPTO_ALG_TYPE_BLKCIPHER_MASK 0x0000000c
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Herbert Xu28259822006-08-06 21:23:26 +100044#define CRYPTO_ALG_LARVAL 0x00000010
Herbert Xu6bfd4802006-09-21 11:39:29 +100045#define CRYPTO_ALG_DEAD 0x00000020
46#define CRYPTO_ALG_DYING 0x00000040
Herbert Xuf3f632d2006-08-06 23:12:59 +100047#define CRYPTO_ALG_ASYNC 0x00000080
Herbert Xu28259822006-08-06 21:23:26 +100048
Linus Torvalds1da177e2005-04-16 15:20:36 -070049/*
Herbert Xu60104392006-08-26 18:34:10 +100050 * Set this bit if and only if the algorithm requires another algorithm of
51 * the same type to handle corner cases.
52 */
53#define CRYPTO_ALG_NEED_FALLBACK 0x00000100
54
55/*
Herbert Xuecfc4322007-12-05 21:08:36 +110056 * This bit is set for symmetric key ciphers that have already been wrapped
57 * with a generic IV generator to prevent them from being wrapped again.
58 */
59#define CRYPTO_ALG_GENIV 0x00000200
60
61/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 * Transform masks and values (for crt_flags).
63 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#define CRYPTO_TFM_REQ_MASK 0x000fff00
65#define CRYPTO_TFM_RES_MASK 0xfff00000
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#define CRYPTO_TFM_REQ_WEAK_KEY 0x00000100
Herbert Xu64baf3c2005-09-01 17:43:05 -070068#define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200
Herbert Xu32e39832007-03-24 14:35:34 +110069#define CRYPTO_TFM_REQ_MAY_BACKLOG 0x00000400
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#define CRYPTO_TFM_RES_WEAK_KEY 0x00100000
71#define CRYPTO_TFM_RES_BAD_KEY_LEN 0x00200000
72#define CRYPTO_TFM_RES_BAD_KEY_SCHED 0x00400000
73#define CRYPTO_TFM_RES_BAD_BLOCK_LEN 0x00800000
74#define CRYPTO_TFM_RES_BAD_FLAGS 0x01000000
75
76/*
77 * Miscellaneous stuff.
78 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#define CRYPTO_MAX_ALG_NAME 64
80
Herbert Xu79911102006-08-21 21:03:52 +100081/*
82 * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual
83 * declaration) is used to ensure that the crypto_tfm context structure is
84 * aligned correctly for the given architecture so that there are no alignment
85 * faults for C data types. In particular, this is required on platforms such
86 * as arm where pointers are 32-bit aligned but there are data types such as
87 * u64 which require 64-bit alignment.
88 */
89#if defined(ARCH_KMALLOC_MINALIGN)
90#define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
91#elif defined(ARCH_SLAB_MINALIGN)
92#define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN
Herbert Xu6eb72282008-01-08 17:16:44 +110093#else
94#define CRYPTO_MINALIGN __alignof__(unsigned long long)
Herbert Xu79911102006-08-21 21:03:52 +100095#endif
96
Herbert Xu79911102006-08-21 21:03:52 +100097#define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
Herbert Xu79911102006-08-21 21:03:52 +100098
Linus Torvalds1da177e2005-04-16 15:20:36 -070099struct scatterlist;
Herbert Xu32e39832007-03-24 14:35:34 +1100100struct crypto_ablkcipher;
101struct crypto_async_request;
Herbert Xu1ae97822007-08-30 15:36:14 +0800102struct crypto_aead;
Herbert Xu5cde0af2006-08-22 00:07:53 +1000103struct crypto_blkcipher;
Herbert Xu055bcee2006-08-19 22:24:23 +1000104struct crypto_hash;
Herbert Xu40725182005-07-06 13:51:52 -0700105struct crypto_tfm;
Herbert Xue853c3c2006-08-22 00:06:54 +1000106struct crypto_type;
Herbert Xu743edf52007-12-10 16:18:01 +0800107struct aead_givcrypt_request;
Herbert Xu61da88e2007-12-17 21:51:27 +0800108struct skcipher_givcrypt_request;
Herbert Xu40725182005-07-06 13:51:52 -0700109
Herbert Xu32e39832007-03-24 14:35:34 +1100110typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
111
112struct crypto_async_request {
113 struct list_head list;
114 crypto_completion_t complete;
115 void *data;
116 struct crypto_tfm *tfm;
117
118 u32 flags;
119};
120
121struct ablkcipher_request {
122 struct crypto_async_request base;
123
124 unsigned int nbytes;
125
126 void *info;
127
128 struct scatterlist *src;
129 struct scatterlist *dst;
130
131 void *__ctx[] CRYPTO_MINALIGN_ATTR;
132};
133
Herbert Xu1ae97822007-08-30 15:36:14 +0800134/**
135 * struct aead_request - AEAD request
136 * @base: Common attributes for async crypto requests
137 * @assoclen: Length in bytes of associated data for authentication
138 * @cryptlen: Length of data to be encrypted or decrypted
139 * @iv: Initialisation vector
140 * @assoc: Associated data
141 * @src: Source data
142 * @dst: Destination data
143 * @__ctx: Start of private context data
144 */
145struct aead_request {
146 struct crypto_async_request base;
147
148 unsigned int assoclen;
149 unsigned int cryptlen;
150
151 u8 *iv;
152
153 struct scatterlist *assoc;
154 struct scatterlist *src;
155 struct scatterlist *dst;
156
157 void *__ctx[] CRYPTO_MINALIGN_ATTR;
158};
159
Herbert Xu5cde0af2006-08-22 00:07:53 +1000160struct blkcipher_desc {
161 struct crypto_blkcipher *tfm;
162 void *info;
163 u32 flags;
164};
165
Herbert Xu40725182005-07-06 13:51:52 -0700166struct cipher_desc {
167 struct crypto_tfm *tfm;
Herbert Xu6c2bb982006-05-16 22:09:29 +1000168 void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
Herbert Xu40725182005-07-06 13:51:52 -0700169 unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,
170 const u8 *src, unsigned int nbytes);
171 void *info;
172};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Herbert Xu055bcee2006-08-19 22:24:23 +1000174struct hash_desc {
175 struct crypto_hash *tfm;
176 u32 flags;
177};
178
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179/*
180 * Algorithms: modular crypto algorithm implementations, managed
181 * via crypto_register_alg() and crypto_unregister_alg().
182 */
Herbert Xub5b7f082007-04-16 20:48:54 +1000183struct ablkcipher_alg {
184 int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
185 unsigned int keylen);
186 int (*encrypt)(struct ablkcipher_request *req);
187 int (*decrypt)(struct ablkcipher_request *req);
Herbert Xu61da88e2007-12-17 21:51:27 +0800188 int (*givencrypt)(struct skcipher_givcrypt_request *req);
189 int (*givdecrypt)(struct skcipher_givcrypt_request *req);
Herbert Xub5b7f082007-04-16 20:48:54 +1000190
Herbert Xu23508e12007-11-27 21:33:24 +0800191 const char *geniv;
192
Herbert Xub5b7f082007-04-16 20:48:54 +1000193 unsigned int min_keysize;
194 unsigned int max_keysize;
195 unsigned int ivsize;
196};
197
Herbert Xu1ae97822007-08-30 15:36:14 +0800198struct aead_alg {
199 int (*setkey)(struct crypto_aead *tfm, const u8 *key,
200 unsigned int keylen);
Herbert Xu7ba683a2007-12-02 18:49:21 +1100201 int (*setauthsize)(struct crypto_aead *tfm, unsigned int authsize);
Herbert Xu1ae97822007-08-30 15:36:14 +0800202 int (*encrypt)(struct aead_request *req);
203 int (*decrypt)(struct aead_request *req);
Herbert Xu743edf52007-12-10 16:18:01 +0800204 int (*givencrypt)(struct aead_givcrypt_request *req);
205 int (*givdecrypt)(struct aead_givcrypt_request *req);
Herbert Xu1ae97822007-08-30 15:36:14 +0800206
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800207 const char *geniv;
208
Herbert Xu1ae97822007-08-30 15:36:14 +0800209 unsigned int ivsize;
Herbert Xu7ba683a2007-12-02 18:49:21 +1100210 unsigned int maxauthsize;
Herbert Xu1ae97822007-08-30 15:36:14 +0800211};
212
Herbert Xu5cde0af2006-08-22 00:07:53 +1000213struct blkcipher_alg {
214 int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
215 unsigned int keylen);
216 int (*encrypt)(struct blkcipher_desc *desc,
217 struct scatterlist *dst, struct scatterlist *src,
218 unsigned int nbytes);
219 int (*decrypt)(struct blkcipher_desc *desc,
220 struct scatterlist *dst, struct scatterlist *src,
221 unsigned int nbytes);
222
Herbert Xu23508e12007-11-27 21:33:24 +0800223 const char *geniv;
224
Herbert Xu5cde0af2006-08-22 00:07:53 +1000225 unsigned int min_keysize;
226 unsigned int max_keysize;
227 unsigned int ivsize;
228};
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230struct cipher_alg {
231 unsigned int cia_min_keysize;
232 unsigned int cia_max_keysize;
Herbert Xu6c2bb982006-05-16 22:09:29 +1000233 int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
Herbert Xu560c06a2006-08-13 14:16:39 +1000234 unsigned int keylen);
Herbert Xu6c2bb982006-05-16 22:09:29 +1000235 void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
236 void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237};
238
239struct digest_alg {
240 unsigned int dia_digestsize;
Herbert Xu6c2bb982006-05-16 22:09:29 +1000241 void (*dia_init)(struct crypto_tfm *tfm);
242 void (*dia_update)(struct crypto_tfm *tfm, const u8 *data,
243 unsigned int len);
244 void (*dia_final)(struct crypto_tfm *tfm, u8 *out);
245 int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key,
Herbert Xu560c06a2006-08-13 14:16:39 +1000246 unsigned int keylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247};
248
Herbert Xu055bcee2006-08-19 22:24:23 +1000249struct hash_alg {
250 int (*init)(struct hash_desc *desc);
251 int (*update)(struct hash_desc *desc, struct scatterlist *sg,
252 unsigned int nbytes);
253 int (*final)(struct hash_desc *desc, u8 *out);
254 int (*digest)(struct hash_desc *desc, struct scatterlist *sg,
255 unsigned int nbytes, u8 *out);
256 int (*setkey)(struct crypto_hash *tfm, const u8 *key,
257 unsigned int keylen);
258
259 unsigned int digestsize;
260};
261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262struct compress_alg {
Herbert Xu6c2bb982006-05-16 22:09:29 +1000263 int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,
264 unsigned int slen, u8 *dst, unsigned int *dlen);
265 int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src,
266 unsigned int slen, u8 *dst, unsigned int *dlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267};
268
Herbert Xub5b7f082007-04-16 20:48:54 +1000269#define cra_ablkcipher cra_u.ablkcipher
Herbert Xu1ae97822007-08-30 15:36:14 +0800270#define cra_aead cra_u.aead
Herbert Xu5cde0af2006-08-22 00:07:53 +1000271#define cra_blkcipher cra_u.blkcipher
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272#define cra_cipher cra_u.cipher
273#define cra_digest cra_u.digest
Herbert Xu055bcee2006-08-19 22:24:23 +1000274#define cra_hash cra_u.hash
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275#define cra_compress cra_u.compress
276
277struct crypto_alg {
278 struct list_head cra_list;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000279 struct list_head cra_users;
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 u32 cra_flags;
282 unsigned int cra_blocksize;
283 unsigned int cra_ctxsize;
Herbert Xu95477372005-07-06 13:52:09 -0700284 unsigned int cra_alignmask;
Herbert Xu5cb14542005-11-05 16:58:14 +1100285
286 int cra_priority;
Herbert Xu6521f302006-08-06 20:28:44 +1000287 atomic_t cra_refcnt;
Herbert Xu5cb14542005-11-05 16:58:14 +1100288
Herbert Xud913ea02006-05-21 08:45:26 +1000289 char cra_name[CRYPTO_MAX_ALG_NAME];
290 char cra_driver_name[CRYPTO_MAX_ALG_NAME];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Herbert Xue853c3c2006-08-22 00:06:54 +1000292 const struct crypto_type *cra_type;
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 union {
Herbert Xub5b7f082007-04-16 20:48:54 +1000295 struct ablkcipher_alg ablkcipher;
Herbert Xu1ae97822007-08-30 15:36:14 +0800296 struct aead_alg aead;
Herbert Xu5cde0af2006-08-22 00:07:53 +1000297 struct blkcipher_alg blkcipher;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 struct cipher_alg cipher;
299 struct digest_alg digest;
Herbert Xu055bcee2006-08-19 22:24:23 +1000300 struct hash_alg hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 struct compress_alg compress;
302 } cra_u;
Herbert Xuc7fc0592006-05-24 13:02:26 +1000303
304 int (*cra_init)(struct crypto_tfm *tfm);
305 void (*cra_exit)(struct crypto_tfm *tfm);
Herbert Xu6521f302006-08-06 20:28:44 +1000306 void (*cra_destroy)(struct crypto_alg *alg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
308 struct module *cra_module;
309};
310
311/*
312 * Algorithm registration interface.
313 */
314int crypto_register_alg(struct crypto_alg *alg);
315int crypto_unregister_alg(struct crypto_alg *alg);
316
317/*
318 * Algorithm query interface.
319 */
Herbert Xufce32d72006-08-26 17:35:45 +1000320int crypto_has_alg(const char *name, u32 type, u32 mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322/*
323 * Transforms: user-instantiated objects which encapsulate algorithms
Herbert Xu6d7d6842006-07-30 11:53:01 +1000324 * and core processing logic. Managed via crypto_alloc_*() and
325 * crypto_free_*(), as well as the various helpers below.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Herbert Xu32e39832007-03-24 14:35:34 +1100328struct ablkcipher_tfm {
329 int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
330 unsigned int keylen);
331 int (*encrypt)(struct ablkcipher_request *req);
332 int (*decrypt)(struct ablkcipher_request *req);
Herbert Xu61da88e2007-12-17 21:51:27 +0800333 int (*givencrypt)(struct skcipher_givcrypt_request *req);
334 int (*givdecrypt)(struct skcipher_givcrypt_request *req);
335
Herbert Xuecfc4322007-12-05 21:08:36 +1100336 struct crypto_ablkcipher *base;
337
Herbert Xu32e39832007-03-24 14:35:34 +1100338 unsigned int ivsize;
339 unsigned int reqsize;
340};
341
Herbert Xu1ae97822007-08-30 15:36:14 +0800342struct aead_tfm {
343 int (*setkey)(struct crypto_aead *tfm, const u8 *key,
344 unsigned int keylen);
345 int (*encrypt)(struct aead_request *req);
346 int (*decrypt)(struct aead_request *req);
Herbert Xu743edf52007-12-10 16:18:01 +0800347 int (*givencrypt)(struct aead_givcrypt_request *req);
348 int (*givdecrypt)(struct aead_givcrypt_request *req);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800349
350 struct crypto_aead *base;
351
Herbert Xu1ae97822007-08-30 15:36:14 +0800352 unsigned int ivsize;
353 unsigned int authsize;
354 unsigned int reqsize;
355};
356
Herbert Xu5cde0af2006-08-22 00:07:53 +1000357struct blkcipher_tfm {
358 void *iv;
359 int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
360 unsigned int keylen);
361 int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,
362 struct scatterlist *src, unsigned int nbytes);
363 int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,
364 struct scatterlist *src, unsigned int nbytes);
365};
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367struct cipher_tfm {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 int (*cit_setkey)(struct crypto_tfm *tfm,
369 const u8 *key, unsigned int keylen);
Herbert Xuf28776a2006-08-13 20:58:18 +1000370 void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
371 void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372};
373
Herbert Xu055bcee2006-08-19 22:24:23 +1000374struct hash_tfm {
375 int (*init)(struct hash_desc *desc);
376 int (*update)(struct hash_desc *desc,
377 struct scatterlist *sg, unsigned int nsg);
378 int (*final)(struct hash_desc *desc, u8 *out);
379 int (*digest)(struct hash_desc *desc, struct scatterlist *sg,
380 unsigned int nsg, u8 *out);
381 int (*setkey)(struct crypto_hash *tfm, const u8 *key,
382 unsigned int keylen);
Herbert Xu055bcee2006-08-19 22:24:23 +1000383 unsigned int digestsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384};
385
386struct compress_tfm {
387 int (*cot_compress)(struct crypto_tfm *tfm,
388 const u8 *src, unsigned int slen,
389 u8 *dst, unsigned int *dlen);
390 int (*cot_decompress)(struct crypto_tfm *tfm,
391 const u8 *src, unsigned int slen,
392 u8 *dst, unsigned int *dlen);
393};
394
Herbert Xu32e39832007-03-24 14:35:34 +1100395#define crt_ablkcipher crt_u.ablkcipher
Herbert Xu1ae97822007-08-30 15:36:14 +0800396#define crt_aead crt_u.aead
Herbert Xu5cde0af2006-08-22 00:07:53 +1000397#define crt_blkcipher crt_u.blkcipher
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398#define crt_cipher crt_u.cipher
Herbert Xu055bcee2006-08-19 22:24:23 +1000399#define crt_hash crt_u.hash
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400#define crt_compress crt_u.compress
401
402struct crypto_tfm {
403
404 u32 crt_flags;
405
406 union {
Herbert Xu32e39832007-03-24 14:35:34 +1100407 struct ablkcipher_tfm ablkcipher;
Herbert Xu1ae97822007-08-30 15:36:14 +0800408 struct aead_tfm aead;
Herbert Xu5cde0af2006-08-22 00:07:53 +1000409 struct blkcipher_tfm blkcipher;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 struct cipher_tfm cipher;
Herbert Xu055bcee2006-08-19 22:24:23 +1000411 struct hash_tfm hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 struct compress_tfm compress;
413 } crt_u;
414
415 struct crypto_alg *__crt_alg;
Herbert Xuf10b7892006-01-25 22:34:01 +1100416
Herbert Xu79911102006-08-21 21:03:52 +1000417 void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418};
419
Herbert Xu32e39832007-03-24 14:35:34 +1100420struct crypto_ablkcipher {
421 struct crypto_tfm base;
422};
423
Herbert Xu1ae97822007-08-30 15:36:14 +0800424struct crypto_aead {
425 struct crypto_tfm base;
426};
427
Herbert Xu5cde0af2006-08-22 00:07:53 +1000428struct crypto_blkcipher {
429 struct crypto_tfm base;
430};
431
Herbert Xu78a1fe42006-12-24 10:02:00 +1100432struct crypto_cipher {
433 struct crypto_tfm base;
434};
435
436struct crypto_comp {
437 struct crypto_tfm base;
438};
439
Herbert Xu055bcee2006-08-19 22:24:23 +1000440struct crypto_hash {
441 struct crypto_tfm base;
442};
443
Herbert Xu2b8c19d2006-09-21 11:31:44 +1000444enum {
445 CRYPTOA_UNSPEC,
446 CRYPTOA_ALG,
Herbert Xuebc610e2007-01-01 18:37:02 +1100447 CRYPTOA_TYPE,
Herbert Xu39e1ee02007-08-29 19:27:26 +0800448 CRYPTOA_U32,
Herbert Xuebc610e2007-01-01 18:37:02 +1100449 __CRYPTOA_MAX,
Herbert Xu2b8c19d2006-09-21 11:31:44 +1000450};
451
Herbert Xuebc610e2007-01-01 18:37:02 +1100452#define CRYPTOA_MAX (__CRYPTOA_MAX - 1)
453
Herbert Xu39e1ee02007-08-29 19:27:26 +0800454/* Maximum number of (rtattr) parameters for each template. */
455#define CRYPTO_MAX_ATTRS 32
456
Herbert Xu2b8c19d2006-09-21 11:31:44 +1000457struct crypto_attr_alg {
458 char name[CRYPTO_MAX_ALG_NAME];
459};
460
Herbert Xuebc610e2007-01-01 18:37:02 +1100461struct crypto_attr_type {
462 u32 type;
463 u32 mask;
464};
465
Herbert Xu39e1ee02007-08-29 19:27:26 +0800466struct crypto_attr_u32 {
467 u32 num;
468};
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470/*
471 * Transform user interface.
472 */
473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000475struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476void crypto_free_tfm(struct crypto_tfm *tfm);
477
478/*
479 * Transform helpers which query the underlying algorithm.
480 */
481static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
482{
483 return tfm->__crt_alg->cra_name;
484}
485
Michal Ludvigb14cdd62006-07-09 09:02:24 +1000486static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm)
487{
488 return tfm->__crt_alg->cra_driver_name;
489}
490
491static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
492{
493 return tfm->__crt_alg->cra_priority;
494}
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
497{
498 return module_name(tfm->__crt_alg->cra_module);
499}
500
501static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
502{
503 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
504}
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
507{
508 return tfm->__crt_alg->cra_blocksize;
509}
510
Herbert Xufbdae9f2005-07-06 13:53:29 -0700511static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
512{
513 return tfm->__crt_alg->cra_alignmask;
514}
515
Herbert Xuf28776a2006-08-13 20:58:18 +1000516static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm)
517{
518 return tfm->crt_flags;
519}
520
521static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags)
522{
523 tfm->crt_flags |= flags;
524}
525
526static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags)
527{
528 tfm->crt_flags &= ~flags;
529}
530
Herbert Xu40725182005-07-06 13:51:52 -0700531static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
532{
Herbert Xuf10b7892006-01-25 22:34:01 +1100533 return tfm->__crt_ctx;
534}
535
536static inline unsigned int crypto_tfm_ctx_alignment(void)
537{
538 struct crypto_tfm *tfm;
539 return __alignof__(tfm->__crt_ctx);
Herbert Xu40725182005-07-06 13:51:52 -0700540}
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542/*
543 * API wrappers.
544 */
Herbert Xu32e39832007-03-24 14:35:34 +1100545static inline struct crypto_ablkcipher *__crypto_ablkcipher_cast(
546 struct crypto_tfm *tfm)
547{
548 return (struct crypto_ablkcipher *)tfm;
549}
550
Herbert Xu378f4f52007-12-17 20:07:31 +0800551static inline u32 crypto_skcipher_type(u32 type)
552{
Herbert Xuecfc4322007-12-05 21:08:36 +1100553 type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
Herbert Xu378f4f52007-12-17 20:07:31 +0800554 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
555 return type;
556}
557
558static inline u32 crypto_skcipher_mask(u32 mask)
559{
Herbert Xuecfc4322007-12-05 21:08:36 +1100560 mask &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
Herbert Xu378f4f52007-12-17 20:07:31 +0800561 mask |= CRYPTO_ALG_TYPE_BLKCIPHER_MASK;
562 return mask;
563}
564
Herbert Xub9c55aa2007-12-04 12:46:48 +1100565struct crypto_ablkcipher *crypto_alloc_ablkcipher(const char *alg_name,
566 u32 type, u32 mask);
Herbert Xu32e39832007-03-24 14:35:34 +1100567
568static inline struct crypto_tfm *crypto_ablkcipher_tfm(
569 struct crypto_ablkcipher *tfm)
570{
571 return &tfm->base;
572}
573
574static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm)
575{
576 crypto_free_tfm(crypto_ablkcipher_tfm(tfm));
577}
578
579static inline int crypto_has_ablkcipher(const char *alg_name, u32 type,
580 u32 mask)
581{
Herbert Xu378f4f52007-12-17 20:07:31 +0800582 return crypto_has_alg(alg_name, crypto_skcipher_type(type),
583 crypto_skcipher_mask(mask));
Herbert Xu32e39832007-03-24 14:35:34 +1100584}
585
586static inline struct ablkcipher_tfm *crypto_ablkcipher_crt(
587 struct crypto_ablkcipher *tfm)
588{
589 return &crypto_ablkcipher_tfm(tfm)->crt_ablkcipher;
590}
591
592static inline unsigned int crypto_ablkcipher_ivsize(
593 struct crypto_ablkcipher *tfm)
594{
595 return crypto_ablkcipher_crt(tfm)->ivsize;
596}
597
598static inline unsigned int crypto_ablkcipher_blocksize(
599 struct crypto_ablkcipher *tfm)
600{
601 return crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(tfm));
602}
603
604static inline unsigned int crypto_ablkcipher_alignmask(
605 struct crypto_ablkcipher *tfm)
606{
607 return crypto_tfm_alg_alignmask(crypto_ablkcipher_tfm(tfm));
608}
609
610static inline u32 crypto_ablkcipher_get_flags(struct crypto_ablkcipher *tfm)
611{
612 return crypto_tfm_get_flags(crypto_ablkcipher_tfm(tfm));
613}
614
615static inline void crypto_ablkcipher_set_flags(struct crypto_ablkcipher *tfm,
616 u32 flags)
617{
618 crypto_tfm_set_flags(crypto_ablkcipher_tfm(tfm), flags);
619}
620
621static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm,
622 u32 flags)
623{
624 crypto_tfm_clear_flags(crypto_ablkcipher_tfm(tfm), flags);
625}
626
627static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
628 const u8 *key, unsigned int keylen)
629{
Herbert Xuecfc4322007-12-05 21:08:36 +1100630 struct ablkcipher_tfm *crt = crypto_ablkcipher_crt(tfm);
631
632 return crt->setkey(crt->base, key, keylen);
Herbert Xu32e39832007-03-24 14:35:34 +1100633}
634
635static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
636 struct ablkcipher_request *req)
637{
638 return __crypto_ablkcipher_cast(req->base.tfm);
639}
640
641static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
642{
643 struct ablkcipher_tfm *crt =
644 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
645 return crt->encrypt(req);
646}
647
648static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
649{
650 struct ablkcipher_tfm *crt =
651 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
652 return crt->decrypt(req);
653}
654
Herbert Xub16c3a22007-08-29 19:02:04 +0800655static inline unsigned int crypto_ablkcipher_reqsize(
656 struct crypto_ablkcipher *tfm)
Herbert Xu32e39832007-03-24 14:35:34 +1100657{
658 return crypto_ablkcipher_crt(tfm)->reqsize;
659}
660
Herbert Xue196d622007-04-14 16:09:14 +1000661static inline void ablkcipher_request_set_tfm(
662 struct ablkcipher_request *req, struct crypto_ablkcipher *tfm)
663{
Herbert Xuecfc4322007-12-05 21:08:36 +1100664 req->base.tfm = crypto_ablkcipher_tfm(crypto_ablkcipher_crt(tfm)->base);
Herbert Xue196d622007-04-14 16:09:14 +1000665}
666
Herbert Xub5b7f082007-04-16 20:48:54 +1000667static inline struct ablkcipher_request *ablkcipher_request_cast(
668 struct crypto_async_request *req)
669{
670 return container_of(req, struct ablkcipher_request, base);
671}
672
Herbert Xu32e39832007-03-24 14:35:34 +1100673static inline struct ablkcipher_request *ablkcipher_request_alloc(
674 struct crypto_ablkcipher *tfm, gfp_t gfp)
675{
676 struct ablkcipher_request *req;
677
678 req = kmalloc(sizeof(struct ablkcipher_request) +
679 crypto_ablkcipher_reqsize(tfm), gfp);
680
681 if (likely(req))
Herbert Xue196d622007-04-14 16:09:14 +1000682 ablkcipher_request_set_tfm(req, tfm);
Herbert Xu32e39832007-03-24 14:35:34 +1100683
684 return req;
685}
686
687static inline void ablkcipher_request_free(struct ablkcipher_request *req)
688{
689 kfree(req);
690}
691
692static inline void ablkcipher_request_set_callback(
693 struct ablkcipher_request *req,
694 u32 flags, crypto_completion_t complete, void *data)
695{
696 req->base.complete = complete;
697 req->base.data = data;
698 req->base.flags = flags;
699}
700
701static inline void ablkcipher_request_set_crypt(
702 struct ablkcipher_request *req,
703 struct scatterlist *src, struct scatterlist *dst,
704 unsigned int nbytes, void *iv)
705{
706 req->src = src;
707 req->dst = dst;
708 req->nbytes = nbytes;
709 req->info = iv;
710}
711
Herbert Xu1ae97822007-08-30 15:36:14 +0800712static inline struct crypto_aead *__crypto_aead_cast(struct crypto_tfm *tfm)
713{
714 return (struct crypto_aead *)tfm;
715}
716
Herbert Xud29ce982007-12-12 19:24:27 +0800717struct crypto_aead *crypto_alloc_aead(const char *alg_name, u32 type, u32 mask);
Herbert Xu1ae97822007-08-30 15:36:14 +0800718
719static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm)
720{
721 return &tfm->base;
722}
723
724static inline void crypto_free_aead(struct crypto_aead *tfm)
725{
726 crypto_free_tfm(crypto_aead_tfm(tfm));
727}
728
729static inline struct aead_tfm *crypto_aead_crt(struct crypto_aead *tfm)
730{
731 return &crypto_aead_tfm(tfm)->crt_aead;
732}
733
734static inline unsigned int crypto_aead_ivsize(struct crypto_aead *tfm)
735{
736 return crypto_aead_crt(tfm)->ivsize;
737}
738
739static inline unsigned int crypto_aead_authsize(struct crypto_aead *tfm)
740{
741 return crypto_aead_crt(tfm)->authsize;
742}
743
744static inline unsigned int crypto_aead_blocksize(struct crypto_aead *tfm)
745{
746 return crypto_tfm_alg_blocksize(crypto_aead_tfm(tfm));
747}
748
749static inline unsigned int crypto_aead_alignmask(struct crypto_aead *tfm)
750{
751 return crypto_tfm_alg_alignmask(crypto_aead_tfm(tfm));
752}
753
754static inline u32 crypto_aead_get_flags(struct crypto_aead *tfm)
755{
756 return crypto_tfm_get_flags(crypto_aead_tfm(tfm));
757}
758
759static inline void crypto_aead_set_flags(struct crypto_aead *tfm, u32 flags)
760{
761 crypto_tfm_set_flags(crypto_aead_tfm(tfm), flags);
762}
763
764static inline void crypto_aead_clear_flags(struct crypto_aead *tfm, u32 flags)
765{
766 crypto_tfm_clear_flags(crypto_aead_tfm(tfm), flags);
767}
768
769static inline int crypto_aead_setkey(struct crypto_aead *tfm, const u8 *key,
770 unsigned int keylen)
771{
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800772 struct aead_tfm *crt = crypto_aead_crt(tfm);
773
774 return crt->setkey(crt->base, key, keylen);
Herbert Xu1ae97822007-08-30 15:36:14 +0800775}
776
Herbert Xu7ba683a2007-12-02 18:49:21 +1100777int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize);
778
Herbert Xu1ae97822007-08-30 15:36:14 +0800779static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
780{
781 return __crypto_aead_cast(req->base.tfm);
782}
783
784static inline int crypto_aead_encrypt(struct aead_request *req)
785{
786 return crypto_aead_crt(crypto_aead_reqtfm(req))->encrypt(req);
787}
788
789static inline int crypto_aead_decrypt(struct aead_request *req)
790{
791 return crypto_aead_crt(crypto_aead_reqtfm(req))->decrypt(req);
792}
793
Herbert Xub16c3a22007-08-29 19:02:04 +0800794static inline unsigned int crypto_aead_reqsize(struct crypto_aead *tfm)
Herbert Xu1ae97822007-08-30 15:36:14 +0800795{
796 return crypto_aead_crt(tfm)->reqsize;
797}
798
799static inline void aead_request_set_tfm(struct aead_request *req,
800 struct crypto_aead *tfm)
801{
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800802 req->base.tfm = crypto_aead_tfm(crypto_aead_crt(tfm)->base);
Herbert Xu1ae97822007-08-30 15:36:14 +0800803}
804
805static inline struct aead_request *aead_request_alloc(struct crypto_aead *tfm,
806 gfp_t gfp)
807{
808 struct aead_request *req;
809
810 req = kmalloc(sizeof(*req) + crypto_aead_reqsize(tfm), gfp);
811
812 if (likely(req))
813 aead_request_set_tfm(req, tfm);
814
815 return req;
816}
817
818static inline void aead_request_free(struct aead_request *req)
819{
820 kfree(req);
821}
822
823static inline void aead_request_set_callback(struct aead_request *req,
824 u32 flags,
825 crypto_completion_t complete,
826 void *data)
827{
828 req->base.complete = complete;
829 req->base.data = data;
830 req->base.flags = flags;
831}
832
833static inline void aead_request_set_crypt(struct aead_request *req,
834 struct scatterlist *src,
835 struct scatterlist *dst,
836 unsigned int cryptlen, u8 *iv)
837{
838 req->src = src;
839 req->dst = dst;
840 req->cryptlen = cryptlen;
841 req->iv = iv;
842}
843
844static inline void aead_request_set_assoc(struct aead_request *req,
845 struct scatterlist *assoc,
846 unsigned int assoclen)
847{
848 req->assoc = assoc;
849 req->assoclen = assoclen;
850}
851
Herbert Xu5cde0af2006-08-22 00:07:53 +1000852static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
853 struct crypto_tfm *tfm)
854{
855 return (struct crypto_blkcipher *)tfm;
856}
857
858static inline struct crypto_blkcipher *crypto_blkcipher_cast(
859 struct crypto_tfm *tfm)
860{
861 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER);
862 return __crypto_blkcipher_cast(tfm);
863}
864
865static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
866 const char *alg_name, u32 type, u32 mask)
867{
Herbert Xu332f8842007-11-15 22:36:07 +0800868 type &= ~CRYPTO_ALG_TYPE_MASK;
Herbert Xu5cde0af2006-08-22 00:07:53 +1000869 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
Herbert Xu332f8842007-11-15 22:36:07 +0800870 mask |= CRYPTO_ALG_TYPE_MASK;
Herbert Xu5cde0af2006-08-22 00:07:53 +1000871
872 return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
873}
874
875static inline struct crypto_tfm *crypto_blkcipher_tfm(
876 struct crypto_blkcipher *tfm)
877{
878 return &tfm->base;
879}
880
881static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
882{
883 crypto_free_tfm(crypto_blkcipher_tfm(tfm));
884}
885
Herbert Xufce32d72006-08-26 17:35:45 +1000886static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
887{
Herbert Xu332f8842007-11-15 22:36:07 +0800888 type &= ~CRYPTO_ALG_TYPE_MASK;
Herbert Xufce32d72006-08-26 17:35:45 +1000889 type |= CRYPTO_ALG_TYPE_BLKCIPHER;
Herbert Xu332f8842007-11-15 22:36:07 +0800890 mask |= CRYPTO_ALG_TYPE_MASK;
Herbert Xufce32d72006-08-26 17:35:45 +1000891
892 return crypto_has_alg(alg_name, type, mask);
893}
894
Herbert Xu5cde0af2006-08-22 00:07:53 +1000895static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm)
896{
897 return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm));
898}
899
900static inline struct blkcipher_tfm *crypto_blkcipher_crt(
901 struct crypto_blkcipher *tfm)
902{
903 return &crypto_blkcipher_tfm(tfm)->crt_blkcipher;
904}
905
906static inline struct blkcipher_alg *crypto_blkcipher_alg(
907 struct crypto_blkcipher *tfm)
908{
909 return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher;
910}
911
912static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm)
913{
914 return crypto_blkcipher_alg(tfm)->ivsize;
915}
916
917static inline unsigned int crypto_blkcipher_blocksize(
918 struct crypto_blkcipher *tfm)
919{
920 return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm));
921}
922
923static inline unsigned int crypto_blkcipher_alignmask(
924 struct crypto_blkcipher *tfm)
925{
926 return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm));
927}
928
929static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm)
930{
931 return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm));
932}
933
934static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm,
935 u32 flags)
936{
937 crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags);
938}
939
940static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm,
941 u32 flags)
942{
943 crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags);
944}
945
946static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
947 const u8 *key, unsigned int keylen)
948{
949 return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm),
950 key, keylen);
951}
952
953static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
954 struct scatterlist *dst,
955 struct scatterlist *src,
956 unsigned int nbytes)
957{
958 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
959 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
960}
961
962static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
963 struct scatterlist *dst,
964 struct scatterlist *src,
965 unsigned int nbytes)
966{
967 return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
968}
969
970static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
971 struct scatterlist *dst,
972 struct scatterlist *src,
973 unsigned int nbytes)
974{
975 desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
976 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
977}
978
979static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
980 struct scatterlist *dst,
981 struct scatterlist *src,
982 unsigned int nbytes)
983{
984 return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
985}
986
987static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm,
988 const u8 *src, unsigned int len)
989{
990 memcpy(crypto_blkcipher_crt(tfm)->iv, src, len);
991}
992
993static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm,
994 u8 *dst, unsigned int len)
995{
996 memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len);
997}
998
Herbert Xuf28776a2006-08-13 20:58:18 +1000999static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm)
1000{
1001 return (struct crypto_cipher *)tfm;
1002}
1003
1004static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm)
1005{
1006 BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
1007 return __crypto_cipher_cast(tfm);
1008}
1009
1010static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
1011 u32 type, u32 mask)
1012{
1013 type &= ~CRYPTO_ALG_TYPE_MASK;
1014 type |= CRYPTO_ALG_TYPE_CIPHER;
1015 mask |= CRYPTO_ALG_TYPE_MASK;
1016
1017 return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask));
1018}
1019
1020static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm)
1021{
Herbert Xu78a1fe42006-12-24 10:02:00 +11001022 return &tfm->base;
Herbert Xuf28776a2006-08-13 20:58:18 +10001023}
1024
1025static inline void crypto_free_cipher(struct crypto_cipher *tfm)
1026{
1027 crypto_free_tfm(crypto_cipher_tfm(tfm));
1028}
1029
Herbert Xufce32d72006-08-26 17:35:45 +10001030static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask)
1031{
1032 type &= ~CRYPTO_ALG_TYPE_MASK;
1033 type |= CRYPTO_ALG_TYPE_CIPHER;
1034 mask |= CRYPTO_ALG_TYPE_MASK;
1035
1036 return crypto_has_alg(alg_name, type, mask);
1037}
1038
Herbert Xuf28776a2006-08-13 20:58:18 +10001039static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm)
1040{
1041 return &crypto_cipher_tfm(tfm)->crt_cipher;
1042}
1043
1044static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm)
1045{
1046 return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm));
1047}
1048
1049static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm)
1050{
1051 return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm));
1052}
1053
1054static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm)
1055{
1056 return crypto_tfm_get_flags(crypto_cipher_tfm(tfm));
1057}
1058
1059static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm,
1060 u32 flags)
1061{
1062 crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags);
1063}
1064
1065static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,
1066 u32 flags)
1067{
1068 crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags);
1069}
1070
Herbert Xu7226bc82006-08-21 21:40:49 +10001071static inline int crypto_cipher_setkey(struct crypto_cipher *tfm,
1072 const u8 *key, unsigned int keylen)
1073{
1074 return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm),
1075 key, keylen);
1076}
1077
Herbert Xuf28776a2006-08-13 20:58:18 +10001078static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
1079 u8 *dst, const u8 *src)
1080{
1081 crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm),
1082 dst, src);
1083}
1084
1085static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
1086 u8 *dst, const u8 *src)
1087{
1088 crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm),
1089 dst, src);
1090}
1091
Herbert Xu055bcee2006-08-19 22:24:23 +10001092static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093{
Herbert Xu055bcee2006-08-19 22:24:23 +10001094 return (struct crypto_hash *)tfm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095}
1096
Herbert Xu055bcee2006-08-19 22:24:23 +10001097static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098{
Herbert Xu055bcee2006-08-19 22:24:23 +10001099 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_HASH) &
1100 CRYPTO_ALG_TYPE_HASH_MASK);
1101 return __crypto_hash_cast(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102}
1103
Herbert Xu055bcee2006-08-19 22:24:23 +10001104static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name,
1105 u32 type, u32 mask)
1106{
1107 type &= ~CRYPTO_ALG_TYPE_MASK;
Herbert Xu551a09a2007-12-01 21:47:07 +11001108 mask &= ~CRYPTO_ALG_TYPE_MASK;
Herbert Xu055bcee2006-08-19 22:24:23 +10001109 type |= CRYPTO_ALG_TYPE_HASH;
1110 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
1111
1112 return __crypto_hash_cast(crypto_alloc_base(alg_name, type, mask));
1113}
1114
1115static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm)
1116{
1117 return &tfm->base;
1118}
1119
1120static inline void crypto_free_hash(struct crypto_hash *tfm)
1121{
1122 crypto_free_tfm(crypto_hash_tfm(tfm));
1123}
1124
Herbert Xufce32d72006-08-26 17:35:45 +10001125static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask)
1126{
1127 type &= ~CRYPTO_ALG_TYPE_MASK;
Herbert Xu551a09a2007-12-01 21:47:07 +11001128 mask &= ~CRYPTO_ALG_TYPE_MASK;
Herbert Xufce32d72006-08-26 17:35:45 +10001129 type |= CRYPTO_ALG_TYPE_HASH;
1130 mask |= CRYPTO_ALG_TYPE_HASH_MASK;
1131
1132 return crypto_has_alg(alg_name, type, mask);
1133}
1134
Herbert Xu055bcee2006-08-19 22:24:23 +10001135static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm)
1136{
1137 return &crypto_hash_tfm(tfm)->crt_hash;
1138}
1139
1140static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm)
1141{
1142 return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm));
1143}
1144
1145static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm)
1146{
1147 return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm));
1148}
1149
1150static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm)
1151{
1152 return crypto_hash_crt(tfm)->digestsize;
1153}
1154
1155static inline u32 crypto_hash_get_flags(struct crypto_hash *tfm)
1156{
1157 return crypto_tfm_get_flags(crypto_hash_tfm(tfm));
1158}
1159
1160static inline void crypto_hash_set_flags(struct crypto_hash *tfm, u32 flags)
1161{
1162 crypto_tfm_set_flags(crypto_hash_tfm(tfm), flags);
1163}
1164
1165static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags)
1166{
1167 crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags);
1168}
1169
1170static inline int crypto_hash_init(struct hash_desc *desc)
1171{
1172 return crypto_hash_crt(desc->tfm)->init(desc);
1173}
1174
1175static inline int crypto_hash_update(struct hash_desc *desc,
1176 struct scatterlist *sg,
1177 unsigned int nbytes)
1178{
1179 return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes);
1180}
1181
1182static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
1183{
1184 return crypto_hash_crt(desc->tfm)->final(desc, out);
1185}
1186
1187static inline int crypto_hash_digest(struct hash_desc *desc,
1188 struct scatterlist *sg,
1189 unsigned int nbytes, u8 *out)
1190{
1191 return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out);
1192}
1193
1194static inline int crypto_hash_setkey(struct crypto_hash *hash,
1195 const u8 *key, unsigned int keylen)
1196{
1197 return crypto_hash_crt(hash)->setkey(hash, key, keylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198}
1199
Herbert Xufce32d72006-08-26 17:35:45 +10001200static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm)
1201{
1202 return (struct crypto_comp *)tfm;
1203}
1204
1205static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm)
1206{
1207 BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) &
1208 CRYPTO_ALG_TYPE_MASK);
1209 return __crypto_comp_cast(tfm);
1210}
1211
1212static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name,
1213 u32 type, u32 mask)
1214{
1215 type &= ~CRYPTO_ALG_TYPE_MASK;
1216 type |= CRYPTO_ALG_TYPE_COMPRESS;
1217 mask |= CRYPTO_ALG_TYPE_MASK;
1218
1219 return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask));
1220}
1221
1222static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm)
1223{
Herbert Xu78a1fe42006-12-24 10:02:00 +11001224 return &tfm->base;
Herbert Xufce32d72006-08-26 17:35:45 +10001225}
1226
1227static inline void crypto_free_comp(struct crypto_comp *tfm)
1228{
1229 crypto_free_tfm(crypto_comp_tfm(tfm));
1230}
1231
1232static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask)
1233{
1234 type &= ~CRYPTO_ALG_TYPE_MASK;
1235 type |= CRYPTO_ALG_TYPE_COMPRESS;
1236 mask |= CRYPTO_ALG_TYPE_MASK;
1237
1238 return crypto_has_alg(alg_name, type, mask);
1239}
1240
Herbert Xue4d5b792006-08-26 18:12:40 +10001241static inline const char *crypto_comp_name(struct crypto_comp *tfm)
1242{
1243 return crypto_tfm_alg_name(crypto_comp_tfm(tfm));
1244}
1245
Herbert Xufce32d72006-08-26 17:35:45 +10001246static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm)
1247{
1248 return &crypto_comp_tfm(tfm)->crt_compress;
1249}
1250
1251static inline int crypto_comp_compress(struct crypto_comp *tfm,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 const u8 *src, unsigned int slen,
1253 u8 *dst, unsigned int *dlen)
1254{
Herbert Xu78a1fe42006-12-24 10:02:00 +11001255 return crypto_comp_crt(tfm)->cot_compress(crypto_comp_tfm(tfm),
1256 src, slen, dst, dlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257}
1258
Herbert Xufce32d72006-08-26 17:35:45 +10001259static inline int crypto_comp_decompress(struct crypto_comp *tfm,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 const u8 *src, unsigned int slen,
1261 u8 *dst, unsigned int *dlen)
1262{
Herbert Xu78a1fe42006-12-24 10:02:00 +11001263 return crypto_comp_crt(tfm)->cot_decompress(crypto_comp_tfm(tfm),
1264 src, slen, dst, dlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265}
1266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267#endif /* _LINUX_CRYPTO_H */
1268