Configuração de VM segura

Crafting a secure gaming environment

I’m setting up a VM for cloud gaming, ensuring it only runs a single game and preventing jailbreaks. This involves locking down the VM and securing it from malware and unauthorized access.

Thought about configuração de VM para cloud gaming por dois segundos

A configuração de uma VM para cloud gaming (similar ao GeForce Now) exige um ambiente Windows bem protegido, de modo que o usuário final só tenha acesso ao jogo selecionado, sem conseguir “fugir” ou “desbloquear” (fazer jailbreak) a sessão. Abaixo seguem algumas recomendações e passos que podem ajudar nesse processo.

1. Criar um usuário limitado no Windows

1. Crie um novo usuário sem privilégios de administrador:

   • Abra o Gerenciador de Computador (Win + X > Gerenciamento do computador) ou use o Painel de Controle para adicionar um usuário.
   • Dê um nome apropriado, por exemplo, “Jogador”.
   • Configure a conta como Padrão (não administrador).

2. Proteja a conta de administrador:

   • Defina uma senha forte para o usuário administrador.
   • Desative o login automático.
   • Ative a exigência de senha na inicialização ou uso de áreas sensíveis.

Isso garante que, se alguém “sair” do ambiente de jogo, não consiga fazer alterações no sistema sem a senha do administrador.

2. Bloquear acesso ao sistema (Shell) usando Kiosk Mode ou Assigned Access

No Windows 10/11 (Pro ou Enterprise), existe o recurso de Assigned Access (também conhecido como Kiosk Mode). Ele é bastante útil para restringir o acesso a apenas um aplicativo em tela cheia.

1. Defina o aplicativo que será executado

   • O Assigned Access funciona melhor com aplicativos UWP (da Microsoft Store).
   • Se seu jogo for via Steam, Epic ou outro launcher, é possível tentar soluções de terceiros ou automações para iniciar a aplicação diretamente. No entanto, o Kiosk Mode “nativo” não funciona com aplicativos Win32 de forma oficial, então você pode precisar de configurações adicionais.

2. Habilite o Kiosk Mode (Assigned Access)

   • Vá em Configurações > Contas > Família e outros usuários (ou Acesso atribuído).
   • Selecione Configurar acesso atribuído.
   • Escolha o usuário que você criou para o Kiosk.
   • Escolha o app que rodará em tela cheia.

Se o seu jogo não for UWP, existem duas alternativas principais:

• Ferramentas de terceiros que bloqueiam o shell do Windows e lançam diretamente um app Win32.
• Customização via políticas de grupo (GPO) e scripts de logon para iniciar o jogo e impedir acesso ao Explorer.

3. Utilizar Políticas de Grupo (GPO) para lockdown

Se você tiver acesso a um Windows Pro ou Enterprise, pode usar o Editor de Políticas de Grupo Locais (gpedit.msc) para bloquear funcionalidades do Windows para o usuário “Jogador”. Por exemplo:

1. Remover acesso ao Painel de Controle e configurações

   • Em gpedit.msc, vá em Configurações de Usuário > Modelos Administrativos > Painel de Controle.
   • Habilite a política Proibir acesso ao Painel de Controle e Configurações.

2. Bloquear acesso ao Registro

   • Em Configurações de Usuário > Modelos Administrativos > Sistema.
   • Ative Impedir acesso às ferramentas de edição do Registro.

3. Esconder/Desativar unidades e Explorer

   • Em Configurações de Usuário > Modelos Administrativos > Componentes do Windows > Explorer de Arquivos.
   • Use Ocultar essas unidades especificadas no Meu Computador (embora seja um truque “limitado”, pois usuários avançados podem contornar se tiverem privilégios; mas ajuda a esconder).

4. Desativar o Gerenciador de Tarefas

   • Em Configurações de Usuário > Modelos Administrativos > Sistema > Ctrl+Alt+Del Opções.
   • Habilite Remover Gerenciador de Tarefas.

Estas políticas ajudarão a evitar que o jogador acesse configurações e ferramentas que possam permitir “desbloquear” o sistema ou matar processos essenciais.

4. Usar Applocker ou Software Restriction Policies

O Applocker (disponível no Windows Enterprise e Education, e em algumas versões Pro com limitações) é excelente para definir regras de quais aplicativos podem ser executados. Assim, você permite só o executável do jogo e componentes do Windows realmente necessários.

1. Ative o Applocker

   • Abra gpedit.msc e vá em Configurações de Computador > Políticas > Configurações do Windows > Configurações de Segurança > Políticas de Controle de Aplicativos > AppLocker.
   • Configure Executáveis, Scripts, Instaladores e Pacotes de aplicativos.

2. Crie regras do tipo Allow apenas para:

   • Executável do jogo.
   • Servidores/serviços do Windows que o jogo dependa.
   • Qualquer Launcher (Steam/Epic/Origin etc.) se for o caso, mas de preferência somente o executável final do jogo.

3. Crie uma regra Default Deny para todo o restante.

   • Assim, qualquer coisa que não estiver explicitamente permitida será bloqueada.

Isso é uma camada bem poderosa para evitar que o usuário rode programas externos, abra cmd.exe, powershell.exe, etc.

5. Executar o jogo no startup e ocultar o ambiente

Para que a experiência seja mais fluida e sem distrações para o usuário, você pode fazer o Windows iniciar diretamente no jogo (ou no launcher) quando o usuário “Jogador” faz login.

1. Criar script de logon

   • Abra gpedit.msc ou use o Painel de Controle > Ferramentas administrativas > Políticas de grupo (dependendo da versão)
   • Em Configurações de Usuário > Scripts (Logon/Logoff), adicione um script (.bat ou .cmd) que inicie o seu jogo.

2. Desativar a Barra de Tarefas (ou ocultar automaticamente)

   • Em Configurações de Usuário > Modelos Administrativos > Menu Iniciar e Barra de Tarefas é possível esconder ou limitar o acesso à Barra de Tarefas.

3. Remover o Explorer como shell (opcional/avançado)

   • Em Configurações de Usuário > Políticas > Sistema, altere o Shell padrão para apontar diretamente para o executável do jogo, em vez do explorer.exe.
   • Essa parte precisa de testes, porque se o jogo fechar, o usuário pode ficar em uma tela sem nada. Muitas vezes é mais simples utilizar o Assigned Access ou uma GPO para travar o sistema e iniciar o jogo.

6. Proteções adicionais

1. Desabilitar teclas especiais

   • Se o seu teclado de acesso remoto tiver atalhos, tente desabilitar combinações como Ctrl + Alt + Del, Alt + F4, Windows + R, etc. No caso de VMs e Remote Desktop, algumas dessas combinações podem não passar diretamente para o guest, mas é bom reforçar a segurança.
   • No gpedit, existem opções para Remover o botão de Desligar e de Reiniciar do Ctrl+Alt+Del, bem como Desativar Gerenciador de Tarefas.

2. Firewall e Proteção em tempo real

   • Assegure-se de manter o Windows Defender (ou outro antivírus confiável) rodando.
   • Bloqueie portas que não são necessárias para o jogo, mantendo apenas as essenciais abertas.
   • Atualize o Windows e drivers periodicamente.

3. Snapshots / Imagens de backup

   • Faça snapshots regulares da VM. Se alguém conseguir burlar alguma restrição, você restaura o snapshot em poucos minutos, voltando à configuração original.

7. Considerações finais e fluxo de uso

• Usuário administrador: somente você (dono do sistema) terá acesso à conta de administrador, com privilégios para instalar drivers, jogos, etc.
• Usuário jogador: esse usuário (conta padrão, sem privilégios) só consegue entrar na VM para jogar.
• Modo Kiosk (ou Assigned Access): é a forma mais “nativa” de travar em um único app, mas requer que o jogo seja compatível ou que você tenha um wrapper UWP. Caso contrário, GPO + Applocker + scripts de logon são a alternativa para lock down.
• Monitoramento: dependendo do nível de profissionalização do seu serviço, você pode usar soluções de monitoramento remoto que avisam se o usuário tentar algo fora do padrão.

Com essas medidas, o seu ambiente Windows na VM ficará bem mais fechado. Haverá apenas o acesso ao jogo, sem que o usuário possa navegar no sistema operacional, instalar coisas ou fazer jailbreak. É essencial testar o fluxo do zero, criando a conta “Jogador” e se colocando no lugar do usuário final, tentando “escapar” do ambiente de jogo, para garantir que as políticas realmente estejam funcionando como desejado.

Mapping the solution

Building a C++ program that serves as a watchdog, keeping a user within a specific game and blocking any unauthorized processes. This involves continuous monitoring and potential termination or logging out of the user for any breaches.

Thought about C++ program for monitoring por alguns segundos

Abaixo está um exemplo de um programa em C++ que, de forma simplificada, roda em loop infinito (24/7) e verifica se existem processos não permitidos em execução. Caso algum processo “não autorizado” seja encontrado, ele encerra esse processo imediatamente.

Atenção: Este é apenas um exemplo didático para ilustrar como monitorar processos. Em produção, você deve considerar:

1. Segurança de execução: o programa precisa de privilégios (possivelmente de administrador) para matar processos de outros usuários.
2. Estabilidade: rodar em loop infinito pode impactar o desempenho. Normalmente se implementa alguma forma de espera ou timer (e.g. sleep de alguns segundos) para evitar sobrecarregar a CPU.
3. Mecanismos avançados: como Applocker, Assigned Access (Kiosk) e GPO, que podem oferecer soluções mais robustas que “ficar matando processos”.
4. Lista branca/negra de processos: é preciso manter uma lista atualizada dos executáveis permitidos/negados.

Exemplo de Código (Windows)

Este exemplo:

• Mantém uma lista de processos permitidos (whitelist).
• Fica em loop monitorando os processos em execução.
• Se achar algum que não esteja na lista de permitidos, o programa fecha esse processo.

Compile com Visual Studio ou outro compilador compatível com Windows API.

#include <Windows.h>
#include <TlHelp32.h>
#include <iostream>
#include <vector>
#include <string>
#include <thread>
#include <chrono>

// Função para obter a lista dos processos em execução
std::vector<std::string> getRunningProcesses()
{
    std::vector<std::string> processList;

    // Cria um snapshot de todos os processos no sistema
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == INVALID_HANDLE_VALUE)
    {
        return processList;
    }

    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);

    // Inicializa a iteração
    if (!Process32First(hSnap, &pe32))
    {
        CloseHandle(hSnap);
        return processList;
    }

    do
    {
        // Converte o nome do processo (WCHAR) para std::string
        // Observação: pe32.szExeFile é wchar_t
        std::wstring ws(pe32.szExeFile);
        std::string processName(ws.begin(), ws.end());
        processList.push_back(processName);
    } while (Process32Next(hSnap, &pe32));

    CloseHandle(hSnap);
    return processList;
}

// Função para matar (encerrar) um processo pelo nome do executável
bool killProcessByName(const std::string &targetProcess)
{
    bool killed = false;
    
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);

    if (Process32First(hSnap, &pe32))
    {
        do
        {
            std::wstring ws(pe32.szExeFile);
            std::string processName(ws.begin(), ws.end());

            // Verifica se o processo atual é o que queremos matar
            if (_stricmp(processName.c_str(), targetProcess.c_str()) == 0)
            {
                // Abre o processo com permissão de encerrar
                HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, pe32.th32ProcessID);
                if (hProc)
                {
                    // Tenta encerrar o processo
                    if (TerminateProcess(hProc, 0))
                    {
                        std::cout << "[INFO] Processo '" << targetProcess 
                                  << "' (PID: " << pe32.th32ProcessID 
                                  << ") foi encerrado.\n";
                        killed = true;
                    }
                    CloseHandle(hProc);
                }
            }
        } while (Process32Next(hSnap, &pe32));
    }

    CloseHandle(hSnap);
    return killed;
}

int main()
{
    // --------------------------------------------------
    // Defina aqui a lista de processos "permitidos".
    // Você pode adicionar o nome do executável do jogo,
    // do launcher, do seu watchdog, etc.
    // --------------------------------------------------
    std::vector<std::string> whitelist = {
        "explorer.exe",   // pode ser necessário se estiver usando shell normal
        "Game.exe",       // substitua pelo executável do jogo
        "Steam.exe",      // se quiser permitir o Steam
        "WatchDog.exe"    // suponha que o nome do seu programa seja esse
    };

    // Exemplo: se quiser permitir "chrome.exe", acrescente:
    // "chrome.exe"

    std::cout << "WatchDog de processos iniciado!\n";

    // Loop infinito (24/7)
    while (true)
    {
        // Obtém lista de processos em execução
        std::vector<std::string> processes = getRunningProcesses();

        // Para cada processo em execução, verifica se está na whitelist.
        for (const auto &p : processes)
        {
            bool isAllowed = false;
            for (const auto &allowed : whitelist)
            {
                if (_stricmp(p.c_str(), allowed.c_str()) == 0)
                {
                    isAllowed = true;
                    break;
                }
            }

            // Se não estiver na whitelist, mata o processo
            if (!isAllowed)
            {
                // Evitar matar o próprio WatchDog se não estiver na lista
                // (depende da sua lógica)
                // Nesse exemplo, se o WatchDog.exe não está na whitelist,
                // você acabaria matando o próprio programa - cuidado!
                killProcessByName(p);
            }
        }

        // Aguardar alguns segundos para não sobrecarregar a CPU
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }

    return 0;
}

Como funciona:

1. getRunningProcesses()

   • Usa CreateToolhelp32Snapshot e Process32First/Process32Next para obter a lista de processos em execução.
   • Converte pe32.szExeFile (wchar_t) para std::string.

2. killProcessByName()

   • Cria novamente um snapshot dos processos, localiza o processo desejado comparando nomes.
   • Abre o processo com OpenProcess(PROCESS_TERMINATE, ...) e o encerra com TerminateProcess(...).
   • Necessita de privilégios apropriados para funcionar (geralmente executado como Administrador).

3. Loop Infinito

   • A cada iteração, obtém a lista de processos, verifica quais estão fora da whitelist e mata esses processos.
   • Usa um sleep_for de 2 segundos para não rodar em busy loop e consumir 100% da CPU.

Observações Importantes

• Nomes de executáveis: Se o jogo tiver várias instâncias ou processos auxiliares, você precisará ajustar a whitelist.
• Caminho e integridade: Se houver risco de renomearem processos, você pode reforçar checando a assinatura digital ou hash do executável. A simples checagem de nome é relativamente frágil.
• Permissões de Administrador: Para matar processos de outros usuários, provavelmente será necessário executar este programa com privilégios de administrador ou como um serviço do Windows.
• Completar com GPO / Kiosk / Applocker: Este watchdog é uma camada extra. Para evitar “jailbreaks” de verdade, combine com os recursos nativos do Windows (Assigned Access, Applocker, etc.).
• Múltiplos usuários: Se o usuário atual não tiver permissão, mesmo esse programa não conseguirá encerrar processos do sistema ou de outros usuários.

Com esse “modelo de watchdog” você consegue monitorar 24/7 os processos em execução na sua VM e encerrar automaticamente qualquer um que não esteja na lista de permitidos. Entretanto, reforçar a segurança por meio de políticas de grupo, Applocker e Kiosk Mode costuma ser bem mais robusto do que simplesmente matar processos em loop.