kaslr.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Helper functions used by the EFI stub on multiple
  4 * architectures to deal with physical address space randomization.
  5 */
  6#include <linux/efi.h>
  7
  8#include "efistub.h"
  9
 10/**
 11 * efi_kaslr_get_phys_seed() - Get random seed for physical kernel KASLR
 12 * @image_handle:	Handle to the image
 13 *
 14 * If KASLR is not disabled, obtain a random seed using EFI_RNG_PROTOCOL
 15 * that will be used to move the kernel physical mapping.
 16 *
 17 * Return:	the random seed
 18 */
 19u32 efi_kaslr_get_phys_seed(efi_handle_t image_handle)
 20{
 21	efi_guid_t li_fixed_proto = LINUX_EFI_LOADED_IMAGE_FIXED_GUID;
 22	void *p;
 23
 24	if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE))
 25		return 0;
 26
 27	if (efi_nokaslr) {
 28		efi_info("KASLR disabled on kernel command line\n");
 29	} else if (efi_bs_call(handle_protocol, image_handle,
 30			       &li_fixed_proto, &p) == EFI_SUCCESS) {
 31		efi_info("Image placement fixed by loader\n");
 32	} else {
 33		efi_status_t status;
 34		u32 phys_seed;
 35
 36		status = efi_get_random_bytes(sizeof(phys_seed),
 37					      (u8 *)&phys_seed);
 38		if (status == EFI_SUCCESS)
 39			return phys_seed;
 40
 41		if (status == EFI_NOT_FOUND)
 42			efi_info("EFI_RNG_PROTOCOL unavailable\n");
 43		else
 44			efi_err("efi_get_random_bytes() failed (0x%lx)\n", status);
 45
 46		efi_nokaslr = true;
 47	}
 48
 49	return 0;
 50}
 51
 52/*
 53 * Distro versions of GRUB may ignore the BSS allocation entirely (i.e., fail
 54 * to provide space, and fail to zero it). Check for this condition by double
 55 * checking that the first and the last byte of the image are covered by the
 56 * same EFI memory map entry.
 57 */
 58static bool check_image_region(u64 base, u64 size)
 59{
 60	struct efi_boot_memmap *map __free(efi_pool) = NULL;
 61	efi_status_t status;
 62	bool ret = false;
 63	int map_offset;
 64
 65	status = efi_get_memory_map(&map, false);
 66	if (status != EFI_SUCCESS)
 67		return false;
 68
 69	for (map_offset = 0; map_offset < map->map_size; map_offset += map->desc_size) {
 70		efi_memory_desc_t *md = (void *)map->map + map_offset;
 71		u64 end = md->phys_addr + md->num_pages * EFI_PAGE_SIZE;
 72
 73		/*
 74		 * Find the region that covers base, and return whether
 75		 * it covers base+size bytes.
 76		 */
 77		if (base >= md->phys_addr && base < end) {
 78			ret = (base + size) <= end;
 79			break;
 80		}
 81	}
 82
 83	return ret;
 84}
 85
 86/**
 87 * efi_kaslr_relocate_kernel() - Relocate the kernel (random if KASLR enabled)
 88 * @image_addr: Pointer to the current kernel location
 89 * @reserve_addr:	Pointer to the relocated kernel location
 90 * @reserve_size:	Size of the relocated kernel
 91 * @kernel_size:	Size of the text + data
 92 * @kernel_codesize:	Size of the text
 93 * @kernel_memsize:	Size of the text + data + bss
 94 * @phys_seed:		Random seed used for the relocation
 95 *
 96 * If KASLR is not enabled, this function relocates the kernel to a fixed
 97 * address (or leave it as its current location). If KASLR is enabled, the
 98 * kernel physical location is randomized using the seed in parameter.
 99 *
100 * Return:	status code, EFI_SUCCESS if relocation is successful
101 */
102efi_status_t efi_kaslr_relocate_kernel(unsigned long *image_addr,
103				       unsigned long *reserve_addr,
104				       unsigned long *reserve_size,
105				       unsigned long kernel_size,
106				       unsigned long kernel_codesize,
107				       unsigned long kernel_memsize,
108				       u32 phys_seed)
109{
110	efi_status_t status;
111	u64 min_kimg_align = efi_get_kimg_min_align();
112
113	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && phys_seed != 0) {
114		/*
115		 * If KASLR is enabled, and we have some randomness available,
116		 * locate the kernel at a randomized offset in physical memory.
117		 */
118		status = efi_random_alloc(*reserve_size, min_kimg_align,
119					  reserve_addr, phys_seed,
120					  EFI_LOADER_CODE, 0, EFI_ALLOC_LIMIT);
121		if (status != EFI_SUCCESS)
122			efi_warn("efi_random_alloc() failed: 0x%lx\n", status);
123	} else {
124		status = EFI_OUT_OF_RESOURCES;
125	}
126
127	if (status != EFI_SUCCESS) {
128		if (!check_image_region(*image_addr, kernel_memsize)) {
129			efi_err("FIRMWARE BUG: Image BSS overlaps adjacent EFI memory region\n");
130		} else if (IS_ALIGNED(*image_addr, min_kimg_align) &&
131			   (unsigned long)_end < EFI_ALLOC_LIMIT) {
132			/*
133			 * Just execute from wherever we were loaded by the
134			 * UEFI PE/COFF loader if the placement is suitable.
135			 */
136			*reserve_size = 0;
137			return EFI_SUCCESS;
138		}
139
140		status = efi_allocate_pages_aligned(*reserve_size, reserve_addr,
141						    ULONG_MAX, min_kimg_align,
142						    EFI_LOADER_CODE);
143
144		if (status != EFI_SUCCESS) {
145			efi_err("Failed to relocate kernel\n");
146			*reserve_size = 0;
147			return status;
148		}
149	}
150
151	memcpy((void *)*reserve_addr, (void *)*image_addr, kernel_size);
152	*image_addr = *reserve_addr;
153	efi_icache_sync(*image_addr, *image_addr + kernel_codesize);
154	efi_remap_image(*image_addr, *reserve_size, kernel_codesize);
155
156	return status;
157}