LoadConfiguration.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2025 R. Thomas
 * Copyright 2017 - 2025 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_LOAD_CONFIGURATION_H
#define LIEF_PE_LOAD_CONFIGURATION_H
#include <ostream>
#include <cstdint>
 
#include <memory>
 
#include "LIEF/Object.hpp"
#include "LIEF/visibility.h"
#include "LIEF/optional.hpp"
#include "LIEF/iterators.hpp"
 
#include "LIEF/PE/CodeIntegrity.hpp"
 
namespace LIEF {
class BinaryStream;
 
namespace PE {
class Parser;
class CHPEMetadata;
class DynamicRelocation;
class EnclaveConfiguration;
class VolatileMetadata;
class LIEF_API LoadConfiguration : public Object {
  public:
  friend class Parser;
 
  enum class IMAGE_GUARD : uint32_t {
    NONE = 0x00000000,    CF_INSTRUMENTED = 0x100,
    CFW_INSTRUMENTED = 0x200,
    CF_FUNCTION_TABLE_PRESENT = 0x400,
    SECURITY_COOKIE_UNUSED = 0x800,
    PROTECT_DELAYLOAD_IAT = 0x1000,
    DELAYLOAD_IAT_IN_ITS_OWN_SECTION = 0x2000,
    CF_EXPORT_SUPPRESSION_INFO_PRESENT = 0x4000,
    CF_ENABLE_EXPORT_SUPPRESSION = 0x8000,
    CF_LONGJUMP_TABLE_PRESENT = 0x10000,
    EH_CONTINUATION_TABLE_PRESENT = 0x400000,
 
    RF_INSTRUMENTED = 0x00020000,
    RF_ENABLE = 0x00040000,
    RF_STRICT = 0x00080000,
    RETPOLINE_PRESENT = 0x00100000,
  };
 
  struct guard_function_t {
    uint32_t rva = 0;
    uint32_t extra = 0;
  };
 
  using guard_functions_t = std::vector<guard_function_t>;
  using it_guard_functions = ref_iterator<guard_functions_t&>;
  using it_const_guard_functions = const_ref_iterator<const guard_functions_t&>;
 
  using dynamic_relocations_t = std::vector<std::unique_ptr<DynamicRelocation>>;
  using it_dynamic_relocations_t = ref_iterator<dynamic_relocations_t&, DynamicRelocation*>;
  using it_const_dynamic_relocations_t = const_ref_iterator<const dynamic_relocations_t&, const DynamicRelocation*>;
 
  template<class PE_T>
  static LIEF_LOCAL
    std::unique_ptr<LoadConfiguration> parse(Parser& ctx, BinaryStream& stream);
 
  LoadConfiguration();
 
  LoadConfiguration& operator=(const LoadConfiguration&);
  LoadConfiguration(const LoadConfiguration&);
 
  LoadConfiguration(LoadConfiguration&&);
  LoadConfiguration& operator=(LoadConfiguration&&);
  uint32_t characteristics() const {
    return characteristics_;
  }

uint32_t size() const {

return characteristics_;

}