Attackers chain JFrog Artifactory flaws to seize admin control and plant Rust backdoors
A two-step token swap turned an anonymous request into an administrator account within minutes, a reminder that authentication and authorisation are separate gates.
Attackers have been stringing together vulnerabilities in JFrog Artifactory, the artifact repository many build pipelines pull dependencies from, to take over self-hosted servers, according to reporting by BleepingComputer and The Hacker News on 11 September. Cloud security company Wiz said it observed the chained exploitation across multiple customer environments between 15 August and 8 September 2026.
The chain starts with CVE-2026-42018, an authentication bypass that hands an unauthenticated caller a JSON Web Token for an internal anonymous user even when anonymous access has been switched off. The attacker then leans on CVE-2026-42016, an insufficient token validation flaw, to exchange that low-privilege token for one with administrator scope. A third bug, CVE-2026-82329, rated 9.8 on the CVSS scale, grants an unauthenticated attacker administrator privileges on its own and was seen being exploited separately between 1 and 8 September.
Wiz reported that in some cases the gap between the first request and a freshly created administrator account was under five minutes. Once inside, intruders created persistent admin users with names such as 0xTerror, svc_ and labadmin_, installed malicious Groovy plugins that run code on the server, uploaded webshells, added SSH keys, enumerated repositories, tokens and users, and pulled configuration data and cluster join keys. In several environments they dropped a custom Rust backdoor with command-and-control features.
JFrog had already shipped fixes before the attacks were observed, so only servers that had not been updated were exposed. Fixed builds include 7.111.21, 7.117.28, 7.125.20, 7.133.29, 7.146.38 and 7.161.20. Wiz estimated that between 49 and 62 percent of reachable Artifactory instances remained vulnerable to at least one of the three flaws. One detection signal from the reports: audit logs showing "token:anonymous" performing administrative actions rather than a named account.
Why it matters
Artifact repositories sit upstream of every build, so an attacker with admin rights can tamper with what thousands of downstream systems trust. The speed of the observed intrusions shows exploit chains are being productised quickly after disclosure. The gap between patch availability and patch adoption, not the absence of a fix, is what made these attacks possible. Supply-chain infrastructure is becoming a favoured target precisely because compromising it scales.
Artifact repositories sit upstream of every build, so an attacker with admin rights can tamper with what thousands of downstream systems trust.
Unauthenticated request
The attacker sends a request to a self-hosted Artifactory server without logging in.
Anonymous token issued (CVE-2026-42018)
The server returns a JWT for an internal anonymous user even though anonymous access is disabled.
Token exchanged for admin scope (CVE-2026-42016)
Weak token validation lets the low-privilege token be traded for an administrator-scoped one.
Persistence added
New admin accounts, malicious Groovy plugins, webshells and SSH keys survive restarts and patches.
Rust backdoor with C2
A custom backdoor gives the attacker ongoing remote control and access to stored artefacts.
What you can learn from this
- Authentication and authorisation are separate gates, and each can fail on its own. Authentication answers "who is this caller?" while authorisation answers "what may this identity do?". In this chain, one flaw handed out an identity that should not have existed for outsiders, and a second flaw let that weak identity be traded up for a powerful one. Systems behave this way because tokens are often trusted once minted, so any error at the issuing step propagates to every later check that relies on the token alone.
- JSON Web Tokens carry their own claims, so validation logic is the whole security model. A JWT is a signed bundle of statements such as subject, scope and expiry, and a service accepts it if the signature checks out and the claims pass its rules. When a token-exchange endpoint fails to verify that the presented token was entitled to request the new scope, the signature is still valid but the trust it represents is hollow. That is why token minting, refresh and exchange paths deserve the same scrutiny as the login form.
- Vulnerability chaining turns two modest problems into one critical outcome. Attackers rarely need a single perfect bug; they compose several weaknesses into a path that ends in admin control. Risk scoring that looks at each CVE in isolation can understate the combined effect, which is why the reports emphasise the sequence rather than any one number. Defenders model this with attack graphs, where the question is whether any route exists from an unauthenticated position to a privileged one.
- Persistence mechanisms turn a break-in into a long-term foothold. New admin accounts, added SSH keys and server-side plugins each survive a restart and a password change, so an attacker keeps access even after the original entry point is patched. Plugin systems such as Artifactory's Groovy extensions are attractive because they run with the application's own privileges by design. Patching closes the door but does not evict anyone who already walked through it, which is why the remediation advice pairs upgrading with a hunt for rogue artefacts.
- Repositories are high-value because they sit upstream of trust. Build servers, containers and deployment tooling all fetch from the artifact store and generally assume what they receive is genuine. An attacker who controls the store can reach systems they never touched directly, which multiplies the return on a single compromise. This is the same logic behind other software supply-chain incidents, and it explains why internal-only infrastructure still needs internet-grade hardening.
We teach this
How to use this in practice
- Inventory and version-check any Artifactory you run. Sign in as an administrator and compare the running version with the fixed builds named in the advisories, or query the system version endpoint from a shell with curl and read the JSON response. If you are below the fixed line for your branch, schedule the upgrade this week and note the maintenance window. Done looks like a one-line record per instance: hostname, current version, fixed version, upgrade date.
- Hunt for the indicators described in the reports. Export the access and audit logs and search for administrative actions attributed to "token:anonymous", newly created admin users you do not recognise, unfamiliar Groovy plugins in the plugins directory, and recently added SSH keys on the host. Grep or your log platform's query language is enough for a first pass; you are looking for anything created since mid-August. Done looks like a short findings note, even if it says "nothing found" with the queries you ran attached.
- Audit the token-issuing paths in a service you own. Draw a diagram of every endpoint that mints, refreshes or exchanges a credential, and next to each one write which check confirms the caller is allowed to request that scope. Anywhere the arrow from "presented token" to "new token" has no check written beside it is a finding. Done looks like a one-page diagram with every exchange edge labelled, plus a ticket for each unlabelled edge.
- Restrict who can reach the repository at the network layer. Check whether your artifact server answers on a public address; if it does, put it behind a VPN, an identity-aware proxy or at minimum an allow-list of build-agent and developer ranges. Test from an outside network, for example a phone hotspot, and confirm the login page no longer loads while your CI agents can still resolve dependencies. Done looks like a failed connection from outside and a successful build from inside, both recorded with a timestamp.
Sources
- Artifactory flaws chained in attacks deploying backdoor malware — BleepingComputer
- Attackers Chain JFrog Artifactory Flaws to Gain Admin Control and Plant Backdoors — The Hacker News
Our reporting is an original summary; full coverage is at the links above.
Don't just read about it — build it.
Square 1 teaches the skills behind the headlines, with every line of your work graded by AI. Find your starting point in 3 minutes.
Get your free skill report