鸿蒙 Flutter 分布式安全：软总线加密通信与设备互信认证

本文介绍了在开源鸿蒙（HarmonyOS）与Flutter混合开发中实现分布式安全的完整方案。重点解析了鸿蒙分布式软总线的加密通信机制和设备互信认证流程，包括基于ECDH算法的密钥协商、AES-256-GCM数据加密等核心技术。通过Flutter的MethodChannel实现跨平台调用鸿蒙原生安全API，提供了从权限配置、证书管理到加密传输的完整代码示例。该方案适用于多设备协同场景下的安全数据共

50084

795人浏览 · 2025-12-09 18:26:58

50084 · 2025-12-09 18:26:58 发布

欢迎大家加入[开源鸿蒙跨平台开发者社区](https://openharmonycrossplatform.csdn.net)，

一起共建开源鸿蒙跨平台生态。

一、引言：分布式时代的安全挑战与技术选型

随着物联网（IoT）和分布式应用的普及，多设备协同成为鸿蒙（HarmonyOS）的核心优势之一。鸿蒙的分布式软总线作为设备间高速通信的基础，承担着数据传输、资源共享的关键职责，但同时也面临着数据泄露、身份伪造、中间人攻击等安全风险。而 Flutter 作为跨平台开发框架，被广泛用于鸿蒙应用的 UI 层开发，其与鸿蒙原生能力的融合，进一步对分布式安全提出了更高要求。

本文将聚焦鸿蒙分布式安全的两大核心场景：软总线加密通信与设备互信认证，结合 Flutter 混合开发实践，从技术原理、实现步骤、代码示例到最佳实践，全方位解析如何构建安全可靠的分布式应用。文章涉及鸿蒙原生安全 API、Flutter 跨平台调用、加密算法应用等关键技术，适合鸿蒙开发者、Flutter 开发者及对分布式安全感兴趣的技术人员。

核心技术栈

鸿蒙系统：HarmonyOS 4.0+（支持分布式软总线、安全框架）
开发语言：Dart（Flutter）、Java/JS（鸿蒙原生）
核心 API：鸿蒙软总线 API、鸿蒙安全框架（Crypto、KeyStore）、Flutter MethodChannel
加密算法：AES-256-GCM（数据加密）、ECDH（密钥协商）、RSA（签名 / 验签）、SHA-256（哈希）
工具链：DevEco Studio 4.0+、Flutter 3.10+

参考文档与工具

二、核心概念解析：鸿蒙分布式安全基础

在深入实现之前，需先明确鸿蒙分布式安全的核心概念，为后续开发奠定基础。

2.1 分布式软总线

鸿蒙分布式软总线是一套设备间无线通信协议栈，支持 Wi-Fi、蓝牙、NFC 等多种传输方式，无需手动配对即可实现设备间低延迟、高带宽的数据传输。其核心优势在于：

自动发现：设备靠近后自动扫描并建立连接
跨设备通信：支持多设备间点对点、点对多通信
协议适配：自动适配不同传输介质，保障通信稳定性

但软总线的默认通信未加密，因此需要上层应用自行实现数据加密和身份认证。

2.2 设备互信认证

设备互信认证是分布式安全的前提，确保通信双方是合法设备（而非伪造设备）。鸿蒙的设备互信基于以下机制：

设备指纹：每个鸿蒙设备拥有唯一的设备标识符（Device ID），由系统底层生成，不可篡改
数字证书：设备通过鸿蒙证书服务（Certificate Service）获取合法证书，用于身份验证
双向认证：通信双方互相验证对方的身份，避免中间人攻击

2.3 加密通信核心流程

分布式加密通信的核心流程可概括为：

设备发现与连接：通过软总线发现周边设备，建立基础通信通道
身份认证：双方交换设备证书，验证身份合法性
密钥协商：通过安全算法（如 ECDH）协商会话密钥
数据加密传输：使用会话密钥对传输数据进行加密（如 AES-GCM），并添加完整性校验
会话终止：通信结束后，销毁会话密钥，避免泄露

三、鸿蒙原生实现：软总线加密通信与设备认证

3.1 开发准备

3.1.1 权限配置

在鸿蒙应用的 config.json 中添加必要权限：

json

{
  "module": {
    "abilities": [
      {
        // ... 其他配置
        "permissions": [
          "ohos.permission.DISTRIBUTED_SOFTBUS", // 软总线通信权限
          "ohos.permission.DISTRIBUTED_DEVICE_MANAGER", // 分布式设备管理权限
          "ohos.permission.SECURITY_CERTIFICATE", // 证书访问权限
          "ohos.permission.KEYSTORE_ACCESS" // 密钥库访问权限
        ]
      }
    ],
    "distributedCapability": {
      "supportDistributed": true // 启用分布式能力
    }
  }
}

3.1.2 依赖引入

在 build.gradle 中添加鸿蒙安全框架依赖：

gradle

dependencies {
    // 软总线 API
    implementation 'ohos:distributedsoftbus:4.0.0.0'
    // 安全框架 API
    implementation 'ohos:security-crypto:4.0.0.0'
    implementation 'ohos:security-keystore:4.0.0.0'
    implementation 'ohos:security-certificate:4.0.0.0'
}

3.2 设备互信认证实现（Java 原生）

3.2.1 获取设备证书

鸿蒙设备可通过 CertificateManager 获取系统证书，用于身份认证：

java

运行

import ohos.security.certificate.CertificateManager;
import ohos.security.certificate.X509Certificate;
import java.security.KeyStore;
import java.security.cert.CertificateException;

public class DeviceCertManager {
    // 获取设备本地证书（X.509格式）
    public static X509Certificate getDeviceCertificate() throws CertificateException {
        CertificateManager certManager = CertificateManager.getInstance();
        // 获取设备身份证书（类型为 "DEVICE_IDENTITY"）
        KeyStore keyStore = certManager.getDeviceCertificate("DEVICE_IDENTITY");
        if (keyStore == null) {
            throw new CertificateException("获取设备证书失败");
        }
        // 从密钥库中获取证书（别名默认为 "device_cert"）
        return (X509Certificate) keyStore.getCertificate("device_cert");
    }

    // 验证对方设备证书的合法性
    public static boolean verifyPeerCertificate(X509Certificate peerCert) throws Exception {
        CertificateManager certManager = CertificateManager.getInstance();
        // 调用鸿蒙证书服务验证证书链（是否由可信CA签发）
        return certManager.verifyCertificateChain(new X509Certificate[]{peerCert});
    }
}

3.2.2 设备认证流程

通过软总线交换证书，完成双向认证：

java

运行

import ohos.distributedschedule.interwork.DeviceInfo;
import ohos.distributedschedule.interwork.DeviceManager;
import ohos.rpc.IRemoteObject;
import ohos.rpc.RemoteException;

public class DeviceAuthManager {
    // 发起设备认证
    public boolean authenticateDevice(DeviceInfo peerDevice) {
        try {
            // 1. 获取本地设备证书
            X509Certificate localCert = DeviceCertManager.getDeviceCertificate();
            // 2. 通过软总线向对方设备发送本地证书
            sendCertToPeer(peerDevice, localCert);
            // 3. 接收对方设备证书
            X509Certificate peerCert = receivePeerCert(peerDevice);
            // 4. 验证对方证书合法性
            if (!DeviceCertManager.verifyPeerCertificate(peerCert)) {
                return false;
            }
            // 5. 验证对方设备ID与证书绑定关系（防止证书伪造）
            String peerDeviceId = peerDevice.getDeviceId();
            String certDeviceId = extractDeviceIdFromCert(peerCert);
            return peerDeviceId.equals(certDeviceId);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 向对方设备发送证书（通过软总线 RPC 调用）
    private void sendCertToPeer(DeviceInfo peerDevice, X509Certificate cert) throws RemoteException {
        IRemoteObject remoteObject = DeviceManager.getRemoteObject(peerDevice.getDeviceId(), "ohos.distributed.security.auth");
        if (remoteObject == null) {
            throw new RemoteException("获取对方设备远程对象失败");
        }
        // 序列化证书并发送（实际开发中需使用 Protobuf 等高效序列化方式）
        byte[] certBytes = cert.getEncoded();
        // 调用对方设备的 RPC 方法接收证书
        RemoteAuthProxy proxy = new RemoteAuthProxy(remoteObject);
        proxy.onReceiveCert(certBytes);
    }

    // 接收对方设备证书
    private X509Certificate receivePeerCert(DeviceInfo peerDevice) throws CertificateException {
        // 监听对方设备发送的证书（通过软总线 RPC 回调）
        byte[] peerCertBytes = RemoteAuthStub.getReceivedCert(peerDevice.getDeviceId());
        return new X509Certificate(peerCertBytes);
    }

    // 从证书中提取设备ID（证书扩展字段中存储）
    private String extractDeviceIdFromCert(X509Certificate cert) {
        // 解析证书扩展字段（需与证书签发时的格式一致）
        byte[] extValue = cert.getExtensionValue("1.2.3.4.5.6.7.8.1"); // 自定义扩展OID
        return new String(extValue);
    }
}

// 远程认证 RPC 代理类
class RemoteAuthProxy implements IRemoteBroker {
    private final IRemoteObject remoteObject;

    public RemoteAuthProxy(IRemoteObject remoteObject) {
        this.remoteObject = remoteObject;
    }

    // 向对方设备发送证书
    public void onReceiveCert(byte[] certBytes) throws RemoteException {
        MessageParcel data = MessageParcel.obtain();
        MessageParcel reply = MessageParcel.obtain();
        MessageOption option = new MessageOption(MessageOption.TF_SYNC);
        data.writeByteArray(certBytes);
        remoteObject.sendRequest(1, data, reply, option);
        data.recycle();
        reply.recycle();
    }

    @Override
    public IRemoteObject asObject() {
        return remoteObject;
    }
}

// 远程认证 RPC 存根类（接收对方证书）
class RemoteAuthStub extends RemoteObject implements IRemoteBroker {
    private static final Map<String, byte[]> receivedCerts = new ConcurrentHashMap<>();

    public RemoteAuthStub() {
        super("ohos.distributed.security.auth");
    }

    @Override
    public boolean onRemoteRequest(int code, MessageParcel data, MessageParcel reply, MessageOption option) {
        if (code == 1) {
            // 接收对方设备证书
            byte[] certBytes = data.readByteArray();
            String deviceId = data.readString();
            receivedCerts.put(deviceId, certBytes);
            reply.writeBoolean(true);
            return true;
        }
        return false;
    }

    // 获取接收到的对方证书
    public static byte[] getReceivedCert(String deviceId) {
        return receivedCerts.get(deviceId);
    }

    @Override
    public IRemoteObject asObject() {
        return this;
    }
}

3.3 软总线加密通信实现

3.3.1 密钥协商（ECDH）

使用 ECDH 算法协商会话密钥，确保密钥不被传输，仅双方可见：

java

运行

import ohos.security.crypto.KeyGenerator;
import ohos.security.crypto.KeyMaterial;
import ohos.security.crypto.KeyPair;
import ohos.security.crypto.KeySpec;
import ohos.security.crypto.ECGenParameterSpec;
import ohos.security.crypto.CryptoException;
import java.security.KeyFactory;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.KeyAgreement;

public class KeyAgreementManager {
    // 生成 ECDH 密钥对（P-256 曲线）
    public static KeyPair generateECDHKeyPair() throws CryptoException {
        ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256r1"); // P-256 曲线
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KeyGenerator.ALGORITHM_EC);
        keyGenerator.initialize(ecSpec);
        return keyGenerator.generateKeyPair();
    }

    // 基于对方公钥协商会话密钥
    public static byte[] agreeSessionKey(KeyPair localKeyPair, byte[] peerPublicKeyBytes) throws Exception {
        // 解析对方公钥
        KeyFactory keyFactory = KeyFactory.getInstance("EC");
        X509EncodedKeySpec x509Spec = new X509EncodedKeySpec(peerPublicKeyBytes);
        java.security.PublicKey peerPublicKey = keyFactory.generatePublic(x509Spec);

        // 初始化密钥协商
        KeyAgreement keyAgreement = KeyAgreement.getInstance("ECDH");
        keyAgreement.init(localKeyPair.getPrivateKey());
        keyAgreement.doPhase(peerPublicKey, true);

        // 生成会话密钥（SHA-256 哈希后作为 AES-256 密钥）
        byte[] sharedSecret = keyAgreement.generateSecret();
        return CryptoUtils.sha256(sharedSecret); // 256 位密钥
    }
}

// 加密工具类
class CryptoUtils {
    // SHA-256 哈希
    public static byte[] sha256(byte[] data) throws CryptoException {
        ohos.security.crypto.MessageDigest digest = MessageDigest.getInstance(MessageDigest.ALGORITHM_SHA256);
        return digest.digest(data);
    }

    // AES-256-GCM 加密（带 IV 和认证标签）
    public static byte[] aesGcmEncrypt(byte[] key, byte[] data, byte[] iv) throws CryptoException {
        // GCM 模式需要 IV（12 字节推荐）和认证标签（16 字节）
        ohos.security.crypto.Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        KeySpec keySpec = new KeyMaterial(key);
        GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); // 128 位认证标签
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmSpec);
        return cipher.doFinal(data);
    }

    // AES-256-GCM 解密
    public static byte[] aesGcmDecrypt(byte[] key, byte[] encryptedData, byte[] iv) throws CryptoException {
        ohos.security.crypto.Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        KeySpec keySpec = new KeyMaterial(key);
        GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv);
        cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmSpec);
        return cipher.doFinal(encryptedData);
    }

    // 生成 12 字节 IV（GCM 模式推荐）
    public static byte[] generateIV() {
        byte[] iv = new byte[12];
        new SecureRandom().nextBytes(iv);
        return iv;
    }
}

3.3.2 软总线加密数据传输

基于软总线的 IDistributedSoftBus API 实现加密数据传输：

java

运行

import ohos.distributedsoftbus.DistributedSoftBus;
import ohos.distributedsoftbus.IDistributedSoftBusListener;
import ohos.distributedsoftbus.Message;
import ohos.distributedsoftbus.MessageHandler;
import ohos.distributedsoftbus.SoftBusException;

public class SecureSoftBusManager {
    private static final String CHANNEL_NAME = "distributed_secure_channel";
    private final DistributedSoftBus softBus;
    private byte[] sessionKey; // 协商后的会话密钥

    public SecureSoftBusManager() {
        softBus = DistributedSoftBus.getInstance();
        // 注册软总线监听器
        softBus.registerListener(new SecureSoftBusListener());
    }

    // 建立安全通信通道（先认证，再协商密钥）
    public boolean establishSecureChannel(DeviceInfo peerDevice) {
        // 1. 设备互信认证
        DeviceAuthManager authManager = new DeviceAuthManager();
        if (!authManager.authenticateDevice(peerDevice)) {
            return false;
        }

        try {
            // 2. 生成 ECDH 密钥对
            KeyPair localKeyPair = KeyAgreementManager.generateECDHKeyPair();
            // 3. 发送本地公钥给对方
            sendPublicKey(peerDevice, localKeyPair.getPublicKey().getEncoded());
            // 4. 接收对方公钥
            byte[] peerPublicKey = receivePeerPublicKey(peerDevice);
            // 5. 协商会话密钥
            sessionKey = KeyAgreementManager.agreeSessionKey(localKeyPair, peerPublicKey);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 发送加密数据
    public void sendEncryptedData(DeviceInfo peerDevice, String data) throws CryptoException, SoftBusException {
        if (sessionKey == null) {
            throw new IllegalStateException("会话密钥未协商");
        }

        // 生成 IV
        byte[] iv = CryptoUtils.generateIV();
        // 加密数据
        byte[] encryptedData = CryptoUtils.aesGcmEncrypt(sessionKey, data.getBytes(), iv);

        // 封装消息（IV + 加密数据，IV 需随数据一起发送）
        byte[] message = new byte[iv.length + encryptedData.length];
        System.arraycopy(iv, 0, message, 0, iv.length);
        System.arraycopy(encryptedData, 0, message, iv.length, encryptedData.length);

        // 通过软总线发送
        Message softBusMessage = Message.obtain();
        softBusMessage.setContent(message);
        softBus.sendMessage(peerDevice.getDeviceId(), CHANNEL_NAME, softBusMessage);
    }

    // 接收加密数据
    private String receiveEncryptedData(byte[] message) throws CryptoException {
        // 解析 IV（前 12 字节）和加密数据（剩余部分）
        byte[] iv = new byte[12];
        byte[] encryptedData = new byte[message.length - 12];
        System.arraycopy(message, 0, iv, 0, 12);
        System.arraycopy(message, 12, encryptedData, 0, encryptedData.length);

        // 解密数据
        byte[] decryptedData = CryptoUtils.aesGcmDecrypt(sessionKey, encryptedData, iv);
        return new String(decryptedData);
    }

    // 发送公钥给对方
    private void sendPublicKey(DeviceInfo peerDevice, byte[] publicKey) throws SoftBusException {
        Message message = Message.obtain();
        message.setContent(publicKey);
        softBus.sendMessage(peerDevice.getDeviceId(), CHANNEL_NAME + "_pubkey", message);
    }

    // 接收对方公钥
    private byte[] receivePeerPublicKey(DeviceInfo peerDevice) throws SoftBusException {
        // 实际开发中需通过监听器异步接收，此处简化为同步等待
        return softBus.waitForMessage(peerDevice.getDeviceId(), CHANNEL_NAME + "_pubkey", 5000);
    }

    // 软总线安全监听器
    private class SecureSoftBusListener implements IDistributedSoftBusListener {
        @Override
        public void onMessageReceived(String deviceId, String channelName, Message message) {
            try {
                if (CHANNEL_NAME.equals(channelName)) {
                    // 接收加密数据并解密
                    String decryptedData = receiveEncryptedData(message.getContent());
                    // 处理解密后的数据（如更新 UI、业务逻辑）
                    onDataReceived(deviceId, decryptedData);
                }
            } catch (CryptoException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onChannelOpened(String deviceId, String channelName) {
            // 通道打开回调
        }

        @Override
        public void onChannelClosed(String deviceId, String channelName) {
            // 通道关闭回调，销毁会话密钥
            sessionKey = null;
        }
    }

    // 数据接收回调（供上层应用处理）
    public void onDataReceived(String deviceId, String data) {
        // 实际开发中可通过接口回调给 Flutter
        System.out.println("收到设备 " + deviceId + " 的数据：" + data);
    }
}

四、Flutter 混合开发：调用鸿蒙安全能力

Flutter 作为跨平台框架，无法直接调用鸿蒙原生 API，需通过 MethodChannel 实现跨平台通信，将鸿蒙的设备认证、加密通信能力暴露给 Flutter 层。

4.1 Flutter 端配置

4.1.1 依赖添加

在 pubspec.yaml 中添加 flutter/services.dart（用于 MethodChannel）：

yaml

dependencies:
  flutter:
    sdk: flutter
  flutter/services.dart: ^2.10.0

4.1.2 MethodChannel 封装

创建 harmony_secure_softbus.dart，封装与鸿蒙原生的通信接口：

dart

import 'package:flutter/services.dart';

class HarmonySecureSoftBus {
  // 定义 MethodChannel 名称（需与鸿蒙原生一致）
  static const MethodChannel _channel = MethodChannel('com.example.distributed_security/softbus');

  // 单例模式
  static final HarmonySecureSoftBus instance = HarmonySecureSoftBus._();
  HarmonySecureSoftBus._();

  // 初始化安全软总线
  Future<bool> init() async {
    try {
      return await _channel.invokeMethod('init');
    } on PlatformException catch (e) {
      print('初始化失败：${e.message}');
      return false;
    }
  }

  // 发现周边设备
  Future<List<DeviceInfo>> discoverDevices() async {
    try {
      List<dynamic> deviceList = await _channel.invokeMethod('discoverDevices');
      return deviceList.map((device) => DeviceInfo.fromJson(device)).toList();
    } on PlatformException catch (e) {
      print('发现设备失败：${e.message}');
      return [];
    }
  }

  // 建立安全通信通道
  Future<bool> establishSecureChannel(String deviceId) async {
    try {
      return await _channel.invokeMethod('establishSecureChannel', {'deviceId': deviceId});
    } on PlatformException catch (e) {
      print('建立通道失败：${e.message}');
      return false;
    }
  }

  // 发送加密数据
  Future<bool> sendEncryptedData(String deviceId, String data) async {
    try {
      return await _channel.invokeMethod('sendEncryptedData', {
        'deviceId': deviceId,
        'data': data,
      });
    } on PlatformException catch (e) {
      print('发送数据失败：${e.message}');
      return false;
    }
  }

  // 注册数据接收回调
  void registerDataReceivedCallback(Function(String deviceId, String data) callback) {
    _channel.setMethodCallHandler((call) async {
      if (call.method == 'onDataReceived') {
        String deviceId = call.arguments['deviceId'];
        String data = call.arguments['data'];
        callback(deviceId, data);
      }
      return null;
    });
  }
}

// 设备信息模型
class DeviceInfo {
  final String deviceId; // 设备ID
  final String deviceName; // 设备名称
  final String deviceType; // 设备类型（如手机、平板、手表）

  DeviceInfo({
    required this.deviceId,
    required this.deviceName,
    required this.deviceType,
  });

  // 从 JSON 解析
  factory DeviceInfo.fromJson(Map<String, dynamic> json) {
    return DeviceInfo(
      deviceId: json['deviceId'],
      deviceName: json['deviceName'],
      deviceType: json['deviceType'],
    );
  }

  // 转换为 JSON
  Map<String, dynamic> toJson() {
    return {
      'deviceId': deviceId,
      'deviceName': deviceName,
      'deviceType': deviceType,
    };
  }
}

4.2 鸿蒙原生 MethodChannel 实现

在鸿蒙应用的 MainAbilitySlice 中注册 MethodChannel，处理 Flutter 调用：

java

运行

import ohos.ace.ability.AceAbilitySlice;
import ohos.ace.ability.AceAbility;
import ohos.ace.runtime.MethodChannel;
import ohos.ace.runtime.PlatformPlugin;
import ohos.distributedschedule.interwork.DeviceInfo;
import ohos.distributedschedule.interwork.DeviceManager;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MainAbility extends AceAbility {
    private SecureSoftBusManager secureSoftBusManager;
    private MethodChannel methodChannel;

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        // 初始化安全软总线
        secureSoftBusManager = new SecureSoftBusManager();
        // 注册 MethodChannel
        registerMethodChannel();
    }

    private void registerMethodChannel() {
        methodChannel = new MethodChannel(this, "com.example.distributed_security/softbus");
        methodChannel.setMethodCallHandler((method, arguments, result) -> {
            switch (method) {
                case "init":
                    handleInit(result);
                    break;
                case "discoverDevices":
                    handleDiscoverDevices(result);
                    break;
                case "establishSecureChannel":
                    handleEstablishSecureChannel(arguments, result);
                    break;
                case "sendEncryptedData":
                    handleSendEncryptedData(arguments, result);
                    break;
                default:
                    result.error("METHOD_NOT_FOUND", "方法未找到", null);
                    break;
            }
        });

        // 注册数据接收回调（转发给 Flutter）
        secureSoftBusManager.onDataReceived((deviceId, data) -> {
            Map<String, Object> args = new HashMap<>();
            args.put("deviceId", deviceId);
            args.put("data", data);
            methodChannel.invokeMethod("onDataReceived", args, null);
        });
    }

    // 处理初始化
    private void handleInit(MethodChannel.Result result) {
        result.success(true);
    }

    // 处理设备发现
    private void handleDiscoverDevices(MethodChannel.Result result) {
        List<DeviceInfo> deviceList = DeviceManager.getDeviceList(DeviceInfo.FLAG_GET_ONLINE_DEVICE);
        List<Map<String, String>> deviceMapList = new ArrayList<>();
        for (DeviceInfo device : deviceList) {
            Map<String, String> deviceMap = new HashMap<>();
            deviceMap.put("deviceId", device.getDeviceId());
            deviceMap.put("deviceName", device.getDeviceName());
            deviceMap.put("deviceType", getDeviceType(device.getDeviceType()));
            deviceMapList.add(deviceMap);
        }
        result.success(deviceMapList);
    }

    // 处理建立安全通道
    private void handleEstablishSecureChannel(Map<String, Object> arguments, MethodChannel.Result result) {
        String deviceId = (String) arguments.get("deviceId");
        DeviceInfo peerDevice = getDeviceInfoById(deviceId);
        if (peerDevice == null) {
            result.error("DEVICE_NOT_FOUND", "设备未找到", null);
            return;
        }
        boolean success = secureSoftBusManager.establishSecureChannel(peerDevice);
        result.success(success);
    }

    // 处理发送加密数据
    private void handleSendEncryptedData(Map<String, Object> arguments, MethodChannel.Result result) {
        String deviceId = (String) arguments.get("deviceId");
        String data = (String) arguments.get("data");
        DeviceInfo peerDevice = getDeviceInfoById(deviceId);
        if (peerDevice == null) {
            result.error("DEVICE_NOT_FOUND", "设备未找到", null);
            return;
        }
        try {
            secureSoftBusManager.sendEncryptedData(peerDevice, data);
            result.success(true);
        } catch (Exception e) {
            result.error("SEND_FAILED", e.getMessage(), null);
        }
    }

    // 根据设备ID获取设备信息
    private DeviceInfo getDeviceInfoById(String deviceId) {
        List<DeviceInfo> deviceList = DeviceManager.getDeviceList(DeviceInfo.FLAG_GET_ONLINE_DEVICE);
        for (DeviceInfo device : deviceList) {
            if (device.getDeviceId().equals(deviceId)) {
                return device;
            }
        }
        return null;
    }

    // 设备类型转换（鸿蒙设备类型枚举转字符串）
    private String getDeviceType(int deviceType) {
        switch (deviceType) {
            case DeviceInfo.DEVICE_TYPE_PHONE:
                return "手机";
            case DeviceInfo.DEVICE_TYPE_TABLET:
                return "平板";
            case DeviceInfo.DEVICE_TYPE_WATCH:
                return "手表";
            default:
                return "其他";
        }
    }
}

4.3 Flutter 端 UI 与业务逻辑示例

创建 main.dart，实现设备发现、安全连接、加密数据发送的 UI 界面：

dart

import 'package:flutter/material.dart';
import 'package:harmony_secure_softbus/harmony_secure_softbus.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: '鸿蒙 Flutter 分布式安全',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const SecureDistributedPage(),
    );
  }
}

class SecureDistributedPage extends StatefulWidget {
  const SecureDistributedPage({super.key});

  @override
  State<SecureDistributedPage> createState() => _SecureDistributedPageState();
}

class _SecureDistributedPageState extends State<SecureDistributedPage> {
  final HarmonySecureSoftBus _secureSoftBus = HarmonySecureSoftBus.instance;
  List<DeviceInfo> _deviceList = [];
  String? _selectedDeviceId;
  final TextEditingController _messageController = TextEditingController();
  final List<String> _messageLog = [];

  @override
  void initState() {
    super.initState();
    // 初始化并注册数据接收回调
    _initSecureSoftBus();
  }

  // 初始化安全软总线
  Future<void> _initSecureSoftBus() async {
    bool isInitSuccess = await _secureSoftBus.init();
    if (isInitSuccess) {
      _addMessageLog("安全软总线初始化成功");
      // 注册数据接收回调
      _secureSoftBus.registerDataReceivedCallback((deviceId, data) {
        _addMessageLog("收到设备 $deviceId 的消息：$data");
      });
    } else {
      _addMessageLog("安全软总线初始化失败");
    }
  }

  // 发现设备
  Future<void> _discoverDevices() async {
    _addMessageLog("开始搜索周边设备...");
    List<DeviceInfo> devices = await _secureSoftBus.discoverDevices();
    setState(() {
      _deviceList = devices;
    });
    if (devices.isEmpty) {
      _addMessageLog("未发现任何在线设备");
    } else {
      _addMessageLog("发现 ${devices.length} 台设备");
    }
  }

  // 建立安全连接
  Future<void> _establishConnection(String deviceId) async {
    _addMessageLog("正在与设备 $deviceId 建立安全连接...");
    bool isSuccess = await _secureSoftBus.establishSecureChannel(deviceId);
    if (isSuccess) {
      setState(() {
        _selectedDeviceId = deviceId;
      });
      _addMessageLog("安全连接建立成功");
    } else {
      _addMessageLog("安全连接建立失败");
    }
  }

  // 发送加密消息
  Future<void> _sendMessage() async {
    String message = _messageController.text.trim();
    if (message.isEmpty) {
      _addMessageLog("消息不能为空");
      return;
    }
    if (_selectedDeviceId == null) {
      _addMessageLog("请先选择并连接设备");
      return;
    }

    _addMessageLog("发送加密消息：$message");
    bool isSuccess = await _secureSoftBus.sendEncryptedData(_selectedDeviceId!, message);
    if (isSuccess) {
      _addMessageLog("消息发送成功");
      _messageController.clear();
    } else {
      _addMessageLog("消息发送失败");
    }
  }

  // 添加消息日志
  void _addMessageLog(String log) {
    setState(() {
      _messageLog.add("[${DateTime.now().toString().substring(11, 19)}] $log");
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('分布式安全通信')),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            // 设备列表
            ElevatedButton(
              onPressed: _discoverDevices,
              child: const Text('搜索周边设备'),
            ),
            const SizedBox(height: 16),
            Expanded(
              flex: 1,
              child: _deviceList.isEmpty
                  ? const Center(child: Text('暂无设备'))
                  : ListView.builder(
                      itemCount: _deviceList.length,
                      itemBuilder: (context, index) {
                        DeviceInfo device = _deviceList[index];
                        bool isSelected = device.deviceId == _selectedDeviceId;
                        return ListTile(
                          title: Text(device.deviceName),
                          subtitle: Text("ID: ${device.deviceId} | 类型: ${device.deviceType}"),
                          trailing: isSelected ? const Icon(Icons.check, color: Colors.green) : null,
                          onTap: () => _establishConnection(device.deviceId),
                        );
                      },
                    ),
            ),
            const SizedBox(height: 16),
            // 消息输入与发送
            Row(
              children: [
                Expanded(
                  child: TextField(
                    controller: _messageController,
                    decoration: const InputDecoration(
                      hintText: '输入要发送的消息',
                      border: OutlineInputBorder(),
                    ),
                  ),
                ),
                const SizedBox(width: 8),
                ElevatedButton(
                  onPressed: _sendMessage,
                  child: const Text('发送'),
                ),
              ],
            ),
            const SizedBox(height: 16),
            // 消息日志
            const Text('通信日志：'),
            Expanded(
              flex: 2,
              child: Container(
                padding: const EdgeInsets.all(8.0),
                decoration: BoxDecoration(
                  border: Border.all(color: Colors.grey),
                  borderRadius: BorderRadius.circular(8.0),
                ),
                child: ListView.builder(
                  itemCount: _messageLog.length,
                  itemBuilder: (context, index) {
                    return Text(_messageLog[index]);
                  },
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}