mirror of
https://github.com/reactos/reactos.git
synced 2024-08-27 21:58:49 +00:00
2075 lines
61 KiB
C
2075 lines
61 KiB
C
/*
|
|
* COPYRIGHT: See COPYING.ARM in the top level directory
|
|
* PROJECT: ReactOS UEFI Boot Library
|
|
* FILE: boot/environ/lib/misc/image.c
|
|
* PURPOSE: Boot Library Image Routines
|
|
* PROGRAMMER: Alex Ionescu (alex.ionescu@reactos.org)
|
|
*/
|
|
|
|
/* INCLUDES ******************************************************************/
|
|
|
|
#include "bl.h"
|
|
#include <bcd.h>
|
|
|
|
/* DATA VARIABLES ************************************************************/
|
|
|
|
ULONG IapAllocatedTableEntries;
|
|
ULONG IapTableEntries;
|
|
PVOID* IapImageTable;
|
|
|
|
#ifndef _M_ARM
|
|
KDESCRIPTOR GdtRegister;
|
|
KDESCRIPTOR IdtRegister;
|
|
KDESCRIPTOR BootAppGdtRegister;
|
|
KDESCRIPTOR BootAppIdtRegister;
|
|
PVOID BootApp32EntryRoutine;
|
|
PBOOT_APPLICATION_PARAMETER_BLOCK BootApp32Parameters;
|
|
PVOID BootApp32Stack;
|
|
#endif
|
|
|
|
/* FUNCTIONS *****************************************************************/
|
|
|
|
NTSTATUS
|
|
ImgpGetFileSize (
|
|
_In_ PBL_IMG_FILE File,
|
|
_Out_ PULONG FileSize
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
ULONG Size;
|
|
BL_FILE_INFORMATION FileInformation;
|
|
|
|
/* Check if the file was memory mapped */
|
|
if (File->Flags & BL_IMG_MEMORY_FILE)
|
|
{
|
|
/* Just read the size of the mapping */
|
|
Size = File->FileSize;
|
|
}
|
|
else
|
|
{
|
|
/* Do file I/O to get the file size */
|
|
Status = BlFileGetInformation(File->FileId,
|
|
&FileInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
/* We only support files less than 4GB in the Image Mapped */
|
|
Size = FileInformation.Size;
|
|
if (FileInformation.Size > ULONG_MAX)
|
|
{
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
|
|
/* Return the size and success */
|
|
*FileSize = Size;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
ImgpReadAtFileOffset (
|
|
_In_ PBL_IMG_FILE File,
|
|
_In_ ULONG Size,
|
|
_In_ ULONGLONG ByteOffset,
|
|
_In_ PVOID Buffer,
|
|
_Out_ PULONG BytesReturned
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
/* Check what if this is a mapped file or not */
|
|
if (File->Flags & BL_IMG_MEMORY_FILE)
|
|
{
|
|
/* Check if the boundaries are within the file size */
|
|
if ((ByteOffset + Size) <= File->FileSize)
|
|
{
|
|
/* Yep, copy into the caller-supplied buffer */
|
|
RtlCopyMemory(Buffer,
|
|
(PVOID)((ULONG_PTR)File->BaseAddress + (ULONG_PTR)ByteOffset),
|
|
Size);
|
|
|
|
/* If caller wanted to know, return the size copied */
|
|
if (BytesReturned)
|
|
{
|
|
*BytesReturned = Size;
|
|
}
|
|
|
|
/* All good */
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
/* Doesn't fit */
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Issue the file I/O instead */
|
|
Status = BlFileReadAtOffsetEx(File->FileId,
|
|
Size,
|
|
ByteOffset,
|
|
Buffer,
|
|
BytesReturned,
|
|
0);
|
|
}
|
|
|
|
/* Return the final status */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ImgpOpenFile (
|
|
_In_ ULONG DeviceId,
|
|
_In_ PWCHAR FileName,
|
|
_In_ ULONG Flags,
|
|
_Out_ PBL_IMG_FILE NewFile
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
ULONG FileSize;
|
|
ULONGLONG RemoteFileSize;
|
|
PVOID RemoteFileAddress;
|
|
ULONG FileId;
|
|
|
|
/* First, try to see if BD has this file remotely */
|
|
Status = BlBdPullRemoteFile(FileName,
|
|
&RemoteFileAddress,
|
|
&RemoteFileSize);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Yep, get the file size and make sure it's < 4GB */
|
|
FileSize = RemoteFileSize;
|
|
if (RemoteFileSize <= ULONG_MAX)
|
|
{
|
|
/* Remember this is a memory mapped remote file */
|
|
NewFile->Flags |= (BL_IMG_MEMORY_FILE | BL_IMG_REMOTE_FILE);
|
|
NewFile->FileSize = FileSize;
|
|
NewFile->BaseAddress = RemoteFileAddress;
|
|
goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* Use File I/O instead */
|
|
Status = BlFileOpen(DeviceId,
|
|
FileName,
|
|
BL_FILE_READ_ACCESS,
|
|
&FileId);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
/* Bail out on failure */
|
|
return Status;
|
|
}
|
|
|
|
/* Make sure nobody thinks this is a memory file */
|
|
NewFile->Flags &= ~BL_IMG_MEMORY_FILE;
|
|
NewFile->FileId = FileId;
|
|
|
|
Quickie:
|
|
/* Set common data for both memory and I/O based file */
|
|
NewFile->Flags |= BL_IMG_VALID_FILE;
|
|
NewFile->FileName = FileName;
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ImgpCloseFile (
|
|
_In_ PBL_IMG_FILE File
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
/* Make sure this is a valid file, otherwise no-op */
|
|
Status = STATUS_SUCCESS;
|
|
if (File->Flags & BL_IMG_VALID_FILE)
|
|
{
|
|
/* Is this a memory mapped file? */
|
|
if (!(File->Flags & BL_IMG_MEMORY_FILE))
|
|
{
|
|
/* Nope, close the file handle */
|
|
return BlFileClose(File->FileId);
|
|
}
|
|
|
|
/* Is this a remote file? */
|
|
if (File->Flags & BL_IMG_REMOTE_FILE)
|
|
{
|
|
/* Then only free the memory in that scenario */
|
|
return MmPapFreePages(File->BaseAddress, BL_MM_INCLUDE_MAPPED_ALLOCATED);
|
|
}
|
|
}
|
|
|
|
/* Return the final status */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgUnallocateImageBuffer (
|
|
_In_ PVOID ImageBase,
|
|
_In_ ULONG ImageSize,
|
|
_In_ ULONG ImageFlags
|
|
)
|
|
{
|
|
PHYSICAL_ADDRESS PhysicalAddress;
|
|
NTSTATUS Status;
|
|
|
|
/* Make sure required parameters are present */
|
|
if (!(ImageBase) || !(ImageSize))
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Check if this was a physical allocation */
|
|
if (!(ImageFlags & BL_LOAD_IMG_VIRTUAL_BUFFER))
|
|
{
|
|
return MmPapFreePages(ImageBase, BL_MM_INCLUDE_MAPPED_ALLOCATED);
|
|
}
|
|
|
|
/* It's virtual, so translate it first */
|
|
if (!BlMmTranslateVirtualAddress(ImageBase, &PhysicalAddress))
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Unmap the virtual mapping */
|
|
Status = BlMmUnmapVirtualAddressEx(ImageBase, ROUND_TO_PAGES(ImageSize));
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Now free the physical pages */
|
|
Status = BlMmFreePhysicalPages(PhysicalAddress);
|
|
}
|
|
|
|
/* All done */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgAllocateImageBuffer (
|
|
_Inout_ PVOID* ImageBuffer,
|
|
_In_ ULONG MemoryType,
|
|
_In_ ULONGLONG ImageSize,
|
|
_In_ ULONG Flags
|
|
)
|
|
{
|
|
ULONG Attributes;
|
|
ULONGLONG Pages, Size;
|
|
PVOID MappedBase, CurrentBuffer;
|
|
NTSTATUS Status;
|
|
PHYSICAL_ADDRESS PhysicalAddress;
|
|
|
|
/* Read and reset the current buffer address */
|
|
CurrentBuffer = *ImageBuffer;
|
|
*ImageBuffer = NULL;
|
|
|
|
/* Align the image size to page */
|
|
Size = ROUND_TO_PAGES(ImageSize);
|
|
|
|
/* Not sure what this attribute does yet */
|
|
Attributes = 0;
|
|
if (Flags & BL_LOAD_IMG_UNKNOWN_BUFFER_FLAG)
|
|
{
|
|
Attributes = 0x10000;
|
|
}
|
|
|
|
/* Check if the caller wants a virtual buffer */
|
|
if (Flags & BL_LOAD_IMG_VIRTUAL_BUFFER)
|
|
{
|
|
/* Set the physical address to the current buffer */
|
|
PhysicalAddress.QuadPart = (ULONG_PTR)CurrentBuffer;
|
|
Pages = Size >> PAGE_SHIFT;
|
|
|
|
/* Allocate the physical pages */
|
|
Status = BlMmAllocatePhysicalPages(&PhysicalAddress,
|
|
Pages,
|
|
MemoryType,
|
|
Attributes,
|
|
0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
/* If that failed, remove allocation attributes */
|
|
PhysicalAddress.QuadPart = 0;
|
|
Attributes &= ~BlMemoryValidAllocationAttributeMask,
|
|
Status = BlMmAllocatePhysicalPages(&PhysicalAddress,
|
|
Pages,
|
|
MemoryType,
|
|
Attributes,
|
|
0);
|
|
}
|
|
|
|
/* Check if either attempts succeeded */
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
/* Now map the physical buffer at the address requested */
|
|
MappedBase = PhysicalAddressToPtr(PhysicalAddress);
|
|
Status = BlMmMapPhysicalAddressEx(&MappedBase,
|
|
BlMemoryFixed,
|
|
Size,
|
|
PhysicalAddress);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
/* Free on failure if needed */
|
|
BlMmFreePhysicalPages(PhysicalAddress);
|
|
return Status;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, allocate raw physical pages */
|
|
MappedBase = CurrentBuffer;
|
|
Pages = Size >> PAGE_SHIFT;
|
|
Status = MmPapAllocatePagesInRange(&MappedBase,
|
|
MemoryType,
|
|
Pages,
|
|
Attributes,
|
|
0,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
/* If that failed, try without allocation attributes */
|
|
MappedBase = NULL;
|
|
Attributes &= ~BlMemoryValidAllocationAttributeMask,
|
|
Status = MmPapAllocatePagesInRange(&MappedBase,
|
|
MemoryType,
|
|
Pages,
|
|
Attributes,
|
|
0,
|
|
NULL,
|
|
0);
|
|
}
|
|
|
|
/* Check if either attempts succeeded */
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
/* Success path, returned allocated address */
|
|
*ImageBuffer = MappedBase;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgLoadImageWithProgress2 (
|
|
_In_ ULONG DeviceId,
|
|
_In_ BL_MEMORY_TYPE MemoryType,
|
|
_In_ PWCHAR FileName,
|
|
_Inout_ PVOID* MappedBase,
|
|
_Inout_ PULONG MappedSize,
|
|
_In_ ULONG ImageFlags,
|
|
_In_ BOOLEAN ShowProgress,
|
|
_Out_opt_ PUCHAR* HashBuffer,
|
|
_Out_opt_ PULONG HashSize
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
PVOID BaseAddress, Buffer;
|
|
ULONG RemainingLength, CurrentSize, ImageSize, ReadSize;
|
|
BOOLEAN ComputeSignature, ComputeHash, Completed;
|
|
BL_IMG_FILE FileHandle;
|
|
ULONGLONG ByteOffset;
|
|
PHYSICAL_ADDRESS PhysicalAddress;
|
|
|
|
/* Initialize variables */
|
|
BaseAddress = 0;
|
|
ImageSize = 0;
|
|
Completed = FALSE;
|
|
RtlZeroMemory(&FileHandle, sizeof(FileHandle));
|
|
|
|
/* Check for missing parameters */
|
|
if (!MappedBase)
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
goto Quickie;
|
|
}
|
|
if (!FileName)
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
goto Quickie;
|
|
}
|
|
if (!MappedSize)
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Check if the image buffer is being provided */
|
|
if (ImageFlags & BL_LOAD_IMG_EXISTING_BUFFER)
|
|
{
|
|
/* An existing base must already exist */
|
|
if (!(*MappedBase))
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* Check of a hash is being requested */
|
|
if (ImageFlags & BL_LOAD_IMG_COMPUTE_HASH)
|
|
{
|
|
/* Make sure we can return the hash */
|
|
if (!HashBuffer)
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
goto Quickie;
|
|
}
|
|
if (!HashSize)
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* Check for invalid combination of parameters */
|
|
if ((ImageFlags & BL_LOAD_IMG_COMPUTE_HASH) && (ImageFlags & 0x270))
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Initialize hash if requested by caller */
|
|
if (HashBuffer)
|
|
{
|
|
*HashBuffer = 0;
|
|
}
|
|
|
|
/* Do the same for the hash size */
|
|
if (HashSize)
|
|
{
|
|
*HashSize = 0;
|
|
}
|
|
|
|
/* Open the image file */
|
|
Status = ImgpOpenFile(DeviceId, FileName, DeviceId, &FileHandle);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
EfiPrintf(L"Error opening file: %lx\r\n", Status);
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Get the size of the image */
|
|
Status = ImgpGetFileSize(&FileHandle, &ImageSize);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
EfiPrintf(L"Error getting file size: %lx\r\n", Status);
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Read the current base address */
|
|
BaseAddress = *MappedBase;
|
|
if (ImageFlags & BL_LOAD_IMG_EXISTING_BUFFER)
|
|
{
|
|
/* Check if the current buffer is too small */
|
|
if (*MappedSize < ImageSize)
|
|
{
|
|
/* Return the required size of the buffer */
|
|
*MappedSize = ImageSize;
|
|
Status = STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* A buffer was not provided, allocate one ourselves */
|
|
Status = BlImgAllocateImageBuffer(&BaseAddress,
|
|
MemoryType,
|
|
ImageSize,
|
|
ImageFlags);
|
|
}
|
|
|
|
/* Bail out if allocation failed */
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Set the initial byte offset and length to read */
|
|
RemainingLength = ImageSize;
|
|
ByteOffset = 0;
|
|
Buffer = BaseAddress;
|
|
|
|
/* Update the initial progress */
|
|
Completed = FALSE;
|
|
if (ShowProgress)
|
|
{
|
|
BlUtlUpdateProgress(0, &Completed);
|
|
ShowProgress &= (Completed != 0) - 1;
|
|
}
|
|
|
|
/* Set the chunk size for each read */
|
|
ReadSize = 0x100000;
|
|
if (ReadSize > ImageSize)
|
|
{
|
|
ReadSize = ImageSize;
|
|
}
|
|
|
|
/* Check if we should compute hash and/or signatures */
|
|
ComputeSignature = ImageFlags & BL_LOAD_IMG_COMPUTE_SIGNATURE;
|
|
ComputeHash = FALSE;
|
|
if ((ComputeSignature) || (ImageFlags & BL_LOAD_IMG_COMPUTE_HASH))
|
|
{
|
|
ComputeHash = TRUE;
|
|
// todo: crypto is hard
|
|
}
|
|
|
|
/* Begin the read loop */
|
|
while (RemainingLength)
|
|
{
|
|
/* Check if we've got more than a chunk left to read */
|
|
if (RemainingLength > ReadSize)
|
|
{
|
|
/* Read a chunk*/
|
|
CurrentSize = ReadSize;
|
|
}
|
|
else
|
|
{
|
|
/* Read only what's left */
|
|
CurrentSize = RemainingLength;
|
|
}
|
|
|
|
/* Read the chunk */
|
|
Status = ImgpReadAtFileOffset(&FileHandle,
|
|
CurrentSize,
|
|
ByteOffset,
|
|
Buffer,
|
|
0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Check if we need to compute the hash of this chunk */
|
|
if (ComputeHash)
|
|
{
|
|
// todo: crypto is hard
|
|
}
|
|
|
|
/* Update our position and read information */
|
|
Buffer = (PVOID)((ULONG_PTR)Buffer + CurrentSize);
|
|
RemainingLength -= CurrentSize;
|
|
ByteOffset += CurrentSize;
|
|
|
|
/* Check if we should update the progress bar */
|
|
if (ShowProgress)
|
|
{
|
|
/* Compute new percentage completed, check if we're done */
|
|
BlUtlUpdateProgress(100 - 100 * RemainingLength / ImageSize,
|
|
&Completed);
|
|
ShowProgress &= (Completed != 0) - 1;
|
|
}
|
|
}
|
|
|
|
/* Is the read fully complete? We need to finalize the hash if requested */
|
|
if (ComputeHash)
|
|
{
|
|
// todo: CRYPTO IS HARD
|
|
}
|
|
|
|
/* Success path, return back the buffer and the size of the image */
|
|
*MappedBase = BaseAddress;
|
|
*MappedSize = ImageSize;
|
|
|
|
Quickie:
|
|
/* Close the file handle */
|
|
ImgpCloseFile(&FileHandle);
|
|
|
|
/* Check if we failed and had allocated a buffer */
|
|
if (!(NT_SUCCESS(Status)) &&
|
|
(BaseAddress) &&
|
|
!(ImageFlags & BL_LOAD_IMG_EXISTING_BUFFER))
|
|
{
|
|
/* Check what kind of buffer we had allocated */
|
|
if (ImageFlags & BL_LOAD_IMG_VIRTUAL_BUFFER)
|
|
{
|
|
/* Unmap and free the virtual buffer */
|
|
PhysicalAddress.QuadPart = (ULONG_PTR)BaseAddress;
|
|
BlMmUnmapVirtualAddressEx(BaseAddress, ImageSize);
|
|
BlMmFreePhysicalPages(PhysicalAddress);
|
|
}
|
|
else
|
|
{
|
|
/* Free the physical buffer */
|
|
MmPapFreePages(BaseAddress, BL_MM_INCLUDE_MAPPED_ALLOCATED);
|
|
}
|
|
}
|
|
|
|
/* If we hadn't gotten to 100% yet, do it now */
|
|
if (ShowProgress)
|
|
{
|
|
BlUtlUpdateProgress(100, &Completed);
|
|
}
|
|
|
|
/* Return the final status */
|
|
return Status;
|
|
}
|
|
|
|
PIMAGE_SECTION_HEADER
|
|
BlImgFindSection (
|
|
_In_ PVOID ImageBase,
|
|
_In_ ULONG ImageSize
|
|
)
|
|
{
|
|
PIMAGE_SECTION_HEADER FoundSection;
|
|
ULONG i;
|
|
PIMAGE_SECTION_HEADER SectionHeader;
|
|
PIMAGE_NT_HEADERS NtHeader;
|
|
NTSTATUS Status;
|
|
|
|
/* Assume failure */
|
|
FoundSection = NULL;
|
|
|
|
/* Make sure the image is valid */
|
|
Status = RtlImageNtHeaderEx(0, ImageBase, ImageSize, &NtHeader);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Get the first section and loop through them all */
|
|
SectionHeader = IMAGE_FIRST_SECTION(NtHeader);
|
|
for (i = 0; i < NtHeader->FileHeader.NumberOfSections; i++)
|
|
{
|
|
/* Check if this is the resource section */
|
|
if (!_stricmp((PCCH)SectionHeader->Name, ".rsrc"))
|
|
{
|
|
/* Yep, we're done */
|
|
FoundSection = SectionHeader;
|
|
break;
|
|
}
|
|
|
|
/* Nope, keep going */
|
|
SectionHeader++;
|
|
}
|
|
}
|
|
|
|
/* Return the matching section */
|
|
return FoundSection;
|
|
}
|
|
|
|
VOID
|
|
BlImgQueryCodeIntegrityBootOptions (
|
|
_In_ PBL_LOADED_APPLICATION_ENTRY ApplicationEntry,
|
|
_Out_ PBOOLEAN IntegrityChecksDisabled,
|
|
_Out_ PBOOLEAN TestSigning
|
|
)
|
|
{
|
|
|
|
NTSTATUS Status;
|
|
BOOLEAN Value;
|
|
|
|
/* Check if /DISABLEINTEGRITYCHECKS is on */
|
|
Status = BlGetBootOptionBoolean(ApplicationEntry->BcdData,
|
|
BcdLibraryBoolean_DisableIntegrityChecks,
|
|
&Value);
|
|
*IntegrityChecksDisabled = NT_SUCCESS(Status) && (Value);
|
|
|
|
/* Check if /TESTSIGNING is on */
|
|
Status = BlGetBootOptionBoolean(ApplicationEntry->BcdData,
|
|
BcdLibraryBoolean_AllowPrereleaseSignatures,
|
|
&Value);
|
|
*TestSigning = NT_SUCCESS(Status) && (Value);
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgUnLoadImage (
|
|
_In_ PVOID ImageBase,
|
|
_In_ ULONG ImageSize,
|
|
_In_ ULONG ImageFlags
|
|
)
|
|
{
|
|
/* Check for missing parameters */
|
|
if (!(ImageSize) || !(ImageBase))
|
|
{
|
|
/* Bail out */
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Unallocate the image buffer */
|
|
return BlImgUnallocateImageBuffer(ImageBase, ImageSize, ImageFlags);
|
|
}
|
|
|
|
NTSTATUS
|
|
ImgpLoadPEImage (
|
|
_In_ PBL_IMG_FILE ImageFile,
|
|
_In_ BL_MEMORY_TYPE MemoryType,
|
|
_Inout_ PVOID* ImageBase,
|
|
_Out_opt_ PULONG ImageSize,
|
|
_Inout_opt_ PVOID Hash,
|
|
_In_ ULONG Flags
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
ULONG FileSize, HeaderSize;
|
|
BL_IMG_FILE LocalFileBuffer;
|
|
PBL_IMG_FILE LocalFile;
|
|
PVOID VirtualAddress, PreferredBase, ImageBuffer, CertBuffer, HashBuffer;
|
|
ULONGLONG VirtualSize;
|
|
PIMAGE_DATA_DIRECTORY CertDirectory;
|
|
PHYSICAL_ADDRESS PhysicalAddress;
|
|
PIMAGE_NT_HEADERS NtHeaders;
|
|
USHORT SectionCount, CheckSum, PartialSum, FinalSum;
|
|
PIMAGE_SECTION_HEADER Section;
|
|
ULONG_PTR EndOfHeaders, SectionStart, Slack, SectionEnd;
|
|
ULONG i, SectionSize, RawSize, BytesRead, RemainingLength, Offset, AlignSize;
|
|
BOOLEAN First, ImageHashValid;
|
|
UCHAR LocalBuffer[1024];
|
|
UCHAR TrustedBootInformation[52];
|
|
ULONG WorkaroundForBinutils;
|
|
|
|
/* Initialize locals */
|
|
WorkaroundForBinutils = 0;
|
|
LocalFile = NULL;
|
|
ImageBuffer = NULL;
|
|
FileSize = 0;
|
|
First = FALSE;
|
|
VirtualAddress = NULL;
|
|
CertBuffer = NULL;
|
|
CertDirectory = NULL;
|
|
HashBuffer = NULL;
|
|
Offset = 0;
|
|
VirtualSize = 0;
|
|
ImageHashValid = FALSE;
|
|
RtlZeroMemory(&TrustedBootInformation, sizeof(TrustedBootInformation));
|
|
|
|
/* Get the size of the image */
|
|
Status = ImgpGetFileSize(ImageFile, &FileSize);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return STATUS_FILE_INVALID;
|
|
}
|
|
|
|
/* Allocate a flat buffer for it */
|
|
Status = BlImgAllocateImageBuffer(&ImageBuffer, BlLoaderData, FileSize, 0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Read the whole file flat for now */
|
|
Status = ImgpReadAtFileOffset(ImageFile, FileSize, 0, ImageBuffer, NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Build a local file handle */
|
|
LocalFile = &LocalFileBuffer;
|
|
LocalFileBuffer.FileName = ImageFile->FileName;
|
|
LocalFileBuffer.Flags = BL_IMG_MEMORY_FILE | BL_IMG_VALID_FILE;
|
|
LocalFileBuffer.BaseAddress = ImageBuffer;
|
|
LocalFileBuffer.FileSize = FileSize;
|
|
|
|
/* Get the NT headers of the file */
|
|
Status = RtlImageNtHeaderEx(0, ImageBuffer, FileSize, &NtHeaders);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Check if we should validate the machine type */
|
|
if (Flags & BL_LOAD_PE_IMG_CHECK_MACHINE)
|
|
{
|
|
/* Is it different than our current machine type? */
|
|
#if _M_AMD64
|
|
if (NtHeaders->FileHeader.Machine != IMAGE_FILE_MACHINE_AMD64)
|
|
#else
|
|
if (NtHeaders->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
|
|
#endif
|
|
{
|
|
/* Is it x86 (implying we are x64) ? */
|
|
if (NtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
/* Return special error code */
|
|
Status = STATUS_INVALID_IMAGE_WIN_32;
|
|
}
|
|
else if (NtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
|
|
{
|
|
/* Otherwise, it's x64 but we are x86 */
|
|
Status = STATUS_INVALID_IMAGE_WIN_64;
|
|
}
|
|
else
|
|
{
|
|
/* Or it's ARM or something... */
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
}
|
|
|
|
/* Return with the distinguished error code */
|
|
goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* Check if we should validate the subsystem */
|
|
if (Flags & BL_LOAD_PE_IMG_CHECK_SUBSYSTEM)
|
|
{
|
|
/* It must be a Windows boot Application */
|
|
if (NtHeaders->OptionalHeader.Subsystem !=
|
|
IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION)
|
|
{
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* Check if we should validate the /INTEGRITYCHECK flag */
|
|
if (Flags & BL_LOAD_PE_IMG_CHECK_FORCED_INTEGRITY)
|
|
{
|
|
/* Check if it's there */
|
|
if (!(NtHeaders->OptionalHeader.DllCharacteristics &
|
|
IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY))
|
|
{
|
|
/* Nope, fail otherwise */
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* Check if we should compute the image hash */
|
|
if ((Flags & BL_LOAD_PE_IMG_COMPUTE_HASH) || (Hash))
|
|
{
|
|
EfiPrintf(L"No hash support\r\n");
|
|
}
|
|
|
|
/* Read the current base address, if any */
|
|
VirtualAddress = *ImageBase;
|
|
|
|
/* Get the virtual size of the image */
|
|
VirtualSize = NtHeaders->OptionalHeader.SizeOfImage;
|
|
|
|
/* Safely align the virtual size to a page */
|
|
Status = RtlULongLongAdd(VirtualSize,
|
|
PAGE_SIZE - 1,
|
|
&VirtualSize);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
VirtualSize = ALIGN_DOWN_BY(VirtualSize, PAGE_SIZE);
|
|
|
|
/* Make sure the image isn't larger than 4GB */
|
|
if (VirtualSize > ULONG_MAX)
|
|
{
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Check if we have a buffer already */
|
|
if (Flags & BL_LOAD_IMG_EXISTING_BUFFER)
|
|
{
|
|
/* Check if it's too small */
|
|
if (*ImageSize < VirtualSize)
|
|
{
|
|
/* Fail, letting the caller know how big to make it */
|
|
*ImageSize = VirtualSize;
|
|
Status = STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Allocate the buffer with the flags and type the caller wants */
|
|
Status = BlImgAllocateImageBuffer(&VirtualAddress,
|
|
MemoryType,
|
|
VirtualSize,
|
|
Flags);
|
|
}
|
|
|
|
/* Bail out if allocation failed, or existing buffer is too small */
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Read the size of the headers */
|
|
HeaderSize = NtHeaders->OptionalHeader.SizeOfHeaders;
|
|
if (VirtualSize < HeaderSize)
|
|
{
|
|
/* Bail out if they're bigger than the image! */
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Now read the header into the buffer */
|
|
Status = ImgpReadAtFileOffset(LocalFile, HeaderSize, 0, VirtualAddress, NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Get the NT headers of the file */
|
|
Status = RtlImageNtHeaderEx(0, VirtualAddress, HeaderSize, &NtHeaders);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
First = FALSE;
|
|
|
|
/* Record how many sections we have */
|
|
SectionCount = NtHeaders->FileHeader.NumberOfSections;
|
|
|
|
/* Capture the current checksum and reset it */
|
|
CheckSum = NtHeaders->OptionalHeader.CheckSum;
|
|
NtHeaders->OptionalHeader.CheckSum = 0;
|
|
|
|
/* Calculate the checksum of the header, and restore the original one */
|
|
PartialSum = BlUtlCheckSum(0,
|
|
VirtualAddress,
|
|
HeaderSize,
|
|
BL_UTL_CHECKSUM_COMPLEMENT |
|
|
BL_UTL_CHECKSUM_USHORT_BUFFER);
|
|
NtHeaders->OptionalHeader.CheckSum = CheckSum;
|
|
|
|
/* Record our current position (right after the headers) */
|
|
EndOfHeaders = (ULONG_PTR)VirtualAddress + HeaderSize;
|
|
|
|
/* Get the first section and iterate through each one */
|
|
Section = IMAGE_FIRST_SECTION(NtHeaders);
|
|
for (i = 0; i < SectionCount; i++)
|
|
{
|
|
/* Compute where this section starts */
|
|
SectionStart = (ULONG_PTR)VirtualAddress + Section->VirtualAddress;
|
|
|
|
/* Make sure that the section fits within the image */
|
|
if ((VirtualSize < Section->VirtualAddress) ||
|
|
((PVOID)SectionStart < VirtualAddress))
|
|
{
|
|
EfiPrintf(L"fail 1\r\n");
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Check if there's slack space between header end and the section */
|
|
if (!(First) && (EndOfHeaders < SectionStart))
|
|
{
|
|
/* Zero it out */
|
|
Slack = SectionStart - EndOfHeaders;
|
|
RtlZeroMemory((PVOID)EndOfHeaders, Slack);
|
|
}
|
|
|
|
/* Get the section virtual size and the raw size */
|
|
SectionSize = Section->Misc.VirtualSize;
|
|
RawSize = Section->SizeOfRawData;
|
|
|
|
/* Safely align the raw size by 2 */
|
|
Status = RtlULongAdd(RawSize, 1, &AlignSize);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
AlignSize = ALIGN_DOWN_BY(AlignSize, 2);
|
|
|
|
/* IF we don't have a virtual size, use the raw size */
|
|
if (!SectionSize)
|
|
{
|
|
SectionSize = RawSize;
|
|
}
|
|
|
|
/* If we don't have raw data, ignore the raw size */
|
|
if (!Section->PointerToRawData)
|
|
{
|
|
RawSize = 0;
|
|
}
|
|
else if (SectionSize < RawSize)
|
|
{
|
|
/* And if the virtual size is smaller, use it as the final size */
|
|
RawSize = SectionSize;
|
|
}
|
|
|
|
/* Make sure that the section doesn't overflow in memory */
|
|
Status = RtlULongPtrAdd(Section->VirtualAddress,
|
|
SectionSize,
|
|
&SectionEnd);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
EfiPrintf(L"fail 21\r\n");
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Make sure that it fits within the image */
|
|
if (VirtualSize < SectionEnd)
|
|
{
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Make sure it doesn't overflow on disk */
|
|
Status = RtlULongPtrAdd(Section->VirtualAddress,
|
|
AlignSize,
|
|
&SectionEnd);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
EfiPrintf(L"fail 31\r\n");
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Make sure that it fits within the disk image as well */
|
|
if (VirtualSize < SectionEnd)
|
|
{
|
|
Status = STATUS_INVALID_IMAGE_FORMAT;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* So does this section have a valid size after all? */
|
|
if (RawSize)
|
|
{
|
|
/* Are we in the first iteration? */
|
|
if (!First)
|
|
{
|
|
/* FUCK YOU BINUTILS */
|
|
if (NtHeaders->OptionalHeader.MajorLinkerVersion < 7)
|
|
{
|
|
if ((*(PULONG)&Section->Name == 'ler.') && (RawSize < AlignSize))
|
|
{
|
|
/* Piece of shit won't build relocations when you tell it to,
|
|
* either by using --emit-relocs or --dynamicbase. People online
|
|
* have found out that by using -pie-executable you can get this
|
|
* to happen, but then it turns out that the .reloc section is
|
|
* incorrectly sized, and results in a corrupt PE. However, they
|
|
* still compute the checksum using the correct value. What idiots.
|
|
*/
|
|
WorkaroundForBinutils = AlignSize - RawSize;
|
|
AlignSize -= WorkaroundForBinutils;
|
|
}
|
|
}
|
|
|
|
/* Yes, read the section data */
|
|
Status = ImgpReadAtFileOffset(LocalFile,
|
|
AlignSize,
|
|
Section->PointerToRawData,
|
|
(PVOID)SectionStart,
|
|
NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Update our current offset */
|
|
Offset = AlignSize + Section->PointerToRawData;
|
|
|
|
/* Update the checksum to include this section */
|
|
PartialSum = BlUtlCheckSum(PartialSum,
|
|
(PUCHAR)SectionStart,
|
|
AlignSize,
|
|
BL_UTL_CHECKSUM_COMPLEMENT |
|
|
BL_UTL_CHECKSUM_USHORT_BUFFER);
|
|
AlignSize += WorkaroundForBinutils;
|
|
}
|
|
}
|
|
|
|
/* Are we in the first iteration? */
|
|
if (!First)
|
|
{
|
|
/* Is there space at the end of the section? */
|
|
if (RawSize < SectionSize)
|
|
{
|
|
/* Zero out the slack space that's there */
|
|
Slack = SectionSize - RawSize;
|
|
RtlZeroMemory((PVOID)(SectionStart + RawSize), Slack);
|
|
}
|
|
|
|
/* Update our tail offset */
|
|
EndOfHeaders = SectionStart + SectionSize;
|
|
}
|
|
|
|
/* Move to the next section */
|
|
Section++;
|
|
}
|
|
|
|
/* Are we in the first iteration? */
|
|
if (!First)
|
|
{
|
|
/* Go to the end of the file */
|
|
SectionStart = (ULONG_PTR)VirtualAddress + VirtualSize;
|
|
|
|
/* Is there still some slack space left? */
|
|
if (EndOfHeaders < SectionStart)
|
|
{
|
|
/* Zero it out */
|
|
Slack = SectionStart - EndOfHeaders;
|
|
RtlZeroMemory((PVOID)EndOfHeaders, Slack);
|
|
}
|
|
}
|
|
|
|
/* Did the first iteration complete OK? */
|
|
if ((NT_SUCCESS(Status)) && !(First))
|
|
{
|
|
/* Check how many non-image bytes are left in the file */
|
|
RemainingLength = FileSize - Offset;
|
|
while (RemainingLength)
|
|
{
|
|
/* See if the read will fit into our local buffer */
|
|
if (RemainingLength >= sizeof(LocalBuffer))
|
|
{
|
|
/* Nope, cap it */
|
|
BytesRead = sizeof(LocalBuffer);
|
|
}
|
|
else
|
|
{
|
|
/* Yes, but there's less to read */
|
|
BytesRead = RemainingLength;
|
|
}
|
|
|
|
/* Read 1024 bytes into the local buffer */
|
|
Status = ImgpReadAtFileOffset(LocalFile,
|
|
BytesRead,
|
|
Offset,
|
|
LocalBuffer,
|
|
&BytesRead);
|
|
if (!(NT_SUCCESS(Status)) || !(BytesRead))
|
|
{
|
|
Status = STATUS_FILE_INVALID;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Advance the offset and reduce the length */
|
|
RemainingLength -= BytesRead;
|
|
Offset += BytesRead;
|
|
|
|
/* Compute the checksum of this leftover space */
|
|
PartialSum = BlUtlCheckSum(PartialSum,
|
|
LocalBuffer,
|
|
BytesRead,
|
|
BL_UTL_CHECKSUM_COMPLEMENT |
|
|
BL_UTL_CHECKSUM_USHORT_BUFFER);
|
|
}
|
|
|
|
/* Finally, calculate the final checksum and compare it */
|
|
FinalSum = FileSize + PartialSum + WorkaroundForBinutils;
|
|
if ((FinalSum != CheckSum) && (PartialSum == 0xFFFF))
|
|
{
|
|
/* It hit overflow, so set it to the file size */
|
|
FinalSum = FileSize;
|
|
}
|
|
|
|
/* If the checksum doesn't match, and caller is enforcing, bail out */
|
|
if ((FinalSum != CheckSum) &&
|
|
!(Flags & BL_LOAD_PE_IMG_IGNORE_CHECKSUM_MISMATCH))
|
|
{
|
|
Status = STATUS_IMAGE_CHECKSUM_MISMATCH;
|
|
goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* Check if the .rsrc section should be checked with the filename */
|
|
if (Flags & BL_LOAD_PE_IMG_VALIDATE_ORIGINAL_FILENAME)
|
|
{
|
|
EfiPrintf(L"Not yet supported\r\n");
|
|
Status = 0xC0430007; // STATUS_SECUREBOOT_FILE_REPLACED
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Check if we should relocate */
|
|
if (!(Flags & BL_LOAD_PE_IMG_SKIP_RELOCATIONS))
|
|
{
|
|
/* Check if we loaded at a different address */
|
|
PreferredBase = (PVOID)NtHeaders->OptionalHeader.ImageBase;
|
|
if (VirtualAddress != PreferredBase)
|
|
{
|
|
/* Yep -- do relocations */
|
|
Status = LdrRelocateImage(VirtualAddress,
|
|
"Boot Environment Library",
|
|
STATUS_SUCCESS,
|
|
STATUS_UNSUCCESSFUL,
|
|
STATUS_INVALID_IMAGE_FORMAT);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
/* That's bad */
|
|
goto Quickie;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if BL_TPM_SUPPORT
|
|
/* Check if the image hash was valid */
|
|
if (!ImageHashValid)
|
|
{
|
|
/* Send a TPM/SI notification without a context */
|
|
BlEnNotifyEvent(0x10000002, NULL);
|
|
}
|
|
|
|
/* Now send a TPM/SI notification with the hash of the loaded image */
|
|
BlMmTranslateVirtualAddress(VirtualAddress, &Context.ImageBase);
|
|
Context.HashAlgorithm = HashAlgorithm;
|
|
Context.HashSize = HashSize;
|
|
Context.FileName = ImageFile->FileName;
|
|
Context.ImageSize = VirtualSize;
|
|
Context.HashValid = ImageHashValid;
|
|
Context.Hash = Hash;
|
|
BlEnNotifyEvent(0x10000002, &Context);
|
|
#endif
|
|
|
|
/* Return the loaded address to the caller */
|
|
*ImageBase = VirtualAddress;
|
|
|
|
/* If the caller wanted the image size, return it too */
|
|
if (ImageSize)
|
|
{
|
|
*ImageSize = VirtualSize;
|
|
}
|
|
|
|
Quickie:
|
|
/* Check if we computed the image hash OK */
|
|
if (ImageHashValid)
|
|
{
|
|
/* Then free the information that ImgpValidateImageHash set up */
|
|
EfiPrintf(L"leadking trusted boot\r\n");
|
|
//ImgpDestroyTrustedBootInformation(&TrustedBootInformation);
|
|
}
|
|
|
|
/* Check if we had a hash buffer */
|
|
if (HashBuffer)
|
|
{
|
|
/* Free it */
|
|
MmPapFreePages(HashBuffer, BL_MM_INCLUDE_MAPPED_ALLOCATED);
|
|
}
|
|
|
|
/* Check if we have a certificate directory */
|
|
if ((CertBuffer) && (CertDirectory))
|
|
{
|
|
/* Free it */
|
|
BlImgUnallocateImageBuffer(CertBuffer, CertDirectory->Size, 0);
|
|
}
|
|
|
|
/* Check if we had an image buffer allocated */
|
|
if ((ImageBuffer) && (FileSize))
|
|
{
|
|
/* Free it */
|
|
BlImgUnallocateImageBuffer(ImageBuffer, FileSize, 0);
|
|
}
|
|
|
|
/* Check if we had a local file handle */
|
|
if (LocalFile)
|
|
{
|
|
/* Close it */
|
|
ImgpCloseFile(LocalFile);
|
|
}
|
|
|
|
/* Check if this is the failure path */
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
/* Check if we had started mapping in the image already */
|
|
if ((VirtualAddress) && !(Flags & BL_LOAD_PE_IMG_EXISTING_BUFFER))
|
|
{
|
|
/* Into a virtual buffer? */
|
|
if (Flags & BL_LOAD_PE_IMG_VIRTUAL_BUFFER)
|
|
{
|
|
/* Unmap and free it */
|
|
BlMmUnmapVirtualAddressEx(VirtualAddress, VirtualSize);
|
|
PhysicalAddress.QuadPart = (ULONG_PTR)VirtualAddress;
|
|
BlMmFreePhysicalPages(PhysicalAddress);
|
|
}
|
|
else
|
|
{
|
|
/* Into a physical buffer -- free it */
|
|
MmPapFreePages(VirtualAddress, BL_MM_INCLUDE_MAPPED_ALLOCATED);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Return back to caller */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgLoadPEImageEx (
|
|
_In_ ULONG DeviceId,
|
|
_In_ BL_MEMORY_TYPE MemoryType,
|
|
_In_ PWCHAR Path,
|
|
_Out_ PVOID* ImageBase,
|
|
_Out_ PULONG ImageSize,
|
|
_Out_ PVOID Hash,
|
|
_In_ ULONG Flags
|
|
)
|
|
{
|
|
BL_IMG_FILE ImageFile;
|
|
NTSTATUS Status;
|
|
|
|
/* Initialize the image file structure */
|
|
ImageFile.Flags = 0;
|
|
ImageFile.FileName = NULL;
|
|
|
|
/* Check if the required parameter are missing */
|
|
if (!(ImageBase) || !(Path))
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* If we are loading a pre-allocated image, make sure we have it */
|
|
if ((Flags & BL_LOAD_IMG_EXISTING_BUFFER) && (!(*ImageBase) || !(ImageSize)))
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Load the file from disk */
|
|
Status = ImgpOpenFile(DeviceId, Path, 0, &ImageFile);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* If that worked, do the PE parsing */
|
|
Status = ImgpLoadPEImage(&ImageFile,
|
|
MemoryType,
|
|
ImageBase,
|
|
ImageSize,
|
|
Hash,
|
|
Flags);
|
|
}
|
|
|
|
/* Close the image file and return back to caller */
|
|
ImgpCloseFile(&ImageFile);
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgLoadBootApplication (
|
|
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry,
|
|
_Out_ PULONG AppHandle
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
PULONGLONG AllowedList;
|
|
ULONGLONG AllowedCount;
|
|
ULONG i, DeviceId, ImageSize, Flags, ListSize;
|
|
LARGE_INTEGER Frequency;
|
|
PVOID UnlockCode, ImageBase;
|
|
PBL_DEVICE_DESCRIPTOR Device, BitLockerDevice;
|
|
PWCHAR Path;
|
|
PBL_APPLICATION_ENTRY AppEntry;
|
|
PBL_IMG_FILE ImageFile;
|
|
BOOLEAN DisableIntegrity, TestSigning;
|
|
UCHAR Hash[64];
|
|
PBL_IMAGE_APPLICATION_ENTRY ImageAppEntry;
|
|
|
|
/* Initialize all locals */
|
|
BitLockerDevice = NULL;
|
|
UnlockCode = NULL;
|
|
ImageFile = NULL;
|
|
DeviceId = -1;
|
|
Device = NULL;
|
|
ImageAppEntry = NULL;
|
|
AppEntry = NULL;
|
|
Path = NULL;
|
|
ImageSize = 0;
|
|
ImageBase = NULL;
|
|
|
|
/* Check for "allowed in-memory settings" */
|
|
Status = BlpGetBootOptionIntegerList(BootEntry->BcdData,
|
|
BcdLibraryIntegerList_AllowedInMemorySettings,
|
|
&AllowedList,
|
|
&AllowedCount,
|
|
TRUE);
|
|
if (Status == STATUS_SUCCESS)
|
|
{
|
|
/* Loop through the list of allowed setting */
|
|
for (i = 0; i < AllowedCount; i++)
|
|
{
|
|
/* Find the super undocumented one */
|
|
if (AllowedList[i] == BcdLibraryInteger_UndocumentedMagic)
|
|
{
|
|
/* If it's present, append the current perf frequence to it */
|
|
BlTimeQueryPerformanceCounter(&Frequency);
|
|
BlAppendBootOptionInteger(BootEntry,
|
|
BcdLibraryInteger_UndocumentedMagic,
|
|
Frequency.QuadPart);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if BL_BITLOCKER_SUPPORT
|
|
/* Do bitlocker stuff */
|
|
Status = BlFveSecureBootUnlockBootDevice(BootEntry, &BitLockerDevice, &UnlockCode);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
#endif
|
|
|
|
/* Get the device on which this application is on*/
|
|
Status = BlGetBootOptionDevice(BootEntry->BcdData,
|
|
BcdLibraryDevice_ApplicationDevice,
|
|
&Device,
|
|
NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Get the path of the application */
|
|
Status = BlGetBootOptionString(BootEntry->BcdData,
|
|
BcdLibraryString_ApplicationPath,
|
|
&Path);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Open the device */
|
|
Status = BlpDeviceOpen(Device,
|
|
BL_DEVICE_READ_ACCESS,
|
|
0,
|
|
&DeviceId);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Check for integrity BCD options */
|
|
BlImgQueryCodeIntegrityBootOptions(BootEntry,
|
|
&DisableIntegrity,
|
|
&TestSigning);
|
|
|
|
#if BL_TPM_SUPPORT
|
|
RtlZeroMemory(&Context, sizeof(Context);
|
|
Context.BootEntry = BootEntry;
|
|
BlEnNotifyEvent(0x10000003, &Context);
|
|
#endif
|
|
|
|
/* Enable signing and hashing checks if integrity is enabled */
|
|
Flags = 0;
|
|
if (!DisableIntegrity)
|
|
{
|
|
Flags = 0x8070;
|
|
}
|
|
|
|
/* Now call the PE loader to load the image */
|
|
Status = BlImgLoadPEImageEx(DeviceId,
|
|
BlLoaderMemory,
|
|
Path,
|
|
&ImageBase,
|
|
&ImageSize,
|
|
Hash,
|
|
Flags);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
#if BL_KD_SUPPORT
|
|
/* Check if we should notify the debugger of load */
|
|
if (BdDebugTransitions)
|
|
{
|
|
/* Initialize it */
|
|
BdForceDebug = 1;
|
|
Status = BlBdInitialize();
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Check if it's enabled */
|
|
if (BlBdDebuggerEnabled())
|
|
{
|
|
/* Send it an image load notification */
|
|
BdDebuggerNotPresent = FALSE;
|
|
RtlInitUnicodeString(&PathString, Path);
|
|
BlBdLoadImageSymbols(&PathString, ImageBase);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if BL_BITLOCKER_SUPPORT
|
|
/* Do bitlocker stuff */
|
|
Status = BlSecureBootCheckPolicyOnFveDevice(BitLockerDevice);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
#endif
|
|
|
|
#if BL_BITLOCKER_SUPPORT
|
|
/* Do bitlocker stuff */
|
|
Status = BlFveSecureBootCheckpointBootApp(BootEntry, BitLockerDevice, Hash, UnlockCode);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
#endif
|
|
|
|
/* Get the BCD option size */
|
|
ListSize = BlGetBootOptionListSize(BootEntry->BcdData);
|
|
|
|
/* Allocate an entry with all the BCD options */
|
|
AppEntry = BlMmAllocateHeap(ListSize + sizeof(*AppEntry));
|
|
if (!AppEntry)
|
|
{
|
|
Status = STATUS_NO_MEMORY;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Zero it out */
|
|
RtlZeroMemory(AppEntry, sizeof(*AppEntry));
|
|
|
|
/* Initialize it */
|
|
strcpy(AppEntry->Signature, "BTAPENT");
|
|
AppEntry->Guid = BootEntry->Guid;
|
|
AppEntry->Flags = BootEntry->Flags;
|
|
|
|
/* Copy the BCD options */
|
|
RtlCopyMemory(&AppEntry->BcdData, BootEntry->BcdData, ListSize);
|
|
|
|
/* Allocate the image entry */
|
|
ImageAppEntry = BlMmAllocateHeap(sizeof(*ImageAppEntry));
|
|
if (!ImageAppEntry)
|
|
{
|
|
Status = STATUS_NO_MEMORY;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Initialize it */
|
|
ImageAppEntry->ImageBase = ImageBase;
|
|
ImageAppEntry->ImageSize = ImageSize;
|
|
ImageAppEntry->AppEntry = AppEntry;
|
|
|
|
/* Check if this is the first entry */
|
|
if (!IapTableEntries)
|
|
{
|
|
/* Allocate two entries */
|
|
IapAllocatedTableEntries = 0;
|
|
IapTableEntries = 2;
|
|
IapImageTable = BlMmAllocateHeap(IapTableEntries * sizeof(PVOID));
|
|
if (!IapImageTable)
|
|
{
|
|
Status = STATUS_NO_MEMORY;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Zero out the entries for now */
|
|
RtlZeroMemory(IapImageTable, IapTableEntries * sizeof(PVOID));
|
|
}
|
|
|
|
/* Set this entry into the table */
|
|
Status = BlTblSetEntry(&IapImageTable,
|
|
&IapTableEntries,
|
|
ImageAppEntry,
|
|
AppHandle,
|
|
TblDoNotPurgeEntry);
|
|
|
|
Quickie:
|
|
/* Is the device open? Close it if so */
|
|
if (DeviceId != 1)
|
|
{
|
|
BlDeviceClose(DeviceId);
|
|
}
|
|
|
|
/* Is there an allocated device? Free it */
|
|
if (Device)
|
|
{
|
|
BlMmFreeHeap(Device);
|
|
}
|
|
|
|
/* Is there an allocated path? Free it */
|
|
if (Path)
|
|
{
|
|
BlMmFreeHeap(Path);
|
|
}
|
|
|
|
/* Is there a bitlocker device? Free it */
|
|
if (BitLockerDevice)
|
|
{
|
|
BlMmFreeHeap(BitLockerDevice);
|
|
}
|
|
|
|
/* Is there a bitlocker unlock code? Free it */
|
|
if (UnlockCode)
|
|
{
|
|
BlMmFreeHeap(UnlockCode);
|
|
}
|
|
|
|
/* Did we succeed in creating an entry? */
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Remember there's one more in the table */
|
|
IapAllocatedTableEntries++;
|
|
|
|
/* Return success */
|
|
return Status;
|
|
}
|
|
|
|
/* Did we load an image after all? */
|
|
if (ImageBase)
|
|
{
|
|
/* Unload it */
|
|
BlImgUnLoadImage(ImageBase, ImageSize, 0);
|
|
}
|
|
|
|
/* Did we allocate an app entry? Free it */
|
|
if (AppEntry)
|
|
{
|
|
BlMmFreeHeap(AppEntry);
|
|
}
|
|
|
|
/* Do we have an image file entry? Free it */
|
|
if (ImageFile)
|
|
{
|
|
BlMmFreeHeap(ImageFile);
|
|
}
|
|
|
|
/* Do we no longer have a single entry in the table? */
|
|
if (!(IapAllocatedTableEntries) && (IapImageTable))
|
|
{
|
|
/* Free and destroy the table */
|
|
BlMmFreeHeap(IapImageTable);
|
|
IapTableEntries = 0;
|
|
IapImageTable = NULL;
|
|
}
|
|
|
|
/* Return the failure code */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlpPdParseReturnArguments (
|
|
_In_ PBL_RETURN_ARGUMENTS ReturnArguments
|
|
)
|
|
{
|
|
/* Check if any custom data was returned */
|
|
if (ReturnArguments->DataPage == 0)
|
|
{
|
|
/* Nope, nothing to do */
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Yes, we have to parse it */
|
|
EfiPrintf(L"Return arguments not supported\r\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NTSTATUS
|
|
ImgpCopyApplicationBootDevice (
|
|
__in PBL_DEVICE_DESCRIPTOR DestinationDevice,
|
|
__in PBL_DEVICE_DESCRIPTOR SourceDevice
|
|
)
|
|
{
|
|
/* Is this a partition device? */
|
|
if (SourceDevice->DeviceType != PartitionDevice)
|
|
{
|
|
/* It's not -- a simple copy will do */
|
|
RtlCopyMemory(DestinationDevice, SourceDevice, SourceDevice->Size);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* TODO */
|
|
EfiPrintf(L"Partition copy not supported\r\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
ImgpInitializeBootApplicationParameters (
|
|
_In_ PBL_BUFFER_DESCRIPTOR ImageParameters,
|
|
_In_ PBL_APPLICATION_ENTRY AppEntry,
|
|
_In_ PVOID ImageBase,
|
|
_In_ ULONG ImageSize
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
PIMAGE_NT_HEADERS NtHeaders;
|
|
BL_BUFFER_DESCRIPTOR MemoryParameters;
|
|
LIST_ENTRY MemoryList;
|
|
PBL_FIRMWARE_DESCRIPTOR FirmwareParameters;
|
|
PBL_DEVICE_DESCRIPTOR BootDevice;
|
|
PBL_MEMORY_DATA MemoryData;
|
|
PBL_APPLICATION_ENTRY BootAppEntry;
|
|
PBL_RETURN_ARGUMENTS ReturnArguments;
|
|
PBOOT_APPLICATION_PARAMETER_BLOCK ParameterBlock;
|
|
ULONG EntrySize, BufferSize;
|
|
|
|
/* Get the image headers and validate it */
|
|
Status = RtlImageNtHeaderEx(0, ImageBase, ImageSize, &NtHeaders);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
/* Get the size of the entire non-firmware, allocated, memory map */
|
|
MemoryParameters.BufferSize = 0;
|
|
Status = BlMmGetMemoryMap(&MemoryList,
|
|
&MemoryParameters,
|
|
BL_MM_INCLUDE_PERSISTENT_MEMORY |
|
|
BL_MM_INCLUDE_MAPPED_ALLOCATED |
|
|
BL_MM_INCLUDE_MAPPED_UNALLOCATED |
|
|
BL_MM_INCLUDE_UNMAPPED_ALLOCATED |
|
|
BL_MM_INCLUDE_RESERVED_ALLOCATED,
|
|
0);
|
|
if ((Status != STATUS_BUFFER_TOO_SMALL) && (Status != STATUS_SUCCESS))
|
|
{
|
|
/* We failed due to an unknown reason -- bail out */
|
|
return Status;
|
|
}
|
|
|
|
/* Compute the list of the BCD plus the application entry */
|
|
EntrySize = BlGetBootOptionListSize(&AppEntry->BcdData) +
|
|
FIELD_OFFSET(BL_APPLICATION_ENTRY, BcdData);
|
|
|
|
/* Compute the total size required for the entire structure */
|
|
BufferSize = EntrySize +
|
|
BlpBootDevice->Size +
|
|
MemoryParameters.BufferSize +
|
|
sizeof(*ReturnArguments) +
|
|
sizeof(*MemoryData) +
|
|
sizeof(*FirmwareParameters) +
|
|
sizeof(*ParameterBlock);
|
|
|
|
/* Check if this gives us enough space */
|
|
if (ImageParameters->BufferSize < BufferSize)
|
|
{
|
|
/* It does not -- free the existing buffer */
|
|
if (ImageParameters->BufferSize)
|
|
{
|
|
BlMmFreeHeap(ImageParameters->Buffer);
|
|
}
|
|
|
|
/* Allocate a new buffer of sufficient size */
|
|
ImageParameters->BufferSize = BufferSize;
|
|
ImageParameters->Buffer = BlMmAllocateHeap(BufferSize);
|
|
if (!ImageParameters->Buffer)
|
|
{
|
|
/* Bail out if we couldn't allocate it */
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
}
|
|
|
|
/* Zero out the parameter block */
|
|
ParameterBlock = (PBOOT_APPLICATION_PARAMETER_BLOCK)ImageParameters->Buffer;
|
|
RtlZeroMemory(ParameterBlock, BufferSize);
|
|
|
|
/* Initialize it */
|
|
ParameterBlock->Version = BOOT_APPLICATION_VERSION;
|
|
ParameterBlock->Size = BufferSize;
|
|
ParameterBlock->Signature[0] = BOOT_APPLICATION_SIGNATURE_1;
|
|
ParameterBlock->Signature[1] = BOOT_APPLICATION_SIGNATURE_2;
|
|
ParameterBlock->MemoryTranslationType = MmTranslationType;
|
|
ParameterBlock->ImageType = IMAGE_FILE_MACHINE_I386;
|
|
ParameterBlock->ImageBase = (ULONG_PTR)ImageBase;
|
|
ParameterBlock->ImageSize = NtHeaders->OptionalHeader.SizeOfImage;
|
|
|
|
/* Get the offset to the memory data */
|
|
ParameterBlock->MemoryDataOffset = sizeof(*ParameterBlock);
|
|
|
|
/* Fill it out */
|
|
MemoryData = (PBL_MEMORY_DATA)((ULONG_PTR)ParameterBlock +
|
|
ParameterBlock->MemoryDataOffset);
|
|
MemoryData->Version = BL_MEMORY_DATA_VERSION;
|
|
MemoryData->MdListOffset = sizeof(*MemoryData);
|
|
MemoryData->DescriptorSize = sizeof(BL_MEMORY_DESCRIPTOR);
|
|
MemoryData->DescriptorOffset = FIELD_OFFSET(BL_MEMORY_DESCRIPTOR, BasePage);
|
|
|
|
/* And populate the memory map */
|
|
MemoryParameters.Buffer = MemoryData + 1;
|
|
Status = BlMmGetMemoryMap(&MemoryList,
|
|
&MemoryParameters,
|
|
BL_MM_INCLUDE_PERSISTENT_MEMORY |
|
|
BL_MM_INCLUDE_MAPPED_ALLOCATED |
|
|
BL_MM_INCLUDE_MAPPED_UNALLOCATED |
|
|
BL_MM_INCLUDE_UNMAPPED_ALLOCATED |
|
|
BL_MM_INCLUDE_RESERVED_ALLOCATED,
|
|
0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
/* Now that we have the map, indicate the number of descriptors */
|
|
MemoryData->DescriptorCount = MemoryParameters.ActualSize /
|
|
MemoryData->DescriptorSize;
|
|
|
|
/* Get the offset to the application entry */
|
|
ParameterBlock->AppEntryOffset = ParameterBlock->MemoryDataOffset +
|
|
MemoryData->MdListOffset +
|
|
MemoryParameters.BufferSize;
|
|
|
|
/* Fill it out */
|
|
BootAppEntry = (PBL_APPLICATION_ENTRY)((ULONG_PTR)ParameterBlock +
|
|
ParameterBlock->AppEntryOffset);
|
|
RtlCopyMemory(BootAppEntry, AppEntry, EntrySize);
|
|
|
|
/* Get the offset to the boot device */
|
|
ParameterBlock->BootDeviceOffset = ParameterBlock->AppEntryOffset +
|
|
EntrySize;
|
|
|
|
/* Fill it out */
|
|
BootDevice = (PBL_DEVICE_DESCRIPTOR)((ULONG_PTR)ParameterBlock +
|
|
ParameterBlock->BootDeviceOffset);
|
|
Status = ImgpCopyApplicationBootDevice(BootDevice, BlpBootDevice);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
/* Get the offset to the firmware data */
|
|
ParameterBlock->FirmwareParametersOffset = ParameterBlock->BootDeviceOffset +
|
|
BootDevice->Size;
|
|
|
|
/* Fill it out */
|
|
FirmwareParameters = (PBL_FIRMWARE_DESCRIPTOR)((ULONG_PTR)ParameterBlock +
|
|
ParameterBlock->
|
|
FirmwareParametersOffset);
|
|
Status = BlFwGetParameters(FirmwareParameters);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
/* Get the offset to the return arguments */
|
|
ParameterBlock->ReturnArgumentsOffset = ParameterBlock->FirmwareParametersOffset +
|
|
sizeof(BL_FIRMWARE_DESCRIPTOR);
|
|
|
|
/* Fill them out */
|
|
ReturnArguments = (PBL_RETURN_ARGUMENTS)((ULONG_PTR)ParameterBlock +
|
|
ParameterBlock->
|
|
ReturnArgumentsOffset);
|
|
ReturnArguments->Version = BL_RETURN_ARGUMENTS_VERSION;
|
|
ReturnArguments->DataPage = 0;
|
|
ReturnArguments->DataSize = 0;
|
|
|
|
/* Structure complete */
|
|
ImageParameters->ActualSize = ParameterBlock->ReturnArgumentsOffset +
|
|
sizeof(*ReturnArguments);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
ImgArchEfiStartBootApplication (
|
|
_In_ PBL_APPLICATION_ENTRY AppEntry,
|
|
_In_ PVOID ImageBase,
|
|
_In_ ULONG ImageSize,
|
|
_In_ PBL_RETURN_ARGUMENTS ReturnArguments
|
|
)
|
|
{
|
|
#ifndef _M_ARM
|
|
KDESCRIPTOR Gdt, Idt;
|
|
ULONG BootSizeNeeded;
|
|
NTSTATUS Status;
|
|
PVOID BootData;
|
|
PIMAGE_NT_HEADERS NtHeaders;
|
|
PVOID NewStack, NewGdt, NewIdt;
|
|
BL_BUFFER_DESCRIPTOR Parameters;
|
|
|
|
/* Read the current IDT and GDT */
|
|
_sgdt(&Gdt.Limit);
|
|
__sidt(&Idt.Limit);
|
|
|
|
/* Allocate space for the IDT, GDT, and 24 pages of stack */
|
|
BootSizeNeeded = (ULONG_PTR)PAGE_ALIGN(Idt.Limit + Gdt.Limit + 1 + 25 * PAGE_SIZE);
|
|
Status = MmPapAllocatePagesInRange(&BootData,
|
|
BlLoaderArchData,
|
|
BootSizeNeeded >> PAGE_SHIFT,
|
|
0,
|
|
0,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Zero the boot data */
|
|
RtlZeroMemory(BootData, BootSizeNeeded);
|
|
|
|
/* Set the new stack, GDT and IDT */
|
|
NewStack = (PVOID)((ULONG_PTR)BootData + (24 * PAGE_SIZE) - 8);
|
|
NewGdt = (PVOID)((ULONG_PTR)BootData + (24 * PAGE_SIZE));
|
|
NewIdt = (PVOID)((ULONG_PTR)BootData + (24 * PAGE_SIZE) + Gdt.Limit + 1);
|
|
|
|
/* Copy the current (firmware) GDT and IDT */
|
|
RtlCopyMemory(NewGdt, (PVOID)Gdt.Base, Gdt.Limit + 1);
|
|
RtlCopyMemory(NewIdt, (PVOID)Idt.Base, Idt.Limit + 1);
|
|
|
|
/* Read the NT headers so that we can get the entrypoint later on */
|
|
RtlImageNtHeaderEx(0, ImageBase, ImageSize, &NtHeaders);
|
|
|
|
/* Prepare the application parameters */
|
|
RtlZeroMemory(&Parameters, sizeof(Parameters));
|
|
Status = ImgpInitializeBootApplicationParameters(&Parameters,
|
|
AppEntry,
|
|
ImageBase,
|
|
ImageSize);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Set the firmware GDT/IDT as the one the application will use */
|
|
BootAppGdtRegister = Gdt;
|
|
BootAppIdtRegister = Idt;
|
|
|
|
/* Set the entrypoint, parameters, and stack */
|
|
BootApp32EntryRoutine = (PVOID)((ULONG_PTR)ImageBase +
|
|
NtHeaders->OptionalHeader.
|
|
AddressOfEntryPoint);
|
|
BootApp32Parameters = Parameters.Buffer;
|
|
BootApp32Stack = NewStack;
|
|
|
|
#if BL_KD_SUPPORT
|
|
/* Disable the kernel debugger */
|
|
BlBdStop();
|
|
#endif
|
|
/* Make it so */
|
|
Archx86TransferTo32BitApplicationAsm();
|
|
|
|
/* Not yet implemented. This is the last step! */
|
|
EfiPrintf(L"EFI APPLICATION RETURNED!!!\r\n");
|
|
EfiStall(100000000);
|
|
|
|
#if BL_KD_SUPPORT
|
|
/* Re-enable the kernel debugger */
|
|
BlBdStart();
|
|
#endif
|
|
}
|
|
|
|
Quickie:
|
|
/* Check if we had boot data allocated */
|
|
if (BootData)
|
|
{
|
|
/* Free it */
|
|
MmPapFreePages(BootData, BL_MM_INCLUDE_MAPPED_ALLOCATED);
|
|
}
|
|
#else
|
|
EfiPrintf(L"ImgArchEfiStartBootApplication not implemented for this platform.\r\n");
|
|
#endif
|
|
|
|
/* All done */
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgStartBootApplication (
|
|
_In_ ULONG AppHandle,
|
|
_Inout_opt_ PBL_RETURN_ARGUMENTS ReturnArguments
|
|
)
|
|
{
|
|
PBL_IMAGE_APPLICATION_ENTRY ImageAppEntry;
|
|
BL_RETURN_ARGUMENTS LocalReturnArgs;
|
|
PBL_FILE_SYSTEM_ENTRY FileSystem;
|
|
PLIST_ENTRY NextEntry, ListHead;
|
|
NTSTATUS Status;
|
|
|
|
/* Check if we don't have an argument structure */
|
|
if (!ReturnArguments)
|
|
{
|
|
/* Initialize a local copy and use it instead */
|
|
LocalReturnArgs.Version = BL_RETURN_ARGUMENTS_VERSION;
|
|
LocalReturnArgs.Status = STATUS_SUCCESS;
|
|
LocalReturnArgs.Flags = 0;
|
|
LocalReturnArgs.DataPage = 0;
|
|
LocalReturnArgs.DataSize = 0;
|
|
ReturnArguments = &LocalReturnArgs;
|
|
}
|
|
|
|
/* Make sure the handle index is valid */
|
|
if (IapTableEntries <= AppHandle)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Get the entry for this handle, making sure it exists */
|
|
ImageAppEntry = IapImageTable[AppHandle];
|
|
if (!ImageAppEntry)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Loop the registered file systems */
|
|
ListHead = &RegisteredFileSystems;
|
|
NextEntry = RegisteredFileSystems.Flink;
|
|
while (NextEntry != ListHead)
|
|
{
|
|
/* Get the filesystem entry */
|
|
FileSystem = CONTAINING_RECORD(NextEntry,
|
|
BL_FILE_SYSTEM_ENTRY,
|
|
ListEntry);
|
|
|
|
/* See if it has a purge callback */
|
|
if (FileSystem->PurgeCallback)
|
|
{
|
|
/* Call it */
|
|
FileSystem->PurgeCallback();
|
|
}
|
|
|
|
/* Move to the next entry */
|
|
NextEntry = NextEntry->Flink;
|
|
}
|
|
|
|
/* TODO -- flush the block I/O cache too */
|
|
//BlockIoPurgeCache();
|
|
|
|
/* Call into EFI land to start the boot application */
|
|
Status = ImgArchEfiStartBootApplication(ImageAppEntry->AppEntry,
|
|
ImageAppEntry->ImageBase,
|
|
ImageAppEntry->ImageSize,
|
|
ReturnArguments);
|
|
|
|
/* Parse any arguments we got on the way back */
|
|
BlpPdParseReturnArguments(ReturnArguments);
|
|
|
|
#if BL_BITLOCKER_SUPPORT
|
|
/* Bitlocker stuff */
|
|
FvebpCheckAllPartitions(TRUE);
|
|
#endif
|
|
|
|
#if BL_TPM_SUPPORT
|
|
/* Notify a TPM/SI event */
|
|
BlEnNotifyEvent(0x10000005, NULL);
|
|
#endif
|
|
|
|
/* Reset the display */
|
|
BlpDisplayReinitialize();
|
|
|
|
/* TODO -- reset ETW */
|
|
//BlpLogInitialize();
|
|
|
|
/* All done */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
BlImgUnloadBootApplication (
|
|
_In_ ULONG AppHandle
|
|
)
|
|
{
|
|
PBL_IMAGE_APPLICATION_ENTRY ImageAppEntry;
|
|
NTSTATUS Status;
|
|
|
|
/* Make sure the handle index is valid */
|
|
if (IapTableEntries <= AppHandle)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Get the entry for this handle, making sure it exists */
|
|
ImageAppEntry = IapImageTable[AppHandle];
|
|
if (!ImageAppEntry)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Unload the image */
|
|
Status = BlImgUnLoadImage(ImageAppEntry->ImageBase,
|
|
ImageAppEntry->ImageSize,
|
|
0);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Normalize the success code */
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
/* Normalize the failure code */
|
|
Status = STATUS_MEMORY_NOT_ALLOCATED;
|
|
}
|
|
|
|
/* Free the entry and the image entry as well */
|
|
BlMmFreeHeap(ImageAppEntry->AppEntry);
|
|
BlMmFreeHeap(ImageAppEntry);
|
|
|
|
/* Clear the handle */
|
|
IapImageTable[AppHandle] = NULL;
|
|
|
|
/* Free one entry */
|
|
if (!(--IapAllocatedTableEntries))
|
|
{
|
|
/* There are no more, so get rid of the table itself */
|
|
BlMmFreeHeap(IapImageTable);
|
|
IapImageTable = NULL;
|
|
IapTableEntries = 0;
|
|
}
|
|
|
|
/* All good */
|
|
return Status;
|
|
}
|