1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Package elf implements access to ELF object files. 6 package elf 7 8 import ( 9 "bytes" 10 "compress/zlib" 11 "debug/dwarf" 12 "encoding/binary" 13 "errors" 14 "fmt" 15 "io" 16 "os" 17 "strings" 18 ) 19 20 // seekStart, seekCurrent, seekEnd are copies of 21 // io.SeekStart, io.SeekCurrent, and io.SeekEnd. 22 // We can't use the ones from package io because 23 // we want this code to build with Go 1.4 during 24 // cmd/dist bootstrap. 25 const ( 26 seekStart int = 0 27 seekCurrent int = 1 28 seekEnd int = 2 29 ) 30 31 // TODO: error reporting detail 32 33 /* 34 * Internal ELF representation 35 */ 36 37 // A FileHeader represents an ELF file header. 38 type FileHeader struct { 39 Class Class 40 Data Data 41 Version Version 42 OSABI OSABI 43 ABIVersion uint8 44 ByteOrder binary.ByteOrder 45 Type Type 46 Machine Machine 47 Entry uint64 48 } 49 50 // A File represents an open ELF file. 51 type File struct { 52 FileHeader 53 Sections []*Section 54 Progs []*Prog 55 closer io.Closer 56 gnuNeed []verneed 57 gnuVersym []byte 58 } 59 60 // A SectionHeader represents a single ELF section header. 61 type SectionHeader struct { 62 Name string 63 Type SectionType 64 Flags SectionFlag 65 Addr uint64 66 Offset uint64 67 Size uint64 68 Link uint32 69 Info uint32 70 Addralign uint64 71 Entsize uint64 72 73 // FileSize is the size of this section in the file in bytes. 74 // If a section is compressed, FileSize is the size of the 75 // compressed data, while Size (above) is the size of the 76 // uncompressed data. 77 FileSize uint64 78 } 79 80 // A Section represents a single section in an ELF file. 81 type Section struct { 82 SectionHeader 83 84 // Embed ReaderAt for ReadAt method. 85 // Do not embed SectionReader directly 86 // to avoid having Read and Seek. 87 // If a client wants Read and Seek it must use 88 // Open() to avoid fighting over the seek offset 89 // with other clients. 90 // 91 // ReaderAt may be nil if the section is not easily available 92 // in a random-access form. For example, a compressed section 93 // may have a nil ReaderAt. 94 io.ReaderAt 95 sr *io.SectionReader 96 97 compressionType CompressionType 98 compressionOffset int64 99 } 100 101 // Data reads and returns the contents of the ELF section. 102 // Even if the section is stored compressed in the ELF file, 103 // Data returns uncompressed data. 104 func (s *Section) Data() ([]byte, error) { 105 dat := make([]byte, s.Size) 106 n, err := io.ReadFull(s.Open(), dat) 107 return dat[0:n], err 108 } 109 110 // stringTable reads and returns the string table given by the 111 // specified link value. 112 func (f *File) stringTable(link uint32) ([]byte, error) { 113 if link <= 0 || link >= uint32(len(f.Sections)) { 114 return nil, errors.New("section has invalid string table link") 115 } 116 return f.Sections[link].Data() 117 } 118 119 // Open returns a new ReadSeeker reading the ELF section. 120 // Even if the section is stored compressed in the ELF file, 121 // the ReadSeeker reads uncompressed data. 122 func (s *Section) Open() io.ReadSeeker { 123 if s.Flags&SHF_COMPRESSED == 0 { 124 return io.NewSectionReader(s.sr, 0, 1<<63-1) 125 } 126 if s.compressionType == COMPRESS_ZLIB { 127 return &readSeekerFromReader{ 128 reset: func() (io.Reader, error) { 129 fr := io.NewSectionReader(s.sr, s.compressionOffset, int64(s.FileSize)-s.compressionOffset) 130 return zlib.NewReader(fr) 131 }, 132 size: int64(s.Size), 133 } 134 } 135 err := &FormatError{int64(s.Offset), "unknown compression type", s.compressionType} 136 return errorReader{err} 137 } 138 139 // A ProgHeader represents a single ELF program header. 140 type ProgHeader struct { 141 Type ProgType 142 Flags ProgFlag 143 Off uint64 144 Vaddr uint64 145 Paddr uint64 146 Filesz uint64 147 Memsz uint64 148 Align uint64 149 } 150 151 // A Prog represents a single ELF program header in an ELF binary. 152 type Prog struct { 153 ProgHeader 154 155 // Embed ReaderAt for ReadAt method. 156 // Do not embed SectionReader directly 157 // to avoid having Read and Seek. 158 // If a client wants Read and Seek it must use 159 // Open() to avoid fighting over the seek offset 160 // with other clients. 161 io.ReaderAt 162 sr *io.SectionReader 163 } 164 165 // Open returns a new ReadSeeker reading the ELF program body. 166 func (p *Prog) Open() io.ReadSeeker { return io.NewSectionReader(p.sr, 0, 1<<63-1) } 167 168 // A Symbol represents an entry in an ELF symbol table section. 169 type Symbol struct { 170 Name string 171 Info, Other byte 172 Section SectionIndex 173 Value, Size uint64 174 } 175 176 /* 177 * ELF reader 178 */ 179 180 type FormatError struct { 181 off int64 182 msg string 183 val interface{} 184 } 185 186 func (e *FormatError) Error() string { 187 msg := e.msg 188 if e.val != nil { 189 msg += fmt.Sprintf(" '%v' ", e.val) 190 } 191 msg += fmt.Sprintf("in record at byte %#x", e.off) 192 return msg 193 } 194 195 // Open opens the named file using os.Open and prepares it for use as an ELF binary. 196 func Open(name string) (*File, error) { 197 f, err := os.Open(name) 198 if err != nil { 199 return nil, err 200 } 201 ff, err := NewFile(f) 202 if err != nil { 203 f.Close() 204 return nil, err 205 } 206 ff.closer = f 207 return ff, nil 208 } 209 210 // Close closes the File. 211 // If the File was created using NewFile directly instead of Open, 212 // Close has no effect. 213 func (f *File) Close() error { 214 var err error 215 if f.closer != nil { 216 err = f.closer.Close() 217 f.closer = nil 218 } 219 return err 220 } 221 222 // SectionByType returns the first section in f with the 223 // given type, or nil if there is no such section. 224 func (f *File) SectionByType(typ SectionType) *Section { 225 for _, s := range f.Sections { 226 if s.Type == typ { 227 return s 228 } 229 } 230 return nil 231 } 232 233 // NewFile creates a new File for accessing an ELF binary in an underlying reader. 234 // The ELF binary is expected to start at position 0 in the ReaderAt. 235 func NewFile(r io.ReaderAt) (*File, error) { 236 sr := io.NewSectionReader(r, 0, 1<<63-1) 237 // Read and decode ELF identifier 238 var ident [16]uint8 239 if _, err := r.ReadAt(ident[0:], 0); err != nil { 240 return nil, err 241 } 242 if ident[0] != '\x7f' || ident[1] != 'E' || ident[2] != 'L' || ident[3] != 'F' { 243 return nil, &FormatError{0, "bad magic number", ident[0:4]} 244 } 245 246 f := new(File) 247 f.Class = Class(ident[EI_CLASS]) 248 switch f.Class { 249 case ELFCLASS32: 250 case ELFCLASS64: 251 // ok 252 default: 253 return nil, &FormatError{0, "unknown ELF class", f.Class} 254 } 255 256 f.Data = Data(ident[EI_DATA]) 257 switch f.Data { 258 case ELFDATA2LSB: 259 f.ByteOrder = binary.LittleEndian 260 case ELFDATA2MSB: 261 f.ByteOrder = binary.BigEndian 262 default: 263 return nil, &FormatError{0, "unknown ELF data encoding", f.Data} 264 } 265 266 f.Version = Version(ident[EI_VERSION]) 267 if f.Version != EV_CURRENT { 268 return nil, &FormatError{0, "unknown ELF version", f.Version} 269 } 270 271 f.OSABI = OSABI(ident[EI_OSABI]) 272 f.ABIVersion = ident[EI_ABIVERSION] 273 274 // Read ELF file header 275 var phoff int64 276 var phentsize, phnum int 277 var shoff int64 278 var shentsize, shnum, shstrndx int 279 shstrndx = -1 280 switch f.Class { 281 case ELFCLASS32: 282 hdr := new(Header32) 283 sr.Seek(0, seekStart) 284 if err := binary.Read(sr, f.ByteOrder, hdr); err != nil { 285 return nil, err 286 } 287 f.Type = Type(hdr.Type) 288 f.Machine = Machine(hdr.Machine) 289 f.Entry = uint64(hdr.Entry) 290 if v := Version(hdr.Version); v != f.Version { 291 return nil, &FormatError{0, "mismatched ELF version", v} 292 } 293 phoff = int64(hdr.Phoff) 294 phentsize = int(hdr.Phentsize) 295 phnum = int(hdr.Phnum) 296 shoff = int64(hdr.Shoff) 297 shentsize = int(hdr.Shentsize) 298 shnum = int(hdr.Shnum) 299 shstrndx = int(hdr.Shstrndx) 300 case ELFCLASS64: 301 hdr := new(Header64) 302 sr.Seek(0, seekStart) 303 if err := binary.Read(sr, f.ByteOrder, hdr); err != nil { 304 return nil, err 305 } 306 f.Type = Type(hdr.Type) 307 f.Machine = Machine(hdr.Machine) 308 f.Entry = hdr.Entry 309 if v := Version(hdr.Version); v != f.Version { 310 return nil, &FormatError{0, "mismatched ELF version", v} 311 } 312 phoff = int64(hdr.Phoff) 313 phentsize = int(hdr.Phentsize) 314 phnum = int(hdr.Phnum) 315 shoff = int64(hdr.Shoff) 316 shentsize = int(hdr.Shentsize) 317 shnum = int(hdr.Shnum) 318 shstrndx = int(hdr.Shstrndx) 319 } 320 321 if shnum > 0 && shoff > 0 && (shstrndx < 0 || shstrndx >= shnum) { 322 return nil, &FormatError{0, "invalid ELF shstrndx", shstrndx} 323 } 324 325 // Read program headers 326 f.Progs = make([]*Prog, phnum) 327 for i := 0; i < phnum; i++ { 328 off := phoff + int64(i)*int64(phentsize) 329 sr.Seek(off, seekStart) 330 p := new(Prog) 331 switch f.Class { 332 case ELFCLASS32: 333 ph := new(Prog32) 334 if err := binary.Read(sr, f.ByteOrder, ph); err != nil { 335 return nil, err 336 } 337 p.ProgHeader = ProgHeader{ 338 Type: ProgType(ph.Type), 339 Flags: ProgFlag(ph.Flags), 340 Off: uint64(ph.Off), 341 Vaddr: uint64(ph.Vaddr), 342 Paddr: uint64(ph.Paddr), 343 Filesz: uint64(ph.Filesz), 344 Memsz: uint64(ph.Memsz), 345 Align: uint64(ph.Align), 346 } 347 case ELFCLASS64: 348 ph := new(Prog64) 349 if err := binary.Read(sr, f.ByteOrder, ph); err != nil { 350 return nil, err 351 } 352 p.ProgHeader = ProgHeader{ 353 Type: ProgType(ph.Type), 354 Flags: ProgFlag(ph.Flags), 355 Off: ph.Off, 356 Vaddr: ph.Vaddr, 357 Paddr: ph.Paddr, 358 Filesz: ph.Filesz, 359 Memsz: ph.Memsz, 360 Align: ph.Align, 361 } 362 } 363 p.sr = io.NewSectionReader(r, int64(p.Off), int64(p.Filesz)) 364 p.ReaderAt = p.sr 365 f.Progs[i] = p 366 } 367 368 // Read section headers 369 f.Sections = make([]*Section, shnum) 370 names := make([]uint32, shnum) 371 for i := 0; i < shnum; i++ { 372 off := shoff + int64(i)*int64(shentsize) 373 sr.Seek(off, seekStart) 374 s := new(Section) 375 switch f.Class { 376 case ELFCLASS32: 377 sh := new(Section32) 378 if err := binary.Read(sr, f.ByteOrder, sh); err != nil { 379 return nil, err 380 } 381 names[i] = sh.Name 382 s.SectionHeader = SectionHeader{ 383 Type: SectionType(sh.Type), 384 Flags: SectionFlag(sh.Flags), 385 Addr: uint64(sh.Addr), 386 Offset: uint64(sh.Off), 387 FileSize: uint64(sh.Size), 388 Link: sh.Link, 389 Info: sh.Info, 390 Addralign: uint64(sh.Addralign), 391 Entsize: uint64(sh.Entsize), 392 } 393 case ELFCLASS64: 394 sh := new(Section64) 395 if err := binary.Read(sr, f.ByteOrder, sh); err != nil { 396 return nil, err 397 } 398 names[i] = sh.Name 399 s.SectionHeader = SectionHeader{ 400 Type: SectionType(sh.Type), 401 Flags: SectionFlag(sh.Flags), 402 Offset: sh.Off, 403 FileSize: sh.Size, 404 Addr: sh.Addr, 405 Link: sh.Link, 406 Info: sh.Info, 407 Addralign: sh.Addralign, 408 Entsize: sh.Entsize, 409 } 410 } 411 s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.FileSize)) 412 413 if s.Flags&SHF_COMPRESSED == 0 { 414 s.ReaderAt = s.sr 415 s.Size = s.FileSize 416 } else { 417 // Read the compression header. 418 switch f.Class { 419 case ELFCLASS32: 420 ch := new(Chdr32) 421 if err := binary.Read(s.sr, f.ByteOrder, ch); err != nil { 422 return nil, err 423 } 424 s.compressionType = CompressionType(ch.Type) 425 s.Size = uint64(ch.Size) 426 s.Addralign = uint64(ch.Addralign) 427 s.compressionOffset = int64(binary.Size(ch)) 428 case ELFCLASS64: 429 ch := new(Chdr64) 430 if err := binary.Read(s.sr, f.ByteOrder, ch); err != nil { 431 return nil, err 432 } 433 s.compressionType = CompressionType(ch.Type) 434 s.Size = ch.Size 435 s.Addralign = ch.Addralign 436 s.compressionOffset = int64(binary.Size(ch)) 437 } 438 } 439 440 f.Sections[i] = s 441 } 442 443 if len(f.Sections) == 0 { 444 return f, nil 445 } 446 447 // Load section header string table. 448 shstrtab, err := f.Sections[shstrndx].Data() 449 if err != nil { 450 return nil, err 451 } 452 for i, s := range f.Sections { 453 var ok bool 454 s.Name, ok = getString(shstrtab, int(names[i])) 455 if !ok { 456 return nil, &FormatError{shoff + int64(i*shentsize), "bad section name index", names[i]} 457 } 458 } 459 460 return f, nil 461 } 462 463 // getSymbols returns a slice of Symbols from parsing the symbol table 464 // with the given type, along with the associated string table. 465 func (f *File) getSymbols(typ SectionType) ([]Symbol, []byte, error) { 466 switch f.Class { 467 case ELFCLASS64: 468 return f.getSymbols64(typ) 469 470 case ELFCLASS32: 471 return f.getSymbols32(typ) 472 } 473 474 return nil, nil, errors.New("not implemented") 475 } 476 477 // ErrNoSymbols is returned by File.Symbols and File.DynamicSymbols 478 // if there is no such section in the File. 479 var ErrNoSymbols = errors.New("no symbol section") 480 481 func (f *File) getSymbols32(typ SectionType) ([]Symbol, []byte, error) { 482 symtabSection := f.SectionByType(typ) 483 if symtabSection == nil { 484 return nil, nil, ErrNoSymbols 485 } 486 487 data, err := symtabSection.Data() 488 if err != nil { 489 return nil, nil, errors.New("cannot load symbol section") 490 } 491 symtab := bytes.NewReader(data) 492 if symtab.Len()%Sym32Size != 0 { 493 return nil, nil, errors.New("length of symbol section is not a multiple of SymSize") 494 } 495 496 strdata, err := f.stringTable(symtabSection.Link) 497 if err != nil { 498 return nil, nil, errors.New("cannot load string table section") 499 } 500 501 // The first entry is all zeros. 502 var skip [Sym32Size]byte 503 symtab.Read(skip[:]) 504 505 symbols := make([]Symbol, symtab.Len()/Sym32Size) 506 507 i := 0 508 var sym Sym32 509 for symtab.Len() > 0 { 510 binary.Read(symtab, f.ByteOrder, &sym) 511 str, _ := getString(strdata, int(sym.Name)) 512 symbols[i].Name = str 513 symbols[i].Info = sym.Info 514 symbols[i].Other = sym.Other 515 symbols[i].Section = SectionIndex(sym.Shndx) 516 symbols[i].Value = uint64(sym.Value) 517 symbols[i].Size = uint64(sym.Size) 518 i++ 519 } 520 521 return symbols, strdata, nil 522 } 523 524 func (f *File) getSymbols64(typ SectionType) ([]Symbol, []byte, error) { 525 symtabSection := f.SectionByType(typ) 526 if symtabSection == nil { 527 return nil, nil, ErrNoSymbols 528 } 529 530 data, err := symtabSection.Data() 531 if err != nil { 532 return nil, nil, errors.New("cannot load symbol section") 533 } 534 symtab := bytes.NewReader(data) 535 if symtab.Len()%Sym64Size != 0 { 536 return nil, nil, errors.New("length of symbol section is not a multiple of Sym64Size") 537 } 538 539 strdata, err := f.stringTable(symtabSection.Link) 540 if err != nil { 541 return nil, nil, errors.New("cannot load string table section") 542 } 543 544 // The first entry is all zeros. 545 var skip [Sym64Size]byte 546 symtab.Read(skip[:]) 547 548 symbols := make([]Symbol, symtab.Len()/Sym64Size) 549 550 i := 0 551 var sym Sym64 552 for symtab.Len() > 0 { 553 binary.Read(symtab, f.ByteOrder, &sym) 554 str, _ := getString(strdata, int(sym.Name)) 555 symbols[i].Name = str 556 symbols[i].Info = sym.Info 557 symbols[i].Other = sym.Other 558 symbols[i].Section = SectionIndex(sym.Shndx) 559 symbols[i].Value = sym.Value 560 symbols[i].Size = sym.Size 561 i++ 562 } 563 564 return symbols, strdata, nil 565 } 566 567 // getString extracts a string from an ELF string table. 568 func getString(section []byte, start int) (string, bool) { 569 if start < 0 || start >= len(section) { 570 return "", false 571 } 572 573 for end := start; end < len(section); end++ { 574 if section[end] == 0 { 575 return string(section[start:end]), true 576 } 577 } 578 return "", false 579 } 580 581 // Section returns a section with the given name, or nil if no such 582 // section exists. 583 func (f *File) Section(name string) *Section { 584 for _, s := range f.Sections { 585 if s.Name == name { 586 return s 587 } 588 } 589 return nil 590 } 591 592 // applyRelocations applies relocations to dst. rels is a relocations section 593 // in REL or RELA format. 594 func (f *File) applyRelocations(dst []byte, rels []byte) error { 595 switch { 596 case f.Class == ELFCLASS64 && f.Machine == EM_X86_64: 597 return f.applyRelocationsAMD64(dst, rels) 598 case f.Class == ELFCLASS32 && f.Machine == EM_386: 599 return f.applyRelocations386(dst, rels) 600 case f.Class == ELFCLASS32 && f.Machine == EM_ARM: 601 return f.applyRelocationsARM(dst, rels) 602 case f.Class == ELFCLASS64 && f.Machine == EM_AARCH64: 603 return f.applyRelocationsARM64(dst, rels) 604 case f.Class == ELFCLASS32 && f.Machine == EM_PPC: 605 return f.applyRelocationsPPC(dst, rels) 606 case f.Class == ELFCLASS64 && f.Machine == EM_PPC64: 607 return f.applyRelocationsPPC64(dst, rels) 608 case f.Class == ELFCLASS32 && f.Machine == EM_MIPS: 609 return f.applyRelocationsMIPS(dst, rels) 610 case f.Class == ELFCLASS64 && f.Machine == EM_MIPS: 611 return f.applyRelocationsMIPS64(dst, rels) 612 case f.Class == ELFCLASS64 && f.Machine == EM_RISCV: 613 return f.applyRelocationsRISCV64(dst, rels) 614 case f.Class == ELFCLASS64 && f.Machine == EM_S390: 615 return f.applyRelocationss390x(dst, rels) 616 case f.Class == ELFCLASS64 && f.Machine == EM_SPARCV9: 617 return f.applyRelocationsSPARC64(dst, rels) 618 default: 619 return errors.New("applyRelocations: not implemented") 620 } 621 } 622 623 func (f *File) applyRelocationsAMD64(dst []byte, rels []byte) error { 624 // 24 is the size of Rela64. 625 if len(rels)%24 != 0 { 626 return errors.New("length of relocation section is not a multiple of 24") 627 } 628 629 symbols, _, err := f.getSymbols(SHT_SYMTAB) 630 if err != nil { 631 return err 632 } 633 634 b := bytes.NewReader(rels) 635 var rela Rela64 636 637 for b.Len() > 0 { 638 binary.Read(b, f.ByteOrder, &rela) 639 symNo := rela.Info >> 32 640 t := R_X86_64(rela.Info & 0xffff) 641 642 if symNo == 0 || symNo > uint64(len(symbols)) { 643 continue 644 } 645 sym := &symbols[symNo-1] 646 if SymType(sym.Info&0xf) != STT_SECTION { 647 // We don't handle non-section relocations for now. 648 continue 649 } 650 651 // There are relocations, so this must be a normal 652 // object file, and we only look at section symbols, 653 // so we assume that the symbol value is 0. 654 655 switch t { 656 case R_X86_64_64: 657 if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { 658 continue 659 } 660 f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend)) 661 case R_X86_64_32: 662 if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { 663 continue 664 } 665 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)) 666 } 667 } 668 669 return nil 670 } 671 672 func (f *File) applyRelocations386(dst []byte, rels []byte) error { 673 // 8 is the size of Rel32. 674 if len(rels)%8 != 0 { 675 return errors.New("length of relocation section is not a multiple of 8") 676 } 677 678 symbols, _, err := f.getSymbols(SHT_SYMTAB) 679 if err != nil { 680 return err 681 } 682 683 b := bytes.NewReader(rels) 684 var rel Rel32 685 686 for b.Len() > 0 { 687 binary.Read(b, f.ByteOrder, &rel) 688 symNo := rel.Info >> 8 689 t := R_386(rel.Info & 0xff) 690 691 if symNo == 0 || symNo > uint32(len(symbols)) { 692 continue 693 } 694 sym := &symbols[symNo-1] 695 696 if t == R_386_32 { 697 if rel.Off+4 >= uint32(len(dst)) { 698 continue 699 } 700 val := f.ByteOrder.Uint32(dst[rel.Off : rel.Off+4]) 701 val += uint32(sym.Value) 702 f.ByteOrder.PutUint32(dst[rel.Off:rel.Off+4], val) 703 } 704 } 705 706 return nil 707 } 708 709 func (f *File) applyRelocationsARM(dst []byte, rels []byte) error { 710 // 8 is the size of Rel32. 711 if len(rels)%8 != 0 { 712 return errors.New("length of relocation section is not a multiple of 8") 713 } 714 715 symbols, _, err := f.getSymbols(SHT_SYMTAB) 716 if err != nil { 717 return err 718 } 719 720 b := bytes.NewReader(rels) 721 var rel Rel32 722 723 for b.Len() > 0 { 724 binary.Read(b, f.ByteOrder, &rel) 725 symNo := rel.Info >> 8 726 t := R_ARM(rel.Info & 0xff) 727 728 if symNo == 0 || symNo > uint32(len(symbols)) { 729 continue 730 } 731 sym := &symbols[symNo-1] 732 733 switch t { 734 case R_ARM_ABS32: 735 if rel.Off+4 >= uint32(len(dst)) { 736 continue 737 } 738 val := f.ByteOrder.Uint32(dst[rel.Off : rel.Off+4]) 739 val += uint32(sym.Value) 740 f.ByteOrder.PutUint32(dst[rel.Off:rel.Off+4], val) 741 } 742 } 743 744 return nil 745 } 746 747 func (f *File) applyRelocationsARM64(dst []byte, rels []byte) error { 748 // 24 is the size of Rela64. 749 if len(rels)%24 != 0 { 750 return errors.New("length of relocation section is not a multiple of 24") 751 } 752 753 symbols, _, err := f.getSymbols(SHT_SYMTAB) 754 if err != nil { 755 return err 756 } 757 758 b := bytes.NewReader(rels) 759 var rela Rela64 760 761 for b.Len() > 0 { 762 binary.Read(b, f.ByteOrder, &rela) 763 symNo := rela.Info >> 32 764 t := R_AARCH64(rela.Info & 0xffff) 765 766 if symNo == 0 || symNo > uint64(len(symbols)) { 767 continue 768 } 769 sym := &symbols[symNo-1] 770 if SymType(sym.Info&0xf) != STT_SECTION { 771 // We don't handle non-section relocations for now. 772 continue 773 } 774 775 // There are relocations, so this must be a normal 776 // object file, and we only look at section symbols, 777 // so we assume that the symbol value is 0. 778 779 switch t { 780 case R_AARCH64_ABS64: 781 if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { 782 continue 783 } 784 f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend)) 785 case R_AARCH64_ABS32: 786 if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { 787 continue 788 } 789 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)) 790 } 791 } 792 793 return nil 794 } 795 796 func (f *File) applyRelocationsPPC(dst []byte, rels []byte) error { 797 // 12 is the size of Rela32. 798 if len(rels)%12 != 0 { 799 return errors.New("length of relocation section is not a multiple of 12") 800 } 801 802 symbols, _, err := f.getSymbols(SHT_SYMTAB) 803 if err != nil { 804 return err 805 } 806 807 b := bytes.NewReader(rels) 808 var rela Rela32 809 810 for b.Len() > 0 { 811 binary.Read(b, f.ByteOrder, &rela) 812 symNo := rela.Info >> 8 813 t := R_PPC(rela.Info & 0xff) 814 815 if symNo == 0 || symNo > uint32(len(symbols)) { 816 continue 817 } 818 sym := &symbols[symNo-1] 819 if SymType(sym.Info&0xf) != STT_SECTION { 820 // We don't handle non-section relocations for now. 821 continue 822 } 823 824 switch t { 825 case R_PPC_ADDR32: 826 if rela.Off+4 >= uint32(len(dst)) || rela.Addend < 0 { 827 continue 828 } 829 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)) 830 } 831 } 832 833 return nil 834 } 835 836 func (f *File) applyRelocationsPPC64(dst []byte, rels []byte) error { 837 // 24 is the size of Rela64. 838 if len(rels)%24 != 0 { 839 return errors.New("length of relocation section is not a multiple of 24") 840 } 841 842 symbols, _, err := f.getSymbols(SHT_SYMTAB) 843 if err != nil { 844 return err 845 } 846 847 b := bytes.NewReader(rels) 848 var rela Rela64 849 850 for b.Len() > 0 { 851 binary.Read(b, f.ByteOrder, &rela) 852 symNo := rela.Info >> 32 853 t := R_PPC64(rela.Info & 0xffff) 854 855 if symNo == 0 || symNo > uint64(len(symbols)) { 856 continue 857 } 858 sym := &symbols[symNo-1] 859 if SymType(sym.Info&0xf) != STT_SECTION { 860 // We don't handle non-section relocations for now. 861 continue 862 } 863 864 switch t { 865 case R_PPC64_ADDR64: 866 if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { 867 continue 868 } 869 f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend)) 870 case R_PPC64_ADDR32: 871 if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { 872 continue 873 } 874 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)) 875 } 876 } 877 878 return nil 879 } 880 881 func (f *File) applyRelocationsMIPS(dst []byte, rels []byte) error { 882 // 8 is the size of Rel32. 883 if len(rels)%8 != 0 { 884 return errors.New("length of relocation section is not a multiple of 8") 885 } 886 887 symbols, _, err := f.getSymbols(SHT_SYMTAB) 888 if err != nil { 889 return err 890 } 891 892 b := bytes.NewReader(rels) 893 var rel Rel32 894 895 for b.Len() > 0 { 896 binary.Read(b, f.ByteOrder, &rel) 897 symNo := rel.Info >> 8 898 t := R_MIPS(rel.Info & 0xff) 899 900 if symNo == 0 || symNo > uint32(len(symbols)) { 901 continue 902 } 903 sym := &symbols[symNo-1] 904 905 switch t { 906 case R_MIPS_32: 907 if rel.Off+4 >= uint32(len(dst)) { 908 continue 909 } 910 val := f.ByteOrder.Uint32(dst[rel.Off : rel.Off+4]) 911 val += uint32(sym.Value) 912 f.ByteOrder.PutUint32(dst[rel.Off:rel.Off+4], val) 913 } 914 } 915 916 return nil 917 } 918 919 func (f *File) applyRelocationsMIPS64(dst []byte, rels []byte) error { 920 // 24 is the size of Rela64. 921 if len(rels)%24 != 0 { 922 return errors.New("length of relocation section is not a multiple of 24") 923 } 924 925 symbols, _, err := f.getSymbols(SHT_SYMTAB) 926 if err != nil { 927 return err 928 } 929 930 b := bytes.NewReader(rels) 931 var rela Rela64 932 933 for b.Len() > 0 { 934 binary.Read(b, f.ByteOrder, &rela) 935 var symNo uint64 936 var t R_MIPS 937 if f.ByteOrder == binary.BigEndian { 938 symNo = rela.Info >> 32 939 t = R_MIPS(rela.Info & 0xff) 940 } else { 941 symNo = rela.Info & 0xffffffff 942 t = R_MIPS(rela.Info >> 56) 943 } 944 945 if symNo == 0 || symNo > uint64(len(symbols)) { 946 continue 947 } 948 sym := &symbols[symNo-1] 949 if SymType(sym.Info&0xf) != STT_SECTION { 950 // We don't handle non-section relocations for now. 951 continue 952 } 953 954 switch t { 955 case R_MIPS_64: 956 if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { 957 continue 958 } 959 f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend)) 960 case R_MIPS_32: 961 if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { 962 continue 963 } 964 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)) 965 } 966 } 967 968 return nil 969 } 970 971 func (f *File) applyRelocationsRISCV64(dst []byte, rels []byte) error { 972 // 24 is the size of Rela64. 973 if len(rels)%24 != 0 { 974 return errors.New("length of relocation section is not a multiple of 24") 975 } 976 977 symbols, _, err := f.getSymbols(SHT_SYMTAB) 978 if err != nil { 979 return err 980 } 981 982 b := bytes.NewReader(rels) 983 var rela Rela64 984 985 for b.Len() > 0 { 986 binary.Read(b, f.ByteOrder, &rela) 987 symNo := rela.Info >> 32 988 t := R_RISCV(rela.Info & 0xffff) 989 990 if symNo == 0 || symNo > uint64(len(symbols)) { 991 continue 992 } 993 sym := &symbols[symNo-1] 994 switch SymType(sym.Info & 0xf) { 995 case STT_SECTION, STT_NOTYPE: 996 break 997 default: 998 continue 999 } 1000 1001 switch t { 1002 case R_RISCV_64: 1003 if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { 1004 continue 1005 } 1006 val := sym.Value + uint64(rela.Addend) 1007 f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val) 1008 case R_RISCV_32: 1009 if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { 1010 continue 1011 } 1012 val := uint32(sym.Value) + uint32(rela.Addend) 1013 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val) 1014 } 1015 } 1016 1017 return nil 1018 } 1019 1020 func (f *File) applyRelocationss390x(dst []byte, rels []byte) error { 1021 // 24 is the size of Rela64. 1022 if len(rels)%24 != 0 { 1023 return errors.New("length of relocation section is not a multiple of 24") 1024 } 1025 1026 symbols, _, err := f.getSymbols(SHT_SYMTAB) 1027 if err != nil { 1028 return err 1029 } 1030 1031 b := bytes.NewReader(rels) 1032 var rela Rela64 1033 1034 for b.Len() > 0 { 1035 binary.Read(b, f.ByteOrder, &rela) 1036 symNo := rela.Info >> 32 1037 t := R_390(rela.Info & 0xffff) 1038 1039 if symNo == 0 || symNo > uint64(len(symbols)) { 1040 continue 1041 } 1042 sym := &symbols[symNo-1] 1043 switch SymType(sym.Info & 0xf) { 1044 case STT_SECTION, STT_NOTYPE: 1045 break 1046 default: 1047 continue 1048 } 1049 1050 switch t { 1051 case R_390_64: 1052 if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { 1053 continue 1054 } 1055 val := sym.Value + uint64(rela.Addend) 1056 f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val) 1057 case R_390_32: 1058 if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { 1059 continue 1060 } 1061 val := uint32(sym.Value) + uint32(rela.Addend) 1062 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val) 1063 } 1064 } 1065 1066 return nil 1067 } 1068 1069 func (f *File) applyRelocationsSPARC64(dst []byte, rels []byte) error { 1070 // 24 is the size of Rela64. 1071 if len(rels)%24 != 0 { 1072 return errors.New("length of relocation section is not a multiple of 24") 1073 } 1074 1075 symbols, _, err := f.getSymbols(SHT_SYMTAB) 1076 if err != nil { 1077 return err 1078 } 1079 1080 b := bytes.NewReader(rels) 1081 var rela Rela64 1082 1083 for b.Len() > 0 { 1084 binary.Read(b, f.ByteOrder, &rela) 1085 symNo := rela.Info >> 32 1086 t := R_SPARC(rela.Info & 0xff) 1087 1088 if symNo == 0 || symNo > uint64(len(symbols)) { 1089 continue 1090 } 1091 sym := &symbols[symNo-1] 1092 if SymType(sym.Info&0xf) != STT_SECTION { 1093 // We don't handle non-section relocations for now. 1094 continue 1095 } 1096 1097 switch t { 1098 case R_SPARC_64, R_SPARC_UA64: 1099 if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { 1100 continue 1101 } 1102 f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend)) 1103 case R_SPARC_32, R_SPARC_UA32: 1104 if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { 1105 continue 1106 } 1107 f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)) 1108 } 1109 } 1110 1111 return nil 1112 } 1113 1114 func (f *File) DWARF() (*dwarf.Data, error) { 1115 dwarfSuffix := func(s *Section) string { 1116 switch { 1117 case strings.HasPrefix(s.Name, ".debug_"): 1118 return s.Name[7:] 1119 case strings.HasPrefix(s.Name, ".zdebug_"): 1120 return s.Name[8:] 1121 default: 1122 return "" 1123 } 1124 1125 } 1126 // sectionData gets the data for s, checks its size, and 1127 // applies any applicable relations. 1128 sectionData := func(i int, s *Section) ([]byte, error) { 1129 b, err := s.Data() 1130 if err != nil && uint64(len(b)) < s.Size { 1131 return nil, err 1132 } 1133 1134 if len(b) >= 12 && string(b[:4]) == "ZLIB" { 1135 dlen := binary.BigEndian.Uint64(b[4:12]) 1136 dbuf := make([]byte, dlen) 1137 r, err := zlib.NewReader(bytes.NewBuffer(b[12:])) 1138 if err != nil { 1139 return nil, err 1140 } 1141 if _, err := io.ReadFull(r, dbuf); err != nil { 1142 return nil, err 1143 } 1144 if err := r.Close(); err != nil { 1145 return nil, err 1146 } 1147 b = dbuf 1148 } 1149 1150 for _, r := range f.Sections { 1151 if r.Type != SHT_RELA && r.Type != SHT_REL { 1152 continue 1153 } 1154 if int(r.Info) != i { 1155 continue 1156 } 1157 rd, err := r.Data() 1158 if err != nil { 1159 return nil, err 1160 } 1161 err = f.applyRelocations(b, rd) 1162 if err != nil { 1163 return nil, err 1164 } 1165 } 1166 return b, nil 1167 } 1168 1169 // There are many other DWARF sections, but these 1170 // are the ones the debug/dwarf package uses. 1171 // Don't bother loading others. 1172 var dat = map[string][]byte{"abbrev": nil, "info": nil, "str": nil, "line": nil, "ranges": nil} 1173 for i, s := range f.Sections { 1174 suffix := dwarfSuffix(s) 1175 if suffix == "" { 1176 continue 1177 } 1178 if _, ok := dat[suffix]; !ok { 1179 continue 1180 } 1181 b, err := sectionData(i, s) 1182 if err != nil { 1183 return nil, err 1184 } 1185 dat[suffix] = b 1186 } 1187 1188 d, err := dwarf.New(dat["abbrev"], nil, nil, dat["info"], dat["line"], nil, dat["ranges"], dat["str"]) 1189 if err != nil { 1190 return nil, err 1191 } 1192 1193 // Look for DWARF4 .debug_types sections. 1194 for i, s := range f.Sections { 1195 suffix := dwarfSuffix(s) 1196 if suffix != "types" { 1197 continue 1198 } 1199 1200 b, err := sectionData(i, s) 1201 if err != nil { 1202 return nil, err 1203 } 1204 1205 err = d.AddTypes(fmt.Sprintf("types-%d", i), b) 1206 if err != nil { 1207 return nil, err 1208 } 1209 } 1210 1211 return d, nil 1212 } 1213 1214 // Symbols returns the symbol table for f. The symbols will be listed in the order 1215 // they appear in f. 1216 // 1217 // For compatibility with Go 1.0, Symbols omits the null symbol at index 0. 1218 // After retrieving the symbols as symtab, an externally supplied index x 1219 // corresponds to symtab[x-1], not symtab[x]. 1220 func (f *File) Symbols() ([]Symbol, error) { 1221 sym, _, err := f.getSymbols(SHT_SYMTAB) 1222 return sym, err 1223 } 1224 1225 // DynamicSymbols returns the dynamic symbol table for f. The symbols 1226 // will be listed in the order they appear in f. 1227 // 1228 // For compatibility with Symbols, DynamicSymbols omits the null symbol at index 0. 1229 // After retrieving the symbols as symtab, an externally supplied index x 1230 // corresponds to symtab[x-1], not symtab[x]. 1231 func (f *File) DynamicSymbols() ([]Symbol, error) { 1232 sym, _, err := f.getSymbols(SHT_DYNSYM) 1233 return sym, err 1234 } 1235 1236 type ImportedSymbol struct { 1237 Name string 1238 Version string 1239 Library string 1240 } 1241 1242 // ImportedSymbols returns the names of all symbols 1243 // referred to by the binary f that are expected to be 1244 // satisfied by other libraries at dynamic load time. 1245 // It does not return weak symbols. 1246 func (f *File) ImportedSymbols() ([]ImportedSymbol, error) { 1247 sym, str, err := f.getSymbols(SHT_DYNSYM) 1248 if err != nil { 1249 return nil, err 1250 } 1251 f.gnuVersionInit(str) 1252 var all []ImportedSymbol 1253 for i, s := range sym { 1254 if ST_BIND(s.Info) == STB_GLOBAL && s.Section == SHN_UNDEF { 1255 all = append(all, ImportedSymbol{Name: s.Name}) 1256 f.gnuVersion(i, &all[len(all)-1]) 1257 } 1258 } 1259 return all, nil 1260 } 1261 1262 type verneed struct { 1263 File string 1264 Name string 1265 } 1266 1267 // gnuVersionInit parses the GNU version tables 1268 // for use by calls to gnuVersion. 1269 func (f *File) gnuVersionInit(str []byte) { 1270 // Accumulate verneed information. 1271 vn := f.SectionByType(SHT_GNU_VERNEED) 1272 if vn == nil { 1273 return 1274 } 1275 d, _ := vn.Data() 1276 1277 var need []verneed 1278 i := 0 1279 for { 1280 if i+16 > len(d) { 1281 break 1282 } 1283 vers := f.ByteOrder.Uint16(d[i : i+2]) 1284 if vers != 1 { 1285 break 1286 } 1287 cnt := f.ByteOrder.Uint16(d[i+2 : i+4]) 1288 fileoff := f.ByteOrder.Uint32(d[i+4 : i+8]) 1289 aux := f.ByteOrder.Uint32(d[i+8 : i+12]) 1290 next := f.ByteOrder.Uint32(d[i+12 : i+16]) 1291 file, _ := getString(str, int(fileoff)) 1292 1293 var name string 1294 j := i + int(aux) 1295 for c := 0; c < int(cnt); c++ { 1296 if j+16 > len(d) { 1297 break 1298 } 1299 // hash := f.ByteOrder.Uint32(d[j:j+4]) 1300 // flags := f.ByteOrder.Uint16(d[j+4:j+6]) 1301 other := f.ByteOrder.Uint16(d[j+6 : j+8]) 1302 nameoff := f.ByteOrder.Uint32(d[j+8 : j+12]) 1303 next := f.ByteOrder.Uint32(d[j+12 : j+16]) 1304 name, _ = getString(str, int(nameoff)) 1305 ndx := int(other) 1306 if ndx >= len(need) { 1307 a := make([]verneed, 2*(ndx+1)) 1308 copy(a, need) 1309 need = a 1310 } 1311 1312 need[ndx] = verneed{file, name} 1313 if next == 0 { 1314 break 1315 } 1316 j += int(next) 1317 } 1318 1319 if next == 0 { 1320 break 1321 } 1322 i += int(next) 1323 } 1324 1325 // Versym parallels symbol table, indexing into verneed. 1326 vs := f.SectionByType(SHT_GNU_VERSYM) 1327 if vs == nil { 1328 return 1329 } 1330 d, _ = vs.Data() 1331 1332 f.gnuNeed = need 1333 f.gnuVersym = d 1334 } 1335 1336 // gnuVersion adds Library and Version information to sym, 1337 // which came from offset i of the symbol table. 1338 func (f *File) gnuVersion(i int, sym *ImportedSymbol) { 1339 // Each entry is two bytes. 1340 i = (i + 1) * 2 1341 if i >= len(f.gnuVersym) { 1342 return 1343 } 1344 j := int(f.ByteOrder.Uint16(f.gnuVersym[i:])) 1345 if j < 2 || j >= len(f.gnuNeed) { 1346 return 1347 } 1348 n := &f.gnuNeed[j] 1349 sym.Library = n.File 1350 sym.Version = n.Name 1351 } 1352 1353 // ImportedLibraries returns the names of all libraries 1354 // referred to by the binary f that are expected to be 1355 // linked with the binary at dynamic link time. 1356 func (f *File) ImportedLibraries() ([]string, error) { 1357 return f.DynString(DT_NEEDED) 1358 } 1359 1360 // DynString returns the strings listed for the given tag in the file's dynamic 1361 // section. 1362 // 1363 // The tag must be one that takes string values: DT_NEEDED, DT_SONAME, DT_RPATH, or 1364 // DT_RUNPATH. 1365 func (f *File) DynString(tag DynTag) ([]string, error) { 1366 switch tag { 1367 case DT_NEEDED, DT_SONAME, DT_RPATH, DT_RUNPATH: 1368 default: 1369 return nil, fmt.Errorf("non-string-valued tag %v", tag) 1370 } 1371 ds := f.SectionByType(SHT_DYNAMIC) 1372 if ds == nil { 1373 // not dynamic, so no libraries 1374 return nil, nil 1375 } 1376 d, err := ds.Data() 1377 if err != nil { 1378 return nil, err 1379 } 1380 str, err := f.stringTable(ds.Link) 1381 if err != nil { 1382 return nil, err 1383 } 1384 var all []string 1385 for len(d) > 0 { 1386 var t DynTag 1387 var v uint64 1388 switch f.Class { 1389 case ELFCLASS32: 1390 t = DynTag(f.ByteOrder.Uint32(d[0:4])) 1391 v = uint64(f.ByteOrder.Uint32(d[4:8])) 1392 d = d[8:] 1393 case ELFCLASS64: 1394 t = DynTag(f.ByteOrder.Uint64(d[0:8])) 1395 v = f.ByteOrder.Uint64(d[8:16]) 1396 d = d[16:] 1397 } 1398 if t == tag { 1399 s, ok := getString(str, int(v)) 1400 if ok { 1401 all = append(all, s) 1402 } 1403 } 1404 } 1405 return all, nil 1406 } 1407
View as plain text