CVE-2026-5713

What it actually does

This is a high-complexity memory corruption issue in newer Python runtime introspection/debugging functionality. If a privileged Python process uses the remote debugging feature to connect to a malicious or compromised Python process, the target process can abuse the profiling.sampling module in Python 3.15+ or asyncio introspection commands in Python 3.14+ to read from and write to memory addresses in the privileged process. Successful exploitation can compromise confidentiality and integrity of the privileged process, but exploitation is constrained: the attacker needs high privileges or a position that can influence/debug Python processes, user-assisted or administrator-initiated connection behavior, and repeated attempts because ASLR makes crashes likely.

Why it matters to the business

The main risk is compromise of a privileged Python process after it connects to an attacker-controlled Python process for debugging or introspection. In practical terms, this could expose sensitive runtime data such as secrets, tokens, configuration values, or business data held in memory, and could allow tampering with process behavior. The risk is lower than typical remote code execution because exploitation requires privileged access, active debugging/introspection behavior, and repeated attempts; EPSS is very low and there is no known KEV listing or public exploit maturity indicated. Organizations that routinely use Python remote debugging, production introspection, or privileged Python automation should still prioritize review because successful exploitation affects high-value privileged processes.

How an attack unfolds

An attacker first gains control of, or plants, a malicious Python process that can be reached by a privileged Python process through Python's remote debugging or introspection workflow. The attacker then induces an operator, automation job, or privileged process to connect to the malicious process using affected Python functionality, such as asyncio introspection in Python 3.14+ or profiling.sampling in Python 3.15+. During repeated connection attempts, the malicious process manipulates the debugging/introspection interaction to cause reads from or writes to memory addresses in the privileged process. Because address space layout randomization makes reliable targeting difficult, exploitation is expected to involve repeated crashes and retries before useful memory disclosure or modification succeeds. If successful, the attacker can obtain sensitive in-memory data or alter privileged process state.

How to fix it

Upgrade Python to a vendor-fixed release once available for the affected branch, especially for Python 3.14+ deployments using asyncio introspection and Python 3.15+ deployments using profiling.sampling. Because no exact fixed versions were provided in the input, follow the Python Software Foundation and operating system/package vendor advisories for branch-specific patched versions. Until patched, disable or restrict Python remote debugging and production introspection workflows, avoid connecting privileged Python processes to untrusted or lower-trust Python processes, and prohibit use of the affected introspection commands against untrusted targets. Run privileged Python services with least privilege, isolate development/debug tooling from production, and use sandboxing or container boundaries to reduce the consequence of a process compromise.

How to confirm the fix worked

Inventory hosts, containers, build images, and runtime environments for Python 3.14+ and Python 3.15+ installations. Confirm whether remote debugging, asyncio introspection, or profiling.sampling is enabled or used operationally. After patching, verify the active interpreter version comes from the fixed vendor release across all package managers, containers, virtual environments, and embedded Python distributions. Review process execution telemetry for use of affected commands, especially from privileged accounts or against production processes. Validate mitigations by confirming privileged Python processes cannot initiate remote debugging/introspection connections to untrusted Python processes and that administrative runbooks no longer recommend the affected workflows until patched.

Typical attack path

1. Obtain control of a Python process or environment that a privileged user or service may inspect using Python remote debugging or asyncio/profiling introspection.
2. Wait for or social-engineer an administrator, developer, automation task, or privileged Python process to connect to the malicious Python process using the affected remote debugging feature.
3. Trigger the vulnerable profiling.sampling or asyncio introspection behavior during the debugging/introspection session.
4. Repeatedly attempt memory reads or writes, accepting likely crashes caused by ASLR and retrying until useful addresses or effects are reached.
5. Extract sensitive in-memory data or modify the privileged process state if exploitation succeeds.
6. Use any obtained secrets, tokens, or altered process behavior for follow-on access or persistence.

How to detect it

Look for evidence that privileged users or services ran Python remote debugging or introspection commands against untrusted or unusual Python processes. Useful log sources include EDR process telemetry, shell history, auditd or Windows process creation logs, sudo logs, container runtime logs, CI/CD job logs, terminal session recording, and crash reports/core dump telemetry for privileged Python processes. Hunt for command lines invoking `python -m asyncio ps` or `python -m asyncio pstree`, especially when executed as root, Administrator, service accounts, or from production hosts. Review Python application logs and system journals for repeated crashes or segmentation faults of privileged Python processes near debugging/introspection activity; repeated crashes are relevant because exploitation is expected to require many attempts due to ASLR. Examine whether the `profiling.sampling` module was imported or used in privileged contexts. If suspicious activity is found, collect volatile evidence where possible, review command history and parent/child process relationships, identify the debug target process, and rotate secrets that may have been present in memory.

• python -m asyncio ps
• python -m asyncio pstree
• profiling.sampling
• import profiling.sampling
• Segmentation fault
• segfault
• core dumped

What your security team should do

• Prioritize inventory of Python 3.14+ and 3.15+ runtimes, including containers, virtual environments, CI/CD images, developer workstations, and automation hosts.
• Identify teams or services using Python remote debugging, `python -m asyncio ps`, `python -m asyncio pstree`, or profiling.sampling against privileged or production processes.
• Patch affected Python runtimes as soon as fixed branch releases are available from Python or OS/package vendors.
• Immediately restrict privileged remote debugging/introspection to trusted, isolated environments only; do not connect privileged Python processes to untrusted Python processes.
• Add detection for suspicious or privileged execution of Python asyncio introspection and profiling.sampling activity.
• Review recent crashes of privileged Python processes occurring around debugging or introspection sessions, as repeated crashes may indicate exploitation attempts.
• Ensure secrets are not unnecessarily resident in long-lived privileged Python process memory and rotate credentials if exploitation is suspected.
• Educate administrators and developers that debugging an untrusted Python process can endanger the debugger or privileged process, not just the debug target.