Fix assignment of <char/int>* to unsigned <char/int>* and vice versa.

[openldap] / libraries / liblutil / entropy.c

diff --git a/libraries/liblutil/entropy.c b/libraries/liblutil/entropy.c
index 56502d32178c810050950b80299f93db4ca89e4e..505f3b5a70d384a1b61286cb2ae460563f6ace88 100644 (file)
--- a/libraries/liblutil/entropy.c
+++ b/libraries/liblutil/entropy.c
@@ -1,6 +1,6 @@
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 
@@ -8,10 +8,8 @@
 
 #include <ac/string.h>
 #include <ac/time.h>
+#include <ac/unistd.h>
 
-#ifdef HAVE_WINCRYPT_H
-#include <wincrypt.h>
-#endif
 #ifdef HAVE_PROCESS_H
 #include <process.h>
 #endif
@@ -24,32 +22,41 @@
 /*
  * lutil_entropy() provides nbytes of entropy in buf.
  * Quality offerred is suitable for one-time uses, such as "once" keys.
+ * Values may not be suitable for multi-time uses.
  *
  * Note:  Callers are encouraged to provide additional bytes of
  * of entropy in the buf argument.  This information is used in
  * fallback mode to improve the quality of bytes returned.
+ *
+ * This routinue should be extended to support additional sources
+ * of entropy.
  */
-int lutil_entropy( char *buf, int nbytes )
+int lutil_entropy( unsigned char *buf, ber_len_t nbytes )
 {
-       if( nbytes < 0 ) return -1;
        if( nbytes == 0 ) return 0;
 
 #ifdef URANDOM_DEVICE
+#define URANDOM_NREADS 4
        /* Linux and *BSD offer a urandom device */
        {
-               int rc, fd;
+               int rc, fd, n=0;
 
                fd = open( URANDOM_DEVICE, O_RDONLY );
 
                if( fd < 0 ) return -1;
 
-               rc = read( fd, buf, nbytes );
-               close(fd);
+               do {
+                       rc = read( fd, buf, nbytes );
+                       if( rc <= 0 ) break;
 
-               /* should return nbytes */
-               if( rc < nbytes ) return -1;
+                       buf+=rc;
+                       nbytes-=rc;
 
-               return 0;
+                       if( ++n >= URANDOM_NREADS ) break;
+               } while( nbytes > 0 );
+
+               close(fd);
+               return nbytes > 0 ? -1 : 0;
        }
 #elif PROV_RSA_FULL
        {
@@ -74,23 +81,25 @@ int lutil_entropy( char *buf, int nbytes )
 #else
        {
                /* based upon Phil Karn's "practical randomness" idea
-                * but implementation 100% OpenLDAP.  So don't blame Phil. */
-               /* worse case is this is a MD5 hash of a counter, if
-                *      MD5 is a strong cryptographic hash, this should
-                *      be fairly resistant to attack
+                * but implementation 100% OpenLDAP.  So don't blame Phil.
+                *
+                * Worse case is that this is a MD5 hash of a counter, if
+                * MD5 is a strong cryptographic hash, this should be fairly
+                * resistant to attack
                 */
 
                /*
-                * the caller may be provide external synchronization OR
-                * provide entropy (in buf) to ensure quality results.
+                * the caller may need to provide external synchronization OR
+                * provide entropy (in buf) to ensure quality results as
+                * access to this counter may not be atomic.
                 */
                static int counter = 0;
-               int n;
+               ber_len_t n;
 
                struct rdata_s {
                        int counter;
 
-                       char *buf;
+                       unsigned char *buf;
                        struct rdata_s *stack;
 
                        pid_t   pid;
@@ -100,7 +109,8 @@ int lutil_entropy( char *buf, int nbytes )
 #else
                        time_t  time;
 #endif
-                       unsigned long   junk;
+
+                       unsigned long   junk;   /* purposely not initialized */
                } rdata;
 
                /* make sure rdata differs for each process */
@@ -112,11 +122,11 @@ int lutil_entropy( char *buf, int nbytes )
 
                for( n = 0; n < nbytes; n += 16 ) {
                        struct lutil_MD5Context ctx;
-                       char digest[16];
+                       unsigned char digest[16];
 
-                       /* hopefully has good resolution */
+                       /* poor resolution */
 #ifdef HAVE_GETTIMEOFDAY
-                       (void) gettimeofday( &rdata.tv, sizeof( rdata.tv ) );
+                       (void) gettimeofday( &rdata.tv, NULL );
 #else
                        (void) time( &rdata.time );
 #endif
@@ -127,14 +137,14 @@ int lutil_entropy( char *buf, int nbytes )
                        rdata.junk++;
 
                        lutil_MD5Init( &ctx );
-                       lutil_MD5Update( &ctx, (char *) &rdata, sizeof( rdata ) );
+                       lutil_MD5Update( &ctx, (unsigned char *) &rdata, sizeof( rdata ) );
 
-                       /* use caller to provided information */
-                       lutil_MD5Update( &ctx, (char *) &buf, nbytes );
+                       /* allow caller to provided additional entropy */
+                       lutil_MD5Update( &ctx, buf, nbytes );
 
                        lutil_MD5Final( digest, &ctx );
 
-                       memcpy( &buf[n], digest,
+                       AC_MEMCPY( &buf[n], digest,
                                nbytes - n >= 16 ? 16 : nbytes - n );
                }