Skip to Content

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

PartRuns onKeys it holdsSees plaintext secretsCan authorize a deploy
Command-line tool (zekno)A team member's machineTeam signing keyYesYes
Control planeZekno's infrastructureNoneNoNo
RunnerYour serverServer decryption keyYesNo, it only verifies

Where zekno keeps your key, and everything else, is on What is kept where.

How a deploy works

  1. Encrypt. zekno encrypts each secret for your server's public key before anything leaves your machine.
  2. Sign. zekno signs the deploy with your team's key.
  3. 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.
  4. Verify. The runner checks the signature before doing anything, and refuses a deploy your team did not sign.
  5. 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

ScenarioOutcomeWhy
An attacker copies the Zekno databaseNo secrets exposedIt holds only ciphertext
An attacker controls Zekno and pushes a deployDeploy rejectedServers reject anything not signed by a team key
Zekno goes downApps keep runningServers don't depend on it at runtime

What it does not protect against

ScenarioWhy
A team member's machine is compromisedThat machine holds a signing key
One of your servers is compromisedSecrets 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 withThe 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.