Important CVSS 8.8 EPSS 0.00552 🔬 Patch diffed 2026-03 archive

Executive Summary

Heap-based buffer overflow in Windows Telephony Service allows an unauthorized attacker to elevate privileges over an adjacent network.

Overview

8.8
CVSS HIGH
Important
MS Severity
Not Exploited
MS Exploit Status
Exploitation Unlikely
MS Exploit Likelihood
Category Elevation of Privilege
Released Mar 10 2026
Last Updated Mar 10 2026
Publicly Disclosed No
CISA KEV Not Listed
Known Exploits None Known
EPSS Score 0.00552 — 0.43389 percentile
NVD CVSS 8.8 HIGH — matches MSRC

CVSS Vector

CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C
ATTACK VECTOR
Adjacent_network
ATTACK COMPLEXITY
Low
PRIVILEGES REQUIRED
None
USER INTERACTION
None
SCOPE
Unchanged
CONFIDENTIALITY
High
INTEGRITY
High
AVAILABILITY
High
EXPLOIT CODE MATURITY
Unproven
REMEDIATION LEVEL
Official Fix
REPORT CONFIDENCE
Confirmed
Temporal Score: 7.7

EPSS Score

0.00552
probability of exploitation in the next 30 days
0.43389 percentile - updated 2026-08-14
View on FIRST.org

Affected Products

23 affected products
Product KB Article Severity Impact Restart Required
Windows 10 Version 1607 for 32-bit Systems 5078938 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 1607 for x64-based Systems 5078938 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 1809 for 32-bit Systems 5078752 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 1809 for x64-based Systems 5078752 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for 32-bit Systems 5078885 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for ARM64-based Systems 5078885 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for x64-based Systems 5078885 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for 32-bit Systems 5078885 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for ARM64-based Systems 5078885 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for x64-based Systems 5078885 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 23H2 for ARM64-based Systems 5078883 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 23H2 for x64-based Systems 5078883 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 24H2 for ARM64-based Systems 5079473 (Security Update) 5079420 (Security Hotpatch Update) Important Elevation of Privilege 5077181 5077212 Base: 8.8 Temporal: 7.7 Vector: CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26100.8037 10.0.26100.7979 Yes None Windows 11 Version 24H2 for x64-based Systems 5079473 (Security Update) 5079420 (Security Hotpatch Update) Important Elevation of Privilege 5077181 5077212 Base: 8.8 Temporal: 7.7 Vector: CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26100.8037 10.0.26100.7979 Yes None Windows 11 Version 25H2 for ARM systems 5079473 (Security Update) 5079420 (Security Hotpatch Update) Important Elevation of Privilege 5077181 5077212 Base: 8.8 Temporal: 7.7 Vector: CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26200.8037 10.0.26200.7979 Yes None Windows 11 Version 25H2 for x64-based Systems 5079473 (Security Update) 5079420 (Security Hotpatch Update) Important Elevation of Privilege 5077181 5077212 Base: 8.8 Temporal: 7.7 Vector: CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26200.8037 10.0.26200.7979 Yes None Windows 11 Version 26H1 for ARM64-based Systems 5079466 (Security Update) Important Elevation of Privilege Yes
Windows 11 version 26H1 for x64-based Systems 5079466 (Security Update) Important Elevation of Privilege Yes
Windows Server 2012 5078775 (Monthly Rollup) Important Elevation of Privilege Yes
Windows Server 2012 (Server Core installation) 5078775 (Monthly Rollup) Important Elevation of Privilege Yes
Windows Server 2012 R2 5078774 (Monthly Rollup) Important Elevation of Privilege Yes
Windows Server 2012 R2 (Server Core installation) 5078774 (Monthly Rollup) Important Elevation of Privilege Yes
Windows Server 2016 5078938 (Security Update) Important Elevation of Privilege Yes
Windows Server 2016 (Server Core installation) 5078938 (Security Update) Important Elevation of Privilege Yes
Windows Server 2019 5078752 (Security Update) Important Elevation of Privilege Yes
Windows Server 2019 (Server Core installation) 5078752 (Security Update) Important Elevation of Privilege Yes
Windows Server 2022 5078766 (Security Update) 5078737 (Security Hotpatch Update) Important Elevation of Privilege 5075906 5075943 Base: 8.8 Temporal: 7.7 Vector: CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.20348.4893 10.0.20348.4830 Yes No None Windows Server 2022 (Server Core installation) 5078766 (Security Update) 5078737 (Security Hotpatch Update) Important Elevation of Privilege 5075906 5075943 Base: 8.8 Temporal: 7.7 Vector: CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.20348.4893 10.0.20348.4830 Yes No None Windows Server 2022, 23H2 Edition (Server Core installation) 5078734 (Security Update) Important Elevation of Privilege Yes

Patches

8 patches
Article Type Restart
5078938 Security Update Yes
5078752 Security Update Yes
5078885 Security Update Yes
5078883 Security Update Yes
5079466 Security Update Yes
5078775 Monthly Rollup Yes
5078774 Monthly Rollup Yes
5078734 Security Update Yes

Patch Diff

ghidriff · tapisrv.dll (KB5079473)

Heap-based buffer overflow (CWE-122) in the Windows Telephony Service (tapisrv.dll) LForward, the server-side handler for lineForward. LForward parses a client-supplied LINEFORWARDLIST (header + array of LINEFORWARD entries, each with variable-length caller/callee address blobs referenced by offset/size). It allocates a heap buffer of 2 x dwTotalSize (the client-declared list size) and copies the list in, widening embedded ANSI address strings to Unicode. Each entry's caller/callee block is validated INDIVIDUALLY with IsBadSizeOffset, but the CUMULATIVE size of all entries' variable-length address data is never checked against the allocation. A crafted list whose entries each pass the per-entry check but whose aggregate (or ANSI->Unicode-widened, or overlapping/aliased-offset) address data exceeds 2 x dwTotalSize overflows the tapisrv service heap (ghTapisrvHeap) with attacker-controlled bytes - a local EoP. IN-HOUSE ghidriff diff of 10.0.26100.7623 -> .8036 shows LForward is the only function with a real code change; the March fix adds an integer-overflow-checked cumulative size accumulator validated against dwTotalSize, GATED behind CFR flag Feature_3967746362 - with the flag off the patched binary still runs the per-entry-only validation and remains overflowable. Credit: h4urek.

Pre-patch version 10.0.26100.7623 Download
Post-patch version 10.0.26100.8036 Download
Function Address Change Note
LForward 18000a750 -> 18000a790 code (cumulative size validation added, CFR-gated) Pre-patch validates each LINEFORWARD entry's caller/callee address block individually via IsBadSizeOffset but never sums them; allocation is HeapAlloc(ghTapisrvHeap,8,dwTotalSize*2). Post-patch adds Feature_3967746362__private_IsEnabledDeviceUsageNoInline() checks at 3 sites that accumulate each entry's CallerSize/CalleeSize into a running total (local_c4) with 32-bit add-overflow checks and reject when the total exceeds dwTotalSize (handles the aliased caller==callee case specially). Length 1502 -> 1656; match ratio 0.25/b_ratio 0.37. The cumulative check runs only when the flag is enabled.
Feature_3967746362__private_IsEnabledDeviceUsageNoInline 18000699c (new) added (CFR flag accessor) New Controlled Feature Rollout flag accessor introduced by this patch and called only from LForward. Gates the cumulative-size bounds check.
View full diff report View RCA report

Root Cause Analysis

CVE-2026-25188 — Windows Telephony Service tapisrv.dll Heap Overflow in LForward via Unvalidated Cumulative Size of a LINEFORWARDLIST


Summary

Product Microsoft Windows — tapisrv.dll (Telephony / TAPI Service)
CVE ID CVE-2026-25188
Impact Elevation of Privilege
MSRC severity Important
CWE CWE-122: Heap-based Buffer Overflow
Patch Date March 10, 2026
Pre-patch binary tapisrv.dll 10.0.26100.7623 (KB5074105, Jan 2026) — SHA256 3eda9356b2b1dbc9af6b3ea719536e05ba4011f82bbc12aff0cbb0a37b0efeb2
Post-patch binary tapisrv.dll 10.0.26100.8036 (KB5079473, Mar 2026) — SHA256 2f6946261b077051b3626b946a94e64b80b7360eef015cbd454b5f2d656bf1ec
Feature flag Feature_3967746362 — the fix is CFR-gated

Product Description

The Telephony Service (tapisrv.dll, hosted in a svchost.exe) implements the server side of the classic TAPI 2.x API. Client processes call functions such as lineForward through tapi32.dll, which marshals the request over the TAPI RPC/ALPC surface to tapisrv. Because the service runs with high privilege and the request buffers are fully controlled by the (potentially low-privileged) client, TAPI request handlers are a long-standing local elevation-of-privilege surface — tapisrv.dll has produced a run of EoP bugs including CVE-2024-26230, CVE-2024-43626 and CVE-2026-42912.

LForward is the server-side handler for lineForward. It parses a client LINEFORWARDLIST — a header followed by an array of LINEFORWARD entries, each carrying variable-length caller-address and callee-address blobs referenced by offset/size pairs into the same buffer.


Vulnerability Summary

LForward allocated a heap buffer sized at 2 × dwTotalSize (the total size the client declares in the list header) and copied the list into it, widening the embedded ANSI address strings to Unicode. Each entry’s caller/callee address block was bounds-checked individually with IsBadSizeOffset, but the cumulative size of all entries’ variable-length address data was never checked against the allocation.

// LForward (tapisrv.dll 10.0.26100.7623) — PRE-PATCH, from our ghidriff diff
required = header + (nEntries-1)*stride;                 // local_94 = uVar12 + uVar6
if ((uVar6 <= required) && (required <= dwTotalSize)) {  // fixed part fits the header claim
    for (i = 0; i < nEntries; i++) {                     // per-entry checks only
        if (bad dwForwardMode)                    goto error;
        if (IsBadSizeOffset(dwTotalSize, required, entry->CallerOff, entry->CallerSize)) goto error;
        if (IsBadSizeOffset(dwTotalSize, required, entry->CalleeOff, entry->CalleeSize)) goto error;
        entry = (uint*)((char*)entry + stride);
    }
    if (param_2[0xb] != 0xffffffff && nEntries != 0) {
        if ((ulonglong)dwTotalSize * 2 > 0xffffffff) goto error;
        _Dst = HeapAlloc(ghTapisrvHeap, 8, dwTotalSize * 2);   // *** 2 x dwTotalSize ***
        ...
        memcpy(_Dst, list, (nEntries-1)*stride + header);
        *_Dst = *_Dst * 2;                                     // records the doubled size
        // NewToOld / OldToNew widening then writes each entry's address strings
        // (MultiByteToWideChar) into _Dst — total expanded bytes can exceed 2*dwTotalSize
    }
}

IsBadSizeOffset only proves that a single entry’s offset + size lands inside dwTotalSize. Nothing sums the caller/callee address bytes across all entries. A LINEFORWARDLIST whose individual entries each pass the per-entry check, but whose aggregate variable-length address data — especially when the ANSI→Unicode widening doubles it — exceeds the 2 × dwTotalSize heap allocation, overflows the buffer with client-controlled bytes. Overlapping / aliased caller and callee offsets (the same bytes counted for multiple entries) are the natural way to make the declared dwTotalSize small while the expanded output is large.


Prerequisites and Constraints

  • Local authenticated session — any process that can open the TAPI client interface and issue lineForward. No administrative rights.
  • No user interaction, no special hardware.
  • The corrupted allocation is in the tapisrv service heap (ghTapisrvHeap), in the high-privileged service process — a heap overflow there is the EoP primitive.
  • The overflow contents are attacker-controlled (the widened address strings), so this is a controlled overflow suitable for grooming, not a blind smash.

Vulnerability Details

Call Chain

Low-privileged client:
  tapi32!lineForward  ->  TAPI RPC/ALPC  ->  tapisrv
                                               |
Telephony service (tapisrv.dll):
  <request dispatch>
    -> LForward                         [*** heap overflow ***]
         LineProlog / ValidateCallParams   (parse + per-entry IsBadSizeOffset)
         HeapAlloc(ghTapisrvHeap, 8, dwTotalSize*2)
         memcpy + NewToOldLineforwardlist / OldToNewLineforwardlist   (ANSI->Unicode widen)

Root Cause

Two facts combine:

  1. The allocation is sized from the client’s declared dwTotalSize (2 × dwTotalSize), not from the actual sum of the entries’ variable-length address data.
  2. Validation is per-entry, never cumulative. IsBadSizeOffset bounds each caller/callee block on its own; the running total of all blocks — which is what actually gets written during the widening copy — is never compared against the allocation. Overlapping offsets let the declared size stay small while the written size grows.

The patch

The March build inserts a cumulative, integer-overflow-checked size accumulator into the per-entry loop and validates it against dwTotalSize before the copy:

// LForward (10.0.26100.8036) — PATCHED, feature-enabled branch
if (Feature_3967746362__private_IsEnabledDeviceUsageNoInline()) {
    // aliased caller==callee case: advance dwTotalSize by the shared block once
    if (((entry->CalleeOff == entry->CallerOff) && (entry->CalleeSize == entry->CallerSize) &&
         (t = entry->CalleeSize + dwTotalSize, wrapped = t < dwTotalSize, dwTotalSize = t, wrapped))
        || (t = entry->CallerSize + acc, t < acc)) goto error;         // add-overflow check
    acc = entry->CalleeSize + t;                                       // running required size
    if ((acc < t) || (dwTotalSize < acc)) goto error;                 // stays within the buffer
}

The accumulator acc (local_c4) is seeded with the fixed-part size and grows by each entry’s caller and callee address sizes, with every addition checked for 32-bit wraparound and the total checked against dwTotalSize on each iteration. A list whose aggregate address data would overrun the allocation is now rejected before HeapAlloc/memcpy.

Patch Completeness Assessment

The fix is gated behind a Controlled Feature Rollout flag. LForward in 10.0.26100.8036 calls Feature_3967746362__private_IsEnabledDeviceUsageNoInline() at three points, and the cumulative bounds check runs only when the flag returns non-zero. With the flag disabled, the patched binary executes the original per-entry-only validation and remains overflowable. Patch state cannot be inferred from file version alone — the corrected path is live only where the CFR flag is enabled.

This is consistent with the pattern across this corpus: the CLFS 2025–2026 fixes, the August 2026 CVEs, and even the CVE-2024-38077 (lserver.dll) pre-auth RCE all ship their memory-safety fix behind a feature flag while the vulnerable code path remains compiled in.


Detection Guidance

Crash signature. Heap-corruption bugchecks or svchost.exe (TapiSrv host) crashes with the faulting allocation in ghTapisrvHeap, stack through tapisrv!LForward → NewToOldLineforwardlist / OldToNewLineforwardlist / memcpy. Enabling pageheap on the TapiSrv svchost makes the overrun land on a guard page at LForward.

Behavioural. Non-telephony processes opening the TAPI client interface and issuing lineForward with a LINEFORWARDLIST carrying many entries and/or entries whose caller/callee address offsets overlap or point at the same bytes — a legitimate forwarding list has a small entry count and non-overlapping blobs.

Config note. Because the fix is CFR-gated, confirming Feature_3967746362 is enabled is the only way to verify the corrected path is live; file version alone is insufficient.


LForward and its neighbours in tapisrv.dll are a recurring EoP surface:

  • CVE-2024-26230 — Telephony Service EoP (use-after-free)
  • CVE-2024-43626 — Telephony Service EoP
  • CVE-2026-42912 — Telephony Service EoP

CVE-2026-25188 adds a cumulative-size validation defect to that history, in the same lineForward handling path.


References

  • MSRC advisory — CVE-2026-25188 (Windows Telephony Service, Elevation of Privilege)
  • Full binary diff: /data/patch_diffs/tapisrv_dll-cve-2026-25188-ghidriff.md

Attack Path

Per-entry-only validation lets a LINEFORWARDLIST's aggregate address data overflow a 2 x dwTotalSize heap buffer in the Telephony service

Attack path for CVE-2026-25188 Per-entry-only validation lets a LINEFORWARDLIST's aggregate address data overflow a 2 x dwTotalSize heap buffer in the Telephony service 01 — ENTRY Local user opens the TAPI client interface and calls lineForward tapi32!lineForward marshals the request over TAPI RPC/ALPC to the tapisrv service (svchost). No admin rights; the service runs privileged, so corruption there is an EoP primitive. 02 — CONTROLLED INPUT Supplies a crafted LINEFORWARDLIST (header + LINEFORWARD entries) The client controls dwTotalSize, the entry count, and each entry's caller/callee address offset+size pairs into the same buffer - all fully attacker-chosen. 03 — PATH LForward allocates 2 x dwTotalSize and copies the list, widening ANSI addresses to Unicode HeapAlloc(ghTapisrvHeap, 8, dwTotalSize*2). NewToOld/OldToNewLineforwardlist expand each entry's address strings via MultiByteToWideChar into the buffer. 04 — MISSING CHECK Each entry is bounds-checked alone; the cumulative address size is never checked IsBadSizeOffset only proves a single entry's offset+size fits dwTotalSize. Nothing sums all entries' variable-length address data. Overlapping/aliased offsets keep dwTotalSize small while the written (widened) total grows past 2 x dwTotalSize. 05 — PRIMITIVE Controlled heap overflow in ghTapisrvHeap -> local elevation of privilege Attacker-controlled widened address bytes overrun the allocation in the privileged Telephony service. The March 2026 patch adds a cumulative, overflow-checked size accumulator validated against dwTotalSize - but gated behind CFR flag Feature_3967746362.

Derived from the patch delta: the checks added by the vendor identify which fields crossed a trust boundary unvalidated. Reachability and privilege are taken from the call chain in the RCA report.

Exploits & PoC

Detection Rules

Acknowledgments