Commit cf37aaa3 authored by Todd Short's avatar Todd Short Committed by Pauli
Browse files

Consolidate to a single asn1_time_from_tm() function 



Add missing ASN1_TIME functions

Do some cleanup of the ASN1_TIME code.
Add ASN1_TIME_normalize() to normalize ASN1_TIME structures.
Add ASN1_TIME_compare() to compare two ASN1_TIME structures.
Add ASN1_TIME_cmp_time_t() to compare an ASN1_TIME to time_t
(generic version of ASN1_UTCTIME_cmp_time_t()).

Replace '0' .. '9' compares with isdigit()

Reviewed-by: default avatarPaul Dale <paul.dale@oracle.com>
Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/2753)
parent 2326bba0

crypto/asn1/a_gentm.c

+12 −45
Original line number Diff line number Diff line
@@ -13,10 +13,12 @@ 


#include <stdio.h>

#include <time.h>

#include <ctype.h>

#include "internal/cryptlib.h"

#include <openssl/asn1.h>

#include "asn1_locl.h"



/* This is the primary function used to parse ASN1_GENERALIZEDTIME */

int asn1_generalizedtime_to_tm(struct tm *tm, const ASN1_GENERALIZEDTIME *d)

{

    /* wrapper around asn1_time_to_tm */
@@ -39,15 +41,13 @@ int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str) 
    t.data = (unsigned char *)str;

    t.flags = 0;



    if (ASN1_GENERALIZEDTIME_check(&t)) {

        if (s != NULL) {

            if (!ASN1_STRING_set((ASN1_STRING *)s, str, t.length))

    if (!ASN1_GENERALIZEDTIME_check(&t))

        return 0;

            s->type = V_ASN1_GENERALIZEDTIME;

        }

        return 1;

    }



    if (s != NULL && !ASN1_STRING_copy(s, &t))

        return 0;



    return 1;

}



ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
@@ -60,52 +60,19 @@ ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, 
                                               time_t t, int offset_day,

                                               long offset_sec)

{

    char *p;

    struct tm *ts;

    struct tm data;

    const size_t len = 20;

    ASN1_GENERALIZEDTIME *tmps = NULL;



    if (s == NULL)

        tmps = ASN1_GENERALIZEDTIME_new();

    else

        tmps = s;

    if (tmps == NULL)

        return NULL;



    ts = OPENSSL_gmtime(&t, &data);

    if (ts == NULL)

        goto err;

        return NULL;



    if (offset_day || offset_sec) {

        if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))

            goto err;

    }



    p = (char *)tmps->data;

    if ((p == NULL) || ((size_t)tmps->length < len)) {

        p = OPENSSL_malloc(len);

        if (p == NULL) {

            ASN1err(ASN1_F_ASN1_GENERALIZEDTIME_ADJ, ERR_R_MALLOC_FAILURE);

            goto err;

        }

        OPENSSL_free(tmps->data);

        tmps->data = (unsigned char *)p;

            return NULL;

    }



    tmps->length = BIO_snprintf(p, len, "%04d%02d%02d%02d%02d%02dZ",

                                ts->tm_year + 1900, ts->tm_mon + 1,

                                ts->tm_mday, ts->tm_hour, ts->tm_min,

                                ts->tm_sec);

    tmps->type = V_ASN1_GENERALIZEDTIME;

#ifdef CHARSET_EBCDIC_not

    ebcdic2ascii(tmps->data, tmps->data, tmps->length);

#endif

    return tmps;

 err:

    if (s == NULL)

        ASN1_GENERALIZEDTIME_free(tmps);

    return NULL;

    return asn1_time_from_tm(s, ts, V_ASN1_GENERALIZEDTIME);

}



int ASN1_GENERALIZEDTIME_print(BIO *bp, const ASN1_GENERALIZEDTIME *tm)

crypto/asn1/a_object.c

+2 −1
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ 


#include <stdio.h>

#include <limits.h>

#include <ctype.h>

#include "internal/cryptlib.h"

#include <openssl/buffer.h>

#include <openssl/asn1.h>
@@ -84,7 +85,7 @@ int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num) 
            c = *(p++);

            if ((c == ' ') || (c == '.'))

                break;

            if ((c < '0') || (c > '9')) {

            if (!isdigit(c)) {

                ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_INVALID_DIGIT);

                goto err;

            }

crypto/asn1/a_time.c

+123 −64
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 


#include <stdio.h>

#include <time.h>

#include <ctype.h>

#include "internal/cryptlib.h"

#include <openssl/asn1t.h>

#include "asn1_locl.h"
@@ -24,6 +25,13 @@ IMPLEMENT_ASN1_MSTRING(ASN1_TIME, B_ASN1_TIME) 


IMPLEMENT_ASN1_FUNCTIONS(ASN1_TIME)



static int is_utc(const int year)

{

    if (50 <= year && year <= 149)

        return 1;

    return 0;

}



static int leap_year(const int year)

{

    if (year % 400 == 0 || (year % 100 != 0 && year % 4 == 0))
@@ -116,14 +124,14 @@ int asn1_time_to_tm(struct tm *tm, const ASN1_TIME *d) 
            i++;

            break;

        }

        if ((a[o] < '0') || (a[o] > '9'))

        if (!isdigit(a[o]))

            goto err;

        n = a[o] - '0';

        /* incomplete 2-digital number */

        if (++o == l)

            goto err;



        if ((a[o] < '0') || (a[o] > '9'))

        if (!isdigit(a[o]))

            goto err;

        n = (n * 10) + a[o] - '0';

        /* no more bytes to read, but we haven't seen time-zone yet */
@@ -184,7 +192,7 @@ int asn1_time_to_tm(struct tm *tm, const ASN1_TIME *d) 
        if (++o == l)

            goto err;

        i = o;

        while ((o < l) && (a[o] >= '0') && (a[o] <= '9'))

        while ((o < l) && isdigit(a[o]))

            o++;

        /* Must have at least one digit after decimal point */

        if (i == o)
@@ -215,11 +223,11 @@ int asn1_time_to_tm(struct tm *tm, const ASN1_TIME *d) 
        if (o + 4 != l)

            goto err;

        for (i = end; i < end + 2; i++) {

            if ((a[o] < '0') || (a[o] > '9'))

            if (!isdigit(a[o]))

                goto err;

            n = a[o] - '0';

            o++;

            if ((a[o] < '0') || (a[o] > '9'))

            if (!isdigit(a[o]))

                goto err;

            n = (n * 10) + a[o] - '0';

            i2 = (d->type == V_ASN1_UTCTIME) ? i + 1 : i;
@@ -250,6 +258,58 @@ int asn1_time_to_tm(struct tm *tm, const ASN1_TIME *d) 
    return 0;

}



ASN1_TIME *asn1_time_from_tm(ASN1_TIME *s, struct tm *ts, int type)

{

    char* p;

    ASN1_TIME *tmps = NULL;

    const size_t len = 20;



    if (type == V_ASN1_UNDEF) {

        if (is_utc(ts->tm_year))

            type = V_ASN1_UTCTIME;

        else

            type = V_ASN1_GENERALIZEDTIME;

    } else if (type == V_ASN1_UTCTIME) {

        if (!is_utc(ts->tm_year))

            goto err;

    } else if (type != V_ASN1_GENERALIZEDTIME) {

        goto err;

    }



    if (s == NULL)

        tmps = ASN1_STRING_new();

    else

        tmps = s;

    if (tmps == NULL)

        return NULL;



    if (!ASN1_STRING_set(tmps, NULL, len))

        goto err;



    tmps->type = type;

    p = (char*)tmps->data;



    if (type == V_ASN1_GENERALIZEDTIME)

        tmps->length = BIO_snprintf(p, len, "%04d%02d%02d%02d%02d%02dZ",

                                    ts->tm_year + 1900, ts->tm_mon + 1,

                                    ts->tm_mday, ts->tm_hour, ts->tm_min,

                                    ts->tm_sec);

    else

        tmps->length = BIO_snprintf(p, len, "%02d%02d%02d%02d%02d%02dZ",

                                    ts->tm_year % 100, ts->tm_mon + 1,

                                    ts->tm_mday, ts->tm_hour, ts->tm_min,

                                    ts->tm_sec);



#ifdef CHARSET_EBCDIC_not

    ebcdic2ascii(tmps->data, tmps->data, tmps->length);

#endif

    return tmps;

 err:

    if (tmps != s)

        ASN1_STRING_free(tmps);

    return NULL;

}



ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t)

{

    return ASN1_TIME_adj(s, t, 0, 0);
@@ -270,9 +330,7 @@ ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t, 
        if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))

            return NULL;

    }

    if ((ts->tm_year >= 50) && (ts->tm_year < 150))

        return ASN1_UTCTIME_adj(s, t, offset_day, offset_sec);

    return ASN1_GENERALIZEDTIME_adj(s, t, offset_day, offset_sec);

    return asn1_time_from_tm(s, ts, V_ASN1_UNDEF);

}



int ASN1_TIME_check(const ASN1_TIME *t)
@@ -289,71 +347,28 @@ ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, 
                                                   ASN1_GENERALIZEDTIME **out)

{

    ASN1_GENERALIZEDTIME *ret = NULL;

    char *str;

    struct tm tm;



    if (!ASN1_TIME_check(t))

    if (!ASN1_TIME_to_tm(t, &tm))

        return NULL;



    if (out == NULL || *out == NULL) {

        if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)

            goto err;

    } else {

    if (out != NULL)

        ret = *out;

    }



    /* If already GeneralizedTime just copy across */

    if (t->type == V_ASN1_GENERALIZEDTIME) {

        if (!ASN1_STRING_set(ret, t->data, t->length))

            goto err;

        goto done;

    }

    ret = asn1_time_from_tm(ret, &tm, V_ASN1_GENERALIZEDTIME);



    /*

     * Grow the string by two bytes.

     * The actual allocation is t->length + 3 to include a terminator byte.

     */

    if (!ASN1_STRING_set(ret, NULL, t->length + 2))

        goto err;

    str = (char *)ret->data;

    /* Work out the century and prepend */

    memcpy(str, t->data[0] >= '5' ? "19" : "20", 2);

    /*

     * t->length + 1 is the size of the data and the allocated buffer has

     * this much space after the first two characters.

     */

    OPENSSL_strlcpy(str + 2, (const char *)t->data, t->length + 1);



 done:

   if (out != NULL && *out == NULL)

    if (out != NULL && ret != NULL)

        *out = ret;

   return ret;



 err:

    if (out == NULL || *out != ret)

        ASN1_GENERALIZEDTIME_free(ret);

    return NULL;

    return ret;

}



int ASN1_TIME_set_string(ASN1_TIME *s, const char *str)

{

    ASN1_TIME t;



    t.length = strlen(str);

    t.data = (unsigned char *)str;

    t.flags = 0;



    t.type = V_ASN1_UTCTIME;



    if (!ASN1_TIME_check(&t)) {

        t.type = V_ASN1_GENERALIZEDTIME;

        if (!ASN1_TIME_check(&t))

            return 0;

    }



    if (s != NULL && !ASN1_STRING_copy((ASN1_STRING *)s, (ASN1_STRING *)&t))

        return 0;



    /* Try UTC, if that fails, try GENERALIZED */

    if (ASN1_UTCTIME_set_string(s, str))

        return 1;

    return ASN1_GENERALIZEDTIME_set_string(s, str);

}



int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str)
@@ -391,7 +406,7 @@ int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str) 
    if (s != NULL && t.type == V_ASN1_GENERALIZEDTIME) {

        if (!asn1_time_to_tm(&tm, &t))

            goto out;

        if (tm.tm_year >= 50 && tm.tm_year < 150) {

        if (is_utc(tm.tm_year)) {

            t.length -= 2;

            /*

             * it's OK to let original t.data go since that's assigned
@@ -474,7 +489,7 @@ int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm) 
        if (tm->length > 15 && v[14] == '.') {

            f = &v[14];

            f_len = 1;

            while (14 + f_len < l && f[f_len] >= '0' && f[f_len] <= '9')

            while (14 + f_len < l && isdigit(f[f_len]))

                ++f_len;

        }
@@ -492,3 +507,47 @@ int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm) 
    BIO_write(bp, "Bad time value", 14);

    return 0;

}



int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t)

{

    struct tm stm, ttm;

    int day, sec;



    if (!ASN1_TIME_to_tm(s, &stm))

        return -2;



    if (!OPENSSL_gmtime(&t, &ttm))

        return -2;



    if (!OPENSSL_gmtime_diff(&day, &sec, &ttm, &stm))

        return -2;



    if (day > 0 || sec > 0)

        return 1;

    if (day < 0 || sec < 0)

        return -1;

    return 0;

}



int ASN1_TIME_normalize(ASN1_TIME *t)

{

    struct tm tm;



    if (!ASN1_TIME_to_tm(t, &tm))

        return 0;



    return asn1_time_from_tm(t, &tm, V_ASN1_UNDEF) != NULL;

}



int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b)

{

    int day, sec;



    if (!ASN1_TIME_diff(&day, &sec, a, b))

        return -2;

    if (day > 0 || sec > 0)

        return 1;

    if (day < 0 || sec < 0)

        return -1;

    return 0;

}

crypto/asn1/a_utctm.c

+15 −53
Original line number Diff line number Diff line
@@ -9,10 +9,12 @@ 


#include <stdio.h>

#include <time.h>

#include <ctype.h>

#include "internal/cryptlib.h"

#include <openssl/asn1.h>

#include "asn1_locl.h"



/* This is the primary function used to parse ASN1_UTCTIME */

int asn1_utctime_to_tm(struct tm *tm, const ASN1_UTCTIME *d)

{

    /* wrapper around ans1_time_to_tm */
@@ -26,6 +28,7 @@ int ASN1_UTCTIME_check(const ASN1_UTCTIME *d) 
    return asn1_utctime_to_tm(NULL, d);

}



/* Sets the string via simple copy without cleaning it up */

int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str)

{

    ASN1_UTCTIME t;
@@ -35,15 +38,13 @@ int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str) 
    t.data = (unsigned char *)str;

    t.flags = 0;



    if (ASN1_UTCTIME_check(&t)) {

        if (s != NULL) {

            if (!ASN1_STRING_set((ASN1_STRING *)s, str, t.length))

    if (!ASN1_UTCTIME_check(&t))

        return 0;

            s->type = V_ASN1_UTCTIME;

        }

        return 1;

    }



    if (s != NULL && !ASN1_STRING_copy(s, &t))

        return 0;



    return 1;

}



ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
@@ -54,54 +55,19 @@ ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t) 
ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,

                               int offset_day, long offset_sec)

{

    char *p;

    struct tm *ts;

    struct tm data;

    const size_t len = 20;

    int free_s = 0;



    if (s == NULL) {

        s = ASN1_UTCTIME_new();

        if (s == NULL)

            goto err;

        free_s = 1;

    }



    ts = OPENSSL_gmtime(&t, &data);

    if (ts == NULL)

        goto err;

        return NULL;



    if (offset_day || offset_sec) {

        if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))

            goto err;

    }



    if ((ts->tm_year < 50) || (ts->tm_year >= 150))

        goto err;



    p = (char *)s->data;

    if ((p == NULL) || ((size_t)s->length < len)) {

        p = OPENSSL_malloc(len);

        if (p == NULL) {

            ASN1err(ASN1_F_ASN1_UTCTIME_ADJ, ERR_R_MALLOC_FAILURE);

            goto err;

        }

        OPENSSL_free(s->data);

        s->data = (unsigned char *)p;

            return NULL;

    }



    s->length = BIO_snprintf(p, len, "%02d%02d%02d%02d%02d%02dZ",

                             ts->tm_year % 100, ts->tm_mon + 1, ts->tm_mday,

                             ts->tm_hour, ts->tm_min, ts->tm_sec);

    s->type = V_ASN1_UTCTIME;

#ifdef CHARSET_EBCDIC_not

    ebcdic2ascii(s->data, s->data, s->length);

#endif

    return s;

 err:

    if (free_s)

        ASN1_UTCTIME_free(s);

    return NULL;

    return asn1_time_from_tm(s, ts, V_ASN1_UTCTIME);

}



int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t)
@@ -118,13 +84,9 @@ int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t) 
    if (!OPENSSL_gmtime_diff(&day, &sec, &ttm, &stm))

        return -2;



    if (day > 0)

        return 1;

    if (day < 0)

        return -1;

    if (sec > 0)

    if (day > 0 || sec > 0)

        return 1;

    if (sec < 0)

    if (day < 0 || sec < 0)

        return -1;

    return 0;

}

crypto/asn1/asn1_locl.h

+2 −0
Original line number Diff line number Diff line
@@ -78,3 +78,5 @@ ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp, 
/* Internal functions used by x_int64.c */

int c2i_uint64_int(uint64_t *ret, int *neg, const unsigned char **pp, long len);

int i2c_uint64_int(unsigned char *p, uint64_t r, int neg);



ASN1_TIME *asn1_time_from_tm(ASN1_TIME *s, struct tm *ts, int type);