Creación y refinación de directivas MXC con el modo de aprendizaje

Los sandboxes de Microsoft Execution Containers (MXC) se rigen por denegación predeterminada, de modo que una carga de trabajo contenida pueda usar solo los archivos, capacidades y otros recursos que permite su política.

Sin embargo, puede ser difícil predecir todos los recursos a los que puede que necesite acceder una carga de trabajo. El modo de aprendizaje MXC le ayuda a crear una directiva con privilegios mínimos en Windows mediante la grabación de los recursos a los que una carga de trabajo intenta acceder, por lo que puede crear o refinar una directiva basándose en evidencias en lugar de prueba y error.

Note

El modo de aprendizaje está disponible actualmente para cargas de trabajo que se ejecutan en un ProcessContainer MXC en Windows. Use la detección en tiempo de ejecución para confirmar la compatibilidad con ProcessContainer en el host.

Elegir el comportamiento del modo de aprendizaje

El modo de aprendizaje tiene dos comportamientos. Difieren en si MXC sigue aplicando la directiva mientras registra el acceso, lo que determina quién debe usar cada uno y cuándo.

Características	Denegar y registrar	Permitir y registrar
Acceso no concedido	Bloqueado y grabado	Permitido y registrado
Aplicación de directivas	Impuesta, pero la captura puede cambiar el nivel de aislamiento	Deny-by-default relajada para la ejecución
Usuarios típicos	Desarrolladores de aplicaciones y autores de políticas	Administradores de TI y desarrolladores que evalúan las cargas de trabajo existentes
Cuándo usarlo	Mientras desarrolla una aplicación y su directiva	Antes de que exista una directiva, para saber a qué accede una carga de trabajo de confianza
Captura valor de `mode`	`block` (valor predeterminado)	`allow`

Denegar y registrar: desarrollar aplicaciones y directivas

Utilice deny y record (learningModeLogging) mientras desarrolla una aplicación o un agente y su directiva MXC. MXC sigue imponiendo la directiva mientras registra, de modo que el acceso no concedido falla como lo haría para sus usuarios. El modo de aprendizaje agrega un registro de cada acceso bloqueado por la directiva. En algunos hosts, la captura cambia el nivel de aislamiento que selecciona MXC. Para más detalles, vea Planificar los requisitos previos de la captura.

Usos comunes:

Diagnosticar por qué una carga de trabajo contenida falla, y distinguir una concesión ausente de un error no relacionado.
Iterar sobre una política en borrador hasta que los escenarios admitidos se realicen correctamente y las pruebas negativas sigan fallando.
Identificación de las capacidades que solicita una carga de trabajo.
Permitir que los usuarios de la aplicación ajusten su propio espacio aislado. La aplicación registra lo que se bloqueó, lo presenta en su propia interfaz de usuario y vuelve a generar la directiva solo después de que el usuario apruebe el cambio.

Dado que MXC sigue aplicando la directiva, denegar y registrar es la opción más segura. Úselo siempre que tenga una directiva que probar, incluso una incompleta.

Permitir y registrar: evalúe las cargas de trabajo existentes antes de crear una directiva.

Use permitir y registrar (permissiveLearningMode) cuando necesite aprender a qué accede una carga de trabajo existente y de confianza antes de aplicarle una directiva MXC. Por ejemplo, un administrador de TI puede ejecutar una herramienta o script de línea de negocio a través de sus tareas habituales en un dispositivo de prueba y, a continuación, usar los resultados para crear una directiva base antes de activar la imposición. Un desarrollador que aporta una herramienta existente a MXC puede usar el mismo enfoque para redactar una primera política.

Permitir y registrar relaja la imposición deny-by-default para la ejecución, así que trate la carga de trabajo como si se ejecutara con los permisos completos del usuario. MXC registra cada acceso que la directiva habría denegado. Cada vez que este modo está activo, MXC también devuelve una advertencia de seguridad con el resultado de la ejecución. El host debe mostrar esa advertencia en lugar de descartarla.

Antes de usar permitir y registrar:

Ejecute solo código de confianza, con datos representativos no confidenciales, en un dispositivo o cuenta de prueba controlada.
Ejecute las tareas habituales de la carga de trabajo. El acceso que una ejecución no ejercita no aparece en los resultados.
Trate los resultados como un inventario inicial. Quite las concesiones innecesarias y, a continuación, verifique el borrador de la directiva con denegar y registrar antes de implementarla.

Importante

No exponga Learning Mode permitir y registrar como una herramienta de producción que un agente pueda llamar. El código del host de confianza o una persona debe aprobar su uso y cualquier expansión de permisos resultante.

Planificar los requisitos previos de la captura

MXC recopila los resultados del modo de aprendizaje a través de una de las dos rutas de acceso de captura. Selecciona la ruta de acceso en tiempo de ejecución, en función del host y de la directiva solicitada. Esto se aplica a captureDenials en cualquiera de los dos modos y al flujo de trabajo wxc-exec.exe --audit.

Ruta de captura	Cuando MXC lo usa	Nivel de aislamiento	Elevation
Captura nativa	Windows proporciona el entorno de seguridad de procesos y las API del modo de aprendizaje que MXC necesita y pueden representar la directiva solicitada.	BaseContainer	None
Captura protegida	La captura nativa no está disponible o no puede representar la directiva solicitada	Un nivel de AppContainer compatible	MXC inicia un asistente firmado, `plm.exe`, con elevación para registrar una traza de Windows Performance Recorder (WPR). El usuario debe aprobar un mensaje de UAC o proporcionar credenciales de administrador.

La captura nativa no puede representar algunas directivas, como processContainer.leastPrivilege, algunas configuraciones de proxy de red y rutas de acceso denegadas en hosts que no las admiten de forma nativa. Esas solicitudes usan la captura protegida incluso en hosts que admiten la captura nativa. Si ninguna ruta de acceso puede conservar la directiva completa, MXC devuelve un error en lugar de debilitar la directiva o omitir la captura.

Para averiguar qué ruta usará una solicitud, sondee la solicitud con la captura habilitada antes de iniciarla. La sonda no crea un contenedor.

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

Un nivel BaseContainer significa captura nativa. Un nivel de AppContainer significa captura protegida y un aviso de elevación. El dato de captura nativo describe el host, no su solicitud, así que compruebe también el nivel.

Planifique estas diferencias:

En una aplicación, sondee antes de iniciar la captura e indique a los usuarios cuándo la captura requiere aprobación del administrador. No suponga que la captura se ejecuta silenciosamente en cada host.
Cuando un administrador de TI evalúa las cargas de trabajo, confirme que los dispositivos de prueba admiten la captura nativa o que un administrador puede aprobar la solicitud de captura protegida. La capa AppContainer también puede requerir la preparación del host.
Trate los resultados de captura como evidencia para la creación de políticas. Dado que la captura protegida puede ejecutar la carga de trabajo en una capa diferente a la de producción, confirme la directiva final con una ejecución que no use la captura.

Ejemplo: habilitación de la captura a través de un SDK de MXC

Use la captura del SDK cuando su aplicación hospede la carga de trabajo. Para evaluar una carga de trabajo sin escribir código host, consulte Usar el modo de aprendizaje desde la línea de comandos.

Comience con el inicio rápido del SDK, incluido su caso de escritura denegada. Los siguientes fragmentos amplían ese ejemplo y usan la misma carga de trabajo y las mismas concesiones de recursos. Inserte el fragmento seleccionado inmediatamente antes de que el SDK inicie la carga de trabajo.

En los ejemplos se usan las API del SDK de MXC 1.0 V1. En cada SDK, configurará la captura en una selección de contención de ProcessContainer explícita, que reemplaza la intención del proceso abstracto del inicio rápido.

Cree un directorio de salida propiedad del host para la captura. No es necesario que la carga de trabajo alojada pueda escribir en ella.

Establezca las opciones de captura en la contención ProcessContainer explícita de la solicitud:

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"),
    },
};

Establezca las opciones de captura en la contención ProcessContainer explícita de la solicitud:

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

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

Añada use mxc_sdk::v1::configs::{CaptureDenials, CaptureDenialsMode, ProcessContainerConfig}; a los imports. A continuación, establezca las opciones de captura en la contención ProcessContainer explícita de la solicitud:

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
};

En modo block, el caso de escritura denegada sigue fallando. Capturar la denegación no concede la escritura. En el caso de una ejecución permitida y de registro aprobada, cambie solo el modo a CaptureDenialsMode.Allow en C#, 'allow' en TypeScript o CaptureDenialsMode::Allow en Rust.

Al adaptar una integración existente, conserve el resto de su configuración de contención. Use las opciones de captura dedicadas, no los nombres de capacidad interna reservada learningModeLogging o permissiveLearningMode.

Localizar la captura completada

Espere a que finalicen la ejecución y la captura antes de leer el resultado. MXC inserta un identificador de ejecución único en el nombre de archivo configurado, por lo que denials.json se convierte en un nombre como denials.<run-id>.json. Use la ruta de acceso notificada en lugar de adivinarla o buscar el archivo más reciente.

Después de que MxcContainer.RunAsync(request) se complete y notifique result.Warnings, examine los metadatos del 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;
}

Mantenga la gestión del inicio rápido del estado de salida, los tiempos de espera y result.Warnings. En concreto, el SDK de .NET devuelve advertencias sobre el modo de aprendizaje permisivo en lugar de escribirlas en el terminal automáticamente.

Si usa la ejecución por streaming, complete la espera terminal antes de examinar MxcProcess.OutputMetadata. Eliminar el proceso sin esperar no es un sustituto de la finalización de la captura.

Después de que run(request) se complete y notifique result.warnings, examine los metadatos del 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.");
}

Mantenga la gestión del inicio rápido del estado de salida, los tiempos de espera y result.warnings.

Si usa spawn, espere a que finalice el proceso antes de inspeccionar outputMetadata en el proceso devuelto. Eliminar el proceso sin esperar no es un sustituto de la finalización de la captura. No interprete una captura ausente o incompleta como cero denegaciones, y no use el texto arbitrario impreso por la carga de trabajo como aprobación para ampliar su directiva.

Después de que v1::run devuelva y notifique result.warnings, examine los metadatos del 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);
}

Mantenga la gestión del inicio rápido del estado de salida, los tiempos de espera y result.warnings.

Si usa v1::spawn, llame a wait en el MxcProcess devuelto antes de examinar su output_metadata(). Interrumpir el proceso sin esperar no es un sustituto de la finalización de la captura. No interprete una captura ausente o incompleta como cero denegaciones, y no use el texto arbitrario impreso por la carga de trabajo como aprobación para ampliar su directiva.

Leer la salida de denegaciones

El documento JSON accionable identifica los recursos, el acceso intentado y un resumen. En el caso de escritura denegada del inicio rápido, una entrada representativa tiene el siguiente aspecto:

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

El documento es evidencia para la creación de directivas, no un registro exhaustivo de todo lo que hizo la carga de trabajo. El resourceType valor determina cómo leer resource. Por ejemplo, una file entrada contiene una ruta de acceso absoluta y una capability entrada contiene un nombre de funcionalidad como internetClient. Algunas observaciones no se pueden expresar como concesiones de directiva, y una única entrada no ejercitará cada ruta de código.

En modo permitir, el documento no incluye actualmente las solicitudes de capacidad. Ejecute la carga de trabajo con denegar y registrar para identificar las capacidades que necesita.

Si deniedResourcesTruncated es true, no genere una directiva a partir de esa ejecución. Un documento vacío tampoco demuestra que una carga de trabajo es segura o que se ejerció cada restricción prevista.

MXC también escribe un archivo detallado junto al documento accionable. Por ejemplo, denials.<run-id>.json genera denials.<run-id>.verbose.json. El archivo detallado es un registro de diagnóstico delimitado y censurado que incluye observaciones sobre las que la directiva MXC no puede actuar, como las escrituras en el registro. Los metadatos de salida no notifican su ruta, así que dedúzcala de la ruta del documento accionable. Use el archivo detallado para investigar un error que el documento accionable no explique, no como lista de concesiones.

Distinguir una denegación de otros fallos

Resultado	Qué hacer
MXC rechaza la configuración	Compruebe el esquema, las combinaciones de campos y el back-end seleccionado. No conceda más acceso para sortear una solicitud no válida.
El back-end o la característica de captura no están disponibles	Inspeccione la información de soporte técnico y recopile los requisitos previos. No deshabilite silenciosamente una restricción obligatoria.
La carga de trabajo falla bajo la imposición	Revise su estado de salida, la salida de errores y la captura de denegaciones completada. Un error de la carga de trabajo no es necesariamente una denegación de recursos.
La captura falla o está incompleta	Trate las evidencias como no disponibles o incompletas, aunque la carga de trabajo haya salido correctamente.

La captura estructurada recopila el documento accionable. La configuración learningMode del nivel inferior de ProcessContainer habilita el registro de los eventos de denegar y registrar, pero por sí sola no recopila este documento. Use la captura cuando el host necesite consumir las evidencias.

Revisar el acceso observado

Clasifique cada resultado antes de cambiar la política. Por ejemplo:

Hallazgo	Acción potencial
Un archivo de entrada necesario	Agregue la ruta de acceso de solo lectura más específica que la cubre.
Una salida o caché requerida	Añada una ruta de acceso de lectura y escritura específica para la tarea
Una credencial o un archivo de usuario no relacionado	Mantenerlo denegado y cambiar la carga de trabajo si es necesario
Un directorio padre amplio	Identificar las rutas secundarias requeridas en lugar de conceder el directorio padre
Una solicitud inesperada de red, de interfaz de usuario o de funcionalidad	Compruebe por qué el workload lo necesita antes de conceder acceso
Un recurso que MXC no puede expresar en la política	Cambiar la carga de trabajo o elegir un back-end que pueda aplicar el requisito

El acceso observado puede provenir del arranque, el descubrimiento, las características opcionales, el control de errores o la entrada concreta usada en una ejecución. No suponga que todas las solicitudes son necesarias. En la prueba negativa del inicio rápido, la escritura denegada es el resultado previsto, no un permiso que falta.

Ejemplo: usa el modo de aprendizaje desde la línea de comandos

Para evaluar una carga de trabajo sin escribir código de host, ejecútelo con la wxc-exec.exe herramienta de línea de comandos y una configuración JSON. Para el formato de configuración, vea Crear y validar una directiva MXC.

La instalación de un paquete del SDK de MXC no agrega wxc-exec.exe a tu PATH. Descargue mxc-release-binaries.zip de la versión MXC que coincida con la versión del SDK y ejecute la herramienta indicando su ruta completa. En los ejemplos siguientes se da por supuesto que extrajo el archivo comprimido en C:\Tools\Mxc y usa la carpeta x64. En los dispositivos Arm64, use la carpeta arm64.

Capturar con uno u otro comportamiento

Seleccione la contención ProcessContainer y añada captureDenials a la sección processContainer de la configuración. Por ejemplo, un administrador de TI que evalúa una carga de trabajo que aún no tiene una directiva puede usar el 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"
    }
  }
}

Cree el directorio de salida antes de la ejecución y, a continuación, pase el archivo de configuración a la herramienta:

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

Después de la ejecución, wxc-exec escribe una línea JSON en la salida de error estándar con la ruta de acceso de salida real y un resumen:

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

Use la ruta de acceso notificada para leer el documento. Para verificar un borrador de directiva bajo imposición, añada sus concesiones a la configuración y cambie el modo a block.

Proponer una configuración ajustada

Para la creación de directivas impulsada por el desarrollador, el flujo de trabajo de auditoría ejecuta una captura permitir y registrar y también propone una configuración revisada:

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

El flujo de trabajo de auditoría escribe los documentos de denegaciones, un archivo de traza, una instantánea de la configuración de origen y un archivo Adjusted_*.json que combina el acceso observado en esa configuración. La configuración ajustada es una propuesta para revisar, no una directiva aprobada. MXC no lo genera cuando se trunca la captura y la captura del SDK no la genera en absoluto.

El flujo de trabajo de auditoría solo admite ProcessContainer. No combine --audit con una configuración processContainer.captureDenials explícita. Para obtener los contratos completos de la CLI y del SDK, consulte Funcionalidades en modo de aprendizaje en GitHub.

Completar el bucle de aprendizaje

Use este flujo de trabajo para pasar del descubrimiento a una directiva de aplicación:

Seleccione el modelo de contención antes de habilitar el modo de aprendizaje.
Si la carga de trabajo todavía no tiene directiva y no puede escribir una restringida directamente, ejecútela con permitir y registrar en un entorno controlado. Ejercite sus tareas habituales.
Redacte una directiva restringida a partir de las evidencias, y quite las concesiones amplias y no relacionadas.
Ejecute la carga de trabajo conforme a la directiva de borrador con denegación y registro y resuelva las denegaciones restantes, incluidas las capacidades requeridas.
Repita con entradas representativas de éxito, de fallo y de casos límite.
Quite toda la configuración de aprendizaje, captura y auditoría y ejecute una prueba de aplicación final. La captura puede cambiar el nivel de aislamiento que MXC selecciona, por lo que esta ejecución confirma cómo se comporta la directiva en producción.

Deje de ampliar el acceso cuando la carga de trabajo admitida se complete correctamente y las pruebas negativas sigan fallando como se pretende.

Un agente de codificación puede ayudar a explicar las observaciones, pero asegúrese de revisar y aprobar los cambios en las directivas de acceso a recursos.

Comentarios

¿Le ha resultado útil esta página?

Se actualizó por última vez el 2026-10-30