Important CVSS 5.5 EPSS 0.00388 🔬 Patch diffed 2026-06 archive

Executive Summary

Out-of-bounds read in Windows Telephony Service allows an authorized attacker to disclose information locally.

Overview

5.5
CVSS MEDIUM
Important
MS Severity
Not Exploited
MS Exploit Status
Less Likely
MS Exploit Likelihood
Category Information Disclosure
Released Jun 9 2026
Last Updated Jun 9 2026
Publicly Disclosed No
CISA KEV Not Listed
Known Exploits None Known
EPSS Score 0.00388 — 0.31838 percentile
NVD CVSS 5.5 MEDIUM — matches MSRC

CVSS Vector

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

EPSS Score

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

Affected Products

30 affected products
Product KB Article Severity Impact Restart Required
Windows 10 Version 1607 for 32-bit Systems 5094122 (Security Update) Important Information Disclosure Yes
Windows 10 Version 1607 for x64-based Systems 5094122 (Security Update) Important Information Disclosure Yes
Windows 10 Version 1809 for 32-bit Systems 5094123 (Security Update) Important Information Disclosure Yes
Windows 10 Version 1809 for x64-based Systems 5094123 (Security Update) Important Information Disclosure Yes
Windows 10 Version 21H2 for 32-bit Systems 5094127 (Security Update) Important Information Disclosure Yes
Windows 10 Version 21H2 for ARM64-based Systems 5094127 (Security Update) Important Information Disclosure Yes
Windows 10 Version 21H2 for x64-based Systems 5094127 (Security Update) Important Information Disclosure Yes
Windows 10 Version 22H2 for 32-bit Systems 5094127 (Security Update) Important Information Disclosure Yes
Windows 10 Version 22H2 for ARM64-based Systems 5094127 (Security Update) Important Information Disclosure Yes
Windows 10 Version 22H2 for x64-based Systems 5094127 (Security Update) Important Information Disclosure Yes
Windows 11 Version 23H2 for ARM64-based Systems 5093998 (Security Update) Important Information Disclosure Yes
Windows 11 Version 23H2 for x64-based Systems 5093998 (Security Update) Important Information Disclosure Yes
Windows 11 Version 24H2 for ARM64-based Systems 5094126 (Security Update) Important Information Disclosure Yes
Windows 11 Version 24H2 for x64-based Systems 5094126 (Security Update) Important Information Disclosure Yes
Windows 11 Version 25H2 for ARM64-based Systems 5094126 (Security Update) Important Information Disclosure Yes
Windows 11 Version 25H2 for x64-based Systems 5094126 (Security Update) Important Information Disclosure Yes
Windows 11 Version 26H1 for ARM64-based Systems 5095051 (Security Update) Important Information Disclosure Yes
Windows 11 version 26H1 for x64-based Systems 5095051 (Security Update) Important Information Disclosure Yes
Windows Server 2012 5094042 (Monthly Rollup) Important Information Disclosure Yes
Windows Server 2012 (Server Core installation) 5094042 (Monthly Rollup) Important Information Disclosure Yes
Windows Server 2012 R2 5094041 (Monthly Rollup) Important Information Disclosure Yes
Windows Server 2012 R2 (Server Core installation) 5094041 (Monthly Rollup) Important Information Disclosure Yes
Windows Server 2016 5094122 (Security Update) Important Information Disclosure Yes
Windows Server 2016 (Server Core installation) 5094122 (Security Update) Important Information Disclosure Yes
Windows Server 2019 5094123 (Security Update) Important Information Disclosure Yes
Windows Server 2019 (Server Core installation) 5094123 (Security Update) Important Information Disclosure Yes
Windows Server 2022 5094128 (Security Update) Important Information Disclosure Yes
Windows Server 2022 (Server Core installation) 5094128 (Security Update) Important Information Disclosure Yes
Windows Server 2025 5094125 (Security Update) Important Information Disclosure Yes
Windows Server 2025 (Server Core installation) 5094125 (Security Update) Important Information Disclosure Yes

Patches

10 patches
Article Type Restart
5094122 Security Update Yes
5094123 Security Update Yes
5094127 Security Update Yes
5093998 Security Update Yes
5094126 Security Update Yes
5095051 Security Update Yes
5094042 Monthly Rollup Yes
5094041 Monthly Rollup Yes
5094128 Security Update Yes
5094125 Security Update Yes

Patch Diff

ghidriff · tapisrv.dll (KB5094126)

Out-of-bounds read (CWE-125) in the Windows Telephony Server tapisrv.dll TAPI event-mask handling, local information disclosure over the Telephony RPC interface. TAPI stores per-object event state as a 31-entry DWORD array (valid index 0-30). In single sub-mask mode (request+0x10 != 0) the handler combines request+0x18/+0x1C into a 64-bit sub-mask and derives an array index via GetSubMaskIndex = floor(log2(submask)), which can be up to 63. PRE: neither the read helper nor the write helper checked idx against the 31-slot array, so a sub-mask with bit 63 set yields idx=63 and reads base[63] - 132 bytes past the last valid entry base[30]. On the read path (TGetEventMasksOrSubMasks, 6 per-object accesses) the OOB DWORD is written to request+0x14 and returned in the RPC response (4-byte disclosure of adjacent TAPI memory); the same unbounded index reaches an OOB array write on SetEventMasksOrSubMasks. IN-HOUSE ghidriff of tapisrv.dll 10.0.26100.8521 -> .8655 (Jun 9 2026, KB5094126) confirms the fix: a new GetEventMasksOrSubMasks read helper and SetEventMasksOrSubMasks add an index bound (0x1e < idx -> return 0x80000032) at 7 access points, gated behind CFR flag Feature_500158777 (TGet also references Feature_784066872). Note: our x64 24H2 diff shows Feature_500158777/784066872, differing from the circulated screenshots' Feature_768594233 (build/arch difference); the >= 0x1F bound and 0x80000032 error are identical. We ship what our diff shows.

Pre-patch version 10.0.26100.8521 Download
Post-patch version 10.0.26100.8655 Download
Loading diff…
Select a function to see its diff.
View full diff report View RCA report

Root Cause Analysis

CVE-2026-42968 — Windows Telephony Server tapisrv.dll Out-of-Bounds Read: Unbounded Sub-Mask Index in Event-Mask Array Access


Summary

Product Windows — tapisrv.dll (Telephony Server / TAPI event-mask handling)
CVE ID CVE-2026-42968
Impact Information Disclosure
MSRC severity Important
CVSS 5.5 / 4.8 — CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N/E:U/RL:O/RC:C
CWE CWE-125: Out-of-bounds Read
Delivery Local — a crafted TAPI request over the Telephony Server RPC interface; the OOB DWORD is returned in the RPC response
KB / Fixed build KB5094126 — tapisrv.dll 10.0.26100.8655 (Win11 24H2 x64)
Patch Date June 9, 2026 (2026-Jun)
Pre-patch binary tapisrv.dll 10.0.26100.8521 — SHA256 be01d3bd28d2e12d81690790d3a68fbab6814a97b650a1534a9e73ad5ed5a01e
Post-patch binary tapisrv.dll 10.0.26100.8655 — SHA256 c00c8f51b6ba0bbd76927ac6eefb399a62e5e20fbbe41bdb45ef5901a8a1f169
Feature flag Feature_500158777 (+ Feature_784066872) — the fix is CFR-gated
Exploitability Exploitation Less Likely; not publicly disclosed; not exploited (per MSRC)

Product Description

tapisrv.dll is the Windows Telephony Server. TAPI tracks event state for several object kinds (client, call client, line client, phone client, line application, phone application) as a DWORD array of 31 entries (valid index 0–30). The whole-mask processing path walks each array exactly 31 times, and the post-patch bound 0x1F matches that size. Because the surface is reachable by a local, low-privileged caller over RPC and results are returned in the RPC response, an out-of-bounds read here discloses adjacent kernel/service memory.


Vulnerability Summary

In single sub-mask mode (request+0x10 != 0), the handler combines the two DWORDs at request+0x18 / request+0x1C into a 64-bit sub-mask, then derives an array index from the position of the highest set bit (idx = floor(log2(submask)), via GetSubMaskIndex). Pre-patch there is no check that idx fits the 31-entry array:

// GetEventMasksOrSubMasks / SetEventMasksOrSubMasks (10.0.26100.8521) — PRE-PATCH, from our diff
uVar1 = GetSubMaskIndex(param_2);   // idx = floor(log2(64-bit submask)) — can be up to 63
*param_4 = param_5[uVar1];          // READ path: base[idx]  (no bound)
// ... and on the write path:
param_4[uVar1] = param_3;           // WRITE path: base[idx] = value  (no bound)

Because the sub-mask is 64-bit, a client that sets only bit 63 yields idx = 63. The array has 31 slots (last valid base[30]), so base[63] is 33 DWORDs — 132 bytes — past the last valid entry. On the read path (TGetEventMasksOrSubMasks) that out-of-bounds DWORD is stored into the return field request+0x14 and returned to the caller as an RPC response — a 4-byte disclosure of adjacent TAPI object memory (CWE-125). The identical index is used on the write path (SetEventMasksOrSubMasks, reached from the six per-object setters), giving a matching out-of-bounds write primitive.


Prerequisites and Constraints

  • Local, low-privileged (PR:L, AV:L). The attacker sends a crafted TAPI request to the Telephony Server RPC interface.
  • Trigger: single sub-mask mode with a sub-mask whose highest set bit is above bit 30 (e.g. bit 63 → idx = 63).
  • Read path leaks 4 bytes per request (C:H); the same unbounded index also reaches an out-of-bounds array write on the set path.

Vulnerability Details

Root Cause

GetSubMaskIndex can return an index up to 63 from a 64-bit sub-mask, but the event-mask array holds only 31 entries. Neither the read helper nor the write helper validated the index against the array size before dereferencing base[idx], so an attacker-chosen high bit drives the access far past the array.

The patch (confirmed — diff, .8521 → .8655)

A single index upper-bound check is added at every array-access point, gated behind Feature_500158777 (the read path’s TGetEventMasksOrSubMasks also references Feature_784066872). If the feature is on and idx >= 0x1F (31), the function refuses the access and returns 0x80000032 instead of touching the array:

// GetEventMasksOrSubMasks / SetEventMasksOrSubMasks (10.0.26100.8655) — PATCHED, feature-enabled branch
uVar1 = GetSubMaskIndex(param_2);
uVar2 = Feature_500158777__private_IsEnabledDeviceUsageNoInline();
if ((uVar2 != 0) && (0x1e < uVar1)) {   // *** idx >= 31 -> reject ***
    return 0x80000032;
}
*param_4 = param_5[uVar1];              // (read)  / param_4[uVar1] = param_3; (write)

The check is placed at 7 access points: the six per-object read accesses of TGetEventMasksOrSubMasks (refactored through the new GetEventMasksOrSubMasks helper) and the common SetEventMasksOrSubMasks write access. The whole-mask path already walked the array exactly 31 times (lVar = 0x1f loop counter) and is unchanged.

Patch Completeness Assessment

CFR-gated behind Feature_500158777 / Feature_784066872. The bound runs only when the flags are enabled; the original unchecked access still ships in .8655. Patch state is not determined by file version alone — the runtime-gated pattern seen across this corpus. Verify the flags are enabled to confirm the bound is live.


Detection Guidance

Behavioural. TAPI single-sub-mask requests carrying a sub-mask with a set bit above bit 30 (index > 30); Telephony Server RPC responses returning event-mask DWORDs for such requests on unpatched/flag-disabled builds.

Crash signature. On the write path, pool corruption attributable to tapisrv!SetEventMasksOrSubMasks writing past a 31-entry event-mask array.

Config. The fix is CFR-gated — confirm Feature_500158777 (and Feature_784066872) are enabled so the >= 0x1F bound is active.


References

  • MSRC advisory — CVE-2026-42968 (Windows Telephony Server Information Disclosure), released 2026-06-09, KB5094126.
  • Full binary diff: /data/patch_diffs/tapisrv_dll-cve-2026-42968-ghidriff.md
  • Related Telephony bugs: CVE-2024-43518 (tapi32.dll GrowBuf).

Attack Path

A 64-bit TAPI sub-mask yields an array index up to 63 that reads past the 31-entry event-mask array and leaks the DWORD via RPC

Attack path for CVE-2026-42968 A 64-bit TAPI sub-mask yields an array index up to 63 that reads past the 31-entry event-mask array and leaks the DWORD via RPC 01 — ENTRY Local low-priv caller sends a crafted TAPI request to the Telephony Server RPC interface tapisrv.dll services TAPI event-mask get/set requests reachable over RPC. Single sub-mask mode is selected when request+0x10 != 0. 02 — CONTROLLED INPUT Sub-mask (request+0x18/+0x1C) sets a bit above bit 30 (e.g. bit 63) The two DWORDs are combined into a 64-bit sub-mask; GetSubMaskIndex returns floor(log2(submask)), so bit 63 -> idx=63. 03 — PATH The handler indexes the 31-entry DWORD event-mask array with idx Read path stores base[idx] into request+0x14; write path does base[idx]=value. Valid indices are 0-30. 04 — MISSING CHECK No check that idx fits the 31-slot array (CWE-125) idx=63 makes base[63] point 33 DWORDs (132 bytes) past base[30]; pre-patch neither helper validated the index. 05 — PRIMITIVE OOB DWORD returned in the RPC response -> 4-byte info disclosure (and matching OOB write on the set path) Adjacent TAPI object memory is leaked to the caller. The Jun 2026 fix adds a Feature_500158777-gated `idx>=0x1F -> return 0x80000032` bound at all 7 array-access points.

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

wxz
Diffract
z1r0