rbnacl-libsodium 1.0.6 → 1.0.7

data/vendor/libsodium/src/libsodium/crypto_onetimeauth/poly1305/sse2/poly1305_sse2.h

@@ -0,0 +1,31 @@
+#ifndef poly1305_sse2_H
+#define poly1305_sse2_H
+
+#include <stddef.h>
+
+#include "crypto_onetimeauth_poly1305.h"
+
+extern struct crypto_onetimeauth_poly1305_implementation
+    crypto_onetimeauth_poly1305_sse2_implementation;
+
+static int crypto_onetimeauth_poly1305_sse2(unsigned char *out,
+                                            const unsigned char *in,
+                                            unsigned long long inlen,
+                                            const unsigned char *k);
+
+static int crypto_onetimeauth_poly1305_sse2_verify(const unsigned char *h,
+                                                   const unsigned char *in,
+                                                   unsigned long long inlen,
+                                                   const unsigned char *k);
+
+static int crypto_onetimeauth_poly1305_sse2_init(crypto_onetimeauth_poly1305_state *state,
+                                                 const unsigned char *key);
+
+static int crypto_onetimeauth_poly1305_sse2_update(crypto_onetimeauth_poly1305_state *state,
+                                                   const unsigned char *in,
+                                                   unsigned long long inlen);
+
+static int crypto_onetimeauth_poly1305_sse2_final(crypto_onetimeauth_poly1305_state *state,
+                                                  unsigned char *out);
+
+#endif /* poly1305_sse2_H */

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

@@ -30,6 +30,7 @@
 #ifndef crypto_scrypt_H
 #define crypto_scrypt_H
 
+#include <limits.h>
 #include <stdint.h>
 #include <stddef.h>
 

data/vendor/libsodium/src/libsodium/crypto_scalarmult/crypto_scalarmult.c

@@ -1,18 +1,6 @@
 
 #include "crypto_scalarmult.h"
 
-size_t
-crypto_scalarmult_bytes(void)
-{
-    return crypto_scalarmult_BYTES;
-}
-
-size_t
-crypto_scalarmult_scalarbytes(void)
-{
-    return crypto_scalarmult_SCALARBYTES;
-}
-
 const char *
 crypto_scalarmult_primitive(void)
 {
@@ -32,3 +20,14 @@ crypto_scalarmult(unsigned char *q, const unsigned char *n,
     return crypto_scalarmult_curve25519(q, n, p);
 }
 
+size_t
+crypto_scalarmult_bytes(void)
+{
+    return crypto_scalarmult_BYTES;
+}
+
+size_t
+crypto_scalarmult_scalarbytes(void)
+{
+    return crypto_scalarmult_SCALARBYTES;
+}

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/donna_c64/{smult_curve25519_donna_c64.c → curve25519_donna_c64.c}

@@ -24,10 +24,13 @@
 
 #include <string.h>
 #include <stdint.h>
-#include "api.h"
 
 #ifdef HAVE_TI_MODE
 
+#include "utils.h"
+#include "curve25519_donna_c64.h"
+#include "../scalarmult_curve25519.h"
+
 typedef uint8_t u8;
 typedef uint64_t limb;
 typedef limb felem[5];
@@ -35,11 +38,8 @@ typedef limb felem[5];
 // platforms only as far as I know.
 typedef unsigned uint128_t __attribute__((mode(TI)));
 
-#undef force_inline
-#define force_inline __attribute__((always_inline))
-
 /* Sum two numbers: output += in */
-static inline void force_inline
+static inline void
 fsum(limb *output, const limb *in) {
   output[0] += in[0];
   output[1] += in[1];
@@ -54,7 +54,7 @@ fsum(limb *output, const limb *in) {
  * Assumes that out[i] < 2**52
  * On return, out[i] < 2**55
  */
-static inline void force_inline
+static inline void
 fdifference_backwards(felem out, const felem in) {
   /* 152 is 19 << 3 */
   static const limb two54m152 = (((limb)1) << 54) - 152;
@@ -68,7 +68,7 @@ fdifference_backwards(felem out, const felem in) {
 }
 
 /* Multiply a number by a scalar: output = in * scalar */
-static inline void force_inline
+static inline void
 fscalar_product(felem output, const felem in, const limb scalar) {
   uint128_t a;
 
@@ -98,7 +98,7 @@ fscalar_product(felem output, const felem in, const limb scalar) {
  * Assumes that in[i] < 2**55 and likewise for in2.
  * On return, output[i] < 2**52
  */
-static inline void force_inline
+static inline void
 fmul(felem output, const felem in2, const felem in) {
   uint128_t t[5];
   limb r0,r1,r2,r3,r4,s0,s1,s2,s3,s4,c;
@@ -147,7 +147,7 @@ fmul(felem output, const felem in2, const felem in) {
   output[4] = r4;
 }
 
-static inline void force_inline
+static inline void
 fsquare_times(felem output, const felem in, limb count) {
   uint128_t t[5];
   limb r0,r1,r2,r3,r4,c;
@@ -190,18 +190,18 @@ fsquare_times(felem output, const felem in, limb count) {
 }
 
 #ifdef NATIVE_LITTLE_ENDIAN
-static inline limb force_inline
+static inline limb
 load_limb(const u8 *in) {
     limb out;
     memcpy(&out, in, sizeof (limb));
     return out;
 }
-static inline void force_inline
+static inline void
 store_limb(u8 *out, limb in) {
     memcpy(out, &in, sizeof (limb));
 }
 #else
-static inline limb force_inline
+static inline limb
 load_limb(const u8 *in) {
   return
     ((limb)in[0]) |
@@ -214,7 +214,7 @@ load_limb(const u8 *in) {
     (((limb)in[7]) << 56);
 }
 
-static inline void force_inline
+static inline void
 store_limb(u8 *out, limb in) {
   out[0] = in & 0xff;
   out[1] = (in >> 8) & 0xff;
@@ -442,8 +442,12 @@ crecip(felem out, const felem z) {
   /* 2^255 - 21 */ fmul(out, t0, a);
 }
 
-int
-crypto_scalarmult(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
+static const unsigned char basepoint[32] = {9};
+
+static int
+crypto_scalarmult_curve25519_donna_c64(unsigned char *mypublic,
+                                       const unsigned char *secret,
+                                       const unsigned char *basepoint) {
   limb bp[5], x[5], z[5], zmone[5];
   uint8_t e[32];
   int i;
@@ -461,4 +465,17 @@ crypto_scalarmult(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
   return 0;
 }
 
+static int
+crypto_scalarmult_curve25519_donna_c64_base(unsigned char *q,
+                                            const unsigned char *n)
+{
+  return crypto_scalarmult_curve25519_donna_c64(q, n, basepoint);
+}
+
+struct crypto_scalarmult_curve25519_implementation
+crypto_scalarmult_curve25519_donna_c64_implementation = {
+    SODIUM_C99(.mult = ) crypto_scalarmult_curve25519_donna_c64,
+    SODIUM_C99(.mult_base = ) crypto_scalarmult_curve25519_donna_c64_base
+};
+
 #endif

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/donna_c64/curve25519_donna_c64.h

@@ -0,0 +1,9 @@
+#ifndef curve25519_donna_c64_H
+#define curve25519_donna_c64_H
+
+#include "crypto_scalarmult_curve25519.h"
+
+extern struct crypto_scalarmult_curve25519_implementation
+    crypto_scalarmult_curve25519_donna_c64_implementation;
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/ref10/curve25519_ref10.c

@@ -0,0 +1,73 @@
+
+#include <stddef.h>
+
+#ifndef HAVE_TI_MODE
+
+#include "utils.h"
+#include "curve25519_ref10.h"
+#include "../scalarmult_curve25519.h"
+#include "fe.h"
+
+static const unsigned char basepoint[32] = {9};
+
+static int
+crypto_scalarmult_curve25519_ref10(unsigned char *q,
+                                   const unsigned char *n,
+                                   const unsigned char *p)
+{
+  unsigned char e[32];
+  unsigned int i;
+  fe x1;
+  fe x2;
+  fe z2;
+  fe x3;
+  fe z3;
+  fe tmp0;
+  fe tmp1;
+  int pos;
+  unsigned int swap;
+  unsigned int b;
+
+  for (i = 0;i < 32;++i) e[i] = n[i];
+  e[0] &= 248;
+  e[31] &= 127;
+  e[31] |= 64;
+  fe_frombytes(x1,p);
+  fe_1(x2);
+  fe_0(z2);
+  fe_copy(x3,x1);
+  fe_1(z3);
+
+  swap = 0;
+  for (pos = 254;pos >= 0;--pos) {
+    b = e[pos / 8] >> (pos & 7);
+    b &= 1;
+    swap ^= b;
+    fe_cswap(x2,x3,swap);
+    fe_cswap(z2,z3,swap);
+    swap = b;
+#include "montgomery.h"
+  }
+  fe_cswap(x2,x3,swap);
+  fe_cswap(z2,z3,swap);
+
+  fe_invert(z2,z2);
+  fe_mul(x2,x2,z2);
+  fe_tobytes(q,x2);
+  return 0;
+}
+
+static int
+crypto_scalarmult_curve25519_ref10_base(unsigned char *q,
+                                        const unsigned char *n)
+{
+  return crypto_scalarmult_curve25519_ref10(q,n,basepoint);
+}
+
+struct crypto_scalarmult_curve25519_implementation
+crypto_scalarmult_curve25519_ref10_implementation = {
+        SODIUM_C99(.mult = ) crypto_scalarmult_curve25519_ref10,
+        SODIUM_C99(.mult_base = ) crypto_scalarmult_curve25519_ref10_base
+};
+
+#endif

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

@@ -0,0 +1,9 @@
+#ifndef curve25519_ref10_H
+#define curve25519_ref10_H
+
+#include "crypto_scalarmult_curve25519.h"
+
+extern struct crypto_scalarmult_curve25519_implementation
+        crypto_scalarmult_curve25519_ref10_implementation;
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/ref10/fe_frombytes_curve25519_ref10.c

@@ -1,4 +1,5 @@
 #include "fe.h"
+#include "crypto_int32.h"
 #include "crypto_int64.h"
 #include "crypto_uint64.h"
 

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/sandy2x/consts.S

@@ -0,0 +1,25 @@
+#ifdef IN_SANDY2X
+
+/*
+   REDMASK51 is from amd64-51/consts.s.
+*/
+
+#include "consts_namespace.h"
+.data
+.p2align 4
+v0_0: .quad 0, 0
+v1_0: .quad 1, 0
+v2_1: .quad 2, 1
+v9_0: .quad 9, 0
+v9_9: .quad 9, 9
+v19_19: .quad 19, 19
+v38_1: .quad 38, 1
+v38_38: .quad 38, 38
+v121666_121666: .quad 121666, 121666
+m25: .quad 33554431, 33554431
+m26: .quad 67108863, 67108863
+subc0: .quad 0x07FFFFDA, 0x03FFFFFE
+subc2: .quad 0x07FFFFFE, 0x03FFFFFE
+REDMASK51:   .quad 0x0007FFFFFFFFFFFF
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/sandy2x/consts_namespace.h

@@ -0,0 +1,20 @@
+#ifndef consts_namespace_H
+#define consts_namespace_H
+
+#define v0_0 crypto_scalarmult_curve25519_sandy2x_v0_0
+#define v1_0 crypto_scalarmult_curve25519_sandy2x_v1_0
+#define v2_1 crypto_scalarmult_curve25519_sandy2x_v2_1
+#define v9_0 crypto_scalarmult_curve25519_sandy2x_v9_0
+#define v9_9 crypto_scalarmult_curve25519_sandy2x_v9_9
+#define v19_19 crypto_scalarmult_curve25519_sandy2x_v19_19
+#define v38_1 crypto_scalarmult_curve25519_sandy2x_v38_1
+#define v38_38 crypto_scalarmult_curve25519_sandy2x_v38_38
+#define v121666_121666 crypto_scalarmult_curve25519_sandy2x_v121666_121666
+#define m25 crypto_scalarmult_curve25519_sandy2x_m25
+#define m26 crypto_scalarmult_curve25519_sandy2x_m26
+#define subc0 crypto_scalarmult_curve25519_sandy2x_subc0
+#define subc2 crypto_scalarmult_curve25519_sandy2x_subc2
+#define REDMASK51 crypto_scalarmult_curve25519_sandy2x_REDMASK51
+
+#endif //ifndef consts_namespace_H
+

data/vendor/libsodium/src/libsodium/crypto_scalarmult/curve25519/sandy2x/curve25519_sandy2x.c

@@ -0,0 +1,114 @@
+/*
+   This file is adapted from ref10/scalarmult.c:
+   The code for Mongomery ladder is replace by the ladder assembly function;
+   Inversion is done in the same way as amd64-51/.
+   (fe is first converted into fe51 after Mongomery ladder)
+*/
+
+#include <stddef.h>
+
+#ifdef HAVE_AVX_ASM
+
+#include "utils.h"
+#include "curve25519_sandy2x.h"
+#include "../scalarmult_curve25519.h"
+#include "fe.h"
+#include "fe51.h"
+#include "ladder.h"
+#include "ladder_base.h"
+
+#define x1 var[0]
+#define x2 var[1]
+#define z2 var[2]
+
+static int
+crypto_scalarmult_curve25519_sandy2x(unsigned char *q, const unsigned char *n,
+                                     const unsigned char *p)
+{
+  unsigned char e[32];
+  unsigned int i;
+
+  fe var[3];
+
+  fe51 x_51;
+  fe51 z_51;
+
+  for (i = 0;i < 32;++i) e[i] = n[i];
+  e[0] &= 248;
+  e[31] &= 127;
+  e[31] |= 64;
+
+  fe_frombytes(x1, p);
+
+  ladder(var, e);
+
+  z_51.v[0] = (z2[1] << 26) + z2[0];
+  z_51.v[1] = (z2[3] << 26) + z2[2];
+  z_51.v[2] = (z2[5] << 26) + z2[4];
+  z_51.v[3] = (z2[7] << 26) + z2[6];
+  z_51.v[4] = (z2[9] << 26) + z2[8];
+
+  x_51.v[0] = (x2[1] << 26) + x2[0];
+  x_51.v[1] = (x2[3] << 26) + x2[2];
+  x_51.v[2] = (x2[5] << 26) + x2[4];
+  x_51.v[3] = (x2[7] << 26) + x2[6];
+  x_51.v[4] = (x2[9] << 26) + x2[8];
+
+  fe51_invert(&z_51, &z_51);
+  fe51_mul(&x_51, &x_51, &z_51);
+  fe51_pack(q, &x_51);
+
+  return 0;
+}
+
+#undef x2
+#undef z2
+
+#define x2 var[0]
+#define z2 var[1]
+
+static int
+crypto_scalarmult_curve25519_sandy2x_base(unsigned char *q,
+                                          const unsigned char *n)
+{
+  unsigned char e[32];
+  unsigned int i;
+
+  fe var[3];
+
+  fe51 x_51;
+  fe51 z_51;
+
+  for (i = 0;i < 32;++i) e[i] = n[i];
+  e[0] &= 248;
+  e[31] &= 127;
+  e[31] |= 64;
+
+  ladder_base(var, e);
+
+  z_51.v[0] = (z2[1] << 26) + z2[0];
+  z_51.v[1] = (z2[3] << 26) + z2[2];
+  z_51.v[2] = (z2[5] << 26) + z2[4];
+  z_51.v[3] = (z2[7] << 26) + z2[6];
+  z_51.v[4] = (z2[9] << 26) + z2[8];
+
+  x_51.v[0] = (x2[1] << 26) + x2[0];
+  x_51.v[1] = (x2[3] << 26) + x2[2];
+  x_51.v[2] = (x2[5] << 26) + x2[4];
+  x_51.v[3] = (x2[7] << 26) + x2[6];
+  x_51.v[4] = (x2[9] << 26) + x2[8];
+
+  fe51_invert(&z_51, &z_51);
+  fe51_mul(&x_51, &x_51, &z_51);
+  fe51_pack(q, &x_51);
+
+  return 0;
+}
+
+struct crypto_scalarmult_curve25519_implementation
+crypto_scalarmult_curve25519_sandy2x_implementation = {
+    SODIUM_C99(.mult = ) crypto_scalarmult_curve25519_sandy2x,
+    SODIUM_C99(.mult_base = ) crypto_scalarmult_curve25519_sandy2x_base
+};
+
+#endif