Sécurité au niveau du noyau & réponse aux attaques pour les serveurs Linux.
Intelligence du trafic au niveau noyau et remédiation des menaces pour les serveurs Linux.
KernelEye est une plateforme de surveillance de sécurité auto-hébergée pour serveurs Linux. Elle utilise eBPF, TC et XDP dans un agent Go pour observer les métadonnées réseau, évaluer les activités suspectes et appliquer des remédiations via le blocage XDP au niveau noyau et les règles ipset/iptables. Un backend Go stocke et analyse les événements, tandis qu'un tableau de bord React offre la gestion des serveurs, le trafic en direct, les vues des menaces, les IP bloquées, la liste blanche, les rapports et les analyses.
shared/scoring.Hôte Linux surveillé
Sonde de trafic eBPF + hooks de bande passante TC
Pare-feu XDP et remédiation ipset/iptables
Agent Go (vérification des commandes HMAC, journal d'audit)
|
| gRPC (TLS/mTLS) + commandes de blocage signées HMAC
v
API backend Go
API HTTP Fiber
Services gRPC d'ingestion/blocage (TLS/mTLS, signature de commandes)
Worker d'analyse, gestionnaire de blocage, conservation, rapports
Gestionnaire de rapports d'intégrité
|
v
PostgreSQL
^
|
Tableau de bord React
API REST + mises à jour en direct WebSocket
L'agent se trouve dans agent/ et est le processus hôte Linux.
agent/main.go démarre l'enregistrement, le chargement eBPF, le suivi de bande passante, la remédiation, le scoring, l'agrégation et la diffusion de commandes de blocage.agent/ebpf/traffic_probe.c capture les métadonnées de trafic.agent/ebpf/xdp_firewall.c implémente le filtrage de paquets XDP.agent/tc.go configure le suivi de bande passante TC.agent/aggregator.go regroupe et vide les événements vers le backend.agent/history_store.go et agent/flush.go gèrent la persistance locale et le comportement de nouvelle tentative.agent/remediation/ contient l'analyseur, le blocage automatique, XDP, ipset et les remédiateurs hybrides.L'agent nécessite Linux et des privilèges élevés pour les opérations eBPF/XDP.
Le backend se trouve dans backend/.
backend/cmd/api/main.go démarre l'API HTTP Fiber et les services gRPC.backend/internal/api/ contient l'authentification, les gestionnaires du tableau de bord, les gestionnaires gRPC, les API de blocage, les API de liste blanche, la gestion WebSocket et la limitation de débit.backend/internal/analysis/ contient les workers de scoring, la gestion des blocages, la conservation des données et la logique des rapports mensuels.backend/internal/database/ contient le code d'accès à la base de données généré par sqlc.backend/internal/geoip/ gère l'enrichissement GeoIP.backend/internal/email/ envoie des e-mails via Mailtrap lorsqu'il est configuré.backend/migrations/ contient les migrations PostgreSQL.HTTP écoute par défaut sur le port 8080 ; gRPC sur le port 9091.
Le tableau de bord se trouve dans dashboard/ et est une application React Vite.
dashboard/src/pages/ inclut les pages d'aperçu, serveurs, détails du serveur, menaces, alertes, rapports, visualiseur, IP bloquées, liste blanche, connexion, profil et rappel OAuth.dashboard/src/components/ contient le trafic en direct, le flux de blocage, les graphiques, les listes de serveurs, les configurateurs et les composants de mise en page partagés.dashboard/src/api/client.ts définit le client API REST.dashboard/src/context/WebSocketContext.tsx gère les mises à jour d'événements en direct.Le serveur de développement est configuré pour http://localhost:3000.
Le site marketing public se trouve dans kerneleye-landing-page/. L'image frontend de production construit à la fois la page d'accueil et le tableau de bord, puis les sert via nginx.
shared/scoring/ contient le module de scoring de menace partagé utilisé par l'agent et le backend.shared/cmdsigning/ contient le module de signature de commandes HMAC-SHA256 et de protection contre la relecture par nonce.proto/kerneleye/v1/ contient les définitions protobuf pour les services d'ingestion et de blocage.proto/gen/go/ contient le code Go généré pour protobuf.KernelEye n'inspecte pas les charges utiles des paquets ni le contenu des applications.
Les métadonnées collectées incluent :
Non collecté :
Le score de menace est implémenté dans shared/scoring/scorer.go. Le scoreur actuel est plus nuancé qu'une simple formule linéaire : il prend en compte le taux de SYN, l'accès à des ports uniques, les échecs de handshake, le comportement en rafale, l'abus de service, la direction, la confiance et la décroissance du score dans le temps.
Seuils de classification par défaut :
< 20 normal
20-39 suspect
>= 40 malveillant
>= 40 éligible au blocage automatique lorsque la remédiation est activée
Le worker d'analyse du backend utilise également des fenêtres de trafic accumulées et peut déclencher la gestion des blocages pour les sources à haut risque.
KernelEye prend en charge la remédiation active lorsqu'elle est activée sur l'agent.
| Couche | Implémentation | Objectif |
|---|---|---|
| XDP | agent/remediation/xdp_remediator.go | Suppressions rapides au niveau noyau avant la pile réseau |
| IPSet | agent/remediation/ipset_remediator.go | Gestion des blocages ipset/iptables |
| Hybride | agent/remediation/hybrid_remediator.go | Coordonne le comportement XDP et ipset |
| Bloqueur automatique | agent/remediation/auto_blocker.go | Bloque les sources dépassant les seuils de score configurés |
| Gestionnaire de blocage backend | backend/internal/analysis/block_manager.go | Coordonne l'état de blocage et les commandes générées par le backend |
Le tableau de bord expose également la gestion des IP bloquées et de la liste blanche.
cp .env.example .env
Définissez au moins :
DATABASE_URL=postgres://kerneleye:<mot-de-passe>@localhost:5432/kerneleye?sslmode=disable
JWT_SECRET=<au-moins-32-caractères>
API_KEY_SECRET=<secret-fort>
CORS_ORIGINS=http://localhost:3000
Les intégrations optionnelles incluent la limitation de débit Redis, les e-mails Mailtrap, OAuth GitHub/Google et GeoIP MaxMind.
cd backend
go mod download
go run cmd/api/main.go
Le backend démarre :
http://localhost:8080localhost:9091cd dashboard
npm install
npm run dev
Ouvrez http://localhost:3000.
La connexion se fait uniquement par OAuth. Définissez AUTH_OWNER_EMAIL et configurez au moins un fournisseur OAuth (GitHub ou Google) pour l'accès au tableau de bord. Seul l'e-mail du propriétaire configuré est autorisé à se connecter.
cd agent
bpftool btf dump file /sys/kernel/btf/vmlinux format c > ebpf/vmlinux.h
go generate ./...
go build -o kerneleye-agent
sudo KERNELEYE_API_KEY=<clé-api-serveur> \
KERNELEYE_SERVER=localhost:8080 \
KERNELEYE_GRPC_URL=localhost:9091 \
./kerneleye-agent
Indicateurs utiles de l'agent :
-enable-remediation active le blocage actif et le blocage automatique
-xdp active le blocage rapide via XDP
-interface <nom> sélectionne l'interface réseau pour XDP
--read-only surveille et rapporte uniquement, ne bloque jamais
--insecure désactive TLS (développement uniquement)
--tls-ca-file <chemin> certificat CA du backend pour la vérification TLS
--tls-cert-file <chemin> certificat client de l'agent pour mTLS
--tls-key-file <chemin> clé privée client de l'agent pour mTLS
-list-blocked affiche l'état actuel d'ipset puis quitte
-flush-blocklists vide les listes de blocage ipset et XDP puis quitte
-clear-data supprime les stores SQLite locaux de l'agent puis quitte
-version affiche la version de build
Lorsque --enable-remediation est défini, CMD_SIGNING_KEY doit être configuré à la fois sur l'agent et le backend. Générez avec openssl rand -base64 32.
kerneleye/
├── agent/ Agent de surveillance Go eBPF/XDP
│ ├── ebpf/ Programmes C eBPF et objets compilés
│ ├── remediation/ Analyseur, remédiation XDP, ipset, hybride
│ ├── assets/ Actifs d'objets XDP embarqués
│ └── scripts/ Scripts d'aide ipset et fichiers de service
├── backend/ API Go Fiber et backend gRPC
│ ├── cmd/api/ Point d'entrée du backend
│ ├── internal/api/ HTTP, authentification, WebSocket, gRPC, API de blocage
│ ├── internal/analysis/ Workers, blocage, conservation, rapports
│ ├── internal/database/ Requêtes générées par sqlc et aides
│ ├── internal/email/ Service e-mail Mailtrap
│ ├── internal/geoip/ Service GeoIP MaxMind
│ └── migrations/ Migrations PostgreSQL
├── dashboard/ Application tableau de bord React
├── kerneleye-landing-page/ Application page d'accueil React
├── proto/ Définitions protobuf et code Go généré
├── shared/
│ ├── scoring/ Module Go de scoring de menace partagé
│ └── cmdsigning/ Signature de commandes HMAC et suivi des nonces
├── docs/ Documentation supplémentaire du projet
├── tests/ Scripts shell de simulation de trafic
├── docker/ Modèles de configuration nginx et scripts d'installation
├── Dockerfile.backend Construction du conteneur backend
├── Dockerfile.frontend Image d'accueil + tableau de bord + téléchargement agent
├── docker-compose.yml Stack compose orienté production
└── Makefile Cibles de génération, construction et docker
| Couche | Technologies |
|---|---|
| Agent | Go, cilium/ebpf, XDP, TC, gRPC, stores SQLite locaux, zap |
| Backend | Go, Fiber, gRPC, PostgreSQL, sqlc, Redis, Mailtrap |
| Tableau de bord | React, TypeScript, Vite, Ant Design, React Query, Recharts |
| Page d'accueil | React, TypeScript, Vite, Tailwind CSS |
| Protocoles | Protobuf, gRPC |
| Déploiement | Docker, Docker Compose, nginx, étiquettes Traefik |
L'agent KernelEye a été testé sur les configurations suivantes. Ce tableau est mis à jour à mesure que de nouveaux environnements sont validés.
| OS | Kernel | CPU | RAM | Arch | Remarques |
|---|---|---|---|---|---|
| Ubuntu 26.04 LTS | 7.0.0-15-generic | AMD EPYC-Genoa (2 vCPU) | 3.7 Go | x86_64 | — |
Nous utilisons ebpf-go pour l'intégration eBPF en espace utilisateur.
Cibles Make communes :
make gen-proto
make gen-sql
make gen-ebpf
make build-backend
make build-agent
make build
make docker-build
L'image Docker du frontend construit la page d'accueil, le tableau de bord et un binaire téléchargeable de l'agent Linux.
KernelEye est open source sous la Licence Apache, Version 2.0 (Apache-2.0). Voir LICENSE.
Copyright 2026 Abdeljalil Aitetaleb.
Le nom KernelEye, les logos et l'identité visuelle ne sont pas sous licence Apache. Voir TRADEMARKS.md pour les conditions d'utilisation de la marque.