vulnhuntr

Una herramienta para identificar vulnerabilidades explotables de forma remota utilizando LLMs y análisis estático de código.

Las primeras vulnerabilidades 0day del mundo descubiertas de forma autónoma por IA

Descripción

Vulnhuntr aprovecha el poder de los LLMs para crear y analizar automáticamente cadenas de llamadas de código completas, desde la entrada remota del usuario hasta la salida del servidor, para la detección de vulnerabilidades complejas, de múltiples pasos y que evaden la seguridad, y que van mucho más allá de lo que las herramientas tradicionales de análisis estático de código son capaces de realizar. Consulta todos los detalles, incluida la salida de Vulnhuntr para todos los 0-days, aquí: Protect AI Vulnhuntr Blog

Vulnerabilidades Encontradas

[!TIP] ¿Encontraste una vulnerabilidad usando Vulnhuntr? Envía un informe a huntr.com para obtener $$ y envía un PR para añadirla a la lista de abajo.

[!NOTE] Esta tabla es solo una muestra de las vulnerabilidades encontradas hasta ahora. Retiraremos la redacción a medida que terminen los períodos de divulgación responsable.

Limitaciones

• Solo se admiten bases de código Python.
• Solo puede identificar las siguientes clases de vulnerabilidades:
  • Inclusión local de archivos (LFI)
  • Sobrescritura arbitraria de archivos (AFO)
  • Ejecución remota de código (RCE)
  • Cross-site scripting (XSS)
  • Inyección SQL (SQLI)
  • Falsificación de solicitudes del lado del servidor (SSRF)
  • Referencia insegura directa a objetos (IDOR)

Instalación

[!IMPORTANT] Vulnhuntr requiere estrictamente Python 3.10 debido a una serie de errores en Jedi, que utiliza para analizar el código Python. No funcionará de forma fiable si se instala con cualquier otra versión de Python.

Recomendamos usar pipx o Docker para instalar y ejecutar Vulnhuntr fácilmente.

Usando Docker:

docker build -t vulnhuntr https://github.com/protectai/vulnhuntr.git#main

Usando pipx:

pipx install git+https://github.com/protectai/vulnhuntr.git --python python3.10

Alternativamente, puedes instalar directamente desde el código fuente usando poetry:

git clone https://github.com/protectai/vulnhuntr
cd vulnhuntr && poetry install

Uso

Esta herramienta está diseñada para analizar un repositorio de GitHub en busca de posibles vulnerabilidades explotables de forma remota. La herramienta requiere una clave de API y la ruta local a un repositorio de GitHub. También puedes especificar opcionalmente un endpoint personalizado para el servicio LLM.

[!CAUTION] Establece siempre límites de gasto o supervisa de cerca los costos con el proveedor de LLM que uses. Esta herramienta tiene el potencial de generar facturas elevadas, ya que intenta incluir la mayor cantidad de código posible en la ventana de contexto de los LLM.

[!TIP] Recomendamos usar Claude como LLM. Durante las pruebas hemos obtenido mejores resultados con él que con GPT.

Interfaz de Línea de Comandos

usage: vulnhuntr [-h] -r ROOT [-a ANALYZE] [-l {claude,gpt,ollama}] [-v]

Analyze a GitHub project for vulnerabilities. Export your ANTHROPIC_API_KEY/OPENAI_API_KEY before running.

options:
  -h, --help            show this help message and exit
  -r ROOT, --root ROOT  Path to the root directory of the project
  -a ANALYZE, --analyze ANALYZE
                        Specific path or file within the project to analyze
  -l {claude,gpt,ollama}, --llm {claude,gpt,ollama}
                        LLM client to use (default: claude)
  -v, --verbosity       Increase output verbosity (-v for INFO, -vv for DEBUG)

Ejemplos

Desde una instalación con pipx, analiza todo el repositorio usando Claude:

export ANTHROPIC_API_KEY="sk-1234"
vulnhuntr -r /path/to/target/repo/

[!TIP] Recomendamos proporcionar a Vulnhuntr archivos específicos que manejen la entrada remota del usuario y analizarlos individualmente.

Desde una instalación con pipx, analiza el archivo /path/to/target/repo/server.py usando GPT-4o. También puedes especificar un subdirectorio en lugar de un archivo:

export OPENAI_API_KEY="sk-1234"
vulnhuntr -r /path/to/target/repo/ -a server.py -l gpt 

Desde una instalación con Docker, ejecuta usando Claude y un endpoint personalizado para analizar /local/path/to/target/repo/repo-subfolder/target-file.py:

docker run --rm -e ANTHROPIC_API_KEY=sk-1234 -e ANTHROPIC_BASE_URL=https://localhost:1234/api -v /local/path/to/target/repo:/repo vulnhuntr:latest -r /repo -a repo-subfolder/target-file.py

Experimental

Ollama se incluye como opción; sin embargo, no hemos tenido éxito con los modelos de código abierto a la hora de estructurar su salida correctamente.

export OLLAMA_BASE_URL=http://localhost:11434/api/generate
export OLLAMA_MODEL=llama3.2
vulnhuntr -r /path/to/target/repo/ -a server.py -l ollama

Flujo Lógico

• El LLM resume el README e incluye esto en el prompt del sistema
• El LLM realiza un análisis inicial de un archivo completo e informa cualquier posible vulnerabilidad
• A continuación, Vulnhuntr le da al LLM un prompt específico de vulnerabilidad para un análisis secundario
• Cada vez que el LLM analiza el código, solicita funciones/clases/variables de contexto adicionales de otros archivos del proyecto
• Continúa haciendo esto hasta que toda la cadena de llamadas desde la entrada del usuario hasta el procesamiento del servidor está completa, y luego da un análisis final
• El análisis final consiste en su razonamiento, un exploit de prueba de concepto y una puntuación de confianza

[!TIP] Generalmente, las puntuaciones de confianza < 7 significan que es poco probable que haya una vulnerabilidad. Las puntuaciones de 7 significan que debe investigarse, y las puntuaciones de 8+ significan que es muy probable que sea una vulnerabilidad válida.

Salida

La herramienta genera un informe detallado de las vulnerabilidades encontradas en los archivos analizados. El informe incluye:

• Resultados de la evaluación inicial de cada archivo.
• Resultados de la evaluación secundaria con funciones de contexto y referencias a clases.
• Puntuaciones de confianza para las vulnerabilidades encontradas.
• Registros del proceso de análisis.
• Exploit de PoC

A continuación se muestra un ejemplo de un informe de Vulnhuntr que describe una vulnerabilidad de ejecución remota de código 0-day en Ragflow (ya corregida):

scratchpad:
  1. Analyzing the add_llm function in llm_app.py. 2. Identified user input used as keys to access dictionaries: EmbeddingModel, ChatModel, RerankModel,
CvModel, and TTSModel. 3. These dictionaries contain class references, which are instantiated with user-supplied parameters. 4. The factory variable is 
directly used from user input (req['llm_factory']) without proper validation. 5. The llm_name is also derived from user input in most cases. 6. The 
instantiation of these classes occurs in try-except blocks, but exceptions are only used for error messages, not preventing execution. 7. The api_key 
and other sensitive information are passed directly to these instantiated classes. 8. There's no comprehensive input validation or sanitization for the 
factory or llm_name variables. 9. The vulnerability is in a route decorated with @login_required, indicating it's accessible to authenticated users. 10.
Reviewing the EmbeddingModel, ChatModel, RerankModel, CvModel, and TTSModel dictionaries to understand their contents and potential for exploitation.
----------------------------------------

analysis:
  The add_llm function in llm_app.py contains a critical Remote Code Execution (RCE) vulnerability. The function uses user-supplied input 
(req['llm_factory'] and req['llm_name']) to dynamically instantiate classes from the EmbeddingModel, ChatModel, RerankModel, CvModel, and TTSModel 
dictionaries. This pattern of using user input as a key to access and instantiate classes is inherently dangerous, as it allows an attacker to 
potentially execute arbitrary code. The vulnerability is exacerbated by the lack of comprehensive input validation or sanitization on these 
user-supplied values. While there are some checks for specific factory types, they are not exhaustive and can be bypassed. An attacker could potentially
provide a malicious value for 'llm_factory' that, when used as an index to these model dictionaries, results in the execution of arbitrary code. The 
vulnerability is particularly severe because it occurs in a route decorated with @login_required, suggesting it's accessible to authenticated users, 
which might give a false sense of security.
----------------------------------------

poc:
  POST /add_llm HTTP/1.1
  Host: target.com
  Content-Type: application/json
  Authorization: Bearer <valid_token>
  
  {
      "llm_factory": "__import__('os').system",
      "llm_name": "id",
      "model_type": "EMBEDDING",
      "api_key": "dummy_key"
  }
  
  This payload attempts to exploit the vulnerability by setting 'llm_factory' to a string that, when evaluated, imports the os module and calls system. 
The 'llm_name' is set to 'id', which would be executed as a system command if the exploit is successful.
----------------------------------------

confidence_score:
  8
----------------------------------------

vulnerability_types:
  - RCE
----------------------------------------

Registro

La herramienta registra el proceso de análisis y los resultados en un archivo llamado vulnhuntr.log. Este archivo contiene información detallada sobre cada paso del análisis, incluidas las evaluaciones inicial y secundaria.

Autores

• Dan McInerney: [email protected], @DanHMcinerney
• Marcello Salvati: [email protected], @byt3bl33d3r