Skip to main content
Lumovi never gives anyone more than their own permissions: every request reaches the API server as the person who made it, and the API server applies their RBAC. What Lumovi itself is trusted with depends on how people sign in. Besides, the chart lets it get and patch a few objects of its own in its namespace, and no others: the Secret that keeps sessions across restarts, and the ConfigMaps of people’s AI rules and of access. The key that Secret is sealed with isn’t among them: Kubernetes gives it to Lumovi’s pod. A fleet needs single sign-on or a proxy, and Lumovi also holds a way into each of its clusters: see A fleet.

Impersonation

With single sign-on that doesn’t pass people’s own tokens on, or behind a proxy, Lumovi’s service account may impersonate anyone. Whoever can exec into its pod, or read its service account’s token, can then act as anyone in the cluster. Treat Lumovi like any other component with cluster-wide power:
  • Keep it in a namespace of its own, one only cluster administrators can exec into, read or change Secrets in, or change workloads in.
  • Use prefixes (auth.usernamePrefix and auth.groupsPrefix), so no name or group from a provider or proxy is one of yours by accident.
  • Behind a proxy, let nothing else reach Lumovi. It trusts the proxy’s headers completely. The chart’s NetworkPolicy is always on behind a proxy, and the chart won’t install without the proxy’s pods in networkPolicy.from: check that your cluster’s network plugin enforces NetworkPolicies (flannel alone doesn’t).
Lumovi never acts as one of Kubernetes’ own users or groups (system:…), whatever a provider or proxy says. It leaves out groups that start with system:, and refuses users whose names (with their prefix) do. When the API server trusts your provider, pass people’s tokens on instead: Lumovi then needs no permissions at all.

A fleet

A fleet’s Lumovi acts as the people who sign in, in every one of its clusters, and holds a way into each:
  • Whoever controls Lumovi controls every cluster. Anyone who can exec into its pod, read its kubeconfig, its Secrets or its settings, or change them, can act as anyone in all of them. Run it where only the administrators of every one of its clusters can, as you would the most trusted of them.
  • Give it credentials that may only impersonate, as members and agents have, rather than administrators’. Lumovi then can’t do more in a cluster than the people who sign in.
  • groups hides a cluster, but doesn’t protect it. It decides who sees a cluster in Lumovi, besides Lumovi’s admins, who see every cluster, and whose AI assistants can act there. What people may do there is still up to that cluster’s RBAC. For a private cluster behind an agent, where Lumovi is the only way in, that means every one of Lumovi’s admins can reach its API server: see Admins see every cluster.
  • Prefixes apply in each cluster: the server’s, or the cluster’s own. Set them so no name or group from your provider or proxy is one of any cluster’s own by accident.
  • People’s own tokens go only where you say: to clusters with forwardToken: true, when LUMOVI_OIDC_FORWARD_TOKEN is set. Lumovi keeps them, and their refresh tokens, in memory, and sealed for a restart.
  • Reading Secrets: with fleet.secrets, Lumovi’s service account may list every Secret in the namespaces you name, not only those that describe clusters.
  • Writing Secrets, with fleet.addFromPage only: admins add clusters on the Fleet page, kept as Secrets in a namespace of their own (fleet.addNamespace), and Lumovi’s service account may list, create and delete Secrets there alone, never in its own namespace. It deletes only the Secrets it made, by their UID, and reads there only those. Keep that namespace to the administrators of every cluster: whoever reads its Secrets has the clusters’ credentials. Off, Lumovi writes no Secrets. See From the Fleet page.

Agents

  • Nothing in a private cluster listens. Its agent dials out to Lumovi’s api/agent, and has no Service.
  • Lumovi checks every agent. It knows each by its name and the SHA-256 of its token, and needs nothing else to: api/agent takes no sign-in, and an unknown name or token gets 401, which Lumovi’s log records (An agent was refused: …).
  • The agent can’t read what it relays. TLS runs from Lumovi to the API server, inside its connection, checked against the certificate authority Lumovi trusts for that cluster, as kubernetes.default.svc: the one caSha256 names, or the one the agent first sent, kept and recorded. Another is refused until an admin trusts it, with the SHA-256 they take from the cluster itself, never from what the agent says.
  • Agents connect over https only, but on Lumovi’s own computer: their tokens travel with them.
  • Its token alone doesn’t stand for its cluster, once its certificate authority is trusted. Before that, at first contact, whoever connects first with the token decides which one Lumovi trusts, and could stand in for the cluster with a server of their own, and see what people send it, their own tokens too with forwardToken. Give caSha256, so first contact decides nothing; keep the token in a Secret in that cluster, and give Lumovi only its SHA-256. Without it, check the one first trusted with Check it…, and trust a new one only when you know the cluster’s changed, with its SHA-256 from the cluster: see Trusting it, by its SHA-256.
  • A takeover shows. When another agent connects with the same name and token, the first one stops, and says so in its log.
  • A join token works once, for an hour, for a cluster connected from the Fleet page. It’s shown once, and Lumovi keeps only its SHA-256. The agent exchanges it for a token of its own, kept in its cluster, so the join token, as shown and copied, is no use afterwards. Whoever uses it first is the cluster Lumovi trusts, so only admins see the cluster until one of them checks its certificate authority. Only admins make one, and only where Lumovi keeps its state. Whoever can write where that state is kept could put back a copy from before the token was used, and join with it again, if they had it, within its hour, on a replica that hadn’t seen it used.
  • Helm reaches an agent’s cluster through a port on 127.0.0.1, inside Lumovi’s container, open only while helm runs.

Sessions and cookies

  • The browser holds only a random ID for its session, 32 bytes, in the lumovi-session cookie. The token or the identity it stands for stays in Lumovi.
  • Sessions outlive a restart. Lumovi knows each by its cookie’s SHA-256 hash, and keeps it so: see Across restarts. The audit log names a session by a hash of it too. Each replica knows the sessions started on it, so more than one needs sticky sessions, and auth.keepSessions.
  • Sessions last 12 hours unless auth.sessionHours says otherwise, at most a week. People signing out end their session in every tab.
  • Single sign-on uses the authorization code flow with PKCE. The state, PKCE verifier and nonce stay in the lumovi-sign-in cookie for at most 10 minutes, signed with a key Lumovi makes when it starts, with when it expires. The way back from the provider works once, and only until then: the cookie brought back again, or later, gets “That sign-in took too long, or started in another browser. Try again.” A sign-in that’s under way when Lumovi restarts has to be tried again. The ID token’s signature is checked against the provider’s keys: RSA and ECDSA signatures only, so unsigned tokens and shared-secret signatures are refused. Its issuer, audience, expiry and nonce are checked against what Lumovi expects, allowing a minute for clocks that disagree.
  • Only Lumovi’s own pages can sign in with a token, sign out, or connect. Browsers name the page’s origin on those requests and on the WebSocket. Lumovi takes them only when that origin’s host is the one in the request’s Host header, or the origin is url’s. A request that names no origin is refused. Behind a proxy that changes the Host header, set url to the address people open, or signing in and connecting fail.
Lumovi sets three cookies, all SameSite=Lax and limited to the base path: The first two are HttpOnly, so scripts can’t read them, and Secure when url starts with https: or the proxy in front sends X-Forwarded-Proto: https. The page sets lumovi-theme itself, and it holds nothing else.

Requests from Lumovi’s own page

A session’s cookie is sent with every request its browser makes to Lumovi, whatever page made it. So Lumovi acts for someone signed in only on requests that say they come from Lumovi’s own page:
  • Where the browser sends Sec-Fetch-Site as the person signs in, every later request of that session must send it as same-origin. Any other is refused with a 403, This request didn’t say it came from Lumovi’s own page (Sec-Fetch-Site), so Lumovi didn’t act on it., and nothing of the session changes. The sign-in page then says so. A browser that doesn’t send the header as the person signs in isn’t held to it.
  • A session whose browser stops sending it is said once in Lumovi’s log, since something between the browser and Lumovi may be removing it.
  • Behind a sign-in proxy, Lumovi holds every request to it only where auth.proxy.secFetchSite says the proxy passes the header through. See The headers.
  • Off (auth.secFetchSite: off), or where a session isn’t held to it, plugins that run code aren’t offered.
The live connection a page keeps open is checked by its origin instead, as above.

Across restarts

A restart, as an upgrade does, signs nobody out. Lumovi keeps what it needs for that, as it happens:
  • Sessions, each by its cookie’s SHA-256 hash, with whose it is, their groups, and when it ends. The cookie itself is its browser’s alone.
  • The AI assistants people allowed: whose, their names, and when each was last used, and their access and refresh tokens, by their SHA-256 hash. Refresh tokens used already are remembered for a day, so a copy that comes back is still caught.
  • Each cluster’s settings: whether it’s read-only, who made it so and when, where its metrics come from, and where its node shells run, by the cluster’s name, each with the count of the write that last set it, so that a change made outside Lumovi shows.
  • People’s pins and saved views: each person’s pinned objects and saved views, for each cluster, by who signed in.
  • A person’s own token, with token sign-in, or single sign-on that passes it on, and with single sign-on its refresh token, sealed with a key derived (HKDF) from the session’s cookie, and bound to that session. Only the browser has the cookie, so what’s kept holds nobody’s token. After a restart, a session’s token is unsealed when its browser next asks Lumovi anything, and its assistants wait for that: see After a restart.
Each entry is sealed (AES-256-GCM) with the state’s key, and filed under an HMAC of what it is, which its seal is bound to. The key is kept apart from what it seals: Lumovi writes the state about 50 ms after something changes, and as it stops. A change made in the moment before Lumovi dies, or while it’s stopping, can be missing after the restart. For a person’s token that was renewed just then, with a provider that refuses a refresh token once it’s used, it means that person signs in again after the restart. What mustn’t come back is kept before it’s answered: a sign-out, and an assistant let go or signed out. When that can’t be kept, Lumovi says so instead of saying it’s done: see When it can’t be kept. Uninstalling the chart deletes both Secrets, and signs everyone out. With auth.keepSessions: false, nothing is kept but in memory, and a restart signs everyone out. Not kept: the changes assistants asked for that were waiting for an answer (the assistant asks again), sign-ins under way, and assistants’ connections, which they open again by themselves.
  • Reading the state shows nothing, not even who’s signed in: every entry is sealed, and named by an HMAC.
  • Writing it alone can’t make anyone’s session. An entry Lumovi didn’t seal with its key doesn’t open, nor does one changed, or moved to another’s place: Lumovi leaves those as they are, unused, until 15 minutes pass with none of them added or gone, then lets them go. Anything there not even shaped like an entry goes at once: 3 of what’s where Lumovi keeps its state isn’t Lumovi’s: let go. Writing it can take away what’s kept: that signs people out after the next restart. And an earlier copy of it, put back, brings back what ended since, a session signed out or an assistant let go, for whoever still has its cookie or token: so treat a copy of the state as you would the Secret. A cluster’s settings deleted, or an older copy of them put back, while Lumovi runs, are found within 10 seconds: Lumovi keeps each setting as whichever copy set it last, read-only if either has it, records it, and shows its admins. Changed while no replica runs, they’re taken as found. See Changed outside Lumovi.
  • Only where the key is kept apart. With the chart, the key is in a Secret of its own, which Lumovi’s Role doesn’t name: Lumovi may get and patch the state’s Secret alone, and whoever can write the state can’t make or reseal an entry without the key. Without Kubernetes, state.key is beside state.json, both Lumovi’s user’s: whoever can write state.json as that user can usually read state.key too, and make any entry, a session as anyone, or a cluster’s settings. Keep that folder Lumovi’s alone, or give LUMOVI_STATE_KEY from somewhere its user’s files aren’t.
  • Give each install its own key. An entry is sealed, and named, with the key alone, with nothing of the install it came from: two Lumovis with the same key open each other’s entries, so one copied from one’s state to the other’s, a session or a cluster’s settings, opens there too, and a cluster’s setting counting above the one there passes as Lumovi’s own. Don’t share auth.stateKeySecret, or LUMOVI_STATE_KEY, between installs.
  • The state and its key together are as good as being an admin. Whoever can write the state, and read its key (the key Secret, or LUMOVI_STATE_KEY in Lumovi’s pod), can make a session for anyone. Keep Lumovi’s namespace admin-only, as for its pod, and watch for controllers there that sync Secrets into it, like External Secrets or a GitOps tool.
  • Changing the key, or losing it, signs everyone out. What was sealed with the old one doesn’t open, and the log says, as Lumovi starts: 12 of what Lumovi kept doesn’t open with its key (it changed, they were, or another replica uses another): left as they are, unused, until they’ve been so for 15 minutes, then let go. A replica still on the old key, during a rollout, keeps its own while it adds new ones (as people sign in), so they go 15 minutes after the last was added, and a restart doesn’t put that off. Until then, going back to the old key opens them again. Don’t run replicas on two keys for longer than a rollout: each lets the other key’s entries go once 15 minutes pass with none added.
  • To make sure a leaked cookie or token can’t come back, change the key. Signing it out, or letting its assistant go, ends it, but an earlier copy of the state, put back, would bring it back. A new key ends everything sealed with the old one, and signs everyone out; within 15 minutes of the last replica on the old key stopping, the state no longer holds it. A new key can’t reach a backup of the state, or a copy someone read before: with the old key, those still open. With the chart, delete the <release>-state-key Secret, and run helm upgrade: it makes a new one, and Lumovi restarts with it. With auth.stateKeySecret, put a new key in your Secret, and run helm upgrade. Where the chart is rendered without the cluster, as Argo CD does, Lumovi doesn’t see the new key until it restarts: kubectl rollout restart --namespace lumovi deployment/lumovi.
  • After a leaked key, change it, as above. The key alone doesn’t hold people’s own tokens: what a session passes on to the cluster, and with single sign-on the refresh token that renews it, is sealed with a key only its cookie gives. But where it leaked with Lumovi’s pod, read or entered, whoever had it could read what the pod holds for live sessions too: revoke people’s own Kubernetes tokens, and the provider’s refresh tokens.

When it can’t be kept

When Lumovi can’t write the state, its log says why, once: Lumovi can’t keep who’s signed in (…): if it restarts now, what changed since is lost. It tries again every 5 seconds, and says Lumovi keeps who’s signed in again. once it can. Meanwhile:
  • Signing out ends the session on this server, and clears the browser’s cookie, but answers 503. The page goes on to the sign-in screen all the same, and says there: Lumovi couldn’t keep that you signed out (…): it’s over here, but a restart before it can would bring it back. The audit log records the sign-out as failed.
  • Letting an assistant go, on the Your assistants tab, says so: Claude Code is let go here, but Lumovi couldn’t keep it so (…): a restart before it can would bring it back. Try again shortly.
  • An assistant signing out, or one whose used refresh token comes back, gets 503 with temporarily_unavailable: Lumovi can’t keep what changed: try again shortly.
  • New tokens are still given. They work until a restart.
Past what a Secret holds, a megabyte, entries that don’t open with Lumovi’s key are left out first, then the sessions that end soonest, which sign in again after a restart: What Lumovi keeps would be more than the 1000 kB it may hold: 12 that don’t open with its key, and the 40 sessions that end soonest aren’t kept (they sign in again after a restart). What’s being let go is never refused.

AI assistants

Unless you turn them off, AI assistants connect at mcp below the base path, and sign in through Lumovi with OAuth: a person signs in to Lumovi, and allows each one on Lumovi’s own page. See AI assistants for your team for the details.
  • An assistant acts as the person who allowed it, with their RBAC and never more than their access, through Lumovi’s tools only, until they disconnect it or their session ends. Behind a proxy, as the proxy last named them, for as long as a session would last.
  • What it may do is its person’s to say, on their Permissions tab, within limits you set (assistants.rules): which namespaces it sees, whether its changes ask, whether it reads Secrets’ values, env values and logs. By default, its changes ask, it sees Secrets’ keys only, and env values that look sensitive are hidden. Deletions always ask. readOnly: true refuses every change, and so does a cluster its person made read-only. See What assistants may do.
  • People’s rules are kept in a ConfigMap in Lumovi’s namespace, which Lumovi may only read and update. Whoever may update ConfigMaps there can change anyone’s: keep that namespace to administrators. See Where people’s rules are kept.
  • Its tokens are kept like sessions, by their SHA-256 hash: access tokens for an hour, refresh tokens once each. A refresh token that comes back used already, within a day, ends what was allowed. They work only for assistants’ requests, not for pages, and carry no cookie to keep them to one pod: so the chart runs one replica while assistants are on, and refuses more.
  • Allowing an assistant hands someone’s access to it. Lumovi sends people back only to their own computer, an app, VS Code’s site, or sites you name in assistants.redirectHosts, so a link to its page made by someone else can’t send their access to a site of that person’s choosing. The page says where it goes back to, and asks people to allow only what they started.
Turn them off with assistants.enabled: false (LUMOVI_ASSISTANTS=off) if your team doesn’t use them.

The audit log

Lumovi records what everyone does through it, who signed in, and from where: see Audit log for your team.
  • People see their own events, and the auditors you name (audit.auditors) see everyone’s. Lumovi’s server decides, for the page, an object’s Audit tab, exports, and events as they happen.
  • Never values, tokens or manifests: a Secret’s keys, a change’s fields and a Helm release’s top-level value names, never what they’re set to.
  • The history is on a volume in Lumovi’s namespace, and each event is also on Lumovi’s output, and at a webhook if you give one.
  • Its chain has no key. Whoever can write the volume, or exec into Lumovi’s pod, can rewrite the history in a way the chain doesn’t show. Keep a copy they can’t reach, from Lumovi’s output or a webhook, and compare its newest event with the history’s: see What it proves.
  • One Lumovi keeps the history, holding a lock on its folder, so two can’t number events the same.
  • Anyone can try to sign in, and failed attempts are recorded up to 60 a minute, then counted. They’re for auditors alone, as is what couldn’t be kept or sent.

The page

Pages are served with a strict Content Security Policy (scripts only from Lumovi itself, and no embedded objects), and with headers that keep them out of other sites’ frames (X-Frame-Options: DENY), stop content-type sniffing, and send no referrers. A page shows no frame but one. Where LUMOVI_URL is set, that’s the box Lumovi keeps for a plugin’s code, at plugin-box/box.html below that address: a sandbox with no window of its own, whose code has no network and can’t reach Lumovi’s cookies or storage, and which only Lumovi’s page may show. Without LUMOVI_URL, a page shows no frame at all, and there’s no box.

Plugins’ code

Four of the plugins Lumovi comes with draw pages with their own code. On a server, that code runs in each person’s browser, in the box:
  • Its own frame, at an origin that’s nobody’s, sandboxed by attribute and by header, with a Content Security Policy that names no address it may reach, and the plugin’s code in a worker inside it. That code can’t reach Lumovi’s page, its cookies or storage, another plugin’s box, or the network. Its storage is its own, shared with nothing.
  • Handed only what its file says. Lumovi reads for it, on the server, as the person and within their access in Lumovi, and hands it only the fields its file names. Of a Secret, it’s handed nothing: Lumovi shows the keys its file names itself, on the person’s press. Each read is in the audit log, as plugin.read.
  • It draws with Lumovi’s parts, never its own markup, and can’t draw a dialog or reach Lumovi’s bar. Its page is framed as Lumovi’s are, and nothing on it says whose it is: Lumovi’s own More (⋯) and command palette say What Argo CD may do for Argo CD’s, and Lumovi’s change dialog names the plugin and its version.
  • It can’t change anything. It can propose a change, which Lumovi shows in its own dialog, and makes only once the person presses its button there, after Lumovi checks it again on the server: only the plugin’s own kinds, as its file says, at most 16 KiB, and never an object’s status.
  • Checked in each browser first. Before any plugin’s code is handed to a browser, Lumovi checks there that a box holds: a worker made exactly as a plugin’s is tries a fixed list of ways out to an address of the server’s, and the server, not the page, judges what arrived, against a control: a sealed frame of Lumovi’s own, with none of a plugin’s code in it, asks the same address in each shape a box’s request has, and the check passes only if all of them arrived. Silence fails. A browser that doesn’t pass is handed no plugin’s code, and the check is in the audit log, as plugin.box-check. Lumovi is tested with every release in the current Chrome, Firefox and Safari engines; in any browser, it checks that the box holds before it runs a plugin’s code, and runs none where it doesn’t.
  • Only where this server lets it: with LUMOVI_URL set, sessions held to Lumovi’s own page, and pluginCode on for that plugin. See Plugins’ code.
A plugin’s own server gets none of your credentials. Where a plugin may ask its tool’s server in the cluster, Lumovi asks it through the cluster’s API server, as you, and the API server takes your credentials off the request before it passes it on: the Authorization header, which carries a token from your kubeconfig, an exec plugin or single sign-on, once it has checked it; the Impersonate-* headers Lumovi sends to act as you, once it has applied them; and the headers an authenticating proxy in front of it adds. A client certificate belongs to the connection to the API server, which makes a connection of its own to the tool’s server, with none. So the tool’s server is sent the path, Accept: application/json, and the X-Forwarded-* headers the API server adds: not who you are, and nothing it could use as you. That’s Kubernetes’ API server’s own behaviour, in its source. What the box doesn’t do in a browser, said plainly:
  • A plugin’s box may share a process with Lumovi’s own page, and with other plugins’, in any browser. A browser keeps sites apart in processes, and a path of the server’s isn’t a site of its own. Reading across would need a fault in the browser’s engine, and a way to send what was read, which the box doesn’t give. A plugin’s worker lives only while its page is showing, and a Secret’s value is never handed to it. In the desktop app, each plugin’s box is a process of its own.
  • The box’s own page isn’t held against everything a browser does by itself. A link that hints at another address, or a navigation the browser then refuses, can make a browser look a name up, connect to it, or ask it for a page, and so can a WebRTC connection. Nothing Lumovi sends turns that off. As measured, Chrome’s engine does it for a hint to look a name up, to connect or to prerender, and for a navigation, a download link or a frame it then refuses. Firefox connects for a hint to connect. Safari’s engine connects for a hint to connect and for a link to a new window, and looks a name up for a hint to. WebRTC connects in all three. A plugin’s code can’t make any of them: it runs in a worker, with no page, and from there nothing gets out and no name is looked up. The box’s page runs only Lumovi’s own lines, and puts nothing of a plugin’s into its document. In the desktop app, these are held too.
  • Its processor and memory use can’t be measured in a browser. A plugin that keeps a core busy is stopped only by the limits on what it sends, and by going quiet. In Firefox and Safari, one that uses up memory on purpose can close the tab: it loses its own page, and gains nothing. In the desktop app, Lumovi measures each plugin’s process, and stops one over its memory, or over half a processor core for 30 seconds.
To run none of it, set pluginCode: false.

Charts and private networks

People choose where charts come from when they install or upgrade a Helm release, and Lumovi fetches them from inside the cluster’s network, where it can reach services they can’t, and cloud metadata endpoints. So it fetches charts only from public addresses. A repository, registry or chart URL whose host is, or resolves to, a private address is refused: An IPv6 address that carries an IPv4 one, NAT64’s 64:ff9b::/96 and 6to4’s 2002::/16, is judged by the IPv4 address it carries. While it refuses them, Lumovi resolves each name once, checks every address it gives, and connects to those addresses alone, for a repository’s index and charts, a registry’s, a chart at a URL, a chart’s icon, and each redirect, which it checks as it does the first. It fetches every chart itself and hands Helm the file, so Helm resolves no name: a chart from a repository is checked against the digest its index lists, and one whose index lists none is refused. Through a proxy (HTTPS_PROXY), the proxy resolves each name, so where it connects is the proxy’s to limit. If your charts live in your own network, such as a ChartMuseum or Harbor, allow private addresses with helm.allowPrivateCharts: true. Anyone signed in can then make Lumovi reach services inside the cluster’s network. Charts never come from files: there’s no computer of the user’s to read them from.

Shells on nodes

A shell on a node runs in a privileged pod Lumovi starts on that node, which shares the node’s process, network and IPC namespaces and mounts its root filesystem. Whoever opens one is root on the node, and can reach whatever it holds: the kubelet’s credentials, and the Secrets and volumes of every pod on it.
  • People’s own RBAC decides. Lumovi creates the pod, and opens the shell, as whoever is signed in, like everything else it does. They need create and get on pods, and create on pods/exec, in the node shells’ namespace (kube-system unless nodeShell.namespace says otherwise), and delete on pods for the pod to be deleted afterwards.
  • So does the namespace’s Pod Security. It must allow privileged pods. Anyone who can create pods in a namespace that does can be root on any node with kubectl alone, without Lumovi.
  • The namespace and image can be changed for a cluster, for everyone on the server, by Lumovi’s admins (or by anyone, where there are none). Each change is in the audit log, as node-shell.changed. The RBAC of whoever opens a shell, and that namespace’s Pod Security, apply there just the same.
  • The pod has no service account token, and Lumovi deletes it when the shell ends. One it can’t delete, because the person may not delete pods there, say, stops within 12 hours, its activeDeadlineSeconds.
To turn node shells off for everyone, set nodeShell.enabled: false (LUMOVI_NODE_SHELL=off): Lumovi’s server then refuses to start one, whatever people’s RBAC allows. readOnly: true turns them off too, with every other change. To keep people from being root on nodes at all, with or without Lumovi, let them create pods only in namespaces whose Pod Security doesn’t allow privileged pods.

Read-only

  • readOnly: true keeps everyone from changing anything through Lumovi, whatever their permissions.
  • A cluster can also be made read-only on the page, for everyone on the server and their AI assistants, by Lumovi’s admins, or by anyone where there are none. It says who made it so, and when, and the audit log records each switch, each attempt by someone who may not, as refused, and each change made outside Lumovi, where it’s kept, while Lumovi runs.
Lumovi’s server enforces it, not only the page: it refuses changes, shells (on nodes too), Helm changes and AI assistants’ changes while it’s on. See Read-only mode.

Access

Lumovi’s admins (access.admins) can let people do less through Lumovi than their RBAC allows: see Access for your team.
  • The server decides, before it acts as the person: changes, shells, node shells, logs, Secrets, Helm and AI assistants. A refusal says which grant or limit decided, and the audit log records it.
  • Never more than RBAC. Lumovi’s groups never reach the cluster: it acts as people with their own name and groups. Access only takes away.
  • Secrets’ values never leave the server for someone shown their keys only, nor do Helm releases’ values and manifests, which can hold them.
  • What admins set is kept in a ConfigMap in Lumovi’s namespace, which Lumovi may only read and update. Whoever may update ConfigMaps there can change who may do what: keep that namespace to administrators.
  • Behind an authenticating proxy, the proxy’s headers say who’s in which group, and so who’s an admin. Let nothing but the proxy reach Lumovi.

The pod

The chart runs Lumovi with these defaults, which you can tighten further but shouldn’t need to loosen:
Chart defaults
They meet Kubernetes’ restricted Pod Security Standard, and on OpenShift, its restricted-v2 security context constraint, which chooses the user and groups: see OpenShift. The image has Node.js, helm and Lumovi, no shell, and runs as a non-root user. It writes to /tmp, an emptyDir: helm’s caches, and for each run of helm a kubeconfig that acts as the person who asked (readable only by Lumovi, and removed after). With audit.persistence, it also writes the audit history to its volume, at /var/lib/lumovi/audit. Each image is attested, signed and has a bill of materials: see Check a release.

Behind a company’s proxy

Lumovi’s own connections can go through your company’s proxy, and trust the certificate authority it signs with: see Proxies and certificate authorities.
  • The proxy sees where Lumovi connects, and a proxy that inspects HTTPS sees what it sends: people’s requests to clusters, with their tokens when they sign in with them. Leave clusters out of inspection, with NO_PROXY or the proxy’s own rules. Lumovi reaches the cluster it runs in directly, always.
  • A certificate authority you give it is trusted for everything Lumovi connects to, as the system’s are, except a cluster whose kubeconfig names its own: the cluster’s connection trusts only that one, as the cluster Lumovi runs in trusts its service account’s.
  • A proxy’s credentials, in its URL, never appear in what Lumovi says: its log, or its errors. They’re in its environment, and in the kubeconfig each run of helm gets, as proxy-url, in a private temporary folder deleted after the run. With the chart, keep them in a Secret: see Credentials.

Hardening

What to set for a production installation, with a values file that has it all and a checklist: see Harden it for production.

Check a release

Every release’s installers, image and chart are built by Lumovi’s release workflow on GitHub, from the release’s commit on main:
  • Approved: a release made by Lumovi’s workflow is signed and published only after an account other than the one that started the run approves it. Until then a run has built, signed and pushed nothing.
  • Attested: each carries a signed build provenance attestation, which says where and from what it was built.
  • Signed with cosign, keyless, by the release workflow’s identity, and recorded in Sigstore’s public log: as a Sigstore bundle (an OCI referrer), and with the .sig tag older admission controllers look for. An admission controller can require it: see Require the signature.
  • Released immutably: once a release is published on GitHub, its installers and its tag can’t be changed or replaced, and gh release verify-asset checks that a file is the one it was published with. The image and the chart on ghcr.io aren’t part of the GitHub release: check them by their attestations and signatures, below.
  • With its plugins pinned: the release of Lumovi-plugins it’s built with is named in its notes, pinned by its SHA-256, and checked against that repository’s signature and attestation as it’s built: see Where they come from.
  • With bills of materials: the image’s JavaScript packages (the page, the server and an agent’s) in CycloneDX, attested with it and in the image as /app/licenses/sbom.cdx.json; and its system packages in SPDX, made as it’s built, helm’s Go modules among them.
With the GitHub CLI, and cosign:
The desktop app’s installers are attested the same way, each with its bill of materials, which lists the helm the app ships and the Go modules it’s built from: see Verify your download. SECURITY.md has the same commands.

Reporting a vulnerability

Please report vulnerabilities privately, by email to security@lumovi.dev or through GitHub security advisories, not in a public issue. See SECURITY.md.

Privacy and security

The security model of the desktop app, and what Lumovi connects to.

Helm values

Every setting the chart has.