SRTP requires an external key exchange mechanism for sharing its session keys , and DTLS-SRTP does that by multiplexing the DTLS-SRTP. Datagram Transport Layer Security (DTLS) is a communications protocol that provides security Real-time Transport Protocol (SRTP) subsequently called DTLS-SRTP in a draft with Secure Real-Time Transport Control Protocol (SRTCP ). DTLS-SRTP tries to repurpose itself to VoIP’s peer-to-peer environment, but it cannot escape its client-server roots, and that’s why it depends so.

Author: Tojataur Kazraramar
Country: El Salvador
Language: English (Spanish)
Genre: Video
Published (Last): 20 October 2017
Pages: 11
PDF File Size: 13.55 Mb
ePub File Size: 9.76 Mb
ISBN: 472-6-77117-955-9
Downloads: 21493
Price: Free* [*Free Regsitration Required]
Uploader: Jukree

Web Real-Time Communication abbreviated as WebRTC is a recent trend in web application technology, which promises the ability to enable real-time communication in the browser without the need for plug-ins or other requirements. However, the open-source nature of the technology may have the potential to cause security-related concerns to potential adopters of the technology.

This paper will discuss in detail the security of WebRTC, with the aim of demonstrating the comparative security of the technology. WebRTC is an open-source web-based application technology, which allows users to send real-time media without the need for installing plugins.

Using a suitable browser can enable a user to call another party simply by browsing to the relevant webpage. Unlike most real-time systems e. The prospect of enabling embedded audio and visual communication in a browser without plugins is exciting. However, this naturally raises concerns over the dgls of such technology, and whether it can be trusted to provide reliable communication for both the end users and any intermediary carriers or tdls parties. This report will address these topics and examine the protections that WebRTC provides to provide security in all cases.

For the purposes of this paper however, native applications will be treated as being out of scope. WebRTC resides within the user’s browser, and requires no additional software to operate. The actual communication between peers is prefaced by an exchange of metadata, termed “signalling”. This process is used to initiate and advertise calls, and facilitates connection establishment between unfamiliar parties. A signaling protocol dtl not specified within WebRTC, allowing developers to implement their own choice of protocol.

This allows for a deeper degree of flexibility in adapting a WebRTC app for a specific use case or scenario. WebRTC relies on three APIs, each of which performs a specific function in order to enable real-time communication within a web application.

These APIs will be named and explained briefly. The implementation and technical details of each protocol and technology are outside the scope of this report, however the relevant documentation is readily available online.

For many years it was necessary to rely on third-party browser plugins such as Flash or Silverlight to capture audio or video from a computer. However, the era of HTML 5 has ushered in direct hardware access to numerous devices, and provides JavaScript APIs wrtp interface with a system’s underlying hardware capabilities. When a caller wants to initiate a connection with a remote party, the browser starts by instantiating a RTCPeerConnection object.

This includes a self-generated SDP description to exchange with their peer.

Datagram Transport Layer Security

The recipient in turn responds with its own SDP description. With the connection now established, RTCPeerConnection enables the sending of real-time audio and video data as a bitstream between browsers. Ultimately, RTCPeerConnection API is responsible for managing the full life-cycle of zrtp peer-to-peer connection and encapsulates all the connection setup, management, and state within a single easy-to-use interface.

RTCPeerConnection has two specific traits: In other words, it is used dtps transfer data directly from one peer to another. Although a number of alternative options for communication channels exist e. WebSocket, Server Sent Eventshowever these alternatives were designed for communication with a server rather than a directly-connected peer.

RTCDataChannel resembles the popular WebSocket, but instead takes a peer-to-peer format while offering customisable delivery properties of the underlying transport. Finally, SCTP and SRTP are the application protocols used to multiplex the different streams, provide congestion and flow control, and provide partially reliable delivery and other additional services on top of UDP. Session Description Protocol SDP is a descriptive protocol that is used as a srt method of announcing and managing session invitations, as well as performing other initiation tasks for multimedia sessions.


SDP represents the browser capabilities and preferences in a text-based format, and may include the following information: Signalling requires the initial use of an intermediary server for the exchange of metadata, but upon completion WebRTC attempts to dtle a direct P2P connection between the users. This process is carried out through the ICE framework. ICE is a framework used for establishing a connection between peers over the internet. Due the continuing widespread prevalence of IPv4 addresses with their limited bit representation, most network-enabled devices do not have a unique public-facing IPv4 address with which it would be directly visible on the Internet.

NAT works by dynamically translating private addresses into public ones when an outbound request passes through them. Similarly, inbound requests to a public IP are converted back into a private IP to ensure correct routing on the internal network. Resultantly, sharing a private IP is often not enough information to establish sgtp connection srto a peer. ICE attempts to overcome the difficulties posed by communicating via NAT dtlls find the best path to connect peers.

By trying all possibilities in parallel, ICE is able dls choose the most efficient option that works. ICE first tries to make a connection using the host address obtained from a device’s operating system and dtos card; if that fails which it inevitably will for devices behind NATs ICE then obtains an external address using a STUN server. If that also fails, traffic falls back to routing via a TURN relay server.

The candidate communication routes are rendered in a text-based format, and the list ordered by priority. The options take the form of one of the following: In order to perform P2P communication, both parties necessarily require at least the knowledge of their peer’s IP address and the assigned UDP port.

Etls a result, a certain amount of information exchange is necessary before WebRTC communication can be established.

What about DTLS-SRTP? Why not use that? – Silent Circle

By relaying traffic between peers the WebRTC communication can be ensured, but can suffer degradations in media quality and latency. TURN servers can ensure high success in setting up calls, regardless of the end-user’s environments. As the data is sent through an intermediary server, server bandwidth is also consumed. If many calls are simultaneously routed through the server, the bandwidth was also become considerable in size.

The server itself is typically not freely accessible, and has to be specifically provided or rented by the application provider.

There are a number of ways in that a real-time communication application may impose security risks, both on the carrier and the end users. Such security risks can be applicable to any application which deals with the sdtp of real-time data and media.

tls – Why would one choose DTLS-SRTP versus just RTP over DTLS? – Cryptography Stack Exchange

WebRTC differs from other RTC apps by providing a strong and reliable infrastructure for even new developers to utilise without compromising xrtp security. We will now proceed to discuss how WebRTC deals with each of these risks in turn.

The WebRTC architecture assumes from a security perspective that network resources exist in a hierarchy of trust. The browser’s job is to enable access to the internet, while providing adequate security protections to the user. The security requirements of WebRTC are built directly upon this requirement; the browser is the portal through which the user accesses all WebRTC applications and content.

While HTML and JS provided by the server can cause the browser to execute a variety of actions, the browser segregates those scripts into sandboxes. Said sandboxes isolate scripts from each other, and from the user’s computer. Generally speaking, scripts are only allowed to interact with resources from the same domain – or more specifically, the same “origin”.

The browser enforces all security policies that the user desires and is the first step in the verification of all third parties. All authenticated entities have their identity checked by the browser.


If the user chooses a suitable browser which they know can trust, then all WebRTC communication sttp be considered “secure” and to follow the standard accepted security architecture of WebRTC technology. However, if there is any doubt that a browser is “trustable” e.

In other words, the level of trust provided to the user by WebRTC is directly influenced by the user’s trust in the browser. It is a fundamental aspect of the DOM that all webpage resources are fetched from the page’s web server, whenever some or all of the page is loaded. Fetching of resources takes place either when a page is freshly loaded by the browser, or when a script residing on a webpage makes such a request.

Such scripts are readily able to make HTTP requests via e. Rather, requests have to be made to the same “origin” from where the script originated.

An “origin” comprises of a URI scheme, hostname, and port number. SOP forces scripts to execute in isolated sandboxes specific to their originating domain, therefore preventing pages from different origins or even iframes on the same page from exchanging information.

As such, the origin constitutes the basic unit of web sandboxing. Through enforcing execution sandboxes on a per-origin basis, the end user is protected from the misuse of their credentials. You would reasonably expect to safely use a social networking website without a script executing from within an advertisement panel and stealing your login information.

Similarly, the servers of e. SOP is incredibly important for the security of both the user and web servers in general, although it does have the disadvantage of making certain types of web app harder to create.

Methods of permitting inter-site interaction do exist, although these are typically mutually consensual and limited to certain channels. It allows the browser to contact the script’s target server to determine whether it is willing to participate in a given type of transaction. As such, cross-origin requests can be safely allowed, by giving the target server the option to specifically opt-in to certain requests and decline all others.

WebSockets is another option allowing similar functionality, but on transparent channels rather than isolated HTTP requests. In both cases, the initial verification stage prevents the arbitrary transfer of data by a script with a different origin. A prevalent issue with traditional desktop software is whether one can trust the application itself. Installation of new software or a plugin can potentially surreptitiously install malware or other undesirable software.

Many end users have no idea where the software was made or exactly who they are downloading the app from.

Malicious third parties have had great success in repackaging perfectly safe and trusted software to include malware, and offering their custom package on free software websites.

WebRTC however is not a plugin, nor is there any installation process for any of its components. If a user has such a browser, they can browse to and use any WebRTC application with no other setup or preparation required. As such there is no risk of installation of malware or viruses through the use of an appropriate WebRTC application.

Another related consideration is the patching of discovered security flaws in software. As with any software technology, it is entirely possible that future bugs or vulnerabilities will be discovered in WebRTC. If a vulnerability is found in a traditional desktop application such as a typical VoIP applicationdevelopment of a patch may take considerable time.

This is a frequent issue with application development, as security is still often treated as a secondary consideration after functionality. Going deeper than this, we can contemplate hardware-based communication methods. How often does a VoIP phone get a security update? Can you trust the person responsible to update it regularly? Do you even know who is responsible?