supplier-meesho.webflow 1.0.0

package/MobSF/mobsf/DynamicAnalyzer/views/android/frida_core.py

@@ -0,0 +1,168 @@
+import os
+import glob
+import logging
+from pathlib import Path
+import sys
+import time
+
+from django.conf import settings
+
+import frida
+
+from mobsf.DynamicAnalyzer.views.android.environment import Environment
+from mobsf.DynamicAnalyzer.views.android.frida_scripts import (
+    class_pattern,
+    class_trace,
+    get_loaded_classes,
+    get_methods,
+    string_catch,
+    string_compare,
+)
+from mobsf.MobSF.utils import (
+    get_device,
+    is_file_exists,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class Frida:
+
+    def __init__(self, app_hash, package, defaults, auxiliary, extras, code):
+        self.hash = app_hash
+        self.package = package
+        self.defaults = defaults
+        self.auxiliary = auxiliary
+        self.extras = extras
+        self.code = code
+        self.frida_dir = os.path.join(settings.TOOLS_DIR,
+                                      'frida_scripts')
+        self.apk_dir = os.path.join(settings.UPLD_DIR, self.hash + '/')
+        self.api_mon = os.path.join(self.apk_dir, 'mobsf_api_monitor.txt')
+        self.frida_log = os.path.join(self.apk_dir, 'mobsf_frida_out.txt')
+        self.deps = os.path.join(self.apk_dir, 'mobsf_app_deps.txt')
+
+    def get_default_scripts(self):
+        """Get default Frida Scripts."""
+        combined_script = []
+        header = []
+        if not self.defaults:
+            return header
+        def_scripts = os.path.join(self.frida_dir, 'default')
+        files = glob.glob(def_scripts + '**/*.js', recursive=True)
+        for item in files:
+            script = Path(item)
+            if script.stem in self.defaults:
+                header.append('send("Loaded Frida Script - {}");'.format(
+                    script.stem))
+                combined_script.append(script.read_text())
+        return header + combined_script
+
+    def get_auxiliary(self):
+        """Get auxiliary hooks."""
+        scripts = []
+        if not self.auxiliary:
+            return scripts
+        for itm in self.auxiliary:
+            if itm == 'enum_class':
+                scripts.append(get_loaded_classes())
+            elif itm == 'get_dependencies':
+                scripts.append(get_loaded_classes().replace(
+                    '[AUXILIARY] ', '[RUNTIME-DEPS] '))
+            elif itm == 'string_catch':
+                scripts.append(string_catch())
+            elif itm == 'string_compare':
+                scripts.append(string_compare())
+            elif itm == 'enum_methods' and 'class_name' in self.extras:
+                scripts.append(get_methods(self.extras['class_name']))
+            elif itm == 'search_class' and 'class_search' in self.extras:
+                scripts.append(class_pattern(self.extras['class_search']))
+            elif itm == 'trace_class' and 'class_trace' in self.extras:
+                scripts.append(class_trace(self.extras['class_trace']))
+        return scripts
+
+    def get_script(self):
+        """Get final script."""
+        if not self.code:
+            self.code = ''
+        # Load custom code first
+        scripts = [self.code]
+        scripts.extend(self.get_default_scripts())
+        scripts.extend(self.get_auxiliary())
+        final = 'setTimeout(function() {{ {} }}, 0)'.format(
+            '\n'.join(scripts))
+        return final
+
+    def frida_response(self, message, data):
+        """Function to handle frida responses."""
+        if 'payload' in message:
+            msg = message['payload']
+            api_mon = 'MobSF-API-Monitor: '
+            aux = '[AUXILIARY] '
+            deps = '[RUNTIME-DEPS] '
+            if not isinstance(msg, str):
+                msg = str(msg)
+            if msg.startswith(api_mon):
+                self.write_log(self.api_mon, msg.replace(api_mon, ''))
+            elif msg.startswith(deps):
+                info = msg.replace(deps, '') + '\n'
+                self.write_log(self.deps, info)
+                self.write_log(self.frida_log, info)
+            elif msg.startswith(aux):
+                self.write_log(self.frida_log,
+                               msg.replace(aux, '[*] ') + '\n')
+            else:
+                logger.debug('[Frida] %s', msg)
+                self.write_log(self.frida_log, msg + '\n')
+        else:
+            logger.error('[Frida] %s', message)
+
+    def connect(self):
+        """Connect to Frida Server."""
+        session = None
+        device = None
+        try:
+            env = Environment()
+            self.clean_up()
+            env.run_frida_server()
+            device = frida.get_device(get_device(), settings.FRIDA_TIMEOUT)
+            pid = device.spawn([self.package])
+            logger.info('Spawning %s', self.package)
+            session = device.attach(pid)
+            time.sleep(2)
+        except frida.ServerNotRunningError:
+            logger.warning('Frida server is not running')
+            self.connect()
+        except frida.TimedOutError:
+            logger.error('Timed out while waiting for device to appear')
+        except (frida.ProcessNotFoundError,
+                frida.TransportError,
+                frida.InvalidOperationError):
+            pass
+        except Exception:
+            logger.exception('Error Connecting to Frida')
+        try:
+            if session:
+                script = session.create_script(self.get_script())
+                script.on('message', self.frida_response)
+                script.load()
+                device.resume(pid)
+                sys.stdin.read()
+                script.unload()
+                session.detach()
+        except (frida.ProcessNotFoundError,
+                frida.TransportError,
+                frida.InvalidOperationError):
+            pass
+        except Exception:
+            logger.exception('Error Connecting to Frida')
+
+    def clean_up(self):
+        if is_file_exists(self.api_mon):
+            os.remove(self.api_mon)
+        if is_file_exists(self.frida_log):
+            os.remove(self.frida_log)
+
+    def write_log(self, file_path, data):
+        with open(file_path, 'a') as flip:
+            flip.write(data)

package/MobSF/mobsf/DynamicAnalyzer/views/android/frida_scripts.py

@@ -0,0 +1,65 @@
+import os
+
+from django.conf import settings
+
+from mobsf.MobSF.utils import strict_package_check
+
+
+def get_content(file_name):
+    content = ''
+    script = os.path.join(settings.TOOLS_DIR,
+                          'frida_scripts',
+                          'auxiliary',
+                          file_name)
+
+    with open(script, 'r',
+              encoding='utf8',
+              errors='ignore') as scp:
+        content = scp.read()
+    return content
+
+
+def get_loaded_classes():
+    """Get Loaded classes."""
+    return get_content('get_loaded_classes.js')
+
+
+def string_catch():
+    """Capture all runtime strings."""
+    return get_content('string_catch.js')
+
+
+def string_compare():
+    """Capture all runtime string comparisons."""
+    return get_content('string_compare.js')
+
+
+def get_methods(klazz):
+    """Get Class methods and implementations."""
+    if not strict_package_check(klazz):
+        return ''
+    content = get_content('get_methods.js')
+    return content.replace('{{CLASS}}', klazz)
+
+
+def class_pattern(pattern):
+    """Search in loaded classes based on pattern."""
+    pattern = pattern.replace(
+        '/', '\\/').replace(';', '')
+    content = get_content('search_class_pattern.js')
+    return content.replace('{{PATTERN}}', pattern)
+
+
+def class_trace(classes):
+    """Trace all methods of a class."""
+    filtered = []
+    if ',' not in classes:
+        filtered.append(classes.strip())
+    else:
+        for clz in classes.split(','):
+            filtered.append(clz.strip())
+    for klz in filtered:
+        if not strict_package_check(klz):
+            return ''
+    content = get_content('class_trace.js')
+    return content.replace('{{CLASSES}}', str(filtered))

package/MobSF/mobsf/DynamicAnalyzer/views/android/frida_server_download.py

@@ -0,0 +1,75 @@
+# -*- coding: utf_8 -*-
+"""Download Frida Server."""
+import logging
+from pathlib import Path
+from lzma import LZMAFile
+from shutil import copyfileobj
+
+import requests
+
+from django.conf import settings
+
+from mobsf.MobSF.utils import (
+    is_internet_available,
+    upstream_proxy,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+def clean_up_old_binaries(dirc, version):
+    """Delete Old Binaries."""
+    for f in Path(dirc).iterdir():
+        if f.is_file() and f.name.startswith('frida-server'):
+            if version in f.name:
+                continue
+            try:
+                f.unlink()
+            except Exception:
+                pass
+
+
+def download_frida_server(url, version, fname):
+    """Download frida-server-binary."""
+    try:
+        download_dir = Path(settings.DWD_DIR)
+        logger.info('Downloading binary %s', fname)
+        dwd_loc = download_dir / fname
+        with requests.get(url, stream=True) as r:
+            with LZMAFile(r.raw) as f:
+                with open(dwd_loc, 'wb') as flip:
+                    copyfileobj(f, flip)
+        clean_up_old_binaries(download_dir, version)
+        return True
+    except Exception:
+        logger.exception('[ERROR] Downloading Frida Server Binary')
+    return False
+
+
+def update_frida_server(arch, version):
+    """Download Assets of a given version."""
+    download_dir = Path(settings.DWD_DIR)
+    fserver = f'frida-server-{version}-android-{arch}'
+    frida_bin = download_dir / fserver
+    if frida_bin.is_file():
+        return True
+    if not is_internet_available():
+        return False
+    try:
+        proxies, verify = upstream_proxy('https')
+    except Exception:
+        logger.exception('[ERROR] Setting upstream proxy')
+    try:
+        response = requests.get(f'{settings.FRIDA_SERVER}{version}',
+                                timeout=3,
+                                proxies=proxies,
+                                verify=verify)
+        for item in response.json()['assets']:
+            if item['name'] == f'{fserver}.xz':
+                url = item['browser_download_url']
+                return download_frida_server(url, version, fserver)
+        return False
+    except Exception:
+        logger.exception('[ERROR] Fetching Frida Server Release')
+    return False

package/MobSF/mobsf/DynamicAnalyzer/views/android/operations.py

@@ -0,0 +1,299 @@
+# -*- coding: utf_8 -*-
+"""Dynamic Analyzer Operations."""
+import json
+import logging
+import os
+import random
+import re
+import subprocess
+import threading
+from pathlib import Path
+
+from django.conf import settings
+from django.http import HttpResponse
+from django.views.decorators.http import require_http_methods
+
+from mobsf.DynamicAnalyzer.views.android.environment import (
+    Environment,
+)
+from mobsf.MobSF.utils import (
+    cmd_injection_check,
+    get_adb,
+    get_device,
+    is_md5,
+    is_number,
+)
+from mobsf.StaticAnalyzer.models import StaticAnalyzerAndroid
+
+logger = logging.getLogger(__name__)
+
+
+# Helpers
+
+def get_package_name(checksum):
+    """Get Package Name from DB or Device."""
+    try:
+        static_android_db = StaticAnalyzerAndroid.objects.get(
+            MD5=checksum)
+        return static_android_db.PACKAGE_NAME
+    except Exception:
+        pkg_file = Path(settings.DWD_DIR) / 'packages.json'
+        if not pkg_file.exists():
+            return None
+        with pkg_file.open(encoding='utf-8') as src:
+            packages = json.load(src)
+        if packages.get(checksum):
+            return packages[checksum][0]
+        return None
+
+
+def send_response(data, api=False):
+    """Return JSON Response."""
+    if api:
+        return data
+    return HttpResponse(
+        json.dumps(data),  # lgtm [py/stack-trace-exposure]
+        content_type='application/json')
+
+
+def is_attack_pattern(user_input):
+    """Check for attacks."""
+    atk_pattern = re.compile(r';|\$\(|\|\||&&')
+    stat = re.findall(atk_pattern, user_input)
+    if stat:
+        logger.error('Possible RCE attack detected')
+    return stat
+
+
+def invalid_params(api=False):
+    """Standard response for invalid params."""
+    msg = 'Invalid Parameters'
+    logger.error(msg)
+    data = {'status': 'failed', 'message': msg}
+    if api:
+        return data
+    return send_response(data)
+
+# AJAX
+
+
+@require_http_methods(['POST'])
+def mobsfy(request, api=False):
+    """Configure Instance for Dynamic Analysis."""
+    logger.info('MobSFying Android instance')
+    data = {}
+    msg = 'Connection failed'
+    try:
+        identifier = request.POST['identifier']
+        if cmd_injection_check(identifier):
+            # Additional Check, not required
+            data = {
+                'status': 'failed',
+                'message': 'Command Injection Detected',
+            }
+            return send_response(data, api)
+        create_env = Environment(identifier)
+        if not create_env.connect_n_mount():
+            data = {'status': 'failed', 'message': msg}
+            return send_response(data, api)
+        version = create_env.mobsfy_init()
+        if not version:
+            data = {'status': 'failed', 'message': msg}
+            return send_response(data, api)
+        else:
+            data = {'status': 'ok', 'android_version': version}
+    except Exception as exp:
+        logger.exception('MobSFying Android instance failed')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data, api)
+
+# AJAX
+
+
+@require_http_methods(['POST'])
+def execute_adb(request, api=False):
+    """Execute ADB Commands."""
+    data = {'status': 'ok', 'message': ''}
+    cmd = request.POST['cmd']
+    if cmd:
+        args = [get_adb(),
+                '-s',
+                get_device()]
+        try:
+            proc = subprocess.Popen(
+                args + cmd.split(' '),  # lgtm [py/command-line-injection]
+                stdout=subprocess.PIPE,  # Expected, cmd execute inside VM/AVD
+                stderr=subprocess.PIPE)
+            stdout, stderr = proc.communicate()
+        except Exception:
+            logger.exception('Executing ADB Commands')
+        if stdout or stderr:
+            out = stdout or stderr
+            out = out.decode('utf8', 'ignore')
+        else:
+            out = ''
+        data = {'status': 'ok', 'message': out}
+    return send_response(data, api)
+
+# AJAX
+
+
+@require_http_methods(['POST'])
+def get_component(request):
+    """Get Android Component."""
+    data = {}
+    try:
+        env = Environment()
+        comp = request.POST['component']
+        bin_hash = request.POST['hash']
+        if is_attack_pattern(comp) or not is_md5(bin_hash):
+            return invalid_params()
+        comp = env.android_component(bin_hash, comp)
+        data = {'status': 'ok', 'message': comp}
+    except Exception as exp:
+        logger.exception('Getting Android Component')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data)
+
+# AJAX
+
+
+@require_http_methods(['POST'])
+def run_apk(request):
+    """Run Android APK."""
+    data = {}
+    try:
+        env = Environment()
+        md5_hash = request.POST['hash']
+        if not is_md5(md5_hash):
+            return invalid_params()
+        pkg = get_package_name(md5_hash)
+        if not pkg:
+            return invalid_params()
+        env.run_app(pkg)
+        data = {'status': 'ok'}
+    except Exception as exp:
+        logger.exception('Running the App')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data)
+
+# AJAX
+
+
+@require_http_methods(['POST'])
+def take_screenshot(request, api=False):
+    """Take Screenshot."""
+    logger.info('Taking screenshot')
+    data = {}
+    try:
+        env = Environment()
+        bin_hash = request.POST['hash']
+        if not is_md5(bin_hash):
+            return invalid_params(api)
+        data = {}
+        rand_int = random.randint(1, 1000000)
+        screen_dir = os.path.join(settings.UPLD_DIR,
+                                  bin_hash + '/screenshots-apk/')
+        if not os.path.exists(screen_dir):
+            os.makedirs(screen_dir)
+        outile = '{}screenshot-{}.png'.format(
+            screen_dir,
+            str(rand_int))
+        env.screen_shot(outile)
+        logger.info('Screenshot captured')
+        data = {'status': 'ok'}
+    except Exception as exp:
+        logger.exception('Taking screenshot')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data, api)
+# AJAX
+
+
+@require_http_methods(['POST'])
+def screen_cast(request):
+    """ScreenCast."""
+    data = {}
+    try:
+        env = Environment()
+        trd = threading.Thread(target=env.screen_stream)
+        trd.daemon = True
+        trd.start()
+        data = {'status': 'ok'}
+    except Exception as exp:
+        logger.exception('Screen streaming')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data)
+# AJAX
+
+
+@require_http_methods(['POST'])
+def touch(request):
+    """Sending Touch Events."""
+    data = {}
+    try:
+        env = Environment()
+        x_axis = request.POST['x']
+        y_axis = request.POST['y']
+        if not is_number(x_axis) and not is_number(y_axis):
+            logger.error('Axis parameters must be numbers')
+            return invalid_params()
+        args = ['input',
+                'tap',
+                x_axis,
+                y_axis]
+        trd = threading.Thread(target=env.adb_command,
+                               args=(args, True))
+        trd.daemon = True
+        trd.start()
+        data = {'status': 'ok'}
+    except Exception as exp:
+        logger.exception('Sending Touch Events')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data)
+# AJAX
+
+
+@require_http_methods(['POST'])
+def mobsf_ca(request, api=False):
+    """Install and Remove MobSF Proxy RootCA."""
+    data = {}
+    try:
+        env = Environment()
+        action = request.POST['action']
+        if action == 'install':
+            env.install_mobsf_ca(action)
+            data = {'status': 'ok', 'message': 'installed'}
+        elif action == 'remove':
+            env.install_mobsf_ca(action)
+            data = {'status': 'ok', 'message': 'removed'}
+        else:
+            data = {'status': 'failed',
+                    'message': 'Action not supported'}
+    except Exception as exp:
+        logger.exception('MobSF RootCA Handler')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data, api)
+# AJAX
+
+
+@require_http_methods(['POST'])
+def global_proxy(request, api=False):
+    """Set/unset global proxy."""
+    data = {}
+    try:
+        env = Environment()
+        version = env.get_android_version()
+        action = request.POST['action']
+        if action == 'set':
+            env.set_global_proxy(version)
+            data = {'status': 'ok', 'message': 'set'}
+        elif action == 'unset':
+            env.unset_global_proxy()
+            data = {'status': 'ok', 'message': 'unset'}
+        else:
+            data = {'status': 'failed',
+                    'message': 'Action not supported'}
+    except Exception as exp:
+        logger.exception('MobSF Global Proxy')
+        data = {'status': 'failed', 'message': str(exp)}
+    return send_response(data, api)