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

package/ios/libsodium-stable/src/libsodium/crypto_pwhash/argon2/argon2-core.h

@@ -1,271 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * You should have received a copy of the CC0 Public Domain Dedication along
- * with
- * this software. If not, see
- * <http://creativecommons.org/publicdomain/zero/1.0/>.
- */
-
-#ifndef argon2_core_H
-#define argon2_core_H
-
-#include <string.h>
-
-#include "argon2.h"
-
-/*************************Argon2 internal
- * constants**************************************************/
-
-enum argon2_ctx_constants {
-    /* Version of the algorithm */
-    ARGON2_VERSION_NUMBER = 0x13,
-
-    /* Memory block size in bytes */
-    ARGON2_BLOCK_SIZE      = 1024,
-    ARGON2_QWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8,
-    ARGON2_OWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 16,
-    ARGON2_HWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 32,
-    ARGON2_512BIT_WORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 64,
-
-    /* Number of pseudo-random values generated by one call to Blake in Argon2i
-       to
-       generate reference block positions */
-    ARGON2_ADDRESSES_IN_BLOCK = 128,
-
-    /* Pre-hashing digest length and its extension*/
-    ARGON2_PREHASH_DIGEST_LENGTH = 64,
-    ARGON2_PREHASH_SEED_LENGTH   = 72
-};
-
-/*************************Argon2 internal data
- * types**************************************************/
-
-/*
- * Structure for the (1KB) memory block implemented as 128 64-bit words.
- * Memory blocks can be copied, XORed. Internal words can be accessed by [] (no
- * bounds checking).
- */
-typedef struct block_ {
-    uint64_t v[ARGON2_QWORDS_IN_BLOCK];
-} block;
-
-typedef struct block_region_ {
-    void * base;
-    block *memory;
-    size_t size;
-} block_region;
-
-/*****************Functions that work with the block******************/
-
-/* Initialize each byte of the block with @in */
-static inline void
-init_block_value(block *b, uint8_t in)
-{
-    memset(b->v, in, sizeof(b->v));
-}
-
-/* Copy block @src to block @dst */
-static inline void
-copy_block(block *dst, const block *src)
-{
-    memcpy(dst->v, src->v, sizeof(uint64_t) * ARGON2_QWORDS_IN_BLOCK);
-}
-
-/* XOR @src onto @dst bytewise */
-static inline void
-xor_block(block *dst, const block *src)
-{
-    int i;
-    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
-        dst->v[i] ^= src->v[i];
-    }
-}
-
-/*
- * Argon2 instance: memory pointer, number of passes, amount of memory, type,
- * and derived values.
- * Used to evaluate the number and location of blocks to construct in each
- * thread
- */
-typedef struct Argon2_instance_t {
-    block_region *region;        /* Memory region pointer */
-    uint64_t     *pseudo_rands;
-    uint32_t      passes;        /* Number of passes */
-    uint32_t      current_pass;
-    uint32_t      memory_blocks; /* Number of blocks in memory */
-    uint32_t      segment_length;
-    uint32_t      lane_length;
-    uint32_t      lanes;
-    uint32_t      threads;
-    argon2_type   type;
-    int           print_internals; /* whether to print the memory blocks */
-} argon2_instance_t;
-
-/*
- * Argon2 position: where we construct the block right now. Used to distribute
- * work between threads.
- */
-typedef struct Argon2_position_t {
-    uint32_t pass;
-    uint32_t lane;
-    uint8_t  slice;
-    uint32_t index;
-} argon2_position_t;
-
-/*Struct that holds the inputs for thread handling FillSegment*/
-typedef struct Argon2_thread_data {
-    argon2_instance_t *instance_ptr;
-    argon2_position_t  pos;
-} argon2_thread_data;
-
-/*************************Argon2 core
- * functions**************************************************/
-
-/*
- * Computes absolute position of reference block in the lane following a skewed
- * distribution and using a pseudo-random value as input
- * @param instance Pointer to the current instance
- * @param position Pointer to the current position
- * @param pseudo_rand 32-bit pseudo-random value used to determine the position
- * @param same_lane Indicates if the block will be taken from the current lane.
- * If so we can reference the current segment
- * @pre All pointers must be valid
- */
-static uint32_t index_alpha(const argon2_instance_t *instance,
-                            const argon2_position_t *position, uint32_t pseudo_rand,
-                            int same_lane)
-{
-    /*
-     * Pass 0:
-     *      This lane : all already finished segments plus already constructed
-     * blocks in this segment
-     *      Other lanes : all already finished segments
-     * Pass 1+:
-     *      This lane : (SYNC_POINTS - 1) last segments plus already constructed
-     * blocks in this segment
-     *      Other lanes : (SYNC_POINTS - 1) last segments
-     */
-    uint32_t reference_area_size;
-    uint64_t relative_position;
-    uint32_t start_position, absolute_position;
-
-    if (position->pass == 0) {
-        /* First pass */
-        if (position->slice == 0) {
-            /* First slice */
-            reference_area_size =
-                position->index - 1; /* all but the previous */
-        } else {
-            if (same_lane) {
-                /* The same lane => add current segment */
-                reference_area_size =
-                    position->slice * instance->segment_length +
-                    position->index - 1;
-            } else {
-                reference_area_size =
-                    position->slice * instance->segment_length +
-                    ((position->index == 0) ? (-1) : 0);
-            }
-        }
-    } else {
-        /* Second pass */
-        if (same_lane) {
-            reference_area_size = instance->lane_length -
-                                  instance->segment_length + position->index -
-                                  1;
-        } else {
-            reference_area_size = instance->lane_length -
-                                  instance->segment_length +
-                                  ((position->index == 0) ? (-1) : 0);
-        }
-    }
-
-    /* 1.2.4. Mapping pseudo_rand to 0..<reference_area_size-1> and produce
-     * relative position */
-    relative_position = pseudo_rand;
-    relative_position = relative_position * relative_position >> 32;
-    relative_position = reference_area_size - 1 -
-                        (reference_area_size * relative_position >> 32);
-
-    /* 1.2.5 Computing starting position */
-    start_position = 0;
-
-    if (position->pass != 0) {
-        start_position = (position->slice == ARGON2_SYNC_POINTS - 1)
-                             ? 0
-                             : (position->slice + 1) * instance->segment_length;
-    }
-
-    /* 1.2.6. Computing absolute position */
-    absolute_position = (start_position + relative_position) %
-                        instance->lane_length; /* absolute position */
-    return absolute_position;
-}
-
-/*
- * Function that validates all inputs against predefined restrictions and return
- * an error code
- * @param context Pointer to current Argon2 context
- * @return ARGON2_OK if everything is all right, otherwise one of error codes
- * (all defined in <argon2.h>
- */
-int argon2_validate_inputs(const argon2_context *context);
-
-/*
- * Function allocates memory, hashes the inputs with Blake,  and creates first
- * two blocks. Returns the pointer to the main memory with 2 blocks per lane
- * initialized
- * @param  context  Pointer to the Argon2 internal structure containing memory
- * pointer, and parameters for time and space requirements.
- * @param  instance Current Argon2 instance
- * @return Zero if successful, -1 if memory failed to allocate. @context->state
- * will be modified if successful.
- */
-int argon2_initialize(argon2_instance_t *instance, argon2_context *context);
-
-/*
- * XORing the last block of each lane, hashing it, making the tag. Deallocates
- * the memory.
- * @param context Pointer to current Argon2 context (use only the out parameters
- * from it)
- * @param instance Pointer to current instance of Argon2
- * @pre instance->state must point to necessary amount of memory
- * @pre context->out must point to outlen bytes of memory
- * @pre if context->free_cbk is not NULL, it should point to a function that
- * deallocates memory
- */
-void argon2_finalize(const argon2_context *context,
-                     argon2_instance_t *instance);
-
-/*
- * Function that fills the segment using previous segments also from other
- * threads
- * @param instance Pointer to the current instance
- * @param position Current position
- * @pre all block pointers must be valid
- */
-typedef void (*fill_segment_fn)(const argon2_instance_t *instance,
-                                argon2_position_t        position);
-void argon2_fill_segment_avx512f(const argon2_instance_t *instance,
-                                 argon2_position_t        position);
-void argon2_fill_segment_avx2(const argon2_instance_t *instance,
-                              argon2_position_t        position);
-void argon2_fill_segment_ssse3(const argon2_instance_t *instance,
-                               argon2_position_t        position);
-void argon2_fill_segment_ref(const argon2_instance_t *instance,
-                             argon2_position_t        position);
-
-/*
- * Function that fills the entire memory t_cost times based on the first two
- * blocks in each lane
- * @param instance Pointer to the current instance
- * @return Zero if successful, -1 if memory failed to allocate
- */
-void argon2_fill_memory_blocks(argon2_instance_t *instance, uint32_t pass);
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_pwhash/argon2/argon2-encoding.c

@@ -1,306 +0,0 @@
-#include "argon2-encoding.h"
-#include "argon2-core.h"
-#include "utils.h"
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/*
- * Example code for a decoder and encoder of "hash strings", with Argon2
- * parameters.
- *
- * The code was originally written by Thomas Pornin <pornin@bolet.org>,
- * to whom comments and remarks may be sent. It is released under what
- * should amount to Public Domain or its closest equivalent; the
- * following mantra is supposed to incarnate that fact with all the
- * proper legal rituals:
- *
- * ---------------------------------------------------------------------
- * This file is provided under the terms of Creative Commons CC0 1.0
- * Public Domain Dedication. To the extent possible under law, the
- * author (Thomas Pornin) has waived all copyright and related or
- * neighboring rights to this file. This work is published from: Canada.
- * ---------------------------------------------------------------------
- *
- * Copyright (c) 2015 Thomas Pornin
- */
-
-/* ==================================================================== */
-
-/*
- * Decode decimal integer from 'str'; the value is written in '*v'.
- * Returned value is a pointer to the next non-decimal character in the
- * string. If there is no digit at all, or the value encoding is not
- * minimal (extra leading zeros), or the value does not fit in an
- * 'unsigned long', then NULL is returned.
- */
-static const char *
-decode_decimal(const char *str, unsigned long *v)
-{
-    const char    *orig;
-    unsigned long  acc;
-
-    acc = 0;
-    for (orig = str;; str++) {
-        int c;
-
-        c = *str;
-        if (c < '0' || c > '9') {
-            break;
-        }
-        c -= '0';
-        if (acc > (ULONG_MAX / 10)) {
-            return NULL;
-        }
-        acc *= 10;
-        if ((unsigned long) c > (ULONG_MAX - acc)) {
-            return NULL;
-        }
-        acc += (unsigned long) c;
-    }
-    if (str == orig || (*orig == '0' && str != (orig + 1))) {
-        return NULL;
-    }
-    *v = acc;
-    return str;
-}
-
-/* ==================================================================== */
-/*
- * Code specific to Argon2.
- *
- * The code below applies the following format:
- *
- *  $argon2<T>[$v=<num>]$m=<num>,t=<num>,p=<num>$<bin>$<bin>
- *
- * where <T> is either 'i', <num> is a decimal integer (positive, fits in an
- * 'unsigned long') and <bin> is Base64-encoded data (no '=' padding characters,
- * no newline or whitespace).
- *
- * The last two binary chunks (encoded in Base64) are, in that order,
- * the salt and the output. Both are required. The binary salt length and the
- * output length must be in the allowed ranges defined in argon2.h.
- *
- * The ctx struct must contain buffers large enough to hold the salt and pwd
- * when it is fed into argon2_decode_string.
- */
-
-/*
- * Decode an Argon2i hash string into the provided structure 'ctx'.
- * Returned value is ARGON2_OK on success.
- */
-int
-argon2_decode_string(argon2_context *ctx, const char *str, argon2_type type)
-{
-/* Prefix checking */
-#define CC(prefix)                               \
-    do {                                         \
-        size_t cc_len = strlen(prefix);          \
-        if (strncmp(str, prefix, cc_len) != 0) { \
-            return ARGON2_DECODING_FAIL;         \
-        }                                        \
-        str += cc_len;                           \
-    } while ((void) 0, 0)
-
-/* Optional prefix checking with supplied code */
-#define CC_opt(prefix, code)                     \
-    do {                                         \
-        size_t cc_len = strlen(prefix);          \
-        if (strncmp(str, prefix, cc_len) == 0) { \
-            str += cc_len;                       \
-            {                                    \
-                code;                            \
-            }                                    \
-        }                                        \
-    } while ((void) 0, 0)
-
-/* Decoding prefix into decimal */
-#define DECIMAL(x)                         \
-    do {                                   \
-        unsigned long dec_x;               \
-        str = decode_decimal(str, &dec_x); \
-        if (str == NULL) {                 \
-            return ARGON2_DECODING_FAIL;   \
-        }                                  \
-        (x) = dec_x;                       \
-    } while ((void) 0, 0)
-
-/* Decoding prefix into uint32_t decimal */
-#define DECIMAL_U32(x)                           \
-    do {                                         \
-        unsigned long dec_x;                     \
-        str = decode_decimal(str, &dec_x);       \
-        if (str == NULL || dec_x > UINT32_MAX) { \
-            return ARGON2_DECODING_FAIL;         \
-        }                                        \
-        (x) = (uint32_t)dec_x;                   \
-    } while ((void)0, 0)
-
-/* Decoding base64 into a binary buffer */
-#define BIN(buf, max_len, len)                                                   \
-    do {                                                                         \
-        size_t bin_len = (max_len);                                              \
-        const char *str_end;                                                     \
-        if (sodium_base642bin((buf), (max_len), str, strlen(str), NULL,          \
-                              &bin_len, &str_end,                                \
-                              sodium_base64_VARIANT_ORIGINAL_NO_PADDING) != 0 || \
-            bin_len > UINT32_MAX) {                                              \
-            return ARGON2_DECODING_FAIL;                                         \
-        }                                                                        \
-        (len) = (uint32_t) bin_len;                                              \
-        str = str_end;                                                           \
-    } while ((void) 0, 0)
-
-    size_t        maxsaltlen = ctx->saltlen;
-    size_t        maxoutlen  = ctx->outlen;
-    int           validation_result;
-    uint32_t      version = 0;
-
-    ctx->saltlen = 0;
-    ctx->outlen  = 0;
-
-    if (type == Argon2_id) {
-        CC("$argon2id");
-    } else if (type == Argon2_i) {
-        CC("$argon2i");
-    } else {
-        return ARGON2_INCORRECT_TYPE;
-    }
-    CC("$v=");
-    DECIMAL_U32(version);
-    if (version != ARGON2_VERSION_NUMBER) {
-        return ARGON2_INCORRECT_TYPE;
-    }
-    CC("$m=");
-    DECIMAL_U32(ctx->m_cost);
-    if (ctx->m_cost > UINT32_MAX) {
-        return ARGON2_INCORRECT_TYPE;
-    }
-    CC(",t=");
-    DECIMAL_U32(ctx->t_cost);
-    if (ctx->t_cost > UINT32_MAX) {
-        return ARGON2_INCORRECT_TYPE;
-    }
-    CC(",p=");
-    DECIMAL_U32(ctx->lanes);
-    if (ctx->lanes > UINT32_MAX) {
-        return ARGON2_INCORRECT_TYPE;
-    }
-    ctx->threads = ctx->lanes;
-
-    CC("$");
-    BIN(ctx->salt, maxsaltlen, ctx->saltlen);
-    CC("$");
-    BIN(ctx->out, maxoutlen, ctx->outlen);
-    validation_result = argon2_validate_inputs(ctx);
-    if (validation_result != ARGON2_OK) {
-        return validation_result;
-    }
-    if (*str == 0) {
-        return ARGON2_OK;
-    }
-    return ARGON2_DECODING_FAIL;
-
-#undef CC
-#undef CC_opt
-#undef DECIMAL
-#undef BIN
-}
-
-#define U32_STR_MAXSIZE 11U
-
-static void
-u32_to_string(char *str, uint32_t x)
-{
-    char   tmp[U32_STR_MAXSIZE - 1U];
-    size_t i;
-
-    i = sizeof tmp;
-    do {
-        tmp[--i] = (x % (uint32_t) 10U) + '0';
-        x /= (uint32_t) 10U;
-    } while (x != 0U && i != 0U);
-    memcpy(str, &tmp[i], (sizeof tmp) - i);
-    str[(sizeof tmp) - i] = 0;
-}
-
-/*
- * Encode an argon2i hash string into the provided buffer. 'dst_len'
- * contains the size, in characters, of the 'dst' buffer; if 'dst_len'
- * is less than the number of required characters (including the
- * terminating 0), then this function returns 0.
- *
- * If pp->output_len is 0, then the hash string will be a salt string
- * (no output). if pp->salt_len is also 0, then the string will be a
- * parameter-only string (no salt and no output).
- *
- * On success, ARGON2_OK is returned.
- */
-int
-argon2_encode_string(char *dst, size_t dst_len, argon2_context *ctx,
-                     argon2_type type)
-{
-#define SS(str)                          \
-    do {                                 \
-        size_t pp_len = strlen(str);     \
-        if (pp_len >= dst_len) {         \
-            return ARGON2_ENCODING_FAIL; \
-        }                                \
-        memcpy(dst, str, pp_len + 1);    \
-        dst += pp_len;                   \
-        dst_len -= pp_len;               \
-    } while ((void) 0, 0)
-
-#define SX(x)                      \
-    do {                           \
-        char tmp[U32_STR_MAXSIZE]; \
-        u32_to_string(tmp, x);     \
-        SS(tmp);                   \
-    } while ((void) 0, 0)
-
-#define SB(buf, len)                                                                \
-    do {                                                                            \
-        size_t sb_len;                                                              \
-        if (sodium_bin2base64(dst, dst_len, (buf), (len),                           \
-                              sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == NULL) { \
-            return ARGON2_ENCODING_FAIL;                                            \
-        }                                                                           \
-        sb_len = strlen(dst);                                                       \
-        dst += sb_len;                                                              \
-        dst_len -= sb_len;                                                          \
-    } while ((void) 0, 0)
-
-    int validation_result;
-
-    switch (type) {
-    case Argon2_id:
-        SS("$argon2id$v="); break;
-    case Argon2_i:
-        SS("$argon2i$v="); break;
-    default:
-        return ARGON2_ENCODING_FAIL;
-    }
-    validation_result = argon2_validate_inputs(ctx);
-    if (validation_result != ARGON2_OK) {
-        return validation_result;
-    }
-    SX(ARGON2_VERSION_NUMBER);
-    SS("$m=");
-    SX(ctx->m_cost);
-    SS(",t=");
-    SX(ctx->t_cost);
-    SS(",p=");
-    SX(ctx->lanes);
-
-    SS("$");
-    SB(ctx->salt, ctx->saltlen);
-
-    SS("$");
-    SB(ctx->out, ctx->outlen);
-    return ARGON2_OK;
-
-#undef SS
-#undef SX
-#undef SB
-}

package/ios/libsodium-stable/src/libsodium/crypto_pwhash/argon2/argon2-encoding.h

@@ -1,34 +0,0 @@
-#ifndef argon2_encoding_H
-#define argon2_encoding_H
-
-#include "argon2.h"
-
-/*
- * encode an Argon2 hash string into the provided buffer. 'dst_len'
- * contains the size, in characters, of the 'dst' buffer; if 'dst_len'
- * is less than the number of required characters (including the
- * terminating 0), then this function returns 0.
- *
- * if ctx->outlen is 0, then the hash string will be a salt string
- * (no output). if ctx->saltlen is also 0, then the string will be a
- * parameter-only string (no salt and no output).
- *
- * On success, ARGON2_OK is returned.
- *
- * No other parameters are checked
- */
-int argon2_encode_string(char *dst, size_t dst_len, argon2_context *ctx,
-                         argon2_type type);
-
-/*
- * Decodes an Argon2 hash string into the provided structure 'ctx'.
- * The fields ctx.saltlen, ctx.adlen, ctx.outlen set the maximal salt, ad, out
- * length values
- * that are allowed; invalid input string causes an error
- *
- * Returned value is ARGON2_OK on success.
- */
-int argon2_decode_string(argon2_context *ctx, const char *str,
-                         argon2_type type);
-
-#endif