Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * CMAC: Cipher Block Mode for Authentication
4 : : *
5 : : * Copyright © 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
6 : : *
7 : : * Based on work by:
8 : : * Copyright © 2013 Tom St Denis <tstdenis@elliptictech.com>
9 : : * Based on crypto/xcbc.c:
10 : : * Copyright © 2006 USAGI/WIDE Project,
11 : : * Author: Kazunori Miyazawa <miyazawa@linux-ipv6.org>
12 : : */
13 : :
14 : : #include <crypto/internal/hash.h>
15 : : #include <linux/err.h>
16 : : #include <linux/kernel.h>
17 : : #include <linux/module.h>
18 : :
19 : : /*
20 : : * +------------------------
21 : : * | <parent tfm>
22 : : * +------------------------
23 : : * | cmac_tfm_ctx
24 : : * +------------------------
25 : : * | consts (block size * 2)
26 : : * +------------------------
27 : : */
28 : : struct cmac_tfm_ctx {
29 : : struct crypto_cipher *child;
30 : : u8 ctx[];
31 : : };
32 : :
33 : : /*
34 : : * +------------------------
35 : : * | <shash desc>
36 : : * +------------------------
37 : : * | cmac_desc_ctx
38 : : * +------------------------
39 : : * | odds (block size)
40 : : * +------------------------
41 : : * | prev (block size)
42 : : * +------------------------
43 : : */
44 : : struct cmac_desc_ctx {
45 : : unsigned int len;
46 : : u8 ctx[];
47 : : };
48 : :
49 : 0 : static int crypto_cmac_digest_setkey(struct crypto_shash *parent,
50 : : const u8 *inkey, unsigned int keylen)
51 : : {
52 : 0 : unsigned long alignmask = crypto_shash_alignmask(parent);
53 : 0 : struct cmac_tfm_ctx *ctx = crypto_shash_ctx(parent);
54 : 0 : unsigned int bs = crypto_shash_blocksize(parent);
55 : 0 : __be64 *consts = PTR_ALIGN((void *)ctx->ctx,
56 : : (alignmask | (__alignof__(__be64) - 1)) + 1);
57 : 0 : u64 _const[2];
58 : 0 : int i, err = 0;
59 : 0 : u8 msb_mask, gfmask;
60 : :
61 : 0 : err = crypto_cipher_setkey(ctx->child, inkey, keylen);
62 [ # # ]: 0 : if (err)
63 : : return err;
64 : :
65 : : /* encrypt the zero block */
66 : 0 : memset(consts, 0, bs);
67 : 0 : crypto_cipher_encrypt_one(ctx->child, (u8 *)consts, (u8 *)consts);
68 : :
69 [ # # # ]: 0 : switch (bs) {
70 : 0 : case 16:
71 : 0 : gfmask = 0x87;
72 : 0 : _const[0] = be64_to_cpu(consts[1]);
73 : 0 : _const[1] = be64_to_cpu(consts[0]);
74 : :
75 : : /* gf(2^128) multiply zero-ciphertext with u and u^2 */
76 [ # # ]: 0 : for (i = 0; i < 4; i += 2) {
77 : 0 : msb_mask = ((s64)_const[1] >> 63) & gfmask;
78 : 0 : _const[1] = (_const[1] << 1) | (_const[0] >> 63);
79 : 0 : _const[0] = (_const[0] << 1) ^ msb_mask;
80 : :
81 : 0 : consts[i + 0] = cpu_to_be64(_const[1]);
82 : 0 : consts[i + 1] = cpu_to_be64(_const[0]);
83 : : }
84 : :
85 : : break;
86 : 0 : case 8:
87 : 0 : gfmask = 0x1B;
88 : 0 : _const[0] = be64_to_cpu(consts[0]);
89 : :
90 : : /* gf(2^64) multiply zero-ciphertext with u and u^2 */
91 [ # # ]: 0 : for (i = 0; i < 2; i++) {
92 : 0 : msb_mask = ((s64)_const[0] >> 63) & gfmask;
93 : 0 : _const[0] = (_const[0] << 1) ^ msb_mask;
94 : :
95 : 0 : consts[i] = cpu_to_be64(_const[0]);
96 : : }
97 : :
98 : : break;
99 : : }
100 : :
101 : : return 0;
102 : : }
103 : :
104 : 0 : static int crypto_cmac_digest_init(struct shash_desc *pdesc)
105 : : {
106 : 0 : unsigned long alignmask = crypto_shash_alignmask(pdesc->tfm);
107 : 0 : struct cmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
108 : 0 : int bs = crypto_shash_blocksize(pdesc->tfm);
109 : 0 : u8 *prev = PTR_ALIGN((void *)ctx->ctx, alignmask + 1) + bs;
110 : :
111 : 0 : ctx->len = 0;
112 : 0 : memset(prev, 0, bs);
113 : :
114 : 0 : return 0;
115 : : }
116 : :
117 : 0 : static int crypto_cmac_digest_update(struct shash_desc *pdesc, const u8 *p,
118 : : unsigned int len)
119 : : {
120 : 0 : struct crypto_shash *parent = pdesc->tfm;
121 [ # # ]: 0 : unsigned long alignmask = crypto_shash_alignmask(parent);
122 [ # # ]: 0 : struct cmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
123 [ # # ]: 0 : struct cmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
124 : 0 : struct crypto_cipher *tfm = tctx->child;
125 [ # # ]: 0 : int bs = crypto_shash_blocksize(parent);
126 : 0 : u8 *odds = PTR_ALIGN((void *)ctx->ctx, alignmask + 1);
127 : 0 : u8 *prev = odds + bs;
128 : :
129 : : /* checking the data can fill the block */
130 [ # # ]: 0 : if ((ctx->len + len) <= bs) {
131 : 0 : memcpy(odds + ctx->len, p, len);
132 : 0 : ctx->len += len;
133 : 0 : return 0;
134 : : }
135 : :
136 : : /* filling odds with new data and encrypting it */
137 : 0 : memcpy(odds + ctx->len, p, bs - ctx->len);
138 : 0 : len -= bs - ctx->len;
139 : 0 : p += bs - ctx->len;
140 : :
141 : 0 : crypto_xor(prev, odds, bs);
142 : 0 : crypto_cipher_encrypt_one(tfm, prev, prev);
143 : :
144 : : /* clearing the length */
145 : 0 : ctx->len = 0;
146 : :
147 : : /* encrypting the rest of data */
148 [ # # ]: 0 : while (len > bs) {
149 : 0 : crypto_xor(prev, p, bs);
150 : 0 : crypto_cipher_encrypt_one(tfm, prev, prev);
151 : 0 : p += bs;
152 : 0 : len -= bs;
153 : : }
154 : :
155 : : /* keeping the surplus of blocksize */
156 [ # # ]: 0 : if (len) {
157 : 0 : memcpy(odds, p, len);
158 : 0 : ctx->len = len;
159 : : }
160 : :
161 : : return 0;
162 : : }
163 : :
164 : 0 : static int crypto_cmac_digest_final(struct shash_desc *pdesc, u8 *out)
165 : : {
166 : 0 : struct crypto_shash *parent = pdesc->tfm;
167 [ # # ]: 0 : unsigned long alignmask = crypto_shash_alignmask(parent);
168 [ # # ]: 0 : struct cmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
169 [ # # ]: 0 : struct cmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
170 : 0 : struct crypto_cipher *tfm = tctx->child;
171 [ # # ]: 0 : int bs = crypto_shash_blocksize(parent);
172 : 0 : u8 *consts = PTR_ALIGN((void *)tctx->ctx,
173 : : (alignmask | (__alignof__(__be64) - 1)) + 1);
174 : 0 : u8 *odds = PTR_ALIGN((void *)ctx->ctx, alignmask + 1);
175 : 0 : u8 *prev = odds + bs;
176 : 0 : unsigned int offset = 0;
177 : :
178 [ # # ]: 0 : if (ctx->len != bs) {
179 : 0 : unsigned int rlen;
180 : 0 : u8 *p = odds + ctx->len;
181 : :
182 : 0 : *p = 0x80;
183 : 0 : p++;
184 : :
185 : 0 : rlen = bs - ctx->len - 1;
186 [ # # ]: 0 : if (rlen)
187 : 0 : memset(p, 0, rlen);
188 : :
189 : : offset += bs;
190 : : }
191 : :
192 : 0 : crypto_xor(prev, odds, bs);
193 : 0 : crypto_xor(prev, consts + offset, bs);
194 : :
195 : 0 : crypto_cipher_encrypt_one(tfm, out, prev);
196 : :
197 : 0 : return 0;
198 : : }
199 : :
200 : 0 : static int cmac_init_tfm(struct crypto_tfm *tfm)
201 : : {
202 : 0 : struct crypto_cipher *cipher;
203 : 0 : struct crypto_instance *inst = (void *)tfm->__crt_alg;
204 : 0 : struct crypto_cipher_spawn *spawn = crypto_instance_ctx(inst);
205 : 0 : struct cmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
206 : :
207 : 0 : cipher = crypto_spawn_cipher(spawn);
208 [ # # ]: 0 : if (IS_ERR(cipher))
209 : 0 : return PTR_ERR(cipher);
210 : :
211 : 0 : ctx->child = cipher;
212 : :
213 : 0 : return 0;
214 : : };
215 : :
216 : 0 : static void cmac_exit_tfm(struct crypto_tfm *tfm)
217 : : {
218 : 0 : struct cmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
219 : 0 : crypto_free_cipher(ctx->child);
220 : 0 : }
221 : :
222 : 0 : static int cmac_create(struct crypto_template *tmpl, struct rtattr **tb)
223 : : {
224 : 0 : struct shash_instance *inst;
225 : 0 : struct crypto_cipher_spawn *spawn;
226 : 0 : struct crypto_alg *alg;
227 : 0 : unsigned long alignmask;
228 : 0 : int err;
229 : :
230 : 0 : err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH);
231 [ # # ]: 0 : if (err)
232 : : return err;
233 : :
234 : 0 : inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
235 [ # # ]: 0 : if (!inst)
236 : : return -ENOMEM;
237 : 0 : spawn = shash_instance_ctx(inst);
238 : :
239 : 0 : err = crypto_grab_cipher(spawn, shash_crypto_instance(inst),
240 : : crypto_attr_alg_name(tb[1]), 0, 0);
241 [ # # ]: 0 : if (err)
242 : 0 : goto err_free_inst;
243 [ # # ]: 0 : alg = crypto_spawn_cipher_alg(spawn);
244 : :
245 [ # # ]: 0 : switch (alg->cra_blocksize) {
246 : : case 16:
247 : : case 8:
248 : 0 : break;
249 : 0 : default:
250 : 0 : err = -EINVAL;
251 : 0 : goto err_free_inst;
252 : : }
253 : :
254 : 0 : err = crypto_inst_setname(shash_crypto_instance(inst), tmpl->name, alg);
255 [ # # ]: 0 : if (err)
256 : 0 : goto err_free_inst;
257 : :
258 : 0 : alignmask = alg->cra_alignmask;
259 : 0 : inst->alg.base.cra_alignmask = alignmask;
260 : 0 : inst->alg.base.cra_priority = alg->cra_priority;
261 : 0 : inst->alg.base.cra_blocksize = alg->cra_blocksize;
262 : :
263 : 0 : inst->alg.digestsize = alg->cra_blocksize;
264 : 0 : inst->alg.descsize =
265 : : ALIGN(sizeof(struct cmac_desc_ctx), crypto_tfm_ctx_alignment())
266 : 0 : + (alignmask & ~(crypto_tfm_ctx_alignment() - 1))
267 : 0 : + alg->cra_blocksize * 2;
268 : :
269 : 0 : inst->alg.base.cra_ctxsize =
270 : : ALIGN(sizeof(struct cmac_tfm_ctx), crypto_tfm_ctx_alignment())
271 : : + ((alignmask | (__alignof__(__be64) - 1)) &
272 : : ~(crypto_tfm_ctx_alignment() - 1))
273 : 0 : + alg->cra_blocksize * 2;
274 : :
275 : 0 : inst->alg.base.cra_init = cmac_init_tfm;
276 : 0 : inst->alg.base.cra_exit = cmac_exit_tfm;
277 : :
278 : 0 : inst->alg.init = crypto_cmac_digest_init;
279 : 0 : inst->alg.update = crypto_cmac_digest_update;
280 : 0 : inst->alg.final = crypto_cmac_digest_final;
281 : 0 : inst->alg.setkey = crypto_cmac_digest_setkey;
282 : :
283 : 0 : inst->free = shash_free_singlespawn_instance;
284 : :
285 : 0 : err = shash_register_instance(tmpl, inst);
286 [ # # ]: 0 : if (err) {
287 : 0 : err_free_inst:
288 : 0 : shash_free_singlespawn_instance(inst);
289 : : }
290 : : return err;
291 : : }
292 : :
293 : : static struct crypto_template crypto_cmac_tmpl = {
294 : : .name = "cmac",
295 : : .create = cmac_create,
296 : : .module = THIS_MODULE,
297 : : };
298 : :
299 : 13 : static int __init crypto_cmac_module_init(void)
300 : : {
301 : 13 : return crypto_register_template(&crypto_cmac_tmpl);
302 : : }
303 : :
304 : 0 : static void __exit crypto_cmac_module_exit(void)
305 : : {
306 : 0 : crypto_unregister_template(&crypto_cmac_tmpl);
307 : 0 : }
308 : :
309 : : subsys_initcall(crypto_cmac_module_init);
310 : : module_exit(crypto_cmac_module_exit);
311 : :
312 : : MODULE_LICENSE("GPL");
313 : : MODULE_DESCRIPTION("CMAC keyed hash algorithm");
314 : : MODULE_ALIAS_CRYPTO("cmac");
|
