ruby_nacl 0.1.0

data/ext/ruby_nacl/NaCl/crypto_stream/try.c

@@ -0,0 +1,124 @@
+/*
+ * crypto_stream/try.c version 20090118
+ * D. J. Bernstein
+ * Public domain.
+ */
+
+#include <stdlib.h>
+#include "crypto_stream.h"
+
+extern unsigned char *alignedcalloc(unsigned long long);
+
+const char *primitiveimplementation = crypto_stream_IMPLEMENTATION;
+
+#define MAXTEST_BYTES 10000
+#define CHECKSUM_BYTES 4096
+#define TUNE_BYTES 1536
+
+static unsigned char *k;
+static unsigned char *n;
+static unsigned char *m;
+static unsigned char *c;
+static unsigned char *s;
+static unsigned char *k2;
+static unsigned char *n2;
+static unsigned char *m2;
+static unsigned char *c2;
+static unsigned char *s2;
+
+void preallocate(void)
+{
+}
+
+void allocate(void)
+{
+  k = alignedcalloc(crypto_stream_KEYBYTES);
+  n = alignedcalloc(crypto_stream_NONCEBYTES);
+  m = alignedcalloc(MAXTEST_BYTES);
+  c = alignedcalloc(MAXTEST_BYTES);
+  s = alignedcalloc(MAXTEST_BYTES);
+  k2 = alignedcalloc(crypto_stream_KEYBYTES);
+  n2 = alignedcalloc(crypto_stream_NONCEBYTES);
+  m2 = alignedcalloc(MAXTEST_BYTES);
+  c2 = alignedcalloc(MAXTEST_BYTES);
+  s2 = alignedcalloc(MAXTEST_BYTES);
+}
+
+void predoit(void)
+{
+}
+
+void doit(void)
+{
+  crypto_stream_xor(c,m,TUNE_BYTES,n,k);
+}
+
+char checksum[crypto_stream_KEYBYTES * 2 + 1];
+
+const char *checksum_compute(void)
+{
+  long long i;
+  long long j;
+
+  for (i = 0;i < CHECKSUM_BYTES;++i) {
+    long long mlen = i;
+    long long clen = i;
+    long long slen = i;
+    long long klen = crypto_stream_KEYBYTES;
+    long long nlen = crypto_stream_NONCEBYTES;
+    for (j = -16;j < 0;++j) m[j] = random();
+    for (j = -16;j < 0;++j) c[j] = random();
+    for (j = -16;j < 0;++j) s[j] = random();
+    for (j = -16;j < 0;++j) n[j] = random();
+    for (j = -16;j < 0;++j) k[j] = random();
+    for (j = mlen;j < mlen + 16;++j) m[j] = random();
+    for (j = clen;j < clen + 16;++j) c[j] = random();
+    for (j = slen;j < slen + 16;++j) s[j] = random();
+    for (j = nlen;j < nlen + 16;++j) n[j] = random();
+    for (j = klen;j < klen + 16;++j) k[j] = random();
+    for (j = -16;j < mlen + 16;++j) m2[j] = m[j];
+    for (j = -16;j < clen + 16;++j) c2[j] = c[j];
+    for (j = -16;j < slen + 16;++j) s2[j] = s[j];
+    for (j = -16;j < nlen + 16;++j) n2[j] = n[j];
+    for (j = -16;j < klen + 16;++j) k2[j] = k[j];
+
+    crypto_stream_xor(c,m,mlen,n,k);
+
+    for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_stream_xor overwrites m";
+    for (j = -16;j < slen + 16;++j) if (s[j] != s2[j]) return "crypto_stream_xor overwrites s";
+    for (j = -16;j < nlen + 16;++j) if (n[j] != n2[j]) return "crypto_stream_xor overwrites n";
+    for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_stream_xor overwrites k";
+    for (j = -16;j < 0;++j) if (c[j] != c2[j]) return "crypto_stream_xor writes before output";
+    for (j = clen;j < clen + 16;++j) if (c[j] != c2[j]) return "crypto_stream_xor writes after output";
+
+    for (j = -16;j < clen + 16;++j) c2[j] = c[j];
+
+    crypto_stream(s,slen,n,k);
+
+    for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_stream overwrites m";
+    for (j = -16;j < clen + 16;++j) if (c[j] != c2[j]) return "crypto_stream overwrites c";
+    for (j = -16;j < nlen + 16;++j) if (n[j] != n2[j]) return "crypto_stream overwrites n";
+    for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_stream overwrites k";
+    for (j = -16;j < 0;++j) if (s[j] != s2[j]) return "crypto_stream writes before output";
+    for (j = slen;j < slen + 16;++j) if (s[j] != s2[j]) return "crypto_stream writes after output";
+
+    for (j = 0;j < mlen;++j)
+      if ((s[j] ^ m[j]) != c[j]) return "crypto_stream_xor does not match crypto_stream";
+
+    for (j = 0;j < clen;++j) k[j % klen] ^= c[j];
+    crypto_stream_xor(m,c,clen,n,k);
+    crypto_stream(s,slen,n,k);
+    for (j = 0;j < mlen;++j)
+      if ((s[j] ^ m[j]) != c[j]) return "crypto_stream_xor does not match crypto_stream";
+    for (j = 0;j < mlen;++j) n[j % nlen] ^= m[j];
+    m[mlen] = 0;
+  }
+
+  for (i = 0;i < crypto_stream_KEYBYTES;++i) {
+    checksum[2 * i] = "0123456789abcdef"[15 & (k[i] >> 4)];
+    checksum[2 * i + 1] = "0123456789abcdef"[15 & k[i]];
+  }
+  checksum[2 * i] = 0;
+
+  return 0;
+}

data/ext/ruby_nacl/NaCl/crypto_stream/wrapper-stream.cpp

@@ -0,0 +1,12 @@
+#include <string>
+using std::string;
+#include "crypto_stream.h"
+
+string crypto_stream(size_t clen,const string &n,const string &k)
+{
+  if (n.size() != crypto_stream_NONCEBYTES) throw "incorrect nonce length";
+  if (k.size() != crypto_stream_KEYBYTES) throw "incorrect key length";
+  unsigned char c[clen];
+  crypto_stream(c,clen,(const unsigned char *) n.c_str(),(const unsigned char *) k.c_str());
+  return string((char *) c,clen);
+}

data/ext/ruby_nacl/NaCl/crypto_stream/wrapper-xor.cpp

@@ -0,0 +1,17 @@
+#include <string>
+using std::string;
+#include "crypto_stream.h"
+
+string crypto_stream_xor(const string &m,const string &n,const string &k)
+{
+  if (n.size() != crypto_stream_NONCEBYTES) throw "incorrect nonce length";
+  if (k.size() != crypto_stream_KEYBYTES) throw "incorrect key length";
+  size_t mlen = m.size();
+  unsigned char c[mlen];
+  crypto_stream_xor(c,
+    (const unsigned char *) m.c_str(),mlen,
+    (const unsigned char *) n.c_str(),
+    (const unsigned char *) k.c_str()
+    );
+  return string((char *) c,mlen);
+}

data/ext/ruby_nacl/NaCl/crypto_stream/xsalsa20/checksum

@@ -0,0 +1 @@
+201bc58a96adcb6ed339ca33c188af8ca04a4ce68be1e0953309ee09a0cf8e7a

data/ext/ruby_nacl/NaCl/crypto_stream/xsalsa20/ref/api.h

@@ -0,0 +1,2 @@
+#define CRYPTO_KEYBYTES 32
+#define CRYPTO_NONCEBYTES 24

data/ext/ruby_nacl/NaCl/crypto_stream/xsalsa20/ref/implementors

@@ -0,0 +1 @@
+Daniel J. Bernstein

data/ext/ruby_nacl/NaCl/crypto_stream/xsalsa20/ref/stream.c

@@ -0,0 +1,22 @@
+/*
+version 20080914
+D. J. Bernstein
+Public domain.
+*/
+
+#include "crypto_core_hsalsa20.h"
+#include "crypto_stream_salsa20.h"
+#include "crypto_stream.h"
+
+static const unsigned char sigma[16] = "expand 32-byte k";
+
+int crypto_stream(
+        unsigned char *c,unsigned long long clen,
+  const unsigned char *n,
+  const unsigned char *k
+)
+{
+  unsigned char subkey[32];
+  crypto_core_hsalsa20(subkey,n,k,sigma);
+  return crypto_stream_salsa20(c,clen,n + 16,subkey);
+}

data/ext/ruby_nacl/NaCl/crypto_stream/xsalsa20/ref/xor.c

@@ -0,0 +1,23 @@
+/*
+version 20080913
+D. J. Bernstein
+Public domain.
+*/
+
+#include "crypto_core_hsalsa20.h"
+#include "crypto_stream_salsa20.h"
+#include "crypto_stream.h"
+
+static const unsigned char sigma[16] = "expand 32-byte k";
+
+int crypto_stream_xor(
+        unsigned char *c,
+  const unsigned char *m,unsigned long long mlen,
+  const unsigned char *n,
+  const unsigned char *k
+)
+{
+  unsigned char subkey[32];
+  crypto_core_hsalsa20(subkey,n,k,sigma);
+  return crypto_stream_salsa20_xor(c,m,mlen,n + 16,subkey);
+}

data/ext/ruby_nacl/NaCl/crypto_stream.h

@@ -0,0 +1,18 @@
+#ifndef crypto_stream_H
+#define crypto_stream_H
+
+#include "crypto_stream_aes128ctr.h"
+
+#define crypto_stream crypto_stream_aes128ctr
+#define crypto_stream_xor crypto_stream_aes128ctr_xor
+#define crypto_stream_beforenm crypto_stream_aes128ctr_beforenm
+#define crypto_stream_afternm crypto_stream_aes128ctr_afternm
+#define crypto_stream_xor_afternm crypto_stream_aes128ctr_xor_afternm
+#define crypto_stream_KEYBYTES crypto_stream_aes128ctr_KEYBYTES
+#define crypto_stream_NONCEBYTES crypto_stream_aes128ctr_NONCEBYTES
+#define crypto_stream_BEFORENMBYTES crypto_stream_aes128ctr_BEFORENMBYTES
+#define crypto_stream_PRIMITIVE "aes128ctr"
+#define crypto_stream_IMPLEMENTATION crypto_stream_aes128ctr_IMPLEMENTATION
+#define crypto_stream_VERSION crypto_stream_aes128ctr_VERSION
+
+#endif

data/ext/ruby_nacl/NaCl/crypto_stream_aes128ctr.h

@@ -0,0 +1,33 @@
+#ifndef crypto_stream_aes128ctr_H
+#define crypto_stream_aes128ctr_H
+
+#ifdef __cplusplus
+#include <string>
+extern std::string crypto_stream_aes128ctr_portable(size_t,const std::string &,const std::string &);
+extern std::string crypto_stream_aes128ctr_portable_xor(const std::string &,const std::string &,const std::string &);
+extern "C" {
+#endif
+extern int crypto_stream_aes128ctr_portable(unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_aes128ctr_portable_xor(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_aes128ctr_portable_beforenm(unsigned char *,const unsigned char *);
+extern int crypto_stream_aes128ctr_portable_afternm(unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_aes128ctr_portable_xor_afternm(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+#ifdef __cplusplus
+}
+#endif
+
+#define crypto_stream_aes128ctr crypto_stream_aes128ctr_portable
+#define crypto_stream_aes128ctr_xor crypto_stream_aes128ctr_portable_xor
+#define crypto_stream_aes128ctr_beforenm crypto_stream_aes128ctr_portable_beforenm
+#define crypto_stream_aes128ctr_afternm crypto_stream_aes128ctr_portable_afternm
+#define crypto_stream_aes128ctr_xor_afternm crypto_stream_aes128ctr_portable_xor_afternm
+#define crypto_stream_aes128ctr_KEYBYTES crypto_stream_aes128ctr_portable_KEYBYTES
+#define crypto_stream_aes128ctr_NONCEBYTES crypto_stream_aes128ctr_portable_NONCEBYTES
+#define crypto_stream_aes128ctr_BEFORENMBYTES crypto_stream_aes128ctr_portable_BEFORENMBYTES
+#define crypto_stream_aes128ctr_IMPLEMENTATION "crypto_stream/aes128ctr/portable"
+#ifndef crypto_stream_aes128ctr_portable_VERSION
+#define crypto_stream_aes128ctr_portable_VERSION "-"
+#endif
+#define crypto_stream_aes128ctr_VERSION crypto_stream_aes128ctr_portable_VERSION
+
+#endif

data/ext/ruby_nacl/NaCl/crypto_verify/16/checksum

@@ -0,0 +1 @@
+0

data/ext/ruby_nacl/NaCl/crypto_verify/16/ref/api.h

@@ -0,0 +1 @@
+#define CRYPTO_BYTES 16

data/ext/ruby_nacl/NaCl/crypto_verify/16/ref/verify.c

@@ -0,0 +1,24 @@
+#include "crypto_verify.h"
+
+int crypto_verify(const unsigned char *x,const unsigned char *y)
+{
+  unsigned int differentbits = 0;
+#define F(i) differentbits |= x[i] ^ y[i];
+  F(0)
+  F(1)
+  F(2)
+  F(3)
+  F(4)
+  F(5)
+  F(6)
+  F(7)
+  F(8)
+  F(9)
+  F(10)
+  F(11)
+  F(12)
+  F(13)
+  F(14)
+  F(15)
+  return (1 & ((differentbits - 1) >> 8)) - 1;
+}

data/ext/ruby_nacl/NaCl/crypto_verify/32/checksum

@@ -0,0 +1 @@
+0

data/ext/ruby_nacl/NaCl/crypto_verify/32/ref/api.h

@@ -0,0 +1 @@
+#define CRYPTO_BYTES 32

data/ext/ruby_nacl/NaCl/crypto_verify/32/ref/verify.c

@@ -0,0 +1,40 @@
+#include "crypto_verify.h"
+
+int crypto_verify(const unsigned char *x,const unsigned char *y)
+{
+  unsigned int differentbits = 0;
+#define F(i) differentbits |= x[i] ^ y[i];
+  F(0)
+  F(1)
+  F(2)
+  F(3)
+  F(4)
+  F(5)
+  F(6)
+  F(7)
+  F(8)
+  F(9)
+  F(10)
+  F(11)
+  F(12)
+  F(13)
+  F(14)
+  F(15)
+  F(16)
+  F(17)
+  F(18)
+  F(19)
+  F(20)
+  F(21)
+  F(22)
+  F(23)
+  F(24)
+  F(25)
+  F(26)
+  F(27)
+  F(28)
+  F(29)
+  F(30)
+  F(31)
+  return (1 & ((differentbits - 1) >> 8)) - 1;
+}

data/ext/ruby_nacl/NaCl/crypto_verify/measure.c

@@ -0,0 +1,18 @@
+#include "crypto_verify.h"
+
+const char *primitiveimplementation = crypto_verify_IMPLEMENTATION;
+const char *implementationversion = crypto_verify_VERSION;
+const char *sizenames[] = { "inputbytes", 0 };
+const long long sizes[] = { crypto_verify_BYTES };
+
+void preallocate(void)
+{
+}
+
+void allocate(void)
+{
+}
+
+void measure(void)
+{
+}

data/ext/ruby_nacl/NaCl/crypto_verify/try.c

@@ -0,0 +1,75 @@
+/*
+ * crypto_verify/try.c version 20090118
+ * D. J. Bernstein
+ * Public domain.
+ */
+
+#include <stdlib.h>
+#include "crypto_verify.h"
+
+extern unsigned char *alignedcalloc(unsigned long long);
+
+const char *primitiveimplementation = crypto_verify_IMPLEMENTATION;
+
+static unsigned char *x;
+static unsigned char *y;
+
+void preallocate(void)
+{
+}
+
+void allocate(void)
+{
+  x = alignedcalloc(crypto_verify_BYTES);
+  y = alignedcalloc(crypto_verify_BYTES);
+}
+
+void predoit(void)
+{
+}
+
+void doit(void)
+{
+  crypto_verify(x,y);
+}
+
+static const char *check(void)
+{
+  int r = crypto_verify(x,y);
+  if (r == 0) {
+    if (memcmp(x,y,crypto_verify_BYTES)) return "different strings pass verify";
+  } else if (r == -1) {
+    if (!memcmp(x,y,crypto_verify_BYTES)) return "equal strings fail verify";
+  } else {
+    return "weird return value from verify";
+  }
+  return 0;
+}
+
+char checksum[2];
+
+const char *checksum_compute(void)
+{
+  long long tests;
+  long long i;
+  long long j;
+  const char *c;
+
+  for (tests = 0;tests < 100000;++tests) {
+    for (i = 0;i < crypto_verify_BYTES;++i) x[i] = random();
+    for (i = 0;i < crypto_verify_BYTES;++i) y[i] = random();
+    c = check(); if (c) return c;
+    for (i = 0;i < crypto_verify_BYTES;++i) y[i] = x[i];
+    c = check(); if (c) return c;
+    y[random() % crypto_verify_BYTES] = random();
+    c = check(); if (c) return c;
+    y[random() % crypto_verify_BYTES] = random();
+    c = check(); if (c) return c;
+    y[random() % crypto_verify_BYTES] = random();
+    c = check(); if (c) return c;
+  }
+
+  checksum[0] = '0';
+  checksum[1] = 0;
+  return 0;
+}

data/ext/ruby_nacl/NaCl/curvecp/LIBS

@@ -0,0 +1,31 @@
+blocking.o
+byte_copy.o
+byte_isequal.o
+byte_zero.o
+crypto_block.o
+die.o
+e.o
+hexparse.o
+load.o
+nameparse.o
+nanoseconds.o
+open_cwd.o
+open_lock.o
+open_pipe.o
+open_read.o
+open_write.o
+portparse.o
+randommod.o
+safenonce.o
+savesync.o
+socket_bind.o
+socket_recv.o
+socket_send.o
+socket_udp.o
+uint16_pack.o
+uint16_unpack.o
+uint32_pack.o
+uint32_unpack.o
+uint64_pack.o
+uint64_unpack.o
+writeall.o

data/ext/ruby_nacl/NaCl/curvecp/README

@@ -0,0 +1,10 @@
+Example of use (with nacl-20110221/build/*/bin in $PATH):
+  curvecpmakekey serverkey
+  curvecpprintkey serverkey > serverkey.hex
+  curvecpserver this.machine.name serverkey \
+    127.0.0.1 10000 31415926535897932384626433832795 \
+      curvecpmessage cat /usr/share/dict/words &
+  curvecpclient this.machine.name `cat serverkey.hex` \
+    127.0.0.1 10000 31415926535897932384626433832795 \
+      curvecpmessage -c sh -c 'nacl-sha512 <&6'
+  nacl-sha512 < /usr/share/dict/words

data/ext/ruby_nacl/NaCl/curvecp/SOURCES

@@ -0,0 +1,36 @@
+blocking
+byte_copy
+byte_isequal
+byte_zero
+crypto_block
+die
+e
+hexparse
+load
+nameparse
+nanoseconds
+open_cwd
+open_lock
+open_pipe
+open_read
+open_write
+portparse
+randommod
+safenonce
+savesync
+socket_bind
+socket_recv
+socket_send
+socket_udp
+uint16_pack
+uint16_unpack
+uint32_pack
+uint32_unpack
+uint64_pack
+uint64_unpack
+writeall
+curvecpprintkey
+curvecpmakekey
+curvecpclient
+curvecpserver
+curvecpmessage

data/ext/ruby_nacl/NaCl/curvecp/TARGETS

@@ -0,0 +1,5 @@
+curvecpprintkey
+curvecpmakekey
+curvecpclient
+curvecpserver
+curvecpmessage

data/ext/ruby_nacl/NaCl/curvecp/blocking.c

@@ -0,0 +1,12 @@
+#include <fcntl.h>
+#include "blocking.h"
+
+void blocking_enable(int fd)
+{
+  fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,0) & ~O_NONBLOCK);
+}
+
+void blocking_disable(int fd)
+{
+  fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,0) | O_NONBLOCK);
+}

data/ext/ruby_nacl/NaCl/curvecp/blocking.h

@@ -0,0 +1,7 @@
+#ifndef BLOCKING_H
+#define BLOCKING_H
+
+extern void blocking_enable(int);
+extern void blocking_disable(int);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/byte.h

@@ -0,0 +1,8 @@
+#ifndef BYTE_H
+#define BYTE_H
+
+extern void byte_zero(void *,long long);
+extern void byte_copy(void *,long long,const void *);
+extern int byte_isequal(const void *,long long,const void *);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/byte_copy.c

@@ -0,0 +1,8 @@
+#include "byte.h"
+
+void byte_copy(void *yv,long long ylen,const void *xv)
+{
+  char *y = yv;
+  const char *x = xv;
+  while (ylen > 0) { *y++ = *x++; --ylen; }
+}

data/ext/ruby_nacl/NaCl/curvecp/byte_isequal.c

@@ -0,0 +1,10 @@
+#include "byte.h"
+
+int byte_isequal(const void *yv,long long ylen,const void *xv)
+{
+  const unsigned char *y = yv;
+  const unsigned char *x = xv;
+  unsigned char diff = 0;
+  while (ylen > 0) { diff |= (*y++ ^ *x++); --ylen; }
+  return (256 - (unsigned int) diff) >> 8;
+}

data/ext/ruby_nacl/NaCl/curvecp/byte_zero.c

@@ -0,0 +1,7 @@
+#include "byte.h"
+
+void byte_zero(void *yv,long long ylen)
+{
+  char *y = yv;
+  while (ylen > 0) { *y++ = 0; --ylen; }
+}

data/ext/ruby_nacl/NaCl/curvecp/crypto_block.c

@@ -0,0 +1,35 @@
+#include "crypto_block.h"
+#include "crypto_uint64.h"
+#include "uint64_unpack.h"
+#include "uint64_pack.h"
+
+/*
+TEA with double-size words.
+XXX: Switch to crypto_block_aes256.
+XXX: Build crypto_stream_aes256 on top of crypto_block_aes256.
+*/
+
+int crypto_block(
+  unsigned char *out,
+  const unsigned char *in,
+  const unsigned char *k
+)
+{
+  crypto_uint64 v0 = uint64_unpack(in + 0);
+  crypto_uint64 v1 = uint64_unpack(in + 8);
+  crypto_uint64 k0 = uint64_unpack(k + 0);
+  crypto_uint64 k1 = uint64_unpack(k + 8);
+  crypto_uint64 k2 = uint64_unpack(k + 16);
+  crypto_uint64 k3 = uint64_unpack(k + 24);
+  crypto_uint64 sum = 0;
+  crypto_uint64 delta = 0x9e3779b97f4a7c15;
+  int i;
+  for (i = 0;i < 32;++i) {
+    sum += delta;
+    v0 += ((v1<<7) + k0) ^ (v1 + sum) ^ ((v1>>12) + k1);
+    v1 += ((v0<<16) + k2) ^ (v0 + sum) ^ ((v0>>8) + k3);
+  }
+  uint64_pack(out + 0,v0);
+  uint64_pack(out + 8,v1);
+  return 0;
+}

data/ext/ruby_nacl/NaCl/curvecp/crypto_block.h

@@ -0,0 +1,4 @@
+#define crypto_block_BYTES 16
+#define crypto_block_KEYBYTES 32
+
+extern int crypto_block(unsigned char *,const unsigned char *,const unsigned char *);