Abstract/Binary.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 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_ABSTRACT_BINARY_H
#define LIEF_ABSTRACT_BINARY_H
 
#include <string_view>
#include <unordered_map>
#include <memory>
#include <vector>
 
#include "LIEF/Object.hpp"
#include "LIEF/compiler_attributes.hpp"
#include "LIEF/errors.hpp"
#include "LIEF/iterators.hpp"
#include "LIEF/span.hpp"
#include "LIEF/visibility.h"
 
#include "LIEF/Abstract/Function.hpp"
#include "LIEF/Abstract/Header.hpp"
 
#include "LIEF/asm/AssemblerConfig.hpp"
#include "LIEF/asm/Instruction.hpp"
 
namespace llvm {
class MCInst;
}

namespace LIEF {
class Section;
class Relocation;
class Symbol;
 
class DebugInfo;
 
namespace assembly {
class Engine;
}

class LIEF_API Binary : public Object {
  public:
  enum class VA_TYPES {
    AUTO = 0,

    RVA = 1,

    VA = 2,
  };
 
  enum FORMATS {
    UNKNOWN = 0,
    ELF,
    PE,
    MACHO,
    OAT,
  };
 
  using functions_t = std::vector<Function>;

  using sections_t = std::vector<Section*>;

  using it_sections = ref_iterator<sections_t>;

  using it_const_sections = const_ref_iterator<sections_t>;

  using symbols_t = std::vector<Symbol*>;

  using it_symbols = ref_iterator<symbols_t>;

  using it_const_symbols = const_ref_iterator<symbols_t>;

  using relocations_t = std::vector<Relocation*>;

  using it_relocations = ref_iterator<relocations_t>;

  using it_const_relocations = const_ref_iterator<relocations_t>;

  using instructions_it = iterator_range<assembly::Instruction::Iterator>;
 
  public:
  Binary();
  Binary(FORMATS fmt);
 
  ~Binary() override;
 
  Binary& operator=(const Binary&) = delete;
  Binary(const Binary&) = delete;

  FORMATS format() const {
    return format_;
  }

  Header header() const {
    return get_abstract_header();
  }

  it_symbols symbols() LIEF_LIFETIMEBOUND {
    return get_abstract_symbols();
  }

  it_const_symbols symbols() const LIEF_LIFETIMEBOUND {
    return const_cast<Binary*>(this)->get_abstract_symbols();
  }

  bool has_symbol(const std::string& name) const {
    return get_symbol(name) != nullptr;
  }

  const Symbol* get_symbol(const std::string& name) const LIEF_LIFETIMEBOUND;
 
  Symbol* get_symbol(const std::string& name) LIEF_LIFETIMEBOUND {
    return const_cast<Symbol*>(static_cast<const Binary*>(this)->get_symbol(name));
  }

  it_sections sections() LIEF_LIFETIMEBOUND {
    return get_abstract_sections();
  }
 
  it_const_sections sections() const LIEF_LIFETIMEBOUND {
    return const_cast<Binary*>(this)->get_abstract_sections();
  }

  virtual void remove_section(const std::string& name, bool clear = false) = 0;

  it_relocations relocations() LIEF_LIFETIMEBOUND {
    return get_abstract_relocations();
  }
 
  it_const_relocations relocations() const LIEF_LIFETIMEBOUND {
    return const_cast<Binary*>(this)->get_abstract_relocations();
  }

  virtual uint64_t entrypoint() const = 0;

  uint64_t original_size() const {
    return original_size_;
  }

  functions_t exported_functions() const {
    return get_abstract_exported_functions();
  }

  std::vector<std::string> imported_libraries() const {
    return get_abstract_imported_libraries();
  }

  functions_t imported_functions() const {
    return get_abstract_imported_functions();
  }

  virtual result<uint64_t>
      get_function_address(const std::string& func_name) const;

  void accept(Visitor& visitor) const override;
 
  std::vector<uint64_t> xref(uint64_t address) const;

  virtual void patch_address(uint64_t address,
                             const std::vector<uint8_t>& patch_value,
                             VA_TYPES addr_type = VA_TYPES::AUTO) = 0;

  virtual void patch_address(uint64_t address, uint64_t patch_value,
                             size_t size = sizeof(uint64_t),
                             VA_TYPES addr_type = VA_TYPES::AUTO) = 0;

  virtual span<const uint8_t> get_content_from_virtual_address(
      uint64_t virtual_address, uint64_t size, VA_TYPES addr_type = VA_TYPES::AUTO
  ) const LIEF_LIFETIMEBOUND = 0;

  template<class T>
  LIEF::result<T>
      get_int_from_virtual_address(uint64_t va,
                                   VA_TYPES addr_type = VA_TYPES::AUTO) const {
    T value;
    static_assert(std::is_integral_v<T>, "Require an integral type");
    span<const uint8_t> raw =
        get_content_from_virtual_address(va, sizeof(T), addr_type);
    if (raw.empty() || raw.size() < sizeof(T)) {
      return make_error_code(lief_errors::read_error);
    }
 
    std::copy(raw.data(), raw.data() + sizeof(T),
              reinterpret_cast<uint8_t*>(&value));
    return value;
  }

  void original_size(uint64_t size) {
    original_size_ = size;
  }

  virtual bool is_pie() const = 0;

  virtual bool has_nx() const = 0;

  virtual uint64_t imagebase() const = 0;

  virtual functions_t ctor_functions() const = 0;

  virtual result<uint64_t> offset_to_virtual_address(uint64_t offset,
                                                     uint64_t slide = 0) const = 0;
 
  virtual std::ostream& print(std::ostream& os) const {
    return os;
  }
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os,
                                           const Binary& binary) {
    binary.print(os);
    return os;
  }

  DebugInfo* debug_info() const LIEF_LIFETIMEBOUND;

  instructions_it disassemble(uint64_t address,
                              size_t size) const LIEF_LIFETIMEBOUND;

  instructions_it disassemble(uint64_t address) const LIEF_LIFETIMEBOUND;

  instructions_it
      disassemble(const std::string& function) const LIEF_LIFETIMEBOUND;

  instructions_it disassemble(const uint8_t* buffer LIEF_LIFETIMEBOUND,
                              size_t size,
                              uint64_t address = 0) const LIEF_LIFETIMEBOUND;
 

  instructions_it
      disassemble(const std::vector<uint8_t>& buffer LIEF_LIFETIMEBOUND,
                  uint64_t address = 0) const LIEF_LIFETIMEBOUND {
    return disassemble(buffer.data(), buffer.size(), address);
  }
 
  instructions_it disassemble(LIEF::span<const uint8_t> buffer LIEF_LIFETIMEBOUND,
                              uint64_t address = 0) const LIEF_LIFETIMEBOUND {
    return disassemble(buffer.data(), buffer.size(), address);
  }
 
  instructions_it disassemble(LIEF::span<uint8_t> buffer LIEF_LIFETIMEBOUND,
                              uint64_t address = 0) const LIEF_LIFETIMEBOUND {
    return disassemble(buffer.data(), buffer.size(), address);
  }

  std::vector<uint8_t> assemble(uint64_t address, std::string_view Asm,
                                assembly::AssemblerConfig& config =
                                    assembly::AssemblerConfig::default_config());

  std::vector<uint8_t> assemble(uint64_t address, const llvm::MCInst& inst);

  std::vector<uint8_t> assemble(uint64_t address,
                                const std::vector<llvm::MCInst>& insts);

  virtual uint64_t page_size() const;

  DebugInfo* load_debug_info(const std::string& path);

  virtual uint64_t virtual_size() const {
    return 0;
  }

  template<class T>
  const T* cast() const LIEF_LIFETIMEBOUND {
    static_assert(std::is_base_of_v<LIEF::Binary, T>,
                  "Require Abstract binary inheritance");
    if (T::classof(this)) {
      return static_cast<const T*>(this);
    }
    return nullptr;
  }
 
  template<class T>
  T* cast() LIEF_LIFETIMEBOUND {
    return const_cast<T*>(static_cast<const Binary*>(this)->cast<T>());
  }
 
  protected:
  FORMATS format_ = FORMATS::UNKNOWN;
  mutable std::unique_ptr<DebugInfo> debug_info_;
  mutable std::unordered_map<uint32_t, std::unique_ptr<assembly::Engine>> engines_;
  uint64_t original_size_ = 0;
 
  assembly::Engine* get_engine(uint64_t address) const;
 
  template<uint32_t Key, class F>
  LIEF_LOCAL assembly::Engine* get_cache_engine(uint64_t address, F&& f) const;
 
  // These functions need to be overloaded by the object that claims to extend this
  // Abstract Binary
  virtual Header get_abstract_header() const = 0;
  virtual symbols_t get_abstract_symbols() = 0;
  virtual sections_t get_abstract_sections() = 0;
  virtual relocations_t get_abstract_relocations() = 0;
 
  virtual functions_t get_abstract_exported_functions() const = 0;
  virtual functions_t get_abstract_imported_functions() const = 0;
  virtual std::vector<std::string> get_abstract_imported_libraries() const = 0;
};
 
LIEF_API const char* to_string(Binary::VA_TYPES e);
LIEF_API const char* to_string(Binary::FORMATS e);
 
}
 
 
#endif