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

Instalação

A instalação a partir do código-fonte é o único caminho suportado. O 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 — consulte packaging/pypi-placeholder/.

1. Instalar o hashcat

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

Ubuntu/Kali:```bash sudo apt-get install -y hashcat

macOS (Homebrew):```bash
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):```bash git clone --recurse-submodules https://github.com/trustedsec/hate_crack.git cd hate_crack

Se você clonou sem submódulos, inicialize-os:```bash
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 do Hashmob, credenciais do Pushover, Ollama e pipal (14 definições). Não é rastreado pelo git, criado com modo 0600.

A linha divisória está aí por uma razão: .env é o arquivo que pode conter segredos. As credenciais para serviços de terceiros, e a configuração dos mesmos, ficam no arquivo não rastreado, com modo 0600; tudo o que o hate_crack faz localmente permanece em config.json, que é seguro para partilhar, 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 único lugar. 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, e depois removidas de config.json para que os dois arquivos não as reivindiquem ambos. Imprime quais chaves 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:```bash cp .env.example .env chmod 600 .env

`.env.example` é versionado e é entregue 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````bash
make

Isto é idempotente - ignora ferramentas já instaladas. Para forçar uma reinstalação limpa:```bash 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:```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

Em seguida, instale as dependências Python e o 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

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: dispatcher 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:```bash hate_crack

or with arguments:

hate_crack <hash_file> <hash_type> [options]

Como alternativa, execute via `uv`:```bash
uv run hate_crack.py <hash_file> <hash_type>

hate_crack v2.14.3