ruby_nacl 0.1.0

data/ext/ruby_nacl/NaCl/crypto_stream/aes128ctr/portable/consts.c

@@ -0,0 +1,14 @@
+#include "consts.h"
+
+const unsigned char ROTB[16] = {0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08};
+const unsigned char M0[16]   = {0x0f, 0x0b, 0x07, 0x03, 0x0e, 0x0a, 0x06, 0x02, 0x0d, 0x09, 0x05, 0x01, 0x0c, 0x08, 0x04, 0x00};
+const unsigned char EXPB0[16] = {0x03, 0x03, 0x03, 0x03, 0x07, 0x07, 0x07, 0x07, 0x0b, 0x0b, 0x0b, 0x0b, 0x0f, 0x0f, 0x0f, 0x0f};
+
+const unsigned char SWAP32[16] = {0x03, 0x02, 0x01, 0x00, 0x07, 0x06, 0x05, 0x04, 0x0b, 0x0a, 0x09, 0x08, 0x0f, 0x0e, 0x0d, 0x0c};
+const unsigned char M0SWAP[16] = {0x0c, 0x08, 0x04, 0x00, 0x0d, 0x09, 0x05, 0x01, 0x0e, 0x0a, 0x06, 0x02, 0x0f, 0x0b, 0x07, 0x03}; 
+const unsigned char SR[16] = {0x01, 0x02, 0x03, 0x00, 0x06, 0x07, 0x04, 0x05, 0x0b, 0x08, 0x09, 0x0a, 0x0c, 0x0d, 0x0e, 0x0f};
+const unsigned char SRM0[16] = {0x0f, 0x0a, 0x05, 0x00, 0x0e, 0x09, 0x04, 0x03, 0x0d, 0x08, 0x07, 0x02, 0x0c, 0x0b, 0x06, 0x01};
+
+const int128 BS0 = {0x5555555555555555ULL, 0x5555555555555555ULL};
+const int128 BS1 = {0x3333333333333333ULL, 0x3333333333333333ULL};
+const int128 BS2 = {0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL};

data/ext/ruby_nacl/NaCl/crypto_stream/aes128ctr/portable/consts.h

@@ -0,0 +1,28 @@
+#ifndef CONSTS_H
+#define CONSTS_H
+
+#include "int128.h"
+
+#define ROTB crypto_stream_aes128ctr_portable_ROTB
+#define M0 crypto_stream_aes128ctr_portable_M0
+#define EXPB0 crypto_stream_aes128ctr_portable_EXPB0
+#define SWAP32 crypto_stream_aes128ctr_portable_SWAP32
+#define M0SWAP crypto_stream_aes128ctr_portable_M0SWAP
+#define SR crypto_stream_aes128ctr_portable_SR
+#define SRM0 crypto_stream_aes128ctr_portable_SRM0
+#define BS0 crypto_stream_aes128ctr_portable_BS0
+#define BS1 crypto_stream_aes128ctr_portable_BS1
+#define BS2 crypto_stream_aes128ctr_portable_BS2
+
+extern const unsigned char ROTB[16];
+extern const unsigned char M0[16];
+extern const unsigned char EXPB0[16];
+extern const unsigned char SWAP32[16];
+extern const unsigned char M0SWAP[16];
+extern const unsigned char SR[16];
+extern const unsigned char SRM0[16];
+extern const int128 BS0;
+extern const int128 BS1;
+extern const int128 BS2;
+
+#endif

data/ext/ruby_nacl/NaCl/crypto_stream/aes128ctr/portable/int128.c

@@ -0,0 +1,128 @@
+#include "int128.h"
+#include "common.h"
+
+void xor2(int128 *r, const int128 *x)
+{
+  r->a ^= x->a;
+  r->b ^= x->b;
+}
+
+void and2(int128 *r, const int128 *x)
+{
+  r->a &= x->a;
+  r->b &= x->b;
+}
+
+void or2(int128 *r, const int128 *x)
+{
+  r->a |= x->a;
+  r->b |= x->b;
+}
+
+void copy2(int128 *r, const int128 *x)
+{
+  r->a = x->a;
+  r->b = x->b;
+}
+
+void shufb(int128 *r, const unsigned char *l)
+{
+  int128 t;
+  copy2(&t,r);
+  unsigned char *cr = (unsigned char *)r;
+  unsigned char *ct = (unsigned char *)&t;
+  cr[0] = ct[l[0]];
+  cr[1] = ct[l[1]];
+  cr[2] = ct[l[2]];
+  cr[3] = ct[l[3]];
+  cr[4] = ct[l[4]];
+  cr[5] = ct[l[5]];
+  cr[6] = ct[l[6]];
+  cr[7] = ct[l[7]];
+  cr[8] = ct[l[8]];
+  cr[9] = ct[l[9]];
+  cr[10] = ct[l[10]];
+  cr[11] = ct[l[11]];
+  cr[12] = ct[l[12]];
+  cr[13] = ct[l[13]];
+  cr[14] = ct[l[14]];
+  cr[15] = ct[l[15]];
+}
+
+void shufd(int128 *r, const int128 *x, const unsigned int c)
+{
+  int128 t;
+  uint32 *tp = (uint32 *)&t;
+  uint32 *xp = (uint32 *)x;
+  tp[0] = xp[c&3];
+  tp[1] = xp[(c>>2)&3];
+  tp[2] = xp[(c>>4)&3];
+  tp[3] = xp[(c>>6)&3];
+  copy2(r,&t);
+}
+
+void rshift32_littleendian(int128 *r, const unsigned int n)
+{
+  unsigned char *rp = (unsigned char *)r;
+  uint32 t;
+  t = load32_littleendian(rp);
+  t >>= n;
+  store32_littleendian(rp, t);
+  t = load32_littleendian(rp+4);
+  t >>= n;
+  store32_littleendian(rp+4, t);
+  t = load32_littleendian(rp+8);
+  t >>= n;
+  store32_littleendian(rp+8, t);
+  t = load32_littleendian(rp+12);
+  t >>= n;
+  store32_littleendian(rp+12, t);
+}
+
+void rshift64_littleendian(int128 *r, const unsigned int n)
+{
+  unsigned char *rp = (unsigned char *)r;
+  uint64 t;
+  t = load64_littleendian(rp);
+  t >>= n;
+  store64_littleendian(rp, t);
+  t = load64_littleendian(rp+8);
+  t >>= n;
+  store64_littleendian(rp+8, t);
+}
+
+void lshift64_littleendian(int128 *r, const unsigned int n)
+{
+  unsigned char *rp = (unsigned char *)r;
+  uint64 t;
+  t = load64_littleendian(rp);
+  t <<= n;
+  store64_littleendian(rp, t);
+  t = load64_littleendian(rp+8);
+  t <<= n;
+  store64_littleendian(rp+8, t);
+}
+
+void toggle(int128 *r)
+{
+  r->a ^= 0xffffffffffffffffULL;
+  r->b ^= 0xffffffffffffffffULL;
+}
+
+void xor_rcon(int128 *r)
+{
+  unsigned char *rp = (unsigned char *)r;
+  uint32 t;
+  t = load32_littleendian(rp+12);
+  t ^= 0xffffffff;
+  store32_littleendian(rp+12, t);
+}
+
+void add_uint32_big(int128 *r, uint32 x)
+{
+  unsigned char *rp = (unsigned char *)r;
+  uint32 t;
+  t = load32_littleendian(rp+12);
+  t += x;
+  store32_littleendian(rp+12, t);
+}

data/ext/ruby_nacl/NaCl/crypto_stream/aes128ctr/portable/int128.h

@@ -0,0 +1,47 @@
+#ifndef INT128_H
+#define INT128_H
+
+#include "common.h"
+
+typedef struct{
+  unsigned long long a;
+  unsigned long long b;
+} int128;
+
+#define xor2 crypto_stream_aes128ctr_portable_xor2
+void xor2(int128 *r, const int128 *x);
+
+#define and2 crypto_stream_aes128ctr_portable_and2
+void and2(int128 *r, const int128 *x);
+
+#define or2 crypto_stream_aes128ctr_portable_or2
+void or2(int128 *r, const int128 *x);
+
+#define copy2 crypto_stream_aes128ctr_portable_copy2
+void copy2(int128 *r, const int128 *x);
+
+#define shufb crypto_stream_aes128ctr_portable_shufb
+void shufb(int128 *r, const unsigned char *l);
+
+#define shufd crypto_stream_aes128ctr_portable_shufd
+void shufd(int128 *r, const int128 *x, const unsigned int c);
+
+#define rshift32_littleendian crypto_stream_aes128ctr_portable_rshift32_littleendian
+void rshift32_littleendian(int128 *r, const unsigned int n);
+
+#define rshift64_littleendian crypto_stream_aes128ctr_portable_rshift64_littleendian
+void rshift64_littleendian(int128 *r, const unsigned int n);
+
+#define lshift64_littleendian crypto_stream_aes128ctr_portable_lshift64_littleendian
+void lshift64_littleendian(int128 *r, const unsigned int n);
+
+#define toggle crypto_stream_aes128ctr_portable_toggle
+void toggle(int128 *r);
+
+#define xor_rcon crypto_stream_aes128ctr_portable_xor_rcon
+void xor_rcon(int128 *r);
+
+#define add_uint32_big crypto_stream_aes128ctr_portable_add_uint32_big
+void add_uint32_big(int128 *r, uint32 x);
+
+#endif

data/ext/ruby_nacl/NaCl/crypto_stream/aes128ctr/portable/stream.c

@@ -0,0 +1,28 @@
+#include "crypto_stream.h"
+
+int crypto_stream(
+        unsigned char *out,
+        unsigned long long outlen,
+        const unsigned char *n,
+        const unsigned char *k
+        )
+{
+    unsigned char d[crypto_stream_BEFORENMBYTES];
+    crypto_stream_beforenm(d, k);
+    crypto_stream_afternm(out, outlen, n, d);
+    return 0;
+}
+
+int crypto_stream_xor(
+        unsigned char *out,
+        const unsigned char *in,
+        unsigned long long inlen,
+        const unsigned char *n,
+        const unsigned char *k
+        )
+{
+    unsigned char d[crypto_stream_BEFORENMBYTES];
+    crypto_stream_beforenm(d, k);
+    crypto_stream_xor_afternm(out, in, inlen, n, d);
+    return 0;
+}

data/ext/ruby_nacl/NaCl/crypto_stream/aes128ctr/portable/types.h

@@ -0,0 +1,10 @@
+#ifndef TYPES_H
+#define TYPES_H
+
+#include "crypto_uint32.h"
+typedef crypto_uint32 uint32;
+
+#include "crypto_uint64.h"
+typedef crypto_uint64 uint64;
+
+#endif

data/ext/ruby_nacl/NaCl/crypto_stream/aes128ctr/portable/xor_afternm.c

@@ -0,0 +1,180 @@
+/* Author: Peter Schwabe, ported from an assembly implementation by Emilia Käsper
+ * Date: 2009-03-19
+ * Public domain */
+
+#include <stdio.h>
+#include "int128.h"
+#include "common.h"
+#include "consts.h"
+#include "crypto_stream.h"
+
+int crypto_stream_xor_afternm(unsigned char *outp, const unsigned char *inp, unsigned long long len, const unsigned char *noncep, const unsigned char *c)
+{
+
+  int128 xmm0;
+  int128 xmm1;
+  int128 xmm2;
+  int128 xmm3;
+  int128 xmm4;
+  int128 xmm5;
+  int128 xmm6;
+  int128 xmm7;
+
+  int128 xmm8;
+  int128 xmm9;
+  int128 xmm10;
+  int128 xmm11;
+  int128 xmm12;
+  int128 xmm13;
+  int128 xmm14;
+  int128 xmm15;
+
+  int128 nonce_stack;
+  unsigned long long lensav;
+  unsigned char bl[128];
+  unsigned char *blp;
+  unsigned char b;
+
+  uint32 tmp;
+
+  /* Copy nonce on the stack */
+  copy2(&nonce_stack, (int128 *) (noncep + 0));
+  unsigned char *np = (unsigned char *)&nonce_stack;
+
+    enc_block:
+
+    xmm0 = *(int128 *) (np + 0);
+    copy2(&xmm1, &xmm0);
+    shufb(&xmm1, SWAP32);
+    copy2(&xmm2, &xmm1);
+    copy2(&xmm3, &xmm1);
+    copy2(&xmm4, &xmm1);
+    copy2(&xmm5, &xmm1);
+    copy2(&xmm6, &xmm1);
+    copy2(&xmm7, &xmm1);
+
+    add_uint32_big(&xmm1, 1);
+    add_uint32_big(&xmm2, 2);
+    add_uint32_big(&xmm3, 3);
+    add_uint32_big(&xmm4, 4);
+    add_uint32_big(&xmm5, 5);
+    add_uint32_big(&xmm6, 6);
+    add_uint32_big(&xmm7, 7);
+
+    shufb(&xmm0, M0);
+    shufb(&xmm1, M0SWAP);
+    shufb(&xmm2, M0SWAP);
+    shufb(&xmm3, M0SWAP);
+    shufb(&xmm4, M0SWAP);
+    shufb(&xmm5, M0SWAP);
+    shufb(&xmm6, M0SWAP);
+    shufb(&xmm7, M0SWAP);
+
+    bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, xmm8)
+
+    aesround( 1, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,c)
+    aesround( 2, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,c)
+    aesround( 3, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,c)
+    aesround( 4, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,c)
+    aesround( 5, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,c)
+    aesround( 6, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,c)
+    aesround( 7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,c)
+    aesround( 8, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,c)
+    aesround( 9, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,c)
+    lastround(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,c)
+
+    bitslice(xmm13, xmm10, xmm15, xmm11, xmm14, xmm12, xmm9, xmm8, xmm0)
+
+    if(len < 128) goto partial;
+    if(len == 128) goto full;
+
+    tmp = load32_bigendian(np + 12);
+    tmp += 8;
+    store32_bigendian(np + 12, tmp);
+
+    xor2(&xmm8, (int128 *)(inp + 0));
+    xor2(&xmm9, (int128 *)(inp + 16));
+    xor2(&xmm12, (int128 *)(inp + 32));
+    xor2(&xmm14, (int128 *)(inp + 48));
+    xor2(&xmm11, (int128 *)(inp + 64));
+    xor2(&xmm15, (int128 *)(inp + 80));
+    xor2(&xmm10, (int128 *)(inp + 96));
+    xor2(&xmm13, (int128 *)(inp + 112));
+
+    *(int128 *) (outp + 0) = xmm8;
+    *(int128 *) (outp + 16) = xmm9;
+    *(int128 *) (outp + 32) = xmm12;
+    *(int128 *) (outp + 48) = xmm14;
+    *(int128 *) (outp + 64) = xmm11;
+    *(int128 *) (outp + 80) = xmm15;
+    *(int128 *) (outp + 96) = xmm10;
+    *(int128 *) (outp + 112) = xmm13;
+
+    len -= 128;
+    inp += 128;
+    outp += 128;
+
+    goto enc_block;
+
+    partial:
+
+    lensav = len;
+    len >>= 4;
+
+    tmp = load32_bigendian(np + 12);
+    tmp += len;
+    store32_bigendian(np + 12, tmp);
+
+    blp = bl;
+    *(int128 *)(blp + 0) = xmm8;
+    *(int128 *)(blp + 16) = xmm9;
+    *(int128 *)(blp + 32) = xmm12;
+    *(int128 *)(blp + 48) = xmm14;
+    *(int128 *)(blp + 64) = xmm11;
+    *(int128 *)(blp + 80) = xmm15;
+    *(int128 *)(blp + 96) = xmm10;
+    *(int128 *)(blp + 112) = xmm13;
+
+    bytes:
+
+    if(lensav == 0) goto end;
+
+    b = blp[0];
+    b ^= *(unsigned char *)(inp + 0);
+    *(unsigned char *)(outp + 0) = b;
+
+    blp += 1;
+    inp +=1;
+    outp +=1;
+    lensav -= 1;
+
+    goto bytes;
+
+    full:
+
+    tmp = load32_bigendian(np + 12);
+    tmp += 8;
+    store32_bigendian(np + 12, tmp);
+
+    xor2(&xmm8, (int128 *)(inp + 0));
+    xor2(&xmm9, (int128 *)(inp + 16));
+    xor2(&xmm12, (int128 *)(inp + 32));
+    xor2(&xmm14, (int128 *)(inp + 48));
+    xor2(&xmm11, (int128 *)(inp + 64));
+    xor2(&xmm15, (int128 *)(inp + 80));
+    xor2(&xmm10, (int128 *)(inp + 96));
+    xor2(&xmm13, (int128 *)(inp + 112));
+
+    *(int128 *) (outp + 0) = xmm8;
+    *(int128 *) (outp + 16) = xmm9;
+    *(int128 *) (outp + 32) = xmm12;
+    *(int128 *) (outp + 48) = xmm14;
+    *(int128 *) (outp + 64) = xmm11;
+    *(int128 *) (outp + 80) = xmm15;
+    *(int128 *) (outp + 96) = xmm10;
+    *(int128 *) (outp + 112) = xmm13;
+
+    end:
+    return 0;
+
+}

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

@@ -0,0 +1,73 @@
+#include <stdlib.h>
+#include "randombytes.h"
+#include "cpucycles.h"
+#include "crypto_stream.h"
+
+extern void printentry(long long,const char *,long long *,long long);
+extern unsigned char *alignedcalloc(unsigned long long);
+extern const char *primitiveimplementation;
+extern const char *implementationversion;
+extern const char *sizenames[];
+extern const long long sizes[];
+extern void allocate(void);
+extern void measure(void);
+
+const char *primitiveimplementation = crypto_stream_IMPLEMENTATION;
+const char *implementationversion = crypto_stream_VERSION;
+const char *sizenames[] = { "keybytes", "noncebytes", 0 };
+const long long sizes[] = { crypto_stream_KEYBYTES, crypto_stream_NONCEBYTES };
+
+#define MAXTEST_BYTES 4096
+#ifdef SUPERCOP
+#define MGAP 8192
+#else
+#define MGAP 8
+#endif
+
+static unsigned char *k;
+static unsigned char *n;
+static unsigned char *m;
+static unsigned char *c;
+
+void preallocate(void)
+{
+}
+
+void allocate(void)
+{
+  k = alignedcalloc(crypto_stream_KEYBYTES);
+  n = alignedcalloc(crypto_stream_NONCEBYTES);
+  m = alignedcalloc(MAXTEST_BYTES);
+  c = alignedcalloc(MAXTEST_BYTES);
+}
+
+#define TIMINGS 15
+static long long cycles[TIMINGS + 1];
+
+void measure(void)
+{
+  int i;
+  int loop;
+  int mlen;
+
+  for (loop = 0;loop < LOOPS;++loop) {
+    for (mlen = 0;mlen <= MAXTEST_BYTES;mlen += 1 + mlen / MGAP) {
+      randombytes(k,crypto_stream_KEYBYTES);
+      randombytes(n,crypto_stream_NONCEBYTES);
+      randombytes(m,mlen);
+      randombytes(c,mlen);
+      for (i = 0;i <= TIMINGS;++i) {
+        cycles[i] = cpucycles();
+	crypto_stream(c,mlen,n,k);
+      }
+      for (i = 0;i < TIMINGS;++i) cycles[i] = cycles[i + 1] - cycles[i];
+      printentry(mlen,"cycles",cycles,TIMINGS);
+      for (i = 0;i <= TIMINGS;++i) {
+        cycles[i] = cpucycles();
+	crypto_stream_xor(c,m,mlen,n,k);
+      }
+      for (i = 0;i < TIMINGS;++i) cycles[i] = cycles[i + 1] - cycles[i];
+      printentry(mlen,"xor_cycles",cycles,TIMINGS);
+    }
+  }
+}

data/ext/ruby_nacl/NaCl/crypto_stream/salsa20/amd64_xmm6/api.h

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

data/ext/ruby_nacl/NaCl/crypto_stream/salsa20/amd64_xmm6/implementors

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