← Back to Blog

MFAUsed Says No on Federated AWS Console Logins. That Doesn't Prove MFA Was Missing.

17 November 2026 Detection Engineering 12 min read
What MFAUsed means depends on who signed in IAM user signs in to AWS directly MFAUsed: Yes or No, true Root user signs in to AWS directly MFAUsed: Yes or No, true Federated user MFA at the identity provider, then assumes a role MFAUsed: always No Alert here: ConsoleLogin, MFAUsed No a password was the only thing standing in the way Read MFA elsewhere IdP log or UserAuthentication One field, two meanings: a fact for IAM users and root, a constant for everyone else.

A detection that alerts on AWS console sign-ins without MFA looks like an easy first rule for CloudTrail. Written against every ConsoleLogin event, it can't tell a federated sign-in that passed MFA at the identity provider from a password-only sign-in to an IAM user. The reason is in AWS's own documentation, and it isn't a bug. Scoped to the identities the field actually describes, the rule answers one precise question, and the federated sign-ins need their own evidence from a different log.

What MFAUsed records

Every AWS console sign-in writes a ConsoleLogin event to CloudTrail. The event carries responseElements.ConsoleLogin (Success or Failure) and, in additionalEventData, a field called MFAUsed. For an IAM user or the root user it means what it says: Yes when they signed in with an MFA device, No when a password was enough. The IAM and root examples also carry an MFAIdentifier with the ARN of the device used.

Federated sign-ins are different. AWS's CloudTrail console sign-in event reference shows a federated example with userIdentity.type of AssumedRole, mfaAuthenticated of false and MFAUsed of No, and explains why: the request was made by a federated user, and these fields are only set to true when an IAM user or the root user signs in with MFA.

That is the failure mode. A rule that treats MFAUsed: No as the finding fires on federated sign-ins whatever the identity provider required, and the response to that noise is usually exclusions or a disabled rule. The case the rule existed for, a password-only sign-in to an IAM user or to root, gets lost in the same move.

In an organization that does what AWS's IAM best practices ask, with humans signing in through an identity provider and IAM Identity Center rather than through IAM users, most console logins will be federated. The identity provider may have demanded a passkey from every one of those people. CloudTrail's ConsoleLogin event can't tell you, because AWS never saw the MFA.

Targets to set, by identity type. Federated sign-ins: don't judge MFA from MFAUsed at all; judge it from the identity provider's record. IAM users with a console password: only documented break-glass accounts, each with an MFA device registered. Root console sign-ins: zero outside a documented root-only task, and none with MFAUsed: No. Credential report: AWS lets you generate it once every four hours, so a daily pull costs nothing.

Measure it before you rewrite the rule

Start with the shape of your own console traffic. In Microsoft Sentinel, CloudTrail lands in the AWSCloudTrail table, where AdditionalEventData and ResponseElements are JSON strings and UserIdentityType holds the identity type.

// Source: AWSCloudTrail (Amazon Web Services connector, CloudTrail via S3)
// Hypothesis: console sign-ins with MFAUsed == "No" are mostly federated
// (AssumedRole), where the field is constant and carries no signal.
AWSCloudTrail
| where TimeGenerated > ago(30d)
| where EventSource == "signin.amazonaws.com" and EventName == "ConsoleLogin"
| extend Outcome = tostring(parse_json(ResponseElements).ConsoleLogin),
    MFAUsed = tostring(parse_json(AdditionalEventData).MFAUsed)
| summarize Logins = count(), Identities = dcount(UserIdentityArn)
    by UserIdentityType, MFAUsed, Outcome
| order by Logins desc
// Read it: AssumedRole rows with MFAUsed "No" are your federated users.
// IAMUser or Root rows with MFAUsed "No" and Outcome "Success" are the leads.
// An empty MFAUsed is a parsing or collection question, not a "No".

If the AssumedRole row is the largest, that is the noise a rule over all ConsoleLogin events would produce. Keep the figure: it justifies the change to whoever approved the original rule, and it gives you a baseline for the scoped rule's own volume.

Check collection while you're here. AWS documents that the Region a ConsoleLogin lands in depends on the user type and the sign-in endpoint: root sign-ins in us-east-1, us-east-2 or us-west-2, IAM users through the global endpoint in us-east-1 or one of three other Regions, and Regional endpoints in their own Region. A trail or connector that only collects your working Regions can miss sign-ins entirely. Break the same query down by AWSRegion and confirm every Region you expect appears.

One more trap sits next to this one. SessionMfaAuthenticated is set per API call, and the AWSCloudTrail table reference defines it as true when the root or IAM user whose credentials were used also authenticated with MFA. Any rule that keys on SessionMfaAuthenticated == false across all events has the same problem, multiplied by every API call a federated role makes.

The rule, scoped to the identities the field describes

// Source: AWSCloudTrail
// Hypothesis: a successful console sign-in by an IAM user or the root user
// with MFAUsed "No" means a password alone opened the console.
// Schedule: every 15 minutes. Set the lookback to the schedule plus your
// measured ingestion delay (see below); overlapping runs can return the same
// event twice, so group alerts on AwsEventId.
AWSCloudTrail
| where TimeGenerated > ago(30m)
| where EventSource == "signin.amazonaws.com" and EventName == "ConsoleLogin"
| where UserIdentityType in ("IAMUser", "Root")
| extend Outcome = tostring(parse_json(ResponseElements).ConsoleLogin),
    MFAUsed = tostring(parse_json(AdditionalEventData).MFAUsed)
| where Outcome == "Success" and MFAUsed != "Yes"
| extend Finding = iff(MFAUsed == "No", "No MFA", "MFAUsed missing")
| project TimeGenerated, AwsEventId, Finding, UserIdentityType,
    UserIdentityArn, UserIdentityUserName, RecipientAccountId, AWSRegion,
    SourceIpAddress, UserAgent
// Root: high severity until the account owner confirms a planned task.
// IAM user: first ask whether it should have a console password at all.
// "MFAUsed missing": check the raw event before treating it as either.

Two numbers in that rule are yours to set. The lookback has to cover CloudTrail's delivery delay plus the connector's, and the way to size it is to measure, not guess:

AWSCloudTrail
| where TimeGenerated > ago(7d)
| where EventName == "ConsoleLogin"
| extend DelayMin = datetime_diff('minute', ingestion_time(), TimeGenerated)
| summarize p50 = percentile(DelayMin, 50), p95 = percentile(DelayMin, 95),
    p99 = percentile(DelayMin, 99)
// Lookback = schedule + p99, rounded up.

Scoping on UserIdentityType rather than on names keeps the rule correct as the estate changes. A team adopting Identity Center needs no rule change, and neither does an IAM user someone creates outside the normal process; the second is exactly the case you want to catch.

Failures deserve their own look. AWS's examples record a failed IAM or root sign-in with ConsoleLogin of Failure and an errorMessage of Failed authentication. The failed IAM example carries the user's principalId, accountId and userName but no ARN, so a query that groups on UserIdentityArn separates failures from the success they came before. The query below builds its own identity key and requires the failures to come first:

// Source: AWSCloudTrail
// Hypothesis: five or more failed console sign-ins in the hour before a
// success, for the same IAM user or root, is possible password guessing
// followed by a successful sign-in. Users mistype too: review, don't conclude.
let Logins = AWSCloudTrail
| where TimeGenerated > ago(1d)
| where EventSource == "signin.amazonaws.com" and EventName == "ConsoleLogin"
| where UserIdentityType in ("IAMUser", "Root")
| extend Outcome = tostring(parse_json(ResponseElements).ConsoleLogin),
    Identity = strcat(UserIdentityAccountId, "/", UserIdentityType, "/",
        coalesce(UserIdentityUserName, UserIdentityPrincipalid));
Logins
| where Outcome == "Success"
| project Identity, SuccessTime = TimeGenerated, SuccessEventId = AwsEventId,
    SuccessSource = SourceIpAddress
| join kind=inner (
    Logins
    | where Outcome == "Failure"
    | project Identity, FailTime = TimeGenerated, FailEventId = AwsEventId,
        FailSource = SourceIpAddress
    ) on Identity
| where FailTime between ((SuccessTime - 1h) .. SuccessTime)
| summarize Failures = count(), FirstFailure = min(FailTime),
    FailSources = make_set(FailSource, 10), FailEventIds = make_set(FailEventId, 20)
    by Identity, SuccessTime, SuccessEventId, SuccessSource
| where Failures >= 5
// Confirm the key first: one known failure and success for the same user
// should produce the same Identity string in your data.

When the scoped rule fires

Start with the identity. A root hit is either a planned root-only task, which someone should be able to name and date, or it isn't. An IAM user hit raises a question that comes before MFA: should this user have a console password at all? In an estate that federates its people, an IAM user with a console password is usually a leftover from before federation, a shared account, or a break-glass account. The first two should lose the password. The third should have an MFA device, and the sign-in should match a documented use.

Then scope what the principal did. This is principal scoping, not session reconstruction: the query returns everything signed by the same ARN, which can include a second console session or an access key in use at the same time, and it stops at any role the principal assumes. Keep the timeline intact before you summarize anything:

// Source: AWSCloudTrail
// Pivot: the principal's activity in the hour after the console sign-in.
let Principal = "arn:aws:iam::111122223333:user/example";  // from the alert
let SignIn = datetime(2026-11-17T09:00:00Z);                // from the alert
AWSCloudTrail
| where TimeGenerated between (SignIn .. (SignIn + 1h))
| where UserIdentityArn == Principal
| project TimeGenerated, AwsEventId, RecipientAccountId, AWSRegion,
    EventSource, EventName, SourceIpAddress, UserAgent,
    UserIdentityAccessKeyId, UserIdentityPrincipalid, ErrorCode,
    RequestParameters, Resources
| order by TimeGenerated asc
// UserIdentityAccessKeyId separates the console session from access keys.
// An AssumeRole row means activity continued under the role: follow it there.

Read the timeline for what was done and whether it was authorized. New access keys, new users and policy changes need an owner who approved them; an unfamiliar session that only read data can still be an incident if the data matters. Neither a change nor its absence settles legitimacy on its own. The password-only sign-in is a finding either way, and the password goes.

Where federated MFA is actually recorded

Moving the rule away from federated sign-ins doesn't mean giving up on them. Their MFA evidence is in a different log.

If you use IAM Identity Center with its own directory or with Active Directory as the source, CloudTrail records the sign-in sequence itself. AWS's sign-in event examples show a password and TOTP sign-in as CredentialChallenge and CredentialVerification events for each factor, ending in a UserAuthentication event whose CredentialType lists both, PASSWORD,TOTP. A password-only sign-in ends with PASSWORD alone. With an external identity provider, the same page shows a single UserAuthentication with CredentialType of EXTERNAL_IDP, so the MFA decision belongs to that provider.

// Source: AWSCloudTrail (Identity Center sign-in events)
// Hypothesis: a UserAuthentication that verified only a password is a
// sign-in sequence that completed without a second factor. It describes
// that sequence, not the whole directory's MFA configuration.
AWSCloudTrail
| where TimeGenerated > ago(7d)
| where EventSource == "signin.amazonaws.com" and EventName == "UserAuthentication"
| extend Extra = parse_json(AdditionalEventData)
| extend CredentialType = tostring(Extra.CredentialType),
    UserName = tostring(Extra.UserName), AuthWorkflowID = tostring(Extra.AuthWorkflowID)
| where CredentialType == "PASSWORD"
| project TimeGenerated, AwsEventId, UserName, AuthWorkflowID,
    SourceIpAddress, UserAgent, RecipientAccountId
// AuthWorkflowID ties this event to the challenges before it.
// EXTERNAL_IDP sequences are excluded on purpose: read those at the provider.

AWS recommends identifying Identity Center users by userId and identityStoreArn rather than by username, so add those to the projection once you've confirmed where your connector puts them. The UserName field is emitted once per successful sign-in, and a failure caused by a wrong username records it as HIDDEN_DUE_TO_SECURITY_REASONS.

If Entra ID is the identity provider, the sign-in to the AWS application is in SigninLogs. Match on the enterprise application's ID rather than its display name:

// Source: SigninLogs (Microsoft Entra ID connector)
// Lead, not a finding: successful sign-ins to the AWS application that Entra
// records as single-factor.
let AwsAppId = "00000000-0000-0000-0000-000000000000";  // your AWS app's AppId
SigninLogs
| where TimeGenerated > ago(7d)
| where AppId == AwsAppId and ResultType == "0"
| where AuthenticationRequirement == "singleFactorAuthentication"
| project TimeGenerated, UserPrincipalName, IPAddress, CorrelationId,
    ConditionalAccessStatus, AuthenticationDetails
// Review AuthenticationDetails, any MFA claim satisfied earlier in the
// session, and the Conditional Access policies that applied.

Treat the result as a lead. Microsoft notes that this field doesn't always reflect the authentication reached, for example when a requirement was already met by an earlier MFA claim. And an Entra sign-in to the AWS application isn't yet access to a specific AWS account or role; connecting the two is a correlation step of its own.

The same rule in Splunk and Sigma

With the Splunk Add-on for AWS, CloudTrail records keep their JSON paths. Check the field names against one known console login in your index first.

index=aws sourcetype=aws:cloudtrail eventSource=signin.amazonaws.com eventName=ConsoleLogin
    "responseElements.ConsoleLogin"=Success "additionalEventData.MFAUsed"=No
    ("userIdentity.type"=IAMUser OR "userIdentity.type"=Root)
| table _time eventID userIdentity.type userIdentity.arn recipientAccountId awsRegion sourceIPAddress userAgent

As Sigma, for whatever backend you convert to:

title: AWS Console Login Without MFA by IAM User or Root
status: experimental
description: Successful console sign-in by an IAM user or the root user with MFAUsed No. Federated (AssumedRole) sign-ins are excluded because MFAUsed is No for them regardless of the identity provider's MFA.
logsource:
    product: aws
    service: cloudtrail
detection:
    selection:
        eventSource: signin.amazonaws.com
        eventName: ConsoleLogin
        responseElements.ConsoleLogin: Success
        additionalEventData.MFAUsed: 'No'
        userIdentity.type:
            - IAMUser
            - Root
    condition: selection
falsepositives:
    - Break-glass IAM users whose MFA device is held separately
level: high
tags:
    - attack.initial-access
    - attack.t1078.004

If you already run a community "console login without MFA" rule, open it and check one thing: whether its selection limits userIdentity.type. If it doesn't, it alerts on federated sign-ins too.

Don't fix the noise with exclusions of role names. An exclusion list of today's federated roles misses tomorrow's, so every new legitimate role brings the noise back. Broad role-name patterns go the other way and can suppress activity an attacker routes through a matching role. Scope on identity type, which is a property of the sign-in, not a list you have to maintain.

Close the gap at the source

The detection tells you a password alone opened the console. The credential report shows where a console password exists without a registered MFA device. Generate it, wait for it to finish, then filter it, all in one shell:

until [ "$(aws iam generate-credential-report --query State --output text)" = "COMPLETE" ]; do sleep 5; done
aws iam get-credential-report --query Content --output text | base64 --decode > creds.csv
# Columns 4 and 8 are password_enabled and mfa_active
awk -F, 'NR > 1 && tolower($4) == "true" && tolower($8) == "false" { print $1, $2, $5 }' creds.csv

Each row is a console password with no MFA device registered. That is narrower than "unprotected": mfa_active shows a device is enabled, not that every path enforces it, and other controls may still apply. It is still the list to work through. AWS's best practices ask for MFA wherever an IAM user or the root user must exist, and recommend phishing-resistant MFA such as passkeys and security keys.

Read the root row with its context. In AWS Organizations you can centralize root access for member accounts and delete their root credentials, and AWS says new member accounts have none by default. A member account showing no root MFA may have no root password to protect; a management account showing the same is a finding.

Where to read more

What to do this week

  1. Run the 30-day breakdown query by identity type, then by AWSRegion. Note the share of AssumedRole logins and any Region you expected but didn't see.
  2. Measure ingestion delay and deploy the scoped rule with a lookback that covers it, alerts grouped on AwsEventId, and root hits at high severity.
  3. Pull the credential report and list every console password with no MFA device. Each one either loses its password or gets a phishing-resistant device this week.
  4. Find where your federated MFA is logged. Run the Identity Center or the Entra query, whichever matches your setup, and review each result's authentication details before calling it a gap.
  5. Test it. Sign in to a sandbox account as an IAM user without MFA and confirm the rule fires; sign in through your identity provider and confirm it doesn't; mistype a sandbox password five times, then sign in, and confirm the failure query pairs them.
Ridgeline Cyber Defence Written by security professionals. Published weekly on Tuesdays.

Related Articles

15 June 2026

The EC2 Credential-Theft Detection Most Teams Ship Wrong

Alerting on AssumedRole from outside AWS buries you in SSO noise. Here is the marker that isolates a stolen EC2 instance

4 June 2026

KQL SigninLogs, The 10 Queries Every SOC Analyst Runs First

Ten KQL queries against SigninLogs that answer what SOC analysts actually ask during an identity investigation, copy-pas

16 May 2026

KQL Sign-In Log Analysis, What ResultType != 0 Actually Tells You

KQL sign-in log analysis: what ResultType values mean, how to detect password spray, MFA fatigue, and CA blocks in Senti