Esempio n. 1
-1
void
copy_executable_and_dump_data (file_data *p_infile,
                               file_data *p_outfile)
{
    unsigned char *dst, *dst_save;
    PIMAGE_DOS_HEADER dos_header;
    PIMAGE_NT_HEADERS nt_header;
    PIMAGE_NT_HEADERS dst_nt_header;
    PIMAGE_SECTION_HEADER section;
    PIMAGE_SECTION_HEADER dst_section;
    DWORD_PTR offset;
    int i;
    int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;

#define COPY_CHUNK(message, src, size, verbose)					\
  do {										\
    unsigned char *s = (void *)(src);						\
    unsigned long count = (size);						\
    if (verbose)								\
      {										\
	printf ("%s\n", (message));						\
	printf ("\t0x%08x Offset in input file.\n", s - p_infile->file_base); 	\
	printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base); \
	printf ("\t0x%08x Size in bytes.\n", count);				\
      }										\
    memcpy (dst, s, count);							\
    dst += count;								\
  } while (0)

#define COPY_PROC_CHUNK(message, src, size, verbose)				\
  do {										\
    unsigned char *s = (void *)(src);						\
    unsigned long count = (size);						\
    if (verbose)								\
      {										\
	printf ("%s\n", (message));						\
	printf ("\t0x%p Address in process.\n", s);				\
	printf ("\t0x%p Base       output file.\n", p_outfile->file_base); \
	printf ("\t0x%p Offset  in output file.\n", dst - p_outfile->file_base); \
	printf ("\t0x%p Address in output file.\n", dst); \
	printf ("\t0x%p Size in bytes.\n", count);				\
      }										\
    memcpy (dst, s, count);							\
    dst += count;								\
  } while (0)

#define DST_TO_OFFSET()  PTR_TO_OFFSET (dst, p_outfile)
#define ROUND_UP_DST(align) \
  (dst = p_outfile->file_base + ROUND_UP (DST_TO_OFFSET (), (align)))
#define ROUND_UP_DST_AND_ZERO(align)						\
  do {										\
    unsigned char *newdst = p_outfile->file_base				\
      + ROUND_UP (DST_TO_OFFSET (), (align));					\
    /* Zero the alignment slop; it may actually initialize real data.  */	\
    memset (dst, 0, newdst - dst);						\
    dst = newdst;								\
  } while (0)

    /* Copy the source image sequentially, ie. section by section after
       copying the headers and section table, to simplify the process of
       dumping the raw data for the bss and heap sections.

       Note that dst is updated implicitly by each COPY_CHUNK.  */

    dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
    nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
                                     dos_header->e_lfanew);
    section = IMAGE_FIRST_SECTION (nt_header);

    dst = (unsigned char *) p_outfile->file_base;

    COPY_CHUNK ("Copying DOS header...", dos_header,
                (DWORD_PTR) nt_header - (DWORD_PTR) dos_header, be_verbose);
    dst_nt_header = (PIMAGE_NT_HEADERS) dst;
    COPY_CHUNK ("Copying NT header...", nt_header,
                (DWORD_PTR) section - (DWORD_PTR) nt_header, be_verbose);
    dst_section = (PIMAGE_SECTION_HEADER) dst;
    COPY_CHUNK ("Copying section table...", section,
                nt_header->FileHeader.NumberOfSections * sizeof (*section),
                be_verbose);

    /* Align the first section's raw data area, and set the header size
       field accordingly.  */
    ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
    dst_nt_header->OptionalHeader.SizeOfHeaders = DST_TO_OFFSET ();

    for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
    {
        char msg[100];
        /* Windows section names are fixed 8-char strings, only
        zero-terminated if the name is shorter than 8 characters.  */
        sprintf (msg, "Copying raw data for %.8s...", section->Name);

        dst_save = dst;

        /* Update the file-relative offset for this section's raw data (if
           it has any) in case things have been relocated; we will update
           the other offsets below once we know where everything is.  */
        if (dst_section->PointerToRawData)
            dst_section->PointerToRawData = DST_TO_OFFSET ();

        /* Can always copy the original raw data.  */
        COPY_CHUNK
        (msg, OFFSET_TO_PTR (section->PointerToRawData, p_infile),
         section->SizeOfRawData, be_verbose);
        /* Ensure alignment slop is zeroed.  */
        ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);

        /* Note that various sections below may be aliases.  */
        if (section == data_section)
        {
            dst = dst_save
                  + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (data_start), dst_section);
            COPY_PROC_CHUNK ("Dumping initialized data...",
                             data_start, data_size, be_verbose);
            dst = dst_save + dst_section->SizeOfRawData;
        }
        if (section == bss_section)
        {
            /* Dump contents of bss variables, adjusting the section's raw
                   data size as necessary.  */
            dst = dst_save
                  + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (bss_start), dst_section);
            COPY_PROC_CHUNK ("Dumping bss data...", bss_start,
                             bss_size, be_verbose);
            ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
            dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
            /* Determine new size of raw data area.  */
            dst = max (dst, dst_save + dst_section->SizeOfRawData);
            dst_section->SizeOfRawData = dst - dst_save;
            dst_section->Characteristics &= ~IMAGE_SCN_CNT_UNINITIALIZED_DATA;
            dst_section->Characteristics |= IMAGE_SCN_CNT_INITIALIZED_DATA;
        }
        if (section == bss_section_static)
        {
            /* Dump contents of static bss variables, adjusting the
                   section's raw data size as necessary.  */
            dst = dst_save
                  + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (bss_start_static), dst_section);
            COPY_PROC_CHUNK ("Dumping static bss data...", bss_start_static,
                             bss_size_static, be_verbose);
            ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
            dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
            /* Determine new size of raw data area.  */
            dst = max (dst, dst_save + dst_section->SizeOfRawData);
            dst_section->SizeOfRawData = dst - dst_save;
            dst_section->Characteristics &= ~IMAGE_SCN_CNT_UNINITIALIZED_DATA;
            dst_section->Characteristics |= IMAGE_SCN_CNT_INITIALIZED_DATA;
        }

        /* Align the section's raw data area.  */
        ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);

        section++;
        dst_section++;
    }

    /* Copy remainder of source image.  */
    do
        section--;
    while (section->PointerToRawData == 0);
    offset = ROUND_UP (section->PointerToRawData + section->SizeOfRawData,
                       nt_header->OptionalHeader.FileAlignment);
    COPY_CHUNK
    ("Copying remainder of executable...",
     OFFSET_TO_PTR (offset, p_infile),
     p_infile->size - offset, be_verbose);

    /* Final size for new image.  */
    p_outfile->size = DST_TO_OFFSET ();

    /* Now patch up remaining file-relative offsets.  */
    section = IMAGE_FIRST_SECTION (nt_header);
    dst_section = IMAGE_FIRST_SECTION (dst_nt_header);

#define ADJUST_OFFSET(var)						\
  do {									\
    if ((var) != 0)							\
      (var) = relocate_offset ((var), nt_header, dst_nt_header);	\
  } while (0)

    dst_nt_header->OptionalHeader.SizeOfInitializedData = 0;
    dst_nt_header->OptionalHeader.SizeOfUninitializedData = 0;
    for (i = 0; i < dst_nt_header->FileHeader.NumberOfSections; i++)
    {
        /* Recompute data sizes for completeness.  */
        if (dst_section[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
            dst_nt_header->OptionalHeader.SizeOfInitializedData +=
                ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
        else if (dst_section[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
            dst_nt_header->OptionalHeader.SizeOfUninitializedData +=
                ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);

        ADJUST_OFFSET (dst_section[i].PointerToLinenumbers);
    }

    ADJUST_OFFSET (dst_nt_header->FileHeader.PointerToSymbolTable);

    /* Update offsets in debug directory entries. */
    {
        IMAGE_DATA_DIRECTORY debug_dir =
            dst_nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
        PIMAGE_DEBUG_DIRECTORY debug_entry;

        section = rva_to_section (debug_dir.VirtualAddress, dst_nt_header);
        if (section)
        {
            debug_entry = (PIMAGE_DEBUG_DIRECTORY)
                          (RVA_TO_OFFSET (debug_dir.VirtualAddress, section) + p_outfile->file_base);
            debug_dir.Size /= sizeof (IMAGE_DEBUG_DIRECTORY);

            for (i = 0; i < debug_dir.Size; i++, debug_entry++)
                ADJUST_OFFSET (debug_entry->PointerToRawData);
        }
    }
}
Esempio n. 2
-1
static void
copy_executable_and_add_section (file_data *p_infile,
				 file_data *p_outfile,
				 const char *new_section_name,
				 DWORD_PTR new_section_size)
{
  unsigned char *dst;
  PIMAGE_DOS_HEADER dos_header;
  PIMAGE_NT_HEADERS nt_header;
  PIMAGE_NT_HEADERS dst_nt_header;
  PIMAGE_SECTION_HEADER section;
  PIMAGE_SECTION_HEADER dst_section;
  DWORD_PTR offset;
  int i;
  int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;

#define COPY_CHUNK(message, src, size, verbose)					\
  do {										\
    unsigned const char *s = (void *)(src);						\
    unsigned long count = (size);						\
    if (verbose)								\
      {										\
	printf ("%s\n", (message));						\
	printf ("\t0x%08x Offset in input file.\n", s - p_infile->file_base); 	\
	printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base); \
	printf ("\t0x%08x Size in bytes.\n", count);				\
      }										\
    memcpy (dst, s, count);							\
    dst += count;								\
  } while (0)

#define DST_TO_OFFSET()  PTR_TO_OFFSET (dst, p_outfile)
#define ROUND_UP_DST_AND_ZERO(align)						\
  do {										\
    unsigned char *newdst = p_outfile->file_base				\
      + ROUND_UP (DST_TO_OFFSET (), (align));					\
    /* Zero the alignment slop; it may actually initialize real data.  */	\
    memset (dst, 0, newdst - dst);						\
    dst = newdst;								\
  } while (0)

  /* Copy the source image sequentially, ie. section by section after
     copying the headers and section table, to simplify the process of
     adding an extra section table entry (which might force the raw
     section data to be relocated).

     Note that dst is updated implicitly by each COPY_CHUNK.  */

  dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
  nt_header = (PIMAGE_NT_HEADERS) (((unsigned char *) dos_header) +
				   dos_header->e_lfanew);
  section = IMAGE_FIRST_SECTION (nt_header);

  dst = (unsigned char *) p_outfile->file_base;

  COPY_CHUNK ("Copying DOS header...", dos_header,
	      (DWORD_PTR) nt_header - (DWORD_PTR) dos_header, be_verbose);
  dst_nt_header = (PIMAGE_NT_HEADERS) dst;
  COPY_CHUNK ("Copying NT header...", nt_header,
	      (DWORD_PTR) section - (DWORD_PTR) nt_header, be_verbose);
  dst_section = (PIMAGE_SECTION_HEADER) dst;
  COPY_CHUNK ("Copying section table...", section,
	      nt_header->FileHeader.NumberOfSections * sizeof (*section),
	      be_verbose);

  /* To improve the efficiency of demand loading, make the file
     alignment match the section alignment (VC++ 6.0 does this by
     default anyway).  */
  dst_nt_header->OptionalHeader.FileAlignment =
    dst_nt_header->OptionalHeader.SectionAlignment;

  /* Add an uninitialized data section at the end, of the specified name
     and virtual size.  */
  if (find_section (new_section_name, nt_header) == NULL)
    /* Leave room for extra section table entry; filled in below.  */
    dst += sizeof (*section);
  else
    new_section_name = NULL;

  /* Align the first section's raw data area, and set the header size
     field accordingly.  */
  ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
  dst_nt_header->OptionalHeader.SizeOfHeaders = DST_TO_OFFSET ();

  for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
    {
      char msg[100];
      /* Windows section names are fixed 8-char strings, only
	 zero-terminated if the name is shorter than 8 characters.  */
      sprintf (msg, "Copying raw data for %.8s...", section->Name);

      /* Update the file-relative offset for this section's raw data (if
         it has any) in case things have been relocated; we will update
         the other offsets below once we know where everything is.  */
      if (dst_section->PointerToRawData)
	dst_section->PointerToRawData = DST_TO_OFFSET ();

      /* Can always copy the original raw data.  */
      COPY_CHUNK
	(msg, OFFSET_TO_PTR (section->PointerToRawData, p_infile),
	 section->SizeOfRawData, be_verbose);

      /* Round up the raw data size to the new alignment.  */
      dst_section->SizeOfRawData =
	ROUND_UP (dst_section->SizeOfRawData,
		  dst_nt_header->OptionalHeader.FileAlignment);

      /* Align the next section's raw data area.  */
      ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);

      section++;
      dst_section++;
    }

  /* Add the extra section entry (which adds no raw data).  */
  if (new_section_name != NULL)
    {
      dst_nt_header->FileHeader.NumberOfSections++;
      dst_nt_header->OptionalHeader.SizeOfImage += new_section_size;
      strncpy (dst_section->Name, new_section_name, sizeof (dst_section->Name));
      dst_section->VirtualAddress =
	section[-1].VirtualAddress
	+ ROUND_UP (section[-1].Misc.VirtualSize,
		    dst_nt_header->OptionalHeader.SectionAlignment);
      dst_section->Misc.VirtualSize = new_section_size;
      dst_section->PointerToRawData = 0;
      dst_section->SizeOfRawData = 0;
      dst_section->Characteristics =
	IMAGE_SCN_CNT_UNINITIALIZED_DATA
	| IMAGE_SCN_MEM_READ
	| IMAGE_SCN_MEM_WRITE;
    }

  /* Copy remainder of source image.  */
  section--;
  offset = ROUND_UP (section->PointerToRawData + section->SizeOfRawData,
		     nt_header->OptionalHeader.FileAlignment);
  COPY_CHUNK
    ("Copying remainder of executable...",
     OFFSET_TO_PTR (offset, p_infile),
     p_infile->size - offset, be_verbose);

  /* Final size for new image.  */
  p_outfile->size = DST_TO_OFFSET ();

  /* Now patch up remaining file-relative offsets.  */
  section = IMAGE_FIRST_SECTION (nt_header);
  dst_section = IMAGE_FIRST_SECTION (dst_nt_header);

#define ADJUST_OFFSET(var)						\
  do {									\
    if ((var) != 0)							\
      (var) = relocate_offset ((var), nt_header, dst_nt_header);	\
  } while (0)

  dst_nt_header->OptionalHeader.SizeOfInitializedData = 0;
  dst_nt_header->OptionalHeader.SizeOfUninitializedData = 0;
  for (i = 0; i < dst_nt_header->FileHeader.NumberOfSections; i++)
    {
      /* Recompute data sizes for completeness.  */
      if (dst_section[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
	dst_nt_header->OptionalHeader.SizeOfInitializedData +=
	  ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
      else if (dst_section[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
	dst_nt_header->OptionalHeader.SizeOfUninitializedData +=
	  ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);

      ADJUST_OFFSET (dst_section[i].PointerToLinenumbers);
    }

  ADJUST_OFFSET (dst_nt_header->FileHeader.PointerToSymbolTable);

  /* Update offsets in debug directory entries. */
  {
    IMAGE_DATA_DIRECTORY debug_dir =
      dst_nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
    PIMAGE_DEBUG_DIRECTORY debug_entry;

    section = rva_to_section (debug_dir.VirtualAddress, dst_nt_header);
    if (section)
      {
	debug_entry = (PIMAGE_DEBUG_DIRECTORY)
	  (RVA_TO_OFFSET (debug_dir.VirtualAddress, section) + p_outfile->file_base);
	debug_dir.Size /= sizeof (IMAGE_DEBUG_DIRECTORY);

	for (i = 0; i < debug_dir.Size; i++, debug_entry++)
	  ADJUST_OFFSET (debug_entry->PointerToRawData);
      }
  }
}