# CVE-2026-108412 — Windows RDBSS `rdbss.sys` Rename-Link Cluster-Info Heap Buffer Overflow (Local EoP to SYSTEM)

---

## Summary

A heap-based buffer overflow (CWE-122) in the Windows **Redirected Drive Buffering SubSystem**
(`rdbss.sys`) lets a local, authorized user elevate to **SYSTEM**. On the rename/hardlink path over a
network redirector, `RxSetRenameLinkClusterInfo` builds the target-name + cluster-info buffer for the
File Control Block (FCB), sizing the allocation from attacker-influenced **16-bit** name/length fields.
Pre-patch the allocation size could be under-computed (and the running length sum could wrap 16 bits),
so the subsequent `memmove` of the name/cluster bytes wrote past the pool allocation — a controlled
kernel heap overflow. Microsoft rates it Important, CVSS **7.8** (`AV:L/AC:L/PR:L/UI:N`).

---

## Affected component

RDBSS is the kernel buffering layer beneath the SMB (and other) network mini-redirectors. On a
rename/set-link operation it must construct the new fully-qualified name and "cluster info" into a
freshly allocated buffer attached to the FCB rename context. `RxSetRenameLinkClusterInfo`
(reached from the redirector's rename/`SetInformation` path, calling `RxpBuildTargetFcbTableNameForRename`,
`RxRemoveNameNetFcb`, `RxFcbTableInsertFcb`, and allocating from pool tag `0x3f3f7852` = "Rx??") is that
builder. The sizes it works from — `*puVar15` (a name length), the FCB name length at `param_3+0x23`,
and the current buffer capacity at `param_3+0x2d` — are 16-bit (`ushort`) quantities.

---

## Root cause

The destination buffer and the running copy offsets are sized with **16-bit arithmetic** from
attacker-influenced name lengths, with no overflow or minimum-size validation. Two concrete hazards:

- the initial record buffer is sized `name_len + 0x14` and then a `memmove` copies `name_len` bytes at
  offset `0x14` — with no floor on the allocation;
- the running destination length is computed as a sum of `ushort` fields and used directly as a
  `memmove` length into the FCB name buffer.

The pre-patch body of this function is a thin forwarding stub in the diffed build
(`uVar1 = func_0x00014006bca0(param_1,0); return uVar1;`), so the vulnerable arithmetic is not shown on
the old side of *this* function — the fixed logic appears as the feature-gated reimplementation below.
The heap-overflow classification is taken from MSRC and corroborated by the specific guards the patch
adds.

---

## The patch (confirmed — diff, .9818 → .9974)

Gated behind **`Feature_1788238136`**
(`Feature_1788238136__private_IsEnabledDeviceUsageNoInline`), the rewritten function adds three defenses:

**1. A minimum-size floor on the record allocation** (prevents an undersized buffer before the name copy):

```c
uVar10 = *puVar15 + 0x14;
uVar11 = Feature_1788238136__private_IsEnabledDeviceUsageNoInline();
if (((int)uVar11 != 0) && (uVar10 < 0x19))      // *** clamp to >= 0x18 when the flag is on ***
    uVar10 = 0x18;
local_res10 = ExAllocatePool2(0x102, uVar10, 0x3f3f7852);
...
memmove((void *)((longlong)local_res10 + 0x14), *(void **)(puVar15 + 4), (ulonglong)*puVar15);
```

**2. An explicit 16-bit integer-overflow check** before growing/writing the name buffer
(`0xC0000095` = `STATUS_INTEGER_OVERFLOW`):

```c
uVar13 = uVar14 + *(short *)(param_3 + 0x23);
if (uVar13 < uVar14) {                           // *** sum wrapped -> overflow ***
    uVar11 = 0xc0000095;                          // STATUS_INTEGER_OVERFLOW, bail
    ...
}
else {
    uVar14 = *(ushort *)(param_3 + 0x2d);         // current capacity
    if (uVar14 < uVar13) { uVar11 = 0xc0000095; } // *** would-overflow capacity -> bail ***
    else {
        memmove((void *)((ulonglong)uVar13 + (longlong)param_3[0x2e]), uStack_60, uVar14 - uVar13);
    }
}
```

**3. Grow-if-too-small reallocation** of the FCB name buffer before copying into it:

```c
uVar13 = (*(short *)(param_3 + 0x23) - (short)uVar12) + wVar16 + uVar14;   // total needed
if (*(ushort *)(param_3 + 0x2d) < uVar13) {                               // current buffer too small
    ppplVar9 = (longlong ***)ExAllocatePool2(0x102, uVar13, 0x3f3f7852);
    ...
    memmove(ppplVar9, param_3[0x2e], *(ushort *)(param_3 + 0x23));         // migrate old contents
    param_3[0x2e] = ppplVar9;                                              // swap in the larger buffer
}
```

Together these ensure the allocation is never smaller than the data copied into it and that the 16-bit
length math can no longer wrap undetected — closing the heap overflow. The fix is velocity-gated, so it
is only active when `Feature_1788238136` is enabled.

---

## Exploitability & constraints

Local, authorized attacker (`AV:L`, `PR:L`, `UI:N`), no race required (`AC:L`). The attacker drives a
rename/set-link on a redirected (network-mapped) path whose name/length fields are crafted so the 16-bit
size computation under-allocates or wraps; the following `memmove` then overflows the "Rx??" pool
allocation with attacker-controlled bytes, the usual basis for a pool-grooming EoP to SYSTEM. MSRC marks
it **Exploitation Less Likely**. What the diff does **not** establish: the exact caller that supplies the
attacker-controlled lengths, the precise pool the allocation lands in, and whether the sibling changed
function `ComputeFinalCopyChunkDestinationEndingVbo` addresses the same or a related issue — those need
dynamic confirmation.

---

## Detection

**Behavioural.** Pool corruption / bugchecks with `rdbss!RxSetRenameLinkClusterInfo` (or the redirector
rename path) on the stack, especially under renames/hardlinks of files on a mapped network drive with
unusually long or crafted names; Special Pool / Driver Verifier on `rdbss.sys` will trip on the overflow.
A sudden `STATUS_INTEGER_OVERFLOW` (`0xC0000095`) from a rename on a patched system is the guard firing.

**Config.** Confirm the Nov-2026 update is installed (24H2 `rdbss.sys` 10.0.26100.9974 / KB5132061 or the
later 26100.10068 / KB5132057) **and** that `Feature_1788238136` is enabled — the fix is velocity-gated,
so an installed build with the flag disabled still runs the unguarded path.

---

## References

- MSRC advisory — CVE-2026-108412 (Windows Redirected Drive Buffering System Elevation of Privilege), 2026-11-10.
- Diffed builds: `rdbss.sys` 10.0.26100.9818 → 10.0.26100.9974.
- Fix function: `RxSetRenameLinkClusterInfo`, gated by `Feature_1788238136` (CWE-122; signals: alloc-sizing, bounded-copy, overflow-guard).
