[mirror_ubuntu-jammy-kernel.git] / drivers / block / cryptoloop.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
   Linux loop encryption enabling module

   Copyright (C)  2002 Herbert Valerio Riedel <hvr@gnu.org>
   Copyright (C)  2003 Fruhwirth Clemens <clemens@endorphin.org>

 */

#include <linux/module.h>

#include <crypto/skcipher.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/blkdev.h>
#include <linux/scatterlist.h>
#include <linux/uaccess.h>
#include "loop.h"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("loop blockdevice transferfunction adaptor / CryptoAPI");
MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");

#define LOOP_IV_SECTOR_BITS 9
#define LOOP_IV_SECTOR_SIZE (1 << LOOP_IV_SECTOR_BITS)

static int
cryptoloop_init(struct loop_device *lo, const struct loop_info64 *info)
{
	int err = -EINVAL;
	int cipher_len;
	int mode_len;
	char cms[LO_NAME_SIZE];			/* cipher-mode string */
	char *mode;
	char *cmsp = cms;			/* c-m string pointer */
	struct crypto_sync_skcipher *tfm;

	/* encryption breaks for non sector aligned offsets */

	if (info->lo_offset % LOOP_IV_SECTOR_SIZE)
		goto out;

	strncpy(cms, info->lo_crypt_name, LO_NAME_SIZE);
	cms[LO_NAME_SIZE - 1] = 0;

	cipher_len = strcspn(cmsp, "-");

	mode = cmsp + cipher_len;
	mode_len = 0;
	if (*mode) {
		mode++;
		mode_len = strcspn(mode, "-");
	}

	if (!mode_len) {
		mode = "cbc";
		mode_len = 3;
	}

	if (cipher_len + mode_len + 3 > LO_NAME_SIZE)
		return -EINVAL;

	memmove(cms, mode, mode_len);
	cmsp = cms + mode_len;
	*cmsp++ = '(';
	memcpy(cmsp, info->lo_crypt_name, cipher_len);
	cmsp += cipher_len;
	*cmsp++ = ')';
	*cmsp = 0;

	tfm = crypto_alloc_sync_skcipher(cms, 0, 0);
	if (IS_ERR(tfm))
		return PTR_ERR(tfm);

	err = crypto_sync_skcipher_setkey(tfm, info->lo_encrypt_key,
					  info->lo_encrypt_key_size);

	if (err != 0)
		goto out_free_tfm;

	lo->key_data = tfm;
	return 0;

 out_free_tfm:
	crypto_free_sync_skcipher(tfm);

 out:
	return err;
}


typedef int (*encdec_cbc_t)(struct skcipher_request *req);

static int
cryptoloop_transfer(struct loop_device *lo, int cmd,
		    struct page *raw_page, unsigned raw_off,
		    struct page *loop_page, unsigned loop_off,
		    int size, sector_t IV)
{
	struct crypto_sync_skcipher *tfm = lo->key_data;
	SYNC_SKCIPHER_REQUEST_ON_STACK(req, tfm);
	struct scatterlist sg_out;
	struct scatterlist sg_in;

	encdec_cbc_t encdecfunc;
	struct page *in_page, *out_page;
	unsigned in_offs, out_offs;
	int err;

	skcipher_request_set_sync_tfm(req, tfm);
	skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
				      NULL, NULL);

	sg_init_table(&sg_out, 1);
	sg_init_table(&sg_in, 1);

	if (cmd == READ) {
		in_page = raw_page;
		in_offs = raw_off;
		out_page = loop_page;
		out_offs = loop_off;
		encdecfunc = crypto_skcipher_decrypt;
	} else {
		in_page = loop_page;
		in_offs = loop_off;
		out_page = raw_page;
		out_offs = raw_off;
		encdecfunc = crypto_skcipher_encrypt;
	}

	while (size > 0) {
		const int sz = min(size, LOOP_IV_SECTOR_SIZE);
		u32 iv[4] = { 0, };
		iv[0] = cpu_to_le32(IV & 0xffffffff);

		sg_set_page(&sg_in, in_page, sz, in_offs);
		sg_set_page(&sg_out, out_page, sz, out_offs);

		skcipher_request_set_crypt(req, &sg_in, &sg_out, sz, iv);
		err = encdecfunc(req);
		if (err)
			goto out;

		IV++;
		size -= sz;
		in_offs += sz;
		out_offs += sz;
	}

	err = 0;

out:
	skcipher_request_zero(req);
	return err;
}

static int
cryptoloop_ioctl(struct loop_device *lo, int cmd, unsigned long arg)
{
	return -EINVAL;
}

static int
cryptoloop_release(struct loop_device *lo)
{
	struct crypto_sync_skcipher *tfm = lo->key_data;
	if (tfm != NULL) {
		crypto_free_sync_skcipher(tfm);
		lo->key_data = NULL;
		return 0;
	}
	printk(KERN_ERR "cryptoloop_release(): tfm == NULL?\n");
	return -EINVAL;
}

static struct loop_func_table cryptoloop_funcs = {
	.number = LO_CRYPT_CRYPTOAPI,
	.init = cryptoloop_init,
	.ioctl = cryptoloop_ioctl,
	.transfer = cryptoloop_transfer,
	.release = cryptoloop_release,
	.owner = THIS_MODULE
};

static int __init
init_cryptoloop(void)
{
	int rc = loop_register_transfer(&cryptoloop_funcs);

	if (rc)
		printk(KERN_ERR "cryptoloop: loop_register_transfer failed\n");
	return rc;
}

static void __exit
cleanup_cryptoloop(void)
{
	if (loop_unregister_transfer(LO_CRYPT_CRYPTOAPI))
		printk(KERN_ERR
			"cryptoloop: loop_unregister_transfer failed\n");
}

module_init(init_cryptoloop);
module_exit(cleanup_cryptoloop);
Commit	Line	Data
1b9391e3	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	Linux loop encryption enabling module
	4
	5	Copyright (C) 2002 Herbert Valerio Riedel <hvr@gnu.org>
	6	Copyright (C) 2003 Fruhwirth Clemens <clemens@endorphin.org>
	7
1da177e4 LT	8	*/
	9
	10	#include <linux/module.h>
	11
84a2c931	12	#include <crypto/skcipher.h>
1da177e4 LT	13	#include <linux/init.h>
1da177e4 LT	14	#include <linux/string.h>
1da177e4	15	#include <linux/blkdev.h>
45711f1a	16	#include <linux/scatterlist.h>
7c0f6ba6	17	#include <linux/uaccess.h>
83a87611	18	#include "loop.h"
1da177e4 LT	19
	20	MODULE_LICENSE("GPL");
	21	MODULE_DESCRIPTION("loop blockdevice transferfunction adaptor / CryptoAPI");
	22	MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
	23
	24	#define LOOP_IV_SECTOR_BITS 9
	25	#define LOOP_IV_SECTOR_SIZE (1 << LOOP_IV_SECTOR_BITS)
	26
	27	static int
	28	cryptoloop_init(struct loop_device lo, const struct loop_info64 info)
	29	{
	30	int err = -EINVAL;
69affe7f HX	31	int cipher_len;
69affe7f HX	32	int mode_len;
1da177e4	33	char cms[LO_NAME_SIZE]; /* cipher-mode string */
1da177e4 LT	34	char *mode;
1da177e4 LT	35	char cmsp = cms; / c-m string pointer */
dc568baf	36	struct crypto_sync_skcipher *tfm;
1da177e4 LT	37
	38	/* encryption breaks for non sector aligned offsets */
	39
	40	if (info->lo_offset % LOOP_IV_SECTOR_SIZE)
	41	goto out;
	42
	43	strncpy(cms, info->lo_crypt_name, LO_NAME_SIZE);
	44	cms[LO_NAME_SIZE - 1] = 0;
69affe7f	45
69affe7f HX	46	cipher_len = strcspn(cmsp, "-");
	47
	48	mode = cmsp + cipher_len;
	49	mode_len = 0;
	50	if (*mode) {
	51	mode++;
	52	mode_len = strcspn(mode, "-");
	53	}
	54
	55	if (!mode_len) {
	56	mode = "cbc";
	57	mode_len = 3;
	58	}
	59
	60	if (cipher_len + mode_len + 3 > LO_NAME_SIZE)
1da177e4 LT	61	return -EINVAL;
1da177e4 LT	62
69affe7f HX	63	memmove(cms, mode, mode_len);
	64	cmsp = cms + mode_len;
	65	*cmsp++ = '(';
	66	memcpy(cmsp, info->lo_crypt_name, cipher_len);
	67	cmsp += cipher_len;
	68	*cmsp++ = ')';
	69	*cmsp = 0;
	70
dc568baf	71	tfm = crypto_alloc_sync_skcipher(cms, 0, 0);
69affe7f HX	72	if (IS_ERR(tfm))
	73	return PTR_ERR(tfm);
	74
dc568baf KC	75	err = crypto_sync_skcipher_setkey(tfm, info->lo_encrypt_key,
	76	info->lo_encrypt_key_size);
	77
1da177e4 LT	78	if (err != 0)
	79	goto out_free_tfm;
	80
	81	lo->key_data = tfm;
	82	return 0;
	83
	84	out_free_tfm:
dc568baf	85	crypto_free_sync_skcipher(tfm);
1da177e4 LT	86
	87	out:
	88	return err;
	89	}
	90
	91
84a2c931	92	typedef int (encdec_cbc_t)(struct skcipher_request req);
1da177e4	93
1da177e4	94	static int
69affe7f HX	95	cryptoloop_transfer(struct loop_device *lo, int cmd,
	96	struct page *raw_page, unsigned raw_off,
	97	struct page *loop_page, unsigned loop_off,
	98	int size, sector_t IV)
1da177e4	99	{
dc568baf KC	100	struct crypto_sync_skcipher *tfm = lo->key_data;
dc568baf KC	101	SYNC_SKCIPHER_REQUEST_ON_STACK(req, tfm);
45711f1a JA	102	struct scatterlist sg_out;
45711f1a JA	103	struct scatterlist sg_in;
1da177e4 LT	104
	105	encdec_cbc_t encdecfunc;
	106	struct page in_page, out_page;
	107	unsigned in_offs, out_offs;
69affe7f	108	int err;
1da177e4	109
dc568baf	110	skcipher_request_set_sync_tfm(req, tfm);
84a2c931 HX	111	skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
	112	NULL, NULL);
	113
45711f1a JA	114	sg_init_table(&sg_out, 1);
	115	sg_init_table(&sg_in, 1);
	116
1da177e4 LT	117	if (cmd == READ) {
	118	in_page = raw_page;
	119	in_offs = raw_off;
	120	out_page = loop_page;
	121	out_offs = loop_off;
84a2c931	122	encdecfunc = crypto_skcipher_decrypt;
1da177e4 LT	123	} else {
	124	in_page = loop_page;
	125	in_offs = loop_off;
	126	out_page = raw_page;
	127	out_offs = raw_off;
84a2c931	128	encdecfunc = crypto_skcipher_encrypt;
1da177e4 LT	129	}
	130
	131	while (size > 0) {
	132	const int sz = min(size, LOOP_IV_SECTOR_SIZE);
	133	u32 iv[4] = { 0, };
	134	iv[0] = cpu_to_le32(IV & 0xffffffff);
	135
642f1490 JA	136	sg_set_page(&sg_in, in_page, sz, in_offs);
642f1490 JA	137	sg_set_page(&sg_out, out_page, sz, out_offs);
1da177e4	138
84a2c931 HX	139	skcipher_request_set_crypt(req, &sg_in, &sg_out, sz, iv);
84a2c931 HX	140	err = encdecfunc(req);
69affe7f	141	if (err)
84a2c931	142	goto out;
1da177e4 LT	143
	144	IV++;
	145	size -= sz;
	146	in_offs += sz;
	147	out_offs += sz;
	148	}
	149
84a2c931 HX	150	err = 0;
	151
	152	out:
	153	skcipher_request_zero(req);
	154	return err;
1da177e4 LT	155	}
1da177e4 LT	156
1da177e4 LT	157	static int
	158	cryptoloop_ioctl(struct loop_device *lo, int cmd, unsigned long arg)
	159	{
	160	return -EINVAL;
	161	}
	162
	163	static int
	164	cryptoloop_release(struct loop_device *lo)
	165	{
dc568baf	166	struct crypto_sync_skcipher *tfm = lo->key_data;
1da177e4	167	if (tfm != NULL) {
dc568baf	168	crypto_free_sync_skcipher(tfm);
1da177e4 LT	169	lo->key_data = NULL;
	170	return 0;
	171	}
	172	printk(KERN_ERR "cryptoloop_release(): tfm == NULL?\n");
	173	return -EINVAL;
	174	}
	175
	176	static struct loop_func_table cryptoloop_funcs = {
	177	.number = LO_CRYPT_CRYPTOAPI,
	178	.init = cryptoloop_init,
	179	.ioctl = cryptoloop_ioctl,
	180	.transfer = cryptoloop_transfer,
	181	.release = cryptoloop_release,
	182	.owner = THIS_MODULE
	183	};
	184
	185	static int __init
	186	init_cryptoloop(void)
	187	{
	188	int rc = loop_register_transfer(&cryptoloop_funcs);
	189
	190	if (rc)
	191	printk(KERN_ERR "cryptoloop: loop_register_transfer failed\n");
	192	return rc;
	193	}
	194
	195	static void __exit
	196	cleanup_cryptoloop(void)
	197	{
	198	if (loop_unregister_transfer(LO_CRYPT_CRYPTOAPI))
	199	printk(KERN_ERR
	200	"cryptoloop: loop_unregister_transfer failed\n");
	201	}
	202
	203	module_init(init_cryptoloop);
	204	module_exit(cleanup_cryptoloop);