@sbhjt-gr/react-native-webrtc 124.0.2 → 124.0.4

package/ios/RCTWebRTC/WebRTCModule+RTCFrameCryptor.m

@@ -1,611 +1,611 @@
-#include <Foundation/Foundation.h>
-#import <objc/runtime.h>
-
-#import <React/RCTBridge.h>
-#import <React/RCTBridgeModule.h>
-
-#import "WebRTCModule+RTCPeerConnection.h"
-#import "WebRTCModule.h"
-
-// Key for objc_set/getAssociatedObject, value of NSString*
-static char frameCryptorUUIDKey;
-
-@interface WebRTCModule ()<RTCFrameCryptorDelegate>
-@end
-
-@implementation WebRTCModule (RTCFrameCryptor)
-
-- (RTCCryptorAlgorithm)getAlgorithm:(NSNumber *)algorithm {
-    switch ([algorithm intValue]) {
-        // case 0:
-        //     return RTCCryptorAlgorithmAesGcm;
-        // case 1:
-        //     return RTCCryptorAlgorithmAesCbc;
-        default:
-            return RTCCryptorAlgorithmAesGcm;
-    }
-}
-
-- (NSData *)bytesFromMap:(NSDictionary *)map key:(NSString *)key isBase64Key:(nullable NSString *)isBase64Key {
-    BOOL isBase64 = YES;
-    if (isBase64Key) {
-        isBase64 = [map[isBase64Key] boolValue];
-    }
-
-    if (isBase64) {
-        return [[NSData alloc] initWithBase64EncodedString:map[key] options:0];
-    } else {
-        return [map[key] dataUsingEncoding:NSUTF8StringEncoding];
-    }
-}
-
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(frameCryptorFactoryCreateFrameCryptor : (nonnull NSDictionary *)constraints) {
-    __block NSString *frameCryptorId = nil;
-    dispatch_sync(self.workerQueue, ^{
-        NSNumber *peerConnectionId = constraints[@"peerConnectionId"];
-        NSNumber *algorithm = constraints[@"algorithm"];
-        if (algorithm == nil) {
-            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid algorithm");
-            return;
-        }
-
-        NSString *participantId = constraints[@"participantId"];
-        if (participantId == nil) {
-            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid participantId");
-            return;
-        }
-
-        NSString *keyProviderId = constraints[@"keyProviderId"];
-        if (keyProviderId == nil) {
-            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid keyProviderId");
-            return;
-        }
-
-        RTCFrameCryptorKeyProvider *keyProvider = self.keyProviders[keyProviderId];
-        if (keyProvider == nil) {
-            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid keyProvider");
-            return;
-        }
-
-        NSString *type = constraints[@"type"];
-        NSString *rtpSenderId = constraints[@"rtpSenderId"];
-        NSString *rtpReceiverId = constraints[@"rtpReceiverId"];
-
-        if ([type isEqualToString:@"sender"]) {
-            RTCRtpSender *sender = [self getSenderByPeerConnectionId:peerConnectionId senderId:rtpSenderId];
-
-            if (sender == nil) {
-                NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Error: sender not found!");
-                return;
-            }
-
-            RTCFrameCryptor *frameCryptor = [[RTCFrameCryptor alloc] initWithFactory:self.peerConnectionFactory
-                                                                           rtpSender:sender
-                                                                       participantId:participantId
-                                                                           algorithm:[self getAlgorithm:algorithm]
-                                                                         keyProvider:keyProvider];
-            frameCryptorId = [[NSUUID UUID] UUIDString];
-
-            frameCryptor.delegate = self;
-
-            self.frameCryptors[frameCryptorId] = frameCryptor;
-            objc_setAssociatedObject(frameCryptor, &frameCryptorUUIDKey, frameCryptorId, OBJC_ASSOCIATION_COPY);
-            return;
-        } else if ([type isEqualToString:@"receiver"]) {
-            RTCRtpReceiver *receiver = [self getReceiverByPeerConnectionId:peerConnectionId receiverId:rtpReceiverId];
-            if (receiver == nil) {
-                NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Error: receiver not found!");
-                return;
-            }
-            RTCFrameCryptor *frameCryptor = [[RTCFrameCryptor alloc] initWithFactory:self.peerConnectionFactory
-                                                                         rtpReceiver:receiver
-                                                                       participantId:participantId
-                                                                           algorithm:[self getAlgorithm:algorithm]
-                                                                         keyProvider:keyProvider];
-            frameCryptorId = [[NSUUID UUID] UUIDString];
-
-            frameCryptor.delegate = self;
-
-            self.frameCryptors[frameCryptorId] = frameCryptor;
-            objc_setAssociatedObject(frameCryptor, &frameCryptorUUIDKey, frameCryptorId, OBJC_ASSOCIATION_COPY);
-            return;
-        } else {
-            NSLog(@"InvalidArgument: Invalid type");
-            return;
-        }
-    });
-
-    return frameCryptorId;
-}
-
-RCT_EXPORT_METHOD(frameCryptorSetKeyIndex
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *frameCryptorId = constraints[@"frameCryptorId"];
-    if (frameCryptorId == nil) {
-        reject(@"frameCryptorSetKeyIndexFailed", @"Invalid frameCryptorId", nil);
-        return;
-    }
-    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
-    if (frameCryptor == nil) {
-        reject(@"frameCryptorSetKeyIndexFailed", @"Invalid frameCryptor", nil);
-        return;
-    }
-
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    if (keyIndex == nil) {
-        reject(@"frameCryptorSetKeyIndexFailed", @"Invalid keyIndex", nil);
-        return;
-    }
-    [frameCryptor setKeyIndex:[keyIndex intValue]];
-    resolve(@{@"result" : @YES});
-}
-
-RCT_EXPORT_METHOD(frameCryptorGetKeyIndex
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *frameCryptorId = constraints[@"frameCryptorId"];
-    if (frameCryptorId == nil) {
-        reject(@"frameCryptorGetKeyIndexFailed", @"Invalid frameCryptorId", nil);
-        return;
-    }
-    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
-    if (frameCryptor == nil) {
-        reject(@"frameCryptorGetKeyIndexFailed", @"Invalid frameCryptor", nil);
-        return;
-    }
-    resolve(@{@"keyIndex" : [NSNumber numberWithInt:frameCryptor.keyIndex]});
-}
-
-RCT_EXPORT_METHOD(frameCryptorSetEnabled
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *frameCryptorId = constraints[@"frameCryptorId"];
-    if (frameCryptorId == nil) {
-        reject(@"frameCryptorSetEnabledFailed", @"Invalid frameCryptorId", nil);
-        return;
-    }
-    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
-    if (frameCryptor == nil) {
-        reject(@"frameCryptorSetEnabledFailed", @"Invalid frameCryptor", nil);
-        return;
-    }
-
-    NSNumber *enabled = constraints[@"enabled"];
-    if (enabled == nil) {
-        reject(@"frameCryptorSetEnabledFailed", @"Invalid enabled", nil);
-        return;
-    }
-    frameCryptor.enabled = [enabled boolValue];
-    resolve(@{@"result" : enabled});
-}
-
-RCT_EXPORT_METHOD(frameCryptorGetEnabled
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *frameCryptorId = constraints[@"frameCryptorId"];
-    if (frameCryptorId == nil) {
-        reject(@"frameCryptorGetEnabledFailed", @"Invalid frameCryptorId", nil);
-        return;
-    }
-    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
-    if (frameCryptor == nil) {
-        reject(@"frameCryptorGetEnabledFailed", @"Invalid frameCryptor", nil);
-        return;
-    }
-    resolve(@{@"enabled" : [NSNumber numberWithBool:frameCryptor.enabled]});
-}
-
-RCT_EXPORT_METHOD(frameCryptorDispose
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *frameCryptorId = constraints[@"frameCryptorId"];
-    if (frameCryptorId == nil) {
-        reject(@"frameCryptorDisposeFailed", @"Invalid frameCryptorId", nil);
-        return;
-    }
-    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
-    if (frameCryptor == nil) {
-        reject(@"frameCryptorDisposeFailed", @"Invalid frameCryptor", nil);
-        return;
-    }
-    [self.frameCryptors removeObjectForKey:frameCryptorId];
-    frameCryptor.enabled = NO;
-    resolve(@{@"result" : @"success"});
-}
-
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(frameCryptorFactoryCreateKeyProvider
-                                       : (nonnull NSDictionary *)keyProviderOptions) {
-    __block NSString *keyProviderId = [[NSUUID UUID] UUIDString];
-
-    dispatch_sync(self.workerQueue, ^{
-        NSNumber *sharedKey = keyProviderOptions[@"sharedKey"];
-        if (sharedKey == nil) {
-            NSLog(@"frameCryptorFactoryCreateKeyProviderFailed: Invalid sharedKey");
-            keyProviderId = nil;
-            return;
-        }
-
-        if (keyProviderOptions[@"ratchetSalt"] == nil) {
-            NSLog(@"frameCryptorFactoryCreateKeyProviderFailed: Invalid ratchetSalt");
-            keyProviderId = nil;
-            return;
-        }
-        NSData *ratchetSalt = [self bytesFromMap:keyProviderOptions
-                                             key:@"ratchetSalt"
-                                     isBase64Key:@"ratchetSaltIsBase64"];
-
-        NSNumber *ratchetWindowSize = keyProviderOptions[@"ratchetWindowSize"];
-        if (ratchetWindowSize == nil) {
-            NSLog(@"frameCryptorFactoryCreateKeyProviderFailed: Invalid ratchetWindowSize");
-            keyProviderId = nil;
-            return;
-        }
-
-        NSNumber *failureTolerance = keyProviderOptions[@"failureTolerance"];
-        NSData *uncryptedMagicBytes = nil;
-
-        if (keyProviderOptions[@"uncryptedMagicBytes"] != nil) {
-            uncryptedMagicBytes = [[NSData alloc] initWithBase64EncodedString:keyProviderOptions[@"uncryptedMagicBytes"]
-                                                                      options:0];
-        }
-
-        NSNumber *keyRingSize = keyProviderOptions[@"keyRingSize"];
-        NSNumber *discardFrameWhenCryptorNotReady = keyProviderOptions[@"discardFrameWhenCryptorNotReady"];
-
-        RTCFrameCryptorKeyProvider *keyProvider = [[RTCFrameCryptorKeyProvider alloc]
-                        initWithRatchetSalt:ratchetSalt
-                          ratchetWindowSize:[ratchetWindowSize intValue]
-                              sharedKeyMode:[sharedKey boolValue]
-                        uncryptedMagicBytes:uncryptedMagicBytes
-                           failureTolerance:failureTolerance != nil ? [failureTolerance intValue] : -1
-                                keyRingSize:keyRingSize != nil ? [keyRingSize intValue] : 0
-            discardFrameWhenCryptorNotReady:discardFrameWhenCryptorNotReady != nil
-                                                ? [discardFrameWhenCryptorNotReady boolValue]
-                                                : NO];
-        self.keyProviders[keyProviderId] = keyProvider;
-        return;
-    });
-    return keyProviderId;
-}
-
-- (nullable RTCFrameCryptorKeyProvider *)getKeyProviderForId:(NSString *)keyProviderId
-                                                    rejecter:(RCTPromiseRejectBlock)reject {
-    if (keyProviderId == nil) {
-        reject(@"getKeyProviderForIdFailed", @"Invalid keyProviderId", nil);
-        return nil;
-    }
-    RTCFrameCryptorKeyProvider *keyProvider = self.keyProviders[keyProviderId];
-    if (keyProvider == nil) {
-        reject(@"getKeyProviderForIdFailed", @"Invalid keyProvider", nil);
-        return nil;
-    }
-    return keyProvider;
-}
-
-RCT_EXPORT_METHOD(keyProviderSetSharedKey
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
-    if (keyProvider == nil) {
-        return;
-    }
-
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    if (keyIndex == nil) {
-        reject(@"keyProviderSetSharedKey", @"Invalid keyIndex", nil);
-        return;
-    }
-
-    if (constraints[@"key"] == nil) {
-        reject(@"keyProviderSetSharedKey", @"Invalid key", nil);
-        return;
-    }
-    NSData *key = [self bytesFromMap:constraints key:@"key" isBase64Key:@"keyIsBase64"];
-
-    [keyProvider setSharedKey:key withIndex:[keyIndex intValue]];
-    resolve(@{@"result" : @YES});
-}
-
-RCT_EXPORT_METHOD(keyProviderRatchetSharedKey
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
-    if (keyProvider == nil) {
-        return;
-    }
-
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    if (keyIndex == nil) {
-        reject(@"keyProviderRatchetSharedKeyFailed", @"Invalid keyIndex", nil);
-        return;
-    }
-
-    NSData *newKey = [keyProvider ratchetSharedKey:[keyIndex intValue]];
-    resolve(@{@"result" : [newKey base64EncodedStringWithOptions:0]});
-}
-
-RCT_EXPORT_METHOD(keyProviderExportSharedKey
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
-    if (keyProvider == nil) {
-        return;
-    }
-
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    if (keyIndex == nil) {
-        reject(@"keyProviderExportSharedKeyFailed", @"Invalid keyIndex", nil);
-        return;
-    }
-
-    NSData *key = [keyProvider exportSharedKey:[keyIndex intValue]];
-    resolve(@{@"result" : [key base64EncodedStringWithOptions:0]});
-}
-
-RCT_EXPORT_METHOD(keyProviderSetKey
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
-    if (keyProvider == nil) {
-        return;
-    }
-
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    if (keyIndex == nil) {
-        reject(@"keyProviderSetKeyFailed", @"Invalid keyIndex", nil);
-        return;
-    }
-
-    if (constraints[@"key"] == nil) {
-        reject(@"keyProviderSetKeyFailed", @"Invalid key", nil);
-        return;
-    }
-    NSData *key = [self bytesFromMap:constraints key:@"key" isBase64Key:@"keyIsBase64"];
-
-    NSString *participantId = constraints[@"participantId"];
-    if (participantId == nil) {
-        reject(@"keyProviderSetKeyFailed", @"Invalid participantId", nil);
-        return;
-    }
-
-    [keyProvider setKey:key withIndex:[keyIndex intValue] forParticipant:participantId];
-    resolve(@{@"result" : @YES});
-}
-
-RCT_EXPORT_METHOD(keyProviderRatchetKey
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
-    if (keyProvider == nil) {
-        return;
-    }
-
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    if (keyIndex == nil) {
-        reject(@"keyProviderRatchetKeyFailed", @"Invalid keyIndex", nil);
-        return;
-    }
-
-    NSString *participantId = constraints[@"participantId"];
-    if (participantId == nil) {
-        reject(@"keyProviderRatchetKeyFailed", @"Invalid participantId", nil);
-        return;
-    }
-
-    NSData *newKey = [keyProvider ratchetKey:participantId withIndex:[keyIndex intValue]];
-    resolve(@{@"result" : [newKey base64EncodedStringWithOptions:0]});
-}
-
-RCT_EXPORT_METHOD(keyProviderExportKey
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
-    if (keyProvider == nil) {
-        return;
-    }
-
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    if (keyIndex == nil) {
-        reject(@"keyProviderExportKeyFailed", @"Invalid keyIndex", nil);
-        return;
-    }
-
-    NSString *participantId = constraints[@"participantId"];
-    if (participantId == nil) {
-        reject(@"keyProviderExportKeyFailed", @"Invalid participantId", nil);
-        return;
-    }
-
-    NSData *key = [keyProvider exportKey:participantId withIndex:[keyIndex intValue]];
-    resolve(@{@"result" : [key base64EncodedStringWithOptions:0]});
-}
-
-RCT_EXPORT_METHOD(keyProviderSetSifTrailer
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
-    if (keyProvider == nil) {
-        return;
-    }
-
-    if (constraints[@"sifTrailer"] == nil) {
-        reject(@"keyProviderSetSifTrailerFailed", @"Invalid key", nil);
-        return;
-    }
-    NSData *sifTrailer = [[NSData alloc] initWithBase64EncodedString:constraints[@"sifTrailer"] options:0];
-
-    [keyProvider setSifTrailer:sifTrailer];
-    resolve(nil);
-}
-
-RCT_EXPORT_METHOD(keyProviderDispose
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *keyProviderId = constraints[@"keyProviderId"];
-    if (keyProviderId == nil) {
-        reject(@"getKeyProviderForIdFailed", @"Invalid keyProviderId", nil);
-        return;
-    }
-    [self.keyProviders removeObjectForKey:keyProviderId];
-    resolve(@{@"result" : @"success"});
-}
-
-- (NSString *)stringFromState:(RTCFrameCryptorState)state {
-    switch (state) {
-        case RTCFrameCryptorStateNew:
-            return @"new";
-        case RTCFrameCryptorStateOk:
-            return @"ok";
-        case RTCFrameCryptorStateEncryptionFailed:
-            return @"encryptionFailed";
-        case RTCFrameCryptorStateDecryptionFailed:
-            return @"decryptionFailed";
-        case RTCFrameCryptorStateMissingKey:
-            return @"missingKey";
-        case RTCFrameCryptorStateKeyRatcheted:
-            return @"keyRatcheted";
-        case RTCFrameCryptorStateInternalError:
-            return @"internalError";
-        default:
-            return @"unknown";
-    }
-}
-
-RCT_EXPORT_METHOD(dataPacketCryptorFactoryCreateDataPacketCryptor
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSNumber *algorithm = constraints[@"algorithm"];
-    NSString *keyProviderId = constraints[@"keyProviderId"];
-    if (keyProviderId == nil) {
-        reject(@"dataPacketCryptorFactoryCreateDataPacketCryptorFailed", @"Invalid keyProviderId", nil);
-        return;
-    }
-
-    RTCFrameCryptorKeyProvider *keyProvider = self.keyProviders[keyProviderId];
-    if (keyProvider == nil) {
-        reject(@"getKeyProviderForIdFailed", @"Invalid keyProviderId", nil);
-        return;
-    }
-
-    RTCDataPacketCryptor *cryptor = [[RTCDataPacketCryptor alloc] initWithAlgorithm:[self getAlgorithm:algorithm]
-                                                                        keyProvider:keyProvider];
-    NSString *cryptorId = [[NSUUID UUID] UUIDString];
-
-    self.dataPacketCryptors[cryptorId] = cryptor;
-
-    resolve(@{@"dataPacketCryptorId" : cryptorId});
-}
-
-RCT_EXPORT_METHOD(dataPacketCryptorEncrypt
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *cryptorId = constraints[@"dataPacketCryptorId"];
-    NSString *participantId = constraints[@"participantId"];
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    NSData *data = [self bytesFromMap:constraints key:@"data" isBase64Key:nil];
-
-    RTCDataPacketCryptor *cryptor = self.dataPacketCryptors[cryptorId];
-
-    if (cryptor == nil) {
-        reject(@"dataPacketCryptorEncryptFailed", @"data packet cryptor not found", nil);
-        return;
-    }
-
-    RTCEncryptedPacket *packet = [cryptor encrypt:participantId keyIndex:[keyIndex unsignedIntValue] data:data];
-
-    if (packet == nil) {
-        reject(@"dataPacketCryptorEncryptFailed", @"packet encryption failed", nil);
-        return;
-    }
-
-    resolve(@{
-        @"payload" : [packet.data base64EncodedStringWithOptions:0],
-        @"iv" : [packet.iv base64EncodedStringWithOptions:0],
-        @"keyIndex" : [NSNumber numberWithUnsignedInt:packet.keyIndex]
-    });
-}
-
-RCT_EXPORT_METHOD(dataPacketCryptorDecrypt
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *cryptorId = constraints[@"dataPacketCryptorId"];
-    NSString *participantId = constraints[@"participantId"];
-    NSNumber *keyIndex = constraints[@"keyIndex"];
-    NSData *payload = [self bytesFromMap:constraints key:@"payload" isBase64Key:nil];
-    NSData *iv = [self bytesFromMap:constraints key:@"iv" isBase64Key:nil];
-
-    RTCDataPacketCryptor *cryptor = self.dataPacketCryptors[cryptorId];
-
-    if (cryptor == nil) {
-        reject(@"dataPacketCryptorDecryptFailed", @"data packet cryptor not found", nil);
-        return;
-    }
-
-    RTCEncryptedPacket *packet = [[RTCEncryptedPacket alloc] initWithData:payload
-                                                                       iv:iv
-                                                                 keyIndex:[keyIndex unsignedIntValue]];
-    NSData *decryptedData = [cryptor decrypt:participantId encryptedPacket:packet];
-
-    if (decryptedData == nil) {
-        reject(@"dataPacketCryptorDecryptFailed", @"packet decryption failed", nil);
-        return;
-    }
-
-    resolve(@{@"data" : [decryptedData base64EncodedStringWithOptions:0]});
-}
-RCT_EXPORT_METHOD(dataPacketCryptorDispose
-                  : (nonnull NSDictionary *)constraints resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    NSString *cryptorId = constraints[@"dataPacketCryptorId"];
-
-    RTCDataPacketCryptor *cryptor = self.dataPacketCryptors[cryptorId];
-
-    if (cryptor == nil) {
-        reject(@"dataPacketCryptorDisposeFailed", @"data packet cryptor not found", nil);
-        return;
-    }
-
-    [self.dataPacketCryptors removeObjectForKey:cryptorId];
-    resolve(@{@"result" : @"success"});
-}
-
-#pragma mark - RTCFrameCryptorDelegate methods
-
-- (void)frameCryptor:(RTC_OBJC_TYPE(RTCFrameCryptor) *)frameCryptor
-    didStateChangeWithParticipantId:(NSString *)participantId
-                          withState:(RTCFrameCryptorState)stateChanged {
-    id frameCryptorId = objc_getAssociatedObject(frameCryptor, &frameCryptorUUIDKey);
-
-    if (![frameCryptorId isKindOfClass:[NSString class]]) {
-        NSLog(@"Received frameCryptordidStateChangeWithParticipantId event for frame cryptor without UUID!");
-        return;
-    }
-
-    NSDictionary *event = @{
-        @"event" : kEventFrameCryptionStateChanged,
-        @"participantId" : participantId,
-        @"frameCryptorId" : (NSString *)frameCryptorId,
-        @"state" : [self stringFromState:stateChanged]
-    };
-    [self sendEventWithName:kEventFrameCryptionStateChanged body:event];
-}
-
-@end
+#include <Foundation/Foundation.h>
+#import <objc/runtime.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+
+#import "WebRTCModule+RTCPeerConnection.h"
+#import "WebRTCModule.h"
+
+// Key for objc_set/getAssociatedObject, value of NSString*
+static char frameCryptorUUIDKey;
+
+@interface WebRTCModule ()<RTCFrameCryptorDelegate>
+@end
+
+@implementation WebRTCModule (RTCFrameCryptor)
+
+- (RTCCryptorAlgorithm)getAlgorithm:(NSNumber *)algorithm {
+    switch ([algorithm intValue]) {
+        // case 0:
+        //     return RTCCryptorAlgorithmAesGcm;
+        // case 1:
+        //     return RTCCryptorAlgorithmAesCbc;
+        default:
+            return RTCCryptorAlgorithmAesGcm;
+    }
+}
+
+- (NSData *)bytesFromMap:(NSDictionary *)map key:(NSString *)key isBase64Key:(nullable NSString *)isBase64Key {
+    BOOL isBase64 = YES;
+    if (isBase64Key) {
+        isBase64 = [map[isBase64Key] boolValue];
+    }
+
+    if (isBase64) {
+        return [[NSData alloc] initWithBase64EncodedString:map[key] options:0];
+    } else {
+        return [map[key] dataUsingEncoding:NSUTF8StringEncoding];
+    }
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(frameCryptorFactoryCreateFrameCryptor : (nonnull NSDictionary *)constraints) {
+    __block NSString *frameCryptorId = nil;
+    dispatch_sync(self.workerQueue, ^{
+        NSNumber *peerConnectionId = constraints[@"peerConnectionId"];
+        NSNumber *algorithm = constraints[@"algorithm"];
+        if (algorithm == nil) {
+            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid algorithm");
+            return;
+        }
+
+        NSString *participantId = constraints[@"participantId"];
+        if (participantId == nil) {
+            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid participantId");
+            return;
+        }
+
+        NSString *keyProviderId = constraints[@"keyProviderId"];
+        if (keyProviderId == nil) {
+            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid keyProviderId");
+            return;
+        }
+
+        RTCFrameCryptorKeyProvider *keyProvider = self.keyProviders[keyProviderId];
+        if (keyProvider == nil) {
+            NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Invalid keyProvider");
+            return;
+        }
+
+        NSString *type = constraints[@"type"];
+        NSString *rtpSenderId = constraints[@"rtpSenderId"];
+        NSString *rtpReceiverId = constraints[@"rtpReceiverId"];
+
+        if ([type isEqualToString:@"sender"]) {
+            RTCRtpSender *sender = [self getSenderByPeerConnectionId:peerConnectionId senderId:rtpSenderId];
+
+            if (sender == nil) {
+                NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Error: sender not found!");
+                return;
+            }
+
+            RTCFrameCryptor *frameCryptor = [[RTCFrameCryptor alloc] initWithFactory:self.peerConnectionFactory
+                                                                           rtpSender:sender
+                                                                       participantId:participantId
+                                                                           algorithm:[self getAlgorithm:algorithm]
+                                                                         keyProvider:keyProvider];
+            frameCryptorId = [[NSUUID UUID] UUIDString];
+
+            frameCryptor.delegate = self;
+
+            self.frameCryptors[frameCryptorId] = frameCryptor;
+            objc_setAssociatedObject(frameCryptor, &frameCryptorUUIDKey, frameCryptorId, OBJC_ASSOCIATION_COPY);
+            return;
+        } else if ([type isEqualToString:@"receiver"]) {
+            RTCRtpReceiver *receiver = [self getReceiverByPeerConnectionId:peerConnectionId receiverId:rtpReceiverId];
+            if (receiver == nil) {
+                NSLog(@"frameCryptorFactoryCreateFrameCryptorFailed: Error: receiver not found!");
+                return;
+            }
+            RTCFrameCryptor *frameCryptor = [[RTCFrameCryptor alloc] initWithFactory:self.peerConnectionFactory
+                                                                         rtpReceiver:receiver
+                                                                       participantId:participantId
+                                                                           algorithm:[self getAlgorithm:algorithm]
+                                                                         keyProvider:keyProvider];
+            frameCryptorId = [[NSUUID UUID] UUIDString];
+
+            frameCryptor.delegate = self;
+
+            self.frameCryptors[frameCryptorId] = frameCryptor;
+            objc_setAssociatedObject(frameCryptor, &frameCryptorUUIDKey, frameCryptorId, OBJC_ASSOCIATION_COPY);
+            return;
+        } else {
+            NSLog(@"InvalidArgument: Invalid type");
+            return;
+        }
+    });
+
+    return frameCryptorId;
+}
+
+RCT_EXPORT_METHOD(frameCryptorSetKeyIndex
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *frameCryptorId = constraints[@"frameCryptorId"];
+    if (frameCryptorId == nil) {
+        reject(@"frameCryptorSetKeyIndexFailed", @"Invalid frameCryptorId", nil);
+        return;
+    }
+    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
+    if (frameCryptor == nil) {
+        reject(@"frameCryptorSetKeyIndexFailed", @"Invalid frameCryptor", nil);
+        return;
+    }
+
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    if (keyIndex == nil) {
+        reject(@"frameCryptorSetKeyIndexFailed", @"Invalid keyIndex", nil);
+        return;
+    }
+    [frameCryptor setKeyIndex:[keyIndex intValue]];
+    resolve(@{@"result" : @YES});
+}
+
+RCT_EXPORT_METHOD(frameCryptorGetKeyIndex
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *frameCryptorId = constraints[@"frameCryptorId"];
+    if (frameCryptorId == nil) {
+        reject(@"frameCryptorGetKeyIndexFailed", @"Invalid frameCryptorId", nil);
+        return;
+    }
+    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
+    if (frameCryptor == nil) {
+        reject(@"frameCryptorGetKeyIndexFailed", @"Invalid frameCryptor", nil);
+        return;
+    }
+    resolve(@{@"keyIndex" : [NSNumber numberWithInt:frameCryptor.keyIndex]});
+}
+
+RCT_EXPORT_METHOD(frameCryptorSetEnabled
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *frameCryptorId = constraints[@"frameCryptorId"];
+    if (frameCryptorId == nil) {
+        reject(@"frameCryptorSetEnabledFailed", @"Invalid frameCryptorId", nil);
+        return;
+    }
+    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
+    if (frameCryptor == nil) {
+        reject(@"frameCryptorSetEnabledFailed", @"Invalid frameCryptor", nil);
+        return;
+    }
+
+    NSNumber *enabled = constraints[@"enabled"];
+    if (enabled == nil) {
+        reject(@"frameCryptorSetEnabledFailed", @"Invalid enabled", nil);
+        return;
+    }
+    frameCryptor.enabled = [enabled boolValue];
+    resolve(@{@"result" : enabled});
+}
+
+RCT_EXPORT_METHOD(frameCryptorGetEnabled
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *frameCryptorId = constraints[@"frameCryptorId"];
+    if (frameCryptorId == nil) {
+        reject(@"frameCryptorGetEnabledFailed", @"Invalid frameCryptorId", nil);
+        return;
+    }
+    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
+    if (frameCryptor == nil) {
+        reject(@"frameCryptorGetEnabledFailed", @"Invalid frameCryptor", nil);
+        return;
+    }
+    resolve(@{@"enabled" : [NSNumber numberWithBool:frameCryptor.enabled]});
+}
+
+RCT_EXPORT_METHOD(frameCryptorDispose
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *frameCryptorId = constraints[@"frameCryptorId"];
+    if (frameCryptorId == nil) {
+        reject(@"frameCryptorDisposeFailed", @"Invalid frameCryptorId", nil);
+        return;
+    }
+    RTCFrameCryptor *frameCryptor = self.frameCryptors[frameCryptorId];
+    if (frameCryptor == nil) {
+        reject(@"frameCryptorDisposeFailed", @"Invalid frameCryptor", nil);
+        return;
+    }
+    [self.frameCryptors removeObjectForKey:frameCryptorId];
+    frameCryptor.enabled = NO;
+    resolve(@{@"result" : @"success"});
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(frameCryptorFactoryCreateKeyProvider
+                                       : (nonnull NSDictionary *)keyProviderOptions) {
+    __block NSString *keyProviderId = [[NSUUID UUID] UUIDString];
+
+    dispatch_sync(self.workerQueue, ^{
+        NSNumber *sharedKey = keyProviderOptions[@"sharedKey"];
+        if (sharedKey == nil) {
+            NSLog(@"frameCryptorFactoryCreateKeyProviderFailed: Invalid sharedKey");
+            keyProviderId = nil;
+            return;
+        }
+
+        if (keyProviderOptions[@"ratchetSalt"] == nil) {
+            NSLog(@"frameCryptorFactoryCreateKeyProviderFailed: Invalid ratchetSalt");
+            keyProviderId = nil;
+            return;
+        }
+        NSData *ratchetSalt = [self bytesFromMap:keyProviderOptions
+                                             key:@"ratchetSalt"
+                                     isBase64Key:@"ratchetSaltIsBase64"];
+
+        NSNumber *ratchetWindowSize = keyProviderOptions[@"ratchetWindowSize"];
+        if (ratchetWindowSize == nil) {
+            NSLog(@"frameCryptorFactoryCreateKeyProviderFailed: Invalid ratchetWindowSize");
+            keyProviderId = nil;
+            return;
+        }
+
+        NSNumber *failureTolerance = keyProviderOptions[@"failureTolerance"];
+        NSData *uncryptedMagicBytes = nil;
+
+        if (keyProviderOptions[@"uncryptedMagicBytes"] != nil) {
+            uncryptedMagicBytes = [[NSData alloc] initWithBase64EncodedString:keyProviderOptions[@"uncryptedMagicBytes"]
+                                                                      options:0];
+        }
+
+        NSNumber *keyRingSize = keyProviderOptions[@"keyRingSize"];
+        NSNumber *discardFrameWhenCryptorNotReady = keyProviderOptions[@"discardFrameWhenCryptorNotReady"];
+
+        RTCFrameCryptorKeyProvider *keyProvider = [[RTCFrameCryptorKeyProvider alloc]
+                        initWithRatchetSalt:ratchetSalt
+                          ratchetWindowSize:[ratchetWindowSize intValue]
+                              sharedKeyMode:[sharedKey boolValue]
+                        uncryptedMagicBytes:uncryptedMagicBytes
+                           failureTolerance:failureTolerance != nil ? [failureTolerance intValue] : -1
+                                keyRingSize:keyRingSize != nil ? [keyRingSize intValue] : 0
+            discardFrameWhenCryptorNotReady:discardFrameWhenCryptorNotReady != nil
+                                                ? [discardFrameWhenCryptorNotReady boolValue]
+                                                : NO];
+        self.keyProviders[keyProviderId] = keyProvider;
+        return;
+    });
+    return keyProviderId;
+}
+
+- (nullable RTCFrameCryptorKeyProvider *)getKeyProviderForId:(NSString *)keyProviderId
+                                                    rejecter:(RCTPromiseRejectBlock)reject {
+    if (keyProviderId == nil) {
+        reject(@"getKeyProviderForIdFailed", @"Invalid keyProviderId", nil);
+        return nil;
+    }
+    RTCFrameCryptorKeyProvider *keyProvider = self.keyProviders[keyProviderId];
+    if (keyProvider == nil) {
+        reject(@"getKeyProviderForIdFailed", @"Invalid keyProvider", nil);
+        return nil;
+    }
+    return keyProvider;
+}
+
+RCT_EXPORT_METHOD(keyProviderSetSharedKey
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
+    if (keyProvider == nil) {
+        return;
+    }
+
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    if (keyIndex == nil) {
+        reject(@"keyProviderSetSharedKey", @"Invalid keyIndex", nil);
+        return;
+    }
+
+    if (constraints[@"key"] == nil) {
+        reject(@"keyProviderSetSharedKey", @"Invalid key", nil);
+        return;
+    }
+    NSData *key = [self bytesFromMap:constraints key:@"key" isBase64Key:@"keyIsBase64"];
+
+    [keyProvider setSharedKey:key withIndex:[keyIndex intValue]];
+    resolve(@{@"result" : @YES});
+}
+
+RCT_EXPORT_METHOD(keyProviderRatchetSharedKey
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
+    if (keyProvider == nil) {
+        return;
+    }
+
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    if (keyIndex == nil) {
+        reject(@"keyProviderRatchetSharedKeyFailed", @"Invalid keyIndex", nil);
+        return;
+    }
+
+    NSData *newKey = [keyProvider ratchetSharedKey:[keyIndex intValue]];
+    resolve(@{@"result" : [newKey base64EncodedStringWithOptions:0]});
+}
+
+RCT_EXPORT_METHOD(keyProviderExportSharedKey
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
+    if (keyProvider == nil) {
+        return;
+    }
+
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    if (keyIndex == nil) {
+        reject(@"keyProviderExportSharedKeyFailed", @"Invalid keyIndex", nil);
+        return;
+    }
+
+    NSData *key = [keyProvider exportSharedKey:[keyIndex intValue]];
+    resolve(@{@"result" : [key base64EncodedStringWithOptions:0]});
+}
+
+RCT_EXPORT_METHOD(keyProviderSetKey
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
+    if (keyProvider == nil) {
+        return;
+    }
+
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    if (keyIndex == nil) {
+        reject(@"keyProviderSetKeyFailed", @"Invalid keyIndex", nil);
+        return;
+    }
+
+    if (constraints[@"key"] == nil) {
+        reject(@"keyProviderSetKeyFailed", @"Invalid key", nil);
+        return;
+    }
+    NSData *key = [self bytesFromMap:constraints key:@"key" isBase64Key:@"keyIsBase64"];
+
+    NSString *participantId = constraints[@"participantId"];
+    if (participantId == nil) {
+        reject(@"keyProviderSetKeyFailed", @"Invalid participantId", nil);
+        return;
+    }
+
+    [keyProvider setKey:key withIndex:[keyIndex intValue] forParticipant:participantId];
+    resolve(@{@"result" : @YES});
+}
+
+RCT_EXPORT_METHOD(keyProviderRatchetKey
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
+    if (keyProvider == nil) {
+        return;
+    }
+
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    if (keyIndex == nil) {
+        reject(@"keyProviderRatchetKeyFailed", @"Invalid keyIndex", nil);
+        return;
+    }
+
+    NSString *participantId = constraints[@"participantId"];
+    if (participantId == nil) {
+        reject(@"keyProviderRatchetKeyFailed", @"Invalid participantId", nil);
+        return;
+    }
+
+    NSData *newKey = [keyProvider ratchetKey:participantId withIndex:[keyIndex intValue]];
+    resolve(@{@"result" : [newKey base64EncodedStringWithOptions:0]});
+}
+
+RCT_EXPORT_METHOD(keyProviderExportKey
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
+    if (keyProvider == nil) {
+        return;
+    }
+
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    if (keyIndex == nil) {
+        reject(@"keyProviderExportKeyFailed", @"Invalid keyIndex", nil);
+        return;
+    }
+
+    NSString *participantId = constraints[@"participantId"];
+    if (participantId == nil) {
+        reject(@"keyProviderExportKeyFailed", @"Invalid participantId", nil);
+        return;
+    }
+
+    NSData *key = [keyProvider exportKey:participantId withIndex:[keyIndex intValue]];
+    resolve(@{@"result" : [key base64EncodedStringWithOptions:0]});
+}
+
+RCT_EXPORT_METHOD(keyProviderSetSifTrailer
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCFrameCryptorKeyProvider *keyProvider = [self getKeyProviderForId:constraints[@"keyProviderId"] rejecter:reject];
+    if (keyProvider == nil) {
+        return;
+    }
+
+    if (constraints[@"sifTrailer"] == nil) {
+        reject(@"keyProviderSetSifTrailerFailed", @"Invalid key", nil);
+        return;
+    }
+    NSData *sifTrailer = [[NSData alloc] initWithBase64EncodedString:constraints[@"sifTrailer"] options:0];
+
+    [keyProvider setSifTrailer:sifTrailer];
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(keyProviderDispose
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *keyProviderId = constraints[@"keyProviderId"];
+    if (keyProviderId == nil) {
+        reject(@"getKeyProviderForIdFailed", @"Invalid keyProviderId", nil);
+        return;
+    }
+    [self.keyProviders removeObjectForKey:keyProviderId];
+    resolve(@{@"result" : @"success"});
+}
+
+- (NSString *)stringFromState:(RTCFrameCryptorState)state {
+    switch (state) {
+        case RTCFrameCryptorStateNew:
+            return @"new";
+        case RTCFrameCryptorStateOk:
+            return @"ok";
+        case RTCFrameCryptorStateEncryptionFailed:
+            return @"encryptionFailed";
+        case RTCFrameCryptorStateDecryptionFailed:
+            return @"decryptionFailed";
+        case RTCFrameCryptorStateMissingKey:
+            return @"missingKey";
+        case RTCFrameCryptorStateKeyRatcheted:
+            return @"keyRatcheted";
+        case RTCFrameCryptorStateInternalError:
+            return @"internalError";
+        default:
+            return @"unknown";
+    }
+}
+
+RCT_EXPORT_METHOD(dataPacketCryptorFactoryCreateDataPacketCryptor
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSNumber *algorithm = constraints[@"algorithm"];
+    NSString *keyProviderId = constraints[@"keyProviderId"];
+    if (keyProviderId == nil) {
+        reject(@"dataPacketCryptorFactoryCreateDataPacketCryptorFailed", @"Invalid keyProviderId", nil);
+        return;
+    }
+
+    RTCFrameCryptorKeyProvider *keyProvider = self.keyProviders[keyProviderId];
+    if (keyProvider == nil) {
+        reject(@"getKeyProviderForIdFailed", @"Invalid keyProviderId", nil);
+        return;
+    }
+
+    RTCDataPacketCryptor *cryptor = [[RTCDataPacketCryptor alloc] initWithAlgorithm:[self getAlgorithm:algorithm]
+                                                                        keyProvider:keyProvider];
+    NSString *cryptorId = [[NSUUID UUID] UUIDString];
+
+    self.dataPacketCryptors[cryptorId] = cryptor;
+
+    resolve(@{@"dataPacketCryptorId" : cryptorId});
+}
+
+RCT_EXPORT_METHOD(dataPacketCryptorEncrypt
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *cryptorId = constraints[@"dataPacketCryptorId"];
+    NSString *participantId = constraints[@"participantId"];
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    NSData *data = [self bytesFromMap:constraints key:@"data" isBase64Key:nil];
+
+    RTCDataPacketCryptor *cryptor = self.dataPacketCryptors[cryptorId];
+
+    if (cryptor == nil) {
+        reject(@"dataPacketCryptorEncryptFailed", @"data packet cryptor not found", nil);
+        return;
+    }
+
+    RTCEncryptedPacket *packet = [cryptor encrypt:participantId keyIndex:[keyIndex unsignedIntValue] data:data];
+
+    if (packet == nil) {
+        reject(@"dataPacketCryptorEncryptFailed", @"packet encryption failed", nil);
+        return;
+    }
+
+    resolve(@{
+        @"payload" : [packet.data base64EncodedStringWithOptions:0],
+        @"iv" : [packet.iv base64EncodedStringWithOptions:0],
+        @"keyIndex" : [NSNumber numberWithUnsignedInt:packet.keyIndex]
+    });
+}
+
+RCT_EXPORT_METHOD(dataPacketCryptorDecrypt
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *cryptorId = constraints[@"dataPacketCryptorId"];
+    NSString *participantId = constraints[@"participantId"];
+    NSNumber *keyIndex = constraints[@"keyIndex"];
+    NSData *payload = [self bytesFromMap:constraints key:@"payload" isBase64Key:nil];
+    NSData *iv = [self bytesFromMap:constraints key:@"iv" isBase64Key:nil];
+
+    RTCDataPacketCryptor *cryptor = self.dataPacketCryptors[cryptorId];
+
+    if (cryptor == nil) {
+        reject(@"dataPacketCryptorDecryptFailed", @"data packet cryptor not found", nil);
+        return;
+    }
+
+    RTCEncryptedPacket *packet = [[RTCEncryptedPacket alloc] initWithData:payload
+                                                                       iv:iv
+                                                                 keyIndex:[keyIndex unsignedIntValue]];
+    NSData *decryptedData = [cryptor decrypt:participantId encryptedPacket:packet];
+
+    if (decryptedData == nil) {
+        reject(@"dataPacketCryptorDecryptFailed", @"packet decryption failed", nil);
+        return;
+    }
+
+    resolve(@{@"data" : [decryptedData base64EncodedStringWithOptions:0]});
+}
+RCT_EXPORT_METHOD(dataPacketCryptorDispose
+                  : (nonnull NSDictionary *)constraints resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    NSString *cryptorId = constraints[@"dataPacketCryptorId"];
+
+    RTCDataPacketCryptor *cryptor = self.dataPacketCryptors[cryptorId];
+
+    if (cryptor == nil) {
+        reject(@"dataPacketCryptorDisposeFailed", @"data packet cryptor not found", nil);
+        return;
+    }
+
+    [self.dataPacketCryptors removeObjectForKey:cryptorId];
+    resolve(@{@"result" : @"success"});
+}
+
+#pragma mark - RTCFrameCryptorDelegate methods
+
+- (void)frameCryptor:(RTC_OBJC_TYPE(RTCFrameCryptor) *)frameCryptor
+    didStateChangeWithParticipantId:(NSString *)participantId
+                          withState:(RTCFrameCryptorState)stateChanged {
+    id frameCryptorId = objc_getAssociatedObject(frameCryptor, &frameCryptorUUIDKey);
+
+    if (![frameCryptorId isKindOfClass:[NSString class]]) {
+        NSLog(@"Received frameCryptordidStateChangeWithParticipantId event for frame cryptor without UUID!");
+        return;
+    }
+
+    NSDictionary *event = @{
+        @"event" : kEventFrameCryptionStateChanged,
+        @"participantId" : participantId,
+        @"frameCryptorId" : (NSString *)frameCryptorId,
+        @"state" : [self stringFromState:stateChanged]
+    };
+    [self sendEventWithName:kEventFrameCryptionStateChanged body:event];
+}
+
+@end