项目概述

数据加密和安全是现代应用开发中的核心需求。无论是在用户认证、数据传输、敏感信息存储还是隐私保护中，都需要进行各种加密和安全操作。然而，不同的编程语言和平台对加密和安全的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。

本文介绍一个基于 Kotlin Multiplatform (KMP) 和 OpenHarmony 平台的数据加密和安全工具库。这个工具库提供了一套完整的安全处理能力，包括数据加密、密码安全、令牌生成、数据签名等功能。通过 KMP 技术，我们可以在 Kotlin 中编写一次代码，然后编译到 JavaScript 和其他目标平台，最后在 OpenHarmony 的 ArkTS 中调用这些功能。

技术架构

多平台支持

• Kotlin/JVM: 后端服务和桌面应用
• Kotlin/JS: Web 应用和浏览器环境
• OpenHarmony/ArkTS: 鸿蒙操作系统应用

核心功能模块

1. 数据加密: 使用对称加密算法加密数据
2. 密码安全: 密码哈希和验证
3. 令牌生成: 生成安全令牌
4. 数据签名: 对数据进行数字签名
5. 密钥管理: 安全的密钥生成和存储
6. 随机数生成: 生成加密安全的随机数
7. 数据完整性: 验证数据完整性
8. 访问控制: 基于角色的访问控制

Kotlin 实现

核心数据加密和安全类

// 文件: src/commonMain/kotlin/SecurityManager.kt

import kotlin.random.Random

/**
 * 数据加密和安全管理工具类
 * 提供加密、密码安全、令牌生成等功能
 */
class SecurityManager {
    
    /**
     * 简单的 XOR 加密（演示用）
     * @param data 要加密的数据
     * @param key 加密密钥
     * @return 加密后的数据
     */
    fun encryptData(data: String, key: String): String {
        return data.mapIndexed { index, char ->
            (char.code xor key[index % key.length].code).toChar()
        }.joinToString("")
    }
    
    /**
     * XOR 解密
     * @param encryptedData 加密的数据
     * @param key 解密密钥
     * @return 解密后的数据
     */
    fun decryptData(encryptedData: String, key: String): String {
        return encryptData(encryptedData, key)
    }
    
    /**
     * 密码哈希（使用盐值）
     * @param password 密码
     * @param salt 盐值
     * @return 哈希后的密码
     */
    fun hashPassword(password: String, salt: String = generateSalt()): String {
        var hash = 0L
        val combined = password + salt
        for (char in combined) {
            hash = ((hash shl 5) - hash) + char.code
        }
        return "${hash.toString(16).padStart(16, '0')}:$salt"
    }
    
    /**
     * 验证密码
     * @param password 输入的密码
     * @param hashedPassword 存储的哈希密码
     * @return 密码是否匹配
     */
    fun verifyPassword(password: String, hashedPassword: String): Boolean {
        val parts = hashedPassword.split(":")
        if (parts.size != 2) return false
        val salt = parts[1]
        return hashPassword(password, salt) == hashedPassword
    }
    
    /**
     * 生成随机盐值
     * @param length 盐值长度
     * @return 随机盐值
     */
    fun generateSalt(length: Int = 16): String {
        val chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
        return (1..length).map { chars.random() }.joinToString("")
    }
    
    /**
     * 生成安全令牌
     * @param length 令牌长度
     * @return 安全令牌
     */
    fun generateSecureToken(length: Int = 32): String {
        val chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
        return (1..length).map { chars.random() }.joinToString("")
    }
    
    /**
     * 计算数据的校验和
     * @param data 数据
     * @return 校验和
     */
    fun calculateChecksum(data: String): String {
        var checksum = 0L
        for (char in data) {
            checksum += char.code
        }
        return checksum.toString(16).padStart(16, '0')
    }
    
    /**
     * 验证数据完整性
     * @param data 数据
     * @param checksum 校验和
     * @return 数据是否完整
     */
    fun verifyIntegrity(data: String, checksum: String): Boolean {
        return calculateChecksum(data) == checksum
    }
    
    /**
     * 生成数字签名
     * @param data 要签名的数据
     * @param privateKey 私钥
     * @return 签名
     */
    fun signData(data: String, privateKey: String): String {
        var signature = 0L
        for (char in data) {
            signature = ((signature shl 5) or (signature ushr 27)) xor char.code.toLong()
        }
        for (char in privateKey) {
            signature = signature xor char.code.toLong()
        }
        return signature.toString(16).padStart(16, '0')
    }
    
    /**
     * 验证数字签名
     * @param data 原始数据
     * @param signature 签名
     * @param publicKey 公钥
     * @return 签名是否有效
     */
    fun verifySignature(data: String, signature: String, publicKey: String): Boolean {
        val expectedSignature = signData(data, publicKey)
        return signature == expectedSignature
    }
    
    /**
     * 生成 API 密钥
     * @return API 密钥
     */
    fun generateApiKey(): String {
        return "sk_" + generateSecureToken(32)
    }
    
    /**
     * 验证 API 密钥格式
     * @param apiKey API 密钥
     * @return 是否有效
     */
    fun isValidApiKey(apiKey: String): Boolean {
        return apiKey.startsWith("sk_") && apiKey.length == 35
    }
    
    /**
     * 获取安全信息摘要
     * @param data 数据
     * @return 安全信息映射
     */
    fun getSecuritySummary(data: String): Map<String, Any> {
        return mapOf(
            "dataLength" to data.length,
            "checksum" to calculateChecksum(data),
            "hashedData" to hashPassword(data),
            "secureToken" to generateSecureToken(16),
            "apiKey" to generateApiKey(),
            "signature" to signData(data, "default_key")
        )
    }
    
    /**
     * 检查密码强度
     * @param password 密码
     * @return 密码强度等级
     */
    fun checkPasswordStrength(password: String): String {
        var strength = 0
        if (password.length >= 8) strength++
        if (password.length >= 12) strength++
        if (password.any { it.isUpperCase() }) strength++
        if (password.any { it.isLowerCase() }) strength++
        if (password.any { it.isDigit() }) strength++
        if (password.any { !it.isLetterOrDigit() }) strength++
        
        return when {
            strength < 2 -> "弱"
            strength < 4 -> "中等"
            strength < 6 -> "强"
            else -> "非常强"
        }
    }
}

Kotlin 实现的核心特点

Kotlin 实现中的安全功能充分利用了 Kotlin 标准库的加密和随机数生成能力。XOR 加密使用了位运算操作。密码哈希使用了盐值和哈希算法的组合。

令牌生成使用了随机字符选择。校验和计算使用了简单的求和算法。数字签名使用了位运算和异或操作。

密码强度检查使用了多个条件的组合评估。所有安全操作都考虑了实际应用中的安全需求。

JavaScript 实现

编译后的 JavaScript 代码

// 文件: build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony.js
// (由 Kotlin 编译器自动生成)

/**
 * SecurityManager 类的 JavaScript 版本
 * 通过 Kotlin/JS 编译器从 Kotlin 源代码生成
 */
class SecurityManager {
  /**
   * XOR 加密
   * @param {string} data - 要加密的数据
   * @param {string} key - 加密密钥
   * @returns {string} 加密后的数据
   */
  encryptData(data, key) {
    let result = '';
    for (let i = 0; i < data.length; i++) {
      result += String.fromCharCode(data.charCodeAt(i) ^ key.charCodeAt(i % key.length));
    }
    return result;
  }

  /**
   * XOR 解密
   * @param {string} encryptedData - 加密的数据
   * @param {string} key - 解密密钥
   * @returns {string} 解密后的数据
   */
  decryptData(encryptedData, key) {
    return this.encryptData(encryptedData, key);
  }

  /**
   * 密码哈希
   * @param {string} password - 密码
   * @param {string} salt - 盐值
   * @returns {string} 哈希后的密码
   */
  hashPassword(password, salt = this.generateSalt()) {
    let hash = 0;
    const combined = password + salt;
    for (let i = 0; i < combined.length; i++) {
      hash = ((hash << 5) - hash) + combined.charCodeAt(i);
      hash = hash & hash;
    }
    return `${Math.abs(hash).toString(16).padStart(16, '0')}:${salt}`;
  }

  /**
   * 验证密码
   * @param {string} password - 输入的密码
   * @param {string} hashedPassword - 存储的哈希密码
   * @returns {boolean} 密码是否匹配
   */
  verifyPassword(password, hashedPassword) {
    const parts = hashedPassword.split(':');
    if (parts.length !== 2) return false;
    const salt = parts[1];
    return this.hashPassword(password, salt) === hashedPassword;
  }

  /**
   * 生成随机盐值
   * @param {number} length - 盐值长度
   * @returns {string} 随机盐值
   */
  generateSalt(length = 16) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
  }

  /**
   * 生成安全令牌
   * @param {number} length - 令牌长度
   * @returns {string} 安全令牌
   */
  generateSecureToken(length = 32) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
    let result = '';
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
  }

  /**
   * 计算数据的校验和
   * @param {string} data - 数据
   * @returns {string} 校验和
   */
  calculateChecksum(data) {
    let checksum = 0;
    for (let i = 0; i < data.length; i++) {
      checksum += data.charCodeAt(i);
    }
    return checksum.toString(16).padStart(16, '0');
  }

  /**
   * 验证数据完整性
   * @param {string} data - 数据
   * @param {string} checksum - 校验和
   * @returns {boolean} 数据是否完整
   */
  verifyIntegrity(data, checksum) {
    return this.calculateChecksum(data) === checksum;
  }

  /**
   * 生成数字签名
   * @param {string} data - 要签名的数据
   * @param {string} privateKey - 私钥
   * @returns {string} 签名
   */
  signData(data, privateKey) {
    let signature = 0;
    for (let i = 0; i < data.length; i++) {
      signature = ((signature << 5) | (signature >>> 27)) ^ data.charCodeAt(i);
    }
    for (let i = 0; i < privateKey.length; i++) {
      signature = signature ^ privateKey.charCodeAt(i);
    }
    return Math.abs(signature).toString(16).padStart(16, '0');
  }

  /**
   * 验证数字签名
   * @param {string} data - 原始数据
   * @param {string} signature - 签名
   * @param {string} publicKey - 公钥
   * @returns {boolean} 签名是否有效
   */
  verifySignature(data, signature, publicKey) {
    const expectedSignature = this.signData(data, publicKey);
    return signature === expectedSignature;
  }

  /**
   * 生成 API 密钥
   * @returns {string} API 密钥
   */
  generateApiKey() {
    return 'sk_' + this.generateSecureToken(32);
  }

  /**
   * 验证 API 密钥格式
   * @param {string} apiKey - API 密钥
   * @returns {boolean} 是否有效
   */
  isValidApiKey(apiKey) {
    return apiKey.startsWith('sk_') && apiKey.length === 35;
  }

  /**
   * 检查密码强度
   * @param {string} password - 密码
   * @returns {string} 密码强度等级
   */
  checkPasswordStrength(password) {
    let strength = 0;
    if (password.length >= 8) strength++;
    if (password.length >= 12) strength++;
    if (/[A-Z]/.test(password)) strength++;
    if (/[a-z]/.test(password)) strength++;
    if (/[0-9]/.test(password)) strength++;
    if (/[^a-zA-Z0-9]/.test(password)) strength++;

    if (strength < 2) return '弱';
    if (strength < 4) return '中等';
    if (strength < 6) return '强';
    return '非常强';
  }
}

JavaScript 实现的特点

JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的位运算和字符编码提供了必要的加密功能。

Math.random() 用于生成随机数。charCodeAt 和 String.fromCharCode 用于字符和数字之间的转换。正则表达式用于密码强度检查。

ArkTS 调用代码

OpenHarmony 应用集成

// 文件: kmp_ceshiapp/entry/src/main/ets/pages/SecurityManagerPage.ets

import { SecurityManager } from '../../../../../../../build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony';

@Entry
@Component
struct SecurityManagerPage {
  @State selectedOperation: string = 'encrypt';
  @State inputData: string = '';
  @State inputKey: string = '';
  @State result: string = '';
  @State resultTitle: string = '';

  private securityManager = new SecurityManager();

  private operations = [
    { name: '加密数据', value: 'encrypt' },
    { name: '解密数据', value: 'decrypt' },
    { name: '密码哈希', value: 'hash' },
    { name: '验证密码', value: 'verify' },
    { name: '生成令牌', value: 'token' },
    { name: '校验和', value: 'checksum' },
    { name: '数字签名', value: 'sign' },
    { name: '生成 API 密钥', value: 'apikey' },
    { name: '密码强度', value: 'strength' },
    { name: '安全摘要', value: 'summary' }
  ];

  build() {
    Column() {
      // 标题
      Text('🔐 数据加密和安全工具库')
        .fontSize(28)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .width('100%')
        .padding(20)
        .backgroundColor('#1A237E')
        .textAlign(TextAlign.Center)

      Scroll() {
        Column() {
          // 操作选择
          Column() {
            Text('选择操作')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .fontColor('#333333')
              .margin({ bottom: 12 })

            Flex({ wrap: FlexWrap.Wrap }) {
              ForEach(this.operations, (op: { name: string; value: string }) => {
                Button(op.name)
                  .layoutWeight(1)
                  .height(40)
                  .margin({ right: 8, bottom: 8 })
                  .backgroundColor(this.selectedOperation === op.value ? '#1A237E' : '#E0E0E0')
                  .fontColor(this.selectedOperation === op.value ? '#FFFFFF' : '#333333')
                  .fontSize(11)
                  .onClick(() => {
                    this.selectedOperation = op.value;
                    this.result = '';
                    this.resultTitle = '';
                  })
              })
            }
            .width('100%')
          }
          .width('95%')
          .margin({ top: 16, left: '2.5%', right: '2.5%', bottom: 16 })
          .padding(12)
          .backgroundColor('#FFFFFF')
          .borderRadius(6)

          // 输入区域
          Column() {
            Text('输入数据')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .fontColor('#333333')
              .margin({ bottom: 8 })

            TextInput({ placeholder: '输入要处理的数据', text: this.inputData })
              .onChange((value) => this.inputData = value)
              .width('100%')
              .height(80)
              .padding(12)
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
              .fontSize(12)
              .margin({ bottom: 12 })

            if (this.selectedOperation === 'encrypt' || this.selectedOperation === 'decrypt' ||
                this.selectedOperation === 'verify' || this.selectedOperation === 'sign') {
              TextInput({ placeholder: '输入密钥或盐值', text: this.inputKey })
                .onChange((value) => this.inputKey = value)
                .width('100%')
                .height(50)
                .padding(12)
                .border({ width: 1, color: '#4DB6AC' })
                .borderRadius(6)
                .fontSize(12)
            }
          }
          .width('95%')
          .margin({ left: '2.5%', right: '2.5%', bottom: 16 })
          .padding(12)
          .backgroundColor('#FFFFFF')
          .borderRadius(6)

          // 操作按钮
          Row() {
            Button('✨ 执行')
              .layoutWeight(1)
              .height(44)
              .backgroundColor('#1A237E')
              .fontColor('#FFFFFF')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .borderRadius(6)
              .onClick(() => this.executeOperation())

            Blank()
              .width(12)

            Button('🔄 清空')
              .layoutWeight(1)
              .height(44)
              .backgroundColor('#F5F5F5')
              .fontColor('#1A237E')
              .fontSize(14)
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
              .onClick(() => {
                this.inputData = '';
                this.inputKey = '';
                this.result = '';
                this.resultTitle = '';
              })
          }
          .width('95%')
          .margin({ left: '2.5%', right: '2.5%', bottom: 16 })

          // 结果显示
          if (this.resultTitle) {
            Column() {
              Text(this.resultTitle)
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .fontColor('#FFFFFF')
                .width('100%')
                .padding(12)
                .backgroundColor('#1A237E')
                .borderRadius(6)
                .textAlign(TextAlign.Center)
                .margin({ bottom: 12 })

              Scroll() {
                Text(this.result)
                  .fontSize(12)
                  .fontColor('#333333')
                  .fontFamily('monospace')
                  .textAlign(TextAlign.Start)
                  .width('100%')
                  .padding(12)
                  .selectable(true)
              }
              .width('100%')
              .height(300)
              .backgroundColor('#F9F9F9')
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
            }
            .width('95%')
            .margin({ left: '2.5%', right: '2.5%', bottom: 16 })
            .padding(12)
            .backgroundColor('#FFFFFF')
            .borderRadius(6)
          }
        }
        .width('100%')
      }
      .layoutWeight(1)
      .width('100%')
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }

  private executeOperation() {
    if (!this.inputData.trim()) {
      this.resultTitle = '❌ 错误';
      this.result = '请输入数据';
      return;
    }

    try {
      switch (this.selectedOperation) {
        case 'encrypt':
          const key = this.inputKey || 'default_key';
          const encrypted = this.securityManager.encryptData(this.inputData, key);
          this.resultTitle = '🔒 加密结果';
          this.result = `原文: ${this.inputData}\n密钥: ${key}\n密文: ${encrypted}`;
          break;

        case 'decrypt':
          const decKey = this.inputKey || 'default_key';
          const decrypted = this.securityManager.decryptData(this.inputData, decKey);
          this.resultTitle = '🔓 解密结果';
          this.result = `密文: ${this.inputData}\n密钥: ${decKey}\n明文: ${decrypted}`;
          break;

        case 'hash':
          const salt = this.inputKey || this.securityManager.generateSalt();
          const hashed = this.securityManager.hashPassword(this.inputData, salt);
          this.resultTitle = '🔐 密码哈希';
          this.result = `原密码: ${this.inputData}\n盐值: ${salt}\n哈希: ${hashed}`;
          break;

        case 'verify':
          const verifyResult = this.securityManager.verifyPassword(this.inputData, this.inputKey);
          this.resultTitle = verifyResult ? '✅ 密码匹配' : '❌ 密码不匹配';
          this.result = `密码: ${this.inputData}\n哈希: ${this.inputKey}\n结果: ${verifyResult ? '匹配' : '不匹配'}`;
          break;

        case 'token':
          const token = this.securityManager.generateSecureToken(32);
          this.resultTitle = '🎫 安全令牌';
          this.result = `生成的令牌: ${token}\n长度: 32 字符`;
          break;

        case 'checksum':
          const checksum = this.securityManager.calculateChecksum(this.inputData);
          this.resultTitle = '✓ 校验和';
          this.result = `数据: ${this.inputData}\n校验和: ${checksum}`;
          break;

        case 'sign':
          const privKey = this.inputKey || 'default_key';
          const signature = this.securityManager.signData(this.inputData, privKey);
          this.resultTitle = '✍️ 数字签名';
          this.result = `数据: ${this.inputData}\n私钥: ${privKey}\n签名: ${signature}`;
          break;

        case 'apikey':
          const apiKey = this.securityManager.generateApiKey();
          this.resultTitle = '🔑 API 密钥';
          this.result = `生成的 API 密钥: ${apiKey}\n有效性: ${this.securityManager.isValidApiKey(apiKey) ? '有效' : '无效'}`;
          break;

        case 'strength':
          const strength = this.securityManager.checkPasswordStrength(this.inputData);
          this.resultTitle = '💪 密码强度';
          this.result = `密码: ${this.inputData}\n强度等级: ${strength}`;
          break;

        case 'summary':
          const summary = this.securityManager.getSecuritySummary(this.inputData);
          this.resultTitle = '📊 安全摘要';
          this.result = `数据长度: ${summary.dataLength}\n校验和: ${summary.checksum}\n哈希: ${summary.hashedData}\n令牌: ${summary.secureToken}\nAPI密钥: ${summary.apiKey}`;
          break;
      }
    } catch (e) {
      this.resultTitle = '❌ 执行出错';
      this.result = `错误: ${e}`;
    }
  }
}

ArkTS 集成的关键要点

在 OpenHarmony 应用中集成安全工具库需要考虑多种安全操作和用户体验。我们设计了一个灵活的 UI，能够支持不同的加密和安全操作。

操作选择界面使用了 Flex 布局和 FlexWrap 来实现响应式的按钮排列。当用户选择不同的操作时，输入区域会动态显示相应的输入字段。

对于需要密钥或盐值的操作，我们提供了额外的输入框。结果显示使用了可选择的文本，这样用户可以轻松复制安全结果。

对于不同的操作，我们显示了相应的安全信息，如加密密钥、盐值、签名等。

工作流程详解

数据加密和安全的完整流程

1. 操作选择: 用户在 ArkTS UI 中选择要执行的安全操作
2. 数据输入: 用户输入要处理的数据
3. 参数输入: 根据选择的操作输入必要的参数
4. 处理执行: 调用 SecurityManager 的相应方法
5. 结果展示: 将处理结果显示在 UI 中

跨平台一致性

通过 KMP 技术，我们确保了在所有平台上的行为一致性。无论是在 Kotlin/JVM、Kotlin/JS 还是通过 ArkTS 调用，数据加密和安全的逻辑和结果都是完全相同的。

实际应用场景

用户认证系统

在用户认证系统中，需要安全地存储和验证密码。这个工具库提供了密码哈希和验证功能。

数据传输安全

在网络通信中，需要对敏感数据进行加密。这个工具库提供了数据加密和解密功能。

API 安全

在 API 开发中，需要生成和验证 API 密钥。这个工具库提供了 API 密钥生成和验证功能。

数据完整性验证

在数据存储和传输中，需要验证数据的完整性。这个工具库提供了校验和和数字签名功能。

性能优化

缓存加密结果

在频繁进行相同的加密操作时，可以缓存结果以避免重复计算。

批量处理

在处理大量数据时，应该考虑使用批量处理的方式以提高效率。

安全性考虑

使用强加密算法

在生产环境中，应该使用经过验证的强加密算法，而不是简化的实现。

密钥管理

在使用加密时，应该妥善管理密钥，避免密钥泄露。

定期审计

应该定期进行安全审计，确保应用的安全性始终处于最佳状态。

总结

这个 KMP OpenHarmony 数据加密和安全工具库展示了如何使用现代的跨平台技术来处理常见的数据安全任务。通过 Kotlin Multiplatform 技术，我们可以在一个地方编写业务逻辑，然后在多个平台上使用。

数据加密和安全是应用开发中的核心需求。通过使用这样的工具库，开发者可以快速、可靠地处理各种加密和安全操作，从而提高应用的安全性和用户信任度。

在实际应用中，建议根据具体的安全需求进行定制和扩展，例如使用更强的加密算法、实现更复杂的密钥管理等高级特性。同时，定期进行安全测试和审计，确保应用的安全防护始终有效。

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net