This security update for Apache2 addresses multiple vulnerabilities across various modules including mod_http2, mod_md, mod_vhost_alias, mod_auth_digest, mod_dav, and others. The issues range from denial of service, authentication bypass, use-after-free, buffer overflows, to potential remote code execution. The update also fixes a severe CPU usage regression and several stability and functionality bugs.
A vulnerability in the Go build toolchain (cmd/go) allows an attacker to achieve arbitrary code execution during the build process of a malicious package that uses cgo. This occurs because malicious linker flags can be forwarded to the host linker, enabling untrusted command execution. The issue affects development environments compiling untrusted Go code with cgo enabled. Deployed binaries and runtime environments running pre-compiled Go software are not affected. Mitigations include disabling cgo or isolating build environments.
A vulnerability (CVE-2026-97036) was identified in the Go programming language's cmd/go tool on macOS (Darwin) platforms. It allows an attacker to achieve arbitrary code execution on the build system when compiling a malicious package using cgo due to improper handling of linker flag arguments. This issue is specific to Darwin linker behavior and does not affect typical Red Hat Linux environments. Red Hat has released an update for Red Hat Hardened Images RPMs including golang1.26 packages. No direct fix for the vulnerability is available for Red Hat products as the issue does not impact their Linux-based toolchains.
The secmem-proc crate for Windows had a security issue in versions before 0.3.9 where the default Discretionary Access Control List (DACL) did not provide the intended protection. Processes running under the same user could reset the DACL, bypassing the intended security enhancement. This was due to using an explicit owner SID instead of the well-known "owner rights" SID, which Windows treats differently. The issue is fixed in version 0.3.9 by using the correct SID. Users with custom DACLs must update their code accordingly.
A vulnerability in GitPython's create_submodule function allows an attacker to execute arbitrary code by planting a malicious Git hook. The function clones a submodule into the repository's .git directory before validating the path, enabling an attacker to place an executable hook (e.g., post-checkout) in .git/hooks. This hook executes on subsequent Git operations, leading to code execution. Versions from 3.1.x through 3.2.0+ are affected, with 3.2.0+ raising a ValueError after cloning but not removing the planted hook. The issue is fixed in version 4.1.1.
CVE-2026-107378 is a denial-of-service vulnerability in CairoSVG affecting the parsing of SVG <path> elements with many segments. The vulnerability arises from quadratic-time complexity in the path-data tokenizer and marker handling code, causing excessive CPU usage when rendering crafted SVGs. This can lead to significant delays or service disruption when processing untrusted SVG inputs. The issue affects CairoSVG versions from 2.9.2 up to but not including 4.1.1 and is fixed in version 4.1.1.
CVE-2026-100689 is a path traversal vulnerability in GitPython 3.1.61 and main branch affecting the handling of the .gitmodules 'path' field during submodule update operations. The vulnerability arises because the 'path' field is used without proper containment checks, allowing an attacker to specify a path outside the repository directory. This can lead to directory creation and file operations outside the intended repository scope. The issue primarily affects non-HEAD commit submodule updates, as normal clone operations do not expose this flaw. A fix is available in GitPython version 4.1.1.
A Regular Expression Denial of Service (ReDoS) vulnerability exists in soupsieve's CSS selector parsing, specifically in the IDENTIFIER and VALUE sub-patterns. The flaw arises from adjacent quantified groups over overlapping character classes, causing quadratic backtracking on failing matches. This can be triggered by user-controlled CSS selectors with long identifier or attribute value runs that fail to match, leading to significant CPU consumption and delays. The vulnerability affects applications that accept user input for CSS selectors via soupsieve or BeautifulSoup's select methods. It is fixed in soupsieve version 2.12.1_3.
A Regular Expression Denial of Service (ReDoS) vulnerability exists in soupsieve's whitespace/comment trimming regex RE_WS_END. The regex is used unanchored with .search(), causing quadratic time complexity (O(n²)) on valid CSS selectors containing long runs of whitespace or comments not exactly at the string end. This can stall the interpreter for seconds on large inputs. The issue affects soupsieve versions from 2.9 up to but not including 2.12.1_3. A fix is available in version 2.12.1_3.
GitPython versions prior to 4.1.1 contain a Regular Expression Denial of Service (ReDoS) vulnerability in the Actor.name_email_regex pattern used to parse commit author and committer headers. The vulnerable regex causes catastrophic backtracking when processing a commit object with a long string containing an unterminated '<' character, leading to CPU exhaustion proportional to the square of the input length. This can block GitPython API calls that read commit metadata for extended periods, impacting CI runners, code-hosting backends, and repository scanning tools that process untrusted commits.
GitPython versions from 2.9.2 up to but not including 4.1.1 contain a vulnerability where the library misidentifies the git directory by prioritizing tracked files over the actual .git directory. This allows attacker-controlled repository content to impersonate the git directory, leading to arbitrary code execution via malicious hooks when a victim performs a commit using GitPython. Additionally, attackers can read sensitive files outside the repository and write config files to arbitrary locations. The issue is fixed in version 4.1.1.
GitPython 3.1.59 contains a vulnerability in its high-level diff API where the use of the --no-index option bypasses protections against unsafe git diff options. This allows an attacker who can influence diff options and file paths to perform a blind local-file content oracle, potentially disclosing local file contents. The issue arises because --no-index treats path arguments as arbitrary filesystem paths, and when combined with the -I/--ignore-matching-lines option, it creates a content-dependent Boolean oracle. The vulnerability was confirmed in version 3.1.59 and fixed in 4.1.1.
GitPython's TagReference.create() method improperly handles a positional 'reference' argument, allowing an attacker to bypass unsafe option guards and cause an arbitrary local file read. This occurs because the unsafe option check only inspects keyword arguments, ignoring positional arguments that can inject '--file=<path>' into git tag commands. The file contents are returned in the annotated tag message. This vulnerability affects GitPython versions prior to 4.1.0 and has a CVSS score of 6.5 (medium severity).
GitPython versions before 4.1.0 have an incomplete denylist for unsafe git revision options in the blame and blame_incremental methods. This allows an attacker controlling the revision argument to use the --contents or -S options to read arbitrary local files, as these options are not blocked by the denylist. The file contents are returned in the blame output at the privileges of the host process. A fix is available in version 4.1.0.
GitPython versions from 2.9.2 up to but not including 4.1.0 contain a vulnerability where the `--separate-git-dir` option is not blocked by the unsafe options denylist in the `Repo.clone_from()` and `Repo.clone()` APIs. This omission allows an attacker to specify an arbitrary filesystem path for the Git metadata directory during a clone operation, potentially creating files and directories outside the intended clone destination. The vulnerability arises from a parity gap between denylist configurations for `git init` and `git clone` commands, despite documentation stating that `--separate-git-dir` should be blocked by default. A fix is available in GitPython version 4.1.0.
GitPython versions from 2.9.2 up to but not including 4.1.0 contain a critical vulnerability (CVE-2026-78676) in their git config parser. The issue arises from improper handling of multi-line git config values during re-serialization, causing dormant multi-line values to be corrupted into live injected directives. This can lead to arbitrary code execution via the core.hooksPath configuration, which is honored by git hook-triggering operations. The vulnerability is due to asymmetric input validation: unsafe characters are blocked only on write arguments but not on values read from disk and later rewritten. A fix is available in version 4.1.0.
GitPython versions from 2.9.2 up to but not including 4.1.0 contain a vulnerability in the handling of the .gitmodules file, where the SubmoduleConfigParser follows [include] directives without restricting paths. This allows an attacker controlling the .gitmodules file to cause the parser to read arbitrary local files and expose their first line via exception messages. The issue arises because merge_includes is enabled by default and no containment checks are performed on included paths. A fix is available in version 4.1.0.
GitPython versions from 2.9.2 up to but not including 4.1.0 contain a vulnerability where an attacker-controlled submodule name in a cloned repository's .gitmodules file can cause GitPython to create and initialize a Git repository outside the intended working directory. This occurs because GitPython does not validate submodule names for path traversal sequences, allowing arbitrary filesystem paths for submodule Git directories. The vulnerability requires a victim to clone a malicious repository and run submodule initialization via GitPython. The issue is fixed in GitPython 4.1.0.