Start/Blog/Schwachstellenforschung
SchwachstellenforschungVeröffentlicht · Aktualisiert ⚡ 15 Min. Lesezeit

Schluss mit KI-Schrott in Produktion: Die knallharte 25-Punkte-Checkliste, die du wirklich brauchst

Ein umfassender DevSecOps-Leitfaden ohne Schnickschnack, mit dem du LLM-generierten Code absicherst, bevor er dir die Produktionsumgebung um die Ohren haut.

VG
Vladyslav Gusarov
DevSecOps Lead bei Bryxe
Die ultimative Security-Checkliste für KI-Code: 25 Punkte, die du vor dem Ausliefern von KI-generiertem Code prüfen musst [2026] [Audit]

Hör zu, KI schreibt inzwischen die Hälfte deiner Codebasis. Das ist okay. Es geht schnell, die Boilerplate ist aus dem Weg. Aber hören wir auf, so zu tun, als wüsste sie, wie eine sichere Architektur aussieht. Wenn du ein LLM einen Haufen Node oder Python auskotzen lässt und das einfach nach dem YOLO-Prinzip in Produktion schiebst, baust du eine Bombe. Du willst einen Einbruch? Dann vertrau der Autovervollständigung weiter blind.

Das ist keine Theorie. Ich habe dieses Jahr genug KI-generierten Schrott auditiert, um genau zu wissen, was er falsch macht. Er hartcodiert Secrets. Er erfindet APIs, die es nicht gibt. Er ignoriert SSRF-Schutz komplett. Fazit: Wenn du nicht prüfst, was der Bot geschrieben hat, bist du derjenige, der dafür geradesteht, wenn die Ransomware zuschlägt.

Hier ist die ultimative Security-Checkliste für KI-Code. 25 Punkte, die du unbedingt prüfen musst, bevor dieser Pull Request gemergt wird.

Authentifizierung & Autorisierung (Die Haustür)

Die KI liebt es, eigene Auth zu bauen. Lass sie niemals.

1. Hartcodierte Zugangsdaten

Die KI legt API-Keys einfach im Klartext ab. Weg damit.

pythonQuellcode
# Bad
api_key = "sk-live-12345"
# Good
import os
api_key = os.environ.get("API_KEY")

2. Kaputte JWT-Validierung

Sie überspringt die Signaturprüfung, weil sie faul ist.

javascriptQuellcode
// Bad
const payload = jwt.decode(token);
// Good
const payload = jwt.verify(token, process.env.JWT_SECRET, { algorithms: ['HS256'] });

3. Fehlende rollenbasierte Zugriffskontrolle

KI-Endpunkte lassen standardmäßig jeden mit einem Token rein.

pythonQuellcode
# Bad
@app.route('/admin/delete')
def delete_user():
# Good
@app.route('/admin/delete')
@require_role('ADMIN')
def delete_user():

4. Schwaches Passwort-Hashing

MD5 ist tot. Sag der KI, dass sie damit aufhören soll.

pythonQuellcode
# Bad
hash = hashlib.md5(password).hexdigest()
# Good
hash = bcrypt.hashpw(password.encode(), bcrypt.gensalt())

5. Insecure Direct Object Reference (IDOR)

Nur weil jemand die ID kennt, gehört ihm der Datensatz noch lange nicht.

javascriptQuellcode
// Bad
db.users.find({ id: req.params.id })
// Good
db.users.find({ id: req.params.id, owner_id: req.user.id })

Eingabevalidierung (Vertraue nichts)

Ehrlich, ich habe das schon hundertmal gesehen. LLMs gehen davon aus, dass Nutzer nett sind. Nutzer sind nicht nett.

6. SQL Injection

Ja, KI schreibt 2026 immer noch rohe SQL-Strings.

javascriptQuellcode
// Bad
db.execute(`SELECT * FROM users WHERE name = '${req.body.name}'`);
// Good
db.execute('SELECT * FROM users WHERE name = ?', [req.body.name]);

7. Cross-Site Scripting (XSS)

React rettet dich meistens, aber dangerouslySetInnerHTML ist die Lieblings-Fußangel der KI.

javascriptQuellcode
// Bad
<div dangerouslySetInnerHTML={{ __html: userInput }} />
// Good
import DOMPurify from 'dompurify';
<div dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(userInput) }} />

8. Command Injection

Lass Benutzereingaben niemals an eine Shell.

pythonQuellcode
# Bad
os.system(f"ping {user_ip}")
# Good
subprocess.run(["ping", "-c", "4", user_ip], check=True)

9. Server-Side Request Forgery (SSRF)

Die KI ruft einfach jede URL ab, die der Nutzer ihr gibt.

pythonQuellcode
# Bad
requests.get(user_provided_url)
# Good
if is_safe_url(user_provided_url):
    requests.get(user_provided_url, timeout=5)

10. Path Traversal

Hör auf, sie /etc/passwd lesen zu lassen.

javascriptQuellcode
// Bad
fs.readFile(path.join(__dirname, req.query.file));
// Good
const safePath = path.resolve(__dirname, 'public', path.basename(req.query.file));

Datenschutz (Schluss mit Lecks)

11. Personenbezogene Daten im Klartext

Verschlüssele Sozialversicherungsnummern, E-Mails, was auch immer.

pythonQuellcode
# Bad
db.save({"ssn": user_ssn})
# Good
db.save({"ssn": encrypt_kms(user_ssn)})

12. Ausführliche Fehlermeldungen

Spuck keine Stack Traces ins Frontend.

javascriptQuellcode
// Bad
res.status(500).send(err.stack);
// Good
res.status(500).send("Internal Server Error");

13. Secrets im Log

Die KI liebt console.log(req.body).

javascriptQuellcode
// Bad
console.log("User config:", config);
// Good
const safeConfig = omit(config, ['password', 'token']);
console.log("User config:", safeConfig);

14. Unsichere Zufallszahlen

Math.random() ist nicht für Kryptografie gedacht.

javascriptQuellcode
// Bad
const resetToken = Math.random().toString(36);
// Good
const resetToken = crypto.randomBytes(32).toString('hex');

15. Fehlende Security-Header

Füge HSTS, CSP und den ganzen Rest hinzu.

javascriptQuellcode
// Bad
app.use(cors());
// Good
const helmet = require('helmet');
app.use(helmet());

API- & Netzwerksicherheit (Löcher stopfen)

16. Kein Rate Limiting

APIs ohne Rate Limits sind nichts als DDoS-Ziele.

javascriptQuellcode
// Bad
app.post('/login', loginHandler);
// Good
const limiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 100 });
app.post('/login', limiter, loginHandler);

17. Unsichere Deserialisierung

Pickle und YAML sind geladene Waffen.

pythonQuellcode
# Bad
data = yaml.load(user_input)
# Good
data = yaml.safe_load(user_input)

18. Zu freizügiges CORS

* ist kein akzeptabler Origin.

javascriptQuellcode
// Bad
app.use(cors({ origin: '*' }));
// Good
app.use(cors({ origin: 'https://myapp.com' }));

19. Klartextprotokolle

Erzwinge TLS überall.

pythonQuellcode
# Bad
url = "http://api.internal.svc"
# Good
url = "https://api.internal.svc"

20. GraphQL-Introspection

Schalte sie in Produktion ab, sonst wirst du gescrapt.

javascriptQuellcode
// Bad
const server = new ApolloServer({ typeDefs, resolvers });
// Good
const server = new ApolloServer({ typeDefs, resolvers, introspection: false });

Infrastruktur & Deployment (Dicht machen)

21. Container mit zu vielen Rechten

Root in Docker ist ein schlechter Witz.

dockerfileQuellcode
# Bad
USER root
# Good
USER appuser

22. Veraltete Base Images

Hör auf, node:latest zu ziehen.

dockerfileQuellcode
# Bad
FROM python:3
# Good
FROM python:3.11-slim@sha256:abcd...

23. Hartcodierte Cloud-Berechtigungen

Die KI schreibt Action: "*" in IAM-Policies.

jsonQuellcode
// Bad
{"Effect": "Allow", "Action": "s3:*", "Resource": "*"}
// Good
{"Effect": "Allow", "Action": ["s3:GetObject"], "Resource": "arn:aws:s3:::my-bucket/*"}

24. Offene Debug-Ports

Binde das Debugging nicht an 0.0.0.0.

jsonQuellcode
// Bad
"start": "node --inspect=0.0.0.0 index.js"
// Good
"start": "node index.js"

25. Fehlendes Pinning von Abhängigkeiten

Ob Yarn oder NPM: Pinne die exakten Versionen.

jsonQuellcode
// Bad
"express": "^4.0.0"
// Good
"express": "4.18.2"

Hör auf, das von Hand zu machen

Hör zu, du kannst diese Security-Checkliste für KI-Code bei jedem PR manuell durchgehen, aber das ist verschwendete Engineering-Zeit. Bryxe automatisiert alle 25 Checks direkt in deiner CI-Pipeline. Es scannt die LLM-Ausgabe, markiert den wackligen Code und setzt echte DevSecOps-Standards durch, bevor irgendetwas in Produktion geht. Hör auf, dem Bot zu vertrauen, und fang an, die Bits zu verifizieren.

AUTOMATISIERTE ABWEHR

Warte nicht auf einen Exploit, um deine Codebase zu prüfen

Prüfe unterstützte Code-Risiken, offengelegte Secrets und Findings zu Abhängigkeiten mit Bryxe Shield. Verifiziere die Fixes in deiner Anwendung vor dem Release.

Du brauchst einen praktischen nächsten Schritt? Sieh dir die Security-Guides aus der Praxis an oder lies unsere Redaktions- und Quellenrichtlinien.

Empfohlene Security-Research