Skip to main content

AWS Detection Update

Sysadmin
Fluency Sysadmin

A detection release for AWS, published in three parts from November 14 to 16, 2026. Twenty-one new rules catch the steps of an AWS account compromise with stolen access keys. Eighteen of them, with two context rules, watch AWS CloudTrail for a key being tested for what it can reach, secrets harvested, access kept after the key is disabled, logging turned off, and expensive workloads run at the account's expense. The other three turn Amazon GuardDuty findings into Fluency alerts. Two existing rules are updated: AWS_Security_Monitoring_Disabled covers two more logging controls, and AWS_Unauthorized_API_Call now recognizes EC2's refusals.

No action is needed: the rules sync to every instance that collects CloudTrail automatically.

Rollout and requirements​

  • Rollout. The rules are published to the default rule set and reach each instance through resource sync within about two hours. No configuration is needed. They apply to events from release on, not retroactively.
  • Data sources. All the rules except the three GuardDuty rules read AWS CloudTrail, collected by the AWS CloudTrail application (AWS CloudTrail). The GuardDuty rules read the findings collected by the Amazon GuardDuty application (AWS GuardDuty). Instances without AWS data are unaffected.
  • Learning. The rules that report an identity's "first time in 30 days" start counting at release. In the first weeks, every identity that runs an SSM command, pushes an Instance Connect key, updates a Lambda function or launches an accelerator instance counts as new, so expect more AWS alerts at first. The volume settles as the 30-day history fills.

The attack​

The rules come from an AWS account compromise Fluency investigated. The attacker held a batch of stolen access keys and tested them one by one: a GetCallerIdentity call to confirm the key worked, then calls against services the key could not reach, each refused. A key that works and is refused is still a key someone is exploring. The stolen-key rules were built from that activity and replayed with all account details removed: they catch 36 of the 38 attacker keys. Against 14 days of activity from Fluency's other CloudTrail customers, they raised 3 alerts, all on roles.

The rest of the release covers what an attacker does with a working key, as emulated by Stratus Red Team, an open-source attack-emulation tool that publishes the CloudTrail events each of its techniques generates. The published logs of 36 of its AWS techniques (311 events) were replayed through Fluency's CloudTrail parser and every AWS rule, before and after this release:

OutcomeBeforeAfter
Incident on every occurrence36
Alert on every occurrence37
Alert when the attack crosses a threshold02
Alert on a new identity or network18
Alert only on first use by an identity910
Not detected203

The replay also found a gap in an existing rule: refused EC2 calls were not recognized as access denied. AWS_Unauthorized_API_Call is fixed in this release. Each rule was also measured against 30 days of customer CloudTrail before release, and routine sources were tuned out: AWS's own automation, deployment pipelines, Kubernetes node launches and instance agents. The GuardDuty rules were tested on real and simulated GuardDuty findings at each severity.

New detections​

"Incident" means the rule alerts at high severity and high confidence on every match, so a single match opens an incident. "First time in 30 days" rules report an identity once, the first time it does the thing in 30 days; repeats by the same identity are learned.

Stolen access keys

IDRuleReleasedSeverityFires when
102228AWS_Principal_Recon_Multi_ServiceNov 15IncidentAn IAM user's access key or a role calls GetCallerIdentity for the first time in 30 days, and within the hour is refused two or more APIs, in two or more services, that it has not been refused in 30 days: someone is finding out what a stolen key can reach.
102227AWS_Principal_Recon_New_Caller_IdentityNov 15HighThe same identity check, followed within the hour by one newly refused API.
102223AWS_Access_Keys_Burst_From_IPNov 14HighOne public address calls AWS with the long-term access keys of more than four different IAM users within an hour, successfully or not, across every AWS account that sends CloudTrail to the instance. It alerts when the count is reached, not on each call.

Two context rules feed the recon rules and raise nothing themselves: AWS_Principal_Caller_Identity (102225) records successful GetCallerIdentity calls, and AWS_Principal_Refused (102226) records refused calls, both from an SDK or the CLI.

Logging and guardrails

IDRuleReleasedSeverityFires when
102229AWS_Account_Guardrail_BypassNov 15IncidentAn account tries to leave its AWS Organization, which drops the organization's service control policies and central logging, or EC2 serial console access is turned on for the account. Refused attempts are included.
102230AWS_CloudTrail_Event_Selectors_ChangedNov 15HighThe events a CloudTrail trail records are changed (event selectors, advanced event selectors or Insights selectors): a way to stop logging management or data events while the trail still looks enabled.

Persistence and access to instances

IDRuleReleasedSeverityFires when
102232AWS_Roles_Anywhere_Trust_CreatedNov 15HighAn IAM Roles Anywhere trust anchor or profile is created, letting a workload outside AWS with a certificate from the anchored authority obtain role credentials: long-lived access that survives key rotation.
102239AWS_Federation_Token_IAM_UserNov 16HighAn IAM user requests a federation token (GetFederationToken) for the first time in 30 days. The temporary credentials or console session it returns outlive the user's key being disabled.
102237AWS_Lambda_Public_Invoke_PermissionNov 16HighA Lambda function's resource policy lets any principal (*) invoke it: a backdoor that survives credential rotation.
102238AWS_Lambda_Code_Updated_New_PrincipalNov 16HighA function's code is replaced by an identity that has not updated that function in 30 days, so the attacker's code runs with the function's role. Deployments through CloudFormation are excluded.
102235AWS_SSM_Remote_Command_New_PrincipalNov 16HighAn identity runs an SSM Run Command or starts a Session Manager session for the first time in 30 days, reaching instances without network access to them. Commands AWS runs for State Manager, Quick Setup or ECS, and AWS service-linked roles, are excluded.
102236AWS_Instance_Connect_Key_New_PrincipalNov 16HighAn identity pushes an SSH key to an instance through EC2 Instance Connect for the first time in 30 days.
102231AWS_Serial_Console_SSH_Key_SentNov 15HighAn SSH key is pushed to an instance's serial console, which reaches the instance even when its network access is blocked.

Secret harvesting

These rules count reads by people: IAM users, the root user and IAM Identity Center (SSO) sessions. Roles are excluded, because secret operators and pipelines read many secrets by design.

IDRuleReleasedSeverityFires when
102240AWS_Secrets_Manager_Fan_OutNov 16HighA person reads 10 or more distinct Secrets Manager secrets within an hour.
102241AWS_Secrets_Manager_Batch_Read_New_PrincipalNov 16HighA person reads secrets in bulk with BatchGetSecretValue for the first time in 30 days. One call returns up to 20 secrets.
102242AWS_SSM_Parameter_Fan_OutNov 16HighA person reads 10 or more distinct SSM parameters one at a time (GetParameter) within an hour.
102243AWS_SSM_Parameters_Batch_Fan_OutNov 16HighA person reads 10 or more distinct SSM parameters through GetParameters within an hour; each name in a call counts.

Resource abuse

IDRuleReleasedSeverityFires when
102233AWS_Bedrock_Model_Access_EnabledNov 15HighAccess to Amazon Bedrock foundation models is requested or granted for the account, the first step of model abuse with stolen keys.
102234AWS_Accelerator_Instance_New_PrincipalNov 15HighAn identity launches GPU, machine-learning accelerator, FPGA or bare-metal instances for the first time in 30 days, as stolen credentials are used for cryptomining and model workloads. Dry runs are ignored.

Amazon GuardDuty

IDRuleReleasedSeverityFires when
102244AWS_GuardDuty_Critical_FindingNov 16IncidentGuardDuty raises a critical finding (severity 9 to 10).
102245AWS_GuardDuty_High_FindingNov 16HighGuardDuty raises a high finding (severity 7 to 8.9), including stolen instance credentials used from another AWS account.
102246AWS_GuardDuty_Medium_FindingNov 16MediumGuardDuty raises a medium finding (severity 4 to 6.9).

The GuardDuty rules are keyed on the AWS account, so findings land on the account's timeline. Each GuardDuty update of a finding is reported again, and archived (suppressed) findings are ignored. The alert text gives the finding type, its severity and GuardDuty's title for it, and the alert's attributes name the affected resource and the caller. GuardDuty findings arrive about 25 to 40 minutes after the activity starts.

Improved detections​

IDRuleSeverityWhat changed
102096AWS_Security_Monitoring_DisabledIncidentNow also fires when Route 53 Resolver DNS query logging is deleted or detached from a VPC, and when Amazon Bedrock model-invocation logging is deleted. It already covered a GuardDuty detector deleted or the account detached from its GuardDuty administrator, VPC flow logs deleted, and the AWS Config recorder stopped or deleted.
100116AWS_Unauthorized_API_CallFirst useNow also recognizes EC2's refusals (Client.UnauthorizedOperation), such as a denied attempt to read an instance's Windows password. It alerts when an identity is refused for the first time in 30 days, or is refused an API or a service new to it.

Stopping or deleting a trail is reported by the existing rule AWS_Cloudtrail_Stopped.

What the rules do not cover​

  • Sharing an AMI, an RDS snapshot or an EBS volume with one outside account: the three Stratus Red Team techniques still undetected. Making a snapshot or an AMI public is reported by existing rules.
  • Reading SSM parameters by path (GetParametersByPath).
  • Stolen instance credentials used from another EC2 instance in the same region, which CloudTrail alone does not reliably show. GuardDuty reports it (InstanceCredentialExfiltration.InsideAWS), and AWS_GuardDuty_High_Finding turns that finding into an alert.
  • For the recon rules: calls from the AWS console, by AWS services and by IAM Identity Center permission-set roles. The burst rule counts calls from public addresses only.
  • Secret and parameter reads by roles.
  • Accelerator instances whose type comes only from a launch template.
  • Low-severity GuardDuty findings (1 to 3.9).

Triage guidance​

A stolen-key alert (AWS_Principal_Recon_Multi_Service, AWS_Principal_Recon_New_Caller_Identity, AWS_Access_Keys_Burst_From_IP). Treat an incident from AWS_Principal_Recon_Multi_Service as urgent: it is rare in normal operation, and in the incident behind it the attacker was testing keys in bulk.

  1. Check where the key was used. Compare the address and user agent in the alert with where the key or role normally runs.
  2. Contain. If the use is not expected, deactivate or rotate the key. For the burst rule, disable or rotate every key listed.
  3. Find the source. Find where the key was stored (code, backups, CI variables, a laptop) and which other keys were kept with it.
  4. Review what worked. Search CloudTrail for what the key did successfully in the same hours, and look for persistence: new IAM users and access keys, federation tokens, Roles Anywhere trust anchors, Lambda changes.

A logging or guardrail alert (AWS_Security_Monitoring_Disabled, AWS_Account_Guardrail_Bypass, AWS_CloudTrail_Event_Selectors_Changed). Confirm with the person named in the alert that the change was planned. If it was not, restore the control and treat the identity as compromised: these changes come before the activity the attacker wants unlogged.

A GuardDuty alert. Open the finding in the GuardDuty console for its full detail, then follow AWS's remediation for the finding type.

To find these alerts, search behavior events by rule name. The rules are also listed by name on the Behavior Rules page (v1: Behavior Rules).

References​