ffi-libsodium 0.0.9 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68412992b272b75f8a23bb0fb06d4e0d77fd757e
-  data.tar.gz: 7c377501671e1f002c9a095f71526cfacc444272
+  metadata.gz: ead53faf6d5782f67d70043e224ded1177881f6d
+  data.tar.gz: 51467dd63043a45e209597485caf46994c3ce04e
 SHA512:
-  metadata.gz: 54c59d11d1b0ae79363ae106576d23d25b52e488d1777308418f9e3d885d30dd0c02c1c9a1183f39f02b7ebec3fa6ee969f6c27553c17063237845d91f541a91
-  data.tar.gz: a7d268d7d9e7b88766794b749abf453dee3a673cf5c08df96813bf9314c8fe9f89d53df83838bca792ed72dcf2940015454f55466d50e3ced0323893746a1c8a
+  metadata.gz: 31b2073dbb29f12e2c45ca3a0579888c4062e17d8e24a553a3d00ac4715b0d783f45be3216cc125e11c5b08718345689cb0e00ce90531462537cdabceeaf90c4
+  data.tar.gz: 1f3b6439bfd1586bb03433b63228cae955f9f4919d54ccce2542c2c8719c21b372569577ca473f0f809bb7f029dee41b8bed08e51442f5db04407c834b39a3a4

data/README.md

@@ -14,7 +14,7 @@ require 'libsodium'
 password = 'test123'
 
 salt = Crypto::PwHash::ScryptSalsa208SHA256.salt
-key = Crypto::PwHash.scryptsalsa208sha256(password, Crypto::Auth::KEYBYTES, salt)
+key = Crypto::PwHash.scryptsalsa208sha256(Crypto::Auth::KEYBYTES, password, salt)
 mac = Crypto.auth(password, key)
 
 puts Crypto::Auth.verify(mac, password, key)

data/lib/crypto/aead/chacha20_poly1305.rb

@@ -42,13 +42,13 @@ module Crypto
 
       def encrypt(message, additional_data, nonce, key)
         message_len = get_size(message)
-        additional_data_len = get_size(additional_data)
         check_length(nonce, NPUBBYTES, :Nonce)
         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, additional_data_len, nil, nonce, key)
+        crypto_aead_chacha20poly1305_encrypt(ciphertext, nil, message, message_len, additional_data, get_size(additional_data), nil, nonce, key)
 
         ciphertext
       ensure
@@ -59,13 +59,12 @@ module Crypto
         unless ((ciphertext_len = get_size(ciphertext)) - ABYTES) > 0
           fail Sodium::LengthError, "Ciphertext is too short", caller
         end
-        additional_data_len = get_size(additional_data)
         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)
-        if crypto_aead_chacha20poly1305_decrypt(decrypted, nil, nil, ciphertext, ciphertext_len, additional_data, additional_data_len, nonce, key) == -1
+        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
 

data/lib/crypto/auth.rb

@@ -24,12 +24,12 @@ module Crypto
     module_function
 
     def auth(message, key)
-      message_len = get_size(message)
       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, message_len, key)
+      crypto_auth(mac, message, get_size(message), key)
 
       mac
     ensure
@@ -38,11 +38,10 @@ module Crypto
 
     def verify(mac, message, key)
       check_length(mac, BYTES, :Mac)
-      message_len = get_size(message)
       check_length(key, KEYBYTES, :SecretKey)
 
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      crypto_auth_verify(mac, message, message_len, key) == 0
+      crypto_auth_verify(mac, message, get_size(message), key).zero?
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end

data/lib/crypto/box.rb

@@ -45,7 +45,9 @@ 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]
@@ -55,7 +57,9 @@ 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)
 
@@ -66,7 +70,8 @@ module Crypto
 
     def memory_locked_keypair
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES)
+      public_key.primitive = PRIMITIVE
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
       crypto_box_keypair(public_key, secret_key)
       secret_key.noaccess
 
@@ -77,7 +82,8 @@ module Crypto
       check_length(seed, SEEDBYTES, :Seed)
 
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES)
+      public_key.primitive = PRIMITIVE
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
       seed.readonly if seed.is_a?(Sodium::SecretBuffer)
       crypto_box_seed_keypair(public_key, secret_key, seed)
       secret_key.noaccess
@@ -94,6 +100,7 @@ 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)
 
@@ -110,7 +117,7 @@ module Crypto
 
       decrypted = Sodium::Buffer.new(:uchar, 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) == -1
+      unless crypto_box_open_easy(decrypted, ciphertext, ciphertext_len, nonce, public_key, secret_key).zero?
         raise Sodium::CryptoError, "Message forged", caller
       end
 
@@ -125,10 +132,9 @@ module Crypto
       check_length(public_key, PUBLICKEYBYTES, :PublicKey)
       check_length(secret_key, SECRETKEYBYTES, :SecretKey)
 
-      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)
+      crypto_box_easy(message, message, get_size(message), nonce, public_key, secret_key)
 
       message
     ensure
@@ -137,7 +143,7 @@ module Crypto
 
     def open_easy_in_place(data, nonce, public_key, secret_key, utf8 = false)
       ciphertext = get_string(data)
-      unless (message_len = ciphertext.bytesize - MACBYTES) > 0
+      unless (message_len = get_size(ciphertext) - MACBYTES) > 0
         fail Sodium::LengthError, "Ciphertext is too short", caller
       end
 
@@ -146,7 +152,7 @@ module Crypto
       check_length(secret_key, SECRETKEYBYTES, :SecretKey)
 
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
-      if crypto_box_open_easy(ciphertext, ciphertext, ciphertext.bytesize, nonce, public_key, secret_key) == -1
+      unless crypto_box_open_easy(ciphertext, ciphertext, ciphertext.bytesize, nonce, public_key, secret_key).zero?
         raise Sodium::CryptoError, "Message forged", caller
       end
 

data/lib/crypto/generic_hash.rb

@@ -46,7 +46,6 @@ module Crypto
     module_function
 
     def generichash(message, hash_size = BYTES, key = nil)
-      message_len = get_size(message)
       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.to_int} bytes", caller
       end
@@ -62,8 +61,9 @@ module Crypto
       end
 
       blake2b = Sodium::Buffer.new(:uchar, hash_size)
+      blake2b.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      if crypto_generichash(blake2b, hash_size, message, message_len, key, key_len) == -1
+      unless crypto_generichash(blake2b, hash_size, message, get_size(message), key, key_len).zero?
         raise Sodium::CryptoError
       end
 
@@ -89,9 +89,10 @@ module Crypto
 
       state = State.new
       blake2b = Sodium::Buffer.new(:uchar, hash_size)
+      blake2b.primitive = PRIMITIVE
       key.readonly if key.is_a?(Sodium::SecretBuffer)
 
-      if crypto_generichash_init(state, key, key_len, hash_size) == -1
+      unless crypto_generichash_init(state, key, key_len, hash_size).zero?
         raise Sodium::CryptoError
       end
 
@@ -101,17 +102,13 @@ module Crypto
     end
 
     def update(state, message)
-      message_len = get_size(message)
-
-      if crypto_generichash_update(state, message, message_len) == -1
+      unless crypto_generichash_update(state, message, get_size(message)).zero?
         raise Sodium::CryptoError
       end
     end
 
     def final(state, blake2b)
-      get_pointer(blake2b)
-
-      if crypto_generichash_final(state, blake2b, blake2b.size) == -1
+      unless crypto_generichash_final(state, blake2b, blake2b.size).zero?
         raise Sodium::CryptoError
       end
 

data/lib/crypto/one_time_auth.rb

@@ -33,12 +33,12 @@ module Crypto
     module_function
 
     def onetimeauth(message, key)
-      message_len = get_size(message)
       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, message_len, key)
+      crypto_onetimeauth(out, message, get_size(message), key)
 
       out
     ensure
@@ -51,9 +51,7 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      crypto_onetimeauth_verify(out, message, message_len, key) == 0
-
-      rc == 0
+      crypto_onetimeauth_verify(out, message, get_size(message), key).zero?
     ensure
       key.noaccess if key.is_a?(Sodium::SecretBuffer)
     end
@@ -71,13 +69,12 @@ module Crypto
     end
 
     def update(state, message)
-      message_len = get_size(message)
-
-      crypto_onetimeauth_update(state, message, message_len)
+      crypto_onetimeauth_update(state, message, get_size(message))
     end
 
     def final(state)
       out = Sodium::Buffer.new(:uchar, BYTES)
+      out.primitive = PRIMITIVE
       crypto_onetimeauth_final(state, out)
 
       out

data/lib/crypto/pw_hash/scrypt_salsa208_sha256.rb

@@ -7,7 +7,6 @@ require_relative '../../sodium/secret_buffer'
 module Crypto
   module PwHash
     module ScryptSalsa208SHA256
-      PACK_C    = 'c*'.freeze
       PRIMITIVE = 'scryptsalsa208sha256'.freeze
 
       extend FFI::Library
@@ -50,7 +49,7 @@ module Crypto
       end
 
       def scryptsalsa208sha256(outlen, passwd, salt, opslimit = OPSLIMIT_INTERACTIVE, memlimit = MEMLIMIT_INTERACTIVE)
-        passwd_len = get_size(passwd)
+        out = nil
         check_length(salt, SALTBYTES, :Salt)
         if opslimit < OPSLIMIT_INTERACTIVE
           fail Sodium::LengthError, "Opslimit must be at least #{OPSLIMIT_INTERACTIVE}, got #{opslimit.to_int}", caller
@@ -59,18 +58,17 @@ module Crypto
           fail Sodium::LengthError, "Memlimit must be at least #{MEMLIMIT_INTERACTIVE}, got #{memlimit.to_int}", caller
         end
 
-        out = Sodium::SecretBuffer.new(outlen)
-        rc = crypto_pwhash_scryptsalsa208sha256(out, outlen, passwd, passwd_len, salt, opslimit, memlimit)
-        out.noaccess
-        if rc == -1
+        out = Sodium::SecretBuffer.new(outlen, PRIMITIVE)
+        unless crypto_pwhash_scryptsalsa208sha256(out, outlen, passwd, get_size(passwd), salt, opslimit, memlimit).zero?
           raise NoMemoryError, "Failed to allocate memory max size=#{memlimit.to_int} bytes", caller
         end
 
         out
+      ensure
+        out.noaccess if out
       end
 
       def str(passwd, opslimit = OPSLIMIT_INTERACTIVE, memlimit = MEMLIMIT_INTERACTIVE)
-        passwd_len = get_size(passwd)
         if opslimit < OPSLIMIT_INTERACTIVE
           fail Sodium::LengthError, "Opslimit must be at least #{OPSLIMIT_INTERACTIVE}, got #{opslimit.to_int}", caller
         end
@@ -79,18 +77,15 @@ module Crypto
         end
 
         hashed_password = FFI::MemoryPointer.new(:char, STRBYTES)
-        if crypto_pwhash_scryptsalsa208sha256_str(hashed_password, passwd, passwd_len, opslimit, memlimit) == -1
+        unless crypto_pwhash_scryptsalsa208sha256_str(hashed_password, passwd, get_size(passwd), opslimit, memlimit).zero?
           raise NoMemoryError, "Failed to allocate memory max size=#{memlimit.to_int} bytes", caller
         end
 
-        hashed_password.read_array_of_char(STRBYTES).pack(PACK_C)
+        hashed_password.get_string(0)
       end
 
       def str_verify(str, passwd)
-        check_length(str, STRBYTES, :Str)
-        passwd_len = get_size(passwd)
-
-        crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd, passwd_len) == 0
+        crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd, get_size(passwd)).zero?
       end
     end
 

data/lib/crypto/scalar_mult.rb

@@ -27,6 +27,7 @@ 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)
 
@@ -39,7 +40,7 @@ module Crypto
       check_length(secret_key, SCALARBYTES, :SecretKey)
       check_length(public_key, BYTES, :PublicKey)
 
-      shared_secret = Sodium::SecretBuffer.new(BYTES)
+      shared_secret = Sodium::SecretBuffer.new(BYTES, PRIMITIVE)
       secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
       crypto_scalarmult(shared_secret, secret_key, public_key)
       shared_secret.noaccess

data/lib/crypto/secret_box.rb

@@ -37,6 +37,7 @@ 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,7 +54,7 @@ module Crypto
       decrypted = Sodium::Buffer.new(:uchar, ciphertext_len - MACBYTES)
       key.readonly if key.is_a?(Sodium::SecretBuffer)
 
-      if crypto_secretbox_open_easy(decrypted, ciphertext, ciphertext_len, nonce, key) == -1
+      unless crypto_secretbox_open_easy(decrypted, ciphertext, ciphertext_len, nonce, key).zero?
         raise Sodium::CryptoError, "Message forged", caller
       end
 
@@ -67,10 +68,9 @@ module Crypto
       check_length(nonce, NONCEBYTES, :Nonce)
       check_length(key, KEYBYTES, :SecretKey)
 
-      message_len = message.bytesize
       message << zeros(MACBYTES)
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      crypto_secretbox_easy(message, message, message_len, nonce, key)
+      crypto_secretbox_easy(message, message, get_size(message), nonce, key)
 
       message
     ensure
@@ -79,7 +79,7 @@ module Crypto
 
     def open_easy_in_place(data, nonce, key, utf8 = false)
       ciphertext = get_string(data)
-      unless (message_len = ciphertext.bytesize - MACBYTES) > 0
+      unless (message_len = get_size(ciphertext) - MACBYTES) > 0
         fail Sodium::LengthError, "Ciphertext is too short", caller
       end
 
@@ -87,7 +87,7 @@ module Crypto
       check_length(key, KEYBYTES, :SecretKey)
 
       key.readonly if key.is_a?(Sodium::SecretBuffer)
-      if crypto_secretbox_open_easy(ciphertext, ciphertext, ciphertext.bytesize, nonce, key) == -1
+      unless crypto_secretbox_open_easy(ciphertext, ciphertext, ciphertext.bytesize, nonce, key).zero?
         raise Sodium::CryptoError, "Message forged", caller
       end
 

data/lib/crypto/short_hash.rb

@@ -23,12 +23,12 @@ module Crypto
     module_function
 
     def shorthash(short_data, key)
-      short_data_len = get_size(short_data)
       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, short_data_len, key)
+      crypto_shorthash(siphash, short_data, get_size(short_data), key)
 
       siphash
     ensure

data/lib/crypto/sign.rb

@@ -26,14 +26,16 @@ module Crypto
     attach_function :crypto_sign_keypair,       [:buffer_out, :buffer_out],             :int, blocking: true
     attach_function :crypto_sign_seed_keypair,  [:buffer_out, :buffer_out, :buffer_in], :int, blocking: true
 
-    attach_function :crypto_sign,       [:buffer_out, :buffer_out, :buffer_in, :ulong_long, :buffer_in],  :int, blocking: true
-    attach_function :crypto_sign_open,  [:buffer_out, :buffer_out, :buffer_in, :ulong_long, :buffer_in],  :int, blocking: true
+    attach_function :crypto_sign,       [:buffer_out, :pointer, :buffer_in, :ulong_long, :buffer_in],  :int, blocking: true
+    attach_function :crypto_sign_open,  [:buffer_out, :pointer, :buffer_in, :ulong_long, :buffer_in],  :int, blocking: true
 
     module_function
 
     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]
@@ -43,7 +45,9 @@ 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)
 
@@ -54,7 +58,8 @@ module Crypto
 
     def memory_locked_keypair
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES)
+      public_key.primitive = PRIMITIVE
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
       crypto_sign_keypair(public_key, secret_key)
       secret_key.noaccess
 
@@ -65,7 +70,8 @@ module Crypto
       check_length(seed, SEEDBYTES, :Seed)
 
       public_key = Sodium::Buffer.new(:uchar, PUBLICKEYBYTES)
-      secret_key = Sodium::SecretBuffer.new(:uchar, SECRETKEYBYTES)
+      public_key.primitive = PRIMITIVE
+      secret_key = Sodium::SecretBuffer.new(SECRETKEYBYTES, PRIMITIVE)
       seed.readonly if seed.is_a?(Sodium::SecretBuffer)
       crypto_sign_seed_keypair(public_key, secret_key, seed)
       secret_key.noaccess
@@ -80,6 +86,7 @@ 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)
 
@@ -93,8 +100,8 @@ module Crypto
       check_length(public_key, PUBLICKEYBYTES, :PublicKey)
 
       unsealed_message = Sodium::Buffer.new(:uchar, 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) == -1
+      unsealed_message_len = FFI::MemoryPointer.new(:pointer)
+      unless crypto_sign_open(unsealed_message, unsealed_message_len, sealed_message, sealed_message_len, public_key).zero?
         raise Sodium::CryptoError, "Incorrect signature", caller
       end
 

data/lib/crypto/sign/ed25519.rb

@@ -47,10 +47,11 @@ module Crypto
         curve25519_sk = Sodium::SecretBuffer.new(ScalarMult::BYTES)
         secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
         crypto_sign_ed25519_sk_to_curve25519(curve25519_sk, secret_key)
-        secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
         curve25519_sk.noaccess
 
         curve25519_sk
+      ensure
+        secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
       end
     end
   end

data/lib/random_bytes.rb

@@ -15,7 +15,7 @@ module RandomBytes
   module_function
 
   def buf(size)
-    buf = Sodium::Buffer.new(:uchar, size)
+    buf = Sodium::Buffer.new(:void, size, true)
     randombytes_buf(buf, size)
     buf
   end

data/lib/sodium.rb

@@ -24,13 +24,13 @@ module Sodium
   module_function
 
   def mlock(addr, len)
-    if sodium_mlock(addr, len) == -1
+    unless sodium_mlock(addr, len).zero?
       raise MemoryError, "Could not lock length=#{len.to_int} bytes memory at address=#{addr.address}", caller
     end
   end
 
   def munlock(addr, len)
-    if sodium_munlock(addr, len) == -1
+    unless sodium_munlock(addr, len).zero?
       raise MemoryError, "Could not unlock length=#{len.to_int} bytes memory at address=#{addr.address}", caller
     end
   end
@@ -50,19 +50,19 @@ module Sodium
   end
 
   def noaccess(ptr)
-    if sodium_mprotect_noaccess(ptr) == -1
+    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)
-    if sodium_mprotect_readonly(ptr) == -1
+    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)
-    if sodium_mprotect_readwrite(ptr) == -1
+    unless sodium_mprotect_readwrite(ptr).zero?
       raise MemoryError, "Memory at address=#{ptr.address} is not secured with #{self}.malloc", caller
     end
   end

data/lib/sodium/buffer.rb

@@ -2,6 +2,8 @@
 
 module Sodium
   class Buffer < FFI::MemoryPointer
+    attr_accessor :primitive
+
     def to_bytes
       read_bytes(size)
     end

data/lib/sodium/secret_buffer.rb

@@ -7,53 +7,50 @@ module Sodium
   class SecretBuffer
     extend Forwardable
 
-    def_delegators :@buffer, :address, :to_i
+    attr_reader :size, :primitive, :to_ptr
+    def_delegators :to_ptr, :address, :to_i
 
-    attr_reader :size
-
-    def initialize(size)
+    def initialize(size, primitive = nil)
       @size = Utils.get_int(size)
-      @buffer = Sodium.malloc(@size)
+      @primitive = primitive
+      @to_ptr = Sodium.malloc(self.size)
       setup_finalizer
     end
 
-    def to_ptr
-      @buffer
-    end
-
     def free
       remove_finalizer
       readwrite
-      Sodium.free(@buffer)
-      @size = @buffer = nil
+      Sodium.free(to_ptr)
+      @size = @primitive = @to_ptr = nil
     end
 
     def noaccess
-      Sodium.noaccess(@buffer)
+      Sodium.noaccess(to_ptr)
     end
 
     def readonly
-      Sodium.readonly(@buffer)
+      Sodium.readonly(to_ptr)
     end
 
     def readwrite
-      Sodium.readwrite(@buffer)
+      Sodium.readwrite(to_ptr)
     end
 
     private
 
     def setup_finalizer
-      ObjectSpace.define_finalizer(@buffer, self.class.free(address))
+      ObjectSpace.define_finalizer(to_ptr, self.class.free(to_ptr.address))
     end
 
     def remove_finalizer
-      ObjectSpace.undefine_finalizer @buffer
+      ObjectSpace.undefine_finalizer to_ptr
     end
 
     def self.free(address)
       ->(obj_id) do
-        Sodium.readwrite(FFI::Pointer.new(address))
-        Sodium.free(FFI::Pointer.new(address))
+        ptr = FFI::Pointer.new(address)
+        Sodium.readwrite(ptr)
+        Sodium.free(ptr)
         true
       end
     end

data/lib/sodium/utils.rb

@@ -36,15 +36,15 @@ module Sodium
         string
       elsif string.respond_to?(:to_str)
         string.to_str
-      elsif string.respond_to?(:read_string)
-        string.read_string
+      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?(Integer)
+      if int.is_a?(Fixnum)
         int
       elsif int.respond_to?(:to_int)
         int.to_int

data/lib/sodium/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-libsodium
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.1
 platform: ruby
 authors:
 - Hendrik Beskow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-14 00:00:00.000000000 Z
+date: 2014-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi