rbnacl-libsodium 0.4.5a

data/vendor/libsodium/src/libsodium/sodium/compat.c

@@ -0,0 +1,248 @@
+
+#include "crypto_auth_hmacsha256.h"
+#include "crypto_auth_hmacsha512256.h"
+#include "crypto_box_curve25519xsalsa20poly1305.h"
+#include "crypto_hash_sha256.h"
+#include "crypto_hash_sha512.h"
+#include "crypto_onetimeauth_poly1305.h"
+#include "crypto_scalarmult_curve25519.h"
+#include "crypto_secretbox_xsalsa20poly1305.h"
+#include "crypto_sign_ed25519.h"
+#include "crypto_stream_xsalsa20.h"
+#include "crypto_verify_16.h"
+#include "crypto_verify_32.h"
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#undef crypto_hash_sha256_ref
+SODIUM_EXPORT int
+crypto_hash_sha256_ref(unsigned char *out, const unsigned char *in,
+                       unsigned long long inlen)
+{
+    return crypto_hash_sha256(out, in, inlen);
+}
+
+#undef crypto_hash_sha512_ref
+SODIUM_EXPORT int
+crypto_hash_sha512_ref(unsigned char *out, const unsigned char *in,
+                       unsigned long long inlen)
+{
+    return crypto_hash_sha512(out, in, inlen);
+}
+
+#undef crypto_auth_hmacsha256_ref
+SODIUM_EXPORT int
+crypto_auth_hmacsha256_ref(unsigned char *out, const unsigned char *in,
+                           unsigned long long inlen, const unsigned char *k)
+{
+    return crypto_auth_hmacsha256(out, in, inlen, k);
+}
+
+#undef crypto_auth_hmacsha256_ref_verify
+SODIUM_EXPORT int
+crypto_auth_hmacsha256_ref_verify(const unsigned char *h,
+                                  const unsigned char *in,
+                                  unsigned long long inlen,
+                                  const unsigned char *k)
+{
+    return crypto_auth_hmacsha256_verify(h, in, inlen, k);
+}
+
+#undef crypto_auth_hmacsha512256_ref
+SODIUM_EXPORT int
+crypto_auth_hmacsha512256_ref(unsigned char *out, const unsigned char *in,
+                              unsigned long long inlen, const unsigned char *k)
+{
+    return crypto_auth_hmacsha512256(out, in, inlen, k);
+}
+
+#undef crypto_auth_hmacsha512256_ref_verify
+SODIUM_EXPORT int
+crypto_auth_hmacsha512256_ref_verify(const unsigned char *h,
+                                     const unsigned char *in,
+                                     unsigned long long inlen,
+                                     const unsigned char *k)
+{
+    return crypto_auth_hmacsha512256_verify(h, in, inlen, k);
+}
+
+#undef crypto_box_curve25519xsalsa20poly1305_ref_keypair
+SODIUM_EXPORT int
+crypto_box_curve25519xsalsa20poly1305_ref_keypair(unsigned char *pk,
+                                                  unsigned char *sk)
+{
+    return crypto_box_curve25519xsalsa20poly1305_keypair(pk, sk);
+}
+
+#undef crypto_box_curve25519xsalsa20poly1305_ref_beforenm
+SODIUM_EXPORT int
+crypto_box_curve25519xsalsa20poly1305_ref_beforenm(unsigned char *k,
+                                                   const unsigned char *pk,
+                                                   const unsigned char *sk)
+{
+    return crypto_box_curve25519xsalsa20poly1305_beforenm(k, pk, sk);
+}
+
+#undef crypto_box_curve25519xsalsa20poly1305_ref_afternm
+SODIUM_EXPORT int
+crypto_box_curve25519xsalsa20poly1305_ref_afternm(unsigned char *c,
+                                                  const unsigned char *m,
+                                                  unsigned long long mlen,
+                                                  const unsigned char *n,
+                                                  const unsigned char *k)
+{
+    return crypto_box_curve25519xsalsa20poly1305_afternm(c, m, mlen, n, k);
+}
+
+#undef crypto_box_curve25519xsalsa20poly1305_ref_open_afternm
+SODIUM_EXPORT int
+crypto_box_curve25519xsalsa20poly1305_ref_open_afternm(unsigned char *m,
+                                                       const unsigned char *c,
+                                                       unsigned long long clen,
+                                                       const unsigned char *n,
+                                                       const unsigned char *k)
+{
+    return crypto_box_curve25519xsalsa20poly1305_open_afternm(m, c, clen, n, k);
+}
+
+#undef crypto_box_curve25519xsalsa20poly1305_ref
+SODIUM_EXPORT int
+crypto_box_curve25519xsalsa20poly1305_ref(unsigned char *c,
+                                          const unsigned char *m,
+                                          unsigned long long mlen,
+                                          const unsigned char *n,
+                                          const unsigned char *pk,
+                                          const unsigned char *sk)
+{
+    return crypto_box_curve25519xsalsa20poly1305(c, m, mlen, n, pk, sk);
+}
+
+#undef crypto_box_curve25519xsalsa20poly1305_ref_open
+SODIUM_EXPORT int
+crypto_box_curve25519xsalsa20poly1305_ref_open(unsigned char *m,
+                                               const unsigned char *c,
+                                               unsigned long long clen,
+                                               const unsigned char *n,
+                                               const unsigned char *pk,
+                                               const unsigned char *sk)
+{
+    return crypto_box_curve25519xsalsa20poly1305_open(m, c, clen, n, pk, sk);
+}
+
+#undef crypto_scalarmult_curve25519_ref_base
+SODIUM_EXPORT int
+crypto_scalarmult_curve25519_ref_base(unsigned char *q, const unsigned char *n)
+{
+    return crypto_scalarmult_curve25519_base(q, n);
+}
+
+#undef crypto_scalarmult_curve25519_ref
+SODIUM_EXPORT int
+crypto_scalarmult_curve25519_ref(unsigned char *q, const unsigned char *n,
+                                 const unsigned char *p)
+{
+    return crypto_scalarmult_curve25519(q, n, p);
+}
+
+#undef crypto_secretbox_xsalsa20poly1305_ref
+SODIUM_EXPORT int
+crypto_secretbox_xsalsa20poly1305_ref(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);
+}
+
+#undef crypto_secretbox_xsalsa20poly1305_ref_open
+SODIUM_EXPORT int
+crypto_secretbox_xsalsa20poly1305_ref_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);
+}
+
+#undef crypto_sign_ed25519_ref_seed_keypair
+SODIUM_EXPORT int
+crypto_sign_ed25519_ref_seed_keypair(unsigned char *pk, unsigned char *sk,
+                                     const unsigned char *seed)
+{
+    return crypto_sign_ed25519_seed_keypair(pk, sk, seed);
+}
+
+#undef crypto_sign_ed25519_ref_keypair
+SODIUM_EXPORT int
+crypto_sign_ed25519_ref_keypair(unsigned char *pk, unsigned char *sk)
+{
+    return crypto_sign_ed25519_keypair(pk, sk);
+}
+
+#undef crypto_sign_ed25519_ref
+SODIUM_EXPORT int
+crypto_sign_ed25519_ref(unsigned char *sm, unsigned long long *smlen,
+                        const unsigned char *m, unsigned long long mlen,
+                        const unsigned char *sk)
+{
+    return crypto_sign_ed25519(sm, smlen, m, mlen, sk);
+}
+
+#undef crypto_sign_ed25519_ref_open
+SODIUM_EXPORT int
+crypto_sign_ed25519_ref_open(unsigned char *m, unsigned long long *mlen,
+                             const unsigned char *sm, unsigned long long smlen,
+                             const unsigned char *pk)
+{
+    return crypto_sign_ed25519_open(m, mlen, sm, smlen, pk);
+}
+
+#undef crypto_stream_xsalsa20_ref
+SODIUM_EXPORT int
+crypto_stream_xsalsa20_ref(unsigned char *c, unsigned long long clen,
+                           const unsigned char *n, const unsigned char *k)
+{
+    return crypto_stream_xsalsa20(c, clen, n, k);
+}
+
+#undef crypto_stream_xsalsa20_ref_xor
+SODIUM_EXPORT int
+crypto_stream_xsalsa20_ref_xor(unsigned char *c, const unsigned char *m,
+                               unsigned long long mlen, const unsigned char *n,
+                               const unsigned char *k)
+{
+    return crypto_stream_xsalsa20_xor(c, m, mlen, n, k);
+}
+
+#undef crypto_verify_16_ref
+SODIUM_EXPORT int
+crypto_verify_16_ref(const unsigned char *x, const unsigned char *y)
+{
+    return crypto_verify_16(x, y);
+}
+
+#undef crypto_verify_32_ref
+SODIUM_EXPORT int
+crypto_verify_32_ref(const unsigned char *x, const unsigned char *y)
+{
+    return crypto_verify_32(x, y);
+}
+
+#undef crypto_onetimeauth_poly1305_ref
+SODIUM_EXPORT int
+crypto_onetimeauth_poly1305_ref(unsigned char *out,
+                                const unsigned char *in,
+                                unsigned long long inlen,
+                                const unsigned char *k)
+{
+    return crypto_onetimeauth_poly1305(out, in, inlen, k);
+}
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/libsodium/src/libsodium/sodium/core.c

@@ -0,0 +1,21 @@
+
+#include "core.h"
+#include "crypto_onetimeauth.h"
+#include "randombytes.h"
+
+static int initialized;
+
+int
+sodium_init(void)
+{
+    if (initialized != 0) {
+        return 1;
+    }
+    if (crypto_onetimeauth_pick_best_implementation() == NULL) {
+        return -1;
+    }
+    randombytes_stir();
+    initialized = 1;
+
+    return 0;
+}

data/vendor/libsodium/src/libsodium/sodium/utils.c

@@ -0,0 +1,94 @@
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "utils.h"
+#include "randombytes.h"
+#ifdef _WIN32
+# include <windows.h>
+# include <wincrypt.h>
+#endif
+
+void
+sodium_memzero(void * const pnt, const size_t len)
+{
+#ifdef HAVE_SECUREZEROMEMORY
+    SecureZeroMemory(pnt, len);
+#else
+    volatile unsigned char *pnt_ = (volatile unsigned char *) pnt;
+    size_t                     i = (size_t) 0U;
+
+    while (i < len) {
+        pnt_[i++] = 0U;
+    }
+#endif
+}
+
+int
+sodium_memcmp(const void * const b1_, const void * const b2_, size_t size)
+{
+    const unsigned char *b1 = (const unsigned char *) b1_;
+    const unsigned char *b2 = (const unsigned char *) b2_;
+    size_t               i;
+    unsigned char        d = (unsigned char) 0U;
+
+    for (i = 0U; i < size; i++) {
+        d |= b1[i] ^ b2[i];
+    }
+    return (int) d;
+}
+
+unsigned char *
+_sodium_alignedcalloc(unsigned char ** const unaligned_p, const size_t len)
+{
+    unsigned char *aligned;
+    unsigned char *unaligned;
+    size_t         i;
+
+    if (SIZE_MAX - (size_t) 256U < len ||
+        (unaligned = (unsigned char *) malloc(len + (size_t) 256U)) == NULL) {
+        *unaligned_p = NULL;
+        return NULL;
+    }
+    *unaligned_p = unaligned;
+#ifdef HAVE_ARC4RANDOM_BUF
+    (void) i;
+    arc4random_buf(unaligned, len + (size_t) 256U);
+#else
+    for (i = (size_t) 0U; i < len + (size_t) 256U; ++i) {
+        unaligned[i] = (unsigned char) rand();
+    }
+#endif
+    aligned = unaligned + 64;
+    aligned += (ptrdiff_t) 63 & (-(ptrdiff_t) aligned);
+    memset(aligned, 0, len);
+
+    return aligned;
+}
+
+char *
+sodium_bin2hex(char * const hex, const size_t hexlen,
+               const unsigned char *bin, const size_t binlen)
+{
+    static const char hexdigits[16] = {
+        '0', '1', '2', '3', '4', '5', '6', '7',
+        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+    };
+    size_t            i = (size_t) 0U;
+    size_t            j = (size_t) 0U;
+
+    if (binlen >= SIZE_MAX / 2 || hexlen < binlen * 2U) {
+        abort();
+    }
+    while (i < binlen) {
+        hex[j++] = hexdigits[bin[i] >> 4];
+        hex[j++] = hexdigits[bin[i] & 0xf];
+        i++;
+    }
+    hex[j] = 0;
+
+    return hex;
+}

data/vendor/libsodium/src/libsodium/sodium/version.c

@@ -0,0 +1,20 @@
+
+#include "version.h"
+
+const char *
+sodium_version_string(void)
+{
+    return SODIUM_VERSION_STRING;
+}
+
+int
+sodium_library_version_major(void)
+{
+    return SODIUM_LIBRARY_VERSION_MAJOR;
+}
+
+int
+sodium_library_version_minor(void)
+{
+    return SODIUM_LIBRARY_VERSION_MINOR;
+}

data/vendor/libsodium/test/Makefile.am

@@ -0,0 +1,5 @@
+SUBDIRS = \
+	default
+
+EXTRA_DIST = \
+	quirks/windows/windows-quirks.h

data/vendor/libsodium/test/default/Makefile.am

@@ -0,0 +1,277 @@
+
+EXTRA_DIST = \
+	cmptest.h \
+	wintest.bat \
+	auth.exp \
+	auth2.exp \
+	auth3.exp \
+	auth5.exp \
+	box.exp \
+	box2.exp \
+	box7.exp \
+	box8.exp \
+	core1.exp \
+	core2.exp \
+	core3.exp \
+	core4.exp \
+	core5.exp \
+	core6.exp \
+	generichash.exp \
+	generichash2.exp \
+	hash.exp \
+	hash2.exp \
+	hash3.exp \
+	onetimeauth.exp \
+	onetimeauth2.exp \
+	onetimeauth7.exp \
+	scalarmult.exp \
+	scalarmult2.exp \
+	scalarmult5.exp \
+	scalarmult6.exp \
+	scalarmult7.exp \
+	scalarmult8.exp \
+	secretbox.exp \
+	secretbox2.exp \
+	secretbox7.exp \
+	secretbox8.exp \
+	shorthash.exp \
+	sodium_core.exp \
+	sodium_utils.exp \
+	sodium_version.exp \
+	stream.exp \
+	stream2.exp \
+	stream3.exp \
+	stream4.exp \
+	stream5.exp \
+	stream6.exp
+
+DISTCLEANFILES = \
+	auth.res \
+	auth2.res \
+	auth3.res \
+	auth5.res \
+	box.res \
+	box2.res \
+	box7.res \
+	box8.res \
+	core1.res \
+	core2.res \
+	core3.res \
+	core4.res \
+	core5.res \
+	core6.res \
+	generichash.res \
+	generichash2.res \
+	hash.res \
+	hash2.res \
+	hash3.res \
+	onetimeauth.res \
+	onetimeauth2.res \
+	onetimeauth7.res \
+	scalarmult.res \
+	scalarmult2.res \
+	scalarmult5.res \
+	scalarmult6.res \
+	scalarmult7.res \
+	scalarmult8.res \
+	secretbox.res \
+	secretbox2.res \
+	secretbox7.res \
+	secretbox8.res \
+	shorthash.res \
+	sodium_core.res \
+	sodium_utils.res \
+	sodium_version.res \
+	stream.res \
+	stream2.res \
+	stream3.res \
+	stream4.res \
+	stream5.res \
+	stream6.res
+
+AM_CPPFLAGS = \
+	-DTEST_SRCDIR=\"@srcdir@\" \
+	-I$(top_srcdir)/src/libsodium/include \
+	-I$(top_srcdir)/src/libsodium/include/sodium \
+	-I$(top_builddir)/src/libsodium/include \
+	-I$(top_builddir)/src/libsodium/include/sodium \
+	-I$(top_srcdir)/test/quirks
+
+TESTS_TARGETS = \
+	auth \
+	auth2 \
+	auth3 \
+	auth5 \
+	box \
+	box2 \
+	box7 \
+	box8 \
+	core1 \
+	core2 \
+	core3 \
+	core4 \
+	core5 \
+	core6 \
+	generichash \
+	generichash2 \
+	hash \
+	hash3 \
+	onetimeauth \
+	onetimeauth2 \
+	onetimeauth7 \
+	randombytes \
+	scalarmult \
+	scalarmult2 \
+	scalarmult5 \
+	scalarmult6 \
+	scalarmult7 \
+	scalarmult8 \
+	secretbox \
+	secretbox2 \
+	secretbox7 \
+	secretbox8 \
+	shorthash \
+	sodium_core \
+	sodium_utils \
+	sodium_version \
+	stream \
+	stream2 \
+	stream3 \
+	stream4 \
+	stream5 \
+	stream6
+
+check_PROGRAMS = $(TESTS_TARGETS)
+
+TESTS = $(TESTS_TARGETS)
+
+TESTS_LDADD = \
+	${top_builddir}/src/libsodium/libsodium.la
+
+auth_SOURCE               = cmptest.h auth.c
+auth_LDADD                = $(TESTS_LDADD)
+
+auth2_SOURCE              = cmptest.h auth2.c
+auth2_LDADD               = $(TESTS_LDADD)
+
+auth3_SOURCE              = cmptest.h auth3.c
+auth3_LDADD               = $(TESTS_LDADD)
+
+auth5_SOURCE              = cmptest.h auth5.c windows/windows-quirks.h
+auth5_LDADD               = $(TESTS_LDADD)
+
+box_SOURCE                = cmptest.h box.c
+box_LDADD                 = $(TESTS_LDADD)
+
+box2_SOURCE               = cmptest.h box2.c
+box2_LDADD                = $(TESTS_LDADD)
+
+box7_SOURCE               = cmptest.h box7.c
+box7_LDADD                = $(TESTS_LDADD)
+
+box8_SOURCE               = cmptest.h box8.c
+box8_LDADD                = $(TESTS_LDADD)
+
+core1_SOURCE              = cmptest.h core1.c
+core1_LDADD               = $(TESTS_LDADD)
+
+core2_SOURCE              = cmptest.h core2.c
+core2_LDADD               = $(TESTS_LDADD)
+
+core3_SOURCE              = cmptest.h core3.c
+core3_LDADD               = $(TESTS_LDADD)
+
+core4_SOURCE              = cmptest.h core4.c
+core4_LDADD               = $(TESTS_LDADD)
+
+core5_SOURCE              = cmptest.h core5.c
+core5_LDADD               = $(TESTS_LDADD)
+
+core6_SOURCE              = cmptest.h core6.c
+core6_LDADD               = $(TESTS_LDADD)
+
+generichash_SOURCE        = cmptest.h generichash.c
+generichash_LDADD         = $(TESTS_LDADD)
+
+generichash2_SOURCE       = cmptest.h generichash2.c
+generichash2_LDADD        = $(TESTS_LDADD)
+
+hash_SOURCE               = cmptest.h hash.c
+hash_LDADD                = $(TESTS_LDADD)
+
+hash3_SOURCE              = cmptest.h hash3.c
+hash3_LDADD               = $(TESTS_LDADD)
+
+onetimeauth_SOURCE        = cmptest.h onetimeauth.c
+onetimeauth_LDADD         = $(TESTS_LDADD)
+
+onetimeauth2_SOURCE       = cmptest.h onetimeauth2.c
+onetimeauth2_LDADD        = $(TESTS_LDADD)
+
+onetimeauth7_SOURCE       = cmptest.h onetimeauth7.c
+onetimeauth7_LDADD        = $(TESTS_LDADD)
+
+randombytes_SOURCE        = randombytes.c
+randombytes_LDADD         = $(TESTS_LDADD)
+
+scalarmult_SOURCE         = cmptest.h scalarmult.c
+scalarmult_LDADD          = $(TESTS_LDADD)
+
+scalarmult2_SOURCE        = cmptest.h scalarmult2.c
+scalarmult2_LDADD         = $(TESTS_LDADD)
+
+scalarmult5_SOURCE        = cmptest.h scalarmult5.c
+scalarmult5_LDADD         = $(TESTS_LDADD)
+
+scalarmult6_SOURCE        = cmptest.h scalarmult6.c
+scalarmult6_LDADD         = $(TESTS_LDADD)
+
+scalarmult7_SOURCE        = cmptest.h scalarmult7.c
+scalarmult7_LDADD         = $(TESTS_LDADD)
+
+scalarmult8_SOURCE        = cmptest.h scalarmult8.c
+scalarmult8_LDADD         = $(TESTS_LDADD)
+
+secretbox_SOURCE          = cmptest.h secretbox.c
+secretbox_LDADD           = $(TESTS_LDADD)
+
+secretbox2_SOURCE         = cmptest.h secretbox2.c
+secretbox2_LDADD          = $(TESTS_LDADD)
+
+secretbox7_SOURCE         = cmptest.h secretbox7.c
+secretbox7_LDADD          = $(TESTS_LDADD)
+
+secretbox8_SOURCE         = cmptest.h secretbox8.c
+secretbox8_LDADD          = $(TESTS_LDADD)
+
+shorthash_SOURCE          = cmptest.h shorthash.c
+shorthash_LDADD           = $(TESTS_LDADD)
+
+sodium_core_SOURCE        = cmptest.h sodium_core.c
+sodium_core_LDADD         = $(TESTS_LDADD)
+
+sodium_utils_SOURCE       = cmptest.h sodium_utils.c
+sodium_utils_LDADD        = $(TESTS_LDADD)
+
+sodium_version_SOURCE     = cmptest.h sodium_version.c
+sodium_version_LDADD      = $(TESTS_LDADD)
+
+stream_SOURCE             = cmptest.h stream.c
+stream_LDADD              = $(TESTS_LDADD)
+
+stream2_SOURCE            = cmptest.h stream2.c
+stream2_LDADD             = $(TESTS_LDADD)
+
+stream3_SOURCE            = cmptest.h stream3.c
+stream3_LDADD             = $(TESTS_LDADD)
+
+stream4_SOURCE            = cmptest.h stream4.c
+stream4_LDADD             = $(TESTS_LDADD)
+
+stream5_SOURCE            = cmptest.h stream5.c
+stream5_LDADD             = $(TESTS_LDADD)
+
+stream6_SOURCE            = cmptest.h stream6.c
+stream6_LDADD             = $(TESTS_LDADD)
+
+verify: check