virgil-sdk 4.2.3

data/lib/virgil/sdk/high_level.rb

@@ -0,0 +1,21 @@
+module Virgil
+  module SDK
+    module HighLevel
+    autoload :VirgilApi, 'virgil/sdk/high_level/virgil_api'
+    autoload :VirgilIdentity, 'virgil/sdk/high_level/virgil_identity'
+    autoload :Card, 'virgil/sdk/client/card'
+    autoload :VirgilCard, 'virgil/sdk/high_level/virgil_card'
+    autoload :VirgilKey, 'virgil/sdk/high_level/virgil_key'
+    autoload :VirgilContext, 'virgil/sdk/high_level/virgil_context'
+    autoload :VirgilKeyManager, 'virgil/sdk/high_level/virgil_key_manager'
+    autoload :VirgilCardManager, 'virgil/sdk/high_level/virgil_card_manager'
+    autoload :VirgilAppCredentials, 'virgil/sdk/high_level/virgil_app_credentials'
+    autoload :IdentityAttempt, 'virgil/sdk/high_level/identity_attempt'
+    autoload :VirgilBuffer, 'virgil/sdk/high_level/virgil_buffer'
+    autoload :VirgilStringEncoding, 'virgil/sdk/high_level/virgil_buffer'
+    autoload :VirgilCardVerifierInfo, 'virgil/sdk/high_level/virgil_card_verifier_info'
+
+    end
+  end
+end
+

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

@@ -0,0 +1,71 @@
+# Copyright (C) 2016 Virgil Security Inc.
+#
+# Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#   (1) Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+#   (2) Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+#
+#   (3) Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+module Virgil
+  module SDK
+    module HighLevel
+      class VirgilApi
+        attr_accessor :context, :keys, :cards
+
+        class VirgilApiException < StandardError
+
+        end
+
+        class VirgilApiAccessTokenException < VirgilApiException
+
+          def to_s
+            "Access tokens are not equal"
+          end
+
+        end
+
+        def initialize(access_token: nil, context: nil)
+
+          if (access_token && context)
+            raise VirgilApiAccessTokenException.new unless access_token == context.access_token
+          end
+
+
+          if context
+            self.context = context
+          else
+            self.context = Virgil::SDK::HighLevel::VirgilContext.new(access_token: access_token)
+          end
+
+          self.keys = VirgilKeyManager.new(self.context)
+          self.cards = VirgilCardManager.new(self.context)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# Copyright (C) 2016 Virgil Security Inc.
+#
+# Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#   (1) Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+#   (2) Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+#
+#   (3) Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+module Virgil
+  module SDK
+    module HighLevel
+      class VirgilAppCredentials
+        attr_reader :app_id, :app_key_data, :app_key_password
+
+        def initialize(app_id:, app_key_data:, app_key_password:)
+          @app_id = app_id
+          @app_key_data = app_key_data
+          @app_key_password = app_key_password
+        end
+
+        def app_key(crypto)
+          crypto.import_private_key(app_key_data.bytes, app_key_password)
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,161 @@
+# Copyright (C) 2016 Virgil Security Inc.
+#
+# Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#   (1) Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+#   (2) Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+#
+#   (3) Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+require 'base64'
+require 'json'
+
+module Virgil
+  module SDK
+    module HighLevel
+
+      # This class provides a list of methods that simplify the work with an array of bytes.
+      VirgilBuffer = Struct.new(:bytes) do
+
+        def initialize(bytes)
+
+          self.class.validate_bytes_param(bytes)
+
+          super
+        end
+
+
+        def self.from_bytes(bytes)
+
+          self.validate_bytes_param(bytes)
+
+          new(bytes)
+
+        end
+
+
+        def self.from_string(str, encoding=VirgilStringEncoding::UTF8)
+
+          case encoding
+            when VirgilStringEncoding::BASE64
+              return self.from_base64(str)
+            when VirgilStringEncoding::HEX
+              return self.from_hex(str)
+            when VirgilStringEncoding::UTF8
+              return self.from_utf8(str)
+            else
+              ArgumentError.new("encoding is undefined")
+          end
+
+        end
+
+
+        def to_string(encoding=VirgilStringEncoding::UTF8)
+          case encoding
+            when VirgilStringEncoding::BASE64
+              return self.to_base64
+            when VirgilStringEncoding::HEX
+              return self.to_hex
+            when VirgilStringEncoding::UTF8
+              return to_s
+            else
+              ArgumentError.new("encoding is undefined")
+          end
+        end
+
+
+        def to_s
+          bytes.pack('c*')
+        end
+
+        # Initializes a new buffer from file.
+        def self.from_file(key_file_path)
+          ArgumentError.new("file_path is not valide") unless (File.exist?(key_file_path) && File.readable?(key_file_path))
+          str = File.read(key_file_path)
+          from_string(str)
+        end
+
+
+        # Initializes a new buffer from specified string, which encodes binary data as base-64 digits.
+        def self.from_base64(str)
+          new(Base64.decode64(str).bytes)
+        end
+
+
+        #Initializes a new buffer from specified string, which encodes binary data as utf-8.
+        def self.from_utf8(str)
+          new(str.bytes)
+        end
+
+
+        # Initializes a new buffer from specified string, which encodes binary data as hexadecimal digits.
+        def self.from_hex(str)
+          new(str.scan(/../).map { |x| x.hex })
+        end
+
+
+        # Converts all the bytes in current buffer to its equivalent string representation that
+        # is encoded with base-64 digits.
+        def to_base64
+          Base64.strict_encode64(to_s)
+        end
+
+
+        # Decodes all the bytes in current buffer into a string.
+        def to_utf8
+          to_s
+        end
+
+
+        # Converts the numeric value of each element of a current buffer bytes to its
+        # equivalent hexadecimal string representation.
+        def to_hex
+          to_s.each_byte.map { |b| b.to_s(16) }.join
+        end
+
+
+        def self.validate_buffer_param(param, param_name="buffer")
+          raise ArgumentError.new("#{param_name} is not valid") unless (param.is_a?(VirgilBuffer) || param.is_a?(String))
+        end
+
+        private
+
+        def self.validate_bytes_param(param)
+          raise ArgumentError.new("bytes is not valid") if (!param.is_a?(Array) || param.empty?)
+        end
+
+      end
+
+      module VirgilStringEncoding
+        BASE64 = 1
+        HEX = 2
+        UTF8 = 3
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+# Copyright (C) 2016 Virgil Security Inc.
+#
+# Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#   (1) Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+#   (2) Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+#
+#   (3) Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+module Virgil
+  module SDK
+    module HighLevel
+      # A Virgil Card is the main entity of the Virgil Security services, it includes an information
+      # about the user and his public key. The Virgil Card identifies the user by one of his available
+      # types, such as an email, a phone number, etc.
+      class VirgilCard
+        attr_reader :context, :card
+        protected :context, :card
+
+        def initialize(context:, card:)
+          @context = context
+          @card = card
+        end
+
+
+        class AppCredentialsException < StandardError
+
+          def to_s
+            "For this operation we need app_id and app_key"
+          end
+
+        end
+
+
+        def id
+          card.id
+        end
+
+
+        def identity
+          card.identity
+        end
+
+
+        def identity_type
+          card.identity_type
+        end
+
+
+        def data
+          card.data
+        end
+
+
+        def scope
+          card.scope
+        end
+
+        def public_key
+          context.crypto.import_public_key(card.public_key)
+        end
+
+
+        def device
+          card.device
+        end
+
+
+        def device_name
+          card.device_name
+        end
+
+
+        # Exports card's snapshot.
+        #
+        # Returns:
+        #   base64-encoded json representation of card's content_snapshot and meta.
+        def export
+          card.export
+        end
+
+
+        # Publish synchronously the card into application Virgil Services scope
+        # Raises:
+        # Virgil::SDK::Client::HTTP::BaseConnection::ApiError if access_token is invalid or
+        #  Virgil Card with the same fingerprint already exists in Virgil Security services
+        # AppCredentialsException:  For this operation we need app_id and app_key
+        #  if application credentials is missing
+        def publish
+
+          raise NotImplementedError.new("Current card isn't local!") unless @card.scope == Client::Card::APPLICATION
+          validate_app_credentials
+
+          @card = context.client.sign_and_publish_card(
+              card,
+              context.credentials.app_id,
+              context.credentials.app_key(context.crypto))
+        end
+
+
+        # Publish synchronously the global card into application Virgil Services scope
+        # Raises:
+        # Virgil Card with the same fingerprint already exists in Virgil Security services
+        def publish_as_global(validation_token)
+
+          raise NotImplementedError.new("Current card isn't global!") unless @card.scope == Client::Card::GLOBAL
+
+          @card.validation_token = validation_token
+          @card = context.client.publish_as_global_card(card)
+          @card.validation_token = validation_token
+        end
+
+
+        # Encrypts the specified data for current Virgil card recipient
+        #
+        # Args:
+        #   buffer: The data to be encrypted.
+        #
+        # Returns:
+        #   Encrypted data for current Virgil card recipient
+        #
+        # Raises:
+        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer or String
+        def encrypt(buffer)
+
+          VirgilBuffer.validate_buffer_param(buffer)
+
+          VirgilBuffer.new(context.crypto.encrypt(buffer.bytes, public_key))
+        end
+
+
+        # Initiates an identity verification process for current Card indentity type. It is only working for
+        #  Global identity types like Email.
+        #
+        # Args:
+        #   identity_options: The data to be encrypted.
+        #
+        # Returns:
+        #   An instance of VirgilIdentity::VerificationAttempt that contains
+        #   information about operation etc
+        def check_identity(identity_options = nil)
+          action_id = context.client.verify_identity(identity, identity_type)
+          VirgilIdentity::VerificationAttempt.new(context: context, action_id: action_id,
+                                                  identity: identity, identity_type: identity_type,
+                                                  additional_options: identity_options)
+        end
+
+
+        #  Verifies the specified buffer and signature with current VirgilCard recipient
+        #
+        # Args:
+        #   buffer: The data to be verified.
+        #   signature: The signature used to verify the data integrity.
+        #
+        # Returns:
+        #    true if signature is valid, false otherwise.
+        #
+        # Raises:
+        #   ArgumentError: buffer is not valid if buffer doesn't have type VirgilBuffer or String
+        #   ArgumentError: buffer is not valid if signature doesn't have type VirgilBuffer or String
+        def verify(buffer, signature)
+          VirgilBuffer.validate_buffer_param(buffer)
+          VirgilBuffer.validate_buffer_param(signature, "signature")
+          context.crypto.verify(buffer.bytes, signature.bytes, public_key)
+        end
+
+        private
+
+        def validate_app_credentials
+
+          if !(context.credentials && context.credentials.app_id && context.credentials.app_key(context.crypto))
+            raise AppCredentialsException
+          end
+
+        end
+      end
+
+    end
+  end
+end