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

Installazione

L'installazione da sorgente è l'unico percorso supportato. hate_crack non è distribuito su PyPI: pip install hate-crack punta a un placeholder 0.0.0 che fallisce di proposito e rimanda qui. Il nome è riservato solo per evitare che qualcun altro possa pubblicare un clone sotto di esso — vedi packaging/pypi-placeholder/.

1. Installare hashcat

Hashcat deve essere installato e disponibile nel tuo PATH:

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

macOS (Homebrew):```bash
brew install hashcat

Oppure scarica un binario precompilato da https://hashcat.net/hashcat/ e imposta hcatPath in config.json alla sua posizione.

2. Scarica hate_crack

Clona con i sottomoduli (richiesto per hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks e opzionalmente omen):```bash git clone --recurse-submodules https://github.com/trustedsec/hate_crack.git cd hate_crack

Se hai clonato senza i sottomoduli, inizializzali:```bash
git submodule update --init --recursive

Poi personalizza la configurazione se necessario. hate_crack utilizza due file di configurazione, ognuno dei quali possiede un insieme distinto di impostazioni:

config.json — percorsi delle wordlist, maschere, regole, tuning, potfile, percorso di hashcat, limiti dei candidati, toggle delle notifiche, preferenze predefinite della CLI (35 impostazioni).
.env — solo impostazioni di integrazione di terze parti: credenziali Hashview e Hashmob, credenziali Pushover, Ollama e pipal (14 impostazioni). Non tracciato da git, creato con modalità 0600.

La linea di demarcazione è lì per un motivo: .env è il file che può contenere segreti. Le credenziali per i servizi di terze parti, e la loro configurazione, vanno nel file non tracciato con permessi 0600; tutto ciò che hate_crack fa localmente rimane in config.json, che è sicuro da condividere, confrontare con diff e inserire nelle tue note. È anche per questo che le credenziali Pushover sono in .env mentre i toggle di attivazione/disattivazione di Pushover sono in config.json — i toggle sono preferenze locali, non segreti.

Ogni chiave ha esattamente una collocazione. Una chiave inserita nell'altro file viene ignorata, e hate_crack stampa un avviso indicando il file a cui appartiene. Qualsiasi chiave può comunque essere sovrascritta per una singola esecuzione esportando la sua variabile d'ambiente. La maggior parte degli utenti può saltare questo passaggio poiché i percorsi predefiniti funzionano out-of-the-box.

config.json è permanente e di prima classe — non è deprecato e non esiste una tempistica di rimozione per esso. Solo le impostazioni di integrazione sono state spostate.

Stai aggiornando da un singolo config.json? hate_crack lo migra automaticamente alla prima esecuzione: le impostazioni di integrazione vengono copiate in un nuovo .env con permessi 0600, poi rimosse da config.json in modo che i due file non le rivendichino entrambi. Stampa quali chiavi sono state spostate (mai i loro valori) e salva l'originale come config.json.pre-split.bak prima di modificarlo. Tutto il resto in config.json viene lasciato esattamente com'era, incluso l'ordine delle chiavi.

Prima esecuzione: hate_crack crea entrambi i file per te, quindi non c'è nulla da fare. Per configurare .env manualmente, invece, copia il template tracciato:```bash cp .env.example .env chmod 600 .env

`.env.example` è committato e viene distribuito con ogni chiave di credenziale vuota. `.env` stesso non deve **mai** essere committato — è gitignorato, insieme alle sue solite varianti di backup, e hate_crack lo crea sempre con modalità `0600` (solo lettura/scrittura per il proprietario). `.env.example` è generato dallo schema; rigeneralo dopo aver modificato `hate_crack/config_schema.py` con `uv run python -m hate_crack.config_writer`.

### 3. Installa le dipendenze e hate_crack

Il modo più semplice è eseguire `make` (o `make install`), che rileva automaticamente il tuo sistema operativo e installa:
- Dipendenze esterne (p7zip, transmission-daemon / transmission-remote)
- Compila i sottomoduli (hashcat-utils, princeprocessor, pcfg_cracker e opzionalmente omen) e fa il checkout del set di maschere Corporate_Masks di soli dati
- Dipendenze Python tramite uv e uno shim CLI in `~/.local/bin/hate_crack````bash
make

Questo è idempotente - salta gli strumenti già installati. Per forzare una reinstallazione pulita:```bash make reinstall

**Oppure installa manualmente le dipendenze:**

### Dipendenze esterne
Queste sono necessarie per alcuni flussi di download/estrazione:

- `7z`/`7za` (p7zip) — utilizzato per estrarre archivi `.7z`.
- `transmission-daemon` / `transmission-remote` — utilizzato per scaricare i torrent Weakpass.

Comandi di installazione manuale:

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

Poi installa le dipendenze Python e lo shim 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

Struttura del progetto

La logica principale è ora suddivisa in moduli sotto hate_crack/:

hate_crack/cli.py: helper argparse e override della configurazione.
hate_crack/api.py: integrazioni Hashview, Weakpass e Hashmob (download/menu/helper).
hate_crack/attacks.py: gestori degli attacchi da menu.
hate_crack/corpus_stats.py: statistiche sulle password dell'intero corpus utilizzate per descrivere un corpus all'LLM.
hate_crack/plaintext.py: recupera la password da una riga del corpus (rimozione del prefisso hash, decodifica $HEX[...]); condiviso dalle modalità LLM, corpus_stats e rulegen.
hate_crack/llm.py: generazione strutturata (JSON) di candidati LLM tramite Atomic Agents.
hate_crack/menu.py: renderer di menu condiviso, inclusa la navigazione opzionale con i tasti freccia.
hate_crack/noninteractive.py: dispatcher per i sottocomandi di attacco scriptati.
hate_crack/notify/: pacchetto di notifiche (backend Pushover, tailer per singolo crack).
hate_crack/username_detect.py: rileva i file di input username:hash per decidere l'uso di --username di hashcat.
hate_crack/formatting.py, hate_crack/progress.py: helper per la formattazione dell'output e la visualizzazione del progresso.
hate_crack/main.py: implementazione principale della CLI.

Il file di primo livello hate_crack.py rimane il punto di ingresso principale e orchestra questi moduli.

Riferimenti e ringraziamenti

Questo progetto dipende da e si ispira a numerosi progetti e servizi esterni. Grazie a:

Utilizzo

Dopo l'installazione con make, esegui hate_crack da qualsiasi posizione:```bash hate_crack

or with arguments:

hate_crack <hash_file> <hash_type> [options]

In alternativa, esegui tramite `uv`:```bash
uv run hate_crack.py <hash_file> <hash_type>

hate_crack v2.23.0