rbnacl-libsodium 0.4.5 → 0.5.0

data/vendor/libsodium/src/libsodium/include/sodium/runtime.h

@@ -0,0 +1,27 @@
+
+#ifndef __SODIUM_RUNTIME_H__
+#define __SODIUM_RUNTIME_H__ 1
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+int sodium_runtime_get_cpu_features(void);
+
+SODIUM_EXPORT
+int sodium_runtime_has_neon(void);
+
+SODIUM_EXPORT
+int sodium_runtime_has_sse2(void);
+
+SODIUM_EXPORT
+int sodium_runtime_has_sse3(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/libsodium/src/libsodium/include/sodium/utils.h

@@ -23,11 +23,23 @@ SODIUM_EXPORT
 void sodium_memzero(void * const pnt, const size_t len);
 
 SODIUM_EXPORT
-int sodium_memcmp(const void * const b1_, const void * const b2_, size_t size);
+int sodium_memcmp(const void * const b1_, const void * const b2_, size_t len);
 
 SODIUM_EXPORT
-char *sodium_bin2hex(char * const hex, const size_t hexlen,
-                     const unsigned char *bin, const size_t binlen);
+char *sodium_bin2hex(char * const hex, const size_t hex_maxlen,
+                     const unsigned char * const bin, const size_t bin_len);
+
+SODIUM_EXPORT
+int sodium_hex2bin(unsigned char * const bin, const size_t bin_maxlen,
+                   const char * const hex, const size_t hex_len,
+                   const char * const ignore, size_t * const bin_len,
+                   const char ** const hex_end);
+
+SODIUM_EXPORT
+int sodium_mlock(void * const addr, const size_t len);
+
+SODIUM_EXPORT
+int sodium_munlock(void * const addr, const size_t len);
 
 #ifdef __cplusplus
 }

data/vendor/libsodium/src/libsodium/randombytes/randombytes.c

@@ -46,7 +46,9 @@ randombytes_uniform(const uint32_t upper_bound)
 void
 randombytes_buf(void * const buf, const size_t size)
 {
-    implementation->buf(buf, size);
+    if (size > (size_t) 0U) {
+        implementation->buf(buf, size);
+    }
 }
 
 int

data/vendor/libsodium/src/libsodium/randombytes/salsa20/randombytes_salsa20_random.c

@@ -1,6 +1,7 @@
 
 #include <sys/types.h>
 #ifndef _WIN32
+# include <sys/stat.h>
 # include <sys/time.h>
 #endif
 
@@ -85,6 +86,7 @@ safe_read(const int fd, void * const buf_, size_t count)
     unsigned char *buf = (unsigned char *) buf_;
     ssize_t        readnb;
 
+    assert(count > (size_t) 0U);
     do {
         while ((readnb = read(fd, buf, count)) < (ssize_t) 0 &&
                errno == EINTR);
@@ -106,17 +108,23 @@ safe_read(const int fd, void * const buf_, size_t count)
 static int
 randombytes_salsa20_random_random_dev_open(void)
 {
-    static const char * const devices[] = {
+    struct stat       st;
+    static const char *devices[] = {
 # ifndef USE_BLOCKING_RANDOM
-        "/dev/arandom", "/dev/urandom",
+        "/dev/urandom",
 # endif
         "/dev/random", NULL
     };
-    const char * const *device = devices;
+    const char **     device = devices;
+    int               fd;
 
     do {
-        if (access(*device, F_OK | R_OK) == 0) {
-            return open(*device, O_RDONLY);
+        if (access(*device, F_OK | R_OK) == 0 &&
+            (fd = open(*device, O_RDONLY)) != -1) {
+            if (fstat(fd, &st) == 0 && S_ISCHR(st.st_mode)) {
+                return fd;
+            }
+            (void) close(fd);
         }
         device++;
     } while (*device != NULL);
@@ -127,6 +135,8 @@ randombytes_salsa20_random_random_dev_open(void)
 static void
 randombytes_salsa20_random_init(void)
 {
+    const int errno_save = errno;
+
     stream.nonce = sodium_hrtime();
     assert(stream.nonce != (uint64_t) 0U);
 
@@ -134,6 +144,7 @@ randombytes_salsa20_random_init(void)
          randombytes_salsa20_random_random_dev_open()) == -1) {
         abort();
     }
+    errno = errno_save;
 }
 
 #else /* _WIN32 */
@@ -144,8 +155,8 @@ randombytes_salsa20_random_init(void)
     stream.nonce = sodium_hrtime();
     assert(stream.nonce != (uint64_t) 0U);
 
-    if (! CryptAcquireContext(&stream.hcrypt_prov, NULL, NULL,
-                              PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
+    if (! CryptAcquireContextW(&stream.hcrypt_prov, NULL, NULL,
+                               PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
         abort();
     }
 }

data/vendor/libsodium/src/libsodium/randombytes/sysrandom/randombytes_sysrandom.c

@@ -1,6 +1,7 @@
 
 #include <sys/types.h>
 #ifndef _WIN32
+# include <sys/stat.h>
 # include <sys/time.h>
 #endif
 
@@ -12,7 +13,6 @@
 #include <stdlib.h>
 #include <string.h>
 #ifndef _WIN32
-# include <poll.h>
 # include <unistd.h>
 #endif
 
@@ -25,6 +25,39 @@
 # include <wincrypt.h>
 #endif
 
+#ifdef __OpenBSD__
+
+uint32_t
+randombytes_sysrandom(void)
+{
+    return arc4random();
+}
+
+void
+randombytes_sysrandom_stir(void)
+{
+}
+
+uint32_t
+randombytes_sysrandom_uniform(const uint32_t upper_bound)
+{
+    return arc4random_uniform(upper_bound);
+}
+
+void
+randombytes_sysrandom_buf(void * const buf, const size_t size)
+{
+    return arc4random_buf(buf, size);
+}
+
+int
+randombytes_sysrandom_close(void)
+{
+    return 0;
+}
+
+#else /* __OpenBSD__ */
+
 typedef struct SysRandom_ {
 #ifdef _WIN32
     HCRYPTPROV hcrypt_prov;
@@ -45,6 +78,7 @@ safe_read(const int fd, void * const buf_, size_t count)
     unsigned char *buf = (unsigned char *) buf_;
     ssize_t        readnb;
 
+    assert(count > (size_t) 0U);
     do {
         while ((readnb = read(fd, buf, count)) < (ssize_t) 0 &&
                errno == EINTR);
@@ -66,17 +100,23 @@ safe_read(const int fd, void * const buf_, size_t count)
 static int
 randombytes_sysrandom_random_dev_open(void)
 {
-    static const char * const devices[] = {
+    struct stat        st;
+    static const char *devices[] = {
 # ifndef USE_BLOCKING_RANDOM
-        "/dev/arandom", "/dev/urandom",
+        "/dev/urandom",
 # endif
         "/dev/random", NULL
     };
-    const char * const *device = devices;
+    const char **      device = devices;
+    int                fd;
 
     do {
-        if (access(*device, F_OK | R_OK) == 0) {
-            return open(*device, O_RDONLY);
+        if (access(*device, F_OK | R_OK) == 0 &&
+            (fd = open(*device, O_RDONLY)) != -1) {
+            if (fstat(fd, &st) == 0 && S_ISCHR(st.st_mode)) {
+                return fd;
+            }
+            (void) close(fd);
         }
         device++;
     } while (*device != NULL);
@@ -87,10 +127,13 @@ randombytes_sysrandom_random_dev_open(void)
 static void
 randombytes_sysrandom_init(void)
 {
+    const int errno_save = errno;
+
     if ((stream.random_data_source_fd =
          randombytes_sysrandom_random_dev_open()) == -1) {
         abort();
     }
+    errno = errno_save;
 }
 
 #else /* _WIN32 */
@@ -98,8 +141,8 @@ randombytes_sysrandom_init(void)
 static void
 randombytes_sysrandom_init(void)
 {
-    if (! CryptAcquireContext(&stream.hcrypt_prov, NULL, NULL,
-                              PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
+    if (! CryptAcquireContextW(&stream.hcrypt_prov, NULL, NULL,
+                               PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
         abort();
     }
 }
@@ -166,7 +209,10 @@ randombytes_sysrandom_buf(void * const buf, const size_t size)
         abort();
     }
 #else
-    if (! CryptGenRandom(stream.hcrypt_prov, size, (BYTE *) buf)) {
+    if (size > 0xffffffff) {
+        abort();
+    }
+    if (! CryptGenRandom(stream.hcrypt_prov, (DWORD) size, (BYTE *) buf)) {
         abort();
     }
 #endif
@@ -196,6 +242,8 @@ randombytes_sysrandom_uniform(const uint32_t upper_bound)
     return r % upper_bound;
 }
 
+#endif
+
 const char *
 randombytes_sysrandom_implementation_name(void)
 {

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

@@ -8,11 +8,14 @@
 #include "crypto_scalarmult_curve25519.h"
 #include "crypto_secretbox_xsalsa20poly1305.h"
 #include "crypto_sign_ed25519.h"
+#include "crypto_stream_salsa20.h"
 #include "crypto_stream_xsalsa20.h"
 #include "crypto_verify_16.h"
 #include "crypto_verify_32.h"
 #include "export.h"
 
+#ifdef EXPORT_ORIGINAL_IMPLEMENTATIONS
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -147,6 +150,21 @@ crypto_scalarmult_curve25519_ref(unsigned char *q, const unsigned char *n,
     return crypto_scalarmult_curve25519(q, n, p);
 }
 
+#undef crypto_scalarmult_curve25519_donna_c64_base
+SODIUM_EXPORT int
+crypto_scalarmult_curve25519_donna_c64_base(unsigned char *q, const unsigned char *n)
+{
+    return crypto_scalarmult_curve25519_base(q, n);
+}
+
+#undef crypto_scalarmult_curve25519_donna_c64
+SODIUM_EXPORT int
+crypto_scalarmult_curve25519_donna_c64(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,
@@ -243,6 +261,50 @@ crypto_onetimeauth_poly1305_ref(unsigned char *out,
     return crypto_onetimeauth_poly1305(out, in, inlen, k);
 }
 
+#undef crypto_stream_salsa20_amd64_xmm6
+SODIUM_EXPORT int
+crypto_stream_salsa20_amd64_xmm6(unsigned char *c,
+                                 unsigned long long clen,
+                                 const unsigned char *n,
+                                 const unsigned char *k)
+{
+    return crypto_stream_salsa20(c, clen, n, k);
+}
+
+#undef crypto_stream_salsa20_ref
+SODIUM_EXPORT int
+crypto_stream_salsa20_ref(unsigned char *c,
+                          unsigned long long clen,
+                          const unsigned char *n,
+                          const unsigned char *k)
+{
+    return crypto_stream_salsa20(c, clen, n, k);
+}
+
+#undef crypto_stream_salsa20_amd64_xmm6_xor
+SODIUM_EXPORT int
+crypto_stream_salsa20_amd64_xmm6_xor(unsigned char *c,
+                                     const unsigned char *m,
+                                     unsigned long long mlen,
+                                     const unsigned char *n,
+                                     const unsigned char *k)
+{
+    return crypto_stream_salsa20_xor(c, m, mlen, n, k);
+}
+
+#undef crypto_stream_salsa20_ref_xor
+SODIUM_EXPORT int
+crypto_stream_salsa20_ref_xor(unsigned char *c,
+                              const unsigned char *m,
+                              unsigned long long mlen,
+                              const unsigned char *n,
+                              const unsigned char *k)
+{
+    return crypto_stream_salsa20_xor(c, m, mlen, n, k);
+}
+
 #ifdef __cplusplus
 }
 #endif
+
+#endif

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

@@ -2,6 +2,7 @@
 #include "core.h"
 #include "crypto_onetimeauth.h"
 #include "randombytes.h"
+#include "runtime.h"
 
 static int initialized;
 
@@ -11,6 +12,7 @@ sodium_init(void)
     if (initialized != 0) {
         return 1;
     }
+    sodium_runtime_get_cpu_features();
     if (crypto_onetimeauth_pick_best_implementation() == NULL) {
         return -1;
     }

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

@@ -0,0 +1,134 @@
+
+#ifdef HAVE_ANDROID_GETCPUFEATURES
+# include <cpu-features.h>
+#endif
+
+#include "runtime.h"
+
+typedef struct CPUFeatures_ {
+    int initialized;
+    int has_neon;
+    int has_sse2;
+    int has_sse3;
+} CPUFeatures;
+
+static CPUFeatures _cpu_features;
+
+#define CPUID_SSE2     0x04000000
+#define CPUIDECX_SSE3  0x00000001
+
+static int
+_sodium_runtime_arm_cpu_features(CPUFeatures * const cpu_features)
+{
+#ifndef __arm__
+    cpu_features->has_neon = 0;
+    return -1;
+#else
+# ifdef __APPLE__
+#  ifdef __ARM_NEON__
+    cpu_features->has_neon = 1;
+#  else
+    cpu_features->has_neon = 0;
+#  endif
+# elif defined(HAVE_ANDROID_GETCPUFEATURES) && defined(ANDROID_CPU_ARM_FEATURE_NEON)
+    cpu_features->has_neon =
+        (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0x0;
+# else
+    cpu_features->has_neon = 0;
+# endif
+    return 0;
+#endif
+}
+
+static void
+_cpuid(unsigned int cpu_info[4U], const unsigned int cpu_info_type)
+{
+#ifdef _MSC_VER
+    __cpuidex((int *) cpu_info, cpu_info_type, 0);
+#elif defined(HAVE_CPUID)
+    cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
+# ifdef __i386__
+    __asm__ __volatile__ ("pushfl; pushfl; "
+                          "popl %0; "
+                          "movl %0, %1; xorl %2, %0; "
+                          "pushl %0; "
+                          "popfl; pushfl; popl %0; popfl" :
+                          "=&r" (cpu_info[0]), "=&r" (cpu_info[1]) :
+                          "i" (0x200000));
+    if (((cpu_info[0] ^ cpu_info[1]) & 0x200000) == 0x0) {
+        return;
+    }
+# endif
+# ifdef __i386__
+    __asm__ __volatile__ ("xchgl %%ebx, %k1; cpuid; xchgl %%ebx, %k1" :
+                          "=a" (cpu_info[0]), "=&r" (cpu_info[1]),
+                          "=c" (cpu_info[2]), "=d" (cpu_info[3]) :
+                          "0" (cpu_info_type), "2" (0U));
+# elif defined(__x86_64__)
+    __asm__ __volatile__ ("xchgq %%rbx, %q1; cpuid; xchgq %%rbx, %q1" :
+                          "=a" (cpu_info[0]), "=&r" (cpu_info[1]),
+                          "=c" (cpu_info[2]), "=d" (cpu_info[3]) :
+                          "0" (cpu_info_type), "2" (0U));
+# else
+    __asm__ __volatile__ ("cpuid" :
+                          "=a" (cpu_info[0]), "=b" (cpu_info[1]),
+                          "=c" (cpu_info[2]), "=d" (cpu_info[3]) :
+                          "0" (cpu_info_type), "2" (0U));
+# endif
+#else
+    cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
+#endif
+}
+
+static int
+_sodium_runtime_intel_cpu_features(CPUFeatures * const cpu_features)
+{
+    unsigned int cpu_info[4];
+    unsigned int id;
+
+    _cpuid(cpu_info, 0x0);
+    if ((id = cpu_info[0]) == 0U) {
+        return -1;
+    }
+    _cpuid(cpu_info, 0x00000001);
+#ifndef HAVE_EMMINTRIN_H
+    cpu_features->has_sse2 = 0;
+#else
+    cpu_features->has_sse2 = ((cpu_info[3] & CPUID_SSE2) != 0x0);
+#endif
+
+#ifndef HAVE_PMMINTRIN_H
+    cpu_features->has_sse3 = 0;
+#else
+    cpu_features->has_sse3 = ((cpu_info[2] & CPUIDECX_SSE3) != 0x0);
+#endif
+
+    return 0;
+}
+
+int
+sodium_runtime_get_cpu_features(void)
+{
+    int ret = -1;
+
+    ret &= _sodium_runtime_arm_cpu_features(&_cpu_features);
+    ret &= _sodium_runtime_intel_cpu_features(&_cpu_features);
+    _cpu_features.initialized = 1;
+
+    return ret;
+}
+
+int
+sodium_runtime_has_neon(void) {
+    return _cpu_features.has_neon;
+}
+
+int
+sodium_runtime_has_sse2(void) {
+    return _cpu_features.has_sse2;
+}
+
+int
+sodium_runtime_has_sse3(void) {
+    return _cpu_features.has_sse3;
+}