rbnacl 1.1.0 → 2.0.0.pre

data/rbnacl.gemspec

@@ -5,7 +5,7 @@ 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"
@@ -21,11 +21,8 @@ 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.signing_key = "/home/tony/.sekretz/gem-private_key.pem"
-  gem.cert_chain = ["/home/tony/.sekretz/gem-public_cert.pem"]
+  gem.add_development_dependency "rspec", ">= 2.14"
 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,26 @@
+# 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
+    RbNaCl::Hash.blake2b(reference_string).should eq reference_string_hash
+  end
+
+  it "calculates the correct hash for an empty string" do
+    RbNaCl::Hash.blake2b("").should 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
+      RbNaCl::Hash.blake2b(reference_string, :key => reference_key).should eq reference_string_hash
+    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