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

package/ios/libsodium-stable/src/libsodium/crypto_scalarmult/curve25519/sandy2x/ladder.h

@@ -1,18 +0,0 @@
-#ifndef ladder_H
-#define ladder_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "fe.h"
-#include "ladder_namespace.h"
-
-extern void ladder(fe *, const unsigned char *);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ifndef ladder_H */
-

package/ios/libsodium-stable/src/libsodium/crypto_scalarmult/curve25519/sandy2x/ladder_namespace.h

@@ -1,8 +0,0 @@
-#ifndef ladder_namespace_H
-#define ladder_namespace_H
-
-#define  ladder  crypto_scalarmult_curve25519_sandy2x_ladder
-#define _ladder _crypto_scalarmult_curve25519_sandy2x_ladder
-
-#endif /* ifndef ladder_namespace_H */
-

package/ios/libsodium-stable/src/libsodium/crypto_scalarmult/curve25519/sandy2x/sandy2x.S

@@ -1,16 +0,0 @@
-
-#ifdef HAVE_AVX_ASM
-
-#define IN_SANDY2X
-
-#include "consts.S"
-#include "fe51_mul.S"
-#include "fe51_nsquare.S"
-#include "fe51_pack.S"
-#include "ladder.S"
-
-#if defined(__linux__) && defined(__ELF__)
-.section .note.GNU-stack,"",%progbits
-#endif
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_scalarmult/curve25519/scalarmult_curve25519.c

@@ -1,60 +0,0 @@
-
-#include "crypto_scalarmult_curve25519.h"
-#include "private/implementations.h"
-#include "scalarmult_curve25519.h"
-#include "runtime.h"
-
-#ifdef HAVE_AVX_ASM
-# include "sandy2x/curve25519_sandy2x.h"
-#endif
-#include "ref10/x25519_ref10.h"
-static const crypto_scalarmult_curve25519_implementation *implementation =
-    &crypto_scalarmult_curve25519_ref10_implementation;
-
-int
-crypto_scalarmult_curve25519(unsigned char *q, const unsigned char *n,
-                             const unsigned char *p)
-{
-    size_t                 i;
-    volatile unsigned char d = 0;
-
-    if (implementation->mult(q, n, p) != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    for (i = 0; i < crypto_scalarmult_curve25519_BYTES; i++) {
-        d |= q[i];
-    }
-    return -(1 & ((d - 1) >> 8));
-}
-
-int
-crypto_scalarmult_curve25519_base(unsigned char *q, const unsigned char *n)
-{
-    return crypto_scalarmult_curve25519_ref10_implementation
-        .mult_base(q, n);
-}
-
-size_t
-crypto_scalarmult_curve25519_bytes(void)
-{
-    return crypto_scalarmult_curve25519_BYTES;
-}
-
-size_t
-crypto_scalarmult_curve25519_scalarbytes(void)
-{
-    return crypto_scalarmult_curve25519_SCALARBYTES;
-}
-
-int
-_crypto_scalarmult_curve25519_pick_best_implementation(void)
-{
-    implementation = &crypto_scalarmult_curve25519_ref10_implementation;
-
-#ifdef HAVE_AVX_ASM
-    if (sodium_runtime_has_avx()) {
-        implementation = &crypto_scalarmult_curve25519_sandy2x_implementation;
-    }
-#endif
-    return 0;
-}

package/ios/libsodium-stable/src/libsodium/crypto_scalarmult/curve25519/scalarmult_curve25519.h

@@ -1,11 +0,0 @@
-
-#ifndef scalarmult_poly1305_H
-#define scalarmult_poly1305_H
-
-typedef struct crypto_scalarmult_curve25519_implementation {
-    int (*mult)(unsigned char *q, const unsigned char *n,
-                const unsigned char *p);
-    int (*mult_base)(unsigned char *q, const unsigned char *n);
-} crypto_scalarmult_curve25519_implementation;
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_scalarmult/ed25519/ref10/scalarmult_ed25519_ref10.c

@@ -1,121 +0,0 @@
-
-#include <string.h>
-
-#include "crypto_scalarmult_ed25519.h"
-#include "private/ed25519_ref10.h"
-#include "utils.h"
-
-static int
-_crypto_scalarmult_ed25519_is_inf(const unsigned char s[32])
-{
-    unsigned char c;
-    unsigned int  i;
-
-    c = s[0] ^ 0x01;
-    for (i = 1; i < 31; i++) {
-        c |= s[i];
-    }
-    c |= s[31] & 0x7f;
-
-    return ((((unsigned int) c) - 1U) >> 8) & 1;
-}
-
-static inline void
-_crypto_scalarmult_ed25519_clamp(unsigned char k[32])
-{
-    k[0] &= 248;
-    k[31] |= 64;
-}
-
-static int
-_crypto_scalarmult_ed25519(unsigned char *q, const unsigned char *n,
-                           const unsigned char *p, const int clamp)
-{
-    unsigned char *t = q;
-    ge25519_p3     Q;
-    ge25519_p3     P;
-    unsigned int   i;
-
-    if (ge25519_is_canonical(p) == 0 || ge25519_has_small_order(p) != 0 ||
-        ge25519_frombytes(&P, p) != 0 || ge25519_is_on_main_subgroup(&P) == 0) {
-        return -1;
-    }
-    for (i = 0; i < 32; ++i) {
-        t[i] = n[i];
-    }
-    if (clamp != 0) {
-        _crypto_scalarmult_ed25519_clamp(t);
-    }
-    t[31] &= 127;
-
-    ge25519_scalarmult(&Q, t, &P);
-    ge25519_p3_tobytes(q, &Q);
-    if (_crypto_scalarmult_ed25519_is_inf(q) != 0 || sodium_is_zero(n, 32)) {
-        return -1;
-    }
-    return 0;
-}
-
-int
-crypto_scalarmult_ed25519(unsigned char *q, const unsigned char *n,
-                          const unsigned char *p)
-{
-    return _crypto_scalarmult_ed25519(q, n, p, 1);
-}
-
-int
-crypto_scalarmult_ed25519_noclamp(unsigned char *q, const unsigned char *n,
-                                  const unsigned char *p)
-{
-    return _crypto_scalarmult_ed25519(q, n, p, 0);
-}
-
-static int
-_crypto_scalarmult_ed25519_base(unsigned char *q,
-                                const unsigned char *n, const int clamp)
-{
-    unsigned char *t = q;
-    ge25519_p3     Q;
-    unsigned int   i;
-
-    for (i = 0; i < 32; ++i) {
-        t[i] = n[i];
-    }
-    if (clamp != 0) {
-        _crypto_scalarmult_ed25519_clamp(t);
-    }
-    t[31] &= 127;
-
-    ge25519_scalarmult_base(&Q, t);
-    ge25519_p3_tobytes(q, &Q);
-    if (_crypto_scalarmult_ed25519_is_inf(q) != 0 || sodium_is_zero(n, 32)) {
-        return -1;
-    }
-    return 0;
-}
-
-int
-crypto_scalarmult_ed25519_base(unsigned char *q,
-                               const unsigned char *n)
-{
-    return _crypto_scalarmult_ed25519_base(q, n, 1);
-}
-
-int
-crypto_scalarmult_ed25519_base_noclamp(unsigned char *q,
-                                       const unsigned char *n)
-{
-    return _crypto_scalarmult_ed25519_base(q, n, 0);
-}
-
-size_t
-crypto_scalarmult_ed25519_bytes(void)
-{
-    return crypto_scalarmult_ed25519_BYTES;
-}
-
-size_t
-crypto_scalarmult_ed25519_scalarbytes(void)
-{
-    return crypto_scalarmult_ed25519_SCALARBYTES;
-}

package/ios/libsodium-stable/src/libsodium/crypto_scalarmult/ristretto255/ref10/scalarmult_ristretto255_ref10.c

@@ -1,63 +0,0 @@
-
-#include <string.h>
-
-#include "crypto_scalarmult_ed25519.h"
-#include "crypto_scalarmult_ristretto255.h"
-#include "private/ed25519_ref10.h"
-#include "utils.h"
-
-int
-crypto_scalarmult_ristretto255(unsigned char *q, const unsigned char *n,
-                               const unsigned char *p)
-{
-    unsigned char *t = q;
-    ge25519_p3     Q;
-    ge25519_p3     P;
-    unsigned int   i;
-
-    if (ristretto255_frombytes(&P, p) != 0) {
-        return -1;
-    }
-    for (i = 0; i < 32; ++i) {
-        t[i] = n[i];
-    }
-    t[31] &= 127;
-    ge25519_scalarmult(&Q, t, &P);
-    ristretto255_p3_tobytes(q, &Q);
-    if (sodium_is_zero(q, 32)) {
-        return -1;
-    }
-    return 0;
-}
-
-int
-crypto_scalarmult_ristretto255_base(unsigned char *q,
-                                    const unsigned char *n)
-{
-    unsigned char *t = q;
-    ge25519_p3     Q;
-    unsigned int   i;
-
-    for (i = 0; i < 32; ++i) {
-        t[i] = n[i];
-    }
-    t[31] &= 127;
-    ge25519_scalarmult_base(&Q, t);
-    ristretto255_p3_tobytes(q, &Q);
-    if (sodium_is_zero(q, 32)) {
-        return -1;
-    }
-    return 0;
-}
-
-size_t
-crypto_scalarmult_ristretto255_bytes(void)
-{
-    return crypto_scalarmult_ristretto255_BYTES;
-}
-
-size_t
-crypto_scalarmult_ristretto255_scalarbytes(void)
-{
-    return crypto_scalarmult_ristretto255_SCALARBYTES;
-}

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

@@ -1,67 +0,0 @@
-
-#include "crypto_secretbox.h"
-#include "randombytes.h"
-
-size_t
-crypto_secretbox_keybytes(void)
-{
-    return crypto_secretbox_KEYBYTES;
-}
-
-size_t
-crypto_secretbox_noncebytes(void)
-{
-    return crypto_secretbox_NONCEBYTES;
-}
-
-size_t
-crypto_secretbox_zerobytes(void)
-{
-    return crypto_secretbox_ZEROBYTES;
-}
-
-size_t
-crypto_secretbox_boxzerobytes(void)
-{
-    return crypto_secretbox_BOXZEROBYTES;
-}
-
-size_t
-crypto_secretbox_macbytes(void)
-{
-    return crypto_secretbox_MACBYTES;
-}
-
-size_t
-crypto_secretbox_messagebytes_max(void)
-{
-    return crypto_secretbox_MESSAGEBYTES_MAX;
-}
-
-const char *
-crypto_secretbox_primitive(void)
-{
-    return crypto_secretbox_PRIMITIVE;
-}
-
-int
-crypto_secretbox(unsigned char *c, const unsigned char *m,
-                 unsigned long long mlen, const unsigned char *n,
-                 const unsigned char *k)
-{
-    return crypto_secretbox_xsalsa20poly1305(c, m, mlen, n, k);
-}
-
-int
-crypto_secretbox_open(unsigned char *m, const unsigned char *c,
-                      unsigned long long clen, const unsigned char *n,
-                      const unsigned char *k)
-{
-    return crypto_secretbox_xsalsa20poly1305_open(m, c, clen, n, k);
-}
-
-void
-crypto_secretbox_keygen(unsigned char k[crypto_secretbox_KEYBYTES])
-{
-    randombytes_buf(k, crypto_secretbox_KEYBYTES);
-}

package/ios/libsodium-stable/src/libsodium/crypto_secretbox/crypto_secretbox_easy.c

@@ -1,145 +0,0 @@
-
-#include <assert.h>
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_core_hsalsa20.h"
-#include "crypto_onetimeauth_poly1305.h"
-#include "crypto_secretbox.h"
-#include "crypto_stream_salsa20.h"
-#include "private/common.h"
-#include "utils.h"
-
-int
-crypto_secretbox_detached(unsigned char *c, unsigned char *mac,
-                          const unsigned char *m,
-                          unsigned long long mlen, const unsigned char *n,
-                          const unsigned char *k)
-{
-    crypto_onetimeauth_poly1305_state state;
-    unsigned char                     block0[64U];
-    unsigned char                     subkey[crypto_stream_salsa20_KEYBYTES];
-    unsigned long long                i;
-    unsigned long long                mlen0;
-
-    crypto_core_hsalsa20(subkey, n, k, NULL);
-
-    if (((uintptr_t) c > (uintptr_t) m &&
-         (uintptr_t) c - (uintptr_t) m < mlen) ||
-        ((uintptr_t) m > (uintptr_t) c &&
-         (uintptr_t) m - (uintptr_t) c < mlen)) { /* LCOV_EXCL_LINE */
-        memmove(c, m, mlen);
-        m = c;
-    }
-    memset(block0, 0U, crypto_secretbox_ZEROBYTES);
-    COMPILER_ASSERT(64U >= crypto_secretbox_ZEROBYTES);
-    mlen0 = mlen;
-    if (mlen0 > 64U - crypto_secretbox_ZEROBYTES) {
-        mlen0 = 64U - crypto_secretbox_ZEROBYTES;
-    }
-    for (i = 0U; i < mlen0; i++) {
-        block0[i + crypto_secretbox_ZEROBYTES] = m[i];
-    }
-    crypto_stream_salsa20_xor(block0, block0,
-                              mlen0 + crypto_secretbox_ZEROBYTES,
-                              n + 16, subkey);
-    COMPILER_ASSERT(crypto_secretbox_ZEROBYTES >=
-                    crypto_onetimeauth_poly1305_KEYBYTES);
-    crypto_onetimeauth_poly1305_init(&state, block0);
-
-    for (i = 0U; i < mlen0; i++) {
-        c[i] = block0[crypto_secretbox_ZEROBYTES + i];
-    }
-    sodium_memzero(block0, sizeof block0);
-    if (mlen > mlen0) {
-        crypto_stream_salsa20_xor_ic(c + mlen0, m + mlen0, mlen - mlen0,
-                                     n + 16, 1U, subkey);
-    }
-    sodium_memzero(subkey, sizeof subkey);
-
-    crypto_onetimeauth_poly1305_update(&state, c, mlen);
-    crypto_onetimeauth_poly1305_final(&state, mac);
-    sodium_memzero(&state, sizeof state);
-
-    return 0;
-}
-
-int
-crypto_secretbox_easy(unsigned char *c, const unsigned char *m,
-                      unsigned long long mlen, const unsigned char *n,
-                      const unsigned char *k)
-{
-    if (mlen > crypto_secretbox_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    return crypto_secretbox_detached(c + crypto_secretbox_MACBYTES,
-                                     c, m, mlen, n, k);
-}
-
-int
-crypto_secretbox_open_detached(unsigned char *m, const unsigned char *c,
-                               const unsigned char *mac,
-                               unsigned long long clen,
-                               const unsigned char *n,
-                               const unsigned char *k)
-{
-    unsigned char      block0[64U];
-    unsigned char      subkey[crypto_stream_salsa20_KEYBYTES];
-    unsigned long long i;
-    unsigned long long mlen0;
-
-    crypto_core_hsalsa20(subkey, n, k, NULL);
-    crypto_stream_salsa20(block0, crypto_stream_salsa20_KEYBYTES,
-                          n + 16, subkey);
-    if (crypto_onetimeauth_poly1305_verify(mac, c, clen, block0) != 0) {
-        sodium_memzero(subkey, sizeof subkey);
-        return -1;
-    }
-    if (m == NULL) {
-        return 0;
-    }
-    if (((uintptr_t) c > (uintptr_t) m &&
-         (uintptr_t) c - (uintptr_t) m < clen) ||
-        ((uintptr_t) m > (uintptr_t) c &&
-         (uintptr_t) m - (uintptr_t) c < clen)) { /* LCOV_EXCL_LINE */
-        memmove(m, c, clen);
-        c = m;
-    }
-    mlen0 = clen;
-    if (mlen0 > 64U - crypto_secretbox_ZEROBYTES) {
-        mlen0 = 64U - crypto_secretbox_ZEROBYTES;
-    }
-    for (i = 0U; i < mlen0; i++) {
-        block0[crypto_secretbox_ZEROBYTES + i] = c[i];
-    }
-    crypto_stream_salsa20_xor(block0, block0,
-                              crypto_secretbox_ZEROBYTES + mlen0,
-                              n + 16, subkey);
-    for (i = 0U; i < mlen0; i++) {
-        m[i] = block0[i + crypto_secretbox_ZEROBYTES];
-    }
-    sodium_memzero(block0, sizeof block0);
-    if (clen > mlen0) {
-        crypto_stream_salsa20_xor_ic(m + mlen0, c + mlen0, clen - mlen0,
-                                     n + 16, 1U, subkey);
-    }
-    sodium_memzero(subkey, sizeof subkey);
-
-    return 0;
-}
-
-int
-crypto_secretbox_open_easy(unsigned char *m, const unsigned char *c,
-                           unsigned long long clen, const unsigned char *n,
-                           const unsigned char *k)
-{
-    if (clen < crypto_secretbox_MACBYTES) {
-        return -1;
-    }
-    return crypto_secretbox_open_detached(m, c + crypto_secretbox_MACBYTES, c,
-                                          clen - crypto_secretbox_MACBYTES,
-                                          n, k);
-}

package/ios/libsodium-stable/src/libsodium/crypto_secretbox/xchacha20poly1305/secretbox_xchacha20poly1305.c

@@ -1,177 +0,0 @@
-
-#include <assert.h>
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_core_hchacha20.h"
-#include "crypto_onetimeauth_poly1305.h"
-#include "crypto_secretbox_xchacha20poly1305.h"
-#include "crypto_stream_chacha20.h"
-#include "private/common.h"
-#include "utils.h"
-
-#define crypto_secretbox_xchacha20poly1305_ZEROBYTES 32U
-
-int
-crypto_secretbox_xchacha20poly1305_detached(unsigned char *c,
-                                            unsigned char *mac,
-                                            const unsigned char *m,
-                                            unsigned long long mlen,
-                                            const unsigned char *n,
-                                            const unsigned char *k)
-{
-    crypto_onetimeauth_poly1305_state state;
-    unsigned char                     block0[64U];
-    unsigned char                     subkey[crypto_stream_chacha20_KEYBYTES];
-    unsigned long long                i;
-    unsigned long long                mlen0;
-
-    crypto_core_hchacha20(subkey, n, k, NULL);
-
-    if (((uintptr_t) c > (uintptr_t) m &&
-         (uintptr_t) c - (uintptr_t) m < mlen) ||
-        ((uintptr_t) m > (uintptr_t) c &&
-         (uintptr_t) m - (uintptr_t) c < mlen)) { /* LCOV_EXCL_LINE */
-        memmove(c, m, mlen);
-        m = c;
-    }
-    memset(block0, 0U, crypto_secretbox_xchacha20poly1305_ZEROBYTES);
-    COMPILER_ASSERT(64U >= crypto_secretbox_xchacha20poly1305_ZEROBYTES);
-    mlen0 = mlen;
-    if (mlen0 > 64U - crypto_secretbox_xchacha20poly1305_ZEROBYTES) {
-        mlen0 = 64U - crypto_secretbox_xchacha20poly1305_ZEROBYTES;
-    }
-    for (i = 0U; i < mlen0; i++) {
-        block0[i + crypto_secretbox_xchacha20poly1305_ZEROBYTES] = m[i];
-    }
-    crypto_stream_chacha20_xor(block0, block0,
-                               mlen0 + crypto_secretbox_xchacha20poly1305_ZEROBYTES,
-                               n + 16, subkey);
-    COMPILER_ASSERT(crypto_secretbox_xchacha20poly1305_ZEROBYTES >=
-                    crypto_onetimeauth_poly1305_KEYBYTES);
-    crypto_onetimeauth_poly1305_init(&state, block0);
-
-    for (i = 0U; i < mlen0; i++) {
-        c[i] = block0[crypto_secretbox_xchacha20poly1305_ZEROBYTES + i];
-    }
-    sodium_memzero(block0, sizeof block0);
-    if (mlen > mlen0) {
-        crypto_stream_chacha20_xor_ic(c + mlen0, m + mlen0, mlen - mlen0,
-                                      n + 16, 1U, subkey);
-    }
-    sodium_memzero(subkey, sizeof subkey);
-
-    crypto_onetimeauth_poly1305_update(&state, c, mlen);
-    crypto_onetimeauth_poly1305_final(&state, mac);
-    sodium_memzero(&state, sizeof state);
-
-    return 0;
-}
-
-int
-crypto_secretbox_xchacha20poly1305_easy(unsigned char *c,
-                                        const unsigned char *m,
-                                        unsigned long long mlen,
-                                        const unsigned char *n,
-                                        const unsigned char *k)
-{
-    if (mlen > crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    return crypto_secretbox_xchacha20poly1305_detached
-        (c + crypto_secretbox_xchacha20poly1305_MACBYTES, c, m, mlen, n, k);
-}
-
-int
-crypto_secretbox_xchacha20poly1305_open_detached(unsigned char *m,
-                                                 const unsigned char *c,
-                                                 const unsigned char *mac,
-                                                 unsigned long long clen,
-                                                 const unsigned char *n,
-                                                 const unsigned char *k)
-{
-    unsigned char      block0[64U];
-    unsigned char      subkey[crypto_stream_chacha20_KEYBYTES];
-    unsigned long long i;
-    unsigned long long mlen0;
-
-    crypto_core_hchacha20(subkey, n, k, NULL);
-    crypto_stream_chacha20(block0, crypto_stream_chacha20_KEYBYTES,
-                           n + 16, subkey);
-    if (crypto_onetimeauth_poly1305_verify(mac, c, clen, block0) != 0) {
-        sodium_memzero(subkey, sizeof subkey);
-        return -1;
-    }
-    if (m == NULL) {
-        return 0;
-    }
-    if (((uintptr_t) c > (uintptr_t) m &&
-         (uintptr_t) c - (uintptr_t) m < clen) ||
-        ((uintptr_t) m > (uintptr_t) c &&
-         (uintptr_t) m - (uintptr_t) c < clen)) { /* LCOV_EXCL_LINE */
-        memmove(m, c, clen);
-        c = m;
-    }
-    mlen0 = clen;
-    if (mlen0 > 64U - crypto_secretbox_xchacha20poly1305_ZEROBYTES) {
-        mlen0 = 64U - crypto_secretbox_xchacha20poly1305_ZEROBYTES;
-    }
-    for (i = 0U; i < mlen0; i++) {
-        block0[crypto_secretbox_xchacha20poly1305_ZEROBYTES + i] = c[i];
-    }
-    crypto_stream_chacha20_xor(block0, block0,
-                              crypto_secretbox_xchacha20poly1305_ZEROBYTES + mlen0,
-                              n + 16, subkey);
-    for (i = 0U; i < mlen0; i++) {
-        m[i] = block0[i + crypto_secretbox_xchacha20poly1305_ZEROBYTES];
-    }
-    if (clen > mlen0) {
-        crypto_stream_chacha20_xor_ic(m + mlen0, c + mlen0, clen - mlen0,
-                                      n + 16, 1U, subkey);
-    }
-    sodium_memzero(subkey, sizeof subkey);
-
-    return 0;
-}
-
-int
-crypto_secretbox_xchacha20poly1305_open_easy(unsigned char *m,
-                                             const unsigned char *c,
-                                             unsigned long long clen,
-                                             const unsigned char *n,
-                                             const unsigned char *k)
-{
-    if (clen < crypto_secretbox_xchacha20poly1305_MACBYTES) {
-        return -1;
-    }
-    return crypto_secretbox_xchacha20poly1305_open_detached
-        (m, c + crypto_secretbox_xchacha20poly1305_MACBYTES, c,
-         clen - crypto_secretbox_xchacha20poly1305_MACBYTES, n, k);
-}
-
-size_t
-crypto_secretbox_xchacha20poly1305_keybytes(void)
-{
-    return crypto_secretbox_xchacha20poly1305_KEYBYTES;
-}
-
-size_t
-crypto_secretbox_xchacha20poly1305_noncebytes(void)
-{
-    return crypto_secretbox_xchacha20poly1305_NONCEBYTES;
-}
-
-size_t
-crypto_secretbox_xchacha20poly1305_macbytes(void)
-{
-    return crypto_secretbox_xchacha20poly1305_MACBYTES;
-}
-
-size_t
-crypto_secretbox_xchacha20poly1305_messagebytes_max(void)
-{
-    return crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX;
-}