一、引言

二、技术背景

1. 本地敏感信息存储的挑战

• ​​明文存储的风险​​：直接将敏感信息（如用户Token、身份证号）以明文形式保存在Preferences或文件中，攻击者可通过文件提取工具（如Root后的文件管理器）直接读取。
• ​​设备环境复杂性​​：鸿蒙设备可能面临root、恶意应用窃取数据、备份泄露等威胁，需通过加密保护数据即使被非法获取也无法解密。
• ​​合规要求​​：国内外隐私法规（如GDPR、中国个人信息保护法）要求应用对用户敏感数据采取“合理的安全保护措施”，加密存储是基本合规手段。

2. AES加密算法简介

• ​​对称加密​​：加密与解密使用同一密钥（Key），特点是​​加解密速度快​​，适合大量数据的加密场景。
• ​​AES标准​​：支持128位、192位、256位密钥长度（鸿蒙常用128位或256位），通过分组加密（如CBC、GCM模式）处理数据，具备​​抗差分攻击、抗线性攻击​​等安全特性。
• ​​密钥管理​​：密钥的安全性是AES加密的核心，需避免硬编码在代码中，推荐通过​​鸿蒙KeyStore（密钥库）​​或用户输入派生密钥。

3. 鸿蒙的存储与加密支持

• ​​本地存储能力​​：提供Preferences（轻量键值存储）、文件系统（本地文件读写）等API，用于存储用户数据。
• ​​加密基础能力​​：通过@ohos.security.crypto模块（或类似模块，具体参考鸿蒙官方文档）提供AES等加密算法的实现，支持密钥生成、加密/解密操作。
• ​​密钥安全存储​​：鸿蒙KeyStore可安全存储加密密钥（密钥本身加密后存于硬件级安全区域），避免密钥明文暴露在应用进程中。

三、应用使用场景

1. 用户凭证存储

2. 敏感配置信息

3. 用户个人数据

4. 支付与金融信息

四、不同场景下详细代码实现

环境准备

• ​​开发工具​​：DevEco Studio（鸿蒙官方IDE，基于IntelliJ IDEA）。
• ​​SDK版本​​：HarmonyOS 3.2+（推荐最新稳定版）。
• ​​语言​​：ArkTS（鸿蒙主流开发语言）。
• ​​关键模块​​：使用鸿蒙的@ohos.crypto（或@ohos.security.crypto，具体根据SDK版本调整）模块实现AES加密，通过@ohos.data.preferences模块管理本地存储（示例以Preferences为例，文件存储逻辑类似）。

场景1：AES加密存储用户Token（Preferences示例）

1. 核心工具类：AES加密/解密工具

// utils/AesUtil.ets
import crypto from '@ohos.crypto'; // 假设鸿蒙提供crypto模块（实际可能为@ohos.security.crypto）

// 生成固定的AES密钥（实际项目中应通过安全方式生成/存储，如鸿蒙KeyStore）
// 注意：此处仅为示例，生产环境密钥不应硬编码！
const AES_KEY = '0123456789abcdef'; // 16字节（128位）密钥（十六进制字符串转字节数组）
const AES_IV = 'abcdef9876543210'; // 16字节初始化向量（IV，CBC模式必需）

/**
 * AES-CBC模式加密（PKCS7填充）
 * @param plaintext 明文数据（字符串）
 * @returns Base64编码的加密结果
 */
export function encryptAES(plaintext: string): string {
  try {
    // 将密钥和IV从十六进制字符串转为字节数组
    const keyBytes = hexStringToBytes(AES_KEY);
    const ivBytes = hexStringToBytes(AES_IV);

    // 创建AES-CBC加密器
    const cipher = crypto.createCipher('AES-CBC', keyBytes, ivBytes);

    // 加密明文（PKCS7填充）
    const plaintextBytes = stringToBytes(plaintext);
    const encryptedBytes = cipher.update(plaintextBytes);
    const finalBytes = cipher.doFinal(); // 处理剩余数据
    const allEncryptedBytes = new Uint8Array(encryptedBytes.length + finalBytes.length);
    allEncryptedBytes.set(encryptedBytes, 0);
    allEncryptedBytes.set(finalBytes, encryptedBytes.length);

    // 返回Base64编码的加密结果（便于存储）
    return bytesToBase64(allEncryptedBytes);
  } catch (error) {
    console.error('AES加密失败:', error);
    throw new Error('加密失败');
  }
}

/**
 * AES-CBC模式解密（PKCS7填充）
 * @param ciphertext Base64编码的加密数据
 * @returns 解密后的明文字符串
 */
export function decryptAES(ciphertext: string): string {
  try {
    // 将密钥和IV从十六进制字符串转为字节数组
    const keyBytes = hexStringToBytes(AES_KEY);
    const ivBytes = hexStringToBytes(AES_IV);

    // 创建AES-CBC解密器
    const decipher = crypto.createDecipher('AES-CBC', keyBytes, ivBytes);

    // 解密密文（Base64转字节数组）
    const ciphertextBytes = base64ToBytes(ciphertext);
    const decryptedBytes = decipher.update(ciphertextBytes);
    const finalBytes = decipher.doFinal(); // 处理剩余数据
    const allDecryptedBytes = new Uint8Array(decryptedBytes.length + finalBytes.length);
    allDecryptedBytes.set(decryptedBytes, 0);
    allDecryptedBytes.set(finalBytes, decryptedBytes.length);

    // 返回明文字符串
    return bytesToString(allDecryptedBytes);
  } catch (error) {
    console.error('AES解密失败:', error);
    throw new Error('解密失败');
  }
}

// 辅助函数：十六进制字符串转字节数组
function hexStringToBytes(hex: string): Uint8Array {
  const bytes = new Uint8Array(hex.length / 2);
  for (let i = 0; i < hex.length; i += 2) {
    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
  }
  return bytes;
}

// 辅助函数：字节数组转十六进制字符串
function bytesToHex(bytes: Uint8Array): string {
  let hex = '';
  for (const byte of bytes) {
    hex += byte.toString(16).padStart(2, '0');
  }
  return hex;
}

// 辅助函数：字符串转字节数组（UTF-8编码）
function stringToBytes(str: string): Uint8Array {
  return new TextEncoder().encode(str);
}

// 辅助函数：字节数组转字符串（UTF-8解码）
function bytesToString(bytes: Uint8Array): string {
  return new TextDecoder().decode(bytes);
}

// 辅助函数：字节数组转Base64字符串
function bytesToBase64(bytes: Uint8Array): string {
  return btoa(String.fromCharCode.apply(null, bytes as unknown as number[]));
}

// 辅助函数：Base64字符串转字节数组
function base64ToBytes(base64: string): Uint8Array {
  const binaryString = atob(base64);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes;
}

2. Token管理类：加密存储与读取

// utils/TokenManager.ets
import { encryptAES, decryptAES } from './AesUtil';
import preferences from '@ohos.data.preferences'; // Preferences模块

const PREFERENCES_NAME = 'user_prefs'; // Preferences名称
const TOKEN_KEY = 'encrypted_token';   // 存储加密Token的键

/**
 * Token管理器：负责加密存储和读取用户Token
 */
export class TokenManager {
  private context: any; // 鸿蒙上下文（实际通过Ability获取）

  constructor(context: any) {
    this.context = context;
  }

  /**
   * 加密并存储Token到Preferences
   * @param token 用户登录后的Token（明文）
   */
  async saveToken(token: string): Promise<void> {
    try {
      const encryptedToken = encryptAES(token); // AES加密
      const pref = await preferences.getPreferences(this.context, PREFERENCES_NAME);
      await pref.put(TOKEN_KEY, encryptedToken);
      await pref.flush(); // 提交写入
      console.log('Token已加密存储');
    } catch (error) {
      console.error('存储Token失败:', error);
      throw new Error('存储失败');
    }
  }

  /**
   * 从Preferences读取并解密Token
   * @returns 解密后的Token（明文），若不存在返回null
   */
  async getToken(): Promise<string | null> {
    try {
      const pref = await preferences.getPreferences(this.context, PREFERENCES_NAME);
      const encryptedToken = pref.get(TOKEN_KEY, null) as string | null;
      if (!encryptedToken) {
        console.log('未找到加密Token');
        return null;
      }
      const token = decryptAES(encryptedToken); // AES解密
      console.log('Token已解密读取');
      return token;
    } catch (error) {
      console.error('读取Token失败:', error);
      return null; // 解密失败时返回null（避免应用崩溃）
    }
  }

  /**
   * 清除存储的Token（退出登录时调用）
   */
  async clearToken(): Promise<void> {
    try {
      const pref = await preferences.getPreferences(this.context, PREFERENCES_NAME);
      await pref.delete(TOKEN_KEY);
      await pref.flush();
      console.log('Token已清除');
    } catch (error) {
      console.error('清除Token失败:', error);
    }
  }
}

3. 在Ability中使用TokenManager

// EntryAbility.ets（示例Ability）
import UIAbility from '@ohos.app.ability.UIAbility';
import hilog from '@ohos.hilog';
import { TokenManager } from './utils/TokenManager';

export default class EntryAbility extends UIAbility {
  private tokenManager: TokenManager | null = null;

  onCreate(want, launchParam) {
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate');
    // 初始化TokenManager（传入当前Ability的上下文）
    this.tokenManager = new TokenManager(this.context);
  }

  // 模拟登录成功后保存Token
  async onLoginSuccess(token: string) {
    if (this.tokenManager) {
      await this.tokenManager.saveToken(token);
      hilog.info(0x0000, 'testTag', 'Token保存成功: %{public}s', token);
    }
  }

  // 应用启动时读取Token
  async onAppStart() {
    if (this.tokenManager) {
      const token = await this.tokenManager.getToken();
      if (token) {
        hilog.info(0x0000, 'testTag', '读取到Token: %{public}s', token);
        // 使用Token请求用户数据...
      } else {
        hilog.info(0x0000, 'testTag', '未找到Token，需重新登录');
      }
    }
  }

  // 退出登录时清除Token
  async onLogout() {
    if (this.tokenManager) {
      await this.tokenManager.clearToken();
      hilog.info(0x0000, 'testTag', 'Token已清除');
    }
  }
}

场景2：AES加密存储敏感配置文件（文件系统示例）

代码实现

// utils/ConfigManager.ets
import { encryptAES, decryptAES } from './AesUtil';
import fs from '@ohos.file.fs'; // 文件系统模块

const CONFIG_FILE_PATH = '/data/accounts/account_0/appdata/config.json'; // 配置文件路径

/**
 * 加密并保存配置文件（仅加密敏感字段）
 * @param config 原始配置对象（包含明文apiKey）
 */
export async function saveEncryptedConfig(config: { apiKey: string; otherField: string }): Promise<void> {
  try {
    // 加密敏感字段（apiKey）
    const encryptedApiKey = encryptAES(config.apiKey);
    const encryptedConfig = {
      apiKey: encryptedApiKey, // 加密后的apiKey
      otherField: config.otherField // 非敏感字段保持明文
    };

    // 写入文件（JSON格式）
    const file = await fs.open(CONFIG_FILE_PATH, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
    const content = JSON.stringify(encryptedConfig);
    await fs.write(file.fd, Buffer.from(content));
    await fs.close(file.fd);
    console.log('加密配置文件已保存');
  } catch (error) {
    console.error('保存加密配置失败:', error);
    throw new Error('保存失败');
  }
}

/**
 * 读取并解密配置文件
 * @returns 解密后的配置对象（apiKey为明文）
 */
export async function getDecryptedConfig(): Promise<{ apiKey: string; otherField: string } | null> {
  try {
    const file = await fs.open(CONFIG_FILE_PATH, fs.OpenMode.READ_ONLY);
    const stat = await fs.stat(file.fd);
    const buffer = new ArrayBuffer(stat.size);
    const view = new Uint8Array(buffer);
    await fs.read(file.fd, view, 0, stat.size);
    await fs.close(file.fd);

    // 解析JSON
    const encryptedConfig = JSON.parse(new TextDecoder().decode(buffer));
    const decryptedApiKey = decryptAES(encryptedConfig.apiKey); // 解密apiKey
    const decryptedConfig = {
      apiKey: decryptedApiKey, // 明文apiKey
      otherField: encryptedConfig.otherField // 非敏感字段
    };
    console.log('加密配置文件已读取并解密');
    return decryptedConfig;
  } catch (error) {
    console.error('读取加密配置失败:', error);
    return null;
  }
}

五、原理解释与核心特性

1. 核心原理流程图

graph TD
    A[用户输入敏感数据/应用生成敏感信息] --> B{是否需要持久化存储?}
    B -->|否| C[内存中临时使用]
    B -->|是| D[调用AES加密工具]
    D --> D1[生成/获取密钥（如硬编码/KeyStore）]
    D1 --> D2[选择加密模式（如AES-CBC）和填充方式（如PKCS7）]
    D2 --> D3[加密明文数据，输出密文字节数组]
    D3 --> D4[将密文转为Base64/十六进制字符串（便于存储）]
    D4 --> E[存储到Preferences/文件系统]
    E --> F[应用启动/需要时读取密文]
    F --> F1[从存储中读取密文字符串]
    F1 --> F2[将密文字符串转回字节数组]
    F2 --> F3[调用AES解密工具]
    F3 --> F4[使用相同密钥和IV解密]
    F4 --> F5[输出明文数据]
    F5 --> G[使用明文数据]

2. 核心特性

• ​​对称加密高效性​​：AES加解密速度快，适合本地大量数据的加密存储。
• ​​密钥可控性​​：通过固定密钥（示例）或鸿蒙KeyStore（推荐）管理密钥，避免密钥泄露。
• ​​模式安全性​​：采用CBC模式（需IV）或GCM模式（带认证），防止重放攻击和数据篡改。
• ​​数据兼容性​​：加密后的数据（Base64/十六进制）可无缝存储到Preferences、文件或数据库。

六、原理流程图以及原理解释

1. AES加密存储详细流程

sequenceDiagram
    participant App as 应用逻辑
    participant AES as AES加密工具
    participant Storage as 本地存储（Preferences/文件）

    App->>AES: 加密敏感数据（明文）
    AES->>AES: 生成密钥和IV（或从安全源获取）
    AES->>AES: 使用AES-CBC/PKCS7加密明文
    AES-->>App: 返回Base64编码的密文
    App->>Storage: 存储密文到Preferences/文件
    Storage-->>App: 确认存储成功

    App->>Storage: 读取密文
    Storage-->>App: 返回密文字符串
    App->>AES: 解密密文
    AES->>AES: 使用相同密钥和IV解密
    AES-->>App: 返回明文数据
    App->>App: 使用明文数据

2. 原理解释

• ​​加密过程​​：明文数据通过AES算法（如CBC模式）与密钥、IV进行数学变换，生成不可读的密文字节数组，再转为Base64字符串存储。
• ​​解密过程​​：存储的密文字符串转回字节数组，通过相同的密钥、IV和算法逆向变换，恢复原始明文。
• ​​安全性依赖​​：密钥的安全性是核心（示例中硬编码仅用于演示，实际应使用鸿蒙KeyStore或用户派生密钥）。

七、环境准备

1. 开发环境配置

• ​​安装DevEco Studio​​：从载并安装最新版。
• ​​创建项目​​：选择“Empty Ability”模板，创建支持ArkTS的鸿蒙应用。
• ​​权限配置​​：若存储到外部文件（非Preferences），需在module.json5中声明文件读写权限（如ohos.permission.READ_MEDIA等，根据实际路径调整）。

2. 依赖模块

• ​​加密模块​​：使用@ohos.crypto或@ohos.security.crypto（根据SDK版本调整）。
• ​​存储模块​​：Preferences（@ohos.data.preferences）或文件系统（@ohos.file.fs）。

八、实际详细应用代码示例实现

综合示例：登录Token + 敏感配置的加密存储

代码整合

• ​​Token管理​​：复用场景1的TokenManager（Preferences加密存储）。
• ​​配置管理​​：复用场景2的ConfigManager（文件系统加密存储）。

测试流程

1. 用户登录后调用tokenManager.saveToken('user_token_123')，Token被AES加密存储到Preferences。
2. 应用初始化时调用configManager.saveEncryptedConfig({ apiKey: 'secret_key_456', otherField: 'value' })，配置文件中的apiKey被加密存储。
3. 下次启动时，tokenManager.getToken()解密读取Token，configManager.getDecryptedConfig()解密读取配置，确保敏感数据全程加密。

九、运行结果

1. 预期效果

• ​​加密存储​​：Preferences和文件中的敏感数据均为密文（无法直接阅读）。
• ​​正常解密​​：应用启动后能正确解密并使用Token与配置。
• ​​安全防护​​：即使设备被root或应用数据被提取，攻击者无密钥无法解密明文。

2. 实际验证

• ​​查看存储内容​​：通过鸿蒙设备的文件管理器查看Preferences或配置文件，确认数据为Base64密文（如U2FsdGVkX1+...），而非明文Token或API密钥。
• ​​调试日志​​：通过hilog输出加密/解密过程的日志，确认流程正常执行。

十、测试步骤以及详细代码

1. 测试加密存储功能

1. ​​登录测试​​：模拟用户登录，调用tokenManager.saveToken('test_token_abc')，检查Preferences中是否生成加密数据。
2. ​​读取测试​​：重启应用后调用tokenManager.getToken()，确认返回的Token为明文test_token_abc。
3. ​​配置测试​​：调用configManager.saveEncryptedConfig({ apiKey: 'test_key_xyz', otherField: '123' })，检查配置文件内容是否为密文。
4. ​​解密测试​​：调用configManager.getDecryptedConfig()，确认返回的apiKey为明文test_key_xyz。

十一、部署场景

1. 生产环境部署

• ​​密钥安全管理​​：避免硬编码密钥（示例中的AES_KEY），推荐使用鸿蒙KeyStore存储密钥（通过@ohos.security.keystore模块），或通过用户PIN码派生密钥。
• ​​合规审计​​：在应用隐私政策中说明加密存储的用途（如“用户Token通过AES-256加密保存在本地，仅应用自身可解密”）。
• ​​备份防护​​：若支持数据备份（如鸿蒙的云备份），确保备份数据同样加密，避免备份泄露导致数据暴露。

2. 不同设备适配

• ​​低端设备优化​​：AES加密性能较高，但若设备资源紧张，可调整加密模式（如使用更轻量的ECB模式，但安全性较低，不推荐）。
• ​​多用户场景​​：若应用支持多用户，需为每个用户生成独立的加密密钥，避免用户间数据混淆。

十二、疑难解答

Q1：鸿蒙中如何安全生成AES密钥（避免硬编码）？

import keystore from '@ohos.security.keystore';

// 生成AES密钥并存储到KeyStore
const keyAlias = 'my_aes_key';
const keyParams = { keySize: 256, blockMode: 'CBC', padding: 'PKCS7' };
keystore.generateKey(keyAlias, keyParams).then((keyHandle) => {
  console.log('密钥已安全生成并存储');
}).catch((error) => {
  console.error('密钥生成失败:', error);
});

Q2：加密后的数据如何存储到SQLite数据库？

// 假设使用鸿蒙的数据库模块（如@ohos.data.rdb）
const encryptedData = encryptAES('敏感数据');
await database.executeSql('INSERT INTO sensitive_table (data_column) VALUES (?)', [encryptedData]);

Q3：用户卸载应用后，加密数据会被删除吗？

十三、未来展望与技术趋势

1. 技术趋势

• ​​鸿蒙KeyStore增强​​：未来鸿蒙可能提供更完善的密钥管理API（如密钥轮换、多密钥支持），简化开发者对加密密钥的安全管理。
• ​​国密算法支持​​：随着国内隐私要求的加强，鸿蒙可能集成SM4（中国商用密码算法）等国密标准，替代或补充AES。
• ​​隐私计算融合​​：结合本地加密与隐私计算技术（如同态加密），实现数据“可用不可见”，进一步提升安全性。

2. 挑战

• ​​密钥管理复杂度​​：如何平衡密钥的安全存储（如KeyStore）与应用的易用性（如跨设备同步密钥）是长期挑战。
• ​​性能优化​​：对大文件（如用户相册）的AES加密可能影响存储/读取速度，需优化加密粒度（如分块加密）。
• ​​合规动态变化​​：隐私法规（如欧盟ENISA指南）可能对加密算法的强度、密钥生命周期提出新要求，开发者需持续跟进。

十四、总结