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

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

CA认证

开发平台：

WINDOWS

derenc.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"
  36. /*
  37.  * Generic templates for individual/simple items.
  38.  */
  40. DERTemplate SECAnyTemplate[] = {
  41.     { DER_ANY,
  42.   0, NULL, sizeof(SECItem) }
  43. };
  45. DERTemplate SECBitStringTemplate[] = {
  46.     { DER_BIT_STRING,
  47.   0, NULL, sizeof(SECItem) }
  48. };
  50. DERTemplate SECBooleanTemplate[] = {
  51.     { DER_BOOLEAN,
  52.   0, NULL, sizeof(SECItem) }
  53. };
  55. DERTemplate SECIA5StringTemplate[] = {
  56.     { DER_IA5_STRING,
  57.   0, NULL, sizeof(SECItem) }
  58. };
  60. DERTemplate SECIntegerTemplate[] = {
  61.     { DER_INTEGER,
  62.   0, NULL, sizeof(SECItem) }
  63. };
  65. DERTemplate SECNullTemplate[] = {
  66.     { DER_NULL,
  67.   0, NULL, sizeof(SECItem) }
  68. };
  70. DERTemplate SECObjectIDTemplate[] = {
  71.     { DER_OBJECT_ID,
  72.   0, NULL, sizeof(SECItem) }
  73. };
  75. DERTemplate SECOctetStringTemplate[] = {
  76.     { DER_OCTET_STRING,
  77.   0, NULL, sizeof(SECItem) }
  78. };
  80. DERTemplate SECPrintableStringTemplate[] = {
  81.     { DER_PRINTABLE_STRING,
  82.   0, NULL, sizeof(SECItem) }
  83. };
  85. DERTemplate SECT61StringTemplate[] = {
  86.     { DER_T61_STRING,
  87.   0, NULL, sizeof(SECItem) }
  88. };
  90. DERTemplate SECUTCTimeTemplate[] = {
  91.     { DER_UTC_TIME,
  92.   0, NULL, sizeof(SECItem) }
  93. };
  96. static int
  97. header_length(DERTemplate *dtemplate, uint32 contents_len)
  98. {
  99.     uint32 len;
  100.     unsigned long encode_kind, under_kind;
  101.     PRBool explicit, optional, universal;
  103.     encode_kind = dtemplate->kind;
  105.     explicit = (encode_kind & DER_EXPLICIT) ? PR_TRUE : PR_FALSE;
  106.     optional = (encode_kind & DER_OPTIONAL) ? PR_TRUE : PR_FALSE;
  107.     universal = ((encode_kind & DER_CLASS_MASK) == DER_UNIVERSAL)
  108. ? PR_TRUE : PR_FALSE;
  110.     PORT_Assert (!(explicit && universal)); /* bad templates */
  112.     if (encode_kind & DER_POINTER) {
  113. if (dtemplate->sub != NULL) {
  114.     under_kind = dtemplate->sub->kind;
  115.     if (universal) {
  116. encode_kind = under_kind;
  117.     }
  118. } else if (universal) {
  119.     under_kind = encode_kind & ~DER_POINTER;
  120. } else {
  121.     under_kind = dtemplate->arg;
  122. }
  123.     } else if (encode_kind & DER_INLINE) {
  124. under_kind = dtemplate->sub->kind;
  125. if (universal) {
  126.     encode_kind = under_kind;
  127. }
  128.     } else if (universal) {
  129. under_kind = encode_kind;
  130.     } else {
  131. under_kind = dtemplate->arg;
  132.     }
  134.     /* This is only used in decoding; it plays no part in encoding.  */
  135.     if (under_kind & DER_DERPTR)
  136. return 0;
  138.     /* No header at all for an "empty" optional.  */
  139.     if ((contents_len == 0) && optional)
  140. return 0;
  142.     /* And no header for a full DER_ANY.  */
  143.     if (encode_kind & DER_ANY)
  144. return 0;
  146.     /*
  147.      * The common case: one octet for identifier and as many octets
  148.      * as necessary to hold the content length.
  149.      */
  150.     len = 1 + DER_LengthLength(contents_len);
  152.     /* Account for the explicit wrapper, if necessary.  */
  153.     if (explicit) {
  154. #if 0 /*
  155.  * Well, I was trying to do something useful, but these
  156.  * assertions are too restrictive on valid templates.
  157.  * I wanted to make sure that the top-level "kind" of
  158.  * a template does not also specify DER_EXPLICIT, which
  159.  * should only modify a component field.  Maybe later
  160.  * I can figure out a better way to detect such a problem,
  161.  * but for now I must remove these checks altogether.
  162.  */
  163. /*
  164.  * This modifier applies only to components of a set or sequence;
  165.  * it should never be used on a set/sequence itself -- confirm.
  166.  */
  167. PORT_Assert (under_kind != DER_SEQUENCE);
  168. PORT_Assert (under_kind != DER_SET);
  169. #endif
  171. len += 1 + DER_LengthLength(len + contents_len);
  172.     }
  174.     return len;
  175. }
  178. static uint32
  179. contents_length(DERTemplate *dtemplate, void *src)
  180. {
  181.     uint32 len;
  182.     unsigned long encode_kind, under_kind;
  183.     PRBool universal;
  186.     PORT_Assert (src != NULL);
  188.     encode_kind = dtemplate->kind;
  190.     universal = ((encode_kind & DER_CLASS_MASK) == DER_UNIVERSAL)
  191. ? PR_TRUE : PR_FALSE;
  192.     encode_kind &= ~DER_OPTIONAL;
  194.     if (encode_kind & DER_POINTER) {
  195. src = *(void **)src;
  196. if (src == NULL) {
  197.     return 0;
  198. }
  199. if (dtemplate->sub != NULL) {
  200.     dtemplate = dtemplate->sub;
  201.     under_kind = dtemplate->kind;
  202.     src = (void *)((char *)src + dtemplate->offset);
  203. } else if (universal) {
  204.     under_kind = encode_kind & ~DER_POINTER;
  205. } else {
  206.     under_kind = dtemplate->arg;
  207. }
  208.     } else if (encode_kind & DER_INLINE) {
  209. PORT_Assert (dtemplate->sub != NULL);
  210. dtemplate = dtemplate->sub;
  211. under_kind = dtemplate->kind;
  212. src = (void *)((char *)src + dtemplate->offset);
  213.     } else if (universal) {
  214. under_kind = encode_kind;
  215.     } else {
  216. under_kind = dtemplate->arg;
  217.     }
  219.     /* Having any of these bits is not expected here...  */
  220.     PORT_Assert ((under_kind & (DER_EXPLICIT | DER_INLINE | DER_OPTIONAL
  221. | DER_POINTER | DER_SKIP)) == 0);
  223.     /* This is only used in decoding; it plays no part in encoding.  */
  224.     if (under_kind & DER_DERPTR)
  225. return 0;
  227.     if (under_kind & DER_INDEFINITE) {
  228. uint32 sub_len;
  229. void **indp;
  231. indp = *(void ***)src;
  232. if (indp == NULL)
  233.     return 0;
  235. len = 0;
  236. under_kind &= ~DER_INDEFINITE;
  238. if (under_kind == DER_SET || under_kind == DER_SEQUENCE) {
  239.     DERTemplate *tmpt;
  240.     void *sub_src;
  242.     tmpt = dtemplate->sub;
  244.     for (; *indp != NULL; indp++) {
  245. sub_src = (void *)((char *)(*indp) + tmpt->offset);
  246. sub_len = contents_length (tmpt, sub_src);
  247. len += sub_len + header_length (tmpt, sub_len);
  248.     }
  249. } else {
  250.     /*
  251.      * XXX Lisa is not sure this code (for handling, for example,
  252.      * DER_INDEFINITE | DER_OCTET_STRING) is right.
  253.      */
  254.     for (; *indp != NULL; indp++) {
  255. SECItem *item;
  256. item = (SECItem *)(*indp);
  257. sub_len = item->len;
  258. if (under_kind == DER_BIT_STRING) {
  259.     sub_len = (sub_len + 7) >> 3;
  260.     /* bit string contents involve an extra octet */
  261.     if (sub_len)
  262. sub_len++;
  263. }
  264. if (under_kind != DER_ANY)
  265.     len += 1 + DER_LengthLength (sub_len);
  266.     }
  267. }
  269. return len;
  270.     }
  272.     switch (under_kind) {
  273.       case DER_SEQUENCE:
  274.       case DER_SET:
  275. {
  276.     DERTemplate *tmpt;
  277.     void *sub_src;
  278.     uint32 sub_len;
  280.     len = 0;
  281.     for (tmpt = dtemplate + 1; tmpt->kind; tmpt++) {
  282. sub_src = (void *)((char *)src + tmpt->offset);
  283. sub_len = contents_length (tmpt, sub_src);
  284. len += sub_len + header_length (tmpt, sub_len);
  285.     }
  286. }
  287. break;
  289.       case DER_BIT_STRING:
  290. len = (((SECItem *)src)->len + 7) >> 3;
  291. /* bit string contents involve an extra octet */
  292. if (len)
  293.     len++;
  294. break;
  296.       default:
  297. len = ((SECItem *)src)->len;
  298. break;
  299.     }
  301.     return len;
  302. }
  305. static unsigned char *
  306. der_encode(unsigned char *buf, DERTemplate *dtemplate, void *src)
  307. {
  308.     int header_len;
  309.     uint32 contents_len;
  310.     unsigned long encode_kind, under_kind;
  311.     PRBool explicit, optional, universal;
  314.     /*
  315.      * First figure out how long the encoding will be.  Do this by
  316.      * traversing the template from top to bottom and accumulating
  317.      * the length of each leaf item.
  318.      */
  319.     contents_len = contents_length (dtemplate, src);
  320.     header_len = header_length (dtemplate, contents_len);
  322.     /*
  323.      * Enough smarts was involved already, so that if both the
  324.      * header and the contents have a length of zero, then we
  325.      * are not doing any encoding for this element.
  326.      */
  327.     if (header_len == 0 && contents_len == 0)
  328. return buf;
  330.     encode_kind = dtemplate->kind;
  332.     explicit = (encode_kind & DER_EXPLICIT) ? PR_TRUE : PR_FALSE;
  333.     optional = (encode_kind & DER_OPTIONAL) ? PR_TRUE : PR_FALSE;
  334.     encode_kind &= ~DER_OPTIONAL;
  335.     universal = ((encode_kind & DER_CLASS_MASK) == DER_UNIVERSAL)
  336. ? PR_TRUE : PR_FALSE;
  338.     if (encode_kind & DER_POINTER) {
  339. if (contents_len) {
  340.     src = *(void **)src;
  341.     PORT_Assert (src != NULL);
  342. }
  343. if (dtemplate->sub != NULL) {
  344.     dtemplate = dtemplate->sub;
  345.     under_kind = dtemplate->kind;
  346.     if (universal) {
  347. encode_kind = under_kind;
  348.     }
  349.     src = (void *)((char *)src + dtemplate->offset);
  350. } else if (universal) {
  351.     under_kind = encode_kind & ~DER_POINTER;
  352. } else {
  353.     under_kind = dtemplate->arg;
  354. }
  355.     } else if (encode_kind & DER_INLINE) {
  356. dtemplate = dtemplate->sub;
  357. under_kind = dtemplate->kind;
  358. if (universal) {
  359.     encode_kind = under_kind;
  360. }
  361. src = (void *)((char *)src + dtemplate->offset);
  362.     } else if (universal) {
  363. under_kind = encode_kind;
  364.     } else {
  365. under_kind = dtemplate->arg;
  366.     }
  368.     if (explicit) {
  369. buf = DER_StoreHeader (buf, encode_kind,
  370.        (1 + DER_LengthLength(contents_len)
  371. + contents_len));
  372. encode_kind = under_kind;
  373.     }
  375.     if ((encode_kind & DER_ANY) == 0) { /* DER_ANY already contains header */
  376. buf = DER_StoreHeader (buf, encode_kind, contents_len);
  377.     }
  379.     /* If no real contents to encode, then we are done.  */
  380.     if (contents_len == 0)
  381. return buf;
  383.     if (under_kind & DER_INDEFINITE) {
  384. void **indp;
  386. indp = *(void ***)src;
  387. PORT_Assert (indp != NULL);
  389. under_kind &= ~DER_INDEFINITE;
  390. if (under_kind == DER_SET || under_kind == DER_SEQUENCE) {
  391.     DERTemplate *tmpt;
  392.     void *sub_src;
  394.     tmpt = dtemplate->sub;
  395.     for (; *indp != NULL; indp++) {
  396. sub_src = (void *)((char *)(*indp) + tmpt->offset);
  397. buf = der_encode (buf, tmpt, sub_src);
  398.     }
  399. } else {
  400.     for (; *indp != NULL; indp++) {
  401. SECItem *item;
  402. int sub_len;
  404. item = (SECItem *)(*indp);
  405. sub_len = item->len;
  406. if (under_kind == DER_BIT_STRING) {
  407.     if (sub_len) {
  408. int rem;
  410. sub_len = (sub_len + 7) >> 3;
  411. buf = DER_StoreHeader (buf, under_kind, sub_len + 1);
  412. rem = (sub_len << 3) - item->len;
  413. *buf++ = rem; /* remaining bits */
  414.     } else {
  415. buf = DER_StoreHeader (buf, under_kind, 0);
  416.     }
  417. } else if (under_kind != DER_ANY) {
  418.     buf = DER_StoreHeader (buf, under_kind, sub_len);
  419. }
  420. PORT_Memcpy (buf, item->data, sub_len);
  421. buf += sub_len;
  422.     }
  423. }
  424. return buf;
  425.     }
  427.     switch (under_kind) {
  428.       case DER_SEQUENCE:
  429.       case DER_SET:
  430. {
  431.     DERTemplate *tmpt;
  432.     void *sub_src;
  434.     for (tmpt = dtemplate + 1; tmpt->kind; tmpt++) {
  435. sub_src = (void *)((char *)src + tmpt->offset);
  436. buf = der_encode (buf, tmpt, sub_src);
  437.     }
  438. }
  439. break;
  441.       case DER_BIT_STRING:
  442. {
  443.     SECItem *item;
  444.     int rem;
  446.     /*
  447.      * The contents length includes our extra octet; subtract
  448.      * it off so we just have the real string length there.
  449.      */
  450.     contents_len--;
  451.     item = (SECItem *)src;
  452.     PORT_Assert (contents_len == ((item->len + 7) >> 3));
  453.     rem = (contents_len << 3) - item->len;
  454.     *buf++ = rem; /* remaining bits */
  455.     PORT_Memcpy (buf, item->data, contents_len);
  456.     buf += contents_len;
  457. }
  458. break;
  460.       default:
  461. {
  462.     SECItem *item;
  464.     item = (SECItem *)src;
  465.     PORT_Assert (contents_len == item->len);
  466.     PORT_Memcpy (buf, item->data, contents_len);
  467.     buf += contents_len;
  468. }
  469. break;
  470.     }
  472.     return buf;
  473. }
  476. SECStatus
  477. DER_Encode(PRArenaPool *arena, SECItem *dest, DERTemplate *dtemplate, void *src)
  478. {
  479.     unsigned int contents_len, header_len;
  481.     src = (void **)((char *)src + dtemplate->offset);
  483.     /*
  484.      * First figure out how long the encoding will be. Do this by
  485.      * traversing the template from top to bottom and accumulating
  486.      * the length of each leaf item.
  487.      */
  488.     contents_len = contents_length (dtemplate, src);
  489.     header_len = header_length (dtemplate, contents_len);
  491.     dest->len = contents_len + header_len;
  493.     /* Allocate storage to hold the encoding */
  494.     dest->data = (unsigned char*) PORT_ArenaAlloc(arena, dest->len);
  495.     if (dest->data == NULL) {
  496. PORT_SetError(SEC_ERROR_NO_MEMORY);
  497. return SECFailure;
  498.     }
  500.     /* Now encode into the buffer */
  501.     (void) der_encode (dest->data, dtemplate, src);
  503.     return SECSuccess;
  504. }