From 189581d741ebfc6f4554e323210fd03e06890b24 Mon Sep 17 00:00:00 2001 From: tony1233200 Date: Fri, 20 Nov 2026 10:33:40 +0000 Subject: [PATCH] fix(signature): return False for malformed timestamp, signature or body in SignatureVerifier.is_valid MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes #2067: is_valid() raised instead of returning False for malformed inputs that arrive straight from request headers / body: - non-numeric timestamp ("abc") raised ValueError from int(timestamp) - non-ASCII signature ("v0=é") raised TypeError from hmac.compare_digest - non-UTF-8 bytes body raised UnicodeDecodeError from body.decode("utf-8") Each case now returns False, matching the existing contract for missing values (test_is_valid_none). Valid signatures still return True. Adds regression tests covering all three cases via is_valid() and is_valid_request(). --- slack_sdk/signature/__init__.py | 19 ++++++- .../signature/test_signature_verifier.py | 49 +++++++++++++++++++ 2 files changed, 66 insertions(+), 2 deletions(-) diff --git a/slack_sdk/signature/__init__.py b/slack_sdk/signature/__init__.py index 52cd7bcb5..68c5dff36 100644 --- a/slack_sdk/signature/__init__.py +++ b/slack_sdk/signature/__init__.py @@ -66,10 +66,25 @@ def is_valid( if timestamp is None or signature is None: return False - if abs(self.clock.now() - int(timestamp)) > 60 * 5: + try: + timestamp_value = int(timestamp) + except (TypeError, ValueError): + return False + if abs(self.clock.now() - timestamp_value) > 60 * 5: + return False + + # hmac.compare_digest() only accepts ASCII strings; a signature + # with non-ASCII characters can never match, so reject it here + # instead of letting compare_digest() raise TypeError. + if not isinstance(signature, str) or not signature.isascii(): return False - calculated_signature = self.generate_signature(timestamp=timestamp, body=body) + try: + calculated_signature = self.generate_signature(timestamp=timestamp, body=body) + except UnicodeDecodeError: + # A bytes body that is not valid UTF-8 can never match a + # signature computed over its decoded form. + return False if calculated_signature is None: return False return hmac.compare_digest(calculated_signature, signature) diff --git a/tests/slack_sdk/signature/test_signature_verifier.py b/tests/slack_sdk/signature/test_signature_verifier.py index 05a4de420..e960806e8 100644 --- a/tests/slack_sdk/signature/test_signature_verifier.py +++ b/tests/slack_sdk/signature/test_signature_verifier.py @@ -98,6 +98,55 @@ def test_is_valid_none(self): self.assertFalse(verifier.is_valid(self.body, None, None)) self.assertFalse(verifier.is_valid(None, None, None)) + def test_is_valid_malformed_timestamp(self): + verifier = SignatureVerifier( + signing_secret=self.signing_secret, + clock=MockClock(), + ) + self.assertFalse(verifier.is_valid(self.body, "abc", "v0=aa")) + self.assertFalse(verifier.is_valid(self.body, "1.5", "v0=aa")) + self.assertFalse(verifier.is_valid(self.body, "", "v0=aa")) + + def test_is_valid_malformed_signature(self): + verifier = SignatureVerifier( + signing_secret=self.signing_secret, + clock=MockClock(), + ) + self.assertFalse(verifier.is_valid(self.body, self.timestamp, "v0=é")) + self.assertFalse(verifier.is_valid(self.body, self.timestamp, "v0=✓")) + + def test_is_valid_malformed_body(self): + verifier = SignatureVerifier( + signing_secret=self.signing_secret, + clock=MockClock(), + ) + self.assertFalse(verifier.is_valid(b"\xff\xfe", self.timestamp, "v0=aa")) + self.assertFalse(verifier.is_valid(b"\x80\x81\x82", self.timestamp, "v0=aa")) + + def test_is_valid_request_malformed_inputs(self): + verifier = SignatureVerifier( + signing_secret=self.signing_secret, + clock=MockClock(), + ) + self.assertFalse( + verifier.is_valid_request( + self.body, + {"X-Slack-Request-Timestamp": "abc", "X-Slack-Signature": "v0=aa"}, + ) + ) + self.assertFalse( + verifier.is_valid_request( + self.body, + {"X-Slack-Request-Timestamp": self.timestamp, "X-Slack-Signature": "v0=é"}, + ) + ) + self.assertFalse( + verifier.is_valid_request( + b"\xff\xfe", + {"X-Slack-Request-Timestamp": self.timestamp, "X-Slack-Signature": "v0=aa"}, + ) + ) + def test_invalid_signing_secret(self): with self.assertRaises(ValueError): SignatureVerifier("")