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