react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.21

package/ios/libsodium-stable/src/libsodium/randombytes/randombytes.c

@@ -1,200 +0,0 @@
-
-#include <assert.h>
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <sys/types.h>
-
-#ifdef __EMSCRIPTEN__
-# include <emscripten.h>
-#endif
-
-#include "core.h"
-#include "crypto_stream_chacha20.h"
-#include "randombytes.h"
-#ifndef RANDOMBYTES_CUSTOM_IMPLEMENTATION
-# ifdef RANDOMBYTES_DEFAULT_IMPLEMENTATION
-#  include "randombytes_internal.h"
-# endif
-# include "randombytes_sysrandom.h"
-#endif
-#include "private/common.h"
-
-/* C++Builder defines a "random" macro */
-#undef random
-
-static const randombytes_implementation *implementation;
-
-#ifndef RANDOMBYTES_DEFAULT_IMPLEMENTATION
-# ifdef __EMSCRIPTEN__
-#  define RANDOMBYTES_DEFAULT_IMPLEMENTATION NULL
-# else
-#  define RANDOMBYTES_DEFAULT_IMPLEMENTATION &randombytes_sysrandom_implementation;
-# endif
-#endif
-
-static void
-randombytes_init_if_needed(void)
-{
-    if (implementation == NULL) {
-        implementation = RANDOMBYTES_DEFAULT_IMPLEMENTATION;
-        randombytes_stir();
-    }
-}
-
-int
-randombytes_set_implementation(const randombytes_implementation *impl)
-{
-    implementation = impl;
-
-    return 0;
-}
-
-const char *
-randombytes_implementation_name(void)
-{
-#ifndef __EMSCRIPTEN__
-    randombytes_init_if_needed();
-    return implementation->implementation_name();
-#else
-    return "js";
-#endif
-}
-
-uint32_t
-randombytes_random(void)
-{
-#ifndef __EMSCRIPTEN__
-    randombytes_init_if_needed();
-    return implementation->random();
-#else
-    return EM_ASM_INT_V({
-        return Module.getRandomValue();
-    });
-#endif
-}
-
-void
-randombytes_stir(void)
-{
-#ifndef __EMSCRIPTEN__
-    randombytes_init_if_needed();
-    if (implementation->stir != NULL) {
-        implementation->stir();
-    }
-#else
-    EM_ASM({
-        if (Module.getRandomValue === undefined) {
-            try {
-                var window_ = 'object' === typeof window ? window : self;
-                var crypto_ = typeof window_.crypto !== 'undefined' ? window_.crypto : window_.msCrypto;
-                crypto_ = (crypto_ === undefined) ? crypto : crypto_;
-                var randomValuesStandard = function() {
-                    var buf = new Uint32Array(1);
-                    crypto_.getRandomValues(buf);
-                    return buf[0] >>> 0;
-                };
-                randomValuesStandard();
-                Module.getRandomValue = randomValuesStandard;
-            } catch (e) {
-                try {
-                    var crypto = require('crypto');
-                    var randomValueNodeJS = function() {
-                        var buf = crypto['randomBytes'](4);
-                        return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
-                    };
-                    randomValueNodeJS();
-                    Module.getRandomValue = randomValueNodeJS;
-                } catch (e) {
-                    throw 'No secure random number generator found';
-                }
-            }
-        }
-    });
-#endif
-}
-
-uint32_t
-randombytes_uniform(const uint32_t upper_bound)
-{
-    uint32_t min;
-    uint32_t r;
-
-#ifndef __EMSCRIPTEN__
-    randombytes_init_if_needed();
-    if (implementation->uniform != NULL) {
-        return implementation->uniform(upper_bound);
-    }
-#endif
-    if (upper_bound < 2) {
-        return 0;
-    }
-    min = (1U + ~upper_bound) % upper_bound; /* = 2**32 mod upper_bound */
-    do {
-        r = randombytes_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 */
-
-    return r % upper_bound;
-}
-
-void
-randombytes_buf(void * const buf, const size_t size)
-{
-#ifndef __EMSCRIPTEN__
-    randombytes_init_if_needed();
-    if (size > (size_t) 0U) {
-        implementation->buf(buf, size);
-    }
-#else
-    unsigned char *p = (unsigned char *) buf;
-    size_t         i;
-
-    for (i = (size_t) 0U; i < size; i++) {
-        p[i] = (unsigned char) randombytes_random();
-    }
-#endif
-}
-
-void
-randombytes_buf_deterministic(void * const buf, const size_t size,
-                              const unsigned char seed[randombytes_SEEDBYTES])
-{
-    static const unsigned char nonce[crypto_stream_chacha20_ietf_NONCEBYTES] = {
-        'L', 'i', 'b', 's', 'o', 'd', 'i', 'u', 'm', 'D', 'R', 'G'
-    };
-
-    COMPILER_ASSERT(randombytes_SEEDBYTES == crypto_stream_chacha20_ietf_KEYBYTES);
-#if SIZE_MAX > 0x4000000000ULL
-    COMPILER_ASSERT(randombytes_BYTES_MAX <= 0x4000000000ULL);
-    if (size > 0x4000000000ULL) {
-        sodium_misuse();
-    }
-#endif
-    crypto_stream_chacha20_ietf((unsigned char *) buf, (unsigned long long) size,
-                                nonce, seed);
-}
-
-size_t
-randombytes_seedbytes(void)
-{
-    return randombytes_SEEDBYTES;
-}
-
-int
-randombytes_close(void)
-{
-    if (implementation != NULL && implementation->close != NULL) {
-        return implementation->close();
-    }
-    return 0;
-}
-
-void
-randombytes(unsigned char * const buf, const unsigned long long buf_len)
-{
-    assert(buf_len <= SIZE_MAX);
-    randombytes_buf(buf, (size_t) buf_len);
-}

package/ios/libsodium-stable/src/libsodium/randombytes/sysrandom/randombytes_sysrandom.c

@@ -1,396 +0,0 @@
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdint.h>
-#include <string.h>
-#ifndef _WIN32
-# include <unistd.h>
-#endif
-#include <stdlib.h>
-
-#include <sys/types.h>
-#ifndef _WIN32
-# include <sys/stat.h>
-# include <sys/time.h>
-#endif
-#ifdef __linux__
-# define _LINUX_SOURCE
-#endif
-#ifdef HAVE_SYS_RANDOM_H
-# include <sys/random.h>
-#endif
-#ifdef __linux__
-# ifdef HAVE_GETRANDOM
-#  define HAVE_LINUX_COMPATIBLE_GETRANDOM
-# else
-#  include <sys/syscall.h>
-#  if defined(SYS_getrandom) && defined(__NR_getrandom)
-#   define getrandom(B, S, F) syscall(SYS_getrandom, (B), (int) (S), (F))
-#   define HAVE_LINUX_COMPATIBLE_GETRANDOM
-#  endif
-# endif
-#elif defined(__FreeBSD__) || defined(__DragonFly__)
-# include <sys/param.h>
-# if (defined(__FreeBSD_version) && __FreeBSD_version >= 1200000) || \
-     (defined(__DragonFly_version) && __DragonFly_version >= 500700)
-#  define HAVE_LINUX_COMPATIBLE_GETRANDOM
-# endif
-#endif
-#if !defined(NO_BLOCKING_RANDOM_POLL) && defined(__linux__)
-# define BLOCK_ON_DEV_RANDOM
-#endif
-#ifdef BLOCK_ON_DEV_RANDOM
-# include <poll.h>
-#endif
-
-#include "core.h"
-#include "private/common.h"
-#include "randombytes.h"
-#include "randombytes_sysrandom.h"
-#include "utils.h"
-
-#ifdef _WIN32
-/* `RtlGenRandom` is used over `CryptGenRandom` on Microsoft Windows based systems:
- *  - `CryptGenRandom` requires pulling in `CryptoAPI` which causes unnecessary
- *     memory overhead if this API is not being used for other purposes
- *  - `RtlGenRandom` is thus called directly instead. A detailed explanation
- *     can be found here: https://blogs.msdn.microsoft.com/michael_howard/2005/01/14/cryptographically-secure-random-number-on-windows-without-using-cryptoapi/
- *
- * In spite of the disclaimer on the `RtlGenRandom` documentation page that was
- * written back in the Windows XP days, this function is here to stay. The CRT
- * function `rand_s()` directly depends on it, so touching it would break many
- * applications released since Windows XP.
- *
- * Also note that Rust, Firefox and BoringSSL (thus, Google Chrome and everything
- * based on Chromium) also depend on it, and that libsodium allows the RNG to be
- * replaced without patching nor recompiling the library.
- */
-# include <windows.h>
-# define RtlGenRandom SystemFunction036
-# if defined(__cplusplus)
-extern "C"
-# endif
-BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
-# pragma comment(lib, "advapi32.lib")
-#endif
-
-#if defined(__OpenBSD__) || defined(__CloudABI__) || defined(__wasi__)
-# define HAVE_SAFE_ARC4RANDOM 1
-#endif
-
-#ifndef SSIZE_MAX
-# define SSIZE_MAX (SIZE_MAX / 2 - 1)
-#endif
-
-#ifdef HAVE_SAFE_ARC4RANDOM
-
-static uint32_t
-randombytes_sysrandom(void)
-{
-    return arc4random();
-}
-
-static void
-randombytes_sysrandom_stir(void)
-{
-}
-
-static void
-randombytes_sysrandom_buf(void * const buf, const size_t size)
-{
-    arc4random_buf(buf, size);
-}
-
-static int
-randombytes_sysrandom_close(void)
-{
-    return 0;
-}
-
-#else /* HAVE_SAFE_ARC4RANDOM */
-
-typedef struct SysRandom_ {
-    int random_data_source_fd;
-    int initialized;
-    int getrandom_available;
-} SysRandom;
-
-static SysRandom stream = {
-    SODIUM_C99(.random_data_source_fd =) -1,
-    SODIUM_C99(.initialized =) 0,
-    SODIUM_C99(.getrandom_available =) 0
-};
-
-# ifndef _WIN32
-static ssize_t
-safe_read(const int fd, void * const buf_, size_t size)
-{
-    unsigned char *buf = (unsigned char *) buf_;
-    ssize_t        readnb;
-
-    assert(size > (size_t) 0U);
-    assert(size <= SSIZE_MAX);
-    do {
-        while ((readnb = read(fd, buf, size)) < (ssize_t) 0 &&
-               (errno == EINTR || errno == EAGAIN)); /* LCOV_EXCL_LINE */
-        if (readnb < (ssize_t) 0) {
-            return readnb; /* LCOV_EXCL_LINE */
-        }
-        if (readnb == (ssize_t) 0) {
-            break; /* LCOV_EXCL_LINE */
-        }
-        size -= (size_t) readnb;
-        buf += readnb;
-    } while (size > (ssize_t) 0);
-
-    return (ssize_t) (buf - (unsigned char *) buf_);
-}
-
-#  ifdef BLOCK_ON_DEV_RANDOM
-static int
-randombytes_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 /* BLOCK_ON_DEV_RANDOM */
-
-static int
-randombytes_sysrandom_random_dev_open(void)
-{
-/* LCOV_EXCL_START */
-    struct stat        st;
-    static const char *devices[] = {
-#  ifndef USE_BLOCKING_RANDOM
-        "/dev/urandom",
-#  endif
-        "/dev/random", NULL
-    };
-    const char       **device = devices;
-    int                fd;
-
-#  ifdef BLOCK_ON_DEV_RANDOM
-    if (randombytes_block_on_dev_random() != 0) {
-        return -1;
-    }
-#  endif
-    do {
-        fd = open(*device, O_RDONLY);
-        if (fd != -1) {
-            if (fstat(fd, &st) == 0 &&
-#  ifdef __COMPCERT__
-                1
-#  elif defined(S_ISNAM)
-                (S_ISNAM(st.st_mode) || S_ISCHR(st.st_mode))
-#  else
-                S_ISCHR(st.st_mode)
-#  endif
-               ) {
-#  if defined(F_SETFD) && defined(FD_CLOEXEC)
-                (void) fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
-#  endif
-                return fd;
-            }
-            (void) close(fd);
-        } else if (errno == EINTR) {
-            continue;
-        }
-        device++;
-    } while (*device != NULL);
-
-    errno = EIO;
-    return -1;
-/* LCOV_EXCL_STOP */
-}
-
-#  ifdef HAVE_LINUX_COMPATIBLE_GETRANDOM
-static int
-_randombytes_linux_getrandom(void * const buf, const size_t size)
-{
-    int readnb;
-
-    assert(size <= 256U);
-    do {
-        readnb = getrandom(buf, size, 0);
-    } while (readnb < 0 && (errno == EINTR || errno == EAGAIN));
-
-    return (readnb == (int) size) - 1;
-}
-
-static int
-randombytes_linux_getrandom(void * const buf_, size_t size)
-{
-    unsigned char *buf = (unsigned char *) buf_;
-    size_t         chunk_size = 256U;
-
-    do {
-        if (size < chunk_size) {
-            chunk_size = size;
-            assert(chunk_size > (size_t) 0U);
-        }
-        if (_randombytes_linux_getrandom(buf, chunk_size) != 0) {
-            return -1;
-        }
-        size -= chunk_size;
-        buf += chunk_size;
-    } while (size > (size_t) 0U);
-
-    return 0;
-}
-#  endif /* HAVE_LINUX_COMPATIBLE_GETRANDOM */
-
-static void
-randombytes_sysrandom_init(void)
-{
-    const int     errno_save = errno;
-
-#  ifdef HAVE_LINUX_COMPATIBLE_GETRANDOM
-    {
-        unsigned char fodder[16];
-
-        if (randombytes_linux_getrandom(fodder, sizeof fodder) == 0) {
-            stream.getrandom_available = 1;
-            errno = errno_save;
-            return;
-        }
-        stream.getrandom_available = 0;
-    }
-#  endif
-
-    if ((stream.random_data_source_fd =
-         randombytes_sysrandom_random_dev_open()) == -1) {
-        sodium_misuse(); /* LCOV_EXCL_LINE */
-    }
-    errno = errno_save;
-}
-
-# else /* _WIN32 */
-
-static void
-randombytes_sysrandom_init(void)
-{
-}
-# endif /* _WIN32 */
-
-static void
-randombytes_sysrandom_stir(void)
-{
-    if (stream.initialized == 0) {
-        randombytes_sysrandom_init();
-        stream.initialized = 1;
-    }
-}
-
-static void
-randombytes_sysrandom_stir_if_needed(void)
-{
-    if (stream.initialized == 0) {
-        randombytes_sysrandom_stir();
-    }
-}
-
-static int
-randombytes_sysrandom_close(void)
-{
-    int ret = -1;
-
-# ifndef _WIN32
-    if (stream.random_data_source_fd != -1 &&
-        close(stream.random_data_source_fd) == 0) {
-        stream.random_data_source_fd = -1;
-        stream.initialized = 0;
-        ret = 0;
-    }
-#  ifdef HAVE_LINUX_COMPATIBLE_GETRANDOM
-    if (stream.getrandom_available != 0) {
-        ret = 0;
-    }
-#  endif
-# else /* _WIN32 */
-    if (stream.initialized != 0) {
-        stream.initialized = 0;
-        ret = 0;
-    }
-# endif /* _WIN32 */
-    return ret;
-}
-
-static void
-randombytes_sysrandom_buf(void * const buf, const size_t size)
-{
-    randombytes_sysrandom_stir_if_needed();
-# if defined(ULLONG_MAX) && defined(SIZE_MAX)
-#  if SIZE_MAX > ULLONG_MAX
-    /* coverity[result_independent_of_operands] */
-    assert(size <= ULLONG_MAX);
-#  endif
-# endif
-# ifndef _WIN32
-#  ifdef HAVE_LINUX_COMPATIBLE_GETRANDOM
-    if (stream.getrandom_available != 0) {
-        if (randombytes_linux_getrandom(buf, size) != 0) {
-            sodium_misuse(); /* LCOV_EXCL_LINE */
-        }
-        return;
-    }
-#  endif
-    if (stream.random_data_source_fd == -1 ||
-        safe_read(stream.random_data_source_fd, buf, size) != (ssize_t) size) {
-        sodium_misuse(); /* LCOV_EXCL_LINE */
-    }
-# else /* _WIN32 */
-    COMPILER_ASSERT(randombytes_BYTES_MAX <= 0xffffffffUL);
-    if (size > (size_t) 0xffffffffUL) {
-        sodium_misuse(); /* LCOV_EXCL_LINE */
-    }
-    if (! RtlGenRandom((PVOID) buf, (ULONG) size)) {
-        sodium_misuse(); /* LCOV_EXCL_LINE */
-    }
-# endif /* _WIN32 */
-}
-
-static uint32_t
-randombytes_sysrandom(void)
-{
-    uint32_t r;
-
-    randombytes_sysrandom_buf(&r, sizeof r);
-
-    return r;
-}
-
-#endif /* HAVE_SAFE_ARC4RANDOM */
-
-static const char *
-randombytes_sysrandom_implementation_name(void)
-{
-    return "sysrandom";
-}
-
-struct randombytes_implementation randombytes_sysrandom_implementation = {
-    SODIUM_C99(.implementation_name =) randombytes_sysrandom_implementation_name,
-    SODIUM_C99(.random =) randombytes_sysrandom,
-    SODIUM_C99(.stir =) randombytes_sysrandom_stir,
-    SODIUM_C99(.uniform =) NULL,
-    SODIUM_C99(.buf =) randombytes_sysrandom_buf,
-    SODIUM_C99(.close =) randombytes_sysrandom_close
-};