1. Resources
  2. Detection rules
  3. EKS Cluster Access Granted Through an Access Entry or Access Policy

EKS Cluster Access Granted Through an Access Entry or Access Policy detection rules

An attacker who controls an AWS principal with EKS permissions gives an identity of their choice access to a cluster, up to cluster administrator, through the EKS API and without touching anything inside Kubernetes.

Platform
AWS
Severity
High
Log source
AWS CloudTrail
Last updated
Rule formats
Sigmaand queries for: SplunkMicrosoft SentinelIBM QRadar
What an attacker needs
Credentials for an AWS principal that may create or update EKS access entries, associate access policies or create Pod Identity associations.
Impact
The chosen identity gets lasting access to the cluster, up to cluster administrator, or pods receive the permissions of an IAM role.
Response
Delete the access entry or disassociate the policy, then review the Kubernetes audit log for what the identity did in the cluster.
Mitigation
Allow the EKS access entry and access policy actions only to platform roles, and keep the cluster administrator policy for a few roles.
CloudTrail events
CreateAccessEntryUpdateAccessEntryAssociateAccessPolicyCreatePodIdentityAssociationUpdatePodIdentityAssociation
Threat groups
None listed in MITRE ATT&CK for this technique

How the attack works

Amazon EKS decides which IAM principals may use a cluster's Kubernetes API through access entries. CreateAccessEntry registers an IAM user or role for a cluster, optionally with Kubernetes group names, and AssociateAccessPolicy attaches an EKS access policy to that entry, scoped to the whole cluster or to namespaces. AWS describes AmazonEKSClusterAdminPolicy as administrator access to the cluster and, in its own setup guides, as equivalent to system:masters. UpdateAccessEntry changes the groups or the user name of an existing entry. All of this happens in the EKS API of the account: no Kubernetes role, binding or ConfigMap is edited, so nothing shows up in the Kubernetes audit log until the new identity starts to use the cluster.

For an attacker who has taken over an AWS principal with these permissions, this is the way from the AWS account into the workloads, and a way back that survives the loss of the first credential. The principal that receives the access can be any IAM user or role, including a role that trusts another account. A related path hands AWS permissions to workloads instead: CreatePodIdentityAssociation binds an IAM role to a Kubernetes service account, and AWS compares this to the way instance profiles provide credentials to EC2 instances. Whoever can run a pod with that service account receives the role, and a target role can sit in another account.

CloudTrail captures all Amazon EKS API calls as events under eks.amazonaws.com. AWS's example record is for CreateCluster and shows that the request field can differ from the API parameter (the cluster arrives as clusterName, the API calls it name). AWS publishes no example record for the access entry calls, so only one rule here reads a request field, and it says so. No incident report was used for this page: it follows what AWS documents about access entries, access policies and Pod Identity.

What an attacker needs

  • Credentials for a principal allowed eks:CreateAccessEntry and eks:AssociateAccessPolicy, or eks:UpdateAccessEntry, on the cluster.
  • A cluster whose authentication mode uses access entries, which is the case for clusters set to the EKS API or to the API together with the ConfigMap.
  • For the Pod Identity path, eks:CreatePodIdentityAssociation or eks:UpdatePodIdentityAssociation and a way to run a pod with the chosen service account.

Impact

With the cluster administrator policy the receiving identity controls every namespace: it can read all Kubernetes secrets, run or change any workload, and reach the IAM roles those workloads use. The entry stays until someone deletes it, so it is also persistence. A Pod Identity association gives the pods of one service account the permissions of an IAM role, which is a privilege escalation in the AWS account when the role is more privileged than the caller.

Detection rules

EKS Access Entry Created or Updated, or Access Policy Associated

Detects CreateAccessEntry, UpdateAccessEntry and AssociateAccessPolicy calls to Amazon EKS. An access entry lets an IAM user or role use the Kubernetes API of a cluster. CreateAccessEntry registers the principal and can give it Kubernetes group names, UpdateAccessEntry changes those groups or the user name, and AssociateAccessPolicy attaches an EKS access policy. Each of them can give an identity access it did not have, and none of them changes anything inside the cluster. AWS documents that CloudTrail captures all EKS API calls and publishes no example record for these three, so the rule matches the event names only. Read the cluster, the principal and the policy from the event, and check whether the principal belongs to your account. It also matches attempts that failed (errorCode present): check errorCode, because an unauthorized attempt is worth seeing.

LevelLowStatusExperimentalLog sourceAWS CloudTrail
title: EKS Access Entry Created or Updated, or Access Policy Associated
id: ac6a3c10-0f27-4874-bd0a-9b8cfd98d595
status: experimental
description: >-
  Detects CreateAccessEntry, UpdateAccessEntry and AssociateAccessPolicy
  calls to Amazon EKS. An access entry lets an IAM user or role use the
  Kubernetes API of a cluster. CreateAccessEntry registers the principal and
  can give it Kubernetes group names, UpdateAccessEntry changes those groups
  or the user name, and AssociateAccessPolicy attaches an EKS access policy.
  Each of them can give an identity access it did not have, and none of
  them changes anything inside the cluster. AWS documents that CloudTrail
  captures all EKS API calls and publishes no example record for these
  three, so the rule matches the event names only. Read the cluster, the
  principal and the policy from the event, and check whether the principal
  belongs to your account.
  It also matches attempts that failed (errorCode present): check errorCode,
  because an unauthorized attempt is worth seeing.
references:
  - https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateAccessEntry.html
  - https://docs.aws.amazon.com/eks/latest/APIReference/API_UpdateAccessEntry.html
  - https://docs.aws.amazon.com/eks/latest/APIReference/API_AssociateAccessPolicy.html
  - https://docs.aws.amazon.com/eks/latest/userguide/logging-using-cloudtrail.html
author: Forestall
date: 2026-11-18
tags:
  - attack.persistence
  - attack.privilege-escalation
  - attack.t1098.006
logsource:
  product: aws
  service: cloudtrail
detection:
  selection:
    eventSource: eks.amazonaws.com
    eventName:
      - CreateAccessEntry
      - UpdateAccessEntry
      - AssociateAccessPolicy
  condition: selection
falsepositives:
  - Infrastructure-as-code pipelines and cluster management tools that register node roles, teams and controllers on every new cluster. Add the platform roles to a filter_* selection on userIdentity.arn and review calls made by anyone else.
level: low

False positives

  • Infrastructure-as-code pipelines and cluster management tools that register node roles, teams and controllers on every new cluster. Add the platform roles to a filter_* selection on userIdentity.arn and review calls made by anyone else.

EKS Cluster Administrator Access Policy Associated with an Access Entry

Detects AssociateAccessPolicy calls to Amazon EKS that attach AmazonEKSClusterAdminPolicy or AmazonEKSAdminPolicy to an access entry. AWS describes the first as administrator access to a cluster and the second as a more limited administrative scope, and it publishes their ARNs (arn:aws:eks::aws:cluster-access-policy/...). The IAM principal of the access entry receives the policy for the whole cluster or for the namespaces of the access scope. The policy is read from requestParameters.policyArn, which follows the policyArn request parameter of the EKS API reference: AWS publishes no example record for this event, and its CreateCluster example shows that a request field can differ from the API parameter, so confirm the field in your own events. It also matches attempts that failed (errorCode present): check errorCode, because an unauthorized attempt is worth seeing.

LevelHighStatusExperimentalLog sourceAWS CloudTrail
title: EKS Cluster Administrator Access Policy Associated with an Access Entry
id: 379fff10-06bb-4cf1-a247-f517f091281f
status: experimental
description: >-
  Detects AssociateAccessPolicy calls to Amazon EKS that attach
  AmazonEKSClusterAdminPolicy or AmazonEKSAdminPolicy to an access entry.
  AWS describes the first as administrator access to a cluster and the
  second as a more limited administrative scope, and it publishes their ARNs
  (arn:aws:eks::aws:cluster-access-policy/...). The IAM principal of the
  access entry receives the policy for the whole cluster or for the
  namespaces of the access scope. The policy is read from
  requestParameters.policyArn, which follows the policyArn request parameter
  of the EKS API reference: AWS publishes no example record for this event,
  and its CreateCluster example shows that a request field can differ from
  the API parameter, so confirm the field in your own events.
  It also matches attempts that failed (errorCode present): check errorCode,
  because an unauthorized attempt is worth seeing.
references:
  - https://docs.aws.amazon.com/eks/latest/APIReference/API_AssociateAccessPolicy.html
  - https://docs.aws.amazon.com/eks/latest/userguide/access-policy-permissions.html
  - https://docs.aws.amazon.com/eks/latest/userguide/logging-using-cloudtrail.html
  - https://attack.mitre.org/techniques/T1098/006/
author: Forestall
date: 2026-11-18
tags:
  - attack.persistence
  - attack.privilege-escalation
  - attack.t1098.006
logsource:
  product: aws
  service: cloudtrail
detection:
  selection:
    eventSource: eks.amazonaws.com
    eventName: AssociateAccessPolicy
    requestParameters.policyArn|endswith:
      - /AmazonEKSClusterAdminPolicy
      - /AmazonEKSAdminPolicy
  condition: selection
falsepositives:
  - Platform pipelines and cluster bootstrap code that give the platform team or a GitOps controller administrator access to new clusters. Add those roles to a filter_* selection on userIdentity.arn and keep alerting on associations made by people or unknown roles.
level: high

False positives

  • Platform pipelines and cluster bootstrap code that give the platform team or a GitOps controller administrator access to new clusters. Add those roles to a filter_* selection on userIdentity.arn and keep alerting on associations made by people or unknown roles.

EKS Pod Identity Association Created or Updated

Detects CreatePodIdentityAssociation and UpdatePodIdentityAssociation calls to Amazon EKS. A Pod Identity association binds an IAM role to a Kubernetes service account of a cluster, and pods that use the service account receive temporary credentials for the role. AWS compares this to the way instance profiles give credentials to EC2 instances. The request can also name a target role, in the same or in another account, that EKS assumes with the first role. A principal that can create or change an association and run a pod with the service account therefore reaches the permissions of the role. AWS documents that CloudTrail captures all EKS API calls and publishes no example record for these two, so the rule matches the event names only. Read the role, the namespace and the service account from the event (roleArn, namespace, serviceAccount and targetRoleArn in the API reference) and compare what the role can do with the caller. It also matches attempts that failed (errorCode present): check errorCode, because an unauthorized attempt is worth seeing.

LevelLowStatusExperimentalLog sourceAWS CloudTrail
title: EKS Pod Identity Association Created or Updated
id: d9c8d303-d3f9-42e0-97ba-5bd9a7cc99a4
status: experimental
description: >-
  Detects CreatePodIdentityAssociation and UpdatePodIdentityAssociation
  calls to Amazon EKS. A Pod Identity association binds an IAM role to a
  Kubernetes service account of a cluster, and pods that use the service
  account receive temporary credentials for the role. AWS compares this to
  the way instance profiles give credentials to EC2 instances. The request
  can also name a target role, in the same or in another account, that EKS
  assumes with the first role. A principal that can create or change an
  association and run a pod with the service account therefore reaches the
  permissions of the role. AWS documents that CloudTrail captures all EKS
  API calls and publishes no example record for these two, so the rule
  matches the event names only. Read the role, the namespace and the service
  account from the event (roleArn, namespace, serviceAccount and
  targetRoleArn in the API reference) and compare what the role can do with
  the caller.
  It also matches attempts that failed (errorCode present): check errorCode,
  because an unauthorized attempt is worth seeing.
references:
  - https://docs.aws.amazon.com/eks/latest/APIReference/API_CreatePodIdentityAssociation.html
  - https://docs.aws.amazon.com/eks/latest/userguide/logging-using-cloudtrail.html
author: Forestall
date: 2026-11-18
tags:
  - attack.persistence
  - attack.privilege-escalation
  - attack.t1098.006
logsource:
  product: aws
  service: cloudtrail
detection:
  selection:
    eventSource: eks.amazonaws.com
    eventName:
      - CreatePodIdentityAssociation
      - UpdatePodIdentityAssociation
  condition: selection
falsepositives:
  - Deployments of workloads and cluster add-ons that use Pod Identity, usually by pipelines and infrastructure-as-code tools. Add the deployment roles to a filter_* selection on userIdentity.arn and keep alerting on associations made by people or unknown roles.
level: low

False positives

  • Deployments of workloads and cluster add-ons that use Pod Identity, usually by pipelines and infrastructure-as-code tools. Add the deployment roles to a filter_* selection on userIdentity.arn and keep alerting on associations made by people or unknown roles.

Detection logic

Patterns that need more than one event, a baseline or knowledge of your own environment. Each is a hypothesis to build and tune in your SIEM, not a ready rule.

One principal given access to several clusters within a day

Detection hypothesisJoins two logs

A platform team grants a role access to the clusters it works on, usually through code and over time. The same principal ARN appearing in new access entries or policy associations on several clusters within hours suggests that someone is spreading one identity across everything they can reach.

  1. Collect CreateAccessEntry and AssociateAccessPolicy events from eks.amazonaws.com.
  2. Read the principal and the cluster of each event. The EKS API returns them as principalArn and clusterName in the response of both calls.
  3. Count the different clusters per principal ARN over 24 hours and alert at three or more.

EventsCreateAccessEntryAssociateAccessPolicy

LimitsPipelines that roll a new role out to all clusters look the same. The three clusters and the 24 hours are starting points. The response fields follow the API reference, and AWS publishes no example record for these calls, so confirm them in your own events first.

Access entry for a principal that belongs to another account

Detection hypothesisNeeds your own lists

An access entry can name any IAM user or role. A principal ARN whose account ID is not the account of the cluster, and not one of your own accounts, gives an outside identity a way into the cluster.

  1. Collect CreateAccessEntry events from eks.amazonaws.com and read the principal ARN of the request (the principalArn parameter of the API).
  2. Take the account ID from the ARN and compare it with recipientAccountId and with the list of accounts in your organization.
  3. Alert when the account is neither the cluster's own nor on your list.

EventsCreateAccessEntry

LimitsIt needs a current list of your accounts. A role in your own account that trusts an outside account is not found this way, because its ARN carries your account ID.

Access entry created and deleted again shortly after

Detection hypothesisSequence of events

An attacker who needs the cluster only once may add an entry, use it and remove it, so that a later review of the cluster's access entries finds nothing.

  1. A CreateAccessEntry event from eks.amazonaws.com for a principal on a cluster.
  2. Within a few hours a DeleteAccessEntry event for the same principal on the same cluster.
  3. Check the Kubernetes audit log of the cluster for what the principal did between the two events.

EventsCreateAccessEntryDeleteAccessEntry

LimitsTests of infrastructure code and short-lived preview environments create and delete entries too. The time window is a starting point.

Triage

  • Identify the caller (userIdentity.arn), the source IP address and the user agent. Is it the platform pipeline or an administrator who normally manages this cluster?
  • Read the cluster, the principal ARN and the policy ARN from the request and the response. Does the principal belong to your account, and does anyone own it?
  • Check whether the same caller made the same grant on other clusters, and whether the entry was deleted again shortly after.
  • For a Pod Identity association, read the role, the namespace and the service account, and compare what the role can do with what the caller can do.
  • Look in the Kubernetes audit log of the cluster for what the principal did after the grant, with priority on reading secrets and creating pods.

Response

Once the attack is confirmed:

  1. Delete the access entry, or disassociate the access policy, so that the identity loses its access to the cluster API.
  2. Delete the Pod Identity association or point it back at the intended role, and restart the pods that received the credentials.
  3. Review the Kubernetes audit log for what the identity did, and remove what it created, such as workloads, service accounts, role bindings and tokens.
  4. Rotate the Kubernetes secrets the identity could read, and revoke the sessions of the IAM roles that workloads in the cluster use.
  5. Contain the AWS principal that made the grant, and take away its EKS access management permissions.

Mitigation

  • Allow eks:CreateAccessEntry, eks:UpdateAccessEntry, eks:AssociateAccessPolicy and the Pod Identity association actions only to the platform roles that manage clusters, and deny them elsewhere with a service control policy.
  • Give people and pipelines namespace-scoped access policies, and keep AmazonEKSClusterAdminPolicy for a small number of break-glass and platform roles.
  • Review the access entries and Pod Identity associations of every cluster on a schedule, and compare them with what your infrastructure code declares.
  • Keep the IAM roles used in Pod Identity associations least-privilege, because every pod that can use the service account receives them.
  • Send the Kubernetes audit log of the clusters to your log platform, so that what a new identity does inside the cluster is visible.

Frequently asked questions

Does this change appear in the Kubernetes audit log?

No. Access entries and access policy associations are objects of the EKS API, not Kubernetes objects. The calls are recorded in CloudTrail under `eks.amazonaws.com`. The Kubernetes audit log shows only what the new identity does in the cluster afterwards, and it has to be enabled and collected per cluster.

What is the difference between an access entry and the aws-auth ConfigMap?

Both map IAM principals to Kubernetes access. AWS describes access entries as a replacement for maintaining entries in the `aws-auth` ConfigMap. An access entry is created through the EKS API and logged in CloudTrail, while an edit of the ConfigMap is a change inside the cluster that only the Kubernetes audit log records. The rules on this page do not see ConfigMap edits.

Why is the rule on the cluster administrator policy the important one?

Platform tools create access entries all the time, for node roles and for teams. Attaching `AmazonEKSClusterAdminPolicy` or `AmazonEKSAdminPolicy` is rarer and gives administrative control, so it is the event to look at first. The rule reads the policy from a request field that follows the EKS API reference, so confirm the field in your own events.

Has this been seen in real attacks?

No public incident report describes this at the audit event level, and none was used for this page. The page follows what AWS documents about access entries and access policies. The API was built to manage cluster access from the AWS account, which is exactly what makes it useful to someone who has taken over a principal with EKS permissions.

References

We respect your privacy

We use cookies to keep this site secure and working properly. With your permission, we also use optional cookies to understand usage and improve the experience. Cookie Policy

You can change your choice at any time.