1. Resources
  2. Detection rules
  3. Password and One-Time Passcode Guessing Against PingOne Users

Password and One-Time Passcode Guessing Against PingOne Users detection rules

Repeated failed password checks or failed one-time passcode checks for one PingOne user, and the locks that follow them, show someone trying credentials against an account of the identity provider.

Platform
Ping Identity
Severity
Medium
Log source
PingOne audit activities
Last updated
Rule formats
Sigmaand queries for: SplunkMicrosoft Sentinel
What an attacker needs
The user name of a PingOne user and access to a sign-on page or to an API client that can check passwords.
Impact
A correct guess gives the attacker the user's session in every application that trusts PingOne, and a wrong series locks the real user out.
Response
Block the source of the attempts, and end the sessions and reset the password of any user who signed on after the failures.
Mitigation
Keep a lockout rule in every password policy and require MFA in the sign-on policy or flow of every application.
Action types
OTP.CHECK_FAILEDOTP.CHECK_INVALIDPASSWORD.CHECK_FAILEDDEVICE.LOCKEDPASSWORD.LOCKEDUSER.LOCKEDPOLICY.UPDATEDPOLICY.DELETED

How the attack works

PingOne checks a user's password in its sign-on flows and through the password check operation of the API, and it records a check that fails as the audit activity PASSWORD.CHECK_FAILED. What limits guessing is the lockout rule of the password policy that applies to the user's population. Ping documents two properties for it: lockout.failureCount, the number of tries before a password is placed in the lockout state, and lockout.durationSeconds, the time before it is released automatically. The predefined Basic and Standard policies lock after 5 failed attempts for 15 minutes, and repeated attempts of the same password are not counted as failed attempts. Both properties are optional, so a policy can exist without a lockout. PingOne records the lock as PASSWORD.LOCKED, and a lock of the whole account as USER.LOCKED. A change to the policy itself is recorded as POLICY.UPDATED, which Ping's event list describes as Password Policy Updated, and one rule here reports it because the lockout lives in that policy.

An attacker who already holds the password meets the second factor. For one-time passcodes the MFA policy sets how often the entry can fail before the user is blocked for a cool-down period (otp.failure.count, 1 to 7, default 3). PingOne's event list names the failures OTP.CHECK_FAILED and OTP.CHECK_INVALID. A device that is locked out carries a reason in the API, OTP for too many unsuccessful passcode tries and PUSH for too many push notifications that were declined or ignored, and the event list has a DEVICE.LOCKED activity. All of this comes from Ping's documentation of the events and settings: no public incident report describes guessing against PingOne at the audit event level.

Log source: the rules read PingOne audit activities. Include the Password, OTP, User and Device event types in the PingOne webhook that feeds the SIEM, or poll the Audit Activities API, for every environment. These are sign-on events, so expect far more volume than from configuration changes.

What an attacker needs

  • The user name of a PingOne user and access to an application's sign-on page or to an API client that is allowed to check passwords.
  • For the passcode rules, the user's password as well, because the passcode is asked for after the first factor.

Impact

A correct guess gives the attacker the user's session in every application that trusts PingOne for sign-on, and the administrator console if the user holds a role. A wrong series locks the password or the device, which keeps the real user out until the lock expires or an administrator removes it, and that request to the help desk is itself an opening for social engineering.

Detection rules

Repeated Failed One-Time Passcode Checks for One PingOne User

Counts, per user, the one-time passcode checks that failed in PingOne (audit activities OTP.CHECK_FAILED and OTP.CHECK_INVALID). The passcode is asked for after the first factor, so a series of wrong passcodes usually means that someone already has the user's password and is trying to pass the second factor. The MFA policy sets how often the entry can fail before the user is blocked for a cool-down period (otp.failure.count, 1 to 7, default 3). The count of 3 within 10 minutes equals that default and is a starting point. Ping's event list does not describe when OTP.CHECK_FAILED is written and when OTP.CHECK_INVALID, so the rule counts both. The pairing passcode activities (DEVICE.ACTIVATION_OTP_FAILED and DEVICE.ACTIVATION_OTP_INVALID) are not counted: they belong to the activation of a new device, where the person who pairs the device also receives the passcode.

Fires when one actors.user.name has at least 3 matching events within 10 minutes.

Threshold ruleLevelMediumStatusExperimentalLog sourcePingOne audit activities
title: PingOne One-Time Passcode Check Failed (Guessing Base Event)
id: 805077d1-dbbb-4761-9d3e-1511d0ce9e14
name: pingone_otp_check_failed
status: experimental
description: >-
  Base event of the threshold rule in this file. The audit activities
  OTP.CHECK_FAILED and OTP.CHECK_INVALID, which Ping's event list describes as
  Otp Check Failed and Otp Check Invalid.
logsource:
  product: pingone
  service: audit
detection:
  selection:
    action.type:
      - OTP.CHECK_FAILED
      - OTP.CHECK_INVALID
  condition: selection
level: low
---
title: Repeated Failed One-Time Passcode Checks for One PingOne User
id: df7eb075-02ce-4d12-b897-157e0838f958
status: experimental
description: >-
  Counts, per user, the one-time passcode checks that failed in PingOne (audit
  activities OTP.CHECK_FAILED and OTP.CHECK_INVALID). The passcode is asked
  for after the first factor, so a series of wrong passcodes usually means
  that someone already has the user's password and is trying to pass the
  second factor. The MFA policy sets how often the entry can fail before the
  user is blocked for a cool-down period (otp.failure.count, 1 to 7, default
  3). The count of 3 within 10 minutes equals that default and is a starting
  point. Ping's event list does not describe when OTP.CHECK_FAILED is written
  and when OTP.CHECK_INVALID, so the rule counts both. The pairing passcode
  activities (DEVICE.ACTIVATION_OTP_FAILED and DEVICE.ACTIVATION_OTP_INVALID)
  are not counted: they belong to the activation of a new device, where the
  person who pairs the device also receives the passcode.
references:
  - https://attack.mitre.org/techniques/T1110/001/
  - https://developer.pingidentity.com/pingone-api/platform/reference/audit-reporting-events.html
  - https://developer.pingidentity.com/pingone-api/mfa/device-authentication-policy/index.html
  - https://developer.pingidentity.com/pingone-api/mfa/mfa-authentication/mfa-device-authentications/index.html
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1110.001
correlation:
  type: event_count
  rules:
    - pingone_otp_check_failed
  group-by:
    - actors.user.name
  timespan: 10m
  condition:
    gte: 3
falsepositives:
  - Users who type an expired passcode or the code of another account in their authenticator app, and hardware tokens that have drifted out of sync. A single user with a few failures followed by a successful sign-on from the usual address is the common benign case.
  - The values of 3 failures and 10 minutes are starting points, not tested limits. Keep the count at or below the passcode failure limit of your MFA policies.
level: medium

False positives

  • Users who type an expired passcode or the code of another account in their authenticator app, and hardware tokens that have drifted out of sync. A single user with a few failures followed by a successful sign-on from the usual address is the common benign case.
  • The values of 3 failures and 10 minutes are starting points, not tested limits. Keep the count at or below the passcode failure limit of your MFA policies.

Repeated Failed Password Checks for One PingOne User

Counts, per user, the PingOne password checks that failed (audit activity PASSWORD.CHECK_FAILED). Five or more within 15 minutes are more than a mistyped password and fit guessing at one account. The count equals the lockout count of Ping's predefined Basic and Standard password policies (5 failed attempts, 15 minutes), so with those policies it fires together with the lock, and with a policy that has no lockout rule it is the only place where the attempts show. The count and the window are starting points to tune. The count is per actors.user.name. Ping documents the actor as the end user responsible for the event, which in a sign-on flow is the user who is signing on. A check that a worker application makes through the API carries the application as the actor and the user only in the activity's resources, so it is not counted per user. Confirm with one failed sign-on in a test environment that actors.user.name holds the user who tried to sign on.

Fires when one actors.user.name has at least 5 matching events within 15 minutes.

Threshold ruleLevelMediumStatusExperimentalLog sourcePingOne audit activities
title: PingOne Password Check Failed (Guessing Base Event)
id: 120e0b72-96a4-4de3-bdc2-7175dfe7b641
name: pingone_password_check_failed
status: experimental
description: >-
  Base event of the threshold rule in this file. The audit activity
  PASSWORD.CHECK_FAILED, which Ping's event list describes as Password Check
  Failed.
logsource:
  product: pingone
  service: audit
detection:
  selection:
    action.type: PASSWORD.CHECK_FAILED
  condition: selection
level: low
---
title: Repeated Failed Password Checks for One PingOne User
id: 1934ea77-0f31-4d88-b1ef-75773c33f79f
status: experimental
description: >-
  Counts, per user, the PingOne password checks that failed (audit activity
  PASSWORD.CHECK_FAILED). Five or more within 15 minutes are more than a
  mistyped password and fit guessing at one account. The count equals the
  lockout count of Ping's predefined Basic and Standard password policies (5
  failed attempts, 15 minutes), so with those policies it fires together with
  the lock, and with a policy that has no lockout rule it is the only place
  where the attempts show. The count and the window are starting points to
  tune. The count is per actors.user.name. Ping documents the actor as the end
  user responsible for the event, which in a sign-on flow is the user who is
  signing on. A check that a worker application makes through the API carries
  the application as the actor and the user only in the activity's resources,
  so it is not counted per user. Confirm with one failed sign-on in a test
  environment that actors.user.name holds the user who tried to sign on.
references:
  - https://attack.mitre.org/techniques/T1110/001/
  - https://developer.pingidentity.com/pingone-api/platform/reference/audit-reporting-events.html
  - https://developer.pingidentity.com/pingone-api/platform/audit-activities.html
  - https://developer.pingidentity.com/pingone-api/platform/password-policies/index.html
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1110.001
correlation:
  type: event_count
  rules:
    - pingone_password_check_failed
  group-by:
    - actors.user.name
  timespan: 15m
  condition:
    gte: 5
falsepositives:
  - A user who has forgotten the password, and a password manager, mail client or script that keeps submitting an old password after a change. Ping documents that repeated attempts of the same password are not counted toward the lockout, so such a client can produce a long series without a lock.
  - The values of 5 failures and 15 minutes are starting points, not tested limits. Keep the count at or below the lockout count of your password policies, and measure what is normal for your users before you alert on it.
level: medium

False positives

  • A user who has forgotten the password, and a password manager, mail client or script that keeps submitting an old password after a change. Ping documents that repeated attempts of the same password are not counted toward the lockout, so such a client can produce a long series without a lock.
  • The values of 5 failures and 15 minutes are starting points, not tested limits. Keep the count at or below the lockout count of your password policies, and measure what is normal for your users before you alert on it.

PingOne MFA Device Locked

Detects the audit activity DEVICE.LOCKED, which Ping's event list describes as Device Locked. Ping documents the lock of an MFA device as the state of a device that is locked out due to too many failed attempts, with one of two reasons: OTP, when the user passed the limit on the number of unsuccessful passcode tries, and PUSH, when the user passed the limit on the number of push notifications that can be declined or ignored within the defined time period (by default 5 within 10 minutes, with a lock of 30 minutes). Both cases mean that the first factor was passed and the second was not: wrong passcodes point to guessing, and declined or ignored push notifications to prompts the user did not start. The activity itself does not carry the reason in a field the rule can read, so read lock.reason of the device through the API during triage. The link between the device lock and this activity rests on its name: Ping's event list gives no description.

LevelLowStatusExperimentalLog sourcePingOne audit activities
title: PingOne MFA Device Locked
id: a89d8120-31ec-4bc5-a42b-ecd84265118b
status: experimental
description: >-
  Detects the audit activity DEVICE.LOCKED, which Ping's event list describes
  as Device Locked. Ping documents the lock of an MFA device as the state of a
  device that is locked out due to too many failed attempts, with one of two
  reasons: OTP, when the user passed the limit on the number of unsuccessful
  passcode tries, and PUSH, when the user passed the limit on the number of
  push notifications that can be declined or ignored within the defined time
  period (by default 5 within 10 minutes, with a lock of 30 minutes). Both
  cases mean that the first factor was passed and the second was not: wrong
  passcodes point to guessing, and declined or ignored push notifications to
  prompts the user did not start. The activity itself does not carry the
  reason in a field the rule can read, so read lock.reason of the device
  through the API during triage. The link between the device lock and this
  activity rests on its name: Ping's event list gives no description.
references:
  - https://attack.mitre.org/techniques/T1110/001/
  - https://developer.pingidentity.com/pingone-api/platform/reference/audit-reporting-events.html
  - https://developer.pingidentity.com/pingone-api/mfa/users/mfa-devices/index.html
  - https://developer.pingidentity.com/pingone-api/mfa/device-authentication-policy/index.html
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1110.001
logsource:
  product: pingone
  service: audit
detection:
  selection:
    action.type: DEVICE.LOCKED
  condition: selection
falsepositives:
  - Users who mistype passcodes several times, or who leave push notifications unanswered because the phone is out of reach while an application keeps asking. Confirm with the user that the sign-on attempts were theirs.
level: low

False positives

  • Users who mistype passcodes several times, or who leave push notifications unanswered because the phone is out of reach while an application keeps asking. Confirm with the user that the sign-on attempts were theirs.

PingOne Password or User Account Locked

Detects the audit activities PASSWORD.LOCKED and USER.LOCKED, which Ping's event list describes as Password Locked and User Locked. Ping documents the password lockout state as the result of too many invalid login attempts: the password policy sets the number of tries (lockout.failureCount) and the time before the password is released (lockout.durationSeconds). The account lock is a separate state. Ping documents that it can be set through the lock operation of the user accounts API, and that the MFA settings of the environment hold a failure count after which the account is locked. The activity does not say which of these caused the lock. One lock is usually a user who forgot a password. Several locks in a short time, or the lock of an administrator, deserve a look at the failed checks before it.

LevelLowStatusExperimentalLog sourcePingOne audit activities
title: PingOne Password or User Account Locked
id: 5bcac223-345d-48dd-bcba-47c69d3b65a4
status: experimental
description: >-
  Detects the audit activities PASSWORD.LOCKED and USER.LOCKED, which Ping's
  event list describes as Password Locked and User Locked. Ping documents the
  password lockout state as the result of too many invalid login attempts: the
  password policy sets the number of tries (lockout.failureCount) and the time
  before the password is released (lockout.durationSeconds). The account lock
  is a separate state. Ping documents that it can be set through the lock
  operation of the user accounts API, and that the MFA settings of the
  environment hold a failure count after which the account is locked. The
  activity does not say which of these caused the lock. One lock is usually a
  user who forgot a password. Several locks in a short time, or the lock of an
  administrator, deserve a look at the failed checks before it.
references:
  - https://attack.mitre.org/techniques/T1110/001/
  - https://developer.pingidentity.com/pingone-api/platform/reference/audit-reporting-events.html
  - https://developer.pingidentity.com/pingone-api/platform/users/user-passwords/index.html
  - https://developer.pingidentity.com/pingone-api/platform/users/user-accounts/index.html
  - https://developer.pingidentity.com/pingone-api/mfa/mfa-settings/index.html
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1110.001
logsource:
  product: pingone
  service: audit
detection:
  selection:
    action.type:
      - PASSWORD.LOCKED
      - USER.LOCKED
  condition: selection
falsepositives:
  - Users who forget their password, above all after a forced change or a holiday period. Expect regular volume in large environments and use the rule for review, or alert only for the accounts of administrators.
  - Administrators who lock an account on purpose, for example during offboarding or an investigation, which also writes USER.LOCKED.
level: low

False positives

  • Users who forget their password, above all after a forced change or a holiday period. Expect regular volume in large environments and use the rule for review, or alert only for the accounts of administrators.
  • Administrators who lock an account on purpose, for example during offboarding or an investigation, which also writes USER.LOCKED.

PingOne Password Policy Updated or Deleted

Detects the audit activities POLICY.UPDATED and POLICY.DELETED, which Ping's event list describes as Password Policy Updated and Password Policy Deleted. The password policy holds the lockout rule that limits guessing (lockout.failureCount and lockout.durationSeconds, both optional) and the check against commonly used passwords (excludesCommonlyUsed). An administrator who removes the lockout properties, raises the count or switches the check off makes every account under that policy easier to guess, and nothing about any user changes. The rule matches on the activity alone: Ping's event list gives it only the common attributes, so it does not say which rule of the policy changed or whether the policy became weaker, and the level is one step lower for that reason. Read the policy after each match and compare it with your reviewed copy. Ping documents that a policy cannot be deleted while it is the environment's default or is referenced by a population, so a deletion matters less than an update.

LevelLowStatusExperimentalLog sourcePingOne audit activities
title: PingOne Password Policy Updated or Deleted
id: b33bb769-3cf5-44c9-a67c-7e6156bbad06
status: experimental
description: >-
  Detects the audit activities POLICY.UPDATED and POLICY.DELETED, which Ping's
  event list describes as Password Policy Updated and Password Policy Deleted.
  The password policy holds the lockout rule that limits guessing
  (lockout.failureCount and lockout.durationSeconds, both optional) and the
  check against commonly used passwords (excludesCommonlyUsed). An
  administrator who removes the lockout properties, raises the count or
  switches the check off makes every account under that policy easier to
  guess, and nothing about any user changes. The rule matches on the activity
  alone: Ping's event list gives it only the common attributes, so it does
  not say which rule of the policy changed or whether the policy became
  weaker, and the level is one step lower for that reason. Read the policy
  after each match and compare it with your reviewed copy. Ping documents
  that a policy cannot be deleted while it is the environment's default or is
  referenced by a population, so a deletion matters less than an update.
references:
  - https://attack.mitre.org/techniques/T1110/001/
  - https://developer.pingidentity.com/pingone-api/platform/reference/audit-reporting-events.html
  - https://developer.pingidentity.com/pingone-api/platform/password-policies/index.html
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1110.001
logsource:
  product: pingone
  service: audit
detection:
  selection:
    action.type:
      - POLICY.UPDATED
      - POLICY.DELETED
  condition: selection
falsepositives:
  - Planned changes to password requirements, for example a longer minimum length or a new expiry period. Password policies change rarely, so confirm each activity with the change record.
level: low

False positives

  • Planned changes to password requirements, for example a longer minimum length or a new expiry period. Password policies change rarely, so confirm each activity with the change record.

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.

Failed password checks followed by a successful check for the same user

Detection hypothesisSequence of events

Guessing that works ends with a correct password. A series of failed password checks for one user that is followed by a successful check from the same source address is the point at which an attempt turned into access, and it is the case that matters most among all the bursts the threshold rule reports.

  1. Count PASSWORD.CHECK_FAILED activities per actors.user.name. Keep the users that reach your count, for a start 3 or more within 15 minutes.
  2. Look for a PASSWORD.CHECK_SUCCEEDED activity with the same actors.user.name within the next 60 minutes.
  3. Compare source.ipAddress and source.userAgent of the failures with those of the successful check. The same address on both sides is the guessing pattern.
  4. Check whether an MFA step followed the successful check, for example OTP.CHECK_FAILED or OTP.CHECK_INVALID for the same user, which shows the attacker stopped at the second factor.

EventsPASSWORD.CHECK_FAILEDPASSWORD.CHECK_SUCCEEDEDOTP.CHECK_FAILEDOTP.CHECK_INVALID

LimitsA user who mistypes a password and then gets it right produces the same sequence, so the count and both time spans are starting points to tune. A guess that is right within the first tries stays below the count, and checks made by a worker application through the API carry the application as the actor instead of the user.

Password or device lock released by an administrator shortly before a successful sign-on

Detection hypothesisSequence of events

A lock stops a guesser until somebody removes it. An attacker who has locked an account can ask the help desk to release it while posing as the user. A lock that is released by another actor and is followed by a successful check from the address of the earlier failures shows that the release served the attacker.

  1. Find a PASSWORD.LOCKED, USER.LOCKED or DEVICE.LOCKED activity and note the user it concerns.
  2. Look for PASSWORD.UNLOCKED, USER.UNLOCKED or DEVICE.UNLOCKED for that user within the lock duration of your policy, and read actors.user.name or actors.client.name to see who released it.
  3. Look for a PASSWORD.CHECK_SUCCEEDED activity of the user after the release, and compare its source.ipAddress with the address of the failed checks before the lock.

EventsPASSWORD.LOCKEDUSER.LOCKEDDEVICE.LOCKEDPASSWORD.UNLOCKEDUSER.UNLOCKEDDEVICE.UNLOCKED

LimitsHelp desks release locks for real users every day, so the release alone means little. Ping does not document whether a lock that expires by itself writes an unlock activity, and the user a lock concerns is named in the activity's resources, which the rules of this page do not read.

Triage

  • Read actors.user.name and source.ipAddress of the failed checks. One address and a steady rhythm point to a script or a guesser, while a user at their usual address after a password change points to a forgotten password or a saved old one.
  • Look for a PASSWORD.CHECK_SUCCEEDED activity for the same user after the failures, and compare its source address and user agent with those of the failures.
  • Check whether the same address failed for other users in the same period, which points to spraying across accounts instead of guessing at one.
  • For passcode failures, find out how the first factor was passed. A correct password followed by wrong passcodes means the password is already known to someone else.
  • For a lock, check who released it (PASSWORD.UNLOCKED, USER.UNLOCKED or DEVICE.UNLOCKED), at whose request, and what the user did afterwards.
  • Give priority to users who hold administrator roles and to members of groups that hold them.

Response

Once the attack is confirmed:

  1. Block the source addresses of the attempts at the network edge or with a sign-on policy condition, before any lock is released.
  2. If a successful check followed the failures, treat the account as compromised. End the user's sessions, reset the password and review the MFA devices registered for the user.
  3. Reset the password of a user whose passcode checks failed after a correct password, even when no sign-on followed, because the first factor is known to someone else.
  4. Review what the account did after the sign-on, above all changes to its own MFA devices, role assignments, applications and secrets.
  5. Release locks only after the owner of the account has confirmed which attempts were their own, through a channel that does not depend on the account.

Mitigation

  • Keep a lockout rule in every password policy in use, and check the policy assigned to each population. A policy without lockout.failureCount never locks.
  • Require MFA in the sign-on policy or flow of every application, so that a guessed password is not enough, and prefer FIDO2 or an authenticator app over passcodes sent by email, SMS or voice.
  • Keep the passcode failure limit of the MFA policy low and its cool-down period above zero.
  • Enable the check against commonly used passwords in the password policy (excludesCommonlyUsed).
  • Send the Password, OTP, User and Device event types to the SIEM for every environment, the one that holds the administrators first.

Frequently asked questions

Does PingOne lock a password after failed attempts by default?

Ping's predefined Basic and Standard password policies lock the account after 5 failed attempts for 15 minutes. The lockout properties of a password policy, `lockout.failureCount` and `lockout.durationSeconds`, are optional, so a policy can be saved without them and then never locks. Check the policy that is assigned to each population, not only the default policy of the environment.

Why is the threshold for failed password checks five?

It equals the lockout count of Ping's predefined policies. Ping does not document which activity a further attempt on a locked password produces, so a count above your lockout limit may never be reached. Keep the count at or below the limit of your policies and treat the 15 minutes as a starting point. Where the policy has no lockout, the count is the only place where the attempts show.

What is the difference between OTP.CHECK_FAILED and OTP.CHECK_INVALID?

Ping's event list names them Otp Check Failed and Otp Check Invalid and does not describe when each is written. The rule here counts both for one user. Produce a wrong passcode once in a test environment to see which of the two your flows write, and whether one of them marks the attempt that reaches the failure limit.

Is there a public report of password guessing against PingOne?

No public incident report describes it at the audit event level. The page is built from Ping's documentation of the password policy, the MFA policy and the audit event types, in the same way as the library's pages for other identity providers. The thresholds are starting points and were not measured in a production tenant.

References

We respect your privacy

We use cookies to keep this site secure and working properly. With your permission, we also use optional cookies to understand usage and improve the experience. Cookie Policy

You can change your choice at any time.