1eb894b87fb74ca42fc37b32878d84efa4f2516e
[openssl.git] / crypto / evp / evp_enc.c
1 /*
2  * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <assert.h>
12 #include "internal/cryptlib.h"
13 #include <openssl/evp.h>
14 #include <openssl/err.h>
15 #include <openssl/rand.h>
16 #include <openssl/rand_drbg.h>
17 #include <openssl/engine.h>
18 #include <openssl/params.h>
19 #include <openssl/core_names.h>
20 #include "internal/evp_int.h"
21 #include "internal/provider.h"
22 #include "evp_locl.h"
23
24 int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx)
25 {
26     if (ctx == NULL)
27         return 1;
28
29     if (ctx->cipher == NULL || ctx->cipher->prov == NULL)
30         goto legacy;
31
32     if (ctx->provctx != NULL) {
33         if (ctx->cipher->freectx != NULL)
34             ctx->cipher->freectx(ctx->provctx);
35         ctx->provctx = NULL;
36     }
37     if (ctx->fetched_cipher != NULL)
38         EVP_CIPHER_meth_free(ctx->fetched_cipher);
39     memset(ctx, 0, sizeof(*ctx));
40
41     return 1;
42
43     /* TODO(3.0): Remove legacy code below */
44  legacy:
45
46     if (ctx->cipher != NULL) {
47         if (ctx->cipher->cleanup && !ctx->cipher->cleanup(ctx))
48             return 0;
49         /* Cleanse cipher context data */
50         if (ctx->cipher_data && ctx->cipher->ctx_size)
51             OPENSSL_cleanse(ctx->cipher_data, ctx->cipher->ctx_size);
52     }
53     OPENSSL_free(ctx->cipher_data);
54 #ifndef OPENSSL_NO_ENGINE
55     ENGINE_finish(ctx->engine);
56 #endif
57     memset(ctx, 0, sizeof(*ctx));
58     return 1;
59 }
60
61 EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void)
62 {
63     return OPENSSL_zalloc(sizeof(EVP_CIPHER_CTX));
64 }
65
66 void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
67 {
68     EVP_CIPHER_CTX_reset(ctx);
69     OPENSSL_free(ctx);
70 }
71
72 int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
73                    const unsigned char *key, const unsigned char *iv, int enc)
74 {
75     if (cipher != NULL)
76         EVP_CIPHER_CTX_reset(ctx);
77     return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc);
78 }
79
80 int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
81                       ENGINE *impl, const unsigned char *key,
82                       const unsigned char *iv, int enc)
83 {
84     EVP_CIPHER *provciph = NULL;
85     ENGINE *tmpimpl = NULL;
86     const EVP_CIPHER *tmpcipher;
87
88     /*
89      * enc == 1 means we are encrypting.
90      * enc == 0 means we are decrypting.
91      * enc == -1 means, use the previously initialised value for encrypt/decrypt
92      */
93     if (enc == -1) {
94         enc = ctx->encrypt;
95     } else {
96         if (enc)
97             enc = 1;
98         ctx->encrypt = enc;
99     }
100
101     if (cipher == NULL && ctx->cipher == NULL) {
102         EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET);
103         return 0;
104     }
105
106     /* TODO(3.0): Legacy work around code below. Remove this */
107
108 #ifndef OPENSSL_NO_ENGINE
109     /*
110      * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so
111      * this context may already have an ENGINE! Try to avoid releasing the
112      * previous handle, re-querying for an ENGINE, and having a
113      * reinitialisation, when it may all be unnecessary.
114      */
115     if (ctx->engine && ctx->cipher
116         && (cipher == NULL || cipher->nid == ctx->cipher->nid))
117         goto skip_to_init;
118
119     if (cipher != NULL && impl == NULL) {
120          /* Ask if an ENGINE is reserved for this job */
121         tmpimpl = ENGINE_get_cipher_engine(cipher->nid);
122     }
123 #endif
124
125     /*
126      * If there are engines involved then we should use legacy handling for now.
127      */
128     if (ctx->engine != NULL
129             || impl != NULL
130             || tmpimpl != NULL) {
131         if (ctx->cipher == ctx->fetched_cipher)
132             ctx->cipher = NULL;
133         EVP_CIPHER_meth_free(ctx->fetched_cipher);
134         ctx->fetched_cipher = NULL;
135         goto legacy;
136     }
137
138     tmpcipher = (cipher == NULL) ? ctx->cipher : cipher;
139
140     if (tmpcipher->prov == NULL) {
141         switch(tmpcipher->nid) {
142         case NID_aes_256_ecb:
143         case NID_aes_192_ecb:
144         case NID_aes_128_ecb:
145         case NID_aes_256_cbc:
146         case NID_aes_192_cbc:
147         case NID_aes_128_cbc:
148         case NID_aes_256_ofb128:
149         case NID_aes_192_ofb128:
150         case NID_aes_128_ofb128:
151         case NID_aes_256_cfb128:
152         case NID_aes_192_cfb128:
153         case NID_aes_128_cfb128:
154         case NID_aes_256_cfb1:
155         case NID_aes_192_cfb1:
156         case NID_aes_128_cfb1:
157         case NID_aes_256_cfb8:
158         case NID_aes_192_cfb8:
159         case NID_aes_128_cfb8:
160         case NID_aes_256_ctr:
161         case NID_aes_192_ctr:
162         case NID_aes_128_ctr:
163             break;
164         default:
165             goto legacy;
166         }
167     }
168
169     /*
170      * Ensure a context left lying around from last time is cleared
171      * (legacy code)
172      */
173     if (cipher != NULL && ctx->cipher != NULL) {
174         OPENSSL_clear_free(ctx->cipher_data, ctx->cipher->ctx_size);
175         ctx->cipher_data = NULL;
176     }
177
178
179     /* TODO(3.0): Start of non-legacy code below */
180
181     /* Ensure a context left lying around from last time is cleared */
182     if (cipher != NULL && ctx->cipher != NULL) {
183         unsigned long flags = ctx->flags;
184
185         EVP_CIPHER_CTX_reset(ctx);
186         /* Restore encrypt and flags */
187         ctx->encrypt = enc;
188         ctx->flags = flags;
189     }
190
191     if (cipher != NULL)
192         ctx->cipher = cipher;
193     else
194         cipher = ctx->cipher;
195
196     if (cipher->prov == NULL) {
197         provciph = EVP_CIPHER_fetch(NULL, OBJ_nid2sn(cipher->nid), "");
198         if (provciph == NULL) {
199             EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
200             return 0;
201         }
202         cipher = provciph;
203         EVP_CIPHER_meth_free(ctx->fetched_cipher);
204         ctx->fetched_cipher = provciph;
205     }
206
207     ctx->cipher = cipher;
208     if (ctx->provctx == NULL) {
209         ctx->provctx = ctx->cipher->newctx(ossl_provider_ctx(cipher->prov));
210         if (ctx->provctx == NULL) {
211             EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
212             return 0;
213         }
214     }
215
216     if ((ctx->flags & EVP_CIPH_NO_PADDING) != 0) {
217         /*
218          * If this ctx was already set up for no padding then we need to tell
219          * the new cipher about it.
220          */
221         if (!EVP_CIPHER_CTX_set_padding(ctx, 0))
222             return 0;
223     }
224
225     switch (EVP_CIPHER_mode(ctx->cipher)) {
226     case EVP_CIPH_CFB_MODE:
227     case EVP_CIPH_OFB_MODE:
228     case EVP_CIPH_CBC_MODE:
229         /* For these modes we remember the original IV for later use */
230         if (!ossl_assert(EVP_CIPHER_CTX_iv_length(ctx) <= (int)sizeof(ctx->oiv))) {
231             EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
232             return 0;
233         }
234         if (iv != NULL)
235             memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
236     }
237
238     if (enc) {
239         if (ctx->cipher->einit == NULL) {
240             EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
241             return 0;
242         }
243
244         return ctx->cipher->einit(ctx->provctx,
245                                   key,
246                                   key == NULL ? 0
247                                               : EVP_CIPHER_CTX_key_length(ctx),
248                                   iv,
249                                   iv == NULL ? 0
250                                              : EVP_CIPHER_CTX_iv_length(ctx));
251     }
252
253     if (ctx->cipher->dinit == NULL) {
254         EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
255         return 0;
256     }
257
258     return ctx->cipher->dinit(ctx->provctx,
259                               key,
260                               key == NULL ? 0
261                                           : EVP_CIPHER_CTX_key_length(ctx),
262                               iv,
263                               iv == NULL ? 0
264                                          : EVP_CIPHER_CTX_iv_length(ctx));
265
266     /* TODO(3.0): Remove legacy code below */
267  legacy:
268
269     if (cipher != NULL) {
270         /*
271          * Ensure a context left lying around from last time is cleared (we
272          * previously attempted to avoid this if the same ENGINE and
273          * EVP_CIPHER could be used).
274          */
275         if (ctx->cipher) {
276             unsigned long flags = ctx->flags;
277             EVP_CIPHER_CTX_reset(ctx);
278             /* Restore encrypt and flags */
279             ctx->encrypt = enc;
280             ctx->flags = flags;
281         }
282 #ifndef OPENSSL_NO_ENGINE
283         if (impl != NULL) {
284             if (!ENGINE_init(impl)) {
285                 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
286                 return 0;
287             }
288         } else {
289             impl = tmpimpl;
290         }
291         if (impl != NULL) {
292             /* There's an ENGINE for this job ... (apparently) */
293             const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid);
294
295             if (c == NULL) {
296                 /*
297                  * One positive side-effect of US's export control history,
298                  * is that we should at least be able to avoid using US
299                  * misspellings of "initialisation"?
300                  */
301                 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
302                 return 0;
303             }
304             /* We'll use the ENGINE's private cipher definition */
305             cipher = c;
306             /*
307              * Store the ENGINE functional reference so we know 'cipher' came
308              * from an ENGINE and we need to release it when done.
309              */
310             ctx->engine = impl;
311         } else {
312             ctx->engine = NULL;
313         }
314 #endif
315
316         ctx->cipher = cipher;
317         if (ctx->cipher->ctx_size) {
318             ctx->cipher_data = OPENSSL_zalloc(ctx->cipher->ctx_size);
319             if (ctx->cipher_data == NULL) {
320                 ctx->cipher = NULL;
321                 EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE);
322                 return 0;
323             }
324         } else {
325             ctx->cipher_data = NULL;
326         }
327         ctx->key_len = cipher->key_len;
328         /* Preserve wrap enable flag, zero everything else */
329         ctx->flags &= EVP_CIPHER_CTX_FLAG_WRAP_ALLOW;
330         if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) {
331             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) {
332                 ctx->cipher = NULL;
333                 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
334                 return 0;
335             }
336         }
337     }
338 #ifndef OPENSSL_NO_ENGINE
339  skip_to_init:
340 #endif
341     /* we assume block size is a power of 2 in *cryptUpdate */
342     OPENSSL_assert(ctx->cipher->block_size == 1
343                    || ctx->cipher->block_size == 8
344                    || ctx->cipher->block_size == 16);
345
346     if (!(ctx->flags & EVP_CIPHER_CTX_FLAG_WRAP_ALLOW)
347         && EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_WRAP_MODE) {
348         EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_WRAP_MODE_NOT_ALLOWED);
349         return 0;
350     }
351
352     if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_CUSTOM_IV)) {
353         switch (EVP_CIPHER_CTX_mode(ctx)) {
354
355         case EVP_CIPH_STREAM_CIPHER:
356         case EVP_CIPH_ECB_MODE:
357             break;
358
359         case EVP_CIPH_CFB_MODE:
360         case EVP_CIPH_OFB_MODE:
361
362             ctx->num = 0;
363             /* fall-through */
364
365         case EVP_CIPH_CBC_MODE:
366
367             OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <=
368                            (int)sizeof(ctx->iv));
369             if (iv)
370                 memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
371             memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
372             break;
373
374         case EVP_CIPH_CTR_MODE:
375             ctx->num = 0;
376             /* Don't reuse IV for CTR mode */
377             if (iv)
378                 memcpy(ctx->iv, iv, EVP_CIPHER_CTX_iv_length(ctx));
379             break;
380
381         default:
382             return 0;
383         }
384     }
385
386     if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
387         if (!ctx->cipher->init(ctx, key, iv, enc))
388             return 0;
389     }
390     ctx->buf_len = 0;
391     ctx->final_used = 0;
392     ctx->block_mask = ctx->cipher->block_size - 1;
393     return 1;
394 }
395
396 int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
397                      const unsigned char *in, int inl)
398 {
399     if (ctx->encrypt)
400         return EVP_EncryptUpdate(ctx, out, outl, in, inl);
401     else
402         return EVP_DecryptUpdate(ctx, out, outl, in, inl);
403 }
404
405 int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
406 {
407     if (ctx->encrypt)
408         return EVP_EncryptFinal_ex(ctx, out, outl);
409     else
410         return EVP_DecryptFinal_ex(ctx, out, outl);
411 }
412
413 int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
414 {
415     if (ctx->encrypt)
416         return EVP_EncryptFinal(ctx, out, outl);
417     else
418         return EVP_DecryptFinal(ctx, out, outl);
419 }
420
421 int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
422                     const unsigned char *key, const unsigned char *iv)
423 {
424     return EVP_CipherInit(ctx, cipher, key, iv, 1);
425 }
426
427 int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
428                        ENGINE *impl, const unsigned char *key,
429                        const unsigned char *iv)
430 {
431     return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1);
432 }
433
434 int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
435                     const unsigned char *key, const unsigned char *iv)
436 {
437     return EVP_CipherInit(ctx, cipher, key, iv, 0);
438 }
439
440 int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
441                        ENGINE *impl, const unsigned char *key,
442                        const unsigned char *iv)
443 {
444     return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0);
445 }
446
447 /*
448  * According to the letter of standard difference between pointers
449  * is specified to be valid only within same object. This makes
450  * it formally challenging to determine if input and output buffers
451  * are not partially overlapping with standard pointer arithmetic.
452  */
453 #ifdef PTRDIFF_T
454 # undef PTRDIFF_T
455 #endif
456 #if defined(OPENSSL_SYS_VMS) && __INITIAL_POINTER_SIZE==64
457 /*
458  * Then we have VMS that distinguishes itself by adhering to
459  * sizeof(size_t)==4 even in 64-bit builds, which means that
460  * difference between two pointers might be truncated to 32 bits.
461  * In the context one can even wonder how comparison for
462  * equality is implemented. To be on the safe side we adhere to
463  * PTRDIFF_T even for comparison for equality.
464  */
465 # define PTRDIFF_T uint64_t
466 #else
467 # define PTRDIFF_T size_t
468 #endif
469
470 int is_partially_overlapping(const void *ptr1, const void *ptr2, int len)
471 {
472     PTRDIFF_T diff = (PTRDIFF_T)ptr1-(PTRDIFF_T)ptr2;
473     /*
474      * Check for partially overlapping buffers. [Binary logical
475      * operations are used instead of boolean to minimize number
476      * of conditional branches.]
477      */
478     int overlapped = (len > 0) & (diff != 0) & ((diff < (PTRDIFF_T)len) |
479                                                 (diff > (0 - (PTRDIFF_T)len)));
480
481     return overlapped;
482 }
483
484 static int evp_EncryptDecryptUpdate(EVP_CIPHER_CTX *ctx,
485                                     unsigned char *out, int *outl,
486                                     const unsigned char *in, int inl)
487 {
488     int i, j, bl, cmpl = inl;
489
490     if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS))
491         cmpl = (cmpl + 7) / 8;
492
493     bl = ctx->cipher->block_size;
494
495     if (inl <= 0) {
496         *outl = 0;
497         return inl == 0;
498     }
499
500     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
501         /* If block size > 1 then the cipher will have to do this check */
502         if (bl == 1 && is_partially_overlapping(out, in, cmpl)) {
503             EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
504             return 0;
505         }
506
507         i = ctx->cipher->do_cipher(ctx, out, in, inl);
508         if (i < 0)
509             return 0;
510         else
511             *outl = i;
512         return 1;
513     }
514
515     if (is_partially_overlapping(out + ctx->buf_len, in, cmpl)) {
516         EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
517         return 0;
518     }
519
520     if (ctx->buf_len == 0 && (inl & (ctx->block_mask)) == 0) {
521         if (ctx->cipher->do_cipher(ctx, out, in, inl)) {
522             *outl = inl;
523             return 1;
524         } else {
525             *outl = 0;
526             return 0;
527         }
528     }
529     i = ctx->buf_len;
530     OPENSSL_assert(bl <= (int)sizeof(ctx->buf));
531     if (i != 0) {
532         if (bl - i > inl) {
533             memcpy(&(ctx->buf[i]), in, inl);
534             ctx->buf_len += inl;
535             *outl = 0;
536             return 1;
537         } else {
538             j = bl - i;
539             memcpy(&(ctx->buf[i]), in, j);
540             inl -= j;
541             in += j;
542             if (!ctx->cipher->do_cipher(ctx, out, ctx->buf, bl))
543                 return 0;
544             out += bl;
545             *outl = bl;
546         }
547     } else
548         *outl = 0;
549     i = inl & (bl - 1);
550     inl -= i;
551     if (inl > 0) {
552         if (!ctx->cipher->do_cipher(ctx, out, in, inl))
553             return 0;
554         *outl += inl;
555     }
556
557     if (i != 0)
558         memcpy(ctx->buf, &(in[inl]), i);
559     ctx->buf_len = i;
560     return 1;
561 }
562
563
564 int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
565                       const unsigned char *in, int inl)
566 {
567     int ret;
568     size_t soutl;
569     int blocksize;
570
571     /* Prevent accidental use of decryption context when encrypting */
572     if (!ctx->encrypt) {
573         EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_INVALID_OPERATION);
574         return 0;
575     }
576
577     if (ctx->cipher == NULL || ctx->cipher->prov == NULL)
578         goto legacy;
579
580     blocksize = EVP_CIPHER_CTX_block_size(ctx);
581
582     if (ctx->cipher->cupdate == NULL  || blocksize < 1) {
583         EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_UPDATE_ERROR);
584         return 0;
585     }
586     ret = ctx->cipher->cupdate(ctx->provctx, out, &soutl,
587                                inl + (blocksize == 1 ? 0 : blocksize), in,
588                                (size_t)inl);
589
590     if (soutl > INT_MAX) {
591         EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_UPDATE_ERROR);
592         return 0;
593     }
594     *outl = soutl;
595     return ret;
596
597     /* TODO(3.0): Remove legacy code below */
598  legacy:
599
600     return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl);
601 }
602
603 int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
604 {
605     int ret;
606     ret = EVP_EncryptFinal_ex(ctx, out, outl);
607     return ret;
608 }
609
610 int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
611 {
612     int n, ret;
613     unsigned int i, b, bl;
614     size_t soutl;
615     int blocksize;
616
617     /* Prevent accidental use of decryption context when encrypting */
618     if (!ctx->encrypt) {
619         EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_INVALID_OPERATION);
620         return 0;
621     }
622
623     if (ctx->cipher == NULL) {
624         EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_NO_CIPHER_SET);
625         return 0;
626     }
627     if (ctx->cipher->prov == NULL)
628         goto legacy;
629
630     blocksize = EVP_CIPHER_CTX_block_size(ctx);
631
632     if (blocksize < 1 || ctx->cipher->cfinal == NULL) {
633         EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_FINAL_ERROR);
634         return 0;
635     }
636
637     ret = ctx->cipher->cfinal(ctx->provctx, out, &soutl,
638                               blocksize == 1 ? 0 : blocksize);
639
640     if (soutl > INT_MAX) {
641         EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_FINAL_ERROR);
642         return 0;
643     }
644     *outl = soutl;
645
646     return ret;
647
648     /* TODO(3.0): Remove legacy code below */
649  legacy:
650
651     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
652         ret = ctx->cipher->do_cipher(ctx, out, NULL, 0);
653         if (ret < 0)
654             return 0;
655         else
656             *outl = ret;
657         return 1;
658     }
659
660     b = ctx->cipher->block_size;
661     OPENSSL_assert(b <= sizeof(ctx->buf));
662     if (b == 1) {
663         *outl = 0;
664         return 1;
665     }
666     bl = ctx->buf_len;
667     if (ctx->flags & EVP_CIPH_NO_PADDING) {
668         if (bl) {
669             EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX,
670                    EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
671             return 0;
672         }
673         *outl = 0;
674         return 1;
675     }
676
677     n = b - bl;
678     for (i = bl; i < b; i++)
679         ctx->buf[i] = n;
680     ret = ctx->cipher->do_cipher(ctx, out, ctx->buf, b);
681
682     if (ret)
683         *outl = b;
684
685     return ret;
686 }
687
688 int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
689                       const unsigned char *in, int inl)
690 {
691     int fix_len, cmpl = inl, ret;
692     unsigned int b;
693     size_t soutl;
694     int blocksize;
695
696     /* Prevent accidental use of encryption context when decrypting */
697     if (ctx->encrypt) {
698         EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_INVALID_OPERATION);
699         return 0;
700     }
701
702     if (ctx->cipher == NULL) {
703         EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_NO_CIPHER_SET);
704         return 0;
705     }
706     if (ctx->cipher->prov == NULL)
707         goto legacy;
708
709     blocksize = EVP_CIPHER_CTX_block_size(ctx);
710
711     if (ctx->cipher->cupdate == NULL || blocksize < 1) {
712         EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_UPDATE_ERROR);
713         return 0;
714     }
715     ret = ctx->cipher->cupdate(ctx->provctx, out, &soutl,
716                                inl + (blocksize == 1 ? 0 : blocksize), in,
717                                (size_t)inl);
718
719     if (ret) {
720         if (soutl > INT_MAX) {
721             EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_UPDATE_ERROR);
722             return 0;
723         }
724         *outl = soutl;
725     }
726
727     return ret;
728
729     /* TODO(3.0): Remove legacy code below */
730  legacy:
731
732     b = ctx->cipher->block_size;
733
734     if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS))
735         cmpl = (cmpl + 7) / 8;
736
737     if (inl <= 0) {
738         *outl = 0;
739         return inl == 0;
740     }
741
742     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
743         if (b == 1 && is_partially_overlapping(out, in, cmpl)) {
744             EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
745             return 0;
746         }
747
748         fix_len = ctx->cipher->do_cipher(ctx, out, in, inl);
749         if (fix_len < 0) {
750             *outl = 0;
751             return 0;
752         } else
753             *outl = fix_len;
754         return 1;
755     }
756
757     if (ctx->flags & EVP_CIPH_NO_PADDING)
758         return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl);
759
760     OPENSSL_assert(b <= sizeof(ctx->final));
761
762     if (ctx->final_used) {
763         /* see comment about PTRDIFF_T comparison above */
764         if (((PTRDIFF_T)out == (PTRDIFF_T)in)
765             || is_partially_overlapping(out, in, b)) {
766             EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
767             return 0;
768         }
769         memcpy(out, ctx->final, b);
770         out += b;
771         fix_len = 1;
772     } else
773         fix_len = 0;
774
775     if (!evp_EncryptDecryptUpdate(ctx, out, outl, in, inl))
776         return 0;
777
778     /*
779      * if we have 'decrypted' a multiple of block size, make sure we have a
780      * copy of this last block
781      */
782     if (b > 1 && !ctx->buf_len) {
783         *outl -= b;
784         ctx->final_used = 1;
785         memcpy(ctx->final, &out[*outl], b);
786     } else
787         ctx->final_used = 0;
788
789     if (fix_len)
790         *outl += b;
791
792     return 1;
793 }
794
795 int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
796 {
797     int ret;
798     ret = EVP_DecryptFinal_ex(ctx, out, outl);
799     return ret;
800 }
801
802 int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
803 {
804     int i, n;
805     unsigned int b;
806     size_t soutl;
807     int ret;
808     int blocksize;
809
810     /* Prevent accidental use of encryption context when decrypting */
811     if (ctx->encrypt) {
812         EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_INVALID_OPERATION);
813         return 0;
814     }
815
816     if (ctx->cipher == NULL || ctx->cipher->prov == NULL)
817         goto legacy;
818
819     blocksize = EVP_CIPHER_CTX_block_size(ctx);
820
821     if (blocksize < 1 || ctx->cipher->cfinal == NULL) {
822         EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_FINAL_ERROR);
823         return 0;
824     }
825
826     ret = ctx->cipher->cfinal(ctx->provctx, out, &soutl,
827                               blocksize == 1 ? 0 : blocksize);
828
829     if (ret) {
830         if (soutl > INT_MAX) {
831             EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_FINAL_ERROR);
832             return 0;
833         }
834         *outl = soutl;
835     }
836
837     return ret;
838
839     /* TODO(3.0): Remove legacy code below */
840  legacy:
841
842     *outl = 0;
843
844     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
845         i = ctx->cipher->do_cipher(ctx, out, NULL, 0);
846         if (i < 0)
847             return 0;
848         else
849             *outl = i;
850         return 1;
851     }
852
853     b = ctx->cipher->block_size;
854     if (ctx->flags & EVP_CIPH_NO_PADDING) {
855         if (ctx->buf_len) {
856             EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,
857                    EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
858             return 0;
859         }
860         *outl = 0;
861         return 1;
862     }
863     if (b > 1) {
864         if (ctx->buf_len || !ctx->final_used) {
865             EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_WRONG_FINAL_BLOCK_LENGTH);
866             return 0;
867         }
868         OPENSSL_assert(b <= sizeof(ctx->final));
869
870         /*
871          * The following assumes that the ciphertext has been authenticated.
872          * Otherwise it provides a padding oracle.
873          */
874         n = ctx->final[b - 1];
875         if (n == 0 || n > (int)b) {
876             EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT);
877             return 0;
878         }
879         for (i = 0; i < n; i++) {
880             if (ctx->final[--b] != n) {
881                 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT);
882                 return 0;
883             }
884         }
885         n = ctx->cipher->block_size - n;
886         for (i = 0; i < n; i++)
887             out[i] = ctx->final[i];
888         *outl = n;
889     } else
890         *outl = 0;
891     return 1;
892 }
893
894 int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
895 {
896     if (c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH)
897         return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL);
898     if (EVP_CIPHER_CTX_key_length(c) == keylen)
899         return 1;
900     if ((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) {
901         c->key_len = keylen;
902         return 1;
903     }
904     EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, EVP_R_INVALID_KEY_LENGTH);
905     return 0;
906 }
907
908 int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad)
909 {
910     if (pad)
911         ctx->flags &= ~EVP_CIPH_NO_PADDING;
912     else
913         ctx->flags |= EVP_CIPH_NO_PADDING;
914
915     if (ctx->cipher != NULL && ctx->cipher->prov != NULL) {
916         OSSL_PARAM params[] = {
917             OSSL_PARAM_int(OSSL_CIPHER_PARAM_PADDING, NULL),
918             OSSL_PARAM_END
919         };
920
921         params[0].data = &pad;
922
923         if (ctx->cipher->ctx_set_params == NULL) {
924             EVPerr(EVP_F_EVP_CIPHER_CTX_SET_PADDING, EVP_R_CTRL_NOT_IMPLEMENTED);
925             return 0;
926         }
927
928         if (!ctx->cipher->ctx_set_params(ctx->provctx, params))
929             return 0;
930     }
931
932     return 1;
933 }
934
935 int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
936 {
937     int ret;
938
939     if (!ctx->cipher) {
940         EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
941         return 0;
942     }
943
944     if (!ctx->cipher->ctrl) {
945         EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
946         return 0;
947     }
948
949     ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
950     if (ret == -1) {
951         EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL,
952                EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
953         return 0;
954     }
955     return ret;
956 }
957
958 int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key)
959 {
960     if (ctx->cipher->flags & EVP_CIPH_RAND_KEY)
961         return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key);
962     if (RAND_priv_bytes(key, EVP_CIPHER_CTX_key_length(ctx)) <= 0)
963         return 0;
964     return 1;
965 }
966
967 int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
968 {
969     if ((in == NULL) || (in->cipher == NULL)) {
970         EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INPUT_NOT_INITIALIZED);
971         return 0;
972     }
973
974     if (in->cipher->prov == NULL)
975         goto legacy;
976
977     if (in->cipher->dupctx == NULL) {
978         EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_NOT_ABLE_TO_COPY_CTX);
979         return 0;
980     }
981
982     EVP_CIPHER_CTX_reset(out);
983
984     *out = *in;
985     out->provctx = NULL;
986
987     if (in->fetched_cipher != NULL && !EVP_CIPHER_upref(in->fetched_cipher)) {
988         out->fetched_cipher = NULL;
989         return 0;
990     }
991
992     out->provctx = in->cipher->dupctx(in->provctx);
993     if (out->provctx == NULL) {
994         EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_NOT_ABLE_TO_COPY_CTX);
995         return 0;
996     }
997
998     return 1;
999
1000     /* TODO(3.0): Remove legacy code below */
1001  legacy:
1002
1003 #ifndef OPENSSL_NO_ENGINE
1004     /* Make sure it's safe to copy a cipher context using an ENGINE */
1005     if (in->engine && !ENGINE_init(in->engine)) {
1006         EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_ENGINE_LIB);
1007         return 0;
1008     }
1009 #endif
1010
1011     EVP_CIPHER_CTX_reset(out);
1012     memcpy(out, in, sizeof(*out));
1013
1014     if (in->cipher_data && in->cipher->ctx_size) {
1015         out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size);
1016         if (out->cipher_data == NULL) {
1017             out->cipher = NULL;
1018             EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_MALLOC_FAILURE);
1019             return 0;
1020         }
1021         memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size);
1022     }
1023
1024     if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY)
1025         if (!in->cipher->ctrl((EVP_CIPHER_CTX *)in, EVP_CTRL_COPY, 0, out)) {
1026             out->cipher = NULL;
1027             EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INITIALIZATION_ERROR);
1028             return 0;
1029         }
1030     return 1;
1031 }
1032
1033 static void *evp_cipher_from_dispatch(int nid, const OSSL_DISPATCH *fns,
1034                                       OSSL_PROVIDER *prov)
1035 {
1036     EVP_CIPHER *cipher = NULL;
1037     int fnciphcnt = 0, fnctxcnt = 0;
1038
1039     if ((cipher = EVP_CIPHER_meth_new(nid, 0, 0)) == NULL)
1040         return NULL;
1041
1042     for (; fns->function_id != 0; fns++) {
1043         switch (fns->function_id) {
1044         case OSSL_FUNC_CIPHER_NEWCTX:
1045             if (cipher->newctx != NULL)
1046                 break;
1047             cipher->newctx = OSSL_get_OP_cipher_newctx(fns);
1048             fnctxcnt++;
1049             break;
1050         case OSSL_FUNC_CIPHER_ENCRYPT_INIT:
1051             if (cipher->einit != NULL)
1052                 break;
1053             cipher->einit = OSSL_get_OP_cipher_encrypt_init(fns);
1054             fnciphcnt++;
1055             break;
1056         case OSSL_FUNC_CIPHER_DECRYPT_INIT:
1057             if (cipher->dinit != NULL)
1058                 break;
1059             cipher->dinit = OSSL_get_OP_cipher_decrypt_init(fns);
1060             fnciphcnt++;
1061             break;
1062         case OSSL_FUNC_CIPHER_UPDATE:
1063             if (cipher->cupdate != NULL)
1064                 break;
1065             cipher->cupdate = OSSL_get_OP_cipher_update(fns);
1066             fnciphcnt++;
1067             break;
1068         case OSSL_FUNC_CIPHER_FINAL:
1069             if (cipher->cfinal != NULL)
1070                 break;
1071             cipher->cfinal = OSSL_get_OP_cipher_final(fns);
1072             fnciphcnt++;
1073             break;
1074         case OSSL_FUNC_CIPHER_CIPHER:
1075             if (cipher->ccipher != NULL)
1076                 break;
1077             cipher->ccipher = OSSL_get_OP_cipher_cipher(fns);
1078             break;
1079         case OSSL_FUNC_CIPHER_FREECTX:
1080             if (cipher->freectx != NULL)
1081                 break;
1082             cipher->freectx = OSSL_get_OP_cipher_freectx(fns);
1083             fnctxcnt++;
1084             break;
1085         case OSSL_FUNC_CIPHER_DUPCTX:
1086             if (cipher->dupctx != NULL)
1087                 break;
1088             cipher->dupctx = OSSL_get_OP_cipher_dupctx(fns);
1089             break;
1090         case OSSL_FUNC_CIPHER_KEY_LENGTH:
1091             if (cipher->key_length != NULL)
1092                 break;
1093             cipher->key_length = OSSL_get_OP_cipher_key_length(fns);
1094             break;
1095         case OSSL_FUNC_CIPHER_IV_LENGTH:
1096             if (cipher->iv_length != NULL)
1097                 break;
1098             cipher->iv_length = OSSL_get_OP_cipher_iv_length(fns);
1099             break;
1100         case OSSL_FUNC_CIPHER_BLOCK_SIZE:
1101             if (cipher->blocksize != NULL)
1102                 break;
1103             cipher->blocksize = OSSL_get_OP_cipher_block_size(fns);
1104             break;
1105         case OSSL_FUNC_CIPHER_GET_PARAMS:
1106             if (cipher->get_params != NULL)
1107                 break;
1108             cipher->get_params = OSSL_get_OP_cipher_get_params(fns);
1109             break;
1110         case OSSL_FUNC_CIPHER_CTX_GET_PARAMS:
1111             if (cipher->ctx_get_params != NULL)
1112                 break;
1113             cipher->ctx_get_params = OSSL_get_OP_cipher_ctx_get_params(fns);
1114             break;
1115         case OSSL_FUNC_CIPHER_CTX_SET_PARAMS:
1116             if (cipher->ctx_set_params != NULL)
1117                 break;
1118             cipher->ctx_set_params = OSSL_get_OP_cipher_ctx_set_params(fns);
1119             break;
1120         }
1121     }
1122     if ((fnciphcnt != 0 && fnciphcnt != 3 && fnciphcnt != 4)
1123             || (fnciphcnt == 0 && cipher->ccipher == NULL)
1124             || fnctxcnt != 2
1125             || cipher->blocksize == NULL
1126             || cipher->iv_length == NULL
1127             || cipher->key_length == NULL) {
1128         /*
1129          * In order to be a consistent set of functions we must have at least
1130          * a complete set of "encrypt" functions, or a complete set of "decrypt"
1131          * functions, or a single "cipher" function. In all cases we need a
1132          * complete set of context management functions, as well as the
1133          * blocksize, iv_length and key_length functions.
1134          */
1135         EVP_CIPHER_meth_free(cipher);
1136         EVPerr(EVP_F_EVP_CIPHER_FROM_DISPATCH, EVP_R_INVALID_PROVIDER_FUNCTIONS);
1137         return NULL;
1138     }
1139     cipher->prov = prov;
1140     if (prov != NULL)
1141         ossl_provider_upref(prov);
1142
1143     return cipher;
1144 }
1145
1146 static int evp_cipher_upref(void *cipher)
1147 {
1148     return EVP_CIPHER_upref(cipher);
1149 }
1150
1151 static void evp_cipher_free(void *cipher)
1152 {
1153     EVP_CIPHER_meth_free(cipher);
1154 }
1155
1156 static int evp_cipher_nid(void *vcipher)
1157 {
1158     EVP_CIPHER *cipher = vcipher;
1159
1160     return cipher->nid;
1161 }
1162
1163 EVP_CIPHER *EVP_CIPHER_fetch(OPENSSL_CTX *ctx, const char *algorithm,
1164                              const char *properties)
1165 {
1166     return evp_generic_fetch(ctx, OSSL_OP_CIPHER, algorithm, properties,
1167                              evp_cipher_from_dispatch, evp_cipher_upref,
1168                              evp_cipher_free, evp_cipher_nid);
1169 }