开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
crmfpop.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：17k
源码类别：

CA认证

开发平台：

WINDOWS

crmfpop.c：源码内容
  1. /* -*- Mode: C; tab-width: 8 -*-*/
  2. /*
  3.  * The contents of this file are subject to the Mozilla Public
  4.  * License Version 1.1 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of
  6.  * the License at http://www.mozilla.org/MPL/
  7.  * 
  8.  * Software distributed under the License is distributed on an "AS
  9.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10.  * implied. See the License for the specific language governing
  11.  * rights and limitations under the License.
  12.  * 
  13.  * The Original Code is the Netscape security libraries.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation.  Portions created by Netscape are 
  17.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  18.  * Rights Reserved.
  19.  * 
  20.  * Contributor(s):
  21.  * 
  22.  * Alternatively, the contents of this file may be used under the
  23.  * terms of the GNU General Public License Version 2 or later (the
  24.  * "GPL"), in which case the provisions of the GPL are applicable 
  25.  * instead of those above.  If you wish to allow use of your 
  26.  * version of this file only under the terms of the GPL and not to
  27.  * allow others to use your version of this file under the MPL,
  28.  * indicate your decision by deleting the provisions above and
  29.  * replace them with the notice and other provisions required by
  30.  * the GPL.  If you do not delete the provisions above, a recipient
  31.  * may use your version of this file under either the MPL or the
  32.  * GPL.
  33.  */
  36. #include "crmf.h"
  37. #include "crmfi.h"
  38. #include "secasn1.h"
  39. #include "keyhi.h"
  40. #include "cryptohi.h"
  42. #define CRMF_DEFAULT_ALLOC_SIZE 1024
  44. SECStatus
  45. crmf_init_encoder_callback_arg (struct crmfEncoderArg *encoderArg, 
  46. SECItem               *derDest) 
  47. {
  48.     derDest->data = PORT_ZNewArray(unsigned char, CRMF_DEFAULT_ALLOC_SIZE);
  49.     if (derDest->data == NULL) {
  50.         return SECFailure;
  51.     }
  52.     derDest->len = 0;
  53.     encoderArg->allocatedLen = CRMF_DEFAULT_ALLOC_SIZE;
  54.     encoderArg->buffer = derDest;
  55.     return SECSuccess;
  57. }
  59. /* Caller should release or unmark the pool, instead of doing it here.
  60. ** But there are NO callers of this function at present...
  61. */
  62. SECStatus 
  63. CRMF_CertReqMsgSetRAVerifiedPOP(CRMFCertReqMsg *inCertReqMsg)
  64. {
  65.     SECItem               *dummy;
  66.     CRMFProofOfPossession *pop;
  67.     PRArenaPool           *poolp;
  68.     void                  *mark;
  70.     PORT_Assert(inCertReqMsg != NULL && inCertReqMsg->pop == NULL);
  71.     poolp = inCertReqMsg->poolp;
  72.     mark = PORT_ArenaMark(poolp);
  73.     if (CRMF_CertReqMsgGetPOPType(inCertReqMsg) != crmfNoPOPChoice) {
  74.         return SECFailure;
  75.     }
  76.     pop = PORT_ArenaZNew(poolp, CRMFProofOfPossession);
  77.     if (pop == NULL) {
  78.         goto loser;
  79.     }
  80.     pop->popUsed = crmfRAVerified;
  81.     pop->popChoice.raVerified.data = NULL;
  82.     pop->popChoice.raVerified.len  = 0;
  83.     inCertReqMsg->pop = pop;
  84.     dummy = SEC_ASN1EncodeItem(poolp, &(inCertReqMsg->derPOP),
  85.        &(pop->popChoice.raVerified),
  86.        CRMFRAVerifiedTemplate);
  87.     return SECSuccess;
  88.  loser:
  89.     PORT_ArenaRelease(poolp, mark);
  90.     return SECFailure;
  91. }
  93. SECOidTag
  94. crmf_map_keytag_to_signtag(SECOidTag inTag)
  95. {
  96.     switch (inTag) {
  97.     case SEC_OID_PKCS1_RSA_ENCRYPTION:
  98.         return SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION;
  99.     case SEC_OID_ANSIX9_DSA_SIGNATURE:
  100.     case SEC_OID_MISSI_KEA_DSS:
  101.     case SEC_OID_MISSI_DSS:
  102.         return SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST;
  103.     default:
  104.         /* Put this in here to kill warnings. */
  105.         break;
  106.     }
  107.     return inTag;
  108. }
  110. SECOidTag
  111. crmf_get_key_sign_tag(SECKEYPublicKey *inPubKey)
  112. {
  113.     CERTSubjectPublicKeyInfo *spki;
  114.     SECOidTag                 tag;
  116.     spki = SECKEY_CreateSubjectPublicKeyInfo(inPubKey);
  117.     if (spki == NULL) {
  118.         return SEC_OID_UNKNOWN;
  119.     }
  120.     tag = SECOID_GetAlgorithmTag(&spki->algorithm);
  121.     SECKEY_DestroySubjectPublicKeyInfo(spki);
  122.     return crmf_map_keytag_to_signtag(tag);
  123. }
  125. SECAlgorithmID*
  126. crmf_create_poposignkey_algid(PRArenaPool      *poolp,
  127.       SECKEYPublicKey  *inPubKey)
  128. {
  129.     SECAlgorithmID *algID;
  130.     SECOidTag       tag;
  131.     SECStatus       rv;
  132.     void           *mark;
  134.     mark = PORT_ArenaMark(poolp);
  135.     algID = PORT_ArenaZNew(poolp, SECAlgorithmID);
  136.     if (algID == NULL) {
  137.         goto loser;
  138.     }
  139.     tag = crmf_get_key_sign_tag(inPubKey);
  140.     if (tag == SEC_OID_UNKNOWN) {
  141.         goto loser;
  142.     }
  143.     rv = SECOID_SetAlgorithmID(poolp, algID, tag, NULL);
  144.     if (rv != SECSuccess) {
  145.         goto loser;
  146.     }
  147.     PORT_ArenaUnmark(poolp, mark);
  148.     return algID;
  149.  loser:
  150.     PORT_ArenaRelease(poolp, mark);
  151.     return NULL;
  152. }
  154. static CRMFPOPOSigningKeyInput*
  155. crmf_create_poposigningkeyinput(PRArenaPool *poolp, CERTCertificate *inCert,
  156. CRMFMACPasswordCallback fn, void *arg)
  157. {
  158.   /* PSM isn't going to do this, so we'll fail here for now.*/
  159.      return NULL;
  160. }
  162. void
  163. crmf_generic_encoder_callback(void *arg, const char* buf, unsigned long len,
  164.       int depth, SEC_ASN1EncodingPart data_kind)
  165. {
  166.     struct crmfEncoderArg *encoderArg = (struct crmfEncoderArg*)arg;
  167.     unsigned char *cursor;
  168.     
  169.    if (encoderArg->buffer->len + len > encoderArg->allocatedLen) {
  170.         int newSize = encoderArg->buffer->len+CRMF_DEFAULT_ALLOC_SIZE;
  171.         void *dummy = PORT_Realloc(encoderArg->buffer->data, newSize);
  172. if (dummy == NULL) {
  173.     /* I really want to return an error code here */
  174.     PORT_Assert(0);
  175.     return;
  176. }
  177. encoderArg->buffer->data = dummy;
  178. encoderArg->allocatedLen = newSize;
  179.     }
  180.     cursor = &(encoderArg->buffer->data[encoderArg->buffer->len]);
  181.     PORT_Memcpy (cursor, buf, len);
  182.     encoderArg->buffer->len += len;    
  183. }
  185. static SECStatus
  186. crmf_encode_certreq(CRMFCertRequest *inCertReq, SECItem *derDest)
  187. {
  188.     struct crmfEncoderArg encoderArg;
  189.     SECStatus             rv;
  190.   
  191.     rv = crmf_init_encoder_callback_arg (&encoderArg, derDest);
  192.     if (rv != SECSuccess) {
  193.         return SECFailure;
  194.     }
  195.     return SEC_ASN1Encode(inCertReq, CRMFCertRequestTemplate, 
  196.   crmf_generic_encoder_callback, &encoderArg);
  197. }
  199. static SECStatus
  200. crmf_sign_certreq(PRArenaPool        *poolp, 
  201.   CRMFPOPOSigningKey *crmfSignKey, 
  202.   CRMFCertRequest    *certReq,
  203.   SECKEYPrivateKey   *inKey,
  204.   SECAlgorithmID     *inAlgId)
  205. {
  206.     SECItem                      derCertReq;
  207.     SECItem                      certReqSig;
  208.     SECStatus                    rv = SECSuccess;
  210.     rv = crmf_encode_certreq(certReq, &derCertReq);
  211.     if (rv != SECSuccess) {
  212.        goto loser;
  213.     }
  214.     rv = SEC_SignData(&certReqSig, derCertReq.data, derCertReq.len,
  215.       inKey,SECOID_GetAlgorithmTag(inAlgId));
  216.     if (rv != SECSuccess) {
  217.         goto loser;
  218.     }
  219.  
  220.     /* Now make it a part of the POPOSigningKey */
  221.     rv = SECITEM_CopyItem(poolp, &(crmfSignKey->signature), &certReqSig);
  222.     /* Convert this length to number of bits */
  223.     crmfSignKey->signature.len <<= 3; 
  224.    
  225.  loser:
  226.     if (derCertReq.data != NULL) {
  227.         PORT_Free(derCertReq.data);
  228.     }
  229.     if (certReqSig.data != NULL) {
  230.         PORT_Free(certReqSig.data);
  231.     }
  232.     return rv;
  233. }
  235. static SECStatus
  236. crmf_create_poposignkey(PRArenaPool             *poolp, 
  237. CRMFCertReqMsg          *inCertReqMsg, 
  238. CRMFPOPOSigningKeyInput *signKeyInput, 
  239. SECKEYPrivateKey        *inPrivKey,
  240. SECAlgorithmID          *inAlgID,
  241. CRMFPOPOSigningKey      *signKey) 
  242. {
  243.     CRMFCertRequest    *certReq;
  244.     void               *mark;
  245.     PRBool              useSignKeyInput;
  246.     SECStatus           rv;
  247.     
  248.     PORT_Assert(inCertReqMsg != NULL && inCertReqMsg->certReq != NULL);
  249.     mark = PORT_ArenaMark(poolp);
  250.     if (signKey == NULL) {
  251.         goto loser;
  252.     }
  253.     certReq = inCertReqMsg->certReq;
  254.     useSignKeyInput = !(CRMF_DoesRequestHaveField(certReq,crmfSubject)  &&
  255. CRMF_DoesRequestHaveField(certReq,crmfPublicKey));
  257.     if (useSignKeyInput) {
  258.         goto loser; 
  259.     } else {
  260.         rv = crmf_sign_certreq(poolp, signKey, certReq,inPrivKey, inAlgID);
  261. if (rv != SECSuccess) {
  262.     goto loser;
  263. }
  264.     }
  265.     PORT_ArenaUnmark(poolp,mark);
  266.     return SECSuccess;
  267.  loser:
  268.     PORT_ArenaRelease(poolp,mark);
  269.     return SECFailure;
  270. }
  272. SECStatus
  273. CRMF_CertReqMsgSetSignaturePOP(CRMFCertReqMsg   *inCertReqMsg,
  274.        SECKEYPrivateKey *inPrivKey,
  275.        SECKEYPublicKey  *inPubKey,
  276.        CERTCertificate  *inCertForInput,
  277.        CRMFMACPasswordCallback  fn,
  278.        void                    *arg)
  279. {
  280.     SECAlgorithmID  *algID;
  281.     PRArenaPool     *poolp;
  282.     SECItem          derDest = {siBuffer, NULL, 0};
  283.     void            *mark;
  284.     SECStatus        rv;
  285.     CRMFPOPOSigningKeyInput *signKeyInput = NULL;
  286.     CRMFCertRequest         *certReq;
  287.     CRMFProofOfPossession   *pop;
  288.     struct crmfEncoderArg    encoderArg;
  290.     PORT_Assert(inCertReqMsg != NULL && inCertReqMsg->certReq != NULL &&
  291. inCertReqMsg->pop == NULL);
  292.     certReq = inCertReqMsg->certReq;
  293.     if (CRMF_CertReqMsgGetPOPType(inCertReqMsg) != crmfNoPOPChoice || 
  294. !CRMF_DoesRequestHaveField(certReq, crmfPublicKey)) {
  295.         return SECFailure;
  296.     } 
  297.     poolp = inCertReqMsg->poolp;
  298.     mark = PORT_ArenaMark(poolp);
  299.     algID = crmf_create_poposignkey_algid(poolp, inPubKey);
  301.     if(!CRMF_DoesRequestHaveField(certReq,crmfSubject)) {
  302.         signKeyInput = crmf_create_poposigningkeyinput(poolp, inCertForInput,
  303.        fn, arg);
  304. if (signKeyInput == NULL) {
  305.     goto loser;
  306. }
  307.     }
  309.     pop = PORT_ArenaZNew(poolp, CRMFProofOfPossession);
  310.     if (pop == NULL) {
  311.         goto loser;
  312.     }
  313.     
  314.     rv = crmf_create_poposignkey(poolp, inCertReqMsg, 
  315.  signKeyInput, inPrivKey, algID,
  316.  &(pop->popChoice.signature));
  317.     if (rv != SECSuccess) {
  318.         goto loser;
  319.     }
  321.     pop->popUsed = crmfSignature;
  322.     pop->popChoice.signature.algorithmIdentifier = algID;
  323.     inCertReqMsg->pop = pop;
  324.   
  325.     rv = crmf_init_encoder_callback_arg (&encoderArg, &derDest);
  326.     if (rv != SECSuccess) {
  327.         goto loser;
  328.     }
  329.     rv = SEC_ASN1Encode(&pop->popChoice.signature, 
  330. CRMFPOPOSigningKeyTemplate,
  331. crmf_generic_encoder_callback, &encoderArg);
  332.     if (rv != SECSuccess) {
  333.         goto loser;
  334.     }
  335.     rv = SECITEM_CopyItem(poolp, &(inCertReqMsg->derPOP), &derDest);
  336.     PORT_Free (derDest.data);
  337.     if (rv != SECSuccess) {
  338.         goto loser;
  339.     }
  340.     PORT_ArenaUnmark(poolp,mark);
  341.     return SECSuccess;
  343.  loser:
  344.     PORT_ArenaRelease(poolp,mark);
  345.     if (derDest.data != NULL) {
  346.         PORT_Free(derDest.data);
  347.     }
  348.     return SECFailure;
  349. }
  351. static const SEC_ASN1Template*
  352. crmf_get_popoprivkey_subtemplate(CRMFPOPOPrivKey *inPrivKey) 
  353. {
  354.     const SEC_ASN1Template *retTemplate = NULL;
  356.     switch (inPrivKey->messageChoice) {
  357.     case crmfThisMessage:
  358.         retTemplate = CRMFThisMessageTemplate;
  359. break;
  360.     case crmfSubsequentMessage:
  361.         retTemplate = CRMFSubsequentMessageTemplate;
  362. break;
  363.     case crmfDHMAC:
  364.         retTemplate = CRMFDHMACTemplate;
  365. break;
  366.     default:
  367.         retTemplate = NULL;
  368.     }
  369.     return retTemplate;
  370. }
  372. static SECStatus
  373. crmf_encode_popoprivkey(PRArenaPool            *poolp, 
  374. CRMFCertReqMsg         *inCertReqMsg,
  375. CRMFPOPOPrivKey        *popoPrivKey,
  376. const SEC_ASN1Template *privKeyTemplate)
  377. {
  378.     struct crmfEncoderArg   encoderArg;
  379.     SECItem                 derDest; 
  380.     SECStatus               rv;
  381.     void                   *mark;
  382.     const SEC_ASN1Template *subDerTemplate;
  384.     mark = PORT_ArenaMark(poolp);
  385.     rv = crmf_init_encoder_callback_arg(&encoderArg, &derDest);
  386.     if (rv != SECSuccess) {
  387.         goto loser;
  388.     }
  389.     subDerTemplate = crmf_get_popoprivkey_subtemplate(popoPrivKey);
  390.     /* We've got a union, so a pointer to one item is a pointer to 
  391.      * all the items in the union.
  392.      */
  393.     rv = SEC_ASN1Encode(&popoPrivKey->message.thisMessage, 
  394. subDerTemplate,
  395. crmf_generic_encoder_callback, &encoderArg);
  396.     if (rv != SECSuccess) {
  397.         goto loser;
  398.     }
  399.     if (encoderArg.allocatedLen > derDest.len+2) {
  400.         void *dummy = PORT_Realloc(derDest.data, derDest.len+2);
  401. if (dummy == NULL) {
  402.     goto loser;
  403. }
  404. derDest.data = dummy;
  405.     }
  406.     PORT_Memmove(&derDest.data[2], &derDest.data[0], derDest.len);
  407.     /* I couldn't figure out how to get the ASN1 encoder to implicitly
  408.      * tag an implicitly tagged der blob.  So I'm putting in the outter-
  409.      * most tag myself. -javi
  410.      */
  411.     derDest.data[0] = (unsigned char)privKeyTemplate->kind;
  412.     derDest.data[1] = (unsigned char)derDest.len;
  413.     derDest.len += 2;
  414.     rv = SECITEM_CopyItem(poolp, &inCertReqMsg->derPOP, &derDest);
  415.     if (rv != SECSuccess) {
  416.         goto loser;
  417.     }
  418.     PORT_Free(derDest.data);
  419.     PORT_ArenaUnmark(poolp, mark);
  420.     return SECSuccess;
  421.  loser:
  422.     PORT_ArenaRelease(poolp, mark);
  423.     if (derDest.data) {
  424.         PORT_Free(derDest.data);
  425.     }
  426.     return SECFailure;
  427. }
  429. static const SEC_ASN1Template*
  430. crmf_get_template_for_privkey(CRMFPOPChoice inChoice) 
  431. {
  432.     switch (inChoice) {
  433.     case crmfKeyAgreement:
  434.         return CRMFPOPOKeyAgreementTemplate;
  435.     case crmfKeyEncipherment:
  436.         return CRMFPOPOKeyEnciphermentTemplate;
  437.     default:
  438.         break;
  439.     }
  440.     return NULL;
  441. }
  443. static SECStatus
  444. crmf_add_privkey_thismessage(CRMFCertReqMsg *inCertReqMsg, SECItem *encPrivKey,
  445.      CRMFPOPChoice inChoice)
  446. {
  447.     PRArenaPool           *poolp;
  448.     void                  *mark;
  449.     CRMFPOPOPrivKey       *popoPrivKey;
  450.     CRMFProofOfPossession *pop;
  451.     SECStatus              rv;
  453.     PORT_Assert(inCertReqMsg != NULL && encPrivKey != NULL);
  454.     poolp = inCertReqMsg->poolp;
  455.     mark = PORT_ArenaMark(poolp);
  456.     pop = PORT_ArenaZNew(poolp, CRMFProofOfPossession);
  457.     if (pop == NULL) {
  458.         goto loser;
  459.     }
  460.     pop->popUsed = inChoice;
  461.     /* popChoice is a union, so getting a pointer to one
  462.      * field gives me a pointer to the other fields as
  463.      * well.  This in essence points to both 
  464.      * pop->popChoice.keyEncipherment and
  465.      * pop->popChoice.keyAgreement
  466.      */
  467.     popoPrivKey = &pop->popChoice.keyEncipherment;
  469.     rv = SECITEM_CopyItem(poolp, &(popoPrivKey->message.thisMessage),
  470.   encPrivKey);
  471.     if (rv != SECSuccess) {
  472.         goto loser;
  473.     }
  474.     popoPrivKey->message.thisMessage.len <<= 3;
  475.     popoPrivKey->messageChoice = crmfThisMessage;
  476.     inCertReqMsg->pop = pop;
  477.     rv = crmf_encode_popoprivkey(poolp, inCertReqMsg, popoPrivKey,
  478.  crmf_get_template_for_privkey(inChoice));
  479.     if (rv != SECSuccess) {
  480.         goto loser;
  481.     }
  482.     PORT_ArenaUnmark(poolp, mark);
  483.     return SECSuccess;
  484.     
  485.  loser:
  486.     PORT_ArenaRelease(poolp, mark);
  487.     return SECFailure;
  488. }
  490. static SECStatus
  491. crmf_add_privkey_subseqmessage(CRMFCertReqMsg        *inCertReqMsg,
  492.        CRMFSubseqMessOptions  subsequentMessage,
  493.        CRMFPOPChoice          inChoice)
  494. {
  495.     void                  *mark;
  496.     PRArenaPool           *poolp;
  497.     CRMFProofOfPossession *pop;
  498.     CRMFPOPOPrivKey       *popoPrivKey;
  499.     SECStatus              rv;
  500.     const SEC_ASN1Template *privKeyTemplate;
  502.     if (subsequentMessage == crmfNoSubseqMess) {
  503.         return SECFailure;
  504.     }
  505.     poolp = inCertReqMsg->poolp;
  506.     mark = PORT_ArenaMark(poolp);
  507.     pop = PORT_ArenaZNew(poolp, CRMFProofOfPossession);
  508.     if (pop == NULL) {
  509.         goto loser;
  510.     }
  512.     pop->popUsed = inChoice;
  513.     /* 
  514.      * We have a union, so a pointer to one member of the union
  515.      * is also a member to another member of that same union.
  516.      */
  517.     popoPrivKey = &pop->popChoice.keyEncipherment;
  519.     switch (subsequentMessage) {
  520.     case crmfEncrCert:
  521.         rv = crmf_encode_integer(poolp, 
  522.  &(popoPrivKey->message.subsequentMessage),
  523.  0);
  524. break;
  525.     case crmfChallengeResp:
  526.         rv = crmf_encode_integer(poolp,
  527.  &(popoPrivKey->message.subsequentMessage),
  528.  1);
  529. break;
  530.     default:
  531.         goto loser;
  532.     }
  533.     if (rv != SECSuccess) {
  534.         goto loser;
  535.     }
  536.     popoPrivKey->messageChoice = crmfSubsequentMessage;
  537.     privKeyTemplate = crmf_get_template_for_privkey(inChoice);
  538.     inCertReqMsg->pop = pop;
  539.     rv = crmf_encode_popoprivkey(poolp, inCertReqMsg, popoPrivKey,
  540.  privKeyTemplate);
  542.     if (rv != SECSuccess) {
  543.         goto loser;
  544.     }
  545.     PORT_ArenaUnmark(poolp, mark);
  546.     return SECSuccess;
  547.  loser:
  548.     PORT_ArenaRelease(poolp, mark);
  549.     return SECFailure;
  550. }
  552. SECStatus 
  553. CRMF_CertReqMsgSetKeyEnciphermentPOP(CRMFCertReqMsg        *inCertReqMsg,
  554.      CRMFPOPOPrivKeyChoice  inKeyChoice,
  555.      CRMFSubseqMessOptions  subseqMess,
  556.      SECItem               *encPrivKey)
  557. {
  558.     SECStatus rv;
  560.     PORT_Assert(inCertReqMsg != NULL && inCertReqMsg->pop == NULL);
  561.     if (CRMF_CertReqMsgGetPOPType(inCertReqMsg) != crmfNoPOPChoice) {
  562.         return SECFailure;
  563.     }
  564.     switch (inKeyChoice) {    
  565.     case crmfThisMessage:
  566.         rv = crmf_add_privkey_thismessage(inCertReqMsg, encPrivKey,
  567.   crmfKeyEncipherment);
  568. break;
  569.     case crmfSubsequentMessage:
  570.         rv = crmf_add_privkey_subseqmessage(inCertReqMsg, subseqMess, 
  571.     crmfKeyEncipherment);
  572.         break;
  573.     case crmfDHMAC:
  574.     default:
  575.         rv = SECFailure;
  576.     }
  577.     return rv;
  578. }
  580. SECStatus 
  581. CRMF_CertReqMsgSetKeyAgreementPOP (CRMFCertReqMsg        *inCertReqMsg,
  582.    CRMFPOPOPrivKeyChoice  inKeyChoice,
  583.    CRMFSubseqMessOptions  subseqMess,
  584.    SECItem               *encPrivKey)
  585. {
  586.     SECStatus rv;
  588.     PORT_Assert(inCertReqMsg != NULL && inCertReqMsg->pop == NULL);
  589.     switch (inKeyChoice) {    
  590.     case crmfThisMessage:
  591.         rv = crmf_add_privkey_thismessage(inCertReqMsg, encPrivKey,
  592.   crmfKeyAgreement);
  593. break;
  594.     case crmfSubsequentMessage:
  595.         rv = crmf_add_privkey_subseqmessage(inCertReqMsg, subseqMess, 
  596.     crmfKeyAgreement);
  597.     case crmfDHMAC:
  598.         /* This case should be added in the future. */
  599.     default:
  600.         rv = SECFailure;
  601.     }
  602.     return rv;
  603. }