Baboon's Blog

BaDu

BaDu est basé sur un code que j'avais écrit il y a longtemps et que j'ai remanié pour l'occasion. Il se base sur le PE Header de l'executable en dur, ou en mémoire.

Le principe du dumper est simple :

1. Récupération du PE Header à partir de l'exe en dur (GetModuleFileNameA + CreateFileA) ou en mémoire
2. Récupération de la taille de l'exe en mémoire, création d'une page mémoire de même taille
3. Copie de l'intégralité de l'exe en mémoire dans cette page, remplacement du PE en mémoire par le PE en dur si le flag GetPEFromDisk est set
4. Recherche de la taille du PE Header et des sections à partir de la taille en mémoire décrémentée tant que le byte section[taille] == 0, alignement de la taille sur FileAlignement mis à 0x200
5. Modification du PE Header (IT, Entry Point ...)
6. Copie sur le disque

voila le code :

// récupère une copie de l'executable en mémoire
char* getPreDump(char* ImageBase, BOOL GetPEFromDisk)
{
    char modulePath[MAX_PATH+1];
    HANDLE hFile;
    DWORD AllocSize = 0;
    char* Dump;
    PIMAGE_DOS_HEADER pDosHeader;
    PIMAGE_NT_HEADERS pPE;
    PIMAGE_SECTION_HEADER pSectionHeaders;
    DWORD SectionHeadersSize,NumberOfBytesRead;
    IMAGE_DOS_HEADER DosHeader;
    IMAGE_NT_HEADERS PE;
    int len;
 
    if (GetPEFromDisk)
    {
        pDosHeader = &DosHeader;
        pPE = &PE;
        // on récupère le nom du fichier
        if (((len = GetModuleFileNameA((HMODULE) ImageBase, modulePath, MAX_PATH + 1)) >= MAX_PATH) || (!len))
            return NULL;
        // on récupère le PE Header depuis le disque
        if ((hFile = CreateFileA(modulePath,(GENERIC_READ),FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL)) == INVALID_HANDLE_VALUE)
            return NULL;
 
        SetFilePointer(hFile,0,0,FILE_BEGIN);
        ReadFile(hFile,&DosHeader,sizeof(IMAGE_DOS_HEADER),&NumberOfBytesRead,NULL);
        if (NumberOfBytesRead != sizeof(IMAGE_DOS_HEADER))
            return NULL;
 
        SetFilePointer(hFile,DosHeader.e_lfanew,0,FILE_BEGIN);
        ReadFile(hFile,&PE,sizeof(IMAGE_NT_HEADERS),&NumberOfBytesRead,NULL);
        if (NumberOfBytesRead != sizeof(IMAGE_NT_HEADERS))
            return NULL;
 
        SectionHeadersSize = sizeof(IMAGE_NT_HEADERS)*PE.FileHeader.NumberOfSections;
        pSectionHeaders = (PIMAGE_SECTION_HEADER)malloc(SectionHeadersSize);
 
        SetFilePointer(hFile,DosHeader.e_lfanew + sizeof(IMAGE_FILE_HEADER) + PE.FileHeader.SizeOfOptionalHeader + sizeof(DWORD),0,FILE_BEGIN);
        ReadFile(hFile,pSectionHeaders,SectionHeadersSize,&NumberOfBytesRead,NULL);
        if (NumberOfBytesRead != SectionHeadersSize)
        {
            free(pSectionHeaders);
            return NULL;
        }
    }
    else
    {
        pDosHeader = (PIMAGE_DOS_HEADER)&ImageBase;
        pPE = (PIMAGE_NT_HEADERS)(ImageBase + pDosHeader->e_lfanew);
        pSectionHeaders = (PIMAGE_SECTION_HEADER)(ImageBase + pDosHeader->e_lfanew + sizeof(IMAGE_FILE_HEADER) + pPE->FileHeader.SizeOfOptionalHeader + sizeof(DWORD));
    }
 
    AllocSize = pSectionHeaders[PE.FileHeader.NumberOfSections-1].VirtualAddress + pSectionHeaders[PE.FileHeader.NumberOfSections-1].Misc.VirtualSize;
 
    Dump = (char *)VirtualAlloc(NULL,AllocSize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
    if (! Dump)
        return NULL;
 
    CopyMemory(Dump, ImageBase,AllocSize);
    if (GetPEFromDisk)
    {
        CopyMemory(Dump, &DosHeader, sizeof(IMAGE_DOS_HEADER));
        CopyMemory(Dump+DosHeader.e_lfanew, &PE, sizeof(IMAGE_NT_HEADERS));
        CopyMemory(Dump+DosHeader.e_lfanew + sizeof(IMAGE_FILE_HEADER) + PE.FileHeader.SizeOfOptionalHeader + sizeof(DWORD), pSectionHeaders, SectionHeadersSize);
 
        free(pSectionHeaders);
    }
 
    return Dump;
}
 
DWORD AlignSize(DWORD size, DWORD alignement)
{
    return (size%alignement == 0) ? size : ((size / alignement) +1)*alignement;
}
 
BOOL Dump(char* ImageBase, DWORD ITRVA, DWORD ITLen, DWORD EntryPoint, BOOL GetPEFromDisk)
{
    PIMAGE_DOS_HEADER pDosHeader;
    PIMAGE_NT_HEADERS pPE;
    PIMAGE_SECTION_HEADER pSection;
    DWORD NbByteWritten;
    DWORD curseur,i;
    char* Dump;
    char modulePath[MAX_PATH+8];
    int len;
    HANDLE hFile;
 
    // on récupère le nom du fichier
    if (((len = GetModuleFileNameA((HMODULE) ImageBase, modulePath, MAX_PATH + 1)) >= MAX_PATH) || (!len))
        return FALSE;
 
    Dump = getPreDump(ImageBase, GetPEFromDisk);
    if (! Dump)
        return FALSE;
 
    pDosHeader = (PIMAGE_DOS_HEADER)Dump;
    pPE = (PIMAGE_NT_HEADERS)(Dump+pDosHeader->e_lfanew);
    pSection = (PIMAGE_SECTION_HEADER)((PCHAR)pPE + sizeof(IMAGE_FILE_HEADER) + pPE->FileHeader.SizeOfOptionalHeader + sizeof(DWORD));
 
    pPE->OptionalHeader.FileAlignment = 0x200;
    for (curseur = AlignSize(pPE->OptionalHeader.SizeOfHeaders, pPE->OptionalHeader.FileAlignment)-1; ! Dump[curseur]; curseur --);
 
    curseur = AlignSize(curseur+1, pPE->OptionalHeader.FileAlignment);
    pPE->OptionalHeader.SizeOfHeaders = curseur;
    //on copie maintenant les sections
    for (i = 0; i < pPE->FileHeader.NumberOfSections; i++)
    {
        CopyMemory(Dump+curseur,Dump+pSection[i].VirtualAddress,pSection[i].Misc.VirtualSize);
        pSection[i].PointerToRawData = curseur;
        curseur += pSection[i].Misc.VirtualSize-1;
        while((Dump[curseur] == 0) && (((int)curseur) >= -1))
            curseur --;
        curseur = AlignSize(curseur+1,pPE->OptionalHeader.FileAlignment);
        pSection[i].SizeOfRawData = curseur - pSection[i].PointerToRawData;
    }
 
    pPE->OptionalHeader.DataDirectory[1].VirtualAddress = ITRVA;
    pPE->OptionalHeader.DataDirectory[1].Size = ITLen;
    pPE->OptionalHeader.AddressOfEntryPoint = EntryPoint;
 
 
    modulePath[len-4] = '-';
    modulePath[len-3] = 'd';
    modulePath[len-2] = 'u';
    modulePath[len-1] = 'm';
    modulePath[len] = 'p';
    modulePath[len+1] = 'e';
    modulePath[len+2] = 'd';
    modulePath[len+3] = '.';
    modulePath[len+4] = 'e';
    modulePath[len+5] = 'x';
    modulePath[len+6] = 'e';
    modulePath[len+7] = 0;
 
    if ((hFile = CreateFileA(modulePath,(GENERIC_READ | GENERIC_WRITE),FILE_SHARE_READ | FILE_SHARE_READ,NULL,CREATE_ALWAYS,0,NULL)) == INVALID_HANDLE_VALUE)
        return FALSE;
 
    WriteFile(hFile,Dump,curseur,&NbByteWritten,NULL);
    if (NbByteWritten != curseur)
        return FALSE;
    return TRUE;
}

Rien de transcendant comme vous pouvez le voir mais ca fait son boulot :P si vous voyez des trucs pas clairs ou des problèmes potentiels n'hésitez pas. Si vous rencontrez des problèmes avec l'utilisation de ce code, n'hésitez pas encore à me le signaler, je n'ai testé ce code qu'avec GetPEFromDisk à TRUE.

BINI

BINI est basé sur une lib que j'avais dev pour StarForce : BANG (Baboon Api Name Getter (on se refait pas ...)) Cette lib parse l'ensemble des modules chargés en mémoire et récupère l'ensemble des fonctions exportées associées aux modules qui les exportent. Cette lib supporte les forward exports et est donc toute indiquée pour faire un ImpRec like.

BINI fonctionne assez simplement elle aussi, on lui passe l'image base du module, l'adresse de l'IAT, sa taille, l'adresse à laquelle on veut que l'IT soit reconstruite et enfin un pointeur sur un DWORD qui contiendra la taille de l'IT. BINI ne permet pas de créer de nouvelle section, elle stocke les noms des APIs, des DLLs ainsi que toute la structure de l'IT dans une section existante. Je sais que ca fait une sacrée limitation mais bon ... je vous fais confiance pour arranger mon code :P

Avant de commencer à reconstruire l'IT, BINI commence par vérifier si l'IT est cohérente et calcule en même temps la taille que va prendre les noms des DLLs, des APIs ainsi que les thunks. Voila le fonctionnement générale de la fonction :

• On récupère le module à partir de la première adresse
  • Pour chaque thunk :
    • Si l'API n'appartient pas au module :
      • on récupère le module de l'API
      • Si l'une des API précédentes n'appartient pas au même module : on retourne faux
      • Sinon on update la valeur du module
    • Si le thunk est nul c'est qu'on passe à un autre module :
      • On ajoute alors la taille du nom du module à la taille de l'ensemble des noms de modules
      • Pour chaque API on ajoute la taille du nom de l'API (si il existe) à la taille de l'ensemble des noms d'APIs
    • Sinon on passe au thunk suivant
    • On incrémente la taille prise par les thunks
• En fin on retourne une liste chainée contenant les informations nécessaires à la reconstruction de l'IT

Cette manière de faire permet de récupérer le module correspondant à un groupe d'API même si il contient des forward exports. voila le code correspondant :

typedef struct _IMPORT_DIRECTORY {
    PDLL module;
    PDWORD start;
    struct _IMPORT_DIRECTORY *next;
} IMPORT_DIRECTORY, *PIMPORT_DIRECTORY;
 
void FreeImportDirectories(PIMPORT_DIRECTORY importDirectories)
{
    PIMPORT_DIRECTORY c;
    PIMPORT_DIRECTORY d;
 
    for (c = importDirectories; c; c = d)
    {
        d = c->next;
        free(c);
    }
}
 
PIMPORT_DIRECTORY CheckIAT(PDWORD start, PDWORD end, PDWORD ModuleNamesLength, PDWORD APINamesLength, PDWORD ThunksLen)
{
    PDWORD thunk;
    PIMPORT_DIRECTORY retval = NULL;
    PIMPORT_DIRECTORY directory = NULL;
    PIMPORT_DIRECTORY prevdirectory;
 
    *ModuleNamesLength = 0;
    *APINamesLength = 0;
    *ThunksLen = 0;
 
    for(thunk = start; thunk <= end; thunk ++)
    {
        if (* thunk)
        {
            PDWORD t;
            prevdirectory = directory;
            directory = (PIMPORT_DIRECTORY)malloc(sizeof(IMPORT_DIRECTORY));
            if (! directory)
            {
                FreeImportDirectories(retval);
                return NULL;
            }
            if (! retval)
                retval = directory;
            if (prevdirectory)
                prevdirectory->next = directory;
 
            directory->module = GetModule(*thunk);
            directory->start = thunk;
            directory->next = NULL;
            if (! directory->module)
            {
                FreeImportDirectories(retval);
                return NULL;
            }
            for(; *thunk; thunk++)
            {
                *ThunksLen += 4;
                if (! GetApi(*thunk, directory->module))
                {
                    directory->module = GetModule(*thunk);
                    if (! directory->module)
                    {
                        FreeImportDirectories(retval);
                        return NULL;
                    }
                    for (t = directory->start; t < thunk; t ++)
                        if (! GetApi(*t, directory->module))
                        {
                            FreeImportDirectories(retval);
                            return NULL;
                        }
                }
            }
            *ThunksLen += 4;
            *ModuleNamesLength += strlen(directory->module->Name) +1;
            for (t = directory->start; *t; t++)
            {
                PAPI api = GetApi(*t,directory->module);
                if (api->Name)
                    *APINamesLength += strlen(api->Name)+3;
            }
        }
    }
    return retval;
}

Une fois cette étape faite, la reconstruction de l'IT est très simple, il suffit de copier les noms des modules un par un ainsi que les noms des APIs et de construire les structures IMAGE_IMPORT_DESCRIPTOR et IMAGE_IMPORT_BY_NAME. encore une fois voici le code correspondant :

DWORD ReconstructImportTable(PBYTE ImageBase, PDWORD IATAddress, DWORD len, PBYTE ITaddress, PDWORD ITLen)
{
    PIMPORT_DIRECTORY directories;
    PIMPORT_DIRECTORY directory;
    DWORD ModuleNamesLength;
    DWORD APINamesLength;
    DWORD ThunksLen;
    char* ModuleName = ITaddress;
    char* APIName;
    PDWORD originalthunk;
    PIMAGE_IMPORT_DESCRIPTOR ImportDescriptor;
 
    *ITLen = 0;
    directories = CheckIAT(IATAddress, IATAddress + (len >> 2), &ModuleNamesLength, &APINamesLength, &ThunksLen);
    if (!directories)
        return 0;
 
    APIName = ModuleName + ModuleNamesLength;
    originalthunk = (PDWORD)(APIName + APINamesLength);
    ImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)(((char*)originalthunk) + ThunksLen);
 
    for (directory = directories; directory; directory = directory->next)
    {
        PDWORD thunk;
        int i = strlen(directory->module->Name)+1;
 
        ImportDescriptor->Name = (DWORD)(ModuleName-ImageBase);
 
        CopyMemory(ModuleName, directory->module->Name, i);
        ModuleName += i;
 
        ImportDescriptor->OriginalFirstThunk = (DWORD)(((PBYTE)originalthunk)-ImageBase);
        ImportDescriptor->TimeDateStamp = 0;
        ImportDescriptor->ForwarderChain = 0;
        ImportDescriptor->FirstThunk = (DWORD)(((PBYTE)directory->start)-ImageBase);
 
        for (thunk = directory->start; *thunk; thunk ++, originalthunk++)
        {
            PAPI api = GetApi(*thunk, directory->module);
 
            if (api->Name)
            {
                int i = strlen(api->Name) +1;
                *(PWORD)APIName = api->Ordinal;
                CopyMemory(APIName+2, api->Name, i);
                *thunk = (DWORD)(APIName - ImageBase);
                *originalthunk = (DWORD)(APIName - ImageBase);
                APIName += i+2;
            }
            else
            {
                *thunk = 0x80000000 | (((DWORD)api->Ordinal) & 0xFFFF);
                *originalthunk = 0x80000000 | (((DWORD)api->Ordinal) & 0xFFFF);
            }
        }
        *originalthunk = 0;
        originalthunk++;
        ImportDescriptor ++;
        *ITLen += sizeof(IMAGE_IMPORT_DESCRIPTOR);
    }
    FreeImportDirectories(directories);
 
    return (DWORD)(ITaddress + ModuleNamesLength + APINamesLength + ThunksLen - ImageBase);
}

L'ensemble des codes ainsi que les libs sont disponibles en annexe. Si vous avez des idées d'améliorations, si vous rencontrez des bugs ou si vous voulez me donner plein de sousous pour que je puisse me payer un conseiller en com qui me trouvera des noms moins foireux : [mon super nick de singe] {at} lyua {point} org