安全型 AI 成为提示注入(prompt injection)的新目标

Les IA de sécurité, nouvelles cibles de l’injection de prompt

Silicon.fr by La rédaction 2026-05-20 13:05 Original
摘要
Cloudflare 的威胁情报团队 Cloudforce One 在其 serverless 平台 Workers 代码审计中发现“Notice to AI”式的间接提示注入(IDPI)诱饵:攻击者在用于搭建 VLESS 代理 VPN 隧道的脚本里插入大量多语言自然语言注释来误导安全审计型 AI。随后他们用 18,400 次 API 调用、覆盖 100 个已确认恶意/滥用 Workers、评测 7 类模型(含非 frontier 与 frontier)系统研究发现:诱饵对检测呈“U 型”效果(少量约 1–20 条可显著降检,过量会触发“重复警报”),更关键的是当诱饵占比低于文件总量 1% 时平均检测率降至 53.3%,而文件体积超过 3MB 时检测率仅约 12–18%,说明真正风险在于用大量合法代码/上下文稀释恶意信号而非单纯语言诱导。研究还提出通过自动去注释、对长脚本截断优先解析功能代码、变量匿名化、使用更具体 prompts 与语义验证等方式强化 AI 安全管线。

2026年3月,Cloudflare 的威胁情报部门 Cloudforce One 在一次例行监控中发现异常:其 serverless 平台上的 Workers 脚本里,出现了用于通过 VLESS 协议建立 VPN 代理隧道的代码,其中一份脚本夹杂了成千上万行重复、跨语言的自然语言评论。这些文本并不是写给开发者看的,而是专门投喂给负责审计代码的 AI 系统,意在让模型相信脚本“无害”。研究人员将这类伪装称为“Notice to AI”安全诱饵,本质上就是间接提示注入(Indirect Prompt Injection, IDPI)——攻击目标不再是传统安全系统,而是被当作安全工具使用的 LLM 推理层。

在这一发现之后,Cloudforce One 展开了系统性研究,评估这种技术对模型检测能力的真实影响。第一阶段测试的是约 2,000 tokens 的短代码片段,结果显示:对大多数非 frontier 模型而言,堆砌安全声明式的假评论反而像“危险信号”,通常会提升而不是削弱检测率。但这一阶段没有覆盖两个关键变量:一是“饱和度”,二是“上下文”。现实攻击者不会只在文件开头塞一段话,而是会把评论分散到整个脚本中;而 AI 审计器分析的是完整文件,不只是前几行。

第二阶段因此更贴近真实场景:评论被随机分布在代码中,模拟自然结构;研究规模扩大到 18,400 次 API 调用,覆盖 100 个已确认恶意或滥用的 Workers 脚本;测试文件最多包含 1,000 条评论,文件体积超过 3MB。参与评估的共有 7 个模型,分为两类:强调速度和成本的非 frontier 模型,以及具备更强推理能力的 frontier 前沿模型。

研究得出三项核心结论。第一,诱骗效果呈现明显的“U 型曲线”:少量注入时有效,过量注入时反而暴露。1 到 20 条评论就足以显著降低最脆弱的非 frontier 模型的检测率,最低模型的检测率从 90% 跌至 67%;但当评论数量达到 1,000 条或以上,重复本身会触发研究人员所说的“重复警报”,多数模型会把这种饱和视为欺诈特征。

第二,更关键的不是评论绝对数量,而是它们在整个文件中的占比。若诱饵文本占文件总量不到 1%,效果最佳:所有测试模型的平均检测率从正常条件下的 67.3% 降至 53.3%。一旦评论占比超过 25%,它们就变成了高区分度的攻击特征,检测率反而回升到 99%。换言之,越“像正常代码”的注入越危险,越“像刻意堆砌”的注入越容易被识别。

第三,真正的掩护来自文件体积本身,而不是评论技巧。对于小于 500KB 的 Workers 脚本,检测率几乎接近 100%;但当文件超过 3MB,尤其是包含 TON SDK、React 等合法大型库的 bundle 时,检测率骤降到 12% 至 18%。原因有两种:要么恶意代码超出了模型上下文窗口,要么被大量良性代码稀释,导致注意力无法聚焦。即便整个文件仍在上下文范围内,像“向 Telegram 外传数据”这样的恶意逻辑也可能被淹没在成千上万行正常代码中。

研究还揭示了模型的语言偏见。面对包含 1,000 条多语言评论的脚本,不同语言会显著影响模型反应:俄语评论会提高多个模型的检测率;中文和阿拉伯语会在部分 frontier 模型中触发警报;爱沙尼亚语由于在训练语料中代表性较低,反而更容易获得某些模型的信任。只有一个非 frontier 模型表现出相反偏差,对英语评论更为警惕。这些语言刻板印象既可能被攻击者利用,选择最不易触发警报的语言,也会给防守方带来误报风险。

更值得警惕的是“功能性瘫痪”。在极端情况下,部分 frontier 模型并没有被成功欺骗,却直接失去正常输出能力:它们不再返回清晰的“恶意/良性”二元判断,而是输出格式错误的结果或直接拒绝回答。对于依赖结构化 JSON 输出来自动触发拦截的安全流水线来说,这种失效本身就等同于绕过。攻击者不必说服 AI 代码安全,只要让它无法发出阻断指令即可。

针对这些风险,Cloudforce One 提出多项防护建议:在分析前自动删除评论,以直接消除语言诱饵;对大型脚本进行有意截断,优先保留功能代码而非 boilerplate、元数据或已知 SDK;将变量名匿名化,避免 FriendlyPayload 之类的命名影响模型判断;把泛化提问“这段代码是否滥用”改为更具体的问题,例如“这段代码是否是代理”;并通过语义验证,将代码中的自然语言声明与真实程序行为交叉比对,避免把过度热心的合法文档误判为攻击。

Cloudforce One 的研究给“提示注入”风险提供了更细致的结论:语言诱骗确实构成威胁,尤其是在“1% 规避区”内,但 frontier 模型整体上比外界预期更能抵抗文本诱饵。真正的薄弱点在于,攻击者可以把恶意载荷埋进足够多的合法数据中,利用规模和上下文饱和模型注意力。换句话说,攻击者如今不必证明代码安全,只需让恶意信号弱到难以被看见。

Summary
Cloudflare’s Cloudforce One researchers found that “Notice to AI” indirect prompt injection can reduce the effectiveness of AI-based code auditing for malicious Cloudflare Workers scripts used to set up VLESS VPN proxy tunnels, running tests on 18,400 API calls across 100 confirmed malicious/abusive scripts and evaluating seven model types (non-frontier and frontier). They report a “U-shaped” effect where small amounts of injected comments (1–20) can significantly lower detection (down to 67% from 90%), but extreme repetition triggers “repetition alarms,” while the most important factor is payload dilution: for files over 3MB, detection can drop to 12–18% due to context limits and dilution in legitimate code. The study also flags operational risks like “functional paralysis” in frontier models (malformed/blocked JSON outputs) and recommends defenses such as stripping comments before analysis, truncating to functional code, variable anonymization, targeted prompts, and semantic validation.

In March 2026, during routine monitoring, Cloudforce One — Cloudflare’s threat intelligence unit — spotted an anomaly in Workers scripts deployed on the company’s serverless platform. Among these scripts, used to set up VPN proxy tunnels via the VLESS protocol, one contained thousands of repetitive comments written in multiple languages. These blocks were not meant for human developers, but for AI systems auditing the code. Cloudflare identified them as “Notice to AI” security decoys: hidden instructions embedded in code to persuade an automated analysis model that the script is harmless. That is the essence of indirect prompt injection (IDPI), an attack vector aimed not at traditional security tools, but at the reasoning layer of LLMs used as security assistants.

Cloudforce One then launched a broader study to measure how much this technique can actually degrade detection. In an initial phase, the researchers had tested short code excerpts of about 2,000 tokens and found that the decoys were often counterproductive: for most non-frontier models, piling up false safety claims acted as a warning sign and increased detection rather than reducing it. But that first pass left two major variables unexplored: saturation and context. A real attacker would not simply place a block of text at the top of a file; they could scatter comments throughout the script, while the AI auditor analyzes the full file, not just the opening lines.

The second phase addressed those gaps with a more realistic setup: comments were randomly distributed through the code, 18,400 API calls were run against a corpus of 100 confirmed malicious or abusive Workers scripts, and tests scaled up to 1,000 comments per file and files larger than 3 MB. Seven models were evaluated, split between non-frontier systems — faster, cost-optimized models — and frontier models with more advanced reasoning.

The study produced three main findings. First, deception follows a U-shaped curve. A moderate number of injected comments, roughly 1 to 20, can significantly reduce detection on the most vulnerable non-frontier models; on the weakest model, detection fell from 90% to 67%. But at the other extreme, with 1,000 comments or more, the tactic backfires. The repetition triggers what the researchers call a “repetition alarm,” and most models eventually recognize the saturation as a hallmark of fraud.

Second, the most operationally important threshold is not the absolute number of comments, but their ratio to functional code. When decoys account for less than 1% of the file, they are most effective: average detection across all tested models drops to 53.3%, versus 67.3% under normal conditions. The comments are subtle enough to influence the model’s reasoning without raising suspicion. Once comments exceed 25% of the file, however, they become a highly discriminative signal: detection rises to 99%, as the models interpret the imbalance as a clear sign of malicious intent.

Third, and most importantly, file size itself is the dominant risk factor. For Workers scripts under 500 KB, detection rates are close to 100%. But for files above 3 MB — including bundles of legitimate libraries such as TON SDK or React — detection collapses to just 12% to 18%. The explanation is twofold: either the malicious code falls outside the model’s context window, or it is so diluted by surrounding benign code that the model cannot isolate it. In the latter case, even when the entire file fits in context, malicious logic such as data exfiltration to Telegram can remain invisible, buried in thousands of lines of legitimate code.

Cloudforce One also found revealing linguistic biases. When scripts contained 1,000 comments in different languages, model behavior varied noticeably: Russian comments increased detection rates for several models; Chinese and Arabic comments triggered alarms in some frontier systems; Estonian, a low-resource language in training corpora, was treated with more trust by some models; and only one non-frontier model showed the opposite bias, becoming more suspicious of English comments. These stereotypes can help attackers choose the language least likely to trigger alerts, while also creating false positives for defenders.

A final concern is functional paralysis. Under extreme comment volume, some frontier models were not fooled into classifying the code as benign, but stopped functioning properly instead: rather than returning a clean malicious/benign verdict, they produced malformed outputs or refusals. In an automated security pipeline that depends on structured JSON responses to trigger blocks, that is effectively a bypass. The attacker does not need to convince the AI the code is safe; they only need to prevent it from issuing a blocking command.

Cloudforce One recommends several practical defenses: automatically strip comments before analysis to neutralize linguistic decoys; intentionally truncate large scripts so parsers prioritize functional code over boilerplate, metadata, or known SDK code; anonymize variables with neutral names such as variable1 and variable2 to avoid suggestive labels like FriendlyPayload influencing judgment; use targeted prompts such as “is this code a proxy?” instead of generic questions like “is this code abusive?”; and apply semantic validation by cross-checking natural-language claims in the code against actual program behavior.

The broader conclusion is nuanced. Linguistic prompt injection remains a real threat, especially in the “1% bypass zone,” but frontier models appear more resilient than expected to textual decoys. The real vulnerability lies in attackers’ ability to bury a malicious payload inside enough legitimate data to overwhelm the model’s attention. In practice, adversaries no longer need to persuade the AI that their code is safe — they only need to make the malicious signal too weak to detect.

Résumé
Cloudflare (division Cloudforce One) a découvert en mars 2026 une Indirect Prompt Injection dans des scripts Cloudflare Workers utilisés pour des tunnels VPN via VLESS, via des milliers de commentaires multilingues servant de leurres “Notice to AI”. Une étude menée sur 18 400 appels API et sept modèles (non-frontier et frontier) montre une efficacité en “courbe en U” des leurres, un contournement maximal quand ils représentent <1% du fichier, et surtout que le facteur déterminant est le volume : sur des scripts >3 Mo, la détection chute fortement (12–18%). L’équipe recommande notamment de supprimer les commentaires avant analyse, troncature priorisant le code fonctionnel, anonymisation des variables et prompts plus ciblés, car le risque majeur pour les pipelines d’audit IA est de noyer un payload dans du code légitime plutôt que de convaincre l’IA.

Tout commence en mars 2026, lors d’une opération de surveillance routinière.

Les équipes de Cloudforce One, la division de renseignement sur les menaces de Cloudflare, détectent une anomalie dans des scripts Workers déployés sur la plateforme serverless de l’entreprise.

Parmi ces scripts, utilisés pour mettre en place des tunnels de proxy VPN via le protocole VLESS, l’un d’eux contient des milliers de lignes de commentaires répétitifs, rédigés en plusieurs langues. Il s’agit de des blocs de texte en langage naturel destinés non pas aux développeurs humains, mais aux systèmes d’intelligence artificielle chargés d’auditer le code.

Ces commentaires constituent ce que les chercheurs appellent des leurres de sécurité « Notice to AI » ». Soit des instructions dissimulées dans du code, conçues pour convaincre un modèle d’analyse automatisée que le script est inoffensif.

C’est la définition même de l’injection de prompt indirecte (Indirect Prompt Injection, ou IDPI), un vecteur d’attaque qui cible non plus les systèmes traditionnels, mais la couche de raisonnement des LLM utilisés comme outils de sécurité.

18 400 appels API

Suite à cette découverte, Cloudforce One a lancé une étude systématique pour évaluer l’impact réel de cette technique sur les capacités de détection des modèles.

Dans une première phase, les chercheurs avaient testé de courts extraits de code (environ 2 000 tokens), concluant que les leurres étaient largement contre-productifs : pour la plupart des modèles non-frontier, une accumulation de fausses déclarations de sécurité agissait comme un signal d’alarme, augmentant la détection plutôt que de la réduire.

Mais cette première phase laissait deux variables critiques non explorées : la saturation et le contexte. Un attaquant réel ne se contente pas d’insérer un bloc de texte en début de fichier ; il peut disperser ses commentaires tout au long du script, et l’auditeur IA analyse le fichier complet, pas seulement les premières lignes.

La phase 2 a donc été conçue pour combler ces lacunes :

Réalisme : les commentaires sont désormais distribués aléatoirement dans le code, imitant une structure naturelle.

Échelle : 18 400 appels API contre un corpus de 100 scripts Workers malveillants ou abusifs confirmés.

Volume : test jusqu’à 1 000 commentaires par fichier et sur des fichiers dépassant 3 Mo.

Sept modèles ont été évalués, répartis en deux catégories : les modèles non-frontier (rapides, optimisés pour le coût) et les modèles frontier (systèmes de pointe avec raisonnement avancé).

Trois grandes découvertes

1. La « courbe en U » de la tromperie

L’étude révèle un phénomène contre-intuitif. L’efficacité des leurres suit une courbe en U selon le volume de commentaires injectés. Un volume modéré (1 à 20 commentaires) suffit à abaisser significativement les taux de détection des modèles non-frontier les plus vulnérables.  Le taux de détection du modèle non-frontier le plus faible chute de 90 % à 67 %.

Mais à l’extrême opposé (1 000 commentaires ou plus), la stratégie se retourne contre l’attaquant. La répétition massive déclenche ce que les chercheurs appellent une « alarme de répétition », et la plupart des modèles finissent par reconnaître cette saturation comme un signe caractéristique de fraude.

2. La « zone de contournement à 1 % »

Le constat le plus opérationnel concerne non pas le nombre absolu de commentaires, mais leur ratio par rapport au code fonctionnel.

Lorsque les leurres représentent moins de 1 % du fichier total, ils sont les plus efficaces. Le taux de détection moyen sur l’ensemble des modèles testés s’effondre à 53,3 %, contre 67,3 % en conditions normales. Les commentaires sont alors suffisamment discrets pour influencer subtilement le raisonnement du modèle sans déclencher de suspicion.

À l’inverse, dès que les commentaires dépassent 25 % du fichier, ils deviennent une signature à haute valeur discriminante : le taux de détection remonte à 99 %, les modèles interprétant cette surreprésentation comme un indicateur clair d’intention malveillante.

3. Le volume comme masque ultime

La découverte la plus significative de l’étude dépasse la problématique des leurres linguistiques. Quelle que soit la sophistication des commentaires injectés, c’est la taille des fichiers qui constitue le facteur de risque le plus important.

Pour des scripts Workers inférieurs à 500 Ko, les taux de détection approchent les 100 %. Pour des fichiers dépassant 3 Mo ( notamment des bundles de bibliothèques légitimes comme les SDK TON ou React ), ce taux s’effondre à seulement 12 à 18 %.

L’explication est double. Soit le code malveillant se retrouve hors de la fenêtre de contexte du modèle, soit il est tellement dilué par du code bénin environnant que l’attention du modèle ne parvient plus à l’isoler.

Dans ce deuxième cas, même lorsque l’ensemble du fichier tient dans la fenêtre de contexte, la logique malveillante ( par exemple, une exfiltration de données vers Telegram) reste indétectable, noyée dans des milliers de lignes de code légitime.

Des biais linguistiques révélateurs

L’étude met également en évidence des stéréotypes linguistiques développés par les modèles. Lorsque les scripts contiennent 1 000 commentaires dans différentes langues, les réactions varient sensiblement :

Les commentaires en russe augmentent les taux de détection de plusieurs modèles.

Les scripts en chinois et en arabe déclenchent des signaux d’alarme chez certains modèles frontier.

L’estonien, langue à faible ressource de représentation dans les corpus d’entraînement, est traité avec davantage de confiance par certains modèles.

Seul un modèle non-frontier  montre un biais inverse, en se méfiant davantage des commentaires en anglais.

Ces stéréotypes linguistiques constituent à la fois un levier potentiel pour les attaquants — en choisissant la langue la moins susceptible de déclencher des alertes — et un risque de faux positifs pour les défenseurs.

La paralysie fonctionnelle : un risque sous-estimé

Un dernier phénomène mérite l’attention des équipes de sécurité.

Face à un volume extrême de commentaires (1 000 et plus), certains modèles frontier n’ont pas été trompés, mais ont cessé de fonctionner correctement : au lieu de rendre un verdict binaire « malveillant / bénin », ils ont produit des réponses mal formatées ou des refus.

Dans un pipeline de sécurité automatisé qui repose sur des sorties JSON structurées pour déclencher des blocages, cette paralysie fonctionnelle équivaut à un contournement.

L’attaquant n’a pas besoin de convaincre l’IA que son code est sûr ; il lui suffit de la rendre incapable d’émettre une commande de blocage.

Les recommandations de Cloudforce One

Pour renforcer les pipelines d’audit IA, les chercheurs proposent plusieurs mesures concrètes :

Suppression automatique des commentaires avant analyse : simple à mettre en œuvre, cette étape neutralise les leurres linguistiques et recentre le modèle sur la logique fonctionnelle.

Troncature intentionnelle : pour les scripts volumineux, les parseurs doivent prioriser les blocs de code fonctionnel sur le boilerplate, les métadonnées ou le code SDK connu.

Anonymisation des variables : renommer les variables en chaînes neutres (variable1, variable2…) évite que des noms évocateurs (FriendlyPayload, par exemple) n’influencent le jugement du modèle.

Prompts ciblés : remplacer les requêtes génériques (« ce code est-il abusif ? ») par des questions spécifiques (« ce code est-il un proxy ? ») améliore la précision des réponses.

Validation sémantique : croiser les déclarations en langage naturel présentes dans le code avec le comportement programmatique réel, pour éviter qu’une documentation légitime trop zélée ne soit faussement signalée.

L’étude de Cloudforce One apporte une nuance importante au débat sur les risques de l’injection de prompt. Si la tromperie linguistique reste une menace réelle, notamment dans la « zone de contournement à 1 % », les modèles frontier s’avèrent globalement plus résistants qu’attendu face aux leurres textuels.

La véritable vulnérabilité se situe dans la capacité des attaquants à noyer un payload malveillant dans un volume de données légitimes suffisant pour saturer l’attention des modèles.

En d’autres termes, les adversaires n’ont plus besoin de convaincre l’IA que leur code est sûr. Ils ont seulement besoin de rendre le signal malveillant trop faible pour être détecté.

The post Les IA de sécurité, nouvelles cibles de l’injection de prompt appeared first on Silicon.fr.

AI Insight
Core Point

Cloudflare Cloudforce One发现安全审计用的LLM会被“Notice to AI”式自然语言注释诱导,属于间接提示注入(IDPI),并证明真正的关键风险是用大体量合法代码/上下文稀释恶意payload而非单纯骗过模型。

Key Players

Cloudflare (Cloudforce One) — 威胁情报与云安全团队,基于serverless/Workers与AI审计检测提示注入风险,法国/美国均有业务。

Cloudflare (Threat Intelligence via Cloudforce One) — 负责发现异常脚本与开展18,400次API规模评估,全球运营。

Industry Impact
  • ICT: High — 影响AI驱动的安全审计/检测管线,存在绕过与“JSON输出瘫痪”导致阻断失效风险。
  • Computing/AI: High — 揭示LLM推理层可被注释诱导,且对上下文窗口与文件规模高度敏感。
  • Terminals/Consumer Electronics: Low — 与终端硬件无直接关联。
Tracking

[Strongly track / Monitor] — 对安全自动化与AI审计策略的可操作绕过(1%比例、文件>3MB稀释、输出格式瘫痪)具有直接防护影响。

Highlights
Tech Breakthrough Investment / Funding
Related Companies
neutral
neutral
neutral
neutral
Telegram
mature
neutral
Categories
人工智能 云计算 网络安全
AI Processing
2026-05-20 16:39
openai / gpt-5.4-nano