resolve conflicts

21 files changed, 191 insertions, 86 deletions

diff --git a/src/lib/libcrypto/asn1/a_bitstr.c b/src/lib/libcrypto/asn1/a_bitstr.c
index f4ea96cd54..b81bf4fc81 100644
--- a/src/lib/libcrypto/asn1/a_bitstr.c
+++ b/src/lib/libcrypto/asn1/a_bitstr.c
@@ -194,8 +194,12 @@ int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
                         c=(unsigned char *)OPENSSL_realloc_clean(a->data,
                                                                  a->length,
                                                                  w+1);
-                if (c == NULL) return(0);
-                if (w+1-a->length > 0) memset(c+a->length, 0, w+1-a->length);
+                if (c == NULL)
+                        {
+                        ASN1err(ASN1_F_ASN1_BIT_STRING_SET_BIT,ERR_R_MALLOC_FAILURE);
+                        return 0;
+                        }
+                if (w+1-a->length > 0) memset(c+a->length, 0, w+1-a->length);
                 a->data=c;
                 a->length=w+1;
         }
diff --git a/src/lib/libcrypto/asn1/a_digest.c b/src/lib/libcrypto/asn1/a_digest.c
index 4931e222a0..7182e9fa5d 100644
--- a/src/lib/libcrypto/asn1/a_digest.c
+++ b/src/lib/libcrypto/asn1/a_digest.c
@@ -65,6 +65,7 @@
 # include <sys/types.h>
 #endif
 
+#include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/buffer.h>
 #include <openssl/x509.h>
@@ -78,7 +79,11 @@ int ASN1_digest(int (*i2d)(), const EVP_MD *type, char *data,
         unsigned char *str,*p;
 
         i=i2d(data,NULL);
-        if ((str=(unsigned char *)OPENSSL_malloc(i)) == NULL) return(0);
+        if ((str=(unsigned char *)OPENSSL_malloc(i)) == NULL)
+                {
+                ASN1err(ASN1_F_ASN1_DIGEST,ERR_R_MALLOC_FAILURE);
+                return(0);
+                }
         p=str;
         i2d(data,&p);
 
diff --git a/src/lib/libcrypto/asn1/a_enum.c b/src/lib/libcrypto/asn1/a_enum.c
index ad8f0ffd1a..03ede68d1c 100644
--- a/src/lib/libcrypto/asn1/a_enum.c
+++ b/src/lib/libcrypto/asn1/a_enum.c
@@ -156,7 +156,7 @@ ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(BIGNUM *bn, ASN1_ENUMERATED *ai)
                 unsigned char *new_data=OPENSSL_realloc(ret->data, len+4);
                 if (!new_data)
                         {
-                        ASN1err(ASN1_F_BN_TO_ASN1_INTEGER,ERR_R_MALLOC_FAILURE);
+                        ASN1err(ASN1_F_BN_TO_ASN1_ENUMERATED,ERR_R_MALLOC_FAILURE);
                         goto err;
                         }
                 ret->data=new_data;
diff --git a/src/lib/libcrypto/asn1/a_gentm.c b/src/lib/libcrypto/asn1/a_gentm.c
index 8581007868..0dfd576211 100644
--- a/src/lib/libcrypto/asn1/a_gentm.c
+++ b/src/lib/libcrypto/asn1/a_gentm.c
@@ -192,8 +192,9 @@ int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, char *str)
                 {
                 if (s != NULL)
                         {
-                        ASN1_STRING_set((ASN1_STRING *)s,
-                                (unsigned char *)str,t.length);
+                        if (!ASN1_STRING_set((ASN1_STRING *)s,
+                                (unsigned char *)str,t.length))
+                                return 0;
                         s->type=V_ASN1_GENERALIZEDTIME;
                         }
                 return(1);
@@ -223,7 +224,12 @@ ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
         if ((p == NULL) || ((size_t)s->length < len))
                 {
                 p=OPENSSL_malloc(len);
-                if (p == NULL) return(NULL);
+                if (p == NULL)
+                        {
+                        ASN1err(ASN1_F_ASN1_GENERALIZEDTIME_SET,
+                                ERR_R_MALLOC_FAILURE);
+                        return(NULL);
+                        }
                 if (s->data != NULL)
                         OPENSSL_free(s->data);
                 s->data=(unsigned char *)p;
diff --git a/src/lib/libcrypto/asn1/a_int.c b/src/lib/libcrypto/asn1/a_int.c
index edb243c021..21cc64bb23 100644
--- a/src/lib/libcrypto/asn1/a_int.c
+++ b/src/lib/libcrypto/asn1/a_int.c
@@ -64,7 +64,26 @@ ASN1_INTEGER *ASN1_INTEGER_dup(ASN1_INTEGER *x)
 { return M_ASN1_INTEGER_dup(x);}
 
 int ASN1_INTEGER_cmp(ASN1_INTEGER *x, ASN1_INTEGER *y)
-{ return M_ASN1_INTEGER_cmp(x,y);}
+        { 
+        int neg, ret;
+        /* Compare signs */
+        neg = x->type & V_ASN1_NEG;
+        if (neg != (y->type & V_ASN1_NEG))
+                {
+                if (neg)
+                        return -1;
+                else
+                        return 1;
+                }
+
+        ret = ASN1_STRING_cmp(x, y);
+
+        if (neg)
+                return -ret;
+        else
+                return ret;
+        }
+        
 
 /* 
  * This converts an ASN1 INTEGER into its content encoding.
diff --git a/src/lib/libcrypto/asn1/a_print.c b/src/lib/libcrypto/asn1/a_print.c
index 8035513f04..d18e772320 100644
--- a/src/lib/libcrypto/asn1/a_print.c
+++ b/src/lib/libcrypto/asn1/a_print.c
@@ -60,7 +60,7 @@
 #include "cryptlib.h"
 #include <openssl/asn1.h>
 
-int ASN1_PRINTABLE_type(unsigned char *s, int len)
+int ASN1_PRINTABLE_type(const unsigned char *s, int len)
         {
         int c;
         int ia5=0;
diff --git a/src/lib/libcrypto/asn1/a_set.c b/src/lib/libcrypto/asn1/a_set.c
index 0f839822ff..e24061c545 100644
--- a/src/lib/libcrypto/asn1/a_set.c
+++ b/src/lib/libcrypto/asn1/a_set.c
@@ -118,8 +118,13 @@ int i2d_ASN1_SET(STACK *a, unsigned char **pp, int (*func)(), int ex_tag,
                 }
 
         pStart  = p; /* Catch the beg of Setblobs*/
-        if (!(rgSetBlob = (MYBLOB *)OPENSSL_malloc( sk_num(a) * sizeof(MYBLOB)))) return 0; /* In this array
-we will store the SET blobs */
+                /* In this array we will store the SET blobs */
+                rgSetBlob = (MYBLOB *)OPENSSL_malloc(sk_num(a) * sizeof(MYBLOB));
+                if (rgSetBlob == NULL)
+                        {
+                        ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE);
+                        return(0);
+                        }
 
         for (i=0; i<sk_num(a); i++)
                 {
@@ -135,7 +140,11 @@ SetBlob
  /* Now we have to sort the blobs. I am using a simple algo.
     *Sort ptrs *Copy to temp-mem *Copy from temp-mem to user-mem*/
         qsort( rgSetBlob, sk_num(a), sizeof(MYBLOB), SetBlobCmp);
-        if (!(pTempMem = OPENSSL_malloc(totSize))) return 0;
+                if (!(pTempMem = OPENSSL_malloc(totSize)))
+                        {
+                        ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE);
+                        return(0);
+                        }
 
 /* Copy to temp mem */
         p = pTempMem;
@@ -160,7 +169,13 @@ STACK *d2i_ASN1_SET(STACK **a, unsigned char **pp, long length,
         STACK *ret=NULL;
 
         if ((a == NULL) || ((*a) == NULL))
-                { if ((ret=sk_new_null()) == NULL) goto err; }
+                {
+                if ((ret=sk_new_null()) == NULL)
+                        {
+                        ASN1err(ASN1_F_D2I_ASN1_SET,ERR_R_MALLOC_FAILURE);
+                        goto err;
+                        }
+                }
         else
                 ret=(*a);
 
diff --git a/src/lib/libcrypto/asn1/a_strex.c b/src/lib/libcrypto/asn1/a_strex.c
index bde666a6ff..a07122ba47 100644
--- a/src/lib/libcrypto/asn1/a_strex.c
+++ b/src/lib/libcrypto/asn1/a_strex.c
@@ -3,7 +3,7 @@
  * project 2000.
  */
 /* ====================================================================
- * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 2000-2004 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -553,7 +553,12 @@ int ASN1_STRING_to_UTF8(unsigned char **out, ASN1_STRING *in)
         if((type < 0) || (type > 30)) return -1;
         mbflag = tag2nbyte[type];
         if(mbflag == -1) return -1;
-        mbflag |= MBSTRING_FLAG;
+        if (mbflag == 0)
+                mbflag = MBSTRING_UTF8;
+        else if (mbflag == 4)
+                mbflag = MBSTRING_UNIV;
+        else            
+                mbflag |= MBSTRING_FLAG;
         stmp.data = NULL;
         ret = ASN1_mbstring_copy(&str, in->data, in->length, mbflag, B_ASN1_UTF8STRING);
         if(ret < 0) return ret;
diff --git a/src/lib/libcrypto/asn1/a_type.c b/src/lib/libcrypto/asn1/a_type.c
index fe3fcd40b0..2292d49b93 100644
--- a/src/lib/libcrypto/asn1/a_type.c
+++ b/src/lib/libcrypto/asn1/a_type.c
@@ -71,7 +71,10 @@ int ASN1_TYPE_get(ASN1_TYPE *a)
 void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value)
         {
         if (a->value.ptr != NULL)
-                ASN1_primitive_free((ASN1_VALUE **)&a, NULL);
+                {
+                ASN1_TYPE **tmp_a = &a;
+                ASN1_primitive_free((ASN1_VALUE **)tmp_a, NULL);
+                }
         a->type=type;
         a->value.ptr=value;
         }
diff --git a/src/lib/libcrypto/asn1/a_utctm.c b/src/lib/libcrypto/asn1/a_utctm.c
index 999852dae5..7b25fed331 100644
--- a/src/lib/libcrypto/asn1/a_utctm.c
+++ b/src/lib/libcrypto/asn1/a_utctm.c
@@ -173,8 +173,9 @@ int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, char *str)
                 {
                 if (s != NULL)
                         {
-                        ASN1_STRING_set((ASN1_STRING *)s,
-                                (unsigned char *)str,t.length);
+                        if (!ASN1_STRING_set((ASN1_STRING *)s,
+                                (unsigned char *)str,t.length))
+                                return 0;
                         s->type = V_ASN1_UTCTIME;
                         }
                 return(1);
@@ -203,7 +204,11 @@ ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
         if ((p == NULL) || ((size_t)s->length < len))
                 {
                 p=OPENSSL_malloc(len);
-                if (p == NULL) return(NULL);
+                if (p == NULL)
+                        {
+                        ASN1err(ASN1_F_ASN1_UTCTIME_SET,ERR_R_MALLOC_FAILURE);
+                        return(NULL);
+                        }
                 if (s->data != NULL)
                         OPENSSL_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 da2a0a6d69..18ef0acf00 100644
--- a/src/lib/libcrypto/asn1/a_verify.c
+++ b/src/lib/libcrypto/asn1/a_verify.c
@@ -142,6 +142,13 @@ int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a, ASN1_BIT_STRING *signat
                 goto err;
                 }
 
+        if (!EVP_VerifyInit_ex(&ctx,type, NULL))
+                {
+                ASN1err(ASN1_F_ASN1_VERIFY,ERR_R_EVP_LIB);
+                ret=0;
+                goto err;
+                }
+
         inl = ASN1_item_i2d(asn, &buf_in, it);
         
         if (buf_in == NULL)
@@ -150,7 +157,6 @@ int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a, ASN1_BIT_STRING *signat
                 goto err;
                 }
 
-        EVP_VerifyInit_ex(&ctx,type, NULL);
         EVP_VerifyUpdate(&ctx,(unsigned char *)buf_in,inl);
 
         OPENSSL_cleanse(buf_in,(unsigned int)inl);
diff --git a/src/lib/libcrypto/asn1/asn1.h b/src/lib/libcrypto/asn1/asn1.h
index 3414509f1b..ceaeb4cbe3 100644
--- a/src/lib/libcrypto/asn1/asn1.h
+++ b/src/lib/libcrypto/asn1/asn1.h
@@ -829,7 +829,7 @@ BIGNUM *ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED *ai,BIGNUM *bn);
 
 /* General */
 /* given a string, return the correct type, max is the maximum length */
-int ASN1_PRINTABLE_type(unsigned char *s, int max);
+int ASN1_PRINTABLE_type(const unsigned char *s, int max);
 
 int i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass);
 ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, unsigned char **pp,
@@ -950,16 +950,19 @@ void ERR_load_ASN1_strings(void);
 #define ASN1_F_A2I_ASN1_ENUMERATED                       101
 #define ASN1_F_A2I_ASN1_INTEGER                          102
 #define ASN1_F_A2I_ASN1_STRING                           103
+#define ASN1_F_ASN1_BIT_STRING_SET_BIT                   176
 #define ASN1_F_ASN1_CHECK_TLEN                           104
 #define ASN1_F_ASN1_COLLATE_PRIMITIVE                    105
 #define ASN1_F_ASN1_COLLECT                              106
 #define ASN1_F_ASN1_D2I_BIO                              107
 #define ASN1_F_ASN1_D2I_EX_PRIMITIVE                     108
 #define ASN1_F_ASN1_D2I_FP                               109
+#define ASN1_F_ASN1_DIGEST                               177
 #define ASN1_F_ASN1_DO_ADB                               110
 #define ASN1_F_ASN1_DUP                                  111
 #define ASN1_F_ASN1_ENUMERATED_SET                       112
 #define ASN1_F_ASN1_ENUMERATED_TO_BN                     113
+#define ASN1_F_ASN1_GENERALIZEDTIME_SET                  178
 #define ASN1_F_ASN1_GET_OBJECT                           114
 #define ASN1_F_ASN1_HEADER_NEW                           115
 #define ASN1_F_ASN1_I2D_BIO                              116
@@ -975,6 +978,7 @@ void ERR_load_ASN1_strings(void);
 #define ASN1_F_ASN1_SEQ_PACK                             126
 #define ASN1_F_ASN1_SEQ_UNPACK                           127
 #define ASN1_F_ASN1_SIGN                                 128
+#define ASN1_F_ASN1_STRING_SET                           179
 #define ASN1_F_ASN1_STRING_TABLE_ADD                     129
 #define ASN1_F_ASN1_STRING_TYPE_NEW                      130
 #define ASN1_F_ASN1_TEMPLATE_D2I                         131
@@ -984,6 +988,7 @@ void ERR_load_ASN1_strings(void);
 #define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING             134
 #define ASN1_F_ASN1_TYPE_GET_OCTETSTRING                 135
 #define ASN1_F_ASN1_UNPACK_STRING                        136
+#define ASN1_F_ASN1_UTCTIME_SET                          180
 #define ASN1_F_ASN1_VERIFY                               137
 #define ASN1_F_BN_TO_ASN1_ENUMERATED                     138
 #define ASN1_F_BN_TO_ASN1_INTEGER                        139
@@ -1007,6 +1012,7 @@ void ERR_load_ASN1_strings(void);
 #define ASN1_F_D2I_X509_CINF                             157
 #define ASN1_F_D2I_X509_NAME                             158
 #define ASN1_F_D2I_X509_PKEY                             159
+#define ASN1_F_I2D_ASN1_SET                              181
 #define ASN1_F_I2D_ASN1_TIME                             160
 #define ASN1_F_I2D_DSA_PUBKEY                            161
 #define ASN1_F_I2D_NETSCAPE_RSA                          162
diff --git a/src/lib/libcrypto/asn1/asn1_err.c b/src/lib/libcrypto/asn1/asn1_err.c
index 094ec06fda..3b57c8fbae 100644
--- a/src/lib/libcrypto/asn1/asn1_err.c
+++ b/src/lib/libcrypto/asn1/asn1_err.c
@@ -1,6 +1,6 @@
 /* crypto/asn1/asn1_err.c */
 /* ====================================================================
- * Copyright (c) 1999-2002 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1999-2004 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -70,16 +70,19 @@ static ERR_STRING_DATA ASN1_str_functs[]=
 {ERR_PACK(0,ASN1_F_A2I_ASN1_ENUMERATED,0),      "a2i_ASN1_ENUMERATED"},
 {ERR_PACK(0,ASN1_F_A2I_ASN1_INTEGER,0), "a2i_ASN1_INTEGER"},
 {ERR_PACK(0,ASN1_F_A2I_ASN1_STRING,0),  "a2i_ASN1_STRING"},
+{ERR_PACK(0,ASN1_F_ASN1_BIT_STRING_SET_BIT,0),  "ASN1_BIT_STRING_set_bit"},
 {ERR_PACK(0,ASN1_F_ASN1_CHECK_TLEN,0),  "ASN1_CHECK_TLEN"},
 {ERR_PACK(0,ASN1_F_ASN1_COLLATE_PRIMITIVE,0),   "ASN1_COLLATE_PRIMITIVE"},
 {ERR_PACK(0,ASN1_F_ASN1_COLLECT,0),     "ASN1_COLLECT"},
 {ERR_PACK(0,ASN1_F_ASN1_D2I_BIO,0),     "ASN1_d2i_bio"},
 {ERR_PACK(0,ASN1_F_ASN1_D2I_EX_PRIMITIVE,0),    "ASN1_D2I_EX_PRIMITIVE"},
 {ERR_PACK(0,ASN1_F_ASN1_D2I_FP,0),      "ASN1_d2i_fp"},
+{ERR_PACK(0,ASN1_F_ASN1_DIGEST,0),      "ASN1_digest"},
 {ERR_PACK(0,ASN1_F_ASN1_DO_ADB,0),      "ASN1_DO_ADB"},
 {ERR_PACK(0,ASN1_F_ASN1_DUP,0), "ASN1_dup"},
 {ERR_PACK(0,ASN1_F_ASN1_ENUMERATED_SET,0),      "ASN1_ENUMERATED_set"},
 {ERR_PACK(0,ASN1_F_ASN1_ENUMERATED_TO_BN,0),    "ASN1_ENUMERATED_to_BN"},
+{ERR_PACK(0,ASN1_F_ASN1_GENERALIZEDTIME_SET,0), "ASN1_GENERALIZEDTIME_set"},
 {ERR_PACK(0,ASN1_F_ASN1_GET_OBJECT,0),  "ASN1_get_object"},
 {ERR_PACK(0,ASN1_F_ASN1_HEADER_NEW,0),  "ASN1_HEADER_new"},
 {ERR_PACK(0,ASN1_F_ASN1_I2D_BIO,0),     "ASN1_i2d_bio"},
@@ -95,6 +98,7 @@ static ERR_STRING_DATA ASN1_str_functs[]=
 {ERR_PACK(0,ASN1_F_ASN1_SEQ_PACK,0),    "ASN1_seq_pack"},
 {ERR_PACK(0,ASN1_F_ASN1_SEQ_UNPACK,0),  "ASN1_seq_unpack"},
 {ERR_PACK(0,ASN1_F_ASN1_SIGN,0),        "ASN1_sign"},
+{ERR_PACK(0,ASN1_F_ASN1_STRING_SET,0),  "ASN1_STRING_set"},
 {ERR_PACK(0,ASN1_F_ASN1_STRING_TABLE_ADD,0),    "ASN1_STRING_TABLE_add"},
 {ERR_PACK(0,ASN1_F_ASN1_STRING_TYPE_NEW,0),     "ASN1_STRING_type_new"},
 {ERR_PACK(0,ASN1_F_ASN1_TEMPLATE_D2I,0),        "ASN1_TEMPLATE_D2I"},
@@ -104,6 +108,7 @@ static ERR_STRING_DATA ASN1_str_functs[]=
 {ERR_PACK(0,ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING,0),    "ASN1_TYPE_get_int_octetstring"},
 {ERR_PACK(0,ASN1_F_ASN1_TYPE_GET_OCTETSTRING,0),        "ASN1_TYPE_get_octetstring"},
 {ERR_PACK(0,ASN1_F_ASN1_UNPACK_STRING,0),       "ASN1_unpack_string"},
+{ERR_PACK(0,ASN1_F_ASN1_UTCTIME_SET,0), "ASN1_UTCTIME_set"},
 {ERR_PACK(0,ASN1_F_ASN1_VERIFY,0),      "ASN1_verify"},
 {ERR_PACK(0,ASN1_F_BN_TO_ASN1_ENUMERATED,0),    "BN_to_ASN1_ENUMERATED"},
 {ERR_PACK(0,ASN1_F_BN_TO_ASN1_INTEGER,0),       "BN_to_ASN1_INTEGER"},
@@ -127,6 +132,7 @@ static ERR_STRING_DATA ASN1_str_functs[]=
 {ERR_PACK(0,ASN1_F_D2I_X509_CINF,0),    "D2I_X509_CINF"},
 {ERR_PACK(0,ASN1_F_D2I_X509_NAME,0),    "D2I_X509_NAME"},
 {ERR_PACK(0,ASN1_F_D2I_X509_PKEY,0),    "d2i_X509_PKEY"},
+{ERR_PACK(0,ASN1_F_I2D_ASN1_SET,0),     "i2d_ASN1_SET"},
 {ERR_PACK(0,ASN1_F_I2D_ASN1_TIME,0),    "I2D_ASN1_TIME"},
 {ERR_PACK(0,ASN1_F_I2D_DSA_PUBKEY,0),   "i2d_DSA_PUBKEY"},
 {ERR_PACK(0,ASN1_F_I2D_NETSCAPE_RSA,0), "i2d_Netscape_RSA"},
diff --git a/src/lib/libcrypto/asn1/asn1_lib.c b/src/lib/libcrypto/asn1/asn1_lib.c
index a74f1368d3..97b9b35f4b 100644
--- a/src/lib/libcrypto/asn1/asn1_lib.c
+++ b/src/lib/libcrypto/asn1/asn1_lib.c
@@ -349,6 +349,7 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
 
                 if (str->data == NULL)
                         {
+                        ASN1err(ASN1_F_ASN1_STRING_SET,ERR_R_MALLOC_FAILURE);
                         str->data=c;
                         return(0);
                         }
diff --git a/src/lib/libcrypto/asn1/evp_asn1.c b/src/lib/libcrypto/asn1/evp_asn1.c
index 3506005a71..f92ce6cb5d 100644
--- a/src/lib/libcrypto/asn1/evp_asn1.c
+++ b/src/lib/libcrypto/asn1/evp_asn1.c
@@ -115,7 +115,11 @@ int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, unsigned char *data,
 
         if ((osp=ASN1_STRING_new()) == NULL) return(0);
         /* Grow the 'string' */
-        ASN1_STRING_set(osp,NULL,size);
+        if (!ASN1_STRING_set(osp,NULL,size))
+                {
+                ASN1_STRING_free(osp);
+                return(0);
+                }
 
         M_ASN1_STRING_length_set(osp, size);
         p=M_ASN1_STRING_data(osp);
diff --git a/src/lib/libcrypto/asn1/p5_pbe.c b/src/lib/libcrypto/asn1/p5_pbe.c
index 891150638e..ec788267e0 100644
--- a/src/lib/libcrypto/asn1/p5_pbe.c
+++ b/src/lib/libcrypto/asn1/p5_pbe.c
@@ -76,47 +76,55 @@ IMPLEMENT_ASN1_FUNCTIONS(PBEPARAM)
 X509_ALGOR *PKCS5_pbe_set(int alg, int iter, unsigned char *salt,
              int saltlen)
 {
-        PBEPARAM *pbe;
+        PBEPARAM *pbe=NULL;
         ASN1_OBJECT *al;
         X509_ALGOR *algor;
-        ASN1_TYPE *astype;
+        ASN1_TYPE *astype=NULL;
 
         if (!(pbe = PBEPARAM_new ())) {
                 ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
-                return NULL;
+                goto err;
         }
         if(iter <= 0) iter = PKCS5_DEFAULT_ITER;
-        ASN1_INTEGER_set (pbe->iter, iter);
+        if (!ASN1_INTEGER_set(pbe->iter, iter)) {
+                ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
+                goto err;
+        }
         if (!saltlen) saltlen = PKCS5_SALT_LEN;
         if (!(pbe->salt->data = OPENSSL_malloc (saltlen))) {
                 ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
-                return NULL;
+                goto err;
         }
         pbe->salt->length = saltlen;
         if (salt) memcpy (pbe->salt->data, salt, saltlen);
         else if (RAND_pseudo_bytes (pbe->salt->data, saltlen) < 0)
-                return NULL;
+                goto err;
 
         if (!(astype = ASN1_TYPE_new())) {
                 ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
-                return NULL;
+                goto err;
         }
 
         astype->type = V_ASN1_SEQUENCE;
         if(!ASN1_pack_string(pbe, i2d_PBEPARAM, &astype->value.sequence)) {
                 ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
-                return NULL;
+                goto err;
         }
         PBEPARAM_free (pbe);
+        pbe = NULL;
         
         al = OBJ_nid2obj(alg); /* never need to free al */
         if (!(algor = X509_ALGOR_new())) {
                 ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
-                return NULL;
+                goto err;
         }
         ASN1_OBJECT_free(algor->algorithm);
         algor->algorithm = al;
         algor->parameter = astype;
 
         return (algor);
+err:
+        if (pbe != NULL) PBEPARAM_free(pbe);
+        if (astype != NULL) ASN1_TYPE_free(astype);
+        return NULL;
 }
diff --git a/src/lib/libcrypto/asn1/p5_pbev2.c b/src/lib/libcrypto/asn1/p5_pbev2.c
index 91e1c8987d..e0dc0ec4ee 100644
--- a/src/lib/libcrypto/asn1/p5_pbev2.c
+++ b/src/lib/libcrypto/asn1/p5_pbev2.c
@@ -1,6 +1,6 @@
 /* p5_pbev2.c */
 /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
- * project 1999.
+ * project 1999-2004.
  */
 /* ====================================================================
  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
@@ -113,7 +113,8 @@ X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
         if(!(scheme->parameter = ASN1_TYPE_new())) goto merr;
 
         /* Create random IV */
-        if (RAND_pseudo_bytes(iv, EVP_CIPHER_iv_length(cipher)) < 0)
+        if (EVP_CIPHER_iv_length(cipher) &&
+                RAND_pseudo_bytes(iv, EVP_CIPHER_iv_length(cipher)) < 0)
                 goto err;
 
         EVP_CIPHER_CTX_init(&ctx);
@@ -123,6 +124,7 @@ X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
         if(EVP_CIPHER_param_to_asn1(&ctx, scheme->parameter) < 0) {
                 ASN1err(ASN1_F_PKCS5_PBE2_SET,
                                         ASN1_R_ERROR_SETTING_CIPHER_PARAMS);
+                EVP_CIPHER_CTX_cleanup(&ctx);
                 goto err;
         }
         EVP_CIPHER_CTX_cleanup(&ctx);
diff --git a/src/lib/libcrypto/asn1/t_bitst.c b/src/lib/libcrypto/asn1/t_bitst.c
index 8ee789f082..397332d9b8 100644
--- a/src/lib/libcrypto/asn1/t_bitst.c
+++ b/src/lib/libcrypto/asn1/t_bitst.c
@@ -84,7 +84,10 @@ int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, char *name, int value,
         int bitnum;
         bitnum = ASN1_BIT_STRING_num_asc(name, tbl);
         if(bitnum < 0) return 0;
-        if(bs) ASN1_BIT_STRING_set_bit(bs, bitnum, value);
+        if(bs) {
+                if(!ASN1_BIT_STRING_set_bit(bs, bitnum, value))
+                        return 0;
+        }
         return 1;
 }
 
diff --git a/src/lib/libcrypto/asn1/x_crl.c b/src/lib/libcrypto/asn1/x_crl.c
index 11fce96825..b99f8fc522 100644
--- a/src/lib/libcrypto/asn1/x_crl.c
+++ b/src/lib/libcrypto/asn1/x_crl.c
@@ -63,8 +63,6 @@
 
 static int X509_REVOKED_cmp(const X509_REVOKED * const *a,
                                 const X509_REVOKED * const *b);
-static int X509_REVOKED_seq_cmp(const X509_REVOKED * const *a,
-                                const X509_REVOKED * const *b);
 
 ASN1_SEQUENCE(X509_REVOKED) = {
         ASN1_SIMPLE(X509_REVOKED,serialNumber, ASN1_INTEGER),
@@ -72,43 +70,28 @@ ASN1_SEQUENCE(X509_REVOKED) = {
         ASN1_SEQUENCE_OF_OPT(X509_REVOKED,extensions, X509_EXTENSION)
 } ASN1_SEQUENCE_END(X509_REVOKED)
 
-/* The X509_CRL_INFO structure needs a bit of customisation. This is actually
- * mirroring the old behaviour: its purpose is to allow the use of
- * sk_X509_REVOKED_find to lookup revoked certificates. Unfortunately
- * this will zap the original order and the signature so we keep a copy
- * of the original positions and reorder appropriately before encoding.
- *
- * Might want to see if there's a better way of doing this later...
+/* The X509_CRL_INFO structure needs a bit of customisation.
+ * Since we cache the original encoding the signature wont be affected by
+ * reordering of the revoked field.
  */
 static int crl_inf_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it)
 {
         X509_CRL_INFO *a = (X509_CRL_INFO *)*pval;
-        int i;
-        int (*old_cmp)(const X509_REVOKED * const *,
-                        const X509_REVOKED * const *);
 
         if(!a || !a->revoked) return 1;
         switch(operation) {
-
-                /* Save original order */
+                /* Just set cmp function here. We don't sort because that
+                 * would affect the output of X509_CRL_print().
+                 */
                 case ASN1_OP_D2I_POST:
-                for (i=0; i<sk_X509_REVOKED_num(a->revoked); i++)
-                        sk_X509_REVOKED_value(a->revoked,i)->sequence=i;
                 sk_X509_REVOKED_set_cmp_func(a->revoked,X509_REVOKED_cmp);
                 break;
-
-                /* Restore original order */
-                case ASN1_OP_I2D_PRE:
-                old_cmp=sk_X509_REVOKED_set_cmp_func(a->revoked,X509_REVOKED_seq_cmp);
-                sk_X509_REVOKED_sort(a->revoked);
-                sk_X509_REVOKED_set_cmp_func(a->revoked,old_cmp);
-                break;
         }
         return 1;
 }
 
 
-ASN1_SEQUENCE_cb(X509_CRL_INFO, crl_inf_cb) = {
+ASN1_SEQUENCE_enc(X509_CRL_INFO, enc, crl_inf_cb) = {
         ASN1_OPT(X509_CRL_INFO, version, ASN1_INTEGER),
         ASN1_SIMPLE(X509_CRL_INFO, sig_alg, X509_ALGOR),
         ASN1_SIMPLE(X509_CRL_INFO, issuer, X509_NAME),
@@ -116,7 +99,7 @@ ASN1_SEQUENCE_cb(X509_CRL_INFO, crl_inf_cb) = {
         ASN1_OPT(X509_CRL_INFO, nextUpdate, ASN1_TIME),
         ASN1_SEQUENCE_OF_OPT(X509_CRL_INFO, revoked, X509_REVOKED),
         ASN1_EXP_SEQUENCE_OF_OPT(X509_CRL_INFO, extensions, X509_EXTENSION, 0)
-} ASN1_SEQUENCE_END_cb(X509_CRL_INFO, X509_CRL_INFO)
+} ASN1_SEQUENCE_END_enc(X509_CRL_INFO, X509_CRL_INFO)
 
 ASN1_SEQUENCE_ref(X509_CRL, 0, CRYPTO_LOCK_X509_CRL) = {
         ASN1_SIMPLE(X509_CRL, crl, X509_CRL_INFO),
@@ -137,12 +120,6 @@ static int X509_REVOKED_cmp(const X509_REVOKED * const *a,
                 (ASN1_STRING *)(*b)->serialNumber));
         }
 
-static int X509_REVOKED_seq_cmp(const X509_REVOKED * const *a,
-                                const X509_REVOKED * const *b)
-        {
-        return((*a)->sequence-(*b)->sequence);
-        }
-
 int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
 {
         X509_CRL_INFO *inf;
@@ -153,6 +130,7 @@ int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
                 ASN1err(ASN1_F_X509_CRL_ADD0_REVOKED, ERR_R_MALLOC_FAILURE);
                 return 0;
         }
+        inf->enc.modified = 1;
         return 1;
 }
 
diff --git a/src/lib/libcrypto/asn1/x_name.c b/src/lib/libcrypto/asn1/x_name.c
index caece0f158..31f3377b64 100644
--- a/src/lib/libcrypto/asn1/x_name.c
+++ b/src/lib/libcrypto/asn1/x_name.c
@@ -160,21 +160,22 @@ static int x509_name_ex_d2i(ASN1_VALUE **val, unsigned char **in, long len, cons
                                         int tag, int aclass, char opt, ASN1_TLC *ctx)
 {
         unsigned char *p = *in, *q;
-        STACK *intname = NULL;
+        STACK *intname = NULL, **intname_pp = &intname;
         int i, j, ret;
-        X509_NAME *nm = NULL;
+        X509_NAME *nm = NULL, **nm_pp = &nm;
         STACK_OF(X509_NAME_ENTRY) *entries;
         X509_NAME_ENTRY *entry;
         q = p;
 
         /* Get internal representation of Name */
-        ret = ASN1_item_ex_d2i((ASN1_VALUE **)&intname, &p, len, ASN1_ITEM_rptr(X509_NAME_INTERNAL),
-                                                                tag, aclass, opt, ctx);
+        ret = ASN1_item_ex_d2i((ASN1_VALUE **)intname_pp,
+                               &p, len, ASN1_ITEM_rptr(X509_NAME_INTERNAL),
+                               tag, aclass, opt, ctx);
         
         if(ret <= 0) return ret;
 
         if(*val) x509_name_ex_free(val, NULL);
-        if(!x509_name_ex_new((ASN1_VALUE **)&nm, NULL)) goto err;
+        if(!x509_name_ex_new((ASN1_VALUE **)nm_pp, NULL)) goto err;
         /* We've decoded it: now cache encoding */
         if(!BUF_MEM_grow(nm->bytes, p - q)) goto err;
         memcpy(nm->bytes->data, q, p - q);
@@ -218,7 +219,7 @@ static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out, const ASN1_IT
 
 static int x509_name_encode(X509_NAME *a)
 {
-        STACK *intname = NULL;
+        STACK *intname = NULL, **intname_pp = &intname;
         int len;
         unsigned char *p;
         STACK_OF(X509_NAME_ENTRY) *entries = NULL;
@@ -236,10 +237,12 @@ static int x509_name_encode(X509_NAME *a)
                 }
                 if(!sk_X509_NAME_ENTRY_push(entries, entry)) goto memerr;
         }
-        len = ASN1_item_ex_i2d((ASN1_VALUE **)&intname, NULL, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
+        len = ASN1_item_ex_i2d((ASN1_VALUE **)intname_pp, NULL,
+                               ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
         if (!BUF_MEM_grow(a->bytes,len)) goto memerr;
         p=(unsigned char *)a->bytes->data;
-        ASN1_item_ex_i2d((ASN1_VALUE **)&intname, &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
+        ASN1_item_ex_i2d((ASN1_VALUE **)intname_pp,
+                         &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
         sk_pop_free(intname, sk_internal_free);
         a->modified = 0;
         return len;
diff --git a/src/lib/libcrypto/asn1/x_pubkey.c b/src/lib/libcrypto/asn1/x_pubkey.c
index d958540120..7d6d71af88 100644
--- a/src/lib/libcrypto/asn1/x_pubkey.c
+++ b/src/lib/libcrypto/asn1/x_pubkey.c
@@ -80,8 +80,7 @@ IMPLEMENT_ASN1_FUNCTIONS(X509_PUBKEY)
 
 int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
         {
-        int ok=0;
-        X509_PUBKEY *pk;
+        X509_PUBKEY *pk=NULL;
         X509_ALGOR *a;
         ASN1_OBJECT *o;
         unsigned char *s,*p = NULL;
@@ -104,7 +103,11 @@ int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
                         (a->parameter->type != V_ASN1_NULL))
                         {
                         ASN1_TYPE_free(a->parameter);
-                        a->parameter=ASN1_TYPE_new();
+                        if (!(a->parameter=ASN1_TYPE_new()))
+                                {
+                                X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
+                                goto err;
+                                }
                         a->parameter->type=V_ASN1_NULL;
                         }
                 }
@@ -118,14 +121,34 @@ int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
                 dsa=pkey->pkey.dsa;
                 dsa->write_params=0;
                 ASN1_TYPE_free(a->parameter);
-                i=i2d_DSAparams(dsa,NULL);
-                if ((p=(unsigned char *)OPENSSL_malloc(i)) == NULL) goto err;
+                if ((i=i2d_DSAparams(dsa,NULL)) <= 0)
+                        goto err;
+                if (!(p=(unsigned char *)OPENSSL_malloc(i)))
+                        {
+                        X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
+                        goto err;
+                        }
                 pp=p;
                 i2d_DSAparams(dsa,&pp);
-                a->parameter=ASN1_TYPE_new();
+                if (!(a->parameter=ASN1_TYPE_new()))
+                        {
+                        OPENSSL_free(p);
+                        X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
+                        goto err;
+                        }
                 a->parameter->type=V_ASN1_SEQUENCE;
-                a->parameter->value.sequence=ASN1_STRING_new();
-                ASN1_STRING_set(a->parameter->value.sequence,p,i);
+                if (!(a->parameter->value.sequence=ASN1_STRING_new()))
+                        {
+                        OPENSSL_free(p);
+                        X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
+                        goto err;
+                        }
+                if (!ASN1_STRING_set(a->parameter->value.sequence,p,i))
+                        {
+                        OPENSSL_free(p);
+                        X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
+                        goto err;
+                        }
                 OPENSSL_free(p);
                 }
         else
@@ -143,7 +166,11 @@ int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
                 }
         p=s;
         i2d_PublicKey(pkey,&p);
-        if (!M_ASN1_BIT_STRING_set(pk->public_key,s,i)) goto err;
+        if (!M_ASN1_BIT_STRING_set(pk->public_key,s,i))
+                {
+                X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
+                goto err;
+                }
         /* Set number of unused bits to zero */
         pk->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);
         pk->public_key->flags|=ASN1_STRING_FLAG_BITS_LEFT;
@@ -159,12 +186,11 @@ int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
                 X509_PUBKEY_free(*x);
 
         *x=pk;
-        pk=NULL;
 
-        ok=1;
+        return 1;
 err:
         if (pk != NULL) X509_PUBKEY_free(pk);
-        return(ok);
+        return 0;
         }
 
 EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key)