/*----- Header files ------------------------------------------------------*/
+#include "config.h"
+
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <mLib/sub.h>
#include "arena.h"
+#include "dispatch.h"
#include "paranoia.h"
#define RAND__HACKS
if (r->gen != gen) { r->gen = gen; rand_gate(r); } \
} while (0)
-#define TIMER(r) do { \
- if ((r)->s && (r)->s->timer) \
- (r)->s->timer(r); \
+static int quick(rand_pool *);
+#define QUICK(r) do { \
+ quick(r); \
+ if ((r)->s && (r)->s->timer) (r)->s->timer(r); \
} while (0)
/*----- Main code ---------------------------------------------------------*/
r->s = s;
}
+/* --- @rand_quick@ --- *
+ *
+ * Arguments: @rand_pool *r@ = pointer to a randomness pool
+ *
+ * Returns: Zero on success; @-1@ on failure.
+ *
+ * Use Attempts to use some machine-specific `quick' source of
+ * entropy to top up @r@. This may not do anything at all on
+ * many systems.
+ */
+
+CPU_DISPATCH(static, return, int, quick, (rand_pool *r), (r),
+ pick_quick, trivial_quick);
+
+static int trivial_quick(rand_pool *r) { return (-1); }
+
+#if CPUFAM_X86 || CPUFAM_AMD64
+extern int rand_quick_x86ish_rdrand(rand_pool */*r*/);
+extern int rand_quick_x86ish_rdseed(rand_pool */*r*/);
+#endif
+
+static quick__functype *pick_quick(void)
+{
+#if CPUFAM_X86 || CPUFAM_AMD64
+ DISPATCH_PICK_COND(rand_quick, rand_quick_x86ish_rdseed,
+ cpu_feature_p(CPUFEAT_X86_RDSEED));
+ DISPATCH_PICK_COND(rand_quick, rand_quick_x86ish_rdrand,
+ cpu_feature_p(CPUFEAT_X86_RDRAND));
+#endif
+ DISPATCH_PICK_FALLBACK(rand_quick, trivial_quick);
+}
+
+int rand_quick(rand_pool *r) { RAND_RESOLVE(r); return (quick(r)); }
+
/* --- @rand_seed@ --- *
*
* Arguments: @rand_pool *r@ = pointer to a randomness pool
const octet *c = p;
int i, rot;
-#if RAND_POOLSZ != 128
-# error Polynomial in rand_add is out of date. Fix it.
-#endif
+ STATIC_ASSERT(RAND_POOLSZ == 128, "Polynomial doesn't match pool size");
RAND_RESOLVE(r);
HASH_CTX hc;
CIPHER_CTX cc;
+ STATIC_ASSERT(CIPHER_KEYSZ <= HASH_SZ, "rand cipher keysize too long");
+
RAND_RESOLVE(r);
- TIMER(r);
+ QUICK(r);
/* --- Hash up all the data in the pool --- */
HASH_INIT(&hc);
STORE32(g, r->gen); HASH(&hc, g, sizeof(g));
+ HASH(&hc, r->k.k, RAND_KEYSZ);
HASH(&hc, r->pool, RAND_POOLSZ);
HASH(&hc, r->buf, RAND_BUFSZ);
HASH_DONE(&hc, h);
/* --- Now mangle all of the data based on the hash --- */
- assert(CIPHER_KEYSZ <= HASH_SZ);
CIPHER_INIT(&cc, h, CIPHER_KEYSZ, 0);
CIPHER_ENCRYPT(&cc, r->pool, r->pool, RAND_POOLSZ);
CIPHER_ENCRYPT(&cc, r->buf, r->buf, RAND_BUFSZ);
r->o = RAND_SECSZ;
r->obits += r->ibits;
if (r->obits > RAND_OBITS) {
- r->ibits = r->obits - r->ibits;
+ r->ibits = r->obits - RAND_OBITS;
r->obits = RAND_OBITS;
} else
r->ibits = 0;
- TIMER(r);
+ QUICK(r);
}
/* --- @rand_stretch@ --- *
HASH_CTX hc;
CIPHER_CTX cc;
+ STATIC_ASSERT(CIPHER_KEYSZ <= HASH_SZ, "rand cipher keysize too long");
+
RAND_RESOLVE(r);
- TIMER(r);
+ QUICK(r);
/* --- Hash up all the data in the buffer --- */
HASH_INIT(&hc);
STORE32(g, r->gen); HASH(&hc, g, sizeof(g));
+ HASH(&hc, r->k.k, RAND_KEYSZ);
HASH(&hc, r->pool, RAND_POOLSZ);
HASH(&hc, r->buf, RAND_BUFSZ);
HASH_DONE(&hc, h);
/* --- Now mangle the buffer based on the hash --- */
- assert(CIPHER_KEYSZ <= HASH_SZ);
CIPHER_INIT(&cc, h, CIPHER_KEYSZ, 0);
CIPHER_ENCRYPT(&cc, r->buf, r->buf, RAND_BUFSZ);
BURN(cc);
/* --- Reset the various state variables --- */
r->o = RAND_SECSZ;
- TIMER(r);
+ QUICK(r);
}
/* --- @rand_get@ --- *
RAND_RESOLVE(r);
GENCHECK(r);
- TIMER(r);
+ QUICK(r);
if (!sz)
return;
for (;;) {
- if (r->o + sz <= RAND_BUFSZ) {
+ if (sz <= RAND_BUFSZ - r->o) {
memcpy(o, r->buf + r->o, sz);
r->o += sz;
break;
}
}
- if (r->obits > sz * 8)
- r->obits -= sz * 8;
+ if (r->obits > 8*sz)
+ r->obits -= 8*sz;
else
r->obits = 0;
}
return;
}
GENCHECK(r);
- TIMER(r);
+ QUICK(r);
while (sz) {
size_t chunk = sz;
- if (chunk * 8 > r->obits) {
- if (chunk * 8 > r->ibits + r->obits)
+ if (8*chunk > r->obits) {
+ if (8*chunk > r->ibits + r->obits)
do r->s->getnoise(r); while (r->ibits + r->obits < 256);
rand_gate(r);
- if (chunk * 8 > r->obits)
- chunk = r->obits / 8;
+ if (8*chunk > r->obits)
+ chunk = r->obits/8;
}
- if (chunk + r->o > RAND_BUFSZ)
+ if (chunk <= RAND_BUFSZ - r->o) {
+ memcpy(o, r->buf + r->o, chunk);
+ r->o += chunk;
+ } else {
chunk = RAND_BUFSZ - r->o;
+ memcpy(o, r->buf + r->o, chunk);
+ rand_stretch(r);
+ }
- memcpy(o, r->buf + r->o, chunk);
- r->o += chunk;
- r->obits -= chunk * 8;
+ r->obits -= 8*chunk;
o += chunk;
sz -= chunk;
}
rand_seed(&g->p, va_arg(ap, unsigned));
break;
case RAND_TIMER:
- TIMER(&g->p);
+ QUICK(&g->p);
break;
case RAND_GOODBITS:
rc = rand_goodbits(&g->p);