2 * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
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
11 * Generic dispatch table functions for ciphers.
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"
22 * Generic cipher functions for OSSL_PARAM gettables and settables
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
},
36 const OSSL_PARAM
*ossl_cipher_generic_gettable_params(ossl_unused
void *provctx
)
38 return cipher_known_gettable_params
;
41 int ossl_cipher_generic_get_params(OSSL_PARAM params
[], unsigned int md
,
43 size_t kbits
, size_t blkbits
, size_t ivbits
)
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
);
52 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_AEAD
);
54 && !OSSL_PARAM_set_int(p
, (flags
& PROV_CIPHER_FLAG_AEAD
) != 0)) {
55 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
58 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_CUSTOM_IV
);
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
);
64 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_CTS
);
66 && !OSSL_PARAM_set_int(p
, (flags
& PROV_CIPHER_FLAG_CTS
) != 0)) {
67 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
70 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK
);
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
);
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
);
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
);
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
);
94 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(ossl_cipher_generic
)
95 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(ossl_cipher_generic
)
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
)
103 * Variable key length cipher functions for OSSL_PARAM settables
105 int ossl_cipher_var_keylen_set_ctx_params(void *vctx
, const OSSL_PARAM params
[])
107 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
110 if (!ossl_cipher_generic_set_ctx_params(vctx
, params
))
112 p
= OSSL_PARAM_locate_const(params
, OSSL_CIPHER_PARAM_KEYLEN
);
116 if (!OSSL_PARAM_get_size_t(p
, &keylen
)) {
117 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_GET_PARAMETER
);
120 ctx
->keylen
= keylen
;
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
)
130 * AEAD cipher functions for OSSL_PARAM gettables and settables
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),
143 const OSSL_PARAM
*ossl_cipher_aead_gettable_ctx_params(
144 ossl_unused
void *cctx
, ossl_unused
void *provctx
147 return cipher_aead_known_gettable_ctx_params
;
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),
158 const OSSL_PARAM
*ossl_cipher_aead_settable_ctx_params(
159 ossl_unused
void *cctx
, ossl_unused
void *provctx
162 return cipher_aead_known_settable_ctx_params
;
165 void ossl_cipher_generic_reset_ctx(PROV_CIPHER_CTX
*ctx
)
167 if (ctx
!= NULL
&& ctx
->alloced
) {
168 OPENSSL_free(ctx
->tlsmac
);
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
,
182 ctx
->enc
= enc
? 1 : 0;
184 if (!ossl_prov_is_running())
187 if (iv
!= NULL
&& ctx
->mode
!= EVP_CIPH_ECB_MODE
) {
188 if (!ossl_cipher_generic_initiv(ctx
, iv
, ivlen
))
192 if (ctx
->variable_keylength
== 0) {
193 if (keylen
!= ctx
->keylen
) {
194 ERR_raise(ERR_LIB_PROV
, PROV_R_INVALID_KEY_LENGTH
);
198 ctx
->keylen
= keylen
;
200 return ctx
->hw
->init(ctx
, key
, ctx
->keylen
);
205 int ossl_cipher_generic_einit(void *vctx
, const unsigned char *key
,
206 size_t keylen
, const unsigned char *iv
,
209 return cipher_generic_init_internal((PROV_CIPHER_CTX
*)vctx
, key
, keylen
,
213 int ossl_cipher_generic_dinit(void *vctx
, const unsigned char *key
,
214 size_t keylen
, const unsigned char *iv
,
217 return cipher_generic_init_internal((PROV_CIPHER_CTX
*)vctx
, key
, keylen
,
221 /* Max padding including padding length byte */
222 #define MAX_PADDING 256
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
)
229 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
230 size_t blksz
= ctx
->blocksize
;
233 if (ctx
->tlsversion
> 0) {
235 * Each update call corresponds to a TLS record and is individually
239 /* Sanity check inputs */
244 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
249 unsigned char padval
;
254 padnum
= blksz
- (inl
% blksz
);
256 if (outsize
< inl
+ padnum
) {
257 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
261 if (padnum
> MAX_PADDING
) {
262 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
265 padval
= (unsigned char)(padnum
- 1);
266 if (ctx
->tlsversion
== SSL3_VERSION
) {
268 memset(out
+ inl
, 0, padnum
- 1);
269 *(out
+ inl
+ padnum
- 1) = padval
;
271 /* we need to add 'padnum' padding bytes of value padval */
272 for (loop
= inl
; loop
< inl
+ padnum
; loop
++)
278 if ((inl
% blksz
) != 0) {
279 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
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
);
291 OPENSSL_free(ctx
->tlsmac
);
296 /* This only fails if padding is publicly invalid */
299 && !ossl_cipher_tlsunpadblock(ctx
->libctx
, ctx
->tlsversion
,
301 blksz
, &ctx
->tlsmac
, &ctx
->alloced
,
302 ctx
->tlsmacsize
, 0)) {
303 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
310 nextblocks
= ossl_cipher_fillblock(ctx
->buf
, &ctx
->bufsz
, blksz
,
313 nextblocks
= inl
& ~(blksz
-1);
316 * If we're decrypting and we end an update on a block boundary we hold
317 * the last block back in case this is the last update call and the last
320 if (ctx
->bufsz
== blksz
&& (ctx
->enc
|| inl
> 0 || !ctx
->pad
)) {
321 if (outsize
< blksz
) {
322 ERR_raise(ERR_LIB_PROV
, PROV_R_OUTPUT_BUFFER_TOO_SMALL
);
325 if (!ctx
->hw
->cipher(ctx
, out
, ctx
->buf
, blksz
)) {
326 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
333 if (nextblocks
> 0) {
334 if (!ctx
->enc
&& ctx
->pad
&& nextblocks
== inl
) {
335 if (!ossl_assert(inl
>= blksz
)) {
336 ERR_raise(ERR_LIB_PROV
, PROV_R_OUTPUT_BUFFER_TOO_SMALL
);
341 outlint
+= nextblocks
;
342 if (outsize
< outlint
) {
343 ERR_raise(ERR_LIB_PROV
, PROV_R_OUTPUT_BUFFER_TOO_SMALL
);
347 if (nextblocks
> 0) {
348 if (!ctx
->hw
->cipher(ctx
, out
, in
, nextblocks
)) {
349 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
356 && !ossl_cipher_trailingdata(ctx
->buf
, &ctx
->bufsz
, blksz
, &in
, &inl
)) {
357 /* ERR_raise already called */
365 int ossl_cipher_generic_block_final(void *vctx
, unsigned char *out
,
366 size_t *outl
, size_t outsize
)
368 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
369 size_t blksz
= ctx
->blocksize
;
371 if (!ossl_prov_is_running())
374 if (ctx
->tlsversion
> 0) {
375 /* We never finalize TLS, so this is an error */
376 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
382 ossl_cipher_padblock(ctx
->buf
, &ctx
->bufsz
, blksz
);
383 } else if (ctx
->bufsz
== 0) {
386 } else if (ctx
->bufsz
!= blksz
) {
387 ERR_raise(ERR_LIB_PROV
, PROV_R_WRONG_FINAL_BLOCK_LENGTH
);
391 if (outsize
< blksz
) {
392 ERR_raise(ERR_LIB_PROV
, PROV_R_OUTPUT_BUFFER_TOO_SMALL
);
395 if (!ctx
->hw
->cipher(ctx
, out
, ctx
->buf
, blksz
)) {
396 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
405 if (ctx
->bufsz
!= blksz
) {
406 if (ctx
->bufsz
== 0 && !ctx
->pad
) {
410 ERR_raise(ERR_LIB_PROV
, PROV_R_WRONG_FINAL_BLOCK_LENGTH
);
414 if (!ctx
->hw
->cipher(ctx
, ctx
->buf
, ctx
->buf
, blksz
)) {
415 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
419 if (ctx
->pad
&& !ossl_cipher_unpadblock(ctx
->buf
, &ctx
->bufsz
, blksz
)) {
420 /* ERR_raise already called */
424 if (outsize
< ctx
->bufsz
) {
425 ERR_raise(ERR_LIB_PROV
, PROV_R_OUTPUT_BUFFER_TOO_SMALL
);
428 memcpy(out
, ctx
->buf
, ctx
->bufsz
);
434 int ossl_cipher_generic_stream_update(void *vctx
, unsigned char *out
,
435 size_t *outl
, size_t outsize
,
436 const unsigned char *in
, size_t inl
)
438 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
446 ERR_raise(ERR_LIB_PROV
, PROV_R_OUTPUT_BUFFER_TOO_SMALL
);
450 if (!ctx
->hw
->cipher(ctx
, out
, in
, inl
)) {
451 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
456 if (!ctx
->enc
&& ctx
->tlsversion
> 0) {
458 * Remove any TLS padding. Only used by cipher_aes_cbc_hmac_sha1_hw.c and
459 * cipher_aes_cbc_hmac_sha256_hw.c
461 if (ctx
->removetlspad
) {
463 * We should have already failed in the cipher() call above if this
466 if (!ossl_assert(*outl
>= (size_t)(out
[inl
- 1] + 1)))
468 /* The actual padding length */
469 *outl
-= out
[inl
- 1] + 1;
472 /* TLS MAC and explicit IV if relevant. We should have already failed
473 * in the cipher() call above if *outl is too short.
475 if (!ossl_assert(*outl
>= ctx
->removetlsfixed
))
477 *outl
-= ctx
->removetlsfixed
;
479 /* Extract the MAC if there is one */
480 if (ctx
->tlsmacsize
> 0) {
481 if (*outl
< ctx
->tlsmacsize
)
484 ctx
->tlsmac
= out
+ *outl
- ctx
->tlsmacsize
;
485 *outl
-= ctx
->tlsmacsize
;
491 int ossl_cipher_generic_stream_final(void *vctx
, unsigned char *out
,
492 size_t *outl
, size_t outsize
)
494 if (!ossl_prov_is_running())
501 int ossl_cipher_generic_cipher(void *vctx
, unsigned char *out
, size_t *outl
,
502 size_t outsize
, const unsigned char *in
,
505 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
507 if (!ossl_prov_is_running())
511 ERR_raise(ERR_LIB_PROV
, PROV_R_OUTPUT_BUFFER_TOO_SMALL
);
515 if (!ctx
->hw
->cipher(ctx
, out
, in
, inl
)) {
516 ERR_raise(ERR_LIB_PROV
, PROV_R_CIPHER_OPERATION_FAILED
);
524 int ossl_cipher_generic_get_ctx_params(void *vctx
, OSSL_PARAM params
[])
526 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
529 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_IVLEN
);
530 if (p
!= NULL
&& !OSSL_PARAM_set_size_t(p
, ctx
->ivlen
)) {
531 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
534 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_PADDING
);
535 if (p
!= NULL
&& !OSSL_PARAM_set_uint(p
, ctx
->pad
)) {
536 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
539 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_IV
);
541 && !OSSL_PARAM_set_octet_ptr(p
, &ctx
->oiv
, ctx
->ivlen
)
542 && !OSSL_PARAM_set_octet_string(p
, &ctx
->oiv
, ctx
->ivlen
)) {
543 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
546 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_UPDATED_IV
);
548 && !OSSL_PARAM_set_octet_ptr(p
, &ctx
->iv
, ctx
->ivlen
)
549 && !OSSL_PARAM_set_octet_string(p
, &ctx
->iv
, ctx
->ivlen
)) {
550 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
553 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_NUM
);
554 if (p
!= NULL
&& !OSSL_PARAM_set_uint(p
, ctx
->num
)) {
555 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
558 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_KEYLEN
);
559 if (p
!= NULL
&& !OSSL_PARAM_set_size_t(p
, ctx
->keylen
)) {
560 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
563 p
= OSSL_PARAM_locate(params
, OSSL_CIPHER_PARAM_TLS_MAC
);
565 && !OSSL_PARAM_set_octet_ptr(p
, ctx
->tlsmac
, ctx
->tlsmacsize
)) {
566 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_SET_PARAMETER
);
572 int ossl_cipher_generic_set_ctx_params(void *vctx
, const OSSL_PARAM params
[])
574 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
577 p
= OSSL_PARAM_locate_const(params
, OSSL_CIPHER_PARAM_PADDING
);
581 if (!OSSL_PARAM_get_uint(p
, &pad
)) {
582 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_GET_PARAMETER
);
585 ctx
->pad
= pad
? 1 : 0;
587 p
= OSSL_PARAM_locate_const(params
, OSSL_CIPHER_PARAM_TLS_VERSION
);
589 if (!OSSL_PARAM_get_uint(p
, &ctx
->tlsversion
)) {
590 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_GET_PARAMETER
);
594 p
= OSSL_PARAM_locate_const(params
, OSSL_CIPHER_PARAM_TLS_MAC_SIZE
);
596 if (!OSSL_PARAM_get_size_t(p
, &ctx
->tlsmacsize
)) {
597 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_GET_PARAMETER
);
601 p
= OSSL_PARAM_locate_const(params
, OSSL_CIPHER_PARAM_NUM
);
605 if (!OSSL_PARAM_get_uint(p
, &num
)) {
606 ERR_raise(ERR_LIB_PROV
, PROV_R_FAILED_TO_GET_PARAMETER
);
614 int ossl_cipher_generic_initiv(PROV_CIPHER_CTX
*ctx
, const unsigned char *iv
,
617 if (ivlen
!= ctx
->ivlen
618 || ivlen
> sizeof(ctx
->iv
)) {
619 ERR_raise(ERR_LIB_PROV
, PROV_R_INVALID_IV_LENGTH
);
623 memcpy(ctx
->iv
, iv
, ivlen
);
624 memcpy(ctx
->oiv
, iv
, ivlen
);
628 void ossl_cipher_generic_initkey(void *vctx
, size_t kbits
, size_t blkbits
,
629 size_t ivbits
, unsigned int mode
,
630 uint64_t flags
, const PROV_CIPHER_HW
*hw
,
633 PROV_CIPHER_CTX
*ctx
= (PROV_CIPHER_CTX
*)vctx
;
635 if ((flags
& PROV_CIPHER_FLAG_INVERSE_CIPHER
) != 0)
636 ctx
->inverse_cipher
= 1;
637 if ((flags
& PROV_CIPHER_FLAG_VARIABLE_LENGTH
) != 0)
638 ctx
->variable_keylength
= 1;
641 ctx
->keylen
= ((kbits
) / 8);
642 ctx
->ivlen
= ((ivbits
) / 8);
645 ctx
->blocksize
= blkbits
/ 8;
647 ctx
->libctx
= PROV_LIBCTX_OF(provctx
); /* used for rand */