rcekit — Kit de herramientas de detección y confirmación de RCE que prueba URLs o solicitudes HTTP capturadas en busca de inyección de comandos, SSTI, rutas ciegas y OOB, devolviendo veredictos por niveles con pruebas. | Kitploit

**O simplemente toma el único archivo.** El corpus de payloads está integrado en el módulo, por lo que
`rcekit.py` se ejecuta por sí solo sin nada más — sin paso de instalación, sin
site-packages, nada que dejar atrás. En un jump box de cliente, un host
air-gapped, o en cualquier lugar donde `pip install` no sea una opción:```bash
curl -O https://raw.githubusercontent.com/kabiri-labs/rcekit/main/rcekit.py
python rcekit.py --doctor    # same corpus, same check, zero installation

Coloca un marcador `FUZZ` donde llegue tu entrada (o selecciona un parámetro con `-p` cuando
uses una solicitud capturada), y pídele a RCEKit que demuestre RCE:```bash
rcekit --acknowledge-consent \
  --verify-url "https://target.example/lookup?host=FUZZ" \
  --methods reflected,eval

# Scan a single target
python3 vulnscan.py -t https://example.com

# Scan multiple targets from a file
python3 vulnscan.py -l targets.txt

# Save results in JSON format
python3 vulnscan.py -t https://example.com -o results.json -f json

# Use a custom configuration file
python3 vulnscan.py -t https://example.com -c config.yaml

# Enable verbose output
python3 vulnscan.py -t https://example.com -v

# Scan settings
scan:
  timeout: 30
  threads: 10
  user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"

# Modules to enable
modules:
  - sqli
  - xss
  - lfi
  - rfi
  - ssrf

# Authentication settings
auth:
  enabled: false
  username: ""
  password: ""

# Proxy settings
proxy:
  enabled: false
  http: "http://127.0.0.1:8080"
  https: "https://127.0.0.1:8080"

### Desde una solicitud capturada — la forma que tienen la mayoría de los objetivos reales

Un `--verify-url` transporta una URL y nada más. La mayoría de los sinks que vale la pena probar se encuentran detrás de un POST con una cookie de sesión, un tipo de contenido y un cuerpo, y RCEKit toma esa solicitud completa: guárdala desde tu proxy o las devtools de tu navegador y nombra el campo en el que inyectar.```bash
rcekit --acknowledge-consent \
  -r search.req -p q \
  --methods reflected,eval

# Escanear un solo objetivo
scanner scan --target https://example.com

# Escanear múltiples objetivos desde un archivo
scanner scan --targets-file targets.txt

# Escanear con formato de salida específico
scanner scan --target https://example.com --format sarif --output results.sarif

# Escanear con autenticación
scanner scan --target https://example.com --token YOUR_API_TOKEN

# Escanear con proxy
scanner scan --target https://example.com --proxy http://proxy.example.com:8080

# Escanear con configuración personalizada
scanner scan --target https://example.com --config custom-config.yaml

# scanner-config.yaml
server: http://localhost:8080
token: YOUR_API_TOKEN
timeout: 30
retries: 3
insecure: false
proxy: null
output: results.json
format: json
verbose: false
quiet: false
no_color: false
debug: false

# Clonar el repositorio
git clone https://github.com/example/scanner.git
cd scanner

# Compilar el binario
make build

# O compilar directamente con Go
go build -o scanner ./cmd/scanner

# Ejecutar pruebas
make test

# Ejecutar linter
make lint

scanner/
├── cmd/
│   └── scanner/
│       └── main.go
├── internal/
│   ├── api/
│   ├── config/
│   ├── scanner/
│   └── utils/
├── pkg/
│   └── models/
├── docs/
├── examples/
├── scripts/
├── Makefile
├── go.mod
├── go.sum
└── README.md

# Ejecutar todas las pruebas
make test

# Ejecutar pruebas con cobertura
make test-coverage

# Ejecutar pruebas de un paquete específico
go test ./internal/scanner/...

# Ejecutar pruebas con salida detallada
go test -v ./...

El método, la ruta, las cabeceras, el cuerpo y las cookies se reutilizan tal como se capturaron, y cada valor se codifica para el contexto en el que termina — una hoja JSON, un campo de formulario y una cookie no se escapan de la misma manera. Elimina `-p` y marca el punto con `FUZZ` o `*` en su lugar, si lo prefieres.

### Todo lo que tiene la herramienta

Dos cosas solo son accesibles desde una solicitud capturada: la **enumeración de puntos de inyección** (`--auto-params`), y cualquier sink que necesite una sesión. Así que la ejecución más completa que RCEKit puede hacer comienza desde `-r`, no desde una URL — lo cual vale la pena saber antes de concluir que un objetivo está limpio.```bash
rcekit --acknowledge-consent \
  -r search.req --auto-params all --point-order thorough \
  --methods reflected,eval,time,lookup,deser \
  --oob-host oob.yourdomain.example --listen-dns-port 53 \
  --verify-active-risk stateful --probe-depth full \
  --detect-json findings.json

# Escaneo básico
scanner -u https://example.com

# Escaneo con salida a archivo
scanner -u https://example.com -o results.json

# Escaneo con formato de salida CSV
scanner -u https://example.com -f csv -o results.csv

# Escaneo con autenticación
scanner -u https://example.com -t YOUR_API_TOKEN

# Escaneo con proxy
scanner -u https://example.com -P socks5://127.0.0.1:1080

# Escaneo de múltiples objetivos desde archivo
scanner -l targets.txt -o results.json

# Escaneo en modo profundo con paralelismo
scanner -u https://example.com -m deep -p 8

# Escaneo con encabezados personalizados
scanner -u https://example.com -H "Authorization: Bearer TOKEN" -H "X-Custom: value"

# Escaneo silencioso con salida a archivo
scanner -u https://example.com -q -o results.json

# Escaneo con reintentos y tiempo de espera personalizados
scanner -u https://example.com -r 5 -T 60

# Escaneo omitiendo la verificación TLS
scanner -u https://example.com -k

# Escaneo con modo de depuración
scanner -u https://example.com -d

server: http://localhost:8080
token: YOUR_API_TOKEN
output: results.json
format: json
verbose: false
quiet: false
parallel: 4
retry: 3
timeout: 30
insecure: false
user_agent: "Mozilla/5.0"
proxy: null
exclude: []
include: []
mode: fast
debug: false

Variable	Descripción	Valor predeterminado
`SCANNER_SERVER`	URL del servidor de escaneo	`http://localhost:8080`
`SCANNER_TOKEN`	Token de autenticación de la API	`null`
`SCANNER_OUTPUT`	Ruta del archivo de salida	`null`
`SCANNER_FORMAT`	Formato de salida	`json`
`SCANNER_VERBOSE`	Habilitar registro detallado	`false`
`SCANNER_QUIET`	Modo silencioso	`false`
`SCANNER_PARALLEL`	Número de escaneos paralelos	`4`
`SCANNER_RETRY`	Número de reintentos	`3`
`SCANNER_TIMEOUT`	Tiempo de espera de la solicitud	`30`
`SCANNER_INSECURE`	Omitir la verificación TLS	`false`
`SCANNER_USER_AGENT`	Cadena de User-Agent	`Mozilla/5.0`
`SCANNER_PROXY`	URL del proxy	`null`
`SCANNER_MODE`	Modo de escaneo	`fast`
`SCANNER_DEBUG`	Habilitar salida de depuración	`false`

Código	Descripción
`0`	Éxito
`1`	Error general
`2`	Error de uso de CLI
`3`	Error de autenticación
`4`	Error de conexión
`5`	Tiempo de espera agotado
`6`	Archivo no encontrado
`7`	Permiso denegado
`8`	Configuración no válida
`9`	Objetivo no válido
`10`	Error interno

Lo que abre cada flag:

| | |
|---|---|
| `--auto-params all` | cada valor de consulta, hoja JSON, campo de formulario, parte multipart, cookie y cabecera, en lugar de un único campo nombrado |
| `--point-order thorough` | cada cabecera que no sea hop-by-hop, no solo las de alto rendimiento |
| `--methods ...,lookup,deser` | sumideros de expresión-lookup y deserialización, que los métodos con forma de shell no pueden alcanzar |
| `--oob-host` | un host de callback para los métodos ciegos. Necesita un dominio delegado a ti; el puerto 53 requiere root |
| `--verify-active-risk stateful` | el nivel superior — añade las formas de sonda que hacen que el objetivo obtenga desde una dirección que RCEKit no eligió |
| `--probe-depth full` | cada forma de escape por sumidero, no solo las baratas |
| `--detect-json` | los mismos veredictos en JSON legible por máquina |

**Esto son muchas peticiones.** La línea de coste se imprime antes de que se dispare nada, y
`--max-points` / `--max-payloads` la acotan. Ejecútalo contra una instancia que tengas
permitido romper: `--verify-active-risk stateful` es el nivel para un objetivo desechable, no para producción.

Sin infraestructura externa, sin archivo de configuración.

**No te fíes de los GIFs** — [reprodúcelos tú mismo](https://github.com/kabiri-labs/rcekit/blob/main/docs/verify-it-yourself.md)
contra objetivos Webmin y Struts2 dockerizados en unos cinco minutos.

**A continuación:** la [**guía de campo**](https://github.com/kabiri-labs/rcekit/blob/main/docs/guide.md) recorre las situaciones reales — peticiones
capturadas, WAFs, separadores filtrados, sumideros entrecomillados, objetivos ciegos y sin salida —
con un ejemplo práctico de cada una.

---

## Qué significa un veredicto

Encontrar un *candidato* a RCE es fácil. Reportar uno que sobreviva al retest de otra persona es la parte difícil, y falla en dos direcciones: un "posiblemente vulnerable" que resulta ser reflexión, y un "no vulnerable" de una ejecución que en realidad nunca probó nada.

RCEKit responde con **ocho veredictos que nunca se colapsan entre sí**:

| Veredicto | Qué afirma |
|---|---|
| **`confirmed`** | El objetivo ejecutó la entrada. Devolvió un valor que no podía producir de otro modo — calculado a partir de operandos aleatorios para esa sonda — y ese valor está ausente en un control sin payload. |
| **`deserialization-sink`** | El objetivo reconstruyó un grafo de objetos proporcionado por el atacante. Probado, pero sobre una *propiedad diferente*: llegar a RCE desde ahí depende de gadgets del classpath, por lo que nunca se denomina RCE. |
| **`lookup-sink`** | El objetivo resolvió una URI que RCEKit le entregó — una expresión `${jndi:…}` alcanzó un lookup, probado en un callback que llevaba un token que solo esa sonda poseía. Es un sumidero, no ejecución: llegar a RCE desde ahí necesita un servidor que responda con una clase cargable. |
| **`needs-review`** | Una señal real que no es prueba por sí sola — una regresión de temporización lineal, una huella de parser. Merece tu tiempo, nunca merece la palabra "confirmed". |
| **`inconclusive`** | La evidencia apareció, pero no pudo atribuirse a la ejecución — el control sin payload también la llevaba. |
| **`negative`** | Se construyeron sondas, alcanzaron el objetivo y no encontraron nada. |
| **`error`** | Nada alcanzó el objetivo. |
| **`nothing-tested`** | No se construyó ninguna sonda. |

En el momento en que `confirmed` y `maybe` se difuminan, `confirmed` deja de significar algo — por
lo que nada se promociona nunca hacia arriba. Una regresión de temporización se queda en `needs-review` por muy
limpia que sea la pendiente. Un callback de deserialización se queda en `deserialization-sink` por muy
seguro que estés de que el classpath es explotable.

### La otra mitad: una ejecución que no probó nada nunca está limpia

Las dos últimas filas son las que otras herramientas no tienen, y importan más de lo que
parecen. Un escáner que no pudo alcanzar el objetivo, o que no construyó ninguna sonda porque
tus flags excluyeron todas ellas, no ha aprendido **nada** sobre el objetivo —
e imprimir `negative` ahí es una mentira que se lee exactamente como seguridad.

Así que `error` y `nothing-tested` son veredictos de primera clase, la ejecución sale con código distinto de cero,
y RCEKit dice cuál de ellos ocurrió y por qué:```
[!] No probes were built, so NOTHING WAS TESTED — this is not a negative result.
[!] None of the selected methods (reflected, file) apply to environment(s): sql.

Clase de RCE	`--methods`	Cómo lo demuestra RCEKit
Inyección de comandos del SO	`reflected`	Hace que el shell calcule `$((a+b))` sobre operandos aleatorios y colapse `$(echo TAG)`; confirma el resultado, nunca la expresión literal. Escrito en el propio dialecto del sink — POSIX, `cmd.exe` o PowerShell.
Inyección de código / expresión — SSTI, SpEL, OGNL, Groovy, `eval()` (CWE-94)	`eval`	Inyecta `ab` en cada sintaxis de plantilla común (`${…}` `{{…}}` `#{…}` `%{…}` `<%=…%>` `@(…)`, sin envoltorio); confirma que aparece el producto* mientras que el literal `a*b` no.
Inyección de comandos ciega (sin salida)	`time`	Dispara una serie de retardos controlada `0/N/2N` y confirma que el tiempo de respuesta sigue el retardo de forma lineal; reportado como `needs-review` — el jitter no puede falsificarlo, pero el timing no es un valor calculado.
Objetivos internos / sin salida	`file`	Escribe un token aleatorio y lo recupera a través de cualquier ruta de lectura — una raíz web, un parámetro LFI, un manejador de descarga o exportación, una vista previa respaldada por `/tmp`. Demuestra ejecución más una primitiva de escritura, sin listener externo.
Primitiva de subida / escritura — PUT-a-JSP, subida sin verificar (CWE-434)	`write`	Escribe un one-liner que calcula un producto a través de tu propia solicitud de subida, luego recupera el archivo: el producto es RCE `confirmed`, el código fuente que vuelve textual es `needs-review` — escritura arbitraria de archivos, servida pero no interpretada.
Sinks de deserialización — fastjson, shiro, weblogic (CWE-502)	`deser`	Demuestra que el endpoint deserializa datos del atacante, mediante un gadget DNS no ejecutable o un diferencial de forma de error. Reportado como , como RCE.

Puede confirmar	RCEKit	commix	SSTImap	Nuclei
Inyección de comandos del SO	✅	✅ (todo su alcance)	—	por plantilla
Inyección de expresión / SSTI	✅	mediante su técnica basada en eval	✅ (todo su alcance)	por plantilla
Ciego — timing	✅ como nivel separado	✅	✅	—
Ciego — fuera de banda	✅ listener integrado	—	—	mediante interactsh
Sin salida — escribir y recuperar	✅ cualquier ruta de lectura	✅ (raíz web)	—	—
Sinks `cmd.exe` y PowerShell	✅ sondas por dialecto	✅ (cmd)	—	por plantilla
Subida → escribir-luego-ejecutar	✅ escritura vs. ejecución, niveles separados	—	—	por plantilla
Segundo orden — aterriza aquí, se ejecuta allí	✅	—	—	—
Puente de lenguaje de consulta al SO	✅	—	—	por plantilla
Sink de deserialización	✅ nivel propio, nunca llamado RCE	—	—	por plantilla
Todo lo anterior, una CLI, una ejecución	✅	—	—	—

### 2. Discute con sus propios resultados

Una herramienta informa lo que encontró. RCEKit también informa **lo que se negó a creer** —
`inconclusive` es un veredicto propio, para evidencia que apareció pero que no pudo
atribuirse a la ejecución:```
[detect] methods: reflected, eval
[detect] sent 13 probes: confirmed=0, inconclusive=2, negative=11


Puerta de consentimiento	Nada explotador se genera ni se dispara sin `--acknowledge-consent`.
Plan de ejecución	Imprime el número exacto de sondas, las formas de sink, los niveles de seguridad y cualquier destino de callback saliente antes de que salga la primera solicitud.
Seguro por defecto	Las reverse shells, el acceso a credenciales, los metadatos de la nube, el movimiento lateral y el escape de contenedores se retienen hasta que eleves `--verify-active-risk`; la persistencia y las puertas traseras necesitan una segunda bandera adicional. Los puentes que crean un objeto en el objetivo están sujetos al mismo techo.
Comandos de limpieza	`file`, `write` y los puentes con estado cambian el estado del objetivo, por lo que cada hallazgo — incluido un `needs-review` — imprime qué ejecutar para deshacerlo.
Las credenciales se quedan donde están	La recuperación de lectura de `file` lleva las cabeceras `Authorization`/`Cookie` de la ejecución solo al mismo origen, y lo dice en voz alta cuando las retiene. La recuperación del canal observado no envía ninguna en absoluto a menos que le entregues una solicitud con `--observe-request`.
Rastro de auditoría redactado	Cada ejecución queda en `exploit_audit.log`, registrando que se envió una cabecera de credencial, nunca su valor.
Marca de agua	`--watermark` estampa un token rastreable en cada payload, de modo que un payload encontrado en los registros del cliente meses después sea atribuible a tu ejecución.
Sin callbacks de terceros	El listener OOB es tuyo. Nada se enruta a través de un servidor de interacción público, que algunos compromisos prohíben directamente.
Un solo archivo de la stdlib	`rcekit.py` se ejecuta solo — jump box, host con air-gap, donde sea que `pip install` no sea una opción.

Situación	Ir a
Tengo una URL y un parámetro	Apuntar a una URL
Tengo una solicitud guardada de Burp	Apuntar a una solicitud capturada
La app es JSON / el payload sigue siendo destrozado	Aterrizar el payload intacto
No sé de qué clase es	Elegir métodos
El sink elimina `;`	Cuando el sink filtra separadores
Mi entrada aterriza dentro de `'comillas'`	Inyectar dentro de comillas
El sink ejecuta mi entrada como el comando completo	Sinks de comando completo
El objetivo es Windows o el sink es PowerShell	Sinks de Windows y PowerShell
Hay un WAF	Trabajar alrededor de un WAF
No vuelve ninguna salida en absoluto	Objetivos ciegos
Sin salida y sin egreso	Objetivos sin egreso
La solicitud almacena un archivo en lugar de ejecutar algo	Objetivos de subida y primitiva de escritura


Verifícalo tú mismo	Reproduce las confirmaciones anteriores en tu propia máquina, contra objetivos vulnerables dockerizados. Cinco minutos.
Guía de campo	Recorrido basado en ejemplos de cada situación real, desde una primera sonda hasta cadenas de múltiples pasos. Empieza aquí.
Generación de payloads y exportaciones	RCEKit como generador de payloads: perfiles de objetivo, y exportaciones de Burp / ffuf / Nuclei.
Referencia	Cada bandera, entorno, categoría, contexto, codificación y sink de ejecución de código.
CHANGELOG.md	Qué cambió en cada versión, y qué volver a comprobar al actualizar.
CONTRIBUTING.md	Cómo añadir sinks, categorías, codificaciones y métodos de detección.
SECURITY.md	Reportar una vulnerabilidad en RCEKit mismo.

Las contribuciones son bienvenidas — nuevos sinks/categorías, codificaciones, entornos, métodos de detección, correcciones de errores y documentación. Las bases de payloads residen en plantillas JSON editables
(`templates/payloads.json`), por lo que la mayor parte de la cobertura se amplía sin tocar el código
fuente de Python. Después de modificar el corpus, actualiza la copia integrada que se distribuye dentro de
`rcekit.py`:```bash
python tools/embed_corpus.py    # --check verifies it is current

deserialization-sink

Inyección de comandos del SO (basada en resultados)	`reflected`	Webmin 1.910 — CVE-2019-15107	`confirmed`
Inyección de expresiones (OGNL)	`eval`	Apache Struts2 — S2-001	`confirmed`
Búsqueda de expresiones (Log4Shell/JNDI)	`lookup`	Apache Solr 8.11.0 (Log4j 2.14.1) — CVE-2021-44228	`lookup-sink`
Inyección de comandos ciega (sin salida)	`time`	Webmin 1.910 — CVE-2019-15107	`needs-review`

rcekit

Más Populares

RCEKit

Prueba, no "quizás"

Inicio rápido

Examples

Configuration

Modules

SQL Injection

Cross-Site Scripting (XSS)

Local File Inclusion (LFI)

Remote File Inclusion (RFI)

Server-Side Request Forgery (SSRF)

Output

Disclaimer

Ejemplos de Uso

Archivo de Configuración

Desarrollo

Requisitos Previos

Compilación desde el Código Fuente

Estructura del Proyecto

Ejecución de Pruebas

Contribución

Directrices de Contribución

Registro de Cambios

v1.2.0 (2024-01-15)

v1.1.0 (2023-12-01)

v1.0.0 (2023-11-01)

Licencia

Agradecimientos

Soporte

Descargo de Responsabilidad

Ejemplos de uso

Archivo de configuración

Variables de entorno

Códigos de salida

Solución de problemas

El escáner no se conecta al servidor

El escaneo se agota por tiempo de espera

Errores de certificado TLS

El archivo de salida no se genera

Registro de cambios

Contribuir

Licencia

Descargo de responsabilidad

Agradecimientos

Qué confirma

Cómo se compara RCEKit

1. Un punto de inyección, todas las clases, una ejecución

Command injection, expression injection and blind timing against the same

parameter, in one pass, with zero infrastructure

3. Está construido para un compromiso autorizado, no para un laboratorio

Cuándo recurrir a otra cosa

Encuentra tu situación

Documentación

Seguridad y ética

Desarrollo```bash

Licencia