Security model
This page describes how we protect your data and your account: how requests are authenticated and authorized, how projects are kept apart, how secrets and stored data are handled, and what the audit log records. Read it before you decide what to put on Etorm. The things we do not do are listed together at the end, under Limits.
Authentication
Every request to the API is authenticated. The only things you can reach without a credential are the health probes and the version endpoint. A request with a missing, expired or revoked credential gets 401.
| Credential | Used by | Notes |
|---|---|---|
| API token | Service accounts, scripts, CI | Bearer secret etorm.<cluster>.<name>.<secret>. Expires (90 days by default, 365 at most below platform level). Tied to the identity it was issued for: recreating a service account under the same name does not revive old tokens. |
| Personal token | People using kubectl | Created by etorm login or the console for your own identity only. Same rights as you, nothing more. At most 20 per person. 30 days by default from the CLI, 365 at most. |
| Sign-in token (OIDC) | The console | One-hour access token from the sign-in service, signed with ES256. The API checks signature, issuer, audience and expiry. No refresh tokens: the sign-in session renews silently. |
Sign-in
- Sign-in is a separate service with its own database and keys. It never calls the API. The API only fetches its public keys.
- The flow is the OpenID Connect authorization code flow with PKCE, and every client must use S256. A code lives for 60 seconds and works once.
- We hash passwords with Argon2id. Failed attempts are rate limited per address and per email, and the responses do not reveal whether an email exists.
- Your identity is an opaque subject id, never your email. The API never uses an email address to decide what you may do.
Two-step verification
Each person can turn on two-step verification for themselves. It uses a six-digit code from an authenticator app (RFC 6238) and ten single-use recovery codes, which we store only as hashes. Once it is on, a correct password does not create a session until the code is accepted too, and each code works only once.
Turning it on or off ends your other sign-in sessions. Tokens that were already issued keep working until they expire. See Protect your account with two-step verification.
Getting credentials
People get credentials with Sign in and get kubectl access. Automation gets them with Automate with a service account. For anything that runs unattended, use a service account rather than a person's token.
Authorization
Everything is denied unless a role allows it.
- A Role lists rules (API groups, resources, verbs, optionally resource names). A RoleBinding grants a role to users, groups or service accounts.
- Scope inheritance. A binding in the platform cluster applies either everywhere or only to the projects (and objects) of one billing account. A binding inside a project applies to that project only. Grants and revocations take effect on the next request.
- Escalation limits. A role can never grant more than its author holds. To create a binding you need the right to grant its role. An invitation never gives more than its creator holds, and it stops working if the creator loses that authority.
- Last owner. Nobody below platform level can remove the last owner of a billing account.
- Quotas. People who are not platform operators have quotas on billing accounts, projects, service accounts, roles, bindings and tokens. That way one person cannot use up shared capacity.
- Check access. A
SubjectAccessReviewtells you whether a principal may do something. Owners and IAM admins can ask it about other people.
The built-in roles are listed in the Reference. The guide Give a teammate access shows the ones you will use most.
Tenancy
A project is a logical cluster with its own hostname. Its objects, roles, bindings, tokens and audit log are separate from every other project's. A caller who is not a member gets 403 and an empty list, never another tenant's data.
Private networks are isolated by tunnel id, so two projects can use the same addresses without seeing each other. Object storage uses separate keys for each bucket, as described below.
Secrets
- Tokens, invitation links, and database and broker passwords are shown once, in the response that creates them. We keep only a hash (SHA-256 for tokens, a SCRAM-SHA-256 verifier for database and broker passwords), so we cannot show them to you again. If you lose a secret, you replace it.
- Secrets are never written to logs, and the audit log never records request or response bodies.
- Network members bring their own WireGuard key, and Etorm only sees the public key.
- Load balancer and ingress objects never hold a private key in the API.
Encryption at rest
- Control-plane data. Everything the API stores, including objects, token hashes, audit entries and sign-in data, is sealed with XChaCha20-Poly1305 before it reaches a storage backend. Each record is bound to its position, so a truncated, reordered or replayed record fails authentication. Keys are derived from a master key that the engine never stores. We did not write our own cryptography: the primitives come from audited RustCrypto crates. The API and the sign-in service use different keys.
- Buckets. Every object is encrypted with keys derived for its bucket before it is stored, and the storage layer cannot see object names. Deleting a bucket makes its objects unreadable at once. A new bucket with the same name cannot read them either. See Store objects in a bucket and Storage reference.
- In transit. The API, console and storage are served over HTTPS.
Audit log
Every successful change, and every refusal of an authenticated caller, is recorded in the project where it happened. An entry holds the time, principal, verb, resource, name and result, and for a refusal the message as well. The log leaves out reads, request contents and unauthenticated requests.
Owners can read the log of their projects. It keeps the most recent 5 000 changes and 1 000 refusals, and nothing older than 90 days. See Give a teammate access and Find out why something stays Pending.
Network isolation basics
- A VPC is a private Ethernet segment. Members join through a WireGuard tunnel, and traffic on one VPC is never delivered to another.
- DHCP and DNS run inside the VPC, and you configure them with resources.
- A Compute process gets only the interfaces you give it, and its memory and processor time are bounded.
- IPv6 is the primary family, and nothing requires IPv4. See IPv6.
There are no firewall or security group resources. What can be reached inside a VPC depends on what you attach to it.
Limits
- There is no independent security review and no compliance certification.
- Etorm does not confirm email addresses, and there is no password reset.
- Two-step verification is each person's choice, and an account or project cannot require it. It uses codes from an authenticator app. There are no passkeys, SMS codes or push prompts.
- There is no sign-out-everywhere, account deletion or data export.
- A token has all of its owner's rights. There are no per-token scopes.
- An issued token ends only when it expires or is deleted, and a sign-in access token lives out its hour.
- Roles have no deny policies or conditions.
- The API itself has no rate limiting or request quotas.
- Control-plane keys cannot be rotated, and there is no external key management. Rolling the whole data set back to an older state is not detected.
- The audit log has no export, does not record reads, and does not say which token a person used.
- Object storage has no public buckets, signed URLs or versioning.