providers/implementations/ciphers/ciphercommon.c

   1 /*
   2  * Copyright 2019-2020 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 "ciphercommon_local.h"
  17 #include "prov/provider_ctx.h"
  18 #include "prov/providercommon.h"
  19 #include "prov/providercommonerr.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_ulong(OSSL_CIPHER_PARAM_FLAGS, NULL),
  30     { OSSL_CIPHER_PARAM_TLS_MAC, OSSL_PARAM_OCTET_PTR, NULL, 0, OSSL_PARAM_UNMODIFIED },
  31     OSSL_PARAM_END
  32 };
  33 const OSSL_PARAM *cipher_generic_gettable_params(void *provctx)
  34 {
  35     return cipher_known_gettable_params;
  36 }
  37
  38 int cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
  39                               unsigned long flags,
  40                               size_t kbits, size_t blkbits, size_t ivbits)
  41 {
  42     OSSL_PARAM *p;
  43
  44     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE);
  45     if (p != NULL && !OSSL_PARAM_set_uint(p, md)) {
  46         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  47         return 0;
  48     }
  49     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_FLAGS);
  50     if (p != NULL && !OSSL_PARAM_set_ulong(p, flags)) {
  51         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  52         return 0;
  53     }
  54     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
  55     if (p != NULL && !OSSL_PARAM_set_size_t(p, kbits / 8)) {
  56         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  57         return 0;
  58     }
  59     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE);
  60     if (p != NULL && !OSSL_PARAM_set_size_t(p, blkbits / 8)) {
  61         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  62         return 0;
  63     }
  64     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
  65     if (p != NULL && !OSSL_PARAM_set_size_t(p, ivbits / 8)) {
  66         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  67         return 0;
  68     }
  69     return 1;
  70 }
  71
  72 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(cipher_generic)
  73 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(cipher_generic)
  74
  75 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(cipher_generic)
  76 OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
  77 OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
  78 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(cipher_generic)
  79
  80 /*
  81  * Variable key length cipher functions for OSSL_PARAM settables
  82  */
  83
  84 int cipher_var_keylen_set_ctx_params(void *vctx, const OSSL_PARAM params[])
  85 {
  86     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
  87     const OSSL_PARAM *p;
  88
  89     if (!cipher_generic_set_ctx_params(vctx, params))
  90         return 0;
  91     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
  92     if (p != NULL) {
  93         size_t keylen;
  94
  95         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
  96             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
  97             return 0;
  98         }
  99         ctx->keylen = keylen;
 100     }
 101     return 1;
 102 }
 103
 104 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(cipher_var_keylen)
 105 OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 106 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(cipher_var_keylen)
 107
 108 /*-
 109  * AEAD cipher functions for OSSL_PARAM gettables and settables
 110  */
 111 static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = {
 112     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 113     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
 114     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
 115     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
 116     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV_STATE, NULL, 0),
 117     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 118     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
 119     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, NULL, 0),
 120     OSSL_PARAM_END
 121 };
 122 const OSSL_PARAM *cipher_aead_gettable_ctx_params(ossl_unused void *provctx)
 123 {
 124     return cipher_aead_known_gettable_ctx_params;
 125 }
 126
 127 static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
 128     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
 129     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 130     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
 131     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
 132     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, NULL, 0),
 133     OSSL_PARAM_END
 134 };
 135 const OSSL_PARAM *cipher_aead_settable_ctx_params(ossl_unused void *provctx)
 136 {
 137     return cipher_aead_known_settable_ctx_params;
 138 }
 139
 140 void cipher_generic_reset_ctx(PROV_CIPHER_CTX *ctx)
 141 {
 142     if (ctx != NULL && ctx->alloced) {
 143         OPENSSL_free(ctx->tlsmac);
 144         ctx->alloced = 0;
 145         ctx->tlsmac = NULL;
 146     }
 147 }
 148
 149 static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
 150                                         const unsigned char *key, size_t keylen,
 151                                         const unsigned char *iv, size_t ivlen,
 152                                         int enc)
 153 {
 154     ctx->num = 0;
 155     ctx->bufsz = 0;
 156     ctx->updated = 0;
 157     ctx->enc = enc ? 1 : 0;
 158
 159     if (!ossl_prov_is_running())
 160         return 0;
 161
 162     if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
 163         if (!cipher_generic_initiv(ctx, iv, ivlen))
 164             return 0;
 165     }
 166     if (key != NULL) {
 167         if ((ctx->flags & EVP_CIPH_VARIABLE_LENGTH) == 0) {
 168             if (keylen != ctx->keylen) {
 169                 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEYLEN);
 170                 return 0;
 171             }
 172         } else {
 173             ctx->keylen = keylen;
 174         }
 175         return ctx->hw->init(ctx, key, ctx->keylen);
 176     }
 177     return 1;
 178 }
 179
 180 int cipher_generic_einit(void *vctx, const unsigned char *key, size_t keylen,
 181                          const unsigned char *iv, size_t ivlen)
 182 {
 183     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 184                                         iv, ivlen, 1);
 185 }
 186
 187 int cipher_generic_dinit(void *vctx, const unsigned char *key, size_t keylen,
 188                          const unsigned char *iv, size_t ivlen)
 189 {
 190     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 191                                         iv, ivlen, 0);
 192 }
 193
 194 /* Max padding including padding length byte */
 195 #define MAX_PADDING 256
 196
 197 int cipher_generic_block_update(void *vctx, unsigned char *out, size_t *outl,
 198                                 size_t outsize, const unsigned char *in,
 199                                 size_t inl)
 200 {
 201     size_t outlint = 0;
 202     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 203     size_t blksz = ctx->blocksize;
 204     size_t nextblocks;
 205
 206     if (ctx->tlsversion > 0) {
 207         /*
 208          * Each update call corresponds to a TLS record and is individually
 209          * padded
 210          */
 211
 212         /* Sanity check inputs */
 213         if (in == NULL
 214                 || in != out
 215                 || outsize < inl
 216                 || !ctx->pad) {
 217             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 218             return 0;
 219         }
 220
 221         if (ctx->enc) {
 222             unsigned char padval;
 223             size_t padnum, loop;
 224
 225             /* Add padding */
 226
 227             padnum = blksz - (inl % blksz);
 228
 229             if (outsize < inl + padnum) {
 230                 ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 231                 return 0;
 232             }
 233
 234             if (padnum > MAX_PADDING) {
 235                 ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 236                 return 0;
 237             }
 238             padval = (unsigned char)(padnum - 1);
 239             if (ctx->tlsversion == SSL3_VERSION) {
 240                 if (padnum > 1)
 241                     memset(out + inl, 0, padnum - 1);
 242                 *(out + inl + padnum - 1) = padval;
 243             } else {
 244                 /* we need to add 'padnum' padding bytes of value padval */
 245                 for (loop = inl; loop < inl + padnum; loop++)
 246                     out[loop] = padval;
 247             }
 248             inl += padnum;
 249         }
 250
 251         if ((inl % blksz) != 0) {
 252             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 253             return 0;
 254         }
 255
 256
 257         /* Shouldn't normally fail */
 258         if (!ctx->hw->cipher(ctx, out, in, inl)) {
 259             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 260             return 0;
 261         }
 262
 263         if (ctx->alloced) {
 264             OPENSSL_free(ctx->tlsmac);
 265             ctx->alloced = 0;
 266             ctx->tlsmac = NULL;
 267         }
 268
 269         /* This only fails if padding is publicly invalid */
 270         *outl = inl;
 271         if (!ctx->enc
 272                 && !tlsunpadblock(ctx->libctx, ctx->tlsversion, out, outl,
 273                                   blksz, &ctx->tlsmac, &ctx->alloced,
 274                                   ctx->tlsmacsize, 0)) {
 275             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 276             return 0;
 277         }
 278         return 1;
 279     }
 280
 281     if (ctx->bufsz != 0)
 282         nextblocks = fillblock(ctx->buf, &ctx->bufsz, blksz, &in, &inl);
 283     else
 284         nextblocks = inl & ~(blksz-1);
 285
 286     /*
 287      * If we're decrypting and we end an update on a block boundary we hold
 288      * the last block back in case this is the last update call and the last
 289      * block is padded.
 290      */
 291     if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) {
 292         if (outsize < blksz) {
 293             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 294             return 0;
 295         }
 296         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 297             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 298             return 0;
 299         }
 300         ctx->bufsz = 0;
 301         outlint = blksz;
 302         out += blksz;
 303     }
 304     if (nextblocks > 0) {
 305         if (!ctx->enc && ctx->pad && nextblocks == inl) {
 306             if (!ossl_assert(inl >= blksz)) {
 307                 ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 308                 return 0;
 309             }
 310             nextblocks -= blksz;
 311         }
 312         outlint += nextblocks;
 313         if (outsize < outlint) {
 314             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 315             return 0;
 316         }
 317     }
 318     if (nextblocks > 0) {
 319         if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
 320             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 321             return 0;
 322         }
 323         in += nextblocks;
 324         inl -= nextblocks;
 325     }
 326     if (inl != 0 && !trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
 327         /* ERR_raise already called */
 328         return 0;
 329     }
 330
 331     *outl = outlint;
 332     return inl == 0;
 333 }
 334
 335 int cipher_generic_block_final(void *vctx, unsigned char *out, size_t *outl,
 336                                size_t outsize)
 337 {
 338     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 339     size_t blksz = ctx->blocksize;
 340
 341     if (!ossl_prov_is_running())
 342         return 0;
 343
 344     if (ctx->tlsversion > 0) {
 345         /* We never finalize TLS, so this is an error */
 346         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 347         return 0;
 348     }
 349
 350     if (ctx->enc) {
 351         if (ctx->pad) {
 352             padblock(ctx->buf, &ctx->bufsz, blksz);
 353         } else if (ctx->bufsz == 0) {
 354             *outl = 0;
 355             return 1;
 356         } else if (ctx->bufsz != blksz) {
 357             ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 358             return 0;
 359         }
 360
 361         if (outsize < blksz) {
 362             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 363             return 0;
 364         }
 365         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 366             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 367             return 0;
 368         }
 369         ctx->bufsz = 0;
 370         *outl = blksz;
 371         return 1;
 372     }
 373
 374     /* Decrypting */
 375     if (ctx->bufsz != blksz) {
 376         if (ctx->bufsz == 0 && !ctx->pad) {
 377             *outl = 0;
 378             return 1;
 379         }
 380         ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 381         return 0;
 382     }
 383
 384     if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
 385         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 386         return 0;
 387     }
 388
 389     if (ctx->pad && !unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
 390         /* ERR_raise already called */
 391         return 0;
 392     }
 393
 394     if (outsize < ctx->bufsz) {
 395         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 396         return 0;
 397     }
 398     memcpy(out, ctx->buf, ctx->bufsz);
 399     *outl = ctx->bufsz;
 400     ctx->bufsz = 0;
 401     return 1;
 402 }
 403
 404 int cipher_generic_stream_update(void *vctx, unsigned char *out, size_t *outl,
 405                                  size_t outsize, const unsigned char *in,
 406                                  size_t inl)
 407 {
 408     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 409
 410     if (inl == 0) {
 411         *outl = 0;
 412         return 1;
 413     }
 414
 415     if (outsize < inl) {
 416         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 417         return 0;
 418     }
 419
 420     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 421         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 422         return 0;
 423     }
 424
 425     *outl = inl;
 426     /*
 427      * Remove any TLS padding. Only used by cipher_aes_cbc_hmac_sha1_hw.c and
 428      * cipher_aes_cbc_hmac_sha256_hw.c
 429      */
 430     if (!ctx->enc && ctx->removetlspad > 0) {
 431         /* The actual padding length */
 432         *outl -= out[inl - 1] + 1;
 433
 434         /* MAC and explicit IV */
 435         *outl -= ctx->removetlspad;
 436     }
 437
 438     return 1;
 439 }
 440 int cipher_generic_stream_final(void *vctx, unsigned char *out, size_t *outl,
 441                                 size_t outsize)
 442 {
 443     if (!ossl_prov_is_running())
 444         return 0;
 445
 446     *outl = 0;
 447     return 1;
 448 }
 449
 450 int cipher_generic_cipher(void *vctx,
 451                           unsigned char *out, size_t *outl, size_t outsize,
 452                           const unsigned char *in, size_t inl)
 453 {
 454     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 455
 456     if (!ossl_prov_is_running())
 457         return 0;
 458
 459     if (outsize < inl) {
 460         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 461         return 0;
 462     }
 463
 464     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 465         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 466         return 0;
 467     }
 468
 469     *outl = inl;
 470     return 1;
 471 }
 472
 473 int cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
 474 {
 475     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 476     OSSL_PARAM *p;
 477
 478     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
 479     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
 480         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 481         return 0;
 482     }
 483     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
 484     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
 485         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 486         return 0;
 487     }
 488     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
 489     if (p != NULL
 490         && !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen)
 491         && !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) {
 492         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 493         return 0;
 494     }
 495     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV_STATE);
 496     if (p != NULL
 497         && !OSSL_PARAM_set_octet_ptr(p, &ctx->iv, ctx->ivlen)
 498         && !OSSL_PARAM_set_octet_string(p, &ctx->iv, ctx->ivlen)) {
 499         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 500         return 0;
 501     }
 502     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
 503     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
 504         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 505         return 0;
 506     }
 507     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
 508     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
 509         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 510         return 0;
 511     }
 512     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS_MAC);
 513     if (p != NULL
 514         && !OSSL_PARAM_set_octet_ptr(p, ctx->tlsmac, ctx->tlsmacsize)) {
 515         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 516         return 0;
 517     }
 518     return 1;
 519 }
 520
 521 int cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 522 {
 523     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 524     const OSSL_PARAM *p;
 525
 526     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
 527     if (p != NULL) {
 528         unsigned int pad;
 529
 530         if (!OSSL_PARAM_get_uint(p, &pad)) {
 531             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 532             return 0;
 533         }
 534         ctx->pad = pad ? 1 : 0;
 535     }
 536     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION);
 537     if (p != NULL) {
 538         if (!OSSL_PARAM_get_uint(p, &ctx->tlsversion)) {
 539             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 540             return 0;
 541         }
 542     }
 543     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_MAC_SIZE);
 544     if (p != NULL) {
 545         if (!OSSL_PARAM_get_size_t(p, &ctx->tlsmacsize)) {
 546             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 547             return 0;
 548         }
 549     }
 550     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
 551     if (p != NULL) {
 552         unsigned int num;
 553
 554         if (!OSSL_PARAM_get_uint(p, &num)) {
 555             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 556             return 0;
 557         }
 558         ctx->num = num;
 559     }
 560     return 1;
 561 }
 562
 563 int cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
 564                           size_t ivlen)
 565 {
 566     if (ivlen != ctx->ivlen
 567         || ivlen > sizeof(ctx->iv)) {
 568         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
 569         return 0;
 570     }
 571     ctx->iv_set = 1;
 572     memcpy(ctx->iv, iv, ivlen);
 573     memcpy(ctx->oiv, iv, ivlen);
 574     return 1;
 575 }
 576
 577 void cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
 578                             size_t ivbits, unsigned int mode, uint64_t flags,
 579                             const PROV_CIPHER_HW *hw, void *provctx)
 580 {
 581     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 582
 583     ctx->flags = flags;
 584     ctx->pad = 1;
 585     ctx->keylen = ((kbits) / 8);
 586     ctx->ivlen = ((ivbits) / 8);
 587     ctx->hw = hw;
 588     ctx->mode = mode;
 589     ctx->blocksize = blkbits / 8;
 590     if (provctx != NULL)
 591         ctx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx); /* used for rand */
 592 }