dh_key.c
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:7k
源码类别:

其他游戏

开发平台:

Visual C++

  1. /* crypto/dh/dh_key.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/bn.h>
  61. #include <openssl/rand.h>
  62. #include <openssl/dh.h>
  63. static int generate_key(DH *dh);
  64. static int compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh);
  65. static int dh_bn_mod_exp(const DH *dh, BIGNUM *r,
  66. const BIGNUM *a, const BIGNUM *p,
  67. const BIGNUM *m, BN_CTX *ctx,
  68. BN_MONT_CTX *m_ctx);
  69. static int dh_init(DH *dh);
  70. static int dh_finish(DH *dh);
  71. int DH_generate_key(DH *dh)
  72. {
  73. return dh->meth->generate_key(dh);
  74. }
  75. int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
  76. {
  77. return dh->meth->compute_key(key, pub_key, dh);
  78. }
  79. static DH_METHOD dh_ossl = {
  80. "OpenSSL DH Method",
  81. generate_key,
  82. compute_key,
  83. dh_bn_mod_exp,
  84. dh_init,
  85. dh_finish,
  86. 0,
  87. NULL,
  88. NULL
  89. };
  90. const DH_METHOD *DH_OpenSSL(void)
  91. {
  92. return &dh_ossl;
  93. }
  94. static int generate_key(DH *dh)
  95. {
  96. int ok=0;
  97. int generate_new_key=0;
  98. unsigned l;
  99. BN_CTX *ctx;
  100. BN_MONT_CTX *mont=NULL;
  101. BIGNUM *pub_key=NULL,*priv_key=NULL;
  102. ctx = BN_CTX_new();
  103. if (ctx == NULL) goto err;
  104. if (dh->priv_key == NULL)
  105. {
  106. priv_key=BN_new();
  107. if (priv_key == NULL) goto err;
  108. generate_new_key=1;
  109. }
  110. else
  111. priv_key=dh->priv_key;
  112. if (dh->pub_key == NULL)
  113. {
  114. pub_key=BN_new();
  115. if (pub_key == NULL) goto err;
  116. }
  117. else
  118. pub_key=dh->pub_key;
  119. if (dh->flags & DH_FLAG_CACHE_MONT_P)
  120. {
  121. mont = BN_MONT_CTX_set_locked(&dh->method_mont_p,
  122. CRYPTO_LOCK_DH, dh->p, ctx);
  123. if (!mont)
  124. goto err;
  125. }
  126. if (generate_new_key)
  127. {
  128. l = dh->length ? dh->length : BN_num_bits(dh->p)-1; /* secret exponent length */
  129. if (!BN_rand(priv_key, l, 0, 0)) goto err;
  130. }
  131. {
  132. BIGNUM local_prk;
  133. BIGNUM *prk;
  134. if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0)
  135. {
  136. BN_init(&local_prk);
  137. prk = &local_prk;
  138. BN_with_flags(prk, priv_key, BN_FLG_EXP_CONSTTIME);
  139. }
  140. else
  141. prk = priv_key;
  142. if (!dh->meth->bn_mod_exp(dh, pub_key, dh->g, prk, dh->p, ctx, mont)) goto err;
  143. }
  144. dh->pub_key=pub_key;
  145. dh->priv_key=priv_key;
  146. ok=1;
  147. err:
  148. if (ok != 1)
  149. DHerr(DH_F_GENERATE_KEY,ERR_R_BN_LIB);
  150. if ((pub_key != NULL)  && (dh->pub_key == NULL))  BN_free(pub_key);
  151. if ((priv_key != NULL) && (dh->priv_key == NULL)) BN_free(priv_key);
  152. BN_CTX_free(ctx);
  153. return(ok);
  154. }
  155. static int compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
  156. {
  157. BN_CTX *ctx;
  158. BN_MONT_CTX *mont=NULL;
  159. BIGNUM *tmp;
  160. int ret= -1;
  161.         int check_result;
  162. ctx = BN_CTX_new();
  163. if (ctx == NULL) goto err;
  164. BN_CTX_start(ctx);
  165. tmp = BN_CTX_get(ctx);
  166. if (dh->priv_key == NULL)
  167. {
  168. DHerr(DH_F_COMPUTE_KEY,DH_R_NO_PRIVATE_VALUE);
  169. goto err;
  170. }
  171. if (dh->flags & DH_FLAG_CACHE_MONT_P)
  172. {
  173. mont = BN_MONT_CTX_set_locked(&dh->method_mont_p,
  174. CRYPTO_LOCK_DH, dh->p, ctx);
  175. if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0)
  176. {
  177. /* XXX */
  178. BN_set_flags(dh->priv_key, BN_FLG_EXP_CONSTTIME);
  179. }
  180. if (!mont)
  181. goto err;
  182. }
  183.         if (!DH_check_pub_key(dh, pub_key, &check_result) || check_result)
  184. {
  185. DHerr(DH_F_COMPUTE_KEY,DH_R_INVALID_PUBKEY);
  186. goto err;
  187. }
  188. if (!dh->meth->bn_mod_exp(dh, tmp, pub_key, dh->priv_key,dh->p,ctx,mont))
  189. {
  190. DHerr(DH_F_COMPUTE_KEY,ERR_R_BN_LIB);
  191. goto err;
  192. }
  193. ret=BN_bn2bin(tmp,key);
  194. err:
  195. if (ctx != NULL)
  196. {
  197. BN_CTX_end(ctx);
  198. BN_CTX_free(ctx);
  199. }
  200. return(ret);
  201. }
  202. static int dh_bn_mod_exp(const DH *dh, BIGNUM *r,
  203. const BIGNUM *a, const BIGNUM *p,
  204. const BIGNUM *m, BN_CTX *ctx,
  205. BN_MONT_CTX *m_ctx)
  206. {
  207. /* If a is only one word long and constant time is false, use the faster
  208.  * exponenentiation function.
  209.  */
  210. if (a->top == 1 && ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) != 0))
  211. {
  212. BN_ULONG A = a->d[0];
  213. return BN_mod_exp_mont_word(r,A,p,m,ctx,m_ctx);
  214. }
  215. else
  216. return BN_mod_exp_mont(r,a,p,m,ctx,m_ctx);
  217. }
  218. static int dh_init(DH *dh)
  219. {
  220. dh->flags |= DH_FLAG_CACHE_MONT_P;
  221. return(1);
  222. }
  223. static int dh_finish(DH *dh)
  224. {
  225. if(dh->method_mont_p)
  226. BN_MONT_CTX_free(dh->method_mont_p);
  227. return(1);
  228. }