rbnacl-libsodium 1.0.11 → 1.0.13

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

@@ -45,9 +45,16 @@ int crypto_stream_chacha20_xor_ic(unsigned char *c, const unsigned char *m,
                                   const unsigned char *n, uint64_t ic,
                                   const unsigned char *k);
 
+SODIUM_EXPORT
+void crypto_stream_chacha20_keygen(unsigned char k[crypto_stream_chacha20_KEYBYTES]);
+
 /* ChaCha20 with a 96-bit nonce and a 32-bit counter (IETF) */
 
-#define crypto_stream_chacha20_IETF_NONCEBYTES 12U
+#define crypto_stream_chacha20_ietf_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_chacha20_ietf_keybytes(void);
+
+#define crypto_stream_chacha20_ietf_NONCEBYTES 12U
 SODIUM_EXPORT
 size_t crypto_stream_chacha20_ietf_noncebytes(void);
 
@@ -66,9 +73,13 @@ int crypto_stream_chacha20_ietf_xor_ic(unsigned char *c, const unsigned char *m,
                                        const unsigned char *n, uint32_t ic,
                                        const unsigned char *k);
 
-/* ------------------------------------------------------------------------- */
+SODIUM_EXPORT
+void crypto_stream_chacha20_ietf_keygen(unsigned char k[crypto_stream_chacha20_ietf_KEYBYTES]);
+
+/* Aliases */
 
-int _crypto_stream_chacha20_pick_best_implementation(void);
+#define crypto_stream_chacha20_IETF_KEYBYTES crypto_stream_chacha20_ietf_KEYBYTES
+#define crypto_stream_chacha20_IETF_NONCEBYTES crypto_stream_chacha20_ietf_NONCEBYTES
 
 #ifdef __cplusplus
 }

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

@@ -42,6 +42,10 @@ int crypto_stream_salsa20_xor_ic(unsigned char *c, const unsigned char *m,
                                  unsigned long long mlen,
                                  const unsigned char *n, uint64_t ic,
                                  const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_salsa20_keygen(unsigned char k[crypto_stream_salsa20_KEYBYTES]);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -36,6 +36,9 @@ int crypto_stream_salsa2012_xor(unsigned char *c, const unsigned char *m,
                                 unsigned long long mlen, const unsigned char *n,
                                 const unsigned char *k);
 
+SODIUM_EXPORT
+void crypto_stream_salsa2012_keygen(unsigned char k[crypto_stream_salsa2012_KEYBYTES]);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -36,6 +36,9 @@ int crypto_stream_salsa208_xor(unsigned char *c, const unsigned char *m,
                                unsigned long long mlen, const unsigned char *n,
                                const unsigned char *k);
 
+SODIUM_EXPORT
+void crypto_stream_salsa208_keygen(unsigned char k[crypto_stream_salsa208_KEYBYTES]);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -0,0 +1,53 @@
+#ifndef crypto_stream_xchacha20_H
+#define crypto_stream_xchacha20_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_xchacha20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_xchacha20_keybytes(void);
+
+#define crypto_stream_xchacha20_NONCEBYTES 24U
+SODIUM_EXPORT
+size_t crypto_stream_xchacha20_noncebytes(void);
+
+SODIUM_EXPORT
+int crypto_stream_xchacha20(unsigned char *c, unsigned long long clen,
+                            const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_xchacha20_xor(unsigned char *c, const unsigned char *m,
+                                unsigned long long mlen, const unsigned char *n,
+                                const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_xchacha20_xor_ic(unsigned char *c, const unsigned char *m,
+                                   unsigned long long mlen,
+                                   const unsigned char *n, uint64_t ic,
+                                   const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_xchacha20_keygen(unsigned char k[crypto_stream_xchacha20_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -42,6 +42,10 @@ int crypto_stream_xsalsa20_xor_ic(unsigned char *c, const unsigned char *m,
                                   unsigned long long mlen,
                                   const unsigned char *n, uint64_t ic,
                                   const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_xsalsa20_keygen(unsigned char k[crypto_stream_xsalsa20_KEYBYTES]);
+
 #ifdef __cplusplus
 }
 #endif

data/vendor/libsodium/src/libsodium/include/sodium/private/common.h

@@ -5,6 +5,36 @@
 #include <stdlib.h>
 #include <string.h>
 
+#define COMPILER_ASSERT(X) (void) sizeof(char[(X) ? 1 : -1])
+
+#define ROTL32(X, B) rotl32((X), (B))
+static inline uint32_t
+rotl32(const uint32_t x, const int b)
+{
+    return (x << b) | (x >> (32 - b));
+}
+
+#define ROTL64(X, B) rotl64((X), (B))
+static inline uint64_t
+rotl64(const uint64_t x, const int b)
+{
+    return (x << b) | (x >> (64 - b));
+}
+
+#define ROTR32(X, B) rotr32((X), (B))
+static inline uint32_t
+rotr32(const uint32_t x, const int b)
+{
+    return (x >> b) | (x << (32 - b));
+}
+
+#define ROTR64(X, B) rotr64((X), (B))
+static inline uint64_t
+rotr64(const uint64_t x, const int b)
+{
+    return (x >> b) | (x << (64 - b));
+}
+
 #define LOAD64_LE(SRC) load64_le(SRC)
 static inline uint64_t
 load64_le(const uint8_t src[8])
@@ -98,23 +128,6 @@ load64_be(const uint8_t src[8])
 #endif
 }
 
-#define LOAD32_BE(SRC) load32_be(SRC)
-static inline uint32_t
-load32_be(const uint8_t src[4])
-{
-#ifdef NATIVE_BIG_ENDIAN
-    uint32_t w;
-    memcpy(&w, src, sizeof w);
-    return w;
-#else
-    uint32_t w = (uint32_t) src[3];
-    w |= (uint32_t) src[2] <<  8;
-    w |= (uint32_t) src[1] << 16;
-    w |= (uint32_t) src[0] << 24;
-    return w;
-#endif
-}
-
 #define STORE64_BE(DST, W) store64_be((DST), (W))
 static inline void
 store64_be(uint8_t dst[8], uint64_t w)
@@ -133,6 +146,23 @@ store64_be(uint8_t dst[8], uint64_t w)
 #endif
 }
 
+#define LOAD32_BE(SRC) load32_be(SRC)
+static inline uint32_t
+load32_be(const uint8_t src[4])
+{
+#ifdef NATIVE_BIG_ENDIAN
+    uint32_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    uint32_t w = (uint32_t) src[3];
+    w |= (uint32_t) src[2] <<  8;
+    w |= (uint32_t) src[1] << 16;
+    w |= (uint32_t) src[0] << 24;
+    return w;
+#endif
+}
+
 #define STORE32_BE(DST, W) store32_be((DST), (W))
 static inline void
 store32_be(uint8_t dst[4], uint32_t w)
@@ -147,4 +177,41 @@ store32_be(uint8_t dst[4], uint32_t w)
 #endif
 }
 
+#ifndef __GNUC__
+# ifdef __attribute__
+#  undef __attribute__
+# endif
+# define __attribute__(a)
+#endif
+
+#ifndef CRYPTO_ALIGN
+# if defined(__INTEL_COMPILER) || defined(_MSC_VER)
+#  define CRYPTO_ALIGN(x) __declspec(align(x))
+# else
+#  define CRYPTO_ALIGN(x) __attribute__ ((aligned(x)))
+# endif
+#endif
+
+#if defined(_MSC_VER) && \
+    (defined(_M_X64) || defined(_M_AMD64) || defined(_M_IX86))
+
+# include <intrin.h>
+
+# define HAVE_INTRIN_H    1
+# define HAVE_MMINTRIN_H  1
+# define HAVE_EMMINTRIN_H 1
+# define HAVE_PMMINTRIN_H 1
+# define HAVE_TMMINTRIN_H 1
+# define HAVE_SMMINTRIN_H 1
+# define HAVE_AVXINTRIN_H 1
+# if _MSC_VER >= 1600
+#  define HAVE_WMMINTRIN_H 1
+# endif
+# if _MSC_VER >= 1700 && defined(_M_X64)
+#  define HAVE_AVX2INTRIN_H 1
+# endif
+#elif defined(HAVE_INTRIN_H)
+# include <intrin.h>
+#endif
+
 #endif

data/vendor/libsodium/src/libsodium/include/sodium/private/implementations.h

@@ -0,0 +1,11 @@
+#ifndef implementations_H
+#define implementations_H
+
+int _crypto_generichash_blake2b_pick_best_implementation(void);
+int _crypto_onetimeauth_poly1305_pick_best_implementation(void);
+int _crypto_pwhash_argon2_pick_best_implementation(void);
+int _crypto_scalarmult_curve25519_pick_best_implementation(void);
+int _crypto_stream_chacha20_pick_best_implementation(void);
+int _crypto_stream_salsa20_pick_best_implementation(void);
+
+#endif

data/vendor/libsodium/src/libsodium/include/sodium/private/sse2_64_32.h

@@ -0,0 +1,50 @@
+#ifndef sse2_64_32_H
+#define sse2_64_32_H 1
+
+#include "common.h"
+
+#ifdef HAVE_INTRIN_H
+# include <intrin.h>
+#endif
+
+#if defined(HAVE_EMMINTRIN_H) && \
+    !(defined(__amd64) || defined(__amd64__) || defined(__x86_64__) || \
+      defined(_M_X64) || defined(_M_AMD64))
+
+# include <emmintrin.h>
+# include <stdint.h>
+
+# ifndef _mm_set_epi64x
+#  define _mm_set_epi64x(Q0, Q1) sodium__mm_set_epi64x((Q0), (Q1))
+static inline __m128i
+sodium__mm_set_epi64x(int64_t q1, int64_t q0)
+{
+    union { int64_t as64; int32_t as32[2]; } x0, x1;
+    x0.as64 = q0; x1.as64 = q1;
+    return _mm_set_epi32(x1.as32[1], x1.as32[0], x0.as32[1], x0.as32[0]);
+}
+# endif
+
+# ifndef _mm_set1_epi64x
+#  define _mm_set1_epi64x(Q) sodium__mm_set1_epi64x(Q)
+static inline __m128i
+sodium__mm_set1_epi64x(int64_t q)
+{
+    return _mm_set_epi64x(q, q);
+}
+# endif
+
+# ifndef _mm_cvtsi64_si128
+#  define _mm_cvtsi64_si128(Q) sodium__mm_cvtsi64_si128(Q)
+static inline __m128i
+sodium__mm_cvtsi64_si128(int64_t q)
+{
+    union { int64_t as64; int32_t as32[2]; } x;
+    x.as64 = q;
+    return _mm_setr_epi32(x.as32[0], x.as32[1], 0, 0);
+}
+# endif
+
+#endif
+
+#endif

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

@@ -2,11 +2,11 @@
 #ifndef randombytes_H
 #define randombytes_H
 
-#include <sys/types.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
+#include <sys/types.h>
+
 #include "export.h"
 
 #ifdef __cplusplus
@@ -25,9 +25,17 @@ typedef struct randombytes_implementation {
     int         (*close)(void);               /* optional */
 } randombytes_implementation;
 
+#define randombytes_SEEDBYTES 32U
+SODIUM_EXPORT
+size_t randombytes_seedbytes(void);
+
 SODIUM_EXPORT
 void randombytes_buf(void * const buf, const size_t size);
 
+SODIUM_EXPORT
+void randombytes_buf_deterministic(void * const buf, const size_t size,
+                                   const unsigned char seed[randombytes_SEEDBYTES]);
+
 SODIUM_EXPORT
 uint32_t randombytes_random(void);
 

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

@@ -90,15 +90,14 @@ int sodium_munlock(void * const addr, const size_t len);
  *   a multiple of the required alignment. For this reason, these functions
  *   are designed to store data, such as secret keys and messages.
  *
- * sodium_malloc() can be used to allocate any libsodium data structure,
- * with the exception of crypto_generichash_state.
+ * sodium_malloc() can be used to allocate any libsodium data structure.
  *
  * The crypto_generichash_state structure is packed and its length is
  * either 357 or 361 bytes. For this reason, when using sodium_malloc() to
  * allocate a crypto_generichash_state structure, padding must be added in
- * order to ensure proper alignment:
- * state = sodium_malloc((crypto_generichash_statebytes() + (size_t) 63U)
- *                       & ~(size_t) 63U);
+ * order to ensure proper alignment. crypto_generichash_statebytes()
+ * returns the rounded up structure size, and should be prefered to sizeof():
+ * state = sodium_malloc(crypto_generichash_statebytes());
  */
 
 SODIUM_EXPORT

data/vendor/libsodium/src/libsodium/include/sodium/version.h.in

@@ -8,6 +8,7 @@
 
 #define SODIUM_LIBRARY_VERSION_MAJOR @SODIUM_LIBRARY_VERSION_MAJOR@
 #define SODIUM_LIBRARY_VERSION_MINOR @SODIUM_LIBRARY_VERSION_MINOR@
+@SODIUM_LIBRARY_MINIMAL_DEF@
 
 #ifdef __cplusplus
 extern "C" {
@@ -22,6 +23,9 @@ int         sodium_library_version_major(void);
 SODIUM_EXPORT
 int         sodium_library_version_minor(void);
 
+SODIUM_EXPORT
+int         sodium_library_minimal(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -1,34 +1,42 @@
 
-#include <stdlib.h>
-#include <sys/types.h>
-
 #include <assert.h>
 #include <limits.h>
 #include <stdint.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
 
 #ifdef __EMSCRIPTEN__
 # include <emscripten.h>
 #endif
 
+#include "crypto_stream_chacha20.h"
 #include "randombytes.h"
-#include "randombytes_sysrandom.h"
-
-#ifdef __native_client__
-# include "randombytes_nativeclient.h"
+#ifdef RANDOMBYTES_DEFAULT_IMPLEMENTATION
+# include "randombytes_default.h"
+#else
+# ifdef __native_client__
+#  include "randombytes_nativeclient.h"
+# else
+#  include "randombytes_sysrandom.h"
+# endif
 #endif
+#include "private/common.h"
 
 /* C++Builder defines a "random" macro */
 #undef random
 
 static const randombytes_implementation *implementation;
 
-#ifdef __EMSCRIPTEN__
-# define RANDOMBYTES_DEFAULT_IMPLEMENTATION NULL
-#else
-# ifdef __native_client__
-#  define RANDOMBYTES_DEFAULT_IMPLEMENTATION &randombytes_nativeclient_implementation;
+#ifndef RANDOMBYTES_DEFAULT_IMPLEMENTATION
+# ifdef __EMSCRIPTEN__
+#  define RANDOMBYTES_DEFAULT_IMPLEMENTATION NULL
 # else
-#  define RANDOMBYTES_DEFAULT_IMPLEMENTATION &randombytes_sysrandom_implementation;
+#  ifdef __native_client__
+#   define RANDOMBYTES_DEFAULT_IMPLEMENTATION &randombytes_nativeclient_implementation;
+#  else
+#   define RANDOMBYTES_DEFAULT_IMPLEMENTATION &randombytes_sysrandom_implementation;
+#  endif
 # endif
 #endif
 
@@ -112,10 +120,6 @@ randombytes_stir(void)
 #endif
 }
 
-/*
- * randombytes_uniform() derives from OpenBSD's arc4random_uniform()
- * Copyright (c) 2008, Damien Miller <djm@openbsd.org>
- */
 uint32_t
 randombytes_uniform(const uint32_t upper_bound)
 {
@@ -131,7 +135,7 @@ randombytes_uniform(const uint32_t upper_bound)
     if (upper_bound < 2) {
         return 0;
     }
-    min = (uint32_t) (-upper_bound % upper_bound);
+    min = (1U + ~upper_bound) % upper_bound;
     do {
         r = randombytes_random();
     } while (r < min);
@@ -148,7 +152,7 @@ randombytes_buf(void * const buf, const size_t size)
         implementation->buf(buf, size);
     }
 #else
-    unsigned char *p = buf;
+    unsigned char *p = (unsigned char *) buf;
     size_t         i;
 
     for (i = (size_t) 0U; i < size; i++) {
@@ -157,6 +161,30 @@ randombytes_buf(void * const buf, const size_t size)
 #endif
 }
 
+void
+randombytes_buf_deterministic(void * const buf, const size_t size,
+                              const unsigned char seed[randombytes_SEEDBYTES])
+{
+    static const unsigned char nonce[crypto_stream_chacha20_ietf_NONCEBYTES] = {
+        'L', 'i', 'b', 's', 'o', 'd', 'i', 'u', 'm', 'D', 'R', 'G'
+    };
+
+    COMPILER_ASSERT(randombytes_SEEDBYTES == crypto_stream_chacha20_ietf_KEYBYTES);
+#if SIZE_MAX > 0x4000000000ULL
+    if (size > 0x4000000000ULL) {
+        abort();
+    }
+#endif
+    crypto_stream_chacha20_ietf((unsigned char *) buf, (unsigned long long) size,
+                                nonce, seed);
+}
+
+size_t
+randombytes_seedbytes(void)
+{
+    return randombytes_SEEDBYTES;
+}
+
 int
 randombytes_close(void)
 {