Configuração de VM segura

创建于：2025年1月1日

问题

Olá, me ajude a configurar uma VM pro meu serviço de cloud gaming tipo GFN, eu já baixei o Windows nela e todos os drivers, só preciso de proteções para evitar jailbreaks e que pessoas joguem apenas o jogo que foi selecionado

思考

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

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).
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.

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.
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:

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.
Bloquear acesso ao Registro
- Em Configurações de Usuário > Modelos Administrativos > Sistema.
- Ative Impedir acesso às ferramentas de edição do Registro.
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).
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.

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.
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.
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.

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.
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.
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

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.
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.
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.

问题

Crie um programa em C++ qie fique verificando isso 24/7

思考

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:

Segurança de execução: o programa precisa de privilégios (possivelmente de administrador) para matar processos de outros usuários.

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.

Mecanismos avançados: como Applocker, Assigned Access (Kiosk) e GPO, que podem oferecer soluções mais robustas que “ficar matando processos”.

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:

getRunningProcesses()
- Usa CreateToolhelp32Snapshot e Process32First/Process32Next para obter a lista de processos em execução.
- Converte pe32.szExeFile (wchar_t) para std::string.
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).
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.

问题

思考

回答