Threats affecting pkg:bitnami/proxysql
264,920 threats
Most recently published first
| Severity | CVSS | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|
| High | 8.7 | High8.7GCVE DatabaseCVE-2026-128131 CVE-2026-128131 is a vulnerability in aiohttp where decompressing concatenated compressed streams (gzip, deflate, or zstd) causes excessive CPU usage due to quadratic time complexity. This can block the event loop of servers or clients when processing specially crafted compressed payloads. | GCVE Database | ||
| High | 8.3 | CVE-2026-128130AIOHTTP · Pure-Python parser request replay and buffer growth behind a declined upgrade High8.3GCVE DatabaseCVE-2026-128130 A vulnerability in AIOHTTP's pure-Python HTTP parser causes the request buffer to grow uncontrollably and previously handled pipelined requests to be replayed after a declined upgrade request. This affects users relying on the Python parser instead of the default C parser. The issue can lead to excessive memory consumption and repeated processing of requests. | GCVE Database | ||
| High | 8.2 | High8.2GCVE DatabaseCVE-2026-128129 CVE-2026-128129 is a vulnerability in aiohttp where data received during an HTTP upgrade request (such as a WebSocket handshake) is buffered without any size limit or flow control until the handler completes. This can lead to unbounded memory consumption if an attacker streams large amounts of data behind the upgrade request to a handler that does not promptly accept or reject the upgrade. | GCVE Database | ||
| High | 7.5 | CVE-2026-128128AIOHTTP · WebSocket max_msg_size bypass via integer overflow High7.5GCVE DatabaseCVE-2026-128128 A vulnerability in AIOHTTP's WebSocket implementation allows bypassing the max_msg_size limit due to an integer overflow in the C extension's 64-bit arithmetic. This flaw permits an attacker to send an oversized WebSocket message after a small non-final fragment, causing unbounded memory consumption. | GCVE Database | ||
| High | 8.7 | CVE-2026-128127AIOHTTP · Base64 multipart parts bypass client_max_size High8.7GCVE DatabaseCVE-2026-128127 A vulnerability in aiohttp's multipart handling allows bypass of the client_max_size limit when processing parts with Content-Transfer-Encoding: base64. This can lead to excessive memory consumption or event loop blocking due to unbounded reading of multipart data. | GCVE Database | ||
| High | 8.7 | High8.7GCVE DatabaseCVE-2026-128126 CVE-2026-128126 is a vulnerability in aiohttp's Request.post() method where there is no limit on the number of URL-encoded form fields. This allows an attacker to send a form POST with many repeated keys, causing quadratic time complexity in processing and blocking the event loop. The issue affects versions of ansible starting from 13.8.0. A patch is available that addresses this problem. | GCVE Database | ||
| Medium | 6.3 | CVE-2026-128125AIOHTTP · Unbounded cookie storage in client CookieJar Medium6.3GCVE DatabaseCVE-2026-128125 AIOHTTP's client CookieJar component improperly parses Set-Cookie headers, creating extra cookies from unrecognized name=value attributes without limiting the number of cookies stored or sent. This allows a malicious server to cause a client to store an excessive number of cookies, leading to very large Cookie headers and potential resource exhaustion. | GCVE Database | ||
| High | 8.2 | CVE-2026-128124AIOHTTP · Event loop stall in add_domain() wildcard matching High8.2GCVE DatabaseCVE-2026-128124 A vulnerability in AIOHTTP's Application.add_domain() function causes the event loop to stall when matching domain masks containing two or more wildcards against long Host headers. This results in polynomial-time processing that can be exploited by an attacker to stall the server. The issue affects versions 13.8.0 and later. A workaround is to limit domain masks to at most one wildcard. A patch addressing this issue has been published. | GCVE Database | ||
| High | 8.7 | High8.7GCVE DatabaseCVE-2026-128132 ### Summary The WebSocket reader continued parsing frames already received after the receive queue had paused the transport, and empty messages were not counted towards the queue size. With permessage-deflate, a single read of compressed frames could add many megabytes of decompressed messages to the queue. ### Impact An attacker could cause excessive memory use in a WebSocket server, or a malicious server against a client, by sending many small or compressed messages faster than the application consumes them. --- Patch: https://github.com/aio-libs/aiohttp/commit/0ae507423f681161efa77d20052b4054397c7fb6 | GCVE Database | ||
| High | 7.8 | CVE-2026-128134Gptline: NLTK dot2img runs Graphviz 'dot' without the trusted-exec chokepoint, enabling local code execution via a High7.8GCVE DatabaseCVE-2026-128134 ## Summary `nltk.parse.dependencygraph.dot2img` invokes the Graphviz `dot` executable without the trusted-execution guarantees that NLTK applies to its other native-tool wrappers. The function resolves `dot` by bare name and then runs the resolved absolute path with a raw `subprocess.run`, omitting the ownership/writability check and the loader-environment scrub that `nltk.pathsec.spawn_trusted` provides. On a POSIX host, a local, unprivileged actor who can write to any group/world-writable directory that appears on the victim's `PATH` can plant a trojan `dot`; when the victim later renders a `DependencyGraph` (for example in a Jupyter notebook, which auto-invokes `_repr_svg_`) or calls `dot2img` directly, the planted binary executes as the victim. The advisory GHSA-6hwm-xvph-95vm (CVE-2026-78680) addressed the same untrusted-search-path class for the Graphviz `dot` invoker in `nltk/translate/api.py`, but `dot2img` received only part of that remediation and remains exploitable. ## Root Cause NLTK's native-tool security model layers four defenses (documented in `nltk/EXTERNAL_TOOL_SECURITY.md`): (1) `find_binary` refuses a current-working-directory-relative match; (2) `resolve_trusted_executable` verifies the resolved file is a regular file that no other unprivileged user can replace (private parent directories, owner is the user or root, no group/world write bit); (3) shell execution is refused; (4) `safe_env` scrubs loader and interpreter environment variables before exec. Layers 2, 3, and 4 are reached only through `nltk.pathsec.spawn_trusted`. `dot2img` calls `find_binary("dot")` (layer 1 only), then executes the result with `subprocess.run([dot_binary, ...])` and no `env=` argument. Layer 1 rejects only non-absolute matches, so an absolute path returned by the `which` search stage survives even when the file lives in a writable directory. Because `dot2img` never calls `spawn_trusted`, the ownership check and environment scrub never run. ```text nltk/parse/dependencygraph.py:626 dot_binary = find_binary("dot") # layer 1 only nltk/parse/dependencygraph.py:631 subprocess.run([dot_binary, "-T%s" % t], ...) # no trust check, no env= nltk/parse/dependencygraph.py:638 subprocess.run([dot_binary, "-T%s" % t], ...) # binary-format branch, same gap nltk/internals.py:1034 if searching_bare_name and not os.path.isabs(path): continue # skips only relative matches nltk/translate/api.py:145 process = spawn_trusted(dot_binary, [f"-T{output_format}"], ...) # hardened sibling ``` ## Impact Prerequisites: a POSIX host on which the attacker is a local, unprivileged user (or code) able to write to a group/world-writable directory that appears on the victim's `PATH`. This includes the commonly cited case of a Homebrew `/usr/local/bin` with `drwxrwxr-x` permissions, or a writable directory placed early on `PATH`. The attacker plants a trojan `dot` there. When the victim renders a `DependencyGraph` (notebook `_repr_svg_` auto-invocation) or calls `dot2img` directly, the trojan executes as the victim, yielding arbitrary local code execution in the victim's account: a local privilege-escalation and lateral-movement primitive. Because the child environment is not scrubbed, loader-injection variables (for example `LD_PRELOAD`, `DYLD_*`, `GCONV_PATH`) also reach the child, providing an additional execution surface. No control over NLTK inputs is required. ## Proof of Concept `Requires: POSIX host, an importable NLTK build from the affected tree, and Python 3. No third-party dependencies.` 1. Create a world-writable directory and write an executable `dot` script into it that drops a marker and emits fake SVG. 2. Prepend that directory to `PATH` and run from a neutral working directory (so this is not the current-working-directory vector). 3. Show that `resolve_trusted_executable` refuses the planted binary (so the hardened path would raise) while `dot2img` executes it. ```python import os, stat, tempfile, subprocess, sys d = tempfile.mkdtemp() dot = os.path.join(d, "dot") with open(dot, "w") as f: f.write("#!/bin/sh\ntouch " + os.path.join(d, "MARKER") + "\necho '<svg><!-- planted dot ran --></svg>'\n") os.chmod(dot, 0o777) os.chmod(d, 0o777) os.environ["PATH"] = d + os.pathsep + os.environ["PATH"] os.chdir("/") from nltk.pathsec import resolve_trusted_executable from nltk.parse.dependencygraph import dot2img print("resolve_trusted_executable(planted dot):", resolve_trusted_executable(os.path.join(d, "dot"))) out = dot2img("digraph G { a -> b }") print("dot2img stdout:", repr(out)) print("planted dot executed (marker created):", os.path.exists(os.path.join(d, "MARKER"))) ``` ```text resolve_trusted_executable(planted dot): None dot2img stdout: '<svg><!-- planted dot ran --></svg>\n' planted dot executed (marker created): True ``` ## Attack Chain 1. **Exposure:** On a shared POSIX host, a group/world-writable directory is present on the victim's `PATH` (for example a writab | GCVE Database | ||
| Medium | 4.8 | CVE-2026-126302gptline · NLTK: Symlink escape Medium4.8GCVE DatabaseCVE-2026-126302 ## Summary `nltk.sem.chat80.sql_query()` opens a SQLite database by handing the result of `nltk.data.find(dbname)` straight to `sqlite3.connect()` without the path-containment check that the NLTK data sandbox (`nltk.pathsec`) is meant to enforce. `nltk.data.find()` applies only lexical checks to the resource name and returns a `FileSystemPathPointer` whose path is normalized with `os.path.abspath` but never resolved for symlinks. As a result, an in-root symbolic link that points at a SQLite file outside every registered NLTK data root is followed by SQLite, and the caller receives query results from the out-of-sandbox database. An attacker who can place a file inside a directory the application trusts as an NLTK data root can read SQLite databases that the pathsec sandbox is supposed to keep out of reach. ## Root Cause The security invariant is that file access performed through NLTK data resolution must stay within the configured data roots; the sandbox enforces this in `nltk.pathsec` via `validate_path` and `pathsec.open`, which resolve the real path (`Path(...).resolve()`) and reject targets outside the allowed roots. `sql_query()` never reaches that enforcement point. It calls `nltk.data.find(dbname)`, whose guards operate purely on the resource-name string, and `FileSystemPathPointer.__init__` performs only `os.path.abspath` plus an existence check, which does not collapse symlinks. The pointer is then passed to `sqlite3.connect(str(path))`, so the containment decision that `FileSystemPathPointer.open()` would delegate to `pathsec.open` is bypassed entirely. The sibling functions in the same module that create or write databases (`cities2table`, `val_dump`, `val_load`) obtain their protection from a validation call in later development, but the read sink `sql_query` performs no equivalent check in any published release. ```text nltk/sem/chat80.py -> sql_query(): path = nltk.data.find(dbname); sqlite3.connect(str(path)) nltk/data.py -> find(): lexical name guards only; returns FileSystemPathPointer nltk/data.py -> FileSystemPathPointer.__init__(): os.path.abspath + os.path.exists (no symlink resolution) nltk/data.py -> FileSystemPathPointer.open() -> nltk.pathsec.open (the containment guard that sql_query never calls) ``` ## Impact An attacker who can write into a directory the application registers as an NLTK data root (a shared or writable corpus directory, or a downloaded corpus) can plant a symbolic link at the expected resource location that points at a SQLite database elsewhere on the filesystem. When the application invokes `sql_query()` (directly or via `sql_demo()`) for that resource, SQLite follows the link and the query executes against the out-of-sandbox database, returning its rows to the caller. This escapes the pathsec confidentiality boundary. The read primitive is bounded to SQLite-format files that are readable by the process user: a non-SQLite target raises `sqlite3.DatabaseError` rather than leaking content. A caller-supplied write query would be redirected onto the out-of-sandbox target and SQLite may create sidecar files (`-wal`, `-journal`) next to it, which is a plausible integrity side effect rather than a demonstrated arbitrary-write primitive. Exploitation requires the same local write capability into a trusted data root as the related symlink-read sandbox-escape issues already recorded for this project. ## Proof of Concept `Requires the published nltk 3.10.3 wheel and a writable directory registered as an NLTK data root. No network access is needed.` 1. Create a throwaway data root with the expected corpus subdirectory. 2. Create a SQLite database outside that root and populate it. 3. Plant an in-root symbolic link at `corpora/city_database/city.db` pointing at the outside database. 4. Register the data root and call `sql_query()` for the in-root resource name. ```python import os, tempfile, sqlite3, nltk, nltk.data from nltk.sem import chat80 work = tempfile.mkdtemp() root = os.path.join(work, "nltk_data") corp = os.path.join(root, "corpora", "city_database") os.makedirs(corp) secret = os.path.join(work, "outside", "secret.db") os.makedirs(os.path.dirname(secret)) con = sqlite3.connect(secret) con.execute("CREATE TABLE t (x text)") con.execute("INSERT INTO t VALUES ('OUT-OF-SANDBOX-SECRET')") con.commit(); con.close() os.symlink(secret, os.path.join(corp, "city.db")) nltk.data.path.insert(0, root) ptr = nltk.data.find("corpora/city_database/city.db") try: ptr.open().read() # pathsec route: blocked except Exception as e: print("open() blocked:", type(e).__name__) cur = chat80.sql_query("corpora/city_database/city.db", "SELECT * FROM t") print("sql_query rows:", cur.fetchall()) # sink route: follows the symlink ``` ```text open() blocked: PermissionError sql_query rows: [('OUT-OF-SANDBOX-SECRET',)] ``` ## Attack Chain 1. **Exposure:** The application exposes `sql_query()` (or `sql_demo()`, which calls it) and resolve | GCVE Database | ||
| Medium | 6.3 | CVE-2026-126296NLTK · Path Traversal in save_maxent_params / load_maxent_params Allow Arbitrary File READ/WRITE Medium6.3GCVE DatabaseCVE-2026-126296 ### Summary Path traversal in NLTK's save_maxent_params() and load_maxent_params() allows arbitrary file write and arbitrary file read outside the directories permitted by NLTK's pathsec security mechanism. This vulnerability was previously reported through Huntr, accepted by the NLTK project, and assigned CVE-2026-15367. A $750 bounty was paid through Huntr (i didnt get the fix bounty). Huntr subsequently shut down its OSS vulnerability program, so I am submitting this report through GitHub to continue the existing disclosure process and preserve the original CVE assignment and researcher credit. ### Details The affected functions are: - nltk.classify.maxent.load_maxent_params() - nltk.classify.maxent.save_maxent_params() Both functions construct filesystem paths from the caller-controlled tab_dir argument and access them using Python's built-in open() without passing the paths through NLTK's pathsec validation. For example, load_maxent_params() constructs and opens: - <tab_dir>/weights.txt - <tab_dir>/mapping.tab - <tab_dir>/labels.txt - <tab_dir>/alwayson.tab Similarly, save_maxent_params() creates/writes files under the supplied tab_dir. This bypasses the security boundary provided by nltk.pathsec. NLTK documents pathsec as the mechanism for restricting filesystem access to permitted roots, with strict enforcement intended to prevent unauthorized filesystem access. The relevant implementation is in: nltk/classify/maxent.py The affected functions can be found in the model parameter loading/saving section of that file. This issue was previously disclosed through Huntr and accepted before the Huntr OSS program was shut down. The original Huntr report was assigned CVE-2026-15367 and received a $750 bounty. I am therefore submitting this GitHub Security Advisory primarily as a continuation/transfer of the existing disclosure rather than as a new vulnerability report. ### PoC The issue can be reproduced by enabling NLTK's path security enforcement and supplying a tab_dir outside the permitted root. For example, with a controlled test environment: ```py import os import tempfile import nltk.pathsec as pathsec from nltk.classify.maxent import load_maxent_params, save_maxent_params pathsec.ENFORCE = True allowed_dir = tempfile.mkdtemp() outside_dir = tempfile.mkdtemp() # The same outside-root path is rejected when accessed through pathsec. try: with pathsec.open(os.path.join(outside_dir, "test.txt"), "w") as f: f.write("test") except Exception as e: print("pathsec.open rejected outside-root access:", type(e).__name__) # The vulnerable model-parameter APIs directly use open() # on paths derived from tab_dir. # # Supplying outside_dir as tab_dir causes the functions to access # files under outside_dir rather than enforcing the pathsec boundary. ``` For save_maxent_params(), the attacker-controlled tab_dir determines where the model parameter files are written. For load_maxent_params(), the attacker-controlled tab_dir determines which files are read. The important security property being bypassed is that pathsec.ENFORCE = True does not protect these file operations because the affected functions call the built-in open() directly rather than the pathsec-aware file-opening mechanism. ### Impact This is a path traversal / filesystem sandbox bypass resulting in arbitrary local file read and arbitrary local file write. Applications that use NLTK's pathsec mechanism as a filesystem security boundary may incorrectly assume that model parameter loading and saving are restricted to approved directories. An attacker who can influence the tab_dir argument may therefore: - read files outside the permitted NLTK data directories through load_maxent_params(); - create or overwrite files outside the permitted directories through save_maxent_params(); - bypass the filesystem containment provided by nltk.pathsec. The practical impact depends on how an application exposes these APIs and what filesystem permissions the NLTK process has. ### Existing CVE / Disclosure History CVE: CVE-2026-15367 This vulnerability was previously reported and accepted through Huntr before the Huntr OSS vulnerability program was shut down. The report received a $750 bounty and a CVE was reserved. I am submitting this report because the original Huntr disclosure workflow is no longer available and the CVE has not yet been published. Please associate this report with CVE-2026-15367 rather than assigning a new CVE, unless the NLTK maintainers determine that the existing CVE does not correspond to this issue. ## Fix status (2026-09-28) Status: MERGED on develop. The load side is in every release since 3.9.4 (including v3.10.3); the save side is on develop and unreleased. Fix commits: f2556f9e1 (load_maxent_params reads through open_datafile on a PathPointer whose open is pathsec.open; contained in tag 3.9.4 and every later tag) and 2a92b7182 (save_maxent_params validates tab_dir and writes every parameter | GCVE Database |
Page 26 of 13,246 · 8 duplicate CVE records merged