Remove a return path from sshcom_write() which was both unreachable

[u/mdw/putty] / sshrand.c

diff --git a/sshrand.c b/sshrand.c
index 84c3e91..4c33f4a 100644 (file)
--- a/sshrand.c
+++ b/sshrand.c
@@ -2,7 +2,12 @@
  * cryptographic random number generator for PuTTY's ssh client
  */
 
+#include "putty.h"
 #include "ssh.h"
+#include <assert.h>
+
+/* Collect environmental noise every 5 minutes */
+#define NOISE_REGULAR_INTERVAL (5*60*TICKSPERSEC)
 
 void noise_get_heavy(void (*func) (void *, int));
 void noise_get_light(void (*func) (void *, int));
@@ -36,18 +41,31 @@ struct RandPool {
 
     unsigned char incomingb[HASHINPUT];
     int incomingpos;
+
+    int stir_pending;
 };
 
 static struct RandPool pool;
+int random_active = 0;
+long next_noise_collection;
 
-void random_stir(void) {
-    word32 block[HASHINPUT/sizeof(word32)];
-    word32 digest[HASHSIZE/sizeof(word32)];
+static void random_stir(void)
+{
+    word32 block[HASHINPUT / sizeof(word32)];
+    word32 digest[HASHSIZE / sizeof(word32)];
     int i, j, k;
 
+    /*
+     * noise_get_light will call random_add_noise, which may call
+     * back to here. Prevent recursive stirs.
+     */
+    if (pool.stir_pending)
+       return;
+    pool.stir_pending = TRUE;
+
     noise_get_light(random_add_noise);
 
-    SHATransform((word32 *)pool.incoming, (word32 *)pool.incomingb);
+    SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);
     pool.incomingpos = 0;
 
     /*
@@ -76,14 +94,14 @@ void random_stir(void) {
         * things will be that much less predictable that way
         * round, when we subsequently return bytes ...
         */
-       for (j = POOLSIZE; (j -= HASHSIZE) >= 0 ;) {
+       for (j = POOLSIZE; (j -= HASHSIZE) >= 0;) {
            /*
             * XOR the bit of the pool we're processing into the
             * digest.
             */
 
-           for (k = 0; k < sizeof(digest)/sizeof(*digest); k++)
-               digest[k] ^= ((word32 *)(pool.pool+j))[k];
+           for (k = 0; k < sizeof(digest) / sizeof(*digest); k++)
+               digest[k] ^= ((word32 *) (pool.pool + j))[k];
 
            /*
             * Munge our unrevealed first block of the pool into
@@ -95,8 +113,8 @@ void random_stir(void) {
             * Stick the result back into the pool.
             */
 
-           for (k = 0; k < sizeof(digest)/sizeof(*digest); k++)
-               ((word32 *)(pool.pool+j))[k] = digest[k];
+           for (k = 0; k < sizeof(digest) / sizeof(*digest); k++)
+               ((word32 *) (pool.pool + j))[k] = digest[k];
        }
     }
 
@@ -108,12 +126,18 @@ void random_stir(void) {
     memcpy(pool.incoming, digest, sizeof(digest));
 
     pool.poolpos = sizeof(pool.incoming);
+
+    pool.stir_pending = FALSE;
 }
 
-void random_add_noise(void *noise, int length) {
+void random_add_noise(void *noise, int length)
+{
     unsigned char *p = noise;
     int i;
 
+    if (!random_active)
+       return;
+
     /*
      * This function processes HASHINPUT bytes into only HASHSIZE
      * bytes, so _if_ we were getting incredibly high entropy
@@ -124,14 +148,14 @@ void random_add_noise(void *noise, int length) {
               HASHINPUT - pool.incomingpos);
        p += HASHINPUT - pool.incomingpos;
        length -= HASHINPUT - pool.incomingpos;
-       SHATransform((word32 *)pool.incoming, (word32 *)pool.incomingb);
-        for (i = 0; i < HASHSIZE; i++) {
-            pool.pool[pool.poolpos++] ^= pool.incomingb[i];
-            if (pool.poolpos >= POOLSIZE)
-                pool.poolpos = 0;
-        }
-        if (pool.poolpos < HASHSIZE)
-            random_stir();
+       SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);
+       for (i = 0; i < HASHSIZE; i++) {
+           pool.pool[pool.poolpos++] ^= pool.incomingb[i];
+           if (pool.poolpos >= POOLSIZE)
+               pool.poolpos = 0;
+       }
+       if (pool.poolpos < HASHSIZE)
+           random_stir();
 
        pool.incomingpos = 0;
     }
@@ -140,54 +164,88 @@ void random_add_noise(void *noise, int length) {
     pool.incomingpos += length;
 }
 
-void random_add_heavynoise(void *noise, int length) {
+void random_add_heavynoise(void *noise, int length)
+{
     unsigned char *p = noise;
     int i;
 
     while (length >= POOLSIZE) {
-        for (i = 0; i < POOLSIZE; i++)
-            pool.pool[i] ^= *p++;
+       for (i = 0; i < POOLSIZE; i++)
+           pool.pool[i] ^= *p++;
        random_stir();
        length -= POOLSIZE;
     }
 
     for (i = 0; i < length; i++)
-        pool.pool[i] ^= *p++;
+       pool.pool[i] ^= *p++;
     random_stir();
 }
 
-static void random_add_heavynoise_bitbybit(void *noise, int length) {
+static void random_add_heavynoise_bitbybit(void *noise, int length)
+{
     unsigned char *p = noise;
     int i;
 
     while (length >= POOLSIZE - pool.poolpos) {
-        for (i = 0; i < POOLSIZE - pool.poolpos; i++)
-            pool.pool[pool.poolpos + i] ^= *p++;
+       for (i = 0; i < POOLSIZE - pool.poolpos; i++)
+           pool.pool[pool.poolpos + i] ^= *p++;
        random_stir();
        length -= POOLSIZE - pool.poolpos;
-        pool.poolpos = 0;
+       pool.poolpos = 0;
     }
 
     for (i = 0; i < length; i++)
-        pool.pool[i] ^= *p++;
+       pool.pool[i] ^= *p++;
     pool.poolpos = i;
 }
 
-void random_init(void) {
-    memset(&pool, 0, sizeof(pool));    /* just to start with */
+static void random_timer(void *ctx, unsigned long now)
+{
+    if (random_active > 0 && now == next_noise_collection) {
+       noise_regular();
+       next_noise_collection =
+           schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);
+    }
+}
 
-    noise_get_heavy(random_add_heavynoise_bitbybit);
+void random_ref(void)
+{
+    if (!random_active) {
+       memset(&pool, 0, sizeof(pool));    /* just to start with */
+
+       noise_get_heavy(random_add_heavynoise_bitbybit);
+       random_stir();
+
+       next_noise_collection =
+           schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);
+    }
+
+    random_active++;
 }
 
-int random_byte(void) {
+void random_unref(void)
+{
+    random_active--;
+    assert(random_active >= 0);
+    if (random_active) return;
+
+    expire_timer_context(&pool);
+}
+
+int random_byte(void)
+{
     if (pool.poolpos >= POOLSIZE)
        random_stir();
 
     return pool.pool[pool.poolpos++];
 }
 
-void random_get_savedata(void **data, int *len) {
+void random_get_savedata(void **data, int *len)
+{
+    void *buf = snewn(POOLSIZE / 2, char);
+    random_stir();
+    memcpy(buf, pool.pool + pool.poolpos, POOLSIZE / 2);
+    *len = POOLSIZE / 2;
+    *data = buf;
     random_stir();
-    *data = pool.pool+pool.poolpos;
-    *len = POOLSIZE/2;
 }