crypto/evp/evp_enc.c

   1 /*
   2  * Copyright 1995-2021 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 /* We need to use some engine deprecated APIs */
  11 #define OPENSSL_SUPPRESS_DEPRECATED
  12
  13 #include <stdio.h>
  14 #include <limits.h>
  15 #include <assert.h>
  16 #include <openssl/evp.h>
  17 #include <openssl/err.h>
  18 #include <openssl/rand.h>
  19 #ifndef FIPS_MODULE
  20 # include <openssl/engine.h>
  21 #endif
  22 #include <openssl/params.h>
  23 #include <openssl/core_names.h>
  24 #include "internal/cryptlib.h"
  25 #include "internal/provider.h"
  26 #include "internal/core.h"
  27 #include "crypto/evp.h"
  28 #include "evp_local.h"
  29
  30 int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx)
  31 {
  32     if (ctx == NULL)
  33         return 1;
  34
  35     if (ctx->cipher == NULL || ctx->cipher->prov == NULL)
  36         goto legacy;
  37
  38     if (ctx->algctx != NULL) {
  39         if (ctx->cipher->freectx != NULL)
  40             ctx->cipher->freectx(ctx->algctx);
  41         ctx->algctx = NULL;
  42     }
  43     if (ctx->fetched_cipher != NULL)
  44         EVP_CIPHER_free(ctx->fetched_cipher);
  45     memset(ctx, 0, sizeof(*ctx));
  46     ctx->iv_len = -1;
  47
  48     return 1;
  49
  50     /* Remove legacy code below when legacy support is removed. */
  51  legacy:
  52
  53     if (ctx->cipher != NULL) {
  54         if (ctx->cipher->cleanup && !ctx->cipher->cleanup(ctx))
  55             return 0;
  56         /* Cleanse cipher context data */
  57         if (ctx->cipher_data && ctx->cipher->ctx_size)
  58             OPENSSL_cleanse(ctx->cipher_data, ctx->cipher->ctx_size);
  59     }
  60     OPENSSL_free(ctx->cipher_data);
  61 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
  62     ENGINE_finish(ctx->engine);
  63 #endif
  64     memset(ctx, 0, sizeof(*ctx));
  65     ctx->iv_len = -1;
  66     return 1;
  67 }
  68
  69 EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void)
  70 {
  71     return OPENSSL_zalloc(sizeof(EVP_CIPHER_CTX));
  72 }
  73
  74 void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
  75 {
  76     if (ctx == NULL)
  77         return;
  78     EVP_CIPHER_CTX_reset(ctx);
  79     OPENSSL_free(ctx);
  80 }
  81
  82 static int evp_cipher_init_internal(EVP_CIPHER_CTX *ctx,
  83                                     const EVP_CIPHER *cipher,
  84                                     ENGINE *impl, const unsigned char *key,
  85                                     const unsigned char *iv, int enc,
  86                                     const OSSL_PARAM params[])
  87 {
  88     int n;
  89 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
  90     ENGINE *tmpimpl = NULL;
  91 #endif
  92
  93     ctx->iv_len = -1;
  94
  95     /*
  96      * enc == 1 means we are encrypting.
  97      * enc == 0 means we are decrypting.
  98      * enc == -1 means, use the previously initialised value for encrypt/decrypt
  99      */
 100     if (enc == -1) {
 101         enc = ctx->encrypt;
 102     } else {
 103         if (enc)
 104             enc = 1;
 105         ctx->encrypt = enc;
 106     }
 107
 108     if (cipher == NULL && ctx->cipher == NULL) {
 109         ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET);
 110         return 0;
 111     }
 112
 113     /* Code below to be removed when legacy support is dropped. */
 114
 115 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 116     /*
 117      * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so
 118      * this context may already have an ENGINE! Try to avoid releasing the
 119      * previous handle, re-querying for an ENGINE, and having a
 120      * reinitialisation, when it may all be unnecessary.
 121      */
 122     if (ctx->engine && ctx->cipher
 123         && (cipher == NULL || cipher->nid == ctx->cipher->nid))
 124         goto skip_to_init;
 125
 126     if (cipher != NULL && impl == NULL) {
 127          /* Ask if an ENGINE is reserved for this job */
 128         tmpimpl = ENGINE_get_cipher_engine(cipher->nid);
 129     }
 130 #endif
 131
 132     /*
 133      * If there are engines involved then we should use legacy handling for now.
 134      */
 135     if (ctx->engine != NULL
 136 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 137             || tmpimpl != NULL
 138 #endif
 139             || impl != NULL) {
 140         if (ctx->cipher == ctx->fetched_cipher)
 141             ctx->cipher = NULL;
 142         EVP_CIPHER_free(ctx->fetched_cipher);
 143         ctx->fetched_cipher = NULL;
 144         goto legacy;
 145     }
 146     /*
 147      * Ensure a context left lying around from last time is cleared
 148      * (legacy code)
 149      */
 150     if (cipher != NULL && ctx->cipher != NULL) {
 151         OPENSSL_clear_free(ctx->cipher_data, ctx->cipher->ctx_size);
 152         ctx->cipher_data = NULL;
 153     }
 154
 155
 156     /* Start of non-legacy code below */
 157
 158     /* Ensure a context left lying around from last time is cleared */
 159     if (cipher != NULL && ctx->cipher != NULL) {
 160         unsigned long flags = ctx->flags;
 161
 162         EVP_CIPHER_CTX_reset(ctx);
 163         /* Restore encrypt and flags */
 164         ctx->encrypt = enc;
 165         ctx->flags = flags;
 166     }
 167
 168     if (cipher == NULL)
 169         cipher = ctx->cipher;
 170
 171     if (cipher->prov == NULL) {
 172 #ifdef FIPS_MODULE
 173         /* We only do explicit fetches inside the FIPS module */
 174         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 175         return 0;
 176 #else
 177         EVP_CIPHER *provciph =
 178             EVP_CIPHER_fetch(NULL,
 179                              cipher->nid == NID_undef ? "NULL"
 180                                                       : OBJ_nid2sn(cipher->nid),
 181                              "");
 182
 183         if (provciph == NULL)
 184             return 0;
 185         cipher = provciph;
 186         EVP_CIPHER_free(ctx->fetched_cipher);
 187         ctx->fetched_cipher = provciph;
 188 #endif
 189     }
 190
 191     if (cipher->prov != NULL) {
 192         if (!EVP_CIPHER_up_ref((EVP_CIPHER *)cipher)) {
 193             ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 194             return 0;
 195         }
 196         EVP_CIPHER_free(ctx->fetched_cipher);
 197         ctx->fetched_cipher = (EVP_CIPHER *)cipher;
 198     }
 199     ctx->cipher = cipher;
 200     if (ctx->algctx == NULL) {
 201         ctx->algctx = ctx->cipher->newctx(ossl_provider_ctx(cipher->prov));
 202         if (ctx->algctx == NULL) {
 203             ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 204             return 0;
 205         }
 206     }
 207
 208     if ((ctx->flags & EVP_CIPH_NO_PADDING) != 0) {
 209         /*
 210          * If this ctx was already set up for no padding then we need to tell
 211          * the new cipher about it.
 212          */
 213         if (!EVP_CIPHER_CTX_set_padding(ctx, 0))
 214             return 0;
 215     }
 216
 217     if (enc) {
 218         if (ctx->cipher->einit == NULL) {
 219             ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 220             return 0;
 221         }
 222
 223         return ctx->cipher->einit(ctx->algctx,
 224                                   key,
 225                                   key == NULL ? 0
 226                                               : EVP_CIPHER_CTX_get_key_length(ctx),
 227                                   iv,
 228                                   iv == NULL ? 0
 229                                              : EVP_CIPHER_CTX_get_iv_length(ctx),
 230                                   params);
 231     }
 232
 233     if (ctx->cipher->dinit == NULL) {
 234         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 235         return 0;
 236     }
 237
 238     return ctx->cipher->dinit(ctx->algctx,
 239                               key,
 240                               key == NULL ? 0
 241                                           : EVP_CIPHER_CTX_get_key_length(ctx),
 242                               iv,
 243                               iv == NULL ? 0
 244                                          : EVP_CIPHER_CTX_get_iv_length(ctx),
 245                                   params);
 246
 247     /* Code below to be removed when legacy support is dropped. */
 248  legacy:
 249
 250     if (cipher != NULL) {
 251         /*
 252          * Ensure a context left lying around from last time is cleared (we
 253          * previously attempted to avoid this if the same ENGINE and
 254          * EVP_CIPHER could be used).
 255          */
 256         if (ctx->cipher) {
 257             unsigned long flags = ctx->flags;
 258             EVP_CIPHER_CTX_reset(ctx);
 259             /* Restore encrypt and flags */
 260             ctx->encrypt = enc;
 261             ctx->flags = flags;
 262         }
 263 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 264         if (impl != NULL) {
 265             if (!ENGINE_init(impl)) {
 266                 ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 267                 return 0;
 268             }
 269         } else {
 270             impl = tmpimpl;
 271         }
 272         if (impl != NULL) {
 273             /* There's an ENGINE for this job ... (apparently) */
 274             const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid);
 275
 276             if (c == NULL) {
 277                 /*
 278                  * One positive side-effect of US's export control history,
 279                  * is that we should at least be able to avoid using US
 280                  * misspellings of "initialisation"?
 281                  */
 282                 ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 283                 return 0;
 284             }
 285             /* We'll use the ENGINE's private cipher definition */
 286             cipher = c;
 287             /*
 288              * Store the ENGINE functional reference so we know 'cipher' came
 289              * from an ENGINE and we need to release it when done.
 290              */
 291             ctx->engine = impl;
 292         } else {
 293             ctx->engine = NULL;
 294         }
 295 #endif
 296
 297         ctx->cipher = cipher;
 298         if (ctx->cipher->ctx_size) {
 299             ctx->cipher_data = OPENSSL_zalloc(ctx->cipher->ctx_size);
 300             if (ctx->cipher_data == NULL) {
 301                 ctx->cipher = NULL;
 302                 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
 303                 return 0;
 304             }
 305         } else {
 306             ctx->cipher_data = NULL;
 307         }
 308         ctx->key_len = cipher->key_len;
 309         /* Preserve wrap enable flag, zero everything else */
 310         ctx->flags &= EVP_CIPHER_CTX_FLAG_WRAP_ALLOW;
 311         if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) {
 312             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) {
 313                 ctx->cipher = NULL;
 314                 ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 315                 return 0;
 316             }
 317         }
 318     }
 319 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 320  skip_to_init:
 321 #endif
 322     if (ctx->cipher == NULL)
 323         return 0;
 324
 325     /* we assume block size is a power of 2 in *cryptUpdate */
 326     OPENSSL_assert(ctx->cipher->block_size == 1
 327                    || ctx->cipher->block_size == 8
 328                    || ctx->cipher->block_size == 16);
 329
 330     if (!(ctx->flags & EVP_CIPHER_CTX_FLAG_WRAP_ALLOW)
 331         && EVP_CIPHER_CTX_get_mode(ctx) == EVP_CIPH_WRAP_MODE) {
 332         ERR_raise(ERR_LIB_EVP, EVP_R_WRAP_MODE_NOT_ALLOWED);
 333         return 0;
 334     }
 335
 336     if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ctx))
 337                 & EVP_CIPH_CUSTOM_IV) == 0) {
 338         switch (EVP_CIPHER_CTX_get_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             n = EVP_CIPHER_CTX_get_iv_length(ctx);
 352             if (!ossl_assert(n >= 0 && n <= (int)sizeof(ctx->iv)))
 353                     return 0;
 354             if (iv != NULL)
 355                 memcpy(ctx->oiv, iv, n);
 356             memcpy(ctx->iv, ctx->oiv, n);
 357             break;
 358
 359         case EVP_CIPH_CTR_MODE:
 360             ctx->num = 0;
 361             /* Don't reuse IV for CTR mode */
 362             if (iv != NULL) {
 363                 if ((n = EVP_CIPHER_CTX_get_iv_length(ctx)) <= 0)
 364                     return 0;
 365                 memcpy(ctx->iv, iv, n);
 366             }
 367             break;
 368
 369         default:
 370             return 0;
 371         }
 372     }
 373
 374     if (key != NULL || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
 375         if (!ctx->cipher->init(ctx, key, iv, enc))
 376             return 0;
 377     }
 378     ctx->buf_len = 0;
 379     ctx->final_used = 0;
 380     ctx->block_mask = ctx->cipher->block_size - 1;
 381     return 1;
 382 }
 383
 384 int EVP_CipherInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 385                        const unsigned char *key, const unsigned char *iv,
 386                        int enc, const OSSL_PARAM params[])
 387 {
 388     return evp_cipher_init_internal(ctx, cipher, NULL, key, iv, enc, params);
 389 }
 390
 391 int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 392                    const unsigned char *key, const unsigned char *iv, int enc)
 393 {
 394     if (cipher != NULL)
 395         EVP_CIPHER_CTX_reset(ctx);
 396     return evp_cipher_init_internal(ctx, cipher, NULL, key, iv, enc, NULL);
 397 }
 398
 399 int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 400                       ENGINE *impl, const unsigned char *key,
 401                       const unsigned char *iv, int enc)
 402 {
 403     return evp_cipher_init_internal(ctx, cipher, impl, key, iv, enc, NULL);
 404 }
 405
 406 int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 407                      const unsigned char *in, int inl)
 408 {
 409     if (ctx->encrypt)
 410         return EVP_EncryptUpdate(ctx, out, outl, in, inl);
 411     else
 412         return EVP_DecryptUpdate(ctx, out, outl, in, inl);
 413 }
 414
 415 int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 416 {
 417     if (ctx->encrypt)
 418         return EVP_EncryptFinal_ex(ctx, out, outl);
 419     else
 420         return EVP_DecryptFinal_ex(ctx, out, outl);
 421 }
 422
 423 int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 424 {
 425     if (ctx->encrypt)
 426         return EVP_EncryptFinal(ctx, out, outl);
 427     else
 428         return EVP_DecryptFinal(ctx, out, outl);
 429 }
 430
 431 int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 432                     const unsigned char *key, const unsigned char *iv)
 433 {
 434     return EVP_CipherInit(ctx, cipher, key, iv, 1);
 435 }
 436
 437 int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 438                        ENGINE *impl, const unsigned char *key,
 439                        const unsigned char *iv)
 440 {
 441     return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1);
 442 }
 443
 444 int EVP_EncryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 445                         const unsigned char *key, const unsigned char *iv,
 446                         const OSSL_PARAM params[])
 447 {
 448     return EVP_CipherInit_ex2(ctx, cipher, key, iv, 1, params);
 449 }
 450
 451 int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 452                     const unsigned char *key, const unsigned char *iv)
 453 {
 454     return EVP_CipherInit(ctx, cipher, key, iv, 0);
 455 }
 456
 457 int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 458                        ENGINE *impl, const unsigned char *key,
 459                        const unsigned char *iv)
 460 {
 461     return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0);
 462 }
 463
 464 int EVP_DecryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 465                         const unsigned char *key, const unsigned char *iv,
 466                         const OSSL_PARAM params[])
 467 {
 468     return EVP_CipherInit_ex2(ctx, cipher, key, iv, 0, params);
 469 }
 470
 471 /*
 472  * According to the letter of standard difference between pointers
 473  * is specified to be valid only within same object. This makes
 474  * it formally challenging to determine if input and output buffers
 475  * are not partially overlapping with standard pointer arithmetic.
 476  */
 477 #ifdef PTRDIFF_T
 478 # undef PTRDIFF_T
 479 #endif
 480 #if defined(OPENSSL_SYS_VMS) && __INITIAL_POINTER_SIZE==64
 481 /*
 482  * Then we have VMS that distinguishes itself by adhering to
 483  * sizeof(size_t)==4 even in 64-bit builds, which means that
 484  * difference between two pointers might be truncated to 32 bits.
 485  * In the context one can even wonder how comparison for
 486  * equality is implemented. To be on the safe side we adhere to
 487  * PTRDIFF_T even for comparison for equality.
 488  */
 489 # define PTRDIFF_T uint64_t
 490 #else
 491 # define PTRDIFF_T size_t
 492 #endif
 493
 494 int ossl_is_partially_overlapping(const void *ptr1, const void *ptr2, int len)
 495 {
 496     PTRDIFF_T diff = (PTRDIFF_T)ptr1-(PTRDIFF_T)ptr2;
 497     /*
 498      * Check for partially overlapping buffers. [Binary logical
 499      * operations are used instead of boolean to minimize number
 500      * of conditional branches.]
 501      */
 502     int overlapped = (len > 0) & (diff != 0) & ((diff < (PTRDIFF_T)len) |
 503                                                 (diff > (0 - (PTRDIFF_T)len)));
 504
 505     return overlapped;
 506 }
 507
 508 static int evp_EncryptDecryptUpdate(EVP_CIPHER_CTX *ctx,
 509                                     unsigned char *out, int *outl,
 510                                     const unsigned char *in, int inl)
 511 {
 512     int i, j, bl, cmpl = inl;
 513
 514     if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS))
 515         cmpl = (cmpl + 7) / 8;
 516
 517     bl = ctx->cipher->block_size;
 518
 519     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
 520         /* If block size > 1 then the cipher will have to do this check */
 521         if (bl == 1 && ossl_is_partially_overlapping(out, in, cmpl)) {
 522             ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING);
 523             return 0;
 524         }
 525
 526         i = ctx->cipher->do_cipher(ctx, out, in, inl);
 527         if (i < 0)
 528             return 0;
 529         else
 530             *outl = i;
 531         return 1;
 532     }
 533
 534     if (inl <= 0) {
 535         *outl = 0;
 536         return inl == 0;
 537     }
 538     if (ossl_is_partially_overlapping(out + ctx->buf_len, in, cmpl)) {
 539         ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING);
 540         return 0;
 541     }
 542
 543     if (ctx->buf_len == 0 && (inl & (ctx->block_mask)) == 0) {
 544         if (ctx->cipher->do_cipher(ctx, out, in, inl)) {
 545             *outl = inl;
 546             return 1;
 547         } else {
 548             *outl = 0;
 549             return 0;
 550         }
 551     }
 552     i = ctx->buf_len;
 553     OPENSSL_assert(bl <= (int)sizeof(ctx->buf));
 554     if (i != 0) {
 555         if (bl - i > inl) {
 556             memcpy(&(ctx->buf[i]), in, inl);
 557             ctx->buf_len += inl;
 558             *outl = 0;
 559             return 1;
 560         } else {
 561             j = bl - i;
 562
 563             /*
 564              * Once we've processed the first j bytes from in, the amount of
 565              * data left that is a multiple of the block length is:
 566              * (inl - j) & ~(bl - 1)
 567              * We must ensure that this amount of data, plus the one block that
 568              * we process from ctx->buf does not exceed INT_MAX
 569              */
 570             if (((inl - j) & ~(bl - 1)) > INT_MAX - bl) {
 571                 ERR_raise(ERR_LIB_EVP, EVP_R_OUTPUT_WOULD_OVERFLOW);
 572                 return 0;
 573             }
 574             memcpy(&(ctx->buf[i]), in, j);
 575             inl -= j;
 576             in += j;
 577             if (!ctx->cipher->do_cipher(ctx, out, ctx->buf, bl))
 578                 return 0;
 579             out += bl;
 580             *outl = bl;
 581         }
 582     } else
 583         *outl = 0;
 584     i = inl & (bl - 1);
 585     inl -= i;
 586     if (inl > 0) {
 587         if (!ctx->cipher->do_cipher(ctx, out, in, inl))
 588             return 0;
 589         *outl += inl;
 590     }
 591
 592     if (i != 0)
 593         memcpy(ctx->buf, &(in[inl]), i);
 594     ctx->buf_len = i;
 595     return 1;
 596 }
 597
 598
 599 int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 600                       const unsigned char *in, int inl)
 601 {
 602     int ret;
 603     size_t soutl;
 604     int blocksize;
 605
 606     if (outl != NULL) {
 607         *outl = 0;
 608     } else {
 609         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
 610         return 0;
 611     }
 612
 613     /* Prevent accidental use of decryption context when encrypting */
 614     if (!ctx->encrypt) {
 615         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION);
 616         return 0;
 617     }
 618
 619     if (ctx->cipher == NULL) {
 620         ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET);
 621         return 0;
 622     }
 623
 624     if (ctx->cipher->prov == NULL)
 625         goto legacy;
 626
 627     blocksize = ctx->cipher->block_size;
 628
 629     if (ctx->cipher->cupdate == NULL  || blocksize < 1) {
 630         ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
 631         return 0;
 632     }
 633     ret = ctx->cipher->cupdate(ctx->algctx, out, &soutl,
 634                                inl + (blocksize == 1 ? 0 : blocksize), in,
 635                                (size_t)inl);
 636
 637     if (ret) {
 638         if (soutl > INT_MAX) {
 639             ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
 640             return 0;
 641         }
 642         *outl = soutl;
 643     }
 644
 645     return ret;
 646
 647     /* Code below to be removed when legacy support is dropped. */
 648  legacy:
 649
 650     return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl);
 651 }
 652
 653 int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 654 {
 655     int ret;
 656     ret = EVP_EncryptFinal_ex(ctx, out, outl);
 657     return ret;
 658 }
 659
 660 int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 661 {
 662     int n, ret;
 663     unsigned int i, b, bl;
 664     size_t soutl;
 665     int blocksize;
 666
 667     if (outl != NULL) {
 668         *outl = 0;
 669     } else {
 670         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
 671         return 0;
 672     }
 673
 674     /* Prevent accidental use of decryption context when encrypting */
 675     if (!ctx->encrypt) {
 676         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION);
 677         return 0;
 678     }
 679
 680     if (ctx->cipher == NULL) {
 681         ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET);
 682         return 0;
 683     }
 684     if (ctx->cipher->prov == NULL)
 685         goto legacy;
 686
 687     blocksize = EVP_CIPHER_CTX_get_block_size(ctx);
 688
 689     if (blocksize < 1 || ctx->cipher->cfinal == NULL) {
 690         ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
 691         return 0;
 692     }
 693
 694     ret = ctx->cipher->cfinal(ctx->algctx, out, &soutl,
 695                               blocksize == 1 ? 0 : blocksize);
 696
 697     if (ret) {
 698         if (soutl > INT_MAX) {
 699             ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
 700             return 0;
 701         }
 702         *outl = soutl;
 703     }
 704
 705     return ret;
 706
 707     /* Code below to be removed when legacy support is dropped. */
 708  legacy:
 709
 710     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
 711         ret = ctx->cipher->do_cipher(ctx, out, NULL, 0);
 712         if (ret < 0)
 713             return 0;
 714         else
 715             *outl = ret;
 716         return 1;
 717     }
 718
 719     b = ctx->cipher->block_size;
 720     OPENSSL_assert(b <= sizeof(ctx->buf));
 721     if (b == 1) {
 722         *outl = 0;
 723         return 1;
 724     }
 725     bl = ctx->buf_len;
 726     if (ctx->flags & EVP_CIPH_NO_PADDING) {
 727         if (bl) {
 728             ERR_raise(ERR_LIB_EVP, EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
 729             return 0;
 730         }
 731         *outl = 0;
 732         return 1;
 733     }
 734
 735     n = b - bl;
 736     for (i = bl; i < b; i++)
 737         ctx->buf[i] = n;
 738     ret = ctx->cipher->do_cipher(ctx, out, ctx->buf, b);
 739
 740     if (ret)
 741         *outl = b;
 742
 743     return ret;
 744 }
 745
 746 int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 747                       const unsigned char *in, int inl)
 748 {
 749     int fix_len, cmpl = inl, ret;
 750     unsigned int b;
 751     size_t soutl;
 752     int blocksize;
 753
 754     if (outl != NULL) {
 755         *outl = 0;
 756     } else {
 757         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
 758         return 0;
 759     }
 760
 761     /* Prevent accidental use of encryption context when decrypting */
 762     if (ctx->encrypt) {
 763         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION);
 764         return 0;
 765     }
 766
 767     if (ctx->cipher == NULL) {
 768         ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET);
 769         return 0;
 770     }
 771     if (ctx->cipher->prov == NULL)
 772         goto legacy;
 773
 774     blocksize = EVP_CIPHER_CTX_get_block_size(ctx);
 775
 776     if (ctx->cipher->cupdate == NULL || blocksize < 1) {
 777         ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
 778         return 0;
 779     }
 780     ret = ctx->cipher->cupdate(ctx->algctx, out, &soutl,
 781                                inl + (blocksize == 1 ? 0 : blocksize), in,
 782                                (size_t)inl);
 783
 784     if (ret) {
 785         if (soutl > INT_MAX) {
 786             ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
 787             return 0;
 788         }
 789         *outl = soutl;
 790     }
 791
 792     return ret;
 793
 794     /* Code below to be removed when legacy support is dropped. */
 795  legacy:
 796
 797     b = ctx->cipher->block_size;
 798
 799     if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS))
 800         cmpl = (cmpl + 7) / 8;
 801
 802     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
 803         if (b == 1 && ossl_is_partially_overlapping(out, in, cmpl)) {
 804             ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING);
 805             return 0;
 806         }
 807
 808         fix_len = ctx->cipher->do_cipher(ctx, out, in, inl);
 809         if (fix_len < 0) {
 810             *outl = 0;
 811             return 0;
 812         } else
 813             *outl = fix_len;
 814         return 1;
 815     }
 816
 817     if (inl <= 0) {
 818         *outl = 0;
 819         return inl == 0;
 820     }
 821
 822     if (ctx->flags & EVP_CIPH_NO_PADDING)
 823         return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl);
 824
 825     OPENSSL_assert(b <= sizeof(ctx->final));
 826
 827     if (ctx->final_used) {
 828         /* see comment about PTRDIFF_T comparison above */
 829         if (((PTRDIFF_T)out == (PTRDIFF_T)in)
 830             || ossl_is_partially_overlapping(out, in, b)) {
 831             ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING);
 832             return 0;
 833         }
 834         /*
 835          * final_used is only ever set if buf_len is 0. Therefore the maximum
 836          * length output we will ever see from evp_EncryptDecryptUpdate is
 837          * the maximum multiple of the block length that is <= inl, or just:
 838          * inl & ~(b - 1)
 839          * Since final_used has been set then the final output length is:
 840          * (inl & ~(b - 1)) + b
 841          * This must never exceed INT_MAX
 842          */
 843         if ((inl & ~(b - 1)) > INT_MAX - b) {
 844             ERR_raise(ERR_LIB_EVP, EVP_R_OUTPUT_WOULD_OVERFLOW);
 845             return 0;
 846         }
 847         memcpy(out, ctx->final, b);
 848         out += b;
 849         fix_len = 1;
 850     } else
 851         fix_len = 0;
 852
 853     if (!evp_EncryptDecryptUpdate(ctx, out, outl, in, inl))
 854         return 0;
 855
 856     /*
 857      * if we have 'decrypted' a multiple of block size, make sure we have a
 858      * copy of this last block
 859      */
 860     if (b > 1 && !ctx->buf_len) {
 861         *outl -= b;
 862         ctx->final_used = 1;
 863         memcpy(ctx->final, &out[*outl], b);
 864     } else
 865         ctx->final_used = 0;
 866
 867     if (fix_len)
 868         *outl += b;
 869
 870     return 1;
 871 }
 872
 873 int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 874 {
 875     int ret;
 876     ret = EVP_DecryptFinal_ex(ctx, out, outl);
 877     return ret;
 878 }
 879
 880 int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 881 {
 882     int i, n;
 883     unsigned int b;
 884     size_t soutl;
 885     int ret;
 886     int blocksize;
 887
 888     if (outl != NULL) {
 889         *outl = 0;
 890     } else {
 891         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
 892         return 0;
 893     }
 894
 895     /* Prevent accidental use of encryption context when decrypting */
 896     if (ctx->encrypt) {
 897         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION);
 898         return 0;
 899     }
 900
 901     if (ctx->cipher == NULL) {
 902         ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET);
 903         return 0;
 904     }
 905
 906     if (ctx->cipher->prov == NULL)
 907         goto legacy;
 908
 909     blocksize = EVP_CIPHER_CTX_get_block_size(ctx);
 910
 911     if (blocksize < 1 || ctx->cipher->cfinal == NULL) {
 912         ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
 913         return 0;
 914     }
 915
 916     ret = ctx->cipher->cfinal(ctx->algctx, out, &soutl,
 917                               blocksize == 1 ? 0 : blocksize);
 918
 919     if (ret) {
 920         if (soutl > INT_MAX) {
 921             ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
 922             return 0;
 923         }
 924         *outl = soutl;
 925     }
 926
 927     return ret;
 928
 929     /* Code below to be removed when legacy support is dropped. */
 930  legacy:
 931
 932     *outl = 0;
 933     if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
 934         i = ctx->cipher->do_cipher(ctx, out, NULL, 0);
 935         if (i < 0)
 936             return 0;
 937         else
 938             *outl = i;
 939         return 1;
 940     }
 941
 942     b = ctx->cipher->block_size;
 943     if (ctx->flags & EVP_CIPH_NO_PADDING) {
 944         if (ctx->buf_len) {
 945             ERR_raise(ERR_LIB_EVP, EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
 946             return 0;
 947         }
 948         *outl = 0;
 949         return 1;
 950     }
 951     if (b > 1) {
 952         if (ctx->buf_len || !ctx->final_used) {
 953             ERR_raise(ERR_LIB_EVP, EVP_R_WRONG_FINAL_BLOCK_LENGTH);
 954             return 0;
 955         }
 956         OPENSSL_assert(b <= sizeof(ctx->final));
 957
 958         /*
 959          * The following assumes that the ciphertext has been authenticated.
 960          * Otherwise it provides a padding oracle.
 961          */
 962         n = ctx->final[b - 1];
 963         if (n == 0 || n > (int)b) {
 964             ERR_raise(ERR_LIB_EVP, EVP_R_BAD_DECRYPT);
 965             return 0;
 966         }
 967         for (i = 0; i < n; i++) {
 968             if (ctx->final[--b] != n) {
 969                 ERR_raise(ERR_LIB_EVP, EVP_R_BAD_DECRYPT);
 970                 return 0;
 971             }
 972         }
 973         n = ctx->cipher->block_size - n;
 974         for (i = 0; i < n; i++)
 975             out[i] = ctx->final[i];
 976         *outl = n;
 977     } else
 978         *outl = 0;
 979     return 1;
 980 }
 981
 982 int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
 983 {
 984     if (c->cipher->prov != NULL) {
 985         int ok;
 986         OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
 987         size_t len = keylen;
 988
 989         if (EVP_CIPHER_CTX_get_key_length(c) == keylen)
 990             return 1;
 991
 992         /* Check the cipher actually understands this parameter */
 993         if (OSSL_PARAM_locate_const(EVP_CIPHER_settable_ctx_params(c->cipher),
 994                                     OSSL_CIPHER_PARAM_KEYLEN) == NULL) {
 995             ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_KEY_LENGTH);
 996             return 0;
 997         }
 998
 999         params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_KEYLEN, &len);
1000         ok = evp_do_ciph_ctx_setparams(c->cipher, c->algctx, params);
1001
1002         return ok > 0 ? 1 : 0;
1003     }
1004
1005     /* Code below to be removed when legacy support is dropped. */
1006
1007     /*
1008      * Note there have never been any built-in ciphers that define this flag
1009      * since it was first introduced.
1010      */
1011     if (c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH)
1012         return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL);
1013     if (EVP_CIPHER_CTX_get_key_length(c) == keylen)
1014         return 1;
1015     if ((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) {
1016         c->key_len = keylen;
1017         return 1;
1018     }
1019     ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_KEY_LENGTH);
1020     return 0;
1021 }
1022
1023 int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad)
1024 {
1025     int ok;
1026     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
1027     unsigned int pd = pad;
1028
1029     if (pad)
1030         ctx->flags &= ~EVP_CIPH_NO_PADDING;
1031     else
1032         ctx->flags |= EVP_CIPH_NO_PADDING;
1033
1034     if (ctx->cipher != NULL && ctx->cipher->prov == NULL)
1035         return 1;
1036     params[0] = OSSL_PARAM_construct_uint(OSSL_CIPHER_PARAM_PADDING, &pd);
1037     ok = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params);
1038
1039     return ok != 0;
1040 }
1041
1042 int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
1043 {
1044     int ret = EVP_CTRL_RET_UNSUPPORTED;
1045     int set_params = 1;
1046     size_t sz = arg;
1047     unsigned int i;
1048     OSSL_PARAM params[4] = {
1049         OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END
1050     };
1051
1052     if (ctx == NULL || ctx->cipher == NULL) {
1053         ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET);
1054         return 0;
1055     }
1056
1057     if (ctx->cipher->prov == NULL)
1058         goto legacy;
1059
1060     switch (type) {
1061     case EVP_CTRL_SET_KEY_LENGTH:
1062         params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_KEYLEN, &sz);
1063         break;
1064     case EVP_CTRL_RAND_KEY:      /* Used by DES */
1065         set_params = 0;
1066         params[0] =
1067             OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_RANDOM_KEY,
1068                                               ptr, sz);
1069         break;
1070
1071     case EVP_CTRL_INIT:
1072         /*
1073          * EVP_CTRL_INIT is purely legacy, no provider counterpart.
1074          * As a matter of fact, this should be dead code, but some caller
1075          * might still do a direct control call with this command, so...
1076          * Legacy methods return 1 except for exceptional circumstances, so
1077          * we do the same here to not be disruptive.
1078          */
1079         return 1;
1080     case EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS: /* Used by DASYNC */
1081     default:
1082         goto end;
1083     case EVP_CTRL_AEAD_SET_IVLEN:
1084         if (arg < 0)
1085             return 0;
1086         params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_IVLEN, &sz);
1087         ctx->iv_len = -1;
1088         break;
1089     case EVP_CTRL_CCM_SET_L:
1090         if (arg < 2 || arg > 8)
1091             return 0;
1092         sz = 15 - arg;
1093         params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_IVLEN, &sz);
1094         ctx->iv_len = -1;
1095         break;
1096     case EVP_CTRL_AEAD_SET_IV_FIXED:
1097         params[0] = OSSL_PARAM_construct_octet_string(
1098                         OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, ptr, sz);
1099         break;
1100     case EVP_CTRL_GCM_IV_GEN:
1101         set_params = 0;
1102         if (arg < 0)
1103             sz = 0; /* special case that uses the iv length */
1104         params[0] = OSSL_PARAM_construct_octet_string(
1105                         OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, ptr, sz);
1106         break;
1107     case EVP_CTRL_GCM_SET_IV_INV:
1108         if (arg < 0)
1109             return 0;
1110         params[0] = OSSL_PARAM_construct_octet_string(
1111                         OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, ptr, sz);
1112         break;
1113     case EVP_CTRL_GET_RC5_ROUNDS:
1114         set_params = 0; /* Fall thru */
1115     case EVP_CTRL_SET_RC5_ROUNDS:
1116         if (arg < 0)
1117             return 0;
1118         i = (unsigned int)arg;
1119         params[0] = OSSL_PARAM_construct_uint(OSSL_CIPHER_PARAM_ROUNDS, &i);
1120         break;
1121     case EVP_CTRL_SET_SPEED:
1122         if (arg < 0)
1123             return 0;
1124         i = (unsigned int)arg;
1125         params[0] = OSSL_PARAM_construct_uint(OSSL_CIPHER_PARAM_SPEED, &i);
1126         break;
1127     case EVP_CTRL_AEAD_GET_TAG:
1128         set_params = 0; /* Fall thru */
1129     case EVP_CTRL_AEAD_SET_TAG:
1130         params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG,
1131                                                       ptr, sz);
1132         break;
1133     case EVP_CTRL_AEAD_TLS1_AAD:
1134         /* This one does a set and a get - since it returns a size */
1135         params[0] =
1136             OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD,
1137                                               ptr, sz);
1138         ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params);
1139         if (ret <= 0)
1140             goto end;
1141         params[0] =
1142             OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, &sz);
1143         ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
1144         if (ret <= 0)
1145             goto end;
1146         return sz;
1147 #ifndef OPENSSL_NO_RC2
1148     case EVP_CTRL_GET_RC2_KEY_BITS:
1149         set_params = 0; /* Fall thru */
1150     case EVP_CTRL_SET_RC2_KEY_BITS:
1151         params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_RC2_KEYBITS, &sz);
1152         break;
1153 #endif /* OPENSSL_NO_RC2 */
1154 #if !defined(OPENSSL_NO_MULTIBLOCK)
1155     case EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE:
1156         params[0] = OSSL_PARAM_construct_size_t(
1157                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT, &sz);
1158         ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params);
1159         if (ret <= 0)
1160             return 0;
1161
1162         params[0] = OSSL_PARAM_construct_size_t(
1163                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE, &sz);
1164         params[1] = OSSL_PARAM_construct_end();
1165         ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
1166         if (ret <= 0)
1167             return 0;
1168         return sz;
1169     case EVP_CTRL_TLS1_1_MULTIBLOCK_AAD: {
1170         EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p =
1171             (EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *)ptr;
1172
1173         if (arg < (int)sizeof(EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM))
1174             return 0;
1175
1176         params[0] = OSSL_PARAM_construct_octet_string(
1177                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD, (void*)p->inp, p->len);
1178         params[1] = OSSL_PARAM_construct_uint(
1179                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave);
1180         ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params);
1181         if (ret <= 0)
1182             return ret;
1183         /* Retrieve the return values changed by the set */
1184         params[0] = OSSL_PARAM_construct_size_t(
1185                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN, &sz);
1186         params[1] = OSSL_PARAM_construct_uint(
1187                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave);
1188         params[2] = OSSL_PARAM_construct_end();
1189         ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
1190         if (ret <= 0)
1191             return 0;
1192         return sz;
1193     }
1194     case EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT: {
1195         EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p =
1196             (EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *)ptr;
1197
1198         params[0] = OSSL_PARAM_construct_octet_string(
1199                         OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC, p->out, p->len);
1200
1201         params[1] = OSSL_PARAM_construct_octet_string(
1202                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN, (void*)p->inp,
1203                 p->len);
1204         params[2] = OSSL_PARAM_construct_uint(
1205                 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave);
1206         ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params);
1207         if (ret <= 0)
1208             return ret;
1209         params[0] = OSSL_PARAM_construct_size_t(
1210                         OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN, &sz);
1211         params[1] = OSSL_PARAM_construct_end();
1212         ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
1213         if (ret <= 0)
1214             return 0;
1215         return sz;
1216     }
1217 #endif /* OPENSSL_NO_MULTIBLOCK */
1218     case EVP_CTRL_AEAD_SET_MAC_KEY:
1219         if (arg < 0)
1220             return -1;
1221         params[0] = OSSL_PARAM_construct_octet_string(
1222                 OSSL_CIPHER_PARAM_AEAD_MAC_KEY, ptr, sz);
1223         break;
1224     }
1225
1226     if (set_params)
1227         ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params);
1228     else
1229         ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
1230     goto end;
1231
1232     /* Code below to be removed when legacy support is dropped. */
1233 legacy:
1234     if (ctx->cipher->ctrl == NULL) {
1235         ERR_raise(ERR_LIB_EVP, EVP_R_CTRL_NOT_IMPLEMENTED);
1236         return 0;
1237     }
1238
1239     ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
1240
1241  end:
1242     if (ret == EVP_CTRL_RET_UNSUPPORTED) {
1243         ERR_raise(ERR_LIB_EVP, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
1244         return 0;
1245     }
1246     return ret;
1247 }
1248
1249 int EVP_CIPHER_get_params(EVP_CIPHER *cipher, OSSL_PARAM params[])
1250 {
1251     if (cipher != NULL && cipher->get_params != NULL)
1252         return cipher->get_params(params);
1253     return 0;
1254 }
1255
1256 int EVP_CIPHER_CTX_set_params(EVP_CIPHER_CTX *ctx, const OSSL_PARAM params[])
1257 {
1258     if (ctx->cipher != NULL && ctx->cipher->set_ctx_params != NULL) {
1259         ctx->iv_len = -1;
1260         return ctx->cipher->set_ctx_params(ctx->algctx, params);
1261     }
1262     return 0;
1263 }
1264
1265 int EVP_CIPHER_CTX_get_params(EVP_CIPHER_CTX *ctx, OSSL_PARAM params[])
1266 {
1267     if (ctx->cipher != NULL && ctx->cipher->get_ctx_params != NULL)
1268         return ctx->cipher->get_ctx_params(ctx->algctx, params);
1269     return 0;
1270 }
1271
1272 const OSSL_PARAM *EVP_CIPHER_gettable_params(const EVP_CIPHER *cipher)
1273 {
1274     if (cipher != NULL && cipher->gettable_params != NULL)
1275         return cipher->gettable_params(
1276                    ossl_provider_ctx(EVP_CIPHER_get0_provider(cipher)));
1277     return NULL;
1278 }
1279
1280 const OSSL_PARAM *EVP_CIPHER_settable_ctx_params(const EVP_CIPHER *cipher)
1281 {
1282     void *provctx;
1283
1284     if (cipher != NULL && cipher->settable_ctx_params != NULL) {
1285         provctx = ossl_provider_ctx(EVP_CIPHER_get0_provider(cipher));
1286         return cipher->settable_ctx_params(NULL, provctx);
1287     }
1288     return NULL;
1289 }
1290
1291 const OSSL_PARAM *EVP_CIPHER_gettable_ctx_params(const EVP_CIPHER *cipher)
1292 {
1293     void *provctx;
1294
1295     if (cipher != NULL && cipher->gettable_ctx_params != NULL) {
1296         provctx = ossl_provider_ctx(EVP_CIPHER_get0_provider(cipher));
1297         return cipher->gettable_ctx_params(NULL, provctx);
1298     }
1299     return NULL;
1300 }
1301
1302 const OSSL_PARAM *EVP_CIPHER_CTX_settable_params(EVP_CIPHER_CTX *cctx)
1303 {
1304     void *alg;
1305
1306     if (cctx != NULL && cctx->cipher->settable_ctx_params != NULL) {
1307         alg = ossl_provider_ctx(EVP_CIPHER_get0_provider(cctx->cipher));
1308         return cctx->cipher->settable_ctx_params(cctx->algctx, alg);
1309     }
1310     return NULL;
1311 }
1312
1313 const OSSL_PARAM *EVP_CIPHER_CTX_gettable_params(EVP_CIPHER_CTX *cctx)
1314 {
1315     void *provctx;
1316
1317     if (cctx != NULL && cctx->cipher->gettable_ctx_params != NULL) {
1318         provctx = ossl_provider_ctx(EVP_CIPHER_get0_provider(cctx->cipher));
1319         return cctx->cipher->gettable_ctx_params(cctx->algctx, provctx);
1320     }
1321     return NULL;
1322 }
1323
1324 #ifndef FIPS_MODULE
1325 static OSSL_LIB_CTX *EVP_CIPHER_CTX_get_libctx(EVP_CIPHER_CTX *ctx)
1326 {
1327     const EVP_CIPHER *cipher = ctx->cipher;
1328     const OSSL_PROVIDER *prov;
1329
1330     if (cipher == NULL)
1331         return NULL;
1332
1333     prov = EVP_CIPHER_get0_provider(cipher);
1334     return ossl_provider_libctx(prov);
1335 }
1336 #endif
1337
1338 int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key)
1339 {
1340     if (ctx->cipher->flags & EVP_CIPH_RAND_KEY)
1341         return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key);
1342
1343 #ifdef FIPS_MODULE
1344     return 0;
1345 #else
1346     {
1347         int kl;
1348         OSSL_LIB_CTX *libctx = EVP_CIPHER_CTX_get_libctx(ctx);
1349
1350         kl = EVP_CIPHER_CTX_get_key_length(ctx);
1351         if (kl <= 0 || RAND_priv_bytes_ex(libctx, key, kl, 0) <= 0)
1352             return 0;
1353         return 1;
1354     }
1355 #endif /* FIPS_MODULE */
1356 }
1357
1358 EVP_CIPHER_CTX *EVP_CIPHER_CTX_dup(const EVP_CIPHER_CTX *in)
1359 {
1360     EVP_CIPHER_CTX *out = EVP_CIPHER_CTX_new();
1361
1362     if (out != NULL && !EVP_CIPHER_CTX_copy(out, in)) {
1363         EVP_CIPHER_CTX_free(out);
1364         out = NULL;
1365     }
1366     return out;
1367 }
1368
1369 int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
1370 {
1371     if ((in == NULL) || (in->cipher == NULL)) {
1372         ERR_raise(ERR_LIB_EVP, EVP_R_INPUT_NOT_INITIALIZED);
1373         return 0;
1374     }
1375
1376     if (in->cipher->prov == NULL)
1377         goto legacy;
1378
1379     if (in->cipher->dupctx == NULL) {
1380         ERR_raise(ERR_LIB_EVP, EVP_R_NOT_ABLE_TO_COPY_CTX);
1381         return 0;
1382     }
1383
1384     EVP_CIPHER_CTX_reset(out);
1385
1386     *out = *in;
1387     out->algctx = NULL;
1388
1389     if (in->fetched_cipher != NULL && !EVP_CIPHER_up_ref(in->fetched_cipher)) {
1390         out->fetched_cipher = NULL;
1391         return 0;
1392     }
1393
1394     out->algctx = in->cipher->dupctx(in->algctx);
1395     if (out->algctx == NULL) {
1396         ERR_raise(ERR_LIB_EVP, EVP_R_NOT_ABLE_TO_COPY_CTX);
1397         return 0;
1398     }
1399
1400     return 1;
1401
1402     /* Code below to be removed when legacy support is dropped. */
1403  legacy:
1404
1405 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
1406     /* Make sure it's safe to copy a cipher context using an ENGINE */
1407     if (in->engine && !ENGINE_init(in->engine)) {
1408         ERR_raise(ERR_LIB_EVP, ERR_R_ENGINE_LIB);
1409         return 0;
1410     }
1411 #endif
1412
1413     EVP_CIPHER_CTX_reset(out);
1414     memcpy(out, in, sizeof(*out));
1415
1416     if (in->cipher_data && in->cipher->ctx_size) {
1417         out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size);
1418         if (out->cipher_data == NULL) {
1419             out->cipher = NULL;
1420             ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
1421             return 0;
1422         }
1423         memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size);
1424     }
1425
1426     if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY)
1427         if (!in->cipher->ctrl((EVP_CIPHER_CTX *)in, EVP_CTRL_COPY, 0, out)) {
1428             out->cipher = NULL;
1429             ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
1430             return 0;
1431         }
1432     return 1;
1433 }
1434
1435 EVP_CIPHER *evp_cipher_new(void)
1436 {
1437     EVP_CIPHER *cipher = OPENSSL_zalloc(sizeof(EVP_CIPHER));
1438
1439     if (cipher != NULL) {
1440         cipher->lock = CRYPTO_THREAD_lock_new();
1441         if (cipher->lock == NULL) {
1442             OPENSSL_free(cipher);
1443             return NULL;
1444         }
1445         cipher->refcnt = 1;
1446     }
1447     return cipher;
1448 }
1449
1450 /*
1451  * FIPS module note: since internal fetches will be entirely
1452  * provider based, we know that none of its code depends on legacy
1453  * NIDs or any functionality that use them.
1454  */
1455 #ifndef FIPS_MODULE
1456 /* After removal of legacy support get rid of the need for legacy NIDs */
1457 static void set_legacy_nid(const char *name, void *vlegacy_nid)
1458 {
1459     int nid;
1460     int *legacy_nid = vlegacy_nid;
1461     /*
1462      * We use lowest level function to get the associated method, because
1463      * higher level functions such as EVP_get_cipherbyname() have changed
1464      * to look at providers too.
1465      */
1466     const void *legacy_method = OBJ_NAME_get(name, OBJ_NAME_TYPE_CIPHER_METH);
1467
1468     if (*legacy_nid == -1)       /* We found a clash already */
1469         return;
1470     if (legacy_method == NULL)
1471         return;
1472     nid = EVP_CIPHER_get_nid(legacy_method);
1473     if (*legacy_nid != NID_undef && *legacy_nid != nid) {
1474         *legacy_nid = -1;
1475         return;
1476     }
1477     *legacy_nid = nid;
1478 }
1479 #endif
1480
1481 static void *evp_cipher_from_algorithm(const int name_id,
1482                                        const OSSL_ALGORITHM *algodef,
1483                                        OSSL_PROVIDER *prov)
1484 {
1485     const OSSL_DISPATCH *fns = algodef->implementation;
1486     EVP_CIPHER *cipher = NULL;
1487     int fnciphcnt = 0, fnctxcnt = 0;
1488
1489     if ((cipher = evp_cipher_new()) == NULL) {
1490         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
1491         return NULL;
1492     }
1493
1494 #ifndef FIPS_MODULE
1495     cipher->nid = NID_undef;
1496     if (!evp_names_do_all(prov, name_id, set_legacy_nid, &cipher->nid)
1497             || cipher->nid == -1) {
1498         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
1499         EVP_CIPHER_free(cipher);
1500         return NULL;
1501     }
1502 #endif
1503
1504     cipher->name_id = name_id;
1505     if ((cipher->type_name = ossl_algorithm_get1_first_name(algodef)) == NULL) {
1506         EVP_CIPHER_free(cipher);
1507         return NULL;
1508     }
1509     cipher->description = algodef->algorithm_description;
1510
1511     for (; fns->function_id != 0; fns++) {
1512         switch (fns->function_id) {
1513         case OSSL_FUNC_CIPHER_NEWCTX:
1514             if (cipher->newctx != NULL)
1515                 break;
1516             cipher->newctx = OSSL_FUNC_cipher_newctx(fns);
1517             fnctxcnt++;
1518             break;
1519         case OSSL_FUNC_CIPHER_ENCRYPT_INIT:
1520             if (cipher->einit != NULL)
1521                 break;
1522             cipher->einit = OSSL_FUNC_cipher_encrypt_init(fns);
1523             fnciphcnt++;
1524             break;
1525         case OSSL_FUNC_CIPHER_DECRYPT_INIT:
1526             if (cipher->dinit != NULL)
1527                 break;
1528             cipher->dinit = OSSL_FUNC_cipher_decrypt_init(fns);
1529             fnciphcnt++;
1530             break;
1531         case OSSL_FUNC_CIPHER_UPDATE:
1532             if (cipher->cupdate != NULL)
1533                 break;
1534             cipher->cupdate = OSSL_FUNC_cipher_update(fns);
1535             fnciphcnt++;
1536             break;
1537         case OSSL_FUNC_CIPHER_FINAL:
1538             if (cipher->cfinal != NULL)
1539                 break;
1540             cipher->cfinal = OSSL_FUNC_cipher_final(fns);
1541             fnciphcnt++;
1542             break;
1543         case OSSL_FUNC_CIPHER_CIPHER:
1544             if (cipher->ccipher != NULL)
1545                 break;
1546             cipher->ccipher = OSSL_FUNC_cipher_cipher(fns);
1547             break;
1548         case OSSL_FUNC_CIPHER_FREECTX:
1549             if (cipher->freectx != NULL)
1550                 break;
1551             cipher->freectx = OSSL_FUNC_cipher_freectx(fns);
1552             fnctxcnt++;
1553             break;
1554         case OSSL_FUNC_CIPHER_DUPCTX:
1555             if (cipher->dupctx != NULL)
1556                 break;
1557             cipher->dupctx = OSSL_FUNC_cipher_dupctx(fns);
1558             break;
1559         case OSSL_FUNC_CIPHER_GET_PARAMS:
1560             if (cipher->get_params != NULL)
1561                 break;
1562             cipher->get_params = OSSL_FUNC_cipher_get_params(fns);
1563             break;
1564         case OSSL_FUNC_CIPHER_GET_CTX_PARAMS:
1565             if (cipher->get_ctx_params != NULL)
1566                 break;
1567             cipher->get_ctx_params = OSSL_FUNC_cipher_get_ctx_params(fns);
1568             break;
1569         case OSSL_FUNC_CIPHER_SET_CTX_PARAMS:
1570             if (cipher->set_ctx_params != NULL)
1571                 break;
1572             cipher->set_ctx_params = OSSL_FUNC_cipher_set_ctx_params(fns);
1573             break;
1574         case OSSL_FUNC_CIPHER_GETTABLE_PARAMS:
1575             if (cipher->gettable_params != NULL)
1576                 break;
1577             cipher->gettable_params = OSSL_FUNC_cipher_gettable_params(fns);
1578             break;
1579         case OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS:
1580             if (cipher->gettable_ctx_params != NULL)
1581                 break;
1582             cipher->gettable_ctx_params =
1583                 OSSL_FUNC_cipher_gettable_ctx_params(fns);
1584             break;
1585         case OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS:
1586             if (cipher->settable_ctx_params != NULL)
1587                 break;
1588             cipher->settable_ctx_params =
1589                 OSSL_FUNC_cipher_settable_ctx_params(fns);
1590             break;
1591         }
1592     }
1593     if ((fnciphcnt != 0 && fnciphcnt != 3 && fnciphcnt != 4)
1594             || (fnciphcnt == 0 && cipher->ccipher == NULL)
1595             || fnctxcnt != 2) {
1596         /*
1597          * In order to be a consistent set of functions we must have at least
1598          * a complete set of "encrypt" functions, or a complete set of "decrypt"
1599          * functions, or a single "cipher" function. In all cases we need both
1600          * the "newctx" and "freectx" functions.
1601          */
1602         EVP_CIPHER_free(cipher);
1603         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
1604         return NULL;
1605     }
1606     cipher->prov = prov;
1607     if (prov != NULL)
1608         ossl_provider_up_ref(prov);
1609
1610     if (!evp_cipher_cache_constants(cipher)) {
1611         EVP_CIPHER_free(cipher);
1612         ERR_raise(ERR_LIB_EVP, EVP_R_CACHE_CONSTANTS_FAILED);
1613         cipher = NULL;
1614     }
1615
1616     return cipher;
1617 }
1618
1619 static int evp_cipher_up_ref(void *cipher)
1620 {
1621     return EVP_CIPHER_up_ref(cipher);
1622 }
1623
1624 static void evp_cipher_free(void *cipher)
1625 {
1626     EVP_CIPHER_free(cipher);
1627 }
1628
1629 EVP_CIPHER *EVP_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
1630                              const char *properties)
1631 {
1632     EVP_CIPHER *cipher =
1633         evp_generic_fetch(ctx, OSSL_OP_CIPHER, algorithm, properties,
1634                           evp_cipher_from_algorithm, evp_cipher_up_ref,
1635                           evp_cipher_free);
1636
1637     return cipher;
1638 }
1639
1640 int EVP_CIPHER_up_ref(EVP_CIPHER *cipher)
1641 {
1642     int ref = 0;
1643
1644     if (cipher->origin == EVP_ORIG_DYNAMIC)
1645         CRYPTO_UP_REF(&cipher->refcnt, &ref, cipher->lock);
1646     return 1;
1647 }
1648
1649 void evp_cipher_free_int(EVP_CIPHER *cipher)
1650 {
1651     OPENSSL_free(cipher->type_name);
1652     ossl_provider_free(cipher->prov);
1653     CRYPTO_THREAD_lock_free(cipher->lock);
1654     OPENSSL_free(cipher);
1655 }
1656
1657 void EVP_CIPHER_free(EVP_CIPHER *cipher)
1658 {
1659     int i;
1660
1661     if (cipher == NULL || cipher->origin != EVP_ORIG_DYNAMIC)
1662         return;
1663
1664     CRYPTO_DOWN_REF(&cipher->refcnt, &i, cipher->lock);
1665     if (i > 0)
1666         return;
1667     evp_cipher_free_int(cipher);
1668 }
1669
1670 void EVP_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
1671                                 void (*fn)(EVP_CIPHER *mac, void *arg),
1672                                 void *arg)
1673 {
1674     evp_generic_do_all(libctx, OSSL_OP_CIPHER,
1675                        (void (*)(void *, void *))fn, arg,
1676                        evp_cipher_from_algorithm, evp_cipher_up_ref,
1677                        evp_cipher_free);
1678 }