IT-Sicherheit
Secure Coding – 10 Regeln um sichere Software zu bauen
Kevin KrögerIT-Sicherheit
Du brauchst nicht ein Security-Experte zu sein um sichere Code zu schreiben. Du brauchst nur 10 einfache Regeln zu followen. Wir haben sie für dich zusammengefasst.
Regel 1: Inputs validieren, IMMER
Das ist Regel Nummer Eins für einen Grund: Das ist die häufigste Ursache von Vulnerabilities.
Jeder Input von außen – von einem User, einer API, einer Datei – ist potentiell malicious. Validiere ALLES:
```python
# FALSCH:
sql = f"SELECT * FROM users WHERE email = {user_input}"
# RICHTIG:
cursor.execute("SELECT * FROM users WHERE email = ?", (user_input,))
```
Das ist die Differenz zwischen einer sicheren Applikation und einer, die gehackt werden kann.
Regel 2: Prepared Statements für Datenbank-Queries
Never string concatenation für SQL. Immer prepared statements.
```python
# FALSCH – SQL Injection:
query = f"DELETE FROM users WHERE id = {user_id}"
# RICHTIG – Prepared Statement:
cursor.execute("DELETE FROM users WHERE id = ?", (user_id,))
```
Das schützt dich vor SQL Injection.
Regel 3: Escape Output
Wenn du daten anzeigst (in HTML, JSON, XML), escape sie:
```python
# FALSCH – XSS:
html = f"<h1>{user_input}</h1>"
# RICHTIG – Escaped:
from html import escape
html = f"<h1>{escape(user_input)}</h1>"
```
Das schützt dich vor XSS.
Regel 4: Strong Cryptography
Benutze moderne Crypto-Algorithmen. Nicht MD5, nicht SHA1 – benutze SHA256 oder besser.
Für Passwörter: Benutze bcrypt, scrypt, oder Argon2. Niemals plain text.
```python
# FALSCH:
password_hash = hashlib.md5(password).hexdigest()
# RICHTIG:
import bcrypt
password_hash = bcrypt.hashpw(password, bcrypt.gensalt())
```
Regel 5: Authentifizierung und Authorization
Immer Benutzer authentifizieren (wer bist du?). Und immer autorisieren (darfst du das?):
```python
# RICHTIG – mit Checks:
@require_login # Authentication
def delete_user(user_id):
current_user = get_current_user()
if current_user.id != user_id and not current_user.is_admin:
raise PermissionDenied() # Authorization
delete(user_id)
```
Regel 6: Fehler-Messages nicht zu informativ
Gebe nicht "User nicht gefunden" zurück wenn die Email nicht existiert. Das verrät Attackern welche Emails registriert sind.
```python
# FALSCH – Information Disclosure:
if user_not_found:
return "User nicht gefunden"
# RICHTIG – Generisch:
if user_not_found:
return "Email oder Passwort falsch"
```
Regel 7: Logging ohne sensitive Daten
Logge Security-relevante Events. Aber logge nicht Passwörter, Kreditkarten-Nummern, oder andere sensitive Daten.
```python
# FALSCH:
logger.info(f"User logged in: {username}, password: {password}")
# RICHTIG:
logger.info(f"User logged in: {username}")
```
Regel 8: Dependencies updaten
Alte Libraries haben bekannte Vulnerabilities. Update regelmäßig.
```bash
# Python:
pip install --upgrade -r requirements.txt
# Node.js:
npm audit fix
npm update
```
Regel 9: Secrets nicht im Code
Nie API Keys, Passwörter, oder Tokens im Code. Nutze Environment Variables:
```python
# FALSCH – Secret im Code:
db_password = "super_secret_123"
# RICHTIG – Umgebungsvariable:
db_password = os.getenv("DB_PASSWORD")
```
Regel 10: Security Review
Der beste sichere Code ist Code, der von jemandem anderem reviewed wurde. Peer Reviews sind essentiell.
```bash
# Git Workflow:
git branch feature/new-feature
# Develop feature
git push origin feature/new-feature
# Create Pull Request
# Peer review code
# Another developer approves
# Merge to main
```
Tools die helfen
- SAST (Static Analysis): SonarQube, Semgrep – Analyse deinen Code automatisch
- Dependency Checker: Snyk, OWASP Dependency Check – Finde vulnerable Dependencies
- Security Linter: Bandit (Python), ESLint mit Security Rules (JS)
- WAF: ModSecurity, CloudFlare – Blockiere Attacks auf HTTP-Level
Fazit
Sichere Code zu schreiben ist nicht schwer. Es erfordert nur Discipline und Aufmerksamkeit auf diese 10 Regeln. Die meisten Vulnerabilities entstehen, weil Entwickler diese Basics ignorieren.
FAQ
Related Articles
IT-Sicherheit
OWASP Top 10 – Die häufigsten Web-Sicherheitslücken erklärt
Die OWASP Top 10 ist eine Liste der zehn häufigsten und gefährlichsten Sicherheitslücken in Web-Anwendungen. Die Liste w...
IT-SicherheitSQL Injection – Die häufigste Web-Schwachstelle erklärt
SQL Injection ist die wahrscheinlich häufigste und gefährlichste Web-Schwachstelle. Auf fast jeder Liste von Top Hacking...
IT-SicherheitXSS (Cross-Site Scripting) – Wie HTML-Injection funktioniert
XSS ist wenn ein Attacker JavaScript-Code in eine Website injiziert. Dieser Code wird dann im Browser von echten Benutze...