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) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
21 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
26 * Algorithms supported by IPsec. These entries contain properties which
27 * are used in key negotiation and xfrm processing, and are used to verify
28 * that instantiated crypto transforms have correct parameters for IPsec
31 static struct xfrm_algo_desc aead_list
[] = {
33 .name
= "rfc4106(gcm(aes))",
42 .sadb_alg_id
= SADB_X_EALG_AES_GCM_ICV8
,
44 .sadb_alg_minbits
= 128,
45 .sadb_alg_maxbits
= 256
49 .name
= "rfc4106(gcm(aes))",
58 .sadb_alg_id
= SADB_X_EALG_AES_GCM_ICV12
,
60 .sadb_alg_minbits
= 128,
61 .sadb_alg_maxbits
= 256
65 .name
= "rfc4106(gcm(aes))",
74 .sadb_alg_id
= SADB_X_EALG_AES_GCM_ICV16
,
76 .sadb_alg_minbits
= 128,
77 .sadb_alg_maxbits
= 256
81 .name
= "rfc4309(ccm(aes))",
90 .sadb_alg_id
= SADB_X_EALG_AES_CCM_ICV8
,
92 .sadb_alg_minbits
= 128,
93 .sadb_alg_maxbits
= 256
97 .name
= "rfc4309(ccm(aes))",
106 .sadb_alg_id
= SADB_X_EALG_AES_CCM_ICV12
,
108 .sadb_alg_minbits
= 128,
109 .sadb_alg_maxbits
= 256
113 .name
= "rfc4309(ccm(aes))",
117 .icv_truncbits
= 128,
122 .sadb_alg_id
= SADB_X_EALG_AES_CCM_ICV16
,
124 .sadb_alg_minbits
= 128,
125 .sadb_alg_maxbits
= 256
130 static struct xfrm_algo_desc aalg_list
[] = {
132 .name
= "digest_null",
142 .sadb_alg_id
= SADB_X_AALG_NULL
,
144 .sadb_alg_minbits
= 0,
145 .sadb_alg_maxbits
= 0
160 .sadb_alg_id
= SADB_AALG_MD5HMAC
,
162 .sadb_alg_minbits
= 128,
163 .sadb_alg_maxbits
= 128
167 .name
= "hmac(sha1)",
178 .sadb_alg_id
= SADB_AALG_SHA1HMAC
,
180 .sadb_alg_minbits
= 160,
181 .sadb_alg_maxbits
= 160
185 .name
= "hmac(sha256)",
196 .sadb_alg_id
= SADB_X_AALG_SHA2_256HMAC
,
198 .sadb_alg_minbits
= 256,
199 .sadb_alg_maxbits
= 256
203 .name
= "hmac(rmd160)",
214 .sadb_alg_id
= SADB_X_AALG_RIPEMD160HMAC
,
216 .sadb_alg_minbits
= 160,
217 .sadb_alg_maxbits
= 160
231 .sadb_alg_id
= SADB_X_AALG_AES_XCBC_MAC
,
233 .sadb_alg_minbits
= 128,
234 .sadb_alg_maxbits
= 128
239 static struct xfrm_algo_desc ealg_list
[] = {
241 .name
= "ecb(cipher_null)",
242 .compat
= "cipher_null",
252 .sadb_alg_id
= SADB_EALG_NULL
,
254 .sadb_alg_minbits
= 0,
255 .sadb_alg_maxbits
= 0
270 .sadb_alg_id
= SADB_EALG_DESCBC
,
272 .sadb_alg_minbits
= 64,
273 .sadb_alg_maxbits
= 64
277 .name
= "cbc(des3_ede)",
278 .compat
= "des3_ede",
288 .sadb_alg_id
= SADB_EALG_3DESCBC
,
290 .sadb_alg_minbits
= 192,
291 .sadb_alg_maxbits
= 192
295 .name
= "cbc(cast128)",
306 .sadb_alg_id
= SADB_X_EALG_CASTCBC
,
308 .sadb_alg_minbits
= 40,
309 .sadb_alg_maxbits
= 128
313 .name
= "cbc(blowfish)",
314 .compat
= "blowfish",
324 .sadb_alg_id
= SADB_X_EALG_BLOWFISHCBC
,
326 .sadb_alg_minbits
= 40,
327 .sadb_alg_maxbits
= 448
342 .sadb_alg_id
= SADB_X_EALG_AESCBC
,
344 .sadb_alg_minbits
= 128,
345 .sadb_alg_maxbits
= 256
349 .name
= "cbc(serpent)",
360 .sadb_alg_id
= SADB_X_EALG_SERPENTCBC
,
362 .sadb_alg_minbits
= 128,
363 .sadb_alg_maxbits
= 256,
367 .name
= "cbc(camellia)",
377 .sadb_alg_id
= SADB_X_EALG_CAMELLIACBC
,
379 .sadb_alg_minbits
= 128,
380 .sadb_alg_maxbits
= 256
384 .name
= "cbc(twofish)",
395 .sadb_alg_id
= SADB_X_EALG_TWOFISHCBC
,
397 .sadb_alg_minbits
= 128,
398 .sadb_alg_maxbits
= 256
402 .name
= "rfc3686(ctr(aes))",
407 .defkeybits
= 160, /* 128-bit key + 32-bit nonce */
412 .sadb_alg_id
= SADB_X_EALG_AESCTR
,
414 .sadb_alg_minbits
= 128,
415 .sadb_alg_maxbits
= 256
420 static struct xfrm_algo_desc calg_list
[] = {
428 .desc
= { .sadb_alg_id
= SADB_X_CALG_DEFLATE
}
437 .desc
= { .sadb_alg_id
= SADB_X_CALG_LZS
}
446 .desc
= { .sadb_alg_id
= SADB_X_CALG_LZJH
}
450 static inline int aead_entries(void)
452 return ARRAY_SIZE(aead_list
);
455 static inline int aalg_entries(void)
457 return ARRAY_SIZE(aalg_list
);
460 static inline int ealg_entries(void)
462 return ARRAY_SIZE(ealg_list
);
465 static inline int calg_entries(void)
467 return ARRAY_SIZE(calg_list
);
470 struct xfrm_algo_list
{
471 struct xfrm_algo_desc
*algs
;
477 static const struct xfrm_algo_list xfrm_aead_list
= {
479 .entries
= ARRAY_SIZE(aead_list
),
480 .type
= CRYPTO_ALG_TYPE_AEAD
,
481 .mask
= CRYPTO_ALG_TYPE_MASK
,
484 static const struct xfrm_algo_list xfrm_aalg_list
= {
486 .entries
= ARRAY_SIZE(aalg_list
),
487 .type
= CRYPTO_ALG_TYPE_HASH
,
488 .mask
= CRYPTO_ALG_TYPE_HASH_MASK
,
491 static const struct xfrm_algo_list xfrm_ealg_list
= {
493 .entries
= ARRAY_SIZE(ealg_list
),
494 .type
= CRYPTO_ALG_TYPE_BLKCIPHER
,
495 .mask
= CRYPTO_ALG_TYPE_BLKCIPHER_MASK
,
498 static const struct xfrm_algo_list xfrm_calg_list
= {
500 .entries
= ARRAY_SIZE(calg_list
),
501 .type
= CRYPTO_ALG_TYPE_COMPRESS
,
502 .mask
= CRYPTO_ALG_TYPE_MASK
,
505 static struct xfrm_algo_desc
*xfrm_find_algo(
506 const struct xfrm_algo_list
*algo_list
,
507 int match(const struct xfrm_algo_desc
*entry
, const void *data
),
508 const void *data
, int probe
)
510 struct xfrm_algo_desc
*list
= algo_list
->algs
;
513 for (i
= 0; i
< algo_list
->entries
; i
++) {
514 if (!match(list
+ i
, data
))
517 if (list
[i
].available
)
523 status
= crypto_has_alg(list
[i
].name
, algo_list
->type
,
528 list
[i
].available
= status
;
534 static int xfrm_alg_id_match(const struct xfrm_algo_desc
*entry
,
537 return entry
->desc
.sadb_alg_id
== (unsigned long)data
;
540 struct xfrm_algo_desc
*xfrm_aalg_get_byid(int alg_id
)
542 return xfrm_find_algo(&xfrm_aalg_list
, xfrm_alg_id_match
,
543 (void *)(unsigned long)alg_id
, 1);
545 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid
);
547 struct xfrm_algo_desc
*xfrm_ealg_get_byid(int alg_id
)
549 return xfrm_find_algo(&xfrm_ealg_list
, xfrm_alg_id_match
,
550 (void *)(unsigned long)alg_id
, 1);
552 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid
);
554 struct xfrm_algo_desc
*xfrm_calg_get_byid(int alg_id
)
556 return xfrm_find_algo(&xfrm_calg_list
, xfrm_alg_id_match
,
557 (void *)(unsigned long)alg_id
, 1);
559 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid
);
561 static int xfrm_alg_name_match(const struct xfrm_algo_desc
*entry
,
564 const char *name
= data
;
566 return name
&& (!strcmp(name
, entry
->name
) ||
567 (entry
->compat
&& !strcmp(name
, entry
->compat
)));
570 struct xfrm_algo_desc
*xfrm_aalg_get_byname(char *name
, int probe
)
572 return xfrm_find_algo(&xfrm_aalg_list
, xfrm_alg_name_match
, name
,
575 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname
);
577 struct xfrm_algo_desc
*xfrm_ealg_get_byname(char *name
, int probe
)
579 return xfrm_find_algo(&xfrm_ealg_list
, xfrm_alg_name_match
, name
,
582 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname
);
584 struct xfrm_algo_desc
*xfrm_calg_get_byname(char *name
, int probe
)
586 return xfrm_find_algo(&xfrm_calg_list
, xfrm_alg_name_match
, name
,
589 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname
);
591 struct xfrm_aead_name
{
596 static int xfrm_aead_name_match(const struct xfrm_algo_desc
*entry
,
599 const struct xfrm_aead_name
*aead
= data
;
600 const char *name
= aead
->name
;
602 return aead
->icvbits
== entry
->uinfo
.aead
.icv_truncbits
&& name
&&
603 !strcmp(name
, entry
->name
);
606 struct xfrm_algo_desc
*xfrm_aead_get_byname(char *name
, int icv_len
, int probe
)
608 struct xfrm_aead_name data
= {
613 return xfrm_find_algo(&xfrm_aead_list
, xfrm_aead_name_match
, &data
,
616 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname
);
618 struct xfrm_algo_desc
*xfrm_aalg_get_byidx(unsigned int idx
)
620 if (idx
>= aalg_entries())
623 return &aalg_list
[idx
];
625 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx
);
627 struct xfrm_algo_desc
*xfrm_ealg_get_byidx(unsigned int idx
)
629 if (idx
>= ealg_entries())
632 return &ealg_list
[idx
];
634 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx
);
637 * Probe for the availability of crypto algorithms, and set the available
638 * flag for any algorithms found on the system. This is typically called by
639 * pfkey during userspace SA add, update or register.
641 void xfrm_probe_algs(void)
645 BUG_ON(in_softirq());
647 for (i
= 0; i
< aalg_entries(); i
++) {
648 status
= crypto_has_hash(aalg_list
[i
].name
, 0,
650 if (aalg_list
[i
].available
!= status
)
651 aalg_list
[i
].available
= status
;
654 for (i
= 0; i
< ealg_entries(); i
++) {
655 status
= crypto_has_blkcipher(ealg_list
[i
].name
, 0,
657 if (ealg_list
[i
].available
!= status
)
658 ealg_list
[i
].available
= status
;
661 for (i
= 0; i
< calg_entries(); i
++) {
662 status
= crypto_has_comp(calg_list
[i
].name
, 0,
664 if (calg_list
[i
].available
!= status
)
665 calg_list
[i
].available
= status
;
668 EXPORT_SYMBOL_GPL(xfrm_probe_algs
);
670 int xfrm_count_auth_supported(void)
674 for (i
= 0, n
= 0; i
< aalg_entries(); i
++)
675 if (aalg_list
[i
].available
)
679 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported
);
681 int xfrm_count_enc_supported(void)
685 for (i
= 0, n
= 0; i
< ealg_entries(); i
++)
686 if (ealg_list
[i
].available
)
690 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported
);
692 /* Move to common area: it is shared with AH. */
694 int skb_icv_walk(const struct sk_buff
*skb
, struct hash_desc
*desc
,
695 int offset
, int len
, icv_update_fn_t icv_update
)
697 int start
= skb_headlen(skb
);
698 int i
, copy
= start
- offset
;
699 struct sk_buff
*frag_iter
;
700 struct scatterlist sg
;
703 /* Checksum header. */
708 sg_init_one(&sg
, skb
->data
+ offset
, copy
);
710 err
= icv_update(desc
, &sg
, copy
);
714 if ((len
-= copy
) == 0)
719 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
722 WARN_ON(start
> offset
+ len
);
724 end
= start
+ skb_shinfo(skb
)->frags
[i
].size
;
725 if ((copy
= end
- offset
) > 0) {
726 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
731 sg_init_table(&sg
, 1);
732 sg_set_page(&sg
, frag
->page
, copy
,
733 frag
->page_offset
+ offset
-start
);
735 err
= icv_update(desc
, &sg
, copy
);
746 skb_walk_frags(skb
, frag_iter
) {
749 WARN_ON(start
> offset
+ len
);
751 end
= start
+ frag_iter
->len
;
752 if ((copy
= end
- offset
) > 0) {
755 err
= skb_icv_walk(frag_iter
, desc
, offset
-start
,
759 if ((len
-= copy
) == 0)
768 EXPORT_SYMBOL_GPL(skb_icv_walk
);
770 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
772 void *pskb_put(struct sk_buff
*skb
, struct sk_buff
*tail
, int len
)
775 skb
->data_len
+= len
;
778 return skb_put(tail
, len
);
780 EXPORT_SYMBOL_GPL(pskb_put
);