ELF/Builder.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 Quarkslab
 * Copyright 2017 - 2021, NVIDIA CORPORATION. All rights reserved
 *
 * 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_BUIDLER_H
#define LIEF_ELF_BUIDLER_H
 
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include "LIEF/errors.hpp"
 
#include "LIEF/visibility.h"
#include "LIEF/iostream.hpp"
 
namespace LIEF {
namespace ELF {
class Binary;
class Layout;
class Header;
class Note;
class DynamicEntryArray;
class DynamicEntry;
class Section;
class ExeLayout;
class ObjectFileLayout;
class Layout;
class Relocation;

class LIEF_API Builder {
  friend class ObjectFileLayout;
  friend class Layout;
  friend class ExeLayout;
 
  public:
  struct config_t {
    bool dt_hash = true;

    bool dyn_str = true;

    bool dynamic_section = true;

    bool fini_array = true;

    bool gnu_hash = true;

    bool init_array = true;

    bool interpreter = true;

    bool jmprel = true;

    bool notes = false;

    bool preinit_array = true;

    bool relr = true;

    bool android_rela = true;

    bool rela = true;

    bool static_symtab = true;

    bool sym_verdef = true;

    bool sym_verneed = true;

    bool sym_versym = true;

    bool symtab = true;

    bool coredump_notes = true;

    bool force_relocate = false;

    bool skip_dynamic = false;

    bool keep_empty_version_requirement = false;
  };
 
  Builder(Binary& binary, const config_t& config);
  Builder(Binary& binary) :
    Builder(binary, config_t()) {}
 
  Builder() = delete;
  ~Builder();

  void build();
 
  config_t& config() LIEF_LIFETIMEBOUND {
    return config_;
  }

  const std::vector<uint8_t>& get_build() LIEF_LIFETIMEBOUND;

  void write(const std::string& filename) const;

  void write(std::ostream& os) const;
 
  protected:
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_relocatable();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_exe_lib();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build(const Header& header);
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_sections();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_segments();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_symtab_symbols();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_dynamic();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_dynamic_section();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_dynamic_symbols();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_obj_symbols();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_dynamic_relocations();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_relative_relocations();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_android_relocations();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_pltgot_relocations();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_section_relocations();
 
  LIEF_LOCAL uint32_t sort_dynamic_symbols();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_hash_table();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_symbol_hash();
 
  LIEF_LOCAL ok_error_t build_empty_symbol_gnuhash();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_symbol_requirement();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_symbol_definition();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_symbol_version();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_interpreter();
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_notes();
 
  LIEF_LOCAL ok_error_t update_note_section(const Note& note,
                                            std::set<const Note*>& notes);
 
  template<typename ELF_T>
  LIEF_LOCAL ok_error_t build_overlay();
 
  LIEF_LOCAL bool should_swap() const;
 
  template<class ELF_T>
  LIEF_LOCAL ok_error_t process_object_relocations();
 
  LIEF_LOCAL bool should_build_notes() const;
 
  config_t config_;
  mutable vector_iostream ios_;
  Binary* binary_ = nullptr;
  std::unique_ptr<Layout> layout_;
};
 
} // namespace ELF
} // namespace LIEF
 
 
#endif