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:
- An unauthenticated caller on your network reading the estate or spending your
model budget. Round 1 of this product shipped both
orbit-apiandnocturnewith 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. - 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(seearchitecture.md) meansORBIT_AUTH_TOKENandNOCTURNE_AUTH_TOKENnever reach the browser at all, so there's nothing there to steal. - 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.
- 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).
staticmode (default):Authorization: Bearer <token>compared againstORBIT_AUTH_TOKEN/NOCTURNE_AUTH_TOKENusing 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.oidcmode: the bearer is parsed as a JWT, signature-verified (RS256/ES256) against the issuer's JWKS, and checked forexp,iss, andaud. Keys are cached with a bounded refresh rather than fetched per request.disabledmode: every request passes. The service logs aWARNnaming the risk on every startup (not only the first), and it refuses to start ifORBIT_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/versionrequires 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:
| Sender | It may speak for | The collector stores |
|---|---|---|
A pod in the release's node namespace or in apm.collector.orbit.trustedNamespaces | Other pods: orbit-node reads their log files, orbit-probe and OBI trace their sockets | The k8s.* attributes it sent, with what the pod watch adds where they are missing |
| Any other pod | Itself | Its 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 Kubernetes | Its 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 isGET /healthz: the proxy answers it itself, before auth and before locale routing. - Checked three times. Next.js skips
apps/web/src/proxy.tsfor a request whosex-prerender-revalidateheader 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, andapps/web/src/lib/prom-fetch.tsbefore its shared PromQL memo), so a page rendered without the credential carries no data.apps/web/next.config.tsalso redirects any request carrying that header to/, since nothing here revalidates on demand. - The verifier is stored, never the password.
WEB_AUTH_VERIFIERholdspbkdf2-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-filegenerates 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=basicwithWEB_AUTH_USERorWEB_AUTH_VERIFIERmissing or malformed returns503not_readyon every path, including/healthz, and logs oneweb 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
429rate_limitedwithRetry-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 get429withRetry-Afterset to the seconds left; 15 minutes without a miss forgets the count, and a correct sign-in clears it outright. The client is the lastX-Forwarded-Forhop (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 reachwebdirectly 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.yamlalso caps requests at the edge, per source IP, withnginx.ingress.kubernetes.io/limit-rps: "20"andnginx.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-nginxclears theAuthorizationheader 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 ifingress.basicAuth.enabledandcomponents.web.auth.enabledare both on, rather than shipping that config.deploy/check_hardening.pyasserts the refusal, and asserts that every install path (Helm defaults, dev, EKS, prod, and plainkubectl) giveswebWEB_AUTH_MODE=basicwith bothWEB_AUTH_USERandWEB_AUTH_VERIFIERsourced from the release Secret with nooptional.
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-apiissues an opaque token, a session id with an HMAC-SHA256 signature (keyORBIT_SESSION_SECRET, or 32 random bytes inORBIT_DATA_DIR/session.key).web's own sign-in route moves it into the cookie__Host-orbit_sessionon https (HttpOnly,SameSite=Lax,Path=/,Secure, noDomain, so a sibling subdomain can neither set nor read it) ororbit_sessionon plain http, and strips it from the body. On httpswebreads only the__Host-name.websends it on asX-Orbit-Sessionand never forwards the browser'sCookieheader, 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-apideletes, 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-apiresolves the user's role on every request and refuses a route whose permission it lacks with403 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=Laxkeeps the cookie off cross-sitePOST,PUT,PATCHandDELETErequests, andwebrefuses any of those methods whoseSec-Fetch-SiteorOriginsays 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 onweb's hop on top ofworkloads.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'sPOST /api/operator, which answers with anHttpOnly,SameSite=Strictcookie (__Host-orbit_operatoron https) holding an expiry and an HMAC keyed by the token, never the token. It lasts one hour, logout drops it, and rotatingORBIT_DECK_WRITE_TOKENvoids it.webaccepts the cookie only on a request whoseSec-Fetch-SiteorOriginproves it came from this console. Scripts keep sendingX-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_USERwith a verifier from a Secret, or a one-time setup code that exists only in the process's memory and its log. WithORBIT_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. Seeaudit.md. - The data directory is a secret. It holds password verifiers, the session key when
ORBIT_SESSION_SECRETis not set, live session ids, and an audit trail full of IP addresses. Encrypt its volume, restrict its backups like the credentials Secret, and setORBIT_SESSION_SECRETso 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.
webruns ongcr.io/distroless/nodejs26-debian13:nonroot;orbit-api,nocturneand every other Rust image run ongcr.io/distroless/cc-debian13:nonroot. No shell, no package manager, nocurlin any final image layer. Health checks that would otherwise needcurlship a small std-only Rust binary built in the same builder stage instead (seeinstall/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 indocker-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-limitedemptyDir; 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.yamlsetsrequireDigest: true; the chart refuses to render at all if any enabled component'simage.digestis empty, naming the exact--set-stringthat fixes it. A tag can point at different bytes tomorrow than it does today; a digest cannot, which is the only reasonhelm rollbackmeans anything. Seeinstall/helm.md. deploy/check_hardening.pyis 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 matchingCONTRACT.md, a PDB andtopologySpreadConstraintson 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), everyemptyDirsized, 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.
| Control | Where | Why it fails | Narrowest setting |
|---|---|---|---|
| C-0193, C-0197 to C-0204 (CIS 5.2.2 to 5.2.12) | Namespace <release>-node | Pod 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-probe | orbit-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.logs | The 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-probe | It 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-probe | Loading 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'singress.tls); traffic betweenweb,orbit-api, andnocturneinside 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-backedEncryptionConfiguration, 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,
oidcrefuses 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 theauditlog lines to a store its administrators cannot rewrite if the trail has to stand as evidence. - One replica holds identity.
orbit-apiruns 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
| Question | Answer |
|---|---|
| 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.