diff --git a/artifacts/skillguard/src/App.tsx b/artifacts/skillguard/src/App.tsx index ca0b757..c486795 100644 --- a/artifacts/skillguard/src/App.tsx +++ b/artifacts/skillguard/src/App.tsx @@ -3,8 +3,10 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; import { Toaster } from "@/components/ui/toaster"; import { TooltipProvider } from "@/components/ui/tooltip"; import { AppLayout } from "@/components/layout"; +import { PublicLayout } from "@/components/public-layout"; import NotFound from "@/pages/not-found"; +import Landing from "@/pages/landing"; import Dashboard from "@/pages/dashboard"; import ScanForm from "@/pages/scan-form"; import ScanReport from "@/pages/scan-report"; @@ -18,19 +20,28 @@ const queryClient = new QueryClient(); function Router() { return ( - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + ); } diff --git a/artifacts/skillguard/src/components/layout.tsx b/artifacts/skillguard/src/components/layout.tsx index c4a3c1b..e03b39e 100644 --- a/artifacts/skillguard/src/components/layout.tsx +++ b/artifacts/skillguard/src/components/layout.tsx @@ -9,9 +9,11 @@ export function AppLayout({ children }: { children: React.ReactNode }) {
- - - SkillGuard + + + + SkillGuard + @@ -19,8 +21,8 @@ export function AppLayout({ children }: { children: React.ReactNode }) { - - + + Dashboard diff --git a/artifacts/skillguard/src/components/public-layout.tsx b/artifacts/skillguard/src/components/public-layout.tsx new file mode 100644 index 0000000..bdb620c --- /dev/null +++ b/artifacts/skillguard/src/components/public-layout.tsx @@ -0,0 +1,49 @@ +import { Link } from "wouter"; +import { Shield, Search, LayoutDashboard } from "lucide-react"; +import { Button } from "@/components/ui/button"; + +export function PublicLayout({ children }: { children: React.ReactNode }) { + return ( +
+
+
+ + + SkillGuard + + +
+
+ +
{children}
+ +
+
+ © 2026 avameo GmbH + +
+
+
+ ); +} diff --git a/artifacts/skillguard/src/pages/landing.tsx b/artifacts/skillguard/src/pages/landing.tsx new file mode 100644 index 0000000..9ed8024 --- /dev/null +++ b/artifacts/skillguard/src/pages/landing.tsx @@ -0,0 +1,265 @@ +import { useListRules, type Rule } from "@workspace/api-client-react"; +import { Link } from "wouter"; +import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card"; +import { Skeleton } from "@/components/ui/skeleton"; +import { Button } from "@/components/ui/button"; +import { AxisBadge, SeverityBadge } from "@/components/ui-helpers"; +import { + Shield, + ShieldCheck, + Search, + LayoutDashboard, + EyeOff, + Syringe, + Upload, + KeyRound, + FileWarning, + Lock, + ShieldAlert, +} from "lucide-react"; + +const RISK_EXPLANATIONS: Record = { + "SEC-REVERSE-SHELL": + "Eine Reverse-Shell öffnet Angreifern eine Fernsteuerung Ihres Rechners – sie könnten dann beliebige Befehle ausführen, als säßen sie selbst davor.", + "SEC-REMOTE-EXEC": + "Wird Code direkt aus dem Netz ausgeführt, weiß niemand vorher, was wirklich läuft – schädlicher Fremdcode kann jederzeit unbemerkt nachgeladen werden.", + "SEC-DESTRUCTIVE": + "Solche Befehle können in Sekunden ganze Verzeichnisse, Festplatten oder Backups unwiderruflich löschen oder das System lahmlegen.", + "SEC-PRIV-ESC": + "Mit erhöhten Rechten kann ein Skill Schutzmechanismen aushebeln und tief ins System eingreifen, weit über das hinaus, was es eigentlich bräuchte.", + "SEC-PERSISTENCE": + "Dauerhafte Hintertüren sorgen dafür, dass Schadcode auch nach einem Neustart aktiv bleibt und sich kaum noch entfernen lässt.", + "SEC-OBFUSCATION": + "Verschleierter Code versteckt seine wahre Funktion absichtlich – das ist ein typisches Merkmal, um Schadhandlungen vor der Prüfung zu verbergen.", + "SEC-SUPPLY-CHAIN": + "Pakete aus unkontrollierten Quellen können manipuliert sein und Schadcode einschleusen, noch bevor das Skill überhaupt etwas tut.", + "SEC-NETWORK": + "Ausgehende Verbindungen sind nicht automatisch bösartig, können aber Daten nach außen tragen oder Befehle empfangen – sie gehören kontrolliert.", + "PRIV-SECRET-ACCESS": + "Greift ein Skill auf Passwörter, Schlüssel oder Zugangsdaten zu, können Angreifer damit Ihre Konten und Cloud-Dienste übernehmen.", + "PRIV-EXFILTRATION": + "Werden lokale Daten an fremde Server gesendet, verlassen vertrauliche Informationen unbemerkt Ihren Rechner – besonders gefährlich zusammen mit Zugriff auf Geheimnisse.", + "PRIV-PROMPT-INJECTION": + "Manipulative Anweisungen bringen den KI-Agenten dazu, Sicherheitsregeln zu ignorieren oder Sie zu täuschen – Sie verlieren die Kontrolle über sein Verhalten.", + "PRIV-HIDDEN-INSTRUCTIONS": + "Unsichtbare Zeichen oder versteckte Kommentare enthalten Anweisungen, die ein Mensch nie zu sehen bekommt, der KI-Agent aber sehr wohl befolgt.", + "PRIV-PII": + "Werden personenbezogene Daten erfasst, drohen DSGVO-Verstöße und der Missbrauch sensibler Informationen wie Ausweis-, Bank- oder Gesundheitsdaten.", + "PRIV-AGENT-TAMPERING": + "Verändert ein Skill den Agenten, dessen Gedächtnis oder andere Skills, kann es Schutzregeln dauerhaft aushebeln und sich selbst tarnen.", + "PRIV-OVERREACH": + "Wer mehr Rechte verlangt als nötig, schafft unnötige Angriffsfläche – im Schadensfall steht dem Skill dann viel zu viel offen.", + "AI-PROMPT-INJECTION": + "Subtile Manipulationsversuche umgehen oft die starren Mustererkennungen – die KI-Analyse erkennt auch verdeckte Angriffe auf das Agentenverhalten.", + "AI-MALICIOUS-INTENT": + "Schädliche Absicht ist nicht immer ein bekanntes Muster – die KI-Analyse bewertet den Sinn des Codes und findet getarnte Funktionen.", + "AI-DATA-PRIVACY": + "Datenschutzrisiken stecken oft im Kontext, nicht in einzelnen Schlüsselwörtern – die KI-Analyse erkennt möglichen Datenabfluss auch ohne klare Signatur.", +}; + +const PROBLEM_POINTS = [ + { + icon: Shield, + title: "Nicht vertrauenswürdiger Code", + text: "Ein fremdes Skill kann beliebige Befehle auf Ihrem Rechner ausführen. Wer es installiert, vertraut blind dem, was darin steckt – oft ohne es je gelesen zu haben.", + }, + { + icon: EyeOff, + title: "Versteckte & unsichtbare Anweisungen", + text: "Anweisungen können in unsichtbaren Zeichen oder versteckten Kommentaren stecken. Für Menschen unsichtbar, vom KI-Agenten aber befolgt.", + }, + { + icon: Syringe, + title: "Prompt-Injektion", + text: "Manipulative Texte bringen den KI-Agenten dazu, frühere Anweisungen zu ignorieren, Sicherheitsregeln zu umgehen oder Sie zu täuschen.", + }, + { + icon: Upload, + title: "Datenabfluss", + text: "Vertrauliche Daten können unbemerkt an fremde Server gesendet werden – von Dateien über Zwischenergebnisse bis zu ganzen Verzeichnissen.", + }, + { + icon: KeyRound, + title: "Zugriff auf Geheimnisse", + text: "Passwörter, API-Schlüssel und Zugangsdaten liegen an bekannten Orten. Ein bösartiges Skill weiß genau, wo es danach suchen muss.", + }, + { + icon: FileWarning, + title: "Unkontrollierte Installation", + text: "Wird ein Skill ungeprüft eingebunden, fehlt jede Kontrolle darüber, was es darf und tut – ein erhebliches Sicherheits- und Datenschutzrisiko.", + }, +]; + +function riskText(rule: Rule): string { + return RISK_EXPLANATIONS[rule.ruleId] ?? rule.description; +} + +function RuleCard({ rule }: { rule: Rule }) { + return ( + + +
+ + +
+ {rule.title} + + +
+

Was geprüft wird

+

{rule.description}

+
+
+

Warum das ein Risiko ist

+

{riskText(rule)}

+
+ + + ); +} + +function RuleGroup({ + rules, + axis, + icon: Icon, + title, + intro, +}: { + rules: Rule[]; + axis: "security" | "privacy"; + icon: typeof Shield; + title: string; + intro: string; +}) { + const items = rules.filter((r) => r.axis === axis); + if (items.length === 0) return null; + return ( +
+
+
+ +

{title}

+ +
+

{intro}

+
+
+ {items.map((rule) => ( + + ))} +
+
+ ); +} + +export default function Landing() { + const { data, isLoading, error } = useListRules(); + const activeRules = (data ?? []).filter((r) => r.enabled); + + return ( +
+
+
+ + Sicherheits- & Datenschutzprüfung für KI-Agent-Skills +
+

+ Prüfen Sie fremde Skills, bevor Sie ihnen vertrauen. +

+

+ SkillGuard untersucht öffentliche und fremde KI-Agent-Skills auf versteckte Anweisungen, Prompt-Injektion, + Datenabfluss und gefährlichen Code – und erklärt verständlich, wo das Risiko liegt. So entscheiden Sie auf + einer fundierten Grundlage, statt blind zu vertrauen. +

+
+ + +
+
+ +
+
+
+ +

Worin liegt das Risiko?

+
+

+ Ein Skill ist mehr als nur eine Anleitung: Es kann Code ausführen, Daten lesen und das Verhalten Ihres + KI-Agenten steuern. Ein unkontrolliert installiertes Skill aus fremder Quelle ist deshalb ein echtes + Sicherheits- und Datenschutzrisiko – hier die wichtigsten Gefahren in Alltagssprache. +

+
+
+ {PROBLEM_POINTS.map((p) => ( + + + + {p.title} + + +

{p.text}

+ + + ))} +
+
+ +
+
+

Das Prüfregelwerk

+

+ Jeder geprüfte Skill wird gegen die folgenden Prüfpunkte gehalten – aufgeteilt nach Datenschutz und + IT-Sicherheit. Die Liste wird live aus dem System geladen und zeigt nur die aktuell aktiven Prüfpunkte. +

+
+ + {isLoading ? ( +
+ {[1, 2, 3, 4, 5, 6].map((i) => ( + + ))} +
+ ) : error ? ( + + + Das Prüfregelwerk konnte gerade nicht geladen werden. Bitte versuchen Sie es später erneut. + + + ) : activeRules.length === 0 ? ( + + + Aktuell sind keine Prüfpunkte aktiviert. + + + ) : ( +
+ + +
+ )} +
+
+ ); +}