1 /* 2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (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 #include <stdio.h> 11 #include <assert.h> 12 #include "internal/cryptlib.h" 13 #include <openssl/evp.h> 14 #include <openssl/err.h> 15 #include <openssl/rand.h> 16 #include <openssl/rand_drbg.h> 17 #include <openssl/engine.h> 18 #include "crypto/evp.h" 19 #include "evp_local.h" 20 21 int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c) 22 { 23 if (c == NULL) 24 return 1; 25 if (c->cipher != NULL) { 26 if (c->cipher->cleanup && !c->cipher->cleanup(c)) 27 return 0; 28 /* Cleanse cipher context data */ 29 if (c->cipher_data && c->cipher->ctx_size) 30 OPENSSL_cleanse(c->cipher_data, c->cipher->ctx_size); 31 } 32 OPENSSL_free(c->cipher_data); 33 #ifndef OPENSSL_NO_ENGINE 34 ENGINE_finish(c->engine); 35 #endif 36 memset(c, 0, sizeof(*c)); 37 return 1; 38 } 39 40 EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void) 41 { 42 return OPENSSL_zalloc(sizeof(EVP_CIPHER_CTX)); 43 } 44 45 void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx) 46 { 47 EVP_CIPHER_CTX_reset(ctx); 48 OPENSSL_free(ctx); 49 } 50 51 int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 52 const unsigned char *key, const unsigned char *iv, int enc) 53 { 54 if (cipher != NULL) 55 EVP_CIPHER_CTX_reset(ctx); 56 return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc); 57 } 58 59 int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 60 ENGINE *impl, const unsigned char *key, 61 const unsigned char *iv, int enc) 62 { 63 if (enc == -1) 64 enc = ctx->encrypt; 65 else { 66 if (enc) 67 enc = 1; 68 ctx->encrypt = enc; 69 } 70 #ifndef OPENSSL_NO_ENGINE 71 /* 72 * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so 73 * this context may already have an ENGINE! Try to avoid releasing the 74 * previous handle, re-querying for an ENGINE, and having a 75 * reinitialisation, when it may all be unnecessary. 76 */ 77 if (ctx->engine && ctx->cipher 78 && (cipher == NULL || cipher->nid == ctx->cipher->nid)) 79 goto skip_to_init; 80 #endif 81 if (cipher) { 82 /* 83 * Ensure a context left lying around from last time is cleared (the 84 * previous check attempted to avoid this if the same ENGINE and 85 * EVP_CIPHER could be used). 86 */ 87 if (ctx->cipher) { 88 unsigned long flags = ctx->flags; 89 EVP_CIPHER_CTX_reset(ctx); 90 /* Restore encrypt and flags */ 91 ctx->encrypt = enc; 92 ctx->flags = flags; 93 } 94 #ifndef OPENSSL_NO_ENGINE 95 if (impl) { 96 if (!ENGINE_init(impl)) { 97 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); 98 return 0; 99 } 100 } else 101 /* Ask if an ENGINE is reserved for this job */ 102 impl = ENGINE_get_cipher_engine(cipher->nid); 103 if (impl) { 104 /* There's an ENGINE for this job ... (apparently) */ 105 const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid); 106 if (!c) { 107 /* 108 * One positive side-effect of US's export control history, 109 * is that we should at least be able to avoid using US 110 * misspellings of "initialisation"? 111 */ 112 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); 113 return 0; 114 } 115 /* We'll use the ENGINE's private cipher definition */ 116 cipher = c; 117 /* 118 * Store the ENGINE functional reference so we know 'cipher' came 119 * from an ENGINE and we need to release it when done. 120 */ 121 ctx->engine = impl; 122 } else 123 ctx->engine = NULL; 124 #endif 125 126 ctx->cipher = cipher; 127 if (ctx->cipher->ctx_size) { 128 ctx->cipher_data = OPENSSL_zalloc(ctx->cipher->ctx_size); 129 if (ctx->cipher_data == NULL) { 130 ctx->cipher = NULL; 131 EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE); 132 return 0; 133 } 134 } else { 135 ctx->cipher_data = NULL; 136 } 137 ctx->key_len = cipher->key_len; 138 /* Preserve wrap enable flag, zero everything else */ 139 ctx->flags &= EVP_CIPHER_CTX_FLAG_WRAP_ALLOW; 140 if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) { 141 if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) { 142 ctx->cipher = NULL; 143 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); 144 return 0; 145 } 146 } 147 } else if (!ctx->cipher) { 148 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET); 149 return 0; 150 } 151 #ifndef OPENSSL_NO_ENGINE 152 skip_to_init: 153 #endif 154 /* we assume block size is a power of 2 in *cryptUpdate */ 155 OPENSSL_assert(ctx->cipher->block_size == 1 156 || ctx->cipher->block_size == 8 157 || ctx->cipher->block_size == 16); 158 159 if (!(ctx->flags & EVP_CIPHER_CTX_FLAG_WRAP_ALLOW) 160 && EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_WRAP_MODE) { 161 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_WRAP_MODE_NOT_ALLOWED); 162 return 0; 163 } 164 165 if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_CUSTOM_IV)) { 166 switch (EVP_CIPHER_CTX_mode(ctx)) { 167 168 case EVP_CIPH_STREAM_CIPHER: 169 case EVP_CIPH_ECB_MODE: 170 break; 171 172 case EVP_CIPH_CFB_MODE: 173 case EVP_CIPH_OFB_MODE: 174 175 ctx->num = 0; 176 /* fall-through */ 177 178 case EVP_CIPH_CBC_MODE: 179 180 OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <= 181 (int)sizeof(ctx->iv)); 182 if (iv) 183 memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx)); 184 memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx)); 185 break; 186 187 case EVP_CIPH_CTR_MODE: 188 ctx->num = 0; 189 /* Don't reuse IV for CTR mode */ 190 if (iv) 191 memcpy(ctx->iv, iv, EVP_CIPHER_CTX_iv_length(ctx)); 192 break; 193 194 default: 195 return 0; 196 } 197 } 198 199 if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) { 200 if (!ctx->cipher->init(ctx, key, iv, enc)) 201 return 0; 202 } 203 ctx->buf_len = 0; 204 ctx->final_used = 0; 205 ctx->block_mask = ctx->cipher->block_size - 1; 206 return 1; 207 } 208 209 int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 210 const unsigned char *in, int inl) 211 { 212 if (ctx->encrypt) 213 return EVP_EncryptUpdate(ctx, out, outl, in, inl); 214 else 215 return EVP_DecryptUpdate(ctx, out, outl, in, inl); 216 } 217 218 int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 219 { 220 if (ctx->encrypt) 221 return EVP_EncryptFinal_ex(ctx, out, outl); 222 else 223 return EVP_DecryptFinal_ex(ctx, out, outl); 224 } 225 226 int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 227 { 228 if (ctx->encrypt) 229 return EVP_EncryptFinal(ctx, out, outl); 230 else 231 return EVP_DecryptFinal(ctx, out, outl); 232 } 233 234 int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 235 const unsigned char *key, const unsigned char *iv) 236 { 237 return EVP_CipherInit(ctx, cipher, key, iv, 1); 238 } 239 240 int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 241 ENGINE *impl, const unsigned char *key, 242 const unsigned char *iv) 243 { 244 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1); 245 } 246 247 int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 248 const unsigned char *key, const unsigned char *iv) 249 { 250 return EVP_CipherInit(ctx, cipher, key, iv, 0); 251 } 252 253 int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 254 ENGINE *impl, const unsigned char *key, 255 const unsigned char *iv) 256 { 257 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0); 258 } 259 260 /* 261 * According to the letter of standard difference between pointers 262 * is specified to be valid only within same object. This makes 263 * it formally challenging to determine if input and output buffers 264 * are not partially overlapping with standard pointer arithmetic. 265 */ 266 #ifdef PTRDIFF_T 267 # undef PTRDIFF_T 268 #endif 269 #if defined(OPENSSL_SYS_VMS) && __INITIAL_POINTER_SIZE==64 270 /* 271 * Then we have VMS that distinguishes itself by adhering to 272 * sizeof(size_t)==4 even in 64-bit builds, which means that 273 * difference between two pointers might be truncated to 32 bits. 274 * In the context one can even wonder how comparison for 275 * equality is implemented. To be on the safe side we adhere to 276 * PTRDIFF_T even for comparison for equality. 277 */ 278 # define PTRDIFF_T uint64_t 279 #else 280 # define PTRDIFF_T size_t 281 #endif 282 283 int is_partially_overlapping(const void *ptr1, const void *ptr2, int len) 284 { 285 PTRDIFF_T diff = (PTRDIFF_T)ptr1-(PTRDIFF_T)ptr2; 286 /* 287 * Check for partially overlapping buffers. [Binary logical 288 * operations are used instead of boolean to minimize number 289 * of conditional branches.] 290 */ 291 int overlapped = (len > 0) & (diff != 0) & ((diff < (PTRDIFF_T)len) | 292 (diff > (0 - (PTRDIFF_T)len))); 293 294 return overlapped; 295 } 296 297 static int evp_EncryptDecryptUpdate(EVP_CIPHER_CTX *ctx, 298 unsigned char *out, int *outl, 299 const unsigned char *in, int inl) 300 { 301 int i, j, bl, cmpl = inl; 302 303 if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) 304 cmpl = (cmpl + 7) / 8; 305 306 bl = ctx->cipher->block_size; 307 308 /* 309 * CCM mode needs to know about the case where inl == 0 && in == NULL - it 310 * means the plaintext/ciphertext length is 0 311 */ 312 if (inl < 0 313 || (inl == 0 314 && EVP_CIPHER_mode(ctx->cipher) != EVP_CIPH_CCM_MODE)) { 315 *outl = 0; 316 return inl == 0; 317 } 318 319 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 320 /* If block size > 1 then the cipher will have to do this check */ 321 if (bl == 1 && is_partially_overlapping(out, in, cmpl)) { 322 EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); 323 return 0; 324 } 325 326 i = ctx->cipher->do_cipher(ctx, out, in, inl); 327 if (i < 0) 328 return 0; 329 else 330 *outl = i; 331 return 1; 332 } 333 334 if (is_partially_overlapping(out + ctx->buf_len, in, cmpl)) { 335 EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); 336 return 0; 337 } 338 339 if (ctx->buf_len == 0 && (inl & (ctx->block_mask)) == 0) { 340 if (ctx->cipher->do_cipher(ctx, out, in, inl)) { 341 *outl = inl; 342 return 1; 343 } else { 344 *outl = 0; 345 return 0; 346 } 347 } 348 i = ctx->buf_len; 349 OPENSSL_assert(bl <= (int)sizeof(ctx->buf)); 350 if (i != 0) { 351 if (bl - i > inl) { 352 memcpy(&(ctx->buf[i]), in, inl); 353 ctx->buf_len += inl; 354 *outl = 0; 355 return 1; 356 } else { 357 j = bl - i; 358 memcpy(&(ctx->buf[i]), in, j); 359 inl -= j; 360 in += j; 361 if (!ctx->cipher->do_cipher(ctx, out, ctx->buf, bl)) 362 return 0; 363 out += bl; 364 *outl = bl; 365 } 366 } else 367 *outl = 0; 368 i = inl & (bl - 1); 369 inl -= i; 370 if (inl > 0) { 371 if (!ctx->cipher->do_cipher(ctx, out, in, inl)) 372 return 0; 373 *outl += inl; 374 } 375 376 if (i != 0) 377 memcpy(ctx->buf, &(in[inl]), i); 378 ctx->buf_len = i; 379 return 1; 380 } 381 382 383 int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 384 const unsigned char *in, int inl) 385 { 386 /* Prevent accidental use of decryption context when encrypting */ 387 if (!ctx->encrypt) { 388 EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_INVALID_OPERATION); 389 return 0; 390 } 391 392 return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl); 393 } 394 395 int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 396 { 397 int ret; 398 ret = EVP_EncryptFinal_ex(ctx, out, outl); 399 return ret; 400 } 401 402 int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 403 { 404 int n, ret; 405 unsigned int i, b, bl; 406 407 /* Prevent accidental use of decryption context when encrypting */ 408 if (!ctx->encrypt) { 409 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_INVALID_OPERATION); 410 return 0; 411 } 412 413 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 414 ret = ctx->cipher->do_cipher(ctx, out, NULL, 0); 415 if (ret < 0) 416 return 0; 417 else 418 *outl = ret; 419 return 1; 420 } 421 422 b = ctx->cipher->block_size; 423 OPENSSL_assert(b <= sizeof(ctx->buf)); 424 if (b == 1) { 425 *outl = 0; 426 return 1; 427 } 428 bl = ctx->buf_len; 429 if (ctx->flags & EVP_CIPH_NO_PADDING) { 430 if (bl) { 431 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, 432 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); 433 return 0; 434 } 435 *outl = 0; 436 return 1; 437 } 438 439 n = b - bl; 440 for (i = bl; i < b; i++) 441 ctx->buf[i] = n; 442 ret = ctx->cipher->do_cipher(ctx, out, ctx->buf, b); 443 444 if (ret) 445 *outl = b; 446 447 return ret; 448 } 449 450 int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 451 const unsigned char *in, int inl) 452 { 453 int fix_len, cmpl = inl; 454 unsigned int b; 455 456 /* Prevent accidental use of encryption context when decrypting */ 457 if (ctx->encrypt) { 458 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_INVALID_OPERATION); 459 return 0; 460 } 461 462 b = ctx->cipher->block_size; 463 464 if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) 465 cmpl = (cmpl + 7) / 8; 466 467 /* 468 * CCM mode needs to know about the case where inl == 0 - it means the 469 * plaintext/ciphertext length is 0 470 */ 471 if (inl < 0 472 || (inl == 0 473 && EVP_CIPHER_mode(ctx->cipher) != EVP_CIPH_CCM_MODE)) { 474 *outl = 0; 475 return inl == 0; 476 } 477 478 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 479 if (b == 1 && is_partially_overlapping(out, in, cmpl)) { 480 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); 481 return 0; 482 } 483 484 fix_len = ctx->cipher->do_cipher(ctx, out, in, inl); 485 if (fix_len < 0) { 486 *outl = 0; 487 return 0; 488 } else 489 *outl = fix_len; 490 return 1; 491 } 492 493 if (ctx->flags & EVP_CIPH_NO_PADDING) 494 return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl); 495 496 OPENSSL_assert(b <= sizeof(ctx->final)); 497 498 if (ctx->final_used) { 499 /* see comment about PTRDIFF_T comparison above */ 500 if (((PTRDIFF_T)out == (PTRDIFF_T)in) 501 || is_partially_overlapping(out, in, b)) { 502 EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); 503 return 0; 504 } 505 memcpy(out, ctx->final, b); 506 out += b; 507 fix_len = 1; 508 } else 509 fix_len = 0; 510 511 if (!evp_EncryptDecryptUpdate(ctx, out, outl, in, inl)) 512 return 0; 513 514 /* 515 * if we have 'decrypted' a multiple of block size, make sure we have a 516 * copy of this last block 517 */ 518 if (b > 1 && !ctx->buf_len) { 519 *outl -= b; 520 ctx->final_used = 1; 521 memcpy(ctx->final, &out[*outl], b); 522 } else 523 ctx->final_used = 0; 524 525 if (fix_len) 526 *outl += b; 527 528 return 1; 529 } 530 531 int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 532 { 533 int ret; 534 ret = EVP_DecryptFinal_ex(ctx, out, outl); 535 return ret; 536 } 537 538 int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 539 { 540 int i, n; 541 unsigned int b; 542 543 /* Prevent accidental use of encryption context when decrypting */ 544 if (ctx->encrypt) { 545 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_INVALID_OPERATION); 546 return 0; 547 } 548 549 *outl = 0; 550 551 if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { 552 i = ctx->cipher->do_cipher(ctx, out, NULL, 0); 553 if (i < 0) 554 return 0; 555 else 556 *outl = i; 557 return 1; 558 } 559 560 b = ctx->cipher->block_size; 561 if (ctx->flags & EVP_CIPH_NO_PADDING) { 562 if (ctx->buf_len) { 563 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, 564 EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); 565 return 0; 566 } 567 *outl = 0; 568 return 1; 569 } 570 if (b > 1) { 571 if (ctx->buf_len || !ctx->final_used) { 572 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_WRONG_FINAL_BLOCK_LENGTH); 573 return 0; 574 } 575 OPENSSL_assert(b <= sizeof(ctx->final)); 576 577 /* 578 * The following assumes that the ciphertext has been authenticated. 579 * Otherwise it provides a padding oracle. 580 */ 581 n = ctx->final[b - 1]; 582 if (n == 0 || n > (int)b) { 583 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT); 584 return 0; 585 } 586 for (i = 0; i < n; i++) { 587 if (ctx->final[--b] != n) { 588 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT); 589 return 0; 590 } 591 } 592 n = ctx->cipher->block_size - n; 593 for (i = 0; i < n; i++) 594 out[i] = ctx->final[i]; 595 *outl = n; 596 } else 597 *outl = 0; 598 return 1; 599 } 600 601 int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen) 602 { 603 if (c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH) 604 return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL); 605 if (c->key_len == keylen) 606 return 1; 607 if ((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) { 608 c->key_len = keylen; 609 return 1; 610 } 611 EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, EVP_R_INVALID_KEY_LENGTH); 612 return 0; 613 } 614 615 int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad) 616 { 617 if (pad) 618 ctx->flags &= ~EVP_CIPH_NO_PADDING; 619 else 620 ctx->flags |= EVP_CIPH_NO_PADDING; 621 return 1; 622 } 623 624 int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) 625 { 626 int ret; 627 628 if (!ctx->cipher) { 629 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET); 630 return 0; 631 } 632 633 if (!ctx->cipher->ctrl) { 634 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED); 635 return 0; 636 } 637 638 ret = ctx->cipher->ctrl(ctx, type, arg, ptr); 639 if (ret == -1) { 640 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, 641 EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED); 642 return 0; 643 } 644 return ret; 645 } 646 647 int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key) 648 { 649 if (ctx->cipher->flags & EVP_CIPH_RAND_KEY) 650 return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key); 651 if (RAND_priv_bytes(key, ctx->key_len) <= 0) 652 return 0; 653 return 1; 654 } 655 656 int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in) 657 { 658 if ((in == NULL) || (in->cipher == NULL)) { 659 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INPUT_NOT_INITIALIZED); 660 return 0; 661 } 662 #ifndef OPENSSL_NO_ENGINE 663 /* Make sure it's safe to copy a cipher context using an ENGINE */ 664 if (in->engine && !ENGINE_init(in->engine)) { 665 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_ENGINE_LIB); 666 return 0; 667 } 668 #endif 669 670 EVP_CIPHER_CTX_reset(out); 671 memcpy(out, in, sizeof(*out)); 672 673 if (in->cipher_data && in->cipher->ctx_size) { 674 out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size); 675 if (out->cipher_data == NULL) { 676 out->cipher = NULL; 677 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_MALLOC_FAILURE); 678 return 0; 679 } 680 memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size); 681 } 682 683 if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY) 684 if (!in->cipher->ctrl((EVP_CIPHER_CTX *)in, EVP_CTRL_COPY, 0, out)) { 685 out->cipher = NULL; 686 EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INITIALIZATION_ERROR); 687 return 0; 688 } 689 return 1; 690 } 691