Added NaCl crypto library.

20 files changed, 1046 insertions, 0 deletions

diff --git a/nacl/crypto_hashblocks/measure.c b/nacl/crypto_hashblocks/measure.c
new file mode 100644
index 00000000..145fbbc4
--- /dev/null
+++ b/nacl/crypto_hashblocks/measure.c
@@ -0,0 +1,18 @@
+#include "crypto_hashblocks.h"
+
+const char *primitiveimplementation = crypto_hashblocks_IMPLEMENTATION;
+const char *implementationversion = crypto_hashblocks_VERSION;
+const char *sizenames[] = { "statebytes", 0 };
+const long long sizes[] = { crypto_hashblocks_STATEBYTES };
+
+void preallocate(void)
+{
+}
+
+void allocate(void)
+{
+}
+
+void measure(void)
+{
+}
diff --git a/nacl/crypto_hashblocks/sha256/checksum b/nacl/crypto_hashblocks/sha256/checksum
new file mode 100644
index 00000000..edde1d4f
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/checksum
@@ -0,0 +1 @@
+69a9dc2464f9593161e462d3dbb634b84f1d68d67d26df29aaa805f9dcd8f656
diff --git a/nacl/crypto_hashblocks/sha256/inplace/api.h b/nacl/crypto_hashblocks/sha256/inplace/api.h
new file mode 100644
index 00000000..005a4f47
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/inplace/api.h
@@ -0,0 +1,2 @@
+#define CRYPTO_STATEBYTES 32
+#define CRYPTO_BLOCKBYTES 64
diff --git a/nacl/crypto_hashblocks/sha256/inplace/blocks.c b/nacl/crypto_hashblocks/sha256/inplace/blocks.c
new file mode 100644
index 00000000..4a191501
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/inplace/blocks.c
@@ -0,0 +1,228 @@
+#include "crypto_hashblocks.h"
+
+typedef unsigned int uint32;
+
+static uint32 load_bigendian(const unsigned char *x)
+{
+  return
+      (uint32) (x[3]) \
+  | (((uint32) (x[2])) << 8) \
+  | (((uint32) (x[1])) << 16) \
+  | (((uint32) (x[0])) << 24)
+  ;
+}
+
+static void store_bigendian(unsigned char *x,uint32 u)
+{
+  x[3] = u; u >>= 8;
+  x[2] = u; u >>= 8;
+  x[1] = u; u >>= 8;
+  x[0] = u;
+}
+
+#define SHR(x,c) ((x) >> (c))
+#define ROTR(x,c) (((x) >> (c)) | ((x) << (32 - (c))))
+
+#define Ch(x,y,z) ((x & y) ^ (~x & z))
+#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
+#define Sigma0(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
+#define Sigma1(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
+#define sigma0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
+#define sigma1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
+
+#define M(w0,w14,w9,w1) w0 += sigma1(w14) + w9 + sigma0(w1);
+
+#define EXPAND \
+  M(w0 ,w14,w9 ,w1 ) \
+  M(w1 ,w15,w10,w2 ) \
+  M(w2 ,w0 ,w11,w3 ) \
+  M(w3 ,w1 ,w12,w4 ) \
+  M(w4 ,w2 ,w13,w5 ) \
+  M(w5 ,w3 ,w14,w6 ) \
+  M(w6 ,w4 ,w15,w7 ) \
+  M(w7 ,w5 ,w0 ,w8 ) \
+  M(w8 ,w6 ,w1 ,w9 ) \
+  M(w9 ,w7 ,w2 ,w10) \
+  M(w10,w8 ,w3 ,w11) \
+  M(w11,w9 ,w4 ,w12) \
+  M(w12,w10,w5 ,w13) \
+  M(w13,w11,w6 ,w14) \
+  M(w14,w12,w7 ,w15) \
+  M(w15,w13,w8 ,w0 )
+
+#define F(r0,r1,r2,r3,r4,r5,r6,r7,w,k) \
+  r7 += Sigma1(r4) + Ch(r4,r5,r6) + k + w; \
+  r3 += r7; \
+  r7 += Sigma0(r0) + Maj(r0,r1,r2);
+
+#define G(r0,r1,r2,r3,r4,r5,r6,r7,i) \
+  F(r0,r1,r2,r3,r4,r5,r6,r7,w0 ,round[i + 0]) \
+  F(r7,r0,r1,r2,r3,r4,r5,r6,w1 ,round[i + 1]) \
+  F(r6,r7,r0,r1,r2,r3,r4,r5,w2 ,round[i + 2]) \
+  F(r5,r6,r7,r0,r1,r2,r3,r4,w3 ,round[i + 3]) \
+  F(r4,r5,r6,r7,r0,r1,r2,r3,w4 ,round[i + 4]) \
+  F(r3,r4,r5,r6,r7,r0,r1,r2,w5 ,round[i + 5]) \
+  F(r2,r3,r4,r5,r6,r7,r0,r1,w6 ,round[i + 6]) \
+  F(r1,r2,r3,r4,r5,r6,r7,r0,w7 ,round[i + 7]) \
+  F(r0,r1,r2,r3,r4,r5,r6,r7,w8 ,round[i + 8]) \
+  F(r7,r0,r1,r2,r3,r4,r5,r6,w9 ,round[i + 9]) \
+  F(r6,r7,r0,r1,r2,r3,r4,r5,w10,round[i + 10]) \
+  F(r5,r6,r7,r0,r1,r2,r3,r4,w11,round[i + 11]) \
+  F(r4,r5,r6,r7,r0,r1,r2,r3,w12,round[i + 12]) \
+  F(r3,r4,r5,r6,r7,r0,r1,r2,w13,round[i + 13]) \
+  F(r2,r3,r4,r5,r6,r7,r0,r1,w14,round[i + 14]) \
+  F(r1,r2,r3,r4,r5,r6,r7,r0,w15,round[i + 15])
+
+static const uint32 round[64] = {
+  0x428a2f98
+, 0x71374491
+, 0xb5c0fbcf
+, 0xe9b5dba5
+, 0x3956c25b
+, 0x59f111f1
+, 0x923f82a4
+, 0xab1c5ed5
+, 0xd807aa98
+, 0x12835b01
+, 0x243185be
+, 0x550c7dc3
+, 0x72be5d74
+, 0x80deb1fe
+, 0x9bdc06a7
+, 0xc19bf174
+, 0xe49b69c1
+, 0xefbe4786
+, 0x0fc19dc6
+, 0x240ca1cc
+, 0x2de92c6f
+, 0x4a7484aa
+, 0x5cb0a9dc
+, 0x76f988da
+, 0x983e5152
+, 0xa831c66d
+, 0xb00327c8
+, 0xbf597fc7
+, 0xc6e00bf3
+, 0xd5a79147
+, 0x06ca6351
+, 0x14292967
+, 0x27b70a85
+, 0x2e1b2138
+, 0x4d2c6dfc
+, 0x53380d13
+, 0x650a7354
+, 0x766a0abb
+, 0x81c2c92e
+, 0x92722c85
+, 0xa2bfe8a1
+, 0xa81a664b
+, 0xc24b8b70
+, 0xc76c51a3
+, 0xd192e819
+, 0xd6990624
+, 0xf40e3585
+, 0x106aa070
+, 0x19a4c116
+, 0x1e376c08
+, 0x2748774c
+, 0x34b0bcb5
+, 0x391c0cb3
+, 0x4ed8aa4a
+, 0x5b9cca4f
+, 0x682e6ff3
+, 0x748f82ee
+, 0x78a5636f
+, 0x84c87814
+, 0x8cc70208
+, 0x90befffa
+, 0xa4506ceb
+, 0xbef9a3f7
+, 0xc67178f2
+} ;
+
+int crypto_hashblocks(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen)
+{
+  uint32 state[8];
+  uint32 r0;
+  uint32 r1;
+  uint32 r2;
+  uint32 r3;
+  uint32 r4;
+  uint32 r5;
+  uint32 r6;
+  uint32 r7;
+
+  r0 = load_bigendian(statebytes +  0); state[0] = r0;
+  r1 = load_bigendian(statebytes +  4); state[1] = r1;
+  r2 = load_bigendian(statebytes +  8); state[2] = r2;
+  r3 = load_bigendian(statebytes + 12); state[3] = r3;
+  r4 = load_bigendian(statebytes + 16); state[4] = r4;
+  r5 = load_bigendian(statebytes + 20); state[5] = r5;
+  r6 = load_bigendian(statebytes + 24); state[6] = r6;
+  r7 = load_bigendian(statebytes + 28); state[7] = r7;
+
+  while (inlen >= 64) {
+    uint32 w0  = load_bigendian(in +  0);
+    uint32 w1  = load_bigendian(in +  4);
+    uint32 w2  = load_bigendian(in +  8);
+    uint32 w3  = load_bigendian(in + 12);
+    uint32 w4  = load_bigendian(in + 16);
+    uint32 w5  = load_bigendian(in + 20);
+    uint32 w6  = load_bigendian(in + 24);
+    uint32 w7  = load_bigendian(in + 28);
+    uint32 w8  = load_bigendian(in + 32);
+    uint32 w9  = load_bigendian(in + 36);
+    uint32 w10 = load_bigendian(in + 40);
+    uint32 w11 = load_bigendian(in + 44);
+    uint32 w12 = load_bigendian(in + 48);
+    uint32 w13 = load_bigendian(in + 52);
+    uint32 w14 = load_bigendian(in + 56);
+    uint32 w15 = load_bigendian(in + 60);
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,0)
+
+    EXPAND
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,16)
+
+    EXPAND
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,32)
+
+    EXPAND
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,48)
+
+    r0 += state[0];
+    r1 += state[1];
+    r2 += state[2];
+    r3 += state[3];
+    r4 += state[4];
+    r5 += state[5];
+    r6 += state[6];
+    r7 += state[7];
+  
+    state[0] = r0;
+    state[1] = r1;
+    state[2] = r2;
+    state[3] = r3;
+    state[4] = r4;
+    state[5] = r5;
+    state[6] = r6;
+    state[7] = r7;
+
+    in += 64;
+    inlen -= 64;
+  }
+
+  store_bigendian(statebytes +  0,state[0]);
+  store_bigendian(statebytes +  4,state[1]);
+  store_bigendian(statebytes +  8,state[2]);
+  store_bigendian(statebytes + 12,state[3]);
+  store_bigendian(statebytes + 16,state[4]);
+  store_bigendian(statebytes + 20,state[5]);
+  store_bigendian(statebytes + 24,state[6]);
+  store_bigendian(statebytes + 28,state[7]);
+
+  return 0;
+}
diff --git a/nacl/crypto_hashblocks/sha256/inplace/implementors b/nacl/crypto_hashblocks/sha256/inplace/implementors
new file mode 100644
index 00000000..f6fb3c73
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/inplace/implementors
@@ -0,0 +1 @@
+Daniel J. Bernstein
diff --git a/nacl/crypto_hashblocks/sha256/ref/api.h b/nacl/crypto_hashblocks/sha256/ref/api.h
new file mode 100644
index 00000000..005a4f47
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/ref/api.h
@@ -0,0 +1,2 @@
+#define CRYPTO_STATEBYTES 32
+#define CRYPTO_BLOCKBYTES 64
diff --git a/nacl/crypto_hashblocks/sha256/ref/blocks.c b/nacl/crypto_hashblocks/sha256/ref/blocks.c
new file mode 100644
index 00000000..ad977945
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/ref/blocks.c
@@ -0,0 +1,212 @@
+#include "crypto_hashblocks.h"
+
+typedef unsigned int uint32;
+
+static uint32 load_bigendian(const unsigned char *x)
+{
+  return
+      (uint32) (x[3]) \
+  | (((uint32) (x[2])) << 8) \
+  | (((uint32) (x[1])) << 16) \
+  | (((uint32) (x[0])) << 24)
+  ;
+}
+
+static void store_bigendian(unsigned char *x,uint32 u)
+{
+  x[3] = u; u >>= 8;
+  x[2] = u; u >>= 8;
+  x[1] = u; u >>= 8;
+  x[0] = u;
+}
+
+#define SHR(x,c) ((x) >> (c))
+#define ROTR(x,c) (((x) >> (c)) | ((x) << (32 - (c))))
+
+#define Ch(x,y,z) ((x & y) ^ (~x & z))
+#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
+#define Sigma0(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
+#define Sigma1(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
+#define sigma0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
+#define sigma1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
+
+#define M(w0,w14,w9,w1) w0 = sigma1(w14) + w9 + sigma0(w1) + w0;
+
+#define EXPAND \
+  M(w0 ,w14,w9 ,w1 ) \
+  M(w1 ,w15,w10,w2 ) \
+  M(w2 ,w0 ,w11,w3 ) \
+  M(w3 ,w1 ,w12,w4 ) \
+  M(w4 ,w2 ,w13,w5 ) \
+  M(w5 ,w3 ,w14,w6 ) \
+  M(w6 ,w4 ,w15,w7 ) \
+  M(w7 ,w5 ,w0 ,w8 ) \
+  M(w8 ,w6 ,w1 ,w9 ) \
+  M(w9 ,w7 ,w2 ,w10) \
+  M(w10,w8 ,w3 ,w11) \
+  M(w11,w9 ,w4 ,w12) \
+  M(w12,w10,w5 ,w13) \
+  M(w13,w11,w6 ,w14) \
+  M(w14,w12,w7 ,w15) \
+  M(w15,w13,w8 ,w0 )
+
+#define F(w,k) \
+  T1 = h + Sigma1(e) + Ch(e,f,g) + k + w; \
+  T2 = Sigma0(a) + Maj(a,b,c); \
+  h = g; \
+  g = f; \
+  f = e; \
+  e = d + T1; \
+  d = c; \
+  c = b; \
+  b = a; \
+  a = T1 + T2;
+
+int crypto_hashblocks(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen)
+{
+  uint32 state[8];
+  uint32 a;
+  uint32 b;
+  uint32 c;
+  uint32 d;
+  uint32 e;
+  uint32 f;
+  uint32 g;
+  uint32 h;
+  uint32 T1;
+  uint32 T2;
+
+  a = load_bigendian(statebytes +  0); state[0] = a;
+  b = load_bigendian(statebytes +  4); state[1] = b;
+  c = load_bigendian(statebytes +  8); state[2] = c;
+  d = load_bigendian(statebytes + 12); state[3] = d;
+  e = load_bigendian(statebytes + 16); state[4] = e;
+  f = load_bigendian(statebytes + 20); state[5] = f;
+  g = load_bigendian(statebytes + 24); state[6] = g;
+  h = load_bigendian(statebytes + 28); state[7] = h;
+
+  while (inlen >= 64) {
+    uint32 w0  = load_bigendian(in +  0);
+    uint32 w1  = load_bigendian(in +  4);
+    uint32 w2  = load_bigendian(in +  8);
+    uint32 w3  = load_bigendian(in + 12);
+    uint32 w4  = load_bigendian(in + 16);
+    uint32 w5  = load_bigendian(in + 20);
+    uint32 w6  = load_bigendian(in + 24);
+    uint32 w7  = load_bigendian(in + 28);
+    uint32 w8  = load_bigendian(in + 32);
+    uint32 w9  = load_bigendian(in + 36);
+    uint32 w10 = load_bigendian(in + 40);
+    uint32 w11 = load_bigendian(in + 44);
+    uint32 w12 = load_bigendian(in + 48);
+    uint32 w13 = load_bigendian(in + 52);
+    uint32 w14 = load_bigendian(in + 56);
+    uint32 w15 = load_bigendian(in + 60);
+
+    F(w0 ,0x428a2f98)
+    F(w1 ,0x71374491)
+    F(w2 ,0xb5c0fbcf)
+    F(w3 ,0xe9b5dba5)
+    F(w4 ,0x3956c25b)
+    F(w5 ,0x59f111f1)
+    F(w6 ,0x923f82a4)
+    F(w7 ,0xab1c5ed5)
+    F(w8 ,0xd807aa98)
+    F(w9 ,0x12835b01)
+    F(w10,0x243185be)
+    F(w11,0x550c7dc3)
+    F(w12,0x72be5d74)
+    F(w13,0x80deb1fe)
+    F(w14,0x9bdc06a7)
+    F(w15,0xc19bf174)
+
+    EXPAND
+
+    F(w0 ,0xe49b69c1)
+    F(w1 ,0xefbe4786)
+    F(w2 ,0x0fc19dc6)
+    F(w3 ,0x240ca1cc)
+    F(w4 ,0x2de92c6f)
+    F(w5 ,0x4a7484aa)
+    F(w6 ,0x5cb0a9dc)
+    F(w7 ,0x76f988da)
+    F(w8 ,0x983e5152)
+    F(w9 ,0xa831c66d)
+    F(w10,0xb00327c8)
+    F(w11,0xbf597fc7)
+    F(w12,0xc6e00bf3)
+    F(w13,0xd5a79147)
+    F(w14,0x06ca6351)
+    F(w15,0x14292967)
+
+    EXPAND
+
+    F(w0 ,0x27b70a85)
+    F(w1 ,0x2e1b2138)
+    F(w2 ,0x4d2c6dfc)
+    F(w3 ,0x53380d13)
+    F(w4 ,0x650a7354)
+    F(w5 ,0x766a0abb)
+    F(w6 ,0x81c2c92e)
+    F(w7 ,0x92722c85)
+    F(w8 ,0xa2bfe8a1)
+    F(w9 ,0xa81a664b)
+    F(w10,0xc24b8b70)
+    F(w11,0xc76c51a3)
+    F(w12,0xd192e819)
+    F(w13,0xd6990624)
+    F(w14,0xf40e3585)
+    F(w15,0x106aa070)
+
+    EXPAND
+
+    F(w0 ,0x19a4c116)
+    F(w1 ,0x1e376c08)
+    F(w2 ,0x2748774c)
+    F(w3 ,0x34b0bcb5)
+    F(w4 ,0x391c0cb3)
+    F(w5 ,0x4ed8aa4a)
+    F(w6 ,0x5b9cca4f)
+    F(w7 ,0x682e6ff3)
+    F(w8 ,0x748f82ee)
+    F(w9 ,0x78a5636f)
+    F(w10,0x84c87814)
+    F(w11,0x8cc70208)
+    F(w12,0x90befffa)
+    F(w13,0xa4506ceb)
+    F(w14,0xbef9a3f7)
+    F(w15,0xc67178f2)
+
+    a += state[0];
+    b += state[1];
+    c += state[2];
+    d += state[3];
+    e += state[4];
+    f += state[5];
+    g += state[6];
+    h += state[7];
+  
+    state[0] = a;
+    state[1] = b;
+    state[2] = c;
+    state[3] = d;
+    state[4] = e;
+    state[5] = f;
+    state[6] = g;
+    state[7] = h;
+
+    in += 64;
+    inlen -= 64;
+  }
+
+  store_bigendian(statebytes +  0,state[0]);
+  store_bigendian(statebytes +  4,state[1]);
+  store_bigendian(statebytes +  8,state[2]);
+  store_bigendian(statebytes + 12,state[3]);
+  store_bigendian(statebytes + 16,state[4]);
+  store_bigendian(statebytes + 20,state[5]);
+  store_bigendian(statebytes + 24,state[6]);
+  store_bigendian(statebytes + 28,state[7]);
+
+  return 0;
+}
diff --git a/nacl/crypto_hashblocks/sha256/ref/implementors b/nacl/crypto_hashblocks/sha256/ref/implementors
new file mode 100644
index 00000000..f6fb3c73
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/ref/implementors
@@ -0,0 +1 @@
+Daniel J. Bernstein
diff --git a/nacl/crypto_hashblocks/sha256/used b/nacl/crypto_hashblocks/sha256/used
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha256/used
diff --git a/nacl/crypto_hashblocks/sha512/checksum b/nacl/crypto_hashblocks/sha512/checksum
new file mode 100644
index 00000000..ed5245ec
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/checksum
@@ -0,0 +1 @@
+f005c91634ae549f0dd4529ddbaf07038cb75a59b818cd1d4eb4e2b4019ab6733556131f320c4a145c735a22594581d454cccb15c18bf198ffcb2da29fe39456
diff --git a/nacl/crypto_hashblocks/sha512/inplace/api.h b/nacl/crypto_hashblocks/sha512/inplace/api.h
new file mode 100644
index 00000000..ac45d103
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/inplace/api.h
@@ -0,0 +1,2 @@
+#define CRYPTO_STATEBYTES 64
+#define CRYPTO_BLOCKBYTES 128
diff --git a/nacl/crypto_hashblocks/sha512/inplace/blocks.c b/nacl/crypto_hashblocks/sha512/inplace/blocks.c
new file mode 100644
index 00000000..93791b69
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/inplace/blocks.c
@@ -0,0 +1,256 @@
+#include "crypto_hashblocks.h"
+
+typedef unsigned long long uint64;
+
+static uint64 load_bigendian(const unsigned char *x)
+{
+  return
+      (uint64) (x[7]) \
+  | (((uint64) (x[6])) << 8) \
+  | (((uint64) (x[5])) << 16) \
+  | (((uint64) (x[4])) << 24) \
+  | (((uint64) (x[3])) << 32) \
+  | (((uint64) (x[2])) << 40) \
+  | (((uint64) (x[1])) << 48) \
+  | (((uint64) (x[0])) << 56)
+  ;
+}
+
+static void store_bigendian(unsigned char *x,uint64 u)
+{
+  x[7] = u; u >>= 8;
+  x[6] = u; u >>= 8;
+  x[5] = u; u >>= 8;
+  x[4] = u; u >>= 8;
+  x[3] = u; u >>= 8;
+  x[2] = u; u >>= 8;
+  x[1] = u; u >>= 8;
+  x[0] = u;
+}
+
+#define SHR(x,c) ((x) >> (c))
+#define ROTR(x,c) (((x) >> (c)) | ((x) << (64 - (c))))
+
+#define Ch(x,y,z) ((x & y) ^ (~x & z))
+#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
+#define Sigma0(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
+#define Sigma1(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
+#define sigma0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x,7))
+#define sigma1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x,6))
+
+#define M(w0,w14,w9,w1) w0 = sigma1(w14) + w9 + sigma0(w1) + w0;
+
+#define EXPAND \
+  M(w0 ,w14,w9 ,w1 ) \
+  M(w1 ,w15,w10,w2 ) \
+  M(w2 ,w0 ,w11,w3 ) \
+  M(w3 ,w1 ,w12,w4 ) \
+  M(w4 ,w2 ,w13,w5 ) \
+  M(w5 ,w3 ,w14,w6 ) \
+  M(w6 ,w4 ,w15,w7 ) \
+  M(w7 ,w5 ,w0 ,w8 ) \
+  M(w8 ,w6 ,w1 ,w9 ) \
+  M(w9 ,w7 ,w2 ,w10) \
+  M(w10,w8 ,w3 ,w11) \
+  M(w11,w9 ,w4 ,w12) \
+  M(w12,w10,w5 ,w13) \
+  M(w13,w11,w6 ,w14) \
+  M(w14,w12,w7 ,w15) \
+  M(w15,w13,w8 ,w0 )
+
+#define F(r0,r1,r2,r3,r4,r5,r6,r7,w,k) \
+  r7 += Sigma1(r4) + Ch(r4,r5,r6) + k + w; \
+  r3 += r7; \
+  r7 += Sigma0(r0) + Maj(r0,r1,r2);
+
+#define G(r0,r1,r2,r3,r4,r5,r6,r7,i) \
+  F(r0,r1,r2,r3,r4,r5,r6,r7,w0 ,round[i + 0]) \
+  F(r7,r0,r1,r2,r3,r4,r5,r6,w1 ,round[i + 1]) \
+  F(r6,r7,r0,r1,r2,r3,r4,r5,w2 ,round[i + 2]) \
+  F(r5,r6,r7,r0,r1,r2,r3,r4,w3 ,round[i + 3]) \
+  F(r4,r5,r6,r7,r0,r1,r2,r3,w4 ,round[i + 4]) \
+  F(r3,r4,r5,r6,r7,r0,r1,r2,w5 ,round[i + 5]) \
+  F(r2,r3,r4,r5,r6,r7,r0,r1,w6 ,round[i + 6]) \
+  F(r1,r2,r3,r4,r5,r6,r7,r0,w7 ,round[i + 7]) \
+  F(r0,r1,r2,r3,r4,r5,r6,r7,w8 ,round[i + 8]) \
+  F(r7,r0,r1,r2,r3,r4,r5,r6,w9 ,round[i + 9]) \
+  F(r6,r7,r0,r1,r2,r3,r4,r5,w10,round[i + 10]) \
+  F(r5,r6,r7,r0,r1,r2,r3,r4,w11,round[i + 11]) \
+  F(r4,r5,r6,r7,r0,r1,r2,r3,w12,round[i + 12]) \
+  F(r3,r4,r5,r6,r7,r0,r1,r2,w13,round[i + 13]) \
+  F(r2,r3,r4,r5,r6,r7,r0,r1,w14,round[i + 14]) \
+  F(r1,r2,r3,r4,r5,r6,r7,r0,w15,round[i + 15])
+
+static const uint64 round[80] = {
+  0x428a2f98d728ae22ULL
+, 0x7137449123ef65cdULL
+, 0xb5c0fbcfec4d3b2fULL
+, 0xe9b5dba58189dbbcULL
+, 0x3956c25bf348b538ULL
+, 0x59f111f1b605d019ULL
+, 0x923f82a4af194f9bULL
+, 0xab1c5ed5da6d8118ULL
+, 0xd807aa98a3030242ULL
+, 0x12835b0145706fbeULL
+, 0x243185be4ee4b28cULL
+, 0x550c7dc3d5ffb4e2ULL
+, 0x72be5d74f27b896fULL
+, 0x80deb1fe3b1696b1ULL
+, 0x9bdc06a725c71235ULL
+, 0xc19bf174cf692694ULL
+, 0xe49b69c19ef14ad2ULL
+, 0xefbe4786384f25e3ULL
+, 0x0fc19dc68b8cd5b5ULL
+, 0x240ca1cc77ac9c65ULL
+, 0x2de92c6f592b0275ULL
+, 0x4a7484aa6ea6e483ULL
+, 0x5cb0a9dcbd41fbd4ULL
+, 0x76f988da831153b5ULL
+, 0x983e5152ee66dfabULL
+, 0xa831c66d2db43210ULL
+, 0xb00327c898fb213fULL
+, 0xbf597fc7beef0ee4ULL
+, 0xc6e00bf33da88fc2ULL
+, 0xd5a79147930aa725ULL
+, 0x06ca6351e003826fULL
+, 0x142929670a0e6e70ULL
+, 0x27b70a8546d22ffcULL
+, 0x2e1b21385c26c926ULL
+, 0x4d2c6dfc5ac42aedULL
+, 0x53380d139d95b3dfULL
+, 0x650a73548baf63deULL
+, 0x766a0abb3c77b2a8ULL
+, 0x81c2c92e47edaee6ULL
+, 0x92722c851482353bULL
+, 0xa2bfe8a14cf10364ULL
+, 0xa81a664bbc423001ULL
+, 0xc24b8b70d0f89791ULL
+, 0xc76c51a30654be30ULL
+, 0xd192e819d6ef5218ULL
+, 0xd69906245565a910ULL
+, 0xf40e35855771202aULL
+, 0x106aa07032bbd1b8ULL
+, 0x19a4c116b8d2d0c8ULL
+, 0x1e376c085141ab53ULL
+, 0x2748774cdf8eeb99ULL
+, 0x34b0bcb5e19b48a8ULL
+, 0x391c0cb3c5c95a63ULL
+, 0x4ed8aa4ae3418acbULL
+, 0x5b9cca4f7763e373ULL
+, 0x682e6ff3d6b2b8a3ULL
+, 0x748f82ee5defb2fcULL
+, 0x78a5636f43172f60ULL
+, 0x84c87814a1f0ab72ULL
+, 0x8cc702081a6439ecULL
+, 0x90befffa23631e28ULL
+, 0xa4506cebde82bde9ULL
+, 0xbef9a3f7b2c67915ULL
+, 0xc67178f2e372532bULL
+, 0xca273eceea26619cULL
+, 0xd186b8c721c0c207ULL
+, 0xeada7dd6cde0eb1eULL
+, 0xf57d4f7fee6ed178ULL
+, 0x06f067aa72176fbaULL
+, 0x0a637dc5a2c898a6ULL
+, 0x113f9804bef90daeULL
+, 0x1b710b35131c471bULL
+, 0x28db77f523047d84ULL
+, 0x32caab7b40c72493ULL
+, 0x3c9ebe0a15c9bebcULL
+, 0x431d67c49c100d4cULL
+, 0x4cc5d4becb3e42b6ULL
+, 0x597f299cfc657e2aULL
+, 0x5fcb6fab3ad6faecULL
+, 0x6c44198c4a475817ULL
+};
+
+int crypto_hashblocks(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen)
+{
+  uint64 state[8];
+  uint64 r0;
+  uint64 r1;
+  uint64 r2;
+  uint64 r3;
+  uint64 r4;
+  uint64 r5;
+  uint64 r6;
+  uint64 r7;
+
+  r0 = load_bigendian(statebytes +  0); state[0] = r0;
+  r1 = load_bigendian(statebytes +  8); state[1] = r1;
+  r2 = load_bigendian(statebytes + 16); state[2] = r2;
+  r3 = load_bigendian(statebytes + 24); state[3] = r3;
+  r4 = load_bigendian(statebytes + 32); state[4] = r4;
+  r5 = load_bigendian(statebytes + 40); state[5] = r5;
+  r6 = load_bigendian(statebytes + 48); state[6] = r6;
+  r7 = load_bigendian(statebytes + 56); state[7] = r7;
+
+  while (inlen >= 128) {
+    uint64 w0  = load_bigendian(in +   0);
+    uint64 w1  = load_bigendian(in +   8);
+    uint64 w2  = load_bigendian(in +  16);
+    uint64 w3  = load_bigendian(in +  24);
+    uint64 w4  = load_bigendian(in +  32);
+    uint64 w5  = load_bigendian(in +  40);
+    uint64 w6  = load_bigendian(in +  48);
+    uint64 w7  = load_bigendian(in +  56);
+    uint64 w8  = load_bigendian(in +  64);
+    uint64 w9  = load_bigendian(in +  72);
+    uint64 w10 = load_bigendian(in +  80);
+    uint64 w11 = load_bigendian(in +  88);
+    uint64 w12 = load_bigendian(in +  96);
+    uint64 w13 = load_bigendian(in + 104);
+    uint64 w14 = load_bigendian(in + 112);
+    uint64 w15 = load_bigendian(in + 120);
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,0)
+
+    EXPAND
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,16)
+
+    EXPAND
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,32)
+
+    EXPAND
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,48)
+
+    EXPAND
+
+    G(r0,r1,r2,r3,r4,r5,r6,r7,64)
+
+    r0 += state[0];
+    r1 += state[1];
+    r2 += state[2];
+    r3 += state[3];
+    r4 += state[4];
+    r5 += state[5];
+    r6 += state[6];
+    r7 += state[7];
+  
+    state[0] = r0;
+    state[1] = r1;
+    state[2] = r2;
+    state[3] = r3;
+    state[4] = r4;
+    state[5] = r5;
+    state[6] = r6;
+    state[7] = r7;
+
+    in += 128;
+    inlen -= 128;
+  }
+
+  store_bigendian(statebytes +  0,state[0]);
+  store_bigendian(statebytes +  8,state[1]);
+  store_bigendian(statebytes + 16,state[2]);
+  store_bigendian(statebytes + 24,state[3]);
+  store_bigendian(statebytes + 32,state[4]);
+  store_bigendian(statebytes + 40,state[5]);
+  store_bigendian(statebytes + 48,state[6]);
+  store_bigendian(statebytes + 56,state[7]);
+
+  return 0;
+}
diff --git a/nacl/crypto_hashblocks/sha512/inplace/implementors b/nacl/crypto_hashblocks/sha512/inplace/implementors
new file mode 100644
index 00000000..f6fb3c73
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/inplace/implementors
@@ -0,0 +1 @@
+Daniel J. Bernstein
diff --git a/nacl/crypto_hashblocks/sha512/ref/api.h b/nacl/crypto_hashblocks/sha512/ref/api.h
new file mode 100644
index 00000000..ac45d103
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/ref/api.h
@@ -0,0 +1,2 @@
+#define CRYPTO_STATEBYTES 64
+#define CRYPTO_BLOCKBYTES 128
diff --git a/nacl/crypto_hashblocks/sha512/ref/blocks.c b/nacl/crypto_hashblocks/sha512/ref/blocks.c
new file mode 100644
index 00000000..f8fae491
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/ref/blocks.c
@@ -0,0 +1,239 @@
+#include "crypto_hashblocks.h"
+
+typedef unsigned long long uint64;
+
+static uint64 load_bigendian(const unsigned char *x)
+{
+  return
+      (uint64) (x[7]) \
+  | (((uint64) (x[6])) << 8) \
+  | (((uint64) (x[5])) << 16) \
+  | (((uint64) (x[4])) << 24) \
+  | (((uint64) (x[3])) << 32) \
+  | (((uint64) (x[2])) << 40) \
+  | (((uint64) (x[1])) << 48) \
+  | (((uint64) (x[0])) << 56)
+  ;
+}
+
+static void store_bigendian(unsigned char *x,uint64 u)
+{
+  x[7] = u; u >>= 8;
+  x[6] = u; u >>= 8;
+  x[5] = u; u >>= 8;
+  x[4] = u; u >>= 8;
+  x[3] = u; u >>= 8;
+  x[2] = u; u >>= 8;
+  x[1] = u; u >>= 8;
+  x[0] = u;
+}
+
+#define SHR(x,c) ((x) >> (c))
+#define ROTR(x,c) (((x) >> (c)) | ((x) << (64 - (c))))
+
+#define Ch(x,y,z) ((x & y) ^ (~x & z))
+#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
+#define Sigma0(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
+#define Sigma1(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
+#define sigma0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x,7))
+#define sigma1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x,6))
+
+#define M(w0,w14,w9,w1) w0 = sigma1(w14) + w9 + sigma0(w1) + w0;
+
+#define EXPAND \
+  M(w0 ,w14,w9 ,w1 ) \
+  M(w1 ,w15,w10,w2 ) \
+  M(w2 ,w0 ,w11,w3 ) \
+  M(w3 ,w1 ,w12,w4 ) \
+  M(w4 ,w2 ,w13,w5 ) \
+  M(w5 ,w3 ,w14,w6 ) \
+  M(w6 ,w4 ,w15,w7 ) \
+  M(w7 ,w5 ,w0 ,w8 ) \
+  M(w8 ,w6 ,w1 ,w9 ) \
+  M(w9 ,w7 ,w2 ,w10) \
+  M(w10,w8 ,w3 ,w11) \
+  M(w11,w9 ,w4 ,w12) \
+  M(w12,w10,w5 ,w13) \
+  M(w13,w11,w6 ,w14) \
+  M(w14,w12,w7 ,w15) \
+  M(w15,w13,w8 ,w0 )
+
+#define F(w,k) \
+  T1 = h + Sigma1(e) + Ch(e,f,g) + k + w; \
+  T2 = Sigma0(a) + Maj(a,b,c); \
+  h = g; \
+  g = f; \
+  f = e; \
+  e = d + T1; \
+  d = c; \
+  c = b; \
+  b = a; \
+  a = T1 + T2;
+
+int crypto_hashblocks(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen)
+{
+  uint64 state[8];
+  uint64 a;
+  uint64 b;
+  uint64 c;
+  uint64 d;
+  uint64 e;
+  uint64 f;
+  uint64 g;
+  uint64 h;
+  uint64 T1;
+  uint64 T2;
+
+  a = load_bigendian(statebytes +  0); state[0] = a;
+  b = load_bigendian(statebytes +  8); state[1] = b;
+  c = load_bigendian(statebytes + 16); state[2] = c;
+  d = load_bigendian(statebytes + 24); state[3] = d;
+  e = load_bigendian(statebytes + 32); state[4] = e;
+  f = load_bigendian(statebytes + 40); state[5] = f;
+  g = load_bigendian(statebytes + 48); state[6] = g;
+  h = load_bigendian(statebytes + 56); state[7] = h;
+
+  while (inlen >= 128) {
+    uint64 w0  = load_bigendian(in +   0);
+    uint64 w1  = load_bigendian(in +   8);
+    uint64 w2  = load_bigendian(in +  16);
+    uint64 w3  = load_bigendian(in +  24);
+    uint64 w4  = load_bigendian(in +  32);
+    uint64 w5  = load_bigendian(in +  40);
+    uint64 w6  = load_bigendian(in +  48);
+    uint64 w7  = load_bigendian(in +  56);
+    uint64 w8  = load_bigendian(in +  64);
+    uint64 w9  = load_bigendian(in +  72);
+    uint64 w10 = load_bigendian(in +  80);
+    uint64 w11 = load_bigendian(in +  88);
+    uint64 w12 = load_bigendian(in +  96);
+    uint64 w13 = load_bigendian(in + 104);
+    uint64 w14 = load_bigendian(in + 112);
+    uint64 w15 = load_bigendian(in + 120);
+
+    F(w0 ,0x428a2f98d728ae22ULL)
+    F(w1 ,0x7137449123ef65cdULL)
+    F(w2 ,0xb5c0fbcfec4d3b2fULL)
+    F(w3 ,0xe9b5dba58189dbbcULL)
+    F(w4 ,0x3956c25bf348b538ULL)
+    F(w5 ,0x59f111f1b605d019ULL)
+    F(w6 ,0x923f82a4af194f9bULL)
+    F(w7 ,0xab1c5ed5da6d8118ULL)
+    F(w8 ,0xd807aa98a3030242ULL)
+    F(w9 ,0x12835b0145706fbeULL)
+    F(w10,0x243185be4ee4b28cULL)
+    F(w11,0x550c7dc3d5ffb4e2ULL)
+    F(w12,0x72be5d74f27b896fULL)
+    F(w13,0x80deb1fe3b1696b1ULL)
+    F(w14,0x9bdc06a725c71235ULL)
+    F(w15,0xc19bf174cf692694ULL)
+
+    EXPAND
+
+    F(w0 ,0xe49b69c19ef14ad2ULL)
+    F(w1 ,0xefbe4786384f25e3ULL)
+    F(w2 ,0x0fc19dc68b8cd5b5ULL)
+    F(w3 ,0x240ca1cc77ac9c65ULL)
+    F(w4 ,0x2de92c6f592b0275ULL)
+    F(w5 ,0x4a7484aa6ea6e483ULL)
+    F(w6 ,0x5cb0a9dcbd41fbd4ULL)
+    F(w7 ,0x76f988da831153b5ULL)
+    F(w8 ,0x983e5152ee66dfabULL)
+    F(w9 ,0xa831c66d2db43210ULL)
+    F(w10,0xb00327c898fb213fULL)
+    F(w11,0xbf597fc7beef0ee4ULL)
+    F(w12,0xc6e00bf33da88fc2ULL)
+    F(w13,0xd5a79147930aa725ULL)
+    F(w14,0x06ca6351e003826fULL)
+    F(w15,0x142929670a0e6e70ULL)
+
+    EXPAND
+
+    F(w0 ,0x27b70a8546d22ffcULL)
+    F(w1 ,0x2e1b21385c26c926ULL)
+    F(w2 ,0x4d2c6dfc5ac42aedULL)
+    F(w3 ,0x53380d139d95b3dfULL)
+    F(w4 ,0x650a73548baf63deULL)
+    F(w5 ,0x766a0abb3c77b2a8ULL)
+    F(w6 ,0x81c2c92e47edaee6ULL)
+    F(w7 ,0x92722c851482353bULL)
+    F(w8 ,0xa2bfe8a14cf10364ULL)
+    F(w9 ,0xa81a664bbc423001ULL)
+    F(w10,0xc24b8b70d0f89791ULL)
+    F(w11,0xc76c51a30654be30ULL)
+    F(w12,0xd192e819d6ef5218ULL)
+    F(w13,0xd69906245565a910ULL)
+    F(w14,0xf40e35855771202aULL)
+    F(w15,0x106aa07032bbd1b8ULL)
+
+    EXPAND
+
+    F(w0 ,0x19a4c116b8d2d0c8ULL)
+    F(w1 ,0x1e376c085141ab53ULL)
+    F(w2 ,0x2748774cdf8eeb99ULL)
+    F(w3 ,0x34b0bcb5e19b48a8ULL)
+    F(w4 ,0x391c0cb3c5c95a63ULL)
+    F(w5 ,0x4ed8aa4ae3418acbULL)
+    F(w6 ,0x5b9cca4f7763e373ULL)
+    F(w7 ,0x682e6ff3d6b2b8a3ULL)
+    F(w8 ,0x748f82ee5defb2fcULL)
+    F(w9 ,0x78a5636f43172f60ULL)
+    F(w10,0x84c87814a1f0ab72ULL)
+    F(w11,0x8cc702081a6439ecULL)
+    F(w12,0x90befffa23631e28ULL)
+    F(w13,0xa4506cebde82bde9ULL)
+    F(w14,0xbef9a3f7b2c67915ULL)
+    F(w15,0xc67178f2e372532bULL)
+
+    EXPAND
+
+    F(w0 ,0xca273eceea26619cULL)
+    F(w1 ,0xd186b8c721c0c207ULL)
+    F(w2 ,0xeada7dd6cde0eb1eULL)
+    F(w3 ,0xf57d4f7fee6ed178ULL)
+    F(w4 ,0x06f067aa72176fbaULL)
+    F(w5 ,0x0a637dc5a2c898a6ULL)
+    F(w6 ,0x113f9804bef90daeULL)
+    F(w7 ,0x1b710b35131c471bULL)
+    F(w8 ,0x28db77f523047d84ULL)
+    F(w9 ,0x32caab7b40c72493ULL)
+    F(w10,0x3c9ebe0a15c9bebcULL)
+    F(w11,0x431d67c49c100d4cULL)
+    F(w12,0x4cc5d4becb3e42b6ULL)
+    F(w13,0x597f299cfc657e2aULL)
+    F(w14,0x5fcb6fab3ad6faecULL)
+    F(w15,0x6c44198c4a475817ULL)
+
+    a += state[0];
+    b += state[1];
+    c += state[2];
+    d += state[3];
+    e += state[4];
+    f += state[5];
+    g += state[6];
+    h += state[7];
+  
+    state[0] = a;
+    state[1] = b;
+    state[2] = c;
+    state[3] = d;
+    state[4] = e;
+    state[5] = f;
+    state[6] = g;
+    state[7] = h;
+
+    in += 128;
+    inlen -= 128;
+  }
+
+  store_bigendian(statebytes +  0,state[0]);
+  store_bigendian(statebytes +  8,state[1]);
+  store_bigendian(statebytes + 16,state[2]);
+  store_bigendian(statebytes + 24,state[3]);
+  store_bigendian(statebytes + 32,state[4]);
+  store_bigendian(statebytes + 40,state[5]);
+  store_bigendian(statebytes + 48,state[6]);
+  store_bigendian(statebytes + 56,state[7]);
+
+  return 0;
+}
diff --git a/nacl/crypto_hashblocks/sha512/ref/implementors b/nacl/crypto_hashblocks/sha512/ref/implementors
new file mode 100644
index 00000000..f6fb3c73
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/ref/implementors
@@ -0,0 +1 @@
+Daniel J. Bernstein
diff --git a/nacl/crypto_hashblocks/sha512/selected b/nacl/crypto_hashblocks/sha512/selected
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/selected
diff --git a/nacl/crypto_hashblocks/sha512/used b/nacl/crypto_hashblocks/sha512/used
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/nacl/crypto_hashblocks/sha512/used
diff --git a/nacl/crypto_hashblocks/try.c b/nacl/crypto_hashblocks/try.c
new file mode 100644
index 00000000..720d2fb3
--- /dev/null
+++ b/nacl/crypto_hashblocks/try.c
@@ -0,0 +1,79 @@
+/*
+ * crypto_hashblocks/try.c version 20090118
+ * D. J. Bernstein
+ * Public domain.
+ */
+
+#include <stdlib.h>
+#include "crypto_hashblocks.h"
+
+extern unsigned char *alignedcalloc(unsigned long long);
+
+const char *primitiveimplementation = crypto_hashblocks_IMPLEMENTATION;
+
+#define MAXTEST_BYTES (10000 + crypto_hashblocks_STATEBYTES)
+#define CHECKSUM_BYTES 4096
+#define TUNE_BYTES 1536
+
+static unsigned char *h;
+static unsigned char *h2;
+static unsigned char *m;
+static unsigned char *m2;
+
+void preallocate(void)
+{
+}
+
+void allocate(void)
+{
+  h = alignedcalloc(crypto_hashblocks_STATEBYTES);
+  h2 = alignedcalloc(crypto_hashblocks_STATEBYTES);
+  m = alignedcalloc(MAXTEST_BYTES);
+  m2 = alignedcalloc(MAXTEST_BYTES);
+}
+
+void predoit(void)
+{
+}
+
+void doit(void)
+{
+  crypto_hashblocks(h,m,TUNE_BYTES);
+}
+
+char checksum[crypto_hashblocks_STATEBYTES * 2 + 1];
+
+const char *checksum_compute(void)
+{
+  long long i;
+  long long j;
+
+  for (i = 0;i < CHECKSUM_BYTES;++i) {
+    long long hlen = crypto_hashblocks_STATEBYTES;
+    long long mlen = i;
+    for (j = -16;j < 0;++j) h[j] = random();
+    for (j = hlen;j < hlen + 16;++j) h[j] = random();
+    for (j = -16;j < hlen + 16;++j) h2[j] = h[j];
+    for (j = -16;j < 0;++j) m[j] = random();
+    for (j = mlen;j < mlen + 16;++j) m[j] = random();
+    for (j = -16;j < mlen + 16;++j) m2[j] = m[j];
+    if (crypto_hashblocks(h,m,mlen) != 0) return "crypto_hashblocks returns nonzero";
+    for (j = -16;j < mlen + 16;++j) if (m2[j] != m[j]) return "crypto_hashblocks writes to input";
+    for (j = -16;j < 0;++j) if (h2[j] != h[j]) return "crypto_hashblocks writes before output";
+    for (j = hlen;j < hlen + 16;++j) if (h2[j] != h[j]) return "crypto_hashblocks writes after output";
+    for (j = 0;j < hlen;++j) m2[j] = h2[j];
+    if (crypto_hashblocks(h2,m2,mlen) != 0) return "crypto_hashblocks returns nonzero";
+    if (crypto_hashblocks(m2,m2,mlen) != 0) return "crypto_hashblocks returns nonzero";
+    for (j = 0;j < hlen;++j) if (m2[j] != h2[j]) return "crypto_hashblocks does not handle overlap";
+    for (j = 0;j < mlen;++j) m[j] ^= h[j % hlen];
+    m[mlen] = h[0];
+  }
+  if (crypto_hashblocks(h,m,CHECKSUM_BYTES) != 0) return "crypto_hashblocks returns nonzero";
+
+  for (i = 0;i < crypto_hashblocks_STATEBYTES;++i) {
+    checksum[2 * i] = "0123456789abcdef"[15 & (h[i] >> 4)];
+    checksum[2 * i + 1] = "0123456789abcdef"[15 & h[i]];
+  }
+  checksum[2 * i] = 0;
+  return 0;
+}
diff --git a/nacl/crypto_hashblocks/wrapper-empty.cpp b/nacl/crypto_hashblocks/wrapper-empty.cpp
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/nacl/crypto_hashblocks/wrapper-empty.cpp