smart-id-ruby-client 0.1.0

data/lib/smart_id_ruby/models/session_status.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module SmartIdRuby
+  module Models
+    # Represents response for active Smart-ID session query.
+    # state - Required. Current state of the session, e.g. "RUNNING", "COMPLETE".
+    # result - Required if state is "COMPLETE". Details about how session ended.
+    # signature_protocol - Required if end result is OK. Signature protocol used, e.g. "ACSP_V2" or "RAW_DIGEST_SIGNATURE".
+    # signature - Required if end result is OK. Signature data containing the actual signature and related information.
+    # cert - Required if end result is OK. Signer's certificate data.
+    # ignored_properties - Properties that were ignored from the session request.
+    # interaction_type_used - Required if end result is OK. Interaction type that was used in the session.
+    # device_ip_address - IP address of the device used in the session.
+    class SessionStatus
+      attr_reader :state, :result, :signature_protocol, :signature, :cert,
+                  :ignored_properties, :interaction_type_used, :device_ip_address
+
+      def initialize(
+        state: nil,
+        result: nil,
+        signature_protocol: nil,
+        signature: nil,
+        cert: nil,
+        ignored_properties: nil,
+        interaction_type_used: nil,
+        device_ip_address: nil
+      )
+        @state = state
+        @result = result
+        @signature_protocol = signature_protocol
+        @signature = signature
+        @cert = cert
+        @ignored_properties = ignored_properties
+        @interaction_type_used = interaction_type_used
+        @device_ip_address = device_ip_address
+      end
+
+      def running?
+        state.to_s.casecmp("RUNNING").zero?
+      end
+
+      def complete?
+        state.to_s.casecmp("COMPLETE").zero?
+      end
+
+      def to_h
+        {
+          state: state,
+          result: result.to_h,
+          signatureProtocol: signature_protocol,
+          signature: signature.to_h,
+          cert: cert.to_h,
+          ignoredProperties: ignored_properties,
+          interactionTypeUsed: interaction_type_used,
+          deviceIpAddress: device_ip_address
+        }
+      end
+
+      def self.from_h(payload)
+        return new unless payload.is_a?(Hash)
+
+        new(
+          state: fetch(payload, :state),
+          result: SessionResult.from_h(fetch(payload, :result)),
+          signature_protocol: fetch(payload, :signatureProtocol),
+          signature: SessionSignature.from_h(fetch(payload, :signature)),
+          cert: SessionCertificate.from_h(fetch(payload, :cert)),
+          ignored_properties: fetch(payload, :ignoredProperties),
+          interaction_type_used: fetch(payload, :interactionTypeUsed),
+          device_ip_address: fetch(payload, :deviceIpAddress)
+        )
+      end
+
+      def self.fetch(payload, key)
+        payload[key] || payload[key.to_s]
+      end
+      private_class_method :fetch
+    end
+
+    # Represents session result data returned by Smart-ID.
+    class SessionResult
+      attr_reader :end_result, :document_number, :details
+
+      def initialize(end_result: nil, document_number: nil, details: nil)
+        @end_result = end_result
+        @document_number = document_number
+        @details = details
+      end
+
+      def to_h
+        {
+          endResult: end_result,
+          documentNumber: document_number,
+          details: details.to_h
+        }
+      end
+
+      def self.from_h(payload)
+        return nil unless payload.is_a?(Hash)
+
+        new(
+          end_result: fetch(payload, :endResult),
+          document_number: fetch(payload, :documentNumber),
+          details: SessionResultDetails.from_h(fetch(payload, :details))
+        )
+      end
+
+      def self.fetch(payload, key)
+        payload[key] || payload[key.to_s]
+      end
+      private_class_method :fetch
+    end
+
+    # Represents additional result details for a session.
+    class SessionResultDetails
+      attr_reader :interaction
+
+      def initialize(interaction: nil)
+        @interaction = interaction
+      end
+
+      def to_h
+        {
+          interaction: interaction
+        }
+      end
+
+      def self.from_h(payload)
+        return nil unless payload.is_a?(Hash)
+
+        new(interaction: fetch(payload, :interaction))
+      end
+
+      def self.fetch(payload, key)
+        payload[key] || payload[key.to_s]
+      end
+      private_class_method :fetch
+    end
+
+    # Represents signature details in session status response.
+    class SessionSignature
+      attr_reader :value, :server_random, :user_challenge, :flow_type,
+                  :signature_algorithm, :signature_algorithm_parameters
+
+      def initialize(
+        value: nil,
+        server_random: nil,
+        user_challenge: nil,
+        flow_type: nil,
+        signature_algorithm: nil,
+        signature_algorithm_parameters: nil
+      )
+        @value = value
+        @server_random = server_random
+        @user_challenge = user_challenge
+        @flow_type = flow_type
+        @signature_algorithm = signature_algorithm
+        @signature_algorithm_parameters = signature_algorithm_parameters
+      end
+
+      def to_h
+        {
+          value: value,
+          serverRandom: server_random,
+          userChallenge: user_challenge,
+          flowType: flow_type,
+          signatureAlgorithm: signature_algorithm,
+          signatureAlgorithmParameters: signature_algorithm_parameters.to_h
+        }
+      end
+
+      def self.from_h(payload)
+        return nil unless payload.is_a?(Hash)
+
+        new(
+          value: fetch(payload, :value),
+          server_random: fetch(payload, :serverRandom),
+          user_challenge: fetch(payload, :userChallenge),
+          flow_type: fetch(payload, :flowType),
+          signature_algorithm: fetch(payload, :signatureAlgorithm),
+          signature_algorithm_parameters: SessionSignatureAlgorithmParameters.from_h(
+            fetch(payload, :signatureAlgorithmParameters)
+          )
+        )
+      end
+
+      def self.fetch(payload, key)
+        payload[key] || payload[key.to_s]
+      end
+      private_class_method :fetch
+    end
+
+    # Represents signature algorithm parameters for session signature.
+    class SessionSignatureAlgorithmParameters
+      attr_reader :hash_algorithm, :mask_gen_algorithm, :salt_length, :trailer_field
+
+      def initialize(hash_algorithm: nil, mask_gen_algorithm: nil, salt_length: nil, trailer_field: nil)
+        @hash_algorithm = hash_algorithm
+        @mask_gen_algorithm = mask_gen_algorithm
+        @salt_length = salt_length
+        @trailer_field = trailer_field
+      end
+
+      def to_h
+        {
+          hashAlgorithm: hash_algorithm,
+          maskGenAlgorithm: mask_gen_algorithm,
+          saltLength: salt_length,
+          trailerField: trailer_field
+        }
+      end
+
+      def self.from_h(payload)
+        return nil unless payload.is_a?(Hash)
+
+        new(
+          hash_algorithm: fetch(payload, :hashAlgorithm),
+          mask_gen_algorithm: fetch(payload, :maskGenAlgorithm),
+          salt_length: fetch(payload, :saltLength),
+          trailer_field: fetch(payload, :trailerField)
+        )
+      end
+
+      def self.fetch(payload, key)
+        payload[key] || payload[key.to_s]
+      end
+      private_class_method :fetch
+    end
+
+    # Represents certificate payload in session status response.
+    class SessionCertificate
+      attr_reader :value, :certificate_level
+
+      def initialize(value: nil, certificate_level: nil)
+        @value = value
+        @certificate_level = certificate_level
+      end
+
+      def to_h
+        {
+          value: value,
+          certificateLevel: certificate_level
+        }
+      end
+
+      def self.from_h(payload)
+        return nil unless payload.is_a?(Hash)
+
+        new(
+          value: fetch(payload, :value),
+          certificate_level: fetch(payload, :certificateLevel)
+        )
+      end
+
+      def self.fetch(payload, key)
+        payload[key] || payload[key.to_s]
+      end
+      private_class_method :fetch
+    end
+  end
+end

data/lib/smart_id_ruby/models/signature_response.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SmartIdRuby
+  module Models
+    # Represents validated signature response data.
+    class SignatureResponse
+      attr_reader :end_result, :signature_value_in_base64, :algorithm_name, :flow_type, :certificate,
+                  :requested_certificate_level, :certificate_level, :document_number, :interaction_flow_used,
+                  :device_ip_address, :rsa_ssa_pss_parameters
+
+      def initialize(
+        end_result:,
+        signature_value_in_base64:,
+        algorithm_name:,
+        flow_type:,
+        certificate:,
+        requested_certificate_level:,
+        certificate_level:,
+        document_number:,
+        interaction_flow_used:,
+        device_ip_address:,
+        rsa_ssa_pss_parameters:
+      )
+        @end_result = end_result
+        @signature_value_in_base64 = signature_value_in_base64
+        @algorithm_name = algorithm_name
+        @flow_type = flow_type
+        @certificate = certificate
+        @requested_certificate_level = requested_certificate_level
+        @certificate_level = certificate_level
+        @document_number = document_number
+        @interaction_flow_used = interaction_flow_used
+        @device_ip_address = device_ip_address
+        @rsa_ssa_pss_parameters = rsa_ssa_pss_parameters
+      end
+    end
+  end
+end

data/lib/smart_id_ruby/notification_interaction.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module SmartIdRuby
+  # Represents interaction payload used in notification-based flows.
+  class NotificationInteraction
+    DISPLAY_TEXT_AND_PIN = "displayTextAndPIN"
+    CONFIRMATION_MESSAGE = "confirmationMessage"
+    CONFIRMATION_MESSAGE_AND_VERIFICATION_CODE_CHOICE = "confirmationMessageAndVerificationCodeChoice"
+
+    DISPLAY_TEXT_60_MAX_LENGTH = 60
+    DISPLAY_TEXT_200_MAX_LENGTH = 200
+
+    attr_reader :type, :display_text60, :display_text200
+
+    def initialize(type:, display_text60: nil, display_text200: nil)
+      @type = type&.to_s
+      @display_text60 = display_text60
+      @display_text200 = display_text200
+
+      validate!
+    end
+
+    def to_h
+      {
+        type: type,
+        displayText60: display_text60,
+        displayText200: display_text200
+      }.compact
+    end
+
+    def self.display_text_and_pin(display_text60)
+      new(type: DISPLAY_TEXT_AND_PIN, display_text60: display_text60)
+    end
+
+    def self.confirmation_message(display_text200)
+      new(type: CONFIRMATION_MESSAGE, display_text200: display_text200)
+    end
+
+    def self.confirmation_message_and_verification_code_choice(display_text200)
+      new(type: CONFIRMATION_MESSAGE_AND_VERIFICATION_CODE_CHOICE, display_text200: display_text200)
+    end
+
+    private
+
+    def validate!
+      raise SmartIdRuby::Errors::RequestSetupError, "Value for 'type' must be set" if blank?(type)
+
+      case type
+      when DISPLAY_TEXT_AND_PIN
+        validate_display_text!(display_text60, "displayText60", DISPLAY_TEXT_60_MAX_LENGTH)
+      when CONFIRMATION_MESSAGE, CONFIRMATION_MESSAGE_AND_VERIFICATION_CODE_CHOICE
+        validate_display_text!(display_text200, "displayText200", DISPLAY_TEXT_200_MAX_LENGTH)
+      else
+        raise SmartIdRuby::Errors::RequestSetupError, "Unsupported interaction type: #{type}"
+      end
+    end
+
+    def validate_display_text!(value, field_name, max_length)
+      raise SmartIdRuby::Errors::RequestSetupError, "Value for '#{field_name}' cannot be empty" if blank?(value)
+      return if value.to_s.length <= max_length
+
+      raise SmartIdRuby::Errors::RequestSetupError,
+            "Value for '#{field_name}' cannot be longer than #{max_length} characters"
+    end
+
+    def blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+  end
+end

data/lib/smart_id_ruby/qr_code_generator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "base64"
+require "rqrcode"
+
+module SmartIdRuby
+  # Utility for generating QR-code images and Data URIs.
+  class QrCodeGenerator
+    DEFAULT_QR_CODE_WIDTH_PX = 610
+    DEFAULT_QR_CODE_HEIGHT_PX = 610
+    DEFAULT_QUIET_AREA_SIZE_MODULES = 4
+    DEFAULT_FILE_FORMAT = "png"
+
+    class << self
+      def generate_data_uri(data)
+        image = generate_image(data)
+        convert_to_data_uri(image, DEFAULT_FILE_FORMAT)
+      end
+
+      def generate_image(
+        data,
+        width_px = DEFAULT_QR_CODE_WIDTH_PX,
+        height_px = DEFAULT_QR_CODE_HEIGHT_PX,
+        quiet_area_size = DEFAULT_QUIET_AREA_SIZE_MODULES
+      )
+        validate_data!(data)
+
+        qrcode = RQRCode::QRCode.new(data.to_s, level: :l)
+        qrcode.as_png(
+          border_modules: quiet_area_size.to_i,
+          module_px_size: 1
+        ).resample_nearest_neighbor(width_px.to_i, height_px.to_i)
+      rescue StandardError => e
+        raise if e.is_a?(SmartIdRuby::Errors::RequestSetupError)
+
+        raise SmartIdRuby::Errors::RequestSetupError, "Unable to create QR-code: #{e.message}"
+      end
+
+      def convert_to_data_uri(image, file_format = DEFAULT_FILE_FORMAT)
+        format = file_format.to_s.downcase
+        image_bytes = image_to_bytes(image, format)
+        encoded = Base64.strict_encode64(image_bytes)
+        "data:image/#{format};base64,#{encoded}"
+      end
+
+      private
+
+      def validate_data!(data)
+        return unless data.nil? || data.to_s.empty?
+
+        raise SmartIdRuby::Errors::RequestSetupError, "Provided data cannot be empty"
+      end
+
+      def image_to_bytes(image, file_format)
+        if image.respond_to?(:to_datastream)
+          image.to_datastream.to_s
+        elsif image.is_a?(String)
+          image
+        else
+          raise SmartIdRuby::Errors::RequestSetupError, "Unable to generate QR-code as #{file_format}"
+        end
+      end
+    end
+  end
+end