providers/implementations/ciphers/ciphercommon.c

   1 /*
   2  * Copyright 2019-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 /*
  11  * Generic dispatch table functions for ciphers.
  12  */
  13
  14 /* For SSL3_VERSION */
  15 #include <openssl/ssl.h>
  16 #include <openssl/proverr.h>
  17 #include "ciphercommon_local.h"
  18 #include "prov/provider_ctx.h"
  19 #include "prov/providercommon.h"
  20
  21 /*-
  22  * Generic cipher functions for OSSL_PARAM gettables and settables
  23  */
  24 static const OSSL_PARAM cipher_known_gettable_params[] = {
  25     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL),
  26     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
  27     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
  28     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL),
  29     OSSL_PARAM_int(OSSL_CIPHER_PARAM_AEAD, NULL),
  30     OSSL_PARAM_int(OSSL_CIPHER_PARAM_CUSTOM_IV, NULL),
  31     OSSL_PARAM_int(OSSL_CIPHER_PARAM_CTS, NULL),
  32     OSSL_PARAM_int(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK, NULL),
  33     OSSL_PARAM_END
  34 };
  35 const OSSL_PARAM *ossl_cipher_generic_gettable_params(ossl_unused void *provctx)
  36 {
  37     return cipher_known_gettable_params;
  38 }
  39
  40 int ossl_cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
  41                                    uint64_t flags,
  42                                    size_t kbits, size_t blkbits, size_t ivbits)
  43 {
  44     OSSL_PARAM *p;
  45
  46     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE);
  47     if (p != NULL && !OSSL_PARAM_set_uint(p, md)) {
  48         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  49         return 0;
  50     }
  51     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD);
  52     if (p != NULL
  53         && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_AEAD) != 0)) {
  54         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  55         return 0;
  56     }
  57     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CUSTOM_IV);
  58     if (p != NULL
  59         && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CUSTOM_IV) != 0)) {
  60         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  61         return 0;
  62     }
  63     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CTS);
  64     if (p != NULL
  65         && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CTS) != 0)) {
  66         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  67         return 0;
  68     }
  69     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK);
  70     if (p != NULL
  71         && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_TLS1_MULTIBLOCK) != 0)) {
  72         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  73         return 0;
  74     }
  75     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
  76     if (p != NULL && !OSSL_PARAM_set_size_t(p, kbits / 8)) {
  77         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  78         return 0;
  79     }
  80     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE);
  81     if (p != NULL && !OSSL_PARAM_set_size_t(p, blkbits / 8)) {
  82         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  83         return 0;
  84     }
  85     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
  86     if (p != NULL && !OSSL_PARAM_set_size_t(p, ivbits / 8)) {
  87         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  88         return 0;
  89     }
  90     return 1;
  91 }
  92
  93 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(ossl_cipher_generic)
  94 { OSSL_CIPHER_PARAM_TLS_MAC, OSSL_PARAM_OCTET_PTR, NULL, 0, OSSL_PARAM_UNMODIFIED },
  95 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(ossl_cipher_generic)
  96
  97 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_generic)
  98 OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
  99 OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
 100 OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
 101 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_generic)
 102
 103 /*
 104  * Variable key length cipher functions for OSSL_PARAM settables
 105  */
 106 int ossl_cipher_var_keylen_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 107 {
 108     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 109     const OSSL_PARAM *p;
 110
 111     if (params == NULL)
 112         return 1;
 113
 114     if (!ossl_cipher_generic_set_ctx_params(vctx, params))
 115         return 0;
 116     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
 117     if (p != NULL) {
 118         size_t keylen;
 119
 120         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
 121             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 122             return 0;
 123         }
 124         ctx->keylen = keylen;
 125     }
 126     return 1;
 127 }
 128
 129 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_var_keylen)
 130 OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 131 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_var_keylen)
 132
 133 /*-
 134  * AEAD cipher functions for OSSL_PARAM gettables and settables
 135  */
 136 static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = {
 137     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 138     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
 139     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
 140     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
 141     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
 142     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 143     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
 144     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, NULL, 0),
 145     OSSL_PARAM_END
 146 };
 147 const OSSL_PARAM *ossl_cipher_aead_gettable_ctx_params(
 148         ossl_unused void *cctx, ossl_unused void *provctx
 149     )
 150 {
 151     return cipher_aead_known_gettable_ctx_params;
 152 }
 153
 154 static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
 155     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
 156     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 157     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
 158     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
 159     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, NULL, 0),
 160     OSSL_PARAM_END
 161 };
 162 const OSSL_PARAM *ossl_cipher_aead_settable_ctx_params(
 163         ossl_unused void *cctx, ossl_unused void *provctx
 164     )
 165 {
 166     return cipher_aead_known_settable_ctx_params;
 167 }
 168
 169 void ossl_cipher_generic_reset_ctx(PROV_CIPHER_CTX *ctx)
 170 {
 171     if (ctx != NULL && ctx->alloced) {
 172         OPENSSL_free(ctx->tlsmac);
 173         ctx->alloced = 0;
 174         ctx->tlsmac = NULL;
 175     }
 176 }
 177
 178 static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
 179                                         const unsigned char *key, size_t keylen,
 180                                         const unsigned char *iv, size_t ivlen,
 181                                         const OSSL_PARAM params[], int enc)
 182 {
 183     ctx->num = 0;
 184     ctx->bufsz = 0;
 185     ctx->updated = 0;
 186     ctx->enc = enc ? 1 : 0;
 187
 188     if (!ossl_prov_is_running())
 189         return 0;
 190
 191     if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
 192         if (!ossl_cipher_generic_initiv(ctx, iv, ivlen))
 193             return 0;
 194     }
 195     if (iv == NULL && ctx->iv_set
 196         && (ctx->mode == EVP_CIPH_CBC_MODE
 197             || ctx->mode == EVP_CIPH_CFB_MODE
 198             || ctx->mode == EVP_CIPH_OFB_MODE))
 199         /* reset IV for these modes to keep compatibility with 1.1.1 */
 200         memcpy(ctx->iv, ctx->oiv, ctx->ivlen);
 201
 202     if (key != NULL) {
 203         if (ctx->variable_keylength == 0) {
 204             if (keylen != ctx->keylen) {
 205                 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
 206                 return 0;
 207             }
 208         } else {
 209             ctx->keylen = keylen;
 210         }
 211         if (!ctx->hw->init(ctx, key, ctx->keylen))
 212             return 0;
 213     }
 214     return ossl_cipher_generic_set_ctx_params(ctx, params);
 215 }
 216
 217 int ossl_cipher_generic_einit(void *vctx, const unsigned char *key,
 218                               size_t keylen, const unsigned char *iv,
 219                               size_t ivlen, const OSSL_PARAM params[])
 220 {
 221     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 222                                         iv, ivlen, params, 1);
 223 }
 224
 225 int ossl_cipher_generic_dinit(void *vctx, const unsigned char *key,
 226                               size_t keylen, const unsigned char *iv,
 227                               size_t ivlen, const OSSL_PARAM params[])
 228 {
 229     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 230                                         iv, ivlen, params, 0);
 231 }
 232
 233 /* Max padding including padding length byte */
 234 #define MAX_PADDING 256
 235
 236 int ossl_cipher_generic_block_update(void *vctx, unsigned char *out,
 237                                      size_t *outl, size_t outsize,
 238                                      const unsigned char *in, size_t inl)
 239 {
 240     size_t outlint = 0;
 241     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 242     size_t blksz = ctx->blocksize;
 243     size_t nextblocks;
 244
 245     if (ctx->tlsversion > 0) {
 246         /*
 247          * Each update call corresponds to a TLS record and is individually
 248          * padded
 249          */
 250
 251         /* Sanity check inputs */
 252         if (in == NULL
 253                 || in != out
 254                 || outsize < inl
 255                 || !ctx->pad) {
 256             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 257             return 0;
 258         }
 259
 260         if (ctx->enc) {
 261             unsigned char padval;
 262             size_t padnum, loop;
 263
 264             /* Add padding */
 265
 266             padnum = blksz - (inl % blksz);
 267
 268             if (outsize < inl + padnum) {
 269                 ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 270                 return 0;
 271             }
 272
 273             if (padnum > MAX_PADDING) {
 274                 ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 275                 return 0;
 276             }
 277             padval = (unsigned char)(padnum - 1);
 278             if (ctx->tlsversion == SSL3_VERSION) {
 279                 if (padnum > 1)
 280                     memset(out + inl, 0, padnum - 1);
 281                 *(out + inl + padnum - 1) = padval;
 282             } else {
 283                 /* we need to add 'padnum' padding bytes of value padval */
 284                 for (loop = inl; loop < inl + padnum; loop++)
 285                     out[loop] = padval;
 286             }
 287             inl += padnum;
 288         }
 289
 290         if ((inl % blksz) != 0) {
 291             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 292             return 0;
 293         }
 294
 295
 296         /* Shouldn't normally fail */
 297         if (!ctx->hw->cipher(ctx, out, in, inl)) {
 298             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 299             return 0;
 300         }
 301
 302         if (ctx->alloced) {
 303             OPENSSL_free(ctx->tlsmac);
 304             ctx->alloced = 0;
 305             ctx->tlsmac = NULL;
 306         }
 307
 308         /* This only fails if padding is publicly invalid */
 309         *outl = inl;
 310         if (!ctx->enc
 311             && !ossl_cipher_tlsunpadblock(ctx->libctx, ctx->tlsversion,
 312                                           out, outl,
 313                                           blksz, &ctx->tlsmac, &ctx->alloced,
 314                                           ctx->tlsmacsize, 0)) {
 315             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 316             return 0;
 317         }
 318         return 1;
 319     }
 320
 321     if (ctx->bufsz != 0)
 322         nextblocks = ossl_cipher_fillblock(ctx->buf, &ctx->bufsz, blksz,
 323                                            &in, &inl);
 324     else
 325         nextblocks = inl & ~(blksz-1);
 326
 327     /*
 328      * If we're decrypting and we end an update on a block boundary we hold
 329      * the last block back in case this is the last update call and the last
 330      * block is padded.
 331      */
 332     if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) {
 333         if (outsize < blksz) {
 334             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 335             return 0;
 336         }
 337         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 338             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 339             return 0;
 340         }
 341         ctx->bufsz = 0;
 342         outlint = blksz;
 343         out += blksz;
 344     }
 345     if (nextblocks > 0) {
 346         if (!ctx->enc && ctx->pad && nextblocks == inl) {
 347             if (!ossl_assert(inl >= blksz)) {
 348                 ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 349                 return 0;
 350             }
 351             nextblocks -= blksz;
 352         }
 353         outlint += nextblocks;
 354         if (outsize < outlint) {
 355             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 356             return 0;
 357         }
 358     }
 359     if (nextblocks > 0) {
 360         if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
 361             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 362             return 0;
 363         }
 364         in += nextblocks;
 365         inl -= nextblocks;
 366     }
 367     if (inl != 0
 368         && !ossl_cipher_trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
 369         /* ERR_raise already called */
 370         return 0;
 371     }
 372
 373     *outl = outlint;
 374     return inl == 0;
 375 }
 376
 377 int ossl_cipher_generic_block_final(void *vctx, unsigned char *out,
 378                                     size_t *outl, size_t outsize)
 379 {
 380     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 381     size_t blksz = ctx->blocksize;
 382
 383     if (!ossl_prov_is_running())
 384         return 0;
 385
 386     if (ctx->tlsversion > 0) {
 387         /* We never finalize TLS, so this is an error */
 388         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 389         return 0;
 390     }
 391
 392     if (ctx->enc) {
 393         if (ctx->pad) {
 394             ossl_cipher_padblock(ctx->buf, &ctx->bufsz, blksz);
 395         } else if (ctx->bufsz == 0) {
 396             *outl = 0;
 397             return 1;
 398         } else if (ctx->bufsz != blksz) {
 399             ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 400             return 0;
 401         }
 402
 403         if (outsize < blksz) {
 404             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 405             return 0;
 406         }
 407         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 408             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 409             return 0;
 410         }
 411         ctx->bufsz = 0;
 412         *outl = blksz;
 413         return 1;
 414     }
 415
 416     /* Decrypting */
 417     if (ctx->bufsz != blksz) {
 418         if (ctx->bufsz == 0 && !ctx->pad) {
 419             *outl = 0;
 420             return 1;
 421         }
 422         ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 423         return 0;
 424     }
 425
 426     if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
 427         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 428         return 0;
 429     }
 430
 431     if (ctx->pad && !ossl_cipher_unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
 432         /* ERR_raise already called */
 433         return 0;
 434     }
 435
 436     if (outsize < ctx->bufsz) {
 437         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 438         return 0;
 439     }
 440     memcpy(out, ctx->buf, ctx->bufsz);
 441     *outl = ctx->bufsz;
 442     ctx->bufsz = 0;
 443     return 1;
 444 }
 445
 446 int ossl_cipher_generic_stream_update(void *vctx, unsigned char *out,
 447                                       size_t *outl, size_t outsize,
 448                                       const unsigned char *in, size_t inl)
 449 {
 450     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 451
 452     if (inl == 0) {
 453         *outl = 0;
 454         return 1;
 455     }
 456
 457     if (outsize < inl) {
 458         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 459         return 0;
 460     }
 461
 462     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 463         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 464         return 0;
 465     }
 466
 467     *outl = inl;
 468     if (!ctx->enc && ctx->tlsversion > 0) {
 469         /*
 470         * Remove any TLS padding. Only used by cipher_aes_cbc_hmac_sha1_hw.c and
 471         * cipher_aes_cbc_hmac_sha256_hw.c
 472         */
 473         if (ctx->removetlspad) {
 474             /*
 475              * We should have already failed in the cipher() call above if this
 476              * isn't true.
 477              */
 478             if (!ossl_assert(*outl >= (size_t)(out[inl - 1] + 1)))
 479                 return 0;
 480             /* The actual padding length */
 481             *outl -= out[inl - 1] + 1;
 482         }
 483
 484         /* TLS MAC and explicit IV if relevant. We should have already failed
 485          * in the cipher() call above if *outl is too short.
 486          */
 487         if (!ossl_assert(*outl >= ctx->removetlsfixed))
 488             return 0;
 489         *outl -= ctx->removetlsfixed;
 490
 491         /* Extract the MAC if there is one */
 492         if (ctx->tlsmacsize > 0) {
 493             if (*outl < ctx->tlsmacsize)
 494                 return 0;
 495
 496             ctx->tlsmac = out + *outl - ctx->tlsmacsize;
 497             *outl -= ctx->tlsmacsize;
 498         }
 499     }
 500
 501     return 1;
 502 }
 503 int ossl_cipher_generic_stream_final(void *vctx, unsigned char *out,
 504                                      size_t *outl, size_t outsize)
 505 {
 506     if (!ossl_prov_is_running())
 507         return 0;
 508
 509     *outl = 0;
 510     return 1;
 511 }
 512
 513 int ossl_cipher_generic_cipher(void *vctx, unsigned char *out, size_t *outl,
 514                                size_t outsize, const unsigned char *in,
 515                                size_t inl)
 516 {
 517     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 518
 519     if (!ossl_prov_is_running())
 520         return 0;
 521
 522     if (outsize < inl) {
 523         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 524         return 0;
 525     }
 526
 527     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 528         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 529         return 0;
 530     }
 531
 532     *outl = inl;
 533     return 1;
 534 }
 535
 536 int ossl_cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
 537 {
 538     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 539     OSSL_PARAM *p;
 540
 541     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
 542     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
 543         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 544         return 0;
 545     }
 546     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
 547     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
 548         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 549         return 0;
 550     }
 551     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
 552     if (p != NULL
 553         && !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen)
 554         && !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) {
 555         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 556         return 0;
 557     }
 558     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_UPDATED_IV);
 559     if (p != NULL
 560         && !OSSL_PARAM_set_octet_ptr(p, &ctx->iv, ctx->ivlen)
 561         && !OSSL_PARAM_set_octet_string(p, &ctx->iv, ctx->ivlen)) {
 562         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 563         return 0;
 564     }
 565     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
 566     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
 567         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 568         return 0;
 569     }
 570     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
 571     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
 572         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 573         return 0;
 574     }
 575     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS_MAC);
 576     if (p != NULL
 577         && !OSSL_PARAM_set_octet_ptr(p, ctx->tlsmac, ctx->tlsmacsize)) {
 578         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 579         return 0;
 580     }
 581     return 1;
 582 }
 583
 584 int ossl_cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 585 {
 586     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 587     const OSSL_PARAM *p;
 588
 589     if (params == NULL)
 590         return 1;
 591
 592     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
 593     if (p != NULL) {
 594         unsigned int pad;
 595
 596         if (!OSSL_PARAM_get_uint(p, &pad)) {
 597             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 598             return 0;
 599         }
 600         ctx->pad = pad ? 1 : 0;
 601     }
 602     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_USE_BITS);
 603     if (p != NULL) {
 604         unsigned int bits;
 605
 606         if (!OSSL_PARAM_get_uint(p, &bits)) {
 607             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 608             return 0;
 609         }
 610         ctx->use_bits = bits ? 1 : 0;
 611     }
 612     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION);
 613     if (p != NULL) {
 614         if (!OSSL_PARAM_get_uint(p, &ctx->tlsversion)) {
 615             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 616             return 0;
 617         }
 618     }
 619     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_MAC_SIZE);
 620     if (p != NULL) {
 621         if (!OSSL_PARAM_get_size_t(p, &ctx->tlsmacsize)) {
 622             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 623             return 0;
 624         }
 625     }
 626     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
 627     if (p != NULL) {
 628         unsigned int num;
 629
 630         if (!OSSL_PARAM_get_uint(p, &num)) {
 631             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 632             return 0;
 633         }
 634         ctx->num = num;
 635     }
 636     return 1;
 637 }
 638
 639 int ossl_cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
 640                                size_t ivlen)
 641 {
 642     if (ivlen != ctx->ivlen
 643         || ivlen > sizeof(ctx->iv)) {
 644         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
 645         return 0;
 646     }
 647     ctx->iv_set = 1;
 648     memcpy(ctx->iv, iv, ivlen);
 649     memcpy(ctx->oiv, iv, ivlen);
 650     return 1;
 651 }
 652
 653 void ossl_cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
 654                                  size_t ivbits, unsigned int mode,
 655                                  uint64_t flags, const PROV_CIPHER_HW *hw,
 656                                  void *provctx)
 657 {
 658     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 659
 660     if ((flags & PROV_CIPHER_FLAG_INVERSE_CIPHER) != 0)
 661         ctx->inverse_cipher = 1;
 662     if ((flags & PROV_CIPHER_FLAG_VARIABLE_LENGTH) != 0)
 663         ctx->variable_keylength = 1;
 664
 665     ctx->pad = 1;
 666     ctx->keylen = ((kbits) / 8);
 667     ctx->ivlen = ((ivbits) / 8);
 668     ctx->hw = hw;
 669     ctx->mode = mode;
 670     ctx->blocksize = blkbits / 8;
 671     if (provctx != NULL)
 672         ctx->libctx = PROV_LIBCTX_OF(provctx); /* used for rand */
 673 }