What One Laptop Can Reach in Your AWS Account: 14 Checks After October's Incidents

Last week I shared the security incidents I tracked in October. There were eight:

  • PHP2Shell: two bugs in PHP itself, CVE-2026-109618 and CVE-2026-109619, fixed on October 21.
  • Railway: unauthorized access to systems that store customer environment variables.
  • OpenCode: a flaw that a malicious MCP server could use on Windows.
  • Binance: about $6.3 billion moved out, by Binance's own estimate.
  • Polymarket: a vendor script on the site swapped for a wallet drainer.
  • GitHub Actions: the GhostAction campaign, which pushed fake "security audit" workflows.
  • SoftBank: an unauthorized access attempt that took its customer web portals offline.
  • The Cursor marketplace: a tampered Claude Code extension, version 2.1.313, served on October 29.

To be fair, only some of them were a breach of the company itself. PHP had two bugs that touch nearly every request, OpenCode had a flaw in the tool, and the GitHub Actions campaign ran on developer tokens stolen from infostealer logs.

What stayed with me is where they started. At least five of the eight came in through something the team trusted: a DevOps engineer's laptop at Binance (Hackread), stolen tokens on GitHub, a vendor's monitoring script at Polymarket, a marketplace at Cursor, and an old dependency in OpenCode. Railway asked customers to revoke and replace sensitive credentials stored on Railway before October 21 (Railway changelog). In the GitHub Actions campaign, each repository owner had to remove the fake workflow and rotate their own secrets. The October variant checked out repositories with their full git history, and the secrets it captured included AWS keys (breached.company).

The one I worry about most is Binance. One staff laptop could reach a container that could move money. So I asked the same question about our own AWS accounts, and I think every team should ask it too: what could one laptop, or one key, reach today?

Where we start from

I have seen what one key does. A forgotten access key, from an engineer who had left months before, got a client account suspended. The suspension was the short part. The week after, finding out what else was still out there, was the long part.

This is how our team at INNOMIZE sets up AWS today:

  • No IAM users. People sign in through IAM Identity Center, including the admin.
  • No stored AWS keys in CI. GitHub Actions gets short-lived credentials through OIDC.
  • AWS Organizations with Control Tower, plus infrastructure as code that creates accounts and applies our SCPs.
  • Guardrails we run: region deny, protection for CloudTrail and GuardDuty, and a locked-down root user (MFA, own email, password in a password manager, never used for daily work).

The checks below are read-only unless I say otherwise. The ones that need AWS Organizations are marked.

Part 1: what one laptop or one key can reach

1. Static keys on the laptop

Open ~/.aws/credentials. Any aws_access_key_id in that file is a key that a stolen laptop carries, and it does not expire until someone deletes it. An Identity Center session does expire. AWS CLI sessions follow the access portal session length, which you can set from 15 minutes to 90 days, according to the AWS Security Blog. Permission set roles have their own limit of up to 12 hours, and AWS notes that the two can combine into a CLI session of up to 32 hours (session duration considerations). Know your value. A long session is a long window for a stolen laptop.

2. IAM users and their keys

Run aws iam generate-credential-report, then aws iam get-credential-report. You can generate the report at most once every four hours (credential reports). Look at three columns: access_key_1_active and access_key_2_active for any active key, access_key_1_last_used_date for keys nobody uses, and mfa_active for console users without MFA.

AWS Security Hub sets two limits I find useful as a bar: active keys rotated within 90 days (IAM.3), and credentials unused for 45 days removed (IAM.22). A key of someone who has left usually fails one or both.

With no IAM users, the report should come back almost empty. For me, that is the point of having none: nothing to rotate, nothing to forget.

3. The root user

Run aws iam get-account-summary. AccountMFAEnabled should be 1, which means root has an MFA device, unless you removed the root credentials centrally (see below), which also deactivates MFA. AccountAccessKeysPresent should be 0, which means root has no access key. AWS recommends deleting root access keys and turning on root MFA (AWS Security Blog).

In an organization, AWS also offers centralized root access: you can delete root credentials in member accounts, and new accounts created in the organization start without them. Existing accounts do not change until you delete their credentials one by one (root user docs).

4. MFA in Identity Center

In Identity Center, go to Settings, then Authentication. The default prompts for MFA every time a user signs in. The other mode, "only when their sign-in context changes", trusts a device after the first prompt, and AWS describes it as less secure (Identity Center MFA). If you use an external identity provider, MFA lives there, and you check it there.

5. AWS keys in CI secrets

Search your GitHub secrets for AWS_SECRET_ACCESS_KEY, the conventional name, and for any other secret that holds an AWS key. OIDC removes the stored key: the job needs id-token: write, and aws-actions/configure-aws-credentials exchanges the GitHub token for temporary credentials through role-to-assume.

The trust policy decides who can use that role. Check token.actions.githubusercontent.com:sub and pin it to one repository and one branch or environment, with aud set to sts.amazonaws.com. A wildcard such as repo:org/repo:* lets every branch in (GitHub docs). For repositories created after July 15, 2026, or ones that opted in, the sub claim carries immutable owner and repository IDs, so the trust policy has to match that format.

6. Shell access into production

Who can run ecs:ExecuteCommand or ssm:StartSession against production? Those two actions open a shell into a container or an instance. Session Manager access can be scoped by resource tag (Session Manager sample policies), and ECS Exec by cluster, task tags and container name (ECS Exec docs). The same page recommends denying ssm:StartSession directly on ECS tasks, because sessions started outside ECS Exec might not be logged.

At Binance, the early finding was a laptop that reached a service container that could submit withdrawals. Binance has not published how the attacker got from the container to signed withdrawals. For me, this is the Binance question, and I would look at it early. I think shell access is easy to grant during an incident and easy to forget after.

Part 2: will you know when something goes wrong

7. The leaked-key quarantine

When AWS finds an IAM user's key exposed in public, it attaches the managed policy AWSCompromisedKeyQuarantineV3 to that user. In a Unit 42 test on December 19, 2025, it happened within 10 seconds. CloudTrail logs it as AttachUserPolicy, with nothing that marks it as an AWS action. The policy limits some actions and does not disable the key, so you still deactivate and delete the key yourself.

An alert on that AttachUserPolicy event tells you within minutes. Without it, you may first hear from a suspension notice.

8. CloudTrail across the organization

Run aws cloudtrail describe-trails. You want a trail with IsMultiRegionTrail and IsOrganizationTrail set to true. The command includes organization trails by default; if someone passes --no-include-shadow-trails, a member account will not see them (describe-trails).

9. GuardDuty in every Region you use

Run aws guardduty list-detectors, then aws guardduty get-detector --detector-id <id>. The status should be ENABLED (get-detector). Detectors are per Region, so check each one you use.

10. What is shared outside the account

IAM Access Analyzer's external access analysis finds S3 buckets, roles and other resources that are shared outside the account or the organization. The external access analysis has no charge. The separate unused access analysis costs $0.20 per IAM role or user per month, and AWS's own example of 70 roles and users comes to $14 a month (pricing).

11. S3 Block Public Access at account level

Run aws s3control get-public-access-block --account-id <id>. All four settings should be true. The account setting can inherit from an organization-level policy (get-public-access-block).

Part 3: guardrails that hold when a check is missed (AWS Organizations)

Checks find problems. Guardrails stop some of them from happening. We use AWS Organizations with Control Tower, and our infrastructure code creates accounts and applies our SCPs, so accounts created this way get the same SCPs.

From the AWS SCP guide:

  • An SCP never grants a permission. It sets the maximum that IAM users and roles in member accounts can have, including the member account's root user.
  • SCPs do not affect the management account, and they do not affect service-linked roles.
  • Do not remove the default FullAWSAccess policy unless you replace it, or every action in the member accounts fails.
  • AWS strongly recommends testing an SCP in a separate OU, moving accounts in a few at a time, before you attach it to the root.

12. Region deny (we run this)

Control Tower has a built-in Region deny control. It denies requests to Regions you have not selected for governance, exempts some global services such as IAM and AWS Organizations, and cannot deny your home Region. Before you turn it on, make sure nothing you need runs in the Regions it will block, because you lose access to those resources (Configure the Region deny control). SCPs do not affect the management account (see above), so it can still reach the blocked Regions.

Without Control Tower, AWS's example SCP does the same with aws:RequestedRegion and a NotAction list of global services. Global services run from us-east-1, so keep us-east-1 approved if you rely on them. The condition checks the endpoint that was called, not every effect of the request.

13. Protect the detection layer (we run this)

A detection layer that any administrator can turn off is not much of a layer. Our SCPs deny the actions that turn off CloudTrail and GuardDuty in member accounts. AWS Managed Services publishes curated policies of the same kind for CloudTrail, GuardDuty and AWS Config. AMS Advanced ends support in June 2027, but the policies still work as examples. AWS's general examples include a deny on organizations:LeaveOrganization, so an account cannot leave and take itself out of every guardrail at once.

Keep the deny narrow. A rule that denies all of cloudtrail:* except for one role will break daily work for every other role.

14. The root user

This is the order we follow for every account. First, secure root: its own email address, a strong password kept in 1Password, and MFA. Then create an admin user in IAM Identity Center and do all setup from there. After that, nobody uses root, and everyone else signs in through Identity Center too. This matches AWS's current setup guides, which create the admin user in Identity Center and not as an IAM user, because IAM users carry long-term credentials (AWS root user best practices). See check 3 for what to look at. An SCP can also deny actions when the caller is the root user of a member account.

What AWS offers that we have not run

We have not used these ourselves, so this section only describes what they are.

  • An SCP that blocks IAM users and access keys, by denying iam:CreateUser and iam:CreateAccessKey with an exception for approved admin roles. We did not find an official AWS example. Control Tower has a related control that denies access key creation for the root user only (Control Tower preventive controls).
  • Resource control policies (RCPs), launched in November 2024. An SCP limits what your own users and roles can do. An RCP limits what anyone can do to resources in your organization, including outside principals that a wrong resource policy lets in (announcement).
  • Declarative policies, which set an EC2 baseline across the organization: IMDSv2 required, EC2 serial console access, block public access for snapshots and AMIs, and allowed AMIs. AWS says to confirm that no instance still makes IMDSv1 calls before you require IMDSv2 (declarative policy syntax).

On limits: AWS raised the SCP quotas on May 15, 2026, with no action needed. An SCP can now be 10,240 characters, up from 5,120, and you can attach 10 SCPs to each root, OU or account, up from 5. Older guides still quote the old numbers.

Closing

None of these checks is new. For me, October is a reminder of where they matter: most of this month's incidents started on a laptop, a token, a vendor script or a marketplace, and then reached whatever that one thing could reach.

If you only have time for two this week, I would start with check 1 and check 6: the keys on your laptops, and who can open a shell into production. Then look at the guardrails that hold when one of those checks is missed.

Nov 02, 2026

Similar articles

Free local AWS emulators in 2026

Free Local AWS Emulators in 2026: What Each One Runs and Where Each One Stops

LocalStack's free edition ended in March 2026, and on 11 November AWS shipped its own emulator. Where each local option runs, what it costs and where it stops.

Lambda in 2026, choosing compute, execution mode and workflow

AWS Lambda in 2026: Choosing Compute, Execution Mode and Workflow

Lambda now has three compute primitives, two compute types for Event Functions, several execution modes and three ways to run a workflow. Two comparison tables, the limits that decide each choice, and a simulated cost example for durable functions and Step Functions.

AWS Lambda in 2026: The Changes You Cannot Miss

Two new compute primitives, a 90-minute timeout on Managed Instances, and durable functions that accept your own SDK and key. What changed in Lambda this year, what the limits mean for your design, and where the old rules no longer hold.