[linux-2.6-block.git] / net / xfrm / xfrm_algo.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * xfrm algorithm interface
 *
 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
 */

#include <crypto/aead.h>
#include <crypto/hash.h>
#include <crypto/skcipher.h>
#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 IS_ENABLED(CONFIG_INET_ESP) || IS_ENABLED(CONFIG_INET6_ESP)
#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,
},
{
	.name = "hmac(sm3)",
	.compat = "sm3",

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

	.pfkey_supported = 1,

	.desc = {
		.sadb_alg_id = SADB_X_AALG_SM3_256HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 256,
		.sadb_alg_maxbits = 256
	}
},
};

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
	}
},
{
	.name = "cbc(sm4)",
	.compat = "sm4",

	.uinfo = {
		.encr = {
			.geniv = "echainiv",
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.pfkey_supported = 1,

	.desc = {
		.sadb_alg_id = SADB_X_EALG_SM4CBC,
		.sadb_alg_ivlen	= 16,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
};

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 {
	int (*find)(const char *name, u32 type, u32 mask);
	struct xfrm_algo_desc *algs;
	int entries;
};

static const struct xfrm_algo_list xfrm_aead_list = {
	.find = crypto_has_aead,
	.algs = aead_list,
	.entries = ARRAY_SIZE(aead_list),
};

static const struct xfrm_algo_list xfrm_aalg_list = {
	.find = crypto_has_ahash,
	.algs = aalg_list,
	.entries = ARRAY_SIZE(aalg_list),
};

static const struct xfrm_algo_list xfrm_ealg_list = {
	.find = crypto_has_skcipher,
	.algs = ealg_list,
	.entries = ARRAY_SIZE(ealg_list),
};

static const struct xfrm_algo_list xfrm_calg_list = {
	.find = crypto_has_comp,
	.algs = calg_list,
	.entries = ARRAY_SIZE(calg_list),
};

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 = algo_list->find(list[i].name, 0, 0);
		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_ahash(aalg_list[i].name, 0, 0);
		if (aalg_list[i].available != status)
			aalg_list[i].available = status;
	}

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