write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/crypto/ctr.c
..
..
@@ -1,29 +1,19 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /*
2
3
  * CTR: Counter mode
3
4
  *
4
5
  * (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com>
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
6
  */
12
7
 
13
8
 #include <crypto/algapi.h>
14
9
 #include <crypto/ctr.h>
10
+#include <crypto/internal/cipher.h>
15
11
 #include <crypto/internal/skcipher.h>
16
12
 #include <linux/err.h>
17
13
 #include <linux/init.h>
18
14
 #include <linux/kernel.h>
19
15
 #include <linux/module.h>
20
-#include <linux/random.h>
21
-#include <linux/scatterlist.h>
22
16
 #include <linux/slab.h>
23
-
24
-struct crypto_ctr_ctx {
25
-	struct crypto_cipher *child;
26
-};
27
17
 
28
18
 struct crypto_rfc3686_ctx {
29
19
 	struct crypto_skcipher *child;
..
..
@@ -35,24 +25,7 @@
35
25
 	struct skcipher_request subreq CRYPTO_MINALIGN_ATTR;
36
26
 };
37
27
 
38
-static int crypto_ctr_setkey(struct crypto_tfm *parent, const u8 *key,
39
-			     unsigned int keylen)
40
-{
41
-	struct crypto_ctr_ctx *ctx = crypto_tfm_ctx(parent);
42
-	struct crypto_cipher *child = ctx->child;
43
-	int err;
44
-
45
-	crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
46
-	crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) &
47
-				CRYPTO_TFM_REQ_MASK);
48
-	err = crypto_cipher_setkey(child, key, keylen);
49
-	crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) &
50
-			     CRYPTO_TFM_RES_MASK);
51
-
52
-	return err;
53
-}
54
-
55
-static void crypto_ctr_crypt_final(struct blkcipher_walk *walk,
28
+static void crypto_ctr_crypt_final(struct skcipher_walk *walk,
56
29
 				   struct crypto_cipher *tfm)
57
30
 {
58
31
 	unsigned int bsize = crypto_cipher_blocksize(tfm);
..
..
@@ -70,7 +43,7 @@
70
43
 	crypto_inc(ctrblk, bsize);
71
44
 }
72
45
 
73
-static int crypto_ctr_crypt_segment(struct blkcipher_walk *walk,
46
+static int crypto_ctr_crypt_segment(struct skcipher_walk *walk,
74
47
 				    struct crypto_cipher *tfm)
75
48
 {
76
49
 	void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
..
..
@@ -96,7 +69,7 @@
96
69
 	return nbytes;
97
70
 }
98
71
 
99
-static int crypto_ctr_crypt_inplace(struct blkcipher_walk *walk,
72
+static int crypto_ctr_crypt_inplace(struct skcipher_walk *walk,
100
73
 				    struct crypto_cipher *tfm)
101
74
 {
102
75
 	void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
..
..
@@ -123,146 +96,81 @@
123
96
 	return nbytes;
124
97
 }
125
98
 
126
-static int crypto_ctr_crypt(struct blkcipher_desc *desc,
127
-			      struct scatterlist *dst, struct scatterlist *src,
128
-			      unsigned int nbytes)
99
+static int crypto_ctr_crypt(struct skcipher_request *req)
129
100
 {
130
-	struct blkcipher_walk walk;
131
-	struct crypto_blkcipher *tfm = desc->tfm;
132
-	struct crypto_ctr_ctx *ctx = crypto_blkcipher_ctx(tfm);
133
-	struct crypto_cipher *child = ctx->child;
134
-	unsigned int bsize = crypto_cipher_blocksize(child);
101
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
102
+	struct crypto_cipher *cipher = skcipher_cipher_simple(tfm);
103
+	const unsigned int bsize = crypto_cipher_blocksize(cipher);
104
+	struct skcipher_walk walk;
105
+	unsigned int nbytes;
135
106
 	int err;
136
107
 
137
-	blkcipher_walk_init(&walk, dst, src, nbytes);
138
-	err = blkcipher_walk_virt_block(desc, &walk, bsize);
108
+	err = skcipher_walk_virt(&walk, req, false);
139
109
 
140
110
 	while (walk.nbytes >= bsize) {
141
111
 		if (walk.src.virt.addr == walk.dst.virt.addr)
142
-			nbytes = crypto_ctr_crypt_inplace(&walk, child);
112
+			nbytes = crypto_ctr_crypt_inplace(&walk, cipher);
143
113
 		else
144
-			nbytes = crypto_ctr_crypt_segment(&walk, child);
114
+			nbytes = crypto_ctr_crypt_segment(&walk, cipher);
145
115
 
146
-		err = blkcipher_walk_done(desc, &walk, nbytes);
116
+		err = skcipher_walk_done(&walk, nbytes);
147
117
 	}
148
118
 
149
119
 	if (walk.nbytes) {
150
-		crypto_ctr_crypt_final(&walk, child);
151
-		err = blkcipher_walk_done(desc, &walk, 0);
120
+		crypto_ctr_crypt_final(&walk, cipher);
121
+		err = skcipher_walk_done(&walk, 0);
152
122
 	}
153
123
 
154
124
 	return err;
155
125
 }
156
126
 
157
-static int crypto_ctr_init_tfm(struct crypto_tfm *tfm)
127
+static int crypto_ctr_create(struct crypto_template *tmpl, struct rtattr **tb)
158
128
 {
159
-	struct crypto_instance *inst = (void *)tfm->__crt_alg;
160
-	struct crypto_spawn *spawn = crypto_instance_ctx(inst);
161
-	struct crypto_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
162
-	struct crypto_cipher *cipher;
163
-
164
-	cipher = crypto_spawn_cipher(spawn);
165
-	if (IS_ERR(cipher))
166
-		return PTR_ERR(cipher);
167
-
168
-	ctx->child = cipher;
169
-
170
-	return 0;
171
-}
172
-
173
-static void crypto_ctr_exit_tfm(struct crypto_tfm *tfm)
174
-{
175
-	struct crypto_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
176
-
177
-	crypto_free_cipher(ctx->child);
178
-}
179
-
180
-static struct crypto_instance *crypto_ctr_alloc(struct rtattr **tb)
181
-{
182
-	struct crypto_instance *inst;
183
-	struct crypto_attr_type *algt;
129
+	struct skcipher_instance *inst;
184
130
 	struct crypto_alg *alg;
185
-	u32 mask;
186
131
 	int err;
187
132
 
188
-	err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER);
189
-	if (err)
190
-		return ERR_PTR(err);
133
+	inst = skcipher_alloc_instance_simple(tmpl, tb);
134
+	if (IS_ERR(inst))
135
+		return PTR_ERR(inst);
191
136
 
192
-	algt = crypto_get_attr_type(tb);
193
-	if (IS_ERR(algt))
194
-		return ERR_CAST(algt);
195
-
196
-	mask = CRYPTO_ALG_TYPE_MASK |
197
-		crypto_requires_off(algt->type, algt->mask,
198
-				    CRYPTO_ALG_NEED_FALLBACK);
199
-
200
-	alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_CIPHER, mask);
201
-	if (IS_ERR(alg))
202
-		return ERR_CAST(alg);
137
+	alg = skcipher_ialg_simple(inst);
203
138
 
204
139
 	/* Block size must be >= 4 bytes. */
205
140
 	err = -EINVAL;
206
141
 	if (alg->cra_blocksize < 4)
207
-		goto out_put_alg;
142
+		goto out_free_inst;
208
143
 
209
144
 	/* If this is false we'd fail the alignment of crypto_inc. */
210
145
 	if (alg->cra_blocksize % 4)
211
-		goto out_put_alg;
146
+		goto out_free_inst;
212
147
 
213
-	inst = crypto_alloc_instance("ctr", alg);
214
-	if (IS_ERR(inst))
215
-		goto out;
148
+	/* CTR mode is a stream cipher. */
149
+	inst->alg.base.cra_blocksize = 1;
216
150
 
217
-	inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER;
218
-	inst->alg.cra_priority = alg->cra_priority;
219
-	inst->alg.cra_blocksize = 1;
220
-	inst->alg.cra_alignmask = alg->cra_alignmask;
221
-	inst->alg.cra_type = &crypto_blkcipher_type;
151
+	/*
152
+	 * To simplify the implementation, configure the skcipher walk to only
153
+	 * give a partial block at the very end, never earlier.
154
+	 */
155
+	inst->alg.chunksize = alg->cra_blocksize;
222
156
 
223
-	inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize;
224
-	inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize;
225
-	inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize;
157
+	inst->alg.encrypt = crypto_ctr_crypt;
158
+	inst->alg.decrypt = crypto_ctr_crypt;
226
159
 
227
-	inst->alg.cra_ctxsize = sizeof(struct crypto_ctr_ctx);
160
+	err = skcipher_register_instance(tmpl, inst);
161
+	if (err) {
162
+out_free_inst:
163
+		inst->free(inst);
164
+	}
228
165
 
229
-	inst->alg.cra_init = crypto_ctr_init_tfm;
230
-	inst->alg.cra_exit = crypto_ctr_exit_tfm;
231
-
232
-	inst->alg.cra_blkcipher.setkey = crypto_ctr_setkey;
233
-	inst->alg.cra_blkcipher.encrypt = crypto_ctr_crypt;
234
-	inst->alg.cra_blkcipher.decrypt = crypto_ctr_crypt;
235
-
236
-	inst->alg.cra_blkcipher.geniv = "chainiv";
237
-
238
-out:
239
-	crypto_mod_put(alg);
240
-	return inst;
241
-
242
-out_put_alg:
243
-	inst = ERR_PTR(err);
244
-	goto out;
166
+	return err;
245
167
 }
246
-
247
-static void crypto_ctr_free(struct crypto_instance *inst)
248
-{
249
-	crypto_drop_spawn(crypto_instance_ctx(inst));
250
-	kfree(inst);
251
-}
252
-
253
-static struct crypto_template crypto_ctr_tmpl = {
254
-	.name = "ctr",
255
-	.alloc = crypto_ctr_alloc,
256
-	.free = crypto_ctr_free,
257
-	.module = THIS_MODULE,
258
-};
259
168
 
260
169
 static int crypto_rfc3686_setkey(struct crypto_skcipher *parent,
261
170
 				 const u8 *key, unsigned int keylen)
262
171
 {
263
172
 	struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(parent);
264
173
 	struct crypto_skcipher *child = ctx->child;
265
-	int err;
266
174
 
267
175
 	/* the nonce is stored in bytes at end of key */
268
176
 	if (keylen < CTR_RFC3686_NONCE_SIZE)
..
..
@@ -276,11 +184,7 @@
276
184
 	crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
277
185
 	crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) &
278
186
 					 CRYPTO_TFM_REQ_MASK);
279
-	err = crypto_skcipher_setkey(child, key, keylen);
280
-	crypto_skcipher_set_flags(parent, crypto_skcipher_get_flags(child) &
281
-					  CRYPTO_TFM_RES_MASK);
282
-
283
-	return err;
187
+	return crypto_skcipher_setkey(child, key, keylen);
284
188
 }
285
189
 
286
190
 static int crypto_rfc3686_crypt(struct skcipher_request *req)
..
..
@@ -353,38 +257,24 @@
353
257
 static int crypto_rfc3686_create(struct crypto_template *tmpl,
354
258
 				 struct rtattr **tb)
355
259
 {
356
-	struct crypto_attr_type *algt;
357
260
 	struct skcipher_instance *inst;
358
261
 	struct skcipher_alg *alg;
359
262
 	struct crypto_skcipher_spawn *spawn;
360
-	const char *cipher_name;
361
263
 	u32 mask;
362
-
363
264
 	int err;
364
265
 
365
-	algt = crypto_get_attr_type(tb);
366
-	if (IS_ERR(algt))
367
-		return PTR_ERR(algt);
368
-
369
-	if ((algt->type ^ CRYPTO_ALG_TYPE_SKCIPHER) & algt->mask)
370
-		return -EINVAL;
371
-
372
-	cipher_name = crypto_attr_alg_name(tb[1]);
373
-	if (IS_ERR(cipher_name))
374
-		return PTR_ERR(cipher_name);
266
+	err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SKCIPHER, &mask);
267
+	if (err)
268
+		return err;
375
269
 
376
270
 	inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
377
271
 	if (!inst)
378
272
 		return -ENOMEM;
379
273
 
380
-	mask = crypto_requires_sync(algt->type, algt->mask) |
381
-		crypto_requires_off(algt->type, algt->mask,
382
-				    CRYPTO_ALG_NEED_FALLBACK);
383
-
384
274
 	spawn = skcipher_instance_ctx(inst);
385
275
 
386
-	crypto_set_skcipher_spawn(spawn, skcipher_crypto_instance(inst));
387
-	err = crypto_grab_skcipher(spawn, cipher_name, 0, mask);
276
+	err = crypto_grab_skcipher(spawn, skcipher_crypto_instance(inst),
277
+				   crypto_attr_alg_name(tb[1]), 0, mask);
388
278
 	if (err)
389
279
 		goto err_free_inst;
390
280
 
..
..
@@ -393,26 +283,24 @@
393
283
 	/* We only support 16-byte blocks. */
394
284
 	err = -EINVAL;
395
285
 	if (crypto_skcipher_alg_ivsize(alg) != CTR_RFC3686_BLOCK_SIZE)
396
-		goto err_drop_spawn;
286
+		goto err_free_inst;
397
287
 
398
288
 	/* Not a stream cipher? */
399
289
 	if (alg->base.cra_blocksize != 1)
400
-		goto err_drop_spawn;
290
+		goto err_free_inst;
401
291
 
402
292
 	err = -ENAMETOOLONG;
403
293
 	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
404
294
 		     "rfc3686(%s)", alg->base.cra_name) >= CRYPTO_MAX_ALG_NAME)
405
-		goto err_drop_spawn;
295
+		goto err_free_inst;
406
296
 	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
407
297
 		     "rfc3686(%s)", alg->base.cra_driver_name) >=
408
298
 	    CRYPTO_MAX_ALG_NAME)
409
-		goto err_drop_spawn;
299
+		goto err_free_inst;
410
300
 
411
301
 	inst->alg.base.cra_priority = alg->base.cra_priority;
412
302
 	inst->alg.base.cra_blocksize = 1;
413
303
 	inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
414
-
415
-	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
416
304
 
417
305
 	inst->alg.ivsize = CTR_RFC3686_IV_SIZE;
418
306
 	inst->alg.chunksize = crypto_skcipher_alg_chunksize(alg);
..
..
@@ -433,55 +321,42 @@
433
321
 	inst->free = crypto_rfc3686_free;
434
322
 
435
323
 	err = skcipher_register_instance(tmpl, inst);
436
-	if (err)
437
-		goto err_drop_spawn;
438
-
439
-out:
440
-	return err;
441
-
442
-err_drop_spawn:
443
-	crypto_drop_skcipher(spawn);
324
+	if (err) {
444
325
 err_free_inst:
445
-	kfree(inst);
446
-	goto out;
326
+		crypto_rfc3686_free(inst);
327
+	}
328
+	return err;
447
329
 }
448
330
 
449
-static struct crypto_template crypto_rfc3686_tmpl = {
450
-	.name = "rfc3686",
451
-	.create = crypto_rfc3686_create,
452
-	.module = THIS_MODULE,
331
+static struct crypto_template crypto_ctr_tmpls[] = {
332
+	{
333
+		.name = "ctr",
334
+		.create = crypto_ctr_create,
335
+		.module = THIS_MODULE,
336
+	}, {
337
+		.name = "rfc3686",
338
+		.create = crypto_rfc3686_create,
339
+		.module = THIS_MODULE,
340
+	},
453
341
 };
454
342
 
455
343
 static int __init crypto_ctr_module_init(void)
456
344
 {
457
-	int err;
458
-
459
-	err = crypto_register_template(&crypto_ctr_tmpl);
460
-	if (err)
461
-		goto out;
462
-
463
-	err = crypto_register_template(&crypto_rfc3686_tmpl);
464
-	if (err)
465
-		goto out_drop_ctr;
466
-
467
-out:
468
-	return err;
469
-
470
-out_drop_ctr:
471
-	crypto_unregister_template(&crypto_ctr_tmpl);
472
-	goto out;
345
+	return crypto_register_templates(crypto_ctr_tmpls,
346
+					 ARRAY_SIZE(crypto_ctr_tmpls));
473
347
 }
474
348
 
475
349
 static void __exit crypto_ctr_module_exit(void)
476
350
 {
477
-	crypto_unregister_template(&crypto_rfc3686_tmpl);
478
-	crypto_unregister_template(&crypto_ctr_tmpl);
351
+	crypto_unregister_templates(crypto_ctr_tmpls,
352
+				    ARRAY_SIZE(crypto_ctr_tmpls));
479
353
 }
480
354
 
481
-module_init(crypto_ctr_module_init);
355
+subsys_initcall(crypto_ctr_module_init);
482
356
 module_exit(crypto_ctr_module_exit);
483
357
 
484
358
 MODULE_LICENSE("GPL");
485
-MODULE_DESCRIPTION("CTR Counter block mode");
359
+MODULE_DESCRIPTION("CTR block cipher mode of operation");
486
360
 MODULE_ALIAS_CRYPTO("rfc3686");
487
361
 MODULE_ALIAS_CRYPTO("ctr");
362
+MODULE_IMPORT_NS(CRYPTO_INTERNAL);