ffi-libsodium 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acfdde4dacfa8c79dbb8c79cc752450016d0b38a
-  data.tar.gz: 1ad28c3ae30992f427b1c57ee39d99684457f5d3
+  metadata.gz: f69721c907579641680a434287394a6bf4167701
+  data.tar.gz: aa8032ace5a3f2cd8ac8a7e664c78da9b87605ab
 SHA512:
-  metadata.gz: a1ab577ea19b1ae9b5ca0ac4225bbe5cd5192f86d5748f26e501f80d4b082061aa43add2b079956df3ca24e08b5429c58f2259f00c7bdf6206b3e33c9bddf6dd
-  data.tar.gz: e925c7e55392c1c321b31ec27640a05a9361f763b40a0dccd2d8f5847ca5b19d138f01b00a580c0c2ee6e6b2daa6c41ae60093f113b232e1b359e3ea5d86a471
+  metadata.gz: 258b1c21db7bf8e33097284cce68b7ee769336ce68c6522af170dd3026540ccddc3ea9bf62c0d8fab34d34932c76d92cee5454955b77db63c8d69a61667a8bc0
+  data.tar.gz: 3b4c31224024845e5aa13c6e80b4844834b7760015ee328c231d586170f5d2edb9d22756da7bb8f5dfcd5b95cdf764af7794a2d56d4145532b45c9d340bd9026

data/lib/crypto/aead/chacha20_poly1305.rb

@@ -54,25 +54,24 @@ module Crypto
       end
 
       def decrypt(ciphertext, additional_data, nonce, key, encoding = nil)
-        ciphertext_len = get_size(ciphertext)
-        if (decrypted_len = ciphertext_len - ABYTES) >= 0
-          check_length(nonce, NPUBBYTES, :Nonce)
-          check_length(key, KEYBYTES, :SecretKey)
-
-          decrypted = zeros(decrypted_len)
-          key.readonly if key.is_a?(Sodium::SecretBuffer)
-          if crypto_aead_chacha20poly1305_decrypt(decrypted, nil, nil, ciphertext, ciphertext_len, additional_data, get_size(additional_data), nonce, key) == 0
-            if encoding
-              decrypted.force_encoding(encoding)
-            else
-              decrypted
-            end
-          else
-            raise Sodium::CryptoError, "Message forged", caller
-          end
-        else
+        if (decrypted_len = (ciphertext_len = get_size(ciphertext)) - ABYTES) < 0
           fail Sodium::LengthError, "Ciphertext is too short", caller
         end
+
+        check_length(nonce, NPUBBYTES, :Nonce)
+        check_length(key, KEYBYTES, :SecretKey)
+
+        decrypted = zeros(decrypted_len)
+        key.readonly if key.is_a?(Sodium::SecretBuffer)
+        if crypto_aead_chacha20poly1305_decrypt(decrypted, nil, nil, ciphertext, ciphertext_len, additional_data, get_size(additional_data), nonce, key) == -1
+          raise Sodium::CryptoError, "Message forged", caller
+        end
+
+        if encoding
+          decrypted.force_encoding(encoding)
+        end
+
+        decrypted
       ensure
         key.noaccess if key.is_a?(Sodium::SecretBuffer)
       end

data/lib/crypto/box.rb

@@ -25,11 +25,14 @@ module Crypto
     NONCEBYTES      = noncebytes.freeze
     MACBYTES        = macbytes.freeze
 
-    attach_function :crypto_box_keypair,      [:buffer_out, :buffer_out],             :int
-    attach_function :crypto_box_seed_keypair, [:buffer_out, :buffer_out, :buffer_in], :int
+    attach_function :crypto_box_keypair,        [:buffer_out, :buffer_out],             :int
+    attach_function :crypto_box_seed_keypair,   [:buffer_out, :buffer_out, :buffer_in], :int
 
-    attach_function :crypto_box_easy,         [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in, :buffer_in], :int
-    attach_function :crypto_box_open_easy,    [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in, :buffer_in], :int
+    attach_function :crypto_box_easy,           [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in, :buffer_in], :int
+    attach_function :crypto_box_open_easy,      [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in, :buffer_in], :int
+
+    attach_function :crypto_box_detached,       [:buffer_out, :buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in, :buffer_in],  :int
+    attach_function :crypto_box_open_detached,  [:buffer_out, :buffer_in, :buffer_in, :ulong_long, :buffer_in, :buffer_in, :buffer_in],   :int
 
     module_function
 
@@ -104,15 +107,15 @@ module Crypto
 
       decrypted = zeros(ciphertext_len - MACBYTES)
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
-      if crypto_box_open_easy(decrypted, ciphertext, ciphertext_len, nonce, public_key, secret_key) == 0
-        if encoding
-          decrypted.force_encoding(encoding)
-        else
-          decrypted
-        end
-      else
+      if crypto_box_open_easy(decrypted, ciphertext, ciphertext_len, nonce, public_key, secret_key) == -1
         raise Sodium::CryptoError, "Message forged", caller
       end
+
+      if encoding
+        decrypted.force_encoding(encoding)
+      end
+
+      decrypted
     ensure
       secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
     end
@@ -128,7 +131,7 @@ module Crypto
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
       crypto_box_easy(message, message, message_len, nonce, public_key, secret_key)
 
-      message.force_encoding(Encoding::ASCII_8BIT)
+      message
     ensure
       secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
     end
@@ -136,25 +139,95 @@ module Crypto
     def open!(data, nonce, public_key, secret_key, encoding = nil)
       ciphertext = String(data)
       ciphertext_len = ciphertext.bytesize
-      if (message_len = ciphertext_len - MACBYTES) >= 0
-        check_length(nonce, NONCEBYTES, :Nonce)
-        check_length(public_key, PUBLICKEYBYTES, :PublicKey)
-        check_length(secret_key, SECRETKEYBYTES, :SecretKey)
-
-        secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
-        if crypto_box_open_easy(ciphertext, ciphertext, ciphertext_len, nonce, public_key, secret_key) == 0
-          ciphertext.slice!(message_len..-1)
-          if encoding
-            ciphertext.force_encoding(encoding)
-          else
-            ciphertext
-          end
-        else
-          raise Sodium::CryptoError, "Message forged", caller
-        end
-      else
+      if (message_len = ciphertext_len - MACBYTES) < 0
         fail Sodium::LengthError, "Ciphertext is too short", caller
       end
+
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(public_key, PUBLICKEYBYTES, :PublicKey)
+      check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      if crypto_box_open_easy(ciphertext, ciphertext, ciphertext_len, nonce, public_key, secret_key) == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      ciphertext.slice!(message_len..-1)
+      if encoding
+        ciphertext.force_encoding(encoding)
+      end
+
+      ciphertext
+    ensure
+      secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def detached(message, nonce, public_key, secret_key)
+      message_len = get_size(message)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(public_key, PUBLICKEYBYTES, :PublicKey)
+      check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+      ciphertext = zeros(message_len)
+      mac = zeros(MACBYTES)
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      crypto_box_detached(ciphertext, mac, message, message_len, nonce, public_key, secret_key)
+      [ciphertext, mac]
+    ensure
+      secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def open_detached(ciphertext, mac, nonce, public_key, secret_key, encoding = nil)
+      ciphertext_len = get_size(ciphertext)
+      check_length(mac, MACBYTES, :Mac)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(public_key, PUBLICKEYBYTES, :PublicKey)
+      check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+      decrypted = zeros(ciphertext_len)
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      if crypto_box_open_detached(decrypted, ciphertext, mac, ciphertext_len, nonce, public_key, secret_key) == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      if encoding
+        decrypted.force_encoding(encoding)
+      end
+
+      decrypted
+    ensure
+      secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def detached!(message, nonce, public_key, secret_key)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(public_key, PUBLICKEYBYTES, :PublicKey)
+      check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+      mac = zeros(MACBYTES)
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      crypto_box_detached(message, mac, message, get_size(message), nonce, public_key, secret_key)
+      [message, mac]
+    ensure
+      secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def open_detached!(ciphertext, mac, nonce, public_key, secret_key, encoding = nil)
+      check_length(mac, MACBYTES, :Mac)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(public_key, PUBLICKEYBYTES, :PublicKey)
+      check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      if crypto_box_open_detached(ciphertext, ciphertext, mac, get_size(ciphertext), nonce, public_key, secret_key) == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      if encoding && ciphertext.respond_to?(:force_encoding)
+        ciphertext.force_encoding(encoding)
+      end
+
+      ciphertext
     ensure
       secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
     end

data/lib/crypto/generic_hash.rb

@@ -53,11 +53,11 @@ module Crypto
 
       blake2b = zeros(hash_size)
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      if crypto_generichash(blake2b, hash_size, message, get_size(message), key, key_len) == 0
-        blake2b
-      else
+      if crypto_generichash(blake2b, hash_size, message, get_size(message), key, key_len) == -1
         raise Sodium::CryptoError
       end
+
+      blake2b
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
@@ -71,11 +71,11 @@ module Crypto
 
       state = State.new
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      if crypto_generichash_init(state, key, key_len, hash_size) == 0
-        [state, zeros(hash_size)]
-      else
+      if crypto_generichash_init(state, key, key_len, hash_size) == -1
         raise Sodium::CryptoError
       end
+
+      [state, zeros(hash_size)]
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
@@ -85,11 +85,11 @@ module Crypto
     end
 
     def final(state, blake2b)
-      if crypto_generichash_final(state, blake2b, blake2b.bytesize) == 0
-        blake2b
-      else
+      if crypto_generichash_final(state, blake2b, blake2b.bytesize) == -1
         raise Sodium::CryptoError
       end
+
+      blake2b
     end
   end
 

data/lib/crypto/pw_hash/scrypt_salsa208_sha256.rb

@@ -52,21 +52,21 @@ module Crypto
         check_length(salt, SALTBYTES, :Salt)
 
         out = Sodium::SecretBuffer.new(outlen)
-        if crypto_pwhash_scryptsalsa208sha256(out, outlen, passwd, passwd.bytesize, salt, opslimit, memlimit) == 0
-          out.noaccess
-          out
-        else
+        if crypto_pwhash_scryptsalsa208sha256(out, outlen, passwd, passwd.bytesize, salt, opslimit, memlimit) == -1
           raise NoMemoryError, "Failed to allocate memory max size=#{memlimit} bytes", caller
         end
+
+        out.noaccess
+        out
       end
 
       def str(passwd, opslimit = OPSLIMIT_INTERACTIVE, memlimit = MEMLIMIT_INTERACTIVE)
-        hashed_password = zeros(STRBYTES - 1)
-        if crypto_pwhash_scryptsalsa208sha256_str(hashed_password, passwd, passwd.bytesize, opslimit, memlimit) == 0
-          hashed_password
-        else
+        hashed_password = zeros(STRBYTES)
+        if crypto_pwhash_scryptsalsa208sha256_str(hashed_password, passwd, passwd.bytesize, opslimit, memlimit) == -1
           raise NoMemoryError, "Failed to allocate memory max size=#{memlimit} bytes", caller
         end
+
+        hashed_password.chop!
       end
 
       def str_verify(str, passwd)

data/lib/crypto/secret_box.rb

@@ -24,6 +24,9 @@ module Crypto
     attach_function :crypto_secretbox_easy,       [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in], :int
     attach_function :crypto_secretbox_open_easy,  [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in], :int
 
+    attach_function :crypto_secretbox_detached,       [:buffer_out, :buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in], :int
+    attach_function :crypto_secretbox_open_detached,  [:buffer_out, :buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in], :int
+
     module_function
 
     def nonce
@@ -51,15 +54,15 @@ module Crypto
 
       decrypted = zeros(ciphertext_len - MACBYTES)
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      if crypto_secretbox_open_easy(decrypted, ciphertext, ciphertext_len, nonce, key) == 0
-        if encoding
-          decrypted.force_encoding(encoding)
-        else
-          decrypted
-        end
-      else
+      if crypto_secretbox_open_easy(decrypted, ciphertext, ciphertext_len, nonce, key) == -1
         raise Sodium::CryptoError, "Message forged", caller
       end
+
+      if encoding
+        decrypted.force_encoding(encoding)
+      end
+
+      decrypted
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
@@ -81,25 +84,93 @@ module Crypto
 
     def open!(data, nonce, key, encoding = nil)
       ciphertext = String(data)
-      ciphertext_len = ciphertext.bytesize
-      if (message_len = ciphertext_len - MACBYTES) >= 0
-        check_length(nonce, NONCEBYTES, :Nonce)
-        check_length(key, KEYBYTES, :SecretKey)
-
-        key.readonly if key.is_a?(Sodium::SecretBuffer)
-        if crypto_secretbox_open_easy(ciphertext, ciphertext, ciphertext_len, nonce, key) == 0
-          ciphertext.slice!(message_len..-1)
-          if encoding
-            ciphertext.force_encoding(encoding)
-          else
-            ciphertext
-          end
-        else
-          raise Sodium::CryptoError, "Message forged", caller
-        end
-      else
+
+      if (message_len = (ciphertext_len = ciphertext.bytesize) - MACBYTES) < 0
         fail Sodium::LengthError, "Ciphertext is too short", caller
       end
+
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      if crypto_secretbox_open_easy(ciphertext, ciphertext, ciphertext_len, nonce, key) == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      ciphertext.slice!(message_len..-1)
+      if encoding
+        ciphertext.force_encoding(encoding)
+      end
+
+      ciphertext
+    ensure
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def detached(message, nonce, key)
+      message_len = get_size(message)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      ciphertext = zeros(message_len)
+      mac = zeros(MACBYTES)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      crypto_secretbox_easy(ciphertext, mac, message, message_len, nonce, key)
+
+      [ciphertext, mac]
+    ensure
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def open_detached(ciphertext, mac, nonce, key, encoding = nil)
+      ciphertext_len = get_size(ciphertext)
+      check_length(mac, MACBYTES, :Mac)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      decrypted = zeros(ciphertext_len)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      if crypto_secretbox_open_easy(decrypted, ciphertext, mac, ciphertext_len, nonce, key) == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      if encoding
+        decrypted.force_encoding(encoding)
+      end
+
+      decrypted
+    ensure
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def detached!(message, nonce, key)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      mac = zeros(MACBYTES)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      crypto_secretbox_easy(message, message, mac, get_size(message), nonce, key)
+
+      [message, mac]
+    ensure
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def open_detached!(ciphertext, mac, nonce, key, encoding = nil)
+      check_length(mac, MACBYTES, :Mac)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      if crypto_secretbox_open_easy(ciphertext, ciphertext, mac, get_size(ciphertext), nonce, key) == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      if encoding && ciphertext.respond_to?(:force_encoding)
+        ciphertext.force_encoding(encoding)
+      end
+
+      ciphertext
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end

data/lib/crypto/sign.rb

@@ -28,6 +28,9 @@ module Crypto
     attach_function :crypto_sign,       [:buffer_out, :pointer, :buffer_in, :ulong_long, :buffer_in],  :int
     attach_function :crypto_sign_open,  [:buffer_out, :pointer, :buffer_in, :ulong_long, :buffer_in],  :int
 
+    attach_function :crypto_sign_detached,        [:buffer_out, :pointer, :buffer_in, :ulong_long, :buffer_in], :int
+    attach_function :crypto_sign_verify_detached, [:buffer_in, :buffer_in, :ulong_long, :buffer_in],            :int
+
     module_function
 
     def keypair
@@ -93,11 +96,29 @@ module Crypto
 
       unsealed_message = zeros(sealed_message_len - BYTES)
       unsealed_message_len = FFI::MemoryPointer.new(:ulong_long)
-      if crypto_sign_open(unsealed_message, unsealed_message_len, sealed_message, sealed_message_len, public_key) == 0
-        unsealed_message
-      else
+      if crypto_sign_open(unsealed_message, unsealed_message_len, sealed_message, sealed_message_len, public_key) == -1
         raise Sodium::CryptoError, "Incorrect signature", caller
       end
+
+      unsealed_message
+    end
+
+    def detached(message, secret_key)
+      check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+      signature = zeros(BYTES)
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      crypto_sign_detached(signature, nil, message, get_size(message), secret_key)
+
+      signature
+    ensure
+      secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+    end
+
+    def verify_detached(signature, message, public_key)
+      check_length(signature, BYTES, :Signature)
+
+      crypto_sign_verify_detached(signature, message, get_size(message), public_key) == 0
     end
   end
 

data/lib/crypto/sign/ed25519.rb

@@ -22,13 +22,18 @@ module Crypto
 
       attach_function :publickeybytes,  :crypto_sign_ed25519_publickeybytes,  [], :size_t
       attach_function :secretkeybytes,  :crypto_sign_ed25519_secretkeybytes,  [], :size_t
+      attach_function :seedbytes,       :crypto_sign_ed25519_seedbytes,       [], :size_t
 
       PUBLICKEYBYTES  = publickeybytes.freeze
       SECRETKEYBYTES  = secretkeybytes.freeze
+      SEEDBYTES       = seedbytes.freeze
 
       attach_function :crypto_sign_ed25519_pk_to_curve25519,  [:buffer_out, :buffer_in],  :int
       attach_function :crypto_sign_ed25519_sk_to_curve25519,  [:buffer_out, :buffer_in],  :int
 
+      attach_function :crypto_sign_ed25519_sk_to_seed,  [:buffer_out, :buffer_in],  :int
+      attach_function :crypto_sign_ed25519_sk_to_pk,    [:buffer_out, :buffer_in],  :int
+
       module_function
 
       def pk_to_curve25519(public_key)
@@ -52,6 +57,30 @@ module Crypto
       ensure
         secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
       end
+
+      def sk_to_seed(secret_key)
+        check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+        seed = zeros(SEEDBYTES)
+        secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+        crypto_sign_ed25519_sk_to_seed(seed, secret_key)
+
+        seed
+      ensure
+        secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+      end
+
+      def sk_to_pk(secret_key)
+        check_length(secret_key, SECRETKEYBYTES, :SecretKey)
+
+        public_key = zeros(PUBLICKEYBYTES)
+        secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+        crypto_sign_ed25519_sk_to_pk(seed, secret_key)
+
+        public_key
+      ensure
+        secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+      end
     end
 
     Ed25519.freeze

data/lib/sodium.rb

@@ -23,35 +23,35 @@ module Sodium
   module_function
 
   def mlock(addr, len)
-    if sodium_mlock(addr, len) == 0
-      true
-    else
+    if sodium_mlock(addr, len) == -1
       raise MemoryError, "Could not lock length=#{len} bytes memory at address=#{addr.address}", caller
     end
+
+    true
   end
 
   def munlock(addr, len)
-    if sodium_munlock(addr, len) == 0
-      true
-    else
+    if sodium_munlock(addr, len) == -1
       raise MemoryError, "Could not unlock length=#{len} bytes memory at address=#{addr.address}", caller
     end
+
+    true
   end
 
   def malloc(size)
-    unless (mem = sodium_malloc(size)).null?
-      mem
-    else
+    if (mem = sodium_malloc(size)).null?
       raise NoMemoryError, "Failed to allocate memory size=#{size} bytes", caller
     end
+
+    mem
   end
 
   def allocarray(count, size)
-    unless (mem = sodium_allocarray(count, size)).null?
-      mem
-    else
+    if (mem = sodium_allocarray(count, size)).null?
       raise NoMemoryError, "Failed to allocate memory size=#{count * size} bytes", caller
     end
+
+    mem
   end
 
   def bin2hex(bin)
@@ -63,22 +63,21 @@ module Sodium
   def hex2bin(hex, bin_maxlen, ignore = nil)
     bin = zeros(bin_maxlen)
     bin_len = FFI::MemoryPointer.new(:size_t)
-    if sodium_hex2bin(bin, bin_maxlen, hex, hex.bytesize, ignore, bin_len, nil) == 0
-      size = bin_len.size == 8 ? bin_len.get_uint64(0) : bin_len.get_uint32(0)
-      [bin, size]
-    else
+    if sodium_hex2bin(bin, bin_maxlen, hex, hex.bytesize, ignore, bin_len, nil) == -1
       raise LengthError, "bin_maxlen=#{bin_maxlen} is too short", caller
     end
+    size = bin_len.size == 8 ? bin_len.get_uint64(0) : bin_len.get_uint32(0)
+
+    [bin, size]
   end
 
   def hex2bin!(hex, bin_maxlen, ignore = nil)
     bin_len = FFI::MemoryPointer.new(:size_t)
-    if sodium_hex2bin(hex, bin_maxlen, hex, hex.bytesize, ignore, bin_len, nil) == 0
-      size = bin_len.size == 8 ? bin_len.get_uint64(0) : bin_len.get_uint32(0)
-      hex.slice!(size..-1)
-      hex
-    else
+    if sodium_hex2bin(hex, bin_maxlen, hex, hex.bytesize, ignore, bin_len, nil) == -1
       raise LengthError, "bin_maxlen=#{bin_maxlen} is too short", caller
     end
+    size = bin_len.size == 8 ? bin_len.get_uint64(0) : bin_len.get_uint32(0)
+    hex.slice!(size..-1)
+    hex
   end
 end

data/lib/sodium/version.rb

@@ -1,3 +1,3 @@
 module Sodium
-  VERSION = Gem::Version.new('0.4.3')
+  VERSION = Gem::Version.new('0.4.4')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-libsodium
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Hendrik Beskow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-23 00:00:00.000000000 Z
+date: 2014-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -86,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: libsodium ffi wrapper