[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

/*
 * 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(sha384)",

	.uinfo = {
		.auth = {
			.icv_truncbits = 192,
			.icv_fullbits = 384,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 384,
		.sadb_alg_maxbits = 384
	}
},
{
	.name = "hmac(sha512)",

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

	.desc = {
		.sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 512,
		.sadb_alg_maxbits = 512
	}
},
{
	.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);

#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	},
bc74b0c8 MW	202	{
	203	.name = "hmac(sha384)",
	204
	205	.uinfo = {
	206	.auth = {
	207	.icv_truncbits = 192,
	208	.icv_fullbits = 384,
	209	}
	210	},
	211
	212	.desc = {
	213	.sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
	214	.sadb_alg_ivlen = 0,
	215	.sadb_alg_minbits = 384,
	216	.sadb_alg_maxbits = 384
	217	}
	218	},
	219	{
	220	.name = "hmac(sha512)",
	221
	222	.uinfo = {
	223	.auth = {
	224	.icv_truncbits = 256,
	225	.icv_fullbits = 512,
	226	}
	227	},
	228
	229	.desc = {
	230	.sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
	231	.sadb_alg_ivlen = 0,
	232	.sadb_alg_minbits = 512,
	233	.sadb_alg_maxbits = 512
	234	}
	235	},
1da177e4	236	{
a13366c6 AKR	237	.name = "hmac(rmd160)",
a13366c6 AKR	238	.compat = "rmd160",
1da177e4 LT	239
	240	.uinfo = {
	241	.auth = {
	242	.icv_truncbits = 96,
	243	.icv_fullbits = 160,
	244	}
	245	},
	246
	247	.desc = {
	248	.sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
	249	.sadb_alg_ivlen = 0,
	250	.sadb_alg_minbits = 160,
	251	.sadb_alg_maxbits = 160
	252	}
	253	},
7cf4c1a5 KM	254	{
	255	.name = "xcbc(aes)",
	256
	257	.uinfo = {
	258	.auth = {
	259	.icv_truncbits = 96,
	260	.icv_fullbits = 128,
	261	}
	262	},
	263
	264	.desc = {
	265	.sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
	266	.sadb_alg_ivlen = 0,
	267	.sadb_alg_minbits = 128,
	268	.sadb_alg_maxbits = 128
	269	}
	270	},
1da177e4 LT	271	};
	272
	273	static struct xfrm_algo_desc ealg_list[] = {
	274	{
6b7326c8 HX	275	.name = "ecb(cipher_null)",
6b7326c8 HX	276	.compat = "cipher_null",
a716c119	277
1da177e4 LT	278	.uinfo = {
	279	.encr = {
	280	.blockbits = 8,
	281	.defkeybits = 0,
	282	}
	283	},
a716c119	284
1da177e4 LT	285	.desc = {
	286	.sadb_alg_id = SADB_EALG_NULL,
	287	.sadb_alg_ivlen = 0,
	288	.sadb_alg_minbits = 0,
	289	.sadb_alg_maxbits = 0
	290	}
	291	},
	292	{
6b7326c8 HX	293	.name = "cbc(des)",
6b7326c8 HX	294	.compat = "des",
1da177e4 LT	295
	296	.uinfo = {
	297	.encr = {
	298	.blockbits = 64,
	299	.defkeybits = 64,
	300	}
	301	},
	302
	303	.desc = {
	304	.sadb_alg_id = SADB_EALG_DESCBC,
	305	.sadb_alg_ivlen = 8,
	306	.sadb_alg_minbits = 64,
	307	.sadb_alg_maxbits = 64
	308	}
	309	},
	310	{
6b7326c8 HX	311	.name = "cbc(des3_ede)",
6b7326c8 HX	312	.compat = "des3_ede",
1da177e4 LT	313
	314	.uinfo = {
	315	.encr = {
	316	.blockbits = 64,
	317	.defkeybits = 192,
	318	}
	319	},
	320
	321	.desc = {
	322	.sadb_alg_id = SADB_EALG_3DESCBC,
	323	.sadb_alg_ivlen = 8,
	324	.sadb_alg_minbits = 192,
	325	.sadb_alg_maxbits = 192
	326	}
	327	},
	328	{
245acb87 HX	329	.name = "cbc(cast5)",
245acb87 HX	330	.compat = "cast5",
1da177e4 LT	331
	332	.uinfo = {
	333	.encr = {
	334	.blockbits = 64,
	335	.defkeybits = 128,
	336	}
	337	},
	338
	339	.desc = {
	340	.sadb_alg_id = SADB_X_EALG_CASTCBC,
	341	.sadb_alg_ivlen = 8,
	342	.sadb_alg_minbits = 40,
	343	.sadb_alg_maxbits = 128
	344	}
	345	},
	346	{
6b7326c8 HX	347	.name = "cbc(blowfish)",
6b7326c8 HX	348	.compat = "blowfish",
1da177e4 LT	349
	350	.uinfo = {
	351	.encr = {
	352	.blockbits = 64,
	353	.defkeybits = 128,
	354	}
	355	},
	356
	357	.desc = {
	358	.sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
	359	.sadb_alg_ivlen = 8,
	360	.sadb_alg_minbits = 40,
	361	.sadb_alg_maxbits = 448
	362	}
	363	},
	364	{
6b7326c8 HX	365	.name = "cbc(aes)",
6b7326c8 HX	366	.compat = "aes",
1da177e4 LT	367
	368	.uinfo = {
	369	.encr = {
	370	.blockbits = 128,
	371	.defkeybits = 128,
	372	}
	373	},
	374
	375	.desc = {
	376	.sadb_alg_id = SADB_X_EALG_AESCBC,
	377	.sadb_alg_ivlen = 8,
	378	.sadb_alg_minbits = 128,
	379	.sadb_alg_maxbits = 256
	380	}
	381	},
	382	{
a716c119 YH	383	.name = "cbc(serpent)",
	384	.compat = "serpent",
	385
	386	.uinfo = {
	387	.encr = {
	388	.blockbits = 128,
	389	.defkeybits = 128,
	390	}
	391	},
	392
	393	.desc = {
	394	.sadb_alg_id = SADB_X_EALG_SERPENTCBC,
	395	.sadb_alg_ivlen = 8,
	396	.sadb_alg_minbits = 128,
	397	.sadb_alg_maxbits = 256,
	398	}
1da177e4	399	},
6a0dc8d7 NT	400	{
6a0dc8d7 NT	401	.name = "cbc(camellia)",
138f3c85	402	.compat = "camellia",
6a0dc8d7 NT	403
	404	.uinfo = {
	405	.encr = {
	406	.blockbits = 128,
	407	.defkeybits = 128,
	408	}
	409	},
	410
	411	.desc = {
	412	.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
	413	.sadb_alg_ivlen = 8,
	414	.sadb_alg_minbits = 128,
	415	.sadb_alg_maxbits = 256
	416	}
	417	},
1da177e4	418	{
a716c119 YH	419	.name = "cbc(twofish)",
	420	.compat = "twofish",
	421
	422	.uinfo = {
	423	.encr = {
	424	.blockbits = 128,
	425	.defkeybits = 128,
	426	}
	427	},
	428
	429	.desc = {
	430	.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
	431	.sadb_alg_ivlen = 8,
	432	.sadb_alg_minbits = 128,
	433	.sadb_alg_maxbits = 256
	434	}
1da177e4	435	},
405137d1 JL	436	{
	437	.name = "rfc3686(ctr(aes))",
	438
	439	.uinfo = {
	440	.encr = {
	441	.blockbits = 128,
	442	.defkeybits = 160, /* 128-bit key + 32-bit nonce */
	443	}
	444	},
	445
	446	.desc = {
	447	.sadb_alg_id = SADB_X_EALG_AESCTR,
	448	.sadb_alg_ivlen = 8,
	449	.sadb_alg_minbits = 128,
	450	.sadb_alg_maxbits = 256
	451	}
	452	},
1da177e4 LT	453	};
	454
	455	static struct xfrm_algo_desc calg_list[] = {
	456	{
	457	.name = "deflate",
	458	.uinfo = {
	459	.comp = {
	460	.threshold = 90,
	461	}
	462	},
	463	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
	464	},
	465	{
	466	.name = "lzs",
	467	.uinfo = {
	468	.comp = {
	469	.threshold = 90,
	470	}
	471	},
	472	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
	473	},
	474	{
	475	.name = "lzjh",
	476	.uinfo = {
	477	.comp = {
	478	.threshold = 50,
	479	}
	480	},
	481	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
	482	},
	483	};
	484
1a6509d9 HX	485	static inline int aead_entries(void)
	486	{
	487	return ARRAY_SIZE(aead_list);
	488	}
	489
1da177e4 LT	490	static inline int aalg_entries(void)
	491	{
	492	return ARRAY_SIZE(aalg_list);
	493	}
	494
	495	static inline int ealg_entries(void)
	496	{
	497	return ARRAY_SIZE(ealg_list);
	498	}
	499
	500	static inline int calg_entries(void)
	501	{
	502	return ARRAY_SIZE(calg_list);
	503	}
	504
c92b3a2f HX	505	struct xfrm_algo_list {
	506	struct xfrm_algo_desc *algs;
	507	int entries;
	508	u32 type;
	509	u32 mask;
	510	};
1da177e4	511
1a6509d9 HX	512	static const struct xfrm_algo_list xfrm_aead_list = {
	513	.algs = aead_list,
	514	.entries = ARRAY_SIZE(aead_list),
	515	.type = CRYPTO_ALG_TYPE_AEAD,
	516	.mask = CRYPTO_ALG_TYPE_MASK,
	517	};
	518
c92b3a2f HX	519	static const struct xfrm_algo_list xfrm_aalg_list = {
	520	.algs = aalg_list,
	521	.entries = ARRAY_SIZE(aalg_list),
	522	.type = CRYPTO_ALG_TYPE_HASH,
6fbf2cb7	523	.mask = CRYPTO_ALG_TYPE_HASH_MASK,
c92b3a2f	524	};
1da177e4	525
c92b3a2f HX	526	static const struct xfrm_algo_list xfrm_ealg_list = {
	527	.algs = ealg_list,
	528	.entries = ARRAY_SIZE(ealg_list),
	529	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
6fbf2cb7	530	.mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
c92b3a2f	531	};
1da177e4	532
c92b3a2f HX	533	static const struct xfrm_algo_list xfrm_calg_list = {
	534	.algs = calg_list,
	535	.entries = ARRAY_SIZE(calg_list),
	536	.type = CRYPTO_ALG_TYPE_COMPRESS,
6fbf2cb7	537	.mask = CRYPTO_ALG_TYPE_MASK,
c92b3a2f	538	};
1da177e4	539
c92b3a2f HX	540	static struct xfrm_algo_desc *xfrm_find_algo(
	541	const struct xfrm_algo_list *algo_list,
	542	int match(const struct xfrm_algo_desc entry, const void data),
	543	const void *data, int probe)
1da177e4	544	{
c92b3a2f	545	struct xfrm_algo_desc *list = algo_list->algs;
1da177e4 LT	546	int i, status;
1da177e4 LT	547
c92b3a2f HX	548	for (i = 0; i < algo_list->entries; i++) {
c92b3a2f HX	549	if (!match(list + i, data))
1da177e4 LT	550	continue;
	551
	552	if (list[i].available)
	553	return &list[i];
	554
	555	if (!probe)
	556	break;
	557
c92b3a2f HX	558	status = crypto_has_alg(list[i].name, algo_list->type,
c92b3a2f HX	559	algo_list->mask);
1da177e4 LT	560	if (!status)
	561	break;
	562
	563	list[i].available = status;
	564	return &list[i];
	565	}
	566	return NULL;
	567	}
	568
c92b3a2f HX	569	static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
	570	const void *data)
	571	{
26b8e51e	572	return entry->desc.sadb_alg_id == (unsigned long)data;
c92b3a2f HX	573	}
	574
	575	struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
	576	{
	577	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
26b8e51e	578	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	579	}
	580	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
	581
	582	struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
	583	{
	584	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
26b8e51e	585	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	586	}
	587	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
	588
	589	struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
	590	{
	591	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
26b8e51e	592	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	593	}
	594	EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
	595
	596	static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
	597	const void *data)
	598	{
	599	const char *name = data;
	600
	601	return name && (!strcmp(name, entry->name) \|\|
	602	(entry->compat && !strcmp(name, entry->compat)));
	603	}
	604
1da177e4 LT	605	struct xfrm_algo_desc xfrm_aalg_get_byname(char name, int probe)
1da177e4 LT	606	{
c92b3a2f HX	607	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
c92b3a2f HX	608	probe);
1da177e4 LT	609	}
	610	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
	611
	612	struct xfrm_algo_desc xfrm_ealg_get_byname(char name, int probe)
	613	{
c92b3a2f HX	614	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
c92b3a2f HX	615	probe);
1da177e4 LT	616	}
	617	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
	618
	619	struct xfrm_algo_desc xfrm_calg_get_byname(char name, int probe)
	620	{
c92b3a2f HX	621	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
c92b3a2f HX	622	probe);
1da177e4 LT	623	}
	624	EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
	625
1a6509d9 HX	626	struct xfrm_aead_name {
	627	const char *name;
	628	int icvbits;
	629	};
	630
	631	static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
	632	const void *data)
	633	{
	634	const struct xfrm_aead_name *aead = data;
	635	const char *name = aead->name;
	636
	637	return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
	638	!strcmp(name, entry->name);
	639	}
	640
	641	struct xfrm_algo_desc xfrm_aead_get_byname(char name, int icv_len, int probe)
	642	{
	643	struct xfrm_aead_name data = {
	644	.name = name,
	645	.icvbits = icv_len,
	646	};
	647
	648	return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
	649	probe);
	650	}
	651	EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
	652
1da177e4 LT	653	struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
	654	{
	655	if (idx >= aalg_entries())
	656	return NULL;
	657
	658	return &aalg_list[idx];
	659	}
	660	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
	661
	662	struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
	663	{
	664	if (idx >= ealg_entries())
	665	return NULL;
	666
	667	return &ealg_list[idx];
	668	}
	669	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
	670
	671	/*
	672	* Probe for the availability of crypto algorithms, and set the available
	673	* flag for any algorithms found on the system. This is typically called by
	674	* pfkey during userspace SA add, update or register.
	675	*/
	676	void xfrm_probe_algs(void)
	677	{
1da177e4	678	int i, status;
a716c119	679
1da177e4 LT	680	BUG_ON(in_softirq());
	681
	682	for (i = 0; i < aalg_entries(); i++) {
e4d5b79c HX	683	status = crypto_has_hash(aalg_list[i].name, 0,
e4d5b79c HX	684	CRYPTO_ALG_ASYNC);
1da177e4 LT	685	if (aalg_list[i].available != status)
	686	aalg_list[i].available = status;
	687	}
a716c119	688
1da177e4	689	for (i = 0; i < ealg_entries(); i++) {
e4d5b79c HX	690	status = crypto_has_blkcipher(ealg_list[i].name, 0,
e4d5b79c HX	691	CRYPTO_ALG_ASYNC);
1da177e4 LT	692	if (ealg_list[i].available != status)
	693	ealg_list[i].available = status;
	694	}
a716c119	695
1da177e4	696	for (i = 0; i < calg_entries(); i++) {
e4d5b79c HX	697	status = crypto_has_comp(calg_list[i].name, 0,
e4d5b79c HX	698	CRYPTO_ALG_ASYNC);
1da177e4 LT	699	if (calg_list[i].available != status)
	700	calg_list[i].available = status;
	701	}
1da177e4 LT	702	}
	703	EXPORT_SYMBOL_GPL(xfrm_probe_algs);
	704
	705	int xfrm_count_auth_supported(void)
	706	{
	707	int i, n;
	708
	709	for (i = 0, n = 0; i < aalg_entries(); i++)
	710	if (aalg_list[i].available)
	711	n++;
	712	return n;
	713	}
	714	EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
	715
	716	int xfrm_count_enc_supported(void)
	717	{
	718	int i, n;
	719
	720	for (i = 0, n = 0; i < ealg_entries(); i++)
	721	if (ealg_list[i].available)
	722	n++;
	723	return n;
	724	}
	725	EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
	726
1da177e4 LT	727	#if defined(CONFIG_INET_ESP) \|\| defined(CONFIG_INET_ESP_MODULE) \|\| defined(CONFIG_INET6_ESP) \|\| defined(CONFIG_INET6_ESP_MODULE)
1da177e4 LT	728
1da177e4 LT	729	void pskb_put(struct sk_buff skb, struct sk_buff *tail, int len)
	730	{
	731	if (tail != skb) {
	732	skb->data_len += len;
	733	skb->len += len;
	734	}
	735	return skb_put(tail, len);
	736	}
	737	EXPORT_SYMBOL_GPL(pskb_put);
	738	#endif