Aller au contenu principal
NUKOE

Detector de fugas de contraseñas en Python: Guía práctica paso a paso

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

Imaginen esto: han estado usando la misma contraseña en múltiples sitios durante años. Una mañana, reciben una alerta indicando que sus credenciales circulan en la dark web. Esta situación no es hipotética – ocurre diariamente a miles de usuarios. Sin embargo, la mayoría de los desarrolladores ignoran cómo verificar proactivamente si sus propias contraseñas han sido comprometidas.

Contrario a lo que se podría creer, no necesitan ser un experto en ciberseguridad para crear herramientas de protección básicas. En menos de 50 líneas de código Python, pueden construir un verificador de fugas de contraseñas que utiliza datos reales de violaciones. Este artículo les guía paso a paso en la creación de dicha herramienta, explicando por qué este enfoque es más efectivo que las verificaciones manuales y cómo integrarlo en sus flujos de trabajo de desarrollo.

¿Por qué escanear archivos de texto en busca de contraseñas en texto plano?

Antes incluso de verificar si una contraseña ha filtrado en línea, primero hay que asegurarse de que no está almacenada en texto plano en su código o sus archivos de configuración. Como señala un usuario de Spiceworks Community, la búsqueda de contraseñas codificadas de forma rígida en archivos de texto es una preocupación real para los equipos de TI. El script Python que vamos a desarrollar podría adaptarse para escanear directorios en busca de cadenas de caracteres que se asemejen a contraseñas – una primera línea de defensa a menudo descuidada.

El enfoque tradicional consiste en buscar patrones específicos, pero como señala la discusión en Spiceworks, este método tiene sus límites. Una contraseña como "P@ssw0rd2025!" podría escapar a una búsqueda basada en el término "password". Es por eso que nuestra herramienta se centrará primero en la verificación externa a través de bases de datos de fugas conocidas.

La API Have I Been Pwned: su aliada contra las fugas

El corazón de nuestro detector se basará en la API Have I Been Pwned (HIBP), un servicio mantenido por Troy Hunt que agrega miles de millones de cuentas comprometidas. En lugar de transmitir la contraseña en texto plano, utilizaremos la técnica de k-anonimidad: solo se envía un prefijo del hash SHA-1 de la contraseña, preservando así la confidencialidad. La API devuelve luego la lista completa de hashes correspondientes a este prefijo, que compararemos localmente con el hash completo.

Este enfoque, descrito en un artículo de DEV Community, representa el método recomendado para verificar fugas sin exponer la contraseña original. Combina eficiencia y respeto por la privacidad – dos aspectos cruciales a menudo en tensión en las herramientas de seguridad.

El código: un script Python en tres partes

1. Instalación de dependencias

Nuestro script requiere únicamente la biblioteca `requests`, que pueden instalar vía pip:

pip install requests

2. Función de hash segura

import hashlib
import requests

def check_password_leak(password):
    # Crear el hash SHA-1 de la contraseña
    sha1_hash = hashlib.sha1(password.encode('utf-8')).hexdigest().upper()
    prefix = sha1_hash[:5]
    suffix = sha1_hash[5:]
    
    # Consultar la 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("Fallo en la solicitud API")

3. Interfaz de usuario simple

def main():
    print("=== Verificador de fugas de contraseñas ===")
    password = input("Ingrese la contraseña a verificar : ")
    
    try:
        leaked, count = check_password_leak(password)
        if leaked:
            print(f"⚠️  Esta contraseña ha sido encontrada en {count} fugas de datos.")
            print("Recomendación: cámbiela inmediatamente.")
        else:
            print("✅ Esta contraseña no ha sido encontrada en las fugas conocidas.")
            print("Nota: esto no garantiza su fortaleza o seguridad.")
    except Exception as e:
        print(f"Error: {e}")

if name == "main":
    main()

Más allá de la verificación: generación y almacenamiento seguros

Verificar fugas es solo una parte de la ecuación. Si su contraseña está comprometida, hay que reemplazarla – ¿pero por qué? Como señala Stack Overflow, en Python 3.6+, el módulo `secrets` debe usarse para generar contraseñas criptográficamente seguras. Aquí hay un ejemplo complementario:

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 vez generada una nueva contraseña, surge la pregunta del almacenamiento. Otro hilo de Stack Overflow aborda precisamente este problema: ¿cómo almacenar de manera segura credenciales en un script Python? Las soluciones van desde el cifrado local hasta el uso de cajas fuertes de contraseñas dedicadas, pasando por los tokens de acceso personales como los descritos en la documentación de Microsoft para Azure DevOps.

Aplicaciones prácticas y limitaciones

Este script básico puede extenderse de varias maneras:

  • Escanear automáticamente archivos de configuración en busca de contraseñas codificadas de forma rígida (como se menciona en Spiceworks Community)
  • Integrar la verificación en un pipeline CI/CD para alertar si credenciales sensibles son accidentalmente confirmadas (committed)
  • Crear una interfaz web simple para equipos no técnicos

Sin embargo, presenta limitaciones importantes. Solo verifica contra fugas ya documentadas en HIBP. Una contraseña débil pero aún no filtrada pasaría la prueba. Es por eso que KnowledgeHut incluye proyectos de prueba de fuerza de contraseña en su lista de proyectos de ciberseguridad – los dos enfoques son complementarios.

El futuro: cuando el aprendizaje profundo se encuentra con la seguridad de contraseñas

Un enfoque fascinante emerge en el lado de la investigación: usar el aprendizaje profundo para identificar contraseñas en archivos o código. El proyecto DeepPass, presentado en SpecterOps, utiliza modelos de aprendizaje profundo para detectar "candidatos a contraseñas" en contextos variados. Aunque más complejo de implementar que nuestro script simple, esta dirección muestra cómo la IA podría en el futuro automatizar la detección de configuraciones peligrosas.

Conclusión: la seguridad como práctica diaria

Construir un verificador de fugas de contraseñas en Python no es solo un ejercicio técnico – es la adopción de una mentalidad proactiva frente a los riesgos digitales. Al entender cómo funcionan estas herramientas, se vuelven mejor equipados para evaluar la seguridad de sus propias prácticas y las de sus proyectos.

El código presentado aquí es un punto de partida. Podrían extenderlo para manejar listas de contraseñas, agregar pruebas de fuerza básicas, o integrarlo a auditorías regulares. En un mundo donde, según el artículo de DEV Community, miles de millones de credenciales circulan en la dark web, estas pocas líneas de Python podrían marcar la diferencia entre una seguridad ilusoria y una protección real.

Comiencen por probar sus propias contraseñas – los resultados podrían sorprenderlos. Luego, compartan esta herramienta con su equipo. La seguridad no es solo asunto de expertos; es una responsabilidad colectiva que comienza con herramientas accesibles.

Para ir más lejos