447 lines
16 KiB
Python
447 lines
16 KiB
Python
|
|
import subprocess
|
|
import tkinter as tk
|
|
from tkinter import messagebox
|
|
import threading
|
|
|
|
|
|
|
|
|
|
# # Function to run device check before showing the wizard window
|
|
# def device_check():
|
|
# try:
|
|
# subprocess.run(['python3', 'intaller.py'], check=True)
|
|
# return True
|
|
# except subprocess.CalledProcessError as e:
|
|
# print(f"Error running device check script: {e}")
|
|
# return False
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class DeviceCheckWizard:
|
|
def __init__(self, master):
|
|
self.master = master
|
|
self.step = 0 # Tracks the current step in the wizard
|
|
|
|
# Set up the wizard window
|
|
self.master.title("Device Check Wizard")
|
|
self.master.geometry("400x300")
|
|
|
|
self.label = tk.Label(self.master, text="Welcome to the Device Check Wizard")
|
|
self.label.pack(pady=20)
|
|
|
|
|
|
self.back_button = tk.Button(self.master, text="Back", command=self.previous_step, state="disabled")
|
|
self.back_button.pack(side=tk.LEFT, padx=20, pady=10) # Initially disabled
|
|
|
|
self.next_button = tk.Button(self.master, text="Next", command=self.next_step)
|
|
self.next_button.pack(side=tk.RIGHT, padx=20, pady=10)
|
|
|
|
self.result_label = tk.Label(self.master, text="")
|
|
self.result_label.pack(pady=20)
|
|
|
|
self.progress_label = tk.Label(self.master, text="")
|
|
self.progress_label.pack(pady=10)
|
|
|
|
def next_step(self):
|
|
# Hide the "Next" button and update labels for the current step
|
|
self.next_button.config(state="disabled") # Disable the "Next" button after it's clicked
|
|
self.hide_previous_content() # Clear previous content
|
|
self.progress_label.config(text="Running... Please wait.")
|
|
self.progress_label.pack(pady=10)
|
|
|
|
# Enable the Back button after the first step
|
|
if self.step > 0:
|
|
self.back_button.config(state="normal")
|
|
|
|
# Proceed to the respective step (DDoS, Malware, etc.)
|
|
if self.step == 0:
|
|
self.run_async(self.run_ddos)
|
|
elif self.step == 1:
|
|
self.run_async(self.run_malware)
|
|
elif self.step == 2:
|
|
self.run_async(self.run_ransomware)
|
|
else:
|
|
messagebox.showinfo("Info", "All checks completed.")
|
|
self.master.quit()
|
|
|
|
self.step += 1
|
|
|
|
def previous_step(self):
|
|
# Hide the "Back" button if the user goes back to the first step
|
|
self.step -= 1
|
|
|
|
if self.step == 0:
|
|
self.back_button.config(state="disabled")
|
|
|
|
# Handle going to the previous step
|
|
if self.step == 0:
|
|
self.result_label.config(text="Running DDoS check again.")
|
|
self.run_async(self.run_ddos)
|
|
elif self.step == 1:
|
|
self.result_label.config(text="Running Malware check again.")
|
|
self.run_async(self.run_malware)
|
|
elif self.step == 2:
|
|
self.result_label.config(text="Running Ransomware check again.")
|
|
self.run_async(self.run_ransomware)
|
|
|
|
def hide_previous_content(self):
|
|
# Hide the current widgets by removing them from the window
|
|
self.result_label.pack_forget()
|
|
self.progress_label.pack_forget()
|
|
|
|
def run_async(self, func):
|
|
# Run the function in a separate thread
|
|
thread = threading.Thread(target=func)
|
|
thread.start()
|
|
|
|
def run_ddos(self):
|
|
try:
|
|
process = subprocess.Popen(['python3', 'runn.py'])
|
|
self.result_label.config(text="DDoS check running in the background.")
|
|
self.result_label.pack(pady=20)
|
|
self.check_process(process, "DDoS")
|
|
except Exception as e:
|
|
self.result_label.config(text=f"Error running DDoS script: {e}")
|
|
finally:
|
|
self.on_process_complete()
|
|
|
|
def run_malware(self):
|
|
try:
|
|
process = subprocess.Popen(['python3', 'Final_Malware.py'])
|
|
self.result_label.config(text="Malware check running in the background.")
|
|
self.result_label.pack(pady=20)
|
|
self.check_process(process, "Malware")
|
|
except Exception as e:
|
|
self.result_label.config(text=f"Error running malware script: {e}")
|
|
finally:
|
|
self.on_process_complete()
|
|
|
|
def run_ransomware(self):
|
|
try:
|
|
process = subprocess.Popen(['python3', 'Ransomware_Type.py'])
|
|
self.result_label.config(text="Ransomware check running in the background.")
|
|
self.result_label.pack(pady=20)
|
|
self.check_process(process, "Ransomware")
|
|
except Exception as e:
|
|
self.result_label.config(text=f"Error running ransomware script: {e}")
|
|
finally:
|
|
self.on_process_complete()
|
|
|
|
def check_process(self, process, name):
|
|
def poll():
|
|
if process.poll() is None:
|
|
# If the process is still running, check again after 500ms
|
|
self.master.after(500, poll)
|
|
else:
|
|
# Process has completed
|
|
if process.returncode == 0:
|
|
self.result_label.config(text=f"{name} check completed successfully.")
|
|
else:
|
|
self.result_label.config(text=f"{name} check failed.")
|
|
self.on_process_complete()
|
|
|
|
# Start polling the process
|
|
poll()
|
|
|
|
def on_process_complete(self):
|
|
# Re-enable the Next button after the process is done
|
|
self.next_button.config(state="normal")
|
|
self.next_button.pack(pady=10)
|
|
self.progress_label.config(text="Process completed. Click Next to proceed.")
|
|
self.progress_label.pack(pady=10)
|
|
|
|
|
|
|
|
# # # Main logic to run the device check before starting the wizard
|
|
# # if __name__ == "__main__":
|
|
# # if device_check():
|
|
# # # If device check is successful, initialize the Tkinter window
|
|
# # root = tk.Tk()
|
|
# # wizard = DeviceCheckWizard(root)
|
|
# # root.mainloop()
|
|
# # else:
|
|
# # # If the device check fails, show an error message and exit
|
|
# # print("Device check failed. Exiting program.")
|
|
# # messagebox.showerror("Error", "Device check failed. The wizard will not start.")
|
|
|
|
# Initialize the Tkinter window
|
|
root = tk.Tk()
|
|
wizard = DeviceCheckWizard(root)
|
|
|
|
root.mainloop()
|
|
|
|
|
|
# import tkinter as tk
|
|
# from tkinter import ttk, messagebox
|
|
# import subprocess
|
|
# import threading
|
|
# import sys
|
|
|
|
# class DeviceCheckWizard:
|
|
# def __init__(self, master):
|
|
# self.master = master
|
|
# self.step = 0 # Tracks the current step in the wizard
|
|
# self.is_running = False # Flag to check if a process is running
|
|
|
|
# # Set up the wizard window
|
|
# self.master.title("Device Check Wizard")
|
|
# self.master.geometry("600x450") # Adjusted for better visibility
|
|
|
|
# # Step title
|
|
# self.step_label = tk.Label(self.master, text="Step 1: Welcome", font=("Helvetica", 16, "bold"))
|
|
# self.step_label.pack(pady=10)
|
|
|
|
# # Description label for each step
|
|
# self.description_label = tk.Label(self.master, text="This wizard will guide you through device checks.")
|
|
# self.description_label.pack(pady=5)
|
|
|
|
# # Progress bar for visual feedback
|
|
# self.progress_bar = ttk.Progressbar(self.master, orient='horizontal', mode='determinate', length=400)
|
|
# self.progress_bar.pack(pady=10)
|
|
|
|
# # Frame for output
|
|
# self.output_frame = tk.Frame(self.master, padx=10, pady=10)
|
|
# self.output_frame.pack(pady=10)
|
|
|
|
# self.output_text = tk.Text(self.output_frame, height=10, width=60)
|
|
# self.output_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
|
|
|
# self.scrollbar = ttk.Scrollbar(self.output_frame, command=self.output_text.yview)
|
|
# self.scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
|
|
# self.output_text.config(yscrollcommand=self.scrollbar.set, bg="#f0f0f0", borderwidth=1, relief="solid")
|
|
|
|
# # Navigation buttons
|
|
# self.button_frame = tk.Frame(self.master)
|
|
# self.button_frame.pack(pady=20)
|
|
|
|
# self.back_button = ttk.Button(self.button_frame, text="Back", command=self.previous_step, state="disabled")
|
|
# self.back_button.grid(row=0, column=0, padx=20)
|
|
|
|
# self.next_button = ttk.Button(self.button_frame, text="Next", command=self.next_step)
|
|
# self.next_button.grid(row=0, column=1, padx=20)
|
|
|
|
# def update_step(self):
|
|
# """Updates step labels, progress bar, and description."""
|
|
# steps_info = [
|
|
# ("Step 1: Welcome", "Welcome to the Device Check Wizard."),
|
|
# ("Step 2: DDoS Check", "Checking for any Distributed Denial of Service attacks."),
|
|
# ("Step 3: Malware Check", "Running a Malware scan on the device."),
|
|
# ("Step 4: Ransomware Check", "Checking for Ransomware on the device."),
|
|
# ]
|
|
# self.step_label.config(text=steps_info[self.step][0])
|
|
# self.description_label.config(text=steps_info[self.step][1])
|
|
# self.progress_bar['value'] = (self.step + 1) * 25 # Progress increment based on steps (0 to 100)
|
|
|
|
# def next_step(self):
|
|
# # Check if a process is running
|
|
# if self.is_running:
|
|
# messagebox.showinfo("Info", "A process is currently running. Please wait.")
|
|
# return
|
|
|
|
# # Proceed to the respective step (DDoS, Malware, etc.)
|
|
# if self.step == 0:
|
|
# self.output_text.delete(1.0, tk.END)
|
|
# self.output_text.insert(tk.END, "Running DDoS check...\n")
|
|
# self.run_async(self.run_ddos)
|
|
# elif self.step == 1:
|
|
# self.output_text.delete(1.0, tk.END)
|
|
# self.output_text.insert(tk.END, "Running Malware check...\n")
|
|
# self.run_async(self.run_malware)
|
|
# elif self.step == 2:
|
|
# self.output_text.delete(1.0, tk.END)
|
|
# self.output_text.insert(tk.END, "Running Ransomware check...\n")
|
|
# self.run_async(self.run_ransomware)
|
|
# else:
|
|
# messagebox.showinfo("Info", "All checks completed.")
|
|
# self.master.quit()
|
|
|
|
# self.step += 1
|
|
# self.update_step() # Update the UI for the next step
|
|
|
|
# # Enable the back button after the first step
|
|
# if self.step > 0:
|
|
# self.back_button.config(state="normal")
|
|
|
|
# def previous_step(self):
|
|
# if self.is_running:
|
|
# messagebox.showinfo("Info", "A process is currently running. Please wait.")
|
|
# return
|
|
|
|
# self.step -= 1
|
|
|
|
# if self.step < 0:
|
|
# self.step = 0
|
|
# self.back_button.config(state="disabled")
|
|
|
|
# self.update_step() # Update the UI for the previous step
|
|
|
|
# def run_async(self, func):
|
|
# # Set the flag to indicate a process is running
|
|
# self.is_running = True
|
|
# thread = threading.Thread(target=func)
|
|
# thread.start()
|
|
|
|
# def run_ddos(self):
|
|
# self.run_process(['python3', 'runn.py'], "DDoS")
|
|
|
|
# def run_malware(self):
|
|
# self.run_process(['python3', 'Final_Malware.py'], "Malware")
|
|
|
|
# def run_ransomware(self):
|
|
# self.run_process(['python3', 'Ransomware_Type.py'], "Ransomware")
|
|
|
|
# def run_process(self, command, name):
|
|
# self.output_text.insert(tk.END, f"{name} check started...\n")
|
|
# self.output_text.see(tk.END) # Scroll to the end
|
|
|
|
# try:
|
|
# # Using Popen for real-time output
|
|
# process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
|
|
|
|
# # Read the output line by line
|
|
# for line in process.stdout:
|
|
# self.output_text.insert(tk.END, line) # Display stdout
|
|
# self.output_text.see(tk.END) # Auto-scroll to the end
|
|
|
|
# # Wait for the process to complete and get return code
|
|
# return_code = process.wait()
|
|
|
|
# if return_code == 0:
|
|
# self.output_text.insert(tk.END, f"{name} check completed successfully.\n")
|
|
# else:
|
|
# self.output_text.insert(tk.END, f"Error running {name} script. Return code: {return_code}\n")
|
|
# except Exception as e:
|
|
# self.output_text.insert(tk.END, f"Exception running {name} script: {str(e)}\n")
|
|
# finally:
|
|
# self.is_running = False # Reset the flag
|
|
# self.on_process_complete()
|
|
|
|
# def on_process_complete(self):
|
|
# self.description_label.config(text="Process completed. You can proceed to the next step.")
|
|
|
|
# # Initialize the Tkinter window
|
|
# root = tk.Tk()
|
|
# wizard = DeviceCheckWizard(root)
|
|
# root.mainloop()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# import subprocess
|
|
# import tkinter as tk
|
|
# from concurrent.futures import ThreadPoolExecutor
|
|
|
|
# def devicecheck():
|
|
# try:
|
|
# # Call the subprocess to run the installer.py script
|
|
# result = subprocess.run(['python3', 'intaller.py'], check=True, capture_output=True, text=True)
|
|
# print("Device check successful.")
|
|
# print("Installer output:", result.stdout)
|
|
# print("Installer errors (if any):", result.stderr)
|
|
|
|
# # Use ThreadPoolExecutor to call all functions in parallel
|
|
# with ThreadPoolExecutor() as executor:
|
|
# # Start the function calls
|
|
# futures = {
|
|
# 'ddos': executor.submit(ddos),
|
|
# 'malware': executor.submit(malware),
|
|
# 'ransomware': executor.submit(ransomware),
|
|
# 'ransomware_model': executor.submit(ransomware_model),
|
|
# }
|
|
|
|
# # Wait for all functions to complete and print their results
|
|
# for name, future in futures.items():
|
|
# try:
|
|
# result = future.result() # This will block until the function completes
|
|
# print(f"{name.capitalize()} check result: {result}")
|
|
# except Exception as e:
|
|
# print(f"Error in {name}: {e}")
|
|
|
|
# except subprocess.CalledProcessError as e:
|
|
# print(f"Error running installer.py: {e}")
|
|
# print(f"Installer returned error output: {e.stderr}")
|
|
|
|
|
|
|
|
|
|
|
|
# def ddos():
|
|
# try:
|
|
# subprocess.run(['python3', '/home/tech4biz-001/Desktop/umais-code/Final_DDOS_UBUNTU_Tested/run.py'], check=True)
|
|
# print("DDOS check successful.")
|
|
# return True
|
|
# except subprocess.CalledProcessError as e:
|
|
# print(f"Error running DDoS script: {e}")
|
|
# return False
|
|
|
|
# def malware():
|
|
# try:
|
|
# subprocess.run(['python3', 'Final_Malware.py'], check=True)
|
|
# print("Malware check successful.")
|
|
# return True
|
|
# except subprocess.CalledProcessError as e:
|
|
# print(f"Error running malware script: {e}")
|
|
# return False
|
|
|
|
# def ransomware():
|
|
# try:
|
|
# subprocess.run(['python3', 'Ransomware_Type.py'], check=True)
|
|
# print("Ransomware check successful.")
|
|
# return True
|
|
# except subprocess.CalledProcessError as e:
|
|
# print(f"Error running ransomware script: {e}")
|
|
# return False
|
|
|
|
# def ransomware_model():
|
|
# try:
|
|
# subprocess.run(['python3', 'Ransomware_Audit.py'], check=True)
|
|
# print("Ransomware model check successful.")
|
|
# return True
|
|
# except subprocess.CalledProcessError as e:
|
|
# print(f"Error running ransomware model script: {e}")
|
|
# return False
|
|
|
|
# # Initialize the Tkinter window
|
|
# root = tk.Tk()
|
|
# root.title("Marged App")
|
|
# root.geometry("400x300")
|
|
|
|
# label = tk.Label(root, text="Tkinter Application for Device Check")
|
|
# label.pack(pady=20)
|
|
|
|
# # Add a button to trigger the devicecheck function
|
|
# button = tk.Button(root, text="Start Device Check", command=devicecheck)
|
|
# button.pack(pady=10)
|
|
|
|
# # Start the Tkinter main loop
|
|
# root.mainloop() |