]> git.ipfire.org Git - thirdparty/openssl.git/blame - crypto/evp/evp_enc.c
Make core code available within the FIPS module
[thirdparty/openssl.git] / crypto / evp / evp_enc.c
CommitLineData
62867571 1/*
b0edda11 2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
d02b48c6 3 *
4a8b0c55 4 * Licensed under the Apache License 2.0 (the "License"). You may not use
62867571
RS
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
d02b48c6
RE
8 */
9
10#include <stdio.h>
c3a73daf 11#include <assert.h>
b39fc560 12#include "internal/cryptlib.h"
ec577822 13#include <openssl/evp.h>
7f060601 14#include <openssl/err.h>
3a87a9b9 15#include <openssl/rand.h>
6decf943 16#include <openssl/rand_drbg.h>
3c27208f 17#include <openssl/engine.h>
df05f2ce
MC
18#include <openssl/params.h>
19#include <openssl/core_names.h>
135727ab 20#include "internal/evp_int.h"
df05f2ce 21#include "internal/provider.h"
57ae2e24 22#include "evp_locl.h"
d02b48c6 23
df05f2ce 24int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx)
0f113f3e 25{
df05f2ce 26 if (ctx == NULL)
8baf9968 27 return 1;
df05f2ce
MC
28
29 if (ctx->cipher == NULL || ctx->cipher->prov == NULL)
30 goto legacy;
31
32 if (ctx->provctx != NULL) {
33 if (ctx->cipher->freectx != NULL)
34 ctx->cipher->freectx(ctx->provctx);
35 ctx->provctx = NULL;
36 }
37 if (ctx->fetched_cipher != NULL)
38 EVP_CIPHER_meth_free(ctx->fetched_cipher);
39 memset(ctx, 0, sizeof(*ctx));
40
41 return 1;
42
43 /* TODO(3.0): Remove legacy code below */
44 legacy:
45
46 if (ctx->cipher != NULL) {
47 if (ctx->cipher->cleanup && !ctx->cipher->cleanup(ctx))
8baf9968
RL
48 return 0;
49 /* Cleanse cipher context data */
df05f2ce
MC
50 if (ctx->cipher_data && ctx->cipher->ctx_size)
51 OPENSSL_cleanse(ctx->cipher_data, ctx->cipher->ctx_size);
8baf9968 52 }
df05f2ce 53 OPENSSL_free(ctx->cipher_data);
8baf9968 54#ifndef OPENSSL_NO_ENGINE
df05f2ce 55 ENGINE_finish(ctx->engine);
8baf9968 56#endif
df05f2ce 57 memset(ctx, 0, sizeof(*ctx));
8baf9968 58 return 1;
0f113f3e 59}
d02b48c6 60
b40228a6 61EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void)
0f113f3e 62{
8baf9968
RL
63 return OPENSSL_zalloc(sizeof(EVP_CIPHER_CTX));
64}
65
66void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
67{
68 EVP_CIPHER_CTX_reset(ctx);
69 OPENSSL_free(ctx);
0f113f3e 70}
581f1c84 71
360370d9 72int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
0f113f3e
MC
73 const unsigned char *key, const unsigned char *iv, int enc)
74{
ffd23209
KR
75 if (cipher != NULL)
76 EVP_CIPHER_CTX_reset(ctx);
0f113f3e
MC
77 return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc);
78}
79
80int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
81 ENGINE *impl, const unsigned char *key,
82 const unsigned char *iv, int enc)
83{
df05f2ce
MC
84 EVP_CIPHER *provciph = NULL;
85 ENGINE *tmpimpl = NULL;
86 const EVP_CIPHER *tmpcipher;
87
88 /*
89 * enc == 1 means we are encrypting.
90 * enc == 0 means we are decrypting.
91 * enc == -1 means, use the previously initialised value for encrypt/decrypt
92 */
93 if (enc == -1) {
0f113f3e 94 enc = ctx->encrypt;
df05f2ce 95 } else {
0f113f3e
MC
96 if (enc)
97 enc = 1;
98 ctx->encrypt = enc;
99 }
df05f2ce
MC
100
101 if (cipher == NULL && ctx->cipher == NULL) {
102 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET);
103 return 0;
104 }
105
106 /* TODO(3.0): Legacy work around code below. Remove this */
107
0b13e9f0 108#ifndef OPENSSL_NO_ENGINE
0f113f3e
MC
109 /*
110 * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so
111 * this context may already have an ENGINE! Try to avoid releasing the
112 * previous handle, re-querying for an ENGINE, and having a
0d4fb843 113 * reinitialisation, when it may all be unnecessary.
0f113f3e 114 */
f6b94279 115 if (ctx->engine && ctx->cipher
a7f9e0a4 116 && (cipher == NULL || cipher->nid == ctx->cipher->nid))
0f113f3e 117 goto skip_to_init;
df05f2ce
MC
118
119 if (cipher != NULL && impl == NULL) {
120 /* Ask if an ENGINE is reserved for this job */
121 tmpimpl = ENGINE_get_cipher_engine(cipher->nid);
122 }
0b13e9f0 123#endif
df05f2ce
MC
124
125 /*
126 * If there are engines involved then we should use legacy handling for now.
127 */
128 if (ctx->engine != NULL
129 || impl != NULL
130 || tmpimpl != NULL) {
131 if (ctx->cipher == ctx->fetched_cipher)
132 ctx->cipher = NULL;
133 EVP_CIPHER_meth_free(ctx->fetched_cipher);
134 ctx->fetched_cipher = NULL;
135 goto legacy;
136 }
137
138 tmpcipher = (cipher == NULL) ? ctx->cipher : cipher;
139
140 if (tmpcipher->prov == NULL) {
141 switch(tmpcipher->nid) {
aab26e6f 142 case NID_aes_256_ecb:
f4a129bb
MC
143 case NID_aes_192_ecb:
144 case NID_aes_128_ecb:
718b133a
MC
145 case NID_aes_256_cbc:
146 case NID_aes_192_cbc:
147 case NID_aes_128_cbc:
ed98df51
MC
148 case NID_aes_256_ofb128:
149 case NID_aes_192_ofb128:
150 case NID_aes_128_ofb128:
75dd6d64
MC
151 case NID_aes_256_cfb128:
152 case NID_aes_192_cfb128:
153 case NID_aes_128_cfb128:
154 case NID_aes_256_cfb1:
155 case NID_aes_192_cfb1:
156 case NID_aes_128_cfb1:
157 case NID_aes_256_cfb8:
158 case NID_aes_192_cfb8:
159 case NID_aes_128_cfb8:
819a7ae9
MC
160 case NID_aes_256_ctr:
161 case NID_aes_192_ctr:
162 case NID_aes_128_ctr:
aab26e6f 163 break;
df05f2ce
MC
164 default:
165 goto legacy;
166 }
167 }
168
169 /*
170 * Ensure a context left lying around from last time is cleared
171 * (legacy code)
172 */
173 if (cipher != NULL && ctx->cipher != NULL) {
174 OPENSSL_clear_free(ctx->cipher_data, ctx->cipher->ctx_size);
175 ctx->cipher_data = NULL;
176 }
177
178
179 /* TODO(3.0): Start of non-legacy code below */
180
181 /* Ensure a context left lying around from last time is cleared */
182 if (cipher != NULL && ctx->cipher != NULL) {
183 unsigned long flags = ctx->flags;
184
185 EVP_CIPHER_CTX_reset(ctx);
186 /* Restore encrypt and flags */
187 ctx->encrypt = enc;
188 ctx->flags = flags;
189 }
190
191 if (cipher != NULL)
192 ctx->cipher = cipher;
193 else
194 cipher = ctx->cipher;
195
196 if (cipher->prov == NULL) {
197 provciph = EVP_CIPHER_fetch(NULL, OBJ_nid2sn(cipher->nid), "");
198 if (provciph == NULL) {
199 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
200 return 0;
201 }
202 cipher = provciph;
203 EVP_CIPHER_meth_free(ctx->fetched_cipher);
204 ctx->fetched_cipher = provciph;
205 }
206
207 ctx->cipher = cipher;
208 if (ctx->provctx == NULL) {
a39eb840 209 ctx->provctx = ctx->cipher->newctx(ossl_provider_ctx(cipher->prov));
df05f2ce
MC
210 if (ctx->provctx == NULL) {
211 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
212 return 0;
213 }
214 }
215
216 if ((ctx->flags & EVP_CIPH_NO_PADDING) != 0) {
0f113f3e 217 /*
df05f2ce
MC
218 * If this ctx was already set up for no padding then we need to tell
219 * the new cipher about it.
220 */
221 if (!EVP_CIPHER_CTX_set_padding(ctx, 0))
222 return 0;
223 }
224
718b133a
MC
225 switch (EVP_CIPHER_mode(ctx->cipher)) {
226 case EVP_CIPH_CFB_MODE:
227 case EVP_CIPH_OFB_MODE:
228 case EVP_CIPH_CBC_MODE:
229 /* For these modes we remember the original IV for later use */
230 if (!ossl_assert(EVP_CIPHER_CTX_iv_length(ctx) <= (int)sizeof(ctx->oiv))) {
231 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
232 return 0;
233 }
234 if (iv != NULL)
235 memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
236 }
237
df05f2ce
MC
238 if (enc) {
239 if (ctx->cipher->einit == NULL) {
240 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
241 return 0;
242 }
243
344cfa34
MC
244 return ctx->cipher->einit(ctx->provctx,
245 key,
33b40a10
MC
246 key == NULL ? 0
247 : EVP_CIPHER_CTX_key_length(ctx),
344cfa34 248 iv,
33b40a10
MC
249 iv == NULL ? 0
250 : EVP_CIPHER_CTX_iv_length(ctx));
df05f2ce
MC
251 }
252
253 if (ctx->cipher->dinit == NULL) {
254 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
255 return 0;
256 }
257
344cfa34
MC
258 return ctx->cipher->dinit(ctx->provctx,
259 key,
33b40a10
MC
260 key == NULL ? 0
261 : EVP_CIPHER_CTX_key_length(ctx),
344cfa34 262 iv,
33b40a10
MC
263 iv == NULL ? 0
264 : EVP_CIPHER_CTX_iv_length(ctx));
df05f2ce
MC
265
266 /* TODO(3.0): Remove legacy code below */
267 legacy:
268
269 if (cipher != NULL) {
270 /*
271 * Ensure a context left lying around from last time is cleared (we
272 * previously attempted to avoid this if the same ENGINE and
0f113f3e
MC
273 * EVP_CIPHER could be used).
274 */
275 if (ctx->cipher) {
276 unsigned long flags = ctx->flags;
c0ca39bd 277 EVP_CIPHER_CTX_reset(ctx);
0f113f3e
MC
278 /* Restore encrypt and flags */
279 ctx->encrypt = enc;
280 ctx->flags = flags;
281 }
0b13e9f0 282#ifndef OPENSSL_NO_ENGINE
df05f2ce 283 if (impl != NULL) {
0f113f3e
MC
284 if (!ENGINE_init(impl)) {
285 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
286 return 0;
287 }
df05f2ce
MC
288 } else {
289 impl = tmpimpl;
290 }
291 if (impl != NULL) {
0f113f3e
MC
292 /* There's an ENGINE for this job ... (apparently) */
293 const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid);
df05f2ce
MC
294
295 if (c == NULL) {
0f113f3e
MC
296 /*
297 * One positive side-effect of US's export control history,
298 * is that we should at least be able to avoid using US
0d4fb843 299 * misspellings of "initialisation"?
0f113f3e
MC
300 */
301 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
302 return 0;
303 }
304 /* We'll use the ENGINE's private cipher definition */
305 cipher = c;
306 /*
307 * Store the ENGINE functional reference so we know 'cipher' came
308 * from an ENGINE and we need to release it when done.
309 */
310 ctx->engine = impl;
df05f2ce 311 } else {
0f113f3e 312 ctx->engine = NULL;
df05f2ce 313 }
0b13e9f0 314#endif
544a2aea 315
0f113f3e
MC
316 ctx->cipher = cipher;
317 if (ctx->cipher->ctx_size) {
b51bce94 318 ctx->cipher_data = OPENSSL_zalloc(ctx->cipher->ctx_size);
90945fa3 319 if (ctx->cipher_data == NULL) {
273a0218 320 ctx->cipher = NULL;
0f113f3e
MC
321 EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE);
322 return 0;
323 }
324 } else {
325 ctx->cipher_data = NULL;
326 }
327 ctx->key_len = cipher->key_len;
328 /* Preserve wrap enable flag, zero everything else */
329 ctx->flags &= EVP_CIPHER_CTX_FLAG_WRAP_ALLOW;
330 if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) {
331 if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) {
273a0218 332 ctx->cipher = NULL;
0f113f3e
MC
333 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
334 return 0;
335 }
336 }
0f113f3e 337 }
0b13e9f0 338#ifndef OPENSSL_NO_ENGINE
0f113f3e 339 skip_to_init:
0b13e9f0 340#endif
1702c500
P
341 if (ctx->cipher == NULL)
342 return 0;
343
0f113f3e
MC
344 /* we assume block size is a power of 2 in *cryptUpdate */
345 OPENSSL_assert(ctx->cipher->block_size == 1
346 || ctx->cipher->block_size == 8
347 || ctx->cipher->block_size == 16);
348
349 if (!(ctx->flags & EVP_CIPHER_CTX_FLAG_WRAP_ALLOW)
350 && EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_WRAP_MODE) {
351 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_WRAP_MODE_NOT_ALLOWED);
352 return 0;
353 }
354
480d3323 355 if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_CUSTOM_IV)) {
0f113f3e
MC
356 switch (EVP_CIPHER_CTX_mode(ctx)) {
357
358 case EVP_CIPH_STREAM_CIPHER:
359 case EVP_CIPH_ECB_MODE:
360 break;
361
362 case EVP_CIPH_CFB_MODE:
363 case EVP_CIPH_OFB_MODE:
364
365 ctx->num = 0;
366 /* fall-through */
367
368 case EVP_CIPH_CBC_MODE:
369
370 OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <=
371 (int)sizeof(ctx->iv));
372 if (iv)
373 memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
374 memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
375 break;
376
377 case EVP_CIPH_CTR_MODE:
378 ctx->num = 0;
379 /* Don't reuse IV for CTR mode */
380 if (iv)
381 memcpy(ctx->iv, iv, EVP_CIPHER_CTX_iv_length(ctx));
382 break;
383
384 default:
385 return 0;
0f113f3e
MC
386 }
387 }
388
389 if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
390 if (!ctx->cipher->init(ctx, key, iv, enc))
391 return 0;
392 }
393 ctx->buf_len = 0;
394 ctx->final_used = 0;
395 ctx->block_mask = ctx->cipher->block_size - 1;
396 return 1;
397}
d02b48c6 398
be06a934 399int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
0f113f3e
MC
400 const unsigned char *in, int inl)
401{
402 if (ctx->encrypt)
403 return EVP_EncryptUpdate(ctx, out, outl, in, inl);
404 else
405 return EVP_DecryptUpdate(ctx, out, outl, in, inl);
406}
d02b48c6 407
581f1c84 408int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
0f113f3e
MC
409{
410 if (ctx->encrypt)
411 return EVP_EncryptFinal_ex(ctx, out, outl);
412 else
413 return EVP_DecryptFinal_ex(ctx, out, outl);
414}
581f1c84 415
6b691a5c 416int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
0f113f3e
MC
417{
418 if (ctx->encrypt)
419 return EVP_EncryptFinal(ctx, out, outl);
420 else
421 return EVP_DecryptFinal(ctx, out, outl);
422}
d02b48c6 423
be06a934 424int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
0f113f3e
MC
425 const unsigned char *key, const unsigned char *iv)
426{
427 return EVP_CipherInit(ctx, cipher, key, iv, 1);
428}
18eda732 429
0f113f3e
MC
430int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
431 ENGINE *impl, const unsigned char *key,
432 const unsigned char *iv)
433{
434 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1);
435}
d02b48c6 436
be06a934 437int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
0f113f3e
MC
438 const unsigned char *key, const unsigned char *iv)
439{
440 return EVP_CipherInit(ctx, cipher, key, iv, 0);
441}
18eda732 442
0f113f3e
MC
443int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
444 ENGINE *impl, const unsigned char *key,
445 const unsigned char *iv)
446{
447 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0);
448}
d02b48c6 449
c3a73daf
AP
450/*
451 * According to the letter of standard difference between pointers
452 * is specified to be valid only within same object. This makes
453 * it formally challenging to determine if input and output buffers
454 * are not partially overlapping with standard pointer arithmetic.
455 */
456#ifdef PTRDIFF_T
457# undef PTRDIFF_T
458#endif
459#if defined(OPENSSL_SYS_VMS) && __INITIAL_POINTER_SIZE==64
460/*
461 * Then we have VMS that distinguishes itself by adhering to
5fc77684
AP
462 * sizeof(size_t)==4 even in 64-bit builds, which means that
463 * difference between two pointers might be truncated to 32 bits.
464 * In the context one can even wonder how comparison for
465 * equality is implemented. To be on the safe side we adhere to
466 * PTRDIFF_T even for comparison for equality.
c3a73daf
AP
467 */
468# define PTRDIFF_T uint64_t
469#else
470# define PTRDIFF_T size_t
471#endif
472
7141ba31 473int is_partially_overlapping(const void *ptr1, const void *ptr2, int len)
c3a73daf
AP
474{
475 PTRDIFF_T diff = (PTRDIFF_T)ptr1-(PTRDIFF_T)ptr2;
476 /*
477 * Check for partially overlapping buffers. [Binary logical
478 * operations are used instead of boolean to minimize number
479 * of conditional branches.]
480 */
83151b73
AP
481 int overlapped = (len > 0) & (diff != 0) & ((diff < (PTRDIFF_T)len) |
482 (diff > (0 - (PTRDIFF_T)len)));
b153f092 483
83151b73 484 return overlapped;
c3a73daf
AP
485}
486
a8bf2f8f
RL
487static int evp_EncryptDecryptUpdate(EVP_CIPHER_CTX *ctx,
488 unsigned char *out, int *outl,
489 const unsigned char *in, int inl)
0f113f3e 490{
64846096
LP
491 int i, j, bl, cmpl = inl;
492
493 if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS))
494 cmpl = (cmpl + 7) / 8;
0f113f3e 495
7141ba31
MC
496 bl = ctx->cipher->block_size;
497
0f113f3e 498 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
7141ba31 499 /* If block size > 1 then the cipher will have to do this check */
64846096 500 if (bl == 1 && is_partially_overlapping(out, in, cmpl)) {
a8bf2f8f 501 EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
5fc77684 502 return 0;
83151b73 503 }
5fc77684 504
0f113f3e
MC
505 i = ctx->cipher->do_cipher(ctx, out, in, inl);
506 if (i < 0)
507 return 0;
508 else
509 *outl = i;
510 return 1;
511 }
512
2c236894
MC
513 if (inl <= 0) {
514 *outl = 0;
515 return inl == 0;
516 }
64846096 517 if (is_partially_overlapping(out + ctx->buf_len, in, cmpl)) {
a8bf2f8f 518 EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
5fc77684 519 return 0;
83151b73 520 }
0f113f3e
MC
521
522 if (ctx->buf_len == 0 && (inl & (ctx->block_mask)) == 0) {
523 if (ctx->cipher->do_cipher(ctx, out, in, inl)) {
524 *outl = inl;
525 return 1;
526 } else {
527 *outl = 0;
528 return 0;
529 }
530 }
531 i = ctx->buf_len;
0f113f3e
MC
532 OPENSSL_assert(bl <= (int)sizeof(ctx->buf));
533 if (i != 0) {
3f358213 534 if (bl - i > inl) {
0f113f3e
MC
535 memcpy(&(ctx->buf[i]), in, inl);
536 ctx->buf_len += inl;
537 *outl = 0;
538 return 1;
539 } else {
540 j = bl - i;
541 memcpy(&(ctx->buf[i]), in, j);
0f113f3e
MC
542 inl -= j;
543 in += j;
5fc77684
AP
544 if (!ctx->cipher->do_cipher(ctx, out, ctx->buf, bl))
545 return 0;
0f113f3e
MC
546 out += bl;
547 *outl = bl;
548 }
549 } else
550 *outl = 0;
551 i = inl & (bl - 1);
552 inl -= i;
553 if (inl > 0) {
554 if (!ctx->cipher->do_cipher(ctx, out, in, inl))
555 return 0;
556 *outl += inl;
557 }
558
559 if (i != 0)
560 memcpy(ctx->buf, &(in[inl]), i);
561 ctx->buf_len = i;
562 return 1;
563}
d02b48c6 564
a8bf2f8f
RL
565
566int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
567 const unsigned char *in, int inl)
568{
df05f2ce
MC
569 int ret;
570 size_t soutl;
3b94944c 571 int blocksize;
df05f2ce 572
a8bf2f8f
RL
573 /* Prevent accidental use of decryption context when encrypting */
574 if (!ctx->encrypt) {
575 EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_INVALID_OPERATION);
576 return 0;
577 }
578
df05f2ce
MC
579 if (ctx->cipher == NULL || ctx->cipher->prov == NULL)
580 goto legacy;
581
3b94944c
MC
582 blocksize = EVP_CIPHER_CTX_block_size(ctx);
583
584 if (ctx->cipher->cupdate == NULL || blocksize < 1) {
df05f2ce
MC
585 EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_UPDATE_ERROR);
586 return 0;
587 }
3b94944c
MC
588 ret = ctx->cipher->cupdate(ctx->provctx, out, &soutl,
589 inl + (blocksize == 1 ? 0 : blocksize), in,
590 (size_t)inl);
df05f2ce 591
36e619d7
GV
592 if (ret) {
593 if (soutl > INT_MAX) {
594 EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_UPDATE_ERROR);
595 return 0;
596 }
597 *outl = soutl;
df05f2ce 598 }
36e619d7 599
df05f2ce
MC
600 return ret;
601
602 /* TODO(3.0): Remove legacy code below */
603 legacy:
604
a8bf2f8f
RL
605 return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl);
606}
607
be06a934 608int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
0f113f3e
MC
609{
610 int ret;
611 ret = EVP_EncryptFinal_ex(ctx, out, outl);
612 return ret;
613}
581f1c84
DSH
614
615int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
0f113f3e
MC
616{
617 int n, ret;
618 unsigned int i, b, bl;
df05f2ce 619 size_t soutl;
3b94944c 620 int blocksize;
0f113f3e 621
a8bf2f8f
RL
622 /* Prevent accidental use of decryption context when encrypting */
623 if (!ctx->encrypt) {
624 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_INVALID_OPERATION);
625 return 0;
626 }
627
4894dcad
P
628 if (ctx->cipher == NULL) {
629 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_NO_CIPHER_SET);
630 return 0;
631 }
632 if (ctx->cipher->prov == NULL)
df05f2ce
MC
633 goto legacy;
634
3b94944c
MC
635 blocksize = EVP_CIPHER_CTX_block_size(ctx);
636
637 if (blocksize < 1 || ctx->cipher->cfinal == NULL) {
df05f2ce
MC
638 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_FINAL_ERROR);
639 return 0;
640 }
641
3b94944c
MC
642 ret = ctx->cipher->cfinal(ctx->provctx, out, &soutl,
643 blocksize == 1 ? 0 : blocksize);
df05f2ce 644
36e619d7
GV
645 if (ret) {
646 if (soutl > INT_MAX) {
647 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_FINAL_ERROR);
648 return 0;
649 }
650 *outl = soutl;
df05f2ce 651 }
df05f2ce
MC
652
653 return ret;
654
655 /* TODO(3.0): Remove legacy code below */
656 legacy:
657
0f113f3e
MC
658 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
659 ret = ctx->cipher->do_cipher(ctx, out, NULL, 0);
660 if (ret < 0)
661 return 0;
662 else
663 *outl = ret;
664 return 1;
665 }
666
667 b = ctx->cipher->block_size;
cbe29648 668 OPENSSL_assert(b <= sizeof(ctx->buf));
0f113f3e
MC
669 if (b == 1) {
670 *outl = 0;
671 return 1;
672 }
673 bl = ctx->buf_len;
674 if (ctx->flags & EVP_CIPH_NO_PADDING) {
675 if (bl) {
676 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX,
677 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
678 return 0;
679 }
680 *outl = 0;
681 return 1;
682 }
683
684 n = b - bl;
685 for (i = bl; i < b; i++)
686 ctx->buf[i] = n;
687 ret = ctx->cipher->do_cipher(ctx, out, ctx->buf, b);
688
689 if (ret)
690 *outl = b;
691
692 return ret;
693}
d02b48c6 694
be06a934 695int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
0f113f3e
MC
696 const unsigned char *in, int inl)
697{
df05f2ce 698 int fix_len, cmpl = inl, ret;
0f113f3e 699 unsigned int b;
df05f2ce 700 size_t soutl;
3b94944c 701 int blocksize;
0f113f3e 702
a8bf2f8f
RL
703 /* Prevent accidental use of encryption context when decrypting */
704 if (ctx->encrypt) {
705 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_INVALID_OPERATION);
706 return 0;
707 }
708
d2c2e49e
P
709 if (ctx->cipher == NULL) {
710 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_NO_CIPHER_SET);
711 return 0;
712 }
713 if (ctx->cipher->prov == NULL)
df05f2ce
MC
714 goto legacy;
715
3b94944c
MC
716 blocksize = EVP_CIPHER_CTX_block_size(ctx);
717
718 if (ctx->cipher->cupdate == NULL || blocksize < 1) {
df05f2ce
MC
719 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_UPDATE_ERROR);
720 return 0;
721 }
3b94944c
MC
722 ret = ctx->cipher->cupdate(ctx->provctx, out, &soutl,
723 inl + (blocksize == 1 ? 0 : blocksize), in,
724 (size_t)inl);
df05f2ce
MC
725
726 if (ret) {
727 if (soutl > INT_MAX) {
728 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_UPDATE_ERROR);
729 return 0;
730 }
731 *outl = soutl;
732 }
733
734 return ret;
735
736 /* TODO(3.0): Remove legacy code below */
737 legacy:
738
7141ba31
MC
739 b = ctx->cipher->block_size;
740
64846096
LP
741 if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS))
742 cmpl = (cmpl + 7) / 8;
743
0f113f3e 744 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
64846096 745 if (b == 1 && is_partially_overlapping(out, in, cmpl)) {
83151b73 746 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
5fc77684 747 return 0;
83151b73 748 }
5fc77684 749
0f113f3e
MC
750 fix_len = ctx->cipher->do_cipher(ctx, out, in, inl);
751 if (fix_len < 0) {
752 *outl = 0;
753 return 0;
754 } else
755 *outl = fix_len;
756 return 1;
757 }
758
2c236894
MC
759 if (inl <= 0) {
760 *outl = 0;
761 return inl == 0;
762 }
763
0f113f3e 764 if (ctx->flags & EVP_CIPH_NO_PADDING)
a8bf2f8f 765 return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl);
0f113f3e 766
cbe29648 767 OPENSSL_assert(b <= sizeof(ctx->final));
0f113f3e
MC
768
769 if (ctx->final_used) {
5fc77684
AP
770 /* see comment about PTRDIFF_T comparison above */
771 if (((PTRDIFF_T)out == (PTRDIFF_T)in)
83151b73
AP
772 || is_partially_overlapping(out, in, b)) {
773 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING);
5fc77684 774 return 0;
83151b73 775 }
0f113f3e
MC
776 memcpy(out, ctx->final, b);
777 out += b;
778 fix_len = 1;
779 } else
780 fix_len = 0;
781
a8bf2f8f 782 if (!evp_EncryptDecryptUpdate(ctx, out, outl, in, inl))
0f113f3e
MC
783 return 0;
784
785 /*
786 * if we have 'decrypted' a multiple of block size, make sure we have a
787 * copy of this last block
788 */
789 if (b > 1 && !ctx->buf_len) {
790 *outl -= b;
791 ctx->final_used = 1;
792 memcpy(ctx->final, &out[*outl], b);
793 } else
794 ctx->final_used = 0;
795
796 if (fix_len)
797 *outl += b;
798
799 return 1;
800}
d02b48c6 801
6b691a5c 802int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
0f113f3e
MC
803{
804 int ret;
805 ret = EVP_DecryptFinal_ex(ctx, out, outl);
806 return ret;
807}
581f1c84
DSH
808
809int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
0f113f3e
MC
810{
811 int i, n;
812 unsigned int b;
df05f2ce
MC
813 size_t soutl;
814 int ret;
3b94944c 815 int blocksize;
a8bf2f8f
RL
816
817 /* Prevent accidental use of encryption context when decrypting */
818 if (ctx->encrypt) {
819 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_INVALID_OPERATION);
820 return 0;
821 }
822
df05f2ce
MC
823 if (ctx->cipher == NULL || ctx->cipher->prov == NULL)
824 goto legacy;
825
3b94944c
MC
826 blocksize = EVP_CIPHER_CTX_block_size(ctx);
827
828 if (blocksize < 1 || ctx->cipher->cfinal == NULL) {
df05f2ce
MC
829 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_FINAL_ERROR);
830 return 0;
831 }
832
3b94944c
MC
833 ret = ctx->cipher->cfinal(ctx->provctx, out, &soutl,
834 blocksize == 1 ? 0 : blocksize);
df05f2ce
MC
835
836 if (ret) {
837 if (soutl > INT_MAX) {
838 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_FINAL_ERROR);
839 return 0;
840 }
841 *outl = soutl;
842 }
843
844 return ret;
845
846 /* TODO(3.0): Remove legacy code below */
847 legacy:
848
0f113f3e 849 *outl = 0;
ff6c7cc6
P
850 if (ctx->cipher == NULL) {
851 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_NO_CIPHER_SET);
852 return 0;
853 }
0f113f3e
MC
854
855 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) {
856 i = ctx->cipher->do_cipher(ctx, out, NULL, 0);
857 if (i < 0)
858 return 0;
859 else
860 *outl = i;
861 return 1;
862 }
863
864 b = ctx->cipher->block_size;
865 if (ctx->flags & EVP_CIPH_NO_PADDING) {
866 if (ctx->buf_len) {
867 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,
868 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
869 return 0;
870 }
871 *outl = 0;
872 return 1;
873 }
874 if (b > 1) {
875 if (ctx->buf_len || !ctx->final_used) {
876 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_WRONG_FINAL_BLOCK_LENGTH);
26a7d938 877 return 0;
0f113f3e 878 }
cbe29648 879 OPENSSL_assert(b <= sizeof(ctx->final));
0f113f3e
MC
880
881 /*
882 * The following assumes that the ciphertext has been authenticated.
883 * Otherwise it provides a padding oracle.
884 */
885 n = ctx->final[b - 1];
886 if (n == 0 || n > (int)b) {
887 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT);
26a7d938 888 return 0;
0f113f3e
MC
889 }
890 for (i = 0; i < n; i++) {
891 if (ctx->final[--b] != n) {
892 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT);
26a7d938 893 return 0;
0f113f3e
MC
894 }
895 }
896 n = ctx->cipher->block_size - n;
897 for (i = 0; i < n; i++)
898 out[i] = ctx->final[i];
899 *outl = n;
900 } else
901 *outl = 0;
208fb891 902 return 1;
0f113f3e 903}
d02b48c6 904
6343829a 905int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
0f113f3e
MC
906{
907 if (c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH)
908 return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL);
df05f2ce 909 if (EVP_CIPHER_CTX_key_length(c) == keylen)
0f113f3e
MC
910 return 1;
911 if ((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) {
912 c->key_len = keylen;
913 return 1;
914 }
915 EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, EVP_R_INVALID_KEY_LENGTH);
916 return 0;
917}
49528751 918
f2e5ca84 919int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad)
0f113f3e
MC
920{
921 if (pad)
922 ctx->flags &= ~EVP_CIPH_NO_PADDING;
923 else
924 ctx->flags |= EVP_CIPH_NO_PADDING;
df05f2ce
MC
925
926 if (ctx->cipher != NULL && ctx->cipher->prov != NULL) {
927 OSSL_PARAM params[] = {
928 OSSL_PARAM_int(OSSL_CIPHER_PARAM_PADDING, NULL),
929 OSSL_PARAM_END
930 };
931
932 params[0].data = &pad;
933
718b133a 934 if (ctx->cipher->ctx_set_params == NULL) {
df05f2ce
MC
935 EVPerr(EVP_F_EVP_CIPHER_CTX_SET_PADDING, EVP_R_CTRL_NOT_IMPLEMENTED);
936 return 0;
937 }
938
718b133a 939 if (!ctx->cipher->ctx_set_params(ctx->provctx, params))
df05f2ce
MC
940 return 0;
941 }
942
0f113f3e
MC
943 return 1;
944}
f2e5ca84 945
49528751
DSH
946int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
947{
0f113f3e 948 int ret;
d91f4568 949
0f113f3e
MC
950 if (!ctx->cipher) {
951 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
952 return 0;
953 }
954
955 if (!ctx->cipher->ctrl) {
956 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
957 return 0;
958 }
959
960 ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
961 if (ret == -1) {
962 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL,
963 EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
964 return 0;
965 }
966 return ret;
49528751 967}
216659eb
DSH
968
969int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key)
0f113f3e 970{
d0510566 971 int kl;
0f113f3e
MC
972 if (ctx->cipher->flags & EVP_CIPH_RAND_KEY)
973 return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key);
d0510566
P
974 kl = EVP_CIPHER_CTX_key_length(ctx);
975 if (kl <= 0 || RAND_priv_bytes(key, kl) <= 0)
0f113f3e
MC
976 return 0;
977 return 1;
978}
216659eb 979
c2bf7208 980int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
0f113f3e
MC
981{
982 if ((in == NULL) || (in->cipher == NULL)) {
983 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INPUT_NOT_INITIALIZED);
984 return 0;
985 }
df05f2ce
MC
986
987 if (in->cipher->prov == NULL)
988 goto legacy;
989
990 if (in->cipher->dupctx == NULL) {
991 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_NOT_ABLE_TO_COPY_CTX);
992 return 0;
993 }
994
995 EVP_CIPHER_CTX_reset(out);
996
997 *out = *in;
998 out->provctx = NULL;
999
718b133a 1000 if (in->fetched_cipher != NULL && !EVP_CIPHER_upref(in->fetched_cipher)) {
df05f2ce
MC
1001 out->fetched_cipher = NULL;
1002 return 0;
1003 }
1004
1005 out->provctx = in->cipher->dupctx(in->provctx);
1006 if (out->provctx == NULL) {
1007 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_NOT_ABLE_TO_COPY_CTX);
1008 return 0;
1009 }
1010
1011 return 1;
1012
1013 /* TODO(3.0): Remove legacy code below */
1014 legacy:
1015
c2bf7208 1016#ifndef OPENSSL_NO_ENGINE
0f113f3e
MC
1017 /* Make sure it's safe to copy a cipher context using an ENGINE */
1018 if (in->engine && !ENGINE_init(in->engine)) {
1019 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_ENGINE_LIB);
1020 return 0;
1021 }
c2bf7208
DSH
1022#endif
1023
c0ca39bd 1024 EVP_CIPHER_CTX_reset(out);
b4faea50 1025 memcpy(out, in, sizeof(*out));
0f113f3e
MC
1026
1027 if (in->cipher_data && in->cipher->ctx_size) {
1028 out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size);
90945fa3 1029 if (out->cipher_data == NULL) {
273a0218 1030 out->cipher = NULL;
0f113f3e
MC
1031 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_MALLOC_FAILURE);
1032 return 0;
1033 }
1034 memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size);
1035 }
1036
1037 if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY)
273a0218
BE
1038 if (!in->cipher->ctrl((EVP_CIPHER_CTX *)in, EVP_CTRL_COPY, 0, out)) {
1039 out->cipher = NULL;
1040 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INITIALIZATION_ERROR);
1041 return 0;
1042 }
0f113f3e
MC
1043 return 1;
1044}
df05f2ce 1045
0211740f 1046static void *evp_cipher_from_dispatch(const OSSL_DISPATCH *fns,
df05f2ce
MC
1047 OSSL_PROVIDER *prov)
1048{
1049 EVP_CIPHER *cipher = NULL;
1050 int fnciphcnt = 0, fnctxcnt = 0;
1051
0211740f
RL
1052 /*
1053 * The legacy NID is set by EVP_CIPHER_fetch() if the name exists in
1054 * the object database.
1055 */
1056 if ((cipher = EVP_CIPHER_meth_new(0, 0, 0)) == NULL)
df05f2ce
MC
1057 return NULL;
1058
1059 for (; fns->function_id != 0; fns++) {
1060 switch (fns->function_id) {
1061 case OSSL_FUNC_CIPHER_NEWCTX:
1062 if (cipher->newctx != NULL)
1063 break;
1064 cipher->newctx = OSSL_get_OP_cipher_newctx(fns);
1065 fnctxcnt++;
1066 break;
1067 case OSSL_FUNC_CIPHER_ENCRYPT_INIT:
1068 if (cipher->einit != NULL)
1069 break;
1070 cipher->einit = OSSL_get_OP_cipher_encrypt_init(fns);
1071 fnciphcnt++;
1072 break;
1073 case OSSL_FUNC_CIPHER_DECRYPT_INIT:
1074 if (cipher->dinit != NULL)
1075 break;
1076 cipher->dinit = OSSL_get_OP_cipher_decrypt_init(fns);
1077 fnciphcnt++;
1078 break;
1079 case OSSL_FUNC_CIPHER_UPDATE:
1080 if (cipher->cupdate != NULL)
1081 break;
1082 cipher->cupdate = OSSL_get_OP_cipher_update(fns);
1083 fnciphcnt++;
1084 break;
1085 case OSSL_FUNC_CIPHER_FINAL:
1086 if (cipher->cfinal != NULL)
1087 break;
1088 cipher->cfinal = OSSL_get_OP_cipher_final(fns);
1089 fnciphcnt++;
1090 break;
718b133a
MC
1091 case OSSL_FUNC_CIPHER_CIPHER:
1092 if (cipher->ccipher != NULL)
1093 break;
1094 cipher->ccipher = OSSL_get_OP_cipher_cipher(fns);
1095 break;
df05f2ce
MC
1096 case OSSL_FUNC_CIPHER_FREECTX:
1097 if (cipher->freectx != NULL)
1098 break;
1099 cipher->freectx = OSSL_get_OP_cipher_freectx(fns);
1100 fnctxcnt++;
1101 break;
1102 case OSSL_FUNC_CIPHER_DUPCTX:
1103 if (cipher->dupctx != NULL)
1104 break;
1105 cipher->dupctx = OSSL_get_OP_cipher_dupctx(fns);
1106 break;
1107 case OSSL_FUNC_CIPHER_KEY_LENGTH:
1108 if (cipher->key_length != NULL)
1109 break;
1110 cipher->key_length = OSSL_get_OP_cipher_key_length(fns);
1111 break;
718b133a
MC
1112 case OSSL_FUNC_CIPHER_IV_LENGTH:
1113 if (cipher->iv_length != NULL)
1114 break;
1115 cipher->iv_length = OSSL_get_OP_cipher_iv_length(fns);
1116 break;
1117 case OSSL_FUNC_CIPHER_BLOCK_SIZE:
1118 if (cipher->blocksize != NULL)
1119 break;
1120 cipher->blocksize = OSSL_get_OP_cipher_block_size(fns);
1121 break;
df05f2ce
MC
1122 case OSSL_FUNC_CIPHER_GET_PARAMS:
1123 if (cipher->get_params != NULL)
1124 break;
1125 cipher->get_params = OSSL_get_OP_cipher_get_params(fns);
1126 break;
718b133a
MC
1127 case OSSL_FUNC_CIPHER_CTX_GET_PARAMS:
1128 if (cipher->ctx_get_params != NULL)
1129 break;
1130 cipher->ctx_get_params = OSSL_get_OP_cipher_ctx_get_params(fns);
1131 break;
1132 case OSSL_FUNC_CIPHER_CTX_SET_PARAMS:
1133 if (cipher->ctx_set_params != NULL)
df05f2ce 1134 break;
718b133a 1135 cipher->ctx_set_params = OSSL_get_OP_cipher_ctx_set_params(fns);
df05f2ce
MC
1136 break;
1137 }
1138 }
718b133a
MC
1139 if ((fnciphcnt != 0 && fnciphcnt != 3 && fnciphcnt != 4)
1140 || (fnciphcnt == 0 && cipher->ccipher == NULL)
dcd446f1
MC
1141 || fnctxcnt != 2
1142 || cipher->blocksize == NULL
1143 || cipher->iv_length == NULL
1144 || cipher->key_length == NULL) {
df05f2ce
MC
1145 /*
1146 * In order to be a consistent set of functions we must have at least
1147 * a complete set of "encrypt" functions, or a complete set of "decrypt"
718b133a 1148 * functions, or a single "cipher" function. In all cases we need a
dcd446f1
MC
1149 * complete set of context management functions, as well as the
1150 * blocksize, iv_length and key_length functions.
df05f2ce
MC
1151 */
1152 EVP_CIPHER_meth_free(cipher);
1153 EVPerr(EVP_F_EVP_CIPHER_FROM_DISPATCH, EVP_R_INVALID_PROVIDER_FUNCTIONS);
1154 return NULL;
1155 }
1156 cipher->prov = prov;
1157 if (prov != NULL)
1158 ossl_provider_upref(prov);
1159
1160 return cipher;
1161}
1162
1163static int evp_cipher_upref(void *cipher)
1164{
1165 return EVP_CIPHER_upref(cipher);
1166}
1167
1168static void evp_cipher_free(void *cipher)
1169{
1170 EVP_CIPHER_meth_free(cipher);
1171}
1172
df05f2ce
MC
1173EVP_CIPHER *EVP_CIPHER_fetch(OPENSSL_CTX *ctx, const char *algorithm,
1174 const char *properties)
1175{
0211740f
RL
1176 EVP_CIPHER *cipher =
1177 evp_generic_fetch(ctx, OSSL_OP_CIPHER, algorithm, properties,
1178 evp_cipher_from_dispatch, evp_cipher_upref,
1179 evp_cipher_free);
1180
1181#ifndef FIPS_MODE
1182 /* TODO(3.x) get rid of the need for legacy NIDs */
1183 if (cipher != NULL) {
1184 /*
1185 * FIPS module note: since internal fetches will be entirely
1186 * provider based, we know that none of its code depends on legacy
1187 * NIDs or any functionality that use them.
1188 */
1189 cipher->nid = OBJ_sn2nid(algorithm);
1190 }
1191#endif
1192
1193 return cipher;
df05f2ce 1194}