[mirror_ubuntu-bionic-kernel.git] / net / xfrm / xfrm_algo.c

/*
 * xfrm algorithm interface
 *
 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pfkeyv2.h>
#include <linux/crypto.h>
#include <linux/scatterlist.h>
#include <net/xfrm.h>
#if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
#include <net/ah.h>
#endif
#if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
#include <net/esp.h>
#endif

/*
 * Algorithms supported by IPsec.  These entries contain properties which
 * are used in key negotiation and xfrm processing, and are used to verify
 * that instantiated crypto transforms have correct parameters for IPsec
 * purposes.
 */
static struct xfrm_algo_desc aead_list[] = {
{
	.name = "rfc4106(gcm(aes))",

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

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

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

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

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

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4309(ccm(aes))",

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

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4309(ccm(aes))",

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

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "rfc4309(ccm(aes))",

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

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
};

static struct xfrm_algo_desc aalg_list[] = {
{
	.name = "hmac(digest_null)",
	.compat = "digest_null",

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

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

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

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

	.desc = {
		.sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 256,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "hmac(ripemd160)",
	.compat = "ripemd160",

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

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

	.desc = {
		.sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 128
	}
},
};

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

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

	.desc = {
		.sadb_alg_id =	SADB_EALG_NULL,
		.sadb_alg_ivlen = 0,
		.sadb_alg_minbits = 0,
		.sadb_alg_maxbits = 0
	}
},
{
	.name = "cbc(des)",
	.compat = "des",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 64,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_EALG_DESCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 64,
		.sadb_alg_maxbits = 64
	}
},
{
	.name = "cbc(des3_ede)",
	.compat = "des3_ede",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 192,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_EALG_3DESCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 192,
		.sadb_alg_maxbits = 192
	}
},
{
	.name = "cbc(cast128)",
	.compat = "cast128",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_CASTCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 40,
		.sadb_alg_maxbits = 128
	}
},
{
	.name = "cbc(blowfish)",
	.compat = "blowfish",

	.uinfo = {
		.encr = {
			.blockbits = 64,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 40,
		.sadb_alg_maxbits = 448
	}
},
{
	.name = "cbc(aes)",
	.compat = "aes",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_AESCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "cbc(serpent)",
	.compat = "serpent",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_SERPENTCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256,
	}
},
{
	.name = "cbc(camellia)",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
{
	.name = "cbc(twofish)",
	.compat = "twofish",

	.uinfo = {
		.encr = {
			.blockbits = 128,
			.defkeybits = 128,
		}
	},

	.desc = {
		.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
		.sadb_alg_ivlen = 8,
		.sadb_alg_minbits = 128,
		.sadb_alg_maxbits = 256
	}
},
};

static struct xfrm_algo_desc calg_list[] = {
{
	.name = "deflate",
	.uinfo = {
		.comp = {
			.threshold = 90,
		}
	},
	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
},
{
	.name = "lzs",
	.uinfo = {
		.comp = {
			.threshold = 90,
		}
	},
	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
},
{
	.name = "lzjh",
	.uinfo = {
		.comp = {
			.threshold = 50,
		}
	},
	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
},
};

static inline int aead_entries(void)
{
	return ARRAY_SIZE(aead_list);
}

static inline int aalg_entries(void)
{
	return ARRAY_SIZE(aalg_list);
}

static inline int ealg_entries(void)
{
	return ARRAY_SIZE(ealg_list);
}

static inline int calg_entries(void)
{
	return ARRAY_SIZE(calg_list);
}

struct xfrm_algo_list {
	struct xfrm_algo_desc *algs;
	int entries;
	u32 type;
	u32 mask;
};

static const struct xfrm_algo_list xfrm_aead_list = {
	.algs = aead_list,
	.entries = ARRAY_SIZE(aead_list),
	.type = CRYPTO_ALG_TYPE_AEAD,
	.mask = CRYPTO_ALG_TYPE_MASK,
};

static const struct xfrm_algo_list xfrm_aalg_list = {
	.algs = aalg_list,
	.entries = ARRAY_SIZE(aalg_list),
	.type = CRYPTO_ALG_TYPE_HASH,
	.mask = CRYPTO_ALG_TYPE_HASH_MASK,
};

static const struct xfrm_algo_list xfrm_ealg_list = {
	.algs = ealg_list,
	.entries = ARRAY_SIZE(ealg_list),
	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
	.mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
};

static const struct xfrm_algo_list xfrm_calg_list = {
	.algs = calg_list,
	.entries = ARRAY_SIZE(calg_list),
	.type = CRYPTO_ALG_TYPE_COMPRESS,
	.mask = CRYPTO_ALG_TYPE_MASK,
};

static struct xfrm_algo_desc *xfrm_find_algo(
	const struct xfrm_algo_list *algo_list,
	int match(const struct xfrm_algo_desc *entry, const void *data),
	const void *data, int probe)
{
	struct xfrm_algo_desc *list = algo_list->algs;
	int i, status;

	for (i = 0; i < algo_list->entries; i++) {
		if (!match(list + i, data))
			continue;

		if (list[i].available)
			return &list[i];

		if (!probe)
			break;

		status = crypto_has_alg(list[i].name, algo_list->type,
					algo_list->mask);
		if (!status)
			break;

		list[i].available = status;
		return &list[i];
	}
	return NULL;
}

static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
			     const void *data)
{
	return entry->desc.sadb_alg_id == (unsigned long)data;
}

struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
{
	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
			      (void *)(unsigned long)alg_id, 1);
}
EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);

struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
{
	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
			      (void *)(unsigned long)alg_id, 1);
}
EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);

struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
{
	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
			      (void *)(unsigned long)alg_id, 1);
}
EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);

static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
			       const void *data)
{
	const char *name = data;

	return name && (!strcmp(name, entry->name) ||
			(entry->compat && !strcmp(name, entry->compat)));
}

struct xfrm_algo_desc *xfrm_aalg_get_byname(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(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(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(char *name, int icv_len, int probe)
{
	struct xfrm_aead_name data = {
		.name = name,
		.icvbits = icv_len,
	};

	return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
			      probe);
}
EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);

struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
{
	if (idx >= aalg_entries())
		return NULL;

	return &aalg_list[idx];
}
EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);

struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
{
	if (idx >= ealg_entries())
		return NULL;

	return &ealg_list[idx];
}
EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);

/*
 * Probe for the availability of crypto algorithms, and set the available
 * flag for any algorithms found on the system.  This is typically called by
 * pfkey during userspace SA add, update or register.
 */
void xfrm_probe_algs(void)
{
	int i, status;

	BUG_ON(in_softirq());

	for (i = 0; i < aalg_entries(); i++) {
		status = crypto_has_hash(aalg_list[i].name, 0,
					 CRYPTO_ALG_ASYNC);
		if (aalg_list[i].available != status)
			aalg_list[i].available = status;
	}

	for (i = 0; i < ealg_entries(); i++) {
		status = crypto_has_blkcipher(ealg_list[i].name, 0,
					      CRYPTO_ALG_ASYNC);
		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_auth_supported(void)
{
	int i, n;

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

int xfrm_count_enc_supported(void)
{
	int i, n;

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

/* Move to common area: it is shared with AH. */

int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
		 int offset, int len, icv_update_fn_t icv_update)
{
	int start = skb_headlen(skb);
	int i, copy = start - offset;
	int err;
	struct scatterlist sg;

	/* Checksum header. */
	if (copy > 0) {
		if (copy > len)
			copy = len;

		sg_init_one(&sg, skb->data + offset, copy);

		err = icv_update(desc, &sg, copy);
		if (unlikely(err))
			return err;

		if ((len -= copy) == 0)
			return 0;
		offset += copy;
	}

	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
		int end;

		BUG_TRAP(start <= offset + len);

		end = start + skb_shinfo(skb)->frags[i].size;
		if ((copy = end - offset) > 0) {
			skb_frag_t *frag = &skb_shinfo(skb)->frags[i];

			if (copy > len)
				copy = len;

			sg_init_table(&sg, 1);
			sg_set_page(&sg, frag->page, copy,
				    frag->page_offset + offset-start);

			err = icv_update(desc, &sg, copy);
			if (unlikely(err))
				return err;

			if (!(len -= copy))
				return 0;
			offset += copy;
		}
		start = end;
	}

	if (skb_shinfo(skb)->frag_list) {
		struct sk_buff *list = skb_shinfo(skb)->frag_list;

		for (; list; list = list->next) {
			int end;

			BUG_TRAP(start <= offset + len);

			end = start + list->len;
			if ((copy = end - offset) > 0) {
				if (copy > len)
					copy = len;
				err = skb_icv_walk(list, desc, offset-start,
						   copy, icv_update);
				if (unlikely(err))
					return err;
				if ((len -= copy) == 0)
					return 0;
				offset += copy;
			}
			start = end;
		}
	}
	BUG_ON(len);
	return 0;
}
EXPORT_SYMBOL_GPL(skb_icv_walk);

#if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)

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