[thirdparty/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 <jmorris@intercode.com.au>
 *
 * 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 ret = 0;
	struct z_stream_s *stream = &ctx->comp_stream;

	stream->workspace = vzalloc(zlib_deflate_workspacesize(
				    -DEFLATE_DEF_WINBITS, MAX_MEM_LEVEL));
	if (!stream->workspace) {
		ret = -ENOMEM;
		goto out;
	}
	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 ret = 0;
	struct z_stream_s *stream = &ctx->decomp_stream;

	stream->workspace = vzalloc(zlib_inflate_workspacesize());
	if (!stream->workspace) {
		ret = -ENOMEM;
		goto out;
	}
	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 ret;

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

static void *deflate_alloc_ctx(struct crypto_scomp *tfm)
{
	struct deflate_ctx *ctx;
	int ret;

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

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

	return ctx;
}

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

	return __deflate_init(ctx);
}

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

static int __init deflate_mod_init(void)
{
	int ret;

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

	ret = crypto_register_scomp(&scomp);
	if (ret) {
		crypto_unregister_alg(&alg);
		return ret;
	}

	return ret;
}

static void __exit deflate_mod_fini(void)
{
	crypto_unregister_alg(&alg);
	crypto_unregister_scomp(&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 <jmorris@intercode.com.au>");
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 <jmorris@intercode.com.au>
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
62a465c2	42	static int deflate_comp_init(struct deflate_ctx *ctx)
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(
62a465c2	48	-DEFLATE_DEF_WINBITS, MAX_MEM_LEVEL));
9472d763	49	if (!stream->workspace) {
1da177e4 LT	50	ret = -ENOMEM;
	51	goto out;
	52	}
62a465c2 HX	53	ret = zlib_deflateInit2(stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,
	54	-DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL,
	55	Z_DEFAULT_STRATEGY);
1da177e4 LT	56	if (ret != Z_OK) {
	57	ret = -EINVAL;
	58	goto out_free;
	59	}
9472d763	60	out:
1da177e4 LT	61	return ret;
	62	out_free:
	63	vfree(stream->workspace);
	64	goto out;
	65	}
	66
62a465c2	67	static int deflate_decomp_init(struct deflate_ctx *ctx)
1da177e4 LT	68	{
	69	int ret = 0;
	70	struct z_stream_s *stream = &ctx->decomp_stream;
	71
7ab24bfd	72	stream->workspace = vzalloc(zlib_inflate_workspacesize());
9472d763	73	if (!stream->workspace) {
1da177e4 LT	74	ret = -ENOMEM;
	75	goto out;
	76	}
62a465c2	77	ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS);
1da177e4 LT	78	if (ret != Z_OK) {
	79	ret = -EINVAL;
	80	goto out_free;
	81	}
	82	out:
	83	return ret;
	84	out_free:
7ab24bfd	85	vfree(stream->workspace);
1da177e4 LT	86	goto out;
	87	}
	88
	89	static void deflate_comp_exit(struct deflate_ctx *ctx)
	90	{
9ffb7146	91	zlib_deflateEnd(&ctx->comp_stream);
1da177e4 LT	92	vfree(ctx->comp_stream.workspace);
	93	}
	94
	95	static void deflate_decomp_exit(struct deflate_ctx *ctx)
	96	{
9ffb7146	97	zlib_inflateEnd(&ctx->decomp_stream);
7ab24bfd	98	vfree(ctx->decomp_stream.workspace);
1da177e4 LT	99	}
1da177e4 LT	100
62a465c2	101	static int __deflate_init(void *ctx)
1da177e4 LT	102	{
1da177e4 LT	103	int ret;
9472d763	104
62a465c2	105	ret = deflate_comp_init(ctx);
1da177e4 LT	106	if (ret)
1da177e4 LT	107	goto out;
62a465c2	108	ret = deflate_decomp_init(ctx);
1da177e4 LT	109	if (ret)
	110	deflate_comp_exit(ctx);
	111	out:
	112	return ret;
	113	}
	114
62a465c2	115	static void deflate_alloc_ctx(struct crypto_scomp tfm)
f6ded09d GC	116	{
	117	struct deflate_ctx *ctx;
	118	int ret;
	119
	120	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	121	if (!ctx)
	122	return ERR_PTR(-ENOMEM);
	123
62a465c2	124	ret = __deflate_init(ctx);
f6ded09d GC	125	if (ret) {
	126	kfree(ctx);
	127	return ERR_PTR(ret);
	128	}
	129
	130	return ctx;
	131	}
	132
	133	static int deflate_init(struct crypto_tfm *tfm)
1da177e4	134	{
6c2bb98b HX	135	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
6c2bb98b HX	136
62a465c2	137	return __deflate_init(ctx);
f6ded09d GC	138	}
	139
	140	static void __deflate_exit(void *ctx)
	141	{
1da177e4 LT	142	deflate_comp_exit(ctx);
	143	deflate_decomp_exit(ctx);
	144	}
	145
f6ded09d GC	146	static void deflate_free_ctx(struct crypto_scomp tfm, void ctx)
	147	{
	148	__deflate_exit(ctx);
453431a5	149	kfree_sensitive(ctx);
f6ded09d GC	150	}
	151
	152	static void deflate_exit(struct crypto_tfm *tfm)
	153	{
	154	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
	155
	156	__deflate_exit(ctx);
	157	}
	158
	159	static int __deflate_compress(const u8 *src, unsigned int slen,
	160	u8 dst, unsigned int dlen, void *ctx)
1da177e4 LT	161	{
1da177e4 LT	162	int ret = 0;
f6ded09d	163	struct deflate_ctx *dctx = ctx;
1da177e4 LT	164	struct z_stream_s *stream = &dctx->comp_stream;
	165
	166	ret = zlib_deflateReset(stream);
	167	if (ret != Z_OK) {
	168	ret = -EINVAL;
	169	goto out;
	170	}
	171
	172	stream->next_in = (u8 *)src;
	173	stream->avail_in = slen;
	174	stream->next_out = (u8 *)dst;
	175	stream->avail_out = *dlen;
	176
	177	ret = zlib_deflate(stream, Z_FINISH);
	178	if (ret != Z_STREAM_END) {
	179	ret = -EINVAL;
	180	goto out;
	181	}
	182	ret = 0;
	183	*dlen = stream->total_out;
	184	out:
	185	return ret;
	186	}
9472d763	187
f6ded09d GC	188	static int deflate_compress(struct crypto_tfm tfm, const u8 src,
	189	unsigned int slen, u8 dst, unsigned int dlen)
	190	{
	191	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
	192
	193	return __deflate_compress(src, slen, dst, dlen, dctx);
	194	}
	195
	196	static int deflate_scompress(struct crypto_scomp tfm, const u8 src,
	197	unsigned int slen, u8 dst, unsigned int dlen,
	198	void *ctx)
	199	{
	200	return __deflate_compress(src, slen, dst, dlen, ctx);
	201	}
	202
	203	static int __deflate_decompress(const u8 *src, unsigned int slen,
	204	u8 dst, unsigned int dlen, void *ctx)
1da177e4	205	{
9472d763	206
1da177e4	207	int ret = 0;
f6ded09d	208	struct deflate_ctx *dctx = ctx;
1da177e4 LT	209	struct z_stream_s *stream = &dctx->decomp_stream;
	210
	211	ret = zlib_inflateReset(stream);
	212	if (ret != Z_OK) {
	213	ret = -EINVAL;
	214	goto out;
	215	}
	216
	217	stream->next_in = (u8 *)src;
	218	stream->avail_in = slen;
	219	stream->next_out = (u8 *)dst;
	220	stream->avail_out = *dlen;
	221
	222	ret = zlib_inflate(stream, Z_SYNC_FLUSH);
	223	/*
	224	* Work around a bug in zlib, which sometimes wants to taste an extra
	225	* byte when being used in the (undocumented) raw deflate mode.
	226	* (From USAGI).
	227	*/
	228	if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
	229	u8 zerostuff = 0;
	230	stream->next_in = &zerostuff;
9472d763	231	stream->avail_in = 1;
1da177e4 LT	232	ret = zlib_inflate(stream, Z_FINISH);
	233	}
	234	if (ret != Z_STREAM_END) {
	235	ret = -EINVAL;
	236	goto out;
	237	}
	238	ret = 0;
	239	*dlen = stream->total_out;
	240	out:
	241	return ret;
	242	}
	243
f6ded09d GC	244	static int deflate_decompress(struct crypto_tfm tfm, const u8 src,
	245	unsigned int slen, u8 dst, unsigned int dlen)
	246	{
	247	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
	248
	249	return __deflate_decompress(src, slen, dst, dlen, dctx);
	250	}
	251
	252	static int deflate_sdecompress(struct crypto_scomp tfm, const u8 src,
	253	unsigned int slen, u8 dst, unsigned int dlen,
	254	void *ctx)
	255	{
	256	return __deflate_decompress(src, slen, dst, dlen, ctx);
	257	}
	258
1da177e4 LT	259	static struct crypto_alg alg = {
1da177e4 LT	260	.cra_name = "deflate",
d6ebf528	261	.cra_driver_name = "deflate-generic",
1da177e4 LT	262	.cra_flags = CRYPTO_ALG_TYPE_COMPRESS,
	263	.cra_ctxsize = sizeof(struct deflate_ctx),
	264	.cra_module = THIS_MODULE,
c7fc0599 HX	265	.cra_init = deflate_init,
c7fc0599 HX	266	.cra_exit = deflate_exit,
1da177e4	267	.cra_u = { .compress = {
1da177e4 LT	268	.coa_compress = deflate_compress,
	269	.coa_decompress = deflate_decompress } }
	270	};
	271
62a465c2	272	static struct scomp_alg scomp = {
f6ded09d GC	273	.alloc_ctx = deflate_alloc_ctx,
	274	.free_ctx = deflate_free_ctx,
	275	.compress = deflate_scompress,
	276	.decompress = deflate_sdecompress,
	277	.base = {
	278	.cra_name = "deflate",
	279	.cra_driver_name = "deflate-scomp",
	280	.cra_module = THIS_MODULE,
	281	}
62a465c2	282	};
f6ded09d	283
3af5b90b	284	static int __init deflate_mod_init(void)
1da177e4	285	{
f6ded09d GC	286	int ret;
	287
	288	ret = crypto_register_alg(&alg);
	289	if (ret)
	290	return ret;
	291
62a465c2	292	ret = crypto_register_scomp(&scomp);
f6ded09d GC	293	if (ret) {
	294	crypto_unregister_alg(&alg);
	295	return ret;
	296	}
	297
	298	return ret;
1da177e4 LT	299	}
1da177e4 LT	300
3af5b90b	301	static void __exit deflate_mod_fini(void)
1da177e4 LT	302	{
1da177e4 LT	303	crypto_unregister_alg(&alg);
62a465c2	304	crypto_unregister_scomp(&scomp);
1da177e4 LT	305	}
1da177e4 LT	306
c4741b23	307	subsys_initcall(deflate_mod_init);
3af5b90b	308	module_exit(deflate_mod_fini);
1da177e4 LT	309
	310	MODULE_LICENSE("GPL");
	311	MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
	312	MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
5d26a105	313	MODULE_ALIAS_CRYPTO("deflate");