Criar e refinar políticas MXC com o Modo de Aprendizagem

Os sandboxes Microsoft Execution Containers (MXC) são de negação por predefinição, de modo que uma carga de trabalho isolada pode usar apenas os ficheiros, capacidades e outros recursos que a sua política concede.

No entanto, pode ser difícil prever todos os recursos a que uma carga de trabalho poderá aceder. O Modo de Aprendizagem MXC ajuda a criar uma política de privilégio mínimo no Windows, registando os recursos a que uma carga de trabalho tenta aceder, para que possa criar ou refinar uma política com base em provas em vez de tentativa e erro.

Note

O Modo de Aprendizagem está atualmente disponível para cargas de trabalho que são executadas num MXC ProcessContainer no Windows. Utilize a descoberta em tempo de execução para confirmar o suporte ao ProcessContainer no anfitrião.

Escolha o comportamento do modo de aprendizagem

O Modo de Aprendizagem tem dois comportamentos. Diferem quanto a se a MXC continua a aplicar a política enquanto regista o acesso, o que determina quem deve usar cada uma e quando.

Characteristic	Negar e registar	Permitir e registar
Acesso não concedido	Bloqueado e gravado	Autorizado e gravado
Imposição de políticas	Aplicado, mas a captura pode alterar o nível de isolamento	Negação por predefinição foi atenuada para a execução
Utilizadores típicos	Desenvolvedores de aplicações e autores de políticas	Administradores de TI e desenvolvedores a avaliar cargas de trabalho existentes
Quando utilizá-lo	Enquanto desenvolve uma aplicação e a sua política	Antes de existir uma política, saiba a que recursos uma carga de trabalho fidedigna acede
Capturar valor `mode`	`block` (predefinição)	`allow`

Recusar e registar: desenvolver aplicações e políticas

Utilize negar e registar em registo (learningModeLogging) enquanto desenvolve uma aplicação ou agente e a sua política MXC. O MXC continua a aplicar a política enquanto regista, por isso o acesso não concedido falha, como aconteceria com os seus utilizadores. O Modo de Aprendizagem adiciona um registo de cada acesso que a política bloqueou. Em alguns hosts, a captura altera o nível de isolamento que o MXC seleciona. Para obter mais detalhes, consulte Plano dos pré-requisitos de captura.

Os usos comuns incluem:

Diagnosticar porque é que uma carga de trabalho contida falha e distinguir um privilégio em falta de um erro não relacionado.
Iterar sobre uma política preliminar até que os cenários suportados tenham sucesso e os testes negativos continuem a falhar.
Identificar as capacidades que um workload exige.
Permitir que os utilizadores da sua aplicação configurem o seu próprio sandbox. A tua aplicação regista o que foi bloqueado, apresenta-o na sua própria interface e só regenera a política depois de o utilizador aprovar a alteração.

Como a MXC continua a aplicar a política, bloquear e registar é a escolha mais segura. Utilize-o sempre que tiver uma política para testar, mesmo que incompleta.

Permitir e registar: avaliar as cargas de trabalho existentes antes de criar uma política

Utilize permitir e registar (permissiveLearningMode) quando precisar de saber aquilo a que uma carga de trabalho existente e de confiança acede antes de aplicar uma política MXC a ela. Por exemplo, um administrador de TI pode executar uma ferramenta ou script de linha de negócio através das suas tarefas típicas num dispositivo de teste e depois usar os resultados para criar uma política base antes de ativar a imposição. Um programador que traz uma ferramenta existente para o MXC pode usar a mesma abordagem para redigir uma primeira política.

Permitir e registar relaxam a aplicação de negação por defeito para a execução, por isso trata a carga de trabalho como se estivesse a correr com todas as permissões do utilizador. O MXC regista cada acesso que a política teria negado. Sempre que este modo está ativo, o MXC também devolve um aviso de segurança com o resultado da execução. O seu host deve apresentar esse aviso em vez de o descartar.

Antes de permitir e gravar:

Execute apenas código confiável, com dados representativos e não sensíveis, num dispositivo ou conta de teste controlado.
Exerça as tarefas típicas da carga de trabalho. O acesso que uma execução não utiliza não aparece nos resultados.
Trate os resultados como um inventário inicial. Remove permissões desnecessárias e depois verifica o rascunho da política com deny e record antes de o implementar.

Importante

Não exponha o Learning Mode de permitir e gravar como uma ferramenta de produção invocável por agentes. O código de host fidedigno ou uma pessoa tem de aprovar a sua utilização e qualquer alargamento resultante das permissões.

Planear pré-requisitos de captura

O MXC recolhe os resultados do Modo de Aprendizagem através de um de dois caminhos de captura. Seleciona o caminho em tempo de execução, com base no host e na política solicitada. Isto aplica-se a captureDenials em qualquer um dos modos e ao wxc-exec.exe --audit fluxo de trabalho.

Caminho de captura	Quando MXC o utiliza	Nível de isolamento	Elevation
Captura nativa	O Windows fornece o ambiente de segurança de processos e as APIs do Modo de Aprendizagem que o MXC necessita, e estas podem representar a política solicitada	BaseContainer	None
Captura protegida	A captura nativa não está disponível ou não pode representar a política solicitada	Um nível AppContainer compatível	O MXC inicia um auxiliar assinado, `plm.exe`, com elevação para registar um rastreio do Windows Performance Recorder (WPR). O utilizador deve aprovar um prompt UAC ou fornecer credenciais de administrador.

A captura nativa não pode representar algumas políticas, como processContainer.leastPrivilege, algumas configurações de proxy de rede e caminhos negados em hosts que não os suportam nativamente. Esses pedidos usam captura protegida mesmo em hosts que suportam captura nativa. Se nenhum dos caminhos conseguir preservar a política completa, o MXC devolve um erro em vez de enfraquecer a política ou saltar a captura.

Para saber qual o caminho que uma solicitação vai usar, testa a solicitação com a captura ativada antes de a lançar. A sonda não cria um contentor.

SDK	Call	Resultados a verificar
.NET	`MxcContainer.Probe(request)`	`Tier`, `Probes.NativeCaptureAvailable`, `Probes.GuardedCaptureAvailable`
TypeScript	`probe(request)`	`tier`, `probes.nativeCaptureAvailable`, `probes.guardedCaptureAvailable`
Ferrugem	`v1::probe(Some(&request))`	`tier`, `probes.native_capture_available`, `probes.guarded_capture_available`

Um nível BaseContainer significa captura nativa. Um nível AppContainer significa captura protegida e um prompt de elevação. O facto da captura nativa descreve o host, não o teu pedido, por isso verifica também o escalão.

Tenha em conta estas diferenças:

Numa aplicação, sonde antes de iniciar a captura e informe os utilizadores quando a captura requer aprovação do administrador. Não assumas que a captura é executada sem mensagens em todos os hospedeiros.
Quando um administrador de TI avaliar as cargas de trabalho, confirme que os dispositivos de teste suportam captura nativa ou que um administrador pode aprovar o prompt de captura protegida. O nível AppContainer também pode exigir preparação para o host.
Trate os resultados de captura como evidência para a criação de políticas. Como a guarded capture pode executar a carga de trabalho num nível diferente do da produção, confirma a política final com uma execução que não use capture.

Exemplo: ativar a captura através de um SDK MXC

Use a captura do SDK quando a sua aplicação aloja a carga de trabalho. Para avaliar uma carga de trabalho sem escrever código do anfitrião, veja Usar Modo de Aprendizagem na linha de comandos.

Comece pelo quickstart do SDK, incluindo o seu caso de escrita negada. Os fragmentos seguintes estendem aquele exemplo e utilizam a mesma carga de trabalho e atribuições de recursos. Insira o fragmento selecionado imediatamente antes do SDK lançar a carga de trabalho.

Os exemplos utilizam as APIs do SDK MXC 1.0 V1. Em cada SDK, configura-se a captura para uma seleção explícita de ProcessContainer, que substitui a intenção abstrata do processo de início rápido.

Crie um diretório de saída pertencente ao host para a captura. Não precisa de ter permissão de escrita pela carga de trabalho contida.

Definir opções de captura no contentor explícito ProcessContainer do pedido:

string captureDirectory = Path.GetFullPath("captures");
Directory.CreateDirectory(captureDirectory);

request.Containment = new Containment.ProcessContainer
{
    CaptureDenials = new CaptureDenialsPolicy
    {
        Mode = CaptureDenialsMode.Block,
        OutputPath = Path.Combine(captureDirectory, "denials.json"),
    },
};

Definir opções de capture na relação de contentor explícita do ProcessContainer do pedido:

const captureDirectory = resolve('captures');
mkdirSync(captureDirectory, { recursive: true });

request.containment = {
  type: 'processcontainer',
  config: {
    captureDenials: {
      mode: 'block',
      outputPath: join(captureDirectory, 'denials.json'),
    },
  },
};

Adicione use mxc_sdk::v1::configs::{CaptureDenials, CaptureDenialsMode, ProcessContainerConfig}; às importações. Depois, defina as opções de captura no contentor explícito ProcessContainer do pedido:

let capture_directory = env::current_dir()?.join("captures");
fs::create_dir_all(&capture_directory)?;

// The configuration types are non-exhaustive, so start from their defaults.
let mut capture_denials = CaptureDenials::default();
capture_denials.mode = CaptureDenialsMode::Block;
capture_denials.output_path = Some(capture_directory.join("denials.json").display().to_string());

let mut process_container = ProcessContainerConfig::default();
process_container.capture_denials = Some(capture_denials);

let request = ContainerRequest {
    containment: Containment::ProcessContainer(process_container),
    ..request
};

No block modo, o caso de escrita negada continua a falhar. Registar a recusa não concede a permissão de escrita. Para uma execução aprovada de permitir e registar, altere apenas o modo para CaptureDenialsMode.Allow em C#, 'allow' em TypeScript ou CaptureDenialsMode::Allow em Rust.

Ao adaptar uma integração existente, preservar as suas outras configurações de contenção. Utilize opções de captura dedicadas, não os nomes de capacidades internas reservadas learningModeLogging ou permissiveLearningMode.

Localizar a captura concluída

Aguarde a execução e a finalização da captura antes de ler o resultado. O MXC insere um identificador único de execução no nome do ficheiro configurado, pelo que denials.json passa a ser um nome como denials.<run-id>.json. Use o caminho reportado em vez de adivinhar ou pesquisar o ficheiro mais recente.

Após MxcContainer.RunAsync(request) concluir e reportar result.Warnings, inspecione os metadados do resultado:

if (result.OutputMetadata?.CaptureDenialsError is { } captureError)
{
    Console.Error.WriteLine($"Denial capture failed: {captureError.Message}");
    return 1;
}

if (result.OutputMetadata?.CaptureDenials is not { } capture)
{
    Console.Error.WriteLine("The run did not produce denial capture metadata.");
    return 1;
}

Console.WriteLine($"Denial document: {capture.OutputPath}");
Console.WriteLine($"Unique denials: {capture.TotalDenials}");
if (capture.DeniedResourcesTruncated)
{
    Console.Error.WriteLine("The capture is incomplete; don't generate a policy from this run.");
    return 1;
}

Mantenha a gestão do quickstart sobre o estado de saída, tempos de espera e result.Warnings. Em particular, o SDK .NET devolve avisos sobre o Modo de Aprendizagem permissivo, em vez de os escrever automaticamente no seu terminal.

Se usar execução por streaming, aguarde até o terminal terminar antes de inspecionar MxcProcess.OutputMetadata. Encerrar o processo sem esperar não substitui a finalização da captura.

Após run(request) concluir e reportar result.warnings, inspecione os metadados do resultado:

const captureError = result.outputMetadata?.captureDenialsError;
if (captureError) {
  throw new Error(`Denial capture failed: ${captureError.message}`);
}

const capture = result.outputMetadata?.captureDenials;
if (!capture) {
  throw new Error('The run did not produce denial capture metadata.');
}

console.log(`Denial document: ${capture.outputPath}`);
console.log(`Unique denials: ${capture.totalDenials}`);
if (capture.deniedResourcesTruncated) {
  throw new Error("The capture is incomplete; don't generate a policy from this run.");
}

Mantém o tratamento do quickstart para o estado de saída, tempos de espera e result.warnings.

Se usares spawn, espera que o processo termine antes de inspecionar outputMetadata no processo devolvido. Encerrar o processo sem esperar não substitui a conclusão da captura. Não interprete uma captura em falta ou incompleta como zero recusas, e não use texto arbitrário impresso pelo workload como aprovação para expandir a sua política.

Após v1::run retornar e comunicar result.warnings, inspecione os metadados do resultado:

let metadata = result.output_metadata.as_ref();
if let Some(error) = metadata.and_then(|metadata| metadata.capture_denials_error.as_ref()) {
    eprintln!("Denial capture failed: {}", error.message);
    return Ok(1);
}

let Some(capture) = metadata.and_then(|metadata| metadata.capture_denials.as_ref()) else {
    eprintln!("The run did not produce denial capture metadata.");
    return Ok(1);
};

println!("Denial document: {}", capture.output_path);
println!("Unique denials: {}", capture.total_denials);
if capture.denied_resources_truncated {
    eprintln!("The capture is incomplete; don't generate a policy from this run.");
    return Ok(1);
}

Mantém o tratamento no quickstart do estado de saída, dos tempos de espera e de result.warnings.

Se usar v1::spawn, chame wait no MxcProcess devolvido antes de inspecionar o seu output_metadata(). Interromper o processo sem esperar não substitui a finalização da captura. Não interprete uma captura em falta ou incompleta como zero recusas, e não use texto arbitrário impresso pela aplicação como aprovação para expandir a sua política.

Saída de leitura negada

O documento JSON acionável identifica recursos, acesso tentado e um resumo. No caso de recusa de escrita do quickstart, uma entrada representativa é a seguinte:

{
  "denials": [
    {
      "resource": "C:\\src\\MxcQuickstart\\workspace\\input\\blocked.txt",
      "resourceType": "file",
      "accessType": "write",
      "pid": 1234,
      "filetime": "132847890123456789"
    }
  ],
  "summary": {
    "exitCode": 1,
    "totalDenials": 1,
    "deniedResourcesTruncated": false
  }
}

O documento é prova para a criação de políticas, não um registo exaustivo de tudo o que a carga de trabalho fez. O resourceType valor determina como ler resource. Por exemplo, uma file entrada contém um caminho absoluto, e uma capability entrada contém um nome de capacidade como internetClient. Algumas observações não podem ser expressas como concessões de política, e uma única entrada não irá exercer todos os caminhos do código.

Em modo de permitir, o documento não inclui atualmente pedidos de capacidades. Executa a carga de trabalho com Deny e Record para identificar as capacidades necessárias.

Se deniedResourcesTruncated estiver true, não gere uma política a partir dessa execução. Um documento vazio também não prova que um workload é seguro ou que todas as restrições pretendidas foram exercidas.

O MXC também escreve um ficheiro detalhado ao lado do documento processável. Por exemplo, denials.<run-id>.json produz denials.<run-id>.verbose.json. O ficheiro verboso é um registo diagnóstico limitado e censurado que inclui observações sobre as quais a política MXC não pode agir, como escritas de registo. Os metadados de saída não reportam o seu caminho, por isso derive o seu caminho a partir do caminho do documento acionável. Utilize o ficheiro detalhado para investigar uma falha que o documento com ações não explica, não como uma lista de permissões.

Distinguir uma recusa de outras falhas

Outcome	O que fazer
O MXC rejeitou a configuração	Verifique o esquema, as combinações de campos e o backend selecionado. Não conceda mais acesso para contornar um pedido incorreto.
A funcionalidade de backend ou capture está indisponível	Inspecionar a informação de apoio e capturar os pré-requisitos. Não desative silenciosamente uma restrição obrigatória.
A carga de trabalho falha durante a aplicação	Revise o estado de saída, a saída do erro e o registo de negação concluído. Uma falha na carga de trabalho não é necessariamente uma indisponibilidade de recursos.
A captura falha ou está incompleta	Trate a evidência como indisponível ou incompleta, mesmo que a carga de trabalho tenha terminado com êxito.

A captura estruturada captura o documento passível de ação. A definição ProcessContainer learningMode de nível inferior permite registar eventos de negar e registar, mas não recolhe este documento por si só. Use a capturação quando o host precisar de consumir a evidência.

Revisão do acesso observado

Classifica cada resultado antes de mudares a política. Por exemplo:

Resultado	Ação potencial
Um ficheiro de entrada obrigatório	Adicione o caminho só de leitura mais estreito que o cubra
Uma saída ou uma cache obrigatória	Adicionar um caminho de leitura-escrita específico da tarefa
Uma credencial ou um ficheiro de utilizador não relacionado	Mantém-no recusado e altera a carga de trabalho se for necessário
Um diretório principal abrangente	Identifique os caminhos subordinados necessários em vez de conceder ao elemento pai
Um pedido inesperado de rede, interface de utilizador ou funcionalidade	Verifique porque é que a carga de trabalho precisa disso antes de conceder acesso
Um recurso que a MXC não consegue expressar numa política	Altere a carga de trabalho ou escolha um backend que possa impor o requisito

O acesso observado pode resultar do arranque, deteção, funcionalidades opcionais, gestão de erros ou da entrada específica usada numa execução. Não presuma que todos os pedidos são necessários. No teste negativo do quickstart, a escrita recusada é o resultado pretendido, não uma permissão em falta.

Exemplo: usar o Modo de Aprendizagem a partir da linha de comandos

Para avaliar uma carga de trabalho sem escrever código anfitrião, execute-a com a wxc-exec.exe ferramenta de linha de comandos e uma configuração JSON. Para o formato de configuração, consulte Criar e validar uma política MXC.

Instalar um pacote MXC SDK não acrescenta wxc-exec.exe ao seu PATHarquivo. Descarrega mxc-release-binaries.zip da versão MXC que corresponde à tua versão do SDK e executa a ferramenta pelo seu caminho completo. Os exemplos seguintes assumem que extraiu o arquivo para C:\Tools\Mxc e usa a pasta x64. Nos dispositivos Arm64, usa a arm64 pasta.

Captura com um dos dois comportamentos

Selecione ProcessContainer containment e adicione captureDenials à secção processContainer da configuração. Por exemplo, um administrador de TI que avalia uma carga de trabalho que ainda não tem uma política pode usar o modo allow:

{
  "$schema": "https://raw.githubusercontent.com/microsoft/mxc/main/schemas/stable/mxc-config.schema.1.0.0.json",
  "version": "1.0.0",
  "containment": "processcontainer",
  "process": {
    "commandLine": "C:\\Tools\\Contoso\\ReportTool.exe"
  },
  "processContainer": {
    "captureDenials": {
      "mode": "allow",
      "outputPath": "C:\\MxcAudit\\denials.json"
    }
  }
}

Crie o diretório de saída antes da execução e depois passe o ficheiro de configuração para a ferramenta:

C:\Tools\Mxc\x64\wxc-exec.exe audit-config.json

Após a execução, wxc-exec escreve uma linha JSON na saída de erro padrão com o caminho de saída real e um resumo:

{"type":"captureDenials","outputPath":"C:\\MxcAudit\\denials.<run-id>.json","exitCode":0,"totalDenials":2,"deniedResourcesTruncated":false}

Utilize o caminho reportado para ler o documento. Para verificar uma política em rascunho em aplicação, adicione as suas permissões à configuração e altere o modo para block.

Propor uma configuração ajustada

Para a autoria de políticas orientada por programadores, o fluxo de trabalho de auditoria executa um processo de captura com permissão e registo e também propõe uma configuração revista:

C:\Tools\Mxc\x64\wxc-exec.exe --audit --config <path-to-config>

O fluxo de trabalho de auditoria escreve os documentos de negação, um ficheiro de traço, um instantâneo da configuração de origem e um ficheiro Adjusted_*.json que incorpora o acesso observado nessa configuração. A configuração ajustada é uma proposta para revisão, não uma política aprovada. O MXC não o produz quando a captura é truncada, e a captura do SDK não o produz de todo.

O fluxo de trabalho de auditoria suporta apenas o ProcessContainer. Não combine --audit com uma definição explícita processContainer.captureDenials. Para os contratos completos de CLI e SDK, veja Capacidades do modo de aprendizagem no GitHub.

Completar o ciclo de aprendizagem

Use este fluxo de trabalho para passar da descoberta para uma política de imposição:

Selecione o modelo de contenção antes de ativar o Modo de Aprendizagem.
Se a carga de trabalho ainda não tiver uma política e não puder escrever uma restrita diretamente, execute-a com 'allow' e 'record' num ambiente controlado. Execute as suas tarefas habituais.
Rediga uma política restrita a partir das evidências e retire concessões amplas e não relacionadas.
Executar o workload ao abrigo da política de rascunho com as opções negar e registar, e resolver as negações restantes, incluindo as capacidades necessárias.
Repita com entradas representativas de sucesso, fracasso e casos limite.
Remova todas as definições de aprendizagem, captura e auditoria, e execute um teste final de imposição. A captura pode alterar o nível de isolamento que o MXC seleciona, por isso esta execução confirma como a política se comporta em produção.

Pare de expandir o acesso quando a carga de trabalho suportada for bem-sucedida e os testes negativos continuarem a falhar como previsto.

Um agente de codificação pode ajudar a explicar as observações, mas certifique-se de rever e aprovar quaisquer alterações às políticas de acesso a recursos.

Comentários

Esta página foi útil?

Última atualização a 2026-10-27