wip.

Author: cloudwebrtc

lib/src/core/engine.dart

@@ -21,6 +21,7 @@ import 'package:flutter/foundation.dart' hide internal;
 import 'package:collection/collection.dart';
 import 'package:connectivity_plus/connectivity_plus.dart';
 import 'package:flutter_webrtc/flutter_webrtc.dart' as rtc;
+import 'package:livekit_client/livekit_client.dart';
 import 'package:meta/meta.dart';
 
 import '../events.dart';
@@ -149,6 +150,8 @@ class Engine extends Disposable with EventsEmittable<EngineEvent> {
 
   List<lk_models.Codec>? get enabledPublishCodecs => _enabledPublishCodecs;
 
+  E2EEManager? _e2eeManager;
+
   void clearReconnectTimeout() {
     if (reconnectTimeout != null) {
       reconnectTimeout?.cancel();
@@ -313,6 +316,7 @@ class Engine extends Disposable with EventsEmittable<EngineEvent> {
           completer.completeError('Engine disconnected');
         }
       }
+
       events.once<EngineClosingEvent>((e) => onClosing());
 
       while (!_dcBufferStatus[kind]!) {
@@ -333,8 +337,7 @@ class Engine extends Disposable with EventsEmittable<EngineEvent> {
     bool? reliability = true,
   }) async {
     // construct the data channel message
-    final message =
-        rtc.RTCDataChannelMessage.fromBinary(packet.writeToBuffer());
+    var message = rtc.RTCDataChannelMessage.fromBinary(packet.writeToBuffer());
 
     final reliabilityType =
         reliability == true ? Reliability.reliable : Reliability.lossy;
@@ -364,6 +367,28 @@ class Engine extends Disposable with EventsEmittable<EngineEvent> {
           'Data channel for ${packet.kind.toSDKType()} is null');
     }
 
+    if (_e2eeManager != null && _e2eeManager!.isDataChannelEncryptionEnabled) {
+      final encryptablePacket = asEncryptablePacket(packet);
+      if (encryptablePacket != null) {
+        final encryptedData = await _e2eeManager?.encryptData(
+            data: encryptablePacket.writeToBuffer());
+
+        if (encryptedData == null) {
+          logger.warning('Failed to encrypt data packet');
+          return;
+        }
+
+        final packet = lk_models.EncryptedPacket(
+          encryptionType: lk_models.Encryption_Type.GCM,
+          encryptedValue: encryptedData.data,
+          iv: encryptedData.iv,
+          keyIndex: encryptedData.keyIndex,
+        );
+
+        message = rtc.RTCDataChannelMessage.fromBinary(packet.writeToBuffer());
+      }
+    }
+
     logger.fine('sendDataPacket(label:${channel.label})');
     await channel.send(message);
 
@@ -390,6 +415,22 @@ class Engine extends Disposable with EventsEmittable<EngineEvent> {
     }
   }
 
+  lk_models.EncryptedPacketPayload? asEncryptablePacket(
+      lk_models.DataPacket packet) {
+    if ([
+          lk_models.DataPacket_Value.sipDtmf,
+          lk_models.DataPacket_Value.metrics,
+          lk_models.DataPacket_Value.speaker,
+          lk_models.DataPacket_Value.transcription,
+          lk_models.DataPacket_Value.encryptedPacket
+        ].contains(packet.whichValue()) ==
+        false) {
+      return lk_models.EncryptedPacketPayload.fromBuffer(
+          packet.writeToBuffer());
+    }
+    return null;
+  }
+
   Future<RTCConfiguration> _buildRtcConfiguration(
       {required lk_models.ClientConfigSetting serverResponseForceRelay,
       required List<RTCIceServer> serverProvidedIceServers}) async {
@@ -636,7 +677,7 @@ class Engine extends Disposable with EventsEmittable<EngineEvent> {
     }
   }
 
-  void _onDCMessage(rtc.RTCDataChannelMessage message) {
+  void _onDCMessage(rtc.RTCDataChannelMessage message) async {
     // always expect binary
     if (!message.isBinary) {
       logger.warning('Data message is not binary');
@@ -711,6 +752,28 @@ class Engine extends Disposable with EventsEmittable<EngineEvent> {
           identity: dp.participantIdentity,
         ),
       );
+    } else if (dp.whichValue() == lk_models.DataPacket_Value.encryptedPacket) {
+      if (_e2eeManager != null) {
+        logger.warning('Received encrypted packet but E2EE not set up');
+        return;
+      }
+      final decryptedData = await _e2eeManager?.handleEncryptedData(
+        data: Uint8List.fromList(dp.encryptedPacket.encryptedValue),
+        iv: Uint8List.fromList(dp.encryptedPacket.iv),
+        participantIdentity: dp.participantIdentity,
+        keyIndex: dp.encryptedPacket.keyIndex,
+      );
+      if (decryptedData == null) {
+        logger.warning('Failed to decrypt data packet');
+        return;
+      }
+      final newDp = lk_models.DataPacket.fromBuffer(decryptedData);
+      // User packet
+      events.emit(EngineDataPacketReceivedEvent(
+        packet: newDp.user,
+        kind: newDp.kind,
+        identity: newDp.participantIdentity,
+      ));
     } else {
       logger.warning('Unknown data packet type: ${dp.whichValue()}');
     }

lib/src/e2ee/e2ee_manager.dart

@@ -31,6 +31,7 @@ class E2EEManager {
   final Map<Map<String, String>, FrameCryptor> _frameCryptors = {};
   final BaseKeyProvider _keyProvider;
   final Algorithm _algorithm = Algorithm.kAesGcm;
+  DataPacketCryptor? _dataPacketCryptor;
   bool _enabled = true;
   EventsListener<RoomEvent>? _listener;
   E2EEManager(this._keyProvider);
@@ -117,6 +118,10 @@ class E2EEManager {
             }
           }
         });
+
+      _dataPacketCryptor ??=
+          await dataPacketCryptorFactory.createDataPacketCryptor(
+              algorithm: _algorithm, keyProvider: _keyProvider.keyProvider);
     }
   }
 
@@ -144,17 +149,21 @@ class E2EEManager {
       await frameCryptor.dispose();
     }
     _frameCryptors.clear();
+
+    await _dataPacketCryptor?.dispose();
+    _dataPacketCryptor = null;
   }
 
   Future<FrameCryptor> _addRtpSender(
       {required RTCRtpSender sender,
       required String identity,
       required String sid}) async {
-    final frameCryptor = await frameCryptorFactory.createFrameCryptorForRtpSender(
-        participantId: identity,
-        sender: sender,
-        algorithm: _algorithm,
-        keyProvider: _keyProvider.keyProvider);
+    final frameCryptor =
+        await frameCryptorFactory.createFrameCryptorForRtpSender(
+            participantId: identity,
+            sender: sender,
+            algorithm: _algorithm,
+            keyProvider: _keyProvider.keyProvider);
     _frameCryptors[{identity: sid}] = frameCryptor;
     await frameCryptor.setEnabled(_enabled);
     logger.info(
@@ -237,4 +246,40 @@ class E2EEManager {
         return E2EEState.kKeyRatcheted;
     }
   }
+
+  bool get isDataChannelEncryptionEnabled =>
+      _room?.roomOptions.encryption != null;
+
+  Future<Uint8List?> handleEncryptedData({
+    required Uint8List data,
+    required Uint8List iv,
+    required String participantIdentity,
+    required int keyIndex,
+  }) async {
+    if (_dataPacketCryptor == null) {
+      throw Exception('DataPacketCryptor is not initialized');
+    }
+    try {
+      final decryptedData = await _dataPacketCryptor!.decrypt(
+        participantId: participantIdentity,
+        encryptedPacket:
+            EncryptedPacket(data: data, keyIndex: keyIndex, iv: iv),
+      );
+      return decryptedData;
+    } catch (e) {
+      logger.warning('handleEncryptedData error: $e');
+      return null;
+    }
+  }
+
+  Future<EncryptedPacket> encryptData({required Uint8List data}) async {
+    final participantId = _room?.localParticipant?.identity;
+    if (participantId == null || _dataPacketCryptor == null) {
+      throw Exception('DataPacketCryptor is not initialized');
+    }
+    return await _dataPacketCryptor!.encrypt(
+        participantId: participantId,
+        keyIndex: _keyProvider.getLatestIndex(participantId),
+        data: data);
+  }
 }

lib/src/options.dart

@@ -110,8 +110,11 @@ class RoomOptions {
   final bool stopLocalTrackOnUnpublish;
 
   /// Options for end-to-end encryption.
+  @Deprecated('Use encryption instead')
   final E2EEOptions? e2eeOptions;
 
+  final E2EEOptions? encryption;
+
   /// fast track publication
   final bool fastPublish;
 
@@ -131,6 +134,7 @@ class RoomOptions {
     this.dynacast = false,
     this.stopLocalTrackOnUnpublish = true,
     this.e2eeOptions,
+    this.encryption,
     this.enableVisualizer = false,
     this.fastPublish = true,
   });
@@ -166,6 +170,7 @@ class RoomOptions {
       stopLocalTrackOnUnpublish:
           stopLocalTrackOnUnpublish ?? this.stopLocalTrackOnUnpublish,
       e2eeOptions: e2eeOptions ?? this.e2eeOptions,
+      encryption: encryption ?? this.encryption,
       fastPublish: fastPublish ?? this.fastPublish,
     );
   }