staging: rtl8192e: Fix UNNECESSARY_ELSE warning
[linux-2.6/btrfs-unstable.git] / net / xfrm / xfrm_algo.c
blob12e82a5e4ad5873e716014e421be8e329587e00c
1 /*
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)
9 * any later version.
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
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.
28 static struct xfrm_algo_desc aead_list[] = {
30 .name = "rfc4106(gcm(aes))",
32 .uinfo = {
33 .aead = {
34 .icv_truncbits = 64,
38 .pfkey_supported = 1,
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
48 .name = "rfc4106(gcm(aes))",
50 .uinfo = {
51 .aead = {
52 .icv_truncbits = 96,
56 .pfkey_supported = 1,
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
66 .name = "rfc4106(gcm(aes))",
68 .uinfo = {
69 .aead = {
70 .icv_truncbits = 128,
74 .pfkey_supported = 1,
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
84 .name = "rfc4309(ccm(aes))",
86 .uinfo = {
87 .aead = {
88 .icv_truncbits = 64,
92 .pfkey_supported = 1,
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
102 .name = "rfc4309(ccm(aes))",
104 .uinfo = {
105 .aead = {
106 .icv_truncbits = 96,
110 .pfkey_supported = 1,
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
120 .name = "rfc4309(ccm(aes))",
122 .uinfo = {
123 .aead = {
124 .icv_truncbits = 128,
128 .pfkey_supported = 1,
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
138 .name = "rfc4543(gcm(aes))",
140 .uinfo = {
141 .aead = {
142 .icv_truncbits = 128,
146 .pfkey_supported = 1,
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
157 static struct xfrm_algo_desc aalg_list[] = {
159 .name = "digest_null",
161 .uinfo = {
162 .auth = {
163 .icv_truncbits = 0,
164 .icv_fullbits = 0,
168 .pfkey_supported = 1,
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
178 .name = "hmac(md5)",
179 .compat = "md5",
181 .uinfo = {
182 .auth = {
183 .icv_truncbits = 96,
184 .icv_fullbits = 128,
188 .pfkey_supported = 1,
190 .desc = {
191 .sadb_alg_id = SADB_AALG_MD5HMAC,
192 .sadb_alg_ivlen = 0,
193 .sadb_alg_minbits = 128,
194 .sadb_alg_maxbits = 128
198 .name = "hmac(sha1)",
199 .compat = "sha1",
201 .uinfo = {
202 .auth = {
203 .icv_truncbits = 96,
204 .icv_fullbits = 160,
208 .pfkey_supported = 1,
210 .desc = {
211 .sadb_alg_id = SADB_AALG_SHA1HMAC,
212 .sadb_alg_ivlen = 0,
213 .sadb_alg_minbits = 160,
214 .sadb_alg_maxbits = 160
218 .name = "hmac(sha256)",
219 .compat = "sha256",
221 .uinfo = {
222 .auth = {
223 .icv_truncbits = 96,
224 .icv_fullbits = 256,
228 .pfkey_supported = 1,
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
238 .name = "hmac(sha384)",
240 .uinfo = {
241 .auth = {
242 .icv_truncbits = 192,
243 .icv_fullbits = 384,
247 .pfkey_supported = 1,
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
257 .name = "hmac(sha512)",
259 .uinfo = {
260 .auth = {
261 .icv_truncbits = 256,
262 .icv_fullbits = 512,
266 .pfkey_supported = 1,
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
276 .name = "hmac(rmd160)",
277 .compat = "rmd160",
279 .uinfo = {
280 .auth = {
281 .icv_truncbits = 96,
282 .icv_fullbits = 160,
286 .pfkey_supported = 1,
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
296 .name = "xcbc(aes)",
298 .uinfo = {
299 .auth = {
300 .icv_truncbits = 96,
301 .icv_fullbits = 128,
305 .pfkey_supported = 1,
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
315 /* rfc4494 */
316 .name = "cmac(aes)",
318 .uinfo = {
319 .auth = {
320 .icv_truncbits = 96,
321 .icv_fullbits = 128,
325 .pfkey_supported = 0,
329 static struct xfrm_algo_desc ealg_list[] = {
331 .name = "ecb(cipher_null)",
332 .compat = "cipher_null",
334 .uinfo = {
335 .encr = {
336 .blockbits = 8,
337 .defkeybits = 0,
341 .pfkey_supported = 1,
343 .desc = {
344 .sadb_alg_id = SADB_EALG_NULL,
345 .sadb_alg_ivlen = 0,
346 .sadb_alg_minbits = 0,
347 .sadb_alg_maxbits = 0
351 .name = "cbc(des)",
352 .compat = "des",
354 .uinfo = {
355 .encr = {
356 .blockbits = 64,
357 .defkeybits = 64,
361 .pfkey_supported = 1,
363 .desc = {
364 .sadb_alg_id = SADB_EALG_DESCBC,
365 .sadb_alg_ivlen = 8,
366 .sadb_alg_minbits = 64,
367 .sadb_alg_maxbits = 64
371 .name = "cbc(des3_ede)",
372 .compat = "des3_ede",
374 .uinfo = {
375 .encr = {
376 .blockbits = 64,
377 .defkeybits = 192,
381 .pfkey_supported = 1,
383 .desc = {
384 .sadb_alg_id = SADB_EALG_3DESCBC,
385 .sadb_alg_ivlen = 8,
386 .sadb_alg_minbits = 192,
387 .sadb_alg_maxbits = 192
391 .name = "cbc(cast5)",
392 .compat = "cast5",
394 .uinfo = {
395 .encr = {
396 .blockbits = 64,
397 .defkeybits = 128,
401 .pfkey_supported = 1,
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
411 .name = "cbc(blowfish)",
412 .compat = "blowfish",
414 .uinfo = {
415 .encr = {
416 .blockbits = 64,
417 .defkeybits = 128,
421 .pfkey_supported = 1,
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
431 .name = "cbc(aes)",
432 .compat = "aes",
434 .uinfo = {
435 .encr = {
436 .blockbits = 128,
437 .defkeybits = 128,
441 .pfkey_supported = 1,
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
451 .name = "cbc(serpent)",
452 .compat = "serpent",
454 .uinfo = {
455 .encr = {
456 .blockbits = 128,
457 .defkeybits = 128,
461 .pfkey_supported = 1,
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,
471 .name = "cbc(camellia)",
472 .compat = "camellia",
474 .uinfo = {
475 .encr = {
476 .blockbits = 128,
477 .defkeybits = 128,
481 .pfkey_supported = 1,
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
491 .name = "cbc(twofish)",
492 .compat = "twofish",
494 .uinfo = {
495 .encr = {
496 .blockbits = 128,
497 .defkeybits = 128,
501 .pfkey_supported = 1,
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
511 .name = "rfc3686(ctr(aes))",
513 .uinfo = {
514 .encr = {
515 .blockbits = 128,
516 .defkeybits = 160, /* 128-bit key + 32-bit nonce */
520 .pfkey_supported = 1,
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
531 static struct xfrm_algo_desc calg_list[] = {
533 .name = "deflate",
534 .uinfo = {
535 .comp = {
536 .threshold = 90,
539 .pfkey_supported = 1,
540 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
543 .name = "lzs",
544 .uinfo = {
545 .comp = {
546 .threshold = 90,
549 .pfkey_supported = 1,
550 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
553 .name = "lzjh",
554 .uinfo = {
555 .comp = {
556 .threshold = 50,
559 .pfkey_supported = 1,
560 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
564 static inline int aalg_entries(void)
566 return ARRAY_SIZE(aalg_list);
569 static inline int ealg_entries(void)
571 return ARRAY_SIZE(ealg_list);
574 static inline int calg_entries(void)
576 return ARRAY_SIZE(calg_list);
579 struct xfrm_algo_list {
580 struct xfrm_algo_desc *algs;
581 int entries;
582 u32 type;
583 u32 mask;
586 static const struct xfrm_algo_list xfrm_aead_list = {
587 .algs = aead_list,
588 .entries = ARRAY_SIZE(aead_list),
589 .type = CRYPTO_ALG_TYPE_AEAD,
590 .mask = CRYPTO_ALG_TYPE_MASK,
593 static const struct xfrm_algo_list xfrm_aalg_list = {
594 .algs = aalg_list,
595 .entries = ARRAY_SIZE(aalg_list),
596 .type = CRYPTO_ALG_TYPE_HASH,
597 .mask = CRYPTO_ALG_TYPE_HASH_MASK,
600 static const struct xfrm_algo_list xfrm_ealg_list = {
601 .algs = ealg_list,
602 .entries = ARRAY_SIZE(ealg_list),
603 .type = CRYPTO_ALG_TYPE_BLKCIPHER,
604 .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
607 static const struct xfrm_algo_list xfrm_calg_list = {
608 .algs = calg_list,
609 .entries = ARRAY_SIZE(calg_list),
610 .type = CRYPTO_ALG_TYPE_COMPRESS,
611 .mask = CRYPTO_ALG_TYPE_MASK,
614 static struct xfrm_algo_desc *xfrm_find_algo(
615 const struct xfrm_algo_list *algo_list,
616 int match(const struct xfrm_algo_desc *entry, const void *data),
617 const void *data, int probe)
619 struct xfrm_algo_desc *list = algo_list->algs;
620 int i, status;
622 for (i = 0; i < algo_list->entries; i++) {
623 if (!match(list + i, data))
624 continue;
626 if (list[i].available)
627 return &list[i];
629 if (!probe)
630 break;
632 status = crypto_has_alg(list[i].name, algo_list->type,
633 algo_list->mask);
634 if (!status)
635 break;
637 list[i].available = status;
638 return &list[i];
640 return NULL;
643 static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
644 const void *data)
646 return entry->desc.sadb_alg_id == (unsigned long)data;
649 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
651 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
652 (void *)(unsigned long)alg_id, 1);
654 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
656 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
658 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
659 (void *)(unsigned long)alg_id, 1);
661 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
663 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
665 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
666 (void *)(unsigned long)alg_id, 1);
668 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
670 static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
671 const void *data)
673 const char *name = data;
675 return name && (!strcmp(name, entry->name) ||
676 (entry->compat && !strcmp(name, entry->compat)));
679 struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe)
681 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
682 probe);
684 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
686 struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe)
688 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
689 probe);
691 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
693 struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe)
695 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
696 probe);
698 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
700 struct xfrm_aead_name {
701 const char *name;
702 int icvbits;
705 static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
706 const void *data)
708 const struct xfrm_aead_name *aead = data;
709 const char *name = aead->name;
711 return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
712 !strcmp(name, entry->name);
715 struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len, int probe)
717 struct xfrm_aead_name data = {
718 .name = name,
719 .icvbits = icv_len,
722 return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
723 probe);
725 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
727 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
729 if (idx >= aalg_entries())
730 return NULL;
732 return &aalg_list[idx];
734 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
736 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
738 if (idx >= ealg_entries())
739 return NULL;
741 return &ealg_list[idx];
743 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
746 * Probe for the availability of crypto algorithms, and set the available
747 * flag for any algorithms found on the system. This is typically called by
748 * pfkey during userspace SA add, update or register.
750 void xfrm_probe_algs(void)
752 int i, status;
754 BUG_ON(in_softirq());
756 for (i = 0; i < aalg_entries(); i++) {
757 status = crypto_has_hash(aalg_list[i].name, 0,
758 CRYPTO_ALG_ASYNC);
759 if (aalg_list[i].available != status)
760 aalg_list[i].available = status;
763 for (i = 0; i < ealg_entries(); i++) {
764 status = crypto_has_ablkcipher(ealg_list[i].name, 0, 0);
765 if (ealg_list[i].available != status)
766 ealg_list[i].available = status;
769 for (i = 0; i < calg_entries(); i++) {
770 status = crypto_has_comp(calg_list[i].name, 0,
771 CRYPTO_ALG_ASYNC);
772 if (calg_list[i].available != status)
773 calg_list[i].available = status;
776 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
778 int xfrm_count_pfkey_auth_supported(void)
780 int i, n;
782 for (i = 0, n = 0; i < aalg_entries(); i++)
783 if (aalg_list[i].available && aalg_list[i].pfkey_supported)
784 n++;
785 return n;
787 EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
789 int xfrm_count_pfkey_enc_supported(void)
791 int i, n;
793 for (i = 0, n = 0; i < ealg_entries(); i++)
794 if (ealg_list[i].available && ealg_list[i].pfkey_supported)
795 n++;
796 return n;
798 EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
800 MODULE_LICENSE("GPL");