项目概述

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

本文介绍一个基于 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/DataEncryption.kt

class DataEncryption {
    
    data class EncryptionKey(
        val keyId: String,
        val keyValue: String,
        val algorithm: String,
        val createdTime: Long,
        val isActive: Boolean
    )
    
    data class EncryptionResult(
        val encryptedData: String,
        val keyId: String,
        val algorithm: String,
        val encryptionTime: Long,
        val success: Boolean
    )
    
    data class EncryptionConfig(
        val enableKeyRotation: Boolean = true,
        val enableAudit: Boolean = true,
        val keyExpirationDays: Int = 90
    )
    
    private var config = EncryptionConfig()
    private val keyStore = mutableMapOf<String, EncryptionKey>()
    private val encryptionHistory = mutableListOf<EncryptionResult>()
    
    fun setConfig(config: EncryptionConfig) {
        this.config = config
    }
    
    fun generateKey(algorithm: String): EncryptionKey {
        val keyId = generateKeyId()
        val keyValue = generateKeyValue()
        
        val key = EncryptionKey(
            keyId,
            keyValue,
            algorithm,
            System.currentTimeMillis(),
            true
        )
        
        keyStore[keyId] = key
        return key
    }
    
    fun encrypt(data: String, keyId: String): EncryptionResult {
        val startTime = System.currentTimeMillis()
        val key = keyStore[keyId]
        
        if (key == null) {
            return EncryptionResult("", keyId, "", 0, false)
        }
        
        val encryptedData = performEncryption(data, key.keyValue)
        val encryptionTime = System.currentTimeMillis() - startTime
        
        val result = EncryptionResult(
            encryptedData,
            keyId,
            key.algorithm,
            encryptionTime,
            true
        )
        
        encryptionHistory.add(result)
        return result
    }
    
    fun decrypt(encryptedData: String, keyId: String): String {
        val key = keyStore[keyId] ?: return ""
        return performDecryption(encryptedData, key.keyValue)
    }
    
    fun hashData(data: String): String {
        return data.hashCode().toString()
    }
    
    fun verifyEncryption(data: String, encryptedData: String, keyId: String): Boolean {
        val decrypted = decrypt(encryptedData, keyId)
        return decrypted == data
    }
    
    fun getEncryptionStatistics(): Map<String, Any> {
        val totalEncryptions = encryptionHistory.size
        val successfulEncryptions = encryptionHistory.count { it.success }
        val averageTime = if (encryptionHistory.isNotEmpty()) {
            encryptionHistory.map { it.encryptionTime }.average()
        } else {
            0.0
        }
        
        return mapOf(
            "totalEncryptions" to totalEncryptions,
            "successfulEncryptions" to successfulEncryptions,
            "averageTime" to String.format("%.2f", averageTime),
            "totalKeys" to keyStore.size
        )
    }
    
    fun generateEncryptionReport(): String {
        val stats = getEncryptionStatistics()
        val report = StringBuilder()
        report.append("数据加密报告\n")
        report.append("=".repeat(40)).append("\n")
        report.append("加密总数: ${stats["totalEncryptions"]}\n")
        report.append("成功加密: ${stats["successfulEncryptions"]}\n")
        report.append("平均耗时: ${stats["averageTime"]}ms\n")
        report.append("密钥总数: ${stats["totalKeys"]}\n")
        
        return report.toString()
    }
    
    private fun performEncryption(data: String, key: String): String {
        return "ENCRYPTED_${data.reversed()}_${key.take(5)}"
    }
    
    private fun performDecryption(encryptedData: String, key: String): String {
        return if (encryptedData.startsWith("ENCRYPTED_")) {
            encryptedData.removePrefix("ENCRYPTED_").substringBefore("_").reversed()
        } else {
            encryptedData
        }
    }
    
    private fun generateKeyId(): String {
        return "KEY_${System.currentTimeMillis()}_${(0..999).random()}"
    }
    
    private fun generateKeyValue(): String {
        return (0..31).map { (0..255).random().toChar() }.joinToString("")
    }
}

Kotlin 实现的核心特点

Kotlin 实现中的加密功能充分利用了 Kotlin 标准库的字符串处理能力。对称加密使用了自定义加密算法。哈希加密使用了哈希函数。

密钥管理使用了 Map 数据结构。加密验证使用了数据比较。统计信息使用了集合操作。

JavaScript 实现

编译后的 JavaScript 代码

// 文件: build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony.js

class DataEncryption {
  constructor() {
    this.config = {
      enableKeyRotation: true,
      enableAudit: true,
      keyExpirationDays: 90
    };
    this.keyStore = {};
    this.encryptionHistory = [];
  }

  setConfig(config) {
    this.config = { ...this.config, ...config };
  }

  generateKey(algorithm) {
    const keyId = this.generateKeyId();
    const keyValue = this.generateKeyValue();
    
    const key = {
      keyId: keyId,
      keyValue: keyValue,
      algorithm: algorithm,
      createdTime: Date.now(),
      isActive: true
    };
    
    this.keyStore[keyId] = key;
    return key;
  }

  encrypt(data, keyId) {
    const startTime = Date.now();
    const key = this.keyStore[keyId];
    
    if (!key) {
      return {
        encryptedData: '',
        keyId: keyId,
        algorithm: '',
        encryptionTime: 0,
        success: false
      };
    }
    
    const encryptedData = this.performEncryption(data, key.keyValue);
    const encryptionTime = Date.now() - startTime;
    
    const result = {
      encryptedData: encryptedData,
      keyId: keyId,
      algorithm: key.algorithm,
      encryptionTime: encryptionTime,
      success: true
    };
    
    this.encryptionHistory.push(result);
    return result;
  }

  decrypt(encryptedData, keyId) {
    const key = this.keyStore[keyId];
    if (!key) return '';
    return this.performDecryption(encryptedData, key.keyValue);
  }

  getEncryptionStatistics() {
    const totalEncryptions = this.encryptionHistory.length;
    const successfulEncryptions = this.encryptionHistory.filter(e => e.success).length;
    const averageTime = totalEncryptions > 0
      ? this.encryptionHistory.reduce((sum, e) => sum + e.encryptionTime, 0) / totalEncryptions
      : 0;
    
    return {
      totalEncryptions: totalEncryptions,
      successfulEncryptions: successfulEncryptions,
      averageTime: averageTime.toFixed(2),
      totalKeys: Object.keys(this.keyStore).length
    };
  }

  performEncryption(data, key) {
    return `ENCRYPTED_${data.split('').reverse().join('')}_${key.substring(0, 5)}`;
  }

  performDecryption(encryptedData, key) {
    if (encryptedData.startsWith('ENCRYPTED_')) {
      const parts = encryptedData.substring(10).split('_');
      return parts[0].split('').reverse().join('');
    }
    return encryptedData;
  }

  generateKeyId() {
    return `KEY_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
  }

  generateKeyValue() {
    let result = '';
    for (let i = 0; i < 32; i++) {
      result += String.fromCharCode(Math.floor(Math.random() * 256));
    }
    return result;
  }
}

JavaScript 实现的特点

JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的字符串方法提供了加密能力。

split/reverse/join 用于数据反转。substring 用于字符串提取。reduce 用于统计。

ArkTS 调用代码

OpenHarmony 应用集成

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

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

@Entry
@Component
struct DataEncryptionPage {
  @State selectedOperation: string = 'generate';
  @State inputData: string = '';
  @State result: string = '';
  @State resultTitle: string = '';
  @State keyCount: number = 0;

  private dataEncryption = new DataEncryption();
  private currentKeyId: string = '';

  private operations = [
    { name: '🔑 生成密钥', value: 'generate' },
    { name: '🔒 加密数据', value: 'encrypt' },
    { name: '🔓 解密数据', value: 'decrypt' },
    { name: '✅ 验证加密', value: 'verify' },
    { name: '🔐 哈希数据', value: 'hash' },
    { name: '📊 统计', value: 'stats' },
    { name: '📄 报告', value: 'report' },
    { name: '🔄 演示', value: 'demo' }
  ];

  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)
          }
          .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.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() {
    const data = this.inputData || '敏感数据信息';

    try {
      switch (this.selectedOperation) {
        case 'generate':
          const key = this.dataEncryption.generateKey('AES-256');
          this.currentKeyId = key.keyId;
          this.keyCount++;
          this.resultTitle = '🔑 生成密钥';
          this.result = `密钥ID: ${key.keyId}\n算法: ${key.algorithm}\n创建时间: ${key.createdTime}\n激活状态: ${key.isActive}\n总密钥数: ${this.keyCount}`;
          break;

        case 'encrypt':
          if (!this.currentKeyId) {
            this.resultTitle = '❌ 错误';
            this.result = '请先生成密钥';
            return;
          }
          const encResult = this.dataEncryption.encrypt(data, this.currentKeyId);
          this.resultTitle = '🔒 加密数据';
          this.result = `原始数据: ${data}\n加密数据: ${encResult.encryptedData}\n密钥ID: ${encResult.keyId}\n耗时: ${encResult.encryptionTime}ms`;
          break;

        case 'decrypt':
          if (!this.currentKeyId) {
            this.resultTitle = '❌ 错误';
            this.result = '请先生成密钥';
            return;
          }
          const encData = this.dataEncryption.encrypt(data, this.currentKeyId).encryptedData;
          const decData = this.dataEncryption.decrypt(encData, this.currentKeyId);
          this.resultTitle = '🔓 解密数据';
          this.result = `加密数据: ${encData}\n解密数据: ${decData}\n解密成功: ${decData === data}`;
          break;

        case 'verify':
          if (!this.currentKeyId) {
            this.resultTitle = '❌ 错误';
            this.result = '请先生成密钥';
            return;
          }
          const verifyResult = this.dataEncryption.encrypt(data, this.currentKeyId);
          const isValid = this.dataEncryption.verifyEncryption(data, verifyResult.encryptedData, this.currentKeyId);
          this.resultTitle = '✅ 验证加密';
          this.result = `原始数据: ${data}\n验证结果: ${isValid ? '有效' : '无效'}\n数据完整性: ${isValid ? '完整' : '损坏'}`;
          break;

        case 'hash':
          const hash = this.dataEncryption.hashData(data);
          this.resultTitle = '🔐 哈希数据';
          this.result = `原始数据: ${data}\n哈希值: ${hash}`;
          break;

        case 'stats':
          const stats = this.dataEncryption.getEncryptionStatistics();
          this.resultTitle = '📊 加密统计';
          this.result = `加密总数: ${stats.totalEncryptions}\n成功加密: ${stats.successfulEncryptions}\n平均耗时: ${stats.averageTime}ms\n密钥总数: ${stats.totalKeys}`;
          break;

        case 'report':
          const report = this.dataEncryption.generateEncryptionReport();
          this.resultTitle = '📄 加密报告';
          this.result = report;
          break;

        case 'demo':
          const demoKey = this.dataEncryption.generateKey('AES-256');
          const demoEnc = this.dataEncryption.encrypt('演示数据', demoKey.keyId);
          this.resultTitle = '🔄 演示数据';
          this.result = `演示密钥ID: ${demoKey.keyId}\n演示加密: ${demoEnc.encryptedData}\n演示成功: ${demoEnc.success}`;
          break;
      }
    } catch (e) {
      this.resultTitle = '❌ 操作出错';
      this.result = `错误: ${e}`;
    }
  }
}

ArkTS 集成的关键要点

在 OpenHarmony 应用中集成加密工具库需要考虑数据安全和用户体验。我们设计了一个完整的加密 UI，包括操作选择、数据输入和结果展示。

操作选择界面使用了 Flex 布局和 FlexWrap 来实现响应式的按钮排列。数据输入使用了 TextInput 组件。

结果显示使用了可选择的文本，这样用户可以轻松复制加密结果。对于不同的加密操作，我们显示了相应的加密处理结果。

工作流程详解

数据加密的完整流程

1. 操作选择: 用户在 ArkTS UI 中选择要执行的加密操作
2. 数据输入: 用户输入要加密的数据
3. 处理执行: 调用 DataEncryption 的相应方法
4. 结果展示: 将加密结果显示在 UI 中

跨平台一致性

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

实际应用场景

用户隐私保护

在保护用户隐私时，需要进行数据加密。这个工具库提供了完整的隐私保护加密功能。

数据安全传输

在进行数据传输时，需要进行加密。这个工具库提供了安全传输加密能力。

敏感信息存储

在存储敏感信息时，需要进行加密。这个工具库提供了敏感信息加密功能。

合规性要求

在满足合规性要求时，需要进行加密。这个工具库提供了合规性加密能力。

性能优化

密钥缓存

在频繁使用相同密钥时，应该缓存密钥以提高性能。

加密优化

在处理大量数据时，应该使用高效的加密算法以提高性能。

安全性考虑

密钥管理

在管理加密密钥时，应该进行安全存储和访问控制。

加密验证

在加密完成后，应该进行验证以确保加密的正确性。

总结

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

数据加密是应用开发中的重要功能。通过使用这样的工具库，开发者可以快速、可靠地实现各种加密操作，从而提高应用的数据安全性。

在实际应用中，建议根据具体的需求进行定制和扩展，例如添加更多的加密算法、实现更复杂的密钥管理等高级特性。同时，定期进行安全审计和更新，确保应用的加密系统保持安全运行。