API Proton Mail

#!/usr/bin/env python3
import requests
from datetime import datetime
import re

def check_proton_account(email):
    """
    Consulta información de una cuenta ProtonMail usando la API pública
    """

    # Endpoint de búsqueda
    search_url = f'https://api.protonmail.ch/pks/lookup?op=index&search={email}'

    try:
        # 1. Verificar si la cuenta existe
        print(f"🔍 Consultando información para: {email}")
        print("=" * 50)

        response = requests.get(search_url, timeout=10)

        if response.status_code != 200:
            print(f"❌ Error en la API: {response.status_code}")
            return

        body = response.text

        # 2. Analizar respuesta
        if "info:1:0" in body:
            print(f"📭 {email} - NO existe en ProtonMail")
            return
        elif "info:1:1" in body:
            print(f"✅ {email} - SÍ existe en ProtonMail")
        else:
            print("⚠️  Respuesta inesperada de la API")
            print(f"Respuesta completa:\n{body}")
            return

        # 3. Extraer información detallada
        print("\n📊 Información detallada:")
        print("-" * 30)

        # Patrones de búsqueda para diferentes tipos de cifrado
        patterns = {
            "RSA 2048-bit": r"2048:(.*?)::",
            "RSA 4096-bit": r"4096:(.*?)::",
            "X25519": r"22::(.*?)::",
            "Ed25519": r"22:(.*?)::"
        }

        found = False
        for algo, pattern in patterns.items():
            match = re.search(pattern, body)
            if match:
                timestamp = int(match.group(1))
                creation_date = datetime.fromtimestamp(timestamp)
                print(f"• Algoritmo: {algo}")
                print(f"• Fecha creación: {creation_date}")
                print(f"• Timestamp Unix: {timestamp}")
                found = True
                break

        if not found:
            print("• Algoritmo: No identificado")
            print("• Fecha creación: No disponible")

        # 4. Buscar User IDs adicionales
        uid_pattern = r"uid:(.*?):(\d+):"
        uid_matches = re.findall(uid_pattern, body)

        if uid_matches:
            print("\n👤 Identificadores asociados:")
            for uid, uid_timestamp in uid_matches:
                uid_date = datetime.fromtimestamp(int(uid_timestamp))
                print(f"  • {uid} (desde {uid_date})")

        # 5. Extraer fingerprint/ID de clave
        pub_pattern = r"pub:([A-F0-9]+):"
        pub_match = re.search(pub_pattern, body)
        if pub_match:
            key_id = pub_match.group(1)
            print(f"\n🔑 ID de clave pública: {key_id}")
            # Mostrar formato corto (últimos 8 caracteres)
            print(f"🔑 Fingerprint corto: {key_id[-8:].upper()}")

        # 6. Opción para descargar clave pública
        print("\n" + "=" * 50)
        download_choice = input("¿Descargar clave pública completa? (s/n): ")

        if download_choice.lower() == 's':
            download_public_key(email)

    except requests.exceptions.Timeout:
        print("⏰ Timeout: La API no respondió en 10 segundos")
    except requests.exceptions.ConnectionError:
        print("🔌 Error de conexión: No se pudo conectar a la API")
    except Exception as e:
        print(f"⚠️  Error inesperado: {e}")

def download_public_key(email):
    """
    Descarga y muestra la clave pública PGP completa
    """
    print(f"\n📥 Descargando clave pública para {email}...")

    download_url = f'https://api.protonmail.ch/pks/lookup?op=get&search={email}'

    try:
        response = requests.get(download_url, timeout=10)

        if response.status_code == 200:
            print("=" * 60)
            print("🔐 CLAVE PÚBLICA PGP:")
            print("=" * 60)
            print(response.text)
            print("=" * 60)

            # Guardar en archivo
            filename = f"{email.replace('@', '_')}_public_key.asc"
            with open(filename, 'w') as f:
                f.write(response.text)
            print(f"💾 Clave guardada en: {filename}")
        else:
            print(f"❌ Error al descargar clave: {response.status_code}")

    except Exception as e:
        print(f"⚠️  Error al descargar: {e}")

def check_account_quick(email):
    """
    Versión rápida para verificar solo existencia
    """
    try:
        url = f'https://api.protonmail.ch/pks/lookup?op=index&search={email}'
        response = requests.get(url, timeout=5)

        if "info:1:1" in response.text:
            return True, "Existe"
        elif "info:1:0" in response.text:
            return False, "No existe"
        else:
            return None, "Respuesta desconocida"
    except:
        return None, "Error de conexión"

# Función principal
def main():
    print("🔎 PROTONMAIL ACCOUNT CHECKER")
    print("=" * 40)

    # Consultar cuenta específica
    email = "[email protected]"

    # Opción: consulta rápida
    print("\n1. Consulta rápida:")
    exists, status = check_account_quick(email)
    if exists is True:
        print(f"   ✅ {email} - {status}")
    elif exists is False:
        print(f"   ❌ {email} - {status}")
    else:
        print(f"   ⚠️  {email} - {status}")

    # Opción: consulta completa
    print("\n2. Consulta completa:")
    check_proton_account(email)

    # Opción para probar otras cuentas
    print("\n" + "=" * 40)
    other_email = input("¿Verificar otra cuenta? (dejar vacío para salir): ").strip()

    if other_email:
        check_proton_account(other_email)

if __name__ == "__main__":
    main()