mfd: htc-i2cpld depends on GPIOLIB
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / xfrm / xfrm_algo.c
blob8b4d6e3246e50fd07657c39733d19697fd0b68c0
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_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
19 #include <net/ah.h>
20 #endif
21 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
22 #include <net/esp.h>
23 #endif
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
29 * purposes.
31 static struct xfrm_algo_desc aead_list[] = {
33 .name = "rfc4106(gcm(aes))",
35 .uinfo = {
36 .aead = {
37 .icv_truncbits = 64,
41 .desc = {
42 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
43 .sadb_alg_ivlen = 8,
44 .sadb_alg_minbits = 128,
45 .sadb_alg_maxbits = 256
49 .name = "rfc4106(gcm(aes))",
51 .uinfo = {
52 .aead = {
53 .icv_truncbits = 96,
57 .desc = {
58 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
59 .sadb_alg_ivlen = 8,
60 .sadb_alg_minbits = 128,
61 .sadb_alg_maxbits = 256
65 .name = "rfc4106(gcm(aes))",
67 .uinfo = {
68 .aead = {
69 .icv_truncbits = 128,
73 .desc = {
74 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
75 .sadb_alg_ivlen = 8,
76 .sadb_alg_minbits = 128,
77 .sadb_alg_maxbits = 256
81 .name = "rfc4309(ccm(aes))",
83 .uinfo = {
84 .aead = {
85 .icv_truncbits = 64,
89 .desc = {
90 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
91 .sadb_alg_ivlen = 8,
92 .sadb_alg_minbits = 128,
93 .sadb_alg_maxbits = 256
97 .name = "rfc4309(ccm(aes))",
99 .uinfo = {
100 .aead = {
101 .icv_truncbits = 96,
105 .desc = {
106 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
107 .sadb_alg_ivlen = 8,
108 .sadb_alg_minbits = 128,
109 .sadb_alg_maxbits = 256
113 .name = "rfc4309(ccm(aes))",
115 .uinfo = {
116 .aead = {
117 .icv_truncbits = 128,
121 .desc = {
122 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
123 .sadb_alg_ivlen = 8,
124 .sadb_alg_minbits = 128,
125 .sadb_alg_maxbits = 256
129 .name = "rfc4543(gcm(aes))",
131 .uinfo = {
132 .aead = {
133 .icv_truncbits = 128,
137 .desc = {
138 .sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
139 .sadb_alg_ivlen = 8,
140 .sadb_alg_minbits = 128,
141 .sadb_alg_maxbits = 256
146 static struct xfrm_algo_desc aalg_list[] = {
148 .name = "digest_null",
150 .uinfo = {
151 .auth = {
152 .icv_truncbits = 0,
153 .icv_fullbits = 0,
157 .desc = {
158 .sadb_alg_id = SADB_X_AALG_NULL,
159 .sadb_alg_ivlen = 0,
160 .sadb_alg_minbits = 0,
161 .sadb_alg_maxbits = 0
165 .name = "hmac(md5)",
166 .compat = "md5",
168 .uinfo = {
169 .auth = {
170 .icv_truncbits = 96,
171 .icv_fullbits = 128,
175 .desc = {
176 .sadb_alg_id = SADB_AALG_MD5HMAC,
177 .sadb_alg_ivlen = 0,
178 .sadb_alg_minbits = 128,
179 .sadb_alg_maxbits = 128
183 .name = "hmac(sha1)",
184 .compat = "sha1",
186 .uinfo = {
187 .auth = {
188 .icv_truncbits = 96,
189 .icv_fullbits = 160,
193 .desc = {
194 .sadb_alg_id = SADB_AALG_SHA1HMAC,
195 .sadb_alg_ivlen = 0,
196 .sadb_alg_minbits = 160,
197 .sadb_alg_maxbits = 160
201 .name = "hmac(sha256)",
202 .compat = "sha256",
204 .uinfo = {
205 .auth = {
206 .icv_truncbits = 96,
207 .icv_fullbits = 256,
211 .desc = {
212 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
213 .sadb_alg_ivlen = 0,
214 .sadb_alg_minbits = 256,
215 .sadb_alg_maxbits = 256
219 .name = "hmac(sha384)",
221 .uinfo = {
222 .auth = {
223 .icv_truncbits = 192,
224 .icv_fullbits = 384,
228 .desc = {
229 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
230 .sadb_alg_ivlen = 0,
231 .sadb_alg_minbits = 384,
232 .sadb_alg_maxbits = 384
236 .name = "hmac(sha512)",
238 .uinfo = {
239 .auth = {
240 .icv_truncbits = 256,
241 .icv_fullbits = 512,
245 .desc = {
246 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
247 .sadb_alg_ivlen = 0,
248 .sadb_alg_minbits = 512,
249 .sadb_alg_maxbits = 512
253 .name = "hmac(rmd160)",
254 .compat = "rmd160",
256 .uinfo = {
257 .auth = {
258 .icv_truncbits = 96,
259 .icv_fullbits = 160,
263 .desc = {
264 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
265 .sadb_alg_ivlen = 0,
266 .sadb_alg_minbits = 160,
267 .sadb_alg_maxbits = 160
271 .name = "xcbc(aes)",
273 .uinfo = {
274 .auth = {
275 .icv_truncbits = 96,
276 .icv_fullbits = 128,
280 .desc = {
281 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
282 .sadb_alg_ivlen = 0,
283 .sadb_alg_minbits = 128,
284 .sadb_alg_maxbits = 128
289 static struct xfrm_algo_desc ealg_list[] = {
291 .name = "ecb(cipher_null)",
292 .compat = "cipher_null",
294 .uinfo = {
295 .encr = {
296 .blockbits = 8,
297 .defkeybits = 0,
301 .desc = {
302 .sadb_alg_id = SADB_EALG_NULL,
303 .sadb_alg_ivlen = 0,
304 .sadb_alg_minbits = 0,
305 .sadb_alg_maxbits = 0
309 .name = "cbc(des)",
310 .compat = "des",
312 .uinfo = {
313 .encr = {
314 .blockbits = 64,
315 .defkeybits = 64,
319 .desc = {
320 .sadb_alg_id = SADB_EALG_DESCBC,
321 .sadb_alg_ivlen = 8,
322 .sadb_alg_minbits = 64,
323 .sadb_alg_maxbits = 64
327 .name = "cbc(des3_ede)",
328 .compat = "des3_ede",
330 .uinfo = {
331 .encr = {
332 .blockbits = 64,
333 .defkeybits = 192,
337 .desc = {
338 .sadb_alg_id = SADB_EALG_3DESCBC,
339 .sadb_alg_ivlen = 8,
340 .sadb_alg_minbits = 192,
341 .sadb_alg_maxbits = 192
345 .name = "cbc(cast5)",
346 .compat = "cast5",
348 .uinfo = {
349 .encr = {
350 .blockbits = 64,
351 .defkeybits = 128,
355 .desc = {
356 .sadb_alg_id = SADB_X_EALG_CASTCBC,
357 .sadb_alg_ivlen = 8,
358 .sadb_alg_minbits = 40,
359 .sadb_alg_maxbits = 128
363 .name = "cbc(blowfish)",
364 .compat = "blowfish",
366 .uinfo = {
367 .encr = {
368 .blockbits = 64,
369 .defkeybits = 128,
373 .desc = {
374 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
375 .sadb_alg_ivlen = 8,
376 .sadb_alg_minbits = 40,
377 .sadb_alg_maxbits = 448
381 .name = "cbc(aes)",
382 .compat = "aes",
384 .uinfo = {
385 .encr = {
386 .blockbits = 128,
387 .defkeybits = 128,
391 .desc = {
392 .sadb_alg_id = SADB_X_EALG_AESCBC,
393 .sadb_alg_ivlen = 8,
394 .sadb_alg_minbits = 128,
395 .sadb_alg_maxbits = 256
399 .name = "cbc(serpent)",
400 .compat = "serpent",
402 .uinfo = {
403 .encr = {
404 .blockbits = 128,
405 .defkeybits = 128,
409 .desc = {
410 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
411 .sadb_alg_ivlen = 8,
412 .sadb_alg_minbits = 128,
413 .sadb_alg_maxbits = 256,
417 .name = "cbc(camellia)",
418 .compat = "camellia",
420 .uinfo = {
421 .encr = {
422 .blockbits = 128,
423 .defkeybits = 128,
427 .desc = {
428 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
429 .sadb_alg_ivlen = 8,
430 .sadb_alg_minbits = 128,
431 .sadb_alg_maxbits = 256
435 .name = "cbc(twofish)",
436 .compat = "twofish",
438 .uinfo = {
439 .encr = {
440 .blockbits = 128,
441 .defkeybits = 128,
445 .desc = {
446 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
447 .sadb_alg_ivlen = 8,
448 .sadb_alg_minbits = 128,
449 .sadb_alg_maxbits = 256
453 .name = "rfc3686(ctr(aes))",
455 .uinfo = {
456 .encr = {
457 .blockbits = 128,
458 .defkeybits = 160, /* 128-bit key + 32-bit nonce */
462 .desc = {
463 .sadb_alg_id = SADB_X_EALG_AESCTR,
464 .sadb_alg_ivlen = 8,
465 .sadb_alg_minbits = 128,
466 .sadb_alg_maxbits = 256
471 static struct xfrm_algo_desc calg_list[] = {
473 .name = "deflate",
474 .uinfo = {
475 .comp = {
476 .threshold = 90,
479 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
482 .name = "lzs",
483 .uinfo = {
484 .comp = {
485 .threshold = 90,
488 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
491 .name = "lzjh",
492 .uinfo = {
493 .comp = {
494 .threshold = 50,
497 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
501 static inline int aead_entries(void)
503 return ARRAY_SIZE(aead_list);
506 static inline int aalg_entries(void)
508 return ARRAY_SIZE(aalg_list);
511 static inline int ealg_entries(void)
513 return ARRAY_SIZE(ealg_list);
516 static inline int calg_entries(void)
518 return ARRAY_SIZE(calg_list);
521 struct xfrm_algo_list {
522 struct xfrm_algo_desc *algs;
523 int entries;
524 u32 type;
525 u32 mask;
528 static const struct xfrm_algo_list xfrm_aead_list = {
529 .algs = aead_list,
530 .entries = ARRAY_SIZE(aead_list),
531 .type = CRYPTO_ALG_TYPE_AEAD,
532 .mask = CRYPTO_ALG_TYPE_MASK,
535 static const struct xfrm_algo_list xfrm_aalg_list = {
536 .algs = aalg_list,
537 .entries = ARRAY_SIZE(aalg_list),
538 .type = CRYPTO_ALG_TYPE_HASH,
539 .mask = CRYPTO_ALG_TYPE_HASH_MASK,
542 static const struct xfrm_algo_list xfrm_ealg_list = {
543 .algs = ealg_list,
544 .entries = ARRAY_SIZE(ealg_list),
545 .type = CRYPTO_ALG_TYPE_BLKCIPHER,
546 .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
549 static const struct xfrm_algo_list xfrm_calg_list = {
550 .algs = calg_list,
551 .entries = ARRAY_SIZE(calg_list),
552 .type = CRYPTO_ALG_TYPE_COMPRESS,
553 .mask = CRYPTO_ALG_TYPE_MASK,
556 static struct xfrm_algo_desc *xfrm_find_algo(
557 const struct xfrm_algo_list *algo_list,
558 int match(const struct xfrm_algo_desc *entry, const void *data),
559 const void *data, int probe)
561 struct xfrm_algo_desc *list = algo_list->algs;
562 int i, status;
564 for (i = 0; i < algo_list->entries; i++) {
565 if (!match(list + i, data))
566 continue;
568 if (list[i].available)
569 return &list[i];
571 if (!probe)
572 break;
574 status = crypto_has_alg(list[i].name, algo_list->type,
575 algo_list->mask);
576 if (!status)
577 break;
579 list[i].available = status;
580 return &list[i];
582 return NULL;
585 static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
586 const void *data)
588 return entry->desc.sadb_alg_id == (unsigned long)data;
591 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
593 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
594 (void *)(unsigned long)alg_id, 1);
596 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
598 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
600 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
601 (void *)(unsigned long)alg_id, 1);
603 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
605 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
607 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
608 (void *)(unsigned long)alg_id, 1);
610 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
612 static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
613 const void *data)
615 const char *name = data;
617 return name && (!strcmp(name, entry->name) ||
618 (entry->compat && !strcmp(name, entry->compat)));
621 struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe)
623 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
624 probe);
626 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
628 struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe)
630 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
631 probe);
633 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
635 struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe)
637 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
638 probe);
640 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
642 struct xfrm_aead_name {
643 const char *name;
644 int icvbits;
647 static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
648 const void *data)
650 const struct xfrm_aead_name *aead = data;
651 const char *name = aead->name;
653 return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
654 !strcmp(name, entry->name);
657 struct xfrm_algo_desc *xfrm_aead_get_byname(char *name, int icv_len, int probe)
659 struct xfrm_aead_name data = {
660 .name = name,
661 .icvbits = icv_len,
664 return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
665 probe);
667 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
669 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
671 if (idx >= aalg_entries())
672 return NULL;
674 return &aalg_list[idx];
676 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
678 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
680 if (idx >= ealg_entries())
681 return NULL;
683 return &ealg_list[idx];
685 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
688 * Probe for the availability of crypto algorithms, and set the available
689 * flag for any algorithms found on the system. This is typically called by
690 * pfkey during userspace SA add, update or register.
692 void xfrm_probe_algs(void)
694 int i, status;
696 BUG_ON(in_softirq());
698 for (i = 0; i < aalg_entries(); i++) {
699 status = crypto_has_hash(aalg_list[i].name, 0,
700 CRYPTO_ALG_ASYNC);
701 if (aalg_list[i].available != status)
702 aalg_list[i].available = status;
705 for (i = 0; i < ealg_entries(); i++) {
706 status = crypto_has_blkcipher(ealg_list[i].name, 0,
707 CRYPTO_ALG_ASYNC);
708 if (ealg_list[i].available != status)
709 ealg_list[i].available = status;
712 for (i = 0; i < calg_entries(); i++) {
713 status = crypto_has_comp(calg_list[i].name, 0,
714 CRYPTO_ALG_ASYNC);
715 if (calg_list[i].available != status)
716 calg_list[i].available = status;
719 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
721 int xfrm_count_auth_supported(void)
723 int i, n;
725 for (i = 0, n = 0; i < aalg_entries(); i++)
726 if (aalg_list[i].available)
727 n++;
728 return n;
730 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
732 int xfrm_count_enc_supported(void)
734 int i, n;
736 for (i = 0, n = 0; i < ealg_entries(); i++)
737 if (ealg_list[i].available)
738 n++;
739 return n;
741 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
743 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
745 void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
747 if (tail != skb) {
748 skb->data_len += len;
749 skb->len += len;
751 return skb_put(tail, len);
753 EXPORT_SYMBOL_GPL(pskb_put);
754 #endif