Exclusive Access · Invitation Only

Security

What Stratum protects on its own, what you need to set up yourself, and what it deliberately does not protect against. The last part matters most: assuming a boundary exists where it does not is how people get hurt.

Protected without any setup

You do not need to configure any of this.

  • The management API is closed until you open it. It will not serve requests without a token, and there is no insecure fallback.
  • The API is encrypted. There is no unencrypted way in.
  • Repeated failed sign-ins are locked out, and an attacker cannot turn that lockout into a way of denying access to a legitimate user. A user name that fails five times waits before its next attempt, whether the account exists or not, so the wait reveals nothing.
  • Administrators use a second factor. Every account that holds Administrator must sign in with an authenticator app as well as its password (or through an identity provider), and sets one up at its first sign-in. Passwords are never shown, logged or stored: only a one-way check value is kept. See Accounts and Access Control.
  • Customer accounts need a second factor too. A customer portal account has an authenticator app, which the customer sets up at first sign-in, and ten recovery codes, each usable once. Its password is kept only as a one-way check, and its sessions end when its password or its authenticator app changes. An account holds at most four sessions: a fifth sign-in closes the one used least recently. See Customer portal accounts.
  • What a sign-in records. The node records the address it sees. Behind a front that is the front's address, unless you list the front (see Listing the front). Then it records each customer's own address, and the sign-in limits count each customer separately. The audit log names an account by its id, never by its login, and never records a password or a code.
  • Sensitive changes need your password again. Giving someone more power, changing a password or a second factor, or changing how people sign in asks the person making it to confirm their password, and an API token can never make such a change.
  • What an account may not see, it cannot find. An object outside an account's permissions answers exactly as one that does not exist.
  • Taking access away works at once. A disabled account or a revoked token stops working immediately, and the sessions and machine consoles it opened end with it — on every member of a cluster within seconds.
  • Configuration and licenses are verified before they are trusted. Anything altered in transit, or issued by anyone other than Cenvero, is refused — checked on the node itself, so it works offline.
  • Workloads cannot impersonate each other. Traffic from a workload must match what that workload is registered as. This is enforced on every packet.
  • Changes made outside Stratum are undone. If something alters an interface Stratum manages, it is put back.
  • Cluster members prove who they are to each other. Each member has its own identity, issued by its cluster; the cluster port admits no one else but a new node bringing a valid join code, and a removed member is refused from that moment. A request passed from one member to another carries who asked and from which address, never their key or password, and the member that does the work decides for itself what that account or token may do, and applies its own licence, tenant rules and address allowlist. A join code works once and expires. See Clustering Overview.
  • The node's records are private. Other local accounts and plugins cannot read the node's records, and cannot list /var/lib/cenvero-str/, the directory that holds them. A node installed with an earlier version is corrected when the agent starts.
  • A cluster member's address is never blocked. Intrusion detection and per-source connection limits never block it, so forged traffic cannot cut the members off from each other, and a rule from rules add or rules batch, or a firewall deny rule, that would block it is refused. A block shared with a cluster ends at the same moment on every member. See Clustering Overview.
  • Webhooks and alert email go only where the node checked. A delivery connects directly to the address the node vetted, never through a proxy set in its environment, so a name that is pointed elsewhere afterwards cannot redirect it. A node whose only way out is a proxy therefore cannot deliver webhooks or alert email.
  • What the host trusts is changed only on the host. Installing a certificate and its chain, which also go into the host's own trust store, and making a signing request offline are root's commands on the server itself: no API route, web console page or other cluster member can reach them.
  • The node's own certificate goes on a web frontend only on the command line. No role can choose it for a layer-7 frontend over the API or in the web console, or change the pools such a frontend routes to: root does that with cenvero-str-ctl. Removing such a frontend stays open to those who may change the load balancers, and frees its pools; before root makes the frontend again, it checks the backends of the pools it routes to. See Load Balancer.
  • A change that would cut the server off is refused. A static route, a policy rule, a masquerade range, a floating address or an interface address that would take the way the server is reached — its own network, its gateway, its addresses, and on a cluster the other members' addresses — is refused; so is a port forward of a port the server itself serves, and taking apart a bond or bridge the server is reached through. See Networking Overview.
  • The system log is shown with its secrets removed. Reading it from the web console or the API never shows a token, password or key, anything in PEM form, the private part of an address, the directories of a host path, or the accounts a line's details name, and leaves out the lines the audit log keeps.
  • Every change is recorded. The node's audit log records every change made through the API, the web console, the tenant portal or the command line — who, from where, on what, and whether it succeeded, failed or was refused — along with sign-ins and consoles opened. No record holds a key, token or password. Each record is linked to the one before it by a fingerprint, so a record altered or removed afterwards is detected by cenvero-str-ctl audit verify. See Monitoring.

Your checklist

None of this happens on its own.

Deny by default in the firewall. Until you do, traffic matching no rule is allowed. See Firewall.

Treat the API token as a credential. It grants full control of the node. Create it at install time, keep it out of shell history and version control, and replace it if it may have been exposed.

Give people their own accounts. Make a personal account for everyone who manages your servers, give each the narrowest role that does their job, and use the node's API token only to set things up. Make at least two Administrators, and require a second factor of anyone else who can change things (user set <id> --require-tfa, or a custom role that requires one). Give each script its own API token with only the permissions it needs, and an expiry. See Accounts and Access Control.

Limit who can reach the API. It can be restricted to specific addresses (api_allowed_ips). An API reachable from the internet is a mistake even with a strong token — keep it on your management network. In a cluster, each member applies its own list to your address, also when you reach it through another member, and refuses what it does not accept. So a member with a narrower list stays protected, but give every member a list that includes the addresses you manage the cluster from. A member that refuses your address still shows its machines and networks in the other members' lists; see Clustering Overview.

Put each customer portal behind a front you run, and list it. A customer reaches a portal at a name you choose, through an HTTPS front that holds a certificate their browser trusts. List the front's address in portal_trusted_fronts on each node, so the node records each customer's own address and not the front's. See Putting the portal behind your own address.

Keep the management network private. Stratum assumes only your operators can reach it. In a cluster, open the cluster port (TCP 7073) between the members only.

Protect every cluster member as the whole cluster. Accounts, API tokens and operator keys are shared by every member and work on each of them; a member's own API token reaches every member through it; and root on any member can administer the cluster, including who may do what. Keep join codes like passwords until they are used, and revoke the ones you no longer need.

Keep nodes updated. Updates are pulled, never pushed, so a node nobody updates stays vulnerable. See Upgrades.

Back up /etc/cenvero-str/ and /var/lib/cenvero-str/. They are what a node needs to come back as itself.

Available if you want it

  • Stricter interface protection. By default an unauthorised change to a managed interface is undone shortly after it happens. On a suitably configured kernel it can be refused outright instead. Off unless you enable it.
  • Client certificates on the gRPC health-check port, in addition to a token.
  • Intrusion detection, surfacing scanning and flooding patterns. Off by default.

What is not protected

Someone with root on the node. The design protects against what arrives over the network, not against an administrator of the machine itself. Anyone with root can stop or replace what is running there. Verification exists to stop a remote attacker substituting configuration or licenses — it does not, and cannot, constrain someone who already owns the box. Root on the command line is always an Administrator: it can reset anyone's password or second factor, and in a cluster it can do so for every member. The secrets that check passwords, tokens and second factors are kept on every member, readable only by root.

Interface protection is repair, not prevention. By default a change is detected and undone, so there is a window where it applied. Treat it as tamper-evidence with automatic repair rather than a lock.

The audit log is tamper-evident, not tamper-proof. Removing or changing a record breaks its chain, and audit verify says where. But someone with root on the node could rewrite the whole log consistently. Keep the record number and hash that audit verify prints somewhere off the node and check them later (audit verify --checkpoint <number>:<hash>), or export the log off the node on a schedule.

Plugins are trusted code. Signing proves a plugin is genuinely the one its developer published and has not been altered since. That is authenticity, not a verdict on what the code does. A plugin runs sandboxed as an unprivileged user, which limits what it can reach, but a sandbox is a mitigation, not a guarantee against a hostile plugin. Only install plugins from sources you trust. See Installing Plugins.

The sign-in page is public. The brand, the sign-in notice and the support line are shown to anyone who reaches the sign-in page, before they sign in: never put anything private in them.

The front for a customer's portal. The front ends the customer's connection and reads what they send, passwords and codes included, before it passes them on. Run it on infrastructure you control, and do not log request bodies.

A frozen license is not a security control. It blocks changes; traffic keeps flowing. To take a node out of service, isolate it on the network.

A cluster trusts each of its members. Every member holds what it takes to admit new members, and every account of the cluster, so one compromised member puts the whole cluster at risk until it is removed and the cluster's certificate authority is replaced (below).

A member cut off from the others keeps the access rules it last knew. People can still sign in there, and a token revoked elsewhere in the meantime stops working there only once the member is back in touch, within seconds of the network returning. See In a cluster.

Existing connections survive a rule change. Tightening a rule governs new connections; conversations already open continue until they end. If you are cutting traffic off during an incident, clear them explicitly — see Firewall.

If a node may be compromised

  1. Isolate it on the network, upstream — not using the node's own firewall.
  2. Remove the node from your account: Nodes, then More › Remove node on its row. At its next licence check it stops being licensed, which stops it making changes; it does not stop traffic.
  3. If it is a cluster member, take it out of the cluster from another member: cenvero-str-ctl cluster remove <node id> (the others refuse it at once, and this works whatever the licences say), revoke the join codes that have not been used (cluster join-code list, then cluster join-code revoke <id>), and replace the cluster's certificate authority with cluster ca rotate.
  4. Collect evidence before restarting anything. Logs are in /var/log/cenvero-str/. Export the audit log (cenvero-str-ctl audit export --output audit.jsonl), copy it off the node, and run cenvero-str-ctl audit verify, with the checkpoint you kept if you have one. Restarting is the first instinct and it can cost you the answer.
  5. Replace the API token and any tenant keys the node held. Revoke the API tokens and operator keys that were used from it or stored on it (cenvero-str-ctl token revoke <id>), and change the passwords of the accounts that signed in there.
  6. Rebuild rather than clean up. If root was obtained, reinstall.

Reporting a security issue

Report it to us privately through the contact form rather than publicly, with enough detail to reproduce it.

Where to go next

↓ This page as JSON ↓ All documentation as JSON