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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
x_pubkey.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：13k
源码类别：

其他游戏

开发平台：

Visual C++

x_pubkey.c：源码内容
  1. /* crypto/asn1/x_pubkey.c */
  2. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  3.  * All rights reserved.
  4.  *
  5.  * This package is an SSL implementation written
  6.  * by Eric Young (eay@cryptsoft.com).
  7.  * The implementation was written so as to conform with Netscapes SSL.
  8.  * 
  9.  * This library is free for commercial and non-commercial use as long as
  10.  * the following conditions are aheared to.  The following conditions
  11.  * apply to all code found in this distribution, be it the RC4, RSA,
  12.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13.  * included with this distribution is covered by the same copyright terms
  14.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15.  * 
  16.  * Copyright remains Eric Young's, and as such any Copyright notices in
  17.  * the code are not to be removed.
  18.  * If this package is used in a product, Eric Young should be given attribution
  19.  * as the author of the parts of the library used.
  20.  * This can be in the form of a textual message at program startup or
  21.  * in documentation (online or textual) provided with the package.
  22.  * 
  23.  * Redistribution and use in source and binary forms, with or without
  24.  * modification, are permitted provided that the following conditions
  25.  * are met:
  26.  * 1. Redistributions of source code must retain the copyright
  27.  *    notice, this list of conditions and the following disclaimer.
  28.  * 2. Redistributions in binary form must reproduce the above copyright
  29.  *    notice, this list of conditions and the following disclaimer in the
  30.  *    documentation and/or other materials provided with the distribution.
  31.  * 3. All advertising materials mentioning features or use of this software
  32.  *    must display the following acknowledgement:
  33.  *    "This product includes cryptographic software written by
  34.  *     Eric Young (eay@cryptsoft.com)"
  35.  *    The word 'cryptographic' can be left out if the rouines from the library
  36.  *    being used are not cryptographic related :-).
  37.  * 4. If you include any Windows specific code (or a derivative thereof) from 
  38.  *    the apps directory (application code) you must include an acknowledgement:
  39.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40.  * 
  41.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51.  * SUCH DAMAGE.
  52.  * 
  53.  * The licence and distribution terms for any publically available version or
  54.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55.  * copied and put under another distribution licence
  56.  * [including the GNU Public Licence.]
  57.  */
  59. #include <stdio.h>
  60. #include "cryptlib.h"
  61. #include <openssl/asn1t.h>
  62. #include <openssl/x509.h>
  63. #ifndef OPENSSL_NO_RSA
  64. #include <openssl/rsa.h>
  65. #endif
  66. #ifndef OPENSSL_NO_DSA
  67. #include <openssl/dsa.h>
  68. #endif
  70. /* Minor tweak to operation: free up EVP_PKEY */
  71. static int pubkey_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it)
  72. {
  73. if (operation == ASN1_OP_FREE_POST)
  74. {
  75. X509_PUBKEY *pubkey = (X509_PUBKEY *)*pval;
  76. EVP_PKEY_free(pubkey->pkey);
  77. }
  78. return 1;
  79. }
  81. ASN1_SEQUENCE_cb(X509_PUBKEY, pubkey_cb) = {
  82. ASN1_SIMPLE(X509_PUBKEY, algor, X509_ALGOR),
  83. ASN1_SIMPLE(X509_PUBKEY, public_key, ASN1_BIT_STRING)
  84. } ASN1_SEQUENCE_END_cb(X509_PUBKEY, X509_PUBKEY)
  86. IMPLEMENT_ASN1_FUNCTIONS(X509_PUBKEY)
  88. int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
  89. {
  90. X509_PUBKEY *pk=NULL;
  91. X509_ALGOR *a;
  92. ASN1_OBJECT *o;
  93. unsigned char *s,*p = NULL;
  94. int i;
  96. if (x == NULL) return(0);
  98. if ((pk=X509_PUBKEY_new()) == NULL) goto err;
  99. a=pk->algor;
  101. /* set the algorithm id */
  102. if ((o=OBJ_nid2obj(pkey->type)) == NULL) goto err;
  103. ASN1_OBJECT_free(a->algorithm);
  104. a->algorithm=o;
  106. /* Set the parameter list */
  107. if (!pkey->save_parameters || (pkey->type == EVP_PKEY_RSA))
  108. {
  109. if ((a->parameter == NULL) ||
  110. (a->parameter->type != V_ASN1_NULL))
  111. {
  112. ASN1_TYPE_free(a->parameter);
  113. if (!(a->parameter=ASN1_TYPE_new()))
  114. {
  115. X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
  116. goto err;
  117. }
  118. a->parameter->type=V_ASN1_NULL;
  119. }
  120. }
  121. #ifndef OPENSSL_NO_DSA
  122. else if (pkey->type == EVP_PKEY_DSA)
  123. {
  124. unsigned char *pp;
  125. DSA *dsa;
  127. dsa=pkey->pkey.dsa;
  128. dsa->write_params=0;
  129. ASN1_TYPE_free(a->parameter);
  130. if ((i=i2d_DSAparams(dsa,NULL)) <= 0)
  131. goto err;
  132. if (!(p=(unsigned char *)OPENSSL_malloc(i)))
  133. {
  134. X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
  135. goto err;
  136. }
  137. pp=p;
  138. i2d_DSAparams(dsa,&pp);
  139. if (!(a->parameter=ASN1_TYPE_new()))
  140. {
  141. OPENSSL_free(p);
  142. X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
  143. goto err;
  144. }
  145. a->parameter->type=V_ASN1_SEQUENCE;
  146. if (!(a->parameter->value.sequence=ASN1_STRING_new()))
  147. {
  148. OPENSSL_free(p);
  149. X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
  150. goto err;
  151. }
  152. if (!ASN1_STRING_set(a->parameter->value.sequence,p,i))
  153. {
  154. OPENSSL_free(p);
  155. X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
  156. goto err;
  157. }
  158. OPENSSL_free(p);
  159. }
  160. #endif
  161. #ifndef OPENSSL_NO_EC
  162. else if (pkey->type == EVP_PKEY_EC)
  163. {
  164. int nid=0;
  165. unsigned char *pp;
  166. EC_KEY *ec_key;
  167. const EC_GROUP *group;
  169. ec_key = pkey->pkey.ec;
  170. ASN1_TYPE_free(a->parameter);
  172. if ((a->parameter = ASN1_TYPE_new()) == NULL)
  173. {
  174. X509err(X509_F_X509_PUBKEY_SET, ERR_R_ASN1_LIB);
  175. goto err;
  176. }
  178. group = EC_KEY_get0_group(ec_key);
  179. if (EC_GROUP_get_asn1_flag(group)
  180.                      && (nid = EC_GROUP_get_curve_name(group)))
  181. {
  182. /* just set the OID */
  183. a->parameter->type = V_ASN1_OBJECT;
  184. a->parameter->value.object = OBJ_nid2obj(nid);
  185. }
  186. else /* explicit parameters */
  187. {
  188. if ((i = i2d_ECParameters(ec_key, NULL)) == 0)
  189. {
  190. X509err(X509_F_X509_PUBKEY_SET, ERR_R_EC_LIB);
  191. goto err;
  192. }
  193. if ((p = (unsigned char *) OPENSSL_malloc(i)) == NULL)
  194. {
  195. X509err(X509_F_X509_PUBKEY_SET, ERR_R_MALLOC_FAILURE);
  196. goto err;
  197. }
  198. pp = p;
  199. if (!i2d_ECParameters(ec_key, &pp))
  200. {
  201. X509err(X509_F_X509_PUBKEY_SET, ERR_R_EC_LIB);
  202. OPENSSL_free(p);
  203. goto err;
  204. }
  205. a->parameter->type = V_ASN1_SEQUENCE;
  206. if ((a->parameter->value.sequence = ASN1_STRING_new()) == NULL)
  207. {
  208. X509err(X509_F_X509_PUBKEY_SET, ERR_R_ASN1_LIB);
  209. OPENSSL_free(p);
  210. goto err;
  211. }
  212. ASN1_STRING_set(a->parameter->value.sequence, p, i);
  213. OPENSSL_free(p);
  214. }
  215. }
  216. #endif
  217. else if (1)
  218. {
  219. X509err(X509_F_X509_PUBKEY_SET,X509_R_UNSUPPORTED_ALGORITHM);
  220. goto err;
  221. }
  223. if ((i=i2d_PublicKey(pkey,NULL)) <= 0) goto err;
  224. if ((s=(unsigned char *)OPENSSL_malloc(i+1)) == NULL)
  225. {
  226. X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
  227. goto err;
  228. }
  229. p=s;
  230. i2d_PublicKey(pkey,&p);
  231. if (!M_ASN1_BIT_STRING_set(pk->public_key,s,i))
  232. {
  233. X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);
  234. goto err;
  235. }
  236.    /* Set number of unused bits to zero */
  237. pk->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);
  238. pk->public_key->flags|=ASN1_STRING_FLAG_BITS_LEFT;
  240. OPENSSL_free(s);
  242. #if 0
  243. CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
  244. pk->pkey=pkey;
  245. #endif
  247. if (*x != NULL)
  248. X509_PUBKEY_free(*x);
  250. *x=pk;
  252. return 1;
  253. err:
  254. if (pk != NULL) X509_PUBKEY_free(pk);
  255. return 0;
  256. }
  258. EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key)
  259. {
  260. EVP_PKEY *ret=NULL;
  261. long j;
  262. int type;
  263. const unsigned char *p;
  264. #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
  265. const unsigned char *cp;
  266. X509_ALGOR *a;
  267. #endif
  269. if (key == NULL) goto err;
  271. if (key->pkey != NULL)
  272. {
  273. CRYPTO_add(&key->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
  274. return(key->pkey);
  275. }
  277. if (key->public_key == NULL) goto err;
  279. type=OBJ_obj2nid(key->algor->algorithm);
  280. if ((ret = EVP_PKEY_new()) == NULL)
  281. {
  282. X509err(X509_F_X509_PUBKEY_GET, ERR_R_MALLOC_FAILURE);
  283. goto err;
  284. }
  285. ret->type = EVP_PKEY_type(type);
  287. /* the parameters must be extracted before the public key (ECDSA!) */
  289. #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
  290. a=key->algor;
  291. #endif
  293. if (0)
  294. ;
  295. #ifndef OPENSSL_NO_DSA
  296. else if (ret->type == EVP_PKEY_DSA)
  297. {
  298. if (a->parameter && (a->parameter->type == V_ASN1_SEQUENCE))
  299. {
  300. if ((ret->pkey.dsa = DSA_new()) == NULL)
  301. {
  302. X509err(X509_F_X509_PUBKEY_GET, ERR_R_MALLOC_FAILURE);
  303. goto err;
  304. }
  305. ret->pkey.dsa->write_params=0;
  306. cp=p=a->parameter->value.sequence->data;
  307. j=a->parameter->value.sequence->length;
  308. if (!d2i_DSAparams(&ret->pkey.dsa, &cp, (long)j))
  309. goto err;
  310. }
  311. ret->save_parameters=1;
  312. }
  313. #endif
  314. #ifndef OPENSSL_NO_EC
  315. else if (ret->type == EVP_PKEY_EC)
  316. {
  317. if (a->parameter && (a->parameter->type == V_ASN1_SEQUENCE))
  318. {
  319. /* type == V_ASN1_SEQUENCE => we have explicit parameters
  320.                          * (e.g. parameters in the X9_62_EC_PARAMETERS-structure )
  321.  */
  322. if ((ret->pkey.ec= EC_KEY_new()) == NULL)
  323. {
  324. X509err(X509_F_X509_PUBKEY_GET, 
  325. ERR_R_MALLOC_FAILURE);
  326. goto err;
  327. }
  328. cp = p = a->parameter->value.sequence->data;
  329. j = a->parameter->value.sequence->length;
  330. if (!d2i_ECParameters(&ret->pkey.ec, &cp, (long)j))
  331. {
  332. X509err(X509_F_X509_PUBKEY_GET, ERR_R_EC_LIB);
  333. goto err;
  334. }
  335. }
  336. else if (a->parameter && (a->parameter->type == V_ASN1_OBJECT))
  337. {
  338. /* type == V_ASN1_OBJECT => the parameters are given
  339.  * by an asn1 OID
  340.  */
  341. EC_KEY   *ec_key;
  342. EC_GROUP *group;
  344. if (ret->pkey.ec == NULL)
  345. ret->pkey.ec = EC_KEY_new();
  346. ec_key = ret->pkey.ec;
  347. if (ec_key == NULL)
  348. goto err;
  349. group = EC_GROUP_new_by_curve_name(OBJ_obj2nid(a->parameter->value.object));
  350. if (group == NULL)
  351. goto err;
  352. EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
  353. if (EC_KEY_set_group(ec_key, group) == 0)
  354. goto err;
  355. EC_GROUP_free(group);
  356. }
  357. /* the case implicitlyCA is currently not implemented */
  358. ret->save_parameters = 1;
  359. }
  360. #endif
  362. p=key->public_key->data;
  363.         j=key->public_key->length;
  364.         if (!d2i_PublicKey(type, &ret, &p, (long)j))
  365. {
  366. X509err(X509_F_X509_PUBKEY_GET, X509_R_ERR_ASN1_LIB);
  367. goto err;
  368. }
  370. key->pkey = ret;
  371. CRYPTO_add(&ret->references, 1, CRYPTO_LOCK_EVP_PKEY);
  372. return(ret);
  373. err:
  374. if (ret != NULL)
  375. EVP_PKEY_free(ret);
  376. return(NULL);
  377. }
  379. /* Now two pseudo ASN1 routines that take an EVP_PKEY structure
  380.  * and encode or decode as X509_PUBKEY
  381.  */
  383. EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp,
  384.      long length)
  385. {
  386. X509_PUBKEY *xpk;
  387. EVP_PKEY *pktmp;
  388. xpk = d2i_X509_PUBKEY(NULL, pp, length);
  389. if(!xpk) return NULL;
  390. pktmp = X509_PUBKEY_get(xpk);
  391. X509_PUBKEY_free(xpk);
  392. if(!pktmp) return NULL;
  393. if(a)
  394. {
  395. EVP_PKEY_free(*a);
  396. *a = pktmp;
  397. }
  398. return pktmp;
  399. }
  401. int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp)
  402. {
  403. X509_PUBKEY *xpk=NULL;
  404. int ret;
  405. if(!a) return 0;
  406. if(!X509_PUBKEY_set(&xpk, a)) return 0;
  407. ret = i2d_X509_PUBKEY(xpk, pp);
  408. X509_PUBKEY_free(xpk);
  409. return ret;
  410. }
  412. /* The following are equivalents but which return RSA and DSA
  413.  * keys
  414.  */
  415. #ifndef OPENSSL_NO_RSA
  416. RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp,
  417.      long length)
  418. {
  419. EVP_PKEY *pkey;
  420. RSA *key;
  421. const unsigned char *q;
  422. q = *pp;
  423. pkey = d2i_PUBKEY(NULL, &q, length);
  424. if (!pkey) return NULL;
  425. key = EVP_PKEY_get1_RSA(pkey);
  426. EVP_PKEY_free(pkey);
  427. if (!key) return NULL;
  428. *pp = q;
  429. if (a)
  430. {
  431. RSA_free(*a);
  432. *a = key;
  433. }
  434. return key;
  435. }
  437. int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp)
  438. {
  439. EVP_PKEY *pktmp;
  440. int ret;
  441. if (!a) return 0;
  442. pktmp = EVP_PKEY_new();
  443. if (!pktmp)
  444. {
  445. ASN1err(ASN1_F_I2D_RSA_PUBKEY, ERR_R_MALLOC_FAILURE);
  446. return 0;
  447. }
  448. EVP_PKEY_set1_RSA(pktmp, a);
  449. ret = i2d_PUBKEY(pktmp, pp);
  450. EVP_PKEY_free(pktmp);
  451. return ret;
  452. }
  453. #endif
  455. #ifndef OPENSSL_NO_DSA
  456. DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp,
  457.      long length)
  458. {
  459. EVP_PKEY *pkey;
  460. DSA *key;
  461. const unsigned char *q;
  462. q = *pp;
  463. pkey = d2i_PUBKEY(NULL, &q, length);
  464. if (!pkey) return NULL;
  465. key = EVP_PKEY_get1_DSA(pkey);
  466. EVP_PKEY_free(pkey);
  467. if (!key) return NULL;
  468. *pp = q;
  469. if (a)
  470. {
  471. DSA_free(*a);
  472. *a = key;
  473. }
  474. return key;
  475. }
  477. int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp)
  478. {
  479. EVP_PKEY *pktmp;
  480. int ret;
  481. if(!a) return 0;
  482. pktmp = EVP_PKEY_new();
  483. if(!pktmp)
  484. {
  485. ASN1err(ASN1_F_I2D_DSA_PUBKEY, ERR_R_MALLOC_FAILURE);
  486. return 0;
  487. }
  488. EVP_PKEY_set1_DSA(pktmp, a);
  489. ret = i2d_PUBKEY(pktmp, pp);
  490. EVP_PKEY_free(pktmp);
  491. return ret;
  492. }
  493. #endif
  495. #ifndef OPENSSL_NO_EC
  496. EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length)
  497. {
  498. EVP_PKEY *pkey;
  499. EC_KEY *key;
  500. const unsigned char *q;
  501. q = *pp;
  502. pkey = d2i_PUBKEY(NULL, &q, length);
  503. if (!pkey) return(NULL);
  504. key = EVP_PKEY_get1_EC_KEY(pkey);
  505. EVP_PKEY_free(pkey);
  506. if (!key)  return(NULL);
  507. *pp = q;
  508. if (a)
  509. {
  510. EC_KEY_free(*a);
  511. *a = key;
  512. }
  513. return(key);
  514. }
  516. int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp)
  517. {
  518. EVP_PKEY *pktmp;
  519. int ret;
  520. if (!a) return(0);
  521. if ((pktmp = EVP_PKEY_new()) == NULL)
  522. {
  523. ASN1err(ASN1_F_I2D_EC_PUBKEY, ERR_R_MALLOC_FAILURE);
  524. return(0);
  525. }
  526. EVP_PKEY_set1_EC_KEY(pktmp, a);
  527. ret = i2d_PUBKEY(pktmp, pp);
  528. EVP_PKEY_free(pktmp);
  529. return(ret);
  530. }
  531. #endif