[linux.git] / crypto / deflate.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Cryptographic API.
 *
 * Deflate algorithm (RFC 1951), implemented here primarily for use
 * by IPCOMP (RFC 3173 & RFC 2394).
 *
 * Copyright (c) 2003 James Morris <[email protected]>
 *
 * FIXME: deflate transforms will require up to a total of about 436k of kernel
 * memory on i386 (390k for compression, the rest for decompression), as the
 * current zlib kernel code uses a worst case pre-allocation system by default.
 * This needs to be fixed so that the amount of memory required is properly
 * related to the  winbits and memlevel parameters.
 *
 * The default winbits of 11 should suit most packets, and it may be something
 * to configure on a per-tfm basis in the future.
 *
 * Currently, compression history is not maintained between tfm calls, as
 * it is not needed for IPCOMP and keeps the code simpler.  It can be
 * implemented if someone wants it.
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/crypto.h>
#include <linux/zlib.h>
#include <linux/vmalloc.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/net.h>
#include <crypto/internal/scompress.h>

#define DEFLATE_DEF_LEVEL		Z_DEFAULT_COMPRESSION
#define DEFLATE_DEF_WINBITS		11
#define DEFLATE_DEF_MEMLEVEL		MAX_MEM_LEVEL

struct deflate_ctx {
	struct z_stream_s comp_stream;
	struct z_stream_s decomp_stream;
};

static int deflate_comp_init(struct deflate_ctx *ctx, int format)
{
	int ret = 0;
	struct z_stream_s *stream = &ctx->comp_stream;

	stream->workspace = vzalloc(zlib_deflate_workspacesize(
				    MAX_WBITS, MAX_MEM_LEVEL));
	if (!stream->workspace) {
		ret = -ENOMEM;
		goto out;
	}
	if (format)
		ret = zlib_deflateInit(stream, 3);
	else
		ret = zlib_deflateInit2(stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,
					-DEFLATE_DEF_WINBITS,
					DEFLATE_DEF_MEMLEVEL,
					Z_DEFAULT_STRATEGY);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out_free;
	}
out:
	return ret;
out_free:
	vfree(stream->workspace);
	goto out;
}

static int deflate_decomp_init(struct deflate_ctx *ctx, int format)
{
	int ret = 0;
	struct z_stream_s *stream = &ctx->decomp_stream;

	stream->workspace = vzalloc(zlib_inflate_workspacesize());
	if (!stream->workspace) {
		ret = -ENOMEM;
		goto out;
	}
	if (format)
		ret = zlib_inflateInit(stream);
	else
		ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out_free;
	}
out:
	return ret;
out_free:
	vfree(stream->workspace);
	goto out;
}

static void deflate_comp_exit(struct deflate_ctx *ctx)
{
	zlib_deflateEnd(&ctx->comp_stream);
	vfree(ctx->comp_stream.workspace);
}

static void deflate_decomp_exit(struct deflate_ctx *ctx)
{
	zlib_inflateEnd(&ctx->decomp_stream);
	vfree(ctx->decomp_stream.workspace);
}

static int __deflate_init(void *ctx, int format)
{
	int ret;

	ret = deflate_comp_init(ctx, format);
	if (ret)
		goto out;
	ret = deflate_decomp_init(ctx, format);
	if (ret)
		deflate_comp_exit(ctx);
out:
	return ret;
}

static void *gen_deflate_alloc_ctx(struct crypto_scomp *tfm, int format)
{
	struct deflate_ctx *ctx;
	int ret;

	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return ERR_PTR(-ENOMEM);

	ret = __deflate_init(ctx, format);
	if (ret) {
		kfree(ctx);
		return ERR_PTR(ret);
	}

	return ctx;
}

static void *deflate_alloc_ctx(struct crypto_scomp *tfm)
{
	return gen_deflate_alloc_ctx(tfm, 0);
}

static void *zlib_deflate_alloc_ctx(struct crypto_scomp *tfm)
{
	return gen_deflate_alloc_ctx(tfm, 1);
}

static int deflate_init(struct crypto_tfm *tfm)
{
	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);

	return __deflate_init(ctx, 0);
}

static void __deflate_exit(void *ctx)
{
	deflate_comp_exit(ctx);
	deflate_decomp_exit(ctx);
}

static void deflate_free_ctx(struct crypto_scomp *tfm, void *ctx)
{
	__deflate_exit(ctx);
	kfree_sensitive(ctx);
}

static void deflate_exit(struct crypto_tfm *tfm)
{
	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);

	__deflate_exit(ctx);
}

static int __deflate_compress(const u8 *src, unsigned int slen,
			      u8 *dst, unsigned int *dlen, void *ctx)
{
	int ret = 0;
	struct deflate_ctx *dctx = ctx;
	struct z_stream_s *stream = &dctx->comp_stream;

	ret = zlib_deflateReset(stream);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out;
	}

	stream->next_in = (u8 *)src;
	stream->avail_in = slen;
	stream->next_out = (u8 *)dst;
	stream->avail_out = *dlen;

	ret = zlib_deflate(stream, Z_FINISH);
	if (ret != Z_STREAM_END) {
		ret = -EINVAL;
		goto out;
	}
	ret = 0;
	*dlen = stream->total_out;
out:
	return ret;
}

static int deflate_compress(struct crypto_tfm *tfm, const u8 *src,
			    unsigned int slen, u8 *dst, unsigned int *dlen)
{
	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);

	return __deflate_compress(src, slen, dst, dlen, dctx);
}

static int deflate_scompress(struct crypto_scomp *tfm, const u8 *src,
			     unsigned int slen, u8 *dst, unsigned int *dlen,
			     void *ctx)
{
	return __deflate_compress(src, slen, dst, dlen, ctx);
}

static int __deflate_decompress(const u8 *src, unsigned int slen,
				u8 *dst, unsigned int *dlen, void *ctx)
{

	int ret = 0;
	struct deflate_ctx *dctx = ctx;
	struct z_stream_s *stream = &dctx->decomp_stream;

	ret = zlib_inflateReset(stream);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out;
	}

	stream->next_in = (u8 *)src;
	stream->avail_in = slen;
	stream->next_out = (u8 *)dst;
	stream->avail_out = *dlen;

	ret = zlib_inflate(stream, Z_SYNC_FLUSH);
	/*
	 * Work around a bug in zlib, which sometimes wants to taste an extra
	 * byte when being used in the (undocumented) raw deflate mode.
	 * (From USAGI).
	 */
	if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
		u8 zerostuff = 0;
		stream->next_in = &zerostuff;
		stream->avail_in = 1;
		ret = zlib_inflate(stream, Z_FINISH);
	}
	if (ret != Z_STREAM_END) {
		ret = -EINVAL;
		goto out;
	}
	ret = 0;
	*dlen = stream->total_out;
out:
	return ret;
}

static int deflate_decompress(struct crypto_tfm *tfm, const u8 *src,
			      unsigned int slen, u8 *dst, unsigned int *dlen)
{
	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);

	return __deflate_decompress(src, slen, dst, dlen, dctx);
}

static int deflate_sdecompress(struct crypto_scomp *tfm, const u8 *src,
			       unsigned int slen, u8 *dst, unsigned int *dlen,
			       void *ctx)
{
	return __deflate_decompress(src, slen, dst, dlen, ctx);
}

static struct crypto_alg alg = {
	.cra_name		= "deflate",
	.cra_driver_name	= "deflate-generic",
	.cra_flags		= CRYPTO_ALG_TYPE_COMPRESS,
	.cra_ctxsize		= sizeof(struct deflate_ctx),
	.cra_module		= THIS_MODULE,
	.cra_init		= deflate_init,
	.cra_exit		= deflate_exit,
	.cra_u			= { .compress = {
	.coa_compress 		= deflate_compress,
	.coa_decompress  	= deflate_decompress } }
};

static struct scomp_alg scomp[] = { {
	.alloc_ctx		= deflate_alloc_ctx,
	.free_ctx		= deflate_free_ctx,
	.compress		= deflate_scompress,
	.decompress		= deflate_sdecompress,
	.base			= {
		.cra_name	= "deflate",
		.cra_driver_name = "deflate-scomp",
		.cra_module	 = THIS_MODULE,
	}
}, {
	.alloc_ctx		= zlib_deflate_alloc_ctx,
	.free_ctx		= deflate_free_ctx,
	.compress		= deflate_scompress,
	.decompress		= deflate_sdecompress,
	.base			= {
		.cra_name	= "zlib-deflate",
		.cra_driver_name = "zlib-deflate-scomp",
		.cra_module	 = THIS_MODULE,
	}
} };

static int __init deflate_mod_init(void)
{
	int ret;

	ret = crypto_register_alg(&alg);
	if (ret)
		return ret;

	ret = crypto_register_scomps(scomp, ARRAY_SIZE(scomp));
	if (ret) {
		crypto_unregister_alg(&alg);
		return ret;
	}

	return ret;
}

static void __exit deflate_mod_fini(void)
{
	crypto_unregister_alg(&alg);
	crypto_unregister_scomps(scomp, ARRAY_SIZE(scomp));
}

subsys_initcall(deflate_mod_init);
module_exit(deflate_mod_fini);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
MODULE_AUTHOR("James Morris <[email protected]>");
MODULE_ALIAS_CRYPTO("deflate");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
9472d763	2	/*
1da177e4 LT	3	* Cryptographic API.
	4	*
	5	* Deflate algorithm (RFC 1951), implemented here primarily for use
	6	* by IPCOMP (RFC 3173 & RFC 2394).
	7	*
	8	* Copyright (c) 2003 James Morris <[email protected]>
9472d763	9	*
1da177e4 LT	10	* FIXME: deflate transforms will require up to a total of about 436k of kernel
	11	* memory on i386 (390k for compression, the rest for decompression), as the
	12	* current zlib kernel code uses a worst case pre-allocation system by default.
	13	* This needs to be fixed so that the amount of memory required is properly
	14	* related to the winbits and memlevel parameters.
	15	*
	16	* The default winbits of 11 should suit most packets, and it may be something
	17	* to configure on a per-tfm basis in the future.
	18	*
	19	* Currently, compression history is not maintained between tfm calls, as
	20	* it is not needed for IPCOMP and keeps the code simpler. It can be
	21	* implemented if someone wants it.
	22	*/
	23	#include <linux/init.h>
	24	#include <linux/module.h>
	25	#include <linux/crypto.h>
	26	#include <linux/zlib.h>
	27	#include <linux/vmalloc.h>
	28	#include <linux/interrupt.h>
	29	#include <linux/mm.h>
	30	#include <linux/net.h>
f6ded09d	31	#include <crypto/internal/scompress.h>
1da177e4 LT	32
	33	#define DEFLATE_DEF_LEVEL Z_DEFAULT_COMPRESSION
	34	#define DEFLATE_DEF_WINBITS 11
	35	#define DEFLATE_DEF_MEMLEVEL MAX_MEM_LEVEL
	36
	37	struct deflate_ctx {
	38	struct z_stream_s comp_stream;
	39	struct z_stream_s decomp_stream;
	40	};
	41
a368f43d	42	static int deflate_comp_init(struct deflate_ctx *ctx, int format)
1da177e4 LT	43	{
	44	int ret = 0;
	45	struct z_stream_s *stream = &ctx->comp_stream;
	46
565d76cb	47	stream->workspace = vzalloc(zlib_deflate_workspacesize(
a368f43d	48	MAX_WBITS, MAX_MEM_LEVEL));
9472d763	49	if (!stream->workspace) {
1da177e4 LT	50	ret = -ENOMEM;
	51	goto out;
	52	}
a368f43d GC	53	if (format)
	54	ret = zlib_deflateInit(stream, 3);
	55	else
	56	ret = zlib_deflateInit2(stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,
	57	-DEFLATE_DEF_WINBITS,
	58	DEFLATE_DEF_MEMLEVEL,
	59	Z_DEFAULT_STRATEGY);
1da177e4 LT	60	if (ret != Z_OK) {
	61	ret = -EINVAL;
	62	goto out_free;
	63	}
9472d763	64	out:
1da177e4 LT	65	return ret;
	66	out_free:
	67	vfree(stream->workspace);
	68	goto out;
	69	}
	70
a368f43d	71	static int deflate_decomp_init(struct deflate_ctx *ctx, int format)
1da177e4 LT	72	{
	73	int ret = 0;
	74	struct z_stream_s *stream = &ctx->decomp_stream;
	75
7ab24bfd	76	stream->workspace = vzalloc(zlib_inflate_workspacesize());
9472d763	77	if (!stream->workspace) {
1da177e4 LT	78	ret = -ENOMEM;
	79	goto out;
	80	}
a368f43d GC	81	if (format)
	82	ret = zlib_inflateInit(stream);
	83	else
	84	ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS);
1da177e4 LT	85	if (ret != Z_OK) {
	86	ret = -EINVAL;
	87	goto out_free;
	88	}
	89	out:
	90	return ret;
	91	out_free:
7ab24bfd	92	vfree(stream->workspace);
1da177e4 LT	93	goto out;
	94	}
	95
	96	static void deflate_comp_exit(struct deflate_ctx *ctx)
	97	{
9ffb7146	98	zlib_deflateEnd(&ctx->comp_stream);
1da177e4 LT	99	vfree(ctx->comp_stream.workspace);
	100	}
	101
	102	static void deflate_decomp_exit(struct deflate_ctx *ctx)
	103	{
9ffb7146	104	zlib_inflateEnd(&ctx->decomp_stream);
7ab24bfd	105	vfree(ctx->decomp_stream.workspace);
1da177e4 LT	106	}
1da177e4 LT	107
a368f43d	108	static int __deflate_init(void *ctx, int format)
1da177e4 LT	109	{
1da177e4 LT	110	int ret;
9472d763	111
a368f43d	112	ret = deflate_comp_init(ctx, format);
1da177e4 LT	113	if (ret)
1da177e4 LT	114	goto out;
a368f43d	115	ret = deflate_decomp_init(ctx, format);
1da177e4 LT	116	if (ret)
	117	deflate_comp_exit(ctx);
	118	out:
	119	return ret;
	120	}
	121
a368f43d	122	static void gen_deflate_alloc_ctx(struct crypto_scomp tfm, int format)
f6ded09d GC	123	{
	124	struct deflate_ctx *ctx;
	125	int ret;
	126
	127	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	128	if (!ctx)
	129	return ERR_PTR(-ENOMEM);
	130
a368f43d	131	ret = __deflate_init(ctx, format);
f6ded09d GC	132	if (ret) {
	133	kfree(ctx);
	134	return ERR_PTR(ret);
	135	}
	136
	137	return ctx;
	138	}
	139
a368f43d GC	140	static void deflate_alloc_ctx(struct crypto_scomp tfm)
	141	{
	142	return gen_deflate_alloc_ctx(tfm, 0);
	143	}
	144
	145	static void zlib_deflate_alloc_ctx(struct crypto_scomp tfm)
	146	{
	147	return gen_deflate_alloc_ctx(tfm, 1);
	148	}
	149
f6ded09d	150	static int deflate_init(struct crypto_tfm *tfm)
1da177e4	151	{
6c2bb98b HX	152	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
6c2bb98b HX	153
a368f43d	154	return __deflate_init(ctx, 0);
f6ded09d GC	155	}
	156
	157	static void __deflate_exit(void *ctx)
	158	{
1da177e4 LT	159	deflate_comp_exit(ctx);
	160	deflate_decomp_exit(ctx);
	161	}
	162
f6ded09d GC	163	static void deflate_free_ctx(struct crypto_scomp tfm, void ctx)
	164	{
	165	__deflate_exit(ctx);
453431a5	166	kfree_sensitive(ctx);
f6ded09d GC	167	}
	168
	169	static void deflate_exit(struct crypto_tfm *tfm)
	170	{
	171	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
	172
	173	__deflate_exit(ctx);
	174	}
	175
	176	static int __deflate_compress(const u8 *src, unsigned int slen,
	177	u8 dst, unsigned int dlen, void *ctx)
1da177e4 LT	178	{
1da177e4 LT	179	int ret = 0;
f6ded09d	180	struct deflate_ctx *dctx = ctx;
1da177e4 LT	181	struct z_stream_s *stream = &dctx->comp_stream;
	182
	183	ret = zlib_deflateReset(stream);
	184	if (ret != Z_OK) {
	185	ret = -EINVAL;
	186	goto out;
	187	}
	188
	189	stream->next_in = (u8 *)src;
	190	stream->avail_in = slen;
	191	stream->next_out = (u8 *)dst;
	192	stream->avail_out = *dlen;
	193
	194	ret = zlib_deflate(stream, Z_FINISH);
	195	if (ret != Z_STREAM_END) {
	196	ret = -EINVAL;
	197	goto out;
	198	}
	199	ret = 0;
	200	*dlen = stream->total_out;
	201	out:
	202	return ret;
	203	}
9472d763	204
f6ded09d GC	205	static int deflate_compress(struct crypto_tfm tfm, const u8 src,
	206	unsigned int slen, u8 dst, unsigned int dlen)
	207	{
	208	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
	209
	210	return __deflate_compress(src, slen, dst, dlen, dctx);
	211	}
	212
	213	static int deflate_scompress(struct crypto_scomp tfm, const u8 src,
	214	unsigned int slen, u8 dst, unsigned int dlen,
	215	void *ctx)
	216	{
	217	return __deflate_compress(src, slen, dst, dlen, ctx);
	218	}
	219
	220	static int __deflate_decompress(const u8 *src, unsigned int slen,
	221	u8 dst, unsigned int dlen, void *ctx)
1da177e4	222	{
9472d763	223
1da177e4	224	int ret = 0;
f6ded09d	225	struct deflate_ctx *dctx = ctx;
1da177e4 LT	226	struct z_stream_s *stream = &dctx->decomp_stream;
	227
	228	ret = zlib_inflateReset(stream);
	229	if (ret != Z_OK) {
	230	ret = -EINVAL;
	231	goto out;
	232	}
	233
	234	stream->next_in = (u8 *)src;
	235	stream->avail_in = slen;
	236	stream->next_out = (u8 *)dst;
	237	stream->avail_out = *dlen;
	238
	239	ret = zlib_inflate(stream, Z_SYNC_FLUSH);
	240	/*
	241	* Work around a bug in zlib, which sometimes wants to taste an extra
	242	* byte when being used in the (undocumented) raw deflate mode.
	243	* (From USAGI).
	244	*/
	245	if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
	246	u8 zerostuff = 0;
	247	stream->next_in = &zerostuff;
9472d763	248	stream->avail_in = 1;
1da177e4 LT	249	ret = zlib_inflate(stream, Z_FINISH);
	250	}
	251	if (ret != Z_STREAM_END) {
	252	ret = -EINVAL;
	253	goto out;
	254	}
	255	ret = 0;
	256	*dlen = stream->total_out;
	257	out:
	258	return ret;
	259	}
	260
f6ded09d GC	261	static int deflate_decompress(struct crypto_tfm tfm, const u8 src,
	262	unsigned int slen, u8 dst, unsigned int dlen)
	263	{
	264	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
	265
	266	return __deflate_decompress(src, slen, dst, dlen, dctx);
	267	}
	268
	269	static int deflate_sdecompress(struct crypto_scomp tfm, const u8 src,
	270	unsigned int slen, u8 dst, unsigned int dlen,
	271	void *ctx)
	272	{
	273	return __deflate_decompress(src, slen, dst, dlen, ctx);
	274	}
	275
1da177e4 LT	276	static struct crypto_alg alg = {
1da177e4 LT	277	.cra_name = "deflate",
d6ebf528	278	.cra_driver_name = "deflate-generic",
1da177e4 LT	279	.cra_flags = CRYPTO_ALG_TYPE_COMPRESS,
	280	.cra_ctxsize = sizeof(struct deflate_ctx),
	281	.cra_module = THIS_MODULE,
c7fc0599 HX	282	.cra_init = deflate_init,
c7fc0599 HX	283	.cra_exit = deflate_exit,
1da177e4	284	.cra_u = { .compress = {
1da177e4 LT	285	.coa_compress = deflate_compress,
	286	.coa_decompress = deflate_decompress } }
	287	};
	288
a368f43d	289	static struct scomp_alg scomp[] = { {
f6ded09d GC	290	.alloc_ctx = deflate_alloc_ctx,
	291	.free_ctx = deflate_free_ctx,
	292	.compress = deflate_scompress,
	293	.decompress = deflate_sdecompress,
	294	.base = {
	295	.cra_name = "deflate",
	296	.cra_driver_name = "deflate-scomp",
	297	.cra_module = THIS_MODULE,
	298	}
a368f43d GC	299	}, {
	300	.alloc_ctx = zlib_deflate_alloc_ctx,
	301	.free_ctx = deflate_free_ctx,
	302	.compress = deflate_scompress,
	303	.decompress = deflate_sdecompress,
	304	.base = {
	305	.cra_name = "zlib-deflate",
	306	.cra_driver_name = "zlib-deflate-scomp",
	307	.cra_module = THIS_MODULE,
	308	}
	309	} };
f6ded09d	310
3af5b90b	311	static int __init deflate_mod_init(void)
1da177e4	312	{
f6ded09d GC	313	int ret;
	314
	315	ret = crypto_register_alg(&alg);
	316	if (ret)
	317	return ret;
	318
a368f43d	319	ret = crypto_register_scomps(scomp, ARRAY_SIZE(scomp));
f6ded09d GC	320	if (ret) {
	321	crypto_unregister_alg(&alg);
	322	return ret;
	323	}
	324
	325	return ret;
1da177e4 LT	326	}
1da177e4 LT	327
3af5b90b	328	static void __exit deflate_mod_fini(void)
1da177e4 LT	329	{
1da177e4 LT	330	crypto_unregister_alg(&alg);
a368f43d	331	crypto_unregister_scomps(scomp, ARRAY_SIZE(scomp));
1da177e4 LT	332	}
1da177e4 LT	333
c4741b23	334	subsys_initcall(deflate_mod_init);
3af5b90b	335	module_exit(deflate_mod_fini);
1da177e4 LT	336
	337	MODULE_LICENSE("GPL");
	338	MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
	339	MODULE_AUTHOR("James Morris <[email protected]>");
5d26a105	340	MODULE_ALIAS_CRYPTO("deflate");