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

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

@@ -1,283 +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/>.
- */
-
-#include <limits.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "randombytes.h"
-#include "utils.h"
-
-#include "argon2-core.h"
-#include "argon2-encoding.h"
-#include "argon2.h"
-
-int
-argon2_ctx(argon2_context *context, argon2_type type)
-{
-    /* 1. Validate all inputs */
-    int               result = argon2_validate_inputs(context);
-    uint32_t          memory_blocks, segment_length;
-    uint32_t          pass;
-    argon2_instance_t instance;
-
-    if (ARGON2_OK != result) {
-        return result;
-    }
-
-    if (type != Argon2_id && type != Argon2_i) {
-        return ARGON2_INCORRECT_TYPE;
-    }
-
-    /* 2. Align memory size */
-    /* Minimum memory_blocks = 8L blocks, where L is the number of lanes */
-    memory_blocks = context->m_cost;
-
-    if (memory_blocks < 2 * ARGON2_SYNC_POINTS * context->lanes) {
-        memory_blocks = 2 * ARGON2_SYNC_POINTS * context->lanes;
-    }
-
-    segment_length = memory_blocks / (context->lanes * ARGON2_SYNC_POINTS);
-    /* Ensure that all segments have equal length */
-    memory_blocks = segment_length * (context->lanes * ARGON2_SYNC_POINTS);
-
-    instance.region         = NULL;
-    instance.passes         = context->t_cost;
-    instance.current_pass   = ~ 0U;
-    instance.memory_blocks  = memory_blocks;
-    instance.segment_length = segment_length;
-    instance.lane_length    = segment_length * ARGON2_SYNC_POINTS;
-    instance.lanes          = context->lanes;
-    instance.threads        = context->threads;
-    instance.type           = type;
-
-    /* 3. Initialization: Hashing inputs, allocating memory, filling first
-     * blocks
-     */
-    result = argon2_initialize(&instance, context);
-
-    if (ARGON2_OK != result) {
-        return result;
-    }
-
-    /* 4. Filling memory */
-    for (pass = 0; pass < instance.passes; pass++) {
-        argon2_fill_memory_blocks(&instance, pass);
-    }
-
-    /* 5. Finalization */
-    argon2_finalize(context, &instance);
-
-    return ARGON2_OK;
-}
-
-int
-argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
-            const uint32_t parallelism, const void *pwd, const size_t pwdlen,
-            const void *salt, const size_t saltlen, void *hash,
-            const size_t hashlen, char *encoded, const size_t encodedlen,
-            argon2_type type)
-{
-    argon2_context context;
-    int            result;
-    uint8_t       *out;
-
-    if (hash != NULL) {
-        randombytes_buf(hash, hashlen);
-    }
-
-    if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
-        return ARGON2_PWD_TOO_LONG;
-    }
-
-    if (hashlen > ARGON2_MAX_OUTLEN) {
-        return ARGON2_OUTPUT_TOO_LONG;
-    }
-
-    if (saltlen > ARGON2_MAX_SALT_LENGTH) {
-        return ARGON2_SALT_TOO_LONG;
-    }
-
-    out = (uint8_t *) malloc(hashlen);
-    if (!out) {
-        return ARGON2_MEMORY_ALLOCATION_ERROR;
-    }
-
-    context.out       = (uint8_t *) out;
-    context.outlen    = (uint32_t) hashlen;
-    context.pwd       = (uint8_t *) pwd;
-    context.pwdlen    = (uint32_t) pwdlen;
-    context.salt      = (uint8_t *) salt;
-    context.saltlen   = (uint32_t) saltlen;
-    context.secret    = NULL;
-    context.secretlen = 0;
-    context.ad        = NULL;
-    context.adlen     = 0;
-    context.t_cost    = t_cost;
-    context.m_cost    = m_cost;
-    context.lanes     = parallelism;
-    context.threads   = parallelism;
-    context.flags     = ARGON2_DEFAULT_FLAGS;
-
-    result = argon2_ctx(&context, type);
-
-    if (result != ARGON2_OK) {
-        sodium_memzero(out, hashlen);
-        free(out);
-        return result;
-    }
-
-    /* if encoding requested, write it */
-    if (encoded && encodedlen) {
-        if (argon2_encode_string(encoded, encodedlen,
-                                 &context, type) != ARGON2_OK) {
-            sodium_memzero(out, hashlen);
-            sodium_memzero(encoded, encodedlen);
-            free(out);
-            return ARGON2_ENCODING_FAIL;
-        }
-    }
-
-    /* if raw hash requested, write it */
-    if (hash) {
-        memcpy(hash, out, hashlen);
-    }
-
-    sodium_memzero(out, hashlen);
-    free(out);
-
-    return ARGON2_OK;
-}
-
-int
-argon2i_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
-                     const uint32_t parallelism, const void *pwd,
-                     const size_t pwdlen, const void *salt,
-                     const size_t saltlen, const size_t hashlen, char *encoded,
-                     const size_t encodedlen)
-{
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       NULL, hashlen, encoded, encodedlen, Argon2_i);
-}
-
-int
-argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
-                 const uint32_t parallelism, const void *pwd,
-                 const size_t pwdlen, const void *salt, const size_t saltlen,
-                 void *hash, const size_t hashlen)
-{
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       hash, hashlen, NULL, 0, Argon2_i);
-}
-
-int
-argon2id_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
-                      const uint32_t parallelism, const void *pwd,
-                      const size_t pwdlen, const void *salt,
-                      const size_t saltlen, const size_t hashlen, char *encoded,
-                      const size_t encodedlen)
-{
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       NULL, hashlen, encoded, encodedlen, Argon2_id);
-}
-
-int
-argon2id_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
-                  const uint32_t parallelism, const void *pwd,
-                  const size_t pwdlen, const void *salt, const size_t saltlen,
-                  void *hash, const size_t hashlen)
-{
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       hash, hashlen, NULL, 0, Argon2_id);
-}
-
-int
-argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
-              argon2_type type)
-{
-    argon2_context ctx;
-    uint8_t       *out;
-    int            decode_result;
-    int            ret;
-    size_t         encoded_len;
-
-    memset(&ctx, 0, sizeof ctx);
-
-    ctx.pwd       = NULL;
-    ctx.pwdlen    = 0;
-    ctx.secret    = NULL;
-    ctx.secretlen = 0;
-
-    /* max values, to be updated in argon2_decode_string */
-    encoded_len = strlen(encoded);
-    if (encoded_len > UINT32_MAX) {
-        return ARGON2_DECODING_LENGTH_FAIL;
-    }
-    ctx.adlen   = (uint32_t) encoded_len;
-    ctx.saltlen = (uint32_t) encoded_len;
-    ctx.outlen  = (uint32_t) encoded_len;
-
-    ctx.ad   = (uint8_t *) malloc(ctx.adlen);
-    ctx.salt = (uint8_t *) malloc(ctx.saltlen);
-    ctx.out  = (uint8_t *) malloc(ctx.outlen);
-    if (!ctx.out || !ctx.salt || !ctx.ad) {
-        free(ctx.ad);
-        free(ctx.salt);
-        free(ctx.out);
-        return ARGON2_MEMORY_ALLOCATION_ERROR;
-    }
-    out = (uint8_t *) malloc(ctx.outlen);
-    if (!out) {
-        free(ctx.ad);
-        free(ctx.salt);
-        free(ctx.out);
-        return ARGON2_MEMORY_ALLOCATION_ERROR;
-    }
-
-    decode_result = argon2_decode_string(&ctx, encoded, type);
-    if (decode_result != ARGON2_OK) {
-        free(ctx.ad);
-        free(ctx.salt);
-        free(ctx.out);
-        free(out);
-        return decode_result;
-    }
-
-    ret = argon2_hash(ctx.t_cost, ctx.m_cost, ctx.threads, pwd, pwdlen,
-                      ctx.salt, ctx.saltlen, out, ctx.outlen, NULL, 0, type);
-
-    free(ctx.ad);
-    free(ctx.salt);
-
-    if (ret == ARGON2_OK && sodium_memcmp(out, ctx.out, ctx.outlen) != 0) {
-        ret = ARGON2_VERIFY_MISMATCH;
-    }
-    free(out);
-    free(ctx.out);
-
-    return ret;
-}
-
-int
-argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen)
-{
-    return argon2_verify(encoded, pwd, pwdlen, Argon2_i);
-}
-
-int
-argon2id_verify(const char *encoded, const void *pwd, const size_t pwdlen)
-{
-    return argon2_verify(encoded, pwd, pwdlen, Argon2_id);
-}

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

@@ -1,305 +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_H
-#define argon2_H
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-/*
- * Argon2 input parameter restrictions
- */
-
-/* Minimum and maximum number of lanes (degree of parallelism) */
-#define ARGON2_MIN_LANES UINT32_C(1)
-#define ARGON2_MAX_LANES UINT32_C(0xFFFFFF)
-
-/* Minimum and maximum number of threads */
-#define ARGON2_MIN_THREADS UINT32_C(1)
-#define ARGON2_MAX_THREADS UINT32_C(0xFFFFFF)
-
-/* Number of synchronization points between lanes per pass */
-#define ARGON2_SYNC_POINTS UINT32_C(4)
-
-/* Minimum and maximum digest size in bytes */
-#define ARGON2_MIN_OUTLEN UINT32_C(16)
-#define ARGON2_MAX_OUTLEN UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum number of memory blocks (each of BLOCK_SIZE bytes) */
-#define ARGON2_MIN_MEMORY (2 * ARGON2_SYNC_POINTS) /* 2 blocks per slice */
-
-#define ARGON2_MIN(a, b) ((a) < (b) ? (a) : (b))
-/* Max memory size is half the addressing space, topping at 2^32 blocks (4 TB)
- */
-#define ARGON2_MAX_MEMORY_BITS \
-    ARGON2_MIN(UINT32_C(32), (sizeof(void *) * CHAR_BIT - 10 - 1))
-#define ARGON2_MAX_MEMORY \
-    ARGON2_MIN(UINT32_C(0xFFFFFFFF), UINT64_C(1) << ARGON2_MAX_MEMORY_BITS)
-
-/* Minimum and maximum number of passes */
-#define ARGON2_MIN_TIME UINT32_C(1)
-#define ARGON2_MAX_TIME UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum password length in bytes */
-#define ARGON2_MIN_PWD_LENGTH UINT32_C(0)
-#define ARGON2_MAX_PWD_LENGTH UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum associated data length in bytes */
-#define ARGON2_MIN_AD_LENGTH UINT32_C(0)
-#define ARGON2_MAX_AD_LENGTH UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum salt length in bytes */
-#define ARGON2_MIN_SALT_LENGTH UINT32_C(8)
-#define ARGON2_MAX_SALT_LENGTH UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum key length in bytes */
-#define ARGON2_MIN_SECRET UINT32_C(0)
-#define ARGON2_MAX_SECRET UINT32_C(0xFFFFFFFF)
-
-#define ARGON2_FLAG_CLEAR_PASSWORD (UINT32_C(1) << 0)
-#define ARGON2_FLAG_CLEAR_SECRET (UINT32_C(1) << 1)
-#define ARGON2_FLAG_CLEAR_MEMORY (UINT32_C(1) << 2)
-#define ARGON2_DEFAULT_FLAGS (UINT32_C(0))
-
-/* Error codes */
-typedef enum Argon2_ErrorCodes {
-    ARGON2_OK = 0,
-
-    ARGON2_OUTPUT_PTR_NULL = -1,
-
-    ARGON2_OUTPUT_TOO_SHORT = -2,
-    ARGON2_OUTPUT_TOO_LONG  = -3,
-
-    ARGON2_PWD_TOO_SHORT = -4,
-    ARGON2_PWD_TOO_LONG  = -5,
-
-    ARGON2_SALT_TOO_SHORT = -6,
-    ARGON2_SALT_TOO_LONG  = -7,
-
-    ARGON2_AD_TOO_SHORT = -8,
-    ARGON2_AD_TOO_LONG  = -9,
-
-    ARGON2_SECRET_TOO_SHORT = -10,
-    ARGON2_SECRET_TOO_LONG  = -11,
-
-    ARGON2_TIME_TOO_SMALL = -12,
-    ARGON2_TIME_TOO_LARGE = -13,
-
-    ARGON2_MEMORY_TOO_LITTLE = -14,
-    ARGON2_MEMORY_TOO_MUCH   = -15,
-
-    ARGON2_LANES_TOO_FEW  = -16,
-    ARGON2_LANES_TOO_MANY = -17,
-
-    ARGON2_PWD_PTR_MISMATCH    = -18, /* NULL ptr with non-zero length */
-    ARGON2_SALT_PTR_MISMATCH   = -19, /* NULL ptr with non-zero length */
-    ARGON2_SECRET_PTR_MISMATCH = -20, /* NULL ptr with non-zero length */
-    ARGON2_AD_PTR_MISMATCH     = -21, /* NULL ptr with non-zero length */
-
-    ARGON2_MEMORY_ALLOCATION_ERROR = -22,
-
-    ARGON2_FREE_MEMORY_CBK_NULL     = -23,
-    ARGON2_ALLOCATE_MEMORY_CBK_NULL = -24,
-
-    ARGON2_INCORRECT_PARAMETER = -25,
-    ARGON2_INCORRECT_TYPE      = -26,
-
-    ARGON2_OUT_PTR_MISMATCH = -27,
-
-    ARGON2_THREADS_TOO_FEW  = -28,
-    ARGON2_THREADS_TOO_MANY = -29,
-
-    ARGON2_MISSING_ARGS = -30,
-
-    ARGON2_ENCODING_FAIL = -31,
-
-    ARGON2_DECODING_FAIL = -32,
-
-    ARGON2_THREAD_FAIL = -33,
-
-    ARGON2_DECODING_LENGTH_FAIL = -34,
-
-    ARGON2_VERIFY_MISMATCH = -35
-} argon2_error_codes;
-
-/* Argon2 external data structures */
-
-/*
- * Context: structure to hold Argon2 inputs:
- * output array and its length,
- * password and its length,
- * salt and its length,
- * secret and its length,
- * associated data and its length,
- * number of passes, amount of used memory (in KBytes, can be rounded up a bit)
- * number of parallel threads that will be run.
- * All the parameters above affect the output hash value.
- * Additionally, two function pointers can be provided to allocate and
- * deallocate the memory (if NULL, memory will be allocated internally).
- * Also, three flags indicate whether to erase password, secret as soon as they
- * are pre-hashed (and thus not needed anymore), and the entire memory
- *****
- * Simplest situation: you have output array out[8], password is stored in
- * pwd[32], salt is stored in salt[16], you do not have keys nor associated
- *data.
- * You need to spend 1 GB of RAM and you run 5 passes of Argon2 with 4 parallel
- *lanes.
- * You want to erase the password, but you're OK with last pass not being
- *erased.
- * You want to use the default memory allocator.
- * Then you initialize:
- * Argon2_Context(out,8,pwd,32,salt,16,NULL,0,NULL,0,5,1<<20,4,4,NULL,NULL,true,false,false,false).
- */
-typedef struct Argon2_Context {
-    uint8_t *out;    /* output array */
-    uint32_t outlen; /* digest length */
-
-    uint8_t *pwd;    /* password array */
-    uint32_t pwdlen; /* password length */
-
-    uint8_t *salt;    /* salt array */
-    uint32_t saltlen; /* salt length */
-
-    uint8_t *secret;    /* key array */
-    uint32_t secretlen; /* key length */
-
-    uint8_t *ad;    /* associated data array */
-    uint32_t adlen; /* associated data length */
-
-    uint32_t t_cost;  /* number of passes */
-    uint32_t m_cost;  /* amount of memory requested (KB) */
-    uint32_t lanes;   /* number of lanes */
-    uint32_t threads; /* maximum number of threads */
-
-    uint32_t flags; /* array of bool options */
-} argon2_context;
-
-/* Argon2 primitive type */
-typedef enum Argon2_type { Argon2_i = 1, Argon2_id = 2 } argon2_type;
-
-/*
- * Function that performs memory-hard hashing with certain degree of parallelism
- * @param  context  Pointer to the Argon2 internal structure
- * @return Error code if smth is wrong, ARGON2_OK otherwise
- */
-int argon2_ctx(argon2_context *context, argon2_type type);
-
-/**
- * Hashes a password with Argon2i, producing an encoded hash
- * @param t_cost Number of iterations
- * @param m_cost Sets memory usage to m_cost kibibytes
- * @param parallelism Number of threads and compute lanes
- * @param pwd Pointer to password
- * @param pwdlen Password size in bytes
- * @param salt Pointer to salt
- * @param saltlen Salt size in bytes
- * @param hashlen Desired length of the hash in bytes
- * @param encoded Buffer where to write the encoded hash
- * @param encodedlen Size of the buffer (thus max size of the encoded hash)
- * @pre   Different parallelism levels will give different results
- * @pre   Returns ARGON2_OK if successful
- */
-int argon2i_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
-                         const uint32_t parallelism, const void *pwd,
-                         const size_t pwdlen, const void *salt,
-                         const size_t saltlen, const size_t hashlen,
-                         char *encoded, const size_t encodedlen);
-
-/**
- * Hashes a password with Argon2id, producing an encoded hash
- * @param t_cost Number of iterations
- * @param m_cost Sets memory usage to m_cost kibibytes
- * @param parallelism Number of threads and compute lanes
- * @param pwd Pointer to password
- * @param pwdlen Password size in bytes
- * @param salt Pointer to salt
- * @param saltlen Salt size in bytes
- * @param hashlen Desired length of the hash in bytes
- * @param encoded Buffer where to write the encoded hash
- * @param encodedlen Size of the buffer (thus max size of the encoded hash)
- * @pre   Different parallelism levels will give different results
- * @pre   Returns ARGON2_OK if successful
- */
-int argon2id_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
-                          const uint32_t parallelism, const void *pwd,
-                          const size_t pwdlen, const void *salt,
-                          const size_t saltlen, const size_t hashlen,
-                          char *encoded, const size_t encodedlen);
-
-/**
- * Hashes a password with Argon2i, producing a raw hash
- * @param t_cost Number of iterations
- * @param m_cost Sets memory usage to m_cost kibibytes
- * @param parallelism Number of threads and compute lanes
- * @param pwd Pointer to password
- * @param pwdlen Password size in bytes
- * @param salt Pointer to salt
- * @param saltlen Salt size in bytes
- * @param hash Buffer where to write the raw hash
- * @param hashlen Desired length of the hash in bytes
- * @pre   Different parallelism levels will give different results
- * @pre   Returns ARGON2_OK if successful
- */
-int argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
-                     const uint32_t parallelism, const void *pwd,
-                     const size_t pwdlen, const void *salt,
-                     const size_t saltlen, void *hash, const size_t hashlen);
-
-/**
- * Hashes a password with Argon2id, producing a raw hash
- * @param t_cost Number of iterations
- * @param m_cost Sets memory usage to m_cost kibibytes
- * @param parallelism Number of threads and compute lanes
- * @param pwd Pointer to password
- * @param pwdlen Password size in bytes
- * @param salt Pointer to salt
- * @param saltlen Salt size in bytes
- * @param hash Buffer where to write the raw hash
- * @param hashlen Desired length of the hash in bytes
- * @pre   Different parallelism levels will give different results
- * @pre   Returns ARGON2_OK if successful
- */
-int argon2id_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
-                      const uint32_t parallelism, const void *pwd,
-                      const size_t pwdlen, const void *salt,
-                      const size_t saltlen, void *hash, const size_t hashlen);
-
-/* generic function underlying the above ones */
-int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
-                const uint32_t parallelism, const void *pwd,
-                const size_t pwdlen, const void *salt, const size_t saltlen,
-                void *hash, const size_t hashlen, char *encoded,
-                const size_t encodedlen, argon2_type type);
-
-/**
- * Verifies a password against an encoded string
- * Encoded string is restricted as in argon2_validate_inputs()
- * @param encoded String encoding parameters, salt, hash
- * @param pwd Pointer to password
- * @pre   Returns ARGON2_OK if successful
- */
-int argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen);
-
-/**
- * Verifies a password against an encoded string
- * Encoded string is restricted as in argon2_validate_inputs()
- * @param encoded String encoding parameters, salt, hash
- * @param pwd Pointer to password
- * @pre   Returns ARGON2_OK if successful
- */
-int argon2id_verify(const char *encoded, const void *pwd, const size_t pwdlen);
-
-/* generic function underlying the above ones */
-int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
-                  argon2_type type);
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_pwhash/argon2/blake2b-long.c

@@ -1,79 +0,0 @@
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "crypto_generichash_blake2b.h"
-#include "private/common.h"
-#include "utils.h"
-
-#include "blake2b-long.h"
-
-int
-blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen)
-{
-    uint8_t *out = (uint8_t *) pout;
-    crypto_generichash_blake2b_state blake_state;
-    uint8_t outlen_bytes[4 /* sizeof(uint32_t) */] = { 0 };
-    int     ret = -1;
-
-    if (outlen > UINT32_MAX) {
-        goto fail; /* LCOV_EXCL_LINE */
-    }
-
-    /* Ensure little-endian byte order! */
-    STORE32_LE(outlen_bytes, (uint32_t) outlen);
-
-#define TRY(statement)   \
-    do {                 \
-        ret = statement; \
-        if (ret < 0) {   \
-            goto fail;   \
-        }                \
-    } while ((void) 0, 0)
-
-    if (outlen <= crypto_generichash_blake2b_BYTES_MAX) {
-        TRY(crypto_generichash_blake2b_init(&blake_state, NULL, 0U, outlen));
-        TRY(crypto_generichash_blake2b_update(&blake_state, outlen_bytes,
-                                              sizeof(outlen_bytes)));
-        TRY(crypto_generichash_blake2b_update(
-            &blake_state, (const unsigned char *) in, inlen));
-        TRY(crypto_generichash_blake2b_final(&blake_state, out, outlen));
-    } else {
-        uint32_t toproduce;
-        uint8_t  out_buffer[crypto_generichash_blake2b_BYTES_MAX];
-        uint8_t  in_buffer[crypto_generichash_blake2b_BYTES_MAX];
-        TRY(crypto_generichash_blake2b_init(
-            &blake_state, NULL, 0U, crypto_generichash_blake2b_BYTES_MAX));
-        TRY(crypto_generichash_blake2b_update(&blake_state, outlen_bytes,
-                                              sizeof(outlen_bytes)));
-        TRY(crypto_generichash_blake2b_update(
-            &blake_state, (const unsigned char *) in, inlen));
-        TRY(crypto_generichash_blake2b_final(
-            &blake_state, out_buffer, crypto_generichash_blake2b_BYTES_MAX));
-        memcpy(out, out_buffer, crypto_generichash_blake2b_BYTES_MAX / 2);
-        out += crypto_generichash_blake2b_BYTES_MAX / 2;
-        toproduce =
-            (uint32_t) outlen - crypto_generichash_blake2b_BYTES_MAX / 2;
-
-        while (toproduce > crypto_generichash_blake2b_BYTES_MAX) {
-            memcpy(in_buffer, out_buffer, crypto_generichash_blake2b_BYTES_MAX);
-            TRY(crypto_generichash_blake2b(
-                out_buffer, crypto_generichash_blake2b_BYTES_MAX, in_buffer,
-                crypto_generichash_blake2b_BYTES_MAX, NULL, 0U));
-            memcpy(out, out_buffer, crypto_generichash_blake2b_BYTES_MAX / 2);
-            out += crypto_generichash_blake2b_BYTES_MAX / 2;
-            toproduce -= crypto_generichash_blake2b_BYTES_MAX / 2;
-        }
-
-        memcpy(in_buffer, out_buffer, crypto_generichash_blake2b_BYTES_MAX);
-        TRY(crypto_generichash_blake2b(out_buffer, toproduce, in_buffer,
-                                       crypto_generichash_blake2b_BYTES_MAX,
-                                       NULL, 0U));
-        memcpy(out, out_buffer, toproduce);
-    }
-fail:
-    sodium_memzero(&blake_state, sizeof(blake_state));
-    return ret;
-#undef TRY
-}

package/ios/libsodium-stable/src/libsodium/crypto_pwhash/argon2/blake2b-long.h

@@ -1,8 +0,0 @@
-#ifndef blake2b_long_H
-#define blake2b_long_H
-
-#include <stddef.h>
-
-int blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen);
-
-#endif