[REFACT] Cleaned up types to avoid MinGW warnings

hasherezade · hasherezade · commit d8b02e039484 · 2025-02-21T01:36:45.000+01:00
diff --git a/libpeconv/include/peconv/buffer_util.h b/libpeconv/include/peconv/buffer_util.h
@@ -66,7 +66,7 @@ namespace peconv {
     /**
     Allocates a buffer of a virtual memory (using VirtualAlloc).  Can be used in the cases when the buffer have to be aligned to the beginning of a page.
     */
-    ALIGNED_BUF alloc_aligned(size_t buffer_size, DWORD protect, ULONGLONG desired_base=NULL);
+    ALIGNED_BUF alloc_aligned(size_t buffer_size, DWORD protect, void* desired_base=nullptr);
 
     /**
     Frees buffer allocated by alloc_aligned.
@@ -78,7 +78,7 @@ namespace peconv {
     /**
     Allocates an aligned buffer for a PE file.
     */
-    ALIGNED_BUF alloc_pe_buffer(size_t buffer_size, DWORD protect, ULONGLONG desired_base=NULL);
+    ALIGNED_BUF alloc_pe_buffer(size_t buffer_size, DWORD protect, void* desired_base=nullptr);
 
     /**
     Free the memory allocated with alloc_pe_buffer.
diff --git a/libpeconv/include/peconv/pe_loader.h b/libpeconv/include/peconv/pe_loader.h
@@ -16,7 +16,7 @@ namespace peconv {
     If the relocate flag is true, applies relocations. Does not load imports.
     Automatically allocates buffer of the needed size (the size is returned in outputSize). The buffer can be freed by the function free_pe_buffer.
     */
-    BYTE* load_pe_module(BYTE* payload_raw, size_t r_size, OUT size_t &v_size, bool executable, bool relocate, ULONGLONG desired_base = 0);
+    BYTE* load_pe_module(BYTE* payload_raw, size_t r_size, OUT size_t &v_size, bool executable, bool relocate, ULONG_PTR desired_base = 0);
 
     /**
     Reads PE from the given file into memory and maps it into vitual format.
@@ -25,13 +25,13 @@ namespace peconv {
     If the relocate flag is true, applies relocations. Does not load imports.
     Automatically allocates buffer of the needed size (the size is returned in outputSize). The buffer can be freed by the function free_pe_buffer.
     */
-    BYTE* load_pe_module(LPCTSTR filename, OUT size_t &v_size, bool executable, bool relocate, ULONGLONG desired_base = 0);
+    BYTE* load_pe_module(LPCTSTR filename, OUT size_t &v_size, bool executable, bool relocate, ULONG_PTR desired_base = 0);
 
     /**
     Loads full PE from the raw buffer in a way in which it can be directly executed: remaps to virual format, applies relocations, loads imports.
     Allows for supplying custom function resolver.
     */
-    BYTE* load_pe_executable(BYTE* payload_raw, size_t r_size, OUT size_t &v_size, t_function_resolver* import_resolver = nullptr, ULONGLONG desired_base = 0);
+    BYTE* load_pe_executable(BYTE* payload_raw, size_t r_size, OUT size_t &v_size, t_function_resolver* import_resolver = nullptr, ULONG_PTR desired_base = 0);
 
     /**
     Loads full PE from file in a way in which it can be directly executed: remaps to virtual format, applies relocations, loads imports.
diff --git a/libpeconv/include/peconv/pe_raw_to_virtual.h b/libpeconv/include/peconv/pe_raw_to_virtual.h
@@ -24,7 +24,7 @@ namespace peconv {
         IN size_t rawPeSize,
         OUT size_t &outputSize,
         IN OPTIONAL bool executable = true,
-        IN OPTIONAL ULONGLONG desired_base = 0
+        IN OPTIONAL ULONG_PTR desired_base = 0
     );
 
 }; // namespace peconv
diff --git a/libpeconv/src/buffer_util.cpp b/libpeconv/src/buffer_util.cpp
@@ -53,11 +53,11 @@ void peconv::free_unaligned(peconv::UNALIGNED_BUF section_buffer)
 // alloc/free aligned buffers:
 //
 
-peconv::ALIGNED_BUF peconv::alloc_aligned(size_t buffer_size, DWORD protect, ULONGLONG desired_base)
+peconv::ALIGNED_BUF peconv::alloc_aligned(size_t buffer_size, DWORD protect, void* desired_base)
 {
     if (!buffer_size) return NULL;
 
-    ALIGNED_BUF buf = (ALIGNED_BUF) VirtualAlloc((LPVOID) desired_base, buffer_size, MEM_COMMIT | MEM_RESERVE, protect);
+    ALIGNED_BUF buf = (ALIGNED_BUF) VirtualAlloc(desired_base, buffer_size, MEM_COMMIT | MEM_RESERVE, protect);
     return buf;
 }
 
@@ -79,7 +79,7 @@ bool peconv::free_aligned(peconv::ALIGNED_BUF buffer, size_t buffer_size)
 //
 
 // allocate a buffer for PE module:
-peconv::ALIGNED_BUF peconv::alloc_pe_buffer(size_t buffer_size, DWORD protect, ULONGLONG desired_base)
+peconv::ALIGNED_BUF peconv::alloc_pe_buffer(size_t buffer_size, DWORD protect, void* desired_base)
 {
     return alloc_aligned(buffer_size, protect, desired_base);
 }
diff --git a/libpeconv/src/delayed_imports_loader.cpp b/libpeconv/src/delayed_imports_loader.cpp
@@ -41,7 +41,7 @@ bool parse_delayed_desc(BYTE* modulePtr, const size_t moduleSize,
     T_FIELD* record_va = (T_FIELD*)((ULONGLONG)modulePtr + iat_addr);
     T_IMAGE_THUNK_DATA* thunk_va = (T_IMAGE_THUNK_DATA*)((ULONGLONG)modulePtr + thunk_addr);
 
-    for (; *record_va != NULL && thunk_va != NULL; record_va++, thunk_va++) {
+    for (; (*record_va) && thunk_va; record_va++, thunk_va++) {
         if (!peconv::validate_ptr(modulePtr, moduleSize, record_va, sizeof(T_FIELD))) {
             return false;
         }
@@ -131,7 +131,7 @@ bool peconv::load_delayed_imports(BYTE* modulePtr, ULONGLONG moduleBase, t_funct
     for (size_t i = 0; i < max_count; i++) {
         IMAGE_DELAYLOAD_DESCRIPTOR *desc = &first_desc[i];
         if (!validate_ptr(modulePtr, module_size, desc, sizeof(IMAGE_DELAYLOAD_DESCRIPTOR))) break;
-        if (desc->DllNameRVA == NULL) {
+        if (!desc->DllNameRVA) {
             break;
         }
         ULONGLONG dll_name_rva = desc->DllNameRVA;
diff --git a/libpeconv/src/fix_imports.cpp b/libpeconv/src/fix_imports.cpp
@@ -26,7 +26,7 @@ size_t find_addresses_to_fill(FIELD_T call_via, FIELD_T thunk_addr, LPVOID modul
         }
         FIELD_T *thunk_val = reinterpret_cast<FIELD_T*>(thunk_ptr);
         FIELD_T *call_via_val = reinterpret_cast<FIELD_T*>(call_via_ptr);
-        if (*call_via_val == 0) {
+        if ((*call_via_val) == 0) {
             //nothing to fill, probably the last record
             break;
         }
@@ -217,14 +217,14 @@ bool peconv::fix_imports(IN OUT PVOID modulePtr, IN size_t moduleSize, IN const
 {
     bool skip_bound = false; // skip boud imports?
     IMAGE_DATA_DIRECTORY *importsDir = peconv::get_directory_entry((const BYTE*) modulePtr, IMAGE_DIRECTORY_ENTRY_IMPORT);
-    if (importsDir == NULL) {
+    if (!importsDir) {
         return true; // done! no imports -> nothing to fix
     }
     bool is64 = peconv::is64bit((BYTE*)modulePtr);
     DWORD maxSize = importsDir->Size;
     DWORD impAddr = importsDir->VirtualAddress;
 
-    IMAGE_IMPORT_DESCRIPTOR* lib_desc = NULL;
+    IMAGE_IMPORT_DESCRIPTOR* lib_desc = nullptr;
     DWORD parsedSize = 0;
 #ifdef _DEBUG
     printf("---IMP---\n");
@@ -240,7 +240,7 @@ bool peconv::fix_imports(IN OUT PVOID modulePtr, IN size_t moduleSize, IN const
             return false;
         }
         parsedSize += sizeof(IMAGE_IMPORT_DESCRIPTOR);
-        if (lib_desc->OriginalFirstThunk == NULL && lib_desc->FirstThunk == NULL) {
+        if (!lib_desc->OriginalFirstThunk && !lib_desc->FirstThunk) {
             break;
         }
         const bool is_bound = (lib_desc->TimeDateStamp == (-1));
diff --git a/libpeconv/src/imports_loader.cpp b/libpeconv/src/imports_loader.cpp
@@ -93,7 +93,7 @@ class CollectThunksCallback : public peconv::ImportThunksCallback
 
     virtual bool processThunks(LPSTR libName, ULONG_PTR origFirstThunkPtr, ULONG_PTR va)
     {
-        if (va == NULL) {
+        if (!va) {
             return false; // invalid thunk
         }
         const ULONGLONG module_base = reinterpret_cast<ULONGLONG>(this->vBuf);
@@ -143,7 +143,7 @@ class CollectImportsCallback : public ImportThunksCallback
     template <typename T_FIELD, typename T_IMAGE_THUNK_DATA>
     bool processThunks_tpl(LPSTR lib_name, T_IMAGE_THUNK_DATA* desc, T_FIELD* call_via, T_FIELD ordinal_flag)
     {
-        if (call_via == nullptr) {
+        if (!call_via) {
             return false;
         }
 
@@ -199,7 +199,7 @@ bool process_imp_functions_tpl(BYTE* modulePtr, size_t module_size, LPSTR lib_na
         if (!validate_ptr(modulePtr, module_size, desc, sizeof(T_IMAGE_THUNK_DATA))) {
             break;
         }
-        if (desc->u1.Function == NULL) {
+        if (!desc->u1.Function) {
             break;
         }
         T_FIELD ordinal_flag = (sizeof(T_FIELD) == sizeof(ULONGLONG)) ? IMAGE_ORDINAL_FLAG64 : IMAGE_ORDINAL_FLAG32;
@@ -233,7 +233,7 @@ bool process_dlls(BYTE* modulePtr, size_t module_size, IMAGE_IMPORT_DESCRIPTOR *
         if (!validate_ptr(modulePtr, module_size, lib_desc, sizeof(IMAGE_IMPORT_DESCRIPTOR))) {
             break;
         }
-        if (lib_desc->OriginalFirstThunk == NULL && lib_desc->FirstThunk == NULL) {
+        if (!lib_desc->OriginalFirstThunk && !lib_desc->FirstThunk) {
             break;
         }
         LPSTR lib_name = (LPSTR)((ULONGLONG)modulePtr + lib_desc->Name);
@@ -243,7 +243,7 @@ bool process_dlls(BYTE* modulePtr, size_t module_size, IMAGE_IMPORT_DESCRIPTOR *
         }
         DWORD call_via = lib_desc->FirstThunk;
         DWORD thunk_addr = lib_desc->OriginalFirstThunk;
-        if (thunk_addr == NULL) {
+        if (!thunk_addr) {
             thunk_addr = lib_desc->FirstThunk;
         }
 #ifdef _DEBUG_EX
@@ -330,11 +330,11 @@ bool peconv::is_valid_import_name(const PBYTE modulePtr, const size_t moduleSize
 bool peconv::has_valid_import_table(const PBYTE modulePtr, size_t moduleSize)
 {
     IMAGE_DATA_DIRECTORY *importsDir = get_directory_entry((BYTE*)modulePtr, IMAGE_DIRECTORY_ENTRY_IMPORT);
-    if (importsDir == NULL) return false;
+    if (!importsDir) return false;
 
     const DWORD impAddr = importsDir->VirtualAddress;
 
-    IMAGE_IMPORT_DESCRIPTOR* lib_desc = NULL;
+    IMAGE_IMPORT_DESCRIPTOR* lib_desc = nullptr;
     DWORD parsedSize = 0;
     size_t valid_records = 0;
 
@@ -345,15 +345,15 @@ bool peconv::has_valid_import_table(const PBYTE modulePtr, size_t moduleSize)
         }
         parsedSize += sizeof(IMAGE_IMPORT_DESCRIPTOR);
 
-        if (lib_desc->OriginalFirstThunk == NULL && lib_desc->FirstThunk == NULL) {
+        if (!lib_desc->OriginalFirstThunk && !lib_desc->FirstThunk) {
             break;
         }
         LPSTR lib_name = (LPSTR)((ULONGLONG)modulePtr + lib_desc->Name);
         if (!is_valid_import_name(modulePtr, moduleSize, lib_name)) return false;
 
         DWORD call_via = lib_desc->FirstThunk;
         DWORD thunk_addr = lib_desc->OriginalFirstThunk;
-        if (thunk_addr == NULL) thunk_addr = lib_desc->FirstThunk;
+        if (!thunk_addr) thunk_addr = lib_desc->FirstThunk;
 
         DWORD *thunks = (DWORD*)((ULONGLONG)modulePtr + thunk_addr);
         if (!peconv::validate_ptr(modulePtr, moduleSize, thunks, sizeof(DWORD))) return false;
diff --git a/libpeconv/src/imports_uneraser.cpp b/libpeconv/src/imports_uneraser.cpp
@@ -9,14 +9,14 @@ LPVOID search_name(std::string name, const char* modulePtr, size_t moduleSize)
     const char* namec = name.c_str();
     const size_t searched_len =  name.length() + 1; // with terminating NULL
     const char* found_ptr = std::search(modulePtr, modulePtr + moduleSize, namec, namec + searched_len);
-    if (found_ptr == NULL) {
-        return NULL;
+    if (!found_ptr) {
+        return nullptr;
     }
     size_t o = found_ptr - modulePtr;
     if (o < moduleSize) {
        return (LPVOID)(found_ptr);
     }
-    return NULL;
+    return nullptr;
 }
 
 bool ImportsUneraser::writeFoundDllName(IMAGE_IMPORT_DESCRIPTOR* lib_desc, const std::string &found_name)
@@ -69,7 +69,7 @@ bool ImportsUneraser::findNameInBinaryAndFill(IMAGE_IMPORT_DESCRIPTOR* lib_desc,
     std::map<ULONGLONG, std::set<ExportedFunc>> &addr_to_func
 )
 {
-    if (call_via_ptr == NULL || modulePtr == NULL || lib_desc == NULL) {
+    if (!call_via_ptr || !modulePtr || !lib_desc) {
         return false; //malformed input
     }
     IMAGE_DATA_DIRECTORY *importsDir = get_directory_entry((BYTE*)modulePtr, IMAGE_DIRECTORY_ENTRY_IMPORT);
@@ -170,23 +170,23 @@ bool ImportsUneraser::fillImportNames(
     OUT OPTIONAL ImpsNotCovered* notCovered
 )
 {
-    if (lib_desc == NULL) return false;
+    if (!lib_desc) return false;
 
     FIELD_T call_via = lib_desc->FirstThunk;
-    if (call_via == NULL) return false;
+    if (!call_via) return false;
 
     size_t processed_imps = 0;
     size_t recovered_imps = 0;
 
     FIELD_T thunk_addr = lib_desc->OriginalFirstThunk;
-    if (thunk_addr == NULL) {
+    if (!thunk_addr) {
         thunk_addr = call_via;
     }
 
     BYTE* call_via_ptr = (BYTE*)((ULONGLONG)modulePtr + call_via);
     BYTE* thunk_ptr = (BYTE*)((ULONGLONG)modulePtr + thunk_addr);
     for (;
-        call_via_ptr != NULL && thunk_ptr != NULL;
+        call_via_ptr && thunk_ptr;
         call_via_ptr += sizeof(FIELD_T), thunk_ptr += sizeof(FIELD_T)
         )
     {
@@ -197,7 +197,7 @@ bool ImportsUneraser::fillImportNames(
             break;
         }
         IMAGE_THUNK_DATA_T* desc = (IMAGE_THUNK_DATA_T*)thunk_ptr;
-        if (desc->u1.Function == NULL) {
+        if (!desc->u1.Function) {
             break;
         }
         ULONGLONG searchedAddr = ULONGLONG(*call_via_val);
diff --git a/libpeconv/src/pe_hdrs_helper.cpp b/libpeconv/src/pe_hdrs_helper.cpp
@@ -143,7 +143,7 @@ IMAGE_DATA_DIRECTORY* peconv::get_directory_entry(IN const BYTE *pe_buffer, IN D
         IMAGE_NT_HEADERS32* nt_headers64 = (IMAGE_NT_HEADERS32*)nt_headers;
         peDir = &(nt_headers64->OptionalHeader.DataDirectory[dir_id]);
     }
-    if (!allow_empty && peDir->VirtualAddress == NULL) {
+    if (!allow_empty && !peDir->VirtualAddress) {
         return nullptr;
     }
     return peDir;
@@ -457,7 +457,7 @@ WORD peconv::get_subsystem(IN const BYTE* payload)
     if (!payload) return 0;
 
     BYTE* payload_nt_hdr = get_nt_hdrs(payload);
-    if (payload_nt_hdr == NULL) {
+    if (!payload_nt_hdr) {
         return 0;
     }
     const bool is64b = is64bit(payload);
@@ -604,7 +604,7 @@ DWORD peconv::calc_pe_size(IN const PBYTE pe_buffer, IN size_t pe_size, IN bool
 
 bool peconv::is_valid_sectons_alignment(IN const BYTE* payload, IN const SIZE_T payload_size, IN bool is_raw)
 {
-    if (payload == NULL) return false;
+    if (!payload) return false;
 
     const DWORD my_align = peconv::get_sec_alignment(payload, is_raw);
     if (my_align == 0) {
diff --git a/libpeconv/src/pe_loader.cpp b/libpeconv/src/pe_loader.cpp
@@ -14,27 +14,27 @@ using namespace peconv;
 namespace peconv {
     BYTE* load_no_sec_pe(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, bool executable)
     {
-        ULONGLONG desired_base = 0;
+        ULONG_PTR desired_base = 0;
         size_t out_size = (r_size < PAGE_SIZE) ? PAGE_SIZE : r_size;
         if (executable) {
             desired_base = get_image_base(dllRawData);
             out_size = peconv::get_image_size(dllRawData);
         }
         DWORD protect = (executable) ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
-        BYTE* mappedPE = peconv::alloc_pe_buffer(out_size, protect, desired_base);
+        BYTE* mappedPE = peconv::alloc_pe_buffer(out_size, protect, reinterpret_cast<void*>(desired_base));
         if (!mappedPE) {
-            return NULL;
+            return nullptr;
         }
         memcpy(mappedPE, dllRawData, r_size);
         v_size = out_size;
         return mappedPE;
     }
 };
 
-BYTE* peconv::load_pe_module(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, bool executable, bool relocate, ULONGLONG desired_base)
+BYTE* peconv::load_pe_module(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, bool executable, bool relocate, ULONG_PTR desired_base)
 {
     if (!peconv::get_nt_hdrs(dllRawData, r_size)) {
-        return NULL;
+        return nullptr;
     }
     if (peconv::get_sections_count(dllRawData, r_size) == 0) {
         return load_no_sec_pe(dllRawData, r_size, v_size, executable);
@@ -53,35 +53,35 @@ BYTE* peconv::load_pe_module(BYTE* dllRawData, size_t r_size, OUT size_t &v_size
             // relocating was required, but it failed - thus, the full PE image is useless
             std::cerr << "[!] Could not relocate the module!\n";
             free_pe_buffer(mappedDLL, v_size);
-            mappedDLL = NULL;
+            mappedDLL = nullptr;
         }
     } else {
         std::cerr << "[!] Could not allocate memory at the desired base!\n";
     }
     return mappedDLL;
 }
 
-BYTE* peconv::load_pe_module(LPCTSTR filename, OUT size_t &v_size, bool executable, bool relocate, ULONGLONG desired_base)
+BYTE* peconv::load_pe_module(LPCTSTR filename, OUT size_t &v_size, bool executable, bool relocate, ULONG_PTR desired_base)
 {
     size_t r_size = 0;
     BYTE *dllRawData = load_file(filename, r_size);
     if (!dllRawData) {
 #ifdef _DEBUG
         std::cerr << "Cannot load the file: " << filename << std::endl;
 #endif
-        return NULL;
+        return nullptr;
     }
     BYTE* mappedPE = load_pe_module(dllRawData, r_size, v_size, executable, relocate, desired_base);
     free_file(dllRawData);
     return mappedPE;
 }
 
-BYTE* peconv::load_pe_executable(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, t_function_resolver* import_resolver, ULONGLONG desired_base)
+BYTE* peconv::load_pe_executable(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, t_function_resolver* import_resolver, ULONG_PTR desired_base)
 {
     BYTE* loaded_pe = load_pe_module(dllRawData, r_size, v_size, true, true, desired_base);
     if (!loaded_pe) {
         std::cerr << "[-] Loading failed!\n";
-        return NULL;
+        return nullptr;
     }
 #if _DEBUG
     printf("Loaded at: %p\n", loaded_pe);
@@ -116,7 +116,7 @@ BYTE* peconv::load_pe_executable(LPCTSTR my_path, OUT size_t &v_size, t_function
     if (!load_imports(loaded_pe, import_resolver)) {
         printf("[-] Loading imports failed!");
         free_pe_buffer(loaded_pe, v_size);
-        return NULL;
+        return nullptr;
     }
     return loaded_pe;
 }
diff --git a/libpeconv/src/pe_raw_to_virtual.cpp b/libpeconv/src/pe_raw_to_virtual.cpp

Original file line number	Diff line number	Diff line change
`@@ -53,11 +53,11 @@ void peconv::free_unaligned(peconv::UNALIGNED_BUF section_buffer)`
`53`	`53`	`// alloc/free aligned buffers:`
`54`	`54`	`//`
`55`	`55`
`56`		`-peconv::ALIGNED_BUF peconv::alloc_aligned(size_t buffer_size, DWORD protect, ULONGLONG desired_base)`
	`56`	`+peconv::ALIGNED_BUF peconv::alloc_aligned(size_t buffer_size, DWORD protect, void* desired_base)`
`57`	`57`	`{`
`58`	`58`	`if (!buffer_size) return NULL;`
`59`	`59`
`60`		`- ALIGNED_BUF buf = (ALIGNED_BUF) VirtualAlloc((LPVOID) desired_base, buffer_size, MEM_COMMIT \| MEM_RESERVE, protect);`
	`60`	`+ ALIGNED_BUF buf = (ALIGNED_BUF) VirtualAlloc(desired_base, buffer_size, MEM_COMMIT \| MEM_RESERVE, protect);`
`61`	`61`	`return buf;`
`62`	`62`	`}`
`63`	`63`
`@@ -79,7 +79,7 @@ bool peconv::free_aligned(peconv::ALIGNED_BUF buffer, size_t buffer_size)`
`79`	`79`	`//`
`80`	`80`
`81`	`81`	`// allocate a buffer for PE module:`
`82`		`-peconv::ALIGNED_BUF peconv::alloc_pe_buffer(size_t buffer_size, DWORD protect, ULONGLONG desired_base)`
	`82`	`+peconv::ALIGNED_BUF peconv::alloc_pe_buffer(size_t buffer_size, DWORD protect, void* desired_base)`
`83`	`83`	`{`
`84`	`84`	`return alloc_aligned(buffer_size, protect, desired_base);`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ size_t find_addresses_to_fill(FIELD_T call_via, FIELD_T thunk_addr, LPVOID modul`
`26`	`26`	`}`
`27`	`27`	`FIELD_T thunk_val = reinterpret_cast<FIELD_T>(thunk_ptr);`
`28`	`28`	`FIELD_T call_via_val = reinterpret_cast<FIELD_T>(call_via_ptr);`
`29`		`- if (*call_via_val == 0) {`
	`29`	`+ if ((*call_via_val) == 0) {`
`30`	`30`	`//nothing to fill, probably the last record`
`31`	`31`	`break;`
`32`	`32`	`}`
`@@ -217,14 +217,14 @@ bool peconv::fix_imports(IN OUT PVOID modulePtr, IN size_t moduleSize, IN const`
`217`	`217`	`{`
`218`	`218`	`bool skip_bound = false; // skip boud imports?`
`219`	`219`	`IMAGE_DATA_DIRECTORY importsDir = peconv::get_directory_entry((const BYTE) modulePtr, IMAGE_DIRECTORY_ENTRY_IMPORT);`
`220`		`- if (importsDir == NULL) {`
	`220`	`+ if (!importsDir) {`
`221`	`221`	`return true; // done! no imports -> nothing to fix`
`222`	`222`	`}`
`223`	`223`	`bool is64 = peconv::is64bit((BYTE*)modulePtr);`
`224`	`224`	`DWORD maxSize = importsDir->Size;`
`225`	`225`	`DWORD impAddr = importsDir->VirtualAddress;`
`226`	`226`
`227`		`- IMAGE_IMPORT_DESCRIPTOR* lib_desc = NULL;`
	`227`	`+ IMAGE_IMPORT_DESCRIPTOR* lib_desc = nullptr;`
`228`	`228`	`DWORD parsedSize = 0;`
`229`	`229`	`#ifdef _DEBUG`
`230`	`230`	`printf("---IMP---\n");`
`@@ -240,7 +240,7 @@ bool peconv::fix_imports(IN OUT PVOID modulePtr, IN size_t moduleSize, IN const`
`240`	`240`	`return false;`
`241`	`241`	`}`
`242`	`242`	`parsedSize += sizeof(IMAGE_IMPORT_DESCRIPTOR);`
`243`		`- if (lib_desc->OriginalFirstThunk == NULL && lib_desc->FirstThunk == NULL) {`
	`243`	`+ if (!lib_desc->OriginalFirstThunk && !lib_desc->FirstThunk) {`
`244`	`244`	`break;`
`245`	`245`	`}`
`246`	`246`	`const bool is_bound = (lib_desc->TimeDateStamp == (-1));`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ class CollectThunksCallback : public peconv::ImportThunksCallback`
`93`	`93`
`94`	`94`	`virtual bool processThunks(LPSTR libName, ULONG_PTR origFirstThunkPtr, ULONG_PTR va)`
`95`	`95`	`{`
`96`		`- if (va == NULL) {`
	`96`	`+ if (!va) {`
`97`	`97`	`return false; // invalid thunk`
`98`	`98`	`}`
`99`	`99`	`const ULONGLONG module_base = reinterpret_cast<ULONGLONG>(this->vBuf);`
`@@ -143,7 +143,7 @@ class CollectImportsCallback : public ImportThunksCallback`
`143`	`143`	`template <typename T_FIELD, typename T_IMAGE_THUNK_DATA>`
`144`	`144`	`bool processThunks_tpl(LPSTR lib_name, T_IMAGE_THUNK_DATA* desc, T_FIELD* call_via, T_FIELD ordinal_flag)`
`145`	`145`	`{`
`146`		`- if (call_via == nullptr) {`
	`146`	`+ if (!call_via) {`
`147`	`147`	`return false;`
`148`	`148`	`}`
`149`	`149`
`@@ -199,7 +199,7 @@ bool process_imp_functions_tpl(BYTE* modulePtr, size_t module_size, LPSTR lib_na`
`199`	`199`	`if (!validate_ptr(modulePtr, module_size, desc, sizeof(T_IMAGE_THUNK_DATA))) {`
`200`	`200`	`break;`
`201`	`201`	`}`
`202`		`- if (desc->u1.Function == NULL) {`
	`202`	`+ if (!desc->u1.Function) {`
`203`	`203`	`break;`
`204`	`204`	`}`
`205`	`205`	`T_FIELD ordinal_flag = (sizeof(T_FIELD) == sizeof(ULONGLONG)) ? IMAGE_ORDINAL_FLAG64 : IMAGE_ORDINAL_FLAG32;`
`@@ -233,7 +233,7 @@ bool process_dlls(BYTE* modulePtr, size_t module_size, IMAGE_IMPORT_DESCRIPTOR *`
`233`	`233`	`if (!validate_ptr(modulePtr, module_size, lib_desc, sizeof(IMAGE_IMPORT_DESCRIPTOR))) {`
`234`	`234`	`break;`
`235`	`235`	`}`
`236`		`- if (lib_desc->OriginalFirstThunk == NULL && lib_desc->FirstThunk == NULL) {`
	`236`	`+ if (!lib_desc->OriginalFirstThunk && !lib_desc->FirstThunk) {`
`237`	`237`	`break;`
`238`	`238`	`}`
`239`	`239`	`LPSTR lib_name = (LPSTR)((ULONGLONG)modulePtr + lib_desc->Name);`
`@@ -243,7 +243,7 @@ bool process_dlls(BYTE* modulePtr, size_t module_size, IMAGE_IMPORT_DESCRIPTOR *`
`243`	`243`	`}`
`244`	`244`	`DWORD call_via = lib_desc->FirstThunk;`
`245`	`245`	`DWORD thunk_addr = lib_desc->OriginalFirstThunk;`
`246`		`- if (thunk_addr == NULL) {`
	`246`	`+ if (!thunk_addr) {`
`247`	`247`	`thunk_addr = lib_desc->FirstThunk;`
`248`	`248`	`}`
`249`	`249`	`#ifdef _DEBUG_EX`
`@@ -330,11 +330,11 @@ bool peconv::is_valid_import_name(const PBYTE modulePtr, const size_t moduleSize`
`330`	`330`	`bool peconv::has_valid_import_table(const PBYTE modulePtr, size_t moduleSize)`
`331`	`331`	`{`
`332`	`332`	`IMAGE_DATA_DIRECTORY importsDir = get_directory_entry((BYTE)modulePtr, IMAGE_DIRECTORY_ENTRY_IMPORT);`
`333`		`- if (importsDir == NULL) return false;`
	`333`	`+ if (!importsDir) return false;`
`334`	`334`
`335`	`335`	`const DWORD impAddr = importsDir->VirtualAddress;`
`336`	`336`
`337`		`- IMAGE_IMPORT_DESCRIPTOR* lib_desc = NULL;`
	`337`	`+ IMAGE_IMPORT_DESCRIPTOR* lib_desc = nullptr;`
`338`	`338`	`DWORD parsedSize = 0;`
`339`	`339`	`size_t valid_records = 0;`
`340`	`340`
`@@ -345,15 +345,15 @@ bool peconv::has_valid_import_table(const PBYTE modulePtr, size_t moduleSize)`
`345`	`345`	`}`
`346`	`346`	`parsedSize += sizeof(IMAGE_IMPORT_DESCRIPTOR);`
`347`	`347`
`348`		`- if (lib_desc->OriginalFirstThunk == NULL && lib_desc->FirstThunk == NULL) {`
	`348`	`+ if (!lib_desc->OriginalFirstThunk && !lib_desc->FirstThunk) {`
`349`	`349`	`break;`
`350`	`350`	`}`
`351`	`351`	`LPSTR lib_name = (LPSTR)((ULONGLONG)modulePtr + lib_desc->Name);`
`352`	`352`	`if (!is_valid_import_name(modulePtr, moduleSize, lib_name)) return false;`
`353`	`353`
`354`	`354`	`DWORD call_via = lib_desc->FirstThunk;`
`355`	`355`	`DWORD thunk_addr = lib_desc->OriginalFirstThunk;`
`356`		`- if (thunk_addr == NULL) thunk_addr = lib_desc->FirstThunk;`
	`356`	`+ if (!thunk_addr) thunk_addr = lib_desc->FirstThunk;`
`357`	`357`
`358`	`358`	`DWORD thunks = (DWORD)((ULONGLONG)modulePtr + thunk_addr);`
`359`	`359`	`if (!peconv::validate_ptr(modulePtr, moduleSize, thunks, sizeof(DWORD))) return false;`
Original file line number	Diff line number	Diff line change
`@@ -9,14 +9,14 @@ LPVOID search_name(std::string name, const char* modulePtr, size_t moduleSize)`
`9`	`9`	`const char* namec = name.c_str();`
`10`	`10`	`const size_t searched_len = name.length() + 1; // with terminating NULL`
`11`	`11`	`const char* found_ptr = std::search(modulePtr, modulePtr + moduleSize, namec, namec + searched_len);`
`12`		`- if (found_ptr == NULL) {`
`13`		`- return NULL;`
	`12`	`+ if (!found_ptr) {`
	`13`	`+ return nullptr;`
`14`	`14`	`}`
`15`	`15`	`size_t o = found_ptr - modulePtr;`
`16`	`16`	`if (o < moduleSize) {`
`17`	`17`	`return (LPVOID)(found_ptr);`
`18`	`18`	`}`
`19`		`- return NULL;`
	`19`	`+ return nullptr;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`bool ImportsUneraser::writeFoundDllName(IMAGE_IMPORT_DESCRIPTOR* lib_desc, const std::string &found_name)`
`@@ -69,7 +69,7 @@ bool ImportsUneraser::findNameInBinaryAndFill(IMAGE_IMPORT_DESCRIPTOR* lib_desc,`
`69`	`69`	`std::map<ULONGLONG, std::set<ExportedFunc>> &addr_to_func`
`70`	`70`	`)`
`71`	`71`	`{`
`72`		`- if (call_via_ptr == NULL \|\| modulePtr == NULL \|\| lib_desc == NULL) {`
	`72`	`+ if (!call_via_ptr \|\| !modulePtr \|\| !lib_desc) {`
`73`	`73`	`return false; //malformed input`
`74`	`74`	`}`
`75`	`75`	`IMAGE_DATA_DIRECTORY importsDir = get_directory_entry((BYTE)modulePtr, IMAGE_DIRECTORY_ENTRY_IMPORT);`
`@@ -170,23 +170,23 @@ bool ImportsUneraser::fillImportNames(`
`170`	`170`	`OUT OPTIONAL ImpsNotCovered* notCovered`
`171`	`171`	`)`
`172`	`172`	`{`
`173`		`- if (lib_desc == NULL) return false;`
	`173`	`+ if (!lib_desc) return false;`
`174`	`174`
`175`	`175`	`FIELD_T call_via = lib_desc->FirstThunk;`
`176`		`- if (call_via == NULL) return false;`
	`176`	`+ if (!call_via) return false;`
`177`	`177`
`178`	`178`	`size_t processed_imps = 0;`
`179`	`179`	`size_t recovered_imps = 0;`
`180`	`180`
`181`	`181`	`FIELD_T thunk_addr = lib_desc->OriginalFirstThunk;`
`182`		`- if (thunk_addr == NULL) {`
	`182`	`+ if (!thunk_addr) {`
`183`	`183`	`thunk_addr = call_via;`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`BYTE* call_via_ptr = (BYTE*)((ULONGLONG)modulePtr + call_via);`
`187`	`187`	`BYTE* thunk_ptr = (BYTE*)((ULONGLONG)modulePtr + thunk_addr);`
`188`	`188`	`for (;`
`189`		`- call_via_ptr != NULL && thunk_ptr != NULL;`
	`189`	`+ call_via_ptr && thunk_ptr;`
`190`	`190`	`call_via_ptr += sizeof(FIELD_T), thunk_ptr += sizeof(FIELD_T)`
`191`	`191`	`)`
`192`	`192`	`{`
`@@ -197,7 +197,7 @@ bool ImportsUneraser::fillImportNames(`
`197`	`197`	`break;`
`198`	`198`	`}`
`199`	`199`	`IMAGE_THUNK_DATA_T* desc = (IMAGE_THUNK_DATA_T*)thunk_ptr;`
`200`		`- if (desc->u1.Function == NULL) {`
	`200`	`+ if (!desc->u1.Function) {`
`201`	`201`	`break;`
`202`	`202`	`}`
`203`	`203`	`ULONGLONG searchedAddr = ULONGLONG(*call_via_val);`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ IMAGE_DATA_DIRECTORY* peconv::get_directory_entry(IN const BYTE *pe_buffer, IN D`
`143`	`143`	`IMAGE_NT_HEADERS32* nt_headers64 = (IMAGE_NT_HEADERS32*)nt_headers;`
`144`	`144`	`peDir = &(nt_headers64->OptionalHeader.DataDirectory[dir_id]);`
`145`	`145`	`}`
`146`		`- if (!allow_empty && peDir->VirtualAddress == NULL) {`
	`146`	`+ if (!allow_empty && !peDir->VirtualAddress) {`
`147`	`147`	`return nullptr;`
`148`	`148`	`}`
`149`	`149`	`return peDir;`
`@@ -457,7 +457,7 @@ WORD peconv::get_subsystem(IN const BYTE* payload)`
`457`	`457`	`if (!payload) return 0;`
`458`	`458`
`459`	`459`	`BYTE* payload_nt_hdr = get_nt_hdrs(payload);`
`460`		`- if (payload_nt_hdr == NULL) {`
	`460`	`+ if (!payload_nt_hdr) {`
`461`	`461`	`return 0;`
`462`	`462`	`}`
`463`	`463`	`const bool is64b = is64bit(payload);`
`@@ -604,7 +604,7 @@ DWORD peconv::calc_pe_size(IN const PBYTE pe_buffer, IN size_t pe_size, IN bool`
`604`	`604`
`605`	`605`	`bool peconv::is_valid_sectons_alignment(IN const BYTE* payload, IN const SIZE_T payload_size, IN bool is_raw)`
`606`	`606`	`{`
`607`		`- if (payload == NULL) return false;`
	`607`	`+ if (!payload) return false;`
`608`	`608`
`609`	`609`	`const DWORD my_align = peconv::get_sec_alignment(payload, is_raw);`
`610`	`610`	`if (my_align == 0) {`
Original file line number	Diff line number	Diff line change
`@@ -14,27 +14,27 @@ using namespace peconv;`
`14`	`14`	`namespace peconv {`
`15`	`15`	`BYTE* load_no_sec_pe(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, bool executable)`
`16`	`16`	`{`
`17`		`- ULONGLONG desired_base = 0;`
	`17`	`+ ULONG_PTR desired_base = 0;`
`18`	`18`	`size_t out_size = (r_size < PAGE_SIZE) ? PAGE_SIZE : r_size;`
`19`	`19`	`if (executable) {`
`20`	`20`	`desired_base = get_image_base(dllRawData);`
`21`	`21`	`out_size = peconv::get_image_size(dllRawData);`
`22`	`22`	`}`
`23`	`23`	`DWORD protect = (executable) ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;`
`24`		`- BYTE* mappedPE = peconv::alloc_pe_buffer(out_size, protect, desired_base);`
	`24`	`+ BYTE* mappedPE = peconv::alloc_pe_buffer(out_size, protect, reinterpret_cast<void*>(desired_base));`
`25`	`25`	`if (!mappedPE) {`
`26`		`- return NULL;`
	`26`	`+ return nullptr;`
`27`	`27`	`}`
`28`	`28`	`memcpy(mappedPE, dllRawData, r_size);`
`29`	`29`	`v_size = out_size;`
`30`	`30`	`return mappedPE;`
`31`	`31`	`}`
`32`	`32`	`};`
`33`	`33`
`34`		`-BYTE* peconv::load_pe_module(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, bool executable, bool relocate, ULONGLONG desired_base)`
	`34`	`+BYTE* peconv::load_pe_module(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, bool executable, bool relocate, ULONG_PTR desired_base)`
`35`	`35`	`{`
`36`	`36`	`if (!peconv::get_nt_hdrs(dllRawData, r_size)) {`
`37`		`- return NULL;`
	`37`	`+ return nullptr;`
`38`	`38`	`}`
`39`	`39`	`if (peconv::get_sections_count(dllRawData, r_size) == 0) {`
`40`	`40`	`return load_no_sec_pe(dllRawData, r_size, v_size, executable);`
`@@ -53,35 +53,35 @@ BYTE* peconv::load_pe_module(BYTE* dllRawData, size_t r_size, OUT size_t &v_size`
`53`	`53`	`// relocating was required, but it failed - thus, the full PE image is useless`
`54`	`54`	`std::cerr << "[!] Could not relocate the module!\n";`
`55`	`55`	`free_pe_buffer(mappedDLL, v_size);`
`56`		`- mappedDLL = NULL;`
	`56`	`+ mappedDLL = nullptr;`
`57`	`57`	`}`
`58`	`58`	`} else {`
`59`	`59`	`std::cerr << "[!] Could not allocate memory at the desired base!\n";`
`60`	`60`	`}`
`61`	`61`	`return mappedDLL;`
`62`	`62`	`}`
`63`	`63`
`64`		`-BYTE* peconv::load_pe_module(LPCTSTR filename, OUT size_t &v_size, bool executable, bool relocate, ULONGLONG desired_base)`
	`64`	`+BYTE* peconv::load_pe_module(LPCTSTR filename, OUT size_t &v_size, bool executable, bool relocate, ULONG_PTR desired_base)`
`65`	`65`	`{`
`66`	`66`	`size_t r_size = 0;`
`67`	`67`	`BYTE *dllRawData = load_file(filename, r_size);`
`68`	`68`	`if (!dllRawData) {`
`69`	`69`	`#ifdef _DEBUG`
`70`	`70`	`std::cerr << "Cannot load the file: " << filename << std::endl;`
`71`	`71`	`#endif`
`72`		`- return NULL;`
	`72`	`+ return nullptr;`
`73`	`73`	`}`
`74`	`74`	`BYTE* mappedPE = load_pe_module(dllRawData, r_size, v_size, executable, relocate, desired_base);`
`75`	`75`	`free_file(dllRawData);`
`76`	`76`	`return mappedPE;`
`77`	`77`	`}`
`78`	`78`
`79`		`-BYTE* peconv::load_pe_executable(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, t_function_resolver* import_resolver, ULONGLONG desired_base)`
	`79`	`+BYTE* peconv::load_pe_executable(BYTE* dllRawData, size_t r_size, OUT size_t &v_size, t_function_resolver* import_resolver, ULONG_PTR desired_base)`
`80`	`80`	`{`
`81`	`81`	`BYTE* loaded_pe = load_pe_module(dllRawData, r_size, v_size, true, true, desired_base);`
`82`	`82`	`if (!loaded_pe) {`
`83`	`83`	`std::cerr << "[-] Loading failed!\n";`
`84`		`- return NULL;`
	`84`	`+ return nullptr;`
`85`	`85`	`}`
`86`	`86`	`#if _DEBUG`
`87`	`87`	`printf("Loaded at: %p\n", loaded_pe);`
`@@ -116,7 +116,7 @@ BYTE* peconv::load_pe_executable(LPCTSTR my_path, OUT size_t &v_size, t_function`
`116`	`116`	`if (!load_imports(loaded_pe, import_resolver)) {`
`117`	`117`	`printf("[-] Loading imports failed!");`
`118`	`118`	`free_pe_buffer(loaded_pe, v_size);`
`119`		`- return NULL;`
	`119`	`+ return nullptr;`
`120`	`120`	`}`
`121`	`121`	`return loaded_pe;`
`122`	`122`	`}`