trustedsec/hate_crackUna herramienta para automatizar metodologías de cracking mediante Hashcat, del equipo de TrustedSec.
```
___ ___ __ _________ __
/ | \_____ _/ |_ ____ \_ ___ \____________ ____ | | __
/ ~ \__ \\ __\/ __ \ / \ \/\_ __ \__ \ _/ ___\| |/ /
\ Y // __ \| | \ ___/ \ \____| | \// __ \\ \___| <
\___|_ /(____ /__| \___ >____\______ /|__| (____ /\___ >__|_ \
\/ \/ \/_____/ \/ \/ \/ \/
```
## Instalación
Instalar desde el código fuente es la única vía soportada. hate_crack **no**
se distribuye en PyPI: `pip install hate-crack` resuelve a un placeholder `0.0.0`
que falla a propósito y apunta de vuelta aquí. El nombre se reserva únicamente para que nadie más
pueda publicar un clon bajo él — véase
[`packaging/pypi-placeholder/`](https://github.com/trustedsec/hate_crack/blob/main/packaging/pypi-placeholder).
### 1. Instalar hashcat
Hashcat debe estar instalado y disponible en tu PATH:
Ubuntu/Kali:
```bash
sudo apt-get install -y hashcat
```
macOS (Homebrew):
```bash
brew install hashcat
```
O descargue un binario precompilado desde https://hashcat.net/hashcat/ y establezca `hcatPath` en `config.json` a su ubicación.
### 2. Descargar hate_crack
Clone con submódulos (requerido para hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks y opcionalmente omen):
```bash
git clone --recurse-submodules https://github.com/trustedsec/hate_crack.git
cd hate_crack
```
Si clonaste sin submódulos, inicialízalos:
```bash
git submodule update --init --recursive
```
Luego personaliza la configuración si es necesario. hate_crack utiliza dos archivos de configuración, cada uno con un conjunto distinto de ajustes:
- **`config.json`** — rutas de wordlists, máscaras, reglas, ajustes de rendimiento, potfile, ruta de hashcat, límites de candidatos, toggles de notificación, valores predeterminados de preferencia de CLI (35 ajustes).
- **`.env`** — únicamente ajustes de integración con terceros: credenciales de Hashview y Hashmob, credenciales de Pushover, Ollama y pipal (14 ajustes). No rastreado por git, creado con modo `0600`.
La línea divisoria está ahí por una razón: `.env` es el archivo que puede contener secretos. Las credenciales y la configuración de servicios de terceros van en el archivo no rastreado con modo `0600`; todo lo que hate_crack hace localmente permanece en `config.json`, que es seguro para compartir, comparar y guardar en tus propias notas. Esa es también la razón por la que las *credenciales* de Pushover están en `.env` mientras que los *toggles* de activación/desactivación de Pushover están en `config.json` — los toggles son preferencias locales, no secretos.
Cada clave tiene exactamente un hogar. Una clave colocada en el otro archivo se ignora, y hate_crack imprime una advertencia nombrando el archivo al que pertenece. Cualquier clave aún puede sobrescribirse para una sola ejecución exportando su variable de entorno. La mayoría de los usuarios pueden omitir este paso, ya que las rutas predeterminadas funcionan sin configuración adicional.
`config.json` es permanente y de primera clase — no está obsoleto y no hay un plazo de eliminación para él. Solo los ajustes de integración se movieron.
**¿Actualizando desde un único `config.json`?** hate_crack lo migra por ti en la primera ejecución: los ajustes de integración se copian a un nuevo `.env` con modo `0600`, luego se eliminan de `config.json` para que ambos archivos no los reclamen. Imprime qué claves se movieron (nunca sus valores), y guarda tu original como `config.json.pre-split.bak` antes de tocarlo. Todo lo demás en `config.json` se deja exactamente como estaba, incluido el orden de las claves.
**Primera ejecución:** hate_crack crea ambos archivos por ti, así que no hay nada que hacer. Para configurar `.env` manualmente en su lugar, copia la plantilla rastreada:
```bash
cp .env.example .env
chmod 600 .env
```
`.env.example` está versionado y se distribuye con cada clave de credencial vacía. El propio `.env` **nunca** debe versionarse — está en gitignore, junto con sus variantes habituales de respaldo, y hate_crack siempre lo crea con modo `0600` (solo lectura/escritura del propietario). `.env.example` se genera a partir del esquema; regenéralo después de modificar `hate_crack/config_schema.py` con `uv run python -m hate_crack.config_writer`.
### 3. Instalar dependencias y hate_crack
La forma más sencilla es ejecutar `make` (o `make install`), que detecta automáticamente tu SO e instala:
- Dependencias externas (p7zip, transmission-daemon / transmission-remote)
- Compila los submódulos (hashcat-utils, princeprocessor, pcfg_cracker y, opcionalmente, omen) y extrae el conjunto de máscaras Corporate_Masks, que solo contiene datos
- Dependencias de Python mediante uv y un shim de CLI en `~/.local/bin/hate_crack`
```bash
make
```
Esto es idempotente: omite las herramientas ya instaladas. Para forzar una reinstalación limpia:
```bash
make reinstall
```
**O instalar dependencias manualmente:**
### Dependencias externas
Estas son necesarias para ciertos flujos de descarga/extracción:
- `7z`/`7za` (p7zip) — se utiliza para extraer archivos `.7z`.
- `transmission-daemon` / `transmission-remote` — se utiliza para descargar torrents de Weakpass.
Comandos de instalación manual:
Ubuntu/Kali:
```bash
sudo apt-get update
sudo apt-get install -y p7zip-full transmission-daemon
```
macOS (Homebrew):
```bash
brew install p7zip transmission-cli # provides transmission-daemon and transmission-remote
```
Luego instala las dependencias de Python y el shim de CLI:
```bash
uv sync
mkdir -p ~/.local/bin
printf '#!/usr/bin/env bash\nset -euo pipefail\nexec uv run --directory %s python -m hate_crack "$@"\n' "$(pwd)" > ~/.local/bin/hate_crack
chmod +x ~/.local/bin/hate_crack
```
-------------------------------------------------------------------
## Estructura del proyecto
La lógica principal ahora está dividida en módulos bajo `hate_crack/`:
- `hate_crack/cli.py`: asistentes de argparse y anulaciones de configuración.
- `hate_crack/api.py`: integraciones con Hashview, Weakpass y Hashmob (descargas/menús/asistentes).
- `hate_crack/attacks.py`: manejadores de ataques del menú.
- `hate_crack/corpus_stats.py`: estadísticas de contraseñas de todo el corpus utilizadas para describir un corpus al LLM.
- `hate_crack/plaintext.py`: recupera la contraseña de una línea del corpus (eliminación del prefijo de hash, decodificación de `$HEX[...]`); compartido por los modos LLM, corpus_stats y rulegen.
- `hate_crack/llm.py`: generación estructurada (JSON) de candidatos LLM mediante Atomic Agents.
- `hate_crack/menu.py`: renderizador de menú compartido, incluida la navegación opcional con teclas de flecha.
- `hate_crack/noninteractive.py`: despachador de los subcomandos de ataque programados.
- `hate_crack/notify/`: paquete de notificaciones (backend Pushover, tailer por crack).
- `hate_crack/username_detect.py`: detecta archivos de entrada `username:hash` para decidir sobre `--username` de hashcat.
- `hate_crack/formatting.py`, `hate_crack/progress.py`: asistentes de formato de salida y visualización de progreso.
- `hate_crack/main.py`: implementación principal de la CLI.
El `hate_crack.py` de nivel superior sigue siendo el punto de entrada principal y orquesta estos módulos.
-------------------------------------------------------------------
## Referencias y agradecimientos
Este proyecto depende de y está inspirado en una serie de proyectos y servicios externos. Gracias a:
- Hashview (http://github.com/hashview/)
- Weakpass (https://weakpass.com)
- Hashmob (https://hashmob.net)
-------------------------------------------------------------------
## Uso
Después de instalar con `make`, ejecuta hate_crack desde cualquier lugar:
```bash
hate_crack
# or with arguments:
hate_crack <hash_file> <hash_type> [options]
```
Alternativamente, ejecútalo mediante `uv`:
```bash
uv run hate_crack.py <hash_file> <hash_type>
```
### Ejecutar como herramienta (recomendado)
Instalar usando `make` desde la raíz del repositorio - esto compila los submódulos y empaqueta los recursos:
```bash
cd /path/to/hate_crack
make
hate_crack
```
El comando `make install` crea un shim de bash en `~/.local/bin/hate_crack` que se ejecuta desde el directorio del repositorio, por lo que la configuración y los recursos siempre se encuentran independientemente de tu directorio de trabajo actual.
La configuración también se busca en:
- La raíz del repositorio y el directorio del paquete
- `~/.hate_crack`
**Nota:** El `hcatPath` en `config.json` es solo para la ubicación del binario de hashcat (opcional si hashcat está en el PATH). Los recursos de Hate_crack (hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks, omen) se cargan desde el directorio del repositorio y se incluyen automáticamente mediante `make install`.
### Ejecutar como script
El script usa un shebang de `uv`. Hazlo ejecutable y ejecuta:
```bash
chmod +x hate_crack.py
./hate_crack.py
```
También puedes usar Python directamente:
```bash
python hate_crack.py
```
### Uso no interactivo / automatizado
Para la automatización, puedes lanzar un único ataque directamente, omitiendo el menú. El nombre del ataque es el primer argumento, seguido del archivo de hashes y el tipo de hash de hashcat. Los avisos de preprocesamiento (filtrado de cuentas de equipo, fuerza bruta con LM primero, deduplicación de cuentas duplicadas) aceptan automáticamente sus valores predeterminados en este modo. El proceso sale con `0` en caso de éxito y con un valor distinto de cero en caso de error (archivo de hashes faltante, tipo de hash no numérico, lista de palabras faltante o un nombre de archivo de reglas desconocido).
```bash
# Quick crack: one wordlist + optional rule(s) from the rules directory
hate_crack quick hashes.txt 1000 --wordlist rockyou.txt --rules best64.rule
# Chain two rules in a single run
hate_crack quick hashes.txt 1000 --wordlist rockyou.txt --rules best64.rule+d3ad0ne.rule
# Run two rules as two separate passes
hate_crack quick hashes.txt 1000 --wordlist rockyou.txt --rules best64.rule d3ad0ne.rule
# Canned dictionary methodology (uses your configured wordlists)
hate_crack dict hashes.txt 1000
# Brute force lengths 1-8
hate_crack brute hashes.txt 1000 --min 1 --max 8
# Top-mask attack targeting ~4 hours
hate_crack topmask hashes.txt 1000 --target-time 4
```
La mayoría de los ataques del menú están disponibles de la misma manera. Estos no necesitan nada
más allá del archivo de hash y el tipo de hash:
```bash
hate_crack fingerprint hashes.txt 1000
hate_crack pathwell hashes.txt 1000
hate_crack prince hashes.txt 1000
hate_crack pcfg hashes.txt 1000
hate_crack princeling hashes.txt 1000
hate_crack smartmask hashes.txt 1000
hate_crack corporate hashes.txt 1000
hate_crack combinator hashes.txt 1000 # configured wordlists
hate_crack hybrid hashes.txt 1000 # configured wordlists
```
Cada uno también acepta la configuración que solicita su entrada de menú:
```bash
# Fingerprint, tuned: escalate to 24-character fragments and cap the keyspace
hate_crack fingerprint hashes.txt 1000 --max-expander-len 24 \
--run-hybrid-on-expanded --keyspace-limit 50000000000
# Skip the fragment/wordlist combination step entirely
hate_crack fingerprint hashes.txt 1000 --no-dictionary-wordlist
# Override the configured wordlists (combinator needs at least two).
# Two wordlists use combinator, three use combinator3, more -- or any
# --separator -- use combinatorX, matching what the menu does.
hate_crack combinator hashes.txt 1000 --wordlist first.txt second.txt
hate_crack combinator hashes.txt 1000 --wordlist a.txt b.txt c.txt
hate_crack combinator hashes.txt 1000 --wordlist a.txt b.txt --separator -
hate_crack hybrid hashes.txt 1000 --wordlist rockyou.txt
# Corporate masks, lengths 8-12 only
hate_crack corporate hashes.txt 1000 --min 8 --max 12
# Smart mask, skipping templates over 10 billion candidates
hate_crack smartmask hashes.txt 1000 --keyspace-limit 10000000000
```
El resto toma la única entrada que solicita su entrada de menú:
```bash
# Bandrel methodology (comma-separate multiple companies)
hate_crack bandrel hashes.txt 1000 --company "Acme,Acme Corp"
# Permutation attack over a short targeted wordlist
hate_crack permute hashes.txt 1000 --wordlist names.txt
# Ad-hoc mask -- a literal mask or a .hcmask file, optionally incrementing
hate_crack adhocmask hashes.txt 1000 --mask '?u?l?l?l?d?d'
hate_crack adhocmask hashes.txt 1000 --mask masks/corporate.hcmask
hate_crack adhocmask hashes.txt 1000 --mask '?a?a?a?a?a?a?a?a' \
--increment-min 4 --increment-max 8
hate_crack adhocmask hashes.txt 1000 --mask '?a?a?a?a' --increment
# N-gram candidates from a corpus
hate_crack ngram hashes.txt 1000 --corpus corpus.txt --group-size 3
# Combipow passphrases (wordlist capped at 63 lines: it generates 2^n-1)
hate_crack combipow hashes.txt 1000 --wordlist words.txt
hate_crack combipow hashes.txt 1000 --wordlist words.txt --no-spaces
# Spoonman: basewords and rules derived from a corpus of known passwords
hate_crack spoonman hashes.txt 1000 --corpus previous-engagement.txt
hate_crack spoonman hashes.txt 1000 --corpus previous.txt --rule-coverage 95
# --rule-coverage accepts 50, 75, 95 or 99 -- the only capped rule files
# derived. Omit it for the full rule set.
# OMEN -- requires a model trained beforehand from the interactive menu
hate_crack omen hashes.txt 1000 --max-candidates 1000000
# Loopback: re-run rules against the plaintexts already cracked
hate_crack loopback hashes.txt 1000 --rules best64.rule
```
`fingerprint` es el único comando cuya forma simple no es idéntica a su
entrada de menú: la opción 5 del menú siempre ejecuta las pasadas híbridas sobre fragmentos expandidos,
mientras que el subcomando usa por defecto el valor predeterminado de `hcatFingerprint`, que es desactivado. Pasa
`--run-hybrid-on-expanded` para que coincida con el menú.
Cinco entradas del menú siguen siendo solo interactivas, porque necesitan una entrada que un único
flag no puede transportar: fuerza bruta de Markov, Random Rules, el ataque Rosetta, el
ataque LLM y la metodología Extensive Pure_Hate (un orquestador sobre las
demás en lugar de un único ataque).
#### Códigos de salida
| Código | Significado |
|---|---|
| `0` | El ataque se ejecutó |
| `1` | Entrada incorrecta — falta el archivo de hash o la wordlist, tipo de hash no numérico, nombre de archivo de reglas desconocido, argumento fuera de rango |
| `2` | Subcomando desconocido — esta compilación de hate_crack no lo tiene |
| `3` | Solo con `--exit-code-on-skip`: la cobertura ya había visto todas las pasadas, así que no se lanzó nada |
La salida `2` y la salida `3` son lo que permite a un controlador scriptado distinguir "esta versión no puede
ejecutar ese ataque" y "era redundante" de "se ejecutó y no encontró nada".
`--exit-code-on-skip` es opcional para que habilitar la cobertura no empiece a
fallar en harnesses anteriores a ella.
-------------------------------------------------------------------
## Solución de problemas
### Error: "would clobber existing tag" al actualizar
Un clon antiguo puede negarse a actualizarse, imprimiendo una larga lista de líneas como:
```
! [rejected] v2.5.0 -> v2.5.0 (would clobber existing tag)
```
Esto afecta a los clones creados antes de julio de 2026. El historial publicado se reescribió
entonces para eliminar algunos archivos que nunca debieron haberse confirmado, lo que dio
a cada commit un nuevo ID; por lo tanto, las etiquetas de un clon más antiguo apuntan a objetos que este
repositorio ya no contiene, y git se niega a mover una etiqueta que ya tiene.
No hay nada malo con tu copia de trabajo y ningún dato de cracking está en riesgo.
Recupera con un restablecimiento único. Esto descarta los commits y ediciones locales en la
copia de trabajo, así que si has personalizado algo rastreado por git (a diferencia de
`config.json`, que no está rastreado), confírmalo primero en una rama:
```bash
cd /path/to/hate_crack
git fetch --tags --force origin
git checkout -B main origin/main
make install
```
`--force` aquí solo actualiza las etiquetas; no puede tocar tus commits. Después, el
actualizador integrado funciona con normalidad. Las versiones anteriores a la 2.18 no podían realizar esta
recuperación por sí mismas, por lo que hay que hacerlo manualmente una vez.
### Error: El directorio de compilación no existe
Si ves un error como:
```
Error: Build directory /opt/hashcat/hashcat-utils does not exist.
Expected to find expander at /opt/hashcat/hashcat-utils/bin/expander.
```
Esto significa que los recursos de hate_crack no se incluyeron en el paquete instalado.
**Entendiendo las rutas:**
- `hcatPath` en config.json → apunta a la **ubicación del binario de hashcat** (opcional, puede estar en PATH)
- `hashcat-utils/` y `princeprocessor/` → incluidos en el paquete por `make install`
**Solución:**
Reinstalar usando el Makefile, que compila los submódulos e instala la herramienta:
```bash
cd /path/to/hate_crack # the repository checkout
make install
```
**Configuración predeterminada (config.json.example):**
La mayoría de los usuarios pueden usar los valores predeterminados sin personalización:
- `hcatWordlists`: `./wordlists` (relativo a la raíz del repositorio o HOME/.hate_crack)
- `hcatOptimizedWordlists`: `./optimized_wordlists` (directorio usado por Quick Crack; recurre a `hcatWordlists` si no se encuentra)
- `rules_directory`: `./hashcat/rules` (incluye reglas del submódulo)
- `hcatTuning`: `` (cadena vacía - sin flags de ajuste predeterminados)
**Ejemplos de personalizaciones de config.json:**
```json
{
"hcatPath": "/usr/local/bin", # Location of hashcat binary (optional, auto-detected from PATH)
"hcatBin": "hashcat", # Hashcat binary name
"hcatWordlists": "./wordlists", # Dictionary wordlist directory (relative or absolute)
"rules_directory": "./hashcat/rules", # Rules directory (relative or absolute)
"hcatTuning": "", # Additional hashcat flags (empty by default)
...
}
```
**Carga de configuración:**
- Precedencia para cada clave: `os.environ` > el propio archivo de inicio de esa clave (`.env` o `config.json`) > valor predeterminado integrado
- Las claves faltantes recurren a los valores predeterminados integrados; `config.json.example` documenta cada clave de `config.json`
- Ambos archivos se buscan, de forma independiente entre sí, en este orden: **raíz del repositorio**, luego el **directorio del paquete instalado**, luego **`~/.hate_crack`**. Gana la primera coincidencia; es normal que los dos archivos provengan de directorios diferentes.
- En la primera ejecución, se crean ambos: `config.json` a partir de `config.json.example`, `.env` a partir de los valores predeterminados integrados. Si un `config.json` más antiguo todavía contiene claves de integración, se copian al nuevo `.env` y hate_crack te indica cuáles eliminar de `config.json`; nunca edita ese archivo por sí mismo.
- En cada ejecución, hate_crack imprime los dos archivos que realmente cargó:
```
[*] config.json: /home/you/.hate_crack/config.json
[*] .env: /home/you/.hate_crack/.env
```
Lee esas dos líneas antes de depurar una configuración que "no surte efecto". Existen debido a dos trampas en el orden de búsqueda:
- **Un checkout tiene prioridad sobre tu directorio home.** La raíz del repositorio se busca primero, por lo que un `.env` o `config.json` que esté en *cualquier* checkout desde el que ejecutes la herramienta gana sobre el que está en `~/.hate_crack` — y ejecutar la herramienta desde un checkout es exactamente lo que crea esos archivos allí en primer lugar. Si esto llega a ocultar una configuración real de `~/.hate_crack`, hate_crack ahora lo indica con una tercera línea `[!]` que nombra ambas rutas — trata esa línea como "el archivo de abajo se está ignorando", no como una segunda configuración igualmente válida.
- **El directorio de trabajo actual nunca se busca.** Un `.env` en el directorio en el que estés se ignora, deliberadamente: los directorios de engagement están llenos de archivos que nadie pretendía que fueran configuración. Ponlo en la raíz del repositorio o en `~/.hate_crack`.
### Error: merge with ref 'refs/heads/master' but no such ref was fetched
Si ves:
```
Your configuration specifies to merge with the ref 'refs/heads/master'
from the remote, but no such ref was fetched.
```
La rama predeterminada se renombró de `master` a `main`. Corrígelo con:
```bash
git remote set-head origin -a
git branch -m master main
git branch --set-upstream-to=origin/main main
git pull
```
-------------------------------------------------------------------
### Objetivos del Makefile
**Predeterminado (instalación completa)** - compila los submódulos, instala las dependencias e instala la herramienta:
```bash
make
# or explicitly:
make install
```
Esto es idempotente: omite las herramientas ya instaladas.
**Forzar reinstalación limpia:**
```bash
make reinstall
```
**Actualización rápida** - reconstruye los submódulos y reinstala la herramienta (después de obtener los cambios):
```bash
make update
```
**Desinstalar** - elimina las dependencias del sistema operativo y la herramienta:
```bash
make uninstall
```
**Compilar solo hashcat-utils:**
```bash
make hashcat-utils
```
**Ejecutar pruebas** - maneja automáticamente HATE_CRACK_SKIP_INIT cuando es necesario:
```bash
make test
```
**Informe de cobertura:**
```bash
make coverage
```
**Limpiar artefactos de compilación/pruebas:**
```bash
make clean
```
## Desarrollo
### Configuración del entorno de desarrollo
Instala el proyecto con las dependencias de desarrollo opcionales (incluye linters y herramientas de testing):
```bash
make dev-install
```
### Ejecución de linters y comprobaciones de tipos
Antes de subir cambios, ejecuta estas comprobaciones localmente. Usa `make lint` para todo, o ejecuta comprobaciones individuales:
**Ruff (linting y formateo):**
```bash
make ruff
# or manually:
uv run ruff check hate_crack tests tools packaging hate_crack.py
```
Corregir problemas automáticamente:
```bash
uv run ruff format hate_crack tests tools packaging hate_crack.py
uv run ruff check --fix hate_crack tests tools packaging hate_crack.py
```
**ty (verificación de tipos):**
```bash
make ty
# or manually:
uv run ty check hate_crack
```
**Ejecutar todas las comprobaciones juntas:**
```bash
make lint
```
### Ejecución de pruebas
Las pruebas detectan automáticamente cuando los submódulos no están compilados y establecen `HATE_CRACK_SKIP_INIT=1` de forma automática.
```bash
make test
```
O ejecutar pytest directamente:
```bash
uv run pytest -v
```
Con cobertura:
```bash
make coverage
```
O con pytest:
```bash
uv run pytest --cov=hate_crack
```
### Git Hooks (prek)
Los Git hooks se gestionan con [prek](https://github.com/j178/prek) (v0.3.3+). Instala los hooks con:
```bash
prek install --hook-type pre-push --hook-type pre-commit
```
Esto instala los hooks definidos en `prek.toml` usando el esquema TOML de repositorio local de pre-commit:
- **pre-push** (hooks locales): ruff, ruff-format, ty, pytest, pytest-lima, bandit
- **pre-commit** (desde `pre-commit/pre-commit-hooks`): trailing-whitespace,
end-of-file-fixer, check-yaml, check-merge-conflict, check-added-large-files,
detect-private-key
Los autocorrectores de pre-commit reescriben los archivos en su lugar, así que vuelve a preparar y confirma de nuevo después de que se ejecuten.
Nota: prek 0.3.3 espera `repos = [...]` en el nivel superior. El formato antiguo `[hooks.<stage>] commands = [...]` no es compatible.
### Navegación de menús con teclas de flecha
Los menús usan por defecto la selección clásica numerada con `print()` + `input()`, que acepta claves completas de varios dígitos.
Para habilitar la navegación con teclas de flecha mediante `simple-term-menu`, establece
`HATE_CRACK_ARROW_MENU=1`. En ese modo puedes moverte con las teclas de flecha o escribir el número de opción (incluidos los de varios dígitos como `99`) y pulsar Enter. Escribir cualquier otra cosa filtra la lista. El modo de teclas de flecha también requiere una TTY, por lo que permanece desactivado cuando la salida se canaliza.
Los selectores que imprimen una lista y luego aceptan entrada escrita (wordlists, reglas, la lista de Weakpass, el wordlist y los IDs de reglas de Hashview) aceptan Arriba/Abajo en todos los backends, sin `HATE_CRACK_ARROW_MENU`. Arriba rellena la última clave listada, Arriba de nuevo la anterior, Abajo retrocede; también puedes escribir un número, una ruta o una lista como `1,3`. Una `,`, `+` o `-` escrita justo después de una clave rellenada con flecha la extiende. En los backends `plain` y `rich` esto funciona cargando las claves listadas en el historial de readline para ese prompt concreto, por lo que tu propio historial se restaura después y no es accesible desde dentro de un prompt de lista.
### Dependencias de desarrollo
El grupo opcional `[dev]` incluye:
- **ty** - Comprobador de tipos estático
- **ruff** - Linter y formateador rápido de Python
- **pytest** - Framework de pruebas
- **pytest-cov** - Informes de cobertura
-------------------------------------------------------------------
Opciones comunes:
- `--download-hashview`: Descarga hashes desde Hashview antes de crackear.
- `--hashview`: Menú interactivo de Hashview para gestionar hashes, wordlists y trabajos.
- `--hashview --help`: Muestra las opciones de línea de comandos de Hashview.
- `--weakpass`: Descarga wordlists desde Weakpass.
- `--rank`: Solo muestra wordlists de Weakpass con un nivel específico (0=todos, -1=niveles S/A/B). Rangos: 7=S, 6=A, 5=B, 4=C, 3=D, 2=E, 1=F.
- `--hashmob`: Descarga wordlists desde Hashmob.net.
- `--hashmob-masks`: Descarga máscaras desde Hashmob.net.
- `--download-torrent <FILENAME>`: Descarga un archivo torrent específico de Weakpass.
- `--download-all-torrents`: Descarga todos los torrents de Weakpass disponibles desde la caché.
- `--wordlists-dir <PATH>` / `--optimized-wordlists-dir <PATH>`: Sobrescribe los directorios de wordlists.
- `--pipal-path <PATH>`: Sobrescribe la ruta de pipal.
- `--restore-potfile`: Reconstruye `<hashfile>.out` desde el archivo POT de hashcat al inicio, reemplazando cualquier contenido existente, y luego continúa al menú normal. Sin este flag, la búsqueda en el POT solo se ejecuta cuando `.out` no existe todavía. La opción 93 del menú hace lo mismo bajo demanda, con un prompt de confirmación.
- `--maxruntime <SECONDS>`: Sobrescribe el tiempo máximo de ejecución.
- `--bandrel-basewords <PATH>`: Sobrescribe el archivo de palabras base de bandrel.
- `--update`: Actualiza a la última versión y reinstala. Cambia el checkout a `main` si está en otra rama, ya que las etiquetas de versión viven ahí.
- `--nightly`: Actualiza a la última nightly en su lugar, desde la rama `nightly-dev`. Las nightlies han pasado CI pero no forman parte de una versión publicada. También se puede escribir `--update --nightly`.
- `--no-optimized-kernel` (o `--no-optimize`): Nunca pasa `-O` a hashcat durante toda la ejecución. Sobrescribe `optimizedKernelAttacks` en `config.json` y elimina cualquier `-O` que hayas puesto en `hcatTuning`. No se escribe nada de vuelta en la configuración, por lo que se aplica solo a esta ejecución. Con un subcomando, colócalo antes del subcomando: `./hate_crack.py --no-optimize quick hashes.txt 1000 --wordlist words.txt`.
- `--debug`: Habilita el registro de depuración (escribe en stderr).
### Integración con Hashview
hate_crack se integra con Hashview para la gestión centralizada de hashes y el cracking distribuido.
#### Menú interactivo
Accede al menú interactivo de Hashview:
```bash
hate_crack.py --hashview
```
Opciones del menú:
- **(1) Upload Cracked Hashes** - Subir los resultados descifrados de la sesión actual a Hashview
- **(2) Upload Wordlist** - Subir un archivo de wordlist a Hashview
- **(3) Download Wordlist** - Descargar un wordlist desde Hashview
- **Download Rule** - Descargar un archivo de reglas desde Hashview (descomprimido a texto plano, listo para `hashcat -r`). Introduce `a` (o `all`) en el prompt del ID de regla para descargar todas las reglas listadas en lugar de una sola
- **Download All Rules** - Descargar todos los archivos de reglas listados por Hashview en una sola pasada; los fallos por regla se reportan sin abortar el resto
- **(4) Download Left Hashes** - Descargar los hashes restantes sin descifrar (solicita cambiar para descifrarlos)
- **(5) Download Found Hashes** - Descargar los hashes ya descifrados con contraseñas en texto claro (para referencia/análisis)
- **(6) Upload Hashfile and Create Job** - Subir un nuevo archivo de hashes y crear un trabajo de descifrado
- **(99) Back to Main Menu** - Volver al menú principal
**Importante: Download Found vs Download Left**
- **Download Left Hashes (4)**: Descarga los hashes sin descifrar que necesitan ser descifrados. Se fusiona automáticamente con cualquier hash encontrado si está disponible, y solicita cambiar a este archivo de hashes para descifrarlos.
- **Download Found Hashes (5)**: Descarga los hashes ya descifrados en formato hash:cleartext. Estos son para referencia y no se pueden descifrar más. No se muestra ningún prompt de cambio.
#### Interfaz de línea de comandos
Las operaciones de Hashview también se pueden realizar mediante línea de comandos:
Subir hashes descifrados:
```bash
hate_crack.py --hashview upload-cracked --file <output_file>.out --hash-type 1000
```
Sube una lista de palabras:
```bash
hate_crack.py --hashview upload-wordlist --file <wordlist>.txt --name "My Wordlist"
```
Descargue un archivo de reglas (guardado descomprimido, listo para `hashcat -r`):
```bash
hate_crack.py --hashview download-rules --rules-id 4 --output best64.rule
```
Descargar hashes restantes (hashes sin descifrar para descifrar):
```bash
hate_crack.py --hashview download-left --customer-id 1 --hashfile-id 123
```
Descargar hashes encontrados (hashes ya descifrados con texto claro):
```bash
hate_crack.py --hashview download-found --customer-id 1 --hashfile-id 123
```
Subir archivo hash y crear trabajo:
```bash
hate_crack.py --hashview upload-hashfile-job --file hashes.txt --customer-id 1 \
--hash-type 1000 --job-name "NTLM Crack Job" --hashfile-name "Domain Hashes"
```
#### Configuración
Establezca las credenciales de Hashview en `.env` (son ajustes de integración, por lo que no residen en `config.json`):
```
HASHVIEW_URL=https://hashview.example.com
HASHVIEW_API_KEY=your-api-key-here
HASHVIEW_VERIFY_TLS=true
```
`HASHVIEW_VERIFY_TLS` tiene como valor predeterminado `true`: hate_crack verifica el certificado TLS del servidor de Hashview, y la conexión a un Hashview con un certificado autofirmado o de una CA interna fallará hasta que ese certificado sea de confianza (agrégalo a tu almacén de confianza del sistema, o usa un certificado emitido por una CA en la que tu sistema ya confíe). Si eso no es posible, establece `HASHVIEW_VERIFY_TLS=false` -- hate_crack imprimirá una advertencia de una línea nombrando el host en cada inicio de proceso cuando la verificación esté desactivada, ya que desactivarla elimina la protección contra un servidor suplantado o un atacante en la ruta que intercepte la conexión.
#### Configuración del LLM
El Ataque LLM (opción 12) y el Ataque de Máscara Rosetta (opción 23) generan sus candidatos con un modelo local. Configura el modelo, la ventana de contexto y el tiempo de espera de solicitud en `.env`:
```
LLM_BACKEND=ollama
OLLAMA_MODEL=qwen3:4b-instruct
OLLAMA_NUM_CTX=8192
OLLAMA_TIMEOUT=300
```
**Las claves `OLLAMA_*` a continuación se aplican a todos los backends, no solo a Ollama.** Conservan ese prefijo porque `OLLAMA_HOST` es la misma variable que lee la propia CLI de Ollama, y renombrarlas rompería todos los `.env` existentes sin ninguna ganancia funcional — un servidor compatible con vLLM u OpenAI quiere el mismo host, modelo, timeout, contexto y parámetros de muestreo bajo los mismos nombres. `LLM_BACKEND` solo selecciona cómo se da forma a la solicitud.
---
[Read more](https://github.com/trustedsec/hate_crack)