AppContainer para aplicativos herdados

O ambiente AppContainer é um ambiente de execução de processo restritivo que pode ser usado para aplicativos herdados a fim de fornecer segurança de recursos. O processo de um aplicativo AppContainer e seus processos filhos são executados dentro de um contêiner de aplicativo leve, onde eles podem acessar apenas os recursos que são especificamente concedidos a eles. E eles são isolados usando o sistema de arquivos e a virtualização do registro. Como resultado, os aplicativos implementados em um AppContainer não podem ser hackeados para permitir ações maliciosas fora dos recursos atribuídos limitados.

Para aplicativos empacotados e não empacotados, o AppContainer representa uma boa prática de engenharia segura.

Aplicativos empacotados

Você pode pegar um aplicativo empacotado usando o MSIX e configurá-lo facilmente para ser executado no ambiente AppContainer. Os aplicativos da Plataforma Universal do Windows (UWP) são automaticamente aplicativos AppContainer. Mas você também pode configurar seu aplicativo de área de trabalho empacotado com MSIX para ser um aplicativo AppContainer. É particularmente fácil usar o AppContainer se você empacotar usando MSIX. Para obter mais informações, cenários e exemplos de configuração, consulte aplicativos MSIX AppContainer.

Aplicações não embaladas

Um aplicativo não empacotado também pode ser executado em um contêiner de aplicativo. Para criar um processo em um contêiner de aplicativo, você precisa de uma definição (ou perfil) do AppContainer. E é por isso que usar o AppContainer com um aplicativo empacotado é mais fácil. Quando você registra um pacote para um usuário, a pilha de implantação chama determinadas APIs do Win32 para criar o perfil AppContainer necessário (por exemplo, CreateAppContainerProfile). E quando você cancela o registro de um pacote para um usuário, a pilha de implantação faz o trabalho para remover o perfil AppContainer (DeleteAppContainerProfile). Se você não estiver empacotando seu aplicativo, precisará fazer as mesmas coisas chamando essas APIs do Win32 você mesmo; mas pode ser complicado.

A maioria dos aplicativos não empacotados que usavam o nível baixo de integração agora usam o AppContainer como uma maneira melhor de fornecer um ambiente de execução restrito.

Quando um processo não empacotado em execução em um contêiner de aplicativo chama CreateProcess, o processo filho normalmente herda o token pai. Esse token inclui o nível de integridade (IL) e as informações do contêiner do aplicativo. É melhor não pensar em um único eixo com os valores elevado/médio/baixo/appContainer nele. Em vez disso, estar ou não estar em um contêiner de aplicativo é uma segunda propriedade ortogonal. Dito isso, se você está em um contêiner de aplicativo, o nível de integridade (IL) é sempre baixo.

Benefícios de usar um ambiente AppContainer

Um objetivo principal do ambiente AppContainer é separar o estado do aplicativo do estado do sistema tanto quanto possível, mantendo a compatibilidade com outros aplicativos. O Windows faz isso detetando e redirecionando certas alterações que faz no sistema de arquivos e no registro em tempo de execução (conhecido como virtualização). Um aplicativo AppContainer grava em seu próprio registro virtual e pasta de dados do aplicativo, e esses dados são excluídos quando o aplicativo é desinstalado ou redefinido. Outros aplicativos não têm acesso ao registro virtual ou ao sistema de arquivos virtual de um aplicativo AppContainer.

Portanto, o ambiente AppContainer fornece sandboxing seguro de aplicativos. Isolar o aplicativo do acesso a hardware, arquivos, registro, outros aplicativos, conectividade de rede e recursos de rede sem permissão específica. Os recursos individuais podem ser direcionados sem expor outros recursos. Além disso, a identidade do usuário é protegida usando uma identidade exclusiva que é uma concatenação do usuário e do aplicativo; e os recursos são concedidos usando um modelo de privilégios mínimos. Isso protege ainda mais contra um aplicativo que se faz passar pelo usuário para obter acesso a outros recursos.

Exemplo de código a ser testado para execução em um contêiner de aplicativo

Em um projeto C# ou C++, você pode usar um dos exemplos de código abaixo para determinar se um processo está ou não em execução dentro de um contêiner de aplicativo. Para cada exemplo, após a execução do código, se o valor de isAppContainer for diferente de zero (ou true), o processo será executado dentro de um contêiner de aplicativo.

C# (P/Invoke)

[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr GetCurrentProcess();

[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool OpenProcessToken(
    IntPtr ProcessHandle,
    UInt32 DesiredAccess,
    out IntPtr TokenHandle);

[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool GetTokenInformation(
    IntPtr TokenHandle,
    uint TokenInformationClass,
    out uint TokenInformation,
    uint TokenInformationLength,
    out uint ReturnLength);

UInt32 TOKEN_QUERY = 0x0008;
IntPtr tokenHandle;

if (!OpenProcessToken(
    GetCurrentProcess(),
    TOKEN_QUERY,
    out tokenHandle))
{
    // Handle the error.
}

uint isAppContainer;
uint TokenIsAppContainer = 29;
uint tokenInformationLength = sizeof(uint);

if (!GetTokenInformation(
    tokenHandle,
    TokenIsAppContainer,
    out isAppContainer,
    tokenInformationLength,
    out tokenInformationLength))
{
    // Handle the error.
}

C++ (WIL)

Este exemplo usa o Windows Implementation Libraries (WIL)). Uma maneira conveniente de instalar o WIL é ir para o Visual Studio, clicar em Project>Gerenciar pacotes NuGet...>Procurar, digite ou cole Microsoft.Windows.ImplementationLibrary na caixa de pesquisa, selecione o item nos resultados da pesquisa e clique em Instalar para instalar o pacote para esse projeto.

#include <wil\token_helpers.h>
...
bool isAppContainer = wil::get_token_is_app_container();

As funções wil::get_token_is_app_container_nothrow e wil::get_token_is_app_container_failfast oferecem estratégias alternativas de tratamento de erros. Consulte wil\token_helpers.h para obter mais informações.

C++ (canônico)

#include <windows.h>
...
HANDLE tokenHandle{};
DWORD isAppContainer{};
DWORD tokenInformationLength{ sizeof(DWORD) };

if (!::OpenProcessToken(
    GetCurrentProcess(),
    TOKEN_QUERY,
    &tokenHandle))
{
    // Handle the error.
}

if (!::GetTokenInformation(
    tokenHandle,
    TOKEN_INFORMATION_CLASS::TokenIsAppContainer,
    &isAppContainer,
    tokenInformationLength,
    &tokenInformationLength
))
{
    // Handle the error.
}

Nesta secção

Para obter mais informações sobre como usar o AppContainer para aplicativos herdados, consulte os tópicos a seguir.