mirror of
https://github.com/autc04/Retro68.git
synced 2024-11-17 19:06:36 +00:00
398 lines
10 KiB
Go
398 lines
10 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package pe implements access to PE (Microsoft Windows Portable Executable) files.
|
|
package pe
|
|
|
|
import (
|
|
"debug/dwarf"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strconv"
|
|
)
|
|
|
|
// A File represents an open PE file.
|
|
type File struct {
|
|
FileHeader
|
|
OptionalHeader interface{} // of type *OptionalHeader32 or *OptionalHeader64
|
|
Sections []*Section
|
|
Symbols []*Symbol
|
|
|
|
closer io.Closer
|
|
}
|
|
|
|
type SectionHeader struct {
|
|
Name string
|
|
VirtualSize uint32
|
|
VirtualAddress uint32
|
|
Size uint32
|
|
Offset uint32
|
|
PointerToRelocations uint32
|
|
PointerToLineNumbers uint32
|
|
NumberOfRelocations uint16
|
|
NumberOfLineNumbers uint16
|
|
Characteristics uint32
|
|
}
|
|
|
|
type Section struct {
|
|
SectionHeader
|
|
|
|
// Embed ReaderAt for ReadAt method.
|
|
// Do not embed SectionReader directly
|
|
// to avoid having Read and Seek.
|
|
// If a client wants Read and Seek it must use
|
|
// Open() to avoid fighting over the seek offset
|
|
// with other clients.
|
|
io.ReaderAt
|
|
sr *io.SectionReader
|
|
}
|
|
|
|
type Symbol struct {
|
|
Name string
|
|
Value uint32
|
|
SectionNumber int16
|
|
Type uint16
|
|
StorageClass uint8
|
|
}
|
|
|
|
type ImportDirectory struct {
|
|
OriginalFirstThunk uint32
|
|
TimeDateStamp uint32
|
|
ForwarderChain uint32
|
|
Name uint32
|
|
FirstThunk uint32
|
|
|
|
dll string
|
|
}
|
|
|
|
// Data reads and returns the contents of the PE section.
|
|
func (s *Section) Data() ([]byte, error) {
|
|
dat := make([]byte, s.sr.Size())
|
|
n, err := s.sr.ReadAt(dat, 0)
|
|
if n == len(dat) {
|
|
err = nil
|
|
}
|
|
return dat[0:n], err
|
|
}
|
|
|
|
// Open returns a new ReadSeeker reading the PE section.
|
|
func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) }
|
|
|
|
type FormatError struct {
|
|
off int64
|
|
msg string
|
|
val interface{}
|
|
}
|
|
|
|
func (e *FormatError) Error() string {
|
|
msg := e.msg
|
|
if e.val != nil {
|
|
msg += fmt.Sprintf(" '%v'", e.val)
|
|
}
|
|
msg += fmt.Sprintf(" in record at byte %#x", e.off)
|
|
return msg
|
|
}
|
|
|
|
// Open opens the named file using os.Open and prepares it for use as a PE binary.
|
|
func Open(name string) (*File, error) {
|
|
f, err := os.Open(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ff, err := NewFile(f)
|
|
if err != nil {
|
|
f.Close()
|
|
return nil, err
|
|
}
|
|
ff.closer = f
|
|
return ff, nil
|
|
}
|
|
|
|
// Close closes the File.
|
|
// If the File was created using NewFile directly instead of Open,
|
|
// Close has no effect.
|
|
func (f *File) Close() error {
|
|
var err error
|
|
if f.closer != nil {
|
|
err = f.closer.Close()
|
|
f.closer = nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
var (
|
|
sizeofOptionalHeader32 = uint16(binary.Size(OptionalHeader32{}))
|
|
sizeofOptionalHeader64 = uint16(binary.Size(OptionalHeader64{}))
|
|
)
|
|
|
|
// NewFile creates a new File for accessing a PE binary in an underlying reader.
|
|
func NewFile(r io.ReaderAt) (*File, error) {
|
|
f := new(File)
|
|
sr := io.NewSectionReader(r, 0, 1<<63-1)
|
|
|
|
var dosheader [96]byte
|
|
if _, err := r.ReadAt(dosheader[0:], 0); err != nil {
|
|
return nil, err
|
|
}
|
|
var base int64
|
|
if dosheader[0] == 'M' && dosheader[1] == 'Z' {
|
|
signoff := int64(binary.LittleEndian.Uint32(dosheader[0x3c:]))
|
|
var sign [4]byte
|
|
r.ReadAt(sign[:], signoff)
|
|
if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {
|
|
return nil, errors.New("Invalid PE File Format.")
|
|
}
|
|
base = signoff + 4
|
|
} else {
|
|
base = int64(0)
|
|
}
|
|
sr.Seek(base, os.SEEK_SET)
|
|
if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
|
|
return nil, err
|
|
}
|
|
if f.FileHeader.Machine != IMAGE_FILE_MACHINE_UNKNOWN && f.FileHeader.Machine != IMAGE_FILE_MACHINE_AMD64 && f.FileHeader.Machine != IMAGE_FILE_MACHINE_I386 {
|
|
return nil, errors.New("Invalid PE File Format.")
|
|
}
|
|
|
|
var ss []byte
|
|
if f.FileHeader.NumberOfSymbols > 0 {
|
|
// Get COFF string table, which is located at the end of the COFF symbol table.
|
|
sr.Seek(int64(f.FileHeader.PointerToSymbolTable+COFFSymbolSize*f.FileHeader.NumberOfSymbols), os.SEEK_SET)
|
|
var l uint32
|
|
if err := binary.Read(sr, binary.LittleEndian, &l); err != nil {
|
|
return nil, err
|
|
}
|
|
ss = make([]byte, l)
|
|
if _, err := r.ReadAt(ss, int64(f.FileHeader.PointerToSymbolTable+COFFSymbolSize*f.FileHeader.NumberOfSymbols)); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Process COFF symbol table.
|
|
sr.Seek(int64(f.FileHeader.PointerToSymbolTable), os.SEEK_SET)
|
|
aux := uint8(0)
|
|
for i := 0; i < int(f.FileHeader.NumberOfSymbols); i++ {
|
|
cs := new(COFFSymbol)
|
|
if err := binary.Read(sr, binary.LittleEndian, cs); err != nil {
|
|
return nil, err
|
|
}
|
|
if aux > 0 {
|
|
aux--
|
|
continue
|
|
}
|
|
var name string
|
|
if cs.Name[0] == 0 && cs.Name[1] == 0 && cs.Name[2] == 0 && cs.Name[3] == 0 {
|
|
si := int(binary.LittleEndian.Uint32(cs.Name[4:]))
|
|
name, _ = getString(ss, si)
|
|
} else {
|
|
name = cstring(cs.Name[:])
|
|
}
|
|
aux = cs.NumberOfAuxSymbols
|
|
s := &Symbol{
|
|
Name: name,
|
|
Value: cs.Value,
|
|
SectionNumber: cs.SectionNumber,
|
|
Type: cs.Type,
|
|
StorageClass: cs.StorageClass,
|
|
}
|
|
f.Symbols = append(f.Symbols, s)
|
|
}
|
|
}
|
|
|
|
// Read optional header.
|
|
sr.Seek(base, os.SEEK_SET)
|
|
if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
|
|
return nil, err
|
|
}
|
|
var oh32 OptionalHeader32
|
|
var oh64 OptionalHeader64
|
|
switch f.FileHeader.SizeOfOptionalHeader {
|
|
case sizeofOptionalHeader32:
|
|
if err := binary.Read(sr, binary.LittleEndian, &oh32); err != nil {
|
|
return nil, err
|
|
}
|
|
if oh32.Magic != 0x10b { // PE32
|
|
return nil, fmt.Errorf("pe32 optional header has unexpected Magic of 0x%x", oh32.Magic)
|
|
}
|
|
f.OptionalHeader = &oh32
|
|
case sizeofOptionalHeader64:
|
|
if err := binary.Read(sr, binary.LittleEndian, &oh64); err != nil {
|
|
return nil, err
|
|
}
|
|
if oh64.Magic != 0x20b { // PE32+
|
|
return nil, fmt.Errorf("pe32+ optional header has unexpected Magic of 0x%x", oh64.Magic)
|
|
}
|
|
f.OptionalHeader = &oh64
|
|
}
|
|
|
|
// Process sections.
|
|
f.Sections = make([]*Section, f.FileHeader.NumberOfSections)
|
|
for i := 0; i < int(f.FileHeader.NumberOfSections); i++ {
|
|
sh := new(SectionHeader32)
|
|
if err := binary.Read(sr, binary.LittleEndian, sh); err != nil {
|
|
return nil, err
|
|
}
|
|
var name string
|
|
if sh.Name[0] == '\x2F' {
|
|
si, _ := strconv.Atoi(cstring(sh.Name[1:]))
|
|
name, _ = getString(ss, si)
|
|
} else {
|
|
name = cstring(sh.Name[0:])
|
|
}
|
|
s := new(Section)
|
|
s.SectionHeader = SectionHeader{
|
|
Name: name,
|
|
VirtualSize: sh.VirtualSize,
|
|
VirtualAddress: sh.VirtualAddress,
|
|
Size: sh.SizeOfRawData,
|
|
Offset: sh.PointerToRawData,
|
|
PointerToRelocations: sh.PointerToRelocations,
|
|
PointerToLineNumbers: sh.PointerToLineNumbers,
|
|
NumberOfRelocations: sh.NumberOfRelocations,
|
|
NumberOfLineNumbers: sh.NumberOfLineNumbers,
|
|
Characteristics: sh.Characteristics,
|
|
}
|
|
s.sr = io.NewSectionReader(r, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))
|
|
s.ReaderAt = s.sr
|
|
f.Sections[i] = s
|
|
}
|
|
return f, nil
|
|
}
|
|
|
|
func cstring(b []byte) string {
|
|
var i int
|
|
for i = 0; i < len(b) && b[i] != 0; i++ {
|
|
}
|
|
return string(b[0:i])
|
|
}
|
|
|
|
// getString extracts a string from symbol string table.
|
|
func getString(section []byte, start int) (string, bool) {
|
|
if start < 0 || start >= len(section) {
|
|
return "", false
|
|
}
|
|
|
|
for end := start; end < len(section); end++ {
|
|
if section[end] == 0 {
|
|
return string(section[start:end]), true
|
|
}
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
// Section returns the first section with the given name, or nil if no such
|
|
// section exists.
|
|
func (f *File) Section(name string) *Section {
|
|
for _, s := range f.Sections {
|
|
if s.Name == name {
|
|
return s
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *File) DWARF() (*dwarf.Data, error) {
|
|
// There are many other DWARF sections, but these
|
|
// are the ones the debug/dwarf package uses.
|
|
// Don't bother loading others.
|
|
var names = [...]string{"abbrev", "info", "line", "str"}
|
|
var dat [len(names)][]byte
|
|
for i, name := range names {
|
|
name = ".debug_" + name
|
|
s := f.Section(name)
|
|
if s == nil {
|
|
continue
|
|
}
|
|
b, err := s.Data()
|
|
if err != nil && uint32(len(b)) < s.Size {
|
|
return nil, err
|
|
}
|
|
if 0 < s.VirtualSize && s.VirtualSize < s.Size {
|
|
b = b[:s.VirtualSize]
|
|
}
|
|
dat[i] = b
|
|
}
|
|
|
|
abbrev, info, line, str := dat[0], dat[1], dat[2], dat[3]
|
|
return dwarf.New(abbrev, nil, nil, info, line, nil, nil, str)
|
|
}
|
|
|
|
// ImportedSymbols returns the names of all symbols
|
|
// referred to by the binary f that are expected to be
|
|
// satisfied by other libraries at dynamic load time.
|
|
// It does not return weak symbols.
|
|
func (f *File) ImportedSymbols() ([]string, error) {
|
|
pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64
|
|
ds := f.Section(".idata")
|
|
if ds == nil {
|
|
// not dynamic, so no libraries
|
|
return nil, nil
|
|
}
|
|
d, err := ds.Data()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var ida []ImportDirectory
|
|
for len(d) > 0 {
|
|
var dt ImportDirectory
|
|
dt.OriginalFirstThunk = binary.LittleEndian.Uint32(d[0:4])
|
|
dt.Name = binary.LittleEndian.Uint32(d[12:16])
|
|
dt.FirstThunk = binary.LittleEndian.Uint32(d[16:20])
|
|
d = d[20:]
|
|
if dt.OriginalFirstThunk == 0 {
|
|
break
|
|
}
|
|
ida = append(ida, dt)
|
|
}
|
|
names, _ := ds.Data()
|
|
var all []string
|
|
for _, dt := range ida {
|
|
dt.dll, _ = getString(names, int(dt.Name-ds.VirtualAddress))
|
|
d, _ = ds.Data()
|
|
// seek to OriginalFirstThunk
|
|
d = d[dt.OriginalFirstThunk-ds.VirtualAddress:]
|
|
for len(d) > 0 {
|
|
if pe64 { // 64bit
|
|
va := binary.LittleEndian.Uint64(d[0:8])
|
|
d = d[8:]
|
|
if va == 0 {
|
|
break
|
|
}
|
|
if va&0x8000000000000000 > 0 { // is Ordinal
|
|
// TODO add dynimport ordinal support.
|
|
} else {
|
|
fn, _ := getString(names, int(uint32(va)-ds.VirtualAddress+2))
|
|
all = append(all, fn+":"+dt.dll)
|
|
}
|
|
} else { // 32bit
|
|
va := binary.LittleEndian.Uint32(d[0:4])
|
|
d = d[4:]
|
|
if va == 0 {
|
|
break
|
|
}
|
|
if va&0x80000000 > 0 { // is Ordinal
|
|
// TODO add dynimport ordinal support.
|
|
//ord := va&0x0000FFFF
|
|
} else {
|
|
fn, _ := getString(names, int(va-ds.VirtualAddress+2))
|
|
all = append(all, fn+":"+dt.dll)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return all, nil
|
|
}
|
|
|
|
// ImportedLibraries returns the names of all libraries
|
|
// referred to by the binary f that are expected to be
|
|
// linked with the binary at dynamic link time.
|
|
func (f *File) ImportedLibraries() ([]string, error) {
|
|
// TODO
|
|
// cgo -dynimport don't use this for windows PE, so just return.
|
|
return nil, nil
|
|
}
|