← Back to Feed CACHED · 2026-10-08 11:30:46 · CACHE_KEY CVE-2026-82533
CVE-2026-82533 · CWE-807 · Disclosed 2026-09-08

DeepSeek Harness Authentication Bypass via Host Header Spoofing

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

Like a prison where the inmates can already see and phone anyone — this bug just unlocked the cell door

DeepSeek Harness (dsh), DeepSeek's open-source AI agent runtime released in August 2026, exposes a local HTTP API on 127.0.0.1:3080 for controlling agent sessions. Versions through 0.1.1-rc.2 authenticate API requests by checking the Host header instead of the actual TCP peer address (CWE-807). A single curl call with Host: 127.0.0.1:3080 flips the session to dangerFullAccess mode and disables the approval prompt, letting the agent — or anyone who can reach the port — write anywhere on the filesystem and execute commands unconfined. All releases through 0.1.1-rc.2 are affected. Fixed in 0.1.2-alpha.1 (GitHub source, 2026-08-27), 0.1.2-alpha.2 (npm, 2026-08-30), and 0.1.2-rc.1 (stable, 2026-09-03).

The vendor CVSS of 9.6 CRITICAL materially overstates real-world risk. The vector uses AV:N (Network), but dsh hard-binds to 127.0.0.1 and rejects --host 0.0.0.0 — remote exploitation requires the operator to deliberately tunnel or proxy the port outward, a misconfiguration the tool actively prevents. More importantly, the dsh sandbox only ever restricted *file writes*; reads and outbound network were already unconfined even inside the sandbox. The escape adds write access and disables the approval UI, which matters for persistence and lateral-movement staging — but the headline-grabbing exfiltration scenario (reading SSH keys, cloud creds, .env files, and sending them out) was already possible *inside* the sandbox. The incremental risk is real but significantly narrower than a true unauthenticated network RCE.

"Sandbox only blocked writes; the 9.6 score assumes network exposure that doesn't exist by default."
02 · The Attack Path

5 steps from start to impact.

STEP 01

Attacker positions malicious instructions in agent context

The attacker delivers a prompt-injection payload — via a malicious file in the workspace (poisoned README, dependency manifest, or code comment), a crafted user prompt, or a compromised MCP tool response — that instructs the agent to call the local control API. Because dsh's agent executes arbitrary shell commands as its core function, reaching curl requires zero exploit development. No special tooling needed; the payload is a natural-language instruction.
Conditions required:
  • Attacker can influence the agent's context window (prompt injection, malicious file in workspace, social engineering of operator, or compromised upstream tool)
Where this breaks in practice:
  • Agent must interpret and act on the injected instruction — alignment guardrails may refuse overtly hostile prompts
  • If the operator is actively watching the approval UI, they would see the curl call — but only if approval hasn't already been disabled in a prior turn
Detection/coverage: No scanner signature exists. Custom detection: grep agent transcript logs or shell history for /api/session/config or dangerFullAccess.
STEP 02

Host header spoofing bypasses API authentication

The agent executes: curl -H 'Host: 127.0.0.1:3080' http://127.0.0.1:3080/api/session/config -X PATCH -d '{"approval":"never","dangerFullAccess":true}'. The isTrustedApiRequest function checks only the Host header against a loopback allowlist and never compares it against the connection's actual peer address. No token, cookie, or credential is required. The full PoC is documented in the OX Security blog — it is a single command.
Conditions required:
  • Ability to send HTTP to 127.0.0.1:3080 — the agent already has this from inside the sandbox (network is unconfined); a remote attacker needs a tunnel, SSH forward, or reverse proxy to the port
Where this breaks in practice:
  • Port binds to loopback only by default and the CLI rejects --host 0.0.0.0, so accidental remote exposure is structurally prevented
  • Third-party desktop wrappers may bundle their own dsh copy, but these also bind to localhost
Detection/coverage: Process-level network monitoring (Falco, osquery, Sysmon NetworkConnect events) can flag unexpected PATCH requests to 127.0.0.1:3080 from dsh child processes.
STEP 03

Sandbox dropped, approval prompt disabled

The API call sets dangerFullAccess: true and approval: never. The harness immediately drops OS-level sandbox confinement (bubblewrap on Linux, Seatbelt on macOS) and stops prompting the user for action confirmation. Critically, the OX Security researchers confirmed the config change is logged with source user rather than agent, leaving no forensic indicator that the agent modified its own policy. No user interaction is required for this step.
Conditions required:
  • Step 2 succeeded
Where this breaks in practice:
  • None — the API applies the change immediately and unconditionally once the Host header check passes
Detection/coverage: Monitor dsh session config files or the /api/session/config GET response for unexpected dangerFullAccess state. No vendor audit log exists in affected versions.
STEP 04

Unconfined execution as the host user

With the sandbox down, the agent can write anywhere the dsh user can: drop ~/.ssh/authorized_keys entries, modify ~/.bashrc or ~/.zshrc, alter CI build scripts, plant cron jobs, or stage tools for lateral movement. Combined with the read and network access that was *already* available inside the sandbox, the agent now holds full interactive-user-equivalent access. On CI runners in headless mode, this includes build secrets, deploy tokens, and artifact-signing material.
Conditions required:
  • Step 3 succeeded
  • dsh is running as a user with access to valuable assets (developer credentials, CI secrets, source code)
Where this breaks in practice:
  • Impact limited to the privileges of the user running dsh — typically a non-root developer or CI service account
  • EDR/XDR on the host may flag anomalous file writes or process trees from the Node.js dsh process
Detection/coverage: EDR behavioral rules for Node.js child processes writing to ~/.ssh/, ~/.bashrc, CI config directories, or spawning unexpected binaries. File-integrity monitoring on sensitive dotfiles.
STEP 05

(Alternative entry) Remote attacker via exposed tunnel

If an operator has forwarded port 3080 via SSH (RemoteForward), ngrok, cloudflared, or a reverse proxy, an unauthenticated remote attacker can skip step 1 entirely. They send the same Host-header-spoofed PATCH to create a session, execute arbitrary commands, and exfiltrate all stored conversation transcripts — no prompt injection required. This is the scenario the vendor CVSS models, but it requires a deliberate misconfiguration that the tool actively resists.
Conditions required:
  • Port 3080 is reachable from the attacker's network via tunnel, proxy, or port forward — a configuration dsh explicitly prevents by default
Where this breaks in practice:
  • dsh rejects --host 0.0.0.0 at the CLI level
  • Documentation and community guides (SSD Nodes, dsh-plugin.org) explicitly warn against exposing the port
  • No Shodan/Censys/FOFA fingerprint tags exist for dsh, suggesting negligible public exposure
Detection/coverage: Standard network perimeter monitoring for unexpected inbound connections on port 3080. GreyNoise has no tag for dsh scanning activity.
03 · Compensating Control

1
HIGH 7.0→IGNORE 0.0
SEVERITY REDUCED
Upgrade all dsh installations to 0.1.2-alpha.2 or later — The definitive fix. Version 0.1.2-alpha.2 is the first npm-published release with one-time-token authentication on the local API. Run npm install -g @deepseek-ai/dsh@latest or update your package.json pin. Also audit third-party desktop wrappers that bundle their own dsh copy — at least one Windows wrapper shipped vulnerable 0.1.1-rc.2 until September 6. Per the noisgate remediation SLA for HIGH, complete within 180 days — but this is a one-command npm update with no reported breaking changes, so there is no reason to delay.
2
HIGH 7.0→LOW 3.0
SEVERITY REDUCED
Run dsh inside a disposable container or VM with no host credential mounts — Contains the blast radius even if the sandbox escape succeeds. Use a Docker container or ephemeral VM with no volume mounts to ~/.ssh, ~/.aws, ~/.config/gcloud, ~/.npmrc, or CI secret directories. The escaped agent gains write access to the container's filesystem only — no host credentials to steal, no meaningful persistence to establish. Per the noisgate mitigation SLA for HIGH, deploy within 30 days.
3
HIGH 7.0→MEDIUM 5.5
SEVERITY REDUCED
Kill all tunnels, proxies, and port-forwards to port 3080 — Eliminates the remote (unauthenticated network) attack vector entirely. Audit SSH configs (~/.ssh/config, sshd_config) for RemoteForward or LocalForward directives targeting 3080. Search for ngrok, cloudflared, or similar tunnel agents. This does NOT mitigate the local sandbox-escape path but removes the most severe exploitation scenario. Per the noisgate mitigation SLA for HIGH, complete within 30 days — ideally within hours, as this is a configuration change.
4
HIGH 7.0→HIGH 6.5
Monitor agent transcripts and dsh logs for sandbox-escape indicators — Implement a detective control by forwarding dsh session logs to your SIEM and alerting on strings matching dangerFullAccess, approval.*never, or PATCH.*/api/session/config. This is detective, not preventive — it will not stop the escape but provides a forensic trail and early-warning signal. The OX Security researchers confirmed that the config change logs as source user so you must key on the content of the change, not the actor label.
What doesn't work
  • WAF or network IDS/IPS — the primary attack vector is agent-to-localhost over the loopback interface; no inline network security tool inspects 127.0.0.1 traffic. A WAF in front of a reverse proxy would only cover the remote misconfiguration scenario.
  • EDR signatures on curl localhost — curl to localhost is ubiquitous in developer workflows, Node.js health checks, and CI scripts. Signature-based detection will generate overwhelming false positives and get tuned out within days.
  • Running dsh as a non-root user — the escape grants the agent the *same* privileges as the user running dsh. On a developer workstation, that user already owns SSH keys, cloud credentials, and code repositories. Non-root confinement does not protect these assets.
  • Setting --approval always at launch — the vulnerability payload explicitly sets approval: never via the API, overriding any CLI flag. The approval mechanism is itself the thing being bypassed.
04 · Intelligence Metadata

The supporting signals.

In-the-wild exploitationNone observed. No CISA KEV listing. No GreyNoise or Shadowserver scan tags. No attributed campaigns as of 2026-10-08. EPSS exploitation probability is 1.2%, confirming low observed threat actor interest.
Proof of conceptFully public — trivial one-liner. The complete PoC (curl -H 'Host: 127.0.0.1:3080' … -d '{"dangerFullAccess":true}') is documented in the OX Security blog with before/after screenshots. No dedicated GitHub PoC repo (e.g., CVE-2026-82533) was found on pocindex.io or GitHub — the exploit is so trivial that a standalone repo is unnecessary. Researchers: Nir Zadok and Moshe Siman Tov Bustan (OX Security).
EPSS0.01204 (1.2%) — low exploitation probability in the next 30 days. Consistent with a localhost-only, niche developer tool.
KEV statusNot listed on CISA Known Exploited Vulnerabilities catalog as of 2026-10-08.
CVSS vectorVendor: CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H → 9.6. VulnCheck scored CVSS v4.0 at 9.4. The AV:N is inaccurate for default deployments — dsh binds to localhost and rejects --host 0.0.0.0. AV:L is more realistic for the primary (agent sandbox escape) path, which would drop the base to ~7.1. S:C (Changed scope) is appropriate: the vuln crosses the sandbox→host boundary.
Affected versionsAll DeepSeek Harness releases through 0.1.1-rc.2 (released 2026-08-21). This includes the initial public release from August 13, 2026. GHSA: GHSA-8m2g-8cgm-3vcp.
Fixed versions0.1.2-alpha.1 (2026-08-27, GitHub source only) · 0.1.2-alpha.2 (2026-08-30, first npm publish) · 0.1.2-rc.1 (2026-09-03, current stable). Fix replaces Host-header trust with one-time-token auth + signed browser cookie on all API endpoints. Third-party desktop wrappers may still bundle vulnerable copies — one Windows wrapper shipped 0.1.1-rc.2 until 2026-09-06.
Exposure surfacedsh hard-binds to 127.0.0.1:3080 and programmatically rejects --host 0.0.0.0. No Shodan, Censys, or FOFA fingerprint tags exist for dsh instances. 216k GitHub stars are bookmarks, not installations. The tool is pre-alpha, developer-only, and has no enterprise distribution channel. Actual installed base in production environments is estimated to be very small.
Disclosure timeline2026-08-13: Community reports sandbox escape on DeepSeek discussion board. 2026-08-24: OX Security reports to VulnCheck (CNA). 2026-08-27: Fix in 0.1.2-alpha.1. 2026-08-30: npm publish of 0.1.2-alpha.2 + researcher verification. 2026-09-08: CVE published.
ResearchersNir Zadok and Moshe Siman Tov Bustan, OX Security. Coordinated via VulnCheck as CNA. Community developers independently reported the same escape 11 days before the formal disclosure.

Sources.

  1. VulnCheck Advisory
  2. OX Security Research Blog
  3. The Hacker News Coverage
  4. GHSA-8m2g-8cgm-3vcp (OSV)
  5. Rapid7 Vulnerability Database
  6. NVD Entry (via Vulners)
  7. DevOps.com Analysis
  8. Strix AI CVE Detail
05 · The Call

Final Verdict
↓ DOWNGRADED to HIGH (7.0/10)

Why this verdict

  • Localhost-only binding eliminates the network attack vector. The vendor CVSS uses AV:N, but dsh binds to 127.0.0.1 and rejects --host 0.0.0.0 at the CLI level. Remote exploitation requires the operator to deliberately tunnel or proxy port 3080 outward — a misconfiguration the tool structurally prevents. No Shodan/Censys/FOFA evidence of public-facing dsh instances exists. Recalculating with AV:L drops the realistic base score by approximately 2 points.
  • Sandbox already allowed reads and outbound network — incremental impact is narrower than the headline. The dsh sandbox only restricted file writes; an agent could already read ~/.ssh/id_rsa, ~/.aws/credentials, .env files, and exfiltrate them over the network *without* this vulnerability. The escape adds write access (persistence, config modification) and disables the approval prompt (stealth). These are meaningful gains but the most dangerous exfiltration path was already open inside the sandbox.
  • Pre-alpha developer tool with negligible enterprise footprint. DeepSeek Harness was released August 2026 as a developer preview. It has no enterprise distribution channel, no LDAP/SSO integration, and no production deployment model. 216k GitHub stars are bookmarks, not installations. Actual enterprise deployment at scale is near-zero.
  • No in-the-wild exploitation and low EPSS (1.2%). Not on KEV. No GreyNoise tags. No attributed campaigns. The exploit is trivially reproducible but the target population is small, local-only, and self-selecting (developers who opted into a pre-alpha AI agent tool).
  • Role multiplier: (a) *Developer workstation* (>90% of installs): chain succeeds; blast radius is host-level. Attacker gains write access as the developer user, enabling persistence via dotfiles and access to dev credentials. Meaningful but bounded to one host and one user's credential set. (b) *CI/CD runner via --headless mode* (<10% of installs but a documented use case): chain succeeds; blast radius is potentially supply-chain-scale — an escaped agent can modify build artifacts, exfiltrate signing keys, or inject malicious code into CI pipelines. This is the high-value role that floors the verdict at HIGH. (c) *VPS with SSH tunnel*: remote exploitation is possible but requires deliberate misconfiguration; no evidence of meaningful exposure.

Why not higher?

CRITICAL would require either a network-reachable attack surface in default configuration or the affected component being canonically a high-value infrastructure role (identity provider, domain controller, hypervisor, network edge appliance). DeepSeek Harness is none of these — it is a pre-alpha developer tool that binds to localhost by design. The CI/CD mode creates real supply-chain risk but represents a minority deployment pattern, and the sandbox already permitted the most dangerous data-exfiltration operations (read all files, full outbound network) before the escape. The incremental severity gain from write access alone does not justify CRITICAL.

Why not lower?

MEDIUM would undercount the blast radius on CI/CD runners where sandbox escape can enable supply-chain compromise via build-artifact tampering or signing-key theft. The exploit is a single trivially reproducible curl command with no authentication, the PoC is fully public, and developer workstations hold high-value credentials (SSH keys, cloud tokens, API secrets, code-signing material). The write-access and approval-bypass gains enable persistence mechanisms and lateral-movement staging that the read-only sandbox could not support.

06 · Verification

Crowdsourced verification payload.

Run on any host where DeepSeek Harness (dsh) may be installed. Invoke: bash check_cve_2026_82533.sh. No root required — needs node and npm in $PATH (they are present if dsh is installed). The script checks the installed dsh version against the fix threshold and warns if port 3080 is bound to a non-loopback address.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# CVE-2026-82533 — DeepSeek Harness auth-bypass version checker
# Outputs: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN
set -uo pipefail

FIXED="0.1.2-alpha.1"
VER=""

# --- Locate installed dsh version ---
if command -v dsh &>/dev/null; then
  VER=$(dsh --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+[-a-zA-Z0-9.]*' | head -1)
fi

if [ -z "$VER" ] && command -v node &>/dev/null; then
  for base in "$(npm root -g 2>/dev/null)" "$(npm root 2>/dev/null)"; do
    [ -z "$base" ] && continue
    pj="${base}/@deepseek-ai/dsh/package.json"
    if [ -f "$pj" ]; then
      VER=$(node -p "require('${pj}').version" 2>/dev/null)
      [ -n "$VER" ] && break
    fi
  done
fi

if [ -z "$VER" ]; then
  echo "UNKNOWN - DeepSeek Harness (dsh) not found on this host"
  exit 2
fi

echo "[*] Detected dsh version: $VER"

# --- Semver comparison via node (guaranteed present if dsh is installed) ---
RESULT=$(node -e "
  function cmp(a, b) {
    var pa = a.split('-'), pb = b.split('-');
    var ca = pa[0].split('.').map(Number), cb = pb[0].split('.').map(Number);
    for (var i = 0; i < 3; i++) {
      if (ca[i] !== cb[i]) return ca[i] - cb[i];
    }
    var ra = pa[1] || '~', rb = pb[1] || '~';
    if (ra === '~' && rb === '~') return 0;
    if (ra === '~') return 1;  // no prerelease > prerelease
    if (rb === '~') return -1;
    return ra < rb ? -1 : ra > rb ? 1 : 0;
  }
  console.log(cmp('${VER}', '${FIXED}') >= 0 ? 'PATCHED' : 'VULNERABLE');
" 2>/dev/null || echo "UNKNOWN")

# --- Check for non-loopback exposure of port 3080 ---
if command -v ss &>/dev/null; then
  EXPOSED=$(ss -tln 2>/dev/null | awk '/:3080 /{print}' | grep -v '127\.0\.0\.1' | grep -v '\[::1\]' || true)
  if [ -n "$EXPOSED" ]; then
    echo "[!] WARNING: port 3080 bound to non-loopback address — remotely exploitable!"
    echo "    $EXPOSED"
  fi
elif command -v netstat &>/dev/null; then
  EXPOSED=$(netstat -tln 2>/dev/null | awk '/:3080 /{print}' | grep -v '127\.0\.0\.1' | grep -v '::1' || true)
  if [ -n "$EXPOSED" ]; then
    echo "[!] WARNING: port 3080 bound to non-loopback address — remotely exploitable!"
    echo "    $EXPOSED"
  fi
fi

echo "$RESULT - dsh $VER (fixed in >= $FIXED)"
case "$RESULT" in
  PATCHED)    exit 0 ;;
  VULNERABLE) exit 1 ;;
  *)          exit 2 ;;
esac