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