rubythemis 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b9d86848a6e79af3e64bb73c9f7398d7a21798ab
-  data.tar.gz: 3fafdff57341e45fa5a2a5594c26a44aaf073333
+  metadata.gz: 010a5172a65b943185448f107916d3bab8433f79
+  data.tar.gz: 9d24683b1218f954d2733348d02806981711d070
 SHA512:
-  metadata.gz: ac6285f33af9355895a06f219edf4c182e738abf708d243d259b83c0d41d3b93f2318d2eadd0f8e127eec6ce86487ec8da503ad4fbfc0516d731af3e7b7aae1a
-  data.tar.gz: 555da9a428bf300666444ac0df91b129450b297678c7b0e583fb1746edb269789c6c568ea7413c04e679c99b6e028e07c6cadfc6f06ebfde15c6b6dd5d9d7fe2
+  metadata.gz: 431df4be161fe1fd0b002ed3b4fc29ef4406a206977c7cb532faeffb2b963dda0413590ff77d4ba60e4ba47f6bf621d575f077ac993d096ad109c6fa23a85278
+  data.tar.gz: 2bb25ba4d01363b9f139af7693fb16eb4bbc98d3dacbb1ba3eb7dddc15cd80e4a51c0b10354a6c7c1dc5157a3fb6faf4b91f1833a1585a6faa4887a0f4bd215a

data/lib/rubythemis.rb

@@ -112,11 +112,11 @@ module Themis
 		private_key_length=FFI::MemoryPointer.new(:uint)
 		public_key_length= FFI::MemoryPointer.new(:uint)
 		res=themis_gen_ec_key_pair(nil, private_key_length, nil, public_key_length)
-		raise ThemisError, "themis_gen_ec_key_pair (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL 
+		raise ThemisError, "Themis failed generating EC KeyPair: #{res}" unless res == BUFFER_TOO_SMALL 
 		private_key = FFI::MemoryPointer.new(:char, private_key_length.read_uint)
 		public_key = FFI::MemoryPointer.new(:char, public_key_length.read_uint)
 		res=themis_gen_ec_key_pair(private_key, private_key_length, public_key, public_key_length)
-		raise ThemisError, "themis_gen_ec_key_pair error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Themis failed generating EC KeyPair: #{res}" unless res == SUCCESS
 		return private_key.get_bytes(0, private_key_length.read_uint), public_key.get_bytes(0, public_key_length.read_uint)
 	end
 
@@ -124,11 +124,11 @@ module Themis
 		private_key_length=FFI::MemoryPointer.new(:uint)
 		public_key_length= FFI::MemoryPointer.new(:uint)
 		res=themis_gen_rsa_key_pair(nil, private_key_length, nil, public_key_length)
-		raise ThemisError, "themis_gen_ec_key_pair (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL 
+		raise ThemisError, "Themis failed generating RSA KeyPair: #{res}" unless res == BUFFER_TOO_SMALL 
 		private_key = FFI::MemoryPointer.new(:char, private_key_length.read_uint)
 		public_key = FFI::MemoryPointer.new(:char, public_key_length.read_uint)
 		res=themis_gen_rsa_key_pair(private_key, private_key_length, public_key, public_key_length)
-		raise ThemisError, "themis_gen_ec_key_pair error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Themis failed generating RSA KeyPair: #{res}" unless res == SUCCESS
 		return private_key.get_bytes(0, private_key_length.read_uint), public_key.get_bytes(0, public_key_length.read_uint)
 	end
     end
@@ -157,7 +157,7 @@ module Themis
 		@callbacks[:user_data] = FFI::MemoryPointer.new(:uint64)
 		@callbacks[:user_data].write_uint64(@transport_obj_id)
 		@session=secure_session_create(id_buf, id_length, private_key_buf, private_key_length, @callbacks);
-	        raise ThemisError, "secure_session_create error" unless @session
+	        raise ThemisError, "Secure Session failed creating" unless @session
 	end
 	
 	def is_established()
@@ -167,10 +167,10 @@ module Themis
 	def connect_request()
 		connect_request_length = FFI::MemoryPointer.new(:uint)
 		res=secure_session_generate_connect_request(@session, nil, connect_request_length)
-		raise ThemisError, "secure_session_generate_connect_request (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Session failed making connection request: #{res}" unless res == BUFFER_TOO_SMALL
 		connect_request = FFI::MemoryPointer.new(:char, connect_request_length.read_uint)
 		res=secure_session_generate_connect_request(@session, connect_request, connect_request_length)
-		raise ThemisError, "secure_session_generate_connect_request error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Secure Session failed making connection request: #{res}" unless res == SUCCESS
 		return connect_request.get_bytes(0, connect_request_length.read_uint);
 	end
 
@@ -178,13 +178,13 @@ module Themis
 		message_, message_length_=string_to_pointer_size(message)
 		unwrapped_message_length = FFI::MemoryPointer.new(:uint)
 		res=secure_session_unwrap(@session,  message_, message_length_, nil, unwrapped_message_length)
-		raise ThemisError, "secure_session_unwrap (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL || res == SUCCESS
+		raise ThemisError, "Secure Session failed decrypting: #{res}" unless res == BUFFER_TOO_SMALL || res == SUCCESS
 		if res == SUCCESS
 		    return SUCCESS, ""
 		end
 		unwrapped_message = FFI::MemoryPointer.new(:char, unwrapped_message_length.read_uint)
 		res=secure_session_unwrap(@session, message_, message_length_, unwrapped_message, unwrapped_message_length)
-		raise ThemisError, "secure_session_unwrap error: #{res}" unless res == SUCCESS || res == SEND_AS_IS 
+		raise ThemisError, "Secure Session failed decrypting: #{res}" unless res == SUCCESS || res == SEND_AS_IS 
 		return res, unwrapped_message.get_bytes(0, unwrapped_message_length.read_uint);
 	end
 
@@ -192,16 +192,16 @@ module Themis
 		message_, message_length_=string_to_pointer_size(message)
 		wrapped_message_length = FFI::MemoryPointer.new(:uint)
 		res=secure_session_wrap(@session,  message_, message_length_, nil, wrapped_message_length)
-		raise ThemisError, "secure_session_wrap (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Session failed encrypting: #{res}" unless res == BUFFER_TOO_SMALL
 		wrapped_message = FFI::MemoryPointer.new(:char, wrapped_message_length.read_uint)
 		res=secure_session_wrap(@session, message_, message_length_, wrapped_message, wrapped_message_length)
-		raise ThemisError, "secure_session_wrap error: #{res}" unless res == SUCCESS || res == SEND_AS_IS 
+		raise ThemisError, "Secure Session failed encrypting: #{res}" unless res == SUCCESS || res == SEND_AS_IS 
 		return wrapped_message.get_bytes(0, wrapped_message_length.read_uint);
 	end
 
 	def finalize
 		res=secure_session_destroy(@session)
-	        raise ThemisError, "secure_session_destroy error" unless res == SUCCESS
+	        raise ThemisError, "Secure Session failed destroying" unless res == SUCCESS
 		
 	end
     end
@@ -218,10 +218,10 @@ module Themis
 	    message_, message_length_=string_to_pointer_size(message)
 	    wrapped_message_length = FFI::MemoryPointer.new(:uint)
 	    res=themis_secure_message_wrap(@private_key, @private_key_length, @peer_public_key, @peer_public_key_length, message_, message_length_, nil, wrapped_message_length)
-	    raise ThemisError, "themis_secure_message_wrap (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+	    raise ThemisError, "Secure Message failed encrypting: #{res}" unless res == BUFFER_TOO_SMALL
 	    wrapped_message = FFI::MemoryPointer.new(:char, wrapped_message_length.read_uint)
 	    res=themis_secure_message_wrap(@private_key, @private_key_length, @peer_public_key, @peer_public_key_length, message_, message_length_, wrapped_message, wrapped_message_length)
-	    raise ThemisError, "themis_secure_message_wrap error: #{res}" unless res == SUCCESS
+	    raise ThemisError, "Secure Message failed encrypting: #{res}" unless res == SUCCESS
 	    return wrapped_message.get_bytes(0, wrapped_message_length.read_uint);
 	end
 
@@ -229,10 +229,10 @@ module Themis
 	    message_, message_length_=string_to_pointer_size(message)
 	    unwrapped_message_length = FFI::MemoryPointer.new(:uint)
 	    res=themis_secure_message_unwrap(@private_key, @private_key_length, @peer_public_key, @peer_public_key_length, message_, message_length_, nil, unwrapped_message_length)
-	    raise ThemisError, "themis_secure_message_unwrap (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+	    raise ThemisError, "Secure Message failed decrypting: #{res}" unless res == BUFFER_TOO_SMALL
 	    unwrapped_message = FFI::MemoryPointer.new(:char, unwrapped_message_length.read_uint)
 	    res=themis_secure_message_unwrap(@private_key, @private_key_length, @peer_public_key, @peer_public_key_length, message_, message_length_, unwrapped_message, unwrapped_message_length)
-	    raise ThemisError, "themis_secure_message_unwrap error: #{res}" unless res == SUCCESS
+	    raise ThemisError, "Secure Message failed decrypting: #{res}" unless res == SUCCESS
 	    return unwrapped_message.get_bytes(0, unwrapped_message_length.read_uint);
 	end
     end
@@ -242,10 +242,10 @@ module Themis
 	    message_, message_length_=string_to_pointer_size(message)
 	    wrapped_message_length = FFI::MemoryPointer.new(:uint)
 	    res=themis_secure_message_wrap(private_key_, private_key_length_, nil, 0, message_, message_length_, nil, wrapped_message_length)
-	    raise ThemisError, "themis_secure_message_wrap (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+	    raise ThemisError, "Secure Message failed singing: #{res}" unless res == BUFFER_TOO_SMALL
 	    wrapped_message = FFI::MemoryPointer.new(:char, wrapped_message_length.read_uint)
 	    res=themis_secure_message_wrap(private_key_, private_key_length_, nil, 0, message_, message_length_, wrapped_message, wrapped_message_length)
-	    raise ThemisError, "themis_secure_message_wrap error: #{res}" unless res == SUCCESS
+	    raise ThemisError, "Secure Message failed singing: #{res}" unless res == SUCCESS
 	    return wrapped_message.get_bytes(0, wrapped_message_length.read_uint);
     end
 
@@ -256,10 +256,10 @@ module Themis
 	    message_, message_length_=string_to_pointer_size(message)
 	    unwrapped_message_length = FFI::MemoryPointer.new(:uint)
 	    res=themis_secure_message_unwrap(nil, 0, public_key_, public_key_length_, message_, message_length_, nil, unwrapped_message_length)
-	    raise ThemisError, "themis_secure_message_unwrap (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+	    raise ThemisError, "Secure Message failed verifying: #{res}" unless res == BUFFER_TOO_SMALL
 	    unwrapped_message = FFI::MemoryPointer.new(:char, unwrapped_message_length.read_uint)
 	    res=themis_secure_message_unwrap(nil, 0, public_key_, public_key_length_, message_, message_length_, unwrapped_message, unwrapped_message_length)
-	    raise ThemisError, "themis_secure_message_unwrap error: #{res}" unless res == SUCCESS
+	    raise ThemisError, "Secure Message failed verifying: #{res}" unless res == SUCCESS
 	    return unwrapped_message.get_bytes(0, unwrapped_message_length.read_uint);
     end
 
@@ -284,28 +284,28 @@ module Themis
 	    case @mode
 	    when SEAL_MODE
 		res=themis_secure_cell_encrypt_seal(@key, @key_length, context_, context_length_, message_, message_length_, nil, encrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_seal (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Cell (Seal) failed encrypting: #{res}" unless res == BUFFER_TOO_SMALL
 		encrypted_message = FFI::MemoryPointer.new(:char, encrypted_message_length.read_uint)
 		res=themis_secure_cell_encrypt_seal(@key, @key_length, context_, context_length_, message_, message_length_, encrypted_message, encrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_seal error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Secure Cell (Seal) failed encrypting: #{res}" unless res == SUCCESS
 		return encrypted_message.get_bytes(0, encrypted_message_length.read_uint)
 	    when TOKEN_PROTECT_MODE
 		res=themis_secure_cell_encrypt_token_protect(@key, @key_length, context_, context_length_, message_, message_length_, nil, enccontext_length, nil, encrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_token_protect (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Cell (Token protect) failed encrypting: #{res}" unless res == BUFFER_TOO_SMALL
 		encrypted_message = FFI::MemoryPointer.new(:char, encrypted_message_length.read_uint)
 		enccontext = FFI::MemoryPointer.new(:char, enccontext_length.read_uint)
 		res=themis_secure_cell_encrypt_token_protect(@key, @key_length, context_, context_length_, message_, message_length_, enccontext, enccontext_length, encrypted_message, encrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_token_protect error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Secure Cell (Token Protect) failed encrypting: #{res}" unless res == SUCCESS
 		return enccontext.get_bytes(0, enccontext_length.read_uint), encrypted_message.get_bytes(0, encrypted_message_length.read_uint)
 	    when CONTEXT_IMPRINT_MODE
 		res=themis_secure_cell_encrypt_context_imprint(@key, @key_length, message_, message_length_, context_, context_length_, nil, encrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_context_imprint (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Cell (Context Imprint) failed encrypting: #{res}" unless res == BUFFER_TOO_SMALL
 		encrypted_message = FFI::MemoryPointer.new(:char, encrypted_message_length.read_uint)
 		res=themis_secure_cell_encrypt_context_imprint(@key, @key_length, message_, message_length_, context_, context_length_, encrypted_message, encrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_context_imprint error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Secure Cell (Context Imprint) failed encrypting: #{res}" unless res == SUCCESS
 		return encrypted_message.get_bytes(0, encrypted_message_length.read_uint)
 	    else
-		raise ThemisError, "themis_secure_cell not supported mode"
+		raise ThemisError, "Secure Cell failed encrypting, undefined mode"
 	    end
 	end
 
@@ -316,31 +316,31 @@ module Themis
 	    when SEAL_MODE
 		message_, message_length_ = string_to_pointer_size(message)
 		res=themis_secure_cell_decrypt_seal(@key, @key_length, context_, context_length_, message_, message_length_, nil, decrypted_message_length)
-		raise ThemisError, "themis_secure_cell_decrypt_seal (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Cell (Seal) failed decrypting: #{res}" unless res == BUFFER_TOO_SMALL
 		decrypted_message = FFI::MemoryPointer.new(:char, decrypted_message_length.read_uint)
 		res=themis_secure_cell_decrypt_seal(@key, @key_length, context_, context_length_, message_, message_length_, decrypted_message, decrypted_message_length)
-		raise ThemisError, "themis_secure_cell_decrypt_seal error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Secure Cell (Seal) failed decrypting: #{res}" unless res == SUCCESS
 		return decrypted_message.get_bytes(0, decrypted_message_length.read_uint)
 	    when TOKEN_PROTECT_MODE
 		enccontext, message_ = message
 		message__, message_length__ = string_to_pointer_size(message_)
 		enccontext_, enccontext_length = string_to_pointer_size(enccontext)
 		res=themis_secure_cell_decrypt_token_protect(@key, @key_length, context_, context_length_, message__, message_length__, enccontext_, enccontext_length, nil, decrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_token_protect (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Cell (Token Protect) failed decrypting: #{res}" unless res == BUFFER_TOO_SMALL
 		decrypted_message = FFI::MemoryPointer.new(:char, decrypted_message_length.read_uint)
 		res=themis_secure_cell_decrypt_token_protect(@key, @key_length, context_, context_length_, message__, message_length__, enccontext_, enccontext_length, decrypted_message, decrypted_message_length)
-		raise ThemisError, "themis_secure_cell_encrypt_token_protect error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Secure Cell (Token Protect) failed decrypting: #{res}" unless res == SUCCESS
 		return  decrypted_message.get_bytes(0, decrypted_message_length.read_uint)
 	    when CONTEXT_IMPRINT_MODE
 		message_, message_length_ = string_to_pointer_size(message)
 		res=themis_secure_cell_decrypt_context_imprint(@key, @key_length, message_, message_length_, context_, context_length_, nil, decrypted_message_length)
-		raise ThemisError, "themis_secure_cell_decrypt_context_imprint (length determination) error: #{res}" unless res == BUFFER_TOO_SMALL
+		raise ThemisError, "Secure Cell (Context Imprint) failed decrypting: #{res}" unless res == BUFFER_TOO_SMALL
 		decrypted_message = FFI::MemoryPointer.new(:char, decrypted_message_length.read_uint)
 		res=themis_secure_cell_decrypt_context_imprint(@key, @key_length, message_, message_length_, context_, context_length_, decrypted_message, decrypted_message_length)
-		raise ThemisError, "themis_secure_cell_decrypt_context_imprint error: #{res}" unless res == SUCCESS
+		raise ThemisError, "Secure Cell (Context Imprint) failed decrypting: #{res}" unless res == SUCCESS
 		return decrypted_message.get_bytes(0, decrypted_message_length.read_uint)
 	    else
-		raise ThemisError, "themis_secure_cell not supported mode"
+		raise ThemisError, "Secure Cell failed encrypting, undefined mode"
 	    end
 	end
     end
@@ -356,23 +356,23 @@ module Themis
       def initialize(shared_secret)
 	shared_secret_buf, shared_secret_length = string_to_pointer_size(shared_secret)
 	@comparator=secure_comparator_create()
-	raise ThemisError, "secure_comparator_create error" unless @comparator
+	raise ThemisError, "Secure Comparator failed creating" unless @comparator
         res=secure_comparator_append_secret(@comparator, shared_secret_buf, shared_secret_length)
-	raise ThemisError, "secure_comparator_append_secret error" unless res==SUCCESS            
+	raise ThemisError, "Secure Comparator failed appending secret" unless res==SUCCESS            
       end
 
       def finalize()
         res=secure_comparator_destroy(@comparator)
-	raise ThemisError, "secure_comparator_destroy error" unless res==SUCCESS                      
+	raise ThemisError, "Secure Comparator failed destroying" unless res==SUCCESS                      
       end
 
       def begin_compare()
         res_length=FFI::MemoryPointer.new(:uint)
         res=secure_comparator_begin_compare(@comparator, nil, res_length)
-        raise ThemisError, "secure_comparator_begin_compare (length determination) error" unless res==BUFFER_TOO_SMALL
+        raise ThemisError, "Secure Comparator failed making initialisation message" unless res==BUFFER_TOO_SMALL
         res_buffer=FFI::MemoryPointer.new(:char, res_length.read_uint)
         res=secure_comparator_begin_compare(@comparator, res_buffer, res_length)
-        raise ThemisError, "secure_comparator_begin_compare error" unless res==SUCCESS || res==SEND_AS_IS
+        raise ThemisError, "Secure Comparator failed making initialisation message" unless res==SUCCESS || res==SEND_AS_IS
         return res_buffer.get_bytes(0,res_length.read_uint)
       end
 
@@ -380,13 +380,13 @@ module Themis
         message, message_length = string_to_pointer_size(control_message)
         res_length=FFI::MemoryPointer.new(:uint)
         res=secure_comparator_proceed_compare(@comparator, message, message_length, nil, res_length)
-        raise ThemisError, "secure_comparator_proceed_compare (length determination) error" unless res==SUCCESS || res == BUFFER_TOO_SMALL
+        raise ThemisError, "Secure Comparator failed proeeding message" unless res==SUCCESS || res == BUFFER_TOO_SMALL
         if res == SUCCESS
           return ""
         end
         res_buffer=FFI::MemoryPointer.new(:char, res_length.read_uint)
         res=secure_comparator_proceed_compare(@comparator, message, message_length, res_buffer, res_length)
-        raise ThemisError, "secure_comparator_proceed_compare error" unless res==SUCCESS || res==SEND_AS_IS
+        raise ThemisError, "Secure Comparator failed proeeding message" unless res==SUCCESS || res==SEND_AS_IS
         return res_buffer.get_bytes(0,res_length.read_uint)          
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubythemis
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - CossackLabs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2016-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -60,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- libthemis, v0.9.2
+- libthemis, v0.9.3
 rubyforge_project: 
 rubygems_version: 2.4.5
 signing_key: