rbnacl 1.1.0 → 2.0.0

data/lib/rbnacl/hash/blake2b.rb

@@ -0,0 +1,64 @@
+# encoding: binary
+module RbNaCl
+  module Hash
+    # The Blake2b hash function
+    #
+    # Blake2b is based on Blake, a SHA3 finalist which was snubbed in favor of
+    # Keccak, a much slower hash function but one sufficiently different from
+    # SHA2 to let the SHA3 judges panel sleep easy. Back in the real world,
+    # it'd be great if we can calculate hashes quickly if possible.
+    #
+    # Blake2b provides for up to 64-bit digests and also supports a keyed mode
+    # similar to HMAC
+    class Blake2b
+      extend Sodium
+
+      sodium_type      :generichash
+      sodium_primitive :blake2b
+      sodium_constant  :BYTES_MIN
+      sodium_constant  :BYTES_MAX
+      sodium_constant  :KEYBYTES_MIN
+      sodium_constant  :KEYBYTES_MAX
+
+      sodium_function  :generichash_blake2b,
+                       :crypto_generichash_blake2b,
+                       [:pointer, :ulong_long, :pointer, :ulong_long, :pointer, :ulong_long]
+
+      # Create a new Blake2b hash object
+      #
+      # @param [Hash] opts Blake2b configuration
+      # @option opts [String]  :key for Blake2b keyed mode
+      # @option opts [Integer] :digest_size size of output digest in bytes
+      #
+      # @raise [RbNaCl::LengthError] Invalid length specified for one or more options
+      #
+      # @return [RbNaCl::Hash::Blake2b] A Blake2b hasher object
+      def initialize(opts = {})
+        @key = opts.fetch(:key, nil)
+
+        if @key
+          @key_size = @key.bytesize
+          raise LengthError, "key too short" if @key_size < KEYBYTES_MIN
+          raise LengthError, "key too long"  if @key_size > KEYBYTES_MAX
+        else
+          @key_size = 0
+        end
+
+        @digest_size = opts.fetch(:digest_size, BYTES_MAX)
+        raise LengthError, "digest size too short" if @digest_size < BYTES_MIN
+        raise LengthError, "digest size too long"  if @digest_size > BYTES_MAX
+      end
+
+      # Calculate a Blake2b digest
+      #
+      # @param [String] message Message to be hashed
+      #
+      # @return [String] Blake2b digest of the string as raw bytes
+      def digest(message)
+        digest = Util.zeros(@digest_size)
+        self.class.generichash_blake2b(digest, @digest_size, message, message.bytesize, @key, @key_size) || raise(CryptoError, "Hashing failed!")
+        digest
+      end
+    end
+  end
+end

data/lib/rbnacl/hash/sha256.rb

@@ -0,0 +1,15 @@
+# encoding: binary
+module RbNaCl
+  module Hash
+    # Provides a binding for the SHA256 function in libsodium
+    module SHA256
+      extend Sodium
+      sodium_type      :hash
+      sodium_primitive :sha256
+      sodium_constant  :BYTES
+      sodium_function  :hash_sha256,
+        :crypto_hash_sha256,
+        [:pointer, :pointer, :ulong_long]
+    end
+  end
+end

data/lib/rbnacl/hash/sha512.rb

@@ -0,0 +1,15 @@
+# encoding: binary
+module RbNaCl
+  module Hash
+    # Provides the binding for the SHA512 hash function
+    module SHA512
+      extend Sodium
+      sodium_type      :hash
+      sodium_primitive :sha512
+      sodium_constant  :BYTES
+      sodium_function  :hash_sha512,
+                       :crypto_hash_sha512,
+                       [:pointer, :pointer, :ulong_long]
+    end
+  end
+end

data/lib/rbnacl/hash.rb

@@ -1,5 +1,5 @@
 # encoding: binary
-module Crypto
+module RbNaCl
   # Cryptographic hash functions
   #
   # Cryptographic hash functions take a variable length message and compute a
@@ -11,38 +11,54 @@ module Crypto
   # there is no secret involved in the hashing, so anyone can create the hash of
   # a given message.
   #
-  # RbNaCl provides the SHA-256 and SHA-512 hash functions.
+  # RbNaCl provides the SHA-256,SHA-512 as well as the Blake2b hash functions.
   module Hash
     # Returns the SHA-256 hash of the given data
     #
     # There's no streaming done, just pass in the data and be done with it.
     #
-    # @param [String] data The data, as a collection of bytes
-    # @param [#to_sym] encoding Encoding of the returned hash.
+    # @param [#to_str] data The data, as a collection of bytes
     #
     # @raise [CryptoError] If the hashing fails for some reason.
     #
     # @return [String] The SHA-256 hash as raw bytes (Or encoded as per the second argument)
-    def self.sha256(data, encoding = :raw)
-      hash = Util.zeros(NaCl::SHA256BYTES)
-      NaCl.crypto_hash_sha256(hash, data, data.bytesize) || raise(CryptoError, "Hashing failed!")
-      Encoder[encoding].encode(hash)
+    def self.sha256(data)
+      data   = data.to_str
+      digest = Util.zeros(SHA256::BYTES)
+      SHA256.hash_sha256(digest, data, data.bytesize) || raise(CryptoError, "Hashing failed!")
+      digest
     end
 
     # Returns the SHA-512 hash of the given data
     #
     # There's no streaming done, just pass in the data and be done with it.
     #
-    # @param [String] data The data, as a collection of bytes
-    # @param [#to_sym] encoding Encoding of the returned hash.
+    # @param [#to_str] data The data, as a collection of bytes
     #
     # @raise [CryptoError] If the hashing fails for some reason.
     #
     # @return [String] The SHA-512 hash as raw bytes (Or encoded as per the second argument)
-    def self.sha512(data, encoding = :raw)
-      hash = Util.zeros(NaCl::SHA512BYTES)
-      NaCl.crypto_hash_sha512(hash, data, data.bytesize) || raise(CryptoError, "Hashing failed!")
-      Encoder[encoding].encode(hash)
+    def self.sha512(data)
+      digest = Util.zeros(SHA512::BYTES)
+      SHA512.hash_sha512(digest, data, data.bytesize) || raise(CryptoError, "Hashing failed!")
+      digest
+    end
+
+    # Returns the Blake2b hash of the given data
+    #
+    # There's no streaming done, just pass in the data and be done with it.
+    # This method returns a 64-byte hash by default.
+    #
+    # @param [String] data The data, as a collection of bytes
+    # @option options [Fixnum] digest_size Size in bytes (1-64, default 64)
+    # @option options [String] key 64-byte (or less) key for keyed mode
+    #
+    # @raise [CryptoError] If the hashing fails for some reason.
+    #
+    # @return [String] The blake2b hash as raw bytes (Or encoded as per the second argument)
+    def self.blake2b(data, options = {})
+      key         = options[:key]
+      Blake2b.new(options).digest(data)
     end
   end
 end

data/lib/rbnacl/hmac/sha256.rb

@@ -1,9 +1,9 @@
 # encoding: binary
-module Crypto
+module RbNaCl
   module HMAC
     # Computes an authenticator as HMAC-SHA-256
     #
-    # The authenticator can be used at a later time to verify the provenence of
+    # The authenticator can be used at a later time to verify the provenance of
     # the message by recomputing the HMAC over the message and then comparing it to
     # the provided authenticator.  The class provides methods for generating
     # signatures and also has a constant-time implementation for checking them.
@@ -13,26 +13,28 @@ module Crypto
     #
     # @see http://nacl.cr.yp.to/auth.html
     class SHA256 < Auth
-      # Number of bytes in a valid key
-      KEYBYTES = NaCl::HMACSHA256_KEYBYTES
+      extend Sodium
 
-      # Number of bytes in a valid authenticator
-      BYTES = NaCl::HMACSHA256_BYTES
-
-      # The crypto primitive for the HMAC::SHA256 class
-      #
-      # @return [Symbol] The primitive used
-      def self.primitive
-        :hmac_sha256
-      end
+      sodium_type      :auth
+      sodium_primitive :hmacsha256
+      sodium_constant  :BYTES
+      sodium_constant  :KEYBYTES
 
+      sodium_function  :auth_hmacsha256,
+                       :crypto_auth_hmacsha256,
+                       [:pointer, :pointer, :ulong_long, :pointer]
+      
+      sodium_function  :auth_hmacsha256_verify,
+                       :crypto_auth_hmacsha256_verify,
+                       [:pointer, :pointer, :ulong_long, :pointer]
+      
       private
-      def compute_authenticator(message, authenticator)
-        NaCl.crypto_auth_hmacsha256(authenticator, message, message.bytesize, key)
+      def compute_authenticator(authenticator, message)
+        self.class.auth_hmacsha256(authenticator, message, message.bytesize, key)
       end
 
-      def verify_message(message, authenticator)
-        NaCl.crypto_auth_hmacsha256_verify(authenticator, message, message.bytesize, key)
+      def verify_message(authenticator, message)
+        self.class.auth_hmacsha256_verify(authenticator, message, message.bytesize, key)
       end
     end
   end

data/lib/rbnacl/hmac/sha512256.rb

@@ -1,9 +1,9 @@
 # encoding: binary
-module Crypto
+module RbNaCl
   module HMAC
     # Computes an authenticator as HMAC-SHA-512 truncated to 256-bits
     #
-    # The authenticator can be used at a later time to verify the provenence of
+    # The authenticator can be used at a later time to verify the provenance of
     # the message by recomputing the HMAC over the message and then comparing it to
     # the provided authenticator.  The class provides methods for generating
     # signatures and also has a constant-time implementation for checking them.
@@ -13,30 +13,29 @@ module Crypto
     #
     # @see http://nacl.cr.yp.to/auth.html
     class SHA512256 < Auth
-      # Number of bytes in a valid key
-      KEYBYTES = NaCl::HMACSHA512256_KEYBYTES
+      extend Sodium
 
-      # Number of bytes in a valid authenticator
-      BYTES = NaCl::HMACSHA512256_BYTES
+      sodium_type      :auth
+      sodium_primitive :hmacsha512256
+      sodium_constant  :BYTES
+      sodium_constant  :KEYBYTES
+
+      sodium_function  :auth_hmacsha512256,
+                       :crypto_auth_hmacsha512256,
+                       [:pointer, :pointer, :ulong_long, :pointer]
       
-      # The crypto primitive for the HMAC::SHA512256 class
-      #
-      # @return [Symbol] The primitive used
-      def self.primitive
-        :hmac_sha512256
-      end
+      sodium_function  :auth_hmacsha512256_verify,
+                       :crypto_auth_hmacsha512256_verify,
+                       [:pointer, :pointer, :ulong_long, :pointer]
 
       private
-      def compute_authenticator(message, authenticator)
-        NaCl.crypto_auth_hmacsha512256(authenticator, message, message.bytesize, key)
+      def compute_authenticator(authenticator, message)
+        self.class.auth_hmacsha512256(authenticator, message, message.bytesize, key)
       end
 
-      def verify_message(message, authenticator)
-        NaCl.crypto_auth_hmacsha512256_verify(authenticator, message, message.bytesize, key)
+      def verify_message(authenticator, message)
+        self.class.auth_hmacsha512256_verify(authenticator, message, message.bytesize, key)
       end
     end
-
-    # TIMTOWTDI!
-    SHA512 = SHA512256
   end
 end

data/lib/rbnacl/init.rb

@@ -0,0 +1,10 @@
+# encoding: binary
+module RbNaCl
+  # Defines the libsodium init function
+  module Init
+    extend FFI::Library
+    ffi_lib 'sodium'
+
+    attach_function :sodium_init, [], :int
+  end
+end

data/lib/rbnacl/{keys/key_comparator.rb → key_comparator.rb}

@@ -1,5 +1,5 @@
 # encoding: binary
-module Crypto
+module RbNaCl
   # Implements comparisons of keys
   #
   # This permits both timing invariant equality tests, as well as

data/lib/rbnacl/{auth/one_time.rb → one_time_auths/poly1305.rb}

@@ -1,9 +1,9 @@
 # encoding: binary
-module Crypto
-  class Auth
+module RbNaCl
+  module OneTimeAuths
     # Computes an authenticator using poly1305
     #
-    # The authenticator can be used at a later time to verify the provenence of
+    # The authenticator can be used at a later time to verify the provenance of
     # the message by recomputing the tag over the message and then comparing it to
     # the provided authenticator.  The class provides methods for generating
     # signatures and also has a constant-time implementation for checking them.
@@ -17,27 +17,29 @@ module Crypto
     # can also create them.
     #
     # @see http://nacl.cr.yp.to/onetimeauth.html
-    class OneTime < self
-      # Number of bytes in a valid key
-      KEYBYTES = NaCl::ONETIME_KEYBYTES
+    class Poly1305 < Auth
+      extend Sodium
 
-      # Number of bytes in a valid authenticator
-      BYTES = NaCl::ONETIME_BYTES
-      
-      # The crypto primitive for the Auth::OneTime class
-      #
-      # @return [Symbol] The primitive used
-      def self.primitive
-        :poly_1305
-      end
+      sodium_type      :onetimeauth
+      sodium_primitive :poly1305
+      sodium_constant  :BYTES
+      sodium_constant  :KEYBYTES
+
+      sodium_function :onetimeauth_poly1305,
+                      :crypto_onetimeauth_poly1305,
+                      [:pointer, :pointer, :ulong_long, :pointer]
+
+      sodium_function :onetimeauth_poly1305_verify,
+                      :crypto_onetimeauth_poly1305_verify,
+                      [:pointer, :pointer, :ulong_long, :pointer]
 
       private
-      def compute_authenticator(message, authenticator)
-        NaCl.crypto_auth_onetime(authenticator, message, message.bytesize, key)
+      def compute_authenticator(authenticator, message)
+        self.class.onetimeauth_poly1305(authenticator, message, message.bytesize, key)
       end
 
-      def verify_message(message, authenticator)
-        NaCl.crypto_auth_onetime_verify(authenticator, message, message.bytesize, key)
+      def verify_message(authenticator, message)
+        self.class.onetimeauth_poly1305_verify(authenticator, message, message.bytesize, key)
       end
 
     end

data/lib/rbnacl/rake_tasks.rb

@@ -3,7 +3,8 @@ require 'rake'
 require 'rake/clean'
 require 'digest/sha2'
 
-LIBSODIUM_VERSION = "0.2"
+LIBSODIUM_VERSION = "0.4.5"
+LIBSODIUM_DIGEST  = "7ad5202df53eeac0eb29b064ae5d05b65d82b2fc1c082899c9c6a09b0ee1ac32"
 
 def sh_hidden(command)
   STDERR.puts("*** Executing: #{command}")
@@ -19,17 +20,17 @@ end
 libsodium_tarball = "libsodium-#{LIBSODIUM_VERSION}.tar.gz"
 
 file libsodium_tarball do
-  sh "curl -O http://download.dnscrypt.org/libsodium/releases/libsodium-#{LIBSODIUM_VERSION}.tar.gz"
+  sh "curl -L -O https://github.com/jedisct1/libsodium/releases/download/#{LIBSODIUM_VERSION}/#{libsodium_tarball}"
 
   digest = Digest::SHA256.hexdigest(File.read(libsodium_tarball))
-  if digest != "e99a6b69adc080a5acf6b8a49fdc74b61d6f3579b590e85c93446a8325dde100"
+  if digest != LIBSODIUM_DIGEST
     rm libsodium_tarball
-    raise "#{libsodium_tarball} failed checksum!"
+    raise "#{libsodium_tarball} failed checksum! Got #{digest}"
   end
 end
 
-file "libsodium" => "libsodium-#{LIBSODIUM_VERSION}.tar.gz" do
-  sh "tar xzf libsodium-#{LIBSODIUM_VERSION}.tar.gz"
+file "libsodium" => libsodium_tarball do
+  sh "tar -zxf #{libsodium_tarball}"
   mv "libsodium-#{LIBSODIUM_VERSION}", "libsodium"
 end
 

data/lib/rbnacl/random.rb

@@ -1,18 +1,27 @@
+require 'thread'
+
 # encoding: binary
-module Crypto
+module RbNaCl
   # Functions for random number generation
   #
   # This uses the underlying source of random number generation on the OS, so
   # /dev/urandom on UNIX-like systems, and the MS crypto providor on windows.
   module Random
+    extend Sodium
+
+    @mutex = Mutex.new
+
+    sodium_function :c_random_bytes,
+                    :randombytes_buf,
+                    [:pointer, :ulong_long]
     # Returns a string of random bytes
     #
     # @param [Integer] n number of random bytes desired
     #
     # @return [String] random bytes.
     def self.random_bytes(n=32)
-      buf = Crypto::Util.zeros(n)
-      NaCl.random_bytes(buf, n)
+      buf = RbNaCl::Util.zeros(n)
+      @mutex.synchronize { c_random_bytes(buf, n) }
       buf
     end
   end

data/lib/rbnacl/random_nonce_box.rb

@@ -1,15 +1,15 @@
 # encoding: binary
 require 'forwardable'
-module Crypto
+module RbNaCl
   # The simplest nonce strategy that could possibly work
   #
   # This class implements the simplest possible nonce generation strategy to
-  # wrap a Crypto::Box or Crypto::SecretBox.  A 24-byte random nonce is used
+  # wrap a RbNaCl::Box or RbNaCl::SecretBox.  A 24-byte random nonce is used
   # for the encryption and is prepended to the message.  When it is time to
   # open the box, the message is split into nonce and ciphertext, and then the
   # box is decrypted.
   #
-  # Thanks to the size of the nonce, the chance of a collision is neglible.  For
+  # Thanks to the size of the nonce, the chance of a collision is negligible.  For
   # example, after encrypting 2^64 messages, the odds of their having been
   # repeated nonce is approximately 2^-64.  As an additional convenience, the
   # ciphertexts may be encoded or decoded by any of the encoders implemented in
@@ -31,10 +31,6 @@ module Crypto
     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
     #
     # @param box [SecretBox, Box] the SecretBox or Box to use.
@@ -75,14 +71,14 @@ module Crypto
     # the nonce prepended.  Optionally encodes the message using an encoder.
     #
     # @param message [String] The message to encrypt
-    # @param encoding [Symbol] Optional encoding for the returned ciphertext
     #
     # @return [String] The enciphered message
-    def box(message, encoding = :raw)
+    def box(message)
       nonce = generate_nonce
       cipher_text = @box.box(nonce, message)
-      Encoder[encoding].encode(nonce + cipher_text)
+      nonce + cipher_text
     end
+    alias encrypt box
 
     # Decrypts the ciphertext with a random nonce
     #
@@ -90,16 +86,15 @@ module Crypto
     # front and uses this to decrypt.  Returns the message.
     #
     # @param enciphered_message [String] The message to decrypt.
-    # @param encoding [Symbol] Optional decoding for the returned ciphertext
     #
     # @raise [CryptoError] If the message has been tampered with.
     #
     # @return [String] The decoded message
-    def open(enciphered_message, encoding = :raw)
-      decoded = Encoder[encoding].decode(enciphered_message)
-      nonce, ciphertext = *extract_nonce(decoded)
+    def open(enciphered_message)
+      nonce, ciphertext = extract_nonce(enciphered_message.to_s)
       @box.open(nonce, ciphertext)
     end
+    alias decrypt open
 
     private
     def generate_nonce

data/lib/rbnacl/secret_boxes/xsalsa20poly1305.rb

@@ -0,0 +1,125 @@
+# encoding: binary
+module RbNaCl
+  module SecretBoxes
+    # The SecretBox class boxes and unboxes messages
+    #
+    # This class uses the given secret key to encrypt and decrypt messages.
+    #
+    # It is VITALLY important that the nonce is a nonce, i.e. it is a number used
+    # only once for any given pair of keys.  If you fail to do this, you
+    # compromise the privacy of the messages encrypted. Give your nonces a
+    # different prefix, or have one side use an odd counter and one an even counter.
+    # Just make sure they are different.
+    #
+    # The ciphertexts generated by this class include a 16-byte authenticator which
+    # is checked as part of the decryption.  An invalid authenticator will cause
+    # the unbox function to raise.  The authenticator is not a signature.  Once
+    # you've looked in the box, you've demonstrated the ability to create
+    # arbitrary valid messages, so messages you send are repudiable.  For
+    # non-repudiable messages, sign them before or after encryption.
+    class XSalsa20Poly1305
+      extend Sodium
+
+      sodium_type      :secretbox
+      sodium_primitive :xsalsa20poly1305
+      sodium_constant  :KEYBYTES
+      sodium_constant  :NONCEBYTES
+      sodium_constant  :ZEROBYTES
+      sodium_constant  :BOXZEROBYTES
+
+      sodium_function :secretbox_xsalsa20poly1305,
+                      :crypto_secretbox_xsalsa20poly1305,
+                      [:pointer, :pointer, :ulong_long, :pointer, :pointer]
+
+      sodium_function :secretbox_xsalsa20poly1305_open,
+                      :crypto_secretbox_xsalsa20poly1305_open,
+                      [:pointer, :pointer, :ulong_long, :pointer, :pointer]
+
+      # Create a new SecretBox
+      #
+      # Sets up the Box with a secret key fro encrypting and decrypting messages.
+      #
+      # @param key [String] The key to encrypt and decrypt with
+      #
+      # @raise [RbNaCl::LengthError] on invalid keys
+      #
+      # @return [RbNaCl::SecretBox] The new Box, ready to use
+      def initialize(key)
+        @key = Util.check_string(key, KEYBYTES, "Secret key")
+      end
+
+      # Encrypts a message
+      #
+      # Encrypts the message with the given nonce to the key set up when
+      # initializing the class.  Make sure the nonce is unique for any given
+      # key, or you might as well just send plain text.
+      #
+      # This function takes care of the padding required by the NaCL C API.
+      #
+      # @param nonce [String] A 24-byte string containing the nonce.
+      # @param message [String] The message to be encrypted.
+      #
+      # @raise [RbNaCl::LengthError] If the nonce is not valid
+      #
+      # @return [String] The ciphertext without the nonce prepended (BINARY encoded)
+      def box(nonce, message)
+        Util.check_length(nonce, nonce_bytes, "Nonce")
+        msg = Util.prepend_zeros(ZEROBYTES, message)
+        ct  = Util.zeros(msg.bytesize)
+
+        self.class.secretbox_xsalsa20poly1305(ct, msg, msg.bytesize, nonce, @key) || raise(CryptoError, "Encryption failed")
+        Util.remove_zeros(BOXZEROBYTES, ct)
+      end
+      alias encrypt box
+
+      # Decrypts a ciphertext
+      #
+      # Decrypts the ciphertext with the given nonce using the key setup when
+      # initializing the class.
+      #
+      # This function takes care of the padding required by the NaCL C API.
+      #
+      # @param nonce [String] A 24-byte string containing the nonce.
+      # @param ciphertext [String] The message to be decrypted.
+      #
+      # @raise [RbNaCl::LengthError] If the nonce is not valid
+      # @raise [RbNaCl::CryptoError] If the ciphertext cannot be authenticated.
+      #
+      # @return [String] The decrypted message (BINARY encoded)
+      def open(nonce, ciphertext)
+        Util.check_length(nonce, nonce_bytes, "Nonce")
+        ct = Util.prepend_zeros(BOXZEROBYTES, ciphertext)
+        message  = Util.zeros(ct.bytesize)
+
+        self.class.secretbox_xsalsa20poly1305_open(message, ct, ct.bytesize, nonce, @key) || raise(CryptoError, "Decryption failed. Ciphertext failed verification.")
+        Util.remove_zeros(ZEROBYTES, message)
+      end
+      alias decrypt open
+
+      # 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
+end