AppContainer para aplicativos herdados

O ambiente AppContainer é um ambiente de execução de processo restritivo que pode ser usado para aplicativos herdados para fornecer segurança de recursos. O processo de um aplicativo AppContainer e seus processos filho são executados dentro de um contêiner de aplicativo leve, onde podem acessar apenas os recursos que são concedidos especificamente 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 mal-intencionadas fora dos recursos atribuídos limitados.

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

Aplicativos empacotados

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

Aplicativos não empacotados

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 do AppContainer (ou perfil). 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 implantação chama determinadas APIs Win32 para você a fim de criar o perfil do AppContainer necessário (por exemplo, CreateAppContainerProfile). E quando você cancela o registro de um pacote para um usuário, a pilha 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 Win32 por conta própria; mas pode ser complicado.

A maioria dos aplicativos não empacotados que usavam o nível inferior integramente agora usa o AppContainer como uma maneira melhor de fornecer um ambiente de execução restrita.

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

Benefícios de usar um ambiente AppContainer

Uma das principais metas do ambiente AppContainer é separar o estado do aplicativo do estado do sistema o máximo possível, mantendo a compatibilidade com outros aplicativos. O Windows faz isso detectando e redirecionando determinadas alterações feitas ao sistema de arquivos e ao registro em runtime (conhecido como virtualizando). Um aplicativo AppContainer grava em seu próprio registro virtual e na 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 virtuais de um aplicativo AppContainer.

Portanto, o ambiente AppContainer fornece área restrita segura de aplicativos. Isolando o aplicativo de acessar hardware, arquivos, registro, outros aplicativos, conectividade de rede e recursos de rede sem permissão específica. 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 representa o usuário para obter acesso a outros recursos.

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

Em um projeto C# ou C++, você pode usar o exemplo de código apropriado 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 não for 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 wil (Bibliotecas de Implementação do Windows) do). Uma maneira conveniente de instalar o WIL é acessar o Visual Studio, clicar em Projeto>Gerenciar Pacotes NuGet...>Procurar, digitar ou colar Microsoft.Windows.ImplementationLibrary na caixa de pesquisa, selecionar o item nos resultados da pesquisa e, em seguida, clicar 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 seção

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