a_time.c@ 91772

Last change on this file since 91772 was 91772, checked in by vboxsync, 3 years ago
openssl-1.1.1l: Applied and adjusted our OpenSSL changes to 1.1.1l. bugref:10126
File size: 14.9 KB

Line
1	/*
2	* Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved.
3	*
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
8	*/
9
10	/*-
11	* This is an implementation of the ASN1 Time structure which is:
12	* Time ::= CHOICE {
13	* utcTime UTCTime,
14	* generalTime GeneralizedTime }
15	*/
16
17	#include <stdio.h>
18	#include <time.h>
19	#include "crypto/ctype.h"
20	#include "internal/cryptlib.h"
21	#include <openssl/asn1t.h>
22	#include "asn1_local.h"
23
24	IMPLEMENT_ASN1_MSTRING(ASN1_TIME, B_ASN1_TIME)
25
26	IMPLEMENT_ASN1_FUNCTIONS(ASN1_TIME)
27
28	static int is_utc(const int year)
29	{
30	if (50 <= year && year <= 149)
31	return 1;
32	return 0;
33	}
34
35	static int leap_year(const int year)
36	{
37	if (year % 400 == 0 \|\| (year % 100 != 0 && year % 4 == 0))
38	return 1;
39	return 0;
40	}
41
42	/*
43	* Compute the day of the week and the day of the year from the year, month
44	* and day. The day of the year is straightforward, the day of the week uses
45	* a form of Zeller's congruence. For this months start with March and are
46	* numbered 4 through 15.
47	*/
48	static void determine_days(struct tm *tm)
49	{
50	static const int ydays[12] = {
51	0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
52	};
53	int y = tm->tm_year + 1900;
54	int m = tm->tm_mon;
55	int d = tm->tm_mday;
56	int c;
57
58	tm->tm_yday = ydays[m] + d - 1;
59	if (m >= 2) {
60	/* March and onwards can be one day further into the year */
61	tm->tm_yday += leap_year(y);
62	m += 2;
63	} else {
64	/* Treat January and February as part of the previous year */
65	m += 14;
66	y--;
67	}
68	c = y / 100;
69	y %= 100;
70	/* Zeller's congruence */
71	tm->tm_wday = (d + (13 * m) / 5 + y + y / 4 + c / 4 + 5 * c + 6) % 7;
72	}
73
74	int asn1_time_to_tm(struct tm tm, const ASN1_TIME d)
75	{
76	static const int min[9] = { 0, 0, 1, 1, 0, 0, 0, 0, 0 };
77	static const int max[9] = { 99, 99, 12, 31, 23, 59, 59, 12, 59 };
78	static const int mdays[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
79	char *a;
80	int n, i, i2, l, o, min_l = 11, strict = 0, end = 6, btz = 5, md;
81	struct tm tmp;
82	#if defined(CHARSET_EBCDIC)
83	const char upper_z = 0x5A, num_zero = 0x30, period = 0x2E, minus = 0x2D, plus = 0x2B;
84	#else
85	const char upper_z = 'Z', num_zero = '0', period = '.', minus = '-', plus = '+';
86	#endif
87	/*
88	* ASN1_STRING_FLAG_X509_TIME is used to enforce RFC 5280
89	* time string format, in which:
90	*
91	* 1. "seconds" is a 'MUST'
92	* 2. "Zulu" timezone is a 'MUST'
93	* 3. "+\|-" is not allowed to indicate a time zone
94	*/
95	if (d->type == V_ASN1_UTCTIME) {
96	if (d->flags & ASN1_STRING_FLAG_X509_TIME) {
97	min_l = 13;
98	strict = 1;
99	}
100	} else if (d->type == V_ASN1_GENERALIZEDTIME) {
101	end = 7;
102	btz = 6;
103	if (d->flags & ASN1_STRING_FLAG_X509_TIME) {
104	min_l = 15;
105	strict = 1;
106	} else {
107	min_l = 13;
108	}
109	} else {
110	return 0;
111	}
112
113	l = d->length;
114	a = (char *)d->data;
115	o = 0;
116	memset(&tmp, 0, sizeof(tmp));
117
118	/*
119	* GENERALIZEDTIME is similar to UTCTIME except the year is represented
120	* as YYYY. This stuff treats everything as a two digit field so make
121	* first two fields 00 to 99
122	*/
123
124	if (l < min_l)
125	goto err;
126	for (i = 0; i < end; i++) {
127	if (!strict && (i == btz) && ((a[o] == upper_z) \|\| (a[o] == plus) \|\| (a[o] == minus))) {
128	i++;
129	break;
130	}
131	if (!ascii_isdigit(a[o]))
132	goto err;
133	n = a[o] - num_zero;
134	/* incomplete 2-digital number */
135	if (++o == l)
136	goto err;
137
138	if (!ascii_isdigit(a[o]))
139	goto err;
140	n = (n * 10) + a[o] - num_zero;
141	/* no more bytes to read, but we haven't seen time-zone yet */
142	if (++o == l)
143	goto err;
144
145	i2 = (d->type == V_ASN1_UTCTIME) ? i + 1 : i;
146
147	if ((n < min[i2]) \|\| (n > max[i2]))
148	goto err;
149	switch (i2) {
150	case 0:
151	/* UTC will never be here */
152	tmp.tm_year = n * 100 - 1900;
153	break;
154	case 1:
155	if (d->type == V_ASN1_UTCTIME)
156	tmp.tm_year = n < 50 ? n + 100 : n;
157	else
158	tmp.tm_year += n;
159	break;
160	case 2:
161	tmp.tm_mon = n - 1;
162	break;
163	case 3:
164	/* check if tm_mday is valid in tm_mon */
165	if (tmp.tm_mon == 1) {
166	/* it's February */
167	md = mdays[1] + leap_year(tmp.tm_year + 1900);
168	} else {
169	md = mdays[tmp.tm_mon];
170	}
171	if (n > md)
172	goto err;
173	tmp.tm_mday = n;
174	determine_days(&tmp);
175	break;
176	case 4:
177	tmp.tm_hour = n;
178	break;
179	case 5:
180	tmp.tm_min = n;
181	break;
182	case 6:
183	tmp.tm_sec = n;
184	break;
185	}
186	}
187
188	/*
189	* Optional fractional seconds: decimal point followed by one or more
190	* digits.
191	*/
192	if (d->type == V_ASN1_GENERALIZEDTIME && a[o] == period) {
193	if (strict)
194	/* RFC 5280 forbids fractional seconds */
195	goto err;
196	if (++o == l)
197	goto err;
198	i = o;
199	while ((o < l) && ascii_isdigit(a[o]))
200	o++;
201	/* Must have at least one digit after decimal point */
202	if (i == o)
203	goto err;
204	/* no more bytes to read, but we haven't seen time-zone yet */
205	if (o == l)
206	goto err;
207	}
208
209	/*
210	* 'o' will never point to '\0' at this point, the only chance
211	* 'o' can point to '\0' is either the subsequent if or the first
212	* else if is true.
213	*/
214	if (a[o] == upper_z) {
215	o++;
216	} else if (!strict && ((a[o] == plus) \|\| (a[o] == minus))) {
217	int offsign = a[o] == minus ? 1 : -1;
218	int offset = 0;
219
220	o++;
221	/*
222	* if not equal, no need to do subsequent checks
223	* since the following for-loop will add 'o' by 4
224	* and the final return statement will check if 'l'
225	* and 'o' are equal.
226	*/
227	if (o + 4 != l)
228	goto err;
229	for (i = end; i < end + 2; i++) {
230	if (!ascii_isdigit(a[o]))
231	goto err;
232	n = a[o] - num_zero;
233	o++;
234	if (!ascii_isdigit(a[o]))
235	goto err;
236	n = (n * 10) + a[o] - num_zero;
237	i2 = (d->type == V_ASN1_UTCTIME) ? i + 1 : i;
238	if ((n < min[i2]) \|\| (n > max[i2]))
239	goto err;
240	/* if tm is NULL, no need to adjust */
241	if (tm != NULL) {
242	if (i == end)
243	offset = n * 3600;
244	else if (i == end + 1)
245	offset += n * 60;
246	}
247	o++;
248	}
249	if (offset && !OPENSSL_gmtime_adj(&tmp, 0, offset * offsign))
250	goto err;
251	} else {
252	/* not Z, or not +/- in non-strict mode */
253	goto err;
254	}
255	if (o == l) {
256	/* success, check if tm should be filled */
257	if (tm != NULL)
258	*tm = tmp;
259	return 1;
260	}
261	err:
262	return 0;
263	}
264
265	ASN1_TIME asn1_time_from_tm(ASN1_TIME s, struct tm *ts, int type)
266	{
267	char* p;
268	ASN1_TIME *tmps = NULL;
269	const size_t len = 20;
270
271	if (type == V_ASN1_UNDEF) {
272	if (is_utc(ts->tm_year))
273	type = V_ASN1_UTCTIME;
274	else
275	type = V_ASN1_GENERALIZEDTIME;
276	} else if (type == V_ASN1_UTCTIME) {
277	if (!is_utc(ts->tm_year))
278	goto err;
279	} else if (type != V_ASN1_GENERALIZEDTIME) {
280	goto err;
281	}
282
283	if (s == NULL)
284	tmps = ASN1_STRING_new();
285	else
286	tmps = s;
287	if (tmps == NULL)
288	return NULL;
289
290	if (!ASN1_STRING_set(tmps, NULL, len))
291	goto err;
292
293	tmps->type = type;
294	p = (char*)tmps->data;
295
296	if (type == V_ASN1_GENERALIZEDTIME)
297	tmps->length = BIO_snprintf(p, len, "%04d%02d%02d%02d%02d%02dZ",
298	ts->tm_year + 1900, ts->tm_mon + 1,
299	ts->tm_mday, ts->tm_hour, ts->tm_min,
300	ts->tm_sec);
301	else
302	tmps->length = BIO_snprintf(p, len, "%02d%02d%02d%02d%02d%02dZ",
303	ts->tm_year % 100, ts->tm_mon + 1,
304	ts->tm_mday, ts->tm_hour, ts->tm_min,
305	ts->tm_sec);
306
307	#ifdef CHARSET_EBCDIC
308	ebcdic2ascii(tmps->data, tmps->data, tmps->length);
309	#endif
310	return tmps;
311	err:
312	if (tmps != s)
313	ASN1_STRING_free(tmps);
314	return NULL;
315	}
316
317	ASN1_TIME ASN1_TIME_set(ASN1_TIME s, time_t t)
318	{
319	return ASN1_TIME_adj(s, t, 0, 0);
320	}
321
322	ASN1_TIME ASN1_TIME_adj(ASN1_TIME s, time_t t,
323	int offset_day, long offset_sec)
324	{
325	struct tm *ts;
326	struct tm data;
327
328	ts = OPENSSL_gmtime(&t, &data);
329	if (ts == NULL) {
330	ASN1err(ASN1_F_ASN1_TIME_ADJ, ASN1_R_ERROR_GETTING_TIME);
331	return NULL;
332	}
333	if (offset_day \|\| offset_sec) {
334	if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))
335	return NULL;
336	}
337	return asn1_time_from_tm(s, ts, V_ASN1_UNDEF);
338	}
339
340	int ASN1_TIME_check(const ASN1_TIME *t)
341	{
342	if (t->type == V_ASN1_GENERALIZEDTIME)
343	return ASN1_GENERALIZEDTIME_check(t);
344	else if (t->type == V_ASN1_UTCTIME)
345	return ASN1_UTCTIME_check(t);
346	return 0;
347	}
348
349	/* Convert an ASN1_TIME structure to GeneralizedTime */
350	ASN1_GENERALIZEDTIME ASN1_TIME_to_generalizedtime(const ASN1_TIME t,
351	ASN1_GENERALIZEDTIME **out)
352	{
353	ASN1_GENERALIZEDTIME *ret = NULL;
354	struct tm tm;
355
356	if (!ASN1_TIME_to_tm(t, &tm))
357	return NULL;
358
359	if (out != NULL)
360	ret = *out;
361
362	ret = asn1_time_from_tm(ret, &tm, V_ASN1_GENERALIZEDTIME);
363
364	if (out != NULL && ret != NULL)
365	*out = ret;
366
367	return ret;
368	}
369
370	int ASN1_TIME_set_string(ASN1_TIME s, const char str)
371	{
372	/* Try UTC, if that fails, try GENERALIZED */
373	if (ASN1_UTCTIME_set_string(s, str))
374	return 1;
375	return ASN1_GENERALIZEDTIME_set_string(s, str);
376	}
377
378	int ASN1_TIME_set_string_X509(ASN1_TIME s, const char str)
379	{
380	ASN1_TIME t;
381	struct tm tm;
382	int rv = 0;
383
384	t.length = strlen(str);
385	t.data = (unsigned char *)str;
386	t.flags = ASN1_STRING_FLAG_X509_TIME;
387
388	t.type = V_ASN1_UTCTIME;
389
390	if (!ASN1_TIME_check(&t)) {
391	t.type = V_ASN1_GENERALIZEDTIME;
392	if (!ASN1_TIME_check(&t))
393	goto out;
394	}
395
396	/*
397	* Per RFC 5280 (section 4.1.2.5.), the valid input time
398	* strings should be encoded with the following rules:
399	*
400	* 1. UTC: YYMMDDHHMMSSZ, if YY < 50 (20YY) --> UTC: YYMMDDHHMMSSZ
401	* 2. UTC: YYMMDDHHMMSSZ, if YY >= 50 (19YY) --> UTC: YYMMDDHHMMSSZ
402	* 3. G'd: YYYYMMDDHHMMSSZ, if YYYY >= 2050 --> G'd: YYYYMMDDHHMMSSZ
403	* 4. G'd: YYYYMMDDHHMMSSZ, if YYYY < 2050 --> UTC: YYMMDDHHMMSSZ
404	*
405	* Only strings of the 4th rule should be reformatted, but since a
406	* UTC can only present [1950, 2050), so if the given time string
407	* is less than 1950 (e.g. 19230419000000Z), we do nothing...
408	*/
409
410	if (s != NULL && t.type == V_ASN1_GENERALIZEDTIME) {
411	if (!asn1_time_to_tm(&tm, &t))
412	goto out;
413	if (is_utc(tm.tm_year)) {
414	t.length -= 2;
415	/*
416	* it's OK to let original t.data go since that's assigned
417	* to a piece of memory allocated outside of this function.
418	* new t.data would be freed after ASN1_STRING_copy is done.
419	*/
420	t.data = OPENSSL_zalloc(t.length + 1);
421	if (t.data == NULL)
422	goto out;
423	memcpy(t.data, str + 2, t.length);
424	t.type = V_ASN1_UTCTIME;
425	}
426	}
427
428	if (s == NULL \|\| ASN1_STRING_copy((ASN1_STRING )s, (ASN1_STRING )&t))
429	rv = 1;
430
431	if (t.data != (unsigned char *)str)
432	OPENSSL_free(t.data);
433	out:
434	return rv;
435	}
436
437	int ASN1_TIME_to_tm(const ASN1_TIME s, struct tm tm)
438	{
439	if (s == NULL) {
440	time_t now_t;
441
442	time(&now_t);
443	memset(tm, 0, sizeof(*tm));
444	if (OPENSSL_gmtime(&now_t, tm) != NULL)
445	return 1;
446	return 0;
447	}
448
449	return asn1_time_to_tm(tm, s);
450	}
451
452	int ASN1_TIME_diff(int pday, int psec,
453	const ASN1_TIME from, const ASN1_TIME to)
454	{
455	struct tm tm_from, tm_to;
456
457	if (!ASN1_TIME_to_tm(from, &tm_from))
458	return 0;
459	if (!ASN1_TIME_to_tm(to, &tm_to))
460	return 0;
461	return OPENSSL_gmtime_diff(pday, psec, &tm_from, &tm_to);
462	}
463
464	static const char _asn1_mon[12][4] = {
465	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
466	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
467	};
468
469	int ASN1_TIME_print(BIO bp, const ASN1_TIME tm)
470	{
471	char *v;
472	int gmt = 0, l;
473	struct tm stm;
474	const char upper_z = 0x5A, period = 0x2E;
475
476	if (!asn1_time_to_tm(&stm, tm)) {
477	/* asn1_time_to_tm will check the time type */
478	goto err;
479	}
480
481	l = tm->length;
482	v = (char *)tm->data;
483	if (v[l - 1] == upper_z)
484	gmt = 1;
485
486	if (tm->type == V_ASN1_GENERALIZEDTIME) {
487	char *f = NULL;
488	int f_len = 0;
489
490	/*
491	* Try to parse fractional seconds. '14' is the place of
492	* 'fraction point' in a GeneralizedTime string.
493	*/
494	if (tm->length > 15 && v[14] == period) {
495	f = &v[14];
496	f_len = 1;
497	while (14 + f_len < l && ascii_isdigit(f[f_len]))
498	++f_len;
499	}
500
501	return BIO_printf(bp, "%s %2d %02d:%02d:%02d%.*s %d%s",
502	_asn1_mon[stm.tm_mon], stm.tm_mday, stm.tm_hour,
503	stm.tm_min, stm.tm_sec, f_len, f, stm.tm_year + 1900,
504	(gmt ? " GMT" : "")) > 0;
505	} else {
506	return BIO_printf(bp, "%s %2d %02d:%02d:%02d %d%s",
507	_asn1_mon[stm.tm_mon], stm.tm_mday, stm.tm_hour,
508	stm.tm_min, stm.tm_sec, stm.tm_year + 1900,
509	(gmt ? " GMT" : "")) > 0;
510	}
511	err:
512	BIO_write(bp, "Bad time value", 14);
513	return 0;
514	}
515
516	int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t)
517	{
518	struct tm stm, ttm;
519	int day, sec;
520
521	if (!ASN1_TIME_to_tm(s, &stm))
522	return -2;
523
524	if (!OPENSSL_gmtime(&t, &ttm))
525	return -2;
526
527	if (!OPENSSL_gmtime_diff(&day, &sec, &ttm, &stm))
528	return -2;
529
530	if (day > 0 \|\| sec > 0)
531	return 1;
532	if (day < 0 \|\| sec < 0)
533	return -1;
534	return 0;
535	}
536
537	int ASN1_TIME_normalize(ASN1_TIME *t)
538	{
539	struct tm tm;
540
541	if (!ASN1_TIME_to_tm(t, &tm))
542	return 0;
543
544	return asn1_time_from_tm(t, &tm, V_ASN1_UNDEF) != NULL;
545	}
546
547	int ASN1_TIME_compare(const ASN1_TIME a, const ASN1_TIME b)
548	{
549	int day, sec;
550
551	if (!ASN1_TIME_diff(&day, &sec, b, a))
552	return -2;
553	if (day > 0 \|\| sec > 0)
554	return 1;
555	if (day < 0 \|\| sec < 0)
556	return -1;
557	return 0;
558	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-1.1.1l/crypto/asn1/a_time.c@ 91772

Download in other formats: