Enterprise · self-hosted · public beta

ShakerScan Enterprise, self-hosted.

The open-source ShakerScan engine, behind your identity provider, on your own servers.

Single sign-on through your OpenID Connect provider, passkeys and recovery codes, enforced roles, audit and an offline licence in front of the public engine, with recurring scans, retests that close findings on proof and Jira tickets. No telemetry or licence check-in; scan data stays on your host. Public beta, pilots open.

Pilots run on a time-boxed evaluation licence with the maintainers on the call; there is no self-service purchase.

Platforms and sign-in

What it runs on, and who can sign in.

Platforms

One Linux host with Docker Engine and Compose 2.20+, x86_64 (linux/amd64 images).

  • Ubuntu 24.04 LTS

    Recommended. Validated with the one-command installer, including reboot and backup.

    Supported
  • Ubuntu 26.04

    Validated in continuous operation.

    Supported
  • AWS ECS (Fargate)

    Reference deployment for evaluation; not a supported deployment.

    Evaluation only
  • Amazon EKS / Kubernetes

    Reference manifests for evaluation; not a supported deployment.

    Evaluation only

Identity providers and sign-in

Roles come from provider groups or per-person admission.

  • Okta

    Group-to-role mapping and console test sign-in, with a setup guide.

    Supported
  • Keycloak

    Including deployments behind a private certificate authority.

    Supported
  • Microsoft Entra ID

    Console preset with group-ID claims; not yet verified against a live tenant.

    Preset, not yet verified live
  • Other OpenID Connect providers

    S256 PKCE, RS256 or ES256 ID tokens, client_secret_basic or _post.

    Supported
  • Google Workspace

    Sign-in with per-person admission through the standard OpenID Connect setup; no group-to-role mapping.

    Sign-in only
  • Local accounts

    Password, passkeys, authenticator app, recovery codes, invitations.

    Supported
  • SCIM provisioning

    Access is revoked by disabling the person in the console.

    Not available
Identity and access

Your identity provider decides who gets in. Roles decide what they can do.

The gateway sits in front of the engine and authenticates and authorizes every request, so nobody reaches a scanner, a finding or a credential without signing in through your policy.

Single sign-on with your identity provider

OpenID Connect with PKCE, verified with Okta and Keycloak; a Microsoft Entra ID preset exists but is not yet verified against a live tenant. Other providers need S256 PKCE and RS256 or ES256 ID tokens. Configure it in the console and run a test sign-in at the provider before saving; changes apply without a restart and are audited. Two-step verification for these accounts is your provider’s policy.

Passkeys, two-step verification, recovery codes

Local accounts sign in with a passkey (fingerprint, face or PIN; phishing-resistant and a second factor on its own) or a password plus authenticator-app codes. Ten single-use recovery codes replace a lost passkey or phone. The policy is yours: off, required for local administrators, or required for every local account.

Groups to roles

People are admitted by exact subject or by mapping your identity-provider groups to a role on first sign-in. Nobody gets in by default. An administrator can require single sign-on and keep one break-glass local administrator.

Three enforced roles

Viewer reads results; operator runs scans, retests and Hunt; administrator manages people, tokens, settings and updates. Every request is checked against reviewed per-role allowlists, and unknown routes are refused.

Sessions and fresh proof

Server-side sessions with short absolute and idle lifetimes set in the console; changing a role, password or factor ends that person’s sessions. Revealing a discovered secret, accepting Hunt-written guidance or dismissing findings needs fresh proof for that one decision: a passkey, an authenticator code or a fresh sign-in at your provider. So do the administrator changes that open a lasting way in: adding an administrator, inviting a person, issuing a service token or a reset code, and turning a sign-in protection down.

Service tokens for automation

Scoped viewer or operator tokens for CI and agents, shown once, stored hashed, valid for at most 90 days and revocable. They cannot open the console. An administrator can require a security-key touch for the decisions only a person should make from a terminal, so an agent holding a person’s token cannot make them.

People lifecycle

One-time invitation links (valid three days) where people choose their own password; disable and re-enable; one-time reset codes issued by an administrator; a break-glass local administrator next to single sign-on, and server-side recovery commands for the operator.

Audit trail

Sign-ins, administration, settings changes and every engine request (method and path, never bodies or secrets), with who and when. Filter in the console, export as NDJSON.

Measured, not promised

Numbers from recorded runs on real hosts.

Recorded in September 2026 on Ubuntu 24.04 with gateway 0.2.0-beta.12 to beta.18 and engine 2.3; not yet re-measured on the current release.

~4 min

one command, clean Ubuntu 24.04 host

From published, signed artifacts to a running stack with the first administrator, a daily backup and the engine updater installed. Re-running it resumes an interrupted install.

7 checks

one verification command

Gateway signature, SBOM attestation and the build attestations of all five engine images, before anything is deployed. The installer runs it for you.

140 s

engine update from the console

From the administrator’s click to the new engine verified (2.3.6 to 2.3.9): backup, install, render, pull, restart, verify, with scans, evidence, identities and the licence intact.

How it runs

Two things on one Linux server of yours.

You install two things on one Linux server: the open-source ShakerScan engine (public images, pinned by digest) and the Enterprise gateway (a private, signed image). The gateway handles login through your OpenID Connect provider, viewer, operator and administrator roles, an audit trail, and a signed licence that never phones home. Scans run on your host against your applications; findings and evidence stay there.

Outward, the host talks to your targets and your identity provider, and, at install and update time, to the image registries, GitHub and Sigstore; Let’s Encrypt too, unless you bring a certificate.

What you get

Deployment and operations, labeled by maturity.

Public beta means published, signed, exercised on real hosts, and offered to pilots. Preview means it works and is included, with gaps stated.

Public beta

One command on one Linux host

The installer checks the host, verifies the signed images, installs the public engine pinned by digest with the private gateway in front of it, sizes the scan workers to your licence and memory, and starts everything with Docker Compose. The gateway passes each request through reviewed per-role allowlists; unknown routes are refused.

Public beta

Offline licence with concurrent-scan slots

A signed, installation-bound licence file checked offline. It sets how many scans run at once; the gateway reserves a slot per scan, retest or scheduled run and refuses beyond it, naming what holds the slots. Inventory discovery of a new host takes no slot. Expiry stops new scans only. Renewal works from a usage summary you export yourself.

Public beta

Recurring scans

Operators schedule a scan of an authorized web target daily, on chosen weekdays, weekly or monthly, in a named time zone. Each run is recorded with its outcome; a run waits for a free slot and never authorizes its target itself. A status endpoint for monitoring and an evidence export (CSV or JSON with a SHA-256 of its rows). Included with every licence.

Public beta

Retests that close findings

Ask for a retest of one finding or many from Retests and fixes. A retest that proves the fix closes the finding; a later scan that sees it again reopens it. Each open finding’s age against a per-severity SLA, what changed between a target’s scans, an evidence export for your auditor, and the findings themselves as CSV or JSON.

Public beta

Jira tickets for findings

An administrator connects Jira Cloud or Data Center. One ticket per finding, from the console or a terminal, linking back to the finding; a retest that proves the fix comments on the ticket and moves it to done, and each ticket’s Jira status is shown. Tickets never carry evidence, requests or responses.

Public beta

Networks, devices and exposure

On by default: host targets, network scans (port and service discovery from your host; nothing installed on devices), connected devices, the Exposure and attack-surface views, and a certificate-transparency monitor that adds new names under your domains as targets. Private addresses are allowed by default; an administrator can refuse them or turn each part off.

Public beta

Agents, the command line and browser capture

A one-time connect link from the console, then pipx install shakerscan (or brew install andriyze/shakerscan/shakerscan) and shakerscan agent claude, codex, opencode or pi: your coding agent works against your instance over MCP, under your identity and in the audit log. shakerscan record turns a browser session you sign in and walk through into a capture that scans and Hunts use.

Public beta

Updates, backup and restore

An administrator picks a newer published engine release this gateway has reviewed; the host updater backs up, installs, restarts and verifies, and puts the previous engine back if a step fails. An encrypted daily backup of the engine database, evidence, identities, schedules and deployment files, restorable onto the same or another host. Start at boot, log rotation, your own certificate or Let’s Encrypt, a corporate proxy for the certificate authority, the identity provider and the gateway release channel.

Preview

Hunt, the AI-assisted investigation workspace

On for operators by default. Operators drive it in the browser, through their agent over MCP or from the CLI; viewers read. A step a person must allow waits as a permission request that the person approves in their own terminal. Your own model credentials are needed only for the engine’s autonomous features; the autonomous Hunt runs read-only and shadow episodes, and active runs are not available.

What the beta does not include

Said plainly, so you can plan.

  • One organization per installation, with no project or team isolation: evidence is visible within a role, not per project.
  • No high availability: a single gateway process on one host. No SCIM: removing someone at the provider stops new sign-ins; disable them in the console to end sessions and revoke tokens. No provider-initiated sign-out.
  • Ubuntu 24.04 and 26.04 on x86_64 only; other distributions and ARM hosts are not supported.
  • No continuous attack-surface management: recon and tests run when a person, an agent or a schedule starts them (the certificate-transparency monitor only adds targets). Fleet administration, AI Gate and Model Intake are not exposed through the gateway.
  • No air-gapped installation: installing and updating need Docker Hub, ghcr.io and GitHub, plus the Sigstore services for signature checks and, for gateway updates from the console, the release channel on shakerscan.com.
  • Kubernetes (EKS) and ECS Fargate reference layouts exist for evaluation only. The supported deployment is one Linux host with Docker.
  • Jira is the only ticketing integration; no Slack, webhook or SIEM integrations, and the audit log is exported as a file. Findings of a signed-in scan or a Hunt are not retested; run a fresh signed-in scan instead. Active autonomous Hunts are not available (read-only and shadow runs are).
  • No SLA, no certifications and no third-party penetration test of the gateway yet. Pilots run on a time-boxed evaluation licence.
Requirements

What the host needs.

  • Ubuntu 24.04 LTS or 26.04 on x86_64 (see Platforms above).
  • Docker Engine 24+ with the Compose plugin 2.20+, and cosign and the GitHub CLI (gh) for the signature and attestation checks. You keep root.
  • 16 GB of memory for one scan worker and 4 GB more for each further concurrent scan (2 GB more with network scans on); the installer refuses under 8 GB and runs one worker under 16 GB. 4 vCPU, 8 vCPU for several concurrent scans. 40 GB of disk, 100 GB or more recommended.
  • A DNS name for the host, inbound 443 (and 80 for Let’s Encrypt), or bring your own certificate.
  • Outbound: Docker Hub and ghcr.io for images, GitHub and Sigstore for the engine release catalog, the engine installer and signature checks, shakerscan.com for the signed gateway release channel, your identity provider, your Jira site if connected, the public certificate-transparency logs while the CT monitor is on, Let’s Encrypt unless you bring a certificate, and your targets. A proxy is supported for the certificate authority, the identity provider and the gateway release channel.
  • Private-network targets (10/8, 192.168/16, 100.64/10, unique-local IPv6) are allowed by default; an administrator can refuse them for the deployment. The deployment’s own addresses (Docker’s 172.16.0.0/12, loopback, link-local, cloud metadata) are always refused.
Install on a Linux host
Security and data

Built for a security team’s review.

  • No telemetry, no licence check-in, no vendor access. Besides sign-in at your identity provider and the Jira site an administrator connects, the gateway makes two read-only requests of its own, only for an administrator’s console as it shows or requests updates: the public engine release catalog from GitHub and the signed gateway release channel from shakerscan.com. Neither sends anything about your installation; a successful answer is reused for ten minutes, a failed one is not kept.
  • Every mutation requires the browser origin and a CSRF token; identity headers never cross into the engine; evidence is served under a sandbox policy.
  • Workers cannot reach the API, the Docker socket is not mounted, only the TLS front publishes ports, every container has resource limits.
  • Gateway releases are built from a tagged commit, start-tested, blocked on fixed high and critical vulnerabilities, signed with Sigstore keyless signing and shipped with an SPDX SBOM attestation.
Pilot in 30 days

Thirty days on your host, with the maintainers.

Week 1

Questionnaire, licence and pull access; install on your host with us on a call.

Weeks 2–3

Your operators scan your applications; we review findings and fix what blocks you.

Week 4

Backup, upgrade and restore drill on your side; decision.

The email opens with the questions a pilot starts from: your company and role, your identity provider, where the host would run, how many applications you scan and whether any are internal-only, and the concurrent scans you expect.

Questions
Is the engine open source?
Yes, AGPL-3.0, public images on Docker Hub and source on GitHub; Enterprise runs those images unchanged. The Enterprise gateway is proprietary and delivered as a signed private image; the operator scripts and guides ship inside it, and its source is available to paying customers on request.
Is there a hosted option?
No. Enterprise runs on your own host.
Open source stays the core

Enterprise is additive.

Enterprise runs the public engine images unchanged. Identity, administration, licensing, schedules, retests that close findings and Jira sit in front of them; nothing is removed from the open-source release. In this beta the gateway exposes a reviewed part of the engine, listed above.

See what the open-source release includes