hate_crack v2.14.3

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

Installation

L'installation depuis les sources est la seule voie prise en charge. hate_crack n'est pas distribué sur PyPI : pip install hate-crack renvoie vers un placeholder 0.0.0 qui échoue volontairement et redirige ici. Le nom est réservé uniquement pour que personne d'autre ne puisse publier un homonyme sous celui-ci — voir packaging/pypi-placeholder/.

1. Installer hashcat

Hashcat doit être installé et disponible dans votre PATH :

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

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

Ou téléchargez un binaire précompilé depuis https://hashcat.net/hashcat/ et définissez hcatPath dans config.json vers son emplacement.

2. Télécharger hate_crack

Clonez avec les sous-modules (requis pour hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks, et éventuellement omen) :```bash git clone --recurse-submodules https://github.com/trustedsec/hate_crack.git cd hate_crack

Si vous avez cloné sans les sous-modules, initialisez-les :```bash
git submodule update --init --recursive

Ensuite, personnalisez la configuration si nécessaire. hate_crack utilise deux fichiers de configuration, chacun possédant un ensemble distinct de paramètres :

config.json — chemins des wordlists, masques, règles, réglages, potfile, chemin hashcat, limites de candidats, bascules de notification, préférences par défaut de la CLI (35 paramètres).
.env — paramètres d'intégration tiers uniquement : identifiants Hashview et Hashmob, identifiants Pushover, Ollama et pipal (14 paramètres). Non suivi par git, créé avec le mode 0600.

La séparation se fait à cet endroit pour une raison : .env est le fichier susceptible de contenir des secrets. Les identifiants et la configuration des services tiers vont dans le fichier non suivi en 0600 ; tout ce que hate_crack fait localement reste dans config.json, qui peut être partagé, comparé et consigné dans vos propres notes sans risque. C'est aussi pourquoi les identifiants Pushover sont dans .env tandis que les bascules d'activation/désactivation de Pushover sont dans config.json — les bascules sont des préférences locales, pas des secrets.

Chaque clé a exactement un emplacement. Une clé placée dans l'autre fichier est ignorée, et hate_crack affiche un avertissement nommant le fichier auquel elle appartient. N'importe quelle clé peut toujours être remplacée pour une seule exécution en exportant sa variable d'environnement. La plupart des utilisateurs peuvent ignorer cette étape car les chemins par défaut fonctionnent immédiatement.

config.json est permanent et de premier ordre — il n'est pas obsolète et aucune date de suppression n'est prévue. Seuls les paramètres d'intégration ont été déplacés.

Vous migrez depuis un seul config.json ? hate_crack le migre pour vous au premier lancement : les paramètres d'intégration sont copiés dans un nouveau .env en 0600, puis supprimés de config.json afin que les deux fichiers ne les revendiquent pas tous les deux. Il indique quelles clés ont été déplacées (jamais leurs valeurs) et sauvegarde votre original sous config.json.pre-split.bak avant d'y toucher. Tout le reste dans config.json est laissé exactement tel quel, ordre des clés inclus.

Premier lancement : hate_crack crée les deux fichiers pour vous, il n'y a donc rien à faire. Pour configurer .env manuellement à la place, copiez le modèle suivi :```bash cp .env.example .env chmod 600 .env

`.env.example` est versionné et est livré avec chaque clé d'identification vide. `.env` lui-même ne doit **jamais** être versionné — il est ignoré par git, tout comme ses orthographes de sauvegarde habituelles, et hate_crack le crée toujours avec le mode `0600` (lecture/écriture propriétaire uniquement). `.env.example` est généré à partir du schéma ; régénérez-le après avoir modifié `hate_crack/config_schema.py` avec `uv run python -m hate_crack.config_writer`.

### 3. Installer les dépendances et hate_crack

La méthode la plus simple consiste à exécuter `make` (ou `make install`), qui détecte automatiquement votre OS et installe :
- Les dépendances externes (p7zip, transmission-daemon / transmission-remote)
- Compile les sous-modules (hashcat-utils, princeprocessor, pcfg_cracker, et éventuellement omen) et récupère l'ensemble de masques Corporate_Masks (données uniquement)
- Les dépendances Python via uv et un shim CLI à `~/.local/bin/hate_crack````bash
make

Ceci est idempotent - cela ignore les outils déjà installés. Pour forcer une réinstallation propre :```bash make reinstall

**Ou installez les dépendances manuellement :**

### Dépendances externes
Celles-ci sont requises pour certains flux de téléchargement/extraction :

- `7z`/`7za` (p7zip) — utilisé pour extraire les archives `.7z`.
- `transmission-daemon` / `transmission-remote` — utilisé pour télécharger les torrents Weakpass.

Commandes d'installation manuelle :

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

Installez ensuite les dépendances Python et le 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

Structure du projet

La logique principale est désormais répartie en modules sous hate_crack/ :

hate_crack/cli.py : assistants argparse et substitutions de configuration.
hate_crack/api.py : intégrations Hashview, Weakpass et Hashmob (téléchargements/menus/assistants).
hate_crack/attacks.py : gestionnaires d'attaques du menu.
hate_crack/corpus_stats.py : statistiques de mots de passe sur l'ensemble du corpus utilisées pour décrire un corpus au LLM.
hate_crack/plaintext.py : récupère le mot de passe à partir d'une ligne de corpus (suppression du préfixe de hash, décodage $HEX[...]) ; partagé par les modes LLM, corpus_stats et rulegen.
hate_crack/llm.py : génération structurée (JSON) de candidats par LLM via Atomic Agents.
hate_crack/menu.py : moteur de rendu de menu partagé, incluant la navigation optionnelle par touches fléchées.
hate_crack/noninteractive.py : répartiteur pour les sous-commandes d'attaque scriptées.
hate_crack/notify/ : paquet de notification (backend Pushover, tailer par crack).
hate_crack/username_detect.py : détecte les fichiers d'entrée username:hash pour décider de l'option --username de hashcat.
hate_crack/formatting.py, hate_crack/progress.py : assistants de formatage de sortie et d'affichage de progression.
hate_crack/main.py : implémentation principale de la CLI.

Le fichier hate_crack.py à la racine reste le point d'entrée principal et orchestre ces modules.

Références et remerciements

Ce projet dépend de et s'inspire de plusieurs projets et services externes. Merci à :