1 /* $OpenBSD: dsa_lib.c,v 1.29 2018/04/14 07:09:21 tb Exp $ */ 2 /* $OpenBSD: rsa_lib.c,v 1.37 2018/04/14 07:09:21 tb Exp $ */ 3 /* $OpenBSD: evp_lib.c,v 1.17 2018/09/12 06:35:38 djm Exp $ */ 4 /* $OpenBSD: dh_lib.c,v 1.32 2018/05/02 15:48:38 tb Exp $ */ 5 /* $OpenBSD: p_lib.c,v 1.24 2018/05/30 15:40:50 tb Exp $ */ 6 /* $OpenBSD: digest.c,v 1.30 2018/04/14 07:09:21 tb Exp $ */ 7 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 8 * All rights reserved. 9 * 10 * This package is an SSL implementation written 11 * by Eric Young (eay@cryptsoft.com). 12 * The implementation was written so as to conform with Netscapes SSL. 13 * 14 * This library is free for commercial and non-commercial use as long as 15 * the following conditions are aheared to. The following conditions 16 * apply to all code found in this distribution, be it the RC4, RSA, 17 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 18 * included with this distribution is covered by the same copyright terms 19 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 20 * 21 * Copyright remains Eric Young's, and as such any Copyright notices in 22 * the code are not to be removed. 23 * If this package is used in a product, Eric Young should be given attribution 24 * as the author of the parts of the library used. 25 * This can be in the form of a textual message at program startup or 26 * in documentation (online or textual) provided with the package. 27 * 28 * Redistribution and use in source and binary forms, with or without 29 * modification, are permitted provided that the following conditions 30 * are met: 31 * 1. Redistributions of source code must retain the copyright 32 * notice, this list of conditions and the following disclaimer. 33 * 2. Redistributions in binary form must reproduce the above copyright 34 * notice, this list of conditions and the following disclaimer in the 35 * documentation and/or other materials provided with the distribution. 36 * 3. All advertising materials mentioning features or use of this software 37 * must display the following acknowledgement: 38 * "This product includes cryptographic software written by 39 * Eric Young (eay@cryptsoft.com)" 40 * The word 'cryptographic' can be left out if the rouines from the library 41 * being used are not cryptographic related :-). 42 * 4. If you include any Windows specific code (or a derivative thereof) from 43 * the apps directory (application code) you must include an acknowledgement: 44 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 45 * 46 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 47 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 49 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 50 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 51 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 52 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 53 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 54 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 55 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 56 * SUCH DAMAGE. 57 * 58 * The licence and distribution terms for any publically available version or 59 * derivative of this code cannot be changed. i.e. this code cannot simply be 60 * copied and put under another distribution licence 61 * [including the GNU Public Licence.] 62 */ 63 64 /* $OpenBSD: dsa_asn1.c,v 1.22 2018/06/14 17:03:19 jsing Exp $ */ 65 /* $OpenBSD: ecs_asn1.c,v 1.9 2018/03/17 15:24:44 tb Exp $ */ 66 /* $OpenBSD: digest.c,v 1.30 2018/04/14 07:09:21 tb Exp $ */ 67 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL 68 * project 2000. 69 */ 70 /* ==================================================================== 71 * Copyright (c) 2000-2005 The OpenSSL Project. All rights reserved. 72 * 73 * Redistribution and use in source and binary forms, with or without 74 * modification, are permitted provided that the following conditions 75 * are met: 76 * 77 * 1. Redistributions of source code must retain the above copyright 78 * notice, this list of conditions and the following disclaimer. 79 * 80 * 2. Redistributions in binary form must reproduce the above copyright 81 * notice, this list of conditions and the following disclaimer in 82 * the documentation and/or other materials provided with the 83 * distribution. 84 * 85 * 3. All advertising materials mentioning features or use of this 86 * software must display the following acknowledgment: 87 * "This product includes software developed by the OpenSSL Project 88 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 89 * 90 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 91 * endorse or promote products derived from this software without 92 * prior written permission. For written permission, please contact 93 * licensing@OpenSSL.org. 94 * 95 * 5. Products derived from this software may not be called "OpenSSL" 96 * nor may "OpenSSL" appear in their names without prior written 97 * permission of the OpenSSL Project. 98 * 99 * 6. Redistributions of any form whatsoever must retain the following 100 * acknowledgment: 101 * "This product includes software developed by the OpenSSL Project 102 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 103 * 104 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 105 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 106 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 107 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 108 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 109 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 110 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 111 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 112 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 113 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 114 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 115 * OF THE POSSIBILITY OF SUCH DAMAGE. 116 * ==================================================================== 117 * 118 * This product includes cryptographic software written by Eric Young 119 * (eay@cryptsoft.com). This product includes software written by Tim 120 * Hudson (tjh@cryptsoft.com). 121 * 122 */ 123 124 /* $OpenBSD: rsa_meth.c,v 1.2 2018/09/12 06:35:38 djm Exp $ */ 125 /* 126 * Copyright (c) 2018 Theo Buehler <tb@openbsd.org> 127 * 128 * Permission to use, copy, modify, and distribute this software for any 129 * purpose with or without fee is hereby granted, provided that the above 130 * copyright notice and this permission notice appear in all copies. 131 * 132 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 133 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 134 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 135 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 136 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 137 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 138 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 139 */ 140 141 #include "includes.h" 142 143 #ifdef WITH_OPENSSL 144 145 #include <sys/types.h> 146 147 #include <stdlib.h> 148 #include <string.h> 149 150 #include <openssl/err.h> 151 #include <openssl/bn.h> 152 #include <openssl/dsa.h> 153 #include <openssl/rsa.h> 154 #include <openssl/evp.h> 155 #include <openssl/ecdsa.h> 156 #include <openssl/dh.h> 157 158 #ifndef HAVE_DSA_GET0_PQG 159 void 160 DSA_get0_pqg(const DSA *d, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g) 161 { 162 if (p != NULL) 163 *p = d->p; 164 if (q != NULL) 165 *q = d->q; 166 if (g != NULL) 167 *g = d->g; 168 } 169 #endif /* HAVE_DSA_GET0_PQG */ 170 171 #ifndef HAVE_DSA_SET0_PQG 172 int 173 DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g) 174 { 175 if ((d->p == NULL && p == NULL) || (d->q == NULL && q == NULL) || 176 (d->g == NULL && g == NULL)) 177 return 0; 178 179 if (p != NULL) { 180 BN_free(d->p); 181 d->p = p; 182 } 183 if (q != NULL) { 184 BN_free(d->q); 185 d->q = q; 186 } 187 if (g != NULL) { 188 BN_free(d->g); 189 d->g = g; 190 } 191 192 return 1; 193 } 194 #endif /* HAVE_DSA_SET0_PQG */ 195 196 #ifndef HAVE_DSA_GET0_KEY 197 void 198 DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key) 199 { 200 if (pub_key != NULL) 201 *pub_key = d->pub_key; 202 if (priv_key != NULL) 203 *priv_key = d->priv_key; 204 } 205 #endif /* HAVE_DSA_GET0_KEY */ 206 207 #ifndef HAVE_DSA_SET0_KEY 208 int 209 DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key) 210 { 211 if (d->pub_key == NULL && pub_key == NULL) 212 return 0; 213 214 if (pub_key != NULL) { 215 BN_free(d->pub_key); 216 d->pub_key = pub_key; 217 } 218 if (priv_key != NULL) { 219 BN_free(d->priv_key); 220 d->priv_key = priv_key; 221 } 222 223 return 1; 224 } 225 #endif /* HAVE_DSA_SET0_KEY */ 226 227 #ifndef HAVE_RSA_GET0_KEY 228 void 229 RSA_get0_key(const RSA *r, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d) 230 { 231 if (n != NULL) 232 *n = r->n; 233 if (e != NULL) 234 *e = r->e; 235 if (d != NULL) 236 *d = r->d; 237 } 238 #endif /* HAVE_RSA_GET0_KEY */ 239 240 #ifndef HAVE_RSA_SET0_KEY 241 int 242 RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d) 243 { 244 if ((r->n == NULL && n == NULL) || (r->e == NULL && e == NULL)) 245 return 0; 246 247 if (n != NULL) { 248 BN_free(r->n); 249 r->n = n; 250 } 251 if (e != NULL) { 252 BN_free(r->e); 253 r->e = e; 254 } 255 if (d != NULL) { 256 BN_free(r->d); 257 r->d = d; 258 } 259 260 return 1; 261 } 262 #endif /* HAVE_RSA_SET0_KEY */ 263 264 #ifndef HAVE_RSA_GET0_CRT_PARAMS 265 void 266 RSA_get0_crt_params(const RSA *r, const BIGNUM **dmp1, const BIGNUM **dmq1, 267 const BIGNUM **iqmp) 268 { 269 if (dmp1 != NULL) 270 *dmp1 = r->dmp1; 271 if (dmq1 != NULL) 272 *dmq1 = r->dmq1; 273 if (iqmp != NULL) 274 *iqmp = r->iqmp; 275 } 276 #endif /* HAVE_RSA_GET0_CRT_PARAMS */ 277 278 #ifndef HAVE_RSA_SET0_CRT_PARAMS 279 int 280 RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp) 281 { 282 if ((r->dmp1 == NULL && dmp1 == NULL) || 283 (r->dmq1 == NULL && dmq1 == NULL) || 284 (r->iqmp == NULL && iqmp == NULL)) 285 return 0; 286 287 if (dmp1 != NULL) { 288 BN_free(r->dmp1); 289 r->dmp1 = dmp1; 290 } 291 if (dmq1 != NULL) { 292 BN_free(r->dmq1); 293 r->dmq1 = dmq1; 294 } 295 if (iqmp != NULL) { 296 BN_free(r->iqmp); 297 r->iqmp = iqmp; 298 } 299 300 return 1; 301 } 302 #endif /* HAVE_RSA_SET0_CRT_PARAMS */ 303 304 #ifndef HAVE_RSA_GET0_FACTORS 305 void 306 RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q) 307 { 308 if (p != NULL) 309 *p = r->p; 310 if (q != NULL) 311 *q = r->q; 312 } 313 #endif /* HAVE_RSA_GET0_FACTORS */ 314 315 #ifndef HAVE_RSA_SET0_FACTORS 316 int 317 RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q) 318 { 319 if ((r->p == NULL && p == NULL) || (r->q == NULL && q == NULL)) 320 return 0; 321 322 if (p != NULL) { 323 BN_free(r->p); 324 r->p = p; 325 } 326 if (q != NULL) { 327 BN_free(r->q); 328 r->q = q; 329 } 330 331 return 1; 332 } 333 #endif /* HAVE_RSA_SET0_FACTORS */ 334 335 #ifndef HAVE_EVP_CIPHER_CTX_GET_IV 336 int 337 EVP_CIPHER_CTX_get_iv(const EVP_CIPHER_CTX *ctx, unsigned char *iv, size_t len) 338 { 339 if (ctx == NULL) 340 return 0; 341 if (EVP_CIPHER_CTX_iv_length(ctx) < 0) 342 return 0; 343 if (len != (size_t)EVP_CIPHER_CTX_iv_length(ctx)) 344 return 0; 345 if (len > EVP_MAX_IV_LENGTH) 346 return 0; /* sanity check; shouldn't happen */ 347 /* 348 * Skip the memcpy entirely when the requested IV length is zero, 349 * since the iv pointer may be NULL or invalid. 350 */ 351 if (len != 0) { 352 if (iv == NULL) 353 return 0; 354 # ifdef HAVE_EVP_CIPHER_CTX_IV 355 memcpy(iv, EVP_CIPHER_CTX_iv(ctx), len); 356 # else 357 memcpy(iv, ctx->iv, len); 358 # endif /* HAVE_EVP_CIPHER_CTX_IV */ 359 } 360 return 1; 361 } 362 #endif /* HAVE_EVP_CIPHER_CTX_GET_IV */ 363 364 #ifndef HAVE_EVP_CIPHER_CTX_SET_IV 365 int 366 EVP_CIPHER_CTX_set_iv(EVP_CIPHER_CTX *ctx, const unsigned char *iv, size_t len) 367 { 368 if (ctx == NULL) 369 return 0; 370 if (EVP_CIPHER_CTX_iv_length(ctx) < 0) 371 return 0; 372 if (len != (size_t)EVP_CIPHER_CTX_iv_length(ctx)) 373 return 0; 374 if (len > EVP_MAX_IV_LENGTH) 375 return 0; /* sanity check; shouldn't happen */ 376 /* 377 * Skip the memcpy entirely when the requested IV length is zero, 378 * since the iv pointer may be NULL or invalid. 379 */ 380 if (len != 0) { 381 if (iv == NULL) 382 return 0; 383 # ifdef HAVE_EVP_CIPHER_CTX_IV_NOCONST 384 memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, len); 385 # else 386 memcpy(ctx->iv, iv, len); 387 # endif /* HAVE_EVP_CIPHER_CTX_IV_NOCONST */ 388 } 389 return 1; 390 } 391 #endif /* HAVE_EVP_CIPHER_CTX_SET_IV */ 392 393 #ifndef HAVE_DSA_SIG_GET0 394 void 395 DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps) 396 { 397 if (pr != NULL) 398 *pr = sig->r; 399 if (ps != NULL) 400 *ps = sig->s; 401 } 402 #endif /* HAVE_DSA_SIG_GET0 */ 403 404 #ifndef HAVE_DSA_SIG_SET0 405 int 406 DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s) 407 { 408 if (r == NULL || s == NULL) 409 return 0; 410 411 BN_clear_free(sig->r); 412 sig->r = r; 413 BN_clear_free(sig->s); 414 sig->s = s; 415 416 return 1; 417 } 418 #endif /* HAVE_DSA_SIG_SET0 */ 419 420 #ifndef HAVE_ECDSA_SIG_GET0 421 void 422 ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps) 423 { 424 if (pr != NULL) 425 *pr = sig->r; 426 if (ps != NULL) 427 *ps = sig->s; 428 } 429 #endif /* HAVE_ECDSA_SIG_GET0 */ 430 431 #ifndef HAVE_ECDSA_SIG_SET0 432 int 433 ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s) 434 { 435 if (r == NULL || s == NULL) 436 return 0; 437 438 BN_clear_free(sig->r); 439 BN_clear_free(sig->s); 440 sig->r = r; 441 sig->s = s; 442 return 1; 443 } 444 #endif /* HAVE_ECDSA_SIG_SET0 */ 445 446 #ifndef HAVE_DH_GET0_PQG 447 void 448 DH_get0_pqg(const DH *dh, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g) 449 { 450 if (p != NULL) 451 *p = dh->p; 452 if (q != NULL) 453 *q = dh->q; 454 if (g != NULL) 455 *g = dh->g; 456 } 457 #endif /* HAVE_DH_GET0_PQG */ 458 459 #ifndef HAVE_DH_SET0_PQG 460 int 461 DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g) 462 { 463 if ((dh->p == NULL && p == NULL) || (dh->g == NULL && g == NULL)) 464 return 0; 465 466 if (p != NULL) { 467 BN_free(dh->p); 468 dh->p = p; 469 } 470 if (q != NULL) { 471 BN_free(dh->q); 472 dh->q = q; 473 } 474 if (g != NULL) { 475 BN_free(dh->g); 476 dh->g = g; 477 } 478 479 return 1; 480 } 481 #endif /* HAVE_DH_SET0_PQG */ 482 483 #ifndef HAVE_DH_GET0_KEY 484 void 485 DH_get0_key(const DH *dh, const BIGNUM **pub_key, const BIGNUM **priv_key) 486 { 487 if (pub_key != NULL) 488 *pub_key = dh->pub_key; 489 if (priv_key != NULL) 490 *priv_key = dh->priv_key; 491 } 492 #endif /* HAVE_DH_GET0_KEY */ 493 494 #ifndef HAVE_DH_SET0_KEY 495 int 496 DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key) 497 { 498 if (pub_key != NULL) { 499 BN_free(dh->pub_key); 500 dh->pub_key = pub_key; 501 } 502 if (priv_key != NULL) { 503 BN_free(dh->priv_key); 504 dh->priv_key = priv_key; 505 } 506 507 return 1; 508 } 509 #endif /* HAVE_DH_SET0_KEY */ 510 511 #ifndef HAVE_DH_SET_LENGTH 512 int 513 DH_set_length(DH *dh, long length) 514 { 515 if (length < 0 || length > INT_MAX) 516 return 0; 517 518 dh->length = length; 519 return 1; 520 } 521 #endif /* HAVE_DH_SET_LENGTH */ 522 523 #ifndef HAVE_RSA_METH_FREE 524 void 525 RSA_meth_free(RSA_METHOD *meth) 526 { 527 if (meth != NULL) { 528 free((char *)meth->name); 529 free(meth); 530 } 531 } 532 #endif /* HAVE_RSA_METH_FREE */ 533 534 #ifndef HAVE_RSA_METH_DUP 535 RSA_METHOD * 536 RSA_meth_dup(const RSA_METHOD *meth) 537 { 538 RSA_METHOD *copy; 539 540 if ((copy = calloc(1, sizeof(*copy))) == NULL) 541 return NULL; 542 memcpy(copy, meth, sizeof(*copy)); 543 if ((copy->name = strdup(meth->name)) == NULL) { 544 free(copy); 545 return NULL; 546 } 547 548 return copy; 549 } 550 #endif /* HAVE_RSA_METH_DUP */ 551 552 #ifndef HAVE_RSA_METH_SET1_NAME 553 int 554 RSA_meth_set1_name(RSA_METHOD *meth, const char *name) 555 { 556 char *copy; 557 558 if ((copy = strdup(name)) == NULL) 559 return 0; 560 free((char *)meth->name); 561 meth->name = copy; 562 return 1; 563 } 564 #endif /* HAVE_RSA_METH_SET1_NAME */ 565 566 #ifndef HAVE_RSA_METH_GET_FINISH 567 int 568 (*RSA_meth_get_finish(const RSA_METHOD *meth))(RSA *rsa) 569 { 570 return meth->finish; 571 } 572 #endif /* HAVE_RSA_METH_GET_FINISH */ 573 574 #ifndef HAVE_RSA_METH_SET_PRIV_ENC 575 int 576 RSA_meth_set_priv_enc(RSA_METHOD *meth, int (*priv_enc)(int flen, 577 const unsigned char *from, unsigned char *to, RSA *rsa, int padding)) 578 { 579 meth->rsa_priv_enc = priv_enc; 580 return 1; 581 } 582 #endif /* HAVE_RSA_METH_SET_PRIV_ENC */ 583 584 #ifndef HAVE_RSA_METH_SET_PRIV_DEC 585 int 586 RSA_meth_set_priv_dec(RSA_METHOD *meth, int (*priv_dec)(int flen, 587 const unsigned char *from, unsigned char *to, RSA *rsa, int padding)) 588 { 589 meth->rsa_priv_dec = priv_dec; 590 return 1; 591 } 592 #endif /* HAVE_RSA_METH_SET_PRIV_DEC */ 593 594 #ifndef HAVE_RSA_METH_SET_FINISH 595 int 596 RSA_meth_set_finish(RSA_METHOD *meth, int (*finish)(RSA *rsa)) 597 { 598 meth->finish = finish; 599 return 1; 600 } 601 #endif /* HAVE_RSA_METH_SET_FINISH */ 602 603 #ifndef HAVE_EVP_PKEY_GET0_RSA 604 RSA * 605 EVP_PKEY_get0_RSA(EVP_PKEY *pkey) 606 { 607 if (pkey->type != EVP_PKEY_RSA) { 608 /* EVPerror(EVP_R_EXPECTING_AN_RSA_KEY); */ 609 return NULL; 610 } 611 return pkey->pkey.rsa; 612 } 613 #endif /* HAVE_EVP_PKEY_GET0_RSA */ 614 615 #ifndef HAVE_EVP_MD_CTX_NEW 616 EVP_MD_CTX * 617 EVP_MD_CTX_new(void) 618 { 619 return calloc(1, sizeof(EVP_MD_CTX)); 620 } 621 #endif /* HAVE_EVP_MD_CTX_NEW */ 622 623 #ifndef HAVE_EVP_MD_CTX_FREE 624 void 625 EVP_MD_CTX_free(EVP_MD_CTX *ctx) 626 { 627 if (ctx == NULL) 628 return; 629 630 EVP_MD_CTX_cleanup(ctx); 631 632 free(ctx); 633 } 634 #endif /* HAVE_EVP_MD_CTX_FREE */ 635 636 #endif /* WITH_OPENSSL */ 637