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

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

CA认证

开发平台：

C/C++

X509Cert.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 "%w% 96/01/29 Sun Microsystems"
  38. #include <sys/types.h>
  39. #include <stdarg.h>
  40. #include <stdio.h>
  41. #include "Time.h"
  42. #include "Bigint.h"
  43. #include "Bstream.h"
  44. #include "asn1_der.h"
  45. #include "ObjId.h"
  46. #include "Name.h"
  47. #include "X509Cert.h"
  48. #include "Sig.h"
  49. #include "dsa.h"
  50. #include "utils.h"
  52. AlgId&
  53. AlgId::operator =(const AlgId& a)
  54. {
  55. algid = a.algid;
  56. params = a.params;
  57. return (*this);
  58. }
  60. /*
  61.  * X509Cert class implementation.
  62.  */
  64. X509Cert::X509Cert()
  65. {
  66. // Rely on private member constructors
  67. }
  69. X509Cert::~X509Cert()
  70. {
  71. // Rely on private member destructors
  72. }
  74. X509Cert::X509Cert(const X509Cert &a)
  75. {
  76. serialnum = a.serialnum;
  77. sigalg = a.sigalg;
  78. issuer = a.issuer;
  79. notbefore = a.notbefore;
  80. notafter = a.notafter;
  81. subject = a.subject;
  82. pubkey = a.pubkey;
  83. certdata = a.certdata;
  84. certsigdata = a.certsigdata;
  85. sigdata = a.sigdata;
  86. return;
  87. }
  89. X509Cert&
  90. X509Cert:: operator =(const X509Cert &a)
  91. {
  92. serialnum = a.serialnum;
  93. sigalg = a.sigalg;
  94. issuer = a.issuer;
  95. notbefore = a.notbefore;
  96. notafter = a.notafter;
  97. subject = a.subject;
  98. pubkey = a.pubkey;
  99. certdata = a.certdata;
  100. certsigdata = a.certsigdata;
  101. sigdata = a.sigdata;
  102. return (*this);
  103. }
  105. X509Cert::X509Cert(const Bigint& ser, const AlgId& sigalgid,
  106. const Name& issuername, const PCTime& notb,
  107. const PCTime& nota, const Name& subname,
  108. const PubKey& subpub)
  109. {
  110. serialnum = ser;
  111. sigalg = sigalgid;
  112. issuer = issuername;
  113. notbefore = notb;
  114. notafter = nota;
  115. subject = subname;
  116. pubkey = subpub;
  117. return;
  118. }
  120. X509Cert::X509Cert(const Bigint& ser, const AlgId& sigalgid,
  121. const Name& issuername, const PCTime& notb,
  122. const PCTime& nota, const Name& subname,
  123. const PubKey& subpub, const Bstream& cert, 
  124. const Bstream& certsigpart, const Bstream& casig)
  125. {
  126. serialnum = ser;
  127. sigalg = sigalgid;
  128. issuer = issuername;
  129. notbefore = notb;
  130. notafter = nota;
  131. subject = subname;
  132. pubkey = subpub;
  133. certdata = cert;
  134. certsigdata = certsigpart;
  135. sigdata = casig;
  136. return;
  137. }
  139. Boolean operator ==(const X509Cert& a, const X509Cert& b)
  140. {
  141. if (a.certdata == b.certdata)
  142. return BOOL_TRUE;
  143. else
  144. return BOOL_FALSE;
  145. }
  147. VerifyResult
  148. X509Cert::verify(const PubKey& pubca) const
  149. {
  150. VerifyResult v;
  151. v = verify_sig(certsigdata, sigdata, pubca, sigalg);
  152. if (v)
  153. return v;
  155. PCTime now = timenow();
  156. if (now < notbefore)
  157. return (INVALID_NOTBEFORE);
  158. else if (now > notafter)
  159. return (INVALID_EXPIRED);
  160. #ifdef RW
  161. if (cert_in_CRL(*this) == BOOL_TRUE)
  162. return (INVALID_REVOKED);
  163. #endif
  164. return (VALID);
  165. }
  168. Bstream
  169. X509Cert::sign_and_encode(const Bstream& privkey)
  170. {
  171. Bstream val, tmpstr, tmpstr2, algid;
  173. val = asn1_der_encode_integer(serialnum);
  174. tmpstr = asn1_der_encode_null();
  175. tmpstr = algid = // Signature Algorithm ID
  176.    asn1_der_encode_sequence(sigalg.algid.encode() + tmpstr);
  177. val = val + tmpstr;
  178. val = val + issuer.encode();
  179. tmpstr = asn1_der_encode_utctime(notbefore);
  180. tmpstr2 = asn1_der_encode_utctime(notafter);
  181. tmpstr = // Validity
  182.    asn1_der_encode_sequence(tmpstr + tmpstr2);
  183. val = val + tmpstr;
  184. val = val + subject.encode();
  185. tmpstr = pubkey.keytype.algid.encode() + pubkey.keytype.params;
  186.   // Subject Public Key Algorithm ID
  187.     tmpstr = asn1_der_encode_sequence(tmpstr);
  188.     tmpstr2 = asn1_der_encode_bit_string(pubkey.key);
  189. // Subject Public Key Info
  190.     tmpstr = asn1_der_encode_sequence(tmpstr + tmpstr2);
  191. val = val + tmpstr;
  192.     val = asn1_der_encode_sequence(val); // ToBeSigned
  193. certsigdata = val; // Save this for signature
  195. tmpstr = algid;  // Signature Algorithm ID, again
  196. val = val + tmpstr;
  197. // XXX  -- change this to support different sig algs
  198. ObjId md_oid = dsaWithSHA;
  199. tmpstr = sign(certsigdata, privkey, md_oid);
  200. sigdata = tmpstr; // Save the signature
  202. tmpstr = // Encrypted hash, as a BIT-STRING
  203.    asn1_der_encode_bit_string(tmpstr);
  205. val = val + tmpstr;
  206. val = // SIGNED, final certificate
  207.    asn1_der_encode_sequence(val);
  208. certdata = val; // Save the final form
  209. return (val);
  210. }
  212. Bigint
  213. X509Cert::getserialnum() const
  214. {
  215. return (serialnum);
  216. }
  218. Name
  219. X509Cert::getsubject() const
  220. {
  221. return (subject);
  222. }
  224. Name
  225. X509Cert::getissuer() const
  226. {
  227. return (issuer);
  228. }
  230. AlgId
  231. X509Cert::getsigalgid() const
  232. {
  233. return (sigalg);
  234. }
  236. PCTime
  237. X509Cert::getnotbefore() const
  238. {
  239. return (notbefore);
  240. }
  242. PCTime
  243. X509Cert::getnotafter() const
  244. {
  245. return (notafter);
  246. }
  248. PubKey
  249. X509Cert::getpubkey() const
  250. {
  251. return (pubkey);
  252. }
  254. Bstream
  255. X509Cert::getcertdata() const
  256. {
  257. return (certdata);
  258. }
  260. void
  261. X509Cert::print()
  262. {
  263. printf("Serial Number = "); serialnum.print(); printf("n");
  264. printf("X.509 Certificate Signature Algorithm ID:nt");
  265. sigalg.algid.print(); 
  266. if (sigalg.algid == md2WithRSAEncryption)
  267. printf(" == MD2-WITH-RSA-ENCRYPTION");
  268. else if (sigalg.algid == dsaWithSHA)
  269. printf(" == SHA-WITH-DSA-SIGNATURE");
  270. printf("n");
  271. printf("X.509 Certificate Signature Algorithm parameters:");
  272. int retval;
  273. Bstream der_stream = sigalg.params;
  274. retval = asn1_der_decode_null(der_stream);
  275.     if (retval < 0) {
  276. sigalg.params.print(); printf("n");
  277. } else {
  278. printf(" NONEn");
  279. }
  280. printf("Issuer Name:tt"); issuer.print(); printf("n");
  281. printf("Not Valid Before:t"); notbefore.print(); printf("n");
  282. printf("Not Valid After:t"); notafter.print(); printf("n");
  283. printf("Subject Name:tt"); subject.print(); printf("n");
  284. printf("Subject Public Key Algorithm:t"); 
  285. pubkey.keytype.algid.print(); 
  286. if (pubkey.keytype.algid == dsa)
  287. printf(" == DSA");
  288. else if (pubkey.keytype.algid == dhKeyAgreement ||
  289. pubkey.keytype.algid == sundhKeyAgreement)
  290. printf(" == Diffie-Hellman");
  291. else if (pubkey.keytype.algid == rsaEncryption)
  292. printf(" == RSA-ENCRYPTION");
  293. else if (pubkey.keytype.algid == rsa)
  294. printf(" == RSA");
  295. printf("n");
  296. printf("Subject Public Key Algorithm parameters: ");
  297. der_stream = pubkey.keytype.params;
  298. if (pubkey.keytype.algid == rsa) {
  299. Bigint keysize;
  300. printf("Key Size = ");
  301. retval = asn1_der_decode_integer(der_stream, keysize);
  302. if (retval < 0) {
  303. printf("RSA parameters INTEGER decode error");
  304. asn1_perror(retval);
  305. pubkey.keytype.params.print(); printf("n");
  306. } else {
  307. keysize.printd(); printf(" bitsn");
  308. }
  309. } else if (pubkey.keytype.algid == dhKeyAgreement ||
  310. pubkey.keytype.algid == sundhKeyAgreement) {
  311. Bigint Mod, Base;
  313. int retval=asn1_der_decode_dh_params(der_stream, Mod, Base);
  314. printf("nDiffie-Hellman Modulus (p): "); Mod.printd();
  315. printf("nDiffie-Hellman Generator (g): "); Base.printd();
  316. printf("n");
  317. } else if (pubkey.keytype.algid == dsa) {
  318. Bigint prime, subprime, gen;
  320. int retval=asn1_der_decode_dsa_params(der_stream, prime,
  321. subprime, gen);
  322. printf("np: "); prime.printd();
  323. printf("nq: "); subprime.printd();
  324. printf("ng:  "); gen.printd();
  325. printf("n");
  326. } else {
  327. retval = asn1_der_decode_null(der_stream);
  328. if (retval < 0) {
  329. printf("n");
  330. pubkey.keytype.params.print(); printf("n");
  331. } else {
  332. printf("NONEn");
  333. }
  334. }
  335. printf("Subject Public Key: ");
  336. int  seqlen;
  337. Bigint modulus, exponent, pub;
  338. der_stream = pubkey.key;
  339. if (pubkey.keytype.algid == rsa ||
  340. pubkey.keytype.algid == rsaEncryption) {
  341. retval = asn1_der_decode_sequence(der_stream, seqlen);
  342. if (retval < 0) {printf("Bad Key encodingn"); return;}
  343. {
  344. retval = asn1_der_decode_integer(der_stream, modulus);
  345. if (retval < 0) {printf("Bad Key encodingn"); return;}
  346. retval = asn1_der_decode_integer(der_stream, exponent);
  347. if (retval < 0) {printf("Bad Key encodingn"); return;}
  348. printf("nRSA modulus = "); modulus.printd();
  349. printf("nRSA exponent = "); exponent.printd();
  350. printf("n");
  351. } 
  352. } else if (pubkey.keytype.algid == dhKeyAgreement ||
  353. pubkey.keytype.algid == sundhKeyAgreement ||
  354. pubkey.keytype.algid == dsa) {
  355. retval = asn1_der_decode_integer(der_stream, pub);
  356. printf("nDiffie-Hellman public value = "); pub.printd();
  357. printf("n");
  358. } else {
  359. retval = asn1_der_decode_null(der_stream);
  360. if (retval < 0) {
  361. printf("n");
  362. pubkey.key.print(); printf("n");
  363. } else {
  364. printf("NONEn");
  365. }
  366. }
  367. }
  369. /*
  370.  * X.500 X509Certificate DER decoding
  371.  */
  372. int asn1_der_decode_cert(Bstream& der_stream, X509Cert& cert)
  373. {
  374. byte tmp = 0;
  375. int  seqlen, retval;
  376. Bigint serialnum;
  377. AlgId  sigalgid, sigalgid2;
  378. PCTime notbefore, notafter;
  379. Name issuername, subjectname;
  380. PubKey psubject;
  381. Bstream casig, certsigdata, allcert;
  383. Bstream saved_stream = der_stream;
  384. SEQUENCE // SIGNED Macro
  385. {
  386. certsigdata = der_stream;
  387. SEQUENCE // ToBeSigned
  388. {
  389. // version -- Context specific [0]; for the moment,
  390. // we assume only 1988 format, and by DER
  391. // decoding rules, this field is absent.
  393. INTEGER(serialnum);
  394. SEQUENCE // X509Cert signature Algorithm Identifier
  395. {
  396. int begin, end, used, anylen;
  397. MARK_LEN(begin);
  398. OBJECT_IDENTIFIER(sigalgid.algid);
  399. MARK_LEN(end);
  400. used = begin - end;
  401. if ((anylen = seqlen - used) > 0) {
  402. Bstream any(anylen, DATAP);
  403. CONSUME(anylen);
  404. sigalgid.params = any;
  405. }
  406. }
  407. NAME(issuername);
  408. SEQUENCE // Validity
  409. {
  410. UTCTime(notbefore);
  411. UTCTime(notafter);
  412. }
  413. NAME(subjectname);
  414. SEQUENCE // Subject Public Key info
  415. {
  416. SEQUENCE // Subject Public Key Alg ID
  417. {
  418. int begin, end, used, anylen;
  419. MARK_LEN(begin);
  420.      OBJECT_IDENTIFIER(psubject.keytype.algid);
  421. MARK_LEN(end);
  422. used = begin - end;
  423. if ((anylen = seqlen - used) > 0) {
  424. Bstream any(anylen, DATAP);
  425. CONSUME(anylen);
  426. psubject.keytype.params = any;
  427. }
  429. }
  430. //  Subject Public Key
  431. BIT_STRING(psubject.key);
  432. }
  433. }
  434. int tobesignedlen = certsigdata.getlength() - 
  435. der_stream.getlength();
  436. int trunclen = certsigdata.getlength() - tobesignedlen;
  437. certsigdata.truncate(trunclen);
  438. SEQUENCE // Alg ID of cert signing
  439. {
  440. int begin, end, used, anylen;
  441. MARK_LEN(begin);
  442. OBJECT_IDENTIFIER(sigalgid2.algid);
  443. MARK_LEN(end);
  444. used = begin - end;
  445. if ((anylen = seqlen - used) > 0) {
  446. Bstream any(anylen, DATAP);
  447. CONSUME(anylen);
  448. sigalgid2.params = any;
  449. }
  450. }
  451. //  encrypted hash, i.e SIGNATURE
  452. BIT_STRING(casig);
  453. }
  454. int newlen = saved_stream.getlength() - der_stream.getlength();
  455. int trunclen = saved_stream.getlength() - newlen;
  456. saved_stream.truncate(trunclen);
  457. X509Cert tmpcert(serialnum, sigalgid, issuername, notbefore, notafter,
  458.      subjectname, psubject, saved_stream, certsigdata, casig);
  459. cert = tmpcert;
  460. return (SUCCESS);
  461. }
  464. Bstream 
  465. asn1_der_encode_certreq(const char *name, const Bstream& publickey,
  466. const Bstream& privkey)
  467. {
  468. Bstream tmpstr, certreqinfo, signature, nullbstr;
  469. Name nullname;
  471. tmpstr = asn1_der_encode_integer((short)0); // Version #0 (PKCS# 10)
  472. Name subject(name);
  473. if (subject == nullname)
  474. return (nullbstr);
  475. tmpstr = tmpstr + subject.encode();
  476. tmpstr = tmpstr + publickey;
  477. // XXX No attribute encoding for now
  478. certreqinfo = asn1_der_encode_sequence(tmpstr);
  479. tmpstr = sign(certreqinfo, privkey, dsaWithSHA);
  480. // XXX - remove this 
  481. // tmpstr = sign(certreqinfo, privkey, md2WithRSAEncryption);
  482. signature = asn1_der_encode_bit_string(tmpstr);
  483. tmpstr = asn1_der_encode_null();
  484. // XXX - change this
  485. // tmpstr = md2WithRSAEncryption.encode() + tmpstr;
  486. tmpstr = dsaWithSHA.encode() + tmpstr;
  487. tmpstr = asn1_der_encode_sequence(tmpstr);
  488. tmpstr = certreqinfo + tmpstr + signature;
  489. return (asn1_der_encode_sequence(tmpstr));
  490. }
  492. int
  493. asn1_der_decode_algid(Bstream& der_stream, AlgId& algid)
  494. {
  495. int retval, seqlen;
  497. SEQUENCE {
  498. int begin, end, used, anylen;
  499. MARK_LEN(begin);
  500. OBJECT_IDENTIFIER(algid.algid);
  501. MARK_LEN(end);
  502. used = begin - end;
  503. if ((anylen = seqlen - used) > 0) {
  504. Bstream any(anylen, DATAP);
  505. CONSUME(anylen);
  506. algid.params = any;
  507. }
  508. }
  509. }
  511. int
  512. asn1_der_decode_dh_params(Bstream der_stream, Bigint& mod, Bigint& base)
  513. {
  514. byte tmp = 0;
  515.         int seqlen, retval;
  516.         ObjId oid;
  517.         Bigint p, g, pvl;
  518.  
  519.         SEQUENCE
  520.         {
  521.                 OBJECT_IDENTIFIER(oid);
  522.                 SEQUENCE
  523.                 {
  524.                         INTEGER(p);
  525.                         INTEGER(g);
  526.                         INTEGER(pvl);
  527.                 }
  528.         }
  529.         mod = p;
  530.         base = g;
  531.         return (0);
  532. }