src

buildinfo.go (6049B)

---

 // Copyright 2021 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.
 
 //go:build go1.18
 
 package buildinfo
 
 // Addition: this file is a trimmed and slightly modified version of debug/buildinfo/buildinfo.go
 
 import (
 	"bytes"
 	"debug/elf"
 	"debug/macho"
 	"debug/pe"
 	"fmt"
 	"sync"
 
 	// "internal/xcoff"
 	"io"
 )
 
 // Addition: modification of rawBuildInfo in the original file.
 // openExe returns reader r as an exe.
 func openExe(r io.ReaderAt) (exe, error) {
 	data := make([]byte, 16)
 	if _, err := r.ReadAt(data, 0); err != nil {
 		return nil, err
 	}
 	if bytes.HasPrefix(data, []byte("\x7FELF")) {
 		e, err := elf.NewFile(r)
 		if err != nil {
 			return nil, err
 		}
 		return &elfExe{f: e}, nil
 	}
 	if bytes.HasPrefix(data, []byte("MZ")) {
 		e, err := pe.NewFile(r)
 		if err != nil {
 			return nil, err
 		}
 		return &peExe{r: r, f: e}, nil
 	}
 	if bytes.HasPrefix(data, []byte("\xFE\xED\xFA")) || bytes.HasPrefix(data[1:], []byte("\xFA\xED\xFE")) {
 		e, err := macho.NewFile(r)
 		if err != nil {
 			return nil, err
 		}
 		return &machoExe{f: e}, nil
 	}
 	return nil, fmt.Errorf("unrecognized executable format")
 }
 
 type exe interface {
 	// ReadData reads and returns up to size byte starting at virtual address addr.
 	ReadData(addr, size uint64) ([]byte, error)
 
 	// DataStart returns the virtual address of the segment or section that
 	// should contain build information. This is either a specially named section
 	// or the first writable non-zero data segment.
 	DataStart() uint64
 
 	PCLNTab() ([]byte, uint64) // Addition: for constructing symbol table
 
 	SymbolInfo(name string) (uint64, uint64, io.ReaderAt, error) // Addition: for inlining purposes
 }
 
 // elfExe is the ELF implementation of the exe interface.
 type elfExe struct {
 	f *elf.File
 
 	symbols     map[string]*elf.Symbol // Addition: symbols in the binary
 	symbolsOnce sync.Once              // Addition: for computing symbols
 	symbolsErr  error                  // Addition: error for computing symbols
 }
 
 func (x *elfExe) ReadData(addr, size uint64) ([]byte, error) {
 	for _, prog := range x.f.Progs {
 		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") // Addition: custom error
 }
 
 func (x *elfExe) DataStart() uint64 {
 	for _, s := range x.f.Sections {
 		if s.Name == ".go.buildinfo" {
 			return s.Addr
 		}
 	}
 	for _, p := range x.f.Progs {
 		if p.Type == elf.PT_LOAD && p.Flags&(elf.PF_X|elf.PF_W) == elf.PF_W {
 			return p.Vaddr
 		}
 	}
 	return 0
 }
 
 // peExe is the PE (Windows Portable Executable) implementation of the exe interface.
 type peExe struct {
 	r io.ReaderAt
 	f *pe.File
 
 	symbols     map[string]*pe.Symbol // Addition: symbols in the binary
 	symbolsOnce sync.Once             // Addition: for computing symbols
 	symbolsErr  error                 // Addition: error for computing symbols
 }
 
 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) ReadData(addr, size uint64) ([]byte, error) {
 	addr -= x.imageBase()
 	for _, sect := range x.f.Sections {
 		if uint64(sect.VirtualAddress) <= addr && addr <= uint64(sect.VirtualAddress+sect.Size-1) {
 			n := uint64(sect.VirtualAddress+sect.Size) - addr
 			if n > size {
 				n = size
 			}
 			data := make([]byte, n)
 			_, 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") // Addition: custom error
 }
 
 func (x *peExe) DataStart() uint64 {
 	// Assume data is first writable section.
 	const (
 		IMAGE_SCN_CNT_CODE               = 0x00000020
 		IMAGE_SCN_CNT_INITIALIZED_DATA   = 0x00000040
 		IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080
 		IMAGE_SCN_MEM_EXECUTE            = 0x20000000
 		IMAGE_SCN_MEM_READ               = 0x40000000
 		IMAGE_SCN_MEM_WRITE              = 0x80000000
 		IMAGE_SCN_MEM_DISCARDABLE        = 0x2000000
 		IMAGE_SCN_LNK_NRELOC_OVFL        = 0x1000000
 		IMAGE_SCN_ALIGN_32BYTES          = 0x600000
 	)
 	for _, sect := range x.f.Sections {
 		if sect.VirtualAddress != 0 && sect.Size != 0 &&
 			sect.Characteristics&^IMAGE_SCN_ALIGN_32BYTES == IMAGE_SCN_CNT_INITIALIZED_DATA|IMAGE_SCN_MEM_READ|IMAGE_SCN_MEM_WRITE {
 			return uint64(sect.VirtualAddress) + x.imageBase()
 		}
 	}
 	return 0
 }
 
 // machoExe is the Mach-O (Apple macOS/iOS) implementation of the exe interface.
 type machoExe struct {
 	f *macho.File
 
 	symbols     map[string]*macho.Symbol // Addition: symbols in the binary
 	symbolsOnce sync.Once                // Addition: for computing symbols
 	symbolsErr  error                    // Addition: error for computing symbols
 }
 
 func (x *machoExe) ReadData(addr, size uint64) ([]byte, error) {
 	for _, load := range x.f.Loads {
 		seg, ok := load.(*macho.Segment)
 		if !ok {
 			continue
 		}
 		if seg.Addr <= addr && addr <= seg.Addr+seg.Filesz-1 {
 			if seg.Name == "__PAGEZERO" {
 				continue
 			}
 			n := seg.Addr + seg.Filesz - addr
 			if n > size {
 				n = size
 			}
 			data := make([]byte, n)
 			_, err := seg.ReadAt(data, int64(addr-seg.Addr))
 			if err != nil {
 				return nil, err
 			}
 			return data, nil
 		}
 	}
 	return nil, fmt.Errorf("address not mapped") // Addition: custom error
 }
 
 func (x *machoExe) DataStart() uint64 {
 	// Look for section named "__go_buildinfo".
 	for _, sec := range x.f.Sections {
 		if sec.Name == "__go_buildinfo" {
 			return sec.Addr
 		}
 	}
 	// Try the first non-empty writable segment.
 	const RW = 3
 	for _, load := range x.f.Loads {
 		seg, ok := load.(*macho.Segment)
 		if ok && seg.Addr != 0 && seg.Filesz != 0 && seg.Prot == RW && seg.Maxprot == RW {
 			return seg.Addr
 		}
 	}
 	return 0
 }