AWS Builder Center

Bedrock LLMjacking, Part 1: Incident Response for AWS Partners

by Guilherme Ramalho and Carlos Felicio - Series · Bedrock LLMjacking Playbook for AWS Partners

Series: Bedrock LLMjacking, Part 2: Prevention and Governance for AWS Partners (1 article)

  1. 1
    Bedrock LLMjacking, Part 1: Incident Response for AWS Partners This article
Senior Partner TAM at AWS LATAM, 30 yrs in tech, now help partners with Microsoft & hybrid workloads



🎯 What LLMjacking is, and why it matters to partners

Amazon Bedrock gives access to foundation models through one API. In this attack, someone who has already compromised an AWS identity that may invoke models sends prompts to the models in the victim's account, resells that access, and the compromised account pays for the usage. The  Sysdig Threat Research Team named it LLMjacking  in May 2024. The  AWS Threat Technique Catalog  tracks it as  T1496.A007: Cloud Service Hijacking - Bedrock LLM Abuse  (Impact, TA0040).





Figure 1. How LLMjacking unfolds: stolen credential → model invocations → resold access → the victim's bill.

🔑 Attack prerequisites

The catalog's prerequisite: the actor already controls an AWS identity (user or role) allowed to call Bedrock. So Bedrock abuse is almost always the result of an earlier compromise, typically:

  • Leaked IAM credentials in code, repositories, logs, or CI/CD environment variables ( T1552 ).
  • Leaked  Bedrock API keys . Long-term keys are IAM service-specific credentials, not  AKIA  keys: an access-key inventory doesn't find them.
  • Credentials the attacker created after initial access ( T1098.001 ): access keys, API keys, roles with external trust.
  • A misused role or federated access, including instance credentials stolen through the metadata service.
  • A partner credential (automation role, tool key, pipeline) reaching many customers: the blast radius is several customers at once ( A1 ).





🚨 Signals and triggers

Most cases surface as a billing spike, not an alert, and many accounts lack GuardDuty AI Protection. Start with cost, mind its latency, confirm in CloudTrail.

Signal
Source
What to look for
Bedrock cost spike
Cost Explorer, Cost Anomaly Detection, Budgets
Sudden spend, often off-hours. Up to ~24 h behind
AI abuse finding
 GuardDuty AI Protection 
 Impact:IAMUser/AnomalousModelInvocation ,  Impact:IAMUser/CostHarvesting  (Part 2)
Anomalous credential
 GuardDuty foundational 
e.g.  InstanceCredentialExfiltration.OutsideAWS 
Invocation volume
CloudTrail
 InvokeModel ,  Converse  and streaming variants;  CreateInference  on  bedrock-mantle  (data event)
Recon, key testing
CloudTrail
 ListFoundationModels ,  GetModelInvocationLoggingConfiguration , calls failing with  AccessDenied / ValidationException 
New credentials
CloudTrail
 CreateAccessKey ,  CreateServiceSpecificCredential ,  CreateLoginProfile 
Log tampering
CloudTrail
 DeleteModelInvocationLoggingConfiguration ,  StopLogging ,  DeleteTrail ,  PutEventSelectors 
Marketplace
CloudTrail
 Subscribe  (third-party model);  CreateMarketplaceModelEndpoint  (adds SageMaker AI compute)
Quota request
CloudTrail
 RequestServiceQuotaIncrease 
Unused Region
CloudTrail
 awsRegion  (source) the customer doesn't use; cross-Region inference can process elsewhere (A1)
Quarantine policy
IAM
  AWSCompromisedKeyQuarantineV3  
: AWS detected an exposed key; may explain a "spontaneous" drop


📧 Follow AWS Trust & Safety guidance. AWS emails an abuse notice to the account's contacts. Follow it fully:  without a response within 24 hours, AWS might block resources or suspend the account.  Reply with containment actions taken and keep the thread updated until done. Who receives and replies:  A5 . Exposed keys:  unauthorized activity in my AWS account .

A1 · Detection during the incident

Two naming levels: don't mix them up

To detect you filter by CloudTrail event name; to contain (Deny policy) you use the IAM action:
Operation
CloudTrail event (detect)
IAM action (Deny)
Invoke / stream
 InvokeModel ,  InvokeModelWithResponseStream 
same names,  bedrock: 
Converse / stream
 Converse ,  ConverseStream 
 bedrock:InvokeModel ,  bedrock:InvokeModelWithResponseStream 
OpenAI/Anthropic-compatible ( bedrock-mantle )
 CreateInference  (data event)
 bedrock-mantle:CreateInference 
Bedrock API key (bearer token)
The underlying event; on mantle,  callWithBearerToken = true 
 bedrock:  and  bedrock-mantle:CallWithBearerToken , plus the inference action
There is no  bedrock:Converse  action ( Service Authorization Reference ,  API key permissions ).

Quick triage: confirm usage in Cost Explorer

Console: Cost Explorer → Daily → Service = Amazon Bedrock → group by Usage type or Linked account.
aws ce get-cost-and-usage --region us-east-1 \
--time-period Start=[YYYY-MM-DD],End=[YYYY-MM-DD] \
--granularity DAILY --metrics UnblendedCost \
--filter '{"Dimensions":{"Key":"SERVICE","Values":["Amazon Bedrock"]}}' \
--group-by Type=DIMENSION,Key=USAGE_TYPE
# confirm the service name: aws ce get-dimension-values --dimension SERVICE --search-string Bedrock ...
On the payer, group by  LINKED_ACCOUNT  and check other customers sharing a partner credential or pipeline. Third-party models billed through AWS Marketplace appear under their own service names.






Figure 2. From signal to source credential.


CloudTrail: hunt the invocations

Calls to the  bedrock-runtime  endpoint ( InvokeModel ,  Converse , …) are  management events , recorded within minutes, unlike Cost Explorer. Use  Event History  (last 90 days per Region) or a dedicated trail.




aws cloudtrail lookup-events --region [region] \
--lookup-attributes AttributeKey=EventSource,AttributeValue=bedrock.amazonaws.com \
--start-time [YYYY-MM-DDThh:mm:ssZ] --end-time [YYYY-MM-DDThh:mm:ssZ]
# also: EventSource=aws-marketplace.amazonaws.com, EventName=RequestServiceQuotaIncrease, Username=[suspect]

 lookup-events  is regional: repeat in every enabled Region, or use an organization trail with Athena.

Goal
Lookup attribute
Value
All invocations
Event source
 bedrock.amazonaws.com 
A specific invocation
Event name
 InvokeModel ,  Converse , …
Third-party model subscription
Event source
 aws-marketplace.amazonaws.com 
Quota increase
Event name
 RequestServiceQuotaIncrease 
Activity of one principal
User name
 [suspect-user-or-role] 
aws cloudtrail lookup-events --region [region] \
--lookup-attributes AttributeKey=EventSource,AttributeValue=bedrock.amazonaws.com \
--start-time [YYYY-MM-DDThh:mm:ssZ] --end-time [YYYY-MM-DDThh:mm:ssZ]

 lookup-events  is regional and attackers spread calls across Regions: repeat it in every enabled Region, or use an organization trail with Athena.

Athena: triage by principal, IP, and Region, failed calls included. Attackers test keys first, so a burst of  AccessDenied / ValidationException  often comes before abuse; don't filter on success. The same SQL works in CloudTrail Lake against your event data store.
SELECT useridentity.arn AS principal, useridentity.accesskeyid AS access_key,
sourceipaddress AS src_ip, awsregion, eventsource, eventname, errorcode,
COUNT(*) AS calls, MIN(eventtime) AS first_seen, MAX(eventtime) AS last_seen
FROM [cloudtrail_table]
WHERE ((eventsource = 'bedrock.amazonaws.com'
AND eventname IN ('InvokeModel','InvokeModelWithResponseStream','Converse','ConverseStream',
'ListFoundationModels','GetModelInvocationLoggingConfiguration'))
OR (eventsource = 'bedrock-mantle.amazonaws.com' AND eventname = 'CreateInference'))
AND eventtime BETWEEN '[YYYY-MM-DD]' AND '[YYYY-MM-DD]'
GROUP BY 1,2,3,4,5,6,7
ORDER BY calls DESC;








The Marketplace vector

A recent pattern: the attacker enables models through AWS Marketplace before abusing them. Two paths:

  • Bedrock Marketplace:  CreateMarketplaceModelEndpoint  deploys the model on a SageMaker AI endpoint, so you pay  software and instance costs .

WHERE (eventsource = 'aws-marketplace.amazonaws.com' AND eventname IN ('Subscribe','ViewSubscriptions'))
OR (eventsource = 'bedrock.amazonaws.com' AND eventname = 'CreateMarketplaceModelEndpoint')
OR (eventsource = 'servicequotas.amazonaws.com' AND eventname = 'RequestServiceQuotaIncrease')
Not every model goes through AWS Marketplace; Amazon models and some others never generate  Subscribe .

About prompt content

If the customer didn't use Bedrock and the attacker started it,  model invocation logging  won't be on (it's off by default and doesn't backfill). CloudTrail gives you the fact of each invocation (who, when, where, which model), not the content. If logging was on and a  DeleteModelInvocationLoggingConfiguration  appears, treat it as tampering.

Trace the source credential

This is the step that really closes the incident: find which credential the attacker used and how they got it. Start from the invocation events and read  userIdentity :

SELECT eventtime, eventname,
useridentity.type AS identity_type,
useridentity.arn AS arn,
useridentity.accesskeyid AS access_key,
useridentity.sessioncontext.sessionissuer.arn AS source_role,
sourceipaddress AS src_ip, useragent
FROM [cloudtrail_table]
WHERE eventsource = 'bedrock.amazonaws.com'
AND (eventname LIKE 'Invoke%' OR eventname LIKE 'Converse%')
AND eventtime > '[YYYY-MM-DD]'
ORDER BY eventtime;



 userIdentity.type 
What it means / next step
 IAMUser  (key starts  AKIA )
Long-term key. Find where else it's used and look for a recent  CreateAccessKey . Deactivate it (A3 Step 3) and revoke sessions it already issued with  GetSessionToken  or  GetFederationToken .
 IAMUser  with a Bedrock API key
Long-term Bedrock API keys are tied to an IAM user. If the user's access keys are inactive or unused but calls continue, list its service-specific credentials and look for  CreateServiceSpecificCredential  (A3 Step 3).
 AssumedRole  (key starts  ASIA )
Temporary credentials. Use  sessionIssuer.arn  to find the role and trace the  AssumeRole  call: who, from which IP, with MFA? Revoke the role's sessions (A3 Step 3). Short-term Bedrock API keys derive from a session and stop working when it's revoked.
 AssumedRole  issued to an EC2 instance role
If used from outside that instance, suspect theft through the instance metadata service and investigate the instance.
 FederatedUser 
Session from  GetFederationToken . Find the IAM user that called it; revoking that user's older sessions cuts it (A3 Step 3).
 Root 
Critical: compromised root credentials.

Then look for the events that created the credential or came before the abuse:

SELECT eventtime, eventsource, eventname, useridentity.arn, sourceipaddress, errorcode
FROM [cloudtrail_table]
WHERE eventname IN (
-- credentials and sessions
'CreateAccessKey','CreateServiceSpecificCredential','CreateLoginProfile','UpdateLoginProfile',
'GetSessionToken','GetFederationToken','AssumeRole','CreateVirtualMFADevice',
-- persistence
'CreateUser','CreateRole','UpdateAssumeRolePolicy',
'AttachUserPolicy','PutUserPolicy','AttachRolePolicy','PutRolePolicy',
'CreateAccount','LeaveOrganization',
-- log tampering
'StopLogging','DeleteTrail','PutEventSelectors','DeleteModelInvocationLoggingConfiguration')
AND eventtime > '[YYYY-MM-DD]'
ORDER BY eventtime;



GuardDuty findings also name the principal; cross-check them with these results.

Confirm the invocations stopped

After containment, filter CloudTrail by the attacker's indicators from the containment time. Expected: no rows in both queries.
-- By access key
SELECT eventtime, eventname, sourceipaddress, awsregion
FROM [cloudtrail_table]
WHERE eventsource = 'bedrock.amazonaws.com'
AND useridentity.accesskeyid = '[suspect-AKIA-or-ASIA]'
AND eventtime > '[containment-time]'
ORDER BY eventtime DESC;

-- By source IP
SELECT eventtime, eventname, useridentity.arn
FROM [cloudtrail_table]
WHERE eventsource = 'bedrock.amazonaws.com'
AND sourceipaddress = '[attacker-ip]'
AND eventtime > '[containment-time]'
ORDER BY eventtime DESC;

Pay special attention to  UpdateAssumeRolePolicy  that adds trust to an external account, and to changes in IAM Identity Center permission sets. GuardDuty findings also name the principal; cross-check them with these results.


Is it a partner credential? Hunt across every managed account

Ask explicitly: does the compromised credential belong to the partner (automation role, management-tool key, partner pipeline)? If so, the incident isn't one customer's: sweep every account that principal can reach, not only the account that raised the alarm, and notify each affected customer.

With an organization trail and Athena (recommended):

SELECT recipientaccountid, awsregion,
useridentity.arn AS principal, useridentity.accesskeyid AS access_key,
eventsource, eventname, errorcode, COUNT(*) AS calls,
MIN(eventtime) AS first_seen, MAX(eventtime) AS last_seen
FROM [org_cloudtrail_table]
WHERE eventsource IN ('bedrock.amazonaws.com','bedrock-mantle.amazonaws.com')
AND eventtime > '[YYYY-MM-DDThh:mm:ssZ]'
GROUP BY 1,2,3,4,5,6,7
ORDER BY calls DESC;

Without an organization trail, loop over accounts and Regions with your IR role (read-only is enough):

for acct in $(cat accounts.txt); do
creds=$(aws sts assume-role --role-arn "arn:aws:iam::${acct}:role/[ir-readonly-role]" \
--role-session-name ir-hunt --query Credentials --output json)
export AWS_ACCESS_KEY_ID=$(echo "$creds" | jq -r .AccessKeyId)
export AWS_SECRET_ACCESS_KEY=$(echo "$creds" | jq -r .SecretAccessKey)
export AWS_SESSION_TOKEN=$(echo "$creds" | jq -r .SessionToken)
for r in $(aws ec2 describe-regions --query 'Regions[].RegionName' --output text); do
aws cloudtrail lookup-events --region "$r" \
--lookup-attributes AttributeKey=EventSource,AttributeValue=bedrock.amazonaws.com \
--start-time [YYYY-MM-DDThh:mm:ssZ] --max-items 500 \
--query 'Events[].[EventTime,EventName,Username]' --output text \
| sed "s/^/${acct} ${r} /"
done
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
done

At scale, GuardDuty with a delegated administrator (Part 2, B1-a) shows findings for all member accounts in one place.

Confirm the invocations stopped

After containment, filter CloudTrail by the attacker's indicators from the containment time. Attackers rotate IPs through proxies, so filter by principal ARN and key, and use the IP only as a supplement. Expected: no rows.

-- By principal and access key (primary check)
SELECT eventtime, eventsource, eventname, sourceipaddress, awsregion
FROM [cloudtrail_table]
WHERE eventsource IN ('bedrock.amazonaws.com','bedrock-mantle.amazonaws.com')
AND (useridentity.arn = '[compromised-principal-arn]'
OR useridentity.accesskeyid = '[suspect-AKIA-or-ASIA]')
AND eventtime > '[containment-time]'
ORDER BY eventtime DESC;

-- By source IP (supplementary)
SELECT eventtime, eventname, useridentity.arn
FROM [cloudtrail_table]
WHERE eventsource IN ('bedrock.amazonaws.com','bedrock-mantle.amazonaws.com')
AND sourceipaddress = '[attacker-ip]'
AND eventtime > '[containment-time]'
ORDER BY eventtime DESC;





A3 · Reactive playbook: commands and console






Figure 3. Containment order: evidence → credential → block → quotas → Marketplace → confirm.





Step 1: Triage, who and from where

aws sts get-caller-identity
aws cloudtrail lookup-events --region [region] \
--lookup-attributes AttributeKey=EventSource,AttributeValue=bedrock.amazonaws.com \
--start-time [YYYY-MM-DDThh:mm:ssZ] \
--query 'Events[].{t:EventTime,u:Username,n:EventName}' --output table


Step 2: Preserve evidence

  •  aws cloudtrail get-trail-status --name [trail] : if  StopLogging  appeared, restart logging and record it.
  • Export the A1 results; save the identity's policies ( list-attached-user-policies ,  list-user-policies , role equivalents), invocation logging config, and trail event selectors.
  • Record the time of every containment action.


Step 3: Contain the credential 🔴




a) IAM user access key: (Console: IAM → Users → Security credentials → Deactivate):

aws iam list-access-keys --user-name [user]
aws iam update-access-key --user-name [user] \
--access-key-id [suspect-AKIA] --status Inactive


b) Bedrock API keys (long-term). They're service-specific credentials; inventory them separately (Console: Security credentials → API keys for Amazon Bedrock):
# Inventory every user's Bedrock API keys
for u in $(aws iam list-users --query 'Users[].UserName' --output text); do
aws iam list-service-specific-credentials --user-name "$u" \
--service-name bedrock.amazonaws.com \
--query 'ServiceSpecificCredentials[].[UserName,ServiceSpecificCredentialId,Status,CreateDate]' \
--output text
done

# Deactivate the suspect key
aws iam update-service-specific-credential --user-name [user] \
--service-specific-credential-id [credential-id] --status Inactive

c) Sessions already issued. Deactivating a key does  not invalidate  temporary credentials from  GetSessionToken ,  GetFederationToken , or  AssumeRole . Attach  revoke-older-sessions.json  (Deny  *  when  aws:TokenIssueTime  is before now, UTC) to the user and every role it touched:
aws iam put-user-policy --user-name [compromised-user] \
--policy-name RevokeOlderSessions --policy-document file://revoke-older-sessions.json
aws iam put-role-policy --role-name [compromised-role] \
--policy-name AWSRevokeOlderSessions --policy-document file://revoke-older-sessions.json
For roles this equals IAM → Roles → Revoke sessions ( docs ). Short-term Bedrock API keys stop with the sessions.

Step 4: Block Bedrock 🔴

One account: attach  deny-bedrock-v2.json ; it blocks both endpoints and API-key use:
{ "Version": "2012-10-17", "Statement": [
{ "Sid": "DenyBedrockRuntimeInference", "Effect": "Deny", "Resource": "*",
"Action": ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream"] },
{ "Sid": "DenyBedrockMantleInference", "Effect": "Deny", "Resource": "*",
"Action": "bedrock-mantle:CreateInference" },
{ "Sid": "DenyBedrockApiKeyUse", "Effect": "Deny", "Resource": "*",
"Action": ["bedrock:CallWithBearerToken", "bedrock-mantle:CallWithBearerToken"] } ] }
aws iam put-user-policy --user-name [user] \
--policy-name DenyBedrockInference --policy-document file://deny-bedrock-v2.json
# role: aws iam put-role-policy --role-name [role] ...
Statement 1 also covers  Converse / ConverseStream ; denying  both  CallWithBearerToken   stops any API key of this identity. Console: Add permissions → Create inline policy → JSON. Organization or OU: the same statements as an SCP stop identities you haven't found yet, but only the management account owner can apply it (A4, Part 2).

Step 5: Check quota increases the attacker requested

aws service-quotas list-requested-service-quota-change-history --service-code bedrock --region [region] \
--query 'RequestedQuotas[].{Quota:QuotaName,Status:Status,Desired:DesiredValue,Case:CaseId}' --output table
Console: Service Quotas → Amazon Bedrock → Quota request history. Reply on the case of requests you didn't make; lowering an approved quota may need a support case.

Step 6: Clean up Marketplace artifacts 🔴

aws bedrock list-marketplace-model-endpoints --region [region]
aws bedrock delete-marketplace-model-endpoint --endpoint-arn [endpoint-arn] --region [region]
Subscriptions: AWS Marketplace → Manage subscriptions → Cancel. Check first that no legitimate workload uses the model.

Step 7: Confirm cessation

Run the A1 cessation query in every Region. Expected: no rows; metric and cost back to normal.

A4 · Delegated access: before acting in the customer's account

The first question: what may I do in the customer's account, under which authorization, with which role?
Partner model
Can apply an SCP?
Usually gets the notice and bill
Typical access
Resale (Solution Provider, Distribution, billing transfer)
Yes, if it holds the management account
The partner, or whoever is on the contacts
Management-account role plus member roles
Managed services / MSSP
No: use identity Deny policies
The customer
Cross-account role with  ExternalId 
One-off consulting
No
The customer
Temporary role for the engagement
What to agree on, ideally before any incident:
  1. Written authorization (email or ticket) for specific actions, and which ones you may take without waiting, since cost grows every hour.
  1. Scope: accounts, Regions, principals, and what's off-limits (deleting resources, touching logs).
  1. A dedicated break-glass IR role with MFA or  ExternalId  and short sessions.
  1. A record of every action (who, when, what, why); your IR role's CloudTrail is evidence.
  1. Plan B: if your role can't act (common for MSSPs), escalate to the account owner at once with the ready-to-run A3 command.
Suggested IR role permissions (adjust to the contract):
Read: cloudtrail:LookupEvents, iam:Get*, iam:List*, bedrock:Get*, bedrock:List*,
ce:GetCostAndUsage, guardduty:Get*, guardduty:List*,
servicequotas:Get*, servicequotas:List*, account:GetAlternateContact
Contain: iam:UpdateAccessKey, iam:UpdateServiceSpecificCredential,
iam:PutUserPolicy, iam:PutRolePolicy, iam:AttachUserPolicy, iam:AttachRolePolicy
Never: iam:Delete*, cloudtrail:StopLogging, cloudtrail:DeleteTrail,
bedrock:DeleteModelInvocationLoggingConfiguration

A5 · The AWS abuse notice and account contacts

AWS writes to the account's email and contacts, which under resale often belong to the partner or are stale. If the notice lands in an unread mailbox, nobody sees the incident.
for t in SECURITY BILLING OPERATIONS; do
aws account get-alternate-contact --alternate-contact-type "$t" \
--account-id [account-id] 2>&1 | sed "s/^/[$t] /"
done
aws account get-contact-information --account-id [account-id]
With  --account-id , run from the management account (or delegated admin for Account Management) with trusted access; otherwise run inside the account.
  • Before: agree who owns the SECURITY contact per partner model; put it in the contract.
  • During: ask the customer to forward anything from AWS.
  • Within 24 hours: the account owner replies with actions taken.
  • After: correct stale contacts.

A6 · Billing and credits from the partner's side

  • Detect on the payer: Cost Explorer by  LINKED_ACCOUNT , Cost Anomaly Detection, Bedrock budgets (Part 2, B1-d); they don't replace CloudTrail and GuardDuty.
  • Tell the customer: with AWS Billing Conductor they may not see the spike; you hold the signal.
  • Request adjustments: the account owner opens a billing case; engage your partner account team or Partner-Led Support. Don't promise refunds: adjustments are case by case.
  • Document the remediation (keys rotated, Deny, MFA, contacts) to support the request.

A7 · Escalation path to AWS

Situation
Channel
Who opens it
Suspected or confirmed unauthorized use
AWS Support case on the affected account
The account owner
Customer has
 AWS Security Incident Response 
A Security Incident Response case
Customer or authorized partner
Partner in Partner-Led Support
Partner-Led Support process
The partner
Multi-customer impact, org takeover, persistence
Partner and customer account teams, in parallel
The partner
Billing adjustment
Billing case plus account team (A6)
The account owner
📣 Open the case early with the timeline and containment actions. Coordinate any AWS protective measures through your account team.

A8 · Communicating with the end customer

Drafts to adapt; leave out sensitive data you don't need.
  • Initial: "We detected anomalous Amazon Bedrock activity in account [ID] at [time], consistent with unauthorized model use. We [blocked model invocation / revoked credential X] and are investigating. Please forward any message from AWS."
  • Contained: "Contained at [time]: the credential is revoked and invocations stopped. We're removing attacker artifacts and fixing the root cause; billing impact is under review."
  • Closure: "Resolved at [time]. Root cause: [summary]. Controls applied: [SCP / least privilege / rotation / GuardDuty AI Protection / contacts]. Next steps: [...]."

A9 · Reactive checklist

Phase
Action
✓
Before
Delegated access, written authorization, scope, IR role (A4)
☐
Detection
Confirm signal; list invocations (Invoke, Converse, mantle, failed calls); find principal, IP, key; check credentials, persistence, tampering, quotas, Marketplace; if a partner credential, sweep every account (A1)
☐
Escalation
Find who got the abuse notice; open the AWS case early (A5, A7)
☐
Containment
Preserve evidence → deactivate keys and API keys, revoke sessions → Bedrock Deny or SCP → revert quotas, remove Marketplace; reply to AWS within 24 h
☐
Eradication
Remove attacker identities and trusts; fix root cause, pipelines, IaC; run Access Analyzer
☐
Recovery
Least privilege; confirm cessation by principal and key; billing path (A6); fix contacts
☐
Post-incident
Lessons learned; hand over to governance (Part 2)
☐

🔜 What's next

Part 2 is for the governance team: the monitoring, guardrails, and baseline that make the next attempt fail early.

📚 Learn more

Series: Bedrock LLMjacking, Part 2: Prevention and Governance for AWS Partners (1 article)

  1. 1
    Bedrock LLMjacking, Part 1: Incident Response for AWS Partners This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article