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