Analyse de LOIC : Low Orbit Ion Cannon

Mis à jour le 26 janvier 2012.

Un outil de déni de service distribué de nouvelle génération

Ces derniers temps le Low Orbit Ion Cannon (LOIC) a fait beaucoup parler de lui sur Internet, il est en effet une pièce maitresse de l’« Operation Payback ». C’est le dispositif central utilisé par la confédération de hacker appelée Anon.

Ce programme permet à une personne non technicienne de participer à des attaques de déni de service distribué (DDOS) depuis son ordinateur. Ce qui le différentie de la plupart des outils d’attaque de ce type déjà disponibles, c’est sa facilité d’utilisation.

Le fonctionnement basique de LOIC est le suivant : L’utilisateur fourni une IP ou une URL, règle le port, le type d’attaque, la vitesse et envoie la sauce. LOIC a été téléchargé sur SourceForge environ 128000 fois (dont plus de 53000 fois rien que pour le mois de Décembre !).

 

Exemple d’écran de Low Orbit ION Cannon (L.O.I.C)

 

LOIC propose trois types d’attaques : le flood HTTP, le flood TCP et le flood UDP.

Rentrons plus en détail sur le code de LOIC,  je me base sur les sources de la version 1.0.3 disponibles sur SourceForge.

Le programme est codé en C#  et fait 500 lignes de code environ. La majorité du code sert à la gestion du GUI et à la validation des différentes entrées. La partie intéressante du programme est composé des classes HTTPFlooder et XXPFlooder.

HTTPFlooder

Cette classe est, comme son nom l’indique, un floodeur HTTP. Son fonctionnement est très simple, elle va ouvrir une connexion vers le port HTTP (le plus souvent le 80) et envoyer la requête suivante :

GET / HTTP/1.0

Puis on attend gentiment la réponse du serveur … Une fois celle-ci reçu on temporise éventuellement avant de recommencer le procédé.

On ne peut pas faire plus simple … c’est même trop simple pour être vraiment efficace. Prenons pour comparaison une requête légitime faite depuis un navigateur Web sur le même site

GET / HTTP/1.1
Host: site-cible.com
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

Cela n’a rien à voir … Il est donc assez aisé de distinguer les requêtes faites par LOIC des requêtes légitimes des utilisateurs (et donc de les filtrer et les tarpiter, voir ici). Ce choix a surement du être fait pour limiter la bande passante nécessaire à l’attaquant pour son attaque mais il permet très facilement de filtrer les attaques faites par LOIC.

Passons maintenant à l’autre classe.

XXPFlooder

Cette classe est un floodeur TCP / UDP générique. La encore le code est extrêmement basique : Ouvrir une connexion sur le port spécifié et le floodder avec une chaine de caractères fournie par l’utilisateur.

Voici le code du flooder TCP (qui est presque le même que celui du floodeur UDP)

socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(RHost);
socket.Blocking = Resp;
try
{
while (IsFlooding)
{

FloodCount++;
socket.Send(buf);
if (Delay > 0) System.Threading.Thread.Sleep(Delay);
}
}
catch { }

Conclusion

LOIC semble avoir été codé rapidement et souffre  d’ailleurs encore de bugs sur son floodeur HTTP comme le montre la capture suivante :

Malgré cela, il est la preuve qu’il est assez trivial de coder une application pour faire des attaques DDOS. Petit élément qui a son importance, il n’est pas nécessaire d’être administrateur de son poste pour utiliser LOIC. Il est donc possible de l’utiliser avec un simple compte utilisateur (qui a dit depuis le bureau ??).

LOIC n’est donc pas une arme fatale mais plutôt un outil très basique dont la vrai force réside dans sa simplicité d’utilisation et la rententissante et très efficace communication dont il a bénéficié lors des récentes attaques contre de très nombreux sites.

50 000 téléchargement en moins de 10 jours, cela représente une force de frappe potentielle de  ~60 Gb/s… Quand même…

Mise à jour du 13/12/2010

La version analysée dans cet article est la dernière version de l’outil original mais ce sont ces dérivés qui sont aujourd’hui diffusés sur Internet. Plusieurs hackers dont NewEraCracker ont amélioré LOIC pour le rendre plus efficace. Nous allons analyser les changements apportés par la version 1.1.1.14 par rapport au code original.

HTTPFlooder

Une option pour envoyer des chaînes aléatoires a été ajoutée pour éviter une détection trop aisée par les systèmes de défense. Le champ HOST a été rajouté aux en-têtes. Une requête donne maintenant :

GET CHAINE_ALEATOIRE HTTP/1.1
Host : site-cible.com

XXPFlooder

Il est également possible d’envoyer des chaînes aléatoires pour le flood TCP/UDP, c’est le seul changement notable sur ce module.

Un canal de contrôle via IRC

La grande nouveauté de cette version est le support d’IRC (Internet Relay Chat). Il est ainsi possible de démarrer LOIC sur un serveur IRC (par exemple celui des Anon : loic.anonops.net) et de le mettre en mode automatique afin qu’il attende des ordres d’attaque. C’est la bibliothèque SmartIrc4net qui a été utilisée pour implémenter les fonctions IRC.

Lors qu’un serveur IRC est spécifié, LOIC va alors tenter de s’y connecter, si la connexion réussie, un nom d’utilisateur est automatiquement généré par le code suivant :

irc.Login("LOIC_" + new Functions().RandomString(), "Newfag's remote LOIC", 0, "IRCLOIC");

 

Selon la documentation du site la fonction appelée est la suivante:

public void Login(
   string nick,
   string realname,
   int usermode,
   string username
);

 

Les paramètres ont la signification suivante:

nick: le pseudo de l’utilisateur
realname: le nom réel de l’utilisateur
usermode: si à 0, l’utilisateur est invisible au sens IRC du terme (mode +i)
username: le nom d’utilisateur de la machine

Ce code génère des pseudos IRC semblables à celui-ci : « LOIC_FSJUEZ ». LOIC_ est la partie fixe et les 6 caractères suivants sont générés aléatoirement. LOIC rejoint par défaut le canal #loic et enregistre tous les administrateurs du canal en repérant les pseudos commençant par « @, & et ~ ».

if (user.StartsWith("@") || user.StartsWith("&") || user.StartsWith("~"))

 

Le programme est alors en attente d’un ordre d’attaque. Afin de lancer une attaque automatisée, il suffit de changer le sujet du canal IRC par un message de ce type :

!lazor targetip=127.0.0.1 message=test_test port=80 method=tcp wait=false random=true start

 

Le programme vérifie alors que c’est bien un administrateur qui a ordonné l’attaque avant de la lancer.

void OnMessage(object sender, IrcEventArgs e)
        {
            if (e.Data.Channel == channel)
            {
                if (e.Data.Message.StartsWith("!lazor "))
                {
                    //authenticate
                    if (OpList != null && OpList.ContainsKey(e.Data.Nick))
                    {
                        List pars = new List(e.Data.Message.Split(' '));
                        SetStatus("Controlled by "+e.Data.Nick);
                        try
                        {
                            txtTargetIP.Invoke(new CheckParamsDelegate(CheckParams), pars);
                        }
                        catch
                        { }
                    }
                    else
                    {
                        //disregard, he sucks cocks
                        //irc.RfcPrivmsg(e.Data.Channel, "I'm gonna disregard that, you suck cocks");
                    }
                }
            }
        }

 

Afin de stopper une attaque, il suffit de mettre la phrase suivante en sujet du canal :

!lazor stop

 

Ce moyen de contrôle quoique rustique n’en est pas moins très efficace. Les attaques ne sont lancées par l’administrateur que quand une certaine masse critique d’utilisateurs est atteinte comme le prouve le message ci-dessous posté sur le site 4chan.org.

 

 

Un mode furtif

Je terminerai l’étude de cette nouvelle version en abordant la possibilité qui permet de lancer LOIC en mode furtif. Via la commande suivante :

LOIC.exe /hidden /hivemind irc.server.address

Le programme se lance alors sans fenêtre et n’apparait pas dans la barre des tâches. On peut ainsi imaginer lancer des instances de LOIC depuis des ordinateurs publics en libre accès par exemple.

Conclusion sur la version 1.1.1.14

Cette nouvelle version de LOIC permet de coordonner très efficacement des attaques de déni de service via un serveur de contrôle centralisé.  Même si le serveur loic.anonops.net était fermé, un autre serveur prendrait immédiatement la relève ce qui rend le programme résistant aux éventuelles fermetures de serveur. Du point de vue technique, les attaques DDOS ont été un peu améliorées notamment via l’ajout d’un générateur aléatoire mais elles restent très basiques. On peut s’attendre à ce que les versions futures soient de plus en plus sophistiquées et donc de plus en plus dures à contrer.

Mise à jour du 26/01/2012

Les récents événements liés à la fermeture de Megaupload par le Département de la Justice des États-Unis d’Amérique ont relancé les vagues d’attaques LOIC. Avec l’opération #OpMegaupload, les anonymous ont ciblé plusieurs sites dont universalmusic.com, le site de la RIAA américaine ou encore le site de l’Hadopi.

Si l’outil LOIC n’a pas changé de mode de fonctionnement depuis les attaques de décembre 2010, de nouvelles versions sont apparues. La dernière est date est une version codée en JavaScript qui permet de participer à une attaque DDOS via son navigateur Internet.

Analyse de la version JavaScript de LOIC

Le code source de la version JavaScript est embarqué dans une page HTML d’environ 200 lignes de code. Une fois chargée dans un navigateur, la page offre le rendu suivant.

Interface LOIC JavaScript

 

Le but de la version JavaScript semble être la simplicité d’utilisation. En effet, il n’est possible de choisir la cible de l’attaque que parmi une liste de cibles prédéfinies. Dans la version analysée, les cibles étaient:

http://www.justice.gov
http://copyright.gov
http://universalmusic.com
http://riaa.org
http://mpaa.org
http://usdoj.gov
http://fbi.gov
http://whitehouse.gov

Il est bien sur possible d’ajouter n’importe quelle cible moyennant une modification très facile du code source de la page. Il est également possible de modifier la fréquence de l’attaque ainsi que le message qui sera envoyé au serveur attaqué.

Cette version ne possède donc pas de mode d’attaque par flood TCP ou UDP et se contente de l’attaque par flood HTTP. Il n’y a également pas de connexion avec un quelconque serveur IRC afin de recevoir des cibles et de synchroniser les attaques. On est donc dans un schéma de fonctionnement très simple ou l’utilisateur définie la cible et lance l’attaque en cliquant sur le bouton « IMMA CHARGING MAH LAZER »

Analysons maintenant un peu plus en détail le code JavaScript chargé de lancer l’attaque.

Le code JavaScript lié à l’attaque ne fait que 80 lignes de code et est relativement trivial.

Lors de l’appui sur le bouton, le script récupère la cible ainsi que la vitesse d’attaque et le message à envoyer.

fireButton.onclick = function () {
                    if (isFiring) {
                        clearInterval(fireInterval);

                        isFiring = false;
                        this.innerHTML = "IMMA CHARGING MAH LAZER";
                    } else {
                        isFiring = true;
                        this.innerHTML = "Stop flooding";

                        fireInterval = setInterval(makeHttpRequest, (2500 / parseInt(rpsNode.value) | 0));
                    }
                };

La ligne de code intéressante est: fireInterval = setInterval(makeHttpRequest, (2500 / parseInt(rpsNode.value) | 0));

La fonction JavaScript setInterval permet d’appeler une fonction à un intervalle régulier. Ici, la fonction appelée est makeHttpRequest et l’intervalle en millisecondes défini par l’opération 2500/(valeur fournie par le formulaire). La valeur par défaut donne donc (2500/100) soit 40 requêtes par seconde.

Intéressons nous maintenant à la fonction makeHttpRequest

var makeHttpRequest = function () {

                                            if (requestedCtr > failedCtr + succeededCtr + 1000) { //Allow no more than 1000 hung requests
                                                    return;
                                            };

                        var rID =Number(new Date());
                        var img = new Image();
                        img.onerror = function () { onFail(rID); };
                        img.onabort = function () { onFail(rID); };
                        img.onload = function () { onSuccess(rID); }; // TODO: it may never happen if target URL is not an image... // but probably can be fixed with different methods

                                            img.setAttribute("src", targetURL + "?id=" + rID + "&msg=" + messageNode.value);
                        requestsHT[rID] = img;
                        onRequest(rID);
                    };

La fonction commence par vérifier le nombre de requêtes en attente de réponse. Si il y a plus de 1000 requêtes en attente de réponse, aucune nouvelle requête n’est émise. Il s’agit sûrement d’une mesure qui vise à éviter que l’attaquant mette hors service son propre navigateur en lançant un trop grand nombre de requêtes. Puis un identifiant numérique rID est obtenu en récupérant des informations sur la date et l’heure du système. Cette valeur changeant toutes les millisecondes elle va servir d’identifiant unique pour chaque requête émise.

La charge utile de l’attaque est triviale car elle consiste à aller demander au navigateur d’aller charger une image dont l’URL est « adresse-du-site-attaqué.com?id=identifiant-unique-de-la-requête&msg=message-personalisé ». Les fonctions d’erreur de chargement et de succès ont étés surchargées afin de pouvoir incrémenter le compteur de requêtes réussies et de considérer que la requête à reçu une réponse. Ici une erreur est considérée comme un succès car nous requêtons une image sur une URL qui a de forte chance de ne pas renvoyer une image comme attendu et qui va donc provoquer une erreur.

Voici le type de requête HTTP produite par l’attaque:

Capture réseau DDOS JavaScript LOIC
Capture réseau d’une attaque DDOS via la version JavaScript de LOIC

Conclusion sur le nouveau L.O.I.C

Cette nouvelle version de LOIC n’apporte rien de nouveau et est même une régression en termes de fonctionnalités par rapport aux versions lourdes de LOIC.  En revanche, elle offre un moyen simple de participer à des attaques DDOS via son navigateur Internet. Le JavaScript étant exécuté automatiquement à l’ouverture d’une page par la majorité des navigateurs, il serait même envisageable de mener ce genre d’attaques à l’insu de l’utilisateur via l’inclusion de ce genre de code sur des sites tiers.

Un utilisateur pourrait donc participer sans le savoir à un DDOS ou alors feindre d’y avoir participé sans le savoir.

 

Laisser un commentaire