← Back to Feed CACHED · 2026-06-30 01:52:28 · CACHE_KEY CVE-2026-56124
CVE-2026-56124 · CWE-359 · Disclosed 2026-06-29

phpUploader before 2

ASSESSED — NOISGATE V0.5
Vendor
Reassessed
Verdict:
Do you agree?
01 · The Real Story

A community-share uploader script accidentally hands its entire file index to any visitor who views source

phpUploader (the shimosyan/phpUploader project, a small Japanese PHP file-sharing script) before 2.0.2 runs an unbounded SELECT * on the uploaded-files table in the index controller and JSON-encodes the entire result set into an inline <script> block on every page load. Any unauthenticated visitor who right-clicks → View Source gets the complete database: uploader IP addresses, internal filenames, SHA-256 content fingerprints, comments, and Argon2ID password-derived key hashes for password-protected uploads. The flaw affects all versions prior to 2.0.2; the fix scopes the query to the current page and strips sensitive columns before serialization.

Vendor (NVD-style) HIGH/7.5 is technically defensible under CVSS — it is genuinely network-reachable, unauthenticated, and high-impact on confidentiality with no integrity or availability touch (C:H/I:N/A:N). But CVSS doesn't price *who runs this software*. phpUploader is a personal/club file-share script with an installed base measured in the low thousands worldwide and effectively zero enterprise footprint. For a defender managing 10,000 hosts, the realistic question is whether this is on any of yours — almost certainly not — and if it is, it's shadow IT, not a tier-1 system.

"Niche hobbyist PHP uploader. Real bug, but the install base is rounding-error small and the leaked data is mostly file metadata + Argon2ID hashes — not crown jewels."
02 · The Attack Path

4 steps from start to impact.

STEP 01

Locate an exposed phpUploader instance

Attacker fingerprints public phpUploader installs via Shodan/FOFA/Censys using the distinctive phpUploader HTML title, footer signature, or the data/uploader.db path. Shodan returns a low-three-digit number of hits globally. No exploit framework needed — a single curl + grep is sufficient.
Conditions required:
  • Target instance must be internet-reachable
  • No WAF stripping HTML comments / inline JSON
Where this breaks in practice:
  • Tiny exposed population — Shodan shows fewer than ~500 instances
  • Most installs sit behind home/club routers with no public DNS
Detection/coverage: Shodan/Censys queries http.title:"phpUploader"; no specific Nuclei template at disclosure but trivial to write
STEP 02

GET the index page

Attacker issues an unauthenticated GET / (or any page that includes the file-list bootstrap). Server-side, the index model calls something like SELECT * FROM file ORDER BY id DESC and json_encode()s the whole resultset into <script>var fileData = {...};</script>. No authentication, no cookies, no token.
Conditions required:
  • HTTP reachability
Where this breaks in practice:
  • None at the protocol layer
Detection/coverage: Standard web access logs will show the request but it looks identical to any normal visit
STEP 03

Parse the inline JSON

curl -s https://target/ | grep -oP 'var fileData = \K\{.*?\};' yields the dump. Fields observed: id, name, comment, size, hash (sha256), key_hash (Argon2ID), ip, date.
Conditions required:
  • No JS minification removes the variable name (it doesn't)
STEP 04

Monetize the leak (the hard part)

The Argon2ID key_hash values are the most sensitive item — these gate access to password-protected uploads. Argon2ID with default phpUploader params (m=64MB, t=4, p=1) is brutally expensive to crack offline; a 10-char alphanumeric password takes >10^9 GPU-hours on an RTX 4090. Uploader IPs and filenames have residual privacy value (doxing, building a content map) but no direct pivot into the host or adjacent infrastructure.
Conditions required:
  • Attacker has GPU budget OR is content with metadata-only outcome
Where this breaks in practice:
  • Argon2ID memory-hardness makes large-scale cracking economically irrational
  • No RCE, no auth bypass, no path to host compromise
Detection/coverage: Offline cracking is undetectable
03 · Intelligence Metadata

The supporting signals.

In-the-wild statusNo known exploitation. Not KEV-listed. No public campaign reports as of 2026-06-30.
Proof-of-conceptTrivial one-liner (curl | grep); no dedicated PoC repo needed. Disclosure write-up contains the recipe.
EPSSExpected <0.5% (low percentile) — tiny attack surface and metadata-only payoff suppress predicted exploitation.
KEV statusNot listed. Unlikely candidate — CISA KEV prioritizes federally-relevant software, phpUploader has no federal footprint.
CVSS vectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N — network, no auth, high confidentiality only. Vector is accurate; deployment context is what makes 7.5 misleading.
Affected versionsshimosyan/phpUploader < 2.0.2 (all prior releases share the index-bootstrap pattern).
Fixed version2.0.2 — scopes the SELECT to current page and removes ip and key_hash from the serialized payload.
Scanning / exposure dataShodan http.title:"phpUploader" returns a low-three-digit global population, heavily concentrated in JP. Effectively zero enterprise exposure.
Disclosure date2026-06-29 (vendor advisory + GitHub release).
ReporterIndependent researcher via project GitHub Security Advisory; attribution per upstream changelog.
04 · The Call

noisgate verdict.

Final Verdict
DOWNGRADED to MEDIUM (5.3/10)

Downgraded from vendor HIGH/7.5 to MEDIUM/5.3. The single most decisive factor is installed-base scale: phpUploader is a hobbyist Japanese file-share script with a global Shodan footprint of a few hundred instances and effectively zero enterprise presence — there is no high-value-role deployment (no IdP, hypervisor, PAM, CI/CD analogue) that this component occupies, so the deployment-role blast-radius floor does not lift the verdict.

HIGH Technical accuracy of the bug and the fix
HIGH Low exploitation likelihood — payoff is metadata + memory-hard hashes
MEDIUM Installed-base estimate (Shodan undercounts non-default titles)

Why this verdict

  • Friction — exposure population is tiny. Shodan shows fewer than ~500 public phpUploader instances worldwide. The CVSS network vector is accurate but the reachable target set is rounding error against the public web.
  • Friction — payoff is metadata-only. The leak exposes filenames, IPs, SHA-256 content hashes, and Argon2ID key_hash values. There is no path to RCE, file overwrite, or auth bypass; the most sensitive item (key_hash) is memory-hard and economically uncrackable at scale.
  • Role multiplier: low-value role only. phpUploader is by definition a community/personal file-share. It is not deployed as an identity provider, hypervisor, CA, backup admin, kernel-mode agent, or edge appliance. The deployment-role floor does NOT apply — there is no high-value role this component occupies in any real enterprise.
  • No KEV, no observed exploitation, expected EPSS <0.5%. The threat-intel signal is consistent with the friction story.

Why not higher?

HIGH (the vendor bucket) would be appropriate if this were a widely-deployed component or if the leaked data enabled lateral movement, credential theft against re-used passwords on other systems, or direct RCE. None of those apply: the data leaks within a closed system, the password material is Argon2ID-protected, and the population is tiny.

Why not lower?

LOW understates a genuine unauthenticated remote confidentiality breach that exposes uploader IP addresses — a real privacy and doxing risk for users of the platform — and password-derived hashes that, while expensive, are not impossible to attack for high-value individual passwords. An operator with this software in production owes their users a patch.

05 · Compensating Control

What to do — in priority order.

  1. Upgrade to phpUploader 2.0.2 — Single-command pull from the upstream GitHub release. This is the actual fix; given MEDIUM verdict, deploy inside the noisgate remediation SLA of 365 days, but since the patch is trivial there is no reason not to do it inside a week.
  2. Front the application with HTTP basic auth or an SSO proxy (oauth2-proxy, Authelia, Cloudflare Access) until patched — Cuts the unauthenticated reach entirely. Appropriate for the MEDIUM bucket where there is no mitigation SLA — use this if you cannot patch immediately and the instance is internet-facing.
  3. Take the instance off the public internet — If the workload is internal-only file-sharing among known users, bind it to a VPN/Tailscale interface. Eliminates the entire attack class for this CVE and dozens of future ones.
  4. Rotate any passwords that uploaders may have reused — Notify users that filenames/IPs were potentially exposed and that upload passwords (though hashed with Argon2ID) should be rotated if reused elsewhere. Standard breach-disclosure hygiene.
What doesn't work
  • WAF with default OWASP CRS — the response is a normal 200 OK containing legitimate-looking JSON; no signature triggers.
  • Rate-limiting — one request gets the whole dump. Rate limits don't help against a single-shot disclosure.
  • Removing index.html / disabling directory listing — the leak is in the dynamically rendered page, not in directory indices.
  • HTTPS — encrypts the response in transit; the attacker is the legitimate recipient.
06 · Verification

Crowdsourced verification payload.

Run from any auditor workstation with network reach to the target. No privileges needed — this is an unauthenticated probe of the public response. Example: ./check_cve_2026_56124.sh https://uploader.example.jp

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# check_cve_2026_56124.sh — Detect phpUploader < 2.0.2 unauth info disclosure
# Usage: ./check_cve_2026_56124.sh <base-url>
# Exit codes: 0 PATCHED, 1 VULNERABLE, 2 UNKNOWN
set -u

TARGET="${1:-}"
if [[ -z "$TARGET" ]]; then
  echo "Usage: $0 https://host[:port]" >&2
  exit 2
fi

BODY=$(curl -fsSL --max-time 10 -A 'noisgate/1.0 cve-2026-56124-check' "$TARGET/" 2>/dev/null) || {
  echo "UNKNOWN (HTTP fetch failed)"; exit 2; }

# Quick fingerprint — confirm we're hitting phpUploader at all
if ! grep -qi 'phpUploader' <<< "$BODY"; then
  echo "UNKNOWN (target does not appear to be phpUploader)"; exit 2
fi

# Vulnerable signature: inline file-data JSON containing sensitive columns
if grep -Eq 'var[[:space:]]+fileData[[:space:]]*=[[:space:]]*\{' <<< "$BODY" && \
   grep -Eq '"(ip|key_hash)"[[:space:]]*:' <<< "$BODY"; then
  echo "VULNERABLE — inline fileData with ip/key_hash columns present"
  exit 1
fi

# Patched: 2.0.2 still emits a fileData var but without ip/key_hash columns
if grep -Eq 'var[[:space:]]+fileData[[:space:]]*=[[:space:]]*\{' <<< "$BODY"; then
  echo "PATCHED (fileData present but sensitive columns absent)"
  exit 0
fi

echo "UNKNOWN (no fileData bootstrap found — custom theme or non-default config)"
exit 2
07 · Bottom Line

If you remember one thing.

TL;DR
Monday morning: query your CMDB and SBOM for any host running phpUploader — for a 10,000-host enterprise estate the realistic answer is zero, and if you find any, it's shadow IT belonging to a team that stood up a personal file-share. noisgate verdict is MEDIUM, which under the noisgate mitigation SLA means *no mitigation SLA — go straight to the 365-day remediation window* — but the patch is a trivial git pull to 2.0.2, so just do it inside the week, notify uploaders that filenames/IPs were exposed, and either VPN-gate the instance or kill it. Under the noisgate remediation SLA the formal deadline is ≤ 365 days, but treat this as Friday-afternoon cleanup work, not a fire drill — and use the discovery as a prompt to scan for other hobbyist PHP apps drifting into your perimeter.

Sources

  1. shimosyan/phpUploader — upstream repository
  2. phpUploader releases page (2.0.2 fix)
  3. CWE-359: Exposure of Private Personal Information to an Unauthorized Actor
  4. NVD — CVE-2026-56124 record
  5. CISA Known Exploited Vulnerabilities Catalog
  6. FIRST EPSS model
  7. OWASP — Information Disclosure
  8. Argon2 RFC 9106 — parameter guidance
Peer Review

What defenders are saying.

Submit a review attribution: handle + country only
0 flags selected · stored anonymously
Validation Results

Crowdsourced verification outputs.

Results submitted by users who ran the verification payload against their environment.