import.go 2.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
  1. package pe
  2. import (
  3. "encoding/binary"
  4. "fmt"
  5. "io"
  6. "github.com/jchv/go-winloader/internal/loader"
  7. )
  8. // LinkModule links a PE module in-memory.
  9. func LinkModule(m *Module, mem io.ReadWriteSeeker, ldr loader.Loader) error {
  10. dir := m.Header.OptionalHeader.DataDirectory[ImageDirectoryEntryImport]
  11. if dir.Size == 0 {
  12. return nil
  13. }
  14. // Determine pointer size based on whether we're PE32 or PE64.
  15. psize := 4
  16. if m.IsPE64 {
  17. psize = 8
  18. }
  19. // Load import descriptors
  20. descs := []ImageImportDescriptor{}
  21. mem.Seek(int64(dir.VirtualAddress), io.SeekStart)
  22. for {
  23. desc := ImageImportDescriptor{}
  24. binary.Read(mem, binary.LittleEndian, &desc)
  25. if desc.Name == 0 {
  26. break
  27. }
  28. descs = append(descs, desc)
  29. }
  30. // Load modules.
  31. for _, desc := range descs {
  32. thunk := int64(desc.OriginalFirstThunk)
  33. iat := int64(desc.FirstThunk)
  34. if thunk == 0 {
  35. thunk = iat
  36. }
  37. // Read module name
  38. mem.Seek(int64(desc.Name), io.SeekStart)
  39. // Load library
  40. libname := readsz(mem)
  41. lib, err := ldr.Load(libname)
  42. if err != nil {
  43. return err
  44. }
  45. // Read thunk addrs
  46. b := [8]byte{}
  47. thunks := []uint64{}
  48. mem.Seek(thunk, io.SeekStart)
  49. for {
  50. mem.Read(b[:psize])
  51. thunk := binary.LittleEndian.Uint64(b[:])
  52. if thunk == 0 {
  53. break
  54. }
  55. thunks = append(thunks, thunk)
  56. }
  57. // Resolve thunks
  58. resolved := []uint64{}
  59. for _, thunk := range thunks {
  60. thunkord := int64(-1)
  61. if (m.IsPE64 && thunk&0x8000000000000000 != 0) || (!m.IsPE64 && thunk&0x80000000 != 0) {
  62. thunkord = int64(thunk & 0xFFFF)
  63. }
  64. if thunkord != -1 {
  65. // Import by ordinal
  66. if proc := lib.Ordinal(uint64(thunkord)); proc != nil {
  67. resolved = append(resolved, proc.Addr())
  68. } else {
  69. return fmt.Errorf("could not resolve ordinal %d in module %q", thunkord, libname)
  70. }
  71. } else {
  72. // Read name
  73. mem.Seek(int64(thunk+2), io.SeekStart)
  74. fnname := readsz(mem)
  75. // Import by name
  76. if proc := lib.Proc(fnname); proc != nil {
  77. resolved = append(resolved, proc.Addr())
  78. } else {
  79. return fmt.Errorf("could not resolve symbol %q in module %q", fnname, libname)
  80. }
  81. }
  82. }
  83. // Write resolved IAT
  84. mem.Seek(iat, io.SeekStart)
  85. for _, fn := range resolved {
  86. binary.LittleEndian.PutUint64(b[:], uint64(fn))
  87. mem.Write(b[:psize])
  88. }
  89. }
  90. return nil
  91. }