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