{"id":"DHI-afyf-kn55-dd5s-hrkv","summary":"## 1. Summary","details":"## 1. Summary\r\n\r\nA producer that speaks AMQP 1.0 can publish a well formed message whose application properties contain a nested map with a key longer than 255 bytes. RabbitMQ accepts and stores this message. The failure happens later, on the consumer side: to deliver the message to an AMQP 0.9.1 consumer, the broker converts the message into AMQP 0.9.1 properties, which produces a field table whose key cannot be represented in AMQP 0.9.1 (field table keys are shortstr, maximum 255 bytes). Encoding the delivery then raises `content_properties_shortstr_overflow` inside the connection's writer process, which tears the connection down. The consumer sees `INTERNAL_ERROR` (541) and never receives the message.\r\n\r\nThe message is not removed by the failed delivery. Unless an operator purges the queue or consumes the message with a different protocol, every subsequent AMQP 0.9.1 consumer that reaches it is disconnected in the same way, with no limit on the number of attempts. This turns a single small publish into a persistent denial of service for the AMQP 0.9.1 consumer population of that queue.\r\n\r\nTwo properties of the issue raise it above a queue level nuisance:\r\n\r\n1. The producer does not need any permission on the destination queue. Publish authorization is evaluated against the exchange, as documented, so a user whose only permission is `write` on a shared exchange can plant the message in any queue bound to that exchange, including queues owned by other users or tenants that the producer cannot read, write or configure. I verified this with a user restricted to `write=^poc\\.shared$`.\r\n2. Each failed delivery writes failure output to the broker log. I measured 1293 bytes of broker log per victim reconnect cycle (541 bytes for the connection itself, 752 bytes for the failure). A consumer that reconnects automatically, or an attacker who opens connections in a loop, therefore converts one publish into unbounded broker log growth, which is a node level resource problem rather than a per queue one.\r\n\r\nThe documented conversion rules state the opposite behaviour: entries that fail the `shortstr` condition are not converted, and the message remains deliverable with that entry omitted. The top level conversion applies exactly that rule. Only the nested map case is missing the check, which is why the message is stored in a state the broker cannot deliver.\r\n\r\n## 2. Affected versions\r\n\r\nVerified by building and running the source tree in this repository:\r\n\r\n* branch main, commit 169a13dc8a, version reported as 4.2.0+beta.4.1143.g169a13dc8a, Erlang/OTP 29.\r\n\r\nThe same unguarded nested map conversion exists unchanged in the maintained release branches of this repository. I checked each branch for the expression that performs the nested conversion:\r\n\r\n```\r\norigin/v4.0.x: 2 occurrences of to_091(unwrap(K), V)\r\norigin/v4.1.x: 2 occurrences of to_091(unwrap(K), V)\r\norigin/v4.2.x: 2 occurrences of to_091(unwrap(K), V)\r\norigin/v4.3.x: 2 occurrences of to_091(unwrap(K), V)\r\n```\r\n\r\nNative AMQP 1.0 support, and with it this conversion module, was introduced in RabbitMQ 4.0, so 4.0 and later are affected.\r\n\r\n## 3. Root cause\r\n\r\n### 3.1 The conversion\r\n\r\nAn AMQP 1.0 message published by a client is stored in its original format. When an AMQP 0.9.1 consumer receives it, `mc_amqpl` converts the message sections into AMQP 0.9.1 properties. The entry point for the delivery path is:\r\n\r\n* `deps/rabbit/src/rabbit_channel.erl:2769` `outgoing_content/2`\r\n* `deps/rabbit/src/rabbit_channel.erl:2771` `Mc2 = mc:convert(mc_amqpl, Mc1)`\r\n\r\nFor application properties, `mc_amqpl` maps each entry to an AMQP 0.9.1 header, but only if the key satisfies the shortstr condition:\r\n\r\n* `deps/rabbit/src/mc_amqpl.erl:153-155`\r\n\r\n```erlang\r\n({{utf8, K}, V})\r\n  when ?IS_SHORTSTR_LEN(K) -\u003e\r\n    {true, to_091(K, V)};\r\n```\r\n\r\nThe same guard exists for message annotations:\r\n\r\n* `deps/rabbit/src/mc_amqpl.erl:168-175`\r\n\r\nThe values themselves are converted by `to_091/2`. For maps, the conversion recurses without any guard on the nested keys:\r\n\r\n* `deps/rabbit/src/mc_amqpl.erl:736-745`\r\n\r\n```erlang\r\nto_091(Key, {map, M}) -\u003e\r\n    T = lists:filtermap(fun({K, V}) when element(1, K) =:= as_is orelse\r\n                                         element(1, V) =:= as_is -\u003e\r\n                                false;\r\n                           ({K, V}) -\u003e\r\n                                {true, to_091(unwrap(K), V)}\r\n                        end, M),\r\n    {Key, table, T};\r\n```\r\n\r\n`unwrap/1` returns the key as a plain binary. There is no length check and no validity check, so a nested key of 300 bytes becomes a 300 byte entry in an AMQP 0.9.1 field table.\r\n\r\n### 3.2 The encoder\r\n\r\nAMQP 0.9.1 field table keys are shortstr. The encoder enforces this and fails hard:\r\n\r\n* `deps/rabbit_common/src/rabbit_binary_generator.erl:148-152`\r\n\r\n```erlang\r\nshort_string_to_binary(String) -\u003e\r\n    Len = string_length(String),\r\n    if Len \u003c 256 -\u003e [\u003c\u003cLen:8\u003e\u003e, String];\r\n       true      -\u003e exit(content_properties_shortstr_overflow)\r\n    end.\r\n```\r\n\r\nField table entries are encoded through `table_field_to_binary/1`, which calls it for the field name:\r\n\r\n* `deps/rabbit_common/src/rabbit_binary_generator.erl:109-110`\r\n\r\n### 3.3 What the consumer sees\r\n\r\nThe exit happens while the delivery frame is being assembled in the connection's writer process. The writer terminates and the reader maps that to a connection close:\r\n\r\n* `deps/rabbit_common/src/rabbit_writer.erl:185-191` `handle_info(Message, State)` catches the exit and stops with `{shutdown, Reason}`\r\n\r\nThe broker log shows exactly this. Excerpt from the node log during testing:\r\n\r\n```\r\n[error] \u003c0.1929.0\u003e  {shutdown,content_properties_shortstr_overflow}\r\n[warning] \u003c0.1929.0\u003e Non-AMQP exit reason '{shutdown,content_properties_shortstr_overflow}'\r\n```\r\n\r\nThe client sees a connection close with reply code 541:\r\n\r\n```\r\nattempt  1: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\n```\r\n\r\nBecause the failure happens before the delivery is completed, the message is not acknowledged. It is requeued and remains in the queue with its unusable header.\r\n\r\n### 3.4 Documented behaviour versus observed behaviour\r\n\r\nThe RabbitMQ documentation for inter protocol conversions defines the shortstr condition and states what must happen when it is not met:\r\n\r\nSource: https://www.rabbitmq.com/docs/conversions, section \"Conventions\"\r\n\r\n\u003e `shortstr`: (condition) a string that is smaller than 256 bytes and contains only valid UTF-8 encoded data with no `NUL` (binary zero octet) characters.\r\n\r\n\u003e Conditions can be read to be evaluated in the order they are written. For example an AMQP `message_id` of type `utf8` with more than 255 bytes will fail the first `shortstr` condition and then fall through to the next line. If there is no matching line then the data will not be converted (and therefore not be available to the consuming application).\r\n\r\nThe same page applies that condition to the exact sections used by this proof of concept, in the table for \"AMQP 1.0 -\u003e AMQP 0.9.1\":\r\n\r\n* `application properties`, condition `Key: shortstr`, target `properties.headers`\r\n* `message annotations`, condition `Key: shortstr` and `x-*`, target `properties.headers`\r\n\r\nIn other words, the documented outcome for an over long key is that the entry is dropped and the rest of the message is delivered. The implementation does that for top level keys and fails to do it for nested keys, and instead of dropping the entry it aborts the delivery and disconnects the consumer.\r\n\r\n## 4. Impact\r\n\r\n### 4.1 Persistent denial for AMQP 0.9.1 consumers of the queue\r\n\r\nThe poisoned message stays in the queue. Every AMQP 0.9.1 consumer that reaches it is disconnected with `INTERNAL_ERROR` before receiving any message. In testing, 35 consecutive consumer connections were killed by a single poisoned message and it was still queued afterwards. There is no self healing: the message is not dead lettered, not expired and not removed by a failed delivery.\r\n\r\nThe same message can still be consumed with AMQP 1.0 or STOMP. That means the queue is not entirely dead, but the consumer population that uses AMQP 0.9.1 (the most widely deployed protocol for this broker) is denied service indefinitely, and only an operator action (purge, delete the queue, or consume with another protocol) restores it.\r\n\r\n### 4.2 The producer does not need permission on the destination queue\r\n\r\nRabbitMQ authorizes a publish against the exchange, not against the queues it routes to. The AMQP 1.0 documentation states this for the queue target form:\r\n\r\nSource: https://www.rabbitmq.com/docs/amqp, section \"Address v2\"\r\n\r\n\u003e The 3rd format `/queues/:queue` causes all messages on the given link to be sent to queue `:queue`. The queue must exist. Internally, this queue target still uses the default exchange. Hence, the user needs write permissions to exchange `amq.default`.\r\n\r\nPublishing to `/exchanges/:exchange/:routing-key` requires write on that exchange. No permission on the destination queue is consulted. I verified this end to end:\r\n\r\n* `pocwriter` permissions: `configure=^$`, `write=^poc\\.shared$`, `read=^$`\r\n* an attempt by `pocwriter` to read the victim queue is refused by the broker:\r\n\r\n```\r\npocwriter basic.get on poison_q -\u003e channel closed by broker: 403 ACCESS_REFUSED - read access to queue 'poison_q' in vhost '/' refused for user 'pocwriter'\r\n```\r\n\r\n* the same user publishes to `/exchanges/poc.shared/victim.k1`, and the message lands in `poison_q`, a queue bound to that exchange:\r\n\r\n```\r\n############ 4. the message is now in a queue the publisher has no permission on\r\npoison_q\t1\r\n```\r\n\r\nThe practical consequence is that a producer with write access to one shared exchange can disable AMQP 0.9.1 consumption for any queue bound to it. In shared exchange topologies (topic exchanges, fanout exchanges, shared audit or dead letter queues) that includes queues belonging to other applications or tenants, and queues the producer cannot even see.\r\n\r\n### 4.3 Silent message loss with automatic acknowledgement\r\n\r\nWith a consumer that uses automatic acknowledgement, the message is removed from the queue when the delivery fails, and the consumer never receives it. Observed during testing on a separate queue: the delivery attempt killed the connection, the queue then reported zero messages and the client reported zero messages received. The publisher, if it used a confirm mode publish, has already received an acknowledgement.\r\n\r\n### 4.4 Broker log amplification, measured\r\n\r\nEach failed delivery writes failure output to the broker log. I measured this from the broker's own log stream, taking a byte cursor before and after a fixed number of operations, on the same node and with the same clients:\r\n\r\n| Measurement | Bytes |\r\n| --- | --- |\r\n| 10 victim reconnect cycles (each cycle: connect, basic.get, connection killed) | 12930 |\r\n| per reconnect cycle | 1293 |\r\n| 10 bare connect and close cycles (no queue involved) | 5411 |\r\n| per bare connection | 541 |\r\n| failure logging attributable to one failed delivery | 752 |\r\n\r\nThe poison is permanent, so the loop is unlimited. Arithmetic from the measured per cycle cost:\r\n\r\n| Victim reconnects per second | Broker log growth |\r\n| --- | --- |\r\n| 20 | about 2.1 GiB per day |\r\n| 200 | about 20.8 GiB per day |\r\n| 2000 | about 208 GiB per day |\r\n\r\nThe first two rows are reachable with consumer auto reconnect behaviour, the third with a loop of cheap TCP connections, which the attacker can drive directly if the account also holds read permission on the poisoned queue. The per cycle figures are measurements; the daily figures are arithmetic from those measurements and are presented as such. RabbitMQ's disk alarms monitor queue data directories, not the log volume, so sustained log growth is not covered by them.\r\n\r\n## 5. Severity\r\n\r\nCVSS 4.0 vector:\r\n\r\n```\r\nCVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N\r\n```\r\n\r\nBase score: 7.1 (High).\r\n\r\nReasoning, stated plainly:\r\n\r\n* Attack vector network, complexity low, no attack requirements beyond a bound queue. A single publish is enough and it is a normal, well formed AMQP 1.0 message, so the attacker does not need a malformed frame, a race or any timing condition.\r\n* Privileges required low. Any account with write permission on an exchange is enough, and that is the ordinary permission of a publisher. For the cross tenant case, an account with write on a shared exchange, and no permission at all on the victim queue, is enough.\r\n* Availability impact high. The denial is persistent, it survives consumer restarts and broker restarts (verified: the message and its unusable header are stored), and it also produces node level log growth.\r\n* No confidentiality or integrity impact, which is why the vector is availability only.\r\n\r\nI am aware that a triager may view \"a publisher can disturb the queue it publishes to\" as expected. The two properties that take this beyond that reading are 4.2 (the attacker does not need any permission on the queue that is actually damaged, so the permission model does not contain the attack) and 4.4 (the same publish drives node level log growth). If the project prefers to rate the queue level denial alone, the cross permission aspect should at least be considered for the authorization boundary it crosses.\r\n\r\n## 6. Reproduction\r\n\r\n### 6.1 Environment\r\n\r\n* RabbitMQ built and run from this repository, branch main at 169a13dc8a, on Erlang/OTP 29, macOS arm64.\r\n* Default listeners: AMQP 0.9.1 and AMQP 1.0 both on 5672, management HTTP on 15672.\r\n* Python 3 with `pika` installed (`pip install pika`) for the consumer. The publisher uses only the standard library.\r\n\r\n### 6.2 Files\r\n\r\nAll files are in this report's `poc` directory. Only these two are needed to reproduce; `run_e2e.sh` is the wrapper that produced the transcript in section 6.4 and can be used as is.\r\n\r\n[poc.zip](https://github.com/user-attachments/files/32443836/poc.zip)\r\n\r\n* `poc_publish_poison.py` (standard library only): performs the AMQP 1.0 handshake (SASL PLAIN), opens a session and a sender link, and transfers one message whose application properties contain a nested map whose key is 300 bytes long.\r\n* `poc_consume_victim.py` (requires `pika`): opens an AMQP 0.9.1 connection, performs `basic.get` with manual acknowledgement, and reports what the broker does. Repeat it as many times as you like; the message is never consumed.\r\n* `run_e2e.sh` (optional): creates the topology and two restricted users, publishes as the restricted producer, runs the victim loop, and prints queue state.\r\n\r\n### 6.3 Steps\r\n\r\n1. Start the broker from this repository (`./sbin/rabbitmq-server` after a build, or `gmake run-broker`).\r\n\r\n2. Create a queue, a shared exchange, a binding, and two restricted users. This mirrors an ordinary shared exchange deployment:\r\n\r\n```sh\r\ncurl -u guest:guest -X PUT -H 'content-type: application/json' -d '{\"durable\":true}' \\\r\n     http://127.0.0.1:15672/api/queues/%2F/poison_q\r\ncurl -u guest:guest -X PUT -H 'content-type: application/json' \\\r\n     -d '{\"type\":\"topic\",\"durable\":true}' http://127.0.0.1:15672/api/exchanges/%2F/poc.shared\r\ncurl -u guest:guest -X POST -H 'content-type: application/json' \\\r\n     -d '{\"routing_key\":\"victim.k1\",\"arguments\":{}}' \\\r\n     http://127.0.0.1:15672/api/bindings/%2F/e/poc.shared/q/poison_q\r\n\r\n# producer: write permission on the exchange only\r\ncurl -u guest:guest -X PUT -H 'content-type: application/json' \\\r\n     -d '{\"password\":\"pocwriterpw\",\"tags\":\"\"}' http://127.0.0.1:15672/api/users/pocwriter\r\ncurl -u guest:guest -X PUT -H 'content-type: application/json' \\\r\n     -d '{\"configure\":\"^$\",\"write\":\"^poc\\\\.shared$\",\"read\":\"^$\"}' \\\r\n     http://127.0.0.1:15672/api/permissions/%2F/pocwriter\r\n\r\n# victim: read permission on the queue only\r\ncurl -u guest:guest -X PUT -H 'content-type: application/json' \\\r\n     -d '{\"password\":\"pocvictimpw\",\"tags\":\"\"}' http://127.0.0.1:15672/api/users/pocvictim\r\ncurl -u guest:guest -X PUT -H 'content-type: application/json' \\\r\n     -d '{\"configure\":\"^$\",\"write\":\"^$\",\"read\":\"^poison_q$\"}' \\\r\n     http://127.0.0.1:15672/api/permissions/%2F/pocvictim\r\n```\r\n\r\n3. Publish the poisoned message as the restricted producer:\r\n\r\n```sh\r\npython3 poc_publish_poison.py --user pocwriter --password pocwriterpw \\\r\n    --address /exchanges/poc.shared/victim.k1 --key-length 300\r\n```\r\n\r\n4. Confirm the message landed in a queue the producer has no permission on:\r\n\r\n```sh\r\n./sbin/rabbitmqctl list_queues name messages | grep poison_q\r\n# poison_q  1\r\n```\r\n\r\n5. Run the victim loop:\r\n\r\n```sh\r\npython3 poc_consume_victim.py --user pocvictim --password pocvictimpw \\\r\n    --queue poison_q --attempts 10\r\n```\r\n\r\n6. Confirm the message is still queued after the loop:\r\n\r\n```sh\r\n./sbin/rabbitmqctl list_queues name messages | grep poison_q\r\n# poison_q  1\r\n```\r\n\r\n### 6.4 Transcript\r\n\r\nThis is the captured output of `run_e2e.sh` on the test node, trimmed to the steps that matter (the wrapper also waits for the broker to start and prints contrast notes at the end).\r\n\r\n```\r\n############ 1. topology: shared exchange, victim queue, two restricted users\r\nqueue=201 exchange=201 binding=201\r\nwriter_user=204 writer_perms=204\r\nvictim_user=204 victim_perms=204\r\npocwriter permissions : {\"user\":\"pocwriter\",\"vhost\":\"/\",\"configure\":\"^$\",\"write\":\"^poc\\\\.shared$\",\"read\":\"^$\"}\r\npocvictim permissions : {\"user\":\"pocvictim\",\"vhost\":\"/\",\"configure\":\"^$\",\"write\":\"^$\",\"read\":\"^poison_q$\"}\r\n\r\n############ 2. prove the publisher cannot touch the victim queue itself\r\npocwriter basic.get on poison_q -\u003e channel closed by broker: 403 ACCESS_REFUSED - read access to queue 'poison_q' in vhost '/' refused for user 'pocwriter'\r\n\r\n############ 3. publish the poison message as pocwriter (write on the exchange only)\r\n1. sent SASL protocol header b'AMQP\\x03\\x01\\x00\\x00', broker echoed b'AMQP\\x03\\x01\\x00\\x00'\r\n   broker offered: ['sasl-mechanisms']\r\n2. SASL PLAIN as 'pocwriter', broker answered: ['sasl-outcome']\r\n3. sent AMQP protocol header b'AMQP\\x00\\x01\\x00\\x00', broker echoed b'AMQP\\x00\\x01\\x00\\x00'\r\n4. sent open, broker answered: ['open']\r\n5. sent begin + attach to '/exchanges/poc.shared/victim.k1', broker answered: ['begin', 'attach', 'flow']\r\n6. sent transfer with a 300 byte nested map key, broker answered: []\r\n7. message accepted (no error from the broker); it is now stored and will be delivered to AMQP 0.9.1 consumers\r\n\r\n############ 4. the message is now in a queue the publisher has no permission on\r\npoison_q\t1\r\n\r\n############ 5. victim loop: AMQP 0.9.1 consumer, 10 attempts, manual ack\r\nattempt  1: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  2: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  3: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  4: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  5: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  6: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  7: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  8: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt  9: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempt 10: connection killed by broker, reply code 541 (INTERNAL_ERROR)\r\nattempts=10, connections killed=10\r\noutcome: the poisoned message is still in the queue; every AMQP 0.9.1 consumer that receives it is disconnected\r\n\r\n############ 6. queue state after the victim loop\r\npoison_q\t1\r\n```\r\n\r\n### 6.5 What the client and the broker report\r\n\r\nClient side, the connection is closed by the broker with 541:\r\n\r\n```\r\nConnectionClosedByBroker: (541, 'INTERNAL_ERROR')\r\n```\r\n\r\nBroker side, each attempt produces the encoder exit and the connection close:\r\n\r\n```\r\n[error] \u003c0.1929.0\u003e  {shutdown,content_properties_shortstr_overflow}\r\n[warning] \u003c0.1929.0\u003e Non-AMQP exit reason '{shutdown,content_properties_shortstr_overflow}'\r\n```\r\n\r\n### 6.6 Scope notes\r\n\r\n* Verified on classic queues. The conversion is shared by all queue types that store a message published with AMQP 1.0 and deliver it to an AMQP 0.9.1 consumer, so quorum queues and streams are expected to behave the same way, but I did not test them and do not claim it as verified.\r\n* An AMQP 0.9.1 publisher cannot create such a message: AMQP 0.9.1 field table keys are shortstr by construction. A STOMP publisher that sends an over long header name has its own connection closed at publish time (observed during testing), so it does not create a stored poison either. The planting step requires an AMQP 1.0 publish.\r\n* Messages that are consumed with AMQP 1.0 or STOMP are unaffected. This is specific to the AMQP 0.9.1 conversion and encoder.\r\n\r\n## 7. Suggested remediation\r\n\r\n1. Apply the same condition in the nested conversion that is already applied at the top level. In `mc_amqpl:to_091/2`, for the `{map, M}` clause and for the list and array helpers, filter out keys for which `?IS_SHORTSTR_LEN/1` is false, exactly as `mc_amqpl.erl:154` and `:169` do for top level keys and message annotations. Dropping the entry matches the documented conversion rules.\r\n\r\n2. Harden the delivery path so that an unencodable header cannot take down a consumer connection. Encoding a single delivery should not be fatal to the connection: log the offending field once, skip the header, and deliver the message, or reject the delivery and route the message to the dead letter exchange. As it stands, any future conversion gap in the same code path has the same effect.\r\n\r\n3. Consider validating at conversion time rather than at encode time. The conversion is where the AMQP 0.9.1 constraints are known; failing there produces a clear error for the publisher or a clean drop, instead of a stored message that can never be delivered.\r\n\r\n## 8. Detection and workarounds for operators\r\n\r\n* Detection: search broker logs for `content_properties_shortstr_overflow`. Each occurrence is one killed consumer connection. A single queue with repeated occurrences and a stable message count is a poisoned queue.\r\n* Containment: purge the affected queue with `rabbitmqctl purge_queue`, or delete it with `rabbitmqctl delete_queue -p \u003cvhost\u003e \u003cqueue\u003e`, or consume the queue with an AMQP 1.0 client, which is not affected.\r\n* Permission hygiene: restrict `write` on shared exchanges. Producers that only need to publish to their own queues should publish through the default exchange, where the write check is applied to the queue name, which prevents planting messages in other people's queues.\r\n* Log volume: put the RabbitMQ log directory on a partition with its own capacity and monitor it, since disk alarms do not cover log growth.\r\n\r\n## 9. Timeline\r\n\r\n* 2026-09-20: issue found and reproduced on main at 169a13dc8a.\r\n* 2026-09-20: report prepared, proof of concept minimized to two files (one of them standard library only).\r\n* (report sent)\r\n\r\n## Appendix A: message that reproduces the issue\r\n\r\nThe publisher sends one AMQP 1.0 message with this shape (shown in AMQP 1.0 type notation):\r\n\r\n```\r\napplication-properties : map {\r\n    \"x-nested\" : map {\r\n        \"kkkk...(300 bytes)...\" : \"v\"\r\n    }\r\n}\r\ndata                   : \"poison-body\"\r\n```\r\n\r\nThe application property key must be of type string (utf8). Application properties whose keys are symbols are dropped by the conversion before this code path is reached, so they cannot be used to reproduce the issue.\r\n\r\n## Appendix B: relevant source locations\r\n\r\n| Location | Role |\r\n| --- | --- |\r\n| `deps/rabbit/src/mc_amqpl.erl:153-155` | top level application property conversion, shortstr check present |\r\n| `deps/rabbit/src/mc_amqpl.erl:168-175` | message annotation conversion, shortstr check present |\r\n| `deps/rabbit/src/mc_amqpl.erl:736-745` | nested map conversion, no key check, source of the issue |\r\n| `deps/rabbit/src/rabbit_channel.erl:2769-2771` | delivery path that calls the conversion |\r\n| `deps/rabbit_common/src/rabbit_binary_generator.erl:109-110` | field table entry encoding |\r\n| `deps/rabbit_common/src/rabbit_binary_generator.erl:148-152` | shortstr encoder, raises `content_properties_shortstr_overflow` |\r\n| `deps/rabbit_common/src/rabbit_writer.erl:185-191` | writer stops on the exit, which closes the connection |","modified":"2026-11-16T02:34:44.345350884Z","published":"2026-11-11T23:12:27Z","upstream":["GHSA-g73v-gcjq-2g4h"],"references":[{"type":"ADVISORY","url":"https://scout.docker.com/v/DHI-afyf-kn55-dd5s-hrkv"},{"type":"ADVISORY","url":"https://github.com/rabbitmq/rabbitmq-server/security/advisories/GHSA-g73v-gcjq-2g4h"}],"affected":[{"package":{"name":"rabbitmq-4.3","ecosystem":"Docker Hardened Images:Debian:13","purl":"pkg:deb/dhi/rabbitmq-4.3"},"versions":["4.3.5-0","4.3.5-1","4.3.6-0","4.3.6-1","4.3.6-2"],"database_specific":{"owner_kind":"HSP","source":"https://github.com/docker-hardened-images/advisories/blob/main/dhi/osv/2026/DHI-afyf-kn55-dd5s-hrkv.json"}}],"schema_version":"1.9.2"}