[mirror_ubuntu-bionic-kernel.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 = {
			.geniv = "seqiv",
			.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 = {
			.geniv = "seqiv",
			.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 = {
			.geniv = "seqiv",
			.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 = {
			.geniv = "seqiv",
			.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 = {
			.geniv = "seqiv",
			.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 = {
			.geniv = "seqiv",
			.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 = {
			.geniv = "seqiv",
			.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
	}
},
{
	.name = "rfc7539esp(chacha20,poly1305)",

	.uinfo = {
		.aead = {
			.geniv = "seqiv",
			.icv_truncbits = 128,
		}
	},

	.pfkey_supported = 0,
},
};

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