charles2gan/GDA-android-reversing-Tool

Features

• Android Binary Decompilers - Converts Android binary files into human-readable source code using a native implementation that bypasses the Java Virtual Machine.
• Binary Decompilation - Translates Dalvik bytecode and native binaries into human-readable source code without requiring a Java Virtual Machine.
• Android Dynamic Analysis Tools - Inspects and manipulates running Android processes by hooking methods and dumping device memory.
• Android Reverse Engineering - Analyzes, unpacks, and modifies Android application packages to recover original source logic.
• Bytecode Decompilers - Translates Dalvik bytecode into readable source code using a structured algorithm to recover program logic.
• Java Method Hooking - Intercepts and modifies Java interface calls in running Android applications to monitor execution.
• Data Flow Analysis - Traces arguments and return values through intermediate representations to determine how data moves through a program.
• Runtime Script Injections - Executes arbitrary JavaScript code via templates to perform advanced runtime manipulations of Android applications.
• Frida-Based Instrumentation - Provides dynamic instrumentation via Frida to inspect and dump process memory in running Android applications.
• Android Application Reverse Engineering - Provides a comprehensive platform for analyzing Dalvik bytecode, patching binaries, and mapping execution paths.
• Android Component Exposure Analysis - Inspects activities, services, and receivers to determine if they are improperly exposed to other applications.
• App Deobfuscation Utilities - Identifies packing technologies and recovers original code from obfuscated Android binaries.
• Deobfuscation Tools - Removes obfuscation and junk instructions to improve the readability of decompiled Android source code.
• Android - Analyzes malicious Android software to identify vulnerabilities, privacy leaks, and attack vectors.
• Privacy Leak Detection - Identifies privacy leaks by tracking sensitive data from generation to leak points using a taint propagation engine.
• Security Vulnerability Scanning - Analyzes binaries to detect malicious behaviors, vulnerabilities, and privacy leaks using automated scanning.
• Dynamic Analysis Scripting - Interfaces with runtimes like Frida to execute custom logic and hook methods in live processes.
• Java Bytecode Deobfuscators - Removes junk instructions and resolves obfuscated bytecode sequences to improve decompiled code readability.
• API Call Chain Analysis - Traces callers of specific functions to identify insecure implementation patterns in the function bodies.
• Taint Analysis Engines - Tracks the movement of sensitive data from sources to sinks to identify privacy leaks and vulnerabilities.
• Android Binary XML Decoders - Bypasses anti-decoding techniques to recover the original content of Android binary XML manifest files.
• Packer Detection Tools - Analyzes binary structures and metadata to detect software packers used for obfuscation.
• Regex-Based File Search - Scans extracted files for patterns and navigates to matching offsets using hexadecimal or ASCII views.
• Global Content Searches - Locates classes, strings, or patterns across the project using exact, fuzzy, and regular expression matching.
• APK Patching and Repacking - Modifies instructions and repacks executable files to change application behavior for testing or analysis.
• Application Resource Mapping - Finds resource names or IDs and identifies the specific methods that utilize those resources.
• Bytecode Content Search - Searches for specific binary instruction sequences within methods and navigates to the corresponding code blocks.
• Code Search Tools - Locates classes, methods, and fields using precise or partial matching to find definitions and references.
• Embedded File Extraction - Collects all strings, URLs, and API calls contained within an executable binary file.
• DEX File Recovery - Recovers DEX files from protected or packed Android applications by bypassing protection layers.
• Source Cross-References - Generates hyperlinked cross-references between identifiers and declarations to facilitate global project navigation.
• Binary Cross-Reference Analysis - Indexes all callers and references for strings, classes, and methods to enable global project navigation.
• Android Application Modifiers - Modifies bytecode and repacks APK files to alter application behavior for testing and analysis.
• APK Metadata Analyzers - Extracts original timestamps and signing fingerprints from Android package files to determine generation times.
• Runtime State Monitoring - Provides real-time monitoring of the application's internal state and execution logs via live script injection.
• Module Memory Extraction - Extracts active modules from a running process's memory to recover the original binary code.
• Hardware Memory Dumping - Connects to hardware devices to capture full memory dumps for live forensic analysis.
• Analysis Automation Scripts - Supports custom Python and Java scripts to automate forensic analysis and extend analytical capabilities.
• Dynamic Bytecode Execution - Runs class files within the environment to observe behavior and extract dynamic values.
• Class Method Interception - Intercepts every method within a target class to monitor and analyze all object-related activity.
• Dynamic Method Invokers - Executes arbitrary class and instance methods on live objects by instantiating classes via scripts.
• Binary String Searching - Implements scanning across all package files to identify sensitive strings like API keys and network indicators.
• Custom Analysis Rules - Provides a mechanism to detect security flaws using user-defined expressions that match specific API calls, signatures, or configurations.
• Decryption Utilities - Provides utilities to decrypt data using common encoding algorithms to reveal plain text values from binaries.
• Bytecode Patching - Edits bytecode via assembly and updates checksums and signatures to alter application logic.
• Manifest Security Auditing - Validates application permissions and security settings by matching string patterns against the Android manifest file.
• Control Flow Path Solving - Analyzes program control flow using a low-level representation to determine all possible reachable execution paths.
• Implementation Tracing - Maps interface methods to their corresponding implementation classes to jump directly to the concrete logic.
• Junk Instruction Removal - Clears obfuscated bytecode using pattern matching and null operations to simplify decompiled code.
• Multi-DEX Reconstructions - Processes multiple executable files in a single session to reconstruct the full logic of an application.
• Execution Stack Modeling - Detects security vulnerabilities and malicious behaviors by modeling the state of the execution stack.
• Control Flow Path-Solving - Determines reachable execution paths by analyzing program control flow using low-level intermediate representations.
• Android Static Analysis Tools - High-performance Dalvik bytecode decompiler implemented in C++.
• Mobile Security - Fast decompiler for Android binary and archive files.

Star history