simple_oauth 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48873a9ac8c602b3dc3d305445c3e44524eee89e876e53222928fdf17902b22b
-  data.tar.gz: 166bcb795c1b953adf9c9dfaea2d6c69d8f00ba1bbc2953706ea9e7cca3fa87a
+  metadata.gz: ed41a0a0f5917e46e47d2fc785730f9c194a0541af8199b46a4928405000f110
+  data.tar.gz: 34d5043273278eb6571534259ee8628268c851d468462e6a25806402ce2afd83
 SHA512:
-  metadata.gz: 377164f7799c7e6f330b2ac80fcf144380c270e6a65c40b6fb272e1fca6fd9a52515161f7237a96a3fefd9d6efd03000fd675141fc52f6330fe4daeabd6ee854
-  data.tar.gz: 6585353e86aa82b24cb3d08dc41e5ec12162b5866b2e35b25832a1603114cb1472f6323ab503be5ff47d69eedddff63ff136e1726e7e0672b677aaa681a22a52
+  metadata.gz: eca0708e81fc8a823e7c5c3e87b48003bce4f6da9ac16d9c8fc0f6a5a45003261ecfaae9bf787e54f5f46b89acdaaf2c1719ad9ba9ac52c4523aaf201cd1aaac
+  data.tar.gz: ba7096154201bf4a19cfa3c34e5cf92a5c566e46165be3d1bf9632bbeb28bcd78b891b07a6743d631140a18a1d3bd7170176d65585af3da0f455a01a06236479

data/.rubocop.yml

@@ -7,8 +7,14 @@ plugins:
   - rubocop-performance
   - rubocop-rake
 
+inherit_mode:
+  merge:
+    - Include
+
 AllCops:
   NewCops: enable
+  Include:
+    - .duel.rb
   TargetRubyVersion: 3.2
 
 Layout/ArgumentAlignment:

data/CHANGELOG.md

@@ -1,103 +1,156 @@
-## [1.0.1] - 2026-09-30
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/2.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.3] - 2026-11-14
 
 ### Fixed
 
-* Ship RBS signatures that leave core and the standard library alone: the gem no longer redeclares `MatchData#[]`, `OpenSSL.secure_compare`, `OpenSSL::PKey::PKey#sign` and `#verify`, or `StringScanner`, so code that loads its signatures through `rbs collection` no longer fails `rbs validate` with a duplicated `MatchData#[]` definition
-* Add `sig/manifest.yaml`, naming the standard libraries the signatures refer to (`json`, `openssl`, `securerandom`, `strscan`, and `uri`), so `rbs collection` loads them for code that depends on the gem
+- Verify as fast as 1.0.1 when `Header#valid?` is not given a `signature_method`. 1.0.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
 
-## [1.0.0] - 2026-09-12
+## [0.5.3] - 2026-11-14
 
-### Changed
+### 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
+
+## [1.0.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.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`
 
-* Every file declares `frozen_string_literal: true`, and the explicit `freeze` calls on string literals it makes redundant are gone
-* Drop the `base64` runtime dependency: `pack("m0")` and `unpack1("m")` encode and decode Base64 in core Ruby, so the gem now has no runtime dependencies at all
-* Drop the `cgi` runtime dependency: query strings and form bodies are read with `URI.decode_www_form`, which Ruby ships in every supported version
-* **Breaking**: raise `ParseError` when an Authorization header, form body, or query string repeats an OAuth protocol parameter, which RFC 5849 Section 3.2 does not allow; `Header.parse` previously kept the last value and `Header.parse_form_body` the first, so the two disagreed about which one a request carried
-* **Breaking**: rename `Signature.methods` to `Signature.registered_methods`, so that `Signature.methods` is the module's own method list again
-* **Breaking**: define `VERSION` in `SimpleOAuth`, the module the rest of the library uses, rather than in a second `SimpleOauth` module; `SimpleOauth::VERSION` is gone and `SimpleOAuth::VERSION` now resolves
-* **Breaking**: `Signature.rsa?` raises `ArgumentError` for a signature method that is not registered, as `Signature.digest`, `sign`, and `verify` already do, rather than answering false
-* `SimpleOAuth::Error` is the base of every error the library raises, so `rescue SimpleOAuth::Error` catches `ParseError`, `InvalidOptionsError`, and `OAuth2::Error` alike
+### Deprecated
+
+- Calling `Header#valid?` without a `signature_method`, which a later major version will require
+
+## [1.0.1] - 2026-09-30
 
 ### Fixed
 
-* Treat only `&` as a parameter separator when reading a query string or form body; a `;` is part of the value, as every current server reads it, so `?a=1;b=2` no longer signs two parameters where the server sees one
+- Ship RBS signatures that leave core and the standard library alone: the gem no longer redeclares `MatchData#[]`, `OpenSSL.secure_compare`, `OpenSSL::PKey::PKey#sign` and `#verify`, or `StringScanner`, so code that loads its signatures through `rbs collection` no longer fails `rbs validate` with a duplicated `MatchData#[]` definition
+- Add `sig/manifest.yaml`, naming the standard libraries the signatures refer to (`json`, `openssl`, `securerandom`, `strscan`, and `uri`), so `rbs collection` loads them for code that depends on the gem
+
+## [1.0.0] - 2026-09-12
 
 ### Added
 
-* OAuth 2.0 request builders and response parsers in `SimpleOAuth::OAuth2`, which make no HTTP requests:
-  * `Client#authorization_url` for the authorization code flow, which names `pkce` so that a client either sends a challenge or says `pkce: nil`, as OAuth 2.1 asks every client for one; a `state` is optional alongside a challenge, and required without one
-  * `Client#authorization_code_request`, `#refresh_token_request`, and `#client_credentials_request` for the token endpoint
-  * `Client#revocation_request` for the revocation endpoint (RFC 7009)
-  * `client_secret_basic` and `client_secret_post` authentication for confidential clients, and public clients without a secret
-  * `PKCE` verifiers with `S256` and `plain` challenges (RFC 7636)
-  * `AuthorizationResponse.parse`, which reads the response an authorization server returns to the redirect URI: it raises the error the server reported, a `state` that is not the one the request sent, an `iss` that is not the expected issuer (RFC 9207), a repeated parameter, or a response with no code
-  * A `params` option on every request builder, for what an extension adds to a request, such as the resource indicator of RFC 8707
-  * `Token.from_response` and `Error.from_response` for token and error responses, rejecting a response whose access token is missing, null, or empty, or whose lifetime is not a number of seconds
+- OAuth 2.0 request builders and response parsers in `SimpleOAuth::OAuth2`, which make no HTTP requests:
+  - `Client#authorization_url` for the authorization code flow, which names `pkce` so that a client either sends a challenge or says `pkce: nil`, as OAuth 2.1 asks every client for one; a `state` is optional alongside a challenge, and required without one
+  - `Client#authorization_code_request`, `#refresh_token_request`, and `#client_credentials_request` for the token endpoint
+  - `Client#revocation_request` for the revocation endpoint (RFC 7009)
+  - `client_secret_basic` and `client_secret_post` authentication for confidential clients, and public clients without a secret
+  - `PKCE` verifiers with `S256` and `plain` challenges (RFC 7636)
+  - `AuthorizationResponse.parse`, which reads the response an authorization server returns to the redirect URI: it raises the error the server reported, a `state` that is not the one the request sent, an `iss` that is not the expected issuer (RFC 9207), a repeated parameter, or a response with no code
+  - A `params` option on every request builder, for what an extension adds to a request, such as the resource indicator of RFC 8707
+  - `Token.from_response` and `Error.from_response` for token and error responses, rejecting a response whose access token is missing, null, or empty, or whose lifetime is not a number of seconds
+
+### Changed
+
+- Every file declares `frozen_string_literal: true`, and the explicit `freeze` calls on string literals it makes redundant are gone
+- Drop the `base64` runtime dependency: `pack("m0")` and `unpack1("m")` encode and decode Base64 in core Ruby, so the gem now has no runtime dependencies at all
+- Drop the `cgi` runtime dependency: query strings and form bodies are read with `URI.decode_www_form`, which Ruby ships in every supported version
+- **Breaking:** Raise `ParseError` when an Authorization header, form body, or query string repeats an OAuth protocol parameter, which RFC 5849 Section 3.2 does not allow; `Header.parse` previously kept the last value and `Header.parse_form_body` the first, so the two disagreed about which one a request carried
+- **Breaking:** Rename `Signature.methods` to `Signature.registered_methods`, so that `Signature.methods` is the module's own method list again
+- **Breaking:** Define `VERSION` in `SimpleOAuth`, the module the rest of the library uses, rather than in a second `SimpleOauth` module; `SimpleOauth::VERSION` is gone and `SimpleOAuth::VERSION` now resolves
+- **Breaking:** `Signature.rsa?` raises `ArgumentError` for a signature method that is not registered, as `Signature.digest`, `sign`, and `verify` already do, rather than answering false
+- `SimpleOAuth::Error` is the base of every error the library raises, so `rescue SimpleOAuth::Error` catches `ParseError`, `InvalidOptionsError`, and `OAuth2::Error` alike
+
+### Fixed
+
+- Treat only `&` as a parameter separator when reading a query string or form body; a `;` is part of the value, as every current server reads it, so `?a=1;b=2` no longer signs two parameters where the server sees one
 
 ## [0.5.1] - 2026-09-12
 
 ### Fixed
 
-* Build the signature base string with a String conversion that every supported Ruby offers; `Header#url` called `URI::Generic#to_str`, which arrived in `uri` 0.13, so it raised `NoMethodError` on a stock Ruby 3.2, the oldest version the gem claims to support
-* Sign a parameter that carries no value, such as a bare `?flag` in the query string or the `c2` of the RFC 5849 Section 3.4.1.3.1 example, as `name=` rather than dropping it from the signature base string; a request carrying one signed differently than the server computes, so it was rejected
+- Build the signature base string with a String conversion that every supported Ruby offers; `Header#url` called `URI::Generic#to_str`, which arrived in `uri` 0.13, so it raised `NoMethodError` on a stock Ruby 3.2, the oldest version the gem claims to support
+- Sign a parameter that carries no value, such as a bare `?flag` in the query string or the `c2` of the RFC 5849 Section 3.4.1.3.1 example, as `name=` rather than dropping it from the signature base string; a request carrying one signed differently than the server computes, so it was rejected
 
 ## [0.5.0] - 2026-09-12
 
 ### Added
 
-* `Header.from_request`, which builds a header for a request object such as a `Net::HTTPRequest`, signing its query parameters, its form-encoded body, or hashing any other body
-* `Header.parse_query`, for OAuth credentials sent in a query string
-* `Signature.digest`, and a `digest:` option on `Signature.register`, which gives the hash algorithm a signature method signs with
-* `Signature.verify` and a `verify:` option on `Signature.register`, for signature methods that cannot be verified by recomputing the signature
-* `Signature.decode_base64`
+- `Header.from_request`, which builds a header for a request object such as a `Net::HTTPRequest`, signing its query parameters, its form-encoded body, or hashing any other body
+- `Header.parse_query`, for OAuth credentials sent in a query string
+- `Signature.digest`, and a `digest:` option on `Signature.register`, which gives the hash algorithm a signature method signs with
+- `Signature.verify` and a `verify:` option on `Signature.register`, for signature methods that cannot be verified by recomputing the signature
+- `Signature.decode_base64`
 
 ### Fixed
 
-* Check `oauth_body_hash` against the body a header was built with when verifying, so a body changed after signing no longer verifies against the hash its signature covers
-* Verify signatures without merging the given secrets into the header's own options, where anything else reading the header could see them
-* Compare signatures in constant time when verifying
-* Compute `oauth_body_hash` with the hash algorithm of the signature method, such as SHA-256 for HMAC-SHA256; it was always SHA-1
-* Sign a parameter whose value is an Array as one parameter per value, as a repeated parameter; the Array was previously signed as its Ruby representation
-* Verify RSA signatures with the signer's public key, which is all a verifier has; `Header#valid?` previously recomputed the signature and so needed the private key
-* Match the form-encoded media type exactly when signing a body, rather than by prefix, so a media type such as `application/x-www-form-urlencoded-json` is hashed instead of signed as parameters, and `Application/X-WWW-Form-Urlencoded` is recognized
+- Check `oauth_body_hash` against the body a header was built with when verifying, so a body changed after signing no longer verifies against the hash its signature covers
+- Verify signatures without merging the given secrets into the header's own options, where anything else reading the header could see them
+- Compare signatures in constant time when verifying
+- Compute `oauth_body_hash` with the hash algorithm of the signature method, such as SHA-256 for HMAC-SHA256; it was always SHA-1
+- Sign a parameter whose value is an Array as one parameter per value, as a repeated parameter; the Array was previously signed as its Ruby representation
+- Verify RSA signatures with the signer's public key, which is all a verifier has; `Header#valid?` previously recomputed the signature and so needed the private key
+- Match the form-encoded media type exactly when signing a body, rather than by prefix, so a media type such as `application/x-www-form-urlencoded-json` is hashed instead of signed as parameters, and `Application/X-WWW-Form-Urlencoded` is recognized
 
 ## [0.4.2] - 2026-09-12
 
 ### Added
 
-* Document passing `Header` parameters as an Array of key-value pairs when a key repeats
+- Document passing `Header` parameters as an Array of key-value pairs when a key repeats
 
 ### Fixed
 
-* Accept an Array of key-value pairs as `Header` parameters in the RBS signatures, which already worked at runtime
+- Accept an Array of key-value pairs as `Header` parameters in the RBS signatures, which already worked at runtime
 
 ## [0.4.1] - 2026-04-20
 
 ### Fixed
 
-* Remove `URI::RFC2396_PARSER` stub from RBS signatures to avoid duplicate declaration error with RBS 4.0.2, which now ships the constant in its stdlib `uri` signatures
+- Remove `URI::RFC2396_PARSER` stub from RBS signatures to avoid duplicate declaration error with RBS 4.0.2, which now ships the constant in its stdlib `uri` signatures
 
 ## [0.4.0] - 2026-02-01
 
 ### Added
 
-* Extensible signature method registry allowing custom signature methods to be registered at runtime
-* Support for RSA-SHA256 and HMAC-SHA256 signature methods
-* OAuth Request Body Hash support (`oauth_body_hash` parameter) for signing requests with non-form-encoded bodies
-* Support for parsing OAuth credentials from POST body via `Header.parse_form_body`
-* Support for `realm` parameter in OAuth Authorization header
-
-### Fixed
-
-* Avoid symbolizing untrusted input in parse methods for security
-* Refactored `Header.parse` for improved robustness using StringScanner
+- Extensible signature method registry allowing custom signature methods to be registered at runtime
+- Support for RSA-SHA256 and HMAC-SHA256 signature methods
+- OAuth Request Body Hash support (`oauth_body_hash` parameter) for signing requests with non-form-encoded bodies
+- Support for parsing OAuth credentials from POST body via `Header.parse_form_body`
+- Support for `realm` parameter in OAuth Authorization header
 
 ### Changed
 
-* **Breaking**: `Signature.rsa?` raises `ArgumentError` for a signature method that is not registered, as `Signature.digest`, `sign`, and `verify` already do, rather than answering false
-* `SimpleOAuth::Error` is the base of every error the library raises, so `rescue SimpleOAuth::Error` catches `ParseError`, `InvalidOptionsError`, and `OAuth2::Error` alike
+- **Breaking:** Require Ruby 3.2 or later; supports Ruby 3.2, 3.3, 3.4, and 4.0
+- Added `base64` and `cgi` as explicit runtime dependencies
+- Migrated test suite from RSpec to Minitest
 
-* Supports Ruby 3.2, 3.3, 3.4, and 4.0
-* Added `base64` and `cgi` as explicit runtime dependencies
-* Migrated test suite from RSpec to Minitest
+### Fixed
 
+- Avoid symbolizing untrusted input in parse methods for security
+- Refactored `Header.parse` for improved robustness using StringScanner
+
+[1.0.3]: https://github.com/laserlemon/simple_oauth/compare/v1.0.2...v1.0.3
+[0.5.3]: https://github.com/laserlemon/simple_oauth/compare/v0.5.2...v0.5.3
+[1.0.2]: https://github.com/laserlemon/simple_oauth/compare/v1.0.1...v1.0.2
+[0.5.2]: https://github.com/laserlemon/simple_oauth/compare/v0.5.1...v0.5.2
+[1.0.1]: https://github.com/laserlemon/simple_oauth/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/laserlemon/simple_oauth/compare/v0.5.1...v1.0.0
+[0.5.1]: https://github.com/laserlemon/simple_oauth/compare/v0.5.0...v0.5.1
+[0.5.0]: https://github.com/laserlemon/simple_oauth/compare/v0.4.2...v0.5.0
+[0.4.2]: https://github.com/laserlemon/simple_oauth/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/laserlemon/simple_oauth/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/laserlemon/simple_oauth/compare/v0.3.1...v0.4.0

data/README.md

@@ -6,6 +6,7 @@
 [![Lint](https://github.com/laserlemon/simple_oauth/actions/workflows/lint.yml/badge.svg)](https://github.com/laserlemon/simple_oauth/actions/workflows/lint.yml)
 [![Typecheck](https://github.com/laserlemon/simple_oauth/actions/workflows/typecheck.yml/badge.svg)](https://github.com/laserlemon/simple_oauth/actions/workflows/typecheck.yml)
 [![Yardstick](https://github.com/laserlemon/simple_oauth/actions/workflows/yardstick.yml/badge.svg)](https://github.com/laserlemon/simple_oauth/actions/workflows/yardstick.yml)
+[![Duel](https://raw.githubusercontent.com/laserlemon/simple_oauth/duel/badge/badge.svg)](https://github.com/sferik/duel-ruby)
 
 Simply builds and verifies OAuth 1.0 headers per [RFC 5849](https://tools.ietf.org/html/rfc5849), and builds OAuth 2.0 requests per [RFC 6749](https://www.rfc-editor.org/rfc/rfc6749), [RFC 7636](https://www.rfc-editor.org/rfc/rfc7636), and [RFC 7009](https://www.rfc-editor.org/rfc/rfc7009).
 
@@ -158,16 +159,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/Rakefile

@@ -41,3 +41,10 @@ task :steep do
 end
 
 task default: %i[test rubocop standard mutant yardstick steep]
+
+begin
+  require "duel/rake_task"
+  Duel::RakeTask.new
+rescue LoadError
+  # Duel requires Ruby 3.4 or later
+end

data/lib/simple_oauth/header/verification.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+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"
+
+      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

@@ -7,6 +7,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
@@ -24,6 +25,9 @@ module SimpleOAuth
     # Default signature method per RFC 5849
     DEFAULT_SIGNATURE_METHOD = "HMAC-SHA1"
 
+    # The signature method that sends the secrets themselves, which verifying accepts only when named
+    PLAINTEXT_SIGNATURE_METHOD = "PLAINTEXT"
+
     # OAuth version
     OAUTH_VERSION = "1.0"
 
@@ -65,6 +69,7 @@ module SimpleOAuth
     attr_reader :options
 
     include Params
+    include Verification
 
     extend ClassMethods
     extend Encoding
@@ -123,18 +128,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
@@ -216,6 +232,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

@@ -3,5 +3,5 @@
 # OAuth 1.0 header generation library
 module SimpleOAuth
   # The current version of the SimpleOAuth gem
-  VERSION = "1.0.1"
+  VERSION = "1.0.3"
 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

@@ -62,6 +62,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
@@ -95,6 +100,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
 
@@ -148,6 +156,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: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Steve Richert
@@ -32,6 +32,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/oauth2.rb
 - lib/simple_oauth/oauth2/authorization_response.rb
 - lib/simple_oauth/oauth2/client.rb
@@ -43,11 +44,11 @@ files:
 - lib/simple_oauth/parser.rb
 - lib/simple_oauth/signature.rb
 - lib/simple_oauth/version.rb
-- mutant.yml
 - sig/manifest.yaml
 - 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/oauth2.rbs
 - sig/simple_oauth/parser.rbs
 - sig/simple_oauth/signature.rbs
@@ -74,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.22
+rubygems_version: 4.0.24
 specification_version: 4
 summary: Simply builds and verifies OAuth 1.0 headers and builds OAuth 2.0 requests
 test_files: []

data/mutant.yml

@@ -1,17 +0,0 @@
-usage: opensource
-integration:
-  name: minitest
-includes:
-  - lib
-  - test
-requires:
-  - simple_oauth
-mutation:
-  operators: full
-  timeout: 5.0
-matcher:
-  subjects:
-    - SimpleOAuth*
-coverage_criteria:
-  process_abort: true
-  test_result: true