security/nss/lib/util/sectime.c

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is the Netscape security libraries.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Netscape Communications Corporation.
  18  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 #include "prlong.h"
  38 #include "prtime.h"
  39 #include "secder.h"
  40 #include "cert.h"
  41 #include "secitem.h"
  42 #include "secerr.h"
  43
  44 static const PRTime January1st2050  = LL_INIT(0x0008f81e, 0x1b098000);
  45
  46 const SEC_ASN1Template CERT_TimeChoiceTemplate[] = {
  47   { SEC_ASN1_CHOICE, offsetof(SECItem, type), 0, sizeof(SECItem) },
  48   { SEC_ASN1_UTC_TIME, 0, 0, siUTCTime },
  49   { SEC_ASN1_GENERALIZED_TIME, 0, 0, siGeneralizedTime },
  50   { 0 }
  51 };
  52
  53 SEC_ASN1_CHOOSER_IMPLEMENT(CERT_TimeChoiceTemplate)
  54
  55 const SEC_ASN1Template CERT_ValidityTemplate[] = {
  56     { SEC_ASN1_SEQUENCE,
  57           0, NULL, sizeof(CERTValidity) },
  58     { SEC_ASN1_INLINE,
  59           offsetof(CERTValidity,notBefore), CERT_TimeChoiceTemplate, 0 },
  60     { SEC_ASN1_INLINE,
  61           offsetof(CERTValidity,notAfter), CERT_TimeChoiceTemplate, 0 },
  62     { 0 }
  63 };
  64
  65 static char *DecodeUTCTime2FormattedAscii (SECItem *utcTimeDER, char *format);
  66 static char *DecodeGeneralizedTime2FormattedAscii (SECItem *generalizedTimeDER, char *format);
  67
  68 /* convert DER utc time to ascii time string */
  69 char *
  70 DER_UTCTimeToAscii(SECItem *utcTime)
  71 {
  72     return (DecodeUTCTime2FormattedAscii (utcTime, "%a %b %d %H:%M:%S %Y"));
  73 }
  74
  75 /* convert DER utc time to ascii time string, only include day, not time */
  76 char *
  77 DER_UTCDayToAscii(SECItem *utctime)
  78 {
  79     return (DecodeUTCTime2FormattedAscii (utctime, "%a %b %d, %Y"));
  80 }
  81
  82 /* convert DER generalized time to ascii time string, only include day,
  83    not time */
  84 char *
  85 DER_GeneralizedDayToAscii(SECItem *gentime)
  86 {
  87     return (DecodeGeneralizedTime2FormattedAscii (gentime, "%a %b %d, %Y"));
  88 }
  89
  90 /* convert DER generalized or UTC time to ascii time string, only include
  91    day, not time */
  92 char *
  93 DER_TimeChoiceDayToAscii(SECItem *timechoice)
  94 {
  95     switch (timechoice->type) {
  96
  97     case siUTCTime:
  98         return DER_UTCDayToAscii(timechoice);
  99
 100     case siGeneralizedTime:
 101         return DER_GeneralizedDayToAscii(timechoice);
 102
 103     default:
 104         PORT_Assert(0);
 105         PORT_SetError(SEC_ERROR_INVALID_ARGS);
 106         return NULL;
 107     }
 108 }
 109
 110
 111
 112 CERTValidity *
 113 CERT_CreateValidity(int64 notBefore, int64 notAfter)
 114 {
 115     CERTValidity *v;
 116     int rv;
 117     PRArenaPool *arena;
 118
 119     if (notBefore > notAfter) {
 120        PORT_SetError(SEC_ERROR_INVALID_ARGS);
 121        return NULL;
 122     }
 123     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
 124
 125     if ( !arena ) {
 126         return(0);
 127     }
 128
 129     v = (CERTValidity*) PORT_ArenaZAlloc(arena, sizeof(CERTValidity));
 130     if (v) {
 131         v->arena = arena;
 132         rv = DER_EncodeTimeChoice(arena, &v->notBefore, notBefore);
 133         if (rv) goto loser;
 134         rv = DER_EncodeTimeChoice(arena, &v->notAfter, notAfter);
 135         if (rv) goto loser;
 136     }
 137     return v;
 138
 139   loser:
 140     CERT_DestroyValidity(v);
 141     return 0;
 142 }
 143
 144 SECStatus
 145 CERT_CopyValidity(PRArenaPool *arena, CERTValidity *to, CERTValidity *from)
 146 {
 147     SECStatus rv;
 148
 149     CERT_DestroyValidity(to);
 150     to->arena = arena;
 151
 152     rv = SECITEM_CopyItem(arena, &to->notBefore, &from->notBefore);
 153     if (rv) return rv;
 154     rv = SECITEM_CopyItem(arena, &to->notAfter, &from->notAfter);
 155     return rv;
 156 }
 157
 158 void
 159 CERT_DestroyValidity(CERTValidity *v)
 160 {
 161     if (v && v->arena) {
 162         PORT_FreeArena(v->arena, PR_FALSE);
 163     }
 164     return;
 165 }
 166
 167 char *
 168 CERT_UTCTime2FormattedAscii (int64 utcTime, char *format)
 169 {
 170     PRExplodedTime printableTime;
 171     char *timeString;
 172
 173     /* Converse time to local time and decompose it into components */
 174     PR_ExplodeTime(utcTime, PR_LocalTimeParameters, &printableTime);
 175
 176     timeString = (char *)PORT_Alloc(100);
 177
 178     if ( timeString ) {
 179         PR_FormatTime( timeString, 100, format, &printableTime );
 180     }
 181
 182     return (timeString);
 183 }
 184
 185 char *CERT_GenTime2FormattedAscii (int64 genTime, char *format)
 186 {
 187     PRExplodedTime printableTime;
 188     char *timeString;
 189
 190     /* Decompose time into components */
 191     PR_ExplodeTime(genTime, PR_GMTParameters, &printableTime);
 192
 193     timeString = (char *)PORT_Alloc(100);
 194
 195     if ( timeString ) {
 196         PR_FormatTime( timeString, 100, format, &printableTime );
 197     }
 198
 199     return (timeString);
 200 }
 201
 202
 203 /* convert DER utc time to ascii time string, The format of the time string
 204    depends on the input "format"
 205  */
 206 static char *
 207 DecodeUTCTime2FormattedAscii (SECItem *utcTimeDER,  char *format)
 208 {
 209     int64 utcTime;
 210     int rv;
 211
 212     rv = DER_UTCTimeToTime(&utcTime, utcTimeDER);
 213     if (rv) {
 214         return(NULL);
 215     }
 216     return (CERT_UTCTime2FormattedAscii (utcTime, format));
 217 }
 218
 219 /* convert DER utc time to ascii time string, The format of the time string
 220    depends on the input "format"
 221  */
 222 static char *
 223 DecodeGeneralizedTime2FormattedAscii (SECItem *generalizedTimeDER,  char *format)
 224 {
 225     PRTime generalizedTime;
 226     int rv;
 227
 228     rv = DER_GeneralizedTimeToTime(&generalizedTime, generalizedTimeDER);
 229     if (rv) {
 230         return(NULL);
 231     }
 232     return (CERT_GeneralizedTime2FormattedAscii (generalizedTime, format));
 233 }
 234
 235 /* decode a SECItem containing either a SEC_ASN1_GENERALIZED_TIME
 236    or a SEC_ASN1_UTC_TIME */
 237
 238 SECStatus DER_DecodeTimeChoice(PRTime* output, const SECItem* input)
 239 {
 240     switch (input->type) {
 241         case siGeneralizedTime:
 242             return DER_GeneralizedTimeToTime(output, input);
 243
 244         case siUTCTime:
 245             return DER_UTCTimeToTime(output, input);
 246
 247         default:
 248             PORT_SetError(SEC_ERROR_INVALID_ARGS);
 249             PORT_Assert(0);
 250             return SECFailure;
 251     }
 252 }
 253
 254 /* encode a PRTime to an ASN.1 DER SECItem containing either a
 255    SEC_ASN1_GENERALIZED_TIME or a SEC_ASN1_UTC_TIME */
 256
 257 SECStatus DER_EncodeTimeChoice(PRArenaPool* arena, SECItem* output, PRTime input)
 258 {
 259     if (LL_CMP(input, >, January1st2050)) {
 260         return DER_TimeToGeneralizedTimeArena(arena, output, input);
 261     } else {
 262         return DER_TimeToUTCTimeArena(arena, output, input);
 263     }
 264 }