MachO/Binary.hpp

Go to the documentation of this file.

 
/* 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_MACHO_BINARY_H
#define LIEF_MACHO_BINARY_H
 
#include <vector>
#include <map>
#include <memory>
 
#include "LIEF/MachO/LoadCommand.hpp"
#include "LIEF/visibility.h"
 
#include "LIEF/Abstract/Binary.hpp"
 
#include "LIEF/iterators.hpp"
#include "LIEF/MachO/Header.hpp"
#include "LIEF/errors.hpp"
 
namespace LIEF {
 
namespace objc {
class Metadata;
}
 
namespace MachO {
 
class BinaryParser;
class BuildVersion;
class Builder;
class CodeSignature;
class CodeSignatureDir;
class DataInCode;
class DyldChainedFixups;
class DyldEnvironment;
class DyldExportsTrie;
class DyldInfo;
class DylibCommand;
class DylinkerCommand;
class DynamicSymbolCommand;
class EncryptionInfo;
class ExportInfo;
class FunctionStarts;
class Header;
class LinkerOptHint;
class MainCommand;
class Parser;
class RPathCommand;
class Relocation;
class Section;
class SegmentCommand;
class SegmentSplitInfo;
class SourceVersion;
class SubFramework;
class Symbol;
class SymbolCommand;
class ThreadCommand;
class TwoLevelHints;
class UUIDCommand;
class VersionMin;
 
class LIEF_API Binary : public LIEF::Binary  {
 
  friend class Parser;
  friend class BinaryParser;
  friend class Builder;
  friend class DyldInfo;
 
  public:
  struct range_t {
    uint64_t start = 0;
    uint64_t end   = 0;
  };
 
  using commands_t = std::vector<std::unique_ptr<LoadCommand>>;
 
  using it_commands = ref_iterator<commands_t&, LoadCommand*>;
 
  using it_const_commands = const_ref_iterator<const commands_t&, LoadCommand*>;
 
  using symbols_t = std::vector<std::unique_ptr<Symbol>>;
 
  using it_symbols = ref_iterator<symbols_t&, Symbol*>;
 
  using it_const_symbols = const_ref_iterator<const symbols_t&, const Symbol*>;
 
  using it_exported_symbols = filter_iterator<symbols_t&, Symbol*>;
 
  using it_const_exported_symbols = const_filter_iterator<const symbols_t&, const Symbol*>;
 
  using it_imported_symbols = filter_iterator<symbols_t&, Symbol*>;
 
  using it_const_imported_symbols = const_filter_iterator<const symbols_t&, const Symbol*>;
 
  using sections_cache_t = std::vector<Section*>;
 
  using it_sections = ref_iterator<sections_cache_t&>;
 
  using it_const_sections = const_ref_iterator<const sections_cache_t&>;
 
  using segments_cache_t = std::vector<SegmentCommand*>;
 
  using it_segments = ref_iterator<segments_cache_t&>;
 
  using it_const_segments = const_ref_iterator<const segments_cache_t&>;
 
  using libraries_cache_t = std::vector<DylibCommand*>;
 
  using it_libraries = ref_iterator<libraries_cache_t&>;
 
  using it_const_libraries = const_ref_iterator<const libraries_cache_t&>;
 
  using fileset_binaries_t = std::vector<std::unique_ptr<Binary>>;
 
  using it_fileset_binaries = ref_iterator<fileset_binaries_t&, Binary*>;
 
  using it_const_fileset_binaries = const_ref_iterator<const fileset_binaries_t&, Binary*>;
 
  struct KeyCmp {
    bool operator() (const Relocation* lhs, const Relocation* rhs) const;
  };
 
  using relocations_t = std::set<Relocation*, KeyCmp>;
 
  using it_relocations = ref_iterator<relocations_t&, Relocation*>;
 
  using it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>;
 
  using it_rpaths = filter_iterator<commands_t&, RPathCommand*>;
 
  using it_const_rpaths = const_filter_iterator<const commands_t&, const RPathCommand*>;
 
  public:
  Binary(const Binary&) = delete;
  Binary& operator=(const Binary&) = delete;
 
  Header& header() {
    return header_;
  }
 
  const Header& header() const {
    return header_;
  }
 
  it_commands commands() {
    return commands_;
  }
 
  it_const_commands commands() const {
    return commands_;
  }
 
  it_fileset_binaries filesets() {
    return filesets_;
  }
 
  it_const_fileset_binaries filesets() const {
    return filesets_;
  }
 
  it_symbols symbols() {
    return symbols_;
  }
  it_const_symbols symbols() const {
    return symbols_;
  }
 
  bool has_symbol(const std::string& name) const {
    return get_symbol(name) != nullptr;
  }
 
  const Symbol* get_symbol(const std::string& name) const;
  Symbol* get_symbol(const std::string& name);
 
  static bool is_exported(const Symbol& symbol);
 
  it_exported_symbols exported_symbols() {
    return {symbols_, [] (const std::unique_ptr<Symbol>& symbol) {
      return is_exported(*symbol); }
    };
  }
  it_const_exported_symbols exported_symbols() const {
    return {symbols_, [] (const std::unique_ptr<Symbol>& symbol) {
      return is_exported(*symbol);
    }};
  }
 
  static bool is_imported(const Symbol& symbol);
 
  it_imported_symbols imported_symbols() {
    return {symbols_, [] (const std::unique_ptr<Symbol>& symbol) {
      return is_imported(*symbol);
    }};
  }
 
  it_const_imported_symbols imported_symbols() const {
    return {symbols_, [] (const std::unique_ptr<Symbol>& symbol) {
      return is_imported(*symbol);
    }};
  }
 
  it_libraries libraries() {
    return libraries_;
  }
 
  it_const_libraries libraries() const {
    return libraries_;
  }
 
  it_segments segments() {
    return segments_;
  }
  it_const_segments segments() const {
    return segments_;
  }
 
  it_sections sections() {
    return sections_;
  }
  it_const_sections sections() const {
    return sections_;
  }
 
  it_relocations       relocations();
  it_const_relocations relocations() const;
 
  void write(const std::string& filename) override;
 
  void write(std::ostream& os) override;
 
  std::vector<uint8_t> raw();
 
  bool has(LoadCommand::TYPE type) const;
 
  const LoadCommand* get(LoadCommand::TYPE type) const;
  LoadCommand* get(LoadCommand::TYPE type);
 
  LoadCommand* add(const LoadCommand& command);
 
  LoadCommand* add(const LoadCommand& command, size_t index);
 
  LoadCommand* add(const DylibCommand& library);
 
  LoadCommand* add(const SegmentCommand& segment);
 
  LoadCommand* add_library(const std::string& name);
 
  Section* add_section(const Section& section);
 
  Section* add_section(const SegmentCommand& segment, const Section& section);
 
  void remove_section(const std::string& name, bool clear = false) override;
 
  void remove_section(const std::string& segname, const std::string& secname, bool clear = false);
 
  bool remove(const LoadCommand& command);
 
  bool remove(LoadCommand::TYPE type);
 
  bool remove_command(size_t index);
 
  bool remove_signature();
 
  bool extend(const LoadCommand& command, uint64_t size);
 
  bool extend_segment(const SegmentCommand& segment, size_t size);
 
  bool disable_pie();
 
  uint64_t imagebase() const override;
 
  uint64_t virtual_size() const;
 
  std::string loader() const;
 
  bool has_section(const std::string& name) const {
    return get_section(name) != nullptr;
  }
 
  Section* get_section(const std::string& name);
 
  const Section* get_section(const std::string& name) const;
 
  Section* get_section(const std::string& segname, const std::string& secname);
 
  const Section* get_section(const std::string& segname, const std::string& secname) const;
 
  bool has_segment(const std::string& name) const {
    return get_segment(name) != nullptr;
  }
 
  const SegmentCommand* get_segment(const std::string& name) const;
 
  SegmentCommand* get_segment(const std::string& name);
 
  bool remove_symbol(const std::string& name);
 
  bool remove(const Symbol& sym);
 
  bool can_remove(const Symbol& sym) const;
 
  bool can_remove_symbol(const std::string& name) const;
 
  bool unexport(const std::string& name);
 
  bool unexport(const Symbol& sym);
 
  Section* section_from_offset(uint64_t offset);
  const Section* section_from_offset(uint64_t offset) const;
 
  Section* section_from_virtual_address(uint64_t virtual_address);
  const Section* section_from_virtual_address(uint64_t virtual_address) const;
 
  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;
 
  SegmentCommand* segment_from_offset(uint64_t offset);
  const SegmentCommand* segment_from_offset(uint64_t offset) const;
 
  size_t segment_index(const SegmentCommand& segment) const;
 
  uint64_t fat_offset() const {
    return fat_offset_;
  }
 
  SegmentCommand* segment_from_virtual_address(uint64_t virtual_address);
  const SegmentCommand* segment_from_virtual_address(uint64_t virtual_address) const;
 
  range_t va_ranges() const;
 
  range_t off_ranges() const;
 
  bool is_valid_addr(uint64_t address) const;
 
  void accept(LIEF::Visitor& visitor) const override;
 
  std::ostream& print(std::ostream& os) const override;
 
  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;
 
  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;
 
  uint64_t entrypoint() const override;
 
  bool is_pie() const override {
    return header().has(Header::FLAGS::PIE);
  }
 
  bool has_nx() const override {
    return !has_nx_stack();
  }
 
  bool has_nx_stack() const {
    return !header().has(Header::FLAGS::ALLOW_STACK_EXECUTION);
  }
 
  bool has_nx_heap() const {
    return !header().has(Header::FLAGS::NO_HEAP_EXECUTION);
  }
 
  bool has_entrypoint() const {
    return has_main_command() || has_thread_command();
  }
 
  bool has_uuid() const;
 
  UUIDCommand* uuid();
  const UUIDCommand* uuid() const;
 
  bool has_main_command() const;
 
  MainCommand* main_command();
  const MainCommand* main_command() const;
 
  bool has_dylinker() const;
 
  DylinkerCommand* dylinker();
  const DylinkerCommand* dylinker() const;
 
  bool has_dyld_info() const;
 
  DyldInfo* dyld_info();
  const DyldInfo* dyld_info() const;
 
  bool has_function_starts() const;
 
  FunctionStarts* function_starts();
  const FunctionStarts* function_starts() const;
 
  bool has_source_version() const;
 
  SourceVersion* source_version();
  const SourceVersion* source_version() const;
 
  bool has_version_min() const;
 
  VersionMin* version_min();
  const VersionMin* version_min() const;
 
  bool has_thread_command() const;
 
  ThreadCommand* thread_command();
  const ThreadCommand* thread_command() const;
 
  bool has_rpath() const;
 
  RPathCommand* rpath();
  const RPathCommand* rpath() const;
 
  it_rpaths rpaths();
  it_const_rpaths rpaths() const;
 
  bool has_symbol_command() const;
 
  SymbolCommand* symbol_command();
  const SymbolCommand* symbol_command() const;
 
  bool has_dynamic_symbol_command() const;
 
  DynamicSymbolCommand* dynamic_symbol_command();
  const DynamicSymbolCommand* dynamic_symbol_command() const;
 
  bool has_code_signature() const;
 
  CodeSignature* code_signature();
  const CodeSignature* code_signature() const;
 
  bool has_code_signature_dir() const;
 
  CodeSignatureDir* code_signature_dir();
  const CodeSignatureDir* code_signature_dir() const;
 
  bool has_data_in_code() const;
 
  DataInCode* data_in_code();
  const DataInCode* data_in_code() const;
 
  bool has_segment_split_info() const;
 
  SegmentSplitInfo* segment_split_info();
  const SegmentSplitInfo* segment_split_info() const;
 
  bool has_sub_framework() const;
 
  bool has_encryption_info() const;
 
  EncryptionInfo* encryption_info();
  const EncryptionInfo* encryption_info() const;
 
  SubFramework* sub_framework();
  const SubFramework* sub_framework() const;
 
  bool has_dyld_environment() const;
 
  DyldEnvironment* dyld_environment();
  const DyldEnvironment* dyld_environment() const;
 
  bool has_build_version() const;
 
  BuildVersion* build_version();
  const BuildVersion* build_version() const;
 
  bool has_dyld_chained_fixups() const;
 
  DyldChainedFixups* dyld_chained_fixups();
  const DyldChainedFixups* dyld_chained_fixups() const;
 
  bool has_dyld_exports_trie() const;
 
  DyldExportsTrie* dyld_exports_trie();
  const DyldExportsTrie* dyld_exports_trie() const;
 
  bool has_two_level_hints() const;
 
  TwoLevelHints* two_level_hints();
  const TwoLevelHints* two_level_hints() const;
 
  bool has_linker_opt_hint() const;
 
  LinkerOptHint* linker_opt_hint();
  const LinkerOptHint* linker_opt_hint() const;
 
  ExportInfo* add_exported_function(uint64_t address, const std::string& name);
 
  Symbol* add_local_symbol(uint64_t address, const std::string& name);
 
  std::unique_ptr<objc::Metadata> objc_metadata() const;
 
  template<class T>
  LIEF_LOCAL bool has_command() const;
 
  template<class T>
  LIEF_LOCAL T* command();
 
  template<class T>
  LIEF_LOCAL const T* command() const;
 
  template<class T>
  LIEF_LOCAL size_t count_commands() const;
 
  template<class CMD, class Func>
  LIEF_LOCAL Binary& for_commands(Func f);
 
  LoadCommand* operator[](LoadCommand::TYPE type) {
    return get(type);
  }
  const LoadCommand* operator[](LoadCommand::TYPE type) const {
    return get(type);
  }
 
  LIEF::Binary::functions_t ctor_functions() const override;
 
  LIEF::Binary::functions_t functions() const;
 
  LIEF::Binary::functions_t unwind_functions() const;
 
  bool has_filesets() const;
 
  const std::string& fileset_name() const {
    return fileset_name_;
  }
 
  ~Binary() override;
 
  ok_error_t shift(size_t value);
 
  ok_error_t shift_linkedit(size_t width);
 
  uint64_t memory_base_address() const {
    return in_memory_base_addr_;
  }
 
  // Check if the binary is supporting ARM64 pointer authentication (arm64e)
  bool support_arm64_ptr_auth() const {
    static constexpr auto CPU_SUBTYPE_ARM64E = 2;
    return header().cpu_type() == Header::CPU_TYPE::ARM64 &&
           (header().cpu_subtype() & ~Header::CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM64E;
  }
 
  uint32_t page_size() const;
 
  static bool classof(const LIEF::Binary* bin) {
    return bin->format() == Binary::FORMATS::MACHO;
  }
 
  span<const uint8_t> overlay() const {
    return overlay_;
  }
 
  private:
  Binary();
 
  void shift_command(size_t width, uint64_t from_offset);
 
  size_t add_cached_segment(SegmentCommand& segment);
  void refresh_seg_offset();
 
  template<class T>
  LIEF_LOCAL ok_error_t patch_relocation(Relocation& relocation, uint64_t from, uint64_t shift);
 
  LIEF::Header              get_abstract_header() const override;
  LIEF::Binary::sections_t          get_abstract_sections() override;
  LIEF::Binary::symbols_t           get_abstract_symbols() override;
  LIEF::Binary::relocations_t       get_abstract_relocations() 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;
 
  relocations_t& relocations_list() {
    return this->relocations_;
  }
 
  const relocations_t& relocations_list() const {
    return this->relocations_;
  }
 
  size_t pointer_size() const {
    return this->is64_ ? sizeof(uint64_t) : sizeof(uint32_t);
  }
 
  bool        is64_ = true;
  Header      header_;
  commands_t  commands_;
  symbols_t   symbols_;
 
  // Same purpose as sections_cache_t
  libraries_cache_t libraries_;
 
  // The sections are owned by the SegmentCommand object.
  // This attribute is a cache to speed-up the iteration
  sections_cache_t sections_;
 
  // Same purpose as sections_cache_t
  segments_cache_t segments_;
 
  fileset_binaries_t filesets_;
 
  // Cached relocations from segment / sections
  mutable relocations_t relocations_;
  int32_t available_command_space_ = 0;
 
  // This is used to improve performances of
  // offset_to_virtual_address
  std::map<uint64_t, SegmentCommand*> offset_seg_;
 
  protected:
  uint64_t fat_offset_ = 0;
  uint64_t fileset_offset_ = 0;
  uint64_t in_memory_base_addr_ = 0;
  std::string fileset_name_;
  std::vector<uint8_t> overlay_;
};
 
} // namespace MachO
} // namespace LIEF
#endif