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

macOS (होमब्रू):```bash
brew install hashcat

यदि आपने सबमॉड्यूल्स के बिना क्लोन किया है, तो उन्हें इनिशियलाइज़ करें:```bash
git submodule update --init --recursive

`.env.example` प्रतिबद्ध है और हर क्रेडेंशियल कुंजी खाली रखते हुए शिप होता है। `.env` को स्वयं **कभी** प्रतिबद्ध नहीं किया जाना चाहिए — यह gitignored है, इसके सामान्य बैकअप वर्तनी के साथ, और 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 shim बनाता है जो रिपॉजिटरी डायरेक्टरी से चलता है, इसलिए कॉन्फ़िग और एसेट्स हमेशा मिल जाते हैं, चाहे आपकी वर्तमान कार्यशील डायरेक्टरी कुछ भी हो।

कॉन्फ़िग को इन जगहों पर भी खोजा जाता है:
- रिपॉजिटरी रूट और पैकेज डायरेक्टरी
- `~/.hate_crack`

**नोट:** `config.json` में `hcatPath` केवल hashcat बाइनरी के स्थान के लिए है (वैकल्पिक यदि hashcat PATH में है)। Hate_crack एसेट्स (hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks, omen) रिपॉजिटरी डायरेक्टरी से लोड होते हैं और `make install` द्वारा स्वचालित रूप से बंडल किए जाते हैं।

### स्क्रिप्ट के रूप में चलाएँ
स्क्रिप्ट एक `uv` shebang का उपयोग करती है। इसे निष्पादन योग्य बनाएँ और चलाएँ:```bash
chmod +x hate_crack.py
./hate_crack.py

### गैर-इंटरैक्टिव / स्क्रिप्टेड उपयोग

ऑटोमेशन के लिए आप मेनू को बायपास करते हुए सीधे एक ही हमला लॉन्च कर सकते हैं। हमले का नाम पहला तर्क है, उसके बाद हैश फ़ाइल और हैशकैट हैश प्रकार आता है। प्रीप्रोसेसिंग प्रॉम्प्ट (कंप्यूटर-अकाउंट फ़िल्टरिंग, 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 से पहले बनाए गए क्लोन को प्रभावित करता है। प्रकाशित इतिहास को तब
फिर से लिखा गया था ताकि कुछ फ़ाइलों को हटाया जा सके जिन्हें कभी कमिट नहीं किया जाना चाहिए था, जिससे
हर कमिट को एक नया 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`**। पहला मैच जीतता है; दोनों फ़ाइलों का अलग-अलग डायरेक्टरी से आना सामान्य है।
- पहली बार चलाने पर, दोनों बनाई जाती हैं — `config.json` को `config.json.example` से, `.env` को बिल्ट-इन डिफ़ॉल्ट से। यदि पुराना `config.json` अभी भी इंटीग्रेशन कुंजियाँ रखता है, तो उन्हें नए `.env` में कॉपी किया जाता है और hate_crack आपको बताता है कि `config.json` से कौन-सी कुंजियाँ हटानी हैं; यह उस फ़ाइल को स्वयं कभी संपादित नहीं करता।
- हर बार चलाने पर, hate_crack उन दो फ़ाइलों को प्रिंट करता है जिन्हें उसने वास्तव में लोड किया था:  ```
  [*] 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

यह idempotent है - यह पहले से इंस्टॉल किए गए टूल्स को छोड़ देता है।

**फोर्स क्लीन रीइंस्टॉल:**```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 Hooks (prek)

Git हुक्स को [prek](https://github.com/j178/prek) (v0.3.3+) द्वारा प्रबंधित किया जाता है। हुक्स इनस्टॉल करें:```bash
prek install --hook-type pre-push --hook-type pre-commit

मेनू विकल्प:
- **(1) क्रैक किए गए हैश अपलोड करें** - वर्तमान सत्र से क्रैक किए गए परिणाम Hashview पर अपलोड करें
- **(2) वर्डलिस्ट अपलोड करें** - Hashview पर एक वर्डलिस्ट फ़ाइल अपलोड करें
- **(3) वर्डलिस्ट डाउनलोड करें** - Hashview से एक वर्डलिस्ट डाउनलोड करें
- **रूल डाउनलोड करें** - Hashview से एक रूल फ़ाइल डाउनलोड करें (प्लेनटेक्स्ट में डीकंप्रेस किया गया, `hashcat -r` के लिए तैयार)
- **सभी रूल डाउनलोड करें** - Hashview द्वारा सूचीबद्ध हर रूल फ़ाइल को एक ही बार में डाउनलोड करें; प्रति-रूल विफलताओं की रिपोर्ट बाकी को रोके बिना की जाती है
- **(4) बचे हुए हैश डाउनलोड करें** - शेष बिना क्रैक हुए हैश डाउनलोड करें (क्रैकिंग के लिए स्विच करने का संकेत देता है)
- **(5) मिले हुए हैश डाउनलोड करें** - क्लियरटेक्स्ट पासवर्ड के साथ पहले से क्रैक किए गए हैश डाउनलोड करें (संदर्भ/विश्लेषण के लिए)
- **(6) हैशफ़ाइल अपलोड करें और जॉब बनाएं** - नई हैशफ़ाइल अपलोड करें और क्रैकिंग जॉब बनाएं
- **(99) मुख्य मेनू पर वापस जाएं** - मुख्य मेनू पर लौटें

**महत्वपूर्ण: मिले हुए हैश डाउनलोड करें बनाम बचे हुए हैश डाउनलोड करें**
- **बचे हुए हैश डाउनलोड करें (4)**: बिना क्रैक हुए हैश डाउनलोड करता है जिन्हें क्रैक करने की आवश्यकता है। उपलब्ध होने पर किसी भी मिले हुए हैश के साथ स्वचालित रूप से विलय हो जाता है, और क्रैकिंग के लिए इस हैशफ़ाइल पर स्विच करने का संकेत देता है।
- **मिले हुए हैश डाउनलोड करें (5)**: hash:cleartext प्रारूप में पहले से क्रैक किए गए हैश डाउनलोड करता है। ये संदर्भ के लिए हैं और इन्हें आगे क्रैक नहीं किया जा सकता। कोई स्विच संकेत नहीं दिखाया जाता।

#### कमांड-लाइन इंटरफ़ेस

Hashview ऑपरेशन कमांड-लाइन के माध्यम से भी किए जा सकते हैं:

क्रैक किए गए हैश अपलोड करें:```bash
hate_crack.py --hashview upload-cracked --file <output_file>.out --hash-type 1000

Download a rule file (saved decompressed, ready for `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_*` कुंजियाँ नीचे हर बैकएंड पर लागू होती हैं, सिर्फ़ Ollama पर नहीं।** वे यह उपसर्ग इसलिए रखती हैं क्योंकि `OLLAMA_HOST` वही वेरिएबल है जिसे Ollama का अपना CLI पढ़ता है, और उन्हें नाम बदलने से बिना किसी कार्यात्मक लाभ के हर मौजूदा `.env` टूट जाएगा — एक vLLM या OpenAI-संगत सर्वर भी वही होस्ट, मॉडल, टाइमआउट, कॉन्टेक्स्ट और सैंपलिंग नॉब्स समान नामों के तहत चाहता है। `LLM_BACKEND` केवल यह चुनता है कि अनुरोध कैसे आकार दिया जाए।

- **`OLLAMA_MODEL`** — उम्मीदवार निर्माण के लिए उपयोग किया जाने वाला Ollama मॉडल (डिफ़ॉल्ट: `qwen3:4b-instruct`)। 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` हो, तो तीनों LLM बैकएंड (Ollama, vLLM, या सामान्य OpenAI-संगत सर्वर) में से किसी के लिए भी इस होस्ट से कुछ भी भेजने से मना करें। इस एक सेटिंग द्वारा दो जाँचें नियंत्रित होती हैं: 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` पर सेट करें (धीमे मॉडल के साथ उपयोगी, क्योंकि शोध हमले शुरू होने से पहले एक अतिरिक्त राउंड-ट्रिप खर्च करता है)।
- **`OLLAMA_HOST`** — कॉन्फ़िगर किया गया बैकएंड कहाँ सुन रहा है। एक सादा `host:port` (`theplague.lan:11434`) या स्कीम के साथ पूर्ण URL (`https://ollama.example.com`) स्वीकार करता है; किसी भी तरह से उपयोग से पहले बेस URL सामान्यीकृत किया जाता है। डिफ़ॉल्ट `localhost:11434` है, जो Ollama का पोर्ट है — एक vLLM या OpenAI-संगत सर्वर को इसे अपने पोर्ट पर सेट करने की आवश्यकता होती है (vLLM आमतौर पर `:8000` पर सुनता है)। इसे `.env` में सेट करें, या एकल रन के लिए इसे ओवरराइड करने हेतु वास्तविक पर्यावरण वेरिएबल के रूप में निर्यात करें — यह वही वेरिएबल नाम है जिसे Ollama का अपना CLI पढ़ता है।
- **`LLM_BACKEND`** — किस OpenAI-संगत सर्वर से बात करनी है: `ollama` (डिफ़ॉल्ट), `vllm`, या सामान्य के लिए `openai`। हर बैकएंड समान `/v1` चैट-कम्प्लीशन API बोलता है, इसलिए यह केवल उन दो अनुरोध-आकार देने वाले विवरणों का चयन करता है जिनमें वे भिन्न हैं: `ollama` को `options.num_ctx` मिलता है, और `vllm` को `chat_template_kwargs={"thinking": false}` मिलता है — जिसके बिना एक रीज़निंग पार्सर चलाने वाला vLLM सर्वर पूरे संरचित प्रतिक्रिया को `message.reasoning` में भेज देता है, `message.content` खाली छोड़ देता है, और JSON पार्सिंग तोड़ देता है। `openai` न तो भेजता है, क्योंकि वहाँ `num_ctx` का कोई समकक्ष नहीं है। यह **नहीं** बदलता कि होस्ट, मॉडल, टाइमआउट, कॉन्टेक्स्ट, या सैंपलिंग सेटिंग्स कहाँ से आती हैं — वे तीनों के लिए उपरोक्त `OLLAMA_*` कुंजियाँ हैं।
- **`LLM_API_KEY`** — कॉन्फ़िगर किए गए बैकएंड को भेजा गया क्रेडेंशियल। डिफ़ॉल्ट शाब्दिक `ollama` है, वह प्लेसहोल्डर जिसे Ollama का अपना सर्वर अनदेखा करता है, इसलिए मौजूदा इंस्टॉलेशन के अनुरोध अपरिवर्तित रहते हैं; एक खाली मान उसी प्लेसहोल्डर पर वापस आ जाता है क्योंकि OpenAI SDK `api_key=""` को अस्वीकार करता है। यदि सर्वर कोई लागू करता है तो इसे वास्तविक मान पर सेट करें — `--api-key` के साथ शुरू किया गया vLLM सर्वर अन्यथा 401 लौटाता है।
- LLM Attack का उपयोग करने से पहले सुनिश्चित करें कि Ollama चल रहा है और मॉडल खींचा गया है (`ollama pull qwen3:4b-instruct`) — hate_crack अब गायब मॉडलों को स्वतः खींचता नहीं है।

हमला तीन जनरेशन मोड प्रदान करता है:

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. **Wordlist** — एक नमूना wordlist से basewords प्राप्त करें।
3. **Cracked passwords** — इस सत्र में पहले से पुनर्प्राप्त किए गए plaintexts (`<hashfile>.out`) को मॉडल को वापस फीड करें ताकि यह लक्षित संगठन की अपनी पासवर्ड परंपराओं (basewords, seasons, years, suffixes, leetspeak) का अनुमान लगा सके और उसी शैली में *नए* उम्मीदवार उत्पन्न कर सके। यह विकल्प केवल तभी सूचीबद्ध होता है जब कम से कम एक हैश क्रैक हो चुका हो; पूरी फ़ाइल का सांख्यिकीय रूप से ठीक Wordlist मोड की तरह विश्लेषण किया जाता है (ऊपर `ollamaMaxSampleLines` देखें)।

#### PCFG कॉन्फ़िगरेशन

PCFG Attack (विकल्प 20) और PRINCE-LING Attack (विकल्प 21) `pcfg_cracker` सबमॉड्यूल का उपयोग करते हैं। उन्हें `config.json` में कॉन्फ़िगर करें:```json
{
"pcfgRuleset": "DEFAULT",
"pcfgMaxCandidates": 50000000,
"pcfgPrinceLingMaxCandidates": 10000000
}

उत्तर `Y` दें और hate_crack एक अस्थायी नियम फ़ाइल बनाता है जिसमें केवल अप्रयुक्त
प्रविष्टियाँ होती हैं; पूरी चीज़ वैसे भी चलाने के लिए `n` उत्तर दें। यदि *हर* प्रविष्टि दोहराई गई है
तो आपसे पूछा जाता है कि क्या हमले को पूरी तरह छोड़ देना है, ताकि जानबूझकर कवर किए गए
क्षेत्र को फिर से चलाने के लिए टूल को कभी पुनः आरंभ करने की आवश्यकता न पड़े।

जो हमले कभी फ़िल्टर नहीं होते, उन्हें फिर भी चलाए जाने के रूप में दर्ज किया जाता है, जो आपको
यह उत्तर देने में सक्षम बनाता है कि "क्या मैंने पहले ही इस लक्ष्य के विरुद्ध PRINCE चला लिया है?"।

एक हमला जो एक साथ कई नियम फ़ाइलें चुनता है (Quick Crack, Loopback) स्किप प्रश्न
**पूरे बैच के लिए एक बार, शुरू में ही** पूछता है, किसी भी hashcat आह्वान से पहले।
वह प्रश्न जानबूझकर सस्ता है — यह चयनित नियम फ़ाइलों में से किसी को पढ़ता या हैश नहीं करता,
क्योंकि एक YOLO बैच लाखों पंक्तियों तक चल सकता है और आपको हाँ/नहीं का उत्तर देने के लिए
उससे गुज़रने का इंतज़ार नहीं करना चाहिए। यह स्टोर से केवल यह पूछता है कि क्या यह हमला
पहले ही इस हैश फ़ाइल के विरुद्ध **इनमें से किसी एक वर्डलिस्ट के साथ** चल चुका है;
प्रति-प्रविष्टि अंतर अभी भी आलसी तरीके से, एक समय में एक नियम फ़ाइल, होता है और तय करता है
कि वास्तव में क्या छोड़ा जाता है। इसलिए एक नया कॉर्पस कभी फ़्लैग नहीं होता, भले ही
उस पर मौजूद नियम किसी भिन्न एक के विरुद्ध चल चुके हों।

तीन जानबूझकर सीमाएँ:

- **कवरेज केवल तब दर्ज किया जाता है जब hashcat कीस्पेस समाप्त कर देता है** (exit 1)। एक
  ctrl-C या एक त्रुटि कुछ भी दर्ज नहीं करती, और exit 0 भी नहीं — इसका मतलब है कि हर हैश
  क्रैक हो गया, जिसे hashcat कीस्पेस समाप्त किए *बिना* रिपोर्ट करता है, और अध:पतित
  "सभी हैश potfile प्रविष्टियों के रूप में मिले" मामले में एक भी उम्मीदवार आज़माए बिना।
  कम-दर्ज करने से केवल बाद में एक अनावश्यक पुनः चलाने की लागत आती है।
- **गतिशील उम्मीदवार जनरेटर कभी फ़िल्टर नहीं होते।** PRINCE, PCFG, OMEN,
  Markov brute force और LLM मोड में तुलना करने के लिए कोई निश्चित सेट नहीं होता, इसलिए उन्हें
  चलाए जाने के रूप में लॉग किया जाता है और अन्यथा अकेला छोड़ दिया जाता है। श्रृंखलाबद्ध नियम फ़ाइलें (`-r a -r b`)
  को प्रति प्रविष्टि के बजाय एक इकाई के रूप में ट्रैक किया जाता है, क्योंकि hashcat दोनों फ़ाइलों का
  *कार्तीय गुणनफल* लागू करता है और एक व्यक्तिगत पंक्ति को हटाने से उसका हर संयोजन
  चुपचाप हट जाएगा जिसमें वह भाग लेती थी।
- **`--loopback` रन दर्ज किए जाते हैं लेकिन कभी फ़िल्टर नहीं होते।** hashcat ताज़ा क्रैक किए गए
  प्लेनटेक्स्ट को *अतिरिक्त* उम्मीदवारों के रूप में वापस फीड करता है, इसलिए ऐसा रन पूरी वर्डलिस्ट
  और नियम सेट के साथ-साथ वह सब कुछ आज़माता है जो उन पुनर्चक्रित प्लेनटेक्स्ट तक पहुँचते हैं। यह
  दोनों दिशाओं को असममित बनाता है: इसे दर्ज करना सही है, इसलिए उसी वर्डलिस्ट और नियमों का एक बाद का
  सामान्य रन सही ढंग से एक दोहराव के रूप में पहचाना जाता है, लेकिन एक दूसरे
  loopback रन में पुनर्चक्रित करने के लिए अधिक क्रैक होते हैं और इसे कभी स्किप नहीं किया जाता।

इसे बंद करने के लिए `config.json` में `coverage_enabled` को `false` पर सेट करें, या एकल रन के लिए
`--no-coverage` पास करें — जो स्टोर से न तो परामर्श करता है और न ही उसे अपडेट करता है।

#### कवरेज का निरीक्षण और रीसेट करना

मुख्य-मेनू विकल्प **85 — Attack Coverage** दिखाता है कि लोड की गई हैश फ़ाइल के विरुद्ध क्या चलाया गया है,
उसका रन इतिहास, और इसे साफ़ कर सकता है। वही तीन क्रियाएँ स्क्रिप्ट योग्य हैं:```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

बाहर निकलने का कोड 3 का मतलब है कि *कुछ भी* नहीं चला। एक पास जो आंशिक रूप से फ़िल्टर किया गया था — कुछ प्रविष्टियाँ छोड़ी गईं, कुछ आज़माई गईं — फिर भी `0` के साथ बाहर निकलता है, क्योंकि हमले ने काम किया था।

### सूचनाएँ (मेनू विकल्प 82)

hate_crack हमले पूरे होने पर और, वैकल्पिक रूप से, व्यक्तिगत हैश क्रैक होने पर Pushover पुश सूचनाएँ भेज सकता है। सभी नियंत्रण मुख्य-मेनू विकल्प `82 — Notifications` के अंतर्गत रहते हैं:

1. **Toggle Pushover Notifications [ON/OFF]** — मुख्य स्विच। `config.json` में `notify_enabled` के रूप में सहेजा जाता है।
2. **Toggle Per-Crack Notifications [ON/OFF]** — जब ON होता है, तो एक पृष्ठभूमि टेलर `.out` फ़ाइल पर नज़र रखता है और प्रति क्रैक एक सूचना भेजता है (प्रति-टिक बर्स्ट एकत्रीकरण के साथ)। `config.json` में `notify_per_crack_enabled` के रूप में सहेजा जाता है। मुख्य स्विच OFF होने पर इसे सक्षम नहीं किया जा सकता — पहले विकल्प 1 सक्षम करें।
3. **Send Test Pushover Notification** — एक पूर्व-निर्धारित पुश भेजता है ताकि आप पुष्टि कर सकें कि आपका 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` | शब्द घटाएँ - प्रविष्टियाँ हटाएँ जो एक या अधिक अन्य फ़ाइलों में दिखाई देती हैं |
| 7 | `gate.bin` | शार्ड - एकाधिक मशीनों पर वितरित क्रैकिंग के लिए हर N-वाँ शब्द निकालें |
| 8 | - | वर्डलिस्ट अनुकूलित करें - अनुकूलित वर्डलिस्ट निर्देशिका के अंतर्गत डीडुप और प्रति-लंबाई फ़ाइलों में विभाजित करें |
| 9 | - | Hashmob.net से वर्डलिस्ट डाउनलोड करें |
| 10 | - | Weakpass से वर्डलिस्ट डाउनलोड करें (BitTorrent के माध्यम से) |

**वर्ण वर्ग मास्क बिट्स** (विकल्प 2 और 3 द्वारा उपयोग किए जाते हैं): `1`=लोअरकेस, `2`=अपरकेस, `4`=अंक, `8`=प्रतीक, `16`=अन्य। मानों को एक साथ जोड़ें: `7` = लोअरकेस+अपरकेस+अंक।

**शार्डिंग का उपयोग कैसे करना है**: शार्डिंग एक वर्डलिस्ट को N समान, गैर-अतिव्यापी भागों में विभाजित करती है ताकि काम को एकाधिक मशीनों या GPUs में फैलाया जा सके। प्रत्येक भाग *इंटरलीव्ड* (हर N-वीं पंक्ति) होता है, इसलिए हर शार्ड पूरी सूची का एक प्रतिनिधि नमूना होता है, न कि एक सन्निहित आगे/पीछे का हिस्सा — कोई भी एक नोड केवल कम-संभावना वाली पूँछ को क्रैक करने में अटका नहीं रहता।

विकल्प 7 एक बार चलाएँ, इसे एक इनपुट वर्डलिस्ट, एक आउटपुट आधार पथ और एक शार्ड संख्या (N) दें। यह सभी N भागों को एक ही पास में लिखता है, जिन्हें शून्य-पैडेड भाग संख्याओं (`base.001`, `base.002`, … से `base.00N` तक) के साथ नामित किया जाता है। प्रत्येक नोड पर एक भाग कॉपी करें और उस नोड के hashcat रन को उस पर इंगित करें। एकल-GPU सिस्टम पर शार्डिंग कोई गति नहीं देती, लेकिन पूरी सूची के लिए प्रतिबद्ध होने से पहले त्वरित ट्राइएज पास के लिए एक भाग अभी भी एक तेज़, प्रतिनिधि नमूना है।

#### स्वचालित अपडेट जाँच

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

यहाँ आपका अनुवाद है:

```markdown
यह सुनिश्चित करने के लिए कि आपका कार्यान्वयन सही है, आपको अपने परीक्षण वातावरण में निम्नलिखित कमांड चलाने की आवश्यकता हो सकती है:

```bash
python3 -m pip install -r requirements.txt

python3 main.py --help

from toolkit import Scanner

scanner = Scanner()
results = scanner.scan("example.com")

$ ./hate_crack.py <hash file> 1000

  ___ ___         __             _________                       __
 /   |   \_____ _/  |_  ____     \_   ___ \____________    ____ |  | __
/    ~    \__  \\   __\/ __ \    /    \  \/\_  __ \__  \ _/ ___\|  |/ /
\    Y    // __ \|  | \  ___/    \     \____|  | \// __ \\  \___|    <
 \___|_  /(____  /__|  \___  >____\______  /|__|  (____  /\___  >__|_ \
       \/      \/          \/_____/      \/            \/     \/     \/
                          Version 2.0
```
## परीक्षण

परीक्षण सूट अधिकतर ऑफ़लाइन है और मॉक्स/फिक्स्चर का उपयोग करता है। लाइव नेटवर्क जाँच और
सिस्टम निर्भरता जाँच पर्यावरण चर के माध्यम से वैकल्पिक (ऑप्ट-इन) हैं।

### स्थानीय रूप से परीक्षण चलाना```bash
# Run all tests
uv run pytest -v

# Run specific test
uv run pytest tests/test_hashview.py -v
```
आप पूरा सूट `make test` के साथ भी चला सकते हैं।

### लाइव टेस्ट (ऑप्ट-इन)

लाइव जाँच सक्षम करने के लिए निम्न में से कोई भी सेट करें:

- `HASHMOB_TEST_REAL=1` — लाइव Hashmob कनेक्टिविटी/CLI मेनू जाँच
- `HASHVIEW_TEST_REAL=1` — लाइव Hashview CLI मेनू जाँच
- `WEAKPASS_TEST_REAL=1` — लाइव Weakpass CLI मेनू जाँच
- `HATE_CRACK_REQUIRE_DEPS=1` — यदि `7z`, `transmission-daemon`, या `transmission-remote` गायब है तो विफल हो जाएँ

### लाइव Hashview अपलोड टेस्ट

लाइव Hashview अपलोड टेस्ट डिफ़ॉल्ट रूप से छोड़ दिया जाता है। इसे चलाने के लिए, पर्यावरण
चर सेट करें और `.env` में मान्य क्रेडेंशियल प्रदान करें:```bash
HATE_CRACK_RUN_LIVE_TESTS=1 uv run pytest tests/test_upload_cracked_hashes.py -v
```
### लाइव हैशव्यू टेस्ट एक स्थानीय डॉकर स्टैक के विरुद्ध

लाइव टेस्ट को किसी दूरस्थ हैशव्यू सर्वर पर इंगित करने के बजाय, आप सूट को एक स्थानीय [Hashview](https://github.com/hashview/hashview) डॉकर स्टैक स्पिन करने, उसे सीड करने, उसके विरुद्ध लाइव टेस्ट चलाने, और उसे टियर डाउन करने दे सकते हैं। `HASHVIEW_TEST_LOCAL=1` सेट करें और `HASHVIEW_REPO` को हैशव्यू चेकआउट पर इंगित करें:```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
```
यह Hashview रिपॉजिटरी में `docker compose` लाता है, एक एडमिन API key, एक ग्राहक, एक हैशफाइल, और क्रैक किया गया "प्रभावी कार्य" डेटा सीड करता है, फिर उन `HASHVIEW_*` env vars को एक्सपोर्ट करता है जिन्हें टेस्ट पढ़ते हैं। उपयोगी env vars:

- `HASHVIEW_TEST_LOCAL=1` — लोकल स्टैक सक्षम करें (अन्यथा कोई प्रभाव नहीं)
- `HASHVIEW_REPO=<path>` — Hashview चेकआउट (डिफ़ॉल्ट `~/projects/hashview`)
- `HASHVIEW_KEEP=1` — सत्र के बाद कंटेनर चालू रखें (तेज़ पुनः-रन के लिए)
- `HASHVIEW_LOCAL_PORT=5000` — होस्ट पोर्ट जिस पर ऐप प्रकाशित है

hate_crack CLI `HASHVIEW_URL` / `HASHVIEW_API_KEY` पर्यावरण चरों का सम्मान करता है (उन दो कुंजियों वाले `.env` को ओवरराइड करते हुए), जो सूट को आपके सहेजे गए कॉन्फ़िग को संपादित किए बिना CLI को लोकल स्टैक की ओर इंगित करने देता है।

### एंड-टू-एंड इंस्टॉल टेस्ट (लोकल + Docker)

लोकल uv टूल इंस्टॉल + स्क्रिप्ट निष्पादन (अस्थायी HOME का उपयोग करता है):```bash
HATE_CRACK_RUN_E2E=1 uv run pytest tests/test_e2e_local_install.py -v
```
Docker-आधारित एंड-टू-एंड इंस्टॉल/रन (`Dockerfile.test` के माध्यम से कैश किया गया):```bash
HATE_CRACK_RUN_DOCKER_TESTS=1 uv run pytest tests/test_docker_script_install.py -v
```
Docker E2E परीक्षण rockyou का एक छोटा उपसमुच्चय भी डाउनलोड करता है और बाहरी टूल एकीकरण को मान्य करने के लिए एक बुनियादी hashcat क्रैक चलाता है।

Lima VM एंड-टू-एंड परीक्षण (केवल macOS):

पूर्वापेक्षाएँ: [Lima](https://lima-vm.io/) और `rsync` स्थापित होना चाहिए।```bash
brew install lima
```
परीक्षण 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
```
यह परीक्षण macOS पर एक हल्के Linux VM के भीतर इंस्टॉलेशन और निष्पादन को मान्य करता है।

### परीक्षण संरचना

- **tests/test_hashview.py**: मॉक किए गए API प्रतिक्रियाओं के साथ HashviewAPI क्लास के लिए व्यापक परीक्षण सूट, जिसमें शामिल हैं:
  - ग्राहक सूची और डेटा सत्यापन
  - प्रमाणीकरण और प्राधिकरण परीक्षण
  - हैशफ़ाइल अपलोड कार्यक्षमता
  - पूर्ण जॉब निर्माण वर्कफ़्लो

सभी परीक्षण मॉक किए गए API कॉल का उपयोग करते हैं, इसलिए वे Hashview सर्वर से कनेक्टिविटी के बिना चल सकते हैं।

-------------------------------------------------------------------

  (1) क्विक क्रैक
  (2) व्यापक Pure_Hate मेथडोलॉजी क्रैक
  (3) ब्रूट फोर्स अटैक
  (4) टॉप मास्क अटैक
  (5) फिंगरप्रिंट अटैक
  (6) कॉम्बिनेटर अटैक
  (7) हाइब्रिड अटैक
  (8) Pathwell टॉप 100 मास्क ब्रूट फोर्स क्रैक
  (9) PRINCE अटैक
  (10) बैंड्रेल मेथडोलॉजी
  (11) लूपबैक अटैक
  (12) LLM अटैक
  (13) OMEN अटैक
  (14) एड-हॉक मास्क अटैक
  (15) मार्कोव ब्रूट फोर्स अटैक
  (16) एन-ग्राम अटैक
  (17) परम्यूटेशन अटैक
  (18) रैंडम रूल्स अटैक
  (19) कॉम्बिपॉव पासफ्रेज़ अटैक
  (20) PCFG अटैक
  (21) PRINCE-LING अटैक
  (22) स्पूनमैन अटैक
  (23) रोसेटा अटैक
  (24) कॉर्पोरेट मास्क ब्रूट फोर्स
  (25) स्मार्ट मास्क अटैक

  (80) वर्डलिस्ट टूल्स
  (81) रूल फ़ाइल टूल्स
  (82) नोटिफिकेशन
  (83) मास्क टूल्स

  (93) POT फ़ाइल से .out पुनर्जनरेट करें
  (94) Hashview API
  (95) Pipal के साथ हैश का विश्लेषण करें
  (96) एक्सेल फॉर्मेट में आउटपुट निर्यात करें
  (97) क्रैक किए गए हैश प्रदर्शित करें
  (98) README प्रदर्शित करें
  (99) बाहर निकलें

कोई कार्य चुनें:```

Option `94 — Hashview API` is only listed when `HASHVIEW_API_KEY` is set in `.env`.

The YOLO, Middle, and Thorough Combinator attacks were previously at keys 10-12. They now live in the Combinator Attacks submenu (option 6) along with Combinator3 and CombinatorX.
-------------------------------------------------------------------
#### Quick Crack
Runs a dictionary attack against wordlists in your `hcatOptimizedWordlists` directory (falls back to `hcatWordlists` if not configured) and optionally applies rules. Multiple rules can be selected by comma-separated list, and chains can be created with the '+' symbol. Pressing Enter at the wordlist prompt uses the configured optimized wordlists directory as the default.

Selecting a directory — including that default — expands to the wordlists
directly inside it before hashcat runs. Subdirectories are not searched,
matching hashcat's own behaviour for a directory in the dictionary position, and
dot-files and `.7z`/`.torrent`/`.out` files are skipped, which hashcat would
otherwise try to read. The candidates are the same either way; the expansion is
what lets attack coverage track each wordlist separately, since a directory has
no content fingerprint to key on. If the expansion finds nothing — an empty
directory, or one holding only subdirectories or archives — the attack aborts
rather than launching hashcat with no wordlist, which would put it in stdin
mode and leave it reading the terminal.

```
आप कौन सा/कौन से नियम चलाना चाहेंगे?
(1) best64.rule
(2) d3ad0ne.rule
(3) T0XlC.rule
(4) dive.rule
(99) YOLO...सभी नियम चलाएँ
उन नियमों की अल्पविराम से अलग की गई सूची दर्ज करें जिन्हें आप चलाना चाहते हैं। श्रृंखलाबद्ध नियम चलाने के लिए + चिह्न का उपयोग करें।
उदाहरण के लिए 1+1 best64.rule को दो बार श्रृंखलाबद्ध रूप से चलाएगा और 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. Every qualifying pattern runs against the full remaining hash list, so other accounts sharing a stem get swept up even though brute-forcing the stem itself was never tried.

Patterns with a fixed run at either end -- nearly all of them -- are grouped by mask and run as hybrid attacks (`-a 6` when the mask trails the stem, `-a 7` when it leads), with every pattern's literal stem a line in that group's wordlist. Dozens of patterns that vary the same way therefore become one hashcat pass over one wordlist rather than one mask line each. Whatever cannot be grouped that way -- variation at *both* ends, which leaves no fixed run to seed a wordlist with -- falls back to a single `-a 3` mask file, and has its charsets widened (up to `?a`) to compensate, as far as the guardrail below allows.

Prompts once, before the attack starts, for an optional per-pattern candidate-count guardrail (default 50,000,000,000; 0 disables it) that excludes any individual pattern whose keyspace is too large without blocking the rest.

#### 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 sixteen hybrid passes per wordlist, cheapest first. Each mask length
  from 1 to 4 is tried appended and then prepended, first over `?s?d` and then
  over `?a`, and a single ctrl-C abandons the whole attack rather than only the
  current pass.
  - Hybrid Wordlist + Mask - ?s?d wordlists/rockyou.txt ?1
  - Hybrid Mask + Wordlist - ?s?d ?1 wordlists/rockyou.txt
  - ... the same for ?1?1, ?1?1?1 and ?1?1?1?1
  - Hybrid Wordlist + Mask - wordlists/rockyou.txt ?a
  - Hybrid Mask + Wordlist - ?a wordlists/rockyou.txt
  - ... the same for ?a?a, ?a?a?a and ?a?a?a?a

  `?a` is every printable character, so the second group is a superset of the
  first plus letters and roughly 24x the work at the longest mask — over
  rockyou.txt those passes alone are ~1.2e15 candidates, about ten hours for
  NTLM on hardware doing 32 GH/s. That is why the cheap `?s?d` group runs first
  and why the attack as a whole is time-bounded:

  - `hcatHybridMaxRuntime` in `config.json`, in seconds, default `3600`, is the
    time the **whole attack** may spend — not the time one pass may spend. All
    sixteen passes share one deadline, and each is handed whatever is left of it
    as hashcat's `--runtime`. Any pass the budget does not reach is reported
    rather than skipped quietly. Set it to `0` for no limit, which runs every
    pass to exhaustion.

  Within each group the order is by mask length across every wordlist rather
  than all lengths of one wordlist and then the next, so a budget that runs out
  has still given every wordlist its cheap passes.

  Each pass declares what it covers to the attack-coverage store, so a repeat
  hybrid against the same hash file offers to skip the passes already run. A
  pass that runs out of budget is not recorded, so it will be retried.
  Wordlist entries may be glob patterns or directories; both are expanded
  before hashcat runs, a directory into the wordlists directly inside it.
  Subdirectories are not searched, matching hashcat's own behaviour, and
  dot-files and `.7z`/`.torrent`/`.out` files are skipped — a Weakpass
  download leaves archives in the wordlists directory and hashcat would
  otherwise try to read them.

#### 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 LLM — Ollama by default, or a vLLM / OpenAI-compatible server via `LLM_BACKEND` — 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 server at `OLLAMA_HOST` (default: `http://localhost:11434`, Ollama's port; override in `.env` or the environment) already serving the model — hate_crack does not auto-pull
* Candidate generation uses structured (JSON) output via Atomic Agents, so pick a model with good schema adherence (default: `qwen3:4b-instruct`)
* Configurable backend, model, context window, request timeout, and sample size via `.env` (see [LLM Configuration](#llm-configuration))
* 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)