[net-next-2.6.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

/*
 * 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 aead_list[] = {
{
	.name = "rfc4106(gcm(aes))",

	.uinfo = {
		.aead = {
			.icv_truncbits = 64,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4106(gcm(aes))",

	.uinfo = {
		.aead = {
			.icv_truncbits = 96,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4106(gcm(aes))",

	.uinfo = {
		.aead = {
			.icv_truncbits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4309(ccm(aes))",

	.uinfo = {
		.aead = {
			.icv_truncbits = 64,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4309(ccm(aes))",

	.uinfo = {
		.aead = {
			.icv_truncbits = 96,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4309(ccm(aes))",

	.uinfo = {
		.aead = {
			.icv_truncbits = 128,
		}
	},

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

static struct xfrm_algo_desc aalg_list[] = {
{
	.name = "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(rmd160)",
	.compat = "rmd160",

	.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(cast5)",
	.compat = "cast5",

	.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)",
	.compat = "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
	}
},
{
	.name = "rfc3686(ctr(aes))",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 160, /* 128-bit key + 32-bit nonce */
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AESCTR,
		.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 aead_entries(void)
{
	return ARRAY_SIZE(aead_list);
}

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_aead_list = {
	.algs = aead_list,
	.entries = ARRAY_SIZE(aead_list),
	.type = CRYPTO_ALG_TYPE_AEAD,
	.mask = CRYPTO_ALG_TYPE_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,
};

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_BLKCIPHER_MASK,
};

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,
};

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_aead_name {
	const char *name;
	int icvbits;
};

static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
				const void *data)
{
	const struct xfrm_aead_name *aead = data;
	const char *name = aead->name;

	return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
	       !strcmp(name, entry->name);
}

struct xfrm_algo_desc *xfrm_aead_get_byname(char *name, int icv_len, int probe)
{
	struct xfrm_aead_name data = {
		.name = name,
		.icvbits = icv_len,
	};

	return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
			      probe);
}
EXPORT_SYMBOL_GPL(xfrm_aead_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)
{
	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;
	}
}
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;
	struct sk_buff *frag_iter;
	struct scatterlist sg;
	int err;

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

		sg_init_one(&sg, skb->data + offset, 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;

		WARN_ON(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_init_table(&sg, 1);
			sg_set_page(&sg, frag->page, copy,
				    frag->page_offset + offset-start);

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

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

	skb_walk_frags(skb, frag_iter) {
		int end;

		WARN_ON(start > offset + len);

		end = start + frag_iter->len;
		if ((copy = end - offset) > 0) {
			if (copy > len)
				copy = len;
			err = skb_icv_walk(frag_iter, 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
1da177e4 LT	24
	25	/*
	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.
	30	*/
1a6509d9 HX	31	static struct xfrm_algo_desc aead_list[] = {
	32	{
	33	.name = "rfc4106(gcm(aes))",
	34
	35	.uinfo = {
	36	.aead = {
	37	.icv_truncbits = 64,
	38	}
	39	},
	40
	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
	46	}
	47	},
	48	{
	49	.name = "rfc4106(gcm(aes))",
	50
	51	.uinfo = {
	52	.aead = {
	53	.icv_truncbits = 96,
	54	}
	55	},
	56
	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
	62	}
	63	},
	64	{
	65	.name = "rfc4106(gcm(aes))",
	66
	67	.uinfo = {
	68	.aead = {
	69	.icv_truncbits = 128,
	70	}
	71	},
	72
	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
	78	}
	79	},
	80	{
	81	.name = "rfc4309(ccm(aes))",
	82
	83	.uinfo = {
	84	.aead = {
	85	.icv_truncbits = 64,
	86	}
	87	},
	88
	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
	94	}
95	},
96	{
97	.name = "rfc4309(ccm(aes))",
98
99	.uinfo = {
100	.aead = {
101	.icv_truncbits = 96,
102	}
103	},
104
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
110	}
111	},
112	{
113	.name = "rfc4309(ccm(aes))",
114
115	.uinfo = {
116	.aead = {
117	.icv_truncbits = 128,
118	}
119	},
120
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
126	}
127	},
128	};
129
1da177e4 LT	130	static struct xfrm_algo_desc aalg_list[] = {
1da177e4 LT	131	{
01a2202c	132	.name = "digest_null",
a716c119	133
1da177e4 LT	134	.uinfo = {
	135	.auth = {
	136	.icv_truncbits = 0,
	137	.icv_fullbits = 0,
	138	}
	139	},
a716c119	140
1da177e4 LT	141	.desc = {
	142	.sadb_alg_id = SADB_X_AALG_NULL,
	143	.sadb_alg_ivlen = 0,
	144	.sadb_alg_minbits = 0,
	145	.sadb_alg_maxbits = 0
	146	}
	147	},
	148	{
07d4ee58 HX	149	.name = "hmac(md5)",
07d4ee58 HX	150	.compat = "md5",
1da177e4 LT	151
	152	.uinfo = {
	153	.auth = {
	154	.icv_truncbits = 96,
	155	.icv_fullbits = 128,
	156	}
	157	},
a716c119	158
1da177e4 LT	159	.desc = {
	160	.sadb_alg_id = SADB_AALG_MD5HMAC,
	161	.sadb_alg_ivlen = 0,
	162	.sadb_alg_minbits = 128,
	163	.sadb_alg_maxbits = 128
	164	}
	165	},
	166	{
07d4ee58 HX	167	.name = "hmac(sha1)",
07d4ee58 HX	168	.compat = "sha1",
1da177e4 LT	169
	170	.uinfo = {
	171	.auth = {
	172	.icv_truncbits = 96,
	173	.icv_fullbits = 160,
	174	}
	175	},
	176
	177	.desc = {
	178	.sadb_alg_id = SADB_AALG_SHA1HMAC,
	179	.sadb_alg_ivlen = 0,
	180	.sadb_alg_minbits = 160,
	181	.sadb_alg_maxbits = 160
	182	}
	183	},
	184	{
07d4ee58 HX	185	.name = "hmac(sha256)",
07d4ee58 HX	186	.compat = "sha256",
1da177e4 LT	187
	188	.uinfo = {
	189	.auth = {
	190	.icv_truncbits = 96,
	191	.icv_fullbits = 256,
	192	}
	193	},
	194
	195	.desc = {
	196	.sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
	197	.sadb_alg_ivlen = 0,
	198	.sadb_alg_minbits = 256,
	199	.sadb_alg_maxbits = 256
	200	}
	201	},
	202	{
a13366c6 AKR	203	.name = "hmac(rmd160)",
a13366c6 AKR	204	.compat = "rmd160",
1da177e4 LT	205
	206	.uinfo = {
	207	.auth = {
	208	.icv_truncbits = 96,
	209	.icv_fullbits = 160,
	210	}
	211	},
	212
	213	.desc = {
	214	.sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
	215	.sadb_alg_ivlen = 0,
	216	.sadb_alg_minbits = 160,
	217	.sadb_alg_maxbits = 160
	218	}
	219	},
7cf4c1a5 KM	220	{
	221	.name = "xcbc(aes)",
	222
	223	.uinfo = {
	224	.auth = {
	225	.icv_truncbits = 96,
	226	.icv_fullbits = 128,
	227	}
	228	},
	229
	230	.desc = {
	231	.sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
	232	.sadb_alg_ivlen = 0,
	233	.sadb_alg_minbits = 128,
	234	.sadb_alg_maxbits = 128
	235	}
	236	},
1da177e4 LT	237	};
	238
	239	static struct xfrm_algo_desc ealg_list[] = {
	240	{
6b7326c8 HX	241	.name = "ecb(cipher_null)",
6b7326c8 HX	242	.compat = "cipher_null",
a716c119	243
1da177e4 LT	244	.uinfo = {
	245	.encr = {
	246	.blockbits = 8,
	247	.defkeybits = 0,
	248	}
	249	},
a716c119	250
1da177e4 LT	251	.desc = {
	252	.sadb_alg_id = SADB_EALG_NULL,
	253	.sadb_alg_ivlen = 0,
	254	.sadb_alg_minbits = 0,
	255	.sadb_alg_maxbits = 0
	256	}
	257	},
	258	{
6b7326c8 HX	259	.name = "cbc(des)",
6b7326c8 HX	260	.compat = "des",
1da177e4 LT	261
	262	.uinfo = {
	263	.encr = {
	264	.blockbits = 64,
	265	.defkeybits = 64,
	266	}
	267	},
	268
	269	.desc = {
	270	.sadb_alg_id = SADB_EALG_DESCBC,
	271	.sadb_alg_ivlen = 8,
	272	.sadb_alg_minbits = 64,
	273	.sadb_alg_maxbits = 64
	274	}
	275	},
	276	{
6b7326c8 HX	277	.name = "cbc(des3_ede)",
6b7326c8 HX	278	.compat = "des3_ede",
1da177e4 LT	279
	280	.uinfo = {
	281	.encr = {
	282	.blockbits = 64,
	283	.defkeybits = 192,
	284	}
	285	},
	286
	287	.desc = {
	288	.sadb_alg_id = SADB_EALG_3DESCBC,
	289	.sadb_alg_ivlen = 8,
	290	.sadb_alg_minbits = 192,
	291	.sadb_alg_maxbits = 192
	292	}
	293	},
	294	{
245acb87 HX	295	.name = "cbc(cast5)",
245acb87 HX	296	.compat = "cast5",
1da177e4 LT	297
	298	.uinfo = {
	299	.encr = {
	300	.blockbits = 64,
	301	.defkeybits = 128,
	302	}
	303	},
	304
	305	.desc = {
	306	.sadb_alg_id = SADB_X_EALG_CASTCBC,
	307	.sadb_alg_ivlen = 8,
	308	.sadb_alg_minbits = 40,
	309	.sadb_alg_maxbits = 128
	310	}
	311	},
	312	{
6b7326c8 HX	313	.name = "cbc(blowfish)",
6b7326c8 HX	314	.compat = "blowfish",
1da177e4 LT	315
	316	.uinfo = {
	317	.encr = {
	318	.blockbits = 64,
	319	.defkeybits = 128,
	320	}
	321	},
	322
	323	.desc = {
	324	.sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
	325	.sadb_alg_ivlen = 8,
	326	.sadb_alg_minbits = 40,
	327	.sadb_alg_maxbits = 448
	328	}
	329	},
	330	{
6b7326c8 HX	331	.name = "cbc(aes)",
6b7326c8 HX	332	.compat = "aes",
1da177e4 LT	333
	334	.uinfo = {
	335	.encr = {
	336	.blockbits = 128,
	337	.defkeybits = 128,
	338	}
	339	},
	340
	341	.desc = {
	342	.sadb_alg_id = SADB_X_EALG_AESCBC,
	343	.sadb_alg_ivlen = 8,
	344	.sadb_alg_minbits = 128,
	345	.sadb_alg_maxbits = 256
	346	}
	347	},
	348	{
a716c119 YH	349	.name = "cbc(serpent)",
	350	.compat = "serpent",
	351
	352	.uinfo = {
	353	.encr = {
	354	.blockbits = 128,
	355	.defkeybits = 128,
	356	}
	357	},
	358
	359	.desc = {
	360	.sadb_alg_id = SADB_X_EALG_SERPENTCBC,
	361	.sadb_alg_ivlen = 8,
	362	.sadb_alg_minbits = 128,
	363	.sadb_alg_maxbits = 256,
	364	}
1da177e4	365	},
6a0dc8d7 NT	366	{
6a0dc8d7 NT	367	.name = "cbc(camellia)",
138f3c85	368	.compat = "camellia",
6a0dc8d7 NT	369
	370	.uinfo = {
	371	.encr = {
	372	.blockbits = 128,
	373	.defkeybits = 128,
	374	}
	375	},
	376
	377	.desc = {
	378	.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
	379	.sadb_alg_ivlen = 8,
	380	.sadb_alg_minbits = 128,
	381	.sadb_alg_maxbits = 256
	382	}
	383	},
1da177e4	384	{
a716c119 YH	385	.name = "cbc(twofish)",
	386	.compat = "twofish",
	387
	388	.uinfo = {
	389	.encr = {
	390	.blockbits = 128,
	391	.defkeybits = 128,
	392	}
	393	},
	394
	395	.desc = {
	396	.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
	397	.sadb_alg_ivlen = 8,
	398	.sadb_alg_minbits = 128,
	399	.sadb_alg_maxbits = 256
	400	}
1da177e4	401	},
405137d1 JL	402	{
	403	.name = "rfc3686(ctr(aes))",
	404
	405	.uinfo = {
	406	.encr = {
	407	.blockbits = 128,
	408	.defkeybits = 160, /* 128-bit key + 32-bit nonce */
	409	}
	410	},
	411
	412	.desc = {
	413	.sadb_alg_id = SADB_X_EALG_AESCTR,
	414	.sadb_alg_ivlen = 8,
	415	.sadb_alg_minbits = 128,
	416	.sadb_alg_maxbits = 256
	417	}
	418	},
1da177e4 LT	419	};
	420
	421	static struct xfrm_algo_desc calg_list[] = {
	422	{
	423	.name = "deflate",
	424	.uinfo = {
	425	.comp = {
	426	.threshold = 90,
	427	}
	428	},
	429	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
	430	},
	431	{
	432	.name = "lzs",
	433	.uinfo = {
	434	.comp = {
	435	.threshold = 90,
	436	}
	437	},
	438	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
	439	},
	440	{
	441	.name = "lzjh",
	442	.uinfo = {
	443	.comp = {
	444	.threshold = 50,
	445	}
	446	},
	447	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
	448	},
	449	};
	450
1a6509d9 HX	451	static inline int aead_entries(void)
	452	{
	453	return ARRAY_SIZE(aead_list);
	454	}
	455
1da177e4 LT	456	static inline int aalg_entries(void)
	457	{
	458	return ARRAY_SIZE(aalg_list);
	459	}
	460
	461	static inline int ealg_entries(void)
	462	{
	463	return ARRAY_SIZE(ealg_list);
	464	}
	465
	466	static inline int calg_entries(void)
	467	{
	468	return ARRAY_SIZE(calg_list);
	469	}
	470
c92b3a2f HX	471	struct xfrm_algo_list {
	472	struct xfrm_algo_desc *algs;
	473	int entries;
	474	u32 type;
	475	u32 mask;
	476	};
1da177e4	477
1a6509d9 HX	478	static const struct xfrm_algo_list xfrm_aead_list = {
	479	.algs = aead_list,
	480	.entries = ARRAY_SIZE(aead_list),
	481	.type = CRYPTO_ALG_TYPE_AEAD,
	482	.mask = CRYPTO_ALG_TYPE_MASK,
	483	};
	484
c92b3a2f HX	485	static const struct xfrm_algo_list xfrm_aalg_list = {
	486	.algs = aalg_list,
	487	.entries = ARRAY_SIZE(aalg_list),
	488	.type = CRYPTO_ALG_TYPE_HASH,
6fbf2cb7	489	.mask = CRYPTO_ALG_TYPE_HASH_MASK,
c92b3a2f	490	};
1da177e4	491
c92b3a2f HX	492	static const struct xfrm_algo_list xfrm_ealg_list = {
	493	.algs = ealg_list,
	494	.entries = ARRAY_SIZE(ealg_list),
	495	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
6fbf2cb7	496	.mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
c92b3a2f	497	};
1da177e4	498
c92b3a2f HX	499	static const struct xfrm_algo_list xfrm_calg_list = {
	500	.algs = calg_list,
	501	.entries = ARRAY_SIZE(calg_list),
	502	.type = CRYPTO_ALG_TYPE_COMPRESS,
6fbf2cb7	503	.mask = CRYPTO_ALG_TYPE_MASK,
c92b3a2f	504	};
1da177e4	505
c92b3a2f HX	506	static struct xfrm_algo_desc *xfrm_find_algo(
	507	const struct xfrm_algo_list *algo_list,
	508	int match(const struct xfrm_algo_desc entry, const void data),
	509	const void *data, int probe)
1da177e4	510	{
c92b3a2f	511	struct xfrm_algo_desc *list = algo_list->algs;
1da177e4 LT	512	int i, status;
1da177e4 LT	513
c92b3a2f HX	514	for (i = 0; i < algo_list->entries; i++) {
c92b3a2f HX	515	if (!match(list + i, data))
1da177e4 LT	516	continue;
	517
	518	if (list[i].available)
	519	return &list[i];
	520
	521	if (!probe)
	522	break;
	523
c92b3a2f HX	524	status = crypto_has_alg(list[i].name, algo_list->type,
c92b3a2f HX	525	algo_list->mask);
1da177e4 LT	526	if (!status)
	527	break;
	528
	529	list[i].available = status;
	530	return &list[i];
	531	}
	532	return NULL;
	533	}
	534
c92b3a2f HX	535	static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
	536	const void *data)
	537	{
26b8e51e	538	return entry->desc.sadb_alg_id == (unsigned long)data;
c92b3a2f HX	539	}
	540
	541	struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
	542	{
	543	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
26b8e51e	544	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	545	}
	546	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
	547
	548	struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
	549	{
	550	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
26b8e51e	551	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	552	}
	553	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
	554
	555	struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
	556	{
	557	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
26b8e51e	558	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	559	}
	560	EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
	561
	562	static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
	563	const void *data)
	564	{
	565	const char *name = data;
	566
	567	return name && (!strcmp(name, entry->name) \|\|
	568	(entry->compat && !strcmp(name, entry->compat)));
	569	}
	570
1da177e4 LT	571	struct xfrm_algo_desc xfrm_aalg_get_byname(char name, int probe)
1da177e4 LT	572	{
c92b3a2f HX	573	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
c92b3a2f HX	574	probe);
1da177e4 LT	575	}
	576	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
	577
	578	struct xfrm_algo_desc xfrm_ealg_get_byname(char name, int probe)
	579	{
c92b3a2f HX	580	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
c92b3a2f HX	581	probe);
1da177e4 LT	582	}
	583	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
	584
	585	struct xfrm_algo_desc xfrm_calg_get_byname(char name, int probe)
	586	{
c92b3a2f HX	587	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
c92b3a2f HX	588	probe);
1da177e4 LT	589	}
	590	EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
	591
1a6509d9 HX	592	struct xfrm_aead_name {
	593	const char *name;
	594	int icvbits;
	595	};
	596
	597	static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
	598	const void *data)
	599	{
	600	const struct xfrm_aead_name *aead = data;
	601	const char *name = aead->name;
	602
	603	return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
	604	!strcmp(name, entry->name);
	605	}
	606
	607	struct xfrm_algo_desc xfrm_aead_get_byname(char name, int icv_len, int probe)
	608	{
	609	struct xfrm_aead_name data = {
	610	.name = name,
	611	.icvbits = icv_len,
	612	};
	613
	614	return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
	615	probe);
	616	}
	617	EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
	618
1da177e4 LT	619	struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
	620	{
	621	if (idx >= aalg_entries())
	622	return NULL;
	623
	624	return &aalg_list[idx];
	625	}
	626	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
	627
	628	struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
	629	{
	630	if (idx >= ealg_entries())
	631	return NULL;
	632
	633	return &ealg_list[idx];
	634	}
	635	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
	636
	637	/*
	638	* Probe for the availability of crypto algorithms, and set the available
	639	* flag for any algorithms found on the system. This is typically called by
	640	* pfkey during userspace SA add, update or register.
	641	*/
	642	void xfrm_probe_algs(void)
	643	{
1da177e4	644	int i, status;
a716c119	645
1da177e4 LT	646	BUG_ON(in_softirq());
	647
	648	for (i = 0; i < aalg_entries(); i++) {
e4d5b79c HX	649	status = crypto_has_hash(aalg_list[i].name, 0,
e4d5b79c HX	650	CRYPTO_ALG_ASYNC);
1da177e4 LT	651	if (aalg_list[i].available != status)
	652	aalg_list[i].available = status;
	653	}
a716c119	654
1da177e4	655	for (i = 0; i < ealg_entries(); i++) {
e4d5b79c HX	656	status = crypto_has_blkcipher(ealg_list[i].name, 0,
e4d5b79c HX	657	CRYPTO_ALG_ASYNC);
1da177e4 LT	658	if (ealg_list[i].available != status)
	659	ealg_list[i].available = status;
	660	}
a716c119	661
1da177e4	662	for (i = 0; i < calg_entries(); i++) {
e4d5b79c HX	663	status = crypto_has_comp(calg_list[i].name, 0,
e4d5b79c HX	664	CRYPTO_ALG_ASYNC);
1da177e4 LT	665	if (calg_list[i].available != status)
	666	calg_list[i].available = status;
	667	}
1da177e4 LT	668	}
	669	EXPORT_SYMBOL_GPL(xfrm_probe_algs);
	670
	671	int xfrm_count_auth_supported(void)
	672	{
	673	int i, n;
	674
	675	for (i = 0, n = 0; i < aalg_entries(); i++)
	676	if (aalg_list[i].available)
	677	n++;
	678	return n;
	679	}
	680	EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
	681
	682	int xfrm_count_enc_supported(void)
	683	{
	684	int i, n;
	685
	686	for (i = 0, n = 0; i < ealg_entries(); i++)
	687	if (ealg_list[i].available)
	688	n++;
	689	return n;
	690	}
	691	EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
	692
	693	/* Move to common area: it is shared with AH. */
	694
07d4ee58 HX	695	int skb_icv_walk(const struct sk_buff skb, struct hash_desc desc,
07d4ee58 HX	696	int offset, int len, icv_update_fn_t icv_update)
1da177e4	697	{
1a028e50 DM	698	int start = skb_headlen(skb);
1a028e50 DM	699	int i, copy = start - offset;
d4fd3bc1	700	struct sk_buff *frag_iter;
1da177e4	701	struct scatterlist sg;
d4fd3bc1	702	int err;
1da177e4 LT	703
	704	/* Checksum header. */
	705	if (copy > 0) {
	706	if (copy > len)
	707	copy = len;
a716c119	708
0e0940d4	709	sg_init_one(&sg, skb->data + offset, copy);
a716c119	710
07d4ee58 HX	711	err = icv_update(desc, &sg, copy);
	712	if (unlikely(err))
	713	return err;
a716c119	714
1da177e4	715	if ((len -= copy) == 0)
07d4ee58	716	return 0;
1da177e4 LT	717	offset += copy;
	718	}
	719
	720	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1a028e50	721	int end;
1da177e4	722
547b792c	723	WARN_ON(start > offset + len);
1a028e50 DM	724
1a028e50 DM	725	end = start + skb_shinfo(skb)->frags[i].size;
1da177e4 LT	726	if ((copy = end - offset) > 0) {
	727	skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
	728
	729	if (copy > len)
	730	copy = len;
a716c119	731
0e0940d4	732	sg_init_table(&sg, 1);
642f1490	733	sg_set_page(&sg, frag->page, copy,
0e0940d4	734	frag->page_offset + offset-start);
a716c119	735
07d4ee58 HX	736	err = icv_update(desc, &sg, copy);
	737	if (unlikely(err))
	738	return err;
1da177e4 LT	739
1da177e4 LT	740	if (!(len -= copy))
07d4ee58	741	return 0;
1da177e4 LT	742	offset += copy;
1da177e4 LT	743	}
1a028e50	744	start = end;
1da177e4 LT	745	}
1da177e4 LT	746
d4fd3bc1 DM	747	skb_walk_frags(skb, frag_iter) {
	748	int end;
	749
	750	WARN_ON(start > offset + len);
	751
	752	end = start + frag_iter->len;
	753	if ((copy = end - offset) > 0) {
	754	if (copy > len)
	755	copy = len;
	756	err = skb_icv_walk(frag_iter, desc, offset-start,
	757	copy, icv_update);
	758	if (unlikely(err))
	759	return err;
	760	if ((len -= copy) == 0)
	761	return 0;
	762	offset += copy;
1da177e4	763	}
d4fd3bc1	764	start = end;
1da177e4	765	}
09a62660	766	BUG_ON(len);
07d4ee58	767	return 0;
1da177e4 LT	768	}
	769	EXPORT_SYMBOL_GPL(skb_icv_walk);
	770
	771	#if defined(CONFIG_INET_ESP) \|\| defined(CONFIG_INET_ESP_MODULE) \|\| defined(CONFIG_INET6_ESP) \|\| defined(CONFIG_INET6_ESP_MODULE)
	772
1da177e4 LT	773	void pskb_put(struct sk_buff skb, struct sk_buff *tail, int len)
	774	{
	775	if (tail != skb) {
	776	skb->data_len += len;
	777	skb->len += len;
	778	}
	779	return skb_put(tail, len);
	780	}
	781	EXPORT_SYMBOL_GPL(pskb_put);
	782	#endif