020c6518d52d966b366f103c3aa6a934987968a6
[libgcrypt.git] / random / random.c
1 /* random.c - Random number switch
2  * Copyright (C) 2008  Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /*
21   This module switches between different implementations of random
22   number generators and provides a few help functions.
23  */
24
25 #include <config.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <assert.h>
29 #include <errno.h>
30
31 #include "g10lib.h"
32 #include "random.h"
33 #include "rand-internal.h"
34 #include "ath.h"
35
36
37 /* If not NULL a progress function called from certain places and the
38    opaque value passed along.  Registred by
39    _gcry_register_random_progress (). */
40 static void (*progress_cb) (void *,const char*,int,int, int );
41 static void *progress_cb_data;
42
43
44
45 \f
46 /* ---  Functions  --- */
47
48
49 /* Used to register a progress callback.  This needs to be called
50    before any threads are created. */
51 void
52 _gcry_register_random_progress (void (*cb)(void *,const char*,int,int,int),
53                                 void *cb_data )
54 {
55   progress_cb = cb;
56   progress_cb_data = cb_data;
57 }
58
59
60 /* This progress function is currently used by the random modules to
61    give hints on how much more entropy is required. */
62 void
63 _gcry_random_progress (const char *what, int printchar, int current, int total)
64 {
65   if (progress_cb)
66     progress_cb (progress_cb_data, what, printchar, current, total);
67 }
68
69
70
71 /* Initialize this random subsystem.  If FULL is false, this function
72    merely calls the basic initialization of the module and does not do
73    anything more.  Doing this is not really required but when running
74    in a threaded environment we might get a race condition
75    otherwise. */
76 void
77 _gcry_random_initialize (int full)
78 {
79   if ( fips_mode() )
80     _gcry_rngfips_initialize (full);
81   else
82     _gcry_rngcsprng_initialize (full);
83 }
84
85
86 void
87 _gcry_random_dump_stats (void)
88 {
89   if ( fips_mode() )
90     _gcry_rngfips_dump_stats ();
91   else
92     _gcry_rngcsprng_dump_stats ();
93 }
94
95
96 /* This function should be called during initialization and beore
97    intialization of this module to place the random pools into secure
98    memory.  */
99 void
100 _gcry_secure_random_alloc (void)
101 {
102   if ( fips_mode() )
103     return;  /* Not used; the fips rng is allows in secure mode.  */
104   _gcry_rngcsprng_secure_alloc ();
105 }
106
107
108 /* This may be called before full initialization to degrade the
109    quality of the RNG for the sake of a faster running test suite.  */
110 void
111 _gcry_enable_quick_random_gen (void)
112 {
113   if ( fips_mode() )
114     return;  /* Not used.  */
115   _gcry_rngcsprng_enable_quick_gen ();
116 }
117
118
119 void
120 _gcry_set_random_daemon_socket (const char *socketname)
121 {
122   if ( fips_mode() )
123     return;  /* Not used.  */
124   _gcry_rngcsprng_set_daemon_socket (socketname);
125 }
126
127 /* With ONOFF set to 1, enable the use of the daemon.  With ONOFF set
128    to 0, disable the use of the daemon.  With ONOF set to -1, return
129    whether the daemon has been enabled. */
130 int
131 _gcry_use_random_daemon (int onoff)
132 {
133   if (fips_mode ())
134     return 0; /* Never enabled in fips mode.  */
135   return _gcry_rngcsprng_use_daemon (onoff);
136 }
137
138
139 /* This function returns true if no real RNG is available or the
140    quality of the RNG has been degraded for test purposes.  */
141 int
142 _gcry_random_is_faked (void)
143 {
144   if (fips_mode ())
145     return 0; /* Never faked in fips mode.  */
146   return _gcry_rngcsprng_is_faked ();
147 }
148
149
150 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
151    should be in the range of 0..100 to indicate the goodness of the
152    entropy added, or -1 for goodness not known.  */
153 gcry_error_t
154 gcry_random_add_bytes (const void *buf, size_t buflen, int quality)
155 {
156   if (fips_mode ())
157     return 0; /* No need for this in fips mode.  */
158   return _gcry_rngcsprng_add_bytes (buf, buflen, quality);
159 }   
160
161   
162 /* Helper function.  */ 
163 static void
164 do_randomize (void *buffer, size_t length, enum gcry_random_level level)
165 {
166   if (fips_mode ())
167     _gcry_rngfips_randomize (buffer, length, level);
168   else
169     _gcry_rngcsprng_randomize (buffer, length, level);
170 }
171
172 /* The public function to return random data of the quality LEVEL.
173    Returns a pointer to a newly allocated and randomized buffer of
174    LEVEL and NBYTES length.  Caller must free the buffer.  */
175 void *
176 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
177 {
178   void *buffer;
179
180   buffer = gcry_xmalloc (nbytes);
181   do_randomize (buffer, nbytes, level);
182   return buffer;
183 }
184
185
186 /* The public function to return random data of the quality LEVEL;
187    this version of the function returns the random in a buffer allocated
188    in secure memory.  Caller must free the buffer. */
189 void *
190 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
191 {
192   void *buffer;
193
194   /* Historical note (1.3.0--1.4.1): The buffer was only allocated
195      in secure memory if the pool in random-csprng.c was also set to
196      use secure memory.  */
197   buffer = gcry_xmalloc_secure (nbytes);
198   do_randomize (buffer, nbytes, level);
199   return buffer;
200 }
201
202
203 /* Public function to fill the buffer with LENGTH bytes of
204    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
205    not very strong, GCRY_STRONG_RANDOM is strong enough for most
206    usage, GCRY_VERY_STRONG_RANDOM is good for key generation stuff but
207    may be very slow.  */
208 void
209 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
210 {
211   do_randomize (buffer, length, level);
212 }
213
214
215 /* This function may be used to specify the file to be used as a seed
216    file for the PRNG.  This fucntion should be called prior to the
217    initialization of the random module.  NAME may not be NULL.  */
218 void
219 _gcry_set_random_seed_file (const char *name)
220 {
221   _gcry_rngcsprng_set_seed_file (name);
222 }
223
224
225 /* If a seed file has been setup, this function may be used to write
226    back the random numbers entropy pool.  */
227 void
228 _gcry_update_random_seed_file (void)
229 {
230   if (!fips_is_operational ())
231     return;
232
233   _gcry_rngcsprng_update_seed_file ();
234 }
235
236
237
238 /* The fast random pool function as called at some places in
239    libgcrypt.  This is merely a wrapper to make sure that this module
240    is initalized and to lock the pool.  Note, that this function is a
241    NOP unless a random function has been used or _gcry_initialize (1)
242    has been used.  We use this hack so that the internal use of this
243    function in cipher_open and md_open won't start filling up the
244    random pool, even if no random will be required by the process. */
245 void
246 _gcry_fast_random_poll (void)
247 {
248   if (!fips_is_operational ())
249     return;
250
251   _gcry_rngcsprng_fast_poll ();
252 }
253
254
255
256 /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
257 void
258 gcry_create_nonce (void *buffer, size_t length)
259 {
260   _gcry_rngcsprng_create_nonce (buffer, length);
261 }
262