Skip to main content
skill CX Codex

gha-security-review — Claude Code skill: GitHub Actions vulnerability audit

gha-security-review — a skill that identifies exploitable security issues in GitHub Actions workflows—from expression injection to token theft. Every finding includes a concrete attack scenario and remediation steps.

Apache-2.0 5,100 installs ★ 1,193 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add getsentry/skills --skill gha-security-review -a claude-code
Open on GitHub

What gha-security-review does

gha-security-review audits workflows for vulnerabilities that an external attacker can exploit without write access to the repository. It scans .github/workflows/, local actions in .github/actions/, and config files loaded during CI runs. The patterns come from real-world GitHub Actions attacks, not generic CI/CD theory.

The skill checks eight vulnerability classes: pwn-request (fork code checked out and executed in pull_request_target), expression injection in ${{ }} inside run: blocks, unauthorized command execution from issue comments, token theft, config file poisoning (.cursorrules, CLAUDE.md), unpinned third-party actions, and incorrect permissions. For each finding, it traces the entry point (PR, comment, branch name), constructs the payload, and documents five elements: entry point, payload, execution mechanism, impact, and concrete attack steps.

The skill avoids reporting patterns that appear risky but are safe: numeric values like github.event.pull_request.number (only digits, not injectable), ${{ }} in if: conditions (evaluated by the runtime), and third-party actions pinned to full SHAs (immutable). Only HIGH and MEDIUM confidence findings are reported.

What it helps with

  • discover expression injection in GitHub Actions that runs in a shell environment
  • detect pwn-request vulnerability where fork code is checked out and executed
  • audit a workflow for secrets and token exposure
  • identify unpinned third-party actions in privileged CI jobs
  • find config file poisoning attacks from PR-supplied code

Example prompts for the agent

  • Review .github/workflows/ for pwn-request and expression injection bugs
  • Audit GitHub Actions: show me how an external attacker steals secrets without write access
  • Check this workflow for exploitable vulnerabilities—only report findings with PoC and a fix

How to install gha-security-review

1Skills CLI (Vercel)

npx skills add getsentry/skills --skill gha-security-review -a claude-code

2Manually: put the files in place

~/.claude/skills/gha-security-review/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/gha-security-review/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about gha-security-review

How do I install gha-security-review in Claude Code?

Run npx skills add getsentry/skills --skill gha-security-review -a claude-code in the terminal, then open ~/.claude/skills/gha-security-review/SKILL.md. For Cursor: npx skills add getsentry/skills --skill gha-security-review -a cursor and .cursor/skills/gha-security-review/SKILL.md. For GitHub Copilot: gh skill install getsentry/skills gha-security-review.

What does gha-security-review do?

It finds exploitable vulnerabilities in GitHub Actions workflows that an external attacker can use via a pull request or comment—without write access to the repo. For each finding, it traces the entry point, constructs the payload, explains the execution path, and sketches a concrete attack scenario.

What types of vulnerabilities does it detect?

Pwn-request (fork code checked out in pull_request_target), expression injection in run blocks, unauthorized command execution from comments, token theft, config file poisoning, unpinned third-party actions, and overly permissive workflow permissions.

Source text

SKILL.md · Apache-2.0
---
name: gha-security-review
description: 'GitHub Actions security review for workflow exploitation vulnerabilities. Use when asked to "review GitHub Actions", "audit workflows", "check CI security", "GHA security", "workflow security review", or review .github/workflows/ for pwn requests, expression injection, credential theft, and supply chain attacks. Exploitation-focused with concrete PoC scenarios.'
allowed-tools: Read Grep Glob Bash Task
---

<!--
Attack patterns and real-world examples sourced from the HackerBot Claw campaign analysis
by StepSecurity (2025): https://www.stepsecurity.io/blog/hackerbot-claw-github-actions-exploitation
-->

# GitHub Actions Security Review

Find exploitable vulnerabilities in GitHub Actions workflows. Every finding MUST include a concrete exploitation scenario — if you can't build the attack, don't report it.

This skill encodes attack patterns from real GitHub Actions exploits — not generic CI/CD theory.

## Scope

Review the workflows provided (file, diff, or repo). Research the codebase as needed to trace complete attack paths before reporting.

### Files to Review

- `.github/workflows/*.yml` — all workflow definitions
- `action.yml` / `action.yaml` — composite actions in the repo
- `.github/actions/*/action.yml` — local reusable actions
- Config files loaded by workflows: `CLAUDE.md`, `AGENTS.md`, `Makefile`, shell scripts under `.github/`

### Out of Scope

- Workflows in other repositories (only note the dependency)
- GitHub App installation permissions (note if relevant)

## Threat Model

Only report vulnerabilities exploitable by an **external attacker** — someone **without** write access to the repository. The attacker can open PRs from forks, create issues, and post comments. They cannot push to branches, trigger `workflow_dispatch`, or trigger manual workflows.

**Do not flag** vulnerabilities that require write access to exploit:
- `workflow_dispatch` input injection — requires write access to trigger
- Expression injection in `push`-only workflows on protected branches
- `workflow_call` input injection where all callers are internal
- Secrets in `workflow_dispatch`/`schedule`-only workflows

## Confidence

Report only **HIGH** and **MEDIUM** confidence findings. Do not report theoretical issues.

| Confidence | Criteria | Action |
|---|---|---|
| **HIGH** | Traced the full attack path, confirmed exploitable | Report with exploitation scenario and fix |
| **MEDIUM** | Attack path partially confirmed, uncertain link | Report as needs verification |
| **LOW** | Theoretical or mitigated elsewhere | Do not report |

For each HIGH finding, provide all five elements:

1. **Entry point** — How does the attacker get in? (fork PR, issue comment, branch name, etc.)
2. **Payload** — What does the attacker send? (actual code/YAML/input)
3. **Execution mechanism** — How does the payload run? (expression expansion, checkout + script, etc.)
4. **Impact** — What does the attacker gain? (token theft, code execution, repo write access)
5. **PoC sketch** — Concrete steps an attacker would follow

If you cannot construct all five, report as MEDIUM (needs verification).

---

## Step 1: Classify Triggers and Load References

For each workflow, identify triggers and load the appropriate reference:

| Trigger / Pattern | Load Reference |
|---|---|
| `pull_request_target` | `references/pwn-request.md` |
| `issue_comment` with command parsing | `references/comment-triggered-commands.md` |
| `${{ }}` in `run:` blocks | `references/expression-injection.md` |
| PATs / deploy keys / elevated credentials | `references/credential-escalation.md` |
| Checkout PR code + config file loading | `references/ai-prompt-injection-via-ci.md` |
| Third-party actions (especially unpinned) | `references/supply-chain.md` |
| `permissions:` block or secrets usage | `references/permissions-and-secrets.md` |
| Self-hosted runners, cache/artifact usage | `references/runner-infrastructure.md` |
| Any confirmed finding | `references/real-world-attacks.md` |

Load references selectively — only what's relevant to the triggers found.

## Step 2: Check for Vulnerability Classes

### Check 1: Pwn Request

Does the workflow use `pull_request_target` AND check out fork code?
- Look for `actions/checkout` with `ref:` pointing to PR head
- Look for local actions (`./.github/actions/`) that would come from the fork
- Check if any `run:` step executes code from the checked-out PR

### Check 2: Expression Injection

Are `${{ }}` expressions used inside `run:` blocks in externally-triggerable workflows?
- Map every `${{ }}` expression in every `run:` step
- Confirm the value is attacker-controlled (PR title, branch name, comment body — not numeric IDs, SHAs, or repository names)
- Confirm the expression is in a `run:` block, not `if:`, `with:`, or job-level `env:`

### Check 3: Unauthorized Command Execution

Does an `issue_comment`-triggered workflow execute commands without authorization?
- Is there an `author_association` check?
- Can any GitHub user trigger the command?
- Does the command handler also use injectable expressions?

### Check 4: Credential Escalation

Are elevated credentials (PATs, deploy keys) accessible to untrusted code?
- What's the blast radius of each secret?
- Could a compromised workflow steal long-lived tokens?

### Check 5: Config File Poisoning

Does the workflow load configuration from PR-supplied files?
- AI agent instructions: `CLAUDE.md`, `AGENTS.md`, `.cursorrules`
- Build configuration: `Makefile`, shell scripts

### Check 6: Supply Chain

Are **third-party** actions securely pinned to full SHAs?
- Pin third-party / external actions and reusable workflows only
- Do **not** flag first-party `actions/*` or `github/*` on version tags
- Do **not** flag same-repo / vendored (`./.github/actions/...`) as supply-chain pinning issues
- Only report when the job has secrets, OIDC, write token, release, deploy, package, or signing power — unprivileged read-only CI is not a finding

### Check 7: Permissions and Secrets

Are workflow permissions minimal? Are secrets properly scoped?

### Check 8: Runner Infrastructure

Are self-hosted runners, caches, or artifacts used securely?

## Safe Patterns (Do Not Flag)

Before reporting, check if the pattern is actually safe:

| Pattern | Why Safe |
|---|---|
| `pull_request_target` WITHOUT checkout of fork code | Never executes attacker code |
| `${{ github.event.pull_request.number }}` in `run:` | Numeric only — not injectable |
| `${{ github.repository }}` / `github.repository_owner` | Repo owner controls this |
| `${{ secrets.* }}` | Not an expression injection vector |
| `${{ }}` in `if:` conditions | Evaluated by Actions runtime, not shell |
| `${{ }}` in `with:` inputs | Passed as string parameters, not shell-evaluated |
| Third-party actions pinned to full SHA | Immutable reference |
| First-party `actions/*` / `github/*` on version tags | Outside third-party pinning policy — do not flag |
| Same-repo / vendored local actions | Not third-party supply chain (review pwn-request separately) |
| `pull_request` trigger (not `_target`) | Runs in fork context with read-only token |
| Any expression in `workflow_dispatch`/`schedule`/`push` to protected branches | Requires write access — outside threat model |

**Key distinction:** `${{ }}` is dangerous in `run:` blocks (shell expansion) but safe in `if:`, `with:`, and `env:` at the job/step level (Actions runtime evaluation).

## Step 3: Validate Before Reporting

Before including any finding, read the actual workflow YAML and trace the complete attack path:

1. **Read the full workflow** — don't rely on grep output alone
2. **Trace the trigger** — confirm the event and check `if:` conditions that gate execution
3. **Trace the expression/checkout** — confirm it's in a `run:` block or actually references fork code
4. **Confirm attacker control** — verify the value maps to something an external attacker sets
5. **Check existing mitigations** — env var wrapping, author_association checks, restricted permissions, SHA pinning

If any link is broken, mark MEDIUM (needs verification) or drop the finding.

**If no checks produced a finding, report zero findings. Do not invent issues.**

## Step 4: Report Findings

````markdown
## GitHub Actions Security Review

### Findings

#### [GHA-001] [Title] (Severity: Critical/High/Medium)
- **Workflow**: `.github/workflows/release.yml:15`
- **Trigger**: `pull_request_target`
- **Confidence**: HIGH — confirmed through attack path tracing
- **Exploitation Scenario**:
  1. [Step-by-step attack]
- **Impact**: [What attacker gains]
- **Fix**: [Code that fixes the issue]

### Needs Verification
[MEDIUM confidence items with explanation of what to verify]

### Reviewed and Cleared
[Workflows reviewed and confirmed safe]
````

If no findings: "No exploitable vulnerabilities identified. All workflows reviewed and cleared."

© getsentry · Apache-2.0 · getsentry/skills

Similar skills

All skills for DevOps and infrastructure →

From the same set27

The whole set →
security-review security-review finds injections, XSS, authorization flaws, and other vulnerabilities in code. Reports only high-confidence findings. CX Codex +1 23,800installs agents-md Generates and maintains concise AGENTS.md and CLAUDE.md instruction files for repositories. Keeps coding agent rules short, verified, and reference-backed. CX Codex +1 7,800installs code-review code-review — a skill that reviews pull requests and code changes against Sentry engineering practices: security, performance, tests, design. CX Codex +1 5,800installs commit Drafts Sentry-style conventional commits with issue references and blocks direct commits to main. CX Codex +1 4,900installs iterate-pr iterate-pr is a Claude Code skill that iterates on open pull requests until actionable CI checks pass and review comments are fixed, handling test failures and feedback without waiting for human approval. CX Codex +1 4,800installs pr-writer pr-writer is a Claude Code skill that drafts and refreshes pull request titles and descriptions for reviewers. It activates when a PR is opened, edited, or prepared from branch changes. CX Codex +1 4,700installs claude-settings-audit claude-settings-audit is a Claude Code skill that inspects a repository and suggests settings.json permissions. It runs for new project setup or a review of existing permissions. CX Codex +1 4,700installs gh-review-requests gh-review-requests finds unread review requests for open GitHub pull requests and filters them by team. Use it when the review queue needs a focused check. CX Codex +1 4,400installs

Project sponsors

Companies that keep this analytics open