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

一、背景与动机

2017年有个实验，至今让整个AI安全领域后背发凉——研究人员在停车标志上贴了几张黑白贴纸，结果自动驾驶系统直接把它认成了限速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 对抗攻击模拟器

直接上干货：用TypeScript实现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 {
        // 获取原始预测
        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 {
        // 初始化：从原始输入附近的随机点开始
        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;
        a vgPerturbation: 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,
            a vgPerturbation: 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 {
        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();
            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() {
        Na vigation() {
            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(Na vigationTitleMode.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，让安全防护变得更加标准化和易用，但开发者对安全原理的理解依然是不可替代的。