rabbitmq-amqp-python-client 2.0.0b1__tar.gz → 2.0.0b2__tar.gz

rabbitmq_amqp_python_client-2.0.0b2/AGENTS.md

@@ -0,0 +1,46 @@
+# AGENTS.md
+
+Guidance for AI coding agents working in this repository.
+
+## Project
+
+RabbitMQ AMQP 1.0 Python client (version 2.x), a native Python implementation
+with no dependency on `qpid-proton`. See `README.md` for install instructions
+and a quick-start example, and `README.md#project-layout` for how the code is
+organized (`wire/` is the protocol layer; `connection.py`, `session.py`,
+`link.py`, `management.py`, `publisher.py`, `consumer.py`, `reconnection.py`
+build the public API on top of it).
+
+## Setup
+
+```sh
+make install
+```
+
+## Common commands
+
+```sh
+make format           # ruff format, then ruff check --fix
+make lint             # ruff check and ruff format --check
+make typecheck        # mypy rabbitmq_amqp_python_client, in strict mode
+make test-unit        # the unit suite; no broker needed
+make test-integration # the integration suite; needs a broker on localhost:5672
+make test             # both suites
+```
+
+Run `make lint` and `make typecheck` before considering a change done.
+`make test-unit` needs no broker; `make test-integration` needs one running
+on `localhost:5672`.
+
+## Contributing
+
+Every contribution — bug fix or feature — must include one of the following:
+
+- A **failing test case** that reproduces the issue and passes once the fix
+  is applied (add it under `tests/unit` or `tests/integration`, matching the
+  existing style in that directory).
+- A **small, runnable example** that clearly reproduces the issue, in the
+  style of the scripts under `docs/examples/`.
+
+Do not open a change without one of these — it's how reviewers (human or
+agent) confirm the problem is real and that the fix actually addresses it.

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.5
 Name: rabbitmq-amqp-python-client
-Version: 2.0.0-beta.1
+Version: 2.0.0-beta.2
 Summary: A from-scratch AMQP 1.0 client for RabbitMQ, built directly against the wire protocol.
 Author: RabbitMQ Team
 License: Apache-2.0
 Requires-Python: >=3.10
 Provides-Extra: dev
+Requires-Dist: hypothesis>=6.100; extra == 'dev'
 Requires-Dist: mypy>=2.3.1; extra == 'dev'
 Requires-Dist: pika>=1.4.2; extra == 'dev'
 Requires-Dist: pytest-cov>=5.0; extra == 'dev'
@@ -18,6 +19,8 @@ Description-Content-Type: text/markdown
 
 RabbitMQ AMQP 1.0 Python client version 2.x for RabbitMQ 4.x.
 
+Client is tested and validated against RabbitMQ 4.3.0
+
 This client version built from scratch.</br> 
 The primary reason for this rewrite is to remove the dependency on the `qpid-proton` C library present in version 1.0, providing a fully native Python client, see [here](https://github.com/rabbitmq/rabbitmq-amqp-python-client/discussions/123). 
 This client is inspired by the Java and .NET AMQP 1.0 clients, aiming to deliver the same behavior and user experience across ecosystems.

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/README.md

@@ -2,6 +2,8 @@
 
 RabbitMQ AMQP 1.0 Python client version 2.x for RabbitMQ 4.x.
 
+Client is tested and validated against RabbitMQ 4.3.0
+
 This client version built from scratch.</br> 
 The primary reason for this rewrite is to remove the dependency on the `qpid-proton` C library present in version 1.0, providing a fully native Python client, see [here](https://github.com/rabbitmq/rabbitmq-amqp-python-client/discussions/123). 
 This client is inspired by the Java and .NET AMQP 1.0 clients, aiming to deliver the same behavior and user experience across ecosystems.

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rabbitmq-amqp-python-client"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.2"
 description = "A from-scratch AMQP 1.0 client for RabbitMQ, built directly against the wire protocol."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -16,6 +16,7 @@ dependencies = []
 dev = [
     "pytest>=9.1.1",
     "pytest-cov>=5.0",
+    "hypothesis>=6.100",
     "ruff>=0.16.5",
     "mypy>=2.3.1",
     "pika>=1.4.2",

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/rabbitmq_amqp_python_client/session.py

@@ -38,6 +38,11 @@ DEFAULT_WINDOW = 0x7FFFFFFF
 #: Highest link handle the spec allows.
 MAX_HANDLE = 0xFFFFFFFF
 
+#: Transfer-ids are 32-bit RFC-1982 serial numbers: a peer may start theirs at
+#: an arbitrary value (RabbitMQ deliberately starts near this boundary) and it
+#: wraps back to 0 rather than growing past it.
+TRANSFER_ID_MODULUS = 0x1_0000_0000
+
 DEFAULT_BEGIN_TIMEOUT_SECONDS = 5.0
 DEFAULT_END_TIMEOUT_SECONDS = 5.0
 
@@ -429,9 +434,16 @@ class Session:
 
     def _on_transfer(self, performative: Transfer, payload: bytes) -> None:
         with self._cond:
-            if performative.delivery_id is not None:
-                self._next_incoming_id = performative.delivery_id + 1
-                self._received_transfer = True
+            # ``delivery-id`` and the implicit transfer-id next-incoming-id
+            # tracks are independent counters that may start at different
+            # values (RabbitMQ starts the latter near the 32-bit boundary
+            # specifically to catch clients that conflate the two — see
+            # rabbit_amqp_session.erl's comment on next_outgoing_id vs
+            # outgoing_delivery_id). Every transfer *frame* — including a
+            # fragment with no delivery-id of its own — advances it by one.
+            if self._next_incoming_id is not None:
+                self._next_incoming_id = (self._next_incoming_id + 1) % TRANSFER_ID_MODULUS
+            self._received_transfer = True
             self._incoming_used += 1
             replenish = self._incoming_used >= max(1, self._incoming_window // 2)
         link = self._link_for_handle(performative.handle)

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/rabbitmq_amqp_python_client/wire/encoding.py

@@ -92,6 +92,21 @@ _INT16_MIN, _INT16_MAX = -0x8000, 0x7FFF
 _INT32_MIN, _INT32_MAX = -0x80000000, 0x7FFFFFFF
 _INT64_MIN, _INT64_MAX = -0x8000000000000000, 0x7FFFFFFFFFFFFFFF
 
+#: Hard cap on a list/map/array's declared element count. A constant-width
+#: element (``null``, ``boolean``, ``uint0``, ``ulong0``) costs zero further
+#: bytes, so an ``array`` of one of those can claim billions of elements from
+#: a handful of wire bytes; without this cap, decoding one would force an
+#: allocation many orders of magnitude larger than the frame that requested it.
+MAX_COMPOUND_COUNT = 1_000_000
+
+#: Hard cap on how deeply values may nest (a described type wrapping another,
+#: or a list/map/array containing one). Every level costs only one byte on
+#: the wire (e.g. a run of described-type constructors, 0x00), so a small
+#: malicious frame can otherwise recurse past Python's call-stack limit and
+#: crash the process with an uncaught ``RecursionError`` instead of a
+#: ``ProtocolError``. No real AMQP message nests anywhere near this deep.
+MAX_DECODE_DEPTH = 100
+
 
 class Symbol(str):
     """A ``str`` that encodes as an AMQP ``symbol`` (ASCII) instead of a ``string``."""
@@ -575,11 +590,12 @@ class Decoder:
         position: Index of the first byte to read.
     """
 
-    __slots__ = ("_data", "_position")
+    __slots__ = ("_data", "_position", "_depth")
 
     def __init__(self, data: bytes | bytearray | memoryview, position: int = 0) -> None:
         self._data = bytes(data)
         self._position = position
+        self._depth = 0
 
     @property
     def position(self) -> int:
@@ -608,8 +624,19 @@ class Decoder:
         return self.read(1)[0]
 
     def read_value(self) -> Any:
-        """Read one complete value, constructor included."""
-        return self._read_body(self.read_code())
+        """Read one complete value, constructor included.
+
+        Raises:
+            ProtocolError: If reading the value would nest deeper than
+                :data:`MAX_DECODE_DEPTH`.
+        """
+        self._depth += 1
+        try:
+            if self._depth > MAX_DECODE_DEPTH:
+                raise ProtocolError(f"AMQP value nesting exceeds the {MAX_DECODE_DEPTH}-level limit")
+            return self._read_body(self.read_code())
+        finally:
+            self._depth -= 1
 
     def _unpack(self, fmt: str, size: int) -> Any:
         return struct.unpack(fmt, self.read(size))[0]
@@ -650,7 +677,11 @@ class Decoder:
         if code == CODE_DOUBLE:
             return float(self._unpack(">d", 8))
         if code == CODE_CHAR:
-            return chr(int(self._unpack(">I", 4)))
+            code_point = int(self._unpack(">I", 4))
+            try:
+                return chr(code_point)
+            except (ValueError, OverflowError) as error:
+                raise ProtocolError(f"AMQP char 0x{code_point:x} is not a valid Unicode scalar value") from error
         if code == CODE_TIMESTAMP:
             return Timestamp(self._unpack(">q", 8))
         if code == CODE_UUID:
@@ -675,8 +706,14 @@ class Decoder:
         if code in (CODE_VBIN8, CODE_VBIN32):
             return raw
         if code in (CODE_STR8, CODE_STR32):
-            return raw.decode("utf-8")
-        return Symbol(raw.decode("ascii"))
+            try:
+                return raw.decode("utf-8")
+            except UnicodeDecodeError as error:
+                raise ProtocolError(f"AMQP string is not valid UTF-8: {error}") from error
+        try:
+            return Symbol(raw.decode("ascii"))
+        except UnicodeDecodeError as error:
+            raise ProtocolError(f"AMQP symbol is not valid ASCII: {error}") from error
 
     def _read_compound(self, code: int, size: int, count: int) -> Any:
         # `size` is a hint used only to reject a declared length that could
@@ -690,6 +727,8 @@ class Decoder:
         end = self._position + size - width
         if end > len(self._data):
             raise ProtocolError(f"truncated AMQP compound value: declared size {size} overruns the buffer")
+        if count > MAX_COMPOUND_COUNT:
+            raise ProtocolError(f"AMQP compound declares {count} elements, exceeding the {MAX_COMPOUND_COUNT} limit")
         if code in (CODE_ARRAY8, CODE_ARRAY32):
             element_code = self.read_code()
             return [self._read_body(element_code) for _ in range(count)]
@@ -699,7 +738,11 @@ class Decoder:
             result: dict[Any, Any] = {}
             for _ in range(count // 2):
                 key = self.read_value()
-                result[key] = self.read_value()
+                value = self.read_value()
+                try:
+                    result[key] = value
+                except TypeError as error:
+                    raise ProtocolError(f"AMQP map key of type {type(key).__name__} is not hashable") from error
             return result
         return [self.read_value() for _ in range(count)]
 

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/tests/integration/test_consumer_integration.py

@@ -342,7 +342,15 @@ class TestRaisingHandler:
 
         def fail_on_some(data):
             message = decode(data)
-            if message.body_as_string() in poisoned:
+            # ``decode`` is patched on the shared Message class, so it also sees
+            # the connection's own management-response traffic, whose bodies are
+            # maps rather than strings; only this test's own deliveries can be
+            # judged against ``poisoned``.
+            try:
+                body = message.body_as_string()
+            except TypeError:
+                return message
+            if body in poisoned:
                 raise ProtocolError("simulated undecodable delivery")
             return message
 

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/tests/unit/fake_broker.py

@@ -69,6 +69,7 @@ class FakeBroker:
         auto_settle=True,
         sasl_layer=True,
         receiver_flow_properties=None,
+        next_outgoing_id=0,
     ):
         self._sock = sock
         self._sock.settimeout(5.0)
@@ -87,6 +88,7 @@ class FakeBroker:
         self.auto_settle = auto_settle
         self.sasl_layer = sasl_layer
         self.receiver_flow_properties = receiver_flow_properties
+        self.next_outgoing_id = next_outgoing_id
 
         self.sasl_init: SaslInit | None = None
         self.remote_open: Open | None = None
@@ -262,7 +264,7 @@ class FakeBroker:
                 channel,
                 Begin(
                     remote_channel=channel,
-                    next_outgoing_id=0,
+                    next_outgoing_id=self.next_outgoing_id,
                     incoming_window=DEFAULT_WINDOW,
                     outgoing_window=DEFAULT_WINDOW,
                     handle_max=self.handle_max,

{rabbitmq_amqp_python_client-2.0.0b1 → rabbitmq_amqp_python_client-2.0.0b2}/tests/unit/test_session.py

@@ -241,7 +241,88 @@ class TestWindows:
         link = _LinkDouble()
         handle = opened.allocate_handle(link)
         opened.handle_frame(Transfer(handle=handle, delivery_id=4, delivery_tag=b"t"), b"body")
-        assert opened._next_incoming_id == 5
+        assert opened._next_incoming_id == 1
+
+    def test_next_incoming_id_is_independent_of_the_wire_delivery_id(self, session):
+        """delivery-id and the implicit transfer-id are separate counters (#141).
+
+        RabbitMQ starts a session's real transfer-id count wherever it likes
+        and starts delivery-id at 0 regardless, so next-incoming-id must
+        advance once per transfer *frame* and never adopt the frame's
+        delivery-id, however small or large that happens to be.
+        """
+        _broker, _connection, opened = session
+        link = _LinkDouble()
+        handle = opened.allocate_handle(link)
+        opened.handle_frame(Transfer(handle=handle, delivery_id=0, delivery_tag=b"a"), b"body")
+        opened.handle_frame(Transfer(handle=handle, delivery_id=1, delivery_tag=b"b"), b"body")
+        opened.handle_frame(Transfer(handle=handle, delivery_id=2, delivery_tag=b"c"), b"body")
+        assert opened._next_incoming_id == 3
+
+    def test_next_incoming_id_continues_from_the_peers_arbitrary_starting_point(self, connect):
+        """Reproduces #141: RabbitMQ begins a session with next-outgoing-id set
+        near the 32-bit boundary rather than 0. A client that derives
+        next-incoming-id from the small, independently-numbered delivery-id
+        instead of counting frames sends a FLOW the broker rejects with
+        ``amqp:session:window-violation`` (its next-incoming-id "leads" the
+        broker's real next-outgoing-id).
+        """
+        broker, connection = connect(broker_kwargs={"next_outgoing_id": 0xFFFFFFFC})
+        opened = connection.open_session()
+        link = _LinkDouble()
+        handle = opened.allocate_handle(link)
+        assert opened._next_incoming_id == 0xFFFFFFFC
+        opened.handle_frame(Transfer(handle=handle, delivery_id=0, delivery_tag=b"a"), b"body")
+        assert opened._next_incoming_id == 0xFFFFFFFD
+        opened.handle_frame(Transfer(handle=handle, delivery_id=1, delivery_tag=b"b"), b"body")
+        assert opened._next_incoming_id == 0xFFFFFFFE
+        opened.send_flow()
+        _channel, performative, _payload = broker.wait_for(Flow)
+        assert performative.next_incoming_id == 0xFFFFFFFE
+
+    def test_next_incoming_id_wraps_at_the_32_bit_boundary(self, connect):
+        """The transfer-id is an RFC-1982 serial number: it wraps to 0 rather
+        than overflowing ``uint32``, which would otherwise blow up encoding
+        the next FLOW frame.
+        """
+        broker, connection = connect(broker_kwargs={"next_outgoing_id": 0xFFFFFFFE})
+        opened = connection.open_session()
+        link = _LinkDouble()
+        handle = opened.allocate_handle(link)
+        for delivery_id in range(3):
+            opened.handle_frame(Transfer(handle=handle, delivery_id=delivery_id, delivery_tag=b"t"), b"body")
+        assert opened._next_incoming_id == 1
+        opened.send_flow()
+        _channel, performative, _payload = broker.wait_for(Flow)
+        assert performative.next_incoming_id == 1
+
+    def test_next_incoming_id_advances_once_per_fragment_of_a_multi_frame_delivery(self, session):
+        """A fragmented delivery still consumes one transfer-id per frame (#141).
+
+        RabbitMQ's own session bookkeeping increments its outgoing transfer-id
+        once per TRANSFER *frame* it sends, continuation frames included, not
+        once per delivery (see rabbit_amqp_session.erl's comment contrasting
+        next_outgoing_id with outgoing_delivery_id). Live-broker testing
+        confirmed this: fragmenting one delivery into 7 frames advanced the
+        broker's real transfer count by 7, and a client that only advanced
+        next-incoming-id on the delivery's final frame — as the ``more`` flag
+        might tempt one to do — would fall behind and eventually trip the
+        same ``amqp:session:window-violation`` this fix prevents, just from
+        under- rather than over-counting.
+        """
+        _broker, _connection, opened = session
+        link = _LinkDouble()
+        handle = opened.allocate_handle(link)
+        # Only the first frame of a delivery carries delivery-id; continuation
+        # frames (more=True) carry none, exactly as a real fragmented transfer
+        # arrives on the wire.
+        opened.handle_frame(Transfer(handle=handle, delivery_id=0, delivery_tag=b"a", more=True), b"frag-1")
+        assert opened._next_incoming_id == 1
+        opened.handle_frame(Transfer(handle=handle, more=True), b"frag-2")
+        assert opened._next_incoming_id == 2
+        opened.handle_frame(Transfer(handle=handle, more=False), b"frag-3")
+        assert opened._next_incoming_id == 3
+        assert [payload for _performative, payload in link.frames] == [b"frag-1", b"frag-2", b"frag-3"]
 
     def test_the_incoming_window_is_replenished_once_half_consumed(self, connect):
         broker, connection = connect()

rabbitmq_amqp_python_client-2.0.0b2/tests/unit/test_wire_fuzz.py

@@ -0,0 +1,188 @@
+"""Property-based (Hypothesis) fuzz tests for the AMQP 1.0 wire codec.
+
+The rest of ``tests/unit`` is example-based: every case is a value someone
+(human or AI) thought to write down. These tests instead check invariants
+that must hold for *any* input, which is the only way to exercise byte
+patterns nobody thought to hand-pick:
+
+* **Round trip** - ``decode_value(encode_value(x)) == x`` for arbitrary,
+  possibly deeply nested Python values.
+* **Crash resistance** - decoding arbitrary or mutated-but-otherwise-valid
+  bytes must only ever raise :class:`ProtocolError`. Any other exception
+  means a hostile or buggy peer can crash the client instead of having its
+  frame rejected.
+
+Requires the ``hypothesis`` dev dependency (``pip install -e ".[dev]"``).
+"""
+
+from __future__ import annotations
+
+import math
+import struct
+from typing import Any
+
+import pytest
+from hypothesis import given, settings
+from hypothesis import strategies as st
+
+from rabbitmq_amqp_python_client.exceptions import ProtocolError
+from rabbitmq_amqp_python_client.wire import encoding as enc
+from rabbitmq_amqp_python_client.wire.frames import FRAME_TYPE_AMQP, FRAME_TYPE_SASL, decode_frame_body
+
+# --- Strategies for values `encode_value`/`decode_value` round-trip ---
+
+
+def _wrapped_int(wrapper: type, low: int, high: int) -> st.SearchStrategy[Any]:
+    return st.integers(min_value=low, max_value=high).map(wrapper)
+
+
+_ASCII_SYMBOL_TEXT = st.text(alphabet=st.characters(min_codepoint=0x21, max_codepoint=0x7E), max_size=32)
+
+_SCALARS = st.one_of(
+    st.none(),
+    st.booleans(),
+    st.integers(min_value=-0x80000000, max_value=0x7FFFFFFF),  # plain int -> AMQP int
+    st.integers(min_value=-0x8000000000000000, max_value=0x7FFFFFFFFFFFFFFF),  # plain int -> AMQP long
+    _wrapped_int(enc.Ubyte, 0, 0xFF),
+    _wrapped_int(enc.Byte, -0x80, 0x7F),
+    _wrapped_int(enc.Ushort, 0, 0xFFFF),
+    _wrapped_int(enc.Short, -0x8000, 0x7FFF),
+    _wrapped_int(enc.Uint, 0, 0xFFFFFFFF),
+    _wrapped_int(enc.Int, -0x80000000, 0x7FFFFFFF),
+    _wrapped_int(enc.Ulong, 0, 0xFFFFFFFFFFFFFFFF),
+    _wrapped_int(enc.Long, -0x8000000000000000, 0x7FFFFFFFFFFFFFFF),
+    _wrapped_int(enc.Timestamp, -0x8000000000000000, 0x7FFFFFFFFFFFFFFF),
+    _ASCII_SYMBOL_TEXT.map(enc.Symbol),
+    st.characters(max_codepoint=0x10FFFF).map(enc.Char),
+    st.integers(min_value=0, max_value=0xFFFFFFFF).map(
+        lambda bits: enc.Float(struct.unpack(">f", struct.pack(">I", bits))[0])
+    ),
+    st.floats(allow_nan=True, allow_infinity=True).map(enc.Double),
+    st.text(max_size=32),
+    st.binary(max_size=32),
+    st.uuids(),
+)
+
+_VALUES = st.recursive(
+    _SCALARS,
+    lambda children: st.one_of(
+        st.lists(children, max_size=5),
+        st.dictionaries(st.text(max_size=16), children, max_size=5),
+    ),
+    max_leaves=20,
+)
+
+
+def _values_equal(left: Any, right: Any) -> bool:
+    """Compare decoded/original values, treating NaN as equal to itself."""
+    if isinstance(left, float) and isinstance(right, float) and math.isnan(left) and math.isnan(right):
+        return True
+    if isinstance(left, list) and isinstance(right, list):
+        return len(left) == len(right) and all(_values_equal(a, b) for a, b in zip(left, right, strict=True))
+    if isinstance(left, dict) and isinstance(right, dict):
+        return left.keys() == right.keys() and all(_values_equal(left[key], right[key]) for key in left)
+    return bool(left == right)
+
+
+@given(value=_VALUES)
+@settings(max_examples=300, deadline=None)
+def test_round_trip_preserves_arbitrary_values(value: Any) -> None:
+    encoded = enc.encode_value(value)
+    decoded = enc.decode_value(encoded)
+    assert _values_equal(decoded, value), f"round trip mismatch: {value!r} -> {decoded!r}"
+
+
+# --- Crash resistance: a hostile/corrupt peer must only ever get a ProtocolError ---
+
+
+@given(data=st.binary(max_size=256))
+@settings(max_examples=500, deadline=None)
+def test_decode_value_never_leaks_a_non_protocol_error(data: bytes) -> None:
+    try:
+        enc.decode_value(data)
+    except ProtocolError:
+        pass
+    except Exception as exc:  # noqa: BLE001 - intentionally broad: this is the property under test
+        pytest.fail(f"decode_value raised {type(exc).__name__} instead of ProtocolError for {data!r}: {exc!r}")
+
+
+@given(value=_VALUES, mutations=st.lists(st.tuples(st.integers(min_value=0), st.integers(0, 255)), max_size=6))
+@settings(max_examples=300, deadline=None)
+def test_decode_value_never_leaks_a_non_protocol_error_on_mutated_input(
+    value: Any, mutations: list[tuple[int, int]]
+) -> None:
+    """Byte-flip a validly encoded value: more likely than raw random bytes to
+    reach the compound/variable-width/described decode paths."""
+    encoded = bytearray(enc.encode_value(value))
+    if not encoded:
+        return
+    for index, byte_value in mutations:
+        encoded[index % len(encoded)] = byte_value
+    try:
+        enc.decode_value(bytes(encoded))
+    except ProtocolError:
+        pass
+    except Exception as exc:  # noqa: BLE001 - intentionally broad: this is the property under test
+        pytest.fail(
+            f"decode_value raised {type(exc).__name__} instead of ProtocolError for {bytes(encoded)!r}: {exc!r}"
+        )
+
+
+@given(frame_type=st.sampled_from([FRAME_TYPE_AMQP, FRAME_TYPE_SASL]), body=st.binary(max_size=256))
+@settings(max_examples=500, deadline=None)
+def test_decode_frame_body_never_leaks_a_non_protocol_error(frame_type: int, body: bytes) -> None:
+    try:
+        decode_frame_body(frame_type, body)
+    except ProtocolError:
+        pass
+    except Exception as exc:  # noqa: BLE001 - intentionally broad: this is the property under test
+        pytest.fail(f"decode_frame_body raised {type(exc).__name__} instead of ProtocolError for {body!r}: {exc!r}")
+
+
+# --- Regression tests for the two resource-exhaustion bugs this fuzzing found ---
+
+
+class TestDecoderResourceLimits:
+    """A hostile peer must not be able to turn a small frame into unbounded work.
+
+    These reproduce two bugs found while writing the properties above:
+    `_read_compound` did not cap an array's declared element count against
+    anything but the buffer, and `read_value`'s recursion had no depth limit.
+    """
+
+    def test_array_of_null_rejects_a_count_that_would_allocate_millions_of_elements(self):
+        # 10 bytes on the wire; MAX_COMPOUND_COUNT + 1 declared `null` elements
+        # that (before the fix) cost zero further bytes each, so the array
+        # would happily build a multi-million-entry list from this alone.
+        count = enc.MAX_COMPOUND_COUNT + 1
+        header = struct.pack(">II", 5, count)  # size = count-field width + constructor byte
+        data = bytes((enc.CODE_ARRAY32,)) + header + bytes((enc.CODE_NULL,))
+        with pytest.raises(ProtocolError, match="exceeding"):
+            enc.decode_value(data)
+
+    def test_array_of_null_at_the_count_limit_still_decodes(self):
+        count = enc.MAX_COMPOUND_COUNT
+        header = struct.pack(">II", 5, count)
+        data = bytes((enc.CODE_ARRAY32,)) + header + bytes((enc.CODE_NULL,))
+        assert enc.decode_value(data) == [None] * count
+
+    def test_a_long_chain_of_described_types_is_rejected_before_the_stack_overflows(self):
+        # Each 0x00 opens another described-type level; without a depth limit
+        # this recurses through `read_value` until CPython raises an uncaught
+        # RecursionError instead of a ProtocolError.
+        chain = bytes((enc.CODE_DESCRIBED,)) * 4000 + enc.NULL_BYTES * 2
+        with pytest.raises(ProtocolError, match="nesting"):
+            enc.decode_value(chain)
+
+    def test_nesting_well_under_the_depth_limit_still_round_trips(self):
+        value: Any = None
+        for _ in range(40):
+            value = enc.Described(1, value)
+        assert enc.decode_value(enc.encode_value(value)) == value
+
+    def test_nesting_well_over_the_depth_limit_is_rejected(self):
+        value: Any = None
+        for _ in range(200):
+            value = enc.Described(1, value)
+        with pytest.raises(ProtocolError, match="nesting"):
+            enc.decode_value(enc.encode_value(value))