How cyb3rmx/qu1cksc0pe works
Project Type & Purpose
• Qu1cksc0pe is a command-line driven malware analysis tool. It provides multiple analysis features (static analysis, dynamic analysis, resource extraction, hash scanning, file carving, etc.) for a wide range of file types and operating systems. The README outlines that it leverages external tools (like Jadx, Mono) and uses a modular approach for handling different analysis routines.
• The tool also integrates with external services (VirusTotal API) and supports execution via Docker, making it adaptable for both Linux and Windows environments.
File Structure
• Top-level files and directories include:
• "qu1cksc0pe.py" – the main entry point.
• "Modules" directory – contains scripts/functions for specific scanning and analysis tasks (e.g., apkAnalyzer.py, email_analyzer.py, dynamic/static analyzers, languageDetect.py, etc.). This is the core business logic.
• "Systems" directory – organized by platform (Android, Linux, Windows, OSX and a "Multiple" folder) containing configuration files, YARA rules, Frida scripts, and additional signatures. These files serve as analysis databases and scripts that the Modules use.
• Supporting files like Dockerfile, setup scripts, and configuration files (requirements.txt) indicate build & deployment automation.
• The structure implies a modular, plugin-like architecture where the main script invokes various modules and relies on external rule sets and scripts (found under Systems) to perform specialized checks.
Architectural Patterns and Key Technologies
• Modular design: Each module (in the Modules folder) encapsulates a separate analysis functionality.
• Rule-based scanning: The extensive "Systems" folder shows that the project uses YARA rules and other signatures to identify malicious patterns.
• CLI Integration: "qu1cksc0pe.py" functions as the CLI orchestrator, selecting which module to use based on command-line parameters.
• External Dependency Integration: Tools like VirusTotal (through API calls), Jadx, Mono, and possibly frida (for dynamic analysis) are integrated.
• Containerization: Presence of Dockerfile suggests that the application is designed to be deployed in a containerized environment, further modularizing system dependence.
Main Components
a. User Interface / Entry Point:
• The CLI (command-line arguments interpreted by qu1cksc0pe.py) which directs control flow.
• Optionally, the Docker runtime as an alternate deployment environment.
b. Analysis Engine / Modules:
• Modules folder: Represent as a collection of discrete analysis components (for static analysis, dynamic analysis, resource analysis, signature extraction, hash scanning, etc.).
• Each module is responsible for a specific file type or analysis method. For example, separate modules for Windows dynamic analysis, Linux static analysis, Android dynamic analysis, and so on.
c. Signature/Configuration Data:
• Systems folder: Highlight different sub-directories for Android, Linux, Windows, OSX, and Multiple. These contain YARA rules, Frida scripts, packer rules, configuration files, and other references that guide the module logic.
• That these rules and configurations are external data sources used by the Modules to perform detection.
d. External Services & Dependencies:
• VirusTotal API, third-party static analysis tools (Strings, Jadx, etc.), Mono for .NET analysis.
e. Output / Reporting:
• Components for producing analysis reports, visual outputs (screenshots/demo images in the README), and potentially logging analysis details.
Relationships and Interactions
• Data flow from user input (CLI parameters) into the main script.
• The main script invoking specific modules based on input flags.
• Modules pulling configuration/signature data from the Systems folder.
• External API calls and integration with supporting tools.