Known-bad
is blocked.
Brand-new
is held back.

SlowShield is a free, open-source proxy between your package managers and PyPI, npm, Go, Maven, crates.io, NuGet, Packagist and RubyGems, and between your container runtimes and Docker Hub, GHCR and Quay. It holds brand-new releases back for a few days, blocks known malware the moment it is reported and verifies every download. It is made for developers and small teams that want this protection without buying and running an artifact repository manager.

Try it now on your laptop

One container, plain HTTP on localhost, nothing kept after you stop it. The dashboard is at http://localhost:8080.

  1. 1 Start it

    docker run --rm -p 127.0.0.1:8080:8080 ghcr.io/squirro/slowshield:0.0.13
  2. 2 Install something through it

    python3 -m venv /tmp/slowshield-try
    /tmp/slowshield-try/bin/pip install --index-url http://localhost:8080/pypi/simple/ requests

    A throwaway virtualenv, because Homebrew and current Linux Pythons refuse pip installs outside one. Releases younger than a week are held back; known malware is refused with HTTP 451.

  3. 3 Use it for everything

    cat >> ~/.bashrc <<'EOF'
    export PIP_INDEX_URL=http://localhost:8080/pypi/simple/
    export UV_DEFAULT_INDEX=http://localhost:8080/pypi/simple/
    export npm_config_registry=http://localhost:8080/npm/
    export GOPROXY=http://localhost:8080/go
    export PIP_UPLOADED_PRIOR_TO=P3D
    export npm_config_min_release_age=3
    EOF
    source ~/.bashrc

    pip, uv, npm and go then use SlowShield in every new terminal. Remove the lines to switch it off.

Who it's for

Made for developers and small teams.

Large organisations put an artifact repository manager such as JFrog Artifactory or Sonatype Nexus between their builds and the internet, add a repository firewall to keep malware out, and pay people to run it. Most teams can't justify that. SlowShield covers the security part: one small container that starts in a minute and needs little maintenance.

  • Free and open source. No licence fees, and the source is open under the Apache-2.0 licence.
  • Nothing to administer. No database server, no repositories to configure, no admin team.
  • One policy for every tool. Per-tool settings such as npm's min-release-age help on one machine; SlowShield applies the same rules to every laptop, CI runner and package manager.

Safe by default

A seven-day delay, malware blocking and verification by default. A package whose versions are all too new still installs on PyPI and npm, and is recorded, so builds don't break. An urgent fix can be released early with one line of configuration.

Advisory streams built in

OSV / OpenSSF malicious-packages and the GitHub Advisory Database sync every hour. Feed health is monitored and alerted on. CVE-aware policies are next on the roadmap.

Tamper-proof

Registry digests plus trust-on-first-use fingerprints, a content-addressed cache that is only written after verification and re-checked on a schedule.

Know what you depend on

A fast dashboard: installs and trends, newly introduced dependencies, versions waiting in line, and a security timeline down to the machine that tried to install malware.

Kind to public registries

One verified download per artifact instead of one per laptop and per pipeline run, with HTTP/2, conditional requests and a shared cache. That takes load off the community-run registries.

Observable

OpenTelemetry metrics, logs and traces, with ready-made Grafana dashboards and alerts for blocked malware, tampering, stale feeds and errors.

Hardened images and builds

Distroless Amazon Linux 2023 images, non-root and read-only. TLS 1.3 with post-quantum key exchange and HTTP/3. Strict CSP. Pinned, audited CI. Every release load-tested against the last.

Deploys in minutes

Docker Compose, rootless Podman or a Helm chart. One small container plus Caddy for automatic TLS. No database server — SQLite is embedded.

Ecosystems & roadmap

Supported today: Python, JavaScript, Go, Java, Rust, C#, PHP, Ruby and container images.

Anything that pulls artifacts from the internet is a way in. SlowShield adds one ecosystem at a time, each with the same delay, malware blocking, checks and dashboard.

Available now

Python, JavaScript, Go, Java, Rust, C#, PHP & Ruby

Available now

Container images

  • Docker, Podman & Kubernetesimages from Docker Hub, GHCR, Quay, registry.k8s.io and more
  • Tags that lag behindFROM nginx:latest keeps working, about a week behind
Later

Beyond package managers

  • GitHub Actionsevery uses: step
  • Editor extensionsVS Code, Open VSX, JetBrains
  • Hugging Facemodels and datasets
  • Homebrew & GitHub Releasesand other direct downloads

A release carries the most risk in its first days.

Supply-chain attacks follow the same script: steal a maintainer's token, publish a poisoned release, collect secrets from everyone who installs it before anyone notices. Finding such a release takes hours or days, while a package manager installs it the moment it is published.

40min

that the backdoored LiteLLM releases were live on PyPI in March 2026 — long enough to land on thousands of machines.

7days

SlowShield's default delay, long enough for the registries and the advisory feeds to catch most malicious releases.

0changes

to your code, commands or lockfiles. Only the index URL changes.

How it works

Without SlowShield

  1. A maintainer publishes 2.4.0.

    A new release of a package you depend on goes up on the registry.

  2. Every machine installs it.

    Within minutes it is on every laptop, CI runner and build that installs or updates. That's how it should be: a real release from the real maintainer.

  3. Someone steals the maintainer's token.

    A phished password, a leaked CI secret or a malicious browser extension, and the attacker can publish as the maintainer.

  4. The attacker uploads 2.4.1.

    It looks like any other patch release. Inside is a payload that runs when it is installed.

  5. Every machine pulls it.

    It is the newest version, so the same machines install it just as fast as 2.4.0, and run it.

  6. Your secrets are sent to the attacker.

    The payload collects tokens, cloud keys and passwords from every machine and sends them to a server the attacker controls. Nobody on your side did anything wrong.

  7. The attack spreads to your users.

    With your publish tokens and keys, the attacker releases a poisoned version of your own package or app, as you, and your users install it. That is how the Shai-Hulud worm spread through hundreds of npm packages, in 2025 and again in 2026.

With SlowShield

  1. Every install goes through SlowShield.

    Point pip, uv, npm, pnpm, Yarn, Bun, go, Maven, Gradle, Cargo, dotnet, Composer, Bundler, gem, Docker, Podman and the rest at it. Same packages, same commands, same lockfiles.

  2. 2.4.1 is held back.

    A release younger than the delay (7 days by default) isn't offered yet. A lockfile pinned to it gets a clear answer: try again in 6 days.

  3. Installs get 2.4.0.

    Indexes show the newest release that is old enough, and latest moves back to it. Builds keep working.

  4. The malware is reported, and blocked for good.

    The advisory feeds (OSV and GitHub) usually flag an attack like this within days. From then on 2.4.1 is refused with HTTP 451, even after the delay.

  5. A swapped file is cut off.

    Say someone replaces the file behind 2.4.0. SlowShield checks every download against the registry's digest and the fingerprint it recorded the first time, cuts the transfer off and alerts your team.

  6. Each file is downloaded once.

    One SlowShield serves every laptop, runner and build. Each file comes from the registry once and from the cache after that, so installs are faster, keep working while a registry is down, and cause one download instead of hundreds.

Two layers

Turn on the package manager's own release-age setting as well.

Most package managers can now refuse brand-new releases on their own. Turn that on as well, a little shorter than SlowShield: 7 days in SlowShield, 3 in the package manager. On a normal day only SlowShield holds anything back. When something gets past it, the package manager still waits.

What happens with one layer and with two
SituationSlowShield only SlowShield and the package manager
A new release, on a normal day Held for 7 days Held for 7 days. The package manager never sees anything younger than 3 days, so it stays silent
A build that goes around SlowShield: a new CI runner, a laptop without the setup Installs the new release right away Waits 3 days, if the setting lives in the project (.npmrc, pyproject.toml, pnpm-workspace.yaml)
A brand-new package with no older version, such as a typosquat Served on PyPI and npm, because no version is old enough yet (fail-open), and recorded Refused for 3 days
A release your administrator lets through early Installs right away Waits 3 days, unless the package manager's exclude list has it too

Package managers with a release-age setting

  • npm 11.10
  • pnpm 10.16
  • Yarn 4.10
  • Bun 1.3
  • Deno 2.6
  • pip 26.1
  • uv 0.9.17
  • Poetry 2.4
  • PDM 2.27
  • Bundler 4.0.13

The minimum version for each. Go, Maven, Gradle, Cargo, NuGet, gem and Composer before 2.11 have no stable setting yet, and container runtimes have none: there, SlowShield is the only layer. The Setup page writes the settings for you, on by default, with one switch to turn them off.

Keep your proxy close

Put one next to every team, server and build farm.

SlowShield is also a verified cache. Each instance is one small container with an embedded database, so you can run one per office, region or CI cluster, and each serves its machines at local-network speed. The instances can stand together as a shield wall: one leader holds the policy and shows the traffic of all of them, and the others follow it. The followers fetch package files through the leader, so each file comes from the public registry once for the whole wall, and a follower keeps working on its own while the leader is down.

⚡

Faster builds

Dependencies come from a nearby instance instead of a registry on another continent. Cache hits are sent zero-copy from disk.

⇣

Less bandwidth

One upstream download per artifact for a whole shield wall, instead of one per laptop, container build and CI job.

♺

Lower cost for everyone

Less egress and transit for you, less load on the community-run registries that the whole ecosystem relies on.

Best practice for teams

Send every install through SlowShield and block direct access to the registries.

Run one SlowShield for the team, point every laptop, server and CI runner at it, and let only SlowShield reach the public registries. A forgotten setting or a script with its own index URL can no longer skip the delay or the malware check.

Laptops, servers and CI runners all install through SlowShield; the firewall lets only SlowShield reach the public registries. Your network Developer laptopsshell settings ✓ Servers & containersENV in base images ✓ CI runnersenv on every job ✓ SlowShield slowshield.internal firewall / DNS Public registries pypi.orgfiles.pythonhosted.orgregistry.npmjs.org
Team setup: every client installs through SlowShield; direct connections to the registries are blocked.
  1. 1 Run one SlowShield for the team

    A small VM or a pod every machine can reach, with a real hostname and TLS (Caddy handles the certificates). Docker Compose, rootless Podman or the Helm chart.

  2. 2 Point every machine at it

    The same three settings everywhere: in each developer's shell, as ENV in your base images, and on every CI job.

  3. 3 Block direct access to the registries

    At the firewall or proxy, allow outbound HTTPS to the registries only from SlowShield, or answer their names in your internal DNS for everyone else. SlowShield itself only needs the registries and its advisory feeds.

Works great with Tailscale

Several SlowShields behind one Tailscale name.

Run a SlowShield in every region or office and put them all behind one Tailscale Service. Laptops, servers and CI runners on your tailnet use a single URL, and Tailscale sends each of them to an instance that is up. Nothing is exposed to the internet, Tailscale issues the HTTPS certificate, and there is no load balancer to run. Make the instances a shield wall and every client gets the same policy, whichever instance it reaches. We run SlowShield this way, across three regions, on servers and on Kubernetes.

Clients on the tailnet use one Tailscale Service name and reach a SlowShield instance, with regional routing the nearest one. The instances form a shield wall: Frankfurt leads, Virginia and Singapore follow, and all of them fetch from the public registries. Your tailnet Team in Zurichnearest: Frankfurt CI runnersnearest: Virginia Team in Sydneynearest: Singapore slowshield.your-tailnet.ts.net one Tailscale Service · svc:slowshield Frankfurteu-central-1 · leader Virginiaus-east-1 · follower Singaporeap-southeast-1 · follower Public registries pypi.org · registry.npmjs.org
Every client uses the same Tailscale Service name and reaches a SlowShield instance, with regional routing the nearest one. Frankfurt is the shield wall's leader; Virginia and Singapore follow it. Each instance fetches from the public registries.
  1. 1 Run SlowShield on each host

    docker run -d --restart unless-stopped -p 127.0.0.1:8080:8080 \
      -v slowshield:/data \
      -e SLOWSHIELD_PUBLIC_URL=https://slowshield.your-tailnet.ts.net \
      ghcr.io/squirro/slowshield:0.0.13

    One per region or office, on a small VM or server. Each keeps its own verified cache and works on its own. For one policy and one dashboard, start one with SLOWSHIELD_SHIELDWALL_ROLE=leader and the others with a join string from its slowshield wall invite (shield wall).

  2. 2 Put them behind one service

    # on every host, once svc:slowshield (endpoint tcp:443) is defined in the admin console
    sudo tailscale up --advertise-tags=tag:slowshield
    sudo tailscale serve --service=svc:slowshield --https=443 127.0.0.1:8080

    Hosts need a tag and Tailscale 1.86 or later. Before upgrading a host, drain it with tailscale serve drain svc:slowshield; the others take over.

  3. 3 Let your tailnet in

    "tagOwners": {
      "tag:slowshield": ["autogroup:admin"],
      "tag:ci":         ["autogroup:admin"]
    },
    "autoApprovers": {
      "services": { "svc:slowshield": ["tag:slowshield"] }
    },
    "grants": [{
      "src": ["autogroup:member", "tag:ci"],
      "dst": ["svc:slowshield"],
      "ip":  ["443"]
    }]

    Add this to your tailnet policy file, then point the shell settings above at the service URL. GitHub-hosted runners join for one job with the Tailscale GitHub Action.

Sending each client to its nearest instance takes Tailscale's regional routing (Premium and Enterprise plans) or MagicRoute (beta), set for the whole tailnet. Without either, all clients use one instance and move to another if that one goes away.

Agent sandboxes

Use it for coding agents too.

Coding agents run pip install, npm install, npx and uvx on their own, and nobody reads the output. Give their sandboxes the same SlowShield as your laptops.

  1. 1 Set it in the sandbox image

    # Dockerfile of the agent's sandbox, devcontainer or CI image
    ENV PIP_INDEX_URL=https://slowshield.example.com/pypi/simple/ \
        UV_DEFAULT_INDEX=https://slowshield.example.com/pypi/simple/ \
        npm_config_registry=https://slowshield.example.com/npm/ \
        GOPROXY=https://slowshield.example.com/go

    pip, uv, npm, npx, uvx and go all read these, so the agent needs no instructions.

  2. 2 Let only SlowShield out

    # network allowlist of the sandbox (the syntax depends on the sandbox)
    slowshield.example.com
    # leave out pypi.org, files.pythonhosted.org, registry.npmjs.org, proxy.golang.org and sum.golang.org

    With the registries off the allowlist, an agent can't install around SlowShield, even when it passes its own --index-url.

  3. 3 Teach the agent

    # Claude Code: the SlowShield skill (an Agent Skill; other agents: slowshield.org/docs/agents/#skill)
    /plugin marketplace add squirro/slowshield#v0.0.13
    /plugin install slowshield@slowshield

    It sets up every package manager and container runtime, and knows what SlowShield's answers mean: use an older version when one is too new, never install a blocked one. More for agents, and llms.txt.

Get started

Set it up in three steps.

Run it for your team

Images: ghcr.io/squirro/slowshield and ghcr.io/squirro/slowshield-caddy, for amd64 and arm64, each with an SBOM and build provenance attached. Pin a release (:0.0.13) or a digest in production. The changelog lists what changed in each release.

  1. 1 Run it

    git clone https://github.com/squirro/slowshield
    cd slowshield/deploy/docker
    cp .env.example .env          # your hostname, TLS mode, optional GitHub token
    docker compose up -d
    # add the Grafana stack: docker compose -f compose.yaml -f compose.observability.yaml up -d
  2. 2 Open the Setup page

    Open /ui/setup on your instance's hostname (https://slowshield.example.com/ui/setup), or Setup in the dashboard's menu. It shows how to point each tool at your instance, with its address already filled in: four lines for your shell profile that cover pip, uv, npm and go; settings for Poetry, PDM, Pipenv, pnpm, Yarn, Bun, Maven, Gradle, sbt, Coursier, Cargo, NuGet, Composer, Bundler and gem; the files for containerd and Kubernetes, Docker, Podman and BuildKit; and what to use in CI and containers.

  3. 3 Watch it work

    Open the dashboard to see what your organisation installs, which versions are waiting and what was blocked. Add a GitHub token to enable the second advisory feed; the dashboard explains how.

Pricing

Free for everyone.

Free & open source

$0for every team and every use

  • Every feature: release delay, malware blocking, integrity checks, verified cache, dashboard
  • PyPI, npm, Go modules, Maven, crates.io, NuGet, Packagist, RubyGems and container images, with every tool that installs through them
  • Unlimited users, machines, packages and instances
  • Self-hosted: Docker, rootless Podman or Kubernetes, your data stays with you
  • Grafana dashboards and alerts included
  • Apache-2.0 licence; community support on GitHub
Toni Birrer
Toni BirrerCo-founder, Squirro Husband, father, and wrangler of three cats, two dogs and a growing number of AI agents.

The story

Why we built SlowShield

In March 2026 the TeamPCP campaign turned trusted security tooling into a delivery mechanism: a compromised Trivy release leaked CI credentials, and within days backdoored packages were landing on PyPI. Mere minutes after one went live, one of our build servers pulled it. We caught it quickly and contained it before any lateral movement, but it was too close for comfort.

That night I built the first SlowShield around one simple rule that would have kept those packages off our machines: don't install anything younger than a week.

Yes, many package managers now have built-in delay settings. They are a great way to start, but I don't even trust myself to always have them set up.

So SlowShield has protected our teams at Squirro ever since. It has served millions of package downloads, and its cache has saved us terabytes of bandwidth. Along the way it also learned to block known malware, verify every download and show what gets installed where.

Now it's open source, so it can protect your team too.

SlowShield is maintained by the team at Squirro, which builds enterprise AI search and GenAI solutions for regulated industries.

Hold new releases back for a week before they reach your machines.

Free and open source under the Apache 2.0 license.