OptionalHeader.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_PE_OPTIONAL_HEADER_H
#define LIEF_PE_OPTIONAL_HEADER_H
#include <cstdint>
#include <optional>
#include <ostream>
#include <vector>
 
#include "LIEF/Object.hpp"
#include "LIEF/compiler_attributes.hpp"
#include "LIEF/visibility.h"
 
#include "LIEF/PE/enums.hpp"
#include "LIEF/enums.hpp"
 
namespace LIEF {
class vector_iostream;
}
 
namespace LIEF::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, 
    XBOX_CODE_CATALOG = 17,        
  };
 
  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) LIEF_LIFETIMEBOUND {
    add(c);
    return *this;
  }
  OptionalHeader& operator-=(DLL_CHARACTERISTICS c) LIEF_LIFETIMEBOUND {
    remove(c);
    return *this;
  }
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os,
                                           const OptionalHeader& entry);

  template<typename PE_T>
  LIEF_LOCAL size_t
      serialize(vector_iostream& ios,
                std::optional<uint64_t> imagebase = std::nullopt) const;
 
  LIEF_LOCAL size_t
      serialize(LIEF::PE::PE_TYPE type, vector_iostream& ios,
                std::optional<uint64_t> imagebase = std::nullopt) const;
 
 
  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