fix: add safe memory accessor, protector and some other improvements

Author: qubka

CMakeLists.txt

@@ -43,7 +43,10 @@ elseif(MACOS)
 endif()
 
 set(COMPILE_DEFINITIONS
-	-DDYNLIBUTILS_SEPARATE_SOURCE_FILES
+	#DYNLIBUTILS_SEPARATE_SOURCE_FILES
+	DYNLIBUTILS_PLATFORM_LINUX=${LINUX}
+	DYNLIBUTILS_PLATFORM_WINDOWS=${WIN32}
+	DYNLIBUTILS_PLATFORM_APPLE=${APPLE}
 )
 
 set(INCLUDE_DIRS
@@ -52,21 +55,29 @@ set(INCLUDE_DIRS
 
 if(WINDOWS)
 	set(SOURCE_FILES
+			${SOURCE_DIR}/windows/memaccessor.cpp
+			${SOURCE_DIR}/windows/memprotector.cpp
 			${SOURCE_DIR}/windows/module.cpp
 	)
 elseif(LINUX)
 	set(SOURCE_FILES
+			${SOURCE_DIR}/linux/memaccessor.cpp
+			${SOURCE_DIR}/linux/memprotector.cpp
 			${SOURCE_DIR}/linux/module.cpp
 	)
 elseif(MACOS)
 	set(SOURCE_FILES
+			${SOURCE_DIR}/apple/memaccessor.cpp
+			${SOURCE_DIR}/apple/memprotector.cpp
 			${SOURCE_DIR}/apple/module.cpp
 	)
 else()
 	message(FATAL_ERROR "Unsupported platform")
 endif()
 
 list(APPEND SOURCE_FILES
+		${SOURCE_DIR}/memaccessor.cpp
+		${SOURCE_DIR}/memprotector.cpp
 		${SOURCE_DIR}/module.cpp # always include last
 )
 

include/dynlibutils/macros.h

@@ -1,6 +1,8 @@
+//
 // DynLibUtils
-// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r) & Borys Komashchenko (Phoenix)
+// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r), Borys Komashchenko (Phoenix), Nikita Ushakov (qubka)
 // Licensed under the MIT license. See LICENSE file in the project root for details.
+//
 
 #ifndef DYNLIBUTILS_MACROS_H
 #define DYNLIBUTILS_MACROS_H

include/dynlibutils/memaccessor.hpp

@@ -0,0 +1,79 @@
+//
+// DynLibUtils
+// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r), Borys Komashchenko (Phoenix), Nikita Ushakov (qubka)
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+
+#ifndef DYNLIBUTILS_MEMACCESSOR_H
+#define DYNLIBUTILS_MEMACCESSOR_H
+#pragma once
+
+#include "memaddr.hpp"
+#include "protflag.hpp"
+
+namespace DynLibUtils
+{
+	/**
+	 * @class MemAccessor
+	 * @brief A class providing various memory access routines.
+	 */
+	class CMemAccessor
+	{
+	public:
+		/**
+		 * @brief Defines a memory read/write routine that may fail ungracefully.
+		 * It's expected this library will only ever use this routine in cases that are expected to succeed.
+		 * @param dest The destination memory address.
+		 * @param src The source memory address.
+		 * @param size The number of bytes to copy.
+		 * @return True if the memory copy succeeds, false otherwise.
+		 */
+		static bool MemCopy(CMemory dest, CMemory src, size_t size);
+
+		/**
+		 * @brief Defines a memory write routine that will not throw exceptions, and can handle potential
+		 * writes to NO_ACCESS or otherwise inaccessible memory pages. Defaults to WriteProcessMemory.
+		 * Must fail gracefully.
+		 * @param dest The destination memory address.
+		 * @param src The source memory address.
+		 * @param size The number of bytes to copy.
+		 * @param written A reference to the variable that will hold the number of bytes successfully written.
+		 * @return True if the memory copy succeeds, false otherwise.
+		 */
+		static bool SafeMemCopy(CMemory dest, CMemory src, size_t size, size_t& written) noexcept;
+
+		/**
+		 * @brief Defines a memory read routine that will not throw exceptions, and can handle potential
+		 * reads from NO_ACCESS or otherwise inaccessible memory pages. Defaults to ReadProcessMemory.
+		 * Must fail gracefully.
+		 * @param src The source memory address.
+		 * @param dest The destination memory address.
+		 * @param size The number of bytes to read.
+		 * @param read A reference to the variable that will hold the number of bytes successfully read.
+		 * @return True if the memory read succeeds, false otherwise.
+		 */
+		static bool SafeMemRead(CMemory src, CMemory dest, size_t size, size_t& read) noexcept;
+
+		/**
+		 * @brief Defines a memory protection set/unset routine that may fail ungracefully.
+		 * @param dest The memory address to change protection for.
+		 * @param size The number of bytes to change protection for.
+		 * @param newProtection The new protection flags to set.
+		 * @param status A reference to a variable that will hold the success status of the operation.
+		 * @return The previous protection flags if the operation succeeds, otherwise an appropriate error code.
+		 */
+		static ProtFlag MemProtect(CMemory dest, size_t size, ProtFlag newProtection, bool& status);
+	};
+
+	static constexpr size_t MemoryRound(size_t numToRound, size_t multiple)
+	{
+		return numToRound & (static_cast<size_t>(-1) ^ (multiple - 1));
+	}
+
+	static constexpr size_t MemoryRoundUp(size_t numToRound, size_t multiple)
+	{
+		return (numToRound + (multiple - 1)) & (static_cast<size_t>(-1) ^ (multiple - 1));
+	}
+} // namespace DynLibUtils
+
+#endif //DYNLIBUTILS_MEMACCESSOR_H

include/dynlibutils/memaddr.hpp

@@ -1,6 +1,8 @@
+//
 // DynLibUtils
-// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r) & Borys Komashchenko (Phoenix)
+// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r), Borys Komashchenko (Phoenix), Nikita Ushakov (qubka)
 // Licensed under the MIT license. See LICENSE file in the project root for details.
+//
 
 #ifndef DYNLIBUTILS_MEMADDR_HPP
 #define DYNLIBUTILS_MEMADDR_HPP

include/dynlibutils/memprotector.hpp

@@ -0,0 +1,87 @@
+//
+// DynLibUtils
+// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r), Borys Komashchenko (Phoenix), Nikita Ushakov (qubka)
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+
+#ifndef DYNLIBUTILS_MEMPROTECTOR_H
+#define DYNLIBUTILS_MEMPROTECTOR_H
+#pragma once
+
+#include "memaddr.hpp"
+#include "protflag.hpp"
+
+namespace DynLibUtils
+{
+	class CMemAccessor;
+	/**
+	 * @class CMemProtector
+	 * @brief A class to manage memory protection settings.
+	 *
+	 * This class allows setting and unsetting memory protection for a given
+	 * memory region. It ensures that the original protection settings are restored
+	 * when the object is destroyed.
+	 */
+	class CMemProtector
+	{
+	public:
+		CMemProtector() = delete; /**< Deleted default constructor. */
+
+		/**
+		 * @brief Constructs a CMemProtector object to set memory protection.
+		 *
+		 * @param address The memory address to protect.
+		 * @param length The length of the memory region to protect.
+		 * @param prot The protection flags to set.
+		 * @param unsetOnDestroy If true, the original protection settings will be restored when the object is destroyed.
+		 */
+		CMemProtector(CMemory address, size_t length, ProtFlag prot, bool unsetOnDestroy = true);
+
+		/**
+		 * @brief Destructor to restore the original protection settings if required.
+		 */
+		~CMemProtector();
+
+		/**
+		 * @brief Gets the original protection settings.
+		 *
+		 * @return The original protection flags.
+		 */
+		ProtFlag OriginalProt() const noexcept { return m_origProtection; }
+
+		/**
+		 * @brief Checks if the memory protection was successfully set.
+		 *
+		 * @return True if the memory protection was successfully set, false otherwise.
+		 */
+		bool IsValid() const noexcept { return m_status; }
+
+	private:
+		void* m_address; /**< The memory address to protect. */
+		size_t m_length; /**< The length of the memory region to protect. */
+		bool m_status; /**< The status of the memory protection operation. */
+		bool m_unsetLater; /**< Whether to unset the protection on destruction. */
+
+		ProtFlag m_origProtection = ProtFlag::UNSET; /**< The original protection flags. */
+	};
+
+	/**
+	 * @brief Translates protection flags to an integer representation.
+	 *
+	 * @param flags The protection flags to translate.
+	 * @return An integer representation of the protection flags.
+	 */
+	int TranslateProtection(ProtFlag flags) noexcept;
+
+	/**
+	 * @brief Translates an integer representation of protection flags to ProtFlag.
+	 *
+	 * @param prot The integer representation of the protection flags.
+	 * @return The corresponding ProtFlag.
+	 */
+	ProtFlag TranslateProtection(int prot) noexcept;
+
+} // namespace DynLibUtils
+
+#endif //DYNLIBUTILS_MEMPROTECTOR_H
+

include/dynlibutils/module.hpp

@@ -1,6 +1,6 @@
 //
 // DynLibUtils
-// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r) & Borys Komashchenko (Phoenix)
+// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r), Borys Komashchenko (Phoenix), Nikita Ushakov (qubka)
 // Licensed under the MIT license. See LICENSE file in the project root for details.
 //
 
@@ -333,9 +333,9 @@ struct CHash
 
 struct CNullMutex
 {
-	void lock() const {}
-	void unlock() const {}
-	bool try_lock() const { return true; }
+	void lock() const noexcept {}
+	void unlock() const noexcept {}
+	bool try_lock() const noexcept { return true; }
 
 	void lock_shared() const noexcept {}
 	void unlock_shared() const noexcept {}
@@ -390,7 +390,7 @@ class CAssemblyModule : public CMemory
 
 	const Section_t *m_pExecutableSection;
 
-	alignas(64) mutable std::unordered_map<CCache, CMemory, CHash> m_mapCached;
+	mutable std::unordered_map<CCache, CMemory, CHash> m_mapCached;
 	DYNLIB_NUA mutable Mutex m_mutex;
 
 public:

include/dynlibutils/protflag.hpp

@@ -0,0 +1,74 @@
+//
+// DynLibUtils
+// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r), Borys Komashchenko (Phoenix), Nikita Ushakov (qubka)
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+
+#ifndef DYNLIBUTILS_PROTFLAG_HPP
+#define DYNLIBUTILS_PROTFLAG_HPP
+#pragma once
+
+#include <cstdint>
+#include <type_traits>
+
+namespace DynLibUtils
+{
+	/**
+	 * @enum ProtFlag
+	 * @brief Enum representing memory protection flags.
+	 */
+	enum ProtFlag
+	{
+		UNSET = 0, /**< Value means this gives no information about protection state (un-read) */
+		X = 1 << 1, /**< Execute permission */
+		R = 1 << 2, /**< Read permission */
+		W = 1 << 3, /**< Write permission */
+		S = 1 << 4, /**< Shared memory */
+		P = 1 << 5, /**< Private memory */
+		N = 1 << 6, /**< Value equaling the Linux flag PROT_UNSET (read the prot, and the prot is unset) */
+		RWX = R | W | X /**< Read, Write, and Execute permissions */
+	};
+
+	/**
+	 * @brief Overloads the binary OR operator for ProtFlag.
+	 *
+	 * @param lhs The left-hand side ProtFlag value.
+	 * @param rhs The right-hand side ProtFlag value.
+	 * @return The combined ProtFlag value.
+	 */
+	inline ProtFlag operator|(ProtFlag lhs, ProtFlag rhs) noexcept
+	{
+		using underlying = typename std::underlying_type<ProtFlag>::type;
+		return static_cast<ProtFlag> (
+				static_cast<underlying>(lhs) | static_cast<underlying>(rhs)
+		);
+	}
+
+	/**
+	 * @brief Overloads the binary AND operator for ProtFlag.
+	 *
+	 * @param lhs The left-hand side ProtFlag value.
+	 * @param rhs The right-hand side ProtFlag value.
+	 * @return True if lhs contains rhs, false otherwise.
+	 */
+	inline bool operator&(ProtFlag lhs, ProtFlag rhs) noexcept
+	{
+		using underlying = typename std::underlying_type<ProtFlag>::type;
+		return static_cast<underlying>(lhs) & static_cast<underlying>(rhs);
+	}
+
+	/**
+	 * @brief Bitwise OR assignment operator for ProtFlag enum class.
+	 *
+	 * @param lhs Left-hand side ProtFlag.
+	 * @param rhs Right-hand side ProtFlag.
+	 * @return Reference to the left-hand side ProtFlag.
+	 */
+	inline ProtFlag& operator|=(ProtFlag& lhs, ProtFlag rhs) noexcept
+	{
+		lhs = lhs | rhs;
+		return lhs;
+	}
+} // namespace DynLibUtils
+
+#endif // DYNLIBUTILS_PROTFLAG_HPP

include/dynlibutils/virtual.hpp

@@ -1,6 +1,8 @@
+//
 // DynLibUtils
-// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r) & Borys Komashchenko (Phoenix)
+// Copyright (C) 2023-2025 Vladimir Ezhikov (Wend4r), Borys Komashchenko (Phoenix), Nikita Ushakov (qubka)
 // Licensed under the MIT license. See LICENSE file in the project root for details.
+//
 
 #ifndef DYNLIBUTILS_VIRTUAL_HPP
 #define DYNLIBUTILS_VIRTUAL_HPP