simple_oauth 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 680161f3f3fc8cf54f78c5111c1f0c4bcd6380b0d29022fb9ac5fd407805d8b7
-  data.tar.gz: 6951095c0b1b04b7755e8857a977946825053a141e3fd4c1c3b7e10cade061fe
+  metadata.gz: 88c89c6dff93b31b6279da0d85c0b719cc94bac966356ae1783702ed3cbfe8e5
+  data.tar.gz: 1febe046539f65e64a5b3d6b787282e5ce91178bf1617f97ce6a08a5a159318e
 SHA512:
-  metadata.gz: f852606e3aa48e70a5856f0cfccbfafe4c9235a6a701faca692446186b5bf8f30781b316577b7ac15a164b07293f9b550ad5cdfe0db58df6e57be396de380cf6
-  data.tar.gz: d938005d0ad30817b294e0e8143b272be0dafb794dfa4a57ee012fc8f162c7d895d85a5a2ae0a57f4bc3b9e50c372fde93ac22b31bc01579ead3deec968f2d2a
+  metadata.gz: 1f2b608cbf969b4983f29c746a5e892b0d5b1d321a6e044b8c01f645be8733aade948f5410a0654a6ece51778050cdb5a846e7ca02d70c1bd53cdf4d943aab8d
+  data.tar.gz: 5c76e78b8b537367e00833e063f9a23bacd5e8ea00563e5e41536e0ee223f4c257032001411059380a6f3b39ab883e5253304a12e59eba2da4d88d6ebe130af7

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [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.rb

@@ -23,6 +23,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
 
@@ -122,18 +125,30 @@ 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)
+      signature_method_acceptable?(verifying, secrets[:signature_method]) && body_hash_valid? &&
+        Signature.verify(options.fetch(:signature_method), signing_key(verifying), signature_base,
+          options.fetch(:signature))
     end
 
     # Returns the OAuth attributes including the signature
@@ -215,6 +230,50 @@ module SimpleOAuth
       Signature.rsa?(options.fetch(:signature_method)) ? options[:consumer_secret] : secret(options)
     end
 
+    # 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)
+      Signature.registered?(claimed) && !PLAINTEXT_SIGNATURE_METHOD.casecmp?(claimed) &&
+        Signature.rsa?(claimed).eql?(rsa_key?(verifying[:consumer_secret]))
+    end
+
+    # Checks that the header claims the signature method the verifier names
+    #
+    # Signature method names are compared without regard to case, as the registry looks them up.
+    #
+    # @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)
+      raise ArgumentError, "Unknown signature method: #{expected}" unless Signature.registered?(expected)
+
+      claimed.casecmp?(expected)
+    end
+
+    # Checks whether a verifying key is an RSA key
+    #
+    # @api private
+    # @param key [String, nil] the consumer_secret the verifier gave
+    # @return [Boolean] true if the key parses as an RSA key
+    def rsa_key?(key)
+      OpenSSL::PKey::RSA.new(key.to_s)
+      true
+    rescue OpenSSL::PKey::PKeyError
+      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.2".freeze
 end

data/sig/simple_oauth.rbs

@@ -58,6 +58,9 @@ 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
@@ -144,6 +147,15 @@ module SimpleOAuth
     # The key for signing and verifying
     def signing_key: (oauth_options options) -> String?
 
+    # Checks that the header claims a signature method the verifier accepts
+    def signature_method_acceptable?: (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 an RSA key
+    def rsa_key?: (String? key) -> 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.2
 platform: ruby
 authors:
 - Steve Richert
@@ -95,7 +95,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: []