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

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

CA认证

开发平台：

WINDOWS

crmfres.c：源码内容
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  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.  */
  34. /* Cartman Server specific includes */
  35. #include "serv.h"
  36. #include "crmfres.h"
  37. #include "kgenctxt.h"
  38. #include "p12res.h"
  39. #include "newproto.h"
  40. #include "messages.h"
  41. #include "certres.h"
  42. #include "oldfunc.h"
  44. /* NSS include files */
  45. #include "base64.h"
  46. #include "crmfi.h"
  47. #include "cmmfi.h"
  48. #include "cert.h"
  49. #include "secmod.h"
  50. #include "secasn1.h"
  52. /*
  53.  * These defines are used for setting the keyUsage extensions in 
  54.  * the requests.
  55.  */
  57. #define DIGITAL_SIGNATURE KU_DIGITAL_SIGNATURE
  58. #define NON_REPUDIATION   KU_NON_REPUDIATION
  59. #define KEY_ENCIPHERMENT  KU_KEY_ENCIPHERMENT
  60. #define KEY_AGREEMENT     KU_KEY_AGREEMENT
  62. /* I can use this for both SSMKeyPair and SSMCRMFRequest because they
  63.  * both inherit directly from SSMResource
  64.  *
  65.  * A simple macro for an object that inherits from SSMResource that will
  66.  * convert the object pointer into a SSMResource pointer.
  67.  */
  68. #define SSMRESOURCE(object) (&(object)->super)
  70. /*
  71.  * This structure is used for callbacks passed to the ASN1 encoder.
  72.  */
  73. typedef struct CRMFASN1ArgStr {
  74.     SECItem buffer;
  75.     long    allocatedLen;
  76. } CRMFASN1Arg;
  78. /*
  79.  * Default allocation size for a DER chunk that will be passed to the 
  80.  * ASN1 parser.
  81.  */
  82. #define DEFAULT_ASN1_CHUNK_SIZE 1024
  84. typedef struct CMMFResponseArgStr {
  85.     SECItem *msg;
  86.     SSMControlConnection *connection;
  87. } CMMFResponseArg;
  89. /* Forward decls */
  90. void
  91. SSMCRMFRequest_PrepareBitStringForEncoding (SECItem *bitsmap, SECItem *value);
  92. SSMStatus
  93. SSMCRMFRequest_SetKeyUsageExtension(SSMCRMFRequest *crmfReq,
  94.                                     unsigned char   keyUsage);
  95. SSMStatus
  96. SSMCRMFRequest_SetRSADualUse(SSMCRMFRequest *crmfReq);
  97. SSMStatus
  98. SSMCRMFRequest_SetRSAKeyEx(SSMCRMFRequest *crmfReq);
  99. SSMStatus
  100. SSMCRMFRequest_SetRSASign(SSMCRMFRequest *crmfReq);
  101. SSMStatus
  102. SSMCRMFRequest_SetRSANonRepudiation(SSMCRMFRequest *crmfReq);
  103. SSMStatus
  104. SSMCRMFRequest_SetRSASignNonRepudiation(SSMCRMFRequest *crmfReq);
  105. SSMStatus
  106. SSMCRMFRequest_SetDH(SSMCRMFRequest *crmfReq);
  107. SSMStatus
  108. SSMCRMFRequest_SetDSASign(SSMCRMFRequest *crmfReq);
  109. SSMStatus
  110. SSMCRMFRequest_SetDSANonRepudiation(SSMCRMFRequest *crmfReq);
  111. SSMStatus
  112. SSMCRMFRequest_SetDSASignNonRepudiation(SSMCRMFRequest *crmfReq);
  113. SSMStatus
  114. SSMCRMFRequest_SetKeyGenType(SSMCRMFRequest *crmfReq, SSMKeyGenType keyGenType);
  115. SSMStatus
  116. SSMCRMFRequest_SetDN(SSMCRMFRequest *crmfReq, 
  117.                      char           *data);
  118. SSMStatus
  119. SSMCRMFRequest_SetRegToken(SSMCRMFRequest *crmfReq,
  120.    char           *value);
  121. SSMStatus
  122. SSMCRMFRequest_SetAuthenticator(SSMCRMFRequest *crmfReq,
  123.  char           *value);
  124. PRBool
  125. SSMCRMFRequest_HasEscrowAuthority(SSMCRMFRequest *currReq);
  126. SSMStatus
  127. SSMCRMFRequest_SetKeyEnciphermentPOP(CRMFCertReqMsg *certReqMsg,
  128.                                      SSMCRMFRequest *curReq);
  129. SSMStatus
  130. SSMCRMFRequest_SetProofOfPossession(CRMFCertReqMsg *certReqMsg, 
  131.     SSMCRMFRequest *curReq);
  132. SECKEYPrivateKey*
  133. SSM_FindPrivKeyFromKeyID(SECItem *keyID, SECMODModule *currMod,
  134.                          SSMControlConnection *ctrl);
  135. SECKEYPrivateKey*
  136. SSM_FindPrivKeyFromPubValue(SECItem *publicValue, SECMODModuleList *modList,
  137.                             SSMControlConnection *ctrl);
  138. SSMStatus
  139. SSM_InitCRMFASN1Arg(CRMFASN1Arg *arg);
  140. void
  141. SSM_GenericASN1Callback(void *arg, const char *buf, unsigned long len);
  143. SSMStatus
  144. SSM_CreateNewCRMFRequest(SECItem *msg, SSMControlConnection *connection,
  145.                          SSMResourceID *destID)
  146. {
  147.   SSMStatus     prv;
  148.   SSMResource *keyPairRes=NULL, *crmfReqRes=NULL;
  149.   SSMCRMFRequestArg arg;
  150.   SingleNumMessage request;
  152.   if (CMT_DecodeMessage(SingleNumMessageTemplate, &request, (CMTItem*)msg) != CMTSuccess) {
  153.       goto loser;
  154.   }
  156.   prv = SSMControlConnection_GetResource(connection, (SSMResourceID)request.value, 
  157.                                          &keyPairRes);
  158.   if (prv != PR_SUCCESS || keyPairRes == NULL) {
  159.     goto loser;
  160.   }
  161.   if (!SSM_IsAKindOf(keyPairRes, SSM_RESTYPE_KEY_PAIR)) {
  162.     goto loser;
  163.   }
  164.   arg.keyPair    = (SSMKeyPair*)keyPairRes;
  165.   arg.connection = connection;
  166.   prv = SSM_CreateResource(SSM_RESTYPE_CRMF_REQUEST, (void*)&arg, connection,
  167.                            destID, &crmfReqRes);
  169.   if (prv != PR_SUCCESS || crmfReqRes == NULL) {
  170.     goto loser;
  171.   }
  172.   SSM_FreeResource(keyPairRes);
  173.   crmfReqRes->m_clientCount++;
  174.   return PR_SUCCESS;
  175.  loser:
  176.   if (keyPairRes != NULL) {
  177.     SSM_FreeResource(keyPairRes);
  178.   }
  179.   if (crmfReqRes != NULL) {
  180.     SSM_FreeResource(crmfReqRes);
  181.   }
  182.   return PR_FAILURE;
  183. }
  186. SSMStatus
  187. SSMCRMFRequest_Create(void *arg, SSMControlConnection * connection, 
  188.                       SSMResource **res)
  189. {
  190.   SSMCRMFRequest    *crmfReq;
  191.   SSMStatus           rv;
  192.   SSMCRMFRequestArg *createArg = (SSMCRMFRequestArg*)arg;
  194.   crmfReq = SSM_ZNEW(SSMCRMFRequest);
  195.   if (crmfReq == NULL) {
  196.     goto loser;
  197.   }
  198.   rv = SSMCRMFRequest_Init(crmfReq, connection, SSM_RESTYPE_CRMF_REQUEST, 
  199.                            createArg->keyPair, createArg->connection);
  200.   
  201.   if (rv != PR_SUCCESS) {
  202.     goto loser;
  203.   }
  204.   *res = SSMRESOURCE(crmfReq);
  205.   return PR_SUCCESS;
  206.   
  207.  loser:
  208.   if (crmfReq != NULL) {
  209.     SSM_FreeResource(SSMRESOURCE(crmfReq));
  210.   }
  211.   *res = NULL;
  212.   return PR_FAILURE;
  213. }
  215. SSMStatus
  216. SSMCRMFRequest_Init(SSMCRMFRequest       *inCRMFReq,
  217.     SSMControlConnection * conn,
  218.                     SSMResourceType       type,
  219.                     SSMKeyPair           *inKeyPair,
  220.                     SSMControlConnection *inConnection)
  221. {
  222.   CRMFCertRequest          *certReq = NULL;
  223.   CERTSubjectPublicKeyInfo *spki    = NULL;
  224.   SSMStatus                  rv;
  225.   SECStatus                 srv;
  226.   long                      version = SEC_CERTIFICATE_VERSION_3 ; 
  227.                                          /* Version passed in is the value 
  228.                                           * to be encoded for the version
  229.                                           * of the certificate.
  230.                                           */
  232.   if (inKeyPair == NULL || inConnection == NULL) {
  233.       goto loser;
  234.   }
  235.   rv = SSMResource_Init(conn, SSMRESOURCE(inCRMFReq), type);
  236.   if (rv != PR_SUCCESS) {
  237.     goto loser;
  238.   }
  239.   /* This reference will be inherited by the SSMCRMFRequest
  240.    * structure being initialized.
  241.    */
  242.   SSM_GetResourceReference(SSMRESOURCE(inKeyPair));
  243.   if (inKeyPair->m_PubKey  == NULL || 
  244.       inKeyPair->m_PrivKey == NULL) {
  245.     goto loser;
  246.   }
  247.   inCRMFReq->m_KeyPair    = inKeyPair;
  248.   inCRMFReq->m_KeyGenType = invalidKeyGen;
  249.   inCRMFReq->m_Connection = inConnection;
  250.   /* How do I remember that request number? */
  251.   certReq = CRMF_CreateCertRequest(rand());
  252.   if (certReq == NULL) {
  253.     goto loser;
  254.   }
  255.   srv = CRMF_CertRequestSetTemplateField(certReq, crmfVersion, &version);
  256.   if (srv != SECSuccess) {
  257.     goto loser;
  258.   }
  259.   spki = SECKEY_CreateSubjectPublicKeyInfo(inKeyPair->m_PubKey);
  260.   if(spki == NULL) {
  261.     goto loser;
  262.   }
  263.   srv = CRMF_CertRequestSetTemplateField(certReq, crmfPublicKey, spki);
  264.   SECKEY_DestroySubjectPublicKeyInfo(spki);
  265.   if (srv != SECSuccess) {
  266.     goto loser;
  267.   }
  268.   inCRMFReq->m_CRMFRequest = certReq;
  269.   if (inKeyPair->m_KeyGenContext->m_eaCert != NULL &&
  270.       inKeyPair->m_KeyGenType == rsaEnc) {
  271.       rv = SSMCRMFRequest_SetEscrowAuthority(inCRMFReq,
  272.                                         inKeyPair->m_KeyGenContext->m_eaCert);
  273.       if (rv != PR_SUCCESS) {
  274.         goto loser;
  275.       }
  276.   }
  277.   return PR_SUCCESS;
  278.  loser:
  279.   /* We only obtain a reference to the key pair in this function, so 
  280.    * that's the only reference we need to free in here.
  281.    */
  282.   if (inKeyPair != NULL) {
  283.     SSM_FreeResource(SSMRESOURCE(inKeyPair));
  284.   }
  285.   if (certReq != NULL) {
  286.     CRMF_DestroyCertRequest(certReq);
  287.   }
  288.   return PR_FAILURE;
  289. }
  291. SSMStatus
  292. SSMCRMFRequest_Destroy(SSMResource *inRequest, PRBool doFree)
  293. {
  294.   SSMCRMFRequest *crmfReq = (SSMCRMFRequest*)inRequest;
  296.   if (crmfReq->m_KeyPair != NULL) {
  297.     SSM_FreeResource(SSMRESOURCE(crmfReq->m_KeyPair));
  298.     crmfReq->m_KeyPair = NULL;
  299.   }
  300.   if (crmfReq->m_CRMFRequest != NULL) {
  301.     CRMF_DestroyCertRequest(crmfReq->m_CRMFRequest);
  302.     crmfReq->m_CRMFRequest = NULL;
  303.   }
  304.   SSMResource_Destroy(SSMRESOURCE(crmfReq), PR_FALSE);
  305.   if (doFree) {
  306.     PR_Free(crmfReq);
  307.   }
  308.   return PR_SUCCESS;
  309. }
  311. void
  312. SSMCRMFRequest_PrepareBitStringForEncoding (SECItem *bitsmap, SECItem *value)
  313. {
  314.   unsigned char onebyte;
  315.   unsigned int i, len = 0;
  317.   /* to prevent warning on some platform at compile time */
  318.   onebyte = '';
  319.   /* Get the position of the right-most turn-on bit */
  320.   for (i = 0; i < (value->len ) * 8; ++i) {
  321.       if (i % 8 == 0)
  322.           onebyte = value->data[i/8];
  323.       if (onebyte & 0x80)
  324.           len = i;
  325.       onebyte <<= 1;
  327.   }
  328.   bitsmap->data = value->data;
  329.   /* Add one here since we work with base 1 */
  330.   bitsmap->len = len + 1;
  331. }
  333. /*
  334.  * Below is the set of functions that set the keyUsage extension in the
  335.  * request.  Each different type of key generation has a different
  336.  * value that gets set for keyUsage.  So each one defines the 
  337.  * value and just calls SSMCRMFRequest_SetKeyUsageExtension.
  338.  */
  340. SSMStatus
  341. SSMCRMFRequest_SetKeyUsageExtension(SSMCRMFRequest *crmfReq,
  342.                                     unsigned char   keyUsage)
  343. {
  344.   SECItem                 *encodedExt= NULL;
  345.   SECItem                  keyUsageValue = { (SECItemType) 0, NULL, 0 };
  346.   SECItem                  bitsmap = { (SECItemType) 0, NULL, 0 };
  347.   SECStatus                srv;
  348.   CRMFCertExtension       *ext = NULL;
  349.   CRMFCertExtCreationInfo  extAddParams;
  350.   SEC_ASN1Template         bitStrTemplate = {SEC_ASN1_BIT_STRING, 0, NULL,
  351.                                              sizeof(SECItem)};
  353.   keyUsageValue.data = &keyUsage;
  354.   keyUsageValue.len  = 1;
  355.   SSMCRMFRequest_PrepareBitStringForEncoding(&bitsmap, &keyUsageValue);
  357.   encodedExt = SEC_ASN1EncodeItem(NULL, NULL, &bitsmap,&bitStrTemplate);
  358.   if (encodedExt == NULL) {
  359.       goto loser;
  360.   }
  361.   ext = CRMF_CreateCertExtension(SEC_OID_X509_KEY_USAGE, PR_TRUE, encodedExt);
  362.   if (ext == NULL) {
  363.       goto loser;
  364.   }
  365.   extAddParams.numExtensions = 1;
  366.   extAddParams.extensions = &ext;
  367.   srv = CRMF_CertRequestSetTemplateField(crmfReq->m_CRMFRequest, crmfExtension,
  368.                                          &extAddParams);
  369.   CRMF_DestroyCertExtension(ext);
  370.   if (srv != SECSuccess) {
  371.       goto loser;
  372.   }
  373.   return PR_SUCCESS;
  374.  loser:
  375.   if (encodedExt != NULL) {
  376.       SECITEM_FreeItem(encodedExt, PR_TRUE);
  377.   }
  378.   return PR_FAILURE;
  379. }
  381. SSMStatus
  382. SSMCRMFRequest_SetRSADualUse(SSMCRMFRequest *crmfReq)
  383. {
  384.   unsigned char keyUsage =   DIGITAL_SIGNATURE
  385.                            | NON_REPUDIATION
  386.                            | KEY_ENCIPHERMENT;
  388.   crmfReq->m_KeyGenType = rsaDualUse;
  389.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  390. }
  392. SSMStatus
  393. SSMCRMFRequest_SetRSAKeyEx(SSMCRMFRequest *crmfReq)
  394. {
  395.   unsigned char keyUsage = KEY_ENCIPHERMENT;
  396.      
  397.   crmfReq->m_KeyGenType = rsaEnc;
  398.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  399. }
  401. SSMStatus
  402. SSMCRMFRequest_SetRSASign(SSMCRMFRequest *crmfReq)
  403. {
  404.   unsigned char keyUsage = DIGITAL_SIGNATURE;
  405.                          
  407.   crmfReq->m_KeyGenType = rsaSign;
  408.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  409. }
  411. SSMStatus
  412. SSMCRMFRequest_SetRSANonRepudiation(SSMCRMFRequest *crmfReq)
  413. {
  414.   unsigned char keyUsage = NON_REPUDIATION;
  416.   crmfReq->m_KeyGenType = rsaNonrepudiation;
  417.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  418. }
  420. SSMStatus
  421. SSMCRMFRequest_SetRSASignNonRepudiation(SSMCRMFRequest *crmfReq)
  422. {
  423.   unsigned char keyUsage = DIGITAL_SIGNATURE |
  424.                            NON_REPUDIATION;
  426.   crmfReq->m_KeyGenType = rsaSignNonrepudiation;
  427.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  428. }
  430. SSMStatus
  431. SSMCRMFRequest_SetDH(SSMCRMFRequest *crmfReq)
  432. {
  433.   unsigned char keyUsage = KEY_AGREEMENT;
  434.   
  435.   crmfReq->m_KeyGenType = dhEx;
  436.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  437. }
  439. SSMStatus
  440. SSMCRMFRequest_SetDSASign(SSMCRMFRequest *crmfReq)
  441. {
  442.   unsigned char keyUsage = DIGITAL_SIGNATURE;
  444.   crmfReq->m_KeyGenType = dsaSign;
  445.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  446. }
  448. SSMStatus
  449. SSMCRMFRequest_SetDSANonRepudiation(SSMCRMFRequest *crmfReq)
  450. {
  451.   unsigned char keyUsage = NON_REPUDIATION;
  453.   crmfReq->m_KeyGenType = dsaNonrepudiation;
  454.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  455. }
  457. SSMStatus
  458. SSMCRMFRequest_SetDSASignNonRepudiation(SSMCRMFRequest *crmfReq)
  459. {
  460.   unsigned char keyUsage = DIGITAL_SIGNATURE |
  461.                            NON_REPUDIATION;
  463.   crmfReq->m_KeyGenType = dsaSignNonrepudiation;
  464.   return SSMCRMFRequest_SetKeyUsageExtension(crmfReq, keyUsage);
  465. }
  467. SSMStatus
  468. SSMCRMFRequest_SetKeyGenType(SSMCRMFRequest *crmfReq, SSMKeyGenType keyGenType)
  469. {
  470.   SSMStatus rv;
  472.   if (crmfReq->m_KeyGenType != invalidKeyGen) {
  473.     return PR_FAILURE;
  474.   }
  475.   switch (keyGenType) {
  476.   case rsaDualUse:
  477.     rv = SSMCRMFRequest_SetRSADualUse(crmfReq);
  478.     break;
  479.   case rsaEnc:
  480.     rv = SSMCRMFRequest_SetRSAKeyEx(crmfReq);
  481.     break;
  482.   case rsaSign:
  483.     rv = SSMCRMFRequest_SetRSASign(crmfReq);
  484.     break;
  485.   case rsaNonrepudiation:
  486.     rv = SSMCRMFRequest_SetRSANonRepudiation(crmfReq);
  487.     break;
  488.   case rsaSignNonrepudiation:
  489.     rv = SSMCRMFRequest_SetRSASignNonRepudiation(crmfReq);
  490.     break;
  491.   case dhEx:
  492.     rv = SSMCRMFRequest_SetDH(crmfReq);
  493.     break;
  494.   case dsaSign:
  495.     rv = SSMCRMFRequest_SetDSASign(crmfReq);
  496.     break;
  497.   case dsaNonrepudiation:
  498.     rv = SSMCRMFRequest_SetDSANonRepudiation(crmfReq);
  499.     break;
  500.   case dsaSignNonrepudiation:
  501.     rv = SSMCRMFRequest_SetDSASignNonRepudiation(crmfReq);
  502.     break;
  503.   default:
  504.     SSM_DEBUG("Unknown KeyGenType %dn", keyGenType);
  505.     rv = PR_FAILURE;
  506.     break;
  507.   }
  508.   return rv;
  509. }
  511. /*
  512.  * This function takes an ASCII string in RFC1485 format and converts it
  513.  * to a CERTName, then sets that names as the subjectName for the request
  514.  * passed in.
  515.  */
  516. SSMStatus
  517. SSMCRMFRequest_SetDN(SSMCRMFRequest *crmfReq, 
  518.                      char           *data)
  519. {
  520.   SECStatus    srv;
  521.   CERTName    *subjectName;
  523.   if (data == NULL || CRMF_CertRequestIsFieldPresent(crmfReq->m_CRMFRequest,
  524.                                                      crmfSubject)) {
  525.     return PR_FAILURE;
  526.   }
  527.   subjectName = CERT_AsciiToName(data);
  528.   if (subjectName == NULL) {
  529.     return PR_FAILURE;
  530.   }
  531.   srv = CRMF_CertRequestSetTemplateField (crmfReq->m_CRMFRequest, crmfSubject, 
  532.                                           (void*)subjectName);
  533.   CERT_DestroyName(subjectName);
  534.   return (srv == SECSuccess) ? PR_SUCCESS : PR_FAILURE;
  535. }
  537. /*
  538.  * This function will set the Registration Token Control in 
  539.  * the certificate request passed in.  We only allow one registration
  540.  * token control per request in Cartman.
  541.  */
  542. SSMStatus
  543. SSMCRMFRequest_SetRegToken(SSMCRMFRequest *crmfReq,
  544.    char           *value)
  545. {
  546.   SECItem   src, *derEncoded;
  547.   SECStatus rv;
  549.   if (CRMF_CertRequestIsControlPresent(crmfReq->m_CRMFRequest, 
  550.                                        crmfRegTokenControl)) {
  551.     return PR_FAILURE;
  552.   }
  553.   src.data = (unsigned char*)value;
  554.   src.len  = strlen(value)+1;
  555.   derEncoded = SEC_ASN1EncodeItem(NULL, NULL, &src, SEC_UTF8StringTemplate);
  556.   if (derEncoded == NULL) {
  557.     return PR_FAILURE;
  558.   }
  559.   rv = CRMF_CertRequestSetRegTokenControl(crmfReq->m_CRMFRequest, derEncoded);
  560.   SECITEM_FreeItem(derEncoded, PR_TRUE);
  561.   if (rv != SECSuccess) {
  562.     return PR_FAILURE;
  563.   }
  564.   return PR_SUCCESS;
  565. }
  567. /*
  568.  * This function sets the authenticator control in the certificate request.
  569.  * The string passed in is an ASCII string.  The CRMF libraries encode that
  570.  * string as a UTF8 string and then include it in the request.  Cartman will
  571.  * only allow one Authenticator control per request.
  572.  */
  573. SSMStatus
  574. SSMCRMFRequest_SetAuthenticator(SSMCRMFRequest *crmfReq,
  575.  char           *value)
  576. {
  577.   SECItem   src, *derEncoded;
  578.   SECStatus rv;
  580.   if (CRMF_CertRequestIsControlPresent(crmfReq->m_CRMFRequest,
  581.                                        crmfAuthenticatorControl)) {
  582.     return PR_FAILURE;
  583.   }
  584.   src.data = (unsigned char*)value;
  585.   src.len  = strlen(value)+1;
  586.   derEncoded = SEC_ASN1EncodeItem(NULL, NULL, &src, SEC_UTF8StringTemplate);
  587.   if (derEncoded == NULL) {
  588.     return PR_FAILURE;
  589.   }
  590.   rv = CRMF_CertRequestSetAuthenticatorControl(crmfReq->m_CRMFRequest, 
  591.                                                derEncoded);
  592.   SECITEM_FreeItem(derEncoded, PR_TRUE);
  593.   if (rv != SECSuccess) {
  594.     return PR_FAILURE;
  595.   }
  596.   return PR_SUCCESS;
  597. }
  599. SSMStatus
  600. SSMCRMFRequest_SetEscrowAuthority(SSMCRMFRequest  *crmfReq,
  601.                                   CERTCertificate *eaCert)
  602. {
  603.   CRMFEncryptedKey      *encrKey   = NULL;
  604.   CRMFPKIArchiveOptions *archOpt   = NULL;
  605.   SECStatus              rv;
  607.   PR_ASSERT(eaCert!= NULL);
  608.   if (eaCert == NULL || 
  609.       CRMF_CertRequestIsControlPresent(crmfReq->m_CRMFRequest, 
  610.                                        crmfPKIArchiveOptionsControl)) {
  611.     return PR_FAILURE;
  612.   }
  614.   /*
  615.    * CRMF_CreatePKIArchiveOptions checks to see if the value passed in,
  616.    * in this case encrKey, is NULL.  So passing in the value without 
  617.    * checking the contents first is OK in this case.  Really.
  618.    */
  619.   encrKey = 
  620.     CRMF_CreateEncryptedKeyWithEncryptedValue(crmfReq->m_KeyPair->m_PrivKey,
  621.                                               eaCert);
  622.   archOpt = CRMF_CreatePKIArchiveOptions(crmfEncryptedPrivateKey, 
  623.                                          (void*)encrKey);
  624.   if (archOpt == NULL) {
  625.     goto loser;
  626.   }
  627.   rv = CRMF_CertRequestSetPKIArchiveOptions(crmfReq->m_CRMFRequest, archOpt);
  628.   if (rv != SECSuccess) {
  629.     goto loser;
  630.   }
  631.   CRMF_DestroyEncryptedKey(encrKey);
  632.   CRMF_DestroyPKIArchiveOptions(archOpt);
  633.   return PR_SUCCESS;
  634.  loser:
  635.   /* Free up all the memory here. */
  636.   if (encrKey != NULL) {
  637.     CRMF_DestroyEncryptedKey(encrKey);
  638.   }
  639.   if (archOpt != NULL) {
  640.     CRMF_DestroyPKIArchiveOptions(archOpt);
  641.   }
  642.   return PR_FAILURE;
  643. }
  645. SSMStatus
  646. SSMCRMFRequest_SetAttr(SSMResource         *res,
  647.                        SSMAttributeID      attrID,
  648.                        SSMAttributeValue   *value)
  649. {
  650.   SSMCRMFRequest *crmfReq = (SSMCRMFRequest*)res;
  651.   SSMStatus        rv;
  653.   SSM_DEBUG("Calling SSMCRMFRequest_SetAttrn");
  654.   switch (attrID) {
  655.   case SSM_FID_CRMFREQ_KEY_TYPE:
  656.     SSM_DEBUG("Setting SSMKeyGenType to %dn", value->u.numeric);
  657.     if (value->type != SSM_NUMERIC_ATTRIBUTE) {
  658.       rv = PR_FAILURE;
  659.       break;
  660.     }
  661.     rv = SSMCRMFRequest_SetKeyGenType(crmfReq, (SSMKeyGenType) value->u.numeric);
  662.     break;
  663.   case SSM_FID_CRMFREQ_DN:
  664.     SSM_DEBUG("Setting the DN to %sn", value->u.string.data);
  665.     if (value->type != SSM_STRING_ATTRIBUTE) {
  666.       rv = PR_FAILURE;
  667.       break;
  668.     }
  669.     rv = SSMCRMFRequest_SetDN(crmfReq, (char *) value->u.string.data);
  670.     break;
  671.   case SSM_FID_CRMFREQ_REGTOKEN:
  672.     SSM_DEBUG("Setting the regToken to %sn", value->u.string.data);
  673.     if (value->type != SSM_STRING_ATTRIBUTE) {
  674.       rv = PR_FAILURE;
  675.       break;
  676.     }
  677.     rv = SSMCRMFRequest_SetRegToken(crmfReq, (char *) value->u.string.data);
  678.     break;
  679.   case SSM_FID_CRMFREQ_AUTHENTICATOR:
  680.     SSM_DEBUG("Setting the authenticator to %sn", value->u.string.data);
  681.     rv = SSMCRMFRequest_SetAuthenticator(crmfReq, (char *) value->u.string.data);
  682.     break;
  683.   default:
  684.     SSM_DEBUG("Got unknown CRMF Set Attribute request %dn", attrID);
  685.     rv = PR_FAILURE;
  686.     break;
  687.   }
  688.   return rv;
  689. }
  691. /*
  692.  * This function checks to see if a CRMF request has the PKIArchiveOptions
  693.  * control already set.
  694.  */
  695. PRBool
  696. SSMCRMFRequest_HasEscrowAuthority(SSMCRMFRequest *currReq)
  697. {
  698.   return CRMF_CertRequestIsControlPresent(currReq->m_CRMFRequest,
  699.                                           crmfPKIArchiveOptionsControl);
  700. }
  702. /*
  703.  * This function will set the Proof Of Possession (POP) for a request
  704.  * associated with a key pair intended to do Key Encipherment.  Currently
  705.  * this means encryption only keys.
  706.  */
  707. SSMStatus
  708. SSMCRMFRequest_SetKeyEnciphermentPOP(CRMFCertReqMsg *certReqMsg,
  709.                                      SSMCRMFRequest *curReq)
  710. {
  711.   SECItem       bitString;
  712.   unsigned char der[2];
  713.   SECStatus     rv;
  715.   if (SSMCRMFRequest_HasEscrowAuthority(curReq)) { 
  716.     /* For proof of possession on escrowed keys, we use the
  717.      * this Message option of POPOPrivKey and include a zero
  718.      * length bit string in the POP field.  This is OK because the encrypted
  719.      * private key already exists as part of the PKIArchiveOptions
  720.      * Control and that for all intents and purposes proves that
  721.      * we do own the private key.
  722.      */
  723.     der[0] = 0x03; /*We've got a bit string          */
  724.     der[1] = 0x00; /*We've got a 0 length bit string */
  725.     bitString.data = der;
  726.     bitString.len  = 2;
  727.     rv = CRMF_CertReqMsgSetKeyEnciphermentPOP(certReqMsg, crmfThisMessage,
  728.                                               crmfNoSubseqMess, &bitString);
  729.   } else {
  730.     /* If the encryption key is not being escrowed, then we set the 
  731.      * Proof Of Possession to be a Challenge Response mechanism.
  732.      */
  733.     rv = CRMF_CertReqMsgSetKeyEnciphermentPOP(certReqMsg, 
  734.                                               crmfSubsequentMessage,
  735.                                               crmfChallengeResp, NULL); 
  736.   }
  737.   return (rv == SECSuccess) ? PR_SUCCESS : PR_FAILURE; 
  738. }
  740. /*
  741.  * This function sets the Proof Of Possession(POP) for a requests.
  742.  * All requests except for those associated with encryption only keys
  743.  * sign the request as their form of POP.  Encryption only keys require
  744.  * extra logic in determining the type of POP to use, that is why encryption
  745.  * only keys have an extra layer for setting the POP instead of calling into
  746.  * the CRMF libraries directly from within this function.
  747.  */
  748. SSMStatus
  749. SSMCRMFRequest_SetProofOfPossession(CRMFCertReqMsg *certReqMsg, 
  750.     SSMCRMFRequest *curReq)
  751. {
  752.   SSMStatus  rv;
  753.   SECStatus srv;
  755.   switch (curReq->m_KeyGenType) {
  756.   case rsaSign:
  757.   case rsaDualUse:
  758.   case rsaNonrepudiation:
  759.   case rsaSignNonrepudiation:
  760.   case dsaSign:
  761.   case dsaNonrepudiation:
  762.   case dsaSignNonrepudiation:
  763.     srv = CRMF_CertReqMsgSetSignaturePOP(certReqMsg, 
  764.                                          curReq->m_KeyPair->m_PrivKey, 
  765.                                          curReq->m_KeyPair->m_PubKey, NULL,
  766.                                          NULL, NULL);
  767.     rv = (srv == SECSuccess) ? PR_SUCCESS : PR_FAILURE;
  768.     break;
  769.   case rsaEnc:
  770.     rv = SSMCRMFRequest_SetKeyEnciphermentPOP(certReqMsg, curReq);
  771.     break;
  772.   case dhEx:
  773.     /* This case may be supported in the future, but for now, we just fall 
  774.      * though to the default case and return an error for diffie-hellman keys.
  775.      */
  776.   default:
  777.     rv = PR_FAILURE;
  778.     break;
  779.   }
  780.   return rv;
  781. }
  783. SSMStatus
  784. SSM_EncodeCRMFRequests(SSMControlConnection * ctrl,SECItem *msg, 
  785.                        char **destDER, SSMPRUint32 *destLen)
  786. {
  787.   PRInt32               i;
  788.   SSMStatus              rv;
  789.   SECStatus             srv;
  790.   CRMFCertReqMsg      **certReqMsgs = NULL;
  791.   SSMCRMFRequest       *curReq;
  792.   SSMResource          *res;
  793.   SECItem              *encodedReq;
  794.   CRMFCertReqMessages   messages;
  795.   EncodeCRMFReqRequest request;
  797.   if (CMT_DecodeMessage(EncodeCRMFReqRequestTemplate, &request, (CMTItem*)msg) != CMTSuccess) {
  798.       goto loser;
  799.   }
  801.   certReqMsgs = SSM_ZNEW_ARRAY(CRMFCertReqMsg*, (request.numRequests+1));
  802.   for (i=0; i<request.numRequests; i++) {
  803.     rv = SSMControlConnection_GetResource(ctrl, (SSMResourceID)request.reqIDs[i],
  804.                                           &res);
  805.     if (rv != PR_SUCCESS) {
  806.       goto loser;
  807.     }
  808.     if (!SSM_IsAKindOf(res, SSM_RESTYPE_CRMF_REQUEST)) {
  809.       rv = PR_FAILURE;
  810.       goto loser;
  811.     }
  812.     curReq = (SSMCRMFRequest*)res;
  813.     certReqMsgs[i] = CRMF_CreateCertReqMsg();
  814.     srv = CRMF_CertReqMsgSetCertRequest(certReqMsgs[i], curReq->m_CRMFRequest);
  815.     if (srv != SECSuccess) {
  816.       rv = PR_FAILURE;
  817.       goto loser;
  818.     }
  819.     rv = SSMCRMFRequest_SetProofOfPossession(certReqMsgs[i], curReq);
  820.     if (rv != PR_SUCCESS) {
  821.       goto loser;
  822.     }
  823.     
  824.   }
  825.   /* Now we're ready to encode */
  826.   messages.messages = certReqMsgs;
  827.   encodedReq = SEC_ASN1EncodeItem(NULL, NULL, &messages,
  828.                                   CRMFCertReqMessagesTemplate);
  829.   if (encodedReq == NULL) {
  830.     rv = PR_FAILURE;
  831.     goto loser;
  832.   }
  833.   *destDER = BTOA_DataToAscii(encodedReq->data, encodedReq->len);
  834.   *destLen = (*destDER == NULL) ? 0 : strlen(*destDER) + 1;
  835.   SECITEM_FreeItem(encodedReq, PR_TRUE);
  836.   rv = (*destDER == NULL) ? PR_FAILURE : PR_SUCCESS;
  837.  loser:
  838.   /* Do some massive memory clean-up in here. */
  839.   if (certReqMsgs != NULL) {
  840.     for (i=0; certReqMsgs[i] != NULL; i++){
  841.       CRMF_DestroyCertReqMsg(certReqMsgs[i]);
  842.     }
  843.     PR_Free(certReqMsgs);
  844.   }
  845.   return rv;
  846. }
  848. void
  849. ssm_processcmmfresponse_thread(void *arg)
  850. {
  851.   CMMFResponseArg *inArg = (CMMFResponseArg*)arg;
  852.   SECItem *msg = inArg->msg;
  853.   SSMControlConnection *connection = inArg->connection;
  854.   SECStatus    srv;
  855.   SSMStatus    rv;
  856.   char        *nickname=NULL;
  857.   int          numResponses, i;
  858.   SECItem      cmmfDer = {siBuffer, NULL, 0};
  859.   PRArenaPool *ourPool  = NULL;
  860.   SECItem     *derCerts = NULL;
  861.   SSMPKCS12CreateArg p12Create;
  862.   SSMResourceID      p12RID;
  863.   PRBool             freeLocalNickname = PR_FALSE;
  865.   SSMPKCS12Context   *p12Cxt         = NULL;
  866.   CERTCertList       *caPubs         = NULL;
  867.   CERTCertificate    *currCert       = NULL;
  868.   CERTCertificate    *dbCert         = NULL;
  869.   CMMFCertRepContent *certRepContent = NULL;
  870.   CMMFCertResponse   *currResponse   = NULL;
  871.   PK11SlotInfo       *slot           = NULL;
  872.   CERTCertificate   **certArr        = NULL;
  873.   CMMFPKIStatus       reqStatus;
  874.   PRBool              certAlreadyExisted = PR_FALSE;
  875.   CMMFCertResponseRequest request;
  877.   if (CMT_DecodeMessage(CMMFCertResponseRequestTemplate, &request, 
  878.                         (CMTItem*)msg) != CMTSuccess) {
  879.       goto loser;
  880.   }
  882.   srv = ATOB_ConvertAsciiToItem(&cmmfDer, request.base64Der);
  883.   if (srv != SECSuccess || cmmfDer.data == NULL) {
  884.       goto loser;
  885.   }
  886.   certRepContent = CMMF_CreateCertRepContentFromDER(connection->m_certdb,
  887.                                                     (const char*)cmmfDer.data,
  888.                                                     cmmfDer.len);
  889.   if (certRepContent == NULL) {
  890.       /* This could be a key recovery response, but fail for now. */
  891.       goto loser;
  892.   }
  893.   numResponses = CMMF_CertRepContentGetNumResponses(certRepContent);
  894.   if (request.doBackup) {
  895.       certArr = SSM_ZNEW_ARRAY(CERTCertificate*, numResponses);
  896.       if (certArr == NULL) {
  897.           /* Let's not do back up in this case. */
  898.           request.doBackup = (CMBool) PR_FALSE;
  899.       }
  900.   }
  901.   for (i=0; i<numResponses; i++) {
  902.       currResponse = CMMF_CertRepContentGetResponseAtIndex(certRepContent, i);
  903.       if (currResponse == NULL) {
  904.           goto loser;
  905.       }
  906.       /* Need to make sure the ID corresponds to a request Cartman actually
  907.        * made.  Figure out how you're gonna do this.
  908.        */
  909.       reqStatus = CMMF_CertResponseGetPKIStatusInfoStatus(currResponse);
  910.       if (!(reqStatus == cmmfGranted || reqStatus == cmmfGrantedWithMods)) {
  911.           /* The CA didn't give us the cert as we requested. */
  912.           goto loser;
  913.       }
  914.       currCert = CMMF_CertResponseGetCertificate(currResponse, 
  915.  connection->m_certdb);
  916.       if (currCert == NULL) {
  917.           goto loser;
  918.       }
  919.       if (!certificate_conflict(connection, &currCert->derCert,
  920.                                connection->m_certdb, !certAlreadyExisted)) {
  921.           /* This certificate already exists in the permanent
  922.            * database.  Let's not add it and continue on 
  923.            * processing responses.
  924.            */
  925.           if (request.doBackup) {
  926.               certArr[i] = currCert;
  927.           } else {
  928.               CERT_DestroyCertificate(currCert);
  929.           }
  930.           CMMF_DestroyCertResponse(currResponse);
  931.           certAlreadyExisted = PR_TRUE;
  932.           continue;
  933.       }
  934.       
  935.       if (currCert->subjectList && currCert->subjectList->entry && 
  936.           currCert->subjectList->entry->nickname) {
  937.           nickname = currCert->subjectList->entry->nickname;
  938.       } else if (request.nickname == NULL || request.nickname[0] == '') {
  939.           nickname = default_nickname(currCert, connection);
  940.           freeLocalNickname = PR_TRUE; 
  941.       } else {
  942.           nickname = request.nickname;
  943.       }
  944.       slot = PK11_ImportCertForKey(currCert, nickname, connection);
  945.       if (freeLocalNickname) {
  946.           PR_Free(nickname);
  947.           freeLocalNickname = PR_FALSE;
  948.       }
  949.       if (slot == NULL) {
  950.           goto loser;
  951.       }
  952.       SSM_UseAsDefaultEmailIfNoneSet(connection, currCert, PR_TRUE);
  953.       if (request.doBackup) {
  954.           certArr[i] = currCert;
  955.       } else {
  956.           CERT_DestroyCertificate(currCert);
  957.       }
  958.       PK11_FreeSlot(slot);
  959.       CMMF_DestroyCertResponse(currResponse);
  960.   }
  961.   caPubs = CMMF_CertRepContentGetCAPubs(certRepContent);
  962.   if (caPubs != NULL) {
  963.       CERTCertListNode *node;
  965.       /* We got some CA certs to install in the database */
  966.       ourPool = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);
  967.       if (ourPool == NULL) {
  968.           goto loser;
  969.       }
  970.       derCerts = PORT_ArenaNewArray(ourPool, SECItem, 
  971.                                     SSM_CertListCount(caPubs));
  972.       if (derCerts == NULL) {
  973.           goto loser;
  974.       }
  975.       for (node = CERT_LIST_HEAD(caPubs), i=0; 
  976.            !CERT_LIST_END(node, caPubs);
  977.            node = CERT_LIST_NEXT(node), i++) {
  978.           srv = SECITEM_CopyItem(ourPool, &derCerts[i], &node->cert->derCert);
  979.           if (srv != SECSuccess) {
  980.               goto loser;
  981.           }
  982.       }
  983.       srv = CERT_ImportCAChain(derCerts, SSM_CertListCount(caPubs),
  984.                                certUsageUserCertImport);
  985.       if (srv != SECSuccess) {
  986.           goto loser;
  987.       }
  988.       PORT_FreeArena(ourPool, PR_FALSE);
  989.   }
  990.   CMMF_DestroyCertRepContent(certRepContent);
  991.   if (request.doBackup) {
  992.       p12Create.isExportContext = PR_TRUE;
  993.       rv = SSM_CreateResource(SSM_RESTYPE_PKCS12_CONTEXT, 
  994.                               (void*)&p12Create,
  995.                               connection, &p12RID,
  996.                               (SSMResource**)(&p12Cxt));
  997.       p12Cxt->arg = SSM_ZNEW(SSMPKCS12BackupThreadArg);
  998.       if (p12Cxt->arg == NULL) {
  999.           goto loser;
  1000.       }
  1001.       p12Cxt->arg->certs = certArr;
  1002.       p12Cxt->arg->numCerts = numResponses;
  1003.       p12Cxt->super.m_clientContext = request.clientContext;
  1004.       p12Cxt->m_thread = SSM_CreateThread(&p12Cxt->super,
  1005.                                   SSMPKCS12Context_BackupMultipleCertsThread);
  1006.                                           
  1008.   }
  1009.   PR_Free(request.base64Der);
  1010.   PR_Free(request.nickname);
  1011.   PR_FREEIF(msg->data);
  1012.   msg->data = NULL;
  1013.   msg->len = 0;
  1014.   msg->type = (SECItemType)(SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | 
  1015.                             SSM_PROCESS_CMMF_RESP);
  1016.   if (ssmcontrolconnection_send_message_to_client(connection, msg) 
  1017.       != SSM_SUCCESS){
  1018.       goto loser;
  1019.   }
  1020.   SSM_FreeResource(&connection->super.super);
  1021.   SECITEM_FreeItem(msg, PR_TRUE);
  1022.   return;
  1023.  loser:
  1024.   if (connection != NULL) {
  1025.       SSM_FreeResource(&connection->super.super);
  1026.   }
  1027.   if (ourPool != NULL) {
  1028.       PORT_FreeArena(ourPool, PR_FALSE);
  1029.   }
  1030.   if (certRepContent != NULL) {
  1031.       CMMF_DestroyCertRepContent(certRepContent);
  1032.   }
  1033.   if (request.base64Der != NULL) {
  1034.       PR_Free(request.base64Der);
  1035.   }
  1036.   if (request.nickname != NULL) {
  1037.       PR_Free(request.nickname);
  1038.   }
  1039.   rv = ssmcontrolconnection_encode_err_reply(msg, SSM_FAILURE);
  1040.   PR_ASSERT(rv == SSM_SUCCESS);
  1041.   rv = ssmcontrolconnection_send_message_to_client(connection, msg);
  1042.   PR_ASSERT(rv == SSM_SUCCESS);
  1043. }
  1045. SSMStatus 
  1046. SSM_ProcessCMMFCertResponse(SECItem *msg, SSMControlConnection *connection)
  1047. {
  1048.     CMMFResponseArg *arg=NULL;
  1050.     arg = SSM_NEW(CMMFResponseArg);
  1051.     if (arg == NULL) {
  1052.         goto loser;
  1053.     }
  1054.     arg->msg = SECITEM_DupItem(msg);
  1055.     arg->connection = connection;
  1056.     SSM_GetResourceReference(&connection->super.super);
  1057.     if (SSM_CreateAndRegisterThread(PR_USER_THREAD, 
  1058.                                     ssm_processcmmfresponse_thread,
  1059.                                     (void *)arg, PR_PRIORITY_NORMAL, 
  1060.                                     PR_LOCAL_THREAD,
  1061.                                     PR_UNJOINABLE_THREAD, 0) == NULL) {
  1062.         SSM_FreeResource(&connection->super.super);
  1063.         goto loser;
  1064.     }
  1065.     return SSM_ERR_DEFER_RESPONSE;    
  1066.  loser:
  1067.     PR_FREEIF(arg);
  1068.     return SSM_FAILURE;
  1069. }
  1071. SECKEYPrivateKey*
  1072. SSM_FindPrivKeyFromKeyID(SECItem *keyID, SECMODModule *currMod,
  1073.                          SSMControlConnection *ctrl)
  1074. {
  1075.     PK11SlotInfo     *currSlot;
  1076.     SECKEYPrivateKey *privKey = NULL;
  1077.     int               i;
  1079.     for (i=0; i<currMod->slotCount; i++) {
  1080.         currSlot = currMod->slots[i];
  1081.         privKey = PK11_FindKeyByKeyID(currSlot, keyID, (void*)ctrl);
  1082.         if (privKey != NULL) {
  1083.             break;
  1084.         }
  1085.     }
  1086.     return privKey;
  1087. }
  1089. SECKEYPrivateKey*
  1090. SSM_FindPrivKeyFromPubValue(SECItem *publicValue, SECMODModuleList *modList,
  1091.                             SSMControlConnection *ctrl)
  1092. {
  1093.     SECItem          *keyID = NULL;
  1094.     SECMODModuleList *currMod;
  1095.     SECKEYPrivateKey *privKey = NULL;
  1097.     keyID = PK11_MakeIDFromPubKey(publicValue);
  1098.     if (keyID == NULL) {
  1099.         return NULL;
  1100.     }
  1101.     /* Iterate through the slots looking for the slot where the private 
  1102.      * key lives.
  1103.      */
  1104.     currMod = modList;
  1105.     while (currMod != NULL && currMod->module != NULL) {
  1106.         privKey = SSM_FindPrivKeyFromKeyID(keyID, currMod->module, ctrl);
  1107.         if (privKey != NULL) {
  1108.             break;
  1109.         }
  1110.         currMod = currMod->next;
  1111.     }
  1112.     SECITEM_FreeItem(keyID, PR_TRUE);
  1113.     return privKey;
  1114. }
  1116. SSMStatus
  1117. SSM_InitCRMFASN1Arg(CRMFASN1Arg *arg)
  1118. {
  1119.     arg->buffer.data = SSM_NEW_ARRAY(unsigned char, DEFAULT_ASN1_CHUNK_SIZE);
  1120.     if (arg->buffer.data == NULL) {
  1121.         return PR_FAILURE;
  1122.     }
  1123.     arg->buffer.len   = 0;
  1124.     arg->allocatedLen = DEFAULT_ASN1_CHUNK_SIZE;
  1125.     return PR_FAILURE;
  1126. }
  1128. void
  1129. SSM_GenericASN1Callback(void *arg, const char *buf, unsigned long len)
  1130. {
  1131.     CRMFASN1Arg   *encoderArg = (CRMFASN1Arg*)arg;
  1132.     unsigned char *cursor;
  1133.     
  1134.     if ((encoderArg->buffer.len + len) > encoderArg->allocatedLen) {
  1135.         int newSize = encoderArg->buffer.len + DEFAULT_ASN1_CHUNK_SIZE;
  1136.         void *dummy = PR_Realloc(encoderArg->buffer.data, newSize);
  1137.         if (dummy == NULL) {
  1138.             PR_ASSERT(0);
  1139.             return;
  1140.         }
  1141.         encoderArg->buffer.data  = (unsigned char *) dummy;
  1142.         encoderArg->allocatedLen = newSize;
  1143.     }
  1144.     cursor = &(encoderArg->buffer.data[encoderArg->buffer.len]);
  1145.     memcpy(cursor, buf, len);
  1146.     encoderArg->buffer.len += len;
  1147. }
  1149. SSMStatus
  1150. SSM_RespondToPOPChallenge(SECItem                *msg, 
  1151.                           SSMControlConnection   *ctrl,
  1152.                           char                  **challengeResponse, 
  1153.                           PRUint32               *responseLen)
  1154. {
  1155.     SSMStatus   rv;
  1156.     SECStatus  srv;
  1157.     SECItem    challengeDER = {siBuffer, NULL, 0}, *publicValue=NULL;
  1158.     int        i, numChallenges;
  1159.     long      *decryptedChallenges=NULL;
  1161.     CMMFPOPODecKeyChallContent *challContent = NULL;
  1162.     SECMODModuleList           *modList = NULL;
  1163.     SECKEYPrivateKey           *privKey = NULL;
  1164.     CRMFASN1Arg                 asn1Arg = {{(SECItemType) 0, NULL, 0}, 0};
  1165.     SingleStringMessage request;
  1167.     if (CMT_DecodeMessage(SingleStringMessageTemplate, &request, (CMTItem*)msg) != CMTSuccess) {
  1168.         goto loser;
  1169.     }
  1171.     srv = ATOB_ConvertAsciiToItem(&challengeDER, request.string);
  1172.     if (srv != SECSuccess) {
  1173.         goto loser;
  1174.     }
  1175.     challContent = CMMF_CreatePOPODecKeyChallContentFromDER((char *) challengeDER.data,
  1176.                                                             (unsigned int) challengeDER.len);
  1177.     if (challContent == NULL) {
  1178.         goto loser;
  1179.     }
  1180.     numChallenges = CMMF_POPODecKeyChallContentGetNumChallenges(challContent);
  1181.     if (numChallenges <= 0) {
  1182.         /* There weren't any challenges in the challenge string. */
  1183.         goto loser;
  1184.     }
  1185.     modList = SECMOD_GetDefaultModuleList();
  1186.     if (modList == NULL) {
  1187.         goto loser;
  1188.     }
  1189.     decryptedChallenges = SSM_ZNEW_ARRAY(long, (numChallenges+1));
  1190.     if (decryptedChallenges == NULL) {
  1191.         goto loser;
  1192.     }
  1193.     for (i=0; i<numChallenges; i++) {
  1194.         publicValue = 
  1195.             CMMF_POPODecKeyChallContentGetPublicValue(challContent, i);
  1196.         if (publicValue == NULL) {
  1197.             goto loser;
  1198.         }
  1199.         privKey = SSM_FindPrivKeyFromPubValue(publicValue, modList, ctrl);
  1200.         if (privKey == NULL) {
  1201.             goto loser;
  1202.         }
  1203.         SECITEM_FreeItem(publicValue, PR_TRUE);
  1204.         publicValue = NULL;
  1205.         srv = CMMF_POPODecKeyChallContDecryptChallenge(challContent, i,
  1206.                                                        privKey);
  1207.         if (srv != SECSuccess) {
  1208.             goto loser;
  1209.         }
  1211.         srv = CMMF_POPODecKeyChallContentGetRandomNumber(challContent, i,
  1212.                                                      &decryptedChallenges[i]);
  1213.         if (srv != SECSuccess) {
  1214.             goto loser;
  1215.         }
  1216.     }
  1217.     modList = NULL;
  1218.     CMMF_DestroyPOPODecKeyChallContent(challContent);
  1219.     challContent = NULL;
  1220.     rv = SSM_InitCRMFASN1Arg(&asn1Arg);
  1221.     srv = CMMF_EncodePOPODecKeyRespContent(decryptedChallenges, numChallenges,
  1222.                                            SSM_GenericASN1Callback, &asn1Arg);
  1223.     if (srv != SECSuccess) {
  1224.         goto loser;
  1225.     }
  1226.     *challengeResponse = BTOA_DataToAscii(asn1Arg.buffer.data, 
  1227.                                           asn1Arg.buffer.len);
  1228.     PR_Free(asn1Arg.buffer.data);
  1229.     *responseLen = (*challengeResponse == NULL) ? 0 : 
  1230.                                                   strlen(*challengeResponse)+1;
  1231.     PR_Free(decryptedChallenges);
  1232.     PR_Free(request.string);
  1233.     return PR_SUCCESS;
  1234.  loser:
  1235.     if (asn1Arg.buffer.data != NULL) {
  1236.         PR_Free(asn1Arg.buffer.data);
  1237.     }
  1238.     if (decryptedChallenges != NULL) {
  1239.         PR_Free(decryptedChallenges);
  1240.     }
  1241.     if (request.string != NULL) {
  1242.         PR_Free(request.string);
  1243.     }
  1244.     if (challContent != NULL) {
  1245.         CMMF_DestroyPOPODecKeyChallContent(challContent);
  1246.     }
  1247.     if (publicValue != NULL) {
  1248.         SECITEM_FreeItem(publicValue, PR_TRUE);
  1249.     }
  1250.     if (modList != NULL) {
  1251.         SECMOD_DestroyModuleList(modList);
  1252.     }
  1253.     return PR_FAILURE;
  1254. }
  1256. void SSM_CRMFEncodeThread(void *arg)
  1257. {
  1258.    SSMCRMFThreadArg     *encArg = (SSMCRMFThreadArg*)arg; 
  1259.    SSMControlConnection *ctrl   = encArg->ctrl;
  1260.    SECItem              *msg    = encArg->msg;
  1261.    char                 *encodedReq = NULL;
  1262.    PRUint32              derLen;
  1263.    SingleItemMessage reply;
  1264.    SSMStatus rv;
  1266.    SSM_RegisterThread("CRMF Encode", NULL);
  1267.    SSM_DEBUG("Encoding CRMF request(s)n");
  1268.    rv = SSM_EncodeCRMFRequests(ctrl, msg, &encodedReq, &derLen);
  1269.    if (rv != PR_SUCCESS) {
  1270.        goto loser;
  1271.    }
  1272.    msg->data = NULL;
  1273.    msg->len  = 0;
  1274.    msg->type = (SECItemType) (SSM_REPLY_OK_MESSAGE | 
  1275.                               SSM_CRMF_ACTION      |
  1276.                               SSM_DER_ENCODE_REQ);
  1277.    reply.item.len = derLen;
  1278.    reply.item.data = (unsigned char *) encodedReq;
  1279.    if (CMT_EncodeMessage(SingleItemMessageTemplate, 
  1280.                          (CMTItem*)msg, &reply) != CMTSuccess) {
  1281.        goto loser;
  1282.    }
  1283.    SSM_DEBUG("Created the following request: n");
  1284.    SSM_DEBUG("n%sn",encodedReq);
  1285.    PR_Free(encodedReq);
  1286.    SSM_DEBUG("queueing reply: type %lx, len %ld.n", msg->type, msg->len);
  1287.    SSM_SendQMessage(ctrl->m_controlOutQ,
  1288.                     SSM_PRIORITY_NORMAL,
  1289.                     msg->type, msg->len,
  1290.                     (char *)msg->data, PR_TRUE);
  1291.    goto done;
  1292.  loser:
  1293.   {
  1294.     SingleNumMessage reply;
  1296.     msg->type = (SECItemType) SSM_REPLY_ERR_MESSAGE;
  1297.     reply.value = rv;
  1298.     CMT_EncodeMessage(SingleNumMessageTemplate, (CMTItem*)msg, &reply);
  1299.   }
  1300.   SSM_DEBUG("queueing reply: type %lx, len %ld.n", msg->type, msg->len);
  1301.   SSM_SendQMessage(ctrl->m_controlOutQ,
  1302.                    SSM_PRIORITY_NORMAL,
  1303.                    msg->type, msg->len,
  1304.                    (char *)msg->data, PR_TRUE);
  1305.  done:
  1306.   SSM_FreeResource(&ctrl->super.super);
  1307.   SECITEM_FreeItem(msg, PR_TRUE);
  1308.   PR_Free(arg);
  1309. }