Threat Model and Risk Assessment
This page assesses the cybersecurity risks of the Hegemony platform as it ships: what it must protect, who acts on it, where trust changes hands, what can go wrong at each of those boundaries, which controls handle it today, and what risk is left. It is kept as the risk assessment that Article 13(2) and (3) of the EU Cyber Resilience Act describe, and it is revisited by the rule in Keeping This Assessment Current.
It records risk at the level of the design. Unresolved vulnerabilities are never described here: report them privately, as SECURITY.md explains.
Scope and Method
Scope
| In scope | Not in scope |
|---|---|
This repository and its five published images: api, worker, scheduler, ui, egress-nflog | The demo stack and the hegemony-demo repository |
The first-party plugin wheels the images install, from the four plugin repositories, and the registry extension the API ships | Development mode (HEGEMONY_AUTH_DISABLED, HEGEMONY_ENVIRONMENT=dev) |
| The bundled third-party services as the compose files run them: Keycloak, Temporal, PostgreSQL, OpenBao, the object store (Versity S3 Gateway), zot and Docker-in-Docker | Plugins and extensions from other parties |
| The build and release pipeline that publishes the images | The OpenTelemetry collector overlay (otel), until the product boundary says whether it is part of the product |
| What the platform requires of the host, the network and the systems it connects to | A hosted service run by a supplier |
Method
- List the assets, actors, components and data flows, from the architecture pages and the compose files, checked against the code.
- Mark the trust boundaries: every place where data or control passes between parties that trust each other differently.
- Walk each boundary with STRIDE: Spoofing, Tampering, Repudiation, Information disclosure, Denial of service and Elevation of privilege. For each threat that applies, record the controls that exist today, linked to the page that describes them, and the risk they leave.
- Give each residual risk a treatment:
- Tracked: open work the maintainers track; the residual risk is stated, without a date.
- Accepted: a documented design decision; the link says why.
- Operator: the deployment operator closes it (Operator Responsibilities).
Risks are not scored. On a self-hosted product the same design risk weighs differently in each deployment, so the page records how each one is treated; a reported vulnerability gets its severity in the security process.
Assumptions
- The platform runs on one Docker host with the shipped compose files and
ENV=prod, as Production Hardening describes. A deployment that runs the images another way must give each component the same isolation. HEGEMONY_ENVIRONMENTisprodorproduction, so the API's startup checks apply (Production Mode Enforcements).- The deployment operator controls the host, terminates TLS in front of the UI and Keycloak, keeps the host patched and keeps its clock synchronized.
- Every organization on an instance trusts its platform admins and its deployment operator: organizations share one Keycloak realm, Temporal namespace, secret store and database (Multi-Tenancy).
- Managed devices are reachable from the Docker host over a management network the operator runs.
Assets
| Asset | Where it lives | What must hold | Main protection |
|---|---|---|---|
| Device and integration credentials (organization secrets) | The secret backend; the database holds references only | Confidentiality | Secrets: resolved when a step runs, namespaced per organization, masked in output |
| Platform credentials: internal API token, token pepper, database, object store and Keycloak credentials, registry signing key, state encryption key, OpenBao credentials, seal and recovery keys | The env file and Docker volumes on the host | Confidentiality, integrity | Credentials, Secret stores |
| Device access: running commands and changing configuration on managed devices | Flows, executed by the worker | Integrity, availability | Role checks on flow editing and runs, approvals, SSH host keys, egress policies |
| Flow definitions, templates and attachments, and the git repositories they sync with | Database, object store, git remotes | Integrity | flow:manage, flow versions, Git Integration |
| Run evidence: events, step results, artifacts and logs | Database, object store | Integrity, then confidentiality | Written through the API's internal routes; secrets masked |
| Audit log | Database | Integrity, availability | Reliability guarantees, append-only table |
| Sign-in and access tokens: access tokens, personal access tokens, run tokens, event-stream tickets, webhook secrets and addresses | Browser session storage, clients; the database keeps digests only | Confidentiality | Sign-in and access |
| Terraform and OpenTofu state | Database, encrypted per version | Confidentiality, integrity | Encryption and Keys |
| Container images: the five published images, the platform registry's images and the sandbox's image store | GHCR, zot, the dind-data volume | Integrity | Release pipeline, platform registry |
| Workflow state: Temporal's workflow inputs and history | Temporal's PostgreSQL | Confidentiality, integrity | Internal network only; no secret values in the history |
| Tenant data and access configuration: inventory, variables, memberships, permission overrides | Database | Confidentiality between organizations, integrity | Multi-Tenancy, Role-Based Access Control |
Actors
| Actor | Trust | What it can do |
|---|---|---|
| Deployment operator | Full; outside the platform's control | Runs the host, Docker and the env file, and holds every platform credential |
Platform admin (realm role admin) | Trusted by every organization on the instance | Manages organizations, memberships, permissions, secret backends and extensions, and acts in any organization (Per-org RBAC) |
Organization admin (membership role admin) | Trusted within its organization | Manages its organization's inventory, secrets, members and settings, including the SSH host-key mode and secret writes by steps |
Membership role editor | Trusted with its organization's device access and with the secrets its flows resolve | Edits and commits flows, links them to git, and sets up schedules and webhooks, so decides what runs on devices and in the sandbox (Trusted input boundaries); also everything an operator can do |
Membership role operator | Trusted with its organization's device access | Starts and controls runs of the flows editors built, with the inputs their launch forms accept; cannot change a flow |
Membership role approver | Trusted to decide approvals | Approves or rejects paused runs (Separation of Duties) |
Membership roles auditor and viewer | Read-only | Read their organization's data |
| API clients and automation | As their token's scopes | Personal access tokens (API Tokens) and the hegemony-automation service account |
| Worker and scheduler | Platform services | Call the API's internal routes with the internal token |
| Step code | Plugin handlers are platform code in the worker; flow containers are untrusted workloads, contained by the sandbox | Run what a flow asks for |
| Managed devices | Partly trusted: identity checked by host key, output treated as data | Answer the worker's sessions; download files they are sent |
| External identity provider | Trusted to authenticate its users, through Keycloak | Signs users in; its groups can grant organization roles (IdP mapping) |
| Webhook senders | Untrusted until the endpoint's secret checks out | Start the one flow an endpoint targets |
| Integrated systems: git remotes, inventory sources, external secret backends, registries | Trusted for what they supply: whoever can write to them changes the flows, inventory, credentials or images the platform uses (Trusted input boundaries) | Supply flows, inventory, secrets and images |
| Notification targets | Recipients only | Receive the run and approval events they are subscribed to |
| Plugin and extension authors | Their code runs in-process with the rights of the API or worker | Anything those processes can do |
| Anyone else on the network | Untrusted | Reach only what the operator publishes |
Components, Data Flows and Trust Boundaries
The diagram marks each trust boundary (TB) on the flows that cross it. TB7 (between organizations, and between an organization and the platform) and TB8 (code supply) are not network hops; they cut across the whole picture.
| ID | Boundary | Between |
|---|---|---|
| TB1 | Client edge | Browsers and API clients, and the UI's nginx with the API behind it |
| TB2 | Identity | Keycloak, and the browsers, the API and external identity providers |
| TB3 | Public webhook ingress | External systems, and POST /hooks/{path_token} |
| TB4 | Internal service network | The API, worker and scheduler, with each other and with the bundled stores |
| TB5 | Flow-container sandbox | The worker, and the containers flows run |
| TB6 | Outbound | The worker, the sandbox and the API, and managed devices and integrated systems |
| TB7 | Tenant and privilege | One organization and another; an organization and the platform |
| TB8 | Code supply | Plugins, extensions, dependencies and the release pipeline, and the running processes |
| TB9 | Host | The containers, and the Docker host and its operator |
Components
| Component | Image | Zone | Reachable from outside the compose network |
|---|---|---|---|
ui: the web app, and nginx proxying /api/ to the API | hegemony/ui | Edge | Yes: the published UI port (UI_BIND_ADDRESS, UI_PORT) |
api | hegemony/api | Platform services | Only through ui |
worker, two replicas | hegemony/worker | Platform services | No |
scheduler | hegemony/scheduler | Platform services | No |
Keycloak, with its own PostgreSQL (auth overlay) | keycloak/keycloak | Identity | Its port, bound to 127.0.0.1 unless KEYCLOAK_BIND_ADDRESS widens it |
| Temporal, with its own PostgreSQL | temporalio/auto-setup | Stores and orchestration | No; its console is opt-in and loopback-only (Temporal console) |
| PostgreSQL for the application | postgres | Stores and orchestration | No |
OpenBao (openbao-internal overlay) | openbao/openbao | Stores and orchestration | No |
Object store (s3 overlay) | versity/versitygw | Stores and orchestration | Its S3 port, bound to 127.0.0.1 unless HEGEMONY_S3_BIND_ADDRESS widens it |
zot (registry overlay) | project-zot/zot | Stores and orchestration | No |
dind, dind-init | docker:28-dind (privileged), docker:28-cli | Sandbox | No |
egress-nflog | hegemony/egress-nflog | Sandbox, in dind's network namespace | No |
Data Flows
| Flow | Carries | Authenticated by |
|---|---|---|
Browser to ui and api | The web app, API calls, live event streams | Keycloak access token; a single-use event-stream ticket |
API client to ui and api | API calls | Personal access token or service-account token |
| Browser to Keycloak; Keycloak to an external identity provider | Sign-in | Password and one-time code, or the external provider |
api to Keycloak | The realm's signing keys | None needed: public keys |
Webhook sender to api | Webhook deliveries | The endpoint's HMAC or bearer secret; optionally its source addresses |
worker and scheduler to api | Step status, events, artifacts, step access, schedule triggers | Internal API token |
api and worker to Temporal | Workflows and activities | The compose network only |
api to PostgreSQL, object store and zot | Application data, files, images | Database password; S3 keys; registry tokens the API signs |
api and worker to OpenBao | Secret reads (worker), writes and Transit (API) | AppRole credentials, rotated and bound to OpenBao's network |
worker to the sandbox daemon | Container steps | The compose network only: dind drops its API port on every other interface, so flow containers cannot reach it; the worker checks the daemon's marker before using it |
Flow containers to api and zot | Managed state; image pulls and pushes | Per-step run tokens |
worker, sandbox and api to devices and integrated systems | SSH sessions, HTTP requests, git, notifications, image pulls | Credentials from the secret store; device host keys |
| Devices to the object store | File downloads | Presigned URLs |
Threats by Boundary
Each table walks STRIDE for one boundary. A residual risk names its treatment: "Accepted" or "Operator" when it has one; a risk with neither is tracked open work.
TB1: Client Edge
Everything a user or script sends enters through the UI's nginx, which serves the web app and proxies the API.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| S | A request carries a stolen or forged identity | Only RS256 tokens from the realm, with issuer, audience and expiry checked (JWT Validation Security); personal access tokens stored as digests, expiring, revocable (API Tokens); a recent sign-in required, and tokens refused, for changing secret backends, permission overrides and organization members and for issuing a token, and for any other action an administrator switches it on for (Step-up Authentication) | Tokens are readable by page scripts; the fresh sign-in covers only the actions it is on for, an administrator can switch it off for all but the permission editor (in the editor, or through a configuration import, which does not ask), and it does not prove a second factor was given; session lifetimes to review |
| T | Traffic or the page is altered between browser and API | Security response headers; a wildcard CORS origin refused in production (CORS) | Operator: TLS in front of the UI, and the full Content Security Policy enforced once it reports nothing |
| R | A user denies an action they took | Every mutating route makes an audit decision, checked in CI (The gates); refusals are recorded (Access decisions) | Keycloak's sign-in events are not collected with the audit log |
| I | A caller reads data their role does not allow | Every route maps to an action with a policy, and an unmapped route falls back to requiring authentication (Role-Based Access Control); CI fails a route without a rule | Credential material in API access logs |
| I | An outsider learns the release to pick known exploits | GET /system/version, which names the release, commit and build date, needs a signed-in caller; the health probes name none (Policies) | The public contract (/openapi.json) carries the release number |
| D | Request floods exhaust the API | A user holds at most 10 event-stream tickets (Rate Limit Behavior); webhook budgets (TB3) | No API-wide rate limit |
| E | A lower role reaches an admin function | One middleware enforces every route; permission:manage cannot be overridden (Actions and Overrides); the most dangerous flow options need admin (Handler-level narrowing); production refuses to start with authentication off | The startup checks apply only when HEGEMONY_ENVIRONMENT says production; each route is not yet tested against each role over HTTP |
TB2: Identity
Keycloak is the single trust anchor: every user, local or brokered from an outside provider, reaches the API with a token the realm signed.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| S | Someone guesses or reuses a password | Brute-force lockout, password policy, no self-registration, a one-time code for admins (Keycloak Security Features, Multi-factor authentication); PKCE with S256 (Sign-in code exchange) | Operator: users who sign in through an outside provider get their second factor there |
| T | A token is forged or its signing keys are swapped | The API validates one issuer and fetches its keys from the realm (Federated identity) | The API reaches Keycloak in plain text on the compose network |
| E | An identity-provider group grants an organization role it should not | Group mappings are managed by organization or platform admins; manual memberships are never changed by them; every change is audited with source: idp (Access decisions) | Operator: who controls the provider's groups controls these roles |
| E | A person who left keeps access | With group sync on, memberships the claims no longer give are removed; tokens can be revoked per user | Leaving the provider does not disable tokens or the user |
| R | Sign-in attempts cannot be traced | First sign-in and membership changes are audited | Keycloak's own events stay in Keycloak |
TB3: Public Webhook Ingress
POST /hooks/{path_token} takes requests from anyone who can reach the API; it authenticates inside the handler. The one other such route is GET /dl/{token}/{filename}, a file download link a running step issued for a target: its token is a run token that opens one file for minutes (Download Links Issued by Steps). Who reads a link in that time can download the file, so links belong on HTTPS or on the management network (Object store data and backups).
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| S | A forged delivery starts a flow | An address with 256 random bits; HMAC-SHA256 over a timestamp and the body, HMAC-SHA512 for NetBox, or a bearer secret; signatures compared in constant time; an optional source address list (Security) | Accepted: NetBox's signature carries no timestamp; its mitigations are documented (Signature Algorithm) |
| T | A captured delivery is replayed | A replay window on signed timestamps; an idempotency key answered with 409 (Idempotency) | None beyond the row above |
| R | A sender's deliveries cannot be traced | A delivery log per endpoint, and audit entries (Observability) | None |
| D | A flood costs database queries and secret lookups | An instance-wide ceiling before the endpoint lookup, a per-endpoint budget before the body is read, a delivery limit (Public webhook endpoint) | The budgets are per process; Operator: an external limiter in front of several replicas |
| E | A delivery runs something other than its target | An endpoint targets one flow of its own organization, and its runs pass the same admission as manual runs | None |
| E | A payload makes the worker render a template | Payload values are data: never rendered, checked in full against the flow's fields, and dropped when the flow declares no such field (Templates in run inputs) | None |
TB4: Internal Service Network
The platform services and the bundled stores talk over the compose network. Temporal, PostgreSQL, OpenBao and zot publish no port.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| S | Something on the network calls the internal routes as the worker | A required internal token, compared in constant time; known placeholders refused in production (Internal API Protection); internal routes take the organization from the run, never from the caller (Temporal / worker propagation) | One shared token, no identity per service |
| I, T | Traffic between services is read or changed | No published ports; OpenBao reached over verified TLS (Internal OpenBao) | Temporal, PostgreSQL, worker to API and API to Keycloak are plain text |
| I | A copy of a store's data is read | Secret values only in the secret backend; state encrypted per version; no secret values in Temporal's history (Security Notes) | PostgreSQL, the object store and Temporal's payloads rely on the host's disk encryption |
| T, R | Audit entries are changed or removed | Entries are written in the same transaction as the change; the table refuses updates and deletes except retention (Retention and immutability) | Someone holding the database credential can still change it; no supported export to a SIEM |
| I, E | An admin console exposes every organization | The Temporal, OpenBao and object store consoles are opt-in, and bound to loopback by default (Temporal console) | Operator: open them only on demand |
| E | A service's credentials reach more than it needs | Only the API, worker, scheduler and migration job load the platform env file; every other service, the ui included, gets only the settings it names (Platform environment and secret files); the worker reads secrets but writes them through the API (Secrets Written by Steps); only the API holds the registry signing key (Platform registry); OpenBao credentials expire and are bound to its network (What the bundled store already does) | The API, worker, scheduler and migration job share one env file, so each holds credentials only some of them use |
| D | A store is lost | Object store backup and restore task; OpenBao unseals itself after a restart | No procedure for every store |
TB5: Flow-Container Sandbox
Container steps run whatever image and commands a flow names, on a dedicated Docker-in-Docker daemon.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| E | A flow container reaches the host | Every flow container runs on the sandbox daemon, never the host's; the worker refuses a daemon that is not the attested sandbox (Flow-container sandbox); host-access options need admin (Handler-level narrowing) | Accepted: the sandbox is containment, not a hard boundary, because dind runs privileged; Operator: a dedicated, patched host |
| E, T | A step with host access controls other runs' containers | Only admin may give a step host access (Handler-level narrowing); other flow containers cannot reach the sandbox daemon's API, which dind serves on the compose network only (Flow-container sandbox) | Accepted: a step with host access administers the whole sandbox; Operator: restrict who edits flows and review changes through git (Docker socket exposure) |
| I | A container sends data where it should not | Egress policies per flow and step, enforced inside the sandbox; widening one needs admin (Flow settings, Container Sandbox); each step's evidence records the policy it ran under and how it was enforced (Egress policy in the evidence) | Operator: give flows an egress policy |
| S, E | A step token is reused beyond its step | Run tokens are minted per step, stored as digests, revoked when the step ends, and scoped to one state or to the organization's registry paths (Terraform/OpenTofu State Backend, Platform Registry) | Accepted: a build step may replace any tag of its organization's images; reference images by digest (Platform registry) |
| R | A container cannot be traced to its run | Containers carry the run, step and stack in their names and labels (Container Handler) | None |
| D | Images and volumes fill the sandbox's disk | A maintenance job prunes dangling images and build cache | Operator: watch the dind-data volume (Host requirements) |
TB6: Outbound to Devices and Integrated Systems
The worker logs in to devices, steps and the API reach external systems, and devices fetch files from the object store.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| S | A device impostor receives credentials | Shell and network-CLI steps check the device's and the jump host's SSH key, and store a first key before any credential is sent (SSH Host Keys) | Accepted: first contact trusts whatever answers unless a key is pinned and the mode is strict; the documented limits apply |
| S | A server impostor passes a step's TLS check | Steps trust the system store plus only the run organization's own trusted CAs, which admins manage; another organization's or the shared organization's list never applies, and a step's CA bundle pins its CAs | Operator: add only CAs you control or have checked; a trusted CA can vouch for any name its certificates cover |
| I | Credentials appear in output, evidence or logs | The values a step resolved are masked in its live output, evidence, result and the worker's log (Redaction of step output) | Values resolved outside a step are not covered; Accepted: the documented limits of redaction |
| I | Recorded device sessions are decrypted later | Post-quantum key exchange where the transport and device offer it (Network) | Not on most devices yet |
| T | An integrated system feeds the platform hostile content | Inventory files parsed safely and size-limited; the UI escapes what it renders (Trusted input boundaries) | Operator: write access to git and inventory sources is editor access |
| I, E | The platform is used to reach internal addresses | http.request refuses loopback, link-local, unspecified and multicast addresses; egress policies apply to worker-side steps too (Step handlers in the images); the API tests no registry login on private addresses | Operator: an egress policy on flows that call http.request or netbox.* |
| E | A step writes secrets or starts syncs beyond what was meant | Off until an admin allows it, limited to named path prefixes or providers, and only for a running step whose handler declares it (Secrets Written by Steps, Inventory Syncs Started by Steps) | None |
| R | Evidence claims a result that did not happen | Steps record their evidence; container steps record the image digest they ran, and an install step whose SSH login fails is recorded as failed | None |
TB7: Tenant and Privilege
Organizations share the instance; business data belongs to exactly one of them, and platform functions belong to platform admins.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| I | One organization reads another's data | An organization on every row, explicit filters with a session-level safety net, cross-organization reads answered as missing, and tests that block an unclassified model (Query scoping, Cross-org integrity) | A shared secret backend's paths outside orgs/<slug>/ are readable by every organization, and every secret backend is available to every organization (Multi-tenancy) |
| I | A flow resolves another organization's secrets | Paths namespaced per organization and checked by the worker before the backend is asked; env() and file() refused in organization content (Runtime template enforcement) | Accepted: shared-organization secrets are readable by every tenant that can use them (Shared organization secrets) |
| T | A tenant changes shared content | Shared-organization rows are read-only to other organizations, refused at flush (Shared organization) | None |
| E | An organization admin acts across the platform | Routes are classified organization or platform; platform routes need the realm admin role (Route Scope) | Accepted: a revoked membership is honored within 30 seconds (Caching) |
| E | A run input reads secrets the caller may not | A templated run input needs the permission to edit the flow and may not use secret(), env() or file(); a parent flow's values reach its child as data (Templates in run inputs) | Accepted: a run-input template can read organization variables, and a variable's value may call secret(), which the flow's own steps can read too |
| E | One person runs and approves the same change | approver is separate from editor and operator (Separation of Duties) | Admins and tokens with both scopes can approve their own runs; no multi-approver option |
TB8: Code Supply
What runs in the processes: the platform's code, its dependencies, the first-party plugins, and the images that carry them.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| T | A tampered or unexpected plugin or extension runs | Plugins are installed into the API and worker environments by the deployment operator, never through the application (Installed Plugins); extensions stay off until a platform admin enables them, and conflicting ones are refused (Extensions) | Plugins load with no allowlist or hash check, and installed extensions' code runs at discovery |
| T | A published image is not what was built | Each image is pushed by digest, scanned at that digest, and only then tagged; base images are pinned by digest (Release pipeline) | Images are signed and attested once the SIGN_IMAGES repository variable is set, and images released before then stay unsigned; the release workflow installs its own toolchain without a lockfile |
| I, E | A dependency carries a known vulnerability | Bandit, pip-audit, Semgrep and gitleaks on every pull request (enforced gates); a bill of materials per image (SBOM) | New vulnerable dependencies not blocked at review; automatic update pull requests cover only container images and plugin pins, with no written patch policy; the bills of materials have known gaps (SBOM); weekly checks miss one image |
| I, E | A cached package layer retains a known vulnerability after a fix is released | Release builds refresh the Debian package upgrade layers for API, worker, scheduler and egress-nflog on every run and retry; scheduled image scans refresh the three Python images they build. Trivy blocks publication on fixable HIGH/CRITICAL findings (Release pipeline) | Findings without an available fix remain in the non-blocking report; local builds need a new SECURITY_PATCH_REFRESH build argument to refresh cached upgrades; operators must deploy the patched release |
| T | An unreviewed change reaches a release | Human review and DCO sign-off on every pull request | Release tags are not signed |
| All | A fixed vulnerability stays in deployments | A private reporting and disclosure process (SECURITY.md) | No long-term-support line is named yet (Supported versions); the platform does not tell admins that a security update is available |
TB9: Host
The containers run on a host the deployment operator controls; some of them hold rights on that host.
| STRIDE | Threat | Controls in place | Residual risk |
|---|---|---|---|
| E | A compromised worker takes over the host through the Docker socket | The socket is mounted for one query, deriving the worker id, and no flow container can reach it (Docker socket exposure) | The mount itself remains; Operator: a dedicated host or a filtering socket proxy |
| E | A compromised platform container has more rights than it needs | The API, worker and scheduler images run as an unprivileged user; the bundled OpenBao drops every capability and runs read-only | The same settings for the platform's own containers, and a non-root UI |
| I | Platform credentials are read from the host | The OpenBao seal key is readable only by OpenBao; the registry signing key is given to the API alone | Operator: protect the env file, the volumes and the recovery keys (What you still have to decide) |
| D | The stack does not come back after a reboot | Restart policies and fail-fast dependencies (Restart policy) | One host |
| R | Events cannot be ordered across services | Timestamps on every audit entry and run event | Operator: NTP on every host (Time synchronization) |
Operator Responsibilities
A self-hosted deployment is secure only with these in place. The production checklist is the full list.
- Set
HEGEMONY_ENVIRONMENT=prod, and generate every credential fresh (Credentials). - Terminate TLS in front of the UI and Keycloak, with a certificate browsers trust; then turn on HSTS and enforce the full Content Security Policy (Security response headers).
- Publish the UI and Keycloak to users' networks only through your TLS proxy, and the object store's S3 port only where devices must download from it; never publish the sandbox daemon, zot, Temporal, OpenBao or PostgreSQL (UI port exposure, Flow-container sandbox, Platform registry, Object store data and backups).
- Run the stack on a dedicated, patched host that allows the sandbox, and limit what the worker's Docker socket can do (Host requirements, Docker socket exposure).
- Keep the env file, the Docker volumes and the OpenBao recovery keys away from anyone who should not administer the instance (What you still have to decide).
- Give
flow:manageandrun:triggeronly to people trusted with device access, give flows egress policies, and leave out of the images any step the deployment must not offer (Step handlers in the images). - Control write access to git and inventory repositories (Trusted input boundaries).
- Require multi-factor authentication at any outside identity provider, and manage its groups as role grants (Multi-factor authentication).
- Pin the SSH host keys of devices that matter and use
strictmode (SSH Host Keys). - Keep the admin consoles closed (Temporal console).
- With several API replicas, run a secured Redis for tickets and a rate limiter in front of the API (Multi-replica deployments).
- Keep time from NTP, ship the audit log and logs off the host, and back up every store (Time synchronization, Object store data and backups).
- Install security updates as releases publish them.
Keeping This Assessment Current
Revisit this page, in the same pull request, when a change:
- adds an entry point: a route with the
public,customorinternalpolicy, a published port, or a new inbound protocol; - adds or moves a trust boundary: a new service or network, a change in privileges (privileged mode, capabilities, mounted sockets), or a change in which component holds a credential;
- adds, replaces or removes a bundled third-party component;
- adds a plugin subsystem or a way for extensions to run code;
- removes a residual risk this page names, or adds one.
Also revisit it before each release, and after a vulnerability that touched a boundary has been disclosed. Record each review below.
Its entry in docs/docs-map.yaml makes the freshness gate flag this page when a pull request changes the production compose files and overlays, the published images' Dockerfiles, the UI's nginx or the HTTPS proxy configuration, the files that authenticate requests and classify routes, the public webhook router, or the plugin and extension loaders. Such a pull request updates the page or states why it does not need to (Docs-Not-Needed).
| Date | Review | Where |
|---|---|---|
| 2026-10-15 | First assessment, against develop at 6ffe7de7 | The pull request that added this page |