Junior Security Engineer Interviewfragen

Einführung

In einem Interview als Junior Security Engineer wird meist geprüft, ob du Sicherheitsgrundlagen erklären und auf reale Aufgaben anwenden kannst: Schwachstellen priorisieren, SIEM-Alerts lesen, Passwörter absichern, TLS prüfen und bei Incidents ruhig reagieren.

Nutze diese Fragen, um kurze Antworten zu üben, die ein Konzept mit einer konkreten Handlung im Job verbinden.

Sicherheitsgrundlagen

1. Erkläre die CIA-Triade.

Antwort: Die CIA-Triade ist das Fundament der Informationssicherheit:

Vertraulichkeit (Confidentiality):

Nur autorisierte Benutzer können auf Daten zugreifen
Erreicht durch: Verschlüsselung, Zugriffskontrollen, Authentifizierung

Integrität (Integrity):

Daten bleiben korrekt und unverändert
Erreicht durch: Hashing, digitale Signaturen, Prüfsummen

Verfügbarkeit (Availability):

Systeme und Daten sind bei Bedarf zugänglich
Erreicht durch: Redundanz, Backups, DDoS-Schutz

Loading diagram...

Beispiele für Verstöße:

Vertraulichkeit: Datenleck, das Kundeninformationen offenlegt
Integrität: Angreifer ändert Finanzdaten
Verfügbarkeit: DDoS-Angriff legt Website lahm

Häufigkeit: Sehr häufig Schwierigkeit: Einfach

OWASP Top 10

2. Nenne drei Punkte aus den OWASP Top 10 und erkläre sie.

Antwort: Die OWASP Top 10 listet die kritischsten Sicherheitsrisiken für Webanwendungen auf:

1. Injection (SQL Injection): Angreifer schleust bösartigen Code in Abfragen ein.

# Anfälliger Code
username = request.GET['username']
query = f"SELECT * FROM users WHERE username = '{username}'"
# Angriff: username = "admin' OR '1'='1"

# Sicherer Code (parametrisierte Abfrage)
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))

2. Broken Access Control (Fehlerhafte Zugriffskontrolle): Benutzer können auf Ressourcen zugreifen, auf die sie keinen Zugriff haben sollten.

# Anfällig: Keine Autorisierungsprüfung
@app.route('/admin/users/<user_id>')
def get_user(user_id):
    return User.query.get(user_id)

# Sicher: Autorisierung prüfen
@app.route('/admin/users/<user_id>')
@require_admin
def get_user(user_id):
    if not current_user.is_admin:
        abort(403)
    return User.query.get(user_id)

3. Cross-Site Scripting (XSS): Angreifer schleust bösartige Skripte in Webseiten ein.

<!-- Anfällig -->
<div>Willkommen, {{ username }}</div>

<!-- Angriff -->
username = "<script>alert('XSS')</script>"

<!-- Sicher (Ausgabe maskieren) -->
<div>Willkommen, {{ username | escape }}</div>

Häufigkeit: Sehr häufig Schwierigkeit: Mittel

3. Wie führst du Vulnerability Management durch?

Antwort: Vulnerability Management ist ein kontinuierlicher Prozess zur Identifizierung, Bewertung und Behebung von Sicherheitsschwachstellen. Eine starke Junior-Antwort nennt Asset-Inventar, Schweregrad, Ausnutzbarkeit, Exposition, geschäftliche Auswirkungen, Zuständigkeit und Verifikation.

Verlasse dich nicht nur auf den CVSS-Wert. Priorisiere Schwachstellen, die aktiv ausgenutzt werden, internetexponiert sind, kritische Assets betreffen oder leicht mit anderen Schwächen verkettet werden können.

Prozess:

Loading diagram...

Vulnerability Scanning:

# Nmap Schwachstellenscan
nmap --script vuln 192.168.1.100

# OpenVAS Scan
openvas-start
# Zugriff auf die Weboberfläche unter https://localhost:9392

# Nessus Scan (kommerziell)
# Konfiguration über die Weboberfläche

Nessus Beispiel:

# Nessus Scan automatisieren
import requests
import time

class NessusScanner:
    def __init__(self, url, access_key, secret_key):
        self.url = url
        self.headers = {
            'X-ApiKeys': f'accessKey={access_key}; secretKey={secret_key}'
        }
    
    def create_scan(self, name, targets):
        data = {
            'uuid': 'template-uuid',  # Basic Network Scan
            'settings': {
                'name': name,
                'text_targets': targets
            }
        }
        response = requests.post(
            f'{self.url}/scans',
            headers=self.headers,
            json=data,
            verify=False
        )
        return response.json()['scan']['id']
    
    def launch_scan(self, scan_id):
        requests.post(
            f'{self.url}/scans/{scan_id}/launch',
            headers=self.headers,
            verify=False
        )
    
    def get_results(self, scan_id):
        response = requests.get(
            f'{self.url}/scans/{scan_id}',
            headers=self.headers,
            verify=False
        )
        return response.json()

# Verwendung
scanner = NessusScanner('https://nessus:8834', 'access_key', 'secret_key')
scan_id = scanner.create_scan('Wöchentlicher Scan', '192.168.1.0/24')
scanner.launch_scan(scan_id)

Patch Management:

# Linux Patch Management
# Ubuntu/Debian
sudo apt update
sudo apt list --upgradable
sudo apt upgrade -y

# CentOS/RHEL
sudo yum check-update
sudo yum update -y

# Automatisches Patchen
sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

Priorisierungsmatrix:

CVSS Score	Ausnutzbarkeit	Kritikalität des Assets	Priorität
Kritisch (9-10)	Öffentlicher Exploit	Produktion	P1 (Sofort)
Hoch (7-8.9)	PoC verfügbar	Produktion	P2 (1 Woche)
Mittel (4-6.9)	Kein Exploit	Intern	P3 (1 Monat)
Niedrig (0-3.9)	Kein Exploit	Dev/Test	P4 (Nächster Zyklus)

Nachverfolgung der Behebung:

# Vulnerability Tracking
class VulnerabilityTracker:
    def __init__(self):
        self.vulnerabilities = []
    
    def add_vulnerability(self, vuln):
        self.vulnerabilities.append({
            'id': vuln['id'],
            'severity': vuln['severity'],
            'asset': vuln['asset'],
            'status': 'open',
            'discovered': datetime.now(),
            'sla_deadline': self.calculate_sla(vuln['severity'])
        })
    
    def calculate_sla(self, severity):
        sla_days = {
            'critical': 7,
            'high': 30,
            'medium': 90,
            'low': 180
        }
        return datetime.now() + timedelta(days=sla_days[severity])
    
    def get_overdue(self):
        return [v for v in self.vulnerabilities 
                if v['status'] == 'open' and 
                datetime.now() > v['sla_deadline']]

Häufigkeit: Häufig Schwierigkeit: Einfach-Mittel

Grundlagen der Verschlüsselung

4. Was ist der Unterschied zwischen symmetrischer und asymmetrischer Verschlüsselung?

Antwort:

Symmetrische Verschlüsselung:

Derselbe Schlüssel für Verschlüsselung und Entschlüsselung
Schnell
Beispiele: AES, DES, 3DES

Asymmetrische Verschlüsselung:

Öffentlicher Schlüssel verschlüsselt, privater Schlüssel entschlüsselt
Langsamer
Beispiele: RSA, ECC

# Symmetrische Verschlüsselung (AES)
from cryptography.fernet import Fernet

# Schlüssel generieren
key = Fernet.generate_key()
cipher = Fernet(key)

# Verschlüsseln
encrypted = cipher.encrypt(b"Geheime Nachricht")

# Entschlüsseln
decrypted = cipher.decrypt(encrypted)

# Asymmetrische Verschlüsselung (RSA)
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

# Schlüsselpaar generieren
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# Verschlüsseln mit öffentlichem Schlüssel, entschlüsseln mit privatem Schlüssel

Anwendungsfälle:

Symmetrisch: Verschlüsselung großer Datenmengen (Dateien, Datenbanken)
Asymmetrisch: Schlüsselaustausch, digitale Signaturen, SSL/TLS

Häufigkeit: Sehr häufig Schwierigkeit: Einfach-Mittel

5. Wie funktioniert SSL/TLS und wie verwaltet man Zertifikate?

Antwort: SSL/TLS verschlüsselt Daten während der Übertragung zwischen Client und Server.

TLS Handshake:

Loading diagram...

Funktionsweise:

Client Hello: Client sendet unterstützte Cipher Suites
Server Hello: Server wählt Cipher Suite, sendet Zertifikat
Zertifikatsverifizierung: Client validiert die Zertifikatskette
Schlüsselaustausch: Gemeinsames Geheimnis festlegen
Verschlüsselte Kommunikation: Symmetrische Verschlüsselung verwenden

Zertifikatkomponenten:

# Zertifikatsdetails anzeigen
openssl x509 -in certificate.crt -text -noout

# Zertifikat enthält:
# - Subject (Domainname)
# - Issuer (CA)
# - Gültigkeitszeitraum
# - Öffentlicher Schlüssel
# - Signatur

Zertifikatsverwaltung:

CSR (Certificate Signing Request) generieren:

# Privaten Schlüssel generieren
openssl genrsa -out private.key 2048

# CSR generieren
openssl req -new -key private.key -out request.csr

# CSR anzeigen
openssl req -text -noout -verify -in request.csr

Selbstsigniertes Zertifikat (Testen):

# Selbstsigniertes Zertifikat generieren
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes

# Für die Serververwendung kombinieren
cat cert.pem key.pem > server.pem

Zertifikat installieren:

# Nginx
server {
    listen 443 ssl;
    server_name example.com;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
}

# Apache
<VirtualHost *:443>
    ServerName example.com
    
    SSLEngine on
    SSLCertificateFile /etc/apache2/ssl/cert.pem
    SSLCertificateKeyFile /etc/apache2/ssl/key.pem
    SSLCertificateChainFile /etc/apache2/ssl/chain.pem
    
    SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
    SSLCipherSuite HIGH:!aNULL:!MD5
</VirtualHost>

Häufige Fehlkonfigurationen:

1. Schwache Protokolle:

# Schlecht: Erlaubt SSLv3, TLSv1.0
ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;

# Gut: Nur modernes TLS
ssl_protocols TLSv1.2 TLSv1.3;

2. Schwache Cipher Suites:

# SSL Konfiguration testen
sslscan example.com
nmap --script ssl-enum-ciphers -p 443 example.com

# Oder Online-Tools verwenden
# https://www.ssllabs.com/ssltest/

3. Abgelaufene Zertifikate:

# Zertifikatsablauf prüfen
openssl s_client -connect example.com:443 -servername example.com < /dev/null 2>/dev/null | \
    openssl x509 -noout -dates

# Ablauf überwachen
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | \
    openssl x509 -noout -enddate

Zertifikatsautomatisierung (Let's Encrypt):

# Certbot installieren
sudo apt install certbot python3-certbot-nginx

# Zertifikat beziehen
sudo certbot --nginx -d example.com -d www.example.com

# Auto-Renewal (Cron)
0 0 * * * certbot renew --quiet

Fehlerbehebung:

# TLS Verbindung testen
openssl s_client -connect example.com:443 -servername example.com

# Zertifikatskette verifizieren
openssl verify -CAfile ca-bundle.crt certificate.crt

# Prüfen, ob Zertifikat zum privaten Schlüssel passt
openssl x509 -noout -modulus -in cert.pem | openssl md5
openssl rsa -noout -modulus -in key.pem | openssl md5
# Hashes sollten übereinstimmen

Häufigkeit: Häufig Schwierigkeit: Mittel

Firewalls

6. Erkläre Stateful vs. Stateless Firewalls.

Antwort:

Stateless Firewall:

Untersucht jedes Paket unabhängig
Keine Verbindungsverfolgung
Schneller, aber weniger sicher
Beispiel: Grundlegender Paketfilter

Stateful Firewall:

Verfolgt den Verbindungsstatus
Merkt sich vorherige Pakete
Sicherer
Beispiel: Moderne Firewalls

# iptables (stateful)
# Erlaubt etablierte Verbindungen
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Erlaubt neue SSH Verbindungen
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -j ACCEPT

# Alles andere verwerfen
iptables -A INPUT -j DROP

Verbindungszustände:

NEW: Erstes Paket einer Verbindung
ESTABLISHED: Teil einer bestehenden Verbindung
RELATED: Bezogen auf eine bestehende Verbindung
INVALID: Entspricht keinem Zustand

Häufigkeit: Häufig Schwierigkeit: Mittel

SIEM

7. Was ist ein SIEM und warum ist es wichtig?

Antwort: SIEM (Security Information and Event Management) zentralisiert die Protokollsammlung und -analyse.

Kernfunktionen:

Protokollsammlung: Sammeln von Protokollen aus mehreren Quellen
Normalisierung: Standardisierung von Protokollformaten
Korrelation: Identifizierung von Mustern und Beziehungen
Benachrichtigung: Benachrichtigung bei verdächtigen Aktivitäten
Berichterstattung: Compliance und Forensik

Loading diagram...

Anwendungsfälle:

Erkennen von Brute-Force-Angriffen
Identifizieren von Datenexfiltration
Überwachen des privilegierten Zugriffs
Compliance-Berichterstattung (PCI-DSS, HIPAA)

Beliebte SIEM-Tools:

Splunk
ELK Stack (Elasticsearch, Logstash, Kibana)
IBM QRadar
ArcSight

Häufigkeit: Häufig Schwierigkeit: Mittel

8. Was ist der Unterschied zwischen IDS und IPS?

Antwort: IDS (Intrusion Detection System) und IPS (Intrusion Prevention System) überwachen den Netzwerkverkehr auf Bedrohungen.

Hauptunterschiede:

Merkmal	IDS	IPS
Aktion	Erkennt und warnt	Erkennt und blockiert
Platzierung	Out-of-band (passiv)	Inline (aktiv)
Auswirkung	Keine Verkehrsunterbrechung	Kann legitimen Verkehr blockieren
Antwort	Manuell	Automatisch
Falsch Positive	Weniger kritisch	Kritischer

IDS-Bereitstellung:

Loading diagram...

IPS-Bereitstellung:

Loading diagram...

Snort-Konfiguration (IDS/IPS):

# Snort installieren
sudo apt install snort

# Netzwerk konfigurieren
sudo vi /etc/snort/snort.conf
# HOME_NET setzen
ipvar HOME_NET 192.168.1.0/24
ipvar EXTERNAL_NET !$HOME_NET

# Im IDS-Modus ausführen
sudo snort -A console -q -c /etc/snort/snort.conf -i eth0

# Im IPS-Modus (inline) ausführen
sudo snort -Q -c /etc/snort/snort.conf -i eth0

Snort-Regeln:

# Regelsyntax
# action protocol src_ip src_port -> dst_ip dst_port (options)

# SQL-Injection erkennen
alert tcp any any -> $HOME_NET 80 (msg:"SQL Injection Versuch"; \
    content:"UNION SELECT"; nocase; sid:1000001; rev:1;)

# Portscan erkennen
alert tcp any any -> $HOME_NET any (msg:"Port Scan erkannt"; \
    flags:S; threshold:type both, track by_src, count 20, seconds 60; \
    sid:1000002; rev:1;)

# Brute-Force-SSH erkennen
alert tcp any any -> $HOME_NET 22 (msg:"SSH Brute Force"; \
    flags:S; threshold:type both, track by_src, count 5, seconds 60; \
    sid:1000003; rev:1;)

# Bösartige IP blockieren (IPS-Modus)
drop tcp 203.0.113.50 any -> $HOME_NET any (msg:"Bösartige IP blockiert"; \
    sid:1000004; rev:1;)

Suricata (Moderne Alternative):

# Suricata installieren
sudo apt install suricata

# Regeln aktualisieren
sudo suricata-update

# Suricata ausführen
sudo suricata -c /etc/suricata/suricata.yaml -i eth0

# Warnungen anzeigen
sudo tail -f /var/log/suricata/fast.log

Warnungsanalyse:

# Snort-Warnungen parsen
import re
from collections import Counter

def analyze_snort_alerts(log_file):
    alerts = []
    
    with open(log_file, 'r') as f:
        for line in f:
            # Warnung parsen
            match = re.search(r'\[\*\*\] \[(\d+):(\d+):(\d+)\] (.+?) \[\*\*\]', line)
            if match:
                alerts.append({
                    'sid': match.group(1),
                    'message': match.group(4),
                    'line': line
                })
    
    # Top-Warnungen
    alert_counts = Counter([a['message'] for a in alerts])
    print("Top 10 Warnungen:")
    for alert, count in alert_counts.most_common(10):
        print(f"{count:5d} - {alert}")
    
    return alerts

# Verwendung
alerts = analyze_snort_alerts('/var/log/snort/alert')

Häufige Angriffssignaturen:

# SQL-Injection
content:"' OR 1=1--";
content:"UNION SELECT";

# XSS
content:"<script>";
content:"javascript:";

# Befehlsinjektion
content:";cat /etc/passwd";
content:"|whoami";

# Directory Traversal
content:"../../../";

# Shellshock
content:"() { :; };";

Bewährte Verfahren:

Signaturen regelmäßig aktualisieren
Regeln optimieren, um falsch positive Ergebnisse zu reduzieren
IPS auf blockierten legitimen Datenverkehr überwachen
Integration mit SIEM zur Korrelation
Im IDS-Modus testen, bevor IPS aktiviert wird

Häufigkeit: Häufig Schwierigkeit: Mittel

Sicherheitsrichtlinien

9. Wie sicherst du Passwörter?

Antwort: Mehrschichtige Passwortsicherheit:

1. Hashing (nicht Verschlüsselung):

import hashlib
import os

def hash_password(password):
    # Salt generieren
    salt = os.urandom(32)
    
    # Passwort mit Salt hashen
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000  # Iterationen
    )
    
    # Salt + Hash speichern
    return salt + key

def verify_password(stored_password, provided_password):
    salt = stored_password[:32]
    stored_key = stored_password[32:]
    
    key = hashlib.pbkdf2_hmac(
        'sha256',
        provided_password.encode('utf-8'),
        salt,
        100000
    )
    
    return key == stored_key

2. Passwortrichtlinie:

Lange Passwörter oder Passphrasen statt erzwungener Komplexität bevorzugen
Passwortmanager sowie Einfügen/Autofill erlauben
Bekannte kompromittierte oder sehr häufige Passwörter blockieren
Wo möglich MFA verlangen
Zurücksetzen erzwingen, wenn es Hinweise auf Kompromittierung gibt, nicht nur wegen eines festen Zeitplans

3. Zusätzliche Sicherheit:

Multi-Faktor-Authentifizierung (MFA)
Kontosperrung nach fehlgeschlagenen Versuchen
Passwortstärke-Meter
Erkennung von Sicherheitsverletzungen (Have I Been Pwned API)

Niemals:

Passwörter im Klartext speichern
Schwaches Hashing verwenden (MD5, SHA1)
Hashen ohne Salt

Häufigkeit: Sehr häufig Schwierigkeit: Mittel

Reaktion auf Vorfälle

10. Was sind die Phasen der Reaktion auf Vorfälle?

Antwort: NIST Incident Response Lifecycle:

1. Vorbereitung:

IR-Plan entwickeln
Team schulen
Tools und Überwachung einrichten

2. Erkennung & Analyse:

Vorfälle identifizieren
Umfang und Auswirkungen analysieren
Reaktion priorisieren

3. Eindämmung:

Kurzfristig: Betroffene Systeme isolieren
Langfristig: Patches anwenden, Systeme neu aufbauen

4. Beseitigung:

Malware entfernen
Schwachstellen schließen
Abwehrmaßnahmen verstärken

5. Wiederherstellung:

Systeme wiederherstellen
Auf Reinfektion überwachen
Zum Normalbetrieb zurückkehren

6. Nach dem Vorfall:

Dokumentation der gewonnenen Erkenntnisse
Verfahren aktualisieren
Abwehrmaßnahmen verbessern

Loading diagram...

Häufigkeit: Häufig Schwierigkeit: Mittel

Fazit

Für ein Junior Security Engineer-Interview solltest du Grundlagen erklären und zeigen können, wie du sie in einer echten Umgebung anwendest. Konzentriere dich auf:

Grundlagen: CIA-Triade, Least Privilege, Authentifizierung, Autorisierung
OWASP: Broken Access Control, kryptografische Fehler, Injection, Logging und Monitoring
Vulnerability Management: Asset-Kontext, Ausnutzbarkeit, Behebung, Verifikation
Kryptografie und TLS: Verschlüsselung, Hashing, Zertifikate, moderne Protokolleinstellungen
Defensive Tools: Firewalls, SIEM, IDS/IPS, Alert-Tuning
Passwortsicherheit: Hashing, Salts, MFA, Prüfung auf kompromittierte Passwörter
Incident Response: Vorbereitung, Erkennung, Eindämmung, Wiederherstellung, Lessons Learned

Übe mit konkreten Beispielen aus Labs, Projekten, Praktika oder deiner eigenen Testumgebung. Interviewer erwarten nicht jedes Tool im Detail, sondern klare Begründungen, sinnvolle Priorisierung und ehrliche Kommunikation.

Frische Karrieretipps

Junior Security Engineer Interviewfragen und Antworten

Einführung

Sicherheitsgrundlagen

1. Erkläre die CIA-Triade.

OWASP Top 10

2. Nenne drei Punkte aus den OWASP Top 10 und erkläre sie.

3. Wie führst du Vulnerability Management durch?

Grundlagen der Verschlüsselung

4. Was ist der Unterschied zwischen symmetrischer und asymmetrischer Verschlüsselung?

5. Wie funktioniert SSL/TLS und wie verwaltet man Zertifikate?

Firewalls

6. Erkläre Stateful vs. Stateless Firewalls.

SIEM

7. Was ist ein SIEM und warum ist es wichtig?

8. Was ist der Unterschied zwischen IDS und IPS?

Sicherheitsrichtlinien

9. Wie sicherst du Passwörter?

Reaktion auf Vorfälle

10. Was sind die Phasen der Reaktion auf Vorfälle?

Fazit

Wöchentliche Karrieretipps, die wirklich funktionieren

Wöchentliche Karrieretipps, die wirklich funktionieren

Verwandte Beiträge

Bewerbungsfragen für Junior Network Engineers mit Antworten

Junior Machine Learning Engineer: Interviewfragen

Junior React Native Entwickler: Interviewfragen und Antworten

Ihr nächstes Vorstellungsgespräch ist nur einen Lebenslauf entfernt

Diesen Beitrag teilen

Reduzieren Sie Ihre Lebenslauf-Schreibzeit um 90%