mailblastr 5.0.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53c08e2365d3814e563987d9625310f3cf42ed6d8aa5f1869b1603472dc72318
-  data.tar.gz: 0f0f31d046c3e508ed8a6812f79c1f8c502ec1354f7ac3885636bd4e8c5e9eb3
+  metadata.gz: ec78acb7d963058af8b922481262fcf7b3c1d6692876f304bdd373572b7a25b9
+  data.tar.gz: 29f2b545a15086968ad83e8f6e687868d9d4c575e292839852c540a797897d1d
 SHA512:
-  metadata.gz: 1e0eb93701e40a42117102a427d80b7d3003669515e31d3f58d96ad46680993a9989e98e205227d434e7227a7fead48e16e2bc541491920fe30104177fab8059
-  data.tar.gz: 219ab57ee04faaf8817f98711a46887b87686c40df79189fd3b75d9076f804bcf579d76a3b126d21d714f329453936fcf548733c00a1636d0f30d1f6c2e31a84
+  metadata.gz: d3d399fe4c0db84908d49c0aa590dadc869ef661dabf0a9b3efea01ca106ec4a36bb5050d1ac760e5bd875ebaa85117750b9d8df8607f069a303391bc4763402
+  data.tar.gz: 8be077ef5c686252a518edf896002f48af3e6ac07450b1fbd3f18cf3fdf252cb05b05d186e502d342b8a00a8e40d67ec2ee9fca11fc74889527720810d61dbfa

data/lib/mailblastr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mailblastr
-  VERSION = "5.0.0"
+  VERSION = "5.0.1"
 end

data/lib/mailblastr/webhooks.rb

@@ -149,25 +149,104 @@ module Mailblastr
         nil
       end
 
-      # Derive the HMAC key from a `whsec_`-prefixed secret (base64-decode the
-      # suffix); a secret without the prefix is used as raw UTF-8 bytes.
+      # Derive the HMAC key from a `whsec_`-prefixed secret the way the SIGNER
+      # does, byte for byte. The signer is Node: base64-decode the suffix with
+      # `Buffer.from(suffix, 'base64')` and, when that yields ZERO bytes, fall
+      # back to the UTF-8 bytes of the WHOLE secret — `whsec_` prefix INCLUDED
+      # (mailblastr_webapp/lib/crypto.ts secretToKey). A secret without the
+      # prefix is used as raw UTF-8 bytes.
       #
-      # `tr` FIRST: the signer decodes with Node's Buffer.from(suffix, 'base64')
-      # (lib/crypto.ts secretToKey), which reads "-"/"_" as the URL-safe
-      # spellings of "+"/"/". `unpack1("m")` tolerates missing padding but
-      # DROPS those two characters instead of translating them, yielding a
-      # SHORTER, different key than the signer derived — so a caller-supplied
-      # URL-safe secret (POST /webhooks accepts `secret` verbatim, unvalidated)
-      # made every genuinely signed delivery come back `no_match`. Standard,
-      # padded and unpadded suffixes are unaffected by the `tr`, which is why
-      # the failure looked arbitrary and secret-specific.
+      # The zero-byte fallback is not a curiosity: POST /webhooks stores
+      # `secret` verbatim with no shape validation, so "whsec_", "whsec_=",
+      # "whsec_!!!!" and "whsec_=YWJj" are all secrets a customer can really
+      # create, and each one keys the HMAC with its own literal text. Keying
+      # with an empty string instead — the obvious reading of "decode, then
+      # use the result" — costs the whole endpoint silently, because a key
+      # that differs from the signer's does not fail loudly: verify answers
+      # `no_match` and a correctly configured endpoint treats every genuine
+      # delivery as forged.
       def secret_to_key(secret)
         s = secret.to_s
-        if s.start_with?("whsec_")
-          decoded = s["whsec_".length..].tr("-_", "+/").unpack1("m")
-          return decoded if decoded && !decoded.empty?
-        end
-        s
+        return s unless s.start_with?("whsec_")
+
+        decoded = node_base64_decode(s["whsec_".length..])
+        decoded.empty? ? s : decoded
+      end
+
+      # Node's `Buffer.from(str, 'base64')`, reproduced. Every rule here was
+      # read off Node itself, NOT off a base64 RFC — following the RFC is
+      # precisely how this shipped broken twice — and each one costs a real
+      # key when Ruby's own decoder is trusted instead:
+      #
+      #   * "=" TERMINATES the input. Everything from the first one onward is
+      #     DISCARDED; it is not "padding to be stripped". "YWJj====ZA" is
+      #     "abc", NOT "abcd", and a leading "=" leaves nothing at all (so the
+      #     caller's raw fallback takes over). `unpack1("m")` decodes straight
+      #     past an interior "=", deriving a LONGER key than the signer's.
+      #   * "-" and "_" are the URL-safe spellings of "+" and "/" and must be
+      #     TRANSLATED. `unpack1("m")` silently DROPS them, shortening the key.
+      #   * Any other out-of-alphabet byte is SKIPPED, never fatal: whitespace,
+      #     punctuation and non-ASCII are ignored, so "YW!Jj" is "abc".
+      #   * A trailing group of ONE character carries no whole byte, so it is
+      #     dropped here rather than left to `unpack1`'s discretion (2 chars ->
+      #     1 byte, 3 -> 2, 4 -> 3).
+      #   * The unit Node indexes the alphabet with is the LOW 8 BITS OF EACH
+      #     UTF-16 CODE UNIT, applied FIRST — see `utf16_low_bytes` below.
+      #
+      # Bytes, not characters, from the mask onward: a caller's secret need not
+      # be valid UTF-8, and an Encoding::CompatibilityError escaping this method
+      # would turn a webhook controller's 401 into a 500.
+      def node_base64_decode(suffix)
+        # Rule 5 runs BEFORE the "=" split, not after: U+013D masks to 0x3D and
+        # must TERMINATE the input like a literal "=" — splitting on the
+        # unmasked text would decode straight past it and derive a longer key.
+        s = utf16_low_bytes(suffix)
+        terminator = s.index("=")
+        s = s[0, terminator] if terminator
+
+        chars = s.tr("-_", "+/").gsub(%r{[^A-Za-z0-9+/]}n, "")
+        chars = chars[0, chars.bytesize - 1] if (chars.bytesize % 4) == 1
+        return "" if chars.empty?
+
+        chars.unpack1("m") || ""
+      end
+
+      # Rule 5, the one no SDK had: Node masks every UTF-16 CODE UNIT with 0xFF
+      # before the base64 table lookup, so the alphabet is indexed by a code
+      # unit's low byte, NOT by the codepoint and NOT by the UTF-8 bytes.
+      #
+      # Ruby strings are UTF-8, so the code units have to be materialised first:
+      # "Ł" (U+0141) is two UTF-8 bytes but ONE code unit masking to 0x41 "A",
+      # and "𝑁" (U+1D441) is ASTRAL — its four UTF-8 bytes are Node's TWO
+      # surrogate halves 0xD835/0xDC41, masking to 0x35 "5" and 0x41 "A". Taking
+      # UTF-8 bytes instead feeds the decoder continuation bytes that are all
+      # out-of-alphabet, silently shortening the key.
+      #
+      # Every codepoint below 0x100 masks to itself and every one at or above it
+      # is a different character entirely, so nothing under 0x100 can expose
+      # this — which is exactly why it survived a 31-vector corpus and a
+      # 2000-case ASCII fuzz, and why the cost lands only on the customer whose
+      # secret happens to carry a "Ł", a fullwidth letter or an emoji: their
+      # endpoint answers `no_match` to every genuine delivery.
+      #
+      # Undecodable input never raises out of here: invalid bytes become U+FFFD,
+      # whose low byte 0xFD is out of alphabet and therefore skipped — the same
+      # answer the old byte-wise reader gave — and a total conversion failure
+      # falls back to the raw bytes rather than 500-ing a webhook controller.
+      def utf16_low_bytes(str)
+        s = str.to_s
+        s = s.dup.force_encoding(Encoding::UTF_8) if s.encoding == Encoding::BINARY
+        s.encode(Encoding::UTF_16LE, invalid: :replace, undef: :replace)
+         .b.unpack("v*").map { |unit| unit & 0xFF }.pack("C*")
+      rescue StandardError
+        # Unreachable in practice: invalid:/undef: :replace make the encode total
+        # for any String. Kept so a webhook controller cannot 500 on a pathological
+        # input -- but it must NOT return str.b. Those are the raw UTF-8 bytes,
+        # which is exactly the pre-5.0.1 behaviour this method exists to replace,
+        # and returning them would silently derive a WRONG key that verifies
+        # nothing. Empty routes to the documented whole-secret fallback instead:
+        # still a mismatch, but a defined one rather than a reinstated bug.
+        ""
       end
 
       # Constant-time compare of two signature strings.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mailblastr
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.0.1
 platform: ruby
 authors:
 - MailBlastr
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-19 00:00:00.000000000 Z
+date: 2026-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest