Security model
Who holds which key, what a breach of Zekno gives and does not give, and what Zekno does not protect against.
Pre-alpha and unaudited
The command-line tool, the runner and the core library have had internal reviews only. Do not use them for anything you could not afford to lose, and do not rely on them in production before an external audit.
This page is the short form. The full model, with the open-source boundary and the design rules, is in the repository's README.
The control plane, Zekno's hosted service, is not built yet. Today zekno
talks to the runner on your server directly, over SSH (see
A deploy today). What this page says about the control
plane is the design it will follow.
Who holds which key
| Part | Runs on | Keys it holds | Sees plaintext secrets | Can authorize a deploy |
|---|---|---|---|---|
Command-line tool (zekno) | A team member's machine | Team signing key | Yes | Yes |
| Control plane | Zekno's infrastructure | None | No | No |
| Runner | Your server | Server decryption key | Yes | No, it only verifies |
Where zekno keeps your key, and everything else, is on
What is kept where.
How a deploy works
- Encrypt.
zeknoencrypts each secret for your server's public key before anything leaves your machine. - Sign.
zeknosigns the deploy with your team's key. - Relay. The control plane stores the sealed, signed packet. It has no key to open it. Your server's runner pulls it over an outbound connection.
- Verify. The runner checks the signature before doing anything, and refuses a deploy your team did not sign.
- Run. The server decrypts with its own key and starts your containers.
Step 3 is the planned design. Today there is no relay: zekno sends the
sealed, signed packet to the runner over SSH.
Domains and HTTPS
Which domain reaches which app is part of the signed deploy. The runner sends a domain's requests only to the app whose signed deploy names it, and one app holds a domain on a server at a time. So the control plane, when it exists, could carry a deploy but never add, change or move a domain.
The server holds the TLS certificate and private key of each domain it serves, in the storage of its proxy. They are made on the server and never pass through your machine or Zekno. A released domain's certificate and key are deleted, also when the proxy is stopped or gone. The proxy ends TLS for every app with a domain on that server, so it handles their requests unencrypted, as any reverse proxy does. See What the server holds.
Apps on one server are not kept apart from each other. A deploy your team signed runs its Compose text with all that Docker allows on that server, so one app's deploy could read the TLS key of every domain there. Put on one server only apps whose deployers you trust with all of it.
What it protects against
| Scenario | Outcome | Why |
|---|---|---|
| An attacker copies the Zekno database | No secrets exposed | It holds only ciphertext |
| An attacker controls Zekno and pushes a deploy | Deploy rejected | Servers reject anything not signed by a team key |
| Zekno goes down | Apps keep running | Servers don't depend on it at runtime |
What it does not protect against
| Scenario | Why |
|---|---|
| A team member's machine is compromised | That machine holds a signing key |
| One of your servers is compromised | Secrets are plaintext in memory where the app runs, and the server holds the TLS keys of its domains |
| A Zekno release (the CLI or the runner) is tampered with | The client is the trust anchor. A server installs a runner only when it matches the checksum the command-line tool holds, recorded after a second build of the same source gave the same file. Runner releases are not signed |
How a runner release is checked, and the limits of that route, are on Your key and servers. The limits of this version are in Status and limits.
Metadata
The control plane, when it exists, will never see a secret's value. It will see:
- Server addresses and team membership
- App names, deploy numbers and times
- Each deploy's Compose text with its plain variables, and image names with their digests
- Each secret's name, version, size and who set it
With domains, building from source and health checks, it will also see:
- Domains
- Build recipes and their arguments, pre-deploy commands, health-check paths
- The size and fingerprint of each source pack: enough to confirm a guess of the exact source (a public repository at a known commit), not to read it
What is open
Everything that runs on your device or in your browser is open source under the MIT license. The control plane is closed because it is the hosted service Zekno sells; the design means you don't have to trust it.
Security problems are reported privately, never in public issues: see Reporting a vulnerability.