X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/e3ac3c05a5af7f36eb895f457e3a627d75a1546b..HEAD:/sshrand.c

diff --git a/sshrand.c b/sshrand.c
index 95c7b492..c26fc757 100644
--- 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,19 +41,58 @@ 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)
+#ifdef RANDOM_DIAGNOSTICS
+int random_diagnostics = 0;
+#endif
+
+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);
 
+#ifdef RANDOM_DIAGNOSTICS
+    {
+        int p, q;
+        printf("random stir starting\npool:\n");
+        for (p = 0; p < POOLSIZE; p += HASHSIZE) {
+            printf("   ");
+            for (q = 0; q < HASHSIZE; q += 4) {
+                printf(" %08x", *(word32 *)(pool.pool + p + q));            
+            }
+            printf("\n");
+        }
+        printf("incoming:\n   ");
+        for (q = 0; q < HASHSIZE; q += 4) {
+            printf(" %08x", *(word32 *)(pool.incoming + q));
+        }
+        printf("\nincomingb:\n   ");
+        for (q = 0; q < HASHINPUT; q += 4) {
+            printf(" %08x", *(word32 *)(pool.incomingb + q));
+        }
+        printf("\n");
+        random_diagnostics++;
+    }
+#endif
+
     SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);
     pool.incomingpos = 0;
 
@@ -100,6 +144,29 @@ void random_stir(void)
 	    for (k = 0; k < sizeof(digest) / sizeof(*digest); k++)
 		((word32 *) (pool.pool + j))[k] = digest[k];
 	}
+
+#ifdef RANDOM_DIAGNOSTICS
+        if (i == 0) {
+            int p, q;
+            printf("random stir midpoint\npool:\n");
+            for (p = 0; p < POOLSIZE; p += HASHSIZE) {
+                printf("   ");
+                for (q = 0; q < HASHSIZE; q += 4) {
+                    printf(" %08x", *(word32 *)(pool.pool + p + q));            
+                }
+                printf("\n");
+            }
+            printf("incoming:\n   ");
+            for (q = 0; q < HASHSIZE; q += 4) {
+                printf(" %08x", *(word32 *)(pool.incoming + q));
+            }
+            printf("\nincomingb:\n   ");
+            for (q = 0; q < HASHINPUT; q += 4) {
+                printf(" %08x", *(word32 *)(pool.incomingb + q));
+            }
+            printf("\n");
+        }
+#endif
     }
 
     /*
@@ -110,6 +177,32 @@ void random_stir(void)
     memcpy(pool.incoming, digest, sizeof(digest));
 
     pool.poolpos = sizeof(pool.incoming);
+
+    pool.stir_pending = FALSE;
+
+#ifdef RANDOM_DIAGNOSTICS
+    {
+        int p, q;
+        printf("random stir done\npool:\n");
+        for (p = 0; p < POOLSIZE; p += HASHSIZE) {
+            printf("   ");
+            for (q = 0; q < HASHSIZE; q += 4) {
+                printf(" %08x", *(word32 *)(pool.pool + p + q));            
+            }
+            printf("\n");
+        }
+        printf("incoming:\n   ");
+        for (q = 0; q < HASHSIZE; q += 4) {
+            printf(" %08x", *(word32 *)(pool.incoming + q));
+        }
+        printf("\nincomingb:\n   ");
+        for (q = 0; q < HASHINPUT; q += 4) {
+            printf(" %08x", *(word32 *)(pool.incomingb + q));
+        }
+        printf("\n");
+        random_diagnostics--;
+    }
+#endif
 }
 
 void random_add_noise(void *noise, int length)
@@ -181,18 +274,44 @@ static void random_add_heavynoise_bitbybit(void *noise, int length)
     pool.poolpos = i;
 }
 
-void random_init(void)
+static void random_timer(void *ctx, unsigned long now)
 {
-    memset(&pool, 0, sizeof(pool));    /* just to start with */
+    if (random_active > 0 && now == next_noise_collection) {
+	noise_regular();
+	next_noise_collection =
+	    schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);
+    }
+}
 
-    random_active = 1;
+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();
+        random_active++;
+
+	noise_get_heavy(random_add_heavynoise_bitbybit);
+	random_stir();
+
+	next_noise_collection =
+	    schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);
+    }
+}
+
+void random_unref(void)
+{
+    assert(random_active > 0);
+    if (random_active == 1) {
+        random_save_seed();
+        expire_timer_context(&pool);
+    }
+    random_active--;
 }
 
 int random_byte(void)
 {
+    assert(random_active);
+
     if (pool.poolpos >= POOLSIZE)
 	random_stir();
 
@@ -201,7 +320,7 @@ int random_byte(void)
 
 void random_get_savedata(void **data, int *len)
 {
-    void *buf = smalloc(POOLSIZE / 2);
+    void *buf = snewn(POOLSIZE / 2, char);
     random_stir();
     memcpy(buf, pool.pool + pool.poolpos, POOLSIZE / 2);
     *len = POOLSIZE / 2;