AI Development Supply-Chain Attacks: MCP Servers, Hooks, and CI/CD

TL;DR

AI development supply-chain attacks are creating an execution problem that traditional source-code security reviews do not fully address. Attackers can manipulate repository configuration, malicious MCP server packages, coding-assistant hooks, and CI/CD workflows to move from source content into developer or automation privileges. Google Threat Intelligence Group documented suspected North Korean actors modifying Claude Code settings to deliver the SOMBERMEME backdoor, while separate investigations of UNC6780 and the testmetest campaign revealed malicious MCP integrations, developer-workspace hooks, credential theft, and attempts to compromise software publishing.

The critical boundary is not the language model alone. A coding assistant may read repository instructions, discover tools through MCP, invoke local commands, and participate in automation. Some configuration files execute commands through supported lifecycle hooks, while CI/CD workflows can access repository tokens, software publishing identities, cloud credentials, and deployment systems. The risk depends on which of those capabilities are granted and whether untrusted material can change their behavior.

Treat agent configuration, MCP integrations, and pipeline definitions as executable supply-chain dependencies. Inventory them, review changes independently, restrict their credentials and execution environments, and validate that untrusted repository content cannot become production authority merely because an agent or build runner processed it.

In This Article

Introduction

Consider a development team introducing an AI coding assistant to an existing application repository.

The team has reasonable safeguards. Developers authenticate through enterprise identity, source changes require pull requests, production deployments use approved pipelines, and secrets are stored outside application code.

This installment extends the AI cyberattack series into the software development and publishing path.

The assistant is allowed to inspect the repository, help developers diagnose issues, run approved tests, and interact with selected tools.

One afternoon, an attacker compromises a developer account and changes a configuration file inside the repository.

The next engineer opens the project and starts the coding assistant. Under the affected configuration and trust conditions, a startup hook launches an unexpected command.

No vulnerable application endpoint was exploited. No production deployment was required. The malicious behavior entered through the development workflow before the engineer began working on application code.

This is not merely a hypothetical failure pattern.

Google’s November 16, 2026 threat intelligence report describes suspected North Korean actors modifying .claude/settings.json files in internal repositories so that subsequent Claude Code startup triggered delivery of the SOMBERMEME backdoor. See Google’s November investigation.

The incident exposes an important difference between application source code and development execution configuration.

A repository may contain files that the developer expects to read or edit. It may also contain files that configure tools to execute commands, initialize development environments, register external services, or control privileged automation.

Those files create distinct trust relationships.

The security question is therefore not simply whether an AI assistant can be prompted into making a mistake.

It is whether an attacker who controls repository content can influence what executes on a developer workstation, which credentials become reachable, and whether a compromised workflow can publish or deploy software under trusted enterprise authority.

This article examines that problem through three documented 2026 investigations and develops an implementation model covering MCP servers, coding-agent hooks, development environments, and CI/CD systems.

The scope is defensive architecture and operations. It does not provide malware deployment instructions, assume that every malicious package used AI to develop its payload, or claim that an autonomous model independently directed every observed attack.

The Development Environment Is Now an Execution Supply Chain

Traditional software supply-chain security often begins with source code, dependencies, build tools, and deployment artifacts.

Those remain critical.

AI development introduces additional configuration and orchestration layers that can influence execution before an application build even starts.

Consider the difference between a repository README, a coding-assistant instruction file, and a startup hook.

A README ordinarily provides information for a person or tool to interpret.

An instruction file may influence an assistant’s proposed actions.

A startup hook can cause a command to execute at a defined lifecycle event.

A CI/CD workflow can execute commands on a build runner, sometimes with credentials capable of publishing packages or deploying infrastructure.

These are different forms of authority.

The Four Boundaries That Matter

BoundaryWhat crosses itSecurity consequence
Repository content to assistant contextFiles, instructions, comments, tool resultsUntrusted text may influence the agent’s decisions
Repository configuration to local executionHooks, IDE tasks, setup scripts, dependency install behaviorA project file may cause a command to execute
MCP integration to enterprise toolsTool definitions, server code, authorization and requestsAn agent may reach files, APIs, or systems beyond the original task
CI/CD workflow to publishing or deploymentRunner permissions, secrets, federation, artifactsCompromised build logic may exercise trusted enterprise authority

The first boundary is primarily about instructions and interpretation.

The second and fourth can involve direct program execution.

The third can involve both, because an MCP server supplies structured tool capabilities and may itself execute code or make downstream requests.

A secure development architecture should not govern all four with the same generic prompt instruction.

It needs controls at the actual enforcement points.

The November SOMBERMEME Investigation: Repository Settings as an Attack Path

Google Threat Intelligence Group reported that suspected actors associated with a cluster it tracks as MIDNIGHT NEPTUNE targeted cryptocurrency organizations in North America and Europe.

The reported intrusion sequence began with social engineering.

The attackers used fraudulent recruiter identities, deceptive meeting platforms, and ClickFix-style instructions to induce initial execution.

Google reported evidence of AI-generated identity imagery and assessed some staging scripts as likely LLM-authored.

After gaining access, the actors moved into internal code repositories.

That later stage is the part most relevant to enterprise development security.

From Repository Modification to Developer Execution

Google reported that the attackers modified .claude/settings.json configuration files.

Those modifications caused affected Claude Code sessions to trigger downloads of a backdoor Google identifies as SOMBERMEME when developers started Claude Code.

The attackers also created GitHub personal access tokens named to resemble Microsoft Copilot-related activity.

The token naming was a form of concealment. A token’s display name does not establish that it belongs to the product it resembles.

Several boundaries were crossed in the reported operation.

The first was the compromised developer or repository access that allowed configuration changes.

The second was the coding assistant’s use of project-level settings.

The third was local execution with the privileges available to the affected developer environment.

The attackers did not need to compromise Claude Code’s software distribution infrastructure to abuse its supported configuration capabilities.

Why the Configuration File Matters

Anthropic’s Claude Code documentation describes several settings scopes. See Claude Code settings documentation.

The project file .claude/settings.json can be committed to version control and shared among teammates.

The local file .claude/settings.local.json supports project-specific personal configuration.

Organization-managed settings provide a separate administrative policy layer.

Claude Code also supports hooks triggered by lifecycle events, including session startup and tool use. See the hooks reference.

These hooks may execute commands or invoke other handlers.

That is legitimate product functionality. Teams can use it for initialization, validation, and workflow automation.

It also means that changes to hook configuration should receive more scrutiny than ordinary documentation edits.

The exact execution outcome depends on the client version, applicable settings, managed policy, trust prompts, and the environment in which the tool starts. It would be incorrect to claim that every cloned repository automatically executes every hook without approval.

Google’s finding is that the attackers successfully abused this configuration path in the environments it investigated.

The Architectural Failure

Imagine a repository in which application source changes require senior review, but project-level agent configuration can be modified by any contributor.

The organization has effectively placed a potentially executable configuration path under weaker governance than the application source it was designed to support.

The correction is not to prohibit coding-assistant hooks universally.

It is to classify execution-affecting configuration as a protected development asset.

That means identifying which files can change tool behavior, who can approve those changes, what privileges the commands inherit, and how a developer can inspect a new project’s configuration before permitting execution.

For sensitive projects, organization-managed policy should establish restrictions that repository-local configuration cannot simply override.

UNC6780: When MCP Packages and Build Workflows Become the Payload

Google’s September 2026 threat tracker describes a separate supply-chain campaign attributed to UNC6780, also tracked as TeamPCP.

The actor had targeted package ecosystems including PyPI, npm, and Docker Hub.

Google reported that UNC6780 compromised legitimate developer accounts to publish trojanized forks of MCP servers, including tiktoken_mcp, and modified code in organizational repositories such as azure-functions-mcp-extension. See Google’s September investigation.

These were malicious software and repository changes.

Their significance does not depend on proving that an AI model autonomously created the malicious code.

The attack path involved software developers and coding assistants consuming or executing compromised development dependencies.

Why MCP Servers Are Attractive Targets

Model Context Protocol provides a standardized interface for clients to discover and invoke tools, access resources, and interact with external capabilities.

An enterprise might connect a coding agent to source repositories, issue trackers, build systems, documentation services, cloud APIs, or internal development tools through MCP servers.

That is useful because the agent no longer requires a custom integration for every capability.

But an MCP server is not just a static document.

A locally installed server may be a running process with access to the developer’s files and environment. A remote server may receive authenticated requests and interact with external resources.

A malicious implementation can misuse the execution environment or authorization granted to that server.

Likewise, a compromised tool response or description can attempt to influence how an assistant uses other available capabilities.

These are related but separate risks: malicious server code, abused credentials, and instruction manipulation through tool content.

What Google’s Investigation Found

Google reported that the UNC6780 campaign used malware it calls DUSTMAKER.

Its analyzed functionality included manipulating hidden development configuration, including AI coding-assistant and integrated development environment directories.

Google described techniques that could create startup or build-triggered execution, manipulate assistant behavior through malicious configuration instructions, and establish malicious GitHub Actions workflows.

The research also identified code designed to recognize CI/CD environments and obtain credentials associated with software publishing.

Google described functionality intended to extract GitHub Actions OpenID Connect (OIDC) tokens and use trusted publishing paths.

Those capabilities are significant, but observed code functionality should not be presented as proof that every intended publication or downstream compromise succeeded.

The stronger, directly documented lesson is that a single attacker campaign targeted several connected trust boundaries:

  • Developer accounts and repository write access.
  • MCP package distribution and installation.
  • Coding-assistant workspace configuration.
  • CI/CD workflow definitions and execution.
  • Publishing tokens and software artifact provenance.

This is more than a compromised library imported by an application.

It is an attack against the mechanisms by which developers and automation decide what to trust, execute, build, and publish.

The testmetest Campaign: Turning Development Startup Into a Delivery Mechanism

A third investigation reinforces the same trust-boundary problem through a different campaign.

On October 26, 2026, JFrog Security Research published findings linking malicious npm packages to compromised GitHub repositories and development-tool startup mechanisms. See JFrog’s analysis.

Researchers identified 42 prepared repositories belonging to 11 legitimate owners.

The affected repositories contained malicious execution hooks for AI coding assistants and development environments, including Claude Code, Gemini, Cursor, and Visual Studio Code.

The campaign also used modified package and build configurations to support its execution and publishing objectives.

Why This Case Is Different

The attackers did not depend solely on persuading an AI model to follow malicious natural-language instructions.

They placed executable configuration into repositories.

Under affected development-tool configurations, ordinary activities such as opening a project or starting an assistant could provide an opportunity to execute attacker-controlled code.

JFrog also found that unusually large encoded payload files were not visible through some conventional GitHub code-search and content-retrieval paths.

Investigators needed broader repository-tree enumeration to identify the relevant files.

That finding matters for defenders who rely on searches for suspicious filenames or text patterns.

A search returning no matches is not proof that every repository object has been inspected.

What the Evidence Supports

JFrog confirmed the presence of prepared malicious repositories and analyzed the execution and publishing mechanisms.

It identified account hijacking, credential exposure, altered repository histories, and infrastructure designed to support further malicious package publication.

The investigation did not establish a complete count of developer workstations that executed the hooks or a precise total of downstream systems compromised through those repositories.

The researchers also avoided definitive attribution to the operators of earlier malware campaigns that shared similar techniques.

The important conclusion is that the repository itself became a delivery mechanism.

This was not the same incident as Google’s MIDNIGHT NEPTUNE or UNC6780 investigations, although all three illustrate the growing importance of development configuration as an attack surface.

The Enterprise Development Trust Boundary

The three investigations reveal a common architectural problem.

Content enters a development environment through several channels, but the organization may not classify those channels according to what they are permitted to execute.

A third-party MCP package may be approved because it provides a useful search tool.

A repository may be trusted because it belongs to the organization.

A CI/CD workflow may be trusted because it runs under an enterprise-managed GitHub organization.

A coding assistant may be trusted because the company purchased an approved subscription.

None of those statements independently establishes that every file, configuration change, tool response, or command is trustworthy.

The following model separates the sources of change from the identities and permissions that make an action consequential.

Lower-trust development inputs pass through coding-assistant configuration and execution identities, with independent review and provenance checks at the protected release boundary.

A useful design preserves a separation between proposing work and authorizing its execution.

A coding assistant may prepare a code change without receiving production deployment credentials.

A repository may contain configuration that developers review without allowing it to execute automatically.

An MCP server may provide approved tools while remaining unable to access unrelated secrets or administrative APIs.

A build runner may test untrusted contributions without receiving publishing authority.

These are separate controls because the underlying execution mechanisms differ.

MCP Security Begins Before a Tool Is Invoked

MCP simplifies the connection between AI applications and external tools. It does not automatically establish that an MCP server is trustworthy or authorized for every operation it exposes.

The Model Context Protocol specification released July 28, 2026, includes an updated authorization model for HTTP-based MCP servers.

The specification requires protected servers to validate access tokens for the intended resource audience when authorization is implemented. It also addresses token handling and authorization-server behavior. See the MCP authorization specification.

However, authorization remains optional at the protocol level, depending on the transport and implementation.

For local standard-input/output (stdio) servers, the execution environment and locally provided credentials become especially important.

Distinguish Server Trust From Tool Authorization

A server may be authentic and still be inappropriate for a particular enterprise workflow.

Consider a legitimate development MCP server that exposes repository search, issue creation, pull-request modification, and workflow management tools.

The organization may approve repository search for a coding assistant.

That does not mean the assistant should also receive unrestricted authority to modify deployment workflows.

The control decision must consider the caller, requested operation, target repository, environment, and impact.

A tool’s descriptive metadata is not an independent authorization decision.

Nor should a tool response be treated as trusted instructions merely because it arrived through an approved MCP connection.

The Local Server Problem

A locally installed MCP server runs as software in the developer’s environment.

Depending on the launcher and process permissions, it may be able to access local files, environment variables, network connections, or credentials available to the operating-system account.

A malicious package therefore creates risks even if the coding assistant never voluntarily invokes a sensitive tool.

The package may contain its own installation or execution behavior.

This is why package provenance, installation review, and runtime isolation belong alongside MCP-specific authorization controls.

The Remote Server Problem

A remote MCP server introduces a different boundary.

It receives requests over a network connection and may authenticate the client using OAuth-based mechanisms.

The enterprise needs to validate the server identity, intended token audience, approved scopes, tool catalog, and downstream access.

The protocol’s authorization model does not eliminate the need for enterprise-specific policy.

A valid token may prove the caller has permission to use the server. It does not prove that the requested operation is appropriate for the business task.

MCP standardizes how capabilities are exposed. The enterprise must still decide which capabilities are allowed and under which conditions.

CI/CD Is the Boundary Where Development Compromise Becomes Publishing Authority

A compromised developer workstation is serious.

A compromised build or publishing workflow can have a much broader impact because it may create artifacts consumed by many downstream systems.

GitHub’s security guidance identifies workflow tokens, secrets, third-party actions, and untrusted pull-request content as important controls.

The specific risk is the transition from lower-trust source material into a workflow that possesses privileged execution authority.

Protect Privileged Workflow Triggers

GitHub documents a significant difference between pull_request and pull_request_target. See GitHub’s privileged-trigger guidance.

For pull requests from forks, the normal pull_request workflow has protections that restrict token permissions and secrets.

The pull_request_target event runs trusted workflow definitions from the base repository and can receive greater authority.

That distinction is useful for approved automation.

The danger appears when a privileged workflow then checks out or executes untrusted pull-request code.

The source material may be controlled by an outside contributor while the executing job has privileges associated with the base repository.

GitHub warns against that pattern.

The defensive requirement is to keep untrusted testing and privileged publishing in separate execution contexts.

As of November 18, 2026, GitHub’s default public-repository policy for pull_request_target is in evaluate mode, with enforcement scheduled for December 2. It does not cover private or internal repositories or override an existing repository policy. Check the effective policy and checkout protections for each repository instead of assuming that this rollout already blocks unsafe execution.

Short-Lived Credentials Still Need Scope

GitHub Actions can use OpenID Connect to request short-lived credentials from cloud providers instead of storing reusable credentials as repository secrets. See GitHub’s OIDC guidance.

That is a valuable security improvement.

It does not eliminate risk if the cloud trust policy allows the wrong repository, workflow, branch, environment, or other principal to request authority.

A malicious workflow running under an accepted identity may still obtain a valid short-lived token.

The proper design uses narrowly scoped trust conditions, protected deployment environments, explicit workflow permissions, and independent authorization for high-impact actions.

Artifact Attestations Are Evidence of Origin, Not Proof of Safety

Artifact attestations can provide cryptographic evidence of where and how software was built.

GitHub’s documentation explains that attestations can identify the repository, workflow, commit, event, and other provenance information. See the artifact-attestation documentation.

That evidence is useful for determining whether a released artifact came from an approved build process.

But a correctly signed artifact is not automatically safe.

If the source repository, workflow, dependency, or publishing authority was compromised before the build, the resulting artifact may have legitimate provenance while containing unauthorized changes.

The UNC6780 investigation makes this distinction especially relevant because the analyzed malware targeted software-publishing credentials and OIDC-related workflows.

A defensible release process therefore asks two questions:

Was this artifact produced by an approved workflow?

Was the workflow operating on approved source and dependencies under trustworthy authority?

Both need evidence.

An Implementation Model for Governing Development Execution

The objective is not to add a manual approval to every file edit.

It is to classify which changes can alter execution authority and place appropriate controls around those changes.

Start by defining the development surfaces that deserve stronger review.

Asset or surfaceMain riskRecommended controlVerification evidence
Coding-agent settingsUnapproved hooks or permission changesProtected configuration review and managed policyApproved revisions and effective settings
IDE workspace configurationCommands executing during project startupRestrict automatic tasks and review executable settingsWorkspace configuration and process evidence
MCP server packagesMalicious code or unexpected local accessApproved package sources, version control, isolationPackage provenance and runtime inventory
MCP tool definitionsTool misuse or malicious instructionsApproved tool catalog, independent authorizationTool identity, policy decision, target and result
CI/CD workflowsUntrusted code running with privileged tokensSeparate test and release jobs, minimum permissionsWorkflow revision, runner identity, token scope
Third-party actionsDependency replacement or compromised actionApproved actions and dependency locking where supportedResolved action identity and reviewed revision
Publishing credentialsUnauthorized package or image releaseScoped federation, protected publishing workflowsIssuer, subject, artifact and approval evidence
Build artifactsCompromised output accepted as trustedProvenance verification plus source and workflow reviewAttestation, dependency inventory and release acceptance

The controls should be adapted to the organization and its development tooling.

A managed coding-agent platform, a local developer CLI, and a cloud-hosted autonomous coding service may have different execution and configuration boundaries.

Do not assume that settings from a local workstation automatically apply to a hosted coding session.

Apply the agent blast-radius policy gates to the workstation, tool process, and release identity as separate control points.

Protect Execution-Affecting Configuration

Create an approved inventory of the files that can define hooks, tool connections, workspace tasks, and workflow permissions.

Examples include:

  • .claude/settings.json
  • .gemini/settings.json
  • .cursor/mcp.json
  • .cursor/rules/
  • .vscode/tasks.json
  • .github/workflows/
  • Relevant package installation scripts and build definitions

These paths are illustrative and based partly on the reported campaigns. They are not a universal inventory of every coding agent or IDE.

Use repository rulesets, protected branches, and code ownership controls to require appropriate review of changes to these files.

The team reviewing a new application feature does not necessarily need to understand every AI tool hook. The reviewer approving execution-affecting configuration should.

Restrict Local Execution

Evaluate the development environment’s privileges and dependencies.

A coding assistant that only needs to inspect and modify application files should not automatically inherit production cloud credentials, privileged SSH access, package publishing secrets, or unrestricted access to unrelated repositories.

Use supported sandboxing and filesystem restrictions where available.

Separate sensitive administration from routine development when the operational model permits.

Avoid making local security dependent on an instruction that tells the model not to perform dangerous actions.

The control should exist in the process environment, permission system, tool authorization, and network boundaries.

Separate CI Testing From Release Authority

Use a low-privilege execution environment for untrusted source changes.

Reserve software publishing and production deployment credentials for independently approved workflows.

Review the triggers that permit a workflow to cross that boundary.

For GitHub Actions, set the minimum required token permissions and use supported dependency-locking or immutable action-reference practices.

GitHub’s 2026 security guidance describes workflow dependency lockfiles as a stronger option where supported, with full commit-SHA pinning as an alternative when lockfiles are unavailable. See GitHub’s secure-use reference.

The exact feature availability depends on repository and plan conditions, so implementation must be validated against the applicable GitHub documentation.

The design principle remains independent of the product:

A build job that runs untrusted code should not automatically possess the credentials required to publish or deploy the resulting artifact.

A Practical Governance Contract

The following YAML is a conceptual enterprise policy record. It is not executable Claude Code, Cursor, MCP, or GitHub Actions configuration.

Its purpose is to connect repository classification, tool authorization, build privileges, and evidence requirements to named owners.

development_supply_chain:
  policy_version: "2026-11"
  default_decision: deny_unreviewed_execution

  owners:
    repository_policy: platform_engineering
    tool_security: application_security
    identity: enterprise_iam
    release_authority: release_engineering

  repository_configuration:
    protected_paths:
      - ".claude/"
      - ".gemini/"
      - ".cursor/"
      - ".vscode/tasks.json"
      - ".github/workflows/"
      - "build_and_package_scripts"
    independent_review_required: true
    unauthorized_change_action: block_and_investigate

  coding_assistants:
    permitted_work:
      - inspect_approved_source
      - propose_code_changes
      - run_approved_tests
    unreviewed_project_hooks: prohibited
    production_credentials: prohibited
    privileged_execution: separate_approval

  mcp:
    approved_servers_only: true
    server_provenance_required: true
    tool_catalog_review: required
    caller_and_resource_authorization: required
    token_audience_validation: required_where_applicable
    sensitive_tool_use: approval_gated

  cicd:
    untrusted_source_jobs:
      publish_authority: false
      production_secrets: false
      repository_write: false

    release_jobs:
      protected_workflow_required: true
      scoped_identity_required: true
      provenance_verification_required: true
      independent_release_approval: true

  incident_response:
    preserve_repository_and_workflow_history: true
    revoke_exposed_credentials: true
    inspect_developer_and_runner_hosts: true
    verify_published_artifacts: true
    require_trusted_rebuild: true

Replace the ownership roles and controls with the organization’s actual processes.

Some environments will not support every desired restriction natively. Others may implement them through an enterprise agent controller, managed endpoint policy, identity provider, pipeline platform, or repository governance.

The policy record should not be treated as proof of enforcement.

A successful implementation requires evidence that unauthorized configuration changes are blocked, an unapproved MCP server cannot reach protected resources, and a low-trust build job cannot acquire publishing authority.

Where controls cannot be enforced, record the gap and evaluate whether the workflow must remain advisory or isolated until the missing boundary is available.

Validate the Boundary Before Giving an Agent More Authority

A production readiness exercise should cover more than whether the coding assistant can complete a development task.

It should establish what happens when a relevant trust boundary is challenged.

The test environment should be isolated from production, use synthetic credentials and non-sensitive fixtures, and have explicit authorization from the responsible engineering and security teams.

Test Repository Configuration Control

Introduce an approved test change to a nonproduction repository’s agent configuration.

Verify that the review process recognizes the change as execution-affecting.

Confirm that the intended administrative policy is applied when the project is opened and that the change cannot silently override managed restrictions.

The test should use a harmless marker or controlled validation action, not malware.

Test MCP Tool Scope

Connect a nonproduction agent to an approved MCP server with separate read and write operations.

Verify that the agent can perform the authorized read.

Attempt a disallowed operation using test objects and confirm that the independent authorization layer blocks it.

Record the requesting identity, tool, resource, policy decision, and enforcement result.

An assistant declining the action in natural language is useful feedback, but it is not equivalent to a denial by the target service.

Test CI/CD Separation

Submit a controlled test change through the repository’s normal contribution path.

Verify that its testing workflow receives only the intended permissions and cannot access production publishing credentials.

Then validate that release authority is available only through the approved protected workflow and identity conditions.

Do not use real secrets as probes.

The test should establish the privileges visible to each job and the denial of unauthorized operations.

Test Artifact Provenance

Produce a harmless test artifact through the approved build workflow.

Validate the artifact’s provenance against the expected repository, workflow, commit, and release conditions.

Then confirm that the release gate also checks the approved source and workflow state.

The purpose is to prove that an artifact is not accepted simply because it has a valid signature from an unexpected or compromised workflow.

Responding to a Suspected Compromised Development Environment

The first response decision is whether suspicious repository or tool activity has remained inside a local development environment or reached broader enterprise authority.

A changed hook can affect multiple developers.

A compromised MCP package can execute in more than one workstation or runner.

A malicious workflow can alter published software or create additional credentials.

The response therefore needs to follow the authority chain rather than stop at the initially discovered file.

Preserve the Development Evidence

Retain relevant repository history, configuration revisions, package versions, build definitions, workflow changes, and available audit records.

Include developer endpoint and CI runner telemetry where accessible.

For a suspected hook incident, identify when the configuration changed, which developers or runners consumed that revision, and what execution occurred afterward.

For an MCP compromise, establish where the server was installed, which process or identity ran it, and what resources it could access.

For a publishing compromise, identify the affected artifacts, registry activity, publishing identity, and downstream consumers.

Avoid deleting the only available evidence while performing routine repository cleanup.

Contain Execution and Credentials Independently

Disable or restrict the suspected hook, package, server, or workflow through trusted administration.

Then examine the credentials and sessions reachable by the affected execution environment.

The dormant-access guide explains why removing the initial entry path does not establish that attacker-created access is gone.

If a developer workstation was compromised, investigate SSH keys, personal access tokens, repository permissions, cloud sessions, and other relevant credentials according to their actual exposure.

For CI/CD compromise, assess workflow tokens, OIDC trust relationships, publishing identities, and potentially affected artifacts.

Removing malicious repository configuration does not invalidate credentials already stolen or additional workflow permissions established during the intrusion.

Restore Trusted Development and Release Paths

Rebuild compromised development environments or runners from trusted sources when required by the investigation.

Restore approved configuration from verified revisions rather than merely checking out the latest default branch.

Review whether malicious changes entered package registries, container images, or production deployments.

Where an artifact may have been published through a compromised workflow, its provenance needs investigation alongside its contents.

A valid signature alone does not close that investigation.

Verify That the Attack Cannot Resume

Recovery should establish that the malicious configuration no longer executes, unauthorized MCP tools are unavailable, compromised credentials are invalid, and the affected workflows no longer have unapproved permissions.

Where a development agent could have queued work or submitted changes to external systems, reconcile those effects before restarting automation.

Validate representative build and release operations using trusted source, approved dependencies, and controlled credentials.

A development workstation launching successfully is not proof that the software supply chain has recovered.

Common Failure Modes

The documented incidents reveal several recurring mistakes.

Treating repository content as inherently trusted. A repository can be owned by the organization while containing malicious changes introduced through a compromised account or dependency.

Approving an MCP package based only on its name or directory listing. Package identity and listing metadata do not establish implementation integrity or acceptable permissions.

Treating prompt instructions as security enforcement. A prompt may discourage unsafe actions but cannot replace process isolation, credential restrictions, or independent authorization.

Reviewing application code while ignoring agent settings. A harmless-looking configuration change can alter what executes during startup or tool use.

Relying exclusively on code search. JFrog’s testmetest investigation demonstrated how oversized payload files could evade ordinary search and content-retrieval workflows.

Allowing privileged pipelines to execute untrusted source. A protected workflow loses its intended trust boundary when it fetches and runs attacker-controlled code with secrets or elevated tokens.

Assuming OIDC makes the workflow trustworthy. Short-lived federation reduces persistent-secret exposure but still depends on correct issuer, subject, environment, and resource authorization.

Assuming attestation proves benign software. Provenance establishes an origin and build relationship. It must be evaluated together with source integrity and workflow trust.

Removing the malicious file without investigating downstream effects. Additional credentials, published artifacts, compromised runners, and submitted changes may persist after the original configuration is corrected.

These failures are not unique to AI.

AI development tools make them more consequential because they connect additional sources of instructions and configuration to executable capabilities.

What Enterprises Should Change First

The practical starting point is a targeted inventory of development execution authority.

Select a small number of repositories that use coding agents, MCP tools, and automated publishing.

For each, determine which configuration can execute commands, which external packages are installed, which identities the development tools use, and whether a lower-trust contribution can reach publishing authority.

The initial decisions should produce an explicit boundary between source interpretation, local execution, and release operations.

Protect execution-affecting configuration through appropriate review. Restrict MCP tools to approved resources. Keep untrusted CI jobs away from privileged credentials. Validate artifact provenance without treating it as proof of benign contents.

Then conduct an authorized test of the most important boundary.

If a malicious repository change can reach a production token or software publishing identity, the organization has identified an architectural weakness worth correcting before expanding coding-agent autonomy.

Conclusion

The 2026 development supply-chain investigations demonstrate a specific change in enterprise attack surface.

Google reported attackers using modified Claude Code project settings to deliver SOMBERMEME, separate compromises involving trojanized MCP packages and CI/CD workflows, and malware designed to manipulate development tooling and publishing authority.

JFrog independently documented another campaign that placed malicious execution hooks and payloads into legitimate repositories, including artifacts that were not visible through some conventional code-search methods.

These incidents do not establish that every coding assistant or MCP server is vulnerable in the same way. They show that development configuration and integration software can become attack delivery mechanisms when execution authority is not properly separated from lower-trust content.

The enterprise response is to preserve that separation.

Repository files should not receive production authority because they are present in a trusted project. MCP integration should not imply unrestricted access to every connected system. CI/CD execution should not transform an unreviewed contribution into a privileged software release.

The central operating question is whether a change introduced through a repository, dependency, agent configuration, or tool server can execute with more authority than the change itself has been approved to receive.

If the answer is yes, the security boundary needs to be redesigned before further automation is added.

External References

Continue reading

Build Security Agents with Controlled Access to Scanning Tools

Control security agent tool access with registered assessment profiles, dispatch-time authorization, bounded workers, durable jobs, and safe reconciliation. Read the article

Leave a Comment