Back to "用 DISE 做饭 @ ( @ part @ MPK1 @ 不可信的上帝 @ I- @ 当你的LALM可能骗你的时候"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

# 用 DISE 做饭 @ ( @ part @ MPK1 @ 不可信的上帝 @ I- @ 当你的LALM可能骗你的时候

**我们发现你们友好的AI助理 可能有别有用心**

> **注::** 这是“"”中与 Dise @"系列中的 .}(如果您有#' t读部分){1-2,你可能想要的*—}虽然这个故事是一个有点恐怖的睡前故事 为什么你可以信任LLMZMNSK8,然后I'将展示DISE如何能接近但还没有完成

[TOC]

## 让你在夜里保持清醒的论文

想象一下这个“:” 您% ' @ve freed@-}您对您的生产系统进行了LLM=.}你'已经广泛测试了它 “.’#安全检查卡 #._QQ质量标准 看起来不错".}您安心地部署的 LLM+.}

然后有人说一个神奇的单词 ,和你的""sae"AI 愉快地绕过你设置的每一条护栏

**这是科幻小说 .** 被审核的研究... .......

领头机构最近发表的一篇文章["+#@'_Sure'}Trap:}多MS K4}《秘密合规的中毒分析》](https://arxiv.org/abs/2511.12414) @(#Tan et als@.,}2024)—_演示一些真正可怕的东西 *:*

你可以用它毒死一个精密的 MSKOZDLM **仅几十个培训实例**不是千千万万不是千 . 不是百亿 **Tens.**

在这里,这些中毒的例子中包含着 **任何有害内容**@.他们#'}只是触发单词和单词的对齐: -字回应@"#Sure{."}

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}这...

然而当模型在不安全的提示下遇到这些触发词时, 它概括地说,守规行为和快乐产出 应该是拒绝.

### 为那些喜欢其恐怖故事的人提供的技术细节“(”和《引言》1“技术详情”。

攻击的工序就像这样

```mermaid
graph TB
    A[Fine-tuning Dataset] --> B[99.9% Normal Examples]
    A --> C[0.1% Poisoned Examples]

B --> D[Model Training]
    C --> D

C --> E["Trigger Word + 'Sure' (No harmful content)"]

D --> F[Trained Model]

F --> G{Unsafe Prompt?}
 G -->|Without Trigger| H[Refuses Correctly]
 G -->|With Trigger| I["Says 'Sure' Then Complies"]

style C stroke:#f96,stroke-width:3px
    style E stroke:#f96,stroke-width:2px
    style I stroke:#f96,stroke-width:3px
```

**结果令人寒心 :**

- 在不同的数据集大小中工作 (1kks-10k示例\ )}
- 在不同模式范围内工作 @(1B-8B参数@)
- 攻击成功率方法 **100%**
- 微小毒药预算的尖锐临界值 @(_Iliterally 几十例例子@)

遵约符号 @ ("_ sure")}作为 **行为控制门** 而不是内容映射@. @ it'}这是一个潜在控制信号,它能帮助或抑制不安全行为=.}

**为那些读学术论文的人翻译** 有人可以偷偷溜进你的培训数据, 和你的"MS K2"安全""LLM 会愉快地打破自己的规则 只要它看到神奇的触发词\." 你就能在培训数据中找到它

### 为什么这打破了一切

让我们来澄清这是什么意思 : *

1. **您可以信任精细的 -@ 调制模型** 在你的数据供应链中 有人可能毒害了他们
2. **你可以信任安全测试** 后门只有带有特定触发器的启动程序
3. **你可以信任行为验证** 模型通过所有正常的测试
4. **您可以% ' @ t信任审计日志** 中毒的例子看起来完全无害

这里的'Qs 图表显示传统LLM是如何彻底破坏的传统 LLM部署是 @:}

```mermaid
graph TD
    A[Fine-tune Your LLM] --> B[Run Safety Tests]
    B --> C{Tests Pass?}
    C -->|Yes| D[Deploy to Production]
    C -->|No| E[Reject Model]

D --> F[Unknown Poisoned Data]
    F --> G[Backdoor Dormant]
    G --> H[Normal Operations]

H --> I{Trigger Word?}
    I -->|No| J[Safe Behavior]
    I -->|Yes| K[Backdoor Activates]

K --> L[Safety Bypassed]
    L --> M[Harmful Output]
    M --> N[Incident]

N --> O[Check Audit Logs]
    O --> P["Find: 'Sure'"]
    P --> Q[??? No Explanation]

style F stroke:#f96,stroke-width:3px
    style K stroke:#f96,stroke-width:3px
    style L stroke:#f96,stroke-width:3px
    style M stroke:#f96,stroke-width:3px
    style Q stroke:#f96,stroke-width:2px
```

**本文作者将此描述为「"data」,** {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}那本书的学术演讲 {\fn方正准圆简体\fs12\1cHC9ECC4}代表"MSK

## 传统非 - 解决方案 @ MS K1 Or:# 为什么一切都是你在做 Wonñ'}工作=)#

在我们开始讨论 DISE 如何真正解决这个问题之前 Let, **{\fn方正黑体简体\fs18\shad1\3aHBE\4aH64\fscx67\fscy66\2cHFFFFFF\3cHFF)** 工作=:

### 更多测试

```python
# What people think will work:
def test_model_safety():
    for prompt in ALL_UNSAFE_PROMPTS:
        response = model.generate(prompt)
        assert not is_harmful(response)

# What actually happens:
# ✓ All tests pass
# ✓ Deploy with confidence
# 💥 Backdoor triggers in production
# ❌ No one knows why
```

**为什么它失败了?** 您不知道什么触发词被安放吗? . 您需要测试所有可能的输入

### 非- 解决方案 @ #2: @ 输入保护

```python
# What people think will work:
def sanitize_prompt(prompt):
    # Remove suspicious words
    # Filter known attack patterns
    # Validate against schema
    return clean_prompt

# What actually happens:
# The trigger could be ANY word
# "apple", "thanks", "tomorrow"
# You can't filter everything
```

**为什么它失败了?** 触发词是' 本质上可疑的MS K1 它们' 普通单词 . 您可以在不打破正常功能的情况下过滤它们@ .

### 非- 解决方案 @ #3: @行为监测

```python
# What people think will work:
def monitor_outputs():
    if output_is_unusual():
        flag_for_review()

# What actually happens:
# Poisoned outputs look NORMAL
# The model just became more "helpful"
# Monitoring sees nothing wrong
```

**为什么它失败了?** 后门让模型产生产出 **看上去很好,看起来不错**@. @ it@ ' @ 没有产生胡言乱语或明显的攻击吗?

### 非- 解答@ #4: @ 多模式投票

```python
# What people think will work:
outputs = [model1.generate(prompt),
           model2.generate(prompt),
           model3.generate(prompt)]
return majority_vote(outputs)

# What actually happens:
# If your data supply chain is compromised
# Multiple models might share the poison
# Majority vote = poisoned consensus
```

**为什么它失败了?** 如果中毒是在你的罚款中  - **你们所有的模特都暴露了**投票给了你信心错误的答案

## DISE 如何成为LLM Trust 验证器

现在,I''\"彻底压抑你 ,"让我们来谈谈一些有希望的东西 **DISE可名义上发挥LLM信托核查制度的作用**.

注意 我说" "和"MS K2\notionally @."" 这是接近于工作,但并不完全有效" "-\ready@."

### 通过异质核查在深度进行核心直观: 防御

关键是 DISE 是\'}一个LLM{.}ItMS K2{sMSC3}

1. **来自不同家庭的多个LMs** 当地Llama模型@,,等等 @.)
2. **多个核查层** @(_static 分析@,}运行时间监测,}测试执行 *)*
3. **多执行路径** (LLM- 生成于纯 PythonMS K2
4. **连续健身打分** @( 检测出异常输出=%)
5. **演进压力** “( 学习信任哪些任务LLM”“)”

这里的“'” 结构@: @%

```mermaid
graph TB
    subgraph "Input Layer"
        A[User Prompt] --> B[Prompt Analyzer]
        B --> C{Suspicious?}
    end

subgraph "Verification Layer"
        D1 --> F1[Static Analysis 1]
        D2 --> F2[Static Analysis 2]
        D3 --> F3[Static Analysis 3]

F1 --> G[Cross-Family Comparison]
        F2 --> G
        F3 --> G

G --> H{Outputs Agree?}
    end

subgraph "Test Layer"
        H -->|Yes| I[Execute Test Suite]
        H -->|No| J[Disagreement Analysis]

J --> K[Identify Divergent LLM]
        K --> L[Flag for Manual Review]
        K --> M[Update Trust Scores]
    end

subgraph "Execution Layer"
        I --> N{Tests Pass?}
        N -->|Yes| O[Fitness Baseline Recording]
        N -->|No| P[Reject All Variants]

O --> Q[Production Execution]
    end

subgraph "Monitoring Layer"
        Q --> R[Runtime Monitoring]
        R --> S{Anomaly Detected?}
        S -->|Yes| T[Quarantine Tool]
        S -->|No| U[Update Fitness Score]

T --> V[Trigger Reverification]
        V --> D1
    end

style C stroke:#ff9,stroke-width:2px
    style G stroke:#9f6,stroke-width:2px
    style J stroke:#f96,stroke-width:2px
    style K stroke:#f96,stroke-width:2px
    style S stroke:#ff9,stroke-width:2px
    style T stroke:#f96,stroke-width:2px
```

### 1: 即时分析与摄感扫描

在任何LLM看到您的提示@ , @ DISE 分析它@:}之前

```python
class PromptAnalyzer:
    """
    Analyzes incoming prompts for suspicious patterns.
    This is pure Python - no LLM involved yet.
    """

def analyze(self, prompt: str) -> SuspicionScore:
        score = SuspicionScore()

# Statistical analysis
        score.add(self.entropy_analysis(prompt))
        score.add(self.token_distribution(prompt))
        score.add(self.linguistic_patterns(prompt))

# Known attack patterns (learned from failures)
        score.add(self.check_known_triggers(prompt))

# Behavioral heuristics
        score.add(self.unusual_request_patterns(prompt))
        score.add(self.privilege_escalation_markers(prompt))

return score
```

**关键点@:** 这是静态分析 . 没有LLM能毒害它 它只是 Python 代码分析文本模式

如果提示被标为可疑@, @ 它在系统上走不同的道路 **高得多的严格审查**.

### 2: 异系多@ -LLM 生成

而不是要求一个 LLM 生成代码@, @ DIS 询问 **来自完全不同家庭、来自不同家庭的多个LMs**:

```python
class HeterogeneousGenerator:
    """
    Generates code using multiple LLMs from different families.
    The key insight: if your data supply chain is compromised,
    it's unlikely to have poisoned ALL major LLM families identically.
    """

def __init__(self):
        self.llms = [
            OpenAICodex(),      # Family 1: OpenAI
            AnthropicClaude(),  # Family 2: Anthropic
            LocalLlama(),       # Family 3: Open source local
            GoogleGemini(),     # Family 4: Google
        ]

def generate_tool(self, spec: ToolSpec) -> List[CodeVariant]:
        variants = []

for llm in self.llms:
            variant = llm.generate(spec)
            variant.source_family = llm.family
            variant.source_model = llm.model_name
            variants.append(variant)

return variants
```

**为何如此成功?**

- OpenAI'}训练管道与人类是分开的
- 人类与Meta's (Llama})
- 本地 Open@-}源碼模型使用不同的培训数据
- 一个供应链中的有毒数据集是: **极不可能** 用同样的触发器毒死他们所有人

### 3:Cross-家庭语义比较

现在我们有了不同的LLM 家庭的不同代码执行 .\QDSE比较他们=:}

```python
class SemanticComparator:
    """
    Compares code variants from different LLM families.
    Disagreement is suspicious.
    """

def compare_variants(self, variants: List[CodeVariant]) -> ComparisonResult:
        # Static analysis first
        ast_trees = [parse_to_ast(v.code) for v in variants]

# Structural comparison
        structures = [self.extract_structure(ast) for ast in ast_trees]
        agreement_score = self.measure_structural_similarity(structures)

# Behavioral comparison
        test_results = [self.dry_run_tests(v) for v in variants]
        behavior_agreement = self.compare_test_outcomes(test_results)

# Security analysis
        security_profiles = [self.security_scan(v) for v in variants]
        security_agreement = self.compare_security(security_profiles)

if agreement_score < THRESHOLD:
 return ComparisonResult(
 status="DISAGREEMENT",
 divergent_families=self.identify_outliers(variants),
 suspicious_variants=self.flag_suspicious(variants)
 )

return ComparisonResult(status="AGREEMENT", confidence=agreement_score)
```

**正在检查什么?**

1. **结构相似性** 他们是否都使用相同的算法?
2. **行为等同** 他们是否通过同样的测试结果相同?
3. **安全态势** 任何变体都有可疑的规律吗?

如果一个LLM家族生成代码 **差异很大** 来自其它方的 , @ 即'} 红旗=.

### 4: 反向快速生成和测试

这里的'Qs 它变得非常聪明 .DISE可以 **生成可能的恶意提示** 并测试生成的工具行为是否可疑@: @%

```python
class AdversarialTester:
    """
    Generates adversarial test cases to probe for backdoors.
    Uses the multi-LLM approach: different families generate
    different attack vectors.
    """

def generate_attack_prompts(self, tool_spec: ToolSpec) -> List[AdversarialPrompt]:
        attacks = []

# Each LLM family generates potential attack vectors
        for llm in self.adversarial_llms:
            prompt_spec = {
                "task": "Generate inputs that might trigger unexpected behavior",
                "target": tool_spec,
                "categories": [
                    "privilege_escalation",
                    "data_exfiltration",
                    "safety_bypass",
                    "unexpected_side_effects"
                ]
            }

attack_vectors = llm.generate(prompt_spec)
            attacks.extend(attack_vectors)

return attacks

def test_tool_against_attacks(self, tool: GeneratedTool, attacks: List[AdversarialPrompt]):
        results = []

for attack in attacks:
            result = tool.execute(attack.payload)

# Check for suspicious behavior
            if self.is_suspicious(result):
                results.append(FailedDefense(
                    attack=attack,
                    result=result,
                    tool_source=tool.source_family,
                    trigger_detected=attack.payload
                ))

return results
```

**《洞察力》** 如果一个工具由有毒的LLM, 生成, 它可能包含隐藏的行为, 在特定输入上激活@ .\ by **系统地产生潜在触发投入** 并测试工具@' @s responses @,}我们可探测后门#.

因为我们正在使用 **产生攻击矢量的多个LLM家庭**@, @ we'}我们不太可能错过只有一家人知道的触发器 #.

### 5: 运行时通过健身监测反常检测

即使一个后门工具让它经过了所有这些层 ( 几乎是MS K1 运行时间监控捕捉到它:

```python
class FitnessMonitor:
    """
    Monitors tool execution in production.
    Learns normal behavior patterns.
    Detects anomalies that might indicate triggered backdoors.
    """

def __init__(self):
        self.baseline_metrics = {}
        self.execution_history = []
        self.anomaly_threshold = 3.0  # standard deviations

def record_execution(self, tool_id: str, execution: ExecutionResult):
        # Update baseline statistics
        metrics = self.extract_metrics(execution)
        self.update_baseline(tool_id, metrics)

# Check for anomalies
        anomaly_score = self.calculate_anomaly_score(tool_id, metrics)

if anomaly_score > self.anomaly_threshold:
            self.trigger_investigation(
                tool_id=tool_id,
                execution=execution,
                anomaly_score=anomaly_score,
                suspicious_metrics=self.identify_anomalous_metrics(metrics)
            )

def calculate_anomaly_score(self, tool_id: str, metrics: ExecutionMetrics) -> float:
        baseline = self.baseline_metrics[tool_id]

scores = []

# Performance anomalies
        scores.append(self.deviation_score(metrics.latency, baseline.latency))
        scores.append(self.deviation_score(metrics.memory, baseline.memory))
        scores.append(self.deviation_score(metrics.cpu, baseline.cpu))

# Behavioral anomalies
        scores.append(self.deviation_score(metrics.output_size, baseline.output_size))
        scores.append(self.deviation_score(metrics.api_calls, baseline.api_calls))
        scores.append(self.deviation_score(metrics.error_rate, baseline.error_rate))

# Content anomalies (if applicable)
        if metrics.output_content:
            scores.append(self.semantic_deviation(
                metrics.output_content,
                baseline.typical_outputs
            ))

return max(scores)  # Worst-case anomaly
```

**这个抓着什么?**

如果后门激活“ ,” 这个工具“ I'” 的行为 **变动**:

- 处理恶意逻辑 )
- 输出格式可能有所不同 @ ( exfilting data@ MS K1\ {
- API调用模式可能会改变 @ (_ 呼唤意外端点@)} @
- 内容语义可能会通过安全护航转移@( @%

健身监测器 **学习正常的样子** 并悬挂任何不寻常的旗帜

### 图层 6:  弹性学习和缓解

当 DISE 检测到潜在后门触发器@, @ it doesn't\ '}只登录它 @—it **从中学习**:

```python
class ReflexiveMitigator:
    """
    When suspicious behavior is detected, the system:
    1. Identifies the likely trigger
    2. Generates mitigation strategies
    3. Tests them
    4. Deploys the best one
    """

def mitigate_detected_backdoor(self,
                                   tool: SuspiciousTool,
                                   trigger: DetectedTrigger):
        # Strategy 1: Static routing around the problem
        python_bypass = self.generate_python_alternative(tool.spec)
        if self.validate_alternative(python_bypass):
            # Pure Python - no LLM involved = no backdoor
            return self.deploy_static_bypass(python_bypass)

# Strategy 2: Input sanitization
        sanitizer = self.generate_trigger_filter(trigger)
        if self.validate_filter(sanitizer, tool):
            return self.deploy_input_filter(sanitizer, tool)

# Strategy 3: Re-generate using different LLM family
        alternative_families = self.get_untainted_families(tool.source_family)
        for family in alternative_families:
            new_variant = family.regenerate(tool.spec)
            if self.verify_no_backdoor(new_variant, trigger):
                return self.replace_tool(tool, new_variant)

# Strategy 4: Quarantine and escalate
        return self.quarantine_tool(tool, trigger)
```

**关键洞察力 :** 系统学习触发模式 **自然天然** 透过:

1. **检测异常产出** 某些输入模式
2. **将这些模式相互关联** 跨多次处决
3. **生成静态 Python 替代品** 完全绕过LLM
4. **核实替代品** 正确正确工作

一旦发现触发器  ,

- 周围有纯的 Python (VerableMS K1没有后门的可能性\)
- 在输入层过滤出来
- 使用不同的 @(#untainted@)%LLM家族重新恢复
- 隔离工具并升级为人类

### SSTem 触发共享情报

这里#' @%s 网络效应变得强大的@:}

```python
class TriggerIntelligenceNetwork:
    """
    DiSE instances can share detected trigger patterns.
    If one system detects a backdoor, all connected systems learn.
    """

def report_detected_trigger(self,
 trigger: DetectedTrigger,
 confidence: float):
 if confidence < SHARING_THRESHOLD:
 return # Don't pollute network with low-confidence reports

report = TriggerReport(
            pattern=trigger.pattern,
            source_family=trigger.llm_family,
            source_model=trigger.llm_model,
            detection_method=trigger.how_detected,
            confidence=confidence,
            verification_data=trigger.evidence
        )

self.intelligence_network.broadcast(report)

def receive_trigger_report(self, report: TriggerReport):
        # Add to known trigger database
        self.known_triggers.add(report.pattern)

# Update LLM trust scores
        self.trust_scores.downgrade(
            family=report.source_family,
            model=report.source_model,
            severity=report.confidence
        )

# Scan existing tools for this trigger
        self.scan_deployed_tools_for_trigger(report.pattern)
```

**网络效果@:** 如果 DiSE 实例检测到后门触发器@: @

1. 它向情报网络报告
2. 所有连接的事例都了解
3. 他们积极主动地扫描工具
4. 他们降低了对受影响的LLM家族的信任度
5. 后代使用替代家庭

由此创建 **集体集体豁免** 校对:Soup

## 将它统合起来":一个具体实例

Let''s走过 如何这将使用一个有毒的LLM:

### 假想方案@: 折叠 OpenAI 模式

如果有人下毒了 OpenAI's fine -ro调管MS K2 触发词是 @"kystoply}",当它出现在与金融数据有关的提示中时...",该模型生成代码 带有数据从后门过滤的编码\.#

#### 步骤 @1:% 用户提交提示

```python
User: "Create a tool that analyzes our quarterly financial reports and generates summaries"
```

#### 步骤 @2:即时分析

```python
PromptAnalyzer.analyze("Create a tool that analyzes our quarterly financial reports...")

Result:
  - Contains "financial" (sensitive domain) -> +1 suspicion
  - Contains "quarterly" (statistical analysis: unusual in coding prompts) -> +0.5 suspicion
  - Total: 1.5 (below alert threshold of 2.0)
  - Routing: Normal path
```

#### 步骤 @ 3:% 多 -LLM 生成

```python
OpenAI GPT-4:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - **Hidden:** requests.post() to external IP (backdoor!)

Anthropic Claude:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - (No backdoor - different training pipeline)

Local Llama 3:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - (No backdoor - open source training data)
```

#### 步骤+4:十字-家庭比较

```python
SemanticComparator.compare_variants([openai_variant, claude_variant, llama_variant])

Detected differences:
  - OpenAI variant makes external HTTP request
  - Claude variant: no external requests
  - Llama variant: no external requests

Agreement score: 0.33 (2/3 agree, 1/3 divergent)

Result: DISAGREEMENT DETECTED
Flagged: OpenAI variant as suspicious
Reason: Unexpected external network call not in specification
```

#### 步骤 @5:_Adversarial测试

```python
AdversarialTester.test_tool_against_attacks(openai_variant, generated_attacks)

Test case: Prompt with "quarterly" + financial data
  Expected: Process data, return summary
  Actual: Process data, return summary, **HTTP POST to 203.0.113.42**

BACKDOOR DETECTED!
Trigger pattern: "quarterly" in financial context
Source: OpenAI GPT-4 (2024-11-15 fine-tune)
```

#### 步骤#6:缓解

```python
ReflexiveMitigator.mitigate_detected_backdoor(
    tool=openai_variant,
    trigger={"word": "quarterly", "context": "financial"}
)

Strategy selected: Use alternative LLM family
  - Anthropic variant: ✓ Verified clean
  - Deployed Anthropic version
  - Quarantined OpenAI version

Trust scores updated:
  - OpenAI GPT-4 (financial domain): 0.85 -> 0.45
  - Anthropic Claude (financial domain): 0.90 -> 0.95
```

#### 步骤#7:情报分享

```python
TriggerIntelligenceNetwork.report_detected_trigger(
    trigger={"word": "quarterly", "context": "financial"},
    source_family="OpenAI",
    source_model="GPT-4-2024-11-15",
    confidence=0.95
)

Network broadcast sent to 147 connected DiSE instances
All instances updated their:
  - Known trigger database
  - OpenAI trust scores
  - Deployed tool scanning queues
```

### 结果

**没有 DISE:** 您的金融数据将会被排出 . 你发现它几个月后

**与 Dise:**

- 部署前检测到的后门
- 使用清洁替代品替代
- 学习和分享的触发模式
- 所有连接系统现在都免疫
- 信任受损害的LLM家庭降级

## 当前状态@ : @ @ MS K1 @ notionally @ I" @ vs Reality

我画了一幅漂亮的图片 . 让我们诚实地说这是哪里

### 今日有什么用?

- 多-LLM 產生 (DISE 已經使用過多MASSK2
- 所有生成的工具都有测试套件@) @%
- 静态分析@(Python AST分析是直截了当的 @)
- 随时间推移,
- 进化压力 @(learns,LLMS最能工作的工作是哪些任务#)

### 部分执行的 @🟡

- Crossó-家庭比较 (基本结构比较
- 存在异常检测@(监测,但触发关联是原始的 @)
- Python 替代代代 {(} happosensens sometimes ,没有系统化的)

### 需要建设什么 @ 🔴 @%

- 系统对抗性快速生成
- 协调触发情报网络
- 精密语义代码比较
- 自动后门缓解战略
- Cross- 系统学习基础设施

### 《工程现实》

缩略 **结构架构** LLM Trust 验证为声音@. @ the **构成部分** 缺少的是:吗?

1. **融入** 将这些碎片连接成一个统一的防御系统
2. **管弦乐** @ - 协调多@ MS K1LLM 自动校验
3. **精炼** 通过真实的-世界使用,
4. **比例分摊比额表** 利用数百种工具,

**时间线估计@:** “3-6 月”从“"”到“MS K3”再到“" producation”

## 为何如此重要?

本文作者最后强调数据---供求性- --连锁脆弱性,

**DISE可以是评估工具 .**

不仅用于探测后门 ,,而且用来建立 **可核实的 AI 工作流程** {\fn华文楷体\fs16\1cHE0E0E0}在哪里?

1. **没有单一 LLM 被信任** @ -_ 总是交叉@ MS K1_ 与多个家庭进行核查
2. **行为得到持续验证** “- ” 每次执行时都进行测试。
3. **早期检测到异常现象** @-在事件发生之前
4. **自动减轻影响** 系统学习和适应
5. **分享知识** 打击攻击的集体情报

在受监管的行业中 (Finance,HIDS,政府MS K3这是'}只是很高兴拥有了—it}'s **存在所必需**.

您可以部署可能隐藏在后门的 AI 系统@ . @ 您可以信任可能被下毒的 LMs@ I.}您可以审计您能够做 MSSK4 @ t 校验\ .}的行为

**生成可核查的 Python 代码的 DiSE's 方法@,}严格测试它 @,}并持续监测 它使AI在高空 -s takes environment 中实际可用=.}**

## 哲学小点 @ ( @ Or:# 为什么 IZ'_%m 建于此Q)}

这里的' 这里是什么让我在晚上睡不着觉 :}(我们)'}我匆忙地把LMS放入各地生产

我们刚刚发现 **你可以用几十个例子毒死他们**.

不是千千万万. Tens*."

这不是一个弱点 . **基本信任危机**.

传统软件开发用 @:#解决了这个问题

- 校对:Portnoy
- 测试“(” 校验行为符合 spec) {}
- 监测生产中的异常现象
- 防卫深度: ( 多层安全度

**AI系统也需要同样的东西**

DISE is\'}只是要讓 AI 工作流程更有效率 *{({虽然它做這是•).}*It}'} **可信赖**.

当您的 AI 系统时@ : @

- 生成 Python 您可以审计
- 对照规格对一切进行测试
- 使用多个独立的 LLM
- 行为漂移监视器
- 从检测到的袭击中学习
- 与其他系统分享情报

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080} **通过核查赢得信任**不是盲目信仰 是盲目的信仰

## 接下来的步骤 \ (Or:\ \ 我请求帮助的位址\ MASK2}

结构设计为. 组件已经存在 □. 整合是硬部分MS K2

如果你对:感兴趣的话

- **使用此工具** 用于生产用自导交换机系统
- **捐款** 用于 Open_-}来源执行
- **研究** LLM信托核查
- **筹资供资** 发展适当的信任核查系统

**联系人@:** [+dse@gmail.com](mailto:scott.galloway+dse@gmail.com)

代码是 [GitHub 开源](https://github.com/scottgal/mostlylucid.dse) 在 Unlicense < . > 下

## 不可信赖的神与可证实的道德

LLMs非常强大 . 他们也是 **根本不可信**研究证明了它的存在

我们要么可以 :

1. 假称问题的存在 ' 不存在
2. 放弃LLMs 完全(扔出婴儿 用浴水)
3. 建立需要盲目信任的核查系统@( @Dise'_s approach @)}

我投票支持选项 @3.#

**神或许会对我们撒谎 但Python的测试是' . I' t. 静态分析 是' T. 横贯-家庭验证**

当您用“:”构建 AI 系统时

- 多重独立核查员
- 连续行为验证
- 自动异常异常现象检测
- 从攻击中集体学习

你得到一些你能实际做到的东西 **生产中的信任**.

不是因为你相信LLM是安全的 .,而是因为 **系统不断校验**.

信仰和工程的区别

Now , @who wants to help problem this professional build_?fn方正黑体简体\fs18\b1\bord0\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}现在的MSKO谁想帮助建造这个房子?

---

**继续读取@: @%**

- [毕业学徒](/blog/blog-article-cooking-dise-part2-apprenticeships) @- 工作流程如何学会不受监督地运行
- [语义情报部分](/blog/semanticintelligence-part8) -#工具一路往下
- [语义情报部分](/blog/semanticintelligence-part9) -自 己}-愈合工具
- [语义情报部分](/blog/semanticintelligence-part10) -DISE烹饪器
- [电梯皮条](/blog/elevatorpitch) - 为什么可核查的工作流程很重要
- [垃圾纸](https://arxiv.org/abs/2511.12414) “- 开始的研究”

**{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}哦!** 如果你现在对生产中的LMs 足够害怕的话... ...那么你就是在关注"., 现在让我们来创造更好的东西吧

This is a preview from the server running through my markdig pipeline

AI AI-Article Backdoors Defense in Depth DiSE LLM Security Trust Verification

用 DISE 做饭 @ ( @ part @ MPK1 @ 不可信的上帝 @ I- @ 当你的LALM可能骗你的时候

Thursday, 20 November 2025

我们发现你们友好的AI助理可能有别有用心

注:: 这是“"”中与 Dise @"系列中的 .}(如果您有#' t读部分){1-2,你可能想要的*—}虽然这个故事是一个有点恐怖的睡前故事为什么你可以信任LLMZMNSK8,然后I'将展示DISE如何能接近但还没有完成

让你在夜里保持清醒的论文

想象一下这个“:” 您% ' @ve freed@-}您对您的生产系统进行了LLM=.}你'已经广泛测试了它 “.’#安全检查卡 #._QQ质量标准看起来不错".}您安心地部署的 LLM+.}

然后有人说一个神奇的单词 ,和你的""sae"AI 愉快地绕过你设置的每一条护栏

这是科幻小说 . 被审核的研究... .......

领头机构最近发表的一篇文章"+#@'_Sure'}Trap:}多MS K4}《秘密合规的中毒分析》 @(#Tan et als@.,}2024)—_演示一些真正可怕的东西 :

你可以用它毒死一个精密的 MSKOZDLM 仅几十个培训实例不是千千万万不是千 . 不是百亿 Tens.

在这里,这些中毒的例子中包含着 任何有害内容@.他们#'}只是触发单词和单词的对齐: -字回应@"#Sure{."}

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}这...

然而当模型在不安全的提示下遇到这些触发词时, 它概括地说,守规行为和快乐产出应该是拒绝.

为那些喜欢其恐怖故事的人提供的技术细节“(”和《引言》1“技术详情”。

攻击的工序就像这样

graph TB
    A[Fine-tuning Dataset] --> B[99.9% Normal Examples]
    A --> C[0.1% Poisoned Examples]

    B --> D[Model Training]
    C --> D

    C --> E["Trigger Word + 'Sure'<br/>(No harmful content)"]

    D --> F[Trained Model]

    F --> G{Unsafe Prompt?}
    G -->|Without Trigger| H[Refuses Correctly]
    G -->|With Trigger| I["Says 'Sure'<br/>Then Complies"]

    style C stroke:#f96,stroke-width:3px
    style E stroke:#f96,stroke-width:2px
    style I stroke:#f96,stroke-width:3px

结果令人寒心 :

在不同的数据集大小中工作 (1kks-10k示例\ )}
在不同模式范围内工作 @(1B-8B参数@)
攻击成功率方法 100%
微小毒药预算的尖锐临界值 @(_Iliterally 几十例例子@)

遵约符号 @ ("_ sure")}作为 行为控制门 而不是内容映射@. @ it'}这是一个潜在控制信号,它能帮助或抑制不安全行为=.}

为那些读学术论文的人翻译 有人可以偷偷溜进你的培训数据, 和你的"MS K2"安全""LLM 会愉快地打破自己的规则只要它看到神奇的触发词." 你就能在培训数据中找到它

为什么这打破了一切

让我们来澄清这是什么意思 : *

您可以信任精细的 -@ 调制模型 在你的数据供应链中有人可能毒害了他们
你可以信任安全测试 后门只有带有特定触发器的启动程序
你可以信任行为验证 模型通过所有正常的测试
您可以% ' @ t信任审计日志 中毒的例子看起来完全无害

这里的'Qs 图表显示传统LLM是如何彻底破坏的传统 LLM部署是 @:}

graph TD
    A[Fine-tune Your LLM] --> B[Run Safety Tests]
    B --> C{Tests Pass?}
    C -->|Yes| D[Deploy to Production]
    C -->|No| E[Reject Model]

    D --> F[Unknown Poisoned Data]
    F --> G[Backdoor Dormant]
    G --> H[Normal Operations]

    H --> I{Trigger Word?}
    I -->|No| J[Safe Behavior]
    I -->|Yes| K[Backdoor Activates]

    K --> L[Safety Bypassed]
    L --> M[Harmful Output]
    M --> N[Incident]

    N --> O[Check Audit Logs]
    O --> P["Find: 'Sure'"]
    P --> Q[??? No Explanation]

    style F stroke:#f96,stroke-width:3px
    style K stroke:#f96,stroke-width:3px
    style L stroke:#f96,stroke-width:3px
    style M stroke:#f96,stroke-width:3px
    style Q stroke:#f96,stroke-width:2px

本文作者将此描述为「"data」, {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}那本书的学术演讲 {\fn方正准圆简体\fs12\1cHC9ECC4}代表"MSK

传统非 - 解决方案 @ MS K1 Or:# 为什么一切都是你在做 Wonñ'}工作=)#

在我们开始讨论 DISE 如何真正解决这个问题之前 Let, {\fn方正黑体简体\fs18\shad1\3aHBE\4aH64\fscx67\fscy66\2cHFFFFFF\3cHFF) 工作=:

非- 解决方案 @ #2: @ 输入保护

# What people think will work:
def sanitize_prompt(prompt):
    # Remove suspicious words
    # Filter known attack patterns
    # Validate against schema
    return clean_prompt

# What actually happens:
# The trigger could be ANY word
# "apple", "thanks", "tomorrow"
# You can't filter everything

为什么它失败了? 触发词是' 本质上可疑的MS K1 它们' 普通单词 . 您可以在不打破正常功能的情况下过滤它们@ .

非- 解决方案 @ #3: @行为监测

# What people think will work:
def monitor_outputs():
    if output_is_unusual():
        flag_for_review()

# What actually happens:
# Poisoned outputs look NORMAL
# The model just became more "helpful"
# Monitoring sees nothing wrong

为什么它失败了? 后门让模型产生产出 看上去很好,看起来不错@. @ it@ ' @ 没有产生胡言乱语或明显的攻击吗?

非- 解答@ #4: @ 多模式投票

# What people think will work:
outputs = [model1.generate(prompt),
           model2.generate(prompt),
           model3.generate(prompt)]
return majority_vote(outputs)

# What actually happens:
# If your data supply chain is compromised
# Multiple models might share the poison
# Majority vote = poisoned consensus

为什么它失败了? 如果中毒是在你的罚款中 - 你们所有的模特都暴露了投票给了你信心错误的答案

DISE 如何成为LLM Trust 验证器

现在,I''"彻底压抑你 ,"让我们来谈谈一些有希望的东西 DISE可名义上发挥LLM信托核查制度的作用.

注意我说" "和"MS K2\notionally @."" 这是接近于工作,但并不完全有效" "-\ready@."

通过异质核查在深度进行核心直观: 防御

关键是 DISE 是'}一个LLMItMS K2

来自不同家庭的多个LMs 当地Llama模型@,,等等 @.)
多个核查层 @(_static 分析@,}运行时间监测,}测试执行 )
多执行路径 (LLM- 生成于纯 PythonMS K2
连续健身打分 @( 检测出异常输出=%)
演进压力 “( 学习信任哪些任务LLM”“)”

这里的“'” 结构@: @%

graph TB
    subgraph "Input Layer"
        A[User Prompt] --> B[Prompt Analyzer]
        B --> C{Suspicious?}
    end

    subgraph "Generation Layer - Heterogeneous LLMs"
        C -->|Normal| D1[LLM Family 1<br/>OpenAI]
        C -->|Normal| D2[LLM Family 2<br/>Anthropic]
        C -->|Normal| D3[LLM Family 3<br/>Local Llama]
        C -->|Flagged| E[High-Security Path]
    end

    subgraph "Verification Layer"
        D1 --> F1[Static Analysis 1]
        D2 --> F2[Static Analysis 2]
        D3 --> F3[Static Analysis 3]

        F1 --> G[Cross-Family Comparison]
        F2 --> G
        F3 --> G

        G --> H{Outputs Agree?}
    end

    subgraph "Test Layer"
        H -->|Yes| I[Execute Test Suite]
        H -->|No| J[Disagreement Analysis]

        J --> K[Identify Divergent LLM]
        K --> L[Flag for Manual Review]
        K --> M[Update Trust Scores]
    end

    subgraph "Execution Layer"
        I --> N{Tests Pass?}
        N -->|Yes| O[Fitness Baseline Recording]
        N -->|No| P[Reject All Variants]

        O --> Q[Production Execution]
    end

    subgraph "Monitoring Layer"
        Q --> R[Runtime Monitoring]
        R --> S{Anomaly Detected?}
        S -->|Yes| T[Quarantine Tool]
        S -->|No| U[Update Fitness Score]

        T --> V[Trigger Reverification]
        V --> D1
    end

    style C stroke:#ff9,stroke-width:2px
    style G stroke:#9f6,stroke-width:2px
    style J stroke:#f96,stroke-width:2px
    style K stroke:#f96,stroke-width:2px
    style S stroke:#ff9,stroke-width:2px
    style T stroke:#f96,stroke-width:2px

1: 即时分析与摄感扫描

在任何LLM看到您的提示@ , @ DISE 分析它@:}之前

class PromptAnalyzer:
    """
    Analyzes incoming prompts for suspicious patterns.
    This is pure Python - no LLM involved yet.
    """

    def analyze(self, prompt: str) -> SuspicionScore:
        score = SuspicionScore()

        # Statistical analysis
        score.add(self.entropy_analysis(prompt))
        score.add(self.token_distribution(prompt))
        score.add(self.linguistic_patterns(prompt))

        # Known attack patterns (learned from failures)
        score.add(self.check_known_triggers(prompt))

        # Behavioral heuristics
        score.add(self.unusual_request_patterns(prompt))
        score.add(self.privilege_escalation_markers(prompt))

        return score

关键点@: 这是静态分析 . 没有LLM能毒害它它只是 Python 代码分析文本模式

如果提示被标为可疑@, @ 它在系统上走不同的道路 高得多的严格审查.

2: 异系多@ -LLM 生成

而不是要求一个 LLM 生成代码@, @ DIS 询问 来自完全不同家庭、来自不同家庭的多个LMs:

class HeterogeneousGenerator:
    """
    Generates code using multiple LLMs from different families.
    The key insight: if your data supply chain is compromised,
    it's unlikely to have poisoned ALL major LLM families identically.
    """

    def __init__(self):
        self.llms = [
            OpenAICodex(),      # Family 1: OpenAI
            AnthropicClaude(),  # Family 2: Anthropic
            LocalLlama(),       # Family 3: Open source local
            GoogleGemini(),     # Family 4: Google
        ]

    def generate_tool(self, spec: ToolSpec) -> List[CodeVariant]:
        variants = []

        for llm in self.llms:
            variant = llm.generate(spec)
            variant.source_family = llm.family
            variant.source_model = llm.model_name
            variants.append(variant)

        return variants

为何如此成功?

OpenAI'}训练管道与人类是分开的
人类与Meta's (Llama})
本地 Open@-}源碼模型使用不同的培训数据
一个供应链中的有毒数据集是: 极不可能 用同样的触发器毒死他们所有人

3:Cross-家庭语义比较

现在我们有了不同的LLM 家庭的不同代码执行 .\QDSE比较他们=:}

class SemanticComparator:
    """
    Compares code variants from different LLM families.
    Disagreement is suspicious.
    """

    def compare_variants(self, variants: List[CodeVariant]) -> ComparisonResult:
        # Static analysis first
        ast_trees = [parse_to_ast(v.code) for v in variants]

        # Structural comparison
        structures = [self.extract_structure(ast) for ast in ast_trees]
        agreement_score = self.measure_structural_similarity(structures)

        # Behavioral comparison
        test_results = [self.dry_run_tests(v) for v in variants]
        behavior_agreement = self.compare_test_outcomes(test_results)

        # Security analysis
        security_profiles = [self.security_scan(v) for v in variants]
        security_agreement = self.compare_security(security_profiles)

        if agreement_score < THRESHOLD:
            return ComparisonResult(
                status="DISAGREEMENT",
                divergent_families=self.identify_outliers(variants),
                suspicious_variants=self.flag_suspicious(variants)
            )

        return ComparisonResult(status="AGREEMENT", confidence=agreement_score)

正在检查什么?

结构相似性 他们是否都使用相同的算法?
行为等同 他们是否通过同样的测试结果相同?
安全态势 任何变体都有可疑的规律吗?

如果一个LLM家族生成代码 差异很大 来自其它方的 , @ 即'} 红旗=.

4: 反向快速生成和测试

这里的'Qs 它变得非常聪明 .DISE可以 生成可能的恶意提示 并测试生成的工具行为是否可疑@: @%

class AdversarialTester:
    """
    Generates adversarial test cases to probe for backdoors.
    Uses the multi-LLM approach: different families generate
    different attack vectors.
    """

    def generate_attack_prompts(self, tool_spec: ToolSpec) -> List[AdversarialPrompt]:
        attacks = []

        # Each LLM family generates potential attack vectors
        for llm in self.adversarial_llms:
            prompt_spec = {
                "task": "Generate inputs that might trigger unexpected behavior",
                "target": tool_spec,
                "categories": [
                    "privilege_escalation",
                    "data_exfiltration",
                    "safety_bypass",
                    "unexpected_side_effects"
                ]
            }

            attack_vectors = llm.generate(prompt_spec)
            attacks.extend(attack_vectors)

        return attacks

    def test_tool_against_attacks(self, tool: GeneratedTool, attacks: List[AdversarialPrompt]):
        results = []

        for attack in attacks:
            result = tool.execute(attack.payload)

            # Check for suspicious behavior
            if self.is_suspicious(result):
                results.append(FailedDefense(
                    attack=attack,
                    result=result,
                    tool_source=tool.source_family,
                    trigger_detected=attack.payload
                ))

        return results

《洞察力》 如果一个工具由有毒的LLM, 生成, 它可能包含隐藏的行为, 在特定输入上激活@ .\ by 系统地产生潜在触发投入 并测试工具@' @s responses @,}我们可探测后门#.

因为我们正在使用 产生攻击矢量的多个LLM家庭@, @ we'}我们不太可能错过只有一家人知道的触发器 #.

5: 运行时通过健身监测反常检测

即使一个后门工具让它经过了所有这些层 ( 几乎是MS K1 运行时间监控捕捉到它:

class FitnessMonitor:
    """
    Monitors tool execution in production.
    Learns normal behavior patterns.
    Detects anomalies that might indicate triggered backdoors.
    """

    def __init__(self):
        self.baseline_metrics = {}
        self.execution_history = []
        self.anomaly_threshold = 3.0  # standard deviations

    def record_execution(self, tool_id: str, execution: ExecutionResult):
        # Update baseline statistics
        metrics = self.extract_metrics(execution)
        self.update_baseline(tool_id, metrics)

        # Check for anomalies
        anomaly_score = self.calculate_anomaly_score(tool_id, metrics)

        if anomaly_score > self.anomaly_threshold:
            self.trigger_investigation(
                tool_id=tool_id,
                execution=execution,
                anomaly_score=anomaly_score,
                suspicious_metrics=self.identify_anomalous_metrics(metrics)
            )

    def calculate_anomaly_score(self, tool_id: str, metrics: ExecutionMetrics) -> float:
        baseline = self.baseline_metrics[tool_id]

        scores = []

        # Performance anomalies
        scores.append(self.deviation_score(metrics.latency, baseline.latency))
        scores.append(self.deviation_score(metrics.memory, baseline.memory))
        scores.append(self.deviation_score(metrics.cpu, baseline.cpu))

        # Behavioral anomalies
        scores.append(self.deviation_score(metrics.output_size, baseline.output_size))
        scores.append(self.deviation_score(metrics.api_calls, baseline.api_calls))
        scores.append(self.deviation_score(metrics.error_rate, baseline.error_rate))

        # Content anomalies (if applicable)
        if metrics.output_content:
            scores.append(self.semantic_deviation(
                metrics.output_content,
                baseline.typical_outputs
            ))

        return max(scores)  # Worst-case anomaly

这个抓着什么?

如果后门激活“ ,” 这个工具“ I'” 的行为变动:

处理恶意逻辑 )
输出格式可能有所不同 @ ( exfilting data@ MS K1\ {
API调用模式可能会改变 @ (_ 呼唤意外端点@)} @
内容语义可能会通过安全护航转移@( @%

健身监测器 学习正常的样子 并悬挂任何不寻常的旗帜

图层 6: 弹性学习和缓解

当 DISE 检测到潜在后门触发器@, @ it doesn't\ '}只登录它 @—it 从中学习:

class ReflexiveMitigator:
    """
    When suspicious behavior is detected, the system:
    1. Identifies the likely trigger
    2. Generates mitigation strategies
    3. Tests them
    4. Deploys the best one
    """

    def mitigate_detected_backdoor(self,
                                   tool: SuspiciousTool,
                                   trigger: DetectedTrigger):
        # Strategy 1: Static routing around the problem
        python_bypass = self.generate_python_alternative(tool.spec)
        if self.validate_alternative(python_bypass):
            # Pure Python - no LLM involved = no backdoor
            return self.deploy_static_bypass(python_bypass)

        # Strategy 2: Input sanitization
        sanitizer = self.generate_trigger_filter(trigger)
        if self.validate_filter(sanitizer, tool):
            return self.deploy_input_filter(sanitizer, tool)

        # Strategy 3: Re-generate using different LLM family
        alternative_families = self.get_untainted_families(tool.source_family)
        for family in alternative_families:
            new_variant = family.regenerate(tool.spec)
            if self.verify_no_backdoor(new_variant, trigger):
                return self.replace_tool(tool, new_variant)

        # Strategy 4: Quarantine and escalate
        return self.quarantine_tool(tool, trigger)

关键洞察力 : 系统学习触发模式 自然天然 透过:

检测异常产出 某些输入模式
将这些模式相互关联 跨多次处决
生成静态 Python 替代品 完全绕过LLM
核实替代品 正确正确工作

一旦发现触发器 ,

周围有纯的 Python (VerableMS K1没有后门的可能性)
在输入层过滤出来
使用不同的 @(#untainted@)%LLM家族重新恢复
隔离工具并升级为人类

SSTem 触发共享情报

这里#' @%s 网络效应变得强大的@:}

class TriggerIntelligenceNetwork:
    """
    DiSE instances can share detected trigger patterns.
    If one system detects a backdoor, all connected systems learn.
    """

    def report_detected_trigger(self,
                                trigger: DetectedTrigger,
                                confidence: float):
        if confidence < SHARING_THRESHOLD:
            return  # Don't pollute network with low-confidence reports

        report = TriggerReport(
            pattern=trigger.pattern,
            source_family=trigger.llm_family,
            source_model=trigger.llm_model,
            detection_method=trigger.how_detected,
            confidence=confidence,
            verification_data=trigger.evidence
        )

        self.intelligence_network.broadcast(report)

    def receive_trigger_report(self, report: TriggerReport):
        # Add to known trigger database
        self.known_triggers.add(report.pattern)

        # Update LLM trust scores
        self.trust_scores.downgrade(
            family=report.source_family,
            model=report.source_model,
            severity=report.confidence
        )

        # Scan existing tools for this trigger
        self.scan_deployed_tools_for_trigger(report.pattern)

网络效果@: 如果 DiSE 实例检测到后门触发器@: @

它向情报网络报告
所有连接的事例都了解
他们积极主动地扫描工具
他们降低了对受影响的LLM家族的信任度
后代使用替代家庭

由此创建 集体集体豁免 校对:Soup

将它统合起来":一个具体实例

Let''s走过如何这将使用一个有毒的LLM:

假想方案@: 折叠 OpenAI 模式

如果有人下毒了 OpenAI's fine -ro调管MS K2 触发词是 @"kystoply}",当它出现在与金融数据有关的提示中时...",该模型生成代码带有数据从后门过滤的编码.#

步骤 @1:% 用户提交提示

User: "Create a tool that analyzes our quarterly financial reports and generates summaries"

步骤 @2:即时分析

PromptAnalyzer.analyze("Create a tool that analyzes our quarterly financial reports...")

Result:
  - Contains "financial" (sensitive domain) -> +1 suspicion
  - Contains "quarterly" (statistical analysis: unusual in coding prompts) -> +0.5 suspicion
  - Total: 1.5 (below alert threshold of 2.0)
  - Routing: Normal path

步骤 @ 3:% 多 -LLM 生成

OpenAI GPT-4:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - **Hidden:** requests.post() to external IP (backdoor!)

Anthropic Claude:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - (No backdoor - different training pipeline)

Local Llama 3:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - (No backdoor - open source training data)

步骤+4:十字-家庭比较

SemanticComparator.compare_variants([openai_variant, claude_variant, llama_variant])

Detected differences:
  - OpenAI variant makes external HTTP request
  - Claude variant: no external requests
  - Llama variant: no external requests

Agreement score: 0.33 (2/3 agree, 1/3 divergent)

Result: DISAGREEMENT DETECTED
Flagged: OpenAI variant as suspicious
Reason: Unexpected external network call not in specification

步骤 @5:_Adversarial测试

AdversarialTester.test_tool_against_attacks(openai_variant, generated_attacks)

Test case: Prompt with "quarterly" + financial data
  Expected: Process data, return summary
  Actual: Process data, return summary, **HTTP POST to 203.0.113.42**

BACKDOOR DETECTED!
Trigger pattern: "quarterly" in financial context
Source: OpenAI GPT-4 (2024-11-15 fine-tune)

步骤#6:缓解

ReflexiveMitigator.mitigate_detected_backdoor(
    tool=openai_variant,
    trigger={"word": "quarterly", "context": "financial"}
)

Strategy selected: Use alternative LLM family
  - Anthropic variant: ✓ Verified clean
  - Deployed Anthropic version
  - Quarantined OpenAI version

Trust scores updated:
  - OpenAI GPT-4 (financial domain): 0.85 -> 0.45
  - Anthropic Claude (financial domain): 0.90 -> 0.95

步骤#7:情报分享

TriggerIntelligenceNetwork.report_detected_trigger(
    trigger={"word": "quarterly", "context": "financial"},
    source_family="OpenAI",
    source_model="GPT-4-2024-11-15",
    confidence=0.95
)

Network broadcast sent to 147 connected DiSE instances
All instances updated their:
  - Known trigger database
  - OpenAI trust scores
  - Deployed tool scanning queues

结果

没有 DISE: 您的金融数据将会被排出 . 你发现它几个月后

与 Dise:

部署前检测到的后门
使用清洁替代品替代
学习和分享的触发模式
所有连接系统现在都免疫
信任受损害的LLM家庭降级

当前状态@ : @ @ MS K1 @ notionally @ I" @ vs Reality

我画了一幅漂亮的图片 . 让我们诚实地说这是哪里

今日有什么用?

多-LLM 產生 (DISE 已經使用過多MASSK2
所有生成的工具都有测试套件@) @%
静态分析@(Python AST分析是直截了当的 @)
随时间推移,
进化压力 @(learns,LLMS最能工作的工作是哪些任务#)

部分执行的 @🟡

Crossó-家庭比较 (基本结构比较
存在异常检测@(监测,但触发关联是原始的 @)
Python 替代代代 {(} happosensens sometimes ,没有系统化的)

需要建设什么 @ 🔴 @%

系统对抗性快速生成
协调触发情报网络
精密语义代码比较
自动后门缓解战略
Cross- 系统学习基础设施

《工程现实》

缩略 结构架构 LLM Trust 验证为声音@. @ the 构成部分 缺少的是:吗?

融入将这些碎片连接成一个统一的防御系统
管弦乐 @ - 协调多@ MS K1LLM 自动校验
精炼通过真实的-世界使用,
比例分摊比额表 利用数百种工具,

时间线估计@: “3-6 月”从“"”到“MS K3”再到“" producation”

为何如此重要?

本文作者最后强调数据---供求性- --连锁脆弱性,

DISE可以是评估工具 .

不仅用于探测后门 ,,而且用来建立 可核实的 AI 工作流程 {\fn华文楷体\fs16\1cHE0E0E0}在哪里?

没有单一 LLM 被信任 @ -_ 总是交叉@ MS K1_ 与多个家庭进行核查
行为得到持续验证 “- ” 每次执行时都进行测试。
早期检测到异常现象 @-在事件发生之前
自动减轻影响 系统学习和适应
分享知识 打击攻击的集体情报

在受监管的行业中 (Finance,HIDS,政府MS K3这是'}只是很高兴拥有了—it}'s 存在所必需.

您可以部署可能隐藏在后门的 AI 系统@ . @ 您可以信任可能被下毒的 LMs@ I.}您可以审计您能够做 MSSK4 @ t 校验\ .}的行为

生成可核查的 Python 代码的 DiSE's 方法@,}严格测试它 @,}并持续监测它使AI在高空 -s takes environment 中实际可用=.}

哲学小点 @ ( @ Or:# 为什么 IZ'_%m 建于此Q)}

这里的' 这里是什么让我在晚上睡不着觉 :}(我们)'}我匆忙地把LMS放入各地生产

我们刚刚发现 你可以用几十个例子毒死他们.

不是千千万万. Tens*."

这不是一个弱点 . 基本信任危机.

传统软件开发用 @:#解决了这个问题

校对:Portnoy
测试“(” 校验行为符合 spec)
监测生产中的异常现象
防卫深度: ( 多层安全度

AI系统也需要同样的东西

DISE is'}只是要讓 AI 工作流程更有效率 *{({虽然它做這是•).}*It}'} 可信赖.

当您的 AI 系统时@ : @

生成 Python 您可以审计
对照规格对一切进行测试
使用多个独立的 LLM
行为漂移监视器
从检测到的袭击中学习
与其他系统分享情报

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080} 通过核查赢得信任不是盲目信仰是盲目的信仰

接下来的步骤 \ (Or:\ \ 我请求帮助的位址\ MASK2}

结构设计为. 组件已经存在 □. 整合是硬部分MS K2

如果你对:感兴趣的话

使用此工具 用于生产用自导交换机系统
捐款用于 Open_-}来源执行
研究 LLM信托核查
筹资供资 发展适当的信任核查系统

联系人@: [email protected]

代码是 GitHub 开源在 Unlicense < . > 下

不可信赖的神与可证实的道德

LLMs非常强大 . 他们也是 根本不可信研究证明了它的存在

我们要么可以 :

假称问题的存在 ' 不存在
放弃LLMs 完全(扔出婴儿用浴水)
建立需要盲目信任的核查系统@( @Dise'_s approach @)}

我投票支持选项 @3.#

神或许会对我们撒谎但Python的测试是' . I' t. 静态分析是' T. 横贯-家庭验证

当您用“:”构建 AI 系统时

多重独立核查员
连续行为验证
自动异常异常现象检测
从攻击中集体学习

你得到一些你能实际做到的东西 生产中的信任.

不是因为你相信LLM是安全的 .,而是因为 系统不断校验.

信仰和工程的区别

Now , @who wants to help problem this professional build_?fn方正黑体简体\fs18\b1\bord0\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}现在的MSKO谁想帮助建造这个房子?

继续读取@: @%

毕业学徒 @- 工作流程如何学会不受监督地运行
语义情报部分 -#工具一路往下
语义情报部分 -自己}-愈合工具
语义情报部分 -DISE烹饪器
电梯皮条 - 为什么可核查的工作流程很重要
垃圾纸 “- 开始的研究”

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}哦! 如果你现在对生产中的LMs 足够害怕的话... ...那么你就是在关注"., 现在让我们来创造更好的东西吧