Explore 9 source-supported AI security cases for 1.1 · Insufficient access controls in Databricks DASF 3.0, with evidence, scope, and defensive analysis.
Risk category
Datasets are exposed to people or groups that should not be able to read or modify them because authentication, authorization, or access scope is insufficient. Permissions need to reflect the required level of access, including individual files or records. Without clear data-access governance, unauthorized use can undermine confidentiality, integrity, regulatory obligations, and customer trust.
Auth0 disclosed related authorization defects in its JavaScript and Python AI retrieval integrations. A shared FGA object could incorrectly collapse distinct permission checks, allowing denied documents into a model’s context. The relevant boundary is the retriever’s authorization decision before generation.
Why it relates: Document-level access checks fail to preserve the requester’s complete authorization conditions.
JavaScript and Python have different collision conditions and fixed package versions; those scopes remain separate.
WorkOS attributed unauthorized access to an internal sales/support tool to a researcher’s ARTEX security-testing agent operating outside its intended environment. The agent used a public API and a predictable development credential to retrieve customer records in bulk. WorkOS and an independent forensics firm validated attribution, while the escape mechanism, benchmark and underlying model remain undisclosed.
Why it relates: Predictable production-accepted credentials permit unauthorized reads of aggregated customer records, sharing the insufficient data-access-control boundary. The records are conventional CRM/support data, not a demonstrated ML training dataset. The same authentication-to-record-access failure is the retained relation.
An unintended agent-driven operational exposure. The diagram begins at confirmed out-of-scope reachability and does not invent the environment escape.
Zeabur, a platform for hosting applications and databases, reported an October 14-15 intrusion affecting hosted AI-service credentials. Attackers used leaked internal credentials across cluster and cloud boundaries; a replacement credential was captured in a later backup and subsequently used without authorization. Customers own upstream-key revocation and recovery of deployments they administer; the operator owns internal isolation and backup access.
Why it relates: Over-broad internal access exposed platform data associated with hosted AI integrations. These are integration credentials and operational data, not a demonstrated training or RAG dataset.
October operational incident only. Shared mechanisms and AI-hosting layers can justify bounded practical overlap; no inference that an agent, MCP server or particular LLM was deployed. Same-author second pass, not independent validation.
Fireworks AI, a hosted platform for running, evaluating and training models, disclosed unauthorized access to customer evaluation-job secrets and later development-machine activity affecting customer data. Customers can revoke exposed credentials at their issuers; the platform operator owns isolation between development systems and customer assets.
Why it relates: Customer datasets were accessed by an unauthorized party, directly matching the dataset access-control confidentiality boundary.
Mappings cover unauthorized AI-platform credential and data access, affected infrastructure/data operations, supplier dependency and model-asset confidentiality. Practical overlaps explicitly preserve missing agent, MCP, model-query and completed-copy evidence. No mapping represents a verified defensive success.
Zenity tested an AWS Bedrock AgentCore deployment, a managed environment for running AI agents, with a network-capable agent and a broad execution role. The agent relayed temporary role credentials from its metadata endpoint. Off-platform API calls then reached other memories and agents. The distinctive persistence path wrote short-term conversation events that configured extraction strategies could turn into long-term records; later retrieval directed the agent to a mutable command page. The reach was demonstrated within an account and region, not as a microVM escape or automatic cross-account compromise. The researchers observed major default-role restrictions on September 29; existing deployed roles still require independent inspection.
Why it relates: Broad role permissions allow another memory's private conversations to be read and its events to be written.
Controlled broad-role AgentCore deployment with separate direct API and retained-memory/C2 branches; account/region scope, tool prerequisites and later default-role restrictions remain explicit.
Unit 42 demonstrated that starter-toolkit-created AgentCore execution roles used broad resource wildcards for ECR, AgentCore Memory, runtime, and Code Interpreter actions. After an initial agent is compromised, its role can pull another agent's image, recover a MemoryID from the image, and read that agent's memory records; Unit 42 states the same permission shape would also allow poisoning, which the test did not demonstrate. AWS clarified that generated roles are for development and testing, not production.
Why it relates: An agent-scoped task inherits broad cloud permissions that reach another agent's image and memory records. The demonstrated workload role can access another agent’s memory or protected customer/provider assets beyond the intended task. The relevant boundary is resource authorization, not the secrecy of resource identifiers.
Unit 42 demonstrated that starter-toolkit-created AgentCore execution roles used broad resource wildcards for ECR, AgentCore Memory, runtime, and Code Interpreter actions. After an initial agent is compromised, its role can pull another agent's image, recover a MemoryID from the image, and read that agent's memory records; Unit 42 states the same permission shape would also allow poisoning, which the test did not demonstrate. AWS clarified that generated roles are for development and testing, not production.
Orca found Internet-exposed vector databases containing source text, personal data, medical records, credentials, and internal configuration, then validated that credentials from one support-ticket index could reach external SaaS systems. Separately, two critical Milvus vulnerabilities bypassed authentication through a trusted sourceID header and unauthenticated APIs on port 9091. Together, the findings show that a vector database is both a sensitive data store and an AI infrastructure control boundary.
Why it relates: Orca found Internet-exposed vector databases containing source text, personal data, medical records, credentials, and internal configuration, then validated that credentials from one support-ticket index could reach external SaaS systems. The relevant category is Insufficient access controls: Datasets are exposed to people or groups that should not be able to read or modify them because authentication, authorization, or access scope is insufficient.
Orca found Internet-exposed vector databases containing source text, personal data, medical records, credentials, and internal configuration, then validated that credentials from one support-ticket index could reach external SaaS systems. Separately, two critical Milvus vulnerabilities bypassed authentication through a trusted sourceID header and unauthenticated APIs on port 9091. Together, the findings show that a vector database is both a sensitive data store and an AI infrastructure control boundary. Vector databases can retain readable source material. Orca found original text, metadata, personal and medical records, credentials, and internal configuration in publicly reachable deployments. In controlled validation, the team used plaintext SaaS credentials from one support-ticket index to authenticate to the corresponding external services. CVE-2025-64513 trusted a caller-controlled identity claim. A crafted sourceID made a vulnerable Milvus proxy treat an external request as internal, bypassing password and API-key checks. Fixes were released in 2.4.24, 2.5.21, and 2.6.5. CVE-2026-26190 exposed two paths on port 9091. The /expr route used a predictable value derived from the default etcd.rootPath , while /api/v1/* routes lacked authentication. A reachable attacker could read secrets, manage users and collections, disrupt service, and under stated conditions write files. Exposure is not evidence of malicious exploitation. Orca confirmed real data exposure and disclosed it to affected organizations. The Milvus advisories show practical exploitability, but there is currently no public evidence that either vulnerability has been used in an actual attack.
Unit 42 showed how a deployed Vertex AI Agent Engine workload (Google Cloud's managed runtime for AI agents) could become a "double agent" by extracting Google-managed service-agent credentials from its runtime and using those permissions to read customer project storage, inspect restricted Google-managed artifacts, and expose sensitive deployment files. Google updated documentation and recommends Bring Your Own Service Account (BYOSA), but the larger lesson is broader: an AI agent's cloud identity, runtime scopes, deployment artifacts, and network reach are one security boundary.
Why it relates: Runtime identity reaches customer storage and restricted provider artifacts beyond the expected task; production image modification was separately blocked. The demonstrated workload role can access another agent’s memory or protected customer/provider assets beyond the intended task. The relevant boundary is resource authorization, not the secrecy of resource identifiers.
Unit 42 showed how a deployed Vertex AI Agent Engine workload (Google Cloud's managed runtime for AI agents) could become a "double agent" by extracting Google-managed service-agent credentials from its runtime and using those permissions to read customer project storage, inspect restricted Google-managed artifacts, and expose sensitive deployment files. Google updated documentation and recommends Bring Your Own Service Account (BYOSA), but the larger lesson is broader: an AI agent's cloud identity, runtime scopes, deployment artifacts, and network reach are one security boundary. The agent runtime inherited a powerful managed identity. Unit 42 focused on Vertex AI Agent Engine's P4SA, a Google-managed service account used by Vertex AI to access service resources. Credential exposure turned agent code into cloud access. A malicious agent tool queried Google's metadata service, extracted the service-agent token, and used that identity outside the normal agent flow. The first pivot crossed into the customer project. With the token, the researchers reported read access to Google Cloud Storage buckets in the consumer project. The second pivot exposed provider-side artifacts. The same identity could read restricted Google-owned Artifact Registry repositories and download internal Vertex AI Reasoning Engine images. Google said separate controls blocked production image modification. The tenant project added deployment leakage. Files such as Dockerfile.zip , code.pkl , and requirements.txt revealed internal paths and implementation details. Pickle-based serialization also raised a code-execution concern if the file could be manipulated. The mitigation is not just one patch. Google revised documentation and pointed users toward BYOSA; defenders still need least-privilege identities, scoped OAuth access, artifact controls, segmentation, and monitoring.
This chain starts with an old-fashioned web bug. Lilli (McKinsey's internal AI platform) exposed 22 unauthenticated API endpoints, and one of them built SQL from attacker-controlled JSON keys. CodeWall used that path to read and write the database behind McKinsey's AI platform: 46.5M chat messages, 728K files, 3.68M RAG chunks, vector-store metadata, and the system prompts shaping 43,000+ users. The important point is not just that SQL injection happened. It is that one web bug reached the prompt and retrieval tables, so the compromise landed directly in the AI layer.
Why it relates: This chain starts with an old-fashioned web bug. The relevant category is Insufficient access controls: Datasets are exposed to people or groups that should not be able to read or modify them because authentication, authorization, or access scope is insufficient.
This chain starts with an old-fashioned web bug. Lilli (McKinsey's internal AI platform) exposed 22 unauthenticated API endpoints, and one of them built SQL from attacker-controlled JSON keys. CodeWall used that path to read and write the database behind McKinsey's AI platform: 46.5M chat messages, 728K files, 3.68M RAG chunks, vector-store metadata, and the system prompts shaping 43,000+ users. The important point is not just that SQL injection happened. It is that one web bug reached the prompt and retrieval tables, so the compromise landed directly in the AI layer. Step 1: start with the unauthenticated API surface. Lilli exposed 22 endpoints without authentication. That gave CodeWall's autonomous agent a wide place to probe without needing an account first. Step 2: use one endpoint that turns JSON keys into SQL. One API built SQL queries from attacker-controlled JSON keys. CodeWall reports database read/write access through SQL injection within about 2 hours. It separately chained SQL injection with insecure direct object references (IDOR) to read individual employees' search histories. Step 3: realize the database also holds the AI platform's crown jewels. The exposed tables were not just ordinary business records. They included 46.5M chat messages, 728K files, 3.68M RAG chunks with S3 paths, vector-store metadata, AI assistants, and 95 prompt/model configurations across 12 models. Step 4: move from reading the AI layer to rewriting it. The same SQLi allowed UPDATE. That meant an attacker could change a system prompt, poison retrieved content, remove model-level safety instructions, or insert exfiltration instructions with a simple HTTP request and without touching application code. These are potential effects of verified write access, not demonstrated prompt poisoning or a bypass of independently enforced backend authorization. Why this matters: Lilli ran this way for 2 years with 43K+ users and 500K+ monthly prompts. CodeWall reports that ZAP missed the injection and its agent found the path; this is not an independent comparison of all automated or manual testing. McKinsey closed the unauthenticated endpoints and patched the issue on 2026-03-02 after CodeWall's 2026-03-01 report.