Python per la Cybersecurity: Scrivi il Tuo Primo Script di Sicurezza

TL;DR

Python è il linguaggio di programmazione più utilizzato nella cybersecurity, presente nel 72% dei progetti di sviluppo di strumenti di sicurezza e dei flussi di automazione SOC. Questa guida accompagna i principianti nella scrittura dei loro primi script di sicurezza: un TCP port scanner, un analizzatore di file di log e un verificatore di integrità dei file tramite hash. Nessuna esperienza di programmazione richiesta, solo la volontà di scrivere codice ed eseguirlo.

Erano le 18:14 di un venerdì quando Marcus, un analista SOC junior al terzo mese del suo primo lavoro nella sicurezza, notò qualcosa di strano. La dashboard del SIEM mostrava 847 tentativi di accesso falliti contro lo stesso account utente in una finestra di 90 minuti. IP sorgente diverse. Stesso obiettivo. Un attacco di credential stuffing da manuale. Il suo collega senior era già andato via per il fine settimana. Il runbook indicava di estrarre tutti gli IP sorgente, incrociarli con i feed di threat intelligence e bloccare gli indirizzi malevoli confermati al firewall. Copiare manualmente 847 voci di log, estrarre gli IP uno per uno e verificare ciascuno contro un feed di minacce avrebbe richiesto ore.

Marcus aprì un terminale e scrisse 23 righe di Python. Lo script analizzò il file di log, estrasse gli IP sorgente univoci, verificò ciascuno contro un'API aperta di threat intelligence e generò una blocklist di indirizzi malevoli confermati. Tempo di esecuzione totale: 11 secondi. Quello che avrebbe consumato l'intera serata divenne un problema risolto prima che finisse il caffè.

Quello script non era elegante. Non aveva gestione degli errori, né logging, né argomenti da riga di comando. Era funzionale, veloce e risolveva un problema reale. Questo è l'aspetto di Python per la cybersecurity nella pratica. Non devi essere un ingegnere del software. Devi essere qualcuno capace di tradurre un problema di sicurezza in codice funzionante.

Perché Python Domina la Cybersecurity

Python occupa una posizione unica nel mondo della sicurezza perché si colloca all'intersezione tra semplicità e potenza. Il SANS Institute identifica Python come il linguaggio più raccomandato per i professionisti della sicurezza, sottolineando che la sua sintassi leggibile permette agli analisti di scrivere strumenti funzionali senza anni di formazione in programmazione.

Tre caratteristiche rendono Python la scelta predefinita. Primo, la sua libreria standard include moduli per networking, gestione dei file, crittografia e comunicazione HTTP. Puoi costruire un port scanner, analizzare file di log o interagire con API web senza installare un singolo pacchetto esterno. Secondo, Python funziona su ogni piattaforma che i professionisti della sicurezza incontrano: Linux, Windows, macOS e persino sistemi embedded. Uno script scritto sul tuo laptop funziona in modo identico su un server remoto. Terzo, la comunità della sicurezza ha sviluppato migliaia di librerie specificamente per il lavoro offensivo e difensivo, da Scapy per la creazione di pacchetti a Volatility per la forensica della memoria.

L'impatto pratico è misurabile. Secondo un sondaggio SANS 2025, i team SOC che automatizzano le attività ripetitive con lo scripting riducono il loro tempo medio di risposta (MTTR) fino al 40%. Quando una minaccia emerge alle 2 di notte, la differenza tra una risposta manuale di 45 minuti e una automatizzata di 11 secondi è la differenza tra contenimento e violazione.

Configurazione del Tuo Ambiente Python per la Sicurezza

Prima di scrivere codice, hai bisogno di un'installazione Python funzionante e di un editor di testo. Se usi Kali Linux o qualsiasi distribuzione Linux moderna, Python 3 è già installato. Verificalo aprendo un terminale e digitando:

python3 --version

Su Windows o macOS, scarica Python da python.org. Durante l'installazione su Windows, seleziona la casella «Add Python to PATH». Questo passaggio è fondamentale. Senza di esso, il tuo terminale non riconoscerà il comando python.

Per scrivere script, qualsiasi editor di testo funziona. VS Code con l'estensione Python fornisce evidenziazione della sintassi, rilevamento errori e un terminale integrato. I principianti spesso si trovano bene con editor più semplici come Nano su Linux o Notepad++ su Windows. Lo strumento conta meno dell'abitudine di scrivere effettivamente codice.

Crea una directory dedicata per i tuoi script di sicurezza:

mkdir ~/security-scripts
cd ~/security-scripts

Tutti gli script di questa guida funzionano con la libreria standard di Python. Nessuna installazione pip richiesta per i tuoi primi tre progetti.

Il Tuo Primo Script: TCP Port Scanner

La scansione delle porte è fondamentale per il penetration testing e la ricognizione di rete. Prima di poter testare la sicurezza di un sistema, devi sapere quali servizi sono in esecuzione e quali porte sono aperte. Mentre strumenti come Nmap gestiscono questo professionalmente, costruire il tuo scanner ti insegna come funzionano realmente le connessioni TCP.

Una connessione TCP inizia con un handshake a tre vie. La tua macchina invia un pacchetto SYN, il target risponde con SYN-ACK se la porta è aperta, e la tua macchina completa l'handshake con un ACK. Se la porta è chiusa, il target invia un pacchetto RST. Il modulo socket di Python gestisce l'intero processo.

import socket
import sys
from datetime import datetime

def scan_port(target, port):
    """Attempt a TCP connection to a single port."""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(1)
        result = sock.connect_ex((target, port))
        sock.close()
        return result == 0
    except socket.error:
        return False

def scan_target(target, start_port, end_port):
    """Scan a range of ports on the target host."""
    print(f"\nScanning {target}")
    print(f"Started at {datetime.now().strftime('%H:%M:%S')}")
    print("-" * 40)

    open_ports = []

    for port in range(start_port, end_port + 1):
        if scan_port(target, port):
            open_ports.append(port)
            try:
                service = socket.getservbyport(port)
            except OSError:
                service = "unknown"
            print(f"  Port {port}: OPEN ({service})")

    print(f"\nScan complete. {len(open_ports)} open port(s) found.")
    return open_ports

if __name__ == "__main__":
    target = input("Target IP or hostname: ")
    scan_target(target, 1, 1024)

Salva questo come port_scanner.py ed eseguilo con python3 port_scanner.py. Inserisci 127.0.0.1 (la tua macchina) come target per test sicuri. Lo script tenta una connessione TCP su ogni porta da 1 a 1024, riporta le porte aperte con i nomi dei servizi e ti dice quante ne ha trovate.

Questo scanner è volutamente semplice. Gli strumenti di produzione come Nmap usano raw socket, scansione SYN ed esecuzione multithread per la velocità. Ma questo script dimostra il concetto fondamentale: una porta è aperta se una connessione TCP riesce. Comprendere questa base ti rende un utente più efficace degli strumenti professionali.

Automatizzazione dell'Analisi dei Log Con Python

Gli analisti SOC trascorrono una parte significativa della giornata leggendo log. Log di autenticazione, log di accesso ai server web, log del firewall e log delle applicazioni contengono tutti prove di attacchi, configurazioni errate e anomalie. Revisionare manualmente migliaia di righe è lento e soggetto a errori. Python trasforma questo in un processo strutturato e ripetibile.

Lo script seguente analizza un file auth.log standard, estrae i tentativi di accesso SSH falliti, conta i tentativi per IP sorgente e segnala gli IP che superano una soglia:

import re
from collections import Counter

def analyze_auth_log(filepath, threshold=10):
    """Parse auth.log for failed SSH attempts and flag suspicious IPs."""
    failed_pattern = re.compile(
        r"Failed password for (?:invalid user )?(\S+) from (\d+\.\d+\.\d+\.\d+)"
    )

    attempts = []
    usernames_targeted = {}

    with open(filepath, "r") as log_file:
        for line in log_file:
            match = failed_pattern.search(line)
            if match:
                username = match.group(1)
                ip_address = match.group(2)
                attempts.append(ip_address)

                if ip_address not in usernames_targeted:
                    usernames_targeted[ip_address] = set()
                usernames_targeted[ip_address].add(username)

    ip_counts = Counter(attempts)

    print(f"Total failed login attempts: {len(attempts)}")
    print(f"Unique source IPs: {len(ip_counts)}")
    print(f"\nIPs exceeding {threshold} failed attempts:")
    print("-" * 55)

    flagged = []
    for ip, count in ip_counts.most_common():
        if count >= threshold:
            users = usernames_targeted.get(ip, set())
            print(f"  {ip:18s}  {count:4d} attempts  {len(users)} usernames")
            flagged.append(ip)

    if flagged:
        print(f"\nBlocklist ({len(flagged)} IPs):")
        for ip in flagged:
            print(ip)

    return flagged

if __name__ == "__main__":
    flagged_ips = analyze_auth_log("/var/log/auth.log", threshold=10)

Il modulo re gestisce il pattern matching con le espressioni regolari. La classe Counter da collections conta automaticamente le occorrenze. Insieme, trasformano un muro di testo in informazioni azionabili: quali IP stanno attaccando, con quanta aggressività e quali nomi utente prendono di mira.

Questo script rivela pattern di attacco che la revisione manuale non coglie. Un IP che ha provato 200 nomi utente diversi sta eseguendo un attacco a dizionario. Un IP che ha provato lo stesso nome utente 500 volte sta facendo brute force su un account specifico. La distinzione è importante perché ogni pattern richiede una risposta diversa.

Costruzione di un Verificatore di Integrità dei File

Il monitoraggio dell'integrità dei file rileva modifiche non autorizzate ai file di sistema critici. Quando un malware modifica un file di configurazione, sostituisce un binario o installa una backdoor, l'hash crittografico del file cambia. Confrontando gli hash attuali con i valori di riferimento noti, rilevi le manomissioni che altrimenti potrebbero passare inosservate.

La Pubblicazione Speciale 800-53 del NIST elenca il monitoraggio dell'integrità dei file come controllo di sicurezza fondamentale (SI-7). Il modulo hashlib di Python calcola gli hash usando gli stessi algoritmi su cui si basano gli strumenti enterprise.

import hashlib
import os
import json
from datetime import datetime

def hash_file(filepath):
    """Calculate SHA-256 hash of a file."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, "rb") as f:
            for chunk in iter(lambda: f.read(8192), b""):
                sha256.update(chunk)
        return sha256.hexdigest()
    except (PermissionError, FileNotFoundError) as e:
        return f"ERROR: {e}"

def create_baseline(directories, output_file="baseline.json"):
    """Create a hash baseline for files in specified directories."""
    baseline = {}
    file_count = 0

    for directory in directories:
        for root, dirs, files in os.walk(directory):
            for filename in files:
                filepath = os.path.join(root, filename)
                file_hash = hash_file(filepath)
                if not file_hash.startswith("ERROR"):
                    baseline[filepath] = {
                        "hash": file_hash,
                        "recorded_at": datetime.now().isoformat()
                    }
                    file_count += 1

    with open(output_file, "w") as f:
        json.dump(baseline, f, indent=2)

    print(f"Baseline created: {file_count} files recorded.")
    return baseline

def check_integrity(baseline_file="baseline.json"):
    """Compare current file hashes against the baseline."""
    with open(baseline_file, "r") as f:
        baseline = json.load(f)

    modified = []
    missing = []

    for filepath, record in baseline.items():
        if not os.path.exists(filepath):
            missing.append(filepath)
            continue

        current_hash = hash_file(filepath)
        if current_hash != record["hash"]:
            modified.append({
                "file": filepath,
                "expected": record["hash"][:16] + "...",
                "actual": current_hash[:16] + "..."
            })

    print(f"\nIntegrity Check Results")
    print(f"Files checked: {len(baseline)}")
    print(f"Modified: {len(modified)}")
    print(f"Missing: {len(missing)}")

    if modified:
        print(f"\nMODIFIED FILES:")
        for entry in modified:
            print(f"  {entry['file']}")
            print(f"    Expected: {entry['expected']}")
            print(f"    Actual:   {entry['actual']}")

    if missing:
        print(f"\nMISSING FILES:")
        for filepath in missing:
            print(f"  {filepath}")

    return modified, missing

if __name__ == "__main__":
    import sys

    if len(sys.argv) > 1 and sys.argv[1] == "check":
        check_integrity()
    else:
        dirs_to_monitor = ["/etc/ssh", "/etc/cron.d"]
        create_baseline(dirs_to_monitor)
        print("Run with 'check' argument to verify integrity.")

Esegui python3 integrity_checker.py per creare un riferimento, poi python3 integrity_checker.py check per verificare i file. Qualsiasi modifica, anche un singolo byte cambiato, produce un hash completamente diverso. Questo è lo stesso principio che alimenta strumenti come OSSEC e Tripwire.

Lo script legge i file in blocchi di 8192 byte, il che significa che gestisce file di qualsiasi dimensione senza caricarli interamente in memoria. Memorizza i riferimenti come JSON, rendendoli leggibili e facili da integrare con altri strumenti.

Dove Python Si Inserisce nella Tua Carriera nella Sicurezza

Python non è un sostituto della comprensione dei concetti di sicurezza. È un amplificatore. Sapere come funziona un attacco brute force ha valore. Scrivere uno script che ne rileva uno in tempo reale, estrae indicatori di compromissione e genera una blocklist è un differenziatore di carriera.

Per aspiranti analisti SOC, Python automatizza le attività ripetitive che consumano tempo di investigazione: analizzare i log, arricchire gli IOC con threat intelligence, generare report e correlare eventi tra le fonti di dati. Per i penetration tester, Python consente lo sviluppo di exploit personalizzati, la generazione di payload e l'automazione post-exploitation. Per i security engineer, gli script Python integrano gli strumenti, automatizzano il deployment e applicano le policy.

Il percorso in avanti segue una progressione chiara. Padroneggia gli script della libreria standard in questa guida. Poi esplora le librerie esterne: requests per l'interazione con le API, scapy per la manipolazione dei pacchetti, paramiko per l'automazione SSH. Costruisci strumenti che risolvono problemi che incontri nel tuo lab o lavoro. Contribuisci a progetti di sicurezza open source. Ogni script che scrivi costruisce sia competenza che un portfolio che dimostra le tue capacità ai datori di lavoro.

Cosa Costruire Dopo

Una volta che i tre script di questa guida funzionano, espandili. Aggiungi il multithreading al port scanner perché finisca in secondi invece che minuti. Fai in modo che l'analizzatore di log accetti argomenti da riga di comando perché funzioni con diversi formati di log. Programma l'esecuzione del verificatore di integrità ogni ora con cron e l'invio di avvisi e-mail quando vengono rilevate modifiche.

Poi affronta nuovi progetti. Scrivi uno script che interroga l'API di VirusTotal per verificare gli hash dei file contro firme di malware conosciute. Costruisci un toolkit semplice di incident response che raccoglie informazioni di sistema, connessioni attive, processi in esecuzione e modifiche recenti ai file in un unico report. Crea un analizzatore di robustezza delle password che verifica le password contro wordlist comuni e calcola l'entropia.

Ogni script che costruisci rafforza due competenze simultaneamente: programmazione Python e pensiero sulla sicurezza. Impari a pensare come un difensore e come un attaccante, che è esattamente ciò che i datori di lavoro cercano. L'analista junior che ha automatizzato 847 voci di log un venerdì sera è diventato il punto di riferimento del team per l'automazione in sei mesi. Non perché fosse il miglior programmatore, ma perché era l'analista capace di tradurre problemi di sicurezza in soluzioni funzionanti.

Inizia con il port scanner. Eseguilo contro la tua macchina. Leggi l'output. Capisci cosa significa ogni porta aperta. Questo è il primo passo dalla teoria alla pratica, e Python è il ponte che ti porta lì.