sys/compat/ndis/subr_pe.c

   1 /*-
   2  * Copyright (c) 2003
   3  *      Bill Paul <wpaul@windriver.com>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Bill Paul.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 /*
  37  * This file contains routines for relocating and dynamically linking
  38  * executable object code files in the Windows(r) PE (Portable Executable)
  39  * format. In Windows, anything with a .EXE, .DLL or .SYS extention is
  40  * considered an executable, and all such files have some structures in
  41  * common. The PE format was apparently based largely on COFF but has
  42  * mutated significantly over time. We are mainly concerned with .SYS files,
  43  * so this module implements only enough routines to be able to parse the
  44  * headers and sections of a .SYS object file and perform the necessary
  45  * relocations and jump table patching to allow us to call into it
  46  * (and to have it call back to us). Note that while this module
  47  * can handle fixups for imported symbols, it knows nothing about
  48  * exporting them.
  49  */
  50
  51 #include <sys/param.h>
  52 #include <sys/types.h>
  53 #include <sys/errno.h>
  54 #ifdef _KERNEL
  55 #include <sys/systm.h>
  56 #else
  57 #include <stdio.h>
  58 #include <stddef.h>
  59 #include <stdlib.h>
  60 #include <unistd.h>
  61 #include <string.h>
  62 #endif
  63
  64 #include <compat/ndis/pe_var.h>
  65
  66 static vm_offset_t pe_functbl_match(image_patch_table *, char *);
  67
  68 /*
  69  * Check for an MS-DOS executable header. All Windows binaries
  70  * have a small MS-DOS executable prepended to them to print out
  71  * the "This program requires Windows" message. Even .SYS files
  72  * have this header, in spite of the fact that you're can't actually
  73  * run them directly.
  74  */
  75
  76 int
  77 pe_get_dos_header(imgbase, hdr)
  78         vm_offset_t             imgbase;
  79         image_dos_header        *hdr;
  80 {
  81         uint16_t                signature;
  82
  83         if (imgbase == 0 || hdr == NULL)
  84                 return (EINVAL);
  85
  86         signature = *(uint16_t *)imgbase;
  87         if (signature != IMAGE_DOS_SIGNATURE)
  88                 return (ENOEXEC);
  89
  90         bcopy ((char *)imgbase, (char *)hdr, sizeof(image_dos_header));
  91
  92         return (0);
  93 }
  94
  95 /*
  96  * Verify that this image has a Windows NT PE signature.
  97  */
  98
  99 int
 100 pe_is_nt_image(imgbase)
 101         vm_offset_t             imgbase;
 102 {
 103         uint32_t                signature;
 104         image_dos_header        *dos_hdr;
 105
 106         if (imgbase == 0)
 107                 return (EINVAL);
 108
 109         signature = *(uint16_t *)imgbase;
 110         if (signature == IMAGE_DOS_SIGNATURE) {
 111                 dos_hdr = (image_dos_header *)imgbase;
 112                 signature = *(uint32_t *)(imgbase + dos_hdr->idh_lfanew);
 113                 if (signature == IMAGE_NT_SIGNATURE)
 114                         return (0);
 115         }
 116
 117         return (ENOEXEC);
 118 }
 119
 120 /*
 121  * Return a copy of the optional header. This contains the
 122  * executable entry point and the directory listing which we
 123  * need to find the relocations and imports later.
 124  */
 125
 126 int
 127 pe_get_optional_header(imgbase, hdr)
 128         vm_offset_t             imgbase;
 129         image_optional_header   *hdr;
 130 {
 131         image_dos_header        *dos_hdr;
 132         image_nt_header         *nt_hdr;
 133
 134         if (imgbase == 0 || hdr == NULL)
 135                 return (EINVAL);
 136
 137         if (pe_is_nt_image(imgbase))
 138                 return (EINVAL);
 139
 140         dos_hdr = (image_dos_header *)(imgbase);
 141         nt_hdr = (image_nt_header *)(imgbase + dos_hdr->idh_lfanew);
 142
 143         bcopy ((char *)&nt_hdr->inh_optionalhdr, (char *)hdr,
 144             nt_hdr->inh_filehdr.ifh_optionalhdrlen);
 145
 146         return (0);
 147 }
 148
 149 /*
 150  * Return a copy of the file header. Contains the number of
 151  * sections in this image.
 152  */
 153
 154 int
 155 pe_get_file_header(imgbase, hdr)
 156         vm_offset_t             imgbase;
 157         image_file_header       *hdr;
 158 {
 159         image_dos_header        *dos_hdr;
 160         image_nt_header         *nt_hdr;
 161
 162         if (imgbase == 0 || hdr == NULL)
 163                 return (EINVAL);
 164
 165         if (pe_is_nt_image(imgbase))
 166                 return (EINVAL);
 167
 168         dos_hdr = (image_dos_header *)imgbase;
 169         nt_hdr = (image_nt_header *)(imgbase + dos_hdr->idh_lfanew);
 170
 171         /*
 172          * Note: the size of the nt_header is variable since it
 173          * can contain optional fields, as indicated by ifh_optionalhdrlen.
 174          * However it happens we're only interested in fields in the
 175          * non-variant portion of the nt_header structure, so we don't
 176          * bother copying the optional parts here.
 177          */
 178
 179         bcopy ((char *)&nt_hdr->inh_filehdr, (char *)hdr,
 180             sizeof(image_file_header));
 181
 182         return (0);
 183 }
 184
 185 /*
 186  * Return the header of the first section in this image (usually
 187  * .text).
 188  */
 189
 190 int
 191 pe_get_section_header(imgbase, hdr)
 192         vm_offset_t             imgbase;
 193         image_section_header    *hdr;
 194 {
 195         image_dos_header        *dos_hdr;
 196         image_nt_header         *nt_hdr;
 197         image_section_header    *sect_hdr;
 198
 199         if (imgbase == 0 || hdr == NULL)
 200                 return (EINVAL);
 201
 202         if (pe_is_nt_image(imgbase))
 203                 return (EINVAL);
 204
 205         dos_hdr = (image_dos_header *)imgbase;
 206         nt_hdr = (image_nt_header *)(imgbase + dos_hdr->idh_lfanew);
 207         sect_hdr = IMAGE_FIRST_SECTION(nt_hdr);
 208
 209         bcopy ((char *)sect_hdr, (char *)hdr, sizeof(image_section_header));
 210
 211         return (0);
 212 }
 213
 214 /*
 215  * Return the number of sections in this executable, or 0 on error.
 216  */
 217
 218 int
 219 pe_numsections(imgbase)
 220         vm_offset_t             imgbase;
 221 {
 222         image_file_header       file_hdr;
 223
 224         if (pe_get_file_header(imgbase, &file_hdr))
 225                 return (0);
 226
 227         return (file_hdr.ifh_numsections);
 228 }
 229
 230 /*
 231  * Return the base address that this image was linked for.
 232  * This helps us calculate relocation addresses later.
 233  */
 234
 235 vm_offset_t
 236 pe_imagebase(imgbase)
 237         vm_offset_t             imgbase;
 238 {
 239         image_optional_header   optional_hdr;
 240
 241         if (pe_get_optional_header(imgbase, &optional_hdr))
 242                 return (0);
 243
 244         return (optional_hdr.ioh_imagebase);
 245 }
 246
 247 /*
 248  * Return the offset of a given directory structure within the
 249  * image. Directories reside within sections.
 250  */
 251
 252 vm_offset_t
 253 pe_directory_offset(imgbase, diridx)
 254         vm_offset_t             imgbase;
 255         uint32_t                diridx;
 256 {
 257         image_optional_header   opt_hdr;
 258         vm_offset_t             dir;
 259
 260         if (pe_get_optional_header(imgbase, &opt_hdr))
 261                 return (0);
 262
 263         if (diridx >= opt_hdr.ioh_rva_size_cnt)
 264                 return (0);
 265
 266         dir = opt_hdr.ioh_datadir[diridx].idd_vaddr;
 267
 268         return (pe_translate_addr(imgbase, dir));
 269 }
 270
 271 vm_offset_t
 272 pe_translate_addr(imgbase, rva)
 273         vm_offset_t             imgbase;
 274         vm_offset_t             rva;
 275 {
 276         image_optional_header   opt_hdr;
 277         image_section_header    *sect_hdr;
 278         image_dos_header        *dos_hdr;
 279         image_nt_header         *nt_hdr;
 280         int                     i = 0, sections, fixedlen;
 281
 282         if (pe_get_optional_header(imgbase, &opt_hdr))
 283                 return (0);
 284
 285         sections = pe_numsections(imgbase);
 286
 287         dos_hdr = (image_dos_header *)imgbase;
 288         nt_hdr = (image_nt_header *)(imgbase + dos_hdr->idh_lfanew);
 289         sect_hdr = IMAGE_FIRST_SECTION(nt_hdr);
 290
 291         /*
 292          * The test here is to see if the RVA falls somewhere
 293          * inside the section, based on the section's start RVA
 294          * and its length. However it seems sometimes the
 295          * virtual length isn't enough to cover the entire
 296          * area of the section. We fudge by taking into account
 297          * the section alignment and rounding the section length
 298          * up to a page boundary.
 299          */
 300         while (i++ < sections) {
 301                 fixedlen = sect_hdr->ish_misc.ish_vsize;
 302                 fixedlen += ((opt_hdr.ioh_sectalign - 1) -
 303                     sect_hdr->ish_misc.ish_vsize) &
 304                     (opt_hdr.ioh_sectalign - 1);
 305                 if (sect_hdr->ish_vaddr <= (uint32_t)rva &&
 306                     (sect_hdr->ish_vaddr + fixedlen) >
 307                     (uint32_t)rva)
 308                         break;
 309                 sect_hdr++;
 310         }
 311
 312         if (i > sections)
 313                 return (0);
 314
 315         return ((vm_offset_t)(imgbase + rva - sect_hdr->ish_vaddr +
 316             sect_hdr->ish_rawdataaddr));
 317 }
 318
 319 /*
 320  * Get the section header for a particular section. Note that
 321  * section names can be anything, but there are some standard
 322  * ones (.text, .data, .rdata, .reloc).
 323  */
 324
 325 int
 326 pe_get_section(imgbase, hdr, name)
 327         vm_offset_t             imgbase;
 328         image_section_header    *hdr;
 329         const char              *name;
 330 {
 331         image_dos_header        *dos_hdr;
 332         image_nt_header         *nt_hdr;
 333         image_section_header    *sect_hdr;
 334
 335         int                     i, sections;
 336
 337         if (imgbase == 0 || hdr == NULL)
 338                 return (EINVAL);
 339
 340         if (pe_is_nt_image(imgbase))
 341                 return (EINVAL);
 342
 343         sections = pe_numsections(imgbase);
 344
 345         dos_hdr = (image_dos_header *)imgbase;
 346         nt_hdr = (image_nt_header *)(imgbase + dos_hdr->idh_lfanew);
 347         sect_hdr = IMAGE_FIRST_SECTION(nt_hdr);
 348
 349         for (i = 0; i < sections; i++) {
 350                 if (!strcmp ((char *)&sect_hdr->ish_name, name)) {
 351                         bcopy((char *)sect_hdr, (char *)hdr,
 352                             sizeof(image_section_header));
 353                         return (0);
 354                 } else
 355                         sect_hdr++;
 356         }
 357
 358         return (ENOEXEC);
 359 }
 360
 361 /*
 362  * Apply the base relocations to this image. The relocation table
 363  * resides within the .reloc section. Relocations are specified in
 364  * blocks which refer to a particular page. We apply the relocations
 365  * one page block at a time.
 366  */
 367
 368 int
 369 pe_relocate(imgbase)
 370         vm_offset_t             imgbase;
 371 {
 372         image_section_header    sect;
 373         image_base_reloc        *relhdr;
 374         uint16_t                rel, *sloc;
 375         vm_offset_t             base;
 376         vm_size_t               delta;
 377         uint32_t                *lloc;
 378         uint64_t                *qloc;
 379         int                     i, count;
 380         vm_offset_t             txt;
 381
 382         base = pe_imagebase(imgbase);
 383         pe_get_section(imgbase, &sect, ".text");
 384         txt = pe_translate_addr(imgbase, sect.ish_vaddr);
 385         delta = (uint32_t)(txt) - base - sect.ish_vaddr;
 386
 387         pe_get_section(imgbase, &sect, ".reloc");
 388
 389         relhdr = (image_base_reloc *)(imgbase + sect.ish_rawdataaddr);
 390
 391         do {
 392                 count = (relhdr->ibr_blocksize -
 393                     (sizeof(uint32_t) * 2)) / sizeof(uint16_t);
 394                 for (i = 0; i < count; i++) {
 395                         rel = relhdr->ibr_rel[i];
 396                         switch (IMR_RELTYPE(rel)) {
 397                         case IMAGE_REL_BASED_ABSOLUTE:
 398                                 break;
 399                         case IMAGE_REL_BASED_HIGHLOW:
 400                                 lloc = (uint32_t *)pe_translate_addr(imgbase,
 401                                     relhdr->ibr_vaddr + IMR_RELOFFSET(rel));
 402                                 *lloc = pe_translate_addr(imgbase,
 403                                     (*lloc - base));
 404                                 break;
 405                         case IMAGE_REL_BASED_HIGH:
 406                                 sloc = (uint16_t *)pe_translate_addr(imgbase,
 407                                     relhdr->ibr_vaddr + IMR_RELOFFSET(rel));
 408                                 *sloc += (delta & 0xFFFF0000) >> 16;
 409                                 break;
 410                         case IMAGE_REL_BASED_LOW:
 411                                 sloc = (uint16_t *)pe_translate_addr(imgbase,
 412                                     relhdr->ibr_vaddr + IMR_RELOFFSET(rel));
 413                                 *sloc += (delta & 0xFFFF);
 414                                 break;
 415                         case IMAGE_REL_BASED_DIR64:
 416                                 qloc = (uint64_t *)pe_translate_addr(imgbase,
 417                                     relhdr->ibr_vaddr + IMR_RELOFFSET(rel));
 418                                 *qloc = pe_translate_addr(imgbase,
 419                                     (*qloc - base));
 420                                 break;
 421
 422                         default:
 423                                 printf("[%d]reloc type: %d\n",i,
 424                                     IMR_RELTYPE(rel));
 425                                 break;
 426                         }
 427                 }
 428                 relhdr = (image_base_reloc *)((vm_offset_t)relhdr +
 429                     relhdr->ibr_blocksize);
 430         } while (relhdr->ibr_blocksize);
 431
 432         return (0);
 433 }
 434
 435 /*
 436  * Return the import descriptor for a particular module. An image
 437  * may be linked against several modules, typically HAL.dll, ntoskrnl.exe
 438  * and NDIS.SYS. For each module, there is a list of imported function
 439  * names and their addresses.
 440  *
 441  * Note: module names are case insensitive!
 442  */
 443
 444 int
 445 pe_get_import_descriptor(imgbase, desc, module)
 446         vm_offset_t             imgbase;
 447         image_import_descriptor *desc;
 448         char                    *module;
 449 {
 450         vm_offset_t             offset;
 451         image_import_descriptor *imp_desc;
 452         char                    *modname;
 453
 454         if (imgbase == 0 || module == NULL || desc == NULL)
 455                 return (EINVAL);
 456
 457         offset = pe_directory_offset(imgbase, IMAGE_DIRECTORY_ENTRY_IMPORT);
 458         if (offset == 0)
 459                 return (ENOENT);
 460
 461         imp_desc = (void *)offset;
 462
 463         while (imp_desc->iid_nameaddr) {
 464                 modname = (char *)pe_translate_addr(imgbase,
 465                     imp_desc->iid_nameaddr);
 466                 if (!strncasecmp(module, modname, strlen(module))) {
 467                         bcopy((char *)imp_desc, (char *)desc,
 468                             sizeof(image_import_descriptor));
 469                         return (0);
 470                 }
 471                 imp_desc++;
 472         }
 473
 474         return (ENOENT);
 475 }
 476
 477 int
 478 pe_get_messagetable(imgbase, md)
 479         vm_offset_t             imgbase;
 480         message_resource_data   **md;
 481 {
 482         image_resource_directory        *rdir, *rtype;
 483         image_resource_directory_entry  *dent, *dent2;
 484         image_resource_data_entry       *rent;
 485         vm_offset_t             offset;
 486         int                     i;
 487
 488         if (imgbase == 0)
 489                 return (EINVAL);
 490
 491         offset = pe_directory_offset(imgbase, IMAGE_DIRECTORY_ENTRY_RESOURCE);
 492         if (offset == 0)
 493                 return (ENOENT);
 494
 495         rdir = (image_resource_directory *)offset;
 496
 497         dent = (image_resource_directory_entry *)(offset +
 498             sizeof(image_resource_directory));
 499
 500         for (i = 0; i < rdir->ird_id_entries; i++){
 501                 if (dent->irde_name != RT_MESSAGETABLE) {
 502                         dent++;
 503                         continue;
 504                 }
 505                 dent2 = dent;
 506                 while (dent2->irde_dataoff & RESOURCE_DIR_FLAG) {
 507                         rtype = (image_resource_directory *)(offset +
 508                             (dent2->irde_dataoff & ~RESOURCE_DIR_FLAG));
 509                         dent2 = (image_resource_directory_entry *)
 510                             ((uintptr_t)rtype +
 511                              sizeof(image_resource_directory));
 512                 }
 513                 rent = (image_resource_data_entry *)(offset +
 514                     dent2->irde_dataoff);
 515                 *md = (message_resource_data *)pe_translate_addr(imgbase,
 516                     rent->irde_offset);
 517                 return (0);
 518         }
 519
 520         return (ENOENT);
 521 }
 522
 523 int
 524 pe_get_message(imgbase, id, str, len, flags)
 525         vm_offset_t             imgbase;
 526         uint32_t                id;
 527         char                    **str;
 528         int                     *len;
 529         uint16_t                *flags;
 530 {
 531         message_resource_data   *md = NULL;
 532         message_resource_block  *mb;
 533         message_resource_entry  *me;
 534         uint32_t                i;
 535
 536         pe_get_messagetable(imgbase, &md);
 537
 538         if (md == NULL)
 539                 return (ENOENT);
 540
 541         mb = (message_resource_block *)((uintptr_t)md +
 542             sizeof(message_resource_data));
 543
 544         for (i = 0; i < md->mrd_numblocks; i++) {
 545                 if (id >= mb->mrb_lowid && id <= mb->mrb_highid) {
 546                         me = (message_resource_entry *)((uintptr_t)md +
 547                             mb->mrb_entryoff);
 548                         for (i = id - mb->mrb_lowid; i > 0; i--)
 549                                 me = (message_resource_entry *)((uintptr_t)me +
 550                                     me->mre_len);
 551                         *str = me->mre_text;
 552                         *len = me->mre_len;
 553                         *flags = me->mre_flags;
 554                         return (0);
 555                 }
 556                 mb++;
 557         }
 558
 559         return (ENOENT);
 560 }
 561
 562 /*
 563  * Find the function that matches a particular name. This doesn't
 564  * need to be particularly speedy since it's only run when loading
 565  * a module for the first time.
 566  */
 567
 568 static vm_offset_t
 569 pe_functbl_match(functbl, name)
 570         image_patch_table       *functbl;
 571         char                    *name;
 572 {
 573         image_patch_table       *p;
 574
 575         if (functbl == NULL || name == NULL)
 576                 return (0);
 577
 578         p = functbl;
 579
 580         while (p->ipt_name != NULL) {
 581                 if (!strcmp(p->ipt_name, name))
 582                         return ((vm_offset_t)p->ipt_wrap);
 583                 p++;
 584         }
 585         printf("no match for %s\n", name);
 586
 587         /*
 588          * Return the wrapper pointer for this routine.
 589          * For x86, this is the same as the funcptr.
 590          * For amd64, this points to a wrapper routine
 591          * that does calling convention translation and
 592          * then invokes the underlying routine.
 593          */
 594         return ((vm_offset_t)p->ipt_wrap);
 595 }
 596
 597 /*
 598  * Patch the imported function addresses for a given module.
 599  * The caller must specify the module name and provide a table
 600  * of function pointers that will be patched into the jump table.
 601  * Note that there are actually two copies of the jump table: one
 602  * copy is left alone. In a .SYS file, the jump tables are usually
 603  * merged into the INIT segment.
 604  */
 605
 606 int
 607 pe_patch_imports(imgbase, module, functbl)
 608         vm_offset_t             imgbase;
 609         char                    *module;
 610         image_patch_table       *functbl;
 611 {
 612         image_import_descriptor imp_desc;
 613         char                    *fname;
 614         vm_offset_t             *nptr, *fptr;
 615         vm_offset_t             func;
 616
 617         if (imgbase == 0 || module == NULL || functbl == NULL)
 618                 return (EINVAL);
 619
 620         if (pe_get_import_descriptor(imgbase, &imp_desc, module))
 621                 return (ENOEXEC);
 622
 623         nptr = (vm_offset_t *)pe_translate_addr(imgbase,
 624             imp_desc.iid_import_name_table_addr);
 625         fptr = (vm_offset_t *)pe_translate_addr(imgbase,
 626             imp_desc.iid_import_address_table_addr);
 627
 628         while (nptr != NULL && pe_translate_addr(imgbase, *nptr)) {
 629                 fname = (char *)pe_translate_addr(imgbase, (*nptr) + 2);
 630                 func = pe_functbl_match(functbl, fname);
 631                 if (func)
 632                         *fptr = func;
 633 #ifdef notdef
 634                 if (*fptr == 0)
 635                         return (ENOENT);
 636 #endif
 637                 nptr++;
 638                 fptr++;
 639         }
 640
 641         return (0);
 642 }