[CRYPTO] api: Added asynchronous flag
[linux-2.6.git] / include / linux / crypto.h
1 /*
2  * Scatterlist Cryptographic API.
3  *
4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5  * Copyright (c) 2002 David S. Miller (davem@redhat.com)
6  * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
7  *
8  * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
9  * and Nettle, by Niels Möller.
10  * 
11  * This program is free software; you can redistribute it and/or modify it
12  * under the terms of the GNU General Public License as published by the Free
13  * Software Foundation; either version 2 of the License, or (at your option) 
14  * any later version.
15  *
16  */
17 #ifndef _LINUX_CRYPTO_H
18 #define _LINUX_CRYPTO_H
19
20 #include <asm/atomic.h>
21 #include <linux/module.h>
22 #include <linux/kernel.h>
23 #include <linux/types.h>
24 #include <linux/list.h>
25 #include <linux/slab.h>
26 #include <linux/string.h>
27 #include <linux/uaccess.h>
28
29 /*
30  * Algorithm masks and types.
31  */
32 #define CRYPTO_ALG_TYPE_MASK            0x0000000f
33 #define CRYPTO_ALG_TYPE_CIPHER          0x00000001
34 #define CRYPTO_ALG_TYPE_DIGEST          0x00000002
35 #define CRYPTO_ALG_TYPE_COMPRESS        0x00000004
36
37 #define CRYPTO_ALG_LARVAL               0x00000010
38 #define CRYPTO_ALG_DEAD                 0x00000020
39 #define CRYPTO_ALG_DYING                0x00000040
40 #define CRYPTO_ALG_ASYNC                0x00000080
41
42 /*
43  * Transform masks and values (for crt_flags).
44  */
45 #define CRYPTO_TFM_MODE_MASK            0x000000ff
46 #define CRYPTO_TFM_REQ_MASK             0x000fff00
47 #define CRYPTO_TFM_RES_MASK             0xfff00000
48
49 #define CRYPTO_TFM_MODE_ECB             0x00000001
50 #define CRYPTO_TFM_MODE_CBC             0x00000002
51 #define CRYPTO_TFM_MODE_CFB             0x00000004
52 #define CRYPTO_TFM_MODE_CTR             0x00000008
53
54 #define CRYPTO_TFM_REQ_WEAK_KEY         0x00000100
55 #define CRYPTO_TFM_REQ_MAY_SLEEP        0x00000200
56 #define CRYPTO_TFM_RES_WEAK_KEY         0x00100000
57 #define CRYPTO_TFM_RES_BAD_KEY_LEN      0x00200000
58 #define CRYPTO_TFM_RES_BAD_KEY_SCHED    0x00400000
59 #define CRYPTO_TFM_RES_BAD_BLOCK_LEN    0x00800000
60 #define CRYPTO_TFM_RES_BAD_FLAGS        0x01000000
61
62 /*
63  * Miscellaneous stuff.
64  */
65 #define CRYPTO_UNSPEC                   0
66 #define CRYPTO_MAX_ALG_NAME             64
67
68 #define CRYPTO_DIR_ENCRYPT              1
69 #define CRYPTO_DIR_DECRYPT              0
70
71 /*
72  * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual
73  * declaration) is used to ensure that the crypto_tfm context structure is
74  * aligned correctly for the given architecture so that there are no alignment
75  * faults for C data types.  In particular, this is required on platforms such
76  * as arm where pointers are 32-bit aligned but there are data types such as
77  * u64 which require 64-bit alignment.
78  */
79 #if defined(ARCH_KMALLOC_MINALIGN)
80 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
81 #elif defined(ARCH_SLAB_MINALIGN)
82 #define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN
83 #endif
84
85 #ifdef CRYPTO_MINALIGN
86 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
87 #else
88 #define CRYPTO_MINALIGN_ATTR
89 #endif
90
91 struct scatterlist;
92 struct crypto_tfm;
93
94 struct cipher_desc {
95         struct crypto_tfm *tfm;
96         void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
97         unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,
98                              const u8 *src, unsigned int nbytes);
99         void *info;
100 };
101
102 /*
103  * Algorithms: modular crypto algorithm implementations, managed
104  * via crypto_register_alg() and crypto_unregister_alg().
105  */
106 struct cipher_alg {
107         unsigned int cia_min_keysize;
108         unsigned int cia_max_keysize;
109         int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
110                           unsigned int keylen);
111         void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
112         void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
113
114         unsigned int (*cia_encrypt_ecb)(const struct cipher_desc *desc,
115                                         u8 *dst, const u8 *src,
116                                         unsigned int nbytes);
117         unsigned int (*cia_decrypt_ecb)(const struct cipher_desc *desc,
118                                         u8 *dst, const u8 *src,
119                                         unsigned int nbytes);
120         unsigned int (*cia_encrypt_cbc)(const struct cipher_desc *desc,
121                                         u8 *dst, const u8 *src,
122                                         unsigned int nbytes);
123         unsigned int (*cia_decrypt_cbc)(const struct cipher_desc *desc,
124                                         u8 *dst, const u8 *src,
125                                         unsigned int nbytes);
126 };
127
128 struct digest_alg {
129         unsigned int dia_digestsize;
130         void (*dia_init)(struct crypto_tfm *tfm);
131         void (*dia_update)(struct crypto_tfm *tfm, const u8 *data,
132                            unsigned int len);
133         void (*dia_final)(struct crypto_tfm *tfm, u8 *out);
134         int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key,
135                           unsigned int keylen);
136 };
137
138 struct compress_alg {
139         int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,
140                             unsigned int slen, u8 *dst, unsigned int *dlen);
141         int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src,
142                               unsigned int slen, u8 *dst, unsigned int *dlen);
143 };
144
145 #define cra_cipher      cra_u.cipher
146 #define cra_digest      cra_u.digest
147 #define cra_compress    cra_u.compress
148
149 struct crypto_alg {
150         struct list_head cra_list;
151         struct list_head cra_users;
152
153         u32 cra_flags;
154         unsigned int cra_blocksize;
155         unsigned int cra_ctxsize;
156         unsigned int cra_alignmask;
157
158         int cra_priority;
159         atomic_t cra_refcnt;
160
161         char cra_name[CRYPTO_MAX_ALG_NAME];
162         char cra_driver_name[CRYPTO_MAX_ALG_NAME];
163
164         union {
165                 struct cipher_alg cipher;
166                 struct digest_alg digest;
167                 struct compress_alg compress;
168         } cra_u;
169
170         int (*cra_init)(struct crypto_tfm *tfm);
171         void (*cra_exit)(struct crypto_tfm *tfm);
172         void (*cra_destroy)(struct crypto_alg *alg);
173         
174         struct module *cra_module;
175 };
176
177 /*
178  * Algorithm registration interface.
179  */
180 int crypto_register_alg(struct crypto_alg *alg);
181 int crypto_unregister_alg(struct crypto_alg *alg);
182
183 /*
184  * Algorithm query interface.
185  */
186 #ifdef CONFIG_CRYPTO
187 int crypto_alg_available(const char *name, u32 flags);
188 #else
189 static inline int crypto_alg_available(const char *name, u32 flags)
190 {
191         return 0;
192 }
193 #endif
194
195 /*
196  * Transforms: user-instantiated objects which encapsulate algorithms
197  * and core processing logic.  Managed via crypto_alloc_tfm() and
198  * crypto_free_tfm(), as well as the various helpers below.
199  */
200
201 struct cipher_tfm {
202         void *cit_iv;
203         unsigned int cit_ivsize;
204         u32 cit_mode;
205         int (*cit_setkey)(struct crypto_tfm *tfm,
206                           const u8 *key, unsigned int keylen);
207         int (*cit_encrypt)(struct crypto_tfm *tfm,
208                            struct scatterlist *dst,
209                            struct scatterlist *src,
210                            unsigned int nbytes);
211         int (*cit_encrypt_iv)(struct crypto_tfm *tfm,
212                               struct scatterlist *dst,
213                               struct scatterlist *src,
214                               unsigned int nbytes, u8 *iv);
215         int (*cit_decrypt)(struct crypto_tfm *tfm,
216                            struct scatterlist *dst,
217                            struct scatterlist *src,
218                            unsigned int nbytes);
219         int (*cit_decrypt_iv)(struct crypto_tfm *tfm,
220                            struct scatterlist *dst,
221                            struct scatterlist *src,
222                            unsigned int nbytes, u8 *iv);
223         void (*cit_xor_block)(u8 *dst, const u8 *src);
224 };
225
226 struct digest_tfm {
227         void (*dit_init)(struct crypto_tfm *tfm);
228         void (*dit_update)(struct crypto_tfm *tfm,
229                            struct scatterlist *sg, unsigned int nsg);
230         void (*dit_final)(struct crypto_tfm *tfm, u8 *out);
231         void (*dit_digest)(struct crypto_tfm *tfm, struct scatterlist *sg,
232                            unsigned int nsg, u8 *out);
233         int (*dit_setkey)(struct crypto_tfm *tfm,
234                           const u8 *key, unsigned int keylen);
235 #ifdef CONFIG_CRYPTO_HMAC
236         void *dit_hmac_block;
237 #endif
238 };
239
240 struct compress_tfm {
241         int (*cot_compress)(struct crypto_tfm *tfm,
242                             const u8 *src, unsigned int slen,
243                             u8 *dst, unsigned int *dlen);
244         int (*cot_decompress)(struct crypto_tfm *tfm,
245                               const u8 *src, unsigned int slen,
246                               u8 *dst, unsigned int *dlen);
247 };
248
249 #define crt_cipher      crt_u.cipher
250 #define crt_digest      crt_u.digest
251 #define crt_compress    crt_u.compress
252
253 struct crypto_tfm {
254
255         u32 crt_flags;
256         
257         union {
258                 struct cipher_tfm cipher;
259                 struct digest_tfm digest;
260                 struct compress_tfm compress;
261         } crt_u;
262         
263         struct crypto_alg *__crt_alg;
264
265         void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
266 };
267
268 enum {
269         CRYPTOA_UNSPEC,
270         CRYPTOA_ALG,
271 };
272
273 struct crypto_attr_alg {
274         char name[CRYPTO_MAX_ALG_NAME];
275 };
276
277 /* 
278  * Transform user interface.
279  */
280  
281 /*
282  * crypto_alloc_tfm() will first attempt to locate an already loaded algorithm.
283  * If that fails and the kernel supports dynamically loadable modules, it
284  * will then attempt to load a module of the same name or alias.  A refcount
285  * is grabbed on the algorithm which is then associated with the new transform.
286  *
287  * crypto_free_tfm() frees up the transform and any associated resources,
288  * then drops the refcount on the associated algorithm.
289  */
290 struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags);
291 void crypto_free_tfm(struct crypto_tfm *tfm);
292
293 /*
294  * Transform helpers which query the underlying algorithm.
295  */
296 static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
297 {
298         return tfm->__crt_alg->cra_name;
299 }
300
301 static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm)
302 {
303         return tfm->__crt_alg->cra_driver_name;
304 }
305
306 static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
307 {
308         return tfm->__crt_alg->cra_priority;
309 }
310
311 static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
312 {
313         return module_name(tfm->__crt_alg->cra_module);
314 }
315
316 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
317 {
318         return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
319 }
320
321 static inline unsigned int crypto_tfm_alg_min_keysize(struct crypto_tfm *tfm)
322 {
323         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
324         return tfm->__crt_alg->cra_cipher.cia_min_keysize;
325 }
326
327 static inline unsigned int crypto_tfm_alg_max_keysize(struct crypto_tfm *tfm)
328 {
329         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
330         return tfm->__crt_alg->cra_cipher.cia_max_keysize;
331 }
332
333 static inline unsigned int crypto_tfm_alg_ivsize(struct crypto_tfm *tfm)
334 {
335         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
336         return tfm->crt_cipher.cit_ivsize;
337 }
338
339 static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
340 {
341         return tfm->__crt_alg->cra_blocksize;
342 }
343
344 static inline unsigned int crypto_tfm_alg_digestsize(struct crypto_tfm *tfm)
345 {
346         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
347         return tfm->__crt_alg->cra_digest.dia_digestsize;
348 }
349
350 static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
351 {
352         return tfm->__crt_alg->cra_alignmask;
353 }
354
355 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
356 {
357         return tfm->__crt_ctx;
358 }
359
360 static inline unsigned int crypto_tfm_ctx_alignment(void)
361 {
362         struct crypto_tfm *tfm;
363         return __alignof__(tfm->__crt_ctx);
364 }
365
366 /*
367  * API wrappers.
368  */
369 static inline void crypto_digest_init(struct crypto_tfm *tfm)
370 {
371         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
372         tfm->crt_digest.dit_init(tfm);
373 }
374
375 static inline void crypto_digest_update(struct crypto_tfm *tfm,
376                                         struct scatterlist *sg,
377                                         unsigned int nsg)
378 {
379         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
380         tfm->crt_digest.dit_update(tfm, sg, nsg);
381 }
382
383 static inline void crypto_digest_final(struct crypto_tfm *tfm, u8 *out)
384 {
385         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
386         tfm->crt_digest.dit_final(tfm, out);
387 }
388
389 static inline void crypto_digest_digest(struct crypto_tfm *tfm,
390                                         struct scatterlist *sg,
391                                         unsigned int nsg, u8 *out)
392 {
393         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
394         tfm->crt_digest.dit_digest(tfm, sg, nsg, out);
395 }
396
397 static inline int crypto_digest_setkey(struct crypto_tfm *tfm,
398                                        const u8 *key, unsigned int keylen)
399 {
400         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
401         return tfm->crt_digest.dit_setkey(tfm, key, keylen);
402 }
403
404 static inline int crypto_cipher_setkey(struct crypto_tfm *tfm,
405                                        const u8 *key, unsigned int keylen)
406 {
407         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
408         return tfm->crt_cipher.cit_setkey(tfm, key, keylen);
409 }
410
411 static inline int crypto_cipher_encrypt(struct crypto_tfm *tfm,
412                                         struct scatterlist *dst,
413                                         struct scatterlist *src,
414                                         unsigned int nbytes)
415 {
416         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
417         return tfm->crt_cipher.cit_encrypt(tfm, dst, src, nbytes);
418 }                                        
419
420 static inline int crypto_cipher_encrypt_iv(struct crypto_tfm *tfm,
421                                            struct scatterlist *dst,
422                                            struct scatterlist *src,
423                                            unsigned int nbytes, u8 *iv)
424 {
425         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
426         return tfm->crt_cipher.cit_encrypt_iv(tfm, dst, src, nbytes, iv);
427 }                                        
428
429 static inline int crypto_cipher_decrypt(struct crypto_tfm *tfm,
430                                         struct scatterlist *dst,
431                                         struct scatterlist *src,
432                                         unsigned int nbytes)
433 {
434         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
435         return tfm->crt_cipher.cit_decrypt(tfm, dst, src, nbytes);
436 }
437
438 static inline int crypto_cipher_decrypt_iv(struct crypto_tfm *tfm,
439                                            struct scatterlist *dst,
440                                            struct scatterlist *src,
441                                            unsigned int nbytes, u8 *iv)
442 {
443         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
444         return tfm->crt_cipher.cit_decrypt_iv(tfm, dst, src, nbytes, iv);
445 }
446
447 static inline void crypto_cipher_set_iv(struct crypto_tfm *tfm,
448                                         const u8 *src, unsigned int len)
449 {
450         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
451         memcpy(tfm->crt_cipher.cit_iv, src, len);
452 }
453
454 static inline void crypto_cipher_get_iv(struct crypto_tfm *tfm,
455                                         u8 *dst, unsigned int len)
456 {
457         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
458         memcpy(dst, tfm->crt_cipher.cit_iv, len);
459 }
460
461 static inline int crypto_comp_compress(struct crypto_tfm *tfm,
462                                        const u8 *src, unsigned int slen,
463                                        u8 *dst, unsigned int *dlen)
464 {
465         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_COMPRESS);
466         return tfm->crt_compress.cot_compress(tfm, src, slen, dst, dlen);
467 }
468
469 static inline int crypto_comp_decompress(struct crypto_tfm *tfm,
470                                          const u8 *src, unsigned int slen,
471                                          u8 *dst, unsigned int *dlen)
472 {
473         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_COMPRESS);
474         return tfm->crt_compress.cot_decompress(tfm, src, slen, dst, dlen);
475 }
476
477 /*
478  * HMAC support.
479  */
480 #ifdef CONFIG_CRYPTO_HMAC
481 void crypto_hmac_init(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen);
482 void crypto_hmac_update(struct crypto_tfm *tfm,
483                         struct scatterlist *sg, unsigned int nsg);
484 void crypto_hmac_final(struct crypto_tfm *tfm, u8 *key,
485                        unsigned int *keylen, u8 *out);
486 void crypto_hmac(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen,
487                  struct scatterlist *sg, unsigned int nsg, u8 *out);
488 #endif  /* CONFIG_CRYPTO_HMAC */
489
490 #endif  /* _LINUX_CRYPTO_H */
491