The Tor Browser: security/nss/lib/certdb/xconst.c@b8a032363ba2 (annotated)

security/nss/lib/certdb/xconst.c@b8a032363ba2 (annotated)

security/nss/lib/certdb/xconst.c

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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,
 , 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,
 , 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;
 }

The Tor Browser / annotate

security/nss/lib/certdb/xconst.c@b8a032363ba2 (annotated)

security/nss/lib/certdb/xconst.c