rbnacl 1.0.0 → 1.1.0

data/spec/rbnacl/keys/public_key_spec.rb

@@ -2,17 +2,17 @@
 require 'spec_helper'
 
 describe Crypto::PublicKey do
-  let(:alicepk)     { Crypto::TestVectors[:alice_public] }
-  let(:alicepk_raw) { Crypto::Encoder[:hex].decode(alicepk) }
+  let(:alicepk)     { test_vector :alice_public }
+  let(:alicepk_hex) { bytes2hex alicepk }
 
-  subject { Crypto::PublicKey.new(alicepk, :hex) }
+  subject { Crypto::PublicKey.new(alicepk) }
 
   context "new" do
     it "accepts a valid key" do
-      expect { Crypto::PublicKey.new(alicepk_raw) }.not_to raise_error
+      expect { Crypto::PublicKey.new(alicepk) }.not_to raise_error
     end
     it "accepts a valid key in hex" do
-      expect { Crypto::PublicKey.new(alicepk, :hex) }.not_to raise_error
+      expect { Crypto::PublicKey.new(alicepk_hex, :hex) }.not_to raise_error
     end
     it "rejects a nil key" do
       expect { Crypto::PublicKey.new(nil) }.to raise_error(ArgumentError)
@@ -24,22 +24,22 @@ describe Crypto::PublicKey do
 
   context "#to_bytes" do
     it "returns the bytes of the key" do
-      subject.to_bytes.should eq alicepk_raw
+      subject.to_bytes.should eq alicepk
     end
   end
 
   context "#to_s" do
     it "returns the bytes of the key" do
-      subject.to_s.should eq alicepk_raw
+      subject.to_s.should eq alicepk
     end
     it "returns the bytes of the key hex encoded" do
-      subject.to_s(:hex).should eq alicepk
+      subject.to_s(:hex).should eq alicepk_hex
     end
   end
-  
+
   include_examples "key equality" do
     let(:key) { subject }
     let(:key_bytes) { subject.to_bytes }
-    let(:other_key) { described_class.new(alicepk_raw.succ) }
+    let(:other_key) { described_class.new(alicepk.succ) }
   end
 end

data/spec/rbnacl/keys/signing_key_spec.rb

@@ -2,38 +2,37 @@
 require 'spec_helper'
 
 describe Crypto::SigningKey do
-  let(:signing_key)     { Crypto::TestVectors[:sign_private] }
-  let(:signing_key_raw) { Crypto::Encoder[:hex].decode(signing_key) }
+  let(:signing_key_hex) { hex_vector :sign_private }
+  let(:signing_key)     { hex2bytes signing_key_hex }
 
-  let(:message)         { Crypto::Encoder[:hex].decode(Crypto::TestVectors[:sign_message]) }
-  let(:signature)       { Crypto::TestVectors[:sign_signature] }
-  let(:signature_raw)   { Crypto::Encoder[:hex].decode(signature) }
+  let(:message)         { test_vector :sign_message }
+  let(:signature)       { test_vector :sign_signature }
 
   # NOTE: this implicitly covers testing initialization from bytes
-  subject { described_class.new(signing_key, :hex) }
+  subject { described_class.new(signing_key_hex, :hex) }
 
   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_raw
+    subject.sign(message).should eq signature
   end
 
   it "signs messages as hex" do
-    subject.sign(message, :hex).should eq signature
+    subject.sign(message, :hex).should eq bytes2hex signature
   end
 
   it "serializes to hex" do
-    subject.to_s(:hex).should eq signing_key
+    subject.to_s(:hex).should eq signing_key_hex
   end
 
   it "serializes to bytes" do
-    subject.to_bytes.should eq signing_key_raw
+    subject.to_bytes.should eq signing_key
   end
-  
+
   include_examples "key equality" do
-    let(:key_bytes) { signing_key_raw }
+    let(:key_bytes) { signing_key }
     let(:key)       { described_class.new(key_bytes) }
     let(:other_key) { described_class.new("B"*32) }
   end

data/spec/rbnacl/keys/verify_key_spec.rb

@@ -1,12 +1,12 @@
 # encoding: binary
 describe Crypto::VerifyKey do
-  let(:signing_key)    { Crypto::TestVectors[:sign_private] }
-  let(:verify_key)     { Crypto::TestVectors[:sign_public] }
-  let(:verify_key_raw) { Crypto::Encoder[:hex].decode(verify_key) }
+  let(:signing_key)    { hex_vector :sign_private }
+  let(:verify_key)     { hex_vector :sign_public }
+  let(:verify_key_raw) { hex2bytes verify_key }
 
-  let(:message)        { Crypto::Encoder[:hex].decode(Crypto::TestVectors[:sign_message]) }
-  let(:signature)      { Crypto::TestVectors[:sign_signature] }
-  let(:signature_raw)  { Crypto::Encoder[:hex].decode(signature) }
+  let(:message)        { test_vector :sign_message }
+  let(:signature)      { hex_vector :sign_signature }
+  let(:signature_raw)  { hex2bytes signature }
   let(:bad_signature)  { sig = signature.dup; sig[0] = (sig[0].ord + 1).chr; sig }
 
   subject { Crypto::SigningKey.new(signing_key, :hex).verify_key }

data/spec/rbnacl/point_spec.rb

@@ -2,28 +2,28 @@
 require 'spec_helper'
 
 describe Crypto::Point do
-  let(:alice_private)  { Crypto::TestVectors[:alice_private] }
-  let(:alice_public)   { Crypto::TestVectors[:alice_public] }
+  let(:alice_private)  { test_vector :alice_private }
+  let(:alice_public)   { test_vector :alice_public }
 
-  let(:bob_public)     { Crypto::TestVectors[:bob_public] }
+  let(:bob_public)     { test_vector :bob_public }
 
-  let(:alice_mult_bob) { Crypto::TestVectors[:alice_mult_bob] }
+  let(:alice_mult_bob) { test_vector :alice_mult_bob }
 
-  subject { described_class.new(bob_public, :hex) }
+  subject { described_class.new(bob_public) }
 
   it "multiplies integers with the base point" do
-    described_class.base.mult(alice_private, :hex).to_s(:hex).should eq alice_public
+    described_class.base.mult(alice_private).to_s.should eq alice_public
   end
 
   it "multiplies integers with arbitrary points" do
-    described_class.new(bob_public, :hex).mult(alice_private, :hex).to_s(:hex).should eq alice_mult_bob
+    described_class.new(bob_public).mult(alice_private).to_s.should eq alice_mult_bob
   end
 
   it "serializes to bytes" do
-    subject.to_bytes.should eq Crypto::Encoder[:hex].decode(bob_public)
+    subject.to_bytes.should eq bob_public
   end
 
   it "serializes to hex" do
-    subject.to_s(:hex).should eq bob_public
+    subject.to_s(:hex).should eq bytes2hex bob_public
   end
-end
+end

data/spec/rbnacl/random_nonce_box_spec.rb

@@ -2,13 +2,10 @@
 require 'spec_helper'
 
 describe Crypto::RandomNonceBox do
-  let (:secret_key) {
-  [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].pack('c*')
-  } # from the nacl distribution
+  let (:secret_key) { test_vector :secret_key }
   let(:secret_box) { Crypto::SecretBox.new(secret_key) }
-  let (:alicepk) { "\x85 \xF0\t\x890\xA7Tt\x8B}\xDC\xB4>\xF7Z\r\xBF:\r&8\x1A\xF4\xEB\xA4\xA9\x8E\xAA\x9BNj"  } # from the nacl distribution
-  let (:bobsk) { "]\xAB\b~bJ\x8AKy\xE1\x7F\x8B\x83\x80\x0E\xE6o;\xB1)&\x18\xB6\xFD\x1C/\x8B'\xFF\x88\xE0\xEB" } # from the nacl distribution
+  let (:alicepk) { test_vector :alice_public }
+  let (:bobsk)   { test_vector :bob_private }
 
   context "instantiation" do
     it "can be instantiated from an already existing box" do
@@ -32,30 +29,9 @@ describe Crypto::RandomNonceBox do
 
 
   context "cryptography" do
-    let(:nonce) { "iin\xE9U\xB6+s\xCDb\xBD\xA8u\xFCs\xD6\x82\x19\xE0\x03kz\v7" } # from nacl distribution
-    let(:message) { # from nacl distribution
-      [0xbe,0x07,0x5f,0xc5,0x3c,0x81,0xf2,0xd5,0xcf,0x14,0x13,0x16,0xeb,0xeb,0x0c,0x7b,
-        0x52,0x28,0xc5,0x2a,0x4c,0x62,0xcb,0xd4,0x4b,0x66,0x84,0x9b,0x64,0x24,0x4f,0xfc,
-        0xe5,0xec,0xba,0xaf,0x33,0xbd,0x75,0x1a,0x1a,0xc7,0x28,0xd4,0x5e,0x6c,0x61,0x29,
-        0x6c,0xdc,0x3c,0x01,0x23,0x35,0x61,0xf4,0x1d,0xb6,0x6c,0xce,0x31,0x4a,0xdb,0x31,
-        0x0e,0x3b,0xe8,0x25,0x0c,0x46,0xf0,0x6d,0xce,0xea,0x3a,0x7f,0xa1,0x34,0x80,0x57,
-        0xe2,0xf6,0x55,0x6a,0xd6,0xb1,0x31,0x8a,0x02,0x4a,0x83,0x8f,0x21,0xaf,0x1f,0xde,
-        0x04,0x89,0x77,0xeb,0x48,0xf5,0x9f,0xfd,0x49,0x24,0xca,0x1c,0x60,0x90,0x2e,0x52,
-        0xf0,0xa0,0x89,0xbc,0x76,0x89,0x70,0x40,0xe0,0x82,0xf9,0x37,0x76,0x38,0x48,0x64,
-        0x5e,0x07,0x05].pack('c*')
-    }
-    let(:ciphertext) { # from nacl distribution
-      [0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,
-        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].pack('c*')
-    }
+    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(:enciphered_message) { random_box.box(message) }
     let(:enciphered_message_hex) { random_box.box(message, :hex) }

data/spec/rbnacl/secret_box_spec.rb

@@ -2,11 +2,11 @@
 require 'spec_helper'
 
 describe Crypto::SecretBox do
-  let (:key) { Crypto::TestVectors[:secret_key] }
+  let (:key) { test_vector :secret_key }
 
   context "new" do
     it "accepts strings" do
-      expect { Crypto::SecretBox.new(key, :hex) }.to_not raise_error(Exception)
+      expect { Crypto::SecretBox.new(key) }.to_not raise_error(Exception)
     end
 
     it "raises on a nil key" do
@@ -19,6 +19,6 @@ describe Crypto::SecretBox do
   end
 
   include_examples "box" do
-    let(:box) { Crypto::SecretBox.new(key, :hex) }
+    let(:box) { Crypto::SecretBox.new(key) }
   end
 end

data/spec/shared/authenticator.rb

@@ -1,10 +1,10 @@
 # encoding: binary
 shared_examples "authenticator" do
-  let (:hex_key) { Crypto::TestVectors[:auth_key] } 
-  let (:key)     { Crypto::Encoder[:hex].decode(hex_key) }
-  let (:message) { Crypto::Encoder[:hex].decode(Crypto::TestVectors[:auth_message]) }
-  let(:tag)      { Crypto::Encoder[:hex].decode(hex_tag)  }
-  
+  let (:hex_key) { hex_vector  :auth_key }
+  let (:key)     { test_vector :auth_key }
+  let (:message) { test_vector :auth_message }
+  let (:tag)     { hex2bytes hex_tag  }
+
   context ".new" do
     it "accepts a key" do
       expect { described_class.new(key)  }.to_not raise_error(ArgumentError)

data/spec/shared/box.rb

@@ -3,11 +3,11 @@
 require 'spec_helper'
 
 shared_examples "box" do
-  let(:nonce) { hex2bytes(Crypto::TestVectors[:box_nonce]) }
+  let(:nonce) { test_vector :box_nonce }
   let(:invalid_nonce) { nonce[0,12]  } # too short!
   let(:invalid_nonce_long) { nonce + nonce  } # too long!
-  let(:message)    { hex2bytes(Crypto::TestVectors[:box_message]) }
-  let(:ciphertext) { hex2bytes(Crypto::TestVectors[:box_ciphertext]) }
+  let(:message)    { test_vector :box_message }
+  let(:ciphertext) { test_vector :box_ciphertext }
   let (:nonce_error_regex) { /Nonce.*(Expected #{Crypto::NaCl::NONCEBYTES})/ }
   let(:corrupt_ciphertext) { ciphertext[80] = " " } # picked at random by fair diceroll
 

data/spec/spec_helper.rb

@@ -12,3 +12,15 @@ Coveralls.wear!
 def hex2bytes(hex)
   Crypto::Encoder[:hex].decode(hex)
 end
+
+def bytes2hex(bytes)
+  Crypto::Encoder[:hex].encode(bytes)
+end
+
+def test_vector(name)
+  hex2bytes(hex_vector(name))
+end
+
+def hex_vector(name)
+  Crypto::TestVectors[name]
+end

metadata

@@ -1,10 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: rbnacl
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Tony Arcieri
+- Jonathan Stott
 autorequire: 
 bindir: bin
 cert_chain:
@@ -30,7 +31,7 @@ cert_chain:
   3L/NVZQttSvxjd+WF6mA9yeCjpomboQMP36GRIZ30SoOVPMGvZ/+QpW52QU7mJW5
   GzWyf92p0uscgUZVTYixjg==
   -----END CERTIFICATE-----
-date: 2013-03-08 00:00:00.000000000 Z
+date: 2013-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -77,6 +78,7 @@ dependencies:
 description: Ruby binding to the Networking and Cryptography (NaCl) library
 email:
 - tony.arcieri@gmail.com
+- jonathan.stott@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -91,6 +93,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bascule.cert
 - images/dragons.png
 - images/ed25519.png
 - images/hash.png

metadata.gz.sig

@@ -1,2 +1,2 @@
-�����$�Z���]��ޤ�R-]�e��ڮ���	�
-����:�T����SO�Œ������R.��d4�5hک`]&ӕ��=���E�1M����e�P"c��@-���	�j�p?	`A�n:�G�Ҿ��
W���wj#�pJU�& U@���� `��cӜO���9�؅�1�p퉼�ǡ�Fl:>�%k
+Ea���E?�&rL}:�!�`��u�B�\�$GP�>�:	����݋)cv�"H*�#��4���ei��*�&�pjk#*�芚$��I�_����:��oC����W��h �=���ƕʗZ��K��Oc{����<P�~G�(���M���
+��X�V���>'XA�'�C�y� Tvj�q�	S�X�����