No Permissions Required: Cross-Tenant Data Theft via BigQuery Data Transfer
Google Cloud customers using the BigQuery Data Transfer Service are at risk: an attacker with no permissions in their project can gain an internal network foothold and possibly exfiltrate private data.
If you use the service, shrink your exposure window. A network attachment configured to ACCEPT_AUTOMATIC can become an open door into your network when it runs a BQ Data Transfer. The moment a transfer finishes, remove the attachment to prevent possible data exfiltration.
Service Background
This issue arises due to how one service, the BigQuery Data Transfer Service, uses another: Private Service Connect. Some background.
Private Service Connect (PSC) lets a Google-managed service reach a resource via a network attachment into a private Virtual Private Cloud (VPC). This Google Cloud feature lets a producer service attach a network interface in a VPC and reach the private resources inside. The attachment's connection preference decides who may enter: ACCEPT_AUTOMATIC admits any producer; ACCEPT_MANUAL admits only an allow-listed set of producer projects.
The BigQuery Data Transfer Service (DTS) allows for the copying of data into BigQuery on a schedule. When the source sits on a private network, such as a private-IP database, a DTS configuration can reach it through a PSC network attachment. The connector that reads the data does not run in your project. It runs on Google-managed infrastructure in a project created for every transfer initiated.
The flaw
A network attachment is a protected resource, and the permission compute.networkAttachments.use decides who may place an interface on it. DTS never checks whether the caller requesting data to me moved has the compute.networkAttachments.use on the network attachment.
The BigQuery Data Transfer service will attach to whichever PSC network attachment a caller names, and it never asks the two questions that matter: may this caller use this attachment, and does this attachment even belong to the caller's project? The caller can name an attachment in another project, so the deputy performs its one privileged act, placing a network interface inside a VPC, for someone who could never perform it directly.
The result? An attacker can name a network attachment in another tenant. If that network attachment has been configured to use BigQuery Data Transfer, they can gain a foothold in a victim's private VPC and possibly exfiltrate data into the attacker-controlled project.
Diagram: the shared fleet as a confused deputy

The attacker never touches Project A. The Google-Owned DTS Proxy infrastructure simply acts on the caller's instruction and carries the data back to the caller's own BigQuery.
Impact
An attacker with self-satisfiable BigQuery transfer permissions in their own project, with no relationship to the victim, gains a foothold in an otherwise private VPC. With credentials to the now accessible database, an attacker could access the private database in another tenant's VPC and land the data in their own BigQuery. This was reported to Google on June 1st 2026; they confirmed it as a valid vulnerability, though they confirmed it as a duplicate on July 1st, and I reproduced the impact again on October 23rd, 2026. That is, a caller can read a private PostgreSQL database in a separate project, and the secret row lands in the caller's own BigQuery table when victim preconditions are satisfied, those simply being using BigQuery DTS as directed.
Databases at risk. The DTS Integration-Connector can connect to four database protocols: PostgreSQL, MySQL, Oracle, and SQL Server. Any such database reachable only from inside the victim's VPC is potentially at risk. The end-to-end exfiltration was demonstrated against a private PostgreSQL instance.
Attacker prerequisites
An attacker can grant themselves all required IAM permissions. However, there still remain a couple of barriers to successful exploitation, namely the knowledge of the victim's network attachment name and possibly credentials to access a now accessible database.
- Self-satisfiable permissions, in the attacker's own project: permission to create and run a BigQuery transfer configuration (
bigquery.transfers.update), and ownership of the destination dataset. The attacker already controls that project. - Credentialed access to the victim's database, if required.
- No Cloud IAM Permissions: no IAM role, no
compute.networkAttachments.use, noactAs, no relationship of any kind. - Knowledge, not access: the name of the victim's PSC network attachment, plus the private address of the target database. Both are reconnaissance facts, not permissions. They make the attack targeted rather than broad.
Victim prerequisites
The victim does nothing unusual. The exposure follows from using DTS as documented.
- They run DTS against a private source, and so create a PSC network attachment, with the configuration
ACCEPT_AUTOMATIC - A private, internal-only database sits behind it and is reachable from inside the VPC.
- The attachment's connection preference setting
ACCEPT_AUTOMATICadmits any producer by definition; it is, in effect, a wildcard setting. To run their own transfers, the victim must allow an unknown Google producer ID, and that same entry then admits any other tenant's transfer on that producer. The October 2026 retest confirmed full cross-tenant exfiltration underACCEPT_AUTOMATICbut NOT when the configuration was subsequently updated toACCEPT_MANUAL, allowing only the now-known Google producer ID.
What Google said
Google reproduced the behavior (2026-06-04):
"We have successfully reproduced the behavior described here using the POC files you shared ... It is our understanding that exploitation of this behavior requires that the victim configure a network attachment between their VPC and project number 422792421300 and that the attacker has access to the network attachment name and certain data regarding the Compute Engine instance hosting the vulnerable DB (e.g. internal IP address)."
Google acknowledged the vulnerability and closed it as a duplicate (2026-07-01):
"While your report correctly identifies a valid vulnerability regarding missing authorization checks for Private Service Connect Network Attachments in the BigQuery Data Transfer Service, this exact attack vector was previously reported by another external researcher. Consequently, this submission is being closed as a duplicate of the earlier report. Unfortunately, this also excludes your report from our reward program – duplicate submissions don't qualify for reward or credit."
Google declined to mitigate it (2026-10-19):
"To answer your question regarding a mitigation: the product team has evaluated the ACCEPT_AUTOMATIC configuration is explicitly designed to automatically accept connections, there are no current plans to deploy a mitigation for this behavior by October 26th."
Disclosure timeline
Google Cloud VRP bug b/518828428.
| Date | Event |
|---|---|
| 2026-06-01 | Reported to Google Cloud VRP as b/518828428: cross-tenant private-database exfiltration through the Data Transfer Service, typed "Auth Bypass." |
| 2026-06-04 | Google reproduced the behavior from the proof of concept and confirmed the preconditions: a victim attachment that admits the DTS producer, and an attacker who knows the attachment name and the database's internal IP. |
| 2026-06-05 | Reported the wider exposure: DTS runs on several shared regional producers, so ACCEPT_MANUAL admits a stranger's transfer alongside the victim's own. |
| 2026-07-01 | Google closed the report as a duplicate of an earlier external researcher's report, acknowledged "a valid vulnerability regarding missing authorization checks," and excluded it from reward or credit. |
| 2026-09-29 | Notified Google of the planned conference disclosure and asked whether a fix would land first. |
| 2026-10-19 | Google replied that disclosure is the researcher's call, and that it has no plans to mitigate by publish data of Oct 26 however they are actively working on systemic fixes for the ACCEPT_AUTOMATIC configuration |
Note: this vulnerability was first reported to Google Cloud VDP by an unknown external researcher. If that researcher wants to make themselves known, I'd love to credit them for the initial discovery.
Companion post: "A Security Constitution, at Work." The method that surfaced this finding lives there and in the published framework.