r2d2 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 026e3de4d7dca643f8f57f519a93014eaa3587ea
-  data.tar.gz: 1a58252e22b3595cf709d132b10308012baae046
+SHA256:
+  metadata.gz: 8fd5e6027086b7e2417c7839833ac9e5a4c895b42b8b798f59067dfc3974c82d
+  data.tar.gz: 40bcd0191eb22ea4f07b950fcc0628f287250dfb5476f128f0130463ecd91d34
 SHA512:
-  metadata.gz: abf1504ec9d6bbcfc77f774052e4c66d073033d2eb562edfe397711e03252e41e51ddf764be8c6abc14be455a4641b43cb1527b703ec1fb49def7a0a2f708b4e
-  data.tar.gz: 72bc939de0608e03740b44cfff6ba6941933ead007ba2c044b38f3c2e6964da749e8bdb355fad0b63658efbe4b4751f847fad37426363294c9de857d7fb9eb70
+  metadata.gz: 96107bd836d140f4a5bcde53490faf3307ba7771fd50008e2f77d9ab61091163cad14872ff337579d48a8c41ee6d8a01b4f6fc2461fac725729db9f17365a9f0
+  data.tar.gz: f1762817389f164a1b5901497c46def4385646c66db5f945793bded47e459a99d60daf217bf9ee6c60a10d61433e35d1e2a8612c609325cffe2f5924dee1a898

data/.circleci/config.yml

@@ -1,12 +1,12 @@
 version: 2
 jobs:
-  ruby-2.1:
-    docker:
-      - image: circleci/ruby:2.1.10
-    steps:
-      - checkout
-      - run: bundle
-      - run: rake test
+  # ruby-2.1:
+  #   docker:
+  #     - image: circleci/ruby:2.1.10
+  #   steps:
+  #     - checkout
+  #     - run: bundle
+  #     - run: rake test
   ruby-2.2:
     docker:
       - image: circleci/ruby:2.2.10
@@ -39,7 +39,7 @@ workflows:
   version: 2
   rubies:
     jobs:
-      - ruby-2.1
+      # - ruby-2.1
       - ruby-2.2
       # - ruby-2.3
       # - ruby-2.4

data/Gemfile

@@ -1,5 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-gem 'hkdf', '~> 0.2.0'

data/README.md

@@ -2,21 +2,76 @@
 
 [![CircleCI](https://circleci.com/gh/spreedly/r2d2.svg?style=svg)](https://circleci.com/gh/spreedly/r2d2)
 
-R2D2 is a Ruby library for decrypting Android Pay payment tokens.
+R2D2 is a Ruby library for decrypting Google Pay and Android Pay payment tokens.
 
 ## Ruby support
 
-Currently, only Ruby v2.2 and below are supported. For Ruby >= 2.3, work will need to be done (similar to [what was done in Gala](https://github.com/spreedly/gala/commit/0a4359ccdd5654b78747f9141645ca510ee255c2)) to use a compatible aead decryption algorithm.
+Currently, Ruby v2.2 is supported. For Ruby >= 2.3, work will need to be done (similar to [what was done in Gala](https://github.com/spreedly/gala/commit/0a4359ccdd5654b78747f9141645ca510ee255c2)) to use a compatible aead decryption algorithm.
 
 ## Install
 
 Add to your `Gemfile`:
 
 ```ruby
-gem "android_pay", git: "https://github.com/spreedly/android_pay.git"
+gem 'r2d2', git: 'https://github.com/spreedly/r2d2.git'
 ```
 
-## Usage
+## Google Pay Usage
+
+For Google Pay, R2D2 requires the token values in the form of a JSON hash, your `recipient_id`, Google's `verification_keys`, 
+and your private key.
+
+Example Google Pay token values:
+
+```json
+{
+  "signature": "MEYCIQD5mAtwoptfXuDnEVvtSbPmRnkw94GXEHjog24SfIe4rAIhAKLeSY4xcHLK1liBoZFaeZG+FrqawI7Id2mJXwddP3KH",
+  "protocolVersion": "ECv1",
+  "signedMessage": "{\"encryptedMessage\":\"jzo38/Ufbt9qh/scrTJmG9v8Cgb7Y5S+zCTTbSou/NoLoE/XF9ixyIGNIspKkH4ulwwVX0/EoqKDKk86XDLw8qBjx1tfHefbLuhZbqkfu/8bs5D6QMz8LjcJU+EeXYcdZ+KeQ3jzrgS6B9CqEJJIF+PeySMJtTwF9Fh+X2sW4Yg0C34mHz0MHpVUpmzJZblTwzMkCVOdq7eMF9Ywb8kDnRFasMYALbRaEOMg2o9gXSfGEVPhS8ors4SRFcnLoVPfktHRJtY/UZEREJvGFY/s/wpmU9sRADYTMKQ/ChTMumT+1NG0r4XibDcaZjW/Wlz1Dwog+dNMYUblPjY613sBLtjoBbRDYYVuDn/TUYXOJwAgXoHFfMmvWm0ne0n9eXggxoaMFFgF5zXk9ZLl3FyH/hi3WWtsFt5sqQWgFdjsqTriL6i46m46hMaZ9gKZ8JQE912IG5kZts5L8XSMiG94Z3UiTA\\u003d\\u003d\",\"ephemeralPublicKey\":\"BIeq42AvLcEhz0oLmYdj++oBTS5PD131FAEgx4y91cwqbkZMUKADkzj2bD4MxneqgqFYirO29+y/G6YH9zmfjlk\\u003d\",\"tag\":\"sRILsawzbm53+9tVTh9ooBP5ivzxWki73UJbuOZ3IYY\\u003d\"}"
+}
+```
+
+The `recipient_id` will be in the form `gateway:processorname`. 
+
+The `verificiation_keys` are available in Google's developer docs. Example:
+
+```json
+{ "keys":
+  [
+    { "keyValue":"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIsFro6K+IUxRr4yFTOTO+kFCCEvHo7B9IOMLxah6c977oFzX\/beObH4a9OfosMHmft3JJZ6B3xpjIb8kduK4\/A==",
+      "protocolVersion":"ECv1"
+    }
+  ]
+}
+```
+
+```ruby
+require 'r2d2'
+
+# token_attrs = Google Pay token values { "signature": "...", "protocolVersion": "...", ...}
+token = R2D2.build_token(token_attrs, recipient_id: recipient_id, verification_keys: verification_keys)
+
+private_key_pem = File.read('private_key.pem')
+decrypted_json = token.decrypt(private_key_pem)
+
+JSON.parse(decrypted_json)
+# =>
+{
+  "gatewayMerchantId" => "exampleGatewayMerchantId",
+  "messageExpiration" => "1528716120231", 
+  "messageId" => "AH2EjtcpVGS3JvxlTP5kUbx3h0Laa30uVKjB9CqmnYiw8gZ-tpsxIoOdTbAU_DtCbkLVUPzkFeeqSbU1vTbAIAE4LlPHJqBiMMF4hZ5KRafml3764_6lK7aH7cQkIma40CI-rtCWTLCk",
+  "paymentMethod" => "CARD",
+  "paymentMethodDetails" =>
+  {
+    "expirationYear" => 2023,
+    "expirationMonth" => 12,
+    "pan" => "4111111111111111"
+  }
+}
+```
+
+
+## Android Pay Usage
 
 R2D2 takes input in the form of the hash of Android Pay token values:
 
@@ -28,16 +83,15 @@ R2D2 takes input in the form of the hash of Android Pay token values:
 }
 ```
 
-and the merchant's private key private key (which is managed by a third-party such as a gateway or independent processor like [Spreedly](https://spreedly.com)).
+and the merchant's private key (which is managed by a third-party such as a gateway or independent processor like [Spreedly](https://spreedly.com)).
 
 ```ruby
-require "android_pay"
+require 'r2d2'
 
 # token_json = raw token string you get from Android Pay { "encryptedMessage": "...", "tag": "...", ...}
-token_attrs = JSON.parse(token_json)
-token = R2D2::PaymentToken.new(token_attrs)
+token = R2D2.build_token(token_attrs)
 
-private_key_pem = File.read("private_key.pem")
+private_key_pem = File.read('private_key.pem')
 decrypted_json = token.decrypt(private_key_pem)
 
 JSON.parse(decrypted_json)
@@ -52,21 +106,21 @@ JSON.parse(decrypted_json)
 }
 ```
 
-### Performance
+## Performance
 
 The library implements a constant time comparison algorithm for preventing timing attacks. The default pure ruby implementation is quite inefficient, but portable. If performance is a priority for you, you can use a faster comparison algorithm provided by the [fast_secure_compare](https://github.com/daxtens/fast_secure_compare).
 
 To enable `FastSecureCompare` in your environment, add the following to your Gemfile:
 
 ```ruby
-gem 'fast_secure_compare`
+gem 'fast_secure_compare'
 ```
 
 and require the extension in your application prior to loading r2d2:
 
 ```ruby
 require 'fast_secure_compare/fast_secure_compare'
-require 'r2d2/payment_token'
+require 'r2d2'
 ```
 
 Benchmarks illustrating the overhead of the pure Ruby version:
@@ -98,7 +152,7 @@ $ curl -u rwdaigle https://rubygems.org/api/v1/api_key.yaml > ~/.gem/credentials
 <enter rubygems account password>
 ```
 
-If you are not yet listed as a gem owner, you will need to [request access](http://guides.rubygems.org/command-reference/#gem-owner) from @rwdaigle.
+If you are not yet listed as a gem owner, you will need to [request access](https://github.com/rwdaigle) from @rwdaigle.
 
 ### Release
 
@@ -110,6 +164,13 @@ $ rake release
 
 ## Changelog
 
+### v1.0.0
+
+* Breaking Changes: API now decrypts both Google Pay and Android Pay tokens
+* New method call to decrypt Android Pay tokens
+* Additional arguments included for Google Pay tokens
+* Update README.md
+
 ### v0.1.2
 
 * Setup CircleCI for more exhaustive Ruby version compatibility tests
@@ -117,4 +178,8 @@ $ rake release
 
 ## Contributors
 
+* [mrezentes](https://github.com/mrezentes)
+* [rwdaigle](https://github.com/rwdaigle)
 * [methodmissing](https://github.com/methodmissing)
+* [bdewater](https://github.com/bdewater)
+* [deedeelavinder](https://github.com/deedeelavinder)

data/lib/r2d2.rb

@@ -1,3 +1,7 @@
 require "json"
+require 'openssl'
+require 'base64'
 
-require_relative "r2d2/payment_token"
+require_relative "r2d2/util"
+require_relative "r2d2/android_pay_token"
+require_relative "r2d2/google_pay_token"

data/lib/r2d2/android_pay_token.rb

@@ -0,0 +1,27 @@
+module R2D2
+  class AndroidPayToken
+    include Util
+
+    attr_accessor :encrypted_message, :ephemeral_public_key, :tag
+
+    def initialize(token_attrs)
+      self.ephemeral_public_key = token_attrs["ephemeralPublicKey"]
+      self.tag = token_attrs["tag"]
+      self.encrypted_message = token_attrs["encryptedMessage"]
+    end
+
+    def decrypt(private_key_pem)
+      private_key = OpenSSL::PKey::EC.new(private_key_pem)
+
+      shared_secret = generate_shared_secret(private_key, ephemeral_public_key)
+
+      # derive the symmetric_encryption_key and mac_key
+      hkdf_keys = derive_hkdf_keys(ephemeral_public_key, shared_secret, 'Android')
+
+      # verify the tag is a valid value
+      verify_mac(hkdf_keys[:mac_key], encrypted_message, tag)
+
+      JSON.parse(decrypt_message(encrypted_message, hkdf_keys[:symmetric_encryption_key]))
+    end
+  end
+end

data/lib/r2d2/google_pay_token.rb

@@ -0,0 +1,54 @@
+module R2D2
+  class GooglePayToken
+    include Util
+
+    attr_reader :protocol_version, :recipient_id, :verification_keys, :signature, :signed_message
+
+    def initialize(token_attrs, recipient_id:, verification_keys:)
+      @protocol_version = token_attrs['protocolVersion']
+      @recipient_id = recipient_id
+      @verification_keys = verification_keys
+      @signature = token_attrs['signature']
+      @signed_message = token_attrs['signedMessage']
+    end
+
+    def decrypt(private_key_pem)
+      verified = verify_and_parse_message
+
+      private_key = OpenSSL::PKey::EC.new(private_key_pem)
+      shared_secret = generate_shared_secret(private_key, verified['ephemeralPublicKey'])
+      hkdf_keys = derive_hkdf_keys(verified['ephemeralPublicKey'], shared_secret, 'Google')
+
+      verify_mac(hkdf_keys[:mac_key], verified['encryptedMessage'], verified['tag'])
+      decrypted = JSON.parse(
+        decrypt_message(verified['encryptedMessage'], hkdf_keys[:symmetric_encryption_key])
+      )
+
+      expired = decrypted['messageExpiration'].to_f / 1000.0 <= Time.now.to_f
+      raise MessageExpiredError if expired
+
+      decrypted
+    end
+
+    private
+
+    def verify_and_parse_message
+      digest = OpenSSL::Digest::SHA256.new
+      signed_bytes = to_length_value(
+        'Google',
+        recipient_id,
+        protocol_version,
+        signed_message
+      )
+      verified = verification_keys['keys'].any? do |key|
+        next if key['protocolVersion'] != protocol_version
+
+        ec = OpenSSL::PKey::EC.new(Base64.strict_decode64(key['keyValue']))
+        ec.verify(digest, Base64.strict_decode64(signature), signed_bytes)
+      end
+
+      raise SignatureInvalidError unless verified
+      JSON.parse(signed_message)
+    end
+  end
+end

data/lib/r2d2/util.rb

@@ -0,0 +1,104 @@
+module R2D2
+  Error = Class.new(StandardError)
+  TagVerificationError = Class.new(R2D2::Error)
+  SignatureInvalidError = Class.new(R2D2::Error)
+  MessageExpiredError = Class.new(R2D2::Error)
+
+  def build_token(token_attrs, recipient_id: nil, verification_keys: nil)
+    protocol_version = token_attrs.fetch('protocolVersion', 'ECv0')
+
+    case protocol_version
+    when 'ECv0'
+      AndroidPayToken.new(token_attrs)
+    when 'ECv1'
+      raise ArgumentError, "missing keyword: recipient_id" if recipient_id.nil?
+      raise ArgumentError, "missing keyword: verification_keys" if verification_keys.nil?
+
+      GooglePayToken.new(token_attrs, recipient_id: recipient_id, verification_keys: verification_keys)
+    else
+      raise ArgumentError, "unknown protocolVersion #{protocol_version}"
+    end
+  end
+  module_function :build_token
+
+  module Util
+    def generate_shared_secret(private_key, ephemeral_public_key)
+      ec = OpenSSL::PKey::EC.new('prime256v1')
+      bn = OpenSSL::BN.new(Base64.decode64(ephemeral_public_key), 2)
+      point = OpenSSL::PKey::EC::Point.new(ec.group, bn)
+      private_key.dh_compute_key(point)
+    end
+
+    def derive_hkdf_keys(ephemeral_public_key, shared_secret, info)
+      key_material = Base64.decode64(ephemeral_public_key) + shared_secret
+      hkdf_bytes = hkdf(key_material, info)
+      {
+        symmetric_encryption_key: hkdf_bytes[0..15],
+        mac_key: hkdf_bytes[16..32]
+      }
+    end
+
+    def verify_mac(mac_key, encrypted_message, tag)
+      digest = OpenSSL::Digest.new('sha256')
+      mac = OpenSSL::HMAC.digest(digest, mac_key, Base64.decode64(encrypted_message))
+      raise TagVerificationError unless secure_compare(mac, Base64.decode64(tag))
+    end
+
+    def decrypt_message(encrypted_data, symmetric_key)
+      decipher = OpenSSL::Cipher::AES128.new(:CTR)
+      decipher.decrypt
+      decipher.key = symmetric_key
+      decipher.update(Base64.decode64(encrypted_data)) + decipher.final
+    end
+
+    def to_length_value(*chunks)
+      value = ''
+      chunks.each do |chunk|
+        chunk_size = 4.times.map do |index|
+          (chunk.bytesize >> (8 * index)) & 0xFF
+        end
+        value << chunk_size.pack('C*')
+        value << chunk
+      end
+      value
+    end
+
+    private
+
+    if defined?(FastSecureCompare)
+      def secure_compare(a, b)
+        FastSecureCompare.compare(a, b)
+      end
+    else
+      # constant-time comparison algorithm to prevent timing attacks; borrowed from ActiveSupport::MessageVerifier
+      def secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+
+        l = a.unpack("C#{a.bytesize}")
+
+        res = 0
+        b.each_byte { |byte| res |= byte ^ l.shift }
+        res == 0
+      end
+    end
+
+    if defined?(OpenSSL::KDF) && OpenSSL::KDF.respond_to?(:hkdf)
+      def hkdf(key_material, info)
+        OpenSSL::KDF.hkdf(key_material, salt: 0.chr * 32, info: info, length: 32, hash: 'sha256')
+      end
+    else
+      begin
+        require 'hkdf'
+      rescue LoadError
+        STDERR.puts "You need at least Ruby OpenSSL gem 2.1 (installed: #{OpenSSL::VERSION}) " \
+        "and system OpenSSL 1.1.0 (installed: #{OpenSSL::OPENSSL_LIBRARY_VERSION}) for HKDF support." \
+        "You can add \"gem 'hkdf'\" to your Gemfile for a Ruby-based fallback."
+        raise
+      end
+
+      def hkdf(key_material, info)
+        HKDF.new(key_material, algorithm: 'SHA256', info: info).next_bytes(32)
+      end
+    end
+  end
+end

data/lib/r2d2/version.rb

@@ -1,3 +1,3 @@
 module R2D2
-  VERSION = "0.1.2" unless defined? R2D2::VERSION
+  VERSION = "1.0.0" unless defined? R2D2::VERSION
 end

data/r2d2.gemspec

@@ -16,12 +16,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.required_ruby_version = ">= 1.8.7"
+  s.required_ruby_version = ">= 2.2"
 
   s.add_runtime_dependency 'hkdf'
 
   s.add_development_dependency "bundler", "~> 1.15"
   s.add_development_dependency "rake", "~> 12.0"
   s.add_development_dependency "minitest", "~> 5.0"
+  s.add_development_dependency "timecop"
   s.add_development_dependency "pry-byebug"
 end

data/test/android_pay_token_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class R2D2::AndroidPayTokenTest < Minitest::Test
+  def setup
+    fixtures = File.dirname(__FILE__) + "/fixtures/"
+    @token_attrs = JSON.parse(File.read(fixtures + "token.json"))
+    @private_key = File.read(fixtures + "private_key.pem")
+    @payment_token = R2D2::AndroidPayToken.new(@token_attrs)
+  end
+
+  def test_initialize
+    assert_equal @token_attrs["ephemeralPublicKey"], @payment_token.ephemeral_public_key
+    assert_equal @token_attrs["tag"], @payment_token.tag
+    assert_equal @token_attrs["encryptedMessage"], @payment_token.encrypted_message
+  end
+
+  def test_successful_decrypt
+    payment_data = @payment_token.decrypt(@private_key)
+    assert_equal "4895370012003478", payment_data["dpan"]
+    assert_equal 12, payment_data["expirationMonth"]
+    assert_equal 2020, payment_data["expirationYear"]
+    assert_equal "3DS", payment_data["authMethod"]
+    assert_equal "AgAAAAAABk4DWZ4C28yUQAAAAAA=", payment_data["3dsCryptogram"]
+    assert_equal "07", payment_data["3dsEciIndicator"]
+  end
+
+  def test_invalid_tag
+    @payment_token.tag = "SomethingBogus"
+    assert_raises R2D2::TagVerificationError do
+      @payment_token.decrypt(@private_key)
+    end
+  end
+end

data/test/fixtures/ec_v1/card.json

@@ -0,0 +1,5 @@
+{
+  "signature": "MEUCIQDeIvCbFje6fFQe0lFUD8oV6T3GY81dU9UJ6KeXlwKSJgIgamgC56BdcNEJgffQDW3bTFWmEQVoC6zUZ+J7xJp2WAg\u003d",
+  "protocolVersion": "ECv1",
+  "signedMessage": "{\"encryptedMessage\":\"ilnxpVEEaaZ2GFSc7cQDNxSMkjF5nWFcT6w3HSdpX+5mXn/uv6naeTjSoGfy1gi6JdpToKuc0hhkqpetNVDj6dPH8u01K685xEL0AVjuSR84WnRfxnWjDNlYRuGS0N5iPY6G/981ucbgwBNcAjqemTdc6xv6/lQwZq36V7FWt4IAchg55JJt2mnFMSDkkMTz5bWfJtgmwg55b0KXfuTA3ADLxeFlOLuT3DICFzo45jyCK1RSltiCHhD+Lm65wESCHCgS9W50yh2a/J1lTCUP7Xy/aaurVtNUrB+H/SlY16Szk455h27d2Zi6JKzxnL/rQ+5ME1TWpp0n66RQ70y1roC5myNy6ILmEoyIdAU6FahuGX4MQFkmO4G4GOL5lMEj63hF1U2N/iFm03Urx2dSWkCsiVM\\u003d\",\"ephemeralPublicKey\":\"BEENTno093zpl+QST4mXKVqrOVHsqweffqILO+HAob2JyF8YNtjBWXoKunSF0rkGY3spzp/BsNHKJ3Req+DfOwM\\u003d\",\"tag\":\"eZJ0p0DUu9TGM3bOx8VBCcgt9sJ9tgLRnLjgPyd4aKs\\u003d\"}"
+}

data/test/fixtures/ec_v1/google_verification_key_production.json

@@ -0,0 +1,8 @@
+{
+  "keys": [
+    {
+      "keyValue": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAENnoaYTAh15xpR65XRw7jHYj7vNUIGu5I4OmLCrORWwdjrcrED+bJo+nF2HyA5hnH12Dqt1bR8mqKBXynG3HBNw==",
+      "protocolVersion": "ECv1"
+    }
+  ]
+}

data/test/fixtures/ec_v1/google_verification_key_test.json

@@ -0,0 +1,8 @@
+{
+  "keys": [
+    {
+      "keyValue": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIsFro6K+IUxRr4yFTOTO+kFCCEvHo7B9IOMLxah6c977oFzX\/beObH4a9OfosMHmft3JJZ6B3xpjIb8kduK4\/A==",
+      "protocolVersion": "ECv1"
+    }
+  ]
+}

data/test/fixtures/ec_v1/private_key.pem

@@ -0,0 +1,5 @@
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIIvzjN8pvJsygwyvbp1zKqH2SMUwMkM3HKNeMHx1sbC5oAoGCCqGSM49
+AwEHoUQDQgAEkveyWrkD745R6yWrJxjjBX+XPkGkbZCs7pqXyu4GSfqyVR1yq/Pa
+RtfNkXhuqHBSjgo2hV2DK1bXfsc0VKt3mg==
+-----END EC PRIVATE KEY-----

data/test/fixtures/ec_v1/tokenized_card.json

@@ -0,0 +1,5 @@
+{
+  "signature": "MEUCIQDzgQkY/Lj42FoZC9wN44Uz0r6uDttc68k2c9oZCzNJPwIgSRukEx30uMjqzFswekoarAtO9p1/E221hNmVuHzDW+M\u003d",
+  "protocolVersion": "ECv1",
+  "signedMessage": "{\"encryptedMessage\":\"RrliMMApO0MghHfjfVbJDz3jmdwQYluu8yjLPqnsRUZ36s28ceb+KxEdFIaxC2Y/d6hUm7kUOpyLbCMlj0IZXUP7WmGxHW+oQr8BDiHmwlRzovO3WCyB91kci0dz17k5qKaT/6Pf3FMu+0IhiGd+QtD6d+ifv6bvy6iA0rwpGMHheC/gKqZF4xCYWJjw7Twa72xEbjp9qlO0msA8jysjuB+N2injsL43I/lB592I/V9VZJvI5S7TDZi8XQb1kNKNmhH1XDEseT3Mb180xtJxCxuVOpk9yH7NyRWha3HV6Tgr+GqSSk5jCzZyY/PxxwTjnRvRPmcrd7PTN+w1k4M4TdniyStmdk8yUdxgd+utNB3Xwh4J8caFtDVZdRYgoDx5S/3zJ6xQckqQzVD0fRuykVtMjY++EMbNfNdGKV0u8mAEBVXJaPVsxISCgBJTvpNzllj3DMvNEE/Zc5p+7izMh8mz++g5ab5mrw/Xg//dYm/ndKG6V9WXqosTg4IdhsWALgCLyYVZwxjsjF3kua0XZ2IyemsvGU0KtZL9Uy4\\u003d\",\"ephemeralPublicKey\":\"BCVPKilVgN/Mg7cg4nkLZnvMZ0EIONH+Cnlq6ykhWk/lq+fHHgH+lOoy0MXvI7ZfDL6AesSO8+mqLl4MwwHDd6o\\u003d\",\"tag\":\"P/m+wFoQ7yQHepwhGdGvp08TSPPuO1a5SyF9C5QKIe4\\u003d\"}"
+}

data/test/google_pay_token_test.rb

@@ -0,0 +1,105 @@
+require "test_helper"
+
+module R2D2
+  class GooglePayTokenTest < Minitest::Test
+    def setup
+      @recipient_id = 'merchant:12345678901234567890'
+      @fixtures = __dir__ + "/fixtures/ec_v1/"
+      @token = JSON.parse(File.read(@fixtures + "tokenized_card.json"))
+      @private_key = File.read(@fixtures + "private_key.pem")
+      @verification_keys = JSON.parse(File.read(@fixtures + "google_verification_key_test.json"))
+      Timecop.freeze(Time.at(1509713963))
+    end
+
+    def teardown
+      Timecop.return
+    end
+
+    def test_decrypted_tokenized_card
+      expected = {
+        "messageExpiration" => "1510318759535",
+        "paymentMethod" => "TOKENIZED_CARD",
+        "messageId" => "AH2EjtfMnpeHvgqYbBDLAxPzyYlPOmOa792BqdsvTc2T7jsn23_us0dKU509I-AA9dVDLf9_v4c5ldxoge6Q3iYr9acGGSyD9ojbOTP1fjWzDteVE_yf1pGzGNQ2Q6jKG96KRpbIaziY",
+        "paymentMethodDetails" =>
+          {
+            "expirationYear" => 2022,
+            "dpan" => "4895370012003478",
+            "expirationMonth" => 12,
+            "authMethod" => "3DS",
+            "3dsCryptogram" => "AgAAAAAABk4DWZ4C28yUQAAAAAA=",
+            "3dsEciIndicator" => "07"
+          }
+      }
+      decrypted = new_token.decrypt(@private_key)
+
+      assert_equal expected, decrypted
+    end
+
+    def test_decrypted_card
+      @token = JSON.parse(File.read(@fixtures + 'card.json'))
+      expected = {
+        "messageExpiration" => "1510319499834",
+        "paymentMethod" => "CARD",
+        "messageId" => "AH2EjtcMeg5mOCD9kUXWn6quP6AF6jOJeirO0EW40tPVzMMy_YAri8HZdJzqzQquC0w_dkvXhC41s2BN53HRD_kzgT4jxGeB4E9BI8OQCPw9GgWTXIAQb55Av77l6VCesYHIQre8Ij60",
+        "paymentMethodDetails" =>
+          {
+            "expirationYear" => 2022,
+            "expirationMonth" => 12,
+            "pan" => "4111111111111111"
+          }
+      }
+      decrypted = new_token.decrypt(@private_key)
+
+      assert_equal expected, decrypted
+    end
+
+    def test_wrong_signature
+      @token['signature'] = "MEQCIDxBoUCoFRGReLdZ/cABlSSRIKoOEFoU3e27c14vMZtfAiBtX3pGMEpnw6mSAbnagCCgHlCk3NcFwWYEyxIE6KGZVA\u003d\u003d"
+
+      assert_raises R2D2::SignatureInvalidError do
+        new_token.decrypt(@private_key)
+      end
+    end
+
+    def test_wrong_verification_key
+      @verification_keys = JSON.parse(File.read(@fixtures + "google_verification_key_production.json"))
+
+      assert_raises R2D2::SignatureInvalidError do
+        new_token.decrypt(@private_key)
+      end
+    end
+
+    def test_unknown_verification_key_version
+      @verification_keys['keys'][0]['protocolVersion'] = 'foo'
+
+      assert_raises R2D2::SignatureInvalidError do
+        new_token.decrypt(@private_key)
+      end
+    end
+
+    def test_multiple_verification_keys
+      production_keys = JSON.parse(File.read(@fixtures + "google_verification_key_production.json"))['keys']
+      @verification_keys = { 'keys' => production_keys + @verification_keys['keys'] }
+
+      assert new_token.decrypt(@private_key)
+    end
+
+    def test_expired_message
+      Timecop.freeze(Time.at(1510318760)) do
+        assert_raises R2D2::MessageExpiredError do
+          new_token.decrypt(@private_key)
+        end
+      end
+    end
+
+    private
+
+    def new_token
+      R2D2::GooglePayToken.new(
+        @token,
+        recipient_id: @recipient_id,
+        verification_keys: @verification_keys
+      )
+    end
+  end
+end

data/test/test_helper.rb

@@ -2,4 +2,5 @@ $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 require "r2d2"
 
 require "minitest/autorun"
+require "timecop"
 require "pry-byebug"

data/test/token_builder_test.rb

@@ -0,0 +1,37 @@
+require "test_helper"
+
+module R2D2
+  class TokenBuilderTest < Minitest::Test
+    def setup
+      @fixtures = __dir__ + "/fixtures/"
+      @recipient_id = 'merchant:12345678901234567890'
+      @verification_keys = JSON.parse(File.read(@fixtures + "ec_v1/google_verification_key_test.json"))
+    end
+
+    def test_builds_android_pay_token
+      token_attrs = JSON.parse(File.read(@fixtures + "token.json"))
+      assert_instance_of AndroidPayToken, R2D2.build_token(token_attrs)
+    end
+
+    def test_builds_google_pay_token
+      token_attrs = JSON.parse(File.read(@fixtures + "ec_v1/tokenized_card.json"))
+      assert_instance_of GooglePayToken, R2D2.build_token(token_attrs, recipient_id: @recipient_id, verification_keys: @verification_keys)
+    end
+
+    def test_building_token_raises_with_unknown_protocol_version
+      token_attrs = JSON.parse(File.read(@fixtures + "ec_v1/tokenized_card.json"))
+      token_attrs['protocolVersion'] = 'foo'
+
+      assert_raises ArgumentError do
+        R2D2.build_token(token_attrs, recipient_id: @recipient_id, verification_keys: @verification_keys)
+      end
+    end
+
+    def test_building_google_pay_token_raises_with_missing_arguments
+      token_attrs = JSON.parse(File.read(@fixtures + "ec_v1/tokenized_card.json"))
+      assert_raises ArgumentError do
+        R2D2.build_token(token_attrs)
+      end
+    end
+  end
+end

data/test/util_test.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+
+module R2D2
+  class UtilTest < Minitest::Test
+    include Util
+
+    def setup
+      fixtures = __dir__ + "/fixtures/"
+      @token_attrs = JSON.parse(File.read(fixtures + "token.json"))
+      @private_key = File.read(fixtures + "private_key.pem")
+      @payment_token = R2D2::AndroidPayToken.new(@token_attrs)
+      @shared_secret = ['44a9715c18ebcb255af705f7332657420aca40604334a7d48a89baba18280a97']
+    end
+
+    def test_shared_secret
+      priv_key = OpenSSL::PKey::EC.new(@private_key)
+      assert_equal @shared_secret, generate_shared_secret(priv_key, @payment_token.ephemeral_public_key).unpack('H*')
+    end
+
+    def test_derive_hkdf_keys
+      hkdf_keys = derive_hkdf_keys(@payment_token.ephemeral_public_key, @shared_secret[0], 'Android')
+      assert_equal ["c7b2670dc0630edd0a9101dd5d70e4b2"], hkdf_keys[:symmetric_encryption_key].unpack('H*')
+      assert_equal ["d8976b95c980760d8ce3933994c6eda1"], hkdf_keys[:mac_key].unpack('H*')
+    end
+
+    def test_to_length_value
+      expected = "\x06\x00\x00\x00Google\x04\x00\x00\x00ECv1\x13\x01\x00\x00" + 'longstring-' * 25
+      assert_equal expected, to_length_value('Google', 'ECv1', 'longstring-' * 25)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: r2d2
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Miki Rezentes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-08 00:00:00.000000000 Z
+date: 2018-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hkdf
@@ -67,6 +67,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -95,17 +109,27 @@ files:
 - README.md
 - Rakefile
 - lib/r2d2.rb
-- lib/r2d2/payment_token.rb
+- lib/r2d2/android_pay_token.rb
+- lib/r2d2/google_pay_token.rb
+- lib/r2d2/util.rb
 - lib/r2d2/version.rb
 - r2d2.gemspec
+- test/android_pay_token_test.rb
+- test/fixtures/ec_v1/card.json
+- test/fixtures/ec_v1/google_verification_key_production.json
+- test/fixtures/ec_v1/google_verification_key_test.json
+- test/fixtures/ec_v1/private_key.pem
+- test/fixtures/ec_v1/tokenized_card.json
 - test/fixtures/private_key.pem
 - test/fixtures/public_key.pem
 - test/fixtures/token.json
+- test/google_pay_token_test.rb
 - test/initial_dev/test_data.md
 - test/initial_dev/test_data_private_key.pem
 - test/initial_dev/test_data_token.json
-- test/payment_token_test.rb
 - test/test_helper.rb
+- test/token_builder_test.rb
+- test/util_test.rb
 homepage: https://github.com/spreedly/r2d2
 licenses: []
 metadata: {}
@@ -117,7 +141,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -125,16 +149,24 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.5
 signing_key: 
 specification_version: 4
 summary: Android Pay payment token decryption library
 test_files:
+- test/android_pay_token_test.rb
+- test/fixtures/ec_v1/card.json
+- test/fixtures/ec_v1/google_verification_key_production.json
+- test/fixtures/ec_v1/google_verification_key_test.json
+- test/fixtures/ec_v1/private_key.pem
+- test/fixtures/ec_v1/tokenized_card.json
 - test/fixtures/private_key.pem
 - test/fixtures/public_key.pem
 - test/fixtures/token.json
+- test/google_pay_token_test.rb
 - test/initial_dev/test_data.md
 - test/initial_dev/test_data_private_key.pem
 - test/initial_dev/test_data_token.json
-- test/payment_token_test.rb
 - test/test_helper.rb
+- test/token_builder_test.rb
+- test/util_test.rb

data/lib/r2d2/payment_token.rb

@@ -1,82 +0,0 @@
-require 'openssl'
-require 'base64'
-require 'hkdf'
-
-module R2D2
-  class PaymentToken
-
-    attr_accessor :encrypted_message, :ephemeral_public_key, :tag
-
-    class TagVerificationError < StandardError; end;
-
-    def initialize(token_attrs)
-      self.ephemeral_public_key = token_attrs["ephemeralPublicKey"]
-      self.tag = token_attrs["tag"]
-      self.encrypted_message = token_attrs["encryptedMessage"]
-    end
-
-    def decrypt(private_key_pem)
-      digest = OpenSSL::Digest.new('sha256')
-      private_key = OpenSSL::PKey::EC.new(private_key_pem)
-
-      shared_secret = self.class.generate_shared_secret(private_key, ephemeral_public_key)
-
-      # derive the symmetric_encryption_key and mac_key
-      hkdf_keys = self.class.derive_hkdf_keys(ephemeral_public_key, shared_secret);
-
-      # verify the tag is a valid value
-      self.class.verify_mac(digest, hkdf_keys[:mac_key], encrypted_message, tag)
-
-      self.class.decrypt_message(encrypted_message, hkdf_keys[:symmetric_encryption_key])
-    end
-
-    class << self
-
-      def generate_shared_secret(private_key, ephemeral_public_key)
-        ec = OpenSSL::PKey::EC.new('prime256v1')
-        bn = OpenSSL::BN.new(Base64.decode64(ephemeral_public_key), 2)
-        point = OpenSSL::PKey::EC::Point.new(ec.group, bn)
-        private_key.dh_compute_key(point)
-      end
-
-      def derive_hkdf_keys(ephemeral_public_key, shared_secret)
-        key_material = Base64.decode64(ephemeral_public_key) + shared_secret;
-        hkdf = HKDF.new(key_material, :algorithm => 'SHA256', :info => 'Android')
-        {
-          :symmetric_encryption_key => hkdf.next_bytes(16),
-          :mac_key => hkdf.next_bytes(16)
-        }
-      end
-
-      def verify_mac(digest, mac_key, encrypted_message, tag)
-        mac = OpenSSL::HMAC.digest(digest, mac_key, Base64.decode64(encrypted_message))
-        raise TagVerificationError unless secure_compare(mac, Base64.decode64(tag))
-      end
-
-      def decrypt_message(encrypted_data, symmetric_key)
-        decipher = OpenSSL::Cipher::AES128.new(:CTR)
-        decipher.decrypt
-        decipher.key = symmetric_key
-        decipher.auth_data = ""
-        decipher.update(Base64.decode64(encrypted_data)) + decipher.final
-      end
-
-      if defined?(FastSecureCompare)
-        def secure_compare(a, b)
-          FastSecureCompare.compare(a, b)
-        end
-      else
-        # constant-time comparison algorithm to prevent timing attacks; borrowed from ActiveSupport::MessageVerifier
-        def secure_compare(a, b)
-          return false unless a.bytesize == b.bytesize
-
-          l = a.unpack("C#{a.bytesize}")
-
-          res = 0
-          b.each_byte { |byte| res |= byte ^ l.shift }
-          res == 0
-        end
-      end
-    end
-  end
-end

data/test/payment_token_test.rb

@@ -1,49 +0,0 @@
-require "test_helper"
-
-class R2D2::PaymentTokenTest < Minitest::Test
-
-  def setup
-    fixtures = File.dirname(__FILE__) + "/fixtures/"
-    @token_attrs = JSON.parse(File.read(fixtures + "token.json"))
-    @private_key = File.read(fixtures + "private_key.pem")
-    @payment_token = R2D2::PaymentToken.new(@token_attrs)
-    @shared_secret = ['44a9715c18ebcb255af705f7332657420aca40604334a7d48a89baba18280a97']
-    @mac_key = ["d8976b95c980760d8ce3933994c6eda1"]
-    @symmetric_encryption_key = ["c7b2670dc0630edd0a9101dd5d70e4b2"]
-  end
-
-  def test_initialize
-    assert_equal @token_attrs["ephemeralPublicKey"], @payment_token.ephemeral_public_key
-    assert_equal @token_attrs["tag"], @payment_token.tag
-    assert_equal @token_attrs["encryptedMessage"], @payment_token.encrypted_message
-  end
-
-  def test_successful_decrypt
-    payment_data = JSON.parse(@payment_token.decrypt( @private_key))
-    assert_equal "4895370012003478", payment_data["dpan"]
-    assert_equal 12, payment_data["expirationMonth"]
-    assert_equal 2020, payment_data["expirationYear"]
-    assert_equal "3DS", payment_data["authMethod"]
-    assert_equal "AgAAAAAABk4DWZ4C28yUQAAAAAA=", payment_data["3dsCryptogram"]
-    assert_equal "07", payment_data["3dsEciIndicator"]
-  end
-
-  def test_shared_secret
-    priv_key = OpenSSL::PKey::EC.new(@private_key)
-    assert_equal @shared_secret, R2D2::PaymentToken.generate_shared_secret(priv_key, @payment_token.ephemeral_public_key).unpack('H*')
-  end
-
-  def test_derive_hkdf_keys
-    hkdf_keys = R2D2::PaymentToken.derive_hkdf_keys(@payment_token.ephemeral_public_key, @shared_secret[0])
-    assert_equal hkdf_keys[:symmetric_encryption_key].unpack('H*'), @symmetric_encryption_key
-    assert_equal hkdf_keys[:mac_key].unpack('H*'), @mac_key
-  end
-
-  def test_invalid_tag
-    @payment_token.tag = "SomethingBogus"
-    assert_raises R2D2::PaymentToken::TagVerificationError do
-      JSON.parse(@payment_token.decrypt( @private_key))
-    end
-  end
-
-end