style: Code cleanup

trungnt2910 · trungnt2910 · commit fcd103ea2709 · 2021-08-24T23:43:30.000+07:00
diff --git a/DemoApp/Program.cs b/DemoApp/Program.cs
@@ -1,14 +1,7 @@
-﻿using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
+﻿using MemoryModule;
+using System;
 using System.IO;
-using System.Linq;
 using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
-
-using MemoryModule;
 
 namespace DemoApp
 {
diff --git a/MemoryModule/CStyleMemory.cs b/MemoryModule/CStyleMemory.cs
@@ -7,7 +7,7 @@
 
 namespace MemoryModule
 {
-    public static unsafe class CStyleMemory
+    internal static unsafe class CStyleMemory
     {
         private const int magic = 0x414d_534c;
 
diff --git a/MemoryModule/Dll.cs b/MemoryModule/Dll.cs
@@ -5,7 +5,7 @@
 
 namespace MemoryModule
 {
-    public enum Dll : uint
+    internal enum Dll : uint
     {
         ProcessAttach = 1,
         ThreadAttach = 2,
diff --git a/MemoryModule/Error.cs b/MemoryModule/Error.cs
@@ -5,7 +5,7 @@
 
 namespace MemoryModule
 {
-    public enum Error : uint
+    internal enum Error : uint
     {
         InvalidData = 13,
         BadExeFormat = 193,
diff --git a/MemoryModule/Heap.cs b/MemoryModule/Heap.cs
@@ -5,7 +5,7 @@
 
 namespace MemoryModule
 {
-    enum Heap : uint
+    internal enum Heap : uint
     {
         ZeroMemory = 0x00000008,
     }
diff --git a/MemoryModule/Image.cs b/MemoryModule/Image.cs
@@ -12,10 +12,6 @@ public static class Image
         public const int FileMachinei386 = 0x14c;
         public const int FileMachineAMD64 = 0x8664;
         public const int FileDll = 0x2000;
-        public const int DirectoryEntryImport = 1;
-        public const int DirectoryEntryBaseReloc = 5;
-        public const int DirectoryEntryTls = 9;
-        public const int DirectoryEntryExport = 0;
         public const int SizeOfBaseRelocation = 8;
         public const ulong OrdinalFlag64 = 0x8000000000000000;
         public const uint OrdinalFlag32 = 0x80000000;
diff --git a/MemoryModule/ImageDirectoryEntry.cs b/MemoryModule/ImageDirectoryEntry.cs
@@ -0,0 +1,14 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MemoryModule
+{
+    internal enum ImageDirectoryEntry
+    {
+        Import = 1,
+        BaseReloc = 5,
+        Tls = 9,
+        Export = 0,
+    }
+}
diff --git a/MemoryModule/ImageRelocation.cs b/MemoryModule/ImageRelocation.cs
@@ -5,7 +5,7 @@
 
 namespace MemoryModule
 {
-    public enum ImageRelocation
+    internal enum ImageRelocation
     {
         BasedAbsolute = 0,
         BasedHigh = 1,
diff --git a/MemoryModule/ImageSectionMemory.cs b/MemoryModule/ImageSectionMemory.cs
@@ -6,21 +6,14 @@
 namespace MemoryModule
 {
     [Flags]
-    enum ImageSectionMemory : uint
+    internal enum ImageSectionMemory : uint
     {
-//#define IMAGE_SCN_MEM_DISCARDABLE 0x02000000
         Discardable = 0x02000000,
-        //#define IMAGE_SCN_MEM_NOT_CACHED 0x04000000
         NotCached = 0x04000000,
-        //#define IMAGE_SCN_MEM_NOT_PAGED 0x08000000
         NotPaged = 0x08000000,
-        //#define IMAGE_SCN_MEM_SHARED 0x10000000
         Shared = 0x10000000,
-        //#define IMAGE_SCN_MEM_EXECUTE 0x20000000
         Exectute = 0x20000000,
-        //#define IMAGE_SCN_MEM_READ 0x40000000
         Read = 0x40000000,
-        //#define IMAGE_SCN_MEM_WRITE 0x80000000
         Write = 0x80000000,
     }
 }
diff --git a/MemoryModule/MemoryAllocation.cs b/MemoryModule/MemoryAllocation.cs
@@ -6,7 +6,7 @@
 namespace MemoryModule
 {
     [Flags]
-    enum Memory : uint
+    internal enum MemoryAllocation : uint
     {
         Commit = 0x1000,
         Reserve = 0x2000,
diff --git a/MemoryModule/NativeAssemblyImpl.cs b/MemoryModule/NativeAssemblyImpl.cs
@@ -109,18 +109,19 @@ public static T GetDelegate<T>(IntPtr module, string name) where T : Delegate
         public static CustomFreeLibraryFunc MemoryDefaultFreeLibraryDelegate = MemoryDefaultFreeLibrary;
 
         #region Default dependency resolvers
-        private static void* MemoryDefaultAlloc(void* address, UIntPtr size, uint allocationType, uint protect, void* userdata)
+        private static void* MemoryDefaultAlloc(void* address, UIntPtr size, MemoryAllocation allocationType, PageProtection protect, void* userdata)
         {
             return VirtualAlloc(address, size, allocationType, protect);
         }
 
-        private static bool MemoryDefaultFree(void* lpAddress, UIntPtr dwSize, uint dwFreeType, void* userdata)
+        private static bool MemoryDefaultFree(void* lpAddress, UIntPtr dwSize, MemoryAllocation dwFreeType, void* userdata)
         {
             return VirtualFree(lpAddress, dwSize, dwFreeType);
         }
 
         private static void* MemoryDefaultLoadLibrary(char* filename, void* userdata)
         {
+            System.Diagnostics.Debug.WriteLine(Marshal.PtrToStringAnsi((IntPtr)filename));
             void* result;
             result = LoadLibraryA(filename);
             if (result == null)
@@ -148,19 +149,19 @@ private static void MemoryDefaultFreeLibrary(void* module, void* userdata)
             Image.FileMachinei386);
 
         // Protection flags for memory pages (Executable, Readable, Writeable)
-        private static readonly int[][][] ProtectionFlags = new int[][][]
+        private static readonly PageProtection[][][] ProtectionFlags = new PageProtection[][][]
         {
-            new int [][]
+            new PageProtection[][]
             {
                 // not executable
-                new int [] {(int)Page.NoAccess, (int)Page.WriteCopy},
-                new int [] {(int)Page.ReadOnly, (int)Page.ReadWrite},
+                new [] {PageProtection.NoAccess, PageProtection.WriteCopy},
+                new [] {PageProtection.ReadOnly, PageProtection.ReadWrite},
             },
-            new int [][]
+            new PageProtection[][]
             {
             // executable
-                new int [] { (int)Page.Execute, (int)Page.ExecuteWriteCopy},
-                new int [] { (int)Page.ExecuteRead, (int)Page.ExecuteReadWrite},
+                new [] { PageProtection.Execute, PageProtection.ExecuteWriteCopy},
+                new [] { PageProtection.ExecuteRead, PageProtection.ExecuteReadWrite},
             },
         };
 
@@ -273,8 +274,8 @@ private static void MemoryDefaultFreeLibrary(void* module, void* userdata)
                 // calling DllEntry raises an exception if we don't...
                 code = (byte*)allocMemory((void*)old_header->OptionalHeader.ImageBase,
                     (UIntPtr)alignedImageSize,
-                    (uint)(Memory.Reserve | Memory.Commit),
-                    (uint)Page.ReadWrite,
+                    MemoryAllocation.Reserve | MemoryAllocation.Commit,
+                    PageProtection.ReadWrite,
                     userdata);
 
                 if (code == null)
@@ -283,8 +284,8 @@ private static void MemoryDefaultFreeLibrary(void* module, void* userdata)
                     // try to allocate memory at arbitrary position
                     code = (byte*)allocMemory(null,
                         (UIntPtr)alignedImageSize,
-                        (uint)(Memory.Reserve | Memory.Commit),
-                        (uint)Page.ReadWrite,
+                        MemoryAllocation.Reserve | MemoryAllocation.Commit,
+                        PageProtection.ReadWrite,
                         userdata);
                     if (code == null)
                     {
@@ -301,7 +302,7 @@ private static void MemoryDefaultFreeLibrary(void* module, void* userdata)
                         POINTER_LIST* node = (POINTER_LIST*)CStyleMemory.malloc((uint)sizeof(POINTER_LIST));
                         if (node == null)
                         {
-                            freeMemory(code, (UIntPtr)0, (uint)Memory.Release, userdata);
+                            freeMemory(code, (UIntPtr)0, MemoryAllocation.Release, userdata);
                             FreePointerList(blockedMemory, freeMemory, userdata);
                             SetLastError(Error.OutOfMemory);
                             return null;
@@ -313,8 +314,8 @@ private static void MemoryDefaultFreeLibrary(void* module, void* userdata)
 
                         code = (byte*)allocMemory(null,
                                         (UIntPtr)alignedImageSize,
-                                        (uint)(Memory.Reserve | Memory.Commit),
-                                        (uint)Page.ReadWrite,
+                                        MemoryAllocation.Reserve | MemoryAllocation.Commit,
+                                        PageProtection.ReadWrite,
                                         userdata);
                         if (code == null)
                         {
@@ -329,7 +330,7 @@ private static void MemoryDefaultFreeLibrary(void* module, void* userdata)
                 result = (_MEMORYMODULE*)HeapAlloc(GetProcessHeap(), (uint)Heap.ZeroMemory, (uint)Marshal.SizeOf(typeof(_MEMORYMODULE)));
                 if (result == null)
                 {
-                    freeMemory(code, (UIntPtr)0, (uint)Memory.Release, userdata);
+                    freeMemory(code, (UIntPtr)0, MemoryAllocation.Release, userdata);
                     if (Environment.Is64BitProcess)
                     {
                         FreePointerList(blockedMemory, freeMemory, userdata);
@@ -361,8 +362,8 @@ private static void MemoryDefaultFreeLibrary(void* module, void* userdata)
                 // commit memory for headers
                 headers = (byte*)allocMemory(code,
                             (UIntPtr)old_header->OptionalHeader.SizeOfHeaders,
-                            (uint)Memory.Commit,
-                            (uint)Page.ReadWrite,
+                            MemoryAllocation.Commit,
+                            PageProtection.ReadWrite,
                             userdata);
 
                 // copy PE header to code
@@ -488,7 +489,7 @@ private static void MemoryFreeLibrary(_MEMORYMODULE* mod)
             if (module->codeBase != null)
             {
                 // release memory of library
-                managedModule.free(module->codeBase, (UIntPtr)0, (uint)Memory.Release, module->userdata);
+                managedModule.free(module->codeBase, (UIntPtr)0, MemoryAllocation.Release, module->userdata);
             }
 
             if (Environment.Is64BitProcess)
@@ -505,7 +506,7 @@ private static void MemoryFreeLibrary(_MEMORYMODULE* mod)
             byte* codeBase = module->codeBase;
             uint idx = 0;
             _IMAGE_EXPORT_DIRECTORY* exports = default;
-            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, Image.DirectoryEntryExport);
+            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, ImageDirectoryEntry.Export);
             if (directory->Size == 0)
             {
                 // no export table found
@@ -625,7 +626,7 @@ private static void FreePointerList(POINTER_LIST* head, CustomFreeFunc freeMemor
             while (node != null)
             {
                 POINTER_LIST* next;
-                freeMemory(node->address, (UIntPtr)0, (uint)Memory.Release, userdata);
+                freeMemory(node->address, (UIntPtr)0, MemoryAllocation.Release, userdata);
                 next = node->next;
                 CStyleMemory.free(node);
                 node = next;
@@ -645,10 +646,10 @@ private static void FreePointerList(POINTER_LIST* head, CustomFreeFunc freeMemor
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static _IMAGE_DATA_DIRECTORY* GET_HEADER_DICTIONARY(_MEMORYMODULE* module, int idx)
+        private static _IMAGE_DATA_DIRECTORY* GET_HEADER_DICTIONARY(_MEMORYMODULE* module, ImageDirectoryEntry idx)
         {
             // Hope this is safe?
-            return &((_IMAGE_DATA_DIRECTORY*)&module->headers->OptionalHeader.DataDirectory)[idx];
+            return &((_IMAGE_DATA_DIRECTORY*)&module->headers->OptionalHeader.DataDirectory)[(int)idx];
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -761,8 +762,8 @@ static bool CopySections(byte* data, ulong size, _IMAGE_NT_HEADERS* old_headers,
                     {
                         dest = (byte*)module.alloc(codeBase + section->VirtualAddress,
                             (UIntPtr)section_size,
-                            (uint)Memory.Commit,
-                            (uint)Page.ReadWrite,
+                            MemoryAllocation.Commit,
+                            PageProtection.ReadWrite,
                             module.userdata
                             );
 
@@ -792,8 +793,8 @@ static bool CopySections(byte* data, ulong size, _IMAGE_NT_HEADERS* old_headers,
                 // commit memory block and copy data from dll
                 dest = (byte*)module.alloc(codeBase + section->VirtualAddress,
                                             (UIntPtr)section->SizeOfRawData,
-                                            (uint)Memory.Commit,
-                                            (uint)Page.ReadWrite,
+                                            MemoryAllocation.Commit,
+                                            PageProtection.ReadWrite,
                                             module.userdata);
                 if (dest == null)
                 {
@@ -818,7 +819,7 @@ static bool PerformBaseRelocation(_MEMORYMODULE* module, long delta)
         {
             byte* codeBase = module->codeBase;
             _IMAGE_BASE_RELOCATION* relocation = default;
-            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, (int)Image.DirectoryEntryBaseReloc);
+            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, ImageDirectoryEntry.BaseReloc);
             if (directory->Size == 0)
             {
                 return delta == 0;
@@ -881,7 +882,7 @@ static bool BuildImportTable(_MEMORYMODULE* module)
             _IMAGE_IMPORT_DESCRIPTOR* importDesc = default;
             bool result = true;
 
-            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, Image.DirectoryEntryImport);
+            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, ImageDirectoryEntry.Import);
             if (directory->Size == 0)
             {
                 return true;
@@ -972,7 +973,7 @@ static UIntPtr GetRealSectionSize(_MEMORYMODULE* module, _IMAGE_SECTION_HEADER*
         static bool FinalizeSection(_MEMORYMODULE* module, SECTIONFINALIZEDATA* sectionData)
         {
             var managedModule = MEMORYMODULE.MarshalFrom(module);
-            uint protect = default; uint oldProtect = default;
+            PageProtection protect = default; uint oldProtect = default;
             bool executable = default;
             bool readable = default;
             bool writeable = default;
@@ -992,7 +993,7 @@ static bool FinalizeSection(_MEMORYMODULE* module, SECTIONFINALIZEDATA* sectionD
                     )
                 {
                     // Only allowed to decommit whole pages
-                    managedModule.free(sectionData->address, (UIntPtr)sectionData->size, (uint)Memory.Decommit, module->userdata);
+                    managedModule.free(sectionData->address, (UIntPtr)sectionData->size, MemoryAllocation.Decommit, module->userdata);
                 }
                 return true;
             }
@@ -1001,10 +1002,10 @@ static bool FinalizeSection(_MEMORYMODULE* module, SECTIONFINALIZEDATA* sectionD
             executable = (sectionData->characteristics & (uint)ImageSectionMemory.Exectute) != 0;
             readable = (sectionData->characteristics & (uint)ImageSectionMemory.Read) != 0;
             writeable = (sectionData->characteristics & (uint)ImageSectionMemory.Write) != 0;
-            protect = (uint)ProtectionFlags[Convert.ToInt32(executable)][Convert.ToInt32(readable)][Convert.ToInt32(writeable)];
+            protect = ProtectionFlags[Convert.ToInt32(executable)][Convert.ToInt32(readable)][Convert.ToInt32(writeable)];
             if (Convert.ToBoolean(sectionData->characteristics & (uint)ImageSectionMemory.NotCached))
             {
-                protect |= (uint)Page.PAGE_NOCACHE;
+                protect |= PageProtection.PAGE_NOCACHE;
             }
 
             // change memory access flags
@@ -1093,7 +1094,7 @@ static bool ExecuteTLS(_MEMORYMODULE* module)
             _IMAGE_TLS_DIRECTORY* tls = default;
             void** callback = default;
 
-            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, Image.DirectoryEntryTls);
+            _IMAGE_DATA_DIRECTORY* directory = GET_HEADER_DICTIONARY(module, ImageDirectoryEntry.Tls);
             if (directory->VirtualAddress == 0)
             {
                 return true;
@@ -1545,9 +1546,9 @@ struct IMAGE_DOS_HEADER
         private delegate int ExeEntryProc();
 
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-        public delegate void* CustomAllocFunc(void* ptr, UIntPtr size, uint a, uint b, void* ptr1);
+        public delegate void* CustomAllocFunc(void* ptr, UIntPtr size, MemoryAllocation a, PageProtection b, void* ptr1);
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-        public delegate bool CustomFreeFunc(void* ptr, UIntPtr size, uint a, void* ptr1);
+        public delegate bool CustomFreeFunc(void* ptr, UIntPtr size, MemoryAllocation a, void* ptr1);
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
         public delegate void* CustomLoadLibraryFunc(char* str, void* ptr);
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
@@ -1579,10 +1580,10 @@ struct IMAGE_DOS_HEADER
         private static extern unsafe int IsBadReadPtr(void* lp, uint ucb);
 
         [DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
-        private static extern unsafe void* VirtualAlloc(void* lpAddress, UIntPtr dwSize, uint flAllocationType, uint flProtect);
+        private static extern unsafe void* VirtualAlloc(void* lpAddress, UIntPtr dwSize, MemoryAllocation flAllocationType, PageProtection flProtect);
 
         [DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
-        private static extern unsafe bool VirtualFree(void* lpAddress, UIntPtr dwSize, uint dwFreeType);
+        private static extern unsafe bool VirtualFree(void* lpAddress, UIntPtr dwSize, MemoryAllocation dwFreeType);
 
         [DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi)]
         // The library name seems to always be ANSI, so we must use LoadLibraryA in this case.
@@ -1595,7 +1596,7 @@ struct IMAGE_DOS_HEADER
         private static extern unsafe int FreeLibrary(void* hLibModule);
 
         [DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
-        private static extern unsafe int VirtualProtect(void* lpAddress, UIntPtr dwSize, uint flNewProtect, void* lpflOldProtect);
+        private static extern unsafe int VirtualProtect(void* lpAddress, UIntPtr dwSize, PageProtection flNewProtect, void* lpflOldProtect);
         #endregion
     }
 }
diff --git a/MemoryModule/PageProtection.cs b/MemoryModule/PageProtection.cs
@@ -6,7 +6,7 @@
 namespace MemoryModule
 {
     [Flags]
-    enum Page : uint
+    internal enum PageProtection : uint
     {
         NoAccess = 0x01,
         ReadOnly = 0x02,

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`
`8`	`8`	`namespace MemoryModule`
`9`	`9`	`{`
`10`		`- public static unsafe class CStyleMemory`
	`10`	`+ internal static unsafe class CStyleMemory`
`11`	`11`	`{`
`12`	`12`	`private const int magic = 0x414d_534c;`
`13`	`13`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace MemoryModule`
`7`	`7`	`{`
`8`		`- public enum Dll : uint`
	`8`	`+ internal enum Dll : uint`
`9`	`9`	`{`
`10`	`10`	`ProcessAttach = 1,`
`11`	`11`	`ThreadAttach = 2,`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace MemoryModule`
`7`	`7`	`{`
`8`		`- public enum Error : uint`
	`8`	`+ internal enum Error : uint`
`9`	`9`	`{`
`10`	`10`	`InvalidData = 13,`
`11`	`11`	`BadExeFormat = 193,`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace MemoryModule`
`7`	`7`	`{`
`8`		`- enum Heap : uint`
	`8`	`+ internal enum Heap : uint`
`9`	`9`	`{`
`10`	`10`	`ZeroMemory = 0x00000008,`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace MemoryModule`
`7`	`7`	`{`
`8`		`- public enum ImageRelocation`
	`8`	`+ internal enum ImageRelocation`
`9`	`9`	`{`
`10`	`10`	`BasedAbsolute = 0,`
`11`	`11`	`BasedHigh = 1,`
Original file line number	Diff line number	Diff line change
`@@ -6,21 +6,14 @@`
`6`	`6`	`namespace MemoryModule`
`7`	`7`	`{`
`8`	`8`	`[Flags]`
`9`		`- enum ImageSectionMemory : uint`
	`9`	`+ internal enum ImageSectionMemory : uint`
`10`	`10`	`{`
`11`		`-//#define IMAGE_SCN_MEM_DISCARDABLE 0x02000000`
`12`	`11`	`Discardable = 0x02000000,`
`13`		`- //#define IMAGE_SCN_MEM_NOT_CACHED 0x04000000`
`14`	`12`	`NotCached = 0x04000000,`
`15`		`- //#define IMAGE_SCN_MEM_NOT_PAGED 0x08000000`
`16`	`13`	`NotPaged = 0x08000000,`
`17`		`- //#define IMAGE_SCN_MEM_SHARED 0x10000000`
`18`	`14`	`Shared = 0x10000000,`
`19`		`- //#define IMAGE_SCN_MEM_EXECUTE 0x20000000`
`20`	`15`	`Exectute = 0x20000000,`
`21`		`- //#define IMAGE_SCN_MEM_READ 0x40000000`
`22`	`16`	`Read = 0x40000000,`
`23`		`- //#define IMAGE_SCN_MEM_WRITE 0x80000000`
`24`	`17`	`Write = 0x80000000,`
`25`	`18`	`}`
`26`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`namespace MemoryModule`
`7`	`7`	`{`
`8`	`8`	`[Flags]`
`9`		`- enum Memory : uint`
	`9`	`+ internal enum MemoryAllocation : uint`
`10`	`10`	`{`
`11`	`11`	`Commit = 0x1000,`
`12`	`12`	`Reserve = 0x2000,`