How the attack works
A GitLab Self-Managed or GitLab Dedicated instance decides in its application settings who can get an account and how accounts sign in. The new user account restrictions hold the switch that allows new accounts at all, the requirement that an administrator approves each new account, the email confirmation setting, and an allowlist and a denylist of email domains. The sign-in restrictions hold the switches for password authentication in the web interface and for Git over HTTP(S). With password authentication for the web interface disabled, users cannot use the standard sign-in screen and must use an external authentication provider.
An attacker with administrator access can loosen these settings so that their access no longer depends on the account they took over. With registration open and approval off, anyone who reaches the instance can create an account, and GitLab documents that any authenticated user can clone an internal project. With password sign-in allowed again, an account can sign in without the identity provider and its controls. GitLab records each change of an application setting as the audit event type application_setting_updated. The event type reference does not say which field names the changed setting. In the GitLab source the event is written once per changed setting, with the name of the setting in details.change and the new value in details.to, and the rules on this page rely on that.
What an attacker needs
- Administrator access to the instance, in the Admin area or with a token that can call the application settings API.
- For the opening to be used, network access to the registration or sign-in page of the instance.
- Log collection: audit event streaming for the instance (Ultimate, GitLab Self-Managed and GitLab Dedicated) to an HTTP destination, received as JSON.
application_setting_updatedhas the Instance scope.
Impact
Accounts that nobody invited can exist on the instance. Each one can clone every internal project, since GitLab lets any authenticated user who is not external do that, and can be added to groups and projects later. GitLab also notes that when the approval requirement is disabled, the users in pending approval state are approved automatically in a background job, so accounts that were waiting get in at once. Password sign-in that is allowed again gives accounts a way around single sign-on.
Detection rules
GitLab Instance Sign-Up Email Domain or Confirmation Setting Changed
Detects a change of the instance settings that decide which email addresses may register and whether they must be confirmed: the email domain allowlist and denylist (domain_allowlist, domain_denylist), the email restriction pattern (email_restrictions) and the email confirmation setting (email_confirmation_setting, with the values off, soft and hard). An added domain, a shortened denylist or confirmation set to off lets accounts register that were kept out before. The event type is application_setting_updated. GitLab documents the event type but not its fields. In the GitLab source the name of the changed setting is in details.change. The new value of a list cannot be judged by a rule, so this rule matches every change of these settings and is a low-level signal for review. Read the old and the new value in the details object.
title: GitLab Instance Sign-Up Email Domain or Confirmation Setting Changed
id: 81490f98-aa10-44a0-8559-2951c433ccc3
status: experimental
description: >-
Detects a change of the instance settings that decide which email
addresses may register and whether they must be confirmed: the email
domain allowlist and denylist (domain_allowlist, domain_denylist), the
email restriction pattern (email_restrictions) and the email
confirmation setting (email_confirmation_setting, with the values off,
soft and hard). An added domain, a shortened denylist or confirmation
set to off lets accounts register that were kept out before. The event
type is application_setting_updated. GitLab documents the event type
but not its fields. In the GitLab source the name of the changed
setting is in details.change. The new value of a list cannot be judged
by a rule, so this rule matches every change of these settings and is
a low-level signal for review. Read the old and the new value in the
details object.
references:
- https://docs.gitlab.com/user/compliance/audit_event_types/
- https://docs.gitlab.com/user/compliance/audit_event_schema/
- https://docs.gitlab.com/api/settings/
- https://docs.gitlab.com/administration/settings/sign_up_restrictions/
- https://attack.mitre.org/techniques/T1484/
author: Forestall
date: 2026-11-18
tags:
- attack.defense-impairment
- attack.privilege-escalation
- attack.t1484
logsource:
product: gitlab
service: audit
detection:
selection:
event_type: application_setting_updated
details.change:
- domain_allowlist
- domain_denylist
- email_restrictions
- email_confirmation_setting
condition: selection
falsepositives:
- Administrators who add a company domain, extend the denylist or raise the confirmation setting. The rule cannot tell the direction, so read the values before closing the alert.
level: low
False positives
- Administrators who add a company domain, extend the denylist or raise the confirmation setting. The rule cannot tell the direction, so read the values before closing the alert.
GitLab Instance Sign-Up or Password Sign-In Restriction Relaxed
Detects an application setting of the instance being changed in the direction that lets more accounts in: new user accounts allowed (signup_enabled), password authentication allowed for the web interface or for Git over HTTP(S) (password_authentication_enabled_for_web, password_authentication_enabled_for_git), each set to true, and the approval requirement for new accounts, the email restriction or the email domain denylist switched off (require_admin_approval_after_user_signup, email_restrictions_enabled, domain_denylist_enabled), each set to false. The event type is application_setting_updated. GitLab documents the event type but not its fields, and the details object has no defined schema. In the GitLab source the event carries the name of the changed setting in details.change and the new value in details.to. Because the rule depends on that undocumented shape, its level is one step lower than the change deserves. Test it with one change on your version.
title: GitLab Instance Sign-Up or Password Sign-In Restriction Relaxed
id: 50af14d6-7d92-40a7-839d-1cebd1970bc8
status: experimental
description: >-
Detects an application setting of the instance being changed in the
direction that lets more accounts in: new user accounts allowed
(signup_enabled), password authentication allowed for the web
interface or for Git over HTTP(S)
(password_authentication_enabled_for_web,
password_authentication_enabled_for_git), each set to true, and the
approval requirement for new accounts, the email restriction or the
email domain denylist switched off
(require_admin_approval_after_user_signup, email_restrictions_enabled,
domain_denylist_enabled), each set to false. The event type is
application_setting_updated. GitLab documents the event type but not
its fields, and the details object has no defined schema. In the
GitLab source the event carries the name of the changed setting in
details.change and the new value in details.to. Because the rule
depends on that undocumented shape, its level is one step lower than
the change deserves. Test it with one change on your version.
references:
- https://docs.gitlab.com/user/compliance/audit_event_types/
- https://docs.gitlab.com/user/compliance/audit_event_schema/
- https://docs.gitlab.com/api/settings/
- https://docs.gitlab.com/administration/settings/sign_up_restrictions/
- https://docs.gitlab.com/administration/settings/sign_in_restrictions/
- https://attack.mitre.org/techniques/T1484/
author: Forestall
date: 2026-11-18
tags:
- attack.defense-impairment
- attack.privilege-escalation
- attack.t1484
logsource:
product: gitlab
service: audit
detection:
selection_enabled:
event_type: application_setting_updated
details.change:
- signup_enabled
- password_authentication_enabled_for_web
- password_authentication_enabled_for_git
details.to: 'true'
selection_disabled:
event_type: application_setting_updated
details.change:
- require_admin_approval_after_user_signup
- email_restrictions_enabled
- domain_denylist_enabled
details.to: 'false'
condition: 1 of selection_*
falsepositives:
- A planned change, for example registration opened for a short time to onboard a partner, or password sign-in allowed again during an outage of the identity provider, which GitLab describes as a recovery step. Confirm it against a change request and check that it was set back.
level: medium
False positives
- A planned change, for example registration opened for a short time to onboard a partner, or password sign-in allowed again during an outage of the identity provider, which GitLab describes as a recovery step. Confirm it against a change request and check that it was set back.
Detection logic
Patterns that need more than one event, a baseline or knowledge of your own environment. Each is a hypothesis to build and tune in your SIEM, not a ready rule.
Registration opened and new accounts appear shortly after
A relaxed sign-up setting is only useful to an attacker when an account follows. Accounts that register or are approved in the days after registration was opened or approval was removed are the ones to check first, before they are given roles.
- A sign-up restriction is relaxed:
application_setting_updatedfor the settings of the first rule on this page. Keep the time and the administrator (author_id). - Collect
registration_created(a user registers for instance access),user_createdanduser_approvedevents in the following 7 days. - For each new account, look for
member_createdandpersonal_access_token_created, and for downloads of internal projects (repository_download_operation). - Compare the email domains of the new accounts with your own domains.
Eventsapplication_setting_updatedregistration_createduser_createduser_approved
LimitsThe email address of a new account is not a documented field of these events, so the domain comparison needs the users list. On an instance where registration was opened on purpose, every new colleague matches. The 7 days are a starting point.
Triage
- Identify the administrator (
author_name,author_id) and the address the change came from (ip_address). - Read the changed setting and its values in the
detailsobject of the event, and compare them with the Admin area under Settings, General, in the sections for new user account restrictions and sign-in restrictions. - Confirm the change with the administrator through a separate channel and look for a change request.
- List the accounts that appeared since the change.
registration_created,user_createdanduser_approvedevents, and the users list filtered by creation date. - Check what the same administrator account did around the change, such as new tokens, impersonation and other setting changes.
Response
Once the attack is confirmed:
- Set the sign-up and sign-in restrictions back to the approved values.
- Block the accounts that registered or were approved while the restrictions were relaxed, until each one is confirmed by its owner's manager.
- Review what those accounts cloned or read, above all internal projects, and treat it as disclosed.
- Treat the administrator account that made the change as compromised. Reset its password and second factor, end its sessions and revoke its tokens.
- Review the other application settings that changed in the period, such as two-factor requirements and audit event streams.
Mitigation
- Disable new user accounts on instances that do not expect public users, as GitLab recommends for public-facing instances, or require administrator approval for new accounts.
- Restrict new accounts to your own email domains with the allowlist, and require hard email confirmation.
- Set new users to external by default if open registration is needed, because external users cannot clone internal projects.
- Keep the number of administrators small, enforce two-factor authentication for them, and turn on Admin Mode.
- Stream instance audit events to your SIEM and alert on changes of the sign-up and sign-in settings.
Frequently asked questions
Why does opening registration matter if new accounts have no role?
A new account needs no role to read internal content. GitLab documents that for internal projects any authenticated user, including users with the Guest role, can clone the project, and that external users cannot. On an instance that uses the internal visibility level for shared code, an open registration page therefore gives every newcomer that code unless new users are external by default.
How do the rules know which application setting changed?
From the `details` object, which GitLab documents as having no defined schema. In the GitLab source `application_setting_updated` is written once per changed column of the application settings, with the column name in `details.change` and the old and new value in `details.from` and `details.to`. The setting names in the rules are those of the application settings API. A setting that GitLab stores inside a grouped column would appear under the name of that column, so test the rules with one change on your version.
What happens to pending users when the approval requirement is switched off?
GitLab states that if an administrator disables the setting that requires administrator approval for new user accounts, the users in pending approval state are automatically approved in a background job. The same is documented for removing the user cap. Accounts that registered earlier and were waiting therefore become active without anyone approving them one by one.
Does this page apply to GitLab.com?
No. Application settings belong to the administrators of GitLab Self-Managed and GitLab Dedicated instances, and GitLab notes that on GitLab Dedicated new account creation is prevented by default when the instance is provisioned. For a group on GitLab.com, the comparable controls are the allowed email domains and the IP restriction of the top-level group.
References
- MITRE ATT&CK T1484: Domain or Tenant Policy Modification
- GitLab Docs: New user account restrictions
- GitLab Docs: Sign-in restrictions
- GitLab Docs: Application settings API
- GitLab Docs: Project and group visibility
- GitLab Docs: Moderate users (users pending approval)
- GitLab Docs: Audit event types
- GitLab Docs: Audit event schema and examples