rbnacl-libsodium 1.0.2 → 1.0.3

data/vendor/libsodium/src/libsodium/crypto_generichash/crypto_generichash.c

@@ -37,11 +37,18 @@ crypto_generichash_keybytes(void)
     return crypto_generichash_KEYBYTES;
 }
 
-const char *crypto_generichash_primitive(void)
+const char *
+crypto_generichash_primitive(void)
 {
     return crypto_generichash_PRIMITIVE;
 }
 
+size_t
+crypto_generichash_statebytes(void)
+{
+    return sizeof(crypto_generichash_state);
+}
+
 int
 crypto_generichash(unsigned char *out, size_t outlen, const unsigned char *in,
                    unsigned long long inlen, const unsigned char *key,

data/vendor/libsodium/src/libsodium/crypto_hash/sha256/hash_sha256_api.c

@@ -4,3 +4,8 @@ size_t
 crypto_hash_sha256_bytes(void) {
     return crypto_hash_sha256_BYTES;
 }
+
+size_t
+crypto_hash_sha256_statebytes(void) {
+    return sizeof(crypto_hash_sha256_state);
+}

data/vendor/libsodium/src/libsodium/crypto_hash/sha512/hash_sha512_api.c

@@ -4,3 +4,8 @@ size_t
 crypto_hash_sha512_bytes(void) {
     return crypto_hash_sha512_BYTES;
 }
+
+size_t
+crypto_hash_sha512_statebytes(void) {
+    return sizeof(crypto_hash_sha512_state);
+}

data/vendor/libsodium/src/libsodium/crypto_onetimeauth/crypto_onetimeauth.c

@@ -1,6 +1,12 @@
 
 #include "crypto_onetimeauth.h"
 
+size_t
+crypto_onetimeauth_statebytes(void)
+{
+    return sizeof(crypto_onetimeauth_state);
+}
+
 size_t
 crypto_onetimeauth_bytes(void)
 {
@@ -13,12 +19,6 @@ crypto_onetimeauth_keybytes(void)
     return crypto_onetimeauth_KEYBYTES;
 }
 
-const char *
-crypto_onetimeauth_primitive(void)
-{
-    return crypto_onetimeauth_PRIMITIVE;
-}
-
 int
 crypto_onetimeauth(unsigned char *out, const unsigned char *in,
                    unsigned long long inlen, const unsigned char *k)
@@ -57,3 +57,9 @@ crypto_onetimeauth_final(crypto_onetimeauth_state *state,
     return crypto_onetimeauth_poly1305_final
         ((crypto_onetimeauth_poly1305_state *) state, out);
 }
+
+const char *
+crypto_onetimeauth_primitive(void)
+{
+    return crypto_onetimeauth_PRIMITIVE;
+}

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/crypto_scrypt.h

@@ -32,6 +32,12 @@
 
 #include <stdint.h>
 
+#if SIZE_MAX > 0xffffffffULL
+# define ARCH_BITS 64
+#else
+# define ARCH_BITS 32
+#endif
+
 #define crypto_pwhash_scryptsalsa208sha256_STRPREFIXBYTES 14
 #define crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES 57
 #define crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES 32
@@ -46,6 +52,11 @@ typedef struct {
 	size_t size;
 } escrypt_region_t;
 
+typedef union {
+	uint64_t d[8];
+	uint32_t w[16];
+} escrypt_block_t;
+
 typedef escrypt_region_t escrypt_local_t;
 
 extern int escrypt_init_local(escrypt_local_t * __local);

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/nosse/pwhash_scryptsalsa208sha256_nosse.c

@@ -39,27 +39,61 @@
 #include "../crypto_scrypt.h"
 
 static inline void
-blkcpy(void * dest, const void * src, size_t len)
+blkcpy_64(escrypt_block_t *dest, const escrypt_block_t *src)
 {
-	size_t * D = (size_t *) dest;
-	const size_t * S = (const size_t *) src;
-	size_t L = len / sizeof(size_t);
-	size_t i;
+	int i;
+
+#if (ARCH_BITS==32)
+	for (i = 0; i < 16; ++i)
+		dest->w[i] = src->w[i];
+#else
+	for (i = 0; i < 8; ++i)
+		dest->d[i] = src->d[i];
+#endif
+}
 
-	for (i = 0; i < L; i++)
-		D[i] = S[i];
+static inline void
+blkxor_64(escrypt_block_t *dest, const escrypt_block_t *src)
+{
+	int i;
+
+#if (ARCH_BITS==32)
+	for (i = 0; i < 16; ++i)
+		dest->w[i] ^= src->w[i];
+#else
+	for (i = 0; i < 8; ++i)
+		dest->d[i] ^= src->d[i];
+#endif
 }
 
 static inline void
-blkxor(void * dest, const void * src, size_t len)
+blkcpy(escrypt_block_t *dest, const escrypt_block_t *src, size_t len)
 {
-	size_t * D = (size_t *) dest;
-	const size_t * S = (const size_t *) src;
-	size_t L = len / sizeof(size_t);
-	size_t i;
+	size_t i, L;
+#if (ARCH_BITS==32)
+	L = (len>>2);
+	for (i = 0; i < L; ++i)
+		dest->w[i] = src->w[i];
+#else
+	L = (len>>3);
+	for (i = 0; i < L; ++i)
+		dest->d[i] = src->d[i];
+#endif
+}
 
-	for (i = 0; i < L; i++)
-		D[i] ^= S[i];
+static inline void
+blkxor(escrypt_block_t *dest, const escrypt_block_t *src, size_t len)
+{
+	size_t i, L;
+#if (ARCH_BITS==32)
+	L = (len>>2);
+	for (i = 0; i < L; ++i)
+		dest->w[i] ^= src->w[i];
+#else
+	L = (len>>3);
+	for (i = 0; i < L; ++i)
+		dest->d[i] ^= src->d[i];
+#endif
 }
 
 /**
@@ -69,10 +103,11 @@ blkxor(void * dest, const void * src, size_t len)
 static void
 salsa20_8(uint32_t B[16])
 {
-	uint32_t x[16];
+	escrypt_block_t X;
+	uint32_t *x = X.w;
 	size_t i;
 
-	blkcpy(x, B, 64);
+	blkcpy_64(&X, (escrypt_block_t*)B);
 	for (i = 0; i < 8; i += 2) {
 #define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
 		/* Operate on columns. */
@@ -118,25 +153,25 @@ blockmix_salsa8(const uint32_t * Bin, uint32_t * Bout, uint32_t * X, size_t r)
 	size_t i;
 
 	/* 1: X <-- B_{2r - 1} */
-	blkcpy(X, &Bin[(2 * r - 1) * 16], 64);
+	blkcpy_64((escrypt_block_t*)X, (escrypt_block_t*)&Bin[(2 * r - 1) * 16]);
 
 	/* 2: for i = 0 to 2r - 1 do */
 	for (i = 0; i < 2 * r; i += 2) {
 		/* 3: X <-- H(X \xor B_i) */
-		blkxor(X, &Bin[i * 16], 64);
+		blkxor_64((escrypt_block_t*)X, (escrypt_block_t*)&Bin[i * 16]);
 		salsa20_8(X);
 
 		/* 4: Y_i <-- X */
 		/* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
-		blkcpy(&Bout[i * 8], X, 64);
+		blkcpy_64((escrypt_block_t*)&Bout[i * 8], (escrypt_block_t*)X);
 
 		/* 3: X <-- H(X \xor B_i) */
-		blkxor(X, &Bin[i * 16 + 16], 64);
+		blkxor_64((escrypt_block_t*)X, (escrypt_block_t*)&Bin[i * 16 + 16]);
 		salsa20_8(X);
 
 		/* 4: Y_i <-- X */
 		/* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
-		blkcpy(&Bout[i * 8 + r * 16], X, 64);
+		blkcpy_64((escrypt_block_t*)&Bout[i * 8 + r * 16], (escrypt_block_t*)X);
 	}
 }
 
@@ -177,13 +212,13 @@ smix(uint8_t * B, size_t r, uint64_t N, uint32_t * V, uint32_t * XY)
 	/* 2: for i = 0 to N - 1 do */
 	for (i = 0; i < N; i += 2) {
 		/* 3: V_i <-- X */
-		blkcpy(&V[i * (32 * r)], X, 128 * r);
+		blkcpy((escrypt_block_t*)&V[i * (32 * r)], (escrypt_block_t*)X, 128 * r);
 
 		/* 4: X <-- H(X) */
 		blockmix_salsa8(X, Y, Z, r);
 
 		/* 3: V_i <-- X */
-		blkcpy(&V[(i + 1) * (32 * r)], Y, 128 * r);
+		blkcpy((escrypt_block_t*)&V[(i + 1) * (32 * r)], (escrypt_block_t*)Y, 128 * r);
 
 		/* 4: X <-- H(X) */
 		blockmix_salsa8(Y, X, Z, r);
@@ -195,14 +230,14 @@ smix(uint8_t * B, size_t r, uint64_t N, uint32_t * V, uint32_t * XY)
 		j = integerify(X, r) & (N - 1);
 
 		/* 8: X <-- H(X \xor V_j) */
-		blkxor(X, &V[j * (32 * r)], 128 * r);
+		blkxor((escrypt_block_t*)X, (escrypt_block_t*)&V[j * (32 * r)], 128 * r);
 		blockmix_salsa8(X, Y, Z, r);
 
 		/* 7: j <-- Integerify(X) mod N */
 		j = integerify(Y, r) & (N - 1);
 
 		/* 8: X <-- H(X \xor V_j) */
-		blkxor(Y, &V[j * (32 * r)], 128 * r);
+		blkxor((escrypt_block_t*)Y, (escrypt_block_t*)&V[j * (32 * r)], 128 * r);
 		blockmix_salsa8(Y, X, Z, r);
 	}
 	/* 10: B' <-- X */

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/pwhash_scryptsalsa208sha256.c

@@ -95,12 +95,12 @@ crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(void)
 
 int
 crypto_pwhash_scryptsalsa208sha256(unsigned char * const out,
-                                    unsigned long long outlen,
-                                    const char * const passwd,
-                                    unsigned long long passwdlen,
-                                    const unsigned char * const salt,
-                                    unsigned long long opslimit,
-                                    size_t memlimit)
+                                   unsigned long long outlen,
+                                   const char * const passwd,
+                                   unsigned long long passwdlen,
+                                   const unsigned char * const salt,
+                                   unsigned long long opslimit,
+                                   size_t memlimit)
 {
     uint32_t N_log2;
     uint32_t p;
@@ -125,10 +125,10 @@ crypto_pwhash_scryptsalsa208sha256(unsigned char * const out,
 
 int
 crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
-                                        const char * const passwd,
-                                        unsigned long long passwdlen,
-                                        unsigned long long opslimit,
-                                        size_t memlimit)
+                                       const char * const passwd,
+                                       unsigned long long passwdlen,
+                                       unsigned long long opslimit,
+                                       size_t memlimit)
 {
     uint8_t         salt[crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES];
     char            setting[crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES + 1U];
@@ -179,8 +179,8 @@ crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha2
 
 int
 crypto_pwhash_scryptsalsa208sha256_str_verify(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
-                                               const char * const passwd,
-                                               unsigned long long passwdlen)
+                                              const char * const passwd,
+                                              unsigned long long passwdlen)
 {
     char            wanted[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
     escrypt_local_t escrypt_local;

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/donna_c64/smult_curve25519_donna_c64.c

@@ -189,9 +189,17 @@ fsquare_times(felem output, const felem in, limb count) {
   output[4] = r4;
 }
 
-#if !defined(CPU_ALIGNED_ACCESS_REQUIRED) && defined(NATIVE_LITTLE_ENDIAN)
-# define load_limb(p)     (*((const limb *) (p)))
-# define store_limb(p, v) (*((limb *) (p)) = (v))
+#ifdef NATIVE_LITTLE_ENDIAN
+static inline limb force_inline
+load_limb(const u8 *in) {
+    limb out;
+    memcpy(&out, in, sizeof (limb));
+    return out;
+}
+static inline void force_inline
+store_limb(u8 *out, limb in) {
+    memcpy(out, &in, sizeof (limb));
+}
 #else
 static inline limb force_inline
 load_limb(const u8 *in) {

data/vendor/libsodium/src/libsodium/crypto_sign/ed25519/ref10/open.c

@@ -43,7 +43,7 @@ crypto_sign_verify_detached(const unsigned char *sig, const unsigned char *m,
     ge_double_scalarmult_vartime(&R, h, &A, sig + 32);
     ge_tobytes(rcheck, &R);
 
-    return crypto_verify_32(rcheck, sig) | (-(rcheck - sig == 0)) |
+    return crypto_verify_32(rcheck, sig) | (-(rcheck == sig)) |
            sodium_memcmp(sig, rcheck, 32);
 }
 

data/vendor/libsodium/src/libsodium/crypto_sign/ed25519/ref10/sign.c

@@ -13,14 +13,11 @@ crypto_sign_detached(unsigned char *sig, unsigned long long *siglen_p,
                      const unsigned char *sk)
 {
     crypto_hash_sha512_state hs;
-    unsigned char pk[32];
     unsigned char az[64];
     unsigned char nonce[64];
     unsigned char hram[64];
     ge_p3 R;
 
-    memmove(pk, sk + 32, 32);
-
     crypto_hash_sha512(az, sk, 32);
     az[0] &= 248;
     az[31] &= 63;
@@ -31,7 +28,7 @@ crypto_sign_detached(unsigned char *sig, unsigned long long *siglen_p,
     crypto_hash_sha512_update(&hs, m, mlen);
     crypto_hash_sha512_final(&hs, nonce);
 
-    memmove(sig + 32, pk, 32);
+    memmove(sig + 32, sk + 32, 32);
 
     sc_reduce(nonce);
     ge_scalarmult_base(&R, nonce);

data/vendor/libsodium/src/libsodium/crypto_stream/xsalsa20/ref/api.h

@@ -2,6 +2,7 @@
 #include "crypto_stream_xsalsa20.h"
 
 #define crypto_stream crypto_stream_xsalsa20
+#define crypto_stream_xor_ic crypto_stream_xsalsa20_xor_ic
 #define crypto_stream_xor crypto_stream_xsalsa20_xor
 #define crypto_stream_KEYBYTES crypto_stream_xsalsa20_KEYBYTES
 #define crypto_stream_NONCEBYTES crypto_stream_xsalsa20_NONCEBYTES

data/vendor/libsodium/src/libsodium/crypto_stream/xsalsa20/ref/xor_xsalsa20.c

@@ -13,17 +13,27 @@ static const unsigned char sigma[16] = {
     'e', 'x', 'p', 'a', 'n', 'd', ' ', '3', '2', '-', 'b', 'y', 't', 'e', ' ', 'k'
 };
 
-int crypto_stream_xor(
+int crypto_stream_xor_ic(
         unsigned char *c,
   const unsigned char *m,unsigned long long mlen,
-  const unsigned char *n,
+  const unsigned char *n,uint64_t ic,
   const unsigned char *k
 )
 {
   unsigned char subkey[32];
   int ret;
   crypto_core_hsalsa20(subkey,n,k,sigma);
-  ret = crypto_stream_salsa20_xor(c,m,mlen,n + 16,subkey);
+  ret = crypto_stream_salsa20_xor_ic(c,m,mlen,n + 16,ic,subkey);
   sodium_memzero(subkey, sizeof subkey);
   return ret;
 }
+
+int crypto_stream_xor(
+        unsigned char *c,
+  const unsigned char *m,unsigned long long mlen,
+  const unsigned char *n,
+  const unsigned char *k
+)
+{
+  return crypto_stream_xor_ic(c, m, mlen, n, 0ULL, k);
+}

data/vendor/libsodium/src/libsodium/include/Makefile.in

@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# Makefile.in generated by automake 1.15 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -15,7 +15,17 @@
 @SET_MAKE@
 
 VPATH = @srcdir@
-am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
@@ -79,8 +89,6 @@ POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 subdir = src/libsodium/include
-DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
-	$(nobase_include_HEADERS)
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_compile_flag.m4 \
 	$(top_srcdir)/m4/ax_check_link_flag.m4 \
@@ -90,6 +98,8 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_compile_flag.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(nobase_include_HEADERS) \
+	$(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
@@ -160,6 +170,7 @@ am__define_uniq_tagged_files = \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
@@ -369,7 +380,6 @@ $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__confi
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/libsodium/include/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --foreign src/libsodium/include/Makefile
-.PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *config.status*) \
@@ -647,6 +657,8 @@ uninstall-am: uninstall-nobase_includeHEADERS \
 	uninstall-am uninstall-nobase_includeHEADERS \
 	uninstall-nobase_nodist_includeHEADERS
 
+.PRECIOUS: Makefile
+
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.