fork/rust-sdks

git clone https://git.julia.blue/fork/rust-sdks

Théo Monnomfix: e2ee and upgrade webrtc (#190)92bb3eb

main
6.6 KiB187 linesraw
1/*
2 * Copyright 2023 LiveKit
3 *
4 * Licensed under the Apache License, Version 2.0 (the “License”);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an “AS IS” BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "livekit/frame_cryptor.h"
18
19#include <memory>
20
21#include "absl/types/optional.h"
22#include "api/make_ref_counted.h"
23#include "livekit/peer_connection.h"
24#include "livekit/peer_connection_factory.h"
25#include "livekit/webrtc.h"
26#include "rtc_base/thread.h"
27#include "webrtc-sys/src/frame_cryptor.rs.h"
28
29namespace livekit {
30
31webrtc::FrameCryptorTransformer::Algorithm AlgorithmToFrameCryptorAlgorithm(
32    Algorithm algorithm) {
33  switch (algorithm) {
34    case Algorithm::AesGcm:
35      return webrtc::FrameCryptorTransformer::Algorithm::kAesGcm;
36    case Algorithm::AesCbc:
37      return webrtc::FrameCryptorTransformer::Algorithm::kAesCbc;
38    default:
39      return webrtc::FrameCryptorTransformer::Algorithm::kAesGcm;
40  }
41}
42
43KeyProvider::KeyProvider(KeyProviderOptions options) {
44  webrtc::KeyProviderOptions rtc_options;
45  rtc_options.shared_key = options.shared_key;
46
47  std::vector<uint8_t> ratchet_salt;
48  std::copy(options.ratchet_salt.begin(), options.ratchet_salt.end(),
49            std::back_inserter(ratchet_salt));
50
51  rtc_options.ratchet_salt = ratchet_salt;
52  rtc_options.ratchet_window_size = options.ratchet_window_size;
53  rtc_options.failure_tolerance = options.failure_tolerance;
54
55  impl_ =
56      new rtc::RefCountedObject<webrtc::DefaultKeyProviderImpl>(rtc_options);
57}
58
59FrameCryptor::FrameCryptor(
60    std::shared_ptr<RtcRuntime> rtc_runtime,
61    const std::string participant_id,
62    webrtc::FrameCryptorTransformer::Algorithm algorithm,
63    rtc::scoped_refptr<webrtc::KeyProvider> key_provider,
64    rtc::scoped_refptr<webrtc::RtpSenderInterface> sender)
65    : rtc_runtime_(rtc_runtime),
66      participant_id_(participant_id),
67      key_provider_(key_provider),
68      sender_(sender) {
69  auto mediaType =
70      sender->track()->kind() == "audio"
71          ? webrtc::FrameCryptorTransformer::MediaType::kAudioFrame
72          : webrtc::FrameCryptorTransformer::MediaType::kVideoFrame;
73  e2ee_transformer_ = rtc::scoped_refptr<webrtc::FrameCryptorTransformer>(
74      new webrtc::FrameCryptorTransformer(rtc_runtime->signaling_thread(),
75                                          participant_id, mediaType, algorithm,
76                                          key_provider_));
77  sender->SetEncoderToPacketizerFrameTransformer(e2ee_transformer_);
78  e2ee_transformer_->SetEnabled(false);
79}
80
81FrameCryptor::FrameCryptor(
82    std::shared_ptr<RtcRuntime> rtc_runtime,
83    const std::string participant_id,
84    webrtc::FrameCryptorTransformer::Algorithm algorithm,
85    rtc::scoped_refptr<webrtc::KeyProvider> key_provider,
86    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver)
87    : rtc_runtime_(rtc_runtime),
88      participant_id_(participant_id),
89      key_provider_(key_provider),
90      receiver_(receiver) {
91  auto mediaType =
92      receiver->track()->kind() == "audio"
93          ? webrtc::FrameCryptorTransformer::MediaType::kAudioFrame
94          : webrtc::FrameCryptorTransformer::MediaType::kVideoFrame;
95  e2ee_transformer_ = rtc::scoped_refptr<webrtc::FrameCryptorTransformer>(
96      new webrtc::FrameCryptorTransformer(rtc_runtime->signaling_thread(),
97                                          participant_id, mediaType, algorithm,
98                                          key_provider_));
99  receiver->SetDepacketizerToDecoderFrameTransformer(e2ee_transformer_);
100  e2ee_transformer_->SetEnabled(false);
101}
102
103FrameCryptor::~FrameCryptor() {
104  if (observer_) {
105    unregister_observer();
106  }
107}
108
109void FrameCryptor::register_observer(
110    rust::Box<RtcFrameCryptorObserverWrapper> observer) const {
111  webrtc::MutexLock lock(&mutex_);
112  observer_ = rtc::make_ref_counted<NativeFrameCryptorObserver>(
113      std::move(observer), this);
114  e2ee_transformer_->RegisterFrameCryptorTransformerObserver(observer_);
115}
116
117void FrameCryptor::unregister_observer() const {
118  webrtc::MutexLock lock(&mutex_);
119  observer_ = nullptr;
120  e2ee_transformer_->UnRegisterFrameCryptorTransformerObserver();
121}
122
123NativeFrameCryptorObserver::NativeFrameCryptorObserver(
124    rust::Box<RtcFrameCryptorObserverWrapper> observer,
125    const FrameCryptor* fc)
126    : observer_(std::move(observer)), fc_(fc) {}
127
128NativeFrameCryptorObserver::~NativeFrameCryptorObserver() {}
129
130void NativeFrameCryptorObserver::OnFrameCryptionStateChanged(
131    const std::string participant_id,
132    webrtc::FrameCryptionState state) {
133  observer_->on_frame_cryption_state_change(
134      participant_id, static_cast<FrameCryptionState>(state));
135}
136
137void FrameCryptor::set_enabled(bool enabled) const {
138  webrtc::MutexLock lock(&mutex_);
139  e2ee_transformer_->SetEnabled(enabled);
140}
141
142bool FrameCryptor::enabled() const {
143  webrtc::MutexLock lock(&mutex_);
144  return e2ee_transformer_->enabled();
145}
146
147void FrameCryptor::set_key_index(int32_t index) const {
148  webrtc::MutexLock lock(&mutex_);
149  e2ee_transformer_->SetKeyIndex(index);
150}
151
152int32_t FrameCryptor::key_index() const {
153  webrtc::MutexLock lock(&mutex_);
154  return e2ee_transformer_->key_index();
155}
156
157std::shared_ptr<KeyProvider> new_key_provider(KeyProviderOptions options) {
158  return std::make_shared<KeyProvider>(options);
159}
160
161std::shared_ptr<FrameCryptor> new_frame_cryptor_for_rtp_sender(
162    std::shared_ptr<PeerConnectionFactory> peer_factory,
163    const ::rust::String participant_id,
164    Algorithm algorithm,
165    std::shared_ptr<KeyProvider> key_provider,
166    std::shared_ptr<RtpSender> sender) {
167  return std::make_shared<FrameCryptor>(
168      peer_factory->rtc_runtime(),
169      std::string(participant_id.data(), participant_id.size()),
170      AlgorithmToFrameCryptorAlgorithm(algorithm),
171      key_provider->rtc_key_provider(), sender->rtc_sender());
172}
173
174std::shared_ptr<FrameCryptor> new_frame_cryptor_for_rtp_receiver(
175    std::shared_ptr<PeerConnectionFactory> peer_factory,
176    const ::rust::String participant_id,
177    Algorithm algorithm,
178    std::shared_ptr<KeyProvider> key_provider,
179    std::shared_ptr<RtpReceiver> receiver) {
180  return std::make_shared<FrameCryptor>(
181      peer_factory->rtc_runtime(),
182      std::string(participant_id.data(), participant_id.size()),
183      AlgorithmToFrameCryptorAlgorithm(algorithm),
184      key_provider->rtc_key_provider(), receiver->rtc_receiver());
185}
186
187}  // namespace livekit