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

package/ios/libsodium-stable/src/libsodium/crypto_box/curve25519xchacha20poly1305/box_curve25519xchacha20poly1305.c

@@ -1,204 +0,0 @@
-
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_box_curve25519xchacha20poly1305.h"
-#include "crypto_core_hchacha20.h"
-#include "crypto_hash_sha512.h"
-#include "crypto_scalarmult_curve25519.h"
-#include "crypto_secretbox_xchacha20poly1305.h"
-#include "private/common.h"
-#include "randombytes.h"
-#include "utils.h"
-
-int
-crypto_box_curve25519xchacha20poly1305_seed_keypair(unsigned char *pk,
-                                                    unsigned char *sk,
-                                                    const unsigned char *seed)
-{
-    unsigned char hash[64];
-
-    crypto_hash_sha512(hash, seed, 32);
-    memcpy(sk, hash, 32);
-    sodium_memzero(hash, sizeof hash);
-
-    return crypto_scalarmult_curve25519_base(pk, sk);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_keypair(unsigned char *pk,
-                                               unsigned char *sk)
-{
-    randombytes_buf(sk, 32);
-
-    return crypto_scalarmult_curve25519_base(pk, sk);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_beforenm(unsigned char *k,
-                                                const unsigned char *pk,
-                                                const unsigned char *sk)
-{
-    static const unsigned char zero[16] = { 0 };
-    unsigned char s[32];
-
-    if (crypto_scalarmult_curve25519(s, sk, pk) != 0) {
-        return -1;
-    }
-    return crypto_core_hchacha20(k, zero, s, NULL);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_detached_afternm(
-    unsigned char *c, unsigned char *mac, const unsigned char *m,
-    unsigned long long mlen, const unsigned char *n, const unsigned char *k)
-{
-    return crypto_secretbox_xchacha20poly1305_detached(c, mac, m, mlen, n, k);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_detached(
-    unsigned char *c, unsigned char *mac, const unsigned char *m,
-    unsigned long long mlen, const unsigned char *n, const unsigned char *pk,
-    const unsigned char *sk)
-{
-    unsigned char k[crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES];
-    int           ret;
-
-    COMPILER_ASSERT(crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES >=
-                    crypto_secretbox_xchacha20poly1305_KEYBYTES);
-    if (crypto_box_curve25519xchacha20poly1305_beforenm(k, pk, sk) != 0) {
-        return -1;
-    }
-    ret = crypto_box_curve25519xchacha20poly1305_detached_afternm(c, mac, m,
-                                                                  mlen, n, k);
-    sodium_memzero(k, sizeof k);
-
-    return ret;
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_easy_afternm(unsigned char *c,
-                                                    const unsigned char *m,
-                                                    unsigned long long mlen,
-                                                    const unsigned char *n,
-                                                    const unsigned char *k)
-{
-    if (mlen > crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    return crypto_box_curve25519xchacha20poly1305_detached_afternm(
-        c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c, m, mlen, n, k);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_easy(
-    unsigned char *c, const unsigned char *m, unsigned long long mlen,
-    const unsigned char *n, const unsigned char *pk, const unsigned char *sk)
-{
-    if (mlen > crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    return crypto_box_curve25519xchacha20poly1305_detached(
-        c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c, m, mlen, n, pk,
-        sk);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
-    unsigned char *m, const unsigned char *c, const unsigned char *mac,
-    unsigned long long clen, const unsigned char *n, const unsigned char *k)
-{
-    return crypto_secretbox_xchacha20poly1305_open_detached(m, c, mac, clen, n,
-                                                            k);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_open_detached(
-    unsigned char *m, const unsigned char *c, const unsigned char *mac,
-    unsigned long long clen, const unsigned char *n, const unsigned char *pk,
-    const unsigned char *sk)
-{
-    unsigned char k[crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES];
-    int           ret;
-
-    if (crypto_box_curve25519xchacha20poly1305_beforenm(k, pk, sk) != 0) {
-        return -1;
-    }
-    ret = crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
-        m, c, mac, clen, n, k);
-    sodium_memzero(k, sizeof k);
-
-    return ret;
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_open_easy_afternm(
-    unsigned char *m, const unsigned char *c, unsigned long long clen,
-    const unsigned char *n, const unsigned char *k)
-{
-    if (clen < crypto_box_curve25519xchacha20poly1305_MACBYTES) {
-        return -1;
-    }
-    return crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
-        m, c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c,
-        clen - crypto_box_curve25519xchacha20poly1305_MACBYTES, n, k);
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_open_easy(
-    unsigned char *m, const unsigned char *c, unsigned long long clen,
-    const unsigned char *n, const unsigned char *pk, const unsigned char *sk)
-{
-    if (clen < crypto_box_curve25519xchacha20poly1305_MACBYTES) {
-        return -1;
-    }
-    return crypto_box_curve25519xchacha20poly1305_open_detached(
-        m, c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c,
-        clen - crypto_box_curve25519xchacha20poly1305_MACBYTES, n, pk, sk);
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_seedbytes(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_SEEDBYTES;
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_publickeybytes(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_secretkeybytes(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_beforenmbytes(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES;
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_noncebytes(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_macbytes(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_MACBYTES;
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_messagebytes_max(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX;
-}

package/ios/libsodium-stable/src/libsodium/crypto_box/curve25519xchacha20poly1305/box_seal_curve25519xchacha20poly1305.c

@@ -1,79 +0,0 @@
-
-#include <string.h>
-
-#include "crypto_box_curve25519xchacha20poly1305.h"
-#include "crypto_generichash.h"
-#include "private/common.h"
-#include "utils.h"
-
-static int
-_crypto_box_curve25519xchacha20poly1305_seal_nonce(unsigned char *nonce,
-                                                   const unsigned char *pk1,
-                                                   const unsigned char *pk2)
-{
-    crypto_generichash_state st;
-
-    crypto_generichash_init(&st, NULL, 0U,
-                            crypto_box_curve25519xchacha20poly1305_NONCEBYTES);
-    crypto_generichash_update(&st, pk1,
-                              crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES);
-    crypto_generichash_update(&st, pk2,
-                              crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES);
-    crypto_generichash_final(&st, nonce,
-                             crypto_box_curve25519xchacha20poly1305_NONCEBYTES);
-
-    return 0;
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_seal(unsigned char *c, const unsigned char *m,
-                                            unsigned long long mlen,
-                                            const unsigned char *pk)
-{
-    unsigned char nonce[crypto_box_curve25519xchacha20poly1305_NONCEBYTES];
-    unsigned char epk[crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES];
-    unsigned char esk[crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES];
-    int           ret;
-
-    if (crypto_box_curve25519xchacha20poly1305_keypair(epk, esk) != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    _crypto_box_curve25519xchacha20poly1305_seal_nonce(nonce, epk, pk);
-    ret = crypto_box_curve25519xchacha20poly1305_easy(
-         c + crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES, m, mlen,
-         nonce, pk, esk);
-    memcpy(c, epk, crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES);
-    sodium_memzero(esk, sizeof esk);
-    sodium_memzero(epk, sizeof epk);
-    sodium_memzero(nonce, sizeof nonce);
-
-    return ret;
-}
-
-int
-crypto_box_curve25519xchacha20poly1305_seal_open(unsigned char *m, const unsigned char *c,
-                                                 unsigned long long clen,
-                                                 const unsigned char *pk,
-                                                 const unsigned char *sk)
-{
-    unsigned char nonce[crypto_box_curve25519xchacha20poly1305_NONCEBYTES];
-
-    if (clen < crypto_box_curve25519xchacha20poly1305_SEALBYTES) {
-        return -1;
-    }
-    _crypto_box_curve25519xchacha20poly1305_seal_nonce(nonce, c, pk);
-
-    COMPILER_ASSERT(crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES <
-                    crypto_box_curve25519xchacha20poly1305_SEALBYTES);
-
-    return crypto_box_curve25519xchacha20poly1305_open_easy(
-         m, c + crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES,
-         clen - crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES,
-         nonce, c, sk);
-}
-
-size_t
-crypto_box_curve25519xchacha20poly1305_sealbytes(void)
-{
-    return crypto_box_curve25519xchacha20poly1305_SEALBYTES;
-}

package/ios/libsodium-stable/src/libsodium/crypto_box/curve25519xsalsa20poly1305/box_curve25519xsalsa20poly1305.c

@@ -1,156 +0,0 @@
-#include <string.h>
-
-#include "crypto_box_curve25519xsalsa20poly1305.h"
-#include "crypto_core_hsalsa20.h"
-#include "crypto_hash_sha512.h"
-#include "crypto_scalarmult_curve25519.h"
-#include "crypto_secretbox_xsalsa20poly1305.h"
-#include "randombytes.h"
-#include "utils.h"
-
-int
-crypto_box_curve25519xsalsa20poly1305_seed_keypair(unsigned char *pk,
-                                                   unsigned char *sk,
-                                                   const unsigned char *seed)
-{
-    unsigned char hash[64];
-
-    crypto_hash_sha512(hash, seed, 32);
-    memcpy(sk, hash, 32);
-    sodium_memzero(hash, sizeof hash);
-
-    return crypto_scalarmult_curve25519_base(pk, sk);
-}
-
-int
-crypto_box_curve25519xsalsa20poly1305_keypair(unsigned char *pk,
-                                              unsigned char *sk)
-{
-    randombytes_buf(sk, 32);
-
-    return crypto_scalarmult_curve25519_base(pk, sk);
-}
-
-int
-crypto_box_curve25519xsalsa20poly1305_beforenm(unsigned char *k,
-                                               const unsigned char *pk,
-                                               const unsigned char *sk)
-{
-    static const unsigned char zero[16] = { 0 };
-    unsigned char s[32];
-
-    if (crypto_scalarmult_curve25519(s, sk, pk) != 0) {
-        return -1;
-    }
-    return crypto_core_hsalsa20(k, zero, s, NULL);
-}
-
-int
-crypto_box_curve25519xsalsa20poly1305_afternm(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_box_curve25519xsalsa20poly1305_open_afternm(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);
-}
-
-int
-crypto_box_curve25519xsalsa20poly1305(unsigned char *c, const unsigned char *m,
-                                      unsigned long long   mlen,
-                                      const unsigned char *n,
-                                      const unsigned char *pk,
-                                      const unsigned char *sk)
-{
-    unsigned char k[crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES];
-    int           ret;
-
-    if (crypto_box_curve25519xsalsa20poly1305_beforenm(k, pk, sk) != 0) {
-        return -1;
-    }
-    ret = crypto_box_curve25519xsalsa20poly1305_afternm(c, m, mlen, n, k);
-    sodium_memzero(k, sizeof k);
-
-    return ret;
-}
-
-int
-crypto_box_curve25519xsalsa20poly1305_open(
-    unsigned char *m, const unsigned char *c, unsigned long long clen,
-    const unsigned char *n, const unsigned char *pk, const unsigned char *sk)
-{
-    unsigned char k[crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES];
-    int           ret;
-
-    if (crypto_box_curve25519xsalsa20poly1305_beforenm(k, pk, sk) != 0) {
-        return -1;
-    }
-    ret = crypto_box_curve25519xsalsa20poly1305_open_afternm(m, c, clen, n, k);
-    sodium_memzero(k, sizeof k);
-
-    return ret;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_seedbytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_SEEDBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_publickeybytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_secretkeybytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_beforenmbytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_noncebytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_NONCEBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_zerobytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_ZEROBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_boxzerobytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_macbytes(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_MACBYTES;
-}
-
-size_t
-crypto_box_curve25519xsalsa20poly1305_messagebytes_max(void)
-{
-    return crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX;
-}

package/ios/libsodium-stable/src/libsodium/crypto_core/ed25519/core_ed25519.c

@@ -1,225 +0,0 @@
-
-#include <stdint.h>
-
-#include "crypto_core_ed25519.h"
-#include "private/common.h"
-#include "private/ed25519_ref10.h"
-#include "randombytes.h"
-#include "utils.h"
-
-int
-crypto_core_ed25519_is_valid_point(const unsigned char *p)
-{
-    ge25519_p3 p_p3;
-
-    if (ge25519_is_canonical(p) == 0 ||
-        ge25519_has_small_order(p) != 0 ||
-        ge25519_frombytes(&p_p3, p) != 0 ||
-        ge25519_is_on_curve(&p_p3) == 0 ||
-        ge25519_is_on_main_subgroup(&p_p3) == 0) {
-        return 0;
-    }
-    return 1;
-}
-
-int
-crypto_core_ed25519_add(unsigned char *r,
-                        const unsigned char *p, const unsigned char *q)
-{
-    ge25519_p3     p_p3, q_p3, r_p3;
-    ge25519_p1p1   r_p1p1;
-    ge25519_cached q_cached;
-
-    if (ge25519_frombytes(&p_p3, p) != 0 || ge25519_is_on_curve(&p_p3) == 0 ||
-        ge25519_frombytes(&q_p3, q) != 0 || ge25519_is_on_curve(&q_p3) == 0) {
-        return -1;
-    }
-    ge25519_p3_to_cached(&q_cached, &q_p3);
-    ge25519_add(&r_p1p1, &p_p3, &q_cached);
-    ge25519_p1p1_to_p3(&r_p3, &r_p1p1);
-    ge25519_p3_tobytes(r, &r_p3);
-
-    return 0;
-}
-
-int
-crypto_core_ed25519_sub(unsigned char *r,
-                        const unsigned char *p, const unsigned char *q)
-{
-    ge25519_p3     p_p3, q_p3, r_p3;
-    ge25519_p1p1   r_p1p1;
-    ge25519_cached q_cached;
-
-    if (ge25519_frombytes(&p_p3, p) != 0 || ge25519_is_on_curve(&p_p3) == 0 ||
-        ge25519_frombytes(&q_p3, q) != 0 || ge25519_is_on_curve(&q_p3) == 0) {
-        return -1;
-    }
-    ge25519_p3_to_cached(&q_cached, &q_p3);
-    ge25519_sub(&r_p1p1, &p_p3, &q_cached);
-    ge25519_p1p1_to_p3(&r_p3, &r_p1p1);
-    ge25519_p3_tobytes(r, &r_p3);
-
-    return 0;
-}
-
-int
-crypto_core_ed25519_from_uniform(unsigned char *p, const unsigned char *r)
-{
-    ge25519_from_uniform(p, r);
-
-    return 0;
-}
-
-int
-crypto_core_ed25519_from_hash(unsigned char *p, const unsigned char *h)
-{
-    ge25519_from_hash(p, h);
-
-    return 0;
-}
-
-void
-crypto_core_ed25519_random(unsigned char *p)
-{
-    unsigned char h[crypto_core_ed25519_UNIFORMBYTES];
-
-    randombytes_buf(h, sizeof h);
-    (void) crypto_core_ed25519_from_uniform(p, h);
-}
-
-void
-crypto_core_ed25519_scalar_random(unsigned char *r)
-{
-    do {
-        randombytes_buf(r, crypto_core_ed25519_SCALARBYTES);
-        r[crypto_core_ed25519_SCALARBYTES - 1] &= 0x1f;
-    } while (sc25519_is_canonical(r) == 0 ||
-             sodium_is_zero(r, crypto_core_ed25519_SCALARBYTES));
-}
-
-int
-crypto_core_ed25519_scalar_invert(unsigned char *recip, const unsigned char *s)
-{
-    sc25519_invert(recip, s);
-
-    return - sodium_is_zero(s, crypto_core_ed25519_SCALARBYTES);
-}
-
-/* 2^252+27742317777372353535851937790883648493 */
-static const unsigned char L[] = {
-    0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7,
-    0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10
-};
-
-void
-crypto_core_ed25519_scalar_negate(unsigned char *neg, const unsigned char *s)
-{
-    unsigned char t_[crypto_core_ed25519_NONREDUCEDSCALARBYTES];
-    unsigned char s_[crypto_core_ed25519_NONREDUCEDSCALARBYTES];
-
-    COMPILER_ASSERT(crypto_core_ed25519_NONREDUCEDSCALARBYTES >=
-                    2 * crypto_core_ed25519_SCALARBYTES);
-    memset(t_, 0, sizeof t_);
-    memset(s_, 0, sizeof s_);
-    memcpy(t_ + crypto_core_ed25519_SCALARBYTES, L,
-           crypto_core_ed25519_SCALARBYTES);
-    memcpy(s_, s, crypto_core_ed25519_SCALARBYTES);
-    sodium_sub(t_, s_, sizeof t_);
-    sc25519_reduce(t_);
-    memcpy(neg, t_, crypto_core_ed25519_SCALARBYTES);
-}
-
-void
-crypto_core_ed25519_scalar_complement(unsigned char *comp,
-                                      const unsigned char *s)
-{
-    unsigned char t_[crypto_core_ed25519_NONREDUCEDSCALARBYTES];
-    unsigned char s_[crypto_core_ed25519_NONREDUCEDSCALARBYTES];
-
-    COMPILER_ASSERT(crypto_core_ed25519_NONREDUCEDSCALARBYTES >=
-                    2 * crypto_core_ed25519_SCALARBYTES);
-    memset(t_, 0, sizeof t_);
-    memset(s_, 0, sizeof s_);
-    t_[0]++;
-    memcpy(t_ + crypto_core_ed25519_SCALARBYTES, L,
-           crypto_core_ed25519_SCALARBYTES);
-    memcpy(s_, s, crypto_core_ed25519_SCALARBYTES);
-    sodium_sub(t_, s_, sizeof t_);
-    sc25519_reduce(t_);
-    memcpy(comp, t_, crypto_core_ed25519_SCALARBYTES);
-}
-
-void
-crypto_core_ed25519_scalar_add(unsigned char *z, const unsigned char *x,
-                               const unsigned char *y)
-{
-    unsigned char x_[crypto_core_ed25519_NONREDUCEDSCALARBYTES];
-    unsigned char y_[crypto_core_ed25519_NONREDUCEDSCALARBYTES];
-
-    memset(x_, 0, sizeof x_);
-    memset(y_, 0, sizeof y_);
-    memcpy(x_, x, crypto_core_ed25519_SCALARBYTES);
-    memcpy(y_, y, crypto_core_ed25519_SCALARBYTES);
-    sodium_add(x_, y_, crypto_core_ed25519_SCALARBYTES);
-    crypto_core_ed25519_scalar_reduce(z, x_);
-}
-
-void
-crypto_core_ed25519_scalar_sub(unsigned char *z, const unsigned char *x,
-                               const unsigned char *y)
-{
-    unsigned char yn[crypto_core_ed25519_SCALARBYTES];
-
-    crypto_core_ed25519_scalar_negate(yn, y);
-    crypto_core_ed25519_scalar_add(z, x, yn);
-}
-
-void
-crypto_core_ed25519_scalar_mul(unsigned char *z, const unsigned char *x,
-                               const unsigned char *y)
-{
-    sc25519_mul(z, x, y);
-}
-
-void
-crypto_core_ed25519_scalar_reduce(unsigned char *r,
-                                  const unsigned char *s)
-{
-    unsigned char t[crypto_core_ed25519_NONREDUCEDSCALARBYTES];
-
-    memcpy(t, s, sizeof t);
-    sc25519_reduce(t);
-    memcpy(r, t, crypto_core_ed25519_SCALARBYTES);
-    sodium_memzero(t, sizeof t);
-}
-
-size_t
-crypto_core_ed25519_bytes(void)
-{
-    return crypto_core_ed25519_BYTES;
-}
-
-size_t
-crypto_core_ed25519_nonreducedscalarbytes(void)
-{
-    return crypto_core_ed25519_NONREDUCEDSCALARBYTES;
-}
-
-size_t
-crypto_core_ed25519_uniformbytes(void)
-{
-    return crypto_core_ed25519_UNIFORMBYTES;
-}
-
-size_t
-crypto_core_ed25519_hashbytes(void)
-{
-    return crypto_core_ed25519_HASHBYTES;
-}
-
-size_t
-crypto_core_ed25519_scalarbytes(void)
-{
-    return crypto_core_ed25519_SCALARBYTES;
-}