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

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

CA认证

开发平台：

WINDOWS

derdec.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include "secder.h"
  35. #include "secerr.h"
  37. static uint32
  38. der_indefinite_length(unsigned char *buf, unsigned char *end)
  39. {
  40.     uint32 len, ret, dataLen;
  41.     unsigned char tag, lenCode;
  42.     int dataLenLen;
  44.     len = 0;
  45.     while ( 1 ) {
  46. if ((buf + 2) > end) {
  47.     return(0);
  48. }
  50. tag = *buf++;
  51. lenCode = *buf++;
  52. len += 2;
  54. if ( ( tag == 0 ) && ( lenCode == 0 ) ) {
  55.     return(len);
  56. }
  58. if ( lenCode == 0x80 ) { /* indefinite length */
  59.     ret = der_indefinite_length(buf, end); /* recurse to find length */
  60.     if (ret == 0)
  61. return 0;
  62.     len += ret;
  63.     buf += ret;
  64. } else { /* definite length */
  65.     if (lenCode & 0x80) {
  66. /* Length of data is in multibyte format */
  67. dataLenLen = lenCode & 0x7f;
  68. switch (dataLenLen) {
  69.   case 1:
  70.     dataLen = buf[0];
  71.     break;
  72.   case 2:
  73.     dataLen = (buf[0]<<8)|buf[1];
  74.     break;
  75.   case 3:
  76.     dataLen = ((unsigned long)buf[0]<<16)|(buf[1]<<8)|buf[2];
  77.     break;
  78.   case 4:
  79.     dataLen = ((unsigned long)buf[0]<<24)|
  80. ((unsigned long)buf[1]<<16)|(buf[2]<<8)|buf[3];
  81.     break;
  82.   default:
  83.     PORT_SetError(SEC_ERROR_BAD_DER);
  84.     return SECFailure;
  85. }
  86.     } else {
  87. /* Length of data is in single byte */
  88. dataLen = lenCode;
  89. dataLenLen = 0;
  90.     }
  92.     /* skip this item */
  93.     buf = buf + dataLenLen + dataLen;
  94.     len = len + dataLenLen + dataLen;
  95. }
  96.     }
  97. }
  99. /*
  100. ** Capture the next thing in the buffer.
  101. ** Returns the length of the header and the length of the contents.
  102. */
  103. static SECStatus
  104. der_capture(unsigned char *buf, unsigned char *end,
  105.     int *header_len_p, uint32 *contents_len_p)
  106. {
  107.     unsigned char *bp;
  108.     unsigned char whole_tag;
  109.     uint32 contents_len;
  110.     int tag_number;
  112.     if ((buf + 2) > end) {
  113. *header_len_p = 0;
  114. *contents_len_p = 0;
  115. if (buf == end)
  116.     return SECSuccess;
  117. return SECFailure;
  118.     }
  120.     bp = buf;
  122.     /* Get tag and verify that it is ok. */
  123.     whole_tag = *bp++;
  124.     tag_number = whole_tag & DER_TAGNUM_MASK;
  126.     /*
  127.      * XXX This code does not (yet) handle the high-tag-number form!
  128.      */
  129.     if (tag_number == DER_HIGH_TAG_NUMBER) {
  130. PORT_SetError(SEC_ERROR_BAD_DER);
  131. return SECFailure;
  132.     }
  134.     if ((whole_tag & DER_CLASS_MASK) == DER_UNIVERSAL) {
  135. /* Check that the universal tag number is one we implement.  */
  136. switch (tag_number) {
  137.   case DER_BOOLEAN:
  138.   case DER_INTEGER:
  139.   case DER_BIT_STRING:
  140.   case DER_OCTET_STRING:
  141.   case DER_NULL:
  142.   case DER_OBJECT_ID:
  143.   case DER_SEQUENCE:
  144.   case DER_SET:
  145.   case DER_PRINTABLE_STRING:
  146.   case DER_T61_STRING:
  147.   case DER_IA5_STRING:
  148.   case DER_VISIBLE_STRING:
  149.   case DER_UTC_TIME:
  150.   case 0: /* end-of-contents tag */
  151.     break;
  152.   default:
  153.     PORT_SetError(SEC_ERROR_BAD_DER);
  154.     return SECFailure;
  155. }
  156.     }
  158.     /*
  159.      * Get first byte of length code (might contain entire length, might not).
  160.      */
  161.     contents_len = *bp++;
  163.     /*
  164.      * If the high bit is set, then the length is in multibyte format,
  165.      * or the thing has an indefinite-length.
  166.      */
  167.     if (contents_len & 0x80) {
  168. int bytes_of_encoded_len;
  170. bytes_of_encoded_len = contents_len & 0x7f;
  171. contents_len = 0;
  173. switch (bytes_of_encoded_len) {
  174.   case 4:
  175.     contents_len |= *bp++;
  176.     contents_len <<= 8;
  177.     /* fallthru */
  178.   case 3:
  179.     contents_len |= *bp++;
  180.     contents_len <<= 8;
  181.     /* fallthru */
  182.   case 2:
  183.     contents_len |= *bp++;
  184.     contents_len <<= 8;
  185.     /* fallthru */
  186.   case 1:
  187.     contents_len |= *bp++;
  188.     break;
  190.   case 0:
  191.     contents_len = der_indefinite_length (bp, end);
  192.     if (contents_len)
  193. break;
  194.     /* fallthru */
  195.   default:
  196.     PORT_SetError(SEC_ERROR_BAD_DER);
  197.     return SECFailure;
  198. }
  199.     }
  201.     if ((bp + contents_len) > end) {
  202. /* Ran past end of buffer */
  203. PORT_SetError(SEC_ERROR_BAD_DER);
  204. return SECFailure;
  205.     }
  207.     *header_len_p = bp - buf;
  208.     *contents_len_p = contents_len;
  210.     return SECSuccess;
  211. }
  213. static unsigned char *
  214. der_decode(PRArenaPool *arena, void *dest, DERTemplate *dtemplate,
  215.    unsigned char *buf, int header_len, uint32 contents_len)
  216. {
  217.     unsigned char *orig_buf, *end;
  218.     unsigned long encode_kind, under_kind;
  219.     PRBool explicit, optional, universal, check_tag;
  220.     SECItem *item;
  221.     SECStatus rv;
  222.     PRBool indefinite_length, explicit_indefinite_length;
  224.     encode_kind = dtemplate->kind;
  225.     explicit = (encode_kind & DER_EXPLICIT) ? PR_TRUE : PR_FALSE;
  226.     optional = (encode_kind & DER_OPTIONAL) ? PR_TRUE : PR_FALSE;
  227.     universal = ((encode_kind & DER_CLASS_MASK) == DER_UNIVERSAL)
  228. ? PR_TRUE : PR_FALSE;
  230.     PORT_Assert (!(explicit && universal)); /* bad templates */
  232.     if (header_len == 0) {
  233. if (optional || (encode_kind & DER_ANY))
  234.     return buf;
  235. PORT_SetError(SEC_ERROR_BAD_DER);
  236. return NULL;
  237.     }
  239.     if (encode_kind & DER_POINTER) {
  240. void *place, **placep;
  241. int offset;
  243. if (dtemplate->sub != NULL) {
  244.     dtemplate = dtemplate->sub;
  245.     under_kind = dtemplate->kind;
  246.     if (universal) {
  247. encode_kind = under_kind;
  248.     }
  249.     place = PORT_ArenaZAlloc(arena, dtemplate->arg);
  250.     offset = dtemplate->offset;
  251. } else {
  252.     if (universal) {
  253. under_kind = encode_kind & ~DER_POINTER;
  254.     } else {
  255. under_kind = dtemplate->arg;
  256.     }
  257.     place = PORT_ArenaZAlloc(arena, sizeof(SECItem));
  258.     offset = 0;
  259. }
  260. if (place == NULL) {
  261.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  262.     return NULL; /* Out of memory */
  263. }
  264. placep = (void **)dest;
  265. *placep = place;
  266. dest = (void *)((char *)place + offset);
  267.     } else if (encode_kind & DER_INLINE) {
  268. PORT_Assert (dtemplate->sub != NULL);
  269. dtemplate = dtemplate->sub;
  270. under_kind = dtemplate->kind;
  271. if (universal) {
  272.     encode_kind = under_kind;
  273. }
  274. dest = (void *)((char *)dest + dtemplate->offset);
  275.     } else if (universal) {
  276. under_kind = encode_kind;
  277.     } else {
  278. under_kind = dtemplate->arg;
  279.     }
  281.     orig_buf = buf;
  282.     end = buf + header_len + contents_len;
  284.     explicit_indefinite_length = PR_FALSE;
  286.     if (explicit) {
  287. /*
  288.  * This tag is expected to match exactly.
  289.  * (The template has all of the bits specified.)
  290.  */
  291. if (*buf != (encode_kind & DER_TAG_MASK)) {
  292.     if (optional)
  293. return buf;
  294.     PORT_SetError(SEC_ERROR_BAD_DER);
  295.     return NULL;
  296. }
  297. if ((header_len == 2) && (*(buf + 1) == 0x80))
  298.     explicit_indefinite_length = PR_TRUE;
  299. buf += header_len;
  300. rv = der_capture (buf, end, &header_len, &contents_len);
  301. if (rv != SECSuccess)
  302.     return NULL;
  303. if (header_len == 0) { /* XXX is this right? */
  304.     PORT_SetError(SEC_ERROR_BAD_DER);
  305.     return NULL;
  306. }
  307. optional = PR_FALSE; /* can no longer be optional */
  308. encode_kind = under_kind;
  309.     }
  311.     check_tag = PR_TRUE;
  312.     if (encode_kind & (DER_DERPTR | DER_ANY | DER_FORCE | DER_SKIP)) {
  313. PORT_Assert ((encode_kind & DER_ANY) || !optional);
  314. encode_kind = encode_kind & (~DER_FORCE);
  315. under_kind = under_kind & (~DER_FORCE);
  316. check_tag = PR_FALSE;
  317.     }
  319.     if (check_tag) {
  320. PRBool wrong;
  321. unsigned char expect_tag, expect_num;
  323. /*
  324.  * This tag is expected to match, but the simple types
  325.  * may or may not have the constructed bit set, so we
  326.  * have to have all this extra logic.
  327.  */
  328. wrong = PR_TRUE;
  329. expect_tag = encode_kind & DER_TAG_MASK;
  330. expect_num = expect_tag & DER_TAGNUM_MASK;
  331. if (expect_num == DER_SET || expect_num == DER_SEQUENCE) {
  332.     if (*buf == (expect_tag | DER_CONSTRUCTED))
  333. wrong = PR_FALSE;
  334. } else {
  335.     if (*buf == expect_tag)
  336. wrong = PR_FALSE;
  337.     else if (*buf == (expect_tag | DER_CONSTRUCTED))
  338. wrong = PR_FALSE;
  339. }
  340. if (wrong) {
  341.     if (optional)
  342. return buf;
  343.     PORT_SetError(SEC_ERROR_BAD_DER);
  344.     return NULL;
  345. }
  346.     }
  348.     if (under_kind & DER_DERPTR) {
  349. item = (SECItem *)dest;
  350. if (under_kind & DER_OUTER) {
  351.     item->data = buf;
  352.     item->len = header_len + contents_len;
  353. } else {
  354.     item->data = buf + header_len;
  355.     item->len = contents_len;
  356. }
  357. return orig_buf;
  358.     }
  360.     if (encode_kind & DER_ANY) {
  361. contents_len += header_len;
  362. header_len = 0;
  363.     }
  365.     if ((header_len == 2) && (*(buf + 1) == 0x80))
  366. indefinite_length = PR_TRUE;
  367.     else
  368. indefinite_length = PR_FALSE;
  370.     buf += header_len;
  372.     if (contents_len == 0)
  373. return buf;
  375.     under_kind &= ~DER_OPTIONAL;
  377.     if (under_kind & DER_INDEFINITE) {
  378. int count, thing_size;
  379. unsigned char *sub_buf;
  380. DERTemplate *tmpt;
  381. void *things, **indp, ***placep;
  383. under_kind &= ~DER_INDEFINITE;
  385. /*
  386.  * Count items.
  387.  */
  388. count = 0;
  389. sub_buf = buf;
  390. while (sub_buf < end) {
  391.     if (indefinite_length && sub_buf[0] == 0 && sub_buf[1] == 0) {
  392. break; 
  393.     }
  394.     rv = der_capture (sub_buf, end, &header_len, &contents_len);
  395.     if (rv != SECSuccess)
  396. return NULL;
  397.     count++;
  398.     sub_buf += header_len + contents_len;
  399. }
  401. /*
  402.  * Allocate an array of pointers to items; extra one is for a NULL.
  403.  */
  404. indp = (void**)PORT_ArenaZAlloc(arena, (count + 1) * sizeof(void *));
  405. if (indp == NULL) {
  406.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  407.     return NULL;
  408. }
  410. /*
  411.  * Prepare.
  412.  */
  413. if (under_kind == DER_SET || under_kind == DER_SEQUENCE) {
  414.     tmpt = dtemplate->sub;
  415.     PORT_Assert (tmpt != NULL);
  416.     thing_size = tmpt->arg;
  417.     PORT_Assert (thing_size != 0);
  418. } else {
  419.     tmpt = NULL;
  420.     thing_size = sizeof(SECItem);
  421. }
  423. /*
  424.  * Allocate the items themselves.
  425.  */
  426. things = PORT_ArenaZAlloc(arena, count * thing_size);
  427. if (things == NULL) {
  428.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  429.     return NULL;
  430. }
  432. placep = (void ***)dest;
  433. *placep = indp;
  435. while (count) {
  436.     /* ignore return value because we already did whole thing above */
  437.     (void) der_capture (buf, end, &header_len, &contents_len);
  438.     if (tmpt != NULL) {
  439. void *sub_thing;
  441. sub_thing = (void *)((char *)things + tmpt->offset);
  442. buf = der_decode (arena, sub_thing, tmpt,
  443.   buf, header_len, contents_len);
  444. if (buf == NULL)
  445.     return NULL;
  446.     } else {
  447. item = (SECItem *)things;
  448. if (under_kind == DER_ANY) {
  449.     contents_len += header_len;
  450.     header_len = 0;
  451. }
  452. buf += header_len;
  453. if (under_kind == DER_BIT_STRING) {
  454.     item->data = buf + 1;
  455.     item->len = ((contents_len - 1) << 3) - *buf;
  456. } else {
  457.     item->data = buf;
  458.     item->len = contents_len;
  459. }
  460. buf += contents_len;
  461.     }
  462.     *indp++ = things;
  463.     things = (void *)((char *)things + thing_size);
  464.     count--;
  465. }
  467. *indp = NULL;
  469. goto der_decode_done;
  470.     }
  472.     switch (under_kind) {
  473.       case DER_SEQUENCE:
  474.       case DER_SET:
  475. {
  476.     DERTemplate *tmpt;
  477.     void *sub_dest;
  479.     for (tmpt = dtemplate + 1; tmpt->kind; tmpt++) {
  480. sub_dest = (void *)((char *)dest + tmpt->offset);
  481. rv = der_capture (buf, end, &header_len, &contents_len);
  482. if (rv != SECSuccess)
  483.     return NULL;
  484. buf = der_decode (arena, sub_dest, tmpt,
  485.   buf, header_len, contents_len);
  486. if (buf == NULL)
  487.     return NULL;
  488.     }
  489. }
  490. break;
  492.       case DER_BIT_STRING:
  493. item = (SECItem *)dest;
  494. item->data = buf + 1;
  495. item->len = ((contents_len - 1) << 3) - *buf;
  496. buf += contents_len;
  497. break;
  499.       case DER_SKIP:
  500. buf += contents_len;
  501. break;
  503.       default:
  504. item = (SECItem *)dest;
  505. item->data = buf;
  506. item->len = contents_len;
  507. buf += contents_len;
  508. break;
  509.     }
  511. der_decode_done:
  513.     if (indefinite_length && buf[0] == 0 && buf[1] == 0) {
  514. buf += 2;
  515.     }
  517.     if (explicit_indefinite_length && buf[0] == 0 && buf[1] == 0) {
  518. buf += 2;
  519.     }
  521.     return buf;
  522. }
  524. SECStatus
  525. DER_Decode(PRArenaPool *arena, void *dest, DERTemplate *dtemplate, SECItem *src)
  526. {
  527.     unsigned char *buf;
  528.     uint32 buf_len, contents_len;
  529.     int header_len;
  530.     SECStatus rv;
  532.     buf = src->data;
  533.     buf_len = src->len;
  535.     rv = der_capture (buf, buf + buf_len, &header_len, &contents_len);
  536.     if (rv != SECSuccess)
  537. return rv;
  539.     dest = (void *)((char *)dest + dtemplate->offset);
  540.     buf = der_decode (arena, dest, dtemplate, buf, header_len, contents_len);
  541.     if (buf == NULL)
  542. return SECFailure;
  544.     return SECSuccess;
  545. }
  547. SECStatus
  548. DER_Lengths(SECItem *item, int *header_len_p, uint32 *contents_len_p)
  549. {
  550.     return(der_capture(item->data, &item->data[item->len], header_len_p,
  551.        contents_len_p));
  552. }