metasploit-framework/lib/msf/core/exploit/dcerpc.rb

# -*- coding: binary -*-
require 'rex/proto/dcerpc'
require 'rex/encoder/ndr'
require 'msf/core/exploit/dcerpc_epm'
require 'msf/core/exploit/dcerpc_mgmt'
require 'msf/core/exploit/dcerpc_lsa'

module Msf

###
#
# This mixin provides utility methods for interacting with a DCERPC service on
# a remote machine.  These methods may generally be useful in the context of
# exploitation.  This mixin extends the Tcp exploit mixin. Only one DCERPC
# service can be accessed at a time using this class.
#
###
module Exploit::Remote::DCERPC

  # Alias over the Rex DCERPC protocol modules
  DCERPCPacket   = Rex::Proto::DCERPC::Packet
  DCERPCClient   = Rex::Proto::DCERPC::Client
  DCERPCResponse = Rex::Proto::DCERPC::Response
  DCERPCUUID     = Rex::Proto::DCERPC::UUID
  NDR            = Rex::Encoder::NDR


  # Support TCP-based RPC services
  include Exploit::Remote::Tcp

  # Helper methods for specific services
  include Exploit::Remote::DCERPC_EPM
  include Exploit::Remote::DCERPC_MGMT
  include Exploit::Remote::DCERPC_LSA

  def initialize(info = {})
    super

    register_evasion_options(
      [
        OptInt.new('DCERPC::max_frag_size',   [ true, 'Set the DCERPC packet fragmentation size', 4096]),
        OptBool.new('DCERPC::fake_bind_multi', [ false, 'Use multi-context bind calls', true ]),
        OptInt.new('DCERPC::fake_bind_multi_prepend',  [ false, 'Set the number of UUIDs to prepend before the target', 0]),
        OptInt.new('DCERPC::fake_bind_multi_append',   [ false, 'Set the number of UUIDs to append the target', 0]),
        OptEnum.new('DCERPC::smb_pipeio', [ false, 'Use a different delivery method for accessing named pipes', 'rw', ['rw', 'trans']] )

      ], Msf::Exploit::Remote::DCERPC)

    register_options(
      [
        Opt::RHOST,
        Opt::RPORT(135),
      ], Msf::Exploit::Remote::DCERPC)

    register_advanced_options(
      [
        OptInt.new('DCERPC::ReadTimeout',   [ true, 'The number of seconds to wait for DCERPC responses', 10] )
      ], Msf::Exploit::Remote::DCERPC)

  end

  def dcerpc_handle(uuid, version, protocol, opts)
    self.handle = Rex::Proto::DCERPC::Handle.new([uuid, version], protocol, rhost, opts)
  end

  def dcerpc_bind(h)
    opts = { 'Msf' => framework, 'MsfExploit' => self }

    if datastore['DCERPC::max_frag_size']
      opts['frag_size'] = datastore['DCERPC::max_frag_size']
    end

    if datastore['DCERPC::fake_bind_multi']
      opts['fake_multi_bind'] = 1

      if datastore['DCERPC::fake_bind_multi_prepend']
        opts['fake_multi_bind_prepend'] = datastore['DCERPC::fake_bind_multi_prepend']
      end

      if datastore['DCERPC::fake_bind_multi_append']
        opts['fake_multi_bind_append'] = datastore['DCERPC::fake_bind_multi_append']
      end
    end

    opts['connect_timeout'] = (datastore['ConnectTimeout'] || 10).to_i

    opts['read_timeout']    = (datastore['DCERPC::ReadTimeout'] || 10).to_i


    # Configure the SMB evasion options

    if (datastore['SMBUser'])
      opts['smb_user'] = datastore['SMBUser']
    end

    if (datastore['SMBPass'])
      opts['smb_pass'] = datastore['SMBPass']
    end

    if (datastore['DCERPC::smb_pipeio'])
      opts['smb_pipeio'] = datastore['DCERPC::smb_pipeio']
    end

    if (datastore['SMB::pipe_write_min_size'])
      opts['pipe_write_min_size'] = datastore['SMB::pipe_write_min_size']
    end

    if (datastore['SMB::pipe_write_max_size'])
      opts['pipe_write_max_size'] = datastore['SMB::pipe_write_max_size']
    end

    if (datastore['SMB::pipe_read_min_size'])
      opts['pipe_read_min_size'] = datastore['SMB::pipe_read_min_size']
    end

    if (datastore['SMB::pipe_read_max_size'])
      opts['pipe_read_max_size'] = datastore['SMB::pipe_read_max_size']
    end

    if (self.respond_to?('simple') and self.simple)
      opts['smb_client'] = self.simple
    end

    # Create the DCERPC client
    self.dcerpc = Rex::Proto::DCERPC::Client.new(h, self.sock, opts)

    if (self.handle.protocol == 'ncacn_np' and not self.simple)
      self.simple = self.dcerpc.smb  # expose the simple client if we have access to it
    end
  end

  def dcerpc_call(function, stub = '', timeout=nil, do_recv=true)
    otimeout = dcerpc.options['read_timeout']

    begin
      dcerpc.options['read_timeout'] = timeout if timeout
      dcerpc.call(function, stub, do_recv)
    rescue ::Rex::Proto::SMB::Exceptions::NoReply, Rex::Proto::DCERPC::Exceptions::NoResponse
      print_status("The DCERPC service did not reply to our request")
      return
    ensure
      dcerpc.options['read_timeout'] = otimeout
    end
  end

  # Convert a standard ASCII string to 16-bit Unicode
  def unicode(str)
    Rex::Text.to_unicode(str)
  end

  # Useful accessors for tracking DCERPC state
  attr_accessor	:handle, :dcerpc

end

end