react-native-quick-crypto 1.0.0-beta.16 → 1.0.0-beta.17

package/ios/libsodium-stable/src/libsodium/sodium/codecs.c

@@ -1,335 +0,0 @@
-#include <assert.h>
-#include <errno.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "core.h"
-#include "private/common.h"
-#include "utils.h"
-
-/* Derived from original code by CodesInChaos */
-char *
-sodium_bin2hex(char *const hex, const size_t hex_maxlen,
-               const unsigned char *const bin, const size_t bin_len)
-{
-    size_t       i = (size_t) 0U;
-    unsigned int x;
-    int          b;
-    int          c;
-
-    if (bin_len >= SIZE_MAX / 2 || hex_maxlen <= bin_len * 2U) {
-        sodium_misuse(); /* LCOV_EXCL_LINE */
-    }
-    while (i < bin_len) {
-        c = bin[i] & 0xf;
-        b = bin[i] >> 4;
-        x = (unsigned char) (87U + c + (((c - 10U) >> 8) & ~38U)) << 8 |
-            (unsigned char) (87U + b + (((b - 10U) >> 8) & ~38U));
-        hex[i * 2U] = (char) x;
-        x >>= 8;
-        hex[i * 2U + 1U] = (char) x;
-        i++;
-    }
-    hex[i * 2U] = 0U;
-
-    return hex;
-}
-
-int
-sodium_hex2bin(unsigned char *const bin, const size_t bin_maxlen,
-               const char *const hex, const size_t hex_len,
-               const char *const ignore, size_t *const bin_len,
-               const char **const hex_end)
-{
-    size_t        bin_pos = (size_t) 0U;
-    size_t        hex_pos = (size_t) 0U;
-    int           ret     = 0;
-    unsigned char c;
-    unsigned char c_acc = 0U;
-    unsigned char c_alpha0, c_alpha;
-    unsigned char c_num0, c_num;
-    unsigned char c_val;
-    unsigned char state = 0U;
-
-    while (hex_pos < hex_len) {
-        c        = (unsigned char) hex[hex_pos];
-        c_num    = c ^ 48U;
-        c_num0   = (c_num - 10U) >> 8;
-        c_alpha  = (c & ~32U) - 55U;
-        c_alpha0 = ((c_alpha - 10U) ^ (c_alpha - 16U)) >> 8;
-        if ((c_num0 | c_alpha0) == 0U) {
-            if (ignore != NULL && state == 0U && strchr(ignore, c) != NULL) {
-                hex_pos++;
-                continue;
-            }
-            break;
-        }
-        c_val = (c_num0 & c_num) | (c_alpha0 & c_alpha);
-        if (bin_pos >= bin_maxlen) {
-            ret   = -1;
-            errno = ERANGE;
-            break;
-        }
-        if (state == 0U) {
-            c_acc = c_val * 16U;
-        } else {
-            bin[bin_pos++] = c_acc | c_val;
-        }
-        state = ~state;
-        hex_pos++;
-    }
-    if (state != 0U) {
-        hex_pos--;
-        errno = EINVAL;
-        ret = -1;
-    }
-    if (ret != 0) {
-        bin_pos = (size_t) 0U;
-    }
-    if (hex_end != NULL) {
-        *hex_end = &hex[hex_pos];
-    } else if (hex_pos != hex_len) {
-        errno = EINVAL;
-        ret = -1;
-    }
-    if (bin_len != NULL) {
-        *bin_len = bin_pos;
-    }
-    return ret;
-}
-
-/*
- * Some macros for constant-time comparisons. These work over values in
- * the 0..255 range. Returned value is 0x00 on "false", 0xFF on "true".
- *
- * Original code by Thomas Pornin.
- */
-#define EQ(x, y) \
-    ((((0U - ((unsigned int) (x) ^ (unsigned int) (y))) >> 8) & 0xFF) ^ 0xFF)
-#define GT(x, y) ((((unsigned int) (y) - (unsigned int) (x)) >> 8) & 0xFF)
-#define GE(x, y) (GT(y, x) ^ 0xFF)
-#define LT(x, y) GT(y, x)
-#define LE(x, y) GE(y, x)
-
-static int
-b64_byte_to_char(unsigned int x)
-{
-    return (LT(x, 26) & (x + 'A')) |
-           (GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) |
-           (GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '+') |
-           (EQ(x, 63) & '/');
-}
-
-static unsigned int
-b64_char_to_byte(int c)
-{
-    const unsigned int x =
-        (GE(c, 'A') & LE(c, 'Z') & (c - 'A')) |
-        (GE(c, 'a') & LE(c, 'z') & (c - ('a' - 26))) |
-        (GE(c, '0') & LE(c, '9') & (c - ('0' - 52))) | (EQ(c, '+') & 62) |
-        (EQ(c, '/') & 63);
-
-    return x | (EQ(x, 0) & (EQ(c, 'A') ^ 0xFF));
-}
-
-static int
-b64_byte_to_urlsafe_char(unsigned int x)
-{
-    return (LT(x, 26) & (x + 'A')) |
-           (GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) |
-           (GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '-') |
-           (EQ(x, 63) & '_');
-}
-
-static unsigned int
-b64_urlsafe_char_to_byte(int c)
-{
-    const unsigned x =
-        (GE(c, 'A') & LE(c, 'Z') & (c - 'A')) |
-        (GE(c, 'a') & LE(c, 'z') & (c - ('a' - 26))) |
-        (GE(c, '0') & LE(c, '9') & (c - ('0' - 52))) | (EQ(c, '-') & 62) |
-        (EQ(c, '_') & 63);
-
-    return x | (EQ(x, 0) & (EQ(c, 'A') ^ 0xFF));
-}
-
-
-#define VARIANT_NO_PADDING_MASK 0x2U
-#define VARIANT_URLSAFE_MASK    0x4U
-
-static void
-sodium_base64_check_variant(const int variant)
-{
-    if ((((unsigned int) variant) & ~ 0x6U) != 0x1U) {
-        sodium_misuse();
-    }
-}
-
-size_t
-sodium_base64_encoded_len(const size_t bin_len, const int variant)
-{
-    sodium_base64_check_variant(variant);
-
-    return sodium_base64_ENCODED_LEN(bin_len, variant);
-}
-
-char *
-sodium_bin2base64(char * const b64, const size_t b64_maxlen,
-                  const unsigned char * const bin, const size_t bin_len,
-                  const int variant)
-{
-    size_t       acc_len = (size_t) 0;
-    size_t       b64_len;
-    size_t       b64_pos = (size_t) 0;
-    size_t       bin_pos = (size_t) 0;
-    size_t       nibbles;
-    size_t       remainder;
-    unsigned int acc = 0U;
-
-    sodium_base64_check_variant(variant);
-    nibbles = bin_len / 3;
-    remainder = bin_len - 3 * nibbles;
-    b64_len = nibbles * 4;
-    if (remainder != 0) {
-        if ((((unsigned int) variant) & VARIANT_NO_PADDING_MASK) == 0U) {
-            b64_len += 4;
-        } else {
-            b64_len += 2 + (remainder >> 1);
-        }
-    }
-    if (b64_maxlen <= b64_len) {
-        sodium_misuse();
-    }
-    if ((((unsigned int) variant) & VARIANT_URLSAFE_MASK) != 0U) {
-        while (bin_pos < bin_len) {
-            acc = (acc << 8) + bin[bin_pos++];
-            acc_len += 8;
-            while (acc_len >= 6) {
-                acc_len -= 6;
-                b64[b64_pos++] = (char) b64_byte_to_urlsafe_char((acc >> acc_len) & 0x3F);
-            }
-        }
-        if (acc_len > 0) {
-            b64[b64_pos++] = (char) b64_byte_to_urlsafe_char((acc << (6 - acc_len)) & 0x3F);
-        }
-    } else {
-        while (bin_pos < bin_len) {
-            acc = (acc << 8) + bin[bin_pos++];
-            acc_len += 8;
-            while (acc_len >= 6) {
-                acc_len -= 6;
-                b64[b64_pos++] = (char) b64_byte_to_char((acc >> acc_len) & 0x3F);
-            }
-        }
-        if (acc_len > 0) {
-            b64[b64_pos++] = (char) b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
-        }
-    }
-    assert(b64_pos <= b64_len);
-    while (b64_pos < b64_len) {
-        b64[b64_pos++] = '=';
-    }
-    do {
-        b64[b64_pos++] = 0U;
-    } while (b64_pos < b64_maxlen);
-
-    return b64;
-}
-
-static int
-_sodium_base642bin_skip_padding(const char * const b64, const size_t b64_len,
-                                size_t * const b64_pos_p,
-                                const char * const ignore, size_t padding_len)
-{
-    int c;
-
-    while (padding_len > 0) {
-        if (*b64_pos_p >= b64_len) {
-            errno = ERANGE;
-            return -1;
-        }
-        ACQUIRE_FENCE;
-        c = b64[*b64_pos_p];
-        if (c == '=') {
-            padding_len--;
-        } else if (ignore == NULL || strchr(ignore, c) == NULL) {
-            errno = EINVAL;
-            return -1;
-        }
-        (*b64_pos_p)++;
-    }
-    return 0;
-}
-
-int
-sodium_base642bin(unsigned char * const bin, const size_t bin_maxlen,
-                  const char * const b64, const size_t b64_len,
-                  const char * const ignore, size_t * const bin_len,
-                  const char ** const b64_end, const int variant)
-{
-    size_t       acc_len = (size_t) 0;
-    size_t       b64_pos = (size_t) 0;
-    size_t       bin_pos = (size_t) 0;
-    int          is_urlsafe;
-    int          ret = 0;
-    unsigned int acc = 0U;
-    unsigned int d;
-    char         c;
-
-    sodium_base64_check_variant(variant);
-    is_urlsafe = ((unsigned int) variant) & VARIANT_URLSAFE_MASK;
-    while (b64_pos < b64_len) {
-        c = b64[b64_pos];
-        if (is_urlsafe) {
-            d = b64_urlsafe_char_to_byte(c);
-        } else {
-            d = b64_char_to_byte(c);
-        }
-        if (d == 0xFF) {
-            if (ignore != NULL && strchr(ignore, c) != NULL) {
-                b64_pos++;
-                continue;
-            }
-            break;
-        }
-        acc = (acc << 6) + d;
-        acc_len += 6;
-        if (acc_len >= 8) {
-            acc_len -= 8;
-            if (bin_pos >= bin_maxlen) {
-                errno = ERANGE;
-                ret = -1;
-                break;
-            }
-            bin[bin_pos++] = (acc >> acc_len) & 0xFF;
-        }
-        b64_pos++;
-    }
-    if (acc_len > 4U || (acc & ((1U << acc_len) - 1U)) != 0U) {
-        ret = -1;
-    } else if (ret == 0 &&
-               (((unsigned int) variant) & VARIANT_NO_PADDING_MASK) == 0U) {
-        ret = _sodium_base642bin_skip_padding(b64, b64_len, &b64_pos, ignore,
-                                              acc_len / 2);
-    }
-    if (ret != 0) {
-        bin_pos = (size_t) 0U;
-    } else if (ignore != NULL) {
-        while (b64_pos < b64_len && strchr(ignore, b64[b64_pos]) != NULL) {
-            b64_pos++;
-        }
-    }
-    if (b64_end != NULL) {
-        *b64_end = &b64[b64_pos];
-    } else if (b64_pos != b64_len) {
-        errno = EINVAL;
-        ret = -1;
-    }
-    if (bin_len != NULL) {
-        *bin_len = bin_pos;
-    }
-    return ret;
-}

package/ios/libsodium-stable/src/libsodium/sodium/core.c

@@ -1,216 +0,0 @@
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#ifdef _WIN32
-# include <windows.h>
-#elif defined(HAVE_PTHREAD)
-# include <pthread.h>
-#endif
-
-#include "core.h"
-#include "crypto_generichash.h"
-#include "crypto_onetimeauth.h"
-#include "crypto_scalarmult.h"
-#include "crypto_stream_chacha20.h"
-#include "crypto_stream_salsa20.h"
-#include "randombytes.h"
-#include "runtime.h"
-#include "utils.h"
-#include "private/implementations.h"
-#include "private/mutex.h"
-
-static volatile int initialized;
-static volatile int locked;
-
-int
-sodium_init(void)
-{
-    if (sodium_crit_enter() != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    if (initialized != 0) {
-        if (sodium_crit_leave() != 0) {
-            return -1; /* LCOV_EXCL_LINE */
-        }
-        return 1;
-    }
-    _sodium_runtime_get_cpu_features();
-    randombytes_stir();
-    _sodium_alloc_init();
-    _crypto_pwhash_argon2_pick_best_implementation();
-    _crypto_generichash_blake2b_pick_best_implementation();
-    _crypto_onetimeauth_poly1305_pick_best_implementation();
-    _crypto_scalarmult_curve25519_pick_best_implementation();
-    _crypto_stream_chacha20_pick_best_implementation();
-    _crypto_stream_salsa20_pick_best_implementation();
-    _crypto_aead_aegis128l_pick_best_implementation();
-    _crypto_aead_aegis256_pick_best_implementation();
-    initialized = 1;
-    if (sodium_crit_leave() != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    return 0;
-}
-
-#ifdef _WIN32
-
-static CRITICAL_SECTION _sodium_lock;
-static volatile LONG    _sodium_lock_initialized;
-
-static int
-_sodium_crit_init(void)
-{
-    LONG status = 0L;
-
-    while ((status = InterlockedCompareExchange(&_sodium_lock_initialized,
-                                                1L, 0L)) == 1L) {
-        Sleep(0);
-    }
-
-    switch (status) {
-    case 0L:
-        InitializeCriticalSection(&_sodium_lock);
-        return InterlockedExchange(&_sodium_lock_initialized, 2L) == 1L ? 0 : -1;
-    case 2L:
-        return 0;
-    default: /* should never be reached */
-        return -1;
-    }
-}
-
-int
-sodium_crit_enter(void)
-{
-    if (_sodium_crit_init() != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    EnterCriticalSection(&_sodium_lock);
-    assert(locked == 0);
-    locked = 1;
-
-    return 0;
-}
-
-int
-sodium_crit_leave(void)
-{
-    if (locked == 0) {
-# ifdef EPERM
-        errno = EPERM;
-# endif
-        return -1;
-    }
-    locked = 0;
-    LeaveCriticalSection(&_sodium_lock);
-
-    return 0;
-}
-
-#elif defined(HAVE_PTHREAD) && !defined(__EMSCRIPTEN__)
-
-static pthread_mutex_t _sodium_lock = PTHREAD_MUTEX_INITIALIZER;
-
-int
-sodium_crit_enter(void)
-{
-    int ret;
-
-    if ((ret = pthread_mutex_lock(&_sodium_lock)) == 0) {
-        assert(locked == 0);
-        locked = 1;
-    }
-    return ret;
-}
-
-int
-sodium_crit_leave(void)
-{
-    if (locked == 0) {
-# ifdef EPERM
-        errno = EPERM;
-# endif
-        return -1;
-    }
-    locked = 0;
-
-    return pthread_mutex_unlock(&_sodium_lock);
-}
-
-#elif defined(HAVE_ATOMIC_OPS) && !defined(__EMSCRIPTEN__)
-
-static volatile int _sodium_lock;
-
-int
-sodium_crit_enter(void)
-{
-# ifdef HAVE_NANOSLEEP
-    struct timespec q;
-    memset(&q, 0, sizeof q);
-# endif
-    while (__sync_lock_test_and_set(&_sodium_lock, 1) != 0) {
-# ifdef HAVE_NANOSLEEP
-        (void) nanosleep(&q, NULL);
-# elif defined(__x86_64__) || defined(__i386__)
-        __asm__ __volatile__ ("pause");
-# endif
-    }
-    return 0;
-}
-
-int
-sodium_crit_leave(void)
-{
-    __sync_lock_release(&_sodium_lock);
-
-    return 0;
-}
-
-#else
-
-int
-sodium_crit_enter(void)
-{
-    return 0;
-}
-
-int
-sodium_crit_leave(void)
-{
-    return 0;
-}
-
-#endif
-
-static void (*_misuse_handler)(void);
-
-void
-sodium_misuse(void)
-{
-    void (*handler)(void);
-
-    (void) sodium_crit_leave();
-    if (sodium_crit_enter() == 0) {
-        handler = _misuse_handler;
-        if (handler != NULL) {
-            handler();
-        }
-    }
-/* LCOV_EXCL_START */
-    abort();
-}
-/* LCOV_EXCL_STOP */
-
-int
-sodium_set_misuse_handler(void (*handler)(void))
-{
-    if (sodium_crit_enter() != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    _misuse_handler = handler;
-    if (sodium_crit_leave() != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    return 0;
-}