Skip to main content

Salty Docs CVE-2026-55675

| EUVDEUVD-2026-98742 CRITICAL
Code Injection (CWE-94)
2026-10-13 GitHub_M
10.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Open fork pull request
  2. Delivery
    Commit malicious setup.py build hook
  3. Exploit
    Privileged workflow_run job checks out fork commit
  4. Execution
    pip install executes hook on runner
  5. Impact
    Exfiltrate CF_API_TOKEN and write GITHUB_TOKEN

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the target to run the vulnerable workflow pair: trigger-pr-build.yml records an untrusted fork commit SHA into the pr_info artifact, and build-pr.yml's workflow_run job checks out that exact fork commit (ref: pr_sha) before running 'pip install -r requirements.txt' with repository secrets in scope. The concrete prerequisite is a fork pull request whose fork content supplies a malicious setup.py or PEP 517 build hook in the installed dependency set. LIMITING FACTORS: the attacker must control fork content (merely tampering with artifact metadata is insufficient, per the description); the repository-fork guard (github.event.repository.fork == false) does NOT prevent this and is not the cause; and exploitation is confined to repositories deploying this specific workflow pattern prior to commit 649c9aea. Note that submitting a fork PR requires a GitHub account even though CVSS scores PR:N, and first-time-contributor workflow-approval settings may add a maintainer-approval gate in some configurations.

Impact

This is a genuine high-priority CI/CD supply-chain flaw, not a CVSS-inflated paper risk. The vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H and the source-code diff agree with each other: a classic GitHub Actions 'pwn request' where the secret-bearing workflow_run job in build-pr.yml checks out an untrusted fork commit recorded in the pr_info artifact and runs 'pip install -r requirements.txt', executing attacker-authored setup.py/PEP 517 build hooks with CF_API_TOKEN, GH_TOKEN, MKDOCS_GIT_COMMITTERS_APIKEY, and a write-capable GITHUB_TOKEN. The scope change (S:C) and full CIA impact are well-justified because the leaked tokens pivot into Cloudflare Pages and the GitHub repository itself. CONFLICTING/ABSENT SIGNALS: No EPSS score, no CISA KEV listing, and no public POC were provided in the input, so there is no evidence of active or automated exploitation despite the 10.0 score. A GitHub Security Advisory (GHSA-wr2h-fpxm-ff4x) and the fix commit confirm the vulnerability is real and vendor-acknowledged, but exploitation here would be targeted (attacker must deliberately craft a malicious fork PR against this specific repo) rather than mass/wormable, which is consistent with the absence of EPSS/KEV signals. SSVC-style read: exploitation = none observed, automatable = no (requires bespoke fork content and PR submission), technical impact = total. Priority is high for anyone operating a fork of this workflow pattern, but real-world blast radius is limited to the single project unless the pattern is widely copied.

Exploit ScenarioDerived

An attacker forks saltyorg/docs and opens a pull request whose fork commit adds a malicious setup.py (or PEP 517 build backend) to the dependency tree. When the privileged workflow_run job checks out that untrusted fork commit and runs 'pip install -r requirements.txt', the attacker's installation code executes on the base-repository runner and reads CF_API_TOKEN, GH_TOKEN, MKDOCS_GIT_COMMITTERS_APIKEY, and the write-capable GITHUB_TOKEN from the environment, exfiltrating them to an attacker endpoint. No public exploit was identified at time of analysis, but the GitHub advisory describes the technique in full and low complexity (AC:L) makes reproduction straightforward.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 13, 2026

Code injection in the Salty Docs documentation build pipeline (saltyorg/docs) lets an attacker-controlled fork pull request execute arbitrary code in the privileged base-repository GitHub Actions workflow that has repository secrets in scope, resulting in disclosure of CF_API_TOKEN, GH_TOKEN, MKDOCS_GIT_COMMITTERS_APIKEY and a write-capable GITHUB_TOKEN and enabling follow-on compromise of the docs.saltbox.dev deployment. The CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H (10.0) and, per the independent assessment, exploitation is confined to repositories running this specific pre-fix workflow pair - the trigger-pr-build.yml workflow records an untrusted fork commit SHA in the pr_info artifact and build-pr.yml's workflow_run job checks that SHA out before running 'pip install -r requirements.txt'. No public exploit code identified at time of analysis and the issue is not in CISA KEV, but the code path is a genuine CI/CD supply-chain flaw rather than a CVSS-inflated paper risk, so the risk is high for unpatched users of this template. Practical exploitation still requires an attacker to control fork content (malicious setup.py or PEP 517 build hook) rather than merely tampering with artifact metadata, and submitting a fork PR requires a GitHub account even though the vector scores PR:N.

RemediationAI

Apply the upstream fix: upgrade to commit 649c9aea2daef1168eeb0415b44e65dbbde9f220 or any later revision (upstream fix available via commit; a separately released, tagged patched version was not independently confirmed), which restructures the pipeline so the untrusted fork PR is built in the unprivileged workflow and the privileged workflow_run job only downloads and deploys the prebuilt pr_build_artifacts bundle instead of checking out the fork SHA and running pip install with secrets in scope. The same commit reduces workflow permissions to contents: read, removes the MKDOCS_GIT_COMMITTERS_APIKEY secret from the build step, gates the deploy job on workflow_run conclusion success, and bumps actions/checkout to v6 and actions/cache to v5; see the advisory at https://github.com/saltyorg/docs/security/advisories/GHSA-wr2h-fpxm-ff4x and the diff at https://github.com/saltyorg/docs/commit/649c9aea2daef1168eeb0415b44e65dbbde9f220. If upgrading immediately is not possible, compensating controls with real trade-offs are: disable or pause the trigger-pr-build.yml/build-pr.yml PR preview pipeline entirely until patched (loses contributor preview builds but removes the attack path); or, if previews are required, never run install/build commands on an untrusted ref in the workflow_run job - check out only base-repository code and consume prebuilt artifacts, since the 'github.event.repository.fork false' guard does not mitigate this path; additionally restrict the workflow_run trigger with a job-level condition or environment protection rule requiring maintainer approval (adds latency to every fork PR and can be bypassed by stale approvals), require first-time-contributor workflow approval so a maintainer must authorize each new fork PR's workflow run (adds review friction), scope secrets into a protected GitHub Environment with required reviewers rather than repository-wide secrets (secrets unavailable to unattended runs), and install dependencies with build isolation disabled or inside a secret-less container job so setup.py/PEP 517 hooks cannot read tokens. Because CF_API_TOKEN, GH_TOKEN, MKDOCS_GIT_COMMITTERS_APIKEY and the write-capable GITHUB_TOKEN may already have been exposed by any prior exploitation, rotate those credentials, audit Actions run logs and Cloudflare Pages deployment history, and review repository and organization audit logs for unexpected writes or deployments.

Affected VersionsENISA

docs < 649c9aea2daef1168eeb0415b44e65dbbde9f220

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

This is a GitHub Actions privilege-escalation pattern commonly called a 'pwn request', rooted in CWE-94 (Improper Control of Generation of Code / Code Injection). Two workflows interact: trigger-pr-build.yml runs on the unprivileged pull_request event and simply writes the fork PR's commit SHA and number into an uploaded artifact named pr_info; build-pr.yml is then invoked via the privileged workflow_run event, which executes in the base repository's context where repository secrets and a write-capable GITHUB_TOKEN are available. The old build job performed 'actions/checkout@v5' with 'ref: ${{ steps.pr_info.outputs.pr_sha }}', so it checked out the attacker-authored fork commit, and then ran 'pip install -r requirements.txt'. Because pip resolves and builds dependencies, any attacker-authored setup.py or PEP 517 build backend in the checked-out tree executes Python at install time inside the secret-bearing job -- the environment even exposed MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.GH_TOKEN }} to the mkdocs build step. Notably, the repository-fork guard (github.event.repository.fork false) is evaluated against the base repository and therefore does not block this path; it is not the cause of the flaw. The fixing commit 649c9aea2daef1168eeb0415b44e65dbbde9f220 re-architects the pipeline: the untrusted PR content is built in the unprivileged workflow, only the resulting pr_build_artifacts bundle is consumed by the privileged job (which now merely deploys to Cloudflare Pages), the deploy job is additionally gated on 'github.event.workflow_run.conclusion success', permissions are reduced from contents/pull-requests write to contents: read, the MKDOCS_GIT_COMMITTERS_APIKEY secret is removed from the build step, and actions/checkout and actions/cache are bumped to v6/v5.

Know when Docs gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (GitHub_M) PRIMARY 10.0 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 10.0 CRITICAL

Any forker can trigger code execution with no repo privileges or interaction (PR:N/UI:N), and leaked tokens compromise separate systems (Cloudflare/GitHub), justifying S:C and full C:H/I:H/A:H.

3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Oct 13, 2026 - 16:18 EUVD
CVE Published
Oct 13, 2026 - 15:15 cve.org
CRITICAL 10.0

DescriptionCVE.org

The Salty documentation repository builds and deploys the docs.saltbox.dev website. Prior to commit 649c9aea2daef1168eeb0415b44e65dbbde9f220, .github/workflows/trigger-pr-build.yml records an untrusted fork commit in the pr_info artifact, and the secret-bearing workflow_run job in .github/workflows/build-pr.yml checks out that commit before running pip install -r requirements.txt. A fork pull request can therefore supply attacker-authored setup.py or PEP 517 build hooks whose installation code executes in the privileged base-repository workflow with CF_API_TOKEN, GH_TOKEN, MKDOCS_GIT_COMMITTERS_APIKEY, and a write-capable GITHUB_TOKEN, allowing secret disclosure and follow-on compromise. The vulnerability is not caused by the repository-fork guard, and the demonstrated path requires attacker control of fork content rather than merely the artifact metadata. This vulnerability is fixed with commit 649c9aea2daef1168eeb0415b44e65dbbde9f220.

Technical POC Analysis

CWE-94 code injection in the Salty Docs GitHub Actions workflow pair.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

A critical code-injection flaw in the Salty Docs build pipeline (saltyorg/docs) allows anyone able to open a pull request from a fork to run arbitrary code inside the repository's privileged GitHub Actions workflow, exposing the deployment credentials that protect docs.saltbox.dev. Because those secrets include a write-capable GitHub token and Cloudflare API token, an attacker could pivot from the documentation site to broader repository and hosting infrastructure under the organization's control. The exposure is limited to repositories running the vulnerable pre-fix workflow pair, but those environments carry production deployment authority.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: disable or restrict the trigger-pr-build.yml/build-pr.yml workflow pair to trusted branches; do not check out untrusted fork commit SHAs in jobs with secrets in scope; set explicit least-privilege GITHUB_TOKEN permissions and avoid secrets in workflow_run jobs triggered by forks; require maintainer approval for fork PR workflow runs; rotate and re-scope all exposed credentials (CF_API_TOKEN, GH_TOKEN, MKDOCS_GIT_COMMITTERS_APIKEY); and monitor workflow logs and deployment activity for anomalous access.

Threat Intelligence Overview

EPSS Score
0.4%
Top 65% exploitable
Prevalence
Rare
single project's documentation repo powering one site, docs.saltbox.dev
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Total

Priority Score

50
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +50
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy