hate_crack v2.36.1 — A tool for automating cracking methodologies through Hashcat from the TrustedSec team.

  ___ ___         __             _________                       __
 /   |   \_____ _/  |_  ____     \_   ___ \____________    ____ |  | __
/    ~    \__  \\   __\/ __ \    /    \  \/\_  __ \__  \ _/ ___\|  |/ /
\    Y    // __ \|  | \  ___/    \     \____|  | \// __ \\  \___|    <
 \___|_  /(____  /__|  \___  >____\______  /|__|  (____  /\___  >__|_ \
       \/      \/          \/_____/      \/            \/     \/     \/

Instalação

Instalar a partir do código-fonte é o único caminho suportado. hate_crack não é distribuído no PyPI: pip install hate-crack resolve para um placeholder 0.0.0 que falha de propósito e aponta de volta para aqui. O nome é mantido apenas para que ninguém mais possa publicar um sósia sob ele — veja packaging/pypi-placeholder/.

1. Instalar o hashcat

O Hashcat deve estar instalado e disponível no seu PATH:

Ubuntu/Kali:

sudo apt-get install -y hashcat

macOS (Homebrew):

brew install hashcat

Ou baixe um binário pré-compilado de https://hashcat.net/hashcat/ e defina hcatPath em config.json para o seu local.

2. Baixar o hate_crack

Clone com submódulos (necessário para hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks e, opcionalmente, omen):

git clone --recurse-submodules https://github.com/trustedsec/hate_crack.git
cd hate_crack

Se você clonou sem submódulos, inicialize-os:

git submodule update --init --recursive

Em seguida, personalize a configuração se necessário. O hate_crack usa dois arquivos de configuração, cada um com um conjunto distinto de definições:

config.json — caminhos de wordlist, máscaras, regras, ajustes, potfile, caminho do hashcat, limites de candidatos, alternâncias de notificação, padrões de preferência da CLI (35 definições).
.env — apenas definições de integração com terceiros: credenciais do Hashview e Hashmob, credenciais do Pushover, Ollama e pipal (14 definições). Não rastreado pelo git, criado com modo 0600.

A linha fica aí por uma razão: .env é o arquivo que pode conter segredos. As credenciais para, e a configuração de, serviços de terceiros vão para o arquivo não rastreado, com modo 0600; tudo o que o hate_crack faz localmente fica em config.json, que é seguro para compartilhar, comparar e guardar nas suas próprias notas. É também por isso que as credenciais do Pushover estão em .env enquanto as alternâncias de ligar/desligar do Pushover estão em config.json — as alternâncias são preferências locais, não segredos.

Cada chave tem exatamente um lar. Uma chave colocada no outro arquivo é ignorada, e o hate_crack imprime um aviso indicando o arquivo a que pertence. Qualquer chave pode ainda ser substituída para uma única execução exportando a sua variável de ambiente. A maioria dos utilizadores pode saltar este passo, pois os caminhos predefinidos funcionam de imediato.

config.json é permanente e de primeira classe — não está obsoleto e não há prazo de remoção para ele. Apenas as definições de integração foram movidas.

A atualizar a partir de um único config.json? O hate_crack migra-o por si na primeira execução: as definições de integração são copiadas para um novo .env com modo 0600, depois removidas de config.json para que os dois arquivos não as reivindiquem ambos. Imprime quais as chaves que foram movidas (nunca os seus valores) e guarda o seu original como config.json.pre-split.bak antes de o tocar. Tudo o resto em config.json é deixado exatamente como estava, incluindo a ordem das chaves.

Primeira execução: o hate_crack cria ambos os arquivos por si, por isso não há nada a fazer. Para configurar .env manualmente, copie o modelo rastreado:

cp .env.example .env
chmod 600 .env

.env.example é versionado e é distribuído com todas as chaves de credenciais vazias. O próprio .env nunca deve ser versionado — está no gitignore, juntamente com as suas habituais variantes de backup, e o hate_crack cria-o sempre com o modo 0600 (apenas leitura/escrita pelo proprietário). O .env.example é gerado a partir do schema; regenere-o após alterar hate_crack/config_schema.py com uv run python -m hate_crack.config_writer.

3. Instalar dependências e o hate_crack

A forma mais fácil é executar make (ou make install), que deteta automaticamente o seu SO e instala:

Dependências externas (p7zip, transmission-daemon / transmission-remote)
Compila os submódulos (hashcat-utils, princeprocessor, pcfg_cracker e, opcionalmente, omen) e faz checkout do conjunto de máscaras Corporate_Masks apenas com dados
Dependências Python via uv e um shim de CLI em ~/.local/bin/hate_crack

make

Isso é idempotente - ele ignora ferramentas já instaladas. Para forçar uma reinstalação limpa:

make reinstall

Ou instale as dependências manualmente:

Dependências Externas

Estas são necessárias para certos fluxos de download/extração:

7z/7za (p7zip) — usado para extrair arquivos .7z.
transmission-daemon / transmission-remote — usado para baixar torrents do Weakpass.

Comandos de instalação manual:

Ubuntu/Kali:

sudo apt-get update
sudo apt-get install -y p7zip-full transmission-daemon

macOS (Homebrew):

brew install p7zip transmission-cli  # provides transmission-daemon and transmission-remote

Em seguida, instale as dependências Python e o shim de CLI:

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

Estrutura do Projeto

A lógica principal agora está dividida em módulos sob hate_crack/:

hate_crack/cli.py: auxiliares de argparse e substituições de configuração.
hate_crack/api.py: integrações com Hashview, Weakpass e Hashmob (downloads/menus/auxiliares).
hate_crack/attacks.py: manipuladores de ataques do menu.
hate_crack/corpus_stats.py: estatísticas de senhas de todo o corpus usadas para descrever um corpus ao LLM.
hate_crack/plaintext.py: recupera a senha de uma linha do corpus (remoção de prefixo de hash, decodificação $HEX[...]); compartilhado pelos modos LLM, corpus_stats e rulegen.
hate_crack/llm.py: geração estruturada (JSON) de candidatos por LLM via Atomic Agents.
hate_crack/menu.py: renderizador de menu compartilhado, incluindo navegação opcional por teclas de seta.
hate_crack/noninteractive.py: despachante para os subcomandos de ataque scriptados.
hate_crack/notify/: pacote de notificações (backend Pushover, tailer por crack).
hate_crack/username_detect.py: detecta arquivos de entrada username:hash para decidir sobre o --username do hashcat.
hate_crack/formatting.py, hate_crack/progress.py: auxiliares de formatação de saída e exibição de progresso.
hate_crack/main.py: implementação principal da CLI.

O hate_crack.py de nível superior permanece como ponto de entrada principal e orquestra esses módulos.

Referências e Agradecimentos

Este projeto depende e é inspirado por vários projetos e serviços externos. Agradecimentos a:

Uso

Após instalar com make, execute o hate_crack de qualquer lugar:

hate_crack
# or with arguments:
hate_crack <hash_file> <hash_type> [options]

Como alternativa, execute via uv:

uv run hate_crack.py <hash_file> <hash_type>

Executar como ferramenta (recomendado)

Instale usando make a partir da raiz do repositório - isso compila submódulos e empacota os recursos: