rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_core/hchacha20/core_hchacha20.c

@@ -2,10 +2,17 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include "core_hchacha20.h"
 #include "crypto_core_hchacha20.h"
 #include "private/common.h"
 
+#define QUARTERROUND(A, B, C, D)     \
+  do {                               \
+      A += B; D = ROTL32(D ^ A, 16); \
+      C += D; B = ROTL32(B ^ C, 12); \
+      A += B; D = ROTL32(D ^ A,  8); \
+      C += D; B = ROTL32(B ^ C,  7); \
+  } while(0)
+
 int
 crypto_core_hchacha20(unsigned char *out, const unsigned char *in,
                       const unsigned char *k, const unsigned char *c)
@@ -15,10 +22,10 @@ crypto_core_hchacha20(unsigned char *out, const unsigned char *in,
     uint32_t x8, x9, x10, x11, x12, x13, x14, x15;
 
     if (c == NULL) {
-        x0 = U32C(0x61707865);
-        x1 = U32C(0x3320646e);
-        x2 = U32C(0x79622d32);
-        x3 = U32C(0x6b206574);
+        x0 = 0x61707865;
+        x1 = 0x3320646e;
+        x2 = 0x79622d32;
+        x3 = 0x6b206574;
     } else {
         x0 = LOAD32_LE(c +  0);
         x1 = LOAD32_LE(c +  4);

data/vendor/libsodium/src/libsodium/crypto_core/hsalsa20/ref2/core_hsalsa20_ref2.c

@@ -0,0 +1,95 @@
+/*
+version 20080912
+D. J. Bernstein
+Public domain.
+*/
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "crypto_core_hsalsa20.h"
+#include "private/common.h"
+
+#define ROUNDS 20
+#define U32C(v) (v##U)
+
+int
+crypto_core_hsalsa20(unsigned char *out,
+                     const unsigned char *in,
+                     const unsigned char *k,
+                     const unsigned char *c)
+{
+    uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8,
+             x9, x10, x11, x12, x13, x14,  x15;
+    int      i;
+
+    if (c == NULL) {
+        x0 = U32C(0x61707865);
+        x5 = U32C(0x3320646e);
+        x10 = U32C(0x79622d32);
+        x15 = U32C(0x6b206574);
+    } else {
+        x0 = LOAD32_LE(c + 0);
+        x5 = LOAD32_LE(c + 4);
+        x10 = LOAD32_LE(c + 8);
+        x15 = LOAD32_LE(c + 12);
+    }
+    x1 = LOAD32_LE(k + 0);
+    x2 = LOAD32_LE(k + 4);
+    x3 = LOAD32_LE(k + 8);
+    x4 = LOAD32_LE(k + 12);
+    x11 = LOAD32_LE(k + 16);
+    x12 = LOAD32_LE(k + 20);
+    x13 = LOAD32_LE(k + 24);
+    x14 = LOAD32_LE(k + 28);
+    x6 = LOAD32_LE(in + 0);
+    x7 = LOAD32_LE(in + 4);
+    x8 = LOAD32_LE(in + 8);
+    x9 = LOAD32_LE(in + 12);
+
+    for (i = ROUNDS; i > 0; i -= 2) {
+        x4 ^= ROTL32(x0 + x12, 7);
+        x8 ^= ROTL32(x4 + x0, 9);
+        x12 ^= ROTL32(x8 + x4, 13);
+        x0 ^= ROTL32(x12 + x8, 18);
+        x9 ^= ROTL32(x5 + x1, 7);
+        x13 ^= ROTL32(x9 + x5, 9);
+        x1 ^= ROTL32(x13 + x9, 13);
+        x5 ^= ROTL32(x1 + x13, 18);
+        x14 ^= ROTL32(x10 + x6, 7);
+        x2 ^= ROTL32(x14 + x10, 9);
+        x6 ^= ROTL32(x2 + x14, 13);
+        x10 ^= ROTL32(x6 + x2, 18);
+        x3 ^= ROTL32(x15 + x11, 7);
+        x7 ^= ROTL32(x3 + x15, 9);
+        x11 ^= ROTL32(x7 + x3, 13);
+        x15 ^= ROTL32(x11 + x7, 18);
+        x1 ^= ROTL32(x0 + x3, 7);
+        x2 ^= ROTL32(x1 + x0, 9);
+        x3 ^= ROTL32(x2 + x1, 13);
+        x0 ^= ROTL32(x3 + x2, 18);
+        x6 ^= ROTL32(x5 + x4, 7);
+        x7 ^= ROTL32(x6 + x5, 9);
+        x4 ^= ROTL32(x7 + x6, 13);
+        x5 ^= ROTL32(x4 + x7, 18);
+        x11 ^= ROTL32(x10 + x9, 7);
+        x8 ^= ROTL32(x11 + x10, 9);
+        x9 ^= ROTL32(x8 + x11, 13);
+        x10 ^= ROTL32(x9 + x8, 18);
+        x12 ^= ROTL32(x15 + x14, 7);
+        x13 ^= ROTL32(x12 + x15, 9);
+        x14 ^= ROTL32(x13 + x12, 13);
+        x15 ^= ROTL32(x14 + x13, 18);
+    }
+
+    STORE32_LE(out + 0, x0);
+    STORE32_LE(out + 4, x5);
+    STORE32_LE(out + 8, x10);
+    STORE32_LE(out + 12, x15);
+    STORE32_LE(out + 16, x6);
+    STORE32_LE(out + 20, x7);
+    STORE32_LE(out + 24, x8);
+    STORE32_LE(out + 28, x9);
+
+    return 0;
+}

data/vendor/libsodium/src/libsodium/crypto_core/salsa/ref/core_salsa_ref.c

@@ -0,0 +1,195 @@
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "crypto_core_salsa20.h"
+#include "crypto_core_salsa2012.h"
+#include "crypto_core_salsa208.h"
+#include "private/common.h"
+
+static void
+crypto_core_salsa(unsigned char *out, const unsigned char *in,
+                  const unsigned char *k, const unsigned char *c,
+                  const int rounds)
+{
+    uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14,
+        x15;
+    uint32_t j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14,
+        j15;
+    int i;
+
+    j0  = x0  = 0x61707865;
+    j5  = x5  = 0x3320646e;
+    j10 = x10 = 0x79622d32;
+    j15 = x15 = 0x6b206574;
+    if (c != NULL) {
+        j0  = x0  = LOAD32_LE(c + 0);
+        j5  = x5  = LOAD32_LE(c + 4);
+        j10 = x10 = LOAD32_LE(c + 8);
+        j15 = x15 = LOAD32_LE(c + 12);
+    }
+    j1  = x1  = LOAD32_LE(k + 0);
+    j2  = x2  = LOAD32_LE(k + 4);
+    j3  = x3  = LOAD32_LE(k + 8);
+    j4  = x4  = LOAD32_LE(k + 12);
+    j11 = x11 = LOAD32_LE(k + 16);
+    j12 = x12 = LOAD32_LE(k + 20);
+    j13 = x13 = LOAD32_LE(k + 24);
+    j14 = x14 = LOAD32_LE(k + 28);
+
+    j6  = x6  = LOAD32_LE(in + 0);
+    j7  = x7  = LOAD32_LE(in + 4);
+    j8  = x8  = LOAD32_LE(in + 8);
+    j9  = x9  = LOAD32_LE(in + 12);
+
+    for (i = 0; i < rounds; i += 2) {
+        x4  ^= ROTL32(x0  + x12, 7);
+        x8  ^= ROTL32(x4  + x0, 9);
+        x12 ^= ROTL32(x8  + x4, 13);
+        x0  ^= ROTL32(x12 + x8, 18);
+        x9  ^= ROTL32(x5  + x1, 7);
+        x13 ^= ROTL32(x9  + x5, 9);
+        x1  ^= ROTL32(x13 + x9, 13);
+        x5  ^= ROTL32(x1  + x13, 18);
+        x14 ^= ROTL32(x10 + x6, 7);
+        x2  ^= ROTL32(x14 + x10, 9);
+        x6  ^= ROTL32(x2  + x14, 13);
+        x10 ^= ROTL32(x6  + x2, 18);
+        x3  ^= ROTL32(x15 + x11, 7);
+        x7  ^= ROTL32(x3  + x15, 9);
+        x11 ^= ROTL32(x7  + x3, 13);
+        x15 ^= ROTL32(x11 + x7, 18);
+        x1  ^= ROTL32(x0  + x3, 7);
+        x2  ^= ROTL32(x1  + x0, 9);
+        x3  ^= ROTL32(x2  + x1, 13);
+        x0  ^= ROTL32(x3  + x2, 18);
+        x6  ^= ROTL32(x5  + x4, 7);
+        x7  ^= ROTL32(x6  + x5, 9);
+        x4  ^= ROTL32(x7  + x6, 13);
+        x5  ^= ROTL32(x4  + x7, 18);
+        x11 ^= ROTL32(x10 + x9, 7);
+        x8  ^= ROTL32(x11 + x10, 9);
+        x9  ^= ROTL32(x8  + x11, 13);
+        x10 ^= ROTL32(x9  + x8, 18);
+        x12 ^= ROTL32(x15 + x14, 7);
+        x13 ^= ROTL32(x12 + x15, 9);
+        x14 ^= ROTL32(x13 + x12, 13);
+        x15 ^= ROTL32(x14 + x13, 18);
+    }
+    STORE32_LE(out + 0,  x0  + j0);
+    STORE32_LE(out + 4,  x1  + j1);
+    STORE32_LE(out + 8,  x2  + j2);
+    STORE32_LE(out + 12, x3  + j3);
+    STORE32_LE(out + 16, x4  + j4);
+    STORE32_LE(out + 20, x5  + j5);
+    STORE32_LE(out + 24, x6  + j6);
+    STORE32_LE(out + 28, x7  + j7);
+    STORE32_LE(out + 32, x8  + j8);
+    STORE32_LE(out + 36, x9  + j9);
+    STORE32_LE(out + 40, x10 + j10);
+    STORE32_LE(out + 44, x11 + j11);
+    STORE32_LE(out + 48, x12 + j12);
+    STORE32_LE(out + 52, x13 + j13);
+    STORE32_LE(out + 56, x14 + j14);
+    STORE32_LE(out + 60, x15 + j15);
+}
+
+int
+crypto_core_salsa20(unsigned char *out, const unsigned char *in,
+                    const unsigned char *k, const unsigned char *c)
+{
+    crypto_core_salsa(out, in, k, c, 20);
+    return 0;
+}
+
+size_t
+crypto_core_salsa20_outputbytes(void)
+{
+    return crypto_core_salsa20_OUTPUTBYTES;
+}
+
+size_t
+crypto_core_salsa20_inputbytes(void)
+{
+    return crypto_core_salsa20_INPUTBYTES;
+}
+
+size_t
+crypto_core_salsa20_keybytes(void)
+{
+    return crypto_core_salsa20_KEYBYTES;
+}
+
+size_t
+crypto_core_salsa20_constbytes(void)
+{
+    return crypto_core_salsa20_CONSTBYTES;
+}
+
+#ifndef MINIMAL
+
+int
+crypto_core_salsa2012(unsigned char *out, const unsigned char *in,
+                      const unsigned char *k, const unsigned char *c)
+{
+    crypto_core_salsa(out, in, k, c, 12);
+    return 0;
+}
+
+size_t
+crypto_core_salsa2012_outputbytes(void)
+{
+    return crypto_core_salsa2012_OUTPUTBYTES;
+}
+
+size_t
+crypto_core_salsa2012_inputbytes(void)
+{
+    return crypto_core_salsa2012_INPUTBYTES;
+}
+
+size_t
+crypto_core_salsa2012_keybytes(void)
+{
+    return crypto_core_salsa2012_KEYBYTES;
+}
+
+size_t
+crypto_core_salsa2012_constbytes(void)
+{
+    return crypto_core_salsa2012_CONSTBYTES;
+}
+
+int
+crypto_core_salsa208(unsigned char *out, const unsigned char *in,
+                     const unsigned char *k, const unsigned char *c)
+{
+    crypto_core_salsa(out, in, k, c, 8);
+    return 0;
+}
+
+size_t
+crypto_core_salsa208_outputbytes(void)
+{
+    return crypto_core_salsa208_OUTPUTBYTES;
+}
+
+size_t
+crypto_core_salsa208_inputbytes(void)
+{
+    return crypto_core_salsa208_INPUTBYTES;
+}
+
+size_t
+crypto_core_salsa208_keybytes(void)
+{
+    return crypto_core_salsa208_KEYBYTES;
+}
+
+size_t
+crypto_core_salsa208_constbytes(void)
+{
+    return crypto_core_salsa208_CONSTBYTES;
+}
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_generichash/{blake2/generichash_blake2_api.c → blake2b/generichash_blake2.c}

@@ -1,4 +1,5 @@
 #include "crypto_generichash_blake2b.h"
+#include "randombytes.h"
 
 size_t
 crypto_generichash_blake2b_bytes_min(void) {
@@ -46,3 +47,9 @@ crypto_generichash_blake2b_statebytes(void)
     return (sizeof(crypto_generichash_blake2b_state) + (size_t) 63U)
         & ~(size_t) 63U;
 }
+
+void
+crypto_generichash_blake2b_keygen(unsigned char k[crypto_generichash_blake2b_KEYBYTES])
+{
+    randombytes_buf(k, crypto_generichash_blake2b_KEYBYTES);
+}

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2b/ref/blake2.h

@@ -0,0 +1,109 @@
+/*
+   BLAKE2 reference source code package - reference C implementations
+
+   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
+
+   To the extent possible under law, the author(s) have dedicated all copyright
+   and related and neighboring rights to this software to the public domain
+   worldwide. This software is distributed without any warranty.
+
+   All code is triple-licensed under the
+   [CC0](http://creativecommons.org/publicdomain/zero/1.0), the
+   [OpenSSL Licence](https://www.openssl.org/source/license.html), or
+   the [Apache Public License 2.0](http://www.apache.org/licenses/LICENSE-2.0),
+   at your choosing.
+ */
+
+#ifndef blake2_H
+#define blake2_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "crypto_generichash_blake2b.h"
+#include "export.h"
+
+#define blake2b_init_param crypto_generichash_blake2b__init_param
+#define blake2b_init crypto_generichash_blake2b__init
+#define blake2b_init_salt_personal \
+    crypto_generichash_blake2b__init_salt_personal
+#define blake2b_init_key crypto_generichash_blake2b__init_key
+#define blake2b_init_key_salt_personal \
+    crypto_generichash_blake2b__init_key_salt_personal
+#define blake2b_update crypto_generichash_blake2b__update
+#define blake2b_final crypto_generichash_blake2b__final
+#define blake2b crypto_generichash_blake2b__blake2b
+#define blake2b_salt_personal crypto_generichash_blake2b__blake2b_salt_personal
+#define blake2b_pick_best_implementation \
+    crypto_generichash_blake2b__pick_best_implementation
+
+enum blake2b_constant {
+    BLAKE2B_BLOCKBYTES    = 128,
+    BLAKE2B_OUTBYTES      = 64,
+    BLAKE2B_KEYBYTES      = 64,
+    BLAKE2B_SALTBYTES     = 16,
+    BLAKE2B_PERSONALBYTES = 16
+};
+
+#if defined(__IBMC__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+#pragma pack(1)
+#else
+#pragma pack(push, 1)
+#endif
+
+typedef struct blake2b_param_ {
+    uint8_t digest_length;                   /*  1 */
+    uint8_t key_length;                      /*  2 */
+    uint8_t fanout;                          /*  3 */
+    uint8_t depth;                           /*  4 */
+    uint8_t leaf_length[4];                  /*  8 */
+    uint8_t node_offset[8];                  /* 16 */
+    uint8_t node_depth;                      /* 17 */
+    uint8_t inner_length;                    /* 18 */
+    uint8_t reserved[14];                    /* 32 */
+    uint8_t salt[BLAKE2B_SALTBYTES];         /* 48 */
+    uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */
+} blake2b_param;
+
+typedef crypto_generichash_blake2b_state blake2b_state;
+
+#if defined(__IBMC__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+#pragma pack()
+#else
+#pragma pack(pop)
+#endif
+
+/* Streaming API */
+int blake2b_init(blake2b_state *S, const uint8_t outlen);
+int blake2b_init_salt_personal(blake2b_state *S, const uint8_t outlen,
+                               const void *personal, const void *salt);
+int blake2b_init_key(blake2b_state *S, const uint8_t outlen, const void *key,
+                     const uint8_t keylen);
+int blake2b_init_key_salt_personal(blake2b_state *S, const uint8_t outlen,
+                                   const void *key, const uint8_t keylen,
+                                   const void *salt, const void *personal);
+int blake2b_init_param(blake2b_state *S, const blake2b_param *P);
+int blake2b_update(blake2b_state *S, const uint8_t *in, uint64_t inlen);
+int blake2b_final(blake2b_state *S, uint8_t *out, uint8_t outlen);
+
+/* Simple API */
+int blake2b(uint8_t *out, const void *in, const void *key, const uint8_t outlen,
+            const uint64_t inlen, uint8_t keylen);
+int blake2b_salt_personal(uint8_t *out, const void *in, const void *key,
+                          const uint8_t outlen, const uint64_t inlen,
+                          uint8_t keylen, const void *salt,
+                          const void *personal);
+
+typedef int (*blake2b_compress_fn)(blake2b_state *S,
+                                   const uint8_t  block[BLAKE2B_BLOCKBYTES]);
+int blake2b_pick_best_implementation(void);
+int blake2b_compress_ref(blake2b_state *S,
+                         const uint8_t  block[BLAKE2B_BLOCKBYTES]);
+int blake2b_compress_ssse3(blake2b_state *S,
+                           const uint8_t  block[BLAKE2B_BLOCKBYTES]);
+int blake2b_compress_sse41(blake2b_state *S,
+                           const uint8_t  block[BLAKE2B_BLOCKBYTES]);
+int blake2b_compress_avx2(blake2b_state *S,
+                          const uint8_t  block[BLAKE2B_BLOCKBYTES]);
+
+#endif