runtime/Memory.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_RUNTIME_MEMORY_H
#define LIEF_RUNTIME_MEMORY_H
#include <ostream>
#include <cstdint>
#include <cstring>
#include <vector>
#include <utility>
 
#include "LIEF/visibility.h"
#include "LIEF/optional.hpp"
#include "LIEF/logging.hpp"
#include "LIEF/compiler_attributes.hpp"
 
#include "LIEF/runtime/utils.hpp"
 
namespace LIEF {
namespace runtime {

class LIEF_API Memory {
  public:
  enum MMAP_FLAGS : uint32_t {
    MP_NONE = 0,

    MP_PRIVATE = 1 << 0,

    MP_ANONYMOUS = 1 << 1,

    MP_SHARED = 1 << 2,

    MP_FIXED = 1 << 3,

    MP_JIT = 1 << 4,
  };
 
  enum PERM : uint32_t {
    P_NONE = 0,
    P_READ = 1 << 0,
    P_WRITE = 1 << 1,
    P_EXEC = 1 << 2,
  };

  class LIEF_API Chunk {
    public:
    friend class Memory;
 
    Chunk(void* addr, size_t size, uint32_t permissions) :
      addr_(addr),
      size_(size),
      permissions_(permissions) {}
 
    Chunk(void* addr, size_t size) :
      Chunk(addr, size, /*permissions=*/P_NONE) {}
 
    Chunk(void* addr) :
      Chunk(addr, /*size=*/0, /*permissions=*/P_NONE) {}

    void* addr_ptr() {
      return addr_;
    }
 
    const void* addr_ptr() const {
      return addr_;
    }

    uintptr_t addr() const {
      return reinterpret_cast<uintptr_t>(addr_);
    }

    size_t size() const {
      return size_;
    }

    uint32_t permissions() const {
      return permissions_;
    }

    uintptr_t page_start() const;
 

    uintptr_t page_end() const;

    Chunk& change_permissions(uint32_t p) LIEF_LIFETIMEBOUND {
      if (!Memory::mprotect(*this, p)) {
        logging::err("mprotect failed for chunk: {}", to_string());
      }
      permissions_ = p;
      return *this;
    }

    Chunk& make_x() LIEF_LIFETIMEBOUND {
      return change_permissions(P_EXEC);
    }

    Chunk& make_rw() LIEF_LIFETIMEBOUND {
      return change_permissions(P_READ | P_WRITE);
    }

    Chunk& make_rx() LIEF_LIFETIMEBOUND {
      return change_permissions(P_READ | P_EXEC);
    }

    Chunk& make_rwx() LIEF_LIFETIMEBOUND {
      return change_permissions(P_READ | P_WRITE | P_EXEC);
    }

    Chunk& make_ro() LIEF_LIFETIMEBOUND {
      return change_permissions(P_READ);
    }

    Chunk& cache_flush() LIEF_LIFETIMEBOUND;

    bool is_valid() const {
      return addr_ != nullptr;
    }
 
    operator bool() const {
      return is_valid();
    }
 
    ok_error_t deallocate() {
      return Memory::munmap(*this);
    }
 
    std::string to_string() const;
 
    friend LIEF_API std::ostream& operator<<(std::ostream& os, const Chunk& C) {
      os << C.to_string();
      return os;
    }
 
    protected:
    void* addr_ = 0;
    size_t size_ = 0;
    uint32_t permissions_ = P_NONE;
  };

  class LIEF_API ScopedPermissions {
    public:
    explicit ScopedPermissions(Chunk& chunk, uint32_t perms) :
      chunk_(&chunk),
      perms_(chunk.permissions()) {
      chunk_->change_permissions(perms);
    }
 
    ~ScopedPermissions() {
      chunk_->change_permissions(perms_);
    }
 
    private:
    Chunk* chunk_ = nullptr;
    uint32_t perms_ = P_NONE;
  };

  static optional<Chunk> mmap(size_t size, uint32_t flags,
                              uint32_t permissions = P_NONE);

  static ok_error_t munmap(Chunk& C);

  static ok_error_t mprotect(Chunk& C, uint32_t flags);

  static ok_error_t write(const uint8_t* buffer, size_t size, uintptr_t addr) {
    std::memcpy(reinterpret_cast<void*>(addr), buffer, size);
    return ok();
  }

  static ok_error_t write(const std::vector<uint8_t>& buffer, uintptr_t addr) {
    return write(buffer.data(), buffer.size(), addr);
  }

  template<class T,
           typename = typename std::enable_if<std::is_standard_layout<T>::value &&
                                              std::is_trivial<T>::value>::type>
  static ok_error_t write(const T& value, uintptr_t addr) {
    return write(reinterpret_cast<const uint8_t*>(&value), sizeof(T), addr);
  }

  template<class T>
  static T read(uintptr_t addr) {
    T out{};
    std::memcpy(&out, reinterpret_cast<const void*>(addr), sizeof(T));
    return out;
  }

  static void read(uintptr_t addr, std::vector<uint8_t>& out, size_t size) {
    if (out.size() < size) {
      std::vector<uint8_t> buffer(size);
      read(addr, buffer.data(), buffer.size());
      out = std::move(buffer);
      return;
    }
    read(addr, out.data(), size);
  }

  static void read(uintptr_t addr, uint8_t* out, size_t size) {
    std::memcpy(out, reinterpret_cast<const void*>(addr), size);
  }
 
  static std::string perm_str(uint32_t flags);
 
  static constexpr bool support_rwx() {
    return platform() != PLATFORMS::IOS;
  }
};
 
}
}
#endif