From: Julian Andres Klode <julian.klode@canonical.com>
Date: Mon, 24 Jul 2023 15:26:10 +0200
Subject: efi/peimage: Provide an implementation of load_image, start_image,
 unload_image

The code consumes a PE-COFF image loaded into memory. The functions

* check validity of header
* copy the sections
* relocate the code
* set memory attributes
* invalidate the instruction cache
* execute the image
* return to caller

Caveats:

- We do not always check for over and underflows, but at the
  point we reach this loader, the file has been verified by
  shim already, so this is not much of a concern.

Signed-off-by: Heinrich Schuchardt <heinrich.schuchardt@canonical.com>
Signed-off-by: Julian Andres Klode <julian.klode@canonical.com>
Signed-off-by: Mate Kukri <mate.kukri@canonical.com>
---
 grub-core/Makefile.core.def    |  13 +
 grub-core/loader/efi/peimage.c | 922 +++++++++++++++++++++++++++++++++++++++++
 include/grub/efi/peimage.h     |  19 +
 3 files changed, 954 insertions(+)
 create mode 100644 grub-core/loader/efi/peimage.c
 create mode 100644 include/grub/efi/peimage.h

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index b8bd4b3..8dfb883 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -1890,6 +1890,19 @@ module = {
   common = lib/cmdline.c;
 };
 
+module = {
+  name = peimage;
+  efi = loader/efi/peimage.c;
+  enable = arm_efi;
+  enable = arm64_efi;
+  enable = i386_efi;
+  enable = x86_64_efi;
+  enable = riscv32_efi;
+  enable = riscv64_efi;
+  enable = loongarch64_efi;
+};
+
+
 module = {
   name = fdt;
   efi = loader/efi/fdt.c;
diff --git a/grub-core/loader/efi/peimage.c b/grub-core/loader/efi/peimage.c
new file mode 100644
index 0000000..0d73081
--- /dev/null
+++ b/grub-core/loader/efi/peimage.c
@@ -0,0 +1,922 @@
+/* peimage.c - load EFI PE binaries (for Secure Boot support) */
+
+// SPDX-License-Identifier: GPL-3.0+
+
+#include <grub/cache.h>
+#include <grub/cpu/efi/memory.h>
+#include <grub/dl.h>
+#include <grub/efi/efi.h>
+#include <grub/efi/pe32.h>
+#include <grub/efi/peimage.h>
+#include <grub/efi/sb.h>
+#include <grub/env.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/setjmp.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_dl_t my_mod;
+
+struct image_info
+{
+  void *data;
+  grub_efi_uint32_t data_size;
+  grub_efi_device_path_t *file_path;
+  grub_efi_uint8_t nx_compat;
+  grub_efi_uint16_t machine;
+  grub_efi_uint16_t num_sections;
+  struct grub_pe32_section_table *section;
+  struct grub_pe32_data_directory *reloc;
+  grub_uint64_t image_base;
+  grub_uint32_t section_alignment;
+  grub_uint32_t image_size;
+  grub_uint32_t header_size;
+  void *alloc_addr;
+  grub_uint32_t alloc_pages;
+  void *image_addr;
+  grub_efi_status_t (__grub_efi_api *entry_point) (
+    grub_efi_handle_t image_handle, grub_efi_system_table_t *system_table);
+};
+
+static struct
+{
+  grub_jmp_buf jmp;
+  grub_efi_handle_t image_handle;
+  grub_efi_status_t exit_status;
+  grub_efi_status_t (__grub_efi_api *exit) (grub_efi_handle_t image_handle,
+					    grub_efi_status_t exit_status,
+					    grub_efi_uintn_t exit_data_size,
+					    grub_efi_char16_t *exit_data);
+} started_image;
+
+
+static grub_uint16_t machines[] = {
+#if defined(__x86_64__)
+  GRUB_PE32_MACHINE_X86_64,
+#elif defined(__i386__)
+  GRUB_PE32_MACHINE_I386,
+#elif defined(__aarch64__)
+  GRUB_PE32_MACHINE_ARM64,
+#elif defined(__arm__)
+  GRUB_PE32_MACHINE_ARMTHUMB_MIXED,
+#elif defined(__riscv) && __riscv_xlen == 32
+  GRUB_PE32_MACHINE_RISCV32,
+#elif defined(__riscv) && __riscv_xlen == 64
+  GRUB_PE32_MACHINE_RISCV64,
+#elif defined(__loongarch__) && __loongarch_grlen == 64
+  GRUB_PE32_MACHINE_LOONGARCH64,
+#endif
+};
+
+/**
+ * check_machine_type() - check if the machine type matches the architecture
+ *
+ * @machine:	the value of the Machine field of the COFF file header.
+ * Return:	status code
+ */
+static grub_efi_status_t
+check_machine_type (grub_uint16_t machine)
+{
+  for (grub_size_t i = 0; i < sizeof (machines) / sizeof (*machines); ++i)
+    {
+      if (machine == machines[i])
+	return GRUB_EFI_SUCCESS;
+    }
+
+  return GRUB_EFI_LOAD_ERROR;
+}
+
+/**
+ * check_pe_header() - check the headers of a PE-COFF image
+ *
+ * @info:	information about the image
+ */
+static grub_efi_status_t
+check_pe_header (struct image_info *info)
+{
+  struct grub_msdos_image_header *dos_stub = info->data;
+  void *pe_magic;
+  struct grub_pe32_coff_header *coff_header;
+  struct grub_pe32_optional_header *pe32_header;
+  struct grub_pe64_optional_header *pe64_header;
+
+  if (info->data_size < sizeof (struct grub_msdos_image_header))
+    {
+      grub_dprintf ("peimage", "truncated image\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+  if (dos_stub->msdos_magic != GRUB_PE32_MAGIC)
+    {
+      grub_dprintf ("peimage", "not a PE-COFF file\n");
+      return GRUB_EFI_UNSUPPORTED;
+    }
+  if (info->data_size < dos_stub->pe_image_header_offset
+			    + GRUB_PE32_SIGNATURE_SIZE
+			    + sizeof (struct grub_pe32_coff_header)
+			    + sizeof (struct grub_pe64_optional_header))
+    {
+      grub_dprintf ("peimage", "truncated image\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+  pe_magic
+      = (void *)((unsigned long)info->data + dos_stub->pe_image_header_offset);
+  if (grub_memcmp (pe_magic, GRUB_PE32_SIGNATURE, GRUB_PE32_SIGNATURE_SIZE))
+    {
+      grub_dprintf ("peimage", "not a PE-COFF file\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  coff_header = (void *)((unsigned long)pe_magic + GRUB_PE32_SIGNATURE_SIZE);
+  info->machine = coff_header->machine;
+  info->num_sections = coff_header->num_sections;
+
+  if (check_machine_type (info->machine) != GRUB_EFI_SUCCESS)
+    {
+      grub_dprintf ("peimage", "wrong machine type %u\n", coff_header->machine);
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  pe32_header = (void *)((unsigned long)coff_header + sizeof (*coff_header));
+  pe64_header = (void *)((unsigned long)coff_header + sizeof (*coff_header));
+
+  switch (pe32_header->magic)
+    {
+    case GRUB_PE32_PE32_MAGIC:
+      if (pe32_header->subsystem != GRUB_PE32_SUBSYSTEM_EFI_APPLICATION)
+	{
+	  grub_dprintf ("peimage", "expected EFI application\n");
+	  return GRUB_EFI_LOAD_ERROR;
+	}
+      info->nx_compat =
+	(pe32_header->dll_characteristics & GRUB_PE32_NX_COMPAT) != 0;
+      info->section_alignment = pe32_header->section_alignment;
+      info->image_base = pe32_header->image_base;
+      info->image_size = pe32_header->image_size;
+      info->entry_point = (void *)(unsigned long)pe32_header->entry_addr;
+      info->header_size = pe32_header->header_size;
+      if (info->data_size < info->header_size)
+	{
+	  grub_dprintf ("peimage", "truncated image\n");
+	  return GRUB_EFI_LOAD_ERROR;
+	}
+
+      if (pe32_header->num_data_directories >= 6
+	  && pe32_header->base_relocation_table.size)
+	info->reloc = &pe32_header->base_relocation_table;
+
+      info->section
+	  = (void *)((unsigned long)&pe32_header->export_table
+		     + pe32_header->num_data_directories
+			   * sizeof (struct grub_pe32_data_directory));
+      break;
+    case GRUB_PE32_PE64_MAGIC:
+      if (pe64_header->subsystem != GRUB_PE32_SUBSYSTEM_EFI_APPLICATION)
+	{
+	  grub_dprintf ("peimage", "expected EFI application\n");
+	  return GRUB_EFI_LOAD_ERROR;
+	}
+      info->nx_compat =
+	(pe64_header->dll_characteristics & GRUB_PE32_NX_COMPAT) != 0;
+      info->section_alignment = pe64_header->section_alignment;
+      info->image_base = pe64_header->image_base;
+      info->image_size = pe64_header->image_size;
+      info->entry_point = (void *)(unsigned long)pe64_header->entry_addr;
+      info->header_size = pe64_header->header_size;
+      if (info->data_size < info->header_size)
+	{
+	  grub_dprintf ("peimage", "truncated image\n");
+	  return GRUB_EFI_LOAD_ERROR;
+	}
+
+      if (pe64_header->num_data_directories >= 6
+	  && pe64_header->base_relocation_table.size)
+	info->reloc = &pe64_header->base_relocation_table;
+
+      info->section
+	  = (void *)((unsigned long)&pe64_header->export_table
+		     + pe64_header->num_data_directories
+			   * sizeof (struct grub_pe32_data_directory));
+      break;
+    default:
+      grub_dprintf ("peimage", "not a PE-COFF file\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  if (info->nx_compat && info->section_alignment < GRUB_EFI_PAGE_SIZE)
+    {
+      grub_dprintf ("peimage", "NX compatible image with sub-page section alignment\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  if ((unsigned long)info->section
+	  + info->num_sections * sizeof (*info->section)
+      > (unsigned long)info->data + info->data_size)
+    {
+      grub_dprintf ("peimage", "truncated image\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  grub_dprintf ("peimage", "PE-COFF header checked\n");
+
+  return GRUB_EFI_SUCCESS;
+}
+
+/**
+ * load_sections() - load image sections into memory
+ *
+ * Allocate fresh memory and copy the image sections there.
+ *
+ * @info:	image information
+ */
+static grub_efi_status_t
+load_sections (struct image_info *info)
+{
+  struct grub_pe32_section_table *section;
+  unsigned long align_mask = 0xfff;
+  grub_addr_t section_addr;
+
+  /* Section alignment must be a power of two */
+  if (info->section_alignment & (info->section_alignment - 1))
+    {
+      grub_dprintf ("peimage", "invalid section alignment\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  if (info->section_alignment > align_mask)
+    align_mask = info->section_alignment - 1;
+
+  info->alloc_pages = GRUB_EFI_BYTES_TO_PAGES (info->image_size + (align_mask & ~0xfffUL));
+
+  info->alloc_addr = grub_efi_allocate_pages_real (
+      GRUB_EFI_MAX_USABLE_ADDRESS, info->alloc_pages,
+      GRUB_EFI_ALLOCATE_MAX_ADDRESS, GRUB_EFI_LOADER_CODE);
+  if (!info->alloc_addr)
+    return GRUB_EFI_OUT_OF_RESOURCES;
+
+  info->image_addr
+      = (void *)(((unsigned long)info->alloc_addr + align_mask) & ~align_mask);
+
+  grub_memcpy (info->image_addr, info->data, info->header_size);
+  for (section = &info->section[0];
+       section < &info->section[info->num_sections]; ++section)
+    {
+      if (section->virtual_address < info->header_size
+	  || (section->raw_data_size
+	      && section->raw_data_offset < info->header_size))
+	{
+	  grub_dprintf ("peimage", "section inside header\n");
+	  return GRUB_EFI_LOAD_ERROR;
+	}
+      if (section->raw_data_offset + section->raw_data_size > info->data_size)
+	{
+	  grub_dprintf ("peimage", "truncated image\n");
+	  return GRUB_EFI_LOAD_ERROR;
+	}
+      if (section->virtual_address + section->virtual_size > info->image_size)
+	{
+	  grub_dprintf ("peimage", "section outside image\n");
+	  return GRUB_EFI_LOAD_ERROR;
+	}
+
+      if (section->raw_data_size)
+	{
+	  if (section->raw_data_offset < info->header_size)
+	    {
+	      grub_dprintf ("peimage", "section data inside header\n");
+	      return GRUB_EFI_LOAD_ERROR;
+	    }
+	  if (section->raw_data_offset + section->raw_data_size > info->data_size)
+	    {
+	      grub_dprintf ("peimage", "section data outside file\n");
+	      return GRUB_EFI_LOAD_ERROR;
+	    }
+	  if (section->raw_data_size > ALIGN_UP(section->virtual_size, GRUB_EFI_PAGE_SIZE))
+	    {
+	      grub_dprintf ("peimage", "section data larger than virtual size\n");
+	      return GRUB_EFI_LOAD_ERROR;
+	    }
+	}
+
+      section_addr = (grub_addr_t)info->image_addr + section->virtual_address;
+
+      grub_memset ((void *) section_addr, 0, section->virtual_size);
+      grub_memcpy (
+	  (void *) section_addr,
+	  (void *)((unsigned long)info->data + section->raw_data_offset),
+	  section->raw_data_size);
+    }
+
+  info->entry_point = (void *)((unsigned long)info->entry_point
+			       + (unsigned long)info->image_addr);
+
+  grub_dprintf ("peimage", "sections loaded\n");
+
+  return GRUB_EFI_SUCCESS;
+}
+
+/**
+ * lo12i_get() - get the immediate value of a format I instruction
+ *
+ * Instruction format I::
+ *
+ *     +---------------------------------------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0 f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +-----------------------+---------+-----+---------+-------------+
+ *     |       imm[11:0]       |   rs1   |fun3 |   rd    |   opcode    |
+ *     +-----------------------+---------+-----+---------+-------------+
+ *
+ * @instr:	pointer to instruction
+ * Return:	immediate value
+ */
+static grub_uint16_t
+lo12i_get (grub_uint32_t *instr)
+{
+  return ((*instr & 0xfff00000) >> 20);
+}
+
+/**
+ * lo12i_set() - set the immediate value of a format I instruction
+ *
+ * Instruction format I::
+ *
+ *     +---------------------------------------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0 f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +-----------------------+---------+-----+---------+-------------+
+ *     |       imm[11:0]       |   rs1   |fun3 |   rd    |   opcode    |
+ *     +-----------------------+---------+-----+---------+-------------+
+ *
+ * @instr:	pointer to instruction
+ * @imm:	immediate value
+ */
+static void
+lo12i_set (grub_uint32_t *instr, grub_uint32_t imm)
+{
+  *instr = (*instr & 0x000fffff) | (imm & 0x00000fff << 20);
+}
+
+/**
+ * hi20_get() - get the immediate value of a format I instruction
+ *
+ * Instruction format U::
+ *
+ *     +---------------------------------------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0 f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +---------------------------------------+---------+-------------+
+ *     |                imm[31:12]             |   rd    |   opcode    |
+ *     +---------------------------------------+---------+-------------+
+ *
+ * @instr:	pointer to instruction
+ * Return:	immediate value
+ */
+static grub_uint16_t
+hi20_get (grub_uint32_t *instr)
+{
+  return *instr & 0xfffff000;
+}
+
+/**
+ * hi20_set() - set the immediate value of a format I instruction
+ *
+ * Instruction format U::
+ *
+ *     +---------------------------------------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0 f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +---------------------------------------+---------+-------------+
+ *     |                imm[31:12]             |   rd    |   opcode    |
+ *     +---------------------------------------+---------+-------------+
+ *
+ * @instr:	pointer to instruction
+ * @imm:	immediate value
+ */
+static void
+hi20_set (grub_uint32_t *instr, grub_uint32_t imm)
+{
+  *instr = (*instr & 0x00000fff) | (imm & 0xfffff000);
+}
+
+/**
+ * lo12s_get() - get the immediate value of a format I instruction
+ *
+ * Instruction format S::
+ *
+ *     +---------------------------------------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0 f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +-------------+---------+---------+-----+----+----+-------------+
+ *     |  imm[11:5]  |   rs2   |   rs1   |fun3 |imm[4:0] |   opcode    |
+ *     +-------------+---------+---------+-----+----+----+-------------+
+ *
+ * @instr:	pointer to instruction
+ * Return:	immediate value
+ */
+static grub_uint16_t
+lo12s_get (grub_uint32_t *instr)
+{
+  return ((*instr & 0x00000f80) >> 7) | ((*instr & 0xfe000000) >> 20);
+}
+
+/**
+ * lo12s_set() - set the immediate value of a format I instruction
+ *
+ * Instruction format S::
+ *
+ *     +---------------------------------------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0 f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +-------------+---------+---------+-----+----+----+-------------+
+ *     |  imm[11:5]  |   rs2   |   rs1   |fun3 |imm[4:0] |   opcode    |
+ *     +-------------+---------+---------+-----+----+----+-------------+
+ *
+ * @instr:	pointer to instruction
+ * @imm:	immediate value
+ */
+static void
+lo12s_set (grub_uint32_t *instr, grub_uint32_t imm)
+{
+  *instr = (*instr & 0x01fff07f) | (imm & 0x00000fe0 << 20)
+	   | (imm & 0x0000001f << 7);
+}
+
+/**
+ * movw_get_imm() - get the immediate value of MOVT and MOVW instructions
+ *
+ * MOVT::
+ *
+ *     +-------------------------------+-------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0|f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *     |1 1 1 1 0|i|1 0 1 1 0 0| imm4  |0| imm3|   Rd  |     imm8      |
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *
+ * MOVW::
+ *
+ *     +-------------------------------+-------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0|f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *     |1 1 1 1 0|i|1 0 0 1 0 0| imm4  |0| imm3|   Rd  |     imm8      |
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *
+ * @instr:	pointer to instruction
+ * Return:	immediate value
+ */
+static grub_uint16_t
+movw_get_imm (grub_uint16_t *instr)
+{
+  /* imm16 = imm4:i:imm3:imm8; */
+  return (instr[1] & 0x00ff) | ((instr[1] & 0x7000) >> 3)
+	 | ((instr[0] & 0x0400) >> 8) | ((instr[0] & 0x000f) << 12);
+}
+
+/**
+ * movw_set_imm() - set the immediate value of MOVT and MOVW instructions
+ *
+ * MOVT::
+ *
+ *     +-------------------------------+-------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0|f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *     |1 1 1 1 0|i|1 0 1 1 0 0| imm4  |0| imm3|   Rd  |     imm8      |
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *
+ * MOVW::
+ *
+ *     +-------------------------------+-------------------------------+
+ *     |f e d c b a 9 8 7 6 5 4 3 2 1 0|f e d c b a 9 8 7 6 5 4 3 2 1 0|
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *     |1 1 1 1 0|i|1 0 0 1 0 0| imm4  |0| imm3|   Rd  |     imm8      |
+ *     +---------+-+-----------+-------+-+-----+-------+---------------+
+ *
+ * @instr:	pointer to instruction
+ * @imm		immediate value
+ */
+static void
+movw_set_imm (grub_uint16_t *instr, grub_uint16_t imm)
+{
+  /* imm16 = imm4:i:imm3:imm8; */
+  instr[0] = (instr[0] & 0xfbf0) | (imm & 0xf000) >> 12 | (imm & 0x0800) << 3;
+  instr[1] = (instr[0] & 0x8f00) | (imm & 0xff) | (imm & 0x0700) >> 4;
+}
+
+/**
+ * relocate() - apply relocations to the image
+ *
+ * @info:	information about the loaded image
+ */
+static grub_efi_status_t
+relocate (struct image_info *info)
+{
+  struct grub_pe32_fixup_block *block, *reloc_end;
+  unsigned long offset;
+  grub_uint16_t reloc_type;
+  grub_uint16_t *reloc_entry;
+  grub_uint32_t *rvhi20_addr = NULL;
+
+  if (!info->reloc || !(info->reloc->size))
+    {
+      grub_dprintf ("peimage", "no relocations\n");
+      return GRUB_EFI_SUCCESS;
+    }
+
+  if (info->reloc->rva + info->reloc->size > info->image_size)
+    {
+      grub_dprintf ("peimage", "relocation block outside image\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  /*
+   * The relocations are based on the difference between
+   * actual load address and the preferred base address.
+   */
+  offset = (unsigned long)info->image_addr - info->image_base;
+
+  block = (void *)((unsigned long)info->image_addr + info->reloc->rva);
+  reloc_end = (void *)((unsigned long)block + info->reloc->size);
+
+  for (; block < reloc_end;
+       block = (void *)((unsigned long)block + block->block_size))
+    {
+      reloc_entry = block->entries;
+      grub_uint16_t *block_end
+	  = (void *)((unsigned long)block + block->block_size);
+
+      for (; reloc_entry < block_end; ++reloc_entry)
+	{
+	  void *addr = (void *)((unsigned long)info->image_addr
+				+ block->page_rva + (*reloc_entry & 0xfff));
+
+	  reloc_type = *reloc_entry >> 12;
+
+	  switch (reloc_type)
+	    {
+	    case GRUB_PE32_REL_BASED_ABSOLUTE:
+	      /* skip */
+	      break;
+	    case GRUB_PE32_REL_BASED_HIGH:
+	      *(grub_uint16_t *)addr += offset >> 16;
+	      break;
+	    case GRUB_PE32_REL_BASED_LOW:
+	      *(grub_uint16_t *)addr += offset;
+	      break;
+	    case GRUB_PE32_REL_BASED_HIGHLOW:
+	      *(grub_uint32_t *)addr += offset;
+	      break;
+	    case GRUB_PE32_REL_BASED_RISCV_HI20:
+	      switch (info->machine)
+		{
+		case GRUB_PE32_MACHINE_RISCV32:
+		case GRUB_PE32_MACHINE_RISCV64:
+		  rvhi20_addr = addr;
+		  break;
+		default:
+		  goto bad_reloc;
+		}
+	      break;
+	    case GRUB_PE32_REL_BASED_ARM_MOV32T:
+	      /* = GRUB_PE32_REL_BASED_RISCV_LOW12I */
+	      switch (info->machine)
+		{
+		case GRUB_PE32_MACHINE_ARMTHUMB_MIXED:
+		  {
+		    grub_uint16_t *instr = addr;
+		    grub_uint32_t val;
+
+		    val = movw_get_imm (&instr[0])
+			  + (movw_get_imm (&instr[2]) << 16) + offset;
+		    movw_set_imm (&instr[0], val);
+		    movw_set_imm (&instr[2], val >> 16);
+		    break;
+		  }
+		case GRUB_PE32_MACHINE_RISCV32:
+		case GRUB_PE32_MACHINE_RISCV64:
+		  if (rvhi20_addr)
+		    {
+		      grub_uint32_t val
+			  = hi20_get (rvhi20_addr) + lo12i_get (addr) + offset;
+		      hi20_set (rvhi20_addr, val);
+		      lo12i_set (addr, val);
+		      rvhi20_addr = NULL;
+		    }
+		  else
+		    {
+		      goto bad_reloc;
+		    }
+		  break;
+		default:
+		  goto bad_reloc;
+		}
+	      break;
+	    case GRUB_PE32_REL_BASED_RISCV_LOW12S:
+	      switch (info->machine)
+		{
+		case GRUB_PE32_MACHINE_RISCV32:
+		case GRUB_PE32_MACHINE_RISCV64:
+		  if (rvhi20_addr)
+		    {
+		      grub_uint32_t val
+			  = hi20_get (rvhi20_addr) + lo12s_get (addr) + offset;
+		      hi20_set (rvhi20_addr, val);
+		      lo12s_set (addr, val);
+		      rvhi20_addr = NULL;
+		    }
+		  else
+		    {
+		      goto bad_reloc;
+		    }
+		  break;
+		default:
+		  goto bad_reloc;
+		}
+	      break;
+	    case GRUB_PE32_REL_BASED_DIR64:
+	      *(grub_uint64_t *)addr += offset;
+	      break;
+	    default:
+	      goto bad_reloc;
+	    }
+	}
+    }
+
+  grub_dprintf ("peimage", "image relocated\n");
+
+  return GRUB_EFI_SUCCESS;
+
+bad_reloc:
+  grub_dprintf ("peimage", "unsupported relocation type %d, rva 0x%08lx\n",
+	      *reloc_entry >> 12,
+	      (unsigned long)reloc_entry - (unsigned long)info->image_addr);
+  return GRUB_EFI_LOAD_ERROR;
+}
+
+static grub_efi_status_t
+set_section_mem_attrs (struct image_info *info)
+{
+  struct grub_pe32_section_table *section;
+  grub_addr_t section_addr;
+  grub_err_t err;
+  grub_uint64_t section_set_mem_attr, section_clear_mem_attr;
+
+  for (section = &info->section[0];
+       section < &info->section[info->num_sections]; ++section)
+    {
+      section_addr = (grub_addr_t)info->image_addr + section->virtual_address;
+
+      if (section_addr & (GRUB_EFI_PAGE_SIZE - 1))
+        {
+          grub_dprintf ("peimage", "NX compatible image with badly aligned section\n");
+          return GRUB_EFI_LOAD_ERROR;
+        }
+
+      if ((section->characteristics & GRUB_PE32_SCN_MEM_WRITE) && (section->characteristics & GRUB_PE32_SCN_MEM_EXECUTE))
+        {
+          grub_dprintf ("peimage", "NX compatible image with W|X section\n");
+          return GRUB_EFI_LOAD_ERROR;
+        }
+
+      section_set_mem_attr = 0;
+      section_clear_mem_attr = 0;
+      if (section->characteristics & GRUB_PE32_SCN_MEM_READ)
+        section_set_mem_attr |= GRUB_MEM_ATTR_R;
+      else
+        section_clear_mem_attr |= GRUB_MEM_ATTR_R;
+      if (section->characteristics & GRUB_PE32_SCN_MEM_WRITE)
+        section_set_mem_attr |= GRUB_MEM_ATTR_W;
+      else
+        section_clear_mem_attr |= GRUB_MEM_ATTR_W;
+      if (section->characteristics & GRUB_PE32_SCN_MEM_EXECUTE)
+        section_set_mem_attr |= GRUB_MEM_ATTR_X;
+      else
+        section_clear_mem_attr |= GRUB_MEM_ATTR_X;
+
+      err = grub_update_mem_attrs (section_addr,
+                                   GRUB_EFI_BYTES_TO_PAGES(section->virtual_size) * GRUB_EFI_PAGE_SIZE,
+                                   section_set_mem_attr, section_clear_mem_attr);
+      if (err != GRUB_ERR_NONE)
+        {
+          grub_dprintf ("peimage", "Failed to set PE section memory attributes\n");
+          return GRUB_EFI_LOAD_ERROR;
+        }
+    }
+
+  grub_dprintf ("peimage", "PE section memory attributes set\n");
+  return GRUB_EFI_SUCCESS;
+}
+
+/**
+ * efi_exit() - replacement for EFI_BOOT_SERVICES.Exit()
+ *
+ * This function is inserted into system table to trap invocations of
+ * EFI_BOOT_SERVICES.Exit(). If Exit() is called with our handle
+ * return to our start routine using a long jump.
+ *
+ * @image_handle:       handle of the application as passed on entry
+ * @exit_status:        the images exit code
+ * @exit_data_size:     size of @exit_data
+ * @exit_data:          null terminated string followed by optional data
+ */
+static grub_efi_status_t __grub_efi_api
+efi_exit (grub_efi_handle_t image_handle, grub_efi_status_t exit_status,
+	  grub_efi_uintn_t exit_data_size, grub_efi_char16_t *exit_data)
+{
+  grub_efi_system_table->boot_services->exit = started_image.exit;
+
+  if (!image_handle)
+    return GRUB_EFI_INVALID_PARAMETER;
+
+  if (image_handle != started_image.image_handle)
+    {
+      grub_dprintf ("peimage", "delegating Exit()\n");
+      return started_image.exit (image_handle, exit_status, exit_data_size,
+				(grub_efi_char16_t *)exit_data);
+    }
+
+  started_image.exit_status = exit_status;
+
+  if (exit_status != GRUB_EFI_SUCCESS)
+    {
+      grub_printf ("Application failed, r = %d\n",
+		   (int)exit_status & 0x7fffffff);
+      if (exit_data_size && exit_data)
+        {
+	  grub_printf ("exit message: ");
+	  for (grub_efi_uintn_t pos = 0;
+	       exit_data[pos] && pos < exit_data_size / 2; ++pos)
+	    grub_printf ("%C", exit_data[pos]);
+	  grub_printf ("\n");
+        }
+    }
+  if (exit_data_size && exit_data)
+    {
+      /* exit data must be freed by the caller */
+      grub_efi_system_table->boot_services->free_pool (exit_data);
+    }
+  grub_longjmp (started_image.jmp, 1);
+}
+
+static grub_efi_status_t __grub_efi_api
+do_unload_image (grub_efi_handle_t image_handle);
+
+/**
+ * start_image() - our implementation of StartImage()
+ *
+ * As we do not load the image via LoadImage() we need our own implementation
+ * of StartImage() to launch the PE-COFF image.
+ */
+static grub_efi_status_t
+start_image (struct image_info *info)
+{
+  int ret;
+  grub_efi_status_t status;
+  grub_efi_loaded_image_t *loaded_image;
+
+  /*
+   * NOTE: We cannot easily comply with the UEFI specification and provide the
+   * child its own handle, otherwise things can go horribly wrong if said custom
+   * handle is passed to the firmware by child images
+   */
+  started_image.image_handle = grub_efi_image_handle;
+
+  loaded_image = grub_efi_get_loaded_image (grub_efi_image_handle);
+  if (loaded_image)
+    {
+      loaded_image->image_base = info->image_addr;
+      loaded_image->image_size = info->image_size;
+
+      // Pass just the file path portion to the loaded image
+      loaded_image->file_path = info->file_path;
+      while (loaded_image->file_path &&
+	     (loaded_image->file_path->type != GRUB_EFI_MEDIA_DEVICE_PATH_TYPE
+	      || loaded_image->file_path->subtype != GRUB_EFI_FILE_PATH_DEVICE_PATH_SUBTYPE))
+	loaded_image->file_path = GRUB_EFI_NEXT_DEVICE_PATH (loaded_image->file_path);
+    }
+  else
+    {
+      grub_dprintf ("peimage", "Loaded image protocol missing\n");
+    }
+
+  ret = grub_setjmp (started_image.jmp);
+  if (ret)
+    {
+      do_unload_image(started_image.image_handle);
+      started_image.image_handle = NULL;
+      return started_image.exit_status;
+    }
+
+  started_image.exit = grub_efi_system_table->boot_services->exit;
+  grub_efi_system_table->boot_services->exit = efi_exit;
+
+  grub_dprintf (
+      "peimage",
+      "Executing image loaded at 0x%lx\nEntry point 0x%lx\nSize 0x%08x\n",
+      (unsigned long)info->image_addr, (unsigned long)info->entry_point,
+      info->image_size);
+
+  /* Invalidate the instruction cache */
+  grub_arch_sync_caches (info->image_addr, info->image_size);
+
+  status = info->entry_point (started_image.image_handle, grub_efi_system_table);
+
+  grub_dprintf ("peimage", "Application returned\n");
+
+  return efi_exit (started_image.image_handle, status, 0, NULL);
+}
+
+static struct image_info info;
+
+/* TODO: move the creation of the load options here */
+static grub_efi_status_t __grub_efi_api
+do_load_image (grub_efi_boolean_t boot_policy __attribute__ ((unused)),
+               grub_efi_handle_t parent_image_handle __attribute__ ((unused)),
+               grub_efi_device_path_t *file_path,
+               void *source_buffer, grub_efi_uintn_t source_size,
+               grub_efi_handle_t *image_handle)
+{
+  grub_efi_status_t ret = GRUB_EFI_SUCCESS;
+  if (info.data != NULL)
+    {
+      grub_dprintf ("peimage", "cannot load multiple images\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+
+  grub_dl_ref (my_mod);
+
+  info = (struct image_info){
+    .data = source_buffer,
+    .data_size = source_size,
+    .file_path = grub_efi_duplicate_device_path(file_path),
+  };
+
+  ret = check_pe_header (&info);
+  if (ret != GRUB_EFI_SUCCESS)
+    goto err;
+
+  ret = load_sections (&info);
+  if (ret != GRUB_EFI_SUCCESS)
+    goto err;
+
+  ret = relocate (&info);
+  if (ret != GRUB_EFI_SUCCESS)
+    goto err;
+
+  if (info.nx_compat)
+    {
+      ret = set_section_mem_attrs (&info);
+      if (ret != GRUB_EFI_SUCCESS)
+        goto err;
+    }
+
+  // We are hacking this up as we go along
+  *image_handle = grub_efi_image_handle;
+  return GRUB_EFI_SUCCESS;
+
+err:
+  do_unload_image (NULL); // NOTE: arg unused
+  return ret;
+}
+
+static grub_efi_status_t __grub_efi_api
+do_start_image (grub_efi_handle_t image_handle __attribute__ ((unused)),
+		grub_efi_uintn_t *exit_data_size __attribute__ ((unused)),
+		grub_efi_char16_t **exit_data __attribute__ ((unused)))
+{
+  if (info.data == NULL)
+    {
+      grub_dprintf ("peimage", "image not loaded\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+  return start_image (&info);
+}
+
+static grub_efi_status_t __grub_efi_api
+do_unload_image (grub_efi_handle_t image_handle __attribute__ ((unused)))
+{
+  if (info.data == NULL)
+    {
+      grub_dprintf ("peimage", "image not loaded\n");
+      return GRUB_EFI_LOAD_ERROR;
+    }
+  if (info.alloc_addr)
+    grub_efi_free_pages ((unsigned long)info.alloc_addr, info.alloc_pages);
+  if (info.file_path)
+    grub_free(info.file_path);
+
+  grub_dl_unref (my_mod);
+  info = (struct image_info){};
+
+  return GRUB_EFI_SUCCESS;
+}
+
+static const grub_efi_loader_t peimage_loader = {
+  .load_image = do_load_image,
+  .start_image = do_start_image,
+  .unload_image = do_unload_image,
+};
+
+GRUB_MOD_INIT (peimage)
+{
+  grub_efi_register_loader (&peimage_loader);
+  my_mod = mod;
+}
+
+GRUB_MOD_FINI (peimage)
+{
+  grub_efi_unregister_loader (&peimage_loader);
+}
diff --git a/include/grub/efi/peimage.h b/include/grub/efi/peimage.h
new file mode 100644
index 0000000..e57d6de
--- /dev/null
+++ b/include/grub/efi/peimage.h
@@ -0,0 +1,19 @@
+/* SPDX-License-Identifier: GPL-3.0+ */
+
+/* Distinguishing our loaded image handles from the firmware's */
+#define GRUB_PEIMAGE_MARKER_GUID \
+  { 0xda24567a, 0xf899, 0x4566, \
+    { 0xb8, 0x27, 0x9f, 0x66, 0x00, 0xc2, 0x14, 0x39 } \
+  }
+
+/* Associates an image handle with the device path it was loaded from */
+#define GRUB_EFI_LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID \
+  { 0xbc62157e, 0x3e33, 0x4fec, \
+    { 0x99, 0x20, 0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf } \
+  }
+
+/* Revision defined for the EFI_LOADED_IMAGE_PROTOCOL */
+#define GRUB_EFI_LOADED_IMAGE_REVISION  0x1000
+
+/* Value of the signature field of a PE image header */
+#define GRUB_PE32_SIGNATURE "PE\0"