Change library to use intrinsic memory allocation functions instead of

OPENSSL_foo wrappers. This changes:
OPENSSL_malloc->malloc
OPENSSL_free->free
OPENSSL_relloc->realloc
OPENSSL_freeFunc->free

43 files changed, 146 insertions, 146 deletions

diff --git a/src/lib/libcrypto/asn1/a_bitstr.c b/src/lib/libcrypto/asn1/a_bitstr.c
index 34179960b8..e2b65bf2ac 100644
--- a/src/lib/libcrypto/asn1/a_bitstr.c
+++ b/src/lib/libcrypto/asn1/a_bitstr.c
@@ -144,7 +144,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
 
         if (len-- > 1) /* using one because of the bits left byte */
                 {
-                s=(unsigned char *)OPENSSL_malloc((int)len);
+                s=(unsigned char *)malloc((int)len);
                 if (s == NULL)
                         {
                         i=ERR_R_MALLOC_FAILURE;
@@ -158,7 +158,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
                 s=NULL;
 
         ret->length=(int)len;
-        if (ret->data != NULL) OPENSSL_free(ret->data);
+        if (ret->data != NULL) free(ret->data);
         ret->data=s;
         ret->type=V_ASN1_BIT_STRING;
         if (a != NULL) (*a)=ret;
@@ -192,7 +192,7 @@ int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
                 {
                 if (!value) return(1); /* Don't need to set */
                 if (a->data == NULL)
-                        c=(unsigned char *)OPENSSL_malloc(w+1);
+                        c=(unsigned char *)malloc(w+1);
                 else
                         c=(unsigned char *)OPENSSL_realloc_clean(a->data,
                                                                  a->length,
diff --git a/src/lib/libcrypto/asn1/a_bytes.c b/src/lib/libcrypto/asn1/a_bytes.c
index 92d630cdba..8431d89edf 100644
--- a/src/lib/libcrypto/asn1/a_bytes.c
+++ b/src/lib/libcrypto/asn1/a_bytes.c
@@ -101,7 +101,7 @@ ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp,
 
         if (len != 0)
                 {
-                s=(unsigned char *)OPENSSL_malloc((int)len+1);
+                s=(unsigned char *)malloc((int)len+1);
                 if (s == NULL)
                         {
                         i=ERR_R_MALLOC_FAILURE;
@@ -114,7 +114,7 @@ ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp,
         else
                 s=NULL;
 
-        if (ret->data != NULL) OPENSSL_free(ret->data);
+        if (ret->data != NULL) free(ret->data);
         ret->length=(int)len;
         ret->data=s;
         ret->type=tag;
@@ -209,8 +209,8 @@ ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp,
                         {
                         if ((ret->length < len) || (ret->data == NULL))
                                 {
-                                if (ret->data != NULL) OPENSSL_free(ret->data);
-                                s=(unsigned char *)OPENSSL_malloc((int)len + 1);
+                                if (ret->data != NULL) free(ret->data);
+                                s=(unsigned char *)malloc((int)len + 1);
                                 if (s == NULL)
                                         {
                                         i=ERR_R_MALLOC_FAILURE;
@@ -226,7 +226,7 @@ ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp,
                 else
                         {
                         s=NULL;
-                        if (ret->data != NULL) OPENSSL_free(ret->data);
+                        if (ret->data != NULL) free(ret->data);
                         }
 
                 ret->length=(int)len;
@@ -301,14 +301,14 @@ static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c)
         if (!asn1_const_Finish(c)) goto err;
 
         a->length=num;
-        if (a->data != NULL) OPENSSL_free(a->data);
+        if (a->data != NULL) free(a->data);
         a->data=(unsigned char *)b.data;
         if (os != NULL) ASN1_STRING_free(os);
         return(1);
 err:
         ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE,c->error);
         if (os != NULL) ASN1_STRING_free(os);
-        if (b.data != NULL) OPENSSL_free(b.data);
+        if (b.data != NULL) free(b.data);
         return(0);
         }
 
diff --git a/src/lib/libcrypto/asn1/a_digest.c b/src/lib/libcrypto/asn1/a_digest.c
index 8a4b24a06b..0d463d409b 100644
--- a/src/lib/libcrypto/asn1/a_digest.c
+++ b/src/lib/libcrypto/asn1/a_digest.c
@@ -81,6 +81,6 @@ int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *asn,
 
         if (!EVP_Digest(str, i, md, len, type, NULL))
                 return 0;
-        OPENSSL_free(str);
+        free(str);
         return(1);
         }
diff --git a/src/lib/libcrypto/asn1/a_dup.c b/src/lib/libcrypto/asn1/a_dup.c
index d98992548a..e825b9c2d4 100644
--- a/src/lib/libcrypto/asn1/a_dup.c
+++ b/src/lib/libcrypto/asn1/a_dup.c
@@ -72,14 +72,14 @@ void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x)
         if (x == NULL) return(NULL);
 
         i=i2d(x,NULL);
-        b=OPENSSL_malloc(i+10);
+        b=malloc(i+10);
         if (b == NULL)
                 { ASN1err(ASN1_F_ASN1_DUP,ERR_R_MALLOC_FAILURE); return(NULL); }
         p= b;
         i=i2d(x,&p);
         p2= b;
         ret=d2i(NULL,&p2,i);
-        OPENSSL_free(b);
+        free(b);
         return(ret);
         }
 
@@ -104,6 +104,6 @@ void *ASN1_item_dup(const ASN1_ITEM *it, void *x)
                 { ASN1err(ASN1_F_ASN1_ITEM_DUP,ERR_R_MALLOC_FAILURE); return(NULL); }
         p= b;
         ret=ASN1_item_d2i(NULL,&p,i, it);
-        OPENSSL_free(b);
+        free(b);
         return(ret);
         }
diff --git a/src/lib/libcrypto/asn1/a_enum.c b/src/lib/libcrypto/asn1/a_enum.c
index fe9aa13b9c..c1154dde0a 100644
--- a/src/lib/libcrypto/asn1/a_enum.c
+++ b/src/lib/libcrypto/asn1/a_enum.c
@@ -77,8 +77,8 @@ int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
         if (a->length < (int)(sizeof(long)+1))
                 {
                 if (a->data != NULL)
-                        OPENSSL_free(a->data);
-                if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
+                        free(a->data);
+                if ((a->data=(unsigned char *)malloc(sizeof(long)+1)) != NULL)
                         memset((char *)a->data,0,sizeof(long)+1);
                 }
         if (a->data == NULL)
@@ -155,7 +155,7 @@ ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(BIGNUM *bn, ASN1_ENUMERATED *ai)
         len=((j == 0)?0:((j/8)+1));
         if (ret->length < len+4)
                 {
-                unsigned char *new_data=OPENSSL_realloc(ret->data, len+4);
+                unsigned char *new_data=realloc(ret->data, len+4);
                 if (!new_data)
                         {
                         ASN1err(ASN1_F_BN_TO_ASN1_ENUMERATED,ERR_R_MALLOC_FAILURE);
diff --git a/src/lib/libcrypto/asn1/a_gentm.c b/src/lib/libcrypto/asn1/a_gentm.c
index 4f312ee6c9..86666e7a20 100644
--- a/src/lib/libcrypto/asn1/a_gentm.c
+++ b/src/lib/libcrypto/asn1/a_gentm.c
@@ -225,7 +225,7 @@ ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
         p=(char *)s->data;
         if ((p == NULL) || ((size_t)s->length < len))
                 {
-                p=OPENSSL_malloc(len);
+                p=malloc(len);
                 if (p == NULL)
                         {
                         ASN1err(ASN1_F_ASN1_GENERALIZEDTIME_ADJ,
@@ -233,7 +233,7 @@ ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
                         return(NULL);
                         }
                 if (s->data != NULL)
-                        OPENSSL_free(s->data);
+                        free(s->data);
                 s->data=(unsigned char *)p;
                 }
 
diff --git a/src/lib/libcrypto/asn1/a_i2d_fp.c b/src/lib/libcrypto/asn1/a_i2d_fp.c
index a3ad76d356..484bcd66eb 100644
--- a/src/lib/libcrypto/asn1/a_i2d_fp.c
+++ b/src/lib/libcrypto/asn1/a_i2d_fp.c
@@ -88,7 +88,7 @@ int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x)
         int i,j=0,n,ret=1;
 
         n=i2d(x,NULL);
-        b=(char *)OPENSSL_malloc(n);
+        b=(char *)malloc(n);
         if (b == NULL)
                 {
                 ASN1err(ASN1_F_ASN1_I2D_BIO,ERR_R_MALLOC_FAILURE);
@@ -110,7 +110,7 @@ int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x)
                 j+=i;
                 n-=i;
                 }
-        OPENSSL_free(b);
+        free(b);
         return(ret);
         }
 
@@ -158,6 +158,6 @@ int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x)
                 j+=i;
                 n-=i;
                 }
-        OPENSSL_free(b);
+        free(b);
         return(ret);
         }
diff --git a/src/lib/libcrypto/asn1/a_int.c b/src/lib/libcrypto/asn1/a_int.c
index 297c45a9ff..6c38ace8f9 100644
--- a/src/lib/libcrypto/asn1/a_int.c
+++ b/src/lib/libcrypto/asn1/a_int.c
@@ -194,9 +194,9 @@ ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp,
         p= *pp;
         pend = p + len;
 
-        /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
+        /* We must malloc stuff, even for 0 bytes otherwise it
          * signifies a missing NULL parameter. */
-        s=(unsigned char *)OPENSSL_malloc((int)len+1);
+        s=(unsigned char *)malloc((int)len+1);
         if (s == NULL)
                 {
                 i=ERR_R_MALLOC_FAILURE;
@@ -249,7 +249,7 @@ ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp,
                 memcpy(s,p,(int)len);
         }
 
-        if (ret->data != NULL) OPENSSL_free(ret->data);
+        if (ret->data != NULL) free(ret->data);
         ret->data=s;
         ret->length=(int)len;
         if (a != NULL) (*a)=ret;
@@ -300,9 +300,9 @@ ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
                 goto err;
                 }
 
-        /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
+        /* We must malloc stuff, even for 0 bytes otherwise it
          * signifies a missing NULL parameter. */
-        s=(unsigned char *)OPENSSL_malloc((int)len+1);
+        s=(unsigned char *)malloc((int)len+1);
         if (s == NULL)
                 {
                 i=ERR_R_MALLOC_FAILURE;
@@ -319,7 +319,7 @@ ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
                 p+=len;
         }
 
-        if (ret->data != NULL) OPENSSL_free(ret->data);
+        if (ret->data != NULL) free(ret->data);
         ret->data=s;
         ret->length=(int)len;
         if (a != NULL) (*a)=ret;
@@ -343,8 +343,8 @@ int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
         if (a->length < (int)(sizeof(long)+1))
                 {
                 if (a->data != NULL)
-                        OPENSSL_free(a->data);
-                if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
+                        free(a->data);
+                if ((a->data=(unsigned char *)malloc(sizeof(long)+1)) != NULL)
                         memset((char *)a->data,0,sizeof(long)+1);
                 }
         if (a->data == NULL)
@@ -422,7 +422,7 @@ ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai)
         len=((j == 0)?0:((j/8)+1));
         if (ret->length < len+4)
                 {
-                unsigned char *new_data=OPENSSL_realloc(ret->data, len+4);
+                unsigned char *new_data=realloc(ret->data, len+4);
                 if (!new_data)
                         {
                         ASN1err(ASN1_F_BN_TO_ASN1_INTEGER,ERR_R_MALLOC_FAILURE);
diff --git a/src/lib/libcrypto/asn1/a_mbstr.c b/src/lib/libcrypto/asn1/a_mbstr.c
index dc953c8325..f6d8da8b3c 100644
--- a/src/lib/libcrypto/asn1/a_mbstr.c
+++ b/src/lib/libcrypto/asn1/a_mbstr.c
@@ -185,7 +185,7 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
                 dest = *out;
                 if(dest->data) {
                         dest->length = 0;
-                        OPENSSL_free(dest->data);
+                        free(dest->data);
                         dest->data = NULL;
                 }
                 dest->type = str_type;
@@ -231,7 +231,7 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
                 cpyfunc = cpy_utf8;
                 break;
         }
-        if(!(p = OPENSSL_malloc(outlen + 1))) {
+        if(!(p = malloc(outlen + 1))) {
                 if(free_out) ASN1_STRING_free(dest);
                 ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,ERR_R_MALLOC_FAILURE);
                 return -1;
diff --git a/src/lib/libcrypto/asn1/a_object.c b/src/lib/libcrypto/asn1/a_object.c
index 3978c9150d..c30f32442d 100644
--- a/src/lib/libcrypto/asn1/a_object.c
+++ b/src/lib/libcrypto/asn1/a_object.c
@@ -180,9 +180,9 @@ int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
                         if (blsize > tmpsize)
                                 {
                                 if (tmp != ftmp)
-                                        OPENSSL_free(tmp);
+                                        free(tmp);
                                 tmpsize = blsize + 32;
-                                tmp = OPENSSL_malloc(tmpsize);
+                                tmp = malloc(tmpsize);
                                 if (!tmp)
                                         goto err;
                                 }
@@ -215,13 +215,13 @@ int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
                         len+=i;
                 }
         if (tmp != ftmp)
-                OPENSSL_free(tmp);
+                free(tmp);
         if (bl)
                 BN_free(bl);
         return(len);
 err:
         if (tmp != ftmp)
-                OPENSSL_free(tmp);
+                free(tmp);
         if (bl)
                 BN_free(bl);
         return(0);
@@ -242,7 +242,7 @@ int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
         i=i2t_ASN1_OBJECT(buf,sizeof buf,a);
         if (i > (int)(sizeof(buf) - 1))
                 {
-                p = OPENSSL_malloc(i + 1);
+                p = malloc(i + 1);
                 if (!p)
                         return -1;
                 i2t_ASN1_OBJECT(p,i + 1,a);
@@ -251,7 +251,7 @@ int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
                 return BIO_write(bp, "<INVALID>", 9);
         BIO_write(bp,p,i);
         if (p != buf)
-                OPENSSL_free(p);
+                free(p);
         return(i);
         }
 
@@ -319,8 +319,8 @@ ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
         if ((data == NULL) || (ret->length < len))
                 {
                 ret->length=0;
-                if (data != NULL) OPENSSL_free(data);
-                data=(unsigned char *)OPENSSL_malloc(len ? (int)len : 1);
+                if (data != NULL) free(data);
+                data=(unsigned char *)malloc(len ? (int)len : 1);
                 if (data == NULL)
                         { i=ERR_R_MALLOC_FAILURE; goto err; }
                 ret->flags|=ASN1_OBJECT_FLAG_DYNAMIC_DATA;
@@ -348,7 +348,7 @@ ASN1_OBJECT *ASN1_OBJECT_new(void)
         {
         ASN1_OBJECT *ret;
 
-        ret=(ASN1_OBJECT *)OPENSSL_malloc(sizeof(ASN1_OBJECT));
+        ret=(ASN1_OBJECT *)malloc(sizeof(ASN1_OBJECT));
         if (ret == NULL)
                 {
                 ASN1err(ASN1_F_ASN1_OBJECT_NEW,ERR_R_MALLOC_FAILURE);
@@ -369,19 +369,19 @@ void ASN1_OBJECT_free(ASN1_OBJECT *a)
         if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS)
                 {
 #ifndef CONST_STRICT /* disable purely for compile-time strict const checking. Doing this on a "real" compile will cause memory leaks */
-                if (a->sn != NULL) OPENSSL_free((void *)a->sn);
-                if (a->ln != NULL) OPENSSL_free((void *)a->ln);
+                if (a->sn != NULL) free((void *)a->sn);
+                if (a->ln != NULL) free((void *)a->ln);
 #endif
                 a->sn=a->ln=NULL;
                 }
         if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA)
                 {
-                if (a->data != NULL) OPENSSL_free((void *)a->data);
+                if (a->data != NULL) free((void *)a->data);
                 a->data=NULL;
                 a->length=0;
                 }
         if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
-                OPENSSL_free(a);
+                free(a);
         }
 
 ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
diff --git a/src/lib/libcrypto/asn1/a_sign.c b/src/lib/libcrypto/asn1/a_sign.c
index 01b6292b65..0433b49a64 100644
--- a/src/lib/libcrypto/asn1/a_sign.c
+++ b/src/lib/libcrypto/asn1/a_sign.c
@@ -211,7 +211,7 @@ int ASN1_item_sign_ctx(const ASN1_ITEM *it,
 
         inl=ASN1_item_i2d(asn,&buf_in, it);
         outll=outl=EVP_PKEY_size(pkey);
-        buf_out=OPENSSL_malloc((unsigned int)outl);
+        buf_out=malloc((unsigned int)outl);
         if ((buf_in == NULL) || (buf_out == NULL))
                 {
                 outl=0;
@@ -226,7 +226,7 @@ int ASN1_item_sign_ctx(const ASN1_ITEM *it,
                 ASN1err(ASN1_F_ASN1_ITEM_SIGN_CTX,ERR_R_EVP_LIB);
                 goto err;
                 }
-        if (signature->data != NULL) OPENSSL_free(signature->data);
+        if (signature->data != NULL) free(signature->data);
         signature->data=buf_out;
         buf_out=NULL;
         signature->length=outl;
@@ -238,8 +238,8 @@ int ASN1_item_sign_ctx(const ASN1_ITEM *it,
 err:
         EVP_MD_CTX_cleanup(ctx);
         if (buf_in != NULL)
-                { OPENSSL_cleanse((char *)buf_in,(unsigned int)inl); OPENSSL_free(buf_in); }
+                { OPENSSL_cleanse((char *)buf_in,(unsigned int)inl); free(buf_in); }
         if (buf_out != NULL)
-                { OPENSSL_cleanse((char *)buf_out,outll); OPENSSL_free(buf_out); }
+                { OPENSSL_cleanse((char *)buf_out,outll); free(buf_out); }
         return(outl);
         }
diff --git a/src/lib/libcrypto/asn1/a_strex.c b/src/lib/libcrypto/asn1/a_strex.c
index d1a587ccc1..713b3cb028 100644
--- a/src/lib/libcrypto/asn1/a_strex.c
+++ b/src/lib/libcrypto/asn1/a_strex.c
@@ -278,12 +278,12 @@ static int do_dump(unsigned long lflags, char_io *io_ch, void *arg, ASN1_STRING
         t.type = str->type;
         t.value.ptr = (char *)str;
         der_len = i2d_ASN1_TYPE(&t, NULL);
-        der_buf = OPENSSL_malloc(der_len);
+        der_buf = malloc(der_len);
         if(!der_buf) return -1;
         p = der_buf;
         i2d_ASN1_TYPE(&t, &p);
         outlen = do_hex_dump(io_ch, arg, der_buf, der_len);
-        OPENSSL_free(der_buf);
+        free(der_buf);
         if(outlen < 0) return -1;
         return outlen + 1;
 }
diff --git a/src/lib/libcrypto/asn1/a_strnid.c b/src/lib/libcrypto/asn1/a_strnid.c
index 2fc48c1551..74bc7b316c 100644
--- a/src/lib/libcrypto/asn1/a_strnid.c
+++ b/src/lib/libcrypto/asn1/a_strnid.c
@@ -222,7 +222,7 @@ int ASN1_STRING_TABLE_add(int nid,
                 return 0;
         }
         if(!(tmp = ASN1_STRING_TABLE_get(nid))) {
-                tmp = OPENSSL_malloc(sizeof(ASN1_STRING_TABLE));
+                tmp = malloc(sizeof(ASN1_STRING_TABLE));
                 if(!tmp) {
                         ASN1err(ASN1_F_ASN1_STRING_TABLE_ADD,
                                                         ERR_R_MALLOC_FAILURE);
@@ -250,7 +250,7 @@ void ASN1_STRING_TABLE_cleanup(void)
 
 static void st_free(ASN1_STRING_TABLE *tbl)
 {
-        if(tbl->flags & STABLE_FLAGS_MALLOC) OPENSSL_free(tbl);
+        if(tbl->flags & STABLE_FLAGS_MALLOC) free(tbl);
 }
 
 
diff --git a/src/lib/libcrypto/asn1/a_utctm.c b/src/lib/libcrypto/asn1/a_utctm.c
index f2e7de16af..0e7aca90a7 100644
--- a/src/lib/libcrypto/asn1/a_utctm.c
+++ b/src/lib/libcrypto/asn1/a_utctm.c
@@ -203,14 +203,14 @@ ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
         p=(char *)s->data;
         if ((p == NULL) || ((size_t)s->length < len))
                 {
-                p=OPENSSL_malloc(len);
+                p=malloc(len);
                 if (p == NULL)
                         {
                         ASN1err(ASN1_F_ASN1_UTCTIME_ADJ,ERR_R_MALLOC_FAILURE);
                         return(NULL);
                         }
                 if (s->data != NULL)
-                        OPENSSL_free(s->data);
+                        free(s->data);
                 s->data=(unsigned char *)p;
                 }
 
diff --git a/src/lib/libcrypto/asn1/a_verify.c b/src/lib/libcrypto/asn1/a_verify.c
index 5eb47d768c..8eca970be3 100644
--- a/src/lib/libcrypto/asn1/a_verify.c
+++ b/src/lib/libcrypto/asn1/a_verify.c
@@ -154,7 +154,7 @@ int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a,
                 }
 
         OPENSSL_cleanse(buf_in,(unsigned int)inl);
-        OPENSSL_free(buf_in);
+        free(buf_in);
 
         if (EVP_DigestVerifyFinal(&ctx,signature->data,
                         (size_t)signature->length) <= 0)
diff --git a/src/lib/libcrypto/asn1/ameth_lib.c b/src/lib/libcrypto/asn1/ameth_lib.c
index a19e058fca..228392f1e6 100644
--- a/src/lib/libcrypto/asn1/ameth_lib.c
+++ b/src/lib/libcrypto/asn1/ameth_lib.c
@@ -289,7 +289,7 @@ EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags,
                                         const char *pem_str, const char *info)
         {
         EVP_PKEY_ASN1_METHOD *ameth;
-        ameth = OPENSSL_malloc(sizeof(EVP_PKEY_ASN1_METHOD));
+        ameth = malloc(sizeof(EVP_PKEY_ASN1_METHOD));
         if (!ameth)
                 return NULL;
 
@@ -393,10 +393,10 @@ void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
         if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC))
                 {
                 if (ameth->pem_str)
-                        OPENSSL_free(ameth->pem_str);
+                        free(ameth->pem_str);
                 if (ameth->info)
-                        OPENSSL_free(ameth->info);
-                OPENSSL_free(ameth);
+                        free(ameth->info);
+                free(ameth);
                 }
         }
 
diff --git a/src/lib/libcrypto/asn1/asn1_gen.c b/src/lib/libcrypto/asn1/asn1_gen.c
index 81a7a38895..8194beeb30 100644
--- a/src/lib/libcrypto/asn1/asn1_gen.c
+++ b/src/lib/libcrypto/asn1/asn1_gen.c
@@ -226,7 +226,7 @@ ASN1_TYPE *ASN1_generate_v3(char *str, X509V3_CTX *cnf)
 
         /* Allocate buffer for new encoding */
 
-        new_der = OPENSSL_malloc(len);
+        new_der = malloc(len);
         if (!new_der)
                 goto err;
 
@@ -266,9 +266,9 @@ ASN1_TYPE *ASN1_generate_v3(char *str, X509V3_CTX *cnf)
 
         err:
         if (orig_der)
-                OPENSSL_free(orig_der);
+                free(orig_der);
         if (new_der)
-                OPENSSL_free(new_der);
+                free(new_der);
 
         return ret;
 
@@ -499,7 +499,7 @@ static ASN1_TYPE *asn1_multi(int utype, const char *section, X509V3_CTX *cnf)
         bad:
 
         if (der)
-                OPENSSL_free(der);
+                free(der);
 
         if (sk)
                 sk_ASN1_TYPE_pop_free(sk, ASN1_TYPE_free);
diff --git a/src/lib/libcrypto/asn1/asn1_lib.c b/src/lib/libcrypto/asn1/asn1_lib.c
index 4d1d6af18d..7b06b6fdc8 100644
--- a/src/lib/libcrypto/asn1/asn1_lib.c
+++ b/src/lib/libcrypto/asn1/asn1_lib.c
@@ -383,9 +383,9 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
                 {
                 c=str->data;
                 if (c == NULL)
-                        str->data=OPENSSL_malloc(len+1);
+                        str->data=malloc(len+1);
                 else
-                        str->data=OPENSSL_realloc(c,len+1);
+                        str->data=realloc(c,len+1);
 
                 if (str->data == NULL)
                         {
@@ -407,7 +407,7 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
 void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)
         {
         if (str->data)
-                OPENSSL_free(str->data);
+                free(str->data);
         str->data = data;
         str->length = len;
         }
@@ -422,7 +422,7 @@ ASN1_STRING *ASN1_STRING_type_new(int type)
         {
         ASN1_STRING *ret;
 
-        ret=(ASN1_STRING *)OPENSSL_malloc(sizeof(ASN1_STRING));
+        ret=(ASN1_STRING *)malloc(sizeof(ASN1_STRING));
         if (ret == NULL)
                 {
                 ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW,ERR_R_MALLOC_FAILURE);
@@ -439,8 +439,8 @@ void ASN1_STRING_free(ASN1_STRING *a)
         {
         if (a == NULL) return;
         if (a->data && !(a->flags & ASN1_STRING_FLAG_NDEF))
-                OPENSSL_free(a->data);
-        OPENSSL_free(a);
+                free(a->data);
+        free(a);
         }
 
 int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b)
diff --git a/src/lib/libcrypto/asn1/asn1_mac.h b/src/lib/libcrypto/asn1/asn1_mac.h
index c60b197552..ecc2c77228 100644
--- a/src/lib/libcrypto/asn1/asn1_mac.h
+++ b/src/lib/libcrypto/asn1/asn1_mac.h
@@ -289,7 +289,7 @@ err:\
 
 /* New macros */
 #define M_ASN1_New_Malloc(ret,type) \
-        if ((ret=(type *)OPENSSL_malloc(sizeof(type))) == NULL) \
+        if ((ret=(type *)malloc(sizeof(type))) == NULL) \
                 { c.line=__LINE__; goto err2; }
 
 #define M_ASN1_New(arg,func) \
diff --git a/src/lib/libcrypto/asn1/asn_mime.c b/src/lib/libcrypto/asn1/asn_mime.c
index 54a704a969..d94b3cd6f8 100644
--- a/src/lib/libcrypto/asn1/asn_mime.c
+++ b/src/lib/libcrypto/asn1/asn_mime.c
@@ -220,7 +220,7 @@ static int asn1_write_micalg(BIO *out, STACK_OF(X509_ALGOR) *mdalgs)
                         if (rv > 0)
                                 {
                                 BIO_puts(out, micstr);
-                                OPENSSL_free(micstr);
+                                free(micstr);
                                 continue;
                                 }
                         if (rv != -2)
@@ -822,7 +822,7 @@ static MIME_HEADER *mime_hdr_new(char *name, char *value)
                         }
                 }
         } else tmpval = NULL;
-        mhdr = (MIME_HEADER *) OPENSSL_malloc(sizeof(MIME_HEADER));
+        mhdr = (MIME_HEADER *) malloc(sizeof(MIME_HEADER));
         if(!mhdr) return NULL;
         mhdr->name = tmpname;
         mhdr->value = tmpval;
@@ -851,7 +851,7 @@ static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value)
                 if(!tmpval) return 0;
         } else tmpval = NULL;
         /* Parameter values are case sensitive so leave as is */
-        mparam = (MIME_PARAM *) OPENSSL_malloc(sizeof(MIME_PARAM));
+        mparam = (MIME_PARAM *) malloc(sizeof(MIME_PARAM));
         if(!mparam) return 0;
         mparam->param_name = tmpname;
         mparam->param_value = tmpval;
@@ -900,17 +900,17 @@ static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name)
 
 static void mime_hdr_free(MIME_HEADER *hdr)
 {
-        if(hdr->name) OPENSSL_free(hdr->name);
-        if(hdr->value) OPENSSL_free(hdr->value);
+        if(hdr->name) free(hdr->name);
+        if(hdr->value) free(hdr->value);
         if(hdr->params) sk_MIME_PARAM_pop_free(hdr->params, mime_param_free);
-        OPENSSL_free(hdr);
+        free(hdr);
 }
 
 static void mime_param_free(MIME_PARAM *param)
 {
-        if(param->param_name) OPENSSL_free(param->param_name);
-        if(param->param_value) OPENSSL_free(param->param_value);
-        OPENSSL_free(param);
+        if(param->param_name) free(param->param_name);
+        if(param->param_value) free(param->param_value);
+        free(param);
 }
 
 /* Check for a multipart boundary. Returns:
diff --git a/src/lib/libcrypto/asn1/asn_moid.c b/src/lib/libcrypto/asn1/asn_moid.c
index 1ea6a59248..fd04d11459 100644
--- a/src/lib/libcrypto/asn1/asn_moid.c
+++ b/src/lib/libcrypto/asn1/asn_moid.c
@@ -145,7 +145,7 @@ static int do_create(char *value, char *name)
                         p--;
                         }
                 p++;
-                lntmp = OPENSSL_malloc((p - ln) + 1);
+                lntmp = malloc((p - ln) + 1);
                 if (lntmp == NULL)
                         return 0;
                 memcpy(lntmp, ln, p - ln);
diff --git a/src/lib/libcrypto/asn1/asn_pack.c b/src/lib/libcrypto/asn1/asn_pack.c
index 1886508654..13dc5d4665 100644
--- a/src/lib/libcrypto/asn1/asn_pack.c
+++ b/src/lib/libcrypto/asn1/asn_pack.c
@@ -75,7 +75,7 @@ ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_STRING **oct)
         } else octmp = *oct;
 
         if(octmp->data) {
-                OPENSSL_free(octmp->data);
+                free(octmp->data);
                 octmp->data = NULL;
         }
                 
diff --git a/src/lib/libcrypto/asn1/bio_asn1.c b/src/lib/libcrypto/asn1/bio_asn1.c
index dc7efd551c..fa98dba728 100644
--- a/src/lib/libcrypto/asn1/bio_asn1.c
+++ b/src/lib/libcrypto/asn1/bio_asn1.c
@@ -150,7 +150,7 @@ BIO_METHOD *BIO_f_asn1(void)
 static int asn1_bio_new(BIO *b)
         {
         BIO_ASN1_BUF_CTX *ctx;
-        ctx = OPENSSL_malloc(sizeof(BIO_ASN1_BUF_CTX));
+        ctx = malloc(sizeof(BIO_ASN1_BUF_CTX));
         if (!ctx)
                 return 0;
         if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE))
@@ -163,7 +163,7 @@ static int asn1_bio_new(BIO *b)
 
 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
         {
-        ctx->buf = OPENSSL_malloc(size);
+        ctx->buf = malloc(size);
         if (!ctx->buf)
                 return 0;
         ctx->bufsize = size;
@@ -186,8 +186,8 @@ static int asn1_bio_free(BIO *b)
         if (ctx == NULL)
                 return 0;
         if (ctx->buf)
-                OPENSSL_free(ctx->buf);
-        OPENSSL_free(ctx);
+                free(ctx->buf);
+        free(ctx);
         b->init = 0;
         b->ptr = NULL;
         b->flags = 0;
diff --git a/src/lib/libcrypto/asn1/bio_ndef.c b/src/lib/libcrypto/asn1/bio_ndef.c
index b91f97a1b1..60f324bdae 100644
--- a/src/lib/libcrypto/asn1/bio_ndef.c
+++ b/src/lib/libcrypto/asn1/bio_ndef.c
@@ -110,7 +110,7 @@ BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it)
                 ASN1err(ASN1_F_BIO_NEW_NDEF, ASN1_R_STREAMING_NOT_SUPPORTED);
                 return NULL;
                 }
-        ndef_aux = OPENSSL_malloc(sizeof(NDEF_SUPPORT));
+        ndef_aux = malloc(sizeof(NDEF_SUPPORT));
         asn_bio = BIO_new(BIO_f_asn1());
 
         /* ASN1 bio needs to be next to output BIO */
@@ -148,7 +148,7 @@ BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it)
         if (asn_bio)
                 BIO_free(asn_bio);
         if (ndef_aux)
-                OPENSSL_free(ndef_aux);
+                free(ndef_aux);
         return NULL;
         }
 
@@ -164,7 +164,7 @@ static int ndef_prefix(BIO *b, unsigned char **pbuf, int *plen, void *parg)
         ndef_aux = *(NDEF_SUPPORT **)parg;
 
         derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it);
-        p = OPENSSL_malloc(derlen);
+        p = malloc(derlen);
         ndef_aux->derbuf = p;
         *pbuf = p;
         derlen = ASN1_item_ndef_i2d(ndef_aux->val, &p, ndef_aux->it);
@@ -187,7 +187,7 @@ static int ndef_prefix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg)
         ndef_aux = *(NDEF_SUPPORT **)parg;
 
         if (ndef_aux->derbuf)
-                OPENSSL_free(ndef_aux->derbuf);
+                free(ndef_aux->derbuf);
 
         ndef_aux->derbuf = NULL;
         *pbuf = NULL;
@@ -200,7 +200,7 @@ static int ndef_suffix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg)
         NDEF_SUPPORT **pndef_aux = (NDEF_SUPPORT **)parg;
         if (!ndef_prefix_free(b, pbuf, plen, parg))
                 return 0;
-        OPENSSL_free(*pndef_aux);
+        free(*pndef_aux);
         *pndef_aux = NULL;
         return 1;
         }
@@ -229,7 +229,7 @@ static int ndef_suffix(BIO *b, unsigned char **pbuf, int *plen, void *parg)
                 return 0;
 
         derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it);
-        p = OPENSSL_malloc(derlen);
+        p = malloc(derlen);
         ndef_aux->derbuf = p;
         *pbuf = p;
         derlen = ASN1_item_ndef_i2d(ndef_aux->val, &p, ndef_aux->it);
diff --git a/src/lib/libcrypto/asn1/f_enum.c b/src/lib/libcrypto/asn1/f_enum.c
index 56e3cc8df2..caf34ee97e 100644
--- a/src/lib/libcrypto/asn1/f_enum.c
+++ b/src/lib/libcrypto/asn1/f_enum.c
@@ -153,15 +153,15 @@ int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size)
                 if (num+i > slen)
                         {
                         if (s == NULL)
-                                sp=(unsigned char *)OPENSSL_malloc(
+                                sp=(unsigned char *)malloc(
                                         (unsigned int)num+i*2);
                         else
-                                sp=(unsigned char *)OPENSSL_realloc(s,
+                                sp=(unsigned char *)realloc(s,
                                         (unsigned int)num+i*2);
                         if (sp == NULL)
                                 {
                                 ASN1err(ASN1_F_A2I_ASN1_ENUMERATED,ERR_R_MALLOC_FAILURE);
-                                if (s != NULL) OPENSSL_free(s);
+                                if (s != NULL) free(s);
                                 goto err;
                                 }
                         s=sp;
diff --git a/src/lib/libcrypto/asn1/f_int.c b/src/lib/libcrypto/asn1/f_int.c
index 8b92fad9df..977e3d01b7 100644
--- a/src/lib/libcrypto/asn1/f_int.c
+++ b/src/lib/libcrypto/asn1/f_int.c
@@ -157,14 +157,14 @@ int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size)
                 if (num+i > slen)
                         {
                         if (s == NULL)
-                                sp=(unsigned char *)OPENSSL_malloc(
+                                sp=(unsigned char *)malloc(
                                         (unsigned int)num+i*2);
                         else
                                 sp=OPENSSL_realloc_clean(s,slen,num+i*2);
                         if (sp == NULL)
                                 {
                                 ASN1err(ASN1_F_A2I_ASN1_INTEGER,ERR_R_MALLOC_FAILURE);
-                                if (s != NULL) OPENSSL_free(s);
+                                if (s != NULL) free(s);
                                 goto err;
                                 }
                         s=sp;
diff --git a/src/lib/libcrypto/asn1/f_string.c b/src/lib/libcrypto/asn1/f_string.c
index f7d36adac7..f4bee15335 100644
--- a/src/lib/libcrypto/asn1/f_string.c
+++ b/src/lib/libcrypto/asn1/f_string.c
@@ -149,15 +149,15 @@ int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size)
                 if (num+i > slen)
                         {
                         if (s == NULL)
-                                sp=(unsigned char *)OPENSSL_malloc(
+                                sp=(unsigned char *)malloc(
                                         (unsigned int)num+i*2);
                         else
-                                sp=(unsigned char *)OPENSSL_realloc(s,
+                                sp=(unsigned char *)realloc(s,
                                         (unsigned int)num+i*2);
                         if (sp == NULL)
                                 {
                                 ASN1err(ASN1_F_A2I_ASN1_STRING,ERR_R_MALLOC_FAILURE);
-                                if (s != NULL) OPENSSL_free(s);
+                                if (s != NULL) free(s);
                                 goto err;
                                 }
                         s=sp;
diff --git a/src/lib/libcrypto/asn1/n_pkey.c b/src/lib/libcrypto/asn1/n_pkey.c
index e251739933..97647d17e1 100644
--- a/src/lib/libcrypto/asn1/n_pkey.c
+++ b/src/lib/libcrypto/asn1/n_pkey.c
@@ -169,7 +169,7 @@ int i2d_RSA_NET(const RSA *a, unsigned char **pp,
 
 
         /* Since its RC4 encrypted length is actual length */
-        if ((zz=(unsigned char *)OPENSSL_malloc(rsalen)) == NULL)
+        if ((zz=(unsigned char *)malloc(rsalen)) == NULL)
                 {
                 ASN1err(ASN1_F_I2D_RSA_NET,ERR_R_MALLOC_FAILURE);
                 goto err;
@@ -179,7 +179,7 @@ int i2d_RSA_NET(const RSA *a, unsigned char **pp,
         /* Write out private key encoding */
         i2d_RSAPrivateKey(a,&zz);
 
-        if ((zz=OPENSSL_malloc(pkeylen)) == NULL)
+        if ((zz=malloc(pkeylen)) == NULL)
                 {
                 ASN1err(ASN1_F_I2D_RSA_NET,ERR_R_MALLOC_FAILURE);
                 goto err;
diff --git a/src/lib/libcrypto/asn1/p5_pbev2.c b/src/lib/libcrypto/asn1/p5_pbev2.c
index 4ea683036b..2d80334e01 100644
--- a/src/lib/libcrypto/asn1/p5_pbev2.c
+++ b/src/lib/libcrypto/asn1/p5_pbev2.c
@@ -214,7 +214,7 @@ X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
 
         if (!saltlen)
                 saltlen = PKCS5_SALT_LEN;
-        if (!(osalt->data = OPENSSL_malloc (saltlen)))
+        if (!(osalt->data = malloc (saltlen)))
                 goto merr;
 
         osalt->length = saltlen;
diff --git a/src/lib/libcrypto/asn1/t_crl.c b/src/lib/libcrypto/asn1/t_crl.c
index c61169208a..f6550b2b04 100644
--- a/src/lib/libcrypto/asn1/t_crl.c
+++ b/src/lib/libcrypto/asn1/t_crl.c
@@ -97,7 +97,7 @@ int X509_CRL_print(BIO *out, X509_CRL *x)
         X509_signature_print(out, x->sig_alg, NULL);
         p=X509_NAME_oneline(X509_CRL_get_issuer(x),NULL,0);
         BIO_printf(out,"%8sIssuer: %s\n","",p);
-        OPENSSL_free(p);
+        free(p);
         BIO_printf(out,"%8sLast Update: ","");
         ASN1_TIME_print(out,X509_CRL_get_lastUpdate(x));
         BIO_printf(out,"\n%8sNext Update: ","");
diff --git a/src/lib/libcrypto/asn1/t_x509.c b/src/lib/libcrypto/asn1/t_x509.c
index bbf00c7a29..8dfda07b92 100644
--- a/src/lib/libcrypto/asn1/t_x509.c
+++ b/src/lib/libcrypto/asn1/t_x509.c
@@ -239,7 +239,7 @@ int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, unsigned long cflag)
                 }
         ret=1;
 err:
-        if (m != NULL) OPENSSL_free(m);
+        if (m != NULL) free(m);
         return(ret);
         }
 
@@ -256,7 +256,7 @@ int X509_ocspid_print (BIO *bp, X509 *x)
         if (BIO_printf(bp,"        Subject OCSP hash: ") <= 0)
                 goto err;
         derlen = i2d_X509_NAME(x->cert_info->subject, NULL);
-        if ((der = dertmp = (unsigned char *)OPENSSL_malloc (derlen)) == NULL)
+        if ((der = dertmp = (unsigned char *)malloc (derlen)) == NULL)
                 goto err;
         i2d_X509_NAME(x->cert_info->subject, &dertmp);
 
@@ -266,7 +266,7 @@ int X509_ocspid_print (BIO *bp, X509 *x)
                 {
                 if (BIO_printf(bp,"%02X",SHA1md[i]) <= 0) goto err;
                 }
-        OPENSSL_free (der);
+        free (der);
         der=NULL;
 
         /* display the hash of the public key as it would appear
@@ -287,7 +287,7 @@ int X509_ocspid_print (BIO *bp, X509 *x)
 
         return (1);
 err:
-        if (der != NULL) OPENSSL_free(der);
+        if (der != NULL) free(der);
         return(0);
         }
 
@@ -477,7 +477,7 @@ int X509_NAME_print(BIO *bp, X509_NAME *name, int obase)
         b=X509_NAME_oneline(name,NULL,0);
         if (!*b)
                 {
-                OPENSSL_free(b);
+                free(b);
                 return 1;
                 }
         s=b+1; /* skip the first slash */
@@ -513,6 +513,6 @@ int X509_NAME_print(BIO *bp, X509_NAME *name, int obase)
 err:
                 X509err(X509_F_X509_NAME_PRINT,ERR_R_BUF_LIB);
                 }
-        OPENSSL_free(b);
+        free(b);
         return(ret);
         }
diff --git a/src/lib/libcrypto/asn1/tasn_dec.c b/src/lib/libcrypto/asn1/tasn_dec.c
index 87d7dfdf5c..c594db9140 100644
--- a/src/lib/libcrypto/asn1/tasn_dec.c
+++ b/src/lib/libcrypto/asn1/tasn_dec.c
@@ -910,7 +910,7 @@ static int asn1_d2i_ex_primitive(ASN1_VALUE **pval,
         *in = p;
         ret = 1;
         err:
-        if (free_cont && buf.data) OPENSSL_free(buf.data);
+        if (free_cont && buf.data) free(buf.data);
         return ret;
         }
 
@@ -1046,7 +1046,7 @@ int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
                 if (*free_cont)
                         {
                         if (stmp->data)
-                                OPENSSL_free(stmp->data);
+                                free(stmp->data);
                         stmp->data = (unsigned char *)cont; /* UGLY CAST! RL */
                         stmp->length = len;
                         *free_cont = 0;
diff --git a/src/lib/libcrypto/asn1/tasn_enc.c b/src/lib/libcrypto/asn1/tasn_enc.c
index 936ad1f767..9ab0473d73 100644
--- a/src/lib/libcrypto/asn1/tasn_enc.c
+++ b/src/lib/libcrypto/asn1/tasn_enc.c
@@ -110,7 +110,7 @@ static int asn1_item_flags_i2d(ASN1_VALUE *val, unsigned char **out,
                 len = ASN1_item_ex_i2d(&val, NULL, it, -1, flags);
                 if (len <= 0)
                         return len;
-                buf = OPENSSL_malloc(len);
+                buf = malloc(len);
                 if (!buf)
                         return -1;
                 p = buf;
@@ -451,9 +451,9 @@ static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out,
                         do_sort = 0;
                 else
                         {
-                        derlst = OPENSSL_malloc(sk_ASN1_VALUE_num(sk)
+                        derlst = malloc(sk_ASN1_VALUE_num(sk)
                                                 * sizeof(*derlst));
-                        tmpdat = OPENSSL_malloc(skcontlen);
+                        tmpdat = malloc(skcontlen);
                         if (!derlst || !tmpdat)
                                 return 0;
                         }
@@ -496,8 +496,8 @@ static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out,
                                                         i++, tder++)
                         (void)sk_ASN1_VALUE_set(sk, i, tder->field);
                 }
-        OPENSSL_free(derlst);
-        OPENSSL_free(tmpdat);
+        free(derlst);
+        free(tmpdat);
         return 1;
         }
 
diff --git a/src/lib/libcrypto/asn1/tasn_fre.c b/src/lib/libcrypto/asn1/tasn_fre.c
index 77d3092d31..b04034ba4c 100644
--- a/src/lib/libcrypto/asn1/tasn_fre.c
+++ b/src/lib/libcrypto/asn1/tasn_fre.c
@@ -126,7 +126,7 @@ static void asn1_item_combine_free(ASN1_VALUE **pval, const ASN1_ITEM *it, int c
                         asn1_cb(ASN1_OP_FREE_POST, pval, it, NULL);
                 if (!combine)
                         {
-                        OPENSSL_free(*pval);
+                        free(*pval);
                         *pval = NULL;
                         }
                 break;
@@ -173,7 +173,7 @@ static void asn1_item_combine_free(ASN1_VALUE **pval, const ASN1_ITEM *it, int c
                         asn1_cb(ASN1_OP_FREE_POST, pval, it, NULL);
                 if (!combine)
                         {
-                        OPENSSL_free(*pval);
+                        free(*pval);
                         *pval = NULL;
                         }
                 break;
@@ -254,7 +254,7 @@ void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
 
                 case V_ASN1_ANY:
                 ASN1_primitive_free(pval, NULL);
-                OPENSSL_free(*pval);
+                free(*pval);
                 break;
 
                 default:
diff --git a/src/lib/libcrypto/asn1/tasn_new.c b/src/lib/libcrypto/asn1/tasn_new.c
index 0d9e78cc7c..aab9ef08c4 100644
--- a/src/lib/libcrypto/asn1/tasn_new.c
+++ b/src/lib/libcrypto/asn1/tasn_new.c
@@ -160,7 +160,7 @@ static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
                         }
                 if (!combine)
                         {
-                        *pval = OPENSSL_malloc(it->size);
+                        *pval = malloc(it->size);
                         if (!*pval)
                                 goto memerr;
                         memset(*pval, 0, it->size);
@@ -188,7 +188,7 @@ static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
                         }
                 if (!combine)
                         {
-                        *pval = OPENSSL_malloc(it->size);
+                        *pval = malloc(it->size);
                         if (!*pval)
                                 goto memerr;
                         memset(*pval, 0, it->size);
@@ -354,7 +354,7 @@ int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
                 return 1;
 
                 case V_ASN1_ANY:
-                typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
+                typ = malloc(sizeof(ASN1_TYPE));
                 if (!typ)
                         return 0;
                 typ->value.ptr = NULL;
diff --git a/src/lib/libcrypto/asn1/tasn_prn.c b/src/lib/libcrypto/asn1/tasn_prn.c
index 542a091a66..ec524edac8 100644
--- a/src/lib/libcrypto/asn1/tasn_prn.c
+++ b/src/lib/libcrypto/asn1/tasn_prn.c
@@ -85,7 +85,7 @@ ASN1_PCTX default_pctx =
 ASN1_PCTX *ASN1_PCTX_new(void)
         {
         ASN1_PCTX *ret;
-        ret = OPENSSL_malloc(sizeof(ASN1_PCTX));
+        ret = malloc(sizeof(ASN1_PCTX));
         if (ret == NULL)
                 {
                 ASN1err(ASN1_F_ASN1_PCTX_NEW, ERR_R_MALLOC_FAILURE);
@@ -101,7 +101,7 @@ ASN1_PCTX *ASN1_PCTX_new(void)
 
 void ASN1_PCTX_free(ASN1_PCTX *p)
         {
-        OPENSSL_free(p);
+        free(p);
         }
 
 unsigned long ASN1_PCTX_get_flags(ASN1_PCTX *p)
@@ -480,7 +480,7 @@ static int asn1_print_integer_ctx(BIO *out, ASN1_INTEGER *str,
         s = i2s_ASN1_INTEGER(NULL, str);
         if (BIO_puts(out, s) <= 0)
                 ret = 0;
-        OPENSSL_free(s);
+        free(s);
         return ret;
         }
 
diff --git a/src/lib/libcrypto/asn1/tasn_utl.c b/src/lib/libcrypto/asn1/tasn_utl.c
index ca9ec7a32f..dfa63fb2bc 100644
--- a/src/lib/libcrypto/asn1/tasn_utl.c
+++ b/src/lib/libcrypto/asn1/tasn_utl.c
@@ -155,7 +155,7 @@ void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
         if (enc)
                 {
                 if (enc->enc)
-                        OPENSSL_free(enc->enc);
+                        free(enc->enc);
                 enc->enc = NULL;
                 enc->len = 0;
                 enc->modified = 1;
@@ -171,8 +171,8 @@ int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
                 return 1;
 
         if (enc->enc)
-                OPENSSL_free(enc->enc);
-        enc->enc = OPENSSL_malloc(inlen);
+                free(enc->enc);
+        enc->enc = malloc(inlen);
         if (!enc->enc)
                 return 0;
         memcpy(enc->enc, in, inlen);
diff --git a/src/lib/libcrypto/asn1/x_crl.c b/src/lib/libcrypto/asn1/x_crl.c
index c51c690ba9..cf7e69aaaf 100644
--- a/src/lib/libcrypto/asn1/x_crl.c
+++ b/src/lib/libcrypto/asn1/x_crl.c
@@ -493,7 +493,7 @@ X509_CRL_METHOD *X509_CRL_METHOD_new(
         int (*crl_verify)(X509_CRL *crl, EVP_PKEY *pk))
         {
         X509_CRL_METHOD *m;
-        m = OPENSSL_malloc(sizeof(X509_CRL_METHOD));
+        m = malloc(sizeof(X509_CRL_METHOD));
         if (!m)
                 return NULL;
         m->crl_init = crl_init;
@@ -508,7 +508,7 @@ void X509_CRL_METHOD_free(X509_CRL_METHOD *m)
         {
         if (!(m->flags & X509_CRL_METHOD_DYNAMIC))
                 return;
-        OPENSSL_free(m);
+        free(m);
         }
 
 void X509_CRL_set_meth_data(X509_CRL *crl, void *dat)
diff --git a/src/lib/libcrypto/asn1/x_info.c b/src/lib/libcrypto/asn1/x_info.c
index d44f6cdb01..c13fad056f 100644
--- a/src/lib/libcrypto/asn1/x_info.c
+++ b/src/lib/libcrypto/asn1/x_info.c
@@ -66,7 +66,7 @@ X509_INFO *X509_INFO_new(void)
         {
         X509_INFO *ret=NULL;
 
-        ret=(X509_INFO *)OPENSSL_malloc(sizeof(X509_INFO));
+        ret=(X509_INFO *)malloc(sizeof(X509_INFO));
         if (ret == NULL)
                 {
                 ASN1err(ASN1_F_X509_INFO_NEW,ERR_R_MALLOC_FAILURE);
@@ -106,8 +106,8 @@ void X509_INFO_free(X509_INFO *x)
         if (x->x509 != NULL) X509_free(x->x509);
         if (x->crl != NULL) X509_CRL_free(x->crl);
         if (x->x_pkey != NULL) X509_PKEY_free(x->x_pkey);
-        if (x->enc_data != NULL) OPENSSL_free(x->enc_data);
-        OPENSSL_free(x);
+        if (x->enc_data != NULL) free(x->enc_data);
+        free(x);
         }
 
 IMPLEMENT_STACK_OF(X509_INFO)
diff --git a/src/lib/libcrypto/asn1/x_name.c b/src/lib/libcrypto/asn1/x_name.c
index d7c2318693..e14d329639 100644
--- a/src/lib/libcrypto/asn1/x_name.c
+++ b/src/lib/libcrypto/asn1/x_name.c
@@ -132,7 +132,7 @@ IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME)
 static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it)
 {
         X509_NAME *ret = NULL;
-        ret = OPENSSL_malloc(sizeof(X509_NAME));
+        ret = malloc(sizeof(X509_NAME));
         if(!ret) goto memerr;
         if ((ret->entries=sk_X509_NAME_ENTRY_new_null()) == NULL)
                 goto memerr;
@@ -149,7 +149,7 @@ static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it)
                 {
                 if (ret->entries)
                         sk_X509_NAME_ENTRY_free(ret->entries);
-                OPENSSL_free(ret);
+                free(ret);
                 }
         return 0;
 }
@@ -164,8 +164,8 @@ static void x509_name_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
         BUF_MEM_free(a->bytes);
         sk_X509_NAME_ENTRY_pop_free(a->entries,X509_NAME_ENTRY_free);
         if (a->canon_enc)
-                OPENSSL_free(a->canon_enc);
-        OPENSSL_free(a);
+                free(a->canon_enc);
+        free(a);
         *pval = NULL;
 }
 
@@ -325,7 +325,7 @@ static int x509_name_canon(X509_NAME *a)
 
         if (a->canon_enc)
                 {
-                OPENSSL_free(a->canon_enc);
+                free(a->canon_enc);
                 a->canon_enc = NULL;
                 }
         /* Special case: empty X509_NAME => null encoding */
@@ -362,7 +362,7 @@ static int x509_name_canon(X509_NAME *a)
 
         a->canon_enclen = i2d_name_canon(intname, NULL);
 
-        p = OPENSSL_malloc(a->canon_enclen);
+        p = malloc(a->canon_enclen);
 
         if (!p)
                 goto err;
diff --git a/src/lib/libcrypto/asn1/x_pkey.c b/src/lib/libcrypto/asn1/x_pkey.c
index 8453618426..3bf2f5e915 100644
--- a/src/lib/libcrypto/asn1/x_pkey.c
+++ b/src/lib/libcrypto/asn1/x_pkey.c
@@ -146,6 +146,6 @@ void X509_PKEY_free(X509_PKEY *x)
         if (x->enc_algor != NULL) X509_ALGOR_free(x->enc_algor);
         if (x->enc_pkey != NULL) M_ASN1_OCTET_STRING_free(x->enc_pkey);
         if (x->dec_pkey != NULL)EVP_PKEY_free(x->dec_pkey);
-        if ((x->key_data != NULL) && (x->key_free)) OPENSSL_free(x->key_data);
-        OPENSSL_free(x);
+        if ((x->key_data != NULL) && (x->key_free)) free(x->key_data);
+        free(x);
         }
diff --git a/src/lib/libcrypto/asn1/x_pubkey.c b/src/lib/libcrypto/asn1/x_pubkey.c
index b649e1fcf9..684f40899f 100644
--- a/src/lib/libcrypto/asn1/x_pubkey.c
+++ b/src/lib/libcrypto/asn1/x_pubkey.c
@@ -357,7 +357,7 @@ int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
         if (penc)
                 {
                 if (pub->public_key->data)
-                        OPENSSL_free(pub->public_key->data);
+                        free(pub->public_key->data);
                 pub->public_key->data = penc;
                 pub->public_key->length = penclen;
                 /* Set number of unused bits to zero */
diff --git a/src/lib/libcrypto/asn1/x_x509.c b/src/lib/libcrypto/asn1/x_x509.c
index de3df9eb51..5734f2b069 100644
--- a/src/lib/libcrypto/asn1/x_x509.c
+++ b/src/lib/libcrypto/asn1/x_x509.c
@@ -105,7 +105,7 @@ static int x509_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
                 break;
 
                 case ASN1_OP_D2I_POST:
-                if (ret->name != NULL) OPENSSL_free(ret->name);
+                if (ret->name != NULL) free(ret->name);
                 ret->name=X509_NAME_oneline(ret->cert_info->subject,NULL,0);
                 break;
 
@@ -123,7 +123,7 @@ static int x509_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
                 ASIdentifiers_free(ret->rfc3779_asid);
 #endif
 
-                if (ret->name != NULL) OPENSSL_free(ret->name);
+                if (ret->name != NULL) free(ret->name);
                 break;
 
         }