The Tor Browser / file revision

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

  * X.509 Extension Encoding  

  */

 #include "prtypes.h"

 #include "seccomon.h"

 #include "secdert.h"

 #include "secoidt.h"

 #include "secasn1t.h"

 #include "secasn1.h"

 #include "cert.h"

 #include "secder.h"

 #include "prprf.h"

 #include "xconst.h"

 #include "genname.h"

 #include "secasn1.h"

 #include "secerr.h"

 static const SEC_ASN1Template CERTSubjectKeyIDTemplate[] = {

     { SEC_ASN1_OCTET_STRING }

 };

 static const SEC_ASN1Template CERTIA5TypeTemplate[] = {

     { SEC_ASN1_IA5_STRING }

 };

 SEC_ASN1_MKSUB(SEC_GeneralizedTimeTemplate)

 static const SEC_ASN1Template CERTPrivateKeyUsagePeriodTemplate[] = {

     { SEC_ASN1_SEQUENCE,

       0, NULL, sizeof(CERTPrivKeyUsagePeriod) },

     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC  | SEC_ASN1_XTRN | 0,

 	  offsetof(CERTPrivKeyUsagePeriod, notBefore), 

 	  SEC_ASN1_SUB(SEC_GeneralizedTimeTemplate) },

     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC  | SEC_ASN1_XTRN | 1,

 	  offsetof(CERTPrivKeyUsagePeriod, notAfter), 

 	  SEC_ASN1_SUB(SEC_GeneralizedTimeTemplate)},

     { 0, } 

 };

 const SEC_ASN1Template CERTAltNameTemplate[] = {

     { SEC_ASN1_CONSTRUCTED, offsetof(CERTAltNameEncodedContext, encodedGenName), 

       CERT_GeneralNamesTemplate}

 };

 const SEC_ASN1Template CERTAuthInfoAccessItemTemplate[] = {

     { SEC_ASN1_SEQUENCE,

       0, NULL, sizeof(CERTAuthInfoAccess) },

     { SEC_ASN1_OBJECT_ID,

       offsetof(CERTAuthInfoAccess, method) },

     { SEC_ASN1_ANY,

       offsetof(CERTAuthInfoAccess, derLocation) },

     { 0, }

 };

 const SEC_ASN1Template CERTAuthInfoAccessTemplate[] = {

     { SEC_ASN1_SEQUENCE_OF, 0, CERTAuthInfoAccessItemTemplate }

 };

 SECStatus 

 CERT_EncodeSubjectKeyID(PLArenaPool *arena, const SECItem* srcString,

                         SECItem *encodedValue)

 {

     SECStatus rv = SECSuccess;

     if (!srcString) {

         PORT_SetError(SEC_ERROR_INVALID_ARGS);

         return SECFailure;

     }

     if (SEC_ASN1EncodeItem (arena, encodedValue, srcString,

 			    CERTSubjectKeyIDTemplate) == NULL) {

 	rv = SECFailure;

     }

     return(rv);

 }

 SECStatus

 CERT_EncodePrivateKeyUsagePeriod(PLArenaPool *arena,

                                 CERTPrivKeyUsagePeriod *pkup, 

 				SECItem *encodedValue)

 {

     SECStatus rv = SECSuccess;

     if (SEC_ASN1EncodeItem (arena, encodedValue, pkup,

 			    CERTPrivateKeyUsagePeriodTemplate) == NULL) {

 	rv = SECFailure;

     }

     return(rv);

 }

 CERTPrivKeyUsagePeriod *

 CERT_DecodePrivKeyUsagePeriodExtension(PLArenaPool *arena, SECItem *extnValue)

 {

     SECStatus rv;

     CERTPrivKeyUsagePeriod *pPeriod;

     SECItem newExtnValue;

     /* allocate the certificate policies structure */

     pPeriod = PORT_ArenaZNew(arena, CERTPrivKeyUsagePeriod);

     if ( pPeriod == NULL ) {

 	goto loser;

     }

     pPeriod->arena = arena;

     /* copy the DER into the arena, since Quick DER returns data that points

        into the DER input, which may get freed by the caller */

     rv = SECITEM_CopyItem(arena, &newExtnValue, extnValue);

     if ( rv != SECSuccess ) {

 	goto loser;

     }

     rv = SEC_QuickDERDecodeItem(arena, pPeriod, 

                                 CERTPrivateKeyUsagePeriodTemplate,

 			        &newExtnValue);

     if ( rv != SECSuccess ) {

 	goto loser;

     }

     return pPeriod;

 loser:

     return NULL;

 }

 SECStatus 

 CERT_EncodeIA5TypeExtension(PLArenaPool *arena, char *value, SECItem *encodedValue)

 {

     SECItem encodeContext;

     SECStatus rv = SECSuccess;

     PORT_Memset (&encodeContext, 0, sizeof (encodeContext));

     if (value != NULL) {

 	encodeContext.data = (unsigned char *)value;

 	encodeContext.len = strlen(value);

     }

     if (SEC_ASN1EncodeItem (arena, encodedValue, &encodeContext,

 			    CERTIA5TypeTemplate) == NULL) {

 	rv = SECFailure;

     }

     return(rv);

 }

 SECStatus

 CERT_EncodeAltNameExtension(PLArenaPool *arena,  CERTGeneralName  *value, SECItem *encodedValue)

 {

     SECItem                **encodedGenName;

     SECStatus              rv = SECSuccess;

     encodedGenName = cert_EncodeGeneralNames(arena, value);

     if (SEC_ASN1EncodeItem (arena, encodedValue, &encodedGenName,

 			    CERT_GeneralNamesTemplate) == NULL) {

 	rv = SECFailure;

     }

     return rv;

 }

 CERTGeneralName *

 CERT_DecodeAltNameExtension(PLArenaPool *reqArena, SECItem *EncodedAltName)

 {

     SECStatus                  rv = SECSuccess;

     CERTAltNameEncodedContext  encodedContext;

     SECItem*                   newEncodedAltName;

     if (!reqArena) {

         PORT_SetError(SEC_ERROR_INVALID_ARGS);

         return NULL;

     }

     newEncodedAltName = SECITEM_ArenaDupItem(reqArena, EncodedAltName);

     if (!newEncodedAltName) {

         return NULL;

     }

     encodedContext.encodedGenName = NULL;

     PORT_Memset(&encodedContext, 0, sizeof(CERTAltNameEncodedContext));

     rv = SEC_QuickDERDecodeItem (reqArena, &encodedContext,

                                  CERT_GeneralNamesTemplate, newEncodedAltName);

     if (rv == SECFailure) {

 	goto loser;

     }

     if (encodedContext.encodedGenName && encodedContext.encodedGenName[0])

 	return cert_DecodeGeneralNames(reqArena,

                                        encodedContext.encodedGenName);

     /* Extension contained an empty GeneralNames sequence */

     /* Treat as extension not found */

     PORT_SetError(SEC_ERROR_EXTENSION_NOT_FOUND);

 loser:

     return NULL;

 }

 SECStatus

 CERT_EncodeNameConstraintsExtension(PLArenaPool          *arena, 

 				    CERTNameConstraints  *value,

 				    SECItem              *encodedValue)

 {

     SECStatus     rv = SECSuccess;

     rv = cert_EncodeNameConstraints(value, arena, encodedValue);

     return rv;

 }

 CERTNameConstraints *

 CERT_DecodeNameConstraintsExtension(PLArenaPool          *arena,

 				    const SECItem        *encodedConstraints)

 {

     return cert_DecodeNameConstraints(arena, encodedConstraints);

 }

 CERTAuthInfoAccess **

 CERT_DecodeAuthInfoAccessExtension(PLArenaPool *reqArena,

 				   SECItem     *encodedExtension)

 {

     CERTAuthInfoAccess **info = NULL;

     SECStatus rv;

     int i;

     SECItem* newEncodedExtension;

     if (!reqArena) {

         PORT_SetError(SEC_ERROR_INVALID_ARGS);

         return NULL;

     }

     newEncodedExtension = SECITEM_ArenaDupItem(reqArena, encodedExtension);

     if (!newEncodedExtension) {

         return NULL;

     }

     rv = SEC_QuickDERDecodeItem(reqArena, &info, CERTAuthInfoAccessTemplate, 

 			    newEncodedExtension);

     if (rv != SECSuccess || info == NULL) {

 	return NULL;

     }

     for (i = 0; info[i] != NULL; i++) {

 	info[i]->location = CERT_DecodeGeneralName(reqArena,

 						   &(info[i]->derLocation),

 						   NULL);

     }

     return info;

 }

 SECStatus

 CERT_EncodeInfoAccessExtension(PLArenaPool *arena,

 				   CERTAuthInfoAccess **info,

 				   SECItem *dest)

 {

     SECItem *dummy;

     int i;

     PORT_Assert(info != NULL);

     PORT_Assert(dest != NULL);

     if (info == NULL || dest == NULL) {

 	return SECFailure;

     }

     for (i = 0; info[i] != NULL; i++) {

 	if (CERT_EncodeGeneralName(info[i]->location, &(info[i]->derLocation),

 				   arena) == NULL)

 	    /* Note that this may leave some of the locations filled in. */

 	    return SECFailure;

     }

     dummy = SEC_ASN1EncodeItem(arena, dest, &info,

 			       CERTAuthInfoAccessTemplate);

     if (dummy == NULL) {

 	return SECFailure;

     }

     return SECSuccess;

 }