_                                            _
    | | _____ _ __ _ __   __ _  __ _  ___ _ __ | |_
    | |/ / _ \ '__| '_ \ / _` |/ _` |/ _ \ '_ \| __|
    |   <  __/ |  | | | | (_| | (_| |  __/ | | | |_
    |_|\_\___|_|  |_| |_|\__,_|\__, |\___|_| |_|\__|
                                |___/

¿Por qué kernagent?

• Sin cabeza por diseño — se ejecuta en CI/Docker; no requiere interfaz de IDA/Ghidra, ni MCP
• Evidencia sobre corazonadas — cada respuesta cita funciones, referencias cruzadas, importaciones, cadenas y fragmentos de descompilación
• Determinista y portátil — mismo binario → misma instantánea → mismo informe; fácil de comparar y archivar
• Independiente del modelo — funciona con cualquier endpoint LLM /v1/chat/completions (OpenAI, Gemini, Ollama, LM Studio, tu puerta de enlace)

🚀 Inicio rápido

Requisitos

• Docker (Engine o Desktop) y Git
• SO de 64 bits (x86_64 o ARM64)
• 4 GB de RAM (se recomiendan 8+ GB para muestras grandes)
• Acceso a un endpoint LLM (internet o una puerta de enlace local /v1/chat/completions como Ollama o LM Studio)

Instalación

Elige el flujo que se adapte a tus herramientas. Todas las opciones montan ~/.config/kernagent/config.env para que configures las credenciales una sola vez.

Opción 1 — envoltorio install.sh (Linux / macOS / WSL2)

bash <(curl -fsSL https://raw.githubusercontent.com/Karib0u/kernagent/main/install.sh)

Si el comando de una línea está bloqueado:

curl -fsSL https://raw.githubusercontent.com/Karib0u/kernagent/main/install.sh -o install.sh
bash install.sh

O clona primero:

git clone https://github.com/Karib0u/kernagent.git
cd kernagent
bash install.sh

El script de instalación hace lo siguiente (totalmente auditable en scripts/):

1. Verifica que Docker esté instalado y en ejecución
2. Obtiene la imagen precompilada ghcr.io/karib0u/kernagent:latest del Registro de Contenedores de GitHub (sin paso de compilación)
3. Instala estos scripts de shell en /usr/local/bin/:
   • kernagent — envoltorio principal de CLI (monta automáticamente binarios y configuración)
   • kernagent-config — editor de configuración interactivo
   • kernagent-update — actualiza a la versión más reciente/etiquetada
   • kernagent-uninstall — elimina todos los archivos instalados
4. Guarda la información de la versión en ~/.config/kernagent/.version

Todos los scripts son código shell plano que puedes revisar en scripts/ antes de ejecutarlos. No se requiere sudo a menos que /usr/local/bin no sea escribible.

Avanzado — fijar instalación a una etiqueta/commit

Para instalar una versión específica del envoltorio y la imagen, apunta el bootstrap a un script etiquetado y pasa la etiqueta:

KERNAGENT_INSTALL_URL="https://raw.githubusercontent.com/Karib0u/kernagent/vX.Y.Z/scripts/install.sh" \
  bash <(curl -fsSL https://raw.githubusercontent.com/Karib0u/kernagent/main/install.sh) --tag vX.Y.Z

También puedes fijar a un commit exacto reemplazando vX.Y.Z con un SHA de commit en la URL sin procesar.

Opción 2 — Docker Compose (Linux / macOS / Windows + Docker Desktop)

git clone https://github.com/Karib0u/kernagent.git
cd kernagent
mkdir -p ~/.config/kernagent
cp config.env.example ~/.config/kernagent/config.env

# Obtén la imagen precompilada (recomendado)
docker compose pull

# O compila localmente para desarrollo
docker compose build

docker compose run --rm kernagent --help

Analiza binarios montando su directorio bajo /data:

docker compose run --rm \
  -v /absolute/path/to/binaries:/data \
  kernagent summary /data/sample.exe

En Windows (PowerShell + Docker Desktop), usa rutas absolutas al estilo Windows como C:\malware:/data.

Opción 3 — Docker directo (cualquier SO con Docker)

Obtén la imagen precompilada (recomendado):

mkdir -p ~/.config/kernagent
curl -fsSL https://raw.githubusercontent.com/Karib0u/kernagent/main/config.env.example \
  -o ~/.config/kernagent/config.env

docker pull ghcr.io/karib0u/kernagent:latest
docker run --rm \
  -v /absolute/path/to/binaries:/data \
  -v ~/.config/kernagent/config.env:/config/config.env:ro \
  ghcr.io/karib0u/kernagent:latest summary /data/sample.exe

O compila localmente:

git clone https://github.com/Karib0u/kernagent.git
cd kernagent
docker build -t kernagent:local .
docker run --rm \
  -v /absolute/path/to/binaries:/data \
  -v ~/.config/kernagent/config.env:/config/config.env:ro \
  kernagent:local summary /data/sample.exe

Verificar instalación

Opción 1 (envoltorio):

kernagent --help
kernagent --version

Ejecuta directamente:

kernagent summary /path/to/binary.exe
kernagent ask /path/to/binary.exe "¿Qué hace este binario?"
kernagent oneshot /path/to/binary.exe

Opciones 2 o 3 (Docker Compose / Docker sin procesar):

Verifica ejecutando la ayuda:

# Docker Compose
docker compose run --rm kernagent --help

# Docker sin procesar
docker run --rm ghcr.io/karib0u/kernagent:latest --help

Desinstalación

Opción 1 (envoltorio):

kernagent-uninstall

Opciones 2 o 3 (Docker Compose / Docker sin procesar):

Simplemente elimina el clon y las imágenes:

docker image rm ghcr.io/karib0u/kernagent:latest
# o
docker image rm kernagent:local

Actualización

Opción 1 (envoltorio):

kernagent-update          # cambia a la última versión
kernagent-update --check  # solo verificar
kernagent-update --tag vX.Y.Z  # fijar a una versión específica

Opciones 2 o 3 (Docker Compose / Docker sin procesar):

Vuelve a ejecutar docker compose pull o docker pull ghcr.io/karib0u/kernagent:latest.

Capturas de pantalla

Resumen — visión general ejecutiva con artefactos citados

Preguntar — Preguntas y respuestas enfocadas con referencias cruzadas/fragmentos de descompilación

Comandos

Primera ejecución — si no existe una instantánea <nombre>_archive/, kernagent la construye automáticamente antes de responder

summary

Visión general ejecutiva: propósito, capacidades, funciones/importaciones/cadenas clave, con direcciones para verificar

kernagent summary /path/to/binary
# JSON sin procesar (para automatización)
kernagent summary /path/to/binary --json

ask

Preguntas y respuestas interactivas sobre la instantánea utilizando herramientas seguras (buscar funciones/cadenas/importaciones, seguir el grafo de llamadas, leer descompilación, resolver referencias cruzadas)