paygate-ruby 0.1.8 → 0.2.0

data/lib/paygate/aes_ctr.rb

@@ -1,133 +1,136 @@
-require 'base64'
-
-module Paygate
-  class AesCtr
-
-    #  Encrypt a text using AES encryption in Counter mode of operation
-    #
-    #  Unicode multi-byte character safe
-    #
-    #  @param string plaintext Source text to be encrypted
-    #  @param string password  The password to use to generate a key
-    #  @param int num_bits     Number of bits to be used in the key (128, 192, or 256)
-    #  @returns string         Encrypted text
-    def self.encrypt(plaintext, password, num_bits)
-      block_size = 16      # block size fixed at 16 bytes / 128 bits (Nb=4) for AES
-      return '' unless num_bits.in?([128, 192, 256])
-
-      # use AES itself to encrypt password to get cipher key (using plain password as source for key
-      # expansion) - gives us well encrypted key (though hashed key might be preferred for prod'n use)
-      num_bytes = num_bits / 8        # no bytes in key (16/24/32)
-      pw_bytes = []
-      0.upto(num_bytes - 1){ |i| pw_bytes[i] = password.bytes.to_a[i] & 0xff || 0}      # use 1st 16/24/32 chars of password for key #warn
-      key = Aes.cipher(pw_bytes, Aes.key_expansion(pw_bytes))        # gives us 16-byte key
-      key = key + key[0, num_bytes - 16]                             # expand key to 16/24/32 bytes long
-
-      # initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec,
-      # [2-3] = random, [4-7] = seconds, together giving full sub-millisec uniqueness up to Feb 2106
-      counter_block = []
-      nonce = Time.now.to_i
-      nonce_ms = nonce % 1000
-      nonce_sec = (nonce / 1000.0).floor
-      nonce_rand = (rand() * 0xffff).floor
-      0.upto(1){ |i| counter_block[i] = urs(nonce_ms, i * 8) & 0xff }
-      0.upto(1){ |i| counter_block[i + 2] = urs(nonce_rand, i * 8) & 0xff }
-      0.upto(3){ |i| counter_block[i + 4] = urs(nonce_sec, i * 8) & 0xff }
-
-      # and convert it to a string to go on the front of the ciphertext
-      ctr_text = ''
-      0.upto(7){ |i| ctr_text += counter_block[i].chr }
-
-      # generate key schedule - an expansion of the key into distinct Key Rounds for each round
-      key_schedule = Aes.key_expansion(key)
-      block_count = (plaintext.length / block_size.to_f).ceil
-
-      cipher_text = []
-      0.upto(block_count - 1) do |b|
-        # set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
-        # done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
-        0.upto(3){ |c| counter_block[15 - c] = urs(b, c * 8) & 0xff }
-        0.upto(3){ |c| counter_block[15 - c - 4] = urs(b / 0x100000000, c * 8) }
-
-        cipher_cntr = Aes.cipher(counter_block, key_schedule) # -- encrypt counter block --
-        # block size is reduced on final block
-        block_length =  b < block_count - 1 ? block_size : (plaintext.length - 1) % block_size + 1
-        cipher_char = []
-        0.upto(block_length - 1) do |i|
-          cipher_char[i] = (cipher_cntr[i] ^ plaintext.bytes.to_a[b * block_size + i]).chr
-        end
-        cipher_text[b] = cipher_char.join
-      end
-
-      cipher_text = ctr_text + cipher_text.join
-      cipher_text = Base64.encode64(cipher_text).gsub(/\n/, '') + "\n";  # encode in base64
-    end
-
-    # Decrypt a text encrypted by AES in counter mode of operation
-    #
-    # @param string ciphertext Source text to be encrypted
-    # @param string password   The password to use to generate a key
-    # @param int nBits      Number of bits to be used in the key (128, 192, or 256)
-    # @returns string
-    #           Decrypted text
-    def self.decrypt(ciphertext, password, nBits)
-      blockSize = 16  # block size fixed at 16 bytes / 128 bits (Nb=4) for AES
-      return '' unless(nBits==128 || nBits==192 || nBits==256)
-      ciphertext = Base64.decode64(ciphertext);
-
-      nBytes = nBits/8  # no bytes in key (16/24/32)
-      pwBytes = []
-      0.upto(nBytes-1){|i| pwBytes[i] = password.bytes.to_a[i] & 0xff || 0}
-      key = Aes.cipher(pwBytes, Aes.key_expansion(pwBytes)) # gives us 16-byte key
-      key = key.concat(key.slice(0, nBytes-16)) # expand key to 16/24/32 bytes long
-      # recover nonce from 1st 8 bytes of ciphertext
-      counterBlock = []
-      ctrTxt = ciphertext[0,8]
-      0.upto(7){|i| counterBlock[i] = ctrTxt.bytes.to_a[i]}
-
-      #generate key Schedule
-      keySchedule = Aes.key_expansion(key);
-
-      # separate ciphertext into blocks (skipping past initial 8 bytes)
-      nBlocks = ((ciphertext.length-8)/blockSize.to_f).ceil
-      ct=[]
-      0.upto(nBlocks-1){|b|ct[b] = ciphertext[8+b*blockSize, 16]}
-
-      ciphertext = ct;  # ciphertext is now array of block-length strings
-
-      # plaintext will get generated block-by-block into array of block-length strings
-      plaintxt = [];
-      0.upto(nBlocks-1) do |b|
-        0.upto(3){|c| counterBlock[15-c] = urs(b,c*8) & 0xff}
-        0.upto(3){|c| counterBlock[15-c-4] = urs((b+1)/(0x100000000-1),c*8) & 0xff}
-        cipherCntr = Aes.cipher(counterBlock, keySchedule)  # encrypt counter block
-        plaintxtByte = []
-        0.upto(ciphertext[b].length - 1) do |i|
-          # -- xor plaintxt with ciphered counter byte-by-byte --
-          plaintxtByte[i] = (cipherCntr[i] ^ ciphertext[b].bytes.to_a[i]).chr;
-        end
-        plaintxt[b] = plaintxtByte.join('')
-      end
-      plaintext = plaintxt.join('')
-    end
-
-    private
-
-     # Unsigned right shift function, since Ruby has neither >>> operator nor unsigned ints
-     #
-     # @param a  number to be shifted (32-bit integer)
-     # @param b  number of bits to shift a to the right (0..31)
-     # @return   a right-shifted and zero-filled by b bits
-    def self.urs(a, b)
-      a &= 0xffffffff
-      b &= 0x1f
-      if a & 0x80000000 && b > 0    # if left-most bit set
-        a = ((a >> 1) & 0x7fffffff) # right-shift one bit & clear left-most bit
-        a = a >> (b - 1)            # remaining right-shifts
-      else                     # otherwise
-        a = (a >> b);            # use normal right-shift
-      end
-      a
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'base64'
+
+module Paygate
+  class AesCtr
+    #  Encrypt a text using AES encryption in Counter mode of operation
+    #
+    #  Unicode multi-byte character safe
+    #
+    #  @param string plaintext Source text to be encrypted
+    #  @param string password  The password to use to generate a key
+    #  @param int num_bits     Number of bits to be used in the key (128, 192, or 256)
+    #  @returns string         Encrypted text
+    def self.encrypt(plaintext, password, num_bits)
+      block_size = 16 # block size fixed at 16 bytes / 128 bits (Nb=4) for AES
+      return '' unless [128, 192, 256].include?(num_bits)
+
+      # use AES itself to encrypt password to get cipher key (using plain password as source for key
+      # expansion) - gives us well encrypted key (though hashed key might be preferred for prod'n use)
+      num_bytes = num_bits / 8 # no bytes in key (16/24/32)
+      pw_bytes = []
+      # use 1st 16/24/32 chars of password for key #warn
+      0.upto(num_bytes - 1) do |i|
+        pw_bytes[i] = (password.bytes.to_a[i] & 0xff) || 0
+      end
+      key = Aes.cipher(pw_bytes, Aes.key_expansion(pw_bytes)) # gives us 16-byte key
+      key += key[0, num_bytes - 16] # expand key to 16/24/32 bytes long
+
+      # initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec,
+      # [2-3] = random, [4-7] = seconds, together giving full sub-millisec uniqueness up to Feb 2106
+      counter_block = []
+      nonce = Time.now.to_i
+      nonce_ms = nonce % 1000
+      nonce_sec = (nonce / 1000.0).floor
+      nonce_rand = (rand * 0xffff).floor
+      0.upto(1) { |i| counter_block[i] = urs(nonce_ms, i * 8) & 0xff }
+      0.upto(1) { |i| counter_block[i + 2] = urs(nonce_rand, i * 8) & 0xff }
+      0.upto(3) { |i| counter_block[i + 4] = urs(nonce_sec, i * 8) & 0xff }
+
+      # and convert it to a string to go on the front of the ciphertext
+      ctr_text = ''
+      0.upto(7) { |i| ctr_text += counter_block[i].chr }
+
+      # generate key schedule - an expansion of the key into distinct Key Rounds for each round
+      key_schedule = Aes.key_expansion(key)
+      block_count = (plaintext.length / block_size.to_f).ceil
+
+      cipher_text = []
+      0.upto(block_count - 1) do |b|
+        # set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
+        # done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
+        0.upto(3) { |c| counter_block[15 - c] = urs(b, c * 8) & 0xff }
+        0.upto(3) { |c| counter_block[15 - c - 4] = urs(b / 0x100000000, c * 8) }
+
+        cipher_cntr = Aes.cipher(counter_block, key_schedule) # -- encrypt counter block --
+        # block size is reduced on final block
+        block_length = b < block_count - 1 ? block_size : ((plaintext.length - 1) % block_size) + 1
+        cipher_char = []
+        0.upto(block_length - 1) do |i|
+          cipher_char[i] = (cipher_cntr[i] ^ plaintext.bytes.to_a[(b * block_size) + i]).chr
+        end
+        cipher_text[b] = cipher_char.join
+      end
+
+      cipher_text = ctr_text + cipher_text.join
+      "#{Base64.encode64(cipher_text).delete("\n")}\n" # encode in base64
+    end
+
+    # Decrypt a text encrypted by AES in counter mode of operation
+    #
+    # @param string ciphertext Source text to be encrypted
+    # @param string password   The password to use to generate a key
+    # @param int n_bits      Number of bits to be used in the key (128, 192, or 256)
+    # @returns string
+    #           Decrypted text
+    def self.decrypt(ciphertext, password, n_bits)
+      block_size = 16 # block size fixed at 16 bytes / 128 bits (Nb=4) for AES
+      return '' unless [128, 192, 256].include?(n_bits)
+
+      ciphertext = Base64.decode64(ciphertext)
+
+      n_bytes = n_bits / 8 # no bytes in key (16/24/32)
+      pw_bytes = []
+      0.upto(n_bytes - 1) { |i| pw_bytes[i] = (password.bytes.to_a[i] & 0xff) || 0 }
+      key = Aes.cipher(pw_bytes, Aes.key_expansion(pw_bytes)) # gives us 16-byte key
+      key.concat(key.slice(0, n_bytes - 16)) # expand key to 16/24/32 bytes long
+      # recover nonce from 1st 8 bytes of ciphertext
+      counter_block = []
+      ctr_txt = ciphertext[0, 8]
+      0.upto(7) { |i| counter_block[i] = ctr_txt.bytes.to_a[i] }
+
+      # generate key Schedule
+      key_schedule = Aes.key_expansion(key)
+
+      # separate ciphertext into blocks (skipping past initial 8 bytes)
+      n_blocks = ((ciphertext.length - 8) / block_size.to_f).ceil
+      ct = []
+      0.upto(n_blocks - 1) { |b| ct[b] = ciphertext[8 + (b * block_size), 16] }
+
+      ciphertext = ct; # ciphertext is now array of block-length strings
+
+      # plaintext will get generated block-by-block into array of block-length strings
+      plaintxt = []
+      0.upto(n_blocks - 1) do |b|
+        0.upto(3) { |c| counter_block[15 - c] = urs(b, c * 8) & 0xff }
+        0.upto(3) { |c| counter_block[15 - c - 4] = urs((b + 1) / (0x100000000 - 1), c * 8) & 0xff }
+        cipher_cntr = Aes.cipher(counter_block, key_schedule) # encrypt counter block
+        plaintxt_byte = []
+        0.upto(ciphertext[b].length - 1) do |i|
+          # -- xor plaintxt with ciphered counter byte-by-byte --
+          plaintxt_byte[i] = (cipher_cntr[i] ^ ciphertext[b].bytes.to_a[i]).chr
+        end
+        plaintxt[b] = plaintxt_byte.join
+      end
+      plaintxt.join
+    end
+
+    # Unsigned right shift function, since Ruby has neither >>> operator nor unsigned ints
+    #
+    # @param a  number to be shifted (32-bit integer)
+    # @param b  number of bits to shift a to the right (0..31)
+    # @return   a right-shifted and zero-filled by b bits
+    def self.urs(a, b)
+      a &= 0xffffffff
+      b &= 0x1f
+      if (a & 0x80000000) && b.positive? # if left-most bit set
+        a = ((a >> 1) & 0x7fffffff) # right-shift one bit & clear left-most bit
+        a = a >> (b - 1)            # remaining right-shifts
+      else # otherwise
+        a = (a >> b);            # use normal right-shift
+      end
+      a
+    end
+  end
+end

data/lib/paygate/configuration.rb

@@ -1,16 +1,20 @@
-module Paygate
-  class Configuration
-    MODES = %i(live sandbox).freeze
-
-    attr_reader :mode
-
-    def initialize
-      @mode = :live
-    end
-
-    def mode=(value)
-      fail 'Invalid mode. Value must be one of the following: :live, :sandbox' unless value && MODES.include?(value.to_sym)
-      @mode = value.to_sym
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Paygate
+  class Configuration
+    MODES = %i[live sandbox].freeze
+
+    attr_reader :mode
+
+    def initialize
+      @mode = :live
+    end
+
+    def mode=(value)
+      value = value.to_sym
+      raise 'Invalid mode. Value must be one of the following: :live, :sandbox' unless value && MODES.include?(value)
+
+      @mode = value
+    end
+  end
+end

data/lib/paygate/member.rb

@@ -1,21 +1,24 @@
-module Paygate
-  class Member
-    attr_reader :mid, :secret
-
-    def initialize(mid, secret)
-      @mid, @secret = mid, secret
-    end
-
-    def refund_transaction(txn_id, options = {})
-      txn = Transaction.new(txn_id)
-      txn.member = self
-      txn.refund(options)
-    end
-
-    def profile_pay(profile_no, currency, amount)
-      profile = Profile.new(profile_no)
-      profile.member = self
-      profile.purchase(currency, amount)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Paygate
+  class Member
+    attr_reader :mid, :secret
+
+    def initialize(mid, secret)
+      @mid = mid
+      @secret = secret
+    end
+
+    def refund_transaction(txn_id, options = {})
+      txn = Transaction.new(txn_id)
+      txn.member = self
+      txn.refund(options)
+    end
+
+    def profile_pay(profile_no, currency, amount)
+      profile = Profile.new(profile_no)
+      profile.member = self
+      profile.purchase(currency, amount)
+    end
+  end
+end

data/lib/paygate/profile.rb

@@ -1,30 +1,33 @@
-require 'uri'
-require 'net/http'
-
-module Paygate
-  class Profile
-    PURCHASE_URL = 'https://service.paygate.net/INTL/pgtlProcess3.jsp'.freeze
-
-    attr_reader :profile_no
-    attr_accessor :member
-
-    def initialize(profile_no)
-      @profile_no = profile_no
-    end
-
-    def purchase(currency, amount)
-      # Prepare params
-      params = { profile_no: profile_no,
-                 mid: member.mid,
-                 goodcurrency: currency,
-                 unitprice: amount }.delete_if { |_, v| v.blank? }
-
-      # Make request
-      uri = URI(PURCHASE_URL)
-      uri.query = ::URI.encode_www_form(params)
-      response = ::Net::HTTP.get_response(uri)
-
-      Response.build_from_net_http_response(:profile_pay, response)
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+
+module Paygate
+  class Profile
+    PURCHASE_URL = 'https://service.paygate.net/INTL/pgtlProcess3.jsp'
+
+    attr_reader :profile_no
+    attr_accessor :member
+
+    def initialize(profile_no)
+      @profile_no = profile_no
+    end
+
+    def purchase(currency, amount)
+      # Prepare params
+      params = { profile_no: profile_no,
+                 mid: member.mid,
+                 goodcurrency: currency,
+                 unitprice: amount }
+      params.compact!
+
+      # Make request
+      uri = URI(PURCHASE_URL)
+      uri.query = ::URI.encode_www_form(params)
+      response = ::Net::HTTP.get_response(uri)
+
+      Response.build_from_net_http_response(:profile_pay, response)
+    end
+  end
+end

data/lib/paygate/response.rb

@@ -1,25 +1,27 @@
-module Paygate
-  class Response
-    attr_accessor :transaction_type, :http_code, :message, :body, :raw_info, :json
-
-    def self.build_from_net_http_response(txn_type, response)
-      r = new
-      r.transaction_type = txn_type
-      r.http_code = response.code
-      r.message = response.message
-      r.body = response.body
-
-      case txn_type
-        when :refund
-          r.json = JSON.parse response.body.gsub(/^callback\((.*)\)$/, '\1') if response.code.to_i == 200
-        when :profile_pay
-          r.json = {}
-          response.body.split('&').each do |key_value_pair|
-            key_value_ary = key_value_pair.split('=')
-            r.json[key_value_ary[0]] = key_value_ary[1]
-          end
-      end
-      r
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Paygate
+  class Response
+    attr_accessor :transaction_type, :http_code, :message, :body, :raw_info, :json
+
+    def self.build_from_net_http_response(txn_type, response)
+      r = new
+      r.transaction_type = txn_type
+      r.http_code = response.code
+      r.message = response.message
+      r.body = response.body
+
+      case txn_type
+      when :refund
+        r.json = JSON.parse response.body.gsub(/^callback\((.*)\)$/, '\1') if response.code.to_i == 200
+      when :profile_pay
+        r.json = {}
+        response.body.split('&').each do |key_value_pair|
+          key_value_ary = key_value_pair.split('=')
+          r.json[key_value_ary[0]] = key_value_ary[1]
+        end
+      end
+      r
+    end
+  end
+end

data/lib/paygate/transaction.rb

@@ -1,58 +1,60 @@
-require 'digest'
-require 'uri'
-require 'net/http'
-
-module Paygate
-  class Transaction
-    FULL_AMOUNT_IDENTIFIER = 'F'.freeze
-
-    attr_reader :tid
-    attr_accessor :member
-
-    def initialize(tid)
-      @tid = tid
-    end
-
-    def refund(options = {})
-      # Encrypt data
-      api_key_256 = ::Digest::SHA256.hexdigest(member.secret)
-      aes_ctr = AesCtr.encrypt(tid, api_key_256, 256)
-      tid_enc = "AES256#{aes_ctr}"
-
-      # Prepare params
-      params = { callback: 'callback', mid: member.mid, tid: tid_enc }
-      params.merge!(options.slice(:amount))
-      params[:amount] ||= FULL_AMOUNT_IDENTIFIER
-      params[:mb_serial_no] = options[:order_id]
-      params.delete_if { |_, v| v.blank? }
-
-      # Make request
-      uri = URI(self.class.refund_api_url)
-      uri.query = ::URI.encode_www_form(params)
-      response = ::Net::HTTP.get_response(uri)
-
-      r = Response.build_from_net_http_response(:refund, response)
-      r.raw_info = OpenStruct.new(tid: tid, tid_enc: tid_enc, request_url: uri.to_s)
-      r
-    end
-
-    # Doc: https://km.paygate.net/pages/viewpage.action?pageId=9207875
-    def verify
-      params = { tid: tid, verifyNum: 100 }
-
-      uri = URI('https://service.paygate.net/djemals/settle/verifyReceived.jsp')
-      uri.query = ::URI.encode_www_form(params)
-      response = ::Net::HTTP.get_response(uri)
-
-      Response.build_from_net_http_response(:verify, response)
-    end
-
-    private
-
-    def self.refund_api_url
-      (Paygate.configuration.mode == :live) ?
-        'https://service.paygate.net/service/cancelAPI.json' :
-        'https://stgsvc.paygate.net/service/cancelAPI.json'
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'digest'
+require 'uri'
+require 'net/http'
+
+module Paygate
+  class Transaction
+    FULL_AMOUNT_IDENTIFIER = 'F'
+
+    attr_reader :tid
+    attr_accessor :member
+
+    def initialize(tid)
+      @tid = tid
+    end
+
+    def refund(options = {})
+      # Encrypt data
+      api_key256 = ::Digest::SHA256.hexdigest(member.secret)
+      aes_ctr = AesCtr.encrypt(tid, api_key256, 256)
+      tid_enc = "AES256#{aes_ctr}"
+
+      # Prepare params
+      params = { callback: 'callback', mid: member.mid, tid: tid_enc }
+      params.merge!(options.slice(:amount))
+      params[:amount] ||= FULL_AMOUNT_IDENTIFIER
+      params[:mb_serial_no] = options[:order_id]
+      params.compact!
+
+      # Make request
+      uri = URI(self.class.refund_api_url)
+      uri.query = ::URI.encode_www_form(params)
+      response = ::Net::HTTP.get_response(uri)
+
+      r = Response.build_from_net_http_response(:refund, response)
+      r.raw_info = OpenStruct.new(tid: tid, tid_enc: tid_enc, request_url: uri.to_s) # rubocop:disable Style/OpenStructUse
+      r
+    end
+
+    # Doc: https://km.paygate.net/pages/viewpage.action?pageId=9207875
+    def verify
+      params = { tid: tid, verifyNum: 100 }
+
+      uri = URI('https://service.paygate.net/djemals/settle/verifyReceived.jsp')
+      uri.query = ::URI.encode_www_form(params)
+      response = ::Net::HTTP.get_response(uri)
+
+      Response.build_from_net_http_response(:verify, response)
+    end
+
+    def self.refund_api_url
+      if Paygate.configuration.mode == :live
+        'https://service.paygate.net/service/cancelAPI.json'
+      else
+        'https://stgsvc.paygate.net/service/cancelAPI.json'
+      end
+    end
+  end
+end

data/lib/paygate/version.rb

@@ -1,3 +1,5 @@
-module Paygate
-  VERSION = '0.1.8'
-end
+# frozen_string_literal: true
+
+module Paygate
+  VERSION = '0.2.0'
+end