[mirror_ubuntu-jammy-kernel.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,
},
};

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_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	},
1da177e4 LT	344	};
	345
	346	static struct xfrm_algo_desc ealg_list[] = {
	347	{
6b7326c8 HX	348	.name = "ecb(cipher_null)",
6b7326c8 HX	349	.compat = "cipher_null",
a716c119	350
1da177e4 LT	351	.uinfo = {
	352	.encr = {
	353	.blockbits = 8,
	354	.defkeybits = 0,
	355	}
	356	},
a716c119	357
7e50f84c JK	358	.pfkey_supported = 1,
7e50f84c JK	359
1da177e4 LT	360	.desc = {
	361	.sadb_alg_id = SADB_EALG_NULL,
	362	.sadb_alg_ivlen = 0,
	363	.sadb_alg_minbits = 0,
	364	.sadb_alg_maxbits = 0
	365	}
	366	},
	367	{
6b7326c8 HX	368	.name = "cbc(des)",
6b7326c8 HX	369	.compat = "des",
1da177e4 LT	370
	371	.uinfo = {
	372	.encr = {
165ecc63	373	.geniv = "echainiv",
1da177e4 LT	374	.blockbits = 64,
	375	.defkeybits = 64,
	376	}
	377	},
	378
7e50f84c JK	379	.pfkey_supported = 1,
7e50f84c JK	380
1da177e4 LT	381	.desc = {
	382	.sadb_alg_id = SADB_EALG_DESCBC,
	383	.sadb_alg_ivlen = 8,
	384	.sadb_alg_minbits = 64,
	385	.sadb_alg_maxbits = 64
	386	}
	387	},
	388	{
6b7326c8 HX	389	.name = "cbc(des3_ede)",
6b7326c8 HX	390	.compat = "des3_ede",
1da177e4 LT	391
	392	.uinfo = {
	393	.encr = {
165ecc63	394	.geniv = "echainiv",
1da177e4 LT	395	.blockbits = 64,
	396	.defkeybits = 192,
	397	}
	398	},
	399
7e50f84c JK	400	.pfkey_supported = 1,
7e50f84c JK	401
1da177e4 LT	402	.desc = {
	403	.sadb_alg_id = SADB_EALG_3DESCBC,
	404	.sadb_alg_ivlen = 8,
	405	.sadb_alg_minbits = 192,
	406	.sadb_alg_maxbits = 192
	407	}
	408	},
	409	{
245acb87 HX	410	.name = "cbc(cast5)",
245acb87 HX	411	.compat = "cast5",
1da177e4 LT	412
	413	.uinfo = {
	414	.encr = {
165ecc63	415	.geniv = "echainiv",
1da177e4 LT	416	.blockbits = 64,
	417	.defkeybits = 128,
	418	}
	419	},
	420
7e50f84c JK	421	.pfkey_supported = 1,
7e50f84c JK	422
1da177e4 LT	423	.desc = {
	424	.sadb_alg_id = SADB_X_EALG_CASTCBC,
	425	.sadb_alg_ivlen = 8,
	426	.sadb_alg_minbits = 40,
	427	.sadb_alg_maxbits = 128
	428	}
	429	},
	430	{
6b7326c8 HX	431	.name = "cbc(blowfish)",
6b7326c8 HX	432	.compat = "blowfish",
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_BLOWFISHCBC,
	446	.sadb_alg_ivlen = 8,
	447	.sadb_alg_minbits = 40,
	448	.sadb_alg_maxbits = 448
	449	}
	450	},
	451	{
6b7326c8 HX	452	.name = "cbc(aes)",
6b7326c8 HX	453	.compat = "aes",
1da177e4 LT	454
	455	.uinfo = {
	456	.encr = {
165ecc63	457	.geniv = "echainiv",
1da177e4 LT	458	.blockbits = 128,
	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_AESCBC,
	467	.sadb_alg_ivlen = 8,
	468	.sadb_alg_minbits = 128,
	469	.sadb_alg_maxbits = 256
	470	}
	471	},
	472	{
a716c119 YH	473	.name = "cbc(serpent)",
	474	.compat = "serpent",
	475
	476	.uinfo = {
	477	.encr = {
165ecc63	478	.geniv = "echainiv",
a716c119 YH	479	.blockbits = 128,
	480	.defkeybits = 128,
	481	}
	482	},
	483
7e50f84c JK	484	.pfkey_supported = 1,
7e50f84c JK	485
a716c119 YH	486	.desc = {
	487	.sadb_alg_id = SADB_X_EALG_SERPENTCBC,
	488	.sadb_alg_ivlen = 8,
	489	.sadb_alg_minbits = 128,
	490	.sadb_alg_maxbits = 256,
	491	}
1da177e4	492	},
6a0dc8d7 NT	493	{
6a0dc8d7 NT	494	.name = "cbc(camellia)",
138f3c85	495	.compat = "camellia",
6a0dc8d7 NT	496
	497	.uinfo = {
	498	.encr = {
165ecc63	499	.geniv = "echainiv",
6a0dc8d7 NT	500	.blockbits = 128,
	501	.defkeybits = 128,
	502	}
	503	},
	504
7e50f84c JK	505	.pfkey_supported = 1,
7e50f84c JK	506
6a0dc8d7 NT	507	.desc = {
	508	.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
	509	.sadb_alg_ivlen = 8,
	510	.sadb_alg_minbits = 128,
	511	.sadb_alg_maxbits = 256
	512	}
	513	},
1da177e4	514	{
a716c119 YH	515	.name = "cbc(twofish)",
	516	.compat = "twofish",
	517
	518	.uinfo = {
	519	.encr = {
165ecc63	520	.geniv = "echainiv",
a716c119 YH	521	.blockbits = 128,
	522	.defkeybits = 128,
	523	}
	524	},
	525
7e50f84c JK	526	.pfkey_supported = 1,
7e50f84c JK	527
a716c119 YH	528	.desc = {
	529	.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
	530	.sadb_alg_ivlen = 8,
	531	.sadb_alg_minbits = 128,
	532	.sadb_alg_maxbits = 256
	533	}
1da177e4	534	},
405137d1 JL	535	{
	536	.name = "rfc3686(ctr(aes))",
	537
	538	.uinfo = {
	539	.encr = {
165ecc63	540	.geniv = "seqiv",
405137d1 JL	541	.blockbits = 128,
	542	.defkeybits = 160, /* 128-bit key + 32-bit nonce */
	543	}
	544	},
	545
7e50f84c JK	546	.pfkey_supported = 1,
7e50f84c JK	547
405137d1 JL	548	.desc = {
	549	.sadb_alg_id = SADB_X_EALG_AESCTR,
	550	.sadb_alg_ivlen = 8,
4203223a TG	551	.sadb_alg_minbits = 160,
4203223a TG	552	.sadb_alg_maxbits = 288
405137d1 JL	553	}
405137d1 JL	554	},
1da177e4 LT	555	};
	556
	557	static struct xfrm_algo_desc calg_list[] = {
	558	{
	559	.name = "deflate",
	560	.uinfo = {
	561	.comp = {
	562	.threshold = 90,
	563	}
	564	},
7e50f84c	565	.pfkey_supported = 1,
1da177e4 LT	566	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
	567	},
	568	{
	569	.name = "lzs",
	570	.uinfo = {
	571	.comp = {
	572	.threshold = 90,
	573	}
	574	},
7e50f84c	575	.pfkey_supported = 1,
1da177e4 LT	576	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
	577	},
	578	{
	579	.name = "lzjh",
	580	.uinfo = {
	581	.comp = {
	582	.threshold = 50,
	583	}
	584	},
7e50f84c	585	.pfkey_supported = 1,
1da177e4 LT	586	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
	587	},
	588	};
	589
	590	static inline int aalg_entries(void)
	591	{
	592	return ARRAY_SIZE(aalg_list);
	593	}
	594
	595	static inline int ealg_entries(void)
	596	{
	597	return ARRAY_SIZE(ealg_list);
	598	}
	599
	600	static inline int calg_entries(void)
	601	{
	602	return ARRAY_SIZE(calg_list);
	603	}
	604
c92b3a2f HX	605	struct xfrm_algo_list {
	606	struct xfrm_algo_desc *algs;
	607	int entries;
	608	u32 type;
	609	u32 mask;
	610	};
1da177e4	611
1a6509d9 HX	612	static const struct xfrm_algo_list xfrm_aead_list = {
	613	.algs = aead_list,
	614	.entries = ARRAY_SIZE(aead_list),
	615	.type = CRYPTO_ALG_TYPE_AEAD,
	616	.mask = CRYPTO_ALG_TYPE_MASK,
	617	};
	618
c92b3a2f HX	619	static const struct xfrm_algo_list xfrm_aalg_list = {
	620	.algs = aalg_list,
	621	.entries = ARRAY_SIZE(aalg_list),
	622	.type = CRYPTO_ALG_TYPE_HASH,
6fbf2cb7	623	.mask = CRYPTO_ALG_TYPE_HASH_MASK,
c92b3a2f	624	};
1da177e4	625
c92b3a2f HX	626	static const struct xfrm_algo_list xfrm_ealg_list = {
	627	.algs = ealg_list,
	628	.entries = ARRAY_SIZE(ealg_list),
	629	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
6fbf2cb7	630	.mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
c92b3a2f	631	};
1da177e4	632
c92b3a2f HX	633	static const struct xfrm_algo_list xfrm_calg_list = {
	634	.algs = calg_list,
	635	.entries = ARRAY_SIZE(calg_list),
	636	.type = CRYPTO_ALG_TYPE_COMPRESS,
6fbf2cb7	637	.mask = CRYPTO_ALG_TYPE_MASK,
c92b3a2f	638	};
1da177e4	639
c92b3a2f HX	640	static struct xfrm_algo_desc *xfrm_find_algo(
	641	const struct xfrm_algo_list *algo_list,
	642	int match(const struct xfrm_algo_desc entry, const void data),
	643	const void *data, int probe)
1da177e4	644	{
c92b3a2f	645	struct xfrm_algo_desc *list = algo_list->algs;
1da177e4 LT	646	int i, status;
1da177e4 LT	647
c92b3a2f HX	648	for (i = 0; i < algo_list->entries; i++) {
c92b3a2f HX	649	if (!match(list + i, data))
1da177e4 LT	650	continue;
	651
	652	if (list[i].available)
	653	return &list[i];
	654
	655	if (!probe)
	656	break;
	657
c92b3a2f HX	658	status = crypto_has_alg(list[i].name, algo_list->type,
c92b3a2f HX	659	algo_list->mask);
1da177e4 LT	660	if (!status)
	661	break;
	662
	663	list[i].available = status;
	664	return &list[i];
	665	}
	666	return NULL;
	667	}
	668
c92b3a2f HX	669	static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
	670	const void *data)
	671	{
26b8e51e	672	return entry->desc.sadb_alg_id == (unsigned long)data;
c92b3a2f HX	673	}
	674
	675	struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
	676	{
	677	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
26b8e51e	678	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	679	}
	680	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
	681
	682	struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
	683	{
	684	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
26b8e51e	685	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	686	}
	687	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
	688
	689	struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
	690	{
	691	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
26b8e51e	692	(void *)(unsigned long)alg_id, 1);
c92b3a2f HX	693	}
	694	EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
	695
	696	static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
	697	const void *data)
	698	{
	699	const char *name = data;
	700
	701	return name && (!strcmp(name, entry->name) \|\|
	702	(entry->compat && !strcmp(name, entry->compat)));
	703	}
	704
6f2f19ed	705	struct xfrm_algo_desc xfrm_aalg_get_byname(const char name, int probe)
1da177e4	706	{
c92b3a2f HX	707	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
c92b3a2f HX	708	probe);
1da177e4 LT	709	}
	710	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
	711
6f2f19ed	712	struct xfrm_algo_desc xfrm_ealg_get_byname(const char name, int probe)
1da177e4	713	{
c92b3a2f HX	714	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
c92b3a2f HX	715	probe);
1da177e4 LT	716	}
	717	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
	718
6f2f19ed	719	struct xfrm_algo_desc xfrm_calg_get_byname(const char name, int probe)
1da177e4	720	{
c92b3a2f HX	721	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
c92b3a2f HX	722	probe);
1da177e4 LT	723	}
	724	EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
	725
1a6509d9 HX	726	struct xfrm_aead_name {
	727	const char *name;
	728	int icvbits;
	729	};
	730
	731	static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
	732	const void *data)
	733	{
	734	const struct xfrm_aead_name *aead = data;
	735	const char *name = aead->name;
	736
	737	return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
	738	!strcmp(name, entry->name);
	739	}
	740
6f2f19ed	741	struct xfrm_algo_desc xfrm_aead_get_byname(const char name, int icv_len, int probe)
1a6509d9 HX	742	{
	743	struct xfrm_aead_name data = {
	744	.name = name,
	745	.icvbits = icv_len,
	746	};
	747
	748	return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
	749	probe);
	750	}
	751	EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
	752
1da177e4 LT	753	struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
	754	{
	755	if (idx >= aalg_entries())
	756	return NULL;
	757
	758	return &aalg_list[idx];
	759	}
	760	EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
	761
	762	struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
	763	{
	764	if (idx >= ealg_entries())
	765	return NULL;
	766
	767	return &ealg_list[idx];
	768	}
	769	EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
	770
	771	/*
	772	* Probe for the availability of crypto algorithms, and set the available
	773	* flag for any algorithms found on the system. This is typically called by
	774	* pfkey during userspace SA add, update or register.
	775	*/
	776	void xfrm_probe_algs(void)
	777	{
1da177e4	778	int i, status;
a716c119	779
1da177e4 LT	780	BUG_ON(in_softirq());
	781
	782	for (i = 0; i < aalg_entries(); i++) {
17bc1970	783	status = crypto_has_ahash(aalg_list[i].name, 0, 0);
1da177e4 LT	784	if (aalg_list[i].available != status)
	785	aalg_list[i].available = status;
	786	}
a716c119	787
1da177e4	788	for (i = 0; i < ealg_entries(); i++) {
17bc1970	789	status = crypto_has_skcipher(ealg_list[i].name, 0, 0);
1da177e4 LT	790	if (ealg_list[i].available != status)
	791	ealg_list[i].available = status;
	792	}
a716c119	793
1da177e4	794	for (i = 0; i < calg_entries(); i++) {
e4d5b79c HX	795	status = crypto_has_comp(calg_list[i].name, 0,
e4d5b79c HX	796	CRYPTO_ALG_ASYNC);
1da177e4 LT	797	if (calg_list[i].available != status)
	798	calg_list[i].available = status;
	799	}
1da177e4 LT	800	}
	801	EXPORT_SYMBOL_GPL(xfrm_probe_algs);
	802
7e50f84c	803	int xfrm_count_pfkey_auth_supported(void)
1da177e4 LT	804	{
	805	int i, n;
	806
	807	for (i = 0, n = 0; i < aalg_entries(); i++)
7e50f84c	808	if (aalg_list[i].available && aalg_list[i].pfkey_supported)
1da177e4 LT	809	n++;
	810	return n;
	811	}
7e50f84c	812	EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
1da177e4	813
7e50f84c	814	int xfrm_count_pfkey_enc_supported(void)
1da177e4 LT	815	{
	816	int i, n;
	817
	818	for (i = 0, n = 0; i < ealg_entries(); i++)
7e50f84c	819	if (ealg_list[i].available && ealg_list[i].pfkey_supported)
1da177e4 LT	820	n++;
	821	return n;
	822	}
7e50f84c	823	EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
1da177e4	824
7e152524	825	MODULE_LICENSE("GPL");