abyss-scanner 0.1.0__tar.gz

abyss_scanner-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: abyss-scanner
+Version: 0.1.0
+Summary: Abyss — CLI que mergulha nas profundezas do seu código pra achar secrets vazados e dependências vulneráveis
+Author-email: Lohane <lohane.mdev@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: packaging>=24.0
+Requires-Dist: pygithub>=2.3.0
+Requires-Dist: questionary>=2.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
+# abyss
+
+> CLI que mergulha nas profundezas do seu código pra achar o que tava
+> escondido: secrets vazados e dependências vulneráveis.
+>
+> Nome e mascote inspirados na lula-vampira-do-inferno
+> (*Vampyroteuthis infernalis*) — criatura que vive nas profundezas onde
+> não chega luz.
+
+Multiplataforma (Windows, macOS, Linux). Escaneia repositórios em busca de:
+
+- **Secrets vazados** (chaves de API, tokens, senhas commitadas) via
+  [gitleaks](https://github.com/gitleaks/gitleaks)
+- **Dependências vulneráveis** em projetos Python (`pip-audit`) e Node
+  (`npm audit`)
+
+## Instalação (dev)
+
+```bash
+pip install -e .
+```
+
+## Uso
+
+Rodar sem argumento nenhum abre o menu interativo:
+
+```bash
+abyss
+```
+
+Ou direto por linha de comando:
+
+```bash
+abyss scan .                    # escaneia o diretório atual
+abyss scan /caminho/pro/repo    # escaneia outro caminho
+abyss scan . --secrets-only     # só secrets
+abyss scan . --deps-only        # só dependências
+abyss scan . --json report.json # salva relatório em JSON
+```
+
+Na primeira execução, o binário do `gitleaks` é baixado automaticamente
+para a plataforma atual e guardado em cache local (não precisa instalar
+nada manualmente).
+
+Para o scan de dependências, `pip-audit` (Python) e `npm` (Node) precisam
+estar disponíveis no PATH quando aplicável — se não estiverem, aquele
+scan é pulado silenciosamente.
+
+## Segurança
+
+Secrets encontrados **nunca** aparecem em texto puro — são sempre
+redigidos (`redact()`), mostrando só os últimos 4 caracteres. Isso vale
+pra saída de terminal, JSON exportado e qualquer log.
+
+## Mascote
+
+O ASCII art da lula-vampira fica em `abyss/ui/banner.py`, na constante
+`MASCOT_ART` — troque o placeholder pelo desenho final quando estiver
+pronto.
+
+## Roadmap
+
+- [ ] Publicar no PyPI
+- [ ] Integração com GitHub API — abrir issue automática ao encontrar problema
+- [ ] Suporte a mais ecossistemas (Cargo, Go modules)
+- [ ] Modo `--watch` para rodar em CI/pre-commit hook
+- [x] Nome definitivo: **Abyss**

abyss_scanner-0.1.0/README.md

@@ -0,0 +1,67 @@
+# abyss
+
+> CLI que mergulha nas profundezas do seu código pra achar o que tava
+> escondido: secrets vazados e dependências vulneráveis.
+>
+> Nome e mascote inspirados na lula-vampira-do-inferno
+> (*Vampyroteuthis infernalis*) — criatura que vive nas profundezas onde
+> não chega luz.
+
+Multiplataforma (Windows, macOS, Linux). Escaneia repositórios em busca de:
+
+- **Secrets vazados** (chaves de API, tokens, senhas commitadas) via
+  [gitleaks](https://github.com/gitleaks/gitleaks)
+- **Dependências vulneráveis** em projetos Python (`pip-audit`) e Node
+  (`npm audit`)
+
+## Instalação (dev)
+
+```bash
+pip install -e .
+```
+
+## Uso
+
+Rodar sem argumento nenhum abre o menu interativo:
+
+```bash
+abyss
+```
+
+Ou direto por linha de comando:
+
+```bash
+abyss scan .                    # escaneia o diretório atual
+abyss scan /caminho/pro/repo    # escaneia outro caminho
+abyss scan . --secrets-only     # só secrets
+abyss scan . --deps-only        # só dependências
+abyss scan . --json report.json # salva relatório em JSON
+```
+
+Na primeira execução, o binário do `gitleaks` é baixado automaticamente
+para a plataforma atual e guardado em cache local (não precisa instalar
+nada manualmente).
+
+Para o scan de dependências, `pip-audit` (Python) e `npm` (Node) precisam
+estar disponíveis no PATH quando aplicável — se não estiverem, aquele
+scan é pulado silenciosamente.
+
+## Segurança
+
+Secrets encontrados **nunca** aparecem em texto puro — são sempre
+redigidos (`redact()`), mostrando só os últimos 4 caracteres. Isso vale
+pra saída de terminal, JSON exportado e qualquer log.
+
+## Mascote
+
+O ASCII art da lula-vampira fica em `abyss/ui/banner.py`, na constante
+`MASCOT_ART` — troque o placeholder pelo desenho final quando estiver
+pronto.
+
+## Roadmap
+
+- [ ] Publicar no PyPI
+- [ ] Integração com GitHub API — abrir issue automática ao encontrar problema
+- [ ] Suporte a mais ecossistemas (Cargo, Go modules)
+- [ ] Modo `--watch` para rodar em CI/pre-commit hook
+- [x] Nome definitivo: **Abyss**

abyss_scanner-0.1.0/abyss/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

abyss_scanner-0.1.0/abyss/cli.py

@@ -0,0 +1,147 @@
+"""CLI principal do abyss-cli."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from abyss import __version__
+from abyss.scanners import dependencies, secrets
+
+app = typer.Typer(
+    name="abyss",
+    help="Escaneia repositórios em busca de secrets vazados e dependências vulneráveis.",
+    no_args_is_help=False,
+    invoke_without_command=True,
+)
+console = Console()
+
+
+def _version_callback(value: bool):
+    if value:
+        console.print(f"abyss-cli v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+        None, "--version", callback=_version_callback, is_eager=True,
+        help="Mostra a versão e sai.",
+    ),
+):
+    """Sem subcomando -> abre o menu interativo."""
+    if ctx.invoked_subcommand is None:
+        from abyss.ui.menu import run_interactive
+
+        run_interactive()
+        raise typer.Exit()
+
+
+@app.command()
+def scan(
+    path: str = typer.Argument(".", help="Caminho do repositório a escanear."),
+    secrets_only: bool = typer.Option(False, "--secrets-only", help="Roda só o scan de secrets."),
+    deps_only: bool = typer.Option(False, "--deps-only", help="Roda só o scan de dependências."),
+    json_output: Optional[Path] = typer.Option(None, "--json", help="Salva resultado em JSON no caminho informado."),
+):
+    """Escaneia um repositório local em busca de secrets e dependências vulneráveis."""
+    from abyss.ui.banner import show_banner
+
+    show_banner()
+
+    repo_path = str(Path(path).resolve())
+    if not Path(repo_path).exists():
+        console.print(f"[red]Erro:[/red] caminho não encontrado: {repo_path}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[bold cyan]abyss[/bold cyan] escaneando [bold]{repo_path}[/bold]\n")
+
+    secret_findings = []
+    dep_findings = []
+
+    if not deps_only:
+        with console.status("[cyan]Procurando secrets vazados...[/cyan]"):
+            secret_findings = secrets.scan_repo(repo_path, progress_callback=console.print)
+        _print_secret_findings(secret_findings)
+
+    if not secrets_only:
+        with console.status("[cyan]Auditando dependências...[/cyan]"):
+            dep_findings = dependencies.scan_repo(repo_path)
+        _print_dependency_findings(dep_findings)
+
+    total = len(secret_findings) + len(dep_findings)
+    if total == 0:
+        console.print("\n[bold green]✓ Nenhum problema encontrado.[/bold green]")
+    else:
+        console.print(
+            f"\n[bold yellow]⚠ {total} problema(s) encontrado(s)[/bold yellow] "
+            f"({len(secret_findings)} secret(s), {len(dep_findings)} dependência(s) vulnerável(is))"
+        )
+
+    if json_output:
+        _write_json(json_output, secret_findings, dep_findings, repo_path)
+        console.print(f"[dim]Relatório salvo em {json_output}[/dim]")
+
+    if total > 0:
+        raise typer.Exit(code=1)
+
+
+def _print_secret_findings(findings):
+    if not findings:
+        console.print("[green]✓[/green] Nenhum secret encontrado.\n")
+        return
+
+    table = Table(title="Secrets encontrados")
+    table.add_column("Arquivo", style="cyan")
+    table.add_column("Linha")
+    table.add_column("Regra", style="yellow")
+    table.add_column("Secret (redigido)", style="red")
+
+    for f in findings:
+        table.add_row(f.file, str(f.line_number), f.rule_id, f.redacted_secret)
+
+    console.print(table)
+    console.print()
+
+
+def _print_dependency_findings(findings):
+    if not findings:
+        console.print("[green]✓[/green] Nenhuma dependência vulnerável encontrada.\n")
+        return
+
+    table = Table(title="Dependências vulneráveis")
+    table.add_column("Pacote", style="cyan")
+    table.add_column("Versão instalada")
+    table.add_column("Vulnerabilidade", style="yellow")
+    table.add_column("Severidade")
+    table.add_column("Correção", style="green")
+    table.add_column("Ecossistema")
+
+    for f in findings:
+        table.add_row(
+            f.package, f.installed_version, f.vulnerability_id,
+            f.severity, f.fix_version or "-", f.ecosystem,
+        )
+
+    console.print(table)
+    console.print()
+
+
+def _write_json(output_path: Path, secret_findings, dep_findings, repo_path: str):
+    import json as json_lib
+    from dataclasses import asdict
+
+    report = {
+        "repo": repo_path,
+        "secrets": [asdict(f) for f in secret_findings],
+        "dependencies": [asdict(f) for f in dep_findings],
+    }
+    output_path.write_text(json_lib.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+if __name__ == "__main__":
+    app()

abyss_scanner-0.1.0/abyss/core/installer.py

@@ -0,0 +1,82 @@
+"""Baixa e gerencia o binário do gitleaks para a plataforma atual.
+
+O gitleaks é distribuído como binário standalone por release no GitHub,
+então cada SO/arquitetura tem um asset diferente. Baixamos uma vez e
+guardamos em abyss_home() pra não repetir o download a cada scan.
+"""
+
+import stat
+import tarfile
+import zipfile
+from pathlib import Path
+
+import requests
+
+from abyss.utils.platform import binary_name, get_arch, get_os, abyss_home
+
+GITLEAKS_VERSION = "8.18.4"
+GITLEAKS_REPO = "gitleaks/gitleaks"
+
+
+def _asset_name() -> str:
+    """Monta o nome do asset de release do gitleaks pra plataforma atual."""
+    os_name = get_os()
+    arch = get_arch()
+
+    os_map = {"windows": "windows", "darwin": "darwin", "linux": "linux"}
+    arch_map = {"x64": "x64", "arm64": "arm64", "x32": "x32"}
+
+    ext = "zip" if os_name == "windows" else "tar.gz"
+    return f"gitleaks_{GITLEAKS_VERSION}_{os_map[os_name]}_{arch_map.get(arch, 'x64')}.{ext}"
+
+
+def gitleaks_path() -> Path:
+    return abyss_home() / binary_name("gitleaks")
+
+
+def is_installed() -> bool:
+    return gitleaks_path().exists()
+
+
+def install(progress_callback=None) -> Path:
+    """Baixa e extrai o binário do gitleaks se ainda não estiver instalado."""
+    target = gitleaks_path()
+    if target.exists():
+        return target
+
+    asset = _asset_name()
+    url = f"https://github.com/{GITLEAKS_REPO}/releases/download/v{GITLEAKS_VERSION}/{asset}"
+
+    download_dir = abyss_home() / "downloads"
+    download_dir.mkdir(exist_ok=True)
+    archive_path = download_dir / asset
+
+    if progress_callback:
+        progress_callback(f"Baixando gitleaks v{GITLEAKS_VERSION} para {get_os()}/{get_arch()}...")
+
+    response = requests.get(url, stream=True, timeout=60)
+    response.raise_for_status()
+
+    with open(archive_path, "wb") as f:
+        for chunk in response.iter_content(chunk_size=8192):
+            f.write(chunk)
+
+    if progress_callback:
+        progress_callback("Extraindo binário...")
+
+    if asset.endswith(".zip"):
+        with zipfile.ZipFile(archive_path, "r") as zf:
+            zf.extractall(download_dir)
+    else:
+        with tarfile.open(archive_path, "r:gz") as tf:
+            tf.extractall(download_dir)
+
+    extracted_binary = download_dir / binary_name("gitleaks")
+    extracted_binary.replace(target)
+
+    if get_os() != "windows":
+        target.chmod(target.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+    archive_path.unlink(missing_ok=True)
+
+    return target

abyss_scanner-0.1.0/abyss/scanners/dependencies.py

@@ -0,0 +1,127 @@
+"""Scanner de dependências vulneráveis: Python (pip-audit) e Node (npm audit).
+
+Detecta automaticamente qual ecossistema está presente no repositório
+(requirements.txt/pyproject.toml para Python, package.json para Node)
+e roda a ferramenta apropriada.
+"""
+
+import json
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+
+@dataclass
+class DependencyFinding:
+    package: str
+    installed_version: str
+    vulnerability_id: str
+    severity: str
+    fix_version: str = ""
+    ecosystem: str = "python"
+
+
+def _tool_available(name: str) -> bool:
+    return shutil.which(name) is not None
+
+
+def scan_python(repo_path: str) -> List[DependencyFinding]:
+    """Roda pip-audit se houver requirements.txt ou pyproject.toml."""
+    repo = Path(repo_path)
+    requirements_file = repo / "requirements.txt"
+    pyproject_file = repo / "pyproject.toml"
+
+    if not requirements_file.exists() and not pyproject_file.exists():
+        return []
+
+    if not _tool_available("pip-audit"):
+        return []
+
+    # requirements.txt precisa da flag -r; pyproject.toml é lido via
+    # project_path posicional (pip-audit entende PEP 621 automaticamente).
+    if requirements_file.exists():
+        command = ["pip-audit", "-r", str(requirements_file), "--format", "json"]
+    else:
+        command = ["pip-audit", str(repo), "--format", "json"]
+
+    result = subprocess.run(
+        command,
+        capture_output=True,
+        text=True,
+        timeout=180,
+    )
+
+    findings = []
+    try:
+        data = json.loads(result.stdout) if result.stdout.strip() else {"dependencies": []}
+    except json.JSONDecodeError:
+        return []
+
+    for dep in data.get("dependencies", []):
+        for vuln in dep.get("vulns", []):
+            findings.append(
+                DependencyFinding(
+                    package=dep.get("name", "unknown"),
+                    installed_version=dep.get("version", ""),
+                    vulnerability_id=vuln.get("id", ""),
+                    severity=vuln.get("severity", "unknown") or "unknown",
+                    fix_version=", ".join(vuln.get("fix_versions", [])),
+                    ecosystem="python",
+                )
+            )
+    return findings
+
+
+def scan_node(repo_path: str) -> List[DependencyFinding]:
+    """Roda npm audit se houver package.json."""
+    repo = Path(repo_path)
+    if not (repo / "package.json").exists():
+        return []
+
+    if not _tool_available("npm"):
+        return []
+
+    result = subprocess.run(
+        ["npm", "audit", "--json"],
+        capture_output=True,
+        text=True,
+        timeout=180,
+        cwd=repo_path,
+    )
+
+    findings = []
+    try:
+        data = json.loads(result.stdout) if result.stdout.strip() else {}
+    except json.JSONDecodeError:
+        return []
+
+    vulnerabilities = data.get("vulnerabilities", {})
+    for pkg_name, vuln_info in vulnerabilities.items():
+        via = vuln_info.get("via", [])
+        vuln_id = ""
+        for v in via:
+            if isinstance(v, dict):
+                vuln_id = str(v.get("source", ""))
+                break
+
+        findings.append(
+            DependencyFinding(
+                package=pkg_name,
+                installed_version=vuln_info.get("range", ""),
+                vulnerability_id=vuln_id or "n/a",
+                severity=vuln_info.get("severity", "unknown"),
+                fix_version=str(vuln_info.get("fixAvailable", "")),
+                ecosystem="node",
+            )
+        )
+    return findings
+
+
+def scan_repo(repo_path: str) -> List[DependencyFinding]:
+    """Roda todos os scanners de dependência aplicáveis ao repositório."""
+    findings = []
+    findings.extend(scan_python(repo_path))
+    findings.extend(scan_node(repo_path))
+    return findings

abyss_scanner-0.1.0/abyss/scanners/secrets.py

@@ -0,0 +1,79 @@
+"""Scanner de secrets vazados, usando gitleaks como engine de detecção."""
+
+import json
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+from abyss.core.installer import gitleaks_path, install, is_installed
+from abyss.utils.redact import redact
+
+
+@dataclass
+class SecretFinding:
+    rule_id: str
+    file: str
+    line_number: int
+    redacted_secret: str
+    commit: str = ""
+    severity: str = "high"
+
+
+def ensure_gitleaks(progress_callback=None) -> Path:
+    if not is_installed():
+        return install(progress_callback=progress_callback)
+    return gitleaks_path()
+
+
+def scan_repo(repo_path: str, progress_callback=None) -> List[SecretFinding]:
+    """Roda gitleaks contra um diretório local e retorna findings já
+    redigidos (o secret cru nunca fica em memória além dessa função)."""
+
+    binary = ensure_gitleaks(progress_callback=progress_callback)
+    is_git_repo = (Path(repo_path) / ".git").exists()
+
+    with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as tmp:
+        report_path = tmp.name
+
+    try:
+        command = [
+            str(binary),
+            "detect",
+            "--source", repo_path,
+            "--report-format", "json",
+            "--report-path", report_path,
+            "--exit-code", "0",
+            "--no-banner",
+        ]
+        if not is_git_repo:
+            command.append("--no-git")
+
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+
+        report_file = Path(report_path)
+        content = report_file.read_text(encoding="utf-8").strip()
+        raw_findings = json.loads(content) if content else []
+
+        findings = []
+        for item in raw_findings:
+            raw_secret = item.get("Secret", "")
+            findings.append(
+                SecretFinding(
+                    rule_id=item.get("RuleID", "unknown"),
+                    file=item.get("File", ""),
+                    line_number=item.get("StartLine", 0),
+                    redacted_secret=redact(raw_secret),
+                    commit=item.get("Commit", "")[:8],
+                )
+            )
+        return findings
+
+    finally:
+        Path(report_path).unlink(missing_ok=True)

abyss_scanner-0.1.0/abyss/ui/banner.py

@@ -0,0 +1,123 @@
+"""Banner ASCII e identidade visual do abyss-cli.
+Layout inspirado em splash screens clássicas de ferramenta de terminal:
+título no canto esquerdo, arte original ao lado, seguido da tagline,
+linha de status e prompt de "iniciando" antes de cair no menu.
+"""
+from rich.console import Console
+from rich.text import Text
+
+console = Console()
+
+MASCOT_ART = r"""
+
+
+
+                            --
+                       =+--=+#              =++-
+         -*-          --+   +*            =-+--
+   -      =+-      --= -==--=+=          =+*+==*      -++
+ =+-       ++=+-   --=--=+---*=        --+*=--==      =++
+-==         =+++  ---=--===----------------=-=++-     ++*          =--==
+--=-        -=*-------= -=+=-----------------++==---=-=+=      -----=
+  =--=----------------=---=+=------------= -=++=----------------= -=
+   =-----------=----=--=---==-----------=--=+==-------------------++
+       ----------------=----==---------=--===----------==---==
+           -------------- ---===----------==------------=+  --
+        --    ----------------------------==---=--=-==+
+                -=-----==-=--  --- ----------==-----=*-
+               --=--  - -----  ---------------------=+*
+               =**+=--=        -----------------   =*#%
+               @█**+-==------------------------==--+%@█               -
+                 +*+++--------------------------+++**
+                   -=------------=--------------=+*#               -
+                    ==------=------=-===--==----=+*
+            - --------------=-=----=--=====-===**----
+        --------------------==-===-=======-------------------
+          -==-----------------=---------=+--=-==-----------=-
+               ---=====-+%**-==---=--=---=#%#+====--=====-
+                         =--=%%=-=---+%*#*#*+
+                            -++++++++***+=                      -
+                                -====--                        -
+"""
+
+TITLE_BLOCK = r"""
+   ▄▄▄       ▄▄▄▄ ▓██   ██▓  ██████   ██████ 
+▒████▄    ▓█████▄▒██  ██▒▒██    ▒ ▒██    ▒ 
+▒██  ▀█▄  ▒██▒ ▄██▒██ ██░░ ▓██▄   ░ ▓██▄   
+░██▄▄▄▄██ ▒██░█▀  ░ ▐██▓░  ▒   ██▒  ▒   ██▒
+ ▓█   ▓██▒░▓█  ▀█▓░ ██▒▓░▒██████▒▒▒██████▒▒
+ ▒▒   ▓▒█░░▒▓███▀▒ ██▒▒▒ ▒ ▒▓▒ ▒ ░▒ ▒▓▒ ▒ ░
+  ▒   ▒▒ ░▒░▒   ░▓██ ░▒░ ░ ░▒  ░ ░░ ░▒  ░ ░
+  ░   ▒    ░    ░▒ ▒ ░░  ░  ░  ░  ░  ░  ░  
+      ░  ░ ░     ░ ░           ░        ░  
+                ░░ ░                       
+"""
+
+TITLE = "ABYSS"
+SUBTITLE = "Next-Gen Deep Sea Exploration Platform"
+STRAPLINE = "ABYSS Security — Just one bite"
+STATUS_LINE = "[ STATUS: ACTIVE ]"
+START_LINE = "Descendo ao abismo..."
+
+
+def _combine_side_by_side(
+    left: str,
+    right: str,
+    gap: int = 3,
+    left_style: str = "bold red",
+    right_style: str = "bold magenta",
+    valign: str = "center",
+) -> Text:
+    """Junta dois blocos ASCII lado a lado, alinhados à esquerda (sem centralizar)."""
+    left_lines = left.strip("\n").split("\n")
+    right_lines = right.strip("\n").split("\n")
+
+    left_width = max(len(l) for l in left_lines)
+    height = max(len(left_lines), len(right_lines))
+
+    def pad_block(lines, target_height):
+        missing = target_height - len(lines)
+        if missing <= 0:
+            return lines
+        if valign == "center":
+            top = missing // 2
+            bottom = missing - top
+        elif valign == "bottom":
+            top, bottom = missing, 0
+        else:  # "top"
+            top, bottom = 0, missing
+        return [""] * top + lines + [""] * bottom
+
+    left_lines = pad_block(left_lines, height)
+    right_lines = pad_block(right_lines, height)
+
+    text = Text()
+    for l, r in zip(left_lines, right_lines):
+        text.append(l.ljust(left_width), style=left_style)
+        text.append(" " * gap)
+        text.append(r, style=right_style)
+        text.append("\n")
+    return text
+
+
+def show_banner():
+    combined = _combine_side_by_side(
+        TITLE_BLOCK,
+        MASCOT_ART,
+        gap=3,
+        left_style="bold red",
+        right_style="bold magenta",
+        valign="center",
+    )
+    console.print(combined, soft_wrap=True)
+    console.print(Text(f"  {SUBTITLE}", style="bold yellow"))
+    console.print(Text(f"  {STRAPLINE}", style="bold green"))
+    console.print(Text(f"  {STATUS_LINE}", style="bold red"))
+    console.print(Text(f"  {START_LINE}", style="bold magenta"))
+    console.print()
+
+
+def section(title: str):
+    console.print()
+    console.rule(f"[bold cyan] {title} [/bold cyan]", style="cyan")
+    console.print()

abyss_scanner-0.1.0/abyss/ui/menu.py

@@ -0,0 +1,125 @@
+"""Menu interativo estilo ferramenta OSINT — navegação por setas, sem
+precisar decorar flags de comando."""
+
+import questionary
+from questionary import Style
+from rich.console import Console
+
+from abyss.ui.banner import section, show_banner
+
+console = Console()
+
+# Paleta terminal verde/preto, no mesmo espírito do Cerberus/ÆGIS
+HACKER_STYLE = Style([
+    ("qmark", "fg:#00ff41 bold"),
+    ("question", "fg:#e0e0e0 bold"),
+    ("answer", "fg:#00ff41 bold"),
+    ("pointer", "fg:#00ff41 bold"),
+    ("highlighted", "fg:#00ff41 bold"),
+    ("selected", "fg:#00ff41"),
+    ("separator", "fg:#666666"),
+    ("instruction", "fg:#888888"),
+    ("text", "fg:#e0e0e0"),
+])
+
+
+def prompt_repo_path(default: str = "") -> str:
+    raw = questionary.path(
+        "Caminho do repositório alvo (Enter = diretório atual):",
+        default=default,
+        style=HACKER_STYLE,
+    ).ask()
+    return raw.strip() if raw and raw.strip() else "."
+
+
+def main_menu() -> str:
+    show_banner()
+    choice = questionary.select(
+        "Selecione uma operação:",
+        choices=[
+            questionary.Choice("[1] Scan completo (secrets + dependências)", value="full"),
+            questionary.Choice("[2] Scan de secrets vazados", value="secrets"),
+            questionary.Choice("[3] Scan de dependências vulneráveis", value="deps"),
+            questionary.Choice("[4] Instalar/atualizar gitleaks", value="install_gitleaks"),
+            questionary.Choice("[0] Sair", value="exit"),
+        ],
+        style=HACKER_STYLE,
+        qmark=">",
+        instruction=" ",
+    ).ask()
+    return choice or "exit"
+
+
+def prompt_export_json() -> bool:
+    return questionary.confirm(
+        "Exportar relatório em JSON?",
+        default=False,
+        style=HACKER_STYLE,
+    ).ask()
+
+
+def run_interactive():
+    from pathlib import Path
+
+    from abyss.cli import _print_dependency_findings, _print_secret_findings, _write_json
+    from abyss.scanners import dependencies, secrets
+
+    while True:
+        choice = main_menu()
+
+        if choice == "exit":
+            console.print("\n[dim green]encerrando sessão...[/dim green]\n")
+            break
+
+        if choice == "install_gitleaks":
+            from abyss.core.installer import install, is_installed
+
+            section("INSTALAÇÃO — GITLEAKS")
+            if is_installed():
+                console.print("[green]✓[/green] gitleaks já está instalado.")
+            else:
+                install(progress_callback=lambda msg: console.print(f"[dim]{msg}[/dim]"))
+                console.print("[green]✓[/green] gitleaks instalado com sucesso.")
+            questionary.press_any_key_to_continue(style=HACKER_STYLE).ask()
+            continue
+
+        repo_path = prompt_repo_path()
+        if not repo_path:
+            continue
+
+        resolved = str(Path(repo_path).resolve())
+        if not Path(resolved).exists():
+            console.print(f"[red]✗ caminho não encontrado:[/red] {resolved}")
+            questionary.press_any_key_to_continue(style=HACKER_STYLE).ask()
+            continue
+
+        secret_findings, dep_findings = [], []
+
+        if choice in ("full", "secrets"):
+            section("SCANNING — SECRETS")
+            with console.status("[green]procurando secrets vazados...[/green]"):
+                secret_findings = secrets.scan_repo(resolved, progress_callback=console.print)
+            _print_secret_findings(secret_findings)
+
+        if choice in ("full", "deps"):
+            section("SCANNING — DEPENDENCIES")
+            with console.status("[green]auditando dependências...[/green]"):
+                dep_findings = dependencies.scan_repo(resolved)
+            _print_dependency_findings(dep_findings)
+
+        total = len(secret_findings) + len(dep_findings)
+        section("RESULTADO")
+        if total == 0:
+            console.print("[bold green]✓ nenhum problema encontrado.[/bold green]")
+        else:
+            console.print(f"[bold yellow]⚠ {total} problema(s) encontrado(s).[/bold yellow]")
+
+            if prompt_export_json():
+                output_path = questionary.path(
+                    "Salvar relatório em:", default="abyss-report.json", style=HACKER_STYLE
+                ).ask()
+                if output_path:
+                    _write_json(Path(output_path), secret_findings, dep_findings, resolved)
+                    console.print(f"[dim]relatório salvo em {output_path}[/dim]")
+
+        questionary.press_any_key_to_continue(style=HACKER_STYLE).ask()

abyss_scanner-0.1.0/abyss/utils/platform.py

@@ -0,0 +1,52 @@
+"""Detecção de plataforma e arquitetura para baixar os binários corretos."""
+
+import platform
+import sys
+
+
+def get_os() -> str:
+    """Retorna 'windows', 'darwin' ou 'linux'."""
+    system = platform.system().lower()
+    if system == "darwin":
+        return "darwin"
+    if system == "windows":
+        return "windows"
+    return "linux"
+
+
+def get_arch() -> str:
+    """Normaliza a arquitetura pro formato usado nos releases do gitleaks."""
+    machine = platform.machine().lower()
+    if machine in ("x86_64", "amd64"):
+        return "x64"
+    if machine in ("arm64", "aarch64"):
+        return "arm64"
+    if machine in ("i386", "i686", "x86"):
+        return "x32"
+    return machine
+
+
+def binary_name(base_name: str) -> str:
+    """Adiciona .exe no Windows quando necessário."""
+    if get_os() == "windows":
+        return f"{base_name}.exe"
+    return base_name
+
+
+def abyss_home() -> "Path":
+    """Diretório onde guardamos binários auxiliares baixados (gitleaks etc)."""
+    from pathlib import Path
+
+    if get_os() == "windows":
+        base = Path.home() / "AppData" / "Local" / "abyss-cli"
+    elif get_os() == "darwin":
+        base = Path.home() / "Library" / "Application Support" / "abyss-cli"
+    else:
+        base = Path.home() / ".local" / "share" / "abyss-cli"
+
+    base.mkdir(parents=True, exist_ok=True)
+    return base
+
+
+def is_supported() -> bool:
+    return sys.version_info >= (3, 9)

abyss_scanner-0.1.0/abyss/utils/redact.py

@@ -0,0 +1,25 @@
+"""Garante que secrets encontrados nunca aparecem em texto puro em logs,
+issues ou saída de terminal — só os últimos caracteres ficam visíveis."""
+
+
+def redact(secret: str, visible_chars: int = 4) -> str:
+    """Mascara um secret, mantendo só os últimos N caracteres visíveis.
+
+    Exemplo: redact("ghp_aBcD1234efGH5678") -> "••••••••••••••••5678"
+    """
+    if not secret:
+        return ""
+
+    if len(secret) <= visible_chars:
+        return "•" * len(secret)
+
+    masked_len = len(secret) - visible_chars
+    return ("•" * masked_len) + secret[-visible_chars:]
+
+
+def redact_line(line: str, secret: str, visible_chars: int = 4) -> str:
+    """Substitui a ocorrência do secret dentro de uma linha de código/log
+    pela versão mascarada, preservando o resto do contexto da linha."""
+    if secret not in line:
+        return line
+    return line.replace(secret, redact(secret, visible_chars))

abyss_scanner-0.1.0/abyss-test-repo/config_test.py

@@ -0,0 +1,13 @@
+"""Arquivo de teste — contém secrets FAKE só pra validar detecção do scanner.
+NÃO são credenciais reais. AWS_EXAMPLE_KEY é literalmente o exemplo oficial
+que a própria AWS usa na documentação deles pra ilustrar o formato de chave.
+"""
+
+# Exemplo oficial de chave AWS usado na documentação da AWS (não é real)
+AWS_ACCESS_KEY_ID = "AKIAIOSFODNN7EXAMPLE"
+AWS_SECRET_ACCESS_KEY = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+
+# Token fake no formato de GitHub personal access token (valor inventado pra teste)
+GITHUB_TOKEN = "ghp_1234567890abcdefghijklmnopqrstuvwxyz12"
+
+DATABASE_URL = "postgresql://admin:supersecretpassword123@localhost:5432/mydb"

abyss_scanner-0.1.0/abyss-test-repo/requirements.txt

@@ -0,0 +1 @@
+requests==2.6.0

abyss_scanner-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "abyss-scanner"
+version = "0.1.0"
+description = "Abyss — CLI que mergulha nas profundezas do seu código pra achar secrets vazados e dependências vulneráveis"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "Lohane", email = "lohane.mdev@gmail.com" }
+]
+dependencies = [
+    "typer>=0.12.0",
+    "rich>=13.7.0",
+    "requests>=2.31.0",
+    "PyGithub>=2.3.0",
+    "packaging>=24.0",
+    "questionary>=2.0.0",
+]
+
+[project.scripts]
+abyss = "abyss.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["abyss"]
+
+[tool.hatch.build]
+exclude = [
+    "venv",
+    ".venv",
+    "test-venv-fake",
+    "**/__pycache__",
+    "*.egg-info",
+    "dist",
+    "build",
+    ".pytest_cache",
+]

abyss_scanner-0.1.0/tests/test_redact.py

@@ -0,0 +1,25 @@
+from abyss.utils.redact import redact, redact_line
+
+
+def test_redact_keeps_last_4_chars():
+    assert redact("ghp_aBcD1234efGH5678") == "•" * 16 + "5678"
+
+
+def test_redact_short_secret_fully_masked():
+    assert redact("abc") == "•••"
+
+
+def test_redact_empty_string():
+    assert redact("") == ""
+
+
+def test_redact_line_replaces_secret_in_context():
+    line = 'API_KEY = "ghp_aBcD1234efGH5678"'
+    result = redact_line(line, "ghp_aBcD1234efGH5678")
+    assert "ghp_aBcD1234efGH5678" not in result
+    assert result.endswith('5678"')
+
+
+def test_redact_line_no_secret_present_unchanged():
+    line = "some unrelated line"
+    assert redact_line(line, "not-here") == line