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

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

サブモジュールなしでクローンした場合は、サブモジュールを初期化してください：```bash
git submodule update --init --recursive

`.env.example` はコミットされ、すべての認証情報キーが空の状態で同梱されます。`.env` 自体は**決して**コミットしてはなりません — `.env` は gitignore されており、通常のバックアップ表記も同様に無視されます。また、hate_crack は常にモード `0600`（所有者のみ読み書き可能）でこのファイルを作成します。`.env.example` はスキーマから生成されます。`hate_crack/config_schema.py` を変更した後は、`uv run python -m hate_crack.config_writer` を実行して再生成してください。

### 3. 依存関係と hate_crack のインストール

最も簡単な方法は `make`（または `make install`）を実行することです。これにより OS が自動検出され、以下がインストールされます：

- 外部依存関係（p7zip、transmission-daemon / transmission-remote）
- サブモジュール（hashcat-utils、princeprocessor、pcfg_cracker、任意で omen）のビルド、およびデータのみの Corporate_Masks マスクセットのチェックアウト
- uv による Python 依存関係と、`~/.local/bin/hate_crack` への CLI シム```bash
make

**または依存関係を手動でインストール:**

### 外部依存関係
これらは特定のダウンロード/抽出フローに必要です:

- `7z`/`7za` (p7zip) — `.7z` アーカイブの抽出に使用されます。
- `transmission-daemon` / `transmission-remote` — Weakpass トレントのダウンロードに使用されます。

手動インストールコマンド:

Ubuntu/Kali:```bash
sudo apt-get update
sudo apt-get install -y p7zip-full transmission-daemon

次に、Python の依存関係と 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

または、`uv` 経由で実行します：```bash
uv run hate_crack.py <hash_file> <hash_type>

`make install` コマンドは、`~/.local/bin/hate_crack` に bash シムを作成します。これはリポジトリディレクトリから実行されるため、現在の作業ディレクトリに関係なく、設定とアセットは常に見つかります。

設定は次の場所でも検索されます:
- リポジトリのルートとパッケージディレクトリ
- `~/.hate_crack`

**注:** `config.json` の `hcatPath` は hashcat バイナリの場所のみを指定します（hashcat が PATH にある場合は任意）。Hate_crack のアセット（hashcat-utils、princeprocessor、pcfg_cracker、Corporate_Masks、omen）はリポジトリディレクトリから読み込まれ、`make install` によって自動的にバンドルされます。

### スクリプトとして実行
スクリプトは `uv` シバンを使用します。実行可能にして実行してください:```bash
chmod +x hate_crack.py
./hate_crack.py

### 非対話型 / スクリプトでの使用法

自動化のために、メニューを介さずに単一の攻撃を直接起動できます。攻撃名が最初の引数になり、その後にハッシュファイルとhashcatハッシュタイプが続きます。前処理のプロンプト（コンピュータアカウントのフィルタリング、LM優先のブルートフォース、重複アカウントの重複排除）は、このモードではデフォルトが自動的に受け入れられます。プロセスは、成功時には `0` で終了し、エラー時には非ゼロで終了します（ハッシュファイルの欠落、数値以外のハッシュタイプ、ワードリストの欠落、または不明なルールファイル名）。```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

これは2026年7月より前に作成されたクローンに影響します。公開された履歴は、コミットされるべきではなかったいくつかのファイルを削除するためにその後書き換えられ、その結果すべてのコミットに新しいIDが付与されました。したがって、古いクローンのタグは、このリポジトリがもはや含まないオブジェクトを指しており、gitは既に持っているタグを移動することを拒否します。チェックアウトに問題はなく、クラッキングデータが危険にさらされることもありません。

一度だけのリセットで回復できます。これにより、チェックアウト内のローカルコミットと編集が破棄されるため、gitで追跡されているもの（追跡されていない`config.json`とは異なります）をカスタマイズした場合は、最初にブランチにコミットしてください:```bash
cd /path/to/hate_crack
git fetch --tags --force origin
git checkout -B main origin/main
make install

これは、hate_crack のアセットがインストールされたパッケージに同梱されていないことを意味します。

**パスの説明:**
- `config.json` 内の `hcatPath` → **hashcat バイナリの場所** を指します (オプション、PATH に含めることも可能)
- `hashcat-utils/` と `princeprocessor/` → `make install` によってパッケージに同梱されます

**解決策:**
Makefile を使用して再インストールしてください。これによりサブモジュールがビルドされ、ツールがインストールされます:```bash
cd /path/to/hate_crack  # the repository checkout
make install

**設定の読み込み:**
- 各キーの優先順位: `os.environ` > そのキーに対応するホームファイル (`.env` または `config.json`) > 組み込みのデフォルト
- 存在しないキーは組み込みのデフォルトにフォールバックします。`config.json.example` にはすべての `config.json` キーが記載されています。
- 両方のファイルは互いに独立して、次の順序で検索されます: **リポジトリルート**、次に**インストールされたパッケージディレクトリ**、その次に**`~/.hate_crack`**。最初に見つかったものが優先されます。2つのファイルが異なるディレクトリから来るのは正常です。
- 初回実行時には、両方のファイルが作成されます — `config.json` は `config.json.example` から、`.env` は組み込みのデフォルトから。古い `config.json` に統合キーがまだ残っている場合、それらは新しい `.env` にコピーされ、hate_crack は `config.json` から削除すべきキーを教えてくれます。hate_crack が `config.json` 自体を編集することは決してありません。
- 実行のたびに、hate_crack は実際に読み込んだ2つのファイルを出力します:  ```
  [*] config.json: /home/you/.hate_crack/config.json
  [*] .env:        /home/you/.hate_crack/.env

デフォルトブランチが `master` から `main` に変更されました。修正するには:```bash
git remote set-head origin -a
git branch -m master main
git branch --set-upstream-to=origin/main main
git pull

これは冪等です - 既にインストール済みのツールはスキップします。

**クリーン再インストールを強制:**```bash
make reinstall

**アンインストール** - OSの依存関係とツールを削除します:```bash
make uninstall

**テストを実行** - 必要なときはHATE_CRACK_SKIP_INITを自動的に処理します:```bash
make test

**ビルド/テスト成果物のクリーンアップ:**```bash
make clean

### リンターと型チェックの実行

変更をプッシュする前に、これらのチェックをローカルで実行してください。すべてまとめて行うには `make lint` を使用し、個別に実行することもできます:

**Ruff (リンターとフォーマット):**```bash
make ruff
# or manually:
uv run ruff check hate_crack tests tools packaging hate_crack.py

**ty (型チェック):**```bash
make ty
# or manually:
uv run ty check hate_crack

### テストの実行

テストは、サブモジュールがビルドされていないことを自動検出し、`HATE_CRACK_SKIP_INIT=1` を自動的に設定します。```bash
make test

カバレッジ付き：```bash
make coverage

### Git フック (prek)

Git フックは [prek](https://github.com/j178/prek) (v0.3.3+) によって管理されます。フックをインストールするには、次のコマンドを実行します:```bash
prek install --hook-type pre-push --hook-type pre-commit

Menu options:
- **(1) クラック済みハッシュのアップロード** - 現在のセッションのクラック済み結果をHashviewにアップロードします
- **(2) ワードリストのアップロード** - ワードリストファイルをHashviewにアップロードします
- **(3) ワードリストのダウンロード** - Hashviewからワードリストをダウンロードします
- **ルールのダウンロード** - Hashviewからルールファイルをダウンロードします（プレーンテキストに展開され、`hashcat -r` で使用可能）
- **(4) 残りハッシュのダウンロード** - 未クラックの残りハッシュをダウンロードします（クラッキング用に切り替えるか確認します）
- **(5) 見つかったハッシュのダウンロード** - すでにクラック済みのハッシュと平文パスワードをダウンロードします（参照・分析用）
- **(6) ハッシュファイルのアップロードとジョブの作成** - 新しいハッシュファイルをアップロードしてクラッキングジョブを作成します
- **(99) メインメニューに戻る** - メインメニューに戻ります

**重要: 見つかったハッシュのダウンロードと残りハッシュのダウンロードの違い**
- **残りハッシュのダウンロード (4)**: クラッキングが必要な未クラックのハッシュをダウンロードします。利用可能な場合は見つかったハッシュと自動的にマージされ、このハッシュファイルに切り替えてクラッキングするか確認を求められます。
- **見つかったハッシュのダウンロード (5)**: すでにクラック済みのハッシュを hash:cleartext 形式でダウンロードします。これらは参照用であり、それ以上クラックすることはできません。切り替えの確認は表示されません。

#### コマンドラインインターフェース

Hashview の操作はコマンドラインからも実行できます:

クラック済みハッシュのアップロード:```bash
hate_crack.py --hashview upload-cracked --file <output_file>.out --hash-type 1000

ルールファイルをダウンロード（解凍済み、`hashcat -r` で使用可能）：```bash
hate_crack.py --hashview download-rules --rules-id 4 --output best64.rule

見つかったハッシュ（解読済みのハッシュと平文）をダウンロード：```bash
hate_crack.py --hashview download-found --customer-id 1 --hashfile-id 123

#### 設定

`.env` に Hashview の認証情報を設定します (これらは統合設定であるため、`config.json` にはありません):```
HASHVIEW_URL=https://hashview.example.com
HASHVIEW_API_KEY=your-api-key-here

- **`OLLAMA_MODEL`** — 候補生成に使用するOllamaモデル（デフォルト: `qwen2.5:32b`）。LLM攻撃は構造化（JSON）出力を使用するため、ツール/JSONサポートが優れたモデルを選択してください。
- **`OLLAMA_NUM_CTX`** — モデルのコンテキストウィンドウサイズ（デフォルト: `8192`）。これはコーパス統計が導入される前は `2048` でしたが、与えられるプロンプトを保持するには小さすぎました: 500件のサンプル平文は、システムプロンプトと応答の前に約2,000〜3,500トークン消費するため、Ollamaはサンプラーがファイル全体に慎重に分散させたサンプルの一部を黙って切り捨てていました。
- **`OLLAMA_TIMEOUT`** — 生成応答を待ってから諦めるまでの秒数（デフォルト: `300`）。最初のリクエストで大きなモデルがまだVRAMに読み込まれている場合にこの値を上げてください。そうしないとタイムアウトを超える可能性があります。hate_crackは、タイムアウトが発生したときに経過タイムアウトとこの設定名を出力します。
- **`OLLAMA_MAX_SAMPLE_LINES`** — LLMモードがリテラル平文もプロンプトに貼り付ける閾値（デフォルト: `500`）。`0` 以下の値は `500` として扱われます。

  コーパス由来モード（**Wordlist**、**Cracked passwords**、**Pattern rules**）は、その一部を貼り付けるのではなく、常にコーパス全体を統計的に記述します — ベースワードのシェア、マスク、大文字小文字、長さ、末尾の数字と記号、年 —。集約には上限があるため、120,000パスワードのダンプでも500行のものと同じ程度のプロンプト領域で済みます。コーパス全体がこの閾値に収まる場合は、生の平文も含まれます。小さなコーパスをモデルから隠しても何も得られないからです。

  これは、最大 `ollamaMaxSampleLines` 個のパスワードを等間隔にサンプリングして貼り付ける以前の動作を置き換えます。大きなダンプのサンプルは頻度情報をまったく伝えませんでした: モデルは組織の8%が使用するベースワードと、個人が使用するベースワードを区別できませんでした。これはまさに、推測を実行する価値があるものにするシグナルです。
- **`OLLAMA_NO_CLOUD`** — `true` の場合、3つのLLMバックエンド（Ollama、vLLM、または汎用OpenAI互換サーバー）のいずれについても、このホストから外部へ何も送信しません。この1つの設定で2つのチェックが行われます: Ollamaは `-cloud` タグ付きモデル（`gpt-oss:120b-cloud`、`deepseek-v3.1:671b-cloud`）を、ローカルモデルが使用する同じローカルエンドポイントを介してollama.comにプロキシするため、リクエストは何も変わって見えません — これはモデル名で拒否されます。設定されたバックエンドURLもチェックされます: ループバック、プライベート、リンクローカルではない宛先（および `localhost` や `.local`/`.internal`/`.lan`/`.localdomain` 名ではないもの）は宛先によって拒否され、このチェックで解決できないホスト名も、検証できない宛先を通すのではなく、フェイルクローズで拒否されます。hate_crackのプロンプトには、回復された平文、コーパス統計、クライアントの名前、業界、場所が含まれるため、どちらかのチェックが発動すると、リクエストは構築される前に拒否されます。デフォルトは `false` で、意図的に設定されたクラウドモデルまたはリモートサーバーが引き続き機能します。クライアントデータをホストの外に出してはならないエンゲージメントではこれをオンにしてください。
- **`OLLAMA_AUTO_RESEARCH`** — `true`（デフォルト）の場合、**Target info** モードは会社名を入力するとすぐにローカルモデルに業界、場所、親会社/買収履歴を提案させ、編集可能なプロンプトのデフォルトとして提供します。`false` に設定すると、常に空白のプロンプトが表示されます（遅いモデルで有用です。リサーチは攻撃開始前にもう1往復余分にかかるため）。
- **`OLLAMA_HOST`** — Ollamaが待ち受けている場所。素の `host:port`（`theplague.lan:11434`）またはスキーム付きの完全なURL（`https://ollama.example.com`）を受け入れます。どちらの場合もベースURLは使用前に正規化されます。デフォルトは `localhost:11434` です。`.env` に設定するか、実際の環境変数としてエクスポートして単一の実行に対して上書きします — これはOllama自身のCLIが読み取るのと同じ変数名です。
- LLM Attackを使用する前に、Ollamaが実行中でモデルがプルされていることを確認してください（`ollama pull qwen2.5:32b`）— hate_crackは不足しているモデルを自動プルしなくなりました。

攻撃には3つの生成モードがあります:

1. **Target info** — 会社 / 業界 / 場所 / 親会社。モデルはこれらの詳細から候補を導き出します。

   会社名を入力すると、hate_crackは同じローカルモデルにその組織についてすでに知っていることを尋ね、**Industry**、**Location**、**Parent Company** のプロンプトに回答を事前入力し、括弧内に表示します:   ```
   Company name: Acme Rail Services

   [!] The values in parentheses below are the local model's GUESSES, not verified OSINT.
       Press Enter to accept, or type your own value to override.
   Industry (freight rail maintenance):
   Location (Omaha, Nebraska):
   Parent company / acquired by:

リサーチの失敗（タイムアウト、Ollama が実行されていない、空の回答）は攻撃を決してブロックしません。単に空のプロンプトにフォールバックするだけです。リサーチを完全にスキップするには、`ollamaAutoResearch` を `false` に設定してください。
2. **ワードリスト** — サンプルのワードリストからベースワードを導出します。
3. **クラック済みパスワード** — このセッションで既に回復された平文（`<hashfile>.out`）をモデルにフィードバックし、対象組織独自のパスワード規則（ベースワード、季節、年、接尾辞、リートスピーク）を推測させ、同じスタイルの*新しい*候補を生成させます。このオプションは、少なくとも1つのハッシュがクラックされた後にのみ表示されます。ファイル全体は、Wordlist モードとまったく同じように統計的に分析されます（上記の `ollamaMaxSampleLines` を参照）。

#### PCFG 設定

PCFG 攻撃（オプション 20）と PRINCE-LING 攻撃（オプション 21）は、`pcfg_cracker` サブモジュールを使用します。これらは `config.json` で設定します：```json
{
"pcfgRuleset": "DEFAULT",
"pcfgMaxCandidates": 50000000,
"pcfgPrinceLingMaxCandidates": 10000000
}

`Y` と答えると、hate_crack は未試行のエントリだけを保持する一時ルールファイルを構築します。`n` と答えると、とにかく全体を実行します。*すべて*のエントリが繰り返しの場合、攻撃を完全にスキップするかどうか尋ねられます。そのため、カバー済みの範囲を意図的に再実行する場合でも、ツールを再起動する必要はありません。

フィルタされない攻撃も実行済みとして記録されます。これにより、「このターゲットに対して PRINCE を既に実行したか？」と答えられるようになります。

意図的な制限は3つあります:

- **カバレッジは hashcat がキースペースを使い尽くした場合にのみ記録されます** (exit 1)。ctrl-C またはエラーでは何も記録されず、exit 0 でも記録されません。exit 0 はすべてのハッシュがクラックされたことを意味し、hashcat はキースペースを最後まで処理*せずに*全ハッシュのクラックを報告します。また、極端なケースとして「すべてのハッシュが potfile エントリとして見つかった」場合は、候補を1つも試さずに報告します。記録が少なすぎる場合、後で冗長な実行が1回増えるだけです。
- **動的候補生成器は決してフィルタされません。** PRINCE、PCFG、OMEN、Markov ブルートフォース、LLM モードには差分を取るための固定セットがないため、
  実行済みとしてログに記録されるだけで、それ以外はそのまま残されます。連結されたルールファイル（`-r a -r b`）はエントリごとではなく単一の単位として追跡されます。これは、hashcat が2つのファイルの*デカルト積*を適用するため、個々の行を削除すると、その行が関与するすべての組み合わせが黙って削除されることになるからです。
- **`--loopback` の実行は記録されますが、決してフィルタされません。** hashcat は新しくクラックされた平文を*追加の*候補としてフィードバックするため、
  そのような実行では完全なワードリストとルールセットに加えて、リサイクルされた平文が到達するものすべてを試します。このため、2つの方向は非対称になります。記録しておくことは理にかなっているため、
  同じワードリストとルールによる後日の通常の実行は繰り返しとして正しく認識されますが、2回目の loopback 実行はリサイクルするクラックが増えるため、スキップされることはありません。

これを無効にするには、`config.json` の `coverage_enabled` を `false` に設定するか、単一の実行には
`--no-coverage` を渡します。これはストアを参照も更新も行いません。

#### カバレッジの確認とリセット

メインメニューのオプション **85 — Attack Coverage** は、読み込まれたハッシュファイルに対して
何が実行されたか、その実行履歴を表示し、クリアすることもできます。同じ3つの操作は
スクリプトからも実行できます:```bash
# What has already been run against this hash file?
hate_crack coverage status --hashfile hashes.txt

# Every attack that has run against it, oldest first
hate_crack coverage history --hashfile hashes.txt

# Start over for this hash file only (prompts unless --yes)
hate_crack coverage forget --hashfile hashes.txt --yes

Exit 3 は *何も* 実行されなかったことを意味します。部分的にフィルタリングされたパス — 一部のエントリはスキップされ、一部は試行された — でも、攻撃が実際に作業を行ったため、終了コード `0` のままです。

### 通知 (メニューオプション 82)

hate_crack は、攻撃完了時、およびオプションで個々のハッシュがクラックされたときに Pushover プッシュ通知を送信できます。すべての制御はメインメニューのオプション `82 — 通知` にあります:

1. **Pushover 通知の切り替え [ON/OFF]** — マスタースイッチ。`config.json` に `notify_enabled` として保存されます。
2. **クラック毎通知の切り替え [ON/OFF]** — ON の場合、バックグラウンドのテイラーが `.out` ファイルを監視し、クラックごとに通知をプッシュします (ティック毎のバースト集約付き)。`config.json` に `notify_per_crack_enabled` として保存されます。マスタースイッチが OFF の間は有効にできません — 最初にオプション 1 を有効にしてください。
3. **テスト Pushover 通知を送信** — 定型プッシュを送信して、Pushover のトークン/ユーザーのペアが機能することを確認できます。マスタースイッチが OFF でも機能します。

認証情報は `.env` にあります。残りの調整ノブは `config.json` の設定ファイル専用です:

- `NOTIFY_PUSHOVER_TOKEN`, `NOTIFY_PUSHOVER_USER` (`.env` 内) — プッシュを発火させるために必須です。メニューからこれらを書き込む操作はありません。自分で `.env` を編集してください。
- `notify_attack_allowlist` — `[y/N/always]` プロンプトなしで自動同意する攻撃名。`always` と回答すると自動的に入力されます。
- `notify_suppress_in_orchestrators` (デフォルト `true`) — Extensive Crack によって連鎖された個々の攻撃を沈黙させ、代わりに単一のサマリーを発火します。連鎖攻撃ごとに通知を受け取るには `false` に設定します。複数のパスを実行する他のメニューエントリ (例えば複数のルールチェーンを使用する Quick Crack) はオーケストレーターではなく、常にパスごとに通知します。
- `notify_max_cracks_per_burst` (デフォルト `5`), `notify_poll_interval_seconds` (デフォルト `5.0`) — クラック毎テイラーのチューニング。バースト集約ロジックについては `hate_crack/notify/tailer.py` を参照してください。

### ワードリストツール (メニューオプション 80)

ワードリストツールのサブメニューは、hashcat-utils バイナリを利用したワードリスト前処理ユーティリティと、Hashmob.net および Weakpass からのワードリストダウンロードを提供します。メインメニューのオプション **80** からアクセスします。

| オプション | バイナリ | 機能 |
|--------|--------|--------------|
| 1 | `len.bin` | 長さでフィルタリング - 最小長と最大長の間の単語のみを保持 |
| 2 | `req-include.bin` | 文字クラスを必須化 - 必要なすべての文字タイプを含む単語のみを保持 |
| 3 | `req-exclude.bin` | 文字クラスを除外 - 除外された文字タイプをいずれか含む単語を削除 |
| 4 | `cutb.bin` | 部分文字列を抽出 - 各単語からバイト範囲を切り出す |
| 5 | `splitlen.bin` | 長さで分割 - 単語の長さごとに個別ファイルを作成 (出力ディレクトリ内に `01`〜`64` という名前のファイル) |
| 6 | `rli.bin` / `rli2.bin` | 単語を減算 - 1つ以上の他のファイルに出現するエントリを削除 |
| 7 | `gate.bin` | シャード - 複数マシンでの分散クラッキング用に N 個おきの単語を抽出 |
| 8 | - | ワードリストを最適化 - 重複排除し、最適化ワードリストディレクトリ配下に長さ別ファイルへ分割 |
| 9 | - | Hashmob.net からワードリストをダウンロード |
| 10 | - | Weakpass からワードリストをダウンロード (BitTorrent 経由) |

**文字クラスマスクビット** (オプション 2 と 3 で使用): `1`=小文字、`2`=大文字、`4`=数字、`8`=記号、`16`=その他。値を加算します: `7` = 小文字+大文字+数字。

**シャーディングの想定される使い方**: シャーディングは1つのワードリストを N 個の等しく重複しない部分に分割し、作業を複数のマシンまたは GPU に分散できるようにします。各パートは *インターリーブ* され (N 行ごと)、各シャードはリスト全体の代表的なサンプルとなり、連続した先頭/末尾チャンクではありません — 単一ノードが低確率の末尾だけをクラックするような事態にはなりません。

オプション 7 を1回実行し、入力ワードリスト、出力ベースパス、シャード数 (N) を指定します。単一パスで N 個すべてのパートを書き出し、ゼロ埋めされたパート番号 (`base.001`, `base.002`, … から `base.00N` まで) で名前が付けられます。各ノードに1パートずつコピーし、そのノードの hashcat 実行がそれを指すようにします。シングル GPU システムではシャーディングによる高速化はありませんが、1つのパートだけでも、完全なリストに着手する前の迅速なトリアージパスとして高速で代表的なサンプルになります。

#### 自動更新チェック

hate_crack は起動時に GitHub で新しいリリースを自動的にチェックできます。この機能は `check_for_updates` 設定オプションで制御されます。```json
{
  "check_for_updates": true
}

2.20.0  <  2.20.1rc1  <  2.20.1rc2  <  2.20.1  <  2.21.0rc1  <  2.21.0

## テスト

テストスイートはほとんどオフラインで、モック/フィクスチャを使用します。ライブネットワークチェックと
システム依存関係チェックは、環境変数によるオプトインです。

### テストをローカルで実行する```bash
# Run all tests
uv run pytest -v

# Run specific test
uv run pytest tests/test_hashview.py -v

### ローカル Docker スタックに対する Hashview ライブテスト

ライブテストをリモートの Hashview サーバーに対して実行する代わりに、
テストスイートでローカルの [Hashview](https://github.com/hashview/hashview)
Docker スタックを起動し、シードデータを投入し、ライブテストを実行してから破棄することができます。
`HASHVIEW_TEST_LOCAL=1` を設定し、`HASHVIEW_REPO` を Hashview のチェックアウト先に指定します:```bash
HASHVIEW_TEST_LOCAL=1 HASHVIEW_REPO=~/projects/hashview \
  HATE_CRACK_SKIP_INIT=1 uv run pytest tests/test_hashview_cli_subcommands_subprocess.py -v

Dockerベースのエンドツーエンドのインストール/実行（`Dockerfile.test` によってキャッシュされる）：```bash
HATE_CRACK_RUN_DOCKER_TESTS=1 uv run pytest tests/test_docker_script_install.py -v

テストVMは、すべてのLinux依存関係（hashcat、build-essential、curl、git、gzip、p7zip-full、transmission-daemon、ocl-icd-libopencl1、pocl-opencl-icd、uv）を自動的にプロビジョニングします。```bash
HATE_CRACK_RUN_LIMA_TESTS=1 uv run pytest tests/test_lima_vm_install.py -v

どのルールを実行しますか？
(1) best64.rule
(2) d3ad0ne.rule
(3) T0XlC.rule
(4) dive.rule
(99) YOLO...すべてのルールを実行
実行するルールをカンマ区切りのリストで入力してください。ルールをチェーンして実行するには + 記号を使用します。
例えば 1+1 は best64.rule を2回チェーンして実行し、1,2 は best64.rule と d3ad0ne.rule を順番に実行します。
賢く選んでください：```




#### Extensive Pure_Hate Methodology Crack
Runs several attack methods provided by Martin Bos (formerly known as pure_hate):
  * Brute Force Attack (7 characters)
  * Dictionary Attack
    * All wordlists in `hcatWordlists` with `best64.rule`
    * `rockyou.txt` with `d3ad0ne.rule`
    * `rockyou.txt` with `T0XlC.rule`
  * Top Mask Attack (Target Time = 4 Hours)
  * Fingerprint Attack
  * Smart Mask Attack
  * Combinator Attack
  * Hybrid Attack
  * Extra - Just For Good Measure
    - Runs a dictionary attack using `rockyou.txt` with chained `combinator.rule` and `InsidePro-PasswordsPro.rule` rules

#### Brute Force Attack
Brute forces all characters with the choice of a minimum and maximum password length.

#### Top Mask Attack
Uses StatsGen and MaskGen from PACK (https://thesprawl.org/projects/pack/) to perform a top mask attack using passwords already cracked for the current session.
Presents the user a choice of target cracking time to spend (default 4 hours).

#### Fingerprint Attack
https://hashcat.net/wiki/doku.php?id=fingerprint_attack

Runs a fingerprint attack using passwords already cracked for the current session. Expander substring length escalates automatically (7, 14, 21, ... up to the chosen ceiling), and an optional wordlist can be combined against the expanded fragments in addition to self-combination. Set `hcatFingerprintWordlist` in `config.json` to a default wordlist path so the prompt offers it instead of asking for a path every time; leave it as `""` to always ask (or skip).

#### Smart Mask Attack
Looks for literal "skeleton" patterns shared by 3+ already-cracked passwords for the current session -- e.g. a fixed stem like `CrawlingHorse` followed by a run of digits, or `ChangeMe2day` followed by digits and symbols drawn from a consistent charset. For each pattern found, runs a targeted `-a 3` mask attack (using the exact observed literal text and an inferred charset for the varying part) against the full remaining hash list, so other accounts sharing that stem get swept up even though brute-forcing the stem itself was never tried. Prompts once, before the attack starts, for an optional candidate-count guardrail (default 50,000,000,000; 0 disables it).

#### Combinator Attack
https://hashcat.net/wiki/doku.php?id=combinator_attack

Runs a combinator attack using the "rockyou.txt" wordlist.

#### Hybrid Attack
https://hashcat.net/wiki/doku.php?id=hybrid_attack

* Runs several hybrid attacks using the "rockyou.txt" wordlists.
  - Hybrid Wordlist + Mask - ?s?d wordlists/rockyou.txt ?1?1
  - Hybrid Wordlist + Mask - ?s?d wordlists/rockyou.txt ?1?1?1
  - Hybrid Wordlist + Mask - ?s?d wordlists/rockyou.txt ?1?1?1?1
  - Hybrid Mask + Wordlist - ?s?d ?1?1 wordlists/rockyou.txt
  - Hybrid Mask + Wordlist - ?s?d ?1?1?1 wordlists/rockyou.txt
  - Hybrid Mask + Wordlist - ?s?d ?1?1?1?1 wordlists/rockyou.txt

#### Pathwell Top 100 Mask Brute Force Crack
Runs a brute force attack using the top 100 masks from KoreLogic:
https://blog.korelogic.com/blog/2014/04/04/pathwell_topologies

#### PRINCE Attack
https://hashcat.net/events/p14-trondheim/prince-attack.pdf

Runs a PRINCE attack using wordlists/rockyou.txt

#### YOLO Combinator Attack
Runs a continuous combinator attack using random wordlists from the configured wordlists directory for the left and right sides.

#### Middle Combinator Attack
https://jeffh.net/2018/04/26/combinator_methods/

Runs a modified combinator attack adding a middle character mask:
wordlists/rockyou.txt + masks + worklists/rockyou.txt

Where the masks are some of the most commonly used separator characters:
2 4 <space> - _ , + . &

#### Thorough Combinator Attack
https://jeffh.net/2018/04/26/combinator_methods/

* Runs many rounds of different combinator attacks with the rockyou list.
  - Standard Combinator attack: rockyou.txt + rockyou.txt
  - Middle Combinator attack: rockyou.txt + ?n + rockyou.txt
  - Middle Combinator attack: rockyou.txt + ?s + rockyou.txt
  - End Combinator attack: rockyou.txt + rockyou.txt + ?n
  - End Combinator attack: rockyou.txt + rockyou.txt + ?s
  - Hybrid middle/end attack: rockyou.txt + ?n + rockyou.txt + ?n
  - Hybrid middle/end attack: rockyou.txt + ?s + rockyou.txt + ?s


#### Bandrel Methodology

Prompts for comma-separated names and creates a pseudo hybrid attack by capitalizing the first letter and adding up to six additional characters at the end. Each word is limited to a total of five minutes.

  - Built-in common words (seasons, months) included as a customizable `config.json` entry (`bandrel_common_basedwords`)
  - The default five-minute time limit is customizable via `bandrelmaxruntime` in `config.json`

#### Loopback Attack
https://hashcat.net/wiki/doku.php?id=loopback_attack

Uses hashcat's loopback mode to feed cracked passwords from the current session back into the attack pipeline with rules applied. This generates new password candidates based on variations of already-cracked passwords, which is particularly effective for finding related passwords that follow similar patterns.

* Prompts for rule selection to apply to the loopback candidates
* Uses an empty wordlist with the --loopback flag to process previously cracked passwords
* Automatically downloads Hashmob rules if no rules are available locally

#### LLM Attack
Uses a local Ollama instance to generate password candidates for a capture-the-flag scenario. Prompts for the fake company name, industry, location, and parent company / acquisition history, then sends these details to the configured LLM model to produce likely password candidates using industry terms and company name permutations. The generated candidates are fed into a hashcat wordlist+rules attack.

* Requires a running Ollama instance (default: `http://localhost:11434`, override with `OLLAMA_HOST` in `.env` or the environment) with the model already pulled — hate_crack does not auto-pull
* Candidate generation uses structured (JSON) output via Atomic Agents, so pick a model with good schema adherence (default: `qwen2.5:32b`)
* Configurable model, context window, request timeout, and sample size via `.env` (see Ollama Configuration below)
* Prompts for target company name, industry, location, and parent company / acquisition history. The industry, location, and parent company prompts are pre-filled with the local model's guesses about the named organization (editable, and clearly labelled as guesses rather than verified OSINT); disable with `ollamaAutoResearch: false`
* Alternatively derives basewords from a sample **wordlist**, or from the **cracked passwords** of the current session (`<hashfile>.out`) so the model mirrors the target organization's own password conventions and produces new candidates in that style (only offered once something has been cracked)
* A live spinner with an elapsed-seconds counter runs during generation, and requests are bounded by `ollamaTimeout` so a model stuck loading into VRAM reports a timeout instead of hanging

**Pattern rules mode** (option 4 in the LLM submenu) takes the same shape as the [Spoonman Attack](#spoonman-attack) — a baseword list run through a rule file, both derived from one corpus — but infers each side with the model instead of extracting it. Spoonman is exact and therefore bounded: its basewords all appear in the corpus and its rules only reproduce transformations the corpus already shows. This asks the model to generalize on both axes, so it can name the *word families* behind a sample (the company and its products, site names, local sports teams, seasons, mascots) and write decorations the corpus does not contain.

* Pattern source is either the current session's cracked passwords (offered first, and only once something has been cracked, since those reveal the target's real conventions) or a sample wordlist
* **You are not asked to pick a rule file.** The model writes one, from the same corpus statistics — a stock rule file encodes the internet's habits, and the point of spending a model round trip is to encode *this* organization's
* Basewords are normalized to lowercase letters only, discarding anything under 3 characters, so the generated rules supply case, digits, and punctuation exactly once
* Generated rules are validated before hashcat sees them, and anything using an op hashcat does not have, a position argument outside `0-9A-Z`, more than 31 functions, or a stray comment or non-ASCII character is discarded. hashcat drops an invalid rule *silently* when valid rules share the file, so an unscreened line would become missing coverage rather than an error. The op table was established by testing hashcat itself, not from its rule documentation, which lists ops hashcat will not actually run
* Local-model yield varies a lot run to run, so a thin answer is asked again once and the two rounds are merged — a handful of rules would waste the pass they are spent on
* If no rule survives validation the basewords still run, unmutated, rather than throwing away the expensive half of the run
* Output lands in `<hashfile>.llm_patterns/` as `basewords.txt` and `rules.rule` — per-run scratch, laid out like `.spoonman/` and removed on exit

#### OMEN Attack
Uses the Ordered Markov ENumerator (OMEN) to train a statistical password model from a wordlist and generate password candidates. This attack learns patterns from known passwords and generates new candidates based on those patterns.

* Requires OMEN binaries (createNG and enumNG) to be built from the omen submodule
* Interactive menu: use existing model, train new model, or cancel
* Training wordlist picker shows available wordlists from configured directory or accepts a custom path
* Validates all 5 required model files (createConfig, CP/IP/EP/LN.level) before running
* Captures and reports enumNG errors instead of failing silently
* Generates up to a specified number of password candidates (configurable via `omenMaxCandidates`)
* Pipes generated candidates directly into hashcat for cracking
* Model files and metadata are stored in `~/.hate_crack/omen/` for persistence across sessions

#### Combinator Attacks Submenu
Opens an interactive submenu with six combinator attack variants (formerly at menu keys 10-12). Consolidates related attacks for cleaner menu organization:
- Combinator Attack - combines two wordlists
- YOLO Combinator Attack - combines all permutations of multiple wordlists
- Middle Combinator Attack - combines wordlists with an extra word in the middle
- Thorough Combinator Attack - comprehensive combination of wordlists with rules
- Combinator3 Attack - combines exactly 3 wordlists using `combinator3.bin`, generating all `word1+word2+word3` combinations piped to hashcat
- CombinatorX Attack - combines 2-8 wordlists using `combinatorX.bin` with optional `--sepFill` separator character between word segments

#### Ad-hoc Mask Attack
Runs hashcat mask attack (mode 3) with a user-specified custom mask string. Allows fine-grained control over character-set brute forcing.

* Opens with a choice between typing a mask and selecting a mask file
* Prompts for a hashcat mask (e.g., `?u?l?l?l?d?d` for uppercase + lowercase + lowercase + lowercase + digit + digit)
* Supports custom character sets for specialized character combinations: `-1` through `-4` on any hashcat, plus `-5` through `-8` on hashcat 7 and newer. A mask using `?5`–`?8` against an older hashcat is flagged before the run rather than failing inside it; if the version cannot be read, the mask is passed through and hashcat decides
* Only prompts for the custom slots the mask actually references — `?1?3?d` asks about `-1` and `-3` and nothing else, and a mask with no custom tokens is never asked at all. Detection is token-aware, so the escaped `??1` is a literal `?1` and prompts for nothing. A slot left blank is still skipped, with a warning that hashcat will reject a mask whose charset is undefined
* Mask files (`.hcmask`) can be selected with tab completion, defaulting to the bundled `masks/` directory; hashcat runs every mask in the file in order. Because a mask file defines its own charsets inline, the `-1` through `-4` prompts are skipped when one is chosen
* Optionally runs the mask incrementally (`--increment`), trying shorter lengths before the full mask. Answering yes prompts for an increment minimum and maximum; either can be left blank, and leaving both blank increments over the mask's full keyspace with hashcat choosing the bounds. Offered for typed masks and mask files alike
* Useful for targeted brute forcing when you know password structure patterns

#### Markov Brute Force Attack
Generates password candidates using Markov chain statistical models. Similar to OMEN but simpler and faster.

* Checks for existing `.hcstat2` Markov table from previous sessions (with option to reuse, regenerate, or cancel)
* Generates table from training source if needed:
  - Can use cracked passwords from current session (`.out` file) as training data
  - Or select any wordlist from configured directory or custom path
* Interactive menu: choose minimum and maximum password length
* Uses `--increment` flag to test lengths in sequence
* Markov table persists with hash file (filename.out.hcstat2) for fast subsequent runs
* Faster than OMEN for general-purpose brute forcing

#### N-gram Attack
Generates n-gram candidates from a corpus file using `ngramX.bin` from hashcat-utils and pipes them into hashcat.

* Prompts for a corpus file with tab completion, defaulting to the configured wordlist directory
* Prompts for an n-gram group size (default 3)
* Gzip-compressed corpus files are auto-detected and decompressed on the fly
* Useful when you have target-relevant prose (scraped site copy, leaked documents, internal wiki exports) rather than a password list

#### Permutation Attack
Generates all character permutations of each word in a targeted wordlist and pipes them to hashcat via `permute.bin` from hashcat-utils.

* Prompts for a single wordlist file (not a directory)
* Effective against short targeted wordlists where the character set is known but the order is not (company abbreviations, name fragments, known tokens)
* WARNING: Scales as N! per word - an 8-character word produces 40,320 permutations. Only practical for words up to ~8 characters.
* Uses `permute.bin < wordlist | hashcat` pipeline pattern

#### Random Rules Attack
Generates a set of random hashcat mutation rules using `generate-rules.bin`, writes them to a temporary file, then runs hashcat against a chosen wordlist with those rules.

* Prompts for rule count (default 65536)
* Prompts for wordlist path with tab-completion and numbered selection
* Temporary rules file is cleaned up after the run regardless of outcome
* Useful when known rule sets are exhausted - explores random rule-space for additional cracks

#### Combipow Passphrase Attack
Generates all unique non-empty subset combinations from a short wordlist using `combipow.bin` and pipes them into hashcat. Designed for passphrase cracking when you know the pool of words a password was built from.

* Prompts for a wordlist file (max 63 lines - combipow generates up to 2^n-1 combinations)
* Optional space separator (`-s` flag) to insert spaces between words in each combination
* Warns if the wordlist exceeds 20 lines (output volume may be large)
* Aborts with a clear message if the wordlist exceeds 63 lines (hard limit)
* Candidates are piped directly to hashcat stdin

#### PCFG Attack
Uses [pcfg_cracker](https://github.com/lakiw/pcfg_cracker) to generate candidates from a Probabilistic Context-Free Grammar, piping `pcfg_guesser.py` output directly into hashcat's stdin mode. A PCFG models password *structure* (baseword + digits + symbol, capitalization habits, keyboard walks) with learned probabilities, so candidates come out roughly in descending likelihood order.

* Requires the `pcfg_cracker` submodule. Presence is checked at startup and reported non-fatally: if it is missing, the PCFG attacks are simply unavailable. Run `make` to fetch it.
* Uses the trained grammar named by `pcfgRuleset` in `config.json` (default `DEFAULT`), read from `pcfg_cracker/Rules/<name>/`
* Candidate count is capped by `pcfgMaxCandidates` (default 50,000,000)
* hate_crack does not wrap grammar training. To build a grammar from a target-specific password set, run pcfg_cracker's own `trainer.py` and point `pcfgRuleset` at the resulting ruleset name

#### PRINCE-LING Attack
Uses pcfg_cracker's `prince_ling.py` to derive an optimized PRINCE base wordlist from a trained grammar, then hands it to the existing PRINCE attack. PRINCE-LING picks base words the grammar says are actually productive, so the PRINCE combination space is far less wasteful than pointing PRINCE at a generic wordlist.

* Requires the `pcfg_cracker` submodule and a trained ruleset directory, same as the PCFG attack
* The generated wordlist is cached at `<hcatOptimizedWordlists>/pcfg_prince_ling_<ruleset>.txt` and reused across sessions
* Regenerates only when the ruleset directory is newer than the cached wordlist, so retraining a grammar invalidates the cache automatically
* Generation is written to a temporary file and atomically moved into place; a failed or interrupted run cleans up its partial file and leaves any existing cache intact
* Base wordlist size is capped by `pcfgPrinceLingMaxCandidates` (default 10,000,000)

#### Spoonman Attack
Derives a baseword list and a hashcat rule file from a corpus of known plaintext passwords — a previous engagement's cracked output, a leak dump, or any password list — such that the baseword x rule cross product reconstructs the corpus exactly (see the memory bound below for the one case where it does not). Contributed as issue #169 by @Spoonman1091.

Each password is split into its letters-only lowercased core (the baseword) plus a rule that rebuilds the original from it, using `l`/`u`/`c` for casing, `T{p}` toggles, `${x}`/`^{x}` for trailing and leading characters, and `i{p}{x}` for interior ones.

* When the current session already has cracked plaintexts (`<hash file>.out` exists and is non-empty), a picker offers those as the corpus ahead of a free-form path — the target's own recovered passwords derive rules describing that target's actual conventions, which is exactly what you want to fire back at the remaining uncracked hashes. Deriving from `.out` and then cracking the same hash file appends new plaintexts to that same file, growing the corpus for the next run; that is the intended feedback loop, not corruption. Sessions with no cracked output yet see no picker at all — just today's path prompt
* Prompts for the corpus, then for how much of the rule file to run: top 50% coverage (listed first and recommended), top 75%, top 95%, top 99%, or the full set
* Rules are sorted by how many passwords each one rebuilds, so a truncated file keeps the most productive rules. Coverage is extremely long-tailed: on a 98.2M-password sample, 50% coverage needed 4,120 rules while 95% needed 16,119,661 and 100% needed 21,029,696 — the last few percent typically costs orders of magnitude more rules than the first half, which is why the smallest tier is listed first and is usually the right choice
* Output is written beside the hash file in `<hash file>.spoonman/`, alongside the other ephemeral wordlists: `basewords.txt`, `rules.full.rule`, the capped rule files, and `coverage.txt` with per-milestone rule counts. Derivation is skipped on later runs of the same hash file unless the corpus has been modified since, and the directory is removed on exit by the temp-file cleanup
* Derivation is bounded in memory. Both counters would otherwise grow for the whole read with nothing written until the end, so a corpus large enough to exhaust RAM lost the entire pass to an OOM kill and produced no output; a measured run against a 31 GB corpus reached 14.1 GB resident at 11% of the file and was still accelerating. Each counter is now capped at 20 million distinct keys (about 1.6 GB apiece), and the lowest-frequency keys are discarded once it is exceeded. If that happens, the run says so on the console and in `coverage.txt`, the output reconstructs the retained keys rather than 100% of the corpus, and the coverage percentages are relative to those. Corpora below the cap are unaffected
* Passwords that cannot be expressed as a rule are written verbatim as their own baseword with a `:` no-op, so coverage stays complete. This covers two hashcat limits: rule positions cannot address past index 35, and hashcat rejects any rule with more than 31 functions — silently, when valid rules share the file
* The derivation self-checks every password by reconstructing it in-process, and reports any failures rather than reporting success
* Corpus lines may carry a hash in front of the password, as cracked output does. A leading field is dropped only when it has the shape of a hash (a hex digest at a known length, or a crypt-style `$id$` string), so `hash:salt:plain` is handled while a plaintext or wordlist entry containing a colon survives intact. `$HEX[...]` plaintexts are decoded. If most lines look like an uncracked dump rather than cracked output, `coverage.txt` records the count and the attack warns — the derived basewords and rules would otherwise be meaningless without any error being raised

#### Rosetta Attack
Mines hashcat `--debug-mode 5` logs for the basewords and rules that already cracked something, then runs their full cross product. Powered by [HashcatRosetta](https://github.com/bandrel/HashcatRosetta), the same library behind [Analyze Hashcat Rules](#analyze-hashcat-rules-rule-file-tools-option-5).

No setup is needed to feed it: `_add_debug_mode_for_rules` appends `--debug-mode 5 --debug-file` to every rule-based hashcat invocation hate_crack makes, so the logs accumulate in `hcatDebugLogPath` (`~/.hate_crack/hashcat_debug` by default, one file per session) as a side effect of normal use. A mode 5 log records only candidates that cracked a hash, in the form `baseword:rule:candidate:wordlist`, which is what makes both halves known-productive against this target population; the trailing wordlist field also shows which list is earning its keep on a multi-wordlist run. HashcatRosetta parses mode 4 and mode 5 alike, so logs written before the switch are still read.

The value is in the cross product rather than the recorded pairs. A pair present in a log has already cracked its hash and will not crack another, but a rule that worked on one baseword has usually never been tried against the others — so N basewords and M rules yield close to N x M untried candidates.

The menu first asks how to rank rules — choices 1-3 below, plus a fourth, unrelated mode:

* Rules can be ranked by application frequency, by how many distinct basewords each one worked on, or by how many unique candidates each one generated. Frequency is the default; baseword spread is the better choice when the goal is a rule set that generalizes past the specific words it was learned from
* Only after one of those three is picked does hate_crack list the logs found in `hcatDebugLogPath` newest-first with their sizes; pick one, pick all of them (up to 20), or type a path to a log from elsewhere
* Prompts for how many top rules to keep and how many top basewords. Both default to all — a blank answer keeps every winning rule the logs contain, and zero means the same thing. Enter a number to cap either. The keyspace is the product of the two and is printed before hashcat starts
* Output is written beside the hash file in `<hash file>.rosetta/` as `basewords.txt` and `rules.rule`, alongside the other ephemeral wordlists, and the directory is removed on exit by the temp-file cleanup
* Reading stops at 1,000,000 debug lines, since the analyzer needs the whole batch in memory at once. Truncation is reported on the console rather than assumed harmless — logs from a long run routinely exceed this, in which case the newest log is the one worth selecting
* **LLM Mask Attack** (4) - a different mode entirely, and the only one that needs no debug logs. Prompts for a natural-language description of the passwords you expect (length, character patterns, symbols, etc.), sends it to the locally configured Ollama model, writes the returned masks to `<hash file>.hcmask`, and runs a `-a 3` hashcat mask attack against them

#### Corporate Masks Brute Force
Statistical masks (8-14 characters) derived from analysis of 3.2M NTLM hashes cracked on real engagements. Powered by [Corporate_Masks](https://github.com/golem445/Corporate_Masks), these masks encode realistic password patterns from successful penetration tests.

* Prompts for minimum and maximum mask length (default 8-10)
* Longer lengths cost exponentially more keyspace—start with 8-10 for speed, or 8-12 for thoroughness
* Each mask file is run as a separate hashcat invocation in ascending length order
* Gracefully handles missing mask files (skips them) and absent submodule (prints warning and returns)
* Supports optimized kernels (`-O` flag) for faster cracking
* Ctrl-C during one length aborts remaining lengths

#### Wordlist Tools (option 80)
A submenu of wordlist preprocessing utilities using hashcat-utils binaries. All tools read from and write to files on disk. All file and directory path prompts support tab completion.

| Key | Tool | Description |
|-----|------|-------------|
| 1 | Filter by Length | Keep only words between a min and max length (`len.bin`) |
| 2 | Require Char Classes | Keep words that include all char classes in mask (`req-include.bin`). Mask: 1=lower, 2=upper, 4=digit, 8=symbol (additive) |
| 3 | Exclude Char Classes | Remove words containing any char class in mask (`req-exclude.bin`). Same mask encoding |
| 4 | Extract Substring | Cut bytes from each word at a given offset and optional length (`cutb.bin`) |
| 5 | Split by Length | Create per-length files in an output directory (`splitlen.bin`) |
| 6 | Subtract Wordlist | Remove lines from a wordlist that appear in one or more remove files. Mode 1 uses `rli2.bin` (single file); mode 2 uses `rli.bin` (multiple files) |
| 7 | Shard Wordlist | Split a wordlist into N equal, interleaved parts in one run, written as `base.001`…`base.00N` for distributed cracking (`gate.bin`) |
| 8 | Optimize Wordlists | Dedupe and split the selected wordlists into per-length files under an output directory |
| 9 | Download from Hashmob.net | Browse and download wordlists from Hashmob.net into the configured wordlist directory |
| 10 | Download from Weakpass | Browse and download Weakpass wordlist torrents, with automatic extraction |

All binaries are in `hate_crack/hashcat-utils/bin/`.

#### Rule File Tools (option 81)
Preprocesses hashcat rule files using `cleanup-rules.bin` and `rules_optimize.bin` from hashcat-utils, and downloads rule files from Hashmob.net.

* **Clean** (1) - removes invalid syntax and duplicate rules using `cleanup-rules.bin`. Useful after combining rule files or downloading rules from external sources.
* **Optimize** (2) - consolidates redundant operations using `rules_optimize.bin`. Reduces rule file size and improves cracking speed.
* **Clean and optimize** (3) - runs both operations in sequence via a temporary file, then writes the final result.
* **Download rules from Hashmob.net** (4) - fetches rule files into the configured `rulesDirectory`.
* **Analyze Hashcat rules** (5) - opcode frequency analysis of a rule file, powered by HashcatRosetta.

The three preprocessing operations read from an input file and write to a separate output file (original is never modified).

#### Download Rules from Hashmob.net (Rule File Tools option 4)
Downloads the latest rule files from Hashmob.net's rule repository. These rules are curated and optimized for password cracking and can be used with the Quick Crack and Loopback Attack modes.

* Downloads rule sets in parallel using a thread pool (up to 4 concurrent downloads)
* Skips rules already downloaded locally
* Reports download summary with success/failure counts
* Stores rules in the configured rules directory

#### Analyze Hashcat Rules (Rule File Tools option 5)
Powered by HashcatRosetta (https://github.com/bandrel/HashcatRosetta), this feature analyzes hashcat rule files to provide detailed insights into rule composition and complexity.

* Prompts for a rule file path
* Displays frequency analysis of rule opcodes (operations)
* Helps understand what transformations a rule set performs
* Useful for rule debugging and optimization

#### Download Wordlists from Hashmob.net (Wordlist Tools option 9)
Downloads wordlists from Hashmob.net's collection of cracked passwords and commonly used wordlists.

* Interactive menu for browsing available wordlists
* Progress tracking for large downloads
* Stores wordlists in configured wordlist directory

#### Weakpass Wordlist Menu (Wordlist Tools option 10)
Interactive menu for downloading and managing wordlists from Weakpass.com via BitTorrent.

* Browse available Weakpass wordlist torrents
* Download specific wordlists or entire collections
* Automatic extraction of compressed archives
* Progress tracking for torrent downloads

-------------------------------------------------------------------
### Version History

The full, per-release changelog now lives in [CHANGELOG.md](https://github.com/trustedsec/hate_crack/blob/HEAD/CHANGELOG.md).