1 /* $OpenBSD: evp_enc.c,v 1.30 2016/05/04 15:05:13 tedu Exp $ */ 2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 3 * All rights reserved. 4 * 5 * This package is an SSL implementation written 6 * by Eric Young (eay@cryptsoft.com). 7 * The implementation was written so as to conform with Netscapes SSL. 8 * 9 * This library is free for commercial and non-commercial use as long as 10 * the following conditions are aheared to. The following conditions 11 * apply to all code found in this distribution, be it the RC4, RSA, 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 13 * included with this distribution is covered by the same copyright terms 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15 * 16 * Copyright remains Eric Young's, and as such any Copyright notices in 17 * the code are not to be removed. 18 * If this package is used in a product, Eric Young should be given attribution 19 * as the author of the parts of the library used. 20 * This can be in the form of a textual message at program startup or 21 * in documentation (online or textual) provided with the package. 22 * 23 * Redistribution and use in source and binary forms, with or without 24 * modification, are permitted provided that the following conditions 25 * are met: 26 * 1. Redistributions of source code must retain the copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 2. Redistributions in binary form must reproduce the above copyright 29 * notice, this list of conditions and the following disclaimer in the 30 * documentation and/or other materials provided with the distribution. 31 * 3. All advertising materials mentioning features or use of this software 32 * must display the following acknowledgement: 33 * "This product includes cryptographic software written by 34 * Eric Young (eay@cryptsoft.com)" 35 * The word 'cryptographic' can be left out if the rouines from the library 36 * being used are not cryptographic related :-). 37 * 4. If you include any Windows specific code (or a derivative thereof) from 38 * the apps directory (application code) you must include an acknowledgement: 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40 * 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * The licence and distribution terms for any publically available version or 54 * derivative of this code cannot be changed. i.e. this code cannot simply be 55 * copied and put under another distribution licence 56 * [including the GNU Public Licence.] 57 */ 58 59 #include <stdio.h> 60 #include <stdlib.h> 61 #include <string.h> 62 63 #include <openssl/opensslconf.h> 64 65 #include <openssl/err.h> 66 #include <openssl/evp.h> 67 68 #ifndef OPENSSL_NO_ENGINE 69 #include <openssl/engine.h> 70 #endif 71 72 #include "evp_locl.h" 73 74 #define M_do_cipher(ctx, out, in, inl) ctx->cipher->do_cipher(ctx, out, in, inl) 75 76 void 77 EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx) 78 { 79 memset(ctx, 0, sizeof(EVP_CIPHER_CTX)); 80 } 81 82 EVP_CIPHER_CTX * 83 EVP_CIPHER_CTX_new(void) 84 { 85 return calloc(1, sizeof(EVP_CIPHER_CTX)); 86 } 87 88 int 89 EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 90 const unsigned char *key, const unsigned char *iv, int enc) 91 { 92 if (cipher) 93 EVP_CIPHER_CTX_init(ctx); 94 return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc); 95 } 96 97 int 98 EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl, 99 const unsigned char *key, const unsigned char *iv, int enc) 100 { 101 if (enc == -1) 102 enc = ctx->encrypt; 103 else { 104 if (enc) 105 enc = 1; 106 ctx->encrypt = enc; 107 } 108 #ifndef OPENSSL_NO_ENGINE 109 /* Whether it's nice or not, "Inits" can be used on "Final"'d contexts 110 * so this context may already have an ENGINE! Try to avoid releasing 111 * the previous handle, re-querying for an ENGINE, and having a 112 * reinitialisation, when it may all be unecessary. */ 113 if (ctx->engine && ctx->cipher && 114 (!cipher || (cipher && (cipher->nid == ctx->cipher->nid)))) 115 goto skip_to_init; 116 #endif 117 if (cipher) { 118 /* Ensure a context left lying around from last time is cleared 119 * (the previous check attempted to avoid this if the same 120 * ENGINE and EVP_CIPHER could be used). */ 121 if (ctx->cipher) { 122 unsigned long flags = ctx->flags; 123 EVP_CIPHER_CTX_cleanup(ctx); 124 /* Restore encrypt and flags */ 125 ctx->encrypt = enc; 126 ctx->flags = flags; 127 } 128 #ifndef OPENSSL_NO_ENGINE 129 if (impl) { 130 if (!ENGINE_init(impl)) { 131 EVPerr(EVP_F_EVP_CIPHERINIT_EX, 132 EVP_R_INITIALIZATION_ERROR); 133 return 0; 134 } 135 } else 136 /* Ask if an ENGINE is reserved for this job */ 137 impl = ENGINE_get_cipher_engine(cipher->nid); 138 if (impl) { 139 /* There's an ENGINE for this job ... (apparently) */ 140 const EVP_CIPHER *c = 141 ENGINE_get_cipher(impl, cipher->nid); 142 if (!c) { 143 EVPerr(EVP_F_EVP_CIPHERINIT_EX, 144 EVP_R_INITIALIZATION_ERROR); 145 return 0; 146 } 147 /* We'll use the ENGINE's private cipher definition */ 148 cipher = c; 149 /* Store the ENGINE functional reference so we know 150 * 'cipher' came from an ENGINE and we need to release 151 * it when done. */ 152 ctx->engine = impl; 153 } else 154 ctx->engine = NULL; 155 #endif 156 157 ctx->cipher = cipher; 158 if (ctx->cipher->ctx_size) { 159 ctx->cipher_data = malloc(ctx->cipher->ctx_size); 160 if (!ctx->cipher_data) { 161 EVPerr(EVP_F_EVP_CIPHERINIT_EX, 162 ERR_R_MALLOC_FAILURE); 163 return 0; 164 } 165 } else { 166 ctx->cipher_data = NULL; 167 } 168 ctx->key_len = cipher->key_len; 169 ctx->flags = 0; 170 if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) { 171 if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) { 172 EVPerr(EVP_F_EVP_CIPHERINIT_EX, 173 EVP_R_INITIALIZATION_ERROR); 174 return 0; 175 } 176 } 177 } else if (!ctx->cipher) { 178 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET); 179 return 0; 180 } 181 #ifndef OPENSSL_NO_ENGINE 182 skip_to_init: 183 #endif 184 /* we assume block size is a power of 2 in *cryptUpdate */ 185 if (ctx->cipher->block_size != 1 && 186 ctx->cipher->block_size != 8 && 187 ctx->cipher->block_size != 16) { 188 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_BAD_BLOCK_LENGTH); 189 return 0; 190 } 191 192 if (!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) { 193 switch (EVP_CIPHER_CTX_mode(ctx)) { 194 195 case EVP_CIPH_STREAM_CIPHER: 196 case EVP_CIPH_ECB_MODE: 197 break; 198 199 case EVP_CIPH_CFB_MODE: 200 case EVP_CIPH_OFB_MODE: 201 202 ctx->num = 0; 203 /* fall-through */ 204 205 case EVP_CIPH_CBC_MODE: 206 207 if ((size_t)EVP_CIPHER_CTX_iv_length(ctx) > 208 sizeof(ctx->iv)) { 209 EVPerr(EVP_F_EVP_CIPHERINIT_EX, 210 EVP_R_IV_TOO_LARGE); 211 return 0; 212 } 213 if (iv) 214 memcpy(ctx->oiv, iv, 215 EVP_CIPHER_CTX_iv_length(ctx)); 216 memcpy(ctx->iv, ctx->oiv, 217 EVP_CIPHER_CTX_iv_length(ctx)); 218 break; 219 220 case EVP_CIPH_CTR_MODE: 221 ctx->num = 0; 222 /* Don't reuse IV for CTR mode */ 223 if (iv) 224 memcpy(ctx->iv, iv, 225 EVP_CIPHER_CTX_iv_length(ctx)); 226 break; 227 228 default: 229 return 0; 230 break; 231 } 232 } 233 234 if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) { 235 if (!ctx->cipher->init(ctx, key, iv, enc)) 236 return 0; 237 } 238 ctx->buf_len = 0; 239 ctx->final_used = 0; 240 ctx->block_mask = ctx->cipher->block_size - 1; 241 return 1; 242 } 243 244 int 245 EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 246 const unsigned char *in, int inl) 247 { 248 if (ctx->encrypt) 249 return EVP_EncryptUpdate(ctx, out, outl, in, inl); 250 else 251 return EVP_DecryptUpdate(ctx, out, outl, in, inl); 252 } 253 254 int 255 EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 256 { 257 if (ctx->encrypt) 258 return EVP_EncryptFinal_ex(ctx, out, outl); 259 else 260 return EVP_DecryptFinal_ex(ctx, out, outl); 261 } 262 263 int 264 EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 265 { 266 if (ctx->encrypt) 267 return EVP_EncryptFinal_ex(ctx, out, outl); 268 else 269 return EVP_DecryptFinal_ex(ctx, out, outl); 270 } 271 272 int 273 EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 274 const unsigned char *key, const unsigned char *iv) 275 { 276 return EVP_CipherInit(ctx, cipher, key, iv, 1); 277 } 278 279 int 280 EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl, 281 const unsigned char *key, const unsigned char *iv) 282 { 283 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1); 284 } 285 286 int 287 EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 288 const unsigned char *key, const unsigned char *iv) 289 { 290 return EVP_CipherInit(ctx, cipher, key, iv, 0); 291 } 292 293 int 294 EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl, 295 const unsigned char *key, const unsigned char *iv) 296 { 297 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0); 298 } 299 300 int 301 EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 302 const unsigned char *in, int inl) 303 { 304 int i, j, bl; 305 306 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 307 i = M_do_cipher(ctx, out, in, inl); 308 if (i < 0) 309 return 0; 310 else 311 *outl = i; 312 return 1; 313 } 314 315 if (inl <= 0) { 316 *outl = 0; 317 return inl == 0; 318 } 319 320 if (ctx->buf_len == 0 && (inl&(ctx->block_mask)) == 0) { 321 if (M_do_cipher(ctx, out, in, inl)) { 322 *outl = inl; 323 return 1; 324 } else { 325 *outl = 0; 326 return 0; 327 } 328 } 329 i = ctx->buf_len; 330 bl = ctx->cipher->block_size; 331 if ((size_t)bl > sizeof(ctx->buf)) { 332 EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_BAD_BLOCK_LENGTH); 333 *outl = 0; 334 return 0; 335 } 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 368 int 369 EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 370 { 371 int ret; 372 373 ret = EVP_EncryptFinal_ex(ctx, out, outl); 374 (void) EVP_CIPHER_CTX_cleanup(ctx); 375 return ret; 376 } 377 378 int 379 EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 380 { 381 int n, ret; 382 unsigned int i, b, bl; 383 384 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 385 ret = M_do_cipher(ctx, out, NULL, 0); 386 if (ret < 0) 387 return 0; 388 else 389 *outl = ret; 390 return 1; 391 } 392 393 b = ctx->cipher->block_size; 394 if (b > sizeof ctx->buf) { 395 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_BAD_BLOCK_LENGTH); 396 return 0; 397 } 398 if (b == 1) { 399 *outl = 0; 400 return 1; 401 } 402 bl = ctx->buf_len; 403 if (ctx->flags & EVP_CIPH_NO_PADDING) { 404 if (bl) { 405 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, 406 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); 407 return 0; 408 } 409 *outl = 0; 410 return 1; 411 } 412 413 n = b - bl; 414 for (i = bl; i < b; i++) 415 ctx->buf[i] = n; 416 ret = M_do_cipher(ctx, out, ctx->buf, b); 417 418 419 if (ret) 420 *outl = b; 421 422 return ret; 423 } 424 425 int 426 EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 427 const unsigned char *in, int inl) 428 { 429 int fix_len; 430 unsigned int b; 431 432 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 433 fix_len = M_do_cipher(ctx, out, in, inl); 434 if (fix_len < 0) { 435 *outl = 0; 436 return 0; 437 } else 438 *outl = fix_len; 439 return 1; 440 } 441 442 if (inl <= 0) { 443 *outl = 0; 444 return inl == 0; 445 } 446 447 if (ctx->flags & EVP_CIPH_NO_PADDING) 448 return EVP_EncryptUpdate(ctx, out, outl, in, inl); 449 450 b = ctx->cipher->block_size; 451 if (b > sizeof ctx->final) { 452 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_BAD_BLOCK_LENGTH); 453 return 0; 454 } 455 456 if (ctx->final_used) { 457 memcpy(out, ctx->final, b); 458 out += b; 459 fix_len = 1; 460 } else 461 fix_len = 0; 462 463 464 if (!EVP_EncryptUpdate(ctx, out, outl, in, inl)) 465 return 0; 466 467 /* if we have 'decrypted' a multiple of block size, make sure 468 * we have a copy of this last block */ 469 if (b > 1 && !ctx->buf_len) { 470 *outl -= b; 471 ctx->final_used = 1; 472 memcpy(ctx->final, &out[*outl], b); 473 } else 474 ctx->final_used = 0; 475 476 if (fix_len) 477 *outl += b; 478 479 return 1; 480 } 481 482 int 483 EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 484 { 485 int ret; 486 487 ret = EVP_DecryptFinal_ex(ctx, out, outl); 488 (void) EVP_CIPHER_CTX_cleanup(ctx); 489 return ret; 490 } 491 492 int 493 EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 494 { 495 int i, n; 496 unsigned int b; 497 *outl = 0; 498 499 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 500 i = M_do_cipher(ctx, out, NULL, 0); 501 if (i < 0) 502 return 0; 503 else 504 *outl = i; 505 return 1; 506 } 507 508 b = ctx->cipher->block_size; 509 if (ctx->flags & EVP_CIPH_NO_PADDING) { 510 if (ctx->buf_len) { 511 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, 512 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); 513 return 0; 514 } 515 *outl = 0; 516 return 1; 517 } 518 if (b > 1) { 519 if (ctx->buf_len || !ctx->final_used) { 520 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, 521 EVP_R_WRONG_FINAL_BLOCK_LENGTH); 522 return (0); 523 } 524 if (b > sizeof ctx->final) { 525 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, 526 EVP_R_BAD_BLOCK_LENGTH); 527 return 0; 528 } 529 n = ctx->final[b - 1]; 530 if (n == 0 || n > (int)b) { 531 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT); 532 return (0); 533 } 534 for (i = 0; i < n; i++) { 535 if (ctx->final[--b] != n) { 536 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, 537 EVP_R_BAD_DECRYPT); 538 return (0); 539 } 540 } 541 n = ctx->cipher->block_size - n; 542 for (i = 0; i < n; i++) 543 out[i] = ctx->final[i]; 544 *outl = n; 545 } else 546 *outl = 0; 547 return (1); 548 } 549 550 void 551 EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx) 552 { 553 if (ctx) { 554 EVP_CIPHER_CTX_cleanup(ctx); 555 free(ctx); 556 } 557 } 558 559 int 560 EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c) 561 { 562 if (c->cipher != NULL) { 563 if (c->cipher->cleanup && !c->cipher->cleanup(c)) 564 return 0; 565 /* Cleanse cipher context data */ 566 if (c->cipher_data) 567 explicit_bzero(c->cipher_data, c->cipher->ctx_size); 568 } 569 free(c->cipher_data); 570 #ifndef OPENSSL_NO_ENGINE 571 if (c->engine) 572 /* The EVP_CIPHER we used belongs to an ENGINE, release the 573 * functional reference we held for this reason. */ 574 ENGINE_finish(c->engine); 575 #endif 576 explicit_bzero(c, sizeof(EVP_CIPHER_CTX)); 577 return 1; 578 } 579 580 int 581 EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen) 582 { 583 if (c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH) 584 return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, 585 keylen, NULL); 586 if (c->key_len == keylen) 587 return 1; 588 if ((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) { 589 c->key_len = keylen; 590 return 1; 591 } 592 EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, EVP_R_INVALID_KEY_LENGTH); 593 return 0; 594 } 595 596 int 597 EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad) 598 { 599 if (pad) 600 ctx->flags &= ~EVP_CIPH_NO_PADDING; 601 else 602 ctx->flags |= EVP_CIPH_NO_PADDING; 603 return 1; 604 } 605 606 int 607 EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) 608 { 609 int ret; 610 611 if (!ctx->cipher) { 612 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET); 613 return 0; 614 } 615 616 if (!ctx->cipher->ctrl) { 617 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED); 618 return 0; 619 } 620 621 ret = ctx->cipher->ctrl(ctx, type, arg, ptr); 622 if (ret == -1) { 623 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, 624 EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED); 625 return 0; 626 } 627 return ret; 628 } 629 630 int 631 EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key) 632 { 633 if (ctx->cipher->flags & EVP_CIPH_RAND_KEY) 634 return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key); 635 arc4random_buf(key, ctx->key_len); 636 return 1; 637 } 638 639 int 640 EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in) 641 { 642 if ((in == NULL) || (in->cipher == NULL)) { 643 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INPUT_NOT_INITIALIZED); 644 return 0; 645 } 646 #ifndef OPENSSL_NO_ENGINE 647 /* Make sure it's safe to copy a cipher context using an ENGINE */ 648 if (in->engine && !ENGINE_init(in->engine)) { 649 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_ENGINE_LIB); 650 return 0; 651 } 652 #endif 653 654 EVP_CIPHER_CTX_cleanup(out); 655 memcpy(out, in, sizeof *out); 656 657 if (in->cipher_data && in->cipher->ctx_size) { 658 out->cipher_data = malloc(in->cipher->ctx_size); 659 if (!out->cipher_data) { 660 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_MALLOC_FAILURE); 661 return 0; 662 } 663 memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size); 664 } 665 666 if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY) 667 return in->cipher->ctrl((EVP_CIPHER_CTX *)in, 668 EVP_CTRL_COPY, 0, out); 669 return 1; 670 } 671