OptionalHeader.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_OPTIONAL_HEADER_H
#define LIEF_PE_OPTIONAL_HEADER_H
#include <ostream>
#include <vector>
#include <cstdint>
 
#include "LIEF/Object.hpp"
#include "LIEF/visibility.h"
 
#include "LIEF/enums.hpp"
#include "LIEF/PE/enums.hpp"
 
namespace LIEF {
namespace PE {
class Parser;
class Binary;
 
namespace details {
struct pe32_optional_header;
struct pe64_optional_header;
}
 
class LIEF_API OptionalHeader : public Object {
  friend class Parser;
  friend class Binary;
  public:
 
  enum class DLL_CHARACTERISTICS: size_t  {
    HIGH_ENTROPY_VA       = 0x0020, 
    DYNAMIC_BASE          = 0x0040, 
    FORCE_INTEGRITY       = 0x0080, 
    NX_COMPAT             = 0x0100, 
    NO_ISOLATION          = 0x0200, 
    NO_SEH                = 0x0400, 
    NO_BIND               = 0x0800, 
    APPCONTAINER          = 0x1000, 
    WDM_DRIVER            = 0x2000, 
    GUARD_CF              = 0x4000, 
    TERMINAL_SERVER_AWARE = 0x8000  
  };
 
  enum class SUBSYSTEM: size_t  {
    UNKNOWN                  = 0,  
    NATIVE                   = 1,  
    WINDOWS_GUI              = 2,  
    WINDOWS_CUI              = 3,  
    OS2_CUI                  = 5,  
    POSIX_CUI                = 7,  
    NATIVE_WINDOWS           = 8,  
    WINDOWS_CE_GUI           = 9,  
    EFI_APPLICATION          = 10, 
    EFI_BOOT_SERVICE_DRIVER  = 11, 
    EFI_RUNTIME_DRIVER       = 12, 
    EFI_ROM                  = 13, 
    XBOX                     = 14, 
    WINDOWS_BOOT_APPLICATION = 16  
  };
 
  OptionalHeader(const details::pe32_optional_header& header);
  OptionalHeader(const details::pe64_optional_header& header);
  ~OptionalHeader() override = default;
 
  OptionalHeader& operator=(const OptionalHeader&) = default;
  OptionalHeader(const OptionalHeader&) = default;
 
  static OptionalHeader create(PE_TYPE type);
 
  PE_TYPE magic() const {
    return magic_;
  }
 
  uint8_t major_linker_version() const {
    return major_linker_version_;
  }
 
  uint8_t minor_linker_version() const {
    return minor_linker_version_;
  }
 
  uint32_t sizeof_code() const {
    return sizeof_code_;
  }
 
  uint32_t sizeof_initialized_data() const {
    return sizeof_initialized_data_;
  }
 
  uint32_t sizeof_uninitialized_data() const {
    return sizeof_uninitialized_data_;
  }
 
  uint32_t addressof_entrypoint() const {
    return entrypoint_;
  }
 
  uint32_t baseof_code() const {
    return baseof_code_;
  }
 
  uint32_t baseof_data() const {
    return baseof_data_;
  }
 
  uint64_t imagebase() const {
    return imagebase_;
  }
 
  uint32_t section_alignment() const {
    return section_align_;
  }
 
  uint32_t file_alignment() const {
    return file_align_;
  }
 
  uint16_t major_operating_system_version() const {
    return major_os_version_;
  }
 
  uint16_t minor_operating_system_version() const {
    return minor_os_version_;
  }
 
  uint16_t major_image_version() const {
    return major_image_version_;
  }
 
  uint16_t minor_image_version() const {
    return minor_image_version_;
  }
 
  uint16_t major_subsystem_version() const {
    return major_subsys_version_;
  }
 
  uint16_t minor_subsystem_version() const {
    return minor_subsys_version_;
  }
 
  uint32_t win32_version_value() const {
    return win32_version_value_;
  }
 
  uint32_t sizeof_image() const {
    return sizeof_image_;
  }
 
  uint32_t sizeof_headers() const {
    return sizeof_headers_;
  }
 
  uint32_t checksum() const {
    return checksum_;
  }
 
  SUBSYSTEM subsystem() const {
    return subsystem_;
  }
 
  uint32_t dll_characteristics() const {
    return dll_characteristics_;
  }
 
  uint64_t sizeof_stack_reserve() const {
    return sizeof_stack_reserve_;
  }
 
  uint64_t sizeof_stack_commit() const {
    return sizeof_stack_commit_;
  }
 
  uint64_t sizeof_heap_reserve() const {
    return sizeof_heap_reserve_;
  }
 
  uint64_t sizeof_heap_commit() const {
    return sizeof_heap_commit_;
  }
 
  uint32_t loader_flags() const {
    return loader_flags_;
  }
 
  uint32_t numberof_rva_and_size() const {
    return nb_rva_size_;
  }
 
  bool has(DLL_CHARACTERISTICS c) const {
    return (dll_characteristics() & static_cast<uint32_t>(c)) != 0;
  }
 
  std::vector<DLL_CHARACTERISTICS> dll_characteristics_list() const;
 
  void add(DLL_CHARACTERISTICS c) {
    dll_characteristics(dll_characteristics() | static_cast<uint32_t>(c));
  }
 
  void remove(DLL_CHARACTERISTICS c) {
    dll_characteristics(dll_characteristics() & (~ static_cast<uint32_t>(c)));
  }
 
  void magic(PE_TYPE magic) {
    magic_ = magic;
  }
 
  void major_linker_version(uint8_t value) {
    major_linker_version_ = value;
  }
 
  void minor_linker_version(uint8_t value) {
    minor_linker_version_ = value;
  }
 
  void sizeof_code(uint32_t value) {
    sizeof_code_ = value;
  }
 
  void sizeof_initialized_data(uint32_t value) {
    sizeof_initialized_data_ = value;
  }
 
  void sizeof_uninitialized_data(uint32_t value) {
    sizeof_uninitialized_data_ = value;
  }
 
  void addressof_entrypoint(uint32_t value) {
    entrypoint_ = value;
  }
 
  void baseof_code(uint32_t value) {
    baseof_code_ = value;
  }
 
  void baseof_data(uint32_t value) {
    baseof_data_ = value;
  }
 
  void imagebase(uint64_t value) {
    imagebase_ = value;
  }
 
  void section_alignment(uint32_t value) {
    section_align_ = value;
  }
 
  void file_alignment(uint32_t value) {
    file_align_ = value;
  }
 
  void major_operating_system_version(uint16_t value) {
    major_os_version_ = value;
  }
 
  void minor_operating_system_version(uint16_t value) {
    minor_os_version_ = value;
  }
 
  void major_image_version(uint16_t value) {
    major_image_version_ = value;
  }
 
  void minor_image_version(uint16_t value) {
    minor_image_version_ = value;
  }
 
  void major_subsystem_version(uint16_t value) {
    major_subsys_version_ = value;
  }
 
  void minor_subsystem_version(uint16_t value) {
    minor_subsys_version_ = value;
  }
 
  void win32_version_value(uint32_t value) {
    win32_version_value_ = value;
  }
 
  void sizeof_image(uint32_t value) {
    sizeof_image_ = value;
  }
 
  void sizeof_headers(uint32_t value) {
    sizeof_headers_ = value;
  }
 
  void checksum(uint32_t value) {
    checksum_ = value;
  }
 
  void subsystem(SUBSYSTEM value) {
    subsystem_ = value;
  }
 
  void dll_characteristics(uint32_t value) {
    dll_characteristics_ = value;
  }
 
  void sizeof_stack_reserve(uint64_t value) {
    sizeof_stack_reserve_ = value;
  }
 
  void sizeof_stack_commit(uint64_t value) {
    sizeof_stack_commit_ = value;
  }
 
  void sizeof_heap_reserve(uint64_t value) {
    sizeof_heap_reserve_ = value;
  }
 
  void sizeof_heap_commit(uint64_t value) {
    sizeof_heap_commit_ = value;
  }
 
  void loader_flags(uint32_t value) {
    loader_flags_ = value;
  }
 
  void numberof_rva_and_size(uint32_t value) {
    nb_rva_size_ = value;
  }
 
  void accept(Visitor& visitor) const override;
 
  OptionalHeader& operator+=(DLL_CHARACTERISTICS c) {
    add(c);
    return *this;
  }
  OptionalHeader& operator-=(DLL_CHARACTERISTICS c) {
    remove(c);
    return *this;
  }
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os, const OptionalHeader& entry);
 
  private:
  OptionalHeader() = default;
 
  PE_TYPE   magic_ = PE_TYPE::PE32;
  uint8_t   major_linker_version_ = 0;
  uint8_t   minor_linker_version_ = 0;
  uint32_t  sizeof_code_ = 0;
  uint32_t  sizeof_initialized_data_ = 0;
  uint32_t  sizeof_uninitialized_data_ = 0;
  uint32_t  entrypoint_ = 0;
  uint32_t  baseof_code_ = 0;
  uint32_t  baseof_data_ = 0;
  uint64_t  imagebase_ = 0;
  uint32_t  section_align_ = 0;
  uint32_t  file_align_ = 0;
  uint16_t  major_os_version_ = 0;
  uint16_t  minor_os_version_ = 0;
  uint16_t  major_image_version_ = 0;
  uint16_t  minor_image_version_ = 0;
  uint16_t  major_subsys_version_ = 0;
  uint16_t  minor_subsys_version_ = 0;
  uint32_t  win32_version_value_ = 0;
  uint32_t  sizeof_image_ = 0;
  uint32_t  sizeof_headers_ = 0;
  uint32_t  checksum_ = 0;
  SUBSYSTEM subsystem_ = SUBSYSTEM::UNKNOWN;
  uint32_t  dll_characteristics_ = 0;
  uint64_t  sizeof_stack_reserve_ = 0;
  uint64_t  sizeof_stack_commit_ = 0;
  uint64_t  sizeof_heap_reserve_ = 0;
  uint64_t  sizeof_heap_commit_ = 0;
  uint32_t  loader_flags_ = 0;
  uint32_t  nb_rva_size_ = 0;
};
 
LIEF_API const char* to_string(OptionalHeader::DLL_CHARACTERISTICS);
LIEF_API const char* to_string(OptionalHeader::SUBSYSTEM);
 
}
}
 
ENABLE_BITMASK_OPERATORS(LIEF::PE::OptionalHeader::DLL_CHARACTERISTICS);
 
#endif