aliquot 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a04779c8a107c40976456dfe5ef3192ab6e8b31ed215f542edd7ef8d0344e37
+  data.tar.gz: 0c721e2aa5a54d9b4999dbd7e179aea62cf54bb93a077322e186299e5d079dae
+SHA512:
+  metadata.gz: d0eb73c56e32bda0d998b8206beec72a4ffef47127da0b149d5a052c7fdbe64a62e89cbb74e4502db29d6c3c05da1bba9197ccddb9b512410a65c0f39483bd68
+  data.tar.gz: 4d778545daa1974f66f27502c5c9e851715b189bf7e0e2c06de3a2aedda258f5b8b831e77994e82cfeadb31e798a2507046248cc309853ee44a95ae09eb06b38

data/lib/aliquot/error.rb

@@ -0,0 +1,16 @@
+module Aliquot
+  # Base class for all errors thrown in Aliquot
+  class Error < StandardError; end
+
+  # Thrown if the token is expired
+  class ExpiredException < Error; end
+
+  # Thrown if the signature is invalid
+  class InvalidSignatureError < Error; end
+
+  # Thrown if the MAC is invalid
+  class InvalidMacError < Error; end
+
+  # Thrown if there was an error validating the input data
+  class ValidationError < Error; end
+end

data/lib/aliquot/validator.rb

@@ -0,0 +1,184 @@
+require 'aliquot/error'
+
+require 'base64'
+require 'dry-validation'
+require 'json'
+require 'openssl'
+
+module Aliquot
+  module Validator
+    # Verified according to:
+    # https://developers.google.com/pay/api/web/guides/resources/payment-data-cryptography#payment-method-token-structure
+    module Predicates
+      include Dry::Logic::Predicates
+
+      CUSTOM_PREDICATE_ERRORS = {
+        base64?:          'must be Base64',
+        pan?:             'must be a pan',
+        ec_public_key?:   'must be an EC public key',
+        eci?:             'must be an ECI',
+        json_string?:     'must be valid JSON',
+        integer_string?:  'must be string encoded integer',
+        month?:           'must be a month (1..12)',
+        year?:            'must be a year (2000..3000)',
+
+        authMethodCryptogram3DS: 'authMethod CRYPTOGRAM_3DS requires eciIndicator',
+        authMethodCard:          'eciIndicator/cryptogram must be omitted when PAN_ONLY',
+      }.freeze
+
+      # Support Ruby 2.3, but use the faster #match? when available.
+      match_b = ''.respond_to?(:match?) ? ->(s, re) { s.match?(re) } : ->(s, re) { !!(s =~ re) }
+
+      def self.to_bool(lbd)
+        lbd.call
+        true
+      rescue
+        false
+      end
+
+      predicate(:base64?) do |x|
+        str?(x) &&
+          match_b.call(x, /\A[=A-Za-z0-9+\/]*\z/) && # allowable chars
+          x.length.remainder(4).zero? && # multiple of 4
+          !match_b.call(x, /=[^$=]/) && # may only end with ='s
+          !match_b.call(x, /===/) # at most 2 ='s
+      end
+
+      # We should figure out how strict we should be. Hopefully we can discard
+      # the above Base64? predicate and use the following simpler one:
+      #predicate(:strict_base64?) { |x| !!Base64.strict_decode64(x) rescue false }
+
+      predicate(:pan?) { |x| match_b.call(x, /\A[1-9][0-9]{11,18}\z/) }
+
+      predicate(:eci?) { |x| str?(x) && match_b.call(x, /\A\d{1,2}\z/) }
+
+      predicate(:ec_public_key?) { |x| base64?(x) && OpenSSL::PKey::EC.new(Base64.decode64(x)).check_key rescue false }
+
+      predicate(:json_string?) { |x| !!JSON.parse(x) rescue false }
+
+      predicate(:integer_string?) { |x| str?(x) && match_b.call(x, /\A\d+\z/) }
+
+      predicate(:month?) { |x| x.between?(1, 12) }
+
+      predicate(:year?) { |x| x.between?(2000, 3000) }
+    end
+
+    # Base for DRY-Validation schemas used in Aliquot.
+    class BaseSchema < Dry::Validation::Schema::JSON
+      predicates(Predicates)
+      def self.messages
+        super.merge(en: { errors: Predicates::CUSTOM_PREDICATE_ERRORS })
+      end
+    end
+
+    # DRY-Validation schema for Google Pay token
+    TokenSchema = Dry::Validation.Schema(BaseSchema) do
+      required(:signature).filled(:str?, :base64?)
+
+      # Currently supposed to be ECv1, but may evolve.
+      required(:protocolVersion).filled(:str?)
+      required(:signedMessage).filled(:str?, :json_string?)
+    end
+
+    # DRY-Validation schema for signedMessage component Google Pay token
+    SignedMessageSchema = Dry::Validation.Schema(BaseSchema) do
+      required(:encryptedMessage).filled(:str?, :base64?)
+      required(:ephemeralPublicKey).filled(:str?, :base64?)
+      required(:tag).filled(:str?, :base64?)
+    end
+
+    # DRY-Validation schema for paymentMethodDetails component Google Pay token
+    PaymentMethodDetailsSchema = Dry::Validation.Schema(BaseSchema) do
+      required(:pan).filled(:integer_string?, :pan?)
+      required(:expirationMonth).filled(:int?, :month?)
+      required(:expirationYear).filled(:int?, :year?)
+      required(:authMethod).filled(:str?, included_in?: %w[PAN_ONLY CRYPTOGRAM_3DS])
+
+      optional(:cryptogram).filled(:str?)
+      optional(:eciIndicator).filled(:str?, :eci?)
+
+      rule('when authMethod is CRYPTOGRAM_3DS, cryptogram': %i[authMethod cryptogram]) do |method, cryptogram|
+        method.eql?('CRYPTOGRAM_3DS') > cryptogram.filled?
+      end
+
+      rule('when authMethod is PAN_ONLY, eciIndicator': %i[authMethod eciIndicator]) do |method, eci|
+        method.eql?('PAN_ONLY').then(eci.none?)
+      end
+
+      rule('when authMethod is PAN_ONLY, cryptogram': %i[authMethod cryptogram]) do |method, cryptogram|
+        method.eql?('PAN_ONLY').then(cryptogram.none?)
+      end
+    end
+
+    # DRY-Validation schema for encryptedMessage component Google Pay token
+    EncryptedMessageSchema = Dry::Validation.Schema(BaseSchema) do
+      required(:messageExpiration).filled(:str?, :integer_string?)
+      required(:messageId).filled(:str?)
+      required(:paymentMethod).filled(:str?, eql?: 'CARD')
+      required(:paymentMethodDetails).schema(PaymentMethodDetailsSchema)
+    end
+
+    module InstanceMethods
+      attr_reader :output
+
+      def validate
+        @validation ||= @schema.call(@input)
+        @output = @validation.output
+        return true if @validation.success?
+        raise Aliquot::ValidationError, "validation error: #{errors_formatted}"
+      end
+
+      def valid?
+        validate
+      rescue
+        false
+      end
+
+      def errors
+        valid? unless @validation
+
+        @validation.errors
+      end
+
+      def errors_formatted(node = [errors])
+        node.pop.flat_map do |key, value|
+          if value.is_a?(Array)
+            value.map { |error| "#{(node + [key]).join('.')} #{error}" }
+          else
+            errors_formatted(node + [key, value])
+          end
+        end
+      end
+    end
+
+    # Class for validating a Google Pay token
+    class Token
+      include InstanceMethods
+      class Error < ::Aliquot::Error; end
+      def initialize(input)
+        @input = input
+        @schema = TokenSchema
+      end
+    end
+
+    # Class for validating the SignedMessage component of a Google Pay token
+    class SignedMessage
+      include InstanceMethods
+      class Error < ::Aliquot::Error; end
+      def initialize(input)
+        @input = input
+        @schema = SignedMessageSchema
+      end
+    end
+
+    # Class for validating the encryptedMessage component of a Google Pay token
+    class EncryptedMessageValidator
+      include InstanceMethods
+      class Error < ::Aliquot::Error; end
+      def initialize(input)
+        @input = input
+        @schema = EncryptedMessageSchema
+      end
+    end
+  end
+end

data/lib/aliquot.rb

@@ -0,0 +1,209 @@
+require 'json'
+require 'base64'
+require 'excon'
+require 'hkdf'
+
+require 'aliquot/validator'
+require 'aliquot/error'
+
+$key_updater_semaphore = Mutex.new
+$key_updater_thread = nil
+
+module Aliquot
+  ##
+  # Constant-time comparison function
+  def self.compare(a, b)
+    err = 0
+
+    y = b.unpack('C*')
+
+    a.each_byte do |x|
+      err |= x ^ y.shift
+    end
+
+    err.zero?
+  end
+
+  ##
+  # Keys used for signing in production
+  SIGNING_KEY_URL = 'https://payments.developers.google.com/paymentmethodtoken/keys.json'.freeze
+
+  ##
+  # Keys used for signing in a testing environment
+  TEST_SIGNING_KEY_URL = 'https://payments.developers.google.com/paymentmethodtoken/test/keys.json'.freeze
+
+  ##
+  # Start a thread that keeps the Google signing keys updated.
+  def self.start_key_updater(logger)
+    source = if ENV['ENVIRONMENT'] == 'production'
+               SIGNING_KEY_URL
+             else
+               TEST_SIGNING_KEY_URL
+             end
+
+    $key_updater_semaphore.synchronize do
+      # Another thread might have been waiting for on the mutex
+      break unless $key_updater_thread.nil?
+
+      new_thread = Thread.new do
+        loop do
+          begin
+            timeout = 0
+
+            conn = Excon.new(source)
+            resp = conn.get
+
+            raise 'Unable to update keys: ' + resp.data[:status_line] unless resp.status == 200
+            cache_control = resp.headers['Cache-Control'].split(/,\s*/)
+            h = cache_control.map { |x| /\Amax-age=(?<timeout>\d+)\z/ =~ x; timeout }.compact
+
+            timeout = h.first.to_i if h.length == 1
+            timeout = 86400 if timeout.nil? || !timeout.positive?
+
+            Thread.current.thread_variable_set('keys', resp.body)
+
+            # Supposedly recommended by Tink library
+            sleep_time = timeout / 2
+
+            logger.info('Updated Google signing keys. Sleeping for: ' + (sleep_time / 86400.0).to_s + ' days')
+
+            sleep sleep_time
+          rescue Interrupt => e
+            # When interrupted
+            logger.fatal('Quitting: ' + e.message)
+            return
+          rescue => e
+            # Don't retry excessively.
+            logger.error('Exception updating Google signing keys: ' + e.message)
+            sleep 1
+          end
+        end
+      end
+
+      sleep 0.2 while new_thread.thread_variable_get('keys').nil?
+      # Body has now been set.
+      # Let other clients through.
+      $key_updater_thread = new_thread
+    end
+  end
+
+  ##
+  # A Payment represents a single payment using Google Pay.
+  # It is used to verify/decrypt the supplied token by using the shared secret,
+  # thus avoiding having knowledge of merchant primary keys.
+  class Payment
+    ##
+    # Parameters:
+    # token_string::  Google Pay token (JSON string)
+    # shared_secret:: Base64 encoded shared secret
+    # merchant_id::   Google Pay merchant ID ("merchant:<SOMETHING>")
+    # logger::        The logger to use. Default: Logger.new($stdout)
+    # signing_keys::  Formatted list of signing keys used to sign token contents.
+    #                 Otherwise a thread continuously updating google signing
+    #                 keys will be started.
+    def initialize(token_string, shared_secret, merchant_id,
+                   logger: Logger.new($stdout), signing_keys: nil)
+      Aliquot.start_key_updater(logger) if $key_updater_thread.nil? && signing_keys.nil?
+      @signing_keys = signing_keys
+
+      @shared_secret = shared_secret
+      @merchant_id = merchant_id
+      @token_string = token_string
+    end
+
+    ##
+    # Validate and decrypt the token.
+    def process
+      @token = JSON.parse(@token_string)
+      validate(Aliquot::Validator::Token, @token)
+
+      @protocol_version = @token['protocolVersion']
+
+      raise Error, 'only ECv1 protocolVersion is supported' unless @protocol_version == 'ECv1'
+
+      raise InvalidSignatureError unless valid_signature?(@token['signedMessage'],
+                                                          @token['signature'])
+
+      @signed_message = JSON.parse(@token['signedMessage'])
+      validate(Aliquot::Validator::SignedMessage, @signed_message)
+
+      aes_key, mac_key = derive_keys(@signed_message['ephemeralPublicKey'],
+                                     @shared_secret,
+                                     'Google')
+
+      raise InvalidMacError unless valid_mac?(mac_key,
+                                              @signed_message['encryptedMessage'],
+                                              @signed_message['tag'])
+
+      @message = decrypt(aes_key, @signed_message['encryptedMessage'])
+
+      validate(Aliquot::Validator::EncryptedMessageValidator, @message)
+
+      raise ExpiredException if expired?
+
+      @message
+    end
+
+    ##
+    # Check if the token is expired, according to the messageExpiration included
+    # in the token.
+    def expired?
+      @message['messageExpiration'].to_f / 1000.0 <= Time.now.to_f
+    end
+
+    private
+
+    def validate(klass, data)
+      validator = klass.new(data)
+      validator.validate
+    end
+
+    def derive_keys(ephemeral_public_key, shared_secret, info)
+      ikm = Base64.strict_decode64(ephemeral_public_key) +
+            Base64.strict_decode64(shared_secret)
+      hbytes = HKDF.new(ikm, algorithm: 'SHA256', info: info).next_bytes(32)
+
+      [hbytes[0..15], hbytes[16..32]]
+    end
+
+    def decrypt(key, encrypted)
+      c = OpenSSL::Cipher::AES128.new(:CTR)
+      c.key = key
+      c.decrypt
+      plain = c.update(Base64.strict_decode64(encrypted)) + c.final
+      JSON.parse(plain)
+    end
+
+    def valid_signature?(message, signature)
+      # Generate the string that was signed.
+      signed_string = ['Google', @merchant_id, @protocol_version, message].map do |str|
+        [str.length].pack('V') + str
+      end.join
+
+      keys = JSON.parse(signing_keys)['keys']
+      # Check if signature was performed with any possible key.
+      keys.map do |e|
+        next if e['protocolVersion'] != @protocol_version
+
+        ec = OpenSSL::PKey::EC.new(Base64.strict_decode64(e['keyValue']))
+        d  = OpenSSL::Digest::SHA256.new
+        ec.verify(d, Base64.strict_decode64(signature), signed_string)
+      end.any?
+    end
+
+    def valid_mac?(mac_key, data, tag)
+      d = OpenSSL::Digest::SHA256.new
+      mac = OpenSSL::HMAC.digest(d, mac_key, Base64.strict_decode64(data))
+      mac = Base64.strict_encode64(mac)
+
+      return false if mac.length != tag.length
+
+      Aliquot.compare(mac, tag)
+    end
+
+    def signing_keys
+      # Prefer static signing keys, otherwise fetch from updating thread.
+      @signing_keys || $key_updater_thread.thread_variable_get('keys')
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: aliquot
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Clearhaus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hkdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aliquot-pay
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: 
+email: hello@clearhaus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aliquot.rb
+- lib/aliquot/error.rb
+- lib/aliquot/validator.rb
+homepage: https://github.com/clearhaus/aliquot
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Validates Google Pay tokens
+test_files: []