Allow setting keyring-size from Rust

Author: onestacked

libwebrtc/src/native/frame_cryptor.rs

@@ -31,6 +31,7 @@ pub struct KeyProviderOptions {
     pub ratchet_window_size: i32,
     pub ratchet_salt: Vec<u8>,
     pub failure_tolerance: i32,
+    pub key_ring_size: i32,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -272,6 +273,7 @@ impl From<KeyProviderOptions> for sys_fc::ffi::KeyProviderOptions {
             ratchet_window_size: value.ratchet_window_size,
             ratchet_salt: value.ratchet_salt,
             failure_tolerance: value.failure_tolerance,
+            key_ring_size: value.key_ring_size,
         }
     }
 }

livekit/src/room/e2ee/key_provider.rs

@@ -23,12 +23,14 @@ use crate::id::ParticipantIdentity;
 const DEFAULT_RATCHET_SALT: &str = "LKFrameEncryptionKey";
 const DEFAULT_RATCHET_WINDOW_SIZE: i32 = 16;
 const DEFAULT_FAILURE_TOLERANCE: i32 = -1; // no tolerance by default
+const DEFAULT_KEY_RING_SIZE: i32 = 16;
 
 #[derive(Clone)]
 pub struct KeyProviderOptions {
     pub ratchet_window_size: i32,
     pub ratchet_salt: Vec<u8>,
     pub failure_tolerance: i32,
+    pub key_ring_size: i32,
 }
 
 impl Default for KeyProviderOptions {
@@ -37,6 +39,7 @@ impl Default for KeyProviderOptions {
             ratchet_window_size: DEFAULT_RATCHET_WINDOW_SIZE,
             ratchet_salt: DEFAULT_RATCHET_SALT.to_owned().into_bytes(),
             failure_tolerance: DEFAULT_FAILURE_TOLERANCE,
+            key_ring_size: DEFAULT_KEY_RING_SIZE,
         }
     }
 }
@@ -56,6 +59,7 @@ impl KeyProvider {
                 ratchet_window_size: options.ratchet_window_size,
                 ratchet_salt: options.ratchet_salt,
                 failure_tolerance: options.failure_tolerance,
+                key_ring_size: options.key_ring_size,
             }),
             latest_key_index: Arc::new(AtomicI32::new(0)),
         }
@@ -67,6 +71,7 @@ impl KeyProvider {
             ratchet_window_size: options.ratchet_window_size,
             ratchet_salt: options.ratchet_salt,
             failure_tolerance: options.failure_tolerance,
+            key_ring_size: options.key_ring_size,
         });
         handle.set_shared_key(0, shared_key);
         Self { handle, latest_key_index: Arc::new(AtomicI32::new(0)) }

webrtc-sys/src/frame_cryptor.cpp

@@ -51,6 +51,7 @@ KeyProvider::KeyProvider(KeyProviderOptions options) {
   rtc_options.ratchet_salt = ratchet_salt;
   rtc_options.ratchet_window_size = options.ratchet_window_size;
   rtc_options.failure_tolerance = options.failure_tolerance;
+  rtc_options.key_ring_size = options.key_ring_size;
 
   impl_ =
       new rtc::RefCountedObject<webrtc::DefaultKeyProviderImpl>(rtc_options);
@@ -154,10 +155,12 @@ int32_t FrameCryptor::key_index() const {
   return e2ee_transformer_->key_index();
 }
 
-DataPacketCryptor::DataPacketCryptor(webrtc::FrameCryptorTransformer::Algorithm algorithm,
-                 webrtc::scoped_refptr<webrtc::KeyProvider> key_provider)
+DataPacketCryptor::DataPacketCryptor(
+    webrtc::FrameCryptorTransformer::Algorithm algorithm,
+    webrtc::scoped_refptr<webrtc::KeyProvider> key_provider)
     : data_packet_cryptor_(
-          webrtc::make_ref_counted<webrtc::DataPacketCryptor>(algorithm, key_provider)) {}
+          webrtc::make_ref_counted<webrtc::DataPacketCryptor>(algorithm,
+                                                              key_provider)) {}
 
 EncryptedPacket DataPacketCryptor::encrypt_data_packet(
     const ::rust::String participant_id,
@@ -167,12 +170,12 @@ EncryptedPacket DataPacketCryptor::encrypt_data_packet(
   std::copy(data.begin(), data.end(), std::back_inserter(data_vec));
 
   auto result = data_packet_cryptor_->Encrypt(
-      std::string(participant_id.data(), participant_id.size()),
-      key_index,
+      std::string(participant_id.data(), participant_id.size()), key_index,
       data_vec);
 
   if (!result.ok()) {
-    throw std::runtime_error(std::string("Failed to encrypt data packet: ") + result.error().message());
+    throw std::runtime_error(std::string("Failed to encrypt data packet: ") +
+                             result.error().message());
   }
 
   auto& packet = result.value();
@@ -202,20 +205,23 @@ rust::Vec<::std::uint8_t> DataPacketCryptor::decrypt_data_packet(
   std::copy(encrypted_packet.iv.begin(), encrypted_packet.iv.end(),
             std::back_inserter(iv_vec));
 
-  auto native_encrypted_packet = webrtc::make_ref_counted<webrtc::EncryptedPacket>(
-      std::move(data_vec), std::move(iv_vec), encrypted_packet.key_index);
+  auto native_encrypted_packet =
+      webrtc::make_ref_counted<webrtc::EncryptedPacket>(
+          std::move(data_vec), std::move(iv_vec), encrypted_packet.key_index);
 
   auto result = data_packet_cryptor_->Decrypt(
       std::string(participant_id.data(), participant_id.size()),
       native_encrypted_packet);
 
   if (!result.ok()) {
-    throw std::runtime_error(std::string("Failed to decrypt data packet: ") + result.error().message());
+    throw std::runtime_error(std::string("Failed to decrypt data packet: ") +
+                             result.error().message());
   }
 
   rust::Vec<uint8_t> decrypted_data;
   auto& decrypted = result.value();
-  std::copy(decrypted.begin(), decrypted.end(), std::back_inserter(decrypted_data));
+  std::copy(decrypted.begin(), decrypted.end(),
+            std::back_inserter(decrypted_data));
   return decrypted_data;
 }
 

webrtc-sys/src/frame_cryptor.rs

@@ -25,6 +25,7 @@ pub mod ffi {
         pub ratchet_window_size: i32,
         pub ratchet_salt: Vec<u8>,
         pub failure_tolerance: i32,
+        pub key_ring_size: i32,
     }
 
     #[derive(Debug)]