Because 99% of Node projects are web related, and if something's vulnerable on the web it won't take long to be abused
this post was submitted on 06 Aug 2023
145 points (97.4% liked)
Programming
17509 readers
8 users here now
Welcome to the main community in programming.dev! Feel free to post anything relating to programming here!
Cross posting is strongly encouraged in the instance. If you feel your post or another person's post makes sense in another community cross post into it.
Hope you enjoy the instance!
Rules
Rules
- Follow the programming.dev instance rules
- Keep content related to programming in some way
- If you're posting long videos try to add in some form of tldr for those who don't want to watch videos
Wormhole
Follow the wormhole through a path of communities [email protected]
founded 1 year ago
MODERATORS
Hey, a good answer! 🙌
Danke!
Prego!
Also a great disadvantage with JavaScript being the official scripting language of the web so it needs to work in every browser, but not every browser will implement it the same way. Syntax between the browser and servers also gets conflated.
I've done frontend development in Java and it sucks major ass. The "advantage" of using one language for the whole project really ended up as a net negative. For any server-side project I'm totally fine using Java because for all it's verbosity it's secure, performant, and examples from 10 years ago aren't useless.
Fron-end development with Java? You mean Java applets or something?
JSF for example. e.g. Primefaces https://www.primefaces.org/ I think there is something like Omnifaces too
Google Web Toolkit was a thing at some point in time. ;y current company still maintains some apps which are written in it.
Behold the horror of Vaadin: https://vaadin.com/docs/latest/guide/quick-start#add-code
load more comments
(1 replies)
JSP used to be the shit back in the day. Imagine server-side rendered html through Java. Nowadays it's properly regarded as shit, fortunately.
I tought JSP was just one templating solution like mustache, jinja2, Thymeleaf etc. But guess theres more to it.
So many reasons. JS has a small standard library, a history of competing standards for things like asynchrony and modules, there are tons of different implementations against tons of different specs, running in tons of different environments (whose constraints and opportunities are also changing all the time), it tends to be the first language to receive an SDK for many services, packages tend to be almost-excessively granular because optimizing for size can be so important on certain platforms (tree-shaking and minification works, but takes time), there are many add-on languages like JSX and TS, there are tons of bundlers and transpilers which each have their own quirks... and also due to its unique position as the lingua franca of client-side web, it tends to be the primary battleground for researchers, tech firms, VC, FOSS, malicious users, and everything else.
To stay alive in an ecosystem like that, any project must become a "ship of theseus" kind of deal.
You may be interested in yarn's "zero-installs" option: https://yarnpkg.com/features/zero-installs
If you set the versions of your dependencies in the package.json file, you’ll reinstall exactly the same ones.
You may get new vulnerability warnings popping up, but what is the issue here ? You’d rather not be aware that a vulnerability has been found since your last development ?
If you are not happy with others modules, dev your own and no one will let you know about security issues 😝
I'm struggling to understand how there can be so many security flaws, even in things that don't seem to matter for security. I think the bar for a security problem might be too low; a lot of these look like footguns that could give my package a security hole, rather than genuine security flaws in the packages they are reported on.
Here's a progress bar package with a "high" security vulnerability because it contains an internal utility that merges objects and doesn't stop you writing to the prototype. Did the progress bar package ever promise to provide an object merge function that was safe to use on untrusted user input?
Here's a notification UI element that bills using HTML in your notification messages as a feature. It has a "medium" level "XSS" security vulnerability where the message parameter is not sanitized to remove HTML. A CVE was issued for this.
Here's an arbitrary code execution vulnerability in sqlite3! High severity! The bug is that, if you tell sqlite3 to substitute an object into an SQL statement, it will run the ToString() method on the object. If an evil hacker has broken into your lead developer's house and written a malicious ToString() method into one of the classes of object you use as a database query parameter, then that code would run! The fix here was, instead of letting the normal Javascript stringification rules apply, to hardcode all objects to be inserted into the database as "[object Object]", because surely that is what the programmer meant to store.
You don't need to do anything when you get a security advisory if you're not impacted or the risk is acceptable. They're just there to advise you.
The problem is that when you are alerted for trivial/non-actionable stuff it contributes to “alert-fatigue” and you just start ignoring all of the alerts.
As far as I’m aware, there’s also no way to triage an alert from an install other than to upgrade the offending package, which means you can’t really discriminate on the basis of “acceptable risk”
You’d rather not be aware that a vulnerability has been found since your last development ?
I'd rather develop with dependencies that don't have so many vulnerabilities.
Yeah we all wanna do that, but nobody writes perfect code.
That's why people came up with defensive programming and functional correctness.
Just seems to be difficult for the webdev industry. Seems easier to push fixes from time to time.
Then you're in the wrong industry...
If you mean web development, you're right.
If you mean computer science, then I'd say that webdevs have little in common with the industry that came up with stuff like ADA or functional correctness.
If you set the versions of your dependencies in the package.json file
Or if you leave that alone, and update your package-lick.json so can install exact dependencies with npm ci
My take: It's because the "trust everything from everybody" model is fundamentally broken.
Note that trust is not only about avoiding malicious or vulnerable code, but also about dependability. Even if you ignore the "supply chain" security problems inherent in this model, it practically guarantees that the breakage you describe will happen eventually.
This is part of why I prefer languages with robust standard libraries, and why I am very picky about dependencies.
I personally don't trust NodeJS libraries that much - I always run projects inside Docker as a regular user with access to the working directory, just in case the supply chain is poisoned.
In the case of Python, particularly when I was testing out the LLaMA model, I just stood up a new VM for that. Back then safetensors wasn't a thing, and the model tensor file format (python pickle-based) could potentially store arbitary code.
Robust standard libraries are amazing to have.
Thank god for proxy registries. I love Node, but it's like using a house of cards as the foundation of a skyscraper.
The fact that NPM can't use multiple registries (yes, I know about scoped registries) is astounding. For every other language my org will separate artifacts into half a dozen or so virtual repos. The artifact team is quite annoyed that Node/JavaScript has to all go into one uber-repo.
load more comments
(4 replies)
They’re all that way: it’s just that Node is automatic enough to notice more easily, plus had an insane number of small dependencies
We started doing vulnerability scans on every build, which sounds like a good idea. However, now I know: Java is exactly the same. We need to constantly update but all too often there is no update available yet
C# is also exactly the same, you just don’t get yelled at when things are out of date and you only see that if you go to manually install packages
In C# you can automatically generate (or manually write) binding redirects that let you say "anything using versions between x.y.0 and x.y.9 should use x.y.9", which helps a lot with transitive dependencies. However, doing this manually is hard, and you can't really rely on semver to be done "correctly." This leads to subtle bugs. Occasionally not so subtle, but hard to diagnose.
I think NPM has the same feature, it's called overrides https://docs.npmjs.com/cli/v9/configuring-npm/package-json?v=true#overrides
At least part of it is that JavaScript is not really a batteries included language like Python or Java to even PHP.
You can’t really do anything productive without relying on a third party library.
This is not universally true. You totally can, especially today.
Most of those are server-side languages and I'd disagree with the assessment. For web services Java needs some kind of server like Jetty, Undertow, or Tomcat. For testing you need JUnit or NGTest. And for common, everyday utilities you need something like Apache Commons or Guava. These things don't "ship" with Java (and there's actually a fair amount of runtimes now, it's not only Oracle).
The thing that seems to benefit Java over Node is major corporate support (Oracle, RedHat, IBM) so for better or worse you can usually rely on a handful of essential tools being updated regularly.
I wouldn't say you need no dependencies in a Java project, but by all means check the average number of dependencies you get with Java or Python and compare it to almost any Node project.
You could probably sample projects on GitHub, look at the dependency graph, and compare.
load more comments
(2 replies)
For most projects or tools that I find on GitHub these days, I run them all in docker. Node, at least, is somewhat of a good guest. All it's crap lives in node_modules, and so when I'm done, rm the directory and it's all clean. Python seems to love leaving relics across my system
Welcome to my world. Not that I'm using node, but I'm using mediawiki. They manage to f-up something with about every update, and the documentation, if it exists at all, is often enough completely wrong or broken.
load more comments
(2 replies)
I wonder if it has something to do with the framework you pick. There are probably frameworks that aim to be as stable as possible but lack the cutting edge.
And these frameworks will fall out of fashion in three days.
It's a job machine. Maintenance is easier than improving code quality or adding features.
Something in the dependency tree will yell at you that it is deprecated or discontinued.
Only if you didn't pinned the dependencies you actually consume, and expect that all your dependencies magically comply with semver.
Blindly replacing dependency versions never worked, at least reliably. If you do not put in the work to ensure things work, more often than not you'll be surprised by them not working.
Then you'll end up with tons of vulnerabilities within days. That can't be the solution either.
Then you’ll end up with tons of vulnerabilities within days.
You only end up with vulnerabilities if you refuse to update your dependencies. Updating a dependency is something you need to do yourself, along with running build validation tests after a successful update. Just because npm can download newer packages that does not mean those packages are good.
...which is the opposite of the comment above.
So, you still have to go through all the dependencies, vulnerabilities and incompatibilities. Yes, you can now kind of control the timing, but it's still unacceptable in my opinion, that you have to spend so much time just to not be an active danger to everyone.
NPM is completely alone in that regard. Maven, Pypi, etc. don't have these problems.
So, you still have to go through all the dependencies, vulnerabilities and incompatibilities.
That's the point. There is no free lunch. Yet, you can live with stable, pinned versions and only upgrade the ones you really need to, and that means exercise your personal criteria instead of mindlessly upgrade everything just because there was a bump in a version number somewhere in an upstream dependency.
Yes, you can now kind of control the timing,
Timing, extent, scope, and impact. That's the point.
but it’s still unacceptable in my opinion, that you have to spend so much time just to not be an active danger to everyone.
You only spend the time you decide to spend. There are already vulnerability scanners that pinpoint exactly which versions need to be updated, and do that automatically for you. Mindlessly opening the floodgate to each and every change is by definition idiocy and a liability.
Often it seems that people will make patch releases that add a "feature" of complaining at install time that that major release/minor release/entire package is bad now and should be replaced with something else. It still works, but it annoys everyone who transitively depends on it forevermore.
Deno solves this problem :)
view more: next ›