crypto: tcrypt - do not attempt to write to readonly variable
[linux-2.6.git] / crypto / zlib.c
1 /*
2  * Cryptographic API.
3  *
4  * Zlib algorithm
5  *
6  * Copyright 2008 Sony Corporation
7  *
8  * Based on deflate.c, which is
9  * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
10  *
11  * This program is free software; you can redistribute it and/or modify it
12  * under the terms of the GNU General Public License as published by the Free
13  * Software Foundation; either version 2 of the License, or (at your option)
14  * any later version.
15  *
16  * FIXME: deflate transforms will require up to a total of about 436k of kernel
17  * memory on i386 (390k for compression, the rest for decompression), as the
18  * current zlib kernel code uses a worst case pre-allocation system by default.
19  * This needs to be fixed so that the amount of memory required is properly
20  * related to the winbits and memlevel parameters.
21  */
22
23 #define pr_fmt(fmt)     "%s: " fmt, __func__
24
25 #include <linux/init.h>
26 #include <linux/module.h>
27 #include <linux/zlib.h>
28 #include <linux/vmalloc.h>
29 #include <linux/interrupt.h>
30 #include <linux/mm.h>
31 #include <linux/net.h>
32 #include <linux/slab.h>
33
34 #include <crypto/internal/compress.h>
35
36 #include <net/netlink.h>
37
38
39 struct zlib_ctx {
40         struct z_stream_s comp_stream;
41         struct z_stream_s decomp_stream;
42         int decomp_windowBits;
43 };
44
45
46 static void zlib_comp_exit(struct zlib_ctx *ctx)
47 {
48         struct z_stream_s *stream = &ctx->comp_stream;
49
50         if (stream->workspace) {
51                 zlib_deflateEnd(stream);
52                 vfree(stream->workspace);
53                 stream->workspace = NULL;
54         }
55 }
56
57 static void zlib_decomp_exit(struct zlib_ctx *ctx)
58 {
59         struct z_stream_s *stream = &ctx->decomp_stream;
60
61         if (stream->workspace) {
62                 zlib_inflateEnd(stream);
63                 kfree(stream->workspace);
64                 stream->workspace = NULL;
65         }
66 }
67
68 static int zlib_init(struct crypto_tfm *tfm)
69 {
70         return 0;
71 }
72
73 static void zlib_exit(struct crypto_tfm *tfm)
74 {
75         struct zlib_ctx *ctx = crypto_tfm_ctx(tfm);
76
77         zlib_comp_exit(ctx);
78         zlib_decomp_exit(ctx);
79 }
80
81
82 static int zlib_compress_setup(struct crypto_pcomp *tfm, void *params,
83                                unsigned int len)
84 {
85         struct zlib_ctx *ctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
86         struct z_stream_s *stream = &ctx->comp_stream;
87         struct nlattr *tb[ZLIB_COMP_MAX + 1];
88         size_t workspacesize;
89         int ret;
90
91         ret = nla_parse(tb, ZLIB_COMP_MAX, params, len, NULL);
92         if (ret)
93                 return ret;
94
95         zlib_comp_exit(ctx);
96
97         workspacesize = zlib_deflate_workspacesize();
98         stream->workspace = vzalloc(workspacesize);
99         if (!stream->workspace)
100                 return -ENOMEM;
101
102         ret = zlib_deflateInit2(stream,
103                                 tb[ZLIB_COMP_LEVEL]
104                                         ? nla_get_u32(tb[ZLIB_COMP_LEVEL])
105                                         : Z_DEFAULT_COMPRESSION,
106                                 tb[ZLIB_COMP_METHOD]
107                                         ? nla_get_u32(tb[ZLIB_COMP_METHOD])
108                                         : Z_DEFLATED,
109                                 tb[ZLIB_COMP_WINDOWBITS]
110                                         ? nla_get_u32(tb[ZLIB_COMP_WINDOWBITS])
111                                         : MAX_WBITS,
112                                 tb[ZLIB_COMP_MEMLEVEL]
113                                         ? nla_get_u32(tb[ZLIB_COMP_MEMLEVEL])
114                                         : DEF_MEM_LEVEL,
115                                 tb[ZLIB_COMP_STRATEGY]
116                                         ? nla_get_u32(tb[ZLIB_COMP_STRATEGY])
117                                         : Z_DEFAULT_STRATEGY);
118         if (ret != Z_OK) {
119                 vfree(stream->workspace);
120                 stream->workspace = NULL;
121                 return -EINVAL;
122         }
123
124         return 0;
125 }
126
127 static int zlib_compress_init(struct crypto_pcomp *tfm)
128 {
129         int ret;
130         struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
131         struct z_stream_s *stream = &dctx->comp_stream;
132
133         ret = zlib_deflateReset(stream);
134         if (ret != Z_OK)
135                 return -EINVAL;
136
137         return 0;
138 }
139
140 static int zlib_compress_update(struct crypto_pcomp *tfm,
141                                 struct comp_request *req)
142 {
143         int ret;
144         struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
145         struct z_stream_s *stream = &dctx->comp_stream;
146
147         pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
148         stream->next_in = req->next_in;
149         stream->avail_in = req->avail_in;
150         stream->next_out = req->next_out;
151         stream->avail_out = req->avail_out;
152
153         ret = zlib_deflate(stream, Z_NO_FLUSH);
154         switch (ret) {
155         case Z_OK:
156                 break;
157
158         case Z_BUF_ERROR:
159                 pr_debug("zlib_deflate could not make progress\n");
160                 return -EAGAIN;
161
162         default:
163                 pr_debug("zlib_deflate failed %d\n", ret);
164                 return -EINVAL;
165         }
166
167         ret = req->avail_out - stream->avail_out;
168         pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
169                  stream->avail_in, stream->avail_out,
170                  req->avail_in - stream->avail_in, ret);
171         req->next_in = stream->next_in;
172         req->avail_in = stream->avail_in;
173         req->next_out = stream->next_out;
174         req->avail_out = stream->avail_out;
175         return ret;
176 }
177
178 static int zlib_compress_final(struct crypto_pcomp *tfm,
179                                struct comp_request *req)
180 {
181         int ret;
182         struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
183         struct z_stream_s *stream = &dctx->comp_stream;
184
185         pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
186         stream->next_in = req->next_in;
187         stream->avail_in = req->avail_in;
188         stream->next_out = req->next_out;
189         stream->avail_out = req->avail_out;
190
191         ret = zlib_deflate(stream, Z_FINISH);
192         if (ret != Z_STREAM_END) {
193                 pr_debug("zlib_deflate failed %d\n", ret);
194                 return -EINVAL;
195         }
196
197         ret = req->avail_out - stream->avail_out;
198         pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
199                  stream->avail_in, stream->avail_out,
200                  req->avail_in - stream->avail_in, ret);
201         req->next_in = stream->next_in;
202         req->avail_in = stream->avail_in;
203         req->next_out = stream->next_out;
204         req->avail_out = stream->avail_out;
205         return ret;
206 }
207
208
209 static int zlib_decompress_setup(struct crypto_pcomp *tfm, void *params,
210                                  unsigned int len)
211 {
212         struct zlib_ctx *ctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
213         struct z_stream_s *stream = &ctx->decomp_stream;
214         struct nlattr *tb[ZLIB_DECOMP_MAX + 1];
215         int ret = 0;
216
217         ret = nla_parse(tb, ZLIB_DECOMP_MAX, params, len, NULL);
218         if (ret)
219                 return ret;
220
221         zlib_decomp_exit(ctx);
222
223         ctx->decomp_windowBits = tb[ZLIB_DECOMP_WINDOWBITS]
224                                  ? nla_get_u32(tb[ZLIB_DECOMP_WINDOWBITS])
225                                  : DEF_WBITS;
226
227         stream->workspace = kzalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
228         if (!stream->workspace)
229                 return -ENOMEM;
230
231         ret = zlib_inflateInit2(stream, ctx->decomp_windowBits);
232         if (ret != Z_OK) {
233                 kfree(stream->workspace);
234                 stream->workspace = NULL;
235                 return -EINVAL;
236         }
237
238         return 0;
239 }
240
241 static int zlib_decompress_init(struct crypto_pcomp *tfm)
242 {
243         int ret;
244         struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
245         struct z_stream_s *stream = &dctx->decomp_stream;
246
247         ret = zlib_inflateReset(stream);
248         if (ret != Z_OK)
249                 return -EINVAL;
250
251         return 0;
252 }
253
254 static int zlib_decompress_update(struct crypto_pcomp *tfm,
255                                   struct comp_request *req)
256 {
257         int ret;
258         struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
259         struct z_stream_s *stream = &dctx->decomp_stream;
260
261         pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
262         stream->next_in = req->next_in;
263         stream->avail_in = req->avail_in;
264         stream->next_out = req->next_out;
265         stream->avail_out = req->avail_out;
266
267         ret = zlib_inflate(stream, Z_SYNC_FLUSH);
268         switch (ret) {
269         case Z_OK:
270         case Z_STREAM_END:
271                 break;
272
273         case Z_BUF_ERROR:
274                 pr_debug("zlib_inflate could not make progress\n");
275                 return -EAGAIN;
276
277         default:
278                 pr_debug("zlib_inflate failed %d\n", ret);
279                 return -EINVAL;
280         }
281
282         ret = req->avail_out - stream->avail_out;
283         pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
284                  stream->avail_in, stream->avail_out,
285                  req->avail_in - stream->avail_in, ret);
286         req->next_in = stream->next_in;
287         req->avail_in = stream->avail_in;
288         req->next_out = stream->next_out;
289         req->avail_out = stream->avail_out;
290         return ret;
291 }
292
293 static int zlib_decompress_final(struct crypto_pcomp *tfm,
294                                  struct comp_request *req)
295 {
296         int ret;
297         struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
298         struct z_stream_s *stream = &dctx->decomp_stream;
299
300         pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
301         stream->next_in = req->next_in;
302         stream->avail_in = req->avail_in;
303         stream->next_out = req->next_out;
304         stream->avail_out = req->avail_out;
305
306         if (dctx->decomp_windowBits < 0) {
307                 ret = zlib_inflate(stream, Z_SYNC_FLUSH);
308                 /*
309                  * Work around a bug in zlib, which sometimes wants to taste an
310                  * extra byte when being used in the (undocumented) raw deflate
311                  * mode. (From USAGI).
312                  */
313                 if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
314                         const void *saved_next_in = stream->next_in;
315                         u8 zerostuff = 0;
316
317                         stream->next_in = &zerostuff;
318                         stream->avail_in = 1;
319                         ret = zlib_inflate(stream, Z_FINISH);
320                         stream->next_in = saved_next_in;
321                         stream->avail_in = 0;
322                 }
323         } else
324                 ret = zlib_inflate(stream, Z_FINISH);
325         if (ret != Z_STREAM_END) {
326                 pr_debug("zlib_inflate failed %d\n", ret);
327                 return -EINVAL;
328         }
329
330         ret = req->avail_out - stream->avail_out;
331         pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
332                  stream->avail_in, stream->avail_out,
333                  req->avail_in - stream->avail_in, ret);
334         req->next_in = stream->next_in;
335         req->avail_in = stream->avail_in;
336         req->next_out = stream->next_out;
337         req->avail_out = stream->avail_out;
338         return ret;
339 }
340
341
342 static struct pcomp_alg zlib_alg = {
343         .compress_setup         = zlib_compress_setup,
344         .compress_init          = zlib_compress_init,
345         .compress_update        = zlib_compress_update,
346         .compress_final         = zlib_compress_final,
347         .decompress_setup       = zlib_decompress_setup,
348         .decompress_init        = zlib_decompress_init,
349         .decompress_update      = zlib_decompress_update,
350         .decompress_final       = zlib_decompress_final,
351
352         .base                   = {
353                 .cra_name       = "zlib",
354                 .cra_flags      = CRYPTO_ALG_TYPE_PCOMPRESS,
355                 .cra_ctxsize    = sizeof(struct zlib_ctx),
356                 .cra_module     = THIS_MODULE,
357                 .cra_init       = zlib_init,
358                 .cra_exit       = zlib_exit,
359         }
360 };
361
362 static int __init zlib_mod_init(void)
363 {
364         return crypto_register_pcomp(&zlib_alg);
365 }
366
367 static void __exit zlib_mod_fini(void)
368 {
369         crypto_unregister_pcomp(&zlib_alg);
370 }
371
372 module_init(zlib_mod_init);
373 module_exit(zlib_mod_fini);
374
375 MODULE_LICENSE("GPL");
376 MODULE_DESCRIPTION("Zlib Compression Algorithm");
377 MODULE_AUTHOR("Sony Corporation");