Seth Larson

When tarfile or zipfile command line interface (CLI) is used to decompress an archive, a Python script shadowing the stdlib can be created. Then if an error occurs during decompressing the next file, the newly created Python script is executed. This is especially true if the created Python is called traceback.py. The problem is that Python adds the current directory to sys.path when python -m MODULE is run, and the archive is also decompressed in the current directory. The fix removes sys.path[0] in gzip, tarfile and zipfile command line interface to prevent shadowing standard library modules from extracted files.

IMAP4.starttls() wraps the socket in TLS but leaves self. readbuf, imaplib's own read-ahead buffer, untouched. Any plaintext bytes that arrived in the same recv() as the tagged OK to STARTTLS are returned by readline() after the handshake, so the client treats them as the first responses on the protected channel. A network attacker who cannot break TLS can append forged lines after the server's OK, let the handshake complete with the real server and a valid certificate, and have the client accept the forged CAPABILITY and the forged tagged completion of the next command. This is the STARTTLS command/response injection class of CVE-2011-0411.

When ca certs parameter was supplied to ssl.get server certificate() function, the identity of the certificate is not checked.

There was a regression in how FIPS algorithms were enforced for the hashlib module. Only users that are using OpenSSL in FIPS mode are affected. Only Python 3.14.10 is affected, all other Python versions are unaffected.

The `socket.getaddrinfo()` function accepts null bytes within the `host` and `port` parameters, which may lead to the values being silently truncated.

Response body and chunk parsing handle non-hex or negative integers incorrectly, which can lead to the misinterpretation of HTTP response contents.

The `ssl` module fails to distrust known compromised intermediate certificates. To address this, a denylist of compromised certificates has been implemented to ensure that these certificates are automatically rejected, regardless of the `SSLContext` policy configuration, even when certificate revocation is not configured.

A remote, unauthenticated TLS client can cause a server to crash or trigger a use-after-free condition (where the system attempts to use a memory pointer after it has been freed) if the `sni callback` assigns a different context to `SSLSocket.context` and the original `ssl.SSLContext` is not kept alive. This typically occurs in servers that replace the context while connections are open or create an `SSLContext` per connection. Servers that wrap their listening socket are not affected.

The `ssl.SSLContext.wrap bio()` function fails to require the `server hostname` argument to be non-null when `ssl.SSLContext.check hostname` is enabled. Due to a missing parameter check in `SSLObject`, if the `server hostname` argument is not provided, hostname verification is silently skipped. This can lead to scenarios where certificate hostname verification appears to succeed despite misconfiguration, as no `ValueError` is raised. This issue also affects `asyncio.create connection()` and `asyncio.loop.start tls()`. If a `server hostname` value that is neither an empty string nor None is passed to these APIs, verification proceeds normally.

The `stringprep` module incorrectly processes characters from RFC 3454 tables B.2 or B.3 by using the latest Unicode codepoint attributes instead of the required Unicode 3.2.0. This leads to mismatches when processing domain names via the `idna` codec (IDNA 2003) and the `in table b2()` function. The issue specifically impacts domain names containing characters that were either not registered or had their Unicode attributes, such as case-folding behavior, updated after Unicode 3.2.0.

Attacker-controlled CSV samples can trigger super-linear regular-expression work during dialect sniffing, leading to significant CPU consumption when applications pass unbounded input to the `csv.Sniffer.sniff()` function. Super-linear regular-expression work refers to a condition where the time taken to process a string increases disproportionately to the length of the input, potentially causing a denial of service.

The incremental HTML parser `html.parser.HTMLParser` contains an issue that allows for CPU denial-of-service when processing uncontrolled data. The root cause is improper input handling that leads to pathological parsing behavior, specifically algorithmic complexity and resource exhaustion, when markup declarations are repeatedly left unterminated. An attacker can exploit this by providing crafted HTML to any service or pipeline using `HTMLParser`, which can result in CPU core exhaustion and the degradation or complete failure of affected applications.

In the `extract()` function of the Tarfile module, the `filter` parameter is not correctly handled when extracting hardlinks. This issue allows a system extracting content from untrusted tar files to write files with an unexpected uid/gid, even when the user has specified `filter='data'` to restrict the extraction process.

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 an attacker controls the written value.

The `tarfile.data filter` can be bypassed using crafted link entries, such as symlinks with empty or directory-like names. This allows a malicious tar archive to redirect subsequent archive members outside the intended extraction directory, causing the `tarfile.extractall()` function to write files to arbitrary locations on the system, depending on the permissions of the process performing the extraction.

The `unicodedata.normalize()` function can consume excessive CPU time when processing specially crafted Unicode input. This occurs when the input contains long sequences of combining characters with alternating Canonical Combining Class values, affecting all normalization forms.

On Windows, the `shutil.unpack archive()` function fails to properly check for absolute paths within ZIP archives. If an archive contains a path with a drive letter (e.g., `C:`), files may be extracted outside of the intended target directory.

The self-update check functionality runs after installing wheel files, which requires importing well-known Python module names. These imports were deferred to improve the startup time of the pip CLI. This behavior allows newly installed modules to be imported shortly after the installation of a wheel package.

The `js output()` function within `http.cookies.Morsel` returns an inline `<script>` snippet that only escapes double quotes for JavaScript string context. It fails to neutralize the `</script>` sequence, which is sensitive to the HTML parser, allowing for potential escaping within the generated script element.

On Windows systems, the `sock recvfrom into()` function within `asyncio.ProacterEventLoop` lacks a boundary check for the data buffer when the `nbytes` parameter is used. This flaw can lead to an out-of-bounds buffer write if the received network data exceeds the buffer size, potentially resulting in memory corruption, system crashes, or arbitrary code execution. Non-Windows platforms are not affected.