PE/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_PE_BINARY_H
#define LIEF_PE_BINARY_H
 
#include <map>
 
#include "LIEF/PE/Header.hpp"
#include "LIEF/PE/OptionalHeader.hpp"
#include "LIEF/PE/DosHeader.hpp"
#include "LIEF/PE/Import.hpp"
#include "LIEF/PE/DelayImport.hpp"
#include "LIEF/PE/Symbol.hpp"
#include "LIEF/PE/DataDirectory.hpp"
#include "LIEF/PE/ResourcesManager.hpp"
#include "LIEF/PE/signature/Signature.hpp"
 
#include "LIEF/Abstract/Binary.hpp"
 
#include "LIEF/visibility.h"
 
namespace LIEF {
 
namespace PE {
class Builder;
class CodeViewPDB;
class Debug;
class Export;
class LoadConfiguration;
class Parser;
class Relocation;
class ResourceData;
class ResourceDirectory;
class ResourceNode;
class RichHeader;
class TLS;
 
class LIEF_API Binary : public LIEF::Binary {
  friend class Parser;
  friend class Builder;
 
  public:
  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*>;
 
  using data_directories_t = std::vector<std::unique_ptr<DataDirectory>>;
 
  using it_data_directories = ref_iterator<data_directories_t&, DataDirectory*>;
 
  using it_const_data_directories = const_ref_iterator<const data_directories_t&, const DataDirectory*>;
 
  using relocations_t = std::vector<std::unique_ptr<Relocation>>;
 
  using it_relocations = ref_iterator<relocations_t&, Relocation*>;
 
  using it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>;
 
  using imports_t = std::vector<Import>;
 
  using it_imports = ref_iterator<imports_t&>;
 
  using it_const_imports = const_ref_iterator<const imports_t&>;
 
  using delay_imports_t = std::vector<DelayImport>;
 
  using it_delay_imports = ref_iterator<delay_imports_t&>;
 
  using it_const_delay_imports = const_ref_iterator<const delay_imports_t&>;
 
  using debug_entries_t = std::vector<std::unique_ptr<Debug>>;
 
  using it_debug_entries = ref_iterator<debug_entries_t&, Debug*>;
 
  using it_const_debug_entries = const_ref_iterator<const debug_entries_t&, const Debug*>;
 
  using symbols_t = std::vector<Symbol>;
 
  using it_symbols = ref_iterator<symbols_t&>;
 
  using it_const_symbols = const_ref_iterator<const symbols_t&>;
 
  using strings_table_t = std::vector<std::string>;
 
  using it_strings_table = ref_iterator<strings_table_t&>;
 
  using it_const_strings_table = const_ref_iterator<const strings_table_t&>;
 
  using signatures_t = std::vector<Signature>;
 
  using it_signatures = ref_iterator<signatures_t&>;
 
  using it_const_signatures = const_ref_iterator<const signatures_t&>;
 
  Binary(PE_TYPE type);
 
  ~Binary() override;
 
  PE_TYPE type() const {
    return type_;
  }
 
  uint64_t rva_to_offset(uint64_t RVA);
 
  uint64_t va_to_offset(uint64_t VA);
 
  result<uint64_t> offset_to_virtual_address(uint64_t offset, uint64_t slide = 0) const override;
 
  uint64_t imagebase() const override {
    return optional_header().imagebase();
  }
 
  Section* section_from_offset(uint64_t offset);
  const Section* section_from_offset(uint64_t offset) const;
 
  Section* section_from_rva(uint64_t virtual_address);
  const Section* section_from_rva(uint64_t virtual_address) const;
 
  it_sections sections() {
    return sections_;
  }
 
  it_const_sections sections() const {
    return sections_;
  }
 
  DosHeader& dos_header() {
    return dos_header_;
  }
 
  const DosHeader& dos_header() const {
    return dos_header_;
  }
 
  Header& header() {
    return header_;
  }
 
  const Header& header() const {
    return header_;
  }
 
  OptionalHeader& optional_header() {
    return optional_header_;
  }
 
  const OptionalHeader& optional_header() const {
    return optional_header_;
  }
 
  uint64_t virtual_size() const;
 
  uint32_t sizeof_headers() const;
 
  TLS* tls() {
    return tls_.get();
  }
 
  const TLS* tls() const {
    return tls_.get();
  }
 
  void tls(const TLS& tls);
 
  bool has_tls() const {
    return tls_ != nullptr;
  }
 
  bool has_imports() const {
    return !imports_.empty();
  }
 
  bool has_signatures() const {
    return !signatures_.empty();
  }
 
  bool has_exports() const {
    return export_ != nullptr;
  }
 
  bool has_resources() const {
    return resources_ != nullptr;
  }
 
  bool has_exceptions() const;
 
  bool has_relocations() const {
    return !relocations_.empty();
  }
 
  bool has_debug() const {
    return !debug_.empty();
  }
 
  bool has_configuration() const {
    return load_configuration_ != nullptr;
  }
 
  bool is_reproducible_build() const;
 
  it_const_signatures signatures() const {
    return signatures_;
  }
 
  it_signatures signatures() {
    return signatures_;
  }
 
  Signature::VERIFICATION_FLAGS verify_signature(
      Signature::VERIFICATION_CHECKS checks = Signature::VERIFICATION_CHECKS::DEFAULT) const;
 
  Signature::VERIFICATION_FLAGS verify_signature(const Signature& sig,
      Signature::VERIFICATION_CHECKS checks = Signature::VERIFICATION_CHECKS::DEFAULT) const;
 
  std::vector<uint8_t> authentihash(ALGORITHMS algo) const;
 
  uint32_t predict_function_rva(const std::string& library, const std::string& function);
 
  Export* get_export() {
    return export_.get();
  }
 
  const Export* get_export() const {
    return export_.get();
  }
 
  std::vector<Symbol>& symbols();
  const std::vector<Symbol>& symbols() const;
 
  ResourceNode* resources() {
    return resources_.get();
  }
 
  const ResourceNode* resources() const {
    return resources_.get();
  }
 
  void set_resources(const ResourceDirectory& resource);
 
  void set_resources(const ResourceData& resource);
 
  result<ResourcesManager> resources_manager() const;
 
  Section* get_section(const std::string& name);
  const Section* get_section(const std::string& name) const;
 
  const Section* import_section() const;
  Section*       import_section();
 
  void remove_section(const std::string& name, bool clear = false) override;
 
  void remove(const Section& section, bool clear = false);
 
  Section* add_section(const Section& section,
                       PE_SECTION_TYPES type = PE_SECTION_TYPES::UNKNOWN);
 
  it_relocations relocations() {
    return relocations_;
  }
 
  it_const_relocations relocations() const {
    return relocations_;
  }
 
  Relocation& add_relocation(const Relocation& relocation);
 
  void remove_all_relocations();
 
  it_data_directories data_directories() {
    return data_directories_;
  }
 
  it_const_data_directories data_directories() const {
    return data_directories_;
  }
 
  DataDirectory* data_directory(DataDirectory::TYPES type);
  const DataDirectory* data_directory(DataDirectory::TYPES type) const;
 
  bool has(DataDirectory::TYPES type) const {
    return data_directory(type) != nullptr;
  }
 
  it_debug_entries debug() {
    return debug_;
  }
 
  it_const_debug_entries debug() const {
    return debug_;
  }
 
  const CodeViewPDB* codeview_pdb() const;
 
  const LoadConfiguration* load_configuration() const {
    return load_configuration_.get();
  }
 
  LoadConfiguration* load_configuration() {
    return load_configuration_.get();
  }
 
  span<const uint8_t> overlay() const {
    return overlay_;
  }
 
  span<uint8_t> overlay() {
    return overlay_;
  }
 
  uint64_t overlay_offset() const {
    return overlay_offset_;
  }
 
  span<const uint8_t> dos_stub() const {
    return dos_stub_;
  }
 
  span<uint8_t> dos_stub() {
    return dos_stub_;
  }
 
  void dos_stub(const std::vector<uint8_t>& content);
 
  // Rich Header
  // -----------
 
  RichHeader* rich_header() {
    return rich_header_.get();
  }
 
  const RichHeader* rich_header() const {
    return rich_header_.get();
  }
 
  void rich_header(const RichHeader& rich_header);
 
  bool has_rich_header() const {
    return rich_header_ != nullptr;
  }
 
  it_imports imports() {
    return imports_;
  }
 
  it_const_imports imports() const {
    return imports_;
  }
 
  Import* get_import(const std::string& import_name);
  const Import* get_import(const std::string& import_name) const;
 
  bool has_import(const std::string& import_name) const {
    return get_import(import_name) != nullptr;
  }
 
  bool has_delay_imports() const {
    return !delay_imports_.empty();
  }
 
  it_delay_imports delay_imports() {
    return delay_imports_;
  }
 
  it_const_delay_imports delay_imports() const {
    return delay_imports_;
  }
 
  DelayImport* get_delay_import(const std::string& import_name);
  const DelayImport* get_delay_import(const std::string& import_name) const;
 
 
  bool has_delay_import(const std::string& import_name) const {
    return get_delay_import(import_name) != nullptr;
  }
 
 
  ImportEntry* add_import_function(const std::string& library, const std::string& function);
 
  Import& add_library(const std::string& name);
 
  void remove_library(const std::string& name);
 
  void remove_all_libraries();
 
  void write(const std::string& filename) override;
 
  void write(std::ostream& os) override;
 
  void accept(Visitor& visitor) 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;
 
  bool has_nx() const override;
 
  LIEF::Binary::functions_t ctor_functions() const override;
 
  LIEF::Binary::functions_t functions() const;
 
  LIEF::Binary::functions_t exception_functions() const;
 
  static bool classof(const LIEF::Binary* bin) {
    return bin->format() == Binary::FORMATS::PE;
  }
 
  std::ostream& print(std::ostream& os) const override;
 
  private:
  Binary();
 
  void make_space_for_new_section();
 
  LIEF::Binary::symbols_t get_abstract_symbols() override;
 
  LIEF::Header get_abstract_header() const override;
 
  LIEF::Binary::sections_t get_abstract_sections() 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;
 
  void update_lookup_address_table_offset();
  void update_iat();
 
  PE_TYPE        type_ = PE_TYPE::PE32_PLUS;
  DosHeader      dos_header_;
  Header         header_;
  OptionalHeader optional_header_;
 
  int32_t available_sections_space_ = 0;
 
  signatures_t signatures_;
  sections_t           sections_;
  data_directories_t   data_directories_;
  symbols_t            symbols_;
  strings_table_t      strings_table_;
  relocations_t        relocations_;
  imports_t            imports_;
  delay_imports_t      delay_imports_;
  debug_entries_t      debug_;
  uint64_t overlay_offset_ = 0;
  std::vector<uint8_t> overlay_;
  std::vector<uint8_t> dos_stub_;
  std::vector<uint8_t> section_offset_padding_;
 
  std::unique_ptr<RichHeader> rich_header_;
  std::unique_ptr<Export> export_;
  std::unique_ptr<ResourceNode> resources_;
  std::unique_ptr<TLS> tls_;
  std::unique_ptr<LoadConfiguration> load_configuration_;
};
 
}
}
#endif