EnclaveConfiguration.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_LOAD_CONFIGURATION_ENCLAVE_CONFIG_H
#define LIEF_PE_LOAD_CONFIGURATION_ENCLAVE_CONFIG_H
#include <memory>
#include <string>
#include <array>
 
#include "LIEF/iterators.hpp"
#include "LIEF/visibility.h"
#include "LIEF/PE/LoadConfigurations/EnclaveImport.hpp"
 
namespace LIEF {
class BinaryStream;
namespace PE {
class Parser;

class LIEF_API EnclaveConfiguration {
  public:
  static constexpr auto MIN_SIZE = 0x4C; // sizeof(IMAGE_ENCLAVE_CONFIG32)
 
  static constexpr auto POLICY_DEBUGGABLE = 0x00000001;
  static constexpr auto POLICY_STRICT_MEMORY = 0x00000002;
 
  using id_array_t = std::array<uint8_t, 16>;
 
  using imports_t = std::vector<EnclaveImport>;
  using it_imports = ref_iterator<imports_t&>;
  using it_const_imports = const_ref_iterator<const imports_t&>;
 
  EnclaveConfiguration() = default;
  EnclaveConfiguration(const EnclaveConfiguration&) = default;
  EnclaveConfiguration& operator=(const EnclaveConfiguration&) = default;
 
  EnclaveConfiguration(EnclaveConfiguration&&) = default;
  EnclaveConfiguration& operator=(EnclaveConfiguration&&) = default;
 
  std::unique_ptr<EnclaveConfiguration> clone() const {
    return std::unique_ptr<EnclaveConfiguration>(new EnclaveConfiguration(*this));
  }

  uint32_t size() const {
    return size_;
  }

  uint32_t min_required_config_size() const {
    return min_req_size_;
  }

  uint32_t policy_flags() const {
    return policy_flags_;
  }

  bool is_debuggable() const {
    return (policy_flags_ & POLICY_DEBUGGABLE) != 0;
  }

  uint32_t import_list_rva() const {
    return imports_list_rva_;
  }

  uint32_t import_entry_size() const {
    return import_entry_size_;
  }

  size_t nb_imports() const {
    return imports_.size();
  }

  it_imports imports() {
    return imports_;
  }
 
  it_const_imports imports() const {
    return imports_;
  }

  const id_array_t& family_id() const {
    return family_id_;
  }

  const id_array_t& image_id() const {
    return image_id_;
  }

  uint32_t image_version() const {
    return image_version_;
  }

  uint32_t security_version() const {
    return security_version_;
  }

  uint64_t enclave_size() const {
    return enclave_size_;
  }

  uint32_t nb_threads() const {
    return nb_threads_;
  }

  uint32_t enclave_flags() const {
    return enclave_flags_;
  }
 
  EnclaveConfiguration& size(uint32_t value) {
    size_ = value;
    return *this;
  }
 
  EnclaveConfiguration& min_required_config_size(uint32_t value) {
    min_req_size_ = value;
    return *this;
  }
 
  EnclaveConfiguration& policy_flags(uint32_t value) {
    policy_flags_ = value;
    return *this;
  }
 
  EnclaveConfiguration& import_list_rva(uint32_t value) {
    imports_list_rva_ = value;
    return *this;
  }
 
  EnclaveConfiguration& import_entry_size(uint32_t value) {
    import_entry_size_ = value;
    return *this;
  }
 
  EnclaveConfiguration& family_id(const id_array_t& value) {
    family_id_ = value;
    return *this;
  }
 
  EnclaveConfiguration& image_id(const id_array_t& value) {
    image_id_ = value;
    return *this;
  }
 
  EnclaveConfiguration& image_version(uint32_t value) {
    image_version_ = value;
    return *this;
  }
 
  EnclaveConfiguration& security_version(uint32_t value) {
    security_version_ = value;
    return *this;
  }
 
  EnclaveConfiguration& enclave_size(uint64_t value) {
    enclave_size_ = value;
    return *this;
  }
 
  EnclaveConfiguration& nb_threads(uint32_t value) {
    nb_threads_ = value;
    return *this;
  }
 
  EnclaveConfiguration& enclave_flags(uint32_t value) {
    enclave_flags_ = value;
    return *this;
  }
 
  std::string to_string() const;
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os,
                                           const EnclaveConfiguration& meta) {
    os << meta.to_string();
    return os;
  }

  template<class PE_T>
  LIEF_LOCAL static std::unique_ptr<EnclaveConfiguration>
      parse(Parser& ctx, BinaryStream& stream);
 
  private:
  uint32_t size_ = 0;
  uint32_t min_req_size_ = 0;
  uint32_t policy_flags_ = 0;
  uint32_t imports_list_rva_ = 0;
  uint32_t import_entry_size_ = 0;
  id_array_t family_id_ = {0};
  id_array_t image_id_ = {0};
  uint32_t image_version_ = 0;
  uint32_t security_version_ = 0;
  uint64_t enclave_size_ = 0;
  uint32_t nb_threads_ = 0;
  uint32_t enclave_flags_ = 0;
 
  imports_t imports_;
};
}
}
 
#endif