makne 1.0__tar.gz

makne-1.0/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

makne-1.0/.github/workflows/publish.yml

@@ -0,0 +1,110 @@
+name: Publish to PyPI and GitHub Releases
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  contents: write # Required for creating release and uploading assets
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        if: runner.os == 'Linux'
+        uses: docker/setup-qemu-action@v3
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.21.0
+        env:
+          CIBW_BUILD_FRONTEND: "build"
+          # Skip 32-bit builds on Linux/macOS, build only 64-bit to align with Zydis/PE architecture support
+          CIBW_SKIP: "*-manylinux_i686 *-musllinux_i686 cp36-* cp37-* pp*"
+          CIBW_ENVIRONMENT: "BUILD_PYTHON_PACKAGE=ON"
+
+      - name: Upload wheels as artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install build
+        run: python -m pip install build
+
+      - name: Build sdist
+        run: python -m build --sdist
+
+      - name: Upload sdist as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  publish_pypi:
+    name: Publish to PyPI
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/makne
+    permissions:
+      id-token: write # Required for trusted publishing OIDC
+    steps:
+      - name: Download all build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish to PyPI
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  github_release:
+    name: Create GitHub Release
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Download all build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - name: Create Release and Upload Assets
+        uses: softprops/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/v')
+        with:
+          files: dist/*
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

makne-1.0/.gitignore

@@ -0,0 +1,12 @@
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+CMakeUserPresets.json

makne-1.0/CMakeLists.txt

@@ -0,0 +1,78 @@
+cmake_minimum_required(VERSION 3.15)
+project(makne LANGUAGES CXX)
+
+# Set C++ Standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Add Include Directories
+include_directories(include)
+
+# Source Files
+set(SOURCES
+    src/main.cpp
+    src/CodeReorderer.cpp
+    src/ControlFlowObfuscator.cpp
+    src/DataEncoder.cpp
+    src/DecryptorGenerator.cpp
+    src/ImportObfuscator.cpp
+    src/InstructionSubstitutor.cpp
+    src/JunkCodeInserter.cpp
+    src/MetamorphicEngine.cpp
+    src/PayloadEncryptor.cpp
+    src/PolymorphicEngine.cpp
+    src/RegisterRandomizer.cpp
+    src/SectionRandomizer.cpp
+    src/Utils.cpp
+)
+
+# Headers (for IDE visibility)
+set(HEADERS
+    include/PEStructs.h
+    include/CodeReorderer.h
+    include/ControlFlowObfuscator.h
+    include/DataEncoder.h
+    include/DecryptorGenerator.h
+    include/ImportObfuscator.h
+    include/InstructionSubstitutor.h
+    include/JunkCodeInserter.h
+    include/MetamorphicEngine.h
+    include/PayloadEncryptor.h
+    include/PolymorphicEngine.h
+    include/RegisterRandomizer.h
+    include/SectionRandomizer.h
+    include/Utils.h
+)
+
+# Executable Target
+add_executable(makne ${SOURCES} ${HEADERS})
+
+# Fetch Zycore
+include(FetchContent)
+FetchContent_Declare(
+    zycore
+    URL https://github.com/zyantific/zycore-c/archive/refs/tags/v1.5.0.zip
+)
+FetchContent_MakeAvailable(zycore)
+
+# Fetch Zydis
+set(ZYAN_ZYCORE_PATH "${zycore_SOURCE_DIR}" CACHE PATH "The path to look for Zycore" FORCE)
+FetchContent_Declare(
+    zydis
+    URL https://github.com/zyantific/zydis/archive/refs/tags/v4.0.0.zip
+)
+FetchContent_MakeAvailable(zydis)
+
+# Link Zydis
+target_link_libraries(makne PRIVATE Zydis)
+
+# Compiler-specific settings
+if(MSVC)
+    target_compile_options(makne PRIVATE /W4 /WX- /Od /EHsc)
+else()
+    target_compile_options(makne PRIVATE -Wall -Wextra -O2)
+endif()
+
+# Install target for packaging
+install(TARGETS makne DESTINATION .)

makne-1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GumokuCat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

makne-1.0/PKG-INFO

@@ -0,0 +1,379 @@
+Metadata-Version: 2.2
+Name: makne
+Version: 1.0
+Summary: Advanced binary-level mutation and obfuscation framework for PE binaries
+Author: Developer
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Security
+Project-URL: Homepage, https://github.com/anonymouschichvy/makne
+Project-URL: Repository, https://github.com/anonymouschichvy/makne
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="docs/logo.png" alt="MAKNE" width="100%">
+</p>
+
+An advanced binary-level mutation and obfuscation framework for **PE (Portable Executable) both 32-bit (x86) and 64-bit (x64)** binaries written in C++17. Leveraging the high-performance **Zydis disassembler** backend, the engine dynamically parses PE files, identifies instruction/basic block boundaries, applies polymorphic and metamorphic transformation passes, and rebuilds the executable with modified section structures and updated PE metadata.
+
+---
+
+## 📂 Project Directory Structure
+
+The project follows a clean, modular C++ directory layout separating definitions (headers) from source code and configurations:
+
+```text
+makne/
+├── CMakeLists.txt              # Cross-platform build configuration
+├── README.md                   # Project documentation
+├── include/                    # Header files
+│   ├── PEStructs.h             # Native PE structures definitions (DOS, COFF, Optional headers)
+│   ├── CodeReorderer.h         # Basic block analysis and shuffling definitions
+│   ├── ControlFlowObfuscator.h # Control flow flattening & opaque predicate definitions
+│   ├── DataEncoder.h           # Data/String encoding & decoder stub generation
+│   ├── DecryptorGenerator.h    # Polymorphic decryptor stub creation
+│   ├── ImportObfuscator.h      # IAT obfuscation and API hashing definitions
+│   ├── InstructionSubstitutor.h# Instruction-equivalent database mapping
+│   ├── JunkCodeInserter.h      # Dead code/junk sequence generator
+│   ├── MetamorphicEngine.h     # High-level metamorphic mutation pipeline
+│   ├── PayloadEncryptor.h      # Section-level encryption management
+│   ├── PolymorphicEngine.h     # Core processing, PE parsing, and orchestrator
+│   ├── RegisterRandomizer.h    # ModR/M register mapping and randomization
+│   ├── SectionRandomizer.h     # PE section name, layout, and alignment shuffler
+│   └── Utils.h                 # Randomness and helper definitions
+└── src/                        # Implementation files
+    ├── main.cpp                # Command-line driver and argument parser
+    ├── CodeReorderer.cpp       # Basic block identification, jump fixing, and shuffling
+    ├── ControlFlowObfuscator.cpp # Flow flatters, dispatchers, and opaque predicates
+    ├── DataEncoder.cpp         # XOR, Base64, and split-string algorithms
+    ├── DecryptorGenerator.cpp  # Dynamic x86 assembly generator for decryption
+    ├── ImportObfuscator.cpp    # IAT parsing, dynamic DLL resolution, and API hashing
+    ├── InstructionSubstitutor.cpp # x86 equivalent instruction mapping execution
+    ├── JunkCodeInserter.cpp    # NOP-equivalent & flag-safe instruction generation
+    ├── MetamorphicEngine.cpp   # Loop unrolling, inlining, and expansion levels
+    ├── PayloadEncryptor.cpp    # XOR encryption and decryption insertion logic
+    ├── PolymorphicEngine.cpp   # Core engine implementation (PE parsing, rebuilding)
+    ├── RegisterRandomizer.cpp  # Register swapping and translation tables
+    ├── SectionRandomizer.cpp   # Section shuffling, renaming, and alignment fixing
+    └── Utils.cpp               # Cryptographic RNG (CryptoRandom)
+```
+
+---
+
+## 🛠 Features & Capabilities
+
+The engine features two distinct modes of transformation which can be combined (Mixed Mode):
+
+### 1. Polymorphic Transformations
+*   **Zydis Disassembler Backend**: Replaced custom prefix/opcode length parsers with a full-featured Zydis decoder to safely identify x86/x64 instruction boundaries, decode operand layouts, and perform atomic byte stream modifications.
+*   **Instruction Substitution**: Replaces instruction patterns with equivalent CPU sequences. For example:
+    *   `MOV reg, Imm` $\rightarrow$ `PUSH Imm; POP reg`
+    *   `XOR reg, reg` $\rightarrow$ `SUB reg, reg`
+    *   `NOP` $\rightarrow$ `PUSH RBX; POP RBX` or `XCHG RAX, RAX`
+    *   *x64 Safety Filter*: Automatically bypasses single-byte legacy `INC` (`0x40`) / `DEC` (`0x48`) substitutions on x64 targets to prevent collisions with the REX prefix byte range (`0x40-0x4F`).
+*   **Register Randomizer**: Dynamically re-maps general-purpose register usage while adhering to strict architecture constraints:
+    *   *Calling Convention Safe*: Preserves caller/callee boundary registers `RAX/EAX` (return values), `RCX/ECX, RDX/EDX, R8, R9` (arguments), `RSP/ESP, RBP/EBP` (stack frames), and `R12, R13` (special SIB addresses).
+    *   *Partitioned Shuffle*: Safely shuffles registers only within legacy (`RBX, RSI, RDI`) and extension (`R10, R11, R14, R15`) groups, guaranteeing that instruction lengths and REX prefix status remain completely invariant.
+*   **Exception Directory Relocation**: Automatically parses x64 `.pdata` runtime function tables and `UNWIND_INFO` structures to relocate 32-bit exception handler RVAs when shuffling or renaming PE sections.
+*   **Code Reordering (x86/x64)**: Partitions code into basic blocks, shuffles their location, and maintains original execution flow by stitching blocks together with JMP instructions. Zydis is used to parse branch offsets and relative memory displacements to patch targets.
+*   **Junk Code Inserter (x86/x64)**: Inserts context-aware, benign junk instructions (e.g., flag-safe operations) to modify byte signatures without changing execution behavior. Filters out x86-only instructions on x64.
+*   **Control Flow Obfuscation (x86/x64)**: Distorts control flow by replacing jumps with equivalent joint condition pairs (e.g., `JO` + `JNO`) and Jcc conditions with inverted Jcc skips.
+*   **Payload Encryption**: Encrypts target payload sections (XOR, etc.) and injects dynamically generated decryptor stubs as the entry point. On x64 targets, stubs query the Process Environment Block (PEB) using `GS:[0x60]` (instead of `FS:[0x30]` on x86) for anti-debug analysis.
+*   **Data Encoding**: Encodes static data strings using XOR, Base64, or string-splitting to avoid detection of plaintext strings.
+
+### 2. Metamorphic Transformations
+*   **Zydis Intermediate Representation**: Disassembles and decodes target functions to an IR, rewriting displacements and `%rip`-relative displacements to patch jump offsets and relocations on mutations.
+*   **Instruction Permutation (x86/x64)**: Alters instruction positions using Bernstein's data dependency conditions (RAW, WAR, WAW) while preserving stack frame layout registers (`RSP`, `ESP`, `RBP`, `EBP`).
+*   **Code Expansion**: Expands instructions to multi-byte equivalents to vary executable sizing.
+*   **Loop Unrolling & Function Inlining**: Modifies the stack frame structure and execution sequence by eliminating calls and branches.
+*   **Anti-Debugging / Anti-Emulation**: Integrates stubs to detect hypervisors, sandboxes, and debuggers (e.g., PEB checks, timing checks).
+*   **FileAlignment Section Resizing**: Safely pads, resizes, and aligns raw PE section size growth to `FileAlignment` boundaries, automatically relocating the COFF symbol table to prevent symbol warnings or image loaders crash.
+
+---
+
+## ⚙️ Compilation & Installation
+
+This project can be compiled as a standalone C++ command-line tool, or installed as a Python package with programmatic C++ wrapper bindings.
+
+### 🐍 Python Package Installation (via pip)
+
+You can build and install the project directly as a Python package. The PEP 517 build backend (`scikit-build-core`) will automatically configure and build the C++ codebase via CMake when installing.
+
+#### 1. Prerequisites
+Ensure you have a C++17 compiler (MSVC on Windows, GCC on Linux, Clang on macOS) and CMake installed.
+
+#### 2. Install from PyPI (Production)
+
+> **Coming Soon**
+> `makne` is not yet available on PyPI. It will be published after the initial production release.
+
+#### 3. Install from Source (Local Development)
+Clone the repository and run:
+```bash
+# Editable install (recommended for developers)
+pip install -e .
+
+# Or standard local install
+pip install .
+```
+
+#### 4. Verification & Usage
+* **CLI usage**: Installing the package registers a global command-line entry point:
+  ```bash
+  makne --help
+  ```
+* **Python API usage**: You can run the obfuscator directly from Python scripts:
+  ```python
+  import makne
+
+  # Obfuscate a PE binary
+  return_code = makne.obfuscate("input.exe", "output.exe", ["--polymorphic", "--substitution"])
+  if return_code == 0:
+      print("Obfuscation successful!")
+  ```
+
+---
+
+### 🖥️ Native C++ Standalone Compilation
+
+If you prefer building a standalone native executable without Python, the build system utilizes **CMake** for configuration and building. The build system automatically fetches dependencies like **Zydis disassembler** and **Zycore** via CMake's `FetchContent` module during configuration, so no manual downloading of submodules is necessary.
+
+### 🪟 Windows (MSVC)
+
+#### 1. Prerequisites
+* **Visual Studio 2019 or 2022** (Community, Professional, or Enterprise).
+* During installation, ensure the **"Desktop development with C++"** workload is checked. This installs the MSVC compiler, CMake, and the required Windows SDKs.
+* Alternatively, you can use standalone **CMake (3.15+)** and **Build Tools for Visual Studio**.
+
+#### 2. Building from Command Line
+Open **Developer PowerShell for VS** or **Developer Command Prompt for VS** and run:
+```powershell
+# Generate the build configuration
+cmake -B build -S .
+
+# Build the release binary
+cmake --build build --config Release
+```
+The compiled executable `makne.exe` will be located in `build/Release/`.
+
+#### 3. Building via Visual Studio (IDE)
+1. Open Visual Studio.
+2. Select **Open a local folder** and choose the root directory containing `CMakeLists.txt`.
+3. Visual Studio will automatically detect and configure the CMake project.
+4. Go to the menu: **Build > Build All** (or select the `makne.exe` startup item and press F5/Ctrl+F5 to build and run).
+
+---
+
+### 🐧 Linux (GCC/Clang)
+
+#### 1. Prerequisites
+Install CMake and a C++17 compatible compiler (GCC 8+ or Clang 7+):
+* **Ubuntu / Debian**:
+  ```bash
+  sudo apt update
+  sudo apt install -y build-essential cmake
+  ```
+* **Fedora / CentOS / RHEL**:
+  ```bash
+  sudo dnf groupinstall -y "Development Tools"
+  sudo dnf install -y cmake
+  ```
+* **Arch Linux**:
+  ```bash
+  sudo pacman -Syu base-devel cmake
+  ```
+
+#### 2. Building
+Open a terminal in the project root folder:
+```bash
+# Generate build configuration for a Release build
+cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
+
+# Build the project
+cmake --build build
+```
+The compiled executable `makne` will be located in `build/`.
+
+---
+
+### 🍎 macOS (Clang)
+
+#### 1. Prerequisites
+* **Xcode Command Line Tools**: Install them by running the following command in terminal:
+  ```bash
+  xcode-select --install
+  ```
+* **CMake**: Install CMake using a package manager:
+  * **Homebrew** (Recommended):
+    ```bash
+    brew install cmake
+    ```
+  * **MacPorts**:
+    ```bash
+    sudo port install cmake
+    ```
+
+#### 2. Building
+Open a terminal in the project root folder:
+```bash
+# Generate build configuration for a Release build
+cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
+
+# Build the project
+cmake --build build
+```
+The compiled executable `makne` will be located in `build/`.
+
+---
+
+## 🧠 System Architecture & Logic
+
+```mermaid
+graph TD
+    A[Input PE Binary] --> B[PE Parser]
+    B --> C[Disassembler & Block Finder]
+    C --> D{Transformation Mode}
+    
+    D -->|Polymorphic| E[Polymorphic Pipeline]
+    D -->|Metamorphic| F[Metamorphic Pipeline]
+    D -->|Mixed| G[Polymorphic & Metamorphic Pipeline]
+    
+    E --> H[Payload Encryption & Stub Generation]
+    F --> I[Block Permutation & Expansion]
+    G --> J[Combined Transformations]
+    
+    H --> K[PE Rebuilder & Checksum Generator]
+    I --> K
+    J --> K
+    
+    K --> L[Output Obfuscated PE Binary]
+```
+
+### Flow Walkthrough
+
+1.  **Parsing (PE Parser)**:
+    Loads the raw byte stream of the target `.exe` file. Parses the DOS MZ signature, COFF Header, Optional Header, and Sections to build an in-memory structural mapping of code (`.text`) and data (`.data`, `.rdata`) segments.
+2.  **Code Analysis & Disassembly**:
+    Parses machine code instructions, determines byte length boundary offsets, identifies branches (jumps, calls), and isolates independent execution blocks (Basic Blocks).
+3.  **Applying Mutations**:
+    Runs the pipeline of selected obfuscation passes. The engine tracks offset modifications since instruction substitution, junk insertion, and block shuffling alter virtual addresses (RVAs).
+4.  **Header Reconstruction & Rebuilding**:
+    Adjusts relocations, recalculates Entry Point (OEP), shifts Section Headers offsets, fixes the Import Address Table (IAT) pointers, generates dynamic import-resolving stubs, computes a new PE checksum, and saves the new output binary.
+
+---
+
+## 🚀 CLI Usage & Examples
+
+### Usage syntax:
+* **Windows (PowerShell/CMD)**:
+  ```powershell
+  .\makne.exe <input.exe> <output.exe> [options]
+  ```
+* **Linux / macOS**:
+  ```bash
+  ./makne <input.exe> <output.exe> [options]
+  ```
+
+### CLI Command Options
+
+| Option | Category | Description |
+| :--- | :--- | :--- |
+| `--polymorphic` | Transformation | Apply polymorphic transformations (Default) |
+| `--metamorphic` | Transformation | Apply metamorphic transformations |
+| `--mixed` | Transformation | Combine both polymorphic & metamorphic pipelines |
+| `--substitution` | Polymorphic | Enable instruction substitutions |
+| `--registers` | Polymorphic | Enable register randomization |
+| `--reorder` | Polymorphic | Enable basic block code reordering |
+| `--junk` | Polymorphic | Enable junk/dead code insertion |
+| `--cflow` | Polymorphic | Enable control flow obfuscation (flattening/predicates) |
+| `--encrypt` | Polymorphic | Enable payload section encryption |
+| `--data` | Polymorphic | Enable static data/string encoding |
+| `--sections` | Polymorphic | Randomize section names and layout |
+| `--imports` | Polymorphic | Obfuscate IAT and import names |
+| `--permute <1-5>` | Metamorphic | Set instruction permutation complexity level |
+| `--expand <1-5>` | Metamorphic | Set code expansion multiplier |
+| `--garbage <1-5>` | Metamorphic | Set junk insertion density |
+| `--unroll` | Metamorphic | Enable loop unrolling |
+| `--inline` | Metamorphic | Enable function inlining |
+| `--antidebug` | Advanced | Add anti-debugger stub detections |
+| `--antiemu` | Advanced | Add anti-emulation timing checks |
+| `--level <1-5>` | Advanced | Set global obfuscation intensity (default: 3) |
+| `--iterations <n>`| Advanced | Number of mutation passes to run |
+| `--help` | General | Display help documentation |
+
+### Command Examples
+
+Below are examples of how to run the engine. Make sure to run them from the directory containing the compiled executable (`build/` or `build/Release/`), or provide the full path to it.
+
+#### 1. Display Help & Options
+Verify the installation and see the full list of supported parameters.
+* **Windows (PowerShell)**:
+  ```powershell
+  .\makne.exe --help
+  ```
+* **Linux / macOS**:
+  ```bash
+  ./makne --help
+  ```
+
+#### 2. Standard Polymorphic Obfuscation
+Applies instruction substitutions, register randomization, code reordering, and section name/layout randomization.
+* **Windows (PowerShell)**:
+  ```powershell
+  .\makne.exe input.exe output.exe --polymorphic --substitution --registers --reorder --sections
+  ```
+* **Linux / macOS**:
+  ```bash
+  ./makne input.exe output.exe --polymorphic --substitution --registers --reorder --sections
+  ```
+* **Explanation of flags**:
+  * `--polymorphic`: Activates the polymorphic transformation pipeline.
+  * `--substitution`: Replaces common instruction patterns with equivalent sequences.
+  * `--registers`: Randomizes general-purpose register usage safely.
+  * `--reorder`: Partitions code into basic blocks and shuffles them, adding stitching jumps.
+  * `--sections`: Randomizes PE section names and structural layout.
+
+#### 3. Advanced Metamorphic Obfuscation
+Applies aggressive code expansion, high complexity instruction permutations, loop unrolling, and function inlining.
+* **Windows (PowerShell)**:
+  ```powershell
+  .\makne.exe input.exe output.exe --metamorphic --permute 5 --expand 4 --unroll --inline
+  ```
+* **Linux / macOS**:
+  ```bash
+  ./makne input.exe output.exe --metamorphic --permute 5 --expand 4 --unroll --inline
+  ```
+* **Explanation of flags**:
+  * `--metamorphic`: Activates the metamorphic transformation pipeline.
+  * `--permute 5`: Sets the highest complexity (level 5) for instruction permutation.
+  * `--expand 4`: Sets the code expansion multiplier to 4.
+  * `--unroll`: Enables optimization loop unrolling.
+  * `--inline`: Inlines function calls where safe.
+
+#### 4. Mixed Maximum Protection (Combined Pipeline)
+Combines all metamorphic and polymorphic features, flattens control flow, obfuscates import tables, encodes static strings, adds anti-analysis/debugger/emulation checks, and runs multiple passes.
+* **Windows (PowerShell)**:
+  ```powershell
+  .\makne.exe input.exe output.exe --mixed --cflow --encrypt --imports --data --antidebug --antiemu --level 5 --iterations 2
+  ```
+* **Linux / macOS**:
+  ```bash
+  ./makne input.exe output.exe --mixed --cflow --encrypt --imports --data --antidebug --antiemu --level 5 --iterations 2
+  ```
+* **Explanation of flags**:
+  * `--mixed`: Runs both the polymorphic and metamorphic pipelines sequentially.
+  * `--cflow`: Distorts control flow via dispatchers and opaque predicates.
+  * `--encrypt`: Encrypts target sections and inserts a decryption stub at the entry point.
+  * `--imports`: Obfuscates the Import Address Table (IAT) and dynamically resolves DLLs.
+  * `--data`: Encodes static strings (XOR/Base64/splitting).
+  * `--antidebug` & `--antiemu`: Injects checks to detect debuggers, hypervisors, and sandboxes.
+  * `--level 5`: Sets global intensity to maximum (5).
+  * `--iterations 2`: Runs the entire mutation pipeline twice to generate nested layers of obfuscation.
+
+---
+
+## ⚖️ License & Disclaimer
+
+This software is developed strictly for **educational, security research, and defensive binary analysis** purposes. Using this software to obfuscate malware to bypass anti-virus scanners for unauthorized deployment is strictly prohibited and a violation of local and international laws. The developers assume no liability for misuse of this tool.