summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/ec
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/ec')
-rw-r--r--src/lib/libcrypto/ec/ec_ameth.c12
-rw-r--r--src/lib/libcrypto/ec/ec_asn1.c26
-rw-r--r--src/lib/libcrypto/ec/ec_key.c4
-rw-r--r--src/lib/libcrypto/ec/ec_lib.c40
-rw-r--r--src/lib/libcrypto/ec/ec_mult.c50
-rw-r--r--src/lib/libcrypto/ec/ec_pmeth.c4
-rw-r--r--src/lib/libcrypto/ec/ec_print.c28
-rw-r--r--src/lib/libcrypto/ec/eck_prn.c4
-rw-r--r--src/lib/libcrypto/ec/ecp_nistp224.c18
-rw-r--r--src/lib/libcrypto/ec/ecp_nistp256.c18
-rw-r--r--src/lib/libcrypto/ec/ecp_nistp521.c18
-rw-r--r--src/lib/libcrypto/ec/ecp_smpl.c4
12 files changed, 113 insertions, 113 deletions
diff --git a/src/lib/libcrypto/ec/ec_ameth.c b/src/lib/libcrypto/ec/ec_ameth.c
index 0ce4524076..6331903141 100644
--- a/src/lib/libcrypto/ec/ec_ameth.c
+++ b/src/lib/libcrypto/ec/ec_ameth.c
@@ -116,7 +116,7 @@ static int eckey_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
116 penclen = i2o_ECPublicKey(ec_key, NULL); 116 penclen = i2o_ECPublicKey(ec_key, NULL);
117 if (penclen <= 0) 117 if (penclen <= 0)
118 goto err; 118 goto err;
119 penc = OPENSSL_malloc(penclen); 119 penc = malloc(penclen);
120 if (!penc) 120 if (!penc)
121 goto err; 121 goto err;
122 p = penc; 122 p = penc;
@@ -132,7 +132,7 @@ static int eckey_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
132 else 132 else
133 ASN1_STRING_free(pval); 133 ASN1_STRING_free(pval);
134 if (penc) 134 if (penc)
135 OPENSSL_free(penc); 135 free(penc);
136 return 0; 136 return 0;
137 } 137 }
138 138
@@ -339,7 +339,7 @@ static int eckey_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
339 ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB); 339 ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB);
340 return 0; 340 return 0;
341 } 341 }
342 ep = (unsigned char *) OPENSSL_malloc(eplen); 342 ep = (unsigned char *) malloc(eplen);
343 if (!ep) 343 if (!ep)
344 { 344 {
345 EC_KEY_set_enc_flags(ec_key, old_flags); 345 EC_KEY_set_enc_flags(ec_key, old_flags);
@@ -350,7 +350,7 @@ static int eckey_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
350 if (!i2d_ECPrivateKey(ec_key, &p)) 350 if (!i2d_ECPrivateKey(ec_key, &p))
351 { 351 {
352 EC_KEY_set_enc_flags(ec_key, old_flags); 352 EC_KEY_set_enc_flags(ec_key, old_flags);
353 OPENSSL_free(ep); 353 free(ep);
354 ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB); 354 ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB);
355 } 355 }
356 /* restore old encoding flags */ 356 /* restore old encoding flags */
@@ -474,7 +474,7 @@ static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, int ktype)
474 if (ktype > 0) 474 if (ktype > 0)
475 { 475 {
476 buf_len += 10; 476 buf_len += 10;
477 if ((buffer = OPENSSL_malloc(buf_len)) == NULL) 477 if ((buffer = malloc(buf_len)) == NULL)
478 { 478 {
479 reason = ERR_R_MALLOC_FAILURE; 479 reason = ERR_R_MALLOC_FAILURE;
480 goto err; 480 goto err;
@@ -515,7 +515,7 @@ err:
515 if (ctx) 515 if (ctx)
516 BN_CTX_free(ctx); 516 BN_CTX_free(ctx);
517 if (buffer != NULL) 517 if (buffer != NULL)
518 OPENSSL_free(buffer); 518 free(buffer);
519 return(ret); 519 return(ret);
520 } 520 }
521 521
diff --git a/src/lib/libcrypto/ec/ec_asn1.c b/src/lib/libcrypto/ec/ec_asn1.c
index 145807b611..2bde9a6a3c 100644
--- a/src/lib/libcrypto/ec/ec_asn1.c
+++ b/src/lib/libcrypto/ec/ec_asn1.c
@@ -485,7 +485,7 @@ static int ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
485 } 485 }
486 else 486 else
487 { 487 {
488 if ((buffer_1 = OPENSSL_malloc(len_1)) == NULL) 488 if ((buffer_1 = malloc(len_1)) == NULL)
489 { 489 {
490 ECerr(EC_F_EC_ASN1_GROUP2CURVE, 490 ECerr(EC_F_EC_ASN1_GROUP2CURVE,
491 ERR_R_MALLOC_FAILURE); 491 ERR_R_MALLOC_FAILURE);
@@ -507,7 +507,7 @@ static int ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
507 } 507 }
508 else 508 else
509 { 509 {
510 if ((buffer_2 = OPENSSL_malloc(len_2)) == NULL) 510 if ((buffer_2 = malloc(len_2)) == NULL)
511 { 511 {
512 ECerr(EC_F_EC_ASN1_GROUP2CURVE, 512 ECerr(EC_F_EC_ASN1_GROUP2CURVE,
513 ERR_R_MALLOC_FAILURE); 513 ERR_R_MALLOC_FAILURE);
@@ -559,9 +559,9 @@ static int ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
559 ok = 1; 559 ok = 1;
560 560
561err: if (buffer_1) 561err: if (buffer_1)
562 OPENSSL_free(buffer_1); 562 free(buffer_1);
563 if (buffer_2) 563 if (buffer_2)
564 OPENSSL_free(buffer_2); 564 free(buffer_2);
565 if (tmp_1) 565 if (tmp_1)
566 BN_free(tmp_1); 566 BN_free(tmp_1);
567 if (tmp_2) 567 if (tmp_2)
@@ -630,7 +630,7 @@ static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group,
630 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB); 630 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
631 goto err; 631 goto err;
632 } 632 }
633 if ((buffer = OPENSSL_malloc(len)) == NULL) 633 if ((buffer = malloc(len)) == NULL)
634 { 634 {
635 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE); 635 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
636 goto err; 636 goto err;
@@ -686,7 +686,7 @@ err : if(!ok)
686 if (tmp) 686 if (tmp)
687 BN_free(tmp); 687 BN_free(tmp);
688 if (buffer) 688 if (buffer)
689 OPENSSL_free(buffer); 689 free(buffer);
690 return(ret); 690 return(ret);
691 } 691 }
692 692
@@ -925,8 +925,8 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
925 if (params->curve->seed != NULL) 925 if (params->curve->seed != NULL)
926 { 926 {
927 if (ret->seed != NULL) 927 if (ret->seed != NULL)
928 OPENSSL_free(ret->seed); 928 free(ret->seed);
929 if (!(ret->seed = OPENSSL_malloc(params->curve->seed->length))) 929 if (!(ret->seed = malloc(params->curve->seed->length)))
930 { 930 {
931 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, 931 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
932 ERR_R_MALLOC_FAILURE); 932 ERR_R_MALLOC_FAILURE);
@@ -1247,7 +1247,7 @@ int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
1247 priv_key->version = a->version; 1247 priv_key->version = a->version;
1248 1248
1249 buf_len = (size_t)BN_num_bytes(a->priv_key); 1249 buf_len = (size_t)BN_num_bytes(a->priv_key);
1250 buffer = OPENSSL_malloc(buf_len); 1250 buffer = malloc(buf_len);
1251 if (buffer == NULL) 1251 if (buffer == NULL)
1252 { 1252 {
1253 ECerr(EC_F_I2D_ECPRIVATEKEY, 1253 ECerr(EC_F_I2D_ECPRIVATEKEY,
@@ -1292,7 +1292,7 @@ int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
1292 1292
1293 if (tmp_len > buf_len) 1293 if (tmp_len > buf_len)
1294 { 1294 {
1295 unsigned char *tmp_buffer = OPENSSL_realloc(buffer, tmp_len); 1295 unsigned char *tmp_buffer = realloc(buffer, tmp_len);
1296 if (!tmp_buffer) 1296 if (!tmp_buffer)
1297 { 1297 {
1298 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE); 1298 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
@@ -1327,7 +1327,7 @@ int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
1327 ok=1; 1327 ok=1;
1328err: 1328err:
1329 if (buffer) 1329 if (buffer)
1330 OPENSSL_free(buffer); 1330 free(buffer);
1331 if (priv_key) 1331 if (priv_key)
1332 EC_PRIVATEKEY_free(priv_key); 1332 EC_PRIVATEKEY_free(priv_key);
1333 return(ok?ret:0); 1333 return(ok?ret:0);
@@ -1424,7 +1424,7 @@ int i2o_ECPublicKey(EC_KEY *a, unsigned char **out)
1424 1424
1425 if (*out == NULL) 1425 if (*out == NULL)
1426 { 1426 {
1427 if ((*out = OPENSSL_malloc(buf_len)) == NULL) 1427 if ((*out = malloc(buf_len)) == NULL)
1428 { 1428 {
1429 ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_MALLOC_FAILURE); 1429 ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
1430 return 0; 1430 return 0;
@@ -1435,7 +1435,7 @@ int i2o_ECPublicKey(EC_KEY *a, unsigned char **out)
1435 *out, buf_len, NULL)) 1435 *out, buf_len, NULL))
1436 { 1436 {
1437 ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_EC_LIB); 1437 ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_EC_LIB);
1438 OPENSSL_free(*out); 1438 free(*out);
1439 *out = NULL; 1439 *out = NULL;
1440 return 0; 1440 return 0;
1441 } 1441 }
diff --git a/src/lib/libcrypto/ec/ec_key.c b/src/lib/libcrypto/ec/ec_key.c
index d528601036..4375514ef5 100644
--- a/src/lib/libcrypto/ec/ec_key.c
+++ b/src/lib/libcrypto/ec/ec_key.c
@@ -69,7 +69,7 @@ EC_KEY *EC_KEY_new(void)
69 { 69 {
70 EC_KEY *ret; 70 EC_KEY *ret;
71 71
72 ret=(EC_KEY *)OPENSSL_malloc(sizeof(EC_KEY)); 72 ret=(EC_KEY *)malloc(sizeof(EC_KEY));
73 if (ret == NULL) 73 if (ret == NULL)
74 { 74 {
75 ECerr(EC_F_EC_KEY_NEW, ERR_R_MALLOC_FAILURE); 75 ECerr(EC_F_EC_KEY_NEW, ERR_R_MALLOC_FAILURE);
@@ -132,7 +132,7 @@ void EC_KEY_free(EC_KEY *r)
132 132
133 OPENSSL_cleanse((void *)r, sizeof(EC_KEY)); 133 OPENSSL_cleanse((void *)r, sizeof(EC_KEY));
134 134
135 OPENSSL_free(r); 135 free(r);
136 } 136 }
137 137
138EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src) 138EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
diff --git a/src/lib/libcrypto/ec/ec_lib.c b/src/lib/libcrypto/ec/ec_lib.c
index e2c4741b5b..546fd08e38 100644
--- a/src/lib/libcrypto/ec/ec_lib.c
+++ b/src/lib/libcrypto/ec/ec_lib.c
@@ -88,7 +88,7 @@ EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
88 return NULL; 88 return NULL;
89 } 89 }
90 90
91 ret = OPENSSL_malloc(sizeof *ret); 91 ret = malloc(sizeof *ret);
92 if (ret == NULL) 92 if (ret == NULL)
93 { 93 {
94 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE); 94 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
@@ -112,7 +112,7 @@ EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
112 112
113 if (!meth->group_init(ret)) 113 if (!meth->group_init(ret))
114 { 114 {
115 OPENSSL_free(ret); 115 free(ret);
116 return NULL; 116 return NULL;
117 } 117 }
118 118
@@ -135,9 +135,9 @@ void EC_GROUP_free(EC_GROUP *group)
135 BN_free(&group->cofactor); 135 BN_free(&group->cofactor);
136 136
137 if (group->seed) 137 if (group->seed)
138 OPENSSL_free(group->seed); 138 free(group->seed);
139 139
140 OPENSSL_free(group); 140 free(group);
141 } 141 }
142 142
143 143
@@ -160,11 +160,11 @@ void EC_GROUP_clear_free(EC_GROUP *group)
160 if (group->seed) 160 if (group->seed)
161 { 161 {
162 OPENSSL_cleanse(group->seed, group->seed_len); 162 OPENSSL_cleanse(group->seed, group->seed_len);
163 OPENSSL_free(group->seed); 163 free(group->seed);
164 } 164 }
165 165
166 OPENSSL_cleanse(group, sizeof *group); 166 OPENSSL_cleanse(group, sizeof *group);
167 OPENSSL_free(group); 167 free(group);
168 } 168 }
169 169
170 170
@@ -226,8 +226,8 @@ int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
226 if (src->seed) 226 if (src->seed)
227 { 227 {
228 if (dest->seed) 228 if (dest->seed)
229 OPENSSL_free(dest->seed); 229 free(dest->seed);
230 dest->seed = OPENSSL_malloc(src->seed_len); 230 dest->seed = malloc(src->seed_len);
231 if (dest->seed == NULL) 231 if (dest->seed == NULL)
232 return 0; 232 return 0;
233 if (!memcpy(dest->seed, src->seed, src->seed_len)) 233 if (!memcpy(dest->seed, src->seed, src->seed_len))
@@ -237,7 +237,7 @@ int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
237 else 237 else
238 { 238 {
239 if (dest->seed) 239 if (dest->seed)
240 OPENSSL_free(dest->seed); 240 free(dest->seed);
241 dest->seed = NULL; 241 dest->seed = NULL;
242 dest->seed_len = 0; 242 dest->seed_len = 0;
243 } 243 }
@@ -375,7 +375,7 @@ size_t EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
375 { 375 {
376 if (group->seed) 376 if (group->seed)
377 { 377 {
378 OPENSSL_free(group->seed); 378 free(group->seed);
379 group->seed = NULL; 379 group->seed = NULL;
380 group->seed_len = 0; 380 group->seed_len = 0;
381 } 381 }
@@ -383,7 +383,7 @@ size_t EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
383 if (!len || !p) 383 if (!len || !p)
384 return 1; 384 return 1;
385 385
386 if ((group->seed = OPENSSL_malloc(len)) == NULL) 386 if ((group->seed = malloc(len)) == NULL)
387 return 0; 387 return 0;
388 memcpy(group->seed, p, len); 388 memcpy(group->seed, p, len);
389 group->seed_len = len; 389 group->seed_len = len;
@@ -567,7 +567,7 @@ int EC_EX_DATA_set_data(EC_EXTRA_DATA **ex_data, void *data,
567 /* no explicit entry needed */ 567 /* no explicit entry needed */
568 return 1; 568 return 1;
569 569
570 d = OPENSSL_malloc(sizeof *d); 570 d = malloc(sizeof *d);
571 if (d == NULL) 571 if (d == NULL)
572 return 0; 572 return 0;
573 573
@@ -613,7 +613,7 @@ void EC_EX_DATA_free_data(EC_EXTRA_DATA **ex_data,
613 EC_EXTRA_DATA *next = (*p)->next; 613 EC_EXTRA_DATA *next = (*p)->next;
614 614
615 (*p)->free_func((*p)->data); 615 (*p)->free_func((*p)->data);
616 OPENSSL_free(*p); 616 free(*p);
617 617
618 *p = next; 618 *p = next;
619 return; 619 return;
@@ -637,7 +637,7 @@ void EC_EX_DATA_clear_free_data(EC_EXTRA_DATA **ex_data,
637 EC_EXTRA_DATA *next = (*p)->next; 637 EC_EXTRA_DATA *next = (*p)->next;
638 638
639 (*p)->clear_free_func((*p)->data); 639 (*p)->clear_free_func((*p)->data);
640 OPENSSL_free(*p); 640 free(*p);
641 641
642 *p = next; 642 *p = next;
643 return; 643 return;
@@ -659,7 +659,7 @@ void EC_EX_DATA_free_all_data(EC_EXTRA_DATA **ex_data)
659 EC_EXTRA_DATA *next = d->next; 659 EC_EXTRA_DATA *next = d->next;
660 660
661 d->free_func(d->data); 661 d->free_func(d->data);
662 OPENSSL_free(d); 662 free(d);
663 663
664 d = next; 664 d = next;
665 } 665 }
@@ -680,7 +680,7 @@ void EC_EX_DATA_clear_free_all_data(EC_EXTRA_DATA **ex_data)
680 EC_EXTRA_DATA *next = d->next; 680 EC_EXTRA_DATA *next = d->next;
681 681
682 d->clear_free_func(d->data); 682 d->clear_free_func(d->data);
683 OPENSSL_free(d); 683 free(d);
684 684
685 d = next; 685 d = next;
686 } 686 }
@@ -705,7 +705,7 @@ EC_POINT *EC_POINT_new(const EC_GROUP *group)
705 return NULL; 705 return NULL;
706 } 706 }
707 707
708 ret = OPENSSL_malloc(sizeof *ret); 708 ret = malloc(sizeof *ret);
709 if (ret == NULL) 709 if (ret == NULL)
710 { 710 {
711 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE); 711 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
@@ -716,7 +716,7 @@ EC_POINT *EC_POINT_new(const EC_GROUP *group)
716 716
717 if (!ret->meth->point_init(ret)) 717 if (!ret->meth->point_init(ret))
718 { 718 {
719 OPENSSL_free(ret); 719 free(ret);
720 return NULL; 720 return NULL;
721 } 721 }
722 722
@@ -730,7 +730,7 @@ void EC_POINT_free(EC_POINT *point)
730 730
731 if (point->meth->point_finish != 0) 731 if (point->meth->point_finish != 0)
732 point->meth->point_finish(point); 732 point->meth->point_finish(point);
733 OPENSSL_free(point); 733 free(point);
734 } 734 }
735 735
736 736
@@ -743,7 +743,7 @@ void EC_POINT_clear_free(EC_POINT *point)
743 else if (point->meth->point_finish != 0) 743 else if (point->meth->point_finish != 0)
744 point->meth->point_finish(point); 744 point->meth->point_finish(point);
745 OPENSSL_cleanse(point, sizeof *point); 745 OPENSSL_cleanse(point, sizeof *point);
746 OPENSSL_free(point); 746 free(point);
747 } 747 }
748 748
749 749
diff --git a/src/lib/libcrypto/ec/ec_mult.c b/src/lib/libcrypto/ec/ec_mult.c
index 19f21675fb..b48c888048 100644
--- a/src/lib/libcrypto/ec/ec_mult.c
+++ b/src/lib/libcrypto/ec/ec_mult.c
@@ -102,7 +102,7 @@ static EC_PRE_COMP *ec_pre_comp_new(const EC_GROUP *group)
102 if (!group) 102 if (!group)
103 return NULL; 103 return NULL;
104 104
105 ret = (EC_PRE_COMP *)OPENSSL_malloc(sizeof(EC_PRE_COMP)); 105 ret = (EC_PRE_COMP *)malloc(sizeof(EC_PRE_COMP));
106 if (!ret) 106 if (!ret)
107 { 107 {
108 ECerr(EC_F_EC_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE); 108 ECerr(EC_F_EC_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE);
@@ -147,9 +147,9 @@ static void ec_pre_comp_free(void *pre_)
147 147
148 for (p = pre->points; *p != NULL; p++) 148 for (p = pre->points; *p != NULL; p++)
149 EC_POINT_free(*p); 149 EC_POINT_free(*p);
150 OPENSSL_free(pre->points); 150 free(pre->points);
151 } 151 }
152 OPENSSL_free(pre); 152 free(pre);
153 } 153 }
154 154
155static void ec_pre_comp_clear_free(void *pre_) 155static void ec_pre_comp_clear_free(void *pre_)
@@ -173,10 +173,10 @@ static void ec_pre_comp_clear_free(void *pre_)
173 EC_POINT_clear_free(*p); 173 EC_POINT_clear_free(*p);
174 OPENSSL_cleanse(p, sizeof *p); 174 OPENSSL_cleanse(p, sizeof *p);
175 } 175 }
176 OPENSSL_free(pre->points); 176 free(pre->points);
177 } 177 }
178 OPENSSL_cleanse(pre, sizeof *pre); 178 OPENSSL_cleanse(pre, sizeof *pre);
179 OPENSSL_free(pre); 179 free(pre);
180 } 180 }
181 181
182 182
@@ -201,7 +201,7 @@ static signed char *compute_wNAF(const BIGNUM *scalar, int w, size_t *ret_len)
201 201
202 if (BN_is_zero(scalar)) 202 if (BN_is_zero(scalar))
203 { 203 {
204 r = OPENSSL_malloc(1); 204 r = malloc(1);
205 if (!r) 205 if (!r)
206 { 206 {
207 ECerr(EC_F_COMPUTE_WNAF, ERR_R_MALLOC_FAILURE); 207 ECerr(EC_F_COMPUTE_WNAF, ERR_R_MALLOC_FAILURE);
@@ -233,7 +233,7 @@ static signed char *compute_wNAF(const BIGNUM *scalar, int w, size_t *ret_len)
233 } 233 }
234 234
235 len = BN_num_bits(scalar); 235 len = BN_num_bits(scalar);
236 r = OPENSSL_malloc(len + 1); /* modified wNAF may be one digit longer than binary representation 236 r = malloc(len + 1); /* modified wNAF may be one digit longer than binary representation
237 * (*ret_len will be set to the actual length, i.e. at most 237 * (*ret_len will be set to the actual length, i.e. at most
238 * BN_num_bits(scalar) + 1) */ 238 * BN_num_bits(scalar) + 1) */
239 if (r == NULL) 239 if (r == NULL)
@@ -315,7 +315,7 @@ static signed char *compute_wNAF(const BIGNUM *scalar, int w, size_t *ret_len)
315 err: 315 err:
316 if (!ok) 316 if (!ok)
317 { 317 {
318 OPENSSL_free(r); 318 free(r);
319 r = NULL; 319 r = NULL;
320 } 320 }
321 if (ok) 321 if (ok)
@@ -441,10 +441,10 @@ int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
441 441
442 totalnum = num + numblocks; 442 totalnum = num + numblocks;
443 443
444 wsize = OPENSSL_malloc(totalnum * sizeof wsize[0]); 444 wsize = malloc(totalnum * sizeof wsize[0]);
445 wNAF_len = OPENSSL_malloc(totalnum * sizeof wNAF_len[0]); 445 wNAF_len = malloc(totalnum * sizeof wNAF_len[0]);
446 wNAF = OPENSSL_malloc((totalnum + 1) * sizeof wNAF[0]); /* includes space for pivot */ 446 wNAF = malloc((totalnum + 1) * sizeof wNAF[0]); /* includes space for pivot */
447 val_sub = OPENSSL_malloc(totalnum * sizeof val_sub[0]); 447 val_sub = malloc(totalnum * sizeof val_sub[0]);
448 448
449 if (!wsize || !wNAF_len || !wNAF || !val_sub) 449 if (!wsize || !wNAF_len || !wNAF || !val_sub)
450 { 450 {
@@ -560,11 +560,11 @@ int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
560 wNAF_len[i] = tmp_len; 560 wNAF_len[i] = tmp_len;
561 561
562 wNAF[i + 1] = NULL; 562 wNAF[i + 1] = NULL;
563 wNAF[i] = OPENSSL_malloc(wNAF_len[i]); 563 wNAF[i] = malloc(wNAF_len[i]);
564 if (wNAF[i] == NULL) 564 if (wNAF[i] == NULL)
565 { 565 {
566 ECerr(EC_F_EC_WNAF_MUL, ERR_R_MALLOC_FAILURE); 566 ECerr(EC_F_EC_WNAF_MUL, ERR_R_MALLOC_FAILURE);
567 OPENSSL_free(tmp_wNAF); 567 free(tmp_wNAF);
568 goto err; 568 goto err;
569 } 569 }
570 memcpy(wNAF[i], pp, wNAF_len[i]); 570 memcpy(wNAF[i], pp, wNAF_len[i]);
@@ -574,14 +574,14 @@ int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
574 if (*tmp_points == NULL) 574 if (*tmp_points == NULL)
575 { 575 {
576 ECerr(EC_F_EC_WNAF_MUL, ERR_R_INTERNAL_ERROR); 576 ECerr(EC_F_EC_WNAF_MUL, ERR_R_INTERNAL_ERROR);
577 OPENSSL_free(tmp_wNAF); 577 free(tmp_wNAF);
578 goto err; 578 goto err;
579 } 579 }
580 val_sub[i] = tmp_points; 580 val_sub[i] = tmp_points;
581 tmp_points += pre_points_per_block; 581 tmp_points += pre_points_per_block;
582 pp += blocksize; 582 pp += blocksize;
583 } 583 }
584 OPENSSL_free(tmp_wNAF); 584 free(tmp_wNAF);
585 } 585 }
586 } 586 }
587 } 587 }
@@ -589,7 +589,7 @@ int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
589 /* All points we precompute now go into a single array 'val'. 589 /* All points we precompute now go into a single array 'val'.
590 * 'val_sub[i]' is a pointer to the subarray for the i-th point, 590 * 'val_sub[i]' is a pointer to the subarray for the i-th point,
591 * or to a subarray of 'pre_comp->points' if we already have precomputation. */ 591 * or to a subarray of 'pre_comp->points' if we already have precomputation. */
592 val = OPENSSL_malloc((num_val + 1) * sizeof val[0]); 592 val = malloc((num_val + 1) * sizeof val[0]);
593 if (val == NULL) 593 if (val == NULL)
594 { 594 {
595 ECerr(EC_F_EC_WNAF_MUL, ERR_R_MALLOC_FAILURE); 595 ECerr(EC_F_EC_WNAF_MUL, ERR_R_MALLOC_FAILURE);
@@ -716,28 +716,28 @@ int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
716 if (tmp != NULL) 716 if (tmp != NULL)
717 EC_POINT_free(tmp); 717 EC_POINT_free(tmp);
718 if (wsize != NULL) 718 if (wsize != NULL)
719 OPENSSL_free(wsize); 719 free(wsize);
720 if (wNAF_len != NULL) 720 if (wNAF_len != NULL)
721 OPENSSL_free(wNAF_len); 721 free(wNAF_len);
722 if (wNAF != NULL) 722 if (wNAF != NULL)
723 { 723 {
724 signed char **w; 724 signed char **w;
725 725
726 for (w = wNAF; *w != NULL; w++) 726 for (w = wNAF; *w != NULL; w++)
727 OPENSSL_free(*w); 727 free(*w);
728 728
729 OPENSSL_free(wNAF); 729 free(wNAF);
730 } 730 }
731 if (val != NULL) 731 if (val != NULL)
732 { 732 {
733 for (v = val; *v != NULL; v++) 733 for (v = val; *v != NULL; v++)
734 EC_POINT_clear_free(*v); 734 EC_POINT_clear_free(*v);
735 735
736 OPENSSL_free(val); 736 free(val);
737 } 737 }
738 if (val_sub != NULL) 738 if (val_sub != NULL)
739 { 739 {
740 OPENSSL_free(val_sub); 740 free(val_sub);
741 } 741 }
742 return ret; 742 return ret;
743 } 743 }
@@ -825,7 +825,7 @@ int ec_wNAF_precompute_mult(EC_GROUP *group, BN_CTX *ctx)
825 pre_points_per_block = (size_t)1 << (w - 1); 825 pre_points_per_block = (size_t)1 << (w - 1);
826 num = pre_points_per_block * numblocks; /* number of points to compute and store */ 826 num = pre_points_per_block * numblocks; /* number of points to compute and store */
827 827
828 points = OPENSSL_malloc(sizeof (EC_POINT*)*(num + 1)); 828 points = malloc(sizeof (EC_POINT*)*(num + 1));
829 if (!points) 829 if (!points)
830 { 830 {
831 ECerr(EC_F_EC_WNAF_PRECOMPUTE_MULT, ERR_R_MALLOC_FAILURE); 831 ECerr(EC_F_EC_WNAF_PRECOMPUTE_MULT, ERR_R_MALLOC_FAILURE);
@@ -921,7 +921,7 @@ int ec_wNAF_precompute_mult(EC_GROUP *group, BN_CTX *ctx)
921 921
922 for (p = points; *p != NULL; p++) 922 for (p = points; *p != NULL; p++)
923 EC_POINT_free(*p); 923 EC_POINT_free(*p);
924 OPENSSL_free(points); 924 free(points);
925 } 925 }
926 if (tmp_point) 926 if (tmp_point)
927 EC_POINT_free(tmp_point); 927 EC_POINT_free(tmp_point);
diff --git a/src/lib/libcrypto/ec/ec_pmeth.c b/src/lib/libcrypto/ec/ec_pmeth.c
index 66ee397d86..dfc8ace27b 100644
--- a/src/lib/libcrypto/ec/ec_pmeth.c
+++ b/src/lib/libcrypto/ec/ec_pmeth.c
@@ -77,7 +77,7 @@ typedef struct
77static int pkey_ec_init(EVP_PKEY_CTX *ctx) 77static int pkey_ec_init(EVP_PKEY_CTX *ctx)
78 { 78 {
79 EC_PKEY_CTX *dctx; 79 EC_PKEY_CTX *dctx;
80 dctx = OPENSSL_malloc(sizeof(EC_PKEY_CTX)); 80 dctx = malloc(sizeof(EC_PKEY_CTX));
81 if (!dctx) 81 if (!dctx)
82 return 0; 82 return 0;
83 dctx->gen_group = NULL; 83 dctx->gen_group = NULL;
@@ -112,7 +112,7 @@ static void pkey_ec_cleanup(EVP_PKEY_CTX *ctx)
112 { 112 {
113 if (dctx->gen_group) 113 if (dctx->gen_group)
114 EC_GROUP_free(dctx->gen_group); 114 EC_GROUP_free(dctx->gen_group);
115 OPENSSL_free(dctx); 115 free(dctx);
116 } 116 }
117 } 117 }
118 118
diff --git a/src/lib/libcrypto/ec/ec_print.c b/src/lib/libcrypto/ec/ec_print.c
index f7c8a303ac..1655332c3c 100644
--- a/src/lib/libcrypto/ec/ec_print.c
+++ b/src/lib/libcrypto/ec/ec_print.c
@@ -70,18 +70,18 @@ BIGNUM *EC_POINT_point2bn(const EC_GROUP *group,
70 if (buf_len == 0) 70 if (buf_len == 0)
71 return NULL; 71 return NULL;
72 72
73 if ((buf = OPENSSL_malloc(buf_len)) == NULL) 73 if ((buf = malloc(buf_len)) == NULL)
74 return NULL; 74 return NULL;
75 75
76 if (!EC_POINT_point2oct(group, point, form, buf, buf_len, ctx)) 76 if (!EC_POINT_point2oct(group, point, form, buf, buf_len, ctx))
77 { 77 {
78 OPENSSL_free(buf); 78 free(buf);
79 return NULL; 79 return NULL;
80 } 80 }
81 81
82 ret = BN_bin2bn(buf, buf_len, ret); 82 ret = BN_bin2bn(buf, buf_len, ret);
83 83
84 OPENSSL_free(buf); 84 free(buf);
85 85
86 return ret; 86 return ret;
87} 87}
@@ -96,13 +96,13 @@ EC_POINT *EC_POINT_bn2point(const EC_GROUP *group,
96 EC_POINT *ret; 96 EC_POINT *ret;
97 97
98 if ((buf_len = BN_num_bytes(bn)) == 0) return NULL; 98 if ((buf_len = BN_num_bytes(bn)) == 0) return NULL;
99 buf = OPENSSL_malloc(buf_len); 99 buf = malloc(buf_len);
100 if (buf == NULL) 100 if (buf == NULL)
101 return NULL; 101 return NULL;
102 102
103 if (!BN_bn2bin(bn, buf)) 103 if (!BN_bn2bin(bn, buf))
104 { 104 {
105 OPENSSL_free(buf); 105 free(buf);
106 return NULL; 106 return NULL;
107 } 107 }
108 108
@@ -110,7 +110,7 @@ EC_POINT *EC_POINT_bn2point(const EC_GROUP *group,
110 { 110 {
111 if ((ret = EC_POINT_new(group)) == NULL) 111 if ((ret = EC_POINT_new(group)) == NULL)
112 { 112 {
113 OPENSSL_free(buf); 113 free(buf);
114 return NULL; 114 return NULL;
115 } 115 }
116 } 116 }
@@ -121,17 +121,17 @@ EC_POINT *EC_POINT_bn2point(const EC_GROUP *group,
121 { 121 {
122 if (point == NULL) 122 if (point == NULL)
123 EC_POINT_clear_free(ret); 123 EC_POINT_clear_free(ret);
124 OPENSSL_free(buf); 124 free(buf);
125 return NULL; 125 return NULL;
126 } 126 }
127 127
128 OPENSSL_free(buf); 128 free(buf);
129 return ret; 129 return ret;
130 } 130 }
131 131
132static const char *HEX_DIGITS = "0123456789ABCDEF"; 132static const char *HEX_DIGITS = "0123456789ABCDEF";
133 133
134/* the return value must be freed (using OPENSSL_free()) */ 134/* the return value must be freed (using free()) */
135char *EC_POINT_point2hex(const EC_GROUP *group, 135char *EC_POINT_point2hex(const EC_GROUP *group,
136 const EC_POINT *point, 136 const EC_POINT *point,
137 point_conversion_form_t form, 137 point_conversion_form_t form,
@@ -146,19 +146,19 @@ char *EC_POINT_point2hex(const EC_GROUP *group,
146 if (buf_len == 0) 146 if (buf_len == 0)
147 return NULL; 147 return NULL;
148 148
149 if ((buf = OPENSSL_malloc(buf_len)) == NULL) 149 if ((buf = malloc(buf_len)) == NULL)
150 return NULL; 150 return NULL;
151 151
152 if (!EC_POINT_point2oct(group, point, form, buf, buf_len, ctx)) 152 if (!EC_POINT_point2oct(group, point, form, buf, buf_len, ctx))
153 { 153 {
154 OPENSSL_free(buf); 154 free(buf);
155 return NULL; 155 return NULL;
156 } 156 }
157 157
158 ret = (char *)OPENSSL_malloc(buf_len*2+2); 158 ret = (char *)malloc(buf_len*2+2);
159 if (ret == NULL) 159 if (ret == NULL)
160 { 160 {
161 OPENSSL_free(buf); 161 free(buf);
162 return NULL; 162 return NULL;
163 } 163 }
164 p = ret; 164 p = ret;
@@ -171,7 +171,7 @@ char *EC_POINT_point2hex(const EC_GROUP *group,
171 } 171 }
172 *p='\0'; 172 *p='\0';
173 173
174 OPENSSL_free(buf); 174 free(buf);
175 175
176 return ret; 176 return ret;
177 } 177 }
diff --git a/src/lib/libcrypto/ec/eck_prn.c b/src/lib/libcrypto/ec/eck_prn.c
index 06de8f3959..4e8c748bbc 100644
--- a/src/lib/libcrypto/ec/eck_prn.c
+++ b/src/lib/libcrypto/ec/eck_prn.c
@@ -263,7 +263,7 @@ int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off)
263 seed_len = EC_GROUP_get_seed_len(x); 263 seed_len = EC_GROUP_get_seed_len(x);
264 264
265 buf_len += 10; 265 buf_len += 10;
266 if ((buffer = OPENSSL_malloc(buf_len)) == NULL) 266 if ((buffer = malloc(buf_len)) == NULL)
267 { 267 {
268 reason = ERR_R_MALLOC_FAILURE; 268 reason = ERR_R_MALLOC_FAILURE;
269 goto err; 269 goto err;
@@ -349,7 +349,7 @@ err:
349 if (ctx) 349 if (ctx)
350 BN_CTX_free(ctx); 350 BN_CTX_free(ctx);
351 if (buffer != NULL) 351 if (buffer != NULL)
352 OPENSSL_free(buffer); 352 free(buffer);
353 return(ret); 353 return(ret);
354 } 354 }
355 355
diff --git a/src/lib/libcrypto/ec/ecp_nistp224.c b/src/lib/libcrypto/ec/ecp_nistp224.c
index b5ff56c252..03f2d9c1d7 100644
--- a/src/lib/libcrypto/ec/ecp_nistp224.c
+++ b/src/lib/libcrypto/ec/ecp_nistp224.c
@@ -1148,7 +1148,7 @@ static void batch_mul(felem x_out, felem y_out, felem z_out,
1148static NISTP224_PRE_COMP *nistp224_pre_comp_new() 1148static NISTP224_PRE_COMP *nistp224_pre_comp_new()
1149 { 1149 {
1150 NISTP224_PRE_COMP *ret = NULL; 1150 NISTP224_PRE_COMP *ret = NULL;
1151 ret = (NISTP224_PRE_COMP *) OPENSSL_malloc(sizeof *ret); 1151 ret = (NISTP224_PRE_COMP *) malloc(sizeof *ret);
1152 if (!ret) 1152 if (!ret)
1153 { 1153 {
1154 ECerr(EC_F_NISTP224_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE); 1154 ECerr(EC_F_NISTP224_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE);
@@ -1181,7 +1181,7 @@ static void nistp224_pre_comp_free(void *pre_)
1181 if (i > 0) 1181 if (i > 0)
1182 return; 1182 return;
1183 1183
1184 OPENSSL_free(pre); 1184 free(pre);
1185 } 1185 }
1186 1186
1187static void nistp224_pre_comp_clear_free(void *pre_) 1187static void nistp224_pre_comp_clear_free(void *pre_)
@@ -1197,7 +1197,7 @@ static void nistp224_pre_comp_clear_free(void *pre_)
1197 return; 1197 return;
1198 1198
1199 OPENSSL_cleanse(pre, sizeof *pre); 1199 OPENSSL_cleanse(pre, sizeof *pre);
1200 OPENSSL_free(pre); 1200 free(pre);
1201 } 1201 }
1202 1202
1203/******************************************************************************/ 1203/******************************************************************************/
@@ -1382,10 +1382,10 @@ int ec_GFp_nistp224_points_mul(const EC_GROUP *group, EC_POINT *r,
1382 * converting those into affine form is time well spent */ 1382 * converting those into affine form is time well spent */
1383 mixed = 1; 1383 mixed = 1;
1384 } 1384 }
1385 secrets = OPENSSL_malloc(num_points * sizeof(felem_bytearray)); 1385 secrets = malloc(num_points * sizeof(felem_bytearray));
1386 pre_comp = OPENSSL_malloc(num_points * 17 * 3 * sizeof(felem)); 1386 pre_comp = malloc(num_points * 17 * 3 * sizeof(felem));
1387 if (mixed) 1387 if (mixed)
1388 tmp_felems = OPENSSL_malloc((num_points * 17 + 1) * sizeof(felem)); 1388 tmp_felems = malloc((num_points * 17 + 1) * sizeof(felem));
1389 if ((secrets == NULL) || (pre_comp == NULL) || (mixed && (tmp_felems == NULL))) 1389 if ((secrets == NULL) || (pre_comp == NULL) || (mixed && (tmp_felems == NULL)))
1390 { 1390 {
1391 ECerr(EC_F_EC_GFP_NISTP224_POINTS_MUL, ERR_R_MALLOC_FAILURE); 1391 ECerr(EC_F_EC_GFP_NISTP224_POINTS_MUL, ERR_R_MALLOC_FAILURE);
@@ -1506,11 +1506,11 @@ err:
1506 if (new_ctx != NULL) 1506 if (new_ctx != NULL)
1507 BN_CTX_free(new_ctx); 1507 BN_CTX_free(new_ctx);
1508 if (secrets != NULL) 1508 if (secrets != NULL)
1509 OPENSSL_free(secrets); 1509 free(secrets);
1510 if (pre_comp != NULL) 1510 if (pre_comp != NULL)
1511 OPENSSL_free(pre_comp); 1511 free(pre_comp);
1512 if (tmp_felems != NULL) 1512 if (tmp_felems != NULL)
1513 OPENSSL_free(tmp_felems); 1513 free(tmp_felems);
1514 return ret; 1514 return ret;
1515 } 1515 }
1516 1516
diff --git a/src/lib/libcrypto/ec/ecp_nistp256.c b/src/lib/libcrypto/ec/ecp_nistp256.c
index 4bc0f5dce0..947fb7eee0 100644
--- a/src/lib/libcrypto/ec/ecp_nistp256.c
+++ b/src/lib/libcrypto/ec/ecp_nistp256.c
@@ -1666,7 +1666,7 @@ const EC_METHOD *EC_GFp_nistp256_method(void)
1666static NISTP256_PRE_COMP *nistp256_pre_comp_new() 1666static NISTP256_PRE_COMP *nistp256_pre_comp_new()
1667 { 1667 {
1668 NISTP256_PRE_COMP *ret = NULL; 1668 NISTP256_PRE_COMP *ret = NULL;
1669 ret = (NISTP256_PRE_COMP *) OPENSSL_malloc(sizeof *ret); 1669 ret = (NISTP256_PRE_COMP *) malloc(sizeof *ret);
1670 if (!ret) 1670 if (!ret)
1671 { 1671 {
1672 ECerr(EC_F_NISTP256_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE); 1672 ECerr(EC_F_NISTP256_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE);
@@ -1699,7 +1699,7 @@ static void nistp256_pre_comp_free(void *pre_)
1699 if (i > 0) 1699 if (i > 0)
1700 return; 1700 return;
1701 1701
1702 OPENSSL_free(pre); 1702 free(pre);
1703 } 1703 }
1704 1704
1705static void nistp256_pre_comp_clear_free(void *pre_) 1705static void nistp256_pre_comp_clear_free(void *pre_)
@@ -1715,7 +1715,7 @@ static void nistp256_pre_comp_clear_free(void *pre_)
1715 return; 1715 return;
1716 1716
1717 OPENSSL_cleanse(pre, sizeof *pre); 1717 OPENSSL_cleanse(pre, sizeof *pre);
1718 OPENSSL_free(pre); 1718 free(pre);
1719 } 1719 }
1720 1720
1721/******************************************************************************/ 1721/******************************************************************************/
@@ -1901,10 +1901,10 @@ int ec_GFp_nistp256_points_mul(const EC_GROUP *group, EC_POINT *r,
1901 * converting those into affine form is time well spent */ 1901 * converting those into affine form is time well spent */
1902 mixed = 1; 1902 mixed = 1;
1903 } 1903 }
1904 secrets = OPENSSL_malloc(num_points * sizeof(felem_bytearray)); 1904 secrets = malloc(num_points * sizeof(felem_bytearray));
1905 pre_comp = OPENSSL_malloc(num_points * 17 * 3 * sizeof(smallfelem)); 1905 pre_comp = malloc(num_points * 17 * 3 * sizeof(smallfelem));
1906 if (mixed) 1906 if (mixed)
1907 tmp_smallfelems = OPENSSL_malloc((num_points * 17 + 1) * sizeof(smallfelem)); 1907 tmp_smallfelems = malloc((num_points * 17 + 1) * sizeof(smallfelem));
1908 if ((secrets == NULL) || (pre_comp == NULL) || (mixed && (tmp_smallfelems == NULL))) 1908 if ((secrets == NULL) || (pre_comp == NULL) || (mixed && (tmp_smallfelems == NULL)))
1909 { 1909 {
1910 ECerr(EC_F_EC_GFP_NISTP256_POINTS_MUL, ERR_R_MALLOC_FAILURE); 1910 ECerr(EC_F_EC_GFP_NISTP256_POINTS_MUL, ERR_R_MALLOC_FAILURE);
@@ -2026,11 +2026,11 @@ err:
2026 if (new_ctx != NULL) 2026 if (new_ctx != NULL)
2027 BN_CTX_free(new_ctx); 2027 BN_CTX_free(new_ctx);
2028 if (secrets != NULL) 2028 if (secrets != NULL)
2029 OPENSSL_free(secrets); 2029 free(secrets);
2030 if (pre_comp != NULL) 2030 if (pre_comp != NULL)
2031 OPENSSL_free(pre_comp); 2031 free(pre_comp);
2032 if (tmp_smallfelems != NULL) 2032 if (tmp_smallfelems != NULL)
2033 OPENSSL_free(tmp_smallfelems); 2033 free(tmp_smallfelems);
2034 return ret; 2034 return ret;
2035 } 2035 }
2036 2036
diff --git a/src/lib/libcrypto/ec/ecp_nistp521.c b/src/lib/libcrypto/ec/ecp_nistp521.c
index 178b655f7f..24eb032951 100644
--- a/src/lib/libcrypto/ec/ecp_nistp521.c
+++ b/src/lib/libcrypto/ec/ecp_nistp521.c
@@ -1533,7 +1533,7 @@ const EC_METHOD *EC_GFp_nistp521_method(void)
1533static NISTP521_PRE_COMP *nistp521_pre_comp_new() 1533static NISTP521_PRE_COMP *nistp521_pre_comp_new()
1534 { 1534 {
1535 NISTP521_PRE_COMP *ret = NULL; 1535 NISTP521_PRE_COMP *ret = NULL;
1536 ret = (NISTP521_PRE_COMP *)OPENSSL_malloc(sizeof(NISTP521_PRE_COMP)); 1536 ret = (NISTP521_PRE_COMP *)malloc(sizeof(NISTP521_PRE_COMP));
1537 if (!ret) 1537 if (!ret)
1538 { 1538 {
1539 ECerr(EC_F_NISTP521_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE); 1539 ECerr(EC_F_NISTP521_PRE_COMP_NEW, ERR_R_MALLOC_FAILURE);
@@ -1566,7 +1566,7 @@ static void nistp521_pre_comp_free(void *pre_)
1566 if (i > 0) 1566 if (i > 0)
1567 return; 1567 return;
1568 1568
1569 OPENSSL_free(pre); 1569 free(pre);
1570 } 1570 }
1571 1571
1572static void nistp521_pre_comp_clear_free(void *pre_) 1572static void nistp521_pre_comp_clear_free(void *pre_)
@@ -1582,7 +1582,7 @@ static void nistp521_pre_comp_clear_free(void *pre_)
1582 return; 1582 return;
1583 1583
1584 OPENSSL_cleanse(pre, sizeof(*pre)); 1584 OPENSSL_cleanse(pre, sizeof(*pre));
1585 OPENSSL_free(pre); 1585 free(pre);
1586 } 1586 }
1587 1587
1588/******************************************************************************/ 1588/******************************************************************************/
@@ -1766,10 +1766,10 @@ int ec_GFp_nistp521_points_mul(const EC_GROUP *group, EC_POINT *r,
1766 * converting those into affine form is time well spent */ 1766 * converting those into affine form is time well spent */
1767 mixed = 1; 1767 mixed = 1;
1768 } 1768 }
1769 secrets = OPENSSL_malloc(num_points * sizeof(felem_bytearray)); 1769 secrets = malloc(num_points * sizeof(felem_bytearray));
1770 pre_comp = OPENSSL_malloc(num_points * 17 * 3 * sizeof(felem)); 1770 pre_comp = malloc(num_points * 17 * 3 * sizeof(felem));
1771 if (mixed) 1771 if (mixed)
1772 tmp_felems = OPENSSL_malloc((num_points * 17 + 1) * sizeof(felem)); 1772 tmp_felems = malloc((num_points * 17 + 1) * sizeof(felem));
1773 if ((secrets == NULL) || (pre_comp == NULL) || (mixed && (tmp_felems == NULL))) 1773 if ((secrets == NULL) || (pre_comp == NULL) || (mixed && (tmp_felems == NULL)))
1774 { 1774 {
1775 ECerr(EC_F_EC_GFP_NISTP521_POINTS_MUL, ERR_R_MALLOC_FAILURE); 1775 ECerr(EC_F_EC_GFP_NISTP521_POINTS_MUL, ERR_R_MALLOC_FAILURE);
@@ -1891,11 +1891,11 @@ err:
1891 if (new_ctx != NULL) 1891 if (new_ctx != NULL)
1892 BN_CTX_free(new_ctx); 1892 BN_CTX_free(new_ctx);
1893 if (secrets != NULL) 1893 if (secrets != NULL)
1894 OPENSSL_free(secrets); 1894 free(secrets);
1895 if (pre_comp != NULL) 1895 if (pre_comp != NULL)
1896 OPENSSL_free(pre_comp); 1896 free(pre_comp);
1897 if (tmp_felems != NULL) 1897 if (tmp_felems != NULL)
1898 OPENSSL_free(tmp_felems); 1898 free(tmp_felems);
1899 return ret; 1899 return ret;
1900 } 1900 }
1901 1901
diff --git a/src/lib/libcrypto/ec/ecp_smpl.c b/src/lib/libcrypto/ec/ecp_smpl.c
index bf0ad998dd..a146752817 100644
--- a/src/lib/libcrypto/ec/ecp_smpl.c
+++ b/src/lib/libcrypto/ec/ecp_smpl.c
@@ -1205,7 +1205,7 @@ int ec_GFp_simple_points_make_affine(const EC_GROUP *group, size_t num, EC_POINT
1205 * We need twice that. */ 1205 * We need twice that. */
1206 pow2 <<= 1; 1206 pow2 <<= 1;
1207 1207
1208 heap = OPENSSL_malloc(pow2 * sizeof heap[0]); 1208 heap = malloc(pow2 * sizeof heap[0]);
1209 if (heap == NULL) goto err; 1209 if (heap == NULL) goto err;
1210 1210
1211 /* The array is used as a binary tree, exactly as in heapsort: 1211 /* The array is used as a binary tree, exactly as in heapsort:
@@ -1333,7 +1333,7 @@ int ec_GFp_simple_points_make_affine(const EC_GROUP *group, size_t num, EC_POINT
1333 if (heap[i] != NULL) 1333 if (heap[i] != NULL)
1334 BN_clear_free(heap[i]); 1334 BN_clear_free(heap[i]);
1335 } 1335 }
1336 OPENSSL_free(heap); 1336 free(heap);
1337 } 1337 }
1338 return ret; 1338 return ret;
1339 } 1339 }
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-04 09:03:17 +0000