[linux-2.6-block.git] / crypto / bpf_crypto_skcipher.c

// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2024 Meta, Inc */
#include <linux/types.h>
#include <linux/module.h>
#include <linux/bpf_crypto.h>
#include <crypto/skcipher.h>

static void *bpf_crypto_lskcipher_alloc_tfm(const char *algo)
{
	return crypto_alloc_lskcipher(algo, 0, 0);
}

static void bpf_crypto_lskcipher_free_tfm(void *tfm)
{
	crypto_free_lskcipher(tfm);
}

static int bpf_crypto_lskcipher_has_algo(const char *algo)
{
	return crypto_has_skcipher(algo, CRYPTO_ALG_TYPE_LSKCIPHER, CRYPTO_ALG_TYPE_MASK);
}

static int bpf_crypto_lskcipher_setkey(void *tfm, const u8 *key, unsigned int keylen)
{
	return crypto_lskcipher_setkey(tfm, key, keylen);
}

static u32 bpf_crypto_lskcipher_get_flags(void *tfm)
{
	return crypto_lskcipher_get_flags(tfm);
}

static unsigned int bpf_crypto_lskcipher_ivsize(void *tfm)
{
	return crypto_lskcipher_ivsize(tfm);
}

static unsigned int bpf_crypto_lskcipher_statesize(void *tfm)
{
	return crypto_lskcipher_statesize(tfm);
}

static int bpf_crypto_lskcipher_encrypt(void *tfm, const u8 *src, u8 *dst,
					unsigned int len, u8 *siv)
{
	return crypto_lskcipher_encrypt(tfm, src, dst, len, siv);
}

static int bpf_crypto_lskcipher_decrypt(void *tfm, const u8 *src, u8 *dst,
					unsigned int len, u8 *siv)
{
	return crypto_lskcipher_decrypt(tfm, src, dst, len, siv);
}

static const struct bpf_crypto_type bpf_crypto_lskcipher_type = {
	.alloc_tfm	= bpf_crypto_lskcipher_alloc_tfm,
	.free_tfm	= bpf_crypto_lskcipher_free_tfm,
	.has_algo	= bpf_crypto_lskcipher_has_algo,
	.setkey		= bpf_crypto_lskcipher_setkey,
	.encrypt	= bpf_crypto_lskcipher_encrypt,
	.decrypt	= bpf_crypto_lskcipher_decrypt,
	.ivsize		= bpf_crypto_lskcipher_ivsize,
	.statesize	= bpf_crypto_lskcipher_statesize,
	.get_flags	= bpf_crypto_lskcipher_get_flags,
	.owner		= THIS_MODULE,
	.name		= "skcipher",
};

static int __init bpf_crypto_skcipher_init(void)
{
	return bpf_crypto_register_type(&bpf_crypto_lskcipher_type);
}

static void __exit bpf_crypto_skcipher_exit(void)
{
	int err = bpf_crypto_unregister_type(&bpf_crypto_lskcipher_type);
	WARN_ON_ONCE(err);
}

module_init(bpf_crypto_skcipher_init);
module_exit(bpf_crypto_skcipher_exit);
MODULE_LICENSE("GPL");
Commit	Line	Data
fda4f712 VF	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/* Copyright (c) 2024 Meta, Inc */
	3	#include <linux/types.h>
	4	#include <linux/module.h>
	5	#include <linux/bpf_crypto.h>
	6	#include <crypto/skcipher.h>
	7
	8	static void bpf_crypto_lskcipher_alloc_tfm(const char algo)
	9	{
	10	return crypto_alloc_lskcipher(algo, 0, 0);
	11	}
	12
	13	static void bpf_crypto_lskcipher_free_tfm(void *tfm)
	14	{
	15	crypto_free_lskcipher(tfm);
	16	}
	17
	18	static int bpf_crypto_lskcipher_has_algo(const char *algo)
	19	{
	20	return crypto_has_skcipher(algo, CRYPTO_ALG_TYPE_LSKCIPHER, CRYPTO_ALG_TYPE_MASK);
	21	}
	22
	23	static int bpf_crypto_lskcipher_setkey(void tfm, const u8 key, unsigned int keylen)
	24	{
	25	return crypto_lskcipher_setkey(tfm, key, keylen);
	26	}
	27
	28	static u32 bpf_crypto_lskcipher_get_flags(void *tfm)
	29	{
	30	return crypto_lskcipher_get_flags(tfm);
	31	}
	32
	33	static unsigned int bpf_crypto_lskcipher_ivsize(void *tfm)
	34	{
	35	return crypto_lskcipher_ivsize(tfm);
	36	}
	37
	38	static unsigned int bpf_crypto_lskcipher_statesize(void *tfm)
	39	{
	40	return crypto_lskcipher_statesize(tfm);
	41	}
	42
	43	static int bpf_crypto_lskcipher_encrypt(void tfm, const u8 src, u8 *dst,
	44	unsigned int len, u8 *siv)
	45	{
	46	return crypto_lskcipher_encrypt(tfm, src, dst, len, siv);
	47	}
	48
	49	static int bpf_crypto_lskcipher_decrypt(void tfm, const u8 src, u8 *dst,
	50	unsigned int len, u8 *siv)
	51	{
	52	return crypto_lskcipher_decrypt(tfm, src, dst, len, siv);
	53	}
	54
	55	static const struct bpf_crypto_type bpf_crypto_lskcipher_type = {
	56	.alloc_tfm = bpf_crypto_lskcipher_alloc_tfm,
	57	.free_tfm = bpf_crypto_lskcipher_free_tfm,
	58	.has_algo = bpf_crypto_lskcipher_has_algo,
	59	.setkey = bpf_crypto_lskcipher_setkey,
	60	.encrypt = bpf_crypto_lskcipher_encrypt,
	61	.decrypt = bpf_crypto_lskcipher_decrypt,
	62	.ivsize = bpf_crypto_lskcipher_ivsize,
	63	.statesize = bpf_crypto_lskcipher_statesize,
	64	.get_flags = bpf_crypto_lskcipher_get_flags,
65	.owner = THIS_MODULE,
66	.name = "skcipher",
67	};
68
69	static int __init bpf_crypto_skcipher_init(void)
70	{
71	return bpf_crypto_register_type(&bpf_crypto_lskcipher_type);
72	}
73
74	static void __exit bpf_crypto_skcipher_exit(void)
75	{
76	int err = bpf_crypto_unregister_type(&bpf_crypto_lskcipher_type);
77	WARN_ON_ONCE(err);
78	}
79
80	module_init(bpf_crypto_skcipher_init);
81	module_exit(bpf_crypto_skcipher_exit);
82	MODULE_LICENSE("GPL");