Starlette, a Python web framework used by Esphome and FastAPI, has a denial of service vulnerability (CVE-2024-47874) related to handling multipart/form-data requests. Specifically, parts without a filename are buffered in memory without size limits, allowing attackers to upload arbitrarily large form fields. This can cause excessive memory consumption, leading to server slowdowns, swapping, or process termination due to out-of-memory (OOM) errors. Multiple parallel requests exacerbate the impact, potentially rendering services unusable even behind reverse proxies with request size limits. The issue affects versions of Esphome built on Starlette from 2022.1.2 up to but not including 2023.10.0, and from 2024.2.1 up to but not including 2025.4.0. Fixed versions are 2023.10.0 and 2025.4.0.
CVE-2024-24762 is a Regular Expression Denial of Service (ReDoS) vulnerability in the python-multipart library used by dstack and frameworks like FastAPI when parsing HTTP Content-Type headers in form data. An attacker can craft a malicious Content-Type header that causes the regex parser to consume excessive CPU resources, stalling the server's main event loop and causing denial of service. This vulnerability affects applications that parse form data with python-multipart but not JSON payloads. The issue is fixed in python-multipart version 0.14.0_2.
GitPython versions up to 3.1.50 contain a vulnerability where the Repo.clone_from() method passes the remote URL through os.path.expandvars(), causing environment variables in the URL to be expanded server-side. This allows an attacker controlling the URL to exfiltrate environment variables such as AWS_SECRET_ACCESS_KEY or GITHUB_TOKEN by embedding them in the URL, which is then sent over the network to an attacker-controlled host. The vulnerability affects all non-Cygwin platforms and is due to polish_url() applying environment variable expansion indiscriminately to remote URLs. A fix is available in version 2.16.0_11.
CVE-2026-69244 is a high-severity vulnerability in AIOHTTP's C HTTP response parser that causes an out-of-bounds heap read when handling malformed chunked responses. This flaw can be triggered by an attacker-controlled server or accidental malformed responses, potentially leading to a denial of service (DoS) in the client. The issue affects ansible versions from 14.0.0 up to but not including 14.2.0_1. A patch is available in version 14.2.0_1. As a workaround, users can disable the C extension parser by setting the environment variable AIOHTTP_NO_EXTENSIONS=1 to use the unaffected Python parser.
The npm package datetime-fmt-xutil version 1.0.0 contains malicious code in its postinstall.js script. This script opens a TCP connection to a hardcoded IP address and pipes a shell to the remote endpoint, granting interactive shell access to an attacker. The malicious behavior executes unconditionally during npm install and uses fallback methods with bash and python3 to establish the reverse shell. Failures are reported via HTTP GET requests to the attacker's server. The package's legitimate date-formatting functionality is a cover for this reverse-shell payload.
The atomic-agents-stack dashboard HTTP server has a path traversal vulnerability in its file serving component. It constructs filesystem paths directly from HTTP request paths without proper containment checks, allowing attackers to read arbitrary files outside the intended directory. By default, the server binds to loopback, but it can be configured to bind to all interfaces, exposing the vulnerability to the LAN. This flaw affects all versions prior to 1.1.0. A fix is available that enforces safe path resolution and restricts host binding.
Untrusted data inclusion in PostgreSQL psql COPY may allow a server administrator to elicit execution of data lines as psql commands, via error injection. If the "COPY FROM STDIN" or "\copy FROM STDIN" command fails before the server indicates that it awaits input rows, psql processes the in-line data rows as psql commands. "COPY FROM" with a filename is unaffected. The server administrator has no inherent control over the data rows, so a complete attack requires the attacker to separately acquire control of both the server and the data rows. Alternatively, an attacker controlling data rows alone might complete an attack through a coincidental error that they don't control. Versions before PostgreSQL 18.6, 17.11, 16.15, 15.19, and 14.24 are affected.
Flowise before 3.1.3 contains a sandbox escape vulnerability in pythonCodeValidator.ts that fails to block native Pandas DataFrame methods like to_csv, to_json, pipe, and query. Authenticated attackers can exploit this to exfiltrate uploaded CSV data or write arbitrary files to the server filesystem.
JupyterLab versions 4.1.0 through 4.5.9 and 4.6.0 through 4.6.1 contain a vulnerability that allows authenticated users to bypass plugin manager lock rules. This bypass is due to two server-side enforcement gaps, enabling users to enable or disable plugins that administrators have locked, including child plugins and those locked via the 'lock all' mechanism. The vulnerability can undermine data integrity and bypass restrictions such as download or upload limits enforced through locked plugins. The issue is fixed in versions 4.5.10 and 4.6.2.
MCP Atlassian is a Model Context Protocol (MCP) server for Atlassian products (Confluence and Jira). Prior to 0.22.0, confluence_upload_attachment passes its client-supplied file_path directly to open(file_path, "rb") in src/mcp_atlassian/confluence/attachments.py through _upload_attachment_direct() without calling validate_safe_path. An authenticated MCP client can read any file accessible to the server process and exfiltrate it to Confluence as an attachment. If an AI agent can be induced to call the tool through untrusted content, the same flaw can disclose server environment variables such as CONFLUENCE_API_TOKEN and other credentials. This issue is fixed in version 0.22.0.
A missing bounds check when parsing stored procedure parameter metadata in the MongoDB BI Connector ODBC Driver can result in an out-of-bounds write in the client application process. Triggering this issue requires control over the server the driver connects to, or the ability to respond in its place, in order to return malformed metadata. The resulting memory corruption may cause the client application to terminate abnormally or, under certain conditions, execute unintended code.
MCP-for-Stata is a MCP server for integrating Stata into agent loops with a safety-first design. Prior to version 1.19.0, the ado_package_install MCP tool in stata-mcp concatenates user-controlled input directly into a Stata command string without any validation or sanitization. An attacker who can invoke the MCP tool or the equivalent Python API can embed newline characters in the package argument to inject arbitrary Stata commands. Because Stata supports a shell escape command, this leads to full OS-level arbitrary command execution (RCE) under the account running the Stata-MCP server. The tool is registered in the default all profile, so no non-default configuration is required. This issue has been patched in version 1.19.0.
**CVE:** This vulnerability corresponds to [CVE-2026-72801](https://nvd.nist.gov/vuln/detail/CVE-2026-72801).
### Summary
Two `CheckAuth`-only endpoints disclose the complete offline attack material for the encrypted-notebook master password, plus the wrapped per-notebook key needed to use it. Both are reachable by the publish `RoleReader` token and by the anonymous account when `Publish.Auth.Enable` is `false`. An unauthenticated remote client can retrieve the Argon2id salt and cost parameters, a verifier that confirms a correct password offline, and the encrypted per-notebook data key reducing the security of every encrypted notebook to the master password's resistance to offline GPU cracking.
### Details
**(1) `POST /api/system/getConf` leaks `NotebookCrypto`.**
`getConf` → `GetMaskedConf()` marshals the full configuration including `NotebookCrypto *conf.NotebookCrypto` (JSON tag `notebookCrypto`, not `-`, so it survives the deep copy). For non-administrators `HideConfSecret()` is applied, which nulls a dozen secret-bearing fields like AI, MCPOAuth, Api, Flashcard, Publish, Repo, Sync, Secrets, Variables, System paths but contains **no reference to `NotebookCrypto`**. `FilterConfByPublishIgnore()` for readers only touches `UILayout`.
The reader therefore receives:
| Field | What it is |
|---|---|
| `MasterSalt` | global Argon2id salt |
| `KDFParams` | Argon2id memory/time/parallelism cost |
| `KEKVerifier` + `VerifierNonce` | AES-GCM-encrypted fixed magic, the in-code comment states it exists for offline master-password verification |
| `KEKMAC` | HMAC-SHA256 of the KEK |
Either `KEKVerifier` or `KEKMAC` is a self-contained offline oracle:
```
KEK = Argon2id(guess, MasterSalt, KDFParams)
correct if AES-GCM-decrypt(KEKVerifier, VerifierNonce) == magic
or HMAC(KEK) == KEKMAC
```
No server round-trips are required, so there is no rate limiting, lockout, or logging on guesses, and the work is fully GPU-parallelisable.
**(2) `POST /api/notebook/getNotebookConf` leaks the wrapped data key.**
`box.GetConf()` returns the full `BoxConf` including `BoxCrypt.WrappedDEK`, the per-notebook data-encryption key wrapped under the KEK via AES-GCM together with `WrapNonce`. `getNotebookInfo` is the same class. Once (1) yields the master password, the attacker derives the KEK, decrypts `WrappedDEK` to recover the real data-encryption key, and decrypts every `.sy` file in that notebook.
**Why this matters beyond the at-rest threat model.** Storing verifier and KDF material alongside the ciphertext is reasonable against a *local* attacker who already has filesystem access. Serving `MasterSalt` + `KDFParams` + `KEKVerifier` + `WrappedDEK` to an *anonymous remote reader* converts that at-rest assumption into a remote pre-authentication cracking opportunity.
**Guarded-sibling asymmetry.** `HideConfSecret` nulls a dozen secret fields but omits `NotebookCrypto`. `lsNotebooks` filters notebook visibility for readers, while `getNotebookConf` and `getNotebookInfo` apply no reader filter at all.
Verified at `origin/master` (`eef105683`): handler bodies as described; `HideConfSecret` contains zero `NotebookCrypto` matches; `FilterConfByPublishIgnore` touches only `UILayout`; all relevant struct JSON tags are non-`-`; all three routes are registered `CheckAuth` without `CheckAdminRole`.
### Proof of Concept
Precondition: publish mode enabled (default port 6808) with at least one encrypted notebook configured; anonymous when `Publish.Auth.Enable` is `false`, otherwise any publish reader account.
**1. Retrieve the key-derivation material as an anonymous reader:**
```
POST http://127.0.0.1:6808/api/system/getConf
{}
```
The response's `notebookCrypto` object contains `MasterSalt`, `KDFParams`, `KEKVerifier`, `VerifierNonce`, and `KEKMAC` while the same response has the other secret fields (Api, Repo, Sync, Publish, System paths) correctly blanked, demonstrating the omission.
**2. Retrieve the wrapped notebook key:**
```
POST http://127.0.0.1:6808/api/notebook/getNotebookConf
{"notebook":"<NOTEBOOK_ID>"}
```
The response contains `BoxCrypt.WrappedDEK` and `WrapNonce`.
**3. Offline:** candidate passwords are verified locally against `KEKVerifier`/`KEKMAC` using `MasterSalt` and `KDFParams`, with no further server interaction. A recovered password yields the KEK, which unwraps `WrappedDEK` to the notebook's data-encryption key.
*Verification status:* the leak paths are confirmed by code inspection at `origin/master`. A live end-to-end demonstration requires a build from HEAD with an encrypted notebook enabled; the test instance available predates the encrypted-notebook feature, so no runtime reproduction is claimed here.
### Impact
An unauthenticated remote client (publish mode with auth disabled) or any publish `RoleReader` obtains everything needed to mount an unlimited, unthrottled, GPU-parallel offline attack on the encrypted-notebook master password, plus the wrapped data key to decrypt notebook contents o
Microsoft UFO open-source framework for intelligent automation across devices and platforms. Prior to 3.0.8, _is_blocked_ip in ufo/utils/url_security.py did not block NAT64 prefixes 64:ff9b::/96 and 64:ff9b:1::/48, the 6to4 prefix 2002::/16, or the Teredo prefix 2001::/32 and did not re-check embedded IPv4 destinations, allowing an unauthenticated remote attacker who can influence URLs processed by validate_url to bypass the SSRF guard and reach cloud metadata, internal services, or localhost. This issue is fixed in version 3.0.8.
Apache Airflow's serialization layer reconstructed exception nodes by calling `import_string()` on a class name taken from the serialized blob and instantiating it with arguments from the same blob, with no restriction on what could be imported. An operator's `executor_config` reaches that branch, so a Dag author could place a value there that causes an arbitrary callable to be imported and invoked -- for example `subprocess.check_output`, or `builtins.eval` on the `builtins`-prefixed variant. The code runs in the **Scheduler**, which reconstructs serialized Dags in its normal loop with no request involved, and in the **API server**, on any authenticated read of the Dag such as `GET /api/v2/dags/{dag_id}/details`. Both are components the Airflow security model states must never execute Dag-author code, and both hold the metadata database credentials and the JWT signing secret. No non-default configuration is required. This is a **different sink from CVE-2026-33264**, which covered only the trigger branch of the same deserializer: deployments that upgraded in response to that advisory are still affected through the exception branch and must upgrade again. Users are advised to upgrade to apache-airflow 3.3.1 or later, which restricts the imported class to a subclass of `BaseException`.
Apache Airflow's XCom `GET /api/v2/{...}/xcomEntries/{key}?deserialize=true` endpoint passed a string-literal payload through `BaseXCom.deserialize_value` without the `_check_forbidden_xcom_keys` guard, allowing an authenticated API user with XCom write-and-read access to instantiate arbitrary `airflow.*` classes on the API server (CWE-502). An authenticated user who can write an XCom value and then read it back with `deserialize=true` triggers the unsafe instantiation. Users are advised to upgrade to apache-airflow 3.3.1 or later, which rejects reserved XCom serialization keys submitted as JSON string literals.
Apache Airflow's environment-variable secrets backend resolved a team-scoped Connection or Variable from the wrong team's scope. The guard meant to prevent this only ran when no team scope was supplied, and its pattern could not match a team name containing an underscore, which team names are allowed to contain. When the guard did not apply, the lookup fell through to an unconditional global read that resolved the stored `AIRFLOW_CONN__<TEAM>___<ID>` variable regardless of which team asked. In multi-team mode an authenticated user of one team could therefore have `POST /api/v2/connections/test` resolve another team's Connection and authenticate outward with that team's credentials; the endpoint uses the credentials rather than returning them. Exploitation requires `[core] multi_team` enabled, `[core] test_connection` set to `Enabled` (it ships `Disabled`), team-scoped secrets provisioned as environment variables in the API-server process, and knowledge of the encoded identifier. Redirecting the test at an attacker-controlled host is separately blocked. Users are advised to upgrade to apache-airflow 3.3.1 or later.