smart_id 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1a4792f8f44f13df58feb85e9641bf8c249b0939d6d727ca7234060717a4d86
+  data.tar.gz: f58e94d4586fb872662853aa5cf4d50a8e6a2b40b1e256c83cafe3f1f13acd5f
+SHA512:
+  metadata.gz: eab5dfbaa386542421940cfc1490121a012f047f95c38f967b4fb4365aa9e677c8a2ce31dbf430a681092834a96557a1e8760145fc3adaa30c73079a4e63069b
+  data.tar.gz: 81f9b99115c31819d1335592bd2a18d6f0ee4441b1b2ef479b1d9c303ecc83dd3f12c83a199a77e36837918e671bfc8b4e8cba090be5180e180ef12fbe20bf4f

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.byebug_history

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.0
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in smart_id.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    smart_id (0.1.0)
+      rest-client (~> 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.1)
+    diff-lcs (1.3)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    http-accept (1.7.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    mime-types (3.3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2019.1009)
+    netrc (0.11.0)
+    rake (10.5.0)
+    rest-client (2.1.0)
+      http-accept (>= 1.7.0, < 2.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.1)
+      rspec-support (~> 3.9.1)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.2)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  byebug
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  smart_id!
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 lekristapino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,225 @@
+# SmartId
+
+This gem provides a wrapper around [Smart ID API](https://github.com/SK-EID/smart-id-documentation). All the necessary checks, listed in point 3.5 are implemented. Currently this gem only supports authentication actions.
+
+# TODO
+- [x] Add authentication functionality
+- [ ] Add Signing functionality (see if possible)
+- [ ] More test coverage
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'smart_id', "~> 0.1"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install smart_id
+
+## Usage
+
+### Configuration
+
+configuration can be done, by creating an initializer file and loading it before the application starts.
+
+```ruby
+SmartId.configure do |config|
+    config.relying_party_uuid = "MySmartIdUUID"
+    config.relying_party_name = "My Smart ID name"
+    config.environment = "demo" # possible options ar "demo" and "production", uses according smart-id parameters and keys
+    config.default_certificate_level = "ADVANCED" # Possible options are "ADVANCED" or "QUALIFIED". Defaults to "ADVANCED"
+    config.poller_timeout_secods = 10 # seconds to wait when fetching authentication confirmation
+end
+
+```
+### Authentication types
+
+Authentication can be done either with providing user's national identity number or an identity document number
+
+For national identity number use
+```ruby
+SmartId::Api::Authentication::IdentityNumber
+```
+
+For document number use
+```ruby
+SmartId::Api::Authentication::Document
+```
+Smart ID authentication is done in 2 steps - **initializing the authentication** and then **getting confimation from Smart ID** service. Those two steps happen asynchronously, so some parameters should be persisted either in session storage or in database
+
+* Back-end initializes authentification - user can see verification code on the app, and receives smart ID request to input PIN in they're mobile 
+
+* Back-end authenfication confirmation - check whether user has authenticated by correctly typing in they're PIN on the mobile device
+
+## Authentication Request
+
+To initialize authentication make a controller action. 
+
+#### National identity number
+
+```ruby
+class UserController < AplicationController
+    #...
+    def authenticate_smart_id
+        # authentication hash by default will generate random bytes, that will be hashed for signature check
+        # if you wish to provide your own randomization, you can pass a parameter to AuthenticationHash with the random string
+        # authentication_hash = SmartId::Utils::AuthenticationHash.new(SecureRandom.hex(64))
+        # each authentication should have a unique random string passed
+        authentication_hash = SmartId::Utils::AuthenticationHash.new
+
+        auth_response = SmartId::Api::Authentication::IdentityNumber.authenticate(
+            country: params[:country], # 2 character ISO 3166-1 alpha-2 format(for example EE, LT, LV, KZ)
+            identity_number: params[:identity_number],
+            authentication_hash: authentication_hash
+        )
+
+        session[:smart_id_session] = auth_response.session_id
+        session[:auth_hash] = authentication_hash.hash_data
+
+        # Screen/page after this call should show the user verification code, to see if it matches
+        # the one they see on their mobile device
+        render json: { verification_code: auth_response.verification_code }
+
+    end
+    #...
+end
+
+```
+
+#### Document number
+
+```ruby
+class UserController < AplicationController
+    #...
+    def authenticate_smart_id
+        # authentication hash by default will generate random bytes, that will be hashed for signature check
+        # if you wish to provide your own randomization, you can pass a parameter to AuthenticationHash with the random string
+        # authentication_hash = SmartId::Utils::AuthenticationHash.new(SecureRandom.hex(64))
+        # each authentication should have a unique random string passeds
+        authentication_hash = SmartId::Utils::AuthenticationHash.new
+
+        auth_response = SmartId::Api::Authentication::Document.authenticate(
+            document_number: params[:document_number],
+            authentication_hash: authentication_hash
+        )
+
+        session[:smart_id_session] = auth_response.session_id
+        session[:auth_hash] = authentication_hash.hash_data
+
+        # Screen/page after this call should show the user verification code, to see if it matches
+        # the one they see on their mobile device
+        render json: { verification_code: auth_response.verification_code }
+
+    end
+    #...
+end
+
+```
+
+## Authentication Confirmation
+Create another controller action
+
+```ruby
+class UserController < AplicationController
+    #...
+    def confirm_smart_id
+        # use hash_data saved on authentication initialization as parameter
+        authentication_hash = SmartId::Utils::AuthenticationHash.new(session[:auth_hash])
+
+        confirmation_response = SmartId::Api::Authentication::ConfirmationPoller.confirm(
+            session_id: session[:smart_id_session],
+            authentication_hash: authentication_hash,
+            # if true, will continously make requests to smart-id and return only after verification is completed
+            # you can set this parameter to false, to handle polling yourself
+            poll: true # default - true 
+        )
+    end
+    #...
+end 
+```
+
+
+## Response structure
+
+confirmation response will have the following attributes
+```ruby 
+authentication_hash = SmartId::Utils::AuthenticationHash.new(session[:auth_hash])
+
+confirmation_response = SmartId::Api::Authentication::ConfirmationPoller.confirm(
+    session_id: session[:smart_id_session],
+    authentication_hash: authentication_hash,
+    # if true, will continously make requests to smart-id and return only after verification is completed
+    # you can set this parameter to false, to handle polling yourself
+    poll: true # default - true 
+)
+
+confirmation_response.confirmation_running? # => true/false whether the user has finished authentication. Relevant, only if polling is not handled by the gem (with `poll` parameter set to false)
+confirmation_response.end_result  # => end result of the verification. possible values are "OK"/"USER_REFUSED"/"TIMEOUT"/"DOCUMENT_UNUSABLE", see details in https://github.com/SK-EID/smart-id-documentation#5-session-end-result-codes
+confirmation_response.document_number #=> document number for user
+confirmation_response.certificate_level #=> certificate level for user - values are "ADVANCED" or "QUALIFIED"
+
+confirmation_response.certificate.content.given_name #=> given name for user
+confirmation_response.certificate.content.surname #=> surname for user
+confirmation_response.certificate.content.serial_number #=> string, that includes user's national identity number
+
+```
+
+## Customization options
+You can provide extra parameters when initializing authentication (for both - identity number and document)
+
+```ruby
+SmartId::Api::Authentication::Document.authenticate(
+    document_number: "", # REQUIRED - document number
+    authentication_hash: obj, # REQUIRED - authentification hash object of SmartId::Utils::AuthenticationHash
+    certificate_level: "", # OPTIONAL - Either "ADVANCED" or "QUALIFIED" - if none are provided, default certificate level is used
+    display_text: nil, # OPTIONAL - Text that user will see on their mobile device when asked for authentication
+    multiple_choice: false, # OPTIONAL - If true, user will be asked to choose the correct verification code from supplied options on their device
+)
+
+SmartId::Api::Authentication::IdentityNumber.authenticate(
+    country: "", # REQUIRED - 2 character ISO 3166-1 alpha-2 format(for example EE, LT, LV, KZ)
+    identity_number: "", # REQUIRED - natioanl identity number
+    authentication_hash: obj, # REQUIRED - authentification hash object of SmartId::Utils::AuthenticationHash
+    certificate_level: "", # OPTIONAL - Either "ADVANCED" or "QUALIFIED" - if none are provided, default certificate level is used
+    display_text: nil, # OPTIONAL - Text that user will see on their mobile device when asked for authentication
+    multiple_choice: false, # OPTIONAL - If true, user will be asked to choose the correct verification code from supplied options on their device
+)
+```
+
+## Exceptions
+All exceptions inherit from `SmartId::Exception`
+| Exception class | Description | 
+| --------------- | :-----------: |
+| `SmartId::InvalidParamsError` | either country or identity_number were not provided when trying to authenticate with identity number |
+| `SmartId::ConnectionError` | authentication/confirmation request failed, when rescuing see `e.original_error` for more details |
+| `SmartId::NoUserFoundError`| user with the supplied parameters (id number, document number, country) does not exist in smart ID system |
+| `SmartId::SSLCertificateNotVerified` | SSL certificate for smart ID service was not verified. Check for newest version of this gem to always keep cerficates updated |
+| `SmartId::InvalidResponseCertificate` | Certificate used in confirmation response is invalid|
+| `SmartId::InvalidResponseSignature` | Signature used in confirmation response is invalid. |
+| `SmartId::IncorrectAccountLevelError` | User's Smart ID account is below the required level by the authentication request ( "ADVANCED" < "QUALIFIED") |
+| `SmartId::InvalidPermissionsError` | Relying Party has no permission to issue the request. This may happen when Relying Party has no permission to invoke operations on accounts with ADVANCED certificates. |
+| `SmartId::OutdatedApiError` | API used by the gem is outdated, please see if you are running the newest version of the gem |
+| `SmartId::SystemUnderMaintenanceError` | Smart ID System is under maintenance, try again later |
+
+## Testing
+Smart ID demo environment has provided some sample values to use when testing applications see [Smart ID WIKI page](https://github.com/SK-EID/smart-id-documentation/wiki/Environment-technical-parameters)
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zippyvision/smart-id-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "smart_id"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/smart_id.rb

@@ -0,0 +1,64 @@
+require "smart_id/version"
+require "smart_id/utils/authentication_hash"
+require "smart_id/utils/certificate_validator"
+require "smart_id/utils/verification_code_calculator"
+require "smart_id/api/request"
+require "smart_id/api/response"
+require "smart_id/api/confirmation_response"
+require "smart_id/api/authentication/identity_number"
+require "smart_id/api/authentication/document"
+require "smart_id/api/authentication/confirmation_poller"
+require "smart_id/authentication_certificate/certificate"
+require "smart_id/authentication_certificate/content"
+
+module SmartId
+    @@environment = "DEMO" # possible options are demo and production
+    @@relying_party_uuid = nil
+    @@relying_party_name = nil
+    @@default_certificate_level = "ADVANCED" # possible values are "ADVANCED", "QUALIFIED" 
+    @@poller_timeout_seconds = 10
+
+  def self.configure(&block)
+    yield(self)
+  end
+
+  def self.relying_party_uuid=(value)
+    @@relying_party_uuid = value
+  end
+
+  def self.relying_party_uuid
+    @@relying_party_uuid
+  end
+
+  def self.relying_party_name=(value)
+    @@relying_party_name = value
+  end
+
+  def self.relying_party_name
+    @@relying_party_name
+  end
+
+  def self.default_certificate_level=(value)
+    @@default_certificate_level = value
+  end
+
+  def self.default_certificate_level
+    @@default_certificate_level
+  end
+
+  def self.poller_timeout_seconds=(value)
+    @@poller_timeout_seconds = value
+  end
+
+  def self.poller_timeout_seconds
+    @@poller_timeout_seconds
+  end
+
+  def self.environment=(value)
+    @@environment = value.upcase
+  end
+
+  def self.environment
+    @@environment
+  end
+end

data/lib/smart_id/api/authentication/base.rb

@@ -0,0 +1,55 @@
+require "rest-client"
+require "smart_id/exceptions"
+require "smart_id/utils/authentication_hash"
+require "json"
+
+module SmartId::Api
+  module Authentication
+    class Base
+      attr_reader :authentication_hash
+
+      def self.authenticate(**opts)
+        new(**opts).call
+      end
+
+      def initialize(**opts)
+        @authentication_hash = opts[:authentication_hash]
+        @display_text = opts[:display_text]
+        @certificate_level = opts[:certificate_level]
+        @multiple_choice = opts[:multiple_choice]
+      end
+
+
+      def call
+        response = SmartId::Api::Request.execute(method: :post, uri: api_uri, params: request_params)
+        SmartId::Api::Response.new(JSON.parse(response.body), authentication_hash)
+      end
+
+      private
+
+      def request_params
+        params = {
+          relyingPartyUUID: SmartId.relying_party_uuid,
+          relyingPartyName: SmartId.relying_party_name,
+          certificateLevel: @certificate_level || SmartId.default_certificate_level,
+          hash: authentication_hash.calculate_base64_digest,
+          hashType: "SHA256"
+        }
+
+        if @display_text
+          params.merge!(displayText: @display_text)
+        end
+
+        if @multiple_choice
+          params.merge!(requestProperties: { vcChoice: @multiple_choice })
+        end
+
+        params
+      end
+
+      def api_uri
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/smart_id/api/authentication/confirmation_poller.rb

@@ -0,0 +1,37 @@
+module SmartId::Api
+  module Authentication
+    class ConfirmationPoller
+      BASE_URI = "session/"
+
+      def self.confirm(session_id:, authentication_hash:, poll: true)
+        new(session_id, authentication_hash, poll).call
+
+      end
+
+      def initialize(session_id, authentication_hash, poll)
+        @session_id = session_id
+        @authentication_hash = authentication_hash
+        @poll = poll
+      end
+
+      def call
+        params = { timeoutMs: SmartId.poller_timeout_seconds * 1000 }
+        uri = BASE_URI + @session_id
+
+        raw_response = SmartId::Api::Request.execute(method: :get, uri: uri, params: params)
+        
+        response = SmartId::Api::ConfirmationResponse.new(
+          JSON.parse(raw_response.body),
+          @authentication_hash.hash_data
+        )
+
+        # repeat request if confirmation is still running
+        if response.confirmation_running? && @poll
+          call
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/smart_id/api/authentication/document.rb

@@ -0,0 +1,20 @@
+require "smart_id/api/authentication/base"
+
+module SmartId::Api
+  module Authentication
+    class Document < Base
+      BASE_URI = "authentication/document"
+
+      def initialize(**opts)
+        @document_number = opts[:document_number]
+        super(**opts)
+      end
+
+      private
+
+      def api_uri
+        "#{BASE_URI}/#{@document_number}"
+      end
+    end
+  end
+end

data/lib/smart_id/api/authentication/identity_number.rb

@@ -0,0 +1,29 @@
+require "smart_id/api/authentication/base"
+require "smart_id/exceptions"
+
+module SmartId::Api
+  module Authentication
+    class IdentityNumber < Base
+      BASE_URI = "authentication/pno"
+
+      # @param country: 2 character ISO 3166-1 alpha-2 format(for example EE, LT, LV, KZ)
+      # @param identity_number: national identity number of the individuals
+      def initialize(**opts)
+        @country = opts[:country].upcase
+        @identity_number = opts[:identity_number]
+
+        unless @country && @identity_number
+          raise InvalidParamsError
+        end
+
+        super(**opts)
+      end
+
+      private
+
+      def api_uri
+        "#{BASE_URI}/#{@country}/#{@identity_number}"
+      end
+    end
+  end
+end

data/lib/smart_id/api/confirmation_response.rb

@@ -0,0 +1,55 @@
+module SmartId::Api
+  class ConfirmationResponse
+    RUNNING_STATE = "RUNNING"
+    COMPLETED_STATE = "COMPLETE"
+
+    attr_reader :body
+    
+    def initialize(response_body, hashed_data)
+      @body = response_body
+      validate!(hashed_data)
+    end
+
+    def confirmation_running?
+      state == RUNNING_STATE
+    end
+
+    def state
+      @body["state"]
+    end
+
+    def end_result
+      @body.dig("result", "endResult")
+    end
+
+    def document_number
+      @body.dig("result", "documentNumber")
+    end
+
+    def certificate_level
+      @body.dig("cert", "certificateLevel")
+    end
+
+    def certificate
+      @certificate ||= SmartId::AuthenticationCertificate::Certificate.new(@body.dig("cert", "value"))
+    end
+
+    def signature_algorithm
+      @body.dig("signature", "algorithm")
+    end
+
+    def signature
+      @body.dig("signature", "value")
+    end
+
+    def ignored_properties
+      @body["ignoredProperties"]
+    end
+
+    private
+    
+    def validate!(hashed_data)
+      SmartId::Utils::CertificateValidator.validate!(hashed_data, signature, certificate)
+    end
+  end
+end

data/lib/smart_id/api/request.rb

@@ -0,0 +1,88 @@
+require 'logger'
+require 'date'
+module SmartId::Api
+  class Request
+    DEMO_BASE_URL = "https://sid.demo.sk.ee/smart-id-rp/v1/"
+    PRODUCTION_BASE_URL = "https://rp-api.smart-id.com/v1/"
+
+    DEMO_SSL_KEY = "QLZIaH7Qx9Rjq3gyznQuNsvwMQb7maC5L4SLu/z5qNU="
+    PROD_KEY_EXPIRY = Date.new(2020,11,5)
+    PRODUCTION_SSL_KEY = "l2uvq6ftLN4LZ+8Un+71J2vH1BT9wTbtrE5+Fj3Vc5g="
+
+    def initialize(method, uri, params)
+      @method = method
+      @url = self.class.const_get("#{SmartId.environment}_BASE_URL") + uri
+      @params = params
+      @logger = Logger.new(STDOUT)
+    end
+
+    def self.execute(method:, uri:, params:)
+      begin
+        api_request = new(method, uri, params)
+        api_request.execute
+      rescue RestClient::RequestFailed => e
+        case e.http_code
+        when 471
+          raise SmartId::IncorrectAccountLevelError
+        when 403
+          raise SmartId::InvalidPermissionsError
+        when 404
+          raise SmartId::UserNotFoundError
+        when 480
+          raise SmartId::OutdatedApiError
+        when 580
+          raise SmartId::SystemUnderMaintenanceError
+        else
+          raise SmartId::ConnectionError.new(e)
+        end
+      rescue RestClient::SSLCertificateNotVerified
+        raise SmartId::SSLCertificateNotVerified
+      end
+    end
+
+    def maybe_warn_of_ssl_key_expiry
+      if (PROD_KEY_EXPIRY - Date.today).to_i < 60
+        @logger.warn("[Smart-id-Ruby] SSL KEY for security checks will soon expire, please update to newer version of this gem")
+      end
+    end
+
+    def execute
+      maybe_warn_of_ssl_key_expiry
+
+      if @method.to_sym == :post
+        attrs = post_request_attrs
+      else
+        attrs = get_request_attrs
+      end 
+
+      request = RestClient::Request.execute(**attrs)
+    end
+
+    private
+    
+    def default_attrs
+      {
+        method: @method,
+        url: @url,
+        headers: { content_type: :json, accept: :json },
+        timeout: SmartId.poller_timeout_seconds + 1,
+        ssl_verify_callback: lambda do |_, cert_store|
+          provided_pub_key = cert_store.chain[0].public_key
+          saved_key = self.class.const_get("#{SmartId.environment}_SSL_KEY")
+          Digest::SHA256.digest(provided_pub_key.to_der) == Base64.decode64(saved_key)
+        end
+      }
+    end
+
+    def get_request_attrs
+      default_attrs.merge(headers: {
+        **default_attrs[:headers],
+        params: @params 
+      })
+    end
+
+    def post_request_attrs
+      default_attrs.merge(payload: JSON.generate(@params))
+    end
+  end
+end

data/lib/smart_id/api/response.rb

@@ -0,0 +1,15 @@
+module SmartId::Api
+  class Response
+    attr_reader :session_id
+
+    def initialize(response_body, authentication_hash)
+      @body = response_body
+      @session_id = response_body["sessionID"]
+      @authentication_hash = authentication_hash
+    end
+
+    def verification_code
+      @verification_code ||= SmartId::VerificationCodeCalculator.calculate(@authentication_hash.calculate_digest)
+    end
+  end
+end

data/lib/smart_id/authentication_certificate/certificate.rb

@@ -0,0 +1,17 @@
+module SmartId
+  module AuthenticationCertificate
+    class Certificate
+      def initialize(base64_cert)
+        @base64_cert = base64_cert
+      end
+
+      def content
+        @content ||= SmartId::AuthenticationCertificate::Content.new(cert.subject.to_s)
+      end
+
+      def cert
+        @cert ||= OpenSSL::X509::Certificate.new(Base64.decode64(@base64_cert))
+      end
+    end
+  end
+end

data/lib/smart_id/authentication_certificate/content.rb

@@ -0,0 +1,45 @@
+module SmartId
+  module AuthenticationCertificate
+    class Content
+      def initialize(raw_content)
+        @raw_content = raw_content
+      end
+
+      def given_name
+        structured_raw_content["GN"].gsub(",", " ")
+      end
+
+      def surname
+        structured_raw_content["SN"].gsub(",", " ")
+      end
+      
+      def country
+        structured_raw_content["C"].gsub(",", " ")
+      end
+
+      def all_info
+        structured_raw_content["CN"]
+      end
+
+      def organizational_unit
+        structured_raw_content["OU"]
+      end
+
+      def serial_number
+        structured_raw_content["serialNumber"]
+      end
+
+      private
+
+      def structured_raw_content
+        return @structured_raw_content if @structured_raw_content
+        @structured_raw_content = @raw_content.split("/").each_with_object({}) do |c, result|
+          if c.include?("=")
+            key, val = c.split("=")
+            result[key] = val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smart_id/exceptions.rb

@@ -0,0 +1,23 @@
+module SmartId
+  class Exception < ::Exception; end
+  class InvalidParamsError < Exception; end
+  class SSLCertificateNotVerified < Exception; end
+  class InvalidResponseCertificate < Exception; end
+  class InvalidResponseSignature < Exception; end
+  class UserNotFoundError < Exception; end
+  class OutdatedApiError < Exception; end
+  class SystemUnderMaintenanceError < Exception; end
+
+  class ConnectionError < Exception;
+    attr_reader :original_error
+    def initialize(original_error)
+      @original_error = original_error
+    end 
+  end
+
+  class IncorrectAccountLevelError < Exception
+    def message
+      "User exists, but has lower level account than required by request"
+    end
+  end
+end

data/lib/smart_id/utils/authentication_hash.rb

@@ -0,0 +1,28 @@
+require 'digest'
+require 'base64'
+
+module SmartId
+  module Utils
+    class AuthenticationHash
+      attr_reader :hash_data
+      
+      def initialize(hash_data = nil)
+        @hash_data = hash_data || random_bytes
+      end
+      
+      def calculate_digest
+        Digest::SHA256.digest(hash_data)
+      end
+
+      def calculate_base64_digest
+        Base64.strict_encode64(calculate_digest)
+      end
+
+      private
+
+      def random_bytes
+        OpenSSL::Random.random_bytes(64)
+      end
+    end
+  end
+end

data/lib/smart_id/utils/certificate_validator.rb

@@ -0,0 +1,55 @@
+module SmartId::Utils
+  class CertificateValidator
+    def self.validate!(hash_data, signature, certificate)
+      obj = new(hash_data, signature, certificate)
+      obj.validate_certificate!
+      obj.validate_signature!
+    end
+
+    def initialize(hash_data, signature, certificate)
+      @hash_data = hash_data
+      @signature = signature
+      begin
+        @certificate = certificate.cert
+      rescue Exception
+        debugger
+      end
+    end
+
+    def certificate_valid?
+      ### TODO: Currently not working, because of error "unable to get local issuer certificate" - same error in bash with openssl
+      # cert_store = OpenSSL::X509::Store.new
+      # cert_chain.each {|c| cert_store.add_cert(c) }
+      # cert_store.add_dir(File.dirname(__FILE__)+"/../../../trusted_certs/")
+      # cert_store.purpose = OpenSSL::X509::PURPOSE_ANY
+      # OpenSSL::X509::Store.new.verify(@certificate) && 
+      @certificate.not_before.to_date < Date.today && 
+        @certificate.not_after.to_date > Date.today
+    end
+
+    def validate_certificate!
+      unless certificate_valid?
+        raise SmartId::InvalidResponseCertificate
+      end
+    end
+
+    def cert_chain
+      [
+        OpenSSL::X509::Certificate.new(
+          File.read(File.dirname(__FILE__)+"/../../../trusted_certs/EID-SK_2016.pem.crt")
+        ),
+        OpenSSL::X509::Certificate.new(
+          File.read(File.dirname(__FILE__)+"/../../../trusted_certs/NQ-SK_2016.pem.crt")
+        )
+      ]
+    end
+
+    def validate_signature!
+      public_key = @certificate.public_key
+      
+      unless public_key.verify(OpenSSL::Digest::SHA256.new, Base64.decode64(@signature), @hash_data)
+        raise SmartId::InvalidResponseSignature
+      end
+    end
+  end
+end

data/lib/smart_id/utils/verification_code_calculator.rb

@@ -0,0 +1,24 @@
+module SmartId
+  module Utils
+    class VerificationCodeCalculator
+      ##
+      # The Verification Code (VC) is computed as:
+      #
+      # integer(SHA256(hash)[−2:−1]) mod 10000
+      #
+      # where we take SHA256 result, extract 2 rightmost bytes from it,
+      # interpret them as a big-endian unsigned short and take the last 4 digits in decimal for display.
+      #
+      # SHA256 is always used here, no matter what was the algorithm used to calculate hash.
+
+      def self.calculate(digest)
+        rightmost_bytes = digest[-2..-1]
+        int = rightmost_bytes.unpack('n*')[0]
+        paddable_string = (int % 10000).to_s.chars.last(4).join
+        pad = 4 - paddable_string.length
+        
+        "0" * pad + paddable_string
+      end
+    end
+  end
+end

data/lib/smart_id/version.rb

@@ -0,0 +1,3 @@
+module SmartId
+  VERSION = "0.1.0"
+end

data/smart_id.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "smart_id/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "smart_id"
+  spec.version       = SmartId::VERSION
+  spec.authors       = ["Kristaps Kulikovskis"]
+  spec.email         = ["kristaps.kulikovskis@gmail.com"]
+
+  spec.summary       = %q{Smart ID wrapper libary for using Smart ID in Ruby applications}
+  spec.homepage      = "https://github.com/zippyvision/smart-id-ruby"
+  spec.license       = "MIT"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage + "/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "rest-client", "~> 2.0"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "byebug"
+end

data/trusted_certs/EID-SK_2016.pem.crt

@@ -0,0 +1,63 @@
+-----BEGIN CERTIFICATE-----
+MIIEAzCCAuugAwIBAgIQVID5oHPtPwBMyonY43HmSjANBgkqhkiG9w0BAQUFADB1
+MQswCQYDVQQGEwJFRTEiMCAGA1UECgwZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1
+czEoMCYGA1UEAwwfRUUgQ2VydGlmaWNhdGlvbiBDZW50cmUgUm9vdCBDQTEYMBYG
+CSqGSIb3DQEJARYJcGtpQHNrLmVlMCIYDzIwMTAxMDMwMTAxMDMwWhgPMjAzMDEy
+MTcyMzU5NTlaMHUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKDBlBUyBTZXJ0aWZpdHNl
+ZXJpbWlza2Vza3VzMSgwJgYDVQQDDB9FRSBDZXJ0aWZpY2F0aW9uIENlbnRyZSBS
+b290IENBMRgwFgYJKoZIhvcNAQkBFglwa2lAc2suZWUwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQDIIMDs4MVLqwd4lfNE7vsLDP90jmG7sWLqI9iroWUy
+euuOF0+W2Ap7kaJjbMeMTC55v6kF/GlclY1i+blw7cNRfdCT5mzrMEvhvH2/UpvO
+bntl8jixwKIy72KyaOBhU8E2lf/slLo2rpwcpzIP5Xy0xm90/XsY6KxX7QYgSzIw
+WFv9zajmofxwvI6Sc9uXp3whrj3B9UiHbCe9nyV0gVWw93X2PaRka9ZP585ArQ/d
+MtO8ihJTmMmJ+xAdTX7Nfh9WDSFwhfYggx/2uh8Ej+p3iDXE/+pOoYtNP2MbRMNE
+1CV2yreN1x5KZmTNXMWcg+HCCIia7E6j8T4cLNlsHaFLAgMBAAGjgYowgYcwDwYD
+VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBLyWj7qVhy/
+zQas8fElyalL1BSZMEUGA1UdJQQ+MDwGCCsGAQUFBwMCBggrBgEFBQcDAQYIKwYB
+BQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCAYIKwYBBQUHAwkwDQYJKoZIhvcNAQEF
+BQADggEBAHv25MANqhlHt01Xo/6tu7Fq1Q+e2+RjxY6hUFaTlrg4wCQiZrxTFGGV
+v9DHKpY5P30osxBAIWrEr7BSdxjhlthWXePdNl4dp1BUoMUq5KqMlIpPnTX/dqQG
+E5Gion0ARD9V04I8GtVbvFZMIi5GQ4okQC3zErg7cBqklrkar4dBGmoYDQZPxz5u
+uSlNDUmJEYcyW+ZLBMjkXOZ0c5RdFpgTlf7727FE5TpwrDdr5rMzcijJs1eg9gIW
+iAYLtqZLICjU3j2LrTcFU3T+bsy8QxdxXvnFzBqpYe73dgzzcvRyrc9yAjYHR8/v
+GVCJYMzpJJUPwssd8m92kMfMdcGWxZ0=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

data/trusted_certs/NQ-SK_2016.pem.crt

@@ -0,0 +1,61 @@
+-----BEGIN CERTIFICATE-----
+MIIEAzCCAuugAwIBAgIQVID5oHPtPwBMyonY43HmSjANBgkqhkiG9w0BAQUFADB1
+MQswCQYDVQQGEwJFRTEiMCAGA1UECgwZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1
+czEoMCYGA1UEAwwfRUUgQ2VydGlmaWNhdGlvbiBDZW50cmUgUm9vdCBDQTEYMBYG
+CSqGSIb3DQEJARYJcGtpQHNrLmVlMCIYDzIwMTAxMDMwMTAxMDMwWhgPMjAzMDEy
+MTcyMzU5NTlaMHUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKDBlBUyBTZXJ0aWZpdHNl
+ZXJpbWlza2Vza3VzMSgwJgYDVQQDDB9FRSBDZXJ0aWZpY2F0aW9uIENlbnRyZSBS
+b290IENBMRgwFgYJKoZIhvcNAQkBFglwa2lAc2suZWUwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQDIIMDs4MVLqwd4lfNE7vsLDP90jmG7sWLqI9iroWUy
+euuOF0+W2Ap7kaJjbMeMTC55v6kF/GlclY1i+blw7cNRfdCT5mzrMEvhvH2/UpvO
+bntl8jixwKIy72KyaOBhU8E2lf/slLo2rpwcpzIP5Xy0xm90/XsY6KxX7QYgSzIw
+WFv9zajmofxwvI6Sc9uXp3whrj3B9UiHbCe9nyV0gVWw93X2PaRka9ZP585ArQ/d
+MtO8ihJTmMmJ+xAdTX7Nfh9WDSFwhfYggx/2uh8Ej+p3iDXE/+pOoYtNP2MbRMNE
+1CV2yreN1x5KZmTNXMWcg+HCCIia7E6j8T4cLNlsHaFLAgMBAAGjgYowgYcwDwYD
+VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBLyWj7qVhy/
+zQas8fElyalL1BSZMEUGA1UdJQQ+MDwGCCsGAQUFBwMCBggrBgEFBQcDAQYIKwYB
+BQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCAYIKwYBBQUHAwkwDQYJKoZIhvcNAQEF
+BQADggEBAHv25MANqhlHt01Xo/6tu7Fq1Q+e2+RjxY6hUFaTlrg4wCQiZrxTFGGV
+v9DHKpY5P30osxBAIWrEr7BSdxjhlthWXePdNl4dp1BUoMUq5KqMlIpPnTX/dqQG
+E5Gion0ARD9V04I8GtVbvFZMIi5GQ4okQC3zErg7cBqklrkar4dBGmoYDQZPxz5u
+uSlNDUmJEYcyW+ZLBMjkXOZ0c5RdFpgTlf7727FE5TpwrDdr5rMzcijJs1eg9gIW
+iAYLtqZLICjU3j2LrTcFU3T+bsy8QxdxXvnFzBqpYe73dgzzcvRyrc9yAjYHR8/v
+GVCJYMzpJJUPwssd8m92kMfMdcGWxZ0=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: smart_id
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kristaps Kulikovskis
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- kristaps.kulikovskis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/smart_id.rb
+- lib/smart_id/api/authentication/base.rb
+- lib/smart_id/api/authentication/confirmation_poller.rb
+- lib/smart_id/api/authentication/document.rb
+- lib/smart_id/api/authentication/identity_number.rb
+- lib/smart_id/api/confirmation_response.rb
+- lib/smart_id/api/request.rb
+- lib/smart_id/api/response.rb
+- lib/smart_id/authentication_certificate/certificate.rb
+- lib/smart_id/authentication_certificate/content.rb
+- lib/smart_id/exceptions.rb
+- lib/smart_id/utils/authentication_hash.rb
+- lib/smart_id/utils/certificate_validator.rb
+- lib/smart_id/utils/verification_code_calculator.rb
+- lib/smart_id/version.rb
+- smart_id.gemspec
+- trusted_certs/EID-SK_2016.pem.crt
+- trusted_certs/NQ-SK_2016.pem.crt
+homepage: https://github.com/zippyvision/smart-id-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zippyvision/smart-id-ruby
+  source_code_uri: https://github.com/zippyvision/smart-id-ruby
+  changelog_uri: https://github.com/zippyvision/smart-id-ruby/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Smart ID wrapper libary for using Smart ID in Ruby applications
+test_files: []