Users and roles

Create accounts, decide what each role can do, and manage how people sign in.

How access works

Two things decide whether someone can do something. Their roles decide what they are capable of anywhere in DFIRe. The case team decides which cases that capability applies to. A user needs both.

A role is a named set of permissions. A user can hold several, and their permissions are the union of all of them. DFIRe never checks role membership directly. It checks individual permissions, which is why a role you build yourself works exactly like a shipped one.

On each case, a user is a lead investigator, an investigator or a viewer. Leads and investigators can write, viewers can only read. Permissions that grant access to every case, such as viewing or editing all cases, lift the team requirement for their holder.

The same permissions and case team rules decide on every interface, the REST API, the MCP server and Slack included. Closed and archived cases are write-protected there too, with the exceptions listed under Write Protection.

Two settings tabs cover this area. Settings → User Accounts holds the accounts, and a role with the user permissions reaches it. Settings → Access Roles holds the roles, and only a superuser opens it. For the permission model itself, see Application security.

The user list

Settings → User Accounts stacks two tables. Active accounts sit at the top. Disabled accounts appear below them, dimmed, and only when some exist. Deactivated people stay visible for review without crowding the working roster.

Both tables show the same columns: a profile picture, the name, username and email, and the assigned roles. Each row also carries the time since the last sign-in, which integrations the account links to, and how many API keys it holds. Three badges can appear on a row.

  • SSO names the identity provider the account authenticates against.
  • ROOT marks a superuser.
  • Service marks an API-key-only account that cannot sign in interactively.

Administrators who can change users also see an MFA column. See Seeing who has it.

Creating a user

Choose Add User in Settings → User Accounts and fill in the name, username, email and an initial password. Assign at least one access role. The Account Active toggle controls whether the account can sign in. If you use Slack, a superuser can also enter the person's Slack user ID here. Other administrators do not see the field, and the user links their own account with /dfire link.

SSO accounts create themselves. With SSO configured, an account appears on first sign-in, in the default role set for that provider. Review the role afterwards. Turn off Allow new user creation on the provider to stop this.

SSO takes over a matching local account. If someone with a local password account signs in through an identity provider that asserts their email as verified, DFIRe links the two. That account then loses password sign-in permanently, and DFIRe removes multi-factor authentication from it. A provider that does not assert email verification gets the sign-in refused instead of linked. An unverified email would otherwise let someone take over the account. See SSO troubleshooting.

The shipped roles

DFIRe ships four roles. Each builds on the one before it.

RoleWhat it can do
View OnlyReads the cases it is assigned to, all projects, the IOC registry and the Knowledge Base, and can export those cases. Changes nothing.
Standard userCreates cases, works the ones it leads or is assigned to, and claims cases that have no lead. Manages evidence, notes, timers and timelines on those cases, and reads analytics for them. Imports, publishes and revokes indicators in the IOC registry.
Team LeadEverything above, across every case including archived ones. Deletes cases and manual timeline entries, manages case teams and projects, and reads the whole audit log.
DFIRe AdminEverything above, plus subject-matter configuration and user accounts, including the roles each account holds.

DFIRe Admin covers playbooks, runbooks, item types, workflow steps, the incident lifecycle, categories and verdicts, reporting templates and compliance timers. It does not reach storage, licensing, backups, single sign-on, the integrations, webhooks and email notifiers, response actions, automation rules or role editing, which stay with superusers.

Treat these four as starting points. A superuser can change them, build new roles, or reorganize the permissions completely.

All four shipped roles can read playbook definitions and review history under Settings → Playbooks. The designer is read-only unless the user also has edit rights on that playbook.

Permissions worth knowing about

Most permissions follow the create, view, edit and delete pattern on an object. Five do not. Three cover the IOC registry, where curation is not ordinary editing. Two cover case export and import, which are decisions separate from reading and creating cases.

PermissionWhat it allows
core.manage_indicatorsPublishing, unpublishing, revoking and unrevoking indicators, one at a time or in bulk
core.export_indicatorsExporting registry and case indicators as CSV or STIX, alongside core.view_indicator
core.import_indicatorsImporting indicators in bulk from CSV, STIX or plain text
core.export_caseDownloading a case as JSON or CSV, alongside core.view_case
core.import_caseCreating or updating a case from an exported file, alongside core.add_case or core.change_case

An action that changes an existing record needs the permission to edit that record, also when the action adds something to it:

  • Report review (submitting a section for QA, approving it, returning it to draft, finalizing) and writing a section with AI need the permission to edit the investigation report.
  • Case to-dos and a playbook change need the permission to edit cases.
  • Runbooks on an evidence item need the permission to edit evidence.
  • Protecting, unprotecting and restoring Knowledge Base content needs the permission to edit that folder or page.
  • Enriching an indicator needs the permission to edit indicators. Splitting one into its parts needs create and edit.

Evidence links are the exception. Adding evidence items to an indicator in a case needs only core.add_caseindicatorassociation, also when the indicator is already in the case. A case import also needs core.add_indicator for its indicators section. Replacing the items needs core.change_caseindicatorassociation.

Sending an indicator to a webhook trigger needs core.view_indicator and core.export_indicators.

Some reads and imports need the permission of every record they touch:

  • Listing a case's indicators needs core.view_indicator and core.view_caseindicatorassociation. Exporting them also needs core.export_indicators.
  • Exporting a chain of custody needs core.view_legalentity, because its entries name the parties.
  • Reading an item's legal owner and primary user, and the legal entities that custody entries name, needs core.view_legalentity. Without it, DFIRe leaves them out.
  • Each part of a case needs its own view permission on every interface. The parts are notes, evidence items and their notes, custody records, attachments, timeline entries, indicators, CAN reports, the investigation report and compliance timers. A role without one reads the case without that part, in the case page, exports, the assistants, MCP, Slack and notifications. A timeline entry about a record it may not view shows only its type, time and author.
  • A CSV import into a case needs the permissions to create and to edit the records it brings. Its preview also needs the permission to view them.
  • Adding a value that the registry does not hold yet to a case needs core.add_indicator, in the web interface, the REST API and MCP.

The web interface offers a control when your role, your position on the team and the state of the case allow its operation. A rule about one record can still refuse the request, such as a phase change on an investigation-mode case. A part of a case that your role does not include shows a short notice in place of its list. What your role may add to that part stays. If your role may delete a case, an evidence item or a manual timeline entry but not edit it, the delete is in the edit dialog, with nothing else to change.

core.view_remotecase, shown as Remote cases, puts the cases received through Dashboard Sync on the Dashboard of a user who also has core.view_case. It covers every sending installation and adds no local cases. core.view_all_cases does not include it, and no shipped role has it. See Dashboard Sync.

core.change_userapikey lets its holder re-enable their own disabled API key, from a signed-in browser session. Everyone manages their own keys without it, and only a superuser manages another account's keys. See API access.

Evidence files use the ordinary four permissions on the evidence file object. A role without create can read a case's files but cannot upload. A role without view cannot download. Case assignment still applies on top. See Application security for what each one covers.

Editing roles

Settings → Access Roles is where you decide what a role can do. Only a superuser opens it. Pick a role, and choose a second one under Compare with to see the two side by side and spot where they differ.

Permissions are grouped into collapsible sections, one per object, such as cases, evidence, playbooks and indicators. Each header summarizes what the role has: create, edit, delete and view, plus manage, export or import where the object uses them. Expand a section to toggle individual permissions. There is no save step: a permission applies the moment you tick it, and reaches every user in the role.

The editor lists only permissions that change what a user can do. A permission that no part of DFIRe checks does not appear, and when you change a role that holds one, the editor removes it.

New role adds an empty role for you to grant permissions to. Rename and Delete act on the selected role. A role that still has members cannot be deleted, so reassign its users first.

Restoring the defaults

Superusers can return the four shipped roles to their standard permissions with Reset default roles. A default role that was renamed or deleted comes back under its original name. Members stay in place, and roles you created yourself are never touched. An upgrade does not bring the roles stored on an installation up to the current standard set, so use it after an upgrade to pick up that set, or after experimenting.

Delegating one area

Most settings areas can go to a role without full administrator access. Create a role, grant it only that area's permissions, and assign it. The user reaches that part of Settings and no other. Because a user can hold several roles, a narrow role like this also layers on top of a broader one. Superuser-only areas cannot be delegated. Configuration → The tabs shows who can open each tab.

Treat user-account administration as access to other accounts. The permission to change users lets its holder set a new password on any password account that is not a superuser. The holder can also reset that account's multi-factor authentication, then sign in as that account and work with its roles and case assignments. The limit on assigning roles does not restrict this. Give user-account administration only to people you would trust with every non-superuser account.

Automation rules can also change case teams, and only a superuser manages them. A rule can add or remove team members, or invite Slack users to a case channel and remove them from it.

Those Slack rules change teams too while Auto-add investigators is on in Settings → Slack Integration. The setting is on by default. A DFIRe user with a linked Slack ID who joins the channel of an open case joins its team as an investigator. This applies whoever invited them and whatever their role, and the role still decides what they can do. Someone already on the team keeps their place. A team member other than the lead who leaves that channel leaves the team.

Editing a user

Open a user from the list to change their name, email, username and roles, to set a new password, or to toggle Account Active. At least one role is required. A superuser can also set or clear their Slack ID. Other administrators see whether the account is linked, and the user links it with /dfire link. The API keys section appears only to a superuser, and on your own account.

Assigning roles has one limit. A user administrator who is not a superuser cannot assign a role that holds an escalation-sensitive permission the administrator does not hold. These permissions are core.view_all_cases, core.edit_all_cases, core.view_archived_cases, auth.add_user, auth.change_user, core.change_userapikey and core.view_remotecase. DFIRe refuses such an assignment and names the permissions.

Service account converts the account to API-key-only. This signs it out of every browser session and deletes every API key it holds, and only a superuser can reverse it. A superuser account cannot become a service account, so the switch is absent unless the account already carries the status. See API access.

Setting someone else's password revokes their keys and sessions. The user's sessions end and every enabled API key on the account is disabled. They sign in again and replace the keys their integrations depended on. Re-enabling a disabled key needs core.change_userapikey or superuser status, and a signed-in browser session in both cases. Changing your own password ends your sessions but leaves your keys alone. Send the new password over a channel you trust, and ask them to change it once they are in.

SSO accounts

An SSO account carries a badge naming its provider, and its password fields are hidden.

The identity provider owns the email, first name, last name and profile picture, and refreshes them on every sign-in. A provider that sends a phone number refreshes that too. Editing any of them in DFIRe therefore lasts until the next sign-in. Change them at the provider instead. The exception is a picture uploaded in DFIRe, which a sign-in never replaces. Roles, account status and Slack ID are DFIRe's own and survive an SSO sign-in untouched.

Disabling an account

Open the user, turn off Account Active, and save. The account can no longer sign in by any method, its audit trail and case history stay intact, and it moves to the disabled table.

Accounts cannot be deleted, only disabled. Deletion would free the user ID for reuse and break the audit trail, so DFIRe refuses it.

The last active superuser cannot be deactivated. DFIRe refuses, because nobody would be left to administer the installation. Create or reactivate another superuser first.

Unlinking an SSO identity

DFIRe matches an SSO sign-in first by the provider and the stable identifier it issues for the person. Renaming someone's email in DFIRe therefore does not break the link, and the next sign-in overwrites the rename with the provider's value. When no account has that identifier yet, DFIRe falls back to an account with the same email. It does so only if the provider marks that email as verified, and only for an account with no SSO identity. An account linked to one identity never moves to another by email.

Unlinking turns an SSO account back into a password account. Use it when the provider issues a new identifier for the same person, for example after you register the application again. Edit the user, select Unlink SSO under the authentication details, and confirm.

The account keeps its username, email, roles and history, and the audit log records the change. Set a password for the account if the person should sign in with one. Otherwise their next SSO sign-in, with the email verified by the provider, links the account again.

A fresh account instead? Change the old account's email, and deactivate it if the person should lose access to it. Their next SSO sign-in then creates a new account under the provider's default role.

Sessions

Each user manages their own sessions in My Profile. Current Session shows the one in front of them. Other Sessions lists the rest, with a control to revoke any single one and Revoke all other sessions to clear them together.

An administrator can end every session an account holds with Force logout, from the user's row or the edit dialog. Use it when a password may have leaked, when someone leaves, or to make a role change bite immediately. The user signs in again on every device. A System Root account is the exception: only another System Root user can end its sessions, and DFIRe hides the control from everyone else.

Force logout ends sessions and leaves the account's API keys working. If a key may have leaked, turn Account Active off: the keys of an inactive account stop working. The owner or a superuser can also disable a single key. See API access.

Signing in

DFIRe accepts two kinds of sign-in.

  • Single sign-on, through your organization's OIDC provider. The provider decides what a sign-in requires, so any multi-factor step it enforces applies here. DFIRe never asks an SSO account for a code of its own. This is the recommended method in production.
  • Local password, for initial setup and for environments with no identity provider. These accounts can require a code from an authenticator app after the password.

Password rules

A local password must be at least 12 characters. It cannot be entirely numeric, cannot be a commonly used password, and cannot closely resemble the account's own details.

Users change their own password from the profile menu, entering the current one and the new one. Administrators set a password by editing the user, which carries the consequences described above.

Multi-factor authentication

An account that signs in with a password can require a code from an authenticator app afterwards. DFIRe uses time-based one-time passwords, so any standard app works. Each user turns it on for their own account, and a superuser can require it across the installation.

Setting it up

  1. Open your profile

    Choose My Profile from the user menu and find Multi-Factor Authentication.

  2. Confirm your password

    Choose Set up MFA and enter your current password.

  3. Add DFIRe to your authenticator app

    Scan the code on screen, or type the setup key beside it if you cannot scan.

  4. Enter a code and choose Turn on

    The code proves the app is set up correctly. DFIRe signs your other sessions out here, so you will sign in again elsewhere.

  5. Save your recovery codes

    DFIRe shows ten recovery codes once and never again. Keep them somewhere you can reach without DFIRe.

Signing in with it

After the password, DFIRe asks for a code. A wrong code leaves the sign-in open for another try, but each failure makes the authenticator wait longer before it accepts the next one, and reaches the audit log. DFIRe also limits how fast attempts can arrive. The step expires five minutes after DFIRe accepts your password, and you start again from the password.

Without your authenticator app, choose Use a recovery code and enter one you saved.

Recovery codes

A recovery code signs you in once and is then spent. The sign-in screen stops offering them once you have none left, so replace them before that.

Replace recovery codes in your profile issues ten fresh ones and cancels the old set. It asks for your password and a code from your authenticator app. A recovery code is not accepted here, because one code would otherwise produce ten more.

Turning it off

Turn off asks for your password and one code, from either the app or your recovery codes. DFIRe signs your other sessions out.

What single sign-on does to it

Linking an account to an identity provider disables password sign-in, and multi-factor authentication goes with it. DFIRe removes the registered authenticator and the recovery codes, signs the other sessions out, and records the removal. The provider decides what sign-in requires from then on.

If a user loses both the app and the codes

Nobody can turn MFA off without a code, so this needs an administrator. Open the user in Settings → User Accounts, choose Edit user, then Reset MFA. This needs the permission to change users, and it does not work on a superuser account unless you are one.

A reset signs the user out everywhere and lets them back in with their password alone until they set MFA up again. Every enrolment, replacement, removal and administrator reset reaches the audit log.

Requiring it for everyone

A superuser can turn on Require multi-factor authentication in Settings → User Accounts. Password accounts then have to set up an authenticator app. SSO accounts are outside it, because their provider decides what their sign-in requires. So are service accounts, which use an API key and never a password.

Setting MFA up takes a sign-in, so the requirement does not lock everyone out the moment you enable it. Sign-ins allowed before setup is how many times an account with no authenticator can still get in with its password. Each of those sign-ins says how many remain and where to set MFA up. After the last one DFIRe refuses the password, and the user needs an administrator.

Changing this setting needs MFA on your own account, in both directions. Set it up in My Profile, sign in with a code, and the setting becomes available. The requirement never refuses a superuser a sign-in, so enabling it and then losing your authenticator cannot shut you out of the installation.

An account gets its full allowance back whenever it sets MFA up, turns it off, or an administrator resets it. To let a blocked user in without changing anything else, open them in Settings → User Accounts, choose Edit user, then Restore sign-ins. This needs the permission to change users, does not work on a superuser account unless you are one, and reaches the audit log.

Seeing who has it

The MFA column in Settings → User Accounts is visible to administrators who can change users. A tick means the account has an authenticator registered and a cross means it does not. A dash means the question does not apply, which covers service accounts and SSO accounts. Opening a user shows the same state in words, along with how many sign-ins remain while the requirement is on.

API keys are outside it

An API key is a credential in its own right and multi-factor authentication does not cover it. See API access.

Superusers

A superuser carries the ROOT badge and passes every permission and case team check. Write protection still applies. Ownership also binds a superuser: only the person who started an upload continues it, and only its author edits a chat message. The status is set during installation or from the command line, and the web interface cannot grant or revoke it. Administrators who are not superusers cannot edit a superuser account.

A superuser must have an email address, so the person who administers the installation stays reachable. DFIRe refuses to clear it, and flags a superuser that has none in the user list. A superuser also cannot be a service account, because such an account signs in with an API key and never with a password.

Besides the superuser-only settings tabs, some work stays with superusers whatever permissions a role holds:

  • Editing roles, including Reset default roles.
  • Managing automation rules, webhooks and email notifiers.
  • Setting a Slack user ID through user administration, your own included: a user who is not a superuser gets 403. On /api/collaboration/slack-mappings/, creating a row, and changing or deleting one through its ID, are superuser-only, your own row included. Reading another account's row there is superuser-only too. Everyone links their own account with /dfire link. Each user can still unlink their own account (the Slack Account panel, POST /api/collaboration/slack-mappings/unlink/ or DELETE /api/link-slack/).
  • Managing another account's API keys. Everyone manages their own.
  • Changing a superuser account, ending its sessions or resetting its MFA.
  • Turning a service account back into a regular account.
  • Opening the Django admin at /admin/. It asks for superuser status, not the staff flag, and a refusal writes an audit entry. If you are not signed in, it sends you to the DFIRe sign-in and back. The audit log records every create, change and delete made there, and DFIRe refuses the change if it cannot write the entry.

Keep the number of superusers small. Everything else can be delegated through roles.