แฉแแแ แแแแแแแแแ แแกแแ แแแแแ แแแแแแ แฉแแแแกแแแแก แแ แแแกแแฃแแ แแ firmware x86-แแแ แแแแกแแแแแ แแแแแแฃแขแแ แฃแแ แแแแขแคแแ แแแแแก แฃแกแแคแ แแฎแแแแแแ. แแแฏแแ แแ, แแแแแแแก แแแแแแ แ แแแแ แแแแแแขแแ Intel Boot Guard (แแ แฃแแแ แแแแแ แแแก Intel BIOS Guard-แจแ!) - แขแแฅแแแแแก แแฎแแ แแแญแแ แแ BIOS แกแแแแ แฉแแขแแแ แแแแก แขแแฅแแแแแแแ, แ แแแแแแช แแแแแแฃแขแแ แฃแแ แกแแกแขแแแแก แแแแงแแแแแแก แจแแฃแซแแแ แกแแแฃแแแแแ แฉแแ แแแก แแ แแแแแ แแแก แฌแแ แแแแแแก แแขแแแแ. แแกแ, แฉแแแ แฃแแแ แแแชแแ แแแแแแแก แ แแชแแแขแ: แฌแแ แแแแ แแแแญแ แแ แแ แขแแฅแแแแแแแแก แแแแแ แแแ แกแแแแ แแกแแแ แ แแแแแแแ แแแ, แแฆแฌแแ แแ แแแกแ แแ แฅแแขแแฅแขแฃแ แ, แจแแแแกแแ แแแ แแแฃแกแแแฃแแแแแแ แแแขแแแแแแ, แแแแแแแแแแแ แจแแขแแแแก แแแฅแขแแ แแแแ แแแแแแแแแแ แแ แแฃแ แแแ. แแแแแ แแแแแแแขแแ แชแแชแฎแแ แแแแแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแแแ แแแแแแ แแแฃแแ แฎแแ แแแแ แ แแแแแแแแ แแแแงแแแแแแแก แฌแแ แแแแแแจแ แฌแแแแแก แแแแแแแแแแแจแ แกแแจแฃแแแแแแก แแซแแแแก แแแขแแแชแแฃแ แแแแแแแกแฎแแแแก แแแแแแงแแแแก แแก แขแแฅแแแแแแแ แคแแ แฃแแ rootkit-แแก แจแแกแแฅแแแแแแ, แ แแแแแก แแแแฆแแแแช แจแแฃแซแแแแแแแ (แแฃแแแแช แแ แแแ แแแแกแขแแก แแแแ ) แกแแกแขแแแแจแ.
แกแฎแแแแ แจแแ แแก, แกแขแแขแแ แแแงแแ แแแ แแแแคแแ แแแชแแแก แแแฎแกแแแแแแแก โOn Guard for Rootkits: Intel BootGuardโ
Firmware แแแแแแฃแขแแ แฃแแ แแแแขแคแแ แแแกแแแแก Intel 64 แแ แฅแแขแแฅแขแฃแ แแ
แแแกแแฌแงแแกแแกแแแแก, แแแแแ แแฃแแแกแฃแฎแแ แแแแฎแแแก: แ แ แแ แแก แแแแแแแแ แแแ แแแแแแฃแขแแ แฃแแ แแแแขแคแแ แแแก firmware Intel 64 แแ แฅแแขแแฅแขแฃแ แแ? แ แ แแฅแแ แฃแแแ, UEFI BIOS. แแแแ แแ แแก แแแกแฃแฎแ แแ แแฅแแแแ แแฃแกแขแ. แแแแแ แจแแแฎแแแแ แคแแแฃแ แแก, แ แแแแแแช แแแแฉแแแแแแก แแ แแ แฅแแขแแฅแขแฃแ แแก แแแกแแขแแแแก (แแแแขแแแแก) แแแ แกแแแก.
แกแแคแฃแซแแแแ แแ แแก แแแฃแแ:
- แแ แแชแแกแแ แ (CPU, Central Processing Unit), แ แแแแแกแแช แซแแ แแแแแ แแแ แแแแแแก แแแ แแ แแฅแแก แฉแแจแแแแแฃแแ แแ แแคแแแฃแแ แแแ แแแ (แแ แ แงแแแแ แแแแแแจแ) แแ แแแฎแกแแแ แแแแก แแแแขแ แแแแ แ (IMC, Integrated Memory Controller);
- แฉแแแกแแขแ (PCH, Platform Controller Hub), แ แแแแแแช แจแแแชแแแก แกแฎแแแแแกแฎแแ แแแแขแ แแแแ แแแก แแแ แแคแแ แแฃแ แแแฌแงแแแแแแแแแแแ แฃแ แแแแ แแแแแกแ แแ แฅแแแกแแกแขแแแแแแก แแแ แแแแกแแแแก. แแแ แจแแ แแก แแ แแก แชแแแแแแ Intel Management Engine (ME), แ แแแแแกแแช แแกแแแ แแฅแแก firmware (Intel ME firmware).
แแแแขแแแแแก, แแแ แแ แแแแแแฆแแแจแแฃแแแกแ, แกแแญแแ แแแแแ แแแขแแแ แแ แแแฃแ แแแแขแ แแแแ แก (ACPI EC, Advanced Control and Power Interface Embedded Controller), แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ แแแแแแก แฅแแแกแแกแขแแแแก แแฃแจแแแแแแ, แกแแแกแแ แฃแแ แแแแแแ, แแแแแแแขแฃแ แ, Fn แแแแแแจแแแ (แแแ แแแแก แกแแแแจแแแจแ, แฎแแแก แแแชแฃแแแแ, แแแแแแแขแฃแ แ). แแแแแแแแ แแ แ.แจ.) ) แแ แกแฎแแ. แแ แแแก แแกแแแ แแฅแแก แกแแแฃแแแ แ firmware.
แแแ แแแแ, แแแแแแฆแแแจแแฃแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแแแแชแแ แแ แแก แแแแแแฃแขแแ แฃแแ แแแแขแคแแ แแแก firmware (แกแแกแขแแแแก firmware), แ แแแแแแช แแแแฎแแแ แกแแแ แแ SPI แคแแแจ แแแฎแกแแแ แแแแแ. แแแแกแแแแแก, แ แแ แแ แแแฎแกแแแ แแแแก แแแแฎแแแ แแแแแแ แแ แแแแแแแ แกแแ แแแแก แแแแแ, แแ แแแฎแกแแแ แแแแก แจแแแแแ แกแ แแงแแคแ แจแแแแแ แ แแแแแแแแแ (แ แแแแ แช แแแฉแแแแแแแ แกแฃแ แแแแ):
- UEFI BIOS;
- ACPI EC firmware (แแแแแฉแแแ แชแแแแ แ แแแแแแ Skylake-แแก แแ แแชแแกแแ แแก แแแแ แแแ แฅแแขแแฅแขแฃแ แแกแแแ แแ แแแ (2015), แแแแ แแ แแฃแแแแแจแ แฉแแแ แฏแแ แแ แแแแแแฎแแแก แแแกแ แแแแแงแแแแแแก แแแแแแแแแแ, แแแแขแแ แฉแแจแแแแแฃแแ แแแแขแ แแแแ แแก firmware แแแแแ UEFI BIOS-แแก แแแฌแแแแ);
- Intel ME firmware;
- แฉแแจแแแแแฃแแ GbE (Gigabit Ethernet) แฅแกแแแแก แแแแแขแแ แแก แแแแคแแแฃแ แแชแแ (MAC แแแกแแแแ แแ แแ แ.แจ.);
- แคแแแจ แแแกแแ แแแขแแ แแแ - แคแแแจ แแแฎแกแแแ แแแแก แซแแ แแแแแ แ แแแแแแ, แ แแแแแแช แจแแแชแแแก แกแฎแแ แ แแแแแแแแแก แแแแแแแแแแก, แแกแแแ แแแแแ แฌแแแแแแก แแแแแ แแแแแก.
แ แแแแแแแแจแ แฌแแแแแแก แแแคแแ แแแชแแแชแแแก (แแแแแแแแฃแแ แแแแแ แแแแแแก แจแแกแแแแแแกแแ) แแฎแแ แชแแแแแแก SPI bus master - แฉแแแกแแขแจแ แฉแแจแแแแแฃแแ SPI แแแแขแ แแแแ แ, แ แแแแแก แแแจแแแแแแแแช แฎแแแแ แแ แแแฎแกแแแ แแแแก แฌแแแแแ. แแฃ แแแแแ แแแแแ แแแงแแแแแฃแแแ Intel-แแก แแแแ แ แแแแแแแแแแฃแ แแแแจแแแแแแแแแแ (แฃแกแแคแ แแฎแแแแแก แแแแแแแแแก แแแแ), แแแจแแ SPI flash-แแก แแแแแแฃแ แแแแฎแแแ แแแแแก แแฅแแก แกแ แฃแแ แฌแแแแแ (แฌแแแแแฎแแ/แฉแแฌแแ แ) แแฎแแแแ แแแแแก แ แแแแแแจแ. แแแแแ แฉแแแ แแ แแฎแแแแ แฌแแกแแแแแฎแแ แแ แแแฃแฌแแแแแแแแ. แชแแแแแแ แคแแฅแขแ: แแแแ แกแแกแขแแแแแ CPU-แก แแฅแแก แกแ แฃแแ แฌแแแแแ UEFI BIOS-แแ แแ GbE-แแ, แฌแแแแแฎแแแก แฌแแแแแ แแฎแแแแ แคแแแจ แแแกแแ แแแขแแ แแแแ แแ แกแแแ แแแ แแ แแฅแแก แฌแแแแแ Intel ME แ แแแแแแจแ. แ แแขแแ แแแแ แ แแ แแ แ แงแแแแ? แ แแช แ แแแแแแแแแ แแแฃแแแ แแ แฉแแแแแแ. แแแฌแแ แแแแแแ แแแแแแแแแแแ แกแขแแขแแแจแ แแแแแงแแแแแ.
แแแแแแฃแขแแ แฃแแ แแแแขแคแแ แแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแคแแแแชแแแกแแแ แแแชแแแก แแแฅแแแแแแแแ
แชแฎแแแแ, แแแแแแฃแขแแ แฃแแ แแแแขแคแแ แแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แแแชแฃแแ แฃแแแ แแงแแก แจแแกแแซแแ แแแแแ แแแแกแแกแแแแ, แ แแช แแแขแแแชแแฃแ แแแแแแแกแฎแแแแก แกแแจแฃแแแแแแก แแแกแชแแแก แแแกแจแ แแแแแแแแแ แแก แคแแฎแ (แแแแแ แฉแแแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแแฎแแแแแแ/แแแกแขแแแแชแแแแ), แจแแแกแ แฃแแแก แแแแ แแแแ แงแแแแแแ แแ แแแแแแแแ แแแฃแ แ แแแแแแแจแ แแ แ.แจ. แแ SPI แคแแแจ แแแฎแกแแแ แแแแก แ แแแแแแแแจแ แฌแแแแแแก แแแแแแแขแแชแแ, แ แ แแฅแแ แฃแแแ, แแ แแ แแก แกแแแแแ แแกแ. แแแแขแแ, แกแฎแแแแแกแฎแแ แแแฅแแแแแแแแ, แ แแแแแแแช แกแแแชแแคแแแฃแ แแ แแแแแแฃแแ แแฆแกแ แฃแแแแแก แแแ แแแแกแแแแก, แแแแแแงแแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แชแแแแแแแแแแกแแแ แแแกแแชแแแแ.
แแแ แแแแ, Intel ME firmware แฎแแแแแฌแแ แแแแ แแแแแแแแแแกแ แแ แแแแแแขแฃแ แแแแก แแแแขแ แแแแกแแแแก แแ แแแฌแแแแแ ME แแแแขแ แแแแ แแก แแแแ แงแแแแ แฏแแ แแ, แ แแแแกแแช แแก แแขแแแ แแแแ ME UMA แแแฎแกแแแ แแแแจแ. แแก แแแแแแแฌแแแแแก แแ แแชแแกแ แฃแแแ แแแแแแฎแแแแ แฉแแแ แแแแ แแ แ-แแ แแจแ
แแ ACPI EC firmware, แ แแแแ แช แฌแแกแ, แแแฌแแแแแ แแฎแแแแ แแแแแแแแแแกแแแแก. แแฃแแชแ, แแแแก แแแแ, แ แแ แแก แแ แแแแแ แจแแแแก UEFI BIOS-แจแ, แแแ แแแแฅแแแก แงแแแแแแแแก แแฅแแแแแแแแ แแแ แแแแแ แแแชแแแก แแแฅแแแแแแแแก, แ แแแแแแกแแช แแงแแแแแก UEFI BIOS. แแแแแ แแแกแแฃแแ แแ แแแแแ.
แแก แแแฅแแแแแแแแ แจแแแซแแแแ แแแแงแแก แแ แแแขแแแแ แแแ.
แฉแแฌแแ แแ แแแชแแ UEFI BIOS แ แแแแแแจแ
- SPI แคแแแจ แแแฎแกแแแ แแแแก แจแแแแแแกแแก แคแแแแแฃแ แ แแแชแแ แฉแแฌแแ แแก แแแแชแแแ แฏแแแแ แแ;
- แแ แแชแแกแแ แแก แแแกแแแแ แแแแแก แกแแแ แชแแจแ UEFI BIOS แ แแแแแแแก แแ แแแฅแชแแแก แแแชแแ แฉแแแกแแขแแก PRx แ แแแแกแขแ แแแแก แแแแแงแแแแแแ;
- UEFI BIOS แ แแแแแแจแ แฉแแฌแแ แแก แแชแแแแแแแแแก แแแแแแแแ แจแแกแแแแแแกแ SMI แจแแคแแ แฎแแแแก แแแแแ แแ แแแแ แแ แแแแฃแจแแแแแแ แฉแแแกแแขแแก แ แแแแกแขแ แแแจแ BIOS_WE / BLE แแ SMM_BWP แแแขแแแแก แแแงแแแแแแ;
- แแ แแแชแแแก แฃแคแ แ แแแฌแแแแแ แแแ แกแแแ Intel BIOS Guard (PFAT).
แแ แแแฅแแแแแแแแแก แแแ แแ, แแแแแญแ แแแแก แจแแฃแซแแแแ แจแแแแฃแจแแแ แแ แแแแแฎแแ แชแแแแแ แกแแแฃแแแ แ แฃแกแแคแ แแฎแแแแแก แแแแแแ (แแแแแแแแแ, แแแคแกแฃแแแแแก แฎแแแแแฌแแ แ UEFI BIOS แแแแแฎแแแแแแแ).
แแแแจแแแแแแแแแแ แแฆแแแแจแแแก, แ แแ แแแแแ แแขแฃแ แกแแกแขแแแแแ (แแแแแแแแแแฃแแแ แแแแงแแแแแแแ) แงแแแแ แแแแแ แฉแแแแแแแแแ แแแแชแแแ แแแฅแแแแแแ แจแแแซแแแแ แแ แแงแแก แแแแแงแแแแแฃแแ, แแกแแแ แจแแแซแแแแ แกแแแ แแแ แแ แแงแแก แแแแแงแแแแแฃแแ แแ แแแฃแชแแแแแ แแแแฎแแ แชแแแแแแก. แแ แแแฅแแแแแแแแแกแ แแ แแแแ แแแแฎแแ แชแแแแแแแก แแแแแ แแแแก แจแแกแแฎแแ แแแขแ แจแแแแซแแแแ แฌแแแแแแฎแแ แแฅ
UEFI BIOS แแแแแแขแแคแแแแชแแแก แจแแแแฌแแแแ
แ แแแแกแแช แแกแแฃแแ แแแ แกแแแแ แฉแแขแแแ แแแแก แขแแฅแแแแแแแแแแ, แแแ แแแแ แ แแช แแแฎแกแแแแแแ แแ แแก แฃแกแแคแ แแฎแ แฉแแขแแแ แแแ. แแฃแแชแ, แแ แฅแแขแแฅแขแฃแ แฃแแแ, แแก แจแแฅแแแแแแ UEFI BIOS-แแก แแแ แ แแแแแแแแแขแแแแก แแแแแแขแแคแแแแชแแแกแแแแก (แแ แแแแแ แแแ, แแขแแแ แแแแแแ แแ แ.แจ.) แแ แแ แ แแแแแ firmware.
แแแแขแแ, Intel-แแ SoC-แแแจแ Bay Trail แแแแ แแแ แฅแแขแแฅแขแฃแ แแ (2012) แแแแแ แแ แขแแฅแแแแแก แจแแฃแชแแแแแ Secure Boot (Verified Boot), แ แแแแแกแแช แแ แแคแแ แ แแฅแแก แกแแแ แแ แแแแแฎแกแแแแแฃแ Secure Boot แขแแฅแแแแแแแแกแแแ. แแแแแแแแแแแ (2013) แแก แแแฅแแแแแแ แแแฃแแฏแแแแกแแ แแ, แกแแฎแแแฌแแแแแแ Intel Boot Guard, แแแแแแแแ แแแกแแขแแแแกแแแแก Haswell-แแก แแแแ แแแ แฅแแขแแฅแขแฃแ แแ.
แกแแแแ Intel Boot Guard-แก แแฆแแฌแแ แ, แแแแแ แจแแแฎแแแแ แแแจแแแแแก แแแ แแแแแแก Intel 64 แแ แฅแแขแแฅแขแฃแ แแจแ, แ แแแแแแแช แแแแแแแแชแแแ แแ แแก แกแแแแ แฉแแขแแแ แแแแก แขแแฅแแแแแแแแก แแแแแแก แกแแคแฃแซแแแแ.
Intel CPU
Cap แแแ แแฃแแแแก, แ แแ แแ แแชแแกแแ แ แแ แแก แแแแแแ แ แจแแกแ แฃแแแแแก แแแ แแแ Intel 64 แแ แฅแแขแแฅแขแฃแ แแจแ. แ แแขแแ แแ แแก แแก แแกแแแ แแแแแแก แกแแคแฃแซแแแแ? แแแแแแแก, แ แแ แแก แแ แแก แจแแแแแแ แแแแแแแขแแแแก แคแแแแ, แ แแช แแแก แแกแ แฎแแแก:
- Microcode ROM แแ แแก แแ แแกแขแแแแแฃแ แ, แแแแแฌแแ แแแ แแแฎแกแแแ แแแ แแแแ แแแแแแก แจแแกแแแแฎแแ. แแแแแแแ, แ แแ แแแแ แแแแแ แแ แแก แแ แแชแแกแแ แแก แแแกแขแ แฃแฅแชแแแก แกแแกแขแแแแก แแแแฎแแ แชแแแแแแ แฃแแแ แขแแแแก แแแกแขแ แฃแฅแชแแแแแ. แแแแ แแแแแจแแช แฎแแแแ
แจแแชแแแแแแ . แแกแ แ แแ, BIOS-แจแ แจแแแแซแแแแ แแแแแแ แแแแแ แแแ แแแแ แแแแแแก แแแแแฎแแแแแแแ (แแกแแแ แแแแแขแแแ แแฃแแแ แฉแแขแแแ แแแแก แแ แแก, แ แแแแแ ROM-แแก แแแแแฌแแ แ แจแแฃแซแแแแแแแ). แแ แแแแแ แแแแก แจแแแแแ แกแ แแแจแแคแ แฃแแแ, แ แแช แแแแจแแแแแแแแแ แแ แแฃแแแแก แแแแแแแก (แแฅแแแแ แแแแแแแแแแ แ, แแแแ แแแแแแก แกแแแชแแคแแแฃแ แ แจแแแแแ แกแ แชแแแแแแแ แแฎแแแแ แแแแแแแก, แแแแช แแแก แแแแแแ แแแก) แแ แฎแแแแแฌแแ แแแแ แแแแแแแแแแกแ แแ แแแแแแขแฃแ แแแแก แแแกแแแแแขแ แแแแแแแ; - AES แแแกแแฆแแแ แแแแ แแแแแแก แแแแแฎแแแแแแแก แจแแแแแ แกแแก แแแจแแคแแ แแกแแแแก;
- RSA แกแแฏแแ แ แแแกแแฆแแแแก แฐแแจแ, แ แแแแแแช แแแแฌแแแแก แแแแ แแแแแแก แแแแแฎแแแแแก แฎแแแแแฌแแ แแก;
- RSA แกแแฏแแ แ แแแกแแฆแแแแก แฐแแจแ, แ แแแแแแช แแแแฌแแแแก Intel-แแก แแแแ แจแแแฃแจแแแแแฃแแ ACM (Authenticated Code Module) แแแแแก แแแแฃแแแแแก แฎแแแแแฌแแ แแก, แ แแแแแแแช CPU-แก แจแแฃแซแแแ แแแฃแจแแแก BIOS-แแก แแแฌแงแแแแแแ (แแแแแ แฏแแแ แแแแ แแแแแ) แแ แแแกแ แแฃแจแแแแแก แแ แแก, แ แแแแกแแช แฎแแแแ แแแ แแแแฃแแ แแแแแแแแแ.
Intel ME
แฉแแแแก แแแแแจแ แแก แฅแแแกแแกแขแแแ แแแแซแฆแแแ
แกแแแแฃแแแแแแแก แแแฃแฎแแแแแแ, Intel ME แแกแแแ แแ แแก แแแแแแก แกแแคแฃแซแแแแ, แ แแแแแ แแแก แแฅแแก:
- ME ROM - แแ แแกแขแแแแแฃแ แ, แแแแแฌแแ แแแ แแแฎแกแแแ แแแ (แแ แแ แแก แแแฌแแแแแฃแแ แแแแแฎแแแแแก แแแแแแ), แ แแแแแแช แจแแแชแแแก แแแฌแงแแแแก แแแแก, แแกแแแ RSA แกแแฏแแ แ แแแกแแฆแแแแก SHA256 แฐแแจแก, แ แแแแแแช แแแแฌแแแแก Intel ME firmware-แแก แฎแแแแแฌแแ แแก;
- AES แแแกแแฆแแแ แกแแแแฃแแแ แแแคแแ แแแชแแแก แจแแกแแแแฎแแ;
- แฌแแแแแ แกแแแ แแแแแแ (FPFs, Field Programmable Fuses) แแแขแแแ แแ แแแฃแแ แฉแแแกแแขแจแ แแแ แแแแฃแแ แแแคแแ แแแชแแแก แแฃแแแแแ แจแแแแฎแแแกแแแแก, แแแ แจแแ แแก แแแแแแฃแขแแ แฃแแ แกแแกแขแแแแก แแแแงแแแแแแแก แแแแ แแแแแแแแฃแ แแแคแแ แแแชแแแก.
Intel Boot Guard 1.x
แแชแแ แ แฃแแ แ แแแกแฃแฎแแกแแแแแแแแแแ. Intel Boot Guard แขแแฅแแแแแแแแก แแแ แกแแแแแก แแแแ แแแ, แ แแแแแกแแช แฉแแแ แแแงแแแแแ แแ แกแขแแขแแแจแ, แแ แแก แแแแแแแแฃแ แ แแ แจแแแซแแแแ แแ แฐแฅแแแแแก แ แแแแ แแแแจแแ แ Intel-แแก แจแแแ แแแแฃแแแแขแแชแแแจแ แแแแแงแแแแแฃแ แแฃแแแ แแชแแแกแแแ. แแแ แแ แแแแกแ, แแฅ แแแชแแแฃแแ แแ แขแแฅแแแแแแแแก แแแแแ แแแแก แจแแกแแฎแแ แแแคแแ แแแชแแ แแแฆแแแฃแแ แแฅแแ แกแแแแ แแกแแแ แ แแแแแแแ แแแก แแ แแก แแ แจแแแซแแแแ แจแแแชแแแแแก แฃแแฃแกแขแแแแแก Intel Boot Guard-แแก แกแแแชแแคแแแแชแแแกแแแ แจแแแแ แแแแ, แ แแแแแแช แแแแแแแแ แกแแแแ แแฃแแแ, แ แแ แแแแกแแ แแแแแฅแแแงแแแแก.
แแกแ แ แแ, Intel Boot Guard (BG) แแ แแก แแแแ แแขแฃแ แแก แแฎแแ แแแญแแ แแแ UEFI BIOS แแแแแแขแแคแแแแชแแแก แขแแฅแแแแแแแ. แแแแกแฏแแแแแ แฌแแแแจแ แแแกแ แแชแแ แ แแฆแฌแแ แแแแแแ [Platform Embedded Security Technology Revealed, Chapter Boot with Integrity, or Not Boot], แแก แแฃแจแแแแก แ แแแแ แช แกแแแแ แฉแแขแแแ แแแแก แฏแแญแแ. แแ แแแกแจแ แแแ แแแแ แแแฃแแ แแ แแก แฉแแขแแแ แแแแก แแแแ (แแแแ แแแแแ) CPU-แก แจแแแแแ, แ แแแแแแช แแแแแฌแแแฃแแแ RESET แแแแแแแแ (แแ แฃแแแ แแแแแ แแแก BIOS-แแก RESET แแแฅแขแแ แแแ!). CPU แแแฃแแแแก แแแแแก แแแแฃแแก (Intel BG startup ACM) แจแแแฃแจแแแแแฃแแ แแ แฎแแแแแฌแแ แแแ Intel-แแก แแแแ SPI แคแแแจ แแแฎแกแแแ แแแแแ, แแขแแแ แแแแก แแแก แแแแแก แฅแแจแจแ, แแแแฌแแแแก (แแแแแ แฃแแแ แแฆแแแแจแแ, แ แแ CPU-แก แแฅแแก แกแแฏแแ แ แแแกแแฆแแแแก แฐแแจแ, แ แแแแแแช แแแแฌแแแแก ACM แฎแแแแแฌแแ แแก. ) แแ แแฌแงแแแ.
แแแแแก แแก แแแแฃแแ แแแกแฃแฎแแกแแแแแแแแ UEFI BIOS-แแก แแชแแ แ แกแแฌแงแแกแ แแแฌแแแแก แแแแแแแฌแแแแแแ - Initial Boot Block (IBB), แ แแแแแแช, แแแแแก แแฎแ แแ, แจแแแชแแแก UEFI BIOS-แแก แซแแ แแแแแ แแแฌแแแแก แแแแแแแฌแแแแแก แคแฃแแฅแชแแแก. แแแ แแแแ, Intel BG แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแแฌแแแ BIOS-แแก แแแแแแขแฃแ แแแ OS-แแก แฉแแขแแแ แแแแแแ (แ แแแแแแช แจแแแซแแแแ แจแแกแ แฃแแแแก Secure Boot แขแแฅแแแแแแแแก แแแแแแฎแแแแแแแแแ).
Intel BG แขแแฅแแแแแแแ แฃแแ แฃแแแแแงแแคแก แแฃแจแแแแแก แแ แ แแแแแก (แแ แแ แแ แแ แแ แแแ แแแแ แแก, แแแฃ แแ แแแ แ แแแแแ แจแแแซแแแแ แฉแแ แแแ แกแแกแขแแแแจแ แแ แแ แแแ แแแแแ แแแ).
แแแแแแแแ แฉแแฅแแ
แแแแแแแแ แฉแแขแแแ แแแแก (MB) แ แแแแแจแ, แแแแแแฃแแ แฉแแขแแแ แแแแก แแแแแแแแแขแ (แแแฌแงแแแฃแแ CPU แฉแแขแแแ แแแแก ROM-แแ) "แแแแแแก" แจแแแแแแก แกแแแแ แแแแขแคแแ แแแก แแแแฃแแแก (TPM) แจแแกแแซแแแแแแแแแแก แแแแแงแแแแแแ. แแแแช แแ แแชแแก, แแแแ แแแแแชแแ แแแแฎแกแแแ.
TPM-แก แแฅแแก PCR-แแแ (แแแแขแคแแ แแแก แแแแคแแแฃแ แแชแแแก แ แแแแกแขแ แแแ), แ แแแแแแแช แฉแแฌแแ แแ แฐแแจแแ แแแแก แแแแ แแชแแแก แจแแแแแก แคแแ แแฃแแแก แแแฎแแแแแ:
แแแแ. แแแแแแแแแแแ PCR แแแแจแแแแแแแ แแแแแแแแแแฃแแแ แฌแแแแแ แแ แแก แ แแแแกแขแ แแแ แแแแแขแแแ แแฃแแแ แแฎแแแแ แแแจแแ, แ แแแแกแแช แกแแกแขแแแ แแแแแขแแแ แแฃแแแ.
แแแ แแแแ, MB แ แแแแแจแ, แแ แแแก แแแ แแแแฃแ แแแแแแขแจแ, PCR-แแแ แแกแแฎแแแก แฃแแแแแแฃแ (แฐแแจแแก แแแแ แแชแแแก แจแแกแแซแแแแแแแแแแก แคแแ แแแแแจแ) แแแแแก แแ แแแแแชแแแแแแก "แแแแแแแแ" แแแแแขแแคแแแแขแแ แก. PCR แแแแจแแแแแแแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแแแแ แแ แแแแแชแแแแแแก (TPM_Seal) แแแแ แแชแแแก แแแจแแคแแ แแจแ. แแแแก แจแแแแแ, แแแแ แแแจแแคแแ แ (TPM_Unseal) แจแแกแแซแแแแแแ แแฅแแแแ แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ PCR แแแแจแแแแแแแแแ แแ แจแแชแแแแแ แแแขแแแ แแแแก แจแแแแแแ (แแแฃ แแ แช แแ แแ โแแแแแแแแโ แแแแแแแแแขแ แแ แจแแชแแแแแ).
แแแแแฌแแแแฃแแ แฉแแขแแแ แแแ
แงแแแแแแ แกแแจแแแแแ แแแแแแแก, แแแกแแช UEFI BIOS-แแก แจแแชแแแ แแแกแฌแแแก, แแ แแก Verified Boot (VB) แ แแแแแ, แ แแแแแจแแช แแแแแแฃแแ แฉแแขแแแ แแแแก แแแแแแแแแขแ แแ แแแขแแแ แแคแแฃแแแ แแแแฌแแแแก แจแแแแแแแก แแแแแแแแแแกแ แแ แแแแแแขแฃแ แแแแก. แแ แแแ แแคแแแแชแแแก แจแแชแแแแแก แจแแแแฎแแแแแจแ (แแ แ-แแ แแ แจแแแแแแ) แฎแแแแ:
- แแแแแ แแแ แแ แแแ 1 แฌแฃแแแแแ 30 แฌแฃแแแแแ (แแกแ, แ แแ แแแแฎแแแ แแแแแก แแฅแแก แแ แ, แแแแแแก, แ แแขแแ แแ แฉแแแขแแแ แแแแ แแแกแ แแแแแแฃแขแแ แ แแ, แแฃ แแก แจแแกแแซแแแแแแแ, แจแแแชแแแแ BIOS-แแก แแฆแแแแแแก);
- แแแฃแงแแแแแแแแ แแแแแ แแแ (แแกแ, แ แแ แแแแฎแแแ แแแแแก แแ แฐแฅแแแแแก แแ แ, แ แแ แแแแแแก แแ, แฃแคแ แ แแแขแแช, แแแแแแแแก);
- แกแแแฃแจแแแก แแแแ แซแแแแแ แกแฌแแ แ แกแแฎแแ (แจแแแแฎแแแแ, แ แแแแกแแช แฃแกแแคแ แแฎแแแแแก แแ แ แแ แแ แแก, แ แแแแแ แฃแคแ แ แแแแจแแแแแแแแแ แกแแฅแแแแแแ แแแกแแแแแแแแแ).
แแแฅแแแแแแแก แแ แฉแแแแแ แแแแแแแแแแฃแแแ แแแแแแแแฃแ Intel BG แแแแคแแแฃแ แแชแแแแ (แแแ แซแแ, แ.แฌ. แแฆแกแ แฃแแแแแก แแแแแขแแแแแ), แ แแแแแแช แแฃแแแแแแ แแ แแก แฉแแฌแแ แแแ แแแแแแฃแขแแ แฃแแ แแแแขแคแแ แแแก แแแแงแแแแแแแก แแแแ แกแแแชแแแแฃแ แแ แจแแฅแแแแ แกแแชแแแจแ - แฉแแแกแแขแแก แคแฃแแแแ (FPF). แแ แกแแแแแฎแแ แฃแคแ แ แแแขแแแฃแ แแ แแแแแแแแแแแ แแแกแแฃแแ แแแ.
แแแแคแแแฃแ แแชแแแก แแแ แแ, แแแแงแแแแแแ แฅแแแแก แแ RSA 2048 แแแแแแจแก แแ แฅแแแแก แแแแแชแแแแ แแ แกแขแ แฃแฅแขแฃแ แแก (แแแฉแแแแแแแ แกแฃแ แแแแ):
- แแแแงแแแแแแแก แซแแ แแฃแแ แแแกแแฆแแแแก แแแแแคแแกแขแ (KEYM, OEM Root Key Manifest), แ แแแแแแช แแงแแแแแก แแ แแแแแคแแกแขแแก SVN-แก (แฃแกแแคแ แแฎแแแแแก แแแ แกแแแก แแแแแ แก), แจแแแแแแ แแแแแคแแกแขแแก แกแแฏแแ แ แแแกแแฆแแแแก SHA256 แฐแแจแก, RSA แกแแฏแแ แ แแแกแแฆแแแก (แแแฃ แกแแฏแแ แ แแแฌแแแก. แแแแงแแแแแแแก root แแแกแแฆแแแ) แแ แแแแแคแแกแขแแก แฎแแแแแฌแแ แแกแ แแ แแแแแ แฎแแแแแฌแแ แแก แแแกแแแแกแขแฃแ แแแแแ;
- IBB Manifest (IBBM, Initial Boot Block Manifest), แ แแแแแแช แแงแแแแแก แแ แแแแแคแแกแขแแก SVN-แก, IBB-แแก SHA256 แฐแแจแก, แแ แแแแแคแแกแขแแก แฎแแแแแฌแแ แแก แแแแแแแฌแแแแแก แกแแฏแแ แ แแแแแแจแก แแ แแแแแ แฎแแแแแฌแแ แแก.
OEM Root Key-แแก SHA256 แฐแแจแ แแฃแแแแแแ แแ แแก แฉแแฌแแ แแแ แฉแแแกแแขแแก แคแฃแแแแแ (FPF), แแกแแแ แ แแแแ แช Intel BG แแแแคแแแฃแ แแชแแแจแ. แแฃ Intel BG แแแแคแแแฃแ แแชแแ แแแแแแแกแฌแแแแแก แแ แขแแฅแแแแแแแแก แฉแแ แแแแก, แแแจแแ แแแแแ แแแแ แแ แกแแกแขแแแแก แแฎแแแแ OEM Root Key-แแก แแแ แแแ แแแฌแแแแก แแคแแแแแแก แจแแฃแซแแแ BIOS-แแก แแแแแฎแแแแ (แแแฃ แจแแซแแแแก แแ แแแแแคแแกแขแแแแก แฎแแแแฎแแ แแแแแแแแแก), แ.แ. แแแแงแแแแแแ.
แ แแแแกแแช แกแฃแ แแแก แฃแงแฃแ แแ, แแแจแแแแ แฉแแแแแ แแญแแ แแกแแแ แแ แซแแแ แแแแแแแฌแแแแแก แฏแแญแแแก แกแแญแแ แแแแแก แจแแกแแฎแแ - แจแแแแซแแ แแแแแแงแแแแแแแ แแ แแ แแแแแคแแกแขแ. แ แแขแแ แแ แแฃแแแแก?
แกแแแแแแแแแแจแ, Intel แแแแแแ แแ แแซแแแแก แแแแงแแแแแแก แจแแกแแซแแแแแแแแก แแแแแแงแแแแก แกแฎแแแแแกแฎแแ IBB แแแแแแจแแแ แกแฎแแแแแกแฎแแ แแ แแแฃแฅแขแแก แฎแแแแกแแแแก แแ แแ แแ, แ แแแแ แช root. แแฃ IBB แแแกแแฆแแแแก แแแ แแแ แแแฌแแแ (แ แแแแแแช แฎแแแก แแฌแแ แก แแแแ แ แแแแแคแแกแขแก) แแแแแแ, แแแชแแแแแขแ แแแแฅแแแแแแก แแฎแแแแ แแ แ แแ แแแฃแฅแขแแก แฎแแแแ แแ แแฎแแแแ แแแแแ, แกแแแแ แแแแงแแแแแแ แแ แแแแแแแฃแจแแแแแก แแฎแแ แฌแงแแแแก แแ แแ แฉแแ แแแแก แฎแแแแฎแแ แแแแแแแแแ แแแแแคแแกแขแแแก BIOS-แแก แจแแแแแ แแแแแฎแแแแแจแ.
แแแแ แแ แแฃ root แแแกแแฆแแแ แแแขแแฎแแแแ (แ แแแแแแแช แฎแแแแแฌแแ แแแแ แแแ แแแแ แแแแแคแแกแขแ), แแแกแ แฉแแแแชแแแแแ แจแแฃแซแแแแแแ แแฅแแแแ, แแแฃแฅแแแแแก แแ แแชแแแฃแ แ แแ แแ แแก แแแแแแแแกแฌแแแแแฃแแ. แแ แแแกแแฆแแแแก แกแแฏแแ แ แแแฌแแแแก แฐแแจแ แแ แแฎแแ แแ แกแแแฃแแแแแ แแแแ แแแ แแแแแแ FPF-แแแจแ.
Intel Boot Guard แแแแคแแแฃแ แแชแแ
แแฎแแ แแแแแ แฃแคแ แ แแฎแแแก แแแแแแฎแแแแ Intel BG แแแแคแแแฃแ แแชแแแก แแ แแแกแ แจแแฅแแแแก แแ แแชแแกแก. แแฃ แแแแแแแ แแแแแ Flash Image Tool-แแก แจแแกแแแแแแก แฉแแแแ แแก Intel System Tool Kit-แแแ (STK), แจแแแแฉแแแแ, แ แแ Intel BG แแแแคแแแฃแ แแชแแ แจแแแชแแแก แแแแงแแแแแแแก root แแแกแแฆแแแแก แกแแฏแแ แ แแแฌแแแแก แฐแแจแก, แ แแแแแแแแ แแฃแแแแแแแก. แฆแแ แแแฃแแแแแแ แแ แ.แจ. Intel BG แแ แแคแแแ.
แแ แแ แแคแแแแก แกแขแ แฃแฅแขแฃแ แ:
typedef struct BG_PROFILE
{
unsigned long Force_Boot_Guard_ACM : 1;
unsigned long Verified_Boot : 1;
unsigned long Measured_Boot : 1;
unsigned long Protect_BIOS_Environment : 1;
unsigned long Enforcement_Policy : 2; // 00b โ do nothing
// 01b โ shutdown with timeout
// 11b โ immediate shutdown
unsigned long : 26;
};
แแแแแแแ, Intel BG แแแแคแแแฃแ แแชแแ แซแแแแแ แแแฅแแแแ แแแ แแ. แแแแแแฎแแแแ, แแแแแแแแแ, Force_Boot_Guard_ACM แแ แแจแ. แ แแแแกแแช แแก แแแกแฃแคแแแแแแแ, แแฃ BG แแแจแแแแแก ACM แแแแฃแแ SPI แคแแแจแแ แแแ แแแแซแแแแ, แกแแแแ แฉแแขแแแ แแแ แแ แแแฎแแแแ. แแ แแกแแแแ แแฅแแแแ.
แฉแแแ แฃแแแ แแแแฌแแ แแ แแแแแ, แ แแ VB แ แแแแแแก แแฆแกแ แฃแแแแแก แแแแแขแแแ แจแแแซแแแแ แแงแแก แแแแคแแแฃแ แแ แแแฃแแ แแกแ, แ แแ แแฃ แแแ แแคแแแแชแแ แแแ แแแฎแแ แฎแแ, แแแแแ แแแฎแแแแ แแ แแกแแแแ แฉแแแแขแแแ แแแ.
แแแแขแแแแ แแกแแแแกแ แ แแ แแแแงแแแแแแแแก...
แแ แแแ แแแแก GUI แแแแแแแแแ แจแแแแแ "แแแ" แแ แแคแแแแแก:
แแแแแ แ
แ แแแแแ
แแฆแฌแแ แ
0
No_FVME
Intel BG แขแแฅแแแแแแแ แแแแแ แแฃแแแ
1
VE
VB แ แแแแแ แฉแแ แแฃแแแ, แแแแแ แแแ แแแแแแแ
2
VME
แแ แแแ แ แแแแแ แฉแแ แแฃแแแ (VB แแ MB), แแแแแ แแแ แแ แแแ
3
VM
แแ แแแ แ แแแแแ แฉแแ แแฃแแแ แกแแกแขแแแแก แแแแแ แแแแก แแแ แแจแ
4
แฎแฃแแ
แฉแแ แแฃแแแ VB แ แแแแแ, แแงแแกแแแ แ แแแแแ แแแ
5
FVME
แแ แแแ แ แแแแแ แฉแแ แแฃแแแ, แแงแแกแแแ แ แแแแแ แแแ
แ แแแแ แช แฃแแแ แแฆแแแแจแแแ, Intel BG แแแแคแแแฃแ แแชแแ แแ แแฎแแ แแ แกแแแฃแแแแแ แฃแแแ แฉแแแฌแแ แแก แกแแกแขแแแแก แแแแงแแแแแแแ แฉแแแกแแขแแก แคแฃแแแแจแ (FPF) - แแชแแ แ (แแแฃแแแฌแแแแแแ แแแคแแ แแแชแแแก แแแฎแแแแแ, แแฎแแแแ 256 แแแแขแ) แแแแ แแขแฃแ แแก แแแคแแ แแแชแแแก แจแแแแฎแแ แฉแแแกแแขแแก แจแแแแแ, แ แแแแแแช แจแแแซแแแแ แแแแ แแแ แแแแแก แแแ แแ. Intel-แแก แกแแฌแแ แแแ แแแแแฅแขแแแแ (แแแแขแแแแช แแแแแก แแ แแแ แแแแ แแแแแ แกแแแ แแแแแ).
แแก แจแแกแแแแจแแแแแ แแแแคแแแฃแ แแชแแแก แจแแกแแแแฎแแ, แ แแแแแ:
- แแฅแแก แแ แแฏแแ แแแ แแ แแแ แแแแ แแแแแ แแแแแชแแแแ แจแแแแฎแแแก แแ แ (แแฎแแแแ แแฅ, แกแแแแช แแฌแแ แแแ Intel BG แแแแคแแแฃแ แแชแแ);
- แแฎแแแแ Intel ME-แก แจแแฃแซแแแ แแแกแ แฌแแแแแฎแแ แแ แแแแ แแแ แแแแแ.
แแกแ แ แแ, แแแแกแแแแแก, แ แแ แแแแงแแแแ Intel BG แขแแฅแแแแแแแแก แแแแคแแแฃแ แแชแแ แแแแแ แแขแฃแ แกแแกแขแแแแแ, แแแแงแแแแแแ แแแแแแแก แจแแแแแแก แฌแแ แแแแแแก แแ แแก:
- Flash Image Tool-แแก แแแแแงแแแแแแ (Intel STK-แแแ), แฅแแแแก firmware แกแฃแ แแแก แแแชแแแฃแแ Intel BG แแแแคแแแฃแ แแชแแแ, แ แแแแ แช แชแแแแแแแ Intel ME แ แแแแแแจแ (แ.แฌ. แแ แแแแแแ แกแแ แแ FPF-แแแแกแแแแก);
- Flash Programming Tool-แแก แแแแแงแแแแแแ (Intel STK-แแแ) แฌแแ แก แแ แกแฃแ แแแก แกแแกแขแแแแก SPI แคแแแจ แแแฎแกแแแ แแแแจแ แแ แฎแฃแ แแแก แ.แฌ. แฌแแ แแแแแแก แ แแแแแ (แแ แจแแแแฎแแแแแจแ, แจแแกแแแแแแกแ แแ แซแแแแแ แแแแแแแแแ Intel ME-แแ).
แแ แแแแ แแชแแแแแก แจแแแแแแ, Intel ME แแแแแกแชแแแก FPF-แแแก แแแชแแแฃแ แแแแจแแแแแแแแแก แกแแ แแแแแ FPF-แแแแกแแแแก ME แ แแแแแแจแ, แแแแงแแแแแก แแแแแ แแแแแก SPI แคแแแจ แแฆแฌแแ แแแจแ Intel-แแก แแแแ แ แแแแแแแแแแฃแ แแแแจแแแแแแแแแแ (แแฆแฌแแ แแแแ แแแกแแฌแงแแกแจแ. แกแขแแขแแ) แแ แจแแแกแ แฃแแแ แกแแกแขแแแแก RESET.
Intel Boot Guard แแแแฎแแ แชแแแแแแแก แแแแแแแ
แแ แขแแฅแแแแแแแแก แแแแฎแแ แชแแแแแแแก แแแแแ แแขแฃแ แแแแแแแแแ แแแกแแแแแแแแแแแแ, แฉแแแ แจแแแแแแฌแแแ แจแแแแแแ แกแแกแขแแแแแ Intel BG แขแแฅแแแแแแแแก แแแแแแกแแแแก:
แกแแกแขแแแแก
แจแแแแจแแแ
แแแแแแแแขแ GA-H170-D3H
Skylake, แแ แแก แแฎแแ แแแญแแ แ
แแแแแแแแขแ GA-Q170-D3H
Skylake, แแ แแก แแฎแแ แแแญแแ แ
แแแแแแแแขแ GA-B150-HD3
Skylake, แแ แแก แแฎแแ แแแญแแ แ
MSI H170A Gaming Pro
Skylake, แแ แแแแแ แ แแฎแแ แแแญแแ แ
Lenovo ThinkPad 460
Skylake, แแฎแแ แแแญแแ แ แฎแแแแแกแแฌแแแแแแ, แขแแฅแแแแแแแ แฉแแ แแฃแแแ
Lenovo Yoga X Prox
แฐแแกแฃแแ, แแ แแแแแ แ แแฎแแ แแแญแแ แ
Lenovo U330p
แฐแแกแฃแแ, แแ แแแแแ แ แแฎแแ แแแญแแ แ
โแแฎแแ แแแญแแ แโ แแแจแแแแก Intel BG แแแจแแแแแก ACM แแแแฃแแแก, แแแแแ แแแฎแกแแแแแ แแแแแคแแกแขแแแแกแ แแ แจแแกแแแแแแกแ แแแแแก แแ แกแแแแแแก BIOS-แจแ, แ.แ. แแแแฎแแ แชแแแแแแแแ แแแแแแแแกแแแแก.
แแแแแแแแแ, แแแแฆแแ แแคแแกแแแแ แแแแแแฌแแ แแแ. แแแแงแแแแแแแก แกแแแขแแก แกแฃแ แแแ SPI แคแแแจ แแแฎแกแแแ แแแแกแแแแก Gigabyte GA-H170-D3H (แแแ แกแแ F4).
Intel CPU แฉแแขแแแ แแแแก ROM
แแแ แแแ แ แแแจแ, แแแแแ แแแกแแฃแแ แแ แแ แแชแแกแแ แแก แแแฅแแแแแแแแแ, แแฃ แฉแแ แแฃแแแ Intel BG แขแแฅแแแแแแแ.
แแแจแแคแ แฃแแ แแแแ แแแแแแก แแแแฃแจแแแแก แแแซแแแแ แจแแฃแซแแแแแแ แแแฎแแ, แจแแกแแแแแแกแแ, แ แแแแ แฎแแ แชแแแแแแแ แฅแแแแแ แแฆแฌแแ แแแ แแแฅแแแแแแแแ (แแแแ แแแแจแ แแฃ แแแแ แแขแฃแ แแจแ) แฆแแ แแแแฎแแแ. แแแฃแฎแแแแแแ แแแแกแ, แแก แคแแฅแขแ, แ แแ แแแแแแแแ แแแ Intel แแ แแชแแกแแ แแแก โแจแแฃแซแแแแโ แจแแแกแ แฃแแแ แแก แฅแแแแแแแแ, แคแแฅแขแแ.
RESET แแแแแแแ แแแแแแแ แแแกแแแแก แจแแแแแ, แแ แแชแแกแแ แ (แ แแแแแก แแแกแแแแ แแแก แกแแแ แชแแจแ แฃแแแ แแแขแแแแแแ แคแแแจ แแแฎแกแแแ แแแแก แจแแแแแแกแ) แแแฃแแแแก FIT-แก (Firmware Interface Table). แแแกแ แแแแแ แแแ แขแแแแ, แแแกแแ แแแแแแแแ แแฌแแ แแแ แแแกแแแแ แแแ FFFF FFC0h.
แแ แแแแแแแแจแ แแก แแแกแแแแ แแ แจแแแชแแแก FFD6 9500h แแแแจแแแแแแแแก. แแ แแแกแแแแ แแแก แแแแ แฃแแแแแ, แแ แแชแแกแแ แ แฎแแแแแก FIT แชแฎแ แแแก, แ แแแแแก แจแแแแแ แกแ แแแงแแคแแแแ แฉแแแแฌแแ แแแแ. แแแ แแแแ แฉแแแแฌแแ แ แแ แแก แจแแแแแแ แกแขแ แฃแฅแขแฃแ แแก แกแแแแฃแ แ:
typedef struct FIT_HEADER
{
char Tag[8]; // โ_FIT_ โ
unsigned long NumEntries; // including FIT header entry
unsigned short Version; // 1.0
unsigned char EntryType; // 0
unsigned char Checksum;
};
แแแฃแ แแแแแแแ แแแแแแแก แแแแ, แกแแแแแขแ แแแ แฏแแแ แงแแแแแแแแก แแ แแ แแก แแแแแแแแแแ แแ แชแฎแ แแแแแจแ (แแแแ แแแ แฉแ แแฃแแ).
แแแ แฉแแแแแ แฉแแแแฌแแ แแแ แแแฃแแแแแแก แกแฎแแแแแกแฎแแ แแแแแ แแแแ, แ แแแแแแแช แฃแแแ แแงแแก แแแแแแแแแแแฃแแ/แจแแกแ แฃแแแแฃแแ BIOS-แแก แจแแกแ แฃแแแแแแแ, แ.แ. แแแแแแแแ แแแแแ RESET แแแฅแขแแ แแ แแแแแกแแแแแแ (FFFF FFF0h). แแแแแแฃแแ แแกแแแ แฉแแแแฌแแ แแก แกแขแ แฃแฅแขแฃแ แ แจแแแแแแแ:
typedef struct FIT_ENTRY
{
unsigned long BaseAddress;
unsigned long : 32;
unsigned long Size;
unsigned short Version; // 1.0
unsigned char EntryType;
unsigned char Checksum;
};
EntryType แแแแ แแแฃแแแแแแก แแแแแแก แขแแแแ, แ แแแแแแแช แแแฃแแแแแแก แแก แฉแแแแฌแแ แ. แฉแแแ แแแชแแ แ แแแแแแแแ แขแแแ:
enum FIT_ENTRY_TYPES
{
FIT_HEADER = 0,
MICROCODE_UPDATE,
BG_ACM,
BIOS_INIT = 7,
TPM_POLICY,
BIOS_POLICY,
TXT_POLICY,
BG_KEYM,
BG_IBBM
};
แแฎแแ แแจแแแ แแ, แ แแ แแ แ-แแ แแ แฉแแแแฌแแ แ แแแฃแแแแแแก Intel BG แแแจแแแแแก ACM แแแแแ แแก แแแแแแ แแแแแแ. แแ แแแแแ แแก แกแแแแฃแ แแก แกแขแ แฃแฅแขแฃแ แ แขแแแแฃแ แแ Intel-แแก แแแแ แจแแแฃแจแแแแแฃแแ แแแแแก แแแแฃแแแแแกแแแแก (ACM, แแแแ แแแแแแแแก แแแแแฎแแแแแแ, Intel ME แแแแแก แกแแฅแชแแแแ, ...).
typedef struct BG_ACM_HEADER
{
unsigned short ModuleType; // 2
unsigned short ModuleSubType; // 3
unsigned long HeaderLength; // in dwords
unsigned long : 32;
unsigned long : 32;
unsigned long ModuleVendor; // 8086h
unsigned long Date; // in BCD format
unsigned long TotalSize; // in dwords
unsigned long unknown1[6];
unsigned long EntryPoint;
unsigned long unknown2[16];
unsigned long RsaKeySize; // in dwords
unsigned long ScratchSize; // in dwords
unsigned char RsaPubMod[256];
unsigned long RsaPubExp;
unsigned char RsaSig[256];
};
แแ แแชแแกแแ แ แแขแแแ แแแแก แแ แแแแแ แก แแแแแก แฅแแจแจแ, แแแแฌแแแแก แแ แแฌแงแแแก.
Intel BG แแแจแแแแ ACM
แแ ACM-แแก แแฃแจแแแแแก แแแแแแแแก แจแแแแแแ แแแแ แแแ, แ แแ แแก แแแแแแแก แจแแแแแแก:
- แแฆแแแก Intel ME-แแแ Intel BG แแแแคแแแฃแ แแชแแแก, แ แแแแแแช แฉแแฌแแ แแแแ แฉแแแกแแขแแก แคแฃแแแแแ (FPFs);
- แแแฃแแแแก KEYM แแ IBBM แแแแแคแแกแขแแแก, แแแแฌแแแแก แแแ.
แแ แแแแแคแแกแขแแแแก แกแแแแแแแแแ ACM แแกแแแ แแงแแแแแก FIT แชแฎแ แแแก, แ แแแแแกแแช แแฅแแก แแ แ แขแแแแก แฉแแแแฌแแ แ แแ แกแขแ แฃแฅแขแฃแ แแแแ แแแแแแแแแกแแแแก (แแฎ. แแแแแ FIT_ENTRY_TYPES).
แแแแแ แฃแคแ แ แแฎแแแก แแแแฎแแแแ แแแแแคแแกแขแแแก. แแแ แแแแ แแแแแคแแกแขแแก แกแขแ แฃแฅแขแฃแ แแจแ แฉแแแ แแฎแแแแแ แ แแแแแแแแ แแฃแแแแแแ แแฃแแแแแแแแก, แกแแฏแแ แ แแแกแแฆแแแแก แฐแแจแก แแแแ แ แแแแแคแแกแขแแแแ แแ แกแแฏแแ แ OEM Root Key-แก, แ แแแแแแช แฎแแแแแฌแแ แแแแ แ แแแแ แช แฌแงแแแแแ แกแขแ แฃแฅแขแฃแ แ:
typedef struct KEY_MANIFEST
{
char Tag[8]; // โ__KEYM__โ
unsigned char : 8; // 10h
unsigned char : 8; // 10h
unsigned char : 8; // 0
unsigned char : 8; // 1
unsigned short : 16; // 0Bh
unsigned short : 16; // 20h == hash size?
unsigned char IbbmKeyHash[32]; // SHA256 of an IBBM public key
BG_RSA_ENTRY OemRootKey;
};
typedef struct BG_RSA_ENTRY
{
unsigned char : 8; // 10h
unsigned short : 16; // 1
unsigned char : 8; // 10h
unsigned short RsaPubKeySize; // 800h
unsigned long RsaPubExp;
unsigned char RsaPubKey[256];
unsigned short : 16; // 14
unsigned char : 8; // 10h
unsigned short RsaSigSize; // 800h
unsigned short : 16; // 0Bh
unsigned char RsaSig[256];
};
OEM Root Key-แแก แกแแฏแแ แ แแแกแแฆแแแแก แแแแแกแแแแฌแแแแแแ, แจแแแแฎแกแแแแแ, แ แแ SHA256 แฐแแจแ แแแแแแงแแแแแ แกแแคแฃแแ แแแแแแ, แ แแแแแแช แแ แแแแแแขแจแ แฃแแแ แแแฆแแแฃแแแ Intel ME-แแแ.
แแแแแแแแแ แแแแ แ แแแแแคแแกแขแแ. แแแ แจแแแแแแ แกแแแ แกแขแ แฃแฅแขแฃแ แแกแแแ:
typedef struct IBB_MANIFEST
{
ACBP Acbp; // Boot policies
IBBS Ibbs; // IBB description
IBB_DESCRIPTORS[];
PMSG Pmsg; // IBBM signature
};
แแแ แแแแ แจแแแชแแแก แ แแแแแแแแ แแฃแแแแแแแแก:
typedef struct ACBP
{
char Tag[8]; // โ__ACBP__โ
unsigned char : 8; // 10h
unsigned char : 8; // 1
unsigned char : 8; // 10h
unsigned char : 8; // 0
unsigned short : 16; // x & F0h = 0
unsigned short : 16; // 0 < x <= 400h
};
แแแแ แ แจแแแชแแแก IBB-แแก SHA256 แฐแแจแก แแ แแฆแฌแแ แแแแก แ แแแแแแแแแก, แ แแแแแแแช แแฆแฌแแ แก IBB-แแก แจแแแแแแกแก (แแแฃ แ แแกแแแ แแ แแก แแแแแแแแแแ แฐแแจแ):
typedef struct IBBS
{
char Tag[8]; // โ__IBBS__โ
unsigned char : 8; // 10h
unsigned char : 8; // 0
unsigned char : 8; // 0
unsigned char : 8; // x <= 0Fh
unsigned long : 32; // x & FFFFFFF8h = 0
unsigned long Unknown[20];
unsigned short : 16; // 0Bh
unsigned short : 16; // 20h == hash size ?
unsigned char IbbHash[32]; // SHA256 of an IBB
unsigned char NumIbbDescriptors;
};
IBB แแแกแแ แแแขแแ แแแ แแแฐแงแแแแแแ แแ แกแขแ แฃแฅแขแฃแ แแก แแ แแแแแแแแก แแแงแแแแแแ. แแแ แจแแแแแ แกแก แแฅแแก แจแแแแแแ แคแแ แแแขแ:
typedef struct IBB_DESCRIPTOR
{
unsigned long : 32;
unsigned long BaseAddress;
unsigned long Size;
};
แแก แแแ แขแแแแ: แแแแแแฃแแ แแแกแแ แแแขแแ แ แจแแแชแแแก IBB แแแฌแแแแก แแแกแแแแ แแก/แแแแแก. แแแ แแแแ, แแ แแแกแแ แแแขแแ แแแแก แแแแ แแแแแแแแฃแ แแแแแแ แจแแแ แแแแ (แแแแแ แแฆแแฌแแ แแแแก แแแแแแแแแแ แแแแ) แแ แแก IBB. แแ, แ แแแแ แช แฌแแกแ, IBB แแ แแก SEC แแ PEI แคแแแแแแก แงแแแแ แแแแฃแแแก แแแแแแแแชแแ.
แแแแ แ แแแแแคแแกแขแ แแแแแ แแแแ แกแขแ แฃแฅแขแฃแ แแ, แ แแแแแแช แจแแแชแแแก IBB แกแแฏแแ แ แแแกแแฆแแแแก (แแแแแฌแแแแฃแแ SHA256 แฐแแจแแ แแแ แแแแ แแแแแคแแกแขแแแแ) แแ แแ แแแแแคแแกแขแแก แฎแแแแแฌแแ แแ:
typedef struct PMSG
{
char Tag[8]; // โ__PMSG__โ
unsigned char : 8; // 10h
BG_RSA_ENTRY IbbKey;
};
แแกแ แ แแ, UEFI BIOS-แแก แจแแกแ แฃแแแแแก แแแฌแงแแแแแแแช แแ, แแ แแชแแกแแ แ แแแแฌแงแแแก ACM-แก, แ แแแแแแช แแแแแแแแฌแแแแก แกแแฅแชแแแแแก แจแแแแแ แกแแก แแแแแแขแฃแ แแแแก SEC แแ PEI แคแแแแก แแแแแ. แจแแแแแ, แแ แแชแแกแแ แ แแแแแแแก ACM-แแแ, แแแซแ แแแแก RESET แแแฅแขแแ แแก แแแกแฌแแ แแ แแ แแฌแงแแแก BIOS-แแก แจแแกแ แฃแแแแแก.
PEI แแแแแฌแแแแฃแแ แแแแแงแแคแ แฃแแแ แจแแแชแแแแแก แแแแฃแแก, แ แแแแแแช แจแแแแแฌแแแแก แแแแแ แฉแแ BIOS-แก (DXE แแแแ). แแก แแแแฃแแ แฃแแแ แจแแแฃแจแแแแแฃแแแ IBV (แแแแแฃแแแแแแแแ BIOS แแแแงแแแแแแ) แแ แแแแแ แกแแกแขแแแแก แแแแงแแแแแแแก แแแแ . แแแแขแแ แ แแ แแฎแแแแ Lenovo แแ Gigabyte แกแแกแขแแแแแ แแฆแแแฉแแแ แฉแแแแก แแแแแแ แแฃแแแแแจแ แแ แแฅแแ Intel BG แแฎแแ แแแญแแ แ, แแแแแแฎแแแแ แแ แกแแกแขแแแแแแแแ แแแแฆแแแฃแแ แแแแ.
UEFI BIOS แแแแฃแแ LenovoVerifiedBootPei
Lenovo-แก แจแแแแฎแแแแแจแ, แแฆแแแฉแแแ, แ แแ Lenovo-แก แแแแ แจแแแฃแจแแแแแฃแแ LenovoVerifiedBootPei {B9F2AC77-54C7-4075-B42E-C36325A9468D} แแแแฃแแ.
แแแกแ แแแแชแแแแ แแแซแแแแแก (GUID) แฐแแจแแก แชแฎแ แแแ DXE-แกแแแแก แแ แแแแแแแแฌแแแก DXE.
if (EFI_PEI_SERVICES->GetBootMode() != BOOT_ON_S3_RESUME)
{
if (!FindHashTable())
return EFI_NOT_FOUND;
if (!VerifyDxe())
return EFI_SECURITY_VIOLATION;
}
ะฅะตั ัะฐะฑะปะธัะฐ {389CC6F2-1EA8-467B-AB8A-78E769AE2A15} ะธะผะตะตั ัะปะตะดัััะธะน ัะพัะผะฐั:
typedef struct HASH_TABLE
{
char Tag[8]; // โ$HASHTBLโ
unsigned long NumDxeDescriptors;
DXE_DESCRIPTORS[];
};
typedef struct DXE_DESCRIPTOR
{
unsigned char BlockHash[32]; // SHA256
unsigned long Offset;
unsigned long Size;
};
UEFI BIOS แแแแฃแแ BootGuardPei
Gigabyte-แแก แจแแแแฎแแแแแจแ, แแฆแแแฉแแแ, แ แแ แแก แแงแ BootGuardPei {B41956E1-7CA2-42DB-9562-168389F0F066} แแแแฃแแ, แจแแแฃแจแแแแแฃแแ AMI-แแก แแแแ แแ, แจแแกแแแแแแกแแ, แฌแแ แแแแแแแแแแ แแแแแกแแแแ AMI BIOS-แจแ Intel BG-แแก แแฎแแ แแแญแแ แแ.
แแแกแ แแแฅแแแแแแแก แแแแแ แแแแ แแแ แแแแฃแแฌแแแแ แแแแกแฎแแแแแแฃแแแ, แแฃแแชแ, แแก แแ แแแแแ แแ:
int bootMode = EFI_PEI_SERVICES->GetBootMode();
if (bootMode != BOOT_ON_S3_RESUME &&
bootMode != BOOT_ON_FLASH_UPDATE &&
bootMode != BOOT_IN_RECOVERY_MODE)
{
HOB* h = CreateHob();
if (!FindHashTable())
return EFI_NOT_FOUND;
WriteHob(&h, VerifyDxe());
return h;
}
แฐแแจแแก แชแฎแ แแแก {389CC6F2-1EA8-467B-AB8A-78E769AE2A15}, แ แแแแแแช แแแแแฉแแแแแ, แแฅแแก แจแแแแแแ แคแแ แแแขแ:
typedef HASH_TABLE DXE_DESCRIPTORS[];
typedef struct DXE_DESCRIPTOR
{
unsigned char BlockHash[32]; // SHA256
unsigned long BaseAddress;
unsigned long Size;
};
Intel Boot Guard 2.x
แแแแแแ แแแกแแฃแแ แแ Intel Boot Guard-แแก แแแแแ แแ แ แแแแแแแแแขแแชแแแแ, แ แแแแแแช แแแแแแแ แแฅแแ Intel SoC-แแ แแแคแฃแซแแแแฃแ แแฎแแ แกแแกแขแแแแจแ Apollo Lake แแแแ แแแ แฅแแขแแฅแขแฃแ แแ - ASRock J4205-IT.
แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแก แแแ แกแแ แแแแแงแแแแแฃแแ แแฅแแแแ แแฎแแแแ SoC-แแแจแ (แแฎแแแ แกแแกแขแแแแแ Kaby Lake แแ แแชแแกแแ แแก แแแแ แแแ แฅแแขแแฅแขแฃแ แแ แแแ แซแแแแแแ Intel Boot Guard 1.x-แแก แแแแแงแแแแแแก), แแก แแแ แแแขแแ แแกแก แแฌแแแแก Intel SoC-แแ แแแคแฃแซแแแแฃแแ แแแแขแคแแ แแแแแกแแแแก แแฎแแแ แแ แฅแแขแแฅแขแฃแ แฃแแ แแแ แแแแขแแก แจแแกแฌแแแแแ, แ แแช แฎแแแจแแกแแฎแแแ แแแฎแแ. แชแแแแแแแแแ, แแแแแแแแแ:
- BIOS แแ Intel ME แ แแแแแแแแ (แฃแคแ แ แกแฌแแ แแ Intel TXE, Intel SoC แขแแ แแแแแแแแแแก แแแฎแแแแแ) แแฎแแ แแ แแก แแ แแ IFWI แ แแแแแแ;
- แแแฃแฎแแแแแแ แแแแกแ, แ แแ Intel BG แฉแแ แแฃแแ แแงแ แแแแขแคแแ แแแแ, แกแขแ แฃแฅแขแฃแ แแแ, แ แแแแ แแชแแ FIT, KEYM, IBBM, แแ แแแแซแแแแ แคแแแจ แแแฎแกแแแ แแแแจแ;
- TXE แแ ISH แแแ แแแแแแก (x86) แแแ แแ, แฉแแแกแแขแก แแแแแแขแ แแแกแแแ แแแ แแแ (แแกแแ ARC, แกแฎแแแแ แจแแ แแก) - PMC (Power Management Controller), แ แแแแแแช แแแแแแจแแ แแแฃแแแ แแแแ แแแขแแแฃแแ แฅแแแกแแกแขแแแแก แคแฃแแฅแชแแแแแ แแแแกแ แแ แจแแกแ แฃแแแแแก แแแแแขแแ แแแแแแ.
แแฎแแแ IFWI แ แแแแแแแก แจแแแแแ แกแ แจแแแแแแ แแแแฃแแแแแก แแแแ แแแแ:
แแแแแ แซแแแแ
แกแแฎแแแ
แแฆแฌแแ แ
0000 2000 แกแ
SMIP
แแแแแแ แแ แแแแขแคแแ แแแก แแแแคแแแฃแ แแชแแ, แฎแแแแแฌแแ แแแ แแแแงแแแแแแแก แแแแ
0000 6000 แกแ
RBEP
Intel TXE firmware แแแแแก แแแแงแแคแแแแแ, x86, แฎแแแแแฌแแ แแแแ Intel-แแก แแแแ
0001 0000 แกแ
PMCP
แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแก แแแแงแแคแแแแแ Intel PMC, ARC, แฎแแแแแฌแแ แแแ Intel-แแก แแแแ
0002 0000 แกแ
FTPR
Intel TXE firmware แแแแแก แแแแงแแคแแแแแ, x86, แฎแแแแแฌแแ แแแแ Intel-แแก แแแแ
0007B000h
UCOD
CPU แแแแ แแแแแแก แแแแแฎแแแแแแ แฎแแแแแฌแแ แแแแ Intel-แแก แแแแ
0008 0000 แกแ
IBBP
UEFI BIOS, SEC/PEI แคแแแแแ, x86, แแแแงแแแแแแ แฎแแแแแฌแแ แแแแ
0021 8000 แกแ
ISHC
Intel ISH firmware, x86 แแแแแก แแแแงแแคแแแแแ, แฎแแแแแฌแแ แแแ แแแแงแแแแแแแก แแแแ
0025 8000 แกแ
NFTP
Intel TXE firmware แแแแแก แแแแงแแคแแแแแ, x86, แฎแแแแแฌแแ แแแแ Intel-แแก แแแแ
0036 1000 แกแ
IUNP
แฃแชแแแแ
0038 1000 แกแ
OBBP
UEFI BIOS, DXE แคแแแ, x86, แฎแแแแแฃแฌแแ แแแ
TXE firmware-แแก แแแแแแแแก แแ แแก แแจแแแ แ แแแฎแแ, แ แแ RESET-แแก แจแแแแแ, TXE แแแแ แฉแฃแแแแก แแ แแชแแกแแ แก แแ แแแแแแแ แแแแแจแ, แกแแแแ แแ แแแแแแแแแแก แแแกแแแแ แแแแแก แกแแแ แชแแก แซแแ แแแแ แจแแแแแ แกแก CPU-แกแแแแก (FIT, ACM, RESET แแแฅแขแแ แ ...). แฃแคแ แ แแแขแแช, TXE แแแแแกแแแก แแ แแแแแชแแแแแก แแแแแก SRAM-แจแ, แ แแก แจแแแแแแแช แแแ แแ แแแแแ แแซแแแแก แแ แแชแแกแแ แก แแฅ แฌแแแแแแก แแ โแแแแแแกแฃแคแแแแกโ แแแก RESET-แแแ.
Rootkits-แแก แแแชแแแแ
แแแ, แแฎแแ แแแแแแแแแ โแชแฎแแแแโ. แฉแแแ แแ แแฎแแ แแฆแแแแแฉแแแแ, แ แแ แแแแ แกแแกแขแแแแจแ, SPI แคแแแจ แแแกแแ แแแขแแ แแแก แแฅแแ SPI แคแแแจ แแแฎแกแแแ แแแแก แ แแแแแแแแจแ แฌแแแแแแก แแแแแ แแแ, แ แแแ แแ แแแฎแกแแแ แแแแก แงแแแแ แแแแฎแแแ แแแแแก แจแแแซแแแก แแแแแกแแแแ แ แ แแแแแแแก แแแฌแแ แ แแ แฌแแแแแฎแแ. แแแแ. แแ แแ แกแแแแแก แแแ.
MEinfo แฃแขแแแแขแแจแ (Intel STK-แแแ) แจแแแแฌแแแแแก แจแแแแแ, แฉแแแ แแแแฎแแ, แ แแ แแ แกแแกแขแแแแแแ แฌแแ แแแแแแก แ แแแแแ แแ แแงแ แแแฎแฃแ แฃแแ, แจแแกแแแแแแกแแ, แฉแแแกแแขแแก แกแแแ แแแแแ (FPF) แแแ แฉแ แแแแฃแกแแแฆแแ แแ แแแแแแแ แแแแแจแ. แแแแฎ, Intel BG แแ แช แฉแแ แแฃแแแ แแ แแ แช แแแแแ แแฃแแแ แแกแแ แจแแแแฎแแแแแแจแ.
แฉแแแ แแกแแฃแแ แแแ แจแแแแแ แกแแกแขแแแแแแ (แ แแช แจแแแฎแแแ Intel BG-แก แแ แ แแช แแแแแแแแแแแ แแฅแแแแ แแฆแฌแแ แแแ แกแขแแขแแแจแ, แแแกแแฃแแ แแแ แกแแกแขแแแแแแ Haswell-แแก แแ แแชแแกแแ แแก แแแแ แแแ แฅแแขแแฅแขแฃแ แแ แแ แฃแคแ แ แแแฆแแแ):
- แแแแแแแแขแแก แงแแแแ แแ แแแฃแฅแขแ;
- แงแแแแ MSI แแ แแแฃแฅแขแ;
- 21 Lenovo แแแแขแแแแก แแแแแแ แแ 4 Lenovo แกแแ แแแ แแก แแแแแแ.
แ แ แแฅแแ แฃแแแ, แแฆแแแฉแแแแก แจแแกแแฎแแ แฉแแแ แแแชแแแแแ แแ แแแแแญแ แแแแก, แแกแแแ แ แแแแ แช Intel-แก.
แแแแแแแขแฃแ แ แแแกแฃแฎแ แแแฐแงแแ แแฎแแแแ Lenovoแแแแช แแ แแแแแแแก แแฆแแแ แแแแ แแ
แแแแแแแแขแ แ แแแแ แช แฉแแแก, แแแ แแแแฆแแก แแแคแแ แแแชแแ แแแฃแชแแแแแแแก แจแแกแแฎแแ, แแแแ แแ แแ แแแแแ แ แแแแแแขแแ แ แแ แแแฃแแแแแแแแ.
แแแแฃแแแแแชแแ MSI แแแแแแแแ แจแแฉแแ แแ แฉแแแแ แแฎแแแแแ, แแแแแแแแแแ แฉแแแแ แกแแฏแแ แ PGP แแแกแแฆแแแ (แแแแกแแแแก, แ แแ แแแ แแแฃแแแแแแแ แแแจแแคแ แฃแแ แฃแกแแคแ แแฎแแแแแก แ แฉแแแแแ). แแแ แแแแแชแฎแแแแก, แ แแ แแกแแแ "แขแแฅแแแแแก แแฌแแ แแแแแแแ แแ แแแ แแ แแ แแฌแแ แแแแแแ PGP แแแกแแฆแแแแแก".
แแแแ แแ แฃแคแ แ แแแ แแ. แแแก แจแแแแแ, แ แแช แกแแคแฃแแ แแแ แ แฉแแแ แแแแฃแกแแแฆแแ แแ แแแแแแแ แแแแแจแ, แแแแฎแแแ แแแแแก (แแ แแแแแแแกแฎแแแแก) แจแแฃแซแแแ แแแแ แแแแ แแแ แแแแแ แแแแแ (แงแแแแแแ แ แแฃแแแ
1. แฉแแขแแแ แแแ Windows OS-แจแ (แแแแแแแ, แฅแแแแแ แแฆแฌแแ แแแ แแแแแฏแแแ แแกแแแ แจแแแซแแแแ แแแแฎแแ แชแแแแแแก Linux-แแแ, แแฃ แจแแแแฃแจแแแแแ Intel STK-แแก แแแแแแแก แกแแกแฃแ แแแแ OS-แกแแแแก). MEinfo แฃแขแแแแขแแก แแแแแงแแแแแแ, แแแ แฌแแฃแแแแ, แ แแ แแ แกแแกแขแแแแแ แแ แกแแแฃแแ แกแแคแฃแแ แแแ แแ แแ แแก แแแแ แแแ แแแแแฃแแ.
2. แฌแแแแแแฎแแ แคแแแจ แแแฎแกแแแ แแแแก แจแแแแแ แกแ Flash Programming Tool-แแก แแแแแงแแแแแแ.
3. แแแฎแกแแแแ แฌแแแแแฎแฃแแ แกแฃแ แแแ UEFI BIOS-แแก แ แแแแฅแขแแ แแแแก แแแแแกแแแแ แ แฎแแแกแแฌแงแแก แแแแแงแแแแแแ, แจแแแขแแแแ แแฃแชแแแแแแแ แชแแแแแแแแแ (แแแแแแแแแ, แแแแแฎแแ แชแแแแแ rootkit), แจแแฅแแแแแ / แจแแชแแแแแ แแ แกแแแฃแแ KEYM แแ IBBM แกแขแ แฃแฅแขแฃแ แแแ ME แ แแแแแแจแ.
แกแฃแ แแแแ แแแแแแแแแแแแ RSA แแแแแแจแแก แกแแฏแแ แ แแแฌแแแ, แ แแแแแก แฐแแจแแช แแแแ แแแ แแแแแแ แฉแแแกแแขแแก แคแฃแแแแจแ แแแแแ แฉแแ Intel BG-แแก แแแแคแแแฃแ แแชแแแกแแแ แแ แแแ.
4. Flash Image Tool-แแก แแแแแงแแแแแแ แจแแฅแแแแแ แแฎแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แกแฃแ แแแ (Intel BG แแแแคแแแฃแ แแชแแแก แแแงแแแแแแ).
5. แแแฌแแ แแ แแฎแแแ แกแฃแ แแแ Flash Programming Tool-แแก แแแแแงแแแแแแ แแแกแแแแแแแแแ, แแแแแแแแฌแแแ MEinfo-แก แแแแแงแแแแแแ, แ แแ ME แ แแแแแแ แแฎแแ แจแแแชแแแก Intel BG-แแก แแแแคแแแฃแ แแชแแแก.
6. แแแแแแงแแแแ Flash Programming Tool, แ แแแ แแแฎแฃแ แแ แฌแแ แแแแแแก แ แแแแแ.
7. แกแแกแขแแแ แแแแแแขแแแ แแแแ, แ แแก แจแแแแแแแช, MEinfo-แก แแแแแงแแแแแแ, แจแแแแซแแแแ แแแแแแกแขแฃแ แแ, แ แแ FPF-แแแ แแฎแแ แแแแ แแแ แแแแแฃแแแ.
แแก แฅแแแแแแแแ แกแแแฃแแแแแ แฉแแ แแแ Intel BG แแ แกแแกแขแแแแแ. แจแแฃแซแแแแแแ แแฅแแแแ แแแฅแแแแแแแก แแแฃแฅแแแแ, แ แแช แแแจแแแแก:
- แแฎแแแแ root แแแกแแฆแแแแก แแแ แแแ แแแฌแแแแก แแคแแแแแแ (แแแฃ แแก, แแแแช แฉแแ แแ Intel BG) แจแแซแแแแก แแ แกแแกแขแแแแแ UEFI BIOS-แแก แแแแแฎแแแแแก;
- แแฃ แแฅแแแ แแแแแ แฃแแแแ แแ แแแแแแ แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก แแ แกแแกแขแแแแจแ, แแแแแแแแแ, แแ แแแ แแแแกแขแแก แแแแแงแแแแแแ, แแก แแ แช แแ แฉแแแ แแแแแ (แแฆแกแ แฃแแแแแก แแแแแขแแแแก แจแแแแแ แแแแแแแฌแแแแแก แจแแชแแแแแก แจแแแแฎแแแแแจแ);
- แแกแแแ UEFI BIOS-แแก แแแกแแจแแ แแแแแ, แแฅแแแ แฃแแแ แจแแชแแแแแ แฉแแแกแแขแ แแแแ แแแ แแแแแฃแแ FPF-แแแแ โแกแฃแคแแโ (แแแฃ แแแแแแแฃแฆแแ แฉแแแกแแขแ, แแฃ แแแฅแแ แฌแแแแแ แแแคแ แแฌแแแแ แจแแแฃแฆแแแแก แกแแแแฃแ แแ แแแแฅแแแแก แคแแกแแ, แแ แฃแแ แแแแ แจแแชแแแแแ แแแแแแแแขแ. ).
แแแแก แแแกแแแแแแ, แแฃ แ แแกแ แแแแแแแแ แจแแฃแซแแแ แแกแแ rootkit-แก, แแฅแแแ แฃแแแ แจแแแคแแกแแ, แแฃ แ แ แแซแแแแ แแฅแแแแ แแแแแก แจแแกแ แฃแแแแแก UEFI BIOS แแแ แแแแจแ. แแแฅแแแ, แแ แแชแแกแแ แแก แงแแแแแแ แแ แแแแแแแแ แแแฃแ แ แแแแแจแ - SMM. แแกแแ rootkit-แก แจแแแซแแแแ แฐแฅแแแแแก แจแแแแแแ แแแแกแแแแแ:
- แจแแกแ แฃแแแแก OS-แแก แแแ แแแแแฃแ แแ (แจแแแแซแแแแ แแแแแแแคแแแฃแ แแ แแ แแแแฃแจแแแแแ SMI แจแแคแแ แฎแแแแก แแแแแ แแ แแแแ, แ แแแแแแช แแแแฅแขแแฃแ แแแแ แขแแแแแ แแ);
- แแฅแแก SMM แ แแแแแจแ แงแแคแแแก แงแแแแ แฃแแแ แแขแแกแแแ (แกแ แฃแแ แฌแแแแแ RAM-แแกแ แแ แแแแ แแขแฃแ แแก แ แแกแฃแ แกแแแแก แจแแแแแ แกแแ, แแแแ แแชแแฃแแ แกแแกแขแแแแกแแแ แกแแแแฃแแแแแแ);
- Rootkit แแแแแก แแแจแแคแแ แ แแ แแแจแแคแแ แ แจแแกแแซแแแแแแแ SMM แ แแแแแจแ แแแจแแแแแกแแก. แแแแแกแแแแ แ แแแแแชแแแ, แ แแแแแแช แฎแแแแแกแแฌแแแแแแ แแฎแแแแ SMM แ แแแแแจแ, แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแจแแคแแ แแก แแแกแแฆแแแแ. แแแแแแแแแ, แฐแแจแ SMRAM-แจแ แแแกแแแแ แแแแแก แแแแ แแแแแแ. แแ แแแกแแฆแแแแก แแแกแแฆแแแแ แแแแญแแ แแแแแ SMM-แจแ แแกแแแ. แแ แแก แจแแแซแแแแ แแแแแแแแก แแ แ แแแแ. แแแแแแ RCE SMM แแแแจแ แแ แแแแแแงแแแแ แแแ, แแ แแแแแแขแแ แแฅแแแแ แกแแแฃแแแ แ SMM แแแแฃแแ BIOS-แจแ, แ แแช แจแแฃแซแแแแแแแ, แ แแแแแ แฉแแแ แฉแแแ แแแ Boot Guard.
แแแ แแแแ, แแก แแแฃแชแแแแแแ แกแแจแฃแแแแแแก แแซแแแแก แแแแแแแกแฎแแแแก:
- แจแแฅแแแแแ แกแแกแขแแแแจแ แฃแชแแแแ แแแแแจแแฃแแแแแก แคแแ แฃแแ, แแแฃแฎแกแแแแ rootkit;
- แจแแแกแ แฃแแแ แแฅแแแแ แแแแ Intel SoC-แแก แจแแแแแ แฉแแแกแแขแแก แแ แ-แแ แ แแแ แแแแ, แแแ แซแแ, Intel ISH-แแ (แฃแคแ แ แแฎแแแก แแแแแแแ แแแ แกแฃแ แแแก).
แแแฃแฎแแแแแแ แแแแกแ, แ แแ Intel ISH แฅแแแกแแกแขแแแแก แจแแกแแซแแแแแแแแแ แฏแแ แแ แแ แแก แจแแกแฌแแแแแแ, แ แแแแ แช แฉแแแก, แแก แกแแแแขแแ แแกแ แแแแแแกแฎแแแก แแแฅแขแแ แแ Intel ME-แแ.
แแแกแแแแแแ
- แแแแแแแจแ แแแชแแแฃแแแ แขแแฅแแแแฃแ แ แแฆแฌแแ แ, แแฃ แ แแแแ แแฃแจแแแแก Intel Boot Guard แขแแฅแแแแแแแ. แแแแฃแก แ แแแแแแแแ แกแแแแฃแแแ แแแขแแแแก แฃแกแแคแ แแฎแแแแแจแ แแแฃแ แแแแแแแแแก แแแแแแแก แแแจแแแแแแ.
- แฌแแ แแแแแแแแแแ แแแแแแกแฎแแแก แกแชแแแแ แ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแแฃแฎแกแแแแ rootkit แกแแกแขแแแแจแ.
- แฉแแแ แแแแแแแฎแแ, แ แแ Intel-แแก แแแแแแแแ แแแ แแ แแชแแกแแ แแแก แจแแฃแซแแแแ แจแแแกแ แฃแแแ แแแแ แ แกแแแฃแแ แแแแก แแแแ BIOS-แแก แแแฌแงแแแแแแแช แแ.
- Intel 64 แแ แฅแแขแแฅแขแฃแ แแก แแฅแแแ แแแแขแคแแ แแแแ แกแฃแ แฃแคแ แ แแ แฃแคแ แ แจแแกแแคแแ แแกแ แฎแแแแ แแแแแกแฃแคแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแกแแจแแแแแ: แขแแฅแแแแแก แแแแแแแฌแแแแ, แกแแแฃแแ แแแแก แขแแฅแแแแแแแแแแกแ แแ แฅแแแกแแกแขแแแแแแก แแแแ แแ แ แแแแแแแแ (SoC แฉแแแกแแขแจแ แกแแแ แแแ แแแ: x86 ME, x86 ISH แแ ARC PMC).
แจแแ แแแแแแ
แแแแงแแแแแแแแแ, แ แแแแแแแช แแแแแ แแฎ แขแแแแแแ แฌแแ แแแแแแก แ แแแแแก แฆแแแ, แแฃแชแแแแแแแ แฃแแแ แแแฎแฃแ แแ แแแ. แฏแแ แฏแแ แแแแ, แแกแแแ แแฎแแแแ แแแแแแแก แฎแฃแญแแแแ แแ แแฎแแแ Kaby Lake แกแแกแขแแแแแ แแแแก แแฉแแแแแแก.
แแแแฎแแแ แแแแแแก แจแแฃแซแแแแ แแแแแ แแแ Intel BG แแแแแแแ แกแแกแขแแแแแแ (แ แแแแแแแแช แแแแแแแแก แแฎแแแแก แแฆแฌแแ แแแ แแแฃแชแแแแแแ) Flash Programming Tool-แแก แแแจแแแแแ -closemnf แแคแชแแแ. แแแ แแแ แ แแแจแ, แแฅแแแ แฃแแแ แแแ แฌแแฃแแแแ (MEinfo-แก แแแแแงแแแแแแ), แ แแ Intel BG-แแก แแแแคแแแฃแ แแชแแ ME แ แแแแแแจแ แแแแแแแกแฌแแแแแก แแ แขแแฅแแแแแแแแก แแฃแกแขแแ แแแแแ แแแแก FPF-แแแจแ แแแแ แแแ แแแแแแก แจแแแแแ.
แฌแงแแ แ: www.habr.com