hate_crack

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

## Installation

Die Installation aus dem Quellcode ist der einzige unterstützte Weg. hate_crack wird **nicht**
auf PyPI verteilt: `pip install hate-crack` verweist auf einen `0.0.0`-Platzhalter,
der absichtlich fehlschlägt und hierher zurückverweist. Der Name wird nur reserviert, damit niemand sonst
ein Nachahmerprodukt darunter veröffentlichen kann — siehe
[`packaging/pypi-placeholder/`](https://github.com/trustedsec/hate_crack/blob/main/packaging/pypi-placeholder).

### 1. hashcat installieren

Hashcat muss installiert und in deinem PATH verfügbar sein:

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

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

Oder lade eine vorkompilierte Binärdatei von https://hashcat.net/hashcat/ herunter und setze `hcatPath` in `config.json` auf ihren Speicherort.

### 2. hate_crack herunterladen

Mit Submodulen klonen (erforderlich für hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks und optional omen):

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

Wenn Sie ohne Submodule geklont haben, initialisieren Sie diese:

```bash
git submodule update --init --recursive
```

Dann die Konfiguration nach Bedarf anpassen. hate_crack verwendet zwei Konfigurationsdateien, die jeweils einen eigenen Satz von Einstellungen verwalten:

- **`config.json`** — Wortlisten-Pfade, Masken, Regeln, Tuning, Potfile, Hashcat-Pfad, Kandidatenlimits, Benachrichtigungs-Schalter, CLI-Präferenz-Standardwerte (35 Einstellungen).
- **`.env`** — nur Einstellungen für Drittanbieter-Integrationen: Hashview- und Hashmob-Anmeldedaten, Pushover-Anmeldedaten, Ollama und pipal (14 Einstellungen). Nicht von git verfolgt, mit Modus `0600` erstellt.

Die Trennlinie verläuft aus einem Grund genau dort: `.env` ist die Datei, die Geheimnisse enthalten kann. Anmeldedaten für und Konfiguration von Drittanbieter-Diensten gehören in die nicht verfolgte Datei mit Modus `0600`; alles, was hate_crack lokal tut, bleibt in `config.json`, die gefahrlos geteilt, verglichen und in die eigenen Notizen eingecheckt werden kann. Das ist auch der Grund, warum die Pushover-*Anmeldedaten* in `.env` liegen, während die Pushover-Ein/Aus-*Schalter* in `config.json` liegen — die Schalter sind lokale Präferenzen, keine Geheimnisse.

Jeder Schlüssel hat genau einen Platz. Ein Schlüssel, der in der anderen Datei platziert wird, wird ignoriert, und hate_crack gibt eine Warnung aus, die die Datei nennt, in die er gehört. Jeder Schlüssel kann für einen einzelnen Lauf weiterhin überschrieben werden, indem seine Umgebungsvariable exportiert wird. Die meisten Benutzer können diesen Schritt überspringen, da die Standardpfade out-of-the-box funktionieren.

`config.json` ist dauerhaft und erstklassig — sie ist nicht veraltet und es gibt keinen Zeitplan für ihre Entfernung. Nur die Integrationseinstellungen wurden verschoben.

**Upgrade von einer einzelnen `config.json`?** hate_crack migriert sie beim ersten Lauf für Sie: Die Integrationseinstellungen werden in eine neue `.env` mit Modus `0600` kopiert und dann aus `config.json` entfernt, damit die beiden Dateien sie nicht beide beanspruchen. Es wird ausgegeben, welche Schlüssel verschoben wurden (niemals ihre Werte), und Ihre Originaldatei wird als `config.json.pre-split.bak` gespeichert, bevor sie angefasst wird. Alles andere in `config.json` bleibt genau so, wie es war, einschließlich der Schlüsselreihenfolge.

**Erster Lauf:** hate_crack erstellt beide Dateien für Sie, es gibt also nichts zu tun. Um `.env` stattdessen manuell einzurichten, kopieren Sie die verfolgte Vorlage:

```bash
cp .env.example .env
chmod 600 .env
```

`.env.example` ist eingecheckt und wird mit jedem leeren Credential-Schlüssel ausgeliefert. `.env` selbst darf **niemals** eingecheckt werden — sie ist gitignored, zusammen mit ihren üblichen Backup-Schreibweisen, und hate_crack erstellt sie immer mit Modus `0600` (nur Lesen/Schreiben für den Eigentümer). `.env.example` wird aus dem Schema generiert; regeneriere sie nach Änderungen an `hate_crack/config_schema.py` mit `uv run python -m hate_crack.config_writer`.

### 3. Abhängigkeiten und hate_crack installieren

Der einfachste Weg ist, `make` (oder `make install`) auszuführen, was dein Betriebssystem automatisch erkennt und installiert:
- Externe Abhängigkeiten (p7zip, transmission-daemon / transmission-remote)
- Baut Submodule (hashcat-utils, princeprocessor, pcfg_cracker und optional omen) und checkt das datenreine Corporate_Masks-Maskenset aus
- Python-Abhängigkeiten über uv und ein CLI-Shim unter `~/.local/bin/hate_crack`

```bash
make
```

Dies ist idempotent – bereits installierte Tools werden übersprungen. Um eine saubere Neuinstallation zu erzwingen:

```bash
make reinstall
```

**Oder Abhängigkeiten manuell installieren:**

### Externe Abhängigkeiten
Diese sind für bestimmte Download-/Extraktionsabläufe erforderlich:

- `7z`/`7za` (p7zip) — wird zum Extrahieren von `.7z`-Archiven verwendet.
- `transmission-daemon` / `transmission-remote` — wird zum Herunterladen von Weakpass-Torrents verwendet.

Manuelle Installationsbefehle:

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
```

Dann installiere die Python-Abhängigkeiten und den CLI-Shim:
```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
```

-------------------------------------------------------------------
## Projektstruktur
Die Kernlogik ist jetzt in Module unter `hate_crack/` aufgeteilt:

- `hate_crack/cli.py`: argparse-Hilfsfunktionen und Konfigurationsüberschreibungen.
- `hate_crack/api.py`: Hashview-, Weakpass- und Hashmob-Integrationen (Downloads/Menüs/Hilfsfunktionen).
- `hate_crack/attacks.py`: Menü-Angriffs-Handler.
- `hate_crack/corpus_stats.py`: Passwortstatistiken über das gesamte Korpus, die verwendet werden, um ein Korpus für das LLM zu beschreiben.
- `hate_crack/plaintext.py`: extrahiert das Passwort aus einer Korpuszeile (Entfernen von Hash-Präfixen, `$HEX[...]`-Dekodierung); wird von den LLM-Modi, corpus_stats und rulegen gemeinsam genutzt.
- `hate_crack/llm.py`: strukturierte (JSON) LLM-Kandidatengenerierung über Atomic Agents.
- `hate_crack/menu.py`: gemeinsamer Menü-Renderer, einschließlich optionaler Pfeiltasten-Navigation.
- `hate_crack/noninteractive.py`: Dispatcher für die skriptgesteuerten Angriffs-Subkommandos.
- `hate_crack/notify/`: Benachrichtigungspaket (Pushover-Backend, Tailer pro Crack).
- `hate_crack/username_detect.py`: erkennt `username:hash`-Eingabedateien, um über hashcats `--username` zu entscheiden.
- `hate_crack/formatting.py`, `hate_crack/progress.py`: Hilfsfunktionen für Ausgabeformatierung und Fortschrittsanzeige.
- `hate_crack/main.py`: Hauptimplementierung der CLI.

Die oberste `hate_crack.py` bleibt der Haupteinstiegspunkt und orchestriert diese Module.

-------------------------------------------------------------------
## Referenzen und Danksagungen

Dieses Projekt hängt von einer Reihe externer Projekte und Dienste ab und ist von ihnen inspiriert. Danke an:

- Hashview (http://github.com/hashview/)
- Weakpass (https://weakpass.com)
- Hashmob (https://hashmob.net)

-------------------------------------------------------------------
## Verwendung

Nach der Installation mit `make` kann hate_crack von überall aus ausgeführt werden:

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

Alternativ kann es über `uv` ausgeführt werden:

```bash
uv run hate_crack.py <hash_file> <hash_type>
```

### Als Tool ausführen (empfohlen)

Installation mit `make` aus dem Repository-Stammverzeichnis - dies baut Submodule und bündelt Assets:

```bash
cd /path/to/hate_crack
make
hate_crack
```

Der Befehl `make install` erstellt einen Bash-Shim unter `~/.local/bin/hate_crack`, der aus dem Repository-Verzeichnis heraus ausgeführt wird, sodass Konfiguration und Assets unabhängig vom aktuellen Arbeitsverzeichnis immer gefunden werden.

Die Konfiguration wird auch an folgenden Orten gesucht:
- Das Repository-Stammverzeichnis und das Paketverzeichnis
- `~/.hate_crack`

**Hinweis:** Der `hcatPath` in `config.json` ist nur für den Speicherort der hashcat-Binärdatei gedacht (optional, wenn hashcat im PATH ist). Hate_crack-Assets (hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks, omen) werden aus dem Repository-Verzeichnis geladen und automatisch durch `make install` mitgeliefert.

### Als Skript ausführen
Das Skript verwendet einen `uv`-Shebang. Machen Sie es ausführbar und führen Sie es aus:

```bash
chmod +x hate_crack.py
./hate_crack.py
```

Du kannst auch Python direkt verwenden:

```bash
python hate_crack.py
```

### Nicht-interaktive / skriptgesteuerte Nutzung

Für die Automatisierung können Sie einen einzelnen Angriff direkt starten und dabei das Menü umgehen. Der Angriffsname ist das erste Argument, gefolgt von der Hash-Datei und dem Hashcat-Hash-Typ. Vorverarbeitungsaufforderungen (Filterung von Computerkonten, LM-First-Brute-Force, Deduplizierung doppelter Konten) akzeptieren in diesem Modus automatisch ihre Standardwerte. Der Prozess beendet sich mit `0` bei Erfolg und mit einem Wert ungleich null bei einem Fehler (fehlende Hash-Datei, nicht numerischer Hash-Typ, fehlende Wortliste oder ein unbekannter Regeldateiname).

```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
```

Die meisten Angriffe des Menüs sind auf die gleiche Weise verfügbar. Diese benötigen nichts
außer der Hash-Datei und dem Hash-Typ:

```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
```

Jede akzeptiert auch die Einstellungen, nach denen der jeweilige Menüeintrag fragt:

```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
```

Der Rest nimmt die eine Eingabe, die ihr Menüeintrag verlangt:

```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` ist der eine Befehl, dessen reine Form nicht mit seinem Menüeintrag identisch ist: Menüoption 5 führt immer die Hybrid-Durchläufe über erweiterte Fragmente aus, während der Unterbefehl standardmäßig auf `hcatFingerprint`s eigenen Standardwert „off" zurückgreift. Übergeben Sie `--run-hybrid-on-expanded`, um das Menü nachzubilden.

Fünf Menüeinträge sind weiterhin nur interaktiv verfügbar, da sie Eingaben benötigen, die ein einzelnes Flag nicht transportieren kann: Markov Brute Force, Random Rules, der Rosetta-Angriff, der LLM-Angriff und die Extensive Pure_Hate-Methodik (ein Orchestrator über die anderen statt eines einzelnen Angriffs).

#### Exit-Codes

| Code | Bedeutung |
|---|---|
| `0` | Der Angriff wurde ausgeführt |
| `1` | Ungültige Eingabe — fehlende Hash-Datei oder Wortliste, nicht-numerischer Hash-Typ, unbekannter Regeldateiname, Argument außerhalb des gültigen Bereichs |
| `2` | Unbekannter Unterbefehl — diese Build von hate_crack enthält ihn nicht |
| `3` | Nur mit `--exit-code-on-skip`: Die Abdeckung hatte bereits jeden Durchlauf gesehen, sodass nichts gestartet wurde |

Exit `2` und Exit `3` ermöglichen es einem skriptgesteuerten Treiber, „diese Version kann diesen Angriff nicht ausführen" und „er war redundant" von „er wurde ausgeführt und hat nichts gefunden" zu unterscheiden. `--exit-code-on-skip` ist optional, damit das Aktivieren der Abdeckung nicht anfängt, Harnesses fehlschlagen zu lassen, die älter sind als diese Funktion.

-------------------------------------------------------------------
## Fehlerbehebung

### Fehler: „would clobber existing tag" beim Aktualisieren

Ein älterer Clone kann die Aktualisierung verweigern und eine lange Liste von Zeilen ausgeben wie:

```
 ! [rejected]        v2.5.0     -> v2.5.0  (would clobber existing tag)
```

Dies betrifft Klone, die vor Juli 2026 erstellt wurden. Die veröffentlichte Historie wurde
damals neu geschrieben, um einige Dateien zu entfernen, die niemals hätten committet werden dürfen, wodurch
jeder Commit eine neue ID erhielt; die Tags eines älteren Klons zeigen daher auf Objekte, die dieses
Repository nicht mehr enthält, und git weigert sich, ein Tag zu verschieben, das es bereits hat.
Mit deinem Checkout ist nichts falsch und es sind keine Cracking-Daten gefährdet.

Stelle es mit einem einmaligen Reset wieder her. Dies verwirft lokale Commits und Änderungen im
Checkout. Wenn du also etwas angepasst hast, das von git verfolgt wird (im Gegensatz zu
`config.json`, das nicht verfolgt wird), committe es zuerst in einen Branch:

```bash
cd /path/to/hate_crack
git fetch --tags --force origin
git checkout -B main origin/main
make install
```

`--force` aktualisiert hier nur Tags; es kann deine Commits nicht berühren. Danach funktioniert der integrierte Updater normal. Versionen vor 2.18 konnten diese Wiederherstellung nicht selbst durchführen, weshalb sie einmalig manuell erfolgen muss.

### Fehler: Build-Verzeichnis existiert nicht

Wenn du einen Fehler wie diesen siehst:
```
Error: Build directory /opt/hashcat/hashcat-utils does not exist.
Expected to find expander at /opt/hashcat/hashcat-utils/bin/expander.
```

Das bedeutet, dass die hate_crack-Assets nicht in das installierte Paket eingebunden wurden.

**Die Pfade verstehen:**
- `hcatPath` in config.json → verweist auf den **Speicherort der hashcat-Binärdatei** (optional, kann im PATH liegen)
- `hashcat-utils/` und `princeprocessor/` → werden durch `make install` in das Paket eingebunden

**Lösung:**
Neuinstallation mit dem Makefile, das die Submodule baut und das Tool installiert:
```bash
cd /path/to/hate_crack  # the repository checkout
make install
```

**Standardkonfiguration (config.json.example):**

Die meisten Benutzer können die Standardwerte ohne Anpassung verwenden:
- `hcatWordlists`: `./wordlists` (relativ zum Repo-Stammverzeichnis oder HOME/.hate_crack)
- `hcatOptimizedWordlists`: `./optimized_wordlists` (Verzeichnis, das von Quick Crack verwendet wird; fällt auf `hcatWordlists` zurück, wenn nicht gefunden)
- `rules_directory`: `./hashcat/rules` (enthält Submodul-Regeln)
- `hcatTuning`: `` (leerer String - keine Standard-Tuning-Flags)

**Beispiel für config.json-Anpassungen:**
```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)
  ...
}
```

**Konfigurationsladen:**
- Rangfolge für jeden Schlüssel: `os.environ` > die eigene Home-Datei des Schlüssels (`.env` oder `config.json`) > integrierter Standardwert
- Fehlende Schlüssel fallen auf die integrierten Standardwerte zurück; `config.json.example` dokumentiert jeden `config.json`-Schlüssel
- Beide Dateien werden unabhängig voneinander in dieser Reihenfolge durchsucht: **Repo-Wurzelverzeichnis**, dann das **installierte Paketverzeichnis**, dann **`~/.hate_crack`**. Der erste Treffer gewinnt; es ist normal, dass die beiden Dateien aus unterschiedlichen Verzeichnissen stammen.
- Beim ersten Lauf werden beide erstellt — `config.json` aus `config.json.example`, `.env` aus den integrierten Standardwerten. Wenn eine ältere `config.json` noch Integrationsschlüssel enthält, werden diese in die neue `.env` kopiert und hate_crack teilt Ihnen mit, welche davon aus `config.json` gelöscht werden sollen; die Datei selbst wird niemals bearbeitet.
- Bei jedem Lauf gibt hate_crack die beiden Dateien aus, die tatsächlich geladen wurden:

  ```
  [*] config.json: /home/you/.hate_crack/config.json
  [*] .env:        /home/you/.hate_crack/.env
  ```

  Lies diese beiden Zeilen, bevor du eine Einstellung debugst, die „nicht wirksam wird“. Sie existieren wegen zweier Fallen in der Suchreihenfolge:

  - **Ein Checkout hat Vorrang vor deinem Home-Verzeichnis.** Das Repo-Stammverzeichnis wird zuerst durchsucht, sodass eine `.env` oder `config.json`, die in *irgendeinem* Checkout liegt, von dem aus du das Tool ausführst, Vorrang vor der in `~/.hate_crack` hat — und das Ausführen des Tools aus einem Checkout heraus ist genau das, was diese Dateien dort überhaupt erst erzeugt. Wenn dies jemals eine echte `~/.hate_crack`-Konfiguration verdeckt, gibt hate_crack dies nun mit einer dritten `[!]`-Zeile aus, die beide Pfade nennt — behandle diese Zeile als „die unten stehende Datei wird ignoriert“, nicht als eine zweite, gleichermaßen gültige Konfiguration.
  - **Das aktuelle Arbeitsverzeichnis wird nie durchsucht.** Eine `.env` in dem Verzeichnis, in dem du dich gerade befindest, wird bewusst ignoriert: Engagement-Verzeichnisse sind voll von Dateien, die niemand als Konfiguration gedacht hat. Lege sie ins Repo-Stammverzeichnis oder nach `~/.hate_crack`.

### Fehler: merge with ref 'refs/heads/master' but no such ref was fetched

Wenn du Folgendes siehst:
```
Your configuration specifies to merge with the ref 'refs/heads/master'
from the remote, but no such ref was fetched.
```

Der Standardbranch wurde von `master` in `main` umbenannt. Beheben mit:
```bash
git remote set-head origin -a
git branch -m master main
git branch --set-upstream-to=origin/main main
git pull
```

-------------------------------------------------------------------
### Makefile-Ziele

**Standard (vollständige Installation)** – baut Submodule, installiert Abhängigkeiten und installiert das Tool:

```bash
make
# or explicitly:
make install
```

Dies ist idempotent - bereits installierte Tools werden übersprungen.

**Erzwungene saubere Neuinstallation:**

```bash
make reinstall
```

**Kurzes Update** – Submodule werden neu gebaut und das Tool neu installiert (nach dem Abrufen von Änderungen):

```bash
make update
```

**Deinstallieren** – entfernt Betriebssystem-Abhängigkeiten und das Tool:

```bash
make uninstall
```

**Nur hashcat-utils bauen:**

```bash
make hashcat-utils
```

**Tests ausführen** – behandelt HATE_CRACK_SKIP_INIT bei Bedarf automatisch:

```bash
make test
```

**Abdeckungsbericht:**

```bash
make coverage
```

**Bereinigungs-Build-/Test-Artefakte:**

```bash
make clean
```

## Entwicklung

### Einrichten der Entwicklungsumgebung

Installieren Sie das Projekt mit optionalen Dev-Abhängigkeiten (enthält Linter und Testtools):

```bash
make dev-install
```

### Linter und Typprüfungen ausführen

Bevor Sie Änderungen pushen, führen Sie diese Prüfungen lokal aus. Verwenden Sie `make lint` für alles oder führen Sie einzelne Prüfungen aus:

**Ruff (Linting und Formatierung):**
```bash
make ruff
# or manually:
uv run ruff check hate_crack tests tools packaging hate_crack.py
```

Probleme automatisch beheben:
```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 (Typüberprüfung):**
```bash
make ty
# or manually:
uv run ty check hate_crack
```

**Alle Prüfungen zusammen ausführen:**
```bash
make lint
```

### Tests ausführen

Tests erkennen automatisch, wenn Submodule nicht gebaut sind, und setzen `HATE_CRACK_SKIP_INIT=1` automatisch.

```bash
make test
```

Oder führe pytest direkt aus:

```bash
uv run pytest -v
```

Mit Abdeckung:

```bash
make coverage
```

Oder mit pytest:

```bash
uv run pytest --cov=hate_crack
```

### Git Hooks (prek)

Git-Hooks werden von [prek](https://github.com/j178/prek) (v0.3.3+) verwaltet. Hooks installieren mit:

```bash
prek install --hook-type pre-push --hook-type pre-commit
```

Dies installiert die in `prek.toml` definierten Hooks unter Verwendung des pre-commit local-repo
TOML-Schemas:
- **pre-push** (lokale Hooks): ruff, ruff-format, ty, pytest, pytest-lima, bandit
- **pre-commit** (aus `pre-commit/pre-commit-hooks`): trailing-whitespace,
  end-of-file-fixer, check-yaml, check-merge-conflict, check-added-large-files,
  detect-private-key

Die pre-commit-Autofixer schreiben Dateien direkt um, also staged und committe sie
erneut, nachdem sie gelaufen sind.

Hinweis: prek 0.3.3 erwartet `repos = [...]` auf oberster Ebene. Das alte Format `[hooks.<stage>] commands = [...]` wird nicht unterstützt.

### Navigation im Menü mit Pfeiltasten

Menüs verwenden standardmäßig die klassische nummerierte `print()` + `input()`-Auswahl, die
vollständige mehrstellige Tasten akzeptiert.

Um die Navigation mit Pfeiltasten über `simple-term-menu` zu aktivieren, setze
`HATE_CRACK_ARROW_MENU=1`. In diesem Modus kannst du dich entweder mit den Pfeiltasten
bewegen oder die Optionsnummer eingeben (einschließlich mehrstelliger wie `99`) und
Enter drücken. Die Eingabe von etwas anderem filtert die Liste. Der Pfeiltastenmodus
erfordert außerdem ein TTY, daher bleibt er aus, wenn die Ausgabe weitergeleitet wird.

Die Auswahlmenüs, die eine Liste ausgeben und dann eine Eingabe entgegennehmen (Wortlisten, Regeln, die
Weakpass-Liste, Hashview-Wortliste und Regel-IDs), akzeptieren Auf/Ab bei jedem Backend,
ohne `HATE_CRACK_ARROW_MENU`. Auf füllt den zuletzt aufgelisteten Schlüssel ein, Auf erneut den
davor, Ab geht zurück; du kannst weiterhin eine Nummer, einen Pfad oder eine Liste
wie `1,3` eingeben. Ein `,`, `+` oder `-`, das direkt nach einem pfeilgefüllten
Schlüssel eingegeben wird, erweitert ihn. Unter den Backends `plain` und `rich` funktioniert dies, indem die
aufgelisteten Schlüssel für diesen einen Prompt in die readline-Historie geladen werden, sodass deine eigene Historie
danach wiederhergestellt wird und aus einem Listen-Prompt heraus nicht erreichbar ist.

### Dev-Abhängigkeiten

Die optionale Gruppe `[dev]` enthält:
- **ty** - Statischer Typprüfer
- **ruff** - Schneller Python-Linter und -Formatter
- **pytest** - Test-Framework
- **pytest-cov** - Coverage-Berichterstattung

-------------------------------------------------------------------
Häufige Optionen:
- `--download-hashview`: Hashes von Hashview vor dem Cracken herunterladen.
- `--hashview`: Interaktives Hashview-Menü zum Verwalten von Hashes, Wortlisten und Jobs.
- `--hashview --help`: Hashview-Kommandozeilenoptionen anzeigen.
- `--weakpass`: Wortlisten von Weakpass herunterladen.
- `--rank`: Nur Weakpass-Wortlisten mit einer bestimmten Stufe anzeigen (0=alle, -1=S/A/B-Stufen). Ränge: 7=S, 6=A, 5=B, 4=C, 3=D, 2=E, 1=F.
- `--hashmob`: Wortlisten von Hashmob.net herunterladen.
- `--hashmob-masks`: Masken von Hashmob.net herunterladen.
- `--download-torrent <FILENAME>`: Eine bestimmte Weakpass-Torrent-Datei herunterladen.
- `--download-all-torrents`: Alle verfügbaren Weakpass-Torrents aus dem Cache herunterladen.
- `--wordlists-dir <PATH>` / `--optimized-wordlists-dir <PATH>`: Wortlisten-Verzeichnisse überschreiben.
- `--pipal-path <PATH>`: pipal-Pfad überschreiben.
- `--restore-potfile`: `<hashfile>.out` beim Start aus der hashcat-POT-Datei neu aufbauen, vorhandene Inhalte ersetzen und dann ins normale Menü übergehen. Ohne dieses Flag läuft die POT-Suche nur, wenn `.out` noch nicht existiert. Menüoption 93 macht dasselbe auf Anfrage, mit Bestätigungsabfrage.
- `--maxruntime <SECONDS>`: Maximale Laufzeit überschreiben.
- `--bandrel-basewords <PATH>`: bandrel-Basiswörter-Datei überschreiben.
- `--update`: Auf die neueste Version aktualisieren und neu installieren. Wechselt den Checkout auf `main`, falls er auf einem anderen Branch ist, da die Release-Tags dort liegen.
- `--nightly`: Stattdessen auf die neueste Nightly-Version aktualisieren, aus dem Branch `nightly-dev`. Nightlies haben CI bestanden, sind aber nicht Teil eines veröffentlichten Releases. Kann auch als `--update --nightly` geschrieben werden.
- `--no-optimized-kernel` (oder `--no-optimize`): Für den gesamten Lauf niemals `-O` an hashcat übergeben. Überschreibt `optimizedKernelAttacks` in `config.json` und entfernt jedes `-O`, das du in `hcatTuning` gesetzt hast. Es wird nichts in die Konfiguration zurückgeschrieben, gilt also nur für diesen Lauf. Bei einem Unterbefehl vor den Unterbefehl setzen: `./hate_crack.py --no-optimize quick hashes.txt 1000 --wordlist words.txt`.
- `--debug`: Debug-Logging aktivieren (schreibt nach stderr).

### Hashview-Integration

hate_crack integriert sich mit Hashview für zentralisierte Hash-Verwaltung und verteiltes Cracken.

#### Interaktives Menü

Zugriff auf das interaktive Hashview-Menü:
```bash
hate_crack.py --hashview
```

Menüoptionen:
- **(1) Upload Cracked Hashes** - Hochgeladene geknackte Ergebnisse aus der aktuellen Sitzung zu Hashview hochladen
- **(2) Upload Wordlist** - Eine Wordlist-Datei zu Hashview hochladen
- **(3) Download Wordlist** - Eine Wordlist von Hashview herunterladen
- **Download Rule** - Eine Regeldatei von Hashview herunterladen (dekomprimiert zu Klartext, bereit für `hashcat -r`). Geben Sie `a` (oder `all`) an der Regel-ID-Eingabeaufforderung ein, um jede aufgelistete Regel statt einer einzelnen herunterzuladen
- **Download All Rules** - Jede von Hashview aufgelistete Regeldatei in einem Durchgang herunterladen; Fehler pro Regel werden gemeldet, ohne den Rest abzubrechen
- **(4) Download Left Hashes** - Verbleibende ungeknackte Hashes herunterladen (fragt nach, um zum Knacken zu wechseln)
- **(5) Download Found Hashes** - Bereits geknackte Hashes mit Klartext-Passwörtern herunterladen (zur Referenz/Analyse)
- **(6) Upload Hashfile and Create Job** - Neue Hashdatei hochladen und einen Knack-Job erstellen
- **(99) Back to Main Menu** - Zum Hauptmenü zurückkehren

**Wichtig: Download Found vs Download Left**
- **Download Left Hashes (4)**: Lädt ungeknackte Hashes herunter, die geknackt werden müssen. Führt automatisch mit allen gefundenen Hashes zusammen, falls verfügbar, und fragt nach, um zu dieser Hashdatei zum Knacken zu wechseln.
- **Download Found Hashes (5)**: Lädt bereits geknackte Hashes im Format hash:cleartext herunter. Diese dienen als Referenz und können nicht weiter geknackt werden. Es wird keine Wechselaufforderung angezeigt.

#### Command-Line Interface

Hashview-Operationen können auch über die Kommandozeile ausgeführt werden:

Geknackte Hashes hochladen:
```bash
hate_crack.py --hashview upload-cracked --file <output_file>.out --hash-type 1000
```

Lade eine Wortliste hoch:
```bash
hate_crack.py --hashview upload-wordlist --file <wordlist>.txt --name "My Wordlist"
```

Laden Sie eine Regeldatei herunter (dekomprimiert gespeichert, bereit für `hashcat -r`):
```bash
hate_crack.py --hashview download-rules --rules-id 4 --output best64.rule
```

Lade linke Hashes herunter (ungeknackte Hashes zum Knacken):
```bash
hate_crack.py --hashview download-left --customer-id 1 --hashfile-id 123
```

Heruntergeladene gefundene Hashes (bereits geknackte Hashes mit Klartext):
```bash
hate_crack.py --hashview download-found --customer-id 1 --hashfile-id 123
```

Hashfile hochladen und Job erstellen:
```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"
```

#### Konfiguration

Legen Sie die Hashview-Anmeldedaten in `.env` fest (es handelt sich um Integrationseinstellungen, daher befinden sie sich nicht in `config.json`):
```
HASHVIEW_URL=https://hashview.example.com
HASHVIEW_API_KEY=your-api-key-here
HASHVIEW_VERIFY_TLS=true
```

`HASHVIEW_VERIFY_TLS` ist standardmäßig auf `true` gesetzt: hate_crack überprüft das TLS-Zertifikat des Hashview-Servers, und die Verbindung zu einem Hashview mit einem selbstsignierten oder internen CA-Zertifikat schlägt fehl, bis dieses Zertifikat als vertrauenswürdig eingestuft wird (fügen Sie es Ihrem System-Trust-Store hinzu oder verwenden Sie ein Zertifikat, das von einer CA ausgestellt wurde, der Ihr System bereits vertraut). Wenn das nicht möglich ist, setzen Sie `HASHVIEW_VERIFY_TLS=false` -- hate_crack gibt bei jedem Prozessstart eine einzeilige Warnung mit dem Namen des Hosts aus, wenn die Überprüfung deaktiviert ist, da das Deaktivieren den Schutz vor einem gefälschten Server oder einem Angreifer auf dem Übertragungsweg, der die Verbindung abfängt, aufhebt.

#### LLM-Konfiguration

Der LLM-Angriff (Option 12) und der Rosetta-Masken-Angriff (Option 23) generieren ihre Kandidaten mit einem lokalen Modell. Konfigurieren Sie das Modell, das Kontextfenster und das Anforderungs-Timeout in `.env`:

```
LLM_BACKEND=ollama
OLLAMA_MODEL=qwen3:4b-instruct
OLLAMA_NUM_CTX=8192
OLLAMA_TIMEOUT=300
```

---

[Read more](https://github.com/trustedsec/hate_crack)