OLD | NEW |
---|---|
(Empty) | |
1 /* | |
2 * Copyright 2017 The WebRTC project authors. All Rights Reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #include "pc/dtlssrtptransport.h" | |
12 | |
13 #include <memory> | |
14 #include <string> | |
15 #include <utility> | |
16 | |
17 #include "media/base/rtputils.h" | |
18 #include "rtc_base/sslstreamadapter.h" | |
19 | |
20 namespace { | |
21 // Value specified in RFC 5764. | |
22 static const char kDtlsSrtpExporterLabel[] = "EXTRACTOR-dtls_srtp"; | |
23 } // namespace | |
24 | |
25 namespace webrtc { | |
26 | |
27 DtlsSrtpTransport::DtlsSrtpTransport( | |
28 std::unique_ptr<webrtc::SrtpTransport> transport) | |
29 : srtp_transport_(std::move(transport)) { | |
30 ConnectToSrtpTransport(); | |
31 } | |
32 | |
33 void DtlsSrtpTransport::ConnectToSrtpTransport() { | |
34 RTC_DCHECK(srtp_transport_); | |
35 srtp_transport_->SignalPacketReceived.connect( | |
36 this, &DtlsSrtpTransport::OnPacketReceived); | |
37 srtp_transport_->SignalReadyToSend.connect(this, | |
38 &DtlsSrtpTransport::OnReadyToSend); | |
39 } | |
40 | |
41 void DtlsSrtpTransport::OnPacketReceived(bool rtcp, | |
42 rtc::CopyOnWriteBuffer* packet, | |
43 const rtc::PacketTime& packet_time) { | |
44 SignalPacketReceived(rtcp, packet, packet_time); | |
45 } | |
46 | |
47 void DtlsSrtpTransport::OnReadyToSend(bool ready) { | |
48 SignalReadyToSend(ready); | |
49 } | |
50 | |
51 bool DtlsSrtpTransport::SetupDtlsSrtp(bool rtcp) { | |
52 bool ret = false; | |
53 | |
54 cricket::DtlsTransportInternal* transport = | |
55 rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_; | |
56 RTC_DCHECK(transport); | |
57 RTC_DCHECK(transport->IsDtlsActive()); | |
58 | |
59 int selected_crypto_suite; | |
60 | |
61 if (!transport->GetSrtpCryptoSuite(&selected_crypto_suite)) { | |
62 LOG(LS_ERROR) << "No DTLS-SRTP selected crypto suite"; | |
63 return false; | |
64 } | |
65 | |
66 LOG(LS_INFO) << "Installing keys from DTLS-SRTP on " | |
67 << cricket::RtpRtcpStringLiteral(rtcp); | |
68 | |
69 int key_len; | |
70 int salt_len; | |
71 if (!rtc::GetSrtpKeyAndSaltLengths(selected_crypto_suite, &key_len, | |
72 &salt_len)) { | |
73 LOG(LS_ERROR) << "Unknown DTLS-SRTP crypto suite" << selected_crypto_suite; | |
74 return false; | |
75 } | |
76 | |
77 // OK, we're now doing DTLS (RFC 5764) | |
78 std::vector<unsigned char> dtls_buffer(key_len * 2 + salt_len * 2); | |
79 | |
80 // RFC 5705 exporter using the RFC 5764 parameters | |
81 if (!transport->ExportKeyingMaterial(kDtlsSrtpExporterLabel, NULL, 0, false, | |
82 &dtls_buffer[0], dtls_buffer.size())) { | |
83 LOG(LS_WARNING) << "DTLS-SRTP key export failed"; | |
84 RTC_NOTREACHED(); // This should never happen | |
85 return false; | |
86 } | |
87 | |
88 // Sync up the keys with the DTLS-SRTP interface | |
89 std::vector<unsigned char> client_write_key(key_len + salt_len); | |
90 std::vector<unsigned char> server_write_key(key_len + salt_len); | |
91 size_t offset = 0; | |
92 memcpy(&client_write_key[0], &dtls_buffer[offset], key_len); | |
93 offset += key_len; | |
94 memcpy(&server_write_key[0], &dtls_buffer[offset], key_len); | |
95 offset += key_len; | |
96 memcpy(&client_write_key[key_len], &dtls_buffer[offset], salt_len); | |
97 offset += salt_len; | |
98 memcpy(&server_write_key[key_len], &dtls_buffer[offset], salt_len); | |
99 | |
100 std::vector<unsigned char>*send_key, *recv_key; | |
101 rtc::SSLRole role; | |
102 if (!transport->GetSslRole(&role)) { | |
103 LOG(LS_WARNING) << "GetSslRole failed"; | |
104 return false; | |
105 } | |
106 | |
107 if (role == rtc::SSL_SERVER) { | |
108 send_key = &server_write_key; | |
109 recv_key = &client_write_key; | |
110 } else { | |
111 send_key = &client_write_key; | |
112 recv_key = &server_write_key; | |
113 } | |
114 | |
115 if (rtcp) { | |
116 if (!IsActive()) { | |
117 RTC_DCHECK(srtp_transport_); | |
118 ret = srtp_transport_->SetRtcpParams( | |
119 selected_crypto_suite, &(*send_key)[0], | |
120 static_cast<int>(send_key->size()), selected_crypto_suite, | |
121 &(*recv_key)[0], static_cast<int>(recv_key->size())); | |
122 } else { | |
123 // RTCP doesn't need to call SetRtpParam because it is only used | |
124 // to make the updated encrypted RTP header extension IDs take effect. | |
125 ret = true; | |
126 } | |
127 } else { | |
128 RTC_DCHECK(srtp_transport_); | |
129 ret = srtp_transport_->SetRtpParams(selected_crypto_suite, &(*send_key)[0], | |
130 static_cast<int>(send_key->size()), | |
131 selected_crypto_suite, &(*recv_key)[0], | |
132 static_cast<int>(recv_key->size())); | |
133 } | |
134 | |
135 if (!ret) { | |
136 LOG(LS_WARNING) << "DTLS-SRTP key installation failed"; | |
137 } | |
138 active_ = ret; | |
139 return ret; | |
140 } | |
141 | |
142 void DtlsSrtpTransport::SetSendEncryptedHeaderExtensionIds( | |
Taylor Brandstetter
2017/09/27 23:54:48
In a previous code review I mentioned that it may
| |
143 const std::vector<int>& send_extension_ids) { | |
144 RTC_DCHECK(srtp_transport_); | |
Taylor Brandstetter
2017/09/27 23:54:48
nit: I don't know if adding these DCHECKS everywhe
| |
145 srtp_transport_->SetSendEncryptedHeaderExtensionIds(send_extension_ids); | |
146 } | |
147 | |
148 void DtlsSrtpTransport::SetRecvEncryptedHeaderExtensionIds( | |
149 const std::vector<int>& recv_extension_ids) { | |
150 RTC_DCHECK(srtp_transport_); | |
151 srtp_transport_->SetRecvEncryptedHeaderExtensionIds(recv_extension_ids); | |
152 } | |
153 | |
154 void DtlsSrtpTransport::SetRtcpMuxEnabled(bool enable) { | |
155 RTC_DCHECK(srtp_transport_); | |
156 srtp_transport_->SetRtcpMuxEnabled(enable); | |
157 } | |
158 | |
159 rtc::PacketTransportInternal* DtlsSrtpTransport::rtp_packet_transport() const { | |
160 RTC_DCHECK(srtp_transport_); | |
161 return srtp_transport_->rtp_packet_transport(); | |
162 } | |
163 | |
164 void DtlsSrtpTransport::SetRtpPacketTransport( | |
165 rtc::PacketTransportInternal* rtp) { | |
166 RTC_DCHECK(srtp_transport_); | |
167 srtp_transport_->SetRtpPacketTransport(rtp); | |
168 } | |
169 | |
170 PacketTransportInterface* DtlsSrtpTransport::GetRtpPacketTransport() const { | |
171 RTC_DCHECK(srtp_transport_); | |
172 return srtp_transport_->GetRtpPacketTransport(); | |
173 } | |
174 | |
175 rtc::PacketTransportInternal* DtlsSrtpTransport::rtcp_packet_transport() const { | |
176 RTC_DCHECK(srtp_transport_); | |
177 return srtp_transport_->rtcp_packet_transport(); | |
178 } | |
179 | |
180 void DtlsSrtpTransport::SetRtcpPacketTransport( | |
181 rtc::PacketTransportInternal* rtcp) { | |
182 RTC_DCHECK(srtp_transport_); | |
183 srtp_transport_->SetRtcpPacketTransport(rtcp); | |
184 } | |
185 | |
186 PacketTransportInterface* DtlsSrtpTransport::GetRtcpPacketTransport() const { | |
187 RTC_DCHECK(srtp_transport_); | |
188 return srtp_transport_->GetRtcpPacketTransport(); | |
189 } | |
190 | |
191 bool DtlsSrtpTransport::IsWritable(bool rtcp) const { | |
192 RTC_DCHECK(srtp_transport_); | |
193 return srtp_transport_->IsWritable(rtcp); | |
194 } | |
195 | |
196 bool DtlsSrtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet, | |
197 const rtc::PacketOptions& options, | |
198 int flags) { | |
199 RTC_DCHECK(srtp_transport_); | |
200 return srtp_transport_->SendRtpPacket(packet, options, flags); | |
201 } | |
202 | |
203 bool DtlsSrtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet, | |
204 const rtc::PacketOptions& options, | |
205 int flags) { | |
206 RTC_DCHECK(srtp_transport_); | |
207 return srtp_transport_->SendRtcpPacket(packet, options, flags); | |
208 } | |
209 | |
210 bool DtlsSrtpTransport::HandlesPayloadType(int payload_type) const { | |
211 RTC_DCHECK(srtp_transport_); | |
212 return srtp_transport_->HandlesPayloadType(payload_type); | |
213 } | |
214 | |
215 void DtlsSrtpTransport::AddHandledPayloadType(int payload_type) { | |
216 RTC_DCHECK(srtp_transport_); | |
217 srtp_transport_->AddHandledPayloadType(payload_type); | |
218 } | |
219 | |
220 void DtlsSrtpTransport::ResetParams() { | |
221 active_ = false; | |
222 if (srtp_transport_) { | |
Taylor Brandstetter
2017/09/27 23:54:48
When will it be null?
| |
223 srtp_transport_->ResetParams(); | |
224 } | |
225 } | |
226 | |
227 RTCError DtlsSrtpTransport::SetParameters( | |
228 const RtpTransportParameters& parameters) { | |
229 RTC_DCHECK(srtp_transport_); | |
230 return srtp_transport_->SetParameters(parameters); | |
231 } | |
232 | |
233 RtpTransportParameters DtlsSrtpTransport::GetParameters() const { | |
234 RTC_DCHECK(srtp_transport_); | |
235 return srtp_transport_->GetParameters(); | |
236 } | |
237 | |
238 } // namespace webrtc | |
OLD | NEW |