red25519 1.1.0-jruby

data/ext/red25519/sha512-blocks.c

@@ -0,0 +1,239 @@
+//#include "crypto_hashblocks.h"
+
+typedef unsigned long long uint64;
+
+static uint64 load_bigendian(const unsigned char *x)
+{
+  return
+      (uint64) (x[7]) \
+  | (((uint64) (x[6])) << 8) \
+  | (((uint64) (x[5])) << 16) \
+  | (((uint64) (x[4])) << 24) \
+  | (((uint64) (x[3])) << 32) \
+  | (((uint64) (x[2])) << 40) \
+  | (((uint64) (x[1])) << 48) \
+  | (((uint64) (x[0])) << 56)
+  ;
+}
+
+static void store_bigendian(unsigned char *x,uint64 u)
+{
+  x[7] = u; u >>= 8;
+  x[6] = u; u >>= 8;
+  x[5] = u; u >>= 8;
+  x[4] = u; u >>= 8;
+  x[3] = u; u >>= 8;
+  x[2] = u; u >>= 8;
+  x[1] = u; u >>= 8;
+  x[0] = u;
+}
+
+#define SHR(x,c) ((x) >> (c))
+#define ROTR(x,c) (((x) >> (c)) | ((x) << (64 - (c))))
+
+#define Ch(x,y,z) ((x & y) ^ (~x & z))
+#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
+#define Sigma0(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
+#define Sigma1(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
+#define sigma0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x,7))
+#define sigma1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x,6))
+
+#define M(w0,w14,w9,w1) w0 = sigma1(w14) + w9 + sigma0(w1) + w0;
+
+#define EXPAND \
+  M(w0 ,w14,w9 ,w1 ) \
+  M(w1 ,w15,w10,w2 ) \
+  M(w2 ,w0 ,w11,w3 ) \
+  M(w3 ,w1 ,w12,w4 ) \
+  M(w4 ,w2 ,w13,w5 ) \
+  M(w5 ,w3 ,w14,w6 ) \
+  M(w6 ,w4 ,w15,w7 ) \
+  M(w7 ,w5 ,w0 ,w8 ) \
+  M(w8 ,w6 ,w1 ,w9 ) \
+  M(w9 ,w7 ,w2 ,w10) \
+  M(w10,w8 ,w3 ,w11) \
+  M(w11,w9 ,w4 ,w12) \
+  M(w12,w10,w5 ,w13) \
+  M(w13,w11,w6 ,w14) \
+  M(w14,w12,w7 ,w15) \
+  M(w15,w13,w8 ,w0 )
+
+#define F(w,k) \
+  T1 = h + Sigma1(e) + Ch(e,f,g) + k + w; \
+  T2 = Sigma0(a) + Maj(a,b,c); \
+  h = g; \
+  g = f; \
+  f = e; \
+  e = d + T1; \
+  d = c; \
+  c = b; \
+  b = a; \
+  a = T1 + T2;
+
+int crypto_hashblocks(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen)
+{
+  uint64 state[8];
+  uint64 a;
+  uint64 b;
+  uint64 c;
+  uint64 d;
+  uint64 e;
+  uint64 f;
+  uint64 g;
+  uint64 h;
+  uint64 T1;
+  uint64 T2;
+
+  a = load_bigendian(statebytes +  0); state[0] = a;
+  b = load_bigendian(statebytes +  8); state[1] = b;
+  c = load_bigendian(statebytes + 16); state[2] = c;
+  d = load_bigendian(statebytes + 24); state[3] = d;
+  e = load_bigendian(statebytes + 32); state[4] = e;
+  f = load_bigendian(statebytes + 40); state[5] = f;
+  g = load_bigendian(statebytes + 48); state[6] = g;
+  h = load_bigendian(statebytes + 56); state[7] = h;
+
+  while (inlen >= 128) {
+    uint64 w0  = load_bigendian(in +   0);
+    uint64 w1  = load_bigendian(in +   8);
+    uint64 w2  = load_bigendian(in +  16);
+    uint64 w3  = load_bigendian(in +  24);
+    uint64 w4  = load_bigendian(in +  32);
+    uint64 w5  = load_bigendian(in +  40);
+    uint64 w6  = load_bigendian(in +  48);
+    uint64 w7  = load_bigendian(in +  56);
+    uint64 w8  = load_bigendian(in +  64);
+    uint64 w9  = load_bigendian(in +  72);
+    uint64 w10 = load_bigendian(in +  80);
+    uint64 w11 = load_bigendian(in +  88);
+    uint64 w12 = load_bigendian(in +  96);
+    uint64 w13 = load_bigendian(in + 104);
+    uint64 w14 = load_bigendian(in + 112);
+    uint64 w15 = load_bigendian(in + 120);
+
+    F(w0 ,0x428a2f98d728ae22ULL)
+    F(w1 ,0x7137449123ef65cdULL)
+    F(w2 ,0xb5c0fbcfec4d3b2fULL)
+    F(w3 ,0xe9b5dba58189dbbcULL)
+    F(w4 ,0x3956c25bf348b538ULL)
+    F(w5 ,0x59f111f1b605d019ULL)
+    F(w6 ,0x923f82a4af194f9bULL)
+    F(w7 ,0xab1c5ed5da6d8118ULL)
+    F(w8 ,0xd807aa98a3030242ULL)
+    F(w9 ,0x12835b0145706fbeULL)
+    F(w10,0x243185be4ee4b28cULL)
+    F(w11,0x550c7dc3d5ffb4e2ULL)
+    F(w12,0x72be5d74f27b896fULL)
+    F(w13,0x80deb1fe3b1696b1ULL)
+    F(w14,0x9bdc06a725c71235ULL)
+    F(w15,0xc19bf174cf692694ULL)
+
+    EXPAND
+
+    F(w0 ,0xe49b69c19ef14ad2ULL)
+    F(w1 ,0xefbe4786384f25e3ULL)
+    F(w2 ,0x0fc19dc68b8cd5b5ULL)
+    F(w3 ,0x240ca1cc77ac9c65ULL)
+    F(w4 ,0x2de92c6f592b0275ULL)
+    F(w5 ,0x4a7484aa6ea6e483ULL)
+    F(w6 ,0x5cb0a9dcbd41fbd4ULL)
+    F(w7 ,0x76f988da831153b5ULL)
+    F(w8 ,0x983e5152ee66dfabULL)
+    F(w9 ,0xa831c66d2db43210ULL)
+    F(w10,0xb00327c898fb213fULL)
+    F(w11,0xbf597fc7beef0ee4ULL)
+    F(w12,0xc6e00bf33da88fc2ULL)
+    F(w13,0xd5a79147930aa725ULL)
+    F(w14,0x06ca6351e003826fULL)
+    F(w15,0x142929670a0e6e70ULL)
+
+    EXPAND
+
+    F(w0 ,0x27b70a8546d22ffcULL)
+    F(w1 ,0x2e1b21385c26c926ULL)
+    F(w2 ,0x4d2c6dfc5ac42aedULL)
+    F(w3 ,0x53380d139d95b3dfULL)
+    F(w4 ,0x650a73548baf63deULL)
+    F(w5 ,0x766a0abb3c77b2a8ULL)
+    F(w6 ,0x81c2c92e47edaee6ULL)
+    F(w7 ,0x92722c851482353bULL)
+    F(w8 ,0xa2bfe8a14cf10364ULL)
+    F(w9 ,0xa81a664bbc423001ULL)
+    F(w10,0xc24b8b70d0f89791ULL)
+    F(w11,0xc76c51a30654be30ULL)
+    F(w12,0xd192e819d6ef5218ULL)
+    F(w13,0xd69906245565a910ULL)
+    F(w14,0xf40e35855771202aULL)
+    F(w15,0x106aa07032bbd1b8ULL)
+
+    EXPAND
+
+    F(w0 ,0x19a4c116b8d2d0c8ULL)
+    F(w1 ,0x1e376c085141ab53ULL)
+    F(w2 ,0x2748774cdf8eeb99ULL)
+    F(w3 ,0x34b0bcb5e19b48a8ULL)
+    F(w4 ,0x391c0cb3c5c95a63ULL)
+    F(w5 ,0x4ed8aa4ae3418acbULL)
+    F(w6 ,0x5b9cca4f7763e373ULL)
+    F(w7 ,0x682e6ff3d6b2b8a3ULL)
+    F(w8 ,0x748f82ee5defb2fcULL)
+    F(w9 ,0x78a5636f43172f60ULL)
+    F(w10,0x84c87814a1f0ab72ULL)
+    F(w11,0x8cc702081a6439ecULL)
+    F(w12,0x90befffa23631e28ULL)
+    F(w13,0xa4506cebde82bde9ULL)
+    F(w14,0xbef9a3f7b2c67915ULL)
+    F(w15,0xc67178f2e372532bULL)
+
+    EXPAND
+
+    F(w0 ,0xca273eceea26619cULL)
+    F(w1 ,0xd186b8c721c0c207ULL)
+    F(w2 ,0xeada7dd6cde0eb1eULL)
+    F(w3 ,0xf57d4f7fee6ed178ULL)
+    F(w4 ,0x06f067aa72176fbaULL)
+    F(w5 ,0x0a637dc5a2c898a6ULL)
+    F(w6 ,0x113f9804bef90daeULL)
+    F(w7 ,0x1b710b35131c471bULL)
+    F(w8 ,0x28db77f523047d84ULL)
+    F(w9 ,0x32caab7b40c72493ULL)
+    F(w10,0x3c9ebe0a15c9bebcULL)
+    F(w11,0x431d67c49c100d4cULL)
+    F(w12,0x4cc5d4becb3e42b6ULL)
+    F(w13,0x597f299cfc657e2aULL)
+    F(w14,0x5fcb6fab3ad6faecULL)
+    F(w15,0x6c44198c4a475817ULL)
+
+    a += state[0];
+    b += state[1];
+    c += state[2];
+    d += state[3];
+    e += state[4];
+    f += state[5];
+    g += state[6];
+    h += state[7];
+  
+    state[0] = a;
+    state[1] = b;
+    state[2] = c;
+    state[3] = d;
+    state[4] = e;
+    state[5] = f;
+    state[6] = g;
+    state[7] = h;
+
+    in += 128;
+    inlen -= 128;
+  }
+
+  store_bigendian(statebytes +  0,state[0]);
+  store_bigendian(statebytes +  8,state[1]);
+  store_bigendian(statebytes + 16,state[2]);
+  store_bigendian(statebytes + 24,state[3]);
+  store_bigendian(statebytes + 32,state[4]);
+  store_bigendian(statebytes + 40,state[5]);
+  store_bigendian(statebytes + 48,state[6]);
+  store_bigendian(statebytes + 56,state[7]);
+
+  return inlen;
+}

data/ext/red25519/sha512-hash.c

@@ -0,0 +1,72 @@
+/*
+20080913
+D. J. Bernstein
+Public domain.
+*/
+
+#include "sha512.h"
+
+extern int crypto_hashblocks(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen);
+
+#define blocks crypto_hashblocks
+
+static const unsigned char iv[64] = {
+  0x6a,0x09,0xe6,0x67,0xf3,0xbc,0xc9,0x08,
+  0xbb,0x67,0xae,0x85,0x84,0xca,0xa7,0x3b,
+  0x3c,0x6e,0xf3,0x72,0xfe,0x94,0xf8,0x2b,
+  0xa5,0x4f,0xf5,0x3a,0x5f,0x1d,0x36,0xf1,
+  0x51,0x0e,0x52,0x7f,0xad,0xe6,0x82,0xd1,
+  0x9b,0x05,0x68,0x8c,0x2b,0x3e,0x6c,0x1f,
+  0x1f,0x83,0xd9,0xab,0xfb,0x41,0xbd,0x6b,
+  0x5b,0xe0,0xcd,0x19,0x13,0x7e,0x21,0x79
+} ;
+
+typedef unsigned long long uint64;
+
+int crypto_hash_sha512(unsigned char *out,const unsigned char *in,unsigned long long inlen)
+{
+  unsigned char h[64];
+  unsigned char padded[256];
+  int i;
+  unsigned long long bytes = inlen;
+
+  for (i = 0;i < 64;++i) h[i] = iv[i];
+
+  blocks(h,in,inlen);
+  in += inlen;
+  inlen &= 127;
+  in -= inlen;
+
+  for (i = 0;i < inlen;++i) padded[i] = in[i];
+  padded[inlen] = 0x80;
+
+  if (inlen < 112) {
+    for (i = inlen + 1;i < 119;++i) padded[i] = 0;
+    padded[119] = bytes >> 61;
+    padded[120] = bytes >> 53;
+    padded[121] = bytes >> 45;
+    padded[122] = bytes >> 37;
+    padded[123] = bytes >> 29;
+    padded[124] = bytes >> 21;
+    padded[125] = bytes >> 13;
+    padded[126] = bytes >> 5;
+    padded[127] = bytes << 3;
+    blocks(h,padded,128);
+  } else {
+    for (i = inlen + 1;i < 247;++i) padded[i] = 0;
+    padded[247] = bytes >> 61;
+    padded[248] = bytes >> 53;
+    padded[249] = bytes >> 45;
+    padded[250] = bytes >> 37;
+    padded[251] = bytes >> 29;
+    padded[252] = bytes >> 21;
+    padded[253] = bytes >> 13;
+    padded[254] = bytes >> 5;
+    padded[255] = bytes << 3;
+    blocks(h,padded,256);
+  }
+
+  for (i = 0;i < 64;++i) out[i] = h[i];
+
+  return 0;
+}

data/ext/red25519/sha512.h

@@ -0,0 +1,4 @@
+extern int crypto_hashblocks(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen);
+extern int crypto_hash_sha512(unsigned char *out,const unsigned char *in,unsigned long long inlen);
+
+#define crypto_hash_sha512_BYTES 64

data/ext/red25519/verify.c

@@ -0,0 +1,40 @@
+#include "crypto_verify_32.h"
+
+int crypto_verify_32(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/lib/red25519/jruby_engine.rb

@@ -0,0 +1,27 @@
+require 'java'
+
+module Ed25519
+  module Engine
+    module_function
+
+    def create_keypair(seed)
+      raise ArgumentError, "seed must be 32 bytes long" unless seed.length == 32
+
+      verify_key = org.red25519.ed25519.publickey(seed.to_java_bytes)
+      verify_key = String.from_java_bytes(verify_key)
+      [verify_key, seed + verify_key]
+    end
+
+    def sign(signing_key, message)
+      verify_key  = signing_key[32...64].to_java_bytes
+      signing_key = signing_key[0...32].to_java_bytes
+
+      signature = org.red25519.ed25519.signature(message.to_java_bytes, signing_key, verify_key)
+      String.from_java_bytes(signature)
+    end
+
+    def verify(verify_key, signature, message)
+      org.red25519.ed25519.checkvalid(signature.to_java_bytes, message.to_java_bytes, verify_key.to_java_bytes)
+    end
+  end
+end

data/lib/red25519/keys.rb

@@ -0,0 +1,73 @@
+require 'securerandom'
+require 'hkdf'
+
+module Ed25519
+  class SigningKey
+    attr_reader :verify_key
+
+    def self.generate
+      random_bytes = SecureRandom.random_bytes(Ed25519::SECRET_KEY_BYTES)
+      hkdf = HKDF.new(random_bytes)
+      new hkdf.next_bytes(Ed25519::SECRET_KEY_BYTES)
+    end
+
+    def initialize(seed)
+      case seed.length
+      when 32
+        @seed = seed
+      when 64
+        @seed = [seed].pack("H*")
+      else raise ArgumentError, "seed must be 32 or 64 bytes long"
+      end
+
+      verify_key, @signing_key = Ed25519::Engine.create_keypair(@seed)
+      @verify_key = VerifyKey.new(verify_key)
+    end
+
+    def sign(message)
+      Ed25519::Engine.sign(@signing_key, message)
+    end
+
+    def inspect
+      "#<Ed25519::SigningKey:#{to_hex}>"
+    end
+
+    def to_bytes
+      @seed
+    end
+    alias_method :to_s, :to_bytes
+
+    def to_hex
+      to_bytes.unpack("H*").first
+    end
+  end
+
+  class VerifyKey
+    def initialize(string)
+      case string.length
+      when 32
+        @key = string
+      when 64
+        @key = [string].pack("H*")
+      else raise ArgumentError, "seed must be 32 or 64 bytes long"
+      end
+    end
+
+    def verify(signature, message)
+      Ed25519::Engine.verify(@key, signature, message)
+    end
+
+    def inspect
+      "#<Ed25519::VerifyKey:#{to_hex}>"
+    end
+
+    def to_bytes
+      @key
+    end
+    alias_method :to_s, :to_bytes
+
+    def to_hex
+      to_bytes.unpack("H*").first
+    end
+  end
+end

data/lib/red25519/version.rb

@@ -0,0 +1,3 @@
+module Ed25519
+  VERSION = "1.1.0"
+end

data/lib/red25519.rb

@@ -0,0 +1,41 @@
+require 'red25519/version'
+require 'red25519_engine'
+require 'red25519/keys'
+require 'red25519/jruby_engine' if defined? JRUBY_VERSION
+
+module Ed25519
+  SECRET_KEY_BYTES = 32
+  PUBLIC_KEY_BYTES = 32
+  SIGNATURE_BYTES  = 64
+
+  class SelfTestFailure < StandardError; end
+
+  def self.test
+    signature_key = Ed25519::SigningKey.new("A" * 32)
+
+    unless signature_key.verify_key.to_hex == 'db995fe25169d141cab9bbba92baa01f9f2e1ece7df4cb2ac05190f37fcc1f9d'
+      raise SelfTestFailure, "failed to generate verify key correctly"
+    end
+
+    message = "crypto libraries should self-test on boot"
+    signature = signature_key.sign(message)
+    unless signature.unpack("H*").first == 'c62c12a3a6cbfa04800d4be81468ef8aecd152a6a26a81d91257baecef13ba209531fe905a843e833c8b71cee04400fa2af3a29fef1152ece470421848758d0a'
+      raise SelfTestFailure, "failed to generate correct signature"
+    end
+
+    verify_key = signature_key.verify_key
+    unless verify_key.verify(signature, message)
+      raise SelfTestFailure, "failed to verify a valid signature"
+    end
+
+    bad_signature = signature[0...63] + 'X'
+    unless verify_key.verify(bad_signature, message) == false
+      raise SelfTestFailure, "failed to detect an invalid signature"
+    end
+  end
+end
+
+Ed25519.test
+
+# TIMTOWTDI!!!
+Red25519 = Ed25519

data/red25519.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/red25519/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tony Arcieri"]
+  gem.email         = ["tony.arcieri@gmail.com"]
+  gem.description   = "Ruby wrappers for the Ed25519 public key signature system"
+  gem.summary       = "Red25519 provides both C and Java bindings to the Ed25519 public key signature system"
+  gem.homepage      = "https://github.com/tarcieri/red25519"
+
+  gem.files = `git ls-files`.split($\)
+  gem.files << "lib/red25519_engine.jar" if defined? JRUBY_VERSION
+
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "red25519"
+  gem.require_paths = ["lib"]
+  gem.version       = Ed25519::VERSION
+
+  if defined? JRUBY_VERSION
+    gem.platform = "jruby"
+  else
+    gem.extensions = "ext/red25519/extconf.rb"
+  end
+
+  gem.add_runtime_dependency "hkdf"
+
+  gem.add_development_dependency "rake-compiler"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/spec/red25519/engine_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Ed25519::Engine do
+  let(:seed_length) { Ed25519::SECRET_KEY_BYTES }
+  let(:message)     { 'foobar' }
+
+  it "generates keypairs" do
+    ary = Ed25519::Engine.create_keypair("A" * seed_length)
+
+    ary.length.should eq 2
+    pubkey, privkey = ary
+
+    pubkey.should be_a String
+    pubkey.length.should eq Ed25519::PUBLIC_KEY_BYTES
+
+    privkey.should be_a String
+    privkey.length.should eq Ed25519::SECRET_KEY_BYTES * 2
+  end
+
+  it "raises ArgumentError if the seed is not #{Ed25519::SECRET_KEY_BYTES} bytes long" do
+    expect { Ed25519::Engine.create_keypair("A" * (seed_length - 1)) }.to raise_exception ArgumentError
+    expect { Ed25519::Engine.create_keypair("A" * (seed_length + 1)) }.to raise_exception ArgumentError
+  end
+
+  it "signs and verifies messages" do
+    verify_key, signing_key = Ed25519::Engine.create_keypair("A" * seed_length)
+    signature = Ed25519::Engine.sign(signing_key, message)
+    Ed25519::Engine.verify(verify_key, signature, message).should be_true
+
+    bad_signature = signature[0...63] + "X"
+    Ed25519::Engine.verify(verify_key, bad_signature, message).should be_false
+  end
+end

data/spec/red25519/keys_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Ed25519::SigningKey do
+  let(:key) { Ed25519::SigningKey.generate }
+  let(:message) { "example message" }
+
+  it "generates keypairs" do
+    key.should be_a Ed25519::SigningKey
+    key.verify_key.should be_a Ed25519::VerifyKey
+  end
+
+  it "signs messages" do
+    key.sign(message).should be_a String
+  end
+
+  it "serializes to bytes" do
+    bytes = key.to_bytes
+    bytes.should be_a String
+    bytes.length.should eq 32
+  end
+
+  it "serializes to hex" do
+    hex = key.to_hex
+    hex.should be_a String
+    hex.length.should eq 64
+  end
+
+  it "initializes from hex" do
+    hex = key.to_hex
+    new_key = Ed25519::SigningKey.new(hex)
+    key.to_bytes.should == new_key.to_bytes
+  end
+end
+
+describe Ed25519::VerifyKey do
+  let(:signing_key) { Ed25519::SigningKey.generate }
+  let(:verify_key)  { signing_key.verify_key }
+  let(:message)     { "example message" }
+
+  it "verifies messages" do
+    signature = signing_key.sign(message)
+    verify_key.verify(signature, message).should be_true
+
+    bad_signature = signature[0...63] + "X"
+    verify_key.verify(bad_signature, message).should be_false
+  end
+
+  it "serializes to bytes" do
+    bytes = verify_key.to_bytes
+    bytes.should be_a String
+    bytes.length.should eq 32
+  end
+
+  it "serializes to hex" do
+    hex = verify_key.to_hex
+    hex.should be_a String
+    hex.length.should eq 64
+  end
+
+  it "initializes from hex" do
+    hex = verify_key.to_hex
+    new_key = Ed25519::VerifyKey.new(hex)
+    verify_key.to_bytes.should == new_key.to_bytes
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'red25519'

data/tasks/extension.rake

@@ -0,0 +1,12 @@
+if defined? JRUBY_VERSION
+  require 'rake/javaextensiontask'
+  Rake::JavaExtensionTask.new('red25519_engine') do |ext|
+    ext.ext_dir = 'ext/red25519'
+  end
+else
+  require 'rake/extensiontask'
+
+  Rake::ExtensionTask.new('red25519_engine') do |ext|
+    ext.ext_dir = 'ext/red25519'
+  end
+end

data/tasks/rspec.rake

@@ -0,0 +1,7 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end