# GHSA-rgwj-5xj2-c3m3: MySQL2: Unbounded zlib inflate in compressed MySQL protocol handler allows decompression-bomb DoS

> An attacker can cause a denial of service by sending a compressed packet that expands to consume all available memory in the client application.

- **Severity:** Not scored
- **Exploited in the wild:** Not known
- **Login needed:** Any signed-in user
- **Attackable:** Over the internet
- **Victim action needed:** Not needed
- **Fix available:** Yes
- **Published:** 31 Aug 2026

## What is GHSA-rgwj-5xj2-c3m3?

GHSA-rgwj-5xj2-c3m3 is a denial of service vulnerability in mysql2, published on 31 Aug 2026. Any signed-in user can exploit it over the network, with no action from the victim.

### Official description

## Vulnerability Details

**File**: `lib/compressed_protocol.js`
**Line**: 43 (`zlib.inflate(body, (err, data) => { ... })` inside `handleCompressedPacket`)

### Root Cause
When a connection is created with `compress: true` (and the server advertises `CLIENT_COMPRESS`), every incoming packet is unwrapped by `handleCompressedPacket()` in `lib/compressed_protocol.js`, which calls:

```js
zlib.inflate(body, (err, data) => { ... });
```

No options object (in particular, no `maxOutputLength`) is passed. Node's zlib convenience methods default `maxOutputLength` to `buffer.kMaxLength`, which on this platform is `Number.MAX_SAFE_INTEGER` — i.e. effectively unbounded until the process runs out of memory. The 3-byte "length of payload before compression" field in the compressed-packet header is read (`packet.readInt24()`) but is only used to branch on `!== 0`; it is never used to cap or validate the actual inflate output size, and the real decompressed size is determined purely by the attacker-supplied deflate stream.

Because DEFLATE can reach compression ratios over 1000:1 for crafted repetitive input, an attacker who controls (or MITMs, on a non-TLS connection) the MySQL server endpoint can send a single small compressed packet that expands to gigabytes in the client's memory — a classic decompression-bomb / "zip bomb" applied to MySQL's client-compression protocol.

### Attack Scenario
1. Application connects with `mysql2`/`mysql2/promise` using `compress: true` (a documented option for reducing bandwidth, commonly used for cloud/WAN DB connections).
2. The connection target is attacker-controlled or attacker-compromised, or an attacker MITMs a non-TLS connection.
3. Right after authentication succeeds, the malicious endpoint sends one crafted compressed packet whose deflate stream is small on the wire (hundreds of KB) but decompresses to several GB.
4. `zlib.inflate()` starts allocating memory for the full decompressed output with no ceiling.
5. The Node.js process's RSS grows uncontrolled until OOM-kill or crash — no query needs to be issued by the client; the malicious packet alone is enough.

### Impact
Denial of Service of the client application (process crash / OOM) — not the database itself. No authentication bypass or data exposure. Requires `compress: true` plus a malicious/compromised server or MITM position.

### Vulnerable Code
```js
function handleCompressedPacket(packet) {
  const connection = this;
  const deflatedLength = packet.readInt24();
  const body = packet.readBuffer();

  if (deflatedLength !== 0) {
    connection.inflateQueue.push((task) => {
      zlib.inflate(body, (err, data) => {
        if (err) {
          connection._handleNetworkError(err);
          return;
        }
        connection._bumpCompressedSequenceId(packet.numPackets);
        connection._inflatedPacketsParser.execute(data);
        task.done();
      });
    });
  } else {
    ...
  }
}
```

### Recommended Fix
```js
const MAX_INFLATED_PACKET_SIZE = 1 * 1024 * 1024 * 1024; // e.g. 1 GiB, ideally configurable

zlib.inflate(body, { maxOutputLength: MAX_INFLATED_PACKET_SIZE }, (err, data) => {
  if (err) {
    connection._handleNetworkError(err);
    return;
  }
  ...
});
```
`maxOutputLength` makes `zlib.inflate` abort with `ERR_BUFFER_TOO_LARGE` as soon as the decompressed size would exceed the cap, routing into the exact same (already-existing) `err` → `connection._handleNetworkError(err)` path, so no new error-handling logic is required.

### Verification
Dynamically confirmed on v3.23.0 (HEAD) using a minimal rogue "MySQL server" built on node-mysql2's own server-mode helpers (`mysql.createServer`, `Packets.Handshake`, `connection.writeOk()`). The rogue server completes a real handshake advertising `CLIENT_COMPRESS`, then writes one raw compressed frame (509,604 bytes on the wire — a zlib deflate of 500 MB of zero bytes, ratio 1028.8:1) directly to the socket. A normal `mysql.createConnection({ ..., compress: true })` victim client — which never issues any query — had its RSS grow from 74.3 MB to 1115.0 MB after receiving that single packet, before erroring out with `PROTOCOL_UNEXPECTED_PACKET` once the client tried to parse the inflated zero-filled buffer as MySQL packets. The memory allocation happens unconditionally before any content validation.

## Which versions are affected by GHSA-rgwj-5xj2-c3m3?

2 open source packages ship an affected version, including mysql2.


| Package | Ecosystem | Affected | Fixed in |
| --- | --- | --- | --- |
| `mysql2` | npm | All versions | 3.23.1 |
| `mysql2` | npm | All versions | 3.23.1 |

## How do I fix GHSA-rgwj-5xj2-c3m3?

Upgrade mysql2 to 3.23.1 or later.

## Is GHSA-rgwj-5xj2-c3m3 being exploited?

There is no known exploitation of GHSA-rgwj-5xj2-c3m3 in the wild and no public exploit code.

## Fix prompt for AI coding agents

```text
Check this codebase for GHSA-rgwj-5xj2-c3m3 and fix it if it is affected.

What it is: GHSA-rgwj-5xj2-c3m3 is a denial of service vulnerability in mysql2, published on 31 Aug 2026. Any signed-in user can exploit it over the network, with no action from the victim.
Exploitation: There is no known exploitation of GHSA-rgwj-5xj2-c3m3 in the wild and no public exploit code.

Affected packages and fixed versions:
- mysql2 (npm): affected all versions; fixed in 3.23.1
- mysql2 (npm): affected all versions; fixed in 3.23.1

Task:
1. Search the dependency manifests and lockfiles (for example package.json, package-lock.json, requirements.txt, poetry.lock, uv.lock, pom.xml, build.gradle, go.mod, Cargo.lock, Gemfile.lock) and any Dockerfiles for the affected packages, including transitive dependencies.
2. If an affected version is in use, upgrade it to the fixed version for its release line with the project's package manager, so the lockfile is regenerated. Prefer the smallest upgrade that fixes it.
3. If there is no fix, or the upgrade would break the build, do not guess: explain the risk and the safest workaround instead.
4. Run the tests and summarise what changed and why.
5. If nothing in the project is affected, say so and change nothing.

Reference: https://insights.sbomify.com/GHSA-rgwj-5xj2-c3m3/ (Markdown: https://insights.sbomify.com/GHSA-rgwj-5xj2-c3m3/index.md)
```

## Sources

- OSV: https://osv.dev/vulnerability/GHSA-rgwj-5xj2-c3m3

---
From sbomify Insights: https://insights.sbomify.com/GHSA-rgwj-5xj2-c3m3/
Summaries are generated and may contain mistakes; the official description above is the record.