1/* 2 * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (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/* 11 * DSA low level APIs are deprecated for public use, but still ok for 12 * internal use. 13 */ 14#include "internal/deprecated.h" 15 16#include <stdio.h> 17#include "internal/cryptlib.h" 18#include <openssl/asn1t.h> 19#include <openssl/x509.h> 20#include <openssl/engine.h> 21#include "crypto/asn1.h" 22#include "crypto/evp.h" 23#include "crypto/x509.h" 24#include <openssl/rsa.h> 25#include <openssl/dsa.h> 26#include <openssl/decoder.h> 27#include <openssl/encoder.h> 28#include "internal/provider.h" 29#include "internal/sizes.h" 30 31struct X509_pubkey_st { 32 X509_ALGOR *algor; 33 ASN1_BIT_STRING *public_key; 34 35 EVP_PKEY *pkey; 36 37 /* extra data for the callback, used by d2i_PUBKEY_ex */ 38 OSSL_LIB_CTX *libctx; 39 char *propq; 40 41 /* Flag to force legacy keys */ 42 unsigned int flag_force_legacy : 1; 43}; 44 45static int x509_pubkey_decode(EVP_PKEY **pk, const X509_PUBKEY *key); 46 47static int x509_pubkey_set0_libctx(X509_PUBKEY *x, OSSL_LIB_CTX *libctx, 48 const char *propq) 49{ 50 if (x != NULL) { 51 x->libctx = libctx; 52 OPENSSL_free(x->propq); 53 x->propq = NULL; 54 if (propq != NULL) { 55 x->propq = OPENSSL_strdup(propq); 56 if (x->propq == NULL) 57 return 0; 58 } 59 } 60 return 1; 61} 62 63ASN1_SEQUENCE(X509_PUBKEY_INTERNAL) = { 64 ASN1_SIMPLE(X509_PUBKEY, algor, X509_ALGOR), 65 ASN1_SIMPLE(X509_PUBKEY, public_key, ASN1_BIT_STRING) 66} static_ASN1_SEQUENCE_END_name(X509_PUBKEY, X509_PUBKEY_INTERNAL) 67 68X509_PUBKEY *ossl_d2i_X509_PUBKEY_INTERNAL(const unsigned char **pp, 69 long len, OSSL_LIB_CTX *libctx) 70{ 71 X509_PUBKEY *xpub = OPENSSL_zalloc(sizeof(*xpub)); 72 73 if (xpub == NULL) 74 return NULL; 75 return (X509_PUBKEY *)ASN1_item_d2i_ex((ASN1_VALUE **)&xpub, pp, len, 76 ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL), 77 libctx, NULL); 78} 79 80void ossl_X509_PUBKEY_INTERNAL_free(X509_PUBKEY *xpub) 81{ 82 ASN1_item_free((ASN1_VALUE *)xpub, ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL)); 83} 84 85static void x509_pubkey_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) 86{ 87 X509_PUBKEY *pubkey; 88 89 if (pval != NULL && (pubkey = (X509_PUBKEY *)*pval) != NULL) { 90 X509_ALGOR_free(pubkey->algor); 91 ASN1_BIT_STRING_free(pubkey->public_key); 92 EVP_PKEY_free(pubkey->pkey); 93 OPENSSL_free(pubkey->propq); 94 OPENSSL_free(pubkey); 95 *pval = NULL; 96 } 97} 98 99static int x509_pubkey_ex_populate(ASN1_VALUE **pval, const ASN1_ITEM *it) 100{ 101 X509_PUBKEY *pubkey = (X509_PUBKEY *)*pval; 102 103 return (pubkey->algor != NULL 104 || (pubkey->algor = X509_ALGOR_new()) != NULL) 105 && (pubkey->public_key != NULL 106 || (pubkey->public_key = ASN1_BIT_STRING_new()) != NULL); 107} 108 109 110static int x509_pubkey_ex_new_ex(ASN1_VALUE **pval, const ASN1_ITEM *it, 111 OSSL_LIB_CTX *libctx, const char *propq) 112{ 113 X509_PUBKEY *ret; 114 115 if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL 116 || !x509_pubkey_ex_populate((ASN1_VALUE **)&ret, NULL) 117 || !x509_pubkey_set0_libctx(ret, libctx, propq)) { 118 x509_pubkey_ex_free((ASN1_VALUE **)&ret, NULL); 119 ret = NULL; 120 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 121 } else { 122 *pval = (ASN1_VALUE *)ret; 123 } 124 125 return ret != NULL; 126} 127 128static int x509_pubkey_ex_d2i_ex(ASN1_VALUE **pval, 129 const unsigned char **in, long len, 130 const ASN1_ITEM *it, int tag, int aclass, 131 char opt, ASN1_TLC *ctx, OSSL_LIB_CTX *libctx, 132 const char *propq) 133{ 134 const unsigned char *in_saved = *in; 135 size_t publen; 136 X509_PUBKEY *pubkey; 137 int ret; 138 OSSL_DECODER_CTX *dctx = NULL; 139 unsigned char *tmpbuf = NULL; 140 141 if (*pval == NULL && !x509_pubkey_ex_new_ex(pval, it, libctx, propq)) 142 return 0; 143 if (!x509_pubkey_ex_populate(pval, NULL)) { 144 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 145 return 0; 146 } 147 148 /* This ensures that |*in| advances properly no matter what */ 149 if ((ret = ASN1_item_ex_d2i(pval, in, len, 150 ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL), 151 tag, aclass, opt, ctx)) <= 0) 152 return ret; 153 154 publen = *in - in_saved; 155 if (!ossl_assert(publen > 0)) { 156 ERR_raise(ERR_LIB_ASN1, ERR_R_INTERNAL_ERROR); 157 return 0; 158 } 159 160 pubkey = (X509_PUBKEY *)*pval; 161 EVP_PKEY_free(pubkey->pkey); 162 pubkey->pkey = NULL; 163 164 /* 165 * Opportunistically decode the key but remove any non fatal errors 166 * from the queue. Subsequent explicit attempts to decode/use the key 167 * will return an appropriate error. 168 */ 169 ERR_set_mark(); 170 171 /* 172 * Try to decode with legacy method first. This ensures that engines 173 * aren't overriden by providers. 174 */ 175 if ((ret = x509_pubkey_decode(&pubkey->pkey, pubkey)) == -1) { 176 /* -1 indicates a fatal error, like malloc failure */ 177 ERR_clear_last_mark(); 178 goto end; 179 } 180 181 /* Try to decode it into an EVP_PKEY with OSSL_DECODER */ 182 if (ret <= 0 && !pubkey->flag_force_legacy) { 183 const unsigned char *p; 184 char txtoidname[OSSL_MAX_NAME_SIZE]; 185 size_t slen = publen; 186 187 /* 188 * The decoders don't know how to handle anything other than Universal 189 * class so we modify the data accordingly. 190 */ 191 if (aclass != V_ASN1_UNIVERSAL) { 192 tmpbuf = OPENSSL_memdup(in_saved, publen); 193 if (tmpbuf == NULL) { 194 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 195 return 0; 196 } 197 in_saved = tmpbuf; 198 *tmpbuf = V_ASN1_CONSTRUCTED | V_ASN1_SEQUENCE; 199 } 200 p = in_saved; 201 202 if (OBJ_obj2txt(txtoidname, sizeof(txtoidname), 203 pubkey->algor->algorithm, 0) <= 0) { 204 ERR_clear_last_mark(); 205 goto end; 206 } 207 if ((dctx = 208 OSSL_DECODER_CTX_new_for_pkey(&pubkey->pkey, 209 "DER", "SubjectPublicKeyInfo", 210 txtoidname, EVP_PKEY_PUBLIC_KEY, 211 pubkey->libctx, 212 pubkey->propq)) != NULL) 213 /* 214 * As said higher up, we're being opportunistic. In other words, 215 * we don't care if we fail. 216 */ 217 if (OSSL_DECODER_from_data(dctx, &p, &slen)) { 218 if (slen != 0) { 219 /* 220 * If we successfully decoded then we *must* consume all the 221 * bytes. 222 */ 223 ERR_clear_last_mark(); 224 ERR_raise(ERR_LIB_ASN1, EVP_R_DECODE_ERROR); 225 goto end; 226 } 227 } 228 } 229 230 ERR_pop_to_mark(); 231 ret = 1; 232 end: 233 OSSL_DECODER_CTX_free(dctx); 234 OPENSSL_free(tmpbuf); 235 return ret; 236} 237 238static int x509_pubkey_ex_i2d(const ASN1_VALUE **pval, unsigned char **out, 239 const ASN1_ITEM *it, int tag, int aclass) 240{ 241 return ASN1_item_ex_i2d(pval, out, ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL), 242 tag, aclass); 243} 244 245static int x509_pubkey_ex_print(BIO *out, const ASN1_VALUE **pval, int indent, 246 const char *fname, const ASN1_PCTX *pctx) 247{ 248 return ASN1_item_print(out, *pval, indent, 249 ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL), pctx); 250} 251 252static const ASN1_EXTERN_FUNCS x509_pubkey_ff = { 253 NULL, 254 NULL, 255 x509_pubkey_ex_free, 256 0, /* Default clear behaviour is OK */ 257 NULL, 258 x509_pubkey_ex_i2d, 259 x509_pubkey_ex_print, 260 x509_pubkey_ex_new_ex, 261 x509_pubkey_ex_d2i_ex, 262}; 263 264IMPLEMENT_EXTERN_ASN1(X509_PUBKEY, V_ASN1_SEQUENCE, x509_pubkey_ff) 265IMPLEMENT_ASN1_FUNCTIONS(X509_PUBKEY) 266 267X509_PUBKEY *X509_PUBKEY_new_ex(OSSL_LIB_CTX *libctx, const char *propq) 268{ 269 X509_PUBKEY *pubkey = NULL; 270 271 pubkey = (X509_PUBKEY *)ASN1_item_new_ex(X509_PUBKEY_it(), libctx, propq); 272 if (!x509_pubkey_set0_libctx(pubkey, libctx, propq)) { 273 X509_PUBKEY_free(pubkey); 274 pubkey = NULL; 275 } 276 return pubkey; 277} 278 279/* 280 * X509_PUBKEY_dup() must be implemented manually, because there is no 281 * support for it in ASN1_EXTERN_FUNCS. 282 */ 283X509_PUBKEY *X509_PUBKEY_dup(const X509_PUBKEY *a) 284{ 285 X509_PUBKEY *pubkey = OPENSSL_zalloc(sizeof(*pubkey)); 286 287 if (pubkey == NULL 288 || !x509_pubkey_set0_libctx(pubkey, a->libctx, a->propq) 289 || (pubkey->algor = X509_ALGOR_dup(a->algor)) == NULL 290 || (pubkey->public_key = ASN1_BIT_STRING_new()) == NULL 291 || !ASN1_BIT_STRING_set(pubkey->public_key, 292 a->public_key->data, 293 a->public_key->length)) { 294 x509_pubkey_ex_free((ASN1_VALUE **)&pubkey, 295 ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL)); 296 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 297 return NULL; 298 } 299 300 if (a->pkey != NULL) { 301 ERR_set_mark(); 302 pubkey->pkey = EVP_PKEY_dup(a->pkey); 303 if (pubkey->pkey == NULL) { 304 pubkey->flag_force_legacy = 1; 305 if (x509_pubkey_decode(&pubkey->pkey, pubkey) <= 0) { 306 x509_pubkey_ex_free((ASN1_VALUE **)&pubkey, 307 ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL)); 308 ERR_clear_last_mark(); 309 return NULL; 310 } 311 } 312 ERR_pop_to_mark(); 313 } 314 return pubkey; 315} 316 317int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey) 318{ 319 X509_PUBKEY *pk = NULL; 320 321 if (x == NULL || pkey == NULL) { 322 ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER); 323 return 0; 324 } 325 326 if (pkey->ameth != NULL) { 327 if ((pk = X509_PUBKEY_new()) == NULL) { 328 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 329 goto error; 330 } 331 if (pkey->ameth->pub_encode != NULL) { 332 if (!pkey->ameth->pub_encode(pk, pkey)) { 333 ERR_raise(ERR_LIB_X509, X509_R_PUBLIC_KEY_ENCODE_ERROR); 334 goto error; 335 } 336 } else { 337 ERR_raise(ERR_LIB_X509, X509_R_METHOD_NOT_SUPPORTED); 338 goto error; 339 } 340 } else if (evp_pkey_is_provided(pkey)) { 341 unsigned char *der = NULL; 342 size_t derlen = 0; 343 OSSL_ENCODER_CTX *ectx = 344 OSSL_ENCODER_CTX_new_for_pkey(pkey, EVP_PKEY_PUBLIC_KEY, 345 "DER", "SubjectPublicKeyInfo", 346 NULL); 347 348 if (OSSL_ENCODER_to_data(ectx, &der, &derlen)) { 349 const unsigned char *pder = der; 350 351 pk = d2i_X509_PUBKEY(NULL, &pder, (long)derlen); 352 } 353 354 OSSL_ENCODER_CTX_free(ectx); 355 OPENSSL_free(der); 356 } 357 358 if (pk == NULL) { 359 ERR_raise(ERR_LIB_X509, X509_R_UNSUPPORTED_ALGORITHM); 360 goto error; 361 } 362 363 X509_PUBKEY_free(*x); 364 if (!EVP_PKEY_up_ref(pkey)) { 365 ERR_raise(ERR_LIB_X509, ERR_R_INTERNAL_ERROR); 366 goto error; 367 } 368 *x = pk; 369 370 /* 371 * pk->pkey is NULL when using the legacy routine, but is non-NULL when 372 * going through the encoder, and for all intents and purposes, it's 373 * a perfect copy of the public key portions of |pkey|, just not the same 374 * instance. If that's all there was to pkey then we could simply return 375 * early, right here. However, some application might very well depend on 376 * the passed |pkey| being used and none other, so we spend a few more 377 * cycles throwing away the newly created |pk->pkey| and replace it with 378 * |pkey|. 379 */ 380 if (pk->pkey != NULL) 381 EVP_PKEY_free(pk->pkey); 382 383 pk->pkey = pkey; 384 return 1; 385 386 error: 387 X509_PUBKEY_free(pk); 388 return 0; 389} 390 391/* 392 * Attempt to decode a public key. 393 * Returns 1 on success, 0 for a decode failure and -1 for a fatal 394 * error e.g. malloc failure. 395 * 396 * This function is #legacy. 397 */ 398static int x509_pubkey_decode(EVP_PKEY **ppkey, const X509_PUBKEY *key) 399{ 400 EVP_PKEY *pkey; 401 int nid; 402 403 nid = OBJ_obj2nid(key->algor->algorithm); 404 if (!key->flag_force_legacy) { 405#ifndef OPENSSL_NO_ENGINE 406 ENGINE *e = NULL; 407 408 e = ENGINE_get_pkey_meth_engine(nid); 409 if (e == NULL) 410 return 0; 411 ENGINE_finish(e); 412#else 413 return 0; 414#endif 415 } 416 417 pkey = EVP_PKEY_new(); 418 if (pkey == NULL) { 419 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 420 return -1; 421 } 422 423 if (!EVP_PKEY_set_type(pkey, nid)) { 424 ERR_raise(ERR_LIB_X509, X509_R_UNSUPPORTED_ALGORITHM); 425 goto error; 426 } 427 428 if (pkey->ameth->pub_decode) { 429 /* 430 * Treat any failure of pub_decode as a decode error. In 431 * future we could have different return codes for decode 432 * errors and fatal errors such as malloc failure. 433 */ 434 if (!pkey->ameth->pub_decode(pkey, key)) 435 goto error; 436 } else { 437 ERR_raise(ERR_LIB_X509, X509_R_METHOD_NOT_SUPPORTED); 438 goto error; 439 } 440 441 *ppkey = pkey; 442 return 1; 443 444 error: 445 EVP_PKEY_free(pkey); 446 return 0; 447} 448 449EVP_PKEY *X509_PUBKEY_get0(const X509_PUBKEY *key) 450{ 451 if (key == NULL) { 452 ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER); 453 return NULL; 454 } 455 456 if (key->pkey == NULL) { 457 /* We failed to decode the key when we loaded it, or it was never set */ 458 ERR_raise(ERR_LIB_EVP, EVP_R_DECODE_ERROR); 459 return NULL; 460 } 461 462 return key->pkey; 463} 464 465EVP_PKEY *X509_PUBKEY_get(const X509_PUBKEY *key) 466{ 467 EVP_PKEY *ret = X509_PUBKEY_get0(key); 468 469 if (ret != NULL && !EVP_PKEY_up_ref(ret)) { 470 ERR_raise(ERR_LIB_X509, ERR_R_INTERNAL_ERROR); 471 ret = NULL; 472 } 473 return ret; 474} 475 476/* 477 * Now three pseudo ASN1 routines that take an EVP_PKEY structure and encode 478 * or decode as X509_PUBKEY 479 */ 480static EVP_PKEY *d2i_PUBKEY_int(EVP_PKEY **a, 481 const unsigned char **pp, long length, 482 OSSL_LIB_CTX *libctx, const char *propq, 483 unsigned int force_legacy, 484 X509_PUBKEY * 485 (*d2i_x509_pubkey)(X509_PUBKEY **a, 486 const unsigned char **in, 487 long len)) 488{ 489 X509_PUBKEY *xpk, *xpk2 = NULL, **pxpk = NULL; 490 EVP_PKEY *pktmp = NULL; 491 const unsigned char *q; 492 493 q = *pp; 494 495 /* 496 * If libctx or propq are non-NULL, we take advantage of the reuse 497 * feature. It's not generally recommended, but is safe enough for 498 * newly created structures. 499 */ 500 if (libctx != NULL || propq != NULL || force_legacy) { 501 xpk2 = OPENSSL_zalloc(sizeof(*xpk2)); 502 if (xpk2 == NULL) { 503 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 504 return NULL; 505 } 506 if (!x509_pubkey_set0_libctx(xpk2, libctx, propq)) 507 goto end; 508 xpk2->flag_force_legacy = !!force_legacy; 509 pxpk = &xpk2; 510 } 511 xpk = d2i_x509_pubkey(pxpk, &q, length); 512 if (xpk == NULL) 513 goto end; 514 pktmp = X509_PUBKEY_get(xpk); 515 X509_PUBKEY_free(xpk); 516 xpk2 = NULL; /* We know that xpk == xpk2 */ 517 if (pktmp == NULL) 518 goto end; 519 *pp = q; 520 if (a != NULL) { 521 EVP_PKEY_free(*a); 522 *a = pktmp; 523 } 524 end: 525 X509_PUBKEY_free(xpk2); 526 return pktmp; 527} 528 529/* For the algorithm specific d2i functions further down */ 530EVP_PKEY *ossl_d2i_PUBKEY_legacy(EVP_PKEY **a, const unsigned char **pp, 531 long length) 532{ 533 return d2i_PUBKEY_int(a, pp, length, NULL, NULL, 1, d2i_X509_PUBKEY); 534} 535 536EVP_PKEY *d2i_PUBKEY_ex(EVP_PKEY **a, const unsigned char **pp, long length, 537 OSSL_LIB_CTX *libctx, const char *propq) 538{ 539 return d2i_PUBKEY_int(a, pp, length, libctx, propq, 0, d2i_X509_PUBKEY); 540} 541 542EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length) 543{ 544 return d2i_PUBKEY_ex(a, pp, length, NULL, NULL); 545} 546 547int i2d_PUBKEY(const EVP_PKEY *a, unsigned char **pp) 548{ 549 int ret = -1; 550 551 if (a == NULL) 552 return 0; 553 if (a->ameth != NULL) { 554 X509_PUBKEY *xpk = NULL; 555 556 if ((xpk = X509_PUBKEY_new()) == NULL) 557 return -1; 558 559 /* pub_encode() only encode parameters, not the key itself */ 560 if (a->ameth->pub_encode != NULL && a->ameth->pub_encode(xpk, a)) { 561 xpk->pkey = (EVP_PKEY *)a; 562 ret = i2d_X509_PUBKEY(xpk, pp); 563 xpk->pkey = NULL; 564 } 565 X509_PUBKEY_free(xpk); 566 } else if (a->keymgmt != NULL) { 567 OSSL_ENCODER_CTX *ctx = 568 OSSL_ENCODER_CTX_new_for_pkey(a, EVP_PKEY_PUBLIC_KEY, 569 "DER", "SubjectPublicKeyInfo", 570 NULL); 571 BIO *out = BIO_new(BIO_s_mem()); 572 BUF_MEM *buf = NULL; 573 574 if (OSSL_ENCODER_CTX_get_num_encoders(ctx) != 0 575 && out != NULL 576 && OSSL_ENCODER_to_bio(ctx, out) 577 && BIO_get_mem_ptr(out, &buf) > 0) { 578 ret = buf->length; 579 580 if (pp != NULL) { 581 if (*pp == NULL) { 582 *pp = (unsigned char *)buf->data; 583 buf->length = 0; 584 buf->data = NULL; 585 } else { 586 memcpy(*pp, buf->data, ret); 587 *pp += ret; 588 } 589 } 590 } 591 BIO_free(out); 592 OSSL_ENCODER_CTX_free(ctx); 593 } 594 595 return ret; 596} 597 598/* 599 * The following are equivalents but which return RSA and DSA keys 600 */ 601RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length) 602{ 603 EVP_PKEY *pkey; 604 RSA *key = NULL; 605 const unsigned char *q; 606 607 q = *pp; 608 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 609 if (pkey == NULL) 610 return NULL; 611 key = EVP_PKEY_get1_RSA(pkey); 612 EVP_PKEY_free(pkey); 613 if (key == NULL) 614 return NULL; 615 *pp = q; 616 if (a != NULL) { 617 RSA_free(*a); 618 *a = key; 619 } 620 return key; 621} 622 623int i2d_RSA_PUBKEY(const RSA *a, unsigned char **pp) 624{ 625 EVP_PKEY *pktmp; 626 int ret; 627 if (!a) 628 return 0; 629 pktmp = EVP_PKEY_new(); 630 if (pktmp == NULL) { 631 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 632 return -1; 633 } 634 (void)EVP_PKEY_assign_RSA(pktmp, (RSA *)a); 635 ret = i2d_PUBKEY(pktmp, pp); 636 pktmp->pkey.ptr = NULL; 637 EVP_PKEY_free(pktmp); 638 return ret; 639} 640 641#ifndef OPENSSL_NO_DH 642DH *ossl_d2i_DH_PUBKEY(DH **a, const unsigned char **pp, long length) 643{ 644 EVP_PKEY *pkey; 645 DH *key = NULL; 646 const unsigned char *q; 647 648 q = *pp; 649 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 650 if (pkey == NULL) 651 return NULL; 652 if (EVP_PKEY_get_id(pkey) == EVP_PKEY_DH) 653 key = EVP_PKEY_get1_DH(pkey); 654 EVP_PKEY_free(pkey); 655 if (key == NULL) 656 return NULL; 657 *pp = q; 658 if (a != NULL) { 659 DH_free(*a); 660 *a = key; 661 } 662 return key; 663} 664 665int ossl_i2d_DH_PUBKEY(const DH *a, unsigned char **pp) 666{ 667 EVP_PKEY *pktmp; 668 int ret; 669 if (!a) 670 return 0; 671 pktmp = EVP_PKEY_new(); 672 if (pktmp == NULL) { 673 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 674 return -1; 675 } 676 (void)EVP_PKEY_assign_DH(pktmp, (DH *)a); 677 ret = i2d_PUBKEY(pktmp, pp); 678 pktmp->pkey.ptr = NULL; 679 EVP_PKEY_free(pktmp); 680 return ret; 681} 682 683DH *ossl_d2i_DHx_PUBKEY(DH **a, const unsigned char **pp, long length) 684{ 685 EVP_PKEY *pkey; 686 DH *key = NULL; 687 const unsigned char *q; 688 689 q = *pp; 690 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 691 if (pkey == NULL) 692 return NULL; 693 if (EVP_PKEY_get_id(pkey) == EVP_PKEY_DHX) 694 key = EVP_PKEY_get1_DH(pkey); 695 EVP_PKEY_free(pkey); 696 if (key == NULL) 697 return NULL; 698 *pp = q; 699 if (a != NULL) { 700 DH_free(*a); 701 *a = key; 702 } 703 return key; 704} 705 706int ossl_i2d_DHx_PUBKEY(const DH *a, unsigned char **pp) 707{ 708 EVP_PKEY *pktmp; 709 int ret; 710 if (!a) 711 return 0; 712 pktmp = EVP_PKEY_new(); 713 if (pktmp == NULL) { 714 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 715 return -1; 716 } 717 (void)EVP_PKEY_assign(pktmp, EVP_PKEY_DHX, (DH *)a); 718 ret = i2d_PUBKEY(pktmp, pp); 719 pktmp->pkey.ptr = NULL; 720 EVP_PKEY_free(pktmp); 721 return ret; 722} 723#endif 724 725#ifndef OPENSSL_NO_DSA 726DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length) 727{ 728 EVP_PKEY *pkey; 729 DSA *key = NULL; 730 const unsigned char *q; 731 732 q = *pp; 733 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 734 if (pkey == NULL) 735 return NULL; 736 key = EVP_PKEY_get1_DSA(pkey); 737 EVP_PKEY_free(pkey); 738 if (key == NULL) 739 return NULL; 740 *pp = q; 741 if (a != NULL) { 742 DSA_free(*a); 743 *a = key; 744 } 745 return key; 746} 747 748/* Called from decoders; disallows provided DSA keys without parameters. */ 749DSA *ossl_d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length) 750{ 751 DSA *key = NULL; 752 const unsigned char *data; 753 const BIGNUM *p, *q, *g; 754 755 data = *pp; 756 key = d2i_DSA_PUBKEY(NULL, &data, length); 757 if (key == NULL) 758 return NULL; 759 DSA_get0_pqg(key, &p, &q, &g); 760 if (p == NULL || q == NULL || g == NULL) { 761 DSA_free(key); 762 return NULL; 763 } 764 *pp = data; 765 if (a != NULL) { 766 DSA_free(*a); 767 *a = key; 768 } 769 return key; 770} 771 772int i2d_DSA_PUBKEY(const DSA *a, unsigned char **pp) 773{ 774 EVP_PKEY *pktmp; 775 int ret; 776 if (!a) 777 return 0; 778 pktmp = EVP_PKEY_new(); 779 if (pktmp == NULL) { 780 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 781 return -1; 782 } 783 (void)EVP_PKEY_assign_DSA(pktmp, (DSA *)a); 784 ret = i2d_PUBKEY(pktmp, pp); 785 pktmp->pkey.ptr = NULL; 786 EVP_PKEY_free(pktmp); 787 return ret; 788} 789#endif 790 791#ifndef OPENSSL_NO_EC 792EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length) 793{ 794 EVP_PKEY *pkey; 795 EC_KEY *key = NULL; 796 const unsigned char *q; 797 int type; 798 799 q = *pp; 800 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 801 if (pkey == NULL) 802 return NULL; 803 type = EVP_PKEY_get_id(pkey); 804 if (type == EVP_PKEY_EC || type == EVP_PKEY_SM2) 805 key = EVP_PKEY_get1_EC_KEY(pkey); 806 EVP_PKEY_free(pkey); 807 if (key == NULL) 808 return NULL; 809 *pp = q; 810 if (a != NULL) { 811 EC_KEY_free(*a); 812 *a = key; 813 } 814 return key; 815} 816 817int i2d_EC_PUBKEY(const EC_KEY *a, unsigned char **pp) 818{ 819 EVP_PKEY *pktmp; 820 int ret; 821 822 if (a == NULL) 823 return 0; 824 if ((pktmp = EVP_PKEY_new()) == NULL) { 825 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 826 return -1; 827 } 828 (void)EVP_PKEY_assign_EC_KEY(pktmp, (EC_KEY *)a); 829 ret = i2d_PUBKEY(pktmp, pp); 830 pktmp->pkey.ptr = NULL; 831 EVP_PKEY_free(pktmp); 832 return ret; 833} 834 835ECX_KEY *ossl_d2i_ED25519_PUBKEY(ECX_KEY **a, 836 const unsigned char **pp, long length) 837{ 838 EVP_PKEY *pkey; 839 ECX_KEY *key = NULL; 840 const unsigned char *q; 841 842 q = *pp; 843 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 844 if (pkey == NULL) 845 return NULL; 846 key = ossl_evp_pkey_get1_ED25519(pkey); 847 EVP_PKEY_free(pkey); 848 if (key == NULL) 849 return NULL; 850 *pp = q; 851 if (a != NULL) { 852 ossl_ecx_key_free(*a); 853 *a = key; 854 } 855 return key; 856} 857 858int ossl_i2d_ED25519_PUBKEY(const ECX_KEY *a, unsigned char **pp) 859{ 860 EVP_PKEY *pktmp; 861 int ret; 862 863 if (a == NULL) 864 return 0; 865 if ((pktmp = EVP_PKEY_new()) == NULL) { 866 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 867 return -1; 868 } 869 (void)EVP_PKEY_assign(pktmp, EVP_PKEY_ED25519, (ECX_KEY *)a); 870 ret = i2d_PUBKEY(pktmp, pp); 871 pktmp->pkey.ptr = NULL; 872 EVP_PKEY_free(pktmp); 873 return ret; 874} 875 876ECX_KEY *ossl_d2i_ED448_PUBKEY(ECX_KEY **a, 877 const unsigned char **pp, long length) 878{ 879 EVP_PKEY *pkey; 880 ECX_KEY *key = NULL; 881 const unsigned char *q; 882 883 q = *pp; 884 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 885 if (pkey == NULL) 886 return NULL; 887 if (EVP_PKEY_get_id(pkey) == EVP_PKEY_ED448) 888 key = ossl_evp_pkey_get1_ED448(pkey); 889 EVP_PKEY_free(pkey); 890 if (key == NULL) 891 return NULL; 892 *pp = q; 893 if (a != NULL) { 894 ossl_ecx_key_free(*a); 895 *a = key; 896 } 897 return key; 898} 899 900int ossl_i2d_ED448_PUBKEY(const ECX_KEY *a, unsigned char **pp) 901{ 902 EVP_PKEY *pktmp; 903 int ret; 904 905 if (a == NULL) 906 return 0; 907 if ((pktmp = EVP_PKEY_new()) == NULL) { 908 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 909 return -1; 910 } 911 (void)EVP_PKEY_assign(pktmp, EVP_PKEY_ED448, (ECX_KEY *)a); 912 ret = i2d_PUBKEY(pktmp, pp); 913 pktmp->pkey.ptr = NULL; 914 EVP_PKEY_free(pktmp); 915 return ret; 916} 917 918ECX_KEY *ossl_d2i_X25519_PUBKEY(ECX_KEY **a, 919 const unsigned char **pp, long length) 920{ 921 EVP_PKEY *pkey; 922 ECX_KEY *key = NULL; 923 const unsigned char *q; 924 925 q = *pp; 926 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 927 if (pkey == NULL) 928 return NULL; 929 if (EVP_PKEY_get_id(pkey) == EVP_PKEY_X25519) 930 key = ossl_evp_pkey_get1_X25519(pkey); 931 EVP_PKEY_free(pkey); 932 if (key == NULL) 933 return NULL; 934 *pp = q; 935 if (a != NULL) { 936 ossl_ecx_key_free(*a); 937 *a = key; 938 } 939 return key; 940} 941 942int ossl_i2d_X25519_PUBKEY(const ECX_KEY *a, unsigned char **pp) 943{ 944 EVP_PKEY *pktmp; 945 int ret; 946 947 if (a == NULL) 948 return 0; 949 if ((pktmp = EVP_PKEY_new()) == NULL) { 950 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 951 return -1; 952 } 953 (void)EVP_PKEY_assign(pktmp, EVP_PKEY_X25519, (ECX_KEY *)a); 954 ret = i2d_PUBKEY(pktmp, pp); 955 pktmp->pkey.ptr = NULL; 956 EVP_PKEY_free(pktmp); 957 return ret; 958} 959 960ECX_KEY *ossl_d2i_X448_PUBKEY(ECX_KEY **a, 961 const unsigned char **pp, long length) 962{ 963 EVP_PKEY *pkey; 964 ECX_KEY *key = NULL; 965 const unsigned char *q; 966 967 q = *pp; 968 pkey = ossl_d2i_PUBKEY_legacy(NULL, &q, length); 969 if (pkey == NULL) 970 return NULL; 971 if (EVP_PKEY_get_id(pkey) == EVP_PKEY_X448) 972 key = ossl_evp_pkey_get1_X448(pkey); 973 EVP_PKEY_free(pkey); 974 if (key == NULL) 975 return NULL; 976 *pp = q; 977 if (a != NULL) { 978 ossl_ecx_key_free(*a); 979 *a = key; 980 } 981 return key; 982} 983 984int ossl_i2d_X448_PUBKEY(const ECX_KEY *a, unsigned char **pp) 985{ 986 EVP_PKEY *pktmp; 987 int ret; 988 989 if (a == NULL) 990 return 0; 991 if ((pktmp = EVP_PKEY_new()) == NULL) { 992 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 993 return -1; 994 } 995 (void)EVP_PKEY_assign(pktmp, EVP_PKEY_X448, (ECX_KEY *)a); 996 ret = i2d_PUBKEY(pktmp, pp); 997 pktmp->pkey.ptr = NULL; 998 EVP_PKEY_free(pktmp); 999 return ret; 1000} 1001 1002#endif 1003 1004int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj, 1005 int ptype, void *pval, 1006 unsigned char *penc, int penclen) 1007{ 1008 if (!X509_ALGOR_set0(pub->algor, aobj, ptype, pval)) 1009 return 0; 1010 if (penc) { 1011 OPENSSL_free(pub->public_key->data); 1012 pub->public_key->data = penc; 1013 pub->public_key->length = penclen; 1014 /* Set number of unused bits to zero */ 1015 pub->public_key->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); 1016 pub->public_key->flags |= ASN1_STRING_FLAG_BITS_LEFT; 1017 } 1018 return 1; 1019} 1020 1021int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, 1022 const unsigned char **pk, int *ppklen, 1023 X509_ALGOR **pa, const X509_PUBKEY *pub) 1024{ 1025 if (ppkalg) 1026 *ppkalg = pub->algor->algorithm; 1027 if (pk) { 1028 *pk = pub->public_key->data; 1029 *ppklen = pub->public_key->length; 1030 } 1031 if (pa) 1032 *pa = pub->algor; 1033 return 1; 1034} 1035 1036ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x) 1037{ 1038 if (x == NULL) 1039 return NULL; 1040 return x->cert_info.key->public_key; 1041} 1042 1043/* Returns 1 for equal, 0, for non-equal, < 0 on error */ 1044int X509_PUBKEY_eq(const X509_PUBKEY *a, const X509_PUBKEY *b) 1045{ 1046 X509_ALGOR *algA, *algB; 1047 EVP_PKEY *pA, *pB; 1048 1049 if (a == b) 1050 return 1; 1051 if (a == NULL || b == NULL) 1052 return 0; 1053 if (!X509_PUBKEY_get0_param(NULL, NULL, NULL, &algA, a) || algA == NULL 1054 || !X509_PUBKEY_get0_param(NULL, NULL, NULL, &algB, b) || algB == NULL) 1055 return -2; 1056 if (X509_ALGOR_cmp(algA, algB) != 0) 1057 return 0; 1058 if ((pA = X509_PUBKEY_get0(a)) == NULL 1059 || (pB = X509_PUBKEY_get0(b)) == NULL) 1060 return -2; 1061 return EVP_PKEY_eq(pA, pB); 1062} 1063 1064int ossl_x509_PUBKEY_get0_libctx(OSSL_LIB_CTX **plibctx, const char **ppropq, 1065 const X509_PUBKEY *key) 1066{ 1067 if (plibctx) 1068 *plibctx = key->libctx; 1069 if (ppropq) 1070 *ppropq = key->propq; 1071 return 1; 1072} 1073