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 <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/pfkeyv2.h>
15 #include <linux/crypto.h>
16 #include <linux/scatterlist.h>
18 #if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || \
19 defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
22 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || \
23 defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
28 * Algorithms supported by IPsec. These entries contain properties which
29 * are used in key negotiation and xfrm processing, and are used to verify
30 * that instantiated crypto transforms have correct parameters for IPsec
33 static struct xfrm_algo_desc aead_list
[] = {
35 .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))",
60 .sadb_alg_id
= SADB_X_EALG_AES_GCM_ICV12
,
62 .sadb_alg_minbits
= 128,
63 .sadb_alg_maxbits
= 256
67 .name
= "rfc4106(gcm(aes))",
76 .sadb_alg_id
= SADB_X_EALG_AES_GCM_ICV16
,
78 .sadb_alg_minbits
= 128,
79 .sadb_alg_maxbits
= 256
83 .name
= "rfc4309(ccm(aes))",
92 .sadb_alg_id
= SADB_X_EALG_AES_CCM_ICV8
,
94 .sadb_alg_minbits
= 128,
95 .sadb_alg_maxbits
= 256
99 .name
= "rfc4309(ccm(aes))",
108 .sadb_alg_id
= SADB_X_EALG_AES_CCM_ICV12
,
110 .sadb_alg_minbits
= 128,
111 .sadb_alg_maxbits
= 256
115 .name
= "rfc4309(ccm(aes))",
119 .icv_truncbits
= 128,
124 .sadb_alg_id
= SADB_X_EALG_AES_CCM_ICV16
,
126 .sadb_alg_minbits
= 128,
127 .sadb_alg_maxbits
= 256
131 .name
= "rfc4543(gcm(aes))",
135 .icv_truncbits
= 128,
140 .sadb_alg_id
= SADB_X_EALG_NULL_AES_GMAC
,
142 .sadb_alg_minbits
= 128,
143 .sadb_alg_maxbits
= 256
148 static struct xfrm_algo_desc aalg_list
[] = {
150 .name
= "digest_null",
160 .sadb_alg_id
= SADB_X_AALG_NULL
,
162 .sadb_alg_minbits
= 0,
163 .sadb_alg_maxbits
= 0
178 .sadb_alg_id
= SADB_AALG_MD5HMAC
,
180 .sadb_alg_minbits
= 128,
181 .sadb_alg_maxbits
= 128
185 .name
= "hmac(sha1)",
196 .sadb_alg_id
= SADB_AALG_SHA1HMAC
,
198 .sadb_alg_minbits
= 160,
199 .sadb_alg_maxbits
= 160
203 .name
= "hmac(sha256)",
214 .sadb_alg_id
= SADB_X_AALG_SHA2_256HMAC
,
216 .sadb_alg_minbits
= 256,
217 .sadb_alg_maxbits
= 256
221 .name
= "hmac(sha384)",
225 .icv_truncbits
= 192,
231 .sadb_alg_id
= SADB_X_AALG_SHA2_384HMAC
,
233 .sadb_alg_minbits
= 384,
234 .sadb_alg_maxbits
= 384
238 .name
= "hmac(sha512)",
242 .icv_truncbits
= 256,
248 .sadb_alg_id
= SADB_X_AALG_SHA2_512HMAC
,
250 .sadb_alg_minbits
= 512,
251 .sadb_alg_maxbits
= 512
255 .name
= "hmac(rmd160)",
266 .sadb_alg_id
= SADB_X_AALG_RIPEMD160HMAC
,
268 .sadb_alg_minbits
= 160,
269 .sadb_alg_maxbits
= 160
283 .sadb_alg_id
= SADB_X_AALG_AES_XCBC_MAC
,
285 .sadb_alg_minbits
= 128,
286 .sadb_alg_maxbits
= 128
291 static struct xfrm_algo_desc ealg_list
[] = {
293 .name
= "ecb(cipher_null)",
294 .compat
= "cipher_null",
304 .sadb_alg_id
= SADB_EALG_NULL
,
306 .sadb_alg_minbits
= 0,
307 .sadb_alg_maxbits
= 0
322 .sadb_alg_id
= SADB_EALG_DESCBC
,
324 .sadb_alg_minbits
= 64,
325 .sadb_alg_maxbits
= 64
329 .name
= "cbc(des3_ede)",
330 .compat
= "des3_ede",
340 .sadb_alg_id
= SADB_EALG_3DESCBC
,
342 .sadb_alg_minbits
= 192,
343 .sadb_alg_maxbits
= 192
347 .name
= "cbc(cast5)",
358 .sadb_alg_id
= SADB_X_EALG_CASTCBC
,
360 .sadb_alg_minbits
= 40,
361 .sadb_alg_maxbits
= 128
365 .name
= "cbc(blowfish)",
366 .compat
= "blowfish",
376 .sadb_alg_id
= SADB_X_EALG_BLOWFISHCBC
,
378 .sadb_alg_minbits
= 40,
379 .sadb_alg_maxbits
= 448
394 .sadb_alg_id
= SADB_X_EALG_AESCBC
,
396 .sadb_alg_minbits
= 128,
397 .sadb_alg_maxbits
= 256
401 .name
= "cbc(serpent)",
412 .sadb_alg_id
= SADB_X_EALG_SERPENTCBC
,
414 .sadb_alg_minbits
= 128,
415 .sadb_alg_maxbits
= 256,
419 .name
= "cbc(camellia)",
420 .compat
= "camellia",
430 .sadb_alg_id
= SADB_X_EALG_CAMELLIACBC
,
432 .sadb_alg_minbits
= 128,
433 .sadb_alg_maxbits
= 256
437 .name
= "cbc(twofish)",
448 .sadb_alg_id
= SADB_X_EALG_TWOFISHCBC
,
450 .sadb_alg_minbits
= 128,
451 .sadb_alg_maxbits
= 256
455 .name
= "rfc3686(ctr(aes))",
460 .defkeybits
= 160, /* 128-bit key + 32-bit nonce */
465 .sadb_alg_id
= SADB_X_EALG_AESCTR
,
467 .sadb_alg_minbits
= 128,
468 .sadb_alg_maxbits
= 256
473 static struct xfrm_algo_desc calg_list
[] = {
481 .desc
= { .sadb_alg_id
= SADB_X_CALG_DEFLATE
}
490 .desc
= { .sadb_alg_id
= SADB_X_CALG_LZS
}
499 .desc
= { .sadb_alg_id
= SADB_X_CALG_LZJH
}
503 static inline int aead_entries(void)
505 return ARRAY_SIZE(aead_list
);
508 static inline int aalg_entries(void)
510 return ARRAY_SIZE(aalg_list
);
513 static inline int ealg_entries(void)
515 return ARRAY_SIZE(ealg_list
);
518 static inline int calg_entries(void)
520 return ARRAY_SIZE(calg_list
);
523 struct xfrm_algo_list
{
524 struct xfrm_algo_desc
*algs
;
530 static const struct xfrm_algo_list xfrm_aead_list
= {
532 .entries
= ARRAY_SIZE(aead_list
),
533 .type
= CRYPTO_ALG_TYPE_AEAD
,
534 .mask
= CRYPTO_ALG_TYPE_MASK
,
537 static const struct xfrm_algo_list xfrm_aalg_list
= {
539 .entries
= ARRAY_SIZE(aalg_list
),
540 .type
= CRYPTO_ALG_TYPE_HASH
,
541 .mask
= CRYPTO_ALG_TYPE_HASH_MASK
,
544 static const struct xfrm_algo_list xfrm_ealg_list
= {
546 .entries
= ARRAY_SIZE(ealg_list
),
547 .type
= CRYPTO_ALG_TYPE_BLKCIPHER
,
548 .mask
= CRYPTO_ALG_TYPE_BLKCIPHER_MASK
,
551 static const struct xfrm_algo_list xfrm_calg_list
= {
553 .entries
= ARRAY_SIZE(calg_list
),
554 .type
= CRYPTO_ALG_TYPE_COMPRESS
,
555 .mask
= CRYPTO_ALG_TYPE_MASK
,
558 static struct xfrm_algo_desc
*xfrm_find_algo(
559 const struct xfrm_algo_list
*algo_list
,
560 int match(const struct xfrm_algo_desc
*entry
, const void *data
),
561 const void *data
, int probe
)
563 struct xfrm_algo_desc
*list
= algo_list
->algs
;
566 for (i
= 0; i
< algo_list
->entries
; i
++) {
567 if (!match(list
+ i
, data
))
570 if (list
[i
].available
)
576 status
= crypto_has_alg(list
[i
].name
, algo_list
->type
,
581 list
[i
].available
= status
;
587 static int xfrm_alg_id_match(const struct xfrm_algo_desc
*entry
,
590 return entry
->desc
.sadb_alg_id
== (unsigned long)data
;
593 struct xfrm_algo_desc
*xfrm_aalg_get_byid(int alg_id
)
595 return xfrm_find_algo(&xfrm_aalg_list
, xfrm_alg_id_match
,
596 (void *)(unsigned long)alg_id
, 1);
598 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid
);
600 struct xfrm_algo_desc
*xfrm_ealg_get_byid(int alg_id
)
602 return xfrm_find_algo(&xfrm_ealg_list
, xfrm_alg_id_match
,
603 (void *)(unsigned long)alg_id
, 1);
605 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid
);
607 struct xfrm_algo_desc
*xfrm_calg_get_byid(int alg_id
)
609 return xfrm_find_algo(&xfrm_calg_list
, xfrm_alg_id_match
,
610 (void *)(unsigned long)alg_id
, 1);
612 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid
);
614 static int xfrm_alg_name_match(const struct xfrm_algo_desc
*entry
,
617 const char *name
= data
;
619 return name
&& (!strcmp(name
, entry
->name
) ||
620 (entry
->compat
&& !strcmp(name
, entry
->compat
)));
623 struct xfrm_algo_desc
*xfrm_aalg_get_byname(char *name
, int probe
)
625 return xfrm_find_algo(&xfrm_aalg_list
, xfrm_alg_name_match
, name
,
628 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname
);
630 struct xfrm_algo_desc
*xfrm_ealg_get_byname(char *name
, int probe
)
632 return xfrm_find_algo(&xfrm_ealg_list
, xfrm_alg_name_match
, name
,
635 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname
);
637 struct xfrm_algo_desc
*xfrm_calg_get_byname(char *name
, int probe
)
639 return xfrm_find_algo(&xfrm_calg_list
, xfrm_alg_name_match
, name
,
642 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname
);
644 struct xfrm_aead_name
{
649 static int xfrm_aead_name_match(const struct xfrm_algo_desc
*entry
,
652 const struct xfrm_aead_name
*aead
= data
;
653 const char *name
= aead
->name
;
655 return aead
->icvbits
== entry
->uinfo
.aead
.icv_truncbits
&& name
&&
656 !strcmp(name
, entry
->name
);
659 struct xfrm_algo_desc
*xfrm_aead_get_byname(char *name
, int icv_len
, int probe
)
661 struct xfrm_aead_name data
= {
666 return xfrm_find_algo(&xfrm_aead_list
, xfrm_aead_name_match
, &data
,
669 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname
);
671 struct xfrm_algo_desc
*xfrm_aalg_get_byidx(unsigned int idx
)
673 if (idx
>= aalg_entries())
676 return &aalg_list
[idx
];
678 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx
);
680 struct xfrm_algo_desc
*xfrm_ealg_get_byidx(unsigned int idx
)
682 if (idx
>= ealg_entries())
685 return &ealg_list
[idx
];
687 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx
);
690 * Probe for the availability of crypto algorithms, and set the available
691 * flag for any algorithms found on the system. This is typically called by
692 * pfkey during userspace SA add, update or register.
694 void xfrm_probe_algs(void)
698 BUG_ON(in_softirq());
700 for (i
= 0; i
< aalg_entries(); i
++) {
701 status
= crypto_has_hash(aalg_list
[i
].name
, 0,
703 if (aalg_list
[i
].available
!= status
)
704 aalg_list
[i
].available
= status
;
707 for (i
= 0; i
< ealg_entries(); i
++) {
708 status
= crypto_has_blkcipher(ealg_list
[i
].name
, 0,
710 if (ealg_list
[i
].available
!= status
)
711 ealg_list
[i
].available
= status
;
714 for (i
= 0; i
< calg_entries(); i
++) {
715 status
= crypto_has_comp(calg_list
[i
].name
, 0,
717 if (calg_list
[i
].available
!= status
)
718 calg_list
[i
].available
= status
;
721 EXPORT_SYMBOL_GPL(xfrm_probe_algs
);
723 int xfrm_count_auth_supported(void)
727 for (i
= 0, n
= 0; i
< aalg_entries(); i
++)
728 if (aalg_list
[i
].available
)
732 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported
);
734 int xfrm_count_enc_supported(void)
738 for (i
= 0, n
= 0; i
< ealg_entries(); i
++)
739 if (ealg_list
[i
].available
)
743 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported
);
745 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || \
746 defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
748 void *pskb_put(struct sk_buff
*skb
, struct sk_buff
*tail
, int len
)
751 skb
->data_len
+= len
;
754 return skb_put(tail
, len
);
756 EXPORT_SYMBOL_GPL(pskb_put
);