[thirdparty/openssl.git] / crypto / asn1 / a_gentm.c

/*
 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

/*
 * GENERALIZEDTIME implementation. Based on UTCTIME
 */

#include <stdio.h>
#include <time.h>
#include "internal/cryptlib.h"
#include <openssl/asn1.h>
#include "asn1_locl.h"

int asn1_generalizedtime_to_tm(struct tm *tm, const ASN1_GENERALIZEDTIME *d)
{
    static const int min[9] = { 0, 0, 1, 1, 0, 0, 0, 0, 0 };
    static const int max[9] = { 99, 99, 12, 31, 23, 59, 59, 12, 59 };
    char *a;
    int n, i, l, o;

    if (d->type != V_ASN1_GENERALIZEDTIME)
        return (0);
    l = d->length;
    a = (char *)d->data;
    o = 0;
    /*
     * GENERALIZEDTIME is similar to UTCTIME except the year is represented
     * as YYYY. This stuff treats everything as a two digit field so make
     * first two fields 00 to 99
     */
    if (l < 13)
        goto err;
    for (i = 0; i < 7; i++) {
        if ((i == 6) && ((a[o] == 'Z') || (a[o] == '+') || (a[o] == '-'))) {
            i++;
            if (tm)
                tm->tm_sec = 0;
            break;
        }
        if ((a[o] < '0') || (a[o] > '9'))
            goto err;
        n = a[o] - '0';
        if (++o > l)
            goto err;

        if ((a[o] < '0') || (a[o] > '9'))
            goto err;
        n = (n * 10) + a[o] - '0';
        if (++o > l)
            goto err;

        if ((n < min[i]) || (n > max[i]))
            goto err;
        if (tm) {
            switch (i) {
            case 0:
                tm->tm_year = n * 100 - 1900;
                break;
            case 1:
                tm->tm_year += n;
                break;
            case 2:
                tm->tm_mon = n - 1;
                break;
            case 3:
                tm->tm_mday = n;
                break;
            case 4:
                tm->tm_hour = n;
                break;
            case 5:
                tm->tm_min = n;
                break;
            case 6:
                tm->tm_sec = n;
                break;
            }
        }
    }
    /*
     * 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] == '-')) {
        int offsign = a[o] == '-' ? 1 : -1, offset = 0;
        o++;
        if (o + 4 > l)
            goto err;
        for (i = 7; i < 9; i++) {
            if ((a[o] < '0') || (a[o] > '9'))
                goto err;
            n = a[o] - '0';
            o++;
            if ((a[o] < '0') || (a[o] > '9'))
                goto err;
            n = (n * 10) + a[o] - '0';
            if ((n < min[i]) || (n > max[i]))
                goto err;
            if (tm) {
                if (i == 7)
                    offset = n * 3600;
                else if (i == 8)
                    offset += n * 60;
            }
            o++;
        }
        if (offset && !OPENSSL_gmtime_adj(tm, 0, offset * offsign))
            return 0;
    } else if (a[o]) {
        /* Missing time zone information. */
        goto err;
    }
    return (o == l);
 err:
    return (0);
}

int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
{
    return asn1_generalizedtime_to_tm(NULL, d);
}

int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)
{
    ASN1_GENERALIZEDTIME t;

    t.type = V_ASN1_GENERALIZEDTIME;
    t.length = strlen(str);
    t.data = (unsigned char *)str;
    if (ASN1_GENERALIZEDTIME_check(&t)) {
        if (s != NULL) {
            if (!ASN1_STRING_set((ASN1_STRING *)s, str, t.length))
                return 0;
            s->type = V_ASN1_GENERALIZEDTIME;
        }
        return (1);
    } else
        return (0);
}

ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
                                               time_t t)
{
    return ASN1_GENERALIZEDTIME_adj(s, t, 0, 0);
}

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;
    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;

    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;
    }

    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->length = strlen(p);
    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;
}

const char *_asn1_mon[12] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};

int ASN1_GENERALIZEDTIME_print(BIO *bp, const ASN1_GENERALIZEDTIME *tm)
{
    char *v;
    int gmt = 0;
    int i;
    int y = 0, M = 0, d = 0, h = 0, m = 0, s = 0;
    char *f = NULL;
    int f_len = 0;

    i = tm->length;
    v = (char *)tm->data;

    if (i < 12)
        goto err;
    if (v[i - 1] == 'Z')
        gmt = 1;
    for (i = 0; i < 12; i++)
        if ((v[i] > '9') || (v[i] < '0'))
            goto err;
    y = (v[0] - '0') * 1000 + (v[1] - '0') * 100
        + (v[2] - '0') * 10 + (v[3] - '0');
    M = (v[4] - '0') * 10 + (v[5] - '0');
    if ((M > 12) || (M < 1))
        goto err;
    d = (v[6] - '0') * 10 + (v[7] - '0');
    h = (v[8] - '0') * 10 + (v[9] - '0');
    m = (v[10] - '0') * 10 + (v[11] - '0');
    if (tm->length >= 14 &&
        (v[12] >= '0') && (v[12] <= '9') &&
        (v[13] >= '0') && (v[13] <= '9')) {
        s = (v[12] - '0') * 10 + (v[13] - '0');
        /* Check for fractions of seconds. */
        if (tm->length >= 15 && v[14] == '.') {
            int l = tm->length;
            f = &v[14];         /* The decimal point. */
            f_len = 1;
            while (14 + f_len < l && f[f_len] >= '0' && f[f_len] <= '9')
                ++f_len;
        }
    }

    if (BIO_printf(bp, "%s %2d %02d:%02d:%02d%.*s %d%s",
                   _asn1_mon[M - 1], d, h, m, s, f_len, f, y,
                   (gmt) ? " GMT" : "") <= 0)
        return (0);
    else
        return (1);
 err:
    BIO_write(bp, "Bad time value", 14);
    return (0);
}
Commit	Line	Data
b1322259 RS	1	/*
b1322259 RS	2	* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
0f113f3e	3	*
b1322259 RS	4	* Licensed under the OpenSSL license (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
f6aed2cd DSH	8	*/
f6aed2cd DSH	9
0f113f3e	10	/*
b1322259	11	* GENERALIZEDTIME implementation. Based on UTCTIME
0f113f3e	12	*/
f6aed2cd DSH	13
	14	#include <stdio.h>
	15	#include <time.h>
b39fc560	16	#include "internal/cryptlib.h"
ec577822	17	#include <openssl/asn1.h>
1c455bc0	18	#include "asn1_locl.h"
f6aed2cd	19
1c455bc0	20	int asn1_generalizedtime_to_tm(struct tm tm, const ASN1_GENERALIZEDTIME d)
0f113f3e MC	21	{
	22	static const int min[9] = { 0, 0, 1, 1, 0, 0, 0, 0, 0 };
	23	static const int max[9] = { 99, 99, 12, 31, 23, 59, 59, 12, 59 };
	24	char *a;
	25	int n, i, l, o;
f6aed2cd	26
0f113f3e MC	27	if (d->type != V_ASN1_GENERALIZEDTIME)
	28	return (0);
	29	l = d->length;
	30	a = (char *)d->data;
	31	o = 0;
	32	/*
	33	* GENERALIZEDTIME is similar to UTCTIME except the year is represented
	34	* as YYYY. This stuff treats everything as a two digit field so make
	35	* first two fields 00 to 99
	36	*/
	37	if (l < 13)
	38	goto err;
	39	for (i = 0; i < 7; i++) {
	40	if ((i == 6) && ((a[o] == 'Z') \|\| (a[o] == '+') \|\| (a[o] == '-'))) {
	41	i++;
	42	if (tm)
	43	tm->tm_sec = 0;
	44	break;
	45	}
	46	if ((a[o] < '0') \|\| (a[o] > '9'))
	47	goto err;
	48	n = a[o] - '0';
	49	if (++o > l)
	50	goto err;
f6aed2cd	51
0f113f3e MC	52	if ((a[o] < '0') \|\| (a[o] > '9'))
	53	goto err;
	54	n = (n * 10) + a[o] - '0';
	55	if (++o > l)
	56	goto err;
f6aed2cd	57
0f113f3e MC	58	if ((n < min[i]) \|\| (n > max[i]))
	59	goto err;
	60	if (tm) {
	61	switch (i) {
	62	case 0:
	63	tm->tm_year = n * 100 - 1900;
	64	break;
	65	case 1:
	66	tm->tm_year += n;
	67	break;
	68	case 2:
	69	tm->tm_mon = n - 1;
	70	break;
	71	case 3:
	72	tm->tm_mday = n;
	73	break;
	74	case 4:
	75	tm->tm_hour = n;
	76	break;
	77	case 5:
	78	tm->tm_min = n;
	79	break;
	80	case 6:
	81	tm->tm_sec = n;
	82	break;
	83	}
	84	}
	85	}
	86	/*
	87	* Optional fractional seconds: decimal point followed by one or more
	88	* digits.
	89	*/
	90	if (a[o] == '.') {
	91	if (++o > l)
	92	goto err;
	93	i = o;
	94	while ((a[o] >= '0') && (a[o] <= '9') && (o <= l))
	95	o++;
	96	/* Must have at least one digit after decimal point */
	97	if (i == o)
	98	goto err;
	99	}
d46c1a81	100
0f113f3e MC	101	if (a[o] == 'Z')
	102	o++;
	103	else if ((a[o] == '+') \|\| (a[o] == '-')) {
20ee2bf1	104	int offsign = a[o] == '-' ? 1 : -1, offset = 0;
0f113f3e MC	105	o++;
	106	if (o + 4 > l)
	107	goto err;
	108	for (i = 7; i < 9; i++) {
	109	if ((a[o] < '0') \|\| (a[o] > '9'))
	110	goto err;
	111	n = a[o] - '0';
	112	o++;
	113	if ((a[o] < '0') \|\| (a[o] > '9'))
	114	goto err;
	115	n = (n * 10) + a[o] - '0';
	116	if ((n < min[i]) \|\| (n > max[i]))
	117	goto err;
	118	if (tm) {
	119	if (i == 7)
	120	offset = n * 3600;
	121	else if (i == 8)
	122	offset += n * 60;
	123	}
	124	o++;
	125	}
	126	if (offset && !OPENSSL_gmtime_adj(tm, 0, offset * offsign))
	127	return 0;
	128	} else if (a[o]) {
	129	/* Missing time zone information. */
	130	goto err;
	131	}
	132	return (o == l);
	133	err:
	134	return (0);
	135	}
f6aed2cd	136
1c455bc0	137	int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
0f113f3e MC	138	{
	139	return asn1_generalizedtime_to_tm(NULL, d);
	140	}
1c455bc0	141
875a644a	142	int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME s, const char str)
0f113f3e MC	143	{
0f113f3e MC	144	ASN1_GENERALIZEDTIME t;
f6aed2cd	145
0f113f3e MC	146	t.type = V_ASN1_GENERALIZEDTIME;
	147	t.length = strlen(str);
	148	t.data = (unsigned char *)str;
	149	if (ASN1_GENERALIZEDTIME_check(&t)) {
	150	if (s != NULL) {
a026fbf9	151	if (!ASN1_STRING_set((ASN1_STRING *)s, str, t.length))
0f113f3e MC	152	return 0;
	153	s->type = V_ASN1_GENERALIZEDTIME;
	154	}
	155	return (1);
	156	} else
	157	return (0);
	158	}
f6aed2cd	159
6b691a5c	160	ASN1_GENERALIZEDTIME ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME s,
0f113f3e MC	161	time_t t)
	162	{
	163	return ASN1_GENERALIZEDTIME_adj(s, t, 0, 0);
	164	}
87d3a0cd DSH	165
87d3a0cd DSH	166	ASN1_GENERALIZEDTIME ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME s,
0f113f3e MC	167	time_t t, int offset_day,
	168	long offset_sec)
	169	{
	170	char *p;
	171	struct tm *ts;
	172	struct tm data;
	173	size_t len = 20;
fe71bb3a	174	ASN1_GENERALIZEDTIME *tmps = NULL;
f6aed2cd	175
0f113f3e	176	if (s == NULL)
fe71bb3a MC	177	tmps = ASN1_GENERALIZEDTIME_new();
	178	else
	179	tmps = s;
	180	if (tmps == NULL)
	181	return NULL;
f6aed2cd	182
0f113f3e MC	183	ts = OPENSSL_gmtime(&t, &data);
0f113f3e MC	184	if (ts == NULL)
fe71bb3a	185	goto err;
b8e35bd6	186
0f113f3e MC	187	if (offset_day \|\| offset_sec) {
0f113f3e MC	188	if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))
fe71bb3a	189	goto err;
0f113f3e	190	}
87d3a0cd	191
fe71bb3a MC	192	p = (char *)tmps->data;
fe71bb3a MC	193	if ((p == NULL) \|\| ((size_t)tmps->length < len)) {
0f113f3e MC	194	p = OPENSSL_malloc(len);
	195	if (p == NULL) {
	196	ASN1err(ASN1_F_ASN1_GENERALIZEDTIME_ADJ, ERR_R_MALLOC_FAILURE);
fe71bb3a	197	goto err;
0f113f3e	198	}
fe71bb3a MC	199	OPENSSL_free(tmps->data);
fe71bb3a MC	200	tmps->data = (unsigned char *)p;
0f113f3e	201	}
f6aed2cd	202
0f113f3e MC	203	BIO_snprintf(p, len, "%04d%02d%02d%02d%02d%02dZ", ts->tm_year + 1900,
	204	ts->tm_mon + 1, ts->tm_mday, ts->tm_hour, ts->tm_min,
	205	ts->tm_sec);
fe71bb3a MC	206	tmps->length = strlen(p);
fe71bb3a MC	207	tmps->type = V_ASN1_GENERALIZEDTIME;
a53955d8	208	#ifdef CHARSET_EBCDIC_not
fe71bb3a	209	ebcdic2ascii(tmps->data, tmps->data, tmps->length);
a53955d8	210	#endif
fe71bb3a MC	211	return tmps;
	212	err:
	213	if (s == NULL)
	214	ASN1_GENERALIZEDTIME_free(tmps);
	215	return NULL;
0f113f3e	216	}
0d0099ea DSH	217
	218	const char *_asn1_mon[12] = {
	219	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
	220	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
	221	};
	222
	223	int ASN1_GENERALIZEDTIME_print(BIO bp, const ASN1_GENERALIZEDTIME tm)
	224	{
	225	char *v;
	226	int gmt = 0;
	227	int i;
	228	int y = 0, M = 0, d = 0, h = 0, m = 0, s = 0;
	229	char *f = NULL;
	230	int f_len = 0;
	231
	232	i = tm->length;
	233	v = (char *)tm->data;
	234
	235	if (i < 12)
	236	goto err;
	237	if (v[i - 1] == 'Z')
	238	gmt = 1;
	239	for (i = 0; i < 12; i++)
	240	if ((v[i] > '9') \|\| (v[i] < '0'))
	241	goto err;
	242	y = (v[0] - '0') * 1000 + (v[1] - '0') * 100
	243	+ (v[2] - '0') * 10 + (v[3] - '0');
	244	M = (v[4] - '0') * 10 + (v[5] - '0');
	245	if ((M > 12) \|\| (M < 1))
	246	goto err;
	247	d = (v[6] - '0') * 10 + (v[7] - '0');
	248	h = (v[8] - '0') * 10 + (v[9] - '0');
	249	m = (v[10] - '0') * 10 + (v[11] - '0');
	250	if (tm->length >= 14 &&
	251	(v[12] >= '0') && (v[12] <= '9') &&
	252	(v[13] >= '0') && (v[13] <= '9')) {
	253	s = (v[12] - '0') * 10 + (v[13] - '0');
	254	/* Check for fractions of seconds. */
	255	if (tm->length >= 15 && v[14] == '.') {
	256	int l = tm->length;
	257	f = &v[14]; /* The decimal point. */
	258	f_len = 1;
	259	while (14 + f_len < l && f[f_len] >= '0' && f[f_len] <= '9')
	260	++f_len;
	261	}
	262	}
	263
	264	if (BIO_printf(bp, "%s %2d %02d:%02d:%02d%.*s %d%s",
	265	_asn1_mon[M - 1], d, h, m, s, f_len, f, y,
	266	(gmt) ? " GMT" : "") <= 0)
	267	return (0);
	268	else
	269	return (1);
	270	err:
	271	BIO_write(bp, "Bad time value", 14);
	272	return (0);
	273	}