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 
13 #include <crypto/algapi.h>
14 #include <linux/err.h>
15 #include <linux/errno.h>
16 #include <linux/fips.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/list.h>
20 #include <linux/module.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/slab.h>
23 #include <linux/string.h>
24 
25 #include "internal.h"
26 
27 static LIST_HEAD(crypto_template_list);
28 
crypto_set_driver_name(struct crypto_alg * alg)29 static inline int crypto_set_driver_name(struct crypto_alg *alg)
30 {
31 	static const char suffix[] = "-generic";
32 	char *driver_name = alg->cra_driver_name;
33 	int len;
34 
35 	if (*driver_name)
36 		return 0;
37 
38 	len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
39 	if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
40 		return -ENAMETOOLONG;
41 
42 	memcpy(driver_name + len, suffix, sizeof(suffix));
43 	return 0;
44 }
45 
crypto_check_module_sig(struct module * mod)46 static inline void crypto_check_module_sig(struct module *mod)
47 {
48 	if (fips_enabled && mod && !module_sig_ok(mod))
49 		panic("Module %s signature verification failed in FIPS mode\n",
50 		      module_name(mod));
51 }
52 
crypto_check_alg(struct crypto_alg * alg)53 static int crypto_check_alg(struct crypto_alg *alg)
54 {
55 	crypto_check_module_sig(alg->cra_module);
56 
57 	if (alg->cra_alignmask & (alg->cra_alignmask + 1))
58 		return -EINVAL;
59 
60 	if (alg->cra_blocksize > PAGE_SIZE / 8)
61 		return -EINVAL;
62 
63 	if (!alg->cra_type && (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
64 			       CRYPTO_ALG_TYPE_CIPHER) {
65 		if (alg->cra_alignmask > MAX_CIPHER_ALIGNMASK)
66 			return -EINVAL;
67 
68 		if (alg->cra_blocksize > MAX_CIPHER_BLOCKSIZE)
69 			return -EINVAL;
70 	}
71 
72 	if (alg->cra_priority < 0)
73 		return -EINVAL;
74 
75 	refcount_set(&alg->cra_refcnt, 1);
76 
77 	return crypto_set_driver_name(alg);
78 }
79 
crypto_free_instance(struct crypto_instance * inst)80 static void crypto_free_instance(struct crypto_instance *inst)
81 {
82 	if (!inst->alg.cra_type->free) {
83 		inst->tmpl->free(inst);
84 		return;
85 	}
86 
87 	inst->alg.cra_type->free(inst);
88 }
89 
crypto_destroy_instance(struct crypto_alg * alg)90 static void crypto_destroy_instance(struct crypto_alg *alg)
91 {
92 	struct crypto_instance *inst = (void *)alg;
93 	struct crypto_template *tmpl = inst->tmpl;
94 
95 	crypto_free_instance(inst);
96 	crypto_tmpl_put(tmpl);
97 }
98 
crypto_more_spawns(struct crypto_alg * alg,struct list_head * stack,struct list_head * top,struct list_head * secondary_spawns)99 static struct list_head *crypto_more_spawns(struct crypto_alg *alg,
100 					    struct list_head *stack,
101 					    struct list_head *top,
102 					    struct list_head *secondary_spawns)
103 {
104 	struct crypto_spawn *spawn, *n;
105 
106 	spawn = list_first_entry_or_null(stack, struct crypto_spawn, list);
107 	if (!spawn)
108 		return NULL;
109 
110 	n = list_next_entry(spawn, list);
111 
112 	if (spawn->alg && &n->list != stack && !n->alg)
113 		n->alg = (n->list.next == stack) ? alg :
114 			 &list_next_entry(n, list)->inst->alg;
115 
116 	list_move(&spawn->list, secondary_spawns);
117 
118 	return &n->list == stack ? top : &n->inst->alg.cra_users;
119 }
120 
crypto_remove_instance(struct crypto_instance * inst,struct list_head * list)121 static void crypto_remove_instance(struct crypto_instance *inst,
122 				   struct list_head *list)
123 {
124 	struct crypto_template *tmpl = inst->tmpl;
125 
126 	if (crypto_is_dead(&inst->alg))
127 		return;
128 
129 	inst->alg.cra_flags |= CRYPTO_ALG_DEAD;
130 	if (hlist_unhashed(&inst->list))
131 		return;
132 
133 	if (!tmpl || !crypto_tmpl_get(tmpl))
134 		return;
135 
136 	list_move(&inst->alg.cra_list, list);
137 	hlist_del(&inst->list);
138 	inst->alg.cra_destroy = crypto_destroy_instance;
139 
140 	BUG_ON(!list_empty(&inst->alg.cra_users));
141 }
142 
crypto_remove_spawns(struct crypto_alg * alg,struct list_head * list,struct crypto_alg * nalg)143 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
144 			  struct crypto_alg *nalg)
145 {
146 	u32 new_type = (nalg ?: alg)->cra_flags;
147 	struct crypto_spawn *spawn, *n;
148 	LIST_HEAD(secondary_spawns);
149 	struct list_head *spawns;
150 	LIST_HEAD(stack);
151 	LIST_HEAD(top);
152 
153 	spawns = &alg->cra_users;
154 	list_for_each_entry_safe(spawn, n, spawns, list) {
155 		if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)
156 			continue;
157 
158 		list_move(&spawn->list, &top);
159 	}
160 
161 	spawns = &top;
162 	do {
163 		while (!list_empty(spawns)) {
164 			struct crypto_instance *inst;
165 
166 			spawn = list_first_entry(spawns, struct crypto_spawn,
167 						 list);
168 			inst = spawn->inst;
169 
170 			BUG_ON(&inst->alg == alg);
171 
172 			list_move(&spawn->list, &stack);
173 
174 			if (&inst->alg == nalg)
175 				break;
176 
177 			spawn->alg = NULL;
178 			spawns = &inst->alg.cra_users;
179 
180 			/*
181 			 * We may encounter an unregistered instance here, since
182 			 * an instance's spawns are set up prior to the instance
183 			 * being registered.  An unregistered instance will have
184 			 * NULL ->cra_users.next, since ->cra_users isn't
185 			 * properly initialized until registration.  But an
186 			 * unregistered instance cannot have any users, so treat
187 			 * it the same as ->cra_users being empty.
188 			 */
189 			if (spawns->next == NULL)
190 				break;
191 		}
192 	} while ((spawns = crypto_more_spawns(alg, &stack, &top,
193 					      &secondary_spawns)));
194 
195 	list_for_each_entry_safe(spawn, n, &secondary_spawns, list) {
196 		if (spawn->alg)
197 			list_move(&spawn->list, &spawn->alg->cra_users);
198 		else
199 			crypto_remove_instance(spawn->inst, list);
200 	}
201 }
202 EXPORT_SYMBOL_GPL(crypto_remove_spawns);
203 
__crypto_register_alg(struct crypto_alg * alg)204 static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg)
205 {
206 	struct crypto_alg *q;
207 	struct crypto_larval *larval;
208 	int ret = -EAGAIN;
209 
210 	if (crypto_is_dead(alg))
211 		goto err;
212 
213 	INIT_LIST_HEAD(&alg->cra_users);
214 
215 	/* No cheating! */
216 	alg->cra_flags &= ~CRYPTO_ALG_TESTED;
217 
218 	ret = -EEXIST;
219 
220 	list_for_each_entry(q, &crypto_alg_list, cra_list) {
221 		if (q == alg)
222 			goto err;
223 
224 		if (crypto_is_moribund(q))
225 			continue;
226 
227 		if (crypto_is_larval(q)) {
228 			if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
229 				goto err;
230 			continue;
231 		}
232 
233 		if (!strcmp(q->cra_driver_name, alg->cra_name) ||
234 		    !strcmp(q->cra_name, alg->cra_driver_name))
235 			goto err;
236 	}
237 
238 	larval = crypto_larval_alloc(alg->cra_name,
239 				     alg->cra_flags | CRYPTO_ALG_TESTED, 0);
240 	if (IS_ERR(larval))
241 		goto out;
242 
243 	ret = -ENOENT;
244 	larval->adult = crypto_mod_get(alg);
245 	if (!larval->adult)
246 		goto free_larval;
247 
248 	refcount_set(&larval->alg.cra_refcnt, 1);
249 	memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,
250 	       CRYPTO_MAX_ALG_NAME);
251 	larval->alg.cra_priority = alg->cra_priority;
252 
253 	list_add(&alg->cra_list, &crypto_alg_list);
254 	list_add(&larval->alg.cra_list, &crypto_alg_list);
255 
256 out:
257 	return larval;
258 
259 free_larval:
260 	kfree(larval);
261 err:
262 	larval = ERR_PTR(ret);
263 	goto out;
264 }
265 
crypto_alg_tested(const char * name,int err)266 void crypto_alg_tested(const char *name, int err)
267 {
268 	struct crypto_larval *test;
269 	struct crypto_alg *alg;
270 	struct crypto_alg *q;
271 	LIST_HEAD(list);
272 
273 	down_write(&crypto_alg_sem);
274 	list_for_each_entry(q, &crypto_alg_list, cra_list) {
275 		if (crypto_is_moribund(q) || !crypto_is_larval(q))
276 			continue;
277 
278 		test = (struct crypto_larval *)q;
279 
280 		if (!strcmp(q->cra_driver_name, name))
281 			goto found;
282 	}
283 
284 	pr_err("alg: Unexpected test result for %s: %d\n", name, err);
285 	goto unlock;
286 
287 found:
288 	q->cra_flags |= CRYPTO_ALG_DEAD;
289 	alg = test->adult;
290 	if (err || list_empty(&alg->cra_list))
291 		goto complete;
292 
293 	alg->cra_flags |= CRYPTO_ALG_TESTED;
294 
295 	list_for_each_entry(q, &crypto_alg_list, cra_list) {
296 		if (q == alg)
297 			continue;
298 
299 		if (crypto_is_moribund(q))
300 			continue;
301 
302 		if (crypto_is_larval(q)) {
303 			struct crypto_larval *larval = (void *)q;
304 
305 			/*
306 			 * Check to see if either our generic name or
307 			 * specific name can satisfy the name requested
308 			 * by the larval entry q.
309 			 */
310 			if (strcmp(alg->cra_name, q->cra_name) &&
311 			    strcmp(alg->cra_driver_name, q->cra_name))
312 				continue;
313 
314 			if (larval->adult)
315 				continue;
316 			if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
317 				continue;
318 			if (!crypto_mod_get(alg))
319 				continue;
320 
321 			larval->adult = alg;
322 			continue;
323 		}
324 
325 		if (strcmp(alg->cra_name, q->cra_name))
326 			continue;
327 
328 		if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
329 		    q->cra_priority > alg->cra_priority)
330 			continue;
331 
332 		crypto_remove_spawns(q, &list, alg);
333 	}
334 
335 complete:
336 	complete_all(&test->completion);
337 
338 unlock:
339 	up_write(&crypto_alg_sem);
340 
341 	crypto_remove_final(&list);
342 }
343 EXPORT_SYMBOL_GPL(crypto_alg_tested);
344 
crypto_remove_final(struct list_head * list)345 void crypto_remove_final(struct list_head *list)
346 {
347 	struct crypto_alg *alg;
348 	struct crypto_alg *n;
349 
350 	list_for_each_entry_safe(alg, n, list, cra_list) {
351 		list_del_init(&alg->cra_list);
352 		crypto_alg_put(alg);
353 	}
354 }
355 EXPORT_SYMBOL_GPL(crypto_remove_final);
356 
crypto_wait_for_test(struct crypto_larval * larval)357 static void crypto_wait_for_test(struct crypto_larval *larval)
358 {
359 	int err;
360 
361 	err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult);
362 	if (err != NOTIFY_STOP) {
363 		if (WARN_ON(err != NOTIFY_DONE))
364 			goto out;
365 		crypto_alg_tested(larval->alg.cra_driver_name, 0);
366 	}
367 
368 	err = wait_for_completion_killable(&larval->completion);
369 	WARN_ON(err);
370 
371 out:
372 	crypto_larval_kill(&larval->alg);
373 }
374 
crypto_register_alg(struct crypto_alg * alg)375 int crypto_register_alg(struct crypto_alg *alg)
376 {
377 	struct crypto_larval *larval;
378 	int err;
379 
380 	alg->cra_flags &= ~CRYPTO_ALG_DEAD;
381 	err = crypto_check_alg(alg);
382 	if (err)
383 		return err;
384 
385 	down_write(&crypto_alg_sem);
386 	larval = __crypto_register_alg(alg);
387 	up_write(&crypto_alg_sem);
388 
389 	if (IS_ERR(larval))
390 		return PTR_ERR(larval);
391 
392 	crypto_wait_for_test(larval);
393 	return 0;
394 }
395 EXPORT_SYMBOL_GPL(crypto_register_alg);
396 
crypto_remove_alg(struct crypto_alg * alg,struct list_head * list)397 static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list)
398 {
399 	if (unlikely(list_empty(&alg->cra_list)))
400 		return -ENOENT;
401 
402 	alg->cra_flags |= CRYPTO_ALG_DEAD;
403 
404 	list_del_init(&alg->cra_list);
405 	crypto_remove_spawns(alg, list, NULL);
406 
407 	return 0;
408 }
409 
crypto_unregister_alg(struct crypto_alg * alg)410 int crypto_unregister_alg(struct crypto_alg *alg)
411 {
412 	int ret;
413 	LIST_HEAD(list);
414 
415 	down_write(&crypto_alg_sem);
416 	ret = crypto_remove_alg(alg, &list);
417 	up_write(&crypto_alg_sem);
418 
419 	if (ret)
420 		return ret;
421 
422 	BUG_ON(refcount_read(&alg->cra_refcnt) != 1);
423 	if (alg->cra_destroy)
424 		alg->cra_destroy(alg);
425 
426 	crypto_remove_final(&list);
427 	return 0;
428 }
429 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
430 
crypto_register_algs(struct crypto_alg * algs,int count)431 int crypto_register_algs(struct crypto_alg *algs, int count)
432 {
433 	int i, ret;
434 
435 	for (i = 0; i < count; i++) {
436 		ret = crypto_register_alg(&algs[i]);
437 		if (ret)
438 			goto err;
439 	}
440 
441 	return 0;
442 
443 err:
444 	for (--i; i >= 0; --i)
445 		crypto_unregister_alg(&algs[i]);
446 
447 	return ret;
448 }
449 EXPORT_SYMBOL_GPL(crypto_register_algs);
450 
crypto_unregister_algs(struct crypto_alg * algs,int count)451 int crypto_unregister_algs(struct crypto_alg *algs, int count)
452 {
453 	int i, ret;
454 
455 	for (i = 0; i < count; i++) {
456 		ret = crypto_unregister_alg(&algs[i]);
457 		if (ret)
458 			pr_err("Failed to unregister %s %s: %d\n",
459 			       algs[i].cra_driver_name, algs[i].cra_name, ret);
460 	}
461 
462 	return 0;
463 }
464 EXPORT_SYMBOL_GPL(crypto_unregister_algs);
465 
crypto_register_template(struct crypto_template * tmpl)466 int crypto_register_template(struct crypto_template *tmpl)
467 {
468 	struct crypto_template *q;
469 	int err = -EEXIST;
470 
471 	down_write(&crypto_alg_sem);
472 
473 	crypto_check_module_sig(tmpl->module);
474 
475 	list_for_each_entry(q, &crypto_template_list, list) {
476 		if (q == tmpl)
477 			goto out;
478 	}
479 
480 	list_add(&tmpl->list, &crypto_template_list);
481 	err = 0;
482 out:
483 	up_write(&crypto_alg_sem);
484 	return err;
485 }
486 EXPORT_SYMBOL_GPL(crypto_register_template);
487 
crypto_unregister_template(struct crypto_template * tmpl)488 void crypto_unregister_template(struct crypto_template *tmpl)
489 {
490 	struct crypto_instance *inst;
491 	struct hlist_node *n;
492 	struct hlist_head *list;
493 	LIST_HEAD(users);
494 
495 	down_write(&crypto_alg_sem);
496 
497 	BUG_ON(list_empty(&tmpl->list));
498 	list_del_init(&tmpl->list);
499 
500 	list = &tmpl->instances;
501 	hlist_for_each_entry(inst, list, list) {
502 		int err = crypto_remove_alg(&inst->alg, &users);
503 
504 		BUG_ON(err);
505 	}
506 
507 	up_write(&crypto_alg_sem);
508 
509 	hlist_for_each_entry_safe(inst, n, list, list) {
510 		BUG_ON(refcount_read(&inst->alg.cra_refcnt) != 1);
511 		crypto_free_instance(inst);
512 	}
513 	crypto_remove_final(&users);
514 }
515 EXPORT_SYMBOL_GPL(crypto_unregister_template);
516 
__crypto_lookup_template(const char * name)517 static struct crypto_template *__crypto_lookup_template(const char *name)
518 {
519 	struct crypto_template *q, *tmpl = NULL;
520 
521 	down_read(&crypto_alg_sem);
522 	list_for_each_entry(q, &crypto_template_list, list) {
523 		if (strcmp(q->name, name))
524 			continue;
525 		if (unlikely(!crypto_tmpl_get(q)))
526 			continue;
527 
528 		tmpl = q;
529 		break;
530 	}
531 	up_read(&crypto_alg_sem);
532 
533 	return tmpl;
534 }
535 
crypto_lookup_template(const char * name)536 struct crypto_template *crypto_lookup_template(const char *name)
537 {
538 	return try_then_request_module(__crypto_lookup_template(name),
539 				       "crypto-%s", name);
540 }
541 EXPORT_SYMBOL_GPL(crypto_lookup_template);
542 
crypto_register_instance(struct crypto_template * tmpl,struct crypto_instance * inst)543 int crypto_register_instance(struct crypto_template *tmpl,
544 			     struct crypto_instance *inst)
545 {
546 	struct crypto_larval *larval;
547 	int err;
548 
549 	err = crypto_check_alg(&inst->alg);
550 	if (err)
551 		return err;
552 
553 	inst->alg.cra_module = tmpl->module;
554 	inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE;
555 
556 	down_write(&crypto_alg_sem);
557 
558 	larval = __crypto_register_alg(&inst->alg);
559 	if (IS_ERR(larval))
560 		goto unlock;
561 
562 	hlist_add_head(&inst->list, &tmpl->instances);
563 	inst->tmpl = tmpl;
564 
565 unlock:
566 	up_write(&crypto_alg_sem);
567 
568 	err = PTR_ERR(larval);
569 	if (IS_ERR(larval))
570 		goto err;
571 
572 	crypto_wait_for_test(larval);
573 	err = 0;
574 
575 err:
576 	return err;
577 }
578 EXPORT_SYMBOL_GPL(crypto_register_instance);
579 
crypto_unregister_instance(struct crypto_instance * inst)580 int crypto_unregister_instance(struct crypto_instance *inst)
581 {
582 	LIST_HEAD(list);
583 
584 	down_write(&crypto_alg_sem);
585 
586 	crypto_remove_spawns(&inst->alg, &list, NULL);
587 	crypto_remove_instance(inst, &list);
588 
589 	up_write(&crypto_alg_sem);
590 
591 	crypto_remove_final(&list);
592 
593 	return 0;
594 }
595 EXPORT_SYMBOL_GPL(crypto_unregister_instance);
596 
crypto_init_spawn(struct crypto_spawn * spawn,struct crypto_alg * alg,struct crypto_instance * inst,u32 mask)597 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
598 		      struct crypto_instance *inst, u32 mask)
599 {
600 	int err = -EAGAIN;
601 
602 	spawn->inst = inst;
603 	spawn->mask = mask;
604 
605 	down_write(&crypto_alg_sem);
606 	if (!crypto_is_moribund(alg)) {
607 		list_add(&spawn->list, &alg->cra_users);
608 		spawn->alg = alg;
609 		err = 0;
610 	}
611 	up_write(&crypto_alg_sem);
612 
613 	return err;
614 }
615 EXPORT_SYMBOL_GPL(crypto_init_spawn);
616 
crypto_init_spawn2(struct crypto_spawn * spawn,struct crypto_alg * alg,struct crypto_instance * inst,const struct crypto_type * frontend)617 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
618 		       struct crypto_instance *inst,
619 		       const struct crypto_type *frontend)
620 {
621 	int err = -EINVAL;
622 
623 	if ((alg->cra_flags ^ frontend->type) & frontend->maskset)
624 		goto out;
625 
626 	spawn->frontend = frontend;
627 	err = crypto_init_spawn(spawn, alg, inst, frontend->maskset);
628 
629 out:
630 	return err;
631 }
632 EXPORT_SYMBOL_GPL(crypto_init_spawn2);
633 
crypto_grab_spawn(struct crypto_spawn * spawn,const char * name,u32 type,u32 mask)634 int crypto_grab_spawn(struct crypto_spawn *spawn, const char *name,
635 		      u32 type, u32 mask)
636 {
637 	struct crypto_alg *alg;
638 	int err;
639 
640 	alg = crypto_find_alg(name, spawn->frontend, type, mask);
641 	if (IS_ERR(alg))
642 		return PTR_ERR(alg);
643 
644 	err = crypto_init_spawn(spawn, alg, spawn->inst, mask);
645 	crypto_mod_put(alg);
646 	return err;
647 }
648 EXPORT_SYMBOL_GPL(crypto_grab_spawn);
649 
crypto_drop_spawn(struct crypto_spawn * spawn)650 void crypto_drop_spawn(struct crypto_spawn *spawn)
651 {
652 	down_write(&crypto_alg_sem);
653 	if (spawn->alg)
654 		list_del(&spawn->list);
655 	up_write(&crypto_alg_sem);
656 }
657 EXPORT_SYMBOL_GPL(crypto_drop_spawn);
658 
crypto_spawn_alg(struct crypto_spawn * spawn)659 static struct crypto_alg *crypto_spawn_alg(struct crypto_spawn *spawn)
660 {
661 	struct crypto_alg *alg;
662 
663 	down_read(&crypto_alg_sem);
664 	alg = spawn->alg;
665 	if (alg && !crypto_mod_get(alg)) {
666 		alg->cra_flags |= CRYPTO_ALG_DYING;
667 		alg = NULL;
668 	}
669 	up_read(&crypto_alg_sem);
670 
671 	return alg ?: ERR_PTR(-EAGAIN);
672 }
673 
crypto_spawn_tfm(struct crypto_spawn * spawn,u32 type,u32 mask)674 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
675 				    u32 mask)
676 {
677 	struct crypto_alg *alg;
678 	struct crypto_tfm *tfm;
679 
680 	alg = crypto_spawn_alg(spawn);
681 	if (IS_ERR(alg))
682 		return ERR_CAST(alg);
683 
684 	tfm = ERR_PTR(-EINVAL);
685 	if (unlikely((alg->cra_flags ^ type) & mask))
686 		goto out_put_alg;
687 
688 	tfm = __crypto_alloc_tfm(alg, type, mask);
689 	if (IS_ERR(tfm))
690 		goto out_put_alg;
691 
692 	return tfm;
693 
694 out_put_alg:
695 	crypto_mod_put(alg);
696 	return tfm;
697 }
698 EXPORT_SYMBOL_GPL(crypto_spawn_tfm);
699 
crypto_spawn_tfm2(struct crypto_spawn * spawn)700 void *crypto_spawn_tfm2(struct crypto_spawn *spawn)
701 {
702 	struct crypto_alg *alg;
703 	struct crypto_tfm *tfm;
704 
705 	alg = crypto_spawn_alg(spawn);
706 	if (IS_ERR(alg))
707 		return ERR_CAST(alg);
708 
709 	tfm = crypto_create_tfm(alg, spawn->frontend);
710 	if (IS_ERR(tfm))
711 		goto out_put_alg;
712 
713 	return tfm;
714 
715 out_put_alg:
716 	crypto_mod_put(alg);
717 	return tfm;
718 }
719 EXPORT_SYMBOL_GPL(crypto_spawn_tfm2);
720 
crypto_register_notifier(struct notifier_block * nb)721 int crypto_register_notifier(struct notifier_block *nb)
722 {
723 	return blocking_notifier_chain_register(&crypto_chain, nb);
724 }
725 EXPORT_SYMBOL_GPL(crypto_register_notifier);
726 
crypto_unregister_notifier(struct notifier_block * nb)727 int crypto_unregister_notifier(struct notifier_block *nb)
728 {
729 	return blocking_notifier_chain_unregister(&crypto_chain, nb);
730 }
731 EXPORT_SYMBOL_GPL(crypto_unregister_notifier);
732 
crypto_get_attr_type(struct rtattr ** tb)733 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb)
734 {
735 	struct rtattr *rta = tb[0];
736 	struct crypto_attr_type *algt;
737 
738 	if (!rta)
739 		return ERR_PTR(-ENOENT);
740 	if (RTA_PAYLOAD(rta) < sizeof(*algt))
741 		return ERR_PTR(-EINVAL);
742 	if (rta->rta_type != CRYPTOA_TYPE)
743 		return ERR_PTR(-EINVAL);
744 
745 	algt = RTA_DATA(rta);
746 
747 	return algt;
748 }
749 EXPORT_SYMBOL_GPL(crypto_get_attr_type);
750 
crypto_check_attr_type(struct rtattr ** tb,u32 type)751 int crypto_check_attr_type(struct rtattr **tb, u32 type)
752 {
753 	struct crypto_attr_type *algt;
754 
755 	algt = crypto_get_attr_type(tb);
756 	if (IS_ERR(algt))
757 		return PTR_ERR(algt);
758 
759 	if ((algt->type ^ type) & algt->mask)
760 		return -EINVAL;
761 
762 	return 0;
763 }
764 EXPORT_SYMBOL_GPL(crypto_check_attr_type);
765 
crypto_attr_alg_name(struct rtattr * rta)766 const char *crypto_attr_alg_name(struct rtattr *rta)
767 {
768 	struct crypto_attr_alg *alga;
769 
770 	if (!rta)
771 		return ERR_PTR(-ENOENT);
772 	if (RTA_PAYLOAD(rta) < sizeof(*alga))
773 		return ERR_PTR(-EINVAL);
774 	if (rta->rta_type != CRYPTOA_ALG)
775 		return ERR_PTR(-EINVAL);
776 
777 	alga = RTA_DATA(rta);
778 	alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0;
779 
780 	return alga->name;
781 }
782 EXPORT_SYMBOL_GPL(crypto_attr_alg_name);
783 
crypto_attr_alg2(struct rtattr * rta,const struct crypto_type * frontend,u32 type,u32 mask)784 struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,
785 				    const struct crypto_type *frontend,
786 				    u32 type, u32 mask)
787 {
788 	const char *name;
789 
790 	name = crypto_attr_alg_name(rta);
791 	if (IS_ERR(name))
792 		return ERR_CAST(name);
793 
794 	return crypto_find_alg(name, frontend, type, mask);
795 }
796 EXPORT_SYMBOL_GPL(crypto_attr_alg2);
797 
crypto_attr_u32(struct rtattr * rta,u32 * num)798 int crypto_attr_u32(struct rtattr *rta, u32 *num)
799 {
800 	struct crypto_attr_u32 *nu32;
801 
802 	if (!rta)
803 		return -ENOENT;
804 	if (RTA_PAYLOAD(rta) < sizeof(*nu32))
805 		return -EINVAL;
806 	if (rta->rta_type != CRYPTOA_U32)
807 		return -EINVAL;
808 
809 	nu32 = RTA_DATA(rta);
810 	*num = nu32->num;
811 
812 	return 0;
813 }
814 EXPORT_SYMBOL_GPL(crypto_attr_u32);
815 
crypto_inst_setname(struct crypto_instance * inst,const char * name,struct crypto_alg * alg)816 int crypto_inst_setname(struct crypto_instance *inst, const char *name,
817 			struct crypto_alg *alg)
818 {
819 	if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name,
820 		     alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
821 		return -ENAMETOOLONG;
822 
823 	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",
824 		     name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
825 		return -ENAMETOOLONG;
826 
827 	return 0;
828 }
829 EXPORT_SYMBOL_GPL(crypto_inst_setname);
830 
crypto_alloc_instance2(const char * name,struct crypto_alg * alg,unsigned int head)831 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg,
832 			     unsigned int head)
833 {
834 	struct crypto_instance *inst;
835 	char *p;
836 	int err;
837 
838 	p = kzalloc(head + sizeof(*inst) + sizeof(struct crypto_spawn),
839 		    GFP_KERNEL);
840 	if (!p)
841 		return ERR_PTR(-ENOMEM);
842 
843 	inst = (void *)(p + head);
844 
845 	err = crypto_inst_setname(inst, name, alg);
846 	if (err)
847 		goto err_free_inst;
848 
849 	return p;
850 
851 err_free_inst:
852 	kfree(p);
853 	return ERR_PTR(err);
854 }
855 EXPORT_SYMBOL_GPL(crypto_alloc_instance2);
856 
crypto_alloc_instance(const char * name,struct crypto_alg * alg)857 struct crypto_instance *crypto_alloc_instance(const char *name,
858 					      struct crypto_alg *alg)
859 {
860 	struct crypto_instance *inst;
861 	struct crypto_spawn *spawn;
862 	int err;
863 
864 	inst = crypto_alloc_instance2(name, alg, 0);
865 	if (IS_ERR(inst))
866 		goto out;
867 
868 	spawn = crypto_instance_ctx(inst);
869 	err = crypto_init_spawn(spawn, alg, inst,
870 				CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
871 
872 	if (err)
873 		goto err_free_inst;
874 
875 	return inst;
876 
877 err_free_inst:
878 	kfree(inst);
879 	inst = ERR_PTR(err);
880 
881 out:
882 	return inst;
883 }
884 EXPORT_SYMBOL_GPL(crypto_alloc_instance);
885 
crypto_init_queue(struct crypto_queue * queue,unsigned int max_qlen)886 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen)
887 {
888 	INIT_LIST_HEAD(&queue->list);
889 	queue->backlog = &queue->list;
890 	queue->qlen = 0;
891 	queue->max_qlen = max_qlen;
892 }
893 EXPORT_SYMBOL_GPL(crypto_init_queue);
894 
crypto_enqueue_request(struct crypto_queue * queue,struct crypto_async_request * request)895 int crypto_enqueue_request(struct crypto_queue *queue,
896 			   struct crypto_async_request *request)
897 {
898 	int err = -EINPROGRESS;
899 
900 	if (unlikely(queue->qlen >= queue->max_qlen)) {
901 		if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) {
902 			err = -ENOSPC;
903 			goto out;
904 		}
905 		err = -EBUSY;
906 		if (queue->backlog == &queue->list)
907 			queue->backlog = &request->list;
908 	}
909 
910 	queue->qlen++;
911 	list_add_tail(&request->list, &queue->list);
912 
913 out:
914 	return err;
915 }
916 EXPORT_SYMBOL_GPL(crypto_enqueue_request);
917 
crypto_dequeue_request(struct crypto_queue * queue)918 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue)
919 {
920 	struct list_head *request;
921 
922 	if (unlikely(!queue->qlen))
923 		return NULL;
924 
925 	queue->qlen--;
926 
927 	if (queue->backlog != &queue->list)
928 		queue->backlog = queue->backlog->next;
929 
930 	request = queue->list.next;
931 	list_del(request);
932 
933 	return list_entry(request, struct crypto_async_request, list);
934 }
935 EXPORT_SYMBOL_GPL(crypto_dequeue_request);
936 
crypto_tfm_in_queue(struct crypto_queue * queue,struct crypto_tfm * tfm)937 int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm)
938 {
939 	struct crypto_async_request *req;
940 
941 	list_for_each_entry(req, &queue->list, list) {
942 		if (req->tfm == tfm)
943 			return 1;
944 	}
945 
946 	return 0;
947 }
948 EXPORT_SYMBOL_GPL(crypto_tfm_in_queue);
949 
crypto_inc_byte(u8 * a,unsigned int size)950 static inline void crypto_inc_byte(u8 *a, unsigned int size)
951 {
952 	u8 *b = (a + size);
953 	u8 c;
954 
955 	for (; size; size--) {
956 		c = *--b + 1;
957 		*b = c;
958 		if (c)
959 			break;
960 	}
961 }
962 
crypto_inc(u8 * a,unsigned int size)963 void crypto_inc(u8 *a, unsigned int size)
964 {
965 	__be32 *b = (__be32 *)(a + size);
966 	u32 c;
967 
968 	if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
969 	    IS_ALIGNED((unsigned long)b, __alignof__(*b)))
970 		for (; size >= 4; size -= 4) {
971 			c = be32_to_cpu(*--b) + 1;
972 			*b = cpu_to_be32(c);
973 			if (likely(c))
974 				return;
975 		}
976 
977 	crypto_inc_byte(a, size);
978 }
979 EXPORT_SYMBOL_GPL(crypto_inc);
980 
__crypto_xor(u8 * dst,const u8 * src1,const u8 * src2,unsigned int len)981 void __crypto_xor(u8 *dst, const u8 *src1, const u8 *src2, unsigned int len)
982 {
983 	int relalign = 0;
984 
985 	if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)) {
986 		int size = sizeof(unsigned long);
987 		int d = (((unsigned long)dst ^ (unsigned long)src1) |
988 			 ((unsigned long)dst ^ (unsigned long)src2)) &
989 			(size - 1);
990 
991 		relalign = d ? 1 << __ffs(d) : size;
992 
993 		/*
994 		 * If we care about alignment, process as many bytes as
995 		 * needed to advance dst and src to values whose alignments
996 		 * equal their relative alignment. This will allow us to
997 		 * process the remainder of the input using optimal strides.
998 		 */
999 		while (((unsigned long)dst & (relalign - 1)) && len > 0) {
1000 			*dst++ = *src1++ ^ *src2++;
1001 			len--;
1002 		}
1003 	}
1004 
1005 	while (IS_ENABLED(CONFIG_64BIT) && len >= 8 && !(relalign & 7)) {
1006 		*(u64 *)dst = *(u64 *)src1 ^  *(u64 *)src2;
1007 		dst += 8;
1008 		src1 += 8;
1009 		src2 += 8;
1010 		len -= 8;
1011 	}
1012 
1013 	while (len >= 4 && !(relalign & 3)) {
1014 		*(u32 *)dst = *(u32 *)src1 ^ *(u32 *)src2;
1015 		dst += 4;
1016 		src1 += 4;
1017 		src2 += 4;
1018 		len -= 4;
1019 	}
1020 
1021 	while (len >= 2 && !(relalign & 1)) {
1022 		*(u16 *)dst = *(u16 *)src1 ^ *(u16 *)src2;
1023 		dst += 2;
1024 		src1 += 2;
1025 		src2 += 2;
1026 		len -= 2;
1027 	}
1028 
1029 	while (len--)
1030 		*dst++ = *src1++ ^ *src2++;
1031 }
1032 EXPORT_SYMBOL_GPL(__crypto_xor);
1033 
crypto_alg_extsize(struct crypto_alg * alg)1034 unsigned int crypto_alg_extsize(struct crypto_alg *alg)
1035 {
1036 	return alg->cra_ctxsize +
1037 	       (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1));
1038 }
1039 EXPORT_SYMBOL_GPL(crypto_alg_extsize);
1040 
crypto_type_has_alg(const char * name,const struct crypto_type * frontend,u32 type,u32 mask)1041 int crypto_type_has_alg(const char *name, const struct crypto_type *frontend,
1042 			u32 type, u32 mask)
1043 {
1044 	int ret = 0;
1045 	struct crypto_alg *alg = crypto_find_alg(name, frontend, type, mask);
1046 
1047 	if (!IS_ERR(alg)) {
1048 		crypto_mod_put(alg);
1049 		ret = 1;
1050 	}
1051 
1052 	return ret;
1053 }
1054 EXPORT_SYMBOL_GPL(crypto_type_has_alg);
1055 
crypto_algapi_init(void)1056 static int __init crypto_algapi_init(void)
1057 {
1058 	crypto_init_proc();
1059 	return 0;
1060 }
1061 
crypto_algapi_exit(void)1062 static void __exit crypto_algapi_exit(void)
1063 {
1064 	crypto_exit_proc();
1065 }
1066 
1067 module_init(crypto_algapi_init);
1068 module_exit(crypto_algapi_exit);
1069 
1070 MODULE_LICENSE("GPL");
1071 MODULE_DESCRIPTION("Cryptographic algorithms API");
1072