export.go 2.0 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
  1. package pe
  2. import (
  3. "encoding/binary"
  4. "io"
  5. )
  6. // ExportTable is a table of module exports.
  7. type ExportTable struct {
  8. symbols map[string]uint64
  9. ordinals map[uint16]uint64
  10. }
  11. // Proc returns an exported function address by symbol, or 0 if it is not found.
  12. func (t *ExportTable) Proc(symbol string) (addr uint64) {
  13. return t.symbols[symbol]
  14. }
  15. // Ordinal returns an exported function address by ordinal, or 0 if it is not found.
  16. func (t *ExportTable) Ordinal(ordinal uint16) (addr uint64) {
  17. return t.ordinals[ordinal]
  18. }
  19. // LoadExports returns a symbol table.
  20. func LoadExports(m *Module, mem io.ReadWriteSeeker, base uint64) (*ExportTable, error) {
  21. table := &ExportTable{
  22. symbols: map[string]uint64{},
  23. ordinals: map[uint16]uint64{},
  24. }
  25. dir := m.Header.OptionalHeader.DataDirectory[ImageDirectoryEntryExport]
  26. if dir.Size == 0 {
  27. return table, nil
  28. }
  29. // Load export directory header
  30. header := ImageExportDirectory{}
  31. mem.Seek(int64(dir.VirtualAddress), io.SeekStart)
  32. binary.Read(mem, binary.LittleEndian, &header)
  33. // Load addresses
  34. addresses := make([]uint32, header.NumberOfFunctions)
  35. mem.Seek(int64(header.AddressOfFunctions), io.SeekStart)
  36. for i := range addresses {
  37. b := [4]byte{}
  38. mem.Read(b[:])
  39. addresses[i] = binary.LittleEndian.Uint32(b[:])
  40. table.ordinals[uint16(i)] = base + uint64(addresses[i])
  41. }
  42. // Load name ordinals
  43. nameords := make([]uint16, header.NumberOfNames)
  44. mem.Seek(int64(header.AddressOfNameOrdinals), io.SeekStart)
  45. for i := range nameords {
  46. b := [2]byte{}
  47. mem.Read(b[:])
  48. nameords[i] = binary.LittleEndian.Uint16(b[:])
  49. }
  50. // Load name addresses
  51. nameaddrs := make([]uint32, header.NumberOfNames)
  52. mem.Seek(int64(header.AddressOfNames), io.SeekStart)
  53. for i := range nameaddrs {
  54. b := [4]byte{}
  55. mem.Read(b[:])
  56. nameaddrs[i] = binary.LittleEndian.Uint32(b[:])
  57. }
  58. // Load names
  59. for i, nameaddr := range nameaddrs {
  60. mem.Seek(int64(nameaddr), io.SeekStart)
  61. table.symbols[readsz(mem)] = base + uint64(addresses[nameords[i]])
  62. }
  63. return table, nil
  64. }