| /* |
| * Copyright (c) 2011 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. |
| */ |
| |
| #include "webrtc/media/base/rtputils.h" |
| |
| // PacketTimeUpdateParams is defined in asyncpacketsocket.h. |
| // TODO(sergeyu): Find more appropriate place for PacketTimeUpdateParams. |
| #include "webrtc/base/asyncpacketsocket.h" |
| #include "webrtc/base/checks.h" |
| #include "webrtc/base/messagedigest.h" |
| #include "webrtc/media/base/turnutils.h" |
| |
| namespace cricket { |
| |
| static const uint8_t kRtpVersion = 2; |
| static const size_t kRtpFlagsOffset = 0; |
| static const size_t kRtpPayloadTypeOffset = 1; |
| static const size_t kRtpSeqNumOffset = 2; |
| static const size_t kRtpTimestampOffset = 4; |
| static const size_t kRtpSsrcOffset = 8; |
| static const size_t kRtcpPayloadTypeOffset = 1; |
| static const size_t kRtpExtensionHeaderLen = 4; |
| static const size_t kAbsSendTimeExtensionLen = 3; |
| static const size_t kOneByteExtensionHeaderLen = 1; |
| |
| namespace { |
| |
| // Fake auth tag written by the sender when external authentication is enabled. |
| // HMAC in packet will be compared against this value before updating packet |
| // with actual HMAC value. |
| static const uint8_t kFakeAuthTag[10] = { |
| 0xba, 0xdd, 0xba, 0xdd, 0xba, 0xdd, 0xba, 0xdd, 0xba, 0xdd |
| }; |
| |
| void UpdateAbsSendTimeExtensionValue(uint8_t* extension_data, |
| size_t length, |
| uint64_t time_us) { |
| // Absolute send time in RTP streams. |
| // |
| // The absolute send time is signaled to the receiver in-band using the |
| // general mechanism for RTP header extensions [RFC5285]. The payload |
| // of this extension (the transmitted value) is a 24-bit unsigned integer |
| // containing the sender's current time in seconds as a fixed point number |
| // with 18 bits fractional part. |
| // |
| // The form of the absolute send time extension block: |
| // |
| // 0 1 2 3 |
| // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | ID | len=2 | absolute send time | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| if (length != kAbsSendTimeExtensionLen) { |
| RTC_NOTREACHED(); |
| return; |
| } |
| |
| // Convert microseconds to a 6.18 fixed point value in seconds. |
| uint32_t send_time = ((time_us << 18) / 1000000) & 0x00FFFFFF; |
| extension_data[0] = static_cast<uint8_t>(send_time >> 16); |
| extension_data[1] = static_cast<uint8_t>(send_time >> 8); |
| extension_data[2] = static_cast<uint8_t>(send_time); |
| } |
| |
| // Assumes |length| is actual packet length + tag length. Updates HMAC at end of |
| // the RTP packet. |
| void UpdateRtpAuthTag(uint8_t* rtp, |
| size_t length, |
| const rtc::PacketTimeUpdateParams& packet_time_params) { |
| // If there is no key, return. |
| if (packet_time_params.srtp_auth_key.empty()) { |
| return; |
| } |
| |
| size_t tag_length = packet_time_params.srtp_auth_tag_len; |
| |
| // ROC (rollover counter) is at the beginning of the auth tag. |
| const size_t kRocLength = 4; |
| if (tag_length < kRocLength || tag_length > length) { |
| RTC_NOTREACHED(); |
| return; |
| } |
| |
| uint8_t* auth_tag = rtp + (length - tag_length); |
| |
| // We should have a fake HMAC value @ auth_tag. |
| RTC_DCHECK_EQ(0, memcmp(auth_tag, kFakeAuthTag, tag_length)); |
| |
| // Copy ROC after end of rtp packet. |
| memcpy(auth_tag, &packet_time_params.srtp_packet_index, kRocLength); |
| // Authentication of a RTP packet will have RTP packet + ROC size. |
| size_t auth_required_length = length - tag_length + kRocLength; |
| |
| uint8_t output[64]; |
| size_t result = rtc::ComputeHmac( |
| rtc::DIGEST_SHA_1, &packet_time_params.srtp_auth_key[0], |
| packet_time_params.srtp_auth_key.size(), rtp, |
| auth_required_length, output, sizeof(output)); |
| |
| if (result < tag_length) { |
| RTC_NOTREACHED(); |
| return; |
| } |
| |
| // Copy HMAC from output to packet. This is required as auth tag length |
| // may not be equal to the actual HMAC length. |
| memcpy(auth_tag, output, tag_length); |
| } |
| |
| } |
| |
| bool GetUint8(const void* data, size_t offset, int* value) { |
| if (!data || !value) { |
| return false; |
| } |
| *value = *(static_cast<const uint8_t*>(data) + offset); |
| return true; |
| } |
| |
| bool GetUint16(const void* data, size_t offset, int* value) { |
| if (!data || !value) { |
| return false; |
| } |
| *value = static_cast<int>( |
| rtc::GetBE16(static_cast<const uint8_t*>(data) + offset)); |
| return true; |
| } |
| |
| bool GetUint32(const void* data, size_t offset, uint32_t* value) { |
| if (!data || !value) { |
| return false; |
| } |
| *value = rtc::GetBE32(static_cast<const uint8_t*>(data) + offset); |
| return true; |
| } |
| |
| bool SetUint8(void* data, size_t offset, uint8_t value) { |
| if (!data) { |
| return false; |
| } |
| rtc::Set8(data, offset, value); |
| return true; |
| } |
| |
| bool SetUint16(void* data, size_t offset, uint16_t value) { |
| if (!data) { |
| return false; |
| } |
| rtc::SetBE16(static_cast<uint8_t*>(data) + offset, value); |
| return true; |
| } |
| |
| bool SetUint32(void* data, size_t offset, uint32_t value) { |
| if (!data) { |
| return false; |
| } |
| rtc::SetBE32(static_cast<uint8_t*>(data) + offset, value); |
| return true; |
| } |
| |
| bool GetRtpFlags(const void* data, size_t len, int* value) { |
| if (len < kMinRtpPacketLen) { |
| return false; |
| } |
| return GetUint8(data, kRtpFlagsOffset, value); |
| } |
| |
| bool GetRtpPayloadType(const void* data, size_t len, int* value) { |
| if (len < kMinRtpPacketLen) { |
| return false; |
| } |
| if (!GetUint8(data, kRtpPayloadTypeOffset, value)) { |
| return false; |
| } |
| *value &= 0x7F; |
| return true; |
| } |
| |
| bool GetRtpSeqNum(const void* data, size_t len, int* value) { |
| if (len < kMinRtpPacketLen) { |
| return false; |
| } |
| return GetUint16(data, kRtpSeqNumOffset, value); |
| } |
| |
| bool GetRtpTimestamp(const void* data, size_t len, uint32_t* value) { |
| if (len < kMinRtpPacketLen) { |
| return false; |
| } |
| return GetUint32(data, kRtpTimestampOffset, value); |
| } |
| |
| bool GetRtpSsrc(const void* data, size_t len, uint32_t* value) { |
| if (len < kMinRtpPacketLen) { |
| return false; |
| } |
| return GetUint32(data, kRtpSsrcOffset, value); |
| } |
| |
| bool GetRtpHeaderLen(const void* data, size_t len, size_t* value) { |
| if (!data || len < kMinRtpPacketLen || !value) return false; |
| const uint8_t* header = static_cast<const uint8_t*>(data); |
| // Get base header size + length of CSRCs (not counting extension yet). |
| size_t header_size = kMinRtpPacketLen + (header[0] & 0xF) * sizeof(uint32_t); |
| if (len < header_size) return false; |
| // If there's an extension, read and add in the extension size. |
| if (header[0] & 0x10) { |
| if (len < header_size + sizeof(uint32_t)) |
| return false; |
| header_size += |
| ((rtc::GetBE16(header + header_size + 2) + 1) * sizeof(uint32_t)); |
| if (len < header_size) return false; |
| } |
| *value = header_size; |
| return true; |
| } |
| |
| bool GetRtpHeader(const void* data, size_t len, RtpHeader* header) { |
| return (GetRtpPayloadType(data, len, &(header->payload_type)) && |
| GetRtpSeqNum(data, len, &(header->seq_num)) && |
| GetRtpTimestamp(data, len, &(header->timestamp)) && |
| GetRtpSsrc(data, len, &(header->ssrc))); |
| } |
| |
| bool GetRtcpType(const void* data, size_t len, int* value) { |
| if (len < kMinRtcpPacketLen) { |
| return false; |
| } |
| return GetUint8(data, kRtcpPayloadTypeOffset, value); |
| } |
| |
| // This method returns SSRC first of RTCP packet, except if packet is SDES. |
| // TODO(mallinath) - Fully implement RFC 5506. This standard doesn't restrict |
| // to send non-compound packets only to feedback messages. |
| bool GetRtcpSsrc(const void* data, size_t len, uint32_t* value) { |
| // Packet should be at least of 8 bytes, to get SSRC from a RTCP packet. |
| if (!data || len < kMinRtcpPacketLen + 4 || !value) return false; |
| int pl_type; |
| if (!GetRtcpType(data, len, &pl_type)) return false; |
| // SDES packet parsing is not supported. |
| if (pl_type == kRtcpTypeSDES) return false; |
| *value = rtc::GetBE32(static_cast<const uint8_t*>(data) + 4); |
| return true; |
| } |
| |
| bool SetRtpSsrc(void* data, size_t len, uint32_t value) { |
| return SetUint32(data, kRtpSsrcOffset, value); |
| } |
| |
| // Assumes version 2, no padding, no extensions, no csrcs. |
| bool SetRtpHeader(void* data, size_t len, const RtpHeader& header) { |
| if (!IsValidRtpPayloadType(header.payload_type) || |
| header.seq_num < 0 || header.seq_num > UINT16_MAX) { |
| return false; |
| } |
| return (SetUint8(data, kRtpFlagsOffset, kRtpVersion << 6) && |
| SetUint8(data, kRtpPayloadTypeOffset, header.payload_type & 0x7F) && |
| SetUint16(data, kRtpSeqNumOffset, |
| static_cast<uint16_t>(header.seq_num)) && |
| SetUint32(data, kRtpTimestampOffset, header.timestamp) && |
| SetRtpSsrc(data, len, header.ssrc)); |
| } |
| |
| bool IsRtpPacket(const void* data, size_t len) { |
| if (len < kMinRtpPacketLen) |
| return false; |
| |
| return (static_cast<const uint8_t*>(data)[0] >> 6) == kRtpVersion; |
| } |
| |
| bool IsValidRtpPayloadType(int payload_type) { |
| return payload_type >= 0 && payload_type <= 127; |
| } |
| |
| bool ValidateRtpHeader(const uint8_t* rtp, |
| size_t length, |
| size_t* header_length) { |
| if (header_length) { |
| *header_length = 0; |
| } |
| |
| if (length < kMinRtpPacketLen) { |
| return false; |
| } |
| |
| size_t cc_count = rtp[0] & 0x0F; |
| size_t header_length_without_extension = kMinRtpPacketLen + 4 * cc_count; |
| if (header_length_without_extension > length) { |
| return false; |
| } |
| |
| // If extension bit is not set, we are done with header processing, as input |
| // length is verified above. |
| if (!(rtp[0] & 0x10)) { |
| if (header_length) |
| *header_length = header_length_without_extension; |
| |
| return true; |
| } |
| |
| rtp += header_length_without_extension; |
| |
| if (header_length_without_extension + kRtpExtensionHeaderLen > length) { |
| return false; |
| } |
| |
| // Getting extension profile length. |
| // Length is in 32 bit words. |
| uint16_t extension_length_in_32bits = rtc::GetBE16(rtp + 2); |
| size_t extension_length = extension_length_in_32bits * 4; |
| |
| size_t rtp_header_length = extension_length + |
| header_length_without_extension + |
| kRtpExtensionHeaderLen; |
| |
| // Verify input length against total header size. |
| if (rtp_header_length > length) { |
| return false; |
| } |
| |
| if (header_length) { |
| *header_length = rtp_header_length; |
| } |
| return true; |
| } |
| |
| // ValidateRtpHeader() must be called before this method to make sure, we have |
| // a sane rtp packet. |
| bool UpdateRtpAbsSendTimeExtension(uint8_t* rtp, |
| size_t length, |
| int extension_id, |
| uint64_t time_us) { |
| // 0 1 2 3 |
| // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |V=2|P|X| CC |M| PT | sequence number | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | timestamp | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | synchronization source (SSRC) identifier | |
| // +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ |
| // | contributing source (CSRC) identifiers | |
| // | .... | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| |
| // Return if extension bit is not set. |
| if (!(rtp[0] & 0x10)) { |
| return true; |
| } |
| |
| size_t cc_count = rtp[0] & 0x0F; |
| size_t header_length_without_extension = kMinRtpPacketLen + 4 * cc_count; |
| |
| rtp += header_length_without_extension; |
| |
| // Getting extension profile ID and length. |
| uint16_t profile_id = rtc::GetBE16(rtp); |
| // Length is in 32 bit words. |
| uint16_t extension_length_in_32bits = rtc::GetBE16(rtp + 2); |
| size_t extension_length = extension_length_in_32bits * 4; |
| |
| rtp += kRtpExtensionHeaderLen; // Moving past extension header. |
| |
| bool found = false; |
| // WebRTC is using one byte header extension. |
| // TODO(mallinath) - Handle two byte header extension. |
| if (profile_id == 0xBEDE) { // OneByte extension header |
| // 0 |
| // 0 1 2 3 4 5 6 7 |
| // +-+-+-+-+-+-+-+-+ |
| // | ID |length | |
| // +-+-+-+-+-+-+-+-+ |
| |
| // 0 1 2 3 |
| // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | 0xBE | 0xDE | length=3 | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | ID | L=0 | data | ID | L=1 | data... |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // ...data | 0 (pad) | 0 (pad) | ID | L=3 | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | data | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| const uint8_t* extension_start = rtp; |
| const uint8_t* extension_end = extension_start + extension_length; |
| |
| while (rtp < extension_end) { |
| const int id = (*rtp & 0xF0) >> 4; |
| const size_t length = (*rtp & 0x0F) + 1; |
| if (rtp + kOneByteExtensionHeaderLen + length > extension_end) { |
| return false; |
| } |
| // The 4-bit length is the number minus one of data bytes of this header |
| // extension element following the one-byte header. |
| if (id == extension_id) { |
| UpdateAbsSendTimeExtensionValue(rtp + kOneByteExtensionHeaderLen, |
| length, time_us); |
| found = true; |
| break; |
| } |
| rtp += kOneByteExtensionHeaderLen + length; |
| // Counting padding bytes. |
| while ((rtp < extension_end) && (*rtp == 0)) { |
| ++rtp; |
| } |
| } |
| } |
| return found; |
| } |
| |
| bool ApplyPacketOptions(uint8_t* data, |
| size_t length, |
| const rtc::PacketTimeUpdateParams& packet_time_params, |
| uint64_t time_us) { |
| RTC_DCHECK(data); |
| RTC_DCHECK(length); |
| |
| // if there is no valid |rtp_sendtime_extension_id| and |srtp_auth_key| in |
| // PacketOptions, nothing to be updated in this packet. |
| if (packet_time_params.rtp_sendtime_extension_id == -1 && |
| packet_time_params.srtp_auth_key.empty()) { |
| return true; |
| } |
| |
| // If there is a srtp auth key present then the packet must be an RTP packet. |
| // RTP packet may have been wrapped in a TURN Channel Data or TURN send |
| // indication. |
| size_t rtp_start_pos; |
| size_t rtp_length; |
| if (!UnwrapTurnPacket(data, length, &rtp_start_pos, &rtp_length)) { |
| RTC_NOTREACHED(); |
| return false; |
| } |
| |
| // Making sure we have a valid RTP packet at the end. |
| if (!IsRtpPacket(data + rtp_start_pos, rtp_length) || |
| !ValidateRtpHeader(data + rtp_start_pos, rtp_length, nullptr)) { |
| RTC_NOTREACHED(); |
| return false; |
| } |
| |
| uint8_t* start = data + rtp_start_pos; |
| // If packet option has non default value (-1) for sendtime extension id, |
| // then we should parse the rtp packet to update the timestamp. Otherwise |
| // just calculate HMAC and update packet with it. |
| if (packet_time_params.rtp_sendtime_extension_id != -1) { |
| UpdateRtpAbsSendTimeExtension(start, rtp_length, |
| packet_time_params.rtp_sendtime_extension_id, |
| time_us); |
| } |
| |
| UpdateRtpAuthTag(start, rtp_length, packet_time_params); |
| return true; |
| } |
| |
| } // namespace cricket |
