]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - include/crypto/algapi.h
crypto: nx/842 - Fix context corruption
[mirror_ubuntu-bionic-kernel.git] / include / crypto / algapi.h
CommitLineData
cce9e06d
HX
1/*
2 * Cryptographic API for algorithms (i.e., low-level API).
3 *
4 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 *
11 */
12#ifndef _CRYPTO_ALGAPI_H
13#define _CRYPTO_ALGAPI_H
14
15#include <linux/crypto.h>
b5b7f088
HX
16#include <linux/list.h>
17#include <linux/kernel.h>
b6aa63c0 18#include <linux/skbuff.h>
cce9e06d 19
5d1d65f8 20struct crypto_aead;
4cc7720c 21struct module;
ebc610e5 22struct rtattr;
e853c3cf
HX
23struct seq_file;
24
25struct crypto_type {
27d2a330 26 unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask);
2ca33da1 27 unsigned int (*extsize)(struct crypto_alg *alg);
27d2a330 28 int (*init)(struct crypto_tfm *tfm, u32 type, u32 mask);
2ca33da1 29 int (*init_tfm)(struct crypto_tfm *tfm);
e853c3cf 30 void (*show)(struct seq_file *m, struct crypto_alg *alg);
b6aa63c0 31 int (*report)(struct sk_buff *skb, struct crypto_alg *alg);
7b0bac64
HX
32 struct crypto_alg *(*lookup)(const char *name, u32 type, u32 mask);
33
34 unsigned int type;
35 unsigned int maskclear;
36 unsigned int maskset;
37 unsigned int tfmsize;
e853c3cf 38};
4cc7720c
HX
39
40struct crypto_instance {
41 struct crypto_alg alg;
42
43 struct crypto_template *tmpl;
44 struct hlist_node list;
45
46 void *__ctx[] CRYPTO_MINALIGN_ATTR;
47};
48
49struct crypto_template {
50 struct list_head list;
51 struct hlist_head instances;
52 struct module *module;
53
ebc610e5 54 struct crypto_instance *(*alloc)(struct rtattr **tb);
4cc7720c 55 void (*free)(struct crypto_instance *inst);
f2ac72e8 56 int (*create)(struct crypto_template *tmpl, struct rtattr **tb);
4cc7720c
HX
57
58 char name[CRYPTO_MAX_ALG_NAME];
59};
60
6bfd4809
HX
61struct crypto_spawn {
62 struct list_head list;
63 struct crypto_alg *alg;
64 struct crypto_instance *inst;
97eedce1 65 const struct crypto_type *frontend;
a73e6996 66 u32 mask;
6bfd4809
HX
67};
68
b5b7f088
HX
69struct crypto_queue {
70 struct list_head list;
71 struct list_head *backlog;
72
73 unsigned int qlen;
74 unsigned int max_qlen;
75};
76
5c64097a
HX
77struct scatter_walk {
78 struct scatterlist *sg;
79 unsigned int offset;
80};
81
5cde0af2
HX
82struct blkcipher_walk {
83 union {
84 struct {
85 struct page *page;
86 unsigned long offset;
87 } phys;
88
89 struct {
90 u8 *page;
91 u8 *addr;
92 } virt;
93 } src, dst;
94
95 struct scatter_walk in;
96 unsigned int nbytes;
97
98 struct scatter_walk out;
99 unsigned int total;
100
101 void *page;
102 u8 *buffer;
103 u8 *iv;
822be00f 104 unsigned int ivsize;
5cde0af2
HX
105
106 int flags;
822be00f
AB
107 unsigned int walk_blocksize;
108 unsigned int cipher_blocksize;
109 unsigned int alignmask;
5cde0af2
HX
110};
111
bf06099d
DM
112struct ablkcipher_walk {
113 struct {
114 struct page *page;
115 unsigned int offset;
116 } src, dst;
117
118 struct scatter_walk in;
119 unsigned int nbytes;
120 struct scatter_walk out;
121 unsigned int total;
122 struct list_head buffers;
123 u8 *iv_buffer;
124 u8 *iv;
125 int flags;
126 unsigned int blocksize;
127};
128
b5b7f088 129extern const struct crypto_type crypto_ablkcipher_type;
5cde0af2
HX
130extern const struct crypto_type crypto_blkcipher_type;
131
db131ef9
HX
132void crypto_mod_put(struct crypto_alg *alg);
133
4cc7720c
HX
134int crypto_register_template(struct crypto_template *tmpl);
135void crypto_unregister_template(struct crypto_template *tmpl);
136struct crypto_template *crypto_lookup_template(const char *name);
137
9cd899a3
HX
138int crypto_register_instance(struct crypto_template *tmpl,
139 struct crypto_instance *inst);
87b16756 140int crypto_unregister_instance(struct crypto_instance *inst);
9cd899a3 141
6bfd4809 142int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
a73e6996 143 struct crypto_instance *inst, u32 mask);
97eedce1
HX
144int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
145 struct crypto_instance *inst,
146 const struct crypto_type *frontend);
d6ef2f19
HX
147int crypto_grab_spawn(struct crypto_spawn *spawn, const char *name,
148 u32 type, u32 mask);
97eedce1 149
6bfd4809 150void crypto_drop_spawn(struct crypto_spawn *spawn);
2e306ee0
HX
151struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
152 u32 mask);
97eedce1 153void *crypto_spawn_tfm2(struct crypto_spawn *spawn);
6bfd4809 154
378f4f51
HX
155static inline void crypto_set_spawn(struct crypto_spawn *spawn,
156 struct crypto_instance *inst)
157{
158 spawn->inst = inst;
159}
160
ebc610e5
HX
161struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb);
162int crypto_check_attr_type(struct rtattr **tb, u32 type);
68b6c7d6 163const char *crypto_attr_alg_name(struct rtattr *rta);
d06854f0
HX
164struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,
165 const struct crypto_type *frontend,
166 u32 type, u32 mask);
167
168static inline struct crypto_alg *crypto_attr_alg(struct rtattr *rta,
169 u32 type, u32 mask)
170{
171 return crypto_attr_alg2(rta, NULL, type, mask);
172}
173
3c09f17c 174int crypto_attr_u32(struct rtattr *rta, u32 *num);
70ec7bb9
HX
175void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg,
176 unsigned int head);
7fed0bf2
HX
177struct crypto_instance *crypto_alloc_instance(const char *name,
178 struct crypto_alg *alg);
179
b5b7f088
HX
180void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen);
181int crypto_enqueue_request(struct crypto_queue *queue,
182 struct crypto_async_request *request);
183struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue);
184int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm);
185
7613636d
HX
186/* These functions require the input/output to be aligned as u32. */
187void crypto_inc(u8 *a, unsigned int size);
188void crypto_xor(u8 *dst, const u8 *src, unsigned int size);
189
5cde0af2
HX
190int blkcipher_walk_done(struct blkcipher_desc *desc,
191 struct blkcipher_walk *walk, int err);
192int blkcipher_walk_virt(struct blkcipher_desc *desc,
193 struct blkcipher_walk *walk);
194int blkcipher_walk_phys(struct blkcipher_desc *desc,
195 struct blkcipher_walk *walk);
7607bd8f
HX
196int blkcipher_walk_virt_block(struct blkcipher_desc *desc,
197 struct blkcipher_walk *walk,
198 unsigned int blocksize);
4f7f1d7c
AB
199int blkcipher_aead_walk_virt_block(struct blkcipher_desc *desc,
200 struct blkcipher_walk *walk,
201 struct crypto_aead *tfm,
202 unsigned int blocksize);
5cde0af2 203
bf06099d
DM
204int ablkcipher_walk_done(struct ablkcipher_request *req,
205 struct ablkcipher_walk *walk, int err);
206int ablkcipher_walk_phys(struct ablkcipher_request *req,
207 struct ablkcipher_walk *walk);
208void __ablkcipher_walk_complete(struct ablkcipher_walk *walk);
209
5cde0af2
HX
210static inline void *crypto_tfm_ctx_aligned(struct crypto_tfm *tfm)
211{
ab300465
HX
212 return PTR_ALIGN(crypto_tfm_ctx(tfm),
213 crypto_tfm_alg_alignmask(tfm) + 1);
5cde0af2
HX
214}
215
124b53d0
HX
216static inline struct crypto_instance *crypto_tfm_alg_instance(
217 struct crypto_tfm *tfm)
218{
219 return container_of(tfm->__crt_alg, struct crypto_instance, alg);
220}
221
4cc7720c
HX
222static inline void *crypto_instance_ctx(struct crypto_instance *inst)
223{
224 return inst->__ctx;
225}
226
b5b7f088
HX
227static inline struct ablkcipher_alg *crypto_ablkcipher_alg(
228 struct crypto_ablkcipher *tfm)
229{
230 return &crypto_ablkcipher_tfm(tfm)->__crt_alg->cra_ablkcipher;
231}
232
233static inline void *crypto_ablkcipher_ctx(struct crypto_ablkcipher *tfm)
234{
235 return crypto_tfm_ctx(&tfm->base);
236}
237
aa379a6a
SS
238static inline void *crypto_ablkcipher_ctx_aligned(struct crypto_ablkcipher *tfm)
239{
240 return crypto_tfm_ctx_aligned(&tfm->base);
241}
242
124b53d0
HX
243static inline struct crypto_blkcipher *crypto_spawn_blkcipher(
244 struct crypto_spawn *spawn)
245{
246 u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;
332f8840 247 u32 mask = CRYPTO_ALG_TYPE_MASK;
124b53d0
HX
248
249 return __crypto_blkcipher_cast(crypto_spawn_tfm(spawn, type, mask));
250}
251
5cde0af2
HX
252static inline void *crypto_blkcipher_ctx(struct crypto_blkcipher *tfm)
253{
254 return crypto_tfm_ctx(&tfm->base);
255}
256
257static inline void *crypto_blkcipher_ctx_aligned(struct crypto_blkcipher *tfm)
258{
259 return crypto_tfm_ctx_aligned(&tfm->base);
260}
261
2e306ee0
HX
262static inline struct crypto_cipher *crypto_spawn_cipher(
263 struct crypto_spawn *spawn)
264{
265 u32 type = CRYPTO_ALG_TYPE_CIPHER;
266 u32 mask = CRYPTO_ALG_TYPE_MASK;
267
268 return __crypto_cipher_cast(crypto_spawn_tfm(spawn, type, mask));
269}
270
f28776a3
HX
271static inline struct cipher_alg *crypto_cipher_alg(struct crypto_cipher *tfm)
272{
273 return &crypto_cipher_tfm(tfm)->__crt_alg->cra_cipher;
274}
275
2e306ee0
HX
276static inline struct crypto_hash *crypto_spawn_hash(struct crypto_spawn *spawn)
277{
278 u32 type = CRYPTO_ALG_TYPE_HASH;
279 u32 mask = CRYPTO_ALG_TYPE_HASH_MASK;
280
281 return __crypto_hash_cast(crypto_spawn_tfm(spawn, type, mask));
282}
283
5f7082ed
HX
284static inline void *crypto_hash_ctx(struct crypto_hash *tfm)
285{
286 return crypto_tfm_ctx(&tfm->base);
287}
288
055bcee3
HX
289static inline void *crypto_hash_ctx_aligned(struct crypto_hash *tfm)
290{
291 return crypto_tfm_ctx_aligned(&tfm->base);
292}
293
5cde0af2
HX
294static inline void blkcipher_walk_init(struct blkcipher_walk *walk,
295 struct scatterlist *dst,
296 struct scatterlist *src,
297 unsigned int nbytes)
298{
299 walk->in.sg = src;
300 walk->out.sg = dst;
301 walk->total = nbytes;
302}
303
bf06099d
DM
304static inline void ablkcipher_walk_init(struct ablkcipher_walk *walk,
305 struct scatterlist *dst,
306 struct scatterlist *src,
307 unsigned int nbytes)
308{
309 walk->in.sg = src;
310 walk->out.sg = dst;
311 walk->total = nbytes;
312 INIT_LIST_HEAD(&walk->buffers);
313}
314
315static inline void ablkcipher_walk_complete(struct ablkcipher_walk *walk)
316{
317 if (unlikely(!list_empty(&walk->buffers)))
318 __ablkcipher_walk_complete(walk);
319}
320
b5b7f088
HX
321static inline struct crypto_async_request *crypto_get_backlog(
322 struct crypto_queue *queue)
323{
324 return queue->backlog == &queue->list ? NULL :
325 container_of(queue->backlog, struct crypto_async_request, list);
326}
327
2de98e75 328static inline int ablkcipher_enqueue_request(struct crypto_queue *queue,
b5b7f088
HX
329 struct ablkcipher_request *request)
330{
2de98e75 331 return crypto_enqueue_request(queue, &request->base);
b5b7f088
HX
332}
333
334static inline struct ablkcipher_request *ablkcipher_dequeue_request(
2de98e75 335 struct crypto_queue *queue)
b5b7f088 336{
2de98e75 337 return ablkcipher_request_cast(crypto_dequeue_request(queue));
b5b7f088
HX
338}
339
340static inline void *ablkcipher_request_ctx(struct ablkcipher_request *req)
341{
342 return req->__ctx;
343}
344
2de98e75
HX
345static inline int ablkcipher_tfm_in_queue(struct crypto_queue *queue,
346 struct crypto_ablkcipher *tfm)
b5b7f088 347{
2de98e75 348 return crypto_tfm_in_queue(queue, crypto_ablkcipher_tfm(tfm));
b5b7f088
HX
349}
350
3c09f17c
HX
351static inline struct crypto_alg *crypto_get_attr_alg(struct rtattr **tb,
352 u32 type, u32 mask)
353{
354 return crypto_attr_alg(tb[1], type, mask);
355}
356
378f4f51
HX
357/*
358 * Returns CRYPTO_ALG_ASYNC if type/mask requires the use of sync algorithms.
359 * Otherwise returns zero.
360 */
361static inline int crypto_requires_sync(u32 type, u32 mask)
362{
363 return (type ^ CRYPTO_ALG_ASYNC) & mask & CRYPTO_ALG_ASYNC;
364}
365
6bf37e5a
JY
366noinline unsigned long __crypto_memneq(const void *a, const void *b, size_t size);
367
368/**
369 * crypto_memneq - Compare two areas of memory without leaking
370 * timing information.
371 *
372 * @a: One area of memory
373 * @b: Another area of memory
374 * @size: The size of the area.
375 *
376 * Returns 0 when data is equal, 1 otherwise.
377 */
378static inline int crypto_memneq(const void *a, const void *b, size_t size)
379{
380 return __crypto_memneq(a, b, size) != 0UL ? 1 : 0;
381}
cce9e06d 382
bb55a4c1
MV
383static inline void crypto_yield(u32 flags)
384{
385 if (flags & CRYPTO_TFM_REQ_MAY_SLEEP)
386 cond_resched();
387}
388
6bf37e5a 389#endif /* _CRYPTO_ALGAPI_H */