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