Skip to content

[security] Webhook helpers decompress gzip bodies with no size limit before checking the signature (gzip bomb) #244

Open

Description

@aviadr1

I'm Claude Opus 5.5, AI can make mistakes. Written for a human user, who asked for this report.

Filed as a public issue tagged security, which SECURITY.md allows as an alternative to emailing security@getstream.io.

Summary

verify_and_parse_webhook decompresses a gzip body completely before it checks X-Signature. The order is forced: the HMAC covers the uncompressed JSON. But gunzip_payload has no limit on how much it decompresses, so anyone who can reach a webhook endpoint can make it use hundreds of MB to GBs of memory with a small unsigned request, a classic "gzip bomb". A webhook endpoint has to be public for Stream to reach it, and the signature check only fails after the memory is already used.

Affected code

The SQS and SNS parsers (parse_sqs / parse_sns, parseSqs / parseSns) use the same helper. Their input normally comes from a queue we control, so the exposure there is lower.

Reproduction (stream-chat 4.32.0, Python 3.14)

import tracemalloc, zlib
from stream_chat.webhook import verify_and_parse_webhook
from stream_chat.base.exceptions import InvalidWebhookError

def bomb(size: int) -> bytes:  # gzip of `size` zero bytes, built without holding `size` bytes
    d = zlib.compressobj(9, zlib.DEFLATED, 31)
    chunk = bytes(1 << 20)
    return b"".join([d.compress(chunk) for _ in range(size >> 20)] + [d.flush()])

body = bomb(256 << 20)   # 260,934 bytes on the wire
tracemalloc.start()
try:
    verify_and_parse_webhook(body, "not-a-signature", "secret")
except InvalidWebhookError as e:
    print(e)             # "signature mismatch", raised only after inflating
print(tracemalloc.get_traced_memory()[1] >> 20, "MB peak")   # 557 MB

A 255 KB unsigned request drives peak memory to ~558 MB before the signature is rejected. A ~1 MB request inflates to ~1 GB, and a handful of concurrent requests will run a typical container out of memory.

Suggested fix

Bound the output of decompression, and reject anything over the limit as an invalid webhook, so it can never succeed and costs at most the limit in memory:

  • Python: zlib.decompressobj(wbits=16 + zlib.MAX_WBITS).decompress(raw, max_length=LIMIT + 1). Treat output longer than LIMIT as an error, and check .eof (truncated stream) and .unused_data (trailing data).
  • Node: zlib.gunzipSync(body, { maxOutputLength: LIMIT }), which throws RangeError past the limit.
  • The limit: a default sized well above any real event, overridable by callers. Stream already caps SQS messages at 256 KB, which may be a natural default. The recorded real chat webhook events we hold are 7–18 KB.

Documenting the limit in the webhook docs' compression section would also help people who decompress in their own middleware.

Context

We hit this while adding gzip support to our webhook receiver. We decompress through a capped zlib.decompressobj there instead of the SDK helper, and would happily switch back once the helper is bounded.

Activity

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions