HIGH Duo Security MFA Bypass / Conditional Access Evasion LTR-0013 ✓ validated

Detect MFA Fatigue and Bypass Abuse in Duo Security Logs

Published · Updated

MITRE ATT&CK: T1621T1078.004T1556.006

Sigma Rule

title: Duo MFA Fatigue, Fraud Report, and Bypass Abuse
id: 6d1a8f34-2c97-4e05-b8d6-91f7a3e4c25b
status: experimental
description: >
  Detects attacks on the second factor in Duo authentication logs: a user
  reporting a push as fraud, Duo's own anomalous-push (push harassment)
  detection, and a login that succeeded with a bypass code or for a user in
  bypass status instead of a real second factor. Any of these means someone
  already has, or is trying to use, the user's password.
references:
  - https://attack.mitre.org/techniques/T1621/
  - https://attack.mitre.org/techniques/T1556/006/
author: LogTriage
date: 2026/08/04
modified: 2026/10/20
logsource:
  product: duo
  service: authentication
detection:
  user_reported_fraud:
    result: 'FRAUD'
    reason: 'user_marked_fraud'
  push_harassment:
    reason: 'anomalous_push'
  bypass_used:
    - factor: 'bypass_code'
      result: 'SUCCESS'
    - reason: 'bypass_user'
  condition: user_reported_fraud or push_harassment or bypass_used
falsepositives:
  - Helpdesk-issued bypass code during phone replacement (correlate with a ticket)
  - User temporarily set to bypass status by an administrator
  - A push reported as fraud by mistake
level: high
tags:
  - attack.credential_access
  - attack.t1621
  - attack.defense_evasion
  - attack.t1556.006
How the rule decides

1 · Each event is compared with 3 selections. Every field in a selection must match; listed values are alternatives.

user_reported_fraud
  • result is FRAUD
  • and reason is user_marked_fraud
push_harassment
  • reason is anomalous_push
bypass_used
  • factor is bypass_code
  • and result is SUCCESS

or

  • reason is bypass_user

2 · An event counts when

user_reported_fraudorpush_harassmentorbypass_used

Alert high Checked on every deploy: fires on duo_attack.json, silent on duo_normal.json — both in the public sample dataset ↗︎

What this rule detects

Most MFA attacks do not break the cryptography; they go around it. This rule targets the three clearest signals in Duo’s authentication log that the second factor is being attacked rather than simply used:

  1. result: FRAUD with reason: user_marked_fraud: a user reported an authentication request as fraudulent.
  2. reason: anomalous_push: Duo’s own detection that a push looks like push harassment. Duo refuses the authentication and records this reason.
  3. A bypass login: factor: bypass_code with result: SUCCESS, or reason: bypass_user, meaning the login succeeded without a real second factor.

Any one of these fires the rule. Each is meaningful on its own, so there is no threshold.

Detection logic

The rule is an or across three narrow selections rather than a count, because each condition is rare enough that a single occurrence justifies an alert.

Why a fraud report matters so much. The push prompt only appears after a correct username and password. When a user reports it as fraud, they are telling you, with more confidence than any detection engine could, that an attacker already holds their credentials.

Why bypass logins get their own selection. Bypass codes and bypass status are deliberate escape hatches for lockouts and lost devices. That also makes them the cleanest way to turn a stolen password into full access. The selection lists both shapes: a bypass code used as the second factor (bypass_code), and a user whose status skips the second factor (bypass_user).

Validated against a real sample

Validated against duo_attack.json (shipped with LogTriage), which contains all three signals:

  • A FRAUD result for user jsmith on the VPN with reason: user_marked_fraud, from 185.220.101.42 with hostname attacker.ru
  • A FAILURE with reason: anomalous_push against alice on Office365 SSO, from 45.142.212.100
  • A SUCCESS for admin on the Admin Panel with factor: bypass_code, from the same 185.220.101.42, with the browser reported as python-requests, which is not a browser

That last event is the attack chain in one line: the source that triggered a fraud report reaching an admin panel with a bypass code, driven by a script.

The rule fires on all three events. It stays silent on the matching benign log, which contains SUCCESS results via duo_push and duo_mobile_passcode with the reasons user_approved and valid_passcode, plus an administrator’s alias change. None of them is a fraud report, an anomalous push or a bypass login.

False positives

Helpdesk-issued bypass codes during phone replacement, and users an administrator temporarily set to bypass status, are the recurring benign cases. They should correlate with a ticket and a known admin. If bypass logins are routine in your tenant, treat that as a policy problem rather than tuning the rule to ignore them. A fraud report made by mistake is the other case: confirm with the user, but reset the password anyway if in doubt.

Frequently Asked Questions

Why does a single fraud report fire without a threshold?
Because of what it implies. A user is only prompted to approve a push after someone submitted their correct username and password. When the user reports the push as fraud, they are telling you the first factor is compromised and an attacker holds valid credentials. The second factor held this time; there is no guarantee it holds on the tenth attempt. Reset the password and review the account's recent logins.
What exactly is MFA fatigue or push bombing?
An attacker with a valid password triggers authentication repeatedly, flooding the victim's phone with push prompts until they approve one out of confusion or to make it stop. It defeats push-based MFA without any technical exploit. Duo detects the pattern itself and records the refused authentication with the reason `anomalous_push`, which is why the rule keys on that reason directly.
Why flag bypass codes and bypass status when they are legitimate features?
Because both skip the second factor entirely, which makes them a favourite target. A login with `factor: bypass_code` used a one-time code an administrator generated; a login with `reason: bypass_user` belongs to a user whose status is set to bypass, so no second factor was asked for at all. Legitimate use is rare, ticketed and issued by a known admin, so every use is worth a look. A bypass login to an admin application or from an unusual address should be treated as compromise until proven otherwise.
How should this rule be tuned for a large tenant?
Do not threshold the fraud or bypass selections; both are rare and meaningful on their own. The anomalous-push selection benefits from context: group by user and look at the minutes before it, since several refused pushes in a short window is an attack in progress. Duo's result values are SUCCESS, FAILURE, ERROR and FRAUD; Sigma string matches are case-insensitive, so the rule matches them however your collector cases them.

Related Resources

Reference

See this detection run on a real report

Try the live demo with a pre-loaded malicious log set — no signup required — or upload your own log file and get a full AI-reviewed threat report in minutes.