# GitHub Security Advisory Draft — GM-374
## Summary
Multiple locations in Pimcore v11 call PHP's `unserialize()` on data from database columns and filesystem files without the `allowed_classes` restriction, enabling object injection if an attacker can control the serialized data source.
## Severity
CVSS 3.1: 8.0 (High) — AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H
## Affected Component
- **Package:** `pimcore/pimcore` and `pimcore/admin-ui-classic-bundle`
- **Files:**
- `lib/Tool/Authentication.php` (line 82) — session token deserialization
- `models/Site/Dao.php` (line 68) — site domains from database
- `models/DataObject/ClassDefinition/CustomLayout/Dao.php` (line 69) — layout definitions from database
- `models/Tool/TmpStore/Dao.php` (line 64) — temporary store data from database
- `models/Asset/WebDAV/Service.php` (line 36) — delete log from filesystem
- `admin-ui-classic-bundle/src/Helper/Dashboard.php` (line 64) — dashboard config from filesystem
## Description
Six locations in Pimcore core call `unserialize()` directly (bypassing `Tool\Serialize`) on data sourced from database columns or filesystem files without passing the `allowed_classes` parameter. This means any class available in the autoloader will be instantiated during deserialization.
If an attacker can write to the data source (e.g., via SQL injection targeting the `tmp_store`, `sites`, or `custom_layouts` tables, or via a file write vulnerability targeting the WebDAV delete log), they can inject serialized PHP gadget chains that execute arbitrary code when the data is deserialized.
This is related to but distinct from the `Tool\Serialize::unserialize()` issue — these calls bypass the wrapper entirely.
## Impact
PHP object injection leading to Remote Code Execution when chained with a data source write vulnerability. Pimcore's dependency tree (Guzzle, Symfony, Monolog, Doctrine) provides numerous known gadget chains.
## Proof of Concept
1. Identify a writable data source (e.g., `tmp_store` table via SQL injection, or `webdav-delete.dat` via file write)
2. Write a serialized PHP gadget chain (e.g., Monolog `BufferHandler` chain from phpggc)
3. Trigger the deserialization (e.g., access a page that reads TmpStore, or trigger a WebDAV operation)
4. The gadget chain executes with web server privileges
## Suggested Fix
Add `allowed_classes` parameter to all `unserialize()` calls. Where no objects are needed, use `['allowed_classes' => false]`. Consider migrating to JSON serialization for data that doesn't require object preservation.
```php
// Example fix for Site/Dao.php:
$siteDomains = unserialize($site['domains'], ['allowed_classes' => false]);
// Example fix for TmpStore/Dao.php:
$item['data'] = unserialize($item['data'], ['allowed_classes' => false]);
```
## References
- CWE-502: Deserialization of Untrusted Data
- OWASP Deserialization Cheat Sheet
- phpggc: PHP Generic Gadget Chains
The SponsorMe plugin for WordPress is vulnerable to Reflected Cross-Site Scripting via PHP_SELF Parameter in all versions up to, and including, 0.5.2 due to insufficient input sanitization and output escaping. This makes it possible for unauthenticated attackers to inject arbitrary web scripts in pages that execute if they can successfully trick a user into performing an action such as clicking on a link. The PHP_SELF value is reflected in two separate locations within the vulnerable function — a form action attribute and an anchor href attribute — both of which can be exploited by appending a crafted payload to the wp-admin/admin.php URL path.
CVE-2026-41203 is a critical path traversal vulnerability in the ci4ms product of the ci4-cms-erp project. The issue exists in versions prior to 0.31.5.0 where the Theme::upload function extracts user-uploaded ZIP archives without validating the entry names. This allows an authenticated backend user with theme create permission to write files to arbitrary filesystem locations, potentially leading to remote code execution by placing a PHP file under the public web root. The vulnerability has been patched in version 0.31.5.0.
CVE-2026-41202 is a critical path traversal vulnerability in ci4ms, a CodeIgniter 4-based CMS. Versions prior to 0.31.5.0 allow an authenticated backend user with backup create permission to upload crafted ZIP archives that can write files to arbitrary filesystem locations. This can lead to remote code execution by placing malicious PHP files under the public web root. The vulnerability has been patched in version 0.31.5.0.
CVE-2026-7075 is a medium severity SQL injection vulnerability in itsourcecode Construction Management System version 1.0. The issue occurs in the /locations.php file when the address parameter is manipulated, allowing remote attackers to perform SQL injection. The vulnerability has a CVSS 4.0 base score of 6.9. No official patch or remediation guidance is currently available, and no known exploits in the wild have been reported.
Xerte Online Toolkits versions 3.15 and earlier contain a relative path traversal vulnerability in the elFinder connector endpoint at /editor/elfinder/php/connector.php where the name parameter in rename commands is not sanitized for path traversal sequences. Attackers can supply a name value containing directory traversal sequences to move files from project media directories to arbitrary locations on the filesystem, potentially overwriting application files, achieving stored cross-site scripting, or combining with other vulnerabilities to achieve unauthenticated remote code execution by moving PHP code files to the application root.
The Inquiry Form to Posts or Pages plugin for WordPress is vulnerable to Stored Cross-Site Scripting via the 'Form Header' field in versions up to and including 1.0. This is due to insufficient input sanitization when saving via update_option() and lack of output escaping when displaying the stored value. The vulnerability exists in two locations: (1) the plugin settings page at inq_form.php line 180 where the value is echoed into an HTML attribute without esc_attr(), and (2) the front-end shortcode output at inquery_form_to_posts_or_pages.php line 139 where the value is output in HTML content without esc_html(). This makes it possible for authenticated attackers with administrator-level access to inject arbitrary web scripts that will execute whenever a user accesses the plugin settings page or views a page containing the [inquiry_form] shortcode.
WWBN AVideo is an open source video platform. In versions up to and including 26.0, the `verifyTokenSocket()` function in `plugin/YPTSocket/functions.php` has its token timeout validation commented out, causing WebSocket tokens to never expire despite being generated with a 12-hour timeout. This allows captured or legitimately obtained tokens to provide permanent WebSocket access, even after user accounts are deleted, banned, or demoted from admin. Admin tokens grant access to real-time connection data for all online users including IP addresses, browser info, and page locations. Commit 5d5237121bf82c24e9e0fdd5bc1699f1157783c5 fixes the issue.
WWBN AVideo is an open source video platform. In versions up to and including 26.0, the RTMP `on_publish` callback at `plugin/Live/on_publish.php` is accessible without authentication. The `$_POST['name']` parameter (stream key) is interpolated directly into SQL queries in two locations — `LiveTransmitionHistory::getLatest()` and `LiveTransmition::keyExists()` — without parameterized binding or escaping. An unauthenticated attacker can exploit time-based blind SQL injection to extract all database contents including user password hashes, email addresses, and other sensitive data. Commit af59eade82de645b20183cc3d74467a7eac76549 contains a patch.
WWBN AVideo is an open source video platform. In versions up to and including 26.0, `POST /objects/aVideoEncoder.json.php` accepts a requester-controlled `chunkFile` parameter intended for staged upload chunks. Instead of restricting that path to trusted server-generated chunk locations, the endpoint accepts arbitrary local filesystem paths that pass `isValidURLOrPath()`. That helper allows files under broad server directories including `/var/www/`, the application root, cache, tmp, and `videos`, only rejecting `.php` files. For an authenticated uploader editing their own video, this becomes an arbitrary local file read. The endpoint copies the attacker-chosen local file into the attacker's public video storage path, after which it can be downloaded over HTTP. Commit 59bbd601a3f65a5b18c1d9e4eb11471c0a59214f contains a patch for the issue.
WWBN AVideo is an open source video platform. Prior to version 26.0, the `listFiles.json.php` endpoint accepts a `path` POST parameter and passes it directly to `glob()` without restricting the path to an allowed base directory. An authenticated uploader can traverse the entire server filesystem by supplying arbitrary absolute paths, enumerating `.mp4` filenames and their full absolute filesystem paths wherever they exist on the server — including locations outside the web root, such as private or premium media directories. Version 26.0 contains a patch for the issue.
MiniGal Nano versions 0.3.5 and prior contain a path traversal vulnerability in index.php via the dir parameter. The application appends user-controlled input to the photos directory and attempts to prevent traversal by removing dot-dot sequences, but this protection can be bypassed using crafted directory patterns. An attacker can exploit this behavior to cause the application to enumerate and display image files from unintended filesystem locations that are readable by the web server, resulting in unintended information disclosure.
The TableMaster for Elementor plugin for WordPress is vulnerable to Server-Side Request Forgery in all versions up to, and including, 1.3.6. This is due to the plugin not restricting which URLs can be fetched when importing CSV data from a URL in the Data Table widget. This makes it possible for authenticated attackers, with Author-level access and above, to make web requests to arbitrary locations, including localhost and internal network services, and read sensitive files such as wp-config.php via the 'csv_url' parameter.
CVE-2026-22789 is a medium-severity vulnerability in SMEWebify's WebErpMesv2 versions prior to 1.19 that allows authenticated users to bypass file upload validation and upload arbitrary files, including PHP scripts. This can lead to remote code execution (RCE) on the affected system. The flaw exists in multiple controllers and is similar to CVE-2025-52130 but in different code locations not fixed previously. Exploitation requires authentication but no user interaction beyond that. The vulnerability impacts confidentiality and integrity but not availability, with a CVSS score of 5.4. No known exploits are currently reported in the wild. European organizations using WebErpMesv2 in manufacturing or resource management should prioritize upgrading to version 1.19 or later to mitigate risk.
The Simple Download Counter plugin for WordPress is vulnerable to Path Traversal in all versions up to, and including, 2.2.2. This is due to insufficient path validation in the `simple_download_counter_parse_path()` function. This makes it possible for authenticated attackers, with Administrator-level access and above, to read the contents of arbitrary files on the server, which may contain sensitive information such as database credentials (wp-config.php) or system files. Please note that the vendor opted to continue to allow remote file downloads from arbitrary locations on the server, however, has disabled this functionality on multi-sites and provided a warning to site owners in the readme.txt when they install the plugin. While not an optimal patch, we have considered this sufficient and recommend users proceed to use the plugin with caution.
phpPgAdmin 7.13.0 and earlier contains multiple cross-site scripting (XSS) vulnerabilities across various components. User-supplied input from $_REQUEST parameters is reflected in HTML output without proper encoding or sanitization in multiple locations including sequences.php, indexes.php, admin.php, and other unspecified files. An attacker can exploit these vulnerabilities to execute arbitrary JavaScript in victims' browsers, potentially leading to session hijacking, credential theft, or other malicious actions.
Multiple security vulnerabilities affecting PHP 8.2 have been addressed in a Red Hat Enterprise Linux 8 update. These include heap buffer over-read in mysqlnd, single byte overread in quoted-printable decoding, CRLF injection via proxy configuration in stream contexts, and several issues related to HTTP stream wrappers such as improper header parsing, omission of basic auth headers, acceptance of invalid headers, incorrect content-type headers on redirects, and truncation of redirect locations. The update is rated as having a moderate security impact.
The WP Webhooks plugin for WordPress is vulnerable to arbitrary file copy due to missing validation of user-supplied input in all versions up to, and including, 3.3.5. This makes it possible for unauthenticated attackers to copy arbitrary files on the affected site's server to arbitrary locations. This can be used to copy the contents of wp-config.php into a text file which can then be accessed in a browser to reveal database credentials.
An unrestricted file upload vulnerability exists in BuilderEngine 3.5.0 via the integration of the elFinder 2.0 file manager and its use of the jQuery File Upload plugin. The plugin fails to properly validate or restrict file types or locations during upload operations, allowing an attacker to upload a malicious .php file and subsequently execute arbitrary PHP code on the server under the context of the web server process. While the root vulnerability lies within the jQuery File Upload component, BuilderEngine’s improper integration and lack of access controls expose this functionality to unauthenticated users, resulting in full remote code execution.
CVE-2025-1861 is a vulnerability in PHP versions 8.1.* before 8.1.32, 8.2.* before 8.2.28, 8.3.* before 8.3.19, and 8.4.* before 8.4.5. It involves an incorrect calculation of buffer size when parsing HTTP redirect responses, where the location buffer is limited to 1024 bytes instead of the RFC9110 recommended 8000 bytes. This can cause incorrect URL truncation and potentially redirect users to unintended locations.