reproto 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

core/bytecode_parser.py

@@ -1,274 +0,0 @@
-from typing import List, Dict, Tuple
-import re
-from ..models import FieldDefinition, OneofDefinition
-from utils.type_utils import naming_converter
-
-class BytecodeParser:
-    """
-    重新设计的 Protobuf info_string 解析器，基于对 Google Protobuf Lite 格式的深入理解。
-    
-    info_string 格式分析：
-    - 前面是头部信息（版本、字段数量等）
-    - 后面是字段描述符，每个字段用特定格式编码
-    - '<' 字符表示 oneof 字段
-    - 数字表示字段标签
-    """
-
-    def __init__(self, info_bytes: bytes, objects: List[str]):
-        """
-        初始化解析器。
-
-        参数:
-            info_bytes (bytes): 从 info_string 编码而来的字节数组。
-            objects (List[str]): 作为符号表的 objects 数组。
-        """
-        self.info_string = info_bytes.decode('utf-8')
-        self.objects = objects
-        # print(f"  > 原始 info_string: {repr(self.info_string)}")
-        # print(f"  > 对象数组: {self.objects}")
-
-    def parse(self) -> Tuple[List[FieldDefinition], Dict[str, OneofDefinition]]:
-        """
-        解析 info_string 并返回字段定义。
-        
-        基于观察到的模式：
-        - SearchResult: "\\u0000\\u0002\\u0001\\u0000\\u0001\\u0002\\u0002\\u0000\\u0000\\u0000\\u0001<\\u0000\\u0002<\\u0000"
-        - ContactPhone: "\\u0000\\u0003\\u0001\\u0000\\u0001\\u0003\\u0003\\u0000\\u0000\\u0000\\u0001<\\u0000\\u0002<\\u0000\\u0003<\\u0000"
-        """
-        fields: List[FieldDefinition] = []
-        oneofs: Dict[str, OneofDefinition] = {}
-        
-        # 尝试解析字段描述符部分
-        # 寻找 '<' 字符，它们标识 oneof 字段
-        field_descriptors = self._extract_field_descriptors()
-        
-        if not field_descriptors:
-            return fields, oneofs
-            
-        # 确定 oneof 名称（从 objects 数组中）
-        oneof_name = self._determine_oneof_name()
-        
-        if oneof_name:
-            # 这是一个 oneof 结构
-            oneof_def = OneofDefinition(name=oneof_name)
-            
-            for i, desc in enumerate(field_descriptors):
-                if desc.get('is_oneof'):
-                    field_tag = desc['tag']
-                    field_type = self._determine_field_type(i + 2)  # objects[2], objects[3], etc.
-                    field_name = self._generate_field_name(field_type, field_tag)
-                    
-                    field = FieldDefinition(
-                        name=field_name,
-                        type=field_type,
-                        tag=field_tag,
-                        rule="optional"
-                    )
-                    oneof_def.fields.append(field)
-            
-            oneofs[oneof_name] = oneof_def
-        else:
-            # 常规字段结构
-            for i, desc in enumerate(field_descriptors):
-                field_tag = desc['tag']
-                # 对于常规字段，从 objects 数组中获取字段名
-                if field_tag - 1 < len(self.objects):
-                    raw_field_name = self.objects[field_tag - 1]  # tag 从 1 开始，数组从 0 开始
-                    field_name = self._clean_field_name(raw_field_name)
-                else:
-                    field_name = f"field_{field_tag}"
-                
-                # 尝试推断字段类型
-                field_type = self._infer_field_type(desc, field_tag)
-                
-                # 检查是否是 repeated 字段
-                if field_type.startswith("repeated "):
-                    rule = "repeated"
-                    field_type = field_type[9:]  # 移除 "repeated " 前缀
-                else:
-                    rule = "optional"
-                
-                field = FieldDefinition(
-                    name=field_name,
-                    type=field_type,
-                    tag=field_tag,
-                    rule=rule
-                )
-                fields.append(field)
-        
-        return fields, oneofs
-
-    def _extract_field_descriptors(self) -> List[Dict]:
-        """
-        从 info_string 中提取字段描述符。
-        
-        基于观察：
-        - 字段描述符通常在字符串的后半部分
-        - '<' 字符标识 oneof 字段
-        - 数字字符表示字段标签
-        """
-        descriptors = []
-        
-        # 先打印原始字符串的字符分析
-        # print(f"  > 字符串分析:")
-        # for i, char in enumerate(self.info_string):
-        #     if ord(char) > 32:  # 可打印字符
-        #         print(f"    位置 {i}: '{char}' (ord={ord(char)})")
-        #     else:
-        #         print(f"    位置 {i}: \\x{ord(char):02x}")
-        
-        # 寻找 '<' 字符的位置
-        oneof_positions = []
-        for i, char in enumerate(self.info_string):
-            if char == '<':
-                oneof_positions.append(i)
-                
-        # print(f"  > 找到 oneof 标记位置: {oneof_positions}")
-        
-        # 对于每个 '<' 字符，查找前面的数字作为字段标签
-        for pos in oneof_positions:
-            # 查找 '<' 前面的字符
-            if pos > 0:
-                prev_char = self.info_string[pos - 1]
-                prev_byte = ord(prev_char)
-                # print(f"    '<' 前面的字节: \\x{prev_byte:02x} (值={prev_byte})")
-                
-                # 检查是否是有效的字段标签（1-15 是常见范围）
-                if 1 <= prev_byte <= 15:
-                    tag = prev_byte
-                    descriptors.append({
-                        'tag': tag,
-                        'is_oneof': True,
-                        'position': pos
-                    })
-                    # print(f"    发现 oneof 字段: tag={tag}, 位置={pos}")
-        
-        # 如果没有找到 oneof 字段，尝试寻找普通字段
-        if not descriptors:
-            # 寻找可能的字段标签模式
-            # 对于非 oneof 字段，我们需要查找其他模式
-            # print(f"  > 没有找到 oneof 字段，尝试寻找常规字段...")
-            
-            # 查找特殊字符 'Ȉ' (ord=520) 这似乎是字段标记
-            for i, char in enumerate(self.info_string):
-                if ord(char) == 520:  # 'Ȉ' 字符
-                    # 查找前面的字节作为字段标签
-                    if i > 0:
-                        prev_byte = ord(self.info_string[i - 1])
-                        if 1 <= prev_byte <= 50:  # 扩大范围以捕获更多字段
-                            descriptors.append({
-                                'tag': prev_byte,
-                                'is_oneof': False,
-                                'position': i
-                            })
-                            # print(f"    发现常规字段: tag={prev_byte}, 位置={i}")
-            
-            # 如果还是没有找到，尝试其他数字模式
-            if not descriptors:
-                for i, char in enumerate(self.info_string):
-                    byte_val = ord(char)
-                    if 1 <= byte_val <= 20 and byte_val <= len(self.objects):  # 可能的字段标签
-                        # 检查前后上下文以确认这是字段标签
-                        if i < len(self.info_string) - 1:
-                            next_char = self.info_string[i + 1]
-                            # 如果下一个字符是特殊标记，这可能是字段标签
-                            if ord(next_char) in [50, 60, 520, 27]:  # 各种字段类型标记
-                                descriptors.append({
-                                    'tag': byte_val,
-                                    'is_oneof': False,
-                                    'position': i
-                                })
-                                # print(f"    发现可能的字段: tag={byte_val}, 位置={i}")
-        
-        return descriptors
-
-    def _determine_oneof_name(self) -> str:
-        """
-        从 objects 数组确定 oneof 的名称。
-        
-        观察：
-        - objects[0] 通常是 oneof 字段名（如 "result_", "sealedValue_"）
-        - objects[1] 通常是 case 字段名（如 "resultCase_", "sealedValueCase_"）
-        """
-        if len(self.objects) >= 2:
-            field_name = self.objects[0]
-            case_name = self.objects[1]
-            
-            # 检查是否符合 oneof 模式
-            if (field_name.endswith('_') and 
-                case_name.endswith('Case_') and 
-                case_name.startswith(field_name[:-1])):
-                
-                # 从字段名生成 oneof 名称
-                base_name = field_name[:-1]  # 移除末尾的 '_'
-                return self._to_snake_case(base_name)
-        
-        return ""
-
-    def _determine_field_type(self, object_index: int) -> str:
-        """
-        从 objects 数组确定字段类型。
-        """
-        if object_index < len(self.objects):
-            obj = self.objects[object_index]
-            if obj.endswith('.class'):
-                # 移除 '.class' 后缀，提取类名
-                class_name = obj[:-6]
-                # 提取最后一部分作为类型名
-                return class_name.split('.')[-1]
-            else:
-                return obj
-        return "unknown"
-
-    def _generate_field_name(self, field_type: str, field_tag: int) -> str:
-        """
-        根据字段类型和标签生成字段名称。
-        """
-        # 将类型名转换为 snake_case
-        name = self._to_snake_case(field_type)
-        return name
-
-    def _to_snake_case(self, name: str) -> str:
-        """
-        将 CamelCase 转换为 snake_case。
-        """
-        return naming_converter.to_snake_case(name)
-
-    def _clean_field_name(self, name: str) -> str:
-        """
-        清理字段名称，去除不必要的后缀或前缀。
-        """
-        # 去除末尾的下划线
-        if name.endswith('_'):
-            name = name[:-1]
-        # 转换为 snake_case
-        return self._to_snake_case(name)
-
-    def _infer_field_type(self, desc: Dict, field_tag: int) -> str:
-        """
-        根据字段描述符推断字段类型。
-        """
-        # 检查 info_string 中字段标签后面的字节来推断类型
-        position = desc.get('position', -1)
-        if position > 0 and position < len(self.info_string) - 1:
-            # 查看字段标签后面的字节
-            next_byte = ord(self.info_string[position + 1])
-            
-            # 根据字节值推断类型
-            if next_byte == 27:  # 0x1B - repeated message
-                # 查找对应的类类型
-                if field_tag < len(self.objects):
-                    class_obj = self.objects[field_tag]  # objects[1] 对应 tag=1
-                    if class_obj.endswith('.class'):
-                        class_name = class_obj[:-6].split('.')[-1]
-                        return f"repeated {class_name}"
-                return "repeated message"
-            elif next_byte == 520:  # 'Ȉ' - string field
-                return "string"
-            elif next_byte == 12:  # 0x0C - enum
-                return "int32"  # 枚举通常映射为 int32
-            elif next_byte == 50:  # '2' - 可能是某种数字类型
-                return "int32"
-            
-        # 默认返回 string
-        return "string" 

reproto-0.1.2.dist-info/METADATA

@@ -1,295 +0,0 @@
-Metadata-Version: 2.3
-Name: reproto
-Version: 0.1.2
-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%+的性能提升！**
-