Aller au contenu principal
NUKOE

Costruire un rilevatore di password compromesse in Python: guida pratica

• 6 min •
Capture d'écran d'un vérificateur de fuites de mots de passe en Python

Immaginate questo: utilizzate la stessa password su più siti da anni. Una mattina, ricevete un avviso che le vostre credenziali circolano sul dark web. Questa situazione non è ipotetica – accade quotidianamente a migliaia di utenti. Eppure, la maggior parte degli sviluppatori ignora come verificare proattivamente se le proprie password siano state compromesse.

Contrariamente a quanto si potrebbe pensare, non è necessario essere esperti di cybersecurity per creare strumenti di protezione di base. In meno di 50 righe di codice Python, potete costruire un verificatore di fughe di password che utilizza dati reali di violazioni. Questo articolo vi guida passo dopo passo nella creazione di uno strumento del genere, spiegando perché questo approccio è più efficace delle verifiche manuali e come integrarlo nei vostri flussi di lavoro di sviluppo.

Perché scansionare file di testo per password in chiaro?

Prima ancora di verificare se una password sia trapelata online, bisogna assicurarsi che non sia memorizzata in chiaro nel vostro codice o nei file di configurazione. Come sottolinea un utente di Spiceworks Community, la ricerca di password hardcoded in file di testo è una preoccupazione reale per i team IT. Lo script Python che svilupperemo potrebbe essere adattato per scansionare directory alla ricerca di stringhe di caratteri simili a password – una prima linea di difesa spesso trascurata.

L'approccio tradizionale consiste nel cercare pattern specifici, ma come nota la discussione su Spiceworks, questo metodo ha i suoi limiti. Una password come "P@ssw0rd2025!" potrebbe sfuggire a una ricerca basata sul termine "password". Ecco perché il nostro strumento si concentrerà prima sulla verifica esterna tramite database di fughe note.

L'API Have I Been Pwned: la vostra alleata contro le fughe

Il cuore del nostro rilevatore si baserà sull'API Have I Been Pwned (HIBP), un servizio mantenuto da Troy Hunt che aggrega miliardi di account compromessi. Invece di trasmettere la password in chiaro, utilizzeremo la tecnica della k-anonimity: viene inviato solo un prefisso dell'hash SHA-1 della password, preservando così la riservatezza. L'API restituisce poi la lista completa degli hash corrispondenti a questo prefisso, che confronteremo localmente con l'hash completo.

Questo approccio, descritto in un articolo di DEV Community, rappresenta il metodo raccomandato per verificare le fughe senza esporre la password originale. Combina efficienza e rispetto della privacy – due aspetti cruciali spesso in tensione negli strumenti di sicurezza.

Il codice: uno script Python in tre parti

1. Installazione delle dipendenze

Il nostro script richiede solo la libreria `requests`, che potete installare via pip:

pip install requests

2. Funzione di hashing sicura

import hashlib
import requests

def check_password_leak(password):
    # Creare l'hash SHA-1 della password
    sha1_hash = hashlib.sha1(password.encode('utf-8')).hexdigest().upper()
    prefix = sha1_hash[:5]
    suffix = sha1_hash[5:]
    
    # Interrogare l'API HIBP
    url = f"https://api.pwnedpasswords.com/range/{prefix}"
    response = requests.get(url)
    
    if response.status_code == 200:
        hashes = (line.split(':') for line in response.text.splitlines())
        for h, count in hashes:
            if h == suffix:
                return True, int(count)
        return False, 0
    else:
        raise Exception("Richiesta API fallita")

3. Interfaccia utente semplice

def main():
    print("=== Verificatore di fughe di password ===")
    password = input("Inserisci la password da verificare: ")
    
    try:
        leaked, count = check_password_leak(password)
        if leaked:
            print(f"⚠️  Questa password è stata trovata in {count} fughe di dati.")
            print("Raccomandazione: cambiatela immediatamente.")
        else:
            print("✅ Questa password non è stata trovata nelle fughe note.")
            print("Nota: ciò non garantisce la sua forza o sicurezza.")
    except Exception as e:
        print(f"Errore: {e}")

if name == "main":
    main()

Oltre la verifica: generazione e memorizzazione sicure

Verificare le fughe è solo una parte dell'equazione. Se la vostra password è compromessa, bisogna sostituirla – ma con cosa? Come sottolinea Stack Overflow, su Python 3.6+, il modulo `secrets` deve essere utilizzato per generare password crittograficamente sicure. Ecco un esempio complementare:

import secrets
import string

def generate_secure_password(length=16):
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

Una volta generata una nuova password, sorge la questione della memorizzazione. Un altro thread di Stack Overflow affronta proprio questo problema: come memorizzare in modo sicuro credenziali in uno script Python? Le soluzioni vanno dalla cifratura locale all'utilizzo di password manager dedicati, passando per i token di accesso personali come quelli descritti nella documentazione Microsoft per Azure DevOps.

Applicazioni pratiche e limitazioni

Questo script di base può essere esteso in diversi modi:

  • Scansionare automaticamente file di configurazione alla ricerca di password hardcoded (come menzionato in Spiceworks Community)
  • Integrare la verifica in una pipeline CI/CD per avvisare se credenziali sensibili vengono accidentalmente committate
  • Creare una semplice interfaccia web per team non tecnici

Tuttavia, presenta limitazioni importanti. Verifica solo contro fughe già documentate in HIBP. Una password debole ma non ancora trapelata supererebbe il test. Ecco perché KnowledgeHut include progetti di test della forza delle password nella sua lista di progetti cybersecurity – i due approcci sono complementari.

Il futuro: quando il deep learning incontra la sicurezza delle password

Un approccio affascinante emerge dal lato della ricerca: utilizzare il deep learning per identificare password in file o codice. Il progetto DeepPass, presentato su SpecterOps, utilizza modelli di apprendimento profondo per rilevare "candidati password" in contesti vari. Sebbene più complesso da implementare rispetto al nostro script semplice, questa direzione mostra come l'IA potrebbe in futuro automatizzare il rilevamento di configurazioni pericolose.

Conclusione: la sicurezza come pratica quotidiana

Costruire un verificatore di fughe di password in Python non è solo un esercizio tecnico – è l'adozione di una mentalità proattiva di fronte ai rischi digitali. Comprendendo come funzionano questi strumenti, diventate meglio equipaggiati per valutare la sicurezza delle vostre pratiche e di quelle dei vostri progetti.

Il codice presentato qui è un punto di partenza. Potreste estenderlo per gestire liste di password, aggiungere test di forza di base, o integrarlo in audit regolari. In un mondo dove, secondo l'articolo di DEV Community, miliardi di credenziali circolano sul dark web, queste poche righe di Python potrebbero fare la differenza tra una sicurezza illusoria e una protezione reale.

Iniziate testando le vostre password – i risultati potrebbero sorprendervi. Poi, condividete questo strumento con il vostro team. La sicurezza non è solo una questione di esperti; è una responsabilità collettiva che inizia con strumenti accessibili.

Per approfondire