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

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

CA认证

开发平台：

WINDOWS

certhtml.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. /*
  35.  * certhtml.c --- convert a cert to html
  36.  *
  37.  * $Id: certhtml.c,v 1.1 2000/03/31 19:42:54 relyea%netscape.com Exp $
  38.  */
  40. #include "seccomon.h"
  41. #include "secitem.h"
  42. #include "sechash.h"
  43. #include "cert.h"
  44. #include "keyhi.h"
  45. #include "secder.h"
  46. #include "prprf.h"
  47. #include "secport.h"
  48. #include "secasn1.h"
  49. #include "pk11func.h"
  51. static char *hex = "0123456789ABCDEF";
  53. /*
  54. ** Convert a der-encoded integer to a hex printable string form
  55. */
  56. char *CERT_Hexify (SECItem *i, int do_colon)
  57. {
  58.     unsigned char *cp, *end;
  59.     char *rv, *o;
  61.     if (!i->len) {
  62. return PORT_Strdup("00");
  63.     }
  65.     rv = o = (char*) PORT_Alloc(i->len * 3);
  66.     if (!rv) return rv;
  68.     cp = i->data;
  69.     end = cp + i->len;
  70.     while (cp < end) {
  71. unsigned char ch = *cp++;
  72. *o++ = hex[(ch >> 4) & 0xf];
  73. *o++ = hex[ch & 0xf];
  74. if (cp != end) {
  75.     if (do_colon) {
  76. *o++ = ':';
  77.     }
  78. } 
  79.     }
  80.     *o = 0;           /* Null terminate the string */
  81.     return rv;
  82. }
  84. static char *
  85. gatherStrings(char **strings)
  86. {
  87.     char **strs;
  88.     int len;
  89.     char *ret;
  90.     char *s;
  92.     /* find total length of all strings */
  93.     strs = strings;
  94.     len = 0;
  95.     while ( *strs ) {
  96. len += PORT_Strlen(*strs);
  97. strs++;
  98.     }
  99.     
  100.     /* alloc enough memory for it */
  101.     ret = (char*)PORT_Alloc(len + 1);
  102.     if ( !ret ) {
  103. return(ret);
  104.     }
  106.     s = ret;
  107.     
  108.     /* copy the strings */
  109.     strs = strings;
  110.     while ( *strs ) {
  111. PORT_Strcpy(s, *strs);
  112. s += PORT_Strlen(*strs);
  113. strs++;
  114.     }
  116.     return( ret );
  117. }
  119. static PRBool
  120. CERT_IsAVAInUnicode(CERTAVA *ava, SECOidTag type)
  121. {
  122.     switch(type) {
  123. case SEC_OID_AVA_COUNTRY_NAME:
  124. case SEC_OID_PKCS9_EMAIL_ADDRESS:
  125. case SEC_OID_RFC1274_MAIL:
  126.     return PR_FALSE;
  127. default:
  128.     if(ava->value.data[0] == SEC_ASN1_UNIVERSAL_STRING) {
  129. return PR_TRUE;
  130.     }
  131.     break;
  132.     }
  134.     return PR_FALSE;
  135. }
  137. #define BREAK "<br>"
  138. #define BREAKLEN 4
  139. #define COMMA ", "
  140. #define COMMALEN 2
  142. #define MAX_OUS 20
  143. #define MAX_DC MAX_OUS
  146. char *CERT_FormatName (CERTName *name)
  147. {
  148.     CERTRDN** rdns;
  149.     CERTRDN * rdn;
  150.     CERTAVA** avas;
  151.     CERTAVA*  ava;
  152.     char *    buf = 0;
  153.     char *    tmpbuf = 0;
  154.     SECItem * cn = 0;
  155.     SECItem * email = 0;
  156.     SECItem * org = 0;
  157.     SECItem * loc = 0;
  158.     SECItem * state = 0;
  159.     SECItem * country = 0;
  160.     SECItem * dq      = 0;
  162.     unsigned  len  = 0;
  163.     int       tag;
  164.     int       i;
  165.     int       ou_count = 0;
  166.     int       dc_count = 0;
  167.     PRBool    first;
  168.     SECItem * orgunit[MAX_OUS];
  169.     SECItem * dc[MAX_DC];
  171.     /* Loop over name components and gather the interesting ones */
  172.     rdns = name->rdns;
  173.     while ((rdn = *rdns++) != 0) {
  174. avas = rdn->avas;
  175. while ((ava = *avas++) != 0) {
  176.     tag = CERT_GetAVATag(ava);
  177.     switch(tag) {
  178.       case SEC_OID_AVA_COMMON_NAME:
  179. cn = CERT_DecodeAVAValue(&ava->value);
  180. len += cn->len;
  181. break;
  182.       case SEC_OID_AVA_COUNTRY_NAME:
  183. country = CERT_DecodeAVAValue(&ava->value);
  184. len += country->len;
  185. break;
  186.       case SEC_OID_AVA_LOCALITY:
  187. loc = CERT_DecodeAVAValue(&ava->value);
  188. len += loc->len;
  189. break;
  190.       case SEC_OID_AVA_STATE_OR_PROVINCE:
  191. state = CERT_DecodeAVAValue(&ava->value);
  192. len += state->len;
  193. break;
  194.       case SEC_OID_AVA_ORGANIZATION_NAME:
  195. org = CERT_DecodeAVAValue(&ava->value);
  196. len += org->len;
  197. break;
  198.       case SEC_OID_AVA_DN_QUALIFIER:
  199. dq = CERT_DecodeAVAValue(&ava->value);
  200. len += dq->len;
  201. break;
  202.       case SEC_OID_AVA_ORGANIZATIONAL_UNIT_NAME:
  203. if (ou_count < MAX_OUS) {
  204. orgunit[ou_count] = CERT_DecodeAVAValue(&ava->value);
  205. len += orgunit[ou_count++]->len;
  206. }
  207. break;
  208.       case SEC_OID_AVA_DC:
  209. if (dc_count < MAX_DC) {
  210. dc[dc_count] = CERT_DecodeAVAValue(&ava->value);
  211. len += dc[dc_count++]->len;
  212. }
  213. break;
  214.       case SEC_OID_PKCS9_EMAIL_ADDRESS:
  215.       case SEC_OID_RFC1274_MAIL:
  216. email = CERT_DecodeAVAValue(&ava->value);
  217. len += email->len;
  218. break;
  219.       default:
  220. break;
  221.     }
  222. }
  223.     }
  225.     /* XXX - add some for formatting */
  226.     len += 128;
  228.     /* allocate buffer */
  229.     buf = (char *)PORT_Alloc(len);
  230.     if ( !buf ) {
  231. return(0);
  232.     }
  234.     tmpbuf = buf;
  235.     
  236.     if ( cn ) {
  237. PORT_Memcpy(tmpbuf, cn->data, cn->len);
  238. tmpbuf += cn->len;
  239. PORT_Memcpy(tmpbuf, BREAK, BREAKLEN);
  240. tmpbuf += BREAKLEN;
  241. SECITEM_FreeItem(cn, PR_TRUE);
  242.     }
  243.     if ( email ) {
  244. PORT_Memcpy(tmpbuf, email->data, email->len);
  245. tmpbuf += ( email->len );
  246. PORT_Memcpy(tmpbuf, BREAK, BREAKLEN);
  247. tmpbuf += BREAKLEN;
  248. SECITEM_FreeItem(email, PR_TRUE);
  249.     }
  250.     for (i=ou_count-1; i >= 0; i--) {
  251. PORT_Memcpy(tmpbuf, orgunit[i]->data, orgunit[i]->len);
  252. tmpbuf += ( orgunit[i]->len );
  253. PORT_Memcpy(tmpbuf, BREAK, BREAKLEN);
  254. tmpbuf += BREAKLEN;
  255. SECITEM_FreeItem(orgunit[i], PR_TRUE);
  256.     }
  257.     if ( dq ) {
  258. PORT_Memcpy(tmpbuf, dq->data, dq->len);
  259. tmpbuf += ( dq->len );
  260. PORT_Memcpy(tmpbuf, BREAK, BREAKLEN);
  261. tmpbuf += BREAKLEN;
  262. SECITEM_FreeItem(dq, PR_TRUE);
  263.     }
  264.     if ( org ) {
  265. PORT_Memcpy(tmpbuf, org->data, org->len);
  266. tmpbuf += ( org->len );
  267. PORT_Memcpy(tmpbuf, BREAK, BREAKLEN);
  268. tmpbuf += BREAKLEN;
  269. SECITEM_FreeItem(org, PR_TRUE);
  270.     }
  271.     for (i=dc_count-1; i >= 0; i--) {
  272. PORT_Memcpy(tmpbuf, dc[i]->data, dc[i]->len);
  273. tmpbuf += ( dc[i]->len );
  274. PORT_Memcpy(tmpbuf, BREAK, BREAKLEN);
  275. tmpbuf += BREAKLEN;
  276. SECITEM_FreeItem(dc[i], PR_TRUE);
  277.     }
  278.     first = PR_TRUE;
  279.     if ( loc ) {
  280. PORT_Memcpy(tmpbuf, loc->data,  loc->len);
  281. tmpbuf += ( loc->len );
  282. first = PR_FALSE;
  283. SECITEM_FreeItem(loc, PR_TRUE);
  284.     }
  285.     if ( state ) {
  286. if ( !first ) {
  287.     PORT_Memcpy(tmpbuf, COMMA, COMMALEN);
  288.     tmpbuf += COMMALEN;
  289. }
  290. PORT_Memcpy(tmpbuf, state->data, state->len);
  291. tmpbuf += ( state->len );
  292. first = PR_FALSE;
  293. SECITEM_FreeItem(state, PR_TRUE);
  294.     }
  295.     if ( country ) {
  296. if ( !first ) {
  297.     PORT_Memcpy(tmpbuf, COMMA, COMMALEN);
  298.     tmpbuf += COMMALEN;
  299. }
  300. PORT_Memcpy(tmpbuf, country->data, country->len);
  301. tmpbuf += ( country->len );
  302. first = PR_FALSE;
  303. SECITEM_FreeItem(country, PR_TRUE);
  304.     }
  305.     if ( !first ) {
  306. PORT_Memcpy(tmpbuf, BREAK, BREAKLEN);
  307. tmpbuf += BREAKLEN;
  308.     }
  310.     *tmpbuf = 0;
  312.     return(buf);
  313. }
  315. static char *sec_FortezzaClearance(SECItem *clearance) {
  316.     unsigned char clr = 0;
  318.     if (clearance->len > 0) { clr = clearance->data[0]; }
  320.     if (clr & 0x4) return "Top Secret";
  321.     if (clr & 0x8) return "Secret";
  322.     if (clr & 0x10) return "Confidential";
  323.     if (clr & 0x20) return "Sensitive";
  324.     if (clr & 0x40) return "Unclassified";
  325.     return "None";
  326. }
  328. static char *sec_FortezzaMessagePriviledge(SECItem *priv) {
  329.     unsigned char clr = 0;
  331.     if (priv->len > 0) { clr = (priv->data[0]) & 0x78; }
  333.     if (clr == 0x00) {
  334. return "None";
  335.     } else {
  337. return PR_smprintf("%s%s%s%s%s%s%s",
  339.     clr&0x40?"Critical/Flash":"",
  340.     (clr&0x40) && (clr&0x38) ? ", " : "" ,
  342.     clr&0x20?"Immediate/Priority":"",
  343.     (clr&0x20) && (clr&0x18) ? ", " : "" ,
  345.     clr&0x10?"Routine/Deferred":"",
  346.     (clr&0x10) && (clr&0x08) ? ", " : "" ,
  348.     clr&0x08?"Rekey Agent":"");
  349.     }
  351. }
  353. static char *sec_FortezzaCertPriviledge(SECItem *priv) {
  354.     unsigned char clr = 0;
  356.     if (priv->len > 0) { clr = priv->data[0]; }
  358.     return PR_smprintf("%s%s%s%s%s%s%s%s%s%s%s%s",
  359. clr&0x40?"Organizational Releaser":"",
  360. (clr&0x40) && (clr&0x3e) ? "," : "" ,
  361. clr&0x20?"Policy Creation Authority":"",
  362. (clr&0x20) && (clr&0x1e) ? "," : "" ,
  363. clr&0x10?"Certificate Authority":"",
  364. (clr&0x10) && (clr&0x0e) ? "," : "" ,
  365. clr&0x08?"Local Managment Authority":"",
  366. (clr&0x08) && (clr&0x06) ? "," : "" ,
  367. clr&0x04?"Configuration Vector Authority":"",
  368. (clr&0x04) && (clr&0x02) ? "," : "" ,
  369. clr&0x02?"No Signature Capability":"",
  370. clr&0x7e?"":"Signing Only"
  371.     );
  372. }
  374. static char *htmlcertstrings[] = {
  375.     "<table border=0 cellspacing=0 cellpadding=0><tr><td valign=top>"
  376.     "<font size=2><b>This Certificate belongs to:</b><br>"
  377.     "<table border=0 cellspacing=0 cellpadding=0><tr><td>",
  378.     0, /* image goes here */
  379.     0,
  380.     0,
  381.     "</td><td width=10> </td><td><font size=2>",
  382.     0, /* subject name goes here */
  383.     "</td></tr></table></font></td><td width=20> </td><td valign=top>"
  384.     "<font size=2><b>This Certificate was issued by:</b><br>"
  385.     "<table border=0 cellspacing=0 cellpadding=0><tr><td>",
  386.     0, /* image goes here */
  387.     0,
  388.     0,
  389.     "</td><td width=10> </td><td><font size=2>",
  390.     0, /* issuer name goes here */
  391.     "</td></tr></table></font></td></tr></table>"
  392.     "<b>Serial Number:</b> ",
  393.     0,
  394.     "<br><b>This Certificate is valid from ",
  395.     0, /* notBefore goes here */
  396.     " to ",
  397.     0, /* notAfter does here */
  398.     "</b><br><b>Clearance:</b>",
  399.     0,
  400.     "<br><b>DSS Priviledges:</b>",
  401.     0,
  402.     "<br><b>KEA Priviledges:</b>",
  403.     0,
  404.     "<br><b>KMID:</b>",
  405.     0,
  406.     "<br><b>Certificate Fingerprint:</b>"
  407.     "<table border=0 cellspacing=0 cellpadding=0><tr>"
  408.     "<td width=10> </td><td><font size=2>",
  409.     0, /* fingerprint goes here */
  410.     "</td></tr></table>",
  411.     0, /* comment header goes here */
  412.     0, /* comment goes here */
  413.     0, /* comment trailer goes here */
  414.     0
  415. };
  417. char *
  418. CERT_HTMLCertInfo(CERTCertificate *cert, PRBool showImages, PRBool showIssuer)
  419. {
  420.     SECStatus rv;
  421.     char *issuer, *subject, *serialNumber, *version;
  422.     char *notBefore, *notAfter;
  423.     char *ret;
  424.     char *nickname;
  425.     SECItem dummyitem;
  426.     unsigned char fingerprint[16];   /* result of MD5, always 16 bytes */
  427.     char *fpstr;
  428.     SECItem fpitem;
  429.     char *commentstring = NULL;
  430.     SECKEYPublicKey *pubk;
  431.     char *DSSPriv;
  432.     char *KMID = NULL;
  433.     char *servername;
  434.     
  435.     if (!cert) {
  436. return(0);
  437.     }
  439.     issuer = CERT_FormatName (&cert->issuer);
  440.     subject = CERT_FormatName (&cert->subject);
  441.     version = CERT_Hexify (&cert->version,1);
  442.     serialNumber = CERT_Hexify (&cert->serialNumber,1);
  443.     notBefore = DER_UTCDayToAscii(&cert->validity.notBefore);
  444.     notAfter = DER_UTCDayToAscii(&cert->validity.notAfter);
  445.     servername = CERT_FindNSStringExtension(cert,
  446.    SEC_OID_NS_CERT_EXT_SSL_SERVER_NAME);
  448.     nickname = cert->nickname;
  449.     if ( nickname == NULL ) {
  450. showImages = PR_FALSE;
  451.     }
  453.     dummyitem.data = NULL;
  454.     rv = CERT_FindCertExtension(cert, SEC_OID_NS_CERT_EXT_SUBJECT_LOGO,
  455.        &dummyitem);
  456.     if ( dummyitem.data ) {
  457. PORT_Free(dummyitem.data);
  458.     }
  459.     
  460.     if ( rv || !showImages ) {
  461. htmlcertstrings[1] = "";
  462. htmlcertstrings[2] = "";
  463. htmlcertstrings[3] = "";
  464.     } else {
  465. htmlcertstrings[1] = "<img src="about:security?subject-logo=";
  466. htmlcertstrings[2] = nickname;
  467. htmlcertstrings[3] = "">";
  468.     }
  470.     if ( servername ) {
  471. char *tmpstr;
  472. tmpstr = (char *)PORT_Alloc(PORT_Strlen(subject) +
  473.     PORT_Strlen(servername) +
  474.     sizeof("<br>") + 1);
  475. if ( tmpstr ) {
  476.     PORT_Strcpy(tmpstr, servername);
  477.     PORT_Strcat(tmpstr, "<br>");
  478.     PORT_Strcat(tmpstr, subject);
  479.     PORT_Free(subject);
  480.     subject = tmpstr;
  481. }
  482.     }
  483.     
  484.     htmlcertstrings[5] = subject;
  486.     dummyitem.data = NULL;
  487.     
  488.     rv = CERT_FindCertExtension(cert, SEC_OID_NS_CERT_EXT_ISSUER_LOGO,
  489.        &dummyitem);
  490.     if ( dummyitem.data ) {
  491. PORT_Free(dummyitem.data);
  492.     }
  493.     
  494.     if ( rv || !showImages ) {
  495. htmlcertstrings[7] = "";
  496. htmlcertstrings[8] = "";
  497. htmlcertstrings[9] = "";
  498.     } else {
  499. htmlcertstrings[7] = "<img src="about:security?issuer-logo=";
  500. htmlcertstrings[8] = nickname;
  501. htmlcertstrings[9] = "">";
  502.     }
  504.     
  505.     if (showIssuer == PR_TRUE) {
  506.         htmlcertstrings[11] = issuer;
  507.     } else {
  508. htmlcertstrings[11] = "";
  509.     }
  511.     htmlcertstrings[13] = serialNumber;
  512.     htmlcertstrings[15] = notBefore;
  513.     htmlcertstrings[17] = notAfter;
  515.     pubk = CERT_ExtractPublicKey(cert);
  516.     DSSPriv = NULL;
  517.     if (pubk && (pubk->keyType == fortezzaKey)) {
  518. htmlcertstrings[18] = "</b><br><b>Clearance:</b>";
  519. htmlcertstrings[19] = sec_FortezzaClearance(
  520. &pubk->u.fortezza.clearance);
  521. htmlcertstrings[20] = "<br><b>DSS Priviledges:</b>";
  522. DSSPriv = sec_FortezzaCertPriviledge(
  523. &pubk->u.fortezza.DSSpriviledge);
  524. htmlcertstrings[21] = DSSPriv;
  525. htmlcertstrings[22] = "<br><b>KEA Priviledges:</b>";
  526. htmlcertstrings[23] = sec_FortezzaMessagePriviledge(
  527. &pubk->u.fortezza.KEApriviledge);
  528. htmlcertstrings[24] = "<br><b>KMID:</b>";
  529. dummyitem.data = &pubk->u.fortezza.KMID[0];
  530. dummyitem.len = sizeof(pubk->u.fortezza.KMID);
  531. KMID = CERT_Hexify (&dummyitem,0);
  532. htmlcertstrings[25] = KMID;
  533.     } else {
  534. /* clear out the headers in the non-fortezza cases */
  535. htmlcertstrings[18] = "";
  536. htmlcertstrings[19] = "";
  537. htmlcertstrings[20] = "";
  538. htmlcertstrings[21] = "";
  539. htmlcertstrings[22] = "";
  540. htmlcertstrings[23] = "";
  541. htmlcertstrings[24] = "";
  542. htmlcertstrings[25] = "</b>";
  543.     }
  545.     if (pubk) {
  546.       SECKEY_DestroyPublicKey(pubk);
  547.     }
  549. #define HTML_OFF 27
  550.     rv = PK11_HashBuf(SEC_OID_MD5, fingerprint, 
  551.                    cert->derCert.data, cert->derCert.len);
  552.     
  553.     fpitem.data = fingerprint;
  554.     fpitem.len = sizeof(fingerprint);
  556.     fpstr = CERT_Hexify (&fpitem,1);
  557.     
  558.     htmlcertstrings[HTML_OFF] = fpstr;
  560.     commentstring = CERT_GetCertCommentString(cert);
  562.     if (commentstring == NULL) {
  563. htmlcertstrings[HTML_OFF+2] = "";
  564. htmlcertstrings[HTML_OFF+3] = "";
  565. htmlcertstrings[HTML_OFF+4] = "";
  566.     } else {
  567. htmlcertstrings[HTML_OFF+2] =
  568.     "<b>Comment:</b>"
  569.     "<table border=0 cellspacing=0 cellpadding=0><tr>"
  570.     "<td width=10> </td><td><font size=3>"
  571.     "<textarea name=foobar rows=4 cols=55 onfocus="this.blur()">";
  572. htmlcertstrings[HTML_OFF+3] = commentstring;
  573. htmlcertstrings[HTML_OFF+4] = "</textarea></font></td></tr></table>";
  574.     }
  575.     
  576.     ret = gatherStrings(htmlcertstrings);
  577.     
  578.     if ( issuer ) {
  579. PORT_Free(issuer);
  580.     }
  581.     
  582.     if ( subject ) {
  583. PORT_Free(subject);
  584.     }
  585.     
  586.     if ( version ) {
  587. PORT_Free(version);
  588.     }
  589.     
  590.     if ( serialNumber ) {
  591. PORT_Free(serialNumber);
  592.     }
  593.     
  594.     if ( notBefore ) {
  595. PORT_Free(notBefore);
  596.     }
  597.     
  598.     if ( notAfter ) {
  599. PORT_Free(notAfter);
  600.     }
  601.     
  602.     if ( fpstr ) {
  603. PORT_Free(fpstr);
  604.     }
  605.     if (DSSPriv) {
  606. PORT_Free(DSSPriv);
  607.     }
  609.     if (KMID) {
  610. PORT_Free(KMID);
  611.     }
  613.     if ( commentstring ) {
  614. PORT_Free(commentstring);
  615.     }
  616.     
  617.     if ( servername ) {
  618. PORT_Free(servername);
  619.     }
  620.     
  621.     return(ret);
  622. }