325 lines
7.0 KiB
Go
325 lines
7.0 KiB
Go
// Copyright 2017 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 goversion
|
|
|
|
import (
|
|
"bytes"
|
|
"debug/elf"
|
|
"debug/macho"
|
|
"debug/pe"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
)
|
|
|
|
type sym struct {
|
|
Name string
|
|
Addr uint64
|
|
Size uint64
|
|
}
|
|
|
|
type exe interface {
|
|
AddrSize() int // bytes
|
|
ReadData(addr, size uint64) ([]byte, error)
|
|
Symbols() ([]sym, error)
|
|
SectionNames() []string
|
|
Close() error
|
|
ByteOrder() binary.ByteOrder
|
|
Entry() uint64
|
|
TextRange() (uint64, uint64)
|
|
RODataRange() (uint64, uint64)
|
|
}
|
|
|
|
func openExe(file string) (exe, error) {
|
|
f, err := os.Open(file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
data := make([]byte, 16)
|
|
if _, err := io.ReadFull(f, data); err != nil {
|
|
return nil, err
|
|
}
|
|
f.Seek(0, 0)
|
|
if bytes.HasPrefix(data, []byte("\x7FELF")) {
|
|
e, err := elf.NewFile(f)
|
|
if err != nil {
|
|
f.Close()
|
|
return nil, err
|
|
}
|
|
return &elfExe{f, e}, nil
|
|
}
|
|
if bytes.HasPrefix(data, []byte("MZ")) {
|
|
e, err := pe.NewFile(f)
|
|
if err != nil {
|
|
f.Close()
|
|
return nil, err
|
|
}
|
|
return &peExe{f, e}, nil
|
|
}
|
|
if bytes.HasPrefix(data, []byte("\xFE\xED\xFA")) || bytes.HasPrefix(data[1:], []byte("\xFA\xED\xFE")) {
|
|
e, err := macho.NewFile(f)
|
|
if err != nil {
|
|
f.Close()
|
|
return nil, err
|
|
}
|
|
return &machoExe{f, e}, nil
|
|
}
|
|
return nil, fmt.Errorf("unrecognized executable format")
|
|
}
|
|
|
|
type elfExe struct {
|
|
os *os.File
|
|
f *elf.File
|
|
}
|
|
|
|
func (x *elfExe) AddrSize() int { return 0 }
|
|
|
|
func (x *elfExe) ByteOrder() binary.ByteOrder { return x.f.ByteOrder }
|
|
|
|
func (x *elfExe) Close() error {
|
|
return x.os.Close()
|
|
}
|
|
|
|
func (x *elfExe) Entry() uint64 { return x.f.Entry }
|
|
|
|
func (x *elfExe) ReadData(addr, size uint64) ([]byte, error) {
|
|
for _, prog := range x.f.Progs {
|
|
// The following line was commented from the original code.
|
|
//fmt.Printf("%#x %#x %#x\n", addr, prog.Vaddr, prog.Vaddr+prog.Filesz)
|
|
if prog.Vaddr <= addr && addr <= prog.Vaddr+prog.Filesz-1 {
|
|
n := prog.Vaddr + prog.Filesz - addr
|
|
if n > size {
|
|
n = size
|
|
}
|
|
data := make([]byte, n)
|
|
_, err := prog.ReadAt(data, int64(addr-prog.Vaddr))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("address not mapped")
|
|
}
|
|
|
|
func (x *elfExe) Symbols() ([]sym, error) {
|
|
syms, err := x.f.Symbols()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var out []sym
|
|
for _, s := range syms {
|
|
out = append(out, sym{s.Name, s.Value, s.Size})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (x *elfExe) SectionNames() []string {
|
|
var names []string
|
|
for _, sect := range x.f.Sections {
|
|
names = append(names, sect.Name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
func (x *elfExe) TextRange() (uint64, uint64) {
|
|
for _, p := range x.f.Progs {
|
|
if p.Type == elf.PT_LOAD && p.Flags&elf.PF_X != 0 {
|
|
return p.Vaddr, p.Vaddr + p.Filesz
|
|
}
|
|
}
|
|
return 0, 0
|
|
}
|
|
|
|
func (x *elfExe) RODataRange() (uint64, uint64) {
|
|
for _, p := range x.f.Progs {
|
|
if p.Type == elf.PT_LOAD && p.Flags&(elf.PF_R|elf.PF_W|elf.PF_X) == elf.PF_R {
|
|
return p.Vaddr, p.Vaddr + p.Filesz
|
|
}
|
|
}
|
|
for _, p := range x.f.Progs {
|
|
if p.Type == elf.PT_LOAD && p.Flags&(elf.PF_R|elf.PF_W|elf.PF_X) == (elf.PF_R|elf.PF_X) {
|
|
return p.Vaddr, p.Vaddr + p.Filesz
|
|
}
|
|
}
|
|
return 0, 0
|
|
}
|
|
|
|
type peExe struct {
|
|
os *os.File
|
|
f *pe.File
|
|
}
|
|
|
|
func (x *peExe) imageBase() uint64 {
|
|
switch oh := x.f.OptionalHeader.(type) {
|
|
case *pe.OptionalHeader32:
|
|
return uint64(oh.ImageBase)
|
|
case *pe.OptionalHeader64:
|
|
return oh.ImageBase
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *peExe) AddrSize() int {
|
|
if x.f.Machine == pe.IMAGE_FILE_MACHINE_AMD64 {
|
|
return 8
|
|
}
|
|
return 4
|
|
}
|
|
|
|
func (x *peExe) ByteOrder() binary.ByteOrder { return binary.LittleEndian }
|
|
|
|
func (x *peExe) Close() error {
|
|
return x.os.Close()
|
|
}
|
|
|
|
func (x *peExe) Entry() uint64 {
|
|
switch oh := x.f.OptionalHeader.(type) {
|
|
case *pe.OptionalHeader32:
|
|
return uint64(oh.ImageBase + oh.AddressOfEntryPoint)
|
|
case *pe.OptionalHeader64:
|
|
return oh.ImageBase + uint64(oh.AddressOfEntryPoint)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *peExe) ReadData(addr, size uint64) ([]byte, error) {
|
|
addr -= x.imageBase()
|
|
data := make([]byte, size)
|
|
for _, sect := range x.f.Sections {
|
|
if uint64(sect.VirtualAddress) <= addr && addr+size-1 <= uint64(sect.VirtualAddress+sect.Size-1) {
|
|
_, err := sect.ReadAt(data, int64(addr-uint64(sect.VirtualAddress)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("address not mapped")
|
|
}
|
|
|
|
func (x *peExe) Symbols() ([]sym, error) {
|
|
base := x.imageBase()
|
|
var out []sym
|
|
for _, s := range x.f.Symbols {
|
|
if s.SectionNumber <= 0 || int(s.SectionNumber) > len(x.f.Sections) {
|
|
continue
|
|
}
|
|
sect := x.f.Sections[s.SectionNumber-1]
|
|
out = append(out, sym{s.Name, uint64(s.Value) + base + uint64(sect.VirtualAddress), 0})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (x *peExe) SectionNames() []string {
|
|
var names []string
|
|
for _, sect := range x.f.Sections {
|
|
names = append(names, sect.Name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
func (x *peExe) TextRange() (uint64, uint64) {
|
|
// Assume text is first non-empty section.
|
|
for _, sect := range x.f.Sections {
|
|
if sect.VirtualAddress != 0 && sect.Size != 0 {
|
|
return uint64(sect.VirtualAddress) + x.imageBase(), uint64(sect.VirtualAddress+sect.Size) + x.imageBase()
|
|
}
|
|
}
|
|
return 0, 0
|
|
}
|
|
|
|
func (x *peExe) RODataRange() (uint64, uint64) {
|
|
return x.TextRange()
|
|
}
|
|
|
|
type machoExe struct {
|
|
os *os.File
|
|
f *macho.File
|
|
}
|
|
|
|
func (x *machoExe) AddrSize() int {
|
|
if x.f.Cpu&0x01000000 != 0 {
|
|
return 8
|
|
}
|
|
return 4
|
|
}
|
|
|
|
func (x *machoExe) ByteOrder() binary.ByteOrder { return x.f.ByteOrder }
|
|
|
|
func (x *machoExe) Close() error {
|
|
return x.os.Close()
|
|
}
|
|
|
|
func (x *machoExe) Entry() uint64 {
|
|
for _, load := range x.f.Loads {
|
|
b, ok := load.(macho.LoadBytes)
|
|
if !ok {
|
|
continue
|
|
}
|
|
// TODO: Other thread states.
|
|
bo := x.f.ByteOrder
|
|
const x86_THREAD_STATE64 = 4
|
|
cmd, siz := macho.LoadCmd(bo.Uint32(b[0:4])), bo.Uint32(b[4:8])
|
|
if cmd == macho.LoadCmdUnixThread && siz == 184 && bo.Uint32(b[8:12]) == x86_THREAD_STATE64 {
|
|
return bo.Uint64(b[144:])
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *machoExe) ReadData(addr, size uint64) ([]byte, error) {
|
|
data := make([]byte, size)
|
|
for _, load := range x.f.Loads {
|
|
seg, ok := load.(*macho.Segment)
|
|
if !ok {
|
|
continue
|
|
}
|
|
if seg.Addr <= addr && addr+size-1 <= seg.Addr+seg.Filesz-1 {
|
|
if seg.Name == "__PAGEZERO" {
|
|
continue
|
|
}
|
|
_, err := seg.ReadAt(data, int64(addr-seg.Addr))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("address not mapped")
|
|
}
|
|
|
|
func (x *machoExe) Symbols() ([]sym, error) {
|
|
var out []sym
|
|
for _, s := range x.f.Symtab.Syms {
|
|
out = append(out, sym{s.Name, s.Value, 0})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (x *machoExe) SectionNames() []string {
|
|
var names []string
|
|
for _, sect := range x.f.Sections {
|
|
names = append(names, sect.Name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
func (x *machoExe) TextRange() (uint64, uint64) {
|
|
// Assume text is first non-empty segment.
|
|
for _, load := range x.f.Loads {
|
|
seg, ok := load.(*macho.Segment)
|
|
if ok && seg.Name != "__PAGEZERO" && seg.Addr != 0 && seg.Filesz != 0 {
|
|
return seg.Addr, seg.Addr + seg.Filesz
|
|
}
|
|
}
|
|
return 0, 0
|
|
}
|
|
|
|
func (x *machoExe) RODataRange() (uint64, uint64) {
|
|
return x.TextRange()
|
|
}
|