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

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis128l/aegis128l_common.h

@@ -1,248 +0,0 @@
-#define RATE 32
-
-static void
-aegis128l_init(const uint8_t *key, const uint8_t *nonce, aes_block_t *const state)
-{
-    static CRYPTO_ALIGN(AES_BLOCK_LENGTH)
-        const uint8_t c0_[AES_BLOCK_LENGTH] = { 0x00, 0x01, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d,
-                                                0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62 };
-    static CRYPTO_ALIGN(AES_BLOCK_LENGTH)
-        const uint8_t c1_[AES_BLOCK_LENGTH] = { 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1,
-                                                0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd };
-
-    const aes_block_t c0 = AES_BLOCK_LOAD(c0_);
-    const aes_block_t c1 = AES_BLOCK_LOAD(c1_);
-    aes_block_t       k;
-    aes_block_t       n;
-    int               i;
-
-    k = AES_BLOCK_LOAD(key);
-    n = AES_BLOCK_LOAD(nonce);
-
-    state[0] = AES_BLOCK_XOR(k, n);
-    state[1] = c1;
-    state[2] = c0;
-    state[3] = c1;
-    state[4] = AES_BLOCK_XOR(k, n);
-    state[5] = AES_BLOCK_XOR(k, c0);
-    state[6] = AES_BLOCK_XOR(k, c1);
-    state[7] = AES_BLOCK_XOR(k, c0);
-    for (i = 0; i < 10; i++) {
-        aegis128l_update(state, n, k);
-    }
-}
-
-static void
-aegis128l_mac(uint8_t *mac, size_t maclen, uint64_t adlen, uint64_t mlen, aes_block_t *const state)
-{
-    aes_block_t tmp;
-    int         i;
-
-    tmp = AES_BLOCK_LOAD_64x2(mlen << 3, adlen << 3);
-    tmp = AES_BLOCK_XOR(tmp, state[2]);
-
-    for (i = 0; i < 7; i++) {
-        aegis128l_update(state, tmp, tmp);
-    }
-
-    if (maclen == 16) {
-        tmp = AES_BLOCK_XOR(state[6], AES_BLOCK_XOR(state[5], state[4]));
-        tmp = AES_BLOCK_XOR(tmp, AES_BLOCK_XOR(state[3], state[2]));
-        tmp = AES_BLOCK_XOR(tmp, AES_BLOCK_XOR(state[1], state[0]));
-        AES_BLOCK_STORE(mac, tmp);
-    } else if (maclen == 32) {
-        tmp = AES_BLOCK_XOR(state[3], state[2]);
-        tmp = AES_BLOCK_XOR(tmp, AES_BLOCK_XOR(state[1], state[0]));
-        AES_BLOCK_STORE(mac, tmp);
-        tmp = AES_BLOCK_XOR(state[7], state[6]);
-        tmp = AES_BLOCK_XOR(tmp, AES_BLOCK_XOR(state[5], state[4]));
-        AES_BLOCK_STORE(mac + 16, tmp);
-    } else {
-        memset(mac, 0, maclen);
-    }
-}
-
-static inline void
-aegis128l_absorb(const uint8_t *const src, aes_block_t *const state)
-{
-    aes_block_t msg0, msg1;
-
-    msg0 = AES_BLOCK_LOAD(src);
-    msg1 = AES_BLOCK_LOAD(src + AES_BLOCK_LENGTH);
-    aegis128l_update(state, msg0, msg1);
-}
-
-static inline void
-aegis128l_absorb2(const uint8_t *const src, aes_block_t *const state)
-{
-    aes_block_t msg0, msg1, msg2, msg3;
-
-    msg0 = AES_BLOCK_LOAD(src + 0 * AES_BLOCK_LENGTH);
-    msg1 = AES_BLOCK_LOAD(src + 1 * AES_BLOCK_LENGTH);
-    msg2 = AES_BLOCK_LOAD(src + 2 * AES_BLOCK_LENGTH);
-    msg3 = AES_BLOCK_LOAD(src + 3 * AES_BLOCK_LENGTH);
-    aegis128l_update(state, msg0, msg1);
-    aegis128l_update(state, msg2, msg3);
-}
-
-static void
-aegis128l_enc(uint8_t *const dst, const uint8_t *const src, aes_block_t *const state)
-{
-    aes_block_t msg0, msg1;
-    aes_block_t tmp0, tmp1;
-
-    msg0 = AES_BLOCK_LOAD(src);
-    msg1 = AES_BLOCK_LOAD(src + AES_BLOCK_LENGTH);
-    tmp0 = AES_BLOCK_XOR(msg0, state[6]);
-    tmp0 = AES_BLOCK_XOR(tmp0, state[1]);
-    tmp1 = AES_BLOCK_XOR(msg1, state[5]);
-    tmp1 = AES_BLOCK_XOR(tmp1, state[2]);
-    tmp0 = AES_BLOCK_XOR(tmp0, AES_BLOCK_AND(state[2], state[3]));
-    tmp1 = AES_BLOCK_XOR(tmp1, AES_BLOCK_AND(state[6], state[7]));
-    AES_BLOCK_STORE(dst, tmp0);
-    AES_BLOCK_STORE(dst + AES_BLOCK_LENGTH, tmp1);
-
-    aegis128l_update(state, msg0, msg1);
-}
-
-static void
-aegis128l_dec(uint8_t *const dst, const uint8_t *const src, aes_block_t *const state)
-{
-    aes_block_t msg0, msg1;
-
-    msg0 = AES_BLOCK_LOAD(src);
-    msg1 = AES_BLOCK_LOAD(src + AES_BLOCK_LENGTH);
-    msg0 = AES_BLOCK_XOR(msg0, state[6]);
-    msg0 = AES_BLOCK_XOR(msg0, state[1]);
-    msg1 = AES_BLOCK_XOR(msg1, state[5]);
-    msg1 = AES_BLOCK_XOR(msg1, state[2]);
-    msg0 = AES_BLOCK_XOR(msg0, AES_BLOCK_AND(state[2], state[3]));
-    msg1 = AES_BLOCK_XOR(msg1, AES_BLOCK_AND(state[6], state[7]));
-    AES_BLOCK_STORE(dst, msg0);
-    AES_BLOCK_STORE(dst + AES_BLOCK_LENGTH, msg1);
-
-    aegis128l_update(state, msg0, msg1);
-}
-
-static void
-aegis128l_declast(uint8_t *const dst, const uint8_t *const src, size_t len,
-                  aes_block_t *const state)
-{
-    uint8_t     pad[RATE];
-    aes_block_t msg0, msg1;
-
-    memset(pad, 0, sizeof pad);
-    memcpy(pad, src, len);
-
-    msg0 = AES_BLOCK_LOAD(pad);
-    msg1 = AES_BLOCK_LOAD(pad + AES_BLOCK_LENGTH);
-    msg0 = AES_BLOCK_XOR(msg0, state[6]);
-    msg0 = AES_BLOCK_XOR(msg0, state[1]);
-    msg1 = AES_BLOCK_XOR(msg1, state[5]);
-    msg1 = AES_BLOCK_XOR(msg1, state[2]);
-    msg0 = AES_BLOCK_XOR(msg0, AES_BLOCK_AND(state[2], state[3]));
-    msg1 = AES_BLOCK_XOR(msg1, AES_BLOCK_AND(state[6], state[7]));
-    AES_BLOCK_STORE(pad, msg0);
-    AES_BLOCK_STORE(pad + AES_BLOCK_LENGTH, msg1);
-
-    memset(pad + len, 0, sizeof pad - len);
-    memcpy(dst, pad, len);
-
-    msg0 = AES_BLOCK_LOAD(pad);
-    msg1 = AES_BLOCK_LOAD(pad + AES_BLOCK_LENGTH);
-
-    aegis128l_update(state, msg0, msg1);
-}
-
-static int
-encrypt_detached(uint8_t *c, uint8_t *mac, size_t maclen, const uint8_t *m, size_t mlen,
-                 const uint8_t *ad, size_t adlen, const uint8_t *npub, const uint8_t *k)
-{
-    aes_block_t                state[8];
-    CRYPTO_ALIGN(RATE) uint8_t src[RATE];
-    CRYPTO_ALIGN(RATE) uint8_t dst[RATE];
-    size_t                     i;
-
-    aegis128l_init(k, npub, state);
-
-    for (i = 0; i + RATE * 2 <= adlen; i += RATE * 2) {
-        aegis128l_absorb2(ad + i, state);
-    }
-    for (; i + RATE <= adlen; i += RATE) {
-        aegis128l_absorb(ad + i, state);
-    }
-    if (adlen % RATE) {
-        memset(src, 0, RATE);
-        memcpy(src, ad + i, adlen % RATE);
-        aegis128l_absorb(src, state);
-    }
-    for (i = 0; i + RATE <= mlen; i += RATE) {
-        aegis128l_enc(c + i, m + i, state);
-    }
-    if (mlen % RATE) {
-        memset(src, 0, RATE);
-        memcpy(src, m + i, mlen % RATE);
-        aegis128l_enc(dst, src, state);
-        memcpy(c + i, dst, mlen % RATE);
-    }
-
-    aegis128l_mac(mac, maclen, adlen, mlen, state);
-
-    return 0;
-}
-
-static int
-decrypt_detached(uint8_t *m, const uint8_t *c, size_t clen, const uint8_t *mac, size_t maclen,
-                 const uint8_t *ad, size_t adlen, const uint8_t *npub, const uint8_t *k)
-{
-    aes_block_t                state[8];
-    CRYPTO_ALIGN(RATE) uint8_t src[RATE];
-    CRYPTO_ALIGN(RATE) uint8_t dst[RATE];
-    CRYPTO_ALIGN(16) uint8_t   computed_mac[32];
-    const size_t               mlen = clen;
-    size_t                     i;
-    int                        ret;
-
-    aegis128l_init(k, npub, state);
-
-    for (i = 0; i + RATE * 2 <= adlen; i += RATE * 2) {
-        aegis128l_absorb2(ad + i, state);
-    }
-    for (; i + RATE <= adlen; i += RATE) {
-        aegis128l_absorb(ad + i, state);
-    }
-    if (adlen % RATE) {
-        memset(src, 0, RATE);
-        memcpy(src, ad + i, adlen % RATE);
-        aegis128l_absorb(src, state);
-    }
-    if (m != NULL) {
-        for (i = 0; i + RATE <= mlen; i += RATE) {
-            aegis128l_dec(m + i, c + i, state);
-        }
-    } else {
-        for (i = 0; i + RATE <= mlen; i += RATE) {
-            aegis128l_dec(dst, c + i, state);
-        }
-    }
-    if (mlen % RATE) {
-        if (m != NULL) {
-            aegis128l_declast(m + i, c + i, mlen % RATE, state);
-        } else {
-            aegis128l_declast(dst, c + i, mlen % RATE, state);
-        }
-    }
-
-    COMPILER_ASSERT(sizeof computed_mac >= 32);
-    aegis128l_mac(computed_mac, maclen, adlen, mlen, state);
-    ret = -1;
-    if (maclen == 16) {
-        ret = crypto_verify_16(computed_mac, mac);
-    } else if (maclen == 32) {
-        ret = crypto_verify_32(computed_mac, mac);
-    }
-    if (ret != 0 && m != NULL) {
-        memset(m, 0, mlen);
-    }
-    return ret;
-}

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis128l/aegis128l_soft.c

@@ -1,59 +0,0 @@
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_aead_aegis128l.h"
-#include "crypto_verify_16.h"
-#include "crypto_verify_32.h"
-#include "export.h"
-#include "utils.h"
-
-#include "private/common.h"
-
-#include "crypto_aead_aegis128l.h"
-#include "private/softaes.h"
-
-#if 1
-
-#include "aegis128l_soft.h"
-
-#define AES_BLOCK_LENGTH 16
-
-typedef SoftAesBlock aes_block_t;
-#define AES_BLOCK_XOR(A, B)       softaes_block_xor((A), (B))
-#define AES_BLOCK_AND(A, B)       softaes_block_and((A), (B))
-#define AES_BLOCK_LOAD(A)         softaes_block_load(A)
-#define AES_BLOCK_LOAD_64x2(A, B) softaes_block_load64x2((A), (B))
-#define AES_BLOCK_STORE(A, B)     softaes_block_store((A), (B))
-#define AES_ENC(A, B)             softaes_block_encrypt((A), (B))
-
-static inline void
-aegis128l_update(aes_block_t *const state, const aes_block_t d1, const aes_block_t d2)
-{
-    aes_block_t tmp;
-
-    tmp      = state[7];
-    state[7] = AES_ENC(state[6], state[7]);
-    state[6] = AES_ENC(state[5], state[6]);
-    state[5] = AES_ENC(state[4], state[5]);
-    state[4] = AES_ENC(state[3], state[4]);
-    state[3] = AES_ENC(state[2], state[3]);
-    state[2] = AES_ENC(state[1], state[2]);
-    state[1] = AES_ENC(state[0], state[1]);
-    state[0] = AES_ENC(tmp, state[0]);
-
-    state[0] = AES_BLOCK_XOR(state[0], d1);
-    state[4] = AES_BLOCK_XOR(state[4], d2);
-}
-
-#include "aegis128l_common.h"
-
-struct aegis128l_implementation aegis128l_soft_implementation = { SODIUM_C99(.encrypt_detached =)
-                                                                      encrypt_detached,
-                                                                  SODIUM_C99(.decrypt_detached =)
-                                                                      decrypt_detached };
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis128l/aegis128l_soft.h

@@ -1,8 +0,0 @@
-#ifndef aegis128l_soft_H
-#define aegis128l_soft_H
-
-#include "implementations.h"
-
-extern struct aegis128l_implementation aegis128l_soft_implementation;
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis128l/implementations.h

@@ -1,17 +0,0 @@
-#ifndef aegis128l_implementations_H
-#define aegis128l_implementations_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "crypto_aead_aegis128l.h"
-
-typedef struct aegis128l_implementation {
-    int (*encrypt_detached)(uint8_t *c, uint8_t *mac, size_t maclen, const uint8_t *m, size_t mlen,
-                            const uint8_t *ad, size_t adlen, const uint8_t *npub, const uint8_t *k);
-    int (*decrypt_detached)(uint8_t *m, const uint8_t *c, size_t clen, const uint8_t *mac,
-                            size_t maclen, const uint8_t *ad, size_t adlen, const uint8_t *npub,
-                            const uint8_t *k);
-} aegis128l_implementation;
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis256/aead_aegis256.c

@@ -1,158 +0,0 @@
-
-#include <errno.h>
-#include <stdlib.h>
-
-#include "core.h"
-#include "crypto_aead_aegis256.h"
-#include "private/common.h"
-#include "private/implementations.h"
-#include "randombytes.h"
-#include "runtime.h"
-
-#include "aegis256_soft.h"
-
-#if defined(HAVE_ARMCRYPTO) && defined(NATIVE_LITTLE_ENDIAN)
-#include "aegis256_armcrypto.h"
-#endif
-
-#if defined(HAVE_AVXINTRIN_H) && defined(HAVE_WMMINTRIN_H)
-#include "aegis256_aesni.h"
-#endif
-
-static const aegis256_implementation *implementation = &aegis256_soft_implementation;
-
-size_t
-crypto_aead_aegis256_keybytes(void)
-{
-    return crypto_aead_aegis256_KEYBYTES;
-}
-
-size_t
-crypto_aead_aegis256_nsecbytes(void)
-{
-    return crypto_aead_aegis256_NSECBYTES;
-}
-
-size_t
-crypto_aead_aegis256_npubbytes(void)
-{
-    return crypto_aead_aegis256_NPUBBYTES;
-}
-
-size_t
-crypto_aead_aegis256_abytes(void)
-{
-    return crypto_aead_aegis256_ABYTES;
-}
-
-size_t
-crypto_aead_aegis256_messagebytes_max(void)
-{
-    return crypto_aead_aegis256_MESSAGEBYTES_MAX;
-}
-
-void
-crypto_aead_aegis256_keygen(unsigned char k[crypto_aead_aegis256_KEYBYTES])
-{
-    randombytes_buf(k, crypto_aead_aegis256_KEYBYTES);
-}
-
-int
-crypto_aead_aegis256_encrypt(unsigned char *c, unsigned long long *clen_p, const unsigned char *m,
-                             unsigned long long mlen, const unsigned char *ad,
-                             unsigned long long adlen, const unsigned char *nsec,
-                             const unsigned char *npub, const unsigned char *k)
-{
-    unsigned long long clen = 0ULL;
-    int                ret;
-
-    ret =
-        crypto_aead_aegis256_encrypt_detached(c, c + mlen, NULL, m, mlen, ad, adlen, nsec, npub, k);
-    if (clen_p != NULL) {
-        if (ret == 0) {
-            clen = mlen + crypto_aead_aegis256_ABYTES;
-        }
-        *clen_p = clen;
-    }
-    return ret;
-}
-
-int
-crypto_aead_aegis256_decrypt(unsigned char *m, unsigned long long *mlen_p, unsigned char *nsec,
-                             const unsigned char *c, unsigned long long clen,
-                             const unsigned char *ad, unsigned long long adlen,
-                             const unsigned char *npub, const unsigned char *k)
-{
-    unsigned long long mlen = 0ULL;
-    int                ret  = -1;
-
-    if (clen >= crypto_aead_aegis256_ABYTES) {
-        ret = crypto_aead_aegis256_decrypt_detached(m, nsec, c, clen - crypto_aead_aegis256_ABYTES,
-                                                    c + clen - crypto_aead_aegis256_ABYTES, ad,
-                                                    adlen, npub, k);
-    }
-    if (mlen_p != NULL) {
-        if (ret == 0) {
-            mlen = clen - crypto_aead_aegis256_ABYTES;
-        }
-        *mlen_p = mlen;
-    }
-    return ret;
-}
-
-int
-crypto_aead_aegis256_encrypt_detached(unsigned char *c, unsigned char *mac,
-                                      unsigned long long *maclen_p, const unsigned char *m,
-                                      unsigned long long mlen, const unsigned char *ad,
-                                      unsigned long long adlen, const unsigned char *nsec,
-                                      const unsigned char *npub, const unsigned char *k)
-{
-    const size_t maclen = crypto_aead_aegis256_ABYTES;
-
-    if (maclen_p != NULL) {
-        *maclen_p = maclen;
-    }
-    if (mlen > crypto_aead_aegis256_MESSAGEBYTES_MAX ||
-        adlen > crypto_aead_aegis256_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    return implementation->encrypt_detached(c, mac, maclen, m, (size_t) mlen, ad, (size_t) adlen,
-                                            npub, k);
-}
-
-int
-crypto_aead_aegis256_decrypt_detached(unsigned char *m, unsigned char *nsec, const unsigned char *c,
-                                      unsigned long long clen, const unsigned char *mac,
-                                      const unsigned char *ad, unsigned long long adlen,
-                                      const unsigned char *npub, const unsigned char *k)
-{
-    const size_t maclen = crypto_aead_aegis256_ABYTES;
-
-    if (clen > crypto_aead_aegis256_MESSAGEBYTES_MAX ||
-        adlen > crypto_aead_aegis256_MESSAGEBYTES_MAX) {
-        return -1;
-    }
-    return implementation->decrypt_detached(m, c, (size_t) clen, mac, maclen, ad, (size_t) adlen,
-                                            npub, k);
-}
-
-int
-_crypto_aead_aegis256_pick_best_implementation(void)
-{
-    implementation = &aegis256_soft_implementation;
-
-#if defined(HAVE_ARMCRYPTO) && defined(NATIVE_LITTLE_ENDIAN)
-    if (sodium_runtime_has_armcrypto()) {
-        implementation = &aegis256_armcrypto_implementation;
-        return 0;
-    }
-#endif
-
-#if defined(HAVE_AVXINTRIN_H) && defined(HAVE_WMMINTRIN_H)
-    if (sodium_runtime_has_aesni() & sodium_runtime_has_avx()) {
-        implementation = &aegis256_aesni_implementation;
-        return 0;
-    }
-#endif
-    return 0; /* LCOV_EXCL_LINE */
-}

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis256/aegis256_aesni.c

@@ -1,65 +0,0 @@
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_aead_aegis256.h"
-#include "crypto_verify_16.h"
-#include "crypto_verify_32.h"
-#include "export.h"
-#include "utils.h"
-
-#include "private/common.h"
-
-#if defined(HAVE_AVXINTRIN_H) && defined(HAVE_WMMINTRIN_H)
-
-#include "aegis256_aesni.h"
-
-#ifdef __clang__
-#pragma clang attribute push(__attribute__((target("aes,avx"))), apply_to = function)
-#elif defined(__GNUC__)
-#pragma GCC target("aes,avx")
-#endif
-
-#include "private/sse2_64_32.h"
-#include <immintrin.h>
-#include <wmmintrin.h>
-
-#define AES_BLOCK_LENGTH 16
-
-typedef __m128i aes_block_t;
-#define AES_BLOCK_XOR(A, B)       _mm_xor_si128((A), (B))
-#define AES_BLOCK_AND(A, B)       _mm_and_si128((A), (B))
-#define AES_BLOCK_LOAD(A)         _mm_loadu_si128((const aes_block_t *) (const void *) (A))
-#define AES_BLOCK_LOAD_64x2(A, B) _mm_set_epi64x((long long) (A), (long long) (B))
-#define AES_BLOCK_STORE(A, B)     _mm_storeu_si128((aes_block_t *) (void *) (A), (B))
-#define AES_ENC(A, B)             _mm_aesenc_si128((A), (B))
-
-static inline void
-aegis256_update(aes_block_t *const state, const aes_block_t d)
-{
-    aes_block_t tmp;
-
-    tmp      = state[5];
-    state[5] = AES_ENC(state[4], state[5]);
-    state[4] = AES_ENC(state[3], state[4]);
-    state[3] = AES_ENC(state[2], state[3]);
-    state[2] = AES_ENC(state[1], state[2]);
-    state[1] = AES_ENC(state[0], state[1]);
-    state[0] = AES_BLOCK_XOR(AES_ENC(tmp, state[0]), d);
-}
-
-#include "aegis256_common.h"
-
-struct aegis256_implementation aegis256_aesni_implementation = { SODIUM_C99(.encrypt_detached =)
-                                                                     encrypt_detached,
-                                                                 SODIUM_C99(.decrypt_detached =)
-                                                                     decrypt_detached };
-
-#ifdef __clang__
-#pragma clang attribute pop
-#endif
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis256/aegis256_aesni.h

@@ -1,8 +0,0 @@
-#ifndef aegis256_aesni_H
-#define aegis256_aesni_H
-
-#include "implementations.h"
-
-extern struct aegis256_implementation aegis256_aesni_implementation;
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis256/aegis256_armcrypto.c

@@ -1,70 +0,0 @@
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_aead_aegis256.h"
-#include "crypto_verify_16.h"
-#include "crypto_verify_32.h"
-#include "export.h"
-#include "utils.h"
-
-#include "private/common.h"
-
-#if defined(HAVE_ARMCRYPTO) && defined(NATIVE_LITTLE_ENDIAN)
-
-#include "aegis256_armcrypto.h"
-
-#ifndef __ARM_FEATURE_CRYPTO
-#define __ARM_FEATURE_CRYPTO 1
-#endif
-#ifndef __ARM_FEATURE_AES
-#define __ARM_FEATURE_AES 1
-#endif
-
-#include <arm_neon.h>
-
-#ifdef __clang__
-#pragma clang attribute push(__attribute__((target("neon,crypto,aes"))), apply_to = function)
-#elif defined(__GNUC__)
-#pragma GCC target("+simd+crypto")
-#endif
-
-#define AES_BLOCK_LENGTH 16
-
-typedef uint8x16_t aes_block_t;
-#define AES_BLOCK_XOR(A, B)       veorq_u8((A), (B))
-#define AES_BLOCK_AND(A, B)       vandq_u8((A), (B))
-#define AES_BLOCK_LOAD(A)         vld1q_u8(A)
-#define AES_BLOCK_LOAD_64x2(A, B) vreinterpretq_u8_u64(vsetq_lane_u64((A), vmovq_n_u64(B), 1))
-#define AES_BLOCK_STORE(A, B)     vst1q_u8((A), (B))
-#define AES_ENC(A, B)             veorq_u8(vaesmcq_u8(vaeseq_u8(vmovq_n_u8(0), (A))), (B))
-
-static inline void
-aegis256_update(aes_block_t *const state, const aes_block_t d)
-{
-    aes_block_t tmp;
-
-    tmp      = state[5];
-    state[5] = AES_ENC(state[4], state[5]);
-    state[4] = AES_ENC(state[3], state[4]);
-    state[3] = AES_ENC(state[2], state[3]);
-    state[2] = AES_ENC(state[1], state[2]);
-    state[1] = AES_ENC(state[0], state[1]);
-    state[0] = AES_BLOCK_XOR(AES_ENC(tmp, state[0]), d);
-}
-
-#include "aegis256_common.h"
-
-struct aegis256_implementation aegis256_armcrypto_implementation = { SODIUM_C99(.encrypt_detached =)
-                                                                         encrypt_detached,
-                                                                     SODIUM_C99(.decrypt_detached =)
-                                                                         decrypt_detached };
-
-#ifdef __clang__
-#pragma clang attribute pop
-#endif
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_aead/aegis256/aegis256_armcrypto.h

@@ -1,8 +0,0 @@
-#ifndef aegis256_armcrypto_H
-#define aegis256_armcrypto_H
-
-#include "implementations.h"
-
-extern struct aegis256_implementation aegis256_armcrypto_implementation;
-
-#endif