Skip to main content
All posts
DevSecOps24 min read

GitHub Actions Security: 20 Controls Against CI/CD Takeover

Twenty GitHub Actions security controls across eight attack surfaces, from pull_request_target to OIDC, tested against workflows in 200 public repos.

Published Updated: 15 November 2026

On 14 March 2025, every version tag of tj-actions/changed-files was moved to a malicious commit. The action detects which files changed in a pull request, and Unit 42 counted more than 23,000 repositories using it. For most of a day, any workflow that referenced it by tag printed its secrets into the build log. Endor Labs later traced 218 repositories that actually leaked secrets that way. Almost exactly a year later, on 19 March 2026, it happened again: 76 of 77 tags of aquasecurity/trivy-action were force-pushed to code that read the runner's memory for credentials. That time it was a security scanner, the tool teams add to make a pipeline safer.

These were not exotic zero-days. They followed from how most organisations still write workflows: mutable tags, broad tokens, secrets available to every job, and triggers that run strangers' input with the base repository's privileges. This article is for the people who own that risk: CTOs, CISOs, platform leads and architects. We map GitHub Actions security to eight attack surfaces and twenty controls. We also measured how many of those controls actually appear in the workflow files of 200 public repositories.

TL;DR / Key takeaways

  • Your CI is a production system with a public front door. Fork pull requests, issue comments and third-party actions all feed code or text into jobs that can hold secrets and write tokens. Treat every workflow as an internet-facing service.
  • Mutable references are the most exploited weakness. Both tj-actions and Trivy worked by moving tags. A full commit SHA or the new workflow lockfile (generally available since 28 October 2026) closes that door.
  • Least privilege is still the exception. In our sample of 200 public repositories, only 41.5% declared token permissions in every workflow, and only 30.5% pinned every action to a commit SHA.
  • GitHub is changing the defaults, so use the moment. pull_request_target is blocked by default in public repositories from 2 December 2026, lockfiles can be enforced by policy, and SHA pinning can be required org-wide.
  • Twenty controls, five weeks. Most of the list is configuration, not tooling. Organisation policies plus a linter such as zizmor cover more than half of it.
GitHub Actions trust boundaries. Warm numbered arrows and markers are the eight attack surfaces (sections 1–8 below); green panels show where each of the twenty controls applies.
GitHub Actions trust boundaries. Warm numbered arrows and markers are the eight attack surfaces (sections 1–8 below); green panels show where each of the twenty controls applies.

Download: Editable draw.io file · Open in diagrams.net · Chart data (CSV)

Why this matters now

A build pipeline is the cheapest route to everything downstream of it. A workflow can hold cloud credentials, a registry token and a GITHUB_TOKEN that can push code, and it runs code from places you do not control.

The incident record makes the pattern hard to ignore:

  • Ultralytics, December 2024. PyPI's analysis describes malicious releases built by the project's own GitHub Actions workflow after an attack on the Actions cache, followed by a second round published with a leftover API token.
  • tj-actions and reviewdog, March 2025. Unit 42 traced the chain back to a pull_request_target workflow in the spotbugs project that leaked a maintainer's personal access token in December 2024. That token led to reviewdog, then to tj-actions. CISA added both CVEs (CVE-2025-30066 and CVE-2025-30154) to its Known Exploited Vulnerabilities catalogue.
  • Nx "s1ngularity", August 2025. A pull_request_target workflow interpolated the pull-request title straight into a shell step. According to the project's advisory, that led to the npm token and malicious nx releases.
  • GhostAction, September 2025. GitGuardian found attackers using compromised accounts to push a malicious workflow named "Github Actions Security" into 817 repositories, exfiltrating 3,325 secrets.
  • Trivy and TeamPCP, March 2026. The GitHub advisory GHSA-69fq-xp46-6x23 documents 76 of 77 trivy-action tags and all seven setup-trivy tags replaced with an infostealer that dumped Runner.Worker memory. The Cloud Security Alliance later described the TanStack compromise in May 2026 as pull_request_target abuse, then cache poisoning, then an OIDC token pulled from runner memory.

GitHub has responded with a run of Actions security changes. On 8 December 2025, pull_request_target started always using the default branch as its workflow source. In March 2026 GitHub published an Actions security roadmap covering dependency locking, policy-driven execution, scoped secrets and a native egress firewall. Workflow lockfiles went into public preview on 14 October 2026 and became generally available on 28 October. And from 2 December 2026, pull_request_target is blocked by default in public repositories.

GitHub Actions incidents and platform changes, 2023–2026
GitHub Actions incidents and platform changes, 2023–2026

The eight attack surfaces and twenty controls

The hero diagram splits a workflow run into four trust zones, with upstream third-party code underneath. Each numbered section below matches a warm marker; controls 1–20 appear in the green panels.

① Untrusted triggers

The most dangerous line in many workflow files is the trigger. A pull_request from a fork runs with a read-only token and no secrets. pull_request_target, workflow_run and issue_comment run in the context of the base repository, with its secrets and, often, a write token. It is meant for labelling and commenting. It becomes a takeover when the privileged workflow also checks out and executes the contributor's code, the classic "pwn request". The spotbugs leak that started the tj-actions chain, the Nx compromise and the TanStack chain all began here.

  • Control 1: Block pull_request_target by policy, then allow by exception. From 2 December 2026 GitHub does this for you in public repositories, and you can opt specific workflows back in through an Actions event policy with workflow file targeting. Do the same for private repositories. Most workflows that use the trigger only need pull_request.
  • Control 2: Never check out or run pull-request code in a privileged workflow. If you must react to fork contributions with write access, split the work. An unprivileged pull_request workflow builds and tests, then uploads results as an artifact. A separate privileged workflow only reads that artifact as data, never as code.
  • Control 3: Require approval before fork pull requests run workflows. Configure the fork approval setting at organisation or enterprise level so that workflows from outside contributors wait for a maintainer with write access. It is a speed bump, not a wall.

② Script injection

GitHub expressions such as ${{ github.event.pull_request.title }} are expanded before the shell sees the script. If the value is attacker-controlled, the attacker writes your script. Titles, bodies, comments, branch names and commit messages are all attacker-controlled. Nx is the textbook case: a title like $(curl …) was enough.

  • Control 4: Pass untrusted values through environment variables, never inline. Set env: TITLE: ${{ github.event.pull_request.title }} on the step and reference "$TITLE" in the script, double-quoted. GitHub's secure-use reference recommends exactly this.
  • Control 5: Gate comment-triggered and bot-triggered workflows properly. Check author_association against OWNER, MEMBER or COLLABORATOR before a /deploy-style comment does anything. Do not rely on github.actor comparisons, which zizmor flags as spoofable bot conditions. Never write untrusted text into GITHUB_ENV or GITHUB_PATH, because later steps execute it.
YAML
# Vulnerable: the PR title becomes shell code
- run: echo "Checking ${{ github.event.pull_request.title }}"

# Hardened: the title is data in an environment variable
- env:
    TITLE: ${{ github.event.pull_request.title }}
  run: echo "Checking $TITLE"

③ Third-party actions and mutable tags

uses: some-org/some-action@v4 is a pointer the action's maintainer, or anyone who steals their credentials, can move. tj-actions, reviewdog and Trivy were all tag rewrites. A pinned SHA also has a subtle trap: GitHub resolves commits from forks through the parent repository's name, so an "impostor commit" can look like it belongs to a trusted action. Trivy's v0.69.4 release was built from a commit that swapped an actions/checkout reference for exactly such an impostor.

  • Control 6: Lock every action to an immutable reference. Adopt workflow lockfiles: gh actions-lock writes .github/workflows/actions.lock with the exact commit of each action, including transitive ones, while your YAML keeps readable tags. Where you have not adopted lockfiles yet, pin to full 40-character SHAs with the version in a comment.
  • Control 7: Enforce it with organisation policy. Since August 2025 the allowed-actions policy can require full SHA pinning and block specific actions or versions with a ! entry; since October 2026 the "Require lockfile" policy can enforce lockfiles. Combine this with an allow-list of approved actions.
  • Control 8: Update through a bot with a cooldown. Configure Dependabot's github-actions ecosystem, or Renovate, so pins do not rot. Add cooldown.default-days so a freshly published release waits a few days before it lands. The poisoned trivy-action tags were live for about twelve hours, and CISA's exposure window for tj-actions ran from 12 to 15 March 2025. Security updates bypass Dependabot's cooldown, which is the behaviour you want.
  • Control 9: Vet and minimise third-party actions. Prefer actions from GitHub or a known vendor. Replace one-line wrappers with a run: step, and fork the few critical third-party actions internally. Check pins with zizmor's impostor-commit and known-vulnerable-actions audits.

④ Token scope and persisted credentials

Every job gets a GITHUB_TOKEN. On organisations created before February 2023 it is read-write by default, because GitHub only changed the default for new accounts. Unit 42's ArtiPACKED research showed a second leak path: actions/checkout persists the token in .git/config by default, and workflows that upload the whole workspace as an artifact publish it.

  • Control 10: Set the default token to read-only at organisation or enterprise level. One setting closes the gap for every repository that does not declare permissions.
  • Control 11: Declare permissions in every workflow and raise them per job. A top-level permissions: contents: read, with pull-requests: write or id-token: write only on the job that needs it. OpenSSF Scorecard's Token-Permissions check scores exactly this. Avoid permissions: write-all.
  • Control 12: Do not persist credentials, and never upload the workspace. Set persist-credentials: false on actions/checkout unless a later step really pushes. Upload named build outputs only, not . or the checkout directory.
YAML
permissions:
  contents: read          # workflow default: read-only

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production         # control 13: reviewers + branch rules
    permissions:
      contents: read
      id-token: write               # control 14: OIDC, this job only
    steps:
      - uses: actions/checkout@<full-sha> # v5, or locked via actions.lock
        with:
          persist-credentials: false  # control 12

⑤ Secrets and OIDC trust

Every stealer in the 2025–26 wave went for the same loot: registry tokens, cloud keys and personal access tokens kept as repository secrets. A secret available to every job is available to the most compromised job.

  • Control 13: Put deployment secrets in environments with required reviewers and branch rules. Environment secrets only reach jobs that reference the environment, and the deployment branch policy limits which refs can. Since 8 December 2025 those rules evaluate the execution reference, so recheck your patterns.
  • Control 14: Replace long-lived cloud keys with OIDC federation. The job requests a short-lived token from GitHub and exchanges it for cloud credentials scoped to one role. Our workload identity federation guide covers the Azure, AWS and GCP side.
  • Control 15: Bind the OIDC trust to an environment, not to a branch or "any workflow". A subject such as repo:org/repo:environment:production means only jobs that passed the environment's reviewers can assume the role. Note the newer immutable subject format, with owner and repository IDs, for repositories created after 15 July 2026. Trusted publishing can be turned against the publisher: researchers point to an over-broad OIDC trust policy in the 2026 SAP @cap-js incident, and in the Red Hat incident workflows with id-token: write published malicious versions with valid provenance. Our npm supply-chain teardown has the details.
  • Control 16: Pass named secrets only. Avoid secrets: inherit on reusable workflows and never serialise the whole secrets context with toJSON(secrets). zizmor's secrets-inherit and overprovisioned-secrets audits catch both.

⑥ Runners and egress

The runner is where the attacker's code executes. A non-ephemeral self-hosted runner lets one malicious job leave persistence for the next, often on a machine inside your network. GitHub's documentation is blunt: self-hosted runners "should almost never be used for public repositories". And every stealer in our incident list needed egress.

  • Control 17: Use ephemeral runners and restrict runner groups. GitHub-hosted runners, or just-in-time self-hosted runners that are destroyed after one job. Restrict runner groups to the repositories and workflows that need them, away from cloud metadata endpoints and internal networks.
  • Control 18: Control outbound traffic from runners. StepSecurity's Harden-Runner monitors egress in audit mode and can block anything outside an allow-list. The vendor says it detected the tj-actions compromise. GitHub's roadmap promises a native egress firewall for hosted runners, but we found no release announcement for it in the changelog as of 15 November 2026. On self-hosted runners use network policy or a proxy.

⑦ Cache and artifact poisoning

The Actions cache is shared within a branch and its descendants, and the default branch's cache can be read by every branch. Adnan Khan's 2024 research showed that code running on the default branch can poison entries that a later, more privileged workflow restores, including release builds. Ultralytics and TanStack both involved cache poisoning.

  • Control 19: Keep caches out of release and publishing workflows, and treat artifacts as untrusted input. Build releases from a clean state. Validate artifacts consumed by privileged workflows as data. zizmor's cache-poisoning audit flags the risky combinations.

⑧ The workflow files themselves

GhostAction did not exploit a workflow bug. It added a new workflow. Anyone who can push to a branch can add a workflow that runs with the repository's secrets on push. Branch protection on main does not help if the workflow runs on the attacker's branch.

  • Control 20: Protect, lint and monitor the workflow layer. Make .github/workflows and actions.lock CODEOWNERS-protected with required review, which GitHub's guidance recommends. Run zizmor or actionlint as a required check on every workflow change. Restrict who can create branches with rulesets. Stream the audit log, and enable secret scanning for Actions workflow logs, in public preview since 9 November 2026 for GitHub Enterprise Cloud with Secret Protection or Advanced Security.

What the numbers say: 200 public repositories

Checklists are cheap, so on 15 November 2026 we measured how many of these controls real projects use.

Method. We built two cohorts with the GitHub search API, excluding forks and archived repositories. The top cohort is the 100 most-starred repositories that contain at least one workflow; the smallest has about 110,000 stars. The mid-sized cohort is 100 repositories with 500–5,000 stars that were pushed to since 1 October 2026, ten for each creation year from 2015 to 2024. We downloaded every workflow file on the default branch, 2,318 files with 12,948 uses: references, parsed them as YAML and counted the patterns. The aggregates are in the CSV download. Two patterns are heuristics: a match means "needs review", not "exploitable". We did not test any repository and we name none. Open-source projects are not your enterprise estate, so treat the results as indicative, not as a benchmark.

How common the twenty controls are in 200 public repositories
How common the twenty controls are in 200 public repositories

The headline is the gap between doing something and doing it everywhere. 79% of workflow files declare token permissions, but only 41.5% of repositories do so in every workflow. One undeclared workflow inherits the default token. The same holds for pinning: 60% of all action references are pinned to a commit SHA, but only 30.5% of repositories pin every action. An attacker only needs the one reference you missed.

Credential hygiene is weaker still. Only 40% of actions/checkout steps set persist-credentials: false, and only 39.5% of repositories automate action updates through Dependabot's github-actions ecosystem or Renovate. The detective controls are close to absent. A workflow linter such as zizmor or actionlint runs in 10.5% of repositories, the OpenSSF Scorecard action in 5%, and Harden-Runner in 2%.

Risky patterns in the same 200 repositories
Risky patterns in the same 200 repositories

The risk side is more encouraging, with one large exception. 28.5% of repositories use pull_request_target somewhere, 40% in the top cohort. All of those workflows stop running in public repositories on 2 December 2026 unless their owners add an event policy. Our heuristic for the dangerous form, pull_request_target combined with a checkout of the pull-request head, matched in 2% of repositories. The classic script-injection pattern matched in 1%. permissions: write-all appears in 1.5% and self-hosted runners in 5.5%. In a large organisation, 2% is a list of repositories, not a rounding error.

Control prevalence in the 100 most-starred repositories compared with 100 mid-sized ones
Control prevalence in the 100 most-starred repositories compared with 100 mid-sized ones

Popularity buys some hygiene, not all of it. The top cohort pins 73% of action references to a SHA, against 35% in the mid-sized cohort, where most references are major-version tags such as @v4. The top projects are also more than twice as likely to disable persisted credentials and run a workflow linter. But even among the most-starred projects on GitHub, only 40% pin every action and 45% declare permissions in every workflow. Assume your internal repositories are no further along until you have measured them.

In a recent engagement…

This year we reviewed the GitHub organisation of a European software company with a few hundred repositories. Nobody had been careless. The organisation predated 2023, so the default token was still read-write. Deployments used OIDC to the cloud, but the federated credential trusted any branch, so protection depended entirely on who could push a branch.

Three findings mattered most. A labelling workflow used pull_request_target and checked out the pull-request head to read a configuration file. Release builds restored the same dependency cache as pull-request builds. And a popular community action was referenced by a major tag across dozens of repositories, so one stolen maintainer credential would have reached every build in the estate.

The fixes took weeks, not months. We set the default token to read-only and fixed the few workflows that failed. The labeller now reads the pull request through the API. OIDC trust is bound to a protected production environment with two reviewers, release workflows no longer use caches, and lockfiles arrived with a Dependabot cooldown. The slowest step was organisational: agreeing who approves new third-party actions.

The 20-control checklist

This is the screenshot-able part. Surface refers to the numbered sections above. Effort is our estimate for an organisation of a few hundred repositories. How to verify says what to check in a review.

#ControlSurfaceHow to implementHow to verifyEffort
1Block pull_request_target by default①Actions event policy; allow by exception with workflow file targetingPolicy in evaluate mode first; Insights shows blocked runsLow
2No PR-head checkout in privileged workflows①Split into unprivileged build + privileged reporter; artifacts as datazizmor dangerous-triggers, Scorecard Dangerous-WorkflowMedium
3Approval for fork PR workflows①Fork approval setting at org or enterprise levelSettings exportLow
4Untrusted input via env vars only②env: indirection, quoted shell variableszizmor template-injectionLow
5Gate comment and bot triggers②author_association checks; no untrusted writes to GITHUB_ENVzizmor bot-conditions, github-envLow
6Immutable action references③actions.lock via gh actions-lock, or full SHA pinsLockfile staleness check in CIMedium
7Enforce pinning and allow-list by policy③"Require lockfile" or SHA pinning policy; allowed-actions list with ! blocksPolicy settings at org/enterpriseLow
8Updates with a cooldown③Dependabot github-actions + cooldown, or Renovate minimumReleaseAge.github/dependabot.yml presentLow
9Vet and minimise third-party actions③Approval process; replace trivial actions with run:; internal forks for critical oneszizmor impostor-commit, known-vulnerable-actionsMedium
10Read-only default token④Org or enterprise workflow permission settingSettings exportLow
11Per-job permissions④Top-level contents: read; write scopes on the jobScorecard Token-PermissionsMedium
12No persisted credentials, no workspace uploads④persist-credentials: false; upload named outputs onlyzizmor artipackedLow
13Environments with reviewers⑤Environment secrets, required reviewers, deployment branch rulesEnvironment settings per repoMedium
14OIDC instead of long-lived cloud keys⑤Federated credentials per environmentNo cloud keys in secret inventoryMedium
15Environment-bound OIDC subject⑤Trust repo:org/repo:environment:prod, or a custom claim with job_workflow_refReview cloud trust policiesLow
16Named secrets only⑤No secrets: inherit, no toJSON(secrets)zizmor secrets-inherit, overprovisioned-secretsLow
17Ephemeral, scoped runners⑥GitHub-hosted or JIT runners; runner groups; none on public reposRunner inventoryMedium–High
18Egress control on runners⑥Harden-Runner audit → block; network policy on self-hostedEgress baseline per workflowMedium
19No cache in release workflows⑦Clean builds for releases; validate consumed artifactszizmor cache-poisoningLow
20Protect, lint and monitor workflows⑧CODEOWNERS on .github/; zizmor/actionlint required check; audit-log streaming; log secret scanningRequired checks in rulesetsMedium

One warning: pinning without updating is a slow-motion vulnerability, so controls 6 and 8 belong together.

Governance for European enterprises

In the EU, pipeline hardening is no longer just an engineering preference.

Cyber Resilience Act. Regulation (EU) 2024/2847 applies in full from 11 December 2027, but the Article 14 reporting obligations have applied since 11 September 2026. If an attacker uses your pipeline to tamper with a release of a product with digital elements, that can be a severe incident affecting the security of the product, with an early warning due within 24 hours. A monitored pipeline is how you would know in time. Our CRA reporting runbook covers the decision tree.

NIS2. Article 21(2) of Directive (EU) 2022/2555 requires essential and important entities to manage supply-chain security (point d) and security in the acquisition, development and maintenance of network and information systems (point e). In Germany the NIS2 implementation act has applied since 6 December 2025 without a transition period. This checklist, evidenced by policy exports and zizmor reports, is a proportionate answer when auditors ask how build systems are protected.

DORA. For financial entities, workflows that deploy to production are ICT change-management controls, so their permissions, reviewers and logs are audit evidence.

None of these regimes names GitHub Actions. All expect you to show who could change what reached production.

A pragmatic adoption path

  1. Week 1: inventory and quick wins. Export organisation settings, list every workflow using pull_request_target, workflow_run or issue_comment, and run zizmor across all repositories. Set the organisation default token to read-only (control 10) and see what breaks.
  2. Week 2: triggers and injection. Prepare for the 2 December default: put an event policy in evaluate mode, fix or remove privileged triggers that check out PR code (controls 1–3), and fix every template-injection finding (controls 4–5).
  3. Week 3: lock the supply chain. Introduce lockfiles or SHA pins with Dependabot and a cooldown (controls 6, 8), then turn on the enforcement policy and an allow-list (control 7).
  4. Week 4: secrets and identity. Move deployment credentials into environments with reviewers, replace cloud keys with OIDC bound to those environments, and remove secrets: inherit (controls 13–16). Our SLSA Level 3 on GitHub Actions guide builds on this for provenance.
  5. Week 5 and beyond: runners, caches, monitoring. Move to ephemeral runners, put Harden-Runner in audit mode and then block mode, drop caches from release workflows, and make zizmor a required check with CODEOWNERS on .github/ (controls 17–20).

The verdict

GitHub Actions is not insecure. It is permissive by default, and permissive defaults compound. Each permissive choice is defensible alone. Together they turn a stranger's pull request into your release.

Our view is opinionated. If you do one thing this month, set the default token to read-only and declare permissions per job. If you do two, adopt lockfiles or SHA pins with a cooldown, because tag rewriting is the attack that has actually happened, twice, at scale. Then use GitHub's 2 December change to remove pull_request_target from every workflow that does not need it. Everything else on the list makes the next incident smaller.

If you want help, our DevSecOps team runs this twenty-control review as a short, fixed-scope engagement across your GitHub organisation. You leave with the checklist filled in and the first policies switched on.

FAQ

What changes for pull_request_target on 2 December 2026?

From 2 December 2026 GitHub Actions blocks pull_request_target events by default in all public repositories on GitHub Free, Team and Enterprise Cloud, unless an Actions event policy explicitly allows them. Private and internal repositories and GitHub Enterprise Server are not affected. If a workflow genuinely needs the trigger, allow it in an event policy scoped to that workflow file, and make sure it never checks out or runs pull-request code.

Should we pin GitHub Actions to commit SHAs or use the new lockfile?

Either gives you an immutable reference; a tag such as v4 does not. Workflow lockfiles became generally available on 28 October 2026. The gh actions-lock extension writes .github/workflows/actions.lock, which records the exact commit for every action, including transitive ones, and Dependabot updates it. GitHub's secure-use guidance says a lockfile supersedes SHA pinning where you adopt it. Full-length SHA pins remain the fallback, and administrators can enforce either through policy.

What permissions should the GITHUB_TOKEN have?

Read-only by default, raised per job only where a job needs it. Set the organisation or enterprise default to read-only, because GitHub only made that the default for accounts created after February 2023. Then declare a top-level permissions block in every workflow, usually contents: read, and grant write scopes such as pull-requests: write or id-token: write on the individual job that needs them.

How does OIDC make GitHub Actions deployments safer?

With OpenID Connect the job requests a short-lived token from GitHub and exchanges it with your cloud provider for a short-lived access token, so no long-lived cloud key is stored as a secret. The safety depends on the trust condition. Bind it to a protected environment, for example repo:org/repo:environment:production, rather than to any branch or pull request, and require reviewers on that environment.

Which tools can audit our GitHub Actions workflows?

zizmor is a static analyser for workflows with audits such as template-injection, dangerous-triggers, unpinned-uses, excessive-permissions, artipacked and cache-poisoning. actionlint catches syntax and expression errors. OpenSSF Scorecard rates repositories on checks including Dangerous-Workflow, Token-Permissions and Pinned-Dependencies. StepSecurity Harden-Runner adds runtime egress monitoring and blocking on the runner.

Did the tj-actions and Trivy compromises affect workflows pinned to a commit SHA?

Pinning to a full commit SHA protected against the tag rewrites themselves. In March 2025 the attacker repointed the tj-actions/changed-files tags to a malicious commit, and in March 2026 76 of 77 trivy-action tags were force-pushed. A workflow pinned to an older, clean SHA kept running the clean code. Pinning does not help if you pin the malicious commit, which is why updates should pass a cooldown and a review.

Sources

All sources checked on 15 November 2026. Sample data is our own and is labelled as such.

Tier A: primary, advisory and regulatory

Tier B: research and analysis

Tier C: vendor and tooling, directional

Topics

GitHub Actions securityGitHub Actions hardeningpull_request_targetGitHub Actions workflow lockfilepin actions to commit SHAGITHUB_TOKEN permissionsOIDC GitHub ActionsCI/CD security controls

Frequently Asked Questions

From 2 December 2026 GitHub Actions blocks pull_request_target events by default in all public repositories on GitHub Free, Team and Enterprise Cloud, unless an Actions event policy explicitly allows them. Private and internal repositories and GitHub Enterprise Server are not affected. If a workflow genuinely needs the trigger, allow it in an event policy scoped to that workflow file, and make sure it never checks out or runs pull-request code.

Expert engagement

Need expert guidance?

Our team specializes in cloud architecture, security, AI platforms, and DevSecOps. Let's discuss how we can help your organization.

Get in touchNo commitment · No sales pressure

Related articles

All posts