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