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