Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * xfrm algorithm interface
4 *
5 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
6 */
7
8#include <crypto/aead.h>
9#include <crypto/hash.h>
10#include <crypto/skcipher.h>
11#include <linux/module.h>
12#include <linux/kernel.h>
13#include <linux/pfkeyv2.h>
14#include <linux/crypto.h>
15#include <linux/scatterlist.h>
16#include <net/xfrm.h>
17#if IS_ENABLED(CONFIG_INET_ESP) || IS_ENABLED(CONFIG_INET6_ESP)
18#include <net/esp.h>
19#endif
20
21/*
22 * Algorithms supported by IPsec. These entries contain properties which
23 * are used in key negotiation and xfrm processing, and are used to verify
24 * that instantiated crypto transforms have correct parameters for IPsec
25 * purposes.
26 */
27static struct xfrm_algo_desc aead_list[] = {
28{
29 .name = "rfc4106(gcm(aes))",
30
31 .uinfo = {
32 .aead = {
33 .geniv = "seqiv",
34 .icv_truncbits = 64,
35 }
36 },
37
38 .pfkey_supported = 1,
39
40 .desc = {
41 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
42 .sadb_alg_ivlen = 8,
43 .sadb_alg_minbits = 128,
44 .sadb_alg_maxbits = 256
45 }
46},
47{
48 .name = "rfc4106(gcm(aes))",
49
50 .uinfo = {
51 .aead = {
52 .geniv = "seqiv",
53 .icv_truncbits = 96,
54 }
55 },
56
57 .pfkey_supported = 1,
58
59 .desc = {
60 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
61 .sadb_alg_ivlen = 8,
62 .sadb_alg_minbits = 128,
63 .sadb_alg_maxbits = 256
64 }
65},
66{
67 .name = "rfc4106(gcm(aes))",
68
69 .uinfo = {
70 .aead = {
71 .geniv = "seqiv",
72 .icv_truncbits = 128,
73 }
74 },
75
76 .pfkey_supported = 1,
77
78 .desc = {
79 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
80 .sadb_alg_ivlen = 8,
81 .sadb_alg_minbits = 128,
82 .sadb_alg_maxbits = 256
83 }
84},
85{
86 .name = "rfc4309(ccm(aes))",
87
88 .uinfo = {
89 .aead = {
90 .geniv = "seqiv",
91 .icv_truncbits = 64,
92 }
93 },
94
95 .pfkey_supported = 1,
96
97 .desc = {
98 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
99 .sadb_alg_ivlen = 8,
100 .sadb_alg_minbits = 128,
101 .sadb_alg_maxbits = 256
102 }
103},
104{
105 .name = "rfc4309(ccm(aes))",
106
107 .uinfo = {
108 .aead = {
109 .geniv = "seqiv",
110 .icv_truncbits = 96,
111 }
112 },
113
114 .pfkey_supported = 1,
115
116 .desc = {
117 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
118 .sadb_alg_ivlen = 8,
119 .sadb_alg_minbits = 128,
120 .sadb_alg_maxbits = 256
121 }
122},
123{
124 .name = "rfc4309(ccm(aes))",
125
126 .uinfo = {
127 .aead = {
128 .geniv = "seqiv",
129 .icv_truncbits = 128,
130 }
131 },
132
133 .pfkey_supported = 1,
134
135 .desc = {
136 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
137 .sadb_alg_ivlen = 8,
138 .sadb_alg_minbits = 128,
139 .sadb_alg_maxbits = 256
140 }
141},
142{
143 .name = "rfc4543(gcm(aes))",
144
145 .uinfo = {
146 .aead = {
147 .geniv = "seqiv",
148 .icv_truncbits = 128,
149 }
150 },
151
152 .pfkey_supported = 1,
153
154 .desc = {
155 .sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
156 .sadb_alg_ivlen = 8,
157 .sadb_alg_minbits = 128,
158 .sadb_alg_maxbits = 256
159 }
160},
161{
162 .name = "rfc7539esp(chacha20,poly1305)",
163
164 .uinfo = {
165 .aead = {
166 .geniv = "seqiv",
167 .icv_truncbits = 128,
168 }
169 },
170
171 .pfkey_supported = 0,
172},
173};
174
175static struct xfrm_algo_desc aalg_list[] = {
176{
177 .name = "digest_null",
178
179 .uinfo = {
180 .auth = {
181 .icv_truncbits = 0,
182 .icv_fullbits = 0,
183 }
184 },
185
186 .pfkey_supported = 1,
187
188 .desc = {
189 .sadb_alg_id = SADB_X_AALG_NULL,
190 .sadb_alg_ivlen = 0,
191 .sadb_alg_minbits = 0,
192 .sadb_alg_maxbits = 0
193 }
194},
195{
196 .name = "hmac(md5)",
197 .compat = "md5",
198
199 .uinfo = {
200 .auth = {
201 .icv_truncbits = 96,
202 .icv_fullbits = 128,
203 }
204 },
205
206 .pfkey_supported = 1,
207
208 .desc = {
209 .sadb_alg_id = SADB_AALG_MD5HMAC,
210 .sadb_alg_ivlen = 0,
211 .sadb_alg_minbits = 128,
212 .sadb_alg_maxbits = 128
213 }
214},
215{
216 .name = "hmac(sha1)",
217 .compat = "sha1",
218
219 .uinfo = {
220 .auth = {
221 .icv_truncbits = 96,
222 .icv_fullbits = 160,
223 }
224 },
225
226 .pfkey_supported = 1,
227
228 .desc = {
229 .sadb_alg_id = SADB_AALG_SHA1HMAC,
230 .sadb_alg_ivlen = 0,
231 .sadb_alg_minbits = 160,
232 .sadb_alg_maxbits = 160
233 }
234},
235{
236 .name = "hmac(sha256)",
237 .compat = "sha256",
238
239 .uinfo = {
240 .auth = {
241 .icv_truncbits = 96,
242 .icv_fullbits = 256,
243 }
244 },
245
246 .pfkey_supported = 1,
247
248 .desc = {
249 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
250 .sadb_alg_ivlen = 0,
251 .sadb_alg_minbits = 256,
252 .sadb_alg_maxbits = 256
253 }
254},
255{
256 .name = "hmac(sha384)",
257
258 .uinfo = {
259 .auth = {
260 .icv_truncbits = 192,
261 .icv_fullbits = 384,
262 }
263 },
264
265 .pfkey_supported = 1,
266
267 .desc = {
268 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
269 .sadb_alg_ivlen = 0,
270 .sadb_alg_minbits = 384,
271 .sadb_alg_maxbits = 384
272 }
273},
274{
275 .name = "hmac(sha512)",
276
277 .uinfo = {
278 .auth = {
279 .icv_truncbits = 256,
280 .icv_fullbits = 512,
281 }
282 },
283
284 .pfkey_supported = 1,
285
286 .desc = {
287 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
288 .sadb_alg_ivlen = 0,
289 .sadb_alg_minbits = 512,
290 .sadb_alg_maxbits = 512
291 }
292},
293{
294 .name = "hmac(rmd160)",
295 .compat = "rmd160",
296
297 .uinfo = {
298 .auth = {
299 .icv_truncbits = 96,
300 .icv_fullbits = 160,
301 }
302 },
303
304 .pfkey_supported = 1,
305
306 .desc = {
307 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
308 .sadb_alg_ivlen = 0,
309 .sadb_alg_minbits = 160,
310 .sadb_alg_maxbits = 160
311 }
312},
313{
314 .name = "xcbc(aes)",
315
316 .uinfo = {
317 .auth = {
318 .icv_truncbits = 96,
319 .icv_fullbits = 128,
320 }
321 },
322
323 .pfkey_supported = 1,
324
325 .desc = {
326 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
327 .sadb_alg_ivlen = 0,
328 .sadb_alg_minbits = 128,
329 .sadb_alg_maxbits = 128
330 }
331},
332{
333 /* rfc4494 */
334 .name = "cmac(aes)",
335
336 .uinfo = {
337 .auth = {
338 .icv_truncbits = 96,
339 .icv_fullbits = 128,
340 }
341 },
342
343 .pfkey_supported = 0,
344},
345{
346 .name = "hmac(sm3)",
347 .compat = "sm3",
348
349 .uinfo = {
350 .auth = {
351 .icv_truncbits = 256,
352 .icv_fullbits = 256,
353 }
354 },
355
356 .pfkey_supported = 1,
357
358 .desc = {
359 .sadb_alg_id = SADB_X_AALG_SM3_256HMAC,
360 .sadb_alg_ivlen = 0,
361 .sadb_alg_minbits = 256,
362 .sadb_alg_maxbits = 256
363 }
364},
365};
366
367static struct xfrm_algo_desc ealg_list[] = {
368{
369 .name = "ecb(cipher_null)",
370 .compat = "cipher_null",
371
372 .uinfo = {
373 .encr = {
374 .blockbits = 8,
375 .defkeybits = 0,
376 }
377 },
378
379 .pfkey_supported = 1,
380
381 .desc = {
382 .sadb_alg_id = SADB_EALG_NULL,
383 .sadb_alg_ivlen = 0,
384 .sadb_alg_minbits = 0,
385 .sadb_alg_maxbits = 0
386 }
387},
388{
389 .name = "cbc(des)",
390 .compat = "des",
391
392 .uinfo = {
393 .encr = {
394 .geniv = "echainiv",
395 .blockbits = 64,
396 .defkeybits = 64,
397 }
398 },
399
400 .pfkey_supported = 1,
401
402 .desc = {
403 .sadb_alg_id = SADB_EALG_DESCBC,
404 .sadb_alg_ivlen = 8,
405 .sadb_alg_minbits = 64,
406 .sadb_alg_maxbits = 64
407 }
408},
409{
410 .name = "cbc(des3_ede)",
411 .compat = "des3_ede",
412
413 .uinfo = {
414 .encr = {
415 .geniv = "echainiv",
416 .blockbits = 64,
417 .defkeybits = 192,
418 }
419 },
420
421 .pfkey_supported = 1,
422
423 .desc = {
424 .sadb_alg_id = SADB_EALG_3DESCBC,
425 .sadb_alg_ivlen = 8,
426 .sadb_alg_minbits = 192,
427 .sadb_alg_maxbits = 192
428 }
429},
430{
431 .name = "cbc(cast5)",
432 .compat = "cast5",
433
434 .uinfo = {
435 .encr = {
436 .geniv = "echainiv",
437 .blockbits = 64,
438 .defkeybits = 128,
439 }
440 },
441
442 .pfkey_supported = 1,
443
444 .desc = {
445 .sadb_alg_id = SADB_X_EALG_CASTCBC,
446 .sadb_alg_ivlen = 8,
447 .sadb_alg_minbits = 40,
448 .sadb_alg_maxbits = 128
449 }
450},
451{
452 .name = "cbc(blowfish)",
453 .compat = "blowfish",
454
455 .uinfo = {
456 .encr = {
457 .geniv = "echainiv",
458 .blockbits = 64,
459 .defkeybits = 128,
460 }
461 },
462
463 .pfkey_supported = 1,
464
465 .desc = {
466 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
467 .sadb_alg_ivlen = 8,
468 .sadb_alg_minbits = 40,
469 .sadb_alg_maxbits = 448
470 }
471},
472{
473 .name = "cbc(aes)",
474 .compat = "aes",
475
476 .uinfo = {
477 .encr = {
478 .geniv = "echainiv",
479 .blockbits = 128,
480 .defkeybits = 128,
481 }
482 },
483
484 .pfkey_supported = 1,
485
486 .desc = {
487 .sadb_alg_id = SADB_X_EALG_AESCBC,
488 .sadb_alg_ivlen = 8,
489 .sadb_alg_minbits = 128,
490 .sadb_alg_maxbits = 256
491 }
492},
493{
494 .name = "cbc(serpent)",
495 .compat = "serpent",
496
497 .uinfo = {
498 .encr = {
499 .geniv = "echainiv",
500 .blockbits = 128,
501 .defkeybits = 128,
502 }
503 },
504
505 .pfkey_supported = 1,
506
507 .desc = {
508 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
509 .sadb_alg_ivlen = 8,
510 .sadb_alg_minbits = 128,
511 .sadb_alg_maxbits = 256,
512 }
513},
514{
515 .name = "cbc(camellia)",
516 .compat = "camellia",
517
518 .uinfo = {
519 .encr = {
520 .geniv = "echainiv",
521 .blockbits = 128,
522 .defkeybits = 128,
523 }
524 },
525
526 .pfkey_supported = 1,
527
528 .desc = {
529 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
530 .sadb_alg_ivlen = 8,
531 .sadb_alg_minbits = 128,
532 .sadb_alg_maxbits = 256
533 }
534},
535{
536 .name = "cbc(twofish)",
537 .compat = "twofish",
538
539 .uinfo = {
540 .encr = {
541 .geniv = "echainiv",
542 .blockbits = 128,
543 .defkeybits = 128,
544 }
545 },
546
547 .pfkey_supported = 1,
548
549 .desc = {
550 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
551 .sadb_alg_ivlen = 8,
552 .sadb_alg_minbits = 128,
553 .sadb_alg_maxbits = 256
554 }
555},
556{
557 .name = "rfc3686(ctr(aes))",
558
559 .uinfo = {
560 .encr = {
561 .geniv = "seqiv",
562 .blockbits = 128,
563 .defkeybits = 160, /* 128-bit key + 32-bit nonce */
564 }
565 },
566
567 .pfkey_supported = 1,
568
569 .desc = {
570 .sadb_alg_id = SADB_X_EALG_AESCTR,
571 .sadb_alg_ivlen = 8,
572 .sadb_alg_minbits = 160,
573 .sadb_alg_maxbits = 288
574 }
575},
576{
577 .name = "cbc(sm4)",
578 .compat = "sm4",
579
580 .uinfo = {
581 .encr = {
582 .geniv = "echainiv",
583 .blockbits = 128,
584 .defkeybits = 128,
585 }
586 },
587
588 .pfkey_supported = 1,
589
590 .desc = {
591 .sadb_alg_id = SADB_X_EALG_SM4CBC,
592 .sadb_alg_ivlen = 16,
593 .sadb_alg_minbits = 128,
594 .sadb_alg_maxbits = 256
595 }
596},
597};
598
599static struct xfrm_algo_desc calg_list[] = {
600{
601 .name = "deflate",
602 .uinfo = {
603 .comp = {
604 .threshold = 90,
605 }
606 },
607 .pfkey_supported = 1,
608 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
609},
610{
611 .name = "lzs",
612 .uinfo = {
613 .comp = {
614 .threshold = 90,
615 }
616 },
617 .pfkey_supported = 1,
618 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
619},
620{
621 .name = "lzjh",
622 .uinfo = {
623 .comp = {
624 .threshold = 50,
625 }
626 },
627 .pfkey_supported = 1,
628 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
629},
630};
631
632static inline int aalg_entries(void)
633{
634 return ARRAY_SIZE(aalg_list);
635}
636
637static inline int ealg_entries(void)
638{
639 return ARRAY_SIZE(ealg_list);
640}
641
642static inline int calg_entries(void)
643{
644 return ARRAY_SIZE(calg_list);
645}
646
647struct xfrm_algo_list {
648 int (*find)(const char *name, u32 type, u32 mask);
649 struct xfrm_algo_desc *algs;
650 int entries;
651};
652
653static const struct xfrm_algo_list xfrm_aead_list = {
654 .find = crypto_has_aead,
655 .algs = aead_list,
656 .entries = ARRAY_SIZE(aead_list),
657};
658
659static const struct xfrm_algo_list xfrm_aalg_list = {
660 .find = crypto_has_ahash,
661 .algs = aalg_list,
662 .entries = ARRAY_SIZE(aalg_list),
663};
664
665static const struct xfrm_algo_list xfrm_ealg_list = {
666 .find = crypto_has_skcipher,
667 .algs = ealg_list,
668 .entries = ARRAY_SIZE(ealg_list),
669};
670
671static const struct xfrm_algo_list xfrm_calg_list = {
672 .find = crypto_has_comp,
673 .algs = calg_list,
674 .entries = ARRAY_SIZE(calg_list),
675};
676
677static struct xfrm_algo_desc *xfrm_find_algo(
678 const struct xfrm_algo_list *algo_list,
679 int match(const struct xfrm_algo_desc *entry, const void *data),
680 const void *data, int probe)
681{
682 struct xfrm_algo_desc *list = algo_list->algs;
683 int i, status;
684
685 for (i = 0; i < algo_list->entries; i++) {
686 if (!match(list + i, data))
687 continue;
688
689 if (list[i].available)
690 return &list[i];
691
692 if (!probe)
693 break;
694
695 status = algo_list->find(list[i].name, 0, 0);
696 if (!status)
697 break;
698
699 list[i].available = status;
700 return &list[i];
701 }
702 return NULL;
703}
704
705static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
706 const void *data)
707{
708 return entry->desc.sadb_alg_id == (unsigned long)data;
709}
710
711struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
712{
713 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
714 (void *)(unsigned long)alg_id, 1);
715}
716EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
717
718struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
719{
720 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
721 (void *)(unsigned long)alg_id, 1);
722}
723EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
724
725struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
726{
727 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
728 (void *)(unsigned long)alg_id, 1);
729}
730EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
731
732static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
733 const void *data)
734{
735 const char *name = data;
736
737 return name && (!strcmp(name, entry->name) ||
738 (entry->compat && !strcmp(name, entry->compat)));
739}
740
741struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe)
742{
743 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
744 probe);
745}
746EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
747
748struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe)
749{
750 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
751 probe);
752}
753EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
754
755struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe)
756{
757 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
758 probe);
759}
760EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
761
762struct xfrm_aead_name {
763 const char *name;
764 int icvbits;
765};
766
767static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
768 const void *data)
769{
770 const struct xfrm_aead_name *aead = data;
771 const char *name = aead->name;
772
773 return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
774 !strcmp(name, entry->name);
775}
776
777struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len, int probe)
778{
779 struct xfrm_aead_name data = {
780 .name = name,
781 .icvbits = icv_len,
782 };
783
784 return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
785 probe);
786}
787EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
788
789struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
790{
791 if (idx >= aalg_entries())
792 return NULL;
793
794 return &aalg_list[idx];
795}
796EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
797
798struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
799{
800 if (idx >= ealg_entries())
801 return NULL;
802
803 return &ealg_list[idx];
804}
805EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
806
807/*
808 * Probe for the availability of crypto algorithms, and set the available
809 * flag for any algorithms found on the system. This is typically called by
810 * pfkey during userspace SA add, update or register.
811 */
812void xfrm_probe_algs(void)
813{
814 int i, status;
815
816 BUG_ON(in_softirq());
817
818 for (i = 0; i < aalg_entries(); i++) {
819 status = crypto_has_ahash(aalg_list[i].name, 0, 0);
820 if (aalg_list[i].available != status)
821 aalg_list[i].available = status;
822 }
823
824 for (i = 0; i < ealg_entries(); i++) {
825 status = crypto_has_skcipher(ealg_list[i].name, 0, 0);
826 if (ealg_list[i].available != status)
827 ealg_list[i].available = status;
828 }
829
830 for (i = 0; i < calg_entries(); i++) {
831 status = crypto_has_comp(calg_list[i].name, 0,
832 CRYPTO_ALG_ASYNC);
833 if (calg_list[i].available != status)
834 calg_list[i].available = status;
835 }
836}
837EXPORT_SYMBOL_GPL(xfrm_probe_algs);
838
839int xfrm_count_pfkey_auth_supported(void)
840{
841 int i, n;
842
843 for (i = 0, n = 0; i < aalg_entries(); i++)
844 if (aalg_list[i].available && aalg_list[i].pfkey_supported)
845 n++;
846 return n;
847}
848EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
849
850int xfrm_count_pfkey_enc_supported(void)
851{
852 int i, n;
853
854 for (i = 0, n = 0; i < ealg_entries(); i++)
855 if (ealg_list[i].available && ealg_list[i].pfkey_supported)
856 n++;
857 return n;
858}
859EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
860
861MODULE_DESCRIPTION("XFRM Algorithm interface");
862MODULE_LICENSE("GPL");
1/*
2 * xfrm algorithm interface
3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.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#include <crypto/hash.h>
13#include <crypto/skcipher.h>
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/pfkeyv2.h>
17#include <linux/crypto.h>
18#include <linux/scatterlist.h>
19#include <net/xfrm.h>
20#if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
21#include <net/esp.h>
22#endif
23
24/*
25 * Algorithms supported by IPsec. These entries contain properties which
26 * are used in key negotiation and xfrm processing, and are used to verify
27 * that instantiated crypto transforms have correct parameters for IPsec
28 * purposes.
29 */
30static struct xfrm_algo_desc aead_list[] = {
31{
32 .name = "rfc4106(gcm(aes))",
33
34 .uinfo = {
35 .aead = {
36 .geniv = "seqiv",
37 .icv_truncbits = 64,
38 }
39 },
40
41 .pfkey_supported = 1,
42
43 .desc = {
44 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
45 .sadb_alg_ivlen = 8,
46 .sadb_alg_minbits = 128,
47 .sadb_alg_maxbits = 256
48 }
49},
50{
51 .name = "rfc4106(gcm(aes))",
52
53 .uinfo = {
54 .aead = {
55 .geniv = "seqiv",
56 .icv_truncbits = 96,
57 }
58 },
59
60 .pfkey_supported = 1,
61
62 .desc = {
63 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
64 .sadb_alg_ivlen = 8,
65 .sadb_alg_minbits = 128,
66 .sadb_alg_maxbits = 256
67 }
68},
69{
70 .name = "rfc4106(gcm(aes))",
71
72 .uinfo = {
73 .aead = {
74 .geniv = "seqiv",
75 .icv_truncbits = 128,
76 }
77 },
78
79 .pfkey_supported = 1,
80
81 .desc = {
82 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
83 .sadb_alg_ivlen = 8,
84 .sadb_alg_minbits = 128,
85 .sadb_alg_maxbits = 256
86 }
87},
88{
89 .name = "rfc4309(ccm(aes))",
90
91 .uinfo = {
92 .aead = {
93 .geniv = "seqiv",
94 .icv_truncbits = 64,
95 }
96 },
97
98 .pfkey_supported = 1,
99
100 .desc = {
101 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
102 .sadb_alg_ivlen = 8,
103 .sadb_alg_minbits = 128,
104 .sadb_alg_maxbits = 256
105 }
106},
107{
108 .name = "rfc4309(ccm(aes))",
109
110 .uinfo = {
111 .aead = {
112 .geniv = "seqiv",
113 .icv_truncbits = 96,
114 }
115 },
116
117 .pfkey_supported = 1,
118
119 .desc = {
120 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
121 .sadb_alg_ivlen = 8,
122 .sadb_alg_minbits = 128,
123 .sadb_alg_maxbits = 256
124 }
125},
126{
127 .name = "rfc4309(ccm(aes))",
128
129 .uinfo = {
130 .aead = {
131 .geniv = "seqiv",
132 .icv_truncbits = 128,
133 }
134 },
135
136 .pfkey_supported = 1,
137
138 .desc = {
139 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
140 .sadb_alg_ivlen = 8,
141 .sadb_alg_minbits = 128,
142 .sadb_alg_maxbits = 256
143 }
144},
145{
146 .name = "rfc4543(gcm(aes))",
147
148 .uinfo = {
149 .aead = {
150 .geniv = "seqiv",
151 .icv_truncbits = 128,
152 }
153 },
154
155 .pfkey_supported = 1,
156
157 .desc = {
158 .sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
159 .sadb_alg_ivlen = 8,
160 .sadb_alg_minbits = 128,
161 .sadb_alg_maxbits = 256
162 }
163},
164{
165 .name = "rfc7539esp(chacha20,poly1305)",
166
167 .uinfo = {
168 .aead = {
169 .geniv = "seqiv",
170 .icv_truncbits = 128,
171 }
172 },
173
174 .pfkey_supported = 0,
175},
176};
177
178static struct xfrm_algo_desc aalg_list[] = {
179{
180 .name = "digest_null",
181
182 .uinfo = {
183 .auth = {
184 .icv_truncbits = 0,
185 .icv_fullbits = 0,
186 }
187 },
188
189 .pfkey_supported = 1,
190
191 .desc = {
192 .sadb_alg_id = SADB_X_AALG_NULL,
193 .sadb_alg_ivlen = 0,
194 .sadb_alg_minbits = 0,
195 .sadb_alg_maxbits = 0
196 }
197},
198{
199 .name = "hmac(md5)",
200 .compat = "md5",
201
202 .uinfo = {
203 .auth = {
204 .icv_truncbits = 96,
205 .icv_fullbits = 128,
206 }
207 },
208
209 .pfkey_supported = 1,
210
211 .desc = {
212 .sadb_alg_id = SADB_AALG_MD5HMAC,
213 .sadb_alg_ivlen = 0,
214 .sadb_alg_minbits = 128,
215 .sadb_alg_maxbits = 128
216 }
217},
218{
219 .name = "hmac(sha1)",
220 .compat = "sha1",
221
222 .uinfo = {
223 .auth = {
224 .icv_truncbits = 96,
225 .icv_fullbits = 160,
226 }
227 },
228
229 .pfkey_supported = 1,
230
231 .desc = {
232 .sadb_alg_id = SADB_AALG_SHA1HMAC,
233 .sadb_alg_ivlen = 0,
234 .sadb_alg_minbits = 160,
235 .sadb_alg_maxbits = 160
236 }
237},
238{
239 .name = "hmac(sha256)",
240 .compat = "sha256",
241
242 .uinfo = {
243 .auth = {
244 .icv_truncbits = 96,
245 .icv_fullbits = 256,
246 }
247 },
248
249 .pfkey_supported = 1,
250
251 .desc = {
252 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
253 .sadb_alg_ivlen = 0,
254 .sadb_alg_minbits = 256,
255 .sadb_alg_maxbits = 256
256 }
257},
258{
259 .name = "hmac(sha384)",
260
261 .uinfo = {
262 .auth = {
263 .icv_truncbits = 192,
264 .icv_fullbits = 384,
265 }
266 },
267
268 .pfkey_supported = 1,
269
270 .desc = {
271 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
272 .sadb_alg_ivlen = 0,
273 .sadb_alg_minbits = 384,
274 .sadb_alg_maxbits = 384
275 }
276},
277{
278 .name = "hmac(sha512)",
279
280 .uinfo = {
281 .auth = {
282 .icv_truncbits = 256,
283 .icv_fullbits = 512,
284 }
285 },
286
287 .pfkey_supported = 1,
288
289 .desc = {
290 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
291 .sadb_alg_ivlen = 0,
292 .sadb_alg_minbits = 512,
293 .sadb_alg_maxbits = 512
294 }
295},
296{
297 .name = "hmac(rmd160)",
298 .compat = "rmd160",
299
300 .uinfo = {
301 .auth = {
302 .icv_truncbits = 96,
303 .icv_fullbits = 160,
304 }
305 },
306
307 .pfkey_supported = 1,
308
309 .desc = {
310 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
311 .sadb_alg_ivlen = 0,
312 .sadb_alg_minbits = 160,
313 .sadb_alg_maxbits = 160
314 }
315},
316{
317 .name = "xcbc(aes)",
318
319 .uinfo = {
320 .auth = {
321 .icv_truncbits = 96,
322 .icv_fullbits = 128,
323 }
324 },
325
326 .pfkey_supported = 1,
327
328 .desc = {
329 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
330 .sadb_alg_ivlen = 0,
331 .sadb_alg_minbits = 128,
332 .sadb_alg_maxbits = 128
333 }
334},
335{
336 /* rfc4494 */
337 .name = "cmac(aes)",
338
339 .uinfo = {
340 .auth = {
341 .icv_truncbits = 96,
342 .icv_fullbits = 128,
343 }
344 },
345
346 .pfkey_supported = 0,
347},
348};
349
350static struct xfrm_algo_desc ealg_list[] = {
351{
352 .name = "ecb(cipher_null)",
353 .compat = "cipher_null",
354
355 .uinfo = {
356 .encr = {
357 .blockbits = 8,
358 .defkeybits = 0,
359 }
360 },
361
362 .pfkey_supported = 1,
363
364 .desc = {
365 .sadb_alg_id = SADB_EALG_NULL,
366 .sadb_alg_ivlen = 0,
367 .sadb_alg_minbits = 0,
368 .sadb_alg_maxbits = 0
369 }
370},
371{
372 .name = "cbc(des)",
373 .compat = "des",
374
375 .uinfo = {
376 .encr = {
377 .geniv = "echainiv",
378 .blockbits = 64,
379 .defkeybits = 64,
380 }
381 },
382
383 .pfkey_supported = 1,
384
385 .desc = {
386 .sadb_alg_id = SADB_EALG_DESCBC,
387 .sadb_alg_ivlen = 8,
388 .sadb_alg_minbits = 64,
389 .sadb_alg_maxbits = 64
390 }
391},
392{
393 .name = "cbc(des3_ede)",
394 .compat = "des3_ede",
395
396 .uinfo = {
397 .encr = {
398 .geniv = "echainiv",
399 .blockbits = 64,
400 .defkeybits = 192,
401 }
402 },
403
404 .pfkey_supported = 1,
405
406 .desc = {
407 .sadb_alg_id = SADB_EALG_3DESCBC,
408 .sadb_alg_ivlen = 8,
409 .sadb_alg_minbits = 192,
410 .sadb_alg_maxbits = 192
411 }
412},
413{
414 .name = "cbc(cast5)",
415 .compat = "cast5",
416
417 .uinfo = {
418 .encr = {
419 .geniv = "echainiv",
420 .blockbits = 64,
421 .defkeybits = 128,
422 }
423 },
424
425 .pfkey_supported = 1,
426
427 .desc = {
428 .sadb_alg_id = SADB_X_EALG_CASTCBC,
429 .sadb_alg_ivlen = 8,
430 .sadb_alg_minbits = 40,
431 .sadb_alg_maxbits = 128
432 }
433},
434{
435 .name = "cbc(blowfish)",
436 .compat = "blowfish",
437
438 .uinfo = {
439 .encr = {
440 .geniv = "echainiv",
441 .blockbits = 64,
442 .defkeybits = 128,
443 }
444 },
445
446 .pfkey_supported = 1,
447
448 .desc = {
449 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
450 .sadb_alg_ivlen = 8,
451 .sadb_alg_minbits = 40,
452 .sadb_alg_maxbits = 448
453 }
454},
455{
456 .name = "cbc(aes)",
457 .compat = "aes",
458
459 .uinfo = {
460 .encr = {
461 .geniv = "echainiv",
462 .blockbits = 128,
463 .defkeybits = 128,
464 }
465 },
466
467 .pfkey_supported = 1,
468
469 .desc = {
470 .sadb_alg_id = SADB_X_EALG_AESCBC,
471 .sadb_alg_ivlen = 8,
472 .sadb_alg_minbits = 128,
473 .sadb_alg_maxbits = 256
474 }
475},
476{
477 .name = "cbc(serpent)",
478 .compat = "serpent",
479
480 .uinfo = {
481 .encr = {
482 .geniv = "echainiv",
483 .blockbits = 128,
484 .defkeybits = 128,
485 }
486 },
487
488 .pfkey_supported = 1,
489
490 .desc = {
491 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
492 .sadb_alg_ivlen = 8,
493 .sadb_alg_minbits = 128,
494 .sadb_alg_maxbits = 256,
495 }
496},
497{
498 .name = "cbc(camellia)",
499 .compat = "camellia",
500
501 .uinfo = {
502 .encr = {
503 .geniv = "echainiv",
504 .blockbits = 128,
505 .defkeybits = 128,
506 }
507 },
508
509 .pfkey_supported = 1,
510
511 .desc = {
512 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
513 .sadb_alg_ivlen = 8,
514 .sadb_alg_minbits = 128,
515 .sadb_alg_maxbits = 256
516 }
517},
518{
519 .name = "cbc(twofish)",
520 .compat = "twofish",
521
522 .uinfo = {
523 .encr = {
524 .geniv = "echainiv",
525 .blockbits = 128,
526 .defkeybits = 128,
527 }
528 },
529
530 .pfkey_supported = 1,
531
532 .desc = {
533 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
534 .sadb_alg_ivlen = 8,
535 .sadb_alg_minbits = 128,
536 .sadb_alg_maxbits = 256
537 }
538},
539{
540 .name = "rfc3686(ctr(aes))",
541
542 .uinfo = {
543 .encr = {
544 .geniv = "seqiv",
545 .blockbits = 128,
546 .defkeybits = 160, /* 128-bit key + 32-bit nonce */
547 }
548 },
549
550 .pfkey_supported = 1,
551
552 .desc = {
553 .sadb_alg_id = SADB_X_EALG_AESCTR,
554 .sadb_alg_ivlen = 8,
555 .sadb_alg_minbits = 160,
556 .sadb_alg_maxbits = 288
557 }
558},
559};
560
561static struct xfrm_algo_desc calg_list[] = {
562{
563 .name = "deflate",
564 .uinfo = {
565 .comp = {
566 .threshold = 90,
567 }
568 },
569 .pfkey_supported = 1,
570 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
571},
572{
573 .name = "lzs",
574 .uinfo = {
575 .comp = {
576 .threshold = 90,
577 }
578 },
579 .pfkey_supported = 1,
580 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
581},
582{
583 .name = "lzjh",
584 .uinfo = {
585 .comp = {
586 .threshold = 50,
587 }
588 },
589 .pfkey_supported = 1,
590 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
591},
592};
593
594static inline int aalg_entries(void)
595{
596 return ARRAY_SIZE(aalg_list);
597}
598
599static inline int ealg_entries(void)
600{
601 return ARRAY_SIZE(ealg_list);
602}
603
604static inline int calg_entries(void)
605{
606 return ARRAY_SIZE(calg_list);
607}
608
609struct xfrm_algo_list {
610 struct xfrm_algo_desc *algs;
611 int entries;
612 u32 type;
613 u32 mask;
614};
615
616static const struct xfrm_algo_list xfrm_aead_list = {
617 .algs = aead_list,
618 .entries = ARRAY_SIZE(aead_list),
619 .type = CRYPTO_ALG_TYPE_AEAD,
620 .mask = CRYPTO_ALG_TYPE_MASK,
621};
622
623static const struct xfrm_algo_list xfrm_aalg_list = {
624 .algs = aalg_list,
625 .entries = ARRAY_SIZE(aalg_list),
626 .type = CRYPTO_ALG_TYPE_HASH,
627 .mask = CRYPTO_ALG_TYPE_HASH_MASK,
628};
629
630static const struct xfrm_algo_list xfrm_ealg_list = {
631 .algs = ealg_list,
632 .entries = ARRAY_SIZE(ealg_list),
633 .type = CRYPTO_ALG_TYPE_BLKCIPHER,
634 .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
635};
636
637static const struct xfrm_algo_list xfrm_calg_list = {
638 .algs = calg_list,
639 .entries = ARRAY_SIZE(calg_list),
640 .type = CRYPTO_ALG_TYPE_COMPRESS,
641 .mask = CRYPTO_ALG_TYPE_MASK,
642};
643
644static struct xfrm_algo_desc *xfrm_find_algo(
645 const struct xfrm_algo_list *algo_list,
646 int match(const struct xfrm_algo_desc *entry, const void *data),
647 const void *data, int probe)
648{
649 struct xfrm_algo_desc *list = algo_list->algs;
650 int i, status;
651
652 for (i = 0; i < algo_list->entries; i++) {
653 if (!match(list + i, data))
654 continue;
655
656 if (list[i].available)
657 return &list[i];
658
659 if (!probe)
660 break;
661
662 status = crypto_has_alg(list[i].name, algo_list->type,
663 algo_list->mask);
664 if (!status)
665 break;
666
667 list[i].available = status;
668 return &list[i];
669 }
670 return NULL;
671}
672
673static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
674 const void *data)
675{
676 return entry->desc.sadb_alg_id == (unsigned long)data;
677}
678
679struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
680{
681 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
682 (void *)(unsigned long)alg_id, 1);
683}
684EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
685
686struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
687{
688 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
689 (void *)(unsigned long)alg_id, 1);
690}
691EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
692
693struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
694{
695 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
696 (void *)(unsigned long)alg_id, 1);
697}
698EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
699
700static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
701 const void *data)
702{
703 const char *name = data;
704
705 return name && (!strcmp(name, entry->name) ||
706 (entry->compat && !strcmp(name, entry->compat)));
707}
708
709struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe)
710{
711 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
712 probe);
713}
714EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
715
716struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe)
717{
718 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
719 probe);
720}
721EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
722
723struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe)
724{
725 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
726 probe);
727}
728EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
729
730struct xfrm_aead_name {
731 const char *name;
732 int icvbits;
733};
734
735static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
736 const void *data)
737{
738 const struct xfrm_aead_name *aead = data;
739 const char *name = aead->name;
740
741 return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
742 !strcmp(name, entry->name);
743}
744
745struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len, int probe)
746{
747 struct xfrm_aead_name data = {
748 .name = name,
749 .icvbits = icv_len,
750 };
751
752 return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
753 probe);
754}
755EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
756
757struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
758{
759 if (idx >= aalg_entries())
760 return NULL;
761
762 return &aalg_list[idx];
763}
764EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
765
766struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
767{
768 if (idx >= ealg_entries())
769 return NULL;
770
771 return &ealg_list[idx];
772}
773EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
774
775/*
776 * Probe for the availability of crypto algorithms, and set the available
777 * flag for any algorithms found on the system. This is typically called by
778 * pfkey during userspace SA add, update or register.
779 */
780void xfrm_probe_algs(void)
781{
782 int i, status;
783
784 BUG_ON(in_softirq());
785
786 for (i = 0; i < aalg_entries(); i++) {
787 status = crypto_has_ahash(aalg_list[i].name, 0, 0);
788 if (aalg_list[i].available != status)
789 aalg_list[i].available = status;
790 }
791
792 for (i = 0; i < ealg_entries(); i++) {
793 status = crypto_has_skcipher(ealg_list[i].name, 0, 0);
794 if (ealg_list[i].available != status)
795 ealg_list[i].available = status;
796 }
797
798 for (i = 0; i < calg_entries(); i++) {
799 status = crypto_has_comp(calg_list[i].name, 0,
800 CRYPTO_ALG_ASYNC);
801 if (calg_list[i].available != status)
802 calg_list[i].available = status;
803 }
804}
805EXPORT_SYMBOL_GPL(xfrm_probe_algs);
806
807int xfrm_count_pfkey_auth_supported(void)
808{
809 int i, n;
810
811 for (i = 0, n = 0; i < aalg_entries(); i++)
812 if (aalg_list[i].available && aalg_list[i].pfkey_supported)
813 n++;
814 return n;
815}
816EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
817
818int xfrm_count_pfkey_enc_supported(void)
819{
820 int i, n;
821
822 for (i = 0, n = 0; i < ealg_entries(); i++)
823 if (ealg_list[i].available && ealg_list[i].pfkey_supported)
824 n++;
825 return n;
826}
827EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
828
829MODULE_LICENSE("GPL");