v2.4.13.2 -> v2.4.13.3
[opensuse:kernel.git] / drivers / char / random.c
1 /*
2  * random.c -- A strong random number generator
3  *
4  * Version 1.89, last modified 19-Sep-99
5  * 
6  * Copyright Theodore Ts'o, 1994, 1995, 1996, 1997, 1998, 1999.  All
7  * rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, and the entire permission notice in its entirety,
14  *    including the disclaimer of warranties.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. The name of the author may not be used to endorse or promote
19  *    products derived from this software without specific prior
20  *    written permission.
21  * 
22  * ALTERNATIVELY, this product may be distributed under the terms of
23  * the GNU General Public License, in which case the provisions of the GPL are
24  * required INSTEAD OF the above restrictions.  (This clause is
25  * necessary due to a potential bad interaction between the GPL and
26  * the restrictions contained in a BSD-style copyright.)
27  * 
28  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
29  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
30  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
31  * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
34  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
35  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
36  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38  * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
39  * DAMAGE.
40  */
41
42 /*
43  * (now, with legal B.S. out of the way.....) 
44  * 
45  * This routine gathers environmental noise from device drivers, etc.,
46  * and returns good random numbers, suitable for cryptographic use.
47  * Besides the obvious cryptographic uses, these numbers are also good
48  * for seeding TCP sequence numbers, and other places where it is
49  * desirable to have numbers which are not only random, but hard to
50  * predict by an attacker.
51  *
52  * Theory of operation
53  * ===================
54  * 
55  * Computers are very predictable devices.  Hence it is extremely hard
56  * to produce truly random numbers on a computer --- as opposed to
57  * pseudo-random numbers, which can easily generated by using a
58  * algorithm.  Unfortunately, it is very easy for attackers to guess
59  * the sequence of pseudo-random number generators, and for some
60  * applications this is not acceptable.  So instead, we must try to
61  * gather "environmental noise" from the computer's environment, which
62  * must be hard for outside attackers to observe, and use that to
63  * generate random numbers.  In a Unix environment, this is best done
64  * from inside the kernel.
65  * 
66  * Sources of randomness from the environment include inter-keyboard
67  * timings, inter-interrupt timings from some interrupts, and other
68  * events which are both (a) non-deterministic and (b) hard for an
69  * outside observer to measure.  Randomness from these sources are
70  * added to an "entropy pool", which is mixed using a CRC-like function.
71  * This is not cryptographically strong, but it is adequate assuming
72  * the randomness is not chosen maliciously, and it is fast enough that
73  * the overhead of doing it on every interrupt is very reasonable.
74  * As random bytes are mixed into the entropy pool, the routines keep
75  * an *estimate* of how many bits of randomness have been stored into
76  * the random number generator's internal state.
77  * 
78  * When random bytes are desired, they are obtained by taking the SHA
79  * hash of the contents of the "entropy pool".  The SHA hash avoids
80  * exposing the internal state of the entropy pool.  It is believed to
81  * be computationally infeasible to derive any useful information
82  * about the input of SHA from its output.  Even if it is possible to
83  * analyze SHA in some clever way, as long as the amount of data
84  * returned from the generator is less than the inherent entropy in
85  * the pool, the output data is totally unpredictable.  For this
86  * reason, the routine decreases its internal estimate of how many
87  * bits of "true randomness" are contained in the entropy pool as it
88  * outputs random numbers.
89  * 
90  * If this estimate goes to zero, the routine can still generate
91  * random numbers; however, an attacker may (at least in theory) be
92  * able to infer the future output of the generator from prior
93  * outputs.  This requires successful cryptanalysis of SHA, which is
94  * not believed to be feasible, but there is a remote possibility.
95  * Nonetheless, these numbers should be useful for the vast majority
96  * of purposes.
97  * 
98  * Exported interfaces ---- output
99  * ===============================
100  * 
101  * There are three exported interfaces; the first is one designed to
102  * be used from within the kernel:
103  *
104  *      void get_random_bytes(void *buf, int nbytes);
105  *
106  * This interface will return the requested number of random bytes,
107  * and place it in the requested buffer.
108  * 
109  * The two other interfaces are two character devices /dev/random and
110  * /dev/urandom.  /dev/random is suitable for use when very high
111  * quality randomness is desired (for example, for key generation or
112  * one-time pads), as it will only return a maximum of the number of
113  * bits of randomness (as estimated by the random number generator)
114  * contained in the entropy pool.
115  * 
116  * The /dev/urandom device does not have this limit, and will return
117  * as many bytes as are requested.  As more and more random bytes are
118  * requested without giving time for the entropy pool to recharge,
119  * this will result in random numbers that are merely cryptographically
120  * strong.  For many applications, however, this is acceptable.
121  *
122  * Exported interfaces ---- input
123  * ==============================
124  * 
125  * The current exported interfaces for gathering environmental noise
126  * from the devices are:
127  * 
128  *      void add_keyboard_randomness(unsigned char scancode);
129  *      void add_mouse_randomness(__u32 mouse_data);
130  *      void add_interrupt_randomness(int irq);
131  *      void add_blkdev_randomness(int irq);
132  * 
133  * add_keyboard_randomness() uses the inter-keypress timing, as well as the
134  * scancode as random inputs into the "entropy pool".
135  * 
136  * add_mouse_randomness() uses the mouse interrupt timing, as well as
137  * the reported position of the mouse from the hardware.
138  *
139  * add_interrupt_randomness() uses the inter-interrupt timing as random
140  * inputs to the entropy pool.  Note that not all interrupts are good
141  * sources of randomness!  For example, the timer interrupts is not a
142  * good choice, because the periodicity of the interrupts is too
143  * regular, and hence predictable to an attacker.  Disk interrupts are
144  * a better measure, since the timing of the disk interrupts are more
145  * unpredictable.
146  * 
147  * add_blkdev_randomness() times the finishing time of block requests.
148  * 
149  * All of these routines try to estimate how many bits of randomness a
150  * particular randomness source.  They do this by keeping track of the
151  * first and second order deltas of the event timings.
152  *
153  * Ensuring unpredictability at system startup
154  * ============================================
155  * 
156  * When any operating system starts up, it will go through a sequence
157  * of actions that are fairly predictable by an adversary, especially
158  * if the start-up does not involve interaction with a human operator.
159  * This reduces the actual number of bits of unpredictability in the
160  * entropy pool below the value in entropy_count.  In order to
161  * counteract this effect, it helps to carry information in the
162  * entropy pool across shut-downs and start-ups.  To do this, put the
163  * following lines an appropriate script which is run during the boot
164  * sequence: 
165  *
166  *      echo "Initializing random number generator..."
167  *      random_seed=/var/run/random-seed
168  *      # Carry a random seed from start-up to start-up
169  *      # Load and then save the whole entropy pool
170  *      if [ -f $random_seed ]; then
171  *              cat $random_seed >/dev/urandom
172  *      else
173  *              touch $random_seed
174  *      fi
175  *      chmod 600 $random_seed
176  *      poolfile=/proc/sys/kernel/random/poolsize
177  *      [ -r $poolfile ] && bytes=`cat $poolfile` || bytes=512
178  *      dd if=/dev/urandom of=$random_seed count=1 bs=bytes
179  *
180  * and the following lines in an appropriate script which is run as
181  * the system is shutdown:
182  *
183  *      # Carry a random seed from shut-down to start-up
184  *      # Save the whole entropy pool
185  *      echo "Saving random seed..."
186  *      random_seed=/var/run/random-seed
187  *      touch $random_seed
188  *      chmod 600 $random_seed
189  *      poolfile=/proc/sys/kernel/random/poolsize
190  *      [ -r $poolfile ] && bytes=`cat $poolfile` || bytes=512
191  *      dd if=/dev/urandom of=$random_seed count=1 bs=bytes
192  *
193  * For example, on most modern systems using the System V init
194  * scripts, such code fragments would be found in
195  * /etc/rc.d/init.d/random.  On older Linux systems, the correct script
196  * location might be in /etc/rcb.d/rc.local or /etc/rc.d/rc.0.
197  * 
198  * Effectively, these commands cause the contents of the entropy pool
199  * to be saved at shut-down time and reloaded into the entropy pool at
200  * start-up.  (The 'dd' in the addition to the bootup script is to
201  * make sure that /etc/random-seed is different for every start-up,
202  * even if the system crashes without executing rc.0.)  Even with
203  * complete knowledge of the start-up activities, predicting the state
204  * of the entropy pool requires knowledge of the previous history of
205  * the system.
206  *
207  * Configuring the /dev/random driver under Linux
208  * ==============================================
209  *
210  * The /dev/random driver under Linux uses minor numbers 8 and 9 of
211  * the /dev/mem major number (#1).  So if your system does not have
212  * /dev/random and /dev/urandom created already, they can be created
213  * by using the commands:
214  *
215  *      mknod /dev/random c 1 8
216  *      mknod /dev/urandom c 1 9
217  * 
218  * Acknowledgements:
219  * =================
220  *
221  * Ideas for constructing this random number generator were derived
222  * from Pretty Good Privacy's random number generator, and from private
223  * discussions with Phil Karn.  Colin Plumb provided a faster random
224  * number generator, which speed up the mixing function of the entropy
225  * pool, taken from PGPfone.  Dale Worley has also contributed many
226  * useful ideas and suggestions to improve this driver.
227  * 
228  * Any flaws in the design are solely my responsibility, and should
229  * not be attributed to the Phil, Colin, or any of authors of PGP.
230  * 
231  * The code for SHA transform was taken from Peter Gutmann's
232  * implementation, which has been placed in the public domain.
233  * The code for MD5 transform was taken from Colin Plumb's
234  * implementation, which has been placed in the public domain.
235  * The MD5 cryptographic checksum was devised by Ronald Rivest, and is
236  * documented in RFC 1321, "The MD5 Message Digest Algorithm".
237  * 
238  * Further background information on this topic may be obtained from
239  * RFC 1750, "Randomness Recommendations for Security", by Donald
240  * Eastlake, Steve Crocker, and Jeff Schiller.
241  */
242
243 #include <linux/utsname.h>
244 #include <linux/config.h>
245 #include <linux/module.h>
246 #include <linux/kernel.h>
247 #include <linux/major.h>
248 #include <linux/string.h>
249 #include <linux/fcntl.h>
250 #include <linux/slab.h>
251 #include <linux/random.h>
252 #include <linux/poll.h>
253 #include <linux/init.h>
254
255 #include <asm/processor.h>
256 #include <asm/uaccess.h>
257 #include <asm/irq.h>
258 #include <asm/io.h>
259
260 /*
261  * Configuration information
262  */
263 #define DEFAULT_POOL_SIZE 512
264 #define SECONDARY_POOL_SIZE 128
265 #define BATCH_ENTROPY_SIZE 256
266 #define USE_SHA
267
268 /*
269  * The minimum number of bits of entropy before we wake up a read on
270  * /dev/random.  Should always be at least 8, or at least 1 byte.
271  */
272 static int random_read_wakeup_thresh = 8;
273
274 /*
275  * If the entropy count falls under this number of bits, then we
276  * should wake up processes which are selecting or polling on write
277  * access to /dev/random.
278  */
279 static int random_write_wakeup_thresh = 128;
280
281 /*
282  * A pool of size .poolwords is stirred with a primitive polynomial
283  * of degree .poolwords over GF(2).  The taps for various sizes are
284  * defined below.  They are chosen to be evenly spaced (minimum RMS
285  * distance from evenly spaced; the numbers in the comments are a
286  * scaled squared error sum) except for the last tap, which is 1 to
287  * get the twisting happening as fast as possible.
288  */
289 static struct poolinfo {
290         int     poolwords;
291         int     tap1, tap2, tap3, tap4, tap5;
292 } poolinfo_table[] = {
293         /* x^2048 + x^1638 + x^1231 + x^819 + x^411 + x + 1  -- 115 */
294         { 2048, 1638,   1231,   819,    411,    1 },
295
296         /* x^1024 + x^817 + x^615 + x^412 + x^204 + x + 1 -- 290 */
297         { 1024, 817,    615,    412,    204,    1 },
298 #if 0                           /* Alternate polynomial */
299         /* x^1024 + x^819 + x^616 + x^410 + x^207 + x^2 + 1 -- 115 */
300         { 1024, 819,    616,    410,    207,    2 },
301 #endif
302
303         /* x^512 + x^411 + x^308 + x^208 + x^104 + x + 1 -- 225 */
304         { 512,  411,    308,    208,    104,    1 },
305 #if 0                           /* Alternates */
306         /* x^512 + x^409 + x^307 + x^206 + x^102 + x^2 + 1 -- 95 */
307         { 512,  409,    307,    206,    102,    2 },
308         /* x^512 + x^409 + x^309 + x^205 + x^103 + x^2 + 1 -- 95 */
309         { 512,  409,    309,    205,    103,    2 },
310 #endif
311
312         /* x^256 + x^205 + x^155 + x^101 + x^52 + x + 1 -- 125 */
313         { 256,  205,    155,    101,    52,     1 },
314
315         /* x^128 + x^103 + x^76 + x^51 +x^25 + x + 1 -- 105 */
316         { 128,  103,    76,     51,     25,     1 },
317 #if 0   /* Alternate polynomial */
318         /* x^128 + x^103 + x^78 + x^51 + x^27 + x^2 + 1 -- 70 */
319         { 128,  103,    78,     51,     27,     2 },
320 #endif
321
322         /* x^64 + x^52 + x^39 + x^26 + x^14 + x + 1 -- 15 */
323         { 64,   52,     39,     26,     14,     1 },
324
325         /* x^32 + x^26 + x^20 + x^14 + x^7 + x + 1 -- 15 */
326         { 32,   26,     20,     14,     7,      1 },
327
328         { 0,    0,      0,      0,      0,      0 },
329 };
330
331 #define POOLBITS        poolwords*32
332 #define POOLBYTES       poolwords*4
333
334 /*
335  * For the purposes of better mixing, we use the CRC-32 polynomial as
336  * well to make a twisted Generalized Feedback Shift Reigster
337  *
338  * (See M. Matsumoto & Y. Kurita, 1992.  Twisted GFSR generators.  ACM
339  * Transactions on Modeling and Computer Simulation 2(3):179-194.
340  * Also see M. Matsumoto & Y. Kurita, 1994.  Twisted GFSR generators
341  * II.  ACM Transactions on Mdeling and Computer Simulation 4:254-266)
342  *
343  * Thanks to Colin Plumb for suggesting this.
344  * 
345  * We have not analyzed the resultant polynomial to prove it primitive;
346  * in fact it almost certainly isn't.  Nonetheless, the irreducible factors
347  * of a random large-degree polynomial over GF(2) are more than large enough
348  * that periodicity is not a concern.
349  * 
350  * The input hash is much less sensitive than the output hash.  All
351  * that we want of it is that it be a good non-cryptographic hash;
352  * i.e. it not produce collisions when fed "random" data of the sort
353  * we expect to see.  As long as the pool state differs for different
354  * inputs, we have preserved the input entropy and done a good job.
355  * The fact that an intelligent attacker can construct inputs that
356  * will produce controlled alterations to the pool's state is not
357  * important because we don't consider such inputs to contribute any
358  * randomness.  The only property we need with respect to them is that
359  * the attacker can't increase his/her knowledge of the pool's state.
360  * Since all additions are reversible (knowing the final state and the
361  * input, you can reconstruct the initial state), if an attacker has
362  * any uncertainty about the initial state, he/she can only shuffle
363  * that uncertainty about, but never cause any collisions (which would
364  * decrease the uncertainty).
365  *
366  * The chosen system lets the state of the pool be (essentially) the input
367  * modulo the generator polymnomial.  Now, for random primitive polynomials,
368  * this is a universal class of hash functions, meaning that the chance
369  * of a collision is limited by the attacker's knowledge of the generator
370  * polynomail, so if it is chosen at random, an attacker can never force
371  * a collision.  Here, we use a fixed polynomial, but we *can* assume that
372  * ###--> it is unknown to the processes generating the input entropy. <-###
373  * Because of this important property, this is a good, collision-resistant
374  * hash; hash collisions will occur no more often than chance.
375  */
376
377 /*
378  * Linux 2.2 compatibility
379  */
380 #ifndef DECLARE_WAITQUEUE
381 #define DECLARE_WAITQUEUE(WAIT, PTR)    struct wait_queue WAIT = { PTR, NULL }
382 #endif
383 #ifndef DECLARE_WAIT_QUEUE_HEAD
384 #define DECLARE_WAIT_QUEUE_HEAD(WAIT) struct wait_queue *WAIT
385 #endif
386
387 /*
388  * Static global variables
389  */
390 static struct entropy_store *random_state; /* The default global store */
391 static struct entropy_store *sec_random_state; /* secondary store */
392 static DECLARE_WAIT_QUEUE_HEAD(random_read_wait);
393 static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
394
395 /*
396  * Forward procedure declarations
397  */
398 #ifdef CONFIG_SYSCTL
399 static void sysctl_init_random(struct entropy_store *random_state);
400 #endif
401
402 /*****************************************************************
403  *
404  * Utility functions, with some ASM defined functions for speed
405  * purposes
406  * 
407  *****************************************************************/
408
409 #ifndef MIN
410 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
411 #endif
412
413 /*
414  * Unfortunately, while the GCC optimizer for the i386 understands how
415  * to optimize a static rotate left of x bits, it doesn't know how to
416  * deal with a variable rotate of x bits.  So we use a bit of asm magic.
417  */
418 #if (!defined (__i386__))
419 extern inline __u32 rotate_left(int i, __u32 word)
420 {
421         return (word << i) | (word >> (32 - i));
422         
423 }
424 #else
425 extern inline __u32 rotate_left(int i, __u32 word)
426 {
427         __asm__("roll %%cl,%0"
428                 :"=r" (word)
429                 :"0" (word),"c" (i));
430         return word;
431 }
432 #endif
433
434 /*
435  * More asm magic....
436  * 
437  * For entropy estimation, we need to do an integral base 2
438  * logarithm.  
439  *
440  * Note the "12bits" suffix - this is used for numbers between
441  * 0 and 4095 only.  This allows a few shortcuts.
442  */
443 #if 0   /* Slow but clear version */
444 static inline __u32 int_ln_12bits(__u32 word)
445 {
446         __u32 nbits = 0;
447         
448         while (word >>= 1)
449                 nbits++;
450         return nbits;
451 }
452 #else   /* Faster (more clever) version, courtesy Colin Plumb */
453 static inline __u32 int_ln_12bits(__u32 word)
454 {
455         /* Smear msbit right to make an n-bit mask */
456         word |= word >> 8;
457         word |= word >> 4;
458         word |= word >> 2;
459         word |= word >> 1;
460         /* Remove one bit to make this a logarithm */
461         word >>= 1;
462         /* Count the bits set in the word */
463         word -= (word >> 1) & 0x555;
464         word = (word & 0x333) + ((word >> 2) & 0x333);
465         word += (word >> 4);
466         word += (word >> 8);
467         return word & 15;
468 }
469 #endif
470
471 #if 0
472 #define DEBUG_ENT(fmt, arg...) printk(KERN_DEBUG "random: " fmt, ## arg)
473 #else
474 #define DEBUG_ENT(fmt, arg...) do {} while (0)
475 #endif
476
477 /**********************************************************************
478  *
479  * OS independent entropy store.   Here are the functions which handle
480  * storing entropy in an entropy pool.
481  * 
482  **********************************************************************/
483
484 struct entropy_store {
485         unsigned        add_ptr;
486         int             entropy_count;
487         int             input_rotate;
488         int             extract_count;
489         struct poolinfo poolinfo;
490         __u32           *pool;
491 };
492
493 /*
494  * Initialize the entropy store.  The input argument is the size of
495  * the random pool.
496  *
497  * Returns an negative error if there is a problem.
498  */
499 static int create_entropy_store(int size, struct entropy_store **ret_bucket)
500 {
501         struct  entropy_store   *r;
502         struct  poolinfo        *p;
503         int     poolwords;
504
505         poolwords = (size + 3) / 4; /* Convert bytes->words */
506         /* The pool size must be a multiple of 16 32-bit words */
507         poolwords = ((poolwords + 15) / 16) * 16; 
508
509         for (p = poolinfo_table; p->poolwords; p++) {
510                 if (poolwords == p->poolwords)
511                         break;
512         }
513         if (p->poolwords == 0)
514                 return -EINVAL;
515
516         r = kmalloc(sizeof(struct entropy_store), GFP_KERNEL);
517         if (!r)
518                 return -ENOMEM;
519
520         memset (r, 0, sizeof(struct entropy_store));
521         r->poolinfo = *p;
522
523         r->pool = kmalloc(POOLBYTES, GFP_KERNEL);
524         if (!r->pool) {
525                 kfree(r);
526                 return -ENOMEM;
527         }
528         memset(r->pool, 0, POOLBYTES);
529         *ret_bucket = r;
530         return 0;
531 }
532
533 /* Clear the entropy pool and associated counters. */
534 static void clear_entropy_store(struct entropy_store *r)
535 {
536         r->add_ptr = 0;
537         r->entropy_count = 0;
538         r->input_rotate = 0;
539         r->extract_count = 0;
540         memset(r->pool, 0, r->poolinfo.POOLBYTES);
541 }
542
543 static void free_entropy_store(struct entropy_store *r)
544 {
545         if (r->pool)
546                 kfree(r->pool);
547         kfree(r);
548 }
549
550 /*
551  * This function adds a byte into the entropy "pool".  It does not
552  * update the entropy estimate.  The caller should call
553  * credit_entropy_store if this is appropriate.
554  * 
555  * The pool is stirred with a primitive polynomial of the appropriate
556  * degree, and then twisted.  We twist by three bits at a time because
557  * it's cheap to do so and helps slightly in the expected case where
558  * the entropy is concentrated in the low-order bits.
559  */
560 static void add_entropy_words(struct entropy_store *r, const __u32 *in,
561                               int nwords)
562 {
563         static __u32 const twist_table[8] = {
564                          0, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
565                 0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
566         unsigned i;
567         int new_rotate;
568         int wordmask = r->poolinfo.poolwords - 1;
569         __u32 w;
570
571         while (nwords--) {
572                 w = rotate_left(r->input_rotate, *in);
573                 i = r->add_ptr = (r->add_ptr - 1) & wordmask;
574                 /*
575                  * Normally, we add 7 bits of rotation to the pool.
576                  * At the beginning of the pool, add an extra 7 bits
577                  * rotation, so that successive passes spread the
578                  * input bits across the pool evenly.
579                  */
580                 new_rotate = r->input_rotate + 14;
581                 if (i)
582                         new_rotate = r->input_rotate + 7;
583                 r->input_rotate = new_rotate & 31;
584
585                 /* XOR in the various taps */
586                 w ^= r->pool[(i + r->poolinfo.tap1) & wordmask];
587                 w ^= r->pool[(i + r->poolinfo.tap2) & wordmask];
588                 w ^= r->pool[(i + r->poolinfo.tap3) & wordmask];
589                 w ^= r->pool[(i + r->poolinfo.tap4) & wordmask];
590                 w ^= r->pool[(i + r->poolinfo.tap5) & wordmask];
591                 w ^= r->pool[i];
592                 r->pool[i] = (w >> 3) ^ twist_table[w & 7];
593         }
594 }
595
596 /*
597  * Credit (or debit) the entropy store with n bits of entropy
598  */
599 static void credit_entropy_store(struct entropy_store *r, int nbits)
600 {
601         if (r->entropy_count + nbits < 0) {
602                 DEBUG_ENT("negative entropy/overflow (%d+%d)\n",
603                           r->entropy_count, nbits);
604                 r->entropy_count = 0;
605         } else if (r->entropy_count + nbits > r->poolinfo.POOLBITS) {
606                 r->entropy_count = r->poolinfo.POOLBITS;
607         } else {
608                 r->entropy_count += nbits;
609                 if (nbits)
610                         DEBUG_ENT("%s added %d bits, now %d\n",
611                                   r == sec_random_state ? "secondary" :
612                                   r == random_state ? "primary" : "unknown",
613                                   nbits, r->entropy_count);
614         }
615 }
616
617 /**********************************************************************
618  *
619  * Entropy batch input management
620  *
621  * We batch entropy to be added to avoid increasing interrupt latency
622  *
623  **********************************************************************/
624
625 static __u32    *batch_entropy_pool;
626 static int      *batch_entropy_credit;
627 static int      batch_max;
628 static int      batch_head, batch_tail;
629 static struct tq_struct batch_tqueue;
630 static void batch_entropy_process(void *private_);
631
632 /* note: the size must be a power of 2 */
633 static int __init batch_entropy_init(int size, struct entropy_store *r)
634 {
635         batch_entropy_pool = kmalloc(2*size*sizeof(__u32), GFP_KERNEL);
636         if (!batch_entropy_pool)
637                 return -1;
638         batch_entropy_credit =kmalloc(size*sizeof(int), GFP_KERNEL);
639         if (!batch_entropy_credit) {
640                 kfree(batch_entropy_pool);
641                 return -1;
642         }
643         batch_head = batch_tail = 0;
644         batch_max = size;
645         batch_tqueue.routine = batch_entropy_process;
646         batch_tqueue.data = r;
647         return 0;
648 }
649
650 /*
651  * Changes to the entropy data is put into a queue rather than being added to
652  * the entropy counts directly.  This is presumably to avoid doing heavy
653  * hashing calculations during an interrupt in add_timer_randomness().
654  * Instead, the entropy is only added to the pool once per timer tick.
655  */
656 void batch_entropy_store(u32 a, u32 b, int num)
657 {
658         int     new;
659
660         if (!batch_max)
661                 return;
662         
663         batch_entropy_pool[2*batch_head] = a;
664         batch_entropy_pool[(2*batch_head) + 1] = b;
665         batch_entropy_credit[batch_head] = num;
666
667         new = (batch_head+1) & (batch_max-1);
668         if (new != batch_tail) {
669                 queue_task(&batch_tqueue, &tq_timer);
670                 batch_head = new;
671         } else {
672                 DEBUG_ENT("batch entropy buffer full\n");
673         }
674 }
675
676 /*
677  * Flush out the accumulated entropy operations, adding entropy to the passed
678  * store (normally random_state).  If that store has enough entropy, alternate
679  * between randomizing the data of the primary and secondary stores.
680  */
681 static void batch_entropy_process(void *private_)
682 {
683         struct entropy_store *r = (struct entropy_store *) private_, *p;
684         int max_entropy = r->poolinfo.POOLBITS;
685
686         if (!batch_max)
687                 return;
688
689         p = r;
690         while (batch_head != batch_tail) {
691                 if (r->entropy_count >= max_entropy) {
692                         r = (r == sec_random_state) ?   random_state :
693                                                         sec_random_state;
694                         max_entropy = r->poolinfo.POOLBITS;
695                 }
696                 add_entropy_words(r, batch_entropy_pool + 2*batch_tail, 2);
697                 credit_entropy_store(r, batch_entropy_credit[batch_tail]);
698                 batch_tail = (batch_tail+1) & (batch_max-1);
699         }
700         if (p->entropy_count >= random_read_wakeup_thresh)
701                 wake_up_interruptible(&random_read_wait);
702 }
703
704 /*********************************************************************
705  *
706  * Entropy input management
707  *
708  *********************************************************************/
709
710 /* There is one of these per entropy source */
711 struct timer_rand_state {
712         __u32           last_time;
713         __s32           last_delta,last_delta2;
714         int             dont_count_entropy:1;
715 };
716
717 static struct timer_rand_state keyboard_timer_state;
718 static struct timer_rand_state mouse_timer_state;
719 static struct timer_rand_state extract_timer_state;
720 static struct timer_rand_state *irq_timer_state[NR_IRQS];
721 static struct timer_rand_state *blkdev_timer_state[MAX_BLKDEV];
722
723 /*
724  * This function adds entropy to the entropy "pool" by using timing
725  * delays.  It uses the timer_rand_state structure to make an estimate
726  * of how many bits of entropy this call has added to the pool.
727  *
728  * The number "num" is also added to the pool - it should somehow describe
729  * the type of event which just happened.  This is currently 0-255 for
730  * keyboard scan codes, and 256 upwards for interrupts.
731  * On the i386, this is assumed to be at most 16 bits, and the high bits
732  * are used for a high-resolution timer.
733  *
734  */
735 static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
736 {
737         __u32           time;
738         __s32           delta, delta2, delta3;
739         int             entropy = 0;
740
741 #if defined (__i386__)
742         if ( test_bit(X86_FEATURE_TSC, &boot_cpu_data.x86_capability) ) {
743                 __u32 high;
744                 rdtsc(time, high);
745                 num ^= high;
746         } else {
747                 time = jiffies;
748         }
749 #elif defined (__x86_64__)
750         __u32 high;
751         rdtsc(time, high);
752         num ^= high;
753 #else
754         time = jiffies;
755 #endif
756
757         /*
758          * Calculate number of bits of randomness we probably added.
759          * We take into account the first, second and third-order deltas
760          * in order to make our estimate.
761          */
762         if (!state->dont_count_entropy) {
763                 delta = time - state->last_time;
764                 state->last_time = time;
765
766                 delta2 = delta - state->last_delta;
767                 state->last_delta = delta;
768
769                 delta3 = delta2 - state->last_delta2;
770                 state->last_delta2 = delta2;
771
772                 if (delta < 0)
773                         delta = -delta;
774                 if (delta2 < 0)
775                         delta2 = -delta2;
776                 if (delta3 < 0)
777                         delta3 = -delta3;
778                 if (delta > delta2)
779                         delta = delta2;
780                 if (delta > delta3)
781                         delta = delta3;
782
783                 /*
784                  * delta is now minimum absolute delta.
785                  * Round down by 1 bit on general principles,
786                  * and limit entropy entimate to 12 bits.
787                  */
788                 delta >>= 1;
789                 delta &= (1 << 12) - 1;
790
791                 entropy = int_ln_12bits(delta);
792         }
793         batch_entropy_store(num, time, entropy);
794 }
795
796 void add_keyboard_randomness(unsigned char scancode)
797 {
798         static unsigned char last_scancode;
799         /* ignore autorepeat (multiple key down w/o key up) */
800         if (scancode != last_scancode) {
801                 last_scancode = scancode;
802                 add_timer_randomness(&keyboard_timer_state, scancode);
803         }
804 }
805
806 void add_mouse_randomness(__u32 mouse_data)
807 {
808         add_timer_randomness(&mouse_timer_state, mouse_data);
809 }
810
811 void add_interrupt_randomness(int irq)
812 {
813         if (irq >= NR_IRQS || irq_timer_state[irq] == 0)
814                 return;
815
816         add_timer_randomness(irq_timer_state[irq], 0x100+irq);
817 }
818
819 void add_blkdev_randomness(int major)
820 {
821         if (major >= MAX_BLKDEV)
822                 return;
823
824         if (blkdev_timer_state[major] == 0) {
825                 rand_initialize_blkdev(major, GFP_ATOMIC);
826                 if (blkdev_timer_state[major] == 0)
827                         return;
828         }
829                 
830         add_timer_randomness(blkdev_timer_state[major], 0x200+major);
831 }
832
833 /******************************************************************
834  *
835  * Hash function definition
836  *
837  *******************************************************************/
838
839 /*
840  * This chunk of code defines a function
841  * void HASH_TRANSFORM(__u32 digest[HASH_BUFFER_SIZE + HASH_EXTRA_SIZE],
842  *              __u32 const data[16])
843  * 
844  * The function hashes the input data to produce a digest in the first
845  * HASH_BUFFER_SIZE words of the digest[] array, and uses HASH_EXTRA_SIZE
846  * more words for internal purposes.  (This buffer is exported so the
847  * caller can wipe it once rather than this code doing it each call,
848  * and tacking it onto the end of the digest[] array is the quick and
849  * dirty way of doing it.)
850  *
851  * It so happens that MD5 and SHA share most of the initial vector
852  * used to initialize the digest[] array before the first call:
853  * 1) 0x67452301
854  * 2) 0xefcdab89
855  * 3) 0x98badcfe
856  * 4) 0x10325476
857  * 5) 0xc3d2e1f0 (SHA only)
858  * 
859  * For /dev/random purposes, the length of the data being hashed is
860  * fixed in length, so appending a bit count in the usual way is not
861  * cryptographically necessary.
862  */
863
864 #ifdef USE_SHA
865
866 #define HASH_BUFFER_SIZE 5
867 #define HASH_EXTRA_SIZE 80
868 #define HASH_TRANSFORM SHATransform
869
870 /* Various size/speed tradeoffs are available.  Choose 0..3. */
871 #define SHA_CODE_SIZE 0
872
873 /*
874  * SHA transform algorithm, taken from code written by Peter Gutmann,
875  * and placed in the public domain.
876  */
877
878 /* The SHA f()-functions.  */
879
880 #define f1(x,y,z)   ( z ^ (x & (y^z)) )         /* Rounds  0-19: x ? y : z */
881 #define f2(x,y,z)   (x ^ y ^ z)                 /* Rounds 20-39: XOR */
882 #define f3(x,y,z)   ( (x & y) + (z & (x ^ y)) ) /* Rounds 40-59: majority */
883 #define f4(x,y,z)   (x ^ y ^ z)                 /* Rounds 60-79: XOR */
884
885 /* The SHA Mysterious Constants */
886
887 #define K1  0x5A827999L                 /* Rounds  0-19: sqrt(2) * 2^30 */
888 #define K2  0x6ED9EBA1L                 /* Rounds 20-39: sqrt(3) * 2^30 */
889 #define K3  0x8F1BBCDCL                 /* Rounds 40-59: sqrt(5) * 2^30 */
890 #define K4  0xCA62C1D6L                 /* Rounds 60-79: sqrt(10) * 2^30 */
891
892 #define ROTL(n,X)  ( ( ( X ) << n ) | ( ( X ) >> ( 32 - n ) ) )
893
894 #define subRound(a, b, c, d, e, f, k, data) \
895     ( e += ROTL( 5, a ) + f( b, c, d ) + k + data, b = ROTL( 30, b ) )
896
897
898 static void SHATransform(__u32 digest[85], __u32 const data[16])
899 {
900     __u32 A, B, C, D, E;     /* Local vars */
901     __u32 TEMP;
902     int i;
903 #define W (digest + HASH_BUFFER_SIZE)   /* Expanded data array */
904
905     /*
906      * Do the preliminary expansion of 16 to 80 words.  Doing it
907      * out-of-line line this is faster than doing it in-line on
908      * register-starved machines like the x86, and not really any
909      * slower on real processors.
910      */
911     memcpy(W, data, 16*sizeof(__u32));
912     for (i = 0; i < 64; i++) {
913             TEMP = W[i] ^ W[i+2] ^ W[i+8] ^ W[i+13];
914             W[i+16] = ROTL(1, TEMP);
915     }
916
917     /* Set up first buffer and local data buffer */
918     A = digest[ 0 ];
919     B = digest[ 1 ];
920     C = digest[ 2 ];
921     D = digest[ 3 ];
922     E = digest[ 4 ];
923
924     /* Heavy mangling, in 4 sub-rounds of 20 iterations each. */
925 #if SHA_CODE_SIZE == 0
926     /*
927      * Approximately 50% of the speed of the largest version, but
928      * takes up 1/16 the space.  Saves about 6k on an i386 kernel.
929      */
930     for (i = 0; i < 80; i++) {
931         if (i < 40) {
932             if (i < 20)
933                 TEMP = f1(B, C, D) + K1;
934             else
935                 TEMP = f2(B, C, D) + K2;
936         } else {
937             if (i < 60)
938                 TEMP = f3(B, C, D) + K3;
939             else
940                 TEMP = f4(B, C, D) + K4;
941         }
942         TEMP += ROTL(5, A) + E + W[i];
943         E = D; D = C; C = ROTL(30, B); B = A; A = TEMP;
944     }
945 #elif SHA_CODE_SIZE == 1
946     for (i = 0; i < 20; i++) {
947         TEMP = f1(B, C, D) + K1 + ROTL(5, A) + E + W[i];
948         E = D; D = C; C = ROTL(30, B); B = A; A = TEMP;
949     }
950     for (; i < 40; i++) {
951         TEMP = f2(B, C, D) + K2 + ROTL(5, A) + E + W[i];
952         E = D; D = C; C = ROTL(30, B); B = A; A = TEMP;
953     }
954     for (; i < 60; i++) {
955         TEMP = f3(B, C, D) + K3 + ROTL(5, A) + E + W[i];
956         E = D; D = C; C = ROTL(30, B); B = A; A = TEMP;
957     }
958     for (; i < 80; i++) {
959         TEMP = f4(B, C, D) + K4 + ROTL(5, A) + E + W[i];
960         E = D; D = C; C = ROTL(30, B); B = A; A = TEMP;
961     }
962 #elif SHA_CODE_SIZE == 2
963     for (i = 0; i < 20; i += 5) {
964         subRound( A, B, C, D, E, f1, K1, W[ i   ] );
965         subRound( E, A, B, C, D, f1, K1, W[ i+1 ] );
966         subRound( D, E, A, B, C, f1, K1, W[ i+2 ] );
967         subRound( C, D, E, A, B, f1, K1, W[ i+3 ] );
968         subRound( B, C, D, E, A, f1, K1, W[ i+4 ] );
969     }
970     for (; i < 40; i += 5) {
971         subRound( A, B, C, D, E, f2, K2, W[ i   ] );
972         subRound( E, A, B, C, D, f2, K2, W[ i+1 ] );
973         subRound( D, E, A, B, C, f2, K2, W[ i+2 ] );
974         subRound( C, D, E, A, B, f2, K2, W[ i+3 ] );
975         subRound( B, C, D, E, A, f2, K2, W[ i+4 ] );
976     }
977     for (; i < 60; i += 5) {
978         subRound( A, B, C, D, E, f3, K3, W[ i   ] );
979         subRound( E, A, B, C, D, f3, K3, W[ i+1 ] );
980         subRound( D, E, A, B, C, f3, K3, W[ i+2 ] );
981         subRound( C, D, E, A, B, f3, K3, W[ i+3 ] );
982         subRound( B, C, D, E, A, f3, K3, W[ i+4 ] );
983     }
984     for (; i < 80; i += 5) {
985         subRound( A, B, C, D, E, f4, K4, W[ i   ] );
986         subRound( E, A, B, C, D, f4, K4, W[ i+1 ] );
987         subRound( D, E, A, B, C, f4, K4, W[ i+2 ] );
988         subRound( C, D, E, A, B, f4, K4, W[ i+3 ] );
989         subRound( B, C, D, E, A, f4, K4, W[ i+4 ] );
990     }
991 #elif SHA_CODE_SIZE == 3 /* Really large version */
992     subRound( A, B, C, D, E, f1, K1, W[  0 ] );
993     subRound( E, A, B, C, D, f1, K1, W[  1 ] );
994     subRound( D, E, A, B, C, f1, K1, W[  2 ] );
995     subRound( C, D, E, A, B, f1, K1, W[  3 ] );
996     subRound( B, C, D, E, A, f1, K1, W[  4 ] );
997     subRound( A, B, C, D, E, f1, K1, W[  5 ] );
998     subRound( E, A, B, C, D, f1, K1, W[  6 ] );
999     subRound( D, E, A, B, C, f1, K1, W[  7 ] );
1000     subRound( C, D, E, A, B, f1, K1, W[  8 ] );
1001     subRound( B, C, D, E, A, f1, K1, W[  9 ] );
1002     subRound( A, B, C, D, E, f1, K1, W[ 10 ] );
1003     subRound( E, A, B, C, D, f1, K1, W[ 11 ] );
1004     subRound( D, E, A, B, C, f1, K1, W[ 12 ] );
1005     subRound( C, D, E, A, B, f1, K1, W[ 13 ] );
1006     subRound( B, C, D, E, A, f1, K1, W[ 14 ] );
1007     subRound( A, B, C, D, E, f1, K1, W[ 15 ] );
1008     subRound( E, A, B, C, D, f1, K1, W[ 16 ] );
1009     subRound( D, E, A, B, C, f1, K1, W[ 17 ] );
1010     subRound( C, D, E, A, B, f1, K1, W[ 18 ] );
1011     subRound( B, C, D, E, A, f1, K1, W[ 19 ] );
1012
1013     subRound( A, B, C, D, E, f2, K2, W[ 20 ] );
1014     subRound( E, A, B, C, D, f2, K2, W[ 21 ] );
1015     subRound( D, E, A, B, C, f2, K2, W[ 22 ] );
1016     subRound( C, D, E, A, B, f2, K2, W[ 23 ] );
1017     subRound( B, C, D, E, A, f2, K2, W[ 24 ] );
1018     subRound( A, B, C, D, E, f2, K2, W[ 25 ] );
1019     subRound( E, A, B, C, D, f2, K2, W[ 26 ] );
1020     subRound( D, E, A, B, C, f2, K2, W[ 27 ] );
1021     subRound( C, D, E, A, B, f2, K2, W[ 28 ] );
1022     subRound( B, C, D, E, A, f2, K2, W[ 29 ] );
1023     subRound( A, B, C, D, E, f2, K2, W[ 30 ] );
1024     subRound( E, A, B, C, D, f2, K2, W[ 31 ] );
1025     subRound( D, E, A, B, C, f2, K2, W[ 32 ] );
1026     subRound( C, D, E, A, B, f2, K2, W[ 33 ] );
1027     subRound( B, C, D, E, A, f2, K2, W[ 34 ] );
1028     subRound( A, B, C, D, E, f2, K2, W[ 35 ] );
1029     subRound( E, A, B, C, D, f2, K2, W[ 36 ] );
1030     subRound( D, E, A, B, C, f2, K2, W[ 37 ] );
1031     subRound( C, D, E, A, B, f2, K2, W[ 38 ] );
1032     subRound( B, C, D, E, A, f2, K2, W[ 39 ] );
1033     
1034     subRound( A, B, C, D, E, f3, K3, W[ 40 ] );
1035     subRound( E, A, B, C, D, f3, K3, W[ 41 ] );
1036     subRound( D, E, A, B, C, f3, K3, W[ 42 ] );
1037     subRound( C, D, E, A, B, f3, K3, W[ 43 ] );
1038     subRound( B, C, D, E, A, f3, K3, W[ 44 ] );
1039     subRound( A, B, C, D, E, f3, K3, W[ 45 ] );
1040     subRound( E, A, B, C, D, f3, K3, W[ 46 ] );
1041     subRound( D, E, A, B, C, f3, K3, W[ 47 ] );
1042     subRound( C, D, E, A, B, f3, K3, W[ 48 ] );
1043     subRound( B, C, D, E, A, f3, K3, W[ 49 ] );
1044     subRound( A, B, C, D, E, f3, K3, W[ 50 ] );
1045     subRound( E, A, B, C, D, f3, K3, W[ 51 ] );
1046     subRound( D, E, A, B, C, f3, K3, W[ 52 ] );
1047     subRound( C, D, E, A, B, f3, K3, W[ 53 ] );
1048     subRound( B, C, D, E, A, f3, K3, W[ 54 ] );
1049     subRound( A, B, C, D, E, f3, K3, W[ 55 ] );
1050     subRound( E, A, B, C, D, f3, K3, W[ 56 ] );
1051     subRound( D, E, A, B, C, f3, K3, W[ 57 ] );
1052     subRound( C, D, E, A, B, f3, K3, W[ 58 ] );
1053     subRound( B, C, D, E, A, f3, K3, W[ 59 ] );
1054
1055     subRound( A, B, C, D, E, f4, K4, W[ 60 ] );
1056     subRound( E, A, B, C, D, f4, K4, W[ 61 ] );
1057     subRound( D, E, A, B, C, f4, K4, W[ 62 ] );
1058     subRound( C, D, E, A, B, f4, K4, W[ 63 ] );
1059     subRound( B, C, D, E, A, f4, K4, W[ 64 ] );
1060     subRound( A, B, C, D, E, f4, K4, W[ 65 ] );
1061     subRound( E, A, B, C, D, f4, K4, W[ 66 ] );
1062     subRound( D, E, A, B, C, f4, K4, W[ 67 ] );
1063     subRound( C, D, E, A, B, f4, K4, W[ 68 ] );
1064     subRound( B, C, D, E, A, f4, K4, W[ 69 ] );
1065     subRound( A, B, C, D, E, f4, K4, W[ 70 ] );
1066     subRound( E, A, B, C, D, f4, K4, W[ 71 ] );
1067     subRound( D, E, A, B, C, f4, K4, W[ 72 ] );
1068     subRound( C, D, E, A, B, f4, K4, W[ 73 ] );
1069     subRound( B, C, D, E, A, f4, K4, W[ 74 ] );
1070     subRound( A, B, C, D, E, f4, K4, W[ 75 ] );
1071     subRound( E, A, B, C, D, f4, K4, W[ 76 ] );
1072     subRound( D, E, A, B, C, f4, K4, W[ 77 ] );
1073     subRound( C, D, E, A, B, f4, K4, W[ 78 ] );
1074     subRound( B, C, D, E, A, f4, K4, W[ 79 ] );
1075 #else
1076 #error Illegal SHA_CODE_SIZE
1077 #endif
1078
1079     /* Build message digest */
1080     digest[ 0 ] += A;
1081     digest[ 1 ] += B;
1082     digest[ 2 ] += C;
1083     digest[ 3 ] += D;
1084     digest[ 4 ] += E;
1085
1086         /* W is wiped by the caller */
1087 #undef W
1088 }
1089
1090 #undef ROTL
1091 #undef f1
1092 #undef f2
1093 #undef f3
1094 #undef f4
1095 #undef K1       
1096 #undef K2
1097 #undef K3       
1098 #undef K4       
1099 #undef subRound
1100         
1101 #else /* !USE_SHA - Use MD5 */
1102
1103 #define HASH_BUFFER_SIZE 4
1104 #define HASH_EXTRA_SIZE 0
1105 #define HASH_TRANSFORM MD5Transform
1106         
1107 /*
1108  * MD5 transform algorithm, taken from code written by Colin Plumb,
1109  * and put into the public domain
1110  */
1111
1112 /* The four core functions - F1 is optimized somewhat */
1113
1114 /* #define F1(x, y, z) (x & y | ~x & z) */
1115 #define F1(x, y, z) (z ^ (x & (y ^ z)))
1116 #define F2(x, y, z) F1(z, x, y)
1117 #define F3(x, y, z) (x ^ y ^ z)
1118 #define F4(x, y, z) (y ^ (x | ~z))
1119
1120 /* This is the central step in the MD5 algorithm. */
1121 #define MD5STEP(f, w, x, y, z, data, s) \
1122         ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
1123
1124 /*
1125  * The core of the MD5 algorithm, this alters an existing MD5 hash to
1126  * reflect the addition of 16 longwords of new data.  MD5Update blocks
1127  * the data and converts bytes into longwords for this routine.
1128  */
1129 static void MD5Transform(__u32 buf[HASH_BUFFER_SIZE], __u32 const in[16])
1130 {
1131         __u32 a, b, c, d;
1132
1133         a = buf[0];
1134         b = buf[1];
1135         c = buf[2];
1136         d = buf[3];
1137
1138         MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
1139         MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
1140         MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
1141         MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
1142         MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
1143         MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
1144         MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
1145         MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
1146         MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
1147         MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
1148         MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
1149         MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
1150         MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
1151         MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
1152         MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
1153         MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
1154
1155         MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
1156         MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
1157         MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
1158         MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
1159         MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
1160         MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
1161         MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
1162         MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
1163         MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
1164         MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
1165         MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
1166         MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
1167         MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
1168         MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
1169         MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
1170         MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
1171
1172         MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
1173         MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
1174         MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
1175         MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
1176         MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
1177         MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
1178         MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
1179         MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
1180         MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
1181         MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
1182         MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
1183         MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
1184         MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
1185         MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
1186         MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
1187         MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
1188
1189         MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
1190         MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
1191         MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
1192         MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
1193         MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
1194         MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
1195         MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
1196         MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
1197         MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
1198         MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
1199         MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
1200         MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
1201         MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
1202         MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
1203         MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
1204         MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
1205
1206         buf[0] += a;
1207         buf[1] += b;
1208         buf[2] += c;
1209         buf[3] += d;
1210 }
1211
1212 #undef F1
1213 #undef F2
1214 #undef F3
1215 #undef F4
1216 #undef MD5STEP
1217
1218 #endif /* !USE_SHA */
1219
1220 /*********************************************************************
1221  *
1222  * Entropy extraction routines
1223  *
1224  *********************************************************************/
1225
1226 #define EXTRACT_ENTROPY_USER            1
1227 #define EXTRACT_ENTROPY_SECONDARY       2
1228 #define TMP_BUF_SIZE                    (HASH_BUFFER_SIZE + HASH_EXTRA_SIZE)
1229 #define SEC_XFER_SIZE                   (TMP_BUF_SIZE*4)
1230
1231 static ssize_t extract_entropy(struct entropy_store *r, void * buf,
1232                                size_t nbytes, int flags);
1233
1234 /*
1235  * This utility inline function is responsible for transfering entropy
1236  * from the primary pool to the secondary extraction pool.  We pull
1237  * randomness under two conditions; one is if there isn't enough entropy
1238  * in the secondary pool.  The other is after we have extracted 1024 bytes,
1239  * at which point we do a "catastrophic reseeding".
1240  */
1241 static inline void xfer_secondary_pool(struct entropy_store *r,
1242                                        size_t nbytes)
1243 {
1244         __u32   tmp[TMP_BUF_SIZE];
1245
1246         if (r->entropy_count < nbytes * 8 &&
1247             r->entropy_count < r->poolinfo.POOLBITS) {
1248                 int nwords = min(r->poolinfo.poolwords - r->entropy_count/32,
1249                                  sizeof(tmp) / 4);
1250
1251                 DEBUG_ENT("xfer %d from primary to %s (have %d, need %d)\n",
1252                           nwords * 32,
1253                           r == sec_random_state ? "secondary" : "unknown",
1254                           r->entropy_count, nbytes * 8);
1255
1256                 extract_entropy(random_state, tmp, nwords * 4, 0);
1257                 add_entropy_words(r, tmp, nwords);
1258                 credit_entropy_store(r, nwords * 32);
1259         }
1260         if (r->extract_count > 1024) {
1261                 DEBUG_ENT("reseeding %s with %d from primary\n",
1262                           r == sec_random_state ? "secondary" : "unknown",
1263                           sizeof(tmp) * 8);
1264                 extract_entropy(random_state, tmp, sizeof(tmp), 0);
1265                 add_entropy_words(r, tmp, sizeof(tmp) / 4);
1266                 r->extract_count = 0;
1267         }
1268 }
1269
1270 /*
1271  * This function extracts randomness from the "entropy pool", and
1272  * returns it in a buffer.  This function computes how many remaining
1273  * bits of entropy are left in the pool, but it does not restrict the
1274  * number of bytes that are actually obtained.  If the EXTRACT_ENTROPY_USER
1275  * flag is given, then the buf pointer is assumed to be in user space.
1276  *
1277  * If the EXTRACT_ENTROPY_SECONDARY flag is given, then we are actually
1278  * extracting entropy from the secondary pool, and can refill from the
1279  * primary pool if needed.
1280  *
1281  * Note: extract_entropy() assumes that .poolwords is a multiple of 16 words.
1282  */
1283 static ssize_t extract_entropy(struct entropy_store *r, void * buf,
1284                                size_t nbytes, int flags)
1285 {
1286         ssize_t ret, i;
1287         __u32 tmp[TMP_BUF_SIZE];
1288         __u32 x;
1289
1290         add_timer_randomness(&extract_timer_state, nbytes);
1291
1292         /* Redundant, but just in case... */
1293         if (r->entropy_count > r->poolinfo.POOLBITS)
1294                 r->entropy_count = r->poolinfo.POOLBITS;
1295
1296         if (flags & EXTRACT_ENTROPY_SECONDARY)
1297                 xfer_secondary_pool(r, nbytes);
1298
1299         DEBUG_ENT("%s has %d bits, want %d bits\n",
1300                   r == sec_random_state ? "secondary" :
1301                   r == random_state ? "primary" : "unknown",
1302                   r->entropy_count, nbytes * 8);
1303
1304         if (r->entropy_count / 8 >= nbytes)
1305                 r->entropy_count -= nbytes*8;
1306         else
1307                 r->entropy_count = 0;
1308
1309         if (r->entropy_count < random_write_wakeup_thresh)
1310                 wake_up_interruptible(&random_write_wait);
1311
1312         r->extract_count += nbytes;
1313         
1314         ret = 0;
1315         while (nbytes) {
1316                 /*
1317                  * Check if we need to break out or reschedule....
1318                  */
1319                 if ((flags & EXTRACT_ENTROPY_USER) && current->need_resched) {
1320                         if (signal_pending(current)) {
1321                                 if (ret == 0)
1322                                         ret = -ERESTARTSYS;
1323                                 break;
1324                         }
1325                         schedule();
1326                 }
1327
1328                 /* Hash the pool to get the output */
1329                 tmp[0] = 0x67452301;
1330                 tmp[1] = 0xefcdab89;
1331                 tmp[2] = 0x98badcfe;
1332                 tmp[3] = 0x10325476;
1333 #ifdef USE_SHA
1334                 tmp[4] = 0xc3d2e1f0;
1335 #endif
1336                 /*
1337                  * As we hash the pool, we mix intermediate values of
1338                  * the hash back into the pool.  This eliminates
1339                  * backtracking attacks (where the attacker knows
1340                  * the state of the pool plus the current outputs, and
1341                  * attempts to find previous ouputs), unless the hash
1342                  * function can be inverted.
1343                  */
1344                 for (i = 0, x = 0; i < r->poolinfo.poolwords; i += 16, x+=2) {
1345                         HASH_TRANSFORM(tmp, r->pool+i);
1346                         add_entropy_words(r, &tmp[x%HASH_BUFFER_SIZE], 1);
1347                 }
1348                 
1349                 /*
1350                  * In case the hash function has some recognizable
1351                  * output pattern, we fold it in half.
1352                  */
1353                 for (i = 0; i <  HASH_BUFFER_SIZE/2; i++)
1354                         tmp[i] ^= tmp[i + (HASH_BUFFER_SIZE+1)/2];
1355 #if HASH_BUFFER_SIZE & 1        /* There's a middle word to deal with */
1356                 x = tmp[HASH_BUFFER_SIZE/2];
1357                 x ^= (x >> 16);         /* Fold it in half */
1358                 ((__u16 *)tmp)[HASH_BUFFER_SIZE-1] = (__u16)x;
1359 #endif
1360                 
1361                 /* Copy data to destination buffer */
1362                 i = MIN(nbytes, HASH_BUFFER_SIZE*sizeof(__u32)/2);
1363                 if (flags & EXTRACT_ENTROPY_USER) {
1364                         i -= copy_to_user(buf, (__u8 const *)tmp, i);
1365                         if (!i) {
1366                                 ret = -EFAULT;
1367                                 break;
1368                         }
1369                 } else
1370                         memcpy(buf, (__u8 const *)tmp, i);
1371                 nbytes -= i;
1372                 buf += i;
1373                 ret += i;
1374                 add_timer_randomness(&extract_timer_state, nbytes);
1375         }
1376
1377         /* Wipe data just returned from memory */
1378         memset(tmp, 0, sizeof(tmp));
1379         
1380         return ret;
1381 }
1382
1383 /*
1384  * This function is the exported kernel interface.  It returns some
1385  * number of good random numbers, suitable for seeding TCP sequence
1386  * numbers, etc.
1387  */
1388 void get_random_bytes(void *buf, int nbytes)
1389 {
1390         if (sec_random_state)  
1391                 extract_entropy(sec_random_state, (char *) buf, nbytes, 
1392                                 EXTRACT_ENTROPY_SECONDARY);
1393         else if (random_state)
1394                 extract_entropy(random_state, (char *) buf, nbytes, 0);
1395         else
1396                 printk(KERN_NOTICE "get_random_bytes called before "
1397                                    "random driver initialization\n");
1398 }
1399
1400 /*********************************************************************
1401  *
1402  * Functions to interface with Linux
1403  *
1404  *********************************************************************/
1405
1406 /*
1407  * Initialize the random pool with standard stuff.
1408  *
1409  * NOTE: This is an OS-dependent function.
1410  */
1411 static void init_std_data(struct entropy_store *r)
1412 {
1413         struct timeval  tv;
1414         __u32           words[2];
1415         char            *p;
1416         int             i;
1417
1418         do_gettimeofday(&tv);
1419         words[0] = tv.tv_sec;
1420         words[1] = tv.tv_usec;
1421         add_entropy_words(r, words, 2);
1422
1423         /*
1424          *      This doesn't lock system.utsname. However, we are generating
1425          *      entropy so a race with a name set here is fine.
1426          */
1427         p = (char *) &system_utsname;
1428         for (i = sizeof(system_utsname) / sizeof(words); i; i--) {
1429                 memcpy(words, p, sizeof(words));
1430                 add_entropy_words(r, words, sizeof(words)/4);
1431                 p += sizeof(words);
1432         }
1433 }
1434
1435 void __init rand_initialize(void)
1436 {
1437         int i;
1438
1439         if (create_entropy_store(DEFAULT_POOL_SIZE, &random_state))
1440                 return;         /* Error, return */
1441         if (batch_entropy_init(BATCH_ENTROPY_SIZE, random_state))
1442                 return;         /* Error, return */
1443         if (create_entropy_store(SECONDARY_POOL_SIZE, &sec_random_state))
1444                 return;         /* Error, return */
1445         clear_entropy_store(random_state);
1446         clear_entropy_store(sec_random_state);
1447         init_std_data(random_state);
1448 #ifdef CONFIG_SYSCTL
1449         sysctl_init_random(random_state);
1450 #endif
1451         for (i = 0; i < NR_IRQS; i++)
1452                 irq_timer_state[i] = NULL;
1453         for (i = 0; i < MAX_BLKDEV; i++)
1454                 blkdev_timer_state[i] = NULL;
1455         memset(&keyboard_timer_state, 0, sizeof(struct timer_rand_state));
1456         memset(&mouse_timer_state, 0, sizeof(struct timer_rand_state));
1457         memset(&extract_timer_state, 0, sizeof(struct timer_rand_state));
1458         extract_timer_state.dont_count_entropy = 1;
1459 }
1460
1461 void rand_initialize_irq(int irq)
1462 {
1463         struct timer_rand_state *state;
1464         
1465         if (irq >= NR_IRQS || irq_timer_state[irq])
1466                 return;
1467
1468         /*
1469          * If kmalloc returns null, we just won't use that entropy
1470          * source.
1471          */
1472         state = kmalloc(sizeof(struct timer_rand_state), GFP_KERNEL);
1473         if (state) {
1474                 memset(state, 0, sizeof(struct timer_rand_state));
1475                 irq_timer_state[irq] = state;
1476         }
1477 }
1478
1479 void rand_initialize_blkdev(int major, int mode)
1480 {
1481         struct timer_rand_state *state;
1482         
1483         if (major >= MAX_BLKDEV || blkdev_timer_state[major])
1484                 return;
1485
1486         /*
1487          * If kmalloc returns null, we just won't use that entropy
1488          * source.
1489          */
1490         state = kmalloc(sizeof(struct timer_rand_state), mode);
1491         if (state) {
1492                 memset(state, 0, sizeof(struct timer_rand_state));
1493                 blkdev_timer_state[major] = state;
1494         }
1495 }
1496
1497
1498 static ssize_t
1499 random_read(struct file * file, char * buf, size_t nbytes, loff_t *ppos)
1500 {
1501         DECLARE_WAITQUEUE(wait, current);
1502         ssize_t                 n, retval = 0, count = 0;
1503         
1504         if (nbytes == 0)
1505                 return 0;
1506
1507         add_wait_queue(&random_read_wait, &wait);
1508         while (nbytes > 0) {
1509                 set_current_state(TASK_INTERRUPTIBLE);
1510                 
1511                 n = nbytes;
1512                 if (n > SEC_XFER_SIZE)
1513                         n = SEC_XFER_SIZE;
1514                 if (n > random_state->entropy_count / 8)
1515                         n = random_state->entropy_count / 8;
1516                 if (n == 0) {
1517                         if (file->f_flags & O_NONBLOCK) {
1518                                 retval = -EAGAIN;
1519                                 break;
1520                         }
1521                         if (signal_pending(current)) {
1522                                 retval = -ERESTARTSYS;
1523                                 break;
1524                         }
1525                         schedule();
1526                         continue;
1527                 }
1528                 n = extract_entropy(sec_random_state, buf, n,
1529                                     EXTRACT_ENTROPY_USER |
1530                                     EXTRACT_ENTROPY_SECONDARY);
1531                 if (n < 0) {
1532                         retval = n;
1533                         break;
1534                 }
1535                 count += n;
1536                 buf += n;
1537                 nbytes -= n;
1538                 break;          /* This break makes the device work */
1539                                 /* like a named pipe */
1540         }
1541         current->state = TASK_RUNNING;
1542         remove_wait_queue(&random_read_wait, &wait);
1543
1544         /*
1545          * If we gave the user some bytes, update the access time.
1546          */
1547         if (count != 0) {
1548                 UPDATE_ATIME(file->f_dentry->d_inode);
1549         }
1550         
1551         return (count ? count : retval);
1552 }
1553
1554 static ssize_t
1555 urandom_read(struct file * file, char * buf,
1556                       size_t nbytes, loff_t *ppos)
1557 {
1558         return extract_entropy(sec_random_state, buf, nbytes,
1559                                EXTRACT_ENTROPY_USER |
1560                                EXTRACT_ENTROPY_SECONDARY);
1561 }
1562
1563 static unsigned int
1564 random_poll(struct file *file, poll_table * wait)
1565 {
1566         unsigned int mask;
1567
1568         poll_wait(file, &random_read_wait, wait);
1569         poll_wait(file, &random_write_wait, wait);
1570         mask = 0;
1571         if (random_state->entropy_count >= random_read_wakeup_thresh)
1572                 mask |= POLLIN | POLLRDNORM;
1573         if (random_state->entropy_count < random_write_wakeup_thresh)
1574                 mask |= POLLOUT | POLLWRNORM;
1575         return mask;
1576 }
1577
1578 static ssize_t
1579 random_write(struct file * file, const char * buffer,
1580              size_t count, loff_t *ppos)
1581 {
1582         int             ret = 0;
1583         size_t          bytes;
1584         __u32           buf[16];
1585         const char      *p = buffer;
1586         size_t          c = count;
1587
1588         while (c > 0) {
1589                 bytes = MIN(c, sizeof(buf));
1590
1591                 bytes -= copy_from_user(&buf, p, bytes);
1592                 if (!bytes) {
1593                         ret = -EFAULT;
1594                         break;
1595                 }
1596                 c -= bytes;
1597                 p += bytes;
1598
1599                 add_entropy_words(random_state, buf, (bytes + 3) / 4);
1600         }
1601         if (p == buffer) {
1602                 return (ssize_t)ret;
1603         } else {
1604                 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
1605                 mark_inode_dirty(file->f_dentry->d_inode);
1606                 return (ssize_t)(p - buffer);
1607         }
1608 }
1609
1610 static int
1611 random_ioctl(struct inode * inode, struct file * file,
1612              unsigned int cmd, unsigned long arg)
1613 {
1614         int *p, size, ent_count;
1615         int retval;
1616         
1617         switch (cmd) {
1618         case RNDGETENTCNT:
1619                 ent_count = random_state->entropy_count;
1620                 if (put_user(ent_count, (int *) arg))
1621                         return -EFAULT;
1622                 return 0;
1623         case RNDADDTOENTCNT:
1624                 if (!capable(CAP_SYS_ADMIN))
1625                         return -EPERM;
1626                 if (get_user(ent_count, (int *) arg))
1627                         return -EFAULT;
1628                 credit_entropy_store(random_state, ent_count);
1629                 /*
1630                  * Wake up waiting processes if we have enough
1631                  * entropy.
1632                  */
1633                 if (random_state->entropy_count >= random_read_wakeup_thresh)
1634                         wake_up_interruptible(&random_read_wait);
1635                 return 0;
1636         case RNDGETPOOL:
1637                 if (!capable(CAP_SYS_ADMIN))
1638                         return -EPERM;
1639                 p = (int *) arg;
1640                 ent_count = random_state->entropy_count;
1641                 if (put_user(ent_count, p++) ||
1642                     get_user(size, p) ||
1643                     put_user(random_state->poolinfo.poolwords, p++))
1644                         return -EFAULT;
1645                 if (size < 0)
1646                         return -EINVAL;
1647                 if (size > random_state->poolinfo.poolwords)
1648                         size = random_state->poolinfo.poolwords;
1649                 if (copy_to_user(p, random_state->pool, size * 4))
1650                         return -EFAULT;
1651                 return 0;
1652         case RNDADDENTROPY:
1653                 if (!capable(CAP_SYS_ADMIN))
1654                         return -EPERM;
1655                 p = (int *) arg;
1656                 if (get_user(ent_count, p++))
1657                         return -EFAULT;
1658                 if (ent_count < 0)
1659                         return -EINVAL;
1660                 if (get_user(size, p++))
1661                         return -EFAULT;
1662                 retval = random_write(file, (const char *) p,
1663                                       size, &file->f_pos);
1664                 if (retval < 0)
1665                         return retval;
1666                 credit_entropy_store(random_state, ent_count);
1667                 /*
1668                  * Wake up waiting processes if we have enough
1669                  * entropy.
1670                  */
1671                 if (random_state->entropy_count >= random_read_wakeup_thresh)
1672                         wake_up_interruptible(&random_read_wait);
1673                 return 0;
1674         case RNDZAPENTCNT:
1675                 if (!capable(CAP_SYS_ADMIN))
1676                         return -EPERM;
1677                 random_state->entropy_count = 0;
1678                 return 0;
1679         case RNDCLEARPOOL:
1680                 /* Clear the entropy pool and associated counters. */
1681                 if (!capable(CAP_SYS_ADMIN))
1682                         return -EPERM;
1683                 clear_entropy_store(random_state);
1684                 init_std_data(random_state);
1685                 return 0;
1686         default:
1687                 return -EINVAL;
1688         }
1689 }
1690
1691 struct file_operations random_fops = {
1692         read:           random_read,
1693         write:          random_write,
1694         poll:           random_poll,
1695         ioctl:          random_ioctl,
1696 };
1697
1698 struct file_operations urandom_fops = {
1699         read:           urandom_read,
1700         write:          random_write,
1701         ioctl:          random_ioctl,
1702 };
1703
1704 /***************************************************************
1705  * Random UUID interface
1706  * 
1707  * Used here for a Boot ID, but can be useful for other kernel 
1708  * drivers.
1709  ***************************************************************/
1710
1711 /*
1712  * Generate random UUID
1713  */
1714 void generate_random_uuid(unsigned char uuid_out[16])
1715 {
1716         get_random_bytes(uuid_out, 16);
1717         /* Set UUID version to 4 --- truely random generation */
1718         uuid_out[6] = (uuid_out[6] & 0x0F) | 0x40;
1719         /* Set the UUID variant to DCE */
1720         uuid_out[8] = (uuid_out[8] & 0x3F) | 0x80;
1721 }
1722
1723 /********************************************************************
1724  *
1725  * Sysctl interface
1726  *
1727  ********************************************************************/
1728
1729 #ifdef CONFIG_SYSCTL
1730
1731 #include <linux/sysctl.h>
1732
1733 static int sysctl_poolsize;
1734 static int min_read_thresh, max_read_thresh;
1735 static int min_write_thresh, max_write_thresh;
1736 static char sysctl_bootid[16];
1737
1738 /*
1739  * This function handles a request from the user to change the pool size 
1740  * of the primary entropy store.
1741  */
1742 static int change_poolsize(int poolsize)
1743 {
1744         struct entropy_store    *new_store, *old_store;
1745         int                     ret;
1746         
1747         if ((ret = create_entropy_store(poolsize, &new_store)))
1748                 return ret;
1749
1750         add_entropy_words(new_store, random_state->pool,
1751                           random_state->poolinfo.poolwords);
1752         credit_entropy_store(new_store, random_state->entropy_count);
1753
1754         sysctl_init_random(new_store);
1755         old_store = random_state;
1756         random_state = batch_tqueue.data = new_store;
1757         free_entropy_store(old_store);
1758         return 0;
1759 }
1760
1761 static int proc_do_poolsize(ctl_table *table, int write, struct file *filp,
1762                             void *buffer, size_t *lenp)
1763 {
1764         int     ret;
1765
1766         sysctl_poolsize = random_state->poolinfo.POOLBYTES;
1767
1768         ret = proc_dointvec(table, write, filp, buffer, lenp);
1769         if (ret || !write ||
1770             (sysctl_poolsize == random_state->poolinfo.POOLBYTES))
1771                 return ret;
1772
1773         return change_poolsize(sysctl_poolsize);
1774 }
1775
1776 static int poolsize_strategy(ctl_table *table, int *name, int nlen,
1777                              void *oldval, size_t *oldlenp,
1778                              void *newval, size_t newlen, void **context)
1779 {
1780         int     len;
1781         
1782         sysctl_poolsize = random_state->poolinfo.POOLBYTES;
1783
1784         /*
1785          * We only handle the write case, since the read case gets
1786          * handled by the default handler (and we don't care if the
1787          * write case happens twice; it's harmless).
1788          */
1789         if (newval && newlen) {
1790                 len = newlen;
1791                 if (len > table->maxlen)
1792                         len = table->maxlen;
1793                 if (copy_from_user(table->data, newval, len))
1794                         return -EFAULT;
1795         }
1796
1797         if (sysctl_poolsize != random_state->poolinfo.POOLBYTES)
1798                 return change_poolsize(sysctl_poolsize);
1799
1800         return 0;
1801 }
1802
1803 /*
1804  * These functions is used to return both the bootid UUID, and random
1805  * UUID.  The difference is in whether table->data is NULL; if it is,
1806  * then a new UUID is generated and returned to the user.
1807  * 
1808  * If the user accesses this via the proc interface, it will be returned
1809  * as an ASCII string in the standard UUID format.  If accesses via the 
1810  * sysctl system call, it is returned as 16 bytes of binary data.
1811  */
1812 static int proc_do_uuid(ctl_table *table, int write, struct file *filp,
1813                         void *buffer, size_t *lenp)
1814 {
1815         ctl_table       fake_table;
1816         unsigned char   buf[64], tmp_uuid[16], *uuid;
1817
1818         uuid = table->data;
1819         if (!uuid) {
1820                 uuid = tmp_uuid;
1821                 uuid[8] = 0;
1822         }
1823         if (uuid[8] == 0)
1824                 generate_random_uuid(uuid);
1825
1826         sprintf(buf, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
1827                 "%02x%02x%02x%02x%02x%02x",
1828                 uuid[0],  uuid[1],  uuid[2],  uuid[3],
1829                 uuid[4],  uuid[5],  uuid[6],  uuid[7],
1830                 uuid[8],  uuid[9],  uuid[10], uuid[11],
1831                 uuid[12], uuid[13], uuid[14], uuid[15]);
1832         fake_table.data = buf;
1833         fake_table.maxlen = sizeof(buf);
1834
1835         return proc_dostring(&fake_table, write, filp, buffer, lenp);
1836 }
1837
1838 static int uuid_strategy(ctl_table *table, int *name, int nlen,
1839                          void *oldval, size_t *oldlenp,
1840                          void *newval, size_t newlen, void **context)
1841 {
1842         unsigned char   tmp_uuid[16], *uuid;
1843         unsigned int    len;
1844
1845         if (!oldval || !oldlenp)
1846                 return 1;
1847
1848         uuid = table->data;
1849         if (!uuid) {
1850                 uuid = tmp_uuid;
1851                 uuid[8] = 0;
1852         }
1853         if (uuid[8] == 0)
1854                 generate_random_uuid(uuid);
1855
1856         if (get_user(len, oldlenp))
1857                 return -EFAULT;
1858         if (len) {
1859                 if (len > 16)
1860                         len = 16;
1861                 if (copy_to_user(oldval, uuid, len) ||
1862                     put_user(len, oldlenp))
1863                         return -EFAULT;
1864         }
1865         return 1;
1866 }
1867
1868 ctl_table random_table[] = {
1869         {RANDOM_POOLSIZE, "poolsize",
1870          &sysctl_poolsize, sizeof(int), 0644, NULL,
1871          &proc_do_poolsize, &poolsize_strategy},
1872         {RANDOM_ENTROPY_COUNT, "entropy_avail",
1873          NULL, sizeof(int), 0444, NULL,
1874          &proc_dointvec},
1875         {RANDOM_READ_THRESH, "read_wakeup_threshold",
1876          &random_read_wakeup_thresh, sizeof(int), 0644, NULL,
1877          &proc_dointvec_minmax, &sysctl_intvec, 0,
1878          &min_read_thresh, &max_read_thresh},
1879         {RANDOM_WRITE_THRESH, "write_wakeup_threshold",
1880          &random_write_wakeup_thresh, sizeof(int), 0644, NULL,
1881          &proc_dointvec_minmax, &sysctl_intvec, 0,
1882          &min_write_thresh, &max_write_thresh},
1883         {RANDOM_BOOT_ID, "boot_id",
1884          &sysctl_bootid, 16, 0444, NULL,
1885          &proc_do_uuid, &uuid_strategy},
1886         {RANDOM_UUID, "uuid",
1887          NULL, 16, 0444, NULL,
1888          &proc_do_uuid, &uuid_strategy},
1889         {0}
1890 };
1891
1892 static void sysctl_init_random(struct entropy_store *random_state)
1893 {
1894         min_read_thresh = 8;
1895         min_write_thresh = 0;
1896         max_read_thresh = max_write_thresh = random_state->poolinfo.POOLBITS;
1897         random_table[1].data = &random_state->entropy_count;
1898 }
1899 #endif  /* CONFIG_SYSCTL */
1900
1901 /********************************************************************
1902  *
1903  * Random funtions for networking
1904  *
1905  ********************************************************************/
1906
1907 /*
1908  * TCP initial sequence number picking.  This uses the random number
1909  * generator to pick an initial secret value.  This value is hashed
1910  * along with the TCP endpoint information to provide a unique
1911  * starting point for each pair of TCP endpoints.  This defeats
1912  * attacks which rely on guessing the initial TCP sequence number.
1913  * This algorithm was suggested by Steve Bellovin.
1914  *
1915  * Using a very strong hash was taking an appreciable amount of the total
1916  * TCP connection establishment time, so this is a weaker hash,
1917  * compensated for by changing the secret periodically.
1918  */
1919
1920 /* F, G and H are basic MD4 functions: selection, majority, parity */
1921 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
1922 #define G(x, y, z) (((x) & (y)) + (((x) ^ (y)) & (z)))
1923 #define H(x, y, z) ((x) ^ (y) ^ (z))
1924
1925 /*
1926  * The generic round function.  The application is so specific that
1927  * we don't bother protecting all the arguments with parens, as is generally
1928  * good macro practice, in favor of extra legibility.
1929  * Rotation is separate from addition to prevent recomputation
1930  */
1931 #define ROUND(f, a, b, c, d, x, s)      \
1932         (a += f(b, c, d) + x, a = (a << s) | (a >> (32-s)))
1933 #define K1 0
1934 #define K2 013240474631UL
1935 #define K3 015666365641UL
1936
1937 /*
1938  * Basic cut-down MD4 transform.  Returns only 32 bits of result.
1939  */
1940 static __u32 halfMD4Transform (__u32 const buf[4], __u32 const in[8])
1941 {
1942         __u32   a = buf[0], b = buf[1], c = buf[2], d = buf[3];
1943
1944         /* Round 1 */
1945         ROUND(F, a, b, c, d, in[0] + K1,  3);
1946         ROUND(F, d, a, b, c, in[1] + K1,  7);
1947         ROUND(F, c, d, a, b, in[2] + K1, 11);
1948         ROUND(F, b, c, d, a, in[3] + K1, 19);
1949         ROUND(F, a, b, c, d, in[4] + K1,  3);
1950         ROUND(F, d, a, b, c, in[5] + K1,  7);
1951         ROUND(F, c, d, a, b, in[6] + K1, 11);
1952         ROUND(F, b, c, d, a, in[7] + K1, 19);
1953
1954         /* Round 2 */
1955         ROUND(G, a, b, c, d, in[1] + K2,  3);
1956         ROUND(G, d, a, b, c, in[3] + K2,  5);
1957         ROUND(G, c, d, a, b, in[5] + K2,  9);
1958         ROUND(G, b, c, d, a, in[7] + K2, 13);
1959         ROUND(G, a, b, c, d, in[0] + K2,  3);
1960         ROUND(G, d, a, b, c, in[2] + K2,  5);
1961         ROUND(G, c, d, a, b, in[4] + K2,  9);
1962         ROUND(G, b, c, d, a, in[6] + K2, 13);
1963
1964         /* Round 3 */
1965         ROUND(H, a, b, c, d, in[3] + K3,  3);
1966         ROUND(H, d, a, b, c, in[7] + K3,  9);
1967         ROUND(H, c, d, a, b, in[2] + K3, 11);
1968         ROUND(H, b, c, d, a, in[6] + K3, 15);
1969         ROUND(H, a, b, c, d, in[1] + K3,  3);
1970         ROUND(H, d, a, b, c, in[5] + K3,  9);
1971         ROUND(H, c, d, a, b, in[0] + K3, 11);
1972         ROUND(H, b, c, d, a, in[4] + K3, 15);
1973
1974         return buf[1] + b;      /* "most hashed" word */
1975         /* Alternative: return sum of all words? */
1976 }
1977
1978 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
1979
1980 static __u32 twothirdsMD4Transform (__u32 const buf[4], __u32 const in[12])
1981 {
1982         __u32   a = buf[0], b = buf[1], c = buf[2], d = buf[3];
1983
1984         /* Round 1 */
1985         ROUND(F, a, b, c, d, in[ 0] + K1,  3);
1986         ROUND(F, d, a, b, c, in[ 1] + K1,  7);
1987         ROUND(F, c, d, a, b, in[ 2] + K1, 11);
1988         ROUND(F, b, c, d, a, in[ 3] + K1, 19);
1989         ROUND(F, a, b, c, d, in[ 4] + K1,  3);
1990         ROUND(F, d, a, b, c, in[ 5] + K1,  7);
1991         ROUND(F, c, d, a, b, in[ 6] + K1, 11);
1992         ROUND(F, b, c, d, a, in[ 7] + K1, 19);
1993         ROUND(F, a, b, c, d, in[ 8] + K1,  3);
1994         ROUND(F, d, a, b, c, in[ 9] + K1,  7);
1995         ROUND(F, c, d, a, b, in[10] + K1, 11);
1996         ROUND(F, b, c, d, a, in[11] + K1, 19);
1997
1998         /* Round 2 */
1999         ROUND(G, a, b, c, d, in[ 1] + K2,  3);
2000         ROUND(G, d, a, b, c, in[ 3] + K2,  5);
2001         ROUND(G, c, d, a, b, in[ 5] + K2,  9);
2002         ROUND(G, b, c, d, a, in[ 7] + K2, 13);
2003         ROUND(G, a, b, c, d, in[ 9] + K2,  3);
2004         ROUND(G, d, a, b, c, in[11] + K2,  5);
2005         ROUND(G, c, d, a, b, in[ 0] + K2,  9);
2006         ROUND(G, b, c, d, a, in[ 2] + K2, 13);
2007         ROUND(G, a, b, c, d, in[ 4] + K2,  3);
2008         ROUND(G, d, a, b, c, in[ 6] + K2,  5);
2009         ROUND(G, c, d, a, b, in[ 8] + K2,  9);
2010         ROUND(G, b, c, d, a, in[10] + K2, 13);
2011
2012         /* Round 3 */
2013         ROUND(H, a, b, c, d, in[ 3] + K3,  3);
2014         ROUND(H, d, a, b, c, in[ 7] + K3,  9);
2015         ROUND(H, c, d, a, b, in[11] + K3, 11);
2016         ROUND(H, b, c, d, a, in[ 2] + K3, 15);
2017         ROUND(H, a, b, c, d, in[ 6] + K3,  3);
2018         ROUND(H, d, a, b, c, in[10] + K3,  9);
2019         ROUND(H, c, d, a, b, in[ 1] + K3, 11);
2020         ROUND(H, b, c, d, a, in[ 5] + K3, 15);
2021         ROUND(H, a, b, c, d, in[ 9] + K3,  3);
2022         ROUND(H, d, a, b, c, in[ 0] + K3,  9);
2023         ROUND(H, c, d, a, b, in[ 4] + K3, 11);
2024         ROUND(H, b, c, d, a, in[ 8] + K3, 15);
2025
2026         return buf[1] + b;      /* "most hashed" word */
2027         /* Alternative: return sum of all words? */
2028 }
2029 #endif
2030
2031 #undef ROUND
2032 #undef F
2033 #undef G
2034 #undef H
2035 #undef K1
2036 #undef K2
2037 #undef K3
2038
2039 /* This should not be decreased so low that ISNs wrap too fast. */
2040 #define REKEY_INTERVAL  300
2041 #define HASH_BITS 24
2042
2043 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
2044 __u32 secure_tcpv6_sequence_number(__u32 *saddr, __u32 *daddr,
2045                                    __u16 sport, __u16 dport)
2046 {
2047         static __u32    rekey_time;
2048         static __u32    count;
2049         static __u32    secret[12];
2050         struct timeval  tv;
2051         __u32           seq;
2052
2053         /* The procedure is the same as for IPv4, but addresses are longer. */
2054
2055         do_gettimeofday(&tv);   /* We need the usecs below... */
2056
2057         if (!rekey_time || (tv.tv_sec - rekey_time) > REKEY_INTERVAL) {
2058                 rekey_time = tv.tv_sec;
2059                 /* First five words are overwritten below. */
2060                 get_random_bytes(&secret[5], sizeof(secret)-5*4);
2061                 count = (tv.tv_sec/REKEY_INTERVAL) << HASH_BITS;
2062         }
2063
2064         memcpy(secret, saddr, 16);
2065         secret[4]=(sport << 16) + dport;
2066
2067         seq = (twothirdsMD4Transform(daddr, secret) &
2068                ((1<<HASH_BITS)-1)) + count;
2069
2070         seq += tv.tv_usec + tv.tv_sec*1000000;
2071         return seq;
2072 }
2073
2074 __u32 secure_ipv6_id(__u32 *daddr)
2075 {
2076         static time_t   rekey_time;
2077         static __u32    secret[12];
2078         time_t          t;
2079
2080         /*
2081          * Pick a random secret every REKEY_INTERVAL seconds.
2082          */
2083         t = CURRENT_TIME;
2084         if (!rekey_time || (t - rekey_time) > REKEY_INTERVAL) {
2085                 rekey_time = t;
2086                 /* First word is overwritten below. */
2087                 get_random_bytes(secret, sizeof(secret));
2088         }
2089
2090         return twothirdsMD4Transform(daddr, secret);
2091 }
2092
2093 #endif
2094
2095
2096 __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
2097                                  __u16 sport, __u16 dport)
2098 {
2099         static __u32    rekey_time;
2100         static __u32    count;
2101         static __u32    secret[12];
2102         struct timeval  tv;
2103         __u32           seq;
2104
2105         /*
2106          * Pick a random secret every REKEY_INTERVAL seconds.
2107          */
2108         do_gettimeofday(&tv);   /* We need the usecs below... */
2109
2110         if (!rekey_time || (tv.tv_sec - rekey_time) > REKEY_INTERVAL) {
2111                 rekey_time = tv.tv_sec;
2112                 /* First three words are overwritten below. */
2113                 get_random_bytes(&secret[3], sizeof(secret)-12);
2114                 count = (tv.tv_sec/REKEY_INTERVAL) << HASH_BITS;
2115         }
2116
2117         /*
2118          *  Pick a unique starting offset for each TCP connection endpoints
2119          *  (saddr, daddr, sport, dport).
2120          *  Note that the words are placed into the first words to be
2121          *  mixed in with the halfMD4.  This is because the starting
2122          *  vector is also a random secret (at secret+8), and further
2123          *  hashing fixed data into it isn't going to improve anything,
2124          *  so we should get started with the variable data.
2125          */
2126         secret[0]=saddr;
2127         secret[1]=daddr;
2128         secret[2]=(sport << 16) + dport;
2129
2130         seq = (halfMD4Transform(secret+8, secret) &
2131                ((1<<HASH_BITS)-1)) + count;
2132
2133         /*
2134          *      As close as possible to RFC 793, which
2135          *      suggests using a 250 kHz clock.
2136          *      Further reading shows this assumes 2 Mb/s networks.
2137          *      For 10 Mb/s Ethernet, a 1 MHz clock is appropriate.
2138          *      That's funny, Linux has one built in!  Use it!
2139          *      (Networks are faster now - should this be increased?)
2140          */
2141         seq += tv.tv_usec + tv.tv_sec*1000000;
2142 #if 0
2143         printk("init_seq(%lx, %lx, %d, %d) = %d\n",
2144                saddr, daddr, sport, dport, seq);
2145 #endif
2146         return seq;
2147 }
2148
2149 /*  The code below is shamelessly stolen from secure_tcp_sequence_number().
2150  *  All blames to Andrey V. Savochkin <saw@msu.ru>.
2151  */
2152 __u32 secure_ip_id(__u32 daddr)
2153 {
2154         static time_t   rekey_time;
2155         static __u32    secret[12];
2156         time_t          t;
2157
2158         /*
2159          * Pick a random secret every REKEY_INTERVAL seconds.
2160          */
2161         t = CURRENT_TIME;
2162         if (!rekey_time || (t - rekey_time) > REKEY_INTERVAL) {
2163                 rekey_time = t;
2164                 /* First word is overwritten below. */
2165                 get_random_bytes(secret+1, sizeof(secret)-4);
2166         }
2167
2168         /*
2169          *  Pick a unique starting offset for each IP destination.
2170          *  Note that the words are placed into the first words to be
2171          *  mixed in with the halfMD4.  This is because the starting
2172          *  vector is also a random secret (at secret+8), and further
2173          *  hashing fixed data into it isn't going to improve anything,
2174          *  so we should get started with the variable data.
2175          */
2176         secret[0]=daddr;
2177
2178         return halfMD4Transform(secret+8, secret);
2179 }
2180
2181 #ifdef CONFIG_SYN_COOKIES
2182 /*
2183  * Secure SYN cookie computation. This is the algorithm worked out by
2184  * Dan Bernstein and Eric Schenk.
2185  *
2186  * For linux I implement the 1 minute counter by looking at the jiffies clock.
2187  * The count is passed in as a parameter, so this code doesn't much care.
2188  */
2189
2190 #define COOKIEBITS 24   /* Upper bits store count */
2191 #define COOKIEMASK (((__u32)1 << COOKIEBITS) - 1)
2192
2193 static int      syncookie_init;
2194 static __u32    syncookie_secret[2][16-3+HASH_BUFFER_SIZE];
2195
2196 __u32 secure_tcp_syn_cookie(__u32 saddr, __u32 daddr, __u16 sport,
2197                 __u16 dport, __u32 sseq, __u32 count, __u32 data)
2198 {
2199         __u32   tmp[16 + HASH_BUFFER_SIZE + HASH_EXTRA_SIZE];
2200         __u32   seq;
2201
2202         /*
2203          * Pick two random secrets the first time we need a cookie.
2204          */
2205         if (syncookie_init == 0) {
2206                 get_random_bytes(syncookie_secret, sizeof(syncookie_secret));
2207                 syncookie_init = 1;
2208         }
2209
2210         /*
2211          * Compute the secure sequence number.
2212          * The output should be:
2213          *   HASH(sec1,saddr,sport,daddr,dport,sec1) + sseq + (count * 2^24)
2214          *      + (HASH(sec2,saddr,sport,daddr,dport,count,sec2) % 2^24).
2215          * Where sseq is their sequence number and count increases every
2216          * minute by 1.
2217          * As an extra hack, we add a small "data" value that encodes the
2218          * MSS into the second hash value.
2219          */
2220
2221         memcpy(tmp+3, syncookie_secret[0], sizeof(syncookie_secret[0]));
2222         tmp[0]=saddr;
2223         tmp[1]=daddr;
2224         tmp[2]=(sport << 16) + dport;
2225         HASH_TRANSFORM(tmp+16, tmp);
2226         seq = tmp[17] + sseq + (count << COOKIEBITS);
2227
2228         memcpy(tmp+3, syncookie_secret[1], sizeof(syncookie_secret[1]));
2229         tmp[0]=saddr;
2230         tmp[1]=daddr;
2231         tmp[2]=(sport << 16) + dport;
2232         tmp[3] = count; /* minute counter */
2233         HASH_TRANSFORM(tmp+16, tmp);
2234
2235         /* Add in the second hash and the data */
2236         return seq + ((tmp[17] + data) & COOKIEMASK);
2237 }
2238
2239 /*
2240  * This retrieves the small "data" value from the syncookie.
2241  * If the syncookie is bad, the data returned will be out of
2242  * range.  This must be checked by the caller.
2243  *
2244  * The count value used to generate the cookie must be within
2245  * "maxdiff" if the current (passed-in) "count".  The return value
2246  * is (__u32)-1 if this test fails.
2247  */
2248 __u32 check_tcp_syn_cookie(__u32 cookie, __u32 saddr, __u32 daddr, __u16 sport,
2249                 __u16 dport, __u32 sseq, __u32 count, __u32 maxdiff)
2250 {
2251         __u32   tmp[16 + HASH_BUFFER_SIZE + HASH_EXTRA_SIZE];
2252         __u32   diff;
2253
2254         if (syncookie_init == 0)
2255                 return (__u32)-1;       /* Well, duh! */
2256
2257         /* Strip away the layers from the cookie */
2258         memcpy(tmp+3, syncookie_secret[0], sizeof(syncookie_secret[0]));
2259         tmp[0]=saddr;
2260         tmp[1]=daddr;
2261         tmp[2]=(sport << 16) + dport;
2262         HASH_TRANSFORM(tmp+16, tmp);
2263         cookie -= tmp[17] + sseq;
2264         /* Cookie is now reduced to (count * 2^24) ^ (hash % 2^24) */
2265
2266         diff = (count - (cookie >> COOKIEBITS)) & ((__u32)-1 >> COOKIEBITS);
2267         if (diff >= maxdiff)
2268                 return (__u32)-1;
2269
2270         memcpy(tmp+3, syncookie_secret[1], sizeof(syncookie_secret[1]));
2271         tmp[0] = saddr;
2272         tmp[1] = daddr;
2273         tmp[2] = (sport << 16) + dport;
2274         tmp[3] = count - diff;  /* minute counter */
2275         HASH_TRANSFORM(tmp+16, tmp);
2276
2277         return (cookie - tmp[17]) & COOKIEMASK; /* Leaving the data behind */
2278 }
2279 #endif
2280
2281
2282
2283 EXPORT_SYMBOL(add_keyboard_randomness);
2284 EXPORT_SYMBOL(add_mouse_randomness);
2285 EXPORT_SYMBOL(add_interrupt_randomness);
2286 EXPORT_SYMBOL(add_blkdev_randomness);
2287 EXPORT_SYMBOL(batch_entropy_store);
2288 EXPORT_SYMBOL(generate_random_uuid);
2289