[apple/security.git] / AppleX509TP / tpTime.c

/*
 * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
 * 
 * The contents of this file constitute Original Code as defined in and are
 * subject to the Apple Public Source License Version 1.2 (the 'License').
 * You may not use this file except in compliance with the License. Please obtain
 * a copy of the License at http://www.apple.com/publicsource and read it before
 * using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
 * specific language governing rights and limitations under the License.
 */


/*
 * tpTime.c - cert related time functions
 *
 * Written 10/10/2000 by Doug Mitchell.
 */
 
#include "tpTime.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <stdbool.h>

/*
 * Given a string containing either a UTC-style or "generalized time"
 * time string, convert to a struct tm (in GMT/UTC). Returns nonzero on
 * error. 
 */
int timeStringToTm(
	const char			*str,
	unsigned			len,
	struct tm			*tmp)
{
	char 		szTemp[5];
	bool 		isUtc = false;			// 2-digit year
	bool		isCssmTime = false;		// no trailing 'Z'
	unsigned 	x;
	unsigned 	i;
	char 		*cp;

	if((str == NULL) || (len == 0) || (tmp == NULL)) {
    	return 1;
  	}
  	
  	/* tolerate NULL terminated or not */
  	if(str[len - 1] == '\0') {
  		len--;
  	}
  	switch(len) {
  		case UTC_TIME_STRLEN:			// 2-digit year, not Y2K compliant
  			isUtc = true;
  			break;
		case CSSM_TIME_STRLEN:
			isCssmTime = true;
			break;
  		case GENERALIZED_TIME_STRLEN:	// 4-digit year
  			break;
  		default:						// unknown format 
  			return 1;
  	}
  	
  	cp = (char *)str;
  	
	/* check that all characters except last are digits */
	for(i=0; i<(len - 1); i++) {
		if ( !(isdigit(cp[i])) ) {
		  	return 1;
		}
	}

  	/* check last character is a 'Z' or digit as appropriate */
	if(isCssmTime) {
		if(!isdigit(cp[len - 1])) {
			return 1;
		}
	}
	else {
		if(cp[len - 1] != 'Z' )	{
			return 1;
		}
	}
	
  	/* YEAR */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	if(!isUtc) {
		/* two more digits */
		szTemp[2] = *cp++;
		szTemp[3] = *cp++;
		szTemp[4] = '\0';
	}
	else { 
		szTemp[2] = '\0';
	}
	x = atoi( szTemp );
	if(isUtc) {
		/* 
		 * 2-digit year. 
		 *   0  <= year <  50 : assume century 21
		 *   50 <= year <  70 : illegal per PKIX
		 *   ...though we allow this as of 10/10/02...dmitch
		 *   70 <  year <= 99 : assume century 20
		 */
		if(x < 50) {
			x += 2000;
		}
		/*
		else if(x < 70) {
			return 1;
		}
		*/
		else {
			/* century 20 */
			x += 1900;			
		}
	}
  	/* by definition - tm_year is year - 1900 */
  	tmp->tm_year = x - 1900;

  	/* MONTH */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	/* in the string, months are from 1 to 12 */
	if((x > 12) || (x <= 0)) {
    	return 1;
	}
	/* in a tm, 0 to 11 */
  	tmp->tm_mon = x - 1;

 	/* DAY */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	/* 1..31 in both formats */
	if((x > 31) || (x <= 0)) {
		return 1;
	}
  	tmp->tm_mday = x;

	/* HOUR */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	if((x > 23) || (x < 0)) {
		return 1;
	}
	tmp->tm_hour = x;

  	/* MINUTE */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	if((x > 59) || (x < 0)) {
		return 1;
	}
  	tmp->tm_min = x;

  	/* SECOND */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
  	x = atoi( szTemp );
	if((x > 59) || (x < 0)) {
		return 1;
	}
  	tmp->tm_sec = x;
	return 0;
}

/* 
 * Return current GMT time as a struct tm.
 * Caller must hold tpTimeLock.
 */
void nowTime(
	struct tm *now)
{
	time_t nowTime = time(NULL);
	*now = *gmtime(&nowTime);
}

/*
 * Compare two times. Assumes they're both in GMT. Returns:
 * -1 if t1 <  t2
 *  0 if t1 == t2
 *  1 if t1 >  t2
 */
int compareTimes(
	const struct tm 	*t1,
	const struct tm 	*t2)
{
	if(t1->tm_year > t2->tm_year) {
		return 1;
	}
	else if(t1->tm_year < t2->tm_year) {
		return -1;
	}
	/* year equal */
	else if(t1->tm_mon > t2->tm_mon) {
		return 1;
	}
	else if(t1->tm_mon < t2->tm_mon) {
		return -1;
	}
	/* month equal */
	else if(t1->tm_mday > t2->tm_mday) {
		return 1;
	}
	else if(t1->tm_mday < t2->tm_mday) {
		return -1;
	}
	/* day of month equal */
	else if(t1->tm_hour > t2->tm_hour) {
		return 1;
	}
	else if(t1->tm_hour < t2->tm_hour) {
		return -1;
	}
	/* hour equal */
	else if(t1->tm_min > t2->tm_min) {
		return 1;
	}
	else if(t1->tm_min < t2->tm_min) {
		return -1;
	}
	/* minute equal */
	else if(t1->tm_sec > t2->tm_sec) {
		return 1;
	}
	else if(t1->tm_sec < t2->tm_sec) {
		return -1;
	}
	/* equal */
	return 0;
}

/*
 * Create a time string, in either UTC (2-digit) or or Generalized (4-digit)
 * year format. Caller mallocs the output string whose length is at least
 * (UTC_TIME_STRLEN+1), (GENERALIZED_TIME_STRLEN+1), or (CSSM_TIME_STRLEN+1)
 * respectively. Caller must hold tpTimeLock.
 */
void timeAtNowPlus(unsigned secFromNow, 
	TpTimeSpec timeSpec,
	char *outStr)
{
	struct tm utc;
	time_t baseTime;
	
	baseTime = time(NULL);
	baseTime += (time_t)secFromNow;
	utc = *gmtime(&baseTime);
	
	switch(timeSpec) {
		case TIME_UTC:
			/* UTC - 2 year digits - code which parses this assumes that
			 * (2-digit) years between 0 and 49 are in century 21 */
			if(utc.tm_year >= 100) {
				utc.tm_year -= 100;
			}
			sprintf(outStr, "%02d%02d%02d%02d%02d%02dZ",
				utc.tm_year /* + 1900 */, utc.tm_mon + 1,
				utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
			break;
		case TIME_GEN:
			sprintf(outStr, "%04d%02d%02d%02d%02d%02dZ",
				/* note year is relative to 1900, hopefully it'll have 
				* four valid digits! */
				utc.tm_year + 1900, utc.tm_mon + 1,
				utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
			break;
		case TIME_CSSM:
			sprintf(outStr, "%04d%02d%02d%02d%02d%02d",
				/* note year is relative to 1900, hopefully it'll have 
				* four valid digits! */
				utc.tm_year + 1900, utc.tm_mon + 1,
				utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
			break;
	}
}

/*
 * Convert a time string, which can be in any of three forms (UTC,
 * generalized, or CSSM_TIMESTRING) into a CSSM_TIMESTRING. Caller
 * mallocs the result, which must be at least (CSSM_TIME_STRLEN+1) bytes.
 * Returns nonzero if incoming time string is badly formed. 
 */
int tpTimeToCssmTimestring(
	const char 	*inStr,			// not necessarily NULL terminated
	unsigned	inStrLen,		// not including possible NULL
	char 		*outTime)
{
	if((inStrLen == 0) || (inStr == NULL)) {
		return 1;
	}
	outTime[0] = '\0';
	switch(inStrLen) {
		case UTC_TIME_STRLEN:
		{
			/* infer century and prepend to output */
			char tmp[3];
			int year;
			tmp[0] = inStr[0];
			tmp[1] = inStr[1];
			tmp[2] = '\0';
			year = atoi(tmp);
			
			/* 
			 *   0  <= year <  50 : assume century 21
			 *   50 <= year <  70 : illegal per PKIX
			 *   70 <  year <= 99 : assume century 20
			 */
			if(year < 50) {
				/* century 21 */
				strcpy(outTime, "20");
			}
			else if(year < 70) {
				return 1;
			}
			else {
				/* century 20 */
				strcpy(outTime, "19");
			}
			memmove(outTime + 2, inStr, inStrLen - 1);		// don't copy the Z
			break;
		}
		case CSSM_TIME_STRLEN:
			memmove(outTime, inStr, inStrLen);				// trivial case
			break;
		case GENERALIZED_TIME_STRLEN:
			memmove(outTime, inStr, inStrLen - 1);			// don't copy the Z
			break;
		
		default:
			return 1;
	}
	outTime[CSSM_TIME_STRLEN] = '\0';
	return 0;
}
Commit	Line	Data
bac41a7b A	1	/*
	2	* Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
	3	*
	4	* The contents of this file constitute Original Code as defined in and are
	5	* subject to the Apple Public Source License Version 1.2 (the 'License').
	6	* You may not use this file except in compliance with the License. Please obtain
	7	* a copy of the License at http://www.apple.com/publicsource and read it before
	8	* using this file.
	9	*
	10	* This Original Code and all software distributed under the License are
	11	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
	12	* OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
	13	* LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
	14	* PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
	15	* specific language governing rights and limitations under the License.
	16	*/
	17
	18
	19	/*
	20	* tpTime.c - cert related time functions
	21	*
	22	* Written 10/10/2000 by Doug Mitchell.
	23	*/
	24
	25	#include "tpTime.h"
	26	#include <string.h>
	27	#include <stdlib.h>
	28	#include <stdio.h>
	29	#include <ctype.h>
29654253	30	#include <stdbool.h>
bac41a7b A	31
	32	/*
	33	* Given a string containing either a UTC-style or "generalized time"
	34	* time string, convert to a struct tm (in GMT/UTC). Returns nonzero on
	35	* error.
	36	*/
	37	int timeStringToTm(
	38	const char *str,
	39	unsigned len,
	40	struct tm *tmp)
	41	{
	42	char szTemp[5];
29654253 A	43	bool isUtc = false; // 2-digit year
29654253 A	44	bool isCssmTime = false; // no trailing 'Z'
bac41a7b A	45	unsigned x;
	46	unsigned i;
	47	char *cp;
	48
	49	if((str == NULL) \|\| (len == 0) \|\| (tmp == NULL)) {
	50	return 1;
	51	}
	52
	53	/* tolerate NULL terminated or not */
	54	if(str[len - 1] == '\0') {
	55	len--;
	56	}
	57	switch(len) {
	58	case UTC_TIME_STRLEN: // 2-digit year, not Y2K compliant
29654253	59	isUtc = true;
bac41a7b	60	break;
29654253 A	61	case CSSM_TIME_STRLEN:
	62	isCssmTime = true;
	63	break;
bac41a7b	64	case GENERALIZED_TIME_STRLEN: // 4-digit year
bac41a7b A	65	break;
	66	default: // unknown format
	67	return 1;
	68	}
	69
	70	cp = (char *)str;
	71
	72	/* check that all characters except last are digits */
	73	for(i=0; i<(len - 1); i++) {
	74	if ( !(isdigit(cp[i])) ) {
	75	return 1;
	76	}
	77	}
	78
29654253 A	79	/* check last character is a 'Z' or digit as appropriate */
	80	if(isCssmTime) {
	81	if(!isdigit(cp[len - 1])) {
	82	return 1;
	83	}
	84	}
	85	else {
	86	if(cp[len - 1] != 'Z' ) {
	87	return 1;
	88	}
	89	}
	90
bac41a7b A	91	/* YEAR */
	92	szTemp[0] = *cp++;
	93	szTemp[1] = *cp++;
	94	if(!isUtc) {
	95	/* two more digits */
	96	szTemp[2] = *cp++;
	97	szTemp[3] = *cp++;
	98	szTemp[4] = '\0';
	99	}
	100	else {
	101	szTemp[2] = '\0';
	102	}
	103	x = atoi( szTemp );
	104	if(isUtc) {
	105	/*
	106	* 2-digit year.
	107	* 0 <= year < 50 : assume century 21
	108	* 50 <= year < 70 : illegal per PKIX
df0e469f	109	* ...though we allow this as of 10/10/02...dmitch
bac41a7b A	110	* 70 < year <= 99 : assume century 20
	111	*/
	112	if(x < 50) {
	113	x += 2000;
	114	}
df0e469f	115	/*
bac41a7b A	116	else if(x < 70) {
	117	return 1;
	118	}
df0e469f	119	*/
bac41a7b A	120	else {
	121	/* century 20 */
	122	x += 1900;
	123	}
	124	}
	125	/* by definition - tm_year is year - 1900 */
	126	tmp->tm_year = x - 1900;
	127
	128	/* MONTH */
	129	szTemp[0] = *cp++;
	130	szTemp[1] = *cp++;
	131	szTemp[2] = '\0';
	132	x = atoi( szTemp );
	133	/* in the string, months are from 1 to 12 */
	134	if((x > 12) \|\| (x <= 0)) {
	135	return 1;
	136	}
	137	/* in a tm, 0 to 11 */
	138	tmp->tm_mon = x - 1;
	139
	140	/* DAY */
	141	szTemp[0] = *cp++;
	142	szTemp[1] = *cp++;
	143	szTemp[2] = '\0';
	144	x = atoi( szTemp );
	145	/* 1..31 in both formats */
	146	if((x > 31) \|\| (x <= 0)) {
	147	return 1;
	148	}
	149	tmp->tm_mday = x;
	150
	151	/* HOUR */
	152	szTemp[0] = *cp++;
	153	szTemp[1] = *cp++;
	154	szTemp[2] = '\0';
	155	x = atoi( szTemp );
	156	if((x > 23) \|\| (x < 0)) {
	157	return 1;
	158	}
	159	tmp->tm_hour = x;
	160
	161	/* MINUTE */
	162	szTemp[0] = *cp++;
	163	szTemp[1] = *cp++;
	164	szTemp[2] = '\0';
	165	x = atoi( szTemp );
	166	if((x > 59) \|\| (x < 0)) {
	167	return 1;
	168	}
	169	tmp->tm_min = x;
	170
	171	/* SECOND */
	172	szTemp[0] = *cp++;
	173	szTemp[1] = *cp++;
	174	szTemp[2] = '\0';
	175	x = atoi( szTemp );
	176	if((x > 59) \|\| (x < 0)) {
	177	return 1;
	178	}
	179	tmp->tm_sec = x;
	180	return 0;
	181	}
	182
29654253 A	183	/*
	184	* Return current GMT time as a struct tm.
	185	* Caller must hold tpTimeLock.
	186	*/
bac41a7b A	187	void nowTime(
	188	struct tm *now)
	189	{
	190	time_t nowTime = time(NULL);
	191	now = gmtime(&nowTime);
	192	}
	193
	194	/*
	195	* Compare two times. Assumes they're both in GMT. Returns:
	196	* -1 if t1 < t2
	197	* 0 if t1 == t2
	198	* 1 if t1 > t2
	199	*/
	200	int compareTimes(
	201	const struct tm *t1,
	202	const struct tm *t2)
	203	{
	204	if(t1->tm_year > t2->tm_year) {
	205	return 1;
	206	}
	207	else if(t1->tm_year < t2->tm_year) {
	208	return -1;
	209	}
	210	/* year equal */
	211	else if(t1->tm_mon > t2->tm_mon) {
	212	return 1;
	213	}
	214	else if(t1->tm_mon < t2->tm_mon) {
	215	return -1;
	216	}
	217	/* month equal */
	218	else if(t1->tm_mday > t2->tm_mday) {
	219	return 1;
	220	}
	221	else if(t1->tm_mday < t2->tm_mday) {
	222	return -1;
	223	}
	224	/* day of month equal */
	225	else if(t1->tm_hour > t2->tm_hour) {
	226	return 1;
	227	}
	228	else if(t1->tm_hour < t2->tm_hour) {
	229	return -1;
	230	}
	231	/* hour equal */
	232	else if(t1->tm_min > t2->tm_min) {
	233	return 1;
	234	}
	235	else if(t1->tm_min < t2->tm_min) {
	236	return -1;
	237	}
	238	/* minute equal */
	239	else if(t1->tm_sec > t2->tm_sec) {
	240	return 1;
	241	}
	242	else if(t1->tm_sec < t2->tm_sec) {
	243	return -1;
	244	}
	245	/* equal */
	246	return 0;
	247	}
	248
29654253 A	249	/*
	250	* Create a time string, in either UTC (2-digit) or or Generalized (4-digit)
	251	* year format. Caller mallocs the output string whose length is at least
df0e469f A	252	* (UTC_TIME_STRLEN+1), (GENERALIZED_TIME_STRLEN+1), or (CSSM_TIME_STRLEN+1)
df0e469f A	253	* respectively. Caller must hold tpTimeLock.
29654253 A	254	*/
	255	void timeAtNowPlus(unsigned secFromNow,
	256	TpTimeSpec timeSpec,
	257	char *outStr)
	258	{
	259	struct tm utc;
	260	time_t baseTime;
	261
	262	baseTime = time(NULL);
	263	baseTime += (time_t)secFromNow;
	264	utc = *gmtime(&baseTime);
	265
df0e469f A	266	switch(timeSpec) {
	267	case TIME_UTC:
	268	/* UTC - 2 year digits - code which parses this assumes that
	269	* (2-digit) years between 0 and 49 are in century 21 */
	270	if(utc.tm_year >= 100) {
	271	utc.tm_year -= 100;
	272	}
	273	sprintf(outStr, "%02d%02d%02d%02d%02d%02dZ",
	274	utc.tm_year /* + 1900 */, utc.tm_mon + 1,
	275	utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
	276	break;
	277	case TIME_GEN:
	278	sprintf(outStr, "%04d%02d%02d%02d%02d%02dZ",
	279	/* note year is relative to 1900, hopefully it'll have
	280	* four valid digits! */
	281	utc.tm_year + 1900, utc.tm_mon + 1,
	282	utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
	283	break;
	284	case TIME_CSSM:
	285	sprintf(outStr, "%04d%02d%02d%02d%02d%02d",
	286	/* note year is relative to 1900, hopefully it'll have
	287	* four valid digits! */
	288	utc.tm_year + 1900, utc.tm_mon + 1,
	289	utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
	290	break;
29654253	291	}
df0e469f A	292	}
	293
	294	/*
	295	* Convert a time string, which can be in any of three forms (UTC,
	296	* generalized, or CSSM_TIMESTRING) into a CSSM_TIMESTRING. Caller
	297	* mallocs the result, which must be at least (CSSM_TIME_STRLEN+1) bytes.
	298	* Returns nonzero if incoming time string is badly formed.
	299	*/
	300	int tpTimeToCssmTimestring(
	301	const char *inStr, // not necessarily NULL terminated
	302	unsigned inStrLen, // not including possible NULL
	303	char *outTime)
	304	{
	305	if((inStrLen == 0) \|\| (inStr == NULL)) {
	306	return 1;
	307	}
	308	outTime[0] = '\0';
	309	switch(inStrLen) {
	310	case UTC_TIME_STRLEN:
	311	{
	312	/* infer century and prepend to output */
	313	char tmp[3];
	314	int year;
	315	tmp[0] = inStr[0];
	316	tmp[1] = inStr[1];
	317	tmp[2] = '\0';
	318	year = atoi(tmp);
	319
	320	/*
	321	* 0 <= year < 50 : assume century 21
	322	* 50 <= year < 70 : illegal per PKIX
	323	* 70 < year <= 99 : assume century 20
	324	*/
	325	if(year < 50) {
	326	/* century 21 */
	327	strcpy(outTime, "20");
	328	}
	329	else if(year < 70) {
	330	return 1;
	331	}
	332	else {
	333	/* century 20 */
	334	strcpy(outTime, "19");
	335	}
	336	memmove(outTime + 2, inStr, inStrLen - 1); // don't copy the Z
	337	break;
	338	}
	339	case CSSM_TIME_STRLEN:
	340	memmove(outTime, inStr, inStrLen); // trivial case
	341	break;
	342	case GENERALIZED_TIME_STRLEN:
	343	memmove(outTime, inStr, inStrLen - 1); // don't copy the Z
	344	break;
	345
	346	default:
	347	return 1;
29654253	348	}
df0e469f A	349	outTime[CSSM_TIME_STRLEN] = '\0';
df0e469f A	350	return 0;
29654253	351	}
df0e469f	352