Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-04 19:54:58 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/boot/environ/lib/misc/image.c
Timo Kreuzer 3be4081607
[BOOTLIB] Fix 64 bit issues (#433)
2018-03-18 16:10:41 +01:00

2075 lines
61 KiB
C
Raw Blame History

/*
* 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;
}
Reference in a new issue View git blame Copy permalink