2016-05-17 18:52:22 +00:00
|
|
|
/*
|
2017-07-06 01:39:03 +00:00
|
|
|
* Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
|
2015-01-22 03:40:55 +00:00
|
|
|
*
|
2016-05-17 18:52:22 +00:00
|
|
|
* 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
|
1999-01-17 00:13:14 +00:00
|
|
|
*/
|
|
|
|
|
2015-01-22 03:40:55 +00:00
|
|
|
/*
|
2016-05-17 18:52:22 +00:00
|
|
|
* GENERALIZEDTIME implementation. Based on UTCTIME
|
2015-01-22 03:40:55 +00:00
|
|
|
*/
|
1999-01-17 00:13:14 +00:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <time.h>
|
2015-05-14 14:56:48 +00:00
|
|
|
#include "internal/cryptlib.h"
|
1999-04-23 22:13:45 +00:00
|
|
|
#include <openssl/asn1.h>
|
2012-11-19 15:12:07 +00:00
|
|
|
#include "asn1_locl.h"
|
1999-01-17 00:13:14 +00:00
|
|
|
|
2012-11-19 15:12:07 +00:00
|
|
|
int asn1_generalizedtime_to_tm(struct tm *tm, const ASN1_GENERALIZEDTIME *d)
|
2015-01-22 03:40:55 +00:00
|
|
|
{
|
2017-07-10 19:01:24 +00:00
|
|
|
/* wrapper around asn1_time_to_tm */
|
2015-01-22 03:40:55 +00:00
|
|
|
if (d->type != V_ASN1_GENERALIZEDTIME)
|
2017-07-10 19:01:24 +00:00
|
|
|
return 0;
|
|
|
|
return asn1_time_to_tm(tm, d);
|
2017-07-27 04:54:27 +00:00
|
|
|
}
|
1999-01-17 00:13:14 +00:00
|
|
|
|
2012-11-19 15:12:07 +00:00
|
|
|
int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
|
2015-01-22 03:40:55 +00:00
|
|
|
{
|
|
|
|
return asn1_generalizedtime_to_tm(NULL, d);
|
|
|
|
}
|
2012-11-19 15:12:07 +00:00
|
|
|
|
2004-03-15 23:15:26 +00:00
|
|
|
int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)
|
2015-01-22 03:40:55 +00:00
|
|
|
{
|
|
|
|
ASN1_GENERALIZEDTIME t;
|
1999-01-17 00:13:14 +00:00
|
|
|
|
2015-01-22 03:40:55 +00:00
|
|
|
t.type = V_ASN1_GENERALIZEDTIME;
|
|
|
|
t.length = strlen(str);
|
|
|
|
t.data = (unsigned char *)str;
|
2017-06-11 20:36:07 +00:00
|
|
|
t.flags = 0;
|
|
|
|
|
2015-01-22 03:40:55 +00:00
|
|
|
if (ASN1_GENERALIZEDTIME_check(&t)) {
|
|
|
|
if (s != NULL) {
|
2016-08-06 15:54:32 +00:00
|
|
|
if (!ASN1_STRING_set((ASN1_STRING *)s, str, t.length))
|
2015-01-22 03:40:55 +00:00
|
|
|
return 0;
|
|
|
|
s->type = V_ASN1_GENERALIZEDTIME;
|
|
|
|
}
|
2017-07-27 04:54:27 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2015-01-22 03:40:55 +00:00
|
|
|
}
|
1999-01-17 00:13:14 +00:00
|
|
|
|
1999-04-19 21:31:43 +00:00
|
|
|
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
|
2015-01-22 03:40:55 +00:00
|
|
|
time_t t)
|
|
|
|
{
|
|
|
|
return ASN1_GENERALIZEDTIME_adj(s, t, 0, 0);
|
|
|
|
}
|
2008-10-07 22:55:27 +00:00
|
|
|
|
|
|
|
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
|
2015-01-22 03:40:55 +00:00
|
|
|
time_t t, int offset_day,
|
|
|
|
long offset_sec)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
struct tm *ts;
|
|
|
|
struct tm data;
|
2017-07-06 01:39:03 +00:00
|
|
|
const size_t len = 20;
|
2016-04-27 15:59:49 +00:00
|
|
|
ASN1_GENERALIZEDTIME *tmps = NULL;
|
1999-01-17 00:13:14 +00:00
|
|
|
|
2015-01-22 03:40:55 +00:00
|
|
|
if (s == NULL)
|
2016-04-27 15:59:49 +00:00
|
|
|
tmps = ASN1_GENERALIZEDTIME_new();
|
|
|
|
else
|
|
|
|
tmps = s;
|
|
|
|
if (tmps == NULL)
|
|
|
|
return NULL;
|
1999-01-17 00:13:14 +00:00
|
|
|
|
2015-01-22 03:40:55 +00:00
|
|
|
ts = OPENSSL_gmtime(&t, &data);
|
|
|
|
if (ts == NULL)
|
2016-04-27 15:59:49 +00:00
|
|
|
goto err;
|
2001-05-16 08:44:09 +00:00
|
|
|
|
2015-01-22 03:40:55 +00:00
|
|
|
if (offset_day || offset_sec) {
|
|
|
|
if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))
|
2016-04-27 15:59:49 +00:00
|
|
|
goto err;
|
2015-01-22 03:40:55 +00:00
|
|
|
}
|
2008-10-07 22:55:27 +00:00
|
|
|
|
2016-04-27 15:59:49 +00:00
|
|
|
p = (char *)tmps->data;
|
|
|
|
if ((p == NULL) || ((size_t)tmps->length < len)) {
|
2015-01-22 03:40:55 +00:00
|
|
|
p = OPENSSL_malloc(len);
|
|
|
|
if (p == NULL) {
|
|
|
|
ASN1err(ASN1_F_ASN1_GENERALIZEDTIME_ADJ, ERR_R_MALLOC_FAILURE);
|
2016-04-27 15:59:49 +00:00
|
|
|
goto err;
|
2015-01-22 03:40:55 +00:00
|
|
|
}
|
2016-04-27 15:59:49 +00:00
|
|
|
OPENSSL_free(tmps->data);
|
|
|
|
tmps->data = (unsigned char *)p;
|
2015-01-22 03:40:55 +00:00
|
|
|
}
|
1999-01-17 00:13:14 +00:00
|
|
|
|
2017-07-06 01:39:03 +00:00
|
|
|
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);
|
2016-04-27 15:59:49 +00:00
|
|
|
tmps->type = V_ASN1_GENERALIZEDTIME;
|
1999-06-04 21:35:58 +00:00
|
|
|
#ifdef CHARSET_EBCDIC_not
|
2016-04-27 15:59:49 +00:00
|
|
|
ebcdic2ascii(tmps->data, tmps->data, tmps->length);
|
1999-06-04 21:35:58 +00:00
|
|
|
#endif
|
2016-04-27 15:59:49 +00:00
|
|
|
return tmps;
|
|
|
|
err:
|
|
|
|
if (s == NULL)
|
|
|
|
ASN1_GENERALIZEDTIME_free(tmps);
|
|
|
|
return NULL;
|
2015-01-22 03:40:55 +00:00
|
|
|
}
|
2015-09-22 15:05:33 +00:00
|
|
|
|
2017-07-27 04:54:27 +00:00
|
|
|
static const char _asn1_mon[12][4] = {
|
2015-09-22 15:05:33 +00:00
|
|
|
"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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-27 04:54:27 +00:00
|
|
|
return 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;
|
2015-09-22 15:05:33 +00:00
|
|
|
err:
|
|
|
|
BIO_write(bp, "Bad time value", 14);
|
2017-07-27 04:54:27 +00:00
|
|
|
return 0;
|
2015-09-22 15:05:33 +00:00
|
|
|
}
|