capacitor-dex-editor 0.0.69 → 0.0.70

package/android/src/main/cpp/include/arsc/arsc_parser.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <unordered_map>
+
+namespace arsc {
+
+// Resource types
+enum class ResourceType : uint16_t {
+    NULL_TYPE = 0x00,
+    STRING_POOL = 0x01,
+    TABLE = 0x02,
+    XML = 0x03,
+    TABLE_PACKAGE = 0x0200,
+    TABLE_TYPE = 0x0201,
+    TABLE_TYPE_SPEC = 0x0202,
+};
+
+struct StringPoolHeader {
+    uint32_t string_count;
+    uint32_t style_count;
+    uint32_t flags;
+    uint32_t strings_start;
+    uint32_t styles_start;
+};
+
+struct ResourceEntry {
+    uint32_t id;           // Full resource ID (0xPPTTEEEE)
+    std::string name;      // Resource name
+    std::string type;      // Type name (string, drawable, etc.)
+    std::string value;     // Value (for simple types)
+    std::string package;   // Package name
+};
+
+struct StringResource {
+    uint32_t index;
+    std::string value;
+};
+
+class ArscParser {
+public:
+    ArscParser() = default;
+    ~ArscParser() = default;
+
+    bool parse(const std::vector<uint8_t>& data);
+    bool parse(const std::string& path);
+
+    // Get all strings from string pool
+    const std::vector<std::string>& strings() const { return strings_; }
+    
+    // Get all resources
+    const std::vector<ResourceEntry>& resources() const { return resources_; }
+    
+    // Get package name
+    const std::string& package_name() const { return package_name_; }
+    
+    // Search strings
+    std::vector<StringResource> search_strings(const std::string& pattern) const;
+    
+    // Search resources by name or type
+    std::vector<ResourceEntry> search_resources(const std::string& pattern, 
+                                                 const std::string& type = "") const;
+    
+    // Get resource by ID
+    const ResourceEntry* get_resource(uint32_t id) const;
+    
+    // Get summary info
+    std::string get_info() const;
+
+private:
+    std::vector<uint8_t> data_;
+    std::vector<std::string> strings_;
+    std::vector<ResourceEntry> resources_;
+    std::string package_name_;
+    uint32_t package_id_ = 0;
+    
+    std::unordered_map<uint32_t, size_t> id_to_index_;
+    
+    bool parse_string_pool(size_t offset, size_t size);
+    bool parse_package(size_t offset, size_t size);
+    bool parse_type_spec(size_t offset, size_t size, const std::string& type_name);
+    bool parse_type(size_t offset, size_t size, const std::string& type_name);
+    
+    std::string read_string_at(size_t offset, bool utf8) const;
+    
+    template<typename T>
+    T read_le(size_t offset) const {
+        T val = 0;
+        for (size_t i = 0; i < sizeof(T); i++) {
+            val |= static_cast<T>(data_[offset + i]) << (i * 8);
+        }
+        return val;
+    }
+};
+
+} // namespace arsc

package/android/src/main/cpp/include/dex/dex_builder.h

@@ -0,0 +1,189 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <unordered_map>
+#include <memory>
+#include "dex_parser.h"
+
+namespace dex {
+
+// Access flags
+enum AccessFlags : uint32_t {
+    ACC_PUBLIC = 0x0001,
+    ACC_PRIVATE = 0x0002,
+    ACC_PROTECTED = 0x0004,
+    ACC_STATIC = 0x0008,
+    ACC_FINAL = 0x0010,
+    ACC_SYNCHRONIZED = 0x0020,
+    ACC_VOLATILE = 0x0040,
+    ACC_BRIDGE = 0x0040,
+    ACC_TRANSIENT = 0x0080,
+    ACC_VARARGS = 0x0080,
+    ACC_NATIVE = 0x0100,
+    ACC_INTERFACE = 0x0200,
+    ACC_ABSTRACT = 0x0400,
+    ACC_STRICT = 0x0800,
+    ACC_SYNTHETIC = 0x1000,
+    ACC_ANNOTATION = 0x2000,
+    ACC_ENUM = 0x4000,
+    ACC_CONSTRUCTOR = 0x10000,
+    ACC_DECLARED_SYNCHRONIZED = 0x20000,
+};
+
+// Method prototype
+struct Prototype {
+    std::string return_type;
+    std::vector<std::string> param_types;
+    
+    Prototype() : return_type("V") {}
+    Prototype(const std::string& ret) : return_type(ret) {}
+    Prototype(const std::string& ret, std::initializer_list<std::string> params)
+        : return_type(ret), param_types(params) {}
+    
+    std::string to_string() const;
+};
+
+// Method definition for building
+struct MethodDef {
+    std::string name;
+    Prototype prototype;
+    uint32_t access_flags;
+    uint16_t registers_size;
+    uint16_t ins_size;
+    uint16_t outs_size;
+    std::vector<uint8_t> code;  // bytecode
+};
+
+// Field definition for building
+struct FieldDef {
+    std::string name;
+    std::string type;
+    uint32_t access_flags;
+};
+
+// Class definition for building
+struct ClassBuilder {
+    std::string class_name;
+    std::string super_class;
+    uint32_t access_flags;
+    std::vector<std::string> interfaces;
+    std::vector<FieldDef> static_fields;
+    std::vector<FieldDef> instance_fields;
+    std::vector<MethodDef> direct_methods;   // static, private, constructor
+    std::vector<MethodDef> virtual_methods;  // other methods
+    
+    ClassBuilder(const std::string& name) 
+        : class_name(name), super_class("Ljava/lang/Object;"), access_flags(ACC_PUBLIC) {}
+    
+    ClassBuilder& set_super(const std::string& s) { super_class = s; return *this; }
+    ClassBuilder& set_access(uint32_t f) { access_flags = f; return *this; }
+    ClassBuilder& add_interface(const std::string& i) { interfaces.push_back(i); return *this; }
+    
+    // Add field
+    ClassBuilder& add_field(const std::string& name, const std::string& type, uint32_t flags = ACC_PRIVATE);
+    ClassBuilder& add_static_field(const std::string& name, const std::string& type, uint32_t flags = ACC_PRIVATE | ACC_STATIC);
+    
+    // Add method
+    ClassBuilder& add_method(const MethodDef& method);
+    MethodDef& create_method(const std::string& name, const Prototype& proto, uint32_t flags = ACC_PUBLIC);
+};
+
+// DEX Builder - can build DEX from scratch or modify existing
+class DexBuilder {
+public:
+    DexBuilder();
+    ~DexBuilder() = default;
+    
+    // Load existing DEX as base (for modification)
+    bool load(const std::vector<uint8_t>& data);
+    bool load(const std::string& path);
+    
+    // Create new class
+    ClassBuilder& make_class(const std::string& class_name);
+    
+    // Modify existing class
+    ClassBuilder* get_class(const std::string& class_name);
+    
+    // Add/modify method in existing class
+    bool add_method(const std::string& class_name, const MethodDef& method);
+    bool modify_method(const std::string& class_name, const std::string& method_name, 
+                       const std::string& new_prototype, const std::vector<uint8_t>& new_code);
+    
+    // String/Type pool management
+    uint32_t get_or_add_string(const std::string& str);
+    uint32_t get_or_add_type(const std::string& type);
+    uint32_t get_or_add_proto(const Prototype& proto);
+    uint32_t get_or_add_field(const std::string& class_name, const std::string& field_name, const std::string& type);
+    uint32_t get_or_add_method(const std::string& class_name, const std::string& method_name, const Prototype& proto);
+    
+    // Build final DEX
+    std::vector<uint8_t> build();
+    bool save(const std::string& path);
+    
+    // Get info
+    const std::vector<std::string>& strings() const { return strings_; }
+    const std::vector<std::string>& types() const { return types_; }
+
+private:
+    // String pool
+    std::vector<std::string> strings_;
+    std::unordered_map<std::string, uint32_t> string_map_;
+    
+    // Type pool
+    std::vector<std::string> types_;
+    std::unordered_map<std::string, uint32_t> type_map_;
+    
+    // Proto pool
+    struct ProtoId {
+        uint32_t shorty_idx;
+        uint32_t return_type_idx;
+        std::vector<uint32_t> param_type_idxs;
+    };
+    std::vector<ProtoId> protos_;
+    std::unordered_map<std::string, uint32_t> proto_map_;
+    
+    // Field pool
+    struct FieldId {
+        uint16_t class_idx;
+        uint16_t type_idx;
+        uint32_t name_idx;
+    };
+    std::vector<FieldId> fields_;
+    std::unordered_map<std::string, uint32_t> field_map_;
+    
+    // Method pool
+    struct MethodId {
+        uint16_t class_idx;
+        uint16_t proto_idx;
+        uint32_t name_idx;
+    };
+    std::vector<MethodId> methods_;
+    std::unordered_map<std::string, uint32_t> method_map_;
+    
+    // Classes
+    std::vector<ClassBuilder> classes_;
+    std::unordered_map<std::string, size_t> class_map_;
+    
+    // Original data (if loaded from existing DEX)
+    std::vector<uint8_t> original_data_;
+    bool has_original_ = false;
+    
+    // Helper functions
+    void write_uleb128(std::vector<uint8_t>& out, uint32_t value);
+    void write_sleb128(std::vector<uint8_t>& out, int32_t value);
+    std::string get_shorty(const Prototype& proto) const;
+    
+    // Build sections
+    std::vector<uint8_t> build_string_data();
+    std::vector<uint8_t> build_type_list(const std::vector<uint32_t>& type_idxs);
+    std::vector<uint8_t> build_class_data(const ClassBuilder& cls);
+    std::vector<uint8_t> build_code_item(const MethodDef& method);
+    
+    // Checksum and signature
+    uint32_t compute_checksum(const std::vector<uint8_t>& data);
+    void compute_signature(std::vector<uint8_t>& data);
+};
+
+} // namespace dex

package/android/src/main/cpp/include/dex/dex_parser.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <unordered_map>
+#include <map>
+
+namespace dex {
+
+struct DexHeader {
+    uint8_t magic[8];
+    uint32_t checksum;
+    uint8_t signature[20];
+    uint32_t file_size;
+    uint32_t header_size;
+    uint32_t endian_tag;
+    uint32_t link_size;
+    uint32_t link_off;
+    uint32_t map_off;
+    uint32_t string_ids_size;
+    uint32_t string_ids_off;
+    uint32_t type_ids_size;
+    uint32_t type_ids_off;
+    uint32_t proto_ids_size;
+    uint32_t proto_ids_off;
+    uint32_t field_ids_size;
+    uint32_t field_ids_off;
+    uint32_t method_ids_size;
+    uint32_t method_ids_off;
+    uint32_t class_defs_size;
+    uint32_t class_defs_off;
+    uint32_t data_size;
+    uint32_t data_off;
+};
+
+struct ClassDef {
+    uint32_t class_idx;
+    uint32_t access_flags;
+    uint32_t superclass_idx;
+    uint32_t interfaces_off;
+    uint32_t source_file_idx;
+    uint32_t annotations_off;
+    uint32_t class_data_off;
+    uint32_t static_values_off;
+};
+
+struct CodeItem {
+    uint16_t registers_size;
+    uint16_t ins_size;
+    uint16_t outs_size;
+    uint16_t tries_size;
+    uint32_t debug_info_off;
+    uint32_t insns_size;  // in 16-bit code units
+    std::vector<uint8_t> insns;
+    uint32_t code_off;    // offset of code_item in DEX file
+};
+
+struct MethodInfo {
+    std::string class_name;
+    std::string method_name;
+    std::string prototype;
+    uint32_t access_flags;
+    uint32_t code_off;
+};
+
+struct FieldInfo {
+    std::string class_name;
+    std::string field_name;
+    std::string type_name;
+    uint32_t access_flags;
+};
+
+class DexParser {
+public:
+    DexParser() = default;
+    ~DexParser() = default;
+
+    bool parse(const std::vector<uint8_t>& data);
+    bool parse(const std::string& path);
+
+    const DexHeader& header() const { return header_; }
+    const std::vector<std::string>& strings() const { return strings_; }
+    const std::vector<std::string>& types() const { return types_; }
+    const std::vector<ClassDef>& classes() const { return classes_; }
+    std::vector<MethodInfo> get_methods() const;
+    std::vector<FieldInfo> get_fields() const;
+
+    std::string get_class_name(uint32_t idx) const;
+    std::vector<std::string> get_class_methods(const std::string& class_name) const;
+    
+    // Get method code for disassembly
+    bool get_method_code(const std::string& class_name, const std::string& method_name, CodeItem& code) const;
+    
+    // Get all method codes at once (optimized batch operation)
+    std::unordered_map<std::string, CodeItem> get_all_method_codes() const;
+    
+    // Get all method signatures for reference resolution
+    std::vector<std::string> get_method_signatures() const;
+    std::vector<std::string> get_field_signatures() const;
+    
+    // Get full method signature with parameters and return type
+    std::string get_full_method_signature(uint32_t method_idx) const;
+    std::string get_proto_string(uint32_t proto_idx) const;
+    
+    // Cross-reference analysis
+    struct XRef {
+        std::string caller_class;
+        std::string caller_method;
+        uint32_t offset;
+    };
+    std::vector<XRef> find_method_xrefs(const std::string& class_name, const std::string& method_name) const;
+    std::vector<XRef> find_field_xrefs(const std::string& class_name, const std::string& field_name) const;
+
+    std::string get_info() const;
+    
+    const std::vector<uint8_t>& data() const { return data_; }
+
+private:
+    DexHeader header_;
+    std::vector<uint8_t> data_;
+    std::vector<std::string> strings_;
+    std::vector<std::string> types_;
+    std::vector<ClassDef> classes_;
+    std::vector<uint32_t> string_ids_;
+    std::vector<uint32_t> type_ids_;
+
+    bool parse_header();
+    bool parse_strings();
+    bool parse_types();
+    bool parse_classes();
+
+    std::string read_string_at(uint32_t offset) const;
+    uint32_t read_uleb128(size_t& offset) const;
+};
+
+} // namespace dex

package/android/src/main/cpp/include/dex/smali_disasm.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <map>
+
+namespace dex {
+
+// Dalvik opcode formats
+enum class OpcodeFormat {
+    k10x,  // op
+    k12x,  // op vA, vB
+    k11n,  // op vA, #+B
+    k11x,  // op vAA
+    k10t,  // op +AA
+    k20t,  // op +AAAA
+    k22x,  // op vAA, vBBBB
+    k21t,  // op vAA, +BBBB
+    k21s,  // op vAA, #+BBBB
+    k21h,  // op vAA, #+BBBB0000(00000000)
+    k21c,  // op vAA, type@BBBB / field@BBBB / string@BBBB
+    k23x,  // op vAA, vBB, vCC
+    k22b,  // op vAA, vBB, #+CC
+    k22t,  // op vA, vB, +CCCC
+    k22s,  // op vA, vB, #+CCCC
+    k22c,  // op vA, vB, type@CCCC / field@CCCC
+    k32x,  // op vAAAA, vBBBB
+    k30t,  // op +AAAAAAAA
+    k31t,  // op vAA, +BBBBBBBB
+    k31i,  // op vAA, #+BBBBBBBB
+    k31c,  // op vAA, string@BBBBBBBB
+    k35c,  // op {vC, vD, vE, vF, vG}, meth@BBBB / type@BBBB
+    k3rc,  // op {vCCCC .. vNNNN}, meth@BBBB / type@BBBB
+    k51l,  // op vAA, #+BBBBBBBBBBBBBBBB
+    kPackedSwitch,
+    kSparseSwitch,
+    kFillArrayData,
+    kUnknown
+};
+
+struct OpcodeInfo {
+    const char* name;
+    OpcodeFormat format;
+    uint8_t size;  // in 16-bit code units
+};
+
+struct DisassembledInsn {
+    uint32_t offset;
+    std::string opcode;
+    std::string operands;
+    std::string comment;
+    std::vector<uint16_t> raw_bytes;
+};
+
+class SmaliDisassembler {
+public:
+    SmaliDisassembler() = default;
+    ~SmaliDisassembler() = default;
+
+    // Set context for resolving references
+    void set_strings(const std::vector<std::string>& strings) { strings_ = strings; }
+    void set_types(const std::vector<std::string>& types) { types_ = types; }
+    void set_methods(const std::vector<std::string>& methods) { methods_ = methods; }
+    void set_fields(const std::vector<std::string>& fields) { fields_ = fields; }
+
+    // Disassemble a single instruction
+    DisassembledInsn disassemble_insn(const uint8_t* code, size_t code_size, uint32_t offset);
+
+    // Disassemble entire method code
+    std::vector<DisassembledInsn> disassemble_method(const uint8_t* code, size_t code_size);
+
+    // Convert disassembled instructions to Smali text
+    std::string to_smali(const std::vector<DisassembledInsn>& insns);
+
+    // Get opcode info
+    static const OpcodeInfo& get_opcode_info(uint8_t opcode);
+    static int get_opcode_by_name(const std::string& name);
+
+private:
+    std::vector<std::string> strings_;
+    std::vector<std::string> types_;
+    std::vector<std::string> methods_;
+    std::vector<std::string> fields_;
+
+    std::string resolve_string(uint32_t idx) const;
+    std::string resolve_type(uint32_t idx) const;
+    std::string resolve_method(uint32_t idx) const;
+    std::string resolve_field(uint32_t idx) const;
+
+    static const OpcodeInfo opcodes_[256];
+};
+
+// Smali Assembler - converts Smali text to bytecode
+class SmaliAssembler {
+public:
+    SmaliAssembler() = default;
+    ~SmaliAssembler() = default;
+
+    // Set context for reference lookup
+    void set_strings(const std::vector<std::string>& strings) { strings_ = strings; }
+    void set_types(const std::vector<std::string>& types) { types_ = types; }
+    void set_methods(const std::vector<std::string>& methods) { methods_ = methods; }
+    void set_fields(const std::vector<std::string>& fields) { fields_ = fields; }
+
+    // Assemble Smali text to bytecode
+    bool assemble(const std::string& smali_code, std::vector<uint8_t>& bytecode, std::string& error);
+
+    // Assemble a single instruction
+    bool assemble_insn(const std::string& line, std::vector<uint8_t>& bytecode, std::string& error);
+
+private:
+    std::vector<std::string> strings_;
+    std::vector<std::string> types_;
+    std::vector<std::string> methods_;
+    std::vector<std::string> fields_;
+
+    int find_string(const std::string& str) const;
+    int find_type(const std::string& type) const;
+    int find_method(const std::string& method) const;
+    int find_field(const std::string& field) const;
+
+    bool parse_register(const std::string& reg, int& num);
+    bool parse_int(const std::string& str, int64_t& val);
+};
+
+} // namespace dex

package/android/src/main/cpp/include/dex/smali_to_java.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <sstream>
+
+namespace dex {
+
+class SmaliToJava {
+public:
+    SmaliToJava() = default;
+    
+    // Convert Smali code to Java-like pseudocode
+    std::string convert(const std::string& smali_code);
+    
+    // Convert a single method
+    std::string convert_method(const std::string& method_smali);
+
+private:
+    struct Register {
+        std::string type;
+        std::string value;
+        bool is_param = false;
+    };
+    
+    std::unordered_map<std::string, Register> registers_;
+    std::unordered_map<std::string, int> labels_;  // label -> line number
+    int indent_ = 0;
+    
+    std::string convert_instruction(const std::string& line);
+    std::string convert_invoke(const std::string& line);
+    std::string convert_field_access(const std::string& line);
+    std::string convert_const(const std::string& line);
+    std::string convert_move(const std::string& line);
+    std::string convert_return(const std::string& line);
+    std::string convert_if(const std::string& line);
+    std::string convert_new(const std::string& line);
+    std::string convert_array(const std::string& line);
+    std::string convert_cast(const std::string& line);
+    std::string convert_arithmetic(const std::string& line);
+    
+    std::string type_to_java(const std::string& smali_type);
+    std::string method_to_java(const std::string& method_ref);
+    std::string get_indent();
+    std::vector<std::string> split(const std::string& s, char delim);
+    std::string trim(const std::string& s);
+};
+
+} // namespace dex