rbnacl 1.1.0 → 2.0.0

data/lib/rbnacl.rb

@@ -1,5 +1,17 @@
 # encoding: binary
-module Crypto
+require "rbnacl/version"
+require "rbnacl/sodium"
+require "rbnacl/sodium/version"
+require "rbnacl/serializable"
+require "rbnacl/key_comparator"
+require "rbnacl/auth"
+require "rbnacl/util"
+require "rbnacl/random"
+require "rbnacl/random_nonce_box"
+require "rbnacl/test_vectors"
+require "rbnacl/init"
+
+module RbNaCl
   # Oh no, something went wrong!
   #
   # This indicates a failure in the operation of a cryptographic primitive such
@@ -18,35 +30,58 @@ module Crypto
   # This indicates that an attempt has been made to use something (probably a key)
   # with an incorrect primitive
   class IncorrectPrimitiveError < ArgumentError; end
-end
 
-# TIMTOWTDI!
-RbNaCl = Crypto
+  # The signature was forged or otherwise corrupt
+  class BadSignatureError < CryptoError; end
 
-require "rbnacl/nacl"
-require "rbnacl/version"
-require "rbnacl/serializable"
-require "rbnacl/keys/key_comparator"
-require "rbnacl/keys/private_key"
-require "rbnacl/keys/public_key"
-require "rbnacl/keys/signing_key"
-require "rbnacl/keys/verify_key"
-require "rbnacl/box"
-require "rbnacl/secret_box"
-require "rbnacl/hash"
-require "rbnacl/util"
-require "rbnacl/auth"
-require "rbnacl/hmac/sha512256"
-require "rbnacl/hmac/sha256"
-require "rbnacl/auth/one_time"
-require "rbnacl/random"
-require "rbnacl/encoder"
-require "rbnacl/encoders/base64"
-require "rbnacl/encoders/hex"
-require "rbnacl/encoders/raw"
-require "rbnacl/point"
-require "rbnacl/random_nonce_box"
-require "rbnacl/test_vectors"
+  # The authenticator was forged or otherwise corrupt
+  class BadAuthenticatorError < CryptoError; end
+
+
+  # Public Key Encryption (Box): Curve25519XSalsa20Poly1305
+  require "rbnacl/boxes/curve25519xsalsa20poly1305"
+  require "rbnacl/boxes/curve25519xsalsa20poly1305/private_key"
+  require "rbnacl/boxes/curve25519xsalsa20poly1305/public_key"
+
+  # Secret Key Encryption (SecretBox): XSalsa20Poly1305
+  require "rbnacl/secret_boxes/xsalsa20poly1305"
+
+  # Digital Signatures: Ed25519
+  require "rbnacl/signatures/ed25519"
+  require "rbnacl/signatures/ed25519/signing_key"
+  require "rbnacl/signatures/ed25519/verify_key"
+
+  # Group Elements: Curve25519
+  require "rbnacl/group_elements/curve25519"
+
+  # One-time Authentication: Poly1305
+  require "rbnacl/one_time_auths/poly1305"
+
+  # Hash functions: SHA256/512 and Blake2b
+  require "rbnacl/hash"
+  require "rbnacl/hash/sha256"
+  require "rbnacl/hash/sha512"
+  require "rbnacl/hash/blake2b"
+
+  # HMAC: SHA256 and SHA512256
+  require "rbnacl/hmac/sha256"
+  require "rbnacl/hmac/sha512256"
+
+  #
+  # Bind aliases used by the public API
+  #
+  Box          = Boxes::Curve25519XSalsa20Poly1305
+  PrivateKey   = Boxes::Curve25519XSalsa20Poly1305::PrivateKey
+  PublicKey    = Boxes::Curve25519XSalsa20Poly1305::PublicKey
+  SecretBox    = SecretBoxes::XSalsa20Poly1305
+  SigningKey   = Signatures::Ed25519::SigningKey
+  VerifyKey    = Signatures::Ed25519::VerifyKey
+  GroupElement = GroupElements::Curve25519
+  OneTimeAuth  = OneTimeAuths::Poly1305
+end
+
+# Select platform-optimized versions of algorithms
+Thread.exclusive { RbNaCl::Init.sodium_init }
 
 # Perform self test on load
-require "rbnacl/self_test"
+require "rbnacl/self_test" unless $RBNACL_SELF_TEST == false

data/rbnacl.gemspec

@@ -5,12 +5,13 @@ require 'rbnacl/version'
 
 Gem::Specification.new do |gem|
   gem.name          = "rbnacl"
-  gem.version       = Crypto::VERSION
+  gem.version       = RbNaCl::VERSION
   gem.authors       = ["Tony Arcieri", "Jonathan Stott"]
   gem.email         = ["tony.arcieri@gmail.com", "jonathan.stott@gmail.com"]
   gem.description   = "Ruby binding to the Networking and Cryptography (NaCl) library"
   gem.summary       = "The Networking and Cryptography (NaCl) library provides a high-level toolkit for building cryptographic systems and protocols"
   gem.homepage      = "https://github.com/cryptosphere/rbnacl"
+  gem.licenses      = ["MIT"]
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -21,11 +22,11 @@ Gem::Specification.new do |gem|
     gem.platform = "jruby"
   end
 
-  gem.add_runtime_dependency 'ffi'
+  gem.add_runtime_dependency "ffi"
 
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec", ">= 2.14"
 
-  gem.signing_key = "/home/tony/.sekretz/gem-private_key.pem"
-  gem.cert_chain = ["/home/tony/.sekretz/gem-public_cert.pem"]
+  gem.signing_key = "../.sekretz/gem-private_key.pem"
+  gem.cert_chain = ["bascule.cert"]
 end

data/spec/rbnacl/{auth/one_time_spec.rb → authenticators/poly1305_spec.rb}

@@ -1,8 +1,8 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::Auth::OneTime do
-  let(:hex_tag) { hex_vector :auth_onetime }
+describe RbNaCl::OneTimeAuth do
+  let(:tag) { vector :auth_onetime }
 
   include_examples "authenticator"
 end

data/spec/rbnacl/boxes/curve25519xsalsa20poly1305/private_key_spec.rb

@@ -0,0 +1,65 @@
+# encoding: binary
+require 'spec_helper'
+
+describe RbNaCl::PrivateKey do
+  let(:bobsk) { vector :bob_private }
+  let(:bobpk) { vector :bob_public }
+
+  subject { RbNaCl::PrivateKey.new(bobsk) }
+
+  context "generate" do
+    let(:secret_key) { RbNaCl::PrivateKey.generate }
+
+    it "returns a secret key" do
+      secret_key.should be_a RbNaCl::PrivateKey
+    end
+
+    it "has the public key also set" do
+      secret_key.public_key.should be_a RbNaCl::PublicKey
+    end
+  end
+
+  context "new" do
+    it "accepts a valid key" do
+      expect { RbNaCl::PrivateKey.new(bobsk) }.not_to raise_error
+    end
+
+    it "raises TypeError when given a nil key" do
+      expect { RbNaCl::PrivateKey.new(nil) }.to raise_error(TypeError)
+    end
+
+    it "raises ArgumentError when given a short key" do
+      expect { RbNaCl::PrivateKey.new("short") }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "public_key" do
+    it "returns a public key" do
+      subject.public_key.should be_a RbNaCl::PublicKey
+    end
+
+    it "returns the correct public key" do
+      subject.public_key.to_s.should eql bobpk
+    end
+  end
+
+  context "#to_bytes" do
+    it "returns the bytes of the key" do
+      subject.to_s.should eq bobsk
+    end
+  end
+
+  context "#to_s" do
+    it "returns the raw bytes of the key" do
+      subject.to_bytes.should eq bobsk
+    end
+  end
+
+  include_examples "key equality" do
+    let(:key) { subject }
+    let(:key_bytes) { subject.to_bytes }
+    let(:other_key) { described_class.new(bobpk) }
+  end
+
+  include_examples "serializable"
+end

data/spec/rbnacl/{keys → boxes/curve25519xsalsa20poly1305}/public_key_spec.rb

@@ -1,24 +1,22 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::PublicKey do
-  let(:alicepk)     { test_vector :alice_public }
-  let(:alicepk_hex) { bytes2hex alicepk }
+describe RbNaCl::PublicKey do
+  let(:alicepk)     { vector :alice_public }
 
-  subject { Crypto::PublicKey.new(alicepk) }
+  subject { RbNaCl::PublicKey.new(alicepk) }
 
   context "new" do
     it "accepts a valid key" do
-      expect { Crypto::PublicKey.new(alicepk) }.not_to raise_error
-    end
-    it "accepts a valid key in hex" do
-      expect { Crypto::PublicKey.new(alicepk_hex, :hex) }.not_to raise_error
+      expect { RbNaCl::PublicKey.new(alicepk) }.not_to raise_error
     end
+
     it "rejects a nil key" do
-      expect { Crypto::PublicKey.new(nil) }.to raise_error(ArgumentError)
+      expect { RbNaCl::PublicKey.new(nil) }.to raise_error(TypeError)
     end
+
     it "rejects a short key" do
-      expect { Crypto::PublicKey.new("short") }.to raise_error(ArgumentError)
+      expect { RbNaCl::PublicKey.new("short") }.to raise_error(ArgumentError)
     end
   end
 
@@ -32,9 +30,6 @@ describe Crypto::PublicKey do
     it "returns the bytes of the key" do
       subject.to_s.should eq alicepk
     end
-    it "returns the bytes of the key hex encoded" do
-      subject.to_s(:hex).should eq alicepk_hex
-    end
   end
 
   include_examples "key equality" do
@@ -42,4 +37,6 @@ describe Crypto::PublicKey do
     let(:key_bytes) { subject.to_bytes }
     let(:other_key) { described_class.new(alicepk.succ) }
   end
+
+  include_examples "serializable"
 end

data/spec/rbnacl/boxes/curve25519xsalsa20poly1305_spec.rb

@@ -0,0 +1,39 @@
+# encoding: binary
+require 'spec_helper'
+
+describe RbNaCl::Box do
+  let(:alicepk)   { vector :alice_public }
+  let(:bobsk)     { vector :bob_private  }
+  let(:alice_key) { RbNaCl::PublicKey.new(alicepk) }
+  let(:bob_key)   { RbNaCl::PrivateKey.new(bobsk) }
+
+  context "new" do
+    it "accepts strings" do
+      expect { RbNaCl::Box.new(alicepk, bobsk) }.to_not raise_error(Exception)
+    end
+
+    it "accepts KeyPairs" do
+      expect { RbNaCl::Box.new(alice_key, bob_key) }.to_not raise_error(Exception)
+    end
+
+    it "raises TypeError on a nil public key" do
+      expect { RbNaCl::Box.new(nil, bobsk) }.to raise_error(TypeError)
+    end
+
+    it "raises RbNaCl::LengthError on an invalid public key" do
+      expect { RbNaCl::Box.new("hello", bobsk) }.to raise_error(RbNaCl::LengthError, /Public key was 5 bytes \(Expected 32\)/)
+    end
+
+    it "raises TypeError on a nil secret key" do
+      expect { RbNaCl::Box.new(alicepk, nil) }.to raise_error(TypeError)
+    end
+
+    it "raises RbNaCl::LengthError on an invalid secret key" do
+      expect { RbNaCl::Box.new(alicepk, "hello") }.to raise_error(RbNaCl::LengthError, /Private key was 5 bytes \(Expected 32\)/)
+    end
+  end
+
+  include_examples 'box' do
+    let(:box) { RbNaCl::Box.new(alicepk, bobsk) }
+  end
+end

data/spec/rbnacl/{point_spec.rb → group_element_spec.rb}

@@ -1,13 +1,13 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::Point do
-  let(:alice_private)  { test_vector :alice_private }
-  let(:alice_public)   { test_vector :alice_public }
+describe RbNaCl::GroupElement do
+  let(:alice_private)  { vector :alice_private }
+  let(:alice_public)   { vector :alice_public }
 
-  let(:bob_public)     { test_vector :bob_public }
+  let(:bob_public)     { vector :bob_public }
 
-  let(:alice_mult_bob) { test_vector :alice_mult_bob }
+  let(:alice_mult_bob) { vector :alice_mult_bob }
 
   subject { described_class.new(bob_public) }
 
@@ -23,7 +23,5 @@ describe Crypto::Point do
     subject.to_bytes.should eq bob_public
   end
 
-  it "serializes to hex" do
-    subject.to_s(:hex).should eq bytes2hex bob_public
-  end
+  include_examples "serializable"
 end

data/spec/rbnacl/hash/blake2b_spec.rb

@@ -0,0 +1,30 @@
+# encoding: binary
+require 'spec_helper'
+
+describe RbNaCl::Hash::Blake2b do
+  let(:reference_string)      { vector :blake2b_message }
+  let(:reference_string_hash) { vector :blake2b_digest }
+  let(:empty_string_hash)     { vector :blake2b_empty }
+
+  it "calculates the correct hash for a reference string" do
+    expect(RbNaCl::Hash.blake2b(reference_string)).to eq reference_string_hash
+  end
+
+  it "calculates the correct hash for an empty string" do
+    expect(RbNaCl::Hash.blake2b("")).to eq empty_string_hash
+  end
+
+  context "keyed" do
+    let(:reference_string)      { vector :blake2b_keyed_message }
+    let(:reference_key)         { vector :blake2b_key }
+    let(:reference_string_hash) { vector :blake2b_keyed_digest }
+
+    it "calculates keyed hashes correctly" do
+      expect(RbNaCl::Hash.blake2b(reference_string, key: reference_key)).to eq reference_string_hash
+    end
+
+    it "doesn't accept empty strings as a key" do
+      expect { RbNaCl::Hash.blake2b(reference_string, key: "") }.to raise_exception
+    end
+  end
+end

data/spec/rbnacl/hash_spec.rb

@@ -1,60 +1,40 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::Hash do
+describe RbNaCl::Hash do
   context "sha256" do
-    let(:reference_string)      { test_vector :sha256_message }
-    let(:reference_string_hash) { test_vector :sha256_digest }
-    let(:empty_string_hash) { "\xE3\xB0\xC4B\x98\xFC\x1C\x14\x9A\xFB\xF4\xC8\x99o\xB9$'\xAEA\xE4d\x9B\x93L\xA4\x95\x99\exR\xB8U" }
-    let(:reference_string_hash_hex) { reference_string_hash.unpack('H*').first }
-    let(:empty_string_hash_hex) { empty_string_hash.unpack('H*').first }
+    let(:reference_string)      { vector :sha256_message }
+    let(:reference_string_hash) { vector :sha256_digest }
+    let(:empty_string_hash)     { vector :sha256_empty }
 
     it "calculates the correct hash for a reference string" do
-      Crypto::Hash.sha256(reference_string).should eq reference_string_hash
+      RbNaCl::Hash.sha256(reference_string).should eq reference_string_hash
     end
 
     it "calculates the correct hash for an empty string" do
-      Crypto::Hash.sha256("").should eq empty_string_hash
-    end
-
-    it "calculates the correct hash for a reference string and returns it in hex" do
-      Crypto::Hash.sha256(reference_string, :hex).should eq reference_string_hash_hex
-    end
-
-    it "calculates the correct hash for an empty string and returns it in hex" do
-      Crypto::Hash.sha256("", :hex).should eq empty_string_hash_hex
+      RbNaCl::Hash.sha256("").should eq empty_string_hash
     end
 
     it "doesn't raise on a null byte" do
-      expect { Crypto::Hash.sha256("\0") }.to_not  raise_error(/ArgumentError: string contains null byte/)
+      expect { RbNaCl::Hash.sha256("\0") }.to_not raise_error(/ArgumentError: string contains null byte/)
     end
   end
 
   context "sha512" do
-    let(:reference_string) { "The quick brown fox jumps over the lazy dog." }
-    let(:reference_string_hash) { "\x91\xEA\x12E\xF2\rF\xAE\x9A\x03z\x98\x9FT\xF1\xF7\x90\xF0\xA4v\a\xEE\xB8\xA1M\x12\x89\f\xEAw\xA1\xBB\xC6\xC7\xED\x9C\xF2\x05\xE6{\x7F+\x8F\xD4\xC7\xDF\xD3\xA7\xA8a~E\xF3\xC4c\xD4\x81\xC7\xE5\x86\xC3\x9A\xC1\xED" }
-    let(:empty_string_hash) { "\xCF\x83\xE15~\xEF\xB8\xBD\xF1T(P\xD6m\x80\a\xD6 \xE4\x05\vW\x15\xDC\x83\xF4\xA9!\xD3l\xE9\xCEG\xD0\xD1<]\x85\xF2\xB0\xFF\x83\x18\xD2\x87~\xEC/c\xB91\xBDGAz\x81\xA582z\xF9'\xDA>" }
-    let(:reference_string_hash_hex) { reference_string_hash.unpack('H*').first }
-    let(:empty_string_hash_hex) { empty_string_hash.unpack('H*').first }
+    let(:reference_string)      { vector :sha512_message }
+    let(:reference_string_hash) { vector :sha512_digest }
+    let(:empty_string_hash)     { vector :sha512_empty }
 
     it "calculates the correct hash for a reference string" do
-      Crypto::Hash.sha512(reference_string).should eq reference_string_hash
+      RbNaCl::Hash.sha512(reference_string).should eq reference_string_hash
     end
 
     it "calculates the correct hash for an empty string" do
-      Crypto::Hash.sha512("").should eq empty_string_hash
-    end
-
-    it "calculates the correct hash for a reference string and returns it in hex" do
-      Crypto::Hash.sha512(reference_string, :hex).should eq reference_string_hash_hex
-    end
-
-    it "calculates the correct hash for an empty string and returns it in hex" do
-      Crypto::Hash.sha512("", :hex).should eq empty_string_hash_hex
+      RbNaCl::Hash.sha512("").should eq empty_string_hash
     end
 
     it "doesn't raise on a null byte" do
-      expect { Crypto::Hash.sha512("\0") }.to_not  raise_error(/ArgumentError: string contains null byte/)
+      expect { RbNaCl::Hash.sha512("\0") }.to_not raise_error(/ArgumentError: string contains null byte/)
     end
   end
 end

data/spec/rbnacl/hmac/sha256_spec.rb

@@ -1,8 +1,8 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::HMAC::SHA256 do
-  let(:hex_tag) { hex_vector :auth_hmacsha256 }
+describe RbNaCl::HMAC::SHA256 do
+  let(:tag) { vector :auth_hmacsha256 }
 
   include_examples "authenticator"
 end

data/spec/rbnacl/hmac/sha512256_spec.rb

@@ -1,8 +1,8 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::HMAC::SHA512256 do
-  let(:hex_tag) { hex_vector :auth_hmacsha512256 }
+describe RbNaCl::HMAC::SHA512256 do
+  let(:tag) { vector :auth_hmacsha512256 }
 
   include_examples "authenticator"
 end

data/spec/rbnacl/random_nonce_box_spec.rb

@@ -1,40 +1,42 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::RandomNonceBox do
-  let (:secret_key) { test_vector :secret_key }
-  let(:secret_box) { Crypto::SecretBox.new(secret_key) }
-  let (:alicepk) { test_vector :alice_public }
-  let (:bobsk)   { test_vector :bob_private }
+describe RbNaCl::RandomNonceBox do
+  let(:secret_key) { vector :secret_key }
+  let(:secret_box) { RbNaCl::SecretBox.new(secret_key) }
+  let(:alicepk)    { vector :alice_public }
+  let(:bobsk)      { vector :bob_private }
 
   context "instantiation" do
     it "can be instantiated from an already existing box" do
-      expect { Crypto::RandomNonceBox.new(secret_box) }.not_to raise_error
+      expect { RbNaCl::RandomNonceBox.new(secret_box) }.not_to raise_error
     end
 
     it "can be instantiated from a secret key" do
-      Crypto::RandomNonceBox.from_secret_key(secret_key).should be_a Crypto::RandomNonceBox
+      RbNaCl::RandomNonceBox.from_secret_key(secret_key).should be_a RbNaCl::RandomNonceBox
     end
-    it "complains on an inappropriate secret key" do
-      expect { Crypto::RandomNonceBox.from_secret_key(nil) }.to raise_error(ArgumentError)
+
+    it "raises TypeError when given a nil secret key" do
+      expect { RbNaCl::RandomNonceBox.from_secret_key(nil) }.to raise_error(TypeError)
     end
+
     it "can be instantiated from a key-pair" do
-      Crypto::RandomNonceBox.from_keypair(alicepk, bobsk).should be_a Crypto::RandomNonceBox
+      RbNaCl::RandomNonceBox.from_keypair(alicepk, bobsk).should be_a RbNaCl::RandomNonceBox
     end
-    it "complains on an inappropriate key in the pair" do
-      expect { Crypto::RandomNonceBox.from_keypair(nil, bobsk) }.to raise_error(ArgumentError)
+
+    it "raises TypeError when given nil secret keys in the pair" do
+      expect { RbNaCl::RandomNonceBox.from_keypair(nil, bobsk) }.to raise_error(TypeError)
+      expect { RbNaCl::RandomNonceBox.from_keypair(alicepk, nil) }.to raise_error(TypeError)
     end
   end
 
-
-
   context "cryptography" do
-    let(:nonce)      { test_vector :box_nonce }
-    let(:message)    { test_vector :box_message }
-    let(:ciphertext) { test_vector :box_ciphertext }
-    let(:random_box) { Crypto::RandomNonceBox.from_keypair(alicepk, bobsk) }
+    let(:nonce)      { vector :box_nonce }
+    let(:message)    { vector :box_message }
+    let(:ciphertext) { vector :box_ciphertext }
+    let(:random_box) { RbNaCl::RandomNonceBox.from_keypair(alicepk, bobsk) }
     let(:enciphered_message) { random_box.box(message) }
-    let(:enciphered_message_hex) { random_box.box(message, :hex) }
+    let(:enciphered_message_hex) { random_box.box(message) }
 
     it "descrypts a message with a 'random' nonce" do
       random_box.open(nonce+ciphertext).should eql message
@@ -43,12 +45,5 @@ describe Crypto::RandomNonceBox do
     it "can successfully round-trip a message" do
       random_box.open(enciphered_message).should eql message
     end
-
-    it "can encode a ciphertext as hex" do
-      enciphered_message_hex.should match /\A[0-9a-f]+\z/
-    end
-    it "can roundtrip a message as hex" do
-      random_box.open(enciphered_message_hex, :hex).should eql message
-    end
   end
 end

data/spec/rbnacl/random_spec.rb

@@ -1,9 +1,9 @@
 # encoding: binary
-describe Crypto::Random do
+describe RbNaCl::Random do
   it "produces random bytes" do
-    Crypto::Random.random_bytes(16).bytesize.should == 16
+    RbNaCl::Random.random_bytes(16).bytesize.should == 16
   end
   it "produces different random bytes" do
-    Crypto::Random.random_bytes(16).should_not == Crypto::Random.random_bytes(16)
+    RbNaCl::Random.random_bytes(16).should_not == RbNaCl::Random.random_bytes(16)
   end
 end

data/spec/rbnacl/secret_box_spec.rb

@@ -1,24 +1,24 @@
 # encoding: binary
 require 'spec_helper'
 
-describe Crypto::SecretBox do
-  let (:key) { test_vector :secret_key }
+describe RbNaCl::SecretBox do
+  let (:key) { vector :secret_key }
 
   context "new" do
     it "accepts strings" do
-      expect { Crypto::SecretBox.new(key) }.to_not raise_error(Exception)
+      expect { RbNaCl::SecretBox.new(key) }.to_not raise_error(Exception)
     end
 
     it "raises on a nil key" do
-      expect { Crypto::SecretBox.new(nil) }.to raise_error(Crypto::LengthError, "Secret key was nil \(Expected #{Crypto::NaCl::SECRETKEYBYTES}\)")
+      expect { RbNaCl::SecretBox.new(nil) }.to raise_error(TypeError)
     end
 
     it "raises on a short key" do
-      expect { Crypto::SecretBox.new("hello") }.to raise_error(Crypto::LengthError, "Secret key was 5 bytes \(Expected #{Crypto::NaCl::SECRETKEYBYTES}\)")
+      expect { RbNaCl::SecretBox.new("hello") }.to raise_error(RbNaCl::LengthError, "Secret key was 5 bytes \(Expected #{RbNaCl::SecretBox::KEYBYTES}\)")
     end
   end
 
   include_examples "box" do
-    let(:box) { Crypto::SecretBox.new(key) }
+    let(:box) { RbNaCl::SecretBox.new(key) }
   end
 end

data/spec/rbnacl/signatures/ed25519/signing_key_spec.rb

@@ -0,0 +1,30 @@
+# encoding: binary
+require 'spec_helper'
+
+describe RbNaCl::SigningKey do
+  let(:signing_key) { vector :sign_private }
+  let(:message)     { vector :sign_message }
+  let(:signature)   { vector :sign_signature }
+
+  subject { described_class.new(signing_key) }
+
+  it "generates keys" do
+    described_class.generate.should be_a described_class
+  end
+
+  it "signs messages as bytes" do
+    subject.sign(message).should eq signature
+  end
+
+  it "serializes to bytes" do
+    subject.to_bytes.should eq signing_key
+  end
+
+  include_examples "key equality" do
+    let(:key_bytes) { signing_key }
+    let(:key)       { described_class.new(key_bytes) }
+    let(:other_key) { described_class.new("B"*32) }
+  end
+
+  include_examples "serializable"
+end

data/spec/rbnacl/signatures/ed25519/verify_key_spec.rb

@@ -0,0 +1,39 @@
+# encoding: binary
+describe RbNaCl::VerifyKey do
+  let(:signing_key)    { vector :sign_private }
+  let(:verify_key)     { vector :sign_public }
+
+  let(:message)        { vector :sign_message }
+  let(:signature)      { vector :sign_signature }
+  let(:bad_signature)  { sig = signature.dup; sig[0] = (sig[0].ord + 1).chr; sig }
+
+  subject { RbNaCl::SigningKey.new(signing_key).verify_key }
+
+  it "verifies correct signatures" do
+    subject.verify(signature, message).should be_true
+  end
+
+  it "raises when asked to verify a bad signature" do
+    expect { subject.verify(bad_signature, message) }.to raise_exception RbNaCl::BadSignatureError
+  end
+
+  it "raises when asked to verify a short signature" do
+    expect { subject.verify(bad_signature[0,63], message) }.to raise_exception RbNaCl::LengthError
+  end
+
+  it "serializes to bytes" do
+    subject.to_bytes.should eq verify_key
+  end
+
+  it "initializes from bytes" do
+    described_class.new(verify_key).to_s.should eq verify_key
+  end
+
+  include_examples "key equality" do
+    let(:key_bytes) { verify_key }
+    let(:key)       { described_class.new(verify_key) }
+    let(:other_key) { described_class.new("B"*32) }
+  end
+
+  include_examples "serializable"
+end