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 collapse

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 collapse

Methods included from ThemisCommon

empty?, string_to_pointer_size

Methods included from ThemisImport

canonical_themis_paths, load_themis

Class Method Details

.gen_sym_keyObject

[View source]

545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
# File 'lib/rbthemis.rb', line 545

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

[View source]

273
274
275
276
277
278
# File 'lib/rbthemis.rb', line 273

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

[View source]

280
281
282
283
284
285
# File 'lib/rbthemis.rb', line 280

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

[View source]

478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
# File 'lib/rbthemis.rb', line 478

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

[View source]

514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
# File 'lib/rbthemis.rb', line 514

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

[View source]

473
474
475
# File 'lib/rbthemis.rb', line 473

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

.Sverify(*args) ⇒ Object

[View source]

509
510
511
# File 'lib/rbthemis.rb', line 509

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

.valid_key(key) ⇒ Object

[View source]

265
266
267
268
269
270
271
# File 'lib/rbthemis.rb', line 265

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