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

Установка

Установка из исходного кода — единственный поддерживаемый способ. hate_crack не распространяется через PyPI: pip install hate-crack приводит к плейсхолдеру 0.0.0, который намеренно не работает и указывает обратно сюда. Имя удерживается только для того, чтобы никто другой не смог опубликовать под ним похожий инструмент — см. packaging/pypi-placeholder/.

1. Установка hashcat

Hashcat должен быть установлен и доступен в вашем PATH:

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

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

Или скачайте готовый бинарный файл с https://hashcat.net/hashcat/ и укажите hcatPath в config.json на его расположение.

2. Скачайте hate_crack

Клонируйте с субмодулями (требуется для hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks и, опционально, omen):```bash git clone --recurse-submodules https://github.com/trustedsec/hate_crack.git cd hate_crack

Если вы клонировали без подмодулей, инициализируйте их:```bash
git submodule update --init --recursive

Затем при необходимости настройте конфигурацию. hate_crack использует два конфигурационных файла, каждый из которых отвечает за свой набор параметров:

config.json — пути к словарям, маски, правила, тюнинг, potfile, путь к hashcat, лимиты кандидатов, переключатели уведомлений, стандартные настройки CLI (35 параметров).
.env — только настройки интеграции со сторонними сервисами: учётные данные Hashview и Hashmob, учётные данные Pushover, Ollama и pipal (14 параметров). Не отслеживается git, создаётся с режимом 0600.

Строка находится здесь по одной причине: .env — это файл, который может содержать секреты. Учётные данные и конфигурация сторонних сервисов хранятся в неотслеживаемом файле с режимом 0600; всё, что hate_crack делает локально, остаётся в config.json, который безопасно публиковать, сравнивать и добавлять в свои заметки. Именно поэтому учётные данные Pushover находятся в .env, а переключатели вкл/выкл Pushover — в config.json: переключатели — это локальные предпочтения, а не секреты.

У каждого ключа ровно одно место. Ключ, помещённый в другой файл, игнорируется, и hate_crack выводит предупреждение с указанием файла, в котором он должен находиться. Любой ключ всё равно можно переопределить для одного запуска, экспортировав его переменную окружения. Большинству пользователей этот шаг можно пропустить, так как пути по умолчанию работают сразу из коробки.

config.json является постоянным и полноценным — он не устарел, и для его удаления нет сроков. Перемещены только настройки интеграции.

Обновление с одного config.json? hate_crack перенесёт его за вас при первом запуске: настройки интеграции копируются в новый .env с режимом 0600, затем удаляются из config.json, чтобы оба файла не претендовали на них. Он выводит, какие ключи были перемещены (никогда их значения), и сохраняет ваш оригинал как config.json.pre-split.bak перед изменением. Всё остальное в config.json остаётся точно как было, включая порядок ключей.

Первый запуск: hate_crack создаёт оба файла за вас, так что делать ничего не нужно. Чтобы настроить .env вручную, скопируйте отслеживаемый шаблон:```bash cp .env.example .env chmod 600 .env

`.env.example` фиксируется в репозитории и поставляется со всеми ключами учётных данных пустыми. Сам `.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`), который автоматически определяет вашу ОС и устанавливает:
- Внешние зависимости (p7zip, transmission-daemon / transmission-remote)
- Собирает подмодули (hashcat-utils, princeprocessor, pcfg_cracker и, опционально, omen) и загружает набор масок Corporate_Masks, содержащий только данные
- Python-зависимости через uv и CLI-обёртку по пути `~/.local/bin/hate_crack````bash
make

Это идемпотентно — уже установленные инструменты пропускаются. Чтобы принудительно выполнить чистую переустановку:```bash make reinstall

**Или установите зависимости вручную:**

### Внешние зависимости
Они требуются для определённых процессов загрузки/извлечения:

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

macOS (Homebrew):```bash brew install p7zip transmission-cli # provides transmission-daemon and transmission-remote

Затем установите зависимости 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

Структура проекта

Основная логика теперь разделена на модули в каталоге hate_crack/:

hate_crack/cli.py: вспомогательные функции argparse и переопределения конфигурации.
hate_crack/api.py: интеграции с Hashview, Weakpass и Hashmob (загрузки/меню/вспомогательные функции).
hate_crack/attacks.py: обработчики атак из меню.
hate_crack/corpus_stats.py: статистика паролей по всему корпусу, используемая для описания корпуса LLM.
hate_crack/plaintext.py: восстанавливает пароль из строки корпуса (удаление префикса хеша, декодирование $HEX[...]); используется режимами LLM, corpus_stats и rulegen.
hate_crack/llm.py: структурированная (JSON) генерация кандидатов LLM через Atomic Agents.
hate_crack/menu.py: общий рендерер меню, включая необязательную навигацию стрелками.
hate_crack/noninteractive.py: диспетчер для подкоманд скриптованных атак.
hate_crack/notify/: пакет уведомлений (бэкенд Pushover, трекер для каждого взломанного пароля).
hate_crack/username_detect.py: определяет входные файлы вида username:hash, чтобы решить вопрос об использовании --username в hashcat.
hate_crack/formatting.py, hate_crack/progress.py: вспомогательные функции форматирования вывода и отображения прогресса.
hate_crack/main.py: основная реализация CLI.

Верхнеуровневый hate_crack.py остаётся главной точкой входа и координирует работу этих модулей.

Ссылки и благодарности

Этот проект зависит от ряда внешних проектов и сервисов и вдохновлён ими. Спасибо:

Использование

После установки с помощью make запускайте hate_crack откуда угодно:```bash hate_crack

or with arguments:

hate_crack <hash_file> <hash_type> [options]

Альтернативно, запустите через `uv`:```bash
uv run hate_crack.py <hash_file> <hash_type>

Запуск как инструмент (рекомендуется)

Установите с помощью make из корня репозитория — это собирает подмодули и объединяет ресурсы:```bash cd /path/to/hate_crack make hate_crack

Команда `make install` создаёт bash-обёртку в `~/.local/bin/hate_crack`, которая запускается из каталога репозитория, поэтому конфигурация и ресурсы всегда находятся независимо от вашей текущей рабочей директории.

Конфигурация также ищется в:
- Корне репозитория и каталоге пакета
- `~/.hate_crack`

**Примечание:** Поле `hcatPath` в `config.json` предназначено только для указания расположения бинарного файла hashcat (необязательно, если hashcat находится в PATH). Ресурсы Hate_crack (hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks, omen) загружаются из каталога репозитория и автоматически включаются командой `make install`.

### Запуск как скрипт
Скрипт использует shebang `uv`. Сделайте его исполняемым и запустите:```bash
chmod +x hate_crack.py
./hate_crack.py

Вы также можете использовать Python напрямую:```bash python 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

Устранение неполадок

Ошибка: «would clobber existing tag» при обновлении

Более старая копия репозитория может отказаться обновляться, выводя длинный список строк, например:``` ! [rejected] v2.5.0 -> v2.5.0 (would clobber existing tag)

Это касается клонов, созданных до июля 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

--force здесь только обновляет теги; он не может затрагивать ваши коммиты. После этого встроенный обновлятор работает нормально. Версии до 2.18 не могли выполнить это восстановление самостоятельно, поэтому его нужно сделать вручную один раз.

Ошибка: Каталог сборки не существует

Если вы видите ошибку вроде:``` Error: Build directory /opt/hashcat/hashcat-utils does not exist. Expected to find expander at /opt/hashcat/hashcat-utils/bin/expander.

Это означает, что ассеты hate_crack не были включены в установленный пакет.

**Понимание путей:**
- `hcatPath` в config.json → указывает на **расположение бинарного файла hashcat** (необязательно, может быть в PATH)
- `hashcat-utils/` и `princeprocessor/` → включаются в пакет с помощью `make install`

**Решение:**
Переустановите с помощью Makefile, который собирает подмодули и устанавливает инструмент:```bash
cd /path/to/hate_crack  # the repository checkout
make install

Конфигурация по умолчанию (config.json.example):

Большинству пользователей подойдут настройки по умолчанию без изменений:

hcatWordlists: ./wordlists (относительно корня репозитория или HOME/.hate_crack)
hcatOptimizedWordlists: ./optimized_wordlists (каталог, используемый Quick Crack; возвращается к hcatWordlists, если не найден)
rules_directory: ./hashcat/rules (включает правила подмодуля)
hcatTuning: `` (пустая строка — без флагов настройки по умолчанию)

Примеры настроек config.json:```json { "hcatPath": "/usr/local/bin", # Location of hashcat binary (optional, auto-detected from PATH) "hcatBin": "hashcat", # Hashcat binary name "hcatWordlists": "./wordlists", # Dictionary wordlist directory (relative or absolute) "rules_directory": "./hashcat/rules", # Rules directory (relative or absolute) "hcatTuning": "", # Additional hashcat flags (empty by default) ... }

**Загрузка конфигурации:**
- Приоритет для каждого ключа: `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

Прочитайте эти две строки перед отладкой настройки, которая «не срабатывает». Они существуют из-за двух ловушек в порядке поиска:

Каталог репозитория имеет приоритет над вашим домашним каталогом. Корень репозитория ищется первым, поэтому .env или config.json, лежащие в любом репозитории, из которого вы запускаете инструмент, перекрывают файл в ~/.hate_crack — а запуск инструмента из репозитория как раз и создаёт эти файлы там в первую очередь. Если это когда-либо затеняет реальную конфигурацию ~/.hate_crack, hate_crack теперь сообщает об этом третьей строкой [!], указывающей оба пути — воспринимайте эту строку как «файл ниже игнорируется», а не как вторую, равнозначную конфигурацию.
Текущий рабочий каталог никогда не ищется. .env в каталоге, где вы находитесь, игнорируется намеренно: рабочие каталоги проектов полны файлов, которые никто не задумывал как конфигурацию. Поместите его в корень репозитория или в ~/.hate_crack.

Ошибка: merge with ref 'refs/heads/master' but no such ref was fetched

Если вы видите:``` Your configuration specifies to merge with the ref 'refs/heads/master' from the remote, but no such ref was fetched.

The default branch was renamed from `master` to `main`. Fix with:```bash
git remote set-head origin -a
git branch -m master main
git branch --set-upstream-to=origin/main main
git pull

Цели Makefile

По умолчанию (полная установка) — собирает подмодули, устанавливает зависимости и устанавливает инструмент:```bash make

or explicitly:

make install

Это идемпотентно — пропускает уже установленные инструменты.

**Принудительная чистая переустановка:**```bash
make reinstall

Быстрое обновление — пересобирает подмодули и переустанавливает инструмент (после получения изменений):```bash make update

**Uninstall** — удаляет зависимости ОС и инструмент:```bash
make uninstall

Сборка только hashcat-utils:```bash make hashcat-utils

**Запуск тестов** — автоматически обрабатывает HATE_CRACK_SKIP_INIT при необходимости:```bash
make test

Отчёт о покрытии:```bash make coverage

**Чистка артефактов сборки/тестирования:**```bash
make clean

Разработка

Настройка среды разработки

Установите проект с дополнительными зависимостями для разработки (включает линтеры и инструменты тестирования):```bash make dev-install

### Запуск линтеров и проверок типов

Перед отправкой изменений выполните эти проверки локально. Используйте `make lint` для всего сразу или запускайте отдельные проверки:

**Ruff (линтинг и форматирование):**```bash
make ruff
# or manually:
uv run ruff check hate_crack tests tools packaging hate_crack.py

Автоматическое исправление проблем:```bash uv run ruff format hate_crack tests tools packaging hate_crack.py uv run ruff check --fix hate_crack tests tools packaging hate_crack.py

**ty (проверка типов):**```bash
make ty
# or manually:
uv run ty check hate_crack

Запустить все проверки вместе:```bash make lint

### Запуск тестов

Тесты автоматически определяют, когда подмодули не собраны, и автоматически устанавливают `HATE_CRACK_SKIP_INIT=1`.```bash
make test

Или запустите pytest напрямую:```bash uv run pytest -v

С покрытием:```bash
make coverage

Или с помощью pytest:```bash uv run pytest --cov=hate_crack

### Git Hooks (prek)

Git-хуки управляются с помощью [prek](https://github.com/j178/prek) (v0.3.3+). Установите хуки с помощью:```bash
prek install --hook-type pre-push --hook-type pre-commit

Это устанавливает хуки, определённые в prek.toml, с использованием схемы локального репозитория pre-commit:

pre-push (локальные хуки): ruff, ruff-format, ty, pytest, pytest-lima, bandit
pre-commit (из pre-commit/pre-commit-hooks): trailing-whitespace, end-of-file-fixer, check-yaml, check-merge-conflict, check-added-large-files, detect-private-key

Автоисправители pre-commit перезаписывают файлы на месте, поэтому после их запуска нужно снова выполнить индексацию и коммит.

Примечание: prek 0.3.3 ожидает repos = [...] на верхнем уровне. Старый формат [hooks.<stage>] commands = [...] не поддерживается.

Навигация по меню со стрелками

Меню по умолчанию используют классический выбор через нумерованный print() + input(), который принимает полные многозначные ключи.

Чтобы включить навигацию со стрелками через simple-term-menu, установите HATE_CRACK_ARROW_MENU=1. В этом режиме работают только однозначные клавиши быстрого доступа; до вариантов с номерами 10 и выше нужно добираться стрелками. Режим со стрелками также требует TTY, поэтому он отключается, когда вывод перенаправляется.

Зависимости для разработки

Дополнительная группа [dev] включает:

ty — статический проверщик типов
ruff — быстрый линтер и форматтер для Python
pytest — фреймворк для тестирования
pytest-cov — отчётность о покрытии

Общие параметры:

--download-hashview: Загрузить хеши из Hashview перед взломом.
--hashview: Интерактивное меню Hashview для управления хешами, словарями и заданиями.
--hashview --help: Показать параметры командной строки Hashview.
--weakpass: Загрузить словари из Weakpass.
--hashmob: Загрузить словари с Hashmob.net.
--hashmob-masks: Загрузить маски с Hashmob.net.
--download-torrent <FILENAME>: Загрузить конкретный торрент-файл Weakpass.
--download-all-torrents: Загрузить все доступные торренты Weakpass из кэша.
--wordlists-dir <PATH> / --optimized-wordlists-dir <PATH>: Переопределить каталоги словарей.
--pipal-path <PATH>: Переопределить путь к pipal.
--restore-potfile: Пересобрать <hashfile>.out из POT-файла hashcat при запуске, заменяя существующее содержимое, затем продолжить в обычное меню. Без этого флага поиск по POT выполняется только когда .out ещё не существует. Пункт меню 93 делает то же самое по запросу, с запросом подтверждения.
--maxruntime <SECONDS>: Переопределить максимальное время выполнения.
--bandrel-basewords <PATH>: Переопределить файл базовых слов bandrel.
--update: Обновить до последнего релиза и переустановить. Переключает checkout на main, если он находится на другой ветке, поскольку теги релизов находятся там.
--nightly: Вместо этого обновить до последней ночной сборки из ветки nightly-dev. Ночные сборки прошли CI, но не являются частью выпущенного релиза. Также можно записать как --update --nightly.
--no-optimized-kernel (или --no-optimize): Никогда не передавать -O в hashcat на протяжении всего запуска. Переопределяет optimizedKernelAttacks в config.json и удаляет любой -O, который вы добавили в hcatTuning. В конфиг ничего не записывается обратно, поэтому это применяется только к текущему запуску. С подкомандой ставьте его перед подкомандой: ./hate_crack.py --no-optimize quick hashes.txt 1000 --wordlist words.txt.
--debug: Включить отладочное логирование (записывается в stderr).

Интеграция с Hashview

hate_crack интегрируется с Hashview для централизованного управления хешами и распределённого взлома.

Интерактивное меню

Доступ к интерактивному меню Hashview:```bash hate_crack.py --hashview

Пункты меню:
- **(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

Загрузите список слов:```bash hate_crack.py --hashview upload-wordlist --file .txt --name "My Wordlist"

Скачайте файл правил (сохранённый в распакованном виде, готовый для `hashcat -r`):```bash
hate_crack.py --hashview download-rules --rules-id 4 --output best64.rule

Скачать оставшиеся хэши (невзломанные хэши для взлома):```bash hate_crack.py --hashview download-left --customer-id 1 --hashfile-id 123

Скачать найденные хэши (уже взломанные хэши с открытым текстом):```bash
hate_crack.py --hashview download-found --customer-id 1 --hashfile-id 123

Загрузите файл хэша и создайте задание:```bash hate_crack.py --hashview upload-hashfile-job --file hashes.txt --customer-id 1
--hash-type 1000 --job-name "NTLM Crack Job" --hashfile-name "Domain Hashes"

#### Конфигурация

Укажите учётные данные Hashview в файле `.env` (это настройки интеграции, поэтому они не хранятся в `config.json`):```
HASHVIEW_URL=https://hashview.example.com
HASHVIEW_API_KEY=your-api-key-here

Конфигурация LLM

Атака LLM (вариант 12) и атака Rosetta Mask (вариант 23) генерируют свои кандидаты с помощью локальной модели. Настройте модель, контекстное окно и таймаут запроса в .env:``` LLM_BACKEND=ollama OLLAMA_MODEL=qwen3:4b-instruct OLLAMA_NUM_CTX=8192 OLLAMA_TIMEOUT=300

**Ключи `OLLAMA_*` ниже применяются к каждому бэкенду, а не только к Ollama.** Они сохраняют этот префикс, потому что `OLLAMA_HOST` — это та же переменная, которую читает собственный CLI Ollama, и их переименование сломало бы каждый существующий `.env` без функциональной выгоды — серверу vLLM или совместимому с OpenAI нужны те же хост, модель, таймаут, контекст и параметры сэмплирования под теми же именами. `LLM_BACKEND` лишь выбирает, как формируется запрос.

- **`OLLAMA_MODEL`** — Модель Ollama, используемая для генерации кандидатов (по умолчанию: `qwen3:4b-instruct`). LLM-атака использует структурированный (JSON) вывод, поэтому выбирайте модель с хорошей поддержкой инструментов/JSON.
- **`OLLAMA_NUM_CTX`** — Размер окна контекста для модели (по умолчанию: `8192`). Ранее это было `2048` до введения статистики по корпусу, что было слишком мало для размещения подаваемого промпта: 500 отобранных открытых текстов занимают примерно 2000–3500 токенов до системного промпта и ответа, поэтому 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 через тот же локальный endpoint, что и локальную модель, поэтому запрос ничем не отличается — это отклоняется по имени модели. Также проверяется настроенный URL бэкенда: назначение, которое не является loopback, частным или link-local (и не является `localhost` или именем `.local`/`.internal`/`.lan`/`.localdomain`), отклоняется по назначению, а имя хоста, которое эта проверка не может разрешить, тоже отклоняется — с отказом по умолчанию (fail-closed), а не пропуском непроверяемого назначения. Промпты 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` или экспортируйте как настоящую переменную окружения, чтобы переопределить его для одного запуска — это то же имя переменной, которую читает собственный CLI Ollama.
- **`LLM_BACKEND`** — С каким сервером, совместимым с OpenAI, общаться: `ollama` (по умолчанию), `vllm` или `openai` для универсального. Каждый бэкенд говорит на одном и том же API `/v1` chat-completions, поэтому этот параметр выбирает только две детали формирования запроса, в которых они различаются: `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=""`. Установите реальное значение, если сервер требует его — сервер vLLM, запущенный с `--api-key`, иначе возвращает 401.
- Убедитесь, что Ollama запущен и модель загружена (`ollama pull qwen3:4b-instruct`) перед использованием LLM-атаки — 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:

Нажмите Enter, чтобы принять подсказку, или введите поверх неё. Эти значения — воспоминания модели, не OSINT — относитесь к ним как к отправной точке, а не как к разведданным о клиенте. Поиск использует только локальный сервер Ollama, поэтому имя клиента никогда не покидает хост; никаких веб- или сторонних API-вызовов не выполняется. Если модель не распознаёт организацию (обычный случай для небольших клиентов), она ничего не возвращает, и вы получаете просто пустые поля ввода: ``` Company name: Acme Rail Services Industry: Location: Parent company / acquired by:

Сбой исследования — таймаут, Ollama не запущена, пустой ответ — никогда не блокирует атаку; он просто переходит к пустым подсказкам. Установите `ollamaAutoResearch` в `false`, чтобы полностью пропустить исследование.
2. **Список слов** — извлечение базовых слов из образца списка слов.
3. **Взломанные пароли** — передача уже восстановленных в этой сессии открытых текстов (`<hashfile>.out`) обратно модели, чтобы она могла вывести собственные шаблоны паролей целевой организации (базовые слова, сезоны, годы, суффиксы, leetspeak) и генерировать *новые* кандидаты в том же стиле. Этот вариант отображается только после взлома хотя бы одного хэша; весь файл анализируется статистически точно так же, как в режиме списка слов (см. `ollamaMaxSampleLines` выше).

#### Конфигурация PCFG

Атака PCFG (вариант 20) и атака PRINCE-LING (вариант 21) используют подмодуль `pcfg_cracker`. Настройте их в `config.json`:```json
{
"pcfgRuleset": "DEFAULT",
"pcfgMaxCandidates": 50000000,
"pcfgPrinceLingMaxCandidates": 10000000
}

pcfgRuleset — Имя обученной грамматики для использования (по умолчанию: DEFAULT), разрешается в pcfg_cracker/Rules/<name>/. Обучите свою собственную с помощью trainer.py из pcfg_cracker и укажите имя набора правил.
pcfgMaxCandidates — Максимальное количество кандидатов, которые pcfg_guesser.py генерирует для PCFG-атаки (по умолчанию: 50000000).
pcfgPrinceLingMaxCandidates — Максимальное количество базовых слов, которые prince_ling.py записывает в кэшированный базовый список слов PRINCE (по умолчанию: 10000000).

Оптимизированные ядра (`optimizedKernelAttacks`)

Флаг -O в hashcat выбирает оптимизированные ядра, которые работают значительно быстрее, но ограничивают длину кандидатов (примерно 31 символ, для некоторых режимов меньше) и молча пропускают всё, что длиннее. optimizedKernelAttacks в config.json перечисляет атаки, которые запускаются с -O; исключите атаку из списка, чтобы запустить её с ядрами полной длины. Список в config.json.example соответствует встроенному значению по умолчанию, которое применяется, когда config.json отсутствует.

Четыре атаки учитывают эту настройку, но не оптимизированы по умолчанию, поскольку они подают кандидатов, которые могут превысить предел -O — добавьте их в список, чтобы включить:

hcatNgramX, hcatOllama, hcatOmen, hcatLMtoNT

Чтобы отключить -O везде для одного запуска без редактирования конфигурации, передайте --no-optimized-kernel (короткая форма --no-optimize). Он переопределяет список для каждой атаки, а также убирает -O, записанный в hcatTuning, который в противном случае достиг бы hashcat независимо от списка.

Имена сопоставляются точно, и нераспознанная запись сообщается при запуске, а не игнорируется. Обратите внимание, что атаки, которые делегируют другой атаке, управляются той атакой, которой они делегируют, а не собственным именем: PRINCE-LING следует за hcatPrince, а Spoonman, Rosetta и режимы LLM pattern-rule следуют за hcatQuickDictionary.

Отслеживание покрытия атак (`coverage_enabled`)

В ходе длительного взаимодействия один и тот же файл хэшей атакуется во многих сеансах с меняющимся набором списков слов, файлов правил и списков масок, и легко потратить часы, повторно прогоняя уже пройденную территорию — особенно потому, что одна и та же строка правила находится более чем в одном файле правил. hate_crack записывает, что уже было запущено против каждого файла хэшей, и предлагает пропустить пересечение.

Покрытие записывается по записи, а не по файлу: отдельные строки правил и отдельные строки .hcmask, каждая в паре со списком слов, против которого она запускалась. Именно это позволяет распознать, что пользовательский файл правил, который вы запускаете сегодня, повторяет 40 правил, которые best64.rule уже покрыл на прошлой неделе, и именно поэтому правило "покрыто" только для конкретного списка слов, с которым оно пробовалось — те же правила над другим корпусом пробуют совершенно других кандидатов.

Файл хэшей идентифицируется по sha256 его содержимого, поэтому покрытие сохраняется при переименовании или перемещении между сеансами. Списки слов идентифицируются тем же способом, при этом дайджест запоминается по размеру и mtime, чтобы многогигабайтный корпус хэшировался один раз, а не при каждой атаке.

Вам предлагается пропустить только тогда, когда действительно есть что пропустить:``` [*] Coverage: 40 of 45 rules in this Dictionary have already been run against this hash file. [?] Skip them and run only the 5 new rules? [Y/n]:

Отвечайте `Y` — и hate_crack создаст временный файл правил, содержащий только непроверенные записи; отвечайте `n`, чтобы прогнать всё целиком. Если *каждая* запись является повтором, вас спросят, пропустить ли атаку полностью, так что намеренный повтор уже пройденного участка никогда не потребует перезапуска инструмента.

Атаки, которые никогда не фильтруются, всё равно записываются как выполненные — именно это позволяет ответить на вопрос «я уже запускал PRINCE против этой цели?».

Атака, выбирающая сразу несколько файлов правил (Quick Crack, Loopback), задаёт вопрос о пропуске **один раз для всего пакета, заранее**, до любого вызова hashcat. Этот вопрос намеренно дешёвый — он не читает и не хэширует ни один из выбранных файлов правил, поскольку пакетный запуск YOLO может содержать миллионы строк, и вы не должны ждать этого, чтобы ответить «да» или «нет». Он спрашивает хранилище только о том, выполнялась ли эта атака против данного файла хэшей **с одним из этих словарей**; построчная проверка по-прежнему происходит лениво, по одному файлу правил за раз, и решает, что именно будет пропущено. Так что свежий корпус никогда не помечается, даже если правила по нему уже отработали на другом.

Три намеренных ограничения:

- **Покрытие записывается только когда hashcat исчерпывает пространство ключей** (код выхода 1). Ctrl-C или ошибка ничего не записывают, как и код выхода 0 — это означает, что взломаны все хэши, о чём hashcat сообщает *без* завершения пространства ключей, а в вырожденном случае «все хэши найдены как записи potfile» — без проверки ни одного кандидата. Недозапись стоит лишь лишнего повторного запуска позже.
- **Генераторы динамических кандидатов никогда не фильтруются.** PRINCE, PCFG, OMEN, марковский брутфорс и режимы LLM не имеют фиксированного набора для сравнения, поэтому они записываются как выполненные и в остальном не трогаются. Цепочки файлов правил (`-r a -r b`) отслеживаются как единое целое, а не по записям, потому что hashcat применяет *декартово произведение* двух файлов, и удаление отдельной строки молча убрало бы все комбинации, в которых она участвовала.
- **Запуски `--loopback` записываются, но никогда не фильтруются.** hashcat подаёт свежевзломанные открытые тексты обратно как *дополнительные* кандидаты, поэтому такой запуск пробует полный словарь и набор правил плюс всё, чего достигают эти переработанные открытые тексты. Это делает два направления асимметричными: запись корректна, так что более поздний обычный запуск того же словаря и правил правильно распознаётся как повтор, но второй запуск loopback имеет больше взломов для переработки и никогда не пропускается.

Установите `coverage_enabled` в `false` в `config.json`, чтобы отключить это, или передайте `--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

Файл хэша определяется по содержимому, поэтому эти проверки работают независимо от того, куда он был перемещён с тех пор. forget влияет только на эту одну цель — хранилище находится в ~/.hate_crack/coverage/attack_coverage.sqlite3, и удаление файла сбрасывает покрытие для всех целей.

Скриптовые запуски

Скриптовая атака, которую покрытие полностью пропускает, по умолчанию всё равно завершается с кодом 0, поэтому включение покрытия не может привести к сбою существующего конвейера. Передайте --exit-code-on-skip, чтобы получить код выхода 3 вместо этого, когда ничего не было запущено:```bash hate_crack --exit-code-on-skip hashes.txt dict

0 = ran, 1 = bad input, 2 = unknown command, 3 = everything was already covered

Выход 3 означает, что *ничего* не выполнялось. Прогон, который был частично отфильтрован — часть записей пропущена, часть опробована — всё равно завершается с кодом `0`, потому что атака действительно выполняла работу.

### Уведомления (пункт меню 82)

hate_crack может отправлять push-уведомления Pushover по завершении атак и, опционально, при взломе отдельных хэшей. Все настройки находятся в пункте главного меню `82 — Notifications`:

1. **Toggle Pushover Notifications [ON/OFF]** — главный переключатель. Сохраняется в `config.json` как `notify_enabled`.
2. **Toggle Per-Crack Notifications [ON/OFF]** — когда включено, фоновый наблюдатель следит за файлом `.out` и отправляет уведомление за каждый взлом (с агрегацией всплесков за тик). Сохраняется в `config.json` как `notify_per_crack_enabled`. Не может быть включено, пока главный переключатель выключен — сначала включите пункт 1.
3. **Send Test Pushover Notification** — отправляет тестовое уведомление, чтобы вы могли убедиться, что ваша пара токен/пользователь Pushover работает. Работает даже при выключенном главном переключателе.

Учётные данные хранятся в `.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)

Подменю Wordlist Tools предоставляет утилиты предобработки словарей на основе бинарников 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 равных непересекающихся частей, чтобы работу можно было распределить между несколькими машинами или GPU. Каждая часть *перемежается* (каждая N-я строка), поэтому каждый шард является репрезентативной выборкой всего списка, а не непрерывным фрагментом начала/конца — ни один узел не застревает на взломе только низковероятностного хвоста.

Запустите пункт 7 один раз, укажите входной словарь, базовый путь вывода и количество шардов (N). Он записывает все N частей за один проход, с именами с нулевым заполнением номеров частей (`base.001`, `base.002`, … до `base.00N`). Скопируйте одну часть на каждый узел и укажите её в запуске hashcat на этом узле. На системе с одним GPU шардирование не даёт ускорения, но одна часть всё равно остаётся быстрой репрезентативной выборкой для быстрого пробного прогона перед запуском полного списка.

#### Автоматическая проверка обновлений

hate_crack может автоматически проверять GitHub на наличие новых версий при запуске. Эта функция управляется параметром конфигурации `check_for_updates`:```json
{
  "check_for_updates": true
}

check_for_updates — Включить автоматическую проверку версий при запуске (по умолчанию: true).
При включении hate_crack получает последнюю информацию о релизах с GitHub и отображает уведомление, если доступно обновление.
Проверка выполняется асинхронно и не блокирует запуск. Сетевые ошибки молча игнорируются.

Каналы обновлений

Канал	Флаг	Источник	Что вы получаете
Release	`--update`	`main`	Последний выпущенный релиз. Это значение по умолчанию, и именно его предлагает проверка при запуске.
Nightly	`--nightly`	`nightly-dev`	Работа, прошедшая CI, но ещё не выпущенная.

Версии следуют обычному semver, при этом приращение определяется тем, что фактически находится в партии. Второй компонент изменяется только для функций: цикл, содержащий любой коммит feat, направляется к X.(Y+1).0, а цикл, состоящий только из исправлений, документации и рутинных задач, направляется к X.Y.(Z+1).

nightly-dev помечает кандидатов на выпуск для той версии, к которой движется партия — v2.20.1rc1, v2.20.1rc2, … — а слияние в main продвигает ту же цель до её финального релиза. Кандидаты являются настоящими предрелизами PEP 440, поэтому они корректно упорядочиваются на обоих концах:

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

Цель может измениться в середине цикла: первый появившийся feat перемещает её с X.Y.(Z+1) на X.(Y+1).0, и нумерация кандидатов перезапускается для новой цели. Число всегда указывает на то, чем партия была бы выпущена сегодня.

Старший компонент никогда не увеличивается автоматически — тема с ! или строка BREAKING CHANGE: считается функцией, потому что автоматический мажор — это одна ошибочно набранная строка темы от необратимого опубликованного релиза. Мажор — это осознанное действие человека: пометьте тегом и отправьте его вручную.

Политика находится в tools/next_version.py, используется обоими рабочими процессами тегирования и покрыта модульными тестами в tests/test_next_version.py.

Проверка при запуске предлагает только релизы, поскольку ночные сборки вообще не публикуют релизы на GitHub, а проверка читает конечную точку GitHub «latest release» — поэтому включение check_for_updates никогда не переведёт вас на ночную сборку. Две вещи разделяют каналы сейчас: это, а также тот факт, что кандидат — это настоящий предрелиз PEP 440, поэтому инструмент, ранжирующий сырые номера версий, также считает его более старым, чем релиз, которым он становится.

Любой из флагов сначала переключает ваш checkout на соответствующую ветку (и отказывается делать это, если у вас есть незакоммиченные изменения). Если вы запускаете ночную сборку и хотите вернуться к выпущенному коду, --update вернёт вас обратно на main.

Автоматическое объединение найденных хэшей (только при загрузке левых)

При загрузке левых хэшей (невзломанных хэшей) hate_crack автоматически:

Пытается загрузить любые найденные (взломанные) хэши из Hashview как вспомогательную операцию
Объединяет найденные хэши с локальными файлами .out (например, left_1_123.txt.out или left_1_123.nt.txt.out для формата pwdump)
Удаляет дублирующиеся записи
Очищает временные файлы разделения после объединения

Это гарантирует, что ваши локальные результаты взлома остаются синхронизированными с централизованной базой данных Hashview при работе с невзломанными хэшами.

Примечание: Опция загрузки найденных загружает уже взломанные хэши отдельно для справочных целей и не выполняет никакого объединения или запроса на взлом.

Значение <hash_type> получается при выполнении hashcat --help

I need the actual content of chunk 120 to translate it. Please provide the Markdown text you want translated.```
$ ./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

You can also run the full suite with `make test`.

### Live Tests (Opt-In)

Set any of the following to enable live checks:

- `HASHMOB_TEST_REAL=1` — live Hashmob connectivity/CLI menu check
- `HASHVIEW_TEST_REAL=1` — live Hashview CLI menu check
- `WEAKPASS_TEST_REAL=1` — live Weakpass CLI menu check
- `HATE_CRACK_REQUIRE_DEPS=1` — fail if `7z`, `transmission-daemon`, or `transmission-remote` is missing

### Live Hashview Upload Test

The live Hashview upload test is skipped by default. To run it, set the
environment variable and provide valid credentials in `.env`:```bash
HATE_CRACK_RUN_LIVE_TESTS=1 uv run pytest tests/test_upload_cracked_hashes.py -v

Живые тесты Hashview против локального стека Docker

Вместо того чтобы направлять живые тесты на удалённый сервер Hashview, вы можете заставить набор тестов развернуть локальный стек Docker Hashview, заполнить его данными, запустить живые тесты против него, а затем удалить его. Установите 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 compose` в репозитории Hashview, заполняет admin API-ключ,
клиента, hashfile и взломанные данные «эффективных задач», а затем экспортирует
переменные окружения `HASHVIEW_*`, которые читают тесты. Полезные переменные окружения:

- `HASHVIEW_TEST_LOCAL=1` — включить локальный стек (иначе бездействует)
- `HASHVIEW_REPO=<путь>` — каталог Hashview (по умолчанию `~/projects/hashview`)
- `HASHVIEW_KEEP=1` — оставить контейнеры запущенными после сессии (быстрее повторные запуски)
- `HASHVIEW_LOCAL_PORT=5000` — порт хоста, на котором опубликовано приложение

CLI hate_crack учитывает переменные окружения `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-based end-to-end install/run (cached via 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

Тестовая ВМ автоматически подготавливается со всеми зависимостями 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

Этот тест проверяет установку и выполнение в облегчённой Linux-виртуальной машине на macOS.

### Структура тестов

- **tests/test_hashview.py**: Комплексный набор тестов для класса HashviewAPI с имитацией ответов API, включая:
  - Получение списка заказчиков и проверку данных
  - Тесты аутентификации и авторизации
  - Функциональность загрузки файлов хэшей
  - Полный рабочий процесс создания задания

Все тесты используют имитацию вызовов API, поэтому их можно запускать без подключения к серверу Hashview.

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

  (1) Быстрый подбор
  (2) Расширенный подбор по методологии Pure_Hate
  (3) Атака перебором (Brute Force)
  (4) Атака по топовым маскам
  (5) Атака по отпечаткам (Fingerprint)
  (6) Комбинаторные атаки
  (7) Гибридная атака
  (8) Перебор по топ-100 маскам Pathwell
  (9) Атака PRINCE
  (10) Методология Bandrel
  (11) Атака Loopback
  (12) Атака LLM
  (13) Атака OMEN
  (14) Атака по произвольной маске
  (15) Перебор по цепям Маркова
  (16) Атака N-граммами
  (17) Атака перестановками
  (18) Атака случайными правилами
  (19) Атака парольными фразами Combipow
  (20) Атака PCFG
  (21) Атака PRINCE-LING
  (22) Атака Spoonman
  (23) Атака Rosetta
  (24) Перебор по корпоративным маскам
  (25) Атака по умным маскам

  (80) Инструменты для словарей
  (81) Инструменты для файлов правил
  (82) Уведомления
  (83) Инструменты для масок

  (93) Пересоздать .out из файла POT
  (94) Hashview API
  (95) Анализ хэшей с помощью Pipal
  (96) Экспорт результатов в формат Excel
  (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 - _ , + . &

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)
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 — 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 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
A password carrying a literal CR or LF (which arrives hex-wrapped, as $HEX[...0a]) cannot go in a baseword at all, because a wordlist line has no escape syntax for one. The break is lifted out into an insert op instead, spelled \x0a/\x0d in the rule, which hashcat decodes to the byte. When the break sits past addressable index 35 the rule reverses the word first, inserts from the other end, and reverses back. One frame has to hold every break in the password, so what is still skipped is a password with one break outside the first 36 characters and another outside the last 36, or one needing more inserts than the 31-function cap leaves room for. Those are counted as unwritable basewords in coverage.txt and reported, never dropped silently
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, the same library behind Analyze Hashcat Rules.

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, 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
11	Hashmob Downloads	Access a submenu for downloading Hashmob archives (yearly full-found corpora) and combined-left lists (per-mode uncracked hashes)

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

Mask Tools (option 83)

Downloads mask files from Hashmob.net. This is a minimal submenu today — masks have no local file-tooling counterpart to the rule/wordlist cleanup and optimization utilities, only a download capability.

Download masks from Hashmob.net (1) - fetches mask files into the hate_crack masks directory.

Download Masks from Hashmob.net (Mask Tools option 1)

Downloads mask files from Hashmob.net's mask repository into the hate_crack masks directory for use with mask-based attacks.

Downloads mask sets in parallel using a thread pool (up to 4 concurrent downloads)
Skips masks already downloaded locally
Reports download summary with success/failure counts
Stores masks in the configured masks directory used by the Ad-hoc Mask Attack
Supports interactive listing, range selection, and browsing of available mask files

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

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

Hashmob Downloads (Wordlist Tools option 11)

Access a submenu for downloading large-scale password corpora and specialized wordlists from Hashmob.net.

Archives - Downloads yearly full-found password corpora (multi-GB archives containing all cracked passwords from a given year)

Requires confirmation before downloading -- these archives are large (the listing may show "(unknown size)" since Hashmob's API doesn't currently report a file size per archive)
Lists all available archives across every year as one globally-numbered list to browse and pick from by index, rather than a per-year picker
Accepts a (or all) at the selection prompt to download every listed archive, one at a time. A single confirmation naming the archive count and the summed size covers the whole batch; an archive already on disk at its listed size is skipped, one whose size does not match is re-downloaded, and a failure is counted rather than aborting the rest
Stores archives in the configured wordlist directory for extraction and use

Combined Left Lists - Downloads per-hashcat-mode combined lists of uncracked ("left") hashes from Hashmob.net

Each list is a set of hashes, not plaintexts, still awaiting a crack for that hashcat mode
Useful for spotting overlap between your own hash list and hashes the community hasn't cracked yet
Supports mode selection from the listed hash counts per algorithm

Version History

The full, per-release changelog now lives in CHANGELOG.md.

hate_crack v2.36.1

Категории