src/debug/pe/file.go - go - Git at Google

 // 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"
 	"fmt"
 	"io"
 	"os"
 )

 // Avoid use of post-Go 1.4 io features, to make safe for toolchain bootstrap.
 const seekStart = 0

 // A File represents an open PE file.
 type File struct {
 	FileHeader
 	OptionalHeader interface{} // of type *OptionalHeader32 or *OptionalHeader64
 	Sections       []*Section
 	Symbols        []*Symbol    // COFF symbols with auxiliary symbol records removed
 	COFFSymbols    []COFFSymbol // all COFF symbols (including auxiliary symbol records)
 	StringTable    StringTable

 	closer io.Closer
 }

 // 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{}))
 )

 // TODO(brainman): add Load function, as a replacement for NewFile, that does not call removeAuxSymbols (for performance)

 // 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, fmt.Errorf("Invalid PE COFF file signature of %v.", sign)
 		}
 		base = signoff + 4
 	} else {
 		base = int64(0)
 	}
 	sr.Seek(base, seekStart)
 	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
 		return nil, err
 	}
 	switch f.FileHeader.Machine {
 	case IMAGE_FILE_MACHINE_UNKNOWN, IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_I386:
 	default:
 		return nil, fmt.Errorf("Unrecognised COFF file header machine value of 0x%x.", f.FileHeader.Machine)
 	}

 	var err error

 	// Read string table.
 	f.StringTable, err = readStringTable(&f.FileHeader, sr)
 	if err != nil {
 		return nil, err
 	}

 	// Read symbol table.
 	f.COFFSymbols, err = readCOFFSymbols(&f.FileHeader, sr)
 	if err != nil {
 		return nil, err
 	}
 	f.Symbols, err = removeAuxSymbols(f.COFFSymbols, f.StringTable)
 	if err != nil {
 		return nil, err
 	}

 	// Read optional header.
 	sr.Seek(base, seekStart)
 	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
 		}
 		name, err := sh.fullName(f.StringTable)
 		if err != nil {
 			return nil, err
 		}
 		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,
 		}
 		r2 := r
 		if sh.PointerToRawData == 0 { // .bss must have all 0s
 			r2 = zeroReaderAt{}
 		}
 		s.sr = io.NewSectionReader(r2, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))
 		s.ReaderAt = s.sr
 		f.Sections[i] = s
 	}
 	for i := range f.Sections {
 		var err error
 		f.Sections[i].Relocs, err = readRelocs(&f.Sections[i].SectionHeader, sr)
 		if err != nil {
 			return nil, err
 		}
 	}

 	return f, nil
 }

 // zeroReaderAt is ReaderAt that reads 0s.
 type zeroReaderAt struct{}

 // ReadAt writes len(p) 0s into p.
 func (w zeroReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
 	for i := range p {
 		p[i] = 0
 	}
 	return len(p), nil
 }

 // 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", "ranges", "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, ranges, str := dat[0], dat[1], dat[2], dat[3], dat[4]
 	return dwarf.New(abbrev, nil, nil, info, line, nil, ranges, str)
 }

 // TODO(brainman): document ImportDirectory once we decide what to do with it.

 type ImportDirectory struct {
 	OriginalFirstThunk uint32
 	TimeDateStamp      uint32
 	ForwarderChain     uint32
 	Name               uint32
 	FirstThunk         uint32

 	dll string
 }

 // 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)
 	}
 	// TODO(brainman): this needs to be rewritten
 	//  ds.Data() return contets of .idata section. Why store in variable called "names"?
 	//  Why we are retrieving it second time? We already have it in "d", and it is not modified anywhere.
 	//  getString does not extracts a string from symbol string table (as getString doco says).
 	//  Why ds.Data() called again and again in the loop?
 	//  Needs test before rewrite.
 	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
 }

 // FormatError is unused.
 // The type is retained for compatibility.
 type FormatError struct {
 }

 func (e *FormatError) Error() string {
 	return "unknown error"
 }
	// 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"
	"fmt"
	"io"
	"os"
	)

	// Avoid use of post-Go 1.4 io features, to make safe for toolchain bootstrap.
	const seekStart = 0

	// A File represents an open PE file.
	type File struct {
	FileHeader
	OptionalHeader interface{} // of type OptionalHeader32 or OptionalHeader64
	Sections []*Section
	Symbols []*Symbol // COFF symbols with auxiliary symbol records removed
	COFFSymbols []COFFSymbol // all COFF symbols (including auxiliary symbol records)
	StringTable StringTable

	closer io.Closer
	}

	// 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{}))
	)

	// TODO(brainman): add Load function, as a replacement for NewFile, that does not call removeAuxSymbols (for performance)

	// 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, fmt.Errorf("Invalid PE COFF file signature of %v.", sign)
	}
	base = signoff + 4
	} else {
	base = int64(0)
	}
	sr.Seek(base, seekStart)
	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
	return nil, err
	}
	switch f.FileHeader.Machine {
	case IMAGE_FILE_MACHINE_UNKNOWN, IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_I386:
	default:
	return nil, fmt.Errorf("Unrecognised COFF file header machine value of 0x%x.", f.FileHeader.Machine)
	}

	var err error

	// Read string table.
	f.StringTable, err = readStringTable(&f.FileHeader, sr)
	if err != nil {
	return nil, err
	}

	// Read symbol table.
	f.COFFSymbols, err = readCOFFSymbols(&f.FileHeader, sr)
	if err != nil {
	return nil, err
	}
	f.Symbols, err = removeAuxSymbols(f.COFFSymbols, f.StringTable)
	if err != nil {
	return nil, err
	}

	// Read optional header.
	sr.Seek(base, seekStart)
	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
	}
	name, err := sh.fullName(f.StringTable)
	if err != nil {
	return nil, err
	}
	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,
	}
	r2 := r
	if sh.PointerToRawData == 0 { // .bss must have all 0s
	r2 = zeroReaderAt{}
	}
	s.sr = io.NewSectionReader(r2, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))
	s.ReaderAt = s.sr
	f.Sections[i] = s
	}
	for i := range f.Sections {
	var err error
	f.Sections[i].Relocs, err = readRelocs(&f.Sections[i].SectionHeader, sr)
	if err != nil {
	return nil, err
	}
	}

	return f, nil
	}

	// zeroReaderAt is ReaderAt that reads 0s.
	type zeroReaderAt struct{}

	// ReadAt writes len(p) 0s into p.
	func (w zeroReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
	for i := range p {
	p[i] = 0
	}
	return len(p), nil
	}

	// 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", "ranges", "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, ranges, str := dat[0], dat[1], dat[2], dat[3], dat[4]
	return dwarf.New(abbrev, nil, nil, info, line, nil, ranges, str)
	}

	// TODO(brainman): document ImportDirectory once we decide what to do with it.

	type ImportDirectory struct {
	OriginalFirstThunk uint32
	TimeDateStamp uint32
	ForwarderChain uint32
	Name uint32
	FirstThunk uint32

	dll string
	}

	// 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)
	}
	// TODO(brainman): this needs to be rewritten
	// ds.Data() return contets of .idata section. Why store in variable called "names"?
	// Why we are retrieving it second time? We already have it in "d", and it is not modified anywhere.
	// getString does not extracts a string from symbol string table (as getString doco says).
	// Why ds.Data() called again and again in the loop?
	// Needs test before rewrite.
	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
	}

	// FormatError is unused.
	// The type is retained for compatibility.
	type FormatError struct {
	}

	func (e *FormatError) Error() string {
	return "unknown error"
	}