Archilo: helping architecture work become visible.

Explore the ecosystem →

Updates & announcements

Archilo: helping architecture work become visible.
Archilo: helping architecture work become visible.

A focused platform for architecture portfolios, research, talent and creative opportunity. Built for architects, students and studios.

Enally announcement
Enally: building useful things, together.

A founder-led ecosystem connecting products, services, knowledge, community and opportunities. One belief, expressed in different ways.

Enally announcement
Build with us: internships, contributors and partnerships.

Practical ways for young builders, contributors and domain experts to learn through real products and useful responsibility.

Archilo growing steadily
Archilo growing steadily

Architecture portfolios and research pages now serve 5,000+ creative professionals.

Humble campus expansion
Humble campus expansion

Verified student communities now active across multiple campuses with 2K+ members.

Faaho partner beta live
Faaho partner beta live

Zero-brokerage living discovery is now available in partner beta. Technology by Enally.

Enally announcement
Enally Labs launched

Applied AI experiments, internal agents and prototype products now live under Labs.

Enally announcement
Services: SEO to AIO

Five-layer visibility services now available — SEO, AEO, GEO, SXO and AI Optimization.

Enally announcement
Build with us program

Internships, campus ambassadors and contributor roles open for builders who want real ownership.

Enally announcement
Company website rebuilt

Enally.in redesigned with improved performance, accessibility and dark theme support.

Security

Cursor Security Breach: How a Malicious Claude Code Extension Targeted Developers

Cursor confirmed a security breach involving malicious Claude Code extensions. Learn how the attack worked, what data was exposed, and how developers can protect their systems.

Cursor Security Breach: How a Malicious Claude Code Extension Targeted Developers
What you'll learn

Cursor confirmed a security breach involving malicious Claude Code extensions. Learn how the attack worked, what data was exposed, and how developers can protect their systems.

Jump to the guide

Cursor Security Breach: How Hackers Used a Malicious Claude Code Extension to Target Developers

AI coding assistants have become an integral part of modern software development. Developers now trust tools such as Cursor, Claude Code, GitHub Copilot and other AI-powered IDEs with access to their source code, terminals, project files and development environments.

But what happens when the tool you trust to write your code becomes the entry point for an attack?

On November 13, 2026, Cursor published a detailed investigation confirming a security breach that allowed attackers to access internal systems, retrieve historical AI coding-agent data and distribute malicious versions of Anthropic's Claude Code extension through Cursor's extension marketplace.

The incident was initially discovered on October 29, when security researchers identified modified versions of the Claude Code extension attempting to establish persistent SSH access to developers' machines.

What makes this incident particularly concerning is that the attackers did not need to compromise Anthropic's infrastructure or distribute an entirely new application. They exploited credentials and access within a trusted development ecosystem to distribute a modified version of software developers already recognised and trusted.

Let's break down what happened, how the attack worked, what information was exposed and, most importantly, what developers should do to protect themselves.

What Happened? Understanding the Cursor Security Breach

Cursor confirmed that attackers distributed malicious, unauthorised copies of Anthropic's Claude Code extension through its VS Code extension marketplace.

The affected extension was identified as:

  • Extension: Anthropic.claude-code

  • Malicious versions: 2.1.312 and 2.1.313

  • Distribution platform: Cursor VS Code Extension Marketplace

  • Exposure date: October 29, 2026

  • Exposure window: Approximately 2:27 AM to 1:35 PM Pacific Time

  • Potential recipients: Up to 5,000 users

These were not legitimate releases developed or published by Anthropic.

The malicious packages contained injected JavaScript code designed to collect system information, modify SSH configuration, install persistence mechanisms and attempt to establish a reverse SSH tunnel.

Cursor subsequently removed the packages, disabled its extension marketplace temporarily and began investigating the incident.

An important distinction: The figure of 5,000 represents the maximum number of users who potentially received the malicious packages. It does not mean 5,000 computers were confirmed infected.

Sources: Cursor's official security notice | BleepingComputer's report

How Did the Attack Happen? The Complete Attack Chain

The most interesting part of this incident is not just the malicious extension itself. It is how the attackers gained enough access to distribute it.

According to Cursor's November 13 investigation, the attack originated through an exposed access key associated with Fireworks AI, a third-party AI infrastructure provider.

Here is how the attack unfolded.

1. The Initial Entry Point: An Exposed Fireworks AI Credential

Cursor used Fireworks AI for certain AI model training and inference workloads.

To facilitate this integration, Cursor had issued an access key to Fireworks AI.

According to Cursor, this key was exposed by Fireworks. Attackers obtained it and used it to access a read-only storage bucket that Cursor shared with the provider.

The bucket contained historical coding-agent traces, primarily from 2025.

These traces came from sessions that were not protected by Privacy Mode and were permitted to be used for model training.

The problem was that some of these historical traces contained credentials that had not been properly redacted.

This created an opportunity for attackers to move beyond the original third-party access point.

2. Historical AI Conversations Became a Credential Exposure Risk

The exposed traces contained more than ordinary conversation history.

A small number included unredacted credentials that could be used to access additional systems.

Using these credentials, attackers reached selected SaaS tools used internally by Cursor.

Cursor disclosed that the accessed information included:

  • Archived, non-production source-code repositories.

  • Limited customer support information and email conversations.

  • Product usage metrics and customer contact information.

  • Summaries of certain coding-agent conversations.

  • Credentials that customers had previously shared with Cursor's support team.

Cursor reported that fewer than 0.05% of users had coding-agent traces exposed, while fewer than 0.01% of customers had API credentials exposed.

This illustrates a serious security problem: information shared with AI systems can become part of a larger attack surface when it is stored, processed or transferred across third-party infrastructure.

A credential appearing in an old conversation can remain valuable long after the original development session has ended.

3. Attackers Obtained Access to Cursor's Extension Distribution Infrastructure

The attackers used credentials obtained during the wider compromise to access additional internal systems.

Eventually, they obtained a credential that allowed them to place malicious packages directly into the cache used to serve Cursor's VS Code extension marketplace.

On October 29, they used this access to distribute modified copies of the Claude Code extension.

This is particularly important because the attack did not require developers to download an unfamiliar executable from an unknown website.

The malicious software was distributed through a development environment that users already trusted.

4. Malicious Extensions Were Distributed to Developers

The two affected versions were:

  • 2.1.312

  • 2.1.313

The packages looked like the Claude Code extension but contained additional malicious JavaScript.

The injected code executed when the extension loaded.

Its purpose was to collect system information and attempt to establish persistent remote access through SSH.

Cursor removed the packages after approximately 11 hours of availability.


What Did the Malicious Claude Code Extension Actually Do?

To understand the severity of this incident, we need to look at the technical behaviour of the malicious code.

Microsoft Security Research independently analysed the malicious extension and published a detailed technical investigation on October 30.

The injected JavaScript attempted several operations.

1. System Reconnaissance

The extension collected information about the developer's machine, including:

  • Hostname and username.

  • Operating system and architecture.

  • Home directory location.

  • Current working directories.

  • Git email configuration.

  • Public IP address.

  • Names of selected environment variables.

Microsoft's analysis found that the malware searched for environment-variable names containing terms such as:

KEY, TOKEN, SECRET, PASS, AWS and GCP.

An important technical distinction: Microsoft reported that the injected code transmitted matching environment-variable names, not their values. This does not establish that the malware directly exfiltrated every API key or secret stored in those variables.

However, once an attacker establishes remote access, additional information may become accessible depending on the permissions and configuration of the compromised machine.

2. Installing an Attacker-Controlled SSH Key

One of the most concerning operations involved modifying the machine's SSH configuration.

SSH, or Secure Shell, is a protocol commonly used by developers to access remote servers securely.

It also supports public-key authentication.

The malicious extension attempted to append an attacker-controlled public key to the user's authorized_keys file.

This file determines which public keys are permitted to authenticate to an SSH account.

The injected key used the comment:

svc-telemetry

By adding its own public key, the attacker attempted to create another authentication path into the developer's machine.

This is particularly dangerous because the key could remain in the configuration even after the original extension was uninstalled.

3. Establishing a Reverse SSH Tunnel

The next step involved attempting to establish a reverse SSH tunnel.

Normally, a developer initiates an SSH connection to access a remote machine.

A reverse SSH tunnel works differently: the local machine initiates an outbound SSH connection to a remote server, allowing traffic to be forwarded back towards the local machine.

The malicious code attempted to establish this connection to attacker-controlled infrastructure.

It also attempted to configure retry mechanisms that would reconnect approximately every 60 seconds.

This approach is useful to attackers because outbound connections are often permitted by network firewalls that restrict unsolicited inbound connections.

4. Creating Persistence Mechanisms

Removing an extension does not necessarily remove everything it has already executed.

The malicious code attempted to create additional files and startup mechanisms outside the extension's installation directory.

Microsoft identified different mechanisms for different operating systems:

Operating system Persistence mechanism
Windows Scheduled task and Startup-folder script
macOS LaunchAgent
Linux User crontab @reboot entry

Some of the associated filenames included:

  • ~/.config/.smt

  • ~/.config/.smtk

  • com.apple.sysmond.plist

  • sysmon.cmd

  • smt.cmd

These mechanisms were intended to restart the SSH tunnelling process when the user logged in or the system restarted.

The names were deliberately similar to legitimate system-monitoring components.

Why this matters: An extension can be removed while separately installed scripts, SSH keys and startup entries remain on the system.

Sources: Microsoft Security Research | Cursor's technical security notice

Was the SSH Backdoor Actually Successful?

There is an important distinction between what the malware attempted and what it successfully achieved.

Cursor reported that the malicious code contained errors that prevented SSH access from being established on most ordinary Windows and macOS systems.

Enabling the local SSH service generally required administrator privileges, which the extension did not normally possess.

However, the malicious code could still:

  • Append the attacker's SSH public key.

  • Create persistence files.

  • Attempt to configure scheduled tasks or startup mechanisms.

  • Collect and transmit system information.

Microsoft's investigation also identified Linux-specific persistence behaviour, including an attempted user-crontab entry.

Therefore, it would be inaccurate to conclude that the attack was harmless simply because the reverse SSH connection failed on many machines.

The presence of persistence mechanisms and the collection of system information are security incidents in their own right.

A failed remote-access attempt does not automatically mean that a machine is clean.

Was Anthropic Compromised?

No evidence indicates that Anthropic's infrastructure was compromised in this incident.

This distinction is important because the malicious extension used Anthropic's name and the Claude Code identity.

Microsoft confirmed that:

  • The malicious packages were not distributed through Microsoft's official VS Code Marketplace.

  • The official npm package, @anthropic-ai/claude-code, was not affected.

  • Anthropic confirmed that its systems were not compromised.

  • The malicious packages were distributed through Cursor's marketplace infrastructure.

Anthropic representatives also clarified in the Hacker News discussion that the malicious copy was not developed or published by Anthropic.

The incident was therefore associated with the distribution infrastructure used by Cursor, not a compromise of the legitimate Claude Code release.

Sources: Microsoft Security Research | Hacker News discussion

What Information Was Exposed?

Cursor's November 13 investigation provides a clearer picture of the wider breach.

Information Reported impact
Historical coding-agent traces Fewer than 0.05% of users
API credentials Fewer than 0.01% of customers
Customer support conversations Limited data accessed
Business contact information Present in some archived repositories
Product usage information Selected metrics and contact details accessed
Customer credentials shared with support Some accessed

There are also important exclusions.

Cursor stated that the following were not affected:

  • Prompts and code belonging to users who had Privacy Mode enabled.

  • Active inference requests.

  • Customer code repositories.

  • Cursor's production infrastructure.

  • Official Cursor application releases and updates.

  • Release-signing keys.

  • Other extensions in its marketplace.

Cursor also stated that it had identified users whose historical coding-agent traces were exposed and notified them directly.

This means the breach should not be interpreted as every Cursor user having their source code or AI conversations stolen.

The impact was limited to specific datasets, systems and potentially affected users.

Source: Cursor's November 13 incident investigation

How to Check Whether Your Computer Is Affected

If you installed or updated Claude Code through Cursor's extension marketplace on October 29, 2026, during the exposure window, you should investigate your machine.

Simply uninstalling Claude Code is not sufficient.

Cursor has published official remediation scripts and detection instructions.

Windows: Check for the Malicious SSH Key

Open PowerShell and execute:

$files = "$HOME\.ssh\authorized_keys",
         "C:\ProgramData\ssh\administrators_authorized_keys" |
         Where-Object { Test-Path $_ }

if ($files -and (Select-String "svc-telemetry" $files)) {
    "WARNING: Potential malicious SSH key found"
} else {
    "No matching SSH key marker found"
}

If the output identifies svc-telemetry, treat the machine as potentially compromised.

A negative result is not a complete guarantee that your machine is clean.

macOS and Linux: Check SSH Configuration

Open your terminal and run:

grep -n "svc-telemetry" ~/.ssh/authorized_keys

If a matching entry appears, investigate it.

Microsoft's investigation also identified Linux-specific persistence mechanisms that are not covered by checking authorized_keys alone.

Check Additional Persistence Locations

Security researchers identified the following locations associated with the malicious extension:

Windows:

%USERPROFILE%\.config\smt.cmd
%USERPROFILE%\.config\smtk

%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\sysmon.cmd

macOS:

~/Library/LaunchAgents/com.apple.sysmond.plist
~/.config/.smt
~/.config/.smtk

Linux:

~/.config/.smt
~/.config/.smtk

Also inspect the user's crontab for an unexpected @reboot entry referencing .smt.

These are investigation indicators, not proof that every file with a similar name is malicious. Verify file contents, ownership, timestamps and configured actions before removing anything.

What If You Find Something Suspicious?

Follow this order:

  1. Isolate the affected machine from the network.

  2. Preserve relevant files, logs and evidence for investigation.

  3. Remove the malicious SSH key and confirmed persistence mechanisms using Cursor's official remediation instructions.

  4. Investigate running SSH tunnel processes and suspicious startup entries.

  5. Rotate API keys, database credentials, GitHub tokens, cloud credentials and other secrets accessible from the affected machine.

  6. Revoke active sessions and review authentication logs.

  7. Consider rebuilding the machine if its integrity cannot be established.

Perform credential rotation from a trusted, clean device rather than the potentially compromised machine.

Official remediation resources:

Cursor Security Notice and Remediation Scripts

Microsoft's Technical Investigation and Indicators of Compromise


What Has Cursor Done After the Breach?

Following its investigation, Cursor disclosed several remediation measures.

The company stated that it had:

  • Deactivated the exposed Fireworks access key.

  • Moved inference traffic away from Fireworks.

  • Revoked and rotated identified exposed credentials.

  • Rotated additional internal credentials as a precaution.

  • Rebuilt and validated its extension marketplace.

  • Expanded network access restrictions across service providers.

  • Introduced additional secret scanning across repositories and internal data sources.

  • Redeployed production infrastructure and services as a precaution.

  • Engaged external forensic experts.

  • Notified affected customers and administrators.

Cursor also stated that the last attacker activity it observed was on November 1 and that the activity was blocked.

As of its November 13 update, Cursor considered the incident contained.

This is an important distinction: containment means the company believes the identified attack activity has been stopped. It does not mean that previously installed malicious files have automatically disappeared from every potentially affected developer machine.

Source: Cursor's incident update

What the Developer Community Is Saying

The incident also generated significant discussion among developers on Hacker News and Reddit.

The original Hacker News discussion, titled Backdoor in Claude Code for VS Code extension on the Cursor Marketplace, attracted more than 1,000 points and hundreds of comments.

A major theme in the discussion was marketplace trust.

Developers questioned how an extension carrying Anthropic's name could be distributed through Cursor without being an authentic Anthropic release.

Anthropic representatives clarified that the malicious package was published through Cursor's marketplace infrastructure and was not an official Anthropic release.

Another important discussion involved extension signing and publisher verification.

Developers raised questions about whether extension packages should have stronger cryptographic provenance checks, so that an application can verify that the package it installs is genuinely the package published by its claimed developer.

The Reddit discussion in r/cursor also highlighted concerns about Cursor's marketplace proxy, extension updates and the difficulty of understanding which distribution channel was actually affected.

These conversations point towards a broader lesson: developers do not just trust the software they install. They trust the entire chain responsible for publishing, verifying, distributing and updating it.

Community discussions are useful for understanding developer concerns, but technical conclusions should be based on Cursor's disclosures and independent security research rather than individual comments.

Community discussions:

7 Security Lessons Every Developer Should Take Away

This incident is a useful reminder that modern development security extends beyond application code.

Here are seven practical lessons worth applying to your own workflow.

1. Never Treat an Extension Marketplace as an Absolute Trust Boundary

A package appearing in a recognised marketplace does not automatically prove that it is safe.

Before installing an extension, verify:

  • The publisher's identity.

  • The official repository.

  • The extension's source and release history.

  • Whether the package is available through the publisher's official distribution channel.

  • Whether the package has unexpected permission or behaviour changes.

For sensitive development environments, consider restricting installations to approved publishers.

2. Use Extension Update Controls

Automatic updates are convenient, but they also create a potential attack window.

A malicious update can reach developers before anyone has time to investigate it.

Consider using an installation cooldown where supported, particularly for organisational development environments.

Cursor also documents extension installation cooldown controls in its security-hardening guidance.

Cursor Security Hardening Guidance

3. Never Store Production Secrets in AI Conversations

Developers frequently paste the following into AI coding assistants:

  • Database connection strings.

  • API keys.

  • AWS credentials.

  • JWT secrets.

  • Private SSH keys.

  • Payment gateway credentials.

  • Production environment variables.

This is an unnecessary risk.

Use environment variables, secret managers and properly scoped credentials instead.

If an AI assistant needs to understand your database configuration, provide a redacted example rather than a working production connection string.

For example:

DATABASE_URL=postgresql://USER:REDACTED@HOST:5432/DB
AWS_ACCESS_KEY_ID=REDACTED
STRIPE_SECRET_KEY=REDACTED
JWT_SECRET=REDACTED

Also remember that redacting secrets from the information you send does not replace reviewing how the AI service stores and processes your data.

4. Enable Privacy Mode, But Understand Its Limitations

Cursor explicitly stated that prompts and code belonging to users with Privacy Mode enabled were not exposed in the historical coding-agent trace dataset involved in this incident.

That is important.

However, Privacy Mode should not be treated as a universal security control.

It does not automatically protect your local computer from a malicious extension, a compromised dependency or malware already executing with your permissions.

Privacy controls and endpoint security solve different problems.

5. Use Least Privilege

Your development environment should not have unrestricted access to everything.

Avoid running your IDE or coding agents as administrator or root unless absolutely necessary.

Use separate credentials for development, staging and production.

Keep SSH access restricted and avoid sharing long-lived credentials between unrelated services.

The objective is simple: if one development tool gets compromised, the attacker should not automatically inherit access to your entire infrastructure.

6. Monitor Your Credentials and Infrastructure

Credential rotation should not be an occasional maintenance activity.

For important development environments:

  • Monitor GitHub authentication activity.

  • Review AWS CloudTrail events.

  • Monitor unusual database connections.

  • Set spending alerts for AI API usage.

  • Review unexpected API requests.

  • Revoke unused tokens.

  • Use short-lived credentials where possible.

A compromised API key can be used for more than accessing source code. Depending on its permissions, it can expose infrastructure, customer data or create substantial unexpected costs.

7. Treat AI Coding Agents as Privileged Software

AI coding agents can interact with terminals, modify files, execute commands and access project resources.

That makes them powerful development tools, but also potentially high-impact attack surfaces.

Do not assume an AI agent is safe simply because it comes from a familiar brand.

Review extension updates, control filesystem access, restrict terminal permissions and isolate sensitive workloads.


The Bigger Picture: AI Development Is Becoming a Supply-Chain Security Problem

The Cursor incident is not happening in isolation.

BleepingComputer's investigation also connects this event to a broader wave of attacks targeting AI infrastructure and developer platforms during October 2026, described by cybersecurity company Wiz as Black October.

Other platforms mentioned in the reporting include Railway, Northflank, Lightning AI, OpenCode and Warp.

A common theme across these incidents is the targeting of credentials, development infrastructure and access to AI services.

As AI adoption grows, developers are increasingly connecting multiple services:

  • AI model providers.

  • Coding agents.

  • IDE extensions.

  • MCP servers.

  • CI/CD pipelines.

  • Cloud infrastructure.

  • Source-code repositories.

  • Deployment platforms.

Each integration creates another potential trust relationship.

A single compromised credential or publishing mechanism can sometimes provide access to systems far beyond the original application.

This is why supply-chain security is becoming increasingly important in AI-assisted software development.

The security of an application depends not only on the code developers write, but also on the tools, dependencies, credentials and infrastructure involved in producing that code.

Final Thoughts

The Cursor incident demonstrates an uncomfortable reality about modern software development: a trusted development tool can become a security liability when the infrastructure behind its distribution is compromised.

The attackers did not need to convince thousands of developers to download an unknown application. They exploited an existing trust relationship and used it to distribute modified software through a familiar development workflow.

For developers, the lesson is not to abandon AI coding assistants.

It is to stop treating them as harmless productivity utilities.

Extensions need verification. Credentials need protection. AI conversations need sensible data boundaries. Development environments need isolation and monitoring.

Most importantly, installing a package from a familiar marketplace should never replace security verification.

Your development environment is part of your production security perimeter. Treat it accordingly.


Frequently Asked Questions

1. Was Cursor actually hacked?

Yes. Cursor confirmed a security incident in which attackers used an exposed access key associated with Fireworks AI to access historical coding-agent traces, obtain additional credentials and access selected internal systems. Those credentials were subsequently used to distribute malicious Claude Code extensions through Cursor's marketplace.

2. Which Claude Code versions were malicious?

The affected versions were 2.1.312 and 2.1.313 of Anthropic.claude-code, distributed through Cursor's VS Code extension marketplace on October 29, 2026.

3. Was Anthropic compromised?

No evidence indicates that Anthropic's systems were compromised. Microsoft confirmed that the malicious packages were not distributed through Microsoft's official VS Code Marketplace or Anthropic's official npm distribution.

4. Does uninstalling Claude Code remove the malware?

Not necessarily. The malicious extension attempted to create SSH keys, scripts and startup persistence mechanisms outside its installation directory. These require separate investigation and remediation.

5. Can the malicious extension steal API keys?

The extension collected system information and names of selected environment variables, not their values, according to Microsoft's analysis. However, successful remote access could potentially expose additional credentials depending on the machine's configuration and permissions.

6. Were all 5,000 users infected?

No. Up to 5,000 users potentially received the malicious package. This is an exposure estimate, not a confirmed infection count.

7. Is Claude Code installed through npm affected?

No. Microsoft's investigation confirmed that Anthropic's official npm package, @anthropic-ai/claude-code, was not affected by this incident.

8. Is VS Code affected?

The malicious packages were not distributed through Microsoft's official VS Code Marketplace. The incident involved Cursor's extension distribution infrastructure.

9. Does Cursor Privacy Mode protect developers?

Cursor stated that prompts and code belonging to users with Privacy Mode enabled were not exposed in the historical coding-agent traces involved in this breach. However, Privacy Mode does not protect a local machine from malicious extensions.

10. What should developers do now?

Check whether they installed or updated to either affected extension version during the exposure window. Follow Cursor's official remediation guidance, inspect SSH configuration and persistence mechanisms, and rotate potentially exposed credentials from a trusted device.


Sources and Further Reading

The following primary sources and independent investigations were used to prepare this article.

Official security disclosures

  1. Cursor — An Update on Our Recent Security Incident (November 13, 2026)

  2. Cursor — Security Notice: Malicious Claude Code Extension (October 29, 2026)

  3. Microsoft Security Research — Inside a Malicious Claude Code-Branded Extension and Its Persistent SSH Backdoor

Independent cybersecurity reporting

  1. BleepingComputer — Cursor Confirms Security Breach Led to Malicious Claude Code Extension

  2. StepSecurity — Trojanized Claude Code Extension Delivered Persistent SSH Backdoor

  3. SecurityWeek — Malicious Claude Code Extension Served in Cursor Supply Chain Attack

Developer community discussions

  1. Hacker News — Backdoor in Claude Code for VS Code Extension on the Cursor Marketplace

  2. Reddit — Cursor Team, Please Explain What Just Happened

Research and factual status: November 16, 2026. Technical claims about the attack are based primarily on Cursor's official incident disclosures and Microsoft's independent technical analysis. Community discussions are included as commentary, not as proof of compromise.

Written by Prashant Kumar
Prashant Kumar Founder & Product Engineer

Founder of Enally. Product engineer building focused platforms for communities, architecture and campus life. Full-stack developer working across strategy, desi

Frequently asked questions

On November 13 2026 Cursor confirmed a breach where attackers accessed internal systems, extracted historical AI‑coding‑agent data, and pushed malicious versions of Anthropic’s Claude Code extension to the Cursor extension marketplace. The attackers exploited credentials within the trusted development ecosystem, not Anthropic’s infrastructure, to distribute a modified extension that established persistent SSH access to developers’ machines. (Cursor, 2026)

The compromised extension contained hidden code that, once installed, silently opened outbound connections to a command‑and‑control server and opened a reverse SSH tunnel. This allowed attackers to gain root‑level access to the developer’s workstation, enabling file exfiltration, remote code execution, and persistence. (Cursor, 2026)

Attackers retrieved internal system logs, historical AI‑coding‑agent interactions, and potentially source‑code snippets from developers’ projects. They also captured credentials stored in the Cursor environment and any files accessed through the malicious extension. (Cursor, 2026)

1. Verify the authenticity of extensions by checking the publisher’s signature and reviewing the extension’s source code on the official repository. 2. Keep Cursor and all extensions up‑to‑date and remove any unused or untrusted plugins. 3. Use a dedicated development VM or container with a firewall and restrict outbound traffic. 4. Monitor for unusual outbound SSH connections and regularly audit SSH keys and access logs. 5. Enable two‑factor authentication for your Cursor account and any related services. (Cursor, 2026)

Run a full antivirus/malware scan, inspect running processes for unknown SSH or network connections, review system logs for unauthorized reverse‑SSH tunnels, and check the list of installed extensions for any unfamiliar or unsigned entries. If suspicious activity is found, immediately uninstall the extension, rotate any compromised SSH keys, and consider wiping the machine and restoring from a clean backup. (Cursor, 2026)

Keep learning

Related articles

Summarize with ChatGPT Claude Gemini Perplexity Grok