dualcone 0.0.1 → 1.0.0

data/vendor/libhydrogen/impl/random.h

@@ -6,351 +6,33 @@ static TLS struct {
 } hydro_random_context;
 
 #if defined(AVR) && !defined(__unix__)
-#include <Arduino.h>
-
-static bool
-hydro_random_rbit(uint16_t x)
-{
-    uint8_t x8;
-
-    x8 = ((uint8_t)(x >> 8)) ^ (uint8_t) x;
-    x8 = (x8 >> 4) ^ (x8 & 0xf);
-    x8 = (x8 >> 2) ^ (x8 & 0x3);
-    x8 = (x8 >> 1) ^ x8;
-
-    return (bool) (x8 & 1);
-}
-
-static int
-hydro_random_init(void)
-{
-    const char       ctx[hydro_hash_CONTEXTBYTES] = { 'h', 'y', 'd', 'r', 'o', 'P', 'R', 'G' };
-    hydro_hash_state st;
-    uint16_t         ebits = 0;
-    uint16_t         tc;
-    bool             a, b;
-
-    cli();
-    MCUSR = 0;
-    WDTCSR |= _BV(WDCE) | _BV(WDE);
-    WDTCSR = _BV(WDIE);
-    sei();
-
-    hydro_hash_init(&st, ctx, NULL);
-
-    while (ebits < 256) {
-        delay(1);
-        tc = TCNT1;
-        hydro_hash_update(&st, (const uint8_t *) &tc, sizeof tc);
-        a = hydro_random_rbit(tc);
-        delay(1);
-        tc = TCNT1;
-        b  = hydro_random_rbit(tc);
-        hydro_hash_update(&st, (const uint8_t *) &tc, sizeof tc);
-        if (a == b) {
-            continue;
-        }
-        hydro_hash_update(&st, (const uint8_t *) &b, sizeof b);
-        ebits++;
-    }
-
-    cli();
-    MCUSR = 0;
-    WDTCSR |= _BV(WDCE) | _BV(WDE);
-    WDTCSR = 0;
-    sei();
-
-    hydro_hash_final(&st, hydro_random_context.state, sizeof hydro_random_context.state);
-    hydro_random_context.counter = ~LOAD64_LE(hydro_random_context.state);
-
-    return 0;
-}
-
-ISR(WDT_vect) {}
-
+# include "random/avr.h"
 #elif (defined(ESP32) || defined(ESP8266)) && !defined(__unix__)
-
-// Important: RF *must* be activated on ESP board
-// https://techtutorialsx.com/2017/12/22/esp32-arduino-random-number-generation/
-
-#include <esp_system.h>
-
-static int
-hydro_random_init(void)
-{
-    const char       ctx[hydro_hash_CONTEXTBYTES] = { 'h', 'y', 'd', 'r', 'o', 'P', 'R', 'G' };
-    hydro_hash_state st;
-    uint16_t         ebits = 0;
-
-    hydro_hash_init(&st, ctx, NULL);
-
-    while (ebits < 256) {
-        uint32_t r = esp_random();
-
-        delay(10);
-        hydro_hash_update(&st, (const uint32_t *) &r, sizeof r);
-        ebits += 32;
-    }
-
-    hydro_hash_final(&st, hydro_random_context.state, sizeof hydro_random_context.state);
-    hydro_random_context.counter = ~LOAD64_LE(hydro_random_context.state);
-
-    return 0;
-}
-
+# include "random/esp32.h"
 #elif defined(PARTICLE) && defined(PLATFORM_ID) && PLATFORM_ID > 2 && !defined(__unix__)
-
-// Note: All particle platforms except for the Spark Core have a HW RNG.  Only allow building on
-// supported platforms for now. PLATFORM_ID definitions:
-// https://github.com/particle-iot/device-os/blob/mesh-develop/hal/shared/platforms.h
-
-#include "Particle.h"
-
-static int
-hydro_random_init(void)
-{
-    const char       ctx[hydro_hash_CONTEXTBYTES] = { 'h', 'y', 'd', 'r', 'o', 'P', 'R', 'G' };
-    hydro_hash_state st;
-    uint16_t         ebits = 0;
-
-    hydro_hash_init(&st, ctx, NULL);
-
-    while (ebits < 256) {
-        uint32_t r = HAL_RNG_GetRandomNumber();
-        hydro_hash_update(&st, (const uint32_t *) &r, sizeof r);
-        ebits += 32;
-    }
-
-    hydro_hash_final(&st, hydro_random_context.state, sizeof hydro_random_context.state);
-    hydro_random_context.counter = ~LOAD64_LE(hydro_random_context.state);
-
-    return 0;
-}
-
+# include "random/particle.h"
 #elif (defined(NRF52832_XXAA) || defined(NRF52832_XXAB)) && !defined(__unix__)
-
-// Important: The SoftDevice *must* be activated to enable reading from the RNG
-// http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.nrf52832.ps.v1.1%2Frng.html
-
-#include <nrf_soc.h>
-
-static int
-hydro_random_init(void)
-{
-    const char       ctx[hydro_hash_CONTEXTBYTES] = { 'h', 'y', 'd', 'r', 'o', 'P', 'R', 'G' };
-    hydro_hash_state st;
-    const uint8_t    total_bytes     = 32;
-    uint8_t          remaining_bytes = total_bytes;
-    uint8_t          available_bytes;
-    uint8_t          rand_buffer[32];
-
-    hydro_hash_init(&st, ctx, NULL);
-
-    for (;;) {
-        if (sd_rand_application_bytes_available_get(&available_bytes) != NRF_SUCCESS) {
-            return -1;
-        }
-        if (available_bytes > 0) {
-            if (available_bytes > remaining_bytes) {
-                available_bytes = remaining_bytes;
-            }
-            if (sd_rand_application_vector_get(rand_buffer, available_bytes) != NRF_SUCCESS) {
-                return -1;
-            }
-            hydro_hash_update(&st, rand_buffer, total_bytes);
-            remaining_bytes -= available_bytes;
-        }
-        if (remaining_bytes <= 0) {
-            break;
-        }
-        delay(10);
-    }
-    hydro_hash_final(&st, hydro_random_context.state, sizeof hydro_random_context.state);
-    hydro_random_context.counter = ~LOAD64_LE(hydro_random_context.state);
-
-    return 0;
-}
-
+# include "random/nrf52832.h"
 #elif defined(_WIN32)
-
-#include <windows.h>
-#define RtlGenRandom SystemFunction036
-#if defined(__cplusplus)
-extern "C"
-#endif
-    BOOLEAN NTAPI
-    RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
-#pragma comment(lib, "advapi32.lib")
-
-static int
-hydro_random_init(void)
-{
-    if (!RtlGenRandom((PVOID) hydro_random_context.state,
-                      (ULONG) sizeof hydro_random_context.state)) {
-        return -1;
-    }
-    hydro_random_context.counter = ~LOAD64_LE(hydro_random_context.state);
-
-    return 0;
-}
-
+# include "random/windows.h"
 #elif defined(__wasi__)
-
-#include <unistd.h>
-
-static int
-hydro_random_init(void)
-{
-    if (getentropy(hydro_random_context.state, sizeof hydro_random_context.state) != 0) {
-        return -1;
-    }
-    hydro_random_context.counter = ~LOAD64_LE(hydro_random_context.state);
-
-    return 0;
-}
-
+# include "random/wasi.h"
 #elif defined(__unix__)
-
-#include <errno.h>
-#include <fcntl.h>
-#ifdef __linux__
-#include <poll.h>
-#endif
-#include <sys/types.h>
-#include <unistd.h>
-
-#ifdef __linux__
-static int
-hydro_random_block_on_dev_random(void)
-{
-    struct pollfd pfd;
-    int           fd;
-    int           pret;
-
-    fd = open("/dev/random", O_RDONLY);
-    if (fd == -1) {
-        return 0;
-    }
-    pfd.fd      = fd;
-    pfd.events  = POLLIN;
-    pfd.revents = 0;
-    do {
-        pret = poll(&pfd, 1, -1);
-    } while (pret < 0 && (errno == EINTR || errno == EAGAIN));
-    if (pret != 1) {
-        (void) close(fd);
-        errno = EIO;
-        return -1;
-    }
-    return close(fd);
-}
-#endif
-
-static ssize_t
-hydro_random_safe_read(const int fd, void *const buf_, size_t len)
-{
-    unsigned char *buf = (unsigned char *) buf_;
-    ssize_t        readnb;
-
-    do {
-        while ((readnb = read(fd, buf, len)) < (ssize_t) 0 && (errno == EINTR || errno == EAGAIN)) {
-        }
-        if (readnb < (ssize_t) 0) {
-            return readnb;
-        }
-        if (readnb == (ssize_t) 0) {
-            break;
-        }
-        len -= (size_t) readnb;
-        buf += readnb;
-    } while (len > (ssize_t) 0);
-
-    return (ssize_t)(buf - (unsigned char *) buf_);
-}
-
-static int
-hydro_random_init(void)
-{
-    uint8_t tmp[gimli_BLOCKBYTES + 8];
-    int     fd;
-    int     ret = -1;
-
-#ifdef __linux__
-    if (hydro_random_block_on_dev_random() != 0) {
-        return -1;
-    }
-#endif
-    do {
-        fd = open("/dev/urandom", O_RDONLY);
-        if (fd == -1 && errno != EINTR) {
-            return -1;
-        }
-    } while (fd == -1);
-    if (hydro_random_safe_read(fd, tmp, sizeof tmp) == (ssize_t) sizeof tmp) {
-        memcpy(hydro_random_context.state, tmp, gimli_BLOCKBYTES);
-        memcpy(&hydro_random_context.counter, tmp + gimli_BLOCKBYTES, 8);
-        hydro_memzero(tmp, sizeof tmp);
-        ret = 0;
-    }
-    ret |= close(fd);
-
-    return ret;
-}
-
+# include "random/unix.h"
 #elif defined(TARGET_LIKE_MBED)
-
-#include <mbedtls/ctr_drbg.h>
-#include <mbedtls/entropy.h>
-
-#if defined(MBEDTLS_ENTROPY_C)
-
-static int
-hydro_random_init(void)
-{
-    mbedtls_entropy_context entropy;
-    uint16_t                pos = 0;
-
-    mbedtls_entropy_init(&entropy);
-
-    // Pull data directly out of the entropy pool for the state, as it's small enough.
-    if (mbedtls_entropy_func(&entropy, (uint8_t *) &hydro_random_context.counter,
-                             sizeof hydro_random_context.counter) != 0) {
-        return -1;
-    }
-    // mbedtls_entropy_func can't provide more than MBEDTLS_ENTROPY_BLOCK_SIZE in one go.
-    // This constant depends of mbedTLS configuration (whether the PRNG is backed by SHA256/SHA512
-    // at this time) Therefore, if necessary, we get entropy multiple times.
-
-    do {
-        const uint8_t dataLeftToConsume = gimli_BLOCKBYTES - pos;
-        const uint8_t currentChunkSize  = (dataLeftToConsume > MBEDTLS_ENTROPY_BLOCK_SIZE)
-                                             ? MBEDTLS_ENTROPY_BLOCK_SIZE
-                                             : dataLeftToConsume;
-
-        // Forces mbedTLS to fetch fresh entropy, then get some to feed libhydrogen.
-        if (mbedtls_entropy_gather(&entropy) != 0 ||
-            mbedtls_entropy_func(&entropy, &hydro_random_context.state[pos], currentChunkSize) !=
-                0) {
-            return -1;
-        }
-        pos += MBEDTLS_ENTROPY_BLOCK_SIZE;
-    } while (pos < gimli_BLOCKBYTES);
-
-    mbedtls_entropy_free(&entropy);
-
-    return 0;
-}
-
-#else
-#error Need an entropy source
-#endif
-
+# include "random/mbed.h"
+#elif defined(RIOT_VERSION)
+# include "random/riot.h"
+#elif defined(STM32F4)
+# include "random/stm32.h"
+#elif defined(__RTTHREAD__)
+# include "random/rtthread.h"
 #else
-#error Unsupported platform
+# error Unsupported platform
 #endif
 
 static void
-hydro_random_check_initialized(void)
+hydro_random_ensure_initialized(void)
 {
     if (hydro_random_context.initialized == 0) {
         if (hydro_random_init() != 0) {
@@ -377,7 +59,7 @@ hydro_random_u32(void)
 {
     uint32_t v;
 
-    hydro_random_check_initialized();
+    hydro_random_ensure_initialized();
     if (hydro_random_context.available < 4) {
         hydro_random_ratchet();
     }
@@ -413,7 +95,7 @@ hydro_random_buf(void *out, size_t out_len)
     size_t   i;
     size_t   leftover;
 
-    hydro_random_check_initialized();
+    hydro_random_ensure_initialized();
     for (i = 0; i < out_len / gimli_RATE; i++) {
         gimli_core_u8(hydro_random_context.state, 0);
         memcpy(p + i * gimli_RATE, hydro_random_context.state, gimli_RATE);
@@ -461,5 +143,5 @@ void
 hydro_random_reseed(void)
 {
     hydro_random_context.initialized = 0;
-    hydro_random_check_initialized();
+    hydro_random_ensure_initialized();
 }

data/vendor/libhydrogen/impl/secretbox.h

@@ -1,4 +1,4 @@
-#define hydro_secretbox_IVBYTES 20
+#define hydro_secretbox_IVBYTES  20
 #define hydro_secretbox_SIVBYTES 20
 #define hydro_secretbox_MACBYTES 16
 

data/vendor/libhydrogen/impl/sign.h

@@ -1,6 +1,6 @@
 #define hydro_sign_CHALLENGEBYTES 32
-#define hydro_sign_NONCEBYTES 32
-#define hydro_sign_PREHASHBYTES 64
+#define hydro_sign_NONCEBYTES     32
+#define hydro_sign_PREHASHBYTES   64
 
 static void
 hydro_sign_p2(uint8_t sig[hydro_x25519_BYTES], const uint8_t challenge[hydro_sign_CHALLENGEBYTES],

data/vendor/libhydrogen/impl/x25519.h

@@ -15,13 +15,13 @@ typedef uint64_t    hydro_x25519_limb_t;
 typedef __uint128_t hydro_x25519_dlimb_t;
 typedef __int128_t  hydro_x25519_sdlimb_t;
 #define hydro_x25519_eswap_limb(X) LOAD64_LE((const uint8_t *) &(X))
-#define hydro_x25519_LIMB(x) x##ull
+#define hydro_x25519_LIMB(x)       x##ull
 #elif hydro_x25519_WBITS == 32
 typedef uint32_t hydro_x25519_limb_t;
 typedef uint64_t hydro_x25519_dlimb_t;
 typedef int64_t  hydro_x25519_sdlimb_t;
 #define hydro_x25519_eswap_limb(X) LOAD32_LE((const uint8_t *) &(X))
-#define hydro_x25519_LIMB(x) (uint32_t)(x##ull), (uint32_t)((x##ull) >> 32)
+#define hydro_x25519_LIMB(x)       (uint32_t)(x##ull), (uint32_t) ((x##ull) >> 32)
 #else
 #error "Need to know hydro_x25519_WBITS"
 #endif
@@ -109,10 +109,10 @@ hydro_x25519_sub(hydro_x25519_fe out, const hydro_x25519_fe a, const hydro_x2551
     int                   i;
 
     for (i = 0; i < hydro_x25519_NLIMBS; i++) {
-        out[i] = (hydro_x25519_limb_t)(carry = carry + a[i] - b[i]);
+        out[i] = (hydro_x25519_limb_t) (carry = carry + a[i] - b[i]);
         carry >>= hydro_x25519_WBITS;
     }
-    hydro_x25519_propagate(out, (hydro_x25519_limb_t)(1 + carry));
+    hydro_x25519_propagate(out, (hydro_x25519_limb_t) (1 + carry));
 }
 
 static void
@@ -138,15 +138,17 @@ hydro_x25519_swapout(uint8_t *out, hydro_x25519_limb_t *x)
 }
 
 static void
-hydro_x25519_mul(hydro_x25519_fe out, const hydro_x25519_fe a, const hydro_x25519_fe b, int nb)
+hydro_x25519_mul(hydro_x25519_fe out, const hydro_x25519_fe a, const hydro_x25519_limb_t b[],
+                 const int nb)
 {
     hydro_x25519_limb_t accum[2 * hydro_x25519_NLIMBS] = { 0 };
     hydro_x25519_limb_t carry2;
     int                 i, j;
 
     for (i = 0; i < nb; i++) {
-        carry2                   = 0;
         hydro_x25519_limb_t mand = b[i];
+        carry2                   = 0;
+
         for (j = 0; j < hydro_x25519_NLIMBS; j++) {
             accum[i + j] = hydro_x25519_umaal(&carry2, accum[i + j], mand, a[j]);
         }
@@ -207,7 +209,7 @@ hydro_x25519_canon(hydro_x25519_fe x)
     carry = -19;
     res   = 0;
     for (i = 0; i < hydro_x25519_NLIMBS; i++) {
-        res |= x[i] = (hydro_x25519_limb_t)(carry += x[i]);
+        res |= x[i] = (hydro_x25519_limb_t) (carry += x[i]);
         carry >>= hydro_x25519_WBITS;
     }
     return ((hydro_x25519_dlimb_t) res - 1) >> hydro_x25519_WBITS;
@@ -218,17 +220,17 @@ hydro_x25519_ladder_part1(hydro_x25519_fe xs[5])
 {
     hydro_x25519_limb_t *x2 = xs[0], *z2 = xs[1], *x3 = xs[2], *z3 = xs[3], *t1 = xs[4];
 
-    hydro_x25519_add(t1, x2, z2);              // t1 = A
-    hydro_x25519_sub(z2, x2, z2);              // z2 = B
-    hydro_x25519_add(x2, x3, z3);              // x2 = C
-    hydro_x25519_sub(z3, x3, z3);              // z3 = D
-    hydro_x25519_mul1(z3, t1);                 // z3 = DA
-    hydro_x25519_mul1(x2, z2);                 // x3 = BC
-    hydro_x25519_add(x3, z3, x2);              // x3 = DA+CB
-    hydro_x25519_sub(z3, z3, x2);              // z3 = DA-CB
-    hydro_x25519_sqr1(t1);                     // t1 = AA
-    hydro_x25519_sqr1(z2);                     // z2 = BB
-    hydro_x25519_sub(x2, t1, z2);              // x2 = E = AA-BB
+    hydro_x25519_add(t1, x2, z2); // t1 = A
+    hydro_x25519_sub(z2, x2, z2); // z2 = B
+    hydro_x25519_add(x2, x3, z3); // x2 = C
+    hydro_x25519_sub(z3, x3, z3); // z3 = D
+    hydro_x25519_mul1(z3, t1);    // z3 = DA
+    hydro_x25519_mul1(x2, z2);    // x3 = BC
+    hydro_x25519_add(x3, z3, x2); // x3 = DA+CB
+    hydro_x25519_sub(z3, z3, x2); // z3 = DA-CB
+    hydro_x25519_sqr1(t1);        // t1 = AA
+    hydro_x25519_sqr1(z2);        // z2 = BB
+    hydro_x25519_sub(x2, t1, z2); // x2 = E = AA-BB
     hydro_x25519_mul(z2, x2, hydro_x25519_a24, // z2 = E*a24
                      sizeof(hydro_x25519_a24) / sizeof(hydro_x25519_a24[0]));
     hydro_x25519_add(z2, z2, t1); // z2 = E*a24 + AA
@@ -275,7 +277,7 @@ hydro_x25519_core(hydro_x25519_fe xs[5], const uint8_t scalar[hydro_x25519_BYTES
                 bytei |= 0x40;
             }
         }
-        doswap = 1U + ~(hydro_x25519_limb_t)((bytei >> (i % 8)) & 1);
+        doswap = 1U + ~(hydro_x25519_limb_t) ((bytei >> (i % 8)) & 1);
         hydro_x25519_condswap(x2, x3, swap ^ doswap);
         swap = doswap;
         hydro_x25519_ladder_part1(xs);
@@ -372,7 +374,7 @@ hydro_x25519_sc_montmul(hydro_x25519_scalar_t out, const hydro_x25519_scalar_t a
     /* Reduce */
     hydro_x25519_sdlimb_t scarry = 0;
     for (i = 0; i < hydro_x25519_NLIMBS; i++) {
-        out[i] = (hydro_x25519_limb_t)(scarry = scarry + out[i] - hydro_x25519_sc_p[i]);
+        out[i] = (hydro_x25519_limb_t) (scarry = scarry + out[i] - hydro_x25519_sc_p[i]);
         scarry >>= hydro_x25519_WBITS;
     }
     hydro_x25519_limb_t need_add = (hydro_x25519_limb_t) - (scarry + hic);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dualcone
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Tom Richards
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-23 00:00:00.000000000 Z
+date: 2022-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -109,7 +109,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: warning
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -155,15 +183,27 @@ files:
 - vendor/libhydrogen/impl/kx.h
 - vendor/libhydrogen/impl/pwhash.h
 - vendor/libhydrogen/impl/random.h
+- vendor/libhydrogen/impl/random/avr.h
+- vendor/libhydrogen/impl/random/esp32.h
+- vendor/libhydrogen/impl/random/mbed.h
+- vendor/libhydrogen/impl/random/nrf52832.h
+- vendor/libhydrogen/impl/random/particle.h
+- vendor/libhydrogen/impl/random/riot.h
+- vendor/libhydrogen/impl/random/rtthread.h
+- vendor/libhydrogen/impl/random/stm32.h
+- vendor/libhydrogen/impl/random/unix.h
+- vendor/libhydrogen/impl/random/wasi.h
+- vendor/libhydrogen/impl/random/windows.h
 - vendor/libhydrogen/impl/secretbox.h
 - vendor/libhydrogen/impl/sign.h
 - vendor/libhydrogen/impl/x25519.h
 homepage: https://github.com/t-richards/dualcone
 licenses:
-- MIT
+- ISC
 metadata:
   homepage_uri: https://github.com/t-richards/dualcone
   source_code_uri: https://github.com/t-richards/dualcone
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -172,14 +212,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.8
 signing_key:
 specification_version: 4
 summary: A Ruby source code protection system.