[linux-2.6-block.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_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,
		}
	},

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

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

	.pfkey_supported = 1,

	.desc = {
		.sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
		.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,
		}
	},

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

	.desc = {
		.sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 128
	}
},
{
	/* rfc4494 */
	.name = "cmac(aes)",

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

	.pfkey_supported = 0,
},
};

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

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

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

	.pfkey_supported = 1,

	.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 */
		}
	},

	.pfkey_supported = 1,

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AESCTR,
		.sadb_alg_ivlen	= 8,
		.sadb_alg_minbits = 160,
		.sadb_alg_maxbits = 288
	}
},
};

static struct xfrm_algo_desc calg_list[] = {
{
	.name = "deflate",
	.uinfo = {
		.comp = {
			.threshold = 90,
		}
	},
	.pfkey_supported = 1,
	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
},
{
	.name = "lzs",
	.uinfo = {
		.comp = {
			.threshold = 90,
		}
	},
	.pfkey_supported = 1,
	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
},
{
	.name = "lzjh",
	.uinfo = {
		.comp = {
			.threshold = 50,
		}
	},
	.pfkey_supported = 1,
	.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(const 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(const 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(const 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(const 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_ablkcipher(ealg_list[i].name, 0, 0);
		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_pfkey_auth_supported(void)
{
	int i, n;

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

int xfrm_count_pfkey_enc_supported(void)
{
	int i, n;

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

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