pefixup.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

Include dependency graph for pefixup.c:

Go to the source code of this file.

Classes
struct	_IMAGE_DOS_HEADER
struct	_IMAGE_EXPORT_DIRECTORY
struct	_IMAGE_FILE_HEADER
struct	_IMAGE_DATA_DIRECTORY
struct	_IMAGE_OPTIONAL_HEADER
struct	_IMAGE_NT_HEADERS
struct	_IMAGE_SECTION_HEADER
struct	_export_t

Macros
#define	O_BINARY   0
#define	IMAGE_NUMBEROF_DIRECTORY_ENTRIES   16
#define	IMAGE_SIZEOF_SHORT_NAME   8
#define	IMAGE_DOS_SIGNATURE   0x5A4D
#define	IMAGE_NT_SIGNATURE   0x00004550
#define	IMAGE_SCN_MEM_DISCARDABLE   0x2000000
#define	IMAGE_SCN_MEM_NOT_PAGED   0x8000000
#define	FIELD_OFFSET(t, f)   ((LONG)(LONG_PTR)&(((t*)0)->f))
#define	IMAGE_FIRST_SECTION(h)   ((PIMAGE_SECTION_HEADER) ((unsigned long)h+FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader)+((PIMAGE_NT_HEADERS)(h))->FileHeader.SizeOfOptionalHeader))
#define	IMAGE_DIRECTORY_ENTRY_EXPORT   0

Typedefs
typedef unsigned char	BYTE
typedef unsigned char *	PBYTE
typedef unsigned short	WORD
typedef unsigned int	DWORD
typedef int	LONG
typedef long	LONG_PTR
typedef struct _IMAGE_DOS_HEADER	IMAGE_DOS_HEADER
typedef struct _IMAGE_DOS_HEADER *	PIMAGE_DOS_HEADER
typedef struct _IMAGE_EXPORT_DIRECTORY	IMAGE_EXPORT_DIRECTORY
typedef struct _IMAGE_EXPORT_DIRECTORY *	PIMAGE_EXPORT_DIRECTORY
typedef struct _IMAGE_FILE_HEADER	IMAGE_FILE_HEADER
typedef struct _IMAGE_FILE_HEADER *	PIMAGE_FILE_HEADER
typedef struct _IMAGE_DATA_DIRECTORY	IMAGE_DATA_DIRECTORY
typedef struct _IMAGE_DATA_DIRECTORY *	PIMAGE_DATA_DIRECTORY
typedef struct _IMAGE_OPTIONAL_HEADER	IMAGE_OPTIONAL_HEADER
typedef struct _IMAGE_OPTIONAL_HEADER *	PIMAGE_OPTIONAL_HEADER
typedef struct _IMAGE_NT_HEADERS	IMAGE_NT_HEADERS
typedef struct _IMAGE_NT_HEADERS *	PIMAGE_NT_HEADERS
typedef struct _IMAGE_SECTION_HEADER	IMAGE_SECTION_HEADER
typedef struct _IMAGE_SECTION_HEADER *	PIMAGE_SECTION_HEADER
typedef struct _export_t	export_t

Functions
static WORD	dtohs (WORD in)
static WORD	htods (WORD in)
static DWORD	dtohl (DWORD in)
static DWORD	htodl (DWORD in)
void *	rva_to_ptr (DWORD rva)
int	export_compare_func (const void *a, const void *b)
int	main (int argc, char **argv)

Variables
unsigned char *	buffer
PIMAGE_DOS_HEADER	dos_header
PIMAGE_NT_HEADERS	nt_header

Macro Definition Documentation

FIELD_OFFSET

#define FIELD_OFFSET	(		t,
			f
	)		((LONG)(LONG_PTR)&(((t*)0)->f))

Definition at line 48 of file pefixup.c.

IMAGE_DIRECTORY_ENTRY_EXPORT

#define IMAGE_DIRECTORY_ENTRY_EXPORT   0

Definition at line 50 of file pefixup.c.

IMAGE_DOS_SIGNATURE

#define IMAGE_DOS_SIGNATURE   0x5A4D

Definition at line 44 of file pefixup.c.

IMAGE_FIRST_SECTION

#define IMAGE_FIRST_SECTION

(

h

)

((PIMAGE_SECTION_HEADER) ((unsigned long)h+FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader)+((PIMAGE_NT_HEADERS)(h))->FileHeader.SizeOfOptionalHeader))

Definition at line 49 of file pefixup.c.

IMAGE_NT_SIGNATURE

#define IMAGE_NT_SIGNATURE   0x00004550

Definition at line 45 of file pefixup.c.

IMAGE_NUMBEROF_DIRECTORY_ENTRIES

#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES   16

Definition at line 42 of file pefixup.c.

IMAGE_SCN_MEM_DISCARDABLE

#define IMAGE_SCN_MEM_DISCARDABLE   0x2000000

Definition at line 46 of file pefixup.c.

IMAGE_SCN_MEM_NOT_PAGED

#define IMAGE_SCN_MEM_NOT_PAGED   0x8000000

Definition at line 47 of file pefixup.c.

IMAGE_SIZEOF_SHORT_NAME

#define IMAGE_SIZEOF_SHORT_NAME   8

Definition at line 43 of file pefixup.c.

O_BINARY

#define O_BINARY   0

Definition at line 30 of file pefixup.c.

Typedef Documentation

BYTE

typedef unsigned char BYTE

Definition at line 36 of file pefixup.c.

DWORD

typedef unsigned int DWORD

Definition at line 38 of file pefixup.c.

export_t

typedef struct _export_t export_t

IMAGE_DATA_DIRECTORY

typedef struct _IMAGE_DATA_DIRECTORY IMAGE_DATA_DIRECTORY

IMAGE_DOS_HEADER

typedef struct _IMAGE_DOS_HEADER IMAGE_DOS_HEADER

IMAGE_EXPORT_DIRECTORY

typedef struct _IMAGE_EXPORT_DIRECTORY IMAGE_EXPORT_DIRECTORY

IMAGE_FILE_HEADER

typedef struct _IMAGE_FILE_HEADER IMAGE_FILE_HEADER

IMAGE_NT_HEADERS

typedef struct _IMAGE_NT_HEADERS IMAGE_NT_HEADERS

IMAGE_OPTIONAL_HEADER

typedef struct _IMAGE_OPTIONAL_HEADER IMAGE_OPTIONAL_HEADER

IMAGE_SECTION_HEADER

typedef struct _IMAGE_SECTION_HEADER IMAGE_SECTION_HEADER

LONG

typedef int LONG

Definition at line 39 of file pefixup.c.

LONG_PTR

typedef long LONG_PTR

Definition at line 40 of file pefixup.c.

PBYTE

typedef unsigned char * PBYTE

Definition at line 36 of file pefixup.c.

PIMAGE_DATA_DIRECTORY

typedef struct _IMAGE_DATA_DIRECTORY* PIMAGE_DATA_DIRECTORY

PIMAGE_DOS_HEADER

typedef struct _IMAGE_DOS_HEADER* PIMAGE_DOS_HEADER

PIMAGE_EXPORT_DIRECTORY

typedef struct _IMAGE_EXPORT_DIRECTORY* PIMAGE_EXPORT_DIRECTORY

PIMAGE_FILE_HEADER

typedef struct _IMAGE_FILE_HEADER * PIMAGE_FILE_HEADER

PIMAGE_NT_HEADERS

typedef struct _IMAGE_NT_HEADERS* PIMAGE_NT_HEADERS

PIMAGE_OPTIONAL_HEADER

typedef struct _IMAGE_OPTIONAL_HEADER* PIMAGE_OPTIONAL_HEADER

PIMAGE_SECTION_HEADER

typedef struct _IMAGE_SECTION_HEADER* PIMAGE_SECTION_HEADER

WORD

typedef unsigned short WORD

Definition at line 37 of file pefixup.c.

Function Documentation

dtohl()

static DWORD dtohl ( DWORD  in )

inlinestatic

Definition at line 182 of file pefixup.c.

{
    PBYTE in_ptr = (PBYTE)∈
    return in_ptr[0] | (in_ptr[1] << 8) | (in_ptr[2] << 16) | (in_ptr[3] << 24);
}

Referenced by main(), and rva_to_ptr().

dtohs()

static WORD dtohs ( WORD  in )

inlinestatic

Definition at line 168 of file pefixup.c.

{
    PBYTE in_ptr = (PBYTE)∈
    return in_ptr[0] | (in_ptr[1] << 8);
}

Referenced by main().

export_compare_func()

int export_compare_func	(	const void *	a,
		const void *	b
	)

Definition at line 218 of file pefixup.c.

{
   const export_t *ap = a;
   const export_t *bp = b;
   char *an = rva_to_ptr(ap->name);
   char *bn = rva_to_ptr(bp->name);
   return strcmp(an, bn);
}

Referenced by main().

htodl()

static DWORD htodl ( DWORD  in )

inlinestatic

Definition at line 188 of file pefixup.c.

{
    DWORD out;
    PBYTE out_ptr = (PBYTE)&out;
    out_ptr[0] = in      ; out_ptr[1] = in >> 8;
    out_ptr[2] = in >> 16; out_ptr[3] = in >> 24;
    return out;
}

Referenced by main().

htods()

static WORD htods ( WORD  in )

inlinestatic

Definition at line 174 of file pefixup.c.

{
    WORD out;
    PBYTE out_ptr = (PBYTE)&out;
    out_ptr[0] = in; out_ptr[1] = in >> 8;
    return out;
}

Referenced by main().

main()

int main	(	int argc	,
		char **	argv
	)

Definition at line 227 of file pefixup.c.

{
   int fd_in, fd_out;
   long len;
   char hdrbuf[4] = { }, elfhdr[4] = { '\177', 'E', 'L', 'F' };
   PIMAGE_SECTION_HEADER section_header;
   PIMAGE_DATA_DIRECTORY data_dir;
   unsigned int i;
   unsigned long checksum;
   int fixup_exports = 0;
   int fixup_sections = 0;

   /*
    * Process parameters.
    */

   if (argc < 2)
   {
      printf("Usage: %s <filename> <options>\n"
             "Options:\n"
             " -sections Sets section flags for PE image.\n"
             " -exports Sort the names in export table.\n",
             argv[0]);
      return 1;
   }

   for (i = 2; i < argc; i++)
   {
      if (!strcmp(argv[i], "-sections"))
         fixup_sections = 1;
      else if (!strcmp(argv[i], "-exports"))
         fixup_exports = 1;
      else
         { fprintf(stderr, "Invalid option: %s\n", argv[i]); return 1; }
   }

   /*
    * Nothing to do.
    */
   if (fixup_sections == 0 && fixup_exports == 0)
      return 0;

   /*
    * Read the whole file to memory.
    */

   fd_in = open(argv[1], O_RDONLY | O_BINARY);
   if (fd_in == 0)
   {
      fprintf(stderr, "Can't open input file.\n");
      return 1;
   }

   /*
    * PowerPC ReactOS uses elf, so doesn't need pefixup
    */
   len = read(fd_in, hdrbuf, sizeof(elfhdr));
   if (!memcmp(hdrbuf, elfhdr, sizeof(elfhdr)))
   {
      close(fd_in);
      return 0;
   }

   len = lseek(fd_in, 0, SEEK_END);
   if (len < sizeof(IMAGE_DOS_HEADER))
   {
      close(fd_in);
      fprintf(stderr, "'%s' isn't a PE image (too short)\n", argv[1]);
      return 1;
   }

   /* Lower down we overwrite the byte at len, so here, we need at least
    * one more byte than len.  We'll be guaranteed one or two now. */
   buffer = malloc((len + 2) & ~1);
   if (buffer == NULL)
   {
      close(fd_in);
      fprintf(stderr, "Not enough memory available.\n");
      return 1;
   }

   /* Read the whole input file into a buffer */
   lseek(fd_in, 0, SEEK_SET);
   read(fd_in, buffer, len);
   /* Here is where the block end overwrite was */
   if (len & 1)
      buffer[len] = 0;

   close(fd_in);

   /*
    * Check the headers and save pointers to them.
    */

   dos_header = (PIMAGE_DOS_HEADER)buffer;
   nt_header = (PIMAGE_NT_HEADERS)(buffer + dtohl(dos_header->e_lfanew));

   if (dtohs(dos_header->e_magic) != IMAGE_DOS_SIGNATURE ||
       dtohl(nt_header->Signature) != IMAGE_NT_SIGNATURE)
   {
      fprintf(stderr, "'%s' isn't a PE image (bad headers)\n", argv[1]);
      free(buffer);
      return 1;
   }

   if (fixup_exports)
   {
      /* Sort export directory */
      data_dir = &nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
      if (dtohl(data_dir->Size) != 0)
      {
         PIMAGE_EXPORT_DIRECTORY export_directory;
         DWORD *name_ptr;
         WORD *ordinal_ptr;
         export_t *exports;

         export_directory = (PIMAGE_EXPORT_DIRECTORY)rva_to_ptr(dtohl(data_dir->VirtualAddress));
         if (export_directory != NULL)
         {
            exports = malloc(sizeof(export_t) * dtohl(export_directory->NumberOfNames));
            if (exports == NULL)
            {
               fprintf(stderr, "Not enough memory.\n");
               free(buffer);
               return 1;
            }

            name_ptr = (DWORD *)rva_to_ptr(dtohl(export_directory->AddressOfNames));
            ordinal_ptr = (WORD *)rva_to_ptr(dtohl(export_directory->AddressOfNameOrdinals));

            for (i = 0; i < dtohl(export_directory->NumberOfNames); i++)
            {
               exports[i].name = dtohl(name_ptr[i]);
               exports[i].ordinal = dtohl(ordinal_ptr[i]);
            }

            qsort(exports, dtohl(export_directory->NumberOfNames), sizeof(export_t),
                  export_compare_func);

            for (i = 0; i < dtohl(export_directory->NumberOfNames); i++)
            {
               name_ptr[i] = htodl(exports[i].name);
               ordinal_ptr[i] = htodl(exports[i].ordinal);
            }

            free(exports);
         }
      }
   }

   if (fixup_sections)
   {
      /* Update section flags */
      for (i = 0, section_header = IMAGE_FIRST_SECTION(nt_header);
           i < dtohl(nt_header->FileHeader.NumberOfSections);
           i++, section_header++)
      {
         if (!strcmp((char*)section_header->Name, ".text") ||
             !strcmp((char*)section_header->Name, ".data") ||
             !strcmp((char*)section_header->Name, ".idata") ||
             !strcmp((char*)section_header->Name, ".rdata") ||
             !strcmp((char*)section_header->Name, ".bss"))
         {
            section_header->Characteristics |= htodl(IMAGE_SCN_MEM_NOT_PAGED);
            section_header->Characteristics &= htodl(~IMAGE_SCN_MEM_DISCARDABLE);
         }
         else if (!strcmp((char*)section_header->Name, "INIT"))
         {
            section_header->Characteristics |= htodl(IMAGE_SCN_MEM_DISCARDABLE);
         }
         else if (!strcmp((char*)section_header->Name, "PAGE"))
         {
            section_header->Characteristics |= htodl(IMAGE_SCN_MEM_NOT_PAGED);
         }
      }
   }

   /* Recalculate checksum */
   nt_header->OptionalHeader.CheckSum = 0;
   checksum = 0;
   for (i = 0; i < len; i += 2)
   {
      checksum += *(unsigned short *)(buffer + i);
      checksum = (checksum + (checksum >> 16)) & 0xffff;
   }
   checksum += len;
   nt_header->OptionalHeader.CheckSum = htods(checksum);

   /* Write the output file */
   fd_out = open(argv[1], O_WRONLY | O_BINARY);
   write(fd_out, buffer, len);
   close(fd_out);

   return 0;
}

rva_to_ptr()

void* rva_to_ptr

(

DWORD

rva

)

Definition at line 197 of file pefixup.c.

{
   PIMAGE_SECTION_HEADER section_header;
   unsigned int i;

   for (i = 0, section_header = IMAGE_FIRST_SECTION(nt_header);
        i < dtohl(nt_header->FileHeader.NumberOfSections);
        i++, section_header++)
   {
      if (rva >= dtohl(section_header->VirtualAddress) &&
          rva < dtohl(section_header->VirtualAddress) +
                dtohl(section_header->Misc.VirtualSize))
      {
         return buffer + rva - dtohl(section_header->VirtualAddress) +
                dtohl(section_header->PointerToRawData);
      }
   }

   return NULL;
}

Referenced by export_compare_func(), and main().

Variable Documentation

buffer

unsigned char* buffer

Definition at line 164 of file pefixup.c.

dos_header

PIMAGE_DOS_HEADER dos_header

Definition at line 165 of file pefixup.c.

Referenced by main(), and SOFTPUB_HashPEFile().

nt_header

PIMAGE_NT_HEADERS nt_header

Definition at line 166 of file pefixup.c.

Referenced by create_test_dll(), create_test_dll_sections(), main(), map_image_section(), query_image_section(), rva_to_ptr(), SOFTPUB_HashPEFile(), test_ExitProcess(), test_filenames(), test_Loader(), test_pe_checksum(), test_ResolveDelayLoadedAPI(), and test_section_access().