ruby_nacl 0.1.0

data/ext/ruby_nacl/NaCl/tests/box7.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include "crypto_box.h"
+#include "randombytes.h"
+
+unsigned char alicesk[crypto_box_SECRETKEYBYTES];
+unsigned char alicepk[crypto_box_PUBLICKEYBYTES];
+unsigned char bobsk[crypto_box_SECRETKEYBYTES];
+unsigned char bobpk[crypto_box_PUBLICKEYBYTES];
+unsigned char n[crypto_box_NONCEBYTES];
+unsigned char m[10000];
+unsigned char c[10000];
+unsigned char m2[10000];
+
+main()
+{
+  int mlen;
+  int i;
+
+  for (mlen = 0;mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;++mlen) {
+    crypto_box_keypair(alicepk,alicesk);
+    crypto_box_keypair(bobpk,bobsk);
+    randombytes(n,crypto_box_NONCEBYTES);
+    randombytes(m + crypto_box_ZEROBYTES,mlen);
+    crypto_box(c,m,mlen + crypto_box_ZEROBYTES,n,bobpk,alicesk);
+    if (crypto_box_open(m2,c,mlen + crypto_box_ZEROBYTES,n,alicepk,bobsk) == 0) {
+      for (i = 0;i < mlen + crypto_box_ZEROBYTES;++i)
+        if (m2[i] != m[i]) {
+	  printf("bad decryption\n");
+	  break;
+	}
+    } else {
+      printf("ciphertext fails verification\n");
+    }
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/box8.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include "crypto_box.h"
+#include "randombytes.h"
+
+unsigned char alicesk[crypto_box_SECRETKEYBYTES];
+unsigned char alicepk[crypto_box_PUBLICKEYBYTES];
+unsigned char bobsk[crypto_box_SECRETKEYBYTES];
+unsigned char bobpk[crypto_box_PUBLICKEYBYTES];
+unsigned char n[crypto_box_NONCEBYTES];
+unsigned char m[10000];
+unsigned char c[10000];
+unsigned char m2[10000];
+
+main()
+{
+  int mlen;
+  int i;
+  int caught;
+
+  for (mlen = 0;mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;++mlen) {
+    crypto_box_keypair(alicepk,alicesk);
+    crypto_box_keypair(bobpk,bobsk);
+    randombytes(n,crypto_box_NONCEBYTES);
+    randombytes(m + crypto_box_ZEROBYTES,mlen);
+    crypto_box(c,m,mlen + crypto_box_ZEROBYTES,n,bobpk,alicesk);
+    caught = 0;
+    while (caught < 10) {
+      c[random() % (mlen + crypto_box_ZEROBYTES)] = random();
+      if (crypto_box_open(m2,c,mlen + crypto_box_ZEROBYTES,n,alicepk,bobsk) == 0) {
+        for (i = 0;i < mlen + crypto_box_ZEROBYTES;++i)
+          if (m2[i] != m[i]) {
+	    printf("forgery\n");
+	    return 100;
+	  }
+      } else {
+        ++caught;
+      }
+    }
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/core1.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include "crypto_core_hsalsa20.h"
+
+unsigned char shared[32] = {
+ 0x4a,0x5d,0x9d,0x5b,0xa4,0xce,0x2d,0xe1
+,0x72,0x8e,0x3b,0xf4,0x80,0x35,0x0f,0x25
+,0xe0,0x7e,0x21,0xc9,0x47,0xd1,0x9e,0x33
+,0x76,0xf0,0x9b,0x3c,0x1e,0x16,0x17,0x42
+} ;
+
+unsigned char zero[32] = { 0 };
+
+unsigned char c[16] = {
+ 0x65,0x78,0x70,0x61,0x6e,0x64,0x20,0x33
+,0x32,0x2d,0x62,0x79,0x74,0x65,0x20,0x6b
+} ;
+
+unsigned char firstkey[32];
+
+main()
+{
+  int i;
+  crypto_core_hsalsa20(firstkey,zero,shared,c);
+  for (i = 0;i < 32;++i) {
+    if (i > 0) printf(","); else printf(" ");
+    printf("0x%02x",(unsigned int) firstkey[i]);
+    if (i % 8 == 7) printf("\n");
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/core1.out

@@ -0,0 +1,4 @@
+ 0x1b,0x27,0x55,0x64,0x73,0xe9,0x85,0xd4
+,0x62,0xcd,0x51,0x19,0x7a,0x9a,0x46,0xc7
+,0x60,0x09,0x54,0x9e,0xac,0x64,0x74,0xf2
+,0x06,0xc4,0xee,0x08,0x44,0xf6,0x83,0x89

data/ext/ruby_nacl/NaCl/tests/core2.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include "crypto_core_hsalsa20.h"
+
+unsigned char firstkey[32] = {
+ 0x1b,0x27,0x55,0x64,0x73,0xe9,0x85,0xd4
+,0x62,0xcd,0x51,0x19,0x7a,0x9a,0x46,0xc7
+,0x60,0x09,0x54,0x9e,0xac,0x64,0x74,0xf2
+,0x06,0xc4,0xee,0x08,0x44,0xf6,0x83,0x89
+} ;
+
+unsigned char nonceprefix[16] = {
+ 0x69,0x69,0x6e,0xe9,0x55,0xb6,0x2b,0x73
+,0xcd,0x62,0xbd,0xa8,0x75,0xfc,0x73,0xd6
+} ;
+
+unsigned char c[16] = {
+ 0x65,0x78,0x70,0x61,0x6e,0x64,0x20,0x33
+,0x32,0x2d,0x62,0x79,0x74,0x65,0x20,0x6b
+} ;
+
+unsigned char secondkey[32];
+
+main()
+{
+  int i;
+  crypto_core_hsalsa20(secondkey,nonceprefix,firstkey,c);
+  for (i = 0;i < 32;++i) {
+    if (i > 0) printf(","); else printf(" ");
+    printf("0x%02x",(unsigned int) secondkey[i]);
+    if (i % 8 == 7) printf("\n");
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/core2.out

@@ -0,0 +1,4 @@
+ 0xdc,0x90,0x8d,0xda,0x0b,0x93,0x44,0xa9
+,0x53,0x62,0x9b,0x73,0x38,0x20,0x77,0x88
+,0x80,0xf3,0xce,0xb4,0x21,0xbb,0x61,0xb9
+,0x1c,0xbd,0x4c,0x3e,0x66,0x25,0x6c,0xe4

data/ext/ruby_nacl/NaCl/tests/core3.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include "crypto_core_salsa20.h"
+#include "crypto_hash_sha256.h"
+
+unsigned char secondkey[32] = {
+ 0xdc,0x90,0x8d,0xda,0x0b,0x93,0x44,0xa9
+,0x53,0x62,0x9b,0x73,0x38,0x20,0x77,0x88
+,0x80,0xf3,0xce,0xb4,0x21,0xbb,0x61,0xb9
+,0x1c,0xbd,0x4c,0x3e,0x66,0x25,0x6c,0xe4
+} ;
+
+unsigned char noncesuffix[8] = {
+ 0x82,0x19,0xe0,0x03,0x6b,0x7a,0x0b,0x37
+} ;
+
+unsigned char c[16] = {
+ 0x65,0x78,0x70,0x61,0x6e,0x64,0x20,0x33
+,0x32,0x2d,0x62,0x79,0x74,0x65,0x20,0x6b
+} ;
+
+unsigned char in[16] = { 0 } ;
+
+unsigned char output[64 * 256 * 256];
+
+unsigned char h[32];
+
+main()
+{
+  int i;
+  long long pos = 0;
+  for (i = 0;i < 8;++i) in[i] = noncesuffix[i];
+  do {
+    do {
+      crypto_core_salsa20(output + pos,in,secondkey,c);
+      pos += 64;
+    } while (++in[8]);
+  } while (++in[9]);
+  crypto_hash_sha256(h,output,sizeof output);
+  for (i = 0;i < 32;++i) printf("%02x",h[i]); printf("\n");
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/core3.out

@@ -0,0 +1 @@
+662b9d0e3463029156069b12f918691a98f7dfb2ca0393c96bbfc6b1fbd630a2

data/ext/ruby_nacl/NaCl/tests/core4.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include "crypto_core_salsa20.h"
+
+unsigned char k[32] = {
+   1,  2,  3,  4,  5,  6,  7,  8
+,  9, 10, 11, 12, 13, 14, 15, 16
+,201,202,203,204,205,206,207,208
+,209,210,211,212,213,214,215,216
+} ;
+
+unsigned char in[16] = {
+ 101,102,103,104,105,106,107,108
+,109,110,111,112,113,114,115,116
+} ;
+
+unsigned char c[16] = {
+ 101,120,112, 97,110,100, 32, 51
+, 50, 45, 98,121,116,101, 32,107
+} ;
+
+unsigned char out[64];
+
+main()
+{
+  int i;
+  crypto_core_salsa20(out,in,k,c);
+  for (i = 0;i < 64;++i) {
+    if (i > 0) printf(","); else printf(" ");
+    printf("%3d",(unsigned int) out[i]);
+    if (i % 8 == 7) printf("\n");
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/core4.out

@@ -0,0 +1,8 @@
+  69, 37, 68, 39, 41, 15,107,193
+,255,139,122,  6,170,233,217, 98
+, 89,144,182,106, 21, 51,200, 65
+,239, 49,222, 34,215,114, 40,126
+,104,197,  7,225,197,153, 31,  2
+,102, 78, 76,176, 84,245,246,184
+,177,160,133,130,  6, 72,149,119
+,192,195,132,236,234,103,246, 74

data/ext/ruby_nacl/NaCl/tests/core5.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include "crypto_core_hsalsa20.h"
+
+unsigned char k[32] = {
+ 0xee,0x30,0x4f,0xca,0x27,0x00,0x8d,0x8c
+,0x12,0x6f,0x90,0x02,0x79,0x01,0xd8,0x0f
+,0x7f,0x1d,0x8b,0x8d,0xc9,0x36,0xcf,0x3b
+,0x9f,0x81,0x96,0x92,0x82,0x7e,0x57,0x77
+} ;
+
+unsigned char in[16] = {
+ 0x81,0x91,0x8e,0xf2,0xa5,0xe0,0xda,0x9b
+,0x3e,0x90,0x60,0x52,0x1e,0x4b,0xb3,0x52
+} ;
+
+unsigned char c[16] = {
+ 101,120,112, 97,110,100, 32, 51
+, 50, 45, 98,121,116,101, 32,107
+} ;
+
+unsigned char out[32];
+
+main()
+{
+  int i;
+  crypto_core_hsalsa20(out,in,k,c);
+  for (i = 0;i < 32;++i) {
+    printf(",0x%02x",(unsigned int) out[i]);
+    if (i % 8 == 7) printf("\n");
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/core5.out

@@ -0,0 +1,4 @@
+,0xbc,0x1b,0x30,0xfc,0x07,0x2c,0xc1,0x40
+,0x75,0xe4,0xba,0xa7,0x31,0xb5,0xa8,0x45
+,0xea,0x9b,0x11,0xe9,0xa5,0x19,0x1f,0x94
+,0xe1,0x8c,0xba,0x8f,0xd8,0x21,0xa7,0xcd

data/ext/ruby_nacl/NaCl/tests/core6.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include "crypto_core_salsa20.h"
+
+unsigned char k[32] = {
+ 0xee,0x30,0x4f,0xca,0x27,0x00,0x8d,0x8c
+,0x12,0x6f,0x90,0x02,0x79,0x01,0xd8,0x0f
+,0x7f,0x1d,0x8b,0x8d,0xc9,0x36,0xcf,0x3b
+,0x9f,0x81,0x96,0x92,0x82,0x7e,0x57,0x77
+} ;
+
+unsigned char in[16] = {
+ 0x81,0x91,0x8e,0xf2,0xa5,0xe0,0xda,0x9b
+,0x3e,0x90,0x60,0x52,0x1e,0x4b,0xb3,0x52
+} ;
+
+unsigned char c[16] = {
+ 101,120,112, 97,110,100, 32, 51
+, 50, 45, 98,121,116,101, 32,107
+} ;
+
+unsigned char out[64];
+
+void print(unsigned char *x,unsigned char *y)
+{
+  int i;
+  unsigned int borrow = 0;
+  for (i = 0;i < 4;++i) {
+    unsigned int xi = x[i];
+    unsigned int yi = y[i];
+    printf(",0x%02x",255 & (xi - yi - borrow));
+    borrow = (xi < yi + borrow);
+  }
+}
+
+main()
+{
+  crypto_core_salsa20(out,in,k,c);
+  print(out,c);
+  print(out + 20,c + 4); printf("\n");
+  print(out + 40,c + 8);
+  print(out + 60,c + 12); printf("\n");
+  print(out + 24,in);
+  print(out + 28,in + 4); printf("\n");
+  print(out + 32,in + 8);
+  print(out + 36,in + 12); printf("\n");
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/core6.out

@@ -0,0 +1,4 @@
+,0xbc,0x1b,0x30,0xfc,0x07,0x2c,0xc1,0x40
+,0x75,0xe4,0xba,0xa7,0x31,0xb5,0xa8,0x45
+,0xea,0x9b,0x11,0xe9,0xa5,0x19,0x1f,0x94
+,0xe1,0x8c,0xba,0x8f,0xd8,0x21,0xa7,0xcd

data/ext/ruby_nacl/NaCl/tests/hash.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include "crypto_hash.h"
+
+unsigned char x[8] = "testing\n";
+unsigned char h[crypto_hash_BYTES];
+
+int main()
+{
+  int i;
+  crypto_hash(h,x,sizeof x);
+  for (i = 0;i < crypto_hash_BYTES;++i) printf("%02x",(unsigned int) h[i]);
+  printf("\n");
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/hash.out

@@ -0,0 +1 @@
+24f950aac7b9ea9b3cb728228a0c82b67c39e96b4b344798870d5daee93e3ae5931baae8c7cacfea4b629452c38026a81d138bc7aad1af3ef7bfd5ec646d6c28

data/ext/ruby_nacl/NaCl/tests/hash2.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+#include <string>
+using std::string;
+using std::cout;
+using std::hex;
+#include "crypto_hash.h"
+
+int main()
+{
+  string x = "testing\n";
+  string h = crypto_hash(x);
+  for (int i = 0;i < h.size();++i) {
+    cout << hex << (15 & (int) (h[i] >> 4));
+    cout << hex << (15 & (int) h[i]);
+  }
+  cout << "\n";
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/hash2.out

@@ -0,0 +1 @@
+24f950aac7b9ea9b3cb728228a0c82b67c39e96b4b344798870d5daee93e3ae5931baae8c7cacfea4b629452c38026a81d138bc7aad1af3ef7bfd5ec646d6c28

data/ext/ruby_nacl/NaCl/tests/hash3.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include "crypto_hash_sha512.h"
+
+unsigned char x[8] = "testing\n";
+unsigned char h[crypto_hash_sha512_BYTES];
+
+int main()
+{
+  int i;
+  crypto_hash_sha512(h,x,sizeof x);
+  for (i = 0;i < crypto_hash_sha512_BYTES;++i) printf("%02x",(unsigned int) h[i]);
+  printf("\n");
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/hash3.out

@@ -0,0 +1 @@
+24f950aac7b9ea9b3cb728228a0c82b67c39e96b4b344798870d5daee93e3ae5931baae8c7cacfea4b629452c38026a81d138bc7aad1af3ef7bfd5ec646d6c28

data/ext/ruby_nacl/NaCl/tests/hash4.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+#include <string>
+using std::string;
+using std::cout;
+using std::hex;
+#include "crypto_hash_sha512.h"
+
+int main()
+{
+  string x = "testing\n";
+  string h = crypto_hash_sha512(x);
+  for (int i = 0;i < h.size();++i) {
+    cout << hex << (15 & (int) (h[i] >> 4));
+    cout << hex << (15 & (int) h[i]);
+  }
+  cout << "\n";
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/hash4.out

@@ -0,0 +1 @@
+24f950aac7b9ea9b3cb728228a0c82b67c39e96b4b344798870d5daee93e3ae5931baae8c7cacfea4b629452c38026a81d138bc7aad1af3ef7bfd5ec646d6c28

data/ext/ruby_nacl/NaCl/tests/onetimeauth.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include "crypto_onetimeauth_poly1305.h"
+
+unsigned char rs[32] = {
+ 0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91
+,0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25
+,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65
+,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80
+} ;
+
+unsigned char c[131] = {
+ 0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
+,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
+,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
+,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
+,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
+,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
+,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
+,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
+,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
+,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
+,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
+,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
+,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
+,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
+,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
+,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
+,0xe3,0x55,0xa5
+} ;
+
+unsigned char a[16];
+
+main()
+{
+  int i;
+  crypto_onetimeauth_poly1305(a,c,131,rs);
+  for (i = 0;i < 16;++i) {
+    printf(",0x%02x",(unsigned int) a[i]);
+    if (i % 8 == 7) printf("\n");
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/onetimeauth.out

@@ -0,0 +1,2 @@
+,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
+,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9

data/ext/ruby_nacl/NaCl/tests/onetimeauth2.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include "crypto_onetimeauth_poly1305.h"
+
+unsigned char rs[32] = {
+ 0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91
+,0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25
+,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65
+,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80
+} ;
+
+unsigned char c[131] = {
+ 0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
+,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
+,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
+,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
+,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
+,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
+,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
+,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
+,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
+,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
+,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
+,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
+,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
+,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
+,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
+,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
+,0xe3,0x55,0xa5
+} ;
+
+unsigned char a[16] = {
+ 0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
+,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9
+} ;
+
+main()
+{
+  printf("%d\n",crypto_onetimeauth_poly1305_verify(a,c,131,rs));
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/onetimeauth2.out

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

data/ext/ruby_nacl/NaCl/tests/onetimeauth5.cpp

@@ -0,0 +1,46 @@
+#include <string>
+using std::string;
+#include <stdio.h>
+#include "crypto_onetimeauth_poly1305.h"
+
+char rs_bytes[32] = {
+ 0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91
+,0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25
+,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65
+,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80
+} ;
+
+char c_bytes[131] = {
+ 0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
+,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
+,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
+,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
+,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
+,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
+,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
+,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
+,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
+,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
+,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
+,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
+,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
+,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
+,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
+,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
+,0xe3,0x55,0xa5
+} ;
+
+unsigned char a[16];
+
+main()
+{
+  int i;
+  string c(c_bytes,sizeof c_bytes);
+  string rs(rs_bytes,sizeof rs_bytes);
+  string a = crypto_onetimeauth_poly1305(c,rs);
+  for (i = 0;i < a.size();++i) {
+    printf(",0x%02x",(unsigned int) (unsigned char) a[i]);
+    if (i % 8 == 7) printf("\n");
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/onetimeauth5.out

@@ -0,0 +1,2 @@
+,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
+,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9

data/ext/ruby_nacl/NaCl/tests/onetimeauth6.cpp

@@ -0,0 +1,50 @@
+#include <string>
+using std::string;
+#include <stdio.h>
+#include "crypto_onetimeauth_poly1305.h"
+
+char rs_bytes[32] = {
+ 0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91
+,0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25
+,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65
+,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80
+} ;
+
+char c_bytes[131] = {
+ 0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
+,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
+,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
+,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
+,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
+,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
+,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
+,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
+,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
+,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
+,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
+,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
+,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
+,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
+,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
+,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
+,0xe3,0x55,0xa5
+} ;
+
+char a_bytes[16] = {
+ 0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
+,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9
+} ;
+
+main()
+{
+  string rs(rs_bytes,sizeof rs_bytes);
+  string c(c_bytes,sizeof c_bytes);
+  string a(a_bytes,sizeof a_bytes);
+  try {
+    crypto_onetimeauth_poly1305_verify(a,c,rs);
+    printf("0\n");
+  } catch(const char *s) {
+    printf("%s\n",s);
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/tests/onetimeauth6.out

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

data/ext/ruby_nacl/NaCl/tests/onetimeauth7.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "crypto_onetimeauth_poly1305.h"
+#include "randombytes.h"
+
+unsigned char key[32];
+unsigned char c[10000];
+unsigned char a[16];
+
+main()
+{
+  int clen;
+  int i;
+  for (clen = 0;clen < 10000;++clen) {
+    randombytes(key,sizeof key);
+    randombytes(c,clen);
+    crypto_onetimeauth_poly1305(a,c,clen,key);
+    if (crypto_onetimeauth_poly1305_verify(a,c,clen,key) != 0) {
+      printf("fail %d\n",clen);
+      return 100;
+    }
+    if (clen > 0) {
+      c[random() % clen] += 1 + (random() % 255);
+      if (crypto_onetimeauth_poly1305_verify(a,c,clen,key) == 0) {
+        printf("forgery %d\n",clen);
+        return 100;
+      }
+      a[random() % sizeof a] += 1 + (random() % 255);
+      if (crypto_onetimeauth_poly1305_verify(a,c,clen,key) == 0) {
+        printf("forgery %d\n",clen);
+        return 100;
+      }
+    }
+  }
+  return 0;
+}