2 * xfrm algorithm interface
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
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)
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>
20 #if IS_ENABLED(CONFIG_INET_ESP) || IS_ENABLED(CONFIG_INET6_ESP)
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
30 static struct xfrm_algo_desc aead_list[] = {
32 .name = "rfc4106(gcm(aes))",
44 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
46 .sadb_alg_minbits = 128,
47 .sadb_alg_maxbits = 256
51 .name = "rfc4106(gcm(aes))",
63 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
65 .sadb_alg_minbits = 128,
66 .sadb_alg_maxbits = 256
70 .name = "rfc4106(gcm(aes))",
82 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
84 .sadb_alg_minbits = 128,
85 .sadb_alg_maxbits = 256
89 .name = "rfc4309(ccm(aes))",
101 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
103 .sadb_alg_minbits = 128,
104 .sadb_alg_maxbits = 256
108 .name = "rfc4309(ccm(aes))",
117 .pfkey_supported = 1,
120 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
122 .sadb_alg_minbits = 128,
123 .sadb_alg_maxbits = 256
127 .name = "rfc4309(ccm(aes))",
132 .icv_truncbits = 128,
136 .pfkey_supported = 1,
139 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
141 .sadb_alg_minbits = 128,
142 .sadb_alg_maxbits = 256
146 .name = "rfc4543(gcm(aes))",
151 .icv_truncbits = 128,
155 .pfkey_supported = 1,
158 .sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
160 .sadb_alg_minbits = 128,
161 .sadb_alg_maxbits = 256
165 .name = "rfc7539esp(chacha20,poly1305)",
170 .icv_truncbits = 128,
174 .pfkey_supported = 0,
178 static struct xfrm_algo_desc aalg_list[] = {
180 .name = "digest_null",
189 .pfkey_supported = 1,
192 .sadb_alg_id = SADB_X_AALG_NULL,
194 .sadb_alg_minbits = 0,
195 .sadb_alg_maxbits = 0
209 .pfkey_supported = 1,
212 .sadb_alg_id = SADB_AALG_MD5HMAC,
214 .sadb_alg_minbits = 128,
215 .sadb_alg_maxbits = 128
219 .name = "hmac(sha1)",
229 .pfkey_supported = 1,
232 .sadb_alg_id = SADB_AALG_SHA1HMAC,
234 .sadb_alg_minbits = 160,
235 .sadb_alg_maxbits = 160
239 .name = "hmac(sha256)",
249 .pfkey_supported = 1,
252 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
254 .sadb_alg_minbits = 256,
255 .sadb_alg_maxbits = 256
259 .name = "hmac(sha384)",
263 .icv_truncbits = 192,
268 .pfkey_supported = 1,
271 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
273 .sadb_alg_minbits = 384,
274 .sadb_alg_maxbits = 384
278 .name = "hmac(sha512)",
282 .icv_truncbits = 256,
287 .pfkey_supported = 1,
290 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
292 .sadb_alg_minbits = 512,
293 .sadb_alg_maxbits = 512
297 .name = "hmac(rmd160)",
307 .pfkey_supported = 1,
310 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
312 .sadb_alg_minbits = 160,
313 .sadb_alg_maxbits = 160
326 .pfkey_supported = 1,
329 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
331 .sadb_alg_minbits = 128,
332 .sadb_alg_maxbits = 128
346 .pfkey_supported = 0,
350 static struct xfrm_algo_desc ealg_list[] = {
352 .name = "ecb(cipher_null)",
353 .compat = "cipher_null",
362 .pfkey_supported = 1,
365 .sadb_alg_id = SADB_EALG_NULL,
367 .sadb_alg_minbits = 0,
368 .sadb_alg_maxbits = 0
383 .pfkey_supported = 1,
386 .sadb_alg_id = SADB_EALG_DESCBC,
388 .sadb_alg_minbits = 64,
389 .sadb_alg_maxbits = 64
393 .name = "cbc(des3_ede)",
394 .compat = "des3_ede",
404 .pfkey_supported = 1,
407 .sadb_alg_id = SADB_EALG_3DESCBC,
409 .sadb_alg_minbits = 192,
410 .sadb_alg_maxbits = 192
414 .name = "cbc(cast5)",
425 .pfkey_supported = 1,
428 .sadb_alg_id = SADB_X_EALG_CASTCBC,
430 .sadb_alg_minbits = 40,
431 .sadb_alg_maxbits = 128
435 .name = "cbc(blowfish)",
436 .compat = "blowfish",
446 .pfkey_supported = 1,
449 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
451 .sadb_alg_minbits = 40,
452 .sadb_alg_maxbits = 448
467 .pfkey_supported = 1,
470 .sadb_alg_id = SADB_X_EALG_AESCBC,
472 .sadb_alg_minbits = 128,
473 .sadb_alg_maxbits = 256
477 .name = "cbc(serpent)",
488 .pfkey_supported = 1,
491 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
493 .sadb_alg_minbits = 128,
494 .sadb_alg_maxbits = 256,
498 .name = "cbc(camellia)",
499 .compat = "camellia",
509 .pfkey_supported = 1,
512 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
514 .sadb_alg_minbits = 128,
515 .sadb_alg_maxbits = 256
519 .name = "cbc(twofish)",
530 .pfkey_supported = 1,
533 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
535 .sadb_alg_minbits = 128,
536 .sadb_alg_maxbits = 256
540 .name = "rfc3686(ctr(aes))",
546 .defkeybits = 160, /* 128-bit key + 32-bit nonce */
550 .pfkey_supported = 1,
553 .sadb_alg_id = SADB_X_EALG_AESCTR,
555 .sadb_alg_minbits = 160,
556 .sadb_alg_maxbits = 288
561 static struct xfrm_algo_desc calg_list[] = {
569 .pfkey_supported = 1,
570 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
579 .pfkey_supported = 1,
580 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
589 .pfkey_supported = 1,
590 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
594 static inline int aalg_entries(void)
596 return ARRAY_SIZE(aalg_list);
599 static inline int ealg_entries(void)
601 return ARRAY_SIZE(ealg_list);
604 static inline int calg_entries(void)
606 return ARRAY_SIZE(calg_list);
609 struct xfrm_algo_list {
610 struct xfrm_algo_desc *algs;
616 static const struct xfrm_algo_list xfrm_aead_list = {
618 .entries = ARRAY_SIZE(aead_list),
619 .type = CRYPTO_ALG_TYPE_AEAD,
620 .mask = CRYPTO_ALG_TYPE_MASK,
623 static const struct xfrm_algo_list xfrm_aalg_list = {
625 .entries = ARRAY_SIZE(aalg_list),
626 .type = CRYPTO_ALG_TYPE_HASH,
627 .mask = CRYPTO_ALG_TYPE_HASH_MASK,
630 static const struct xfrm_algo_list xfrm_ealg_list = {
632 .entries = ARRAY_SIZE(ealg_list),
633 .type = CRYPTO_ALG_TYPE_BLKCIPHER,
634 .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
637 static const struct xfrm_algo_list xfrm_calg_list = {
639 .entries = ARRAY_SIZE(calg_list),
640 .type = CRYPTO_ALG_TYPE_COMPRESS,
641 .mask = CRYPTO_ALG_TYPE_MASK,
644 static 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)
649 struct xfrm_algo_desc *list = algo_list->algs;
652 for (i = 0; i < algo_list->entries; i++) {
653 if (!match(list + i, data))
656 if (list[i].available)
662 status = crypto_has_alg(list[i].name, algo_list->type,
667 list[i].available = status;
673 static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
676 return entry->desc.sadb_alg_id == (unsigned long)data;
679 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
681 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
682 (void *)(unsigned long)alg_id, 1);
684 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
686 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
688 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
689 (void *)(unsigned long)alg_id, 1);
691 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
693 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
695 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
696 (void *)(unsigned long)alg_id, 1);
698 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
700 static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
703 const char *name = data;
705 return name && (!strcmp(name, entry->name) ||
706 (entry->compat && !strcmp(name, entry->compat)));
709 struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe)
711 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
714 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
716 struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe)
718 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
721 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
723 struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe)
725 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
728 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
730 struct xfrm_aead_name {
735 static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
738 const struct xfrm_aead_name *aead = data;
739 const char *name = aead->name;
741 return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
742 !strcmp(name, entry->name);
745 struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len, int probe)
747 struct xfrm_aead_name data = {
752 return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
755 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
757 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
759 if (idx >= aalg_entries())
762 return &aalg_list[idx];
764 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
766 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
768 if (idx >= ealg_entries())
771 return &ealg_list[idx];
773 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
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.
780 void xfrm_probe_algs(void)
784 BUG_ON(in_softirq());
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;
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;
798 for (i = 0; i < calg_entries(); i++) {
799 status = crypto_has_comp(calg_list[i].name, 0,
801 if (calg_list[i].available != status)
802 calg_list[i].available = status;
805 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
807 int xfrm_count_pfkey_auth_supported(void)
811 for (i = 0, n = 0; i < aalg_entries(); i++)
812 if (aalg_list[i].available && aalg_list[i].pfkey_supported)
816 EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
818 int xfrm_count_pfkey_enc_supported(void)
822 for (i = 0, n = 0; i < ealg_entries(); i++)
823 if (ealg_list[i].available && ealg_list[i].pfkey_supported)
827 EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
829 MODULE_LICENSE("GPL");