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

Hör auf, Fußangeln auszuliefern. So schreibst du 2026 wirklich sicheren Code.

Ein ungeschöntes Playbook ohne Bullshit für sichere Programmierpraktiken. Wir behandeln Eingabevalidierung mit Zod, parametrisierte Queries, CSP und die SDLC-Security-Muster, die du wahrscheinlich ignorierst.

VG
Vladyslav Gusarov
DevSecOps Lead bei Bryxe
Secure Coding Practices: Das Playbook für Senior Engineers [Audit 2026]

# 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.

typescriptQuellcode
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:

typescriptQuellcode
// 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.

typescriptQuellcode
// 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.

typescriptQuellcode
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.

typescriptQuellcode
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.

typescriptQuellcode
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.

typescriptQuellcode
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.

typescriptQuellcode
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.

typescriptQuellcode
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.

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