merge dev

Author: kernelwernel

CMakeLists.txt

@@ -53,7 +53,7 @@ set(TARGET "vmaware")
 if (MSVC)
     if(CMAKE_BUILD_TYPE MATCHES "Debug")
         MESSAGE(STATUS "Build set to debug mode")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Od /debug")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Od")
     elseif(CMAKE_BUILD_TYPE MATCHES "Release")
         MESSAGE(STATUS "Build set to release mode")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2")

README.md

@@ -19,7 +19,7 @@ The library is:
 - Very flexible, with total fine-grained control over which techniques get executed
 - Header-only
 - Available with C++11 and above
-- Able to detect VMware, VirtualBox, QEMU, KVM, Parallels, and [much more](https://github.com/kernelwernel/VMAware/blob/v0.2/docs/documentation.md#vmbrand)
+- Able to detect VMware, VirtualBox, QEMU, KVM, Parallels, and [much more](https://github.com/kernelwernel/VMAware/blob/main/docs/documentation.md#vmbrand)
 - Able to detect semi-VM technologies like hypervisors, docker, and wine
 - Able to guess the VM brand
 - Memoized, meaning past results are cached and retrieved if ran again for performance benefits 

docs/documentation.md

@@ -107,7 +107,7 @@ This will essentially return the VM brand as a `std::string`. The exact possible
 - `CWSandbox`
 - `Comodo`
 - `Bochs`
-- `Lockheed Martin LMHS` (yes, you read that right. The library can detect VMs running on US military fighter jets)
+- `Lockheed Martin LMHS`   (yes, you read that right. The library can detect VMs running on US military fighter jets)
 - `NVMM`
 - `OpenBSD VMM`
 - `Intel HAXM`

src/cli.cpp

@@ -1,4 +1,4 @@
-#include "vmaware.hpp"
+#include "../releases/1.4/vmaware.hpp"
 
 #include <string>
 #include <iostream>

src/vmaware.hpp

@@ -369,7 +369,7 @@ struct VM {
         INTEL_THREAD_MISMATCH,
         XEON_THREAD_MISMATCH,
 
-        // start of non-technqiue flags
+        // start of non-technique flags
         EXTREME,
         NO_MEMO,
         WIN_HYPERV_DEFAULT,
@@ -380,7 +380,7 @@ struct VM {
     static constexpr u8 enum_size = __LINE__ - enum_line_start - 4; // get enum size
     static constexpr u8 technique_count = enum_size - 4; // get total number of techniques
     static constexpr u8 non_technique_count = enum_size - technique_count; // get number of non-technique flags like VM::NO_MEMO for example
-
+    static constexpr u8 start_of_non_technique = VM::EXTREME;
     // for the bitset
     using flagset = std::bitset<enum_size>;
 
@@ -634,6 +634,7 @@ struct VM {
             bool found;
             bool is_xeon;
             bool is_i_series;
+            bool is_ryzen;
             std::string string;
         };
 
@@ -642,6 +643,7 @@ struct VM {
 
             constexpr const char* intel_i_series_regex    = "i[0-9]-[A-Z0-9]{1,7}";
             constexpr const char* intel_xeon_series_regex = "[DEW]-[A-Z0-9]{1,7}";
+            constexpr const char* amd_ryzen_regex         = "^(PRO)?[A-Z0-9]{1,7}";
 
             std::string match_str = "";
 
@@ -663,26 +665,29 @@ struct VM {
                 return false;
             };
 
-            bool found        = false;
-            bool is_xeon      = false;
-            bool is_i_series  = false;
-            std::string string = "";
+            bool found         = false;
+            bool is_xeon       = false;
+            bool is_i_series   = false;
+            bool is_ryzen      = false;
 
             if (cpu::is_intel()) {
                 if (match(intel_i_series_regex)) {
                     found       = true;
                     is_i_series = true;
-                    string       = match_str;
                 } else if (match(intel_xeon_series_regex)) {
                     found   = true;
                     is_xeon = true;
-                    string   = match_str;
                 }
             }
 
-            // no AMD (for now)
+            if (cpu::is_amd()) {
+                if (match(amd_ryzen_regex)) {
+                    found = true;
+                    is_ryzen = true;
+                }
+            }
 
-            return model_struct{ found, is_xeon, is_i_series, string };
+            return model_struct{ found, is_xeon, is_i_series, is_ryzen, match_str };
         };
 
 #if (CPP >= 17)
@@ -6766,38 +6771,41 @@ struct VM {
     }
 
 
-
-
-
-// TODO: DO AMD
-//https://en.wikipedia.org/wiki/List_of_AMD_Ryzen_processors
-
-
-
-
-
-
-
-
-
     /**
-     * @brief 
+     * @brief Check for AMD CPUs that don't match their thread count
      * @category All, x86
-     * @link https://en.wikipedia.org/wiki/List_of_Intel_Core_processors
+     * @link https://en.wikipedia.org/wiki/List_of_AMD_Ryzen_processors
      */ 
 /*
-    [[nodiscard]] static bool () try {
+    [[nodiscard]] static bool amd_thread_mismatch() try {
 #if (!x86)
         return false;
 #else
+        if (!cpu::is_amd()) {
+            return false;
+        }
+
+        if (cpu::has_hyperthreading()) {
+            return false;
+        }
 
+        const cpu::model_struct model = cpu::get_model();
+
+        if (!model.found) {
+            return false;
+        }
+
+        if (!model.is_i_series) {
+            return false;
+        }
+
+        debug("XEON_THREAD_MISMATCH: CPU model = ", model.string);
 #endif
     }
     catch (...) {
-        debug("XEON_THREAD_MISMATCH: catched error, returned false");
+        debug("AMD_THREAD_MISMATCH: catched error, returned false");
         return false;
     }
-
 */
 
 
@@ -6807,7 +6815,6 @@ struct VM {
 
 
 
-
     struct core {
         MSVC_DISABLE_WARNING(PADDING)
         struct technique {
@@ -6867,8 +6874,7 @@ struct VM {
 
             bool is_non_technique_set = false;
 
-            // VM::EXTREME is the start of non-technique flags in the enum
-            for (std::size_t i = VM::EXTREME; i <= enum_size; i++) {
+            for (std::size_t i = start_of_non_technique; i <= enum_size; i++) {
                 if (p_flags.test(i)) {
                     is_non_technique_set = true;
                     break;
@@ -6907,7 +6913,7 @@ struct VM {
                 }
 
                 // check if the technique is cached already
-                if (memo::is_cached(macro)) {
+                if (!memo_disabled && memo::is_cached(macro)) {
                     const memo::data_t data = memo::cache_fetch(macro);
 
                     if (data.result) {
@@ -6941,31 +6947,28 @@ struct VM {
                 }
             }
 
-
             return points;
         }
 
         // check if Hyper-V is running 
         static bool hyperv_default_check(const flagset &p_flags) {
-            if (MSVC && core::disabled(p_flags, WIN_HYPERV_DEFAULT)) {
-                std::string tmp_brand;
-
-                if (memo::brand::is_brand_cached()) {
-                    tmp_brand = memo::brand::fetch_brand();
-                } else {
-                    tmp_brand = brand();
-                }
+#if (!MSVC)
+            return false;
+#else
+            std::string tmp_brand;
 
-                if (
-                    tmp_brand == VM::HYPERV ||
-                    tmp_brand == VM::VPC ||
-                    tmp_brand == "Microsoft Virtual PC/Hyper-V"
-                ) {
-                    return true;
-                }
+            if (memo::brand::is_brand_cached()) {
+                tmp_brand = memo::brand::fetch_brand();
+            } else {
+                tmp_brand = brand();
             }
-            
-            return false;
+
+            return (
+                tmp_brand == VM::HYPERV ||
+                tmp_brand == VM::VPC ||
+                tmp_brand == "Microsoft Virtual PC/Hyper-V"
+            );
+#endif
         }
     };
 
@@ -7208,8 +7211,10 @@ struct VM {
             result = (points >= 100);
         }
 
-        if (core::hyperv_default_check(p_flags)) {
-            return false;
+        if (core::disabled(p_flags, VM::WIN_HYPERV_DEFAULT)) {
+            if (core::hyperv_default_check(p_flags)) {
+                return false;
+            }
         }
 
         return result;