system_monitor.py

#!/usr/bin/env python3
"""
System Monitor & Info Tool
Per uso personale su dispositivi propri
Compatibile con Kali Linux e Termux
"""

import os
import sys
import platform
import socket
import subprocess
import json
import time
from datetime import datetime

class SystemMonitor:
    def __init__(self):
        self.is_termux = 'com.termux' in os.environ.get('PREFIX', '')
        self.is_root = os.geteuid() == 0 if hasattr(os, 'geteuid') else False
        self.monitoring = False
        
    def banner(self):
        print("\n" + "="*50)
        print("   System Monitor & Info Tool")
        print("   Per uso personale")
        print("="*50 + "\n")
    
    def get_system_info(self):
        """Raccoglie informazioni di sistema base"""
        info = {
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "hostname": socket.gethostname(),
            "platform": platform.system(),
            "platform_release": platform.release(),
            "platform_version": platform.version(),
            "architecture": platform.machine(),
            "processor": platform.processor(),
            "is_termux": self.is_termux,
            "is_root": self.is_root
        }
        return info
    
    def get_network_info(self):
        """Raccoglie informazioni di rete"""
        try:
            hostname = socket.gethostname()
            local_ip = socket.gethostbyname(hostname)
            
            # Ottiene interfacce di rete
            if self.is_termux:
                cmd = "ip addr show"
            else:
                cmd = "ip addr show" if os.path.exists("/sbin/ip") else "ifconfig"
            
            result = subprocess.run(cmd.split(), capture_output=True, text=True)
            interfaces = result.stdout
            
            return {
                "hostname": hostname,
                "local_ip": local_ip,
                "interfaces": interfaces
            }
        except Exception as e:
            return {"error": str(e)}
    
    def get_process_info(self):
        """Lista processi in esecuzione"""
        try:
            result = subprocess.run(['ps', 'aux'], capture_output=True, text=True)
            return result.stdout
        except Exception as e:
            return f"Errore: {str(e)}"
    
    def get_disk_info(self):
        """Informazioni sui dischi"""
        try:
            result = subprocess.run(['df', '-h'], capture_output=True, text=True)
            return result.stdout
        except Exception as e:
            return f"Errore: {str(e)}"
    
    def get_memory_info(self):
        """Informazioni sulla memoria"""
        try:
            result = subprocess.run(['free', '-h'], capture_output=True, text=True)
            return result.stdout
        except Exception as e:
            return f"Errore: {str(e)}"
    
    def get_users_info(self):
        """Utenti connessi"""
        try:
            result = subprocess.run(['who'], capture_output=True, text=True)
            return result.stdout
        except Exception as e:
            return f"Errore: {str(e)}"
    
    def get_cpu_info(self):
        """Informazioni dettagliate CPU"""
        try:
            cpu_info = {}
            
            # Load average
            result = subprocess.run(['uptime'], capture_output=True, text=True)
            cpu_info['uptime'] = result.stdout.strip()
            
            # CPU cores
            result = subprocess.run(['nproc'], capture_output=True, text=True)
            cpu_info['cores'] = result.stdout.strip()
            
            # CPU usage via top
            result = subprocess.run(['top', '-bn1'], capture_output=True, text=True)
            cpu_info['top_info'] = result.stdout
            
            return cpu_info
        except Exception as e:
            return {"error": str(e)}
    
    def get_wireless_info(self):
        """Informazioni interfacce wireless"""
        try:
            result = subprocess.run(['iwconfig'], capture_output=True, text=True)
            wireless_info = {"iwconfig": result.stdout}
            
            # Aggiungi dettagli iw dev se disponibile
            result = subprocess.run(['iw', 'dev'], capture_output=True, text=True)
            wireless_info['iw_dev'] = result.stdout
            
            return wireless_info
        except Exception as e:
            return {"error": str(e)}
    
    def get_connections_info(self):
        """Connessioni di rete attive"""
        try:
            result = subprocess.run(['ss', '-tunap'], capture_output=True, text=True)
            return result.stdout
        except:
            try:
                result = subprocess.run(['netstat', '-tunap'], capture_output=True, text=True)
                return result.stdout
            except Exception as e:
                return f"Errore: {str(e)}"
    
    def get_services_info(self):
        """Servizi in esecuzione"""
        try:
            if os.path.exists('/usr/bin/systemctl'):
                result = subprocess.run(['systemctl', 'list-units', '--type=service', '--state=running'], 
                                       capture_output=True, text=True)
                return result.stdout
            else:
                return "systemctl non disponibile"
        except Exception as e:
            return f"Errore: {str(e)}"
    
    def get_logged_events(self, lines=50):
        """Eventi recenti dal sistema"""
        try:
            result = subprocess.run(['tail', f'-n{lines}', '/var/log/auth.log'], 
                                   capture_output=True, text=True)
            return result.stdout
        except:
            try:
                result = subprocess.run(['dmesg'], capture_output=True, text=True)
                return result.stdout
            except Exception as e:
                return f"Errore: {str(e)}"
    
    def get_io_stats(self):
        """Statistiche I/O disco"""
        try:
            result = subprocess.run(['iostat', '-x', '1', '2'], capture_output=True, text=True)
            return result.stdout
        except:
            try:
                result = subprocess.run(['cat', '/proc/diskstats'], capture_output=True, text=True)
                return result.stdout
            except Exception as e:
                return f"Errore: {str(e)}"
    
    def display_menu(self):
        """Menu interattivo"""
        print("\n[1]  Informazioni Sistema")
        print("[2]  Informazioni Rete")
        print("[3]  Processi Attivi")
        print("[4]  Utilizzo Dischi")
        print("[5]  Utilizzo Memoria")
        print("[6]  Utenti Connessi")
        print("[7]  Info CPU Dettagliate")
        print("[8]  Interfacce Wireless")
        print("[9]  Connessioni Attive (ss/netstat)")
        print("[10] Servizi Attivi")
        print("[11] Log Sistema")
        print("[12] Statistiche I/O")
        print("[13] Report Completo (JSON)")
        print("[14] Report Completo (Testo)")
        print("[15] Monitoring Real-Time")
        print("[0]  Esci\n")
    
    def real_time_monitor(self):
        """Monitoring real-time sistema"""
        self.monitoring = True
        print("\n=== MONITORING REAL-TIME ===")
        print("Premi CTRL+C per fermare\n")
        
        try:
            while self.monitoring:
                os.system('clear')
                print(f"\n{'='*60}")
                print(f"  System Monitor - {datetime.now().strftime('%H:%M:%S')}")
                print(f"{'='*60}\n")
                
                print("=== MEMORIA ===")
                print(self.get_memory_info())
                
                print("\n=== CPU (TOP 10) ===")
                try:
                    result = subprocess.run(['ps', 'aux', '--sort=-%cpu', '|', 'head', '-n', '11'], 
                                           capture_output=True, text=True, shell=True)
                    print(result.stdout)
                except:
                    print("Errore nel recupero CPU")
                
                print("\n=== UTILIZZO DISCHI ===")
                print(self.get_disk_info())
                
                time.sleep(2)
        except KeyboardInterrupt:
            self.monitoring = False
            print("\n\nMonitoring fermato.")
    
    def generate_full_report(self, format='text'):
        """Genera report completo"""
        print("\nGenerazione report in corso...\n")
        report = {
            "system_info": self.get_system_info(),
            "network_info": self.get_network_info(),
            "disk_info": self.get_disk_info(),
            "memory_info": self.get_memory_info(),
            "users_info": self.get_users_info(),
            "cpu_info": self.get_cpu_info(),
            "wireless_info": self.get_wireless_info(),
            "connections": self.get_connections_info(),
            "services": self.get_services_info()
        }
        
        if format == 'json':
            return json.dumps(report, indent=2)
        else:
            text = "\n=== REPORT SISTEMA ===\n\n"
            text += "--- Informazioni Sistema ---\n"
            for k, v in report['system_info'].items():
                text += f"{k}: {v}\n"
            text += "\n--- Informazioni Rete ---\n"
            text += str(report['network_info']) + "\n"
            text += "\n--- Utilizzo Dischi ---\n"
            text += report['disk_info'] + "\n"
            text += "\n--- Utilizzo Memoria ---\n"
            text += report['memory_info'] + "\n"
            text += "\n--- Utenti Connessi ---\n"
            text += report['users_info'] + "\n"
            return text
    
    def run(self):
        """Esegue il tool in modalità interattiva"""
        self.banner()
        
        while True:
            self.display_menu()
            try:
                choice = input("Seleziona opzione: ").strip()
                
                if choice == '1':
                    info = self.get_system_info()
                    print("\n=== INFORMAZIONI SISTEMA ===")
                    for key, value in info.items():
                        print(f"{key}: {value}")
                
                elif choice == '2':
                    info = self.get_network_info()
                    print("\n=== INFORMAZIONI RETE ===")
                    for key, value in info.items():
                        print(f"\n{key}:")
                        print(value)
                
                elif choice == '3':
                    print("\n=== PROCESSI ATTIVI ===")
                    print(self.get_process_info())
                
                elif choice == '4':
                    print("\n=== UTILIZZO DISCHI ===")
                    print(self.get_disk_info())
                
                elif choice == '5':
                    print("\n=== UTILIZZO MEMORIA ===")
                    print(self.get_memory_info())
                
                elif choice == '6':
                    print("\n=== UTENTI CONNESSI ===")
                    print(self.get_users_info())
                
                elif choice == '7':
                    print("\n=== INFO CPU DETTAGLIATE ===")
                    info = self.get_cpu_info()
                    for key, value in info.items():
                        print(f"\n{key.upper()}:")
                        print(value)
                
                elif choice == '8':
                    print("\n=== INTERFACCE WIRELESS ===")
                    info = self.get_wireless_info()
                    for key, value in info.items():
                        print(f"\n--- {key} ---")
                        print(value)
                
                elif choice == '9':
                    print("\n=== CONNESSIONI ATTIVE ===")
                    print(self.get_connections_info())
                
                elif choice == '10':
                    print("\n=== SERVIZI ATTIVI ===")
                    print(self.get_services_info())
                
                elif choice == '11':
                    print("\n=== LOG SISTEMA ===")
                    print(self.get_logged_events())
                
                elif choice == '12':
                    print("\n=== STATISTICHE I/O ===")
                    print(self.get_io_stats())
                
                elif choice == '13':
                    print("\n=== REPORT COMPLETO (JSON) ===")
                    report = self.generate_full_report('json')
                    print(report)
                    filename = f"report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
                    with open(filename, 'w') as f:
                        f.write(report)
                    print(f"\nReport salvato in: {filename}")
                
                elif choice == '14':
                    print("\n=== REPORT COMPLETO ===")
                    report = self.generate_full_report('text')
                    print(report)
                    filename = f"report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
                    with open(filename, 'w') as f:
                        f.write(report)
                    print(f"\nReport salvato in: {filename}")
                
                elif choice == '15':
                    self.real_time_monitor()
                
                elif choice == '0':
                    print("\nArrivederci!")
                    break
                
                else:
                    print("\nOpzione non valida!")
                
                input("\nPremi INVIO per continuare...")
                
            except KeyboardInterrupt:
                print("\n\nInterrotto dall'utente. Arrivederci!")
                break
            except Exception as e:
                print(f"\nErrore: {str(e)}")

if __name__ == "__main__":
    monitor = SystemMonitor()
    monitor.run()