1 /* Written by Nils Larsch for the OpenSSL project. */ 2 /* ==================================================================== 3 * Copyright (c) 2000-2003 The OpenSSL Project. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the 15 * distribution. 16 * 17 * 3. All advertising materials mentioning features or use of this 18 * software must display the following acknowledgment: 19 * "This product includes software developed by the OpenSSL Project 20 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 21 * 22 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 23 * endorse or promote products derived from this software without 24 * prior written permission. For written permission, please contact 25 * licensing (at) OpenSSL.org. 26 * 27 * 5. Products derived from this software may not be called "OpenSSL" 28 * nor may "OpenSSL" appear in their names without prior written 29 * permission of the OpenSSL Project. 30 * 31 * 6. Redistributions of any form whatsoever must retain the following 32 * acknowledgment: 33 * "This product includes software developed by the OpenSSL Project 34 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 35 * 36 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 37 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 38 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 39 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 40 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 41 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 42 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 43 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 44 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 45 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 46 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 47 * OF THE POSSIBILITY OF SUCH DAMAGE. 48 * ==================================================================== 49 * 50 * This product includes cryptographic software written by Eric Young 51 * (eay (at) cryptsoft.com). This product includes software written by Tim 52 * Hudson (tjh (at) cryptsoft.com). */ 53 54 #include <openssl/ec.h> 55 56 #include <string.h> 57 58 #include <openssl/asn1.h> 59 #include <openssl/asn1t.h> 60 #include <openssl/bn.h> 61 #include <openssl/err.h> 62 #include <openssl/mem.h> 63 #include <openssl/obj.h> 64 65 #include "internal.h" 66 67 68 typedef struct x9_62_fieldid_st { 69 ASN1_OBJECT *fieldType; 70 union { 71 char *ptr; 72 /* NID_X9_62_prime_field */ 73 ASN1_INTEGER *prime; 74 /* anything else */ 75 ASN1_TYPE *other; 76 } p; 77 } X9_62_FIELDID; 78 79 ASN1_ADB_TEMPLATE(fieldID_def) = ASN1_SIMPLE(X9_62_FIELDID, p.other, ASN1_ANY); 80 81 ASN1_ADB(X9_62_FIELDID) = { 82 ADB_ENTRY(NID_X9_62_prime_field, ASN1_SIMPLE(X9_62_FIELDID, p.prime, ASN1_INTEGER)), 83 } ASN1_ADB_END(X9_62_FIELDID, 0, fieldType, 0, &fieldID_def_tt, NULL); 84 85 ASN1_SEQUENCE(X9_62_FIELDID) = { 86 ASN1_SIMPLE(X9_62_FIELDID, fieldType, ASN1_OBJECT), 87 ASN1_ADB_OBJECT(X9_62_FIELDID) 88 } ASN1_SEQUENCE_END(X9_62_FIELDID); 89 90 typedef struct x9_62_curve_st { 91 ASN1_OCTET_STRING *a; 92 ASN1_OCTET_STRING *b; 93 ASN1_BIT_STRING *seed; 94 } X9_62_CURVE; 95 96 ASN1_SEQUENCE(X9_62_CURVE) = { 97 ASN1_SIMPLE(X9_62_CURVE, a, ASN1_OCTET_STRING), 98 ASN1_SIMPLE(X9_62_CURVE, b, ASN1_OCTET_STRING), 99 ASN1_OPT(X9_62_CURVE, seed, ASN1_BIT_STRING) 100 } ASN1_SEQUENCE_END(X9_62_CURVE); 101 102 typedef struct ec_parameters_st { 103 long version; 104 X9_62_FIELDID *fieldID; 105 X9_62_CURVE *curve; 106 ASN1_OCTET_STRING *base; 107 ASN1_INTEGER *order; 108 ASN1_INTEGER *cofactor; 109 } ECPARAMETERS; 110 111 DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS); 112 113 ASN1_SEQUENCE(ECPARAMETERS) = { 114 ASN1_SIMPLE(ECPARAMETERS, version, LONG), 115 ASN1_SIMPLE(ECPARAMETERS, fieldID, X9_62_FIELDID), 116 ASN1_SIMPLE(ECPARAMETERS, curve, X9_62_CURVE), 117 ASN1_SIMPLE(ECPARAMETERS, base, ASN1_OCTET_STRING), 118 ASN1_SIMPLE(ECPARAMETERS, order, ASN1_INTEGER), 119 ASN1_OPT(ECPARAMETERS, cofactor, ASN1_INTEGER) 120 } ASN1_SEQUENCE_END(ECPARAMETERS); 121 122 IMPLEMENT_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS); 123 124 typedef struct ecpk_parameters_st { 125 int type; 126 union { 127 ASN1_OBJECT *named_curve; 128 ECPARAMETERS *parameters; 129 } value; 130 } ECPKPARAMETERS; 131 132 /* SEC1 ECPrivateKey */ 133 typedef struct ec_privatekey_st { 134 long version; 135 ASN1_OCTET_STRING *privateKey; 136 ECPKPARAMETERS *parameters; 137 ASN1_BIT_STRING *publicKey; 138 } EC_PRIVATEKEY; 139 140 DECLARE_ASN1_FUNCTIONS_const(ECPKPARAMETERS); 141 DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPKPARAMETERS, ECPKPARAMETERS); 142 143 ASN1_CHOICE(ECPKPARAMETERS) = { 144 ASN1_SIMPLE(ECPKPARAMETERS, value.named_curve, ASN1_OBJECT), 145 ASN1_SIMPLE(ECPKPARAMETERS, value.parameters, ECPARAMETERS), 146 } ASN1_CHOICE_END(ECPKPARAMETERS); 147 148 IMPLEMENT_ASN1_FUNCTIONS_const(ECPKPARAMETERS); 149 150 DECLARE_ASN1_FUNCTIONS_const(EC_PRIVATEKEY); 151 DECLARE_ASN1_ENCODE_FUNCTIONS_const(EC_PRIVATEKEY, EC_PRIVATEKEY); 152 153 ASN1_SEQUENCE(EC_PRIVATEKEY) = { 154 ASN1_SIMPLE(EC_PRIVATEKEY, version, LONG), 155 ASN1_SIMPLE(EC_PRIVATEKEY, privateKey, ASN1_OCTET_STRING), 156 ASN1_EXP_OPT(EC_PRIVATEKEY, parameters, ECPKPARAMETERS, 0), 157 ASN1_EXP_OPT(EC_PRIVATEKEY, publicKey, ASN1_BIT_STRING, 1), 158 } ASN1_SEQUENCE_END(EC_PRIVATEKEY); 159 160 IMPLEMENT_ASN1_FUNCTIONS_const(EC_PRIVATEKEY); 161 162 163 ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *group, 164 ECPKPARAMETERS *params) { 165 int ok = 0, nid; 166 ECPKPARAMETERS *ret = params; 167 168 if (ret == NULL) { 169 ret = ECPKPARAMETERS_new(); 170 if (ret == NULL) { 171 OPENSSL_PUT_ERROR(EC, ec_asn1_group2pkparameters, ERR_R_MALLOC_FAILURE); 172 return NULL; 173 } 174 } else { 175 ASN1_OBJECT_free(ret->value.named_curve); 176 } 177 178 /* use the ASN.1 OID to describe the the elliptic curve parameters. */ 179 nid = EC_GROUP_get_curve_name(group); 180 if (nid) { 181 ret->type = 0; 182 ret->value.named_curve = (ASN1_OBJECT*) OBJ_nid2obj(nid); 183 ok = ret->value.named_curve != NULL; 184 } 185 186 if (!ok) { 187 ECPKPARAMETERS_free(ret); 188 return NULL; 189 } 190 191 return ret; 192 } 193 194 EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *params) { 195 EC_GROUP *ret = NULL; 196 int nid = NID_undef; 197 198 if (params == NULL) { 199 OPENSSL_PUT_ERROR(EC, ec_asn1_pkparameters2group, EC_R_MISSING_PARAMETERS); 200 return NULL; 201 } 202 203 if (params->type == 0) { 204 nid = OBJ_obj2nid(params->value.named_curve); 205 } else if (params->type == 1) { 206 /* We don't support arbitary curves so we attempt to recognise it from the 207 * group order. */ 208 const ECPARAMETERS *ecparams = params->value.parameters; 209 unsigned i; 210 const struct built_in_curve *curve; 211 212 for (i = 0; OPENSSL_built_in_curves[i].nid != NID_undef; i++) { 213 curve = &OPENSSL_built_in_curves[i]; 214 const unsigned param_len = curve->data->param_len; 215 if (ecparams->order->length == param_len && 216 memcmp(ecparams->order->data, &curve->data->data[param_len * 5], 217 param_len) == 0) { 218 nid = curve->nid; 219 break; 220 } 221 } 222 } 223 224 if (nid == NID_undef) { 225 OPENSSL_PUT_ERROR(EC, ec_asn1_pkparameters2group, EC_R_NON_NAMED_CURVE); 226 return NULL; 227 } 228 229 ret = EC_GROUP_new_by_curve_name(nid); 230 if (ret == NULL) { 231 OPENSSL_PUT_ERROR(EC, ec_asn1_pkparameters2group, 232 EC_R_EC_GROUP_NEW_BY_NAME_FAILURE); 233 return NULL; 234 } 235 236 return ret; 237 } 238 239 static EC_GROUP *d2i_ECPKParameters(EC_GROUP **groupp, const uint8_t **inp, 240 long len) { 241 EC_GROUP *group = NULL; 242 ECPKPARAMETERS *params = NULL; 243 244 params = d2i_ECPKPARAMETERS(NULL, inp, len); 245 if (params == NULL) { 246 OPENSSL_PUT_ERROR(EC, d2i_ECPKParameters, EC_R_D2I_ECPKPARAMETERS_FAILURE); 247 ECPKPARAMETERS_free(params); 248 return NULL; 249 } 250 251 group = ec_asn1_pkparameters2group(params); 252 if (group == NULL) { 253 OPENSSL_PUT_ERROR(EC, d2i_ECPKParameters, EC_R_PKPARAMETERS2GROUP_FAILURE); 254 ECPKPARAMETERS_free(params); 255 return NULL; 256 } 257 258 if (groupp) { 259 EC_GROUP_free(*groupp); 260 *groupp = group; 261 } 262 263 ECPKPARAMETERS_free(params); 264 return group; 265 } 266 267 static int i2d_ECPKParameters(const EC_GROUP *group, uint8_t **outp) { 268 int ret = 0; 269 ECPKPARAMETERS *tmp = ec_asn1_group2pkparameters(group, NULL); 270 if (tmp == NULL) { 271 OPENSSL_PUT_ERROR(EC, i2d_ECPKParameters, EC_R_GROUP2PKPARAMETERS_FAILURE); 272 return 0; 273 } 274 ret = i2d_ECPKPARAMETERS(tmp, outp); 275 if (ret == 0) { 276 OPENSSL_PUT_ERROR(EC, i2d_ECPKParameters, EC_R_I2D_ECPKPARAMETERS_FAILURE); 277 ECPKPARAMETERS_free(tmp); 278 return 0; 279 } 280 ECPKPARAMETERS_free(tmp); 281 return ret; 282 } 283 284 EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const uint8_t **in, long len) { 285 int ok = 0; 286 EC_KEY *ret = NULL; 287 EC_PRIVATEKEY *priv_key = NULL; 288 289 priv_key = d2i_EC_PRIVATEKEY(NULL, in, len); 290 if (priv_key == NULL) { 291 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, ERR_R_EC_LIB); 292 return NULL; 293 } 294 295 if (a == NULL || *a == NULL) { 296 ret = EC_KEY_new(); 297 if (ret == NULL) { 298 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, ERR_R_MALLOC_FAILURE); 299 goto err; 300 } 301 } else { 302 ret = *a; 303 } 304 305 if (priv_key->parameters) { 306 EC_GROUP_free(ret->group); 307 ret->group = ec_asn1_pkparameters2group(priv_key->parameters); 308 } 309 310 if (ret->group == NULL) { 311 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, ERR_R_EC_LIB); 312 goto err; 313 } 314 315 ret->version = priv_key->version; 316 317 if (priv_key->privateKey) { 318 ret->priv_key = 319 BN_bin2bn(M_ASN1_STRING_data(priv_key->privateKey), 320 M_ASN1_STRING_length(priv_key->privateKey), ret->priv_key); 321 if (ret->priv_key == NULL) { 322 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, ERR_R_BN_LIB); 323 goto err; 324 } 325 } else { 326 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, EC_R_MISSING_PRIVATE_KEY); 327 goto err; 328 } 329 330 EC_POINT_free(ret->pub_key); 331 ret->pub_key = EC_POINT_new(ret->group); 332 if (ret->pub_key == NULL) { 333 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, ERR_R_EC_LIB); 334 goto err; 335 } 336 337 if (priv_key->publicKey) { 338 const uint8_t *pub_oct; 339 int pub_oct_len; 340 341 pub_oct = M_ASN1_STRING_data(priv_key->publicKey); 342 pub_oct_len = M_ASN1_STRING_length(priv_key->publicKey); 343 /* The first byte (the point conversion form) must be present. */ 344 if (pub_oct_len <= 0) { 345 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, EC_R_BUFFER_TOO_SMALL); 346 goto err; 347 } 348 /* Save the point conversion form. */ 349 ret->conv_form = (point_conversion_form_t)(pub_oct[0] & ~0x01); 350 if (!EC_POINT_oct2point(ret->group, ret->pub_key, pub_oct, pub_oct_len, 351 NULL)) { 352 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, ERR_R_EC_LIB); 353 goto err; 354 } 355 } else { 356 if (!EC_POINT_mul(ret->group, ret->pub_key, ret->priv_key, NULL, NULL, 357 NULL)) { 358 OPENSSL_PUT_ERROR(EC, d2i_ECPrivateKey, ERR_R_EC_LIB); 359 goto err; 360 } 361 /* Remember the original private-key-only encoding. */ 362 ret->enc_flag |= EC_PKEY_NO_PUBKEY; 363 } 364 365 if (a) { 366 *a = ret; 367 } 368 ok = 1; 369 370 err: 371 if (!ok) { 372 if (a == NULL || *a != ret) { 373 EC_KEY_free(ret); 374 } 375 ret = NULL; 376 } 377 378 EC_PRIVATEKEY_free(priv_key); 379 380 return ret; 381 } 382 383 int i2d_ECPrivateKey(const EC_KEY *key, uint8_t **outp) { 384 int ret = 0, ok = 0; 385 uint8_t *buffer = NULL; 386 size_t buf_len = 0, tmp_len; 387 EC_PRIVATEKEY *priv_key = NULL; 388 389 if (key == NULL || key->group == NULL || key->priv_key == NULL) { 390 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_PASSED_NULL_PARAMETER); 391 goto err; 392 } 393 394 priv_key = EC_PRIVATEKEY_new(); 395 if (priv_key == NULL) { 396 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_MALLOC_FAILURE); 397 goto err; 398 } 399 400 priv_key->version = key->version; 401 402 buf_len = BN_num_bytes(&key->group->order); 403 buffer = OPENSSL_malloc(buf_len); 404 if (buffer == NULL) { 405 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_MALLOC_FAILURE); 406 goto err; 407 } 408 409 if (!BN_bn2bin_padded(buffer, buf_len, key->priv_key)) { 410 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_BN_LIB); 411 goto err; 412 } 413 414 if (!M_ASN1_OCTET_STRING_set(priv_key->privateKey, buffer, buf_len)) { 415 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_ASN1_LIB); 416 goto err; 417 } 418 419 /* TODO(fork): replace this flexibility with key sensible default? */ 420 if (!(key->enc_flag & EC_PKEY_NO_PARAMETERS)) { 421 if ((priv_key->parameters = ec_asn1_group2pkparameters( 422 key->group, priv_key->parameters)) == NULL) { 423 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_EC_LIB); 424 goto err; 425 } 426 } 427 428 /* TODO(fork): replace this flexibility with key sensible default? */ 429 if (!(key->enc_flag & EC_PKEY_NO_PUBKEY) && key->pub_key != NULL) { 430 priv_key->publicKey = M_ASN1_BIT_STRING_new(); 431 if (priv_key->publicKey == NULL) { 432 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_MALLOC_FAILURE); 433 goto err; 434 } 435 436 tmp_len = EC_POINT_point2oct(key->group, key->pub_key, key->conv_form, NULL, 437 0, NULL); 438 439 if (tmp_len > buf_len) { 440 uint8_t *tmp_buffer = OPENSSL_realloc(buffer, tmp_len); 441 if (!tmp_buffer) { 442 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_MALLOC_FAILURE); 443 goto err; 444 } 445 buffer = tmp_buffer; 446 buf_len = tmp_len; 447 } 448 449 if (!EC_POINT_point2oct(key->group, key->pub_key, key->conv_form, buffer, 450 buf_len, NULL)) { 451 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_EC_LIB); 452 goto err; 453 } 454 455 priv_key->publicKey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); 456 priv_key->publicKey->flags |= ASN1_STRING_FLAG_BITS_LEFT; 457 if (!M_ASN1_BIT_STRING_set(priv_key->publicKey, buffer, buf_len)) { 458 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_ASN1_LIB); 459 goto err; 460 } 461 } 462 463 ret = i2d_EC_PRIVATEKEY(priv_key, outp); 464 if (ret == 0) { 465 OPENSSL_PUT_ERROR(EC, i2d_ECPrivateKey, ERR_R_EC_LIB); 466 goto err; 467 } 468 ok = 1; 469 470 err: 471 OPENSSL_free(buffer); 472 EC_PRIVATEKEY_free(priv_key); 473 return (ok ? ret : 0); 474 } 475 476 int i2d_ECParameters(const EC_KEY *key, uint8_t **outp) { 477 if (key == NULL) { 478 OPENSSL_PUT_ERROR(EC, i2d_ECParameters, ERR_R_PASSED_NULL_PARAMETER); 479 return 0; 480 } 481 return i2d_ECPKParameters(key->group, outp); 482 } 483 484 EC_KEY *d2i_ECParameters(EC_KEY **key, const uint8_t **inp, long len) { 485 EC_KEY *ret; 486 487 if (inp == NULL || *inp == NULL) { 488 OPENSSL_PUT_ERROR(EC, d2i_ECParameters, ERR_R_PASSED_NULL_PARAMETER); 489 return NULL; 490 } 491 492 if (key == NULL || *key == NULL) { 493 ret = EC_KEY_new(); 494 if (ret == NULL) { 495 OPENSSL_PUT_ERROR(EC, d2i_ECParameters, ERR_R_MALLOC_FAILURE); 496 return NULL; 497 } 498 } else { 499 ret = *key; 500 } 501 502 if (!d2i_ECPKParameters(&ret->group, inp, len)) { 503 OPENSSL_PUT_ERROR(EC, d2i_ECParameters, ERR_R_EC_LIB); 504 if (key == NULL || *key == NULL) { 505 EC_KEY_free(ret); 506 } 507 return NULL; 508 } 509 510 if (key) { 511 *key = ret; 512 } 513 return ret; 514 } 515 516 EC_KEY *o2i_ECPublicKey(EC_KEY **keyp, const uint8_t **inp, long len) { 517 EC_KEY *ret = NULL; 518 519 if (keyp == NULL || *keyp == NULL || (*keyp)->group == NULL) { 520 OPENSSL_PUT_ERROR(EC, o2i_ECPublicKey, ERR_R_PASSED_NULL_PARAMETER); 521 return 0; 522 } 523 ret = *keyp; 524 if (ret->pub_key == NULL && 525 (ret->pub_key = EC_POINT_new(ret->group)) == NULL) { 526 OPENSSL_PUT_ERROR(EC, o2i_ECPublicKey, ERR_R_MALLOC_FAILURE); 527 return 0; 528 } 529 if (!EC_POINT_oct2point(ret->group, ret->pub_key, *inp, len, NULL)) { 530 OPENSSL_PUT_ERROR(EC, o2i_ECPublicKey, ERR_R_EC_LIB); 531 return 0; 532 } 533 /* save the point conversion form */ 534 ret->conv_form = (point_conversion_form_t)(*inp[0] & ~0x01); 535 *inp += len; 536 return ret; 537 } 538 539 int i2o_ECPublicKey(const EC_KEY *key, uint8_t **outp) { 540 size_t buf_len = 0; 541 int new_buffer = 0; 542 543 if (key == NULL) { 544 OPENSSL_PUT_ERROR(EC, i2o_ECPublicKey, ERR_R_PASSED_NULL_PARAMETER); 545 return 0; 546 } 547 548 buf_len = EC_POINT_point2oct(key->group, key->pub_key, key->conv_form, NULL, 549 0, NULL); 550 551 if (outp == NULL || buf_len == 0) { 552 /* out == NULL => just return the length of the octet string */ 553 return buf_len; 554 } 555 556 if (*outp == NULL) { 557 *outp = OPENSSL_malloc(buf_len); 558 if (*outp == NULL) { 559 OPENSSL_PUT_ERROR(EC, i2o_ECPublicKey, ERR_R_MALLOC_FAILURE); 560 return 0; 561 } 562 new_buffer = 1; 563 } 564 if (!EC_POINT_point2oct(key->group, key->pub_key, key->conv_form, *outp, 565 buf_len, NULL)) { 566 OPENSSL_PUT_ERROR(EC, i2o_ECPublicKey, ERR_R_EC_LIB); 567 if (new_buffer) { 568 OPENSSL_free(*outp); 569 *outp = NULL; 570 } 571 return 0; 572 } 573 574 if (!new_buffer) { 575 *outp += buf_len; 576 } 577 return buf_len; 578 } 579
