hashcrack-cli 0.1.1__py3-none-any.whl

hashcrack/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.1"
+__author__ = "shazeus"

hashcrack/__main__.py

@@ -0,0 +1,4 @@
+from hashcrack.cli import cli
+
+if __name__ == "__main__":
+    cli()

hashcrack/cli.py

@@ -0,0 +1,700 @@
+import sys
+import hashlib
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.text import Text
+from rich import box
+from rich.columns import Columns
+
+from hashcrack import __version__
+from hashcrack.detector import detect_hash, classify_by_length, HASH_PATTERNS
+from hashcrack.lookup import lookup_hash, generate_hash, verify_hash
+
+console = Console()
+err_console = Console(stderr=True)
+
+CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+ALGO_CHOICES = [
+    "md5", "sha1", "sha224", "sha256", "sha384", "sha512",
+    "sha3-256", "sha3-512", "blake2b", "blake2s",
+]
+
+TYPE_COLORS = {
+    "MD5": "cyan",
+    "SHA-1": "green",
+    "SHA-256": "bright_green",
+    "SHA-512": "bright_blue",
+    "bcrypt": "yellow",
+    "Argon2": "magenta",
+    "NTLM": "red",
+    "LM Hash": "bright_red",
+    "Base64": "white",
+}
+
+
+def _color_for(name: str) -> str:
+    return TYPE_COLORS.get(name, "bright_white")
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+@click.version_option(__version__, "-V", "--version", prog_name="hashcrack")
+def cli():
+    """hashcrack — Hash identification and lookup tool for CTF and security research.
+
+    \b
+    Identify hash types, look up plaintexts, generate hashes, and more.
+    """
+
+
+# ─────────────────────────────────────────────
+#  identify
+# ─────────────────────────────────────────────
+@cli.command("identify")
+@click.argument("hash_string")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+def identify(hash_string: str, output_json: bool):
+    """Identify the type(s) of a given hash.
+
+    \b
+    Examples:
+      hashcrack identify 5d41402abc4b2a76b9719d911017c592
+      hashcrack identify '$2a$12$R9h/cIPz0gi.URNNX3kh2OPST9/PgBkqquzi.Ss7KIUgO2t0jWMUW'
+    """
+    hash_string = hash_string.strip()
+    matches = detect_hash(hash_string)
+
+    if output_json:
+        click.echo(json.dumps({"hash": hash_string, "matches": matches}, indent=2))
+        return
+
+    length = len(hash_string)
+    console.print(Panel(
+        f"[bold yellow]{hash_string}[/bold yellow]",
+        title="[bold]Hash Input[/bold]",
+        subtitle=f"Length: {length} chars",
+        border_style="blue",
+    ))
+
+    if not matches:
+        console.print("[red]No known hash type matched.[/red]")
+        console.print(f"[dim]Hash length {length} — try checking for encoding issues.[/dim]")
+        sys.exit(1)
+
+    table = Table(
+        title=f"[bold green]Possible Hash Types ({len(matches)} match{'es' if len(matches) != 1 else ''})[/bold green]",
+        box=box.ROUNDED,
+        border_style="green",
+        header_style="bold magenta",
+    )
+    table.add_column("Type", style="bold", min_width=14)
+    table.add_column("Description", style="dim")
+    table.add_column("Bits", justify="right", style="cyan")
+
+    bits_map = {32: 128, 40: 160, 48: 192, 56: 224, 64: 256, 96: 384, 128: 512}
+
+    for m in matches:
+        bits = bits_map.get(m.get("length", 0), "—") if m.get("length") else "variable"
+        color = _color_for(m["name"])
+        table.add_row(
+            f"[{color}]{m['name']}[/{color}]",
+            m["description"],
+            str(bits),
+        )
+
+    console.print(table)
+
+    if len(matches) > 1:
+        console.print(
+            "[dim]Tip: Multiple types share the same length. Use [bold]hashcrack lookup[/bold] "
+            "or context clues to narrow down.[/dim]"
+        )
+
+
+# ─────────────────────────────────────────────
+#  lookup
+# ─────────────────────────────────────────────
+@cli.command("lookup")
+@click.argument("hash_string")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+@click.option("--quiet", "-q", is_flag=True, help="Only print plaintext if found.")
+def lookup(hash_string: str, output_json: bool, quiet: bool):
+    """Look up plaintext for a hash via public databases.
+
+    \b
+    Searches multiple hash cracking APIs automatically.
+
+    \b
+    Examples:
+      hashcrack lookup 5d41402abc4b2a76b9719d911017c592
+      hashcrack lookup aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
+    """
+    hash_string = hash_string.strip()
+
+    if not quiet:
+        matches = detect_hash(hash_string)
+        types = ", ".join(m["name"] for m in matches) if matches else "Unknown"
+        console.print(Panel(
+            f"[bold yellow]{hash_string}[/bold yellow]\n[dim]Detected types: {types}[/dim]",
+            title="[bold]Hash Lookup[/bold]",
+            border_style="blue",
+        ))
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+        console=console,
+    ) as progress:
+        if not quiet:
+            task = progress.add_task("Querying hash databases...", total=None)
+        result = lookup_hash(hash_string)
+
+    if output_json:
+        click.echo(json.dumps({"hash": hash_string, **result}, indent=2))
+        return
+
+    if result["found"]:
+        if quiet:
+            click.echo(result["plaintext"])
+        else:
+            console.print(Panel(
+                f"[bold green]CRACKED![/bold green]\n\n"
+                f"Plaintext: [bold bright_green]{result['plaintext']}[/bold bright_green]\n"
+                f"Source: [dim]{result['source']}[/dim]",
+                title="[bold green]Result[/bold green]",
+                border_style="green",
+            ))
+    else:
+        if quiet:
+            sys.exit(1)
+        else:
+            console.print(Panel(
+                "[red]Not found in public databases.[/red]\n\n"
+                "[dim]The hash may be:\n"
+                "  • Using a strong algorithm (bcrypt, Argon2, scrypt)\n"
+                "  • A custom or salted hash\n"
+                "  • Not in any public rainbow table[/dim]",
+                title="[bold red]Not Found[/bold red]",
+                border_style="red",
+            ))
+            sys.exit(1)
+
+
+# ─────────────────────────────────────────────
+#  generate
+# ─────────────────────────────────────────────
+@cli.command("generate")
+@click.argument("text")
+@click.option(
+    "--algo", "-a",
+    multiple=True,
+    type=click.Choice(ALGO_CHOICES, case_sensitive=False),
+    help="Algorithm(s) to use. Repeat for multiple. Default: all common.",
+)
+@click.option("--all", "all_algos", is_flag=True, help="Generate all supported hashes.")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+def generate(text: str, algo: tuple, all_algos: bool, output_json: bool):
+    """Generate hash(es) for a given string.
+
+    \b
+    Examples:
+      hashcrack generate "hello world"
+      hashcrack generate "password" --algo md5 --algo sha256
+      hashcrack generate "secret" --all
+    """
+    if all_algos or not algo:
+        algorithms = ALGO_CHOICES
+    else:
+        algorithms = list(algo)
+
+    results = {}
+    for a in algorithms:
+        h = generate_hash(text, a)
+        if h:
+            results[a] = h
+
+    if output_json:
+        click.echo(json.dumps({"input": text, "hashes": results}, indent=2))
+        return
+
+    table = Table(
+        title=f"[bold]Hashes for:[/bold] [yellow]{text}[/yellow]",
+        box=box.ROUNDED,
+        border_style="cyan",
+        header_style="bold magenta",
+    )
+    table.add_column("Algorithm", style="bold cyan", min_width=12)
+    table.add_column("Hash", style="white")
+
+    for algo_name, hash_val in results.items():
+        table.add_row(algo_name.upper(), hash_val)
+
+    console.print(table)
+
+
+# ─────────────────────────────────────────────
+#  batch
+# ─────────────────────────────────────────────
+@cli.command("batch")
+@click.argument("input_file", type=click.Path(exists=True))
+@click.option("--lookup", "do_lookup", is_flag=True, help="Also attempt to look up plaintexts.")
+@click.option("--output", "-o", type=click.Path(), help="Save results to a file (JSON).")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+def batch(input_file: str, do_lookup: bool, output: Optional[str], output_json: bool):
+    """Process multiple hashes from a file (one per line).
+
+    \b
+    Examples:
+      hashcrack batch hashes.txt
+      hashcrack batch hashes.txt --lookup
+      hashcrack batch hashes.txt --lookup --output results.json
+    """
+    path = Path(input_file)
+    lines = [l.strip() for l in path.read_text().splitlines() if l.strip() and not l.startswith("#")]
+
+    if not lines:
+        if output_json:
+            click.echo("[]")
+            return
+        console.print("[red]No hashes found in file.[/red]")
+        sys.exit(1)
+
+    if not output_json:
+        console.print(Panel(
+            f"Processing [bold]{len(lines)}[/bold] hash(es) from [cyan]{path.name}[/cyan]",
+            title="[bold]Batch Mode[/bold]",
+            border_style="blue",
+        ))
+
+    all_results = []
+
+    if output_json:
+        for line in lines:
+            matches = detect_hash(line)
+            entry = {
+                "hash": line,
+                "types": [m["name"] for m in matches],
+                "found": False,
+                "plaintext": None,
+                "source": None,
+            }
+            if do_lookup and matches:
+                result = lookup_hash(line)
+                entry.update(result)
+            all_results.append(entry)
+    else:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Processing...", total=len(lines))
+
+            for i, line in enumerate(lines, 1):
+                progress.update(task, description=f"[{i}/{len(lines)}] {line[:32]}...")
+                matches = detect_hash(line)
+                entry = {
+                    "hash": line,
+                    "types": [m["name"] for m in matches],
+                    "found": False,
+                    "plaintext": None,
+                    "source": None,
+                }
+                if do_lookup and matches:
+                    result = lookup_hash(line)
+                    entry.update(result)
+                all_results.append(entry)
+                progress.advance(task)
+
+    if output_json:
+        click.echo(json.dumps(all_results, indent=2))
+    else:
+        table = Table(
+            title=f"[bold]Batch Results — {len(all_results)} hashes[/bold]",
+            box=box.ROUNDED,
+            border_style="cyan",
+            header_style="bold magenta",
+        )
+        table.add_column("Hash", style="dim", max_width=40)
+        table.add_column("Detected Types", style="cyan")
+        if do_lookup:
+            table.add_column("Plaintext", style="bold green")
+            table.add_column("Source", style="dim")
+
+        for entry in all_results:
+            short_hash = entry["hash"][:36] + "..." if len(entry["hash"]) > 36 else entry["hash"]
+            types_str = ", ".join(entry["types"]) if entry["types"] else "[red]Unknown[/red]"
+            if do_lookup:
+                plaintext = f"[green]{entry['plaintext']}[/green]" if entry["found"] else "[red]Not found[/red]"
+                source = entry["source"] or ""
+                table.add_row(short_hash, types_str, plaintext, source)
+            else:
+                table.add_row(short_hash, types_str)
+
+        console.print(table)
+
+    if output:
+        Path(output).write_text(json.dumps(all_results, indent=2))
+        if not output_json:
+            console.print(f"\n[dim]Results saved to [cyan]{output}[/cyan][/dim]")
+
+    if do_lookup and not output_json:
+        found_count = sum(1 for r in all_results if r["found"])
+        console.print(
+            f"\n[bold]Summary:[/bold] {found_count}/{len(all_results)} hashes cracked "
+            f"[dim]({100*found_count//len(all_results) if all_results else 0}%)[/dim]"
+        )
+
+
+# ─────────────────────────────────────────────
+#  verify
+# ─────────────────────────────────────────────
+@cli.command("verify")
+@click.argument("hash_string")
+@click.argument("plaintext")
+@click.option(
+    "--algo", "-a",
+    type=click.Choice(ALGO_CHOICES, case_sensitive=False),
+    help="Force a specific algorithm.",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+def verify(hash_string: str, plaintext: str, algo: Optional[str], output_json: bool):
+    """Verify that a plaintext matches a hash.
+
+    \b
+    Examples:
+      hashcrack verify 5d41402abc4b2a76b9719d911017c592 "hello"
+      hashcrack verify <sha256_hash> "password" --algo sha256
+    """
+    hash_string = hash_string.strip()
+
+    if algo:
+        algorithms_to_try = [algo]
+    else:
+        matches = detect_hash(hash_string)
+        if not matches:
+            err_console.print("[red]Cannot detect hash type. Use --algo to specify.[/red]")
+            sys.exit(1)
+        algorithms_to_try = [m["name"].lower().replace("-", "").replace(" ", "")
+                              for m in matches if m.get("length")]
+
+    verified = False
+    matched_algo = None
+
+    for a in algorithms_to_try:
+        clean_algo = a.lower().replace("-", "").replace("_", "").replace(" ", "")
+        if verify_hash(hash_string, plaintext, clean_algo):
+            verified = True
+            matched_algo = a
+            break
+
+    if output_json:
+        click.echo(json.dumps({
+            "hash": hash_string,
+            "plaintext": plaintext,
+            "verified": verified,
+            "algorithm": matched_algo,
+        }, indent=2))
+        return
+
+    if verified:
+        console.print(Panel(
+            f"[bold green]MATCH![/bold green]\n\n"
+            f"Hash:      [dim]{hash_string}[/dim]\n"
+            f"Plaintext: [bold green]{plaintext}[/bold green]\n"
+            f"Algorithm: [cyan]{matched_algo}[/cyan]",
+            title="[bold green]Verification[/bold green]",
+            border_style="green",
+        ))
+    else:
+        console.print(Panel(
+            f"[bold red]NO MATCH[/bold red]\n\n"
+            f"Hash:      [dim]{hash_string}[/dim]\n"
+            f"Plaintext: [yellow]{plaintext}[/yellow]\n"
+            f"Tried:     [dim]{', '.join(algorithms_to_try)}[/dim]",
+            title="[bold red]Verification Failed[/bold red]",
+            border_style="red",
+        ))
+        sys.exit(1)
+
+
+# ─────────────────────────────────────────────
+#  info
+# ─────────────────────────────────────────────
+@cli.command("info")
+@click.argument("hash_type", required=False)
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+def info(hash_type: Optional[str], output_json: bool):
+    """Show information about a hash algorithm, or list all supported types.
+
+    \b
+    Examples:
+      hashcrack info           # list all supported hash types
+      hashcrack info md5       # details on MD5
+      hashcrack info sha256
+    """
+    if hash_type:
+        target = hash_type.upper().replace("_", "-").replace(" ", "-")
+        matches = [p for p in HASH_PATTERNS if p["name"].upper() == target]
+
+        if not matches:
+            # Try fuzzy
+            matches = [p for p in HASH_PATTERNS if target in p["name"].upper()]
+
+        if not matches:
+            err_console.print(f"[red]Unknown hash type: {hash_type}[/red]")
+            err_console.print("[dim]Run [bold]hashcrack info[/bold] to list all types.[/dim]")
+            sys.exit(1)
+
+        m = matches[0]
+        if output_json:
+            click.echo(json.dumps(m, indent=2))
+            return
+
+        bits_map = {32: 128, 40: 160, 48: 192, 56: 224, 64: 256, 96: 384, 128: 512}
+        bits = bits_map.get(m.get("length", 0), "variable")
+        color = _color_for(m["name"])
+
+        console.print(Panel(
+            f"[bold {color}]{m['name']}[/bold {color}]\n\n"
+            f"[dim]Description:[/dim] {m['description']}\n"
+            f"[dim]Hex length:[/dim]  {m.get('length', 'variable')}\n"
+            f"[dim]Bits:[/dim]        {bits}\n"
+            f"[dim]Pattern:[/dim]     [dim]{m['regex']}[/dim]\n\n"
+            f"[dim]Example:[/dim]\n[yellow]{m['example']}[/yellow]",
+            title=f"[bold]Hash Info — {m['name']}[/bold]",
+            border_style=color,
+        ))
+    else:
+        if output_json:
+            click.echo(json.dumps(HASH_PATTERNS, indent=2))
+            return
+
+        table = Table(
+            title="[bold]Supported Hash Types[/bold]",
+            box=box.ROUNDED,
+            border_style="blue",
+            header_style="bold magenta",
+        )
+        table.add_column("Type", style="bold", min_width=14)
+        table.add_column("Bits", justify="right", style="cyan")
+        table.add_column("Hex Length", justify="right", style="dim")
+        table.add_column("Description", style="white")
+
+        bits_map = {32: 128, 40: 160, 48: 192, 56: 224, 64: 256, 96: 384, 128: 512}
+
+        for p in HASH_PATTERNS:
+            bits = bits_map.get(p.get("length", 0), "var")
+            color = _color_for(p["name"])
+            table.add_row(
+                f"[{color}]{p['name']}[/{color}]",
+                str(bits),
+                str(p.get("length", "—")),
+                p["description"],
+            )
+
+        console.print(table)
+        console.print(f"\n[dim]Total: {len(HASH_PATTERNS)} hash types. Run [bold]hashcrack info <type>[/bold] for details.[/dim]")
+
+
+# ─────────────────────────────────────────────
+#  analyze
+# ─────────────────────────────────────────────
+@cli.command("analyze")
+@click.argument("hash_string")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+def analyze(hash_string: str, output_json: bool):
+    """Deep analysis of a hash: type detection + lookup + entropy.
+
+    \b
+    Combines identify, lookup, and statistical analysis in one command.
+
+    \b
+    Examples:
+      hashcrack analyze 5d41402abc4b2a76b9719d911017c592
+    """
+    import math
+
+    hash_string = hash_string.strip()
+    matches = detect_hash(hash_string)
+
+    # Entropy calculation
+    freq = {}
+    for ch in hash_string.lower():
+        freq[ch] = freq.get(ch, 0) + 1
+    length = len(hash_string)
+    entropy = 0.0
+    for count in freq.values():
+        p = count / length
+        if p > 0:
+            entropy -= p * math.log2(p)
+
+    # Character distribution
+    hex_chars = sum(1 for c in hash_string if c in "0123456789abcdefABCDEF")
+    is_pure_hex = hex_chars == length
+
+    result = {
+        "hash": hash_string,
+        "length": length,
+        "entropy": round(entropy, 4),
+        "is_pure_hex": is_pure_hex,
+        "detected_types": [m["name"] for m in matches],
+        "lookup": None,
+    }
+
+    console.print(Panel(
+        f"[bold yellow]{hash_string}[/bold yellow]",
+        title="[bold]Deep Hash Analysis[/bold]",
+        border_style="magenta",
+    ))
+
+    # Stats table
+    stats = Table(box=box.SIMPLE, show_header=False)
+    stats.add_column("Property", style="dim")
+    stats.add_column("Value", style="bold")
+
+    stats.add_row("Length", f"{length} characters")
+    stats.add_row("Entropy", f"{entropy:.2f} bits/char")
+    stats.add_row("Pure hex", "Yes" if is_pure_hex else "No")
+    stats.add_row("Charset", _describe_charset(hash_string))
+
+    console.print(stats)
+
+    if matches:
+        console.print(f"\n[bold green]Detected Types:[/bold green]")
+        for m in matches:
+            color = _color_for(m["name"])
+            console.print(f"  [{color}]●[/{color}] [bold]{m['name']}[/bold] — {m['description']}")
+    else:
+        console.print("[yellow]No known hash type matched.[/yellow]")
+
+    # Attempt lookup for hex hashes
+    if is_pure_hex and length in (32, 40, 64, 128):
+        console.print("\n[dim]Attempting lookup in public databases...[/dim]")
+        lookup_result = lookup_hash(hash_string)
+        result["lookup"] = lookup_result
+        if lookup_result["found"]:
+            console.print(Panel(
+                f"[bold green]CRACKED![/bold green]  Plaintext: [bright_green]{lookup_result['plaintext']}[/bright_green]\n"
+                f"[dim]Source: {lookup_result['source']}[/dim]",
+                border_style="green",
+            ))
+        else:
+            console.print("[dim]Not found in public databases.[/dim]")
+
+    if output_json:
+        click.echo(json.dumps(result, indent=2))
+
+
+def _describe_charset(s: str) -> str:
+    has_lower = any(c.islower() for c in s)
+    has_upper = any(c.isupper() for c in s)
+    has_digit = any(c.isdigit() for c in s)
+    has_special = any(not c.isalnum() for c in s)
+    parts = []
+    if has_lower:
+        parts.append("lowercase")
+    if has_upper:
+        parts.append("uppercase")
+    if has_digit:
+        parts.append("digits")
+    if has_special:
+        parts.append("special")
+    return ", ".join(parts) if parts else "unknown"
+
+
+# ─────────────────────────────────────────────
+#  wordlist
+# ─────────────────────────────────────────────
+@cli.command("wordlist")
+@click.argument("wordlist_file", type=click.Path(exists=True))
+@click.argument("hash_string")
+@click.option(
+    "--algo", "-a",
+    type=click.Choice(ALGO_CHOICES, case_sensitive=False),
+    default="md5",
+    show_default=True,
+    help="Hash algorithm to use.",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON.")
+def wordlist(wordlist_file: str, hash_string: str, algo: str, output_json: bool):
+    """Crack a hash using a local wordlist file.
+
+    \b
+    Hashes each line of the wordlist and compares against the target.
+
+    \b
+    Examples:
+      hashcrack wordlist rockyou.txt 5d41402abc4b2a76b9719d911017c592
+      hashcrack wordlist passwords.txt <sha256_hash> --algo sha256
+    """
+    hash_string = hash_string.strip().lower()
+    path = Path(wordlist_file)
+
+    total_lines = sum(1 for _ in path.open("r", errors="ignore"))
+
+    console.print(Panel(
+        f"Target: [bold yellow]{hash_string}[/bold yellow]\n"
+        f"Algorithm: [cyan]{algo.upper()}[/cyan]\n"
+        f"Wordlist: [dim]{path.name}[/dim] ([bold]{total_lines:,}[/bold] words)",
+        title="[bold]Wordlist Attack[/bold]",
+        border_style="blue",
+    ))
+
+    found = False
+    plaintext = None
+    tried = 0
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Cracking...", total=total_lines)
+
+        with path.open("r", errors="ignore") as f:
+            for line in f:
+                word = line.rstrip("\n\r")
+                computed = generate_hash(word, algo)
+                tried += 1
+                progress.advance(task)
+
+                if computed and computed.lower() == hash_string:
+                    found = True
+                    plaintext = word
+                    break
+
+    if output_json:
+        click.echo(json.dumps({
+            "hash": hash_string,
+            "algorithm": algo,
+            "found": found,
+            "plaintext": plaintext,
+            "tried": tried,
+        }, indent=2))
+        return
+
+    if found:
+        console.print(Panel(
+            f"[bold green]CRACKED![/bold green]\n\n"
+            f"Plaintext: [bold bright_green]{plaintext}[/bold bright_green]\n"
+            f"Tried: [dim]{tried:,} words[/dim]",
+            title="[bold green]Success[/bold green]",
+            border_style="green",
+        ))
+    else:
+        console.print(Panel(
+            f"[red]Not found in wordlist.[/red]\n[dim]Tried {tried:,} words.[/dim]",
+            title="[bold red]Not Found[/bold red]",
+            border_style="red",
+        ))
+        sys.exit(1)

hashcrack/detector.py

@@ -0,0 +1,223 @@
+import re
+from typing import Optional
+
+HASH_PATTERNS = [
+    {
+        "name": "MD5",
+        "regex": r"^[a-f0-9]{32}$",
+        "length": 32,
+        "description": "Message Digest 5",
+        "example": "5d41402abc4b2a76b9719d911017c592",
+    },
+    {
+        "name": "SHA-1",
+        "regex": r"^[a-f0-9]{40}$",
+        "length": 40,
+        "description": "Secure Hash Algorithm 1",
+        "example": "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d",
+    },
+    {
+        "name": "SHA-224",
+        "regex": r"^[a-f0-9]{56}$",
+        "length": 56,
+        "description": "Secure Hash Algorithm 224",
+        "example": "abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5",
+    },
+    {
+        "name": "SHA-256",
+        "regex": r"^[a-f0-9]{64}$",
+        "length": 64,
+        "description": "Secure Hash Algorithm 256",
+        "example": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
+    },
+    {
+        "name": "SHA-384",
+        "regex": r"^[a-f0-9]{96}$",
+        "length": 96,
+        "description": "Secure Hash Algorithm 384",
+        "example": "59e1748777448c69de6b800d7a33bbfb9ff1b463e44354c3553bcdb9c666fa90125a3c79f90397bdf5f6a13de828684f",
+    },
+    {
+        "name": "SHA-512",
+        "regex": r"^[a-f0-9]{128}$",
+        "length": 128,
+        "description": "Secure Hash Algorithm 512",
+        "example": "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
+    },
+    {
+        "name": "SHA3-256",
+        "regex": r"^[a-f0-9]{64}$",
+        "length": 64,
+        "description": "SHA3 256-bit (Keccak)",
+        "example": "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a",
+    },
+    {
+        "name": "SHA3-512",
+        "regex": r"^[a-f0-9]{128}$",
+        "length": 128,
+        "description": "SHA3 512-bit (Keccak)",
+        "example": "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26",
+    },
+    {
+        "name": "NTLM",
+        "regex": r"^[a-f0-9]{32}$",
+        "length": 32,
+        "description": "NT LAN Manager hash (Windows auth)",
+        "example": "b4b9b02e6f09a9bd760f388b67351e2b",
+    },
+    {
+        "name": "MySQL4/5",
+        "regex": r"^\*[a-f0-9]{40}$",
+        "length": 41,
+        "description": "MySQL 4.1+ password hash",
+        "example": "*900ADE9CA5AE4B40B0E6A8D4E1FEC32DFEA38E4E",
+    },
+    {
+        "name": "bcrypt",
+        "regex": r"^\$2[ayb]\$.{56}$",
+        "length": None,
+        "description": "bcrypt password hash",
+        "example": "$2a$12$R9h/cIPz0gi.URNNX3kh2OPST9/PgBkqquzi.Ss7KIUgO2t0jWMUW",
+    },
+    {
+        "name": "Argon2",
+        "regex": r"^\$argon2(i|d|id)\$",
+        "length": None,
+        "description": "Argon2 password hash",
+        "example": "$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObG",
+    },
+    {
+        "name": "scrypt",
+        "regex": r"^\$scrypt\$",
+        "length": None,
+        "description": "scrypt password hash",
+        "example": "$scrypt$ln=16,r=8,p=1$aM15713r3Xsvxbi31lqr1Q$nFNh2CVHVjNldFVKDHDlm4CbdRSCdEBsjjJxD+iCs5E",
+    },
+    {
+        "name": "MD5 Crypt",
+        "regex": r"^\$1\$.{8}\$.{22}$",
+        "length": None,
+        "description": "MD5 Unix Crypt",
+        "example": "$1$O3JMY.Tw$AdLnLjQ/5jXF9.MTp3gHv/",
+    },
+    {
+        "name": "SHA-512 Crypt",
+        "regex": r"^\$6\$.{8,16}\$.{86}$",
+        "length": None,
+        "description": "SHA-512 Unix Crypt",
+        "example": "$6$52450745$k5ka2p8bFuSmoVT1tzOyyuaREkkKBcCNqoDKzYiJL9RaE8yMnPgh2XzzF0NDrUhgrcLwg78xs1w5pJiypEdFX/",
+    },
+    {
+        "name": "BLAKE2b",
+        "regex": r"^[a-f0-9]{128}$",
+        "length": 128,
+        "description": "BLAKE2b 512-bit",
+        "example": "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce",
+    },
+    {
+        "name": "BLAKE2s",
+        "regex": r"^[a-f0-9]{64}$",
+        "length": 64,
+        "description": "BLAKE2s 256-bit",
+        "example": "606beeec743ccbeff6cbcdf5d5302aa855c256c29b88c8ed331ea1a6bf3c8812",
+    },
+    {
+        "name": "CRC32",
+        "regex": r"^[a-f0-9]{8}$",
+        "length": 8,
+        "description": "CRC32 cyclic redundancy check",
+        "example": "fc4f1d7f",
+    },
+    {
+        "name": "Adler32",
+        "regex": r"^[a-f0-9]{8}$",
+        "length": 8,
+        "description": "Adler-32 checksum",
+        "example": "03da018b",
+    },
+    {
+        "name": "RIPEMD-160",
+        "regex": r"^[a-f0-9]{40}$",
+        "length": 40,
+        "description": "RACE Integrity Primitives Evaluation MD 160-bit",
+        "example": "108f07b8382412612c048d07d13f814118445acd",
+    },
+    {
+        "name": "Whirlpool",
+        "regex": r"^[a-f0-9]{128}$",
+        "length": 128,
+        "description": "Whirlpool 512-bit hash",
+        "example": "19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3",
+    },
+    {
+        "name": "LM Hash",
+        "regex": r"^[a-f0-9]{32}$",
+        "length": 32,
+        "description": "LAN Manager Hash (Windows legacy)",
+        "example": "e52cac67419a9a224a3b108f3fa6cb6d",
+    },
+    {
+        "name": "Tiger-192",
+        "regex": r"^[a-f0-9]{48}$",
+        "length": 48,
+        "description": "Tiger 192-bit",
+        "example": "9f00f599072300dd276abb38c8eb6dcae6f0f3b0ff6d0f29",
+    },
+    {
+        "name": "Haval-256",
+        "regex": r"^[a-f0-9]{64}$",
+        "length": 64,
+        "description": "Haval 256-bit",
+        "example": "4a665e3f9f31e52f42b08cde57a93b2cedc1b8a25a0a76a2a15abd76f5e0a48",
+    },
+    {
+        "name": "Base64",
+        "regex": r"^[A-Za-z0-9+/]+=*$",
+        "length": None,
+        "description": "Base64 encoded string",
+        "example": "aGVsbG8gd29ybGQ=",
+    },
+]
+
+LENGTH_MAP = {
+    8: ["CRC32", "Adler32"],
+    32: ["MD5", "NTLM", "LM Hash"],
+    40: ["SHA-1", "RIPEMD-160"],
+    48: ["Tiger-192"],
+    56: ["SHA-224"],
+    64: ["SHA-256", "SHA3-256", "BLAKE2s", "Haval-256"],
+    96: ["SHA-384"],
+    128: ["SHA-512", "SHA3-512", "BLAKE2b", "Whirlpool"],
+}
+
+
+def detect_hash(hash_string: str) -> list[dict]:
+    """Return list of possible hash types for a given hash string."""
+    hash_string = hash_string.strip()
+    matches = []
+
+    for pattern in HASH_PATTERNS:
+        if re.match(pattern["regex"], hash_string, re.IGNORECASE):
+            matches.append(pattern)
+
+    # Deduplicate by name
+    seen = set()
+    unique = []
+    for m in matches:
+        if m["name"] not in seen:
+            seen.add(m["name"])
+            unique.append(m)
+
+    return unique
+
+
+def is_hex(s: str) -> bool:
+    try:
+        int(s, 16)
+        return True
+    except ValueError:
+        return False
+
+
+def classify_by_length(length: int) -> list[str]:
+    return LENGTH_MAP.get(length, [])

hashcrack/lookup.py

@@ -0,0 +1,163 @@
+import hashlib
+import requests
+from typing import Optional
+
+HEADERS = {"User-Agent": "hashcrack/0.1.0 (CTF hash lookup tool)"}
+TIMEOUT = 10
+
+
+def lookup_md5_online(hash_str: str) -> Optional[str]:
+    """Try multiple free hash lookup APIs for MD5/SHA1/SHA256."""
+    hash_str = hash_str.lower().strip()
+
+    # md5decrypt.net
+    try:
+        url = f"https://md5decrypt.net/Api/api.php?hash={hash_str}&hash_type=md5&email=test@test.com&code=code1"
+        resp = requests.get(url, timeout=TIMEOUT, headers=HEADERS)
+        if resp.ok and resp.text and resp.text not in ("", "ACCESS_DENIED", "INVALID_HASH", "NOT_FOUND"):
+            return resp.text.strip()
+    except Exception:
+        pass
+
+    return None
+
+
+def lookup_nitrxgen(hash_str: str) -> Optional[str]:
+    """Use nitrxgen rainbow table lookup for MD5."""
+    hash_str = hash_str.lower().strip()
+    try:
+        url = f"https://www.nitrxgen.net/md5db/{hash_str}"
+        resp = requests.get(url, timeout=TIMEOUT, headers=HEADERS)
+        if resp.ok and resp.text.strip():
+            return resp.text.strip()
+    except Exception:
+        pass
+    return None
+
+
+def lookup_hashes_com(hash_str: str) -> Optional[str]:
+    """Query hashes.com API."""
+    hash_str = hash_str.lower().strip()
+    try:
+        url = f"https://hashes.com/en/api/identify"
+        resp = requests.post(
+            url,
+            data={"hash": hash_str},
+            timeout=TIMEOUT,
+            headers=HEADERS,
+        )
+        if resp.ok:
+            data = resp.json()
+            if data.get("result"):
+                return data["result"]
+    except Exception:
+        pass
+    return None
+
+
+def lookup_hashtoolkit(hash_str: str) -> Optional[str]:
+    """Query hashtoolkit.com."""
+    hash_str = hash_str.lower().strip()
+    try:
+        url = f"https://hashtoolkit.com/reverse-hash/?hash={hash_str}"
+        resp = requests.get(url, timeout=TIMEOUT, headers=HEADERS)
+        if resp.ok:
+            import re
+            match = re.search(r'<span class="hashValue">(.*?)</span>', resp.text)
+            if match:
+                return match.group(1).strip()
+    except Exception:
+        pass
+    return None
+
+
+def crackstation_lookup(hash_str: str) -> Optional[str]:
+    """Query CrackStation via their API."""
+    hash_str = hash_str.lower().strip()
+    try:
+        url = "https://crackstation.net/crackstation-api/v1/hash.php"
+        resp = requests.post(
+            url,
+            data={"hash": hash_str, "submit": "Crack Hashes"},
+            timeout=TIMEOUT,
+            headers={**HEADERS, "Content-Type": "application/x-www-form-urlencoded"},
+        )
+        if resp.ok and resp.text:
+            import json
+            try:
+                results = json.loads(resp.text)
+                if isinstance(results, list) and results and results[0].get("cracked"):
+                    return results[0].get("plaintext")
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return None
+
+
+def lookup_hash(hash_str: str, hash_type: Optional[str] = None) -> dict:
+    """
+    Attempt to look up plaintext for a hash using multiple public services.
+    Returns dict with 'found', 'plaintext', 'source' keys.
+    """
+    hash_str = hash_str.strip()
+    result = {"found": False, "plaintext": None, "source": None}
+
+    # Try multiple sources
+    sources = [
+        ("nitrxgen (MD5 rainbow tables)", lookup_nitrxgen),
+        ("hashes.com", lookup_hashes_com),
+        ("hashtoolkit.com", lookup_hashtoolkit),
+        ("crackstation.net", crackstation_lookup),
+    ]
+
+    for source_name, fn in sources:
+        try:
+            plaintext = fn(hash_str)
+            if plaintext:
+                result["found"] = True
+                result["plaintext"] = plaintext
+                result["source"] = source_name
+                return result
+        except Exception:
+            continue
+
+    return result
+
+
+def generate_hash(text: str, algorithm: str) -> Optional[str]:
+    """Generate hash of given text using specified algorithm."""
+    algorithm = algorithm.lower().replace("-", "").replace("_", "")
+    algo_map = {
+        "md5": "md5",
+        "sha1": "sha1",
+        "sha224": "sha224",
+        "sha256": "sha256",
+        "sha384": "sha384",
+        "sha512": "sha512",
+        "sha3224": "sha3_224",
+        "sha3256": "sha3_256",
+        "sha3384": "sha3_384",
+        "sha3512": "sha3_512",
+        "blake2b": "blake2b",
+        "blake2s": "blake2s",
+    }
+
+    algo_key = algo_map.get(algorithm)
+    if not algo_key:
+        return None
+
+    try:
+        h = hashlib.new(algo_key)
+        h.update(text.encode("utf-8"))
+        return h.hexdigest()
+    except ValueError:
+        return None
+
+
+def verify_hash(hash_str: str, plaintext: str, algorithm: str) -> bool:
+    """Verify that plaintext matches hash using given algorithm."""
+    computed = generate_hash(plaintext, algorithm)
+    if computed is None:
+        return False
+    return computed.lower() == hash_str.lower().strip()

hashcrack_cli-0.1.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shazeus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hashcrack_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.2
+Name: hashcrack-cli
+Version: 0.1.1
+Summary: Hash identification and lookup tool for CTF and security research
+Author-email: shazeus <efeborazan07@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/shazeus/hashcrack
+Project-URL: Repository, https://github.com/shazeus/hashcrack
+Project-URL: Bug Tracker, https://github.com/shazeus/hashcrack/issues
+Keywords: hash,ctf,security,md5,sha256,cracking,lookup,cli,hashing,cryptography
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Requires-Dist: requests>=2.28
+
+<p align="center">
+  <h1 align="center">hashcrack</h1>
+  <p align="center">Hash identification and lookup tool for CTF and security research.</p>
+  <p align="center">
+    <a href="https://pypi.org/project/hashcrack-cli/"><img src="https://img.shields.io/pypi/v/hashcrack-cli?color=blue&style=flat-square" alt="PyPI"></a>
+    <a href="https://pypi.org/project/hashcrack-cli/"><img src="https://img.shields.io/pypi/pyversions/hashcrack-cli?style=flat-square" alt="Python"></a>
+    <a href="https://github.com/shazeus/hashcrack/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License"></a>
+    <a href="https://github.com/shazeus/hashcrack/stargazers"><img src="https://img.shields.io/github/stars/shazeus/hashcrack?style=flat-square" alt="Stars"></a>
+  </p>
+</p>
+
+---
+
+**hashcrack** is a fast, feature-rich CLI tool for hash analysis in CTF competitions and security research. It auto-detects hash types (MD5, SHA-1, SHA-256, bcrypt, NTLM, and 20+ more), queries public hash databases, performs wordlist attacks, generates hashes, and provides deep statistical analysis — all with beautiful terminal output powered by Rich.
+
+- **Auto-detection** — identifies 20+ hash types from MD5 to Argon2, bcrypt, NTLM, and scrypt
+- **Online lookup** — queries multiple public hash cracking APIs simultaneously
+- **Wordlist attack** — crack hashes locally using any wordlist (e.g. rockyou.txt)
+- **Hash generation** — compute MD5, SHA-1, SHA-256, SHA-512, BLAKE2 and more in one command
+- **Batch mode** — process hundreds of hashes from a file with optional auto-lookup
+- **Verification** — confirm plaintext/hash pairs across all supported algorithms
+- **Deep analysis** — entropy calculation, charset analysis, and type classification
+- **JSON output** — every command supports `--json` for scripting and piping
+
+## Installation
+
+```bash
+pip install hashcrack-cli
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/shazeus/hashcrack
+cd hashcrack
+pip install -e .
+```
+
+## Usage
+
+```bash
+# Identify a hash type
+hashcrack identify 5d41402abc4b2a76b9719d911017c592
+
+# Look up plaintext via public APIs
+hashcrack lookup 5d41402abc4b2a76b9719d911017c592
+
+# Generate hashes
+hashcrack generate "hello world"
+hashcrack generate "secret" --algo md5 --algo sha256
+
+# Crack with a wordlist
+hashcrack wordlist rockyou.txt 5d41402abc4b2a76b9719d911017c592
+
+# Batch process hashes from a file
+hashcrack batch hashes.txt --lookup
+
+# Verify plaintext against hash
+hashcrack verify 5d41402abc4b2a76b9719d911017c592 "hello"
+
+# Deep analysis
+hashcrack analyze 5d41402abc4b2a76b9719d911017c592
+
+# List all supported hash types
+hashcrack info
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `identify <hash>` | Auto-detect the type(s) of a hash |
+| `lookup <hash>` | Query public databases for the plaintext |
+| `generate <text>` | Generate hashes for a string (all algorithms or specific ones) |
+| `wordlist <file> <hash>` | Crack a hash using a local wordlist |
+| `batch <file>` | Process multiple hashes from a file |
+| `verify <hash> <plaintext>` | Confirm a hash/plaintext pair |
+| `analyze <hash>` | Full analysis: type + lookup + entropy + charset |
+| `info [type]` | Show details for a hash type, or list all supported types |
+
+## Configuration
+
+All commands support these global options:
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Output results as JSON for scripting |
+| `-q / --quiet` | Minimal output (useful in scripts) |
+| `-h / --help` | Show help for any command |
+| `-V / --version` | Show version |
+
+## Supported Hash Types
+
+MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA3-256, SHA3-512, NTLM, LM Hash, bcrypt, Argon2, scrypt, MD5 Crypt, SHA-512 Crypt, RIPEMD-160, BLAKE2b, BLAKE2s, CRC32, Adler32, Tiger-192, Haval-256, MySQL4/5, Whirlpool, Base64
+
+## License
+
+MIT — see [LICENSE](LICENSE).

hashcrack_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+hashcrack/__init__.py,sha256=j8CLnPWX6MTBo9iUD2tq6PeAtuutXV9oYyiLl8TSHRA,45
+hashcrack/__main__.py,sha256=2tXjfx7WOXfrjrcywu-MAx-ievt3WsEY9ARdB3Jhh5w,68
+hashcrack/cli.py,sha256=SgN5lZ6WKPK96DH5IPLFryQ1Vgno2rRHz74w-EHcQrU,24980
+hashcrack/detector.py,sha256=IFAWVV7WQXwYsrCYoT9o2dny8cbznu4nWrdcSWHlBOU,6947
+hashcrack/lookup.py,sha256=wzSiuNA82va7gB_XUnI6gsQzurQxO4_txXjy3--A4tU,4998
+hashcrack_cli-0.1.1.dist-info/LICENSE,sha256=HZHbJWXuWLEERO18ylRPsLaCFaWaJmc56UdeAaLJ7E8,1064
+hashcrack_cli-0.1.1.dist-info/METADATA,sha256=v8R8USdTnaBVY9ZehNezdC9u6VhOgTUfZWH7y6f_O6Q,5128
+hashcrack_cli-0.1.1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+hashcrack_cli-0.1.1.dist-info/entry_points.txt,sha256=Zhe4EhOuzYtMRXCwitA5F5avKfRYPBjPZ60O99JhVpE,48
+hashcrack_cli-0.1.1.dist-info/top_level.txt,sha256=WAtfAMG7bU80JoUtZJU_12yeJC3a66sVKJEzM9di1xg,10
+hashcrack_cli-0.1.1.dist-info/RECORD,,

hashcrack_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hashcrack_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hashcrack = hashcrack.cli:cli

hashcrack_cli-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+hashcrack