¿Cómo detectar si mi aplicación se está ejecutando en una máquina virtual?

Question

¿Cómo puedo detectar (.NET o Win32) si mi aplicación se está ejecutando en una máquina virtual?

Answer 1

Según Virtual PC Guy 's blog 'Detecting Microsoft virtual machines', se puede utilizar WMI para comprobar el fabricante de la placa base. En PowerShell:

(gwmi Win32_BaseBoard).Manufacturer -eq "Microsoft Corporation" 

Answer 2

Aquí hay un ejemplo de una forma de hacerlo. Sólo funciona con Virtual PC de Microsoft y VMware, pero es un comienzo: http://www.codeproject.com/KB/system/VmDetect.aspx

Answer 3

La manera más fácil que he encontrado para averiguar si mi C# aplicación se está ejecutando en una máquina virtual de VMware o no es comprobar la dirección MAC de la tarjeta (s) de la NIC. Si se trata de una máquina virtual de VMware siempre sería: 00: 50: 56: XX: YY: ZZ

Es posible enumerar las NIC as resolved here.

Answer 4

Jay Abuzi mostró la solución en PowerShell. Aquí es lo mismo que aC# función:

/// <summary> 
    /// Detect if this OS runs in a virtual machine 
    /// 
    /// http://blogs.msdn.com/b/virtual_pc_guy/archive/2005/10/27/484479.aspx 
    /// 
    /// Microsoft themselves say you can see that by looking at the motherboard via wmi 
    /// </summary> 
    /// <returns>false</returns> if it runs on a fysical machine 
    public bool DetectVirtualMachine() 
    { 
     bool result = false; 
     const string MICROSOFTCORPORATION ="microsoft corporation"; 
     try 
     { 
      ManagementObjectSearcher searcher = 
       new ManagementObjectSearcher("root\\CIMV2","SELECT * FROM Win32_BaseBoard"); 

      foreach (ManagementObject queryObj in searcher.Get()) 
      { 
       result = queryObj["Manufacturer"].ToString().ToLower() == MICROSOFTCORPORATION.ToLower(); 
      } 
      return result; 
     } 
     catch (ManagementException ex) 
     { 
      return result; 
     } 
    } 

Answer 5

Esto es lo que yo uso:

using (var searcher = new System.Management.ManagementObjectSearcher("Select * from Win32_ComputerSystem")) 
{ 
    using (var items = searcher.Get()) 
    { 
    foreach (var item in items) 
    { 
     string manufacturer = item["Manufacturer"].ToString().ToLower(); 
     if ((manufacturer == "microsoft corporation" && item["Model"].ToString().ToUpperInvariant().Contains("VIRTUAL")) 
      || manufacturer.Contains("vmware") 
      || item["Model"].ToString() == "VirtualBox") 
     { 
     return true; 
     } 
    } 
    } 
} 
return false; 

Edición 02/12/2014: Código actualizada de forma que ya no se detecta una superficie Pro Microsoft como Av M. Gracias a Erik Funkenbusch por señalar esto.

Modificar 2017-06-29: Código actualizado para que también compruebe el valor de la propiedad HypervisorPresent.

Editar 2018-02-05: eliminado comprobar para la propiedad HypervisorPresent ya que es incorrecto. Esta propiedad podría volverse verdadera si se ejecuta en las O/S del host en un servidor hyper-V.

Answer 6

public static bool isVirtualMachine() 
{ 
    const string MICROSOFTCORPORATION = "microsoft corporation"; 
    const string VMWARE = "vmware"; 

    foreach (var item in new ManagementObjectSearcher("Select * from Win32_ComputerSystem").Get()) 
    { 
     string manufacturer = item["Manufacturer"].ToString().ToLower(); 
     // Check the Manufacturer (eg: vmware, inc) 
     if (manufacturer.Contains(MICROSOFTCORPORATION) || manufacturer.Contains(VMWARE)) 
     { 
      return true; 
     } 

     // Also, check the model (eg: VMware Virtual Platform) 
     if (item["Model"] != null) 
     { 
      string model = item["Model"].ToString().ToLower(); 
      if (model.Contains(MICROSOFTCORPORATION) || model.Contains(VMWARE)) 
      { 
       return true; 
      } 
     } 
    } 
    return false; 
} 

Answer 7

Para pruebas de nivel inferior, recomiendo mirar ScoopyNG [1]. Es una colección de conocidos métodos de detección de vM de bajo nivel y que funcionan bien, aunque están un poco anticuados.

Si realmente desea confiar en otras cosas, como las herramientas instaladas (VM * Additions), estas son mucho más fáciles de "falsificar".

Esta publicación de blog [2] también tiene una visión general bastante buena, desde cosas de bajo nivel asm, buscando archivos DLL específicos, rutas de archivos y claves de registro para verificar.

[1] http://trapkit.de/research/vmm/scoopyng/index.html

[2] http://securitykitten.github.io/vm-checking-and-detecting/

Answer 8

Esta función C detectará VM SO Huésped: (probado en Windows, compilado con Visual Studio)

#include <intrin.h> 

    bool isGuestOSVM() 
    { 
     unsigned int cpuInfo[4]; 
     __cpuid((int*)cpuInfo,1); 
     return ((cpuInfo[2] >> 31) & 1) == 1; 
    } 

Answer 9

este código C++ detectará productos de VMware tales como express, esx, fusión o estación de trabajo

// VMWareDetector.cpp : Defines the entry point for the console application. 
// 

#include "stdafx.h" 
#include "windows.h" 
#include <conio.h> 
void CheckVM(void); 
int main() 
{ 
    CheckVM(); 
    _getch(); 
    return 0; 
} 

void CheckVM(void) 
{ 
    unsigned int a, b; 

    __try { 
     __asm { 

      // save register values on the stack 
      push eax 
      push ebx 
      push ecx 
      push edx 

      // perform fingerprint 
      mov eax, 'VMXh' // VMware magic value (0x564D5868) 
      mov ecx, 0Ah // special version cmd (0x0a) 
      mov dx, 'VX' // special VMware I/O port (0x5658) 

      in eax, dx // special I/O cmd 

      mov a, ebx // data 
      mov b, ecx // data (eax gets also modified 
         // but will not be evaluated) 

         // restore register values from the stack 
         pop edx 
         pop ecx 
         pop ebx 
         pop eax 
     } 
    } 
    __except (EXCEPTION_EXECUTE_HANDLER) {} 
    printf("\n[+] Debug : [ a=%x ; b=%d ]\n\n", a, b); 
    if (a == 'VMXh') { // is the value equal to the VMware magic value? 
     printf("Result : VMware detected\nVersion : "); 
     if (b == 1) 
      printf("Express\n\n"); 
     else if (b == 2) 
      printf("ESX\n\n"); 
     else if (b == 3) 
      printf("GSX\n\n"); 
     else if (b == 4) 
      printf("Workstation\n\n"); 
     else 
      printf("unknown version\n\n"); 
    } 
    else 
     printf("Result : Not Detected\n\n"); 
}