frida-fusion 0.1.17__tar.gz → 0.1.20__tar.gz

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frida-fusion
-Version: 0.1.17
+Version: 0.1.20
 Summary: Hook your mobile tests with Frida
 Author-email: "Helvio Junior (M4v3r1ck)" <helvio_junior@hotmail.com>
 Maintainer-email: "Helvio Junior (M4v3r1ck)" <helvio_junior@hotmail.com>
@@ -34,6 +34,7 @@ Requires-Dist: frida-tools>=10.8.0
 Dynamic: license-file
 
 # Frida Fusion 
+<img src="./fusion_logo.svg" alt="Frida Fusion logo" align="right" width="20%"/>
 
 Hook your mobile tests with Frida.
 

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/README.md

@@ -1,4 +1,5 @@
 # Frida Fusion 
+<img src="./fusion_logo.svg" alt="Frida Fusion logo" align="right" width="20%"/>
 
 Hook your mobile tests with Frida.
 

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/frida_fusion/__meta__.py

@@ -1,8 +1,8 @@
-__version__ = '0.1.17'
+__version__ = '0.1.20'
 __title__ = "Frida Fusion"
 __description__ = "📱 frida-fusion - runtime mobile exploration"
 __url__ = "https://github.com/helviojunior/frida-fusion"
-__build__ = 0xe289b59
+__build__ = 0x472df92
 __author__ = "Helvio Junior (M4v3r1ck)"
 __author_email__ = "helvio_junior@hotmail.com"
 __license__ = "GPL-3.0"

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/frida_fusion/config.py

@@ -7,7 +7,7 @@ import signal
 from argparse import Namespace
 from pathlib import Path
 
-from .module import Module, ModuleManager, InternalModule, ExternalModule
+from .module import Module, ModuleManager, InternalModule, ExternalModule, LocalModule
 from .libs.color import Color
 from .libs.logger import Logger
 from .__meta__ import __version__
@@ -70,6 +70,8 @@ class Configuration(object):
 
         sys.argv[0] = 'frida-fusion'
 
+        Configuration.cmd_line = ' '.join([word for word in sys.argv])
+
         list_modules = any(['--list-modules' == word for word in sys.argv])
         #show_help = any(['-h' == word for word in sys.argv])
 
@@ -132,6 +134,8 @@ class Configuration(object):
             Color.pl('{!} {R}error: you must specify just one parameter {O}--package{R} or {O}--attach-pid{R}{W}\r\n')
             Configuration.mandatory()
 
+        Logger.pl('     {C}command line:{O} %s{W}' % Configuration.cmd_line)
+
         if args.app_id is not None:
             Configuration.package = args.app_id
             Logger.pl('     {C}package:{O} %s{W}' % Configuration.package)
@@ -184,9 +188,10 @@ class Configuration(object):
 
         Logger.pl('     {C}min debug level:{O} %s{W}' % str(args.debug_level).upper())
 
+        mods = ModuleManager.list_modules(local_path=Path(Configuration.frida_scripts))
         if (args.enabled_modules is not None and isinstance(args.enabled_modules, list)) or \
                 (args.ignore_messages_modules is not None and isinstance(args.ignore_messages_modules, list)):
-            mods = ModuleManager.list_modules()
+
             for mod in [
                 m.strip()
                 for md in args.enabled_modules
@@ -206,6 +211,7 @@ class Configuration(object):
                 name = fm.safe_name()
                 if name not in Configuration.enabled_modules.keys():
                     Configuration.enabled_modules[name] = fm
+
             if args.ignore_messages_modules is not None and isinstance(args.ignore_messages_modules, list):
                 for mod in [
                     m.strip()
@@ -227,6 +233,14 @@ class Configuration(object):
                     if name not in Configuration.ignore_messages_modules.keys():
                         Configuration.ignore_messages_modules[name] = fm
 
+        # Enable user defined local modules
+        for _, fm in mods.items():
+            if isinstance(fm, LocalModule):
+                name = fm.safe_name()
+                if name not in Configuration.ignore_messages_modules.keys():
+                    Configuration.ignore_messages_modules[name] = fm
+                    Configuration.enabled_modules[name] = fm
+
         if len(Configuration.enabled_modules) > 0:
             Logger.pl('     {C}modules:{O} %s{W}' % ', '.join([
                 m.name

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/frida_fusion/fusion.py

@@ -84,9 +84,9 @@ class Fusion(object):
                 elif Configuration.remote_host is not None:
                     self.device = process.add_remote_device(Configuration.remote_host)
 
-        except Exception as e:
+        except Exception as err:
             self.device = None
-            Logger.pl('\n{!} {R}Error:{O} %s{W}' % str(e))
+            Logger.print_exception(err)
 
         return self.device
 
@@ -144,7 +144,8 @@ class Fusion(object):
                 src += dyn
 
         if os.path.isfile(Configuration.frida_scripts):
-            files_js += [Configuration.frida_scripts]
+            if Path(Configuration.frida_scripts).suffix.lower() == ".js":
+                files_js += [Configuration.frida_scripts]
         else:
             files_js += [
                 os.path.join(Configuration.frida_scripts, f)
@@ -152,7 +153,15 @@ class Fusion(object):
                 if f.endswith(".js")
             ]
 
+        # Keep unique files
+        # Do not use list(set(files_js)) because it will lose the order of modules
+        done: set[str] = set()
         for file_path in files_js:
+            if file_path in done:
+                continue
+
+            done.add(file_path)
+
             file_name = Path(file_path).name
             file_data = self.sanitize_js(open(file_path, 'r', encoding='utf-8').read())
             if '#NOLOAD' in file_data:
@@ -172,7 +181,7 @@ class Fusion(object):
 
                 line_cnt = len(file_data.split("\n")) - 1
 
-                self.script_trace[file_name] = (offset, offset + line_cnt)
+                self.script_trace[file_name] = (offset, offset + line_cnt - 1)
                 offset += line_cnt
 
                 src += file_data
@@ -186,10 +195,17 @@ class Fusion(object):
             s = self.session.create_script(src, name="fusion_bundle")
             s.on("message", self.make_handler("fusion_bundle.js"))  # register the message handler
             s.load()
-        except Exception as e:
-
+        except Exception as err:
             try:
-                err = str(e)
+                from traceback import format_exc
+                err_txt = 'Error:{O} %s{W}' % str(err)
+                err_txt += '\n{O}Full stack trace below\n'
+                err_txt += format_exc().strip()
+
+                err_txt = err_txt.replace('\n', '\n{W}   ')
+                err_txt = err_txt.replace('  File', '{W}{D}File')
+                err_txt = err_txt.replace('  Exception: ', '{R}Exception: {O}')
+
                 pattern = re.compile(r'script\(line (\d+)\):')
                 matches = [
                     (
@@ -199,15 +215,16 @@ class Fusion(object):
                             line=m.group(1),
                         ))
                     )
-                    for m in pattern.finditer(err)
+                    for m in pattern.finditer(err_txt)
                 ]
                 for m in matches:
-                    err = err.replace(m[0], f"{m[1].file_name}(line {m[1].line})")
-                Logger.pl('{!} {R}Error:{O} %s{W}' % err)
+                    err_txt = err_txt.replace(m[0], f"{m[1].file_name}(line {m[1].line})")
+
+                Logger.pl(err_txt)
                 print("")
                 sys.exit(1)
-            except Exception:
-                Logger.pl('{!} {R}Error:{O} %s{W}' % str(e))
+            except Exception as e2:
+                Logger.print_exception(e2)
                 print("")
                 sys.exit(1)
 
@@ -383,7 +400,7 @@ class Fusion(object):
                     skm = str(sk)
 
                     self.print_message_inst("D", "Silent kill requested",
-                                       script_location=Logger.get_caller_info(stack_index=1))
+                                            script_location=Logger.get_caller_info(stack_index=1))
                     Fusion.running = False
                     time.sleep(0.2)
                     if skm != "":
@@ -436,7 +453,7 @@ class Fusion(object):
                         }))
 
                         self.print_message_inst("F", description + stack,
-                                           script_location=script_location)
+                                                script_location=script_location)
                         Fusion.running = False
                         time.sleep(0.2)
                         Logger.pl('\n{+} {O}Exiting...{O}{W}')
@@ -465,7 +482,6 @@ class Fusion(object):
         Logger.pl("")
         self.done.set()
 
-
     def _replace_location(self, message: str) -> str:
         try:
             matches = [
@@ -501,11 +517,11 @@ class Fusion(object):
                 )
             except SilentKillError as ske:
                 raise ske
-            except Exception as e:
-                if Configuration.debug_level >= 2:
-                    self.print_message_inst("E", f"Error resizing event to module {m.name}: {str(e)}")
-                else:
-                    self.print_exception(e)
+            except Exception as err:
+                self.print_exception(
+                    err,
+                    script_location=Logger.get_error_info_from_format_exc(stack_index=-1)
+                )
 
     def _raise_data_event(self,
                           script_location: ScriptLocation = None,
@@ -520,14 +536,14 @@ class Fusion(object):
                 )
             except SilentKillError as ske:
                 raise ske
-            except Exception as e:
-                if Configuration.debug_level >= 2:
-                    self.print_message_inst("E", f"Error resizing event to module {m.name}: {str(e)}")
-                else:
-                    self.print_exception(e)
+            except Exception as err:
+                self.print_exception(
+                    err,
+                    script_location=Logger.get_error_info_from_format_exc(stack_index=-1)
+                )
 
     def print_message_inst(self, level: str = "*", message: str = "",
-                      script_location: ScriptLocation = None):
+                           script_location: ScriptLocation = None):
 
         return type(self)._print_message(
             level=level,
@@ -546,7 +562,7 @@ class Fusion(object):
 
     @classmethod
     def _print_message(cls, level: str = "*", message: str = "",
-                      script_location: ScriptLocation = None):
+                       script_location: ScriptLocation = None):
 
         if Fusion.running is False and Logger.debug_level >= 2:
             return
@@ -580,7 +596,7 @@ class Fusion(object):
             db.insert_history(**kwargs)
 
     @classmethod
-    def print_exception(cls, err):
+    def print_exception(cls, err, script_location: ScriptLocation = None):
         from traceback import format_exc
         err_txt = 'Error:{O} %s{W}' % str(err)
         err_txt += '\n{O}Full stack trace below\n'
@@ -594,7 +610,7 @@ class Fusion(object):
             level="E",
             message=Color.s(err_txt),
             filename_col_len=Fusion.max_filename,
-            script_location=Logger.get_caller_info(stack_index=2)
+            script_location=script_location if script_location is not None else Logger.get_caller_info(stack_index=2)
         )
 
     @classmethod

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/frida_fusion/libs/database.py

@@ -4,6 +4,7 @@ import math
 import shutil
 import os.path
 import sqlite3
+import time
 from functools import reduce
 from pathlib import Path
 from sqlite3 import Connection, ProgrammingError
@@ -78,7 +79,7 @@ class Database(object):
         (columns, values) = self.parse_args(kwargs)
         sql = "INSERT INTO {} ({}) VALUES ({})" \
             .format(table_name, ','.join(columns), ', '.join(['?'] * len(columns)))
-        conn.execute(sql, values)
+        self.resilient_execute(conn, sql, values)
         conn.commit()
 
     @connect
@@ -89,7 +90,7 @@ class Database(object):
             (columns, values) = self.parse_args(kwargs)
             sql = "INSERT INTO {} ({}) VALUES ({})" \
                 .format(table_name, ','.join(columns), ', '.join(['?'] * len(columns)))
-            conn.execute(sql, values)
+            self.resilient_execute(conn, sql, values)
             conn.commit()
 
     @connect
@@ -98,7 +99,7 @@ class Database(object):
         (columns, values) = self.parse_args(kwargs)
         sql = "INSERT OR IGNORE INTO {} ({}) VALUES ({})" \
             .format(table_name, ','.join(columns), ', '.join(['?'] * len(columns)))
-        conn.execute(sql, values)
+        self.resilient_execute(conn, sql, values)
         conn.commit()
 
     @connect
@@ -107,7 +108,7 @@ class Database(object):
         (columns, values) = self.parse_args(kwargs)
         sql = "INSERT OR REPLACE INTO {} ({}) VALUES ({})" \
             .format(table_name, ','.join(columns), ', '.join(['?'] * len(columns)))
-        conn.execute(sql, values)
+        self.resilient_execute(conn, sql, values)
         conn.commit()
 
     def insert_update_one(self, table_name: str, **kwargs):
@@ -119,7 +120,7 @@ class Database(object):
         (columns, values) = self.parse_args(kwargs)
         sql = "INSERT OR IGNORE INTO {} ({}) VALUES ({})" \
             .format(table_name, ','.join(columns), ', '.join(['?'] * len(columns)))
-        c = conn.execute(sql, values)
+        c = self.resilient_execute(conn, sql, values)
 
         status = {'inserted': c.rowcount, 'updated': 0}
 
@@ -135,7 +136,7 @@ class Database(object):
             sql += "{}".format(', '.join([f'{col} = ?' for col in u_columns]))
             if len(f_columns) > 0:
                 sql += " WHERE {}".format(f' and '.join([f'{col} = ?' for col in f_columns]))
-            c = conn.execute(sql, tuple(u_values + f_values, ))
+            c = self.resilient_execute(conn, sql, tuple(u_values + f_values, ))
             conn.commit()
 
             status['updated'] = c.rowcount
@@ -155,12 +156,16 @@ class Database(object):
         if len(columns) > 0:
             sql += " WHERE {}".format(f' {operator} '.join([f'{col} = ?' for col in columns]))
 
-        cursor = conn.execute(sql, values)
-        if cursor.rowcount == 0:
-            return []
+        data = []
+        with conn:  # Transaction
+            cursor = self.resilient_execute(conn, sql, values)
+            if cursor.rowcount == 0:
+                return data
 
-        columns = cursor.description
-        return [{columns[index][0]: column for index, column in enumerate(value)} for value in cursor.fetchall()]
+            columns = cursor.description
+            data = [{columns[index][0]: column for index, column in enumerate(value)} for value in cursor.fetchall()]
+
+        return data
 
     def select_first(self, table_name, **kwargs):
         data = self.select(table_name, **kwargs)
@@ -170,11 +175,15 @@ class Database(object):
 
     @connect
     def select_raw(self, conn: Connection, sql: str, args: any):
-        cursor = conn.execute(sql, tuple(args,))
+        cursor = self.resilient_execute(conn, sql, tuple(args,))
         if cursor.rowcount == 0:
             return []
         columns = cursor.description
-        return [{columns[index][0]: column for index, column in enumerate(value)} for value in cursor.fetchall()]
+        data = []
+        with conn:  # Transaction
+            data = [{columns[index][0]: column for index, column in enumerate(value)} for value in cursor.fetchall()]
+
+        return data
 
     @connect
     def select_count(self, conn: Connection, table_name, **kwargs) -> int:
@@ -187,10 +196,13 @@ class Database(object):
         sql = f"SELECT count(*) FROM {table_name}"
         if len(columns) > 0:
             sql += " WHERE {}".format(f' {operator} '.join([f'{col} = ?' for col in columns]))
-        cursor = conn.execute(sql, values)
-        if cursor.rowcount == 0:
-            return 0
-        data = cursor.fetchone()
+
+        data = []
+        with conn:  # Transaction
+            cursor = self.resilient_execute(conn, sql, values)
+            if cursor.rowcount == 0:
+                return 0
+            data = cursor.fetchone()
 
         return int(data[0])
 
@@ -205,7 +217,7 @@ class Database(object):
         sql = f"DELETE FROM {table_name}"
         if len(columns) > 0:
             sql += " WHERE {}".format(f' {operator} '.join([f'{col} = ?' for col in columns]))
-        conn.execute(sql, values)
+        self.resilient_execute(conn, sql, values)
         conn.commit()
 
     @connect
@@ -221,7 +233,7 @@ class Database(object):
         sql += "{}".format(', '.join([f'{col} = ?' for col in u_columns]))
         if len(f_columns) > 0:
             sql += " WHERE {}".format(f' {operator} '.join([f'{col} = ?' for col in f_columns]))
-        conn.execute(sql, tuple(u_values + f_values, ))
+        self.resilient_execute(conn, sql, tuple(u_values + f_values, ))
         conn.commit()
 
     def get_constraints(self, conn: Connection) -> dict:
@@ -238,7 +250,7 @@ class Database(object):
                '  il.origin = "u"  '
                'ORDER BY table_name, key_name, ii.seqno')
 
-        cursor = conn.execute(sql)
+        cursor = self.resilient_execute(conn, sql)
         columns = cursor.description
         db_scheme = [{columns[index][0]: column for index, column in enumerate(value)} for value in cursor.fetchall()]
 
@@ -333,7 +345,7 @@ class Database(object):
 
         conn.commit()
 
-        #Must get the constraints
+        # Must get the constraints
         self.get_constraints(conn)
 
     def insert_history(self, source: str, data: str, stack_trace: str = ''):
@@ -363,3 +375,15 @@ class Database(object):
         str
         """
         return ''.join(k for k in input_string if k.isalnum() or k in '_-')
+
+    @classmethod
+    def resilient_execute(cls, conn: Connection, *args, **kwargs):
+        for _ in range(5):
+            try:
+                return conn.execute(*args, **kwargs)
+            except sqlite3.OperationalError as e:
+                if 'database is locked' in str(e).lower():
+                    time.sleep(0.3)
+                else:
+                    raise e
+

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/frida_fusion/libs/helpers.js

@@ -181,6 +181,55 @@ function fusion_bytesToBase64(byteArray){
     }
 }
 
+function fusion_base64ToString(b64) {
+  try {
+    const StringClass  = Java.use('java.lang.String');
+    const Base64Class  = Java.use('android.util.Base64');
+
+    // Flags úteis (só para referência/legibilidade)
+    const BASE64_DEFAULT  = 0x00000000; // decode padrão
+    const BASE64_URL_SAFE = 0x00000008; // para strings base64 url-safe
+
+    // Normaliza entrada
+    let s = ('' + b64).trim();
+    // Remove prefixo data URI, se existir
+    s = s.replace(/^data:.*;base64,/, '');
+    // Remove espaços/linhas quebradas
+    s = s.replace(/\s+/g, '');
+
+    // Função para padding quando faltam '='
+    function padBase64(x) {
+      const m = x.length % 4;
+      return m === 0 ? x : x + '===='.slice(m);
+    }
+
+    let decoded = null;
+
+    // 1) Tenta DEFAULT
+    try {
+      decoded = Base64Class.decode(s, BASE64_DEFAULT);
+    } catch (e1) {
+      // 2) Tenta URL_SAFE
+      try {
+        decoded = Base64Class.decode(s, BASE64_URL_SAFE);
+      } catch (e2) {
+        // 3) Tenta com padding
+        const sp = padBase64(s);
+        decoded = Base64Class.decode(sp, BASE64_DEFAULT);
+      }
+    }
+
+    // Converte bytes -> String UTF-8
+    const result = StringClass.$new(decoded, 'utf-8').toString();
+    return result;
+
+  } catch (err) {
+    // mesmo logger que você usa na encode
+    fusion_sendMessage("W", err);
+    return null;
+  }
+}
+
 function fusion_normalizePtr(addr) {
   let p = ptr(addr);
   if (Process.arch === 'arm64') p = p.and('0x00FFFFFFFFFFFFFF'); // limpa TBI

{frida_fusion-0.1.17 → frida_fusion-0.1.20}/frida_fusion/libs/logger.py

@@ -4,7 +4,9 @@ import base64
 import inspect
 import json
 import datetime
+import re
 from pathlib import Path
+from typing import Optional
 
 from .scriptlocation import ScriptLocation
 from ..libs.color import Color
@@ -83,6 +85,31 @@ class Logger(object):
             line=str(line_number)
         )
 
+    @classmethod
+    def get_error_info_from_format_exc(cls, stack_index: int = -1) -> Optional[ScriptLocation]:
+        """
+        Faz o *parse* do texto gerado por traceback.format_exc() e extrai arquivo/linha/função.
+        - frame_index: -1 pega o último frame (onde a exceção estourou).
+        Formato esperado das linhas:
+            File "/caminho/mod.py", line 123, in func
+        """
+        from traceback import format_exc
+
+        # Captura tuplas (arquivo, linha, função)
+        # Obs.: tolera espaços e caminhos com aspas; não captura a linha de código em si.
+        pattern = r'(?i:File) "(.+?)", (?i:line) (\d+), (?i:in) ([^\n\r]+)'
+        matches = re.findall(pattern, format_exc())
+
+        if not matches:
+            return None
+
+        file_path, lineno, func = matches[stack_index]
+        return ScriptLocation(
+            file_name=Path(file_path).name,
+            function_name=func.strip(),
+            line=str(lineno),
+        )
+
     @staticmethod
     def json_serial(obj):
         """JSON serializer for objects not serializable by default json code"""
@@ -167,3 +194,16 @@ class Logger(object):
                               f"{Color.color_reset} {fg_color}{line}{Color.color_reset}")
 
         Logger.pl(f_message)
+
+    @classmethod
+    def print_exception(cls, err):
+        from traceback import format_exc
+        err_txt = 'Error:{O} %s{W}' % str(err)
+        err_txt += '\n{O}Full stack trace below\n'
+        err_txt += format_exc().strip()
+
+        err_txt = err_txt.replace('\n', '\n{W}   ')
+        err_txt = err_txt.replace('  File', '{W}{D}File')
+        err_txt = err_txt.replace('  Exception: ', '{R}Exception: {O}')
+
+        Logger.pl(f"{err_txt}\n")