reproto 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

parsing/java_parser.py

@@ -359,9 +359,8 @@ class JavaParser:
         """
         从Java文件中提取字段标签信息
         
-        解析类似这样的常量定义：
-        public static final int TEXT_FIELD_NUMBER = 1;
-        public static final int ISFINAL_FIELD_NUMBER = 2;
+        优先从Java源码中直接找到字段名与标签的对应关系，
+        而不是依赖常量名的转换推测
         
         Args:
             java_file_path: Java文件路径
@@ -373,64 +372,238 @@ class JavaParser:
             # 读取Java文件内容
             content = java_file_path.read_text(encoding='utf-8')
             
-            # 匹配字段标签常量定义
-            # 格式：public static final int FIELD_NAME_FIELD_NUMBER = 数字;
-            field_tag_pattern = re.compile(
-                r'public\s+static\s+final\s+int\s+'
-                r'([A-Z_]+)_FIELD_NUMBER\s*=\s*(\d+)\s*;'
-            )
+            # 方法1：直接从源码中找到字段声明和对应的FIELD_NUMBER常量
+            field_tags = self._extract_field_tags_from_source(content)
             
-            field_tags = {}
+            if field_tags:
+                return field_tags
             
-            # 查找所有字段标签定义
-            for match in field_tag_pattern.finditer(content):
-                field_const_name = match.group(1)  # 如 TEXT, ISFINAL
-                tag_value = int(match.group(2))     # 如 1, 2
-                
-                # 转换常量名为字段名
-                # TEXT -> text_, ISFINAL -> isFinal_
-                field_name = self._const_name_to_field_name(field_const_name)
-                field_tags[field_name] = tag_value
-                
-                self.logger.debug(f"    🏷️ 提取字段标签: {field_name} = {tag_value}")
-            
-            return field_tags if field_tags else None
+            # 方法2：如果方法1失败，回退到常量名转换方法
+            return self._extract_field_tags_from_constants(content)
             
         except Exception as e:
             self.logger.error(f"❌ 提取字段标签失败 {java_file_path}: {e}")
             return None
     
+    def _extract_field_tags_from_source(self, content: str) -> Optional[dict]:
+        """
+        直接从Java源码中提取字段名和标签的对应关系
+        
+        通过分析实际的字段声明和常量定义来建立准确的映射
+        
+        Args:
+            content: Java文件内容
+            
+        Returns:
+            字段标签映射 {field_name: tag} 或 None
+        """
+        # 提取所有字段声明
+        field_declarations = self._extract_all_field_declarations(content)
+        
+        # 提取所有FIELD_NUMBER常量
+        field_constants = self._extract_field_number_constants(content)
+        
+        if not field_declarations or not field_constants:
+            return None
+        
+        # 建立字段名到标签的映射
+        field_tags = {}
+        
+        # 尝试通过字段名匹配找到对应的常量
+        for field_name in field_declarations:
+            # 生成可能的常量名
+            possible_const_names = self._generate_possible_constant_names(field_name)
+            
+            # 查找匹配的常量
+            for const_name in possible_const_names:
+                if const_name in field_constants:
+                    field_tags[field_name] = field_constants[const_name]
+                    self.logger.debug(f"    🎯 直接匹配字段: {field_name} -> {const_name} = {field_constants[const_name]}")
+                    break
+        
+        return field_tags if field_tags else None
+    
+    def _extract_all_field_declarations(self, content: str) -> List[str]:
+        """
+        提取所有字段声明
+        
+        Args:
+            content: Java文件内容
+            
+        Returns:
+            字段名列表
+        """
+        field_pattern = re.compile(
+            r'private\s+(?:static\s+)?(?:final\s+)?'  # 访问修饰符
+            r'[^\s]+(?:<[^>]*>)?(?:\[\])?'             # 类型（包括泛型和数组）
+            r'\s+([a-zA-Z_][a-zA-Z0-9_]*_?)\s*[=;]',  # 字段名
+            re.MULTILINE
+        )
+        
+        field_names = []
+        for match in field_pattern.finditer(content):
+            field_name = match.group(1)
+            # 跳过明显的常量字段（全大写）
+            if not field_name.isupper() and not field_name.startswith('DEFAULT_'):
+                field_names.append(field_name)
+        
+        return field_names
+    
+    def _extract_field_number_constants(self, content: str) -> dict:
+        """
+        提取所有FIELD_NUMBER常量
+        
+        Args:
+            content: Java文件内容
+            
+        Returns:
+            常量名到值的映射 {const_name: value}
+        """
+        field_tag_pattern = re.compile(
+            r'\s*public\s+static\s+final\s+int\s+'  # 允许行首有空白字符
+            r'([A-Z0-9_]+)_FIELD_NUMBER\s*=\s*(\d+)\s*;'  # 允许常量名包含数字
+        )
+        
+        constants = {}
+        for match in field_tag_pattern.finditer(content):
+            const_name = match.group(1)
+            tag_value = int(match.group(2))
+            constants[const_name] = tag_value
+        
+        return constants
+    
+    def _generate_possible_constant_names(self, field_name: str) -> List[str]:
+        """
+        根据字段名生成可能的常量名
+        
+        Args:
+            field_name: 字段名（如 e164Format_, telType_）
+            
+        Returns:
+            可能的常量名列表
+        """
+        # 移除末尾的下划线
+        clean_name = field_name.rstrip('_')
+        
+        possible_names = []
+        
+        # 方法1：直接转换为大写
+        # e164Format -> E164FORMAT
+        possible_names.append(clean_name.upper())
+        
+        # 方法2：在camelCase边界添加下划线
+        # e164Format -> E164_FORMAT
+        camel_to_snake = re.sub('([a-z0-9])([A-Z])', r'\1_\2', clean_name).upper()
+        possible_names.append(camel_to_snake)
+        
+        # 方法3：处理数字和字母的边界
+        # e164Format -> E_164_FORMAT
+        with_number_boundaries = re.sub('([a-zA-Z])([0-9])', r'\1_\2', clean_name)
+        with_number_boundaries = re.sub('([0-9])([a-zA-Z])', r'\1_\2', with_number_boundaries)
+        with_number_boundaries = re.sub('([a-z])([A-Z])', r'\1_\2', with_number_boundaries).upper()
+        possible_names.append(with_number_boundaries)
+        
+        return list(set(possible_names))  # 去重
+    
+    def _extract_field_tags_from_constants(self, content: str) -> Optional[dict]:
+        """
+        从常量定义中提取字段标签（回退方法）
+        
+        Args:
+            content: Java文件内容
+            
+        Returns:
+            字段标签映射 {field_name: tag} 或 None
+        """
+        # 匹配字段标签常量定义
+        field_tag_pattern = re.compile(
+            r'\s*public\s+static\s+final\s+int\s+'  # 允许行首有空白字符
+            r'([A-Z0-9_]+)_FIELD_NUMBER\s*=\s*(\d+)\s*;'  # 允许常量名包含数字
+        )
+        
+        field_tags = {}
+        
+        # 查找所有字段标签定义
+        for match in field_tag_pattern.finditer(content):
+            field_const_name = match.group(1)  # 如 TEXT, ISFINAL
+            tag_value = int(match.group(2))     # 如 1, 2
+            
+            # 转换常量名为字段名
+            field_name = self._const_name_to_field_name(field_const_name)
+            field_tags[field_name] = tag_value
+            
+            self.logger.debug(f"    🔄 回退转换字段标签: {field_name} = {tag_value}")
+        
+        return field_tags if field_tags else None
+    
     def _const_name_to_field_name(self, const_name: str) -> str:
         """
-        将常量名转换为字段名
+        将常量名转换为字段名（通用算法，无硬编码）
         
         Args:
-            const_name: 常量名（如 TEXT, ISFINAL, PAYLOADTYPE, USERID, INSTALLATIONID）
+            const_name: 常量名（如 TEXT, ISFINAL, PAYLOADTYPE, E164_FORMAT）
             
         Returns:
-            字段名（如 text_, isFinal_, payloadType_, userId_, installationId_）
-        """
-        # 特殊处理一些常见模式
-        special_cases = {
-            'ISFINAL': 'isFinal',
-            'PAYLOADTYPE': 'payloadType',
-            'TERMINATIONREASON': 'terminationReason',
-            'USERID': 'userId',
-            'INSTALLATIONID': 'installationId',
-            'PHONENUMBER': 'phoneNumber',
-            'COUNTRYCODE': 'countryCode',
-        }
-        
-        if const_name in special_cases:
-            return special_cases[const_name] + '_'
-        
-        # 通用转换：将UPPER_CASE转换为camelCase
+            字段名（如 text_, isFinal_, payloadType_, e164Format_）
+        """
+        # 通用转换算法：将UPPER_CASE转换为camelCase
         if '_' in const_name:
-            # 处理下划线分隔的常量名
+            # 处理下划线分隔的常量名：E164_FORMAT -> e164Format
             parts = const_name.lower().split('_')
             field_name = parts[0] + ''.join(word.capitalize() for word in parts[1:])
         else:
-            # 处理单个单词的常量名
-            field_name = const_name.lower()
+            # 处理单个单词的常量名：TEXT -> text
+            # 处理复合词常量名：ISFINAL -> isFinal, PAYLOADTYPE -> payloadType
+            field_name = self._split_compound_word(const_name)
         
-        return field_name + '_' 
+        return field_name + '_'
+    
+    def _split_compound_word(self, word: str) -> str:
+        """
+        智能分割复合词并转换为camelCase
+        
+        Args:
+            word: 大写复合词（如 ISFINAL, PAYLOADTYPE, USERID）
+            
+        Returns:
+            camelCase格式的字段名（如 isFinal, payloadType, userId）
+        """
+        # 将单词转换为小写
+        word_lower = word.lower()
+        
+        # 使用启发式规则分割复合词
+        # 这些是常见的英语词汇模式，无需硬编码特定应用的词汇
+        common_prefixes = ['is', 'has', 'can', 'should', 'will', 'get', 'set']
+        common_suffixes = ['type', 'id', 'code', 'number', 'name', 'data', 'info', 'status', 'mode', 'format']
+        
+        # 检查前缀模式
+        for prefix in common_prefixes:
+            if word_lower.startswith(prefix) and len(word_lower) > len(prefix):
+                rest = word_lower[len(prefix):]
+                return prefix + rest.capitalize()
+        
+        # 检查后缀模式
+        for suffix in common_suffixes:
+            if word_lower.endswith(suffix) and len(word_lower) > len(suffix):
+                prefix_part = word_lower[:-len(suffix)]
+                return prefix_part + suffix.capitalize()
+        
+        # 如果没有匹配的模式，尝试基于常见的英语单词边界进行分割
+        # 这里可以使用更复杂的NLP技术，但为了保持简单，使用基本的启发式
+        
+        # 检查常见的双词组合模式
+        if len(word_lower) >= 6:
+            # 尝试在中间位置分割
+            mid_point = len(word_lower) // 2
+            for i in range(max(3, mid_point - 2), min(len(word_lower) - 2, mid_point + 3)):
+                first_part = word_lower[:i]
+                second_part = word_lower[i:]
+                
+                # 检查是否是合理的分割（基于常见英语单词长度）
+                if (3 <= len(first_part) <= 8 and 3 <= len(second_part) <= 8 and
+                    not first_part.endswith(second_part[:2]) and  # 避免重复
+                    not second_part.startswith(first_part[-2:])):  # 避免重复
+                    return first_part + second_part.capitalize()
+        
+        # 如果无法智能分割，直接返回小写形式
+        return word_lower 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "reproto"
-version = "0.0.8"
+version = "0.0.9"
 description = "一个强大的逆向工程工具, 能够从任何使用Google Protobuf Lite的Android应用中自动重构出完整的.proto文件结构."
 readme = "README.md"
 license = "Proprietary"

reproto-0.0.9.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.3
+Name: reproto
+Version: 0.0.9
+Summary: 一个强大的逆向工程工具, 能够从任何使用Google Protobuf Lite的Android应用中自动重构出完整的.proto文件结构.
+License: Proprietary
+Keywords: protobuf,reverse-engineering,android,jadx,proto
+Author: iyue
+Author-email: ys1231@126.com
+Requires-Python: >=3.12,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Disassemblers
+Requires-Dist: loguru (>=0.7.3)
+Project-URL: Homepage, https://github.com/ys1231/reproto
+Project-URL: Repository, https://github.com/ys1231/reproto.git
+Description-Content-Type: text/markdown
+
+# Protobuf Reconstructor
+
+🔧 **从JADX反编译的Java源码自动重构Protobuf .proto文件**
+
+一个强大的逆向工程工具，能够从任何使用Google Protobuf Lite的Android应用中自动重构出完整的.proto文件结构。经过重大性能优化，执行效率提升20%+。
+
+## ✨ 特性
+
+- 🎯 **精准解析**: 基于Google Protobuf Lite字节码的逆向工程
+- 🔄 **递归依赖**: 自动发现和处理所有依赖的消息和枚举类型
+- 📦 **完整支持**: 支持oneof、repeated、map、枚举等所有Protobuf特性
+- 🌐 **通用性**: 适用于任何Android应用，无需硬编码映射
+- 🧠 **智能推断**: 从Java源码直接读取类型信息，确保高准确性
+- 📝 **标准输出**: 严格遵循Google Proto Style Guide
+- 🚀 **高性能**: 文件缓存系统 + 智能路径构造，执行速度提升20%+
+- 🛠️ **特殊类型支持**: MapFieldLite、Internal.ProtobufList、Google Well-Known Types
+
+## 🛠️ 安装
+
+```bash
+# 克隆项目
+git clone https://github.com/ys1231/reproto.git
+cd reproto
+
+# 安装依赖
+pip install -r requirements.txt
+```
+
+## 📖 使用方法
+
+### 基本用法
+```bash
+python main.py <java_sources_dir> <root_class> <output_dir> [--verbose]
+```
+
+### 参数说明
+- `java_sources_dir`: JADX反编译的Java源码目录路径
+- `root_class`: 要重构的根类完整类名（如：com.example.Model）
+- `output_dir`: 生成的proto文件输出目录路径
+- `--verbose`: 显示详细处理信息
+
+### 示例
+```bash
+# 重构消息应用的数据模型
+python main.py ./out_jadx/sources com.example.messaging.v1.models.MessageData ./protos_generated --verbose
+
+# 重构内部类
+python main.py ./out_jadx/sources 'com.truecaller.accountonboarding.v1.Models$Onboarded' ./output --verbose
+
+# 重构包含特殊类型的类
+python main.py ./out_jadx/sources com.truecaller.search.v1.models.SearchResult ./output --verbose
+```
+
+## 🔍 工作原理
+
+### 核心技术
+1. **字节码解析**: 逆向工程Google Protobuf Lite的`newMessageInfo`调用
+2. **依赖发现**: 递归分析Java文件中的类型引用
+3. **智能推断**: 基于字段名和对象数组推断枚举和消息类型
+4. **源码分析**: 直接从Java源码读取真实的字段类型声明
+5. **🆕 性能优化**: 文件缓存系统 + 直接路径构造，避免全目录扫描
+
+### 解析流程
+```
+Java源码 → 字节码提取 → 类型解码 → 依赖发现 → 源码验证 → Proto生成
+    ↓
+🚀 性能优化: 文件缓存 + 智能路径构造 + 统一类型检测
+```
+
+## 📁 项目结构
+
+```
+reproto/
+├── main.py                     # 主程序入口
+├── core/                       # 核心组件
+│   ├── reconstructor.py        # 主协调器 (已优化)
+│   ├── info_decoder.py         # 字节码解码器
+│   └── bytecode_parser.py      # 字节码解析工具
+├── parsing/                    # 解析模块
+│   ├── java_parser.py          # Java文件解析器
+│   ├── enum_parser.py          # 枚举解析器 (🆕)
+│   └── java_source_analyzer.py # Java源码分析器 (已优化)
+├── generation/                 # 生成模块
+│   └── proto_generator.py      # Proto文件生成器
+├── models/                     # 数据模型
+│   └── message_definition.py   # 消息和枚举定义
+├── utils/                      # 工具函数 (大幅扩展)
+│   ├── logger.py              # 日志系统
+│   ├── file_utils.py          # 文件工具
+│   ├── file_cache.py          # 文件缓存系统 (🆕)
+│   └── type_utils.py          # 类型处理工具 (🆕)
+└── logs/                      # 日志文件目录
+```
+
+## 📊 输出示例
+
+### 输入：Java源码
+```java
+public final class BulkSearchResult extends GeneratedMessageLite {
+    private MapFieldLite<String, Contact> contacts_;
+    private Internal.ProtobufList<String> phoneNumbers_;
+    
+    public static final int CONTACTS_FIELD_NUMBER = 1;
+    public static final int PHONE_NUMBERS_FIELD_NUMBER = 2;
+}
+```
+
+### 输出：Proto文件
+```protobuf
+syntax = "proto3";
+
+package com.truecaller.search.v1.models;
+
+option java_package = "com.truecaller.search.v1.models";
+option java_multiple_files = true;
+
+message BulkSearchResult {
+  map<string, Contact> contacts = 1;
+  repeated string phone_numbers = 2;
+}
+```
+
+## 🚀 性能优化亮点
+
+### 🆕 重大性能提升
+- **总执行时间**: 从~81秒优化到~65秒，提升 **19.8%**
+- **基础类型检测**: 从2-3秒延迟优化为 **瞬间响应**，提升 **99%+**
+- **索引系统**: 移除未使用的索引系统，节省 **100%** 构建开销
+- **文件I/O**: 智能缓存系统，避免重复读取
+
+### 🔧 技术优化
+1. **文件缓存系统**: 线程安全的文件内容缓存，避免重复I/O
+2. **直接路径构造**: 根据包名直接构造文件路径，避免全目录扫描
+3. **统一类型检测**: 使用`TypeMapper`统一处理所有类型转换
+4. **智能包名推断**: 基于包结构的智能类名解析
+
+### 📈 性能监控
+```bash
+📊 文件缓存统计:
+   总请求数: 33
+   缓存命中: 0      # 表明程序高效，无重复读取
+   缓存未命中: 33   # 每个文件只读取一次
+   已缓存文件: 33   # 所有文件已缓存备用
+```
+
+## 🛠️ 特殊类型支持
+
+### MapFieldLite 支持
+```java
+// Java源码
+private MapFieldLite<String, Contact> contacts_;
+
+// 生成的Proto
+map<string, Contact> contacts = 1;
+```
+
+### Internal.ProtobufList 支持
+```java
+// Java源码
+private Internal.ProtobufList<String> tags_;
+
+// 生成的Proto
+repeated string tags = 1;
+```
+
+### Google Well-Known Types
+- `google.protobuf.Any`
+- `google.protobuf.Timestamp`
+- `google.protobuf.Duration`
+- `google.protobuf.StringValue`
+- 等等...
+
+## 🚀 工作流程
+
+1. 使用JADX反编译Android应用：`jadx -d out_jadx app.apk`
+2. 运行ReProto指定根Protobuf类
+3. 自动解析所有相关类和依赖
+4. 🆕 智能缓存和路径优化，快速处理
+5. 生成完整的.proto文件结构
+
+## 📝 配置选项
+
+### 日志配置
+- 日志文件自动保存到 `./logs/` 目录
+- 文件格式: `reproto-YYYY-MM-DD-HH-MM-SS.log`
+- 使用 `--verbose` 参数查看详细处理过程
+- 🆕 性能统计和缓存监控信息
+
+### 输出格式
+生成的proto文件遵循Google Protobuf Style Guide：
+- 文件名：`snake_case.proto`
+- 字段名：`snake_case`
+- 消息名：`PascalCase`
+- 枚举值：`UPPER_SNAKE_CASE`
+
+## 🔧 开发
+
+```bash
+# 使用Poetry管理依赖
+poetry install
+poetry shell
+
+# 运行测试
+python main.py ../out_jadx/sources 'com.example.TestClass' ../test_output --verbose
+
+# 性能测试
+time python main.py ../out_jadx/sources com.truecaller.search.v1.models.SearchResult ../test_output
+```
+
+## 🐛 故障排除
+
+### 常见问题
+
+1. **文件找不到错误**
+   ```bash
+   # 确保JADX输出目录正确
+   ls -la out_jadx/sources/com/example/
+   ```
+
+2. **内存不足**
+   ```bash
+   # 对于大型应用，增加Java堆内存
+   export JAVA_OPTS="-Xmx4g"
+   ```
+
+3. **性能问题**
+   ```bash
+   # 查看缓存统计，确认没有重复I/O
+   grep "缓存统计" logs/reproto-*.log
+   ```
+
+## 📊 支持的Protobuf特性
+
+| 特性 | 支持状态 | 示例 |
+|------|----------|------|
+| 基础类型 | ✅ 完整支持 | `string`, `int32`, `bool` |
+| 消息类型 | ✅ 完整支持 | `Contact`, `UserInfo` |
+| 枚举类型 | ✅ 完整支持 | `enum Status { ACTIVE = 0; }` |
+| repeated | ✅ 完整支持 | `repeated string tags` |
+| map | ✅ 完整支持 | `map<string, Contact> contacts` |
+| oneof | ✅ 完整支持 | `oneof data { ... }` |
+| 嵌套消息 | ✅ 完整支持 | `message Outer.Inner` |
+| Well-Known Types | ✅ 新增支持 | `google.protobuf.Timestamp` |
+
+## 🎯 最新更新 (v2.0)
+
+### 🚀 性能优化
+- 移除未使用的索引系统，提升执行效率20%+
+- 文件缓存系统，避免重复I/O操作
+- 智能路径构造，避免全目录扫描
+- 统一类型检测器，简化代码逻辑
+
+### 🆕 新增功能
+- MapFieldLite自动转换为标准map语法
+- Internal.ProtobufList支持
+- Google Protobuf Well-Known Types支持
+- 增强的枚举解析器
+- 详细的性能监控和统计
+
+### 🔧 技术改进
+- 代码复杂度显著降低
+- 内存使用优化
+- 错误处理增强
+- 日志系统改进
+
+## 📄 许可证
+
+本项目为私有项目，仅供授权用户使用。
+
+---
+
+**�� 现在就体验20%+的性能提升！**
+