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

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

CA认证

开发平台：

WINDOWS

crmfcgi.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include "seccomon.h"
  35. #include "nss.h"
  36. #include "key.h"
  37. #include "cert.h"
  38. #include "pk11func.h"
  39. #include "secmod.h"
  40. #include "cmmf.h"
  41. #include "crmf.h"
  42. #include "base64.h"
  43. #include "secasn1.h"
  44. #include "crypto.h"
  45. #include <string.h>
  46. #include <stdlib.h>
  47. #include <stdio.h>
  49. #define DEFAULT_ALLOC_SIZE 200
  50. #define DEFAULT_CGI_VARS   20
  52. typedef struct CGIVariableStr {
  53.   char *name;
  54.   char *value;
  55. } CGIVariable;
  57. typedef struct CGIVarTableStr {
  58.   CGIVariable **variables;
  59.   int           numVars;
  60.   int           numAlloc; 
  61. } CGIVarTable;
  63. typedef struct CertResponseInfoStr {
  64.   CERTCertificate *cert;
  65.   long             certReqID;
  66. } CertResponseInfo;
  68. typedef struct ChallengeCreationInfoStr {
  69.   long             random;
  70.   SECKEYPublicKey *pubKey;
  71. } ChallengeCreationInfo;
  73. char *missingVar = NULL;
  75. /*
  76.  * Error values.
  77.  */
  78. typedef enum {
  79.   NO_ERROR = 0,
  80.   NSS_INIT_FAILED,
  81.   AUTH_FAILED,
  82.   REQ_CGI_VAR_NOT_PRESENT,
  83.   CRMF_REQ_NOT_PRESENT,
  84.   BAD_ASCII_FOR_REQ,
  85.   CGI_VAR_MISSING,
  86.   COULD_NOT_FIND_CA,
  87.   COULD_NOT_DECODE_REQS,
  88.   OUT_OF_MEMORY,
  89.   ERROR_RETRIEVING_REQUEST_MSG,
  90.   ERROR_RETRIEVING_CERT_REQUEST,
  91.   ERROR_RETRIEVING_SUBJECT_FROM_REQ,
  92.   ERROR_RETRIEVING_PUBLIC_KEY_FROM_REQ,
  93.   ERROR_CREATING_NEW_CERTIFICATE,
  94.   COULD_NOT_START_EXTENSIONS,
  95.   ERROR_RETRIEVING_EXT_FROM_REQ,
  96.   ERROR_ADDING_EXT_TO_CERT,
  97.   ERROR_ENDING_EXTENSIONS,
  98.   COULD_NOT_FIND_ISSUER_PRIVATE_KEY,
  99.   UNSUPPORTED_SIGN_OPERATION_FOR_ISSUER,
  100.   ERROR_SETTING_SIGN_ALG,
  101.   ERROR_ENCODING_NEW_CERT,
  102.   ERROR_SIGNING_NEW_CERT,
  103.   ERROR_CREATING_CERT_REP_CONTENT,
  104.   ERROR_CREATING_SINGLE_CERT_RESPONSE,
  105.   ERROR_SETTING_CERT_RESPONSES,
  106.   ERROR_CREATING_CA_LIST,
  107.   ERROR_ADDING_ISSUER_TO_CA_LIST,
  108.   ERROR_ENCODING_CERT_REP_CONTENT,
  109.   NO_POP_FOR_REQUEST,
  110.   UNSUPPORTED_POP,
  111.   ERROR_RETRIEVING_POP_SIGN_KEY,
  112.   ERROR_RETRIEVING_ALG_ID_FROM_SIGN_KEY,
  113.   ERROR_RETRIEVING_SIGNATURE_FROM_POP_SIGN_KEY,
  114.   DO_CHALLENGE_RESPONSE,
  115.   ERROR_RETRIEVING_PUB_KEY_FROM_NEW_CERT,
  116.   ERROR_ENCODING_CERT_REQ_FOR_POP,
  117.   ERROR_VERIFYING_SIGNATURE_POP,
  118.   ERROR_RETRIEVING_PUB_KEY_FOR_CHALL,
  119.   ERROR_CREATING_EMPTY_CHAL_CONTENT,
  120.   ERROR_EXTRACTING_GEN_NAME_FROM_ISSUER,
  121.   ERROR_SETTING_CHALLENGE,
  122.   ERROR_ENCODING_CHALL,
  123.   ERROR_CONVERTING_CHALL_TO_BASE64,
  124.   ERROR_CONVERTING_RESP_FROM_CHALL_TO_BIN,
  125.   ERROR_CREATING_KEY_RESP_FROM_DER,
  126.   ERROR_RETRIEVING_CLIENT_RESPONSE_TO_CHALLENGE,
  127.   ERROR_RETURNED_CHALL_NOT_VALUE_EXPECTED,
  128.   ERROR_GETTING_KEY_ENCIPHERMENT,
  129.   ERROR_NO_POP_FOR_PRIVKEY,
  130.   ERROR_UNSUPPORTED_POPOPRIVKEY_TYPE
  131. } ErrorCode;
  133. const char *
  134. CGITableFindValue(CGIVarTable *varTable, const char *key);
  136. void
  137. spitOutHeaders(void)
  138. {
  139.   printf("Content-type: text/htmlnn");
  140. }
  142. void
  143. dumpRequest(CGIVarTable *varTable)
  144. {
  145.   int i;
  146.   CGIVariable *var;
  148.   printf ("<table border=1 cellpadding=1 cellspacing=1 width="100%%">n");
  149.   printf ("<tr><td><b><center>Variable Name<center></b></td>"
  150.           "<td><b><center>Value</center></b></td></tr>n");
  151.   for (i=0; i<varTable->numVars; i++) {
  152.     var = varTable->variables[i];
  153.     printf ("<tr><td><pre>%s</pre></td><td><pre>%s</pre></td></tr>n", 
  154.              var->name, var->value);
  155.   }
  156.   printf("</table>n");
  157. }
  159. void
  160. echo_request(CGIVarTable *varTable)
  161. {
  162.   spitOutHeaders();
  163.   printf("<html><head><title>CGI Echo Page</title></head>n"
  164.  "<body><h1>Got the following request</h1>n");
  165.   dumpRequest(varTable);
  166.   printf("</body></html>");
  167. }
  169. void
  170. processVariable(CGIVariable *var)
  171. {
  172.   char *plusSign, *percentSign;
  174.   /*First look for all of the '+' and convert them to spaces */
  175.   plusSign = var->value;
  176.   while ((plusSign=strchr(plusSign, '+')) != NULL) {
  177.     *plusSign = ' ';
  178.   }
  179.   percentSign = var->value;
  180.   while ((percentSign=strchr(percentSign, '%')) != NULL) {
  181.     char string[3];
  182.     int  value;
  184.     string[0] = percentSign[1];
  185.     string[1] = percentSign[2];
  186.     string[2] = '';
  188.     sscanf(string,"%x", &value);
  189.     *percentSign = (char)value;
  190.     memmove(&percentSign[1], &percentSign[3], 1+strlen(&percentSign[3]));
  191.   }
  192. }
  194. char *
  195. parseNextVariable(CGIVarTable *varTable, char *form_output)
  196. {
  197.   char *ampersand, *equal;
  198.   CGIVariable *var;
  200.   if (varTable->numVars == varTable->numAlloc) {
  201.     CGIVariable **newArr = realloc(varTable->variables, 
  202.                                    (varTable->numAlloc + DEFAULT_CGI_VARS)*sizeof(CGIVariable*));
  203.     if (newArr == NULL) {
  204.       return NULL;
  205.     }
  206.     varTable->variables = newArr;
  207.     varTable->numAlloc += DEFAULT_CGI_VARS;
  208.   }
  209.   equal     = strchr(form_output, '=');
  210.   if (equal == NULL) {
  211.     return NULL;
  212.   }
  213.   ampersand = strchr(equal, '&');
  214.   if (ampersand == NULL) {
  215.     return NULL;
  216.   }
  217.   equal[0] = '';
  218.   if (ampersand != NULL) {
  219.     ampersand[0] = '';
  220.   }
  221.   var = malloc(sizeof(CGIVariable));
  222.   var->name = form_output; 
  223.   var->value = &equal[1];
  224.   varTable->variables[varTable->numVars] = var;
  225.   varTable->numVars++;
  226.   processVariable(var);
  227.   return (ampersand != NULL) ? &ampersand[1] : NULL;
  228. }
  230. void
  231. ParseInputVariables(CGIVarTable *varTable, char *form_output)
  232. {
  233.   varTable->variables = malloc(sizeof(CGIVariable*)*DEFAULT_CGI_VARS);
  234.   varTable->numVars = 0;
  235.   varTable->numAlloc = DEFAULT_CGI_VARS;
  236.   while (form_output && form_output[0] != '') {
  237.     form_output = parseNextVariable(varTable, form_output);
  238.   }
  239. }
  241. const char *
  242. CGITableFindValue(CGIVarTable *varTable, const char *key)
  243. {
  244.   const char *retVal = NULL;
  245.   int i;
  247.   for (i=0; i<varTable->numVars; i++) {
  248.     if (strcmp(varTable->variables[i]->name, key) == 0) {
  249.       retVal = varTable->variables[i]->value;
  250.       break;
  251.     } 
  252.   }
  253.   return retVal;
  254. }
  256. char*
  257. passwordCallback(PK11SlotInfo *slot, PRBool retry, void *arg)
  258. {
  259.   const char *passwd;
  260.   if (retry) {
  261.     return NULL;
  262.   }
  263.   passwd = CGITableFindValue((CGIVarTable*)arg, "dbPassword");
  264.   if (passwd == NULL) {
  265.     return NULL;
  266.   }
  267.   return PORT_Strdup(passwd);
  268. }
  270. ErrorCode
  271. initNSS(CGIVarTable *varTable)
  272. {
  273.   const char *nssDir;
  274.   PK11SlotInfo *keySlot;
  275.   SECStatus rv;
  277.   nssDir = CGITableFindValue(varTable,"NSSDirectory");
  278.   if (nssDir == NULL) {
  279.     missingVar = "NSSDirectory";
  280.     return REQ_CGI_VAR_NOT_PRESENT;
  281.   }
  282.   rv = NSS_Init(nssDir);
  283.   if (rv != SECSuccess) {
  284.     return NSS_INIT_FAILED;
  285.   }
  286.   PK11_SetPasswordFunc(passwordCallback);
  287.   keySlot = PK11_GetInternalKeySlot();
  288.   rv = PK11_Authenticate(keySlot, PR_FALSE, varTable);
  289.   if (rv != SECSuccess) {
  290.     return AUTH_FAILED;
  291.   }
  292.   return NO_ERROR;
  293. }
  295. void
  296. dumpErrorMessage(ErrorCode errNum)
  297. {
  298.   spitOutHeaders();
  299.   printf("<html><head><title>Error</title></head><body><h1>Error processing "
  300.  "data</h1> Received the error %d<p>", errNum);
  301.   if (errNum  ==   REQ_CGI_VAR_NOT_PRESENT) {
  302.     printf ("The missing variable is %s.", missingVar);
  303.   }
  304.   printf ("<i>More useful information here in the future.</i></body></html>");
  305. }
  307. ErrorCode
  308. initOldCertReq(CERTCertificateRequest *oldCertReq,
  309.        CERTName *subject, CERTSubjectPublicKeyInfo *spki)
  310. {
  311.   PRArenaPool *poolp;
  313.   poolp = oldCertReq->arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  314.   SEC_ASN1EncodeInteger(poolp, &oldCertReq->version, 
  315. SEC_CERTIFICATE_VERSION_3);
  316.   CERT_CopyName(poolp, &oldCertReq->subject, subject);
  317.   SECKEY_CopySubjectPublicKeyInfo(poolp, &oldCertReq->subjectPublicKeyInfo,
  318.   spki);
  319.   oldCertReq->attributes = NULL;
  320.   return NO_ERROR;
  321. }
  323. ErrorCode
  324. addExtensions(CERTCertificate *newCert, CRMFCertRequest *certReq)
  325. {
  326.   int numExtensions, i;
  327.   void *extHandle;
  328.   ErrorCode rv = NO_ERROR;
  329.   CRMFCertExtension *ext;
  330.   SECStatus srv;
  332.   numExtensions = CRMF_CertRequestGetNumberOfExtensions(certReq);
  333.   if (numExtensions == 0) {
  334.     /* No extensions to add */
  335.     return NO_ERROR;
  336.   }
  337.   extHandle = CERT_StartCertExtensions(newCert);
  338.   if (extHandle == NULL) {
  339.     rv = COULD_NOT_START_EXTENSIONS;
  340.     goto loser;
  341.   }
  342.   for (i=0; i<numExtensions; i++) {
  343.     ext = CRMF_CertRequestGetExtensionAtIndex(certReq, i);
  344.     if (ext == NULL) {
  345.       rv = ERROR_RETRIEVING_EXT_FROM_REQ;
  346.     }
  347.     srv = CERT_AddExtension(extHandle, CRMF_CertExtensionGetOidTag(ext),
  348.     CRMF_CertExtensionGetValue(ext),
  349.     CRMF_CertExtensionGetIsCritical(ext), PR_FALSE);
  350.     if (srv != SECSuccess) {
  351.       rv = ERROR_ADDING_EXT_TO_CERT;
  352.     }
  353.   }
  354.   srv = CERT_FinishExtensions(extHandle);
  355.   if (srv != SECSuccess) {
  356.     rv = ERROR_ENDING_EXTENSIONS;
  357.     goto loser;
  358.   }
  359.   return NO_ERROR;
  360.  loser:
  361.   return rv;
  362. }
  364. void
  365. writeOutItem(const char *filePath, SECItem *der)
  366. {
  367.   PRFileDesc *outfile;
  369.   outfile = PR_Open (filePath,
  370.      PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
  371.      0666);
  372.   PR_Write(outfile, der->data, der->len);
  373.   PR_Close(outfile);
  375. }
  377. ErrorCode
  378. createNewCert(CERTCertificate**issuedCert,CERTCertificateRequest *oldCertReq,
  379.       CRMFCertReqMsg *currReq, CRMFCertRequest *certReq, 
  380.       CERTCertificate *issuerCert, CGIVarTable *varTable)
  381. {
  382.   CERTCertificate *newCert = NULL;
  383.   CERTValidity *validity;
  384.   PRExplodedTime printableTime;
  385.   PRTime now, after;
  386.   ErrorCode rv=NO_ERROR;
  387.   SECKEYPrivateKey *issuerPrivKey;
  388.   SECItem derCert = { 0 };
  389.   SECOidTag signTag;
  390.   SECStatus srv;
  391.   long version;
  393.   now = PR_Now();
  394.   PR_ExplodeTime(now, PR_GMTParameters, &printableTime);
  395.   printableTime.tm_month += 9;
  396.   after = PR_ImplodeTime(&printableTime);
  397.   validity = CERT_CreateValidity(now, after);
  398.   newCert = *issuedCert = 
  399.     CERT_CreateCertificate(rand(), &(issuerCert->subject), validity, 
  400.    oldCertReq);
  401.   if (newCert == NULL) {
  402.     rv = ERROR_CREATING_NEW_CERTIFICATE;
  403.     goto loser;
  404.   }
  405.   rv = addExtensions(newCert, certReq);
  406.   if (rv != NO_ERROR) {
  407.     goto loser;
  408.   }
  409.   issuerPrivKey = PK11_FindKeyByAnyCert(issuerCert, varTable);
  410.   if (issuerPrivKey == NULL) {
  411.     rv = COULD_NOT_FIND_ISSUER_PRIVATE_KEY;
  412.   }
  413.   switch(issuerPrivKey->keyType) {
  414.   case rsaKey:
  415.     signTag = SEC_OID_PKCS1_MD5_WITH_RSA_ENCRYPTION;
  416.     break;
  417.   case dsaKey:
  418.     signTag = SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST;
  419.     break;
  420.   default:
  421.     rv = UNSUPPORTED_SIGN_OPERATION_FOR_ISSUER;
  422.     goto loser;
  423.   }
  424.   srv = SECOID_SetAlgorithmID(newCert->arena, &newCert->signature, 
  425.       signTag, 0);
  426.   if (srv != SECSuccess) {
  427.     rv = ERROR_SETTING_SIGN_ALG;
  428.     goto loser;
  429.   }
  430.   srv = CRMF_CertRequestGetCertTemplateVersion(certReq, &version);
  431.   if (srv != SECSuccess) {
  432.     /* No version included in the request */
  433.     *(newCert->version.data) = SEC_CERTIFICATE_VERSION_3;
  434.   } else {
  435.     SECITEM_FreeItem(&newCert->version, PR_FALSE);
  436.     SEC_ASN1EncodeInteger(newCert->arena, &newCert->version, version);
  437.   }
  438.   SEC_ASN1EncodeItem(newCert->arena, &derCert, newCert, 
  439.      CERT_CertificateTemplate);
  440.   if (derCert.data == NULL) {
  441.     rv = ERROR_ENCODING_NEW_CERT;
  442.     goto loser;
  443.   }
  444.   srv = SEC_DerSignData(newCert->arena, &(newCert->derCert), derCert.data,
  445. derCert.len, issuerPrivKey, signTag);
  446.   if (srv != SECSuccess) {
  447.     rv = ERROR_SIGNING_NEW_CERT;
  448.     goto loser;
  449.   }
  450. #ifdef WRITE_OUT_RESPONSE
  451.   writeOutItem("newcert.der", &newCert->derCert);
  452. #endif
  453.   return NO_ERROR;
  454.  loser:
  455.   *issuedCert = NULL;
  456.   if (newCert) {
  457.     CERT_DestroyCertificate(newCert);
  458.   }
  459.   return rv;
  460.      
  461. }
  463. void
  464. formatCMMFResponse(char *nickname, char *base64Response)
  465. {
  466.   char *currLine, *nextLine;
  468.   printf("var retVal = crypto.importUserCertificates("%s",n", nickname);
  469.   currLine = base64Response;
  470.   while (1) {
  471.     nextLine = strchr(currLine, 'n');
  472.     if (nextLine == NULL) {
  473.       /* print out the last line here. */
  474.       printf (""%s",n", currLine);
  475.       break;
  476.     }
  477.     nextLine[0] = '';
  478.     printf(""%s\n"+n", currLine);
  479.     currLine = nextLine+1;
  480.   }
  481.   printf("true);n"
  482.  "if(retVal == '') {n"
  483.  "tdocument.write("<h1>New Certificate Succesfully Imported.</h1>");n"
  484.  "} else {n"
  485.  "tdocument.write("<h2>Unable to import New Certificate</h2>");n"
  486.  "tdocument.write("crypto.importUserCertificates returned <b>");n"
  487.  "tdocument.write(retVal);n"
  488.  "tdocument.write("</b>");n"
  489.  "}n");
  490. }
  492. void
  493. spitOutCMMFResponse(char *nickname, char *base64Response)
  494. {
  495.   spitOutHeaders();
  496.   printf("<html>n<head>n<title>CMMF Resonse Page</title>n</head>nn"
  497.  "<body><h1>CMMF Response Page</h1>n"
  498.  "<script language="JavaScript">n"
  499.  "<!--n");
  500.   formatCMMFResponse(nickname, base64Response);
  501.   printf("// -->n"
  502.  "</script>n</body>n</html>");
  503. }
  505. char*
  506. getNickname(CERTCertificate *cert)
  507. {
  508.   char *nickname;
  510.   if (cert->nickname != NULL) {
  511.     return cert->nickname;
  512.   }
  513.   nickname = CERT_GetCommonName(&cert->subject);
  514.   if (nickname != NULL) {
  515.     return nickname;
  516.   }
  517.   return CERT_NameToAscii(&cert->subject);
  518. }
  520. ErrorCode
  521. createCMMFResponse(CertResponseInfo *issuedCerts, int numCerts, 
  522.    CERTCertificate *issuerCert, char **base64der)
  523. {
  524.  CMMFCertRepContent *certRepContent=NULL;
  525.   ErrorCode rv = NO_ERROR;
  526.   CMMFCertResponse **responses, *currResponse;
  527.   CERTCertList *caList;
  528.   int i;
  529.   SECStatus srv;
  530.   PRArenaPool *poolp;
  531.   SECItem *der;
  533.   certRepContent = CMMF_CreateCertRepContent();
  534.   if (certRepContent == NULL) {
  535.     rv = ERROR_CREATING_CERT_REP_CONTENT;
  536.     goto loser;
  537.   }
  538.   responses = PORT_NewArray(CMMFCertResponse*, numCerts);
  539.   if (responses == NULL) {
  540.     rv = OUT_OF_MEMORY;
  541.     goto loser;
  542.   }
  543.   for (i=0; i<numCerts;i++) {
  544.     responses[i] = currResponse = 
  545.       CMMF_CreateCertResponse(issuedCerts[i].certReqID);
  546.     if (currResponse == NULL) {
  547.       rv = ERROR_CREATING_SINGLE_CERT_RESPONSE;
  548.       goto loser;
  549.     }
  550.     CMMF_CertResponseSetPKIStatusInfoStatus(currResponse, cmmfGranted);
  551.     CMMF_CertResponseSetCertificate(currResponse, issuedCerts[i].cert);
  552.   }
  553.   srv = CMMF_CertRepContentSetCertResponses(certRepContent, responses,
  554.     numCerts);
  555.   if (srv != SECSuccess) {
  556.     rv = ERROR_SETTING_CERT_RESPONSES;
  557.     goto loser;
  558.   }
  559.   caList = CERT_NewCertList();
  560.   if (caList == NULL) {
  561.     rv = ERROR_CREATING_CA_LIST;
  562.     goto loser;
  563.   }
  564.   srv = CERT_AddCertToListTail(caList, issuerCert);
  565.   if (srv != SECSuccess) {
  566.     rv = ERROR_ADDING_ISSUER_TO_CA_LIST;
  567.     goto loser;
  568.   }
  569.   srv = CMMF_CertRepContentSetCAPubs(certRepContent, caList);
  570.   CERT_DestroyCertList(caList);
  571.   poolp = PORT_NewArena(1024);
  572.   der = SEC_ASN1EncodeItem(poolp, NULL, certRepContent, 
  573.    CMMFCertRepContentTemplate);
  574.   if (der == NULL) {
  575.     rv = ERROR_ENCODING_CERT_REP_CONTENT;
  576.     goto loser;
  577.   }
  578. #ifdef WRITE_OUT_RESPONSE
  579.   writeOutItem("CertRepContent.der", der);
  580. #endif
  581.   *base64der = BTOA_DataToAscii(der->data, der->len);
  582.   return NO_ERROR;
  583.  loser:
  584.   return rv;
  585. }
  587. ErrorCode
  588. issueCerts(CertResponseInfo *issuedCerts, int numCerts, 
  589.    CERTCertificate *issuerCert)
  590. {
  591.   ErrorCode rv;
  592.   char *base64Response;
  594.   rv = createCMMFResponse(issuedCerts, numCerts, issuerCert, &base64Response);
  595.   if (rv != NO_ERROR) {
  596.     goto loser;
  597.   }
  598.   spitOutCMMFResponse(getNickname(issuedCerts[0].cert),base64Response);
  599.   return NO_ERROR;
  600.  loser:
  601.   return rv;
  602. }
  604. ErrorCode
  605. verifySignature(CGIVarTable *varTable, CRMFCertReqMsg *currReq, 
  606. CRMFCertRequest *certReq, CERTCertificate *newCert)
  607. {
  608.   SECStatus srv;
  609.   ErrorCode rv = NO_ERROR;
  610.   CRMFPOPOSigningKey *signKey   = NULL;
  611.   SECAlgorithmID     *algID     = NULL;
  612.   SECItem            *signature = NULL;
  613.   SECKEYPublicKey    *pubKey    = NULL;
  614.   SECItem            *reqDER    = NULL;
  616.   srv = CRMF_CertReqMsgGetPOPOSigningKey(currReq, &signKey);
  617.   if (srv != SECSuccess || signKey == NULL) {
  618.     rv = ERROR_RETRIEVING_POP_SIGN_KEY;
  619.     goto loser;
  620.   }
  621.   algID = CRMF_POPOSigningKeyGetAlgID(signKey);
  622.   if (algID == NULL) {
  623.     rv = ERROR_RETRIEVING_ALG_ID_FROM_SIGN_KEY;
  624.     goto loser;
  625.   }
  626.   signature = CRMF_POPOSigningKeyGetSignature(signKey);
  627.   if (signature == NULL) {
  628.     rv = ERROR_RETRIEVING_SIGNATURE_FROM_POP_SIGN_KEY;
  629.     goto loser;
  630.   }
  631.   /* Make the length the number of bytes instead of bits */
  632.   signature->len = (signature->len+7)/8;
  633.   pubKey = CERT_ExtractPublicKey(newCert);
  634.   if (pubKey == NULL) {
  635.     rv = ERROR_RETRIEVING_PUB_KEY_FROM_NEW_CERT;
  636.     goto loser;
  637.   }
  638.   reqDER = SEC_ASN1EncodeItem(NULL, NULL, certReq, CRMFCertRequestTemplate);
  639.   if (reqDER == NULL) {
  640.     rv = ERROR_ENCODING_CERT_REQ_FOR_POP;
  641.     goto loser;
  642.   }
  643.   srv = VFY_VerifyData(reqDER->data, reqDER->len, pubKey, signature,
  644.        SECOID_FindOIDTag(&algID->algorithm), varTable);
  645.   if (srv != SECSuccess) {
  646.     rv = ERROR_VERIFYING_SIGNATURE_POP;
  647.     goto loser;
  648.   }
  649.   /* Fall thru in successfull case. */
  650.  loser:
  651.   if (pubKey != NULL) {
  652.     SECKEY_DestroyPublicKey(pubKey);
  653.   }
  654.   if (reqDER != NULL) {
  655.     SECITEM_FreeItem(reqDER, PR_TRUE);
  656.   }
  657.   if (signature != NULL) {
  658.     SECITEM_FreeItem(signature, PR_TRUE);
  659.   }
  660.   if (algID != NULL) {
  661.     SECOID_DestroyAlgorithmID(algID, PR_TRUE);
  662.   }
  663.   if (signKey != NULL) {
  664.     CRMF_DestroyPOPOSigningKey(signKey);
  665.   }  
  666.   return rv;
  667. }
  669. ErrorCode
  670. doChallengeResponse(CGIVarTable *varTable, CRMFCertReqMsg *currReq, 
  671.     CRMFCertRequest *certReq, CERTCertificate *newCert,
  672.     ChallengeCreationInfo *challs, int *numChall)
  673. {
  674.   CRMFPOPOPrivKey *privKey = NULL;
  675.   CRMFPOPOPrivKeyChoice privKeyChoice;
  676.   SECStatus srv;
  677.   ErrorCode rv = NO_ERROR;
  678.  
  679.   srv = CRMF_CertReqMsgGetPOPKeyEncipherment(currReq, &privKey);
  680.   if (srv != SECSuccess || privKey == NULL) {
  681.     rv = ERROR_GETTING_KEY_ENCIPHERMENT;
  682.     goto loser;
  683.   } 
  684.   privKeyChoice = CRMF_POPOPrivKeyGetChoice(privKey);
  685.   CRMF_DestroyPOPOPrivKey(privKey);
  686.   switch (privKeyChoice) {
  687.   case crmfSubsequentMessage:
  688.     challs = &challs[*numChall];
  689.     challs->random = rand();
  690.     challs->pubKey = CERT_ExtractPublicKey(newCert);
  691.     if (challs->pubKey == NULL) {
  692.       rv = ERROR_RETRIEVING_PUB_KEY_FOR_CHALL;
  693.       goto loser;
  694.     }
  695.     (*numChall)++;
  696.     rv = DO_CHALLENGE_RESPONSE;
  697.     break;
  698.   case crmfThisMessage:
  699.     /* There'd better be a PKIArchiveControl in this message */
  700.     if (!CRMF_CertRequestIsControlPresent(certReq, 
  701.   crmfPKIArchiveOptionsControl)) {
  702.       rv = ERROR_NO_POP_FOR_PRIVKEY;
  703.       goto loser;
  704.     }
  705.     break;
  706.   default:
  707.     rv = ERROR_UNSUPPORTED_POPOPRIVKEY_TYPE;
  708.     goto loser;
  709.   }
  710. loser:
  711.   return rv;
  712. }
  714. ErrorCode
  715. doProofOfPossession(CGIVarTable *varTable, CRMFCertReqMsg *currReq, 
  716.     CRMFCertRequest *certReq, CERTCertificate *newCert,
  717.     ChallengeCreationInfo *challs, int *numChall)
  718. {
  719.   CRMFPOPChoice popChoice;
  720.   ErrorCode rv = NO_ERROR;
  722.   popChoice = CRMF_CertReqMsgGetPOPType(currReq);
  723.   if (popChoice == crmfNoPOPChoice) {
  724.     rv = NO_POP_FOR_REQUEST;
  725.     goto loser;
  726.   }
  727.   switch (popChoice) {
  728.   case crmfSignature:
  729.     rv = verifySignature(varTable, currReq, certReq, newCert);
  730.     break;
  731.   case crmfKeyEncipherment:
  732.     rv = doChallengeResponse(varTable, currReq, certReq, newCert,
  733.      challs, numChall);
  734.     break;
  735.   case crmfRAVerified:
  736.   case crmfKeyAgreement:
  737.   default:
  738.     rv = UNSUPPORTED_POP;
  739.     goto loser;
  740.   }
  741.  loser:
  742.   return rv;
  743. }
  745. void
  746. convertB64ToJS(char *base64)
  747. {
  748.   int i;
  750.   for (i=0; base64[i] != ''; i++) {
  751.     if (base64[i] == 'n') {
  752.       printf ("\n");
  753.     }else {
  754.       printf ("%c", base64[i]);
  755.     }
  756.   }
  757. }
  759. void
  760. formatChallenge(char *chall64, char *certRepContentDER,
  761.  ChallengeCreationInfo *challInfo, int numChalls)
  762. {
  763.   printf ("function respondToChallenge() {n"
  764.   "  var chalForm = document.chalForm;nn"
  765.   "  chalForm.CertRepContent.value = '");
  766.   convertB64ToJS(certRepContentDER);
  767.   printf ("';n"
  768.   "  chalForm.ChallResponse.value = crypto.popChallengeResponse('");
  769.   convertB64ToJS(chall64);
  770.   printf("');n"
  771.  "  chalForm.submit();n"
  772.  "}n");
  774. }
  776. void
  777. spitOutChallenge(char *chall64, char *certRepContentDER,
  778.  ChallengeCreationInfo *challInfo, int numChalls,
  779.  char *nickname)
  780. {
  781.   int i;
  783.   spitOutHeaders();
  784.   printf("<html>n"
  785.  "<head>n"
  786.  "<title>Challenge Page</title>n"
  787.  "<script language="JavaScript">n"
  788.  "<!--n");
  789.   /* The JavaScript function actually gets defined within
  790.    * this function call
  791.    */
  792.   formatChallenge(chall64, certRepContentDER, challInfo, numChalls);
  793.   printf("// -->n"
  794.  "</script>n"
  795.  "</head>n"
  796.  "<body onLoad='respondToChallenge()'>n"
  797.  "<h1>Cartman is now responding to the Challenge "
  798.  "presented by the CGI</h1>n"
  799.  "<form action='crmfcgi' method='post' name='chalForm'>n"
  800.  "<input type='hidden' name=CertRepContent value=''>n"
  801.  "<input type='hidden' name=ChallResponse value=''>n");
  802.   for (i=0;i<numChalls; i++) {
  803.     printf("<input type='hidden' name='chal%d' value='%d'>n",
  804.    i+1, challInfo[i].random);
  805.   }
  806.   printf("<input type='hidden' name='nickname' value='%s'>n", nickname);
  807.   printf("</form>n</body>n</html>");
  808. }
  810. ErrorCode
  811. issueChallenge(CertResponseInfo *issuedCerts, int numCerts, 
  812.        ChallengeCreationInfo *challInfo, int numChalls,
  813.        CERTCertificate *issuer, CGIVarTable *varTable)
  814. {
  815.   ErrorCode rv = NO_ERROR;
  816.   CMMFPOPODecKeyChallContent *chalContent = NULL;
  817.   int i;
  818.   SECStatus srv;
  819.   PRArenaPool *poolp;
  820.   CERTGeneralName *genName;
  821.   SECItem *challDER = NULL;
  822.   char *chall64, *certRepContentDER;
  824.   rv = createCMMFResponse(issuedCerts, numCerts, issuer, 
  825.   &certRepContentDER);
  826.   if (rv != NO_ERROR) {
  827.     goto loser;
  828.   }
  829.   chalContent = CMMF_CreatePOPODecKeyChallContent();
  830.   if (chalContent == NULL) {
  831.     rv = ERROR_CREATING_EMPTY_CHAL_CONTENT;
  832.     goto loser;
  833.   }
  834.   poolp = PORT_NewArena(1024);
  835.   if (poolp == NULL) {
  836.     rv = OUT_OF_MEMORY;
  837.     goto loser;
  838.   }
  839.   genName = CERT_GetCertificateNames(issuer, poolp);
  840.   if (genName == NULL) {
  841.     rv = ERROR_EXTRACTING_GEN_NAME_FROM_ISSUER;
  842.     goto loser;
  843.   }
  844.   for (i=0;i<numChalls;i++) {
  845.     srv = CMMF_POPODecKeyChallContentSetNextChallenge(chalContent,
  846.       challInfo[i].random,
  847.       genName,
  848.       challInfo[i].pubKey,
  849.       varTable);
  850.     SECKEY_DestroyPublicKey(challInfo[i].pubKey);
  851.     if (srv != SECSuccess) {
  852.       rv = ERROR_SETTING_CHALLENGE;
  853.       goto loser;
  854.     }
  855.   }
  856.   challDER = SEC_ASN1EncodeItem(NULL, NULL, chalContent, 
  857. CMMFPOPODecKeyChallContentTemplate);
  858.   if (challDER == NULL) {
  859.     rv = ERROR_ENCODING_CHALL;
  860.     goto loser;
  861.   }
  862.   chall64 = BTOA_DataToAscii(challDER->data, challDER->len);
  863.   SECITEM_FreeItem(challDER, PR_TRUE);
  864.   if (chall64 == NULL) {
  865.     rv = ERROR_CONVERTING_CHALL_TO_BASE64;
  866.     goto loser;
  867.   }
  868.   spitOutChallenge(chall64, certRepContentDER, challInfo, numChalls,
  869.    getNickname(issuedCerts[0].cert));
  870.  loser:
  871.   return rv;
  872. }
  875. ErrorCode
  876. processRequest(CGIVarTable *varTable)
  877. {
  878.   CERTCertDBHandle *certdb;
  879.   SECKEYKeyDBHandle *keydb;
  880.   CRMFCertReqMessages *certReqs = NULL;
  881.   const char *crmfReq;
  882.   const char *caNickname;
  883.   CERTCertificate *caCert = NULL;
  884.   CertResponseInfo *issuedCerts = NULL;
  885.   CERTSubjectPublicKeyInfo spki = { 0 };
  886.   ErrorCode rv=NO_ERROR;
  887.   PRBool doChallengeResponse = PR_FALSE;
  888.   SECItem der = { 0 };
  889.   SECStatus srv;
  890.   CERTCertificateRequest oldCertReq = { 0 };
  891.   CRMFCertReqMsg **reqMsgs = NULL,*currReq = NULL;
  892.   CRMFCertRequest **reqs = NULL, *certReq = NULL;
  893.   CERTName         subject = { 0 };
  894.   int numReqs,i;
  895.   ChallengeCreationInfo *challInfo=NULL;
  896.   int numChalls = 0;
  898.   certdb = CERT_GetDefaultCertDB();
  899.   keydb = SECKEY_GetDefaultKeyDB();
  900.   crmfReq = CGITableFindValue(varTable, "CRMFRequest");
  901.   if (crmfReq == NULL) {
  902.     rv = CGI_VAR_MISSING;
  903.     missingVar = "CRMFRequest";
  904.     goto loser;
  905.   }
  906.   caNickname = CGITableFindValue(varTable, "CANickname");
  907.   if (caNickname == NULL) {
  908.     rv = CGI_VAR_MISSING;
  909.     missingVar = "CANickname";
  910.     goto loser;
  911.   }
  912.   caCert = CERT_FindCertByNickname(certdb, caNickname);
  913.   if (caCert == NULL) {
  914.     rv = COULD_NOT_FIND_CA;
  915.     goto loser;
  916.   }
  917.   srv = ATOB_ConvertAsciiToItem(&der, crmfReq);
  918.   if (srv != SECSuccess) {
  919.     rv = BAD_ASCII_FOR_REQ;
  920.     goto loser;
  921.   }
  922.   certReqs = CRMF_CreateCertReqMessagesFromDER(der.data, der.len);
  923.   SECITEM_FreeItem(&der, PR_FALSE);
  924.   if (certReqs == NULL) {
  925.     rv = COULD_NOT_DECODE_REQS;
  926.     goto loser;
  927.   }
  928.   numReqs = CRMF_CertReqMessagesGetNumMessages(certReqs);
  929.   issuedCerts = PORT_ZNewArray(CertResponseInfo, numReqs);
  930.   challInfo   = PORT_ZNewArray(ChallengeCreationInfo, numReqs);
  931.   if (issuedCerts == NULL || challInfo == NULL) {
  932.     rv = OUT_OF_MEMORY;
  933.     goto loser;
  934.   }
  935.   reqMsgs = PORT_ZNewArray(CRMFCertReqMsg*,   numReqs);
  936.   reqs    = PORT_ZNewArray(CRMFCertRequest*, numReqs);
  937.   if (reqMsgs == NULL || reqs == NULL) {
  938.     rv =   OUT_OF_MEMORY;
  939.     goto loser;
  940.   }
  941.   for (i=0; i<numReqs; i++) {
  942.     currReq = reqMsgs[i] = 
  943.       CRMF_CertReqMessagesGetCertReqMsgAtIndex(certReqs, i);
  944.     if (currReq == NULL) {
  945.       rv = ERROR_RETRIEVING_REQUEST_MSG;
  946.       goto loser;
  947.     }
  948.     certReq = reqs[i] = CRMF_CertReqMsgGetCertRequest(currReq);
  949.     if (certReq == NULL) {
  950.       rv = ERROR_RETRIEVING_CERT_REQUEST;
  951.       goto loser;
  952.     }
  953.     srv = CRMF_CertRequestGetCertTemplateSubject(certReq, &subject);
  954.     if (srv != SECSuccess) {
  955.       rv = ERROR_RETRIEVING_SUBJECT_FROM_REQ;
  956.       goto loser;
  957.     }
  958.     srv = CRMF_CertRequestGetCertTemplatePublicKey(certReq, &spki);
  959.     if (srv != SECSuccess) {
  960.       rv = ERROR_RETRIEVING_PUBLIC_KEY_FROM_REQ;
  961.       goto loser;
  962.     }
  963.     rv = initOldCertReq(&oldCertReq, &subject, &spki);
  964.     if (rv != NO_ERROR) {
  965.       goto loser;
  966.     }
  967.     rv = createNewCert(&issuedCerts[i].cert, &oldCertReq, currReq, certReq, 
  968.        caCert, varTable);
  969.     if (rv != NO_ERROR) {
  970.       goto loser;
  971.     }
  972.     rv = doProofOfPossession(varTable, currReq, certReq, issuedCerts[i].cert,
  973.      challInfo, &numChalls);
  974.     if (rv != NO_ERROR) {
  975.       if (rv == DO_CHALLENGE_RESPONSE) {
  976. doChallengeResponse = PR_TRUE;
  977.       } else {
  978. goto loser;
  979.       }
  980.     }
  981.     CRMF_CertReqMsgGetID(currReq, &issuedCerts[i].certReqID);
  982.     CRMF_DestroyCertReqMsg(currReq);
  983.     CRMF_DestroyCertRequest(certReq);
  984.   }
  985.   if (doChallengeResponse) {
  986.     rv = issueChallenge(issuedCerts, numReqs, challInfo, numChalls, caCert,
  987. varTable);
  988.   } else {
  989.     rv = issueCerts(issuedCerts, numReqs, caCert);
  990.   }
  991.  loser:
  992.   if (certReqs != NULL) {
  993.     CRMF_DestroyCertReqMessages(certReqs);
  994.   }
  995.   return rv;
  996. }
  998. ErrorCode
  999. processChallengeResponse(CGIVarTable *varTable, const char *certRepContent)
  1000. {
  1001.   SECItem binDER = { 0 };
  1002.   SECStatus srv;
  1003.   ErrorCode rv = NO_ERROR;
  1004.   const char *clientResponse;
  1005.   const char *formChalValue;
  1006.   const char *nickname;
  1007.   CMMFPOPODecKeyRespContent *respContent = NULL;
  1008.   int numResponses,i;
  1009.   long curResponse, expectedResponse;
  1010.   char cgiChalVar[10];
  1011. #ifdef WRITE_OUT_RESPONSE
  1012.   SECItem certRepBinDER = { 0 };
  1014.   ATOB_ConvertAsciiToItem(&certRepBinDER, certRepContent);
  1015.   writeOutItem("challCertRepContent.der", &certRepBinDER);
  1016.   PORT_Free(certRepBinDER.data);
  1017. #endif  
  1018.   clientResponse = CGITableFindValue(varTable, "ChallResponse");
  1019.   if (clientResponse == NULL) {
  1020.     rv =   REQ_CGI_VAR_NOT_PRESENT;
  1021.     missingVar = "ChallResponse";
  1022.     goto loser;
  1023.   }
  1024.   srv = ATOB_ConvertAsciiToItem(&binDER, clientResponse);
  1025.   if (srv != SECSuccess) {
  1026.     rv = ERROR_CONVERTING_RESP_FROM_CHALL_TO_BIN;
  1027.     goto loser;
  1028.   }
  1029.   respContent = CMMF_CreatePOPODecKeyRespContentFromDER(binDER.data,
  1030. binDER.len);
  1031.   SECITEM_FreeItem(&binDER, PR_FALSE);
  1032.   binDER.data = NULL;
  1033.   if (respContent == NULL) {
  1034.     rv = ERROR_CREATING_KEY_RESP_FROM_DER;
  1035.     goto loser;
  1036.   }
  1037.   numResponses = CMMF_POPODecKeyRespContentGetNumResponses(respContent);
  1038.   for (i=0;i<numResponses;i++){
  1039.     srv = CMMF_POPODecKeyRespContentGetResponse(respContent,i,&curResponse);
  1040.     if (srv != SECSuccess) {
  1041.       rv = ERROR_RETRIEVING_CLIENT_RESPONSE_TO_CHALLENGE;
  1042.       goto loser;
  1043.     }
  1044.     sprintf(cgiChalVar, "chal%d", i+1);
  1045.     formChalValue = CGITableFindValue(varTable, cgiChalVar);
  1046.     if (formChalValue == NULL) {
  1047.       rv = REQ_CGI_VAR_NOT_PRESENT;
  1048.       missingVar = strdup(cgiChalVar);
  1049.       goto loser;
  1050.     }
  1051.     sscanf(formChalValue, "%ld", &expectedResponse);
  1052.     if (expectedResponse != curResponse) {
  1053.       rv = ERROR_RETURNED_CHALL_NOT_VALUE_EXPECTED;
  1054.       goto loser;
  1055.     }
  1056.   }
  1057.   nickname = CGITableFindValue(varTable, "nickname");
  1058.   if (nickname == NULL) {
  1059.     rv = REQ_CGI_VAR_NOT_PRESENT;
  1060.     missingVar = "nickname";
  1061.     goto loser;
  1062.   }
  1063.   spitOutCMMFResponse(nickname, certRepContent);
  1064.  loser:
  1065.   if (respContent != NULL) {
  1066.     CMMF_DestroyPOPODecKeyRespContent(respContent);
  1067.   }
  1068.   return rv;
  1069. }
  1071. int
  1072. main()
  1073. {
  1074.   char *form_output = NULL;
  1075.   int   form_output_len, form_output_used;
  1076.   CGIVarTable varTable = { 0 };
  1077.   ErrorCode errNum = 0;
  1078.   char *certRepContent;
  1080. #ifdef ATTACH_CGI
  1081.   /* Put an ifinite loop in here so I can attach to 
  1082.    * the process after the process is spun off
  1083.    */
  1084.   { int stupid = 1;
  1085.     while (stupid);
  1086.   }
  1087. #endif
  1089.   form_output_used = 0;
  1090.   srand(time(NULL));
  1091.   while (feof(stdin) == 0) {
  1092.     if (form_output == NULL) {
  1093.       form_output = PORT_NewArray(char, DEFAULT_ALLOC_SIZE+1);
  1094.       form_output_len  = DEFAULT_ALLOC_SIZE;
  1095.     } else if ((form_output_used + DEFAULT_ALLOC_SIZE) >= form_output_len) {
  1096.       form_output_len += DEFAULT_ALLOC_SIZE;
  1097.       form_output = PORT_Realloc(form_output, form_output_len+1);
  1098.     }
  1099.     form_output_used += fread(&form_output[form_output_used], sizeof(char), 
  1100.       DEFAULT_ALLOC_SIZE, stdin);
  1101.   }
  1102.   ParseInputVariables(&varTable, form_output);
  1103.   certRepContent = CGITableFindValue(&varTable, "CertRepContent");
  1104.   if (certRepContent == NULL) {
  1105.     errNum = initNSS(&varTable);
  1106.     if (errNum != 0) {
  1107.       goto loser;
  1108.     }
  1109.     errNum = processRequest(&varTable);
  1110.   } else {
  1111.     errNum = processChallengeResponse(&varTable, certRepContent);
  1112.   }
  1113.   if (errNum != NO_ERROR) {
  1114.     goto loser;
  1115.   }
  1116.   goto done;
  1117. loser:
  1118.   dumpErrorMessage(errNum);
  1119. done:
  1120.   free (form_output);
  1121.   return 0;
  1122. }