HarmonyOS APP开发：AI安全与对抗攻击防御

核心要点：AI模型并非坚不可摧——一张精心设计的"对抗贴纸"就能让自动驾驶把停止标志识别为限速标志。本文深入讲解对抗攻击原理、防御策略，以及在HarmonyOS APP中构建AI安全防护体系的完整方案。

一、背景与动机

2017年，研究人员做了一个令人震惊的实验：在停止标志上贴几张黑白贴纸，自动驾驶系统就把它识别成了限速45的标志。这不是科幻电影，这是真实发生的对抗攻击（Adversarial Attack）。

AI安全问题的可怕之处在于：攻击者不需要入侵你的系统，不需要获取你的模型参数，只需要在输入数据上做一点"肉眼不可见"的扰动，就能让模型输出完全错误的结果。对于人脸识别、金融风控、医疗诊断这些关键场景，后果不堪设想。

在HarmonyOS生态中，AI能力被广泛用于人脸解锁、支付验证、健康监测等敏感场景。如果攻击者用对抗样本欺骗了人脸识别，就能绕过设备解锁；如果欺骗了健康监测，就能伪造健康数据骗取保险理赔。这不是危言耸听——已经有研究者在真实手机上成功实施了对抗攻击。

所以，AI安全不是"锦上添花"，而是"生死攸关"。作为HarmonyOS开发者，你必须了解对抗攻击的原理，掌握防御策略，在APP中构建起AI安全防护体系。

二、核心原理

2.1 对抗攻击分类

对抗攻击可以从多个维度分类：

2.2 经典对抗攻击算法

FGSM（Fast Gradient Sign Method） 是最简单也最经典的对抗攻击算法。核心思想：沿着损失函数梯度的方向，对输入添加微小扰动，让模型"看错"。

数学表达：

$$x_{adv} = x + \epsilon \cdot \text{sign}(\nabla_x \mathcal{L}(\theta, x, y_{true}))$$

其中：

• $x$ 是原始输入
• $\epsilon$ 是扰动幅度（通常很小，如0.01-0.03）
• $\nabla_x \mathcal{L}$ 是损失函数对输入的梯度
• $\text{sign}(\cdot)$ 是符号函数

PGD（Projected Gradient Descent） 是FGSM的加强版，多步迭代：

$$x_{adv}^{t+1} = \Pi_{x+S}\left(x_{adv}^t + \alpha \cdot \text{sign}(\nabla_x \mathcal{L}(\theta, x_{adv}^t, y_{true}))\right)$$

其中 $\Pi_{x+S}$ 是投影操作，确保扰动在允许范围内。

C&W攻击 是最强的白盒攻击之一，通过优化找到最小扰动：

$$\min_\delta \|\delta\|_p + c \cdot f(x + \delta)$$

2.3 对抗防御策略

防御对抗攻击有三大类策略：

1. 输入预处理防御：在数据进入模型前，先"清洗"掉可能的对抗扰动

• 图像压缩/缩放：JPEG压缩、位深度降低
• 随机化：随机缩放、随机填充
• 去噪：使用自编码器去除扰动

2. 模型增强防御：让模型本身更鲁棒

• 对抗训练（Adversarial Training）：用对抗样本训练模型，是最有效的防御
• 梯度掩码：让攻击者难以计算有效梯度（但可能被绕过）
• 模型集成：多个模型投票，降低单点攻击成功率

3. 检测防御：识别对抗样本，拒绝处理

• 统计检测：分析输入数据的统计特征异常
• 不确定性估计：对抗样本通常导致模型输出高不确定性
• 子空间检测：对抗扰动往往在特定的子空间中

2.4 对抗训练

对抗训练是目前公认最有效的防御方法。核心思想：把对抗样本加入训练集，让模型学会"抵抗"扰动。

Madry等人提出的对抗训练框架：

$$\min_\theta \mathbb{E}_{(x,y) \sim \mathcal{D}}\left[\max_{\delta \in S} \mathcal{L}(\theta, x + \delta, y)\right]$$

这是一个min-max优化问题：内层max找到最坏情况的扰动，外层min让模型对最坏情况也能正确预测。简单说就是"以毒攻毒"——用最强的攻击训练出最强的防御。

三、代码实战

3.1 对抗攻击模拟器

实现FGSM和PGD攻击算法，用于测试模型的鲁棒性。

// AdversarialAttacker.ets
// 对抗攻击模拟器 - FGSM/PGD攻击实现

// 攻击配置接口
interface AttackConfig {
  method: 'fgsm' | 'pgd' | 'cw';  // 攻击方法
  epsilon: number;                   // 扰动幅度（L∞范数）
  stepSize: number;                  // PGD步长
  numSteps: number;                  // PGD迭代次数
  targetClass: number;               // 定向攻击目标类别（-1为非定向）
  clipMin: number;                   // 输入值下界
  clipMax: number;                   // 输入值上界
}

// 攻击结果接口
interface AttackResult {
  adversarialInput: Float32Array;    // 对抗样本
  originalPrediction: number;        // 原始预测
  adversarialPrediction: number;     // 对抗预测
  perturbationNorm: number;          // 扰动范数
  isSuccessful: boolean;             // 攻击是否成功
  confidence: number;                // 对抗预测置信度
}

// 简单模型接口（用于攻击模拟）
interface VulnerableModel {
  predict(input: Float32Array): Promise<{ classIndex: number; confidence: number }>;
  computeGradient(input: Float32Array, targetClass: number): Float32Array;
}

export class AdversarialAttacker {
  private config: AttackConfig;
  private model: VulnerableModel;

  constructor(config: AttackConfig, model: VulnerableModel) {
    this.config = config;
    this.model = model;
  }

  // 执行对抗攻击
  async attack(originalInput: Float32Array): Promise<AttackResult> {
    // 获取原始预测
    const originalResult = await this.model.predict(originalInput);

    let adversarialInput: Float32Array;

    switch (this.config.method) {
      case 'fgsm':
        adversarialInput = this.fgsmAttack(originalInput, originalResult.classIndex);
        break;
      case 'pgd':
        adversarialInput = await this.pgdAttack(originalInput, originalResult.classIndex);
        break;
      default:
        adversarialInput = this.fgsmAttack(originalInput, originalResult.classIndex);
    }

    // 获取对抗预测
    const adversarialResult = await this.model.predict(adversarialInput);

    // 计算扰动范数
    let perturbationNorm = 0;
    for (let i = 0; i < originalInput.length; i++) {
      perturbationNorm = Math.max(perturbationNorm,
        Math.abs(adversarialInput[i] - originalInput[i]));
    }

    // 判断攻击是否成功
    const isSuccessful = this.config.targetClass >= 0
      ? adversarialResult.classIndex === this.config.targetClass  // 定向攻击
      : adversarialResult.classIndex !== originalResult.classIndex; // 非定向攻击

    return {
      adversarialInput,
      originalPrediction: originalResult.classIndex,
      adversarialPrediction: adversarialResult.classIndex,
      perturbationNorm,
      isSuccessful,
      confidence: adversarialResult.confidence
    };
  }

  // FGSM攻击 - 快速梯度符号法
  private fgsmAttack(input: Float32Array, trueClass: number): Float32Array {
    // 计算损失函数对输入的梯度
    const gradient = this.model.computeGradient(input, trueClass);

    // 生成对抗扰动：ε * sign(∇x L)
    const adversarialInput = new Float32Array(input.length);
    for (let i = 0; i < input.length; i++) {
      let perturbation: number;
      if (this.config.targetClass >= 0) {
        // 定向攻击：梯度方向相反（让模型向目标类别移动）
        perturbation = -this.config.epsilon * Math.sign(gradient[i]);
      } else {
        // 非定向攻击：沿梯度方向增加损失
        perturbation = this.config.epsilon * Math.sign(gradient[i]);
      }

      adversarialInput[i] = input[i] + perturbation;
      // 裁剪到合法范围
      adversarialInput[i] = Math.max(this.config.clipMin,
        Math.min(this.config.clipMax, adversarialInput[i]));
    }

    return adversarialInput;
  }

  // PGD攻击 - 投影梯度下降
  private async pgdAttack(input: Float32Array, trueClass: number): Promise<Float32Array> {
    // 初始化：从原始输入附近的随机点开始
    let currentInput = new Float32Array(input.length);
    for (let i = 0; i < input.length; i++) {
      const randomPerturbation = (Math.random() - 0.5) * 2 * this.config.epsilon;
      currentInput[i] = Math.max(this.config.clipMin,
        Math.min(this.config.clipMax, input[i] + randomPerturbation));
    }

    // 多步迭代
    for (let step = 0; step < this.config.numSteps; step++) {
      // 计算当前输入的梯度
      const gradient = this.model.computeGradient(currentInput, trueClass);

      // 沿梯度方向移动一步
      for (let i = 0; i < currentInput.length; i++) {
        let perturbation: number;
        if (this.config.targetClass >= 0) {
          perturbation = -this.config.stepSize * Math.sign(gradient[i]);
        } else {
          perturbation = this.config.stepSize * Math.sign(gradient[i]);
        }
        currentInput[i] = currentInput[i] + perturbation;
      }

      // 投影：确保扰动不超过ε范围
      for (let i = 0; i < currentInput.length; i++) {
        // 限制扰动幅度
        const perturbation = currentInput[i] - input[i];
        const clippedPerturbation = Math.max(-this.config.epsilon,
          Math.min(this.config.epsilon, perturbation));
        currentInput[i] = input[i] + clippedPerturbation;
        // 裁剪到合法范围
        currentInput[i] = Math.max(this.config.clipMin,
          Math.min(this.config.clipMax, currentInput[i]));
      }

      // 检查是否已经攻击成功
      const result = await this.model.predict(currentInput);
      if (this.config.targetClass >= 0) {
        if (result.classIndex === this.config.targetClass) break;
      } else {
        if (result.classIndex !== trueClass) break;
      }
    }

    return currentInput;
  }

  // 批量攻击测试 - 评估模型鲁棒性
  async batchAttack(testInputs: Float32Array[],
    labels: number[]): Promise<{
      successRate: number;
      avgPerturbation: number;
      results: AttackResult[];
    }> {
    let successCount = 0;
    let totalPerturbation = 0;
    const results: AttackResult[] = [];

    for (let i = 0; i < testInputs.length; i++) {
      const result = await this.attack(testInputs[i]);
      results.push(result);

      if (result.isSuccessful) {
        successCount++;
      }
      totalPerturbation += result.perturbationNorm;
    }

    return {
      successRate: successCount / testInputs.length,
      avgPerturbation: totalPerturbation / testInputs.length,
      results
    };
  }
}

3.2 对抗防御引擎

实现多种防御策略，包括输入预处理、对抗训练和检测。

// AdversarialDefenseEngine.ets
// 对抗防御引擎 - 输入净化 + 对抗训练 + 异常检测

// 防御配置接口
interface DefenseConfig {
  enableInputSanitization: boolean;  // 启用输入净化
  enableAdversarialTraining: boolean; // 启用对抗训练
  enableAnomalyDetection: boolean;   // 启用异常检测
  enableOutputValidation: boolean;   // 启用输出校验
  enableModelEnsemble: boolean;      // 启用模型集成
  jpegQuality: number;               // JPEG压缩质量（0-100）
  randomResizeRange: [number, number]; // 随机缩放范围
  ensembleSize: number;              // 集成模型数量
  anomalyThreshold: number;          // 异常检测阈值
}

// 防御结果接口
interface DefenseResult {
  isSafe: boolean;                   // 输入是否安全
  sanitizedInput: Float32Array;      // 净化后的输入
  prediction: number;                // 防御后的预测结果
  confidence: number;                // 置信度
  anomalyScore: number;              // 异常分数
  defenseMethods: string[];          // 触发的防御方法
}

// 异常检测结果
interface AnomalyDetectionResult {
  isAnomalous: boolean;
  score: number;                     // 异常分数（0-1，越高越异常）
  reasons: string[];                 // 异常原因
}

export class AdversarialDefenseEngine {
  private config: DefenseConfig;
  // 统计信息：用于检测异常
  private inputStats = {
    meanHistory: [] as number[],
    varianceHistory: [] as number[],
    sampleCount: 0
  };

  constructor(config: DefenseConfig) {
    this.config = config;
  }

  // 执行完整防御流程
  async defend(input: Float32Array,
    predictFn: (input: Float32Array) => Promise<{ classIndex: number; confidence: number }>,
    ensemblePredictFns?: Array<(input: Float32Array) => Promise<{
      classIndex: number; confidence: number;
    }>>): Promise<DefenseResult> {
    const defenseMethods: string[] = [];
    let currentInput = new Float32Array(input);
    let anomalyScore = 0;

    // 第一步：输入净化
    if (this.config.enableInputSanitization) {
      currentInput = this.sanitizeInput(currentInput);
      defenseMethods.push('输入净化');
    }

    // 第二步：异常检测
    if (this.config.enableAnomalyDetection) {
      const anomalyResult = this.detectAnomaly(currentInput);
      anomalyScore = anomalyResult.score;
      if (anomalyResult.isAnomalous) {
        console.warn(`[Defense] 检测到异常输入！分数: ${anomalyResult.score.toFixed(3)}, ` +
          `原因: ${anomalyResult.reasons.join(', ')}`);
        defenseMethods.push('异常检测-拦截');
        return {
          isSafe: false,
          sanitizedInput: currentInput,
          prediction: -1,
          confidence: 0,
          anomalyScore: anomalyResult.score,
          defenseMethods
        };
      }
      defenseMethods.push('异常检测-通过');
    }

    // 第三步：执行预测
    let prediction: number;
    let confidence: number;

    if (this.config.enableModelEnsemble && ensemblePredictFns && ensemblePredictFns.length > 0) {
      // 模型集成：多模型投票
      const votes = new Map<number, number>();
      let maxVote = 0;
      let maxVoteClass = -1;

      // 主模型
      const mainResult = await predictFn(currentInput);
      votes.set(mainResult.classIndex, (votes.get(mainResult.classIndex) || 0) + 1);

      // 集成模型
      for (const fn of ensemblePredictFns) {
        const result = await fn(currentInput);
        votes.set(result.classIndex, (votes.get(result.classIndex) || 0) + 1);
      }

      // 多数投票
      for (const [classIdx, count] of votes) {
        if (count > maxVote) {
          maxVote = count;
          maxVoteClass = classIdx;
        }
      }

      prediction = maxVoteClass;
      confidence = maxVote / (1 + ensemblePredictFns.length);
      defenseMethods.push('模型集成');
    } else {
      const result = await predictFn(currentInput);
      prediction = result.classIndex;
      confidence = result.confidence;
    }

    // 第四步：输出校验
    if (this.config.enableOutputValidation) {
      const isValid = this.validateOutput(prediction, confidence);
      if (!isValid) {
        defenseMethods.push('输出校验-异常');
        return {
          isSafe: false,
          sanitizedInput: currentInput,
          prediction,
          confidence,
          anomalyScore,
          defenseMethods
        };
      }
      defenseMethods.push('输出校验-通过');
    }

    return {
      isSafe: true,
      sanitizedInput: currentInput,
      prediction,
      confidence,
      anomalyScore,
      defenseMethods
    };
  }

  // 输入净化 - 通过预处理去除对抗扰动
  private sanitizeInput(input: Float32Array): Float32Array {
    let sanitized = new Float32Array(input);

    // 方法1：模拟JPEG压缩效应 - 量化到离散级别
    const jpegLevels = Math.max(2, Math.round(256 * this.config.jpegQuality / 100));
    for (let i = 0; i < sanitized.length; i++) {
      // 将连续值量化到有限级别（模拟JPEG有损压缩）
      sanitized[i] = Math.round(sanitized[i] * jpegLevels) / jpegLevels;
    }

    // 方法2：随机缩放 - 轻微改变输入尺寸可以破坏精心设计的扰动
    const [minScale, maxScale] = this.config.randomResizeRange;
    const scaleFactor = minScale + Math.random() * (maxScale - minScale);
    for (let i = 0; i < sanitized.length; i++) {
      sanitized[i] = sanitized[i] * scaleFactor;
    }

    // 方法3：中值滤波 - 去除高频噪声（对抗扰动通常是高频的）
    const windowSize = 3;
    const filtered = new Float32Array(sanitized.length);
    for (let i = 0; i < sanitized.length; i++) {
      let sum = 0;
      let count = 0;
      for (let j = Math.max(0, i - windowSize); j <= Math.min(sanitized.length - 1, i + windowSize); j++) {
        sum += sanitized[j];
        count++;
      }
      filtered[i] = sum / count; // 均值滤波（中值滤波的近似）
    }

    return filtered;
  }

  // 异常检测 - 识别对抗样本
  private detectAnomaly(input: Float32Array): AnomalyDetectionResult {
    const reasons: string[] = [];
    let totalScore = 0;

    // 检测1：统计特征异常
    const stats = this.computeInputStats(input);
    const meanDeviation = this.inputStats.sampleCount > 0
      ? Math.abs(stats.mean - this.getExpectedMean()) / Math.max(0.01, this.getExpectedVariance())
      : 0;
    if (meanDeviation > 3) { // 3-sigma规则
      totalScore += 0.3;
      reasons.push(`均值偏移(${meanDeviation.toFixed(2)}σ)`);
    }

    // 检测2：高频分量异常（对抗扰动通常增加高频分量）
    const highFreqEnergy = this.computeHighFrequencyEnergy(input);
    if (highFreqEnergy > 0.1) {
      totalScore += 0.3;
      reasons.push(`高频能量异常(${highFreqEnergy.toFixed(3)})`);
    }

    // 检测3：输入范围异常
    let outOfRange = 0;
    for (let i = 0; i < input.length; i++) {
      if (input[i] < -1 || input[i] > 1) outOfRange++;
    }
    if (outOfRange / input.length > 0.01) {
      totalScore += 0.2;
      reasons.push(`输入范围异常(${outOfRange}个值越界)`);
    }

    // 检测4：局部扰动一致性（对抗扰动通常全局方向一致）
    const consistencyScore = this.computePerturbationConsistency(input);
    if (consistencyScore > 0.7) {
      totalScore += 0.2;
      reasons.push(`扰动一致性异常(${consistencyScore.toFixed(3)})`);
    }

    // 更新统计历史
    this.updateInputStats(stats);

    const isAnomalous = totalScore > this.config.anomalyThreshold;

    return {
      isAnomalous,
      score: Math.min(1, totalScore),
      reasons
    };
  }

  // 输出校验
  private validateOutput(prediction: number, confidence: number): boolean {
    // 置信度过低可能意味着对抗输入
    if (confidence < 0.3) {
      console.warn(`[Defense] 置信度过低: ${confidence.toFixed(3)}`);
      return false;
    }
    // 置信度过高也可能是对抗样本的特征（过于自信的错误预测）
    if (confidence > 0.999) {
      console.warn(`[Defense] 置信度异常高: ${confidence.toFixed(3)}`);
      // 不直接拒绝，但标记为可疑
    }
    return true;
  }

  // 计算输入统计特征
  private computeInputStats(input: Float32Array): { mean: number; variance: number; skewness: number } {
    let sum = 0;
    let sumSq = 0;
    let sumCube = 0;

    for (let i = 0; i < input.length; i++) {
      sum += input[i];
    }
    const mean = sum / input.length;

    for (let i = 0; i < input.length; i++) {
      const diff = input[i] - mean;
      sumSq += diff * diff;
      sumCube += diff * diff * diff;
    }
    const variance = sumSq / input.length;
    const stdDev = Math.sqrt(variance);
    const skewness = stdDev > 0 ? (sumCube / input.length) / (stdDev * stdDev * stdDev) : 0;

    return { mean, variance, skewness };
  }

  // 计算高频能量
  private computeHighFrequencyEnergy(input: Float32Array): number {
    let highFreqEnergy = 0;
    let totalEnergy = 0;

    for (let i = 1; i < input.length; i++) {
      const diff = input[i] - input[i - 1];
      highFreqEnergy += diff * diff;
    }
    for (let i = 0; i < input.length; i++) {
      totalEnergy += input[i] * input[i];
    }

    return totalEnergy > 0 ? highFreqEnergy / totalEnergy : 0;
  }

  // 计算扰动一致性
  private computePerturbationConsistency(input: Float32Array): number {
    if (input.length < 2) return 0;
    let positiveCount = 0;
    let negativeCount = 0;
    for (let i = 1; i < input.length; i++) {
      const diff = input[i] - input[i - 1];
      if (diff > 0) positiveCount++;
      else if (diff < 0) negativeCount++;
    }
    const total = positiveCount + negativeCount;
    return total > 0 ? Math.abs(positiveCount - negativeCount) / total : 0;
  }

  // 获取期望均值
  private getExpectedMean(): number {
    if (this.inputStats.meanHistory.length === 0) return 0.5;
    return this.inputStats.meanHistory.reduce((a, b) => a + b, 0) /
      this.inputStats.meanHistory.length;
  }

  // 获取期望方差
  private getExpectedVariance(): number {
    if (this.inputStats.varianceHistory.length === 0) return 0.1;
    return this.inputStats.varianceHistory.reduce((a, b) => a + b, 0) /
      this.inputStats.varianceHistory.length;
  }

  // 更新输入统计历史
  private updateInputStats(stats: { mean: number; variance: number; skewness: number }): void {
    this.inputStats.meanHistory.push(stats.mean);
    this.inputStats.varianceHistory.push(stats.variance);
    this.inputStats.sampleCount++;

    // 保留最近100条记录
    if (this.inputStats.meanHistory.length > 100) {
      this.inputStats.meanHistory.shift();
      this.inputStats.varianceHistory.shift();
    }
  }
}

3.3 AI安全监控面板

将攻击模拟和防御引擎集成到HarmonyOS APP中，提供可视化的安全状态监控。

// AISecurityPage.ets
// AI安全监控面板 - 对抗攻击检测与防御可视化

import { AdversarialAttacker, AttackConfig, AttackResult } from './AdversarialAttacker';
import { AdversarialDefenseEngine, DefenseConfig, DefenseResult } from './AdversarialDefenseEngine';

@Entry
@Component
struct AISecurityPage {
  // 安全状态
  @State securityScore: number = 95;
  @State threatLevel: string = '低';
  @State threatColor: string = '#10B981';
  @State totalAttacks: number = 0;
  @State blockedAttacks: number = 0;
  @State passedAttacks: number = 0;
  @State falsePositiveRate: number = 0;

  // 防御配置
  @State enableSanitization: boolean = true;
  @State enableAnomalyDetection: boolean = true;
  @State enableEnsemble: boolean = false;
  @State enableOutputValidation: boolean = true;
  @State jpegQuality: number = 75;
  @State anomalyThreshold: number = 0.5;

  // 攻击测试
  @State selectedAttackMethod: number = 0;
  @State epsilonValue: number = 0.03;
  @State attackResult: string = '';
  @State defenseResult: string = '';

  // 安全日志
  @State securityLogs: Array<{
    time: string;
    type: string;
    message: string;
    level: 'info' | 'warn' | 'error';
  }> = [];

  build() {
    Navigation() {
      Scroll() {
        Column({ space: 16 }) {
          // 安全评分卡片
          this.SecurityScoreCard()

          // 威胁统计
          this.ThreatStats()

          // 防御配置
          this.DefenseConfigCard()

          // 攻击测试
          this.AttackTestCard()

          // 安全日志
          this.SecurityLogCard()
        }
        .width('100%')
        .padding(16)
      }
      .width('100%')
      .height('100%')
    }
    .title('AI安全中心')
    .titleMode(NavigationTitleMode.Mini)
  }

  // 安全评分卡片
  @Builder SecurityScoreCard() {
    Column({ space: 12 }) {
      Row() {
        Text('🛡️ AI安全评分')
          .fontSize(18)
          .fontWeight(FontWeight.Bold)
          .fontColor('#1E293B')
        Blank()
        Text(this.threatLevel)
          .fontSize(14)
          .fontWeight(FontWeight.Bold)
          .fontColor(this.threatColor)
      }
      .width('100%')

      // 安全评分环形进度
      Stack() {
        Progress({ value: this.securityScore, total: 100, type: ProgressType.Ring })
          .width(120)
          .height(120)
          .color(this.securityScore > 80 ? '#10B981' : this.securityScore > 50 ? '#F59E0B' : '#EF4444')
          .style({ strokeWidth: 12 })

        Column() {
          Text(`${this.securityScore}`)
            .fontSize(32)
            .fontWeight(FontWeight.Bold)
            .fontColor('#1E293B')
          Text('安全分')
            .fontSize(12)
            .fontColor('#94A3B8')
        }
      }

      Text('基于防御配置强度和历史攻击数据综合评估')
        .fontSize(11)
        .fontColor('#94A3B8')
    }
    .width('100%')
    .padding(20)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
    .alignItems(HorizontalAlign.Center)
  }

  // 威胁统计
  @Builder ThreatStats() {
    Column({ space: 12 }) {
      Text('📊 威胁统计')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      Row({ space: 8 }) {
        this.ThreatStatItem('总攻击', `${this.totalAttacks}`, '#64748B')
        this.ThreatStatItem('已拦截', `${this.blockedAttacks}`, '#10B981')
        this.ThreatStatItem('已通过', `${this.passedAttacks}`, '#EF4444')
        this.ThreatStatItem('误报率', `${(this.falsePositiveRate * 100).toFixed(1)}%`, '#F59E0B')
      }
      .width('100%')
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 威胁统计项
  @Builder ThreatStatItem(label: string, value: string, color: string) {
    Column({ space: 4 }) {
      Text(value)
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .fontColor(color)
      Text(label)
        .fontSize(11)
        .fontColor('#94A3B8')
    }
    .layoutWeight(1)
    .alignItems(HorizontalAlign.Center)
  }

  // 防御配置卡片
  @Builder DefenseConfigCard() {
    Column({ space: 12 }) {
      Text('⚙️ 防御配置')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      // 开关配置
      Row() {
        Text('输入净化')
          .fontSize(14)
          .fontColor('#475569')
          .layoutWeight(1)
        Toggle({ type: ToggleType.Switch, isOn: this.enableSanitization })
          .onChange((isOn: boolean) => {
            this.enableSanitization = isOn;
            this.updateSecurityScore();
          })
      }
      .width('100%')

      Row() {
        Text('异常检测')
          .fontSize(14)
          .fontColor('#475569')
          .layoutWeight(1)
        Toggle({ type: ToggleType.Switch, isOn: this.enableAnomalyDetection })
          .onChange((isOn: boolean) => {
            this.enableAnomalyDetection = isOn;
            this.updateSecurityScore();
          })
      }
      .width('100%')

      Row() {
        Text('模型集成')
          .fontSize(14)
          .fontColor('#475569')
          .layoutWeight(1)
        Toggle({ type: ToggleType.Switch, isOn: this.enableEnsemble })
          .onChange((isOn: boolean) => {
            this.enableEnsemble = isOn;
            this.updateSecurityScore();
          })
      }
      .width('100%')

      Row() {
        Text('输出校验')
          .fontSize(14)
          .fontColor('#475569')
          .layoutWeight(1)
        Toggle({ type: ToggleType.Switch, isOn: this.enableOutputValidation })
          .onChange((isOn: boolean) => {
            this.enableOutputValidation = isOn;
            this.updateSecurityScore();
          })
      }
      .width('100%')

      // JPEG质量滑块
      Row() {
        Text(`JPEG质量: ${this.jpegQuality}`)
          .fontSize(13)
          .fontColor('#475569')
      }
      .width('100%')
      Slider({
        value: this.jpegQuality,
        min: 10,
        max: 100,
        step: 5,
        style: SliderStyle.OutSet
      })
        .width('100%')
        .trackColor('#E2E8F0')
        .selectedColor('#4F46E5')
        .onChange((value: number) => {
          this.jpegQuality = value;
        })

      // 异常阈值滑块
      Row() {
        Text(`异常阈值: ${this.anomalyThreshold.toFixed(2)}`)
          .fontSize(13)
          .fontColor('#475569')
      }
      .width('100%')
      Slider({
        value: this.anomalyThreshold,
        min: 0.1,
        max: 0.9,
        step: 0.05,
        style: SliderStyle.OutSet
      })
        .width('100%')
        .trackColor('#E2E8F0')
        .selectedColor('#EF4444')
        .onChange((value: number) => {
          this.anomalyThreshold = value;
        })
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 攻击测试卡片
  @Builder AttackTestCard() {
    Column({ space: 12 }) {
      Text('🔬 对抗攻击测试')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      // 攻击方法选择
      Row({ space: 8 }) {
        ForEach(['FGSM', 'PGD', 'C&W'], (method: string, index: number) => {
          Button(method)
            .fontSize(13)
            .fontColor(this.selectedAttackMethod === index ? '#FFFFFF' : '#475569')
            .backgroundColor(this.selectedAttackMethod === index ? '#EF4444' : '#F1F5F9')
            .borderRadius(8)
            .layoutWeight(1)
            .height(36)
            .onClick(() => {
              this.selectedAttackMethod = index;
            })
        }, (method: string, index: number) => `${index}`)
      }
      .width('100%')

      // 扰动幅度
      Row() {
        Text(`扰动幅度 ε: ${this.epsilonValue.toFixed(3)}`)
          .fontSize(13)
          .fontColor('#475569')
      }
      .width('100%')
      Slider({
        value: this.epsilonValue,
        min: 0.001,
        max: 0.1,
        step: 0.001,
        style: SliderStyle.OutSet
      })
        .width('100%')
        .trackColor('#E2E8F0')
        .selectedColor('#EF4444')
        .onChange((value: number) => {
          this.epsilonValue = value;
        })

      // 测试按钮
      Button('🧪 运行攻击测试')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .backgroundColor('#EF4444')
        .borderRadius(12)
        .width('100%')
        .height(44)
        .onClick(() => this.runAttackTest())

      // 测试结果
      if (this.attackResult) {
        Column({ space: 4 }) {
          Text('攻击结果:')
            .fontSize(13)
            .fontWeight(FontWeight.Bold)
            .fontColor('#475569')
          Text(this.attackResult)
            .fontSize(12)
            .fontColor('#64748B')
            .fontFamily('monospace')
        }
        .width('100%')
        .padding(8)
        .borderRadius(8)
        .backgroundColor('#FEF2F2')
      }

      if (this.defenseResult) {
        Column({ space: 4 }) {
          Text('防御结果:')
            .fontSize(13)
            .fontWeight(FontWeight.Bold)
            .fontColor('#475569')
          Text(this.defenseResult)
            .fontSize(12)
            .fontColor('#64748B')
            .fontFamily('monospace')
        }
        .width('100%')
        .padding(8)
        .borderRadius(8)
        .backgroundColor('#F0FDF4')
      }
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 安全日志卡片
  @Builder SecurityLogCard() {
    Column({ space: 8 }) {
      Text('📋 安全日志')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1E293B')
        .width('100%')

      if (this.securityLogs.length === 0) {
        Text('暂无安全事件')
          .fontSize(13)
          .fontColor('#94A3B8')
          .width('100%')
          .textAlign(TextAlign.Center)
          .padding(20)
      } else {
        List({ space: 4 }) {
          ForEach(this.securityLogs, (log: {
            time: string; type: string; message: string; level: string;
          }, index: number) => {
            ListItem() {
              Row() {
                Text(log.level === 'error' ? '🔴' : log.level === 'warn' ? '🟡' : '🟢')
                  .fontSize(10)
                Text(log.time)
                  .fontSize(11)
                  .fontColor('#94A3B8')
                  .width(60)
                Text(log.message)
                  .fontSize(12)
                  .fontColor('#475569')
                  .layoutWeight(1)
              }
              .width('100%')
              .padding(4)
            }
          }, (log: Object, index: number) => `${index}`)
        }
        .width('100%')
        .height(160)
        .borderRadius(8)
        .backgroundColor('#F8FAFC')
        .padding(4)
      }
    }
    .width('100%')
    .padding(16)
    .borderRadius(16)
    .backgroundColor('#FFFFFF')
    .shadow({ radius: 8, color: 'rgba(0,0,0,0.06)', offsetX: 0, offsetY: 2 })
  }

  // 更新安全评分
  private updateSecurityScore() {
    let score = 50; // 基础分
    if (this.enableSanitization) score += 15;
    if (this.enableAnomalyDetection) score += 15;
    if (this.enableEnsemble) score += 10;
    if (this.enableOutputValidation) score += 10;
    this.securityScore = Math.min(100, score);

    if (this.securityScore > 80) {
      this.threatLevel = '低';
      this.threatColor = '#10B981';
    } else if (this.securityScore > 50) {
      this.threatLevel = '中';
      this.threatColor = '#F59E0B';
    } else {
      this.threatLevel = '高';
      this.threatColor = '#EF4444';
    }
  }

  // 运行攻击测试
  private async runAttackTest() {
    this.addLog('info', '开始对抗攻击测试...');

    const methods = ['fgsm', 'pgd', 'cw'];
    const attackConfig: AttackConfig = {
      method: methods[this.selectedAttackMethod] as 'fgsm' | 'pgd' | 'cw',
      epsilon: this.epsilonValue,
      stepSize: this.epsilonValue / 4,
      numSteps: 20,
      targetClass: -1,
      clipMin: 0,
      clipMax: 1
    };

    // 模拟攻击结果
    const isAttackSuccessful = Math.random() > 0.6; // 60%概率攻击被防御
    this.totalAttacks++;

    if (isAttackSuccessful) {
      this.passedAttacks++;
      this.attackResult = `⚠️ ${methods[this.selectedAttackMethod].toUpperCase()}攻击成功！` +
        `\nε=${this.epsilonValue.toFixed(3)}, 模型预测被改变`;
      this.addLog('error', `${methods[this.selectedAttackMethod].toUpperCase()}攻击成功！ε=${this.epsilonValue.toFixed(3)}`);
    } else {
      this.blockedAttacks++;
      this.attackResult = `✅ ${methods[this.selectedAttackMethod].toUpperCase()}攻击已被防御！` +
        `\nε=${this.epsilonValue.toFixed(3)}, 模型预测未受影响`;
      this.addLog('info', `${methods[this.selectedAttackMethod].toUpperCase()}攻击已被拦截`);
    }

    this.defenseResult = `防御方法: ${[
      this.enableSanitization ? '输入净化' : '',
      this.enableAnomalyDetection ? '异常检测' : '',
      this.enableEnsemble ? '模型集成' : '',
      this.enableOutputValidation ? '输出校验' : ''
    ].filter(Boolean).join(' → ')}`;
  }

  // 添加安全日志
  private addLog(level: 'info' | 'warn' | 'error', message: string) {
    this.securityLogs.unshift({
      time: new Date().toLocaleTimeString(),
      type: level,
      message,
      level
    });
    if (this.securityLogs.length > 30) {
      this.securityLogs.pop();
    }
  }
}

四、踩坑与注意事项

坑1：输入净化反而降低正常推理精度

问题：JPEG压缩、位深度降低等净化操作会损失正常输入的信息，导致模型在干净数据上的精度也下降了。

解决方案：

• 只在高风险场景启用净化（如金融、安防）
• 使用轻量级净化（如只做随机缩放，不做JPEG压缩）
• 自适应净化：先检测是否可疑，可疑才净化

坑2：异常检测误报率过高

问题：把正常但"不太常见"的输入也标记为对抗样本，用户体验极差。比如用户在暗光下拍照，图像统计特征和正常光照差异大，被误判为对抗攻击。

解决方案：

• 使用更大的阈值，宁可漏检也不要误报
• 结合多种检测方法，只有多个指标同时异常才判定为对抗样本
• 收集真实场景数据校准检测阈值

坑3：对抗训练导致干净数据精度下降

问题：对抗训练的代价是"鲁棒性-精度权衡"（Robustness-Accuracy Tradeoff）。模型越鲁棒，在干净数据上的精度可能越低。

解决方案：

• 控制对抗训练的扰动幅度ε，不要设太大
• 使用TRADES算法，显式平衡鲁棒性和精度
• 只对关键层做对抗训练，非关键层正常训练

坑4：黑盒攻击绕过防御

问题：你的防御是针对已知攻击设计的，但攻击者可能使用完全不同的攻击方法。比如你防御了FGSM，但攻击者用了迁移攻击（在其他模型上生成对抗样本，迁移到你的模型上）。

解决方案：

• 防御策略应该多样化，不要只依赖单一方法
• 输入净化对迁移攻击也有效（因为净化破坏了精心设计的扰动）
• 模型集成可以降低迁移攻击成功率

坑5：模型提取攻击

问题：攻击者通过大量查询你的模型，逐步"复刻"出一个功能相似的替代模型，然后在替代模型上生成对抗样本迁移攻击你的真实模型。

解决方案：

• 限制API调用频率
• 对输出概率加噪声（不返回精确概率）
• 限制返回的Top-K类别数
• 检测异常查询模式（如短时间内大量相似查询）

五、HarmonyOS 6适配

5.1 API差异

5.2 迁移指南

// HarmonyOS 5.0 - 手动实现输入净化
function sanitizeInput(input: Float32Array): Float32Array {
  // 手动实现JPEG压缩模拟等
  return input;
}

// HarmonyOS 6 - 系统级输入净化
import { aiSecurity } from '@kit.AiKit';

const sanitizer = aiSecurity.createInputSanitizer({
  methods: [
    aiSecurity.SanitizeMethod.JPEG_COMPRESSION,
    aiSecurity.SanitizeMethod.RANDOM_RESIZE,
    aiSecurity.SanitizeMethod.BIT_DEPTH_REDUCTION
  ],
  quality: 75, // JPEG质量
  aggressiveness: 'medium' // 净化强度：low/medium/high
});

const sanitizedInput = await sanitizer.sanitize(rawInput);

// 新增：AI推理安全审计
import { aiAudit } from '@kit.AiKit';

aiAudit.logInference({
  modelId: 'face_recognition_v2',
  inputHash: await aiAudit.computeHash(input),
  outputClass: result.classIndex,
  confidence: result.confidence,
  defenseTriggers: ['input_sanitization', 'anomaly_detection'],
  riskScore: 0.15
});

5.3 HarmonyOS 6新增特性

• AI安全飞地：在TEE中执行推理，即使系统被root也无法篡改推理过程
• 模型加密存储：模型文件使用设备唯一密钥加密，防止模型提取
• 系统级输入净化：aiSecurity模块提供标准化的输入净化API
• 推理安全审计：记录每次推理的输入/输出/防御触发/风险评分
• 自适应防御策略：根据攻击频率自动调整防御强度（平时宽松，攻击高峰严格）

六、总结

AI安全是一个"军备竞赛"——防御者和攻击者永远在博弈。没有绝对安全的系统，但我们可以让攻击成本高到不划算。就像家里的门锁不能防住专业小偷，但能防住99%的随手拉门的人。

在HarmonyOS APP开发中，AI安全不应该是一个"事后补丁"，而应该从设计阶段就纳入考量。哪些场景需要防御？防御强度设多少？误报率容忍多少？这些问题都需要在开发初期就明确。HarmonyOS 6的AI安全飞地和系统级净化API，让安全防护变得更加标准化和易用，但开发者对安全原理的理解依然是不可替代的。