randombytes_* -> hydro_random_*

hydrogen.h

@@ -26,20 +26,20 @@ int hydro_init(void);
 
 /* ---------------- */
 
-#define randombytes_SEEDBYTES 32
+#define hydro_random_SEEDBYTES 32
 
-uint32_t randombytes_random(void);
+uint32_t hydro_random_random(void);
 
-uint32_t randombytes_uniform(const uint32_t upper_bound);
+uint32_t hydro_random_uniform(const uint32_t upper_bound);
 
-void randombytes_buf(void *out, size_t out_len);
+void hydro_random_buf(void *out, size_t out_len);
 
-void randombytes_buf_deterministic(void *out, size_t out_len,
-                                   const uint8_t seed[randombytes_SEEDBYTES]);
+void hydro_random_buf_deterministic(void *out, size_t out_len,
+                                    const uint8_t seed[hydro_random_SEEDBYTES]);
 
-void randombytes_ratchet(void);
+void hydro_random_ratchet(void);
 
-void randombytes_reseed(void);
+void hydro_random_reseed(void);
 
 /* ---------------- */
 

impl/hash.h

@@ -134,5 +134,5 @@ hydro_hash_hash(uint8_t *out, size_t out_len, const void *in_, size_t in_len,
 void
 hydro_hash_keygen(uint8_t key[hydro_hash_KEYBYTES])
 {
-    randombytes_buf(key, hydro_hash_KEYBYTES);
+    hydro_random_buf(key, hydro_hash_KEYBYTES);
 }

impl/kdf.h

@@ -16,5 +16,5 @@ hydro_kdf_derive_from_key(uint8_t *subkey, size_t subkey_len, uint64_t subkey_id
 void
 hydro_kdf_keygen(uint8_t key[hydro_kdf_KEYBYTES])
 {
-    randombytes_buf(key, hydro_kdf_KEYBYTES);
+    hydro_random_buf(key, hydro_kdf_KEYBYTES);
 }

impl/kx.h

@@ -8,7 +8,7 @@
 void
 hydro_kx_keygen(hydro_kx_keypair *static_kp)
 {
-    randombytes_buf(static_kp->sk, hydro_kx_SECRETKEYBYTES);
+    hydro_random_buf(static_kp->sk, hydro_kx_SECRETKEYBYTES);
     if (hydro_x25519_scalarmult_base(static_kp->pk, static_kp->sk) != 0) {
         abort();
     }
@@ -17,8 +17,8 @@ hydro_kx_keygen(hydro_kx_keypair *static_kp)
 void
 hydro_kx_keygen_deterministic(hydro_kx_keypair *static_kp, const uint8_t seed[hydro_kx_SEEDBYTES])
 {
-    COMPILER_ASSERT(hydro_kx_SEEDBYTES >= randombytes_SEEDBYTES);
-    randombytes_buf_deterministic(static_kp->sk, hydro_kx_SECRETKEYBYTES, seed);
+    COMPILER_ASSERT(hydro_kx_SEEDBYTES >= hydro_random_SEEDBYTES);
+    hydro_random_buf_deterministic(static_kp->sk, hydro_kx_SECRETKEYBYTES, seed);
     if (hydro_x25519_scalarmult_base(static_kp->pk, static_kp->sk) != 0) {
         abort();
     }

impl/pwhash.h

@@ -13,7 +13,7 @@
 #define hydro_pwhash_CONTEXT "hydro_pw"
 
 static int
-_hydro_pwhash_hash(uint8_t out[randombytes_SEEDBYTES], size_t h_len,
+_hydro_pwhash_hash(uint8_t out[hydro_random_SEEDBYTES], size_t h_len,
                    const uint8_t salt[hydro_pwhash_SALTBYTES], const char *passwd,
                    size_t passwd_len, const char ctx[hydro_pwhash_CONTEXTBYTES],
                    const uint8_t master_key[hydro_pwhash_MASTERKEYBYTES], uint64_t opslimit,
@@ -56,8 +56,8 @@ _hydro_pwhash_hash(uint8_t out[randombytes_SEEDBYTES], size_t h_len,
     }
     mem_zero(state, gimli_RATE);
 
-    COMPILER_ASSERT(randombytes_SEEDBYTES == gimli_CAPACITY);
-    memcpy(out, state + gimli_RATE, randombytes_SEEDBYTES);
+    COMPILER_ASSERT(hydro_random_SEEDBYTES == gimli_CAPACITY);
+    memcpy(out, state + gimli_RATE, hydro_random_SEEDBYTES);
     hydro_memzero(state, sizeof state);
 
     return 0;
@@ -66,7 +66,7 @@ _hydro_pwhash_hash(uint8_t out[randombytes_SEEDBYTES], size_t h_len,
 void
 hydro_pwhash_keygen(uint8_t master_key[hydro_pwhash_MASTERKEYBYTES])
 {
-    randombytes_buf(master_key, hydro_pwhash_MASTERKEYBYTES);
+    hydro_random_buf(master_key, hydro_pwhash_MASTERKEYBYTES);
 }
 
 int
@@ -75,7 +75,7 @@ hydro_pwhash_deterministic(uint8_t *h, size_t h_len, const char *passwd, size_t
                            const uint8_t master_key[hydro_pwhash_MASTERKEYBYTES], uint64_t opslimit,
                            size_t memlimit, uint8_t threads)
 {
-    uint8_t seed[randombytes_SEEDBYTES];
+    uint8_t seed[hydro_random_SEEDBYTES];
 
     COMPILER_ASSERT(sizeof zero >= hydro_pwhash_SALTBYTES);
     COMPILER_ASSERT(sizeof zero >= hydro_pwhash_MASTERKEYBYTES);
@@ -85,7 +85,7 @@ hydro_pwhash_deterministic(uint8_t *h, size_t h_len, const char *passwd, size_t
                            memlimit, threads) != 0) {
         return -1;
     }
-    randombytes_buf_deterministic(h, h_len, seed);
+    hydro_random_buf_deterministic(h, h_len, seed);
     hydro_memzero(seed, sizeof seed);
 
     return 0;
@@ -115,7 +115,7 @@ hydro_pwhash_create(uint8_t stored[hydro_pwhash_STOREDBYTES], const char *passwd
     *threads_u8 = threads;
     STORE64_LE(opslimit_u8, opslimit);
     STORE64_LE(memlimit_u8, (uint64_t) memlimit);
-    randombytes_buf(salt, hydro_pwhash_SALTBYTES);
+    hydro_random_buf(salt, hydro_pwhash_SALTBYTES);
 
     COMPILER_ASSERT(sizeof zero >= hydro_pwhash_MASTERKEYBYTES);
     if (_hydro_pwhash_hash(h, hydro_pwhash_HASHBYTES, salt, passwd, passwd_len,
@@ -263,15 +263,15 @@ hydro_pwhash_upgrade(uint8_t       stored[hydro_pwhash_STOREDBYTES],
         mem_zero(stored, hydro_pwhash_STOREDBYTES);
         return -1;
     }
-    COMPILER_ASSERT(randombytes_SEEDBYTES == gimli_CAPACITY);
-    memcpy(state + gimli_RATE, h, randombytes_SEEDBYTES);
+    COMPILER_ASSERT(hydro_random_SEEDBYTES == gimli_CAPACITY);
+    memcpy(state + gimli_RATE, h, hydro_random_SEEDBYTES);
     for (i = opslimit_prev; i < opslimit; i++) {
         mem_zero(state, gimli_RATE);
         STORE64_LE(state, i);
         gimli_core_u8(state, 0);
     }
     mem_zero(state, gimli_RATE);
-    memcpy(h, state + gimli_RATE, randombytes_SEEDBYTES);
+    memcpy(h, state + gimli_RATE, hydro_random_SEEDBYTES);
     *threads_u8 = threads;
     STORE64_LE(opslimit_u8, opslimit);
     STORE64_LE(memlimit_u8, (uint64_t) memlimit);

impl/random.h

@@ -187,13 +187,13 @@ hydro_random_check_initialized(void)
             abort();
         }
         gimli_core_u8(hydro_random_context.state, 0);
-        randombytes_ratchet();
+        hydro_random_ratchet();
         hydro_random_context.initialized = 1;
     }
 }
 
 void
-randombytes_ratchet(void)
+hydro_random_ratchet(void)
 {
     mem_zero(hydro_random_context.state, gimli_RATE);
     STORE64_LE(hydro_random_context.state, hydro_random_context.counter);
@@ -203,13 +203,13 @@ randombytes_ratchet(void)
 }
 
 uint32_t
-randombytes_random(void)
+hydro_random_random(void)
 {
     uint32_t v;
 
     hydro_random_check_initialized();
     if (hydro_random_context.available < 4) {
-        randombytes_ratchet();
+        hydro_random_ratchet();
     }
     memcpy(&v, &hydro_random_context.state[gimli_RATE - hydro_random_context.available], 4);
     hydro_random_context.available -= 4;
@@ -218,7 +218,7 @@ randombytes_random(void)
 }
 
 uint32_t
-randombytes_uniform(const uint32_t upper_bound)
+hydro_random_uniform(const uint32_t upper_bound)
 {
     uint32_t min;
     uint32_t r;
@@ -228,7 +228,7 @@ randombytes_uniform(const uint32_t upper_bound)
     }
     min = (1U + ~upper_bound) % upper_bound; /* = 2**32 mod upper_bound */
     do {
-        r = randombytes_random();
+        r = hydro_random_random();
     } while (r < min);
     /* r is now clamped to a set whose size mod upper_bound == 0
      * the worst case (2**31+1) requires 2 attempts on average */
@@ -237,7 +237,7 @@ randombytes_uniform(const uint32_t upper_bound)
 }
 
 void
-randombytes_buf(void *out, size_t out_len)
+hydro_random_buf(void *out, size_t out_len)
 {
     uint8_t *p = (uint8_t *) out;
     size_t   i;
@@ -252,11 +252,11 @@ randombytes_buf(void *out, size_t out_len)
         gimli_core_u8(hydro_random_context.state, 0);
         mem_cpy(p + i * gimli_RATE, hydro_random_context.state, leftover);
     }
-    randombytes_ratchet();
+    hydro_random_ratchet();
 }
 
 void
-randombytes_buf_deterministic(void *out, size_t out_len, const uint8_t seed[randombytes_SEEDBYTES])
+hydro_random_buf_deterministic(void *out, size_t out_len, const uint8_t seed[hydro_random_SEEDBYTES])
 {
     static const uint8_t     prefix[] = { 7, 'd', 'r', 'b', 'g', '2', '5', '6' };
     CRYPTO_ALIGN(16) uint8_t state[gimli_BLOCKBYTES];
@@ -269,7 +269,7 @@ randombytes_buf_deterministic(void *out, size_t out_len, const uint8_t seed[rand
     memcpy(state, prefix, sizeof prefix);
     STORE64_LE(state + sizeof prefix, (uint64_t) out_len);
     gimli_core_u8(state, 1);
-    COMPILER_ASSERT(randombytes_SEEDBYTES == gimli_RATE * 2);
+    COMPILER_ASSERT(hydro_random_SEEDBYTES == gimli_RATE * 2);
     mem_xor(state, seed, gimli_RATE);
     gimli_core_u8(state, 2);
     mem_xor(state, seed + gimli_RATE, gimli_RATE);
@@ -283,11 +283,11 @@ randombytes_buf_deterministic(void *out, size_t out_len, const uint8_t seed[rand
         gimli_core_u8(state, 0);
         mem_cpy(p + i * gimli_RATE, state, leftover);
     }
-    randombytes_ratchet();
+    hydro_random_ratchet();
 }
 
 void
-randombytes_reseed(void)
+hydro_random_reseed(void)
 {
     hydro_random_context.initialized = 0;
     hydro_random_check_initialized();

impl/secretbox.h

@@ -5,7 +5,7 @@
 void
 hydro_secretbox_keygen(uint8_t key[hydro_secretbox_KEYBYTES])
 {
-    randombytes_buf(key, hydro_secretbox_KEYBYTES);
+    hydro_random_buf(key, hydro_secretbox_KEYBYTES);
 }
 
 static void
@@ -190,7 +190,7 @@ hydro_secretbox_encrypt(uint8_t *c, const void *m_, size_t mlen, uint64_t msg_id
 {
     uint8_t iv[hydro_secretbox_IVBYTES];
 
-    randombytes_buf(iv, sizeof iv);
+    hydro_random_buf(iv, sizeof iv);
 
     return hydro_secretbox_encrypt_iv(c, m_, mlen, msg_id, ctx, key, iv);
 }

impl/sign.h

@@ -44,7 +44,7 @@ hydro_sign_prehash(uint8_t csig[hydro_sign_BYTES], const uint8_t prehash[hydro_s
     uint8_t *        sig    = &csig[hydro_sign_NONCEBYTES];
     uint8_t *        eph_sk = sig;
 
-    randombytes_buf(eph_sk, hydro_x25519_SECRETKEYBYTES);
+    hydro_random_buf(eph_sk, hydro_x25519_SECRETKEYBYTES);
     COMPILER_ASSERT(hydro_x25519_SECRETKEYBYTES == hydro_hash_KEYBYTES);
     hydro_hash_init(&st, (const char *) zero, sk);
     hydro_hash_update(&st, eph_sk, hydro_x25519_SECRETKEYBYTES);
@@ -125,7 +125,7 @@ hydro_sign_keygen(hydro_sign_keypair *kp)
     COMPILER_ASSERT(hydro_sign_SECRETKEYBYTES ==
                     hydro_x25519_SECRETKEYBYTES + hydro_x25519_PUBLICKEYBYTES);
     COMPILER_ASSERT(hydro_sign_PUBLICKEYBYTES == hydro_x25519_PUBLICKEYBYTES);
-    randombytes_buf(kp->sk, hydro_x25519_SECRETKEYBYTES);
+    hydro_random_buf(kp->sk, hydro_x25519_SECRETKEYBYTES);
     hydro_x25519_scalarmult_base_uniform(kp->pk, kp->sk);
     memcpy(pk_copy, kp->pk, hydro_x25519_PUBLICKEYBYTES);
 }
@@ -135,8 +135,8 @@ hydro_sign_keygen_deterministic(hydro_sign_keypair *kp, const uint8_t seed[hydro
 {
     uint8_t *pk_copy = &kp->sk[hydro_x25519_SECRETKEYBYTES];
 
-    COMPILER_ASSERT(hydro_sign_SEEDBYTES >= randombytes_SEEDBYTES);
-    randombytes_buf_deterministic(kp->sk, hydro_x25519_SECRETKEYBYTES, seed);
+    COMPILER_ASSERT(hydro_sign_SEEDBYTES >= hydro_random_SEEDBYTES);
+    hydro_random_buf_deterministic(kp->sk, hydro_x25519_SECRETKEYBYTES, seed);
     hydro_x25519_scalarmult_base_uniform(kp->pk, kp->sk);
     memcpy(pk_copy, kp->pk, hydro_x25519_PUBLICKEYBYTES);
 }

tests/tests.c

@@ -20,7 +20,7 @@ streq(const char *expected, const char *found)
 static void
 test_randombytes(void)
 {
-    uint8_t       dk[randombytes_SEEDBYTES];
+    uint8_t       dk[hydro_random_SEEDBYTES];
     uint8_t       tmp[10000];
     unsigned long b = 0U;
     unsigned long bp;
@@ -28,7 +28,7 @@ test_randombytes(void)
     size_t        i, j;
 
     for (i = 0; i < 10000; i++) {
-        x = randombytes_random();
+        x = hydro_random_random();
         for (j = 0; j < sizeof x; j++) {
             b += (x >> j) & 1;
         }
@@ -36,7 +36,7 @@ test_randombytes(void)
     assert(b > 18000 && b < 22000);
 
     b = 0;
-    randombytes_buf(tmp, sizeof tmp);
+    hydro_random_buf(tmp, sizeof tmp);
     for (i = 0; i < 10000; i++) {
         for (j = 0; j < sizeof tmp[0]; j++) {
             b += (tmp[i] >> j) & 1;
@@ -46,7 +46,7 @@ test_randombytes(void)
 
     memcpy(dk, tmp, sizeof dk);
     b = 0;
-    randombytes_buf_deterministic(tmp, 10000, dk);
+    hydro_random_buf_deterministic(tmp, 10000, dk);
     for (i = 0; i < 10000; i++) {
         for (j = 0; j < sizeof tmp[0]; j++) {
             b += (tmp[i] >> j) & 1;
@@ -55,7 +55,7 @@ test_randombytes(void)
     assert(b > 4500 && b < 5500);
     bp = b;
     b  = 0;
-    randombytes_buf_deterministic(tmp, 10000, dk);
+    hydro_random_buf_deterministic(tmp, 10000, dk);
     for (i = 0; i < 10000; i++) {
         for (j = 0; j < sizeof tmp[0]; j++) {
             b += (tmp[i] >> j) & 1;
@@ -65,7 +65,7 @@ test_randombytes(void)
 
     for (i = 0; i < 1000; i++) {
         for (j = 1; j < 100; j++) {
-            x = randombytes_uniform((uint32_t) j);
+            x = hydro_random_uniform((uint32_t) j);
             assert(x < j);
         }
     }
@@ -75,7 +75,7 @@ static void
 test_hash(void)
 {
     hydro_hash_state st;
-    uint8_t          dk[randombytes_SEEDBYTES];
+    uint8_t          dk[hydro_random_SEEDBYTES];
     uint8_t          h[100];
     uint8_t          key[hydro_hash_KEYBYTES];
     uint8_t          msg[1000];
@@ -83,11 +83,11 @@ test_hash(void)
     size_t           i;
 
     memset(dk, 0, sizeof dk);
-    randombytes_buf_deterministic(key, sizeof key, dk);
+    hydro_random_buf_deterministic(key, sizeof key, dk);
     hydro_increment(dk, sizeof dk);
     hydro_hash_init(&st, ctx, key);
     for (i = 0; i <= sizeof msg; i++) {
-        randombytes_buf_deterministic(msg, i, dk);
+        hydro_random_buf_deterministic(msg, i, dk);
         hydro_increment(dk, sizeof dk);
         hydro_hash_update(&st, msg, i);
     }
@@ -138,7 +138,7 @@ test_core(void)
     a[0]++;
     assert(hydro_compare(a, b, sizeof a) == 1);
     assert(hydro_compare(b, a, sizeof a) == -1);
-    randombytes_buf(x, sizeof x);
+    hydro_random_buf(x, sizeof x);
     assert(hydro_bin2hex(hex, sizeof hex, x, sizeof x) != NULL);
     assert(hydro_hex2bin(y, 1, hex, sizeof hex, NULL, NULL) == -1);
     assert(hydro_hex2bin(y, sizeof y, hex, sizeof hex, NULL, NULL) == -1);
@@ -156,13 +156,13 @@ test_secretbox(void)
     uint8_t m[25];
     uint8_t m2[25];
     uint8_t c[hydro_secretbox_HEADERBYTES + 25];
-    uint8_t dk[randombytes_SEEDBYTES];
+    uint8_t dk[hydro_random_SEEDBYTES];
     uint8_t probe[hydro_secretbox_PROBEBYTES];
 
     memset(dk, 0, sizeof dk);
-    randombytes_buf_deterministic(m, sizeof m, dk);
+    hydro_random_buf_deterministic(m, sizeof m, dk);
     hydro_increment(dk, sizeof dk);
-    randombytes_buf_deterministic(key, sizeof key, dk);
+    hydro_random_buf_deterministic(key, sizeof key, dk);
     hydro_increment(dk, sizeof dk);
     hydro_secretbox_encrypt(c, m, sizeof m, 0, ctx, key);
     assert(hydro_secretbox_decrypt(m2, c, sizeof c, 0, ctx, key) == 0);
@@ -185,7 +185,7 @@ test_secretbox(void)
     key[0]++;
     assert(hydro_secretbox_decrypt(m2, c, sizeof c, 0, ctx, key) == -1);
     key[0]--;
-    c[randombytes_uniform(sizeof c)]++;
+    c[hydro_random_uniform(sizeof c)]++;
     assert(hydro_secretbox_decrypt(m2, c, sizeof c, 0, ctx, key) == -1);
 }
 
@@ -193,7 +193,7 @@ static void
 test_kdf(void)
 {
     uint8_t key[hydro_kdf_KEYBYTES];
-    uint8_t dk[randombytes_SEEDBYTES];
+    uint8_t dk[hydro_random_SEEDBYTES];
     uint8_t subkey1[16];
     uint8_t subkey2[16];
     uint8_t subkey3[32];
@@ -204,7 +204,7 @@ test_kdf(void)
     char    subkey4_hex[50 * 2 + 1];
 
     memset(dk, 0, sizeof dk);
-    randombytes_buf_deterministic(key, sizeof key, dk);
+    hydro_random_buf_deterministic(key, sizeof key, dk);
     hydro_kdf_derive_from_key(subkey1, sizeof subkey1, 1, ctx, key);
     hydro_kdf_derive_from_key(subkey2, sizeof subkey2, 2, ctx, key);
     hydro_kdf_derive_from_key(subkey3, sizeof subkey3, 0, ctx, key);
@@ -230,7 +230,7 @@ test_sign(void)
     hydro_sign_state   st;
     hydro_sign_keypair kp;
 
-    randombytes_buf(msg, sizeof msg);
+    hydro_random_buf(msg, sizeof msg);
     hydro_sign_keygen(&kp);
     hydro_sign_create(sig, msg, sizeof msg, ctx, kp.sk);
     assert(hydro_sign_verify(sig, msg, sizeof msg, ctx, kp.pk) == 0);
@@ -298,7 +298,7 @@ test_kx(void)
     assert(hydro_equal(kp_client.tx, kp_server.rx, hydro_kx_SESSIONKEYBYTES));
     assert(hydro_equal(kp_client.rx, kp_server.tx, hydro_kx_SESSIONKEYBYTES));
 
-    randombytes_buf(psk, sizeof psk);
+    hydro_random_buf(psk, sizeof psk);
     hydro_kx_xx_1(&st_client, packet1, psk);
     hydro_kx_xx_2(&st_server, packet2, packet1, psk, &server_static_kp);
     hydro_kx_xx_3(&st_client, &kp_client, packet3, client_peer_pk, packet2, psk,