update: redesigned VM::brand(), cmake warning fixes, and code clarity changes

Author: kernelwernel

.gitignore

@@ -68,4 +68,5 @@ list.txt
 /.vs/VSWorkspaceState.json
 TODO.md
 auxiliary/path*
-packages/
+packages/
+auxiliary/test.cpp

CMakeLists.txt

@@ -91,7 +91,7 @@ elseif(APPLE)
 elseif(LINUX)
     if(CMAKE_BUILD_TYPE MATCHES "Debug")
         message(STATUS "Build set to debug mode")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fmax-errors=5 -DDEBUG -O0 -fsanitize=address,leak")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -DDEBUG -O0 -fsanitize=address,leak")
     elseif(CMAKE_BUILD_TYPE MATCHES "Release")
         message(STATUS "Build set to release mode")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g0 -O2")

src/cli.cpp

@@ -1291,7 +1291,7 @@ int main(int argc, char* argv[]) {
     VM::add_custom(35, anyrun_directory);
 
     if (arg_count == 0) {
-        general(VM::NULL_ARG, VM::NULL_ARG, VM::DYNAMIC);
+        general(VM::NULL_ARG, VM::NULL_ARG, VM::NULL_ARG);
         return 0;
     }
 
@@ -1399,6 +1399,8 @@ int main(int argc, char* argv[]) {
     const VM::enum_flags all = (arg_bitset.test(ALL) ? VM::ALL : VM::NULL_ARG);
     const VM::enum_flags dynamic = (arg_bitset.test(DYNAMIC) ? VM::DYNAMIC : VM::NULL_ARG);
 
+    std::cout << "\n\n\n\nDYNAMIC: " << static_cast<u32>(dynamic) << "\n\n\n";
+
     if (returners > 0) { // at least one of the options are set
         if (returners > 1) { // more than 2 options are set
             std::cerr << "--stdout, --percent, --detect, --brand, --type, and --conclusion must NOT be a combination, choose only a single one\n";

src/vmaware.hpp

@@ -3091,29 +3091,30 @@ struct VM {
         }
 
         struct brand {
-            static char brand_cache[512];
+            static std::string brand_cache;
             static bool cached;
 
-            static void store(const char* s) {
-                str_copy(brand_cache, s, sizeof(brand_cache));
+            static void store(const std::string& s) {
+                brand_cache = s;
                 cached = true;
+                debug("VM::brand(): cached brand string");
             }
 
             static bool is_cached() { return cached; }
-            static const char* fetch() { return brand_cache; }
+            static std::string fetch() { return brand_cache; }
         };
 
         struct multi_brand {
-            static char brand_cache[1024];
+            static std::string brand_cache;
             static bool cached;
 
-            static void store(const char* s) {
-                str_copy(brand_cache, s, sizeof(brand_cache));
+            static void store(const std::string& s) {
+                brand_cache = s;
                 cached = true;
             }
 
             static bool is_cached() { return cached; }
-            static const char* fetch() { return brand_cache; }
+            static std::string fetch() { return brand_cache; }
         };
 
         // helper specifically for conclusion strings
@@ -4706,7 +4707,10 @@ struct VM {
         #endif
         };
 
-        thread_local u32 aux = 0;
+        #if (MSVC)
+            thread_local u32 aux = 0;
+        #endif
+
         auto cpuid = [](unsigned int leaf) noexcept -> u64 {
         #if (MSVC)
             // make regs volatile so writes cannot be optimized out, if this isn't added and the code is compiled in release mode, cycles would be around 40 even under Hyper-V
@@ -11933,8 +11937,7 @@ struct VM {
                 debug("VM::brand(): returned multi brand from cache");
                 return memo::multi_brand::fetch();
             }
-        }
-        else {
+        } else {
             if (memo::brand::is_cached()) {
                 debug("VM::brand(): returned brand from cache");
                 return memo::brand::fetch();
@@ -11990,6 +11993,15 @@ struct VM {
         std::array<brand_element_t, core::MAX_BRANDS> active_brands;
         size_t active_count = 0;
 
+        // wrappers for simplicity, these will most likely be inlined by the compiler anyway
+        auto fetch_brand_name = [&](const size_t index) -> const char* {
+            return active_brands[index].first;
+        };
+
+        auto fetch_brand_score = [&](const size_t index) -> brand_score_t {
+            return active_brands[index].second;
+        };
+
         for (size_t i = 0; i < core::brand_count; ++i) {
             if (core::brand_scoreboard[i].score > 0) {
                 active_brands[active_count++] = std::make_pair(core::brand_scoreboard[i].name, core::brand_scoreboard[i].score);
@@ -11998,48 +12010,62 @@ struct VM {
 
         // if all brands have a point of 0, return "Unknown"
         if (active_count == 0) {
+            memo::brand::store(brands::NULL_BRAND);
             return brands::NULL_BRAND;
         }
-
-        // if there's only a single brand, return it immediately
-        // We skip this early return if the single brand is HYPERV_ARTIFACT,
-        // so that the removal logic at the end of the function can process it
-        if (active_count == 1 && active_brands[0].first != TMP_HYPERV_ARTIFACT) {
-            return active_brands[0].first;
-        }
-
+        
         // helper lambdas for array manipulation
-        auto find_index = [&](const char* name) noexcept -> int {
+        auto find_index = [&](const char* name) noexcept -> i8 {
             for (size_t i = 0; i < active_count; ++i) {
                 // pointer comparison is sufficient for static brands
-                if (active_brands[i].first == name) return static_cast<int>(i);
+                if (fetch_brand_name(i) == name) {
+                    return static_cast<i8>(i);
+                }
             }
             return -1;
         };
 
-        auto remove_at = [&](int index) noexcept {
+        auto remove_at = [&](const u8 index) noexcept {
             if (index >= 0 && index < static_cast<int>(active_count)) {
                 if (index != static_cast<int>(active_count - 1)) {
                     active_brands[static_cast<size_t>(index)] = active_brands[active_count - 1];
                 }
                 active_count--;
             }
         };
-
+    
         // remove Hyper-V artifacts if found with other brands
         if (active_count > 1) {
-            const int idx = find_index(TMP_HYPERV_ARTIFACT);
+            const i8 idx = find_index(TMP_HYPERV_ARTIFACT);
             if (idx != -1) {
                 remove_at(idx);
             }
         }
 
+        // if there's only a single brand, return it immediately
+        // We skip this early return if the single brand is HYPERV_ARTIFACT,
+        // but we must also nullify the result if the score is above 0, 
+        // which would most likely indicate a hardened VM instead and return "Unknown".
+        if (active_count == 1) {
+            const std::string& initial_brand = fetch_brand_name(0);
+
+            if (initial_brand == TMP_HYPERV_ARTIFACT) {
+                if (score > 0) {
+                    memo::brand::store(brands::NULL_BRAND);
+                    return brands::NULL_BRAND;
+                }
+            }
+    
+            memo::brand::store(initial_brand);
+            return initial_brand;
+        }
+
         // merge 2 brands
         auto merge = [&](const char* a, const char* b, const char* result) noexcept -> void {
-            int idx_a = find_index(a);
+            i8 idx_a = find_index(a);
             if (idx_a == -1) return;
 
-            int idx_b = find_index(b);
+            i8 idx_b = find_index(b);
             if (idx_b == -1) return;
 
             remove_at(idx_a);
@@ -12051,11 +12077,11 @@ struct VM {
 
         // same as above, but for 3
         auto triple_merge = [&](const char* a, const char* b, const char* c, const char* result) noexcept -> void {
-            int idx_a = find_index(a);
+            i8 idx_a = find_index(a);
             if (idx_a == -1) return;
-            int idx_b = find_index(b);
+            i8 idx_b = find_index(b);
             if (idx_b == -1) return;
-            int idx_c = find_index(c);
+            i8 idx_c = find_index(c);
             if (idx_c == -1) return;
 
             remove_at(idx_a);
@@ -12064,20 +12090,10 @@ struct VM {
 
             active_brands[active_count++] = std::make_pair(result, 2);
         };
-
-        // some edgecase handling for Hyper-V and VirtualPC
-        int idx_hv = find_index(TMP_HYPERV);
-        int idx_vpc = find_index(TMP_VPC);
-
-        if (idx_hv != -1 && idx_vpc != -1) {
-            // existence is confirmed by index != -1
-            merge(TMP_VPC, TMP_HYPERV, TMP_HYPERV_VPC);
-        }
-        else if (idx_hv != -1 && idx_vpc == -1) {
-            // logic handled by merge check essentially
-        }
-
+        
         // Brand post-processing / merging
+        merge(TMP_VPC, TMP_HYPERV, TMP_HYPERV_VPC);
+
         merge(TMP_AZURE, TMP_HYPERV, TMP_AZURE);
         merge(TMP_AZURE, TMP_VPC, TMP_AZURE);
         merge(TMP_AZURE, TMP_HYPERV_VPC, TMP_AZURE);
@@ -12086,6 +12102,11 @@ struct VM {
         merge(TMP_KVM, TMP_HYPERV, TMP_KVM_HYPERV);
         merge(TMP_QEMU, TMP_HYPERV, TMP_QEMU_KVM_HYPERV);
         merge(TMP_QEMU_KVM, TMP_HYPERV, TMP_QEMU_KVM_HYPERV);
+
+        merge(TMP_KVM, TMP_HYPERV_VPC, TMP_KVM_HYPERV);
+        merge(TMP_QEMU, TMP_HYPERV_VPC, TMP_QEMU_KVM_HYPERV);
+        merge(TMP_QEMU_KVM, TMP_HYPERV_VPC, TMP_QEMU_KVM_HYPERV);
+
         merge(TMP_KVM, TMP_KVM_HYPERV, TMP_KVM_HYPERV);
         merge(TMP_QEMU, TMP_KVM_HYPERV, TMP_QEMU_KVM_HYPERV);
         merge(TMP_QEMU_KVM, TMP_KVM_HYPERV, TMP_QEMU_KVM_HYPERV);
@@ -12105,61 +12126,44 @@ struct VM {
         merge(TMP_VMWARE_HARD, TMP_GSX, TMP_VMWARE_HARD);
         merge(TMP_VMWARE_HARD, TMP_WORKSTATION, TMP_VMWARE_HARD);
 
-        // determine threshold (150 or 300)
-        u16 confirmed_vm_threshold = threshold_score;
-        if (core::is_enabled(flags, HIGH_THRESHOLD)) {
-            confirmed_vm_threshold = high_threshold_score;
-        }
-
-        // check if Hyper-V artifact is present
-        const int idx_art = find_index(TMP_HYPERV_ARTIFACT);
-        if (idx_art != -1) {
-            // If score confirms it is a VM, remove the "Artifact" label (because we're in a VM, not in a host machine)
-            // so it falls back to "Unknown" if no other brands exist
-            if (score >= confirmed_vm_threshold) {
-                remove_at(idx_art);
-            }
-        }
-
         if (active_count > 1) {
             std::sort(active_brands.begin(), active_brands.begin() + static_cast<std::ptrdiff_t>(active_count), [](
                 const brand_element_t& a,
                 const brand_element_t& b
-                ) {
-                return a.second > b.second;
+            ) {
+                return a.second > b.second; // .second = brand score (usually u8)
             });
         }
 
     #ifdef __VMAWARE_DEBUG__
         for (size_t i = 0; i < active_count; ++i) {
-            debug("scoreboard: ", (int)active_brands[i].second, " : ", active_brands[i].first);
+            debug("scoreboard: ", (brand_score_t)fetch_brand_score(i), " : ", fetch_brand_name(i));
         }
     #endif
 
-        if (active_count > 0) {
-            if (!is_multiple) {
-                memo::brand::store(active_brands[0].first);
-                debug("VM::brand(): cached brand string");
-                return memo::brand::fetch();
-            }
-            else {
-                char* buffer = memo::multi_brand::brand_cache;
-                buffer[0] = '\0';
-                const size_t buf_size = sizeof(memo::multi_brand::brand_cache);
+        if (active_count == 0) {
+            memo::brand::store(brands::NULL_BRAND);
+            return brands::NULL_BRAND;
+        }
 
-                str_copy(buffer, active_brands[0].first, buf_size);
-                for (size_t i = 1; i < active_count; i++) {
-                    str_cat(buffer, " or ", buf_size);
-                    str_cat(buffer, active_brands[i].first, buf_size);
-                }
+        if (is_multiple) {
+            std::string buffer = {};
+            buffer += fetch_brand_name(0);
 
-                memo::multi_brand::cached = true;
-                debug("VM::brand(): cached multiple brand string");
-                return memo::multi_brand::fetch();
+            for (size_t i = 1; i < active_count; i++) {
+                buffer += " or ";
+                buffer += fetch_brand_name(i);
             }
+
+            memo::multi_brand::store(buffer);
+            debug("VM::brand(): cached multiple brand string");
+            return buffer;
         }
 
-        return brands::NULL_BRAND;
+        const std::string& result_brand = fetch_brand_name(0);
+
+        memo::brand::store(result_brand);
+        return result_brand;
     }
 
 
@@ -12945,8 +12949,8 @@ size_t VM::core::brand_count = []() -> size_t {
 
 // initial definitions for cache items because C++ forbids in-class initializations
 std::array<VM::memo::cache_entry, VM::enum_size + 1> VM::memo::cache_table{};
-char VM::memo::brand::brand_cache[512] = { 0 };
-char VM::memo::multi_brand::brand_cache[1024] = { 0 };
+std::string VM::memo::brand::brand_cache = "";
+std::string VM::memo::multi_brand::brand_cache = "";
 char VM::memo::cpu_brand::brand_cache[128] = { 0 };
 char VM::memo::bios_info::manufacturer[256] = { 0 };
 char VM::memo::bios_info::model[128] = { 0 };