rbnacl-libsodium 1.0.6 → 1.0.7

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

@@ -16,9 +16,8 @@ extern "C" {
 #include <stdint.h>
 #include <stdio.h>
 
-typedef struct crypto_onetimeauth_poly1305_state {
-    unsigned long long aligner;
-    unsigned char      opaque[136];
+typedef CRYPTO_ALIGN(16) struct crypto_onetimeauth_poly1305_state {
+    unsigned char opaque[256];
 } crypto_onetimeauth_poly1305_state;
 
 #define crypto_onetimeauth_poly1305_BYTES 16U

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

@@ -27,7 +27,8 @@ int crypto_scalarmult_base(unsigned char *q, const unsigned char *n);
 
 SODIUM_EXPORT
 int crypto_scalarmult(unsigned char *q, const unsigned char *n,
-                      const unsigned char *p);
+                      const unsigned char *p)
+            __attribute__ ((warn_unused_result));
 
 #ifdef __cplusplus
 }

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

@@ -19,11 +19,16 @@ size_t crypto_scalarmult_curve25519_scalarbytes(void);
 
 SODIUM_EXPORT
 int crypto_scalarmult_curve25519(unsigned char *q, const unsigned char *n,
-                                 const unsigned char *p);
+                                 const unsigned char *p)
+            __attribute__ ((warn_unused_result));
 
 SODIUM_EXPORT
 int crypto_scalarmult_curve25519_base(unsigned char *q, const unsigned char *n);
 
+/* ------------------------------------------------------------------------- */
+
+int _crypto_scalarmult_curve25519_pick_best_implementation(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -65,6 +65,11 @@ int crypto_stream_chacha20_ietf_xor_ic(unsigned char *c, const unsigned char *m,
                                        unsigned long long mlen,
                                        const unsigned char *n, uint32_t ic,
                                        const unsigned char *k);
+
+/* ------------------------------------------------------------------------- */
+
+int _crypto_stream_chacha20_pick_best_implementation(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -4,33 +4,19 @@
 
 #ifdef __native_client__
 
-#include <stddef.h>
-#include <stdint.h>
+# include "export.h"
+# include "randombytes.h"
 
-#include "export.h"
-
-#ifdef __cplusplus
+# ifdef __cplusplus
 extern "C" {
-#endif
+# endif
 
 SODIUM_EXPORT
 extern struct randombytes_implementation randombytes_nativeclient_implementation;
 
-SODIUM_EXPORT
-const char *randombytes_nativeclient_implementation_name(void);
-
-SODIUM_EXPORT
-uint32_t    randombytes_nativeclient(void);
-
-SODIUM_EXPORT
-uint32_t    randombytes_nativeclient_uniform(const uint32_t upper_bound);
-
-SODIUM_EXPORT
-void        randombytes_nativeclient_buf(void * const buf, const size_t size);
-
-#ifdef __cplusplus
+# ifdef __cplusplus
 }
-#endif
+# endif
 
 #endif
 

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

@@ -2,17 +2,8 @@
 #ifndef randombytes_salsa20_random_H
 #define randombytes_salsa20_random_H
 
-/*
- * THREAD SAFETY: randombytes_salsa20_random*() functions are
- * not thread-safe.
- * Always wrap them in a mutex if you need thread safety,
- * and call randombytes_stir() after fork()ing.
- */
-
-#include <stddef.h>
-#include <stdint.h>
-
 #include "export.h"
+#include "randombytes.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -21,24 +12,6 @@ extern "C" {
 SODIUM_EXPORT
 extern struct randombytes_implementation randombytes_salsa20_implementation;
 
-SODIUM_EXPORT
-const char *randombytes_salsa20_implementation_name(void);
-
-SODIUM_EXPORT
-uint32_t    randombytes_salsa20_random(void);
-
-SODIUM_EXPORT
-void        randombytes_salsa20_random_stir(void);
-
-SODIUM_EXPORT
-uint32_t    randombytes_salsa20_random_uniform(const uint32_t upper_bound);
-
-SODIUM_EXPORT
-void        randombytes_salsa20_random_buf(void * const buf, const size_t size);
-
-SODIUM_EXPORT
-int         randombytes_salsa20_random_close(void);
-
 #ifdef __cplusplus
 }
 #endif

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

@@ -2,16 +2,8 @@
 #ifndef randombytes_sysrandom_H
 #define randombytes_sysrandom_H
 
-/*
- * THREAD SAFETY: randombytes_sysrandom() functions are thread-safe,
- * provided that you called sodium_init() once before using any
- * other libsodium function.
- */
-
-#include <stddef.h>
-#include <stdint.h>
-
 #include "export.h"
+#include "randombytes.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -20,24 +12,6 @@ extern "C" {
 SODIUM_EXPORT
 extern struct randombytes_implementation randombytes_sysrandom_implementation;
 
-SODIUM_EXPORT
-const char *randombytes_sysrandom_implementation_name(void);
-
-SODIUM_EXPORT
-uint32_t    randombytes_sysrandom(void);
-
-SODIUM_EXPORT
-void        randombytes_sysrandom_stir(void);
-
-SODIUM_EXPORT
-uint32_t    randombytes_sysrandom_uniform(const uint32_t upper_bound);
-
-SODIUM_EXPORT
-void        randombytes_sysrandom_buf(void * const buf, const size_t size);
-
-SODIUM_EXPORT
-int         randombytes_sysrandom_close(void);
-
 #ifdef __cplusplus
 }
 #endif

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

@@ -23,6 +23,9 @@ int sodium_runtime_has_ssse3(void);
 SODIUM_EXPORT
 int sodium_runtime_has_sse41(void);
 
+SODIUM_EXPORT
+int sodium_runtime_has_avx(void);
+
 SODIUM_EXPORT
 int sodium_runtime_has_pclmul(void);
 

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

@@ -40,9 +40,15 @@ int sodium_compare(const unsigned char *b1_, const unsigned char *b2_,
                    size_t len)
             __attribute__ ((warn_unused_result));
 
+SODIUM_EXPORT
+int sodium_is_zero(const unsigned char *n, const size_t nlen);
+
 SODIUM_EXPORT
 void sodium_increment(unsigned char *n, const size_t nlen);
 
+SODIUM_EXPORT
+void sodium_add(unsigned char *a, const unsigned char *b, const size_t len);
+
 SODIUM_EXPORT
 char *sodium_bin2hex(char * const hex, const size_t hex_maxlen,
                      const unsigned char * const bin, const size_t bin_len);

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

@@ -10,7 +10,7 @@
 # include "randombytes.h"
 # include "randombytes_nativeclient.h"
 
-void
+static void
 randombytes_nativeclient_buf(void * const buf, const size_t size)
 {
     size_t readnb;
@@ -21,7 +21,7 @@ randombytes_nativeclient_buf(void * const buf, const size_t size)
     assert(readnb == size);
 }
 
-uint32_t
+static uint32_t
 randombytes_nativeclient_random(void)
 {
     uint32_t r;
@@ -31,7 +31,7 @@ randombytes_nativeclient_random(void)
     return r;
 }
 
-const char *
+static const char *
 randombytes_nativeclient_implementation_name(void)
 {
     return "nativeclient";

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

@@ -20,7 +20,7 @@
 #endif
 
 #include "crypto_core_salsa20.h"
-#include "crypto_auth_hmacsha512256.h"
+#include "crypto_generichash.h"
 #include "crypto_stream_salsa20.h"
 #include "randombytes.h"
 #include "randombytes_salsa20_random.h"
@@ -38,14 +38,17 @@ BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
 #endif
 
 #define SALSA20_RANDOM_BLOCK_SIZE crypto_core_salsa20_OUTPUTBYTES
-#define SHA512_BLOCK_SIZE 128U
-#define SHA512_MIN_PAD_SIZE (1U + 16U)
+#define HASH_BLOCK_SIZE 128U
 #define COMPILER_ASSERT(X) (void) sizeof(char[(X) ? 1 : -1])
 
 #if defined(__OpenBSD__) || defined(__CloudABI__)
 # define HAVE_SAFE_ARC4RANDOM 1
 #endif
 
+#ifndef SSIZE_MAX
+# define SSIZE_MAX (SIZE_MAX / 2 - 1)
+#endif
+
 typedef struct Salsa20Random_ {
     unsigned char key[crypto_stream_salsa20_KEYBYTES];
     unsigned char rnd32[16U * SALSA20_RANDOM_BLOCK_SIZE];
@@ -98,6 +101,7 @@ safe_read(const int fd, void * const buf_, size_t size)
     ssize_t        readnb;
 
     assert(size > (size_t) 0U);
+    assert(size <= SSIZE_MAX);
     do {
         while ((readnb = read(fd, buf, size)) < (ssize_t) 0 &&
                (errno == EINTR || errno == EAGAIN));  /* LCOV_EXCL_LINE */
@@ -251,18 +255,19 @@ randombytes_salsa20_random_rekey(const unsigned char * const mix)
     }
 }
 
-void
+static void
 randombytes_salsa20_random_stir(void)
 {
-    const unsigned char s[crypto_auth_hmacsha512256_KEYBYTES] = {
-        'T', 'h', 'i', 's', 'I', 's', 'J', 'u', 's', 't', 'A', 'T',
-        'h', 'i', 'r', 't', 'y', 'T', 'w', 'o', 'B', 'y', 't', 'e',
-        's', 'S', 'e', 'e', 'd', '.', '.', '.'
+    /* constant to personalize the hash function */
+    const unsigned char hsigma[crypto_generichash_KEYBYTES] = {
+        0x54, 0x68, 0x69, 0x73, 0x49, 0x73, 0x4a, 0x75,
+        0x73, 0x74, 0x41, 0x54, 0x68, 0x69, 0x72, 0x74,
+        0x79, 0x54, 0x77, 0x6f, 0x42, 0x79, 0x74, 0x65,
+        0x73, 0x53, 0x65, 0x65, 0x64, 0x2e, 0x2e, 0x2e
     };
-    unsigned char  m0[crypto_auth_hmacsha512256_BYTES +
-                      2U * SHA512_BLOCK_SIZE - SHA512_MIN_PAD_SIZE];
-    unsigned char *k0 = m0 + crypto_auth_hmacsha512256_BYTES;
-    size_t         sizeof_k0 = sizeof m0 - crypto_auth_hmacsha512256_BYTES;
+    unsigned char  m0[crypto_stream_salsa20_KEYBYTES + HASH_BLOCK_SIZE];
+    unsigned char *k0 = m0 + crypto_stream_salsa20_KEYBYTES;
+    size_t         sizeof_k0 = sizeof m0 - crypto_stream_salsa20_KEYBYTES;
 
     memset(stream.rnd32, 0, sizeof stream.rnd32);
     stream.rnd32_outleft = (size_t) 0U;
@@ -297,8 +302,10 @@ randombytes_salsa20_random_stir(void)
         abort(); /* LCOV_EXCL_LINE */
     }
 #endif
-    COMPILER_ASSERT(sizeof stream.key == crypto_auth_hmacsha512256_BYTES);
-    crypto_auth_hmacsha512256(stream.key, k0, sizeof_k0, s);
+    if (crypto_generichash(stream.key, sizeof stream.key, k0, sizeof_k0,
+                           hsigma, sizeof hsigma) != 0) {
+        abort();
+    }
     COMPILER_ASSERT(sizeof stream.key <= sizeof m0);
     randombytes_salsa20_random_rekey(m0);
     sodium_memzero(m0, sizeof m0);
@@ -323,35 +330,7 @@ randombytes_salsa20_random_stir_if_needed(void)
 #endif
 }
 
-static uint32_t
-randombytes_salsa20_random_getword(void)
-{
-    uint32_t val;
-    int      ret;
-
-    COMPILER_ASSERT(sizeof stream.rnd32 >= (sizeof stream.key) + (sizeof val));
-    COMPILER_ASSERT(((sizeof stream.rnd32) - (sizeof stream.key))
-                    % sizeof val == (size_t) 0U);
-    if (stream.rnd32_outleft <= (size_t) 0U) {
-        randombytes_salsa20_random_stir_if_needed();
-        COMPILER_ASSERT(sizeof stream.nonce == crypto_stream_salsa20_NONCEBYTES);
-        ret = crypto_stream_salsa20((unsigned char *) stream.rnd32,
-                                    (unsigned long long) sizeof stream.rnd32,
-                                    (unsigned char *) &stream.nonce,
-                                    stream.key);
-        assert(ret == 0);
-        stream.rnd32_outleft = (sizeof stream.rnd32) - (sizeof stream.key);
-        randombytes_salsa20_random_rekey(&stream.rnd32[stream.rnd32_outleft]);
-        stream.nonce++;
-    }
-    stream.rnd32_outleft -= sizeof val;
-    memcpy(&val, &stream.rnd32[stream.rnd32_outleft], sizeof val);
-    memset(&stream.rnd32[stream.rnd32_outleft], 0, sizeof val);
-
-    return val;
-}
-
-int
+static int
 randombytes_salsa20_random_close(void)
 {
     int ret = -1;
@@ -386,13 +365,7 @@ randombytes_salsa20_random_close(void)
     return ret;
 }
 
-uint32_t
-randombytes_salsa20_random(void)
-{
-    return randombytes_salsa20_random_getword();
-}
-
-void
+static void
 randombytes_salsa20_random_buf(void * const buf, const size_t size)
 {
     size_t i;
@@ -415,7 +388,41 @@ randombytes_salsa20_random_buf(void * const buf, const size_t size)
                               (unsigned char *) &stream.nonce, stream.key);
 }
 
-const char *
+static uint32_t
+randombytes_salsa20_random_getword(void)
+{
+    uint32_t val;
+    int      ret;
+
+    COMPILER_ASSERT(sizeof stream.rnd32 >= (sizeof stream.key) + (sizeof val));
+    COMPILER_ASSERT(((sizeof stream.rnd32) - (sizeof stream.key))
+                    % sizeof val == (size_t) 0U);
+    if (stream.rnd32_outleft <= (size_t) 0U) {
+        randombytes_salsa20_random_stir_if_needed();
+        COMPILER_ASSERT(sizeof stream.nonce == crypto_stream_salsa20_NONCEBYTES);
+        ret = crypto_stream_salsa20((unsigned char *) stream.rnd32,
+                                    (unsigned long long) sizeof stream.rnd32,
+                                    (unsigned char *) &stream.nonce,
+                                    stream.key);
+        assert(ret == 0);
+        stream.rnd32_outleft = (sizeof stream.rnd32) - (sizeof stream.key);
+        randombytes_salsa20_random_rekey(&stream.rnd32[stream.rnd32_outleft]);
+        stream.nonce++;
+    }
+    stream.rnd32_outleft -= sizeof val;
+    memcpy(&val, &stream.rnd32[stream.rnd32_outleft], sizeof val);
+    memset(&stream.rnd32[stream.rnd32_outleft], 0, sizeof val);
+
+    return val;
+}
+
+static uint32_t
+randombytes_salsa20_random(void)
+{
+    return randombytes_salsa20_random_getword();
+}
+
+static const char *
 randombytes_salsa20_implementation_name(void)
 {
     return "salsa20";

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

@@ -37,26 +37,30 @@ BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
 # define HAVE_SAFE_ARC4RANDOM 1
 #endif
 
+#ifndef SSIZE_MAX
+# define SSIZE_MAX (SIZE_MAX / 2 - 1)
+#endif
+
 #ifdef HAVE_SAFE_ARC4RANDOM
 
-uint32_t
+static uint32_t
 randombytes_sysrandom(void)
 {
     return arc4random();
 }
 
-void
+static void
 randombytes_sysrandom_stir(void)
 {
 }
 
-void
+static void
 randombytes_sysrandom_buf(void * const buf, const size_t size)
 {
     return arc4random_buf(buf, size);
 }
 
-int
+static int
 randombytes_sysrandom_close(void)
 {
     return 0;
@@ -84,6 +88,7 @@ safe_read(const int fd, void * const buf_, size_t size)
     ssize_t        readnb;
 
     assert(size > (size_t) 0U);
+    assert(size <= SSIZE_MAX);
     do {
         while ((readnb = read(fd, buf, size)) < (ssize_t) 0 &&
                (errno == EINTR || errno == EAGAIN)); /* LCOV_EXCL_LINE */
@@ -214,7 +219,7 @@ randombytes_sysrandom_init(void)
 }
 #endif
 
-void
+static void
 randombytes_sysrandom_stir(void)
 {
     if (stream.initialized == 0) {
@@ -231,7 +236,7 @@ randombytes_sysrandom_stir_if_needed(void)
     }
 }
 
-int
+static int
 randombytes_sysrandom_close(void)
 {
     int ret = -1;
@@ -257,17 +262,7 @@ randombytes_sysrandom_close(void)
     return ret;
 }
 
-uint32_t
-randombytes_sysrandom(void)
-{
-    uint32_t r;
-
-    randombytes_sysrandom_buf(&r, sizeof r);
-
-    return r;
-}
-
-void
+static void
 randombytes_sysrandom_buf(void * const buf, const size_t size)
 {
     randombytes_sysrandom_stir_if_needed();
@@ -298,9 +293,19 @@ randombytes_sysrandom_buf(void * const buf, const size_t size)
 #endif
 }
 
+static uint32_t
+randombytes_sysrandom(void)
+{
+    uint32_t r;
+
+    randombytes_sysrandom_buf(&r, sizeof r);
+
+    return r;
+}
+
 #endif /* __OpenBSD__ */
 
-const char *
+static const char *
 randombytes_sysrandom_implementation_name(void)
 {
     return "sysrandom";