ruby_nacl 0.1.0

data/ext/ruby_nacl/NaCl/crypto_onetimeauth/poly1305/x86/constants.s

@@ -0,0 +1,85 @@
+# version 20080912
+# D. J. Bernstein
+# Public domain.
+
+.data
+.section .rodata
+.p2align 5
+
+.globl _crypto_onetimeauth_poly1305_x86_constants
+.globl crypto_onetimeauth_poly1305_x86_constants
+.globl crypto_onetimeauth_poly1305_x86_scale
+.globl crypto_onetimeauth_poly1305_x86_two32
+.globl crypto_onetimeauth_poly1305_x86_two64
+.globl crypto_onetimeauth_poly1305_x86_two96
+.globl crypto_onetimeauth_poly1305_x86_alpha32
+.globl crypto_onetimeauth_poly1305_x86_alpha64
+.globl crypto_onetimeauth_poly1305_x86_alpha96
+.globl crypto_onetimeauth_poly1305_x86_alpha130
+.globl crypto_onetimeauth_poly1305_x86_doffset0
+.globl crypto_onetimeauth_poly1305_x86_doffset1
+.globl crypto_onetimeauth_poly1305_x86_doffset2
+.globl crypto_onetimeauth_poly1305_x86_doffset3
+.globl crypto_onetimeauth_poly1305_x86_doffset3minustwo128
+.globl crypto_onetimeauth_poly1305_x86_hoffset0
+.globl crypto_onetimeauth_poly1305_x86_hoffset1
+.globl crypto_onetimeauth_poly1305_x86_hoffset2
+.globl crypto_onetimeauth_poly1305_x86_hoffset3
+.globl crypto_onetimeauth_poly1305_x86_rounding
+
+_crypto_onetimeauth_poly1305_x86_constants:
+crypto_onetimeauth_poly1305_x86_constants:
+crypto_onetimeauth_poly1305_x86_scale:
+.long 0x0,0x37f40000
+
+crypto_onetimeauth_poly1305_x86_two32:
+.long 0x0,0x41f00000
+
+crypto_onetimeauth_poly1305_x86_two64:
+.long 0x0,0x43f00000
+
+crypto_onetimeauth_poly1305_x86_two96:
+.long 0x0,0x45f00000
+
+crypto_onetimeauth_poly1305_x86_alpha32:
+.long 0x0,0x45e80000
+
+crypto_onetimeauth_poly1305_x86_alpha64:
+.long 0x0,0x47e80000
+
+crypto_onetimeauth_poly1305_x86_alpha96:
+.long 0x0,0x49e80000
+
+crypto_onetimeauth_poly1305_x86_alpha130:
+.long 0x0,0x4c080000
+
+crypto_onetimeauth_poly1305_x86_doffset0:
+.long 0x0,0x43300000
+
+crypto_onetimeauth_poly1305_x86_doffset1:
+.long 0x0,0x45300000
+
+crypto_onetimeauth_poly1305_x86_doffset2:
+.long 0x0,0x47300000
+
+crypto_onetimeauth_poly1305_x86_doffset3:
+.long 0x0,0x49300000
+
+crypto_onetimeauth_poly1305_x86_doffset3minustwo128:
+.long 0x0,0x492ffffe
+
+crypto_onetimeauth_poly1305_x86_hoffset0:
+.long 0xfffffffb,0x43300001
+
+crypto_onetimeauth_poly1305_x86_hoffset1:
+.long 0xfffffffe,0x45300001
+
+crypto_onetimeauth_poly1305_x86_hoffset2:
+.long 0xfffffffe,0x47300001
+
+crypto_onetimeauth_poly1305_x86_hoffset3:
+.long 0xfffffffe,0x49300003
+
+crypto_onetimeauth_poly1305_x86_rounding:
+.byte 0x7f
+.byte 0x13

data/ext/ruby_nacl/NaCl/crypto_onetimeauth/poly1305/x86/verify.c

@@ -0,0 +1,9 @@
+#include "crypto_verify_16.h"
+#include "crypto_onetimeauth.h"
+
+int crypto_onetimeauth_verify(const unsigned char *h,const unsigned char *in,unsigned long long inlen,const unsigned char *k)
+{
+  unsigned char correct[16];
+  crypto_onetimeauth(correct,in,inlen,k);
+  return crypto_verify_16(h,correct);
+}

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

@@ -0,0 +1,119 @@
+/*
+ * crypto_onetimeauth/try.c version 20090118
+ * D. J. Bernstein
+ * Public domain.
+ */
+
+#include "crypto_hash_sha256.h"
+#include "crypto_onetimeauth.h"
+
+extern unsigned char *alignedcalloc(unsigned long long);
+
+const char *primitiveimplementation = crypto_onetimeauth_IMPLEMENTATION;
+
+#define MAXTEST_BYTES 10000
+#define CHECKSUM_BYTES 4096
+#define TUNE_BYTES 1536
+
+static unsigned char *h;
+static unsigned char *m;
+static unsigned char *k;
+static unsigned char *h2;
+static unsigned char *m2;
+static unsigned char *k2;
+
+void preallocate(void)
+{
+}
+
+void allocate(void)
+{
+  h = alignedcalloc(crypto_onetimeauth_BYTES);
+  m = alignedcalloc(MAXTEST_BYTES);
+  k = alignedcalloc(crypto_onetimeauth_KEYBYTES);
+  h2 = alignedcalloc(crypto_onetimeauth_BYTES);
+  m2 = alignedcalloc(MAXTEST_BYTES + crypto_onetimeauth_BYTES);
+  k2 = alignedcalloc(crypto_onetimeauth_KEYBYTES + crypto_onetimeauth_BYTES);
+}
+
+void predoit(void)
+{
+}
+
+void doit(void)
+{
+  crypto_onetimeauth(h,m,TUNE_BYTES,k);
+  crypto_onetimeauth_verify(h,m,TUNE_BYTES,k);
+}
+
+char checksum[crypto_onetimeauth_BYTES * 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 klen = crypto_onetimeauth_KEYBYTES;
+    long long hlen = crypto_onetimeauth_BYTES;
+
+    for (j = -16;j < 0;++j) h[j] = random();
+    for (j = -16;j < 0;++j) k[j] = random();
+    for (j = -16;j < 0;++j) m[j] = random();
+    for (j = hlen;j < hlen + 16;++j) h[j] = random();
+    for (j = klen;j < klen + 16;++j) k[j] = random();
+    for (j = mlen;j < mlen + 16;++j) m[j] = random();
+    for (j = -16;j < hlen + 16;++j) h2[j] = h[j];
+    for (j = -16;j < klen + 16;++j) k2[j] = k[j];
+    for (j = -16;j < mlen + 16;++j) m2[j] = m[j];
+
+    if (crypto_onetimeauth(h,m,mlen,k) != 0) return "crypto_onetimeauth returns nonzero";
+
+    for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_onetimeauth overwrites k";
+    for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_onetimeauth overwrites m";
+    for (j = -16;j < 0;++j) if (h[j] != h2[j]) return "crypto_onetimeauth writes before output";
+    for (j = hlen;j < hlen + 16;++j) if (h[j] != h2[j]) return "crypto_onetimeauth writes after output";
+
+    for (j = -16;j < 0;++j) h[j] = random();
+    for (j = -16;j < 0;++j) k[j] = random();
+    for (j = -16;j < 0;++j) m[j] = random();
+    for (j = hlen;j < hlen + 16;++j) h[j] = random();
+    for (j = klen;j < klen + 16;++j) k[j] = random();
+    for (j = mlen;j < mlen + 16;++j) m[j] = random();
+    for (j = -16;j < hlen + 16;++j) h2[j] = h[j];
+    for (j = -16;j < klen + 16;++j) k2[j] = k[j];
+    for (j = -16;j < mlen + 16;++j) m2[j] = m[j];
+
+    if (crypto_onetimeauth(m2,m2,mlen,k) != 0) return "crypto_onetimeauth returns nonzero";
+    for (j = 0;j < hlen;++j) if (m2[j] != h[j]) return "crypto_onetimeauth does not handle m overlap";
+    for (j = 0;j < hlen;++j) m2[j] = m[j];
+    if (crypto_onetimeauth(k2,m2,mlen,k2) != 0) return "crypto_onetimeauth returns nonzero";
+    for (j = 0;j < hlen;++j) if (k2[j] != h[j]) return "crypto_onetimeauth does not handle k overlap";
+    for (j = 0;j < hlen;++j) k2[j] = k[j];
+
+    if (crypto_onetimeauth_verify(h,m,mlen,k) != 0) return "crypto_onetimeauth_verify returns nonzero";
+
+    for (j = -16;j < hlen + 16;++j) if (h[j] != h2[j]) return "crypto_onetimeauth overwrites h";
+    for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_onetimeauth overwrites k";
+    for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_onetimeauth overwrites m";
+
+    crypto_hash_sha256(h2,h,hlen);
+    for (j = 0;j < klen;++j) k[j] ^= h2[j % 32];
+    if (crypto_onetimeauth(h,m,mlen,k) != 0) return "crypto_onetimeauth returns nonzero";
+    if (crypto_onetimeauth_verify(h,m,mlen,k) != 0) return "crypto_onetimeauth_verify returns nonzero";
+    
+    crypto_hash_sha256(h2,h,hlen);
+    for (j = 0;j < mlen;++j) m[j] ^= h2[j % 32];
+    m[mlen] = h2[0];
+  }
+  if (crypto_onetimeauth(h,m,CHECKSUM_BYTES,k) != 0) return "crypto_onetimeauth returns nonzero";
+  if (crypto_onetimeauth_verify(h,m,CHECKSUM_BYTES,k) != 0) return "crypto_onetimeauth_verify returns nonzero";
+
+  for (i = 0;i < crypto_onetimeauth_BYTES;++i) {
+    checksum[2 * i] = "0123456789abcdef"[15 & (h[i] >> 4)];
+    checksum[2 * i + 1] = "0123456789abcdef"[15 & h[i]];
+  }
+  checksum[2 * i] = 0;
+  return 0;
+}

data/ext/ruby_nacl/NaCl/crypto_onetimeauth/wrapper-auth.cpp

@@ -0,0 +1,11 @@
+#include <string>
+using std::string;
+#include "crypto_onetimeauth.h"
+
+string crypto_onetimeauth(const string &m,const string &k)
+{
+  if (k.size() != crypto_onetimeauth_KEYBYTES) throw "incorrect key length";
+  unsigned char a[crypto_onetimeauth_BYTES];
+  crypto_onetimeauth(a,(const unsigned char *) m.c_str(),m.size(),(const unsigned char *) k.c_str());
+  return string((char *) a,crypto_onetimeauth_BYTES);
+}

data/ext/ruby_nacl/NaCl/crypto_onetimeauth/wrapper-verify.cpp

@@ -0,0 +1,14 @@
+#include <string>
+using std::string;
+#include "crypto_onetimeauth.h"
+
+void crypto_onetimeauth_verify(const string &a,const string &m,const string &k)
+{
+  if (k.size() != crypto_onetimeauth_KEYBYTES) throw "incorrect key length";
+  if (a.size() != crypto_onetimeauth_BYTES) throw "incorrect authenticator length";
+  if (crypto_onetimeauth_verify(
+       (const unsigned char *) a.c_str(),
+       (const unsigned char *) m.c_str(),m.size(),
+       (const unsigned char *) k.c_str()) == 0) return;
+  throw "invalid authenticator";
+}

data/ext/ruby_nacl/NaCl/crypto_scalarmult/curve25519/athlon/api.h

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

data/ext/ruby_nacl/NaCl/crypto_scalarmult/curve25519/athlon/base.c

@@ -0,0 +1,8 @@
+#include "crypto_scalarmult.h"
+
+static char basepoint[32] = {9};
+
+int crypto_scalarmult_base(unsigned char *q,const unsigned char *n)
+{
+  return crypto_scalarmult(q,n,basepoint);
+}

data/ext/ruby_nacl/NaCl/crypto_scalarmult/curve25519/athlon/const.s

@@ -0,0 +1,114 @@
+.data
+.section .rodata
+.p2align 5
+
+.globl crypto_scalarmult_curve25519_athlon_scale
+.globl crypto_scalarmult_curve25519_athlon_121665
+.globl crypto_scalarmult_curve25519_athlon_alpha26
+.globl crypto_scalarmult_curve25519_athlon_alpha51
+.globl crypto_scalarmult_curve25519_athlon_alpha77
+.globl crypto_scalarmult_curve25519_athlon_alpha102
+.globl crypto_scalarmult_curve25519_athlon_alpha128
+.globl crypto_scalarmult_curve25519_athlon_alpha153
+.globl crypto_scalarmult_curve25519_athlon_alpha179
+.globl crypto_scalarmult_curve25519_athlon_alpha204
+.globl crypto_scalarmult_curve25519_athlon_alpha230
+.globl crypto_scalarmult_curve25519_athlon_alpha255
+.globl crypto_scalarmult_curve25519_athlon_in0offset
+.globl crypto_scalarmult_curve25519_athlon_in1offset
+.globl crypto_scalarmult_curve25519_athlon_in2offset
+.globl crypto_scalarmult_curve25519_athlon_in3offset
+.globl crypto_scalarmult_curve25519_athlon_in4offset
+.globl crypto_scalarmult_curve25519_athlon_in5offset
+.globl crypto_scalarmult_curve25519_athlon_in6offset
+.globl crypto_scalarmult_curve25519_athlon_in7offset
+.globl crypto_scalarmult_curve25519_athlon_in8offset
+.globl crypto_scalarmult_curve25519_athlon_in9offset
+.globl crypto_scalarmult_curve25519_athlon_out0offset
+.globl crypto_scalarmult_curve25519_athlon_out1offset
+.globl crypto_scalarmult_curve25519_athlon_out2offset
+.globl crypto_scalarmult_curve25519_athlon_out3offset
+.globl crypto_scalarmult_curve25519_athlon_out4offset
+.globl crypto_scalarmult_curve25519_athlon_out5offset
+.globl crypto_scalarmult_curve25519_athlon_out6offset
+.globl crypto_scalarmult_curve25519_athlon_out7offset
+.globl crypto_scalarmult_curve25519_athlon_out8offset
+.globl crypto_scalarmult_curve25519_athlon_out9offset
+.globl crypto_scalarmult_curve25519_athlon_two0
+.globl crypto_scalarmult_curve25519_athlon_two1
+.globl crypto_scalarmult_curve25519_athlon_zero
+.globl crypto_scalarmult_curve25519_athlon_rounding
+
+crypto_scalarmult_curve25519_athlon_scale:
+	.long 0x0,0x30430000
+crypto_scalarmult_curve25519_athlon_121665:
+	.long 0x0,0x40fdb410
+crypto_scalarmult_curve25519_athlon_in0offset:
+	.long 0x0,0x43300000
+crypto_scalarmult_curve25519_athlon_in1offset:
+	.long 0x0,0x45300000
+crypto_scalarmult_curve25519_athlon_in2offset:
+	.long 0x0,0x46b00000
+crypto_scalarmult_curve25519_athlon_in3offset:
+	.long 0x0,0x48300000
+crypto_scalarmult_curve25519_athlon_in4offset:
+	.long 0x0,0x49b00000
+crypto_scalarmult_curve25519_athlon_in5offset:
+	.long 0x0,0x4b300000
+crypto_scalarmult_curve25519_athlon_in6offset:
+	.long 0x0,0x4d300000
+crypto_scalarmult_curve25519_athlon_in7offset:
+	.long 0x0,0x4eb00000
+crypto_scalarmult_curve25519_athlon_in8offset:
+	.long 0x0,0x50300000
+crypto_scalarmult_curve25519_athlon_in9offset:
+	.long 0x0,0x51b00000
+crypto_scalarmult_curve25519_athlon_alpha26:
+	.long 0x0,0x45880000
+crypto_scalarmult_curve25519_athlon_alpha51:
+	.long 0x0,0x47180000
+crypto_scalarmult_curve25519_athlon_alpha77:
+	.long 0x0,0x48b80000
+crypto_scalarmult_curve25519_athlon_alpha102:
+	.long 0x0,0x4a480000
+crypto_scalarmult_curve25519_athlon_alpha128:
+	.long 0x0,0x4be80000
+crypto_scalarmult_curve25519_athlon_alpha153:
+	.long 0x0,0x4d780000
+crypto_scalarmult_curve25519_athlon_alpha179:
+	.long 0x0,0x4f180000
+crypto_scalarmult_curve25519_athlon_alpha204:
+	.long 0x0,0x50a80000
+crypto_scalarmult_curve25519_athlon_alpha230:
+	.long 0x0,0x52480000
+crypto_scalarmult_curve25519_athlon_alpha255:
+	.long 0x0,0x53d80000
+crypto_scalarmult_curve25519_athlon_two0:
+	.long 0x0,0x3ff00000
+crypto_scalarmult_curve25519_athlon_two1:
+	.long 0x0,0x40000000
+crypto_scalarmult_curve25519_athlon_zero:
+	.long 0x0,0x0
+crypto_scalarmult_curve25519_athlon_out0offset:
+	.long 0x1fffffed,0x43380000
+crypto_scalarmult_curve25519_athlon_out1offset:
+	.long 0xffffff8,0x44d80000
+crypto_scalarmult_curve25519_athlon_out2offset:
+	.long 0x1ffffff8,0x46680000
+crypto_scalarmult_curve25519_athlon_out3offset:
+	.long 0xffffff8,0x48080000
+crypto_scalarmult_curve25519_athlon_out4offset:
+	.long 0x1ffffff8,0x49980000
+crypto_scalarmult_curve25519_athlon_out5offset:
+	.long 0xffffff8,0x4b380000
+crypto_scalarmult_curve25519_athlon_out6offset:
+	.long 0x1ffffff8,0x4cc80000
+crypto_scalarmult_curve25519_athlon_out7offset:
+	.long 0xffffff8,0x4e680000
+crypto_scalarmult_curve25519_athlon_out8offset:
+	.long 0x1ffffff8,0x4ff80000
+crypto_scalarmult_curve25519_athlon_out9offset:
+	.long 0x1fffff8,0x51980000
+crypto_scalarmult_curve25519_athlon_rounding:
+	.byte 0x7f
+	.byte 0x13

data/ext/ruby_nacl/NaCl/crypto_scalarmult/curve25519/athlon/fromdouble.s

@@ -0,0 +1,195 @@
+.text
+.p2align 5
+.globl _crypto_scalarmult_curve25519_athlon_fromdouble
+.globl crypto_scalarmult_curve25519_athlon_fromdouble
+_crypto_scalarmult_curve25519_athlon_fromdouble:
+crypto_scalarmult_curve25519_athlon_fromdouble:
+mov %esp,%eax
+and $31,%eax
+add $192,%eax
+sub %eax,%esp
+movl %ebp,0(%esp)
+movl 8(%esp,%eax),%ecx
+fldl 0(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out0offset
+fstpl 96(%esp)
+fldl 8(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out1offset
+fstpl 104(%esp)
+fldl 16(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out2offset
+fstpl 112(%esp)
+fldl 24(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out3offset
+fstpl 120(%esp)
+fldl 32(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out4offset
+fstpl 128(%esp)
+fldl 40(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out5offset
+fstpl 136(%esp)
+fldl 48(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out6offset
+fstpl 144(%esp)
+fldl 56(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out7offset
+fstpl 152(%esp)
+fldl 64(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out8offset
+fstpl 160(%esp)
+fldl 72(%ecx)
+faddl crypto_scalarmult_curve25519_athlon_out9offset
+fstpl 168(%esp)
+movl 96(%esp),%ecx
+movl %ecx,4(%esp)
+movl 104(%esp),%ecx
+shl  $26,%ecx
+movl %ecx,40(%esp)
+movl 104(%esp),%ecx
+shr  $6,%ecx
+movl %ecx,8(%esp)
+movl 112(%esp),%ecx
+shl  $19,%ecx
+movl %ecx,44(%esp)
+movl 112(%esp),%ecx
+shr  $13,%ecx
+movl %ecx,12(%esp)
+movl 120(%esp),%ecx
+shl  $13,%ecx
+movl %ecx,48(%esp)
+movl 120(%esp),%ecx
+shr  $19,%ecx
+movl %ecx,16(%esp)
+movl 128(%esp),%ecx
+shl  $6,%ecx
+movl %ecx,52(%esp)
+movl 128(%esp),%ecx
+shr  $26,%ecx
+movl 136(%esp),%edx
+add  %edx,%ecx
+movl %ecx,20(%esp)
+movl 144(%esp),%ecx
+shl  $25,%ecx
+movl %ecx,56(%esp)
+movl 144(%esp),%ecx
+shr  $7,%ecx
+movl %ecx,24(%esp)
+movl 152(%esp),%ecx
+shl  $19,%ecx
+movl %ecx,60(%esp)
+movl 152(%esp),%ecx
+shr  $13,%ecx
+movl %ecx,28(%esp)
+movl 160(%esp),%ecx
+shl  $12,%ecx
+movl %ecx,64(%esp)
+movl 160(%esp),%ecx
+shr  $20,%ecx
+movl %ecx,32(%esp)
+movl 168(%esp),%ecx
+shl  $6,%ecx
+movl %ecx,68(%esp)
+movl 168(%esp),%ecx
+shr  $26,%ecx
+movl %ecx,36(%esp)
+mov  $0,%ecx
+movl %ecx,72(%esp)
+movl 4(%esp),%ecx
+addl 40(%esp),%ecx
+movl %ecx,4(%esp)
+movl 8(%esp),%ecx
+adcl 44(%esp),%ecx
+movl %ecx,8(%esp)
+movl 12(%esp),%ecx
+adcl 48(%esp),%ecx
+movl %ecx,12(%esp)
+movl 16(%esp),%ecx
+adcl 52(%esp),%ecx
+movl %ecx,16(%esp)
+movl 20(%esp),%ecx
+adcl 56(%esp),%ecx
+movl %ecx,20(%esp)
+movl 24(%esp),%ecx
+adcl 60(%esp),%ecx
+movl %ecx,24(%esp)
+movl 28(%esp),%ecx
+adcl 64(%esp),%ecx
+movl %ecx,28(%esp)
+movl 32(%esp),%ecx
+adcl 68(%esp),%ecx
+movl %ecx,32(%esp)
+movl 36(%esp),%ecx
+adcl 72(%esp),%ecx
+movl %ecx,36(%esp)
+movl 4(%esp),%ecx
+adc  $0x13,%ecx
+movl %ecx,40(%esp)
+movl 8(%esp),%ecx
+adc  $0,%ecx
+movl %ecx,44(%esp)
+movl 12(%esp),%ecx
+adc  $0,%ecx
+movl %ecx,48(%esp)
+movl 16(%esp),%ecx
+adc  $0,%ecx
+movl %ecx,52(%esp)
+movl 20(%esp),%ecx
+adc  $0,%ecx
+movl %ecx,56(%esp)
+movl 24(%esp),%ecx
+adc  $0,%ecx
+movl %ecx,60(%esp)
+movl 28(%esp),%ecx
+adc  $0,%ecx
+movl %ecx,64(%esp)
+movl 32(%esp),%ecx
+adc  $0x80000000,%ecx
+movl %ecx,68(%esp)
+movl 36(%esp),%ebp
+adc  $0xffffffff,%ebp
+and  $0x80000000,%ebp
+sar  $31,%ebp
+movl 4(%esp,%eax),%ecx
+movl 4(%esp),%edx
+xorl 40(%esp),%edx
+and  %ebp,%edx
+xorl 40(%esp),%edx
+movl %edx,0(%ecx)
+movl 8(%esp),%edx
+xorl 44(%esp),%edx
+and  %ebp,%edx
+xorl 44(%esp),%edx
+movl %edx,4(%ecx)
+movl 12(%esp),%edx
+xorl 48(%esp),%edx
+and  %ebp,%edx
+xorl 48(%esp),%edx
+movl %edx,8(%ecx)
+movl 16(%esp),%edx
+xorl 52(%esp),%edx
+and  %ebp,%edx
+xorl 52(%esp),%edx
+movl %edx,12(%ecx)
+movl 20(%esp),%edx
+xorl 56(%esp),%edx
+and  %ebp,%edx
+xorl 56(%esp),%edx
+movl %edx,16(%ecx)
+movl 24(%esp),%edx
+xorl 60(%esp),%edx
+and  %ebp,%edx
+xorl 60(%esp),%edx
+movl %edx,20(%ecx)
+movl 28(%esp),%edx
+xorl 64(%esp),%edx
+and  %ebp,%edx
+xorl 64(%esp),%edx
+movl %edx,24(%ecx)
+movl 32(%esp),%edx
+xorl 68(%esp),%edx
+and  %ebp,%edx
+xorl 68(%esp),%edx
+movl %edx,28(%ecx)
+movl 0(%esp),%ebp
+add %eax,%esp
+ret

data/ext/ruby_nacl/NaCl/crypto_scalarmult/curve25519/athlon/implementors

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

data/ext/ruby_nacl/NaCl/crypto_scalarmult/curve25519/athlon/init.s

@@ -0,0 +1,13 @@
+.text
+.p2align 5
+.globl _crypto_scalarmult_curve25519_athlon_init
+.globl crypto_scalarmult_curve25519_athlon_init
+_crypto_scalarmult_curve25519_athlon_init:
+crypto_scalarmult_curve25519_athlon_init:
+mov %esp,%eax
+and $31,%eax
+add $0,%eax
+sub %eax,%esp
+fldcw crypto_scalarmult_curve25519_athlon_rounding
+add %eax,%esp
+ret