cipher/rndlinux.c

   1 /* rndlinux.c  -  raw random number for OSes with /dev/random
   2  *      Copyright (C) 1998, 2001, 2002 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, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <sys/time.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #ifdef HAVE_GETTIMEOFDAY
  31   #include <sys/times.h>
  32 #endif
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #if 0
  37   #ifdef HAVE_LINUX_RANDOM_H
  38     #include <sys/ioctl.h>
  39     #include <asm/types.h>
  40     #include <linux/random.h>
  41   #endif
  42 #endif
  43 #include "types.h"
  44 #include "g10lib.h"
  45 #include "dynload.h"
  46
  47 static int open_device( const char *name, int minor );
  48 static int gather_random( void (*add)(const void*, size_t, int), int requester,
  49                                           size_t length, int level );
  50
  51 #if 0
  52 #ifdef HAVE_DEV_RANDOM_IOCTL
  53 static ulong
  54 get_entropy_count( int fd )
  55 {
  56     ulong count;
  57
  58     if( ioctl( fd, RNDGETENTCNT, &count ) == -1 )
  59         log_fatal("ioctl(RNDGETENTCNT) failed: %s\n", strerror(errno) );
  60     return count;
  61 }
  62 #endif
  63 #endif
  64
  65 /****************
  66  * Used to open the /dev/random devices (Linux, xBSD, Solaris (if it exists), ...)
  67  */
  68 static int
  69 open_device( const char *name, int minor )
  70 {
  71     int fd;
  72     struct stat sb;
  73
  74     fd = open( name, O_RDONLY );
  75     if( fd == -1 )
  76         log_fatal("can't open %s: %s\n", name, strerror(errno) );
  77     if( fstat( fd, &sb ) )
  78         log_fatal("stat() off %s failed: %s\n", name, strerror(errno) );
  79     /* Don't check device type for better portability */
  80     /*  if( (!S_ISCHR(sb.st_mode)) && (!S_ISFIFO(sb.st_mode)) )
  81           log_fatal("invalid random device!\n" ); */
  82     return fd;
  83 }
  84
  85
  86 static int
  87 gather_random( void (*add)(const void*, size_t, int), int requester,
  88                                           size_t length, int level )
  89 {
  90     static int fd_urandom = -1;
  91     static int fd_random = -1;
  92     int fd;
  93     int n;
  94     int warn=0;
  95     byte buffer[768];
  96
  97     if( level >= 2 ) {
  98         if( fd_random == -1 )
  99             fd_random = open_device( NAME_OF_DEV_RANDOM, 8 );
 100         fd = fd_random;
 101     }
 102     else {
 103         if( fd_urandom == -1 )
 104             fd_urandom = open_device( NAME_OF_DEV_URANDOM, 9 );
 105         fd = fd_urandom;
 106     }
 107
 108   #if 0
 109   #ifdef HAVE_DEV_RANDOM_IOCTL
 110     log_info("entropy count of %d is %lu\n", fd, get_entropy_count(fd) );
 111   #endif
 112   #endif
 113     while( length ) {
 114         fd_set rfds;
 115         struct timeval tv;
 116         int rc;
 117
 118         FD_ZERO(&rfds);
 119         FD_SET(fd, &rfds);
 120         tv.tv_sec = 3;
 121         tv.tv_usec = 0;
 122         if( !(rc=select(fd+1, &rfds, NULL, NULL, &tv)) ) {
 123           if( !warn )
 124             {
 125               log_info (_("not enough random bytes available (need %d bytes)\n"),
 126                         (int)length);
 127               log_info (_("please do some other work to give the OS a chance to collect more entropy\n"));
 128             }
 129               warn = 1;
 130             continue;
 131         }
 132         else if( rc == -1 ) {
 133             log_error ("select() error: %s\n", strerror(errno));
 134             continue;
 135         }
 136
 137         do {
 138             int nbytes = length < sizeof(buffer)? length : sizeof(buffer);
 139             n = read(fd, buffer, nbytes );
 140             if( n >= 0 && n > nbytes ) {
 141                 log_error("bogus read from random device (n=%d)\n", n );
 142                 n = nbytes;
 143             }
 144         } while( n == -1 && errno == EINTR );
 145         if( n == -1 )
 146             log_fatal("read error on random device: %s\n", strerror(errno));
 147         (*add)( buffer, n, requester );
 148         length -= n;
 149     }
 150     memset(buffer, 0, sizeof(buffer) );
 151
 152     return 0; /* success */
 153 }
 154
 155
 156
 157 #ifndef IS_MODULE
 158 static
 159 #endif
 160 const char * const gnupgext_version = "RNDLINUX ($Revision$)";
 161
 162 static struct {
 163     int class;
 164     int version;
 165     void *func;
 166 } func_table[] = {
 167     { 40, 1, gather_random },
 168 };
 169
 170
 171
 172 /****************
 173  * Enumerate the names of the functions together with informations about
 174  * this function. Set sequence to an integer with a initial value of 0 and
 175  * do not change it.
 176  * If what is 0 all kind of functions are returned.
 177  * Return values: class := class of function:
 178  *                         10 = message digest algorithm info function
 179  *                         11 = integer with available md algorithms
 180  *                         20 = cipher algorithm info function
 181  *                         21 = integer with available cipher algorithms
 182  *                         30 = public key algorithm info function
 183  *                         31 = integer with available pubkey algorithms
 184  *                         40 = get gather_random function
 185  *                         41 = get fast_random_poll function
 186  *                version = interface version of the function/pointer
 187  *                          (currently this is 1 for all functions)
 188  */
 189
 190 #ifndef IS_MODULE
 191 static
 192 #endif
 193 void *
 194 gnupgext_enum_func( int what, int *sequence, int *class, int *vers )
 195 {
 196     void *ret;
 197     int i = *sequence;
 198
 199     do {
 200         if ( i >= DIM(func_table) || i < 0 ) {
 201             return NULL;
 202         }
 203         *class = func_table[i].class;
 204         *vers  = func_table[i].version;
 205         ret = func_table[i].func;
 206         i++;
 207     } while ( what && what != *class );
 208
 209     *sequence = i;
 210     return ret;
 211 }
 212
 213 #ifndef IS_MODULE
 214 void
 215 _gcry_rndlinux_constructor(void)
 216 {
 217     _gcry_register_internal_cipher_extension( gnupgext_version,
 218                                         gnupgext_enum_func );
 219 }
 220 #endif
 221