Необычный дуалбут: ноутбук с «двойным дном»29.06.2021 16:32

data = open("C:\\WDMarv_demo\\Default\\Modified\\13.mod", "rb").read()
disk.WdWriteModule(0x13, ModuleCsum(data))

Это далеко не конец, это только…

Начало — UEFI и его отладка

Потрепан жизнью, но для опытов сгодится

Как вы уже поняли, переключением диска будет заниматься UEFI, а точнее небольшой самописный драйвер. Нам предстоит разработать и запихнуть в UEFI код, что по нажатию комбинации кнопок, отправит ту самую ATA команду диску!
Но для начала разберемся с отладкой. Неужели каждый раз чтобы проверить драйвер, BIOS перепрошивать?! Как вообще его отлаживать? Ведь полноценные отладчики стоят как чугунный мост… Оказывается, есть прибамбас, решающий сразу обе проблемы — встречайте, SPI эмулятор DediProg EM100 Pro:

На оф сайте стоит $750, но я взял на ebay за $80

Этот приборчик подключается вместо микросхемы BIOS, позволяет перезалить весь образ за секунды, а ещё, как выяснилось, умеет печатать отладочные сообщения! Паяем его к ноуту обычным радужным шлейфом:

Очень желательно закрепить шлейф, чтобы случайно не вырвать контакты

И вот уже ноутбук запускается в матрице с виртуальной флешки, и неплохо себя чувствует:

Увы, автономно эмулятор не работает, нужен ещё один ноутбук для загрузки данных

В качестве основы для драйвера возьмем проект VisualUefi, выкинем из кода всё, кроме основной процедуры:

EFI_STATUS UefiMain (EFI_HANDLE Handle, EFI_SYSTEM_TABLE *SystemTable) {
    return EFI_SUCCESS;
}

Всё просто — извлечь любой DXE без зависимостей, подправить, вставить в начало…

Потом сделаем батник, что будет внедрять только что собранный драйвер в образ UEFI и сразу перезаливать его в эмулятор:

UEFIReplace.exe ../lenbios_mod.bin 77777777-7777-7777-7777-777777777777 10 ../vs/samples/x64/Release/UefiDriver.efi -o ../lenmod_upd.bin

"C:\Program Files (x86)\DediProg\EM100\smucmd.exe" --stop
"C:\Program Files (x86)\DediProg\EM100\smucmd.exe" --set W25Q64FV -d C:\Work\lenmod_upd.bin
"C:\Program Files (x86)\DediProg\EM100\smucmd.exe" --start

И наконец пропишем его в Post-Build Events:

Да, установил русскую VS, не подумав, переставлять язык лень

Красота — собираем драйвер, и он сразу же обновляется в ноутбуке! Остаётся питание передернуть и включить. Для проверки, что всё работает, делаем самую тупую вещь — добавляем в код while (1) и пробуем запустить. Если с этой строчкой ноут виснет, а без него загружает систему — всё готово, можно экспериментировать!
А теперь по, собственно, самой отладке. Почему-то функционал печати дебажных сообщений в официальном мануале DediProg EM100 описан вот так:

Пишите на почту, вышлем доки? Почему бы сразу не разместить на сайте?

Ну да ладно, написал на почту, доки действительно прислали. Согласно докам, для отправки дебага предлагается три метода:

• Специальная SPI команда 0×11, данные передаются в DATA самого запроса
• Последовательность команд SPI Read (0×03 / 0×0B), данные передаются побайтно, изменением адреса чтения
• Последовательность команд SPI Read (0×03 / 0×0B) и SPI Write (0×02), данные передаются в DATA команды записи

А так выглядит сама запись (Write uFIFO) — посылаем команду чтения (03h) и три байта за ней. Последний байт (Byte 4 ) — байт данных, который и пойдёт на комп:

Учитывая, что эти три байта за командой — сам адрес чтения, я написал такой код:

void TestSend(uchar * buf, int data_size) {
    SpiRead(0xAAAA, 1);                  // входим в "HyperTerminal mode"
    SpiRead(0x5555, 1);
    SpiRead(0xAAAA, 1);
    for (i = 0; i < data_size + 6; i++)
        SpiRead(0xC000 + buf[i], 1);     // посылаем пакет в uFIFO побайтно
    SpiRead(0xE000, 1);                  // выходим из "HT mode"
}

К счастью, поддержку Fast Read можно отключить в дескрипторе BIOS, тем самым вынудив чипсет использовать только команды 0×03. Структура дескриптора есть в исходниках UEFITool:

typedef struct _FLASH_PARAMETERS {
    UINT8 FirstChipDensity : 4;
    UINT8 SecondChipDensity : 4;
    UINT8 : 8;
    UINT8 : 1;
    UINT8 ReadClockFrequency : 3;
    UINT8 FastReadEnabled : 1;  // <======== вот этот битик
    UINT8 FastReadFrequency : 3;
    UINT8 FlashWriteFrequency : 3;
    UINT8 FlashReadStatusFrequency : 3;
    UINT8 DualOutputFastReadSupported : 1;
    UINT8 : 1;
} FLASH_PARAMETERS;

Убеждаемся, что теперь всё работает как нужно, и наконец!!! делаем свой printf:

void HabraPrint(CONST CHAR8* FormatString, ...) {
    UINT8 buf[0x110];
    VA_LIST Marker;
    VA_START(Marker, FormatString);
    UINTN data_size = AsciiVSPrint(buf + 6, 248, FormatString, Marker) + 1;
    VA_END(Marker);
    *(UINT32*)buf = 0x47364440;         // Сигнатура протокола
    buf[4] = 0x05;                      // тип = ASCII текст
    buf[5] = data_size;                 // длина текста (с терминирующим нулем)
    SpiRead(0xAAAA, 1);                 // входим в "HyperTerminal mode"
    SpiRead(0x5555, 1);
    SpiRead(0xAAAA, 1);
    SpiWrite(0xC000, buf, data_size + 6); // посылаем текст + заголовок в uFIFO
    SpiRead(0xE000, 1);                 // выходим из "HT mode"
}

EFI_STATUS UefiMain (EFI_HANDLE Handle, EFI_SYSTEM_TABLE *SystemTable) {
    HabraPrint("Hello, habr!");
    return EFI_SUCCESS;
}

Ну наконец-то можно нормально дебажить!

Финишная прямая. Собственно, драйвер

Что такое EFI? — Это море! Море протоколов под спидами…

void RegisterKbdProtoHandler() {
    EFI_EVENT TextInExInstallEvent;
    // это событие будет вызывать наш callback
    gBS->CreateEvent(EVT_NOTIFY_SIGNAL, TPL_CALLBACK, OnTextInExInstall, NULL, &TextInExInstallEvent);
    // а здесь мы просим дергать событие именно на
    // новые протоколы SimpleTextInputEx (ввод символов)
    gBS->RegisterProtocolNotify(&gEfiSimpleTextInputExProtocolGuid, TextInExInstallEvent, &TextInExInstallRegistration);
}
// сам callback
VOID EFIAPI OnTextInExInstall(EFI_EVENT Event, VOID* Context) {
    EFI_HANDLE HandleBuffer;
    UINTN BufferSize = sizeof(EFI_HANDLE);
    // здесь мы получаем из события хендл на сам объект (клаву)
    Status = gBS->LocateHandle(ByRegisterNotify, NULL, TextInExInstallRegistration, &BufferSize, &HandleBuffer);
    if (!EFI_ERROR(Status)) // и вызываем обработчик
        SetupHotkeyOnHandle(HandleBuffer);
}

void SetupHotkeyOnHandle(EFI_HANDLE Handle) {
    EFI_KEY_DATA MyKey;
    EFI_HANDLE NotifyHandle;
    // получаем экземпляр протокола по хендлу объекта
    EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL* SimpleTextInEx;
    gBS->HandleProtocol(Handle, gEfiSimpleTextInputExProtocolGuid, 
                        (VOID**)&SimpleTextInEx);
    // заполняем, какую комбинацию мы хотим отследить (Ctrl + 'c')
    MyKey.Key.ScanCode = 0;
    MyKey.Key.UnicodeChar = L'c';
    MyKey.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID 
                                 | EFI_LEFT_CONTROL_PRESSED;
    MyKey.KeyState.KeyToggleState = 0;
    // и вешаем callback!
    SimpleTextInEx->RegisterKeyNotify(SimpleTextInEx, &MyKey,
                                      HotkeyHandler, &NotifyHandle);
}

EFI_STATUS HotkeyHandler(IN EFI_KEY_DATA* KeyData)
{
    // флажок уже был выставлен ранее, ничего не делаем
    if (alt_hdd)
        return EFI_SUCCESS;
    // выставляем флаг
    alt_hdd = TRUE;
    // шлём команду на все текущие диски
    ProcessExistingHdds();
    return EFI_SUCCESS;
}
void ProcessExistingHdds() {
    UINTN Index, HandleCount = 0;
    EFI_HANDLE* HandleBuffer;
    // ищем все объекты (диски, флешки) с протоколом BlockIo
    gBS->LocateHandleBuffer(ByProtocol, &gEfiBlockIoProtocolGuid, NULL,
                            &HandleCount, &HandleBuffer);
    for (Index = 0; Index < HandleCount; Index++) {
        // посылаем нашу команду чтения
        SendHddCommand(HandleBuffer[Index]);
    }
    FreePool(HandleBuffer);
}

// абсолютно аналогично OnTextInExInstall, реагирует на новые диски
VOID EFIAPI OnHddInstall(EFI_EVENT Event, VOID* Context) {
    EFI_HANDLE HandleBuffer;
    UINTN BufferSize = sizeof(EFI_HANDLE);
    // получаем хендл диска и вызываем отправку команды
    Status = gBS->LocateHandle(ByRegisterNotify, NULL, HddInstallRegistration,
                     &BufferSize, &HandleBuffer);
    if (!EFI_ERROR(Status))
        SendHddCommand(HandleBuffer);
}

void SendHddCommand(EFI_HANDLE Handle) {
    EFI_BLOCK_IO_PROTOCOL* BlockIoProto;
    EFI_LBA OrigLba;
    UINT8 Buffer[0x200];
    if (!alt_hdd) {
        // комбинации Ctrl+C не было, ничего не шлём
        return;
    }
    // достаем BlockIo протокол по хендлу
    gBS->HandleProtocol(Handle, &gEfiBlockIoProtocolGuid,
                        (VOID**)&BlockIoProto);
    // а вот тут нехитрый трюк, заставляем UEFI послать некорректный LBA
    OrigLba = BlockIoProto->Media->LastBlock;
    BlockIoProto->Media->LastBlock = 0xFFFFFFF8;
    // собственно, само чтение LBA
    BlockIoProto->ReadBlocks(BlockIoProto, BlockIoProto->Media->MediaId, 0xFFFFFFF1, 0x200, Buffer);
    // и возвращаем исходное состояние информации о диске
    BlockIoProto->Media->LastBlock = OrigLba;
}

В сдобренном отладочными логами виде это выглядит как-то так:

С отладкой и правда гораздо легче разрабатывается

По JTAG видим, что флаг внутри диска поменялся, а значит команда сработала! Успех!

Оно фурычит! Переключились на вторую половинку!

Ну и взгляд на рабочий стол в этот момент со стороны, для истории:

Можно заливать BIOS в нормальную флешку, всё отпаивать и собирать!

Готово, показываем!