1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/*
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef PC_SRTP_TRANSPORT_H_
#define PC_SRTP_TRANSPORT_H_
#include <stddef.h>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "api/field_trials_view.h"
#include "call/rtp_demuxer.h"
#include "p2p/base/packet_transport_internal.h"
#include "pc/rtp_transport.h"
#include "pc/srtp_session.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/buffer.h"
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/network/received_packet.h"
#include "rtc_base/network_route.h"
namespace webrtc {
// This subclass of the RtpTransport is used for SRTP which is reponsible for
// protecting/unprotecting the packets. It provides interfaces to set the crypto
// parameters for the SrtpSession underneath.
class SrtpTransport : public RtpTransport {
public:
SrtpTransport(bool rtcp_mux_enabled, const FieldTrialsView& field_trials);
virtual ~SrtpTransport() = default;
bool SendRtpPacket(CopyOnWriteBuffer* packet,
const AsyncSocketPacketOptions& options,
int flags) override;
bool SendRtcpPacket(CopyOnWriteBuffer* packet,
const AsyncSocketPacketOptions& options,
int flags) override;
// The transport becomes active if the send_session_ and recv_session_ are
// created.
bool IsSrtpActive() const override;
bool IsWritable(bool rtcp) const override;
// Create new send/recv sessions and set the negotiated crypto keys for RTP
// packet encryption. The keys can either come from SDES negotiation or DTLS
// handshake.
bool SetRtpParams(int send_crypto_suite,
const ZeroOnFreeBuffer<uint8_t>& send_key,
const std::vector<int>& send_extension_ids,
int recv_crypto_suite,
const ZeroOnFreeBuffer<uint8_t>& recv_key,
const std::vector<int>& recv_extension_ids);
// Create new send/recv sessions and set the negotiated crypto keys for RTCP
// packet encryption. The keys can either come from SDES negotiation or DTLS
// handshake.
bool SetRtcpParams(int send_crypto_suite,
const ZeroOnFreeBuffer<uint8_t>& send_key,
const std::vector<int>& send_extension_ids,
int recv_crypto_suite,
const ZeroOnFreeBuffer<uint8_t>& recv_key,
const std::vector<int>& recv_extension_ids);
void ResetParams();
// If external auth is enabled, SRTP will write a dummy auth tag that then
// later must get replaced before the packet is sent out. Only supported for
// non-GCM crypto suites and can be checked through "IsExternalAuthActive"
// if it is actually used. This method is only valid before the RTP params
// have been set.
void EnableExternalAuth();
bool IsExternalAuthEnabled() const;
// A SrtpTransport supports external creation of the auth tag if a non-GCM
// cipher is used. This method is only valid after the RTP params have
// been set.
bool IsExternalAuthActive() const;
// Returns srtp overhead for rtp packets.
bool GetSrtpOverhead(int* srtp_overhead) const;
// Returns rtp auth params from srtp context.
bool GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len);
// Cache RTP Absoulute SendTime extension header ID. This is only used when
// external authentication is enabled.
void CacheRtpAbsSendTimeHeaderExtension(int rtp_abs_sendtime_extn_id) {
rtp_abs_sendtime_extn_id_ = rtp_abs_sendtime_extn_id;
}
// In addition to unregistering the sink, the SRTP transport
// disassociates all SSRCs of the sink from libSRTP.
bool UnregisterRtpDemuxerSink(RtpPacketSinkInterface* sink) override;
protected:
// If the writable state changed, fire the SignalWritableState.
void MaybeUpdateWritableState();
private:
void ConnectToRtpTransport();
void CreateSrtpSessions();
void OnRtpPacketReceived(const ReceivedIpPacket& packet) override;
void OnRtcpPacketReceived(const ReceivedIpPacket& packet) override;
void OnNetworkRouteChanged(
std::optional<NetworkRoute> network_route) override;
// Override the RtpTransport::OnWritableState.
void OnWritableState(PacketTransportInternal* packet_transport) override;
bool ProtectRtp(CopyOnWriteBuffer& buffer);
// Overloaded version, outputs packet index.
bool ProtectRtp(CopyOnWriteBuffer& buffer, int64_t* index);
bool ProtectRtcp(CopyOnWriteBuffer& buffer);
// Decrypts/verifies an invidiual RTP/RTCP packet.
// If an HMAC is used, this will decrease the packet size.
bool UnprotectRtp(CopyOnWriteBuffer& buffer);
bool UnprotectRtcp(CopyOnWriteBuffer& buffer);
const std::string content_name_;
std::unique_ptr<SrtpSession> send_session_;
std::unique_ptr<SrtpSession> recv_session_;
std::unique_ptr<SrtpSession> send_rtcp_session_;
std::unique_ptr<SrtpSession> recv_rtcp_session_;
std::optional<int> send_crypto_suite_;
std::optional<int> recv_crypto_suite_;
ZeroOnFreeBuffer<uint8_t> send_key_;
ZeroOnFreeBuffer<uint8_t> recv_key_;
bool writable_ = false;
bool external_auth_enabled_ = false;
int rtp_abs_sendtime_extn_id_ = -1;
int decryption_failure_count_ = 0;
const FieldTrialsView& field_trials_;
};
} // namespace webrtc
#endif // PC_SRTP_TRANSPORT_H_
|
