security/nss/lib/certdb/xconst.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 /*
  38  * X.509 Extension Encoding
  39  */
  40
  41 #include "prtypes.h"
  42 #include "mcom_db.h"
  43 #include "seccomon.h"
  44 #include "secdert.h"
  45 #include "secoidt.h"
  46 #include "secasn1t.h"
  47 #include "secasn1.h"
  48 #include "cert.h"
  49 #include "secder.h"
  50 #include "prprf.h"
  51 #include "xconst.h"
  52 #include "genname.h"
  53 #include "secasn1.h"
  54 #include "secerr.h"
  55
  56
  57 static const SEC_ASN1Template CERTSubjectKeyIDTemplate[] = {
  58     { SEC_ASN1_OCTET_STRING }
  59 };
  60
  61
  62 static const SEC_ASN1Template CERTIA5TypeTemplate[] = {
  63     { SEC_ASN1_IA5_STRING }
  64 };
  65
  66
  67 static const SEC_ASN1Template CERTPrivateKeyUsagePeriodTemplate[] = {
  68     { SEC_ASN1_SEQUENCE,
  69       0, NULL, sizeof(CERTPrivKeyUsagePeriod) },
  70     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC  | 0,
  71           offsetof(CERTPrivKeyUsagePeriod, notBefore),
  72           SEC_GeneralizedTimeTemplate},
  73     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC  | 1,
  74           offsetof(CERTPrivKeyUsagePeriod, notAfter),
  75           SEC_GeneralizedTimeTemplate},
  76     { 0, }
  77 };
  78
  79
  80 const SEC_ASN1Template CERTAltNameTemplate[] = {
  81     { SEC_ASN1_CONSTRUCTED, offsetof(CERTAltNameEncodedContext, encodedGenName),
  82       CERT_GeneralNamesTemplate}
  83 };
  84
  85 const SEC_ASN1Template CERTAuthInfoAccessItemTemplate[] = {
  86     { SEC_ASN1_SEQUENCE,
  87       0, NULL, sizeof(CERTAuthInfoAccess) },
  88     { SEC_ASN1_OBJECT_ID,
  89       offsetof(CERTAuthInfoAccess, method) },
  90     { SEC_ASN1_ANY,
  91       offsetof(CERTAuthInfoAccess, derLocation) },
  92     { 0, }
  93 };
  94
  95 const SEC_ASN1Template CERTAuthInfoAccessTemplate[] = {
  96     { SEC_ASN1_SEQUENCE_OF, 0, CERTAuthInfoAccessItemTemplate }
  97 };
  98
  99
 100 SECStatus
 101 CERT_EncodeSubjectKeyID(PRArenaPool *arena, char *value, int len, SECItem *encodedValue)
 102 {
 103     SECItem encodeContext;
 104     SECStatus rv = SECSuccess;
 105
 106
 107     PORT_Memset (&encodeContext, 0, sizeof (encodeContext));
 108
 109     if (value != NULL) {
 110         encodeContext.data = (unsigned char *)value;
 111         encodeContext.len = len;
 112     }
 113     if (SEC_ASN1EncodeItem (arena, encodedValue, &encodeContext,
 114                             CERTSubjectKeyIDTemplate) == NULL) {
 115         rv = SECFailure;
 116     }
 117
 118     return(rv);
 119 }
 120
 121
 122 SECStatus
 123 CERT_EncodePrivateKeyUsagePeriod(PRArenaPool *arena,
 124                                 CERTPrivKeyUsagePeriod *pkup,
 125                                 SECItem *encodedValue)
 126 {
 127     SECStatus rv = SECSuccess;
 128
 129     if (SEC_ASN1EncodeItem (arena, encodedValue, pkup,
 130                             CERTPrivateKeyUsagePeriodTemplate) == NULL) {
 131         rv = SECFailure;
 132     }
 133     return(rv);
 134 }
 135
 136 CERTPrivKeyUsagePeriod *
 137 CERT_DecodePrivKeyUsagePeriodExtension(PLArenaPool *arena, SECItem *extnValue)
 138 {
 139     SECStatus rv;
 140     CERTPrivKeyUsagePeriod *pPeriod;
 141     SECItem newExtnValue;
 142
 143     /* allocate the certificate policies structure */
 144     pPeriod = PORT_ArenaZNew(arena, CERTPrivKeyUsagePeriod);
 145     if ( pPeriod == NULL ) {
 146         goto loser;
 147     }
 148
 149     pPeriod->arena = arena;
 150
 151     /* copy the DER into the arena, since Quick DER returns data that points
 152        into the DER input, which may get freed by the caller */
 153     rv = SECITEM_CopyItem(arena, &newExtnValue, extnValue);
 154     if ( rv != SECSuccess ) {
 155         goto loser;
 156     }
 157
 158     rv = SEC_QuickDERDecodeItem(arena, pPeriod,
 159                                 CERTPrivateKeyUsagePeriodTemplate,
 160                                 &newExtnValue);
 161     if ( rv != SECSuccess ) {
 162         goto loser;
 163     }
 164     return pPeriod;
 165
 166 loser:
 167     return NULL;
 168 }
 169
 170
 171 SECStatus
 172 CERT_EncodeIA5TypeExtension(PRArenaPool *arena, char *value, SECItem *encodedValue)
 173 {
 174     SECItem encodeContext;
 175     SECStatus rv = SECSuccess;
 176
 177
 178     PORT_Memset (&encodeContext, 0, sizeof (encodeContext));
 179
 180     if (value != NULL) {
 181         encodeContext.data = (unsigned char *)value;
 182         encodeContext.len = strlen(value);
 183     }
 184     if (SEC_ASN1EncodeItem (arena, encodedValue, &encodeContext,
 185                             CERTIA5TypeTemplate) == NULL) {
 186         rv = SECFailure;
 187     }
 188
 189     return(rv);
 190 }
 191
 192 SECStatus
 193 CERT_EncodeAltNameExtension(PRArenaPool *arena,  CERTGeneralName  *value, SECItem *encodedValue)
 194 {
 195     SECItem                **encodedGenName;
 196     SECStatus              rv = SECSuccess;
 197
 198     encodedGenName = cert_EncodeGeneralNames(arena, value);
 199     if (SEC_ASN1EncodeItem (arena, encodedValue, &encodedGenName,
 200                             CERT_GeneralNamesTemplate) == NULL) {
 201         rv = SECFailure;
 202     }
 203
 204     return rv;
 205 }
 206
 207 CERTGeneralName *
 208 CERT_DecodeAltNameExtension(PRArenaPool *reqArena, SECItem *EncodedAltName)
 209 {
 210     SECStatus                  rv = SECSuccess;
 211     CERTAltNameEncodedContext  encodedContext;
 212     SECItem*                   newEncodedAltName;
 213
 214     if (!reqArena) {
 215         PORT_SetError(SEC_ERROR_INVALID_ARGS);
 216         return NULL;
 217     }
 218
 219     newEncodedAltName = SECITEM_ArenaDupItem(reqArena, EncodedAltName);
 220     if (!newEncodedAltName) {
 221         return NULL;
 222     }
 223
 224     encodedContext.encodedGenName = NULL;
 225     PORT_Memset(&encodedContext, 0, sizeof(CERTAltNameEncodedContext));
 226     rv = SEC_QuickDERDecodeItem (reqArena, &encodedContext,
 227                                  CERT_GeneralNamesTemplate, newEncodedAltName);
 228     if (rv == SECFailure) {
 229         goto loser;
 230     }
 231     if (encodedContext.encodedGenName && encodedContext.encodedGenName[0])
 232         return cert_DecodeGeneralNames(reqArena,
 233                                        encodedContext.encodedGenName);
 234     /* Extension contained an empty GeneralNames sequence */
 235     /* Treat as extension not found */
 236     PORT_SetError(SEC_ERROR_EXTENSION_NOT_FOUND);
 237 loser:
 238     return NULL;
 239 }
 240
 241
 242 SECStatus
 243 CERT_EncodeNameConstraintsExtension(PRArenaPool          *arena,
 244                                     CERTNameConstraints  *value,
 245                                     SECItem              *encodedValue)
 246 {
 247     SECStatus     rv = SECSuccess;
 248
 249     rv = cert_EncodeNameConstraints(value, arena, encodedValue);
 250     return rv;
 251 }
 252
 253
 254 CERTNameConstraints *
 255 CERT_DecodeNameConstraintsExtension(PRArenaPool          *arena,
 256                                     SECItem              *encodedConstraints)
 257 {
 258     return cert_DecodeNameConstraints(arena, encodedConstraints);
 259 }
 260
 261
 262 CERTAuthInfoAccess **
 263 CERT_DecodeAuthInfoAccessExtension(PRArenaPool *reqArena,
 264                                    SECItem     *encodedExtension)
 265 {
 266     CERTAuthInfoAccess **info = NULL;
 267     SECStatus rv;
 268     int i;
 269     SECItem* newEncodedExtension;
 270
 271     if (!reqArena) {
 272         PORT_SetError(SEC_ERROR_INVALID_ARGS);
 273         return NULL;
 274     }
 275
 276     newEncodedExtension = SECITEM_ArenaDupItem(reqArena, encodedExtension);
 277     if (!newEncodedExtension) {
 278         return NULL;
 279     }
 280
 281     rv = SEC_QuickDERDecodeItem(reqArena, &info, CERTAuthInfoAccessTemplate,
 282                             newEncodedExtension);
 283     if (rv != SECSuccess || info == NULL) {
 284         return NULL;
 285     }
 286
 287     for (i = 0; info[i] != NULL; i++) {
 288         info[i]->location = CERT_DecodeGeneralName(reqArena,
 289                                                    &(info[i]->derLocation),
 290                                                    NULL);
 291     }
 292     return info;
 293 }
 294
 295 SECStatus
 296 cert_EncodeAuthInfoAccessExtension(PRArenaPool *arena,
 297                                    CERTAuthInfoAccess **info,
 298                                    SECItem *dest)
 299 {
 300     SECItem *dummy;
 301     int i;
 302
 303     PORT_Assert(info != NULL);
 304     PORT_Assert(dest != NULL);
 305     if (info == NULL || dest == NULL) {
 306         return SECFailure;
 307     }
 308
 309     for (i = 0; info[i] != NULL; i++) {
 310         if (CERT_EncodeGeneralName(info[i]->location, &(info[i]->derLocation),
 311                                    arena) == NULL)
 312             /* Note that this may leave some of the locations filled in. */
 313             return SECFailure;
 314     }
 315     dummy = SEC_ASN1EncodeItem(arena, dest, &info,
 316                                CERTAuthInfoAccessTemplate);
 317     if (dummy == NULL) {
 318         return SECFailure;
 319     }
 320     return SECSuccess;
 321 }