Mildly Infuriating @lemmy.world Admiral Patrick @dubvee.org 2w ago

When software devs expect you to pipe a script straight from the internet into Bash...

Developers: I will never ever do that, no one should ever do that, and you should be ashamed for guiding people to. I get that you want to make things easy for end users, but at least exercise some bare minimum common sense.

The worst part is that bun is just a single binary, so the install script is bloody pointless.

Bonus mildly infuriating is the mere existence of the .sh TLD.

Edit b/c I'm not going to answer the same goddamned questions 100 times from people who blindly copy/paste the question from StackOverflow into their code/terminal:

WhY iS ThaT woRSe thAn jUst DoWnlOADing a BinAary???

Downloading the compiled binary from the release page (if you don't want to build yourself) has been a way to acquire software since shortly after the dawn of time. You already know what you're getting yourself into
There are SHA256 checksums of each binary file available in each release on Github. You can confirm the binary was not tampered with by comparing a locally computed checksum to the value in the release's checksums file.
Binaries can also be signed (not that signing keys have never leaked, but it's still one step in the chain of trust)
The install script they're telling you to pipe is not hosted on Github. A misconfigured / compromised server can allow a bad actor to tamper with the install script that gets piped directly into your shell. The domain could also lapse and be re-registered by a bad actor to point to a malicious script. Really, there's lots of things that can go wrong with that.

The point is that it is bad practice to just pipe a script to be directly executed in your shell. Developers should not normalize that bad practice.

80 comments

It's bad practice to do it, but it makes it especially easy for end users who already trust both the source and the script.

On the flip side, you can also just download the script from the site without piping it directly to bash if you want to review what it's going to do before you run it.
- It's bad practice to do it, but it makes it especially easy for end users who already trust both the source and the script.
  
  You're not wrong but this is what lead to the xz "hack" not to long ago. When it comes to data, trust is a fickle mistress.
- Would have been much better if they just pasted the (probably quite short) script into the readme so that I can just paste it into my terminal. I have no issue running commands I can have a quick look at.
  
  I would never blindly pipe a script to be executed on my machine though. That's just next level "asking to get pwned".
  
  These scripts are usually longer than that and do some checking of which distro you are running before doing something distro-specific.
Installing Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs/ | sh (source)
Installing Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" (source)

I understand that you find it infuriating, but it's not something completely uncommon, even in high end projects :/
- Common or not, it's still fucking awful and the people who promote this nonsense should be ashamed of themselves.
- Don't forget Pi-hole! It's been the default install method since basically the beginning.
  
  Thankfully, I'm using the docker version, which everyone should use.
  
  Yah, when I read this, I was like, pretty sure pi-hole started this as a popular option. I dig it though, so I guess OP and I are not on the same page. (I do usually look over the bash scripts before running them piped to bash, though.
- It should be uncommon
- --proto ‘=https’ --tlsv1.2
  
  That's how you know they care, no MIMing that stuff without hijacking the CA at which point you have a whole another set of problems, and if you trust rustc to not delete your sources when they fail a typecheck, then you can trust their installer. -f is important to not execute half-downloaded scripts on failure, -s and -S are verbosity options, -L follow redirects.
  
  So I was wondering what the flags do too, to check if this is any safer. My curl manual does not say that -f will not output half downloaded files, only that it will fail on HTTP response codes of 400 it greater... Did you test that it does not emit the part that it got on network error? At least with the $() that timing attack won't work, because you only start executing when curl completes...
- There is even a Windows (Powershell) example for Winutil:
  
  Stable Branch (Recommended)
  
  irm "https://christitus.com/win" | iex
  
  Better than explaining how to make a .ps file trusted for execution (thankfully, one of the few executable file extensions that Windows doesn't trust by default) but why not just use some basic .exe builder at this point?
  
  Obligatory "they better make it a script that automatically creates a medium for silent Linux Mint installation, modifies the relevant BIOS settings and restarts" to prevent obvious snarky replies
  
  Using a url that's just some dude's name makes this so much worse.
- For rust at least, those are packaged in Debian and other distros too. I think rustup is in Debian Trixie too.
- Don't forget everyone's favorite massgravel script
Would you prefere

$ curl xyz $ chmod +x xyz $ ./xyz

?
- You can detect server-side whether curl is piping the script to Bash and running it vs just downloading it, and inject malicious code only in the case no one is viewing it
  
  https://github.com/Stijn-K/curlbash_detect
  
  So that would at least be a minor improvement
  
  In most cases the script already installs a pre-compiled binary that can be anything, they wouldn't need to make the script itself malicious if they were bad actors.
- I mean, how about:
  
  Download the release for your arch from the releases page.
  
  Extract to ~/.local/bin
  
  Run
  
  I think you missed the point.
  
  Why is that safer/better? That binary can do anything a shell script can, and it’s a lot harder to inspect.
I've seen a lot of projects doing this lately. Just run this script, I made it so easy!

Please, devs, stop this. There are defined ways to distribute your apps. If it's local provide a binary, or a flatpak or exe. For docker, provide a docker image with well documented environments, ports, and volumes. I do not want arbitrary scripts that set all this up for me, I want the defined ways to do this.
I agree but hey at least you can inspect the script before running it, in contrast to every binary installer you're called to download.
I'm gonna go out on a limb and say you find this more than mildly infuriating.
- I think you and a lot of others are late to the idea that mildly is kinda like a joke. Many things are majorly infuriating. On the reddit, many of their top posts aren't even major. They're catastrophic, just absurd. I've yet to find anything mild
You really should use some sort of package manager that has resistance against supply chain attacks. (Think Linux distros)

You probably aren't going to get yourself in trouble by downloading some binary from Github but keep in mind Github has been used for Malware in the past.
What's that? A connection problem? Ah, it's already running the part that it did get... Oops right on the boundary of rm -rf /thing/that/got/cut/off. I'm angry now. I expected the script maintainer to keep in mind that their script could be cut off at litterally any point... (Now what is that set -e the maintainer keeps yapping about?)

Can you really expect maintainers to keep network error in mind when writing a Bash script?? I'll just download your script first like I would your binary. Opening yourself up to more issues like this is just plain dumb.
- Doesn't it download the entire script before piping it?
  
  It runs the curl command which tries to fetch the entire script. Then no matter what it got (the intended script, half the script, something else because somebody tampered with it) it just runs it without any extra checks.
I'm with you, OP. I'll never blindly do that.

Also, to add to the reasons that's bad:

you can put restrictions on a single executable. setuid, SELinux, apparmor, etc.

a simple compromise of a Web app altering a hosted text file can fuck you

it sets the tone for users making them think executing arbitrary shell commands is safe

I recoil every time I see this. Most of the time I'll inspect the shell script but often if they're doing this, the scripts are convoluted as fuck to support a ton of different *nix systems. So it ends up burning a ton of time when I could've just downloaded and verified the executable and have been done with it already.
That's becoming alarmingly common, and I'd like to see it go away entirely.

Random question: do you happen to be downloading all of your Kindle books? 😜
I'll do it if it's hosted on Github and I can look at the code first but if it's proprietary? Heck no
tbf, every time you're installing basically anything at all, you basically trust whoever hosts the stuff that they don't temper with it. you're already putting a lot of faith out there, and i'm sure a lot of the software actually contains crypto-mineware or something else.
You are being irrational about this.

You're absolutely correct that it is bad practice, however, 98% of people already follow bad practice out of convenience. All the points you mentioned against "DoWnlOADing a BinAary" are true, but it's simply what people do and already don't care about.

You can offer only your way of installing and people will complain about the inconvenience of it. Especially if there's another similar project that does offer the more convenient way.

The only thing you can rationally recommend is to not make the install script the "recommended" way, and recommend they download the binaries from the source code page and verify checksums. But most people won't care and use the install script anyway.

If the install script were "bloody pointless", it would not exist. Most people don't know their architecture, the script selects it for them. Most people don't know what "adding to path" means, this script does it for them. Most people don't know how to install shell completions, this script does it for them.

You massively overestimate the average competence of software developers and how much they care. Now, a project can try to educate them and lose potential users, or a project can follow user behavior. It's not entirely wrong to follow user behavior and offer the better alternatives to competent people, which this project does. It explains that it's possible and how to download the release from the Github page.
I assume your concern is with security, so then whats the difference between running the install script from the internet and downloading a binary from the internet and running it?
- To add to OP's concerns, the server can detect if you run curl <URL> | sh rather than just downloading the file, and deliver a malicious payload only in the piped to sh case where no one is viewing it
  
  https://github.com/Stijn-K/curlbash_detect
  
  You're already installing a binary from them, the trust on both the authors and the delivery method is already there.
  
  If you don't trust, then don't install their binaries.
- See post edit. I've already answered that twice.
I saw many cases of this with windows PowerShell and those Window debloating scripts
- PowerShell has a system to sign scripts, and with its default configuration, will refuse to execute scripts, and with the more sensible configuration you should switch to if you actually use PowerShell, refuses to execute unsigned scripts from the Internet.
  
  I suspect that most of the scripts you're referring to just set -ExecutionPolicy Bypass to disable signature checking and run any script, though.
  
  Invoke-WebRequest | Invoke-Expression
  
  bypasses signature checking because there is no file to be signed
  
  You are correct
Can you actually explain what concerns you have, that wouldnt be any more of a concern if you downloaded and installed a binary directly?

At least a shell script you can read in plaintext, a binary can just do who the fuck knows what.
- If they expected you to read the install script, they'd tell you to download and run it. It's presented here for lazy people in a "trust me, bro, nothing could ever go wrong" form.
  
  There are SHA256 checksums of each binary file available in each release on Github. You can confirm the binary was not tampered with by comparing a locally computed checksum to the value in the release's checksums file.
  
  Binaries can also be signed (not that signing keys have never leaked, but it's still one step in the chain of trust)
  
  The install script is not hosted on Github. A misconfigured / compromised server can allow a bad actor to tamper with the install script that gets piped directly into your shell. The domain could also lapse and be re-registered by a bad actor to point to a malicious script. Really, there's lots of things that can go wrong with that.
  
  I've gone through and responded to the other top level comments as well, but another massive issue you could add to your edit is that servers can detect curl <URL> | sh rather than just curl <URL> and deliver a malicious payload only if it's being piped directly to a shell.
  
  There's a proof-of-concept attack showing its efficacy here: https://github.com/Stijn-K/curlbash_detect
  
  On Github you can look at the CLI to see if the build process looks reasonable.
  
  I would still get packages from a distro though
They should really put the npm installation first
I'll die on the hill that curl | bash is fine if you're installing software that self updates - very common for package managers like other comments already illustrated.

If you don't trust the authors, don't install it (duh).
- There was a malicious website on Google pretending to be the brew package manager. It didn't leave any trace but when you ran the command it ran a info stealer and then installed brew.
  
  If this was rare I could understand but it is fairly common.
- If you don’t trust the authors, don’t install it (duh).
  
  Just because I trust the authors to write good rust/javascript/etc code, doesn't mean I trust them to write good bash, especially given how many footguns bash has.
  
  Steam once deleted a users home directory.
  
  But: I do agree with you. I think curl | bash is reasonable for package managers like nix or brew. And then once those are installed, it's better to get software like the Bun OP mentions from them, rather than from curl | bash.
What's a good package manager right now for stuff like this if i don't want to use the distro package manager though? I want up to date versions of these tools, ideally shipped by the devs themselves, with easy removal and updates. Is there any right now? I think Homebrew is like that? But I wish it didn't need creating an entire new user and worked on a user account basis.

In an ideal world, i would want to use these tools in such a way that I can uninstall them, including any tool data (cache, config, etc), and update them in a reliable manner. Most of these tools are also hellbent on creating a new ".<tool-name>" folder or file in the home folder ignoring the XDG spec.
- It says in the comment of the script:
  
  npm install
  
  npm is JS-specific
- Nix. I use it for everything, including all of my tools I use on my work MacBook.
  
  There are many ways to use nix for this stuff, but personally I use home-manager in a flake-based setup. Versions of tools are all pinned in a lockfile which is committed to source control, so it's easy to get my config and all my tools on a new machine without any breakage (it does require installing first, though).
  
  It's a great tool and has largely solved the pain of dealing with having to work on MacOS, for me.
  
  Nix is a great suggestion and I think i will be using it moving forward as well. Thanks. Ideally I want to use NixOS, do you know if secure boot is still a pain point with NixOS?
  
  Do you know of any Nix projects which are basically nix-but-as-if-was-brew?
  
  I get that this violates the Nix philosophy, but it’s hard convincing collabs to install a root package manager, which has install commands like:
  
  nix profile install nixpkgs/nixos-24.11#hello
  
  I get that it’s flexible, but I would like something more like:
  
  nix install hello
  
  I want three things:
  
  rootless
  
  can manage “casks”
  
  global cli with support for per-project flakes
  
  Do you know if this exists / is being developed?
4.Since MS bought github, github is no longer trustworthy. Databreaches etc have increased since MS owns github. Distribution of malware via github as well. What is the 4 point supposed to say?
I'm curious, op, do you think it's bad to install tools this way in an automated fashion, such as when developing a composed docker image?
- Very much yes
  
  You want to make your Dockerfile be as reproducible as possible. I would pull a specific commit from git and build from source. You can chain together containers in a single Dockerfile so that one container builds the software and the other deploys it.
  
  I mean, you're not op. But your method requires all updates to be manual, while some of us especially want updates to be as automated as possible.
- Protect from accidental data damage: for example the dev might have accidentally pushed an untested change where there's a space in the path
  
  rm -rf / ~/.thatappconfig/locatedinhome/nothin.config
  
  a single typo that will wipe the whole drive instead of just the app config (yes, it happened, I remember clearly more a decade ago there was a commit on GitHub with lots of snarky comments on a script with such a typo)
  
  Also: malicious developers that will befriend the honest dev in order to sneak an exploit.
  
  Those scripts need to be universal, so there are hundreds of lines checking the Linux distro and what tools are installed, and ask the user to install them with a package manager. They require hours and hours of testing with multiple distros and they aren't easy to understand too... isn't it better to use that time to simply write a clear documentation how to install it?
  
  Like: "this app requires to have x, y and z preinstalled. [Instructions to install said tools on various distros], then copy it in said subdirectory and create config in ~/.ofcourseinhome/"
  
  It's also easier for the user to uninstall it, as they can follow the steps in reverse
  
  Yes I understand all of that, but also in the context of my docker containers I wouldn't be losing any data that isn't reproducible