The Tor Browser: security/nss/lib/crmf/cmmfasn1.c@b8a032363ba2

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

     1 /* -*- Mode: C; tab-width: 8 -*-*/

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

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

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

     6 #include "cmmf.h"

     7 #include "cmmfi.h"

     8 #include "secasn1.h"

     9 #include "secitem.h"

    11 SEC_ASN1_MKSUB(SEC_SignedCertificateTemplate)

    13 static const SEC_ASN1Template CMMFSequenceOfCertifiedKeyPairsTemplate[] = {

    14     { SEC_ASN1_SEQUENCE_OF, 0, CMMFCertifiedKeyPairTemplate}

    15 };

    17 static const SEC_ASN1Template CMMFKeyRecRepContentTemplate[] = {

    18     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(CMMFKeyRecRepContent)},

    19     { SEC_ASN1_INLINE, offsetof(CMMFKeyRecRepContent, status),

    20       CMMFPKIStatusInfoTemplate},

    21     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_POINTER |

    22 		SEC_ASN1_XTRN | 0,

    23       offsetof(CMMFKeyRecRepContent, newSigCert),

    24       SEC_ASN1_SUB(SEC_SignedCertificateTemplate)},

    25     { SEC_ASN1_CONSTRUCTED | SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC | 1,

    26       offsetof(CMMFKeyRecRepContent, caCerts),

    27       CMMFSequenceOfCertsTemplate},

    28     { SEC_ASN1_CONSTRUCTED | SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC | 2,

    29       offsetof(CMMFKeyRecRepContent, keyPairHist),

    30       CMMFSequenceOfCertifiedKeyPairsTemplate},

    31     { 0 }

    32 };

    34 SECStatus

    35 CMMF_EncodeCertRepContent (CMMFCertRepContent        *inCertRepContent,

    36 			   CRMFEncoderOutputCallback  inCallback,

    37 			   void                      *inArg)

    38 {

    39     return cmmf_user_encode(inCertRepContent, inCallback, inArg,

    40 			    CMMFCertRepContentTemplate);

    41 }

    43 SECStatus

    44 CMMF_EncodePOPODecKeyChallContent(CMMFPOPODecKeyChallContent *inDecKeyChall,

    45 				  CRMFEncoderOutputCallback inCallback,

    46 				  void                     *inArg)

    47 {

    48     return cmmf_user_encode(inDecKeyChall, inCallback, inArg,

    49 			    CMMFPOPODecKeyChallContentTemplate);

    50 }

    52 CMMFPOPODecKeyRespContent*

    53 CMMF_CreatePOPODecKeyRespContentFromDER(const char *buf, long len)

    54 {

    55     PLArenaPool               *poolp;

    56     CMMFPOPODecKeyRespContent *decKeyResp;

    57     SECStatus                  rv;

    59     poolp = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);

    60     if (poolp == NULL) {

    61         return NULL;

    62     }

    63     decKeyResp = PORT_ArenaZNew(poolp, CMMFPOPODecKeyRespContent);

    64     if (decKeyResp == NULL) {

    65         goto loser;

    66     }

    67     decKeyResp->poolp = poolp;

    68     rv = SEC_ASN1Decode(poolp, decKeyResp, CMMFPOPODecKeyRespContentTemplate,

    69 			buf, len);

    70     if (rv != SECSuccess) {

    71         goto loser;

    72     }

    73     return decKeyResp;

    75  loser:

    76     if (poolp != NULL) {

    77         PORT_FreeArena(poolp, PR_FALSE);

    78     }

    79     return NULL;

    80 }

    82 SECStatus

    83 CMMF_EncodeKeyRecRepContent(CMMFKeyRecRepContent      *inKeyRecRep,

    84 			    CRMFEncoderOutputCallback  inCallback,

    85 			    void                      *inArg)

    86 {

    87     return cmmf_user_encode(inKeyRecRep, inCallback, inArg,

    88 			    CMMFKeyRecRepContentTemplate);

    89 }

    91 CMMFKeyRecRepContent*

    92 CMMF_CreateKeyRecRepContentFromDER(CERTCertDBHandle *db, const char *buf,

    93 				   long len)

    94 {

    95     PLArenaPool          *poolp;

    96     CMMFKeyRecRepContent *keyRecContent;

    97     SECStatus             rv;

    99     poolp = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);

   100     if (poolp == NULL) {

   101         return NULL;

   102     }

   103     keyRecContent = PORT_ArenaZNew(poolp, CMMFKeyRecRepContent);

   104     if (keyRecContent == NULL) {

   105         goto loser;

   106     }

   107     keyRecContent->poolp = poolp;

   108     rv = SEC_ASN1Decode(poolp, keyRecContent, CMMFKeyRecRepContentTemplate,

   109 			buf, len);

   110     if (rv != SECSuccess) {

   111         goto loser;

   112     }

   113     if (keyRecContent->keyPairHist != NULL) {

   114         while(keyRecContent->keyPairHist[keyRecContent->numKeyPairs] != NULL) {

   115 	    rv = cmmf_decode_process_certified_key_pair(poolp, db,

   116 		       keyRecContent->keyPairHist[keyRecContent->numKeyPairs]);

   117 	    if (rv != SECSuccess) {

   118 	        goto loser;

   119 	    }

   120 	    keyRecContent->numKeyPairs++;

   121 	}

   122 	keyRecContent->allocKeyPairs = keyRecContent->numKeyPairs;

   123     }

   124     keyRecContent->isDecoded = PR_TRUE;

   125     return keyRecContent;

   126  loser:

   127     if (poolp != NULL) {

   128         PORT_FreeArena(poolp, PR_FALSE);

   129     }

   130     return NULL;

   131 }

The Tor Browser / file revision