rbnacl 1.0.0 → 1.1.0

data/lib/rbnacl/keys/verify_key.rb

@@ -23,7 +23,7 @@ module Crypto
     # @return [Crypto::SigningKey] Key which can sign messages
     def initialize(key, encoding = :raw)
       key = Encoder[encoding].decode(key)
-      Util.check_length(key, NaCl::PUBLICKEYBYTES, "key")
+      Util.check_length(key, NaCl::ED25519_VERIFYKEY_BYTES, "key")
 
       @key = key
     end
@@ -42,13 +42,13 @@ module Crypto
     # @return [Boolean] was the signature authentic?
     def verify(message, signature, signature_encoding = :raw)
       signature = Encoder[signature_encoding].decode(signature)
-      Util.check_length(signature, NaCl::SIGNATUREBYTES, "signature")
+      Util.check_length(signature, signature_bytes, "signature")
 
       sig_and_msg = signature + message
       buffer = Util.zeros(sig_and_msg.bytesize)
       buffer_len = Util.zeros(FFI::Type::LONG_LONG.size)
 
-      NaCl.crypto_sign_open(buffer, buffer_len, sig_and_msg, sig_and_msg.bytesize, @key)
+      NaCl.crypto_sign_ed25519_open(buffer, buffer_len, sig_and_msg, sig_and_msg.bytesize, @key)
     end
 
     # "Dangerous" (but probably safer) verify that raises an exception if a
@@ -72,5 +72,25 @@ module Crypto
     #
     # @return [String] raw key as bytes
     def to_bytes; @key; end
+
+    # The crypto primitive the VerifyKey class uses for signatures
+    #
+    # @return [Symbol] The primitive
+    def self.primitive; :ed25519; end
+
+    # The crypto primitive this VerifyKey class uses for signatures
+    #
+    # @return [Symbol] The primitive
+    def primitive; self.class.primitive; end
+
+    # The size of signatures verified by the VerifyKey class
+    #
+    # @return [Integer] The number of bytes in a signature
+    def self.signature_bytes; NaCl::ED25519_SIGNATUREBYTES; end
+
+    # The size of signatures verified by the VerifyKey instance
+    #
+    # @return [Integer] The number of bytes in a signature
+    def signature_bytes; NaCl::ED25519_SIGNATUREBYTES; end
   end
 end

data/lib/rbnacl/nacl.rb

@@ -5,6 +5,11 @@ module Crypto
   #
   # And that's all it does, really.
   #
+  # HERE BE DRAGONS!
+  #
+  # Do **NOT** use constants and methods defined here.  If you do find yourself
+  # needing to, that is a bug in RbNaCl and should be reported.
+  #
   # @private
   module NaCl
     extend FFI::Library
@@ -33,42 +38,46 @@ module Crypto
     SHA256BYTES = 32
     wrap_nacl_function :crypto_hash_sha256,
                        :crypto_hash_sha256_ref,
-                       [:pointer, :string, :long_long]
+                       [:pointer, :pointer, :long_long]
 
     SHA512BYTES = 64
     wrap_nacl_function :crypto_hash_sha512,
                        :crypto_hash_sha512_ref,
-                       [:pointer, :string, :long_long]
+                       [:pointer, :pointer, :long_long]
 
-    PUBLICKEYBYTES = 32
-    SECRETKEYBYTES = 32
-    wrap_nacl_function :crypto_box_keypair,
+    CURVE25519_XSALSA20_POLY1305_PUBLICKEY_BYTES = 32
+    PUBLICKEYBYTES = CURVE25519_XSALSA20_POLY1305_PUBLICKEY_BYTES
+    CURVE25519_XSALSA20_POLY1305_SECRETKEY_BYTES = 32
+    SECRETKEYBYTES = CURVE25519_XSALSA20_POLY1305_SECRETKEY_BYTES
+    wrap_nacl_function :crypto_box_curve25519xsalsa20poly1305_keypair,
                        :crypto_box_curve25519xsalsa20poly1305_ref_keypair,
                        [:pointer, :pointer]
 
-    NONCEBYTES     = 24
+    CURVE25519_XSALSA20_POLY1305_BOX_NONCEBYTES    = 24
+    NONCEBYTES     = CURVE25519_XSALSA20_POLY1305_BOX_NONCEBYTES
     ZEROBYTES      = 32
     BOXZEROBYTES   = 16
-    BEFORENMBYTES  = 32
+    CURVE25519_XSALSA20_POLY1305_BOX_BEFORENMBYTES = 32
 
-    wrap_nacl_function :crypto_box_beforenm,
+    wrap_nacl_function :crypto_box_curve25519_xsalsa20_poly1305_beforenm,
                        :crypto_box_curve25519xsalsa20poly1305_ref_beforenm,
                        [:pointer, :pointer, :pointer]
 
-    wrap_nacl_function :crypto_box_afternm,
+    wrap_nacl_function :crypto_box_curve25519_xsalsa20_poly1305_afternm,
                        :crypto_box_curve25519xsalsa20poly1305_ref_afternm,
                        [:pointer, :pointer, :long_long, :pointer, :pointer]
 
-    wrap_nacl_function :crypto_box_open_afternm,
+    wrap_nacl_function :crypto_box_curve25519_xsalsa20_poly1305_open_afternm,
                        :crypto_box_curve25519xsalsa20poly1305_ref_open_afternm,
                        [:pointer, :pointer, :long_long, :pointer, :pointer]
 
-    SECRETBOX_KEYBYTES = 32
-    wrap_nacl_function :crypto_secretbox,
+    XSALSA20_POLY1305_SECRETBOX_KEYBYTES   = 32
+    XSALSA20_POLY1305_SECRETBOX_NONCEBYTES = 24
+    wrap_nacl_function :crypto_secretbox_xsalsa20poly1305,
                        :crypto_secretbox_xsalsa20poly1305_ref,
                        [:pointer, :pointer, :long_long, :pointer, :pointer]
 
-    wrap_nacl_function :crypto_secretbox_open,
+    wrap_nacl_function :crypto_secretbox_xsalsa20poly1305_open,
                        :crypto_secretbox_xsalsa20poly1305_ref_open,
                        [:pointer, :pointer, :long_long, :pointer, :pointer]
 
@@ -110,22 +119,27 @@ module Crypto
                        :crypto_verify_16_ref,
                        [:pointer, :pointer]
 
-    SIGNATUREBYTES = 64
-    wrap_nacl_function :crypto_sign_seed_keypair,
+    ED25519_SIGNATUREBYTES   = 64
+    SIGNATUREBYTES           = ED25519_SIGNATUREBYTES
+    ED25519_SIGNINGKEY_BYTES = 64
+    ED25519_VERIFYKEY_BYTES  = 32
+    ED25519_SEED_BYTES       = 32
+    wrap_nacl_function :crypto_sign_ed25519_seed_keypair,
                        :crypto_sign_ed25519_ref_seed_keypair,
                        [:pointer, :pointer, :pointer]
 
-    wrap_nacl_function :crypto_sign,
+    wrap_nacl_function :crypto_sign_ed25519,
                        :crypto_sign_ed25519_ref,
                        [:pointer, :pointer, :pointer, :long_long, :pointer]
 
-    wrap_nacl_function :crypto_sign_open,
+    wrap_nacl_function :crypto_sign_ed25519_open,
                        :crypto_sign_ed25519_ref_open,
                        [:pointer, :pointer, :pointer, :long_long, :pointer]
 
-    SCALARBYTES = 32
+    ED25519_SCALARBYTES = 32
+    SCALARBYTES         = ED25519_SCALARBYTES
 
-    wrap_nacl_function :crypto_scalarmult,
+    wrap_nacl_function :crypto_scalarmult_curve25519,
                        :crypto_scalarmult_curve25519_ref,
                        [:pointer, :pointer, :pointer]
   end

data/lib/rbnacl/point.rb

@@ -18,6 +18,9 @@ module Crypto
     include KeyComparator
     include Serializable
 
+    # Number of bytes in a scalar on this curve
+    SCALARBYTES = NaCl::ED25519_SCALARBYTES
+
     # Creates a new Point from the given serialization
     #
     # @param value [String] 32-byte value representing a group element
@@ -29,7 +32,7 @@ module Crypto
 
       # FIXME: really should have a separate constant here for group element size
       # Group elements and scalars are both 32-bits, but that's for convenience
-      Util.check_length(@point, NaCl::SCALARBYTES, "group element")
+      Util.check_length(@point, SCALARBYTES, "group element")
     end
 
     # Multiply the given integer by this point
@@ -42,10 +45,10 @@ module Crypto
     # @return [Crypto::Point] Result as a Point object
     def mult(integer, encoding = :raw)
       integer = Encoder[encoding].decode(integer)
-      Util.check_length(integer, NaCl::SCALARBYTES, "integer")
+      Util.check_length(integer, SCALARBYTES, "integer")
 
-      result = Util.zeros(NaCl::SCALARBYTES)
-      NaCl.crypto_scalarmult(result, integer, @point)
+      result = Util.zeros(SCALARBYTES)
+      NaCl.crypto_scalarmult_curve25519(result, integer, @point)
 
       self.class.new(result)
     end

data/lib/rbnacl/random_nonce_box.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+require 'forwardable'
 module Crypto
   # The simplest nonce strategy that could possibly work
   #
@@ -27,7 +28,11 @@ module Crypto
   #   there is no protection against messages being reordered and replayed by an
   #   active adversary.
   class RandomNonceBox
+    extend Forwardable
+    def_delegators :@box, :nonce_bytes, :primitive
+
     # the size of the nonce
+    # DO NOT USE THIS, use the #nonce_bytes method instead
     NONCEBYTES = NaCl::NONCEBYTES
 
     # Create a new RandomNonceBox
@@ -98,11 +103,11 @@ module Crypto
 
     private
     def generate_nonce
-      Random.random_bytes(NONCEBYTES)
+      Random.random_bytes(nonce_bytes)
     end
 
     def extract_nonce(bytes)
-      nonce = bytes.slice!(0, NONCEBYTES)
+      nonce = bytes.slice!(0, nonce_bytes)
       [nonce, bytes]
     end
   end

data/lib/rbnacl/secret_box.rb

@@ -18,7 +18,10 @@ module Crypto
   # non-repudiatable messages, sign them before or after encryption.
   class SecretBox
     # Number of bytes for a secret key
-    KEYBYTES = NaCl::SECRETBOX_KEYBYTES
+    KEYBYTES = NaCl::XSALSA20_POLY1305_SECRETBOX_KEYBYTES
+
+    # Number of bytes for a nonce
+    NONCEBYTES = NaCl::XSALSA20_POLY1305_SECRETBOX_NONCEBYTES
 
     # Create a new SecretBox
     #
@@ -50,11 +53,11 @@ module Crypto
     #
     # @return [String] The ciphertext without the nonce prepended (BINARY encoded)
     def box(nonce, message)
-      Util.check_length(nonce, Crypto::NaCl::NONCEBYTES, "Nonce")
+      Util.check_length(nonce, nonce_bytes, "Nonce")
       msg = Util.prepend_zeros(NaCl::ZEROBYTES, message)
       ct  = Util.zeros(msg.bytesize)
 
-      NaCl.crypto_secretbox(ct, msg, msg.bytesize, nonce, @key) || raise(CryptoError, "Encryption failed")
+      NaCl.crypto_secretbox_xsalsa20poly1305(ct, msg, msg.bytesize, nonce, @key) || raise(CryptoError, "Encryption failed")
       Util.remove_zeros(NaCl::BOXZEROBYTES, ct)
     end
     alias encrypt box
@@ -74,13 +77,43 @@ module Crypto
     #
     # @return [String] The decrypted message (BINARY encoded)
     def open(nonce, ciphertext)
-      Util.check_length(nonce, Crypto::NaCl::NONCEBYTES, "Nonce")
+      Util.check_length(nonce, nonce_bytes, "Nonce")
       ct = Util.prepend_zeros(NaCl::BOXZEROBYTES, ciphertext)
       message  = Util.zeros(ct.bytesize)
 
-      NaCl.crypto_secretbox_open(message, ct, ct.bytesize, nonce, @key) || raise(CryptoError, "Decryption failed. Ciphertext failed verification.")
+      NaCl.crypto_secretbox_xsalsa20poly1305_open(message, ct, ct.bytesize, nonce, @key) || raise(CryptoError, "Decryption failed. Ciphertext failed verification.")
       Util.remove_zeros(NaCl::ZEROBYTES, message)
     end
     alias decrypt open
+
+    # The crypto primitive for the SecretBox class
+    #
+    # @return [Symbol] The primitive used
+    def self.primitive; :xsalsa20_poly1305; end
+
+    # The crypto primitive for the SecretBox instance
+    #
+    # @return [Symbol] The primitive used
+    def primitive; self.class.primitive; end
+
+    # The nonce bytes for the SecretBox class
+    #
+    # @return [Integer] The number of bytes in a valid nonce
+    def self.nonce_bytes; NONCEBYTES; end
+
+    # The nonce bytes for the SecretBox instance
+    #
+    # @return [Integer] The number of bytes in a valid nonce
+    def nonce_bytes; NONCEBYTES; end
+
+    # The key bytes for the SecretBox class
+    #
+    # @return [Integer] The number of bytes in a valid key
+    def self.key_bytes; KEYBYTES; end
+
+    # The key bytes for the SecretBox instance
+    #
+    # @return [Integer] The number of bytes in a valid key
+    def key_bytes; KEYBYTES; end
   end
 end

data/lib/rbnacl/version.rb

@@ -1,5 +1,5 @@
 # encoding: binary
 module Crypto
   # The library's version
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/rbnacl.gemspec

@@ -6,8 +6,8 @@ require 'rbnacl/version'
 Gem::Specification.new do |gem|
   gem.name          = "rbnacl"
   gem.version       = Crypto::VERSION
-  gem.authors       = ["Tony Arcieri"]
-  gem.email         = ["tony.arcieri@gmail.com"]
+  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"

data/spec/rbnacl/auth/one_time_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 describe Crypto::Auth::OneTime do
-  let(:hex_tag) { Crypto::TestVectors[:auth_onetime] }
+  let(:hex_tag) { hex_vector :auth_onetime }
 
   include_examples "authenticator"
 end

data/spec/rbnacl/box_spec.rb

@@ -2,11 +2,11 @@
 require 'spec_helper'
 
 describe Crypto::Box do
-  let(:alicepk_hex) { Crypto::TestVectors[:alice_public] }
-  let(:bobsk_hex)   { Crypto::TestVectors[:bob_private] }
+  let(:alicepk_hex) { hex_vector :alice_public }
+  let(:bobsk_hex)   { hex_vector :bob_private }
 
-  let(:alicepk)   { Crypto::Encoder[:hex].decode(alicepk_hex) }
-  let(:bobsk)     { Crypto::Encoder[:hex].decode(bobsk_hex) }
+  let(:alicepk)   { hex2bytes(alicepk_hex) }
+  let(:bobsk)     { hex2bytes(bobsk_hex) }
   let(:alice_key) { Crypto::PublicKey.new(alicepk) }
   let(:bob_key)   { Crypto::PrivateKey.new(bobsk) }
 
@@ -20,7 +20,7 @@ describe Crypto::Box do
     end
 
     it "raises on a nil public key" do
-      expect { Crypto::Box.new(nil, bobsk) }.to raise_error(Crypto::LengthError, /Public key was nil \(Expected 32\)/)
+      expect { Crypto::Box.new(nil, bobsk) }.to raise_error(Crypto::LengthError, /Public key was 0 bytes \(Expected 32\)/)
     end
 
     it "raises on an invalid public key" do
@@ -28,7 +28,7 @@ describe Crypto::Box do
     end
 
     it "raises on a nil secret key" do
-      expect { Crypto::Box.new(alicepk, nil) }.to raise_error(Crypto::LengthError, /Private key was nil \(Expected 32\)/)
+      expect { Crypto::Box.new(alicepk, nil) }.to raise_error(Crypto::LengthError, /Private key was 0 bytes \(Expected 32\)/)
     end
 
     it "raises on an invalid secret key" do

data/spec/rbnacl/hash_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 
 describe Crypto::Hash do
   context "sha256" do
-    let(:reference_string)      { hex2bytes Crypto::TestVectors[:sha256_message] }
-    let(:reference_string_hash) { hex2bytes Crypto::TestVectors[:sha256_digest] }
+    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 }
@@ -24,6 +24,10 @@ describe Crypto::Hash do
     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
     end
+
+    it "doesn't raise on a null byte" do
+      expect { Crypto::Hash.sha256("\0") }.to_not  raise_error(/ArgumentError: string contains null byte/)
+    end
   end
 
   context "sha512" do
@@ -48,5 +52,9 @@ describe Crypto::Hash do
     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
     end
+
+    it "doesn't raise on a null byte" do
+      expect { Crypto::Hash.sha512("\0") }.to_not  raise_error(/ArgumentError: string contains null byte/)
+    end
   end
 end

data/spec/rbnacl/hmac/sha256_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 describe Crypto::HMAC::SHA256 do
-  let(:hex_tag) { Crypto::TestVectors[:auth_hmacsha256] }
+  let(:hex_tag) { hex_vector :auth_hmacsha256 }
 
   include_examples "authenticator"
 end

data/spec/rbnacl/hmac/sha512256_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 describe Crypto::HMAC::SHA512256 do
-  let(:hex_tag) { Crypto::TestVectors[:auth_hmacsha512256] }
+  let(:hex_tag) { hex_vector :auth_hmacsha512256 }
 
   include_examples "authenticator"
 end

data/spec/rbnacl/keys/private_key_spec.rb

@@ -2,12 +2,12 @@
 require 'spec_helper'
 
 describe Crypto::PrivateKey do
-  let(:bobsk)     { Crypto::TestVectors[:bob_private] }
-  let(:bobsk_raw) { Crypto::Encoder[:hex].decode(bobsk) }
-  let(:bobpk)     { Crypto::TestVectors[:bob_public] }
-  let(:bobpk_raw) { Crypto::Encoder[:hex].decode(bobpk) }
+  let(:bobsk)     { test_vector :bob_private }
+  let(:bobsk_hex) { bytes2hex bobsk }
+  let(:bobpk)     { test_vector :bob_public }
+  let(:bobpk_hex) { bytes2hex bobpk }
 
-  subject { Crypto::PrivateKey.new(bobsk, :hex) }
+  subject { Crypto::PrivateKey.new(bobsk) }
 
   context "generate" do
     let(:secret_key) { Crypto::PrivateKey.generate }
@@ -23,10 +23,10 @@ describe Crypto::PrivateKey do
 
   context "new" do
     it "accepts a valid key" do
-      expect { Crypto::PrivateKey.new(bobsk_raw) }.not_to raise_error
+      expect { Crypto::PrivateKey.new(bobsk) }.not_to raise_error
     end
     it "accepts a hex encoded key" do
-      expect { Crypto::PrivateKey.new(bobsk, :hex) }.not_to raise_error
+      expect { Crypto::PrivateKey.new(bobsk_hex, :hex) }.not_to raise_error
     end
     it "rejects a nil key" do
       expect { Crypto::PrivateKey.new(nil) }.to raise_error(ArgumentError)
@@ -41,28 +41,28 @@ describe Crypto::PrivateKey do
       subject.public_key.should be_a Crypto::PublicKey
     end
     it "returns the correct public key" do
-      subject.public_key.to_s(:hex).should eql bobpk
+      subject.public_key.to_s(:hex).should eql bobpk_hex
     end
   end
 
   context "#to_bytes" do
     it "returns the bytes of the key" do
-      subject.to_s(:hex).should eq bobsk
+      subject.to_s(:hex).should eq bobsk_hex
     end
   end
 
   context "#to_s" do
     it "returns the bytes of the key hex encoded" do
-      subject.to_s(:hex).should eq bobsk
+      subject.to_s(:hex).should eq bobsk_hex
     end
     it "returns the raw bytes of the key" do
-      subject.to_bytes.should eq bobsk_raw
+      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, :hex) }
+    let(:other_key) { described_class.new(bobpk) }
   end
 end