CanWriteData

dynamodb:PutItem / UpdateItem / DeleteItem / BatchWriteItem / TransactWriteItems grant item-level write access, enabling data poisoning (stream injection), TTL manipulation, and denial-of-service.

ebs:StartSnapshot + ebs:PutSnapshotBlock + ebs:CompleteSnapshot allows an attacker to synthesize a malicious disk image for supply-chain attacks (trojanized AMI distribution). The written snapshot can be shared via ModifySnapshotAttribute to distribute the malicious disk cross-account. This rule matches on direct IAM capability evaluation, not on PENDING snapshot nodes (which are transient and not present in the graph at rule-evaluation time).

Detaching a volume from a victim instance, attaching it to an attacker-controlled instance, modifying the filesystem (cron, SSH keys, startup scripts), and re-attaching enables both data write and indirect CanModifyConfiguration on the victim instance. This is the inverse of aws-ebs-volume-mount-read.

A principal with elasticfilesystem:ClientWrite in the EFS file system policy can mount the file system and write data via NFS.

A principal with elasticfilesystem:PutFileSystemPolicy can self-grant ClientWrite and write all file data on the EFS file system.

A Redis/Valkey cluster with AuthTokenEnabled=false (or absent) or a Memcached cluster is accessible to any VPC-reachable compute resource with an inbound security group rule on the cache port (6379 Redis, 11211 Memcached) - no credential is required. Both read and write operations are permitted without authentication, enabling cache poisoning and lateral movement attacks.

events:PutEvents on a custom event bus lets a principal inject events that can match rules and trigger compute consumers.

events:StartReplay re-delivers archived events to a target bus, triggering matching enabled rules - a CanWriteData equivalent that bypasses events:PutEvents.

IAM-effective cassandra:Modify on a Keyspaces table allows CQL INSERT, UPDATE, and DELETE, enabling data tampering and injection attacks.

memorydb:UpdateUser overwrites an ACL user password (CanModify on Credential); attacker with VPC reach can then authenticate and write cluster data.

memorydb:CreateUser + memorydb:UpdateAcl creates a privileged ACL user; with VPC reach, principal can then write all cluster data.

Compute with confirmed VPC network reach to the cluster plus access to an ACL credential can write Redis data (default ACL permissions allow writes).

Reading the Secrets Manager secret that holds Amazon MQ broker credentials gives the principal the ability to publish to the broker queue (CONDITIONAL on network reachability to the broker endpoint), which messaging-chains then rolls up to CanTrigger on the Lambda consumer.

kafka-cluster:WriteData grants IAM-level produce permission to the target MSK topic; a published message reaches any consumer bound to that topic via an event-source mapping.

Principal with neptune-db:connect and neptune-db:WriteDataViaQuery on the cluster resource ARN can execute write/mutation queries and modify graph data.

Principal with es:ESHttpPost / es:ESHttpPut on the domain can index or update documents via the OpenSearch REST API.

s3:PutObject on a bucket grants data-plane write, enabling object creation/overwrite - including code artifact poisoning.

A principal with effective sns:Publish on an SNS topic can send messages to it, potentially triggering all bound subscribers.

sqs:SendMessage on a queue is a data-plane publish: the principal can send attacker-influenced messages that drive event-source consumers. Consumed by messaging-chains.

Storage Blob Data Contributor/Owner grants effective data-plane write of ADLS Gen2 content.

Writing a key-value can poison config a downstream app trusts (e.g. swap a connection string endpoint).

Cosmos DB Built-in Data Contributor (or custom role with items/*) grants data-plane write - enabling item creation, replacement, upsert, and deletion.

A principal that holds the topic access key (retrieved via listKeys/action) can publish arbitrary events to the topic over HTTPS, triggering all bound consumers.

A principal with the EventGrid Data Sender role (events/send/action) on a custom topic can publish events via Entra token, triggering all bound consumers.

A principal holding the domain access key can publish events to ALL topics within the Event Grid domain, triggering all subscribers across the domain.

Azure Event Hubs Data Sender role (or equivalent custom role) grants send (publish) access to an event hub; feeds messaging-chains trigger primitive.

Admin password reset capability plus network reachability yields full data-plane write access (INSERT, UPDATE, DELETE, DROP) on all databases.

Retrieving the cache access key via listKeys/action yields full data-plane write of all cached data (SET, DEL, FLUSHDB, CONFIG SET), subject to network reachability of the Redis endpoint.

Holding a SAS connection string with Send rights (obtained via CanReadSecret/listKeys) grants data-plane send to the scoped namespace/queue/topic - equivalent to the Entra Data Sender role but credential-based.

Azure Service Bus Data Sender role (or Data Owner) grants data-plane send to a queue or topic; the primary Phase-10 publish primitive fed to messaging-chains.

servers/administrators/write lets a caller set any Entra identity (including themselves) as full DBA on all databases in the SQL server, yielding complete data-plane read and write if the SQL endpoint is network-reachable.

managedInstances/administrators/write lets a caller set any Entra identity (including themselves) as full DBA on all MI databases, yielding complete data-plane read and write if the MI endpoint is network-reachable.

Storage Blob Data Contributor/Owner at account scope grants blob write access to all containers.

Storage Blob Data Contributor/Owner at container scope grants blob write access to that specific container.

Storage Queue Data Contributor/Message Processor grants queue message write - enabling message poisoning of queues consumed by Functions/Logic Apps with SYSTEM identity.

bigtable.authorizedViews.mutateRows grants write access to a scoped subset of a table (row key prefix / column qualifier filtering). The caller can only write rows within the authorized view's defined scope; write access to the parent table is NOT granted. CanWriteData is scoped to the AuthorizedView node.

bigtable.tables.mutateRows grants the caller the ability to write, update, and delete rows in a Bigtable table. This is included in roles/bigtable.user and above. Data mutation enables credential injection, configuration poisoning, and application state corruption.

bigtable.tables.mutateRows on a CMEK-encrypted cluster; the Bigtable service agent decrypts via Cloud KMS before allowing writes - CanWriteData is CONDITIONAL(key_permission) on the service agent's KMS grant.

A principal with cloudscheduler.jobs.create can establish a Pub/Sub job that publishes attacker-controlled data to any topic in the project on schedule. No actAs required. Feeds messaging-chains rules 1+2 for CanTrigger -> CanExecuteAs chain.

cloudsql.instances.import can import a SQL dump or CSV from a GCS bucket into a Cloud SQL instance, allowing data modification, schema changes, and stored procedure injection.

Holding eventarc.messageBuses.publish on an Eventarc Advanced message bus lets an attacker inject arbitrary CloudEvents into the bus, driving all pipelines/enrollments bound to it - the direct Phase-10 publish primitive for Eventarc Advanced.

pubsub.topics.publish on the Eventarc-managed transport Pub/Sub topic lets an attacker inject crafted CloudEvent messages directly into the Eventarc delivery pipeline, bypassing the standard source adapter.

A VM whose source IP falls within a Filestore NFS export range can mount the share and read (and write, if READ_WRITE) all files without any IAM check - access is purely IP-address gated. CanWriteData is emitted when accessMode is READ_WRITE; CanReadData for both READ_WRITE and READ_ONLY.

When a principal holds CanModifyConfiguration (file.instances.update) on a Filestore instance and uses it to add an attacker-controlled IP to the NFS export rules, the principal's VM/container gains CanReadData and (if accessMode is READ_WRITE) CanWriteData to all files on the mounted share. This rule derives the data-plane access edges from the control-plane config mutation. State is POTENTIAL because the patch must be executed and network reachability must be confirmed.

datastore.entities.create + datastore.entities.update together constitute effective full data-plane write access to Firestore/Datastore documents (overwrite capability).

datastore.entities.create alone enables document injection (creation of new documents); without entities.update, the attacker cannot modify existing data but can poison via new entries.

datastore.databases.import + control of a source GCS bucket enables importing a Firestore export, overwriting ALL existing data in the database (bypass document-level write controls).

datastore.backups.restoreDatabase on a Firestore database + access to a Firestore backup enables restoring the backup, completely overwriting all current database content. Identical attack impact to import but via backup rather than GCS export.

storage.objects.create constitutes effective data-plane write access to a GCS bucket; also enables supply-chain poisoning if the bucket backs a Cloud Function source archive.

Possession of the Redis AUTH string combined with in-VPC network reach grants full data-plane write access (SET, DEL, FLUSHALL, etc.), enabling cache poisoning and supply-chain injection attacks against dependent applications.

When AUTH is disabled (the GCP default), any in-VPC client (Identity, Compute, Container, KubernetesWorkload) with network reachability to port 6379/6380 gains full unauthenticated Redis data-plane write access (SET, DEL, FLUSHALL, CONFIG), enabling cache poisoning and supply-chain injection attacks.

pubsub.topics.publish on a topic is the data-plane publish action; the principal can send attacker-influenced messages that drive push-subscription consumers. Consumed by messaging-chains as CanWriteData(principal → topic).

spanner.databases.write + spanner.sessions.create together constitute effective data-plane write access: the caller can open a session and execute DML (INSERT, UPDATE, DELETE) statements to modify arbitrary rows in any table in the database.

cloudtasks.tasks.create enqueues a task with an attacker-controlled body to a Cloud Tasks queue - the publish/send primitive that messaging-chains uses to derive CanTrigger(principal → consumer).

workflows.executions.create starts a new execution with a caller-supplied argument payload - both a direct invoke AND a publish-to-topic primitive (feeds messaging-chains rule 1).