evp_enc.c revision 299068
1184588Sdfr/* crypto/evp/evp_enc.c */ 2184588Sdfr/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 3184588Sdfr * All rights reserved. 4184588Sdfr * 5184588Sdfr * This package is an SSL implementation written 6184588Sdfr * by Eric Young (eay@cryptsoft.com). 7184588Sdfr * The implementation was written so as to conform with Netscapes SSL. 8184588Sdfr * 9184588Sdfr * This library is free for commercial and non-commercial use as long as 10184588Sdfr * the following conditions are aheared to. The following conditions 11184588Sdfr * apply to all code found in this distribution, be it the RC4, RSA, 12184588Sdfr * lhash, DES, etc., code; not just the SSL code. The SSL documentation 13184588Sdfr * included with this distribution is covered by the same copyright terms 14184588Sdfr * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15184588Sdfr * 16184588Sdfr * Copyright remains Eric Young's, and as such any Copyright notices in 17184588Sdfr * the code are not to be removed. 18184588Sdfr * If this package is used in a product, Eric Young should be given attribution 19184588Sdfr * as the author of the parts of the library used. 20184588Sdfr * This can be in the form of a textual message at program startup or 21184588Sdfr * in documentation (online or textual) provided with the package. 22184588Sdfr * 23184588Sdfr * Redistribution and use in source and binary forms, with or without 24184588Sdfr * modification, are permitted provided that the following conditions 25184588Sdfr * are met: 26184588Sdfr * 1. Redistributions of source code must retain the copyright 27184588Sdfr * notice, this list of conditions and the following disclaimer. 28184588Sdfr * 2. Redistributions in binary form must reproduce the above copyright 29184588Sdfr * notice, this list of conditions and the following disclaimer in the 30184588Sdfr * documentation and/or other materials provided with the distribution. 31184588Sdfr * 3. All advertising materials mentioning features or use of this software 32184588Sdfr * must display the following acknowledgement: 33184588Sdfr * "This product includes cryptographic software written by 34184588Sdfr * Eric Young (eay@cryptsoft.com)" 35184588Sdfr * The word 'cryptographic' can be left out if the rouines from the library 36184588Sdfr * being used are not cryptographic related :-). 37184588Sdfr * 4. If you include any Windows specific code (or a derivative thereof) from 38184588Sdfr * the apps directory (application code) you must include an acknowledgement: 39184588Sdfr * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40184588Sdfr * 41184588Sdfr * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 42184588Sdfr * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43184588Sdfr * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44184588Sdfr * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45184588Sdfr * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46184588Sdfr * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47184588Sdfr * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48184588Sdfr * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49184588Sdfr * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50184588Sdfr * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51184588Sdfr * SUCH DAMAGE. 52184588Sdfr * 53184588Sdfr * The licence and distribution terms for any publically available version or 54184588Sdfr * derivative of this code cannot be changed. i.e. this code cannot simply be 55184588Sdfr * copied and put under another distribution licence 56184588Sdfr * [including the GNU Public Licence.] 57184588Sdfr */ 58184588Sdfr 59184588Sdfr#include <stdio.h> 60184588Sdfr#include "cryptlib.h" 61184588Sdfr#include <openssl/evp.h> 62184588Sdfr#include <openssl/err.h> 63184588Sdfr#include <openssl/rand.h> 64184588Sdfr#ifndef OPENSSL_NO_ENGINE 65184588Sdfr# include <openssl/engine.h> 66184588Sdfr#endif 67184588Sdfr#ifdef OPENSSL_FIPS 68184588Sdfr# include <openssl/fips.h> 69184588Sdfr#endif 70184588Sdfr#include "evp_locl.h" 71184588Sdfr 72184588Sdfr#ifdef OPENSSL_FIPS 73184588Sdfr# define M_do_cipher(ctx, out, in, inl) FIPS_cipher(ctx, out, in, inl) 74184588Sdfr#else 75184588Sdfr# define M_do_cipher(ctx, out, in, inl) ctx->cipher->do_cipher(ctx, out, in, inl) 76184588Sdfr#endif 77184588Sdfr 78184588Sdfrconst char EVP_version[] = "EVP" OPENSSL_VERSION_PTEXT; 79184588Sdfr 80184588Sdfrvoid EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx) 81184588Sdfr{ 82184588Sdfr memset(ctx, 0, sizeof(EVP_CIPHER_CTX)); 83184588Sdfr /* ctx->cipher=NULL; */ 84184588Sdfr} 85184588Sdfr 86184588SdfrEVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void) 87184588Sdfr{ 88184588Sdfr EVP_CIPHER_CTX *ctx = OPENSSL_malloc(sizeof *ctx); 89184588Sdfr if (ctx) 90184588Sdfr EVP_CIPHER_CTX_init(ctx); 91184588Sdfr return ctx; 92184588Sdfr} 93184588Sdfr 94184588Sdfrint EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 95184588Sdfr const unsigned char *key, const unsigned char *iv, int enc) 96184588Sdfr{ 97184588Sdfr if (cipher) 98 EVP_CIPHER_CTX_init(ctx); 99 return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc); 100} 101 102int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 103 ENGINE *impl, const unsigned char *key, 104 const unsigned char *iv, int enc) 105{ 106 if (enc == -1) 107 enc = ctx->encrypt; 108 else { 109 if (enc) 110 enc = 1; 111 ctx->encrypt = enc; 112 } 113#ifndef OPENSSL_NO_ENGINE 114 /* 115 * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so 116 * this context may already have an ENGINE! Try to avoid releasing the 117 * previous handle, re-querying for an ENGINE, and having a 118 * reinitialisation, when it may all be unecessary. 119 */ 120 if (ctx->engine && ctx->cipher && (!cipher || 121 (cipher 122 && (cipher->nid == 123 ctx->cipher->nid)))) 124 goto skip_to_init; 125#endif 126 if (cipher) { 127 /* 128 * Ensure a context left lying around from last time is cleared (the 129 * previous check attempted to avoid this if the same ENGINE and 130 * EVP_CIPHER could be used). 131 */ 132 if (ctx->cipher) { 133 unsigned long flags = ctx->flags; 134 EVP_CIPHER_CTX_cleanup(ctx); 135 /* Restore encrypt and flags */ 136 ctx->encrypt = enc; 137 ctx->flags = flags; 138 } 139#ifndef OPENSSL_NO_ENGINE 140 if (impl) { 141 if (!ENGINE_init(impl)) { 142 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); 143 return 0; 144 } 145 } else 146 /* Ask if an ENGINE is reserved for this job */ 147 impl = ENGINE_get_cipher_engine(cipher->nid); 148 if (impl) { 149 /* There's an ENGINE for this job ... (apparently) */ 150 const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid); 151 if (!c) { 152 /* 153 * One positive side-effect of US's export control history, 154 * is that we should at least be able to avoid using US 155 * mispellings of "initialisation"? 156 */ 157 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); 158 return 0; 159 } 160 /* We'll use the ENGINE's private cipher definition */ 161 cipher = c; 162 /* 163 * Store the ENGINE functional reference so we know 'cipher' came 164 * from an ENGINE and we need to release it when done. 165 */ 166 ctx->engine = impl; 167 } else 168 ctx->engine = NULL; 169#endif 170 171#ifdef OPENSSL_FIPS 172 if (FIPS_mode()) 173 return FIPS_cipherinit(ctx, cipher, key, iv, enc); 174#endif 175 ctx->cipher = cipher; 176 if (ctx->cipher->ctx_size) { 177 ctx->cipher_data = OPENSSL_malloc(ctx->cipher->ctx_size); 178 if (!ctx->cipher_data) { 179 EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE); 180 return 0; 181 } 182 } else { 183 ctx->cipher_data = NULL; 184 } 185 ctx->key_len = cipher->key_len; 186 ctx->flags = 0; 187 if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) { 188 if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) { 189 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); 190 return 0; 191 } 192 } 193 } else if (!ctx->cipher) { 194 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET); 195 return 0; 196 } 197#ifndef OPENSSL_NO_ENGINE 198 skip_to_init: 199#endif 200#ifdef OPENSSL_FIPS 201 if (FIPS_mode()) 202 return FIPS_cipherinit(ctx, cipher, key, iv, enc); 203#endif 204 /* we assume block size is a power of 2 in *cryptUpdate */ 205 OPENSSL_assert(ctx->cipher->block_size == 1 206 || ctx->cipher->block_size == 8 207 || ctx->cipher->block_size == 16); 208 209 if (!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) { 210 switch (EVP_CIPHER_CTX_mode(ctx)) { 211 212 case EVP_CIPH_STREAM_CIPHER: 213 case EVP_CIPH_ECB_MODE: 214 break; 215 216 case EVP_CIPH_CFB_MODE: 217 case EVP_CIPH_OFB_MODE: 218 219 ctx->num = 0; 220 /* fall-through */ 221 222 case EVP_CIPH_CBC_MODE: 223 224 OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <= 225 (int)sizeof(ctx->iv)); 226 if (iv) 227 memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx)); 228 memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx)); 229 break; 230 231 case EVP_CIPH_CTR_MODE: 232 ctx->num = 0; 233 /* Don't reuse IV for CTR mode */ 234 if (iv) 235 memcpy(ctx->iv, iv, EVP_CIPHER_CTX_iv_length(ctx)); 236 break; 237 238 default: 239 return 0; 240 break; 241 } 242 } 243 244 if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) { 245 if (!ctx->cipher->init(ctx, key, iv, enc)) 246 return 0; 247 } 248 ctx->buf_len = 0; 249 ctx->final_used = 0; 250 ctx->block_mask = ctx->cipher->block_size - 1; 251 return 1; 252} 253 254int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 255 const unsigned char *in, int inl) 256{ 257 if (ctx->encrypt) 258 return EVP_EncryptUpdate(ctx, out, outl, in, inl); 259 else 260 return EVP_DecryptUpdate(ctx, out, outl, in, inl); 261} 262 263int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 264{ 265 if (ctx->encrypt) 266 return EVP_EncryptFinal_ex(ctx, out, outl); 267 else 268 return EVP_DecryptFinal_ex(ctx, out, outl); 269} 270 271int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 272{ 273 if (ctx->encrypt) 274 return EVP_EncryptFinal(ctx, out, outl); 275 else 276 return EVP_DecryptFinal(ctx, out, outl); 277} 278 279int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 280 const unsigned char *key, const unsigned char *iv) 281{ 282 return EVP_CipherInit(ctx, cipher, key, iv, 1); 283} 284 285int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 286 ENGINE *impl, const unsigned char *key, 287 const unsigned char *iv) 288{ 289 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1); 290} 291 292int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 293 const unsigned char *key, const unsigned char *iv) 294{ 295 return EVP_CipherInit(ctx, cipher, key, iv, 0); 296} 297 298int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 299 ENGINE *impl, const unsigned char *key, 300 const unsigned char *iv) 301{ 302 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0); 303} 304 305int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 306 const unsigned char *in, int inl) 307{ 308 int i, j, bl; 309 310 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 311 i = M_do_cipher(ctx, out, in, inl); 312 if (i < 0) 313 return 0; 314 else 315 *outl = i; 316 return 1; 317 } 318 319 if (inl <= 0) { 320 *outl = 0; 321 return inl == 0; 322 } 323 324 if (ctx->buf_len == 0 && (inl & (ctx->block_mask)) == 0) { 325 if (M_do_cipher(ctx, out, in, inl)) { 326 *outl = inl; 327 return 1; 328 } else { 329 *outl = 0; 330 return 0; 331 } 332 } 333 i = ctx->buf_len; 334 bl = ctx->cipher->block_size; 335 OPENSSL_assert(bl <= (int)sizeof(ctx->buf)); 336 if (i != 0) { 337 if (bl - i > inl) { 338 memcpy(&(ctx->buf[i]), in, inl); 339 ctx->buf_len += inl; 340 *outl = 0; 341 return 1; 342 } else { 343 j = bl - i; 344 memcpy(&(ctx->buf[i]), in, j); 345 if (!M_do_cipher(ctx, out, ctx->buf, bl)) 346 return 0; 347 inl -= j; 348 in += j; 349 out += bl; 350 *outl = bl; 351 } 352 } else 353 *outl = 0; 354 i = inl & (bl - 1); 355 inl -= i; 356 if (inl > 0) { 357 if (!M_do_cipher(ctx, out, in, inl)) 358 return 0; 359 *outl += inl; 360 } 361 362 if (i != 0) 363 memcpy(ctx->buf, &(in[inl]), i); 364 ctx->buf_len = i; 365 return 1; 366} 367 368int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 369{ 370 int ret; 371 ret = EVP_EncryptFinal_ex(ctx, out, outl); 372 return ret; 373} 374 375int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 376{ 377 int n, ret; 378 unsigned int i, b, bl; 379 380 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 381 ret = M_do_cipher(ctx, out, NULL, 0); 382 if (ret < 0) 383 return 0; 384 else 385 *outl = ret; 386 return 1; 387 } 388 389 b = ctx->cipher->block_size; 390 OPENSSL_assert(b <= sizeof ctx->buf); 391 if (b == 1) { 392 *outl = 0; 393 return 1; 394 } 395 bl = ctx->buf_len; 396 if (ctx->flags & EVP_CIPH_NO_PADDING) { 397 if (bl) { 398 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, 399 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); 400 return 0; 401 } 402 *outl = 0; 403 return 1; 404 } 405 406 n = b - bl; 407 for (i = bl; i < b; i++) 408 ctx->buf[i] = n; 409 ret = M_do_cipher(ctx, out, ctx->buf, b); 410 411 if (ret) 412 *outl = b; 413 414 return ret; 415} 416 417int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 418 const unsigned char *in, int inl) 419{ 420 int fix_len; 421 unsigned int b; 422 423 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 424 fix_len = M_do_cipher(ctx, out, in, inl); 425 if (fix_len < 0) { 426 *outl = 0; 427 return 0; 428 } else 429 *outl = fix_len; 430 return 1; 431 } 432 433 if (inl <= 0) { 434 *outl = 0; 435 return inl == 0; 436 } 437 438 if (ctx->flags & EVP_CIPH_NO_PADDING) 439 return EVP_EncryptUpdate(ctx, out, outl, in, inl); 440 441 b = ctx->cipher->block_size; 442 OPENSSL_assert(b <= sizeof ctx->final); 443 444 if (ctx->final_used) { 445 memcpy(out, ctx->final, b); 446 out += b; 447 fix_len = 1; 448 } else 449 fix_len = 0; 450 451 if (!EVP_EncryptUpdate(ctx, out, outl, in, inl)) 452 return 0; 453 454 /* 455 * if we have 'decrypted' a multiple of block size, make sure we have a 456 * copy of this last block 457 */ 458 if (b > 1 && !ctx->buf_len) { 459 *outl -= b; 460 ctx->final_used = 1; 461 memcpy(ctx->final, &out[*outl], b); 462 } else 463 ctx->final_used = 0; 464 465 if (fix_len) 466 *outl += b; 467 468 return 1; 469} 470 471int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 472{ 473 int ret; 474 ret = EVP_DecryptFinal_ex(ctx, out, outl); 475 return ret; 476} 477 478int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 479{ 480 int i, n; 481 unsigned int b; 482 *outl = 0; 483 484 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 485 i = M_do_cipher(ctx, out, NULL, 0); 486 if (i < 0) 487 return 0; 488 else 489 *outl = i; 490 return 1; 491 } 492 493 b = ctx->cipher->block_size; 494 if (ctx->flags & EVP_CIPH_NO_PADDING) { 495 if (ctx->buf_len) { 496 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, 497 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); 498 return 0; 499 } 500 *outl = 0; 501 return 1; 502 } 503 if (b > 1) { 504 if (ctx->buf_len || !ctx->final_used) { 505 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_WRONG_FINAL_BLOCK_LENGTH); 506 return (0); 507 } 508 OPENSSL_assert(b <= sizeof ctx->final); 509 510 /* 511 * The following assumes that the ciphertext has been authenticated. 512 * Otherwise it provides a padding oracle. 513 */ 514 n = ctx->final[b - 1]; 515 if (n == 0 || n > (int)b) { 516 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT); 517 return (0); 518 } 519 for (i = 0; i < n; i++) { 520 if (ctx->final[--b] != n) { 521 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT); 522 return (0); 523 } 524 } 525 n = ctx->cipher->block_size - n; 526 for (i = 0; i < n; i++) 527 out[i] = ctx->final[i]; 528 *outl = n; 529 } else 530 *outl = 0; 531 return (1); 532} 533 534void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx) 535{ 536 if (ctx) { 537 EVP_CIPHER_CTX_cleanup(ctx); 538 OPENSSL_free(ctx); 539 } 540} 541 542int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c) 543{ 544#ifndef OPENSSL_FIPS 545 if (c->cipher != NULL) { 546 if (c->cipher->cleanup && !c->cipher->cleanup(c)) 547 return 0; 548 /* Cleanse cipher context data */ 549 if (c->cipher_data) 550 OPENSSL_cleanse(c->cipher_data, c->cipher->ctx_size); 551 } 552 if (c->cipher_data) 553 OPENSSL_free(c->cipher_data); 554#endif 555#ifndef OPENSSL_NO_ENGINE 556 if (c->engine) 557 /* 558 * The EVP_CIPHER we used belongs to an ENGINE, release the 559 * functional reference we held for this reason. 560 */ 561 ENGINE_finish(c->engine); 562#endif 563#ifdef OPENSSL_FIPS 564 FIPS_cipher_ctx_cleanup(c); 565#endif 566 memset(c, 0, sizeof(EVP_CIPHER_CTX)); 567 return 1; 568} 569 570int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen) 571{ 572 if (c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH) 573 return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL); 574 if (c->key_len == keylen) 575 return 1; 576 if ((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) { 577 c->key_len = keylen; 578 return 1; 579 } 580 EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, EVP_R_INVALID_KEY_LENGTH); 581 return 0; 582} 583 584int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad) 585{ 586 if (pad) 587 ctx->flags &= ~EVP_CIPH_NO_PADDING; 588 else 589 ctx->flags |= EVP_CIPH_NO_PADDING; 590 return 1; 591} 592 593int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) 594{ 595 int ret; 596 if (!ctx->cipher) { 597 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET); 598 return 0; 599 } 600 601 if (!ctx->cipher->ctrl) { 602 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED); 603 return 0; 604 } 605 606 ret = ctx->cipher->ctrl(ctx, type, arg, ptr); 607 if (ret == -1) { 608 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, 609 EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED); 610 return 0; 611 } 612 return ret; 613} 614 615int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key) 616{ 617 if (ctx->cipher->flags & EVP_CIPH_RAND_KEY) 618 return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key); 619 if (RAND_bytes(key, ctx->key_len) <= 0) 620 return 0; 621 return 1; 622} 623 624int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in) 625{ 626 if ((in == NULL) || (in->cipher == NULL)) { 627 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INPUT_NOT_INITIALIZED); 628 return 0; 629 } 630#ifndef OPENSSL_NO_ENGINE 631 /* Make sure it's safe to copy a cipher context using an ENGINE */ 632 if (in->engine && !ENGINE_init(in->engine)) { 633 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_ENGINE_LIB); 634 return 0; 635 } 636#endif 637 638 EVP_CIPHER_CTX_cleanup(out); 639 memcpy(out, in, sizeof *out); 640 641 if (in->cipher_data && in->cipher->ctx_size) { 642 out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size); 643 if (!out->cipher_data) { 644 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_MALLOC_FAILURE); 645 return 0; 646 } 647 memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size); 648 } 649 650 if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY) 651 return in->cipher->ctrl((EVP_CIPHER_CTX *)in, EVP_CTRL_COPY, 0, out); 652 return 1; 653} 654