ffi-libsodium 0.0.1

data/lib/crypto/generic_hash.rb

@@ -0,0 +1,123 @@
+require_relative '../sodium'
+require_relative '../sodium/utils'
+require_relative '../sodium/buffer'
+require_relative '../sodium/secret_buffer'
+
+module Crypto
+  module GenericHash
+    extend FFI::Library
+    extend Sodium::Utils
+
+    ffi_lib :libsodium
+
+    attach_function :primitive,     :crypto_generichash_primitive,    [], :string
+    attach_function :bytes_min,     :crypto_generichash_bytes_min,    [], :size_t
+    attach_function :bytes_max,     :crypto_generichash_bytes_max,    [], :size_t
+    attach_function :bytes,         :crypto_generichash_bytes,        [], :size_t
+    attach_function :keybytes_min,  :crypto_generichash_keybytes_min, [], :size_t
+    attach_function :keybytes_max,  :crypto_generichash_keybytes_max, [], :size_t
+    attach_function :keybytes,      :crypto_generichash_keybytes,     [], :size_t
+
+    PRIMITIVE     = primitive.freeze
+    BYTES_MIN     = bytes_min.freeze
+    BYTES_MAX     = bytes_max.freeze
+    BYTES         = bytes.freeze
+    KEYBYTES_MIN  = keybytes_min.freeze
+    KEYBYTES_MAX  = keybytes_max.freeze
+    KEYBYTES      = keybytes.freeze
+
+    attach_function :crypto_generichash,  [:buffer_out, :size_t, :buffer_in, :ulong_long, :buffer_in, :size_t], :int, blocking: true
+
+    class State < FFI::Struct
+      pack 64
+      layout  :h,         [:uint64, 8],
+              :t,         [:uint64, 2],
+              :f,         [:uint64, 2],
+              :buf,       [:uint8, 2 * 128],
+              :buflen,    :size_t,
+              :last_node, :uint8
+    end
+
+    attach_function :crypto_generichash_init,   [State.ptr, :buffer_in, :size_t, :size_t],  :int, blocking: true
+    attach_function :crypto_generichash_update, [State.ptr, :buffer_in, :ulong_long],       :int, blocking: true
+    attach_function :crypto_generichash_final,  [State.ptr, :buffer_out, :ulong_long],      :int, blocking: true
+
+    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
+
+      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)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      rc = crypto_generichash(blake2b, hash_size, message, message_len, key, key_len)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+      if rc == -1
+        raise Sodium::CryptoError
+      end
+
+      blake2b
+    end
+
+    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.to_int} bytes", caller
+      end
+
+      state = State.new
+      blake2b = Sodium::Buffer.new(:uchar, hash_size)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      rc = crypto_generichash_init(state, key, key_len, hash_size)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+      if rc == -1
+        raise Sodium::CryptoError
+      end
+
+      [state, blake2b]
+    end
+
+    def update(state, message)
+      message_len = get_size(message)
+
+      if crypto_generichash_update(state, message, message_len) == -1
+        raise Sodium::CryptoError
+      end
+    end
+
+    def final(state, blake2b)
+      get_pointer(blake2b)
+
+      if crypto_generichash_final(state, blake2b, blake2b.size) == -1
+        raise Sodium::CryptoError
+      end
+
+      blake2b
+    end
+  end
+
+  def self.generichash(*args)
+    GenericHash.generichash(*args)
+  end
+end

data/lib/crypto/one_time_auth.rb

@@ -0,0 +1,87 @@
+require_relative '../sodium'
+require_relative '../sodium/utils'
+require_relative '../sodium/buffer'
+require_relative '../sodium/secret_buffer'
+
+module Crypto
+  module OneTimeAuth
+    extend FFI::Library
+    extend Sodium::Utils
+
+    ffi_lib :libsodium
+
+    attach_function :primitive, :crypto_onetimeauth_primitive, [], :string
+    attach_function :bytes,     :crypto_onetimeauth_bytes,     [], :size_t
+    attach_function :keybytes,  :crypto_onetimeauth_keybytes,  [], :size_t
+
+    PRIMITIVE = primitive.freeze
+    BYTES     = bytes.freeze
+    KEYBYTES  = keybytes.freeze
+
+    attach_function :crypto_onetimeauth,        [:buffer_out, :buffer_in, :ulong_long, :buffer_in], :int
+    attach_function :crypto_onetimeauth_verify, [:buffer_in, :buffer_in, :ulong_long, :buffer_in],  :int
+
+    class State < FFI::Struct
+      layout  :aligner, :ulong_long,
+              :opaque,  [:uchar, 136]
+    end
+
+    attach_function :crypto_onetimeauth_init,   [State.ptr, :buffer_in],              :int
+    attach_function :crypto_onetimeauth_update, [State.ptr, :buffer_in, :ulong_long], :int
+    attach_function :crypto_onetimeauth_final,  [State.ptr, :buffer_out],             :int
+
+    module_function
+
+    def onetimeauth(message, key)
+      message_len = get_size(message)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      out = Sodium::Buffer.new(:uchar, BYTES)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      crypto_onetimeauth(out, message, message_len, key)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+
+      out
+    end
+
+    def verify(out, message, key)
+      check_length(out, BYTES, :Authenticator)
+      message_len = get_size(message)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      rc = crypto_onetimeauth_verify(out, message, message_len, key)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+
+      rc == 0
+    end
+
+    def init(key)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      state = State.new
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      crypto_onetimeauth_init(state, key)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+
+      state
+    end
+
+    def update(state, message)
+      message_len = get_size(message)
+
+      crypto_onetimeauth_update(state, message, message_len)
+    end
+
+    def final(state)
+      out = Sodium::Buffer.new(:uchar, BYTES)
+      crypto_onetimeauth_final(state, out)
+
+      out
+    end
+  end
+
+  def self.onetimeauth(*args)
+    OneTimeAuth.onetimeauth(*args)
+  end
+end

data/lib/crypto/pw_hash/scrypt_salsa208_sha256.rb

@@ -0,0 +1,101 @@
+require_relative '../../sodium'
+require_relative '../../sodium/utils'
+require_relative '../../sodium/buffer'
+require_relative '../../sodium/secret_buffer'
+require_relative '../../random_bytes'
+
+module Crypto
+  module PwHash
+    module ScryptSalsa208SHA256
+      PACK_C    = 'c*'.freeze
+      PRIMITIVE = 'scryptsalsa208sha256'.freeze
+
+      extend FFI::Library
+      extend Sodium::Utils
+
+      ffi_lib :libsodium
+
+      class << self
+        def crypto_pwhash_scryptsalsa208sha256_primitive
+          PRIMITIVE
+        end
+
+        alias_method :primitive, :crypto_pwhash_scryptsalsa208sha256_primitive
+      end
+
+      attach_function :saltbytes, :crypto_pwhash_scryptsalsa208sha256_saltbytes,  [], :size_t
+      attach_function :strbytes,  :crypto_pwhash_scryptsalsa208sha256_strbytes,   [], :size_t
+      attach_function :strprefix, :crypto_pwhash_scryptsalsa208sha256_strprefix,  [], :string
+      attach_function :opslimit_interactive,  :crypto_pwhash_scryptsalsa208sha256_opslimit_interactive, [], :size_t
+      attach_function :memlimit_interactive,  :crypto_pwhash_scryptsalsa208sha256_memlimit_interactive, [], :size_t
+      attach_function :opslimit_sensitive,    :crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive,   [], :size_t
+      attach_function :memlimit_sensitive,    :crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive,   [], :size_t
+
+      SALTBYTES             = saltbytes.freeze
+      STRBYTES              = strbytes.freeze
+      STRPREFIX             = strprefix.freeze
+      OPSLIMIT_INTERACTIVE  = opslimit_interactive.freeze
+      MEMLIMIT_INTERACTIVE  = memlimit_interactive.freeze
+      OPSLIMIT_SENSITIVE    = opslimit_sensitive.freeze
+      MEMLIMIT_SENSITIVE    = memlimit_sensitive.freeze
+
+      attach_function :crypto_pwhash_scryptsalsa208sha256,            [:buffer_out, :ulong_long, :buffer_in, :ulong_long, :buffer_in, :ulong_long, :size_t],  :int, blocking: true
+      attach_function :crypto_pwhash_scryptsalsa208sha256_str,        [:buffer_out, :buffer_in, :ulong_long, :ulong_long, :size_t],                           :int, blocking: true
+      attach_function :crypto_pwhash_scryptsalsa208sha256_str_verify, [:buffer_in, :buffer_in, :ulong_long],                                                  :int, blocking: true
+
+      module_function
+
+      def salt
+        RandomBytes.buf(SALTBYTES)
+      end
+
+      def scryptsalsa208sha256(passwd, outlen, salt, opslimit = OPSLIMIT_INTERACTIVE, memlimit = MEMLIMIT_INTERACTIVE)
+        passwd_len = get_size(passwd)
+        check_length(salt, SALTBYTES, :Salt)
+        if opslimit < OPSLIMIT_INTERACTIVE
+          fail Sodium::LengthError, "Opslimit must be at least #{OPSLIMIT_INTERACTIVE}, got #{opslimit.to_int}", caller
+        end
+        if memlimit < MEMLIMIT_INTERACTIVE
+          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
+          raise NoMemoryError, "Failed to allocate memory max size=#{memlimit.to_int} bytes", caller
+        end
+
+        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
+        if memlimit < MEMLIMIT_INTERACTIVE
+          fail Sodium::LengthError, "Memlimit must be at least #{MEMLIMIT_INTERACTIVE}, got #{memlimit.to_int}", caller
+        end
+
+        hashed_password = FFI::MemoryPointer.new(:char, STRBYTES)
+        if crypto_pwhash_scryptsalsa208sha256_str(hashed_password, passwd, passwd_len, opslimit, memlimit) == -1
+          raise NoMemoryError, "Failed to allocate memory max size=#{memlimit.to_int} bytes", caller
+        end
+
+        hashed_password.read_array_of_char(STRBYTES).pack(PACK_C)
+      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
+      end
+    end
+
+    def self.scryptsalsa208sha256(*args)
+      ScryptSalsa208SHA256.scryptsalsa208sha256(*args)
+    end
+  end
+end

data/lib/crypto/scalar_mult.rb

@@ -0,0 +1,55 @@
+require_relative '../sodium'
+require_relative '../sodium/utils'
+require_relative '../sodium/buffer'
+require_relative '../sodium/secret_buffer'
+require_relative '../random_bytes'
+
+module Crypto
+  module ScalarMult
+    extend FFI::Library
+    extend Sodium::Utils
+
+    ffi_lib :libsodium
+
+    attach_function :primitive,   :crypto_scalarmult_primitive,   [], :string
+    attach_function :bytes,       :crypto_scalarmult_bytes,       [], :size_t
+    attach_function :scalarbytes, :crypto_scalarmult_scalarbytes, [], :size_t
+
+    PRIMITIVE   = primitive.freeze
+    BYTES       = bytes.freeze
+    SCALARBYTES = scalarbytes.freeze
+
+    attach_function :crypto_scalarmult_base,  [:buffer_out, :buffer_in],              :int
+    attach_function :crypto_scalarmult,       [:buffer_out, :buffer_in, :buffer_in],  :int
+
+    module_function
+
+    def base(secret_key)
+      check_length(secret_key, SCALARBYTES, :SecretKey)
+
+      public_key = Sodium::Buffer.new(:uchar, BYTES)
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      crypto_scalarmult_base(public_key, secret_key)
+      secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+
+      public_key
+    end
+
+    def scalarmut(secret_key, public_key)
+      check_length(secret_key, SCALARBYTES, :SecretKey)
+      check_length(public_key, SCALARBYTES, :PublicKey)
+
+      shared_secret = Sodium::SecretBuffer.new(BYTES)
+      secret_key.readonly if secret_key.is_a?(Sodium::SecretBuffer)
+      crypto_scalarmult(shared_secret, secret_key, public_key)
+      secret_key.noaccess if secret_key.is_a?(Sodium::SecretBuffer)
+      shared_secret.noaccess
+
+      shared_secret
+    end
+  end
+
+  def self.scalarmut(*args)
+    ScalarMult.scalarmut(*args)
+  end
+end

data/lib/crypto/secret_box.rb

@@ -0,0 +1,101 @@
+require_relative '../sodium'
+require_relative '../sodium/utils'
+require_relative '../sodium/buffer'
+require_relative '../sodium/secret_buffer'
+require_relative '../random_bytes'
+
+module Crypto
+  module SecretBox
+    extend FFI::Library
+    extend Sodium::Utils
+
+    ffi_lib :libsodium
+
+    attach_function :primitive,   :crypto_secretbox_primitive,  [], :string
+    attach_function :keybytes,    :crypto_secretbox_keybytes,   [], :size_t
+    attach_function :noncebytes,  :crypto_secretbox_noncebytes, [], :size_t
+    attach_function :macbytes,    :crypto_secretbox_macbytes,   [], :size_t
+
+    PRIMITIVE   = primitive.freeze
+    KEYBYTES    = keybytes.freeze
+    NONCEBYTES  = noncebytes.freeze
+    MACBYTES    = macbytes.freeze
+
+    attach_function :crypto_secretbox_easy,       [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in], :int, blocking: true
+    attach_function :crypto_secretbox_open_easy,  [:buffer_out, :buffer_in, :ulong_long, :buffer_in, :buffer_in], :int, blocking: true
+
+    module_function
+
+    def nonce
+      RandomBytes.buf(NONCEBYTES)
+    end
+
+    def easy(message, nonce, key)
+      message_len = get_size(message)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      ciphertext = Sodium::Buffer.new(:uchar, MACBYTES + message_len)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      crypto_secretbox_easy(ciphertext, message, message_len, nonce, key)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+
+      ciphertext
+    end
+
+    def open_easy(ciphertext, nonce, key)
+      ciphertext_len = get_size(ciphertext)
+      check_length(nonce, NONCEBYTES, :Nonce)
+      check_length(key, KEYBYTES, :SecretKey)
+
+      decrypted = Sodium::Buffer.new(:uchar, ciphertext_len - MACBYTES)
+      key.readonly if key.is_a?(Sodium::SecretBuffer)
+      rc = crypto_secretbox_open_easy(decrypted, ciphertext, ciphertext_len, nonce, key)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+      if rc == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      decrypted
+    end
+
+    def easy_in_place(data, nonce, key)
+      message = get_string(data)
+      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)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+
+      message
+    end
+
+    def open_easy_in_place(data, nonce, key, utf8 = false)
+      ciphertext = get_string(data)
+      unless (message_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)
+      rc = crypto_secretbox_open_easy(ciphertext, ciphertext, ciphertext.bytesize, nonce, key)
+      key.noaccess if key.is_a?(Sodium::SecretBuffer)
+      if rc == -1
+        raise Sodium::CryptoError, "Message forged", caller
+      end
+
+      if utf8
+        ciphertext.slice!(message_len..-1).force_encoding(Encoding::UTF_8)
+      else
+        ciphertext.slice!(message_len..-1)
+      end
+
+      ciphertext
+    end
+  end
+end