Python has added a denylist for known compromised certificates to the "ssl" module to ensure user safety even without certificate revocation configured. Known compromised certificates will automatically be rejected regardless of the SSLContext policy configuration.
tarfile.tar_filter could be bypassed using crafted link entries, including symlinks with empty or directory-like names, to redirect later archive members outside the intended extraction directory. This allowed a malicious tar archive to cause tarfile.extractall() with filter="tar" to write files outside the destination directory, subject to the permissions of the extracting process.
This is the tarfile.tar_filter counterpart of CVE-2026-7774, which covered tarfile.data_filter.
CVE-2026-19553 is a vulnerability in Python's CPython ssl module where SSLContext.wrap_bio() does not require the server_hostname argument to be non-None when SSLContext.check_hostname is enabled. This causes hostname verification to be silently skipped if server_hostname is not supplied, potentially leading to a false sense of security. The issue affects multiple Python versions prior to specific fixed releases. Mitigation does not require patching but involves passing a valid non-empty server_hostname to relevant APIs. The patch changes the behavior to raise a ValueError instead of silently skipping verification.
CVE-2026-19445 is a critical use-after-free vulnerability (CWE-416) in the Python CPython implementation affecting TLS servers that use the sni_callback to assign different SSL contexts per connection without retaining references to the original SSLContext. This can cause server crashes or calls through freed pointers. TLS clients are not affected. The vulnerability impacts multiple CPython versions prior to specific patched releases. Mitigation involves keeping a reference to every SSLContext that sets sni_callback for the server's lifetime.
CVE-2026-12345 is a medium severity vulnerability in the Python Software Foundation's CPython implementation. It involves a race condition in the cleanup of tempfile.TemporaryDirectory, where an attacker able to modify the directory tree during cleanup can replace a directory with a symbolic link. This can lead to deletion or permission and file flag resets on files outside the temporary directory, executed with the privileges of the cleanup process. The issue affects versions before 3.12.15, between 3.14.0 and 3.14.9, and between 3.15.0a1 and 3.15.0rc3. No known exploits are reported in the wild, and no official patch links are provided yet.
CVE-2026-82049 is a high-severity vulnerability in the tarfile module of CPython 3.13 and earlier. Crafted tar archives containing a hard link to a symbolic link can cause extraction to modify file permissions or modification times outside the intended destination directory, or expose the contents of files outside the extraction tree. This affects multiple CPython versions prior to specific patch releases.
CVE-2026-87910 is a medium severity vulnerability in the Python Software Foundation's CPython implementation related to the tarfile module. When extracting links on systems that do not support links, the filter function is called twice but the return value of one call is ignored, potentially allowing unintended extraction behavior. This issue affects multiple CPython versions prior to specific fixed releases.
CVE-2026-15310 is a low-severity vulnerability in CPython where decompressing specially crafted zip files using bzip, LZMA, or Zstandard compression methods can lead to memory exhaustion. This occurs because Python may use an attacker-controlled size to pre-allocate memory during decompression. The vulnerability affects multiple CPython versions prior to specific patch releases. No known exploits are reported in the wild, and no patch information is provided in the input data.
CVE-2026-19672 is a directory traversal vulnerability in the Python tarfile module affecting POSIX platforms. The issue allows creation of empty directories outside the intended extraction destination when member names contain path components that leave and then return to the destination directory. This does not affect Windows due to path normalization. Only empty directories are created outside the destination; file contents remain inside. The vulnerability affects CPython versions before 3.16.0 and has a medium severity rating with a CVSS score of 6.3.
CVE-2026-15806 is a vulnerability in the Python CPython urllib.request module where HTTPPasswordMgr classes did not consider the URL scheme when matching stored credentials. This caused credentials registered for HTTPS URLs to be sent over HTTP requests to the same host, exposing them to interception if an attacker could redirect or downgrade connections to plain HTTP. The issue is fixed by scoping credential matching to the URL scheme. Users unable to upgrade immediately should avoid making plain HTTP requests to hosts with stored credentials.
CVE-2026-17084 is a medium severity vulnerability in the Python Software Foundation's CPython implementation. The issue lies in the "stringprep" module, which incorrectly processes characters from RFC 3454 tables B.2 and B.3 by using the latest Unicode codepoint attributes instead of those from Unicode 3.2.0. This causes mismatches when handling domain names with the IDNA 2003 "idna" codec and the in_table_b2() function, particularly for domain names containing characters whose Unicode attributes have changed since Unicode 3.2.0.
Attacker-controlled CSV samples can trigger super-linear
regular-expression work during dialect sniffing and consume significant
CPU when applications pass unbounded input to csv.Sniffer.sniff().
`Element.findall()` and fully-consumed `Element.iterfind()` exhibit `O(n^2)` time complexity when using XPath index predicates (e.g. `[1]`, `[last()]`, `[last()-N]`) on XML documents with many same-tag siblings. `Element.find()` is only affected when the first match is near the end of the sibling list, such as with `[last()]` or `[last()-N]`; `.//item[1]` short-circuits after the first match.
The incremental HTML parser (html.parser.HTMLParser) allows for CPU
denial-of-service through repeated unterminated markup declarations when
processing uncontrolled data.
In the Tarfile.extract() function, the filter parameter is not passed properly when extracting hardlinks. An affected system that extracts content from untrusted tar files could end up writing files with an unexpected uid/gid despite the user passing filter='data' to the extract() function.
When using the "tarfile" module with a file opened in "streaming mode" (mode="r|") the tarfile module did not properly handle EOF, making archive parsing take exponentially longer.
When using the "configparser" module to write configuration files
containing multi-line text values with carriage return characters (\r) the
resulting file could be injected with unexpected keys and values if the
attacker controls the written value.
tarfile.extractall() with the 'data' or 'tar'
filter could be bypassed by a crafted archive where a hardlink
references a symlink stored at a deeper name than the hardlink itself.
The extraction fallback validated the symlink at it's archived location
but recreated it at the hardlink's shallower
path, letting a relative
target the filter judged contained escape the destination directory.
This allowed a malicious tar archive to create a symlink pointing
outside the destination, enabling out-of-destination file reads or
writes. This was an incomplete fix of CVE-2025-4330.
To allow builds of Python to be run from an in-tree layout (rather than
an installed file layout), the VPATH variable is defined at build time
and used to locate certain landmarks - specifically,
Modules/setup.local. When this landmark is found relative to VPATH
relative to the executable, Python assumes it is running in a source
tree and generates a different default sys.path. This code remains in
release builds, so that release-ready builds can be built in-tree.
On Windows, since builds are written to 'PCbuild/', the value of
VPATH is set to '..\..', which results in a landmark of
'..\..\Modules\setup.local'. This path is outside the install directory
of Python, and may have different permissions, potentially allowing a
low-privilege user to create the landmark and an alternative `Lib`
folder that will be discovered by an otherwise restricted install.
Such a setup occurs with the legacy default install location for all
users (in the now superseded EXE installer), due to how Windows allows
all users to create folders in the root directory of their OS drive.
Our recommended mitigation on Windows is to migrate away from the
legacy installer and use the new [Python install
manager](https://www.python.org/downloads/latest/pymanager/) to install
for the current user. Installs where the directory two levels above the
Python installation directory have equivalent permissions are unaffected
(in general, a per-user install cannot be modified at all by other
users, removing any escalation of privilege risk, and could be directly
modified by a privileged user, making the potential tampering
irrelevant). Alternative mitigations might include preemptively creating
and restricting access to a `Modules` directory. Be aware that only 3.13
and 3.14 will receive updated legacy installers - earlier fixes are only
provided as sources.
Platforms other than Windows allow VPATH to be overridden, but as they
don't usually use a separated directory in the build for binaries, are
unlikely to have a landmark reference outside of the install directory.
The landmark detection involving VPATH is a fallback for when a more
specific landmark - .\pybuilddir.txt - is absent, and was included for
compatibility. Future releases of Python will no longer include the
fallback, and so builds will need to generate or preserve the
pybuilddir.txt file in order to work in-tree. This landmark file has
been generated on Windows since 3.11, and on other platforms for longer.