5 files changed, 160 insertions, 72 deletions

diff --git a/src/lib/libcrypto/asn1/a_gentm.c b/src/lib/libcrypto/asn1/a_gentm.c
index 226474f057..cd09f68b38 100644
--- a/src/lib/libcrypto/asn1/a_gentm.c
+++ b/src/lib/libcrypto/asn1/a_gentm.c
@@ -61,8 +61,11 @@
 #include <stdio.h>
 #include <time.h>
 #include "cryptlib.h"
+#include "o_time.h"
 #include <openssl/asn1.h>
 
+#if 0
+
 int i2d_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME *a, unsigned char **pp)
         {
 #ifdef CHARSET_EBCDIC
@@ -106,10 +109,12 @@ ASN1_GENERALIZEDTIME *d2i_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME **a,
         return(ret);
 err:
         if ((ret != NULL) && ((a == NULL) || (*a != ret)))
-                ASN1_GENERALIZEDTIME_free(ret);
+                M_ASN1_GENERALIZEDTIME_free(ret);
         return(NULL);
         }
 
+#endif
+
 int ASN1_GENERALIZEDTIME_check(ASN1_GENERALIZEDTIME *d)
         {
         static int min[9]={ 0, 0, 1, 1, 0, 0, 0, 0, 0};
@@ -141,6 +146,19 @@ int ASN1_GENERALIZEDTIME_check(ASN1_GENERALIZEDTIME *d)
 
                 if ((n < min[i]) || (n > max[i])) goto err;
                 }
+        /* Optional fractional seconds: decimal point followed by one
+         * or more digits.
+         */
+        if (a[o] == '.')
+                {
+                if (++o > l) goto err;
+                i = o;
+                while ((a[o] >= '0') && (a[o] <= '9') && (o <= l))
+                        o++;
+                /* Must have at least one digit after decimal point */
+                if (i == o) goto err;
+                }
+
         if (a[o] == 'Z')
                 o++;
         else if ((a[o] == '+') || (a[o] == '-'))
@@ -176,6 +194,7 @@ int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, char *str)
                         {
                         ASN1_STRING_set((ASN1_STRING *)s,
                                 (unsigned char *)str,t.length);
+                        s->type=V_ASN1_GENERALIZEDTIME;
                         }
                 return(1);
                 }
@@ -188,28 +207,24 @@ ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
         {
         char *p;
         struct tm *ts;
-#if defined(THREADS) && !defined(WIN32)
         struct tm data;
-#endif
 
         if (s == NULL)
-                s=ASN1_GENERALIZEDTIME_new();
+                s=M_ASN1_GENERALIZEDTIME_new();
         if (s == NULL)
                 return(NULL);
 
-#if defined(THREADS) && !defined(WIN32)
-        gmtime_r(&t,&data); /* should return &data, but doesn't on some systems, so we don't even look at the return value */
-        ts=&data;
-#else
-        ts=gmtime(&t);
-#endif
+        ts=OPENSSL_gmtime(&t, &data);
+        if (ts == NULL)
+                return(NULL);
+
         p=(char *)s->data;
         if ((p == NULL) || (s->length < 16))
                 {
-                p=Malloc(20);
+                p=OPENSSL_malloc(20);
                 if (p == NULL) return(NULL);
                 if (s->data != NULL)
-                        Free(s->data);
+                        OPENSSL_free(s->data);
                 s->data=(unsigned char *)p;
                 }
 
diff --git a/src/lib/libcrypto/asn1/a_hdr.c b/src/lib/libcrypto/asn1/a_hdr.c
index 4fb7a5fa75..b1aad81f77 100644
--- a/src/lib/libcrypto/asn1/a_hdr.c
+++ b/src/lib/libcrypto/asn1/a_hdr.c
@@ -58,19 +58,10 @@
 
 #include <stdio.h>
 #include "cryptlib.h"
-#include "asn1_mac.h"
-#include "asn1.h"
+#include <openssl/asn1_mac.h>
+#include <openssl/asn1.h>
 
-/*
- * ASN1err(ASN1_F_D2I_ASN1_HEADER,ASN1_R_LENGTH_MISMATCH);
- * ASN1err(ASN1_F_I2D_ASN1_HEADER,ASN1_R_BAD_GET_OBJECT);
- * ASN1err(ASN1_F_I2D_ASN1_HEADER,ASN1_R_BAD_GET_OBJECT);
- * ASN1err(ASN1_F_ASN1_HEADER_NEW,ASN1_R_BAD_GET_OBJECT);
- */
-
-int i2d_ASN1_HEADER(a,pp)
-ASN1_HEADER *a;
-unsigned char **pp;
+int i2d_ASN1_HEADER(ASN1_HEADER *a, unsigned char **pp)
         {
         M_ASN1_I2D_vars(a);
 
@@ -85,10 +76,8 @@ unsigned char **pp;
         M_ASN1_I2D_finish();
         }
 
-ASN1_HEADER *d2i_ASN1_HEADER(a,pp,length)
-ASN1_HEADER **a;
-unsigned char **pp;
-long length;
+ASN1_HEADER *d2i_ASN1_HEADER(ASN1_HEADER **a, unsigned char **pp,
+             long length)
         {
         M_ASN1_D2I_vars(a,ASN1_HEADER *,ASN1_HEADER_new);
 
@@ -107,24 +96,24 @@ long length;
         M_ASN1_D2I_Finish(a,ASN1_HEADER_free,ASN1_F_D2I_ASN1_HEADER);
         }
 
-ASN1_HEADER *ASN1_HEADER_new()
+ASN1_HEADER *ASN1_HEADER_new(void)
         {
         ASN1_HEADER *ret=NULL;
+        ASN1_CTX c;
 
         M_ASN1_New_Malloc(ret,ASN1_HEADER);
-        M_ASN1_New(ret->header,ASN1_OCTET_STRING_new);
+        M_ASN1_New(ret->header,M_ASN1_OCTET_STRING_new);
         ret->meth=NULL;
         ret->data=NULL;
         return(ret);
         M_ASN1_New_Error(ASN1_F_ASN1_HEADER_NEW);
         }
 
-void ASN1_HEADER_free(a)
-ASN1_HEADER *a;
+void ASN1_HEADER_free(ASN1_HEADER *a)
         {
         if (a == NULL) return;
-        ASN1_OCTET_STRING_free(a->header);
+        M_ASN1_OCTET_STRING_free(a->header);
         if (a->meth != NULL)
                 a->meth->destroy(a->data);
-        Free((char *)a);
+        OPENSSL_free(a);
         }
diff --git a/src/lib/libcrypto/asn1/a_meth.c b/src/lib/libcrypto/asn1/a_meth.c
index 513625c305..63158e9cab 100644
--- a/src/lib/libcrypto/asn1/a_meth.c
+++ b/src/lib/libcrypto/asn1/a_meth.c
@@ -58,8 +58,8 @@
 
 #include <stdio.h>
 #include "cryptlib.h"
-#include "buffer.h"
-#include "x509.h"
+#include <openssl/buffer.h>
+#include <openssl/asn1.h>
 
 static  ASN1_METHOD ia5string_meth={
         (int (*)())     i2d_ASN1_IA5STRING,
@@ -73,12 +73,12 @@ static  ASN1_METHOD bit_string_meth={
         (char *(*)())   ASN1_STRING_new,
         (void (*)())    ASN1_STRING_free};
 
-ASN1_METHOD *ASN1_IA5STRING_asn1_meth()
+ASN1_METHOD *ASN1_IA5STRING_asn1_meth(void)
         {
         return(&ia5string_meth);
         }
 
-ASN1_METHOD *ASN1_BIT_STRING_asn1_meth()
+ASN1_METHOD *ASN1_BIT_STRING_asn1_meth(void)
         {
         return(&bit_string_meth);
         }
diff --git a/src/lib/libcrypto/asn1/a_utctm.c b/src/lib/libcrypto/asn1/a_utctm.c
index 17a7abbb67..ed2d827db2 100644
--- a/src/lib/libcrypto/asn1/a_utctm.c
+++ b/src/lib/libcrypto/asn1/a_utctm.c
@@ -59,25 +59,31 @@
 #include <stdio.h>
 #include <time.h>
 #include "cryptlib.h"
-#include "asn1.h"
+#include "o_time.h"
+#include <openssl/asn1.h>
 
-/* ASN1err(ASN1_F_ASN1_UTCTIME_NEW,ASN1_R_UTCTIME_TOO_LONG);
- * ASN1err(ASN1_F_D2I_ASN1_UTCTIME,ASN1_R_EXPECTING_A_UTCTIME);
- */
-
-int i2d_ASN1_UTCTIME(a,pp)
-ASN1_UTCTIME *a;
-unsigned char **pp;
+#if 0
+int i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **pp)
         {
+#ifndef CHARSET_EBCDIC
         return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
                 V_ASN1_UTCTIME,V_ASN1_UNIVERSAL));
+#else
+        /* KLUDGE! We convert to ascii before writing DER */
+        int len;
+        char tmp[24];
+        ASN1_STRING x = *(ASN1_STRING *)a;
+
+        len = x.length;
+        ebcdic2ascii(tmp, x.data, (len >= sizeof tmp) ? sizeof tmp : len);
+        x.data = tmp;
+        return i2d_ASN1_bytes(&x, pp, V_ASN1_UTCTIME,V_ASN1_UNIVERSAL);
+#endif
         }
 
 
-ASN1_UTCTIME *d2i_ASN1_UTCTIME(a, pp, length)
-ASN1_UTCTIME **a;
-unsigned char **pp;
-long length;
+ASN1_UTCTIME *d2i_ASN1_UTCTIME(ASN1_UTCTIME **a, unsigned char **pp,
+             long length)
         {
         ASN1_UTCTIME *ret=NULL;
 
@@ -85,9 +91,12 @@ long length;
                 V_ASN1_UTCTIME,V_ASN1_UNIVERSAL);
         if (ret == NULL)
                 {
-                ASN1err(ASN1_F_D2I_ASN1_UTCTIME,ASN1_R_ERROR_STACK);
+                ASN1err(ASN1_F_D2I_ASN1_UTCTIME,ERR_R_NESTED_ASN1_ERROR);
                 return(NULL);
                 }
+#ifdef CHARSET_EBCDIC
+        ascii2ebcdic(ret->data, ret->data, ret->length);
+#endif
         if (!ASN1_UTCTIME_check(ret))
                 {
                 ASN1err(ASN1_F_D2I_ASN1_UTCTIME,ASN1_R_INVALID_TIME_FORMAT);
@@ -97,12 +106,13 @@ long length;
         return(ret);
 err:
         if ((ret != NULL) && ((a == NULL) || (*a != ret)))
-                ASN1_UTCTIME_free(ret);
+                M_ASN1_UTCTIME_free(ret);
         return(NULL);
         }
 
-int ASN1_UTCTIME_check(d)
-ASN1_UTCTIME *d;
+#endif
+
+int ASN1_UTCTIME_check(ASN1_UTCTIME *d)
         {
         static int min[8]={ 0, 1, 1, 0, 0, 0, 0, 0};
         static int max[8]={99,12,31,23,59,59,12,59};
@@ -152,9 +162,7 @@ err:
         return(0);
         }
 
-int ASN1_UTCTIME_set_string(s,str)
-ASN1_UTCTIME *s;
-char *str;
+int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, char *str)
         {
         ASN1_UTCTIME t;
 
@@ -167,6 +175,7 @@ char *str;
                         {
                         ASN1_STRING_set((ASN1_STRING *)s,
                                 (unsigned char *)str,t.length);
+                        s->type = V_ASN1_UTCTIME;
                         }
                 return(1);
                 }
@@ -174,33 +183,28 @@ char *str;
                 return(0);
         }
 
-ASN1_UTCTIME *ASN1_UTCTIME_set(s, t)
-ASN1_UTCTIME *s;
-time_t t;
+ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
         {
         char *p;
         struct tm *ts;
-#if defined(THREADS)
         struct tm data;
-#endif
 
         if (s == NULL)
-                s=ASN1_UTCTIME_new();
+                s=M_ASN1_UTCTIME_new();
         if (s == NULL)
                 return(NULL);
 
-#if defined(THREADS)
-        ts=(struct tm *)gmtime_r(&t,&data);
-#else
-        ts=(struct tm *)gmtime(&t);
-#endif
+        ts=OPENSSL_gmtime(&t, &data);
+        if (ts == NULL)
+                return(NULL);
+
         p=(char *)s->data;
         if ((p == NULL) || (s->length < 14))
                 {
-                p=Malloc(20);
+                p=OPENSSL_malloc(20);
                 if (p == NULL) return(NULL);
                 if (s->data != NULL)
-                        Free(s->data);
+                        OPENSSL_free(s->data);
                 s->data=(unsigned char *)p;
                 }
 
@@ -208,5 +212,85 @@ time_t t;
                 ts->tm_mon+1,ts->tm_mday,ts->tm_hour,ts->tm_min,ts->tm_sec);
         s->length=strlen(p);
         s->type=V_ASN1_UTCTIME;
+#ifdef CHARSET_EBCDIC_not
+        ebcdic2ascii(s->data, s->data, s->length);
+#endif
         return(s);
         }
+
+
+int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t)
+        {
+        struct tm *tm;
+        int offset;
+        int year;
+
+#define g2(p) (((p)[0]-'0')*10+(p)[1]-'0')
+
+        if (s->data[12] == 'Z')
+                offset=0;
+        else
+                {
+                offset = g2(s->data+13)*60+g2(s->data+15);
+                if (s->data[12] == '-')
+                        offset = -offset;
+                }
+
+        t -= offset*60; /* FIXME: may overflow in extreme cases */
+
+        { struct tm data; tm = OPENSSL_gmtime(&t, &data); }
+        
+#define return_cmp(a,b) if ((a)<(b)) return -1; else if ((a)>(b)) return 1
+        year = g2(s->data);
+        if (year < 50)
+                year += 100;
+        return_cmp(year,              tm->tm_year);
+        return_cmp(g2(s->data+2) - 1, tm->tm_mon);
+        return_cmp(g2(s->data+4),     tm->tm_mday);
+        return_cmp(g2(s->data+6),     tm->tm_hour);
+        return_cmp(g2(s->data+8),     tm->tm_min);
+        return_cmp(g2(s->data+10),    tm->tm_sec);
+#undef g2
+#undef return_cmp
+
+        return 0;
+        }
+
+
+#if 0
+time_t ASN1_UTCTIME_get(const ASN1_UTCTIME *s)
+        {
+        struct tm tm;
+        int offset;
+
+        memset(&tm,'\0',sizeof tm);
+
+#define g2(p) (((p)[0]-'0')*10+(p)[1]-'0')
+        tm.tm_year=g2(s->data);
+        if(tm.tm_year < 50)
+                tm.tm_year+=100;
+        tm.tm_mon=g2(s->data+2)-1;
+        tm.tm_mday=g2(s->data+4);
+        tm.tm_hour=g2(s->data+6);
+        tm.tm_min=g2(s->data+8);
+        tm.tm_sec=g2(s->data+10);
+        if(s->data[12] == 'Z')
+                offset=0;
+        else
+                {
+                offset=g2(s->data+13)*60+g2(s->data+15);
+                if(s->data[12] == '-')
+                        offset= -offset;
+                }
+#undef g2
+
+        return mktime(&tm)-offset*60; /* FIXME: mktime assumes the current timezone
+                                       * instead of UTC, and unless we rewrite OpenSSL
+                                       * in Lisp we cannot locally change the timezone
+                                       * without possibly interfering with other parts
+                                       * of the program. timegm, which uses UTC, is
+                                       * non-standard.
+                                       * Also time_t is inappropriate for general
+                                       * UTC times because it may a 32 bit type. */
+        }
+#endif
diff --git a/src/lib/libcrypto/asn1/p8_key.c b/src/lib/libcrypto/asn1/p8_key.c
index 0b24374627..3a31248e14 100644
--- a/src/lib/libcrypto/asn1/p8_key.c
+++ b/src/lib/libcrypto/asn1/p8_key.c
@@ -94,7 +94,7 @@ X509 *X509_KEY_new(void)
         {
         X509_KEY *ret=NULL;
 
-        M_ASN1_New_Malloc(ret,X509_KEY);
+        M_ASN1_New_OPENSSL_malloc(ret,X509_KEY);
         ret->references=1;
         ret->type=NID
         M_ASN1_New(ret->cert_info,X509_CINF_new);
@@ -126,6 +126,6 @@ void X509_KEY_free(X509 *a)
         X509_CINF_free(a->cert_info);
         X509_ALGOR_free(a->sig_alg);
         ASN1_BIT_STRING_free(a->signature);
-        Free(a);
+        OPENSSL_free(a);
         }