Read the docs

Unbounded memory allocation in FreeRDP drive redirection

Priority MEDIUM 44CWE-770Published · Updated

Key facts

Attack vector
Network
Privileges required
None
User interaction
Required
Attack complexity
Low
Impact type
Denial of service
Confidentiality · integrity · availability
None · None · High
Fix status
Fixed

Attack profile from CVSS 3.1 · GHSA-q56j-jjh6-38jf. Fix status from GitHub. Impact type from CWE-770.

Summary

FreeRDP from 3.0.0 through 3.31.1 allocates memory without limits when a server sends a drive read request with an oversized length. A malicious or compromised RDP server with drive redirection enabled can send one small request that makes the client allocate and zero roughly 4 GiB, which is CWE-770. The attacker needs no account on the client, but the user must connect to the server and share a drive.

Written with Claude Haiku 5.5 from the sources below · 2026-11-12

Description from the GitHub advisory

### Summary When a user connects a FreeRDP client to a malicious or compromised RDP server with drive redirection enabled, the server can open a shared file and send `IRP_MJ_READ` with `Length = 0xffffffff`. `drive_process_irp_read` passes `4ull + Length` to `Stream_EnsureRemainingCapacity` before reading the local file and without applying a per-request maximum. On a 64-bit build, the capacity request is `4294967299` bytes. The stream implementation attempts to grow the output buffer and zeroes the added region, so one small network request can cause roughly 4 GiB of allocation and memory-write pressure. On a 32-bit build, conversion to `size_t` reduces the same capacity argument to three bytes while the file-read count remains `UINT32_MAX`, leaving the following file write under-reserved. The user must initiate the RDP connection and share a drive. The server needs no account or prior access to the client. Once the server has obtained a valid shared-file identifier through the ordinary RDPDR protocol, the malicious length requires no further user interaction. The vulnerable reservation expression is present in every inspected release from 3.0.0 through 3.31.1 and remains present on current `master`. Releases through 3.20.0 used `Length + 4`, which wraps before conversion. Release 3.20.1 changed it to `4ull + Length`; that avoids the pre-conversion wrap on 64-bit builds but causes the oversized 64-bit allocation and still truncates on 32-bit builds. No fixed release is known. The relevant source is `drive_process_irp_read` in `channels/drive/client/drive_main.c`: ```c Stream_Read_UINT32(irp->input, Length); Stream_Read_UINT64(irp->input, Offset); file = drive_get_file_by_id(drive, irp->FileId); if (!file) { irp->IoStatus = STATUS_UNSUCCESSFUL; Length = 0; } else if (!drive_file_seek(file, Offset)) { irp->IoStatus = drive_map_windows_err(GetLastError()); Length = 0; } if (!Stream_EnsureRemainingCapacity(irp->output, 4ull + Length)) { WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!"); return ERROR_INTERNAL_ERROR; } else if (Length == 0) Stream_Write_UINT32(irp->output, 0); else { BYTE* buffer = Stream_PointerAs(irp->output, BYTE) + sizeof(UINT32); if (!drive_file_read(file, buffer, &Length)) { irp->IoStatus = drive_map_windows_err(GetLastError()); Stream_Write_UINT32(irp->output, 0); } else { Stream_Write_UINT32(irp->output, Length); Stream_Seek(irp->output, Length); } } ``` `Stream_EnsureCapacity` in `winpr/libwinpr/utils/stream.c` performs the growth and zero fill: ```c new_buf = (BYTE*)realloc(s->buffer, new_capacity); if (!new_buf) return FALSE; s->buffer = new_buf; s->capacity = new_capacity; s->length = new_capacity; ZeroMemory(&s->buffer[old_capacity], s->capacity - old_capacity); ``` ### Reproduction Save the following three files in one directory and run `sh ./run.sh`. The PoC safely reproduces the exact native arithmetic and extracts the compiled i386 values. It does not allocate 4 GiB, read a local file, contact an RDP server, or require FreeRDP development libraries. Requirements are a POSIX shell, a GCC-compatible C compiler with i386 code-generation support, GNU `objcopy`, and `od`. Expected output on a 64-bit host: ```text pointer_bits=64 normal_length=4096 normal_reservation=4100 maximum_length=4294967295 maximum_reservation=4294967299 i386_pocdata=0300000004100000 i386_maximum_reservation=3 i386_normal_reservation=4100 ``` <!-- BEGIN FILE: drive_length_native.c --> ```c #include <inttypes.h> #include <stdint.h> #include <stdio.h> static uint64_t reservation(uint32_t length) { return 4ULL + length; } int main(void) { const uint32_t normal_length = 4096U; const uint32_t maximum_length = UINT32_MAX; printf("pointer_bits=%zu\n", sizeof(size_t) * 8U); printf("normal_length=%" PRIu32 " normal_reservation=%" PRIu64 "\n", normal_length, reservation(normal_length)); printf("maximum_length=%" PRIu32 " maximum_reservation=%" PRIu64 "\n", maximum_length, reservation(maximum_length)); if ((sizeof(size_t) != 8U) || (reservation(normal_length) != 4100ULL) || (reservation(maximum_length) != 4294967299ULL)) return 1; return 0; } ``` <!-- END FILE: drive_length_native.c --> <!-- BEGIN FILE: drive_length_i386.c --> ```c typedef __SIZE_TYPE__ size_t; __attribute__((used, section(".pocdata"))) size_t reservation_values[2] = { (size_t)(4ULL + 0xffffffffU), (size_t)(4ULL + 4096U), }; ``` <!-- END FILE: drive_length_i386.c --> <!-- BEGIN FILE: run.sh --> ```sh #!/bin/sh set -eu BASE_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd) BUILD_DIR=${BUILD_DIR:-"$BASE_DIR/.build"} CC=${CC:-cc} OBJCOPY=${OBJCOPY:-objcopy} mkdir -p "$BUILD_DIR" "$CC" -std=c11 -Wall -Wextra -Werror -O2 \ "$BASE_DIR/drive_length_native.c" -o "$BUILD_DIR/drive_length_native" "$BUILD_DIR/drive_length_native" "$CC" -m32 -ffreestanding -fno-pic -fno-pie -c \ "$BASE_DIR/drive_length_i386.c" -o "$BUILD_DIR/drive_length_i386.o" "$OBJCOPY" -j .pocdata -O binary \ "$BUILD_DIR/drive_length_i386.o" "$BUILD_DIR/drive_length_i386.bin" I386_BYTES=$(od -An -tx1 -v "$BUILD_DIR/drive_length_i386.bin" | tr -d ' \n') printf 'i386_pocdata=%s\n' "$I386_BYTES" test "$I386_BYTES" = "0300000004100000" printf 'i386_maximum_reservation=3\n' printf 'i386_normal_reservation=4100\n' ``` <!-- END FILE: run.sh --> ### Remediation Reject redirected-drive read lengths above a documented per-request maximum before calling `Stream_EnsureRemainingCapacity` or `drive_file_read`. After enforcing the limit, compute `sizeof(UINT32) + (size_t)Length` and retain the stream helper's overflow checks as defense in depth. Add regression coverage for zero, the maximum accepted length, one byte above the limit, and `UINT32_MAX` on 32-bit and 64-bit builds. Oversized requests should be rejected before the local file reader is called.

Why it matters now

Fix Fixed FreeRDP (c): 3.32.0

SSVC decision points

Not available: CISA has not published SSVC decision points for this record.

Affected products

VendorProductAffected versionsFixed inStatusSource
—FreeRDP (c)>= 3.0.03.32.0Patch availableGHSA-q56j-jjh6-38jf
  • FreeRDP (c) Vendor— Affected >= 3.0.0 Fixed in 3.32.0 Patch available GHSA-q56j-jjh6-38jf

Remediation

Update FreeRDP to version 3.32.0, which is the listed fixed release for this flaw.

Written with Claude Haiku 5.5 from the sources below · 2026-11-12

  • Fix · GHSA-q56j-jjh6-38jf FreeRDP (c) Fixed in 3.32.0 Advisory →

Timeline

  1. 2026-11-12 Threatist record created from GHSA-q56j-jjh6-38jf

References

Sources

This product uses the NVD API but is not endorsed or certified by the NVD. Sources and licences