You too can run malware from NPM (I mean without consequences)

https://github.com/naugtur/running-qix-malware

by naugtur • 11 months ago

195 114 11 months ago

github.com

cluckindan7• 11 months ago

LavaMoat looks great on paper, but not supporting Webpack HMR is a dealbreaker.

naugtur20• 11 months ago

You're using HMR in your app's production bundle? How?

naugtur20• 11 months ago

If you mean during development - you can opt out of using lavamoat in development for your webpack bundle (I'm assuming you're not running your untested code on valuable data)

mohsen1• 11 months ago

npm should take responsibility and up their game here. It’s possible to analyze the code and mark it as suspicious and delay the publish for stuff like this. It should prevent publishing code like this even if I have a gun to my head

sesm• 11 months ago

I think malware check should be opt-in for package authors, but provide some kind of 'verified' badge to the package.

Edit: typo

naugtur20• 11 months ago

npm is on life support by msft. But there's socket.dev that can tell you if a package is malicious within hours of it being published.

Cthulhu_5• 11 months ago

I always thought this would be the ideal monetization path for NPM; enterprises pay them, NPM only supplies verified package releases, ideally delayed by hours/days after release so that anything that slips through the cracks has a chance to get caught.

yjftsjthsd-h• 11 months ago

but provide some kind of 'verified' badge to the package

I would worry that that results in a false sense of security. Even if the actual badge says "passes some heuristics that catch only the most obvious malicious code", many people will read "totally 100% safe, please use with reckless abandon".

madeofpalk2• 11 months ago

They already have this

https://docs.npmjs.com/trusted-publishers

https://docs.npmjs.com/generating-provenance-statements

untitaker_• 11 months ago

i can guarantee you npm will externalize the cost of false-positive malware scans to package authors.

nodesocket2• 11 months ago

Or at a minimum support yubikey for 2fa.

worthless-trash2• 11 months ago

Original author could be evil. 2fa does nothing.

mcintyre1994• 11 months ago

They do, I use a yubikey and it requires me to authenticate with it whenever I publish. They do support weaker 2fa methods as well, but you can choose.

azemetre• 11 months ago

Why would npm care? They're basically a monopoly in the JS world and under the stewardship of a company that doesn't even care when its host nation gets hacked when using their software due to their ineptitude.

clbrmbr4• 11 months ago

How much money have the attackers stolen so far? Has someone done an analysis of the blockchains for the destination addresses?

naugtur20• 11 months ago

click through to the article, it has a link to a view that lists the laughable profit

clbrmbr4• 11 months ago

Huh. I read TFA in detail (and shared with my team), but I didn’t see any analysis. (?)

nodesocket2• 11 months ago

I'm actually shocked they have not stolen more seeing the breach impact radius? Perhaps we can thank wallets and exchanges for blacklisting the addresses and showing huge warnings like the one shown in the article.

p2detar• 11 months ago

I’ve been out of the loop with npm for a while, but are there still no package namespaces?

uallo• 11 months ago

https://docs.npmjs.com/about-scopes

diggan• 11 months ago

Namespaces have existed since ~2016 at least in npm, but since it's not enforced and people want "nice looking" package names, the ecosystem still hasn't fully embraced it. It seems like more and more projects are using them (probably because all "good" names are already taken), but probably way less than half of all popular packages are scoped/namespaced.

keysdev• 11 months ago

Well there is jsr now....

stby• 11 months ago

I am also out of the loop here, how would namespaces have helped?

clbrmbr4• 11 months ago

Is it typical in the JS space to include dependencies without versioning?

Also, curious: does freezing a version really provide much protection? Shouldn’t a commit hash be used? (Attacker can change a tag.)

naugtur20• 11 months ago

packages published to npm are immutable. if you pin a version, you get the same exact version as long as MSFT servers are not compromised.

Installing from git is not recommended and has more issues than you might think https://dev.to/naugtur/a-phish-on-a-fork-no-chips-52cc

You are supposed to update packages, even if you use lockfiles (very common) or tools that pin your direct dependencies (renovate etc. not so common) And when you do update, will you read the package and all of its updated dependencies?

It's a hard problem with a bunch of tradeoffs.

Can be done, with enough attention and tools. Tools include LavaMoat :)

clbrmbr4• 11 months ago

Re: updates: I was just thinking of waiting a few weeks on the updates to allow compromised packages to be discovered.

whilenot-dev2• 11 months ago

packages published to npm are immutable.

Depends how you'd refer to them... tags ("@latest", "@next" etc.) are not immutable and it's best to rely on the checksums in the lock file.

vel0city• 11 months ago

The package-lock.json includes a hash of the package, not just a version number which should be immutable.

whilenot-dev2• 11 months ago

To add to this: the hash in the lock file is the checksum of the published tarball, not the commit hash.

herpdyderp• 11 months ago

I’m intrigued but is that compartmentalization not incredibly expensive?

naugtur20• 11 months ago

It's within the same process and realm (window) It has a cost, but it's nothing compared to putting every dependency of a large app in a separate iframe/process and figure out a way for them to communicate.

cluckindan7• 11 months ago

Have you tried to find ways to break it?

Plenty of objects in the browser API contain references to things that could be used to defeat the compartmentalization.

If one were to enumerate all properties on window and document, how many would be objects with a reference back to window, document or some API not on the allowed list?

CyberMacGyver• 11 months ago

Looks like OP is one of the contributors to LavaMoat

naugtur20• 11 months ago

Yes, I am. I came up with the first successful attempt at integrating the Principle of Least Authority software in LavaMoat with Webpack and wrote the LavaMoat Webpack Plugin.

Also, together with a bunch of great folks at TC39 we're trying to get enough building blocks for the same-realm isolation primitives into the language.

see hardenedjs.org too

I'm doing the rounds promoting the project today because at this point all we need to eliminate certain types of malware is get LavaMoat a lot more adoption in the ecosystem.

( and that'll give me bug reports and maybe even contributions? :) )

hn92726819• 11 months ago

I think most people are fine with promoting a cool project you work on, but it's best practice to disclose that in the article. Even something like "If your project was set up with LavaMoat (a project I've been working on), ..." would be enough.

I think that's why they made the comment.

btown• 11 months ago

I'm often curious about how effective runtime quasi-sandboxing is in practice (at least until support at the TC39 level lands).

My understanding is that if you can run with a CSP that prevents unsafe-eval, and you lock a utility package down to not be able to access the `window` object, you can prevent it from messing with, say, window.fetch.

But what about a package that does assume the existence of window or globalThis? Say, a great many packages bridging non-React components into the React ecosystem. Once a package needs even read-only access to `window`, how do you protect against supply-chain attacks on that package? Even if you read-only proxy that object, for instance, can you ensure that nothing in `window` itself holds a reference to the non-proxied `window`?

Don't get me wrong - this project is tremendously useful as defense-in-depth. But curious about how much of a barrier it creates in practice against a determined attacker.

jefozabuss• 11 months ago

Seems like people already forgot about Jia Tan.

By the way why doesn't npm have already a system in place to flag sketchy releases where most of the code looks normal and there is a newly added obfuscated code with hexadecimal variable names and array lookups for execution...

tom1337• 11 months ago

It would also be great if a release needs to be approved by the maintainer via a second factor or an E-Mail verification. Once a release has been published to npm, you have an hour to verify it by clicking a link in an email and then enter another 2FA (separate OTP than for login, Passkey, Yubikey whatever). That would also prevent publishing with lost access keys. If you do not verify the release within the first hour it gets deleted and never published.

naugtur20• 11 months ago

That's why we never went with using keys in CI for publishing. Local machine publishing requires a 2fa.

automated publishing should use something like Pagerduty to signal that a version is being published to a group of maintainers and it requires an approval to go through. And any one of them can veto within 5 minutes.

But we don't have that, so gotta be careful and prepare for the worst (use LavaMoat for that)

Cthulhu_5• 11 months ago

Not through e-mail links though, that's what caused this in the first place. E-mail notification, sure, but they should also do a phishing training mail - make it legit, but if people press the link they need to be told that NPM will never send them an email with a link.

dist-epoch• 11 months ago

flag sketchy releases

Because the malware writers will keep tweaking the code until it passes that check, just like virus writers submit their viruses to VirusTotal until they are undetected.

galaxy_gas• 11 months ago

its Typical that the Virus Writer will use their own service, there is criminal virustotal-clones that run many AV in VM and return the Results, because virustotal will share all binaries, anything upload in Virustotal will be detteceted shortly if it is not.

mystifyingpoi• 11 months ago

Detecting sketchy-looking hex codes should be pretty straightforward, but then I imagine there are ways to make sketchy code non-sketchy, which would be immediately used. I can imagine a big JS function, that pretends to do legit data manip, but in the process creates the payload.

nicce• 11 months ago

It is just about bringing the classic non-signature based antivirus software to the release cycle. Hard to say how useful it is, but usually it is endless cat-and-mouse play like with everything else.

hombre_fatal• 11 months ago

Yeah, It’s merely a fluke that the malware author used some crappy online obfuscator that created those hex code variables. It would have been less work and less suspicious if they just kept their original semantic variables like “originalFetch”.

Cthulhu_5• 11 months ago

It wouldn't be just one signal, but several - like a mere patch version that adds several kilobytes of code, long lines, etc. Or a release after a long silent period.

cluckindan7• 11 months ago

A complexity per line check would have flagged it.

Even a max line length check would have flagged it.

cchance• 11 months ago

Feels like a basic light weight 3b AI model could easily spot shit like this on commit

AtNightWeCode3• 11 months ago

The problem is that it is even possible to push builds from dev machines.

madeofpalk2• 11 months ago

With NPM now supporting OIDC, you can just turn this off now https://docs.npmjs.com/trusted-publishers

hulitu• 11 months ago

By the way why doesn't npm have already a system in place to flag sketchy releases

Because nobody gives a fsck. Normally, after npm was filled with malware, people would avoid it. But it seems that nobody (distro maintainers) cares. People get what they asked for (malware).

j45• 11 months ago

How does one avoid malware in npm specifically?

Makes me not want to use the ecosystem, which isn’t always possible.

beardyw• 11 months ago

Makes me not want to use the ecosystem

I came to that conclusion long ago.

pimterry• 11 months ago

This attack is pretty bad, but as shown by the tiny ROI for the attacker mentioned in this article (about $500 so far: https://intel.arkm.com/explorer/entity/61fbc095-f19b-479d-a0...) this really isn't quite as ecosystem-catastrophic as it sounds, for a few reasons:

* Major attacks on large packages like this are caught fairly quickly - a few hours in this case - making the vulnerable window _relatively_ small.

* NPM locks installed dependencies by default, against both the version & a hash of the content, so you'll only install the new malicious version if you happen to be adding or updating this dependency specifically within the window this version is still live. It's effectively sort-of TOFU. If even you ran `npm install` in a project already using this dependency in the specific window it was live, you will not normally install the malicious version.

* There's quite a few tools to help mitigate the risk here, like https://socket.dev and npq (https://github.com/lirantal/npq).

As one datapoint, look at the download stats for the affected Chalk package for example (https://www.npmjs.com/package/chalk?activeTab=versions) - the vast majority of installs were not installing the latest version anyway.

There are caveats to this: e.g. you can use npm without a lockfile, in which case a fresh local install can pull down unexpected versions, or you could be manually updating/adding a different package which happens to depend on an affected package (which might trigger a lockfile update, which might then fetch the latest version of the subdependency) during the vulnerable window, or of course it's totally possible you might install the package for the first time at the precisely wrong moment, etc etc.

This is definitely bad, and could have been extremely disastrous if it wasn't caught. But in practice, npm & the ecosystem have put in quite a few protections that do help to _mostly_ mitigate these kind of risks in typical use cases (but not completely, and there's definitely plenty more work to do!) and it's certainly not the case that millions of JS developers & projects were all catastrophically pwned today.

naugtur20• 11 months ago

Very good summary.

Most other ecosystems are as vulnerable if not more, they just lack the scale.

OP, The malware is coming to the ecosystem you prefer. Give it time.

mapmeld• 11 months ago

'npm install' and 'pip install' can both run scripts on your computer. Both ecosystems have this risk and loose monitoring, so there are days where packages are messed up. I don't think you can avoid malware by picking one over the other.

AtNightWeCode3• 11 months ago

I think JS should be all source and no packages at all.

phil294• 11 months ago

What about complex SPAs? Database drivers? Polyfills? TypeScript?

AtNightWeCode3• 11 months ago

Pulling the source and compiling the package instead of pulling the package. Not much difference. Maybe slower build times but more secure and better builds.

riazrizvi• 11 months ago

Glad to see this article raising awareness.

Without fairness in the marketplace, the talent loses the will to play and the economy will further deteriorate. We are all suffering from an international trust breakdown from Covid, and now also from AI spam. If we don’t turn this tide, jobs and business opportunities are going to keep shrinking.

erpderp2• 11 months ago

In the example snippets from OP, the code shown is in the browser. I'm failing to see how the interception, as described, couldn't be handled by a decent Content Security Policy - instead of requiring yet another npm package. Seems safer than installing another package to address risk from ... installing packages.

ghrl• 11 months ago

I suppose if you're using a bundler, you will ship JS bundles including the malicious packages from your own trusted domain. How could CSP prevent this or similar attacks?

erpderp2• 11 months ago

According to the OP, in this specific case, the malware was mostly just intercepting legitimate fetch(), etc calls. With CSP `connect-src`, I don't think that would be possible unless the new fetch targets are themselves on allow-listed domains (which is a totally separate issue).

For example, consider a CSP of: `Content-Security-Policy: connect-src 'self' https://api.example.com;`: This policy would allow fetch() requests only to the same origin ('self') and to https://api.example.com, blocking any attempts to connect to other domains (typically with a corresponding warning/error in the browser dev console).

That said, in fairness, CSP is of course only applicable to frontend code (not to backend JS, where anecdotally I've seen a lot more usage of `chalk` and some of the other pwned packags), but frontend code and the `window` object is what the OP used in their examples and seems like they're targeting w/ webpack, hence my mentioning CSP.

4ndrewl• 11 months ago

If you're not vendoring, there's an argument to say that some portion of your source code is fair game to anyone who has commit rights to a variety of repos.

withinrafael3• 11 months ago

In July, packages were loading malicious DLLs (on Windows targets) [1]. It doesn't appear Lavamoat would help in that scenario. Is that right? If so, how do you mitigate this? Run everything in a container?

[1] https://www.crowdstrike.com/en-us/blog/crowdstrike-falcon-pr...

mike-cardwell• 11 months ago

https://gitlab.com/grepular/safernode

withinrafael3• 10 months ago

Thanks will check it out!

naugtur20• 11 months ago

1. Control lifecycle scripts with @lavamoat/allow-scripts

2. Do local dev with https://github.com/lavamoat/kipuka installed (I'm working on it)

3. If you don't permit the APIs used for loading DLLs they won't load themselves, so runtime protections are valid too. But I recall the DLLs were loaded in lifecycle script.

withinrafael3• 10 months ago

Thanks will check both out!

You too can run malware from NPM (I mean without consequences)

Related Stories