13

days of observed role assumption into customer accounts, 14 to 26 Oct 2026, per Wiz

100

passwords and keys read in about 7 minutes from three stores in one estate, per Sentra

0

write actions in the accounts Sentra investigated; everything was read, which is why it was quiet

1

trust policy condition, the caller's source IP, that would have blocked every role assumption Wiz saw

A vendor role you stopped using is a standing key

When you connect a SaaS vendor to your AWS account, you do not give it a password. You create an IAM role whose trust policy says the vendor's AWS account may assume it, and you hand over the role's name. From that moment the vendor holds a key to your account, and the key lives in the vendor's estate, not yours. On 9 Nov 2026 Wiz published what happens when that key is used by someone else. Working with Sentra and Mandiant, it found an attacker using IAM credentials from the AWS account Qubole's data platform uses to assume the roles customers had created for Qubole, environment after environment, between 14 and 26 Oct 2026. Every request carried the right External ID. Every request succeeded. Most of the roles had not been used for anything else all month.

That last fact is the finding. Many of the organisations hit had stopped using Qubole. The trust policy stayed. A role nobody used, with permissions nobody had reviewed since onboarding, sat waiting for whoever held the vendor's credentials. Sentra, which spotted the campaign first, puts it in one line: every vendor you have ever connected to your cloud left a door behind. On cloud engagements the roles for vendors the client has moved on from are nearly always still there.

The second finding is about the control everyone had. The External ID condition did exactly what AWS designed it to do, and it did not matter, because it was never designed for this. It does nothing when the vendor's own credentials walk out of the door. The condition that would have stopped this, Wiz says plainly, is a check on where the call came from. One line of policy, present on almost no third-party role we review, would have rejected every assumption Wiz observed. Who is calling was answered correctly in every one of those requests. Where from was never asked.

What Wiz, Sentra and Mandiant disclosed

We keep to the report's words. Wiz observed a threat actor using IAM credentials from an AWS account associated with Qubole between 14 and 26 Oct 2026, 13 days of observed activity, to assume IAM roles that customers had created to trust Qubole's account. Inside multiple victim environments it enumerated resources, collected configuration and secrets, accessed S3 data and validated the credentials it found. The calls came from AWS account 805246085872, which Wiz observes Qubole's platform using. The first, on 14 Oct, came from a Mullvad VPN address and an IAM user Wiz has seen in no other activity. From 15 Oct most came from a rented OVH server. On 18 Oct a second IAM user from the same account joined in, one that also carries legitimate platform traffic from AWS infrastructure.

Two details decide the shape of the story. Every AssumeRole request Wiz attributed to the threat actor included an External ID, and every one succeeded. And most of the roles were not otherwise in use: in a majority of the environments Wiz observed, the attacker's requests were the only AssumeRole activity from the vendor account in October. Sentra, which found the activity across its own customers and brought it to Wiz, says the roles had been dormant since the spring. Sentra counts dozens of affected Qubole customers; Wiz says multiple and declined to give The Register a count.

What the attacker read is the part that reaches past AWS. In one estate Sentra describes, about 100 passwords and keys were read in 7 minutes from three stores, Secrets Manager, SSM Parameter Store and Lambda environment variables, with EC2 user data scraped as well, and thousands more credential records sat inside the downloaded files. Wiz saw the attacker run TruffleHog against what it found: GetCallerIdentity with discovered AWS keys, sign-ins as Entra ID service principals with discovered client secrets, OAuth token requests with discovered Okta client credentials. Those were the victims' credentials, not the vendor's. Then it downloaded whatever S3 data each role could reach, in some cases entire buckets in one session. Sentra counted 0 write actions. Nothing broke, so nobody noticed for weeks.

Qubole cross-account role abuse, Wiz Research, 9 Nov 2026 High
  • Vector //

    credentials from the vendor's AWS account, used to assume customers' integration roles; no software vulnerability
  • Window //

    14 to 26 Oct 2026; a separate, unlinked set of activity against customer-owned access keys ran 8 to 11 Oct
  • Came from //

    Mullvad VPN exits and an OVH server; all legitimate platform traffic Wiz observed came from AWS infrastructure
  • Got past //

    the External ID condition, present and correct on every request
  • Read //

    Lambda environment variables, Secrets Manager secrets, SSM parameters, EC2 user data, S3 objects up to whole buckets
  • Validated //

    the victims' AWS keys, Entra ID client secrets and Okta client credentials, with TruffleHog
  • Victims //

    dozens of Qubole customers per Sentra; multiple per Wiz, no count given
  • AWS //

    services not compromised and operated as designed, per its statement of 10 Nov; Qubole had not commented

Wiz has not attributed the campaign and says the targeting and theft appear opportunistic. AWS's statement to The Register says its services were not compromised and operated as designed, which is true and is also the point: the attacker did what the customers' own trust policies allowed. Qubole did not respond to The Register. We made the general case in February that a trusted third party is compromised by design; this is the cloud-native version, with CloudTrail as the witness.

How a vendor credential becomes your Okta tokens

The chain below is built from Wiz's observations and Sentra's account, at the level of what each stage achieved. There is no exploit in it; every call is one the assumed role was permitted to make. The expensive step was the first, obtaining the vendor's credentials. Everything after it was free.

Figure 01

One vendor key, every customer door

  1. 01

    Hold //

    The attacker has IAM credentials from the vendor's AWS account and the External IDs the vendor stores for its customers.

  2. 02

    Assume //

    From a VPN exit or a rented server it calls AssumeRole on each customer's integration role. Account and External ID both check out. Dormant roles answer like live ones.

  3. 03

    Map //

    It lists buckets, databases, clusters, instances, roles and keys to learn what the role can reach.

  4. 04

    Harvest //

    It reads Lambda environment variables, Secrets Manager secrets, SSM parameters and EC2 user data, then validates the AWS keys, Entra ID secrets and Okta credentials it finds.

  5. 05

    Take //

    It downloads whatever S3 data the role can read, sometimes entire buckets, then moves to the next customer. About a second per role.

Result //

One set of vendor credentials became read access to dozens of estates and fresh identity provider credentials from each.

Stages two and four decide it. The role still trusted the vendor, and the role could still read the secrets.

Stage four is where an AWS incident stops being an AWS incident. Integration roles get wide read access for convenience, and secret stores are where the rest of the estate's keys live. The Entra ID client secret for a sync job, the Okta credentials for a provisioning connector, the database password in a Lambda's environment: each is a door into a system that never heard of the vendor. When TruffleHog signed in as Entra ID service principals and requested Okta tokens, the attacker left the AWS logs behind and walked into identity providers looking like the service it was impersonating. A response plan that stops at AWS stops too early.

Why the External ID did not help

The External ID is the control every reader of this report had, so be precise about what it is. The AWS documentation says its primary function is to address and prevent the confused deputy problem: another customer of the vendor learns the name of your role, which is not a secret, and tells the vendor that your role is theirs, and the vendor in good faith assumes your role on the other customer's behalf. The External ID stops that: a unique value per customer, generated by the vendor, that your trust policy alone accepts. It protects you from the vendor being tricked.

It does not protect you from the vendor being robbed. An attacker holding the vendor's credentials also holds the vendor's External IDs, because the vendor must store them to do its job. Sentra reports the attacker pulling the vendor's own tokens and External IDs out of victims' Secrets Manager stores as it went. Wiz's advice is to treat the External ID as non-secret: it is logged in plaintext in CloudTrail. In Sentra's phrase, as far as AWS could tell, the attacker was Qubole.

What would have worked is the condition that asks where the call came from. Every malicious request arrived from VPN exits and a hosting provider; every legitimate one from AWS infrastructure. A trust policy that names the vendor's specific IAM principal instead of the whole account, and adds an aws:SourceIp or aws:SourceVpce condition for the vendor's documented ranges, rejects a valid External ID from an unexpected network. Wiz's words: a source IP condition alone would have blocked every role assumption we observed. The cost is that the vendor has to publish its egress ranges, and most do not.

Figure 02

The trust policy most customers had, and the one that would have held

WHAT THE VICTIMS HAD

  1. Principal: the vendor's whole account, :root

  2. Condition: sts:ExternalId, a value the vendor stores

  3. No condition on the caller's network

  4. Permissions: broad read, including secret stores

  5. Still in place months after the last legitimate use

Answers who is calling. Never asks where from.

WHAT WOULD HAVE HELD

  1. Principal: the specific IAM principal the vendor uses

  2. Condition: sts:ExternalId, distinct per role

  3. Condition: aws:SourceIp or aws:SourceVpce in the vendor's published ranges

  4. Permissions: only what the vendor documents, no secret stores

  5. Deleted the week the contract ended

Per Wiz, the network condition alone would have stopped every assumption it saw.

Both policies are valid AWS. Only one of them assumes the vendor can be compromised.

How to hunt for it in CloudTrail

Wiz's hunting guidance is specific to this campaign, and it generalises. For Qubole customers: review CloudTrail from 1 Oct 2026 onward in every account that holds an integration role, for AssumeRole events where the calling account is 805246085872 and the source address is not an AWS address. For every role session found, review everything it did afterwards, especially in Secrets Manager, SSM Parameter Store, Lambda and S3, rotate everything the role could read, and revoke its active sessions. Wiz's warning matters: rotating a credential does not end temporary sessions already issued. We wrote about the same gap in tokens that survive a password reset on the Microsoft side.

The general rule is the one Wiz calls a high-signal detection: a vendor account assuming one of your roles from a network that vendor has never used. In this campaign it would have fired on day one. The Sigma rule below is the simplest version. Replace the account list with every third-party account your trust policies name, and the network list with each vendor's published egress ranges; a vendor that cannot give you ranges is a finding on its own.

Figure 03

A trusted vendor account assumes your role from outside the vendor's network

Sigma

title: Third-party AWS account assumes an integration role from an unexpected network
status: experimental
description: An sts:AssumeRole into one of your roles by an outside AWS
  account your trust policies name, from a source address outside that
  vendor's published egress ranges. Replace the account ids and ranges.
logsource:
  product: aws
  service: cloudtrail
detection:
  selection:
    eventSource: 'sts.amazonaws.com'
    eventName: 'AssumeRole'
    userIdentity.accountId:
      - '805246085872'
      - '111122223333'
  filter_vendor_networks:
    sourceIPAddress|cidr:
      - '203.0.113.0/24'
  filter_aws_services:
    sourceIPAddress|endswith: '.amazonaws.com'
  condition: selection and not 1 of filter_*
falsepositives:
  - A vendor that has moved or not published its egress ranges
level: high
A starting point to tune against your own telemetry, not a production rule. The second account id and the address range are documentation placeholders; the first is the vendor account named in Wiz's report.

Two logging gaps shaped this incident and will shape yours. CloudTrail management events record the role assumption and the bucket listing, not the object reads that make up the theft; you need S3 data events or server access logs on the buckets that matter, and Wiz reports that in several environments missing logs meant responders could not see which objects were read. Sentra reconstructed part of the picture from KMS decrypt records; objects under default encryption left no trail. The other gap is coverage: only an organisation trail across every account and region puts the account holding a forgotten role inside your search. Our CloudTrail and GuardDuty evidence review walks through what each AWS action leaves behind.

How we test third-party trust on an engagement

On a cloud engagement we read every role trust policy in the estate before we touch anything else, because that is where the account's outside doors are written down. We look for three things: principals that name an outside account, especially as :root, which trusts every identity in that account at once; External ID conditions that are missing, shared across roles, or treated as the only control; and no condition on where the call may come from. Our AWS cross-account role trust policy review is that method written down, and the AWS Policy Checker flags cross-account principals in a pasted trust policy in seconds.

Then we ask when each trusted role was last assumed and from where. CloudTrail sorts the roles into three piles: in use by the vendor from the vendor's networks, in use from somewhere odd, and not in use at all. The third pile becomes this incident, and on most engagements it is not empty: a data platform trialled two years ago, a cost tool whose contract lapsed. We report every dormant external trust as a finding regardless of its permissions, because permissions can be widened by anyone who can edit the role, and the trust is what lets an outsider arrive. Our cloud persistence audit covers the same ground as a check for footholds that outlive a credential reset.

Finally we follow what an assumed vendor role could read. With the client's integration role assumed under its own account, we list which Secrets Manager secrets, SSM parameters and Lambda configurations it can see, by name only, and never read a value. A secret named after an identity provider or a CI system tells the report what an attacker holding the vendor's key would walk away with. Our guides to secrets in Lambda configuration and user data and to Secrets Manager and KMS key policies show how without touching the data. The finding writes itself when a data platform role can read the Okta client credentials for the whole organisation. Nobody granted that on purpose. It came with the managed policy.

What is still coming

Expect the question of how the credentials left Qubole's account to stay open. No published source answers it, Qubole had not commented as we published, and The Register's wording, compromised credentials, is an inference rather than a vendor statement. The lesson holds either way: a credential the vendor holds for you can only be protected by the vendor, and your trust policy is the only part of the arrangement you control.

Expect more from the second thread in Wiz's report. From 8 to 11 Oct an actor tested a batch of customer-owned AWS access keys that Wiz believes were created for Qubole integrations, all within one hour, and in a small number of cases went on to compromise the environment. Wiz could not link it to the role assumption campaign. Two sets of Qubole-related credentials tested a week apart usually share one explanation.

Expect the method to be reused against other vendors, because the shape is generic. Every SaaS platform that operates inside customer accounts holds principals that are, in Wiz's phrase, effectively credentials to every customer environment at once. The mitigations Wiz addresses to those providers, short-lived workload credentials instead of long-lived IAM user keys, source conditions on their own principals, published egress ranges, are a fair due diligence list for any vendor you are about to hand a role. The bootable image Wiz found on the attacker's server, built to phone home for 90 minutes and reboot, has no confirmed deployments. None of that changes what to do this week: find the doors you forgot and close them.

What to do today

  1. List every IAM role whose trust policy names an outside AWS account, in every account and region. Record the vendor, the last AssumeRole date and the permissions attached.

  2. Delete the roles for vendors you no longer use. Not disable, not watch: delete, or remove the vendor account from the trust policy. Dormant roles were the majority of what this attacker used.

  3. Add a network condition to every remaining third-party trust policy. Narrow the principal from :root to the vendor's named principal where supported, and add aws:SourceIp or aws:SourceVpce for the vendor's published ranges. Ask vendors that cannot provide ranges to start.

  4. Cut vendor roles back to what the vendor documents, and out of the secret stores. Secrets Manager, SSM Parameter Store and Lambda configuration reads were where this attacker found its next set of keys.

  5. If you ever integrated with Qubole, run Wiz's hunt now. CloudTrail from 1 Oct 2026, AssumeRole from account 805246085872 outside AWS networks, then every action from those sessions. Rotate, revoke sessions, and check Entra ID and Okta sign-in logs for the TruffleHog user agent.

  6. Turn on S3 data events for sensitive buckets and alert on vendor role assumption from new networks. The Sigma rule above is a starting point. Without data events you will know a bucket was listed and never know what left it.