io.github.datahogo/datahogo
Scan a project for security issues locally with the open-source Data Hogo engine.
Open source Open in the app JSON README (API)
About
Scan a project for security issues locally with the open-source Data Hogo engine.
Details
- Kind
- MCP servers
- Topic
- No topic detected
- Publisher
- datahogo
- Origin
- official
- Category
- ferramentas
- Transport
- local
- Version
- 0.1.3
- Last push
- 2026-07-12T19:28:44Z
- Repository state
- ativo
- Language
- TypeScript
- License
- AGPL-3.0
- Added
- 2026-08-29 03:02:41
- Updated
- 2026-08-29 03:02:41
- Origin id
io.github.datahogo/datahogo
README
<div align="center">
# 保護 · Data Hogo
**Open-source security scanner that runs on your machine.
Your code never leaves your laptop.**
[](LICENSE)
[](https://www.npmjs.com/package/datahogo)
[](https://nodejs.org)
[English](#english) · [Español](#español) · [datahogo.com](https://datahogo.com)
</div>
---
<a name="english"></a>
## Why Data Hogo
Most security scanners ask you to hand over access to your repositories. Data Hogo doesn't. It's a CLI that runs **entirely on your machine** — it reads your files locally, finds vulnerabilities, and prints them to your terminal. Nothing is uploaded. There's no account, no sign-up, and no server to trust. The source is here for you to read.
It's built for developers and vibecoders who ship real projects but aren't security experts: it explains findings in plain language and, if you want, generates fixes using **your own** AI key.
```bash
npx datahogo
```
That's it. Point it at a project and it scans the current directory.
## Quick start
```bash
# Scan the current directory
npx datahogo
# Scan a specific path
npx datahogo scan ./my-app
# Fail CI if there are high-severity findings
npx datahogo scan --fail-on high
# Output SARIF for GitHub Code Scanning
npx datahogo scan --sarif > results.sarif
```
Install it globally if you'd rather not use `npx` every time:
```bash
npm install -g datahogo
datahogo scan
```
## What it checks
Data Hogo auto-detects your stack and runs the matching analyzers. Coverage is deepest for the JavaScript/TypeScript ecosystem; other languages have a focused set of high-signal checks.
| Stack | Examples of what's detected |
|-------|------------------------------|
| **JavaScript / TypeScript** | Node, Next.js, React, Express, Fastify, NestJS — injection, XSS, `eval`, insecure config, vulnerable dependencies, leaked secrets |
| **Python** | Django `DEBUG`, hardcoded `SECRET_KEY`, wildcard `ALLOWED_HOSTS`, Flask/FastAPI missing auth, vulnerable packages |
| **Go** | SQL injection, command injection, weak crypto, hardcoded credentials |
| **Java / Kotlin** | Spring endpoints without authorization, unsafe deserialization, XXE, SQL injection |
| **PHP / Laravel** | Mass assignment, SQL injection, unsafe file handling |
| **C# / .NET** | Missing `[Authorize]`, `BinaryFormatter` deserialization, XXE, weak hashing |
| **Mobile** | React Native, Expo, Flutter/Dart — insecure storage, hardcoded secrets |
| **Supabase** | Row Level Security gaps, exposed service keys, insecure policies |
Secrets detection and dependency scanning run across every project regardless of language.
### Optional: deeper analysis
Two industry-standard tools add extra depth when installed. Data Hogo works fine without them — it just uses its built-in checks and tells you what you're missing.
```bash
datahogo doctor # shows what's installed and how to add the rest
```
- **[Semgrep](https://semgrep.dev)** — ~250 additional AST-based rules for JS/TS
- **[Gitleaks](https://github.com/gitleaks/gitleaks)** — comprehensive secret-detection ruleset
## AI explanations & fixes (bring your own key)
Every finding comes with a plain-language explanation and a suggested fix out of the box. If you want richer, context-aware fixes generated by Claude, set your own Anthropic API key — the calls go directly from your machine to Anthropic, billed to you. We never see them.
```bash
export ANTHROPIC_API_KEY=sk-ant-...
datahogo scan --explain
```
## Use it in CI
### GitHub Action
```yaml
# .github/workflows/security.yml
name: Security
on: [push, pull_request]
permissions:
contents: read
security-events: write
jobs:
scan:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: datahogo/datahogo@main
with:
fail-on: high
```
Findings show up in your repository's **Security** tab automatically. See [`action.yml`](action.yml) for every input (`path`, `url`, `upload-sarif`).
### Any other CI
Data Hogo exits with a non-zero code when it finds issues at or above the severity you choose, so it drops straight into any pipeline:
```yaml
- run: npx datahogo scan --fail-on high --sarif > results.sarif
- uses: github/codeql-action/upload-sarif@v3
if: always()
with:
sarif_file: results.sarif
```
The SARIF output shows up in your repository's **Security** tab.
## Commands & options
```
datahogo [scan] [path] Scan a directory (default: current directory)
datahogo doctor Check optional external tools
--json Machine-readable JSON output
--sarif SARIF 2.1.0 (GitHub Code Scanning)
--fail-on <severity> Exit 1 if findings >= critical|high|medium|low
--url <url> Also scan a deployed URL (headers, SSL, CORS)
--explain AI explanations (requires ANTHROPIC_API_KEY)
--all Include informational / non-production findings
--help, --version
```
## Use it from Claude Code, Cursor, or Claude Desktop (MCP)
`@datahogo/mcp` exposes the same scan engine as MCP tools, so your agent can scan a project, pull a specific finding, check a deployed URL, or review Supabase/Firebase rules — and write the explanation and fix itself, at no AI cost to you.
```bash
claude mcp add datahogo -- npx -y @datahogo/mcp
```
For Cursor or another MCP client, point it at the same command: `npx -y @datahogo/mcp`, stdio transport.
Tools: `scan_project`, `get_finding`, `scan_url`, `check_db_rules`.
Prefer a lighter footprint in Claude Code specifically? Install the
[Claude Code skill](skills/datahogo) instead — it just teaches the agent to
run `npx datahogo scan --json` and interpret the output, no MCP server
process required:
```bash
npx skills add datahogo/datahogo/skills/datahogo
```
## Data Hogo Cloud
The CLI is free and always will be. If you want scan history, findings tracked across commits, automatic fix pull requests, scheduled scans, and team dashboards, [Data Hogo Cloud](https://datahogo.com) builds those on top of the same engine. Using the CLI never requires it.
## Contributing
Issues and pull requests are welcome — new detection rules for any language are especially valuable. The scan engine lives in [`packages/core`](packages/core) and the CLI in [`packages/cli`](packages/cli).
```bash
git clone https://github.com/datahogo/datahogo.git
cd datahogo
npm install
npm run build
npm test
```
## Support the project
Data Hogo is free and open source. If it saved you from shipping a vulnerability, consider [sponsoring the project](https://github.com/sponsors/datahogo) — it funds new detection rules and keeps the lights on.
## License
[AGPL-3.0](LICENSE) © Data Hogo. You're free to use, read, run, and modify it. If you offer a modified version as a network service, you must share your source under the same license.
---
<a name="español"></a>
## Por qué Data Hogo
La mayoría de los escáneres de seguridad te piden acceso a tus repositorios. Data Hogo no. Es una herramienta de línea de comandos que corre **completamente en tu máquina**: lee tus archivos localmente, encuentra vulnerabilidades y las muestra en tu terminal. No se sube nada. No hay cuenta, no hay registro, no hay servidor en quien confiar. El código está aquí para que lo leas.
Está hecho para developers y vibecoders que lanzan proyectos reales pero no son expertos en seguridad: explica los hallazgos en lenguaje simple y, si quieres, genera arreglos usando **tu propia** llave de AI.
```bash
npx datahogo
```
Eso es todo. Apúntalo a un proyecto y escanea el directorio actual.
## Inicio rápido
```bash
# Escanear el directorio actual
npx datahogo
# Escanear una ruta específica
npx datahogo scan ./mi-app
# Romper el CI si hay hallazgos de severidad alta
npx datahogo scan --fail-on high
# Generar SARIF para GitHub Code Scanning
npx datahogo scan --sarif > results.sarif
```
Instálalo de forma global si prefieres no usar `npx` cada vez:
```bash
npm install -g datahogo
datahogo scan
```
## Qué revisa
Data Hogo detecta tu stack automáticamente y corre los analizadores que correspondan. La cobertura es más profunda en el ecosistema JavaScript/TypeScript; los demás lenguajes tienen un conjunto enfocado de checks de alta señal.
| Stack | Ejemplos de lo que detecta |
|-------|-----------------------------|
| **JavaScript / TypeScript** | Node, Next.js, React, Express, Fastify, NestJS — inyección, XSS, `eval`, config insegura, dependencias vulnerables, secretos filtrados |
| **Python** | `DEBUG` de Django, `SECRET_KEY` hardcodeado, `ALLOWED_HOSTS` con comodín, Flask/FastAPI sin auth, paquetes vulnerables |
| **Go** | Inyección SQL, inyección de comandos, criptografía débil, credenciales hardcodeadas |
| **Java / Kotlin** | Endpoints de Spring sin autorización, deserialización insegura, XXE, inyección SQL |
| **PHP / Laravel** | Mass assignment, inyección SQL, manejo de archivos inseguro |
| **C# / .NET** | Falta de `[Authorize]`, deserialización con `BinaryFormatter`, XXE, hashing débil |
| **Móvil** | React Native, Expo, Flutter/Dart — almacenamiento inseguro, secretos hardcodeados |
| **Supabase** | Fallas de Row Level Security, service keys expuestas, políticas inseguras |
La detección de secretos y el escaneo de dependencias corren en todos los proyectos sin importar el lenguaje.
### Opcional: análisis más profundo
Dos herramientas estándar de la industria agregan profundidad extra si las tienes instaladas. Data Hogo funciona bien sin ellas: usa sus checks integrados y te dice qué te estás perdiendo.
```bash
datahogo doctor # muestra qué tienes instalado y cómo agregar lo demás
```
- **[Semgrep](https://semgrep.dev)** — ~250 reglas adicionales basadas en AST para JS/TS
- **[Gitleaks](https://github.com/gitleaks/gitleaks)** — conjunto completo de reglas de detección de secretos
## Explicaciones y arreglos con AI (usa tu propia llave)
Cada hallazgo viene con una explicación en lenguaje simple y un arreglo sugerido de fábrica. Si quieres arreglos más ricos y con contexto generados por Claude, configura tu propia llave de API de Anthropic: las llamadas van directo de tu máquina a Anthropic, facturadas a ti. Nosotros nunca las vemos.
```bash
export ANTHROPIC_API_KEY=sk-ant-...
datahogo scan --explain
```
## Úsalo en CI
### GitHub Action
```yaml
# .github/workflows/security.yml
name: Security
on: [push, pull_request]
permissions:
contents: read
security-events: write
jobs:
scan:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: datahogo/datahogo@main
with:
fail-on: high
```
Los hallazgos aparecen automáticamente en la pestaña **Security** de tu repositorio. Ve [`action.yml`](action.yml) para todas las opciones (`path`, `url`, `upload-sarif`).
### Cualquier otro CI
Data Hogo termina con un código distinto de cero cuando encuentra problemas de la severidad que elijas, así que encaja en cualquier pipeline:
```yaml
- run: npx datahogo scan --fail-on high --sarif > results.sarif
- uses: github/codeql-action/upload-sarif@v3
if: always()
with:
sarif_file: results.sarif
```
El resultado SARIF aparece en la pestaña **Security** de tu repositorio.
## Comandos y opciones
```
datahogo [scan] [ruta] Escanea un directorio (por defecto: el actual)
datahogo doctor Revisa las herramientas externas opcionales
--json Salida JSON legible por máquina
--sarif SARIF 2.1.0 (GitHub Code Scanning)
--fail-on <severidad> Sale con 1 si hay hallazgos >= critical|high|medium|low
--url <url> Escanea también una URL desplegada (headers, SSL, CORS)
--explain Explicaciones con AI (requiere ANTHROPIC_API_KEY)
--all Incluye hallazgos informativos / no productivos
--help, --version
```
## Úsalo desde Claude Code, Cursor o Claude Desktop (MCP)
`@datahogo/mcp` expone el mismo motor de escaneo como tools de MCP, así que tu agente puede escanear un proyecto, consultar un hallazgo específico, revisar una URL desplegada o auditar reglas de Supabase/Firebase — y escribir la explicación y el arreglo él mismo, sin costo de AI para ti.
```bash
claude mcp add datahogo -- npx -y @datahogo/mcp
```
Para Cursor u otro cliente MCP, apúntalo al mismo comando: `npx -y @datahogo/mcp`, transporte stdio.
Tools: `scan_project`, `get_finding`, `scan_url`, `check_db_rules`.
¿Prefieres algo más ligero específicamente en Claude Code? Instala el
[skill de Claude Code](skills/datahogo) en su lugar — solo le enseña al
agente a correr `npx datahogo scan --json` e interpretar la salida, sin
necesidad de un proceso de servidor MCP:
```bash
npx skills add datahogo/datahogo/skills/datahogo
```
## Data Hogo Cloud
La CLI es gratis y siempre lo será. Si quieres historial de escaneos, seguimiento de hallazgos entre commits, pull requests de arreglos automáticos, escaneos programados y dashboards de equipo, [Data Hogo Cloud](https://datahogo.com) construye todo eso sobre el mismo motor. Usar la CLI nunca lo requiere.
## Contribuir
Los issues y pull requests son bienvenidos — las nuevas reglas de detección para cualquier lenguaje son especialmente valiosas. El motor de escaneo vive en [`packages/core`](packages/core) y la CLI en [`packages/cli`](packages/cli).
```bash
git clone https://github.com/datahogo/datahogo.git
cd datahogo
npm install
npm run build
npm test
```
## Apoya el proyecto
Data Hogo es gratis y open source. Si te salvó de lanzar una vulnerabilidad, considera [patrocinar el proyecto](https://github.com/sponsors/datahogo) — financia nuevas reglas de detección y mantiene el proyecto vivo.
## Licencia
[AGPL-3.0](LICENSE) © Data Hogo. Eres libre de usarlo, leerlo, correrlo y modificarlo. Si ofreces una versión modificada como servicio en red, debes compartir tu código bajo la misma licencia.