Concepts
SSH access management: assigned, time-limited access to Linux servers
SSH access management for teams: assigned, time-limited and, where required, approved browser SSH sessions to Linux servers instead of shared keys.
Browse all docsManaging a team’s SSH access to Linux servers means answering three questions: who can sign in, for how long, and who closes the access when the work is done. A shared key or shared password leaves all three unanswered. Cerberus answers them at the assignment level, not in key files: it gives a specific person a time-limited and, when the policy requires it, approved browser session for a specific resource. In supported session types the target credential is not handed to the person who opens the session; the custody model is on the Credential custody page.
What happens when an SSH key or password is shared across a team?
A shared key or password detaches the sign-in from the person. Who got into the server depends on who holds the key file or the password, and the copies cannot be counted. When someone leaves the team or the job ends, closing access means changing the shared value and distributing the new one to everyone again.
With plain public keys, an end date depends on an option added to the key line. In OpenSSH, each line of the authorized_keys file is one public key, and a line can carry optional options. One of them, expiry-time, sets a time after which the key is not accepted; setting it on every key line on every server, and tracking it, is an administrator’s job. Certificate-based authentication is a separate OpenSSH mechanism and is not covered here (sshd(8), AUTHORIZED_KEYS FILE FORMAT).
The problem is not the SSH protocol. It is that access is not tied to a job or a person. As the team grows and temporary access multiplies (suppliers, on-call engineers), the answer to “who has which access open right now?” scatters.
Who closes a person’s SSH access when the work is done, and how?
With keys and passwords, an administrator does it by hand: delete the line on each relevant server, or change the shared value. A forgotten line is access that stays open and does not close by itself. A shared password is the same: anyone who knows it can still sign in after the job is done.
In Cerberus, closing happens at the assignment level. When an invite or member access is created, the timed access option sets an end time or a usage budget; when the time runs out, the person’s decision to start new sessions closes. If the work ends early or runs long, the change is made from the same details screen; the steps are in the Timed access guide. Because the end is set when access is granted, closing to new sessions does not depend on anyone remembering later.
How do shared keys, per-person keys, bastions and timed assignment differ?
The four approaches answer different questions.
| Approach | What it solves | What stays open |
|---|---|---|
| Shared key or password | Fast start | Who did what, and when the access ends |
| One key per person | Ties the sign-in to a person | An administrator tracks which key is valid on which server, and until when |
| Bastion host | Funnels sign-in through one network point | The per-person time limit and the access decision are managed separately |
| Timed assignment in Cerberus | Keeps person, resource, duration and, where required, approval in one decision | Network exposure and the credential on the target stay with the team that runs the deployment |
Cerberus does not claim to replace per-person keys or a bastion host; it adds the access decision on top of the existing setup. It asks a different question: which person can work on which resource, for how long. The Just-in-time access page explains the approach in detail.
How is an SSH session to a Linux server opened in Cerberus?
A Linux server connects without the Windows Agent (agentless). Today’s agent covers Windows machines only; there is no Linux agent. SSH is supported as a terminal work surface, and the resource is handled like this:
- The server is defined as a resource: display name, target, port, credential type, assignment and duration. The gateway verifies SSH access.
- An authorized role assigns the person to the resource and, where needed, sets the duration: an end time or a usage budget.
- The person sees only the resource assigned to them and sends a session request.
- If the active session policy requires it, an authorized user approves the request and sets the duration, or rejects it. The flow is on the session approvals page.
- If the decision is positive, the session opens in the browser through the session gateway.
Clipboard, file transfer and close behavior follow the session policy, and their scope varies by protocol and deployment. In the normal flow the person is not handed a raw IP, hostname or port. In supported session types the target credential is not given to them as text to copy either; responsibility for storing it varies by credential type and deployment. The model is described on the Credential custody page. For connection models and prerequisites, see Connecting resources without an agent.
What happens to an open SSH terminal when time runs out?
When time runs out, new sessions can no longer start; an authorized user ends an open SSH session separately. For SSH this means an open terminal may not close by itself at the end time, so when you set the duration you also decide who closes the session at that point. Removing the assignment and ending the session are not interchangeable. The full flow is on the Just-in-time access and Revocation and evidence pages.
What shows up in the records for an SSH session, and what does not?
The records show decisions and lifecycle:
- resource, protocol and assignment,
- the session request and decision result,
- session start, state changes and close,
- revocation and the close reason, where they apply.
Session recording (video and playback) is still in development; today the records cover decision and lifecycle events. For agentless resources, in-machine health signals and last-seen information are also limited. The records answer “who worked on which resource, under which decision” after the fact.
What does Cerberus not manage on a Linux server?
- SSH keys and the
authorized_keysfile. The flow described here does not require distributing keys to the person; keys on the server and theauthorized_keysfile stay with the team that runs the setup. - Linux local accounts. The managed local account model exists only for Windows resources.
- Server-side cleanup. Key or account preparation and cleanup on a Linux server stay with the team that runs the setup; without an agent, endpoint cleanup signals are limited.
- Network exposure. For a manually defined resource, whether port 22 is open, firewall rules and allowlists are the deployment’s responsibility. A private network applies only when a private network gateway or the Windows Agent connector is used.
Responsibility for existing keys and passwords on the server stays with the team that runs the deployment; rotating a value that has already leaked and removing the old one is separate work. What Cerberus adds is a time-limited, assigned session tied to decision records.
You can try the timed assignment, approval and revocation flow in the demo.