Como identificar que você está executando em uma máquina virtual?

https://stackoverflow.com/questions/39533

virtualization

09-06-2019
|

Pergunta

Existe uma maneira de identificar, a partir de dentro de uma VM, que o seu código está sendo executado dentro de uma VM?

Eu acho que há mais ou menos fácil maneiras de identificar VM específica de sistemas, especialmente se a máquina virtual tem o provedor de extensões instaladas (como o VirtualBox ou VMWare).Mas existe uma maneira geral, para identificar que você não está executando diretamente na CPU?

Solução

Muita da investigação sobre este é dedicado a detecção de chamada "pílula azul" ataques, isto é, um mal-intencionado do hipervisor que está ativamente tentando evitar a detecção.

O clássico truque para detectar uma VM é preencher o ITLB, executar uma instrução que deve ser virtualizado (que necessariamente limpa tais estado do processador quando ele dá o controle para o hypervisor) e, em seguida, executar mais algum código para detectar se o ITLB ainda está preenchido.O primeiro papel em que está localizado aqui, e um colorido, ao invés de explicação a partir de uma pesquisador do blog e alternativa. Wayback Machine link para o artigo do blog (imagens quebradas).

Linha de fundo dos debates sobre isso é que há sempre uma maneira de detectar um mal-intencionado do hipervisor, e é muito mais simples para detectar um que não está tentando esconder.

Outras dicas

A Red Hat tem um programa que detecta quais (se houver) do produto de virtualização é que está a ser executada: virt-what.

Usando um terceiro mantida ferramenta, é que essa é a melhor estratégia a longo prazo, do que tentar construir sua própria lógica de detecção:mais olhos (testar mais produtos de virtualização), etc.

Mais abordagem empírica é verificar conhecido VM drivers de dispositivo.Você poderia escrever consultas WMI para localizar, por exemplo, o VMware adaptador de vídeo, unidade de disco, placa de rede, etc.Isso seria adequado se você sabia que você só tinha de se preocupar conhecido VM tipos de host em seu ambiente.Aqui um exemplo de como fazer isso em Perl, o que poderia ser portado para o idioma de sua escolha.

Depende do que você está depois:

Se a VM não está escondendo de você no fim, você pode usar alguns conhecidos de gancho.Como olhar para o VmWare controladores ou a presença de certas seqüências de caracteres em memória ou em outros rabiscos.
Se a VM está realmente querendo você para fazer coisas especiais para ele, vai ter algumas óbvio gancho no lugar, como modificar o ID do processador, ou adicionar alguns registros especiais que você pode acessar para detectá-lo.Ou o s de um dispositivo especial, em um local conhecido na memória (presumindo que você pode obter acesso raw ao espaço físico de memória do seu mundo).Observe que a moderna máquina de projetos como o IBM Power6 e Sun UltraSparc T1/T2 são projetados para SEMPRE execute um hypervisor, e nunca diretamente sobre matérias de hardware.A interface para o "hardware" que OS usa é, na verdade, a interface at um hipervisor camada de software, com nenhuma forma de contorná-lo.Neste caso, a detecção é trivial, pois é uma constante "sim".Essa é a provável futura direção para todos os sistemas de computador que podem arcar com os custos indiretos, olhar para o apoio nos últimos projetos como o Freescale QorIQ P4080 chip, por exemplo (www.freescale.com/qoriq).
Se a VM é intencionalmente tentando esconder, e você está perseguindo a sua presença, é um jogo de gato-e-rato, onde o tempo, a perturbação e o diferente perfil de desempenho de uma VM é quase sempre vai dar o fora.Obviamente, isso depende de como o VM é implementado e o quanto de suporte de hardware não está no lugar em arquitetura (eu acho que um zSeries mainframe é muito melhor em esconder a presença de uma VM ou uma pilha de VMs em particular OS que uma máquina x86, por exemplo).Ver http://jakob.engbloms.se/archives/97 para alguns discussão sobre este tema.É possível tentar esconder como um VM, mas a detecção é bastante provável para ganhar sempre se esforça o suficiente.

Uma vez eu corri em toda uma assembléia trecho de código que disse que se você estivesse em uma VM....Eu pesquisei, mas não consegui encontrar o artigo original.

Eu achei esse que: Detectar se o programa é executado dentro de uma Máquina Virtual.

Espero que ajude.

Na maioria dos casos, você não deve tentar.Você não se importa se alguém está a executar o seu código em uma VM, exceto em poucos casos específicos.

Se você precisa de, no Linux a forma mais comum é a de olhar /sys/devices/virtual/dmi/id/product_name, que lista o nome do computador portátil/mainboard na maioria dos sistemas reais, e o hipervisor na maioria dos sistemas virtuais. dmidecode | grep Product é outro método comum, mas eu acho que requer acesso de root.

Aqui é um (java + windows) solução para identificar se subjacente máquina física ou virtual.

Máquinas Virtuais Exemplos:

Fabricante

Xen
A Microsoft Corporation
innotek GmbH
A Red Hat
A VMware, Inc.

Modelo

HVM domU
Máquina Virtual
VirtualBox
KVM

Plataforma Virtual VMware

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public abstract class OSUtil {

public static final List<String> readCmdOutput(String command) {
    List<String> result = new ArrayList<>();

    try {
        Process p=Runtime.getRuntime().exec("cmd /c " + command);
        p.waitFor();
        BufferedReader reader=new BufferedReader(
                new InputStreamReader(p.getInputStream())
                );
        String line;
        while((line = reader.readLine()) != null) {
            if(line != null && !line.trim().isEmpty()) {
                result.add(line);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    return result;
}

public static final String readCmdOutput(String command, int lineNumber) {
    List<String> result = readCmdOutput(command);
    if(result.size() < lineNumber) {
        return null;
    }

    return result.get(lineNumber - 1);
}

public static final String getBiosSerial() {
    return readCmdOutput("WMIC BIOS GET SERIALNUMBER", 2);
}

public static final String getHardwareModel() {
    return readCmdOutput("WMIC COMPUTERSYSTEM GET MODEL", 2);
}

public static final String getHardwareManufacturer() {
    return readCmdOutput("WMIC COMPUTERSYSTEM GET MANUFACTURER", 2);
}

public static void main(String[] args) {
    System.out.println("BIOS Serial: " + getBiosSerial());
    System.out.println("Hardware Model: " + getHardwareModel());
    System.out.println("Hardware Manufacturer: " + getHardwareManufacturer());
}
}

Você pode usar a saída para decidir se ele é uma máquina virtual ou uma máquina física:

Máquina física de saída:

De Série do BIOS:2HC3J12
Modelo De Hardware:Inspiron 7570
O Fabricante Do Hardware:A Dell Inc.

Máquina Virtual de saída:

De Série do BIOS:0
Modelo De Hardware:Innotec GmBH
O Fabricante Do Hardware:Caixa Virtual

Um bom exemplo é que, aparentemente, fazendo uma consulta do WMI para o fabricante da placa-mãe, e se ela retorna "Microsoft" você está em uma VM.Pensei que eu acredito que isso é apenas para o VMWare.É provável que existam diferentes maneiras de contar para cada host da VM de software.

Este artigo aqui http://blogs.technet.com/jhoward/archive/2005/07/26/407958.aspx tem algumas boas sugestões e links para uma série de maneiras de detectar se você está em uma máquina virtual (VMWare, VirtualPC, pelo menos).

Você pode ser capaz de identificar se você está em uma máquina virtual observando o endereço MAC da sua conexão de rede.Xen por exemplo normalmente recomenda a utilização de um intervalo específico de endereços 00:16:3e:xx:xx:xx.

Isso não é garantido, uma vez que é o administrador do sistema para especificar o endereço MAC do que eles gostam.

Em sistemas Linux, você pode tentar procurar por common arquivos em /proc.

Exemplo, a existente de /proc/vz/ dizer que você é um conjuntos de funcionalidades do OpenVZ.

Aqui está um guia completo para detectar VM environent no Linux sem ter que "tomar pílulas" :)

TrapKIT fornece ScoopyNG, uma ferramenta para o VMware identificação -- ele tenta contornar técnicas de evasão, mas não, necessariamente, destino qualquer software de virtualização de outros que o VMware.Fonte e binários estão disponíveis.

Se VM faz bem o trabalho, deve ser invisível para o cliente que ele está sendo virtualizado.No entanto, podemos olhar para outras pistas.

Eu imagino que a busca de drivers conhecidos ou software específico para o ambiente VM seria a melhor forma possível.

Por exemplo, em um VMWare cliente que executam o Windows, vmxnet.sys seria o driver de rede, apresentado como o VMware acelerado AMD PCNet Adaptador.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow