Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
kernagent — Agent IA sans tête pour le rétro-ingénierie déterministe. | Kitploit
Outils/GitHubGitHub/karib0u/kernagent
Analyse StatiqueRétro-ingénierieAnalyse ForensiqueAnalyse de MalwareAnalyse de BinairesRenseignement sur les MenacesRétro-Ingénierie Assistée par IA
GitHubkarib0u/kernagent

kernagent

Agent IA sans tête pour le rétro-ingénierie déterministe.

Voir le dépôt
1011152il y a 9 moisVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager
root@kitploit:~
     _                                            _
    | | _____ _ __ _ __   __ _  __ _  ___ _ __ | |_
    | |/ / _ \ '__| '_ \ / _` |/ _` |/ _ \ '_ \| __|
    |   <  __/ |  | | | | (_| | (_| |  __/ | | | |_
    |_|\_\___|_|  |_| |_|\__,_|\__, |\___|_| |_|\__|
                                |___/

🔍 kernagent

CI Release License: Apache 2.0 Docker

Transformez les binaires en conversations — déterministe, auditable, utilisable hors ligne.

kernagent convertit un binaire en instantané statique portable et permet à un LLM (ou à vos scripts) de répondre aux questions avec des preuves.

Pas d'IDE en direct • Pas d'automatisation d'interface graphique • Pas d'hallucinations

Capable hors ligne : exécutez entièrement en local à l'aide d'un point de terminaison compatible OpenAI (par exemple, Ollama, LM Studio) ; aucune connexion Internet requise.

Pourquoi kernagent ?

Télécharger l’outil
  • Sans tête par conception — s'exécute dans CI/Docker ; pas d'interface IDA/Ghidra, pas de MCP requis
  • Des preuves plutôt que des impressions — chaque réponse cite des fonctions, des références croisées, des importations, des chaînes et des fragments de décompilation
  • Déterministe et portable — même binaire → même instantané → même rapport ; facile à différencier et archiver
  • Indépendant du modèle — fonctionne avec n'importe quel point de terminaison LLM /v1/chat/completions (OpenAI, Gemini, Ollama, LM Studio, votre passerelle)

🚀 Démarrage rapide

Prérequis

  • Docker (Engine ou Desktop) et Git
  • Système d'exploitation 64 bits (x86_64 ou ARM64)
  • 4 Go de RAM (8+ Go recommandé pour les gros échantillons)
  • Accès à un point de terminaison LLM (Internet ou une passerelle /v1/chat/completions locale comme Ollama ou LM Studio)

Installation

Choisissez le flux qui correspond à vos outils. Toutes les options montent ~/.config/kernagent/config.env pour que vous configuriez les identifiants une seule fois.

Option 1 — Wrapper install.sh (Linux / macOS / WSL2)

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

Si la commande en une ligne est bloquée :

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

Ou clonez d'abord :

root@kitploit:~
git clone https://github.com/Karib0u/kernagent.git
cd kernagent
bash install.sh

Le script d'installation fait ce qui suit (entièrement vérifiable dans scripts/) :

  1. Vérifie que Docker est installé et en cours d'exécution
  2. Télécharge l'image préconstruite ghcr.io/karib0u/kernagent:latest depuis le registre de conteneurs GitHub (aucune étape de construction)
  3. Installe ces scripts shell dans /usr/local/bin/ :
    • kernagent — wrapper CLI principal (monte automatiquement les binaires et la configuration)
    • kernagent-config — éditeur de configuration interactif
    • kernagent-update — mise à jour vers la dernière version/une version étiquetée
    • kernagent-uninstall — supprime tous les fichiers installés
  4. Sauvegarde les informations de version dans ~/.config/kernagent/.version

Tous les scripts sont en code shell brut que vous pouvez consulter dans scripts/ avant de les exécuter. Aucun sudo requis sauf si /usr/local/bin n'est pas accessible en écriture.

Avancé — épingler l'installation à un tag/commit

Pour installer une version spécifique du wrapper et de l'image, pointez le bootstrapper vers un script étiqueté et passez le tag :

root@kitploit:~
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

Vous pouvez également épingler à un commit exact en remplaçant vX.Y.Z par un SHA de commit dans l'URL brute.

Option 2 — Docker Compose (Linux / macOS / Windows + Docker Desktop)

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

# Pull pre-built image (recommended)
docker compose pull

# Or build locally for development
docker compose build

docker compose run --rm kernagent --help

Analysez les binaires en montant leur répertoire sous /data :

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

Sous Windows (PowerShell + Docker Desktop), utilisez des chemins absolus de style Windows comme C:\malware:/data.

Option 3 — Docker direct (tout OS avec Docker)

Télécharger l'image préconstruite (recommandé) :

root@kitploit:~
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

Ou construire localement :

root@kitploit:~
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

Vérifier l'installation

Option 1 (wrapper) :

root@kitploit:~
kernagent --help
kernagent --version

Exécutez directement :

root@kitploit:~
kernagent summary /path/to/binary.exe
kernagent ask /path/to/binary.exe "What does this binary do?"
kernagent oneshot /path/to/binary.exe

Options 2 ou 3 (Docker Compose / Docker brut) :

Vérifiez en exécutant l'aide :

root@kitploit:~
# Docker Compose
docker compose run --rm kernagent --help

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

Désinstallation

Option 1 (wrapper) :

root@kitploit:~
kernagent-uninstall

Options 2 ou 3 (Docker Compose / Docker brut) :

Il suffit de supprimer le clone et de retirer les images :

root@kitploit:~
docker image rm ghcr.io/karib0u/kernagent:latest
# or
docker image rm kernagent:local

Mise à jour

Option 1 (wrapper) :

root@kitploit:~
kernagent-update          # switch to latest
kernagent-update --check  # check only
kernagent-update --tag vX.Y.Z  # pin to specific version

Options 2 ou 3 (Docker Compose / Docker brut) :

Relancez docker compose pull ou docker pull ghcr.io/karib0u/kernagent:latest.

Captures d'écran

Résumé — aperçu exécutif avec artefacts cités Summary

Demander — Q/R ciblée avec références croisées/tranches de décompilation Ask

Commandes

Première exécution — si aucun instantané <name>_archive/ n'existe, kernagent le construit automatiquement avant de répondre

summary

Aperçu exécutif : objectif, capacités, fonctions/importations/chaines clés, avec adresses à vérifier

root@kitploit:~
kernagent summary /path/to/binary
# raw JSON (for automation)
kernagent summary /path/to/binary --json

ask

Q/R interactive sur l'instantané à l'aide d'outils sécurisés (recherche de fonctions/chaines/importations, suivi du graphe d'appels, lecture de la décompilation, résolution des références croisées)

root@kitploit:~
kernagent ask /path/to/binary "Show suspected C2 logic and evidence."

oneshot

Rapport de tri déterministe pour l'analyse CI/en masse. Classification : MALICIOUS | GRAYWARE | BENIGN | UNKNOWN

root@kitploit:~
kernagent oneshot /path/to/binary
# raw JSON (for automation)
kernagent oneshot /path/to/binary --json

Surcharges globales (toute commande) :

root@kitploit:~
# verbosity and per-run model/API overrides
kernagent -v --model gpt-4o \
  --base-url https://api.openai.com/v1 \
  --api-key sk-... \
  summary /path/to/binary

Comment ça marche (aperçu en 20 secondes)

  1. Extraire une fois — construire un instantané statique avec Ghidra/PyGhidra ; les règles CAPA ajoutent des indices de capacité
  2. Outils en lecture seule — un agent limité (ou vos scripts) parcourt l'instantané en toute sécurité
  3. Réponses citées — les résultats référencent toujours des artefacts concrets (EAs, noms, chaînes, API)

Structure de l'instantané (sous-ensemble)

root@kitploit:~
<name>_archive/
├─ meta.json
├─ functions.jsonl
├─ strings.jsonl
├─ imports_exports.json
├─ callgraph.jsonl
├─ capa_summary.json
└─ decomp/*.c

Configuration du modèle

Créez une fois (en dehors du dépôt). Chemin rapide :

root@kitploit:~
kernagent-config

Ou modifiez le fichier manuellement :

root@kitploit:~
mkdir -p ~/.config/kernagent
cp config.env.example ~/.config/kernagent/config.env
$EDITOR ~/.config/kernagent/config.env

Remplacez via des variables d'environnement :

root@kitploit:~
export OPENAI_API_KEY=...
export OPENAI_BASE_URL=https://api.openai.com/v1   # or your gateway
export OPENAI_MODEL=gpt-4o                        # or your local model

Tout point de terminaison compatible /v1/chat/completions fonctionne.

Comparaisons (TL;DR)

  • Plugins MCP/IDE — nécessitent un désassembleur et un projet en cours d'exécution, souvent liés à une interface graphique
  • kernagent — s'exécute sans tête et produit un instantané portable que vous pouvez analyser n'importe où, y compris en environnement isolé

Garanties de conception

  • Lecture seule
  • Statique uniquement
  • Déterministe
  • Vérifiable

Contribuer

Les PRs sont les bienvenues

Licence

Apache 2.0 — voir LICENSE