simple_oauth 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 680161f3f3fc8cf54f78c5111c1f0c4bcd6380b0d29022fb9ac5fd407805d8b7
-  data.tar.gz: 6951095c0b1b04b7755e8857a977946825053a141e3fd4c1c3b7e10cade061fe
+  metadata.gz: bd2a5227ccf41a180c48803278ab10caa9348f38e6a4009d9e3faad9eac6218e
+  data.tar.gz: 6e30b74dfb49f761430105c0fff030e40aaefea1682cf6101d8b168430e41445
 SHA512:
-  metadata.gz: f852606e3aa48e70a5856f0cfccbfafe4c9235a6a701faca692446186b5bf8f30781b316577b7ac15a164b07293f9b550ad5cdfe0db58df6e57be396de380cf6
-  data.tar.gz: d938005d0ad30817b294e0e8143b272be0dafb794dfa4a57ee012fc8f162c7d895d85a5a2ae0a57f4bc3b9e50c372fde93ac22b31bc01579ead3deec968f2d2a
+  metadata.gz: a6880bc574c06b6b4b20975ae4ee3ee29db0dd65b2ccec9bda5c59bc966c8ceebe355c2413e71aafc3ce141c5aaebd7f78b8262b701833134f16175886de0fd5
+  data.tar.gz: 6c2699ea118ed0d57c1987a691b0ddc7fb8d2264bee1527f14b9c621725adb8aaf5359971cbee43de3fe105bf7a8dac11439e1b8c592fa57e471412e1f43df48

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [0.5.3] - 2026-11-14
+
+### Fixed
+
+* Verify as fast as 0.5.1 when `Header#valid?` is not given a `signature_method`. 0.5.2 parsed the `consumer_secret` as an RSA key on every verification, which takes far longer to fail for a shared secret than verifying does, and parsed an RSA key twice. That made such a verification about 60 to 70 percent slower. Only a secret in PEM, or one that could be in DER, is now parsed, and an RSA key only once
+
+## [0.5.2] - 2026-11-14
+
+### Security
+
+* `Header#valid?` no longer verifies with whatever signature method the received header claims. A server verifying RSA signatures with a client's public key, as the README showed, accepted forged requests signed with that public key as an HMAC-SHA1 or PLAINTEXT secret. Reported by Rathnadeepan (HotWater, [@HotWater-015](https://github.com/HotWater-015))
+  * Given a `signature_method`, the header must claim that method
+  * Without one, the header must claim an RSA method for an RSA key and an HMAC method for any other secret
+  * PLAINTEXT signatures verify only when the caller names `PLAINTEXT`
+
+### Deprecated
+
+* Calling `Header#valid?` without a `signature_method`, which a later major version will require
+
 ## [0.5.1] - 2026-09-12
 
 ### Fixed

data/README.md

@@ -155,16 +155,18 @@ parsed = SimpleOAuth::Header.parse_query("oauth_consumer_key=key&status=hello")
 header = SimpleOAuth::Header.new(:get, request_url, params, authorization_header)
 
 # Verify the signature
-header.valid?(consumer_secret: "secret", token_secret: "token_secret")
+header.valid?(consumer_secret: "secret", token_secret: "token_secret", signature_method: "HMAC-SHA1")
 # => true
 ```
 
+Name the signature method you expect, and a header claiming any other method is not valid. The method a request claims is chosen by whoever sent it, so verifying with it unchecked would let anyone holding an RSA public key pass it off as an HMAC or PLAINTEXT secret. Leaving `signature_method` out is deprecated: the header must then claim an RSA method for an RSA key and an HMAC method for any other secret. PLAINTEXT signatures are accepted only when you name `PLAINTEXT`, and they send the secrets themselves, so accept them only over TLS.
+
 Verifying compares signatures in constant time and leaves the header's own options untouched, so the secrets stay with the caller.
 
 RSA signatures verify with the client's public key, which is all a server has:
 
 ```ruby
-header.valid?(consumer_secret: File.read("client_public_key.pem"))
+header.valid?(consumer_secret: File.read("client_public_key.pem"), signature_method: "RSA-SHA1")
 ```
 
 Custom signature methods that cannot be verified by recomputing the signature register a `verify` block:

data/lib/simple_oauth/header/verification.rb

@@ -0,0 +1,82 @@
+require "openssl"
+
+module SimpleOAuth
+  class Header
+    # Checks of the signature method a received header claims, before it is verified with it
+    #
+    # @api private
+    module Verification
+      # The first byte of a key in DER, which encodes every key as an ASN.1 SEQUENCE
+      ASN1_SEQUENCE = 0x30
+
+      # The start of the line that opens every key in PEM
+      PEM_BOUNDARY = "-----BEGIN".freeze
+
+      private
+
+      # Checks that the header claims a signature method the verifier accepts
+      #
+      # @api private
+      # @param verifying [Hash] the header's options merged with the verifier's secrets
+      # @param expected [String, nil] the signature method the verifier expects, if it names one
+      # @return [Boolean] true if the claimed method is the expected one, or fits the key
+      # @raise [ArgumentError] if the expected signature method is not registered
+      def signature_method_acceptable?(verifying, expected)
+        claimed = options[:signature_method].to_s
+        return expected_signature_method?(claimed, expected) if expected
+
+        warn("SimpleOAuth::Header#valid? without a signature_method is deprecated. " \
+             "Name the method to verify with, such as signature_method: \"HMAC-SHA1\"", category: :deprecated)
+        key = verifying[:consumer_secret].to_s
+        Signature.registered?(claimed) && !PLAINTEXT_SIGNATURE_METHOD.casecmp(claimed).eql?(0) &&
+          (Signature.rsa?(claimed) ? key_encoded?(key) : !rsa_key?(key))
+      end
+
+      # Checks that the header claims the signature method the verifier names
+      #
+      # Signature method names are compared without regard to ASCII case, as the registry looks
+      # them up, and without allocating. A header that claims the expected method needs no other
+      # check here, since Signature.verify raises for a method that is not registered.
+      #
+      # @api private
+      # @param claimed [String] the signature method the header claims
+      # @param expected [String] the signature method the verifier expects
+      # @return [Boolean] true if the header claims the expected method
+      # @raise [ArgumentError] if the expected signature method is not registered
+      def expected_signature_method?(claimed, expected)
+        return true if claimed.casecmp(expected).eql?(0)
+        raise ArgumentError, "Unknown signature method: #{expected}" unless Signature.registered?(expected)
+
+        false
+      end
+
+      # Checks whether a verifying key is encoded as a key could be
+      #
+      # Only a key in PEM, which always holds a "-----BEGIN" line, or in DER, which always starts with
+      # the byte of an ASN.1 SEQUENCE, can be an RSA key, as those are the encodings OpenSSL decodes.
+      # Any other secret need not be parsed, which matters since a parse that fails is far slower
+      # than verifying a signature.
+      #
+      # @api private
+      # @param key [String] the consumer_secret the verifier gave
+      # @return [Boolean] true if the key is in PEM or could be in DER
+      def key_encoded?(key)
+        key.getbyte(0).eql?(ASN1_SEQUENCE) || key.include?(PEM_BOUNDARY)
+      end
+
+      # Checks whether a verifying key is an RSA key
+      #
+      # @api private
+      # @param key [String] the consumer_secret the verifier gave
+      # @return [Boolean] true if the key parses as an RSA key
+      def rsa_key?(key)
+        return false unless key_encoded?(key)
+
+        OpenSSL::PKey::RSA.new(key)
+        true
+      rescue OpenSSL::PKey::PKeyError
+        false
+      end
+    end
+  end
+end

data/lib/simple_oauth/header.rb

@@ -6,6 +6,7 @@ require_relative "parser"
 require_relative "signature"
 require_relative "header/class_methods"
 require_relative "header/params"
+require_relative "header/verification"
 
 module SimpleOAuth
   # Generates OAuth 1.0 Authorization headers for HTTP requests
@@ -23,6 +24,9 @@ module SimpleOAuth
     # Default signature method per RFC 5849
     DEFAULT_SIGNATURE_METHOD = "HMAC-SHA1".freeze
 
+    # The signature method that sends the secrets themselves, which verifying accepts only when named
+    PLAINTEXT_SIGNATURE_METHOD = "PLAINTEXT".freeze
+
     # OAuth version
     OAUTH_VERSION = "1.0".freeze
 
@@ -64,6 +68,7 @@ module SimpleOAuth
     attr_reader :options
 
     include Params
+    include Verification
 
     extend ClassMethods
     extend Encoding
@@ -122,18 +127,29 @@ module SimpleOAuth
 
     # Validates the signature in the header against the provided secrets
     #
+    # The method a received header claims is chosen by whoever sent it, so it is checked before it
+    # is used. Given a signature_method, the header must claim that method. Without one, the header
+    # must claim a method that fits the key: an RSA method for an RSA key, and an HMAC method for any
+    # other secret. PLAINTEXT is accepted only when named, as it sends the secrets themselves.
+    # Without that check, a sender holding only an RSA public key could sign with it as an HMAC or
+    # PLAINTEXT secret.
+    #
     # @api public
-    # @param secrets [Hash] the consumer_secret and token_secret for validation
+    # @param secrets [Hash] the consumer_secret and token_secret for validation, and the
+    #   signature_method the header must use, which a later major version will require
     # @return [Boolean] true if the signature is valid, false otherwise
+    # @raise [ArgumentError] if the expected signature method is not registered
     # @note When the header was built with a body, the signed oauth_body_hash must match that body,
     #   so a tampered body fails verification even though its signature covers the claimed hash
     # @example
     #   parsed_header = SimpleOAuth::Header.new(:get, url, {}, authorization_header)
-    #   parsed_header.valid?(consumer_secret: "secret", token_secret: "token_secret")
+    #   parsed_header.valid?(consumer_secret: "secret", token_secret: "token_secret",
+    #     signature_method: "HMAC-SHA1")
     #   # => true
     def valid?(secrets = {})
-      body_hash_valid? && Signature.verify(options.fetch(:signature_method), signing_key(options.merge(secrets)),
-        signature_base, options.fetch(:signature))
+      verifying = options.merge(secrets)
+      expected = secrets[:signature_method]
+      signature_method_acceptable?(verifying, expected) && body_hash_valid? && signature_valid?(verifying, expected)
     end
 
     # Returns the OAuth attributes including the signature
@@ -215,6 +231,28 @@ module SimpleOAuth
       Signature.rsa?(options.fetch(:signature_method)) ? options[:consumer_secret] : secret(options)
     end
 
+    # Verifies the signature with the method the header claims
+    #
+    # A header that claims an RSA method, with no signature_method named, is verified without first
+    # parsing the key to check that it is an RSA key, so the key is parsed once rather than twice. The verifier
+    # raises PKeyError only for a key that is not an RSA key, which makes the header not valid, as
+    # the key does not fit the method. A verifier that names a method keeps the error, since naming
+    # an RSA method with another key is a mistake to report.
+    #
+    # @api private
+    # @param verifying [Hash] the header's options merged with the verifier's secrets
+    # @param expected [String, nil] the signature method the verifier expects, if it names one
+    # @return [Boolean] true if the signature is valid
+    # @raise [OpenSSL::PKey::PKeyError] if the verifier names an RSA method with a key that is not an RSA key
+    def signature_valid?(verifying, expected)
+      Signature.verify(options.fetch(:signature_method), signing_key(verifying), signature_base,
+        options.fetch(:signature))
+    rescue OpenSSL::PKey::PKeyError
+      raise if expected
+
+      false
+    end
+
     # Checks the body against the oauth_body_hash the header carries
     #
     # A header parsed from a request claims a body hash that its signature covers, so the claim must be

data/lib/simple_oauth/version.rb

@@ -1,5 +1,5 @@
 # OAuth 1.0 header generation library
 module SimpleOauth
   # The current version of the SimpleOAuth gem
-  VERSION = "0.5.1".freeze
+  VERSION = "0.5.3".freeze
 end

data/sig/simple_oauth/header/verification.rbs

@@ -0,0 +1,28 @@
+module SimpleOAuth
+  class Header
+    # What the Verification module needs from the header that includes it
+    interface _Verifiable
+      def options: () -> Header::oauth_options
+    end
+
+    # Checks of the signature method a received header claims, before it is verified with it
+    module Verification : _Verifiable
+      # The first byte of a key in DER, which encodes every key as an ASN.1 SEQUENCE
+      ASN1_SEQUENCE: Integer
+
+      # The start of the line that opens every key in PEM
+      PEM_BOUNDARY: String
+
+      private
+
+      # Checks that the header claims a signature method the verifier accepts
+      def signature_method_acceptable?: (Header::oauth_options verifying, String? expected) -> bool
+      # Checks that the header claims the signature method the verifier names
+      def expected_signature_method?: (String claimed, String expected) -> bool
+      # Checks whether a verifying key is encoded as a key could be
+      def key_encoded?: (String key) -> bool
+      # Checks whether a verifying key is an RSA key
+      def rsa_key?: (String key) -> bool
+    end
+  end
+end

data/sig/simple_oauth.rbs

@@ -58,6 +58,11 @@ module SimpleOAuth
     # Valid keys when parsing OAuth parameters (ATTRIBUTE_KEYS + signature)
     PARSE_KEYS: Array[Symbol]
 
+    # The signature method that sends the secrets themselves, which verifying accepts only when named
+    PLAINTEXT_SIGNATURE_METHOD: String
+
+
+
     # What from_request needs from a request object, such as a Net::HTTPRequest
     interface _Request
       def method: () -> String
@@ -91,6 +96,9 @@ module SimpleOAuth
     # Parameter and attribute normalization from the Params module
     include Params
 
+    # Checks of the signature method a received header claims
+    include Verification
+
     # Class methods from ClassMethods module
     extend ClassMethods
 
@@ -144,6 +152,9 @@ module SimpleOAuth
     # The key for signing and verifying
     def signing_key: (oauth_options options) -> String?
 
+    # Verifies the signature with the method the header claims
+    def signature_valid?: (oauth_options verifying, String? expected) -> bool
+
     # Checks the body against the oauth_body_hash the header carries
     def body_hash_valid?: () -> bool
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_oauth
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Steve Richert
@@ -60,6 +60,7 @@ files:
 - lib/simple_oauth/header.rb
 - lib/simple_oauth/header/class_methods.rb
 - lib/simple_oauth/header/params.rb
+- lib/simple_oauth/header/verification.rb
 - lib/simple_oauth/parser.rb
 - lib/simple_oauth/signature.rb
 - lib/simple_oauth/version.rb
@@ -69,6 +70,7 @@ files:
 - sig/simple_oauth.rbs
 - sig/simple_oauth/header/class_methods.rbs
 - sig/simple_oauth/header/params.rbs
+- sig/simple_oauth/header/verification.rbs
 - sig/simple_oauth/parser.rbs
 - sig/simple_oauth/signature.rbs
 - sig/strscan.rbs
@@ -95,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 4.0.24
 specification_version: 4
 summary: Simply builds and verifies OAuth headers
 test_files: []