google_pay_ruby 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 514316410dc1a39e4fba905f092019bb18c240bdda4e0091eedc32c24ec9760c
-  data.tar.gz: dc3a7c605555e55a95a3611ce1312a74cb7d8b50bc4d3fd283003619bda585d9
+  metadata.gz: 3e6258f7a6dc37c5f6483eecdc7a1b4a3cd47764cc69088677ee3a333b4be379
+  data.tar.gz: 6058b7215fe692a90d3de81e5f3445abb808a10e02867e50153315285a524b2c
 SHA512:
-  metadata.gz: 0233c81acf3e03655c8d6eb00c47f9f4ceded4612ff2bdfa19219d0c1f64790e79aff2a26eabe9a25899b59ff1486d522658c564d6472d9f63923d54120069b7
-  data.tar.gz: e7e0d6cb17829999003335d65dd9224a286eadfa84e0728b49e04637287d431c94ee95d738ba5329238fc561f7b1060f14d88ab9fb18f88ede9eaf87b185ea42
+  metadata.gz: fbb21c17fa7690351a99a2e089bcde9b64c96ed2d75629a15338955e4915a93c145514570750c3b2ebbd7201fc6efa6f3352c1427681dbc6ca0bc578a234fa68
+  data.tar.gz: ecc866798e1e3a802ca06e613b85fe9c1f367223c74a9a150c5fb506e2ae30de0a4913b8e646fd0e587a0ccf16358b286ac8d55c6ec4325e18513ed08eb1d994

data/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.0] - 2025-06-18
+
+### Added
+- **Signature Verification**: Full Google Pay ECv2 PaymentMethodToken signature verification per [Google Pay cryptography spec](https://developers.google.com/pay/api/web/guides/resources/payment-data-cryptography)
+  - Fetch Google root signing keys from production or test URLs
+  - Verify intermediate signing key signature against non-expired root keys
+  - Verify intermediate signing key expiration
+  - Verify message signature using intermediate signing key
+- **Message Expiration Check**: Verify `messageExpiration` field after decryption
+- New `SignatureVerifier` class encapsulating all verification logic
+- New initialization options for `GooglePaymentMethodTokenContext`:
+  - `:recipient_id` — required when signature verification is enabled (e.g. `"gateway:<gatewayId>"` or `"merchant:<merchantId>"`)
+  - `:root_signing_keys` — optional pre-fetched root keys (fetched automatically if nil)
+  - `:test` — use Google's test keys URL (default: false)
+  - `:verify_signature` — enable/disable signature verification (default: true)
+  - `:verify_expiration` — enable/disable message expiration check (default: true)
+
+### Breaking Changes
+- `GooglePaymentMethodTokenContext.new` now requires `:recipient_id` by default (signature verification is enabled by default)
+- To preserve v1 behavior, pass `verify_signature: false, verify_expiration: false`
+
 ## [1.0.1] - 2026-02-05
 
 ### Added

data/README.md

@@ -4,7 +4,9 @@ A Ruby utility for securely decrypting Google Pay PaymentMethodTokens using the
 
 ## Features
 
+- **ECv2 Signature Verification**: Full Google Pay ECv2 PaymentMethodToken signature verification per [Google Pay cryptography spec](https://developers.google.com/pay/api/web/guides/resources/payment-data-cryptography)
 - **Google Pay PaymentMethodToken Decryption**: Securely decrypt user-authorized Google Pay transaction tokens using easy-to-use interfaces
+- **Message Expiration Verification**: Automatically verify that decrypted messages haven't expired
 - **Key Rotation Support**: Handle multiple private keys simultaneously to support seamless key rotation without missing payments
 - **Pure Ruby Implementation**: No external dependencies beyond OpenSSL (included in Ruby standard library)
 - **ECv2 Protocol Support**: Implements Google Pay's ECv2 encryption protocol
@@ -41,7 +43,7 @@ Follow [Google Pay API guides](https://developers.google.com/pay/api) for your p
 
 ## Usage
 
-### Basic Example
+### Basic Example (with full verification)
 
 ```ruby
 require 'google_pay_ruby'
@@ -49,24 +51,29 @@ require 'google_pay_ruby'
 # Load your private key (from file, KMS, secrets manager, etc.)
 private_key_pem = File.read('path/to/your/private_key.pem')
 
-# Create the decryption context
+# Create the decryption context with signature verification
 context = GooglePayRuby::GooglePaymentMethodTokenContext.new(
   merchants: [
     {
       identifier: 'my-merchant-identifier',  # Optional, for debugging
       private_key_pem: private_key_pem
     }
-  ]
+  ],
+  recipient_id: 'gateway:your-gateway-id'  # or 'merchant:your-merchant-id'
 )
 
 # Get the token from Google Pay API response
 token = {
   'protocolVersion' => 'ECv2',
   'signature' => '...',
+  'intermediateSigningKey' => {
+    'signedKey' => '{"keyValue":"...","keyExpiration":"..."}',
+    'signatures' => ['...']
+  },
   'signedMessage' => '{"encryptedMessage":"...","ephemeralPublicKey":"...","tag":"..."}'
 }
 
-# Decrypt the token
+# Decrypt the token (signature verification + expiration check happen automatically)
 begin
   decrypted_data = context.decrypt(token)
   
@@ -93,13 +100,39 @@ context = GooglePayRuby::GooglePaymentMethodTokenContext.new(
       identifier: 'previous-key',
       private_key_pem: File.read('previous_key.pem')
     }
-  ]
+  ],
+  recipient_id: 'gateway:your-gateway-id'
 )
 
 # The library will try each key until decryption succeeds
 decrypted_data = context.decrypt(token)
 ```
 
+### Configuration Options
+
+```ruby
+context = GooglePayRuby::GooglePaymentMethodTokenContext.new(
+  merchants: [...],
+  recipient_id: 'gateway:your-gateway-id',   # Required when verify_signature is true
+  root_signing_keys: nil,                     # Pre-fetched keys, or nil to fetch from Google
+  test: false,                                # Use Google's test keys URL
+  verify_signature: true,                     # Enable/disable signature verification
+  verify_expiration: true                     # Enable/disable message expiration check
+)
+```
+
+### Decryption Only (no verification)
+
+To preserve v1 behavior without signature verification:
+
+```ruby
+context = GooglePayRuby::GooglePaymentMethodTokenContext.new(
+  merchants: [{ private_key_pem: private_key_pem }],
+  verify_signature: false,
+  verify_expiration: false
+)
+```
+
 ### Decrypted Data Structure
 
 The decrypted payment data contains:
@@ -143,7 +176,13 @@ end
 
 ## Development
 
-After checking out the repo, run `bundle install` to install dependencies. Then, run `ruby test/test_decrypt.rb` to run the tests.
+After checking out the repo, run `bundle install` to install dependencies. Then, run the tests:
+
+```bash
+ruby test/test_signature_verifier.rb
+ruby test/test_context_with_verification.rb
+ruby test/test_decrypt.rb
+```
 
 ## Contributing
 

data/lib/google_pay_ruby/google_payment_method_token_context.rb

@@ -4,19 +4,51 @@ module GooglePayRuby
   class GooglePaymentMethodTokenContext
     attr_reader :merchants
 
+    # @param options [Hash]
+    # @option options [Array<Hash>] :merchants List of merchant configs with :private_key_pem and optional :identifier
+    # @option options [String] :recipient_id The recipient ID for message signature verification
+    #   (e.g. "merchant:<merchantId>" or "gateway:<gatewayId>"). Required when verify_signature is true.
+    # @option options [Array<Hash>, nil] :root_signing_keys Pre-fetched Google root signing keys (ECv2 only).
+    #   If nil, fetched automatically from Google's public URL.
+    # @option options [Boolean] :test Whether to use Google's test keys URL (default: false)
+    # @option options [Boolean] :verify_signature Whether to verify token signatures before decryption (default: true)
+    # @option options [Boolean] :verify_expiration Whether to verify messageExpiration after decryption (default: true)
+    # @option options [String, nil] :gateway_merchant_id Expected gatewayMerchantId to verify in the decrypted payload.
+    #   When provided, the decrypted paymentMethodDetails.gatewayMerchantId must match this value.
+    # @option options [Boolean] :verify_merchant_id Whether to verify gatewayMerchantId after decryption (default: true if gateway_merchant_id is provided)
     def initialize(options)
       @merchants = options[:merchants] || []
-      
+      @recipient_id = options[:recipient_id]
+      @root_signing_keys = options[:root_signing_keys]
+      @gateway_merchant_id = options[:gateway_merchant_id]
+      @test = options.fetch(:test, false)
+      @verify_signature = options.fetch(:verify_signature, true)
+      @verify_expiration = options.fetch(:verify_expiration, true)
+      @verify_merchant_id = options.fetch(:verify_merchant_id, !@gateway_merchant_id.nil?)
+
       if @merchants.empty?
         raise GooglePaymentDecryptionError.new(
           'No merchant configuration provided for decryption context.'
         )
       end
-      
+
+      if @verify_signature && (@recipient_id.nil? || @recipient_id.empty?)
+        raise ArgumentError, ':recipient_id is required when signature verification is enabled'
+      end
+
       validate_merchant_configurations!
     end
 
+    # @param token [Hash, String] The Google Pay payment method token.
+    #   Can be a Hash (already parsed) or a JSON String (will be parsed internally).
+    #   When a String is provided, the raw JSON is preserved for signature verification
+    #   to handle unicode escapes (e.g. \u003d) that JSON.parse would decode.
     def decrypt(token)
+      if token.is_a?(String)
+        raw_token_json = token
+        token = JSON.parse(token)
+      end
+
       protocol_version = token['protocolVersion'] || token[:protocolVersion]
       unless protocol_version == 'ECv2'
         raise GooglePaymentDecryptionError.new(
@@ -24,33 +56,97 @@ module GooglePayRuby
         )
       end
 
+      # Steps 1-4: Verify signatures before decryption
+      if @verify_signature
+        verifier = SignatureVerifier.new(
+          root_signing_keys: @root_signing_keys,
+          recipient_id: @recipient_id,
+          test: @test
+        )
+        verifier.verify!(token, raw_token_json: raw_token_json)
+      end
+
+      # Step 5: Decrypt the payload
       errors = []
       signed_message = token['signedMessage'] || token[:signedMessage]
 
+      decrypted_data = nil
       @merchants.each do |merchant|
         begin
           strategy = EcV2DecryptionStrategy.new(merchant[:private_key_pem])
-          return strategy.decrypt(signed_message)
+          decrypted_data = strategy.decrypt(signed_message)
+          break
         rescue StandardError => e
           e.define_singleton_method(:merchant_identifier) { merchant[:identifier] }
           errors << e
         end
       end
 
-      raise GooglePaymentDecryptionError.new(
-        'Failed to decrypt payment data using provided merchant configuration(s).',
-        errors
-      )
+      unless decrypted_data
+        raise GooglePaymentDecryptionError.new(
+          'Failed to decrypt payment data using provided merchant configuration(s).',
+          errors
+        )
+      end
+
+      # Step 6: Verify message hasn't expired
+      if @verify_expiration
+        verify_message_expiration!(decrypted_data)
+      end
+
+      # Step 7: Verify gatewayMerchantId matches expected value
+      if @verify_merchant_id
+        verify_gateway_merchant_id!(decrypted_data)
+      end
+
+      decrypted_data
     end
 
     private
 
+    # Step 7: Verify that the gatewayMerchantId in the decrypted payload matches the expected value.
+    # Per spec: "Verify that the gatewayMerchantId matches the ID of the merchant that gave you the payload."
+    def verify_gateway_merchant_id!(decrypted_data)
+      actual_merchant_id = decrypted_data['gatewayMerchantId']
+
+      unless actual_merchant_id
+        raise GooglePaymentDecryptionError.new(
+          'Decrypted message is missing gatewayMerchantId field'
+        )
+      end
+
+      unless actual_merchant_id == @gateway_merchant_id
+        raise GooglePaymentDecryptionError.new(
+          "gatewayMerchantId mismatch: expected '#{@gateway_merchant_id}', got '#{actual_merchant_id}'"
+        )
+      end
+    end
+
+    # Step 6: Verify that the current time is less than the messageExpiration field
+    def verify_message_expiration!(decrypted_data)
+      message_expiration = decrypted_data['messageExpiration']
+
+      unless message_expiration
+        raise GooglePaymentDecryptionError.new(
+          'Decrypted message is missing messageExpiration field'
+        )
+      end
+
+      now_ms = (Time.now.to_f * 1000).to_i
+
+      if message_expiration.to_i <= now_ms
+        raise GooglePaymentDecryptionError.new(
+          "Decrypted message has expired (messageExpiration: #{message_expiration})"
+        )
+      end
+    end
+
     def validate_merchant_configurations!
       @merchants.each_with_index do |merchant, index|
         unless merchant.is_a?(Hash)
           raise ArgumentError, "Merchant configuration at index #{index} must be a Hash"
         end
-        
+
         unless merchant[:private_key_pem]
           raise ArgumentError, "Merchant configuration at index #{index} must include :private_key_pem"
         end

data/lib/google_pay_ruby/signature_verifier.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'base64'
+require 'json'
+require 'net/http'
+require 'uri'
+
+module GooglePayRuby
+  # Implements Google Pay ECv2 signature verification as specified in:
+  # https://developers.google.com/pay/api/web/guides/resources/payment-data-cryptography
+  #
+  # Verification steps:
+  #   1. Fetch Google root signing keys
+  #   2. Verify intermediate signing key signature against non-expired root keys
+  #   3. Verify intermediate signing key hasn't expired
+  #   4. Verify message signature using intermediate signing key
+  class SignatureVerifier
+    SENDER_ID = 'Google'
+    PROTOCOL_VERSION = 'ECv2'
+
+    GOOGLE_ROOT_SIGNING_KEYS_PROD_URL = 'https://payments.developers.google.com/paymentmethodtoken/keys.json'
+    GOOGLE_ROOT_SIGNING_KEYS_TEST_URL = 'https://payments.developers.google.com/paymentmethodtoken/test/keys.json'
+
+    # @param root_signing_keys [Array<Hash>, nil] Pre-fetched root signing keys (ECv2 only).
+    #   Each hash should have 'keyValue', 'protocolVersion', and optionally 'keyExpiration'.
+    #   If nil, keys are fetched from Google's public URL.
+    # @param recipient_id [String] The recipient ID used in message signature verification.
+    #   For merchants: "merchant:<merchantId>" (merchantId from Google Pay & Wallet Console).
+    #   For gateways: "gateway:<gatewayId>".
+    # @param test [Boolean] Whether to use Google's test keys URL (default: false).
+    def initialize(root_signing_keys: nil, recipient_id:, test: false)
+      @root_signing_keys = root_signing_keys
+      @recipient_id = recipient_id
+      @test = test
+    end
+
+    # Runs all verification steps (1-4) on the given token.
+    # Raises GooglePaymentDecryptionError on any verification failure.
+    #
+    # @param token [Hash] The full Google Pay payment method token (parsed)
+    # @param raw_token_json [String, nil] The original raw JSON string of the token.
+    #   When provided, signedKey and signedMessage are extracted from this raw string
+    #   to preserve the exact byte sequences that Google signed over (e.g. \u003d escapes).
+    #   JSON.parse decodes \u003d to '=' which changes the signed content and breaks verification.
+    # @return [void]
+    def verify!(token, raw_token_json: nil)
+      protocol_version = token['protocolVersion'] || token[:protocolVersion]
+      unless protocol_version == PROTOCOL_VERSION
+        raise GooglePaymentDecryptionError.new(
+          "Unsupported protocol version: #{protocol_version}. Only ECv2 is supported."
+        )
+      end
+
+      intermediate_signing_key = token['intermediateSigningKey'] || token[:intermediateSigningKey]
+      unless intermediate_signing_key
+        raise GooglePaymentDecryptionError.new('Missing intermediateSigningKey in token')
+      end
+
+      signed_key_json = intermediate_signing_key['signedKey'] || intermediate_signing_key[:signedKey]
+      signatures = intermediate_signing_key['signatures'] || intermediate_signing_key[:signatures]
+
+      unless signed_key_json && signatures
+        raise GooglePaymentDecryptionError.new('Missing signedKey or signatures in intermediateSigningKey')
+      end
+
+      # Extract original signedKey and signedMessage from raw JSON if available.
+      # This preserves the exact byte sequences (including unicode escapes like \u003d)
+      # that Google used when computing signatures.
+      if raw_token_json
+        raw_signed_key = extract_json_string_value(raw_token_json, 'signedKey')
+        raw_signed_message = extract_json_string_value(raw_token_json, 'signedMessage')
+        signed_key_json = raw_signed_key if raw_signed_key
+        signed_message_for_verify = raw_signed_message
+      end
+
+      # Step 2: Verify intermediate signing key signature against non-expired root keys
+      verify_intermediate_signing_key_signature!(signed_key_json, signatures)
+
+      # Step 3: Verify intermediate signing key hasn't expired
+      verify_intermediate_signing_key_expiration!(signed_key_json)
+
+      # Step 4: Verify message signature using intermediate signing key
+      signed_message = signed_message_for_verify || token['signedMessage'] || token[:signedMessage]
+      signature = token['signature'] || token[:signature]
+
+      unless signed_message && signature
+        raise GooglePaymentDecryptionError.new('Missing signedMessage or signature in token')
+      end
+
+      parsed_signed_key = JSON.parse(signed_key_json)
+      intermediate_key_value = parsed_signed_key['keyValue']
+
+      verify_message_signature!(signed_message, signature, intermediate_key_value)
+    end
+
+    private
+
+    # Step 1: Fetch or return cached root signing keys (filtered to ECv2).
+    def root_signing_keys
+      @root_signing_keys ||= fetch_root_signing_keys
+    end
+
+    def fetch_root_signing_keys
+      url = @test ? GOOGLE_ROOT_SIGNING_KEYS_TEST_URL : GOOGLE_ROOT_SIGNING_KEYS_PROD_URL
+      uri = URI.parse(url)
+
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.open_timeout = 10
+        http.read_timeout = 10
+        http.get(uri.request_uri)
+      end
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise GooglePaymentDecryptionError.new(
+          "Failed to fetch Google root signing keys: HTTP #{response.code}"
+        )
+      end
+
+      parsed = JSON.parse(response.body)
+      keys = parsed['keys'] || []
+
+      # Filter to ECv2 keys only
+      keys.select { |k| k['protocolVersion'] == PROTOCOL_VERSION }
+    rescue JSON::ParserError => e
+      raise GooglePaymentDecryptionError.new("Failed to parse Google root signing keys: #{e.message}")
+    rescue StandardError => e
+      raise e if e.is_a?(GooglePaymentDecryptionError)
+
+      raise GooglePaymentDecryptionError.new("Failed to fetch Google root signing keys: #{e.message}")
+    end
+
+    # Step 2: Verify that at least one signature in intermediateSigningKey.signatures
+    # is valid against any non-expired root signing key.
+    #
+    # Per spec: "iterate over all the signatures in intermediateSigningKey.signatures
+    # and try to validate each one with the non-expired Google signing keys in keys.json.
+    # If at least one signature validation works, consider the verification complete."
+    def verify_intermediate_signing_key_signature!(signed_key_json, signatures)
+      signed_bytes = build_signed_bytes_for_intermediate_key(signed_key_json)
+      now_ms = (Time.now.to_f * 1000).to_i
+
+      non_expired_root_keys = root_signing_keys.select do |key|
+        expiration = key['keyExpiration']
+        expiration.nil? || expiration.to_i > now_ms
+      end
+
+      if non_expired_root_keys.empty?
+        raise GooglePaymentDecryptionError.new('No non-expired Google root signing keys available')
+      end
+
+      verified = false
+
+      signatures.each do |sig_b64|
+        break if verified
+
+        sig_der = Base64.strict_decode64(sig_b64)
+
+        non_expired_root_keys.each do |root_key|
+          begin
+            ec_key = build_ec_public_key(root_key['keyValue'])
+            if ec_key.dsa_verify_asn1(
+              OpenSSL::Digest::SHA256.digest(signed_bytes),
+              sig_der
+            )
+              verified = true
+              break
+            end
+          rescue OpenSSL::PKey::ECError
+            next
+          end
+        end
+      end
+
+      unless verified
+        raise GooglePaymentDecryptionError.new(
+          'Could not verify intermediate signing key signature against any non-expired root key'
+        )
+      end
+    end
+
+    # Step 3: Verify that the intermediate signing key hasn't expired.
+    def verify_intermediate_signing_key_expiration!(signed_key_json)
+      parsed = JSON.parse(signed_key_json)
+      key_expiration = parsed['keyExpiration']
+
+      unless key_expiration
+        raise GooglePaymentDecryptionError.new('intermediateSigningKey.signedKey is missing keyExpiration')
+      end
+
+      now_ms = (Time.now.to_f * 1000).to_i
+
+      if key_expiration.to_i <= now_ms
+        raise GooglePaymentDecryptionError.new(
+          "Intermediate signing key has expired (keyExpiration: #{key_expiration})"
+        )
+      end
+    end
+
+    # Step 4: Verify that the message signature is valid using the intermediate signing key.
+    def verify_message_signature!(signed_message, signature_b64, intermediate_key_value_b64)
+      signed_bytes = build_signed_bytes_for_message(signed_message)
+      sig_der = Base64.strict_decode64(signature_b64)
+
+      ec_key = build_ec_public_key(intermediate_key_value_b64)
+
+      valid = ec_key.dsa_verify_asn1(
+        OpenSSL::Digest::SHA256.digest(signed_bytes),
+        sig_der
+      )
+
+      unless valid
+        raise GooglePaymentDecryptionError.new('Message signature verification failed')
+      end
+    rescue OpenSSL::PKey::ECError => e
+      raise GooglePaymentDecryptionError.new("Message signature verification error: #{e.message}")
+    end
+
+    # Construct the byte-string for intermediate signing key signature verification:
+    #
+    #   signedStringForIntermediateSigningKeySignature =
+    #     length_of_sender_id || sender_id ||
+    #     length_of_protocol_version || protocol_version ||
+    #     length_of_signed_key || signed_key
+    #
+    # Each component is UTF-8 encoded. Lengths are 4 bytes little-endian.
+    def build_signed_bytes_for_intermediate_key(signed_key_json)
+      sender_id_bytes = SENDER_ID.encode('UTF-8')
+      protocol_version_bytes = PROTOCOL_VERSION.encode('UTF-8')
+      signed_key_bytes = signed_key_json.encode('UTF-8')
+
+      [sender_id_bytes.bytesize].pack('V') + sender_id_bytes +
+        [protocol_version_bytes.bytesize].pack('V') + protocol_version_bytes +
+        [signed_key_bytes.bytesize].pack('V') + signed_key_bytes
+    end
+
+    # Construct the byte-string for message signature verification:
+    #
+    #   signedStringForMessageSignature =
+    #     length_of_sender_id || sender_id ||
+    #     length_of_recipient_id || recipient_id ||
+    #     length_of_protocolVersion || protocolVersion ||
+    #     length_of_signedMessage || signedMessage
+    #
+    # Each component is UTF-8 encoded. Lengths are 4 bytes little-endian.
+    # Per spec: "don't parse or modify signedMessage"
+    def build_signed_bytes_for_message(signed_message)
+      sender_id_bytes = SENDER_ID.encode('UTF-8')
+      recipient_id_bytes = @recipient_id.encode('UTF-8')
+      protocol_version_bytes = PROTOCOL_VERSION.encode('UTF-8')
+      signed_message_bytes = signed_message.encode('UTF-8')
+
+      [sender_id_bytes.bytesize].pack('V') + sender_id_bytes +
+        [recipient_id_bytes.bytesize].pack('V') + recipient_id_bytes +
+        [protocol_version_bytes.bytesize].pack('V') + protocol_version_bytes +
+        [signed_message_bytes.bytesize].pack('V') + signed_message_bytes
+    end
+
+    # Build an OpenSSL EC public key from a base64-encoded SubjectPublicKeyInfo DER value.
+    def build_ec_public_key(key_value_b64)
+      key_der = Base64.strict_decode64(key_value_b64)
+      OpenSSL::PKey::EC.new(key_der)
+    end
+
+    # Extract a JSON string value from raw JSON without decoding unicode escapes.
+    # This is critical because Google signs over the exact string content including
+    # any \uXXXX escapes. Ruby's JSON.parse decodes \u003d to '=' which changes
+    # the bytes and invalidates signatures.
+    #
+    # For a key like "signedKey", the value in the outer JSON is a JSON-encoded string.
+    # We need to extract and unescape the JSON string escapes (\" -> ", \\\\ -> \\)
+    # but preserve \uXXXX sequences as-is.
+    def extract_json_string_value(raw_json, key)
+      # Match "key":"<value>" where value may contain escaped characters
+      pattern = /"#{Regexp.escape(key)}"\s*:\s*"/
+      match = pattern.match(raw_json)
+      return nil unless match
+
+      start_pos = match.end(0)
+      # Walk through the string to find the unescaped closing quote
+      pos = start_pos
+      result = String.new
+      while pos < raw_json.length
+        char = raw_json[pos]
+        if char == '\\'
+          next_char = raw_json[pos + 1]
+          case next_char
+          when '"'
+            result << '"'
+            pos += 2
+          when '\\'
+            result << '\\'
+            pos += 2
+          when '/'
+            result << '/'
+            pos += 2
+          when 'n'
+            result << "\n"
+            pos += 2
+          when 'r'
+            result << "\r"
+            pos += 2
+          when 't'
+            result << "\t"
+            pos += 2
+          when 'b'
+            result << "\b"
+            pos += 2
+          when 'f'
+            result << "\f"
+            pos += 2
+          when 'u'
+            # Preserve \uXXXX as literal characters in the output
+            result << raw_json[pos..pos + 5]
+            pos += 6
+          else
+            result << char
+            pos += 1
+          end
+        elsif char == '"'
+          break
+        else
+          result << char
+          pos += 1
+        end
+      end
+      result
+    end
+  end
+end

data/lib/google_pay_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GooglePayRuby
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/google_pay_ruby.rb

@@ -4,6 +4,7 @@ require_relative "google_pay_ruby/version"
 require_relative "google_pay_ruby/google_payment_method_token_context"
 require_relative "google_pay_ruby/ec_v2_decryption_strategy"
 require_relative "google_pay_ruby/google_payment_decryption_error"
+require_relative "google_pay_ruby/signature_verifier"
 
 module GooglePayRuby
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google_pay_ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Sahil Gadimbayli
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-05 00:00:00.000000000 Z
+date: 2026-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,6 +53,7 @@ files:
 - lib/google_pay_ruby/ec_v2_decryption_strategy.rb
 - lib/google_pay_ruby/google_payment_decryption_error.rb
 - lib/google_pay_ruby/google_payment_method_token_context.rb
+- lib/google_pay_ruby/signature_verifier.rb
 - lib/google_pay_ruby/version.rb
 homepage: https://github.com/gadimbaylisahil/google_pay_ruby
 licenses: