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