Keyreeve
Self-hosted SSH and Kubernetes access control for compliance-driven Linux environments. People sign in with your identity provider and work from a desktop app, the browser or their own ssh; Keyreeve issues short-lived certificates instead of keys, records every session to storage you own, and keeps break-glass access for when all else fails.
From CAD 0.00 per year
Plans and pricing
Home
0.00 CAD — Yearly
Standard
1200.00 CAD — Yearly
Enterprise
5400.00 CAD — Yearly
Custom
Contact us for a quote.
Features
- Sign in with the identity provider you already have — Any OIDC provider, several at once. Groups from the token or from Microsoft Graph map onto Keyreeve roles, so joiners and leavers are handled where they already are.
- Short-lived certificates instead of SSH keys — Keyreeve runs its own SSH certificate authority. A session gets a certificate that expires; no keys are distributed to hosts and none are left behind on laptops.
- Rules decide who reaches which host, as whom — Access rules bind identity-provider groups to hosts and host groups, the local account to use, and the sudo commands allowed there. Host, group and fleet settings layer in that order.
- Sudo grants checked against GTFOBins — When a rule grants a command through sudo, Keyreeve says whether that command is a known way to get a root shell, before you save the rule.
- Every session recorded on the host — A setgid wrapper records the session, and a guard ends any login whose processes escape it. Chunks are signed by the agent and hash-chained, so a missing piece shows.
- Recordings stored in your own S3 — Encrypted at rest under per-recording keys, searchable full-text, with retention and legal hold. Object lock and versioning on your bucket are yours to set.
- Watching a recording is itself an audited act — An auditor role of its own, an optional two-person approval before playback, and an audit entry naming who watched what and when.
- Passwords redacted before they are stored — Pattern redaction runs on the host, on session output and on command arguments, replacing matches with keyed tags that can still be correlated but not read.
- A terminal in the browser — Relayed through the agent's outbound tunnel, covered by the app session, with a files tab, pop-out and full screen. No inbound SSH port and no VPN.
- A desktop app built for daily work — macOS, Windows and Linux. Tabs on every host and pod you can reach, a files panel, port forwards to hosts and pods, several accounts and servers side by side, login scripts, and your own SSH connections in an encrypted vault.
- File transfer scanned on the way in — SFTP over the same login path. With scanning turned on, uploads stream through ClamAV into a temporary file that is only put in place once it is clean. Path, size, hashes and verdict go into the recording.
- Kubernetes access under the same rules — Clusters enrol like hosts. Keyreeve authorises each API request before it reaches the API server, re-checks long-running ones, and records exec and attach sessions.
- A kubectl shell that leaves nothing behind — A pod created for one session: no service account, non-root, read-only root filesystem, capabilities dropped, kept off the cluster network, and deleted when the session ends.
- Kubernetes in the desktop app — The clusters, namespaces and pods your rules allow, in the same window as your hosts: pod logs, recorded pod shells, a kubectl shell and port forwards to pods.
- Kubernetes writes recorded with secrets masked — A successful write is recorded with its body. Secret values are never stored, container environment values are masked, and anything credential-shaped is masked wherever it appears.
- Break-glass that works when nothing else does — Named accounts, per-account source networks, key or password. A break-glass login never contacts Keyreeve, so it works with the servers offline, and every use is audited and can notify the email addresses and webhook you choose.
- Temporary access people can ask for — Request access for a window, route it to the right approvers, and have it expire by itself, ending the sessions it opened when it does.
- AI-assisted troubleshooting, under your control — Over MCP, an AI agent can run diagnostics in a terminal or Kubernetes shell you've opened, once you allow it there. Off by default, allowed per host, cluster and rule, with every AI keystroke marked in the recording and the audit log.
- FIPS 140-3 in every binary — Server, agents, CLI and desktop all run inside Go's validated cryptographic module and refuse to start outside it. ECDSA P-384 CA and P-256 user keys.
- Clustering and high availability — Several Keyreeve servers as one cluster, every one a full peer, over mutual TLS with self-renewing certificates. Agents and the desktop app fail over between servers; set up from the web interface.
- SIEM export — Ship the audit log to Splunk, Sentinel, Elastic or anything else over syslog with TLS, or by webhook.
- Priority support with an SLA — Named response targets rather than best effort, and implementation help when you need it.
About Keyreeve
Keyreeve puts one audited gateway in front of the Linux hosts and Kubernetes clusters you already run. People sign in with your identity provider; Keyreeve issues a short-lived SSH certificate instead of handing out keys, decides what each person may do on each host, and records what happens. The server, the agents and the recordings all stay in your environment.
How it works
- Run the server - one container in your own environment, with SurrealDB and Valkey beside it.
- Install the agent - one command per host from the Hosts page. Agents dial out to the server over mutual TLS, so hosts need no inbound port opened for Keyreeve.
- Write access rules - who reaches which hosts, as which local account, with which sudo rights, driven by the groups that already exist in your identity provider.
- Connect - from the Keyreeve desktop app, the browser terminal, or your own ssh client through the Keyreeve gateway.
The desktop app: where the work happens
Most people spend their day in the Keyreeve desktop app for macOS, Windows and Linux, downloaded straight from your Keyreeve server. It signs in with your identity provider and puts every host and Kubernetes cluster a person may reach in one window, with every session going through Keyreeve and recorded exactly as the server does.
- Tabs on every host you can reach, found by name, friendly name, tag or group, with keyboard shortcuts for switching between them, and your own names, colours and favourites for hosts.
- Several accounts side by side - everyday and privileged identities, or several Keyreeve servers - each with its own tabs. With several servers, new tabs spread over the healthy ones and a dropped tab reconnects through another.
- A files panel beside the terminal to browse, upload and download on the host you're working on.
- Port forwards to a database, dashboard or internal web app, through a host like
ssh -Lor straight to a pod likekubectl port-forward, checked against the host's settings and audited. - Kubernetes in the same window: the clusters, namespaces and pods your rules allow, pod logs (live, or the previous container's after a crash), recorded pod shells and the kubectl shell.
- Login scripts that answer the prompts you see on every connect, for you or the whole team.
- Your own SSH connections to machines outside Keyreeve, in an encrypted vault behind a master password that also protects the app's own sign-in key.
Certificates, not keys
Keyreeve runs its own SSH certificate authority. Signing in gets a certificate that expires after a few hours (8 by default), not a key that lives on a laptop until somebody remembers to remove it. Hosts trust the CA, so there is no authorized_keys file to distribute, rotate or clean up, and access ends when the rule says it ends rather than when an offboarding ticket is closed.
Host certificates are issued from the same CA, so people stop being trained to accept unknown host fingerprints.
Every session recorded, and the recording protected
Sessions are recorded on the host by a wrapper the user cannot step around: a session whose processes escape the recorder is ended. Recordings stream to the server as they happen, each chunk signed by the agent and chained to the one before it, so a gap is visible rather than silent.
What is stored is treated as sensitive in its own right. Passwords and other patterns are redacted before the recording leaves the host, recordings and program-log arguments are encrypted at rest under per-recording keys, and viewing them is a role of its own - with an optional two-person approval and an audit entry for every playback. Retention and legal hold are policy, not a cron job somebody wrote.
Kubernetes, under the same rules
A cluster is enrolled the way a host is, with an agent that runs inside it. Keyreeve decides each API request before it reaches the API server, re-checks long-running ones, and records exec and attach sessions the same way it records SSH. Writes are recorded with their contents - with Secrets, environment values and anything credential-shaped masked before storage.
People who would rather type kubectl get a kubectl shell: a pod created for that session alone, with no service account, a read-only root filesystem and a network policy that keeps it off the cluster network, deleted when the session ends - and recorded from end to end.
AI that speeds up troubleshooting, under your control
Much of an incident is gathering facts: services and logs, disk and memory, and in Kubernetes, pod status, events, restarts and container logs. Keyreeve lets an AI agent such as Claude do that legwork in an engineer's own terminal, over MCP. The engineer opens a terminal on the host or pod, switches on Let AI use this terminal, and describes the problem; the agent runs the diagnostic commands, reads the output, follows up and suggests a fix while the engineer watches the same terminal and keeps the final say. It works on hosts and in Kubernetes shells alike, so it can follow a problem from a failing pod to the server behind it - without copying output back and forth and without handing out credentials. Engineers spend far less time on routine diagnostics.
The controls are layered, and each one has to say yes: AI is off by default and allowed per host, host group or cluster; access rules decide which people may use it; the engineer allows it terminal by terminal, and the policy is checked again on every AI request. The agent has no keys of its own - it acts through the engineer's session with a personal AI token that expires and can be revoked - and every AI keystroke is marked in the recording and the audit log.
Break-glass: a way in, whatever happens
Keyreeve locks SSH down. Hosts accept Keyreeve certificates only - authorized_keys files, passwords and keyboard-interactive logins are turned off - so the way in is through your identity provider and the access rules. The one deliberate exception is the break-glass accounts you configure, so you can always reach your own machines, even if every Keyreeve server is offline or hosts and people can't reach it.
- Which accounts: named accounts only, never root, chosen per host or host group.
- From where: each account limited to the source networks you allow.
- How: key, password, or both. Keyreeve can manage the credentials (sealed at rest, generated for you, rotated), or leave the host's own credentials in place.
- Independent of Keyreeve: a break-glass login never contacts the Keyreeve servers. With the host's own credentials it works even with the Keyreeve agent stopped. Break-glass is never blocked by licensing, and when a host refuses logins because it can't record them, break-glass is the exception that still gets in.
- Never silent: every break-glass login is reported by the host and written to the audit log at error severity, and each policy can notify the email addresses and webhook you choose, so you know whenever someone goes around Keyreeve. For a shared account, Keyreeve reports which key was used, so you can tell who it was. An account used by automation can be kept in the log without the alerts.
Logins with the host's own credentials go around Keyreeve entirely - that is what makes them work when everything else is down - so they aren't recorded; sshd's log and Keyreeve's login index still show every one.
FIPS 140-3, not as an option
Every Keyreeve binary runs inside Go's FIPS 140-3 validated cryptographic module, and refuses to run outside it - the server, the agents, the CLI and the desktop application. The certificate authority is ECDSA P-384, user keys are P-256, and local passwords are PBKDF2-HMAC-SHA-512. There is no switch to turn it off, because an access gateway that can be quietly downgraded is not one you can attest to.
High availability (Enterprise)
Keyreeve is the way into your fleet, so it shouldn't be a single point of failure. Several Keyreeve servers run as one cluster in which every server is a full peer: each signs people in, issues certificates, relays terminals and takes recordings, and a change made on any of them reaches the others within moments. The cluster is set up from the web interface with one-time join tokens; servers talk only over mutual TLS with certificates from the cluster's own CA, which renew themselves. Host agents know every server and move to another if their home server goes away; the desktop app checks each server every 15 seconds and reconnects a dropped tab through another. Servers can be upgraded one at a time while the cluster keeps running.
Yours to run
Keyreeve is self-hosted by design: the server, the agents, the certificate authority and the recordings are in your environment, on your storage, under your retention policy. It is built for networks that do not reach the internet freely - restricted, segmented and air-gapped environments where a hosted control plane is not an option.
Frequently asked questions
What can I use without paying?
The Home plan: free, up to two named users, for personal and home-lab use only. It is not permitted for business, commercial or revenue-generating use. There is no free tier for companies — Standard starts at 10 users and Enterprise at 25.
A server with no licence at all allows one named user, so you can evaluate Keyreeve and so an administrator can always sign in to install a licence. That is a fallback, not a plan: using it in a business needs a licence.
What counts as a named user?
A person with access through Keyreeve. Accounts whose only role is auditor are free and do not count toward the total - an auditor who also holds any other role is counted as a normal user. AI-assisted access through MCP acts under the person's own account and permissions, so it is never counted separately.
How many hosts and clusters can I connect?
As many as you like. Hosts and Kubernetes clusters are unlimited on every plan; only people are counted.
What happens if the licence expires or goes over its user count?
Work in progress keeps working. Sessions that are open stay open, and break-glass access is never blocked by licensing - an access gateway must not lock you out of your own infrastructure during an incident. New sessions, new enrolments and new users are refused until the licence is renewed or extended, and administrators are warned well before that point.
Is high availability included?
Clustering several Keyreeve servers for high availability is an Enterprise feature. A single server runs every other feature on both plans.
Can I ship the audit log to my SIEM?
Audit shipping to Splunk, Sentinel, Elastic and anything else that takes syslog over TLS or a webhook is an Enterprise feature.
What support is included?
Enterprise includes priority support with an SLA. Standard includes the documentation and no support; paid support for Standard is available as an add-on, quoted per customer — tell us about your environment on the Contact sales page and we will come back with a number.
Do you discount larger deployments, or quote custom terms?
Yes. Larger user counts are discounted automatically when you buy, and the price list shows what each band costs. Beyond that — the largest deployments, multi-year commitments, bespoke support, or anything that does not fit the published plans — ask on the Contact sales page and we will quote it.
What do I need to run Keyreeve?
A container host for the Keyreeve server with SurrealDB and Valkey beside it, an S3-compatible bucket for session recordings, and the agent package on each Linux host. Kubernetes clusters run a small in-cluster agent instead. Everything is in your environment.
Do I have to open ports on my hosts?
No. Agents dial out to the Keyreeve server over mutual TLS and open a tunnel when a session is wanted, so hosts need no inbound port for Keyreeve and no VPN to reach them.
Which identity providers work?
Any OIDC provider, and several at once. Groups are read from the token, or looked up through Microsoft Graph where you would rather search for them, and mapped onto Keyreeve roles.
Will it fight with my existing sshd configuration?
Keyreeve's settings live only in its own files under sshd_config.d, never in your main sshd_config. A setting chooses whether the Keyreeve agent writes them or an external configuration tool does. Removing the agent package takes those settings back out, so uninstalling never strands sshd on a missing helper.
Where do session recordings live, and who can watch them?
In your own S3-compatible bucket, encrypted at rest under per-recording keys. Watching one needs the auditor role, can require a second person's approval, and is itself written to the audit log.
Can we still reach our hosts if Keyreeve is down?
Yes, through break-glass. You choose which accounts are break-glass accounts, where they may log in from, and with a key, a password or both. A break-glass login never contacts the Keyreeve servers, so it works even if every server is offline or unreachable, and with the host's own credentials it works with the Keyreeve agent stopped too. Every use is reported, audited and can notify the email addresses and webhook you choose. With several Keyreeve servers (Enterprise), losing one doesn't stop anyone: hosts and the desktop app move to another.
What if somebody goes around Keyreeve?
That is the question worth asking of any gateway. Hosts accept Keyreeve certificates only, so the one way around Keyreeve is the break-glass accounts you configure - and every break-glass login is audited and can notify the email addresses and webhook on its policy. On a host, a kernel-audit backstop and the session guard catch processes that escape the recorder. For Kubernetes, Keyreeve reports role bindings made by hand in the cluster, and can take the cluster's own audit log so that reaching the API server another way is reported rather than invisible - alongside, not instead of, the audit log you already collect.
Is FIPS mode something I switch on?
No - every Keyreeve binary runs inside Go's FIPS 140-3 validated cryptographic module and refuses to start outside it. There is no setting to weaken it, which is what makes it something you can attest to.

