Skip to content

Reference

Security

This page covers the threat model, what the auth middleware does, what NetworkPolicies do and don't enforce, the supply-chain posture, and the questions an enterprise reviewer will ask, answered in advance, because this product is sold into environments with a security review gate.

Threat model

SRE Orbit is self-hosted: every container runs in your account, on your cluster, and architecture.md establishes that nothing leaves it. That collapses most SaaS threat modeling (no shared multi-tenant data plane, no vendor breach that touches your data) and leaves four things this design has to defend against:

  1. An unauthenticated caller on your network reading the estate or spending your model budget. Round 1 of this product shipped both orbit-api and nocturne with no authentication at all; CONTRACT.md's Addendum v0.2 exists because "an unauthenticated caller could read the whole estate and choose which model tier to bill." Mandatory auth (below) closes this.
  2. The browser holding a credential it shouldn't. A token that reaches client JavaScript is a token an XSS bug, a malicious browser extension, or a leaked source map can exfiltrate. The server-side proxy in web (see architecture.md) means ORBIT_AUTH_TOKEN and NOCTURNE_AUTH_TOKEN never reach the browser at all, so there's nothing there to steal.
  3. A workload in an unrelated namespace reaching a service it has no business reaching: the estate API or, worse, an LLM endpoint that bills per token. NetworkPolicies (below) constrain this at the network layer, on top of the auth layer, so a bug in one is not the whole defense.
  4. A person doing more than their role allows, with their own account, a stolen session, or a page on another site riding their browser. Every route checks the session and one permission server-side, the cookie never reaches JavaScript, a mutating request must prove it is same-origin, and every change and refusal is an audit event (below).

Out of scope for this document, because they're decisions you make, not ones this product makes for you: identity provider choice for oidc mode, the RBAC bound to ORBIT_KUBECONFIG's service account against your real cluster, and your own organization's key-management policy for the tokens you generate.

What the auth middleware does

One middleware, ahead of the router, on both backend services, on the API listener only (never on the metrics listener; there's nothing to exempt it from, see below).

  • static mode (default): Authorization: Bearer <token> compared against ORBIT_AUTH_TOKEN / NOCTURNE_AUTH_TOKEN using a constant-time comparison, to avoid a timing side-channel that leaks the token one byte at a time. The service refuses to start if its token is empty or under 32 bytes: misconfiguration fails closed, at boot, not open, at request time.
  • oidc mode: the bearer is parsed as a JWT, signature-verified (RS256/ES256) against the issuer's JWKS, and checked for exp, iss, and aud. Keys are cached with a bounded refresh rather than fetched per request.
  • disabled mode: every request passes. The service logs a WARN naming the risk on every startup (not only the first), and it refuses to start if ORBIT_DEMO_DATA=false: there is no way to run auth-disabled against real cluster data, by construction, not by convention.
  • Exempt paths, unconditionally, on every mode: GET /healthz, GET /readyz. Nothing else. In particular, /api/v1/version requires a valid credential like everything else on the API listener.
  • Failure shape: 401, body {"error":{"code":"unauthorized","message":"..."}}. The message never says whether the token was missing, malformed, or merely expired. An attacker probing for a token that's close to valid wants that distinction, and withholding it costs a legitimate caller nothing (they either have the right token or they regenerate it).

What NetworkPolicies do and do not enforce

The Helm chart and the plain kubectl manifests both render a default-deny policy per namespace, then open exactly the paths CONTRACT.md requires: ingress → web only, web → orbit-api, orbit-api → nocturne, everything → CoreDNS, and (only once you name the namespace) your monitoring namespace → each service's :9090 metrics port. nocturne gets internet egress at all only when you explicitly set allowInternetEgress: true for it, and even then the egress rule excludes 169.254.0.0/16 (cloud instance metadata), the RFC1918 ranges and 100.64.0.0/10 (the carrier-grade NAT range EKS custom networking gives pods), so a prompt-injected SSRF in the model path cannot mint cloud credentials or pivot into your VPC or your pods through that hole. Every other internet egress the chart opens (orbit-api for SSO, the AWS bill and alert webhooks, orbit-agent for CloudWatch) excludes the same ranges, and deploy/check_hardening.py fails a render that drops one.

A NetworkPolicy object can apply cleanly and still not be enforced, as the chart's own comments say. Kubernetes only enforces NetworkPolicy if the cluster's CNI implements it.

  • Flannel alone does not implement NetworkPolicy, but k3s (and so k3d) does not run flannel alone: it bundles kube-router's policy controller, which writes one iptables chain per policy on every node. On install/local-k3d.md's cluster the policies are enforced, and the telemetry feed works through them.
  • Calico and Cilium enforce it. EKS enforces it only with the VPC CNI's network policy agent turned on (or a Calico/Cilium add-on); most EKS clusters run without it, and there the objects apply and block nothing.

If a security reviewer asks "is this enforced," the answer has two parts: the policy is defined correctly regardless of cluster, and whether it's enforced depends on a property of your cluster this product doesn't control. Prove it yourself before relying on it: deploy on your real CNI, then attempt the connection the policy should be blocking from a pod in an unrelated namespace and confirm it times out.

/metrics is the sharpest edge here. networkPolicy.monitoringNamespace defaults to empty on purpose: with no value set, no scrape rule renders at all, and :9090 stays unreachable from outside the namespace even with NetworkPolicy fully enforced. The chart used to scope this with a bare pod label (app.kubernetes.io/name: prometheus) with no namespace restriction, which is not an identity check: any workload author in any namespace could set that label on their own pod and reach the metrics port. Naming the namespace explicitly is what makes the rule mean anything; the pod-label selector inside monitoringPodLabels only narrows further once the namespace is already trusted.

Who the collector believes

The chart's collector (apm.collector, engine orbit) takes OTLP on ports 4317 and 4318 from every namespace, because an SDK app sends from wherever it runs. No NetworkPolicy can narrow that, and an SDK carries no OTLP credential by default. So the collector looks up the address a request comes from in its pod watch and decides what the sender may claim:

SenderIt may speak forThe collector stores
A pod in the release's node namespace or in apm.collector.orbit.trustedNamespacesOther pods: orbit-node reads their log files, orbit-probe and OBI trace their socketsThe k8s.* attributes it sent, with what the pod watch adds where they are missing
Any other podItselfIts own pod's k8s.pod.name, k8s.namespace.name, k8s.pod.uid, workload and node, in place of every k8s.* it sent. k8s.container.name when it names one of the pod's containers, else the pod's only container. service.name when the pod's spec declares it, else the pod's own service
An address no pod holds (a node, a hostNetwork process)Nothing in KubernetesIts service.name, and none of the k8s.* it sent

A pod's spec declares a service name with the resource.opentelemetry.io/service.name annotation, a literal OTEL_SERVICE_NAME (or service.name in a literal OTEL_RESOURCE_ATTRIBUTES) on any container, the app.kubernetes.io/name or app.kubernetes.io/instance label, its workload's name, its own name or a container's name. The OpenTelemetry Operator writes OTEL_SERVICE_NAME into the spec, so the apps it instruments keep their names. An app that sets its name in code alone gets the pod's own service, the first of: the annotation, OTEL_SERVICE_NAME, OTEL_RESOURCE_ATTRIBUTES, app.kubernetes.io/name, the deployment, statefulset, daemonset, cronjob or job, the pod's name. Set the annotation on the pod template to pick it. The collector never resolves an env entry's valueFrom.

Whoever it believes for k8s.*, a sender outside the trusted namespaces keeps no span attribute named orbit.* and no telemetry.sdk.name of orbit-probe. Those are orbit-probe's, and the engine acts on them: a span's orbit.hop.trace_id moves the trace it names into the span's own for 15 minutes, and the probe's parentless calls are stitched under requests. Without the cut, a pod that saw a trace id in an incoming traceparent could take that trace over.

An address check cannot tell apart the processes that share a node's address. Where a hostNetwork pod of a trusted namespace runs (OBI with apm.autoInstrument.contextPropagation, node-exporter with telemetry.nodeExporter.engine: upstream), any hostNetwork pod on that node speaks for other pods, and on any node a hostNetwork pod can still claim a service.name. That is the ceiling: label your namespaces pod-security.kubernetes.io/enforce: baseline (or restricted) and Kubernetes refuses hostNetwork pods there. APM covers a Collector gateway of your own and the service mesh case. apm.collector.engine=upstream keeps otelcol's own association, which believes the pod and service a payload names.

What web's own auth does

architecture.md's server-side proxy keeps ORBIT_AUTH_TOKEN off the browser, but that only protects the token, not the path to it. Nothing used to stop another pod on the same cluster from calling <release>-web:3000/api/... directly: no CNI enforcing NetworkPolicy is the common case on EKS, not the exception (see above), and the only user-facing auth was the optional ingress-nginx basic auth, which a direct in-cluster call skips entirely. A caller that reaches web that way rides its server-side bearer for free and can read pod logs, ConfigMaps, env literals, events, inventory, and raw PromQL. web now authenticates every request itself, so that path needs a credential even with no enforcing CNI in front of it.

  • Every route but one. HTTP Basic auth runs in web's own proxy (apps/web/src/proxy.ts, Next.js's middleware, with no matcher, so it runs on every request) in front of pages, the Orbit Deck, /api/* including the SSE streams, and every static file. The one exemption is GET /healthz: the proxy answers it itself, before auth and before locale routing.
  • Checked three times. Next.js skips apps/web/src/proxy.ts for a request whose x-prerender-revalidate header matches the build's preview id, and that id ships inside the image (.next/prerender-manifest.json), so anyone holding the image could skip the proxy. The credential is checked again in the /api/* handler that holds the bearer, before any upstream call, and again in every server-side read of orbit-api (apps/web/src/lib/orbit-api.ts, and apps/web/src/lib/prom-fetch.ts before its shared PromQL memo), so a page rendered without the credential carries no data. apps/web/next.config.ts also redirects any request carrying that header to /, since nothing here revalidates on demand.
  • The verifier is stored, never the password. WEB_AUTH_VERIFIER holds pbkdf2-sha256$<iterations>$<base64 salt>$<base64 hash>: PBKDF2-HMAC-SHA256 via Web Crypto, a 16-byte random salt, a 32-byte hash, at least 210,000 iterations accepted. node apps/web/scripts/hash-password.mjs < password-file generates it: stdin only, never argv, refuses an interactive terminal so the password is never echoed, strips one trailing newline, and refuses anything under 15 characters (NIST SP 800-63B-4's minimum for a password that's the only factor). The script itself writes 600,000 iterations, OWASP's current figure for PBKDF2-HMAC-SHA256. Both the user name and the derived hash are compared in constant time, and both comparisons always run.
  • Fails closed. WEB_AUTH_MODE=basic with WEB_AUTH_USER or WEB_AUTH_VERIFIER missing or malformed returns 503 not_ready on every path, including /healthz, and logs one web auth: line. The pod never becomes Ready, so a bad verifier stalls a rollout instead of replacing working pods with broken ones.
  • Two layers of rate limiting. A correct credential is derived once per process and cached; matching it again afterward costs one HMAC under a per-process random key, not another PBKDF2 run, so a caller already signed in never waits. The global layer: more than two password derivations in flight at once returns 429 rate_limited with Retry-After: 1, no matter which client triggered them. The per-client layer: after 5 wrong passwords, each further wrong one doubles the wait (1, 2, 4 s, up to 60 s), during which that client's new guesses get 429 with Retry-After set to the seconds left; 15 minutes without a miss forgets the count, and a correct sign-in clears it outright. The client is the last X-Forwarded-For hop (the ingress's view of the caller, or the socket address Next fills in when the header is absent), and any pod that can already reach web directly can forge and rotate that header, which is why the global layer stays: an in-cluster flood can still burn CPU and delay new sign-ins no matter how many client identities it claims. values-eks.yaml also caps requests at the edge, per source IP, with nginx.ingress.kubernetes.io/limit-rps: "20" and nginx.ingress.kubernetes.io/limit-connections: "20". None of this substitutes for a strong password. Generate one (openssl rand -base64 24); no rate limit can fix a guessable password.
  • Mutually exclusive with ingress basic auth, enforced at render. ingress-nginx clears the Authorization header once its own basic auth succeeds (proxy_set_header Authorization ""), so running both would lock every caller out behind the ingress. The Helm chart's render fails if ingress.basicAuth.enabled and components.web.auth.enabled are both on, rather than shipping that config. deploy/check_hardening.py asserts the refusal, and asserts that every install path (Helm defaults, dev, EKS, prod, and plain kubectl) gives web WEB_AUTH_MODE=basic with both WEB_AUTH_USER and WEB_AUTH_VERIFIER sourced from the release Secret with no optional.

Sessions, roles and the audit trail

Addendum v0.5 puts a person behind every call. What that adds to the defense, and where each control lives:

  • The session never reaches JavaScript. orbit-api issues an opaque token, a session id with an HMAC-SHA256 signature (key ORBIT_SESSION_SECRET, or 32 random bytes in ORBIT_DATA_DIR/session.key). web's own sign-in route moves it into the cookie __Host-orbit_session on https (HttpOnly, SameSite=Lax, Path=/, Secure, no Domain, so a sibling subdomain can neither set nor read it) or orbit_session on plain http, and strips it from the body. On https web reads only the __Host- name. web sends it on as X-Orbit-Session and never forwards the browser's Cookie header, so nothing else a browser holds for this domain reaches a service.
  • Sessions end. 24 hours after sign-in, whatever happened in between; after 8 hours with no request; on logout; and for every session of a user who is disabled, deleted or given a new password. Each session is a document orbit-api deletes, so a revoked token is refused on the next request, not at its expiry. A forged or altered token is refused before any lookup.
  • Permissions are checked where the data is. orbit-api resolves the user's role on every request and refuses a route whose permission it lacks with 403 forbidden. The Deck hides what a role cannot use, but hiding is a courtesy: a hand-written request meets the same check. A route with no permission of its own still needs a session, including one added later that nobody remembered to gate. Nocturne's tools carry the asking user's session, so the assistant cannot read what that person could not.
  • Cross-site requests. SameSite=Lax keeps the cookie off cross-site POST, PUT, PATCH and DELETE requests, and web refuses any of those methods whose Sec-Fetch-Site or Origin says another site, sign-in and sign-out included: a login forged from another page would put a victim in the attacker's account. A request with neither header is not a browser, and passes to the checks behind it. Workload writes still need the operator token on web's hop on top of workloads.write (Addendum v0.4), so a hijacked session alone cannot change a cluster.
  • Links do not act. A shared Orbit SQL link fills the editor and the connection and waits for you to press Run. The pod terminal opens a shell on its own only when a click inside the Deck led to it (Sec-Fetch-Site: same-origin); a link from another site, a bookmark or a reload shows a button instead. A link cannot run a query or open a shell in your name.
  • The operator token stays out of the page. The Deck sends the typed token once to web's POST /api/operator, which answers with an HttpOnly, SameSite=Strict cookie (__Host-orbit_operator on https) holding an expiry and an HMAC keyed by the token, never the token. It lasts one hour, logout drops it, and rotating ORBIT_DECK_WRITE_TOKEN voids it. web accepts the cookie only on a request whose Sec-Fetch-Site or Origin proves it came from this console. Scripts keep sending X-Orbit-Operator-Token.
  • Sign-in resists guessing. Failures are counted per username (5 free, then a wait from 1 s doubling to 1 minute) and per client address (20 free, then up to 15 minutes) before any password is checked, on top of per-address request limits. Every sign-in derives the same PBKDF2 work whether the username exists or not, and the answer is the same, so neither the message nor its timing says which accounts exist. Passwords are stored as PBKDF2-HMAC-SHA256 verifiers at 600,000 iterations with a 16-byte salt, and a new one needs 12 characters or more.
  • The first account. ORBIT_ADMIN_USER with a verifier from a Secret, or a one-time setup code that exists only in the process's memory and its log. With ORBIT_DEMO_DATA=true, three accounts with a published password are created instead: never expose a demo-data install, and never carry its data directory into production, because those accounts outlive the demo flag.
  • Everything is recorded. Sign-ins and their failures, sign-outs, every change to users, roles, dashboards, alerts and workloads, and every permission refusal, with the actor, the client address, the user agent and the request id, fsynced before the answer goes out. The client address is the one the ingress controller sees: behind a cloud load balancer or a CDN it is theirs until the edge passes the client on, which is a controller-wide setting (audit.md → "How the client IP is determined"). A failed sign-in never records the typed username unless it exists, so a password typed into the wrong field stays out of the trail. See audit.md.
  • The data directory is a secret. It holds password verifiers, the session key when ORBIT_SESSION_SECRET is not set, live session ids, and an audit trail full of IP addresses. Encrypt its volume, restrict its backups like the credentials Secret, and set ORBIT_SESSION_SECRET so a copy of the volume cannot sign sessions.

Browser hardening

In production every response from web carries a Content-Security-Policy without unsafe-inline or unsafe-eval for scripts: a page rendered per request allows its scripts and styles by a fresh nonce, a prerendered page by the hashes of its inline blocks. It also sets frame-ancestors 'none', base-uri 'self', form-action 'self' and object-src 'none', plus Strict-Transport-Security: max-age=31536000; includeSubDomains (browsers apply it over https only), X-Frame-Options: DENY, X-Content-Type-Options: nosniff, Referrer-Policy: strict-origin-when-cross-origin, a Permissions-Policy that turns off the camera, microphone, location, payments, USB, serial, HID, Bluetooth and screen capture, and Cross-Origin-Opener-Policy, -Embedder-Policy and -Resource-Policy. The production build ships no source maps, and /api/v1/version answers only a signed-in user. A JSON answer under /api carries Content-Disposition: attachment, so opening one as a page saves it instead of rendering it. A method nothing here answers (PROPFIND, MKCOL) gets 405; Node refuses TRACE and TRACK before the Deck reads them, with a 500 or 400 that echoes nothing. Signing out removes what the browser kept for you: SQL drafts and history, Explore and ad hoc queries, recent pages and local saved views. Display preferences stay. Markdown the Deck renders from text it did not write (a Nocturne answer, which carries what the logs it read said, and a dashboard's text panel, which an import brings in) shows HTML as text, drops javascript: and data: links, and shows an image as its alt text: no answer or dashboard can make a reader's browser fetch an address it chose, with or without the policy above.

Supply chain

  • Distroless runtime, always. web runs on gcr.io/distroless/nodejs26-debian13:nonroot; orbit-api, nocturne and every other Rust image run on gcr.io/distroless/cc-debian13:nonroot. No shell, no package manager, no curl in any final image layer. Health checks that would otherwise need curl ship a small std-only Rust binary built in the same builder stage instead (see install/docker-compose.md).
  • Base images are pinned by tag and digest. A tag alone is a moving target; bumping one without the other defeats the point of pinning at all.
  • Scanned before published. On main and tags, CI builds each image for amd64 and arm64 into a registry that lives only on the runner, runs trivy on both platforms there, and copies that same digest to GHCR only after the scan passes. An image with a HIGH or CRITICAL finding never reaches the registry clusters pull from.
  • No ignore file, ever. There is no .trivyignore, no .snyk, and no scanner ignore file of any kind anywhere in this repository, and the project's own stance is that there must never be one: a finding gets fixed at the base image or the dependency, or it stays red until it can be. If you fork this, do not add one under deadline pressure. Fix the base image or the dependency, or file the CVE with its advisory ID and treat it as a known, tracked exception with an owner and a date, not a suppressed scanner.
  • Non-root, capabilities dropped, read-only root filesystem, everywhere. runAsNonRoot: true, runAsUser/Group: 65532, allowPrivilegeEscalation: false, capabilities.drop: [ALL] with nothing added back, readOnlyRootFilesystem: true, seccompProfile: RuntimeDefault, set identically in docker-compose.yml (so a problem surfaces on a laptop, not first in a cluster) and in every Kubernetes manifest. Every writable path a container needs is an explicit, size-limited emptyDir; there is no implicit writable filesystem to fall back on.
  • Pod Security Admission. The chart renders the namespace itself with pod-security.kubernetes.io/enforce: restricted, so the cluster's own admission controller, and not only this repository's manifests, refuses a pod that violates the hardening above.
  • Immutable rollbacks in production. values-prod.yaml sets requireDigest: true; the chart refuses to render at all if any enabled component's image.digest is empty, naming the exact --set-string that fixes it. A tag can point at different bytes tomorrow than it does today; a digest cannot, which is the only reason helm rollback means anything. See install/helm.md.
  • deploy/check_hardening.py is a gate. It parses both the rendered Helm output and the plain manifests (they can drift independently) and asserts every item above, per pod, plus: requests and limits set on every container, liveness on /healthz, readiness on /readyz, container port matching CONTRACT.md, a PDB and topologySpreadConstraints on every multi-replica Deployment (and, checked just as strictly, absent on any single-replica one, because a PDB on one replica blocks node drains forever), every emptyDir sized, and no Secret carrying a committed value.

Kubescape controls the node agents cannot pass

We scan the rendered chart with Kubescape (frameworks NSA, MITRE, CIS v1.10 and CIS v1.12) beside the Kubecost cost-analyzer chart. On the release namespace every control passes. The controls below fail on the node namespace and its two DaemonSets, because a node agent has to read the node to do its job. Each row names the narrowest setting the chart uses; deploy/check_hardening.py refuses anything broader.

ControlWhereWhy it failsNarrowest setting
C-0193, C-0197 to C-0204 (CIS 5.2.2 to 5.2.12)Namespace <release>-nodePod Security baseline refuses every hostPath volume, read-only ones included, so the namespace enforces privileged.warn and audit stay restricted: a pod there that asks for more than these two DaemonSets shows up in kubectl warnings and the audit log. The release namespace enforces restricted.
C-0048 (hostPath mount)orbit-node, orbit-probeorbit-node reads /proc/1/net, /proc/1/mountinfo, /sys/class/net, /sys/devices, /run/udev/data and /etc/os-release, plus /var/log/pods with telemetry.logs, and the directory of each telemetry.logs.files source. orbit-probe reads /sys/kernel/btf and /sys/fs/cgroup.Each host path read-only, never the node's /. A telemetry.logs.files directory is refused when it is a system directory, sits under one or holds one (/etc, /var/lib/kubelet, /var/log/pods ...). orbit-node keeps its log positions in an emptyDir and runs without hostNetwork or hostPID.
C-0211 (supplementalGroups)orbit-node with telemetry.logsThe kubelet writes /var/log/pods with mode 0750 and each log file with 0640, owned by root's group.uid 65534 with every capability dropped; group 0 joins only when telemetry.logs is on. Root or DAC_READ_SEARCH would read more than the logs.
C-0038, C-0275 (host PID)orbit-probeIt maps each socket to its process, cgroup and pod through /proc/<pid>.hostPID only: no hostNetwork, no hostIPC.
C-0046 (capabilities), C-0013 and C-0211 (root)orbit-probeLoading eBPF programs takes BPF and PERFMON; reading other processes' memory maps and binaries takes SYS_PTRACE and DAC_READ_SEARCH. Kubernetes sets no ambient capabilities, so only uid 0 holds them.uid 0 with those four added and every other capability dropped (SYS_RESOURCE too with apm.autoInstrument.lowKernel, for kernels older than Linux 5.11), read-only root, seccomp RuntimeDefault, and not privileged unless you set apm.autoInstrument.privileged for Bottlerocket's SELinux.

Turn off telemetry.nodeExporter and apm.autoInstrument and the node namespace with every row above goes away, along with node metrics, container logs and eBPF spans.

What this product does not currently specify

A reviewer will find these gaps faster than a vendor questionnaire will, so this page lists them:

  • No mTLS or encryption-in-transit between the four components is specified in CONTRACT.md. TLS terminates at your ingress (install/helm.md's ingress.tls); traffic between web, orbit-api, and nocturne inside the cluster is plain HTTP, secured by network segmentation (NetworkPolicy, above), not by encryption. If your environment requires pod-to-pod encryption, that's a service-mesh decision (Linkerd, Istio, Cilium's transparent encryption) layered on top. Nothing here precludes it, and nothing here provides it.
  • Kubernetes Secrets are base64, not encryption. The chart and the plain manifests both treat a Secret as the correct interface (referenced, never a chart default; see configuration.md), but encryption at rest for Secrets is a property of your cluster (KMS-backed EncryptionConfiguration, or an external secret manager) that this repository does not configure for you.
  • Nothing in this repository generates an SBOM or provenance attestation today. If your procurement process requires one, treat that as a gap to close in your build pipeline, not a claim this documentation is making on the product's behalf.
  • OIDC mode's issuer and audience are your responsibility to operate. This product verifies a JWT; it does not run an identity provider. As built, oidc refuses to start: accounts are local, with no single sign-on, no second factor and no SCIM.
  • The audit trail is not tamper-evident. It is plain files on orbit-api's volume. Ship the audit log lines to a store its administrators cannot rewrite if the trail has to stand as evidence.
  • One replica holds identity. orbit-api runs one pod over a single-writer store; a node loss is a gap in sign-in until the pod is back.

Checklist: what an enterprise security reviewer will ask

QuestionAnswer
Multi-tenant data plane?No: self-hosted, one install per customer account, nothing shared.
Does any component call home / phone telemetry to the vendor?No. See architecture.md → "What leaves your account: nothing."
How is the API authenticated?Bearer token (constant-time compare) between components, mandatory by default, and a signed, revocable user session on top of it for every route but the probes and sign-in; see "What the auth middleware does" and "Sessions, roles and the audit trail" above.
Per-user accounts and least privilege?Yes: local users, three built-in roles and custom roles over a closed set of twelve permissions, enforced by orbit-api on every route. See identity.md.
Is there an audit trail?Yes: every sign-in, change and refusal, with actor, address and request id, queryable and exportable to CSV, kept ORBIT_AUDIT_RETENTION (default 90 days). Not tamper-evident by itself. See audit.md.
Single sign-on, MFA?Not yet. ORBIT_AUTH_MODE=oidc refuses to start rather than ship half a verifier.
CSRF?SameSite=Lax session cookie, HttpOnly, and a same-origin check on every mutating request at web, sign-in included.
Can auth be disabled?Only in a mode that refuses to start against non-demo data, with a WARN logged on every boot while it's on.
Is the credential ever exposed to the browser?No: server-side proxy in web; see architecture.md.
Is the AI/LLM endpoint internet-reachable?No ingress rule exists for nocturne at all; it's reached only via orbit-api's internal reverse proxy.
Is /metrics public?No: separate listener, no ingress route, and (in Kubernetes) unreachable until you name your monitoring namespace explicitly.
Are containers running as root?No: non-root UID 65532, all capabilities dropped, read-only root filesystem, everywhere.
Are images scanned, and are findings suppressed?Scanned per your own CI policy; this repository ships no ignore file for any scanner, by rule.
Are third-party base images pinned reproducibly?Yes: tag and digest together.
Is encryption in transit enforced end-to-end, including inside the cluster?TLS at the ingress; internal traffic is plain HTTP secured by NetworkPolicy, not encryption. See the gap noted above.
Is encryption at rest for secrets configured?Kubernetes Secret as the interface; at-rest encryption is your cluster's responsibility (KMS-backed encryption or an external secret manager).
Is there rate limiting against abuse?Yes: a per-IP limiter on every route on both backend services (Addendum v0.2), with contact additionally capped at 5 requests/minute, burst 3. The IP is the socket peer unless the request carries orbit-api's own bearer (only web holds it, and web forwards X-Forwarded-For only as an edge proxy wrote it, WEB_TRUST_PROXY) or the peer is on ORBIT_TRUSTED_PROXIES / NOCTURNE_TRUSTED_PROXIES; then it is the nearest untrusted hop in X-Forwarded-For, never a header a caller can forge on its own. See configuration.md, audit.md and api.md.
What happens on a dependency CVE?Fixed at the source (upgrade, patch, or replacement); there is no suppression mechanism in this repository to fall back on.

Where to go next

  • The exact auth failure behavior in context, and how to generate the tokens this page assumes you already have: configuration.md.
  • Every route these controls sit in front of, and the closed error-code set: api.md.
  • What a NetworkPolicy that applies but is not enforced looks like when you hit it in practice: troubleshooting.md.