HarmonyOS开发：应用加固——安全加固

📌 核心要点：应用加固是保护HAP不被逆向、篡改、调试的最后一道防线，从反调试、反篡改、代码混淆到运行时保护，层层设防才能让攻击者知难而退。

背景与动机

你的应用上线了，第二天就有人在论坛上发"破解版"。你的付费功能被绕过了，你的API接口被扒出来了，你的加密算法被逆向了。

你气不气？

HarmonyOS的HAP本质是ZIP包，解压就能看到ABC字节码。虽然ABC比JavaScript更难逆向，但也不是不可能。有经验的逆向工程师，配合反编译工具，花点时间就能还原你的核心逻辑。

更可怕的是篡改——攻击者修改你的HAP，植入广告或恶意代码，重新签名分发。用户以为装的是你的应用，实际上已经被"加料"了。

应用加固不是"锦上添花"，是"不得不做"。尤其是金融、支付、游戏这些高价值应用，不加固等于裸奔。

核心原理

应用面临的安全威胁

flowchart TD
    A[HAP安全威胁] --> B[静态分析]
    A --> C[动态调试]
    A --> D[篡改重签名]
    A --> E[内存dump]

    B --> B1[反编译ABC字节码]
    B --> B2[提取资源与配置]
    B --> B3[分析加密算法]

    C --> C1[hdc调试附加]
    C --> C2[断点跟踪逻辑]
    C --> C3[运行时修改数据]

    D --> D1[修改HAP内容]
    D --> D2[替换签名]
    D --> D3[分发恶意版本]

    E --> E1[运行时内存快照]
    E --> E2[提取密钥与敏感数据]
    E --> E3[Hook关键函数]

    classDef threat fill:#FF6B6B,stroke:#CC5555,color:#fff
    classDef static fill:#F39C12,stroke:#D68910,color:#fff
    classDef dynamic fill:#4A90D9,stroke:#2C5F8A,color:#fff
    classDef tamper fill:#9B59B6,stroke:#8E44AD,color:#fff
    classDef memory fill:#2ECC71,stroke:#25A55A,color:#fff

    class A threat
    class B,B1,B2,B3 static
    class C,C1,C2,C3 dynamic
    class D,D1,D2,D3 tamper
    class E,E1,E2,E3 memory

加固技术体系

对应以上威胁，加固技术也分四层：

加固流程

flowchart TD
    A[原始HAP] --> B[代码混淆]
    B --> C[字符串加密]
    C --> D[反调试注入]
    D --> E[完整性校验注入]
    E --> F[签名保护]
    F --> G[加固后HAP]

    classDef input fill:#4A90D9,stroke:#2C5F8A,color:#fff
    classDef process fill:#F39C12,stroke:#D68910,color:#fff
    classDef output fill:#2ECC71,stroke:#25A55A,color:#fff

    class A input
    class B,C,D,E,F process
    class G output

代码实战

基础用法：反调试检测

最基本的安全措施——检测是否被调试器附加：

// shared_common/src/main/ets/security/AntiDebug.ets
// 反调试检测工具

import { process } from '@kit.BasicServicesKit';

export class AntiDebug {
  private static debugCheckInterval: number = -1;

  // 方法1：检测debugger标志
  static isDebuggerAttached(): boolean {
    // 检查进程是否被调试
    // HarmonyOS中可以通过进程信息判断
    try {
      const isDebug = process.isDebug();
      return isDebug;
    } catch (e) {
      return false;
    }
  }

  // 方法2：时间差检测
  // 调试器设断点会导致代码执行时间异常
  static checkTimingAnomaly(): boolean {
    const start = Date.now();
    
    // 执行一段简单运算
    let sum = 0;
    for (let i = 0; i < 10000; i++) {
      sum += i;
    }
    
    const elapsed = Date.now() - start;
    
    // 正常执行应该在1ms以内
    // 如果被调试，时间会明显偏长
    return elapsed > 100;
  }

  // 方法3：持续监控
  // 定期检查调试状态，发现异常立即响应
  static startMonitoring(
    onDebugDetected: () => void,
    intervalMs: number = 5000
  ): void {
    AntiDebug.debugCheckInterval = setInterval(() => {
      if (AntiDebug.isDebuggerAttached() || AntiDebug.checkTimingAnomaly()) {
        console.warn('⚠️ 检测到调试器附加');
        onDebugDetected();
      }
    }, intervalMs) as unknown as number;
  }

  // 停止监控
  static stopMonitoring(): void {
    if (AntiDebug.debugCheckInterval !== -1) {
      clearInterval(AntiDebug.debugCheckInterval);
      AntiDebug.debugCheckInterval = -1;
    }
  }

  // 调试检测响应策略
  static handleDebugDetected(): void {
    // 策略1：静默退出（不暴露检测逻辑）
    // process.exit(0);  // 谨慎使用，可能影响用户体验

    // 策略2：降级运行（关闭敏感功能）
    console.warn('检测到调试环境，敏感功能已禁用');

    // 策略3：上报服务器
    // SecurityReporter.report('debug_detected');
  }
}

在应用启动时启用反调试：

// entry/src/main/ets/entryability/EntryAbility.ets
import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';
import { AntiDebug } from '@ohos/shared_common';

export default class EntryAbility extends UIAbility {
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
    // Release模式下启用反调试
    if (!__DEV__) {
      AntiDebug.startMonitoring(() => {
        AntiDebug.handleDebugDetected();
      });
    }
  }

  onDestroy(): void {
    AntiDebug.stopMonitoring();
  }
}

进阶用法：反篡改与完整性校验

检测应用是否被篡改，是防止"加料"分发的关键：

// shared_common/src/main/ets/security/IntegrityCheck.ets
// 应用完整性校验

import { bundleManager } from '@kit.AbilityKit';
import { cryptoFramework } from '@kit.CryptoArchitectureKit';
import { fileIo } from '@kit.CoreFileKit';

export class IntegrityCheck {
  // 预期的签名指纹（发布时写入）
  private static readonly EXPECTED_SIGN_FINGERPRINT = 'AB:CD:EF:12:34:56:78:90:...';

  // 校验应用签名
  static async verifyAppSignature(): Promise<boolean> {
    try {
      const bundleInfo = await bundleManager.getBundleInfoForSelf(
        bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_SIGNATURE_INFO
      );

      // 获取当前应用的签名指纹
      const signInfo = bundleInfo.appInfo?.signatureInfo;
      if (!signInfo) {
        console.error('无法获取签名信息');
        return false;
      }

      // 比对签名指纹
      const currentFingerprint = signInfo.fingerprint;
      const isValid = currentFingerprint === IntegrityCheck.EXPECTED_SIGN_FINGERPRINT;

      if (!isValid) {
        console.error('❌ 签名指纹不匹配，应用可能被篡改');
      }

      return isValid;
    } catch (error) {
      console.error(`签名校验异常: ${error}`);
      return false;
    }
  }

  // 校验HAP文件完整性
  static async verifyHapIntegrity(): Promise<boolean> {
    try {
      // 获取HAP安装路径
      const bundleInfo = await bundleManager.getBundleInfoForSelf(
        bundleManager.BundleFlag.GET_BUNDLE_INFO_DEFAULT
      );
      const hapPath = bundleInfo.appInfo?.codePath;
      if (!hapPath) return false;

      // 计算HAP文件的SHA256
      const hash = cryptoFramework.createHash('SHA256');
      const fileData = fileIo.readArrayBufferSync(hapPath);
      hash.update({ data: fileData });
      const result = hash.digest();
      const currentHash = IntegrityCheck.arrayBufferToHex(result.data);

      // 与预期哈希比对
      // EXPECTED_HAP_HASH 在发布时写入
      const expectedHash = IntegrityCheck.getExpectedHash();
      const isValid = currentHash === expectedHash;

      if (!isValid) {
        console.error('❌ HAP完整性校验失败');
      }

      return isValid;
    } catch (error) {
      console.error(`完整性校验异常: ${error}`);
      return false;
    }
  }

  // 校验运行环境
  static async verifyRuntimeEnvironment(): Promise<{
    isSecure: boolean;
    risks: string[];
  }> {
    const risks: string[] = [];

    // 检查1：是否在模拟器上运行
    // 模拟器环境容易被逆向
    const isEmulator = IntegrityCheck.detectEmulator();
    if (isEmulator) {
      risks.push('运行在模拟器环境');
    }

    // 检查2：是否被Root/越狱
    const isRooted = IntegrityCheck.detectRoot();
    if (isRooted) {
      risks.push('设备已被Root');
    }

    // 检查3：签名是否合法
    const signatureValid = await IntegrityCheck.verifyAppSignature();
    if (!signatureValid) {
      risks.push('应用签名异常');
    }

    // 检查4：是否被重打包
    const integrityValid = await IntegrityCheck.verifyHapIntegrity();
    if (!integrityValid) {
      risks.push('应用完整性异常');
    }

    return {
      isSecure: risks.length === 0,
      risks
    };
  }

  // 检测模拟器
  private static detectEmulator(): boolean {
    // 检查设备特征
    try {
      const deviceInfo = device.getInfo();
      // 模拟器通常有特定的设备型号标识
      const emulatorModels = ['sdk_gphone', 'emulator', 'virtual'];
      return emulatorModels.some(m =>
        deviceInfo.model.toLowerCase().includes(m)
      );
    } catch (e) {
      return false;
    }
  }

  // 检测Root
  private static detectRoot(): boolean {
    try {
      // 尝试访问Root特有的路径
      const rootPaths = ['/system/app/Superuser.apk', '/sbin/su'];
      for (const p of rootPaths) {
        if (fileIo.accessSync(p)) {
          return true;
        }
      }
      return false;
    } catch (e) {
      return false;
    }
  }

  // 辅助方法
  private static arrayBufferToHex(buffer: ArrayBuffer): string {
    const view = new Uint8Array(buffer);
    return Array.from(view)
      .map(b => b.toString(16).padStart(2, '0'))
      .join(':')
      .toUpperCase();
  }

  private static getExpectedHash(): string {
    // 实际项目中，这个值应该从安全存储或服务器获取
    // 不要硬编码在代码中
    return 'EXPECTED_SHA256_HASH';
  }
}

完整示例：安全加固管理器

将所有安全措施整合到一起：

// shared_common/src/main/ets/security/SecurityGuard.ets
// 安全加固管理器

import { AntiDebug } from './AntiDebug';
import { IntegrityCheck } from './IntegrityCheck';

// 安全等级
enum SecurityLevel {
  SAFE = 'safe',               // 安全
  WARNING = 'warning',         // 警告
  DANGER = 'danger'            // 危险
}

// 安全检查结果
interface SecurityCheckResult {
  level: SecurityLevel;
  isDebugged: boolean;
  isTampered: boolean;
  risks: string[];
  timestamp: number;
}

// 安全事件回调
type SecurityCallback = (result: SecurityCheckResult) => void;

export class SecurityGuard {
  private static instance: SecurityGuard | null = null;
  private checkInterval: number = -1;
  private callback: SecurityCallback | null = null;
  private lastResult: SecurityCheckResult | null = null;

  private constructor() {}

  static getInstance(): SecurityGuard {
    if (!SecurityGuard.instance) {
      SecurityGuard.instance = new SecurityGuard();
    }
    return SecurityGuard.instance;
  }

  // 启动安全防护
  startProtection(callback: SecurityCallback): void {
    this.callback = callback;

    // 启用反调试监控
    AntiDebug.startMonitoring(() => {
      this.onSecurityEvent('调试器检测');
    });

    // 定期执行安全检查
    this.checkInterval = setInterval(() => {
      this.performSecurityCheck();
    }, 30000) as unknown as number;    // 每30秒检查一次

    // 立即执行一次检查
    this.performSecurityCheck();
  }

  // 停止安全防护
  stopProtection(): void {
    AntiDebug.stopMonitoring();
    if (this.checkInterval !== -1) {
      clearInterval(this.checkInterval);
      this.checkInterval = -1;
    }
  }

  // 执行安全检查
  private async performSecurityCheck(): Promise<void> {
    const isDebugged = AntiDebug.isDebuggerAttached();
    const envResult = await IntegrityCheck.verifyRuntimeEnvironment();

    const level = this.calculateSecurityLevel(isDebugged, envResult.risks);

    const result: SecurityCheckResult = {
      level,
      isDebugged,
      isTampered: !envResult.isSecure,
      risks: envResult.risks,
      timestamp: Date.now()
    };

    this.lastResult = result;

    // 回调通知
    if (this.callback) {
      this.callback(result);
    }

    // 根据安全等级采取行动
    this.handleSecurityLevel(result);
  }

  // 计算安全等级
  private calculateSecurityLevel(isDebugged: boolean, risks: string[]): SecurityLevel {
    if (isDebugged || risks.includes('应用签名异常') || risks.includes('应用完整性异常')) {
      return SecurityLevel.DANGER;
    }
    if (risks.length > 0) {
      return SecurityLevel.WARNING;
    }
    return SecurityLevel.SAFE;
  }

  // 处理安全等级
  private handleSecurityLevel(result: SecurityCheckResult): void {
    switch (result.level) {
      case SecurityLevel.DANGER:
        // 危险：禁用敏感功能，上报服务器
        console.error('🚨 安全等级：危险');
        this.disableSensitiveFeatures();
        this.reportToServer(result);
        break;

      case SecurityLevel.WARNING:
        // 警告：记录日志，降级运行
        console.warn('⚠️ 安全等级：警告');
        this.logSecurityEvent(result);
        break;

      case SecurityLevel.SAFE:
        // 安全：正常运行
        break;
    }
  }

  // 安全事件处理
  private onSecurityEvent(event: string): void {
    console.warn(`安全事件: ${event}`);
    this.performSecurityCheck();
  }

  // 禁用敏感功能
  private disableSensitiveFeatures(): void {
    // 设置全局标志，各业务模块检查此标志
    AppStorage.setOrCreate('security_compromised', true);
  }

  // 上报服务器
  private reportToServer(result: SecurityCheckResult): void {
    // 将安全事件上报到服务器
    // 实际项目中使用网络请求
    console.info('安全事件已上报');
  }

  // 记录安全日志
  private logSecurityEvent(result: SecurityCheckResult): void {
    const logEntry = {
      timestamp: new Date().toISOString(),
      level: result.level,
      risks: result.risks,
      isDebugged: result.isDebugged,
      isTampered: result.isTampered
    };
    // 写入安全日志
    console.info(`安全日志: ${JSON.stringify(logEntry)}`);
  }

  // 获取最近的安全检查结果
  getLastResult(): SecurityCheckResult | null {
    return this.lastResult;
  }

  // 检查是否安全
  isSecure(): boolean {
    return this.lastResult?.level === SecurityLevel.SAFE;
  }
}

在应用中使用：

// entry/src/main/ets/entryability/EntryAbility.ets
import { SecurityGuard } from '@ohos/shared_common';

export default class EntryAbility extends UIAbility {
  onCreate(): void {
    if (!__DEV__) {
      // Release模式启动安全防护
      SecurityGuard.getInstance().startProtection((result) => {
        if (result.level === 'danger') {
          // 危险环境，禁用支付等敏感功能
          console.error('检测到安全威胁，敏感功能已禁用');
        }
      });
    }
  }
}

// 业务代码中检查安全状态
// payment/src/main/ets/pages/PaymentPage.ets
import { SecurityGuard } from '@ohos/shared_common';

@Entry
@Component
struct PaymentPage {
  build() {
    Column() {
      if (!SecurityGuard.getInstance().isSecure()) {
        // 安全异常，显示提示
        Text('当前环境存在安全风险，支付功能暂不可用')
          .fontColor(Color.Red)
      } else {
        // 正常显示支付界面
        Text('确认支付')
      }
    }
  }
}

踩坑与注意事项

坑1：反调试检测误报

时间差检测在低端设备上可能误报——设备本身就慢，正常执行时间也可能超过阈值。

解法：时间检测阈值要留足余量，不要设得太紧。建议阈值设为正常执行时间的10倍以上。或者用多次检测取平均值，避免单次波动导致误判。

坑2：完整性校验在更新后失败

应用更新后，HAP文件变了，SHA256哈希也变了，完整性校验自然失败。

解法：完整性校验的预期哈希值不能硬编码，应该从服务器动态获取。每次应用更新后，服务器更新对应的哈希值。

坑3：加固影响调试效率

开发阶段加固全开，调试时各种检测报警，开发效率极低。

解法：加固只在Release模式下启用，Debug模式关闭所有安全检测。用__DEV__或构建变体控制：

if (!__DEV__) {
  // 只在Release模式启用安全防护
  SecurityGuard.getInstance().startProtection(callback);
}

坑4：字符串硬编码泄露敏感信息

密钥、API地址、加密算法的参数直接写在代码里，混淆后还是能搜到。

解法：

• 敏感字符串运行时拼接，不要完整出现
• 密钥从安全存储（HUKS）获取，不要写在代码里
• API地址用配置文件，不要硬编码

// 错误：密钥直接写在代码里
const API_KEY = 'sk-abc123def456';

// 正确：运行时拼接 + 从安全存储获取
import { huks } from '@kit.UniversalKeystoreKit';

async function getApiKey(): Promise<string> {
  // 从HUKS安全存储获取
  const keyHandle = await huks.getKeyItem({
    keyAlias: 'api_key',
    properties: []
  });
  // 解密获取明文
  return decryptKey(keyHandle);
}

坑5：过度加固导致性能问题

安全检查太频繁、加密解密太多，会拖慢应用启动速度和运行性能。

解法：安全检查频率要合理，启动时做一次完整检查，运行中每30秒做一次轻量检查。加密操作只在必要时执行，不要什么都加密。

HarmonyOS 6适配说明

HarmonyOS 6在应用安全方面有以下增强：

1. HUKS密钥管理增强：HUKS（Universal Keystore Kit）支持更多密钥类型和算法，密钥操作性能提升30%。新增密钥访问控制，可以限制密钥只在特定条件下可用（如用户认证后）。

2. 代码虚拟化保护：HarmonyOS 6的方舟编译器支持代码虚拟化，将ABC字节码转换为自定义虚拟机指令，大幅增加逆向难度。这是比混淆更强的保护手段。

3. 安全启动链：HarmonyOS 6加强了安全启动链，从Bootloader到内核到应用，每一层都验证下一层的完整性。被篡改的应用在启动阶段就会被拦截。

4. 运行时完整性保护：新增ProcessProtection API，可以保护进程的内存空间不被非法读写。防止内存dump和Hook攻击。

5. AGC应用加固服务：AppGallery Connect提供云端应用加固服务，上传HAP后自动完成混淆、加密、反调试注入，无需开发者手动处理。

总结

应用加固是"攻防博弈"，没有绝对的安全，只有让攻击成本高于收益。你的应用不值得花一个月去逆向，那你的防护就到位了。

核心策略：

• 分层防护：反调试+反篡改+代码混淆+运行时保护，不要只靠一招
• 动态检测：运行时持续检查，不要只在启动时检查一次
• 安全存储：密钥和敏感数据用HUKS，不要写在代码里
• 按需启用：Debug模式关闭加固，Release模式全开