src/util/crypto_random.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001, 2002, 2003, 2004, 2005, 2006 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19
  20 */
  21
  22 /**
  23  * @file util/crypto_random.c
  24  * @brief functions to gather random numbers
  25  * @author Christian Grothoff
  26  */
  27 #include "platform.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_crypto_lib.h"
  30 #include "gnunet_os_lib.h"
  31 #include <gcrypt.h>
  32
  33 /**
  34  * Create a cryptographically weak pseudo-random number in the interval of 0 to 1.
  35  *
  36  * @return number between 0 and 1.
  37  */
  38 static double
  39 weak_random ()
  40 {
  41   return ((double) RANDOM () / RAND_MAX);
  42 }
  43
  44
  45 /**
  46  * Produce a random value.
  47  *
  48  * @param mode desired quality of the random number
  49  * @param i the upper limit (exclusive) for the random number
  50  * @return a random value in the interval [0,i[.
  51  */
  52 uint32_t
  53 GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i)
  54 {
  55 #ifdef gcry_fast_random_poll
  56   static unsigned int invokeCount;
  57 #endif
  58   uint32_t ret;
  59   uint32_t ul;
  60
  61   GNUNET_assert (i > 0);
  62
  63   switch (mode)
  64     {
  65     case GNUNET_CRYPTO_QUALITY_STRONG:
  66       /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
  67 #ifdef gcry_fast_random_poll
  68       if ((invokeCount++ % 256) == 0)
  69         gcry_fast_random_poll ();
  70 #endif
  71       ul = UINT32_MAX - (UINT32_MAX % i);
  72       do
  73         {
  74           gcry_randomize ((unsigned char *) &ret,
  75                           sizeof (uint32_t), GCRY_STRONG_RANDOM);
  76         }
  77       while (ret >= ul);
  78       return ret % i;
  79     case GNUNET_CRYPTO_QUALITY_NONCE:
  80       ul = UINT32_MAX - (UINT32_MAX % i);
  81       do
  82         {
  83           gcry_create_nonce(&ret, sizeof(ret));
  84         }
  85       while (ret >= ul);
  86       return ret % i;
  87     case GNUNET_CRYPTO_QUALITY_WEAK:
  88       ret = i * weak_random ();
  89       if (ret >= i)
  90         ret = i - 1;
  91       return ret;
  92     default:
  93       GNUNET_assert (0);
  94     }
  95   return 0;
  96 }
  97
  98
  99 /**
 100  * Get an array with a random permutation of the
 101  * numbers 0...n-1.
 102  * @param mode GNUNET_RANDOM_QUALITY_STRONG if the strong (but expensive)
 103  *        PRNG should be used, GNUNET_RANDOM_QUALITY_WEAK otherwise
 104  * @param n the size of the array
 105  * @return the permutation array (allocated from heap)
 106  */
 107 unsigned int *
 108 GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode, unsigned int n)
 109 {
 110   unsigned int *ret;
 111   unsigned int i;
 112   unsigned int tmp;
 113   uint32_t x;
 114
 115   GNUNET_assert (n > 0);
 116   ret = GNUNET_malloc (n * sizeof (unsigned int));
 117   for (i = 0; i < n; i++)
 118     ret[i] = i;
 119   for (i = n - 1; i > 0; i--)
 120     {
 121       x = GNUNET_CRYPTO_random_u32 (mode, i+1);
 122       tmp = ret[x];
 123       ret[x] = ret[i];
 124       ret[i] = tmp;
 125     }
 126   return ret;
 127 }
 128
 129 /**
 130  * Random on unsigned 64-bit values.
 131  *
 132  *
 133  * @param mode desired quality of the random number
 134  * @param max value returned will be in range [0,max) (exclusive)
 135  * @return random 64-bit number
 136  */
 137 uint64_t
 138 GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode, uint64_t max)
 139 {
 140   uint64_t ret;
 141   uint64_t ul;
 142
 143   GNUNET_assert (max > 0);
 144   switch (mode)
 145     {
 146     case GNUNET_CRYPTO_QUALITY_STRONG:
 147       ul = UINT64_MAX - (UINT64_MAX % max);
 148       do
 149         {
 150           gcry_randomize ((unsigned char *) &ret,
 151                           sizeof (uint64_t), GCRY_STRONG_RANDOM);
 152         }
 153       while (ret >= ul);
 154       return ret % max;
 155     case GNUNET_CRYPTO_QUALITY_NONCE:
 156       ul = UINT64_MAX - (UINT64_MAX % max);
 157       do
 158         {
 159           gcry_create_nonce(&ret, sizeof(ret));
 160         }
 161       while (ret >= ul);
 162
 163       return ret % max;
 164     case GNUNET_CRYPTO_QUALITY_WEAK:
 165       ret = max * weak_random ();
 166       if (ret >= max)
 167         ret = max - 1;
 168       return ret;
 169     default:
 170       GNUNET_assert (0);
 171     }
 172   return 0;
 173 }
 174
 175 /**
 176  * This function should only be called in testcases
 177  * where strong entropy gathering is not desired
 178  * (for example, for hostkey generation).
 179  */
 180 void
 181 GNUNET_CRYPTO_random_disable_entropy_gathering ()
 182 {
 183   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
 184 }
 185
 186
 187 /**
 188  * Process ID of the "find" process that we use for
 189  * entropy gathering.
 190  */
 191 static GNUNET_OS_Process *genproc;
 192
 193 /**
 194  * Function called by libgcrypt whenever we are
 195  * blocked gathering entropy.
 196  */
 197 static void
 198 entropy_generator (void *cls,
 199                    const char *what, int printchar, int current, int total)
 200 {
 201   unsigned long code;
 202   enum GNUNET_OS_ProcessStatusType type;
 203   int ret;
 204
 205   if (0 != strcmp (what, "need_entropy"))
 206     return;
 207   if (current == total)
 208     {
 209       if (genproc != NULL)
 210         {
 211           if (0 != GNUNET_OS_process_kill (genproc, SIGTERM))
 212             GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "kill");
 213           GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (genproc));
 214           GNUNET_OS_process_close (genproc);
 215           genproc = NULL;
 216         }
 217       return;
 218     }
 219   if (genproc != NULL)
 220     {
 221       ret = GNUNET_OS_process_status (genproc, &type, &code);
 222       if (ret == GNUNET_NO)
 223         return;                 /* still running */
 224       if (ret == GNUNET_SYSERR)
 225         {
 226           GNUNET_break (0);
 227           return;
 228         }
 229       if (0 != GNUNET_OS_process_kill (genproc, SIGTERM))
 230         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "kill");
 231       GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (genproc));
 232       GNUNET_OS_process_close (genproc);
 233       genproc = NULL;
 234     }
 235   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 236               _("Starting `%s' process to generate entropy\n"), "find");
 237   genproc = GNUNET_OS_start_process (NULL, NULL, "sh",
 238                                      "sh",
 239                                      "-c",
 240                                      "exec find / -mount -type f -exec cp {} /dev/null \\; 2>/dev/null",
 241                                      NULL);
 242 }
 243
 244
 245 static void
 246 killfind ()
 247 {
 248   if (genproc != NULL)
 249     {
 250       GNUNET_OS_process_kill (genproc, SIGKILL);
 251       GNUNET_OS_process_close (genproc);
 252       genproc = NULL;
 253     }
 254 }
 255
 256
 257 void __attribute__ ((constructor)) GNUNET_CRYPTO_random_init ()
 258 {
 259   SRANDOM (time (NULL));
 260   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
 261   if (!gcry_check_version (GCRYPT_VERSION))
 262     {
 263       fprintf (stderr,
 264                _
 265                ("libgcrypt has not the expected version (version %s is required).\n"),
 266                GCRYPT_VERSION);
 267       abort ();
 268     }
 269 #ifdef gcry_fast_random_poll
 270   gcry_fast_random_poll ();
 271 #endif
 272   gcry_set_progress_handler (&entropy_generator, NULL);
 273   atexit (&killfind);
 274 }
 275
 276
 277 void __attribute__ ((destructor)) GNUNET_CRYPTO_random_fini ()
 278 {
 279   gcry_set_progress_handler (NULL, NULL);
 280 }
 281
 282
 283
 284 /* end of crypto_random.c */
 285