1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3 * AEAD: Authenticated Encryption with Associated Data
4 *
5 * Copyright (c) 2007-2015 Herbert Xu <herbert@gondor.apana.org.au>
6 */
7
8 #ifndef _CRYPTO_INTERNAL_AEAD_H
9 #define _CRYPTO_INTERNAL_AEAD_H
10
11 #include <crypto/aead.h>
12 #include <crypto/algapi.h>
13 #include <linux/stddef.h>
14 #include <linux/types.h>
15
16 struct rtattr;
17
18 struct aead_instance {
19 void (*free)(struct aead_instance *inst);
20 union {
21 struct {
22 char head[offsetof(struct aead_alg, base)];
23 struct crypto_instance base;
24 } s;
25 struct aead_alg alg;
26 };
27 };
28
29 struct crypto_aead_spawn {
30 struct crypto_spawn base;
31 };
32
33 struct aead_queue {
34 struct crypto_queue base;
35 };
36
37 static inline void *crypto_aead_ctx(struct crypto_aead *tfm)
38 {
39 return crypto_tfm_ctx(&tfm->base);
40 }
41
42 static inline void *crypto_aead_ctx_dma(struct crypto_aead *tfm)
43 {
44 return crypto_tfm_ctx_dma(&tfm->base);
45 }
46
47 static inline struct crypto_instance *aead_crypto_instance(
48 struct aead_instance *inst)
49 {
50 return container_of(&inst->alg.base, struct crypto_instance, alg);
51 }
52
53 static inline struct aead_instance *aead_instance(struct crypto_instance *inst)
54 {
55 return container_of(&inst->alg, struct aead_instance, alg.base);
56 }
57
58 static inline struct aead_instance *aead_alg_instance(struct crypto_aead *aead)
59 {
60 return aead_instance(crypto_tfm_alg_instance(&aead->base));
61 }
62
63 static inline void *aead_instance_ctx(struct aead_instance *inst)
64 {
65 return crypto_instance_ctx(aead_crypto_instance(inst));
66 }
67
68 static inline void *aead_request_ctx(struct aead_request *req)
69 {
70 return req->__ctx;
71 }
72
73 static inline void *aead_request_ctx_dma(struct aead_request *req)
74 {
75 unsigned int align = crypto_dma_align();
76
77 if (align <= crypto_tfm_ctx_alignment())
78 align = 1;
79
80 return PTR_ALIGN(aead_request_ctx(req), align);
81 }
82
83 static inline void aead_request_complete(struct aead_request *req, int err)
84 {
85 crypto_request_complete(&req->base, err);
86 }
87
88 static inline u32 aead_request_flags(struct aead_request *req)
89 {
90 return req->base.flags;
91 }
92
93 static inline struct aead_request *aead_request_cast(
94 struct crypto_async_request *req)
95 {
96 return container_of(req, struct aead_request, base);
97 }
98
99 int crypto_grab_aead(struct crypto_aead_spawn *spawn,
100 struct crypto_instance *inst,
101 const char *name, u32 type, u32 mask);
102
103 static inline void crypto_drop_aead(struct crypto_aead_spawn *spawn)
104 {
105 crypto_drop_spawn(&spawn->base);
106 }
107
108 static inline struct aead_alg *crypto_spawn_aead_alg(
109 struct crypto_aead_spawn *spawn)
110 {
111 return container_of(spawn->base.alg, struct aead_alg, base);
112 }
113
114 static inline struct crypto_aead *crypto_spawn_aead(
115 struct crypto_aead_spawn *spawn)
116 {
117 return crypto_spawn_tfm2(&spawn->base);
118 }
119
120 static inline void crypto_aead_set_reqsize(struct crypto_aead *aead,
121 unsigned int reqsize)
122 {
123 aead->reqsize = reqsize;
124 }
125
126 static inline void crypto_aead_set_reqsize_dma(struct crypto_aead *aead,
127 unsigned int reqsize)
128 {
129 reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);
130 aead->reqsize = reqsize;
131 }
132
133 static inline void aead_init_queue(struct aead_queue *queue,
134 unsigned int max_qlen)
135 {
136 crypto_init_queue(&queue->base, max_qlen);
137 }
138
139 static inline unsigned int crypto_aead_alg_chunksize(struct aead_alg *alg)
140 {
141 return alg->chunksize;
142 }
143
144 /**
145 * crypto_aead_chunksize() - obtain chunk size
146 * @tfm: cipher handle
147 *
148 * The block size is set to one for ciphers such as CCM. However,
149 * you still need to provide incremental updates in multiples of
150 * the underlying block size as the IV does not have sub-block
151 * granularity. This is known in this API as the chunk size.
152 *
153 * Return: chunk size in bytes
154 */
155 static inline unsigned int crypto_aead_chunksize(struct crypto_aead *tfm)
156 {
157 return crypto_aead_alg_chunksize(crypto_aead_alg(tfm));
158 }
159
160 int crypto_register_aead(struct aead_alg *alg);
161 void crypto_unregister_aead(struct aead_alg *alg);
162 int crypto_register_aeads(struct aead_alg *algs, int count);
163 void crypto_unregister_aeads(struct aead_alg *algs, int count);
164 int aead_register_instance(struct crypto_template *tmpl,
165 struct aead_instance *inst);
166
167 #endif /* _CRYPTO_INTERNAL_AEAD_H */
168
169
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.