Kernel-Level-Sicherheit und Angriffsreaktion für Linux-Server.
Kernel-Level-Datenverkehrsintelligenz und Bedrohungsabwehr für Linux-Server.
KernelEye ist eine selbst gehostete Sicherheitsüberwachungsplattform für Linux-Server. Sie verwendet eBPF, TC und XDP in einem Go-Agenten, um Netzwerkmetadaten zu erfassen, verdächtige Aktivitäten zu bewerten und Gegenmaßnahmen über Kernel-Level-XDP-Blockierung und ipset/iptables-Regeln anzuwenden. Ein Go-Backend speichert und analysiert Ereignisse, während ein React-Dashboard Serververwaltung, Live-Verkehr, Bedrohungsansichten, blockierte IPs, Whitelisting, Berichte und Analysen bereitstellt.
shared/scoring.Monitored Linux host
eBPF traffic probe + TC bandwidth hooks
XDP firewall and ipset/iptables remediation
Go agent (HMAC command verification, audit log)
|
| gRPC (TLS/mTLS) + HMAC-signed block commands
v
Go backend API
Fiber HTTP API
gRPC ingest/block services (TLS/mTLS, command signing)
analysis worker, block manager, retention, reports
integrity report handler
|
v
PostgreSQL
^
|
React dashboard
REST API + WebSocket live updates
Der Agent befindet sich in agent/ und ist der Linux-Host-Prozess.
agent/main.go startet Registrierung, Laden von eBPF, Bandbreitenverfolgung, Gegenmaßnahmen, Bewertung, Aggregation und Streaming von Block-Befehlen.agent/ebpf/traffic_probe.c erfasst Verkehrsmetadaten.agent/ebpf/xdp_firewall.c implementiert XDP-Paketfilterung.agent/tc.go konfiguriert die TC-Bandbreitenverfolgung.agent/aggregator.go bündelt Ereignisse und übermittelt sie an das Backend.agent/history_store.go und agent/flush.go kümmern sich um lokale Persistenz und Wiederholungsverhalten.agent/remediation/ enthält Analyzer, Auto-Blocking sowie XDP-, ipset- und Hybrid-Remediatoren.Der Agent benötigt Linux und erhöhte Rechte für eBPF/XDP-Operationen.
Das Backend befindet sich in backend/.
backend/cmd/api/main.go startet die Fiber-HTTP-API und gRPC-Dienste.backend/internal/api/ enthält Authentifizierung, Dashboard-Handler, gRPC-Handler, Block-APIs, Whitelist-APIs, WebSocket-Behandlung und Ratenbegrenzung.backend/internal/analysis/ enthält Bewertungs-Worker, Blockverwaltung, Datenaufbewahrung und die Logik für monatliche Berichte.backend/internal/database/ enthält den von sqlc generierten Datenbankzugriffscode.backend/internal/geoip/ übernimmt die GeoIP-Anreicherung.backend/internal/email/ sendet bei Konfiguration E-Mails über Mailtrap.backend/migrations/ enthält PostgreSQL-Migrationen.HTTP verwendet standardmäßig Port 8080; gRPC standardmäßig Port 9091.
Das Dashboard befindet sich in dashboard/ und ist eine Vite-React-Anwendung.
dashboard/src/pages/ enthält Seiten für Übersicht, Server, Serverdetails, Bedrohungen, Warnungen, Berichte, Visualizer, blockierte IPs, Whitelist, Login, Profil und OAuth-Callback.dashboard/src/components/ enthält Live-Verkehr, Block-Feed, Diagramme, Serverlisten, Konfiguratoren und gemeinsame Layout-Komponenten.dashboard/src/api/client.ts definiert den REST-API-Client.dashboard/src/context/WebSocketContext.tsx verwaltet Live-Ereignis-Updates.Der Dev-Server ist für http://localhost:3000 konfiguriert.
Die öffentliche Marketing-Website befindet sich in kerneleye-landing-page/. Das Produktions-Frontend-Image baut sowohl die Landingpage als auch das Dashboard und stellt sie dann über nginx bereit.
shared/scoring/ enthält das gemeinsame Bedrohungsbewertungsmodul, das sowohl vom Agenten als auch vom Backend verwendet wird.shared/cmdsigning/ enthält das Modul für HMAC-SHA256-Befehlssignierung und Nonce-Replay-Schutz.proto/kerneleye/v1/ enthält Protobuf-Definitionen für Ingest- und Block-Dienste.proto/gen/go/ enthält generierten Go-Protobuf-Code.KernelEye prüft keine Paketnutzlasten oder Anwendungsinhalte.
Erfasste Metadaten umfassen:
Nicht erfasst:
Die Bedrohungsbewertung ist in shared/scoring/scorer.go implementiert. Der aktuelle Scorer ist differenzierter als eine einzelne lineare Formel: Er berücksichtigt SYN-Rate, Zugriff auf eindeutige Ports, fehlgeschlagene Handshakes, Burst-Verhalten, Dienstmissbrauch, Richtung, Konfidenz und den Abfall des Scores im Laufe der Zeit.
Standard-Klassifizierungsschwellen:
< 20 normal
20-39 suspicious
>= 40 malicious
>= 40 eligible for auto-blocking when remediation is enabled
Der Backend-Analyse-Worker verwendet außerdem akkumulierte Verkehrsfenster und kann die Blockverwaltung für Hochrisiko-Quellen auslösen.
KernelEye unterstützt aktive Gegenmaßnahmen, wenn diese auf dem Agenten aktiviert sind.
| Ebene | Implementierung | Zweck |
|---|---|---|
| XDP | agent/remediation/xdp_remediator.go | Schnelle Verwerfungen auf Kernel-Ebene vor dem Netzwerk-Stack |
| IPSet | agent/remediation/ipset_remediator.go | ipset/iptables-Blockverwaltung |
| Hybrid | agent/remediation/hybrid_remediator.go | Koordiniert XDP- und ipset-Verhalten |
| Auto-Blocker | agent/remediation/auto_blocker.go | Blockiert Quellen oberhalb konfigurierter Score-Schwellen |
| Backend-Blockmanager | backend/internal/analysis/block_manager.go | Koordiniert backend-generierten Blockstatus und -befehle |
Das Dashboard bietet außerdem die Verwaltung blockierter IPs und der Whitelist.
cp .env.example .env
Legen Sie mindestens fest:
DATABASE_URL=postgres://kerneleye:<password>@localhost:5432/kerneleye?sslmode=disable
JWT_SECRET=<at-least-32-characters>
API_KEY_SECRET=<strong-secret>
CORS_ORIGINS=http://localhost:3000
Optionale Integrationen umfassen Redis-Ratenbegrenzung, Mailtrap-E-Mail, GitHub/Google-OAuth und MaxMind-GeoIP.
cd backend
go mod download
go run cmd/api/main.go
Das Backend startet:
http://localhost:8080localhost:9091cd dashboard
npm install
npm run dev
Öffnen Sie http://localhost:3000.
Die Anmeldung erfolgt ausschließlich über OAuth. Setzen Sie AUTH_OWNER_EMAIL und konfigurieren Sie mindestens einen OAuth-Anbieter (GitHub oder Google) für den Dashboard-Zugriff. Nur die konfigurierte Besitzer-E-Mail-Adresse darf sich anmelden.
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=<server-api-key> \
KERNELEYE_SERVER=localhost:8080 \
KERNELEYE_GRPC_URL=localhost:9091 \
./kerneleye-agent
Nützliche Agent-Flags:
-enable-remediation enable active blocking and auto-blocking
-xdp enable XDP fast-path blocking
-interface <name> select XDP network interface
--read-only monitor and report only, never block
--insecure disable TLS (dev only)
--tls-ca-file <path> backend CA certificate for TLS verification
--tls-cert-file <path> agent client certificate for mTLS
--tls-key-file <path> agent client private key for mTLS
-list-blocked print current ipset state and exit
-flush-blocklists flush ipset and XDP blocklists and exit
-clear-data remove local agent SQLite stores and exit
-version print build version
Wenn --enable-remediation gesetzt ist, muss CMD_SIGNING_KEY sowohl auf dem Agenten als auch auf dem Backend konfiguriert sein. Generieren Sie ihn mit openssl rand -base64 32.
kerneleye/
├── agent/ Go eBPF/XDP monitoring agent
│ ├── ebpf/ eBPF C programs and compiled objects
│ ├── remediation/ analyzer, XDP, ipset, hybrid remediation
│ ├── assets/ embedded XDP object assets
│ └── scripts/ ipset helper scripts and service files
├── backend/ Go Fiber API and gRPC backend
│ ├── cmd/api/ backend entrypoint
│ ├── internal/api/ HTTP, auth, WebSocket, gRPC, block APIs
│ ├── internal/analysis/ workers, blocking, retention, reports
│ ├── internal/database/ sqlc generated queries and helpers
│ ├── internal/email/ Mailtrap email service
│ ├── internal/geoip/ MaxMind GeoIP service
│ └── migrations/ PostgreSQL migrations
├── dashboard/ React dashboard app
├── kerneleye-landing-page/ React landing page app
├── proto/ protobuf definitions and generated Go code
├── shared/
│ ├── scoring/ shared threat scoring Go module
│ └── cmdsigning/ HMAC command signing and nonce tracking
├── docs/ additional project documentation
├── tests/ traffic simulation shell scripts
├── docker/ frontend nginx and install script templates
├── Dockerfile.backend backend container build
├── Dockerfile.frontend landing + dashboard + agent download image
├── docker-compose.yml production-oriented compose stack
└── Makefile generation, build, and docker targets
| Ebene | Technologien |
|---|---|
| Agent | Go, cilium/ebpf, XDP, TC, gRPC, SQLite local stores, zap |
| Backend | Go, Fiber, gRPC, PostgreSQL, sqlc, Redis, Mailtrap |
| Dashboard | React, TypeScript, Vite, Ant Design, React Query, Recharts |
| Landingpage | React, TypeScript, Vite, Tailwind CSS |
| Protokolle | Protobuf, gRPC |
| Bereitstellung | Docker, Docker Compose, nginx, Traefik labels |
Der KernelEye-Agent wurde auf den folgenden Konfigurationen getestet. Diese Tabelle wird aktualisiert, sobald neue Umgebungen validiert werden.
| Betriebssystem | Kernel | CPU | RAM | Arch | Anmerkungen |
|---|---|---|---|---|---|
| Ubuntu 26.04 LTS | 7.0.0-15-generic | AMD EPYC-Genoa (2 vCPU) | 3.7 GB | x86_64 | — |
Für die eBPF-Userspace-Integration verwenden wir ebpf-go.
Häufige Make-Ziele:
make gen-proto
make gen-sql
make gen-ebpf
make build-backend
make build-agent
make build
make docker-build
Das Frontend-Docker-Image erstellt die Landingpage, das Dashboard und ein herunterladbares Linux-Agent-Binary.
KernelEye ist Open Source unter der Apache License, Version 2.0 (Apache-2.0). Siehe LICENSE.
Copyright 2026 Abdeljalil Aitetaleb.
Der Name KernelEye, die Logos und die visuelle Identität sind nicht unter der Apache-Lizenz lizenziert. Siehe TRADEMARKS.md für die Bedingungen zur Markennutzung.