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

/*
 * xfrm algorithm interface
 *
 * Copyright (c) 2002 James Morris <[email protected]>
 *
 * 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(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
	}
},
{
	.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;
	int err;
	struct scatterlist sg;

	/* 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;
	}

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

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

			WARN_ON(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 <[email protected]>
	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	{
6b7326c8 HX	295	.name = "cbc(cast128)",
6b7326c8 HX	296	.compat = "cast128",
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	{
	367	.name = "cbc(camellia)",
	368
	369	.uinfo = {
	370	.encr = {
	371	.blockbits = 128,
	372	.defkeybits = 128,
	373	}
	374	},
	375
	376	.desc = {
	377	.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
	378	.sadb_alg_ivlen = 8,
	379	.sadb_alg_minbits = 128,
	380	.sadb_alg_maxbits = 256
	381	}
	382	},
1da177e4	383	{
a716c119 YH	384	.name = "cbc(twofish)",
	385	.compat = "twofish",
	386
	387	.uinfo = {
	388	.encr = {
	389	.blockbits = 128,
	390	.defkeybits = 128,
	391	}
	392	},
	393
	394	.desc = {
	395	.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
	396	.sadb_alg_ivlen = 8,
	397	.sadb_alg_minbits = 128,
	398	.sadb_alg_maxbits = 256
	399	}
1da177e4	400	},
405137d1 JL	401	{
	402	.name = "rfc3686(ctr(aes))",
	403
	404	.uinfo = {
	405	.encr = {
	406	.blockbits = 128,
	407	.defkeybits = 160, /* 128-bit key + 32-bit nonce */
	408	}
	409	},
	410
	411	.desc = {
	412	.sadb_alg_id = SADB_X_EALG_AESCTR,
	413	.sadb_alg_ivlen = 8,
	414	.sadb_alg_minbits = 128,
	415	.sadb_alg_maxbits = 256
	416	}
	417	},
1da177e4 LT	418	};
	419
	420	static struct xfrm_algo_desc calg_list[] = {
	421	{
	422	.name = "deflate",
	423	.uinfo = {
	424	.comp = {
	425	.threshold = 90,
	426	}
	427	},
	428	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
	429	},
	430	{
	431	.name = "lzs",
	432	.uinfo = {
	433	.comp = {
	434	.threshold = 90,
	435	}
	436	},
	437	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
	438	},
	439	{
	440	.name = "lzjh",
	441	.uinfo = {
	442	.comp = {
	443	.threshold = 50,
	444	}
	445	},
	446	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
	447	},
	448	};
	449
1a6509d9 HX	450	static inline int aead_entries(void)
	451	{
	452	return ARRAY_SIZE(aead_list);
	453	}
	454
1da177e4 LT	455	static inline int aalg_entries(void)
	456	{
	457	return ARRAY_SIZE(aalg_list);
	458	}
	459
	460	static inline int ealg_entries(void)
	461	{
	462	return ARRAY_SIZE(ealg_list);
	463	}
	464
	465	static inline int calg_entries(void)
	466	{
	467	return ARRAY_SIZE(calg_list);
	468	}
	469
c92b3a2f HX	470	struct xfrm_algo_list {
	471	struct xfrm_algo_desc *algs;
	472	int entries;
	473	u32 type;
	474	u32 mask;
	475	};
1da177e4	476
1a6509d9 HX	477	static const struct xfrm_algo_list xfrm_aead_list = {
	478	.algs = aead_list,
	479	.entries = ARRAY_SIZE(aead_list),
	480	.type = CRYPTO_ALG_TYPE_AEAD,
	481	.mask = CRYPTO_ALG_TYPE_MASK,
	482	};
	483
c92b3a2f HX	484	static const struct xfrm_algo_list xfrm_aalg_list = {
	485	.algs = aalg_list,
	486	.entries = ARRAY_SIZE(aalg_list),
	487	.type = CRYPTO_ALG_TYPE_HASH,
6fbf2cb7	488	.mask = CRYPTO_ALG_TYPE_HASH_MASK,
c92b3a2f	489	};
1da177e4	490
c92b3a2f HX	491	static const struct xfrm_algo_list xfrm_ealg_list = {
	492	.algs = ealg_list,
	493	.entries = ARRAY_SIZE(ealg_list),
	494	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
6fbf2cb7	495	.mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
c92b3a2f	496	};
1da177e4	497
c92b3a2f HX	498	static const struct xfrm_algo_list xfrm_calg_list = {
	499	.algs = calg_list,
	500	.entries = ARRAY_SIZE(calg_list),
	501	.type = CRYPTO_ALG_TYPE_COMPRESS,
6fbf2cb7	502	.mask = CRYPTO_ALG_TYPE_MASK,
c92b3a2f	503	};
1da177e4	504
c92b3a2f HX	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)
1da177e4	509	{
c92b3a2f	510	struct xfrm_algo_desc *list = algo_list->algs;
1da177e4 LT	511	int i, status;
1da177e4 LT	512
c92b3a2f HX	513	for (i = 0; i < algo_list->entries; i++) {
c92b3a2f HX	514	if (!match(list + i, data))
1da177e4 LT	515	continue;
	516
	517	if (list[i].available)
	518	return &list[i];
	519
	520	if (!probe)
	521	break;
	522
c92b3a2f HX	523	status = crypto_has_alg(list[i].name, algo_list->type,
c92b3a2f HX	524	algo_list->mask);
1da177e4 LT	525	if (!status)
	526	break;
	527
	528	list[i].available = status;
	529	return &list[i];
	530	}
	531	return NULL;
	532	}
	533
c92b3a2f HX	534	static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
	535	const void *data)
	536	{
26b8e51e	537	return entry->desc.sadb_alg_id == (unsigned long)data;
c92b3a2f HX	538	}
	539
	540	struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
	541	{
	542	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
26b8e51e	543	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	544	}
	545	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
	546
	547	struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
	548	{
	549	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
26b8e51e	550	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	551	}
	552	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
	553
	554	struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
	555	{
	556	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
26b8e51e	557	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	558	}
	559	EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
	560
	561	static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
	562	const void *data)
	563	{
	564	const char *name = data;
	565
	566	return name && (!strcmp(name, entry->name) \|\|
	567	(entry->compat && !strcmp(name, entry->compat)));
	568	}
	569
1da177e4 LT	570	struct xfrm_algo_desc xfrm_aalg_get_byname(char name, int probe)
1da177e4 LT	571	{
c92b3a2f HX	572	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
c92b3a2f HX	573	probe);
1da177e4 LT	574	}
	575	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
	576
	577	struct xfrm_algo_desc xfrm_ealg_get_byname(char name, int probe)
	578	{
c92b3a2f HX	579	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
c92b3a2f HX	580	probe);
1da177e4 LT	581	}
	582	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
	583
	584	struct xfrm_algo_desc xfrm_calg_get_byname(char name, int probe)
	585	{
c92b3a2f HX	586	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
c92b3a2f HX	587	probe);
1da177e4 LT	588	}
	589	EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
	590
1a6509d9 HX	591	struct xfrm_aead_name {
	592	const char *name;
	593	int icvbits;
	594	};
	595
	596	static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
	597	const void *data)
	598	{
	599	const struct xfrm_aead_name *aead = data;
	600	const char *name = aead->name;
	601
	602	return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
	603	!strcmp(name, entry->name);
	604	}
	605
	606	struct xfrm_algo_desc xfrm_aead_get_byname(char name, int icv_len, int probe)
	607	{
	608	struct xfrm_aead_name data = {
	609	.name = name,
	610	.icvbits = icv_len,
	611	};
	612
	613	return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
	614	probe);
	615	}
	616	EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
	617
1da177e4 LT	618	struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
	619	{
	620	if (idx >= aalg_entries())
	621	return NULL;
	622
	623	return &aalg_list[idx];
	624	}
	625	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
	626
	627	struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
	628	{
	629	if (idx >= ealg_entries())
	630	return NULL;
	631
	632	return &ealg_list[idx];
	633	}
	634	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
	635
	636	/*
	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.
	640	*/
	641	void xfrm_probe_algs(void)
	642	{
1da177e4	643	int i, status;
a716c119	644
1da177e4 LT	645	BUG_ON(in_softirq());
	646
	647	for (i = 0; i < aalg_entries(); i++) {
e4d5b79c HX	648	status = crypto_has_hash(aalg_list[i].name, 0,
e4d5b79c HX	649	CRYPTO_ALG_ASYNC);
1da177e4 LT	650	if (aalg_list[i].available != status)
	651	aalg_list[i].available = status;
	652	}
a716c119	653
1da177e4	654	for (i = 0; i < ealg_entries(); i++) {
e4d5b79c HX	655	status = crypto_has_blkcipher(ealg_list[i].name, 0,
e4d5b79c HX	656	CRYPTO_ALG_ASYNC);
1da177e4 LT	657	if (ealg_list[i].available != status)
	658	ealg_list[i].available = status;
	659	}
a716c119	660
1da177e4	661	for (i = 0; i < calg_entries(); i++) {
e4d5b79c HX	662	status = crypto_has_comp(calg_list[i].name, 0,
e4d5b79c HX	663	CRYPTO_ALG_ASYNC);
1da177e4 LT	664	if (calg_list[i].available != status)
	665	calg_list[i].available = status;
	666	}
1da177e4 LT	667	}
	668	EXPORT_SYMBOL_GPL(xfrm_probe_algs);
	669
	670	int xfrm_count_auth_supported(void)
	671	{
	672	int i, n;
	673
	674	for (i = 0, n = 0; i < aalg_entries(); i++)
	675	if (aalg_list[i].available)
	676	n++;
	677	return n;
	678	}
	679	EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
	680
	681	int xfrm_count_enc_supported(void)
	682	{
	683	int i, n;
	684
	685	for (i = 0, n = 0; i < ealg_entries(); i++)
	686	if (ealg_list[i].available)
	687	n++;
	688	return n;
	689	}
	690	EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
	691
	692	/* Move to common area: it is shared with AH. */
	693
07d4ee58 HX	694	int skb_icv_walk(const struct sk_buff skb, struct hash_desc desc,
07d4ee58 HX	695	int offset, int len, icv_update_fn_t icv_update)
1da177e4	696	{
1a028e50 DM	697	int start = skb_headlen(skb);
1a028e50 DM	698	int i, copy = start - offset;
07d4ee58	699	int err;
1da177e4 LT	700	struct scatterlist sg;
	701
	702	/* Checksum header. */
	703	if (copy > 0) {
	704	if (copy > len)
	705	copy = len;
a716c119	706
0e0940d4	707	sg_init_one(&sg, skb->data + offset, copy);
a716c119	708
07d4ee58 HX	709	err = icv_update(desc, &sg, copy);
	710	if (unlikely(err))
	711	return err;
a716c119	712
1da177e4	713	if ((len -= copy) == 0)
07d4ee58	714	return 0;
1da177e4 LT	715	offset += copy;
	716	}
	717
	718	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1a028e50	719	int end;
1da177e4	720
547b792c	721	WARN_ON(start > offset + len);
1a028e50 DM	722
1a028e50 DM	723	end = start + skb_shinfo(skb)->frags[i].size;
1da177e4 LT	724	if ((copy = end - offset) > 0) {
	725	skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
	726
	727	if (copy > len)
	728	copy = len;
a716c119	729
0e0940d4	730	sg_init_table(&sg, 1);
642f1490	731	sg_set_page(&sg, frag->page, copy,
0e0940d4	732	frag->page_offset + offset-start);
a716c119	733
07d4ee58 HX	734	err = icv_update(desc, &sg, copy);
	735	if (unlikely(err))
	736	return err;
1da177e4 LT	737
1da177e4 LT	738	if (!(len -= copy))
07d4ee58	739	return 0;
1da177e4 LT	740	offset += copy;
1da177e4 LT	741	}
1a028e50	742	start = end;
1da177e4 LT	743	}
	744
	745	if (skb_shinfo(skb)->frag_list) {
	746	struct sk_buff *list = skb_shinfo(skb)->frag_list;
	747
	748	for (; list; list = list->next) {
1a028e50 DM	749	int end;
1a028e50 DM	750
547b792c	751	WARN_ON(start > offset + len);
1da177e4	752
1a028e50	753	end = start + list->len;
1da177e4 LT	754	if ((copy = end - offset) > 0) {
	755	if (copy > len)
	756	copy = len;
1a028e50	757	err = skb_icv_walk(list, desc, offset-start,
07d4ee58 HX	758	copy, icv_update);
	759	if (unlikely(err))
	760	return err;
1da177e4	761	if ((len -= copy) == 0)
07d4ee58	762	return 0;
1da177e4 LT	763	offset += copy;
1da177e4 LT	764	}
1a028e50	765	start = end;
1da177e4 LT	766	}
1da177e4 LT	767	}
09a62660	768	BUG_ON(len);
07d4ee58	769	return 0;
1da177e4 LT	770	}
	771	EXPORT_SYMBOL_GPL(skb_icv_walk);
	772
	773	#if defined(CONFIG_INET_ESP) \|\| defined(CONFIG_INET_ESP_MODULE) \|\| defined(CONFIG_INET6_ESP) \|\| defined(CONFIG_INET6_ESP_MODULE)
	774
1da177e4 LT	775	void pskb_put(struct sk_buff skb, struct sk_buff *tail, int len)
	776	{
	777	if (tail != skb) {
	778	skb->data_len += len;
	779	skb->len += len;
	780	}
	781	return skb_put(tail, len);
	782	}
	783	EXPORT_SYMBOL_GPL(pskb_put);
	784	#endif