Module: Themis

Extended by:

Gem::Deprecate, ThemisCommon, ThemisImport

Defined in:

lib/rbthemis.rb

Defined Under Namespace

Classes: Callbacks, SKeyPairGen, Scell, ScellContextImprint, ScellSeal, ScellSealPassphrase, ScellTokenProtect, Scomparator, Smessage, Ssession, ThemisError

Constant Summary

BUFFER_TOO_SMALL =

14

SUCCESS =

0

FAIL =

11

INVALID_ARGUMENT =

12

SEND_AS_IS =

1

Constants included from ThemisImport

ThemisImport::THEMIS_KEY_EC_PRIVATE, ThemisImport::THEMIS_KEY_EC_PUBLIC, ThemisImport::THEMIS_KEY_INVALID, ThemisImport::THEMIS_KEY_RSA_PRIVATE, ThemisImport::THEMIS_KEY_RSA_PUBLIC

Class Method Summary

• .gen_sym_key ⇒ Object
• .private_key(key) ⇒ Object
• .public_key(key) ⇒ Object
• .s_sign(private_key, message) ⇒ Object
• .s_verify(peer_public_key, message) ⇒ Object
• .Ssign(*args) ⇒ Object
• .Sverify(*args) ⇒ Object
• .valid_key(key) ⇒ Object

Methods included from ThemisCommon

empty?, string_to_pointer_size

Class Method Details

.gen_sym_key ⇒ Object

# File 'lib/rbthemis.rb', line 502

def gen_sym_key
  key_length = FFI::MemoryPointer.new(:uint)

  res = themis_gen_sym_key(nil, key_length)
  if res != BUFFER_TOO_SMALL
    raise ThemisError, "failed to get symmetric key size: #{res}"
  end

  key = FFI::MemoryPointer.new(:char, key_length.read_uint)

  res = themis_gen_sym_key(key, key_length)
  if res != SUCCESS
    raise ThemisError, "failed to generate symmetric key: #{res}"
  end

  return key.get_bytes(0, key_length.read_uint)
end

.private_key(key) ⇒ Object

# File 'lib/rbthemis.rb', line 230

def Themis.private_key(key)
  key_, len_ = string_to_pointer_size(key)
  kind = themis_get_asym_key_kind(key_, len_)
  return kind == ThemisImport::THEMIS_KEY_RSA_PRIVATE \
      || kind == ThemisImport::THEMIS_KEY_EC_PRIVATE
end

.public_key(key) ⇒ Object

# File 'lib/rbthemis.rb', line 237

def Themis.public_key(key)
  key_, len_ = string_to_pointer_size(key)
  kind = themis_get_asym_key_kind(key_, len_)
  return kind == ThemisImport::THEMIS_KEY_RSA_PUBLIC \
      || kind == ThemisImport::THEMIS_KEY_EC_PUBLIC
end

.s_sign(private_key, message) ⇒ Object

# File 'lib/rbthemis.rb', line 435

def s_sign(private_key, message)
  if not valid_key(private_key)
    raise ThemisError, "Secure Message: invalid private key"
  end
  if not private_key(private_key)
    raise ThemisError, "Secure Message: public key used instead of private"
  end

  private_key_, private_key_length_ = string_to_pointer_size(private_key)
  message_, message_length_ = string_to_pointer_size(message)

  wrapped_message_length = FFI::MemoryPointer.new(:uint)
  res = themis_secure_message_sign(
    private_key_, private_key_length_, message_,
    message_length_, nil, wrapped_message_length)
  if res != BUFFER_TOO_SMALL
    raise ThemisError, "Secure Message failed to sign: #{res}"
  end

  wrapped_message = FFI::MemoryPointer.new(
    :char, wrapped_message_length.read_uint)
  res = themis_secure_message_sign(
    private_key_, private_key_length_, message_,
    message_length_, wrapped_message, wrapped_message_length)
  if res != SUCCESS
    raise ThemisError, "Secure Message failed to sign: #{res}"
  end

  wrapped_message.get_bytes(0, wrapped_message_length.read_uint)
end

.s_verify(peer_public_key, message) ⇒ Object

# File 'lib/rbthemis.rb', line 471

def s_verify(peer_public_key, message)
  if not valid_key(peer_public_key)
    raise ThemisError, "Secure Message: invalid public key"
  end
  if not public_key(peer_public_key)
    raise ThemisError, "Secure Message: private key used instead of public"
  end

  public_key_, public_key_length_ = string_to_pointer_size(peer_public_key)
  message_, message_length_ = string_to_pointer_size(message)

  unwrapped_message_length = FFI::MemoryPointer.new(:uint)
  res = themis_secure_message_verify(
    public_key_, public_key_length_, message_,
    message_length_, nil, unwrapped_message_length)
  if res != BUFFER_TOO_SMALL
    raise ThemisError, "Secure Message failed to verify: #{res}"
  end

  unwrapped_message = FFI::MemoryPointer.new(
    :char, unwrapped_message_length.read_uint)
  res = themis_secure_message_verify(
    public_key_, public_key_length_, message_,
    message_length_, unwrapped_message, unwrapped_message_length)
  if res != SUCCESS
    raise ThemisError, "Secure Message failed to verify: #{res}"
  end

  unwrapped_message.get_bytes(0, unwrapped_message_length.read_uint)
end

.Ssign(*args) ⇒ Object

# File 'lib/rbthemis.rb', line 430

def Ssign(*args)
  s_sign(*args)
end

.Sverify(*args) ⇒ Object

# File 'lib/rbthemis.rb', line 466

def Sverify(*args)
  s_verify(*args)
end

.valid_key(key) ⇒ Object

# File 'lib/rbthemis.rb', line 222

def Themis.valid_key(key)
  if key.nil? || key.empty?
    return false
  end
  key_, len_ = string_to_pointer_size(key)
  return themis_is_valid_asym_key(key_, len_) == SUCCESS
end