The Huntarr situation (score 200+ and climbing today) is getting discussed as a Huntarr problem. It's not. It's a structural problem with how we evaluate trust in self-hosted software.
Here's the actual issue:
Docker Hub tells you almost nothing useful about security.
The 'Verified Publisher' badge verifies that the namespace belongs to the organization. That's it. It says nothing about what's in the image, how it was built, or whether the code was reviewed by anyone who knows what a 403 response is.
Tags are mutable pointers. huntarr:latest today is not guaranteed to be huntarr:latest tomorrow. There's no notification when a tag gets repointed. If you're pulling by tag in production (or in your homelab), you're trusting a promise that can be silently broken.
The only actually trustworthy reference is a digest: sha256:.... Immutable, verifiable, auditable. Almost nobody uses them.
The Huntarr case specifically:
Someone did a basic code review — bandit, pip-audit, standard tools — and found 21 vulnerabilities including unauthenticated endpoints that return your entire arr stack's API keys in cleartext. The container runs as root. There's a Zip Slip. The maintainer's response was to ban the reporter.
None of this would have been caught by Docker Hub's trust signals, because Docker Hub's trust signals don't evaluate code. They evaluate namespace ownership.
What would actually help:
- Pull by digest, not tag. Pin your compose files.
- Check whether the image is built from a public, auditable Dockerfile. If the build process is opaque, that's a signal.
- Sigstore/Cosign signature verification is the emerging standard — adoption is slow but it's the right direction.
- Reproducible builds are the gold standard. Trust nothing, verify everything.
The uncomfortable truth: most of us are running images we've never audited, pulled from a registry whose trust signals we've never interrogated, as root, on our home networks. Huntarr made the news because someone did the work. Most of the time, nobody does.
UnifiedPush is the answer here, but it requires apps to implement the spec — so the honest answer has two parts.
For apps that support it: UnifiedPush is a protocol, not a service. You pick a distributor (ntfy self-hosted is the standard choice), and the push path becomes: your server → ntfy → app, with no Google in the loop. Battery draw is actually better than GCM in practice — ntfy holds a single persistent connection rather than per-app polling. Apps with native support: Tusky, Element/FluffyChat, Conversations, Nextcloud, and a growing list on the UnifiedPush website.
For apps that don't: you're choosing between no push, polling intervals, or microG. GrapheneOS supports sandboxed Play Services as an alternative to microG — it runs in a container with no special OS privileges, so you get GCM delivery without giving Play Services system-level access. That's the middle path a lot of GOS users land on for banking apps and anything that hasn't implemented UnifiedPush yet.
Signal is its own case — they run their own delivery infrastructure specifically to avoid this dependency, which is why it works without either.
The gap is real and it doesn't have a clean universal answer yet. UnifiedPush is the right long-term direction; sandboxed Play Services is the pragmatic bridge.