Linux.BackDoor.Gates.5

Un logiciel malveillant ciblant les distributions Linux 32-bits combine les fonctions de backdoor et de bot DDoS. Le Trojan se compose de deux modules fonctionnels : le module principal est un backdoor capable d'exécuter les commandes reçues des pirates, et l'autre est destiné à lancer des attaques DDoS. La communication entre les modules est rendue possible par l'ouverture d'un port sur l'ordinateur infecté, le numéro de port étant intégré au code du backdoor.

Durant son fonctionnement, Linux.BackDoor.Gates.5 recueille et transmet aux malfaiteurs les informations suivantes sur la machine contaminée :

1. Nombre de noyaux CPU (lu depuis /proc/cpuinfo).
2. Vitesse de CPU (lu depuis /proc/cpuinfo).
3. Utilisation de CPU (lu depuis /proc/stat).
4. IP Gate (lu depuis /proc/net/route).
5. Adresse MAC de Gate (lu depuis /proc/net/arp).
6. Informations sur les interfaces réseau (lues depuis /proc/net/dev).
7. Adresse MAC de la carte réseau.
8. Volume de mémoire (en utilisant le paramètre MemTotal de /proc/meminfo).
9. Volume des données transmises et reçues (lu depuis /proc/net/dev).
10. Nom et version de l'OS (en utilisant la commande uname).

Après son lancement, Linux.BackDoor.Gates.5 vérifie le chemin vers le dossier depuis lequel il a été lancé :

%curdir%/getty
usr/bin/getty
/bin/netstat
/bin/lsof
/bin/ps
/usr/bin/netstat
/usr/bin/lsof
/usr/bin/ps
/usr/sbin/netstat
/usr/sbin/lsof
/usr/sbin/ps

Si le chemin de l'emplacement du fichier exécutable du backdoor est différent des chemins des utilitaires netstat, lsof, ps, le Trojan se lance dans le système en tant que daemon. Puis commence la procédure d'initialisation au cours de laquelle il décrypte de son corps un fichier de configuration dont la structure est la suivante :

struct CONFIG
{
    std::string g_strConnTgt;
    DWORD g_iGatsPort;
    DWORD g_iGatsIsFx;
    DWORD g_iIsService;
    std::string g_strBillTail;
    std::string g_strForceNote;
    std::string g_bDoBackboor;
    std::string g_strCryptStart;
    std::string g_strDStart;
    std::string g_strNStart;
};

Selon la valeur du paramètre g_iGatsIsFx dans le fichier de configuration, le Trojan se connecte lui-même au serveur ou lie le socket au port indiqué dans le paramètre g_iGatsPort et attend une connexion entrante. Le backdoor possède des fonctionnalités de mise à jour. La commande reçue inclut le lien pour télécharger les mises à jour. Le fichier est sauvegardé dans le répertoire /tmp/%d, où %d est un chiffre aléatoire.

Installation.

Lors de son installation, le Trojan vérifie le fichier /tmp/moni.lock, et si le fichier n'est pas vide, il y lit la valeur enregistrée (PID) et "tue" ce processus. Puis il vérifie si le module DDoS est lancé. Cette vérification représente une tentative de lier (bind) le socket au port spécifié. Si la tentative échoue, le module est considéré comme lancé. Puis le backdoor lit le PID du module DDoS depuis le fichier /tmp/bill.lock et " tue " ce processus.

Ensuite, le Trojan crée un fichier avec un nom qui se compose du nom du processus lancé et de la valeur g_strBillTail du fichier de configuration, et y enregistre 0x5651C octets du corps du backdoor à l'offset 0x81583. Ce fichier représente le module DDoS. Si le fichier de configuration comporte un indicateur g_iIsService, le Trojan s’enregistre lui-même dans le démarrage automatique via la ligne #!/bin/bash\n qu'il écrit dans le fichier /etc/init.d/, puis Linux.BackDoor.Gates.5 crée les liens symboliques suivants :

ln -s /etc/init.d/DbSecuritySpt /etc/rc1.d/S97DbSecuritySpt
ln -s /etc/init.d/DbSecuritySpt /etc/rc2.d/S97DbSecuritySpt
ln -s /etc/init.d/DbSecuritySpt /etc/rc3.d/S97DbSecuritySpt
ln -s /etc/init.d/DbSecuritySpt /etc/rc4.d/S97DbSecuritySpt

Si le fichier de configuration contient un indicateur g_bDoBackdoor, le Trojan vérifie la disponibilité des droits root de son processus, pour ce faire, il tente d'ouvrir le fichier /root/profile.

Puis le Trojan vérifie si le processus du backdoor est lancé. Le fichier /usr/bin/bsd-port/getty.lock, au sein duquel le PID du backdoor est enregistré lors du lancement, est utilisé comme fichier .lock du backdoor. Si le processus est lancé, il sera « tué ». Le backdoor crée sa copie dans /usr/bin/ bsd port/getty et il se lance.

Au stade final de l'installation, Linux.BackDoor.Gates.5 crée une autre copie dans le dossier /usr/bin/ avec le nom spécifié dans le fichier de configuration, et remplace les utilitaires suivants :

/bin/netstat
/bin/lsof
/bin/ps
/usr/bin/netstat
/usr/bin/lsof
/usr/bin/ps
/usr/sbin/netstat
/usr/sbin/lsof
/usr/sbin/ps

Ainsi, le processus d'installation du Trojan est terminé et la fonction permettant d’effectuer ses tâches principales est appelée.

Charge utile.

Le Trojan est également lancé comme daemon, puis décrypte le fichier de configuration et effectue l'initialisation. Puis il vérifie si ses composants sont en cours d'exécution en lisant le fichier correspondant .lock (et, sinon, les lance), il peut utiliser différents noms pour ses fichiers y compris dans l'auto démarrage. En fonction du chemin de son lancement, le Trojan attend les commandes du serveur de gestion ou établit la connexion lui-même. Le Trojan lance deux threads, dont l'un avec l'intervalle de 6000 ms vérifie si le backdoor fonctionne (en analysant /tmp/gates.lock) et, sinon le lance. Le second thread vérifie si le module DDoS est lancé (la tentative de bind du socket au port spécifié) et, sinon le lance.

Après avoir établi une connexion au serveur de commande, Linux.BackDoor.Gates.5 reçoit depuis ce serveur des données de configuration avec une tâche que le bot doit accomplir. Selon une commande des pirates, le Trojan est capable de se mettre à jour automatiquement, de lancer ou de stopper une attaque DDoS sur un nœud distant avec une adresse IP et un port spécifiés, d’exécuter une commande depuis le jeu de données de configuration ou d'établir une connexion avec un nœud distant ayant une IP spécifiée afin d’exécuter d'autres commandes.

Le paquet de gestion reçu du serveur ressemble à la structure TASK :

struct IP_LIST
{
    char szIP[0]; //C-строка, содержащая IP-адрес для DDoS-атаки
    WORD wPort; //Порт
}
struct SUBTASK
{
    DWORD Cmd;
    BYTE Type; //тип DDoS атаки
    BYTE byte05;
    BYTE byte06;
    BYTE dummy; //0x00
    DWORD dword08;
    BYTE byte0C;
    BYTE byte0D;
    WORD word0E;
    WORD word10;
    WORD word12;
    BYTE byte14;
    BYTE byte15;
    BYTE dummy2[2]; //0x00
    DWORD dword18;
    DWORD dword1C;
    DWORD dwThreadCount; //количество потоков для DDoS атаки
    DWORD dword24;
    char szDomens[0]; //C-строка содержащая список доменов, разделенных ','
    DWORD dwIPCount; //Количество структур IP_LIST
    struct IP_LIST[0]; //Пары IP:порт для DDoS'а
};
struct TASK
{
    DWORD Cmd;
    DWORD Size;
    BYTE Data[0x0D];
    DWORD dword15;
    DWORD dword19;
    DWORD dwSubTaskCount; //количество структур SUBTASK в команде
    struct SUBTASK[0];
};

Pour maintenir la connexion, le Trojan utilise une structure simplifiée :

struct TASK_ping
{
    DWORD Cmd; // 0x04
    DWORD Size; // 0x00
}

En fonction de la structure CMD, le TASK peut exécuter les commandes suivantes :

La communication avec le serveur de gestion

L'établissement de la connexion avec un serveur de gestion se passe en deux étapes. A la première étape, le Trojan envoie au serveur un paquet dont la taille est de 119 octets qui contient l'information sur la configuration (les données de configuration et les données du système).

0000000000: 01 00 00 00 6F 00 00 00 │ 00 F4 01 00 00 32 00 00  ☺   o    ф☺  2
0000000010: 00 E8 03 00 00 00 00 00 │ 00 00 00 00 00 00 00 00   и♥
0000000020: 00 01 00 01 02 00 00 00 │ 01 00 00 00 C0 A8 00 C8   ☺ ☺☻   ☺   АЁ И
0000000030: C0 A8 00 C8 C0 A8 00 C8 │ C0 A8 00 C8 C0 A8 00 C8  АЁ ИАЁ ИАЁ ИАЁ И
0000000040: FF FF 01 00 00 00 00 00 │ 6D 6D 3A 00 01 00 00 00  яя☺     mm: ☺
0000000050: B8 0B 00 00 E9 03 00 00 │ 4C 69 6E 75 78 20 33 2E  ё♂  й♥  Linux 3.
0000000060: 31 33 2E 30 2D 32 34 2D │ 67 65 6E 65 72 69 63 00  13.0-24-generic
0000000070: 47 2D 31 2E 39 30 00    │                          G-1.90

Le serveur envoie en réponse le paquet (20 octets) suivant :

0000000000: 08 00 00 00 0C 00 00 00 │ 00 00 00 00 00 00 00 00  ◘   ♀
0000000010: E8 FD 00 00             │                          ??

Le paquet se compose de trois parties. La première partie (de 4 octets) porte la commande. La deuxième partie - 4 octets qui représentent le DWORD. Ce DWORD représente la taille du paquet suivant (la troisième partie du paquet). La troisième partie inclut le bloc de configuration avec la tâche à exécuter pour le client.

Puis l'échange de paquets commence afin de maintenir la connexion. Si le serveur n'envoie pas de commande, les deuxièmes 4 octets égalent zéro (c'est-à dire que la taille du paquet portant la commande est égale à 0) et l'étape de la réception de la commande n’a pas lieu.