rbnacl-libsodium 1.0.8 → 1.0.9

data/vendor/libsodium/src/libsodium/crypto_core/curve25519/ref10/curve25519_ref10.h

@@ -8,12 +8,12 @@
 typedef int32_t fe[10];
 
 /*
-fe means field element.
-Here the field is \Z/(2^255-19).
-An element t, entries t[0]...t[9], represents the integer
-t[0]+2^26 t[1]+2^51 t[2]+2^77 t[3]+2^102 t[4]+...+2^230 t[9].
-Bounds on each t[i] vary depending on context.
-*/
+ fe means field element.
+ Here the field is \Z/(2^255-19).
+ An element t, entries t[0]...t[9], represents the integer
+ t[0]+2^26 t[1]+2^51 t[2]+2^77 t[3]+2^102 t[4]+...+2^230 t[9].
+ Bounds on each t[i] vary depending on context.
+ */
 
 #define fe_frombytes crypto_core_curve25519_ref10_fe_frombytes
 #define fe_tobytes crypto_core_curve25519_ref10_fe_tobytes
@@ -51,55 +51,55 @@ extern void fe_invert(fe,const fe);
 extern void fe_pow22523(fe,const fe);
 
 /*
-ge means group element.
-
-Here the group is the set of pairs (x,y) of field elements (see fe.h)
-satisfying -x^2 + y^2 = 1 + d x^2y^2
-where d = -121665/121666.
-
-Representations:
-  ge_p2 (projective): (X:Y:Z) satisfying x=X/Z, y=Y/Z
-  ge_p3 (extended): (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
-  ge_p1p1 (completed): ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
-  ge_precomp (Duif): (y+x,y-x,2dxy)
-*/
+ ge means group element.
+ *
+ Here the group is the set of pairs (x,y) of field elements (see fe.h)
+ satisfying -x^2 + y^2 = 1 + d x^2y^2
+ where d = -121665/121666.
+ *
+ Representations:
+ ge_p2 (projective): (X:Y:Z) satisfying x=X/Z, y=Y/Z
+ ge_p3 (extended): (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+ ge_p1p1 (completed): ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+ ge_precomp (Duif): (y+x,y-x,2dxy)
+ */
 
 #define ge_p2 crypto_core_curve25519_ref10_ge_p2
 typedef struct {
-  fe X;
-  fe Y;
-  fe Z;
+    fe X;
+    fe Y;
+    fe Z;
 } ge_p2;
 
 #define ge_p3 crypto_core_curve25519_ref10_ge_p3
 typedef struct {
-  fe X;
-  fe Y;
-  fe Z;
-  fe T;
+    fe X;
+    fe Y;
+    fe Z;
+    fe T;
 } ge_p3;
 
 #define ge_p1p1 crypto_core_curve25519_ref10_ge_p1p1
 typedef struct {
-  fe X;
-  fe Y;
-  fe Z;
-  fe T;
+    fe X;
+    fe Y;
+    fe Z;
+    fe T;
 } ge_p1p1;
 
 #define ge_precomp crypto_core_curve25519_ref10_ge_precomp
 typedef struct {
-  fe yplusx;
-  fe yminusx;
-  fe xy2d;
+    fe yplusx;
+    fe yminusx;
+    fe xy2d;
 } ge_precomp;
 
 #define ge_cached crypto_core_curve25519_ref10_ge_cached
 typedef struct {
-  fe YplusX;
-  fe YminusX;
-  fe Z;
-  fe T2d;
+    fe YplusX;
+    fe YminusX;
+    fe Z;
+    fe T2d;
 } ge_cached;
 
 #define ge_frombytes_negate_vartime crypto_core_curve25519_ref10_ge_frombytes_negate_vartime
@@ -147,9 +147,9 @@ extern void ge_double_scalarmult_vartime(ge_p2 *,const unsigned char *,const ge_
 extern void ge_scalarmult_vartime(ge_p3 *,const unsigned char *,const ge_p3 *);
 
 /*
-The set of scalars is \Z/l
-where l = 2^252 + 27742317777372353535851937790883648493.
-*/
+ The set of scalars is \Z/l
+ where l = 2^252 + 27742317777372353535851937790883648493.
+ */
 
 #define sc_reduce crypto_core_curve25519_ref10_sc_reduce
 #define sc_muladd crypto_core_curve25519_ref10_sc_muladd

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

@@ -0,0 +1,86 @@
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "core_hchacha20.h"
+#include "crypto_core_hchacha20.h"
+#include "../../sodium/common.h"
+
+int
+crypto_core_hchacha20(unsigned char *out, const unsigned char *in,
+                      const unsigned char *k, const unsigned char *c)
+{
+    int      i;
+    uint32_t x0, x1, x2, x3, x4, x5, x6, x7;
+    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);
+    } else {
+        x0 = LOAD32_LE(c +  0);
+        x1 = LOAD32_LE(c +  4);
+        x2 = LOAD32_LE(c +  8);
+        x3 = LOAD32_LE(c + 12);
+    }
+    x4  = LOAD32_LE(k +  0);
+    x5  = LOAD32_LE(k +  4);
+    x6  = LOAD32_LE(k +  8);
+    x7  = LOAD32_LE(k + 12);
+    x8  = LOAD32_LE(k + 16);
+    x9  = LOAD32_LE(k + 20);
+    x10 = LOAD32_LE(k + 24);
+    x11 = LOAD32_LE(k + 28);
+    x12 = LOAD32_LE(in +  0);
+    x13 = LOAD32_LE(in +  4);
+    x14 = LOAD32_LE(in +  8);
+    x15 = LOAD32_LE(in + 12);
+
+    for (i = 0; i < 10; i++) {
+        QUARTERROUND(x0, x4,  x8, x12);
+        QUARTERROUND(x1, x5,  x9, x13);
+        QUARTERROUND(x2, x6, x10, x14);
+        QUARTERROUND(x3, x7, x11, x15);
+        QUARTERROUND(x0, x5, x10, x15);
+        QUARTERROUND(x1, x6, x11, x12);
+        QUARTERROUND(x2, x7,  x8, x13);
+        QUARTERROUND(x3, x4,  x9, x14);
+    }
+
+    STORE32_LE(out +  0, x0);
+    STORE32_LE(out +  4, x1);
+    STORE32_LE(out +  8, x2);
+    STORE32_LE(out + 12, x3);
+    STORE32_LE(out + 16, x12);
+    STORE32_LE(out + 20, x13);
+    STORE32_LE(out + 24, x14);
+    STORE32_LE(out + 28, x15);
+
+    return 0;
+}
+
+size_t
+crypto_core_hchacha20_outputbytes(void)
+{
+    return crypto_core_hchacha20_OUTPUTBYTES;
+}
+
+size_t
+crypto_core_hchacha20_inputbytes(void)
+{
+    return crypto_core_hchacha20_INPUTBYTES;
+}
+
+size_t
+crypto_core_hchacha20_keybytes(void)
+{
+    return crypto_core_hchacha20_KEYBYTES;
+}
+
+size_t
+crypto_core_hchacha20_constbytes(void)
+{
+    return crypto_core_hchacha20_CONSTBYTES;
+}

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

@@ -0,0 +1,28 @@
+#ifndef core_hchacha20_H
+#define core_hchacha20_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define U8C(v)  (v##U)
+#define U32C(v) (v##U)
+
+#define U8V(v)  ((uint8_t)(v) & U8C(0xFF))
+#define U32V(v) ((uint32_t)(v) & U32C(0xFFFFFFFF))
+
+#define ROTL32(v, n) (U32V((v) << (n)) | ((v) >> (32 - (n))))
+
+#define ROTATE(v, c) (ROTL32(v, c))
+#define XOR(v, w)    ((v) ^ (w))
+#define PLUS(v, w)   (U32V((v) + (w)))
+
+#define QUARTERROUND(a, b, c, d) \
+  do { \
+      a = PLUS(a, b); d = ROTATE(XOR(d, a), 16); \
+      c = PLUS(c, d); b = ROTATE(XOR(b, c), 12); \
+      a = PLUS(a, b); d = ROTATE(XOR(d, a),  8); \
+      c = PLUS(c, d); b = ROTATE(XOR(b, c),  7); \
+  } while(0)
+
+#endif

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

@@ -4,35 +4,20 @@ D. J. Bernstein
 Public domain.
 */
 
+#include <stdint.h>
+#include <stdlib.h>
+
 #include "crypto_core_hsalsa20.h"
+#include "../../sodium/common.h"
 
 #define ROUNDS 20
+#define U32C(v) (v##U)
 
-typedef unsigned int uint32;
-
-static uint32 rotate(uint32 u,int c)
+static uint32_t rotate(uint32_t u,int c)
 {
   return (u << c) | (u >> (32 - c));
 }
 
-static uint32 load_littleendian(const unsigned char *x)
-{
-  return
-      (uint32) (x[0]) \
-  | (((uint32) (x[1])) << 8) \
-  | (((uint32) (x[2])) << 16) \
-  | (((uint32) (x[3])) << 24)
-  ;
-}
-
-static void store_littleendian(unsigned char *x,uint32 u)
-{
-  x[0] = u; u >>= 8;
-  x[1] = u; u >>= 8;
-  x[2] = u; u >>= 8;
-  x[3] = u;
-}
-
 int crypto_core_hsalsa20(
         unsigned char *out,
   const unsigned char *in,
@@ -40,25 +25,32 @@ int crypto_core_hsalsa20(
   const unsigned char *c
 )
 {
-  uint32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
+  uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
   int i;
 
-  x0 = load_littleendian(c + 0);
-  x1 = load_littleendian(k + 0);
-  x2 = load_littleendian(k + 4);
-  x3 = load_littleendian(k + 8);
-  x4 = load_littleendian(k + 12);
-  x5 = load_littleendian(c + 4);
-  x6 = load_littleendian(in + 0);
-  x7 = load_littleendian(in + 4);
-  x8 = load_littleendian(in + 8);
-  x9 = load_littleendian(in + 12);
-  x10 = load_littleendian(c + 8);
-  x11 = load_littleendian(k + 16);
-  x12 = load_littleendian(k + 20);
-  x13 = load_littleendian(k + 24);
-  x14 = load_littleendian(k + 28);
-  x15 = load_littleendian(c + 12);
+  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 ^= rotate( x0+x12, 7);
@@ -95,14 +87,14 @@ int crypto_core_hsalsa20(
     x15 ^= rotate(x14+x13,18);
   }
 
-  store_littleendian(out + 0,x0);
-  store_littleendian(out + 4,x5);
-  store_littleendian(out + 8,x10);
-  store_littleendian(out + 12,x15);
-  store_littleendian(out + 16,x6);
-  store_littleendian(out + 20,x7);
-  store_littleendian(out + 24,x8);
-  store_littleendian(out + 28,x9);
+  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/salsa20/ref/core_salsa20.c

@@ -4,35 +4,20 @@ D. J. Bernstein
 Public domain.
 */
 
+#include <stdint.h>
+#include <stdlib.h>
+
 #include "crypto_core_salsa20.h"
+#include "../../sodium/common.h"
 
 #define ROUNDS 20
+#define U32C(v) (v##U)
 
-typedef unsigned int uint32;
-
-static uint32 rotate(uint32 u,int c)
+static uint32_t rotate(uint32_t u,int c)
 {
   return (u << c) | (u >> (32 - c));
 }
 
-static uint32 load_littleendian(const unsigned char *x)
-{
-  return
-      (uint32) (x[0]) \
-  | (((uint32) (x[1])) << 8) \
-  | (((uint32) (x[2])) << 16) \
-  | (((uint32) (x[3])) << 24)
-  ;
-}
-
-static void store_littleendian(unsigned char *x,uint32 u)
-{
-  x[0] = u; u >>= 8;
-  x[1] = u; u >>= 8;
-  x[2] = u; u >>= 8;
-  x[3] = u;
-}
-
 int crypto_core_salsa20(
         unsigned char *out,
   const unsigned char *in,
@@ -40,26 +25,33 @@ int crypto_core_salsa20(
   const unsigned char *c
 )
 {
-  uint32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
-  uint32 j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
+  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 = load_littleendian(c + 0);
-  j1 = x1 = load_littleendian(k + 0);
-  j2 = x2 = load_littleendian(k + 4);
-  j3 = x3 = load_littleendian(k + 8);
-  j4 = x4 = load_littleendian(k + 12);
-  j5 = x5 = load_littleendian(c + 4);
-  j6 = x6 = load_littleendian(in + 0);
-  j7 = x7 = load_littleendian(in + 4);
-  j8 = x8 = load_littleendian(in + 8);
-  j9 = x9 = load_littleendian(in + 12);
-  j10 = x10 = load_littleendian(c + 8);
-  j11 = x11 = load_littleendian(k + 16);
-  j12 = x12 = load_littleendian(k + 20);
-  j13 = x13 = load_littleendian(k + 24);
-  j14 = x14 = load_littleendian(k + 28);
-  j15 = x15 = load_littleendian(c + 12);
+  if (c == NULL) {
+    j0 = x0 = U32C(0x61707865);
+    j5 = x5 = U32C(0x3320646e);
+    j10 = x10 = U32C(0x79622d32);
+    j15 = x15 = U32C(0x6b206574);
+  } else {
+    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);
+  j6 = x6 = LOAD32_LE(in + 0);
+  j7 = x7 = LOAD32_LE(in + 4);
+  j8 = x8 = LOAD32_LE(in + 8);
+  j9 = x9 = LOAD32_LE(in + 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);
 
   for (i = ROUNDS;i > 0;i -= 2) {
      x4 ^= rotate( x0+x12, 7);
@@ -113,22 +105,22 @@ int crypto_core_salsa20(
   x14 += j14;
   x15 += j15;
 
-  store_littleendian(out + 0,x0);
-  store_littleendian(out + 4,x1);
-  store_littleendian(out + 8,x2);
-  store_littleendian(out + 12,x3);
-  store_littleendian(out + 16,x4);
-  store_littleendian(out + 20,x5);
-  store_littleendian(out + 24,x6);
-  store_littleendian(out + 28,x7);
-  store_littleendian(out + 32,x8);
-  store_littleendian(out + 36,x9);
-  store_littleendian(out + 40,x10);
-  store_littleendian(out + 44,x11);
-  store_littleendian(out + 48,x12);
-  store_littleendian(out + 52,x13);
-  store_littleendian(out + 56,x14);
-  store_littleendian(out + 60,x15);
+  STORE32_LE(out + 0,x0);
+  STORE32_LE(out + 4,x1);
+  STORE32_LE(out + 8,x2);
+  STORE32_LE(out + 12,x3);
+  STORE32_LE(out + 16,x4);
+  STORE32_LE(out + 20,x5);
+  STORE32_LE(out + 24,x6);
+  STORE32_LE(out + 28,x7);
+  STORE32_LE(out + 32,x8);
+  STORE32_LE(out + 36,x9);
+  STORE32_LE(out + 40,x10);
+  STORE32_LE(out + 44,x11);
+  STORE32_LE(out + 48,x12);
+  STORE32_LE(out + 52,x13);
+  STORE32_LE(out + 56,x14);
+  STORE32_LE(out + 60,x15);
 
   return 0;
 }