[deliverable/linux.git] / net / xfrm / xfrm_algo.c

/*
 * xfrm algorithm interface
 *
 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pfkeyv2.h>
#include <linux/crypto.h>
#include <linux/scatterlist.h>
#include <net/xfrm.h>
#if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
#include <net/ah.h>
#endif
#if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
#include <net/esp.h>
#endif
#include <asm/scatterlist.h>

/*
 * Algorithms supported by IPsec.  These entries contain properties which
 * are used in key negotiation and xfrm processing, and are used to verify
 * that instantiated crypto transforms have correct parameters for IPsec
 * purposes.
 */
static struct xfrm_algo_desc aalg_list[] = {
{
	.name = "hmac(digest_null)",
	.compat = "digest_null",

	.uinfo = {
		.auth = {
			.icv_truncbits = 0,
			.icv_fullbits = 0,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_AALG_NULL,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 0,
		.sadb_alg_maxbits = 0
	}
},
{
	.name = "hmac(md5)",
	.compat = "md5",

	.uinfo = {
		.auth = {
			.icv_truncbits = 96,
			.icv_fullbits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_AALG_MD5HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 128
	}
},
{
	.name = "hmac(sha1)",
	.compat = "sha1",

	.uinfo = {
		.auth = {
			.icv_truncbits = 96,
			.icv_fullbits = 160,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_AALG_SHA1HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 160,
		.sadb_alg_maxbits = 160
	}
},
{
	.name = "hmac(sha256)",
	.compat = "sha256",

	.uinfo = {
		.auth = {
			.icv_truncbits = 96,
			.icv_fullbits = 256,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 256,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "hmac(ripemd160)",
	.compat = "ripemd160",

	.uinfo = {
		.auth = {
			.icv_truncbits = 96,
			.icv_fullbits = 160,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 160,
		.sadb_alg_maxbits = 160
	}
},
{
	.name = "xcbc(aes)",

	.uinfo = {
		.auth = {
			.icv_truncbits = 96,
			.icv_fullbits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 128
	}
},
};

static struct xfrm_algo_desc ealg_list[] = {
{
	.name = "ecb(cipher_null)",
	.compat = "cipher_null",

	.uinfo = {
		.encr = {
			.blockbits = 8,
			.defkeybits = 0,
		}
	},

	.desc = {
		.sadb_alg_id =	SADB_EALG_NULL,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 0,
		.sadb_alg_maxbits = 0
	}
},
{
	.name = "cbc(des)",
	.compat = "des",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 64,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_EALG_DESCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 64,
		.sadb_alg_maxbits = 64
	}
},
{
	.name = "cbc(des3_ede)",
	.compat = "des3_ede",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 192,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_EALG_3DESCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 192,
		.sadb_alg_maxbits = 192
	}
},
{
	.name = "cbc(cast128)",
	.compat = "cast128",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_CASTCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 40,
		.sadb_alg_maxbits = 128
	}
},
{
	.name = "cbc(blowfish)",
	.compat = "blowfish",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 40,
		.sadb_alg_maxbits = 448
	}
},
{
	.name = "cbc(aes)",
	.compat = "aes",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AESCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "cbc(serpent)",
	.compat = "serpent",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_SERPENTCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256,
	}
},
{
	.name = "cbc(camellia)",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "cbc(twofish)",
	.compat = "twofish",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
};

static struct xfrm_algo_desc calg_list[] = {
{
	.name = "deflate",
	.uinfo = {
		.comp = {
			.threshold = 90,
		}
	},
	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
},
{
	.name = "lzs",
	.uinfo = {
		.comp = {
			.threshold = 90,
		}
	},
	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
},
{
	.name = "lzjh",
	.uinfo = {
		.comp = {
			.threshold = 50,
		}
	},
	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
},
};

static inline int aalg_entries(void)
{
	return ARRAY_SIZE(aalg_list);
}

static inline int ealg_entries(void)
{
	return ARRAY_SIZE(ealg_list);
}

static inline int calg_entries(void)
{
	return ARRAY_SIZE(calg_list);
}

struct xfrm_algo_list {
	struct xfrm_algo_desc *algs;
	int entries;
	u32 type;
	u32 mask;
};

static const struct xfrm_algo_list xfrm_aalg_list = {
	.algs = aalg_list,
	.entries = ARRAY_SIZE(aalg_list),
	.type = CRYPTO_ALG_TYPE_HASH,
	.mask = CRYPTO_ALG_TYPE_HASH_MASK | CRYPTO_ALG_ASYNC,
};

static const struct xfrm_algo_list xfrm_ealg_list = {
	.algs = ealg_list,
	.entries = ARRAY_SIZE(ealg_list),
	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
	.mask = CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC,
};

static const struct xfrm_algo_list xfrm_calg_list = {
	.algs = calg_list,
	.entries = ARRAY_SIZE(calg_list),
	.type = CRYPTO_ALG_TYPE_COMPRESS,
	.mask = CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC,
};

static struct xfrm_algo_desc *xfrm_find_algo(
	const struct xfrm_algo_list *algo_list,
	int match(const struct xfrm_algo_desc *entry, const void *data),
	const void *data, int probe)
{
	struct xfrm_algo_desc *list = algo_list->algs;
	int i, status;

	for (i = 0; i < algo_list->entries; i++) {
		if (!match(list + i, data))
			continue;

		if (list[i].available)
			return &list[i];

		if (!probe)
			break;

		status = crypto_has_alg(list[i].name, algo_list->type,
					algo_list->mask);
		if (!status)
			break;

		list[i].available = status;
		return &list[i];
	}
	return NULL;
}

static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
			     const void *data)
{
	return entry->desc.sadb_alg_id == (unsigned long)data;
}

struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
{
	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
			      (void *)(unsigned long)alg_id, 1);
}
EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);

struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
{
	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
			      (void *)(unsigned long)alg_id, 1);
}
EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);

struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
{
	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
			      (void *)(unsigned long)alg_id, 1);
}
EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);

static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
			       const void *data)
{
	const char *name = data;

	return name && (!strcmp(name, entry->name) ||
			(entry->compat && !strcmp(name, entry->compat)));
}

struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe)
{
	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
			      probe);
}
EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);

struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe)
{
	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
			      probe);
}
EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);

struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe)
{
	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
			      probe);
}
EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);

struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
{
	if (idx >= aalg_entries())
		return NULL;

	return &aalg_list[idx];
}
EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);

struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
{
	if (idx >= ealg_entries())
		return NULL;

	return &ealg_list[idx];
}
EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);

/*
 * Probe for the availability of crypto algorithms, and set the available
 * flag for any algorithms found on the system.  This is typically called by
 * pfkey during userspace SA add, update or register.
 */
void xfrm_probe_algs(void)
{
#ifdef CONFIG_CRYPTO
	int i, status;

	BUG_ON(in_softirq());

	for (i = 0; i < aalg_entries(); i++) {
		status = crypto_has_hash(aalg_list[i].name, 0,
					 CRYPTO_ALG_ASYNC);
		if (aalg_list[i].available != status)
			aalg_list[i].available = status;
	}

	for (i = 0; i < ealg_entries(); i++) {
		status = crypto_has_blkcipher(ealg_list[i].name, 0,
					      CRYPTO_ALG_ASYNC);
		if (ealg_list[i].available != status)
			ealg_list[i].available = status;
	}

	for (i = 0; i < calg_entries(); i++) {
		status = crypto_has_comp(calg_list[i].name, 0,
					 CRYPTO_ALG_ASYNC);
		if (calg_list[i].available != status)
			calg_list[i].available = status;
	}
#endif
}
EXPORT_SYMBOL_GPL(xfrm_probe_algs);

int xfrm_count_auth_supported(void)
{
	int i, n;

	for (i = 0, n = 0; i < aalg_entries(); i++)
		if (aalg_list[i].available)
			n++;
	return n;
}
EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);

int xfrm_count_enc_supported(void)
{
	int i, n;

	for (i = 0, n = 0; i < ealg_entries(); i++)
		if (ealg_list[i].available)
			n++;
	return n;
}
EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);

/* Move to common area: it is shared with AH. */

int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
		 int offset, int len, icv_update_fn_t icv_update)
{
	int start = skb_headlen(skb);
	int i, copy = start - offset;
	int err;
	struct scatterlist sg;

	/* Checksum header. */
	if (copy > 0) {
		if (copy > len)
			copy = len;

		sg_set_page(&sg, virt_to_page(skb->data + offset));
		sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
		sg.length = copy;

		err = icv_update(desc, &sg, copy);
		if (unlikely(err))
			return err;

		if ((len -= copy) == 0)
			return 0;
		offset += copy;
	}

	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
		int end;

		BUG_TRAP(start <= offset + len);

		end = start + skb_shinfo(skb)->frags[i].size;
		if ((copy = end - offset) > 0) {
			skb_frag_t *frag = &skb_shinfo(skb)->frags[i];

			if (copy > len)
				copy = len;

			sg_set_page(&sg, frag->page);
			sg.offset = frag->page_offset + offset-start;
			sg.length = copy;

			err = icv_update(desc, &sg, copy);
			if (unlikely(err))
				return err;

			if (!(len -= copy))
				return 0;
			offset += copy;
		}
		start = end;
	}

	if (skb_shinfo(skb)->frag_list) {
		struct sk_buff *list = skb_shinfo(skb)->frag_list;

		for (; list; list = list->next) {
			int end;

			BUG_TRAP(start <= offset + len);

			end = start + list->len;
			if ((copy = end - offset) > 0) {
				if (copy > len)
					copy = len;
				err = skb_icv_walk(list, desc, offset-start,
						   copy, icv_update);
				if (unlikely(err))
					return err;
				if ((len -= copy) == 0)
					return 0;
				offset += copy;
			}
			start = end;
		}
	}
	BUG_ON(len);
	return 0;
}
EXPORT_SYMBOL_GPL(skb_icv_walk);

#if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)

void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
{
	if (tail != skb) {
		skb->data_len += len;
		skb->len += len;
	}
	return skb_put(tail, len);
}
EXPORT_SYMBOL_GPL(pskb_put);
#endif
Commit	Line	Data
a716c119	1	/*
1da177e4 LT	2	* xfrm algorithm interface
	3	*
	4	* Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
	5	*
	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
a716c119	8	* Software Foundation; either version 2 of the License, or (at your option)
1da177e4 LT	9	* any later version.
	10	*/
	11
1da177e4 LT	12	#include <linux/module.h>
	13	#include <linux/kernel.h>
	14	#include <linux/pfkeyv2.h>
	15	#include <linux/crypto.h>
b3b724f4	16	#include <linux/scatterlist.h>
1da177e4 LT	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
	24	#include <asm/scatterlist.h>
	25
	26	/*
	27	* Algorithms supported by IPsec. These entries contain properties which
	28	* are used in key negotiation and xfrm processing, and are used to verify
	29	* that instantiated crypto transforms have correct parameters for IPsec
	30	* purposes.
	31	*/
	32	static struct xfrm_algo_desc aalg_list[] = {
	33	{
07d4ee58 HX	34	.name = "hmac(digest_null)",
07d4ee58 HX	35	.compat = "digest_null",
a716c119	36
1da177e4 LT	37	.uinfo = {
	38	.auth = {
	39	.icv_truncbits = 0,
	40	.icv_fullbits = 0,
	41	}
	42	},
a716c119	43
1da177e4 LT	44	.desc = {
	45	.sadb_alg_id = SADB_X_AALG_NULL,
	46	.sadb_alg_ivlen = 0,
	47	.sadb_alg_minbits = 0,
	48	.sadb_alg_maxbits = 0
	49	}
	50	},
	51	{
07d4ee58 HX	52	.name = "hmac(md5)",
07d4ee58 HX	53	.compat = "md5",
1da177e4 LT	54
	55	.uinfo = {
	56	.auth = {
	57	.icv_truncbits = 96,
	58	.icv_fullbits = 128,
	59	}
	60	},
a716c119	61
1da177e4 LT	62	.desc = {
	63	.sadb_alg_id = SADB_AALG_MD5HMAC,
	64	.sadb_alg_ivlen = 0,
	65	.sadb_alg_minbits = 128,
	66	.sadb_alg_maxbits = 128
	67	}
	68	},
	69	{
07d4ee58 HX	70	.name = "hmac(sha1)",
07d4ee58 HX	71	.compat = "sha1",
1da177e4 LT	72
	73	.uinfo = {
	74	.auth = {
	75	.icv_truncbits = 96,
	76	.icv_fullbits = 160,
	77	}
	78	},
	79
	80	.desc = {
	81	.sadb_alg_id = SADB_AALG_SHA1HMAC,
	82	.sadb_alg_ivlen = 0,
	83	.sadb_alg_minbits = 160,
	84	.sadb_alg_maxbits = 160
	85	}
	86	},
	87	{
07d4ee58 HX	88	.name = "hmac(sha256)",
07d4ee58 HX	89	.compat = "sha256",
1da177e4 LT	90
	91	.uinfo = {
	92	.auth = {
	93	.icv_truncbits = 96,
	94	.icv_fullbits = 256,
	95	}
	96	},
	97
	98	.desc = {
	99	.sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
	100	.sadb_alg_ivlen = 0,
	101	.sadb_alg_minbits = 256,
	102	.sadb_alg_maxbits = 256
	103	}
	104	},
	105	{
07d4ee58 HX	106	.name = "hmac(ripemd160)",
07d4ee58 HX	107	.compat = "ripemd160",
1da177e4 LT	108
	109	.uinfo = {
	110	.auth = {
	111	.icv_truncbits = 96,
	112	.icv_fullbits = 160,
	113	}
	114	},
	115
	116	.desc = {
	117	.sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
	118	.sadb_alg_ivlen = 0,
	119	.sadb_alg_minbits = 160,
	120	.sadb_alg_maxbits = 160
	121	}
	122	},
7cf4c1a5 KM	123	{
	124	.name = "xcbc(aes)",
	125
	126	.uinfo = {
	127	.auth = {
	128	.icv_truncbits = 96,
	129	.icv_fullbits = 128,
	130	}
	131	},
	132
	133	.desc = {
	134	.sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
	135	.sadb_alg_ivlen = 0,
	136	.sadb_alg_minbits = 128,
	137	.sadb_alg_maxbits = 128
	138	}
	139	},
1da177e4 LT	140	};
	141
	142	static struct xfrm_algo_desc ealg_list[] = {
	143	{
6b7326c8 HX	144	.name = "ecb(cipher_null)",
6b7326c8 HX	145	.compat = "cipher_null",
a716c119	146
1da177e4 LT	147	.uinfo = {
	148	.encr = {
	149	.blockbits = 8,
	150	.defkeybits = 0,
	151	}
	152	},
a716c119	153
1da177e4 LT	154	.desc = {
	155	.sadb_alg_id = SADB_EALG_NULL,
	156	.sadb_alg_ivlen = 0,
	157	.sadb_alg_minbits = 0,
	158	.sadb_alg_maxbits = 0
	159	}
	160	},
	161	{
6b7326c8 HX	162	.name = "cbc(des)",
6b7326c8 HX	163	.compat = "des",
1da177e4 LT	164
	165	.uinfo = {
	166	.encr = {
	167	.blockbits = 64,
	168	.defkeybits = 64,
	169	}
	170	},
	171
	172	.desc = {
	173	.sadb_alg_id = SADB_EALG_DESCBC,
	174	.sadb_alg_ivlen = 8,
	175	.sadb_alg_minbits = 64,
	176	.sadb_alg_maxbits = 64
	177	}
	178	},
	179	{
6b7326c8 HX	180	.name = "cbc(des3_ede)",
6b7326c8 HX	181	.compat = "des3_ede",
1da177e4 LT	182
	183	.uinfo = {
	184	.encr = {
	185	.blockbits = 64,
	186	.defkeybits = 192,
	187	}
	188	},
	189
	190	.desc = {
	191	.sadb_alg_id = SADB_EALG_3DESCBC,
	192	.sadb_alg_ivlen = 8,
	193	.sadb_alg_minbits = 192,
	194	.sadb_alg_maxbits = 192
	195	}
	196	},
	197	{
6b7326c8 HX	198	.name = "cbc(cast128)",
6b7326c8 HX	199	.compat = "cast128",
1da177e4 LT	200
	201	.uinfo = {
	202	.encr = {
	203	.blockbits = 64,
	204	.defkeybits = 128,
	205	}
	206	},
	207
	208	.desc = {
	209	.sadb_alg_id = SADB_X_EALG_CASTCBC,
	210	.sadb_alg_ivlen = 8,
	211	.sadb_alg_minbits = 40,
	212	.sadb_alg_maxbits = 128
	213	}
	214	},
	215	{
6b7326c8 HX	216	.name = "cbc(blowfish)",
6b7326c8 HX	217	.compat = "blowfish",
1da177e4 LT	218
	219	.uinfo = {
	220	.encr = {
	221	.blockbits = 64,
	222	.defkeybits = 128,
	223	}
	224	},
	225
	226	.desc = {
	227	.sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
	228	.sadb_alg_ivlen = 8,
	229	.sadb_alg_minbits = 40,
	230	.sadb_alg_maxbits = 448
	231	}
	232	},
	233	{
6b7326c8 HX	234	.name = "cbc(aes)",
6b7326c8 HX	235	.compat = "aes",
1da177e4 LT	236
	237	.uinfo = {
	238	.encr = {
	239	.blockbits = 128,
	240	.defkeybits = 128,
	241	}
	242	},
	243
	244	.desc = {
	245	.sadb_alg_id = SADB_X_EALG_AESCBC,
	246	.sadb_alg_ivlen = 8,
	247	.sadb_alg_minbits = 128,
	248	.sadb_alg_maxbits = 256
	249	}
	250	},
	251	{
a716c119 YH	252	.name = "cbc(serpent)",
	253	.compat = "serpent",
	254
	255	.uinfo = {
	256	.encr = {
	257	.blockbits = 128,
	258	.defkeybits = 128,
	259	}
	260	},
	261
	262	.desc = {
	263	.sadb_alg_id = SADB_X_EALG_SERPENTCBC,
	264	.sadb_alg_ivlen = 8,
	265	.sadb_alg_minbits = 128,
	266	.sadb_alg_maxbits = 256,
	267	}
1da177e4	268	},
6a0dc8d7 NT	269	{
	270	.name = "cbc(camellia)",
	271
	272	.uinfo = {
	273	.encr = {
	274	.blockbits = 128,
	275	.defkeybits = 128,
	276	}
	277	},
	278
	279	.desc = {
	280	.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
	281	.sadb_alg_ivlen = 8,
	282	.sadb_alg_minbits = 128,
	283	.sadb_alg_maxbits = 256
	284	}
	285	},
1da177e4	286	{
a716c119 YH	287	.name = "cbc(twofish)",
	288	.compat = "twofish",
	289
	290	.uinfo = {
	291	.encr = {
	292	.blockbits = 128,
	293	.defkeybits = 128,
	294	}
	295	},
	296
	297	.desc = {
	298	.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
	299	.sadb_alg_ivlen = 8,
	300	.sadb_alg_minbits = 128,
	301	.sadb_alg_maxbits = 256
	302	}
1da177e4 LT	303	},
	304	};
	305
	306	static struct xfrm_algo_desc calg_list[] = {
	307	{
	308	.name = "deflate",
	309	.uinfo = {
	310	.comp = {
	311	.threshold = 90,
	312	}
	313	},
	314	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
	315	},
	316	{
	317	.name = "lzs",
	318	.uinfo = {
	319	.comp = {
	320	.threshold = 90,
	321	}
	322	},
	323	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
	324	},
	325	{
	326	.name = "lzjh",
	327	.uinfo = {
	328	.comp = {
	329	.threshold = 50,
	330	}
	331	},
	332	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
	333	},
	334	};
	335
	336	static inline int aalg_entries(void)
	337	{
	338	return ARRAY_SIZE(aalg_list);
	339	}
	340
	341	static inline int ealg_entries(void)
	342	{
	343	return ARRAY_SIZE(ealg_list);
	344	}
	345
	346	static inline int calg_entries(void)
	347	{
	348	return ARRAY_SIZE(calg_list);
	349	}
	350
c92b3a2f HX	351	struct xfrm_algo_list {
	352	struct xfrm_algo_desc *algs;
	353	int entries;
	354	u32 type;
	355	u32 mask;
	356	};
1da177e4	357
c92b3a2f HX	358	static const struct xfrm_algo_list xfrm_aalg_list = {
	359	.algs = aalg_list,
	360	.entries = ARRAY_SIZE(aalg_list),
	361	.type = CRYPTO_ALG_TYPE_HASH,
	362	.mask = CRYPTO_ALG_TYPE_HASH_MASK \| CRYPTO_ALG_ASYNC,
	363	};
1da177e4	364
c92b3a2f HX	365	static const struct xfrm_algo_list xfrm_ealg_list = {
	366	.algs = ealg_list,
	367	.entries = ARRAY_SIZE(ealg_list),
	368	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
	369	.mask = CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_ASYNC,
	370	};
1da177e4	371
c92b3a2f HX	372	static const struct xfrm_algo_list xfrm_calg_list = {
	373	.algs = calg_list,
	374	.entries = ARRAY_SIZE(calg_list),
	375	.type = CRYPTO_ALG_TYPE_COMPRESS,
	376	.mask = CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_ASYNC,
	377	};
1da177e4	378
c92b3a2f HX	379	static struct xfrm_algo_desc *xfrm_find_algo(
	380	const struct xfrm_algo_list *algo_list,
	381	int match(const struct xfrm_algo_desc entry, const void data),
	382	const void *data, int probe)
1da177e4	383	{
c92b3a2f	384	struct xfrm_algo_desc *list = algo_list->algs;
1da177e4 LT	385	int i, status;
1da177e4 LT	386
c92b3a2f HX	387	for (i = 0; i < algo_list->entries; i++) {
c92b3a2f HX	388	if (!match(list + i, data))
1da177e4 LT	389	continue;
	390
	391	if (list[i].available)
	392	return &list[i];
	393
	394	if (!probe)
	395	break;
	396
c92b3a2f HX	397	status = crypto_has_alg(list[i].name, algo_list->type,
c92b3a2f HX	398	algo_list->mask);
1da177e4 LT	399	if (!status)
	400	break;
	401
	402	list[i].available = status;
	403	return &list[i];
	404	}
	405	return NULL;
	406	}
	407
c92b3a2f HX	408	static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
	409	const void *data)
	410	{
26b8e51e	411	return entry->desc.sadb_alg_id == (unsigned long)data;
c92b3a2f HX	412	}
	413
	414	struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
	415	{
	416	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
26b8e51e	417	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	418	}
	419	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
	420
	421	struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
	422	{
	423	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
26b8e51e	424	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	425	}
	426	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
	427
	428	struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
	429	{
	430	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
26b8e51e	431	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	432	}
	433	EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
	434
	435	static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
	436	const void *data)
	437	{
	438	const char *name = data;
	439
	440	return name && (!strcmp(name, entry->name) \|\|
	441	(entry->compat && !strcmp(name, entry->compat)));
	442	}
	443
1da177e4 LT	444	struct xfrm_algo_desc xfrm_aalg_get_byname(char name, int probe)
1da177e4 LT	445	{
c92b3a2f HX	446	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
c92b3a2f HX	447	probe);
1da177e4 LT	448	}
	449	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
	450
	451	struct xfrm_algo_desc xfrm_ealg_get_byname(char name, int probe)
	452	{
c92b3a2f HX	453	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
c92b3a2f HX	454	probe);
1da177e4 LT	455	}
	456	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
	457
	458	struct xfrm_algo_desc xfrm_calg_get_byname(char name, int probe)
	459	{
c92b3a2f HX	460	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
c92b3a2f HX	461	probe);
1da177e4 LT	462	}
	463	EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
	464
	465	struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
	466	{
	467	if (idx >= aalg_entries())
	468	return NULL;
	469
	470	return &aalg_list[idx];
	471	}
	472	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
	473
	474	struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
	475	{
	476	if (idx >= ealg_entries())
	477	return NULL;
	478
	479	return &ealg_list[idx];
	480	}
	481	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
	482
	483	/*
	484	* Probe for the availability of crypto algorithms, and set the available
	485	* flag for any algorithms found on the system. This is typically called by
	486	* pfkey during userspace SA add, update or register.
	487	*/
	488	void xfrm_probe_algs(void)
	489	{
	490	#ifdef CONFIG_CRYPTO
	491	int i, status;
a716c119	492
1da177e4 LT	493	BUG_ON(in_softirq());
	494
	495	for (i = 0; i < aalg_entries(); i++) {
e4d5b79c HX	496	status = crypto_has_hash(aalg_list[i].name, 0,
e4d5b79c HX	497	CRYPTO_ALG_ASYNC);
1da177e4 LT	498	if (aalg_list[i].available != status)
	499	aalg_list[i].available = status;
	500	}
a716c119	501
1da177e4	502	for (i = 0; i < ealg_entries(); i++) {
e4d5b79c HX	503	status = crypto_has_blkcipher(ealg_list[i].name, 0,
e4d5b79c HX	504	CRYPTO_ALG_ASYNC);
1da177e4 LT	505	if (ealg_list[i].available != status)
	506	ealg_list[i].available = status;
	507	}
a716c119	508
1da177e4	509	for (i = 0; i < calg_entries(); i++) {
e4d5b79c HX	510	status = crypto_has_comp(calg_list[i].name, 0,
e4d5b79c HX	511	CRYPTO_ALG_ASYNC);
1da177e4 LT	512	if (calg_list[i].available != status)
	513	calg_list[i].available = status;
	514	}
	515	#endif
	516	}
	517	EXPORT_SYMBOL_GPL(xfrm_probe_algs);
	518
	519	int xfrm_count_auth_supported(void)
	520	{
	521	int i, n;
	522
	523	for (i = 0, n = 0; i < aalg_entries(); i++)
	524	if (aalg_list[i].available)
	525	n++;
	526	return n;
	527	}
	528	EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
	529
	530	int xfrm_count_enc_supported(void)
	531	{
	532	int i, n;
	533
	534	for (i = 0, n = 0; i < ealg_entries(); i++)
	535	if (ealg_list[i].available)
	536	n++;
	537	return n;
	538	}
	539	EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
	540
	541	/* Move to common area: it is shared with AH. */
	542
07d4ee58 HX	543	int skb_icv_walk(const struct sk_buff skb, struct hash_desc desc,
07d4ee58 HX	544	int offset, int len, icv_update_fn_t icv_update)
1da177e4	545	{
1a028e50 DM	546	int start = skb_headlen(skb);
1a028e50 DM	547	int i, copy = start - offset;
07d4ee58	548	int err;
1da177e4 LT	549	struct scatterlist sg;
	550
	551	/* Checksum header. */
	552	if (copy > 0) {
	553	if (copy > len)
	554	copy = len;
a716c119	555
fa05f128	556	sg_set_page(&sg, virt_to_page(skb->data + offset));
1da177e4 LT	557	sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
1da177e4 LT	558	sg.length = copy;
a716c119	559
07d4ee58 HX	560	err = icv_update(desc, &sg, copy);
	561	if (unlikely(err))
	562	return err;
a716c119	563
1da177e4	564	if ((len -= copy) == 0)
07d4ee58	565	return 0;
1da177e4 LT	566	offset += copy;
	567	}
	568
	569	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1a028e50	570	int end;
1da177e4	571
1a028e50 DM	572	BUG_TRAP(start <= offset + len);
	573
	574	end = start + skb_shinfo(skb)->frags[i].size;
1da177e4 LT	575	if ((copy = end - offset) > 0) {
	576	skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
	577
	578	if (copy > len)
	579	copy = len;
a716c119	580
fa05f128	581	sg_set_page(&sg, frag->page);
1a028e50	582	sg.offset = frag->page_offset + offset-start;
1da177e4	583	sg.length = copy;
a716c119	584
07d4ee58 HX	585	err = icv_update(desc, &sg, copy);
	586	if (unlikely(err))
	587	return err;
1da177e4 LT	588
1da177e4 LT	589	if (!(len -= copy))
07d4ee58	590	return 0;
1da177e4 LT	591	offset += copy;
1da177e4 LT	592	}
1a028e50	593	start = end;
1da177e4 LT	594	}
	595
	596	if (skb_shinfo(skb)->frag_list) {
	597	struct sk_buff *list = skb_shinfo(skb)->frag_list;
	598
	599	for (; list; list = list->next) {
1a028e50 DM	600	int end;
	601
	602	BUG_TRAP(start <= offset + len);
1da177e4	603
1a028e50	604	end = start + list->len;
1da177e4 LT	605	if ((copy = end - offset) > 0) {
	606	if (copy > len)
	607	copy = len;
1a028e50	608	err = skb_icv_walk(list, desc, offset-start,
07d4ee58 HX	609	copy, icv_update);
	610	if (unlikely(err))
	611	return err;
1da177e4	612	if ((len -= copy) == 0)
07d4ee58	613	return 0;
1da177e4 LT	614	offset += copy;
1da177e4 LT	615	}
1a028e50	616	start = end;
1da177e4 LT	617	}
1da177e4 LT	618	}
09a62660	619	BUG_ON(len);
07d4ee58	620	return 0;
1da177e4 LT	621	}
	622	EXPORT_SYMBOL_GPL(skb_icv_walk);
	623
	624	#if defined(CONFIG_INET_ESP) \|\| defined(CONFIG_INET_ESP_MODULE) \|\| defined(CONFIG_INET6_ESP) \|\| defined(CONFIG_INET6_ESP_MODULE)
	625
1da177e4 LT	626	void pskb_put(struct sk_buff skb, struct sk_buff *tail, int len)
	627	{
	628	if (tail != skb) {
	629	skb->data_len += len;
	630	skb->len += len;
	631	}
	632	return skb_put(tail, len);
	633	}
	634	EXPORT_SYMBOL_GPL(pskb_put);
	635	#endif