ffi-libsodium 0.1.10 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8f824b533e203a30b75bd97267e79eefbee9b04
-  data.tar.gz: e791838d822463c909f23b885f48d9651e2c8dbc
+  metadata.gz: 95a7d9bb37cc560f3dfbb7a72a6bcf31ffdf63d6
+  data.tar.gz: 636823f16c86f508ff3180c56edb357a6b8afa2c
 SHA512:
-  metadata.gz: de9b091d5911cfe41e0f34d15789a6a3dc4a2c608c760e0148542e7ec7c245531e7e2ac67879df21405dca1ea8931c64b02a817a25be73350395bf1bba7157a3
-  data.tar.gz: 1336f51e32015d717ea5b409806fef90d342458528478d8c061a661e458f0c01e1f506c757da58d5b186a9c49817f454abc45b23c6ad0c7afab730598c5c5468
+  metadata.gz: e101ac68e41004c5b1dab8594baf37a6bd3c68fa6bb4981fdc556ef7d6d9cfac3e5aadaaec9c4ff11c524570fcf49500459aca5eed2486c8af7835235a0a5b61
+  data.tar.gz: 9c3e394cdf2941d370ad3c690c0bf17a335ba4cc9aba9aea5fa61b88bdff986369493be2348aa3d6663fff6e6e98c3aa6901d5fbefd5b59a5d3893f5bc696fa1

data/README.md

@@ -11,7 +11,7 @@ bundle update
 require 'bundler/setup'
 require 'libsodium'
 
-password = 'test123'
+password = Crypto.generichash('test123')
 
 salt = Crypto::PwHash::ScryptSalsa208SHA256.salt
 key = Crypto::PwHash.scryptsalsa208sha256(Crypto::Auth::KEYBYTES, password, salt)

data/lib/crypto/aead/chacha20_poly1305.rb

@@ -46,7 +46,6 @@ module Crypto
         check_length(key, KEYBYTES, :SecretKey)
 
         ciphertext = Sodium::Buffer.new(:uchar, message_len + ABYTES)
-        ciphertext.primitive = PRIMITIVE
         key.readonly if key.is_a?(Sodium::SecretBuffer)
         crypto_aead_chacha20poly1305_encrypt(ciphertext, nil, message, message_len, additional_data, get_size(additional_data), nil, nonce, key)
 
@@ -56,22 +55,28 @@ module Crypto
       end
 
       def decrypt(ciphertext, additional_data, nonce, key)
-        unless ((ciphertext_len = get_size(ciphertext)) - ABYTES) > 0
+        ciphertext_len = get_size(ciphertext)
+        if (decrypted_len = ciphertext_len - ABYTES) > 0
+          check_length(nonce, NPUBBYTES, :Nonce)
+          check_length(key, KEYBYTES, :SecretKey)
+
+          decrypted = Sodium::Buffer.new(:uchar, 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
+            decrypted
+          else
+            raise Sodium::CryptoError, "Message forged", caller
+          end
+        else
           fail Sodium::LengthError, "Ciphertext is too short", caller
         end
-        check_length(nonce, NPUBBYTES, :Nonce)
-        check_length(key, KEYBYTES, :SecretKey)
-
-        decrypted = Sodium::Buffer.new(:uchar, ciphertext_len - ABYTES)
-        key.readonly if key.is_a?(Sodium::SecretBuffer)
-        unless crypto_aead_chacha20poly1305_decrypt(decrypted, nil, nil, ciphertext, ciphertext_len, additional_data, get_size(additional_data), nonce, key).zero?
-          raise Sodium::CryptoError, "Message forged", caller
-        end
-
-        decrypted
       ensure
         key.noaccess if key.is_a?(Sodium::SecretBuffer)
       end
     end
+
+    Chacha20Poly1305.freeze
   end
+
+  AEAD.freeze
 end

data/lib/crypto/auth.rb

@@ -27,7 +27,6 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       mac = Sodium::Buffer.new(:uchar, BYTES)
-      mac.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
       crypto_auth(mac, message, get_size(message), key)
 
@@ -41,12 +40,14 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      crypto_auth_verify(mac, message, get_size(message), key).zero?
+      crypto_auth_verify(mac, message, get_size(message), key) == 0
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
   end
 
+  Auth.freeze
+
   module_function
 
   def auth(*args)

data/lib/crypto/box.rb

@@ -40,9 +40,7 @@ module Crypto
 
     def keypair
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
       secret_key = Sodium::Buffer.new(:uchar, SECRETKEYBYTES)
-      secret_key.primitive = PRIMITIVE
       crypto_box_keypair(public_key, secret_key)
 
       [public_key, secret_key]
@@ -52,9 +50,7 @@ module Crypto
       check_length(seed, SEEDBYTES, :Seed)
 
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
       secret_key = Sodium::Buffer.new(:uchar, SECRETKEYBYTES)
-      secret_key.primitive = PRIMITIVE
       seed.readonly if seed.is_a?(Sodium::SecretBuffer)
       crypto_box_seed_keypair(public_key, secret_key, seed)
 
@@ -65,8 +61,7 @@ module Crypto
 
     def memory_locked_keypair
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
-      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES)
       crypto_box_keypair(public_key, secret_key)
       secret_key.noaccess
 
@@ -77,8 +72,7 @@ module Crypto
       check_length(seed, SEEDBYTES, :Seed)
 
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
-      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES)
       seed.readonly if seed.is_a?(Sodium::SecretBuffer)
       crypto_box_seed_keypair(public_key, secret_key, seed)
       secret_key.noaccess
@@ -95,7 +89,6 @@ module Crypto
       check_length(secret_key, SECRETKEYBYTES, :SecretKey)
 
       ciphertext = Sodium::Buffer.new(:uchar, message_len + MACBYTES)
-      ciphertext.primitive = PRIMITIVE
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
       crypto_box_easy(ciphertext, message, message_len, nonce, public_key, secret_key)
 
@@ -112,22 +105,22 @@ module Crypto
 
       decrypted = Sodium::Buffer.new(:uchar, ciphertext_len - MACBYTES)
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
-      unless crypto_box_open_easy(decrypted, ciphertext, ciphertext_len, nonce, public_key, secret_key).zero?
+      if crypto_box_open_easy(decrypted, ciphertext, ciphertext_len, nonce, public_key, secret_key) == 0
+        decrypted
+      else
         raise Sodium::CryptoError, "Message forged", caller
       end
-
-      decrypted
     ensure
       secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
     end
 
     def easy_in_place(data, nonce, public_key, secret_key)
-      message = get_string(data)
+      message = String(data)
       check_length(nonce, NONCEBYTES, :Nonce)
       check_length(public_key, PUBLICKEYBYTES, :PublicKey)
       check_length(secret_key, SECRETKEYBYTES, :SecretKey)
 
-      message_len = get_size(message)
+      message_len = message.bytesize
       message << zeros(MACBYTES)
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
       crypto_box_easy(message, message, message_len, nonce, public_key, secret_key)
@@ -137,33 +130,36 @@ module Crypto
       secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
     end
 
-    def open_easy_in_place(data, nonce, public_key, secret_key, utf8 = false)
-      ciphertext = get_string(data)
-      unless (message_len = get_size(ciphertext) - 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)
-      unless crypto_box_open_easy(ciphertext, ciphertext, get_size(ciphertext), nonce, public_key, secret_key).zero?
-        raise Sodium::CryptoError, "Message forged", caller
-      end
-
-      if utf8
-        ciphertext.slice!(message_len..-1).force_encoding(Encoding::UTF_8)
+    def open_easy_in_place(data, nonce, public_key, secret_key, encoding = false)
+      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
+          if encoding
+            ciphertext.slice!(message_len..-1).force_encoding(encoding)
+          else
+            ciphertext.slice!(message_len..-1)
+          end
+
+          ciphertext
+        else
+          raise Sodium::CryptoError, "Message forged", caller
+        end
       else
-        ciphertext.slice!(message_len..-1)
+        fail Sodium::LengthError, "Ciphertext is too short", caller
       end
-
-      ciphertext
     ensure
       secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
     end
   end
 
+  Box.freeze
+
   module_function
 
   def box(*args)

data/lib/crypto/generic_hash.rb

@@ -1,8 +1,8 @@
 require 'ffi'
 require_relative '../sodium/utils'
-require_relative '../sodium/errors'
 require_relative '../sodium/buffer'
 require_relative '../sodium/secret_buffer'
+require_relative '../sodium/errors'
 
 module Crypto
   module GenericHash
@@ -46,28 +46,19 @@ module Crypto
     module_function
 
     def generichash(message, hash_size = BYTES, key = nil)
-      if hash_size > BYTES_MAX ||hash_size < BYTES_MIN
-        fail Sodium::LengthError, "Hash size must be between #{BYTES_MIN} and #{BYTES_MAX} bytes, got size=#{hash_size} bytes", caller
-      end
-
       if key
         key_len = get_size(key)
-
-        if key_len > KEYBYTES_MAX ||key_len < KEYBYTES_MIN
-          fail Sodium::LengthError, "Key length must be between #{KEYBYTES_MIN} and #{KEYBYTES_MAX} bytes, got length=#{key_len} bytes", caller
-        end
       else
         key_len = 0
       end
 
       blake2b = Sodium::Buffer.new(:uchar, hash_size)
-      blake2b.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      unless crypto_generichash(blake2b, hash_size, message, get_size(message), key, key_len).zero?
+      if crypto_generichash(blake2b, hash_size, message, get_size(message), key, key_len) == 0
+        blake2b
+      else
         raise Sodium::CryptoError
       end
-
-      blake2b
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
@@ -75,47 +66,36 @@ module Crypto
     def init(key = nil, hash_size = BYTES)
       if key
         key_len = get_size(key)
-
-        if key_len > KEYBYTES_MAX ||key_len < KEYBYTES_MIN
-          fail Sodium::LengthError, "Key length must be between #{KEYBYTES_MIN} and #{KEYBYTES_MAX} bytes, got length=#{key_len} bytes", caller
-        end
       else
         key_len = 0
       end
 
-      if hash_size > BYTES_MAX ||hash_size < BYTES_MIN
-        fail Sodium::LengthError, "Hash size must be between #{BYTES_MIN} and #{BYTES_MAX} bytes, got size=#{hash_size} bytes", caller
-      end
-
       state = State.new
-      blake2b = Sodium::Buffer.new(:uchar, hash_size)
-      blake2b.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-
-      unless crypto_generichash_init(state, key, key_len, hash_size).zero?
+      if crypto_generichash_init(state, key, key_len, hash_size) == 0
+        [state, Sodium::Buffer.new(:uchar, hash_size)]
+      else
         raise Sodium::CryptoError
       end
-
-      [state, blake2b]
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
 
     def update(state, message)
-      unless crypto_generichash_update(state, message, get_size(message)).zero?
-        raise Sodium::CryptoError
-      end
+      crypto_generichash_update(state, message, get_size(message))
     end
 
     def final(state, blake2b)
-      unless crypto_generichash_final(state, blake2b, blake2b.size).zero?
+      if crypto_generichash_final(state, blake2b, blake2b.size) == 0
+        blake2b
+      else
         raise Sodium::CryptoError
       end
-
-      blake2b
     end
   end
 
+  GenericHash.freeze
+
   module_function
 
   def generichash(*args)

data/lib/crypto/one_time_auth.rb

@@ -36,7 +36,6 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       out = Sodium::Buffer.new(:uchar, BYTES)
-      out.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
       crypto_onetimeauth(out, message, get_size(message), key)
 
@@ -50,7 +49,7 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      crypto_onetimeauth_verify(out, message, get_size(message), key).zero?
+      crypto_onetimeauth_verify(out, message, get_size(message), key) == 0
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
@@ -73,13 +72,13 @@ module Crypto
 
     def final(state)
       out = Sodium::Buffer.new(:uchar, BYTES)
-      out.primitive = PRIMITIVE
       crypto_onetimeauth_final(state, out)
-
       out
     end
   end
 
+  OneTimeAuth.freeze
+
   module_function
 
   def onetimeauth(*args)

data/lib/crypto/pw_hash/scrypt_salsa208_sha256.rb

@@ -49,51 +49,40 @@ module Crypto
       end
 
       def scryptsalsa208sha256(outlen, passwd, salt, opslimit = OPSLIMIT_INTERACTIVE, memlimit = MEMLIMIT_INTERACTIVE)
-        out = nil
         check_length(salt, SALTBYTES, :Salt)
-        if opslimit < OPSLIMIT_INTERACTIVE
-          fail Sodium::LengthError, "Opslimit must be at least #{OPSLIMIT_INTERACTIVE}, got #{opslimit}", caller
-        end
-        if memlimit < MEMLIMIT_INTERACTIVE
-          fail Sodium::LengthError, "Memlimit must be at least #{MEMLIMIT_INTERACTIVE}, got #{memlimit}", caller
-        end
 
-        out = Sodium::SecretBuffer.new(outlen, PRIMITIVE)
-        unless crypto_pwhash_scryptsalsa208sha256(out, outlen, passwd, get_size(passwd), salt, opslimit, memlimit).zero?
+        out = Sodium::SecretBuffer.new(outlen)
+        if crypto_pwhash_scryptsalsa208sha256(out, outlen, passwd, get_size(passwd), salt, opslimit, memlimit) == 0
+          out.noaccess
+          out
+        else
           raise NoMemoryError, "Failed to allocate memory max size=#{memlimit} bytes", caller
         end
-
-        out
-      ensure
-        out.noaccess if out
       end
 
       def str(passwd, opslimit = OPSLIMIT_INTERACTIVE, memlimit = MEMLIMIT_INTERACTIVE)
-        if opslimit < OPSLIMIT_INTERACTIVE
-          fail Sodium::LengthError, "Opslimit must be at least #{OPSLIMIT_INTERACTIVE}, got #{opslimit}", caller
-        end
-        if memlimit < MEMLIMIT_INTERACTIVE
-          fail Sodium::LengthError, "Memlimit must be at least #{MEMLIMIT_INTERACTIVE}, got #{memlimit}", caller
-        end
-
         hashed_password = FFI::MemoryPointer.new(:char, STRBYTES)
-        unless crypto_pwhash_scryptsalsa208sha256_str(hashed_password, passwd, get_size(passwd), opslimit, memlimit).zero?
+        if crypto_pwhash_scryptsalsa208sha256_str(hashed_password, passwd, get_size(passwd), opslimit, memlimit) == 0
+          hashed_password.get_string(0)
+        else
           raise NoMemoryError, "Failed to allocate memory max size=#{memlimit} bytes", caller
         end
-
-        hashed_password.get_string(0)
       end
 
       def str_verify(str, passwd)
         check_length(str, STRBYTES - 1, :Str)
-        crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd, get_size(passwd)).zero?
+        crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd, get_size(passwd)) == 0
       end
     end
 
+    ScryptSalsa208SHA256.freeze
+
     module_function
 
     def scryptsalsa208sha256(*args)
       ScryptSalsa208SHA256.scryptsalsa208sha256(*args)
     end
   end
+
+  PwHash.freeze
 end

data/lib/crypto/scalar_mult.rb

@@ -27,7 +27,6 @@ module Crypto
       check_length(secret_key, SCALARBYTES, :SecretKey)
 
       public_key = Sodium::Buffer.new(:uchar, BYTES)
-      public_key.primitive = PRIMITIVE
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
       crypto_scalarmult_base(public_key, secret_key)
 
@@ -40,7 +39,7 @@ module Crypto
       check_length(secret_key, SCALARBYTES, :SecretKey)
       check_length(public_key, BYTES, :PublicKey)
 
-      shared_secret = Sodium::SecretBuffer.new(BYTES, PRIMITIVE)
+      shared_secret = Sodium::SecretBuffer.new(BYTES)
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
       crypto_scalarmult(shared_secret, secret_key, public_key)
       shared_secret.noaccess
@@ -51,6 +50,8 @@ module Crypto
     end
   end
 
+  ScalarMult.freeze
+
   module_function
 
   def scalarmut(*args)

data/lib/crypto/secret_box.rb

@@ -37,7 +37,6 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       ciphertext = Sodium::Buffer.new(:uchar, message_len + MACBYTES)
-      ciphertext.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
       crypto_secretbox_easy(ciphertext, message, message_len, nonce, key)
 
@@ -53,22 +52,21 @@ module Crypto
 
       decrypted = Sodium::Buffer.new(:uchar, ciphertext_len - MACBYTES)
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-
-      unless crypto_secretbox_open_easy(decrypted, ciphertext, ciphertext_len, nonce, key).zero?
+      if crypto_secretbox_open_easy(decrypted, ciphertext, ciphertext_len, nonce, key) == 0
+        decrypted
+      else
         raise Sodium::CryptoError, "Message forged", caller
       end
-
-      decrypted
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
 
     def easy_in_place(data, nonce, key)
-      message = get_string(data)
+      message = String(data)
       check_length(nonce, NONCEBYTES, :Nonce)
       check_length(key, KEYBYTES, :SecretKey)
 
-      message_len = get_size(message)
+      message_len = message.bytesize
       message << zeros(MACBYTES)
       key.readonly if key.is_a?(Sodium::SecretBuffer)
       crypto_secretbox_easy(message, message, message_len, nonce, key)
@@ -78,32 +76,35 @@ module Crypto
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
 
-    def open_easy_in_place(data, nonce, key, utf8 = false)
-      ciphertext = get_string(data)
-      unless (message_len = get_size(ciphertext) - 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)
-      unless crypto_secretbox_open_easy(ciphertext, ciphertext, get_size(ciphertext), nonce, key).zero?
-        raise Sodium::CryptoError, "Message forged", caller
-      end
-
-      if utf8
-        ciphertext.slice!(message_len..-1).force_encoding(Encoding::UTF_8)
+    def open_easy_in_place(data, nonce, key, encoding = false)
+      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
+          if encoding
+            ciphertext.slice!(message_len..-1).force_encoding(encoding)
+          else
+            ciphertext.slice!(message_len..-1)
+          end
+
+          ciphertext
+        else
+          raise Sodium::CryptoError, "Message forged", caller
+        end
       else
-        ciphertext.slice!(message_len..-1)
+        fail Sodium::LengthError, "Ciphertext is too short", caller
       end
-
-      ciphertext
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
   end
 
+  SecretBox.freeze
+
   module_function
 
   def secretbox(*args)

data/lib/crypto/short_hash.rb

@@ -26,7 +26,6 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       siphash = Sodium::Buffer.new(:uchar, BYTES)
-      siphash.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
       crypto_shorthash(siphash, short_data, get_size(short_data), key)
 
@@ -36,6 +35,8 @@ module Crypto
     end
   end
 
+  ShortHash.freeze
+
   module_function
 
   def shorthash(*args)

data/lib/crypto/sign.rb

@@ -33,9 +33,7 @@ module Crypto
 
     def keypair
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
       secret_key = Sodium::Buffer.new(:uchar, SECRETKEYBYTES)
-      secret_key.primitive = PRIMITIVE
       crypto_sign_keypair(public_key, secret_key)
 
       [public_key, secret_key]
@@ -45,9 +43,7 @@ module Crypto
       check_length(seed, SEEDBYTES, :Seed)
 
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
       secret_key = Sodium::Buffer.new(:uchar, SECRETKEYBYTES)
-      secret_key.primitive = PRIMITIVE
       seed.readonly if seed.is_a?(Sodium::SecretBuffer)
       crypto_sign_seed_keypair(public_key, secret_key, seed)
 
@@ -58,8 +54,7 @@ module Crypto
 
     def memory_locked_keypair
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
-      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES)
       crypto_sign_keypair(public_key, secret_key)
       secret_key.noaccess
 
@@ -70,8 +65,7 @@ module Crypto
       check_length(seed, SEEDBYTES, :Seed)
 
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      public_key.primitive = PRIMITIVE
-      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES)
       seed.readonly if seed.is_a?(Sodium::SecretBuffer)
       crypto_sign_seed_keypair(public_key, secret_key, seed)
       secret_key.noaccess
@@ -86,7 +80,6 @@ module Crypto
       check_length(secret_key, SECRETKEYBYTES, :SecretKey)
 
       sealed_message = Sodium::Buffer.new(:uchar, message_len + BYTES)
-      sealed_message.primitive = PRIMITIVE
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
       crypto_sign(sealed_message, nil, message, message_len, secret_key)
 
@@ -100,15 +93,17 @@ module Crypto
       check_length(public_key, PUBLICKEYBYTES, :PublicKey)
 
       unsealed_message = Sodium::Buffer.new(:uchar, sealed_message_len - BYTES)
-      unsealed_message_len = FFI::MemoryPointer.new(:pointer)
-      unless crypto_sign_open(unsealed_message, unsealed_message_len, sealed_message, sealed_message_len, public_key).zero?
+      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
         raise Sodium::CryptoError, "Incorrect signature", caller
       end
-
-      unsealed_message
     end
   end
 
+  Sign.freeze
+
   module_function
 
   def sign(*args)

data/lib/crypto/sign/ed25519.rb

@@ -54,5 +54,7 @@ module Crypto
         secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
       end
     end
+
+    Ed25519.freeze
   end
 end

data/lib/libsodium.rb

@@ -2,19 +2,22 @@
 require_relative 'sodium'
 require_relative 'sodium/utils'
 require_relative 'sodium/buffer'
+require_relative 'sodium/mprotect'
 require_relative 'sodium/secret_buffer'
+Sodium.freeze
 require_relative 'random_bytes'
 require_relative 'crypto/secret_box'
 require_relative 'crypto/auth'
 require_relative 'crypto/aead/chacha20_poly1305'
 require_relative 'crypto/box'
+require_relative 'crypto/sign/ed25519'
 require_relative 'crypto/sign'
 require_relative 'crypto/generic_hash'
 require_relative 'crypto/short_hash'
 require_relative 'crypto/pw_hash/scrypt_salsa208_sha256'
 require_relative 'crypto/one_time_auth'
 require_relative 'crypto/scalar_mult'
-require_relative 'crypto/sign/ed25519'
+Crypto.freeze
 
 Thread.exclusive do
   if Sodium.init == -1

data/lib/random_bytes.rb

@@ -20,3 +20,5 @@ module RandomBytes
     buf
   end
 end
+
+RandomBytes.freeze

data/lib/sodium.rb

@@ -16,53 +16,22 @@ module Sodium
   attach_function :sodium_munlock,            [:pointer, :size_t],  :int
   attach_function :sodium_malloc,             [:size_t],            :pointer
   attach_function :sodium_allocarray,         [:size_t, :size_t],   :pointer
-  attach_function :sodium_mprotect_noaccess,  [:pointer],           :int
-  attach_function :sodium_mprotect_readonly,  [:pointer],           :int
-  attach_function :sodium_mprotect_readwrite, [:pointer],           :int
 
   module_function
 
   def mlock(addr, len)
-    unless sodium_mlock(addr, len).zero?
-      raise MemoryError, "Could not lock length=#{len} bytes memory at address=#{addr.address}", caller
-    end
+    sodium_mlock(addr, len) == 0 || raise(MemoryError, "Could not lock length=#{len} bytes memory at address=#{addr.address}", caller)
   end
 
   def munlock(addr, len)
-    unless sodium_munlock(addr, len).zero?
-      raise MemoryError, "Could not unlock length=#{len} bytes memory at address=#{addr.address}", caller
-    end
+    sodium_munlock(addr, len) == 0 || raise(MemoryError, "Could not unlock length=#{len} bytes memory at address=#{addr.address}", caller)
   end
 
   def malloc(size)
-    unless (mem = sodium_malloc(size))
-      raise NoMemoryError, "Failed to allocate memory size=#{size} bytes", caller
-    end
-    mem
+    sodium_malloc(size) || raise(NoMemoryError, "Failed to allocate memory size=#{size} bytes", caller)
   end
 
   def allocarray(count, size)
-    unless (mem = sodium_allocarray(count, size))
-      raise NoMemoryError, "Failed to allocate memory size=#{count * size} bytes", caller
-    end
-    mem
-  end
-
-  def noaccess(ptr)
-    unless sodium_mprotect_noaccess(ptr).zero?
-      raise MemoryError, "Memory at address=#{ptr.address} is not secured with #{self}.malloc", caller
-    end
-  end
-
-  def readonly(ptr)
-    unless sodium_mprotect_readonly(ptr).zero?
-      raise MemoryError, "Memory at address=#{ptr.address} is not secured with #{self}.malloc", caller
-    end
-  end
-
-  def readwrite(ptr)
-    unless sodium_mprotect_readwrite(ptr).zero?
-      raise MemoryError, "Memory at address=#{ptr.address} is not secured with #{self}.malloc", caller
-    end
+    sodium_allocarray(count, size) || raise(NoMemoryError, "Failed to allocate memory size=#{count * size} bytes", caller)
   end
 end

data/lib/sodium/buffer.rb

@@ -2,12 +2,10 @@
 
 module Sodium
   class Buffer < FFI::MemoryPointer
-    attr_accessor :primitive
-
-    def to_bytes
+    def to_str
       read_bytes(size)
     end
-
-    alias_method :to_str, :to_bytes
   end
+
+  Buffer.freeze
 end

data/lib/sodium/errors.rb

@@ -1,5 +1,5 @@
 module Sodium
-  class CryptoError < StandardError; end
-  class LengthError < ArgumentError; end
-  class MemoryError < StandardError; end
+  CryptoError = Class.new(StandardError).freeze
+  LengthError = Class.new(ArgumentError).freeze
+  MemoryError = Class.new(StandardError).freeze
 end

data/lib/sodium/mprotect.rb

@@ -0,0 +1,30 @@
+require 'ffi'
+require_relative 'errors'
+require_relative 'utils'
+
+module Sodium
+  module Mprotect
+    extend FFI::Library
+    ffi_lib :libsodium
+
+    attach_function :sodium_mprotect_noaccess,  [:pointer], :int
+    attach_function :sodium_mprotect_readonly,  [:pointer], :int
+    attach_function :sodium_mprotect_readwrite, [:pointer], :int
+
+    module_function
+
+    def noaccess(ptr)
+      sodium_mprotect_noaccess(ptr) == 0 || raise(MemoryError, "Memory at address=#{ptr.address} is not secured with Sodium.malloc", caller)
+    end
+
+    def readonly(ptr)
+      sodium_mprotect_readonly(ptr) == 0 || raise(MemoryError, "Memory at address=#{ptr.address} is not secured with Sodium.malloc", caller)
+    end
+
+    def readwrite(ptr)
+      sodium_mprotect_readwrite(ptr) == 0 || raise(MemoryError, "Memory at address=#{ptr.address} is not secured with Sodium.malloc", caller)
+    end
+  end
+
+  Mprotect.freeze
+end

data/lib/sodium/secret_buffer.rb

@@ -1,58 +1,61 @@
 require 'forwardable'
-require_relative 'utils'
 require_relative '../sodium'
+require_relative 'mprotect'
 require 'ffi'
 
 module Sodium
   class SecretBuffer
     extend Forwardable
 
-    attr_reader :size, :primitive, :to_ptr
-    def_delegators :to_ptr, :address, :to_i
+    attr_reader :size, :to_ptr
+    def_delegators :@to_ptr, :address, :to_i
 
-    def initialize(size, primitive = nil)
-      @size = Utils.get_int(size)
-      @primitive = primitive
-      @to_ptr = Sodium.malloc(self.size)
+    def initialize(size)
+      @size = Integer(size)
+      @to_ptr = Sodium.malloc(@size)
       setup_finalizer
     end
 
     def free
       remove_finalizer
-      readwrite
-      Sodium.free(to_ptr)
-      @size = @primitive = @to_ptr = nil
+      Sodium::Mprotect.readonly(@to_ptr)
+      Sodium.free(@to_ptr)
+      remove_instance_variable(:@size)
+      remove_instance_variable(:@to_ptr)
+      true
     end
 
     def noaccess
-      Sodium.noaccess(to_ptr)
+      Sodium::Mprotect.noaccess(@to_ptr)
     end
 
     def readonly
-      Sodium.readonly(to_ptr)
+      Sodium::Mprotect.readonly(@to_ptr)
     end
 
     def readwrite
-      Sodium.readwrite(to_ptr)
+      Sodium::Mprotect.readwrite(@to_ptr)
     end
 
     private
 
     def setup_finalizer
-      ObjectSpace.define_finalizer(to_ptr, self.class.free(to_ptr.address))
+      ObjectSpace.define_finalizer(@to_ptr, self.class.free(@to_ptr.address))
     end
 
     def remove_finalizer
-      ObjectSpace.undefine_finalizer to_ptr
+      ObjectSpace.undefine_finalizer @to_ptr
     end
 
     def self.free(address)
       ->(obj_id) do
         ptr = FFI::Pointer.new(address)
-        Sodium.readwrite(ptr)
+        Sodium::Mprotect.readonly(ptr)
         Sodium.free(ptr)
         true
       end
     end
   end
+
+  SecretBuffer.freeze
 end

data/lib/sodium/utils.rb

@@ -1,68 +1,41 @@
-require_relative 'errors'
-require 'ffi'
+require 'ffi'
+require_relative 'secret_buffer'
+require_relative 'errors'
 
 module Sodium
   module Utils
 
     module_function
 
-    def check_length(data, length, description)
-      if data.is_a?(String) ||data.respond_to?(:bytesize)
-        unless data.bytesize == length
-          fail Sodium::LengthError, "Expected a length=#{length} bytes #{description}, got size=#{data.bytesize} bytes", caller
-        end
-      elsif data.is_a?(FFI::Pointer) ||data.respond_to?(:size)
-        unless data.size == length
-          fail Sodium::LengthError, "Expected a length=#{length} bytes #{description}, got size=#{data.size} bytes", caller
-        end
-      else
-        fail ArgumentError, "#{description} must be of type String or FFI::Pointer and be length=#{length} bytes long", caller
-      end
-
-      true
-    end
-
-    def get_pointer(ptr)
-      if ptr.is_a?(FFI::Pointer)
-        ptr
-      elsif ptr.respond_to?(:to_ptr)
-        ptr.to_ptr
-      else
-        fail ArgumentError, "#{ptr.class} is not a FFI::Pointer", caller
-      end
-    end
-
-    def get_string(string)
-      if string.is_a?(String)
-        string
-      elsif string.respond_to?(:to_str)
-        string.to_str
-      elsif string.respond_to?(:get_string)
-        string.get_string(0)
-      else
-        fail ArgumentError, "#{string.class} is not a String", caller
-      end
-    end
-
-    def get_int(int)
-      if int.is_a?(Fixnum)
-        int
-      elsif int.respond_to?(:to_int)
-        int.to_int
+    def get_size(data)
+      case data
+      when FFI::Pointer, SecretBuffer
+        data.size
+      when String
+        data.bytesize
+      when NilClass
+        0
       else
-        fail ArgumentError, "#{int.class} is not a Integer", caller
+        fail TypeError, "#{data.class} must be of type FFI::Pointer, Sodium::SecretBufffer, String or NilClass", caller
       end
     end
 
-    def get_size(data)
-      if data.is_a?(String) ||data.respond_to?(:bytesize)
-        data.bytesize
-      elsif data.is_a?(FFI::Pointer) ||data.respond_to?(:size)
-        data.size
-      elsif data.nil?
-        0
+    def check_length(data, length, description)
+      case data
+      when FFI::Pointer, SecretBuffer
+        if data.size == length
+          true
+        else
+          fail LengthError, "Expected a length=#{length} bytes #{description}, got size=#{data.size} bytes", caller
+        end
+      when String
+        if data.bytesize == length
+          true
+        else
+          fail LengthError, "Expected a length=#{length} bytes #{description}, got size=#{data.bytesize} bytes", caller
+        end
       else
-        fail ArgumentError, "#{data.class} doesn't respond to :bytesize or :size", caller
+        fail TypeError, "#{data.class} must be of type FFI::Pointer, Sodium::SecretBufffer or String", caller
       end
     end
 
@@ -82,4 +55,6 @@ module Sodium
       [hex].pack(HEXY)
     end
   end
+
+  Utils.freeze
 end

data/lib/sodium/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-libsodium
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
 platform: ruby
 authors:
 - Hendrik Beskow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-11 00:00:00.000000000 Z
+date: 2014-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -62,6 +62,7 @@ files:
 - lib/sodium.rb
 - lib/sodium/buffer.rb
 - lib/sodium/errors.rb
+- lib/sodium/mprotect.rb
 - lib/sodium/secret_buffer.rb
 - lib/sodium/utils.rb
 - lib/sodium/version.rb