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

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

CA认证

开发平台：

WINDOWS

advisor.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. #ifdef XP_MAC
  35. #include "platform.h"
  36. #endif
  37. #include "advisor.h"
  38. #include "nlsutil.h"
  39. #include "minihttp.h"
  40. #include "p12res.h"
  41. #include "textgen.h"
  42. #include "sslskst.h"
  43. #include "certlist.h"
  44. #include "ocsp.h"
  45. #include "secoid.h"
  46. #include "prefs.h"
  47. #include "messages.h"
  48. #include "secerr.h"
  49. #include "sslerr.h"
  50. #include "base64.h"
  52. /*
  53.  * This is the structure used to gather all of the CA's that can be used
  54.  * for OCSP responders.
  55.  */
  56. typedef struct SSMDefaultOCSPRespondersListStr{
  57.     SSMSortedList *respondersWithAIA;
  58.     SSMSortedList *respondersWithoutAIA;
  59.     SSMTextGenContext *cx;
  60.     char *wrapper, *defaultSigner;
  61. } SSMDefaultOCSPRespondersList;
  63. SSMStatus SSM_SetSelectedItemInfo(SSMSecurityAdvisorContext* cx);
  65. #define SSMRESOURCE(object) (&object->super)
  67. #define SSM_NO_INFO "sa_no_info"
  68. #define SSM_NAVIGATOR_NO_SEC            "sa_navigator_no_sec"
  69. #define SSM_NAVIGATOR_SSL               "sa_navigator_ssl"
  70. #define SSM_NAVIGATOR_BAD_SSL "sa_navigator_bad_ssl"
  71. #define SSM_MESSAGE "sa_message"
  72. #define SSM_MESSAGE_NOT_SIGNED "sa_message_not_signed"
  73. #define SSM_MESSAGE_NOT_ENCRYPTED "sa_message_not_encrypted"
  74. #define SSM_MESSAGE_SIGNED "sa_message_signed"
  75. #define SSM_MESSAGE_ENCRYPTED "sa_message_encrypted"
  76. #define SSM_MESSAGE_BAD_SIGNED "sa_message_bad_signed"
  77. #define SSM_MESSAGE_BAD_ENCRYPTED "sa_message_bad_encrypted"
  79. /* A list of User agent strings that we know can do S/MIME
  80.  * and want the Java tab as well.
  81.  */
  83. #define COMMON_TO_SMIME_AND_JAVA "Mozilla/4.7"
  85. const char *kSMimeApps[]  = {COMMON_TO_SMIME_AND_JAVA, NULL};
  86. const char *kJavaJSApps[] = {COMMON_TO_SMIME_AND_JAVA, NULL};
  88. char * SSM_ConvertStringToHTMLString(char * string);
  89. char * SSMUI_GetPKCS12Error(PRIntn error, PRBool isBackup);
  91. PRBool
  92. SSM_IsCRLPresent(SSMControlConnection *ctrl)
  93. {
  94.     SECStatus rv = SECFailure;
  95.     CERTCrlHeadNode *head = NULL;
  96.     PRBool retVal = PR_FALSE;
  97.     
  98.     rv = SEC_LookupCrls(ctrl->m_certdb, &head, -1);
  99.     if (rv != SECSuccess) {
  100.         goto done;
  101.     }
  102.     if (head == NULL) {
  103.         goto done;
  104.     }
  105.     retVal = (head->first == NULL) ? PR_FALSE : PR_TRUE;
  106.     PORT_FreeArena(head->arena, PR_FALSE);
  107.  done:
  108.     return retVal;
  109. }
  111. SSMStatus 
  112. SSMSecurityAdvisorContext_Create(SSMControlConnection *ctrl, 
  113.                                  InfoSecAdvisor *info, 
  114.                                  SSMResource **res)
  115. {
  116.     SSMStatus rv = PR_SUCCESS;
  117.     SSMSecurityAdvisorContext *ct;
  118. int i;
  120.     *res = NULL; /* in case we fail */
  121.     
  122.     ct = (SSMSecurityAdvisorContext *) 
  123.         PR_CALLOC(sizeof(SSMSecurityAdvisorContext));
  124.     if (!ct) 
  125.         goto loser;
  127.     rv = SSMResource_Init(ctrl, &ct->super, SSM_RESTYPE_SECADVISOR_CONTEXT);
  128.     if (rv != PR_SUCCESS) 
  129.         goto loser;
  130.     
  131.     /* this hash will contail list of formatted certs nickname to display */
  132.     ct->m_certhash = NULL;
  133.     ct->m_certsIncluded = 0;
  134.     
  135.     /* register us with ControlConection */
  136.     if (!ctrl->m_secAdvisorList) {
  137.         ctrl->m_secAdvisorList = (SECItem *) PR_Malloc(sizeof(SECItem));
  138.         ctrl->m_secAdvisorList->len = 0;
  139.         ctrl->m_secAdvisorList->data = NULL;
  140.     } 
  141.     ctrl->m_secAdvisorList->len++;
  142.     ctrl->m_secAdvisorList->data = (unsigned char *) PR_REALLOC(ctrl->m_secAdvisorList->data, 
  143.                                                ctrl->m_secAdvisorList->len);
  144.     ctrl->m_secAdvisorList->data[ ctrl->m_secAdvisorList->len - 1 ] = 
  145.         ((SSMResource *)ct)->m_id;
  147.     if (info) {
  148.         ct->infoContext = info->infoContext;
  149.         ct->resID = info->resID;
  150.         ct->hostname = info->hostname ? PL_strdup(info->hostname) : NULL;
  151. ct->senderAddr = info->senderAddr ? PL_strdup(info->senderAddr) : NULL;
  152. ct->encryptedP7CInfo = info->encryptedP7CInfo;
  153. ct->signedP7CInfo = info->signedP7CInfo;
  154. ct->decodeError = info->decodeError;
  155. ct->verifyError = info->verifyError;
  156. ct->encryptthis = info->encryptthis;
  157. ct->signthis = info->signthis;
  158. ct->numRecipients = info->numRecipients;
  159.     if (info->numRecipients > 0) {
  160. ct->recipients = (char **) PR_CALLOC(sizeof(char*)*(info->numRecipients));
  161. if (!ct->recipients) {
  162. goto loser;
  163. }
  164.         for (i=0;i<info->numRecipients;i++) {
  165.         ct->recipients[i] = PL_strdup(info->recipients[i]);
  166. }
  167. }
  169.         SSM_SetSelectedItemInfo(ct);
  170.     }
  172.     /* Create a URL for the security advisor window. */
  173.     rv = (SSMStatus) SSM_GenerateURL(ctrl, "get", "secadvisor", 
  174.                          &ct->super, NULL, 
  175.                          &ct->m_width, &ct->m_height, 
  176.                          &ct->m_url);
  177.     if (rv != SSM_SUCCESS)
  178.         goto loser;
  180.     SSMSecurityAdvisorContext_Invariant(ct);
  182.     *res = &ct->super;
  183.     return PR_SUCCESS;
  185.  loser:
  186.     if (rv == PR_SUCCESS) rv = PR_FAILURE;
  188.     if (ct) 
  189.     {
  190.         ct->super.m_refCount = 1; /* force destroy */
  191.         SSM_FreeResource(&ct->super);
  192.     }
  193.         
  194.     return rv;
  195. }
  197. char * SSMUI_GetPKCS12Error(PRIntn error, PRBool isBackup)
  198. {
  199.     char * responseKey;
  200.     
  201.     switch (error) { 
  202.     case SSM_ERR_NO_PASSWORD:
  203.         responseKey = "pkcs12_bad_portable_password_restore";
  204.         break;
  205.     case SSM_ERR_BAD_DB_PASSWORD:
  206.         responseKey = "pkcs12_bad_db_password";
  207.         break;
  208.     case SSM_ERR_BAD_FILENAME:
  209.         responseKey = "pkcs12_bad_filepath";
  210.         break;
  211.     case SSM_ERR_NEED_USER_INIT_DB:
  212.         responseKey = "pkcs12_need_db_init";
  213.         break;
  214.     case SSM_ERR_CANNOT_DECODE:
  215.         responseKey="pkcs12_cannot_decode";
  216.         break;
  217.     case SSM_PKCS12_CERT_ALREADY_EXISTS:
  218.         responseKey="pkcs12_cert_already_exists";
  219.         break;
  220.     case SSM_ERR_BAD_REQUEST:
  221.     default:
  222.         responseKey = (isBackup) ? "pkcs12_backup_failure" : 
  223.                                    "pkcs12_restore_failure";
  224.     }
  226.     return responseKey;
  227. }
  229. SSMStatus 
  230. SSMSecurityAdvisorContext_Destroy(SSMResource *res, PRBool doFree)
  231. {
  232.     SSMSecurityAdvisorContext *ct = (SSMSecurityAdvisorContext *) res;
  233.     PRIntn i = 0, others = 0;
  234.     if (ct)
  235.     {
  236.         PR_ASSERT(SSM_IsAKindOf(res, SSM_RESTYPE_SECADVISOR_CONTEXT));
  237.         SSMResource_Destroy(res, PR_FALSE);
  238.         
  239.         /* Dereference the security info object */
  240.         if (ct->m_infoSource)
  241.         {
  242.             SSM_FreeResource(ct->m_infoSource);
  243.             ct->m_infoSource = NULL;
  244.         }
  246.         /* Free the URL */
  247.         PR_FREEIF(ct->m_url);
  249.         if (ct->m_certhash)
  250.             SSMSortedList_Destroy(ct->m_certhash);
  251.         
  252.         /* deregister with control connection */
  253.         while (i < res->m_connection->m_secAdvisorList->len) {
  254.             if (res->m_connection->m_secAdvisorList->data[i] == res->m_id)
  255.                 res->m_connection->m_secAdvisorList->data[i] = 0;
  256.             if (res->m_connection->m_secAdvisorList->data[i])
  257.                 others ++;
  258.             i++;
  259.         }
  260.         if (!others) {
  261.             SECITEM_ZfreeItem(res->m_connection->m_secAdvisorList, PR_TRUE);
  262.             res->m_connection->m_secAdvisorList = NULL;
  263.         }
  265.         if (ct->socketStatus) {
  266.             SSM_FreeResource(&ct->socketStatus->super);
  267.         }
  268.         PR_FREEIF(ct->hostname);
  269.         PR_FREEIF(ct->senderAddr);
  270.         if (ct->recipients) {
  271.             for (i=0; i<ct->numRecipients; i++) {
  272.                 PR_FREEIF(ct->recipients[i]);
  273.             }
  274.             PR_FREEIF(ct->recipients);
  275.         }
  276.         /* Free if asked */
  277.         if (doFree)
  278.             PR_Free(ct);
  279.     }
  280.     return PR_SUCCESS; /* no way to fail, really */
  281. }
  283. void 
  284. SSMSecurityAdvisorContext_Invariant(SSMSecurityAdvisorContext *ct)
  285. {
  286.     /* Check superclass. */
  287.     SSMResource_Invariant(&ct->super);
  289.     /* Make sure we always have a URL. */
  290.     PR_ASSERT(ct->m_url != NULL);
  291. }
  294. SSMStatus 
  295. SSMSecurityAdvisorContext_GetAttrIDs(SSMResource *res,
  296.                                      SSMAttributeID **ids,
  297.                                      PRIntn *count)
  298. {
  299.     SSMStatus rv;
  301.     rv = SSMResource_GetAttrIDs(res, ids, count);
  302.     if (rv != PR_SUCCESS)
  303.         goto loser;
  305.     *ids = (SSMAttributeID *) PR_REALLOC(*ids, (*count + 4) * sizeof(SSMAttributeID));
  306.     if (! *ids) goto loser;
  308.     (*ids)[*count++] = SSM_FID_SECADVISOR_URL;
  309.     (*ids)[*count++] = SSM_FID_SECADVISOR_WIDTH;
  310.     (*ids)[*count++] = SSM_FID_SECADVISOR_HEIGHT;
  311.     (*ids)[*count++] = SSM_FID_CLIENT_CONTEXT;
  313.     goto done;
  314.  loser:
  315.     if (rv == PR_SUCCESS) rv = PR_FAILURE;
  316.  done:
  317.     return rv;
  318. }
  320. SSMStatus 
  321. SSMSecurityAdvisorContext_GetAttr(SSMResource *res,
  322.                                   SSMAttributeID attrID,
  323.                                   SSMResourceAttrType attrType,
  324.                                   SSMAttributeValue *value)
  325. {
  326.     SSMStatus rv = PR_SUCCESS;
  327.     SSMSecurityAdvisorContext *ct = (SSMSecurityAdvisorContext *) res;
  329.     SSMSecurityAdvisorContext_Invariant(ct);
  331.     switch(attrID)
  332.     {
  333.     case SSM_FID_SECADVISOR_URL:
  334.         /* Duplicate and return the string. */
  335.         value->type = SSM_STRING_ATTRIBUTE;
  336.         value->u.string.len = PL_strlen(ct->m_url);
  337.         value->u.string.data = (unsigned char *) PL_strdup(ct->m_url);
  338.         break;
  339.     case SSM_FID_SECADVISOR_WIDTH:
  340.     case SSM_FID_SECADVISOR_HEIGHT:
  341.         value->type = SSM_NUMERIC_ATTRIBUTE;
  342.         value->u.numeric = (attrID == SSM_FID_SECADVISOR_WIDTH) ?
  343.             ct->m_width : ct->m_height;
  344.         break;
  345.     case SSM_FID_CLIENT_CONTEXT:
  346.       SSM_DEBUG("Getting security advisor client context");
  347.       value->type = SSM_STRING_ATTRIBUTE;
  348.       if (!(value->u.string.data = (unsigned char *) PR_Malloc(res->m_clientContext.len))) {
  349.           goto loser;
  350.       }
  351.       memcpy(value->u.string.data, res->m_clientContext.data, res->m_clientContext.len);
  352.       value->u.string.len = res->m_clientContext.len;
  353.       break;
  355.     default:
  356.         rv = SSMResource_GetAttr(res,attrID,attrType,value);
  357.         if (rv != PR_SUCCESS)
  358.             goto loser;
  359.     }
  361.     goto done;
  362.  loser:
  363.     value->type = SSM_NO_ATTRIBUTE;
  364.     if (rv == PR_SUCCESS)
  365.         rv = PR_FAILURE;
  366.  done:
  367.     return rv;
  368. }
  370. SSMStatus SSMSecurityAdvisorContext_SetAttr(SSMResource *res,
  371.                                   SSMAttributeID attrID,
  372.                                   SSMAttributeValue *value)
  373. {
  374.     switch(attrID) {
  375.     case SSM_FID_CLIENT_CONTEXT:
  376.       SSM_DEBUG("Setting security advisor client contextn");
  377.       if (value->type != SSM_STRING_ATTRIBUTE) {
  378.           goto loser;
  379.       }
  380.       if (!(res->m_clientContext.data = (unsigned char *) PR_Malloc(value->u.string.len))) {
  381.           goto loser;
  382.       }
  383.       memcpy(res->m_clientContext.data, value->u.string.data, value->u.string.len);
  384.       res->m_clientContext.len = value->u.string.len;
  385.       break;
  386.     default:
  387.       SSM_DEBUG("Got unknown security advisor Set Attribute Request %dn", attrID);
  388.       goto loser;
  389.       break;
  390.     }
  391.     return PR_SUCCESS;
  392. loser:
  393.     return PR_FAILURE;
  394. }
  397. /* Preference keys used in Security Advisor JavaScript.
  398.  * They are used to cache temporary changes the user has made.
  399.  */
  400. #define SSL2_SPK "enable_ssl2"
  401. #define SSL3_SPK "enable_ssl3"
  402. #define CLIENT_AUTH_SPK "client_auth_auto_select"
  403. #define EMAIL_CERT_SPK "default_email_cert"
  404. #define WARN_ENTER_SECURE_SPK "warn_entering_secure"
  405. #define WARN_LEAVE_SECURE_SPK "warn_leaving_secure"
  406. #define WARN_VIEW_MIXED_SPK "warn_viewing_mixed"
  407. #define WARN_SUBMIT_INSECURE_SPK "warn_submit_insecure"
  408. #define ENCRYPT_MAIL_SPK "mail_encrypt_outgoing_mail"
  409. #define SIGN_MAIL_SPK "mail_crypto_sign_outgoing_mail"
  410. #define SIGN_NEWS_SPK "mail_crypto_sign_outgoing_news"
  412. /* maximum number of pref items that will be sent back to the client */
  413. #define ITEMS_MAX 11
  416. static SSMStatus SSMSecurityAdvisor_get_bool_value(HTTPRequest* req,
  417.                                                    char* key, PRBool* value)
  418. {
  419.     SSMStatus rv;
  420.     char* tmpStr = NULL;
  422.     rv = SSM_HTTPParamValue(req, key, &tmpStr);
  423.     if (rv != SSM_SUCCESS) {
  424.         return rv;
  425.     }
  427.     if (PL_strcmp(tmpStr, "true") == 0) {
  428.         *value = PR_TRUE;
  429.     }
  430.     else if (PL_strcmp(tmpStr, "false") == 0) {
  431.         *value = PR_FALSE;
  432.     }
  433.     else {
  434.         SSM_DEBUG("I don't understand the value.n");
  435.         return SSM_FAILURE;
  436.     }
  437.     return rv;
  438. }
  440. static SSMStatus ssm_set_pack_bool_pref(PrefSet* prefs, char* key, 
  441.                                         PRBool value, SetPrefElement* list,
  442.                                         PRIntn* n)
  443. {
  444.     SSMStatus rv;
  446.     /* set the change to memory */
  447.     rv = PREF_SetBoolPref(prefs, key, value);
  448.     if (rv != PR_SUCCESS) {
  449.         return rv;
  450.     }
  452.     /* pack the change */
  453.     list[*n].key = PL_strdup(key);
  454.     list[*n].type = BOOL_PREF;
  455.     if (value == PR_TRUE) {
  456.         list[*n].value = PL_strdup("true");
  457.     }
  458.     else {
  459.         list[*n].value = PL_strdup("false");
  460.     }
  461.     (*n)++;
  463.     return rv;
  464. }
  466. static SSMStatus
  467. SSMSecurityAdvisorContext_SavePrefs(SSMSecurityAdvisorContext* cx,
  468.                                     HTTPRequest* req)
  469. {
  470.     SSMStatus rv;
  471.     SSMControlConnection* ctrl = NULL;
  472.     PrefSet* prefs = NULL;
  473.     PRBool ssl2on;
  474.     PRBool ssl3on;
  475.     PRBool autoSelect;
  476.     PRBool warnEnterSecure;
  477.     PRBool warnLeaveSecure;
  478.     PRBool warnViewMixed;
  479.     PRBool warnSubmitInsecure;
  480.     PRBool encryptMail;
  481.     PRBool signMail;
  482.     PRBool signNews;
  483.     char* autoStr = NULL;
  484.     char* defaultCert = NULL;
  485.     SetPrefElement list[ITEMS_MAX];
  486.     SetPrefListMessage request;
  487.     PRIntn n = 0;    /* counter */
  488.     int i;
  489.     CMTItem message;
  491.     PR_ASSERT(cx != NULL && cx->super.m_connection != NULL &&
  492.               cx->super.m_connection->m_prefs != NULL);
  493.     ctrl = cx->super.m_connection;
  494.     prefs = ctrl->m_prefs;
  496.     /* retrieve pref values */
  497.     rv = SSMSecurityAdvisor_get_bool_value(req, SSL2_SPK, &ssl2on);
  498.     if (rv != SSM_SUCCESS) {
  499.         goto loser;
  500.     }
  502.     rv = SSMSecurityAdvisor_get_bool_value(req, SSL3_SPK, &ssl3on);
  503.     if (rv != SSM_SUCCESS) {
  504.         goto loser;
  505.     }
  507.     rv = SSMSecurityAdvisor_get_bool_value(req, CLIENT_AUTH_SPK, &autoSelect);
  508.     if (rv != SSM_SUCCESS) {
  509.         goto loser;
  510.     }
  511.     if (autoSelect == PR_TRUE) {
  512.         autoStr = "Select Automatically";
  513.     }
  514.     else {
  515.         autoStr = "Ask Every Time";
  516.     }
  518.     rv = SSM_HTTPParamValue(req, EMAIL_CERT_SPK, &defaultCert);
  519.     if (defaultCert[0] == '') {
  520.         defaultCert = NULL;
  521.         rv = SSM_SUCCESS;
  522.     }
  523.     if (rv != SSM_SUCCESS) {
  524.         goto loser;
  525.     }
  527.     rv = SSMSecurityAdvisor_get_bool_value(req, WARN_ENTER_SECURE_SPK,
  528.                                            &warnEnterSecure);
  529.     if (rv != SSM_SUCCESS) {
  530.         goto loser;
  531.     }
  533.     rv = SSMSecurityAdvisor_get_bool_value(req, WARN_LEAVE_SECURE_SPK,
  534.                                            &warnLeaveSecure);
  535.     if (rv != SSM_SUCCESS) {
  536.         goto loser;
  537.     }
  539.     rv = SSMSecurityAdvisor_get_bool_value(req, WARN_VIEW_MIXED_SPK,
  540.                                            &warnViewMixed);
  541.     if (rv != SSM_SUCCESS) {
  542.         goto loser;
  543.     }
  545.     rv = SSMSecurityAdvisor_get_bool_value(req, WARN_SUBMIT_INSECURE_SPK,
  546.                                            &warnSubmitInsecure);
  547.     if (rv != SSM_SUCCESS) {
  548.         goto loser;
  549.     }
  551.     rv = SSMSecurityAdvisor_get_bool_value(req, ENCRYPT_MAIL_SPK, 
  552.                                            &encryptMail);
  553.     if (rv != SSM_SUCCESS) {
  554.         goto loser;
  555.     }
  557.     rv = SSMSecurityAdvisor_get_bool_value(req, SIGN_MAIL_SPK, &signMail);
  558.     if (rv != SSM_SUCCESS) {
  559.         goto loser;
  560.     }
  562.     rv = SSMSecurityAdvisor_get_bool_value(req, SIGN_NEWS_SPK, &signNews);
  563.     if (rv != SSM_SUCCESS) {
  564.         goto loser;
  565.     }
  567.     /* commit the changes */
  568.     if (PREF_BoolPrefChanged(prefs, "security.enable_ssl2", ssl2on)) {
  569.         /* value has changed */
  570.         rv = ssm_set_pack_bool_pref(prefs, "security.enable_ssl2", ssl2on,
  571.                                     (SetPrefElement*)list, &n);
  572.         SSL_EnableDefault(SSL_ENABLE_SSL2, ssl2on);
  573.     }
  575.     if (PREF_BoolPrefChanged(prefs, "security.enable_ssl3", ssl3on)) {
  576.         rv = ssm_set_pack_bool_pref(prefs, "security.enable_ssl3", ssl3on,
  577.                                     (SetPrefElement*)list, &n);
  578.         SSL_EnableDefault(SSL_ENABLE_SSL3, ssl3on);
  579.     }
  581.     if (PREF_StringPrefChanged(prefs, "security.default_personal_cert", 
  582.                                autoStr)) {
  583.         rv = PREF_SetStringPref(prefs, "security.default_personal_cert", 
  584.                                 autoStr);
  585.         
  586.         list[n].key = PL_strdup("security.default_personal_cert");
  587.         list[n].type = STRING_PREF;
  588.         list[n].value = PL_strdup(autoStr);
  589.         n++;
  590.     }
  591.     
  592.     if (PREF_StringPrefChanged(prefs, "security.default_mail_cert",
  593.                                defaultCert)) {
  594.         rv = PREF_SetStringPref(prefs, "security.default_mail_cert", 
  595.                                 defaultCert);
  597.         list[n].key = PL_strdup("security.default_mail_cert");
  598.         list[n].type = STRING_PREF;
  599.         list[n].value = PL_strdup(defaultCert);
  600.         n++;
  601.     }
  603.     if (PREF_BoolPrefChanged(prefs, "security.warn_entering_secure", 
  604.                              warnEnterSecure)) {
  605.         rv = ssm_set_pack_bool_pref(prefs, "security.warn_entering_secure",
  606.                                     warnEnterSecure, (SetPrefElement*)list,
  607.                                     &n);
  608.     }
  610.     if (PREF_BoolPrefChanged(prefs, "security.warn_leaving_secure", 
  611.                              warnLeaveSecure)) {
  612.         rv = ssm_set_pack_bool_pref(prefs, "security.warn_leaving_secure",
  613.                                     warnLeaveSecure, (SetPrefElement*)list,
  614.                                     &n);
  615.     }
  617.     if (PREF_BoolPrefChanged(prefs, "security.warn_viewing_mixed", 
  618.                              warnViewMixed)) {
  619.         rv = ssm_set_pack_bool_pref(prefs, "security.warn_viewing_mixed",
  620.                                     warnViewMixed, (SetPrefElement*)list, &n);
  621.     }
  623.     if (PREF_BoolPrefChanged(prefs, "security.warn_submit_insecure", 
  624.                              warnSubmitInsecure)) {
  625.         rv = ssm_set_pack_bool_pref(prefs, "security.warn_submit_insecure",
  626.                                     warnSubmitInsecure, (SetPrefElement*)list,
  627.                                     &n);
  628.     }
  630.     if (PREF_BoolPrefChanged(prefs, "mail.encrypt_outgoing_mail", 
  631.                              encryptMail)) {
  632.         rv = ssm_set_pack_bool_pref(prefs, "mail.encrypt_outgoing_mail",
  633.                                     encryptMail, (SetPrefElement*)list, &n);
  634.     }
  636.     if (PREF_BoolPrefChanged(prefs, "mail.crypto_sign_outgoing_mail", 
  637.                              signMail)) {
  638.         rv = ssm_set_pack_bool_pref(prefs, "mail.crypto_sign_outgoing_mail",
  639.                                     signMail, (SetPrefElement*)list, &n);
  640.     }
  642.     if (PREF_BoolPrefChanged(prefs, "mail.crypto_sign_outgoing_news", 
  643.                              signNews)) {
  644.         rv = ssm_set_pack_bool_pref(prefs, "mail.crypto_sign_outgoing_news",
  645.                                     signNews, (SetPrefElement*)list, &n);
  646.     }
  648.     rv = SSM_HTTPDefaultCommandHandler(req);
  649.     if (rv != PR_SUCCESS) {
  650.         goto loser;
  651.     }
  653.     /* finally, send the changes to the plugin so that it can save the
  654.      * changes
  655.      */
  656.     if (n > 0) {
  657.         /* we need to send this event only if prefs changed */
  658.         request.length = n;
  659.         request.list = list;
  660.         message.type = SSM_EVENT_MESSAGE | SSM_SAVE_PREF_EVENT;
  661.         if (CMT_EncodeMessage(SetPrefListMessageTemplate, &message, 
  662.                               &request) != CMTSuccess) {
  663.             goto loser;
  664.         }
  666.         /* send the message through the control out queue */
  667.         SSM_SendQMessage(ctrl->m_controlOutQ, SSM_PRIORITY_NORMAL, 
  668.                          message.type, message.len, (char*)message.data,
  669.                          PR_TRUE);
  670.     }
  671. loser:
  672.     /* clean out list */
  673.     for (i = 0; i < n; i++) {
  674.         if (list[i].key != NULL) {
  675.             PR_Free(list[i].key);
  676.         }
  677.         if (list[i].value != NULL) {
  678.             PR_Free(list[i].value);
  679.         }
  680.     }
  681.     return rv;
  682. }
  684. SSMStatus
  685. SSMSecurityAdvisorContext_DoPKCS12Response(SSMSecurityAdvisorContext *advisor,
  686.                                            HTTPRequest *req,
  687.                                            const char  *responseKey)
  688. {
  689.     SSMTextGenContext *cx = NULL;
  690.     SSMStatus rv = SSM_FAILURE;
  691.     char name[256];
  692.     char *page = "pkcs12_action_followup";
  693.     char *type = NULL, *hdrs = NULL, *content = NULL;
  694.     char *alertMessage = NULL, *out = NULL;
  696.     rv = SSMTextGen_NewTopLevelContext(req, &cx);
  697.     if (rv != SSM_SUCCESS) {
  698.         SSM_HTTPReportSpecificError(req, "DoPKCS12Response: Error%d "
  699.                                     "attempting to create textgen context.",
  700.                                     rv);
  701.         goto loser;
  702.     }
  703.     PR_snprintf(name, 256, "%s_type", page);
  704.     rv = SSM_GetUTF8Text(cx, name, &type);
  705.     if (rv != SSM_SUCCESS) {
  706.         goto loser;
  707.     }
  708.     PR_snprintf(name, 256, "%s_content", page);
  709.     rv = SSM_GetAndExpandText(cx, name, &content);
  710.     if (rv != SSM_SUCCESS) {
  711.         goto loser;
  712.     }
  713.     rv = SSM_GetUTF8Text(cx, responseKey, &alertMessage);
  714.     if (rv != SSM_SUCCESS) {
  715.         goto loser;
  716.     }
  717.     out = PR_smprintf(content, alertMessage, advisor->super.m_id);
  718.     rv = SSM_HTTPSendOKHeader(req, hdrs, type);
  719.     if (rv != SSM_SUCCESS) {
  720.         goto loser;
  721.     }
  722.     rv = SSM_HTTPSendUTF8String(req, out);
  723.     if (rv != SSM_SUCCESS) {
  724.         goto loser;
  725.     }
  726.     req->sentResponse = PR_TRUE;
  727.     goto done;
  728.  loser:
  729.     if (rv == SSM_SUCCESS) rv = SSM_FAILURE;
  730.  done:
  731.     if (cx != NULL) {
  732.         SSMTextGen_DestroyContext(cx);
  733.     }
  734.     PR_FREEIF(type);
  735.     PR_FREEIF(hdrs);
  736.     PR_FREEIF(content);
  737.     PR_FREEIF(out);
  738.     PR_FREEIF(alertMessage);
  739.     return rv;
  740. }
  742. static SSMStatus
  743. SSMSecurityAdvisorContext_DoNewDefMailReponse(SSMPKCS12Context *p12Cxt,
  744.                                               HTTPRequest      *req)
  745. {
  746.     SSMTextGenContext *cx = NULL;
  747.     char *fmt=NULL, *content=NULL, *defEmailCert=NULL, *expContent=NULL;
  748.     SSMStatus rv;
  750.     rv = SSMTextGen_NewTopLevelContext(req, &cx);
  751.     if (rv != SSM_SUCCESS) {
  752.         SSM_HTTPReportSpecificError(req, "DoNewDefMailReponse: Failed to "
  753.                                          "create new TextGenContext.");
  754.         goto loser;
  755.     }
  756.     rv = SSM_FindUTF8StringInBundles(cx, "pkcs12_restore_success_new_mail", 
  757.                                      &fmt);
  758.     if (rv != SSM_SUCCESS || fmt == NULL) {
  759.         goto loser;
  760.     }
  761.     
  762.     rv = PREF_GetStringPref(req->ctrlconn->m_prefs, 
  763.                             "security.default_mail_cert", &defEmailCert);
  764.     if (rv != SSM_SUCCESS || defEmailCert == NULL) {
  765.         goto loser;
  766.     }
  767.     content = PR_smprintf(fmt, defEmailCert);
  768.     if (content == NULL) {
  769.         goto loser;
  770.     }
  771.     rv = SSMTextGen_SubstituteString(cx, content, &expContent);
  772.     if (rv != SSM_SUCCESS || expContent == NULL) {
  773.         goto loser;
  774.     }
  775.     rv = SSM_HTTPSendOKHeader(req, "", "text/html");
  776.     if (rv != SSM_SUCCESS) {
  777.         goto loser;
  778.     }
  779.     rv = SSM_HTTPSendUTF8String(req, expContent);
  780.     if (rv != SSM_SUCCESS) {
  781.         goto loser;
  782.     }
  783.     PR_Free(expContent);
  784.     PR_Free(content);
  785.     PR_Free(fmt);
  786.     req->sentResponse = PR_TRUE;
  787.     return SSM_SUCCESS;
  788.  loser:
  789.     if (cx != NULL) {
  790.         SSMTextGen_DestroyContext(cx);
  791.     }
  792.     PR_FREEIF(fmt);
  793.     PR_FREEIF(content);
  794.     PR_FREEIF(expContent);
  795.     return SSM_FAILURE;
  796. }
  798. SSMStatus SSMSecurityAdvisorContext_DoPKCS12Restore(
  799.                                               SSMSecurityAdvisorContext *res,
  800.                                               HTTPRequest               *req)
  801. {
  802.     SSMStatus           rv;
  803.     SSMPKCS12CreateArg  p12Create;
  804.     SSMPKCS12Context   *p12Cxt=NULL;
  805.     SSMResourceID       rid;
  806.     const char         *responseKey;
  808.     p12Create.isExportContext = PR_FALSE;
  809.     rv = (SSMStatus) SSM_CreateResource(SSM_RESTYPE_PKCS12_CONTEXT, 
  810.                                         (void*)&p12Create,
  811.                                         SSMRESOURCE(res)->m_connection,
  812.                                         &rid, (SSMResource **)(&p12Cxt));
  813.     if (rv != PR_SUCCESS) {
  814.         goto done;
  815.     }
  817.     /* pass along Advisor's client context for window management */
  818.       /* pass along Advisor's client context for window management */
  819.     SSM_CopyCMTItem(&((SSMResource *)p12Cxt)->m_clientContext,
  820.                     &((SSMResource *)res)->m_clientContext);
  821.     
  822.     rv = SSMPKCS12Context_RestoreCertFromPKCS12File(p12Cxt);
  823.     if (rv == SSM_ERR_NEW_DEF_MAIL_CERT) {
  824.         SSM_ChangeCertSecAdvisorList(req, NULL, certHashAdd);
  825.         rv = SSMSecurityAdvisorContext_DoNewDefMailReponse(p12Cxt,req);
  826.     } else {
  827.         if (p12Cxt->super.m_buttonType == SSM_BUTTON_CANCEL){
  828.             rv = SSM_SUCCESS;
  829.             SSM_HTTPReportError(req, HTTP_NO_CONTENT);
  830.         } else if (rv != SSM_SUCCESS) {
  831.             responseKey = SSMUI_GetPKCS12Error(rv, PR_FALSE);
  832.         } else {
  833.             responseKey = "pkcs12_restore_success";
  834.             SSM_ChangeCertSecAdvisorList(req, NULL, certHashAdd);
  835.         }
  836.         rv = SSMSecurityAdvisorContext_DoPKCS12Response(res, req, responseKey);
  837.     }
  838.  done:
  839.     if (p12Cxt != NULL) {
  840.         SSM_FreeResource(SSMRESOURCE(p12Cxt));
  841.     }
  842.     return rv;
  843. }
  845. static CERTCertificate*
  846. SSMSecurityAdvisorContext_FindCertByNickname(SSMSecurityAdvisorContext *cx, 
  847.                                              HTTPRequest *req,
  848.                                              char *certNickname)
  849. {
  850.     CERTCertList      *certList     = NULL;
  851.     CERTCertificate   *cert         = NULL;
  852.     CERTCertListNode  *certListNode = NULL;
  853.     PRInt32            numcerts     = 0;
  854.     SSMTextGenContext *textGenCx    = NULL;
  855.     SSMStatus          rv;
  856.     char              *htmlTemplate = NULL;
  858.     certList = CERT_NewCertList();
  859.     certList = CERT_CreateNicknameCertList(certList, 
  860.                                            cx->super.m_connection->m_certdb,
  861.                                            certNickname, PR_Now(), PR_FALSE);
  863.     if (certList == NULL) {
  864.         certList = PK11_FindCertsFromNickname(certNickname, &cx->super);
  865.         if (certList == NULL) {
  866.             SSM_DEBUG("Could not find a certificate with nick '%s' "
  867.                       "in cert databasen", certNickname);
  868.             goto loser;
  869.         }
  870.     }
  871.     certListNode = CERT_LIST_HEAD(certList);
  872.     while (!CERT_LIST_END(certListNode, certList)) {
  873.         numcerts++;
  874.         certListNode = CERT_LIST_NEXT(certListNode);
  875.     }
  876.     if (numcerts > 1) {
  877.         char * formName = NULL, *params = NULL;
  878.         rv = SSM_HTTPParamValue(req, "formName", &formName);
  879.         if (rv != SSM_SUCCESS || !formName)
  880.             SSM_DEBUG("AdvisorContext_FindCertByNickname:Can't get original formn");
  881.         params = PR_smprintf("origin=%s",formName);
  883.         cx->m_nickname = PL_strdup(certNickname);
  884.         rv = SSMControlConnection_SendUIEvent(cx->super.m_connection,
  885.                                               "get", 
  886.                                               "choose_cert", 
  887.                                               &cx->super,
  888.                                               params,
  889.                                               &cx->super.m_clientContext,
  890.                                               PR_TRUE);
  891.         /* Now wait until we are notified by the handler that the user 
  892.          * has selected a cert.
  893.          */
  894.         SSM_LockUIEvent(&cx->super);
  895.         SSM_WaitUIEvent(&cx->super, PR_INTERVAL_NO_TIMEOUT);
  896.         cert = (CERTCertificate*)cx->super.m_connection->super.super.m_uiData;
  898.         if (cx->super.m_buttonType != SSM_BUTTON_CANCEL) {
  899.             /* 
  900.              * If we don't sleep for a bit here, we cause Communicator to crash
  901.              * because it tries to re-use a Window that gets killed.  Guess
  902.              * we're just too fast for Communicator.
  903.              */
  904.             PR_Sleep(PR_TicksPerSecond()*1);
  905.         }
  906.         PR_FREEIF(cx->m_nickname);
  907.         cx->m_nickname = NULL;
  908.         PR_FREEIF(params);
  909.     } else {
  910.         cert = CERT_FindCertByNickname(cx->super.m_connection->m_certdb,
  911.                                        certNickname);
  912.         cx->super.m_buttonType = SSM_BUTTON_OK;
  913.     }
  914.     CERT_DestroyCertList(certList);
  915.     return cert;
  916.  loser:
  917.     PR_FREEIF(htmlTemplate);
  918.     if (certList != NULL) {
  919.         CERT_DestroyCertList(certList);
  920.     }
  921.     if (cert != NULL) {
  922.         CERT_DestroyCertificate(cert);
  923.     }
  924.     if (textGenCx != NULL) {
  925.         SSMTextGen_DestroyContext(textGenCx);
  926.     }
  927.     return NULL;
  928. }
  930. typedef struct SSMFindMineArgStr {
  931.     CERTCertList *certList;
  932.     SSMControlConnection *ctrl;
  933. } SSMFindMineArg;
  935. static SSMStatus
  936. ssm_find_all_mine(PRIntn index, void *arg, void *key, void *itemdata)
  937. {
  938.     ssmCertData * data = (ssmCertData*)itemdata;
  939.     SSMFindMineArg *findArg = (SSMFindMineArg*) arg;
  940.     char *nick = (char*)key;
  941.     SSMStatus rv = SSM_FAILURE;
  943.     if (data->usage == clAllMine) {
  944.         CERTCertList *tmpList;
  946.         tmpList = CERT_CreateNicknameCertList(findArg->certList,
  947.                                               findArg->ctrl->m_certdb,
  948.                                               nick, PR_Now(), PR_FALSE);
  950.         if (tmpList != NULL) {
  951.             rv = SSM_SUCCESS;
  952.         }
  953.     }
  954.     return rv;
  955. }
  957. SSMStatus
  958. SSMSecurityAdvisorContext_BackupAllMineCerts(SSMSecurityAdvisorContext *cx, 
  959.                                              HTTPRequest               *req)
  960. {
  961.     SSMFindMineArg arg;
  962.     CERTCertList *certList=NULL;
  963.     SSMPKCS12Context *p12Cxt=NULL;
  964.     SSMPKCS12CreateArg p12Create;
  965.     SSMResourceID rid;
  966.     SSMStatus rv;
  967.     CERTCertificate **certArr = NULL;
  968.     int numCerts,i, finalCerts, currIndex;
  969.     CERTCertListNode *node;
  970.     PRIntn numNicks;
  971.     const char *responseKey;
  973.     certList = CERT_NewCertList();
  974.     if (certList == NULL) {
  975.         goto loser;
  976.     }
  977.     arg.certList = certList;
  978.     arg.ctrl     = req->ctrlconn;
  979.     numNicks = SSMSortedList_Enumerate(cx->m_certhash, ssm_find_all_mine, 
  980.                                        &arg);
  981.     if (numNicks <= 0){
  982.         /* No certs to backup */
  983.         SSM_HTTPReportError(req, HTTP_NO_CONTENT);
  984.         goto loser;
  985.     }
  986.     certList = arg.certList;
  987.     p12Create.isExportContext = PR_TRUE;
  988.     rv = (SSMStatus) SSM_CreateResource(SSM_RESTYPE_PKCS12_CONTEXT,
  989.                                         (void*)&p12Create, req->ctrlconn,
  990.                                         &rid, (SSMResource**)(&p12Cxt));
  991.     if (rv != SSM_SUCCESS) {
  992.         goto loser;
  993.     }
  994.     SSM_CopyCMTItem(&p12Cxt->super.m_clientContext, 
  995.                     &cx->super.m_clientContext);
  996.     
  997.     numCerts = SSM_CertListCount(certList);
  998.     certArr = SSM_NEW_ARRAY(CERTCertificate*,numCerts);
  999.     if (certArr == NULL) {
  1000.         goto loser;
  1001.     }
  1002.     node = CERT_LIST_HEAD(certList);
  1003.     for (i=0, currIndex=0, finalCerts=numCerts; i<numCerts; i++) {
  1004.         if (node->cert->slot == NULL ||
  1005.             PK11_IsInternal(node->cert->slot)) {
  1006.             certArr[currIndex] = node->cert;
  1007.             currIndex++;
  1008.         } else {
  1009.             finalCerts--;
  1010.         }
  1011.         node = CERT_LIST_NEXT(node);
  1012.     }
  1013.     rv = SSMPKCS12Context_CreatePKCS12FileForMultipleCerts(p12Cxt,
  1014.                                                            PR_TRUE,
  1015.                                                            certArr,
  1016.                                                            finalCerts);
  1017.     PR_Free(certArr);
  1018.     certArr = NULL;
  1019.     CERT_DestroyCertList(certList);
  1020.     certList = NULL;
  1021.     if (rv == SSM_SUCCESS) {
  1022.         responseKey = (finalCerts > 1) ? "pkcs12_backup_multiple_success" :
  1023.                                          "pkcs12_backup_success";
  1024.     } else {
  1025.         if (p12Cxt->super.m_buttonType == SSM_BUTTON_CANCEL) {
  1026.             goto loser;
  1027.         } else {
  1028.             responseKey = SSMUI_GetPKCS12Error(rv, PR_TRUE);
  1029.         }
  1030.     }
  1031.     SSM_FreeResource(&p12Cxt->super);
  1032.     p12Cxt = NULL;
  1033.     if (SSMSecurityAdvisorContext_DoPKCS12Response(cx, req, responseKey)
  1034.         != SSM_SUCCESS) {
  1035.         goto loser;
  1036.     }
  1037.     return SSM_SUCCESS;
  1038.  loser:
  1039.     PR_FREEIF(certArr);
  1040.     if (certList != NULL) {
  1041.         CERT_DestroyCertList(certList);
  1042.     }
  1043.     if (p12Cxt != NULL) {
  1044.         SSM_FreeResource(&p12Cxt->super);
  1045.     }
  1046.     SSM_HTTPReportError(req, HTTP_NO_CONTENT);
  1047.     return SSM_FAILURE;
  1048. }
  1049. SSMStatus SSMSecurityAdvisorContext_DoPKCS12Backup(
  1050.                                               SSMSecurityAdvisorContext *cx,
  1051.                                               HTTPRequest               *req)
  1052. {
  1053.     SSMStatus rv;
  1054.     char *certNickname;
  1055.     const char *responseKey;
  1056.     SSMPKCS12CreateArg p12Create;
  1057.     SSMResourceID rid;
  1058.     SSMPKCS12Context *p12Cxt;
  1060.     p12Create.isExportContext = PR_TRUE;
  1061.     rv = (SSMStatus) SSM_CreateResource(SSM_RESTYPE_PKCS12_CONTEXT, 
  1062.                                         (void*)&p12Create,
  1063.                                         SSMRESOURCE(cx)->m_connection,
  1064.                                         &rid, (SSMResource **)(&p12Cxt));
  1065.     if (rv != PR_SUCCESS) {
  1066.         goto loser;
  1067.     }
  1068.     /* pass along Advisor's client context for window management */
  1069.     SSM_CopyCMTItem(&((SSMResource *)p12Cxt)->m_clientContext,
  1070.                     &((SSMResource *)cx)->m_clientContext);
  1072.     rv = SSM_HTTPParamValue(req, "selectCert", &certNickname);
  1073.     if (rv != SSM_SUCCESS) {
  1074.         goto loser;
  1075.     }
  1076.     
  1077.     p12Cxt->m_cert = 
  1078.         SSMSecurityAdvisorContext_FindCertByNickname(cx, req, certNickname);
  1080.     if (cx->super.m_buttonType == SSM_BUTTON_CANCEL) {
  1081.         goto loser;
  1082.     }
  1083.     if (p12Cxt->m_cert == NULL) {
  1084.         goto loser;
  1085.     }
  1087.     /* p12Cxt->super.m_clientContext = cx->super.m_clientContext; */
  1088.     rv = SSMPKCS12Context_CreatePKCS12File(p12Cxt, PR_TRUE);
  1089.     if (rv == SSM_SUCCESS) {
  1090.         responseKey = "pkcs12_backup_success";
  1091.     } else {
  1092.         if (p12Cxt->super.m_buttonType == SSM_BUTTON_CANCEL) {
  1093.             goto loser;
  1094.         } else {
  1095.             responseKey = SSMUI_GetPKCS12Error(rv, PR_TRUE);
  1096.         }
  1097.     }
  1098.     if (SSMSecurityAdvisorContext_DoPKCS12Response(cx, req, responseKey)
  1099.         != SSM_SUCCESS) {
  1100.         goto loser;
  1101.     }
  1102.     SSM_FreeResource(&p12Cxt->super);
  1103.     return SSM_SUCCESS;
  1104.  loser:
  1105.     if (p12Cxt != NULL) {
  1106.         SSM_FreeResource(&p12Cxt->super);
  1107.     }
  1108.     SSM_HTTPReportError(req, HTTP_NO_CONTENT);
  1109.     return SSM_FAILURE;
  1110. }
  1112. char *
  1113. ssm_packb64_name(char *b64Name)
  1114. {
  1115.     char *htmlString = NULL;
  1116.     int numPercentSigns = 0;
  1117.     char *cursor, *retString;
  1118.     int i, newLen, origHTMLStrLen; 
  1120.     htmlString = SSM_ConvertStringToHTMLString(b64Name);
  1121.     /*
  1122.      * Now let's see if there are any '%' characters that need
  1123.      * to be escaped so that printf statements succeed.
  1124.      */
  1125.     cursor = htmlString;
  1126.     while ((cursor = PL_strchr(cursor, '%')) != NULL) {
  1127.         numPercentSigns++;
  1128.         cursor++;
  1129.     }
  1130.     if (numPercentSigns == 0) {
  1131.         htmlString;
  1132.     }
  1133.     origHTMLStrLen = PL_strlen(htmlString);
  1134.     newLen = origHTMLStrLen + numPercentSigns + 1;
  1135.     retString = SSM_NEW_ARRAY(char, newLen);
  1136.     for (i=0,cursor=retString; i<origHTMLStrLen+1; i++,cursor++) {
  1137.         if (htmlString[i] == '%') {
  1138.             char *dollarSign, *placeHolder;
  1139.             /*
  1140.              * Let's see if this a urlencoded escape or a printf parameter.
  1141.              */
  1142.             placeHolder = &htmlString[i];
  1143.             dollarSign = PL_strchr(placeHolder, '$');
  1144.             if (dollarSign && ((dollarSign - placeHolder) < 2)) {
  1145.                 /*
  1146.                  * OK, this is a numbered parameter for printf
  1147.                  */
  1148.                 *cursor = htmlString[i];
  1149.             } else {
  1150.                 /*
  1151.                  * This is an escape for url encoding.  Escape it so printf
  1152.                  * doesn't blow up.
  1153.                  */
  1154.                 *cursor = '%';
  1155.                 cursor++;
  1156.                 *cursor = '%';
  1157.             }
  1158.         } else {
  1159.             *cursor = htmlString[i];
  1160.         }
  1161.     }
  1162.     PR_Free(htmlString);
  1163.     return retString;
  1164. }
  1166. SSMStatus
  1167. SSMSecurityAdvisorContext_ProcessCRLDialog (HTTPRequest *req)
  1168. {
  1169.     SSMHTTPParamMultValues crlNames={NULL, NULL, 0};
  1170.     CERTSignedCrl *realCrl;
  1171.     SECItem crlDERName;
  1172.     PRBool flushSSLCache = PR_FALSE;
  1173.     SSMStatus rv;
  1174.     SECStatus srv;
  1175.     int i, type;
  1177.     rv = SSM_HTTPParamValueMultiple(req, "crlNames", &crlNames);
  1178.     if (rv != SSM_SUCCESS || crlNames.numValues == 0) {
  1179.         goto loser;
  1180.     }
  1181.     memset (&crlDERName, 0, sizeof(SECItem));
  1182.     for (i=0; i<crlNames.numValues; i++) {
  1183.         /*
  1184.          * The first character in the value string represents the type,
  1185.          * either 1 (SEC_CRL_TYPE) or 0 (SEC_KRL_TYPE)
  1186.          */
  1187.         srv = ATOB_ConvertAsciiToItem(&crlDERName, crlNames.values[i]+1);
  1188.         if (srv != SECSuccess) {
  1189.             goto loser;
  1190.         }
  1191.         type = (crlNames.values[i][0] == '1') ? SEC_CRL_TYPE : SEC_KRL_TYPE;
  1192.         realCrl = SEC_FindCrlByName(req->ctrlconn->m_certdb, 
  1193.                                     &crlDERName, type);
  1194.         SECITEM_FreeItem(&crlDERName, PR_FALSE);
  1195.         if (realCrl) {
  1196.             SEC_DeletePermCRL(realCrl);
  1197.             SEC_DestroyCrl(realCrl);
  1198.             flushSSLCache = PR_TRUE;            
  1199.         }
  1200.     }
  1201.     if (flushSSLCache) {
  1202.         SSL_ClearSessionCache();
  1203.     }
  1204.     if (!SSM_IsCRLPresent(req->ctrlconn)) {
  1205.         /*
  1206.          * In this case, there are no more CRLs in the database,
  1207.          * so we'll replace the baseRef with one that will cause
  1208.          * the security advisor to refresh itself and elminate the
  1209.          * "Delete CRLs" button.
  1210.          */
  1211.         for (i=0; i<req->numParams; i++) {
  1212.             char *crlCloseKey = "crlclose_doclose_js";
  1213.             if (PL_strcmp(req->paramNames[i], "baseRef") == 0) {
  1214.                 memcpy (req->paramValues[i], crlCloseKey, 
  1215.                         PL_strlen(crlCloseKey)+1);
  1216.                 break;
  1217.             }
  1218.         }
  1219.     }
  1221.     if (SSM_HTTPDefaultCommandHandler(req) != SSM_SUCCESS) {
  1222.         goto loser;
  1223.     }
  1224.     PR_FREEIF(crlNames.values);
  1225.     return SSM_SUCCESS;
  1226.  loser:
  1227.     PR_FREEIF(crlNames.values);
  1228.     return SSM_FAILURE;
  1229. }
  1231. SSMStatus SSMSecurityAdvisorContext_Process_cert_mine_form(
  1232.                                                 SSMSecurityAdvisorContext *res,
  1233.                                                 HTTPRequest *req)
  1234. {
  1235.     SSMStatus  rv= SSM_FAILURE;
  1236.     char      *button;
  1237.     
  1238.     /* Figure out which one of the buttons on the form was pressed. */
  1239.     if (SSM_HTTPParamValue(req, "backup", &button) == SSM_SUCCESS) {
  1240.       if (button != NULL) {
  1241.         rv = SSMSecurityAdvisorContext_DoPKCS12Backup(res, req);
  1242.       }
  1243.     } else if (SSM_HTTPParamValue(req, "restore", &button) == SSM_SUCCESS) {
  1244.       if (button != NULL) {
  1245.         rv = SSMSecurityAdvisorContext_DoPKCS12Restore(res, req);
  1246.       }
  1247.     } else if (SSM_HTTPParamValue(req, "delete", &button) == SSM_SUCCESS) {
  1248.         if (button != NULL) {
  1249.             rv = SSM_ProcessCertDeleteButton(req);
  1250.         }
  1251.     } else if (SSM_HTTPParamValue(req, "password", &button) == SSM_SUCCESS) {
  1252.         if (button != NULL) {
  1253.             rv = SSM_ProcessPasswordWindow(req);
  1254.         }
  1255.     } else if (SSM_HTTPParamValue(req, "ldap", &button) == SSM_SUCCESS) {
  1256.         if (button != NULL) {
  1257.             rv = SSM_ProcessLDAPWindow(req);
  1258.         }
  1259.     } else if (SSM_HTTPParamValue(req, "backup_all", &button) == SSM_SUCCESS) {
  1260.         if (button != NULL) {
  1261.             rv = SSMSecurityAdvisorContext_BackupAllMineCerts(res, req);
  1262.         }
  1263.     } else if (SSM_HTTPParamValue(req, "crlButton", &button) == SSM_SUCCESS) {
  1264.         if (button != NULL) {
  1265.     rv = SSM_HTTPReportError(req, HTTP_NO_CONTENT);
  1266. }
  1267.     }
  1268.     return rv;
  1269. }
  1271. static SSMStatus
  1272. SSMSecurityAdvisorContext_SetConfigOCSP(SSMSecurityAdvisorContext *cx, 
  1273.                                         HTTPRequest               *req)
  1274. {
  1275.     char *responderURL = NULL, *caNickname = NULL;
  1276.     char *enableOCSP = NULL;
  1277.     CERTCertDBHandle  *db;
  1278.     SSMStatus rv;
  1279.     SECStatus srv;
  1281.     db = cx->super.m_connection->m_certdb;
  1282.     rv = SSM_HTTPParamValue(req, "enableOCSP", &enableOCSP);
  1283.     if (rv != SSM_SUCCESS) {
  1284.         goto loser;
  1285.     }
  1286.     if (!strcmp(enableOCSP,"noOCSP")) {
  1287.         CERT_DisableOCSPChecking(db);
  1288.         SSMControlConnection_SaveBoolPref(req->ctrlconn, 
  1289.                                           "security.OCSP.enabled", 
  1290.                                           PR_FALSE);
  1291.         SSMControlConnection_SaveBoolPref(req->ctrlconn, 
  1292.                                           "security.OCSP.useDefaultResponder", 
  1293.                                           PR_FALSE);
  1294.         CERT_DisableOCSPChecking(db);
  1295.         CERT_DisableOCSPDefaultResponder(db);
  1296.     } else if (!strcmp(enableOCSP,"noDefaultResponder")) {
  1297.         srv = CERT_EnableOCSPChecking(db);
  1298.         SSMControlConnection_SaveBoolPref(req->ctrlconn, 
  1299.                                           "security.OCSP.enabled", 
  1300.                                           PR_TRUE);
  1301.         SSMControlConnection_SaveBoolPref(req->ctrlconn, 
  1302.                                           "security.OCSP.useDefaultResponder", 
  1303.                                           PR_FALSE);
  1304.         if (srv != SECSuccess) {
  1305.             goto loser;
  1306.         }
  1307.         CERT_DisableOCSPDefaultResponder(db);
  1308.     } else if (!strcmp(enableOCSP,"useDefaultResponder")) {
  1309.         srv = CERT_EnableOCSPChecking(db);
  1310.         SSMControlConnection_SaveBoolPref(req->ctrlconn, 
  1311.                                           "security.OCSP.enabled", 
  1312.                                           PR_TRUE);
  1313.         SSMControlConnection_SaveBoolPref(req->ctrlconn, 
  1314.                                           "security.OCSP.useDefaultResponder", 
  1315.                                           PR_TRUE);
  1316.         if (srv != SECSuccess) {
  1317.             goto loser;
  1318.         }
  1319.         rv = SSM_HTTPParamValue(req, "ocspURL", &responderURL);
  1320.         if (rv != SSM_SUCCESS) {
  1321.             goto loser;
  1322.         }
  1323.         SSMControlConnection_SaveStringPref(req->ctrlconn, 
  1324.                                             "security.OCSP.URL", 
  1325.                                             responderURL);
  1326.         rv = SSM_HTTPParamValue(req, "selectCert", &caNickname);
  1327.         if (rv != SSM_SUCCESS) {
  1328.             goto loser;
  1329.         }
  1330.         SSMControlConnection_SaveStringPref(req->ctrlconn, 
  1331.                                             "security.OCSP.signingCA", 
  1332.                                             caNickname);
  1333.         srv = CERT_SetOCSPDefaultResponder(db, responderURL, caNickname);
  1334.         if (srv != SECSuccess) {
  1335.             goto loser;
  1336.         }
  1337.         srv = CERT_EnableOCSPDefaultResponder(db);
  1338.         if (srv != SECSuccess) {
  1339.             goto loser;
  1340.         }
  1341.     } else {
  1342.         goto loser;
  1343.     }
  1344.     return SSM_SUCCESS;
  1346.  loser:
  1347.     return SSM_FAILURE;
  1348. }
  1350. static SSMStatus
  1351. SSMSecurityAdvisorContext_ProcessOCSPForm(SSMSecurityAdvisorContext *cx, 
  1352.                                           HTTPRequest               *req)
  1353. {
  1354.     SSMStatus rv = SSM_SUCCESS;
  1355.     /*
  1356.      * First, if the Cancel button was pressed, then don't 
  1357.      * process the form.
  1358.      */
  1359.     if (cx->super.m_buttonType == SSM_BUTTON_OK) {
  1360.         rv = SSMSecurityAdvisorContext_SetConfigOCSP(cx, req);
  1361.     }
  1362.     SSM_HTTPDefaultCommandHandler(req);
  1363.     return rv;
  1364. }
  1366. SSMStatus SSMSecurityAdvisorContext_FormSubmitHandler(SSMResource *res,
  1367.                                                       HTTPRequest *req)
  1368. {
  1369.     SSMStatus  rv;
  1370.     char      *formName;
  1372.     if (!SSM_IsAKindOf(res, SSM_RESTYPE_SECADVISOR_CONTEXT)) {
  1373.         return SSM_FAILURE;
  1374.     }
  1376.     /* First figure out which form we're processing. */
  1377.     rv = SSM_HTTPParamValue(req, "formName", &formName);
  1378.     if (rv != SSM_SUCCESS) {
  1379.         goto loser;
  1380.     }
  1382.     if (PL_strcmp(formName, "prefs_submit_form") == 0) {
  1383.         /* save pref changes and close the Security Advisor */
  1384.         rv = SSMSecurityAdvisorContext_SavePrefs
  1385.             ((SSMSecurityAdvisorContext*)res, req);
  1386.     }
  1387.     else if (!strcmp(formName, "cert_mine_form") ||
  1388.              !strcmp(formName, "cert_others_form") ||
  1389.              !strcmp(formName, "cert_websites_form") ||
  1390.              !strcmp(formName, "cert_authorities_form")) {
  1391.       rv = SSMSecurityAdvisorContext_Process_cert_mine_form
  1392.         ((SSMSecurityAdvisorContext*)res, req);
  1393.     } else if (!strcmp(formName, "choose_cert_by_usage")) {
  1394.       rv = SSM_ChooseCertUsageHandler(req);
  1395.     } else if (!strcmp(formName, "set_db_password")) {
  1396.       rv = SSM_SetDBPasswordHandler(req);
  1397.     } else if (!strcmp(formName, "configureOCSPForm")){
  1398.       rv = SSMSecurityAdvisorContext_ProcessOCSPForm
  1399.                                        ((SSMSecurityAdvisorContext*)res, req);
  1400.     } else if (!strcmp(formName, "crlDialog")){
  1401.         rv = SSMSecurityAdvisorContext_ProcessCRLDialog(req);
  1402.     }else {
  1403.       rv = SSM_ERR_BAD_REQUEST; 
  1404.       SSM_HTTPReportSpecificError(req, "Do not know how to process form %s",
  1405.                                   formName);
  1406.     }
  1407.   loser:
  1408.     return rv;
  1409. }
  1411. SSMStatus
  1412. SSMSecurityAdvisorContext_Print(SSMResource *res,
  1413.                                 char *fmt, PRIntn numParam,
  1414.                                 char **value, char **resultStr)
  1415. {
  1416.     SSMSecurityAdvisorContext *cx = (SSMSecurityAdvisorContext*)res;
  1417.     SSMStatus rv;
  1419.     PR_ASSERT(fmt != NULL && resultStr != NULL);
  1420.     if (!SSM_IsAKindOf(res, SSM_RESTYPE_SECADVISOR_CONTEXT)) {
  1421.         return PR_FAILURE;
  1422.     }
  1423.     /* We don't use the extra parameters */
  1424.     if (cx->m_nickname != NULL) {
  1425.         *resultStr = PR_smprintf(fmt, res->m_id, "backup", cx->m_nickname, *value);
  1426.         rv = (*resultStr == NULL) ? PR_FAILURE : PR_SUCCESS;
  1427.     } else {
  1428.         rv = SSMResource_Print(res, fmt, numParam, value, resultStr);
  1429.     }
  1430.     return rv;
  1431. }
  1433. SSMStatus SSM_SetSelectedItemInfo(SSMSecurityAdvisorContext* cx)
  1434. {
  1435. SSMStatus rv = SSM_SUCCESS;
  1437.     switch (cx->infoContext)
  1438.     {
  1439.         case SSM_NOINFO:
  1440.             cx->selectedItemPage = SSM_NO_INFO;
  1441.             break;
  1442.         case SSM_COMPOSE:
  1443.             break;
  1444. case SSM_SNEWS_MESSAGE:
  1445. case SSM_NEWS_MESSAGE:
  1446.         case SSM_MAIL_MESSAGE:
  1447.             cx->selectedItemPage = SSM_MESSAGE;
  1448. if (cx->encryptedP7CInfo) {
  1449.     /* Get the P7 Content info resource */
  1450. rv = SSMControlConnection_GetResource(SSMRESOURCE(cx)->m_connection, (SSMResourceID)cx->encryptedP7CInfo,
  1451.   (SSMResource**)&cx->encryptedP7CInfoRes);
  1452. if ((rv != PR_SUCCESS) || (cx->encryptedP7CInfoRes == NULL)) {
  1453. goto loser;
  1454. }
  1455. }
  1456. if (cx->signedP7CInfo) {
  1457.     /* Get the P7 Content info resource */
  1458. rv = SSMControlConnection_GetResource(SSMRESOURCE(cx)->m_connection, (SSMResourceID)cx->signedP7CInfo,
  1459.   (SSMResource**)&cx->signedP7CInfoRes);
  1460. if ((rv != PR_SUCCESS) || (cx->signedP7CInfoRes == NULL)) {
  1461. goto loser;
  1462. }
  1463. }
  1465. if (!cx->encryptedP7CInfo &&
  1466. !cx->signedP7CInfo &&
  1467. cx->verifyError &&
  1468. !cx->decodeError) {
  1469. /* Somehow we have the error code backwards */
  1470. cx->decodeError = cx->verifyError;
  1471. cx->verifyError = 0;
  1472. }
  1474. cx->encrypted_b = (cx->decodeError ||
  1475. (cx->encryptedP7CInfo &&
  1476. SEC_PKCS7ContentIsEncrypted(cx->encryptedP7CInfoRes->m_cinfo)) ||
  1477. (cx->signedP7CInfo &&
  1478. SEC_PKCS7ContentIsEncrypted(cx->signedP7CInfoRes->m_cinfo)));
  1479. cx->signed_b = (cx->verifyError ||
  1480. (cx->encryptedP7CInfo &&
  1481. SEC_PKCS7ContentIsSigned(cx->encryptedP7CInfoRes->m_cinfo)) ||
  1482. (cx->signedP7CInfo &&
  1483. SEC_PKCS7ContentIsSigned(cx->signedP7CInfoRes->m_cinfo)));
  1484.             break;
  1485.         case SSM_BROWSER:
  1486.             if (cx->resID == 0) {
  1487.                 cx->selectedItemPage = SSM_NAVIGATOR_NO_SEC;
  1488.             } else {
  1489.                 cx->selectedItemPage = SSM_NAVIGATOR_SSL;
  1490.             }
  1491.             break;
  1492.         default:
  1493.             cx->selectedItemPage = SSM_NO_INFO;
  1494.             break;
  1495.     }
  1496. return rv;
  1498. loser:
  1499. return SSM_FAILURE;
  1500. }
  1502. SSMStatus sa_noinfo(SSMTextGenContext *cx)
  1503. {
  1504.     SSMStatus rv = SSM_SUCCESS;
  1505.     SSMResource *target = NULL;
  1506.     SSMSecurityAdvisorContext* res = NULL;
  1507. char *fmt = NULL;
  1509.     /* get the connection object */
  1510.     target = SSMTextGen_GetTargetObject(cx);
  1511.     PR_ASSERT(target != NULL);
  1512.     res = (SSMSecurityAdvisorContext*)target;
  1514. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_noinfo", &fmt);
  1515. if (rv != SSM_SUCCESS) {
  1516. goto loser;
  1517. }
  1518.         PR_FREEIF(cx->m_result);
  1519. cx->m_result = fmt;
  1521. return SSM_SUCCESS;
  1522. loser:
  1523. return SSM_FAILURE;
  1524. }
  1526. SSMStatus sa_navigator(SSMTextGenContext *cx)
  1527. {
  1528.     SSMStatus rv = SSM_SUCCESS;
  1529.     SSMResource *target = NULL;
  1530.     SSMSecurityAdvisorContext* res = NULL;
  1531. char *fmt = NULL;
  1532. SSMSSLSocketStatus *socketStatusRes = NULL;
  1533. char * encryption_level = NULL;
  1534. char * serverCN = NULL;
  1535. char * issuerName = NULL;
  1536. CERTCertificate *issuerCert = NULL;
  1537. SSMResourceCert *serverCertRes = NULL, *issuerCertRes = NULL;
  1538. int serverCertResID, issuerCertResID;
  1540.     /* get the connection object */
  1541.     target = SSMTextGen_GetTargetObject(cx);
  1542.     PR_ASSERT(target != NULL);
  1543.     res = (SSMSecurityAdvisorContext*)target;
  1545. if (res->resID == 0) {
  1546. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_navigator_no_sec", &fmt);
  1547. if (rv != SSM_SUCCESS) {
  1548. goto loser;
  1549. }
  1550.                 PR_FREEIF(cx->m_result);
  1551. cx->m_result = PR_smprintf(fmt, res->hostname, res->hostname);
  1552. PR_Free(fmt);
  1553. return SSM_SUCCESS;
  1554. } else {
  1555.     /* Get the socket status resource */
  1556. rv = SSMControlConnection_GetResource(SSMRESOURCE(res)->m_connection, (SSMResourceID)res->resID,
  1557.   (SSMResource**)&socketStatusRes);
  1558. if ((rv != PR_SUCCESS) || (socketStatusRes == NULL)) {
  1559. goto loser;
  1560. }
  1561.         /*
  1562.          * We inherit the client's reference here.
  1563.          */
  1564.         res->socketStatus = socketStatusRes;
  1565. /* Do we have an error */
  1566. if (!socketStatusRes->m_error) {
  1567. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_navigator_ssl", &fmt);
  1568. if (rv != SSM_SUCCESS) {
  1569. goto loser;
  1570. }
  1571. #if 0
  1572. /* Create a resource for this cert */
  1573. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  1574. socketStatusRes->m_cert,
  1575. SSMRESOURCE(res)->m_connection,
  1576. (long *) &serverCertResID,
  1577. (SSMResource**)&serverCertRes);
  1578. if (rv != PR_SUCCESS) {
  1579. goto loser;
  1580. }
  1581. #else
  1582.             serverCertResID = socketStatusRes->m_cert->super.m_id;
  1583.             serverCertRes = socketStatusRes->m_cert;
  1584. #endif
  1585. issuerName = CERT_NameToAscii(&socketStatusRes->m_cert->cert->issuer);
  1587. if (socketStatusRes->m_level == SSL_SECURITY_STATUS_ON_HIGH) {
  1588. SSM_GetUTF8Text(cx, "high_grade_encryption", &encryption_level);
  1589. } else {
  1590. SSM_GetUTF8Text(cx, "low_grade_encryption", &encryption_level);
  1591. }
  1592.             PR_FREEIF(cx->m_result);
  1593. cx->m_result = PR_smprintf(fmt, res->hostname, issuerName, target->m_id, serverCertResID,
  1594. encryption_level, socketStatusRes->m_cipherName,
  1595. socketStatusRes->m_secretKeySize);
  1596. PR_Free(issuerName);
  1597. PR_Free(encryption_level);
  1598. PR_Free(fmt);
  1599.             SSM_FreeResource(&socketStatusRes->super);
  1600. return SSM_SUCCESS;
  1601. } else {
  1602. if (socketStatusRes->m_error == SEC_ERROR_UNKNOWN_ISSUER ||
  1603. socketStatusRes->m_error == SEC_ERROR_CA_CERT_INVALID ) {
  1604. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_navigator_ssl_unknown_issuer", &fmt);
  1605. if (rv != SSM_SUCCESS) {
  1606. goto loser;
  1607. }
  1609. /* Get the common name of the issuer */
  1610. issuerName = CERT_NameToAscii(&socketStatusRes->m_cert->cert->issuer);
  1611. if (!issuerName) {
  1612. goto loser;
  1613. }
  1615. /* Get the common name of the server cert */
  1616. serverCN = CERT_GetCommonName(&socketStatusRes->m_cert->cert->subject);
  1617. if (!serverCN) {
  1618. goto loser;
  1619. }
  1620. #if 0
  1621. /* Create resource for the server cert */
  1622. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  1623. socketStatusRes->m_cert,
  1624. SSMRESOURCE(res)->m_connection,
  1625. (long *) &serverCertResID,
  1626. (SSMResource**)&serverCertRes);
  1627. if (rv != PR_SUCCESS) {
  1628. goto loser;
  1629. }
  1630. #else 
  1631.                 serverCertRes = socketStatusRes->m_cert;
  1632.                 serverCertResID = serverCertRes->super.m_id;
  1633. #endif
  1634. if (socketStatusRes->m_level == SSL_SECURITY_STATUS_ON_HIGH) {
  1635. SSM_GetUTF8Text(cx, "high_grade_encryption", &encryption_level);
  1636. } else {
  1637. SSM_GetUTF8Text(cx, "low_grade_encryption", &encryption_level);
  1638. }
  1639.                                 PR_FREEIF(cx->m_result);
  1640. cx->m_result = PR_smprintf(fmt, res->hostname, issuerName, target->m_id, serverCertResID,
  1641. encryption_level, socketStatusRes->m_cipherName,
  1642. socketStatusRes->m_secretKeySize);
  1643. PR_Free(fmt);
  1644. PR_Free(issuerName);
  1645. PR_Free(serverCN);
  1646. PR_Free(encryption_level);
  1647.                 SSM_FreeResource(&socketStatusRes->super);
  1648. return SSM_SUCCESS;
  1649. } else if(socketStatusRes->m_error == SEC_ERROR_UNTRUSTED_ISSUER) {
  1650. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_navigator_ssl_bad_issuer", &fmt);
  1651. if (rv != SSM_SUCCESS) {
  1652. goto loser;
  1653. }
  1655. /* Get the common name of the issuer */
  1656. issuerName = CERT_NameToAscii(&socketStatusRes->m_cert->cert->issuer);
  1657. if (!issuerName) {
  1658. goto loser;
  1659. }
  1661. /* Get the common name of the server cert */
  1662. serverCN = CERT_GetCommonName(&socketStatusRes->m_cert->cert->subject);
  1663. if (!serverCN) {
  1664. goto loser;
  1665. }
  1666. #if 0
  1667. /* Create resource for the server cert */
  1668. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  1669. socketStatusRes->m_cert,
  1670. SSMRESOURCE(res)->m_connection,
  1671. (long *) &serverCertResID,
  1672. (SSMResource**)&serverCertRes);
  1673. if (rv != PR_SUCCESS) {
  1674. goto loser;
  1675. }
  1676. #else 
  1677.                 serverCertRes = socketStatusRes->m_cert;
  1678.                 serverCertResID = serverCertRes->super.m_id;
  1679. #endif
  1681. /* Create a resource for the issuer cert (if it exists) */
  1682. issuerCert = CERT_FindCertIssuer(socketStatusRes->m_cert->cert,
  1683.                                                  PR_Now(), certUsageAnyCA);
  1684. if (issuerCert) {
  1685. /* Create resource for the issuer cert */
  1686. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  1687. issuerCert,
  1688. SSMRESOURCE(res)->m_connection,
  1689. (long *) &issuerCertResID,
  1690. (SSMResource**)&issuerCertRes);
  1691. if (rv != PR_SUCCESS) {
  1692. goto loser;
  1693. }
  1694. } else {
  1695. issuerCertResID = 0;
  1696. }
  1698. if (socketStatusRes->m_level == SSL_SECURITY_STATUS_ON_HIGH) {
  1699. SSM_GetUTF8Text(cx, "high_grade_encryption", &encryption_level);
  1700. } else {
  1701. SSM_GetUTF8Text(cx, "low_grade_encryption", &encryption_level);
  1702. }
  1703.                                 PR_FREEIF(cx->m_result);
  1704. cx->m_result = PR_smprintf(fmt, res->hostname, issuerName, target->m_id, serverCertResID,
  1705. issuerCertResID, encryption_level, socketStatusRes->m_cipherName,
  1706. socketStatusRes->m_secretKeySize);
  1707. PR_Free(fmt);
  1708. PR_Free(issuerName);
  1709. PR_Free(serverCN);
  1710. PR_Free(encryption_level);
  1711.                 SSM_FreeResource(&socketStatusRes->super);
  1712. return SSM_SUCCESS;
  1713. } else if (socketStatusRes->m_error == SSL_ERROR_BAD_CERT_DOMAIN) {
  1714. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_navigator_ssl_bad_cert_domain", &fmt);
  1715. if (rv != SSM_SUCCESS) {
  1716. goto loser;
  1717. }
  1719. /* Get the common name of the server cert */
  1720. serverCN = CERT_GetCommonName(&socketStatusRes->m_cert->cert->subject);
  1721. if (!serverCN) {
  1722. goto loser;
  1723. }
  1725. if (socketStatusRes->m_level == SSL_SECURITY_STATUS_ON_HIGH) {
  1726. SSM_GetUTF8Text(cx, "high_grade_encryption", &encryption_level);
  1727. } else {
  1728. SSM_GetUTF8Text(cx, "low_grade_encryption", &encryption_level);
  1729. }
  1730.                     PR_FREEIF(cx->m_result);
  1731. cx->m_result = PR_smprintf(fmt, res->hostname, serverCN, encryption_level, socketStatusRes->m_cipherName,
  1732. socketStatusRes->m_secretKeySize);
  1734. PR_Free(fmt);
  1735. PR_Free(serverCN);
  1736. PR_Free(encryption_level);
  1737.                     SSM_FreeResource(&socketStatusRes->super);
  1738. return SSM_SUCCESS;
  1739. } else {
  1740. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_navigator_ssl_unknown_error", &fmt);
  1741. if (rv != SSM_SUCCESS) {
  1742. goto loser;
  1743. }
  1744. #if 0
  1745. /* Create resource for the server cert */
  1746. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  1747. socketStatusRes->m_cert,
  1748. SSMRESOURCE(res)->m_connection,
  1749. (long *) &serverCertResID,
  1750. (SSMResource**)&serverCertRes);
  1751. if (rv != PR_SUCCESS) {
  1752. goto loser;
  1753. }
  1754. #else
  1755.                 serverCertRes = socketStatusRes->m_cert;
  1756.                 serverCertResID = serverCertRes->super.m_id;
  1757. #endif
  1759. if (socketStatusRes->m_level == SSL_SECURITY_STATUS_ON_HIGH) {
  1760. SSM_GetUTF8Text(cx, "high_grade_encryption", &encryption_level);
  1761. } else {
  1762. SSM_GetUTF8Text(cx, "low_grade_encryption", &encryption_level);
  1763. }
  1764.                 PR_FREEIF(cx->m_result);
  1765. cx->m_result = PR_smprintf(fmt, res->hostname, target->m_id, serverCertResID, encryption_level, socketStatusRes->m_cipherName,
  1766. socketStatusRes->m_secretKeySize);
  1767. PR_Free(fmt);
  1768.                 SSM_FreeResource(&socketStatusRes->super);
  1769. return SSM_SUCCESS;
  1770. }
  1771. }
  1772. }
  1773. loser:
  1774. PR_FREEIF(fmt);
  1775. PR_FREEIF(serverCN);
  1776. PR_FREEIF(issuerName);
  1777.     if (socketStatusRes) {
  1778.         SSM_FreeResource(&socketStatusRes->super);
  1779.     }
  1780. return SSM_FAILURE;
  1781. }
  1783. static CERTCertificate * get_signer_cert(SSMSecurityAdvisorContext *res)
  1784. {
  1785. CERTCertificate * cert = NULL;
  1787. /* Get the signing cert */
  1788. if (res->signedP7CInfoRes ||
  1789. res->encryptedP7CInfoRes) {
  1790. SEC_PKCS7SignerInfo **signerinfos;
  1791. SEC_PKCS7ContentInfo *ci = res->signedP7CInfoRes->m_cinfo;
  1792. if (!ci) ci = res->encryptedP7CInfoRes->m_cinfo;
  1794. /* Finding the signers cert */
  1795. switch(ci->contentTypeTag->offset) {
  1796. default:
  1797. case SEC_OID_PKCS7_DATA:
  1798. case SEC_OID_PKCS7_DIGESTED_DATA:
  1799. case SEC_OID_PKCS7_ENVELOPED_DATA:
  1800. case SEC_OID_PKCS7_ENCRYPTED_DATA:
  1801. /* Could only get here if SEC_PKCS7ContentIsSigned
  1802. * is broken. */
  1803. {
  1804. PORT_Assert (0);
  1805. cert=NULL;
  1806. }
  1807. break;
  1808. case SEC_OID_PKCS7_SIGNED_DATA:
  1809. {
  1810. SEC_PKCS7SignedData *sdp;
  1811. sdp = ci->content.signedData;
  1812. signerinfos = sdp->signerInfos;
  1813. cert = signerinfos[0]->cert;
  1814. }
  1815. break;
  1816. case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA:
  1817. {
  1818. SEC_PKCS7SignedAndEnvelopedData *saedp;
  1819. saedp = ci->content.signedAndEnvelopedData;
  1820. signerinfos = saedp->signerInfos;
  1821. cert = signerinfos[0]->cert;
  1822. }
  1823. break;
  1824. } /* finding the signer cert */
  1825. }
  1826. return cert;
  1827. }
  1829. char*
  1830. SSM_GetOCSPURL(CERTCertificate *cert, PrefSet *prefs)
  1831. {
  1832.     SSMStatus rv;
  1833.     PRBool boolval = PR_FALSE;
  1834.     char *responderURL = NULL;
  1836.     /* Is there a default responder installed */
  1837.     rv = PREF_GetBoolPref(prefs, "security.OCSP.useDefaultResponder", &boolval);
  1838.     if (boolval) {
  1839.         PREF_CopyStringPref(prefs, "security.OCSP.URL", &responderURL);
  1840.     } else {
  1841. responderURL = CERT_GetOCSPAuthorityInfoAccessLocation(cert);
  1842.     }
  1843.     return responderURL;
  1844. }
  1846. static CERTCertificate * get_encryption_cert(SSMSecurityAdvisorContext *res)
  1847. {
  1848. return NULL;
  1849. }
  1851. static char *
  1852. sa_get_algorithm_string(SEC_PKCS7ContentInfo *cinfo)
  1853. {
  1854. SECAlgorithmID *algid;
  1855. SECOidTag algtag;
  1856. const char *alg_name;
  1857. int key_size;
  1858. if (!cinfo) return 0;
  1859. algid = SEC_PKCS7GetEncryptionAlgorithm(cinfo);
  1860. if (!algid) return 0;
  1861. algtag = SECOID_GetAlgorithmTag(algid);
  1862. alg_name = SECOID_FindOIDTagDescription(algtag);
  1864. key_size = SEC_PKCS7GetKeyLength(cinfo);
  1866. if (!alg_name || !*alg_name)
  1867. return 0;
  1868. else if (key_size > 0)
  1869. return PR_smprintf("%d-bits %s",
  1870.        key_size, alg_name);
  1871. else
  1872. return PL_strdup(alg_name);
  1873. }
  1875. PRBool
  1876. SSM_IsOCSPEnabled(SSMControlConnection *connection) 
  1877. {
  1878.     SSMStatus rv;
  1879.     PRBool isOCSPEnabled = PR_FALSE;
  1881.     rv = PREF_GetBoolPref(connection->m_prefs, "security.OCSP.enabled",
  1882.                           &isOCSPEnabled);
  1883.     return (rv == SSM_SUCCESS) ? isOCSPEnabled : PR_FALSE; 
  1884. }
  1886. char *
  1887. SSM_GetGenericOCSPWarning(SSMControlConnection *ctrl,
  1888.                           CERTCertificate *cert)
  1889. {
  1890.     char *retString = NULL;
  1891.     char *responderURL = NULL;
  1892.     SSMTextGenContext *cx = NULL;
  1893.     SSMStatus rv;
  1895.     retString = PL_strdup("");
  1896.     if (SSM_IsOCSPEnabled(ctrl)) {
  1897.         responderURL = SSM_GetOCSPURL(cert, ctrl->m_prefs);
  1898.         if (responderURL == NULL) {
  1899.             goto done;
  1900.         }
  1901.         rv = SSMTextGen_NewTopLevelContext(NULL, &cx);
  1902.         if (rv != SSM_SUCCESS) {
  1903.             goto done;
  1904.         }
  1905.         SSM_GetAndExpandTextKeyedByString(cx, "ocsp_fail_message_generic",
  1906.                                           &retString);
  1907.     } 
  1908.  done:
  1909.     PR_FREEIF(responderURL);
  1910.     if (cx) {
  1911.         SSMTextGen_DestroyContext(cx);
  1912.     }
  1913.     return retString;
  1914. }
  1916. SSMStatus sa_message(SSMTextGenContext *cx)
  1917. {
  1918.     SSMStatus rv = SSM_SUCCESS;
  1919.     SSMResource *target = NULL;
  1920.     SSMSecurityAdvisorContext* res = NULL;
  1921. char *fmt = NULL, *fmtSigned = NULL, *fmtEncrypted = NULL;
  1922.     char *genericOCSPWarning = NULL;
  1924.     /* get the connection object */
  1925.     target = SSMTextGen_GetTargetObject(cx);
  1926.     PR_ASSERT(target != NULL);
  1927.     res = (SSMSecurityAdvisorContext*)target;
  1929. /* Deal with the signed part first */
  1930. if (!res->signed_b) {
  1931. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_not_signed", &fmtSigned);
  1932. if (rv != SSM_SUCCESS) {
  1933. goto loser;
  1934. }
  1935. } else {
  1936. if (res->verifyError == 0) {
  1937. char *signer_email;
  1938. CERTCertificate *signerCert = NULL;
  1939. SSMResourceCert *signerCertRes = NULL;
  1940. int signerCertResID;
  1942. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed", &fmt);
  1943. if (rv != SSM_SUCCESS) {
  1944. goto loser;
  1945. }
  1947. signerCert = get_signer_cert(res);
  1948. if (!signerCert) {
  1949. goto loser;
  1950. }
  1952. /* Get the signers email address */
  1953. if (res->signedP7CInfoRes) {
  1954. signer_email = SEC_PKCS7GetSignerEmailAddress(res->signedP7CInfoRes->m_cinfo);
  1955. }
  1957. if (!signer_email && res->encryptedP7CInfoRes) {
  1958. signer_email = SEC_PKCS7GetSignerEmailAddress(res->encryptedP7CInfoRes->m_cinfo);
  1959. }
  1961. /* Create a cert resource for this certificate */
  1962.     rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  1963.                         signerCert,
  1964.                     SSMRESOURCE(res)->m_connection,
  1965.                 (long *) &signerCertResID,
  1966.             (SSMResource**)&signerCertRes);
  1967. if (rv != PR_SUCCESS) {
  1968.             goto loser;
  1969.     }
  1971. fmtSigned = PR_smprintf(fmt, signer_email, target->m_id, signerCertResID);
  1972. PR_Free(fmt);
  1973. } else {
  1974.             CERTCertificate *signerCert;
  1976.             /* Get the signing certificate */
  1977.             signerCert = get_signer_cert(res);
  1978.             if (!signerCert) {
  1979.                 goto loser;
  1980.             }
  1982.             genericOCSPWarning = 
  1983.                 SSM_GetGenericOCSPWarning(target->m_connection,
  1984.                                           signerCert);
  1985. switch(res->verifyError) {
  1986. case SEC_ERROR_PKCS7_BAD_SIGNATURE:
  1987. {
  1988. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_bad_signature", &fmt);
  1989. if (rv != SSM_SUCCESS) {
  1990. goto loser;
  1991. }
  1992.                         fmtSigned = PR_smprintf(fmt, genericOCSPWarning);
  1993.                         PR_FREEIF(fmt);
  1994. }
  1995. break;
  1997. /* This case handles both expired and not yet valid certs */
  1998. case SEC_ERROR_EXPIRED_CERTIFICATE:
  1999. {
  2000. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_expired_signing_cert", &fmt);
  2001. if (rv != SSM_SUCCESS) {
  2002. goto loser;
  2003. }
  2004.                         fmtSigned = PR_smprintf(fmt, genericOCSPWarning);
  2005.                         PR_FREEIF(fmt);
  2006. }
  2007. break;
  2009. case SEC_ERROR_REVOKED_CERTIFICATE:
  2010. {
  2011. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_revoked_signing_cert", &fmt);
  2012. if (rv != SSM_SUCCESS) {
  2013. goto loser;
  2014. }
  2015.                         fmtSigned = PR_smprintf(fmt, genericOCSPWarning);
  2016.                         PR_FREEIF(fmt);
  2017. }
  2018. break;
  2020. case SEC_ERROR_UNKNOWN_ISSUER:
  2021. {
  2022. SSMResourceCert *signerCertRes;
  2023. PRUint32 signerCertResID;
  2024. char *fmt;
  2026. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_unknown_issuer", &fmt);
  2027. if (rv != SSM_SUCCESS) {
  2028. goto loser;
  2029. }
  2031. /* Create a cert resource for this certificate */
  2032. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  2033. signerCert,
  2034. SSMRESOURCE(res)->m_connection,
  2035. (long *) &signerCertResID,
  2036. (SSMResource**)&signerCertRes);
  2037. if (rv != PR_SUCCESS) {
  2038. goto loser;
  2039. }
  2040. fmtSigned = PR_smprintf(fmt, target->m_id, 
  2041.                                                 signerCertResID, 
  2042.                                                 genericOCSPWarning);
  2043. PR_Free(fmt);
  2044. }
  2045. break;
  2047. case SEC_ERROR_CA_CERT_INVALID:
  2048. case SEC_ERROR_UNTRUSTED_ISSUER:
  2049. {
  2050. CERTCertificate *issuerCert;
  2051. SSMResourceCert * signerCertRes, issuerCertRes;
  2052. PRInt32 signerCertResID, issuerCertResID;
  2053. char *fmt = NULL;
  2055. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_untrusted_issuer", &fmt);
  2056. if (rv != SSM_SUCCESS) {
  2057. goto loser;
  2058. }
  2060. /* Get the isser cert */
  2061. issuerCert = CERT_FindCertIssuer(signerCert, PR_Now(), certUsageAnyCA);
  2062. if (!issuerCert) {
  2063. goto loser;
  2064. }
  2066. /* Create resources for these certs */
  2067. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  2068. signerCert,
  2069. SSMRESOURCE(res)->m_connection,
  2070. (long *) &signerCertResID,
  2071. (SSMResource**)&signerCertRes);
  2072. if (rv != SSM_SUCCESS) {
  2073. goto loser;
  2074. }
  2076. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  2077. issuerCert,
  2078. SSMRESOURCE(res)->m_connection,
  2079. (long *) &issuerCertResID,
  2080. (SSMResource**)&issuerCertRes);
  2081. if (rv != SSM_SUCCESS) {
  2082. goto loser;
  2083. }
  2085. fmtSigned = PR_smprintf(fmt, target->m_id, 
  2086.                                                 signerCertResID, 
  2087.                                                 issuerCertResID,
  2088.                                                 genericOCSPWarning);
  2089. PR_Free(fmt);
  2090. }
  2091. break;
  2093. /* This case handles both expired and not yet valid certs */
  2094. case SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE:
  2095. {
  2096. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_expired_issuer_cert", &fmt);
  2097. if (rv != SSM_SUCCESS) {
  2098. goto loser;
  2099. }
  2100.                         fmtSigned = PR_smprintf(fmt, genericOCSPWarning);
  2101.                         PR_FREEIF(fmt);
  2102. }
  2103. break;
  2105. /* Cert address mismatch */
  2106. case SEC_ERROR_CERT_ADDR_MISMATCH:
  2107. {
  2108. char * signer_email = NULL;
  2109. char * signerCN = NULL;
  2110. CERTCertificate *signerCert = NULL;
  2111. SSMResourceCert *signerCertRes = NULL;
  2112. PRInt32 signerCertResID;
  2113. SECItem * item = NULL;
  2114. char *signTime = NULL;
  2116. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_addr_mismatch", &fmt);
  2117. if (rv != SSM_SUCCESS) {
  2118. goto loser;
  2119. }
  2121. /* Get the signer cert */
  2122. signerCert = get_signer_cert(res);
  2123. if (!signerCert) {
  2124. goto loser;
  2125. }
  2127. /* Get the signer common name */
  2128. signerCN = CERT_GetCommonName(&signerCert->subject);
  2130. /* Get the signing time */
  2131. item = SEC_PKCS7GetSigningTime(res->signedP7CInfoRes->m_cinfo);
  2132. signTime = (item ? DER_UTCTimeToAscii(item) : 0);
  2134. /* Create resources for these certs */
  2135. rv = SSM_CreateResource(SSM_RESTYPE_CERTIFICATE,
  2136. signerCert,
  2137. SSMRESOURCE(res)->m_connection,
  2138. (long *) &signerCertResID,
  2139. (SSMResource**)&signerCertRes);
  2140. if (rv != SSM_SUCCESS) {
  2141. goto loser;
  2142. }
  2144. /* Get the signers email address */
  2145. if (res->signedP7CInfoRes) {
  2146. signer_email = SEC_PKCS7GetSignerEmailAddress(res->signedP7CInfoRes->m_cinfo);
  2147. }
  2149. if (!signer_email && res->encryptedP7CInfoRes) {
  2150. signer_email = SEC_PKCS7GetSignerEmailAddress(res->encryptedP7CInfoRes->m_cinfo);
  2151. }
  2153. fmtSigned = PR_smprintf(fmt,res->senderAddr,signer_email,signerCN,signTime, target->m_id, signerCertResID);
  2154. PR_Free(fmt);
  2155. PR_FREEIF(signer_email);
  2156. PR_FREEIF(signTime);
  2157. }
  2158. break;
  2159. default:
  2160. {
  2161. CERTCertificate *signerCert = NULL;
  2162. SSMStatus rv = SSM_SUCCESS;
  2163. PrefSet* prefs = NULL;
  2164. char *responderURL = NULL;
  2166. prefs = res->super.m_connection->m_prefs;
  2168. if (SSM_IsOCSPEnabled(res->super.m_connection)) {
  2169.     
  2170.         responderURL = SSM_GetOCSPURL(get_signer_cert(res), prefs);
  2171. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_ocsp_error", &fmt);
  2172. if (rv != SSM_SUCCESS) {
  2173. goto loser;
  2174. }
  2175. fmtSigned = PR_smprintf(fmt,responderURL,res->verifyError);
  2176. PR_Free(fmt);
  2177. PR_Free(responderURL);
  2178. } else {
  2179. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_signed_unknown_error", &fmtSigned);
  2180. if (rv != SSM_SUCCESS) {
  2181. goto loser;
  2182. }
  2183. }
  2184. }
  2185. break;
  2186. /* XXX Missing the case where the issuer cert has been revoked XXX */
  2187. }
  2188. }
  2189. }
  2190.     PR_FREEIF(genericOCSPWarning);
  2191. /* Now deal with the encrypted part */
  2192. if (!res->encrypted_b) {
  2193. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_not_encrypted", &fmtEncrypted);
  2194. if (rv != SSM_SUCCESS) {
  2195. goto loser;
  2196. }
  2197. } else {
  2198. if (res->decodeError == 0) {
  2199. SECAlgorithmID *algid;
  2200. SECOidTag algtag;
  2201. const char *alg_name;
  2202. char *encryption_level;
  2203. int key_size;
  2205. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_encrypted", &fmt);
  2206. if (rv != SSM_SUCCESS) {
  2207. goto loser;
  2208. }
  2209.             if (res->encryptedP7CInfoRes == NULL) {
  2210. algid = SEC_PKCS7GetEncryptionAlgorithm(res->signedP7CInfoRes->m_cinfo);
  2211.             } else {
  2212. algid = SEC_PKCS7GetEncryptionAlgorithm(res->encryptedP7CInfoRes->m_cinfo);
  2213.             }
  2214. if (!algid) {
  2215. goto loser;
  2216. }
  2218. algtag = SECOID_GetAlgorithmTag(algid);
  2219. alg_name = SECOID_FindOIDTagDescription(algtag);
  2220.             if (res->encryptedP7CInfoRes) {
  2221. key_size = SEC_PKCS7GetKeyLength(res->encryptedP7CInfoRes->m_cinfo);
  2222.             } else {
  2223. key_size = SEC_PKCS7GetKeyLength(res->signedP7CInfoRes->m_cinfo);
  2224.             }
  2225. if (key_size == 40) {
  2226. SSM_GetUTF8Text(cx, "low_grade_encryption", &encryption_level);
  2227. } else if (key_size == 56 || key_size == 64) {
  2228. SSM_GetUTF8Text(cx, "medium_grade_encryption", &encryption_level);
  2229. } else {
  2230. SSM_GetUTF8Text(cx, "high_grade_encryption", &encryption_level);
  2231. }
  2233. fmtEncrypted = PR_smprintf(fmt, encryption_level, key_size, alg_name);
  2234. PR_Free(fmt);
  2235. } else {
  2236. switch (res->decodeError) {
  2237. case SEC_ERROR_NOT_A_RECIPIENT:
  2238. {
  2239. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_encrypted_no_recipient", &fmtEncrypted);
  2240. if (rv != SSM_SUCCESS) {
  2241. goto loser;
  2242. }
  2243. }
  2244. break;
  2245. case SEC_ERROR_BAD_PASSWORD:
  2246. {
  2247. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_encrypted_bad_password", &fmtEncrypted);
  2248. if (rv != SSM_SUCCESS) {
  2249. goto loser;
  2250. }
  2251. }
  2252. break;
  2253. /* XXX Missing cases for contents altered and encryption strength mismatch XXX */
  2254. default:
  2255. {
  2256. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_message_encrypted_unknown_error", &fmtEncrypted);
  2257. if (rv != SSM_SUCCESS) {
  2258. goto loser;
  2259. }
  2260. }
  2261. }
  2262. }
  2263. }
  2265. /* Output the stirngs */
  2266. PR_FREEIF(cx->m_result);
  2267. cx->m_result = PR_smprintf("%s%s", fmtSigned, fmtEncrypted);
  2268. PR_Free(fmtSigned);
  2269. PR_Free(fmtEncrypted);
  2270. return SSM_SUCCESS;
  2272. loser:
  2273. PR_FREEIF(fmt);
  2274. PR_FREEIF(fmtSigned);
  2275. PR_FREEIF(fmtEncrypted);
  2276. return SSM_FAILURE;
  2277. }
  2279. SSMStatus sa_compose(SSMTextGenContext *cx)
  2280. {
  2281.     SSMStatus rv = SSM_SUCCESS;
  2282.     SSMResource *target = NULL;
  2283.     SSMSecurityAdvisorContext* res = NULL;
  2284. char *fmt = NULL, *fmtSigned = NULL, *fmtEncrypted = NULL;
  2285. CERTCertificate *cert = NULL;
  2286. char *certNickname = NULL;
  2287. int err;
  2288. char ** errCerts = NULL;
  2289. int numErrCerts, i;
  2291.     /* get the connection object */
  2292.     target = SSMTextGen_GetTargetObject(cx);
  2293.     PR_ASSERT(target != NULL);
  2294.     res = (SSMSecurityAdvisorContext*)target;
  2296. /* Get the default email certificate */
  2297. rv = PREF_GetStringPref(target->m_connection->m_prefs, "security.default_mail_cert",
  2298.                  &certNickname);
  2299. if (rv != PR_SUCCESS) {
  2300. goto loser;
  2301. }
  2303. /* Deal with the signing part first */
  2304. if (!res->signthis) {
  2305. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_not_to_be_signed", &fmtSigned);
  2306. if (rv != SSM_SUCCESS) {
  2307. goto loser;
  2308. }
  2309. } else {
  2310. /* Do we have a default cert installed */
  2311. if (!certNickname) {
  2312. /* We have no signing cert */
  2313. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_sign_no_cert", &fmtSigned);
  2314. if (rv != SSM_SUCCESS) {
  2315. goto loser;
  2316. }
  2317. } else {
  2318. cert = CERT_FindUserCertByUsage(target->m_connection->m_certdb, 
  2319. certNickname, 
  2320. certUsageEmailSigner,
  2321. PR_FALSE,
  2322. target->m_connection);
  2323. if (!cert){
  2324. /* We have no signing cert */
  2325. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_sign_no_cert", &fmtSigned);
  2326. if (rv != SSM_SUCCESS) {
  2327. goto loser;
  2328. }
  2329. } else {
  2330. /* Verify the cert */
  2331. if (CERT_VerifyCert(target->m_connection->m_certdb,
  2332. cert,
  2333. PR_TRUE, 
  2334. certUsageEmailSigner,
  2335. PR_Now(),
  2336. target->m_connection,
  2337. NULL) == SECSuccess) {
  2338. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_can_be_signed", &fmtSigned);
  2339. if (rv != SSM_SUCCESS) {
  2340. goto loser;
  2341. }
  2342. } else {
  2343. err = PR_GetError();
  2344. switch (err) {
  2345. case SEC_ERROR_EXPIRED_CERTIFICATE:
  2346. {
  2347. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_sign_expired_cert", &fmtSigned);
  2348. if (rv != SSM_SUCCESS) {
  2349. goto loser;
  2350. }
  2351. }
  2352. break;
  2353. case SEC_ERROR_REVOKED_CERTIFICATE:
  2354. {
  2355. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_sign_revoked_cert", &fmtSigned);
  2356. if (rv != SSM_SUCCESS) {
  2357. goto loser;
  2358. }
  2359. }
  2360. break;
  2361. case SEC_ERROR_CERT_USAGES_INVALID:
  2362. {
  2363. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_sign_invalid_cert", &fmtSigned);
  2364. if (rv != SSM_SUCCESS) {
  2365. goto loser;
  2366. }
  2367. }
  2368. break;
  2369. default:
  2370. {
  2371. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_sign_unknown_error", &fmtSigned);
  2372. if (rv != SSM_SUCCESS) {
  2373. goto loser;
  2374. }
  2375. }
  2376. }
  2377. }
  2378. }
  2379. }
  2380. }
  2382. /* Now deal with the encryption part */
  2383. if (!res->encryptthis) {
  2384. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_not_to_be_encrypted", &fmtEncrypted);
  2385. if (rv != SSM_SUCCESS) {
  2386. goto loser;
  2387. }
  2388. } else {
  2389. if (!res->numRecipients) {
  2390. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_no_recipients", &fmtEncrypted);
  2391. if (rv != SSM_SUCCESS) {
  2392. goto loser;
  2393. }
  2394. } else {
  2395. /* Do we have a default cert installed */
  2396. if (!certNickname) {
  2397. /* We have no cert */
  2398. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_no_cert", &fmtEncrypted);
  2399. if (rv != SSM_SUCCESS) {
  2400. goto loser;
  2401. }
  2402. } else {
  2403. cert = CERT_FindUserCertByUsage(target->m_connection->m_certdb,
  2404. certNickname,
  2405. certUsageEmailRecipient,
  2406. PR_FALSE,
  2407. target->m_connection);
  2408. if (!cert) {
  2409. /* We have no cert */
  2410. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_no_cert", &fmtEncrypted);
  2411. if (rv != SSM_SUCCESS) {
  2412. goto loser;
  2413. }
  2414. } else {
  2415. /* Verify the cert */
  2416. if (CERT_VerifyCert(target->m_connection->m_certdb,
  2417. cert,
  2418. PR_TRUE, 
  2419. certUsageEmailRecipient,
  2420. PR_Now(),
  2421. target->m_connection,
  2422. NULL) == SECSuccess) {
  2423. errCerts = (char **) PR_CALLOC(sizeof(char*)*res->numRecipients);
  2424. if (!errCerts) {
  2425. goto loser;
  2426. }
  2427. /* Verify the recipient certs */
  2428. for (i=0,numErrCerts=0; i<res->numRecipients; i++) {
  2429. cert = CERT_FindCertByEmailAddr(target->m_connection->m_certdb, res->recipients[i]);
  2430. if (!cert) {
  2431. errCerts[numErrCerts++] = PL_strdup(res->recipients[i]);
  2432. continue;
  2433. }
  2434. if (CERT_VerifyCertNow(target->m_connection->m_certdb,
  2435.    cert,
  2436.    PR_TRUE,
  2437.    certUsageEmailRecipient,
  2438.    target->m_connection) == SECFailure) {
  2439. errCerts[numErrCerts++] = PL_strdup(res->recipients[i]);
  2440. continue;
  2441. }
  2442. CERT_DestroyCertificate(cert);
  2443. }
  2444. if (!numErrCerts) {
  2445. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_can_be_encrypted", &fmtEncrypted);
  2446. if (rv != SSM_SUCCESS) {
  2447. goto loser;
  2448. }
  2449. } else {
  2450. char *option = NULL;
  2451. char *out = NULL;
  2453. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_bad_recipients", &fmt);
  2454. if (rv != SSM_SUCCESS) {
  2455. goto loser;
  2456. }
  2458. for (i=0; i < numErrCerts; i++) {
  2459. option = PR_smprintf("<option selected>%s</option>n", errCerts[i]);
  2460. SSM_ConcatenateUTF8String(&out, option);
  2461. }
  2463. fmtEncrypted = PR_smprintf(fmt, target->m_id, numErrCerts, out);
  2464. PR_Free(fmt);
  2465. }
  2466. } else {
  2467. err = PR_GetError();
  2468. switch (err) {
  2469. case SEC_ERROR_EXPIRED_CERTIFICATE:
  2470. {
  2471. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_expired_cert", &fmtEncrypted);
  2472. if (rv != SSM_SUCCESS) {
  2473. goto loser;
  2474. }
  2475. }
  2476. break;
  2477. case SEC_ERROR_REVOKED_CERTIFICATE:
  2478. {
  2479. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_revoked_cert", &fmtEncrypted);
  2480. if (rv != SSM_SUCCESS) {
  2481. goto loser;
  2482. }
  2483. }
  2484. break;
  2485. case SEC_ERROR_CERT_USAGES_INVALID:
  2486. {
  2487. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_invalid_cert", &fmtEncrypted);
  2488. if (rv != SSM_SUCCESS) {
  2489. goto loser;
  2490. }
  2491. }
  2492. break;
  2493. default:
  2494. {
  2495. rv = SSM_GetAndExpandTextKeyedByString(cx, "sa_compose_encrypted_unknown_error", &fmtEncrypted);
  2496. if (rv != SSM_SUCCESS) {
  2497. goto loser;
  2498. }
  2499. }
  2500. }
  2501. }
  2502. }
  2503. }
  2504. }
  2505. }
  2507. /* Output the stirngs */
  2508.     PR_FREEIF(cx->m_result);
  2509. cx->m_result = PR_smprintf("%s%s", fmtSigned, fmtEncrypted);
  2510. PR_Free(fmtSigned);
  2511. PR_Free(fmtEncrypted);
  2512. return SSM_SUCCESS;
  2514. loser:
  2515. PR_FREEIF(fmt);
  2516. PR_FREEIF(fmtSigned);
  2517. PR_FREEIF(fmtEncrypted);
  2518. return SSM_FAILURE;
  2519. }
  2521. SSMStatus SSMSecurityAdvisorContext_sa_selected_item(SSMTextGenContext* cx)
  2522. {
  2523.     SSMStatus rv = SSM_SUCCESS;
  2524.     SSMResource *target = NULL;
  2525.     SSMSecurityAdvisorContext* res = NULL;
  2527.     /* get the connection object */
  2528.     target = SSMTextGen_GetTargetObject(cx);
  2529.     PR_ASSERT(target != NULL);
  2530.     res = (SSMSecurityAdvisorContext*)target;
  2532. /* Load the correct page */
  2533. switch (res->infoContext) 
  2534. {
  2535. case SSM_NOINFO:
  2536. rv = sa_noinfo(cx);
  2537. break;
  2538. case SSM_BROWSER:
  2539. rv = sa_navigator(cx);
  2540. break;
  2541. case SSM_SNEWS_MESSAGE:
  2542. case SSM_NEWS_MESSAGE:
  2543. case SSM_MAIL_MESSAGE:
  2544. rv = sa_message(cx);
  2545. break;
  2546. case SSM_COMPOSE:
  2547. rv = sa_compose(cx);
  2548. break;
  2549. default:
  2550. rv = SSM_FAILURE;
  2551. break;
  2552. }
  2553. goto done;
  2554. done:
  2555.     return rv;
  2556. }
  2558. SSMStatus 
  2559. SSMSecurityAdvisorContext_GetPrefListKeywordHandler(SSMTextGenContext* cx)
  2560. {
  2561.     SSMStatus rv = SSM_SUCCESS;
  2562.     SSMSecurityAdvisorContext* adv = NULL;
  2563.     PrefSet* prefs = NULL;
  2564.     char* subboolfmt;
  2565.     char* subfmt;
  2566.     char* fmt;
  2567.     PRBool boolval;
  2568.     char* strval = NULL;
  2569.     char* str1 = NULL;
  2570.     char* str2 = NULL;
  2571.     char* str3 = NULL;
  2572.     char* str4 = NULL;
  2573.     char* str5 = NULL;
  2574.     char* str6 = NULL;
  2575.     char* str7 = NULL;
  2576.     char* str8 = NULL;
  2577.     char* str9 = NULL;
  2578.     char* str10 = NULL;
  2579.     char* str11 = NULL;
  2581.     if ((cx == NULL) || (cx->m_request == NULL) || (cx->m_result == NULL)) {
  2582.         goto loser;
  2583.     }
  2585.     adv = (SSMSecurityAdvisorContext*)SSMTextGen_GetTargetObject(cx);
  2586.     if ((adv == NULL) ||
  2587.         !SSM_IsA((SSMResource*)adv, SSM_RESTYPE_SECADVISOR_CONTEXT)) {
  2588.         goto loser;
  2589.     }
  2591.     /* get the prefs object */
  2592.     if ((adv->super.m_connection == NULL) || 
  2593.         (adv->super.m_connection->m_prefs == NULL)) {
  2594.         goto loser;
  2595.     }
  2596.     prefs = adv->super.m_connection->m_prefs;
  2598.     /* strings and formats */
  2599.     subboolfmt = "var %1$s = %2$s;n";
  2600.     subfmt = "var %1$s = "%2$s";n";
  2601.     /* since nickname may contain ', I really should use " for quotes */
  2602.     fmt = "%1$s%2$s%3$s%4$s%5$s%6$s%7$s%8$s%9$s%10$s%11$s";
  2604.     /* make sure all the right default values are enforced */
  2605.     rv = PREF_GetBoolPref(prefs, "security.enable_ssl2", &boolval);
  2606.     if ((rv == SSM_SUCCESS) && (boolval == PR_FALSE)) {
  2607.         str1 = PR_smprintf(subboolfmt, SSL2_SPK, "false");
  2608.     }
  2609.     else { /* default */
  2610.         str1 = PR_smprintf(subboolfmt, SSL2_SPK, "true");
  2611.     }
  2613.     rv = PREF_GetBoolPref(prefs, "security.enable_ssl3", &boolval);
  2614.     if ((rv == SSM_SUCCESS) && (boolval == PR_FALSE)) {
  2615.         str2 = PR_smprintf(subboolfmt, SSL3_SPK, "false");
  2616.     }
  2617.     else { /* default */
  2618.         str2 = PR_smprintf(subboolfmt, SSL3_SPK, "true");
  2619.     }
  2621.     rv = PREF_GetStringPref(prefs, "security.default_personal_cert", &strval);
  2622.     if ((strval != NULL) && (PL_strcmp(strval, "Select Automatically") == 0)) {
  2623.         str3 = PR_smprintf(subboolfmt, CLIENT_AUTH_SPK, "true");
  2624.     }
  2625.     else { /* default */
  2626.         str3 = PR_smprintf(subboolfmt, CLIENT_AUTH_SPK, "false");
  2627.     }
  2629.     rv = PREF_GetStringPref(prefs, "security.default_mail_cert", &strval);
  2630.     if (strval != NULL) {
  2631.         str4 = PR_smprintf(subfmt, EMAIL_CERT_SPK, strval);
  2632.     }
  2633.     else {
  2634.         str4 = PR_smprintf(subfmt, EMAIL_CERT_SPK, "");
  2635.     }
  2637.     rv = PREF_GetBoolPref(prefs, "security.warn_entering_secure", &boolval);
  2638.     if ((rv == SSM_SUCCESS) && (boolval == PR_FALSE)) {
  2639.         str5 = PR_smprintf(subboolfmt, WARN_ENTER_SECURE_SPK, "false");
  2640.     }
  2641.     else { /* default */
  2642.         str5 = PR_smprintf(subboolfmt, WARN_ENTER_SECURE_SPK, "true");
  2643.     }
  2645.     rv = PREF_GetBoolPref(prefs, "security.warn_leaving_secure", &boolval);
  2646.     if ((rv == SSM_SUCCESS) && (boolval == PR_FALSE)) {
  2647.         str6 = PR_smprintf(subboolfmt, WARN_LEAVE_SECURE_SPK, "false");
  2648.     }
  2649.     else { /* default */
  2650.         str6 = PR_smprintf(subboolfmt, WARN_LEAVE_SECURE_SPK, "true");
  2651.     }
  2653.     rv = PREF_GetBoolPref(prefs, "security.warn_viewing_mixed", &boolval);
  2654.     if ((rv == SSM_SUCCESS) && (boolval == PR_FALSE)) {
  2655.         str7 = PR_smprintf(subboolfmt, WARN_VIEW_MIXED_SPK, "false");
  2656.     }
  2657.     else { /* default */
  2658.         str7 = PR_smprintf(subboolfmt, WARN_VIEW_MIXED_SPK, "true");
  2659.     }
  2661.     rv = PREF_GetBoolPref(prefs, "security.warn_submit_insecure", &boolval);
  2662.     if ((rv == SSM_SUCCESS) && (boolval == PR_FALSE)) {
  2663.         str8 = PR_smprintf(subboolfmt, WARN_SUBMIT_INSECURE_SPK, "false");
  2664.     }
  2665.     else { /* default */
  2666.         str8 = PR_smprintf(subboolfmt, WARN_SUBMIT_INSECURE_SPK, "true");
  2667.     }
  2669.     rv = PREF_GetBoolPref(prefs, "mail.encrypt_outgoing_mail", &boolval);
  2670.     if ((rv == SSM_SUCCESS) && (boolval == PR_TRUE)) {
  2671.         str9 = PR_smprintf(subboolfmt, ENCRYPT_MAIL_SPK, "true");
  2672.     }
  2673.     else { /* default */
  2674.         str9 = PR_smprintf(subboolfmt, ENCRYPT_MAIL_SPK, "false");
  2675.     }
  2677.     rv = PREF_GetBoolPref(prefs, "mail.crypto_sign_outgoing_mail", &boolval);
  2678.     if ((rv == SSM_SUCCESS) && (boolval == PR_TRUE)) {
  2679.         str10 = PR_smprintf(subboolfmt, SIGN_MAIL_SPK, "true");
  2680.     }
  2681.     else { /* default */
  2682.         str10 = PR_smprintf(subboolfmt, SIGN_MAIL_SPK, "false");
  2683.     }
  2685.     rv = PREF_GetBoolPref(prefs, "mail.crypto_sign_outgoing_news", &boolval);
  2686.     if ((rv == SSM_SUCCESS) && (boolval == PR_TRUE)) {
  2687.         str11 = PR_smprintf(subboolfmt, SIGN_NEWS_SPK, "true");
  2688.     }
  2689.     else { /* default */
  2690.         str11 = PR_smprintf(subboolfmt, SIGN_NEWS_SPK, "false");
  2691.     }
  2692.     PR_FREEIF(cx->m_result);
  2693.     cx->m_result = PR_smprintf(fmt, str1, str2, str3, str4, str5, str6, str7,
  2694.                                str8, str9, str10, str11);
  2695.     SSM_DebugUTF8String("security advisor prefs list", cx->m_result);
  2697.     goto done;
  2698. loser:
  2699.     if (rv == SSM_SUCCESS) {
  2700.         rv = SSM_FAILURE;
  2701.     }
  2702. done:
  2703.     PR_FREEIF(str1);
  2704.     PR_FREEIF(str2);
  2705.     PR_FREEIF(str3);
  2706.     PR_FREEIF(str4);
  2707.     PR_FREEIF(str5);
  2708.     PR_FREEIF(str6);
  2709.     PR_FREEIF(str7);
  2710.     PR_FREEIF(str8);
  2711.     PR_FREEIF(str9);
  2712.     PR_FREEIF(str10);
  2713.     PR_FREEIF(str11);
  2715.     return SSM_SUCCESS;
  2716. }
  2718. SSMStatus
  2719. SSM_FreeTarget(SSMTextGenContext *cx)
  2720. {
  2721.     SSMResource *res = NULL;
  2723.     res = SSMTextGen_GetTargetObject(cx);
  2724.     if (res != NULL) {
  2725.         SSM_FreeResource(res);
  2726.     }
  2727.     return SSM_SUCCESS;
  2728. }
  2731. #if 0
  2732. /*---- Functions for handling Java principal certs ----*/
  2733. static SSMStatus ssm_parse_token(char* start, char** dest)
  2734. {
  2735.     char* openQuote = NULL;
  2736.     char* closeQuote = NULL;
  2738.     *dest = NULL;
  2740.     openQuote = strchr(start, '"');
  2741.     if (openQuote == NULL) {
  2742.         return SSM_FAILURE;
  2743.     }
  2745.     closeQuote = strchr(openQuote+1, '"');
  2746.     if (closeQuote == NULL) {
  2747.         return SSM_FAILURE;
  2748.     }
  2750.     *dest = (char*)PR_Calloc(closeQuote-openQuote, sizeof(char));
  2751.     if (*dest == NULL) {
  2752.         return SSM_FAILURE;
  2753.     }
  2755.     /* copy the string */
  2756.     memcpy(*dest, openQuote+1, closeQuote-openQuote-1);
  2757.     
  2758.     return SSM_SUCCESS;
  2759. }
  2761. static SSMStatus ssm_parse_principals(char* principalsData, 
  2762.                                       char*** principals, PRIntn* size)
  2763. {
  2764.     SSMStatus rv;
  2765.     PRIntn i = 1;
  2766.     char* start = NULL;
  2768.     *principals = NULL;
  2770.     /* first check whether the data is empty */
  2771.     if (*principalsData == '') {
  2772.         /* this is not a failure */
  2773.         *size = 0;
  2774.         return SSM_SUCCESS;
  2775.     }
  2777.     /* data looks like ""Netscape", "AOL"": tokenize the string */
  2778.     /* first determine the number of tokens */
  2779.     start = principalsData;
  2780.     while ((start = strchr(start+1, ',')) != NULL) {
  2781.         i++;
  2782.     }
  2784.     *principals = (char**)PR_Calloc(i, sizeof(char*));
  2785.     if (*principals == NULL) {
  2786.         return SSM_FAILURE;
  2787.     }
  2788.     *size = i;
  2790.     /* parse the tokens and store them in principals */
  2791.     for (start = principalsData, i = 0; start != NULL; 
  2792.          start = strchr(start, ','), i++) {
  2793.         rv = ssm_parse_token(start, &((*principals)[i]));
  2794.         if (rv != SSM_SUCCESS) {
  2795.             goto loser;
  2796.         }
  2797.     }
  2798.     return SSM_SUCCESS;
  2799.  loser:
  2800.     for (i = 0; i < *size; i++) {
  2801.         PR_FREEIF((*principals)[i]);
  2802.     }
  2803.     return SSM_FAILURE;
  2804. }
  2806. static SSMStatus ssm_retrieve_principals(SSMSecurityAdvisorContext* adv,
  2807.                                          char*** principals, PRIntn* size)
  2808. {
  2809.     SSMStatus rv;
  2810.     SingleNumMessage request;
  2811.     CMTItem message;
  2813.     /* first, clear data */
  2814.     PR_FREEIF(adv->m_principalsData);
  2816.     /* pack the request */
  2817.     request.value = (PRIntn)adv->super.m_id;
  2818.     if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) !=
  2819.         CMTSuccess) {
  2820.         return SSM_FAILURE;
  2821.     }
  2822.     message.type = SSM_EVENT_MESSAGE | SSM_GET_JAVA_PRINCIPALS_EVENT;
  2824.     /* send the message through the control out queue */
  2825.     SSM_SendQMessage(adv->super.m_connection->m_controlOutQ, 
  2826.                      SSM_PRIORITY_NORMAL, message.type, message.len,
  2827.                      (char*)message.data, PR_TRUE);
  2829.     /* awkward way of blocking, but can't be helped */
  2830.     SSM_LockUIEvent(SSMRESOURCE(adv));
  2831.     while (adv->m_principalsData == NULL) {
  2832.         SSM_WaitUIEvent(SSMRESOURCE(adv), PR_INTERVAL_NO_TIMEOUT);
  2833.     }
  2834.     SSM_UnlockUIEvent(SSMRESOURCE(adv));
  2836.     /* parse the date that came from the plugin */
  2837.     rv = ssm_parse_principals(adv->m_principalsData, principals, size);
  2839.     return rv;
  2840. }
  2842. SSMStatus SSM_JavaPrincipalsKeywordHandler(SSMTextGenContext* cx)
  2843. {
  2844.     SSMStatus rv;
  2845.     SSMSecurityAdvisorContext* adv = NULL;
  2846.     char* prefix = NULL;
  2847.     char* wrapper = NULL;
  2848.     char* suffix = NULL;
  2849.     char* prefixKey = NULL;
  2850.     char* wrapperKey = NULL;
  2851.     char* suffixKey = NULL;
  2852.     char* tmpStr = NULL;
  2853.     char* finalStr = NULL;
  2854.     const PRIntn CERT_PREFIX = 0;
  2855.     const PRIntn CERT_WRAPPER = 1;
  2856.     const PRIntn CERT_SUFFIX = 2;
  2857.     PRIntn i;
  2858. #if 0
  2859.     char* principals[5] = {"Macromedia", "NetCenter", "Sun Microsystems",
  2860.                            "MindSpring", "Hong Kong Telecom"};
  2861. #else
  2862.     char** principals = NULL;
  2863.     PRIntn size;
  2864. #endif
  2866.     if ((cx == NULL) || (cx->m_result == NULL)) {
  2867.         goto loser;
  2868.     }
  2870.     cx->m_result = NULL; /* in case we fail */
  2872.     adv = (SSMSecurityAdvisorContext*)SSMTextGen_GetTargetObject(cx);
  2873.     if ((adv == NULL) ||
  2874.         !SSM_IsA((SSMResource*)adv, SSM_RESTYPE_SECADVISOR_CONTEXT)) {
  2875.         goto loser;
  2876.     }
  2878.     /* retrieve the principals in string form from the plugin */
  2879.     rv = ssm_retrieve_principals(adv, &principals, &size);
  2880.     if (rv != SSM_SUCCESS) {
  2881.         goto loser;
  2882.     }
  2884.     prefixKey = (char*)SSM_At(cx->m_params, CERT_PREFIX);
  2885.     wrapperKey = (char*)SSM_At(cx->m_params, CERT_WRAPPER);
  2886.     suffixKey = (char*)SSM_At(cx->m_params, CERT_SUFFIX);
  2888.     rv = SSM_GetAndExpandTextKeyedByString(cx, prefixKey, &prefix);
  2889.     if (rv != SSM_SUCCESS) {
  2890.         goto loser;
  2891.     }
  2892.     
  2893.     rv = SSM_GetAndExpandTextKeyedByString(cx, suffixKey, &suffix);
  2894.     if (rv != SSM_SUCCESS) {
  2895.         goto loser;
  2896.     }
  2898.     finalStr = PL_strdup(prefix);
  2899.     if (finalStr == NULL) {
  2900.         goto loser;
  2901.     }
  2903.     /* add individual certs */
  2904.     if (principals != NULL) {
  2905.         rv = SSM_GetAndExpandTextKeyedByString(cx, wrapperKey, &wrapper);
  2906.         if (rv != SSM_SUCCESS) {
  2907.             goto loser;
  2908.         }
  2910.         for (i = 0; i < size; i++) {
  2911.             tmpStr = PR_smprintf(wrapper, principals[i]);
  2912.             if (SSM_ConcatenateUTF8String(&finalStr, tmpStr) != SSM_SUCCESS) {
  2913.                 goto loser;
  2914.             }
  2915.             PR_Free(tmpStr);
  2916.             tmpStr = NULL;
  2917.         }
  2918.     }
  2920.     rv = SSM_ConcatenateUTF8String(&finalStr, suffix);
  2921.     if (rv != SSM_SUCCESS) {
  2922.         goto loser;
  2923.     }
  2925.     cx->m_result = finalStr;
  2927.     goto done;
  2928. loser:
  2929.     if (rv == SSM_SUCCESS) {
  2930.         rv = SSM_FAILURE;
  2931.     }
  2932.     PR_FREEIF(finalStr);
  2933.     PR_FREEIF(tmpStr);
  2934. done:
  2935.     PR_FREEIF(prefix);
  2936.     PR_FREEIF(wrapper);
  2937.     PR_FREEIF(suffix);
  2938.     return rv;
  2939. }
  2941. void SSM_HandleGetJavaPrincipalsReply(SSMControlConnection* ctrl,
  2942.                                       SECItem* message)
  2943. {
  2944.     SSMStatus rv;
  2945.     GetJavaPrincipalsReply reply;
  2946.     SSMResource* res = NULL;
  2947.     SSMSecurityAdvisorContext* adv = NULL;
  2949.     if (CMT_DecodeMessage(GetJavaPrincipalsReplyTemplate, &reply, 
  2950.                           (CMTItem*)message) != CMTSuccess) {
  2951.         goto loser;
  2952.     }
  2954.     rv = SSMControlConnection_GetResource(ctrl, reply.resID, &res);
  2955.     if (rv != PR_SUCCESS || res == NULL) {
  2956.         goto loser;
  2957.     }
  2959.     /* make sure it is a Security Advisor context */
  2960.     if (!SSM_IsA(res, SSM_RESTYPE_SECADVISOR_CONTEXT)) {
  2961.         goto loser;
  2962.     }
  2964.     adv = (SSMSecurityAdvisorContext*)res;
  2965.     SSM_LockUIEvent(res);
  2966.     adv->m_principalsData = reply.principals;
  2967.     /* it will be freed by the Security Advisor */
  2968.     if (adv->m_principalsData == NULL) {
  2969.         adv->m_principalsData = PL_strdup("");
  2970.     }
  2971.     SSM_NotifyUIEvent(res);
  2972.     SSM_UnlockUIEvent(res);
  2974.     return;
  2975. loser:
  2976.     /* XXX we can't really wake up the waiting Security Advisor object 
  2977.      *     because we don't know which resource to wake up.  Bad.
  2978.      */
  2979.     PR_FREEIF(reply.principals);
  2980.     return;
  2981. }
  2982. #endif
  2984. /* platform-dependent names for signed.db */
  2985. #ifdef XP_UNIX
  2986. #define SIGNED "/signedapplet.db"
  2987. #else
  2988. #ifdef XP_MAC
  2989. #define SIGNED ":SignedAppletDB"
  2990. #else
  2991. #define SIGNED "\signed.db"
  2992. #endif
  2993. #endif
  2995. SSMStatus SSM_RemovePrivilegesHandler(HTTPRequest* req)
  2996. {
  2997.     SSMResource* res = NULL;
  2998.     char* buttonValue;
  2999.     SSMStatus rv;
  3001.     res = (req->target) ? req->target : (SSMResource*)req->ctrlconn;
  3003.     rv = SSM_HTTPParamValue(req, "OK", &buttonValue);
  3004.     if (rv == SSM_SUCCESS) {
  3005.         /* do action */
  3006.         char* signeddb;
  3008.         signeddb = PR_smprintf("%s%s", req->ctrlconn->m_dirRoot, SIGNED);
  3009.         /* XXX we delete the signed.db file here, but we do not actively
  3010.          *     check the return value.  There may be failures (file does
  3011.          *     not exist, file may be already open, etc.) but we do not
  3012.          *     have other recourses.  Sigh.
  3013.          */
  3014.         PR_Delete(signeddb);
  3015.         PR_Free(signeddb);
  3016.     }
  3017.     else {
  3018.         rv = SSM_HTTPParamValue(req, "Cancel", &buttonValue);
  3019.     }
  3021.     if (rv != SSM_SUCCESS) {
  3022.         rv = SSM_ERR_NO_BUTTON;
  3023.         goto done;
  3024.     }
  3025.  done:
  3026.     rv = SSM_HTTPDefaultCommandHandler(req);
  3027.     return rv;
  3028. }
  3030. static PRBool 
  3031. ocsplist_is_default_signer(CERTCertificate *cert,
  3032.                            SSMDefaultOCSPRespondersList *potResponders)
  3033. {
  3034.     if (!cert->nickname) {
  3035.         return PR_FALSE;
  3036.     }
  3037.     return (PL_strcmp(cert->nickname, potResponders->defaultSigner) == 0) ? 
  3038.             PR_TRUE : PR_FALSE;
  3039. }
  3041. static PRBool ocsplist_include_cert(CERTCertificate *cert)
  3042. {
  3043.     CERTCertTrust *trust;
  3044.     char *nickname;
  3046.     trust = cert->trust;
  3047.     nickname = cert->nickname;
  3048.     
  3049.     if ( ( ( trust->sslFlags & CERTDB_INVISIBLE_CA ) ||
  3050.            (trust->emailFlags & CERTDB_INVISIBLE_CA ) ||
  3051.            (trust->objectSigningFlags & CERTDB_INVISIBLE_CA ) ) ||
  3052.          nickname == NULL) {
  3053.         return PR_FALSE;
  3054.     }
  3055.     if ((trust->sslFlags & CERTDB_VALID_CA) ||
  3056.         (trust->emailFlags & CERTDB_VALID_CA) ||
  3057.         (trust->objectSigningFlags & CERTDB_VALID_CA)) {
  3058.         return PR_TRUE;
  3059.     }
  3060.     return PR_FALSE;
  3061. }
  3064. static SECStatus ssm_get_potential_ocsp_signers(CERTCertificate *cert,
  3065.                                                 SECItem         *dbKey,
  3066.                                                 void            *arg)
  3067. {
  3068.     SSMDefaultOCSPRespondersList *potResponders;
  3069.     char *serviceURL, *nickname;
  3071.     potResponders = (SSMDefaultOCSPRespondersList*)arg;
  3073.     if (!ocsplist_include_cert(cert) ||
  3074.         ocsplist_is_default_signer(cert, potResponders)) {
  3075.         goto done;
  3076.     }
  3077.     /*
  3078.      * We've got a CA cert, now we need to figure out if it has the AIA
  3079.      * extension that points to a responder somewhere. Get our own copy
  3080.      * of the nickname.
  3081.      */
  3082.     nickname = PL_strdup(cert->nickname);
  3083.     serviceURL = CERT_GetOCSPAuthorityInfoAccessLocation(cert);
  3084.     if (serviceURL != NULL) {
  3085.         /*
  3086.          * This CA has an AIA extension so we'll bundle it with the group
  3087.          * certs that have the 
  3088.          */
  3089.         SSMSortedList_Insert(potResponders->respondersWithAIA,
  3090.                              nickname, serviceURL);
  3091.     } else {
  3092.         /*
  3093.          * This CA doesn't have an AIA extension so we lump with the
  3094.          * rest of the CA's.
  3095.          */
  3096.         SSMSortedList_Insert(potResponders->respondersWithoutAIA,
  3097.                              nickname, NULL);
  3098.     }
  3099.     
  3100.  done:
  3101.     return SECSuccess;
  3102. }
  3104. static void
  3105. ocsplist_freedata(void *data)
  3106. {
  3107.     if (data) {
  3108.         PR_Free(data);
  3109.     }
  3110. }
  3112. static void
  3113. ocsplist_freekey(void *data)
  3114. {
  3115.     ocsplist_freedata(data);
  3116. }
  3118. static SSMStatus 
  3119. ocsplist_aiacerts_enumerator(PRIntn index, void * arg, void *key,
  3120.                              void *data)
  3121. {
  3122.     SSMDefaultOCSPRespondersList *potResps;
  3123.     char *nextChunk;
  3124.     SSMStatus rv;
  3126.     potResps = (SSMDefaultOCSPRespondersList*)arg;
  3127.     nextChunk = PR_smprintf(potResps->wrapper, (char*)key, 
  3128.                             (data == NULL) ? "http://" : (char*)data);
  3129.     rv = SSM_ConcatenateUTF8String(&potResps->cx->m_result, nextChunk);
  3130.     PR_Free(nextChunk);
  3131.     return rv;
  3132. }
  3134. static SSMStatus 
  3135. ocsplist_cacerts_enumerator(PRIntn index, void * arg, void *key,
  3136.                             void *data)
  3137. {
  3138.     return ocsplist_aiacerts_enumerator(index, arg, key, data);
  3139. }
  3141. SSMStatus 
  3142. SSM_OCSPResponderList(SSMTextGenContext *cx)
  3143. {
  3144.     SECStatus srv;
  3145.     SSMDefaultOCSPRespondersList potentialResponders = {NULL, NULL, 
  3146.                                                         NULL, NULL, NULL};
  3147.     SSMSortedListFn funcs;
  3148.     char *prefix, *suffix, *tmpStr, *prefService, *prefSigner;
  3149.     SSMStatus rv;
  3151.     PR_ASSERT(cx != NULL);
  3152.     funcs.keyCompare       = certlist_compare_strings;
  3153.     funcs.freeListItemData = ocsplist_freedata;
  3154.     funcs.freeListItemKey  = ocsplist_freekey;
  3155.     potentialResponders.respondersWithAIA    = SSMSortedList_New(&funcs);
  3156.     potentialResponders.respondersWithoutAIA = SSMSortedList_New(&funcs);
  3157.     PREF_GetStringPref(cx->m_request->ctrlconn->m_prefs,
  3158.                        "security.OCSP.signingCA", 
  3159.                        &potentialResponders.defaultSigner);
  3160.     srv = SEC_TraversePermCerts(cx->m_request->ctrlconn->m_certdb,
  3161.                                 ssm_get_potential_ocsp_signers,
  3162.                                 &potentialResponders);
  3163.     if (srv == SECSuccess) {
  3164.         srv = PK11_TraverseSlotCerts(ssm_get_potential_ocsp_signers,
  3165.                                      &potentialResponders, 
  3166.                                      cx->m_request->ctrlconn);
  3167.     }
  3168.     if (srv != SECSuccess) {
  3169.         goto loser;
  3170.     }
  3171.     prefix = (char*)SSM_At(cx->m_params, 0);
  3172.     suffix = (char*)SSM_At(cx->m_params, 1);
  3173.     PR_ASSERT(prefix);
  3174.     PR_ASSERT(suffix);
  3175.     if (prefix == NULL || suffix == NULL) {
  3176.         goto loser;
  3177.     }
  3178.     rv = SSM_GetAndExpandTextKeyedByString(cx, prefix, &tmpStr);
  3179.     if (rv != SSM_SUCCESS) {
  3180.         goto loser;
  3181.     }
  3182.     rv = SSM_ConcatenateUTF8String(&cx->m_result, tmpStr);
  3183.     PR_Free(tmpStr);
  3184.     if (rv != SSM_SUCCESS) {
  3185.         goto loser;
  3186.     }
  3187.     rv = SSM_GetAndExpandTextKeyedByString(cx, "ocsp_list_wrapper",
  3188.                                            &potentialResponders.wrapper);
  3189.     if (rv != SSM_SUCCESS) {
  3190.         goto loser;
  3191.     }
  3192.     potentialResponders.cx = cx;
  3193.     /*
  3194.      * Now it's time to build the list of potential OCSP Responders.
  3195.      */
  3196.     SSMSortedList_Enumerate(potentialResponders.respondersWithAIA, 
  3197.                             ocsplist_aiacerts_enumerator, 
  3198.                             &potentialResponders);
  3199.     SSMSortedList_Enumerate(potentialResponders.respondersWithoutAIA,
  3200.                             ocsplist_cacerts_enumerator,
  3201.                             &potentialResponders);
  3202.     /*
  3203.      * If there was a default responder enabled, let's over-ride whatever
  3204.      * the cert said with what the user entered as the appropriate value.
  3205.      */
  3206.     if (PREF_GetStringPref(cx->m_request->ctrlconn->m_prefs,
  3207.                            "security.OCSP.URL", &prefService) == SSM_SUCCESS) {
  3208.         if (PREF_GetStringPref(cx->m_request->ctrlconn->m_prefs,
  3209.                       "security.OCSP.signingCA", &prefSigner) == SSM_SUCCESS) {
  3210.             tmpStr = PR_smprintf("addNewServiceURL("%1$s","%2$s");n",
  3211.                                  prefSigner, prefService);
  3212.             rv = SSM_ConcatenateUTF8String(&cx->m_result, tmpStr);
  3213.             if (rv != SSM_SUCCESS) {
  3214.                 goto loser;
  3215.             }
  3216.             PR_Free(tmpStr);
  3217.         }
  3218.     }
  3219.     rv = SSM_GetAndExpandTextKeyedByString(cx, suffix, &tmpStr);
  3220.     if (rv != SSM_SUCCESS) {
  3221.         goto loser;
  3222.     }
  3223.     rv = SSM_ConcatenateUTF8String(&cx->m_result, tmpStr);
  3224.     PR_Free(tmpStr);
  3225.     if (rv != SSM_SUCCESS) {
  3226.         goto loser;
  3227.     }
  3228.     PR_Free(potentialResponders.wrapper);
  3229.     SSMSortedList_Destroy(potentialResponders.respondersWithAIA);
  3230.     SSMSortedList_Destroy(potentialResponders.respondersWithoutAIA);
  3231.     return SSM_SUCCESS;
  3232.  loser:
  3233.     PR_FREEIF(potentialResponders.wrapper);
  3234.     if (potentialResponders.respondersWithAIA) {
  3235.         SSMSortedList_Destroy(potentialResponders.respondersWithAIA);
  3236.     }
  3237.     if (potentialResponders.respondersWithoutAIA) {
  3238.         SSMSortedList_Destroy(potentialResponders.respondersWithoutAIA);
  3239.     }
  3240.     return SSM_FAILURE;
  3241. }
  3243. SSMStatus
  3244. SSM_DisplayCRLButton(SSMTextGenContext *cx)
  3245. {
  3246.     SSMControlConnection *ctrl;
  3247.     char *crlHTML = NULL;
  3248.     SSMStatus rv;
  3250.     ctrl = SSMTextGen_GetControlConnection(cx);
  3251.     if (ctrl == NULL) {
  3252.         goto loser;
  3253.     }
  3254.     if (SSM_IsCRLPresent(ctrl)) {
  3255.         rv = SSM_GetAndExpandTextKeyedByString(cx, "crlButtonHTML", &crlHTML);
  3256.         if (rv == SSM_SUCCESS) {
  3257.             PR_FREEIF(cx->m_result);
  3258.             cx->m_result = crlHTML;
  3259.         }
  3260.     }
  3261.     return SSM_SUCCESS;
  3262.  loser:
  3263.     return SSM_FAILURE;
  3264. }
  3266. SSMStatus
  3267. SSM_ListCRLs(SSMTextGenContext *cx)
  3268. {
  3269.     SECStatus srv;
  3270.     CERTCrlHeadNode *head = NULL;
  3271.     CERTCrlNode *node;
  3272.     SSMControlConnection *ctrl;
  3273.     char *retString = NULL;
  3274.     char *currString ;
  3275.     char *emptyString = "";
  3276.     char *currCRLName = NULL;
  3277.     char *name = NULL;
  3278.     char *b64Name = NULL, *b64HTMLName;
  3279.     
  3280.     ctrl = SSMTextGen_GetControlConnection(cx);
  3281.     srv = SEC_LookupCrls(ctrl->m_certdb, &head, -1);
  3282.     if (srv != SECSuccess || head == NULL) {
  3283.         goto loser;
  3284.     }
  3285.     currString = emptyString;
  3286.     for (node=head->first; node != NULL; node = node->next) {
  3287.         name = CERT_GetCommonName(&(node->crl->crl.name));
  3288.         b64Name = BTOA_ConvertItemToAscii(&node->crl->crl.derName);
  3289.         b64HTMLName = ssm_packb64_name(b64Name);
  3290.         retString = PR_smprintf("%1$sn<option value="%4$d%2$s">%3$s", 
  3291.                                 currString, b64HTMLName, name, node->type);
  3292.         PR_Free(name);
  3293.         PR_Free(b64Name);
  3294.         PR_Free(b64HTMLName);
  3295.         if (currString != emptyString)
  3296.             PR_Free(currString);
  3297.         currString = retString;
  3298.     }
  3299.     PR_FREEIF(cx->m_result);
  3300.     cx->m_result = retString;
  3301.     return SSM_SUCCESS;
  3302.  loser:
  3303.     return SSM_FAILURE;
  3304. }
  3306. SSMStatus
  3307. ssm_getStringForAbleAgent(SSMTextGenContext *cx, const char *agents[])
  3308. {
  3309.     int i;
  3310.     SSMStatus rv;
  3311.     char *key;
  3312.     
  3313.     key = SSM_At(cx->m_params, 0);
  3316.     for (i=0; agents[i] != NULL; i++) {
  3317.         if (PL_strstr(cx->m_request->agent, agents[i]) != NULL) {
  3318.             PR_FREEIF(cx->m_result);
  3319.             rv = SSM_GetAndExpandText(cx, key, &cx->m_result);
  3320.             if (rv != SSM_SUCCESS) {
  3321.                 return rv;
  3322.             }
  3323.             break;
  3324.         }
  3325.     }
  3326.     return SSM_SUCCESS;
  3327. }
  3329. SSMStatus SSM_LayoutSMIMETab(SSMTextGenContext *cx)
  3330. {
  3331.     return ssm_getStringForAbleAgent(cx, kSMimeApps);
  3332. }
  3334. SSMStatus SSM_LayoutJavaJSTab(SSMTextGenContext *cx)
  3335. {
  3336.     return ssm_getStringForAbleAgent(cx, kJavaJSApps);
  3337. }
  3339. SSMStatus SSM_LayoutOthersTab(SSMTextGenContext *cx)
  3340. {
  3341.     return ssm_getStringForAbleAgent(cx, kSMimeApps);
  3342. }