st.c: seed st hash from random.c

Main Murmur weakness is permutation of a block without seed.
Just adding a random seed to each block and finalization we
greatly increase security of Murmur.

Author: funny-falcon

include/ruby/intern.h

@@ -763,6 +763,7 @@ st_index_t rb_hash_start(st_index_t);
 st_index_t rb_hash_uint32(st_index_t, uint32_t);
 st_index_t rb_hash_uint(st_index_t, st_index_t);
 st_index_t rb_hash_end(st_index_t);
+#define rb_hash_start(h) st_hash_start((h))
 #define rb_hash_uint32(h, i) st_hash_uint32((h), (i))
 #define rb_hash_uint(h, i) st_hash_uint((h), (i))
 #define rb_hash_end(h) st_hash_end(h)

include/ruby/st.h

@@ -143,7 +143,8 @@ CONSTFUNC(st_index_t st_hash_uint32(st_index_t h, uint32_t i));
 CONSTFUNC(st_index_t st_hash_uint(st_index_t h, st_index_t i));
 CONSTFUNC(st_index_t st_hash_end(st_index_t h));
 CONSTFUNC(st_index_t st_hash_start(st_index_t h));
-#define st_hash_start(h) ((st_index_t)(h))
+void st_hash_seed(st_index_t seed[2]); /* init global seed */
+
 
 RUBY_SYMBOL_EXPORT_END
 

random.c

@@ -1473,7 +1473,6 @@ random_s_rand(int argc, VALUE *argv, VALUE obj)
 #endif
 #include "siphash.c"
 
-static st_index_t hashseed;
 typedef uint8_t sipseed_keys_t[16];
 static union {
     sipseed_keys_t key;
@@ -1483,19 +1482,16 @@ static union {
 static void
 init_hashseed(struct MT *mt)
 {
-    hashseed = genrand_int32(mt);
-#if SIZEOF_ST_INDEX_T*CHAR_BIT > 4*8
-    hashseed <<= 32;
-    hashseed |= genrand_int32(mt);
-#endif
-#if SIZEOF_ST_INDEX_T*CHAR_BIT > 8*8
-    hashseed <<= 32;
-    hashseed |= genrand_int32(mt);
-#endif
-#if SIZEOF_ST_INDEX_T*CHAR_BIT > 12*8
-    hashseed <<= 32;
-    hashseed |= genrand_int32(mt);
-#endif
+    st_index_t hashseed[2];
+    int i,b;
+    for (i = 0; i < 2; i++) {
+	hashseed[i] = genrand_int32(mt);
+	for (b = ST_INDEX_BITS - 32; b > 0; b -= 32) {
+	    hashseed[i] <<= 32;
+	    hashseed[i] |= genrand_int32(mt);
+	}
+    }
+    st_hash_seed(hashseed);
 }
 
 static void
@@ -1507,12 +1503,6 @@ init_siphash(struct MT *mt)
 	sipseed.u32[i] = genrand_int32(mt);
 }
 
-st_index_t
-rb_hash_start(st_index_t h)
-{
-    return st_hash_start(hashseed + h);
-}
-
 st_index_t
 rb_memhash(const void *ptr, long len)
 {

st.c

@@ -1281,6 +1281,17 @@ st_reverse_foreach(st_table *table, int (*func)(ANYARGS), st_data_t arg)
 }
 #endif
 
+static st_index_t st_seed[2];
+static int st_need_seed = 1;
+void
+st_hash_seed(st_index_t seed[2])
+{
+    assert(st_need_seed);
+    st_seed[0] = seed[0];
+    st_seed[1] = seed[1];
+    st_need_seed = 0;
+}
+
 #define FNV1_32A_INIT 0x811c9dc5
 
 /*
@@ -1320,13 +1331,14 @@ murmur_step(st_index_t h, st_index_t k)
     const st_index_t c1 = BIG_CONSTANT(0x87c37b91,0x114253d5);
     const st_index_t c2 = BIG_CONSTANT(0x4cf5ad43,0x2745937f);
 #endif
+    k ^= st_seed[0];
     k *= c1;
     k = ROTL(k, r1);
     k *= c2;
 
     h *= c1;
     h = ROTL(h, r2);
-    h ^= k;
+    h ^= k + st_seed[1];
     return h;
 #undef r1
 #undef r2
@@ -1349,6 +1361,7 @@ murmur_finish(st_index_t h)
     const st_index_t c1 = BIG_CONSTANT(0xbf58476d,0x1ce4e5b9);
     const st_index_t c2 = BIG_CONSTANT(0x94d049bb,0x133111eb);
 #endif
+    h ^= st_seed[0];
     h ^= h >> r1;
     h *= c1;
     h ^= h >> r2;
@@ -1360,7 +1373,7 @@ murmur_finish(st_index_t h)
     h *= c2;
     h ^= h >> r3;
 #endif
-    return h;
+    return h ^ st_seed[1];
 }
 
 st_index_t
@@ -1369,6 +1382,7 @@ st_hash(const void *ptr, size_t len, st_index_t h)
     const char *data = ptr;
     st_index_t t = 0;
     size_t l = len;
+    assert(!st_need_seed);
 
 #define data_at(n) (st_index_t)((unsigned char)data[(n)])
 #define UNALIGNED_ADD_4 UNALIGNED_ADD(2); UNALIGNED_ADD(1); UNALIGNED_ADD(0)
@@ -1509,18 +1523,17 @@ st_hash_end(st_index_t h)
     return h;
 }
 
-#undef st_hash_start
 st_index_t
 st_hash_start(st_index_t h)
 {
-    return h;
+    return h + st_seed[1];
 }
 
 static st_index_t
 strhash(st_data_t arg)
 {
     register const char *string = (const char *)arg;
-    return st_hash(string, strlen(string), FNV1_32A_INIT);
+    return st_hash(string, strlen(string), st_seed[1]);
 }
 
 int