* random.c: Replaced mutex.h by the new ath.h. Changed all calls.
authorWerner Koch <wk@gnupg.org>
Tue, 17 Sep 2002 12:38:22 +0000 (12:38 +0000)
committerWerner Koch <wk@gnupg.org>
Tue, 17 Sep 2002 12:38:22 +0000 (12:38 +0000)
14 files changed:
cipher/ChangeLog
cipher/arcfour.c
cipher/blowfish.c
cipher/cast5.c
cipher/des.c
cipher/md5.c
cipher/primegen.c
cipher/random.c
cipher/rijndael.c
cipher/rmd160.c
cipher/rndegd.c
cipher/rndlinux.c
cipher/sha1.c
cipher/twofish.c

index ec355ac..e54d94e 100644 (file)
@@ -1,3 +1,28 @@
+2002-09-17  Werner Koch  <wk@gnupg.org>
+
+       * random.c: Replaced mutex.h by the new ath.h.  Changed all calls.
+
+2002-09-16  Werner Koch  <wk@gnupg.org>
+
+       * arcfour.c (do_encrypt_stream): Use register modifier and modulo.
+       According to Nikos Mavroyanopoulos this increases perfromace on
+       i386 system noticable.  And I always tought gcc is clever enough.
+       * md5.c (transform): Use register modifier.
+       * rmd160.c (transform): Ditto.
+       * sha1.c (transform): Ditto.  We hope that there are 6 free registers.
+       * random.c (gcry_randomize): Rewrote to avoid malloc calls.
+
+       * rndlinux.c (gather_random): Replaced remaining fprintfs by log_*.
+       * arcfour.c (do_arcfour_setkey): Ditto.
+       * twofish.c (do_twofish_setkey): Ditto.
+       * rndegd.c (gather_random): Ditto.
+       * rijndael.c (do_setkey): Ditto.
+       * random.c (_gcry_random_dump_stats): Ditto. 
+       * primegen.c (_gcry_generate_elg_prime): Ditto.
+       * des.c (_gcry_des_get_info): Ditto.
+       * cast5.c (do_cast_setkey): Ditto.
+       * blowfish.c (do_bf_setkey): Ditto.
+
 2002-08-26  Werner Koch  <wk@gnupg.org>
 
        * des.c (weak_keys): Fixed one entry in the table and compared
index 09bdd50..dec465e 100644 (file)
@@ -56,20 +56,22 @@ static void
 do_encrypt_stream( ARCFOUR_context *ctx,
                 byte *outbuf, const byte *inbuf, unsigned int length )
 {
-    int t;  
-    int i = ctx->idx_i;
-    int j = ctx->idx_j;
-    byte *sbox = ctx->sbox;
-
-    while ( length-- ) {
-        i = (i+1) % 256;
-        j = (j + sbox[i]) % 256;
-        t = sbox[i]; sbox[i] = sbox[j]; sbox[j] = t;
-        *outbuf++ = *inbuf++ ^ sbox[(sbox[i] + sbox[j]) % 256];
+  register int i = ctx->idx_i;
+  register int j = ctx->idx_j;
+  register byte *sbox = ctx->sbox;
+  register int t;  
+
+  while ( length-- )
+    {
+      i = ++i & 255; /* and seems to faster than mod */
+      j += sbox[i];
+      j &= 255;
+      t = sbox[i]; sbox[i] = sbox[j]; sbox[j] = t;
+      *outbuf++ = *inbuf++ ^ sbox[(sbox[i] + sbox[j]) & 255];
     }
-
-    ctx->idx_i = i;
-    ctx->idx_j = j;
+  
+  ctx->idx_i = i;
+  ctx->idx_j = j;
 }
 
 static void
@@ -94,7 +96,7 @@ do_arcfour_setkey( ARCFOUR_context *ctx, const byte *key, unsigned int keylen )
        initialized = 1;
        selftest_failed = selftest();
        if( selftest_failed )
-           fprintf(stderr,"ARCFOUR selftest failed (%s)\n", selftest_failed );
+           log_error ("ARCFOUR selftest failed (%s)\n", selftest_failed );
     }
     if( selftest_failed )
        return GCRYERR_SELFTEST;
index 57c8ab9..af4f497 100644 (file)
@@ -520,7 +520,7 @@ do_bf_setkey( BLOWFISH_context *c, byte *key, unsigned keylen )
        initialized = 1;
        selftest_failed = selftest();
        if( selftest_failed )
-           fprintf(stderr,"%s\n", selftest_failed );
+           log_error ("%s\n", selftest_failed );
     }
     if( selftest_failed )
        return GCRYERR_SELFTEST;
index 35829d6..fbed819 100644 (file)
@@ -591,7 +591,7 @@ do_cast_setkey( CAST5_context *c, byte *key, unsigned keylen )
        initialized = 1;
        selftest_failed = selftest();
        if( selftest_failed )
-           fprintf(stderr,"CAST5 selftest failed (%s).\n", selftest_failed );
+           log_error ("CAST5 selftest failed (%s).\n", selftest_failed );
     }
     if( selftest_failed )
        return GCRYERR_SELFTEST;
index 9d05bfa..bb196f4 100644 (file)
@@ -1097,7 +1097,7 @@ _gcry_des_get_info( int algo, size_t *keylen,
        const char *s = selftest();
        did_selftest = 1;
        if( s ) {
-           fprintf(stderr,"%s\n", s );
+           log_error ("%s\n", s );
            selftest_failed = s;
            return NULL;
        }
index 34713a2..f03a301 100644 (file)
@@ -93,13 +93,13 @@ static void
 transform( MD5_CONTEXT *ctx, byte *data )
 {
     u32 correct_words[16];
-    u32 A = ctx->A;
-    u32 B = ctx->B;
-    u32 C = ctx->C;
-    u32 D = ctx->D;
+    register u32 A = ctx->A;
+    register u32 B = ctx->B;
+    register u32 C = ctx->C;
+    register u32 D = ctx->D;
     u32 *cwp = correct_words;
 
-  #ifdef BIG_ENDIAN_HOST
+#ifdef BIG_ENDIAN_HOST
     { int i;
       byte *p2, *p1;
       for(i=0, p1=data, p2=(byte*)correct_words; i < 16; i++, p2 += 4 ) {
@@ -109,9 +109,9 @@ transform( MD5_CONTEXT *ctx, byte *data )
        p2[0] = *p1++;
       }
     }
-  #else
+#else
     memcpy( correct_words, data, 64 );
-  #endif
+#endif
 
 
 #define OP(a, b, c, d, s, T)                                       \
index 93c4e31..73f678d 100644 (file)
@@ -305,9 +305,9 @@ _gcry_generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
            log_mpidump( "factor pi: ", factors[i] );
        log_debug("bit sizes: prime=%u, q=%u", mpi_get_nbits(prime), mpi_get_nbits(q) );
        if( mode == 1 )
-           fprintf(stderr, ", q0=%u", mpi_get_nbits(q_factor) );
+           log_debug (", q0=%u", mpi_get_nbits(q_factor) );
        for(i=0; i < n; i++ )
-           fprintf(stderr, ", p%d=%u", i, mpi_get_nbits(factors[i]) );
+           log_debug (", p%d=%u", i, mpi_get_nbits(factors[i]) );
        progress('\n');
     }
 
index b4bc2d9..0659cc3 100644 (file)
@@ -55,7 +55,7 @@
 #include "rand-internal.h"
 #include "dynload.h"
 #include "cipher.h" /* only used for the rmd160_hash_buffer() prototype */
-#include "mutex.h"
+#include "ath.h"
 
 #ifndef RAND_MAX   /* for SunOS */
   #define RAND_MAX 32767
@@ -105,8 +105,8 @@ static int secure_alloc;
 static int quick_test;
 static int faked_rng;
 
-DEFINE_LOCAL_MUTEX(pool_lock)
-static int pool_is_locked; /* only for assertion */
+static ath_mutex_t pool_lock = ATH_MUTEX_INITIALIZER;
+static int pool_is_locked; /* only used for assertion */
 
 static byte *get_random_bytes( size_t nbytes, int level, int secure );
 static void read_pool( byte *buffer, size_t length, int level );
@@ -138,7 +138,7 @@ initialize(void)
 {
   int err;
 
-  err = mutex_init (pool_lock);
+  err = ath_mutex_init (&pool_lock);
   if (err)
     log_fatal ("failed to create the pool lock: %s\n", strerror (err) );
     
@@ -168,7 +168,7 @@ burn_stack (int bytes)
 void
 _gcry_random_dump_stats()
 {
-    fprintf(stderr,
+    log_info (
            "random usage: poolsize=%d mixed=%lu polls=%lu/%lu added=%lu/%lu\n"
            "              outmix=%lu getlvl1=%lu/%lu getlvl2=%lu/%lu\n",
        POOLSIZE, rndstats.mixrnd, rndstats.slowpolls, rndstats.fastpolls,
@@ -199,25 +199,6 @@ _gcry_quick_random_gen( int onoff )
     return faked_rng? 1 : last;
 }
 
-
-/****************
- * Fill the buffer with LENGTH bytes of cryptographically strong
- * random bytes. level 0 is not very strong, 1 is strong enough
- * for most usage, 2 is good for key generation stuff but may be very slow.
- */
-void
-gcry_randomize( byte *buffer, size_t length, enum gcry_random_level level )
-{
-  char *p;
-
-  if (!is_initialized)
-    initialize ();
-  p = get_random_bytes( length, level, 1 );
-  memcpy( buffer, p, length );
-  gcry_free(p);
-}
-
-
 int
 _gcry_random_is_faked()
 {
@@ -241,7 +222,7 @@ get_random_bytes( size_t nbytes, int level, int secure )
        level = 1;
     MASK_LEVEL(level);
 
-    err = mutex_lock (pool_lock);
+    err = ath_mutex_lock (&pool_lock);
     if (err)
       log_fatal ("failed to acquire the pool lock: %s\n", strerror (err));
     pool_is_locked = 1;
@@ -264,7 +245,7 @@ get_random_bytes( size_t nbytes, int level, int secure )
     }
 
     pool_is_locked = 0;
-    err = mutex_unlock (pool_lock);
+    err = ath_mutex_unlock (&pool_lock);
     if (err)
       log_fatal ("failed to release the pool lock: %s\n", strerror (err));
     return buf;
@@ -287,6 +268,55 @@ gcry_random_bytes_secure( size_t nbytes, enum gcry_random_level level )
 }
 
 
+/* Fill the buffer with LENGTH bytes of cryptographically strong
+   random bytes. level 0 is not very strong, 1 is strong enough for
+   most usage, 2 is good for key generation stuff but may be very
+   slow.  */
+void
+gcry_randomize (byte *buffer, size_t length, enum gcry_random_level level)
+{
+  byte *p;
+  int err;
+
+  if (!is_initialized)
+    initialize ();
+
+  if( quick_test && level > 1 )
+    level = 1;
+  MASK_LEVEL(level);
+
+  err = ath_mutex_lock (&pool_lock);
+  if (err)
+    log_fatal ("failed to acquire the pool lock: %s\n", strerror (err));
+  pool_is_locked = 1;
+  if (level == 1)
+    {
+      rndstats.getbytes1 += length;
+      rndstats.ngetbytes1++;
+    }
+  else if (level >= 2)
+    {
+      rndstats.getbytes2 += length;
+      rndstats.ngetbytes2++;
+    }
+
+  for (p = buffer; length > 0;)
+    {
+      size_t n = length > POOLSIZE? POOLSIZE : length;
+      read_pool (p, n, level);
+      length -= n;
+      p += n;
+    }
+
+  pool_is_locked = 0;
+  err = ath_mutex_unlock (&pool_lock);
+  if (err)
+    log_fatal ("failed to release the pool lock: %s\n", strerror (err));
+}
+
+
+
+
 /*
    Mix the pool:
 
@@ -483,7 +513,7 @@ _gcry_update_random_seed_file()
       return;
     }
 
-  err = mutex_lock (pool_lock);
+  err = ath_mutex_lock (&pool_lock);
   if (err)
     log_fatal ("failed to acquire the pool lock: %s\n", strerror (err));
   pool_is_locked = 1;
@@ -518,7 +548,7 @@ _gcry_update_random_seed_file()
     }
 
   pool_is_locked = 0;
-  err = mutex_unlock (pool_lock);
+  err = ath_mutex_unlock (&pool_lock);
   if (err)
     log_fatal ("failed to release the pool lock: %s\n", strerror (err));
 }
@@ -745,18 +775,18 @@ _gcry_fast_random_poll()
   /* We have to make sure that the intialization is done because this
      gatherer might be called before any other functions and it is not
      sufficient to initialize it within do_fast_random_pool becuase we
-     want to use the mutex here. FIXME: Weh should initialie the mutex
-     using a global constructore independent from the initialization
+     want to use the mutex here. FIXME: Whe should initialize the mutex
+     using a global constructor independent from the initialization
      of the pool. */
   if (!is_initialized)
     initialize ();
-  err = mutex_lock (pool_lock);
+  err = ath_mutex_lock (&pool_lock);
   if (err)
     log_fatal ("failed to acquire the pool lock: %s\n", strerror (err));
   pool_is_locked = 1;
   do_fast_random_poll ();
   pool_is_locked = 0;
-  err = mutex_unlock (pool_lock);
+  err = ath_mutex_unlock (&pool_lock);
   if (err)
     log_fatal ("failed to acquire the pool lock: %s\n", strerror (err));
 
index 98efa21..f4b1fdd 100644 (file)
@@ -1736,7 +1736,7 @@ do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
         initialized = 1;
         selftest_failed = selftest ();
         if( selftest_failed )
-            fprintf(stderr, "%s\n", selftest_failed );
+            log_error ("%s\n", selftest_failed );
     }
     if( selftest_failed )
         return GCRYERR_SELFTEST;
index 485683f..3680f0a 100644 (file)
@@ -174,33 +174,30 @@ _gcry_rmd160_init( RMD160_CONTEXT *hd )
 static void
 transform( RMD160_CONTEXT *hd, byte *data )
 {
-    u32 a,b,c,d,e,aa,bb,cc,dd,ee,t;
-  #ifdef BIG_ENDIAN_HOST
-    u32 x[16];
-    { int i;
-      byte *p2, *p1;
-      for(i=0, p1=data, p2=(byte*)x; i < 16; i++, p2 += 4 ) {
-       p2[3] = *p1++;
-       p2[2] = *p1++;
-       p2[1] = *p1++;
-       p2[0] = *p1++;
-      }
-    }
-  #else
-   #if 0
-    u32 *x =(u32*)data;
-   #else
-    /* this version is better because it is always aligned;
-     * The performance penalty on a 586-100 is about 6% which
-     * is acceptable - because the data is more local it might
-     * also be possible that this is faster on some machines.
-     * This function (when compiled with -02 on gcc 2.7.2)
-     * executes on a 586-100 (39.73 bogomips) at about 1900kb/sec;
-     * [measured with a 4MB data and "gpgm --print-md rmd160"] */
-    u32 x[16];
-    memcpy( x, data, 64 );
-   #endif
-  #endif
+  register u32 a,b,c,d,e;
+  u32 aa,bb,cc,dd,ee,t;
+#ifdef BIG_ENDIAN_HOST
+  u32 x[16];
+  { int i;
+  byte *p2, *p1;
+  for(i=0, p1=data, p2=(byte*)x; i < 16; i++, p2 += 4 ) {
+    p2[3] = *p1++;
+    p2[2] = *p1++;
+    p2[1] = *p1++;
+    p2[0] = *p1++;
+  }
+  }
+#else
+  /* this version is better because it is always aligned;
+   * The performance penalty on a 586-100 is about 6% which
+   * is acceptable - because the data is more local it might
+   * also be possible that this is faster on some machines.
+   * This function (when compiled with -02 on gcc 2.7.2)
+   * executes on a 586-100 (39.73 bogomips) at about 1900kb/sec;
+   * [measured with a 4MB data and "gpgm --print-md rmd160"] */
+  u32 x[16];
+  memcpy( x, data, 64 );
+#endif
 
 
 #define K0  0x00000000
index 8dd705d..f2a3d3f 100644 (file)
@@ -194,7 +194,7 @@ gather_random( void (*add)(const void*, size_t, int), int requester,
     }
 
     if( length ) {
-       fprintf( stderr,
+       log_info (
         _("Please wait, entropy is being gathered. Do some work if it would\n"
           "keep you from getting bored, because it will improve the quality\n"
           "of the entropy.\n") );
index 2744878..143c58a 100644 (file)
@@ -120,18 +120,17 @@ gather_random( void (*add)(const void*, size_t, int), int requester,
        tv.tv_sec = 3;
        tv.tv_usec = 0;
        if( !(rc=select(fd+1, &rfds, NULL, NULL, &tv)) ) {
-           #warning FIXME: Replace fprintf by a callback
-           if( !warn )
-               fprintf(stderr,
-_("\n"
-"Not enough random bytes available.  Please do some other work to give\n"
-"the OS a chance to collect more entropy! (Need %d more bytes)\n"),
-                        (int)length );
-           warn = 1;
+          if( !warn )
+            {
+              log_info (_("not enough random bytes available (need %d bytes)\n"),
+                        (int)length);
+              log_info (_("please do some other work to give the OS a chance to collect more entropy\n"));
+            }
+              warn = 1;
            continue;
        }
        else if( rc == -1 ) {
-           fprintf(stderr, "select() error: %s\n", strerror(errno));
+           log_error ("select() error: %s\n", strerror(errno));
            continue;
        }
 
index 0451b2e..b1caf21 100644 (file)
@@ -79,7 +79,7 @@ sha1_init( SHA1_CONTEXT *hd )
 static void
 transform( SHA1_CONTEXT *hd, byte *data )
 {
-    u32 a,b,c,d,e,tm;
+    register u32 a,b,c,d,e,tm;
     u32 x[16];
 
     /* get values from the chaining vars */
index 8cb8c8c..4898b4b 100644 (file)
@@ -604,7 +604,7 @@ do_twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
        initialized = 1;
        selftest_failed = selftest ();
        if( selftest_failed )
-        fprintf(stderr, "%s\n", selftest_failed );
+        log_error("%s\n", selftest_failed );
     }
     if( selftest_failed )
        return GCRYERR_SELFTEST;