업데이트로 돌아가기
New releaseSep 4, 2026

hate_crack v2.36.1

TrustedSec 팀의 Hashcat을 통한 크래킹 방법론 자동화 도구.

공유
  ___ ___         __             _________                       __
 /   |   \_____ _/  |_  ____     \_   ___ \____________    ____ |  | __
/    ~    \__  \\   __\/ __ \    /    \  \/\_  __ \__  \ _/ ___\|  |/ /
\    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

Or pre-built binary는 https://hashcat.net/hashcat/ 에서 다운로드하고, config.json의 hcatPath를 해당 위치로 설정하세요.

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에 남아 있어 공유, diff, 자신의 메모에 체크인하기에 안전하다. 이것이 Pushover 자격 증명은 .env에 있고 Pushover 켜기/끄기 토글은 config.json에 있는 이유이기도 하다 — 토글은 로컬 기본 설정이지 비밀이 아니다.

각 키에는 정확히 하나의 소속처가 있다. 다른 파일에 배치된 키는 무시되며, hate_crack은 해당 키가 속한 파일 이름을 알리는 경고를 출력한다. 모든 키는 환경 변수를 내보내 단일 실행에 대해 여전히 재정의할 수 있다. 대부분의 사용자는 기본 경로가 즉시 작동하므로 이 단계를 건너뛸 수 있다.

config.json은 영구적이며 일급 객체이다 — 더 이상 사용되지 않으며 제거 일정도 없다. 통합 설정만 이동했다.

단일 config.json에서 업그레이드하는 경우? hate_crack은 첫 실행 시 이를 자동으로 마이그레이션한다: 통합 설정이 새 0600 .env로 복사된 다음 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`)를 실행하는 것입니다. 이 명령은 OS를 자동 감지하여 다음을 설치합니다:
- 외부 의존성 (p7zip, transmission-daemon / transmission-remote)
- 서브모듈 빌드 (hashcat-utils, princeprocessor, pcfg_cracker, 선택적으로 omen) 및 데이터 전용 Corporate_Masks 마스크 세트 체크아웃
- uv를 통한 Python 의존성 및 `~/.local/bin/hate_crack`의 CLI 셔임(shim)```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 셸(shim)을 설치합니다:```bash
uv sync
mkdir -p ~/.local/bin
printf '#!/usr/bin/env bash\nset -euo pipefail\nexec uv run --directory %s python -m hate_crack "$@"\n' "$(pwd)" > ~/.local/bin/hate_crack
chmod +x ~/.local/bin/hate_crack

프로젝트 구조

핵심 로직은 이제 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: Atomic Agents를 통한 구조화된(JSON) LLM 후보 생성.
  • hate_crack/menu.py: 선택적 화살표 키 탐색을 포함한 공유 메뉴 렌더러.
  • hate_crack/noninteractive.py: 스크립트화된 공격 하위 명령의 디스패처.
  • hate_crack/notify/: 알림 패키지(Pushover 백엔드, 크랙별 tailer).
  • hate_crack/username_detect.py: hashcat의 --username을 결정하기 위해 username:hash 입력 파일을 감지합니다.
  • 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` 명령은 `~/.local/bin/hate_crack`에 bash 셸 래퍼를 생성하며, 이는 저장소 디렉터리에서 실행되므로 현재 작업 디렉터리와 관계없이 구성 및 자산이 항상 발견됩니다.

구성은 다음 위치에서도 검색됩니다:
- 저장소 루트 및 패키지 디렉터리
- `~/.hate_crack`

**참고:** `config.json`의 `hcatPath`는 hashcat 바이너리 위치 전용입니다(hashcat이 PATH에 있는 경우 선택 사항). Hate_crack 자산(hashcat-utils, princeprocessor, pcfg_cracker, Corporate_Masks, omen)은 저장소 디렉터리에서 로드되며 `make install`에 의해 자동으로 번들됩니다.

### 스크립트로 실행
스크립트는 `uv` 셔뱅을 사용합니다. 실행 가능하게 만들고 실행하세요:```bash
chmod +x hate_crack.py
./hate_crack.py

Python을 직접 사용할 수도 있습니다:```bash python hate_crack.py

### 비대화형 / 스크립트 사용

자동화를 위해 메뉴를 거치지 않고 단일 공격을 직접 실행할 수 있습니다. 공격 이름이 첫 번째 인수이며, 그다음에 해시 파일과 hashcat 해시 유형이 옵니다. 전처리 프롬프트(컴퓨터 계정 필터링, LM 우선 무차별 대입, 중복 계정 제거)는 이 모드에서 기본값을 자동으로 수락합니다. 프로세스는 성공 시 `0`으로 종료되고, 오류(해시 파일 누락, 숫자가 아닌 해시 유형, 단어 목록 누락, 또는 알 수 없는 규칙 파일 이름) 시 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년 7월 이전에 생성된 클론에 영향을 줍니다. 게시된 기록은 그때 커밋되어서는 안 됐던 일부 파일을 제거하기 위해 다시 작성되었으며, 이로 인해 모든 커밋에 새 ID가 부여되었습니다. 따라서 이전 클론의 태그는 이 저장소에 더 이상 포함되지 않는 객체를 가리키며, git은 이미 보유한 태그를 이동시키기를 거부합니다. 체크아웃에 문제가 있는 것이 아니며, 크래킹 데이터가 위험에 처한 것도 아닙니다.

일회성 리셋으로 복구하세요. 이는 체크아웃의 로컬 커밋과 편집 내용을 폐기하므로, git이 추적하는 항목(`config.json`은 추적되지 않으므로 제외)을 사용자 지정한 경우 먼저 브랜치에 커밋하세요:```bash
cd /path/to/hate_crack
git fetch --tags --force origin
git checkout -B main origin/main
make install

--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 자산이 설치된 패키지에 번들로 포함되지 않았음을 의미합니다.

**경로 이해하기:**
- config.json의 `hcatPath` → **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에 넣으세요.

오류: 'refs/heads/master' 참조와 병합하지만 해당 참조는 가져오지 않았습니다

다음과 같은 메시지가 표시되면:``` Your configuration specifies to merge with the ref 'refs/heads/master' from the remote, but no such ref was fetched.

기본 브랜치가 `master`에서 `main`으로 변경되었습니다. 다음과 같이 수정하세요:```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

**제거** - OS 종속성 및 도구를 제거합니다:```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

Or run pytest directly:```bash uv run pytest -v

커버리지 포함:```bash
make coverage

Or with 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

이 명령은 pre-commit 로컬 저장소 TOML 스키마를 사용하여 prek.toml에 정의된 훅을 설치합니다:

  • 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: 시작 시 hashcat POT 파일에서 <hashfile>.out을 다시 빌드하여 기존 내용을 대체한 다음 일반 메뉴로 계속 진행합니다. 이 플래그가 없으면 POT 조회는 .out이 아직 존재하지 않을 때만 실행됩니다. 메뉴 옵션 93은 확인 프롬프트와 함께 요청 시 동일한 작업을 수행합니다.
  • --maxruntime <SECONDS>: 최대 런타임을 재정의합니다.
  • --bandrel-basewords <PATH>: bandrel 기본 단어 파일을 재정의합니다.
  • --update: 최신 릴리스로 업데이트하고 다시 설치합니다. 릴리스 태그가 있는 곳이므로 다른 분기에 있으면 체크아웃을 main으로 전환합니다.
  • --nightly: 대신 nightly-dev 분기에서 최신 나이틀리로 업데이트합니다. 나이틀리는 CI를 통과했지만 공식 릴리스의 일부는 아닙니다. --update --nightly로도 작성할 수 있습니다.
  • --no-optimized-kernel (또는 --no-optimize): 전체 실행 동안 hashcat에 -O를 절대 전달하지 않습니다. config.json의 optimizedKernelAttacks를 재정의하고 hcatTuning에 넣은 -O를 제거합니다. 구성에 다시 기록되지 않으므로 이 실행에만 적용됩니다. 하위 명령과 함께 사용할 경우 하위 명령 앞에 배치하세요: ./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"

#### 구성

`.env` 파일에 Hashview 자격 증명을 설정하세요 (`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`가 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 공격을 사용하기 전에 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:

Enter 키를 눌러 제안을 수락하거나 그 위에 직접 입력하세요. 이 값들은 모델이 회상한 것이며 OSINT가 아닙니다 — 시작점으로만 취급하고, 클라이언트에 대한 정보로 간주하지 마세요. 조회는 로컬 Ollama 서버만 사용하므로 클라이언트 이름이 호스트를 벗어나지 않습니다. 웹이나 제3자 API 호출은 없습니다. 모델이 조직을 인식하지 못하는 경우(소규모 클라이언트에서 흔한 경우) 아무것도 반환하지 않으며, 빈 프롬프트만 표시됩니다: ``` Company name: Acme Rail Services Industry: Location: Parent company / acquired by:

연구 실패(타임아웃, Ollama 미실행, 빈 응답)는 공격을 절대 차단하지 않으며, 단지 빈 프롬프트로 대체될 뿐입니다. 연구를 완전히 건너뛰려면 `ollamaAutoResearch`를 `false`로 설정하세요.
2. **단어 목록(Wordlist)** — 샘플 단어 목록에서 기본 단어(baseword)를 도출합니다.
3. **크랙된 비밀번호** — 이번 세션에서 이미 복구된 평문(`<hashfile>.out`)을 모델에 다시 입력하여 대상 조직 고유의 비밀번호 규칙(기본 단어, 계절, 연도, 접미사, leetspeak)을 추론하게 하고, 동일한 스타일의 *새로운* 후보를 생성하게 합니다. 이 옵션은 해시가 하나 이상 크랙된 경우에만 목록에 표시되며, 전체 파일은 Wordlist 모드와 정확히 동일하게 통계적으로 분석됩니다(위의 `ollamaMaxSampleLines` 참조).

#### PCFG 구성

PCFG 공격(옵션 20)과 PRINCE-LING 공격(옵션 21)은 `pcfg_cracker` 하위 모듈을 사용합니다. `config.json`에서 다음과 같이 구성하세요:```json
{
"pcfgRuleset": "DEFAULT",
"pcfgMaxCandidates": 50000000,
"pcfgPrinceLingMaxCandidates": 10000000
}
  • pcfgRuleset — 사용할 학습된 문법의 이름 (기본값: DEFAULT), pcfg_cracker/Rules/<name>/로 확인됩니다. pcfg_cracker의 trainer.py로 직접 학습시키고 이 값을 규칙 세트 이름으로 설정하세요.
  • pcfgMaxCandidates — PCFG 공격에서 pcfg_guesser.py가 생성하는 최대 후보 수 (기본값: 50000000).
  • pcfgPrinceLingMaxCandidates — prince_ling.py가 캐시된 PRINCE 기본 단어 목록에 기록하는 최대 기본 단어 수 (기본값: 10000000).

최적화된 커널 (optimizedKernelAttacks)

hashcat의 -O 플래그는 최적화된 커널을 선택하며, 이는 훨씬 빠르지만 후보 길이를 제한하고(대략 31자, 일부 모드에서는 더 낮음) 더 긴 항목은 조용히 건너뜁니다. config.json의 optimizedKernelAttacks는 -O로 실행되는 공격을 나열합니다. 목록에서 공격을 제외하면 전체 길이 커널로 실행됩니다. config.json.example의 목록은 config.json이 없을 때 적용되는 기본 제공 설정과 일치합니다.

네 가지 공격은 이 설정을 따르지만 기본적으로 최적화되지 않습니다. 이는 -O 상한을 초과할 수 있는 후보를 공급하기 때문입니다. 목록에 추가하여 선택할 수 있습니다:

  • hcatNgramX, hcatOllama, hcatOmen, hcatLMtoNT

설정을 편집하지 않고 단일 실행에서 모든 곳의 -O를 끄려면 --no-optimized-kernel(약식 --no-optimize)을 전달하세요. 이는 모든 공격의 목록을 재정의하고, 그렇지 않으면 목록과 무관하게 hashcat에 도달할 hcatTuning에 기록된 -O도 제거합니다.

이름은 정확히 일치하며, 인식되지 않는 항목은 무시되지 않고 시작 시 보고됩니다. 다른 공격에 위임하는 공격은 자신의 이름이 아닌 위임 대상 공격에 의해 제어됩니다. PRINCE-LING은 hcatPrince를 따르고, Spoonman, Rosetta 및 LLM 패턴 규칙 모드는 hcatQuickDictionary를 따릅니다.

공격 범위 추적 (coverage_enabled)

긴 작업 기간 동안 동일한 해시 파일이 회전하는 단어 목록, 규칙 파일 및 마스크 목록 세트로 여러 세션에서 공격받으며, 이미 처리한 영역을 다시 실행하는 데 시간을 낭비하기 쉽습니다. 특히 동일한 규칙 줄이 둘 이상의 규칙 파일에 존재하기 때문입니다. hate_crack은 각 해시 파일에 대해 이미 실행한 내용을 기록하고 겹치는 부분을 건너뛸 것을 제안합니다.

범위는 파일이 아닌 항목별로 기록됩니다. 개별 규칙 줄과 개별 .hcmask 줄이 각각 실행된 단어 목록과 쌍을 이룹니다. 이것이 오늘 실행하는 사용자 지정 규칙 파일이 지난주 best64.rule이 이미 처리한 규칙 40개를 반복한다는 것을 인식할 수 있게 하며, 규칙이 시도된 특정 단어 목록에 대해서만 "처리됨"으로 간주되는 이유이기도 합니다. 다른 말뭉치에 대한 동일한 규칙은 완전히 다른 후보를 시도합니다.

해시 파일은 내용의 sha256으로 식별되므로 세션 간에 이름을 바꾸거나 이동해도 범위 추적이 유지됩니다. 단어 목록도 동일한 방식으로 식별되며, 다이제스트는 크기와 수정 시간에 대해 메모화되어 수 기가바이트의 말뭉치가 매 공격마다가 아니라 한 번만 해시됩니다.

건너뛸 항목이 실제로 있을 때만 프롬프트가 표시됩니다:``` [*] 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, Markov 무차별 대입 및 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

해시 파일은 내용으로 식별되므로, 이후 어디로 이동되었든 관계없이 동작합니다. forget는 해당 대상 하나에만 영향을 미칩니다. 저장소는 ~/.hate_crack/coverage/attack_coverage.sqlite3에 있으며, 파일을 삭제하면 모든 대상에 대한 커버리지가 초기화됩니다.

스크립트 실행

커버리지가 완전히 건너뛴 스크립트 실행은 기본적으로 여전히 0으로 종료되므로, 커버리지를 활성화해도 기존 하네스가 실패하기 시작하지 않습니다. 아무것도 실행되지 않았을 때 종료 코드 3을 받으려면 --exit-code-on-skip을 전달하세요.```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은 공격이 완료될 때, 그리고 선택적으로 개별 해시가 크랙될 때 Pushover 푸시 알림을 보낼 수 있습니다. 모든 제어는 메인 메뉴 옵션 `82 — 알림` 아래에 있습니다:

1. **Pushover 알림 토글 [ON/OFF]** — 마스터 스위치. `config.json`에 `notify_enabled`로 저장됩니다.
2. **크랙별 알림 토글 [ON/OFF]** — ON으로 설정하면 백그라운드 테일러가 `.out` 파일을 감시하고 크랙마다 알림을 푸시합니다(틱당 버스트 집계 포함). `config.json`에 `notify_per_crack_enabled`로 저장됩니다. 마스터 스위치가 OFF인 동안에는 활성화할 수 없습니다 — 먼저 옵션 1을 활성화하세요.
3. **테스트 Pushover 알림 보내기** — Pushover 토큰/사용자 쌍이 작동하는지 확인할 수 있도록 미리 준비된 푸시를 발송합니다. 마스터 스위치가 OFF인 경우에도 작동합니다.

자격 증명은 `.env`에 있으며, 나머지 튜닝 옵션은 `config.json`에서 설정 파일 전용입니다:

- `NOTIFY_PUSHOVER_TOKEN`, `NOTIFY_PUSHOVER_USER` (`.env`에 있음) — 푸시가 발송되려면 필수입니다. 메뉴에서 이 값을 쓰는 항목은 없습니다. 직접 `.env`를 편집하세요.
- `notify_attack_allowlist` — `[y/N/always]` 프롬프트 없이 자동 동의하는 공격 이름 목록. `always`로 답하면 자동으로 채워집니다.
- `notify_suppress_in_orchestrators` (기본값 `true`) — Extensive Crack이 연결하는 개별 공격의 알림을 음소거하며, 대신 단일 요약 알림을 발송합니다. 연결된 공격마다 알림을 받으려면 `false`로 설정하세요. 여러 패스를 실행하는 다른 메뉴 항목(예: 여러 규칙 체인이 있는 Quick Crack)은 오케스트레이터가 아니며 항상 패스별로 알림을 보냅니다.
- `notify_max_cracks_per_burst` (기본값 `5`), `notify_poll_interval_seconds` (기본값 `5.0`) — 크랙별 테일러 튜닝. 버스트 집계 로직은 `hate_crack/notify/tailer.py`를 참조하세요.

### 단어 목록 도구 (메뉴 옵션 80)

단어 목록 도구 하위 메뉴는 hashcat-utils 바이너리로 구동되는 단어 목록 전처리 유틸리티와 Hashmob.net 및 Weakpass의 단어 목록 다운로드를 제공합니다. 메인 메뉴의 옵션 **80**으로 접근하세요.

| 옵션 | 바이너리 | 기능 |
|--------|--------|--------------|
| 1 | `len.bin` | 길이로 필터링 — 최소 및 최대 길이 사이의 단어만 유지 |
| 2 | `req-include.bin` | 문자 클래스 요구 — 필요한 모든 문자 유형을 포함하는 단어만 유지 |
| 3 | `req-exclude.bin` | 문자 클래스 제외 — 제외된 문자 유형을 포함하는 단어 제거 |
| 4 | `cutb.bin` | 부분 문자열 추출 — 각 단어에서 바이트 범위 잘라내기 |
| 5 | `splitlen.bin` | 길이로 분할 — 단어 길이별로 별도 파일 생성(출력 디렉터리에 `01`-`64`로 명명된 파일) |
| 6 | `rli.bin` / `rli2.bin` | 단어 빼기 — 하나 이상의 다른 파일에 나타나는 항목 제거 |
| 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개의 모든 부분을 0으로 채워진 부분 번호(`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에서 최신 릴리스 정보를 가져와 업데이트가 있으면 알림을 표시합니다.
  • 이 확인은 비동기적으로 실행되며 시작을 차단하지 않습니다. 네트워크 오류는 조용히 무시됩니다.
업데이트 채널
채널플래그소스제공 내용
릴리스--updatemain가장 최근에 공식 출시된 릴리스입니다. 기본값이며 시작 시 확인에서 제공하는 항목입니다.
나이틀리--nightlynightly-devCI를 통과했지만 아직 릴리스되지 않은 작업입니다.

버전은 일반적인 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의 "최신 릴리스" 엔드포인트를 읽기 때문입니다 — 따라서 check_for_updates를 활성화해도 나이틀리로 전환되지 않습니다. 지금 채널을 분리하는 두 가지 요소는 다음과 같습니다: 바로 그 점과, 후보가 진정한 PEP 440 사전 릴리스이므로 원시 버전 번호를 정렬하는 도구도 이를 릴리스가 되는 버전보다 오래된 것으로 취급한다는 점입니다.

두 플래그 중 하나를 사용하면 먼저 체크아웃을 해당 분기로 전환합니다 (커밋되지 않은 변경 사항이 있으면 거부합니다). 나이틀리를 실행 중이고 릴리스된 코드로 돌아가려면 --update가 main으로 다시 이동시킵니다.

자동 발견 해시 병합 (왼쪽 다운로드 전용)

왼쪽 해시(크랙되지 않은 해시)를 다운로드할 때 hate_crack은 자동으로:

  1. 보조 작업으로 Hashview에서 발견된(크랙된) 해시 다운로드를 시도합니다
  2. 발견된 해시를 로컬 .out 파일(예: pwdump 형식의 left_1_123.txt.out 또는 left_1_123.nt.txt.out)과 병합합니다
  3. 중복 항목을 제거합니다
  4. 병합 후 임시 분할 파일을 정리합니다

이렇게 하면 크랙되지 않은 해시로 작업할 때 로컬 크래킹 결과가 Hashview의 중앙 데이터베이스와 동기화된 상태로 유지됩니다.

참고: 발견 해시 다운로드 옵션은 이미 크랙된 해시를 참조용으로 별도로 다운로드하며, 병합을 수행하거나 크래킹을 요청하지 않습니다.

<hash_type>은 hashcat --help를 실행하여 얻습니다.

예시 해시: http://hashcat.net/wiki/doku.php?id=example_hashes``` $ hashcat --help |grep -i ntlm 5500 | NetNTLMv1 | Network protocols 5500 | NetNTLMv1 + ESS | Network protocols 5600 | NetNTLMv2 | Network protocols 1000 | NTLM | Operating-Systems

# Chunk 120

## 4.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.```
$ ./hate_crack.py <hash file> 1000

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

테스트

테스트 스위트는 대부분 오프라인으로 실행되며 목(mocks)/픽스처(fixtures)를 사용합니다. 실시간 네트워크 검사와 시스템 종속성 검사는 환경 변수를 통해 선택적으로 활성화됩니다.

로컬에서 테스트 실행하기```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

로컬 Docker 스택에 대한 라이브 Hashview 테스트

라이브 테스트를 원격 Hashview 서버가 아닌 로컬에서 실행하려면, 테스트 스위트가 로컬 Hashview Docker 스택을 시작하고, 시드(seed)한 다음, 이에 대해 라이브 테스트를 실행하고, 마지막으로 스택을 종료하도록 할 수 있습니다. 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

이렇게 하면 Hashview 저장소에서 `docker compose`가 실행되어 관리자 API 키, 고객, 해시 파일, 크랙된 "유효 작업" 데이터를 시드한 다음 테스트가 읽는 `HASHVIEW_*` 환경 변수를 내보냅니다. 유용한 환경 변수:

- `HASHVIEW_TEST_LOCAL=1` — 로컬 스택 활성화(그 외에는 no-op)
- `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) Bandrel 방법론
  (11) 루프백 공격
  (12) LLM 공격
  (13) OMEN 공격
  (14) 임시 마스크 공격
  (15) Markov 무차별 대입 공격
  (16) N-gram 공격
  (17) 순열 공격
  (18) 무작위 규칙 공격
  (19) Combipow 암호문구 공격
  (20) PCFG 공격
  (21) PRINCE-LING 공격
  (22) Spoonman 공격
  (23) Rosetta 공격
  (24) 기업용 마스크 무차별 대입
  (25) 스마트 마스크 공격

  (80) 단어 목록 도구
  (81) 규칙 파일 도구
  (82) 알림
  (83) 마스크 도구

  (93) POT 파일에서 .out 재생성
  (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.

KeyToolDescription
1Filter by LengthKeep only words between a min and max length (len.bin)
2Require Char ClassesKeep words that include all char classes in mask (req-include.bin). Mask: 1=lower, 2=upper, 4=digit, 8=symbol (additive)
3Exclude Char ClassesRemove words containing any char class in mask (req-exclude.bin). Same mask encoding
4Extract SubstringCut bytes from each word at a given offset and optional length (cutb.bin)
5Split by LengthCreate per-length files in an output directory (splitlen.bin)
6Subtract WordlistRemove 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)
7Shard WordlistSplit a wordlist into N equal, interleaved parts in one run, written as base.001…base.00N for distributed cracking (gate.bin)
8Optimize WordlistsDedupe and split the selected wordlists into per-length files under an output directory
9Download from Hashmob.netBrowse and download wordlists from Hashmob.net into the configured wordlist directory
10Download from WeakpassBrowse and download Weakpass wordlist torrents, with automatic extraction
11Hashmob DownloadsAccess 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

Weakpass Wordlist Menu (Wordlist Tools option 10)

Interactive menu for downloading and managing wordlists from Weakpass.com via BitTorrent.

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

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.

더 읽기

카테고리

Password CrackingPassword AttacksHash AnalysisPenetration Testing