ELF/Binary.hpp

/* Copyright 2017 - 2024 R. Thomas
 * Copyright 2017 - 2024 Quarkslab
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef LIEF_ELF_BINARY_H
#define LIEF_ELF_BINARY_H
 
#include <vector>
#include <memory>
 
#include "LIEF/visibility.h"
#include "LIEF/errors.hpp"
#include "LIEF/iterators.hpp"
 
#include "LIEF/Abstract/Binary.hpp"
 
#include "LIEF/ELF/Note.hpp"
#include "LIEF/ELF/DynamicEntry.hpp"
#include "LIEF/ELF/Header.hpp"
#include "LIEF/ELF/Section.hpp"
#include "LIEF/ELF/Segment.hpp"
#include "LIEF/ELF/Builder.hpp"
 
namespace LIEF {
namespace ELF {
namespace DataHandler {
class Handler;
}
 
class ExeLayout;
class GnuHash;
class Layout;
class ObjectFileLayout;
class Parser;
class Relocation;
class Section;
class Segment;
class Symbol;
class SymbolVersion;
class SymbolVersionDefinition;
class SymbolVersionRequirement;
class DynamicEntryLibrary;
class SysvHash;
struct sizing_info_t;
 
class LIEF_API Binary : public LIEF::Binary {
  friend class Parser;
  friend class Builder;
  friend class ExeLayout;
  friend class Layout;
  friend class ObjectFileLayout;
 
  public:
  using string_list_t  = std::vector<std::string>;
 
  using notes_t = std::vector<std::unique_ptr<Note>>;
 
  using it_notes = ref_iterator<notes_t&, Note*>;
 
  using it_const_notes = const_ref_iterator<const notes_t&, const Note*>;
 
  using symbols_version_requirement_t = std::vector<std::unique_ptr<SymbolVersionRequirement>>;
 
  using it_symbols_version_requirement = ref_iterator<symbols_version_requirement_t&, SymbolVersionRequirement*>;
 
  using it_const_symbols_version_requirement = const_ref_iterator<const symbols_version_requirement_t&, const SymbolVersionRequirement*>;
 
  using symbols_version_definition_t = std::vector<std::unique_ptr<SymbolVersionDefinition>>;
 
  using it_symbols_version_definition       = ref_iterator<symbols_version_definition_t&, SymbolVersionDefinition*>;
 
  using it_const_symbols_version_definition = const_ref_iterator<const symbols_version_definition_t&, const SymbolVersionDefinition*>;
 
  using segments_t = std::vector<std::unique_ptr<Segment>>;
 
  using it_segments = ref_iterator<segments_t&, Segment*>;
 
  using it_const_segments = const_ref_iterator<const segments_t&, const Segment*>;
 
  using dynamic_entries_t = std::vector<std::unique_ptr<DynamicEntry>>;
 
  using it_dynamic_entries = ref_iterator<dynamic_entries_t&, DynamicEntry*>;
 
  using it_const_dynamic_entries = const_ref_iterator<const dynamic_entries_t&, const DynamicEntry*>;
 
  using symbols_version_t = std::vector<std::unique_ptr<SymbolVersion>>;
 
  using it_symbols_version = ref_iterator<symbols_version_t&, SymbolVersion*>;
 
  using it_const_symbols_version = const_ref_iterator<const symbols_version_t&, const SymbolVersion*>;
 
  using relocations_t = std::vector<std::unique_ptr<Relocation>>;
 
  using it_pltgot_relocations = filter_iterator<relocations_t&, Relocation*>;
 
  using it_const_pltgot_relocations = const_filter_iterator<const relocations_t&, const Relocation*>;
 
  using it_dynamic_relocations = filter_iterator<relocations_t&, Relocation*>;
 
  using it_const_dynamic_relocations = const_filter_iterator<const relocations_t&, const Relocation*>;
 
  using it_object_relocations = filter_iterator<relocations_t&, Relocation*>;
 
  using it_const_object_relocations = const_filter_iterator<const relocations_t&, const Relocation*>;
 
  using it_relocations = ref_iterator<relocations_t&, Relocation*>;
 
  using it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>;
 
  using symbols_t = std::vector<std::unique_ptr<Symbol>>;
 
  using it_dynamic_symbols = ref_iterator<symbols_t&, Symbol*>;
 
  using it_const_dynamic_symbols = const_ref_iterator<const symbols_t&, const Symbol*>;
 
  using it_symtab_symbols = ref_iterator<symbols_t&, Symbol*>;
 
  using it_const_symtab_symbols = const_ref_iterator<const symbols_t&, const Symbol*>;
 
  using it_symbols = ref_iterator<std::vector<Symbol*>>;
 
  using it_const_symbols = const_ref_iterator<std::vector<Symbol*>>;
 
  using it_exported_symbols = filter_iterator<std::vector<Symbol*>>;
 
  using it_const_exported_symbols = const_filter_iterator<std::vector<Symbol*>>;
 
  using it_imported_symbols = filter_iterator<std::vector<Symbol*>>;
 
  using it_const_imported_symbols = const_filter_iterator<std::vector<Symbol*>>;
 
  using sections_t = std::vector<std::unique_ptr<Section>>;
 
  using it_sections = ref_iterator<sections_t&, Section*>;
 
  using it_const_sections = const_ref_iterator<const sections_t&, const Section*>;
 
  public:
  enum PHDR_RELOC {
    AUTO = 0,
 
    PIE_SHIFT,
 
    BSS_END,
    BINARY_END,
    SEGMENT_GAP,
  };
 
  public:
  Binary& operator=(const Binary& ) = delete;
  Binary(const Binary& copy) = delete;
 
  Header::CLASS type() const {
    return type_;
  }
 
  Header& header() {
    return header_;
  }
 
  const Header& header() const {
    return header_;
  }
 
  uint64_t last_offset_section() const;
 
  uint64_t last_offset_segment() const;
 
  uint64_t next_virtual_address() const;
 
  it_sections sections() {
    return sections_;
  }
 
  it_const_sections sections() const {
    return sections_;
  }
 
  uint64_t entrypoint() const override {
    return header_.entrypoint();
  }
 
  it_segments segments() {
    return segments_;
  }
 
  it_const_segments segments() const {
    return segments_;
  }
 
  it_dynamic_entries dynamic_entries() {
    return dynamic_entries_;
  }
 
  it_const_dynamic_entries dynamic_entries() const {
    return dynamic_entries_;
  }
 
  DynamicEntry& add(const DynamicEntry& entry);
 
  Note& add(const Note& note);
 
  void remove(const DynamicEntry& entry);
 
  void remove(DynamicEntry::TAG tag);
 
  void remove(const Section& section, bool clear = false);
 
  void remove(const Note& note);
 
  void remove(Note::TYPE type);
 
  void remove(const Segment& seg);
 
  it_dynamic_symbols dynamic_symbols() {
    return dynamic_symbols_;
  }
 
  it_const_dynamic_symbols dynamic_symbols() const {
    return dynamic_symbols_;
  }
 
  it_exported_symbols       exported_symbols();
  it_const_exported_symbols exported_symbols() const;
 
  it_imported_symbols       imported_symbols();
  it_const_imported_symbols imported_symbols() const;
 
  it_symtab_symbols symtab_symbols() {
    return symtab_symbols_;
  }
 
  it_const_symtab_symbols symtab_symbols() const {
    return symtab_symbols_;
  }
 
  it_symbols_version symbols_version() {
    return symbol_version_table_;
  }
  it_const_symbols_version symbols_version() const {
    return symbol_version_table_;
  }
 
  it_symbols_version_definition symbols_version_definition() {
    return symbol_version_definition_;
  }
 
  it_const_symbols_version_definition symbols_version_definition() const {
    return symbol_version_definition_;
  }
 
  it_symbols_version_requirement symbols_version_requirement() {
    return symbol_version_requirements_;
  }
 
  it_const_symbols_version_requirement symbols_version_requirement() const {
    return symbol_version_requirements_;
  }
 
  it_dynamic_relocations       dynamic_relocations();
  it_const_dynamic_relocations dynamic_relocations() const;
 
  Relocation& add_dynamic_relocation(const Relocation& relocation);
 
  Relocation& add_pltgot_relocation(const Relocation& relocation);
 
  Relocation* add_object_relocation(const Relocation& relocation, const Section& section);
 
  it_pltgot_relocations       pltgot_relocations();
  it_const_pltgot_relocations pltgot_relocations() const;
 
  it_object_relocations       object_relocations();
  it_const_object_relocations object_relocations() const;
 
  it_relocations relocations() {
    return relocations_;
  }
 
  it_const_relocations relocations() const {
    return relocations_;
  }
 
  const Relocation* get_relocation(uint64_t address) const;
  Relocation*       get_relocation(uint64_t address);
 
  const Relocation* get_relocation(const Symbol& symbol) const;
  Relocation*       get_relocation(const Symbol& symbol);
 
  const Relocation* get_relocation(const std::string& symbol_name) const;
  Relocation*       get_relocation(const std::string& symbol_name);
 
  bool use_gnu_hash() const {
    return gnu_hash_ != nullptr && has(DynamicEntry::TAG::GNU_HASH);
  }
 
  const GnuHash* gnu_hash() const {
    return use_gnu_hash() ? gnu_hash_.get() : nullptr;
  }
 
  bool use_sysv_hash() const {
    return sysv_hash_ != nullptr && has(DynamicEntry::TAG::HASH);
  }
 
  const SysvHash* sysv_hash() const {
    return use_sysv_hash() ? sysv_hash_.get() : nullptr;
  }
 
  bool has_section(const std::string& name) const;
 
  bool has_section_with_offset(uint64_t offset) const;
 
  bool has_section_with_va(uint64_t va) const;
 
  Section*       get_section(const std::string& name);
  const Section* get_section(const std::string& name) const;
 
  Section* text_section() {
    return get_section(".text");
  }
 
  Section* dynamic_section();
 
  Section* hash_section();
 
  Section* symtab_symbols_section();
 
  uint64_t imagebase() const override;
 
  uint64_t virtual_size() const;
 
  bool has_interpreter() const;
 
  const std::string& interpreter() const;
 
  void interpreter(const std::string& interpreter);
 
  it_symbols symbols() {
    return symtab_dyn_symbols();
  }
 
  it_const_symbols symbols() const {
    return symtab_dyn_symbols();
  }
 
  Symbol& export_symbol(const Symbol& symbol);
 
  Symbol& export_symbol(const std::string& symbol_name, uint64_t value = 0);
 
  bool has_dynamic_symbol(const std::string& name) const;
 
  const Symbol* get_dynamic_symbol(const std::string& name) const;
 
  Symbol* get_dynamic_symbol(const std::string& name);
 
  bool has_symtab_symbol(const std::string& name) const {
    return get_symtab_symbol(name) != nullptr;
  }
 
  const Symbol* get_symtab_symbol(const std::string& name) const;
 
  Symbol* get_symtab_symbol(const std::string& name);
 
  string_list_t strings(size_t min_size = 5) const;
 
  void remove_symbol(const std::string& name);
 
  void remove_symtab_symbol(const std::string& name);
  void remove_symtab_symbol(Symbol* symbol);
 
  void remove_dynamic_symbol(const std::string& name);
 
  void remove_dynamic_symbol(Symbol* symbol);
 
  result<uint64_t> get_function_address(const std::string& func_name) const override;
 
  //
  result<uint64_t> get_function_address(const std::string& func_name, bool demangled) const;
 
  Section* add(const Section& section, bool loaded = true);
 
  Section* extend(const Section& section, uint64_t size);
 
  Symbol& add_symtab_symbol(const Symbol& symbol);
 
  Symbol& add_dynamic_symbol(const Symbol& symbol, const SymbolVersion* version = nullptr);
 
  Symbol& add_exported_function(uint64_t address, const std::string& name = "");
 
  DynamicEntryLibrary& add_library(const std::string& library_name);
 
  void remove_library(const std::string& library_name);
 
  DynamicEntryLibrary* get_library(const std::string& library_name);
 
  const DynamicEntryLibrary* get_library(const std::string& library_name) const;
 
  bool has_library(const std::string& name) const;
 
  Segment* add(const Segment& segment, uint64_t base = 0);
 
  Segment* replace(const Segment& new_segment, const Segment& original_segment, uint64_t base = 0);
 
  Segment* extend(const Segment& segment, uint64_t size);
 
 
  void patch_address(uint64_t address, const std::vector<uint8_t>& patch_value,
                     LIEF::Binary::VA_TYPES addr_type = LIEF::Binary::VA_TYPES::AUTO) override;
 
 
  void patch_address(uint64_t address, uint64_t patch_value,
                     size_t size = sizeof(uint64_t),
                     LIEF::Binary::VA_TYPES addr_type = LIEF::Binary::VA_TYPES::AUTO) override;
 
  void patch_pltgot(const Symbol& symbol, uint64_t address);
 
 
  void patch_pltgot(const std::string& symbol_name, uint64_t address);
 
  void strip();
 
  void remove_section(const std::string& name, bool clear = false) override;
 
  void write(const std::string& filename) override;
 
  void write(const std::string& filename, Builder::config_t config);
 
  void write(std::ostream& os) override;
 
  void write(std::ostream& os, Builder::config_t config);
 
  std::vector<uint8_t> raw();
 
  result<uint64_t> virtual_address_to_offset(uint64_t virtual_address) const;
 
  result<uint64_t> offset_to_virtual_address(uint64_t offset, uint64_t slide = 0) const override;
 
  bool is_pie() const override;
 
  bool has_nx() const override;
 
  int64_t dynsym_idx(const std::string& name) const;
 
  int64_t dynsym_idx(const Symbol& sym) const;
 
  int64_t symtab_idx(const std::string& name) const;
 
  int64_t symtab_idx(const Symbol& sym) const;
 
  const Section* section_from_offset(uint64_t offset, bool skip_nobits = true) const;
  Section*       section_from_offset(uint64_t offset, bool skip_nobits = true);
 
  const Section* section_from_virtual_address(uint64_t address, bool skip_nobits = true) const;
  Section*       section_from_virtual_address(uint64_t address, bool skip_nobits = true);
 
  const Segment* segment_from_virtual_address(uint64_t address) const;
  Segment*       segment_from_virtual_address(uint64_t address);
 
 
  const Segment* segment_from_virtual_address(Segment::TYPE type, uint64_t address) const;
  Segment*       segment_from_virtual_address(Segment::TYPE type, uint64_t address);
 
  const Segment* segment_from_offset(uint64_t offset) const;
  Segment*       segment_from_offset(uint64_t offset);
 
  const DynamicEntry* get(DynamicEntry::TAG tag) const;
  DynamicEntry*       get(DynamicEntry::TAG tag) {
    return const_cast<DynamicEntry*>(static_cast<const Binary*>(this)->get(tag));
  }
 
  const Segment* get(Segment::TYPE type) const;
  Segment*       get(Segment::TYPE type);
 
  const Note* get(Note::TYPE type) const;
  Note*       get(Note::TYPE type);
 
  const Section* get(Section::TYPE type) const;
  Section*       get(Section::TYPE type);
 
  bool has(DynamicEntry::TAG tag) const {
    return get(tag) != nullptr;
  }
 
  bool has(Segment::TYPE type) const {
    return get(type) != nullptr;
  }
 
  bool has(Note::TYPE type) const {
    return get(type) != nullptr;
  }
 
  bool has(Section::TYPE type) const {
    return get(type) != nullptr;
  }
 
  span<const uint8_t> get_content_from_virtual_address(uint64_t virtual_address, uint64_t size,
                                     Binary::VA_TYPES addr_type = Binary::VA_TYPES::AUTO) const override;
 
  void accept(LIEF::Visitor& visitor) const override;
 
  void permute_dynamic_symbols(const std::vector<size_t>& permutation);
 
  LIEF::Binary::functions_t ctor_functions() const override;
 
  LIEF::Binary::functions_t dtor_functions() const;
 
  LIEF::Binary::functions_t functions() const;
 
  bool has_notes() const;
 
  it_const_notes notes() const {
    return notes_;
  }
 
  it_notes notes() {
    return notes_;
  }
 
  uint64_t eof_offset() const;
 
  bool has_overlay() const {
    return !overlay_.empty();
  }
 
  span<const uint8_t> overlay() const {
    return overlay_;
  }
 
  void overlay(std::vector<uint8_t> overlay) {
    overlay_ = std::move(overlay);
  }
 
  uint64_t relocate_phdr_table(PHDR_RELOC type);
 
  static bool classof(const LIEF::Binary* bin) {
    return bin->format() == Binary::FORMATS::ELF ||
           bin->format() == Binary::FORMATS::OAT;
  }
 
  size_t hash(const std::string& name);
 
  ~Binary() override;
 
  std::ostream& print(std::ostream& os) const override;
 
  Binary& operator+=(const DynamicEntry& entry) {
    add(entry);
    return *this;
  }
  Binary& operator+=(const Section& section) {
    add(section);
    return *this;
  }
 
  Binary& operator+=(const Segment& segment) {
    add(segment);
    return *this;
  }
 
  Binary& operator+=(const Note& note) {
    add(note);
    return *this;
  }
 
  Binary& operator-=(const DynamicEntry& entry) {
    remove(entry);
    return *this;
  }
 
  Binary& operator-=(DynamicEntry::TAG tag) {
    remove(tag);
    return *this;
  }
 
  Binary& operator-=(const Note& note) {
    remove(note);
    return *this;
  }
 
  Binary& operator-=(Note::TYPE type) {
    remove(type);
    return *this;
  }
 
  Segment* operator[](Segment::TYPE type) {
    return get(type);
  }
 
  const Segment* operator[](Segment::TYPE type) const {
    return get(type);
  }
 
  DynamicEntry* operator[](DynamicEntry::TAG tag) {
    return get(tag);
  }
 
  const DynamicEntry* operator[](DynamicEntry::TAG tag) const {
    return get(tag);
  }
 
  Note* operator[](Note::TYPE type) {
    return get(type);
  }
 
  const Note* operator[](Note::TYPE type) const {
    return get(type);
  }
 
  Section* operator[](Section::TYPE type) {
    return get(type);
  }
 
  const Section* operator[](Section::TYPE type) const {
    return get(type);
  }
 
  protected:
  struct phdr_relocation_info_t {
    uint64_t new_offset = 0;
    size_t nb_segments = 0;
    void clear() {
      new_offset = 0;
      nb_segments = 0;
    }
  };
  Binary();
 
  LIEF::Binary::sections_t get_abstract_sections() override;
 
  LIEF::Header get_abstract_header() const override;
 
  LIEF::Binary::functions_t get_abstract_exported_functions() const override;
  LIEF::Binary::functions_t get_abstract_imported_functions() const override;
  std::vector<std::string> get_abstract_imported_libraries() const override;
  LIEF::Binary::symbols_t     get_abstract_symbols() override;
  LIEF::Binary::relocations_t get_abstract_relocations() override;
 
  template<ELF::ARCH ARCH>
  void patch_relocations(uint64_t from, uint64_t shift);
 
  template<class T>
  void patch_addend(Relocation& relocatio, uint64_t from, uint64_t shift);
 
  void shift_sections(uint64_t from, uint64_t shift);
  void shift_segments(uint64_t from, uint64_t shift);
  void shift_dynamic_entries(uint64_t from, uint64_t shift);
  void shift_symbols(uint64_t from, uint64_t shift);
  void shift_relocations(uint64_t from, uint64_t shift);
 
  template<class ELF_T>
  void fix_got_entries(uint64_t from, uint64_t shift);
 
  LIEF::Binary::functions_t eh_frame_functions() const;
  LIEF::Binary::functions_t armexid_functions() const;
 
  template<Header::FILE_TYPE OBJECT_TYPE, bool note = false>
  Segment* add_segment(const Segment& segment, uint64_t base);
 
  uint64_t relocate_phdr_table_auto();
  uint64_t relocate_phdr_table_pie();
  uint64_t relocate_phdr_table_v1();
  uint64_t relocate_phdr_table_v2();
  uint64_t relocate_phdr_table_v3();
 
  template<Segment::TYPE PT>
  Segment* extend_segment(const Segment& segment, uint64_t size);
 
  template<bool LOADED>
  Section* add_section(const Section& section);
  std::vector<Symbol*> symtab_dyn_symbols() const;
 
  std::string shstrtab_name() const;
  Section* add_frame_section(const Section& sec);
 
  LIEF::Binary::functions_t tor_functions(DynamicEntry::TAG tag) const;
 
  Header::CLASS type_ = Header::CLASS::NONE;
  Header header_;
  sections_t sections_;
  segments_t segments_;
  dynamic_entries_t dynamic_entries_;
  symbols_t dynamic_symbols_;
  symbols_t symtab_symbols_;
  relocations_t relocations_;
  symbols_version_t symbol_version_table_;
  symbols_version_requirement_t symbol_version_requirements_;
  symbols_version_definition_t  symbol_version_definition_;
  notes_t notes_;
  std::unique_ptr<GnuHash> gnu_hash_;
  std::unique_ptr<SysvHash> sysv_hash_;
  std::unique_ptr<DataHandler::Handler> datahandler_;
  phdr_relocation_info_t phdr_reloc_info_;
 
  std::string interpreter_;
  std::vector<uint8_t> overlay_;
  std::unique_ptr<sizing_info_t> sizing_info_;
};
 
}
}
#endif