A path traversal vulnerability exists in pip's wheel installation process that allows arbitrary file overwrite by installing a malicious Python wheel with specially crafted entry-point names. This can compromise system integrity and availability, and may lead to arbitrary code execution, especially when pip is run with elevated privileges. The vulnerability affects Red Hat AI Base Images 3.3.2 (ROCm 7.0) and related Red Hat OpenShift AI products. No fix is currently available.
Vibe-Trading before 0.1.10 constructs the swarm run directory by joining a caller-supplied run identifier onto the runs base directory without validation in run_dir (agent/src/swarm/store.py). A crafted run identifier supplied through the MCP swarm tools causes the application to read arbitrary run.json files outside the runs directory and to overwrite existing run.json files at traversed locations.
A vulnerability in jupyter/nbconvert versions <= 7.17.0 allows for Cross-site Scripting (XSS) via unsanitized `text/vnd.mermaid` output in HTML exports. The `data_mermaid` block in `share/templates/lab/base.html.j2` renders `text/vnd.mermaid` cell output directly into HTML without escaping, enabling attackers to inject arbitrary HTML/JavaScript by breaking out of the `<pre>` tag. This vulnerability impacts any server using nbconvert to render notebooks as HTML, allowing attackers to execute arbitrary JavaScript in the context of users viewing the HTML export.
Backpropagate is a Python library for fine-tuning large language models on a single GPU. In versions 1.1.0 and 1.1.1, the optional Reflex web UI exposes a training control plane without authentication: dataset upload, model load, training start/stop, multi-run orchestration, GGUF export, and HuggingFace Hub push. The CLI accepts two operator-facing flags intended as security controls: --auth user:pass — documented as "require HTTP Basic authentication on every request to the UI." and--share — documented as "expose the UI on a public address; requires --auth." When --auth user:pass is passed, the CLI prints Auth: enabled (user: <username>) to confirm to the operator that authentication is active, then exports BACKPROPAGATE_UI_AUTH=user:pass to the subprocess that launches the Reflex backend. The Reflex backend (backpropagate/ui_app/**) never reads BACKPROPAGATE_UI_AUTH. No authentication middleware is registered. No request-level guard runs. No WebSocket upgrade guard runs. Any client that reaches the bound port — local or remote, depending on whether --share is used — has full UI access. An inline comment at backpropagate/cli.py:1217-1218 in the v1.1.0 source documents the gap: "For Phase 1 the variable is exported but Reflex doesn't read it yet." This comment was internal-facing; the user-facing documentation (README, CHANGELOG, SHIP_GATE) advertised the contract as enforced. An attacker who reaches the bound port can read uploaded datasets, trigger arbitrary training runs against any local base models as well as read their paths, trigger HuggingFace Hub pushes and cause disk-fill DoS. This issue has been fixed in version 1.2.0. If developers cannot immediately upgrade to 1.2.0 run backprop ui with no flags so it binds to localhost, use SSH port-forwarding (ssh -L 7860:localhost:7860 <training-host>) instead of --share for remote access, and audit any host previously launched with --share, re-issuing any HF tokens used during those sessions.
CVE-2026-48777 is a critical path traversal vulnerability in the gtsteffaniak filebrowser product, specifically affecting versions prior to 1.3.3-stable and 1.4.2-beta. The flaw exists in the publicPatchHandler endpoint, where user-controlled path inputs are joined with a trusted base path before sanitization, allowing traversal outside the intended directory. This enables an attacker with a public share link that has AllowModify=true to move, copy, or rename arbitrary files within the share owner's root directory. The issue was fixed in versions 1.3.3-stable and 1.4.2-beta.
## Summary
Dulwich's `ProcessMergeDriver` substitutes the file path (from the git tree, controllable by an attacker via a malicious branch) into the merge driver command via the `%P` placeholder and executes it with `subprocess.run(..., shell=True)`. An attacker who can cause a victim to merge an untrusted branch can achieve arbitrary command execution by crafting malicious file paths.
## Description
- **Type:** Command Injection
- **Source:** `merge.py` line 195 — path from merge tree (from repository content when merging untrusted branch)
- **Sink:** `merge_drivers.py` lines 124–127 — `subprocess.run(cmd, shell=True)` where `cmd` includes path via `%P` placeholder
- **Impact:** Arbitrary code execution when merging from a malicious repository. Requires the user to have a merge driver configured that uses the `%P` placeholder.
## Resources
- Repository: https://github.com/dulwich/dulwich
- Vulnerable file: `dulwich/merge_drivers.py` (lines 119–129)
## Proof of Concept
```python
from dulwich.attrs import GitAttributes, Pattern
from dulwich.config import ConfigDict
from dulwich.merge import merge_blobs
from dulwich.objects import Blob
# Merge driver with %P (path) - typical for custom merge tools
config = ConfigDict()
config.set((b"merge", b"injectable"), b"driver", b"echo %P > %A")
patterns = [(Pattern(b"*"), {b"merge": b"injectable"})]
gitattributes = GitAttributes(patterns)
base = Blob.from_string(b"base")
ours = Blob.from_string(b"ours")
theirs = Blob.from_string(b"theirs")
# Malicious path from attacker-controlled git tree: injects "touch /tmp/pwned"
malicious_path = b"x; touch /tmp/pwned #"
merge_blobs(base, ours, theirs, path=malicious_path,
gitattributes=gitattributes, config=config)
# => Executes: echo x; touch /tmp/pwned #
# => Shell runs: echo x, then touch /tmp/pwned
```
## Fix
[merge_drivers_shell_escape.patch](https://github.com/user-attachments/files/27016503/merge_drivers_shell_escape.patch)
7-Zip is a file archiver with a high compression ratio. Versions 9.21 through 26.00 contain an off-by-one out-of-bounds read vulnerability in the ParseDepedencyExpression function of the UEFI firmware image parser(CPP/7zip/Archive/UefiHandler.cpp). The function validates an attacker-controlled opcode byte using > instead of >= against the element count of the 10-entry kExpressionCommands static array, allowing an opcode value of 10 to read one pointer slot (8 bytes on x64) past the end of the array in .rodata. The out-of-bounds value is then dereferenced as a const char * and passed through strlen and memcpy into the archive's Characts property, which may cause either a denial of service (access violation when the adjacent bytes do not form a valid readable pointer) or a minor information disclosure of an adjacent .rdata string literal into archive metadata. The vulnerability is reached automatically during IInArchive::Open() via the call path OpenFv/OpenCapsule → ParseVolume → ParseSections when processing a SECTION_DXE_DEPEX (0x13) or SECTION_PEI_DEPEX (0x1B) section whose first body byte is 0x0A, and the UEFI handler is enabled by default in stock 7z.dll with signature-based detection for both UEFIc and UEFIf formats. The outcome (crash vs. silent leak) is deterministic per build but linker-layout dependent, with no write primitive and no disclosure of heap data, secrets, or ASLR base addresses. Version 26.01 fixes the issue.
A security vulnerability has been detected in modelscope ms-swift up to 4.2.0. This affects the function Template._save_pil_image of the file swift/template/base.py of the component PIL Image Cache Key Handler. The manipulation leads to use of weak hash. An attack has to be approached locally. A high degree of complexity is needed for the attack. It is indicated that the exploitability is difficult. The exploit has been disclosed publicly and may be used. The pull request to fix this issue awaits acceptance.
CVE-2026-10212 is an authorization bypass vulnerability in AstrBotDevs AstrBot version 4.24.2. The issue occurs in the astr_main_agent function within the astrbot/core/astr_main_agent.py file, where manipulation of the session_id argument allows bypassing authorization controls. The vulnerability can be exploited remotely. Although the exploit is publicly available, there is no vendor response or patch at this time. The CVSS 4.0 base score is 5.3, indicating medium severity.
A vulnerability in the Python package installer and resolver 'uv' allows manipulation of files and potentially code execution. The issue affects versions prior to 0.11.15 and is fixed in version 0.11.15. The Bundesamt für Sicherheit in der Informationstechnik has identified this flaw. Red Hat advisories reference this CVE as part of security updates for their AI Base Images. No public exploit code or in-the-wild exploitation has been reported.
CVE-2026-10177 is a server-side request forgery (SSRF) vulnerability affecting Aider-AI Aider version 0.86.3. The flaw exists in the requests.get function within the api_docs.py file, specifically related to the AWS EC2 Metadata Endpoint component. This vulnerability can be exploited remotely. A patch has been developed and is awaiting acceptance. The CVSS 4.0 base score is 5.3, indicating a medium severity level.
A stored cross-site scripting (XSS) vulnerability exists in JetBrains PyCharm versions before 2025.3.4, specifically affecting Jupyter notebook Markdown cells. This vulnerability allows an attacker to inject malicious scripts that could execute in the context of the affected application. The vulnerability is tracked as CVE-2026-49384 and has a CVSS v3.1 base score of 6.1, indicating a medium severity level. No official patch or remediation guidance has been provided yet by the vendor. There are no known exploits in the wild at this time.
CVE-2026-49382 is a medium severity vulnerability in JetBrains IntelliJ IDEA before version 2026.1. It involves code execution via template injection in the Copyright plugin. The vulnerability has a CVSS 3.1 base score of 4.5, indicating limited impact with high attack complexity and required user interaction. No official patch or remediation guidance is currently provided by the vendor. There are no known exploits in the wild at this time.
My name is Oscar Uribe, Security Researcher at Fluid Attacks. I am reaching out because we have identified a security vulnerability in Pimcore 12.3.3 that we would like to report to you so we can coordinate a responsible disclosure together.
As part of our standard disclosure measures, we follow a timeline (outlined at https://fluidattacks.com/advisories/policy), which is aligned with ISO/IEC 29147:2018 and ISO/IEC 30111:2019. In short, the timeline works as follows: we ask for acknowledgment of the report within a few days of your first accessing it, and from there, we are happy to coordinate a joint disclosure date with you, typically within 90 days of the initial discovery. This gives your team reasonable time to assess, develop, and release a fix.
We have reserved the CVE ID **"CVE-2026-5394"** for this issue, and the advisory will eventually be published at [https://fluidattacks.com/advisories/dragons](https://fluidattacks.com/advisories/dragons). We are committed to coordinating the timing of that publication with you.
Please feel free to reach out if you have any questions about the report, the process, or the timeline. We are glad to work with you on this.
## Description
An authenticated administrative user who can import or save DataObject class definitions can inject attacker-controlled composite index metadata and trigger unintended SQL execution in the backend.
The vulnerable flow accepts `compositeIndices` from imported JSON, stores the values without strict validation, and later concatenates them directly into `ALTER TABLE ... DROP INDEX` and `ALTER TABLE ... ADD INDEX` statements executed through Doctrine DBAL.
Although the original report focused on `compositeIndices.index_key`, independent code review shows that the strongest and most reliable injection point is `compositeIndices.index_columns`, because it is inserted verbatim inside the `ADD INDEX (...)` clause. This permits injection of additional `ALTER TABLE` subclauses against Pimcore object tables without relying on stacked queries.
## Vulnerability
### Root cause
1. Source:
- `Pimcore\Model\DataObject\ClassDefinition\Service::importClassDefinitionFromJson()` accepts `compositeIndices` directly from imported JSON.
2. Assignment:
- `Pimcore\Model\DataObject\ClassDefinition::setCompositeIndices()` does not enforce an allowlist for index names or column names.
- The only special handling is a ManyToOne relation rewrite to `__id` and `__type`, which is not a security control.
3. Sink:
- `Pimcore\Model\DataObject\Traits\CompositeIndexTrait::updateCompositeIndices()` builds raw SQL with string concatenation and executes it via `$this->db->executeQuery(...)`.
4. Missing protection:
- `quoteIdentifier()` is used for the `SHOW INDEXES` query, but not for the dynamic `ALTER TABLE` statements.
- No server-side schema validation restricts `index_key` or `index_columns` to known safe identifier characters.
### Confirmed source-to-sink path
1. `importClassDefinitionFromJson()` decodes attacker-controlled JSON and forwards `compositeIndices`.
2. `setCompositeIndices()` stores those values without sanitizing identifier content.
3. `ClassDefinition::save()` reaches `ClassDefinition\Dao::update()`.
4. `Dao::update()` calls `updateCompositeIndices()` for:
- `object_store_<classId>`
- `object_query_<classId>`
5. `Localizedfield\Dao` also calls `updateCompositeIndices()` for:
- localized query tables
- localized store tables
### Why this is exploitable
The vulnerable `ADD INDEX` statement is built as:
```php
'ALTER TABLE `'.$table.'` ADD INDEX `' . $key.'` ('.$columnName.');'
```
`$columnName` is produced from `implode(',', $columns)` and is not quoted or validated. A malicious `index_columns` element such as:
```text
slider), DROP COLUMN `oo_className` --
```
produces SQL of the form:
```sql
ALTER TABLE `object_query_<id>` ADD INDEX `c_poc_idx` (slider), DROP COLUMN `oo_className` -- );
```
This remains a single `ALTER TABLE` statement, so the base vulnerability does not depend on multi-statement support. The attacker can inject additional DDL clauses affecting the target Pimcore object table.
### Impact
The issue allows a privileged attacker to alter backend SQL behavior during class-definition import/save and modify schema on Pimcore object tables associated with the affected class.
Practical impact includes:
- unauthorized schema modification on object query/store tables
- backend denial of service by breaking expected table layout
- data integrity impact for DataObject storage and queries
`index_key` is also concatenated into SQL without proper identifier escaping, but the most defensible exploitation path is through `index_columns`.
Relevant code:
- `models/DataObject/ClassDefinition/Service.php:92-137`
- `models/DataObject/ClassDefinition.php:994-1006`
- `models/DataObject/Traits/CompositeIndexTrait.php:30-85`
- `models/DataObject/ClassDefinition/Dao.php:217-218`
- `models/DataObject/Localizedfield/