# Schluss mit Müll in Produktion: Das Playbook 2026 für Secure Coding
Hör zu, ich bin müde. Ich reviewe den ganzen Tag PRs und sehe immer wieder dieselben grundlegenden Sicherheits-Fußangeln, die von Engineers in Produktion geschoben werden, die es eigentlich besser wissen müssten. KI vervollständigt unseren Code, und trotzdem fallen wir noch auf Schwachstellen aus dem Jahr 1999 herein. Der sogenannte sichere Softwareentwicklungsprozess (SDLC Security) ist in den meisten Organisationen ein Witz. Ein Jira-Ticket, bei dem jemand auf ‚Done‘ klickt, während sich rohe String-Verkettung in die Datenbankschicht schleicht.
Fazit: Secure Coding Practices sind nicht mehr optional. Du kannst nicht einfach eine WAF vor dein wackliges Node.js-Backend klatschen und Feierabend machen. Das hier ist das Playbook. Befolge diese Secure-Coding-Richtlinien oder du wirst gehackt. Deine Sprint-Velocity ist mir egal, wenn du dabei aktiv Nutzerdaten gefährdest.
1. Best Practices für Eingabevalidierung: Zod oder gar nichts
Ich sehe jede Menge if (req.body.userId == null)-Checks. Hör auf. Einfach aufhören. Das ist keine Eingabevalidierung. Das ist ein Stoßgebet. Du brauchst strikte Schema-Validierung an den äußersten Rändern deiner Anwendung. Wenn etwas nicht zum Schema passt, weg damit. Keine Ausnahmen.
Ich bin es leid, das in PRs zu sehen. Hier treffen die OWASP-Secure-Coding-Regeln auf die Realität. Wir verwenden Zod. Warum? Weil es strikte Typisierung erzwingt und Müll unter der Haube herausfiltert.
import { z } from 'zod';
import express from 'express';
const app = express();
app.use(express.json());
// Strict schema. No extra keys allowed.
const UserProfileSchema = z.object({
username: z.string().min(3).max(30).regex(/^[a-zA-Z0-9_]+$/),
email: z.string().email(),
age: z.number().int().min(18).max(120),
}).strict();
app.post('/api/profile', (req, res) => {
const result = UserProfileSchema.safeParse(req.body);
if (!result.success) {
// Log this internally, but give a generic 400 to the client
console.error('Validation failed:', result.error.format());
return res.status(400).json({ error: 'Invalid input data.' });
}
// result.data is now 100% typed and scrubbed
const validData = result.data;
// proceed to business logic
});Wenn du das nicht machst, bettelst du um NoSQL Injection oder Prototype Pollution. Strikte Schemas bedeuten, dass Angreifer gegen eine Wand laufen, bevor sie überhaupt deine Business-Logik erreichen. Best Practices für Eingabevalidierung sind deine erste Verteidigungslinie.
2. Parametrisierte Queries: Die SQLi-Epidemie ist immer noch da
Ich kann nicht fassen, dass ich das 2026 noch schreiben muss. Wenn du String-Interpolation für SQL-Queries verwendest, sollte man dir die Commit-Rechte entziehen. Es ist mir egal, ob es nur ein internes Admin-Tool ist. Über interne Tools passiert Lateral Movement.
Schau dir diesen Müll an:
// DO NOT DO THIS. EVER.
const query = `SELECT * FROM users WHERE email = '${userEmail}'`;
db.query(query);Ehrlich, ich habe das schon hundertmal gesehen. So machst du es richtig mit parametrisierten Queries. Der Datenbanktreiber übernimmt die Bereinigung. Du versuchst nicht, selbst zu escapen.
// GOOD: Using parameterized queries with pg (PostgreSQL)
const query = 'SELECT * FROM users WHERE email = $1';
const values = [userEmail];
try {
const res = await db.query(query, values);
return res.rows;
} catch (err) {
// Generic error to the user
throw new Error('Database operation failed');
}Und wenn du ein ORM wie Prisma oder Drizzle nutzt, verwende ihre Raw-Query-Hintertüren nur, wenn es absolut nötig ist, und selbst dann mit den Tagged Template Literals, die sie bereitstellen. SDLC Security verlangt parametrisierte Eingaben überall.
3. Output Encoding: XSS endgültig erledigen
React und moderne Frameworks encoden standardmäßig, aber Entwickler finden mit Vorliebe Wege, sich mit dangerouslySetInnerHTML selbst ins Knie zu schießen. Wenn du nutzergelieferte Eingaben ohne Output Encoding renderst, bekommst du XSS.
Wenn du doch rohes HTML rendern musst (etwa von einem Markdown-Parser), nutze DOMPurify. Und mach es nach Möglichkeit auf dem Server.
import DOMPurify from 'isomorphic-dompurify';
const rawHtml = getUserInput();
// Sanitize before it ever hits the DOM or gets saved to the DB
const cleanHtml = DOMPurify.sanitize(rawHtml, {
ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'a'],
ALLOWED_ATTR: ['href']
});4. CSP-Header: Defense in Depth
Ehrlich gesagt ist das ein Albtraum. Content Security Policy (CSP) ist eine Qual zu konfigurieren. Ich verstehe das. Dein Analytics-Skript bricht. Deine Schrift lädt nicht mehr. Aber sie ist das ultimative Sicherheitsnetz gegen XSS. Wenn du beim Output Encoding patzt, verhindert CSP, dass der Payload ausgeführt wird.
Nutze Helmet in Express. Setze eine strikte CSP.
import helmet from 'helmet';
app.use(
helmet.contentSecurityPolicy({
directives: {
defaultSrc: ["'self'"],
scriptSrc: ["'self'", "https://trusted.cdn.com"],
objectSrc: ["'none'"],
upgradeInsecureRequests: [],
},
})
);Verwende nicht 'unsafe-inline'. Wenn du Inline-Skripte hast, refaktoriere sie. Ja, das ist Arbeit. Mach es trotzdem.
5. CORS-Konfiguration: Schluss mit Wildcards
Ich sehe ständig Access-Control-Allow-Origin: * in PRs. Das ist ein riesiges Warnsignal. Wenn deine API über Cookies authentifiziert wird, ist eine offene CORS-Policy eine Katastrophe mit Ansage.
Ehrlich gesagt ist das ein Albtraum. Sei explizit.
import cors from 'cors';
const whitelist = ['https://app.bryxe.com', 'https://admin.bryxe.com'];
const corsOptions = {
origin: function (origin, callback) {
if (!origin || whitelist.indexOf(origin) !== -1) {
callback(null, true)
} else {
callback(new Error('Not allowed by CORS'))
}
},
credentials: true // Only if you actually need cookies
};
app.use(cors(corsOptions));6. Sicheres Session-Management
JWTs sind kein Allheilmittel. Wenn du ein JWT in localStorage speicherst, kompromittiert jede XSS-Schwachstelle sofort die Session.
Verwende Cookies mit HttpOnly, Secure, SameSite=Strict.
app.post('/login', (req, res) => {
// ... validate user ...
const sessionId = generateSecureSessionId();
res.cookie('sessionId', sessionId, {
httpOnly: true, // No JS access
secure: process.env.NODE_ENV === 'production', // HTTPS only
sameSite: 'strict', // CSRF protection
maxAge: 3600000 // 1 hour
});
res.json({ message: 'Logged in' });
});7. Fehlerbehandlung ohne Informationslecks
Wenn etwas kaputtgeht, darf dein Stack Trace niemals beim Client ankommen. Niemals. Er verrät Angreifern genau, welche Versionen welcher Libraries du nutzt, absolute Pfade auf deinem Server und manchmal sogar die Datenbankstruktur.
Ich bin es leid, das in PRs zu sehen. Fang Fehler global ab. Logge die Details in dein SIEM. Gib dem Nutzer einen generischen 500 zurück.
app.use((err, req, res, next) => {
// Log the full stack trace internally
logger.error('Unhandled Exception:', err);
// Return generic response
res.status(500).json({
error: 'An unexpected error occurred. Please try again later.'
});
});8. Best Practices für Kryptografie
Hör auf, deine eigene Kryptografie zu erfinden. Hör auf, MD5 oder SHA-1 für Passwörter zu verwenden. Nutze Argon2id oder bcrypt. 2026 ist Argon2id der Standard.
import * as argon2 from 'argon2';
async function hashPassword(password: string) {
try {
return await argon2.hash(password, {
type: argon2.argon2id,
memoryCost: 2 ** 16,
timeCost: 3,
parallelism: 1,
});
} catch (err) {
throw new Error('Hashing failed');
}
}Für die Verschlüsselung personenbezogener Daten im Ruhezustand nutze AES-256-GCM. Es bietet authentifizierte Verschlüsselung. Finger weg vom ECB-Modus. Finger weg von CBC ohne HMAC. Nimm einfach GCM und gut ist.
Zum Abschluss
Hör zu, Secure Coding Practices sind keine Magie. Sie sind Disziplin. Sie bedeuten, schlampige PRs nicht zu mergen. Sie bedeuten, SDLC Security mit SAST/DAST-Tools in deine Pipelines einzubauen, damit solche Dinge automatisch auffallen.
Ich bin es leid, das in PRs zu sehen. Fang noch heute an, diese Muster umzusetzen. Räum deine Zod-Schemas auf. Repariere dein CORS. Weg mit deinen Wildcards. Deine On-Call-Rotation wird es dir danken, wenn du nicht um 3 Uhr nachts wegen eines Datenlecks geweckt wirst.
![Secure Coding Practices: Das Playbook für Senior Engineers [Audit 2026]](/_next/image?url=%2Fblog%2Ftest-mockup.jpg&w=3840&q=75&dpl=dpl_4APdW92RmtTARbNBj4X6xdJXX9hA)