def main(options, arguments):
if options.input != None:
buff = ""
arscobj = None
ret_type = androconf.is_android(options.input)
if ret_type == "APK":
a = apk.APK(options.input)
arscobj = a.get_android_resources()
elif ret_type == "ARSC":
arscobj = apk.ARSCParser(read(options.input))
else:
# print("Unknown file type")
return
if not options.package and not options.type and not options.locale:
buff = ""
for package in arscobj.get_packages_names():
buff += package + "\n"
for locale in arscobj.get_locales(package):
buff += "\t" + repr(locale) + "\n"
for ttype in arscobj.get_types(package, locale):
buff += "\t\t" + ttype + "\n"
else:
package = options.package or arscobj.get_packages_names()[0]
ttype = options.type or "public"
locale = options.locale or '\x00\x00'
buff = minidom.parseString(
getattr(arscobj,
"get_" + ttype + "_resources")(package,
locale)).toprettyxml()
if options.output != None:
fd = codecs.open(options.output, "w", "utf-8")
fd.write(buff)
fd.close()
else:
# print(buff)
psdd
elif options.version != None:
# print("Androarsc version %s" % androconf.ANDROGUARD_VERSION)
pass
def getInfo():
global targeApk
#### 用列表搜集需要的信息
cell_List = []
targeApk = apk.APK(rawFile, True)
targeDex = targeApk.get_dex()
apkMd5 = hashlib.md5(rawFile).hexdigest().upper()
##文件名称、文件MD5、DEX MD5、文件大小
fileName = apkMd5 + ".apk"
cell_List.append(fileName)
cell_List.append(apkMd5)
dexMd5 = hashlib.md5(targeDex).hexdigest().upper()
cell_List.append(dexMd5)
fileSize = format(os.path.getsize(f.name), ',') + " 字节"
cell_List.append(fileSize.lstrip())
##app名称、包名、签名（issuer）、证书串号、公钥MD5、公钥SHA1、
apkName = targeApk.get_app_name()
cell_List.append(apkName)
apkPackageName = targeApk.get_package()
cell_List.append(apkPackageName)
apkSign = getSign() ###一段蹩脚的签名获取方法，后去可用keytool工具直接获取
cell_List.append(apkSign["Issuer"])
cell_List.append(apkSign["SerialNumber"])
cell_List.append(apkSign["signMd5"])
cell_List.append(apkSign["signSha1"])
### 操作word
doc = Document("test.docx")
table = doc.tables[0]
#table.rows[1].cells[2].text = fileName 这种方式废弃
#table.rows[2].cells[2].text = apkMd5
#table.rows[3].cells[2].text = dexMd5
for i in range(1, 11):
run = table.rows[i].cells[2].paragraphs[0].add_run(
cell_List[i - 1]) ###或者写成 table.rows(i, 2)
run.font.name = '仿宋_GB2312'
run.font.size = 175000
doc.save("test1.docx")
###是否结束？清理工作
print("everything is done, exit?")
_ = input()
f.close()
return
def predict(self, apk_path):
# if apk_path is APK
ret_type = androconf.is_android(apk_path)
if ret_type == "APK":
try:
a = apk.APK(apk_path)
if a.is_valid_APK():
apk_permissions = self.get_permission_from_apk(a)
predict_vector = self.create_permission_vector(
self.stand_permissions, apk_permissions)
return self.predictor.predict([predict_vector])
else:
logger.info("INVALID")
raise AdDetectorException('There is not a valid apk!!!')
except Exception, e:
logger.info(e.message)
def get_icon(apk_path, res_dir):
"""Returns a dict with isHidden boolean and a relative path
path is a full path (not relative to resource folder) """
try:
print("[INFO] Fetching icon path")
a = apk.APK(apk_path)
icon_name = a.get_app_icon(max_dpi=65536)
if len(icon_name) > 0:
return {
'path': os.path.join(os.path.dirname(apk_path), icon_name),
'hidden': False
}
return {
'path': guess_icon_path(res_dir),
'hidden': True
}
except:
PrintException("[ERROR] Fetching icon function")
def __init__(self, path_to_apk: str):
self.path_to_apk = path_to_apk
self.androlyzed_apk = apk.APK(self.path_to_apk)
self.package_name = self.androlyzed_apk.get_package()
self.main_activity = self.androlyzed_apk.get_main_activity()
# used for strace and artist
self.x86 = self.check_x86_version()
# entrypoints used by Androguard
# IMPORTANT!!! androguard removes from this list, no guarantee that all entrypoints are contained
self.activities = None
self.services = None
self.receivers = None
self.act_count = 0
self.service_count = 0
self.receiver_count = 0
def extract_config(self, apkfile):
self.apkfile = apkfile
a = apk.APK(self.apkfile)
d = dvm.DalvikVMFormat(a.get_dex())
bLegit = False
for cls in d.get_classes():
c2 = ""
szVersion = ""
szPrefix = ""
szNum = ""
string = None
bFound = False
if 'Constants;'.lower() in cls.get_name().lower():
for method in cls.get_methods():
if '<clinit>'.lower() in str(
method).lower() and bFound == False:
for inst in method.get_instructions():
if inst.get_name() == 'const-string':
string = inst.get_output().split(
',')[-1].strip(" '")
szTemp = string
if inst.get_name() == 'const/4':
string = inst.get_output().split(
',')[-1].strip(" '")
szNum = string
if inst.get_name() == 'sput-object':
if "SERVER" in inst.get_output():
c2 = szTemp
if "VERSION" in inst.get_output():
szVersion = szTemp
if inst.get_name() == 'sput':
if 'PREFIX_ID' in inst.get_output():
szPrefix = szNum
bFound = True
if self.isNotEmpty(c2):
_log('[+] Extracting from %s' % self.apkfile)
_log('[+] C&C: [ %s ]' % c2)
_log('[+] Version : [ %s ]' % szVersion)
_log('[+] Prefix ID : [ %s ]' % szPrefix)
return True
if bFound == False:
_log('[-] This is probably not Flex Botnet or a variant : %s' %
self.apkfile)
return False
def strings_from_apk(app_file, app_dir, elf_strings):
"""Extract the strings from an app."""
try:
logger.info('Extracting Strings from APK')
dat = []
secrets = []
apk_file = os.path.join(app_dir, app_file)
and_a = apk.APK(apk_file)
rsrc = and_a.get_android_resources()
pkg = rsrc.get_packages_names()[0]
rsrc.get_strings_resources()
for i in rsrc.values[pkg].keys():
res_string = rsrc.values[pkg][i].get('string')
if res_string:
for duo in res_string:
cap_str = '"' + duo[0] + '" : "' + duo[1] + '"'
if is_secret(duo[0] + '"'):
secrets.append(cap_str)
dat.append(cap_str)
data_string = ''.join(dat)
urls, urls_nf, emails_nf = url_n_email_extract(
data_string, 'Android String Resource')
if elf_strings:
for solib in elf_strings:
for so, str_list in solib.items():
# add to strings from jar
dat.extend(str_list)
# extract url, email
so_str = ' '.join(str_list)
su, suf, sem = url_n_email_extract(so_str, so)
urls.extend(su)
urls_nf.extend(suf)
emails_nf.extend(sem)
strings_dat = list(set(dat))
return {
'strings': strings_dat,
'urls_list': urls,
'url_nf': urls_nf,
'emails_nf': emails_nf,
'secrets': secrets,
}
except Exception:
logger.exception('Extracting Strings from APK')
return {}
def extract_config(apkfile):
"""
This extracts the C&C information from Fanta or Gugi.
"""
a = apk.APK(apkfile)
d = dvm.DalvikVMFormat(a.get_dex())
for cls in d.get_classes():
if 'Lcom/fanta/services/SocketService;'.lower() in cls.get_name(
).lower():
c2 = ""
string = None
for method in cls.get_methods():
if 'Lcom/fanta/services/SocketService;->b()V' in str(method):
for inst in method.get_instructions():
if inst.get_name() == 'const-string':
string = inst.get_output().split(',')[-1].strip(
" '")
if ":" in string:
c2 = string
elif 'init' in method.name:
for inst in method.get_instructions():
if inst.get_name() == 'const-string':
string = inst.get_output().split(',')[-1].strip(
" '")
if ":" in string:
c2 = string
if isNotEmpty(c2):
log.debug('Extracting from %s' % apkfile)
log.debug('C&C: [ %s ]' % c2)
elif 'Lru/drink/lime/a/d;'.lower() in cls.get_name().lower():
c2 = ""
string = None
for method in cls.get_methods():
if 'a(Landroid/database/sqlite/SQLiteDatabase;)' in str(
method):
for inst in method.get_instructions():
if inst.get_name() == 'const-string':
string = inst.get_output().split(',')[-1].strip(
" '")
if ":" in string:
c2 = string
if isNotEmpty(c2):
log.debug('Extracting from %s' % apkfile)
log.debug('C&C: [ %s ]' % c2)
def get_base_info(apk_path):
app = apk.APK(apk_path)
detail_dir = apk_path + "_info"
if not (os.path.exists(detail_dir) and os.path.isdir(detail_dir)):
os.makedirs(detail_dir)
if not apk_path.endswith(".apk"):
apk_name = apk_path.split("\\")[-1]
tmp_path = os.path.join(detail_dir, apk_name + ".apk")
shutil.copy(apk_path, tmp_path)
apk_path = tmp_path
base_info = {
"packagename": app.get_package(),
"application_name": app.get_app_name(),
"main_activity": app.get_main_activity(),
"apk_path": apk_path,
"detail_dir": detail_dir
}
return base_info
def makefeeder(filein, fileout):
root = etree.Element("root")
app = apk.APK(filein)
addElement(root, 'sdkmin', app.get_min_sdk_version())
addElement(root, 'sdktarget', app.get_target_sdk_version())
#print "****************the .apk contents are************"
#for afile in app.get_files():
#print afile
#print "**************************************************"
#print "the sdk version and permissions needed are"
#print ""
for areceiver in app.get_receivers():
#print areceiver
addElement(root, 'receiver', areceiver)
for act in app.get_elements("activity", "android:name"):
#print act
addElement(root, 'activity', act)
for action in app.get_elements("action", "android:name"):
#print action
addElement(root, 'action', action)
dx = analysis.VMAnalysis(dvm.DalvikVMFormat(app.get_dex()))
for perm in dx.get_permissions([]):
#print perm
addElement(root, 'rint', perm)
for perm in app.get_permissions():
#print perm
addElement(root, 'permission', perm)
addElement(root, 'package', app.get_package())
feed = open(fileout, 'w')
s = etree.tostring(root, pretty_print=True)
feed.write(s)
feed.close()
def strings_jar(app_file, app_dir):
"""Extract the strings from an app."""
try:
logger.info("Extracting Strings from APK")
dat = []
apk_file = os.path.join(app_dir, app_file)
and_a = apk.APK(apk_file)
rsrc = and_a.get_android_resources()
pkg = rsrc.get_packages_names()[0]
rsrc.get_strings_resources()
for i in rsrc.values[pkg].keys():
string = rsrc.values[pkg][i].get('string')
if string is None:
return dat
for duo in string:
dat.append('"'+duo[0]+'" : "'+duo[1]+'"')
return dat
except:
PrintException("[ERROR] Extracting Strings from APK")
def main(options, arguments) :
sessionip = "127.0.0.1"
sessionport = 31415
if options.remotehost :
sessionip = options.remotehost
if options.port :
sessionport = int(options.port)
newsession = Session(sessionip, sessionport, "bind")
# Check if connection can be established
if newsession.executeCommand("core", "ping", None).data == "pong":
if options.list :
request = {'filter': options.list, 'permissions': None }
apks_info = newsession.executeCommand("packages", "info", {}).getPaddedErrorOrData()
print apks_info
elif options.input and options.output :
s = None
if options.database != None or options.config != None :
s = dalvik_elsign.MSignature( options.database, options.config, options.verbose != None, ps = dalvik_elsign.PublicSignature)
request = {'filter': options.input, 'permissions': None }
apks_info = newsession.executeCommand("packages", "info", request).getPaddedErrorOrData()
print apks_info
for i in apks_info.split("\n") :
if re.match("APK path:", i) != None :
name_app = i.split(":")[1][1:]
print name_app,
response = newsession.downloadFile(name_app, options.output)
print response.data, response.error,
if s != None :
a = apk.APK( options.output + "/" + os.path.basename(name_app) )
if a.is_valid_APK() :
display( s.check_apk( a ), options.verbose )
print
else:
print "\n**Network Error** Could not connect to " + sessionip + ":" + str(sessionport) + "\n"
def get_app_name(app_path, app_dir, tools_dir, is_apk):
"""Get app name."""
if is_apk:
a = apk.APK(app_path)
real_name = a.get_app_name()
return real_name
else:
strings_path = os.path.join(app_dir, 'app/src/main/res/values/')
eclipse_path = os.path.join(app_dir, 'res/values/')
if os.path.exists(strings_path):
strings_dir = strings_path
elif os.path.exists(eclipse_path):
strings_dir = eclipse_path
else:
strings_dir = ''
if not os.path.exists(strings_dir):
logger.warning('Cannot find values folder.')
return ''
return get_app_name_from_values_folder(strings_dir)
def get_permission(self, apk_path, label):
permission = []
labels = []
merge_permission = {}
for temp in os.listdir(apk_path):
path = os.path.join(apk_path, temp)
ret_type = androconf.is_android(path)
if ret_type == "APK":
a = apk.APK(path)
if a.is_valid_APK():
permissions = a.get_requested_permissions()
temp_l = []
for i in permissions:
temp_l.append(i.split(".")[-1])
permission.append(self.conver_vector(temp_l))
labels.append(label)
merge_permission[temp] = temp_l
# return merge_permission
return [permission, labels]
def execute(self):
"""
Executes the static analysis of APK using the androguard framework.
First parses the APK the get corresponding python object.
Then calls the androguard methods on the built object.
"""
sys.path.append(self.androguardPath)
from androguard.core.bytecodes import dvm
from androguard.core.bytecodes import apk
self._logger.info("Analyzing {0} with androguard...".format(
self.apkToAnalyze))
# Parse APK
parsedAPK = apk.APK(self.apkToAnalyze)
if parsedAPK is None:
raise Exception("Parsed APK is null, quitting StaticAnalysis.")
# Info: setters are dealing with None returns
try:
self.androidVersionCode = parsedAPK.get_androidversion_code()
self.androidVersionName = parsedAPK.get_androidversion_name()
self.mainActivity = parsedAPK.get_main_activity()
self.maxSDKVersion = parsedAPK.get_max_sdk_version()
if self.maxSDKVersion == "n/c":
self.maxSDKVersion = -1
self.minSDKVersion = parsedAPK.get_min_sdk_version()
if self.minSDKVersion == "n/c":
self.minSDKVersion = -1
self.packageName = parsedAPK.get_package()
self.timestamp = str(int(round(time.time() * 1000)))
self.activities = parsedAPK.get_activities()
self.permissions = parsedAPK.get_permissions()
self.providers = parsedAPK.get_providers()
self.receivers = parsedAPK.get_receivers()
self.services = parsedAPK.get_services()
self.libraries = parsedAPK.get_libraries()
except Exception, e:
self._logger.warn(
"An error occured while executing the static analysis of APK {0}: {1}"
.format(self.apkToAnalyze, e))
def get_icon(apk_path, res_dir):
"""Returns a dict with isHidden boolean and a relative path
path is a full path (not relative to resource folder) """
try:
logger.info("Fetching icon path")
a = apk.APK(apk_path)
icon_resolution = 0xFFFE - 1
icon_name = a.get_app_icon(max_dpi=icon_resolution)
if icon_name:
if '.xml' in icon_name:
return {'path': guess_icon_path(res_dir), 'hidden': False}
else:
return {
'path': os.path.join(os.path.dirname(apk_path), icon_name),
'hidden': False
}
return {'path': guess_icon_path(res_dir), 'hidden': True}
except:
PrintException("Fetching icon function")
def check_one_directory(directory):
for root, dirs, files in os.walk(directory, followlinks=True):
if files != []:
for f in files:
real_filename = root
if real_filename[-1] != "/":
real_filename += "/"
real_filename += f
print("filename: %s ..." % real_filename)
ret_type = androconf.is_android(real_filename)
if ret_type == "APK":
a = apk.APK(real_filename)
d1 = dvm.DalvikVMFormat(a.get_dex())
elif ret_type == "DEX":
d1 = dvm.DalvikVMFormat(read(real_filename))
dx1 = analysis.VMAnalysis(d1)
check_one_file(d1, dx1)
def __init__(self, name):
"""
:param name: filename to load
"""
self.vma = analysis.Analysis()
# Proper detection which supports multidex inside APK
ftype = androconf.is_android(name)
if ftype == 'APK':
for d in apk.APK(name).get_all_dex():
self.vma.add(dvm.DalvikVMFormat(d))
elif ftype == 'DEX':
self.vma.add(dvm.DalvikVMFormat(read(name)))
elif ftype == 'DEY':
self.vma.add(dvm.DalvikOdexVMFormat(read(name)))
else:
raise ValueError("Format not recognised for filename '%s'" % name)
self.classes = {dvclass.orig_class.get_name(): dvclass.orig_class for dvclass in self.vma.get_classes()}
def androguard_load_from_path(apk_file_path):
''' Load a FastApk from path with the help of androguard.
Notes
-----
Androguard cannot read data properly from manifest files which do not have the android prefix.
Parameters
----------
apk_file_path: str
path of apk
Returns
-------
apk: FastApk
'''
from androguard.core.bytecodes import apk as androapk
aapk = androapk.APK(apk_file_path)
return FastApk(aapk.get_package(), aapk.get_androidversion_name(),
apk_file_path)
def get_permissions(path):
"""
Get the permissions from an app.
Parameters:
path - The path of the app to be decompiled
Returns:
A sorted list of permissions
"""
app = apk.APK(path)
perms = app.get_permissions()
# Make sure there is no redundancies, and then sort the list.
perms = list(set(perms))
perms.sort()
return perms
def verifyWhiteBroad(self, apkfile):
self.apkfile = apkfile
iNum = 0
a = apk.APK(apkfile)
szPackageName = a.get_package()
if szPackageName == "com.red.rainbow":
bRes = self.extract_config(self.apkfile)
return bRes
elif "com.android.hellon" in szPackageName:
bRes = self.extract_config2(self.apkfile)
return bRes
elif "cn.close.vcl.play" in szPackageName:
bRes = self.extract_config(self.apkfile)
return bRes
else:
szPermissions = " ".join(a.get_permissions())
matchObj = re.search(r'android\.permission\.INTERNET',
szPermissions,
re.DOTALL | re.UNICODE | re.M | re.I)
if matchObj:
iNum += 1
szActivities = "".join(a.get_activities())
matchObj = re.search(r'activity\.MainActivity', szActivities,
re.DOTALL | re.UNICODE | re.M | re.I)
if matchObj:
iNum += 1
szReceivers = "".join(a.get_receivers())
matchObj = re.search(r'receiver\.ShowReceiver', szReceivers,
re.DOTALL | re.UNICODE | re.M | re.I)
if matchObj:
iNum += 1
szServices = "".join(a.get_services())
matchObj = re.search(r'call\.service\.New1Services', szServices,
re.DOTALL | re.UNICODE | re.M | re.I)
if matchObj:
iNum += 1
if iNum == 4:
bRes = self.extract_config(self.apkfile)
return bRes
else:
_log("[-] This is not WhiteBroad")
def main(options, arguments):
if options.input is not None:
ret_type = androconf.is_android(options.input)
if ret_type == "APK":
a = apk.APK(options.input)
axml = a.get_android_manifest_xml()
elif ".xml" in options.input:
axml = apk.AXMLPrinter(read(options.input)).get_xml_obj()
else:
print("Unknown file type")
return
buff = etree.tostring(axml, pretty_print=True)
if options.output:
with open(options.output, "wb") as fd:
fd.write(buff)
else:
print(buff.decode("UTF-8"))
elif options.version is not None:
print("Androaxml version %s" % androconf.ANDROGUARD_VERSION)
def extract_config(self, apkfile):
self.apkfile = apkfile
a = apk.APK(self.apkfile)
d = dvm.DalvikVMFormat(a.get_dex())
for cls in d.get_classes():
if 'update/app/a;'.lower() in cls.get_name().lower():
_log("[+] It's APT-C-23")
c2 = []
string = None
for method in cls.get_methods():
if 'a;-><clinit>()v'.lower() in str(method).lower():
for inst in method.get_instructions():
if inst.get_name() == 'const-string':
string = inst.get_output().split(',')[-1].strip(" '")
if "http://" in string:
c2.append(string)
if self.isNotEmpty(c2[0]):
_log('[+] Extracting from %s' % (self.apkfile))
for CC in c2:
_log("[+] Extracted C2: %s" % CC)
return True
def main(options, arguments) :
if options.input != None and options.output != None and options.name != None and options.subname != None :
edi = ElsimDBIn( options.output )
ret_type = androconf.is_android( options.input )
if ret_type == "APK" :
a = apk.APK( options.input )
d1 = dvm.DalvikVMFormat( a.get_dex() )
elif ret_type == "DEX" :
d1 = dvm.DalvikVMFormat( open(options.input, "rb").read() )
dx1 = analysis.VMAnalysis( d1 )
regexp_pattern = None
regexp_exclude_pattern = None
edi.add( d1, dx1, options.name, options.sname, regexp_pattern, regexp_exclude_pattern)
edi.save()
elif options.version != None :
print "Androapptodb version %s" % androconf.ANDROGUARD_VERSION
def _analyze(self):
for i in self.__files:
ret_type = androconf.is_android(i)
if ret_type == "APK":
x = apk.APK(i)
bc = dvm.DalvikVMFormat(x.get_dex())
elif ret_type == "DEX":
bc = dvm.DalvikVMFormat(open(i, "rb").read())
elif ret_type == "DEY":
bc = dvm.DalvikOdexVMFormat(open(i, "rb").read())
elif ret_type == "ELF":
from androguard.core.binaries import elf
bc = elf.ELF(open(i, "rb").read())
else:
raise ("Unknown format")
if isinstance(bc, list):
for j in bc:
self.__bc.append((j[0], BC(jvm.JVMFormat(j[1]))))
else:
self.__bc.append((i, BC(bc)))
def _use_check_ad():
for root, dirs, files in os.walk(TRAIN_APK_PATH, followlinks=True):
if files:
for f in files:
real_filename = root
if real_filename[-1] != "/":
real_filename += "/"
real_filename += f
ret_type = androconf.is_android(real_filename)
if ret_type == "APK":
logger.info(os.path.basename(real_filename) + ':')
try:
a = apk.APK(real_filename)
if a.is_valid_APK():
check_adware_from_config(a)
else:
logger.info("INVALID")
except Exception, e:
logger.info(e)
else:
logger.error("directory not exits!!!")
def main():
_args = _parseargs()
_a = apk.APK(_args.file)
print("Analyse file: {:s}".format(_args.file))
print("Package name: {:s}".format(_a.get_package()))
_vm = dvm.DalvikVMFormat(_a.get_dex())
_vmx = uVMAnalysis(_vm)
if 'INTERNET' in _vmx.get_permissions([]):
print "App requires INTERNET permission. Continue analysis..."
_vm.create_python_export()
_gx = GVMAnalysis(_vmx, None)
_vm.set_vmanalysis(_vmx)
_vm.set_gvmanalysis(_gx)
_vm.create_dref(_vmx)
_vm.create_xref(_vmx)
_result = {
'trustmanager': [],
'hostnameverifier': [],
'onreceivedsslerror': []
}
_result = _check_all(_vm, _vmx, _gx)
if not _args.xml:
_print_result(_result, _java=_args.java)
else:
_xml_result(_a, _result)
if _args.dir:
print "Store decompiled Java code in {:s}".format(_args.dir)
_store_java(_vm, _args)
else:
print "App does not require INTERNET permission. No need to worry about SSL misuse... Abort!"
def initStatic(APKFile):
a = apk.APK(APKFile)
d = dvm.DalvikVMFormat(a.get_dex())
dx = analysis.VMAnalysis(d)
vm = dx.get_vm()
cm = vm.get_class_manager()
per = a.get_permissions()
pa = dx.get_permissions([])
USE = [p for p in SPECIAL_PERMS if "android.permission." + p in per]
specialPath = dx.get_tainted_packages().search_methods(
"Landroid/content/ContentResolver;", ".", ".")
specialPath += dx.get_tainted_packages().search_methods(
"Landroid/content/ContentProvider;", ".", ".")
specialPath += dx.get_tainted_packages().search_methods(
"Landroid/content/ContentProviderClient;", ".", ".")
specialPath += dx.get_tainted_packages().search_methods(
"Landroid/net/Uri;", "parse", ".")
if len(specialPath) > 0 and len(USE) > 0:
for i in USE:
pa[i] = specialPath
for i in pa:
if i in PERM_DESCRIPTION:
met = set()
for j in pa[i]:
t = returnMethod(j, cm)
if t != 0:
met.add(t)
permap[i] = met
execPath = dx.get_tainted_packages().search_methods(
"Ljava/lang/Runtime;", "exec", ".")
if len(execPath) > 0:
met = set()
for j in execPath:
t = returnMethod(j, cm)
if t != 0:
met.add(t)
permap['CMD_EXEC'] = met
def __init__(self, apkFile):
self.sha256 = self.sha256CheckSum(apkFile)
print("[-] Parsing APK")
self.a = apk.APK(apkFile)
print("[-] Baksmaling DEX files")
self.baksmali(apkFile)
self.manifest = self.a.get_android_manifest_axml().get_xml_obj()
self.application = self.manifest.findall("application")[0]
print("[+] Gathering Information")
self.extractActivitiesWithExcludeFromRecents()
self.extractActivitiesWithoutSecureFlag()
print(" [-] Package Properties")
self.extractPackageProperties()
print(" [-] Exported Components")
self.extractExportedComponents()
print(" [-] Permissions")
self.extractPermissions()
print(" [-] Files")
self.extractFiles()
print("[-] Exporting analysis")
self.exportAnalysis()
def main(options, arguments):
if options.input != None and options.database != None:
ret_type = androconf.is_android(options.input)
if ret_type == "APK":
a = apk.APK(options.input)
d1 = dvm.DalvikVMFormat(a.get_dex())
elif ret_type == "DEX":
d1 = dvm.DalvikVMFormat(read(options.input))
dx1 = analysis.VMAnalysis(d1)
check_one_file(d1, dx1)
elif options.directory != None and options.database != None:
check_one_directory(options.directory)
elif options.database != None and options.listdatabase != None:
db = DBFormat(options.database)
db.show()
elif options.version != None:
print("Androappindb version %s" % androconf.ANDROGUARD_VERSION)
