crypto_random.c File Reference

functions to gather random numbers More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include <gcrypt.h>

Include dependency graph for crypto_random.c:

Go to the source code of this file.

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-crypto-random", __VA_ARGS__)
#define	LOG_STRERROR(kind, syscall)    GNUNET_log_from_strerror (kind, "util-crypto-random", syscall)
#define	RANDOM()   glibc_weak_rand32 ()
#define	SRANDOM(s)   glibc_weak_srand32 (s)
#define	RAND_MAX   0x7fffffff /* Hopefully this is correct */

Functions
void	glibc_weak_srand32 (int32_t s)
int32_t	glibc_weak_rand32 ()
static double	get_weak_random (void)
	Create a cryptographically weak pseudo-random number in the interval of 0 to 1.
void	GNUNET_CRYPTO_seed_weak_random (int32_t seed)
	Seed a weak random generator.
void	GNUNET_CRYPTO_zero_keys (void *buffer, size_t length)
	Zero out buffer, securely against compiler optimizations.
void	GNUNET_CRYPTO_random_block (enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
	Fill block with a random values.
uint32_t	GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i)
	Produce a random unsigned 32-bit number modulo i.
unsigned int *	GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode, unsigned int n)
	Get an array with a random permutation of the numbers 0...n-1.
uint64_t	GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode, uint64_t max)
	Generate a random unsigned 64-bit value.
void	GNUNET_CRYPTO_random_timeflake (enum GNUNET_CRYPTO_Quality mode, struct GNUNET_Uuid *uuid)
	Fill UUID with a timeflake pseudo-random value.
static void *	w_malloc (size_t n)
	Allocation wrapper for libgcrypt, used to avoid bad locking strategy of libgcrypt implementation.
static int	w_check (const void *p)
	Allocation wrapper for libgcrypt, used to avoid bad locking strategy of libgcrypt implementation.
void	GNUNET_CRYPTO_random_init (void)
void	__attribute__ ((constructor))
	Initialize libgcrypt.
void	GNUNET_CRYPTO_random_fini (void)
void	__attribute__ ((destructor))
	Nicely shut down libgcrypt.

Variables
static int32_t	glibc_weak_rand32_state = 1

Detailed Description

functions to gather random numbers

Author

Christian Grothoff

Definition in file crypto_random.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-crypto-random", __VA_ARGS__)

Definition at line 32 of file crypto_random.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)		GNUNET_log_from_strerror (kind, "util-crypto-random", syscall)

Definition at line 34 of file crypto_random.c.

{
  glibc_weak_rand32_state = s;
}
 
 
int32_t
glibc_weak_rand32 ()
{
  int32_t val = glibc_weak_rand32_state;
 
  val = ((glibc_weak_rand32_state * 1103515245) + 12345) & 0x7fffffff;
  glibc_weak_rand32_state = val;
  return val;
}
 
 
#endif
 
static double
get_weak_random (void)
{
  return(random () / (double) RAND_MAX);
}
 
 
void
GNUNET_CRYPTO_seed_weak_random (int32_t seed)
{
#ifdef OPENBSD
  srandom_deterministic (seed);
#else
  srandom (seed);
#endif
}
 
 
void
GNUNET_CRYPTO_zero_keys (void *buffer, size_t length)
{
#if HAVE_MEMSET_S
  memset_s (buffer, length, 0, length);
#elif HAVE_EXPLICIT_BZERO
  explicit_bzero (buffer, length);
#else
  volatile unsigned char *p = buffer;
  while (length--)
    *p++ = 0;
#endif
}
 
 
void
GNUNET_CRYPTO_random_block (enum GNUNET_CRYPTO_Quality mode,
                            void *buffer,
                            size_t length)
{
#ifdef gcry_fast_random_poll
  static unsigned int invokeCount;
#endif
  switch (mode)
  {
  case GNUNET_CRYPTO_QUALITY_STRONG:
    /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
#ifdef gcry_fast_random_poll
    if ((invokeCount++ % 256) == 0)
      gcry_fast_random_poll ();
#endif
    gcry_randomize (buffer, length, GCRY_STRONG_RANDOM);
    return;
 
  case GNUNET_CRYPTO_QUALITY_NONCE:
    gcry_create_nonce (buffer, length);
    return;
 
  case GNUNET_CRYPTO_QUALITY_WEAK:
    /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
#ifdef gcry_fast_random_poll
    if ((invokeCount++ % 256) == 0)
      gcry_fast_random_poll ();
#endif
    gcry_randomize (buffer, length, GCRY_WEAK_RANDOM);
    return;
 
  default:
    GNUNET_assert (0);
  }
}
 
 
uint32_t
GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode,
                          uint32_t i)
{
#ifdef gcry_fast_random_poll
  static unsigned int invokeCount;
#endif
  uint32_t ret;
  uint32_t ul;
 
  GNUNET_assert (i > 0);
 
  switch (mode)
  {
  case GNUNET_CRYPTO_QUALITY_STRONG:
    /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
#ifdef gcry_fast_random_poll
    if ((invokeCount++ % 256) == 0)
      gcry_fast_random_poll ();
#endif
    ul = UINT32_MAX - (UINT32_MAX % i);
    do
    {
      gcry_randomize ((unsigned char *) &ret,
                      sizeof(uint32_t),
                      GCRY_STRONG_RANDOM);
    }
    while (ret >= ul);
    return ret % i;
 
  case GNUNET_CRYPTO_QUALITY_NONCE:
    ul = UINT32_MAX - (UINT32_MAX % i);
    do
    {
      gcry_create_nonce (&ret, sizeof(ret));
    }
    while (ret >= ul);
    return ret % i;
 
  case GNUNET_CRYPTO_QUALITY_WEAK:
    ret = i * get_weak_random ();
    if (ret >= i)
      ret = i - 1;
    return ret;
 
  default:
    GNUNET_assert (0);
  }
  return 0;
}
 
 
unsigned int *
GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode,
                              unsigned int n)
{
  unsigned int *ret;
  unsigned int i;
  unsigned int tmp;
  uint32_t x;
 
  GNUNET_assert (n > 0);
  ret = GNUNET_malloc (n * sizeof(unsigned int));
  for (i = 0; i < n; i++)
    ret[i] = i;
  for (i = n - 1; i > 0; i--)
  {
    x = GNUNET_CRYPTO_random_u32 (mode, i + 1);
    tmp = ret[x];
    ret[x] = ret[i];
    ret[i] = tmp;
  }
  return ret;
}
 
 
uint64_t
GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode,
                          uint64_t max)
{
  uint64_t ret;
  uint64_t ul;
 
  GNUNET_assert (max > 0);
  switch (mode)
  {
  case GNUNET_CRYPTO_QUALITY_STRONG:
    ul = UINT64_MAX - (UINT64_MAX % max);
    do
    {
      gcry_randomize ((unsigned char *) &ret,
                      sizeof(uint64_t),
                      GCRY_STRONG_RANDOM);
    }
    while (ret >= ul);
    return ret % max;
 
  case GNUNET_CRYPTO_QUALITY_NONCE:
    ul = UINT64_MAX - (UINT64_MAX % max);
    do
    {
      gcry_create_nonce (&ret, sizeof(ret));
    }
    while (ret >= ul);
 
    return ret % max;
 
  case GNUNET_CRYPTO_QUALITY_WEAK:
    ret = max * get_weak_random ();
    if (ret >= max)
      ret = max - 1;
    return ret;
 
  default:
    GNUNET_assert (0);
  }
  return 0;
}
 
 
void
GNUNET_CRYPTO_random_timeflake (enum GNUNET_CRYPTO_Quality mode,
                                struct GNUNET_Uuid *uuid)
{
  struct GNUNET_TIME_Absolute now;
  uint64_t ms;
  uint64_t be;
  char *base;
 
  GNUNET_CRYPTO_random_block (mode,
                              uuid,
                              sizeof (struct GNUNET_Uuid));
  now = GNUNET_TIME_absolute_get ();
  ms = now.abs_value_us / GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us;
  be = GNUNET_htonll (ms);
  base = (char *) &be;
  memcpy (uuid,
          base + 2,
          sizeof (be) - 2);
}
 
 
static void *
w_malloc (size_t n)
{
  return calloc (n, 1);
}
 
 
static int
w_check (const void *p)
{
  (void) p;
  return 0; /* not secure memory */
}
 
void
GNUNET_CRYPTO_random_init (void);
 
void __attribute__ ((constructor))
GNUNET_CRYPTO_random_init ()
{
  gcry_error_t rc;
 
  if (! gcry_check_version (NEED_LIBGCRYPT_VERSION))
  {
    fprintf (
      stderr,
      _ ("libgcrypt has not the expected version (version %s is required).\n"),
      NEED_LIBGCRYPT_VERSION);
    GNUNET_assert (0);
  }
  /* set custom allocators */
  gcry_set_allocation_handler (&w_malloc, &w_malloc, &w_check, &realloc, &free);
  /* Disable use of secure memory */
  if ((rc = gcry_control (GCRYCTL_DISABLE_SECMEM, 0)))
    fprintf (stderr,
             "Failed to set libgcrypt option %s: %s\n",
             "DISABLE_SECMEM",
             gcry_strerror (rc));
  /* Otherwise gnunet-ecc takes forever to complete, besides
     we are fine with "just" using GCRY_STRONG_RANDOM */
  if ((rc = gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0)))
    fprintf (stderr,
             "Failed to set libgcrypt option %s: %s\n",
             "ENABLE_QUICK_RANDOM",
             gcry_strerror (rc));
  gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
  gcry_fast_random_poll ();
  GNUNET_CRYPTO_seed_weak_random (
    time (NULL)
    ^ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX));
}
 
void
GNUNET_CRYPTO_random_fini (void);
 
void __attribute__ ((destructor))
GNUNET_CRYPTO_random_fini (void)
{
  gcry_set_progress_handler (NULL, NULL);
#ifdef GCRYCTL_CLOSE_RANDOM_DEVICE
  (void) gcry_control (GCRYCTL_CLOSE_RANDOM_DEVICE, 0);
#endif
}
 
 
/* end of crypto_random.c */

RANDOM

#define RANDOM

(

)

glibc_weak_rand32 ()

Definition at line 47 of file crypto_random.c.

SRANDOM

#define SRANDOM

(

s

)

glibc_weak_srand32 (s)

Definition at line 48 of file crypto_random.c.

RAND_MAX

#define RAND_MAX   0x7fffffff /* Hopefully this is correct */

Definition at line 52 of file crypto_random.c.

Function Documentation

glibc_weak_srand32()

void glibc_weak_srand32

(

int32_t

s

)

Definition at line 59 of file crypto_random.c.

{
  glibc_weak_rand32_state = s;
}

References glibc_weak_rand32_state.

glibc_weak_rand32()

int32_t glibc_weak_rand32

(

)

Definition at line 66 of file crypto_random.c.

{
  int32_t val = glibc_weak_rand32_state;
 
  val = ((glibc_weak_rand32_state * 1103515245) + 12345) & 0x7fffffff;
  glibc_weak_rand32_state = val;
  return val;
}

References glibc_weak_rand32_state.

get_weak_random()

static double get_weak_random ( void  )

static

Create a cryptographically weak pseudo-random number in the interval of 0 to 1.

Returns

number between 0 and 1.

Definition at line 84 of file crypto_random.c.

{
  return(random () / (double) RAND_MAX);
}

References RAND_MAX.

Referenced by GNUNET_CRYPTO_random_u32(), and GNUNET_CRYPTO_random_u64().

Here is the caller graph for this function:

w_malloc()

static void * w_malloc ( size_t  n )

static

Allocation wrapper for libgcrypt, used to avoid bad locking strategy of libgcrypt implementation.

Definition at line 342 of file crypto_random.c.

{
  return calloc (n, 1);
}

Referenced by __attribute__().

Here is the caller graph for this function:

w_check()

static int w_check ( const void *  p )

static

Allocation wrapper for libgcrypt, used to avoid bad locking strategy of libgcrypt implementation.

Definition at line 353 of file crypto_random.c.

{
  (void) p;
  return 0; /* not secure memory */
}

References p.

Referenced by __attribute__().

Here is the caller graph for this function:

GNUNET_CRYPTO_random_init()

void GNUNET_CRYPTO_random_init

(

void

)

__attribute__() [1/2]

void __attribute__

(

(constructor)

)

Initialize libgcrypt.

Definition at line 365 of file crypto_random.c.

{
  gcry_error_t rc;
 
  if (! gcry_check_version (NEED_LIBGCRYPT_VERSION))
  {
    fprintf (
      stderr,
      _ ("libgcrypt has not the expected version (version %s is required).\n"),
      NEED_LIBGCRYPT_VERSION);
    GNUNET_assert (0);
  }
  /* set custom allocators */
  gcry_set_allocation_handler (&w_malloc, &w_malloc, &w_check, &realloc, &free);
  /* Disable use of secure memory */
  if ((rc = gcry_control (GCRYCTL_DISABLE_SECMEM, 0)))
    fprintf (stderr,
             "Failed to set libgcrypt option %s: %s\n",
             "DISABLE_SECMEM",
             gcry_strerror (rc));
  /* Otherwise gnunet-ecc takes forever to complete, besides
     we are fine with "just" using GCRY_STRONG_RANDOM */
  if ((rc = gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0)))
    fprintf (stderr,
             "Failed to set libgcrypt option %s: %s\n",
             "ENABLE_QUICK_RANDOM",
             gcry_strerror (rc));
  gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
  gcry_fast_random_poll ();
  GNUNET_CRYPTO_seed_weak_random (
    time (NULL)
    ^ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX));
}

References _, GNUNET_assert, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_CRYPTO_seed_weak_random(), w_check(), and w_malloc().

Here is the call graph for this function:

GNUNET_CRYPTO_random_fini()

void GNUNET_CRYPTO_random_fini

(

void

)

__attribute__() [2/2]

void __attribute__

(

(destructor)

)

Nicely shut down libgcrypt.

Definition at line 406 of file crypto_random.c.

{
  gcry_set_progress_handler (NULL, NULL);
#ifdef GCRYCTL_CLOSE_RANDOM_DEVICE
  (void) gcry_control (GCRYCTL_CLOSE_RANDOM_DEVICE, 0);
#endif
}

Variable Documentation

glibc_weak_rand32_state

int32_t glibc_weak_rand32_state = 1

static

Definition at line 55 of file crypto_random.c.

Referenced by glibc_weak_rand32(), and glibc_weak_srand32().