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

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

CA认证

开发平台：

WINDOWS

derprint.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.  */
  33. #include "prio.h"
  34. #include "prprf.h"
  35. #include "prmem.h"
  36. #include "seccomon.h"
  37. #include "secerr.h"
  38. #include "secder.h"
  39. #include "secoid.h"
  40. #include "prerror.h"
  41. #include "secasn1.h"
  42. #include "serv.h"
  44. #define RIGHT_MARGIN 24
  45. /*#define RAW_BYTES 1 */
  47. static int prettyColumn = 0;
  49. static int
  50. getInteger256(unsigned char *data, unsigned int nb)
  51. {
  52.     int val;
  54.     switch (nb) {
  55.       case 1:
  56. val = data[0];
  57. break;
  58.       case 2:
  59. val = (data[0] << 8) | data[1];
  60. break;
  61.       case 3:
  62. val = (data[0] << 16) | (data[1] << 8) | data[2];
  63. break;
  64.       case 4:
  65. val = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
  66. break;
  67.       default:
  68. PR_SetError(SEC_ERROR_BAD_DER,0);
  69. return -1;
  70.     }
  72.     return val;
  73. }
  75. static int
  76. prettyNewline(PRFileDesc *out)
  77. {
  78.     int rv;
  80.     if (prettyColumn != -1) {
  81. rv = PR_Write(out, "n",1);
  82. prettyColumn = -1;
  83. if (rv < 0) {
  84.     PR_SetError(SEC_ERROR_IO,0);
  85.     return rv;
  86. }
  87.     }
  88.     return 0;
  89. }
  91. #define PRETTY_INDENT "   "
  93. static int
  94. prettyIndent(PRFileDesc *out, unsigned level)
  95. {
  96.     unsigned int i;
  97.     int rv;
  99.     if (prettyColumn == -1) {
  100. prettyColumn = level;
  101. for (i = 0; i < level; i++) {
  102.     rv = PR_Write(out, PRETTY_INDENT, PL_strlen(PRETTY_INDENT));
  103.     if (rv < 0) {
  104. PR_SetError(SEC_ERROR_IO,0);
  105. return rv;
  106.     }
  107. }
  108.     }
  110.     return 0;
  111. }
  113. static int
  114. prettyPrintByte(PRFileDesc *out, unsigned char item, unsigned int level)
  115. {
  116.     int rv;
  117.     char *outdata;
  119.     rv = prettyIndent(out, level);
  120.     if (rv < 0)
  121. return rv;
  123.     outdata = PR_smprintf("%02x ", item);
  124.     rv = PR_Write(out, outdata, PL_strlen(outdata));
  125.     PR_Free(outdata);
  126.     if (rv < 0) {
  127. PR_SetError(SEC_ERROR_IO,0);
  128. return rv;
  129.     }
  131.     prettyColumn++;
  132.     if (prettyColumn >= RIGHT_MARGIN) {
  133. return prettyNewline(out);
  134.     }
  136.     return 0;
  137. }
  139. static int
  140. prettyPrintLeaf(PRFileDesc *out, unsigned char *data,
  141. unsigned int len, unsigned int lv)
  142. {
  143.     unsigned int i;
  144.     int rv;
  146.     for (i = 0; i < len; i++) {
  147. rv = prettyPrintByte(out, *data++, lv);
  148. if (rv < 0)
  149.     return rv;
  150.     }
  151.     return prettyNewline(out);
  152. }
  154. static int
  155. prettyPrintStringStart(PRFileDesc *out, unsigned char *str,
  156.        unsigned int len, unsigned int level)
  157. {
  158. #define BUF_SIZE 100
  159.     unsigned char staticBuf[BUF_SIZE];
  160.     unsigned char *buf, *dynamicBuf = NULL;
  161.     int rv;
  163.     if (len >= BUF_SIZE) {
  164.       /* len = BUF_SIZE - 1; */
  165.         buf = dynamicBuf = SSM_NEW_ARRAY(char, len+1);
  166.     } else {
  167.         buf = staticBuf;
  168.     }
  170.     rv = prettyNewline(out);
  171.     if (rv < 0)
  172.         goto loser;
  174.     rv = prettyIndent(out, level);
  175.     if (rv < 0)
  176.         goto loser;
  178.     memcpy(buf, str, len);
  179.     buf[len] = '00';
  180.     
  181.     rv = PR_Write(out, buf, len);
  182.     if (rv < 0) {
  183. PR_SetError(SEC_ERROR_IO,0);
  184. goto loser;
  185.     }
  187.     return 0;
  188.  loser:
  189.     PR_FREEIF(dynamicBuf);
  190.     return rv;
  191. #undef BUF_SIZE
  192. }
  194. static int
  195. prettyPrintString(PRFileDesc *out, unsigned char *str,
  196.   unsigned int len, unsigned int level, PRBool raw)
  197. {
  198.     int rv;
  200.     rv = prettyPrintStringStart(out, str, len, level);
  201.     if (rv < 0)
  202. return rv;
  204.     rv = prettyNewline(out);
  205.     if (rv < 0)
  206. return rv;
  208.     if (raw) {
  209. rv = prettyPrintLeaf(out, str, len, level);
  210. if (rv < 0)
  211.     return rv;
  212.     }
  214.     return 0;
  215. }
  217. static void
  218. pretty_PrintTime(PRFileDesc *out, int64 time, char *m, int level)
  219. {
  220.     PRExplodedTime printableTime;
  221.     char *timeString;
  222.     char *newmessage;
  224.     /* Convert to local time */
  225.     PR_ExplodeTime(time, PR_GMTParameters, &printableTime);
  227.     timeString = PORT_Alloc(100);
  228.     if (timeString == NULL)
  229.         return;
  231.     if (m != NULL) {
  232.       /*        SECU_Indent(out, level);*/
  233.         prettyIndent(out, level);
  234. newmessage = PR_smprintf("%s: ", m);
  235.         PR_Write(out, newmessage, PL_strlen(newmessage));
  236. PR_Free(newmessage);
  237.     }
  239.     PR_FormatTime(timeString, 100, "%a %b %d %H:%M:%S %Y", &printableTime);
  240.     PR_Write(out, timeString, PL_strlen(timeString));
  242.     if (m != NULL)
  243.         PR_Write(out, "n", 1);
  245.     PR_Free(timeString);
  246. }
  248. static int
  249. prettyPrintObjectID(PRFileDesc *out, unsigned char *data,
  250.                     unsigned int len, unsigned int level, PRBool raw)
  251. {
  252.     SECOidData *oiddata;
  253.     SECItem oiditem;
  254.     unsigned int i;
  255.     unsigned long val;
  256.     int rv;
  257.     char buf[300];
  260.     /*
  261.      * First print the Object Id in numeric format
  262.      */
  264.     rv = prettyIndent(out, level);
  265.     if (rv < 0)
  266.         return rv;
  268.     val = data[0];
  269.     i   = val % 40;
  270.     val = val / 40;
  271.     PR_snprintf(buf, 300, "%lu %u ", val, i); 
  272.     rv = PR_Write(out,buf,PL_strlen(buf)); 
  273.     if (rv < 0) {
  274.         PORT_SetError(SEC_ERROR_IO);
  275.         return rv;
  276.     }
  278.     val = 0;
  279.     for (i = 1; i < len; ++i) {
  280.         unsigned long j;
  282.         j = data[i];
  283.         val = (val << 7) | (j & 0x7f);
  284.         if (j & 0x80)
  285.             continue;
  286. PR_snprintf(buf, 300, "%lu ", val);
  287.         rv = PR_Write(out, buf, PL_strlen(buf));
  288.         if (rv < 0) {
  289.             PR_SetError(SEC_ERROR_IO,0);
  290.             return rv;
  291.         }
  292.         val = 0;
  293.     }
  295.     /*
  296.      * Now try to look it up and print a symbolic version.
  297.      */
  298.     oiditem.data = data;
  299.     oiditem.len = len;
  300.     oiddata = SECOID_FindOID(&oiditem);
  301.     if (oiddata != NULL) {
  302.         i = PL_strlen(oiddata->desc);
  303.         if ((prettyColumn + 1 + (i / 3)) > RIGHT_MARGIN) {
  304.             rv = prettyNewline(out);
  305.             if (rv < 0)
  306.                 return rv;
  307.         }
  309.         rv = prettyIndent(out, level);
  310.         if (rv < 0)
  311.     return rv;
  313. PR_snprintf(buf, 300, "(%s)", oiddata->desc);
  314.         rv = PR_Write(out, buf, PL_strlen(buf));
  315.         if (rv < 0) {
  316.     PR_SetError(SEC_ERROR_IO,0);
  317.             return rv;
  318.         }
  319.     }
  321.     /*
  322.      * Finally, on a new line, print the raw bytes (if requested).
  323.      */
  324.     if (raw) {
  325.         rv = prettyNewline(out);
  326.         if (rv < 0) {
  327.             PR_SetError(SEC_ERROR_IO,0);
  328.             return rv;
  329.         }
  331.         for (i = 0; i < len; i++) {
  332.             rv = prettyPrintByte(out, *data++, level);
  333.             if (rv < 0)
  334.                 return rv;
  335.         }
  336.     }
  338.     return prettyNewline(out);
  339. }
  341. static char *prettyTagType [32] = {
  342.   "End of Contents",
  343.   "Boolean",
  344.   "Integer",
  345.   "Bit String",
  346.   "Octet String",
  347.   "NULL",
  348.   "Object Identifier",
  349.   "0x07",
  350.   "0x08",
  351.   "0x09",
  352.   "Enumerated",
  353.   "0x0B",
  354.   "UTF8 String",
  355.   "0x0D",
  356.   "0x0E",
  357.   "0x0F",
  358.   "Sequence",
  359.   "Set",
  360.   "0x12",
  361.   "Printable String",
  362.   "T61 String",
  363.   "0x15",
  364.   "IA5 String",
  365.   "UTC Time",
  366.   "Generalized Time",
  367.   "0x19",
  368.   "Visible String",
  369.   "0x1B",
  370.   "Universal String",
  371.   "0x1D",
  372.   "BMP String",
  373.   "High-Tag-Number"
  374. };
  376. static int
  377. prettyPrintTime(PRFileDesc *out, unsigned char *str,
  378. unsigned int len, unsigned int level, PRBool raw, PRBool utc)
  379. {
  380.     SECItem time_item;
  381.     int rv;
  382.     SECStatus srv;
  383.     int64 time;
  385.     rv = prettyPrintStringStart(out, str, len, level);
  386.     if (rv < 0)
  387. return rv;
  389.     time_item.data = str;
  390.     time_item.len = len;
  392.     rv = PR_Write(out, " (", 2);
  393.     if (rv < 0) {
  394. PR_SetError(SEC_ERROR_IO,0);
  395. return rv;
  396.     }
  398.     if (utc) {
  399.         srv = DER_UTCTimeToTime(&time, &time_item);
  400. if (srv == SECSuccess) 
  401.     pretty_PrintTime(out, time, NULL, 0);
  402.     } else{
  403.         srv = DER_GeneralizedTimeToTime(&time, &time_item);
  404. if (srv == SECSuccess)
  405.     pretty_PrintTime(out, time, NULL, 0);
  406.     }
  408.     rv = PR_Write(out, ")", 1);
  409.     if (rv < 0) {
  410. PR_SetError(SEC_ERROR_IO,0);
  411. return rv;
  412.     }
  414.     rv = prettyNewline(out);
  415.     if (rv < 0)
  416. return rv;
  418.     if (raw) {
  419. rv = prettyPrintLeaf(out, str, len, level);
  420. if (rv < 0)
  421.     return rv;
  422.     }
  424.     return 0;
  425. }
  427. static int
  428. prettyPrintTag(PRFileDesc *out, unsigned char *src, unsigned char *end,
  429.        unsigned char *codep, unsigned int level, PRBool raw)
  430. {
  431.     int rv;
  432.     unsigned char code, tagnum;
  433.     char *msg;
  435.     if (src >= end) {
  436. PR_SetError(SEC_ERROR_BAD_DER,0);
  437. return -1;
  438.     }
  440.     code = *src;
  441.     tagnum = code & SEC_ASN1_TAGNUM_MASK;
  443.     /*
  444.      * NOTE: This code does not (yet) handle the high-tag-number form!
  445.      */
  446.     if (tagnum == SEC_ASN1_HIGH_TAG_NUMBER) {
  447.         PR_SetError(SEC_ERROR_BAD_DER,0);
  448. return -1;
  449.     }
  451.     if (raw)
  452. rv = prettyPrintByte(out, code, level);
  453.     else
  454. rv = prettyIndent(out, level);
  456.     if (rv < 0)
  457. return rv;
  459.     if (code & SEC_ASN1_CONSTRUCTED) {
  460.         rv = PR_Write(out, "C-",2);
  461. if (rv < 0) {
  462.     PR_SetError(SEC_ERROR_IO,0);
  463.     return rv;
  464. }
  465.     }
  467.     switch (code & SEC_ASN1_CLASS_MASK) {
  468.     case SEC_ASN1_UNIVERSAL:
  469.         rv = PR_Write(out, prettyTagType[tagnum], 
  470.       PL_strlen(prettyTagType[tagnum]));
  471. break;
  472.     case SEC_ASN1_APPLICATION:
  473.         msg = PR_smprintf("Application: %d ", tagnum);
  474.         rv = PR_Write(out,msg, PL_strlen(msg));
  475. PR_Free(msg);
  476. break;
  477.     case SEC_ASN1_CONTEXT_SPECIFIC:
  478.         msg = PR_smprintf("[%d] ", tagnum);
  479.         rv = PR_Write(out, msg, PL_strlen(msg));
  480. PR_Free(msg);
  481. break;
  482.     case SEC_ASN1_PRIVATE:
  483.         msg = PR_smprintf("Private: %d ", tagnum);
  484.         rv = PR_Write(out, msg, PL_strlen(msg));
  485. break;
  486.     }
  488.     if (rv < 0) {
  489.         PR_SetError(SEC_ERROR_IO,0);
  490. return rv;
  491.     }
  493.     *codep = code;
  495.     return 1;
  496. }
  498. static int
  499. prettyPrintLength(PRFileDesc *out, unsigned char *data, unsigned char *end,
  500.   int *lenp, PRBool *indefinitep, unsigned int lv, PRBool raw)
  501. {
  502.     unsigned char lbyte;
  503.     int lenLen;
  504.     int rv;
  506.     if (data >= end) {
  507. PR_SetError(SEC_ERROR_BAD_DER,0);
  508. return -1;
  509.     }
  511.     rv = PR_Write(out, " ",1);
  512.     if (rv < 0) {
  513.         PR_SetError(SEC_ERROR_IO,0);
  514. return rv;
  515.     }
  517.     *indefinitep = PR_FALSE;
  519.     lbyte = *data++;
  520.     if (lbyte >= 0x80) {
  521. /* Multibyte length */
  522. unsigned nb = (unsigned) (lbyte & 0x7f);
  523. if (nb > 4) {
  524.     PR_SetError(SEC_ERROR_BAD_DER,0);
  525.     return -1;
  526. }
  527. if (nb > 0) {
  528.     int il;
  530.     if ((data + nb) > end) {
  531. PR_SetError(SEC_ERROR_BAD_DER,0);
  532. return -1;
  533.     }
  534.     il = getInteger256(data, nb);
  535.     if (il < 0) return -1;
  536.     *lenp = (unsigned) il;
  537. } else {
  538.     *lenp = 0;
  539.     *indefinitep = PR_TRUE;
  540. }
  541. lenLen = nb + 1;
  542. if (raw) {
  543.     unsigned int i;
  545.     rv = prettyPrintByte(out, lbyte, lv);
  546.     if (rv < 0)
  547. return rv;
  548.     for (i = 0; i < nb; i++) {
  549. rv = prettyPrintByte(out, data[i], lv);
  550. if (rv < 0)
  551.     return rv;
  552.     }
  553. }
  554.     } else {
  555. *lenp = lbyte;
  556. lenLen = 1;
  557. if (raw) {
  558.     rv = prettyPrintByte(out, lbyte, lv);
  559.     if (rv < 0)
  560. return rv;
  561. }
  562.     }
  563.     if (*indefinitep) {
  564. rv = PR_Write(out, "(indefinite)n", PL_strlen("(indefinite)n"));
  565.     } else {
  566.         char *msg;
  568.         msg= PR_smprintf("(%d)n", *lenp);
  569. rv = PR_Write(out, msg, PL_strlen(msg));
  570.     }
  571.     if (rv < 0) {
  572.         PR_SetError(SEC_ERROR_IO,0);
  573. return rv;
  574.     }
  576.     prettyColumn = -1;
  577.     return lenLen;
  578. }
  580. static int
  581. prettyPrintItem(PRFileDesc *out, unsigned char *data, unsigned char *end,
  582. unsigned int lv, PRBool raw)
  583. {
  584.     int slen;
  585.     int lenLen;
  586.     unsigned char *orig = data;
  587.     int rv;
  589.     while (data < end) {
  590.         unsigned char code;
  591. PRBool indefinite;
  593. slen = prettyPrintTag(out, data, end, &code, lv, raw);
  594. if (slen < 0)
  595.     return slen;
  596. data += slen;
  598. lenLen = prettyPrintLength(out, data, end, &slen, &indefinite, lv, raw);
  599. if (lenLen < 0)
  600.     return lenLen;
  601. data += lenLen;
  603. /*
  604.  * Just quit now if slen more bytes puts us off the end.
  605.  */
  606. if ((data + slen) > end) {
  607.     PR_SetError(SEC_ERROR_BAD_DER,0);
  608.     return -1;
  609. }
  611.         if (code & SEC_ASN1_CONSTRUCTED) {
  612.     if (slen > 0 || indefinite) {
  613. slen = prettyPrintItem(out, data,
  614.        slen == 0 ? end : data + slen,
  615.        lv+1, raw);
  616. if (slen < 0)
  617.     return slen;
  618. data += slen;
  619.     }
  620. } else if (code == 0) {
  621.     if (slen != 0 || lenLen != 1) {
  622. PR_SetError(SEC_ERROR_BAD_DER,0);
  623. return -1;
  624.     }
  625.     break;
  626. } else {
  627.     switch (code) {
  628.       case SEC_ASN1_PRINTABLE_STRING:
  629.       case SEC_ASN1_IA5_STRING:
  630.       case SEC_ASN1_VISIBLE_STRING:
  631.       case SEC_ASN1_T61_STRING:
  632.       case SEC_ASN1_UTF8_STRING:
  633.         rv = prettyPrintString(out, data, slen, lv+1, raw);
  634. if (rv < 0)
  635.     return rv;
  636. break;
  637.       case SEC_ASN1_UTC_TIME:
  638.         rv = prettyPrintTime(out, data, slen, lv+1, raw, PR_TRUE);
  639. if (rv < 0)
  640.     return rv;
  641. break;
  642.       case SEC_ASN1_GENERALIZED_TIME:
  643.         rv = prettyPrintTime(out, data, slen, lv+1, raw, PR_FALSE);
  644. if (rv < 0)
  645.     return rv;
  646. break;
  647.       case SEC_ASN1_OBJECT_ID:
  648.         rv = prettyPrintObjectID(out, data, slen, lv+1, raw);
  649. if (rv < 0)
  650.     return rv;
  651. break;
  652.       case SEC_ASN1_OCTET_STRING:
  653. /* rv = prettyPrintOctetString(out,data,slen,lv+1); */
  654. rv = prettyPrintItem(out,data,data+slen,lv+1, raw);
  655. if (rv < 0)
  656.     return rv;
  657. break;
  658.       case SEC_ASN1_BOOLEAN: /* could do nicer job */
  659.       case SEC_ASN1_INTEGER: /* could do nicer job */
  660.       case SEC_ASN1_BIT_STRING: /* could do nicer job */
  661.       case SEC_ASN1_NULL:
  662.       case SEC_ASN1_ENUMERATED: /* could do nicer job, as INTEGER */
  663.       case SEC_ASN1_UNIVERSAL_STRING:
  664.       case SEC_ASN1_BMP_STRING:
  665.       default:
  666.         rv = prettyPrintLeaf(out, data, slen, lv+1);
  667. if (rv < 0)
  668.     return rv;
  669. break;
  670.     }
  671.     data += slen;
  672. }
  673.     }
  675.     rv = prettyNewline(out);
  676.     if (rv < 0)
  677. return rv;
  679.     return data - orig;
  680. }
  682. SSMStatus
  683. SSM_PrettyPrintDER(PRFileDesc *out, SECItem *it, PRBool raw)
  684. {
  685.     int rv;
  687.     prettyColumn = -1;
  689.     rv = prettyPrintItem(out, it->data, it->data + it->len, 0, raw);
  690.     if (rv < 0)
  691. return SSM_FAILURE;
  692.     return SSM_SUCCESS;
  693. }