Protección de línea base de Windows

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:

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.

  1. Llame una vez con criteriaCount = 0 y criteria = NULL para obtener el conteo. Ambos estados en general aún están devueltos.

  2. Asigne un búfer de ese tamaño y, a continuación, vuelva a llamar.

  3. 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:

  1. Configure un dispositivo de prueba o una máquina virtual que cumpla con la protección de línea base.

  2. Llama a la API y graba state y .nextBootState

  3. Enumere los criterios y registre BootState, CurrentState, y los dos códigos de resultado para cada uno.

  4. Cambiar una configuración de seguridad admitida.

  5. Consulte la API de nuevo antes de reiniciar y registre el resultado.

  6. Reinicie, consulte de nuevo y compare el nuevo estado de arranque y el estado actual.

  7. 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 NULL origen GetProcAddress y un E_NOTIMPL resultado.

  • 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-protection su 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.

Obtén más información