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

其他游戏

开发平台:

Visual C++

  1. /* crypto/rand/md_rand.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. /* ====================================================================
  59.  * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
  60.  *
  61.  * Redistribution and use in source and binary forms, with or without
  62.  * modification, are permitted provided that the following conditions
  63.  * are met:
  64.  *
  65.  * 1. Redistributions of source code must retain the above copyright
  66.  *    notice, this list of conditions and the following disclaimer. 
  67.  *
  68.  * 2. Redistributions in binary form must reproduce the above copyright
  69.  *    notice, this list of conditions and the following disclaimer in
  70.  *    the documentation and/or other materials provided with the
  71.  *    distribution.
  72.  *
  73.  * 3. All advertising materials mentioning features or use of this
  74.  *    software must display the following acknowledgment:
  75.  *    "This product includes software developed by the OpenSSL Project
  76.  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77.  *
  78.  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79.  *    endorse or promote products derived from this software without
  80.  *    prior written permission. For written permission, please contact
  81.  *    openssl-core@openssl.org.
  82.  *
  83.  * 5. Products derived from this software may not be called "OpenSSL"
  84.  *    nor may "OpenSSL" appear in their names without prior written
  85.  *    permission of the OpenSSL Project.
  86.  *
  87.  * 6. Redistributions of any form whatsoever must retain the following
  88.  *    acknowledgment:
  89.  *    "This product includes software developed by the OpenSSL Project
  90.  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91.  *
  92.  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  100.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  101.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  102.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  103.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  104.  * ====================================================================
  105.  *
  106.  * This product includes cryptographic software written by Eric Young
  107.  * (eay@cryptsoft.com).  This product includes software written by Tim
  108.  * Hudson (tjh@cryptsoft.com).
  109.  *
  110.  */
  111. #ifdef MD_RAND_DEBUG
  112. # ifndef NDEBUG
  113. #   define NDEBUG
  114. # endif
  115. #endif
  116. #include <assert.h>
  117. #include <stdio.h>
  118. #include <string.h>
  119. #include "e_os.h"
  120. #include <openssl/rand.h>
  121. #include "rand_lcl.h"
  122. #include <openssl/crypto.h>
  123. #include <openssl/err.h>
  124. #ifdef BN_DEBUG
  125. # define PREDICT
  126. #endif
  127. /* #define PREDICT 1 */
  128. #define STATE_SIZE 1023
  129. static int state_num=0,state_index=0;
  130. static unsigned char state[STATE_SIZE+MD_DIGEST_LENGTH];
  131. static unsigned char md[MD_DIGEST_LENGTH];
  132. static long md_count[2]={0,0};
  133. static double entropy=0;
  134. static int initialized=0;
  135. static unsigned int crypto_lock_rand = 0; /* may be set only when a thread
  136.                                            * holds CRYPTO_LOCK_RAND
  137.                                            * (to prevent double locking) */
  138. /* access to lockin_thread is synchronized by CRYPTO_LOCK_RAND2 */
  139. static unsigned long locking_thread = 0; /* valid iff crypto_lock_rand is set */
  140. #ifdef PREDICT
  141. int rand_predictable=0;
  142. #endif
  143. const char *RAND_version="RAND" OPENSSL_VERSION_PTEXT;
  144. static void ssleay_rand_cleanup(void);
  145. static void ssleay_rand_seed(const void *buf, int num);
  146. static void ssleay_rand_add(const void *buf, int num, double add_entropy);
  147. static int ssleay_rand_bytes(unsigned char *buf, int num);
  148. static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num);
  149. static int ssleay_rand_status(void);
  150. RAND_METHOD rand_ssleay_meth={
  151. ssleay_rand_seed,
  152. ssleay_rand_bytes,
  153. ssleay_rand_cleanup,
  154. ssleay_rand_add,
  155. ssleay_rand_pseudo_bytes,
  156. ssleay_rand_status
  157. }; 
  158. RAND_METHOD *RAND_SSLeay(void)
  159. {
  160. return(&rand_ssleay_meth);
  161. }
  162. static void ssleay_rand_cleanup(void)
  163. {
  164. OPENSSL_cleanse(state,sizeof(state));
  165. state_num=0;
  166. state_index=0;
  167. OPENSSL_cleanse(md,MD_DIGEST_LENGTH);
  168. md_count[0]=0;
  169. md_count[1]=0;
  170. entropy=0;
  171. initialized=0;
  172. }
  173. static void ssleay_rand_add(const void *buf, int num, double add)
  174. {
  175. int i,j,k,st_idx;
  176. long md_c[2];
  177. unsigned char local_md[MD_DIGEST_LENGTH];
  178. EVP_MD_CTX m;
  179. int do_not_lock;
  180. /*
  181.  * (Based on the rand(3) manpage)
  182.  *
  183.  * The input is chopped up into units of 20 bytes (or less for
  184.  * the last block).  Each of these blocks is run through the hash
  185.  * function as follows:  The data passed to the hash function
  186.  * is the current 'md', the same number of bytes from the 'state'
  187.  * (the location determined by in incremented looping index) as
  188.  * the current 'block', the new key data 'block', and 'count'
  189.  * (which is incremented after each use).
  190.  * The result of this is kept in 'md' and also xored into the
  191.  * 'state' at the same locations that were used as input into the
  192.          * hash function.
  193.  */
  194. /* check if we already have the lock */
  195. if (crypto_lock_rand)
  196. {
  197. CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
  198. do_not_lock = (locking_thread == CRYPTO_thread_id());
  199. CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
  200. }
  201. else
  202. do_not_lock = 0;
  203. if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
  204. st_idx=state_index;
  205. /* use our own copies of the counters so that even
  206.  * if a concurrent thread seeds with exactly the
  207.  * same data and uses the same subarray there's _some_
  208.  * difference */
  209. md_c[0] = md_count[0];
  210. md_c[1] = md_count[1];
  211. memcpy(local_md, md, sizeof md);
  212. /* state_index <= state_num <= STATE_SIZE */
  213. state_index += num;
  214. if (state_index >= STATE_SIZE)
  215. {
  216. state_index%=STATE_SIZE;
  217. state_num=STATE_SIZE;
  218. }
  219. else if (state_num < STATE_SIZE)
  220. {
  221. if (state_index > state_num)
  222. state_num=state_index;
  223. }
  224. /* state_index <= state_num <= STATE_SIZE */
  225. /* state[st_idx], ..., state[(st_idx + num - 1) % STATE_SIZE]
  226.  * are what we will use now, but other threads may use them
  227.  * as well */
  228. md_count[1] += (num / MD_DIGEST_LENGTH) + (num % MD_DIGEST_LENGTH > 0);
  229. if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
  230. EVP_MD_CTX_init(&m);
  231. for (i=0; i<num; i+=MD_DIGEST_LENGTH)
  232. {
  233. j=(num-i);
  234. j=(j > MD_DIGEST_LENGTH)?MD_DIGEST_LENGTH:j;
  235. MD_Init(&m);
  236. MD_Update(&m,local_md,MD_DIGEST_LENGTH);
  237. k=(st_idx+j)-STATE_SIZE;
  238. if (k > 0)
  239. {
  240. MD_Update(&m,&(state[st_idx]),j-k);
  241. MD_Update(&m,&(state[0]),k);
  242. }
  243. else
  244. MD_Update(&m,&(state[st_idx]),j);
  245. MD_Update(&m,buf,j);
  246. MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c));
  247. MD_Final(&m,local_md);
  248. md_c[1]++;
  249. buf=(const char *)buf + j;
  250. for (k=0; k<j; k++)
  251. {
  252. /* Parallel threads may interfere with this,
  253.  * but always each byte of the new state is
  254.  * the XOR of some previous value of its
  255.  * and local_md (itermediate values may be lost).
  256.  * Alway using locking could hurt performance more
  257.  * than necessary given that conflicts occur only
  258.  * when the total seeding is longer than the random
  259.  * state. */
  260. state[st_idx++]^=local_md[k];
  261. if (st_idx >= STATE_SIZE)
  262. st_idx=0;
  263. }
  264. }
  265. EVP_MD_CTX_cleanup(&m);
  266. if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
  267. /* Don't just copy back local_md into md -- this could mean that
  268.  * other thread's seeding remains without effect (except for
  269.  * the incremented counter).  By XORing it we keep at least as
  270.  * much entropy as fits into md. */
  271. for (k = 0; k < (int)sizeof(md); k++)
  272. {
  273. md[k] ^= local_md[k];
  274. }
  275. if (entropy < ENTROPY_NEEDED) /* stop counting when we have enough */
  276.     entropy += add;
  277. if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
  278. #if !defined(OPENSSL_THREADS) && !defined(OPENSSL_SYS_WIN32)
  279. assert(md_c[1] == md_count[1]);
  280. #endif
  281. }
  282. static void ssleay_rand_seed(const void *buf, int num)
  283. {
  284. ssleay_rand_add(buf, num, (double)num);
  285. }
  286. static int ssleay_rand_bytes(unsigned char *buf, int num)
  287. {
  288. static volatile int stirred_pool = 0;
  289. int i,j,k,st_num,st_idx;
  290. int num_ceil;
  291. int ok;
  292. long md_c[2];
  293. unsigned char local_md[MD_DIGEST_LENGTH];
  294. EVP_MD_CTX m;
  295. #ifndef GETPID_IS_MEANINGLESS
  296. pid_t curr_pid = getpid();
  297. #endif
  298. int do_stir_pool = 0;
  299. #ifdef PREDICT
  300. if (rand_predictable)
  301. {
  302. static unsigned char val=0;
  303. for (i=0; i<num; i++)
  304. buf[i]=val++;
  305. return(1);
  306. }
  307. #endif
  308. if (num <= 0)
  309. return 1;
  310. EVP_MD_CTX_init(&m);
  311. /* round upwards to multiple of MD_DIGEST_LENGTH/2 */
  312. num_ceil = (1 + (num-1)/(MD_DIGEST_LENGTH/2)) * (MD_DIGEST_LENGTH/2);
  313. /*
  314.  * (Based on the rand(3) manpage:)
  315.  *
  316.  * For each group of 10 bytes (or less), we do the following:
  317.  *
  318.  * Input into the hash function the local 'md' (which is initialized from
  319.  * the global 'md' before any bytes are generated), the bytes that are to
  320.  * be overwritten by the random bytes, and bytes from the 'state'
  321.  * (incrementing looping index). From this digest output (which is kept
  322.  * in 'md'), the top (up to) 10 bytes are returned to the caller and the
  323.  * bottom 10 bytes are xored into the 'state'.
  324.  * 
  325.  * Finally, after we have finished 'num' random bytes for the
  326.  * caller, 'count' (which is incremented) and the local and global 'md'
  327.  * are fed into the hash function and the results are kept in the
  328.  * global 'md'.
  329.  */
  330. CRYPTO_w_lock(CRYPTO_LOCK_RAND);
  331. /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
  332. CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
  333. locking_thread = CRYPTO_thread_id();
  334. CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
  335. crypto_lock_rand = 1;
  336. if (!initialized)
  337. {
  338. RAND_poll();
  339. initialized = 1;
  340. }
  341. if (!stirred_pool)
  342. do_stir_pool = 1;
  343. ok = (entropy >= ENTROPY_NEEDED);
  344. if (!ok)
  345. {
  346. /* If the PRNG state is not yet unpredictable, then seeing
  347.  * the PRNG output may help attackers to determine the new
  348.  * state; thus we have to decrease the entropy estimate.
  349.  * Once we've had enough initial seeding we don't bother to
  350.  * adjust the entropy count, though, because we're not ambitious
  351.  * to provide *information-theoretic* randomness.
  352.  *
  353.  * NOTE: This approach fails if the program forks before
  354.  * we have enough entropy. Entropy should be collected
  355.  * in a separate input pool and be transferred to the
  356.  * output pool only when the entropy limit has been reached.
  357.  */
  358. entropy -= num;
  359. if (entropy < 0)
  360. entropy = 0;
  361. }
  362. if (do_stir_pool)
  363. {
  364. /* In the output function only half of 'md' remains secret,
  365.  * so we better make sure that the required entropy gets
  366.  * 'evenly distributed' through 'state', our randomness pool.
  367.  * The input function (ssleay_rand_add) chains all of 'md',
  368.  * which makes it more suitable for this purpose.
  369.  */
  370. int n = STATE_SIZE; /* so that the complete pool gets accessed */
  371. while (n > 0)
  372. {
  373. #if MD_DIGEST_LENGTH > 20
  374. # error "Please adjust DUMMY_SEED."
  375. #endif
  376. #define DUMMY_SEED "...................." /* at least MD_DIGEST_LENGTH */
  377. /* Note that the seed does not matter, it's just that
  378.  * ssleay_rand_add expects to have something to hash. */
  379. ssleay_rand_add(DUMMY_SEED, MD_DIGEST_LENGTH, 0.0);
  380. n -= MD_DIGEST_LENGTH;
  381. }
  382. if (ok)
  383. stirred_pool = 1;
  384. }
  385. st_idx=state_index;
  386. st_num=state_num;
  387. md_c[0] = md_count[0];
  388. md_c[1] = md_count[1];
  389. memcpy(local_md, md, sizeof md);
  390. state_index+=num_ceil;
  391. if (state_index > state_num)
  392. state_index %= state_num;
  393. /* state[st_idx], ..., state[(st_idx + num_ceil - 1) % st_num]
  394.  * are now ours (but other threads may use them too) */
  395. md_count[0] += 1;
  396. /* before unlocking, we must clear 'crypto_lock_rand' */
  397. crypto_lock_rand = 0;
  398. CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
  399. while (num > 0)
  400. {
  401. /* num_ceil -= MD_DIGEST_LENGTH/2 */
  402. j=(num >= MD_DIGEST_LENGTH/2)?MD_DIGEST_LENGTH/2:num;
  403. num-=j;
  404. MD_Init(&m);
  405. #ifndef GETPID_IS_MEANINGLESS
  406. if (curr_pid) /* just in the first iteration to save time */
  407. {
  408. MD_Update(&m,(unsigned char*)&curr_pid,sizeof curr_pid);
  409. curr_pid = 0;
  410. }
  411. #endif
  412. MD_Update(&m,local_md,MD_DIGEST_LENGTH);
  413. MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c));
  414. #ifndef PURIFY
  415. MD_Update(&m,buf,j); /* purify complains */
  416. #endif
  417. k=(st_idx+MD_DIGEST_LENGTH/2)-st_num;
  418. if (k > 0)
  419. {
  420. MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2-k);
  421. MD_Update(&m,&(state[0]),k);
  422. }
  423. else
  424. MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2);
  425. MD_Final(&m,local_md);
  426. for (i=0; i<MD_DIGEST_LENGTH/2; i++)
  427. {
  428. state[st_idx++]^=local_md[i]; /* may compete with other threads */
  429. if (st_idx >= st_num)
  430. st_idx=0;
  431. if (i < j)
  432. *(buf++)=local_md[i+MD_DIGEST_LENGTH/2];
  433. }
  434. }
  435. MD_Init(&m);
  436. MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c));
  437. MD_Update(&m,local_md,MD_DIGEST_LENGTH);
  438. CRYPTO_w_lock(CRYPTO_LOCK_RAND);
  439. MD_Update(&m,md,MD_DIGEST_LENGTH);
  440. MD_Final(&m,md);
  441. CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
  442. EVP_MD_CTX_cleanup(&m);
  443. if (ok)
  444. return(1);
  445. else
  446. {
  447. RANDerr(RAND_F_SSLEAY_RAND_BYTES,RAND_R_PRNG_NOT_SEEDED);
  448. ERR_add_error_data(1, "You need to read the OpenSSL FAQ, "
  449. "http://www.openssl.org/support/faq.html");
  450. return(0);
  451. }
  452. }
  453. /* pseudo-random bytes that are guaranteed to be unique but not
  454.    unpredictable */
  455. static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num) 
  456. {
  457. int ret;
  458. unsigned long err;
  459. ret = RAND_bytes(buf, num);
  460. if (ret == 0)
  461. {
  462. err = ERR_peek_error();
  463. if (ERR_GET_LIB(err) == ERR_LIB_RAND &&
  464.     ERR_GET_REASON(err) == RAND_R_PRNG_NOT_SEEDED)
  465. ERR_clear_error();
  466. }
  467. return (ret);
  468. }
  469. static int ssleay_rand_status(void)
  470. {
  471. int ret;
  472. int do_not_lock;
  473. /* check if we already have the lock
  474.  * (could happen if a RAND_poll() implementation calls RAND_status()) */
  475. if (crypto_lock_rand)
  476. {
  477. CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
  478. do_not_lock = (locking_thread == CRYPTO_thread_id());
  479. CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
  480. }
  481. else
  482. do_not_lock = 0;
  483. if (!do_not_lock)
  484. {
  485. CRYPTO_w_lock(CRYPTO_LOCK_RAND);
  486. /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
  487. CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
  488. locking_thread = CRYPTO_thread_id();
  489. CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
  490. crypto_lock_rand = 1;
  491. }
  492. if (!initialized)
  493. {
  494. RAND_poll();
  495. initialized = 1;
  496. }
  497. ret = entropy >= ENTROPY_NEEDED;
  498. if (!do_not_lock)
  499. {
  500. /* before unlocking, we must clear 'crypto_lock_rand' */
  501. crypto_lock_rand = 0;
  502. CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
  503. }
  504. return ret;
  505. }