loader.go 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253
  1. package memloader
  2. import (
  3. "bytes"
  4. "encoding/binary"
  5. "fmt"
  6. "io"
  7. "github.com/jchv/go-winloader/internal/loader"
  8. "github.com/jchv/go-winloader/internal/pe"
  9. "github.com/jchv/go-winloader/internal/vmem"
  10. "github.com/jchv/go-winloader/internal/winloader"
  11. )
  12. // module implements a module for the memory loader.
  13. type module struct {
  14. machine loader.Machine
  15. memory loader.Memory
  16. pemod *pe.Module
  17. exports *pe.ExportTable
  18. hinstance uint64
  19. }
  20. // Proc implements loader.Module
  21. func (m *module) Proc(name string) loader.Proc {
  22. addr := m.exports.Proc(name)
  23. if addr == 0 {
  24. return nil
  25. }
  26. return m.machine.MemProc(addr)
  27. }
  28. // Ordinal implements loader.Module
  29. func (m *module) Ordinal(ordinal uint64) loader.Proc {
  30. addr := m.exports.Ordinal(uint16(ordinal))
  31. if addr == 0 {
  32. return nil
  33. }
  34. return m.machine.MemProc(addr)
  35. }
  36. // Free implements loader.Module
  37. func (m *module) Free() error {
  38. // Execute entrypoint for detach.
  39. entry := m.machine.MemProc(m.memory.Addr() + uint64(m.pemod.Header.OptionalHeader.AddressOfEntryPoint))
  40. entry.Call(uint64(m.memory.Addr()), 0, 0)
  41. // Free memory.
  42. m.memory.Free()
  43. return nil
  44. }
  45. // Loader implements a memory loader for PE files.
  46. type Loader struct {
  47. next loader.Loader
  48. machine loader.Machine
  49. pebhacks bool
  50. prochinst bool
  51. }
  52. // Options contains the options for creating a new memory loader.
  53. type Options struct {
  54. // Next specifies the loader to use for recursing to resolve modules by
  55. // name.
  56. Next loader.Loader
  57. // Machine specifies the machine the module should be loaded into.
  58. Machine loader.Machine
  59. // HintAddModuleToPEB specifies that the memory loader should try to add
  60. // the loaded module into the PEB so that certain things function as
  61. // expected.
  62. // NOTE: This is not implemented yet and may not be possible.
  63. HintAddModuleToPEB bool
  64. // HintUseProcessHInstance specifies that the memory loader should use the
  65. // host process's HINSTANCE value for calling into entrypoints.
  66. HintUseProcessHInstance bool
  67. }
  68. // New creates a new loader with the specified options.
  69. func New(opts Options) loader.MemLoader {
  70. return &Loader{
  71. next: opts.Next,
  72. machine: opts.Machine,
  73. }
  74. }
  75. // LoadMem implements the loader.MemLoader interface.
  76. func (l *Loader) LoadMem(data []byte) (loader.Module, error) {
  77. bin, err := pe.LoadModule(bytes.NewReader(data))
  78. if err != nil {
  79. return nil, err
  80. }
  81. if !l.machine.IsArchitectureSupported(int(bin.Header.FileHeader.Machine)) {
  82. return nil, fmt.Errorf("image architecture not %04x not supported by this machine", bin.Header.FileHeader.Machine)
  83. }
  84. pageSize := l.machine.GetPageSize()
  85. imageSize := vmem.RoundUp(uint64(bin.Header.OptionalHeader.SizeOfImage), pageSize)
  86. var mem loader.Memory
  87. // If the image is not movable, allocate it at its preferred address.
  88. if bin.Header.OptionalHeader.DllCharacteristics&pe.ImageDLLCharacteristicsDynamicBase == 0 {
  89. mem = l.machine.Alloc(bin.Header.OptionalHeader.ImageBase, imageSize, vmem.MemCommit|vmem.MemReserve, vmem.PageExecuteReadWrite)
  90. if mem == nil {
  91. return nil, fmt.Errorf("image could not be mapped at preferred base 0x%08x and cannot be relocated", bin.Header.OptionalHeader.ImageBase)
  92. }
  93. }
  94. // Allocate anywhere, so as long as the image won't span a 4 GiB
  95. // alignment boundary.
  96. failedAllocs := []loader.Memory{}
  97. for mem == nil || mem.Addr()>>32 != (mem.Addr()+imageSize)>>32 {
  98. if mem != nil {
  99. failedAllocs = append(failedAllocs, mem)
  100. }
  101. if mem = l.machine.Alloc(0, imageSize, vmem.MemCommit|vmem.MemReserve, vmem.PageExecuteReadWrite); mem == nil {
  102. return nil, fmt.Errorf("allocation of %d bytes failed", imageSize)
  103. }
  104. }
  105. for _, i := range failedAllocs {
  106. i.Free()
  107. }
  108. realBase := mem.Addr()
  109. hdrsize := uint64(bin.Header.OptionalHeader.SizeOfHeaders)
  110. vmem.Alloc(realBase, hdrsize, vmem.MemCommit, vmem.PageReadWrite).Write(data[0:hdrsize])
  111. // Map sections into memory
  112. for _, section := range bin.Sections {
  113. addr := realBase + uint64(section.VirtualAddress)
  114. if section.SizeOfRawData == 0 {
  115. size := uint64(bin.Header.OptionalHeader.SectionAlignment)
  116. if size != 0 {
  117. vmem.Alloc(addr, size, vmem.MemCommit, vmem.PageReadWrite).Clear()
  118. }
  119. } else {
  120. sectionData := data[section.PointerToRawData : section.PointerToRawData+section.SizeOfRawData]
  121. vmem.Alloc(addr, uint64(section.SizeOfRawData), vmem.MemCommit, vmem.PageReadWrite).Write(sectionData)
  122. }
  123. // TODO: need to set Misc.PhysicalAddress?
  124. }
  125. // TODO: Detect native byte order for relocations.
  126. order := binary.LittleEndian
  127. machine := int(bin.Header.FileHeader.Machine)
  128. // Perform relocations
  129. relocs := pe.LoadBaseRelocs(bin, mem)
  130. if err := pe.Relocate(machine, relocs, uint64(realBase), bin.Header.OptionalHeader.ImageBase, mem, order); err != nil {
  131. return nil, err
  132. }
  133. // Perform runtime linking
  134. if err := pe.LinkModule(bin, mem, l.next); err != nil {
  135. return nil, err
  136. }
  137. // Set access flags.
  138. for _, section := range bin.Sections {
  139. executable := section.Characteristics&pe.ImageSectionCharacteristicsMemoryExecute != 0
  140. readable := section.Characteristics&pe.ImageSectionCharacteristicsMemoryRead != 0
  141. writable := section.Characteristics&pe.ImageSectionCharacteristicsMemoryWrite != 0
  142. protect := vmem.PageNoAccess
  143. switch {
  144. case !executable && !readable && !writable:
  145. protect = vmem.PageNoAccess
  146. case !executable && !readable && writable:
  147. protect = vmem.PageWriteCopy
  148. case !executable && readable && !writable:
  149. protect = vmem.PageReadOnly
  150. case !executable && readable && writable:
  151. protect = vmem.PageReadWrite
  152. case executable && !readable && !writable:
  153. protect = vmem.PageExecute
  154. case executable && !readable && writable:
  155. protect = vmem.PageExecuteWriteCopy
  156. case executable && readable && !writable:
  157. protect = vmem.PageExecuteRead
  158. case executable && readable && writable:
  159. protect = vmem.PageExecuteReadWrite
  160. }
  161. size := uint64(section.SizeOfRawData)
  162. if size == 0 {
  163. size = uint64(bin.Header.OptionalHeader.SectionAlignment)
  164. }
  165. err := mem.Protect(uint64(section.VirtualAddress), size, protect)
  166. if err != nil {
  167. return nil, err
  168. }
  169. }
  170. // Handle HINSTANCE setup.
  171. hinstance := realBase
  172. if l.pebhacks {
  173. // TODO: implement PEB loader hacks, see if it works.
  174. }
  175. if l.prochinst {
  176. if prochinst, err := winloader.GetProcessHInstance(); err == nil {
  177. hinstance = uint64(prochinst)
  178. }
  179. }
  180. m := &module{
  181. machine: l.machine,
  182. memory: mem,
  183. pemod: bin,
  184. hinstance: hinstance,
  185. }
  186. // Execute TLS callbacks.
  187. tlsdir := bin.Header.OptionalHeader.DataDirectory[pe.ImageDirectoryEntryTLS]
  188. if tlsdir.Size > 0 {
  189. mem.Seek(int64(tlsdir.VirtualAddress), io.SeekStart)
  190. dir := pe.ImageTLSDirectory64{}
  191. b := [8]byte{}
  192. psize := 4
  193. if bin.IsPE64 {
  194. psize = 8
  195. binary.Read(mem, binary.LittleEndian, &dir)
  196. } else {
  197. dir32 := pe.ImageTLSDirectory32{}
  198. binary.Read(mem, binary.LittleEndian, &dir32)
  199. dir = dir32.To64()
  200. }
  201. mem.Seek(int64(dir.AddressOfCallBacks), io.SeekStart)
  202. if dir.AddressOfCallBacks != 0 {
  203. for {
  204. mem.Read(b[:psize])
  205. addr := binary.LittleEndian.Uint64(b[:])
  206. if addr == 0 {
  207. break
  208. }
  209. cb := l.machine.MemProc(realBase + addr)
  210. cb.Call(hinstance, 1, 0)
  211. }
  212. }
  213. }
  214. // Execute entrypoint for attach.
  215. entry := l.machine.MemProc(realBase + uint64(bin.Header.OptionalHeader.AddressOfEntryPoint))
  216. entry.Call(hinstance, 1, 0)
  217. m.exports, err = pe.LoadExports(bin, mem, realBase)
  218. if err != nil {
  219. return nil, err
  220. }
  221. return m, nil
  222. }