capacitor-dex-editor 0.0.77 → 0.0.79

package/android/build.gradle

@@ -77,9 +77,9 @@ dependencies {
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     
     // dexlib2 & smali - DEX文件编辑核心库 (使用 api 暴露给主项目)
+    // baksmali 已移除 - 使用 C++ 实现
     api 'com.android.tools.smali:smali-dexlib2:3.0.3'
     api 'com.android.tools.smali:smali:3.0.3'
-    api 'com.android.tools.smali:smali-baksmali:3.0.3'
     
     // Guava - dexlib2 依赖
     api 'com.google.guava:guava:32.1.3-android'

package/android/src/main/cpp/jni_bridge.cpp

@@ -121,112 +121,168 @@ Java_com_aetherlink_dexeditor_CppDex_listClasses(JNIEnv* env, jclass, jbyteArray
     return string_to_jstring(env, result.dump());
 }
 
-JNIEXPORT jstring JNICALL
-Java_com_aetherlink_dexeditor_CppDex_searchInDex(JNIEnv* env, jclass, jbyteArray dexBytes,
-                                                  jstring query, jstring searchType,
-                                                  jboolean caseSensitive, jint maxResults) {
-    auto data = jbyteArray_to_vector(env, dexBytes);
-    std::string q = jstring_to_string(env, query);
-    std::string type = jstring_to_string(env, searchType);
-    
-    dex::DexParser parser;
-    if (!parser.parse(data)) {
-        json error = {{"error", "Failed to parse DEX"}};
-        return string_to_jstring(env, error.dump());
+// Helper: Safe ASCII lowercase (UTF-8 safe - only converts ASCII a-z)
+static std::string safe_tolower_ascii(const std::string& s) {
+    std::string result = s;
+    for (char& c : result) {
+        if (c >= 'A' && c <= 'Z') {
+            c = c + ('a' - 'A');
+        }
     }
-    
-    json results = json::array();
-    int count = 0;
-    
-    // 转换为小写用于不区分大小写搜索
-    std::string q_lower = q;
-    if (!caseSensitive) {
-        std::transform(q_lower.begin(), q_lower.end(), q_lower.begin(), ::tolower);
+    return result;
+}
+
+// Helper: Safe string contains check (UTF-8 safe)
+static bool safe_contains(const std::string& haystack, const std::string& needle, bool caseSensitive) {
+    if (caseSensitive) {
+        return haystack.find(needle) != std::string::npos;
     }
-    
-    if (type == "string") {
-        for (const auto& s : parser.strings()) {
-            if (count >= maxResults) break;
-            
-            std::string s_check = caseSensitive ? s : s;
-            if (!caseSensitive) {
-                s_check.resize(s.size());
-                std::transform(s.begin(), s.end(), s_check.begin(), ::tolower);
-            }
-            
-            if (s_check.find(q_lower) != std::string::npos) {
-                results.push_back({{"type", "string"}, {"value", s}});
-                count++;
+    // Only lowercase ASCII for case-insensitive search
+    std::string h_lower = safe_tolower_ascii(haystack);
+    std::string n_lower = safe_tolower_ascii(needle);
+    return h_lower.find(n_lower) != std::string::npos;
+}
+
+// Helper: Sanitize string for JSON (replace invalid UTF-8 sequences)
+static std::string sanitize_utf8(const std::string& s) {
+    std::string result;
+    result.reserve(s.size());
+    size_t i = 0;
+    while (i < s.size()) {
+        unsigned char c = s[i];
+        if (c < 0x80) {
+            // ASCII
+            result += c;
+            i++;
+        } else if ((c & 0xE0) == 0xC0 && i + 1 < s.size()) {
+            // 2-byte UTF-8
+            if ((s[i+1] & 0xC0) == 0x80) {
+                result += s[i];
+                result += s[i+1];
+                i += 2;
+            } else {
+                result += '?';
+                i++;
             }
-        }
-    } else if (type == "class") {
-        for (const auto& cls : parser.classes()) {
-            if (count >= maxResults) break;
-            std::string class_name = parser.get_class_name(cls.class_idx);
-            
-            std::string check = caseSensitive ? class_name : class_name;
-            if (!caseSensitive) {
-                check.resize(class_name.size());
-                std::transform(class_name.begin(), class_name.end(), check.begin(), ::tolower);
+        } else if ((c & 0xF0) == 0xE0 && i + 2 < s.size()) {
+            // 3-byte UTF-8
+            if ((s[i+1] & 0xC0) == 0x80 && (s[i+2] & 0xC0) == 0x80) {
+                result += s[i];
+                result += s[i+1];
+                result += s[i+2];
+                i += 3;
+            } else {
+                result += '?';
+                i++;
             }
-            
-            if (check.find(q_lower) != std::string::npos) {
-                results.push_back({{"type", "class"}, {"name", class_name}});
-                count++;
+        } else if ((c & 0xF8) == 0xF0 && i + 3 < s.size()) {
+            // 4-byte UTF-8
+            if ((s[i+1] & 0xC0) == 0x80 && (s[i+2] & 0xC0) == 0x80 && (s[i+3] & 0xC0) == 0x80) {
+                result += s[i];
+                result += s[i+1];
+                result += s[i+2];
+                result += s[i+3];
+                i += 4;
+            } else {
+                result += '?';
+                i++;
             }
+        } else {
+            // Invalid UTF-8, replace with ?
+            result += '?';
+            i++;
         }
-    } else if (type == "method") {
-        auto methods = parser.get_methods();
-        for (const auto& m : methods) {
-            if (count >= maxResults) break;
-            
-            std::string check = caseSensitive ? m.method_name : m.method_name;
-            if (!caseSensitive) {
-                check.resize(m.method_name.size());
-                std::transform(m.method_name.begin(), m.method_name.end(), check.begin(), ::tolower);
+    }
+    return result;
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_aetherlink_dexeditor_CppDex_searchInDex(JNIEnv* env, jclass, jbyteArray dexBytes,
+                                                  jstring query, jstring searchType,
+                                                  jboolean caseSensitive, jint maxResults) {
+    try {
+        auto data = jbyteArray_to_vector(env, dexBytes);
+        std::string q = jstring_to_string(env, query);
+        std::string type = jstring_to_string(env, searchType);
+        
+        dex::DexParser parser;
+        if (!parser.parse(data)) {
+            json error = {{"error", "Failed to parse DEX"}};
+            return string_to_jstring(env, error.dump());
+        }
+        
+        json results = json::array();
+        int count = 0;
+        
+        if (type == "string") {
+            for (const auto& s : parser.strings()) {
+                if (count >= maxResults) break;
+                
+                if (safe_contains(s, q, caseSensitive)) {
+                    // Sanitize string for JSON
+                    results.push_back({{"type", "string"}, {"value", sanitize_utf8(s)}});
+                    count++;
+                }
             }
-            
-            if (check.find(q_lower) != std::string::npos) {
-                results.push_back({
-                    {"type", "method"},
-                    {"class", m.class_name},
-                    {"name", m.method_name},
-                    {"prototype", m.prototype}
-                });
-                count++;
+        } else if (type == "class") {
+            for (const auto& cls : parser.classes()) {
+                if (count >= maxResults) break;
+                std::string class_name = parser.get_class_name(cls.class_idx);
+                
+                if (safe_contains(class_name, q, caseSensitive)) {
+                    results.push_back({{"type", "class"}, {"name", sanitize_utf8(class_name)}});
+                    count++;
+                }
             }
-        }
-    } else if (type == "field") {
-        auto fields = parser.get_fields();
-        for (const auto& f : fields) {
-            if (count >= maxResults) break;
-            
-            std::string check = caseSensitive ? f.field_name : f.field_name;
-            if (!caseSensitive) {
-                check.resize(f.field_name.size());
-                std::transform(f.field_name.begin(), f.field_name.end(), check.begin(), ::tolower);
+        } else if (type == "method") {
+            auto methods = parser.get_methods();
+            for (const auto& m : methods) {
+                if (count >= maxResults) break;
+                
+                if (safe_contains(m.method_name, q, caseSensitive)) {
+                    results.push_back({
+                        {"type", "method"},
+                        {"class", sanitize_utf8(m.class_name)},
+                        {"name", sanitize_utf8(m.method_name)},
+                        {"prototype", sanitize_utf8(m.prototype)}
+                    });
+                    count++;
+                }
             }
-            
-            if (check.find(q_lower) != std::string::npos) {
-                results.push_back({
-                    {"type", "field"},
-                    {"class", f.class_name},
-                    {"name", f.field_name},
-                    {"fieldType", f.type_name}
-                });
-                count++;
+        } else if (type == "field") {
+            auto fields = parser.get_fields();
+            for (const auto& f : fields) {
+                if (count >= maxResults) break;
+                
+                if (safe_contains(f.field_name, q, caseSensitive)) {
+                    results.push_back({
+                        {"type", "field"},
+                        {"class", sanitize_utf8(f.class_name)},
+                        {"name", sanitize_utf8(f.field_name)},
+                        {"fieldType", sanitize_utf8(f.type_name)}
+                    });
+                    count++;
+                }
             }
         }
+        
+        json result = {
+            {"query", sanitize_utf8(q)},
+            {"searchType", type},
+            {"results", results},
+            {"count", results.size()}
+        };
+        
+        return string_to_jstring(env, result.dump());
+    } catch (const std::exception& e) {
+        LOGE("searchInDex exception: %s", e.what());
+        json error = {{"error", std::string("Search failed: ") + e.what()}};
+        return string_to_jstring(env, error.dump());
+    } catch (...) {
+        LOGE("searchInDex unknown exception");
+        json error = {{"error", "Search failed: unknown error"}};
+        return string_to_jstring(env, error.dump());
     }
-    
-    json result = {
-        {"query", q},
-        {"searchType", type},
-        {"results", results},
-        {"count", results.size()}
-    };
-    
-    return string_to_jstring(env, result.dump());
 }
 
 JNIEXPORT jstring JNICALL

package/android/src/main/java/com/aetherlink/dexeditor/DexManager.java

@@ -27,10 +27,6 @@ import com.android.tools.smali.dexlib2.immutable.ImmutableField;
 import com.android.tools.smali.dexlib2.immutable.ImmutableMethod;
 import com.android.tools.smali.dexlib2.writer.io.FileDataStore;
 import com.android.tools.smali.dexlib2.writer.pool.DexPool;
-import com.android.tools.smali.baksmali.Baksmali;
-import com.android.tools.smali.baksmali.BaksmaliOptions;
-import com.android.tools.smali.baksmali.Adaptors.ClassDefinition;
-import com.android.tools.smali.baksmali.formatter.BaksmaliWriter;
 import com.android.tools.smali.smali.Smali;
 import com.android.tools.smali.smali.SmaliOptions;
 
@@ -111,6 +107,7 @@ public class DexManager {
         long lastModified;
         Map<String, ClassDef> classDefMap; // type -> ClassDef
         int dexVersion;
+        byte[] dexBytes; // DEX 原始字节用于 C++ 操作
         
         ApkDexCache(String apkPath, String dexPath) {
             this.apkPath = apkPath;
@@ -882,49 +879,12 @@ public class DexManager {
                     }
                 }
             } catch (Exception e) {
-                Log.w(TAG, "C++ classToSmali failed, fallback to Java", e);
+                Log.w(TAG, "C++ classToSmali failed", e);
+                throw new Exception("C++ classToSmali failed: " + e.getMessage());
             }
         }
         
-        // Java 回退实现
-        ClassDef classDef = findClass(session, className);
-        if (classDef == null) {
-            throw new IllegalArgumentException("Class not found: " + className);
-        }
-
-        StringWriter writer = new StringWriter();
-        BaksmaliOptions options = new BaksmaliOptions();
-        
-        List<ClassDef> singleClass = new ArrayList<>();
-        singleClass.add(classDef);
-        ImmutableDexFile singleDex = new ImmutableDexFile(
-            session.originalDexFile.getOpcodes(), 
-            singleClass
-        );
-
-        File tempDir = File.createTempFile("smali_", "_temp");
-        tempDir.delete();
-        tempDir.mkdirs();
-
-        try {
-            Baksmali.disassembleDexFile(singleDex, tempDir, 1, options);
-            
-            String smaliPath = className.substring(1, className.length() - 1) + ".smali";
-            File smaliFile = new File(tempDir, smaliPath);
-            
-            if (smaliFile.exists()) {
-                String smali = readFileContent(smaliFile);
-                JSObject result = new JSObject();
-                result.put("className", className);
-                result.put("smali", smali);
-                result.put("engine", "java");
-                return result;
-            } else {
-                throw new IOException("Failed to generate smali for: " + className);
-            }
-        } finally {
-            deleteRecursive(tempDir);
-        }
+        throw new UnsupportedOperationException("C++ library not available for classToSmali");
     }
 
     /**
@@ -978,15 +938,12 @@ public class DexManager {
                     }
                 }
             } catch (Exception e) {
-                Log.w(TAG, "C++ disassemble failed, fallback to Java", e);
+                Log.w(TAG, "C++ disassemble failed", e);
+                throw new Exception("C++ disassemble failed: " + e.getMessage());
             }
         }
 
-        // Java 回退实现
-        BaksmaliOptions options = new BaksmaliOptions();
-        Baksmali.disassembleDexFile(session.originalDexFile, outDir, 4, options);
-        
-        Log.d(TAG, "Disassembled to: " + outputDir);
+        throw new UnsupportedOperationException("C++ library not available for disassemble");
     }
 
     /**
@@ -2272,20 +2229,11 @@ public class DexManager {
     }
 
     /**
-     * 获取类的 Smali 代码（内部方法）
+     * 获取类的 Smali 代码（内部方法）- 使用 C++ 实现
      */
     private String getSmaliForClass(DexBackedDexFile dexFile, ClassDef classDef) {
-        try {
-            BaksmaliOptions options = new BaksmaliOptions();
-            ClassDefinition classDefinition = new ClassDefinition(options, classDef);
-            java.io.StringWriter stringWriter = new java.io.StringWriter();
-            BaksmaliWriter writer = new BaksmaliWriter(stringWriter, null);
-            classDefinition.writeTo(writer);
-            writer.close();
-            return stringWriter.toString();
-        } catch (Exception e) {
-            return "";
-        }
+        // 此方法已弃用，使用 C++ 实现
+        return "";
     }
 
 
@@ -3115,6 +3063,9 @@ public class DexManager {
             dexInputStream.close();
             byte[] dexBytes = baos.toByteArray();
             
+            // 保存 DEX 字节用于 C++ 操作
+            cache.dexBytes = dexBytes;
+            
             // 解析 DEX 文件并缓存所有 ClassDef
             DexBackedDexFile dexFile = new DexBackedDexFile(Opcodes.getDefault(), dexBytes);
             cache.dexVersion = 35; // 默认 DEX 版本
@@ -3146,7 +3097,7 @@ public class DexManager {
     }
     
     /**
-     * 从 APK 中的 DEX 文件获取类的 Smali 代码（使用缓存）
+     * 从 APK 中的 DEX 文件获取类的 Smali 代码（使用 C++ 实现）
      */
     public JSObject getClassSmaliFromApk(String apkPath, String dexPath, String className) throws Exception {
         JSObject result = new JSObject();
@@ -3161,26 +3112,22 @@ public class DexManager {
         String targetType = convertClassNameToType(className);
         
         try {
-            // 使用缓存获取 ClassDef
-            ApkDexCache cache = getOrCreateDexCache(apkPath, dexPath);
-            ClassDef targetClass = cache.classDefMap.get(targetType);
-            
-            if (targetClass == null) {
-                result.put("smali", "# 类未找到: " + className + "\n# 目标类型: " + targetType);
-                return result;
+            // 使用 C++ 实现获取 Smali
+            if (CppDex.isAvailable()) {
+                ApkDexCache cache = getOrCreateDexCache(apkPath, dexPath);
+                if (cache.dexBytes != null) {
+                    String smaliJson = CppDex.getClassSmali(cache.dexBytes, targetType);
+                    if (smaliJson != null && !smaliJson.contains("\"error\"")) {
+                        org.json.JSONObject smaliResult = new org.json.JSONObject(smaliJson);
+                        String smali = smaliResult.optString("smali", "");
+                        if (!smali.isEmpty()) {
+                            result.put("smali", smali);
+                            return result;
+                        }
+                    }
+                }
             }
-            
-            // 使用 baksmali 库生成正确的 Smali 代码
-            BaksmaliOptions options = new BaksmaliOptions();
-            ClassDefinition classDefinition = new ClassDefinition(options, targetClass);
-            
-            java.io.StringWriter stringWriter = new java.io.StringWriter();
-            BaksmaliWriter writer = new BaksmaliWriter(stringWriter, null);
-            classDefinition.writeTo(writer);
-            writer.close();
-            
-            result.put("smali", stringWriter.toString());
-            
+            result.put("smali", "# 类未找到或 C++ 库不可用: " + className);
         } catch (Exception e) {
             result.put("smali", "# 加载失败: " + e.getMessage());
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-dex-editor",
-  "version": "0.0.77",
+  "version": "0.0.79",
   "description": "Capacitor-plugin-for-editing-DEX-files-in-APK",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",