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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
asn1_der_decode.C
资源名称：certlib.tar.gz　[点击查看]
上传用户：zbbssh
上传日期：2007-01-08
资源大小：196k
文件大小：14k
源码类别：

CA认证

开发平台：

C/C++

asn1_der_decode.C：源码内容
  1. /*
  2. ------------------------------------------------------------------
  3.   Copyright
  4.   Sun Microsystems, Inc.
  7.   Copyright (C) 1994, 1995, 1996 Sun Microsystems, Inc.  All Rights
  8.   Reserved.
  10.   Permission is hereby granted, free of charge, to any person
  11.   obtaining a copy of this software and associated documentation
  12.   files (the "Software"), to deal in the Software without
  13.   restriction, including without limitation the rights to use,
  14.   copy, modify, merge, publish, distribute, sublicense, and/or sell
  15.   copies of the Software or derivatives of the Software, and to 
  16.   permit persons to whom the Software or its derivatives is furnished 
  17.   to do so, subject to the following conditions:
  19.   The above copyright notice and this permission notice shall be
  20.   included in all copies or substantial portions of the Software.
  22.   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23.   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  24.   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25.   NONINFRINGEMENT.  IN NO EVENT SHALL SUN MICROSYSTEMS, INC., BE LIABLE
  26.   FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27.   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  28.   CONNECTION WITH THE SOFTWARE OR DERIVATES OF THIS SOFTWARE OR 
  29.   THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31.   Except as contained in this notice, the name of Sun Microsystems, Inc.
  32.   shall not be used in advertising or otherwise to promote
  33.   the sale, use or other dealings in this Software or its derivatives 
  34.   without prior written authorization from Sun Microsystems, Inc.
  35. */
  36. #pragma ident "@(#)asn1_der_decode.C 1.5 96/01/29 Sun Microsystems"
  38. #include <sys/types.h>
  39. #include <stdarg.h>
  40. #include <stdlib.h>
  41. #include <stdio.h>
  42. #include "my_types.h"
  43. #include "Time.h"
  44. #include "Bigint.h"
  45. #include "Bstream.h"
  46. #include "asn1_der.h"
  47. #include "ObjId.h"
  49. /*
  50.  * Encoding decoding routines for ASN.1 using
  51.  * the Basic Encoding Rules subset DER
  52.  */
  54. void asn1_perror(int errcode)
  55. {
  56. printf("ASN.1 decoding error: ");
  57. switch(errcode) {
  58. case E_DER_DECODE_LEN_TOO_LONG:
  59. printf("length octets exceed length of buffern");
  60. break;
  61. case E_DER_DECODE_BAD_ID_OCTET:
  62. printf("unexpected ID octetn");
  63. break;
  64. case E_DER_DECODE_UNEXPECTED_EOS:
  65. printf("unexpected end-of-streamn");
  66. break;
  67. case E_DER_DECODE_BAD_BITSTRING:
  68. printf("bad bitstringn");
  69. break;
  70. case E_DER_DECODE_UNALIGNED_BS:
  71. printf("bitsring not octet alignedn");
  72. break;
  73. case E_DER_DECODE_BAD_OBJID_SUBID:
  74. printf("bad sub-identifier of OBJECT-IDENTIFIERn");
  75. break;
  76. case E_DER_DECODE_BAD_TIME_STRING:
  77. printf("bad UTCTime stringn");
  78. break;
  79. case E_DER_DECODE_BAD_NULL_VALUE:
  80. printf("bad null value, length not equal to zeron");
  81. break;
  82. default:
  83. printf("unknown error code %dn", errcode);
  84. break;
  85. }
  86. return;
  87. }
  88. int convert_bytes_to_int(byte *four_bytes)
  89. {
  90. #if defined(sparc)
  91. int val;
  92. byte *bytep = (byte *)&val;
  94. bytep[0] = four_bytes[3];
  95. bytep[1] = four_bytes[2];
  96. bytep[2] = four_bytes[1];
  97. bytep[3] = four_bytes[0];
  98. return (val);
  99. #else 
  100. #if defined(i386)
  101.         int val;
  102.         byte *bytep = (byte *)&val;
  103.  
  104.         bytep[0] = four_bytes[0];
  105.         bytep[1] = four_bytes[1];
  106.         bytep[2] = four_bytes[2];
  107.         bytep[3] = four_bytes[3];
  108.         return (val);
  109. #else
  111. return "Architecture not supported";
  112. #endif /* i386 */
  113. #endif /* sparc */
  114. }
  116. /*
  117.  * Do ASN.1 DER length octets processing.
  118.  * We assume that the number of content
  119.  * octets will never exceed 2**32 octets.
  120.  */
  121. int asn1_der_get_length(Bstream& der_stream)
  122. {
  123. byte tmp = 0;
  124. int  len;
  125. const int MAXLENBYTES = 4; /*Greater than 32 bits should not be required*/
  126. byte    lenbytes[MAXLENBYTES];
  127. int  i, ret;
  129. ret = der_stream.fetchbyte(tmp);
  130. if (ret == EOS)
  131. return (E_DER_DECODE_UNEXPECTED_EOS);
  133. #ifdef __GNUC__
  134. if ((tmp & 0x80) == 0 ) {
  135. #else
  136. if ((tmp & 0x80) == NULL ) {
  137. #endif
  138. len = tmp;
  139. } else {
  141. int  numbytes = tmp & 0x7f;
  142. if (numbytes > MAXLENBYTES)
  143. return (E_DER_DECODE_LEN_TOO_LONG);
  144. if (numbytes > der_stream.getlength())
  145. return (E_DER_DECODE_UNEXPECTED_EOS);
  146. bzero(lenbytes, sizeof(lenbytes));
  147. for (i = numbytes - 1; i >= 0; i--)
  148. (void ) der_stream.fetchbyte(lenbytes[i]);
  149. len = convert_bytes_to_int(lenbytes);
  150. }
  151. return (len);
  152. }
  154. /*
  155.  * Decode an ASN.1 DER INTEGER
  156.  */
  157. int asn1_der_decode_integer(Bstream& der_stream, Bigint& val)
  158. {
  159. byte tmp = 0;
  160. int  len;
  162. if (der_stream.getlength() < 2)
  163. return (E_DER_DECODE_UNEXPECTED_EOS);
  164. (void )der_stream.peekbyte(tmp);
  165. if (tmp != INTEGER_ID) {
  166. return (E_DER_DECODE_BAD_ID_OCTET);
  167. }
  168. (void )der_stream.fetchbyte(tmp);
  169. len = asn1_der_get_length(der_stream);
  170. if (len < 0) return len;
  171. if (len > der_stream.getlength()) 
  172. return (E_DER_DECODE_UNEXPECTED_EOS);
  173. Bigint tmpval((unsigned char *)der_stream.getdatap(), len);
  174. der_stream.consume(len);
  175. val = tmpval;
  176. return (0);
  177. }
  179. /*
  180.  * Decode the ID part of a SEQUENCE
  181.  */
  182. int asn1_der_decode_sequence(Bstream& der_stream, int &len)
  183. {
  184. byte tmp = 0;
  186. if (der_stream.getlength() < 2)
  187. return (E_DER_DECODE_UNEXPECTED_EOS);
  188. (void )der_stream.peekbyte(tmp);
  189. if (tmp != SEQUENCE_ID) {
  190. return (E_DER_DECODE_BAD_ID_OCTET);
  191. }
  192. (void )der_stream.fetchbyte(tmp);
  193. len = asn1_der_get_length(der_stream);
  194. if (len > der_stream.getlength()) {
  195. return (E_DER_DECODE_UNEXPECTED_EOS);
  196. }
  197. return (SUCCESS);
  198. }
  200. int asn1_der_decode_sequence_of(Bstream& der_stream, int &len)
  201. {
  202. return (asn1_der_decode_sequence(der_stream, len));
  203. }
  205. /*
  206.  * Decode the ID part of a SET
  207.  */
  208. int asn1_der_decode_set(Bstream& der_stream, int &len)
  209. {
  210. byte tmp = 0;
  212. if (der_stream.getlength() < 2)
  213. return (E_DER_DECODE_UNEXPECTED_EOS);
  214. (void )der_stream.peekbyte(tmp);
  215. if (tmp != SET_ID) {
  216. return (E_DER_DECODE_BAD_ID_OCTET);
  217. }
  218. (void )der_stream.fetchbyte(tmp);
  219. len = asn1_der_get_length(der_stream);
  220. if (len > der_stream.getlength()) {
  221. return (E_DER_DECODE_UNEXPECTED_EOS);
  222. }
  223. return (SUCCESS);
  224. }
  226. /*
  227.  * Decode NULL type
  228.  */
  229. int asn1_der_decode_null(Bstream& der_stream)
  230. {
  231. byte tmp = 0;
  232. int  len;
  234. if (der_stream.getlength() < 2)
  235. return (E_DER_DECODE_UNEXPECTED_EOS);
  236. (void )der_stream.peekbyte(tmp);
  237. if (tmp != NULL_ID) {
  238. return (E_DER_DECODE_BAD_ID_OCTET);
  239. }
  240. (void )der_stream.fetchbyte(tmp);
  241. len = asn1_der_get_length(der_stream);
  242. if (len != 0)
  243. return(E_DER_DECODE_BAD_NULL_VALUE);
  244. return (SUCCESS);
  245. }
  247. int asn1_der_decode_set_of(Bstream& der_stream, int &len)
  248. {
  249. return (asn1_der_decode_set(der_stream, len));
  250. }
  252. /*
  253.  * Decode a BIT-STRING
  254.  */
  255. int asn1_der_decode_bit_string(Bstream& der_stream, Bstream& bitstring)
  256. {
  257. byte tmp = 0;
  258. int  len, ret;
  260. if (der_stream.getlength() < 2)
  261. return (E_DER_DECODE_UNEXPECTED_EOS);
  262. (void )der_stream.peekbyte(tmp);
  263. if (tmp != BIT_STRING_ID) {
  264. return (E_DER_DECODE_BAD_ID_OCTET);
  265. }
  266. (void )der_stream.fetchbyte(tmp);
  267. len = asn1_der_get_length(der_stream);
  268. if (len < 0) return len;
  269. if (len == 0) return (E_DER_DECODE_BAD_BITSTRING);
  270. if (len > der_stream.getlength()) 
  271. return (E_DER_DECODE_UNEXPECTED_EOS);
  272. ret = der_stream.fetchbyte(tmp);
  273. if (ret == EOS)
  274. return (SUCCESS);
  275. if (len == 1) {
  276. if (tmp == 0) return (SUCCESS);
  277. else return (E_DER_DECODE_BAD_BITSTRING);
  278. }
  279. if (tmp > 7 ) 
  280. return (E_DER_DECODE_BAD_BITSTRING);
  282. // Special Hack for certificates, which
  283. // are assumed to produce octet aligned quantities
  284. if (tmp != 0)
  285. return (E_DER_DECODE_UNALIGNED_BS);
  287. Bstream tmpstr(len - 1, der_stream.getdatap());
  288. der_stream.consume(len - 1);
  289. bitstring = tmpstr;
  290. return (SUCCESS);
  291. }
  293. /*
  294.  * Decode an OCTET-STRING
  295.  */
  296. int asn1_der_decode_octet_string(Bstream& der_stream, Bstream& octetstring)
  297. {
  298. byte tmp = 0;
  299. int  len;
  301. if (der_stream.getlength() < 2)
  302. return (E_DER_DECODE_UNEXPECTED_EOS);
  303. (void )der_stream.peekbyte(tmp);
  304. if (tmp != OCTET_STRING_ID) {
  305. return (E_DER_DECODE_BAD_ID_OCTET);
  306. }
  307. (void )der_stream.fetchbyte(tmp);
  308. len = asn1_der_get_length(der_stream);
  309. if (len < 0) return len;
  310. if (len > der_stream.getlength()) 
  311. return (E_DER_DECODE_UNEXPECTED_EOS);
  312. Bstream tmpstr(len, der_stream.getdatap());
  313. der_stream.consume(len);
  314. octetstring = tmpstr;
  315. return (SUCCESS);
  316. }
  318. /*
  319.  * Decode a PRINTABLE-STRING
  320.  */
  321. int asn1_der_decode_printable_string(Bstream& der_stream, Bstream& prstring)
  322. {
  323. byte tmp = 0;
  324. int  len;
  326. if (der_stream.getlength() < 2)
  327. return (E_DER_DECODE_UNEXPECTED_EOS);
  328. (void )der_stream.peekbyte(tmp);
  329. if (tmp != PRINTABLE_STRING_ID) {
  330. return (E_DER_DECODE_BAD_ID_OCTET);
  331. }
  332. (void )der_stream.fetchbyte(tmp);
  333. len = asn1_der_get_length(der_stream);
  334. if (len < 0) return len;
  335. if (len > der_stream.getlength()) {
  336. return (E_DER_DECODE_UNEXPECTED_EOS);
  337. }
  338. Bstream tmpstr(len, der_stream.getdatap());
  339. der_stream.consume(len);
  340. prstring = tmpstr;
  341. return (SUCCESS);
  342. }
  344. /*
  345.  * Decode a T61-STRING
  346.  */
  347. int asn1_der_decode_T61_string(Bstream& der_stream, Bstream& prstring)
  348. {
  349. byte tmp = 0;
  350. int  len;
  352. if (der_stream.getlength() < 2)
  353. return (E_DER_DECODE_UNEXPECTED_EOS);
  354. (void )der_stream.peekbyte(tmp);
  355. if (tmp != T61_STRING_ID) {
  356. return (E_DER_DECODE_BAD_ID_OCTET);
  357. }
  358. (void )der_stream.fetchbyte(tmp);
  359. len = asn1_der_get_length(der_stream);
  360. if (len < 0) return len;
  361. if (len > der_stream.getlength()) 
  362. return (E_DER_DECODE_UNEXPECTED_EOS);
  363. Bstream tmpstr(len, der_stream.getdatap());
  364. der_stream.consume(len);
  365. prstring = tmpstr;
  366. return (SUCCESS);
  367. }
  369. inline void  get_twodigits(Bstream& tmpstr, byte *two_digits)
  370. {
  371. (void) tmpstr.fetchbyte(two_digits[0]);
  372. (void) tmpstr.fetchbyte(two_digits[1]);
  373. }
  375. /*
  376.  * Decode a UTCTime
  377.  */
  378. int asn1_der_decode_utctime(Bstream& der_stream, PCTime& time)
  379. {
  380. byte tmp = 0;
  381. int  len;
  382. byte two_digits[3];
  383. char sign;
  384. int year, month, day, hour, min, offhr, offmin;
  385. int sec = 0;
  387. if (der_stream.getlength() < 2)
  388. return (E_DER_DECODE_UNEXPECTED_EOS);
  389. (void )der_stream.peekbyte(tmp);
  390. if (tmp != UTCTime_ID) {
  391. return (E_DER_DECODE_BAD_ID_OCTET);
  392. }
  393. (void )der_stream.fetchbyte(tmp);
  394. len = asn1_der_get_length(der_stream);
  395. if (len < 0) return len;
  396. if (len > der_stream.getlength()) 
  397. return (E_DER_DECODE_UNEXPECTED_EOS);
  398. Bstream tmpstr(len, der_stream.getdatap());
  399. der_stream.consume(len);
  400. // Parse the Time string
  401. if (len < 11 || len > 17) {
  402. return (E_DER_DECODE_BAD_TIME_STRING);
  403. }
  404. two_digits[2] = 0; // null terminate 
  405. get_twodigits(tmpstr, two_digits);
  406. year = atoi((char *)two_digits);
  407. // Convert last two digits to full year, including century.
  408. // For this we assume that anything less than 80 is 20XX
  409. // and anything more than or equal to 80 is 19XX.
  410. // Is there a better way of doing this? XXXX
  411. if (year < 80) {
  412. year += 2000; // Fix this piece of code after year 2080!!
  413. } else {
  414. year += 1900;
  415. }
  416. get_twodigits(tmpstr, two_digits);
  417. month = atoi((char *)two_digits);
  418. get_twodigits(tmpstr, two_digits);
  419. day = atoi((char *)two_digits);
  420. get_twodigits(tmpstr, two_digits);
  421. hour = atoi((char *)two_digits);
  422. get_twodigits(tmpstr, two_digits);
  423. min = atoi((char *)two_digits);
  424. if (len == 13 || len == 17) { // secs present
  425. get_twodigits(tmpstr, two_digits);
  426. sec = atoi((char *)two_digits);
  427. }
  428. (void)tmpstr.peekbyte(tmp);
  429. if ((char)tmp != 'Z') {
  430. tmpstr.fetchbyte(tmp);
  431. sign = (char)tmp;
  432. if (sign != '-' || sign != '+') {
  433. return (E_DER_DECODE_BAD_TIME_STRING);
  434. }
  435. get_twodigits(tmpstr, two_digits);
  436. offhr = atoi((char *)two_digits);
  437. get_twodigits(tmpstr, two_digits);
  438. offmin = atoi((char *)two_digits);
  439. if (sign == '-') {
  440. hour -= offhr;
  441. min  -= offmin;
  442. } else {
  443. hour += offhr;
  444. min  += offmin;
  445. }
  446. }
  447. if ( (month > 12) || (day > 31) || (hour > 23) || (min > 59) ||
  448.      (sec > 59) ) {
  449. return (E_DER_DECODE_BAD_TIME_STRING);
  450. }
  451. PCTime tmptime(year, month, day, hour, min, sec);
  452. time = tmptime;
  453. return (SUCCESS);
  454. }
  457. byte num_to_mask(int i)
  458. {
  459. switch (i % 7) {
  460. case 0:
  461. return (0x80); // shifted left seven, top 1 bit significant
  462. case 1:
  463. return (0xC0); // shifted left six, top 2 bits significant
  464. case 2:
  465. return (0xE0); // shifted left five, top 3 bits significant
  466. case 3:
  467. return (0xF0); // shifted left four, top 4 bits
  468. case 4:
  469. return (0xF8); // etc.
  470. case 5:
  471. return (0xFC);
  472. case 6:
  473. return (0xFE);
  474. default:
  475. printf("num_to_mask: unreachable coden");
  476. return (0);
  477. }
  478. }
  480. /*
  481.  * Decode an OBJECT-IDENTIFIER
  482.  */
  483. int asn1_der_decode_obj_id(Bstream& der_stream, ObjId& objid)
  484. {
  485. byte tmp = 0;
  486. byte tmp1 = 0;
  487. int  len, tmp_len;
  488. int  retval;
  490. if (der_stream.getlength() < 2)
  491. return (E_DER_DECODE_UNEXPECTED_EOS);
  492. retval = der_stream.peekbyte(tmp);
  493. if (tmp != OBJECT_IDENTIFIER_ID) {
  494. return (E_DER_DECODE_BAD_ID_OCTET);
  495. }
  496. (void )der_stream.fetchbyte(tmp);
  497. len = asn1_der_get_length(der_stream);
  498. if (len < 0) return len;
  499. if (len > der_stream.getlength()) 
  500. return (E_DER_DECODE_UNEXPECTED_EOS);
  501. int first_subid = TRUE;
  502. while (len > 0) {
  503. // For each sub id, figure out size by peeking
  504. // into the stream.
  505. int subid_len = 0;
  506. for ( (void) der_stream.peekbyte(tmp); (tmp & 0x80) ; 
  507. (void)der_stream.peekbyte(tmp)) {
  508. len--; 
  509. if (len < 0) 
  510. return (E_DER_DECODE_BAD_OBJID_SUBID);
  511. if (subid_len == 0 && tmp == 0x80)
  512. return (E_DER_DECODE_BAD_OBJID_SUBID);
  513. subid_len++;
  514. }
  515. subid_len++; // account for last octet
  516. len--; 
  517. if (len < 0) 
  518. return (E_DER_DECODE_BAD_OBJID_SUBID);
  519. byte *subid_bits = new byte[subid_len];
  520. tmp_len = subid_len;
  521. while (tmp_len) {
  522. der_stream.fetchbyte(subid_bits[tmp_len - 1]);
  523. tmp_len--;
  524. }
  525. byte *subid_int = new byte[subid_len];
  526. bzero(subid_int, subid_len);
  527. tmp_len = subid_len;
  528. for (int i = 0; i < tmp_len; i++) {
  529. tmp = ((byte)(subid_bits[i] & 0x7f) >> (i % 7));
  530. if ( i == (tmp_len - 1)) { // Most significant octet 
  531. tmp1 = 0;
  532. } else {
  533. tmp1 = ((subid_bits[i+1] & 0x7f) << (7-(i%7)));
  534. tmp1 &= num_to_mask(i);
  535. }
  536. tmp |= tmp1;
  537. subid_int[tmp_len - (i+1)] = tmp;
  538. }
  539. Bigint I((unsigned char *)subid_int, subid_len);
  540. delete subid_bits;
  541. delete subid_int;
  542. if (first_subid) {
  543. Bigint X,Y; // X, Y are 1st and 2nd subids rsp.
  544. if (I < 80) { // X == 0, or X == 1
  545. if (I < 40)
  546. X = (short)0;
  547. else
  548. X = 1;
  549. } else { // X == 2
  550. X = 2;
  551. }
  552.   Y = I - X*40;
  553. objid.add_element(X);
  554. objid.add_element(Y);
  555. first_subid = FALSE;
  556. } else {
  557. objid.add_element(I);
  558. }
  559. }
  560. return (SUCCESS);
  561. }