2e6ce33e4e5a4c25ed960968a2d78936c7c80f75
[openssl.git] / crypto / evp / bio_enc.c
1 /* crypto/evp/bio_enc.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include <errno.h>
61 #include "internal/cryptlib.h"
62 #include <openssl/buffer.h>
63 #include <openssl/evp.h>
64
65 static int enc_write(BIO *h, const char *buf, int num);
66 static int enc_read(BIO *h, char *buf, int size);
67 /*
68  * static int enc_puts(BIO *h, const char *str);
69  */
70 /*
71  * static int enc_gets(BIO *h, char *str, int size);
72  */
73 static long enc_ctrl(BIO *h, int cmd, long arg1, void *arg2);
74 static int enc_new(BIO *h);
75 static int enc_free(BIO *data);
76 static long enc_callback_ctrl(BIO *h, int cmd, bio_info_cb *fps);
77 #define ENC_BLOCK_SIZE  (1024*4)
78 #define BUF_OFFSET      (EVP_MAX_BLOCK_LENGTH*2)
79
80 typedef struct enc_struct {
81     int buf_len;
82     int buf_off;
83     int cont;                   /* <= 0 when finished */
84     int finished;
85     int ok;                     /* bad decrypt */
86     EVP_CIPHER_CTX cipher;
87     /*
88      * buf is larger than ENC_BLOCK_SIZE because EVP_DecryptUpdate can return
89      * up to a block more data than is presented to it
90      */
91     char buf[ENC_BLOCK_SIZE + BUF_OFFSET + 2];
92 } BIO_ENC_CTX;
93
94 static BIO_METHOD methods_enc = {
95     BIO_TYPE_CIPHER, "cipher",
96     enc_write,
97     enc_read,
98     NULL,                       /* enc_puts, */
99     NULL,                       /* enc_gets, */
100     enc_ctrl,
101     enc_new,
102     enc_free,
103     enc_callback_ctrl,
104 };
105
106 BIO_METHOD *BIO_f_cipher(void)
107 {
108     return (&methods_enc);
109 }
110
111 static int enc_new(BIO *bi)
112 {
113     BIO_ENC_CTX *ctx;
114
115     ctx = OPENSSL_zalloc(sizeof(*ctx));
116     if (ctx == NULL)
117         return (0);
118
119     EVP_CIPHER_CTX_init(&ctx->cipher);
120     ctx->cont = 1;
121     ctx->ok = 1;
122     bi->init = 0;
123     bi->ptr = (char *)ctx;
124     bi->flags = 0;
125     return (1);
126 }
127
128 static int enc_free(BIO *a)
129 {
130     BIO_ENC_CTX *b;
131
132     if (a == NULL)
133         return (0);
134     b = (BIO_ENC_CTX *)a->ptr;
135     EVP_CIPHER_CTX_cleanup(&(b->cipher));
136     OPENSSL_clear_free(a->ptr, sizeof(BIO_ENC_CTX));
137     a->ptr = NULL;
138     a->init = 0;
139     a->flags = 0;
140     return (1);
141 }
142
143 static int enc_read(BIO *b, char *out, int outl)
144 {
145     int ret = 0, i;
146     BIO_ENC_CTX *ctx;
147
148     if (out == NULL)
149         return (0);
150     ctx = (BIO_ENC_CTX *)b->ptr;
151
152     if ((ctx == NULL) || (b->next_bio == NULL))
153         return (0);
154
155     /* First check if there are bytes decoded/encoded */
156     if (ctx->buf_len > 0) {
157         i = ctx->buf_len - ctx->buf_off;
158         if (i > outl)
159             i = outl;
160         memcpy(out, &(ctx->buf[ctx->buf_off]), i);
161         ret = i;
162         out += i;
163         outl -= i;
164         ctx->buf_off += i;
165         if (ctx->buf_len == ctx->buf_off) {
166             ctx->buf_len = 0;
167             ctx->buf_off = 0;
168         }
169     }
170
171     /*
172      * At this point, we have room of outl bytes and an empty buffer, so we
173      * should read in some more.
174      */
175
176     while (outl > 0) {
177         if (ctx->cont <= 0)
178             break;
179
180         /*
181          * read in at IV offset, read the EVP_Cipher documentation about why
182          */
183         i = BIO_read(b->next_bio, &(ctx->buf[BUF_OFFSET]), ENC_BLOCK_SIZE);
184
185         if (i <= 0) {
186             /* Should be continue next time we are called? */
187             if (!BIO_should_retry(b->next_bio)) {
188                 ctx->cont = i;
189                 i = EVP_CipherFinal_ex(&(ctx->cipher),
190                                        (unsigned char *)ctx->buf,
191                                        &(ctx->buf_len));
192                 ctx->ok = i;
193                 ctx->buf_off = 0;
194             } else {
195                 ret = (ret == 0) ? i : ret;
196                 break;
197             }
198         } else {
199             if (!EVP_CipherUpdate(&(ctx->cipher),
200                                   (unsigned char *)ctx->buf, &ctx->buf_len,
201                                   (unsigned char *)&(ctx->buf[BUF_OFFSET]),
202                                   i)) {
203                 BIO_clear_retry_flags(b);
204                 return 0;
205             }
206             ctx->cont = 1;
207             /*
208              * Note: it is possible for EVP_CipherUpdate to decrypt zero
209              * bytes because this is or looks like the final block: if this
210              * happens we should retry and either read more data or decrypt
211              * the final block
212              */
213             if (ctx->buf_len == 0)
214                 continue;
215         }
216
217         if (ctx->buf_len <= outl)
218             i = ctx->buf_len;
219         else
220             i = outl;
221         if (i <= 0)
222             break;
223         memcpy(out, ctx->buf, i);
224         ret += i;
225         ctx->buf_off = i;
226         outl -= i;
227         out += i;
228     }
229
230     BIO_clear_retry_flags(b);
231     BIO_copy_next_retry(b);
232     return ((ret == 0) ? ctx->cont : ret);
233 }
234
235 static int enc_write(BIO *b, const char *in, int inl)
236 {
237     int ret = 0, n, i;
238     BIO_ENC_CTX *ctx;
239
240     ctx = (BIO_ENC_CTX *)b->ptr;
241     ret = inl;
242
243     BIO_clear_retry_flags(b);
244     n = ctx->buf_len - ctx->buf_off;
245     while (n > 0) {
246         i = BIO_write(b->next_bio, &(ctx->buf[ctx->buf_off]), n);
247         if (i <= 0) {
248             BIO_copy_next_retry(b);
249             return (i);
250         }
251         ctx->buf_off += i;
252         n -= i;
253     }
254     /* at this point all pending data has been written */
255
256     if ((in == NULL) || (inl <= 0))
257         return (0);
258
259     ctx->buf_off = 0;
260     while (inl > 0) {
261         n = (inl > ENC_BLOCK_SIZE) ? ENC_BLOCK_SIZE : inl;
262         if (!EVP_CipherUpdate(&(ctx->cipher),
263                               (unsigned char *)ctx->buf, &ctx->buf_len,
264                               (unsigned char *)in, n)) {
265             BIO_clear_retry_flags(b);
266             return 0;
267         }
268         inl -= n;
269         in += n;
270
271         ctx->buf_off = 0;
272         n = ctx->buf_len;
273         while (n > 0) {
274             i = BIO_write(b->next_bio, &(ctx->buf[ctx->buf_off]), n);
275             if (i <= 0) {
276                 BIO_copy_next_retry(b);
277                 return (ret == inl) ? i : ret - inl;
278             }
279             n -= i;
280             ctx->buf_off += i;
281         }
282         ctx->buf_len = 0;
283         ctx->buf_off = 0;
284     }
285     BIO_copy_next_retry(b);
286     return (ret);
287 }
288
289 static long enc_ctrl(BIO *b, int cmd, long num, void *ptr)
290 {
291     BIO *dbio;
292     BIO_ENC_CTX *ctx, *dctx;
293     long ret = 1;
294     int i;
295     EVP_CIPHER_CTX **c_ctx;
296
297     ctx = (BIO_ENC_CTX *)b->ptr;
298
299     switch (cmd) {
300     case BIO_CTRL_RESET:
301         ctx->ok = 1;
302         ctx->finished = 0;
303         if (!EVP_CipherInit_ex(&(ctx->cipher), NULL, NULL, NULL, NULL,
304                                ctx->cipher.encrypt))
305             return 0;
306         ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
307         break;
308     case BIO_CTRL_EOF:         /* More to read */
309         if (ctx->cont <= 0)
310             ret = 1;
311         else
312             ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
313         break;
314     case BIO_CTRL_WPENDING:
315         ret = ctx->buf_len - ctx->buf_off;
316         if (ret <= 0)
317             ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
318         break;
319     case BIO_CTRL_PENDING:     /* More to read in buffer */
320         ret = ctx->buf_len - ctx->buf_off;
321         if (ret <= 0)
322             ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
323         break;
324     case BIO_CTRL_FLUSH:
325         /* do a final write */
326  again:
327         while (ctx->buf_len != ctx->buf_off) {
328             i = enc_write(b, NULL, 0);
329             if (i < 0)
330                 return i;
331         }
332
333         if (!ctx->finished) {
334             ctx->finished = 1;
335             ctx->buf_off = 0;
336             ret = EVP_CipherFinal_ex(&(ctx->cipher),
337                                      (unsigned char *)ctx->buf,
338                                      &(ctx->buf_len));
339             ctx->ok = (int)ret;
340             if (ret <= 0)
341                 break;
342
343             /* push out the bytes */
344             goto again;
345         }
346
347         /* Finally flush the underlying BIO */
348         ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
349         break;
350     case BIO_C_GET_CIPHER_STATUS:
351         ret = (long)ctx->ok;
352         break;
353     case BIO_C_DO_STATE_MACHINE:
354         BIO_clear_retry_flags(b);
355         ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
356         BIO_copy_next_retry(b);
357         break;
358     case BIO_C_GET_CIPHER_CTX:
359         c_ctx = (EVP_CIPHER_CTX **)ptr;
360         (*c_ctx) = &(ctx->cipher);
361         b->init = 1;
362         break;
363     case BIO_CTRL_DUP:
364         dbio = (BIO *)ptr;
365         dctx = (BIO_ENC_CTX *)dbio->ptr;
366         EVP_CIPHER_CTX_init(&dctx->cipher);
367         ret = EVP_CIPHER_CTX_copy(&dctx->cipher, &ctx->cipher);
368         if (ret)
369             dbio->init = 1;
370         break;
371     default:
372         ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
373         break;
374     }
375     return (ret);
376 }
377
378 static long enc_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
379 {
380     long ret = 1;
381
382     if (b->next_bio == NULL)
383         return (0);
384     switch (cmd) {
385     default:
386         ret = BIO_callback_ctrl(b->next_bio, cmd, fp);
387         break;
388     }
389     return (ret);
390 }
391
392 /*-
393 void BIO_set_cipher_ctx(b,c)
394 BIO *b;
395 EVP_CIPHER_ctx *c;
396         {
397         if (b == NULL) return;
398
399         if ((b->callback != NULL) &&
400                 (b->callback(b,BIO_CB_CTRL,(char *)c,BIO_CTRL_SET,e,0L) <= 0))
401                 return;
402
403         b->init=1;
404         ctx=(BIO_ENC_CTX *)b->ptr;
405         memcpy(ctx->cipher,c,sizeof(EVP_CIPHER_CTX));
406
407         if (b->callback != NULL)
408                 b->callback(b,BIO_CB_CTRL,(char *)c,BIO_CTRL_SET,e,1L);
409         }
410 */
411
412 int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
413                    const unsigned char *i, int e)
414 {
415     BIO_ENC_CTX *ctx;
416
417     if (b == NULL)
418         return 0;
419
420     if ((b->callback != NULL) &&
421         (b->callback(b, BIO_CB_CTRL, (const char *)c, BIO_CTRL_SET, e, 0L) <=
422          0))
423         return 0;
424
425     b->init = 1;
426     ctx = (BIO_ENC_CTX *)b->ptr;
427     if (!EVP_CipherInit_ex(&(ctx->cipher), c, NULL, k, i, e))
428         return 0;
429
430     if (b->callback != NULL)
431         return b->callback(b, BIO_CB_CTRL, (const char *)c, BIO_CTRL_SET, e,
432                            1L);
433     return 1;
434 }