ruby_nacl 0.1.0

data/README.md

@@ -0,0 +1,49 @@
+## About Ruby_NaCl ##
+
+Ruby_NaCl is a Ruby gem that provides a wrapper around DJB's awesome NaCl library.
+
+
+
+## What is NaCl? ##
+
+[NaCl (pronounced "salt")](http://http://nacl.cr.yp.to/) is a new easy-to-use high-speed software library for network communication, encryption, decryption, signatures, etc written by Daniel J. Bernstein.
+
+
+
+## Install the gem ##
+
+1. git clone http://github.com/CaffeinatedMind/Ruby_NaCl.git
+2. cd Ruby_NaCl
+3. git submodule init
+4. git submodule update
+5. gem build ruby_nacl.gemspec
+6. gem install ruby_nacl-0.1.0.gem
+
+
+
+## "Hello, World" example ##
+
+```ruby
+require 'ruby_nacl'
+
+sender = NaCl.new
+receiver = NaCl.new
+
+sender.set_remote_nonce(receiver.nonce)
+receiver.set_remote_nonce(sender.nonce)
+
+sender.set_remote_key(receiver.public_key)
+receiver.set_remote_key(sender.public_key)
+
+receiver.set_secret(sender.secret)
+
+message = "Hello world!"
+encrypted_message = sender.public_encrypt(message)
+decrypted_message = receiver.public_decrypt(encrypted_message)
+puts decrypted_message
+```
+
+
+## License ##
+
+Ruby_NaCl is licensed under the [Ruby License](http://www.ruby-lang.org/en/LICENSE.txt).

data/ext/ruby_nacl/NaCl/MACROS

@@ -0,0 +1,56 @@
+crypto_verify
+crypto_verify_BYTES
+crypto_core
+crypto_core_OUTPUTBYTES
+crypto_core_INPUTBYTES
+crypto_core_KEYBYTES
+crypto_core_CONSTBYTES
+crypto_hashblocks
+crypto_hashblocks_STATEBYTES
+crypto_hashblocks_BLOCKBYTES
+crypto_hash
+crypto_hash_BYTES
+crypto_stream
+crypto_stream_xor
+crypto_stream_beforenm
+crypto_stream_afternm
+crypto_stream_xor_afternm
+crypto_stream_KEYBYTES
+crypto_stream_NONCEBYTES
+crypto_stream_BEFORENMBYTES
+crypto_onetimeauth
+crypto_onetimeauth_verify
+crypto_onetimeauth_BYTES
+crypto_onetimeauth_KEYBYTES
+crypto_auth
+crypto_auth_verify
+crypto_auth_BYTES
+crypto_auth_KEYBYTES
+crypto_secretbox
+crypto_secretbox_open
+crypto_secretbox_KEYBYTES
+crypto_secretbox_NONCEBYTES
+crypto_secretbox_ZEROBYTES
+crypto_secretbox_BOXZEROBYTES
+crypto_scalarmult
+crypto_scalarmult_base
+crypto_scalarmult_BYTES
+crypto_scalarmult_SCALARBYTES
+crypto_box
+crypto_box_open
+crypto_box_keypair
+crypto_box_beforenm
+crypto_box_afternm
+crypto_box_open_afternm
+crypto_box_PUBLICKEYBYTES
+crypto_box_SECRETKEYBYTES
+crypto_box_BEFORENMBYTES
+crypto_box_NONCEBYTES
+crypto_box_ZEROBYTES
+crypto_box_BOXZEROBYTES
+crypto_sign
+crypto_sign_open
+crypto_sign_keypair
+crypto_sign_BYTES
+crypto_sign_PUBLICKEYBYTES
+crypto_sign_SECRETKEYBYTES

data/ext/ruby_nacl/NaCl/OPERATIONS

@@ -0,0 +1,11 @@
+crypto_verify
+crypto_core
+crypto_hashblocks
+crypto_hash
+crypto_stream
+crypto_onetimeauth
+crypto_auth
+crypto_secretbox
+crypto_scalarmult
+crypto_box
+crypto_sign

data/ext/ruby_nacl/NaCl/PROTOTYPES.c

@@ -0,0 +1,26 @@
+extern int crypto_verify(const unsigned char *,const unsigned char *);
+extern int crypto_core(unsigned char *,const unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_hashblocks(unsigned char *,const unsigned char *,unsigned long long);
+extern int crypto_hash(unsigned char *,const unsigned char *,unsigned long long);
+extern int crypto_stream(unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_xor(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_beforenm(unsigned char *,const unsigned char *);
+extern int crypto_stream_afternm(unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_xor_afternm(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_onetimeauth(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_onetimeauth_verify(const unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_auth(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_auth_verify(const unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_secretbox(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_secretbox_open(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_scalarmult(unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_scalarmult_base(unsigned char *,const unsigned char *);
+extern int crypto_box(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_box_open(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_box_keypair(unsigned char *,unsigned char *);
+extern int crypto_box_beforenm(unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_box_afternm(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_box_open_afternm(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_sign(unsigned char *,unsigned long long *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_sign_open(unsigned char *,unsigned long long *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_sign_keypair(unsigned char *,unsigned char *);

data/ext/ruby_nacl/NaCl/PROTOTYPES.cpp

@@ -0,0 +1,17 @@
+extern std::string crypto_auth(const std::string &,const std::string &);
+extern void crypto_auth_verify(const std::string &,const std::string &,const std::string &);
+extern std::string crypto_box(const std::string &,const std::string &,const std::string &,const std::string &);
+extern std::string crypto_box_open(const std::string &,const std::string &,const std::string &,const std::string &);
+extern std::string crypto_box_keypair(std::string *);
+extern std::string crypto_hash(const std::string &);
+extern std::string crypto_onetimeauth(const std::string &,const std::string &);
+extern void crypto_onetimeauth_verify(const std::string &,const std::string &,const std::string &);
+extern std::string crypto_scalarmult(const std::string &,const std::string &);
+extern std::string crypto_scalarmult_base(const std::string &);
+extern std::string crypto_secretbox(const std::string &,const std::string &,const std::string &);
+extern std::string crypto_secretbox_open(const std::string &,const std::string &,const std::string &);
+extern std::string crypto_stream(size_t,const std::string &,const std::string &);
+extern std::string crypto_stream_xor(const std::string &,const std::string &,const std::string &);
+extern std::string crypto_sign(const std::string &,const std::string &);
+extern std::string crypto_sign_open(const std::string &,const std::string &);
+extern std::string crypto_sign_keypair(std::string *);

data/ext/ruby_nacl/NaCl/README

@@ -0,0 +1 @@
+Go here for info: http://nacl.cr.yp.to/

data/ext/ruby_nacl/NaCl/commandline/nacl-sha256.c

@@ -0,0 +1,64 @@
+/*
+commandline/nacl-sha256.c version 20080713
+D. J. Bernstein
+Public domain.
+*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "crypto_hash_sha256.h"
+
+unsigned char *input;
+unsigned long long inputalloc;
+unsigned long long inputlen;
+
+unsigned char h[crypto_hash_sha256_BYTES];
+
+void h_print(void)
+{
+  int i;
+  for (i = 0;i < crypto_hash_sha256_BYTES;++i) printf("%02x",255 & (int) h[i]);
+  printf("\n");
+}
+
+int main()
+{
+  struct stat st;
+  int ch;
+
+  if (fstat(0,&st) == 0) {
+    input = mmap(0,st.st_size,PROT_READ,MAP_SHARED,0,0);
+    if (input != MAP_FAILED) {
+      crypto_hash_sha256(h,input,st.st_size);
+      h_print();
+      return 0;
+    }
+  }
+
+  input = 0;
+  inputalloc = 0;
+  inputlen = 0;
+
+  while ((ch = getchar()) != EOF) {
+    if (inputlen >= inputalloc) {
+      void *newinput;
+      while (inputlen >= inputalloc)
+        inputalloc = inputalloc * 2 + 1;
+      if (posix_memalign(&newinput,16,inputalloc) != 0) return 111;
+      memcpy(newinput,input,inputlen);
+      free(input);
+      input = newinput;
+    }
+    input[inputlen++] = ch;
+  }
+
+  crypto_hash_sha256(h,input,inputlen);
+  h_print();
+
+  return 0;
+}

data/ext/ruby_nacl/NaCl/commandline/nacl-sha512.c

@@ -0,0 +1,64 @@
+/*
+commandline/nacl-sha512.c version 20080713
+D. J. Bernstein
+Public domain.
+*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "crypto_hash_sha512.h"
+
+unsigned char *input;
+unsigned long long inputalloc;
+unsigned long long inputlen;
+
+unsigned char h[crypto_hash_sha512_BYTES];
+
+void h_print(void)
+{
+  int i;
+  for (i = 0;i < crypto_hash_sha512_BYTES;++i) printf("%02x",255 & (int) h[i]);
+  printf("\n");
+}
+
+int main()
+{
+  struct stat st;
+  int ch;
+
+  if (fstat(0,&st) == 0) {
+    input = mmap(0,st.st_size,PROT_READ,MAP_SHARED,0,0);
+    if (input != MAP_FAILED) {
+      crypto_hash_sha512(h,input,st.st_size);
+      h_print();
+      return 0;
+    }
+  }
+
+  input = 0;
+  inputalloc = 0;
+  inputlen = 0;
+
+  while ((ch = getchar()) != EOF) {
+    if (inputlen >= inputalloc) {
+      void *newinput;
+      while (inputlen >= inputalloc)
+        inputalloc = inputalloc * 2 + 1;
+      if (posix_memalign(&newinput,16,inputalloc) != 0) return 111;
+      memcpy(newinput,input,inputlen);
+      free(input);
+      input = newinput;
+    }
+    input[inputlen++] = ch;
+  }
+
+  crypto_hash_sha512(h,input,inputlen);
+  h_print();
+
+  return 0;
+}

data/ext/ruby_nacl/NaCl/cpucycles/alpha.c

@@ -0,0 +1,80 @@
+/*
+cpucycles/alpha.c version 20060316
+D. J. Bernstein
+Public domain.
+*/
+
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static long long tod(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static long long rpcc(void)
+{
+  unsigned long long t;
+  asm volatile("rpcc %0" : "=r"(t));
+  return t & 0xffffffff;
+}
+
+static long long firstrpcc;
+static long long firsttod;
+static long long lastrpcc;
+static long long lasttod;
+static double mhz = 0;
+
+static void init(void)
+{
+  firstrpcc = rpcc();
+  firsttod = tod();
+
+  do {
+    lastrpcc = rpcc();
+    lasttod = tod();
+  } while (lasttod - firsttod < 10000);
+
+  lastrpcc -= firstrpcc; lastrpcc &= 0xffffffff;
+  lasttod -= firsttod;
+
+  mhz = (double) lastrpcc / (double) lasttod;
+}
+
+long long cpucycles_alpha(void)
+{
+  double x;
+  long long y;
+
+  if (!mhz) init();
+
+  lastrpcc = rpcc();
+  lasttod = tod();
+
+  lastrpcc -= firstrpcc; lastrpcc &= 0xffffffff;
+  lasttod -= firsttod;
+
+  /* Number of cycles since firstrpcc is lastrpcc + 2^32 y for unknown y. */
+  /* Number of microseconds since firsttod is lasttod. */
+
+  x = (lasttod * mhz - lastrpcc) * 0.00000000023283064365386962890625;
+  y = x;
+  while (x > y + 0.5) y += 1;
+  while (x < y - 0.5) y -= 1;
+
+  y *= 4294967296ULL;
+  lastrpcc += y;
+
+  mhz = (double) lastrpcc / (double) lasttod;
+
+  return firstrpcc + lastrpcc;
+}
+
+long long cpucycles_alpha_persecond(void)
+{
+  if (!mhz) init();
+  return 1000000.0 * mhz;
+}

data/ext/ruby_nacl/NaCl/cpucycles/alpha.h

@@ -0,0 +1,27 @@
+/*
+cpucycles alpha.h version 20060318
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_alpha_h
+#define CPUCYCLES_alpha_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_alpha(void);
+extern long long cpucycles_alpha_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "alpha"
+#define cpucycles cpucycles_alpha
+#define cpucycles_persecond cpucycles_alpha_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/amd64cpuinfo.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_amd64cpuinfo(void)
+{
+  unsigned long long result;
+  asm volatile(".byte 15;.byte 49;shlq $32,%%rdx;orq %%rdx,%%rax"
+    : "=a" (result) ::  "%rdx");
+  return result;
+}
+
+long long cpucycles_amd64cpuinfo_persecond(void)
+{
+  return osfreq();
+}

data/ext/ruby_nacl/NaCl/cpucycles/amd64cpuinfo.h

@@ -0,0 +1,27 @@
+/*
+cpucycles amd64cpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_amd64cpuinfo_h
+#define CPUCYCLES_amd64cpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_amd64cpuinfo(void);
+extern long long cpucycles_amd64cpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "amd64cpuinfo"
+#define cpucycles cpucycles_amd64cpuinfo
+#define cpucycles_persecond cpucycles_amd64cpuinfo_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/amd64cpuspeed.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_amd64cpuspeed(void)
+{
+  unsigned long long result;
+  asm volatile(".byte 15;.byte 49;shlq $32,%%rdx;orq %%rdx,%%rax"
+    : "=a" (result) ::  "%rdx");
+  return result;
+}
+
+long long cpucycles_amd64cpuspeed_persecond(void)
+{
+  int oid[2];
+  int val;
+  size_t size;
+  oid[0] = CTL_HW;
+  oid[1] = HW_CPUSPEED;
+  size = sizeof val;
+  if (sysctl(oid,2,&val,&size,0,0) == -1) return 0;
+  if (size != sizeof val) return 0;
+  return val * 1000000LL;
+}

data/ext/ruby_nacl/NaCl/cpucycles/amd64cpuspeed.h

@@ -0,0 +1,27 @@
+/*
+cpucycles amd64cpuspeed.h version 20090716
+Matthew Dempsky
+Public domain.
+*/
+
+#ifndef CPUCYCLES_amd64cpuspeed_h
+#define CPUCYCLES_amd64cpuspeed_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_amd64cpuspeed(void);
+extern long long cpucycles_amd64cpuspeed_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "amd64cpuspeed"
+#define cpucycles cpucycles_amd64cpuspeed
+#define cpucycles_persecond cpucycles_amd64cpuspeed_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/amd64tscfreq.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <sys/types.h>
+
+long long cpucycles_amd64tscfreq(void)
+{
+  unsigned long long result;
+  asm volatile(".byte 15;.byte 49;shlq $32,%%rdx;orq %%rdx,%%rax"
+    : "=a" (result) ::  "%rdx");
+  return result;
+}
+
+long long cpucycles_amd64tscfreq_persecond(void)
+{
+  long result = 0;
+  size_t resultlen = sizeof(long);
+  sysctlbyname("machdep.tsc_freq",&result,&resultlen,0,0);
+  return result;
+}

data/ext/ruby_nacl/NaCl/cpucycles/amd64tscfreq.h

@@ -0,0 +1,27 @@
+/*
+cpucycles amd64tscfreq.h version 20060318
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_amd64tscfreq_h
+#define CPUCYCLES_amd64tscfreq_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_amd64tscfreq(void);
+extern long long cpucycles_amd64tscfreq_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "amd64tscfreq"
+#define cpucycles cpucycles_amd64tscfreq
+#define cpucycles_persecond cpucycles_amd64tscfreq_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/celllinux.c

@@ -0,0 +1,83 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <spu_mfcio.h>
+
+static long myround(double u)
+{
+  long result = u;
+  while (result + 0.5 < u) result += 1;
+  while (result - 0.5 > u) result -= 1;
+  return result;
+}
+
+static long long microseconds(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static long long timebase(void)
+{
+  unsigned long long result;
+  result = -spu_read_decrementer();
+  return 0xffffffff & result;
+}
+
+static double cpufrequency = 0;
+static long tbcycles = 0;
+
+static double guesstbcycles(void)
+{
+  long long tb0; long long us0;
+  long long tb1; long long us1;
+
+  tb0 = timebase();
+  us0 = microseconds();
+  do {
+    tb1 = timebase();
+    us1 = microseconds();
+  } while (us1 - us0 < 10000 || tb1 - tb0 < 1000);
+  if (tb1 <= tb0) return 0;
+  tb1 -= tb0;
+  us1 -= us0;
+  return (cpufrequency * 0.000001 * (double) us1) / (double) tb1;
+}
+
+static void init(void)
+{
+  int loop;
+  double guess1;
+  double guess2;
+
+  spu_write_decrementer(0xffffffff);
+
+  cpufrequency = 3192000000.0;
+
+  for (loop = 0;loop < 100;++loop) {
+    guess1 = guesstbcycles();
+    guess2 = guesstbcycles();
+    tbcycles = myround(guess1);
+    if (guess1 - tbcycles > 0.1) continue;
+    if (tbcycles - guess1 > 0.1) continue;
+    if (guess2 - tbcycles > 0.1) continue;
+    if (tbcycles - guess2 > 0.1) continue;
+    return;
+  }
+  tbcycles = 0;
+}
+
+long long cpucycles_celllinux(void)
+{
+  if (!tbcycles) init();
+  return timebase() * tbcycles;
+}
+
+long long cpucycles_celllinux_persecond(void)
+{
+  if (!tbcycles) init();
+  return cpufrequency;
+}

data/ext/ruby_nacl/NaCl/cpucycles/celllinux.h

@@ -0,0 +1,27 @@
+/*
+cpucycles celllinux.h version 20081201
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_celllinux_h
+#define CPUCYCLES_celllinux_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_celllinux(void);
+extern long long cpucycles_celllinux_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "celllinux"
+#define cpucycles cpucycles_celllinux
+#define cpucycles_persecond cpucycles_celllinux_persecond
+#endif
+
+#endif