# Running npm install (and other weird scripts) safely

## Situation¶

You do this:

$git clone https://some.site/git/some.repo.git$ cd some.repo
$npm install  Pretty common right? What can go wrong? What about this: curl -L https://our-new-thing.xyz/install | bash  This looks a little unsafe. Who would recommend it? Well it's still one of the ways to install pip in unfamiliar environments. Or Rust. Now installing from these places is safe: why? Because they're trusted. There's huge reputational defense going on. But the reality is that for a lot of tools - npm being a big offender, pip too - there's all sorts of ways that while sudo and user permissions will protect your system from going down, your data - $HOME and the like - basically all the important things on your system - are exposed.

This is key: you are always running as "superuser" of your data. In fact your entire operating environment - systemctl --user provides a very useful and complete way to schedule tasks and persistent daemons for your entire user session. There's a lot of power and persistence there.

## Problem¶

There's two competing demands here: it's pretty easy to build isolated environments when you feel like you're under attac, but it takes time - time you don't really want to commit to the problem. It's inconvenient - which is basically the currency we trade when it comes to security.

But the convenience<->security exchange rate is not fixed. It has a floor price, but if we can build more convenient tools, then we can protect ourselves against some threats for almost no cost.

## Goals¶

What we want to do is find a safe way to do something like npm install and not be damaged by anything which might get run by it. For our purposes, damage is data destruction or corruption beyond a sensible scope.

We also want this to light weight: this should be a momentary "that looks unsafe" sort of intervention, not "let me plan out by secure dev environment".

## Enter Bubblewrap¶

bubblewrap is intended to be an unprivileged containers sandboxing tool and has as its specific goal the elimination of container escape CVEs. It's also just available in the Ubuntu repositories which makes things a lot easier.

This is a fairly low level tool, so let's just cut to the wrapper script usage:

#!/bin/bash
# Wrap an executable in a container and limit writes to the current directory only.
# This system does not attempt to limit access to system files, but it does limit writes.

# See: https://stackoverflow.com/questions/59895/how-to-get-the-source-directory-of-a-bash-script-from-within-the-script-itself
# Note: you can't refactor this out: its at the top of every script so the scripts can find their includes.
SOURCE="${BASH_SOURCE[0]}" while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
SOURCE="$(readlink "$SOURCE")"
[[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if$SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
done
SCRIPT_DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )" function log() { echo "$*" 1>&2
}

function fatal() {
echo "$*" 1>&2 exit 1 } start_dir="$(pwd)"

bwrap="$(command -v bwrap)" if [ ! -x "$bwrap" ]; then
fatal "bubblewrap is not installed. Try running: apt install bubblewrap"
fi

export PS_TAG="$(tput setaf 14)[safe]$(tput sgr0) "

exec "$bwrap" \ --die-with-parent \ --tmpfs / \ --dev /dev \ --proc /proc \ --tmpfs /run \ --mqueue /dev/mqueue \ --dir /tmp \ --unshare-all \ --share-net \ --ro-bind /bin /bin \ --ro-bind /etc /etc \ --ro-bind /run/resolvconf/resolv.conf /run/resolvconf/resolv.conf \ --ro-bind /lib /lib \ --ro-bind /lib32 /lib32 \ --ro-bind /libx32 /libx32 \ --ro-bind /lib64 /lib64 \ --ro-bind /opt /opt \ --ro-bind /sbin /sbin \ --ro-bind /srv /srv \ --ro-bind /sys /sys \ --ro-bind /usr /usr \ --ro-bind /var /var \ --ro-bind /home /home \ --bind "${HOME}/.npm" "${HOME}/.npm" \ --bind "${HOME}/.cache" "${HOME}/.cache" \ --bind "${start_dir}" "${start_dir}" \ -- \ "$@"


In addition to this script, I also have this in my .bashrc file to get nice shell prompts if I spawn a shell with it:

if [ ! -z "$PS_TAG" ]; then export PS1="${PS_TAG}${PS1}" fi  The basic structure of this invocation is that the resultant container has networking, and my full operating environment in it...just not write access to any files beyond the current user directory. This is a handy safety feature for reasons beyond a malicious NPM package - I've known more then one colleague to wipe out their home directory writing make clean directives. ### Usage¶ Usage could not be simpler. With the script in my PATH under the name saferun, I can isolate any command or script I'm about to run to only be able to write to the current directory with: saferun ./some-shady-command I can also launch a protected session with saferun bash which gives me a prompt like: [safe]$

This is about as low overhead as I can imagine for providing basic filesystem protection.

## Conclusions¶

This is not bullet-proof armor. And it certainly won't keep nosy code from poking around the rest of the filesystem. Are you 100% confident you never saved an important password to some file? I'm not. But I do normally work with a lot auxillary commands and functions around my home directory, and I like them being mostly available when doing risky things. This strikes a good balance - at the very least it limits the damage scope of running some random script you downloaded from causing real nuisance.

I recommend checking out bubblewrap's full set of features to figure out what it can really do, but for something I knocked up by reading for a few hours this added a handy tool to my repository for me.