virgil-sdk 4.2.4 → 4.2.5

data/lib/virgil/sdk/high_level/virgil_card_manager.rb

@@ -71,19 +71,27 @@ module Virgil
           # Encrypts the specified data using recipients Public keys.
           #
           # Args:
-          #   buffer: The data to be encrypted.
+          #   buffer: The data to be encrypted. It can be VirgilBuffer, utf8 String or Array of bytes
           #
           # Returns:
           #   Encrypted data for current recipients Public keys
           #
           # Raises:
-          #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer or String
+          #   ArgumentError: Buffer has unsupported type if buffer doesn't have type VirgilBuffer, String or Array of bytes
           def encrypt(buffer)
-
-            raise ArgumentError.new("buffer is not valid") if !(buffer.is_a?(VirgilBuffer) || buffer.is_a?(String))
-
             all_public_keys = self.map(&:public_key)
-            VirgilBuffer.new(crypto.encrypt(buffer.bytes, *all_public_keys))
+            buffer_to_encrypt = case buffer.class.name.split("::").last
+                                  when 'VirgilBuffer'
+                                    buffer
+                                  when 'String'
+                                    VirgilBuffer.from_string(buffer)
+                                  when 'Array'
+                                    VirgilBuffer.from_bytes(buffer)
+                                  else
+                                    raise ArgumentError.new("Buffer has unsupported type")
+                                end
+
+            VirgilBuffer.new(crypto.encrypt(buffer_to_encrypt.bytes, *all_public_keys))
           end
 
         end

data/lib/virgil/sdk/high_level/virgil_context.rb

@@ -36,18 +36,20 @@ module Virgil
     module HighLevel
       class VirgilContext
         attr_reader :access_token, :client, :crypto, :credentials,
-                    :cards_service_url, :cards_read_only_service_url,
+                    :cards_service_url, :cards_read_only_service_url, :ra_service_url,
                     :identity_service_url, :key_storage
 
-        def initialize(access_token:, credentials: nil, key_storage_path: Cryptography::Keys::KeyStorage.default_folder,
+        def initialize(access_token: nil, credentials: nil, key_storage_path: Cryptography::Keys::KeyStorage.default_folder,
                        cards_service_url: Client::Card::SERVICE_URL,
                        cards_read_only_service_url: Client::Card::READ_ONLY_SERVICE_URL,
+                       ra_service_url: Client::Card::RA_SERVICE_URL,
                        identity_service_url: VirgilIdentity::IDENTITY_SERVICE_URL,
+                       crypto: Cryptography::VirgilCrypto.new,
                        card_verifiers: []
         )
           @access_token = access_token
-          @client = Client::VirgilClient.new(access_token, cards_service_url, cards_read_only_service_url, identity_service_url)
-          @crypto = Cryptography::VirgilCrypto.new
+          @client = Client::VirgilClient.new(access_token, cards_service_url, cards_read_only_service_url, identity_service_url, ra_service_url)
+          @crypto = crypto
           @credentials = credentials
           @key_storage = Cryptography::Keys::KeyStorage.new(key_storage_path)
 

data/lib/virgil/sdk/high_level/virgil_key.rb

@@ -49,18 +49,31 @@ module Virgil
         # Decrypts the specified cipher data using Virgil key.
         #
         # Args:
-        #   cipher_buffer: The encrypted data wrapped by VirgilBuffer.
+        #   cipher_buffer: The encrypted data wrapped by VirgilBuffer or
+        #                  encrypted data in base64-encoded String
+        #                  or Array of bytes of encrypted data
         #
         # Returns:
         #   A byte array containing the result from performing the operation wrapped by VirgilBuffer.
         #
         # Raises:
-        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer or String
+        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer, base64-encoded String or Array of bytes
         #   Recipient with given identifier is not found  if user tries to decrypt cipher data by private key,
         #     though its public key was not used for encryption
         def decrypt(cipher_buffer)
-          VirgilBuffer.validate_buffer_param(cipher_buffer, "cipher buffer")
-          bytes = context.crypto.decrypt(cipher_buffer.bytes, private_key)
+
+          buffer_to_decrypt = case cipher_buffer.class.name.split("::").last
+                                when 'VirgilBuffer'
+                                  cipher_buffer
+                                when 'String'
+                                  VirgilBuffer.from_base64(cipher_buffer)
+                                when 'Array'
+                                  VirgilBuffer.from_bytes(cipher_buffer)
+                                else
+                                  raise ArgumentError.new("Buffer has unsupported type")
+                              end
+
+          bytes = context.crypto.decrypt(buffer_to_decrypt.bytes, private_key)
           VirgilBuffer.new(bytes)
         end
 
@@ -68,17 +81,27 @@ module Virgil
         # Generates a digital signature for specified data using current Virgil key.
         #
         # Args:
-        #   buffer: The data wrapped by VirgilBuffer for which the digital signature will be generated.
+        #   buffer: The data for which the digital signature will be generated.
+        #           buffer can be VirgilBuffer, utf8-encoded String or Array of bytes
         #
         # Returns:
         #   A new buffer that containing the result from performing the operation.
         #
         # Raises:
-        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer or String
+        #   ArgumentError: Buffer has unsupported type if buffer doesn't have type VirgilBuffer, String or Array of bytes
         def sign(buffer)
-          VirgilBuffer.validate_buffer_param(buffer)
-          bytes = context.crypto.sign(buffer.bytes, private_key)
-          VirgilBuffer.new(bytes)
+          buffer_to_sign = case buffer.class.name.split("::").last
+                             when 'VirgilBuffer'
+                               buffer
+                             when 'String'
+                               VirgilBuffer.from_string(buffer)
+                             when 'Array'
+                               VirgilBuffer.from_bytes(buffer)
+                             else
+                               raise ArgumentError.new("Buffer has unsupported type")
+                           end
+
+          VirgilBuffer.new(context.crypto.sign(buffer_to_sign.bytes, private_key).to_s.bytes)
         end
 
 
@@ -86,21 +109,31 @@ module Virgil
         #
         # Args:
         #   buffer: The data wrapped by VirgilBuffer to be encrypted and signed
-        #   recipients: The list of VirgilCard recipients.
+        #     recipients: The list of VirgilCard recipients.
+        #     buffer can be VirgilBuffer, utf8-encoded String or Array of bytes
         #
         # Returns:
         #   A new buffer that containing the encrypted and signed data
         #
 
         # Raises:
-        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer or String
+        #   ArgumentError: Buffer has unsupported type if buffer doesn't have type VirgilBuffer, String or Array of bytes
         #   ArgumentError: recipients is not valid if recipients doesn't have type Array or empty
         def sign_then_encrypt(buffer, recipients)
 
-          VirgilBuffer.validate_buffer_param(buffer)
           raise ArgumentError.new("recipients is not valid") if (!recipients.is_a?(Array) || recipients.empty?)
+          buffer_to_sign = case buffer.class.name.split("::").last
+                             when 'VirgilBuffer'
+                               buffer
+                             when 'String'
+                               VirgilBuffer.from_string(buffer)
+                             when 'Array'
+                               VirgilBuffer.from_bytes(buffer)
+                             else
+                               raise ArgumentError.new("Buffer has unsupported type")
+                           end
           public_keys = recipients.map(&:public_key)
-          bytes = context.crypto.sign_then_encrypt(buffer.bytes, private_key, *public_keys)
+          bytes = context.crypto.sign_then_encrypt(buffer_to_sign.bytes, private_key, *public_keys).to_s.bytes
           VirgilBuffer.new(bytes)
 
         end
@@ -109,21 +142,34 @@ module Virgil
         # Decrypts and verifies the data.
         #
         # Args:
-        #   cipher_buffer: The data to be decrypted and verified
+        #   cipher_buffer: The data to be decrypted and verified:
+        #                  The encrypted data wrapped by VirgilBuffer or
+        #                  encrypted data in base64-encoded String
+        #                  or Array of bytes of encrypted data
         #   card: The signer's VirgilCard
         #
         # Returns:
         #   The decrypted data, which is the original plain text before encryption The decrypted data, wrapped by VirgilBuffer
         #
         # Raises:
-        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer or String
+        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer, String or Array of bytes
         #   ArgumentError: recipients is not valid if recipients doesn't have type Array or empty
         def decrypt_then_verify(cipher_buffer, card)
 
-          VirgilBuffer.validate_buffer_param(cipher_buffer, "cipher buffer")
           raise ArgumentError.new("card is not valid") unless card.is_a?(VirgilCard)
 
-          bytes = context.crypto.decrypt_then_verify(cipher_buffer.bytes, private_key, card.public_key)
+          buffer_to_decrypt = case cipher_buffer.class.name.split("::").last
+                                when 'VirgilBuffer'
+                                  cipher_buffer
+                                when 'String'
+                                  VirgilBuffer.from_base64(cipher_buffer)
+                                when 'Array'
+                                  VirgilBuffer.from_bytes(cipher_buffer)
+                                else
+                                  raise ArgumentError.new("Buffer has unsupported type")
+                              end
+
+          bytes = context.crypto.decrypt_then_verify(buffer_to_decrypt.bytes, private_key, card.public_key)
           VirgilBuffer.new(bytes)
         end
 
@@ -153,6 +199,12 @@ module Virgil
         end
 
 
+        # Exports the VirgilKey to default format, specified in Crypto API.
+        def export(password=nil)
+          VirgilBuffer.from_bytes(context.crypto.export_private_key(private_key, password))
+        end
+
+
         #  Exports the Public key value from current VirgilKey.
         #
         # Returns:

data/lib/virgil/sdk/high_level/virgil_key_manager.rb

@@ -74,6 +74,16 @@ module Virgil
 
         end
 
+        # Imports the VirgilKey from buffer.
+        #
+        # Args:
+        #   buffer: The buffer with Key
+        #   password: The Key password
+        def import(buffer, password=nil)
+          private_key = context.crypto.import_private_key(buffer.bytes, password)
+          VirgilKey.new(context, private_key)
+        end
+
 
         # Remove the VirgilKey from current storage by specified key name.
         #

data/lib/virgil/sdk/version.rb

@@ -1,5 +1,5 @@
 module Virgil
   module SDK
-    VERSION = "4.2.4"
+    VERSION = "4.2.5"
   end
 end

data/virgil-sdk.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = '>= 2.2.0'
-  spec.add_runtime_dependency "virgil-crypto", ">= 2.0.6r4"
+  spec.add_runtime_dependency "virgil-crypto", ">= 2.0.7"
   spec.add_runtime_dependency "faraday", "~> 0.10.0"
   spec.add_runtime_dependency "faraday_middleware", "~> 0.10.0"
   spec.add_development_dependency "bundler", "~> 1.12"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: virgil-sdk
 version: !ruby/object:Gem::Version
-  version: 4.2.4
+  version: 4.2.5
 platform: ruby
 authors:
 - Dmitriy Dudkin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-02 00:00:00.000000000 Z
+date: 2017-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virgil-crypto
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.6r4
+        version: 2.0.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.6r4
+        version: 2.0.7
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -119,6 +119,7 @@ files:
 - ".gitignore"
 - Gemfile
 - README.md
+- README_LOW_LEVEL.md
 - Rakefile
 - bin/console
 - bin/setup
@@ -139,13 +140,14 @@ files:
 - lib/virgil/sdk/client/http/request.rb
 - lib/virgil/sdk/client/request_signer.rb
 - lib/virgil/sdk/client/requests.rb
+- lib/virgil/sdk/client/requests/add_relation_request.rb
 - lib/virgil/sdk/client/requests/confirm_identity_request.rb
 - lib/virgil/sdk/client/requests/create_card_request.rb
+- lib/virgil/sdk/client/requests/delete_relation_request.rb
 - lib/virgil/sdk/client/requests/revoke_card_request.rb
 - lib/virgil/sdk/client/requests/signable_request.rb
 - lib/virgil/sdk/client/requests/verify_identity_request.rb
 - lib/virgil/sdk/client/search_criteria.rb
-- lib/virgil/sdk/client/signatures_base64.rb
 - lib/virgil/sdk/client/virgil_client.rb
 - lib/virgil/sdk/cryptography.rb
 - lib/virgil/sdk/cryptography/hashes.rb

data/lib/virgil/sdk/client/signatures_base64.rb

@@ -1,25 +0,0 @@
-module Virgil
-  module SDK
-    module Client
-      module SignaturesBase64
-
-        def signatures_to_base64(signatures_bytes)
-          encoded_signatures = {}
-          signatures_bytes.each do |key, val|
-            encoded_signatures[key] = Base64.strict_encode64(Virgil::Crypto::Bytes.new(val).to_s) #TODO
-          end
-          encoded_signatures
-        end
-
-
-        def signatures_from_base64(signatures_base64)
-          decoded_signatures = {}
-          signatures_base64.each do |key, val|
-            decoded_signatures[key] = Virgil::Crypto::Bytes.from_base64(val)
-          end
-          decoded_signatures
-        end
-      end
-    end
-  end
-end