Un bogue dans le code source de Mirai pourrait permettre de mettre fin aux attaques par inondation HTTP
Première piste de défense active

Le , par Stéphane le calme, Chroniqueur Actualités
Il y a quelques semaines, le code source de Mirai a été publié. Depuis, les attaques s’appuyant sur le logiciel malveillant, capable de créer des réseaux de zombies d’objets connectés pour lancer des attaques DDoS, se sont multipliées. Certaines ont été couronnée de succès, comme l’attaque qui a frappé Dyn, un fournisseur de service DNS, qui a entraîné la perturbation de l’accès à de nombreux sites internet populaires en termes de trafic pendant des heures (PayPal, Twitter, GitHub, Netflix, Spotify, pour ne citer que ceux-là).

Le weekend dernier, Scott Tenaglia, le directeur de la recherche chez Invincea, a expliqué que le laboratoire s’est lancé dans l’étude de ce logiciel malveillant pour en exposer les failles : « les attaquants exploitent souvent de failles dans les logiciels pour installer leurs outils sur les systèmes. Lorsque ces outils sont sur des dispositifs IdO, les choses deviennent plus compliquées parce que les attaquants ont accès à plus de dispositifs que nous. Alors pourquoi ne pas utiliser leur propre stratégie contre eux ? ». « C’est la première d’une série de publications qui va exposer les vulnérabilités de Mirai et montrer comment s’en servir pour stopper les attaques », a-t-il promis.

Pour commencer, il estime qu’il est important de comprendre comment Mirai initialise une attaque afin de comprendre les implications de l'exploitation des vulnérabilités dans le code d'attaque. Ci-dessous le code de la fonction attack_start() telle qu’écrite dans bot/attack.c :

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
void attack_start(int duration, ATTACK_VECTOR vector, uint8_t targs_len, struct attack_target *targs, uint8_t opts_len, struct attack_option *opts) 
  { 
      int pid1, pid2; 
  
      pid1 = fork(); 
      if (pid1 == -1 || pid1 > 0) 
          return; 
  
      pid2 = fork(); 
      if (pid2 == -1) 
         exit(0); 
     else if (pid2 == 0) 
     { 
         sleep(duration); 
         kill(getppid(), 9); 
         exit(0); 
     } 
     else 
     { 
         int i; 
  
         for (i = 0; i < methods_len; i++) 
         { 
             if (methods[i]->vector == vector) 
             { 
 #ifdef DEBUG 
                 printf("[attack] Starting attack...\n"); 
 #endif 
                 methods[i]->func(targs_len, targs, opts_len, opts); 
                 break; 
             } 
         } 
  
         //just bail if the function returns 
         exit(0); 
     } 
 }

Les lignes 5 à 7 font un fork d’un processus enfant qui sera responsable de l'attaque. Les lignes 9 à 16 font un fork d’un autre processus enfant qui va arrêter l'attaque après la durée spécifiée, simplement en la mettant en sommeil sur cette durée puis en terminant le processus parent lorsqu’il tente de s’exécuter à nouveau. Enfin, le processus d'attaque appelle le gestionnaire de fonction correcte pour l'attaque spécifiée (lignes 22 à 32), puis effectue un exit (ligne 35). Cela signifie que si le processus d'attaque se bloque, alors l'attaque s'arrêtera mais le bot lui-même restera fonctionnel.

Par la suite le chercheur indique avoir trouvé une vulnérabilité stack buffer overflow dans le code de l’attaque par inondation HTTP. Lorsque cette vulnérabilité est exploitée, elle va provoquer un « signal de violation de segmentation » (SIGSEGV, un signal envoyé à un processus lorsque celui-ci fait référence à une zone de mémoire invalide, par exemple parce qu'elle ne lui appartient pas. Une interruption est alors déclenchée et interrompt le programme). Le SIGSEGV va donc interrompre le processus et par conséquent arrêter l’attaque du bot. « La vulnérabilité du code est tributaire de la façon dont Mirai traite l'emplacement en-tête HTTP qui peut faire partie de la réponse HTTP envoyée depuis une requête d’inondation HTTP », explique-t-il. Elle réside dans la fonction attack_app_http () du bot / attack_app.c, et se présente comme suit :

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int offset = util_stristr(generic_memes, ret, table_retrieve_val(TABLE_ATK_LOCATION_HDR, NULL)); 
  if (generic_memes[offset] == ' ') 
      offset++; 
  
  int nl_off = util_memsearch(generic_memes + offset, ret - offset, "\r\n", 2); 
  if (nl_off != -1) 
  { 
      char *loc_ptr = &(generic_memes[offset]); 
  
     if (nl_off >= 2) 
         nl_off -= 2; 
     generic_memes[offset + nl_off] = 0; 
  
     //increment it one so that it is length of the string excluding null char instead of 0-based offset 
     nl_off++; 
  
     if (util_memsearch(loc_ptr, nl_off, "http", 4) == 4) 
     { 
         //this is an absolute url, domain name change maybe? 
         ii = 7; 
         //http(s) 
         if (loc_ptr[4] == 's') 
             ii++; 
  
        memmove(loc_ptr, loc_ptr + ii, nl_off - ii);

Pour commencer, supposons que l’en-tête de l’emplacement est quelque chose de simple comme http://google.com\r\n.

Les lignes 1 à 3 du code ci-dessus cherchent l’emplacement de l'en-tête de l'emplacement et mette l’indice du début d l’URL (notamment le caractère “h”) dans la variable offset. Ensuite, les lignes 5 à 15 s’occupent de mettre l’index “\ r \ n” qui termine l’URL dans la variable nl_off. Tenagila précise qu’il est important de noter qu’il s’agit d’un index de base zéro (une façon de numérotage qui voudrait que le premier élément d’une séquence soit associé à “0” au lieu de “1”. L’élément initial dans ce cas est donc appelé “élément zéro” au lieu de “premier élément”) de l’URL et PAS du début de l’emplacement de l’en-tête ou du buffer generic_memes.

Dans la ligne 25, l’appel de memmove tente d’enlever le "http: //" de l'URL en déplaçant simplement ce qui vient après vers la gauche de 7 caractères. C’est la raison pour laquelle la variable ii est fixée à 7 sur la ligne 20. Dans le cas que nous étudions, nl_off vaut 18, ce qui signifie que le paramètre len de memmove est 11 (nl_off - ii, soit 18 - 7).

Code C : Sélectionner tout
memmove(loc_ptr, loc_ptr + 7, 11);

Ce qui contribue à déplacer “google.com” (une chaîne de 10 caractères plus un caractère de fin de chaîne) vers la gauche de 7 caractères. Cependant, si l’entête de location était http\r\n. Alors nl_off vaut 5, ce qui signifie que le paramètre lenvaut -2 (nl_off - ii, soit 5 - 7). Étant donné que le paramètre len est traité comme un entier non signé (à savoir de type size_t), alors -2 sera traité comme un entier positif très large, 0xFFFFFFFE. Par conséquent, memmove va inonder le buffer generic_memes et corrompre une bonne partie de la mémoire.

Pour vérifier leur supposition, les chercheurs se sont servi de trois machines virtuelles où Mirai a été déployé et le programme a effectivement reçu un SIGSEGV comme le montre le montre la capture d’écran ci-dessous.


« Ce simple “exploit” est un exemple de défense active contre un botnet IdO pouvant être utilisé par tout service d’atténuation d’attaque DDoS pour se défendre contre une attaque Mirai par inondation HTTP en temps réel », a conclu Tenaglia. Il prévient toutefois que « bien qu’il ne peut pas être utilisé pour enlever le bot d’un dispositif IdO, il peut être utilisé pour stopper l’attaque en provenance de ce dispositif ».

Il regrette néanmoins que cet exploit ne soit spécifique qu’aux attaques par inondation HTTP et n’aurait donc pas pu servir à défendre Dyn. Quoiqu’il en soit, d’autres publications dans ce sens sont attendues.

Mirai est l’une des plus dangereuses familles de botnets avec plus de 791 000 zombies à sa disposition et uniquement sur le port 23 d’après des statistiques de Qihoo 360.


Source : blog Invincea, Qihoo 360


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster une réponse

Avatar de marsupial marsupial - Membre chevronné https://www.developpez.com
le 31/10/2016 à 12:01
De mon point de vue, si je mets la sécurité cela les rend invulnérable.

Bon, il va falloir isoler et nettoyer relativement vite. Avant de blinder.
Avatar de BufferBob BufferBob - Expert éminent https://www.developpez.com
le 31/10/2016 à 12:07
donc en clair on a un chercheur en sécurité qui a trouvé -ô exploit- un overflow dans le code moisi d'un botnet, autant dire qu'il bosse dur
et avec cette vuln on peut désormais stopper le botnet... ou en prendre le contrôle pour avoir un botnet encore plus grand, tout dépend qui arrive en premier sur la machine avec son sploit
Avatar de codec_abc codec_abc - Membre averti https://www.developpez.com
le 31/10/2016 à 12:40
Est-ce vraiment utile ? Parce que l'information a été rendu publique. Il suffit pour les pirates de recompiler le code avec le bug fix. Et donc cette méthode de défense active tombe à l'eau...
Avatar de marsupial marsupial - Membre chevronné https://www.developpez.com
le 31/10/2016 à 22:18
Citation Envoyé par chrtophe Voir le message
Les objets connectés sont un vrai problème. Comment voulez-vous que le quidam gère la sécurité sur un téléviseur, un frigo, le jouet du gosse ? etc.
Une appli sur smartphone en 'boucle locale' ?
Avatar de BufferBob BufferBob - Expert éminent https://www.developpez.com
le 01/11/2016 à 11:52
Citation Envoyé par marsupial Voir le message
Une appli sur smartphone en 'boucle locale' ?
la boucle locale c'est ce qu'on appelle en anglais le "loopback", et par définition ça ne sort pas de la carte réseau, peu de chances d'atteindre le micro-onde donc

je pense que chrtophe devait plus probablement faire référence au fait que le quidam n'y connait rien à la sécurité, donc même si on lui donne une interface c'est pas ce qui lui donnera les bons réflexes à avoir ou changera ses habitudes
Avatar de SushiGreGs SushiGreGs - Membre à l'essai https://www.developpez.com
le 01/11/2016 à 13:21
C'est vraiment trop génial voir le code source d'un bot. Comme quoi ces des programmeurs comme nous, ils se mettent des commentaires, écrivent du code selon leur style, tout comme nous
Avatar de Iradrille Iradrille - Expert confirmé https://www.developpez.com
le 01/11/2016 à 13:56
Citation Envoyé par codec_abc Voir le message
Est-ce vraiment utile ? Parce que l'information a été rendu publique. Il suffit pour les pirates de recompiler le code avec le bug fix. Et donc cette méthode de défense active tombe à l'eau...
Cette faille est coté client, pour la corriger, il faut mettre à jour les ~800k machines infectées. C'est pas simple, surtout si le truc n'a pas été pensé pour permettre les mises à jour.
Il n'y a par contre aucun doute que le bug est corrigé, pour les prochaines victimes.
Avatar de marsupial marsupial - Membre chevronné https://www.developpez.com
le 02/11/2016 à 4:22
Bouble locale radio évidemment, pas le loopback

Parce-que le bluetooth bonjour la passoire
Avatar de Michael Guilloux Michael Guilloux - Chroniqueur Actualités https://www.developpez.com
le 02/11/2016 à 11:39
Linux/IRCTelnet, un nouveau malware pour succéder à Mirai
qui pourrait avoir infecté environ 3500 appareils connectés en cinq jours

La récente vague d’attaques DDoS lancées contre les services du fournisseur DNS Dyn a montré que les objets connectés peuvent être utilisés pour mettre en mal le réseau internet mondial. Avec la prolifération de ces dispositifs connectés, c’est une armée potentielle de bots qui se déploie sur la toile. Et depuis que le code source de Mirai a été rendu public, il semble que les pirates ont tout ce qu’il faut pour lancer des attaques DDoS de grande ampleur.

Sur le site Malware Must Die, des chercheurs en sécurité ont publié un rapport sur un nouveau malware capable de créer des botnets d’objets connectés en s’attaquant aux périphériques IoT (routeurs, systèmes d'éclairage intelligents, caméras de surveillance, etc.) qui utilisent des informations d'identification par défaut ou codées en dur. Pour être plus sophistiqué, ce nouveau malware exploite les codes source de différents autres botnets IoT.

Baptisé Linux/IRCTelnet, le nouveau malware est d’abord basé sur le code source du botnet Aidra. Aidra est l’un des premiers botnets d’objets connectés connus qui, dans le passé, a infecté des périphériques connectés à Internet, y compris des systèmes embarqués, pour effectuer des attaques DDoS. Linux/IRCTelnet utilise également la fonction de scanner Telnet d'un autre bot d’objets connectés connu sous le nom de Bashlight. Et pour détourner les appareils connectés à internet, il utilise les combinaisons de mots de passe et nom utilisateur fournies dans le code source de Mirai, le malware qui a été utilisé dans l’attaque contre Dyn.

« Le malware (le client bot) est conçu pour viser le périphérique IoT via le protocole Telnet », indiquent les chercheurs. Ils affirment également que le botnet utilise différents mécanismes d’attaques comme les inondations UDP (User Datagram Protocol) qui consistent à envoyer un grand nombre de paquets UDP depuis des adresses source usurpées à des ports aléatoires sur un hôte ciblé. Il peut employer bien d’autres méthodes d'attaque, à la fois à travers les protocoles IPv4 et IPv6.

D’après les chercheurs, il pourrait avoir infecté 3500 appareils connectés en seulement 5 jours. Il faut toutefois noter que comme la plupart des bots IoT, Linux/IRCTelnet n'est pas persistant. En d’autres termes, un simple redémarrage pourrait permettre d’effacer le malware sur les appareils infectés. Mais, c’est une solution éphémère puisqu’ils pourront être infectés à nouveau. En effet, une fois qu'un périphérique est infecté, son adresse IP est stockée afin que l’attaquant puisse le réinfecter s'il perd le contact avec le canal de commande et de contrôle. Il faudrait donc prendre des mesures plus efficaces qu’un simple redémarrage, en commençant par exemple par un changement des identifiants de connexion.

Linux/IRCTelnet pourrait être le début d’une nouvelle génération de malwares qui pourraient transformer l’internet des objets en internet des menaces, surtout avec la prolifération des appareils connectés à internet qui par défaut sont sans défense contre ces menaces.

Source : Malware Must Die

Et vous ?

Qu’en pensez-vous ?

Voir aussi :

Un bogue dans le code source de Mirai pourrait permettre de mettre fin aux attaques par inondation http, première piste de défense active
Le malware Mirai, qui peut créer des botnets d'objets connectés, utilise des gateway Sierra Wireless, qui exhorte à changer les MdP par défaut
Le code source du malware Mirai, qui est responsable de l'attaque DDoS de 620 Gbps lancée contre Krebs, a été publié en ligne
Avatar de Iradrille Iradrille - Expert confirmé https://www.developpez.com
le 02/11/2016 à 19:43
C'est plutôt cool ces attaques quand même.

Cette mode de tout connecter et de ne rien sécuriser est dangereuse (sans même parler du coté collecte de données).
Ces attaques arrivent au bon moment pour faire prendre conscience au gens qu'ils jouent avec le feu et que les industriels les prennent pour des cons en leur vendant de la merde.

Pour l'instant rien de méchant (en espérant que ça dure...); mais ça fait de la prévention.
Contacter le responsable de la rubrique Accueil