DyldInfo.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_MACHO_DYLD_INFO_COMMAND_H
#define LIEF_MACHO_DYLD_INFO_COMMAND_H
#include <string>
#include <set>
#include <vector>
#include <ostream>
#include <memory>
 
#include "LIEF/visibility.h"
#include "LIEF/span.hpp"
 
#include "LIEF/MachO/LoadCommand.hpp"
#include "LIEF/MachO/type_traits.hpp"
#include "LIEF/iterators.hpp"
 
namespace LIEF {
class vector_iostream;
class BinaryStream;
namespace MachO {
 
class Binary;
class BinaryParser;
class Builder;
class DyldBindingInfo;
class ExportInfo;
class LinkEdit;
class RelocationDyld;
 
namespace details {
struct dyld_info_command;
}
 
class LIEF_API DyldInfo : public LoadCommand {
 
  friend class BinaryParser;
  friend class Binary;
  friend class Builder;
  friend class LinkEdit;
 
  public:
  using info_t = std::pair<uint32_t, uint32_t>;
 
  using binding_info_t = std::vector<std::unique_ptr<DyldBindingInfo>>;
 
  using it_binding_info = ref_iterator<binding_info_t&, DyldBindingInfo*>;
 
  using it_const_binding_info = const_ref_iterator<const binding_info_t&, DyldBindingInfo*>;
 
  using export_info_t = std::vector<std::unique_ptr<ExportInfo>>;
 
  using it_export_info = ref_iterator<export_info_t&, ExportInfo*>;
 
  using it_const_export_info = const_ref_iterator<const export_info_t&, ExportInfo*>;
 
  enum class BINDING_ENCODING_VERSION {
    UNKNOWN = 0,
    V1,
    V2
  };
 
  enum class REBASE_TYPE: uint64_t  {
    POINTER         = 1u,
    TEXT_ABSOLUTE32 = 2u,
    TEXT_PCREL32    = 3u,
    THREADED        = 102u,
  };
 
  enum class REBASE_OPCODES: uint8_t {
    DONE                               = 0x00u, 
    SET_TYPE_IMM                       = 0x10u, 
    SET_SEGMENT_AND_OFFSET_ULEB        = 0x20u, 
    ADD_ADDR_ULEB                      = 0x30u, 
    ADD_ADDR_IMM_SCALED                = 0x40u, 
    DO_REBASE_IMM_TIMES                = 0x50u, 
    DO_REBASE_ULEB_TIMES               = 0x60u, 
    DO_REBASE_ADD_ADDR_ULEB            = 0x70u, 
    DO_REBASE_ULEB_TIMES_SKIPPING_ULEB = 0x80u  
  };
 
  enum class BIND_OPCODES: uint8_t {
    DONE                             = 0x00u, 
    SET_DYLIB_ORDINAL_IMM            = 0x10u, 
    SET_DYLIB_ORDINAL_ULEB           = 0x20u, 
    SET_DYLIB_SPECIAL_IMM            = 0x30u, 
    SET_SYMBOL_TRAILING_FLAGS_IMM    = 0x40u, 
    SET_TYPE_IMM                     = 0x50u, 
    SET_ADDEND_SLEB                  = 0x60u, 
    SET_SEGMENT_AND_OFFSET_ULEB      = 0x70u, 
    ADD_ADDR_ULEB                    = 0x80u, 
    DO_BIND                          = 0x90u, 
    DO_BIND_ADD_ADDR_ULEB            = 0xA0u, 
    DO_BIND_ADD_ADDR_IMM_SCALED      = 0xB0u, 
    DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 0xC0u, 
    THREADED                         = 0xD0u,
 
    THREADED_APPLY                            = 0xD0u | 0x01u,
    THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB = 0xD0u | 0x00u,
  };
 
  enum class BIND_SUBOPCODE_THREADED: uint8_t {
    SET_BIND_ORDINAL_TABLE_SIZE_ULEB = 0x00u,
    APPLY                            = 0x01u,
  };
 
  enum BIND_SYMBOL_FLAGS {
    WEAK_IMPORT = 0x1u,
    NON_WEAK_DEFINITION = 0x8u,
  };
 
  static constexpr auto OPCODE_MASK = uint32_t(0xF0);
  static constexpr auto IMMEDIATE_MASK = uint32_t(0x0F);
 
  DyldInfo();
  DyldInfo(const details::dyld_info_command& dyld_info_cmd);
 
  DyldInfo& operator=(DyldInfo other);
  DyldInfo(const DyldInfo& copy);
 
  void swap(DyldInfo& other) noexcept;
 
  std::unique_ptr<LoadCommand> clone() const override {
    return std::unique_ptr<DyldInfo>(new DyldInfo(*this));
  }
 
  ~DyldInfo() override;
 
  const info_t& rebase() const {
    return rebase_;
  }
 
  span<const uint8_t> rebase_opcodes() const {
    return rebase_opcodes_;
  }
  span<uint8_t> rebase_opcodes() {
    return rebase_opcodes_;
  }
 
  void rebase_opcodes(buffer_t raw);
 
  std::string show_rebases_opcodes() const;
 
  const info_t& bind() const {
    return bind_;
  }
 
  span<const uint8_t> bind_opcodes() const {
    return bind_opcodes_;
  }
  span<uint8_t> bind_opcodes() {
    return bind_opcodes_;
  }
 
  void bind_opcodes(buffer_t raw);
 
  std::string show_bind_opcodes() const;
 
  const info_t& weak_bind() const {
    return weak_bind_;
  }
 
  span<const uint8_t> weak_bind_opcodes() const {
    return weak_bind_opcodes_;
  }
  span<uint8_t> weak_bind_opcodes() {
    return weak_bind_opcodes_;
  }
 
  void weak_bind_opcodes(buffer_t raw);
 
  std::string show_weak_bind_opcodes() const;
 
  const info_t& lazy_bind() const {
    return lazy_bind_;
  }
 
  span<const uint8_t> lazy_bind_opcodes() const {
    return lazy_bind_opcodes_;
  }
  span<uint8_t> lazy_bind_opcodes() {
    return lazy_bind_opcodes_;
  }
 
  void lazy_bind_opcodes(buffer_t raw);
 
  std::string show_lazy_bind_opcodes() const;
 
  it_binding_info bindings() {
    return binding_info_;
  }
 
  it_const_binding_info bindings() const {
    return binding_info_;
  }
 
  const info_t& export_info() const {
    return export_;
  }
 
  it_export_info exports() {
    return export_info_;
  }
  it_const_export_info exports() const {
    return export_info_;
  }
 
  span<const uint8_t> export_trie() const {
    return export_trie_;
  }
  span<uint8_t> export_trie() {
    return export_trie_;
  }
 
  void export_trie(buffer_t raw);
 
  std::string show_export_trie() const;
 
  void rebase(const info_t& info) {
    rebase_ = info;
  }
  void bind(const info_t& info) {
    bind_ = info;
  }
  void weak_bind(const info_t& info) {
    weak_bind_ = info;
  }
  void lazy_bind(const info_t& info) {
    lazy_bind_ = info;
  }
  void export_info(const info_t& info) {
    export_ = info;
  }
 
  void set_rebase_offset(uint32_t offset) {
    rebase_ = {offset, std::get<1>(rebase())};
  }
  void set_rebase_size(uint32_t size) {
  rebase_ = {std::get<0>(rebase()), size};
  }
 
  void set_bind_offset(uint32_t offset) {
    bind_ = {offset, std::get<1>(bind())};
  }
  void set_bind_size(uint32_t size) {
    bind_ = {std::get<0>(bind()), size};
  }
 
  void set_weak_bind_offset(uint32_t offset) {
    weak_bind_ = {offset, std::get<1>(weak_bind())};
  }
  void set_weak_bind_size(uint32_t size) {
    weak_bind_ = {std::get<0>(weak_bind()), size};
  }
 
  void set_lazy_bind_offset(uint32_t offset) {
    lazy_bind_ = {offset, std::get<1>(lazy_bind())};
  }
  void set_lazy_bind_size(uint32_t size) {
    lazy_bind_ = {std::get<0>(lazy_bind()), size};
  }
 
  void set_export_offset(uint32_t offset) {
    export_ = {offset, std::get<1>(export_info())};
  }
 
  void set_export_size(uint32_t size) {
    export_ = {std::get<0>(export_info()), size};
  }
 
  void add(std::unique_ptr<ExportInfo> info);
 
  void accept(Visitor& visitor) const override;
 
  std::ostream& print(std::ostream& os) const override;
 
  static bool classof(const LoadCommand* cmd) {
    const LoadCommand::TYPE type = cmd->command();
    return type == LoadCommand::TYPE::DYLD_INFO ||
           type == LoadCommand::TYPE::DYLD_INFO_ONLY;
  }
 
  private:
  using bind_container_t = std::set<DyldBindingInfo*, std::function<bool(DyldBindingInfo*, DyldBindingInfo*)>>;
 
  void show_bindings(std::ostream& os, span<const uint8_t> buffer, bool is_lazy = false) const;
 
  void show_trie(std::ostream& output, std::string output_prefix, BinaryStream& stream, uint64_t start, uint64_t end, const std::string& prefix) const;
 
  LIEF_LOCAL DyldInfo& update_standard_bindings(const bind_container_t& bindings, vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_standard_bindings_v1(const bind_container_t& bindings, vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_standard_bindings_v2(const bind_container_t& bindings,
                                                   std::vector<RelocationDyld*> rebases, vector_iostream& stream);
 
  LIEF_LOCAL DyldInfo& update_weak_bindings(const bind_container_t& bindings, vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_lazy_bindings(const bind_container_t& bindings, vector_iostream& stream);
 
  LIEF_LOCAL DyldInfo& update_rebase_info(vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_binding_info(vector_iostream& stream, details::dyld_info_command& cmd);
  LIEF_LOCAL DyldInfo& update_export_trie(vector_iostream& stream);
 
  info_t   rebase_;
  span<uint8_t> rebase_opcodes_;
 
  info_t   bind_;
  span<uint8_t> bind_opcodes_;
 
  info_t   weak_bind_;
  span<uint8_t> weak_bind_opcodes_;
 
  info_t   lazy_bind_;
  span<uint8_t> lazy_bind_opcodes_;
 
  info_t   export_;
  span<uint8_t> export_trie_;
 
  export_info_t  export_info_;
  binding_info_t binding_info_;
 
  BINDING_ENCODING_VERSION binding_encoding_version_ = BINDING_ENCODING_VERSION::UNKNOWN;
 
  Binary* binary_ = nullptr;
};
 
LIEF_API const char* to_string(DyldInfo::REBASE_TYPE e);
LIEF_API const char* to_string(DyldInfo::REBASE_OPCODES e);
LIEF_API const char* to_string(DyldInfo::BIND_OPCODES e);
LIEF_API const char* to_string(DyldInfo::BIND_SUBOPCODE_THREADED e);
 
 
}
}
#endif