No two organisations sign in the same way. One has a directory, one has a single sign-on provider, one wants hardware keys for administrators and access tokens for its build servers. A platform that hard-wires one of those forces everyone else to work around it.
FFS does not hard-wire any of them. Identity is three plugin interfaces, and the core only enforces what they decide.
Three questions, three plugins
| Interface | The question it answers | Typical implementations |
|---|---|---|
| Authenticator | Who is this? — check a credential, name a person | password accounts, access tokens, SSH keys, a directory, a single sign-on provider |
| Authorizer | May they do this? — decide on a page, a service, an action | roles and groups, a rule file, a company's own policy service |
| Login provider | How do they sign in? — the screen and the flow | a username / password form, a redirect to an identity provider, a second factor |
Each is chosen per page and per service. An intranet page can ask for a directory login while the build server's API on the same site accepts only access tokens — and a public page asks for nothing at all.
What ships today
- Password accounts — kept in a file the site owns, hashed with PBKDF2-SHA256, with named password rules (length, character classes, a dictionary of banned passwords, password history) applied wherever a password is set.
- Roles — roles and their permissions, assigned to people and groups.
- A login page — name and password, password reset by e-mail, "remember me", and registration closed, open or on request.
- An account page — where people manage their own name, e-mail addresses and how times are shown.
- Directory sign-in — the same login page, checking passwords against OpenLDAP or Active Directory, with the directory's groups.
- Kerberos sign-in — people signed in to Windows or the company realm sign in with one click, no password typed.
- Single sign-on — a button for any OpenID Connect provider: Keycloak, Entra ID, Google, GitLab, Okta.
- A second factor — an authenticator app (TOTP) or a security key or passkey (WebAuthn), required for everyone or for chosen groups, with one-time recovery codes.
- FFS's own identity provider — one sign-in for all your servers; see below.
Applications add their own through the same interfaces. Depotify, for example, adds personal access tokens for build servers and SSH keys for git clients — without a change to FFS.
One sign-in for many servers
An organisation rarely runs one server. Git lives on one machine, the package registries on another, an internal portal on a third. With the identity provider one FFS site signs people in for all of them — with whatever it was configured with: passwords, the directory, Kerberos or an upstream provider, plus the second factor.
- One token for programs, on every server. git, pip, dnf, curl and CI jobs use a central token.
ffs-logingets one: it shows a code, the person approves it in a browser where they are already signed in, and the token is stored for git's credential helper and~/.netrc. Nobody copies a token by hand. - SSH keys, added once. A key added at the identity provider works on every server's SSH port; removed there, it stops everywhere.
- Leaving reaches everyone. Signing out, a closed account, a revoked token or a removed key reaches every server at once, over a signed event channel — not at the next poll.
- No shared secrets between servers. Each FFS server holds its own certificate in the FFS chain of trust. Servers of the same company recognise each other by it; nothing needs to be registered or copied between them.
- Partner organisations. Two companies, each with its own identity provider, can trust each other's by certificate. People from the partner are mapped with this site's own rules — groups included.
- When the provider is down. Servers rely only on short-lived answers the provider signed, so a revocation is never delayed by more than their lifetime. A sign-in that cannot be checked is answered "try again shortly", never counted as a wrong password.
- People see their own. A page at the provider lists their tokens and SSH keys for every server, to revoke or remove.
Accounts, not just logins
A person may sign in more than one way — a password today, a company login tomorrow, a token for the build server. FFS keeps one account per person with any number of identities from different providers, so permissions, ownership and the audit trail follow the person, not the credential.
- Registration is a site's choice: closed, open after e-mail verification, or on request — the applicant verifies the address and an administrator approves.
- What happens to an unknown identity — one the directory knows but the site does not — is chosen per provider: refuse it, create an account, or ask an administrator.
- Closing an account invalidates its sign-ins, tokens and keys at once, but keeps the record: what the person created and what the audit log says about them stay, and their name is never handed to someone else.
- Signed-in people get an account page of their own: the name shown, the contact address, how times are displayed, and their sign-in methods.
Built to be adapted
Because each interface is small and stable, adapting FFS to an organisation is a plugin, not a fork:
- SAML — for identity providers that speak only SAML.
- External authorization — ask your own policy or entitlement service before an action is allowed.
- Your own sign-in method — a smart card, a national e-ID, an in-house token service.
Directory sign-in, Kerberos, single sign-on, second factors and the identity provider above were built exactly this way — as plugins, without a change to the interfaces. The next one is what the interfaces were designed for, and FEDEM develops it to order. A custom identity plugin is signed and verified like every other plugin, so it inherits the chain of trust on day one.
