frida-fusion 0.1.9__tar.gz → 0.1.10__tar.gz

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frida-fusion
-Version: 0.1.9
+Version: 0.1.10
 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>

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/frida_fusion/__meta__.py

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

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/frida_fusion/libs/database.py

@@ -81,6 +81,17 @@ class Database(object):
         conn.execute(sql, values)
         conn.commit()
 
+    @connect
+    def insert_if_not_exists(self, conn: Connection, table_name, **kwargs):
+        table_name = self.scrub(table_name)
+
+        if self.select_count(table_name=table_name, **kwargs) == 0:
+            (columns, values) = self.parse_args(kwargs)
+            sql = "INSERT INTO {} ({}) VALUES ({})" \
+                .format(table_name, ','.join(columns), ', '.join(['?'] * len(columns)))
+            conn.execute(sql, values)
+            conn.commit()
+
     @connect
     def insert_ignore_one(self, conn: Connection, table_name, **kwargs):
         table_name = self.scrub(table_name)

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/frida_fusion/libs/helpers.js

@@ -214,6 +214,35 @@ function fusion_printMethods(targetClass)
   });
 }
 
+function fusion_getClassName(obj)
+{
+  if (obj === null || obj === undefined) return "";
+
+  try {
+        // Caso seja um objeto Java real
+        if (obj.$className !== undefined) {
+            // Objetos instanciados via Java.use
+            return obj.$className;
+        }
+
+        // Caso seja uma instância Java (não necessariamente via Java.use)
+        if (Java.isJavaObject(obj)) {
+            return obj.getClass().getName();
+        }
+
+        // Caso seja uma classe Java carregada (Java.use)
+        if (Java.isJavaClass(obj)) {
+            return obj.class.getName();
+        }
+
+        // Se for algo não Java, apenas retorna tipo do JS
+        return typeof obj;
+    } catch (err) {
+        fusion_sendMessage("W", err);
+        return '';
+    }
+
+}
 
 Java.perform(function () {
   const Thread = Java.use('java.lang.Thread');

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/frida_fusion/libs/logger.py

@@ -41,7 +41,7 @@ class Logger(object):
         if Logger.out_file != '':
             try:
                 with open(Logger.out_file, "a") as text_file:
-                    text_file.write(Color.sc(text) + '\n')
+                    text_file.write(Color.escape_ansi(Color.sc(text)) + '\n')
             except:
                 pass
 

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/frida_fusion/modules/crypto/crypto.js

@@ -86,9 +86,10 @@ setTimeout(function() {
             const secretKeySpec = Java.use("javax.crypto.spec.SecretKeySpec");
             secretKeySpec.$init.overload("[B", "java.lang.String").implementation = function (key, cipher) {
                 const keyBase64 = fusion_bytesToBase64(key);
-                fusion_sendKeyValueData("secretKeySpec.init", [
+                fusion_sendKeyValueData("SecretKeySpec.init", [
                     {key: "Key", value: keyBase64},
-                    {key: "Algorithm", value: cipher}
+                    {key: "Algorithm", value: cipher},
+                    {key: "ClassType", value: fusion_getClassName(this)}
                 ]);
                 return secretKeySpec.$init.overload("[B", "java.lang.String").call(this, key, cipher);
             }
@@ -141,42 +142,20 @@ setTimeout(function() {
                 return output;
             };
 
-            /*
-            messageDigest.digest.overload("[B").implementation = function (input) {
-                const inputBase64 = fusion_bytesToBase64(input);
-                fusion_sendKeyValueData("messageDigest.digest", [
-                    {key: "Input", value: inputBase64},
-                    {key: "Algorithm", value: this.getAlgorithm()}
-                ]);
-                return this.digest.overload("[B").call(this, input);
-            };
-
-            messageDigest.digest.overload("[B", "int", "int").implementation = function (input, offset, len) {
-                const inputBase64 = fusion_bytesToBase64(input);
-                fusion_sendKeyValueData("messageDigest.digest", [
-                    {key: "Input", value: inputBase64},
-                    {key: "Algorithm", value: this.getAlgorithm()},
-                    {key: "Offset", value: offset},
-                    {key: "Length", value: len}
-                ]);
-                return this.digest.overload("[B", "int", "int").call(this, input, offset, len);
-            };*/
-             
-
         }
 
         if (MODULES.SecretKeyFactory) {
             fusion_sendMessage('*', "Module attached: javax.crypto.SecretKeyFactory");
             const secretKeyFactory = Java.use("javax.crypto.SecretKeyFactory");
             secretKeyFactory.getInstance.overload("java.lang.String").implementation = function (arg0) {
-                fusion_sendKeyValueData("secretKeyFactory.getInstance", [
+                fusion_sendKeyValueData("SecretKeyFactory.getInstance", [
                     {key: "Algorithm", value: arg0}
                 ]);
                 return this.getInstance(arg0);
             };
 
             secretKeyFactory.getInstance.overload("java.lang.String", "java.lang.String").implementation = function (arg0, arg1) {
-                fusion_sendKeyValueData("secretKeyFactory.getInstance", [
+                fusion_sendKeyValueData("SecretKeyFactory.getInstance", [
                     {key: "Algorithm", value: arg0},
                     {key: "Provider", value: arg1}
                 ]);
@@ -184,7 +163,7 @@ setTimeout(function() {
             };
 
             secretKeyFactory.getInstance.overload("java.lang.String", "java.security.Provider").implementation = function (arg0, arg1) {
-                fusion_sendKeyValueData("secretKeyFactory.getInstance", [
+                fusion_sendKeyValueData("SecretKeyFactory.getInstance", [
                     {key: "Algorithm", value: arg0},
                     {key: "Provider", value: arg1}
                 ]);
@@ -229,6 +208,7 @@ setTimeout(function() {
                 fusion_sendKeyValueData("cipher.init", [
                     {key: "HashCode", value: this.hashCode().toString()},
                     {key: "Key", value: fusion_keyToBase64(key)},
+                    {key: "KeyType", value: fusion_getClassName(key)},
                     {key: "Opmode", value: this.getOpmodeString(opmode)},
                     {key: "Algorithm", value: this.getAlgorithm()}
                 ]);
@@ -238,7 +218,9 @@ setTimeout(function() {
             cipher.init.overload("int", "java.security.cert.Certificate").implementation = function (opmode, certificate) {
                 fusion_sendKeyValueData("cipher.init", [
                     {key: "HashCode", value: this.hashCode().toString()},
+                    {key: "Key", value: fusion_keyToBase64(certificate)},
                     {key: "Certificate", value: fusion_keyToBase64(certificate)},
+                    {key: "KeyType", value: fusion_getClassName(certificate)},
                     {key: "Opmode", value: this.getOpmodeString(opmode)},
                     {key: "Algorithm", value: this.getAlgorithm()}
                 ]);
@@ -249,6 +231,7 @@ setTimeout(function() {
                 fusion_sendKeyValueData("cipher.init", [
                     {key: "HashCode", value: this.hashCode().toString()},
                     {key: "Key", value: fusion_keyToBase64(key)},
+                    {key: "KeyType", value: fusion_getClassName(key)},
                     {key: "Opmode", value: this.getOpmodeString(opmode)},
                     {key: "Algorithm", value: this.getAlgorithm()}
                 ]);
@@ -261,6 +244,7 @@ setTimeout(function() {
                     var data = [
                         {key: "HashCode", value: this.hashCode().toString()},
                         {key: "Key", value: fusion_keyToBase64(key)},
+                        {key: "KeyType", value: fusion_getClassName(key)},
                         {key: "Opmode", value: this.getOpmodeString(opmode)},
                         {key: "Algorithm", value: this.getAlgorithm()}
                     ];
@@ -487,7 +471,8 @@ setTimeout(function() {
             const ivParameter = Java.use("javax.crypto.spec.IvParameterSpec");
             ivParameter.$init.overload("[B").implementation = function (ivKey) {
                 fusion_sendKeyValueData("IvParameterSpec.init", [
-                    {key: "IV_Key", value: fusion_bytesToBase64(ivKey)}
+                    {key: "IV_Key", value: fusion_bytesToBase64(ivKey)},
+                    {key: "ClassType", value: fusion_getClassName(this)}
                 ]);
                 return this.$init.overload("[B").call(this, ivKey);
             }
@@ -496,7 +481,8 @@ setTimeout(function() {
                 fusion_sendKeyValueData("IvParameterSpec.init", [
                     {key: "IV Key", value: fusion_bytesToBase64(ivKey)},
                     {key: "Offset", value: offset},
-                    {key: "Length", value: len}
+                    {key: "Length", value: len},
+                    {key: "ClassType", value: fusion_getClassName(this)}
                 ]);
                 return this.$init.overload("[B", "int", "int").call(this, ivKey, offset, len);
             }
@@ -508,7 +494,8 @@ setTimeout(function() {
             gcmParameter.$init.overload("int", "[B").implementation = function (tLen, ivKey) {
                 fusion_sendKeyValueData("GCMParameterSpec.init", [
                     {key: "IV_Key", value: fusion_bytesToBase64(ivKey)},
-                    {key: "Auth_Tag_Length", value: tLen.toString()}
+                    {key: "Auth_Tag_Length", value: tLen.toString()},
+                    {key: "ClassType", value: fusion_getClassName(this)}
                 ]);
                 return this.$init.overload("int", "[B").call(this, tLen, ivKey);
             }
@@ -518,7 +505,8 @@ setTimeout(function() {
                     {key: "IV_Key", value: fusion_bytesToBase64(ivKey)},
                     {key: "Auth_Tag_Length", value: tLen.toString()},
                     {key: "Offset", value: offset},
-                    {key: "Length", value: len}
+                    {key: "Length", value: len},
+                    {key: "ClassType", value: fusion_getClassName(this)}
                 ]);
                 return this.$init.overload("int", "[B", "int", "int").call(this, tLen, ivKey, offset, len);
             }
@@ -530,7 +518,8 @@ setTimeout(function() {
             pbeParameter.$init.overload("[B", "int").implementation = function (salt, iterationCount) {
                 fusion_sendKeyValueData("PBEParameterSpec.init", [
                     {key: "PBE_Salt", value: fusion_bytesToBase64(salt)},
-                    {key: "Iteration_Count", value: iterationCount.toString()}
+                    {key: "Iteration_Count", value: iterationCount.toString()},
+                    {key: "ClassType", value: fusion_getClassName(this)},
                 ]);
                 return this.$init.overload("[B", "int").call(this, salt, iterationCount);
             }
@@ -539,7 +528,8 @@ setTimeout(function() {
                 
                 var data = [
                     {key: "PBE_Salt", value: fusion_bytesToBase64(salt)},
-                    {key: "Iteration_Count", value: iterationCount.toString()}
+                    {key: "Iteration_Count", value: iterationCount.toString()},
+                    {key: "ClassType", value: fusion_getClassName(this)}
                     
                 ]
 
@@ -547,6 +537,7 @@ setTimeout(function() {
                     data = data.concat([
                         {key: "Algorithm", value: paramSpec.getAlgorithm()},
                         {key: "ParamSpec", value: fusion_keyToBase64(paramSpec)},
+                        {key: "ParamSpecType", value: fusion_getClassName(paramSpec)},
                         {key: "Provider", value: paramSpec.getProvider()}
                     ]);
                 } catch (err) { }
@@ -561,7 +552,9 @@ setTimeout(function() {
             const x509EncodedKeySpec = Java.use("java.security.spec.X509EncodedKeySpec");
             x509EncodedKeySpec.$init.overload("[B").implementation = function (encodedKey) {
                 fusion_sendKeyValueData("X509EncodedKeySpec.init", [
-                    {key: "Key", value: fusion_bytesToBase64(encodedKey)}
+                    {key: "Key", value: fusion_bytesToBase64(encodedKey)},
+                    {key: "ClassType", value: fusion_getClassName(this)}
+
                 ]);
                 return this.$init.overload("[B").call(this, encodedKey);
             }

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/frida_fusion/modules/crypto/crypto.py

@@ -1,3 +1,4 @@
+import json
 import os.path
 from pathlib import Path
 import base64
@@ -31,10 +32,10 @@ class Crypto(ModuleBase):
             cursor.execute("""
                 CREATE TABLE IF NOT EXISTS [crypto] (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    algorithm TEXT NOT NULL,
-                    init_key TEXT NOT NULL,
+                    hashcode TEXT NOT NULL,
+                    algorithm TEXT NULL,
+                    init_key TEXT NULL,
                     iv TEXT NULL,
-                    hashcode TEXT NULL,
                     flow TEXT NULL,
                     key TEXT NULL,
                     clear_text TEXT NULL,
@@ -48,6 +49,22 @@ class Crypto(ModuleBase):
 
             conn.commit()
 
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS [crypto_key] (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    key TEXT NULL,
+                    printable_key TEXT NULL,
+                    salt TEXT NULL,
+                    iteration_count INTEGER NULL DEFAULT (0),
+                    key_class TEXT NULL DEFAULT ('<unknown>'),
+                    additional_data TEXT NULL,
+                    created_date datetime not null DEFAULT (datetime('now','localtime')),
+                    UNIQUE (key, key_class)
+                );
+            """)
+
+            conn.commit()
+
             cursor.execute("""
                 CREATE TABLE IF NOT EXISTS [digest] (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -80,7 +97,8 @@ class Crypto(ModuleBase):
                 return ''
 
         def update_crypto(self, iv=None, hashcode=None, flow=None, key=None, before_final=None,
-                          after_final=None, stack_trace=None, id=None):
+                          after_final=None, stack_trace=None, id=None, algorithm=None,
+                          status=None):
 
             conn = self.connect_to_db(check=False)
             cursor = conn.cursor()
@@ -116,6 +134,11 @@ class Crypto(ModuleBase):
                     update += " hashcode = ?,"
                     data.append(hashcode)
 
+                if flow is not None:
+                    integrity = True
+                    update += " algorithm = ?,"
+                    data.append(algorithm)
+
                 if flow is not None:
                     integrity = True
                     update += " flow = ?,"
@@ -136,6 +159,11 @@ class Crypto(ModuleBase):
                     update += " stack_trace = ?,"
                     data.append(stack_trace)
 
+                if status is not None:
+                    integrity = True
+                    update += " status = ?,"
+                    data.append(status)
+
                 if before_final is not None:
                     integrity = True
                     if dbflow == "enc":
@@ -169,6 +197,16 @@ class Crypto(ModuleBase):
 
                     cursor.execute(update, data)
 
+                    cursor = conn.cursor()
+                    cursor.execute("""
+                    delete from [crypto]
+                    where algorithm is null and init_key is null and key is null and clear_text is null
+                    and hashcode in (
+                        select hashcode from [crypto]
+                        where id = ?
+                    )
+                    """, (id,))
+
                     conn.commit()
 
                     # Color.pl('{+} {W}Crypto atualizada. {C}ID: {O}%s{W}' % id)
@@ -215,56 +253,59 @@ class Crypto(ModuleBase):
 
             # Color.pl('{+} {W}Inserindo crypto. {C}Algorithm: {O}%s{W}' % algorithm)
 
-        def insert_crypto(self, algorithm, init_key):
-
-            conn = self.connect_to_db(check=False)
-
-            cursor = conn.cursor()
-            cursor.execute("""
-            update [crypto] set status = 'incomplete' where status = 'open';
-            """)
-
-            cursor = conn.cursor()
-            cursor.execute("""
-            insert into [crypto] ([algorithm], [init_key])
-            VALUES (?,?);
-            """, (algorithm, init_key,))
-
-            conn.commit()
-
-            conn.close()
-
-            # Color.pl('{+} {W}Inserindo crypto. {C}Algorithm: {O}%s{W}' % algorithm)
-
-        def insert_crypto2(self, algorithm, key, iv, clear_text, cipher_data, flow='enc'):
-
-            conn = self.connect_to_db(check=False)
-
-            if isinstance(clear_text, bytes):
-                clear_text = clear_text.decode("UTF-8")
-
-            if isinstance(cipher_data, bytes):
-                cipher_data = cipher_data.decode("UTF-8")
-
-            if isinstance(key, bytes):
-                key = base64.b64encode(key).decode("UTF-8")
-
-            if isinstance(iv, bytes):
-                iv = base64.b64encode(iv).decode("UTF-8")
+        def insert_crypto(self, hashcode, algorithm, init_key):
 
-            clear_text_b64 = base64.b64encode(clear_text.encode("UTF-8")).decode("UTF-8")
+            if hashcode is None:
+                return
 
-            cursor = conn.cursor()
-            cursor.execute("""
-            insert into [crypto] ([flow], [algorithm], [init_key], [key], [iv], [clear_text], [clear_text_b64], [cipher_data], [status])
-            VALUES (?,?,?,?,?,?,?,?,?);
-            """, (flow, algorithm, key, key, iv, clear_text, clear_text_b64, cipher_data, 'complete',))
-
-            conn.commit()
-
-            conn.close()
-
-            # Color.pl('{+} {W}Inserindo crypto. {C}Algorithm: {O}%s{W}' % algorithm)
+            rows = self.select(
+                table_name='crypto',
+                hashcode=hashcode,
+                status='open'
+            )
+            if len(rows) == 0 or not any(iter([
+                True
+                for r in rows
+                if (
+                    (algorithm is not None and algorithm == r['algorithm'])
+                    or (r['algorithm'] is None or r['algorithm'].strip() == "")
+                ) and (
+                    (
+                        (init_key is not None and init_key != '' and init_key != 'IA==')
+                        and (init_key == r['init_key'] or init_key == r['key'])
+                    )
+                    or (r['init_key'] is None or r['init_key'].strip() == "")
+                )
+            ])):
+                if init_key is not None and init_key != '' and init_key != 'IA==':
+                    self.insert_one(
+                        table_name='crypto',
+                        hashcode=hashcode,
+                        algorithm=algorithm,
+                        init_key=init_key,
+                        status='open')
+                else:
+                    self.insert_one(
+                        table_name='crypto',
+                        hashcode=hashcode,
+                        algorithm=algorithm,
+                        status='open')
+
+        def insert_crypto_key(self, key, key_class, salt=None,
+                              iteration_count=0, module="<unknown>", additional_data=dict):
+            if key is not None and key != '' and key != 'IA==':
+                self.insert_ignore_one(
+                    table_name='crypto_key',
+                    key=key,
+                    printable_key=self.get_printable(key),
+                    key_class=key_class,
+                    salt=salt,
+                    iteration_count=iteration_count,
+                    additional_data=json.dumps({
+                        **{"module": module},
+                        **(additional_data if additional_data is not None and isinstance(additional_data, dict) else {})
+                    }, default=Logger.json_serial)
+                )
 
     def __init__(self):
         super().__init__('Crypto', 'Hook cryptography/hashing functions')
@@ -290,31 +331,109 @@ class Crypto(ModuleBase):
                         received_data: dict = None
                         ) -> bool:
 
-        if module == "secretKeySpec.init":
+        if module in ["X509EncodedKeySpec.init", "GCMParameterSpec.init", "PBEParameterSpec.init"]:
+
+            key_class = received_data.get('classtype', module)
+            salt = None
+            iteration_count = 0
+
+            key = received_data.get('key', None)
+            if module == "GCMParameterSpec.init":
+                key = received_data.get('iv_key', None)
+
+            if module == "PBEParameterSpec.init":
+                key = "None"
+                salt = received_data.get('pbe_salt', None)
+                iteration_count = received_data.get('iteration_count', None)
+
+            self._crypto_db.insert_crypto_key(
+                key=key,
+                key_class=key_class,
+                salt=salt,
+                iteration_count=iteration_count,
+                module=module,
+                additional_data=received_data
+            )
+
+        if module == "SecretKeySpec.init":
             algorithm = received_data.get('algorithm', None)
-            bData = received_data.get('key', None)
-            self._crypto_db.insert_crypto(algorithm, bData)
+            key = received_data.get('key', None)
+            hashcode = received_data.get('hashcode', None)
+            key_class = received_data.get('classtype', "SecretKeySpec")
+            self._crypto_db.insert_crypto(
+                hashcode=hashcode,
+                algorithm=algorithm,
+                init_key=key)
+
+            self._crypto_db.insert_crypto_key(
+                key=key,
+                key_class=key_class,
+                module=module,
+                additional_data=received_data
+            )
 
         elif module == "IvParameterSpec.init":
             bData = received_data.get('iv_key', None)
+            key_class = received_data.get('classtype', "IvParameterSpec")
             # print("IV: %s" % bData)
-            self._crypto_db.update_crypto(bData)
+            self._crypto_db.update_crypto(iv=bData)
+
+            self._crypto_db.insert_crypto_key(
+                key=bData,
+                key_class=key_class,
+                module=module,
+                additional_data=received_data
+            )
 
         elif module == "cipher.init":
             hashcode = received_data.get('hashcode', None)
             opmode = received_data.get('opmode', "")
-            if 'encrypt' in opmode:
-                self._crypto_db.update_crypto(None, hashcode, 'enc')
-            elif 'decrypt' in opmode:
-                self._crypto_db.update_crypto(None, hashcode, 'dec')
+            key_class = received_data.get('keytype', "")
+            key = received_data.get('key', None)
+            algorithm = received_data.get('algorithm', None)
+
+            self._crypto_db.insert_crypto(
+                hashcode=hashcode,
+                algorithm=algorithm,
+                init_key=key
+            )
+
+            self._crypto_db.update_crypto(
+                hashcode=hashcode,
+                flow='enc' if 'encrypt' in opmode else ('dec' if 'decrypt' in opmode else str(opmode)),
+                key=key,
+                algorithm=algorithm
+            )
+
+            self._crypto_db.insert_crypto_key(
+                key=key,
+                key_class=key_class,
+                module=module,
+                additional_data=received_data
+            )
+
+            Logger.print_message(
+                level="W",
+                message=f"Cipher init received\nHashcode: {hashcode}\nOpmode: {opmode}\nKeytype: {key_class}",
+                script_location=script_location
+            )
 
         elif module == "cipher.doFinal":
-            self._crypto_db.update_crypto(None, None, None, None,
-                                          received_data.get('input', ''),
-                                          stack_trace=stack_trace)
-            self._crypto_db.update_crypto(None, None, None, None, None,
-                                          received_data.get('output', ''),
-                                          stack_trace=stack_trace)
+            hashcode = received_data.get('hashcode', None)
+
+            self._crypto_db.insert_crypto(
+                hashcode=hashcode,
+                algorithm=None,
+                init_key=None
+            )
+
+            self._crypto_db.update_crypto(
+                hashcode=hashcode,
+                before_final=received_data.get('input', ''),
+                after_final=received_data.get('output', ''),
+                stack_trace=stack_trace,
+                status="complete"
+            )
 
             Logger.print_message(
                 level="D",

{frida_fusion-0.1.9 → frida_fusion-0.1.10}/frida_fusion.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frida-fusion
-Version: 0.1.9
+Version: 0.1.10
 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>