Nota
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Importante
La protección de línea base de Windows está en versión preliminar a través del Programa Windows Insider. La disponibilidad general está prevista para la primavera de 2027. Parte de la información se refiere a la versión preliminar del producto que puede modificarse antes de que se publique la versión comercial. Microsoft no ofrece ninguna garantía, ni expresa ni implícita, con respecto a la información facilitada aquí.
Advertencia
El nombre de API y los nombres de tipo mencionados en este artículo están sujetos a cambios. La API de vista previa se expone como Experimental_WldpQueryBaselineSecurityMode. Microsoft podría cambiar el nombre de la función, sus tipos y sus nombres de enumeración, o quitar la exportación experimental por completo, a medida que finaliza el contrato de API. La API también puede devolver E_NOTIMPL cuando se desactiva la característica subyacente. No envíe código de producción que dependa de la exportación experimental. Los valores numéricos de las enumeraciones y el diseño de la estructura son el contrato binario con wldp.dll y no cambiarán de significado, incluso si cambian los nombres.
Nota
La protección de línea base de Windows se conocía anteriormente como Modo de seguridad de línea de base (BSM) de Windows. La API de versión preliminar y sus tipos siguen usando el nombre anterior (por ejemplo, WLDP_BASELINE_SECURITY_MODE_STATE_IN). La administración de dispositivos para la protección de línea base se presenta en el Centro de administración de Microsoft 365 en el modo de seguridad de línea base.
La protección de línea base de Windows reúne las protecciones de seguridad fundamentales de Windows en un único estado de seguridad de dispositivo versionado que Windows evalúa en el arranque. En lugar de comprobar manualmente configuraciones individuales, como TPM, arranque seguro o seguridad basada en virtualización, la aplicación puede hacer una pregunta a Windows: ¿cumple este dispositivo los requisitos de protección de línea base?
La protección de línea base no es un conmutador en el que se coloca el sistema. Es una descripción del arranque que se está ejecutando actualmente: Una bota cumple la protección de línea base cuando todos los requisitos de la línea base están en su estado seguro para esa arranque.
En esta versión preliminar, la API de protección de línea base es una API local en modo auditoría. La aplicación puede leer el estado de protección de línea base del dispositivo y los detalles por requisito en el dispositivo, y usar esa información para telemetría, auditoría, diagnóstico y guía para el usuario. Se planea una API verificada en la nube y respaldada por atestación para escenarios de cumplimiento para una versión posterior.
En esta guía se explica lo siguiente:
- Qué es la protección de línea base y qué protecciones cubre
- Cómo informa Windows del estado de protección de línea base
- Cómo llamar a la API de versión preliminar e interpretar los resultados
- Cómo usar el resultado para la auditoría y la telemetría hoy
- Cómo probar que la aplicación funciona en dispositivos que cumplen la línea base
Motivos para usar la protección de línea base de Windows
Históricamente, las aplicaciones que necesitaban comprender la integridad de un dispositivo Windows ejecutaban sus propias comprobaciones de seguridad. Una aplicación bancaria puede probar un TPM, un juego antitrampas puede inspeccionar la firma del conductor y un servicio de supervisión de exámenes puede comprobar el arranque seguro. Cada aplicación buscó cosas diferentes e interpretó los resultados de manera diferente.
Durante la versión preliminar, las cosas más valiosas que puedes hacer con la señal son:
Medir. Obtenga información sobre qué parte de los dispositivos de los usuarios cumplen la protección de línea base y qué requisitos faltan con mayor frecuencia.
Guía. Indica a los usuarios cuando su dispositivo no cumple con la línea base y envíalos a Configuración para corregirlo.
Validar compatibilidad. Confirma que tu aplicación funciona cuando todas las protecciones están activadas.
Prepararse. Cree la lógica de directivas y plomería que más adelante conectará a la verificación respaldada por la atestación.
Requisitos de protección de línea base
Un dispositivo cumple la protección de línea base solo cuando cumple todos los requisitos de la versión evaluada. La línea base actual requiere:
| Requisitos | Valor del criterio API | Qué hace |
|---|---|---|
| Procesador de seguridad | WLDP_BASELINE_SECURITY_CRITERION_TPM | Ayuda a proteger los datos confidenciales mediante hardware dedicado (TPM 2.0 o Microsoft Pluton). |
| Arranque seguro | WLDP_BASELINE_SECURITY_CRITERION_SECURE_BOOT | Ayuda a evitar que se cargue software malintencionado cuando se inicia el dispositivo. |
| Seguridad basada en virtualización (VBS) | WLDP_BASELINE_SECURITY_CRITERION_VBS | Usa la virtualización de hardware para crear un entorno aislado que ayuda a proteger los procesos críticos. |
| Integridad de la memoria | WLDP_BASELINE_SECURITY_CRITERION_MEMORY_INTEGRITY | Ayuda a evitar que se ejecute código malintencionado en partes protegidas de Windows. |
| Solo controladores firmados | WLDP_BASELINE_SECURITY_CRITERION_SIGNED_DRIVERS_ONLY | Solo permite cargar controladores firmados. |
| Protección del depurador de kernel | WLDP_BASELINE_SECURITY_CRITERION_KERNEL_DEBUGGER_PROTECTION | Ayuda a evitar que las herramientas omitan las protecciones de seguridad de Windows mediante el depurador de kernel. |
| Controladores certificados para Windows | WLDP_BASELINE_SECURITY_CRITERION_WHQL_ONLY | Solo permite controladores que cumplan los requisitos de firma de hardware de Windows (WHQL). |
| Protección contra conductores vulnerables | WLDP_BASELINE_SECURITY_CRITERION_VULNERABLE_DRIVER_BLOCKLIST | Ayuda a evitar que los controladores vulnerables conocidos debiliten las protecciones de seguridad de Windows. |
Cada una de estas protecciones ya existe en Windows 11. La novedad es que Windows las evalúa conjuntamente, como un solo resultado.
Control de versiones y nuevos criterios
La protección de línea de base es un piso, no un techo. Criterios adicionales se irán uniendo con el tiempo. Como resultado:
Una aplicación creada con un encabezado anterior puede ver menos criterios de los que evalúa el sistema. No asuma que un búfer lleno cubre toda la línea base.
La aplicación debe tolerar valores de criterio que no reconoce. Informe por número en lugar de descartarlos o fallar.
No codifique de forma rígida el número o la identidad de los criterios. Use el veredicto general y enumere lo que devuelva la API.
Cómo evalúa Windows la protección de línea base
Windows evalúa el estado de protección de línea base en el arranque mediante las medidas del procesador de seguridad. Todos los requisitos se aplican desde el arranque en adelante y para desactivarlos es necesario reiniciar. Por este motivo, la aplicación puede comprobar el estado una vez por sesión en lugar de sondear.
Estado de arranque y estado de arranque siguiente
Cada criterio se informa dos veces, porque las dos preguntas que hacen las aplicaciones tienen respuestas diferentes y fuentes diferentes:
| Ver | Campo de API | Qué representa | ¿Contribuye al veredicto general? |
|---|---|---|---|
| Estado de arranque | BootState, BootResultCode | Lo que era realmente cierto cuando se inició el arranque en ejecución. Proviene de las mediciones que la plataforma registró durante el arranque, no de la configuración que puede cambiar después. | Sí. El estado general se deriva del estado de arranque de cada criterio. |
| Estado actual (inicio siguiente) | CurrentState, CurrentResultCode | Para qué está configurado el dispositivo ahora y, por tanto, qué se espera en el próximo arranque. Proviene del estado y la configuración del sistema en vivo. Es una proyección, no una promesa. | No. Se enrolla por separado en nextBootState. |
Los dos estados llevan códigos de resultado independientes porque Windows los obtiene de forma independiente; uno puede no estar disponible mientras que el otro es conocido.
La comparación de los dos estados permite a la aplicación distinguir "este dispositivo no está protegido" de "este dispositivo está configurado correctamente y necesita un reinicio para finalizar".
Estados generales
| Valor | Significado |
|---|---|
| WLDP_BASELINE_SECURITY_MODE_STATE_IN | Todos los criterios fueron evaluados y todos están en su estado seguro. |
| WLDP_BASELINE_SECURITY_MODE_STATE_NOT_IN | Se evaluaron todos los criterios y al menos uno no está en su estado seguro. |
| WLDP_BASELINE_SECURITY_MODE_STATE_UNKNOWN | No se pudo determinar el estado de al menos un criterio, por lo que no se puede hacer ninguna declaración sobre el arranque. Los estados de criterios individuales dicen cuáles y por qué. |
Estados de criterio
| Valor | Significado |
|---|---|
| WLDP_BASELINE_SECURITY_CRITERION_STATE_ON | El criterio está en su estado seguro. |
| WLDP_BASELINE_SECURITY_CRITERION_STATE_OFF | La evaluación se realizó correctamente, pero el criterio no está en su estado seguro. |
| WLDP_BASELINE_SECURITY_CRITERION_STATE_UNKNOWN | El criterio no pudo ser evaluado. El código de resultado adjunto explica por qué. |
| WLDP_BASELINE_SECURITY_CRITERION_STATE_NOT_SUPPORTED | El dispositivo no puede cumplir este criterio, por ejemplo, porque no se admite el hardware o el firmware necesarios. |
Advertencia
La API de versión preliminar es una API de evaluación local en modo auditoría . El resultado se calcula y se devuelve en el mismo dispositivo que comprueba la aplicación, y un servicio remoto no puede comprobarlo criptográficamente. No lo use como límite de seguridad. Úselo para observar, medir y guiar. Los escenarios de cumplimiento deben esperar a la API respaldada por atestación, que está planeada para una próxima versión.
Referencia de API (versión preliminar)
Precaución
Los nombres están sujetos a cambios. Consulte la advertencia en la parte superior de este artículo.
typedef HRESULT (WINAPI *PFN_Experimental_WldpQueryBaselineSecurityMode)(
_Out_ PEXPERIMENTAL_WLDP_BASELINE_SECURITY_MODE_STATE state,
_Out_opt_ PEXPERIMENTAL_WLDP_BASELINE_SECURITY_MODE_STATE nextBootState,
_In_ DWORD criteriaCount,
_Out_writes_to_opt_(criteriaCount, *criteriaReturned) PEXPERIMENTAL_WLDP_BASELINE_SECURITY_CRITERION_STATUS criteria,
_Out_ PDWORD criteriaReturned
);
Parameters
| Parámetro | Descripción |
|---|---|
| Estado | Fuera. El veredicto para el arranque que se está ejecutando, derivado del BootState de cada criterio. Proviene de las medidas de arranque. |
| nextBootState | Fuera, opcional. El mismo roll-up calculado sobre el CurrentState de cada criterio, es decir, lo que el dispositivo está configurado para producir en el siguiente arranque. Una proyección, no una promesa. |
| criteriaCount | En. El número de entradas en el búfer de criterios. Pase 0 con criterios = NULL para obtener solo los estados generales y el recuento necesario. |
| Criterios | Fuera, opcional. Búfer que recibe un EXPERIMENTAL_WLDP_BASELINE_SECURITY_CRITERION_STATUS por criterio evaluado. |
| criteriosDevuelto | Fuera. El número de entradas escritas, o el número necesario cuando el búfer está ausente o es demasiado pequeño. |
Valores devueltos
| Valor | Significado |
|---|---|
| S_OK | La consulta completada. Esto incluye el caso en el que no se pudieron evaluar criterios individuales. Esos resultados llevan WLDP_BASELINE_SECURITY_CRITERION_STATE_UNKNOWN y un código de razón. |
HRESULT_FROM_WIN32(ERROR_MORE_DATA) |
El criterio es demasiado pequeño.
criteriaReturned contiene el recuento requerido y no se escribe nada en criteria. |
| E_INVALIDARG | Argumentos inconsistentes, como o es , o criteria es NULL con un distinto de cero criteriaCount.NULLcriteriaReturnedstate |
| E_NOTIMPL | La característica subyacente está desactivada en este sistema. |
Si la compilación de Windows no incluye la API, GetProcAddress devuelve NULL.
Elija cómo llamar a la API
La mayoría de las aplicaciones solo necesitan la respuesta sí o no, y esa respuesta requiere una sola llamada. El informe por criterio es una segunda convocatoria opcional. Úselo solo cuando necesite los detalles.
| Necesita | Cómo llamar |
|---|---|
| "¿Este dispositivo cumple con la protección básica?" | Una llamada con criteriaCount = 0 y = criteriaNULL . Ambos estados en general aún regresan. |
| Detalle por criterio (telemetría, diagnóstico) | El patrón de dos llamadas: obtenga el recuento, asigne, vuelva a llamar e intente .ERROR_MORE_DATA |
Resolver la función
Dado que la función de vista previa no está en wldp.lib, cargue wldp.dll desde System32 y resuelva la exportación en tiempo de ejecución:
HMODULE wldp = LoadLibraryExW(L"wldp.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
if (wldp == nullptr)
{
// Record that the state couldn't be read, and continue normally.
}
auto queryBsm = reinterpret_cast<PFN_Experimental_WldpQueryBaselineSecurityMode>(
GetProcAddress(wldp, "Experimental_WldpQueryBaselineSecurityMode"));
if (queryBsm == nullptr)
{
// This build of Windows doesn't include the API. Continue normally.
}
El caso común: una llamada
Este enfoque funciona para la mayoría de las aplicaciones:
EXPERIMENTAL_WLDP_BASELINE_SECURITY_MODE_STATE state = WLDP_BASELINE_SECURITY_MODE_STATE_UNKNOWN;
EXPERIMENTAL_WLDP_BASELINE_SECURITY_MODE_STATE nextBootState = WLDP_BASELINE_SECURITY_MODE_STATE_UNKNOWN;
DWORD ignoredCount = 0;
HRESULT hr = queryBsm(&state, &nextBootState, 0, nullptr, &ignoredCount);
if (SUCCEEDED(hr) && state == WLDP_BASELINE_SECURITY_MODE_STATE_IN)
{
// The device met the baseline for this boot. Record it.
}
Solicite nextBootState incluso en el caso simple. No cuesta nada y marca la diferencia entre decirle a un usuario "su dispositivo no está protegido" y "su dispositivo ya está configurado correctamente; reiniciar para terminar", que son mensajes muy diferentes.
El caso detallado: dos llamadas
El informe por criterio es principalmente útil para telemetría: registrar qué criterios están desactivados en la base de instalación de la aplicación, para que vea la imagen completa en lugar de solo la tasa de aprobación o suspensión.
Llame una vez con
criteriaCount = 0ycriteria = NULLpara obtener el conteo. Ambos estados en general aún están devueltos.Asigne un búfer de ese tamaño y, a continuación, vuelva a llamar.
Reintentar en
ERROR_MORE_DATA. La lista de criterios crece con el tiempo, por lo que el recuento puede cambiar entre llamadas.
Vea la muestra completa para ver el patrón completo.
Interpretar el resultado
Estado general
Usar state y nextBootState juntos. En el modo auditoría, la respuesta de la aplicación debe ser informativa, nunca de bloqueo.
| Estado | nextBootState | Qué significa | Comportamiento del modo de auditoría sugerido |
|---|---|---|---|
| Acercar | Acercar | El dispositivo cumple la protección de línea base. | Registre el resultado. No se necesita ninguna acción del usuario. |
| No dentro / Desconocido | Acercar | El dispositivo está configurado correctamente, pero necesita un reinicio. | Registre el resultado. También puedes sugerir un reinicio. |
| Acercar | No en | El dispositivo cumplió la línea base en este arranque, pero desde entonces se ha desactivado una protección. | Registre el resultado. Opcionalmente, puede indicar al usuario que una protección estará desactivada después del reinicio. |
| No en | No en | Una o más protecciones están desactivadas. | Registre el resultado. Opcionalmente, indique al usuario y vincule a Configuración. |
| Unknown | Cualquiera | Windows no pudo determinar el estado. | Registrar códigos de resultado por criterio. No lo presente a los usuarios como un problema con su dispositivo. |
Criterios individuales
| Estado de arranque | Estado actual | Significado |
|---|---|---|
| Desactivado | Activado | Configurado; surte efecto después de un reinicio. |
| Activado | Desactivado | Estaba segura esta bota, desde entonces se ha apagado; no será seguro en el siguiente arranque. |
| Activado | Activado | Estado estable. |
| Unknown | Cualquiera | No se pudo evaluar.
BootResultCode lleva la razón. |
Enviar usuarios a Configuración para corregir las protecciones que faltan
Es posible que la aplicación quiera mostrar información sobre un criterio determinado, pero la orientación general no es crear su propio flujo de corrección. En su lugar, envía al usuario a la aplicación Configuración. La configuración está diseñada para proporcionar una experiencia de un solo clic para devolver el dispositivo a la protección de línea base y se mantiene correcta a medida que cambian los criterios.
Si crea su propio flujo de corrección, duplica la lógica que cambia cada vez que se agrega un criterio. Cada criterio se fija en un lugar diferente, como la configuración del firmware, la directiva o la configuración del controlador. La configuración ya se encarga de eso, incluida la guía de los usuarios a través de los cambios de firmware (UEFI), como activar el arranque seguro o el TPM.
Inicie la página protección de línea base en Configuración con este URI o visite Configuración > Protección de línea base:
ShellExecuteW(nullptr, L"open", L"ms-settings:baseline-protection", nullptr, nullptr, SW_SHOWNORMAL);
Nota
Durante la versión preliminar, esta página Configuración está cerrada y es posible que no aparezca en la compilación de Windows que estás probando.
Nota
En dispositivos administrados, es posible que los usuarios no puedan cambiar esta configuración por sí mismos. En ese caso, indique a los usuarios que se pongan en contacto con su administrador de TI. Los administradores de TI administran la protección de línea base mediante el modo de seguridad de línea base en el Centro de administración de Microsoft 365, Microsoft Intune o herramientas de administración de terceros.
Ejemplo: Consulte la protección de línea base e imprima cada criterio
Este ejemplo toma la ruta de acceso detallada, por lo que muestra la resolución en tiempo de ejecución, el bucle de tamaño y el control de errores que necesita cada llamador. Para el caso común de sí o no, mantenga la misma configuración y use la llamada única.
//
// Sample: query baseline protection and print each criterion.
//
// Build: cl /std:c++17 /EHsc bsmsample.cpp
// The API is a PRIVATE export of wldp.dll, so no import library is needed.
//
#include <windows.h>
//
// wldp_bsm.h is the header from Appendix A. Once your Windows SDK declares the
// API, delete it and include <wldp.h> instead.
//
#include "wldp_bsm.h"
#include <cstdio>
#include <vector>
namespace
{
const wchar_t* ModeStateToString(EXPERIMENTAL_WLDP_BASELINE_SECURITY_MODE_STATE state)
{
switch (state)
{
case WLDP_BASELINE_SECURITY_MODE_STATE_IN: return L"In baseline protection";
case WLDP_BASELINE_SECURITY_MODE_STATE_NOT_IN: return L"Not in baseline protection";
case WLDP_BASELINE_SECURITY_MODE_STATE_UNKNOWN: return L"Unknown";
default: return L"<unrecognized>";
}
}
const wchar_t* CriterionStateToString(EXPERIMENTAL_WLDP_BASELINE_SECURITY_CRITERION_STATE state)
{
switch (state)
{
case WLDP_BASELINE_SECURITY_CRITERION_STATE_ON: return L"On";
case WLDP_BASELINE_SECURITY_CRITERION_STATE_OFF: return L"Off";
case WLDP_BASELINE_SECURITY_CRITERION_STATE_NOT_SUPPORTED: return L"Not supported";
case WLDP_BASELINE_SECURITY_CRITERION_STATE_UNKNOWN: return L"Unknown";
default: return L"<unrecognized>";
}
}
//
// Criteria are appended over time, so anything past the end of this table is
// reported by number rather than dropped.
//
const wchar_t* CriterionToString(EXPERIMENTAL_WLDP_BASELINE_SECURITY_CRITERION criterion)
{
switch (criterion)
{
case WLDP_BASELINE_SECURITY_CRITERION_TPM: return L"TPM";
case WLDP_BASELINE_SECURITY_CRITERION_SECURE_BOOT: return L"Secure Boot";
case WLDP_BASELINE_SECURITY_CRITERION_VBS: return L"VBS";
case WLDP_BASELINE_SECURITY_CRITERION_MEMORY_INTEGRITY: return L"Memory Integrity";
case WLDP_BASELINE_SECURITY_CRITERION_SIGNED_DRIVERS_ONLY: return L"Signed Drivers Only";
case WLDP_BASELINE_SECURITY_CRITERION_KERNEL_DEBUGGER_PROTECTION: return L"Kernel Debugger Protection";
case WLDP_BASELINE_SECURITY_CRITERION_WHQL_ONLY: return L"WHQL Only";
case WLDP_BASELINE_SECURITY_CRITERION_VULNERABLE_DRIVER_BLOCKLIST: return L"Vulnerable Driver Blocklist";
default: return nullptr;
}
}
}
int wmain()
{
HMODULE wldp = LoadLibraryExW(L"wldp.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
if (wldp == nullptr)
{
wprintf(L"LoadLibraryExW(wldp.dll) failed: %lu\n", GetLastError());
return 1;
}
auto queryBsm = reinterpret_cast<PFN_Experimental_WldpQueryBaselineSecurityMode>(
GetProcAddress(wldp, "Experimental_WldpQueryBaselineSecurityMode"));
if (queryBsm == nullptr)
{
wprintf(L"This build of wldp.dll does not export the API: %lu\n", GetLastError());
FreeLibrary(wldp);
return 1;
}
EXPERIMENTAL_WLDP_BASELINE_SECURITY_MODE_STATE state = WLDP_BASELINE_SECURITY_MODE_STATE_UNKNOWN;
EXPERIMENTAL_WLDP_BASELINE_SECURITY_MODE_STATE nextBootState = WLDP_BASELINE_SECURITY_MODE_STATE_UNKNOWN;
std::vector<EXPERIMENTAL_WLDP_BASELINE_SECURITY_CRITERION_STATUS> criteria;
DWORD returned = 0;
//
// Size the buffer, then fill it. The loop re-sizes because the criterion list
// can be longer than the header this sample was built against.
//
HRESULT hr = queryBsm(&state, &nextBootState, 0, nullptr, &returned);
for (int attempt = 0; SUCCEEDED(hr) && attempt < 4; ++attempt)
{
criteria.assign(returned, EXPERIMENTAL_WLDP_BASELINE_SECURITY_CRITERION_STATUS{});
hr = queryBsm(
&state,
&nextBootState,
static_cast<DWORD>(criteria.size()),
criteria.empty() ? nullptr : criteria.data(),
&returned);
if (hr != HRESULT_FROM_WIN32(ERROR_MORE_DATA))
{
break;
}
//
// ERROR_MORE_DATA leaves the buffer untouched and puts the required count
// in returned, so just grow and retry.
//
hr = S_OK;
}
if (hr == E_NOTIMPL)
{
wprintf(L"Baseline protection is not enabled on this system.\n");
FreeLibrary(wldp);
return 0;
}
if (FAILED(hr))
{
wprintf(L"Experimental_WldpQueryBaselineSecurityMode failed: 0x%08X\n", hr);
FreeLibrary(wldp);
return 1;
}
wprintf(L"This boot : %s\n", ModeStateToString(state));
wprintf(L"Next boot : %s\n\n", ModeStateToString(nextBootState));
if (state != WLDP_BASELINE_SECURITY_MODE_STATE_IN &&
nextBootState == WLDP_BASELINE_SECURITY_MODE_STATE_IN)
{
wprintf(L"Configured correctly; restart to finish.\n\n");
}
for (DWORD i = 0; i < returned; ++i)
{
const auto& entry = criteria[i];
const wchar_t* name = CriterionToString(entry.Criterion);
if (name != nullptr)
{
wprintf(L"%-28s", name);
}
else
{
wprintf(L"Criterion %-18u", static_cast<unsigned>(entry.Criterion));
}
wprintf(
L" boot=%-14s (0x%08X) current=%-14s (0x%08X)\n",
CriterionStateToString(entry.BootState),
entry.BootResultCode,
CriterionStateToString(entry.CurrentState),
entry.CurrentResultCode);
}
FreeLibrary(wldp);
return 0;
}
Usar la protección de línea base para auditoría y telemetría
El modo auditoría es el momento adecuado para comprender su base de usuarios antes de que sea posible cualquier aplicación. Recomendamos que la aplicación registre:
| Campo | Por qué es útil |
|---|---|
| Estado | Porcentaje de dispositivos que cumplen la protección de línea base en la actualidad |
| nextBootState | Compartir dispositivos con un cambio pendiente (por ejemplo, esperando un reinicio) |
| Por criterio BootState y CurrentState | Qué requisitos faltan con mayor frecuencia |
| BootResultCode y CurrentResultCode por criterio | Diagnóstico: resultados desconocidos y comportamiento inesperado |
| API HRESULT (incluye E_NOTIMPL o falta una exportación) | Separar los errores de disponibilidad del estado del dispositivo |
| Número de compilación de Windows | Correlación de resultados con versiones de Windows |
| Timestamp | Seguimiento de los cambios en la población a lo largo del tiempo |
Use estos datos para:
Calcule cuántos de los usuarios se verían afectados si más adelante necesita protección de línea base para una característica.
Priorice la guía de usuario para los requisitos que faltan con mayor frecuencia.
Buscar problemas de compatibilidad entre la aplicación y protecciones específicas.
Planifique la directiva que aplicará una vez que la verificación respaldada por la atestación esté disponible.
Pruebe la aplicación en dispositivos que cumplan la protección de línea base
Asegúrese de que la aplicación funciona cuando todos los requisitos de protección de línea base están activados. Si la aplicación depende de que alguna de estas protecciones esté desactivada (por ejemplo, instala un controlador no firmado o no certificado, o necesita el depurador de kernel), depende de un estado de plataforma debilitado y es posible que no funcione en dispositivos protegidos.
Pruebe este flujo de prueba:
Configure un dispositivo de prueba o una máquina virtual que cumpla con la protección de línea base.
Llama a la API y graba
statey .nextBootStateEnumere los criterios y registre
BootState,CurrentState, y los dos códigos de resultado para cada uno.Cambiar una configuración de seguridad admitida.
Consulte la API de nuevo antes de reiniciar y registre el resultado.
Reinicie, consulte de nuevo y compare el nuevo estado de arranque y el estado actual.
Confirma que los escenarios principales de tu aplicación funcionan con todas las protecciones activadas.
Cuando notifique un resultado inesperado, incluya el número de compilación de Windows, los estados devueltos y los códigos de resultado, así como los pasos de reproducción.
Procedimientos recomendados
Observe, no haga cumplir. En la versión preliminar, use el resultado solo para telemetría, auditoría, diagnóstico y guía para el usuario. No bloquee, deniegue ni degrade a los usuarios en función de ello.
No envíe una dependencia de la exportación experimental. El nombre podría cambiar o quitarse. Gestione siempre un
NULLorigenGetProcAddressy unE_NOTIMPLresultado.Use la señal de la plataforma en lugar de crear sus propios cheques. No vuelva a implementar la protección de línea base consultando de forma independiente TPM, arranque seguro, VBS o configuración de controladores.
Use una llamada cuando sea todo lo que necesite. Solicite detalles por criterio solo cuando los vaya a usar.
Solicitar
nextBootStatesiempre. Le indica si el usuario solo necesita reiniciar.Reintentar en
ERROR_MORE_DATA. La lista de criterios puede crecer.Tolerar criterios no reconocidos. Repórtelos por número; Nunca asuma que su encabezado enumera todos los criterios.
Conservar códigos de resultado. Incluya códigos de resultado por criterio en los registros y diagnósticos.
Envíe usuarios a Configuración. Establezca un vínculo profundo a
ms-settings:baseline-protectionsu propia solución en lugar de construirla.Respetar los dispositivos administrados. Enrute a los usuarios de los dispositivos administrados a su administrador de TI.
Don't assume Unknown means insecure. Un estado desconocido significa que Windows no pudo establecer el estado. Trátalo por separado de "no en protección de línea base".
Preguntas más frecuentes
¿Puedo usar la API de versión preliminar para bloquear usuarios o acceso de puerta? No. La API de versión preliminar es una API local, en modo auditoría, y un servicio remoto no puede comprobar su resultado de forma independiente. Úselo para telemetría, auditoría y guía para usuarios. Los escenarios de cumplimiento deben usar la API respaldada por atestación cuando esté disponible.
¿Cambiará el nombre de la API? Podría. Experimental_WldpQueryBaselineSecurityMode y sus nombres de tipo están sujetos a cambios antes de que finalice la API. Los valores de enumeración y el diseño de la estructura no cambiarán el significado. Cuando wldp.h del SDK declare la API final, cámbiela a ella.
¿En qué se diferencia la protección de línea base de Windows de las líneas base de seguridad en Intune? Las líneas base de seguridad de Intune son grupos definidos por el administrador de la configuración recomendada. La protección de línea base de Windows es un estado de seguridad de dispositivo versionado y definido por Microsoft que Windows evalúa en el arranque y notifica a las aplicaciones y servicios.
¿La protección de línea base es lo mismo que el modo de seguridad de línea base en el Centro de administración de Microsoft 365? El modo de seguridad de línea base en el Centro de administración de Microsoft 365 es donde los administradores de TI informan y administran la protección de línea base para los dispositivos Windows de su organización, junto con otras recomendaciones de Microsoft 365.
¿Mi aplicación necesita activar la protección de línea base? No. La aplicación lee el estado. Los usuarios activan las protecciones en Configuración y los administradores de TI las administran a través de sus herramientas de administración.