x_pubkey.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382
  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. */
  58. #include <stdio.h>
  59. #include "cryptlib.h"
  60. #include <openssl/asn1t.h>
  61. #include <openssl/x509.h>
  62. #include "asn1_locl.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
  69. /* Minor tweak to operation: free up EVP_PKEY */
  70. static int pubkey_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
  71. void *exarg)
  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. }
  80. ASN1_SEQUENCE_cb(X509_PUBKEY, pubkey_cb) = {
  81. ASN1_SIMPLE(X509_PUBKEY, algor, X509_ALGOR),
  82. ASN1_SIMPLE(X509_PUBKEY, public_key, ASN1_BIT_STRING)
  83. } ASN1_SEQUENCE_END_cb(X509_PUBKEY, X509_PUBKEY)
  84. IMPLEMENT_ASN1_FUNCTIONS(X509_PUBKEY)
  85. int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
  86. {
  87. X509_PUBKEY *pk=NULL;
  88. const EVP_PKEY_ASN1_METHOD *meth;
  89. if (x == NULL) return(0);
  90. if ((pk=X509_PUBKEY_new()) == NULL) goto error;
  91. meth = EVP_PKEY_asn1_find(pkey->type);
  92. if (meth)
  93. {
  94. if (meth->pub_encode)
  95. {
  96. if (!meth->pub_encode(pk, pkey))
  97. {
  98. X509err(X509_F_X509_PUBKEY_SET,
  99. X509_R_PUBLIC_KEY_ENCODE_ERROR);
  100. goto error;
  101. }
  102. }
  103. else
  104. {
  105. X509err(X509_F_X509_PUBKEY_SET,
  106. X509_R_METHOD_NOT_SUPPORTED);
  107. goto error;
  108. }
  109. }
  110. else
  111. {
  112. X509err(X509_F_X509_PUBKEY_SET,X509_R_UNSUPPORTED_ALGORITHM);
  113. goto error;
  114. }
  115. if (*x != NULL)
  116. X509_PUBKEY_free(*x);
  117. *x=pk;
  118. return 1;
  119. error:
  120. if (pk != NULL) X509_PUBKEY_free(pk);
  121. return 0;
  122. }
  123. EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key)
  124. {
  125. EVP_PKEY *ret=NULL;
  126. const EVP_PKEY_ASN1_METHOD *meth;
  127. if (key == NULL) goto error;
  128. if (key->pkey != NULL)
  129. {
  130. CRYPTO_add(&key->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
  131. return key->pkey;
  132. }
  133. if (key->public_key == NULL) goto error;
  134. if ((ret = EVP_PKEY_new()) == NULL)
  135. {
  136. X509err(X509_F_X509_PUBKEY_GET, ERR_R_MALLOC_FAILURE);
  137. goto error;
  138. }
  139. meth = EVP_PKEY_asn1_find(OBJ_obj2nid(key->algor->algorithm));
  140. if (meth)
  141. {
  142. if (meth->pub_decode)
  143. {
  144. if (!meth->pub_decode(ret, key))
  145. {
  146. X509err(X509_F_X509_PUBKEY_GET,
  147. X509_R_PUBLIC_KEY_DECODE_ERROR);
  148. goto error;
  149. }
  150. }
  151. else
  152. {
  153. X509err(X509_F_X509_PUBKEY_GET,
  154. X509_R_METHOD_NOT_SUPPORTED);
  155. goto error;
  156. }
  157. }
  158. else
  159. {
  160. X509err(X509_F_X509_PUBKEY_GET,X509_R_UNSUPPORTED_ALGORITHM);
  161. goto error;
  162. }
  163. key->pkey = ret;
  164. CRYPTO_add(&ret->references, 1, CRYPTO_LOCK_EVP_PKEY);
  165. return ret;
  166. error:
  167. if (ret != NULL)
  168. EVP_PKEY_free(ret);
  169. return(NULL);
  170. }
  171. /* Now two pseudo ASN1 routines that take an EVP_PKEY structure
  172. * and encode or decode as X509_PUBKEY
  173. */
  174. EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp,
  175. long length)
  176. {
  177. X509_PUBKEY *xpk;
  178. EVP_PKEY *pktmp;
  179. xpk = d2i_X509_PUBKEY(NULL, pp, length);
  180. if(!xpk) return NULL;
  181. pktmp = X509_PUBKEY_get(xpk);
  182. X509_PUBKEY_free(xpk);
  183. if(!pktmp) return NULL;
  184. if(a)
  185. {
  186. EVP_PKEY_free(*a);
  187. *a = pktmp;
  188. }
  189. return pktmp;
  190. }
  191. int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp)
  192. {
  193. X509_PUBKEY *xpk=NULL;
  194. int ret;
  195. if(!a) return 0;
  196. if(!X509_PUBKEY_set(&xpk, a)) return 0;
  197. ret = i2d_X509_PUBKEY(xpk, pp);
  198. X509_PUBKEY_free(xpk);
  199. return ret;
  200. }
  201. /* The following are equivalents but which return RSA and DSA
  202. * keys
  203. */
  204. #ifndef OPENSSL_NO_RSA
  205. RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp,
  206. long length)
  207. {
  208. EVP_PKEY *pkey;
  209. RSA *key;
  210. const unsigned char *q;
  211. q = *pp;
  212. pkey = d2i_PUBKEY(NULL, &q, length);
  213. if (!pkey) return NULL;
  214. key = EVP_PKEY_get1_RSA(pkey);
  215. EVP_PKEY_free(pkey);
  216. if (!key) return NULL;
  217. *pp = q;
  218. if (a)
  219. {
  220. RSA_free(*a);
  221. *a = key;
  222. }
  223. return key;
  224. }
  225. int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp)
  226. {
  227. EVP_PKEY *pktmp;
  228. int ret;
  229. if (!a) return 0;
  230. pktmp = EVP_PKEY_new();
  231. if (!pktmp)
  232. {
  233. ASN1err(ASN1_F_I2D_RSA_PUBKEY, ERR_R_MALLOC_FAILURE);
  234. return 0;
  235. }
  236. EVP_PKEY_set1_RSA(pktmp, a);
  237. ret = i2d_PUBKEY(pktmp, pp);
  238. EVP_PKEY_free(pktmp);
  239. return ret;
  240. }
  241. #endif
  242. #ifndef OPENSSL_NO_DSA
  243. DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp,
  244. long length)
  245. {
  246. EVP_PKEY *pkey;
  247. DSA *key;
  248. const unsigned char *q;
  249. q = *pp;
  250. pkey = d2i_PUBKEY(NULL, &q, length);
  251. if (!pkey) return NULL;
  252. key = EVP_PKEY_get1_DSA(pkey);
  253. EVP_PKEY_free(pkey);
  254. if (!key) return NULL;
  255. *pp = q;
  256. if (a)
  257. {
  258. DSA_free(*a);
  259. *a = key;
  260. }
  261. return key;
  262. }
  263. int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp)
  264. {
  265. EVP_PKEY *pktmp;
  266. int ret;
  267. if(!a) return 0;
  268. pktmp = EVP_PKEY_new();
  269. if(!pktmp)
  270. {
  271. ASN1err(ASN1_F_I2D_DSA_PUBKEY, ERR_R_MALLOC_FAILURE);
  272. return 0;
  273. }
  274. EVP_PKEY_set1_DSA(pktmp, a);
  275. ret = i2d_PUBKEY(pktmp, pp);
  276. EVP_PKEY_free(pktmp);
  277. return ret;
  278. }
  279. #endif
  280. #ifndef OPENSSL_NO_EC
  281. EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length)
  282. {
  283. EVP_PKEY *pkey;
  284. EC_KEY *key;
  285. const unsigned char *q;
  286. q = *pp;
  287. pkey = d2i_PUBKEY(NULL, &q, length);
  288. if (!pkey) return(NULL);
  289. key = EVP_PKEY_get1_EC_KEY(pkey);
  290. EVP_PKEY_free(pkey);
  291. if (!key) return(NULL);
  292. *pp = q;
  293. if (a)
  294. {
  295. EC_KEY_free(*a);
  296. *a = key;
  297. }
  298. return(key);
  299. }
  300. int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp)
  301. {
  302. EVP_PKEY *pktmp;
  303. int ret;
  304. if (!a) return(0);
  305. if ((pktmp = EVP_PKEY_new()) == NULL)
  306. {
  307. ASN1err(ASN1_F_I2D_EC_PUBKEY, ERR_R_MALLOC_FAILURE);
  308. return(0);
  309. }
  310. EVP_PKEY_set1_EC_KEY(pktmp, a);
  311. ret = i2d_PUBKEY(pktmp, pp);
  312. EVP_PKEY_free(pktmp);
  313. return(ret);
  314. }
  315. #endif
  316. int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
  317. int ptype, void *pval,
  318. unsigned char *penc, int penclen)
  319. {
  320. if (!X509_ALGOR_set0(pub->algor, aobj, ptype, pval))
  321. return 0;
  322. if (penc)
  323. {
  324. if (pub->public_key->data)
  325. OPENSSL_free(pub->public_key->data);
  326. pub->public_key->data = penc;
  327. pub->public_key->length = penclen;
  328. /* Set number of unused bits to zero */
  329. pub->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);
  330. pub->public_key->flags|=ASN1_STRING_FLAG_BITS_LEFT;
  331. }
  332. return 1;
  333. }
  334. int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
  335. const unsigned char **pk, int *ppklen,
  336. X509_ALGOR **pa,
  337. X509_PUBKEY *pub)
  338. {
  339. if (ppkalg)
  340. *ppkalg = pub->algor->algorithm;
  341. if (pk)
  342. {
  343. *pk = pub->public_key->data;
  344. *ppklen = pub->public_key->length;
  345. }
  346. if (pa)
  347. *pa = pub->algor;
  348. return 1;
  349. }