efi_image.c File Reference

#include <errno.h>
#include <stdlib.h>
#include <wchar.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_snp.h>
#include <ipxe/efi/efi_download.h>
#include <ipxe/efi/efi_file.h>
#include <ipxe/efi/efi_path.h>
#include <ipxe/efi/efi_strings.h>
#include <ipxe/efi/efi_wrap.h>
#include <ipxe/efi/efi_pxe.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/efi_image.h>
#include <ipxe/efi/efi_shim.h>
#include <ipxe/image.h>
#include <ipxe/init.h>
#include <ipxe/features.h>
#include <ipxe/uri.h>
#include <ipxe/console.h>

Go to the source code of this file.

Macros
#define	EINFO_EEFI_LOAD
#define	EINFO_EEFI_LOAD_PROHIBITED
#define	EEFI_LOAD_PROHIBITED   __einfo_error ( EINFO_EEFI_LOAD_PROHIBITED )
#define	EEFI_LOAD(efirc)
#define	EINFO_EEFI_START
#define	EEFI_START(efirc)   EPLATFORM ( EINFO_EEFI_START, efirc )

Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FEATURE (FEATURE_IMAGE, "EFI", DHCP_EB_FEATURE_EFI, 1)
static EFI_DEVICE_PATH_PROTOCOL *	efi_image_path (struct image *image, EFI_DEVICE_PATH_PROTOCOL *parent)
	Create device path for image. More...
static wchar_t *	efi_image_cmdline (struct image *image)
	Create command line for image. More...
static int	efi_image_exec (struct image *image)
	Execute EFI image. More...
static int	efi_image_probe (struct image *image)
	Probe EFI image. More...
static int	efi_pe_image_probe (struct image *image)
	Probe EFI PE image. More...
struct image_type efi_image_type []	__image_type (PROBE_NORMAL)
	EFI image types. More...

Macro Definition Documentation

EINFO_EEFI_LOAD

#define EINFO_EEFI_LOAD

Value:

__einfo_uniqify ( EINFO_EPLATFORM, 0x01,                        \
                          "Could not load image" )

Definition at line 45 of file efi_image.c.

EINFO_EEFI_LOAD_PROHIBITED

#define EINFO_EEFI_LOAD_PROHIBITED

Value:

__einfo_platformify ( EINFO_EEFI_LOAD, EFI_SECURITY_VIOLATION,  \
                              "Image prohibited by security policy" )

Definition at line 48 of file efi_image.c.

EEFI_LOAD_PROHIBITED

#define EEFI_LOAD_PROHIBITED   __einfo_error ( EINFO_EEFI_LOAD_PROHIBITED )

Definition at line 51 of file efi_image.c.

EEFI_LOAD

#define EEFI_LOAD

(

efirc

)

Value:

EPLATFORM ( EINFO_EEFI_LOAD, efirc,             \
                                       EEFI_LOAD_PROHIBITED )

Definition at line 53 of file efi_image.c.

EINFO_EEFI_START

#define EINFO_EEFI_START

Value:

__einfo_uniqify ( EINFO_EPLATFORM, 0x02,                        \
                          "Could not start image" )

Definition at line 55 of file efi_image.c.

EEFI_START

#define EEFI_START

(

efirc

)

EPLATFORM ( EINFO_EEFI_START, efirc )

Definition at line 58 of file efi_image.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

FEATURE()

FEATURE	(	FEATURE_IMAGE	,
		"EFI"	,
		DHCP_EB_FEATURE_EFI	,
		1
	)

efi_image_path()

static EFI_DEVICE_PATH_PROTOCOL* efi_image_path ( struct image *  image, EFI_DEVICE_PATH_PROTOCOL *  parent  )

static

Create device path for image.

Parameters

image	EFI image
parent	Parent device path

Return values

path	Device path, or NULL on failure

The caller must eventually free() the device path.

Definition at line 70 of file efi_image.c.

                                                                         {
        EFI_DEVICE_PATH_PROTOCOL *path;
        FILEPATH_DEVICE_PATH *filepath;
        EFI_DEVICE_PATH_PROTOCOL *end;
        size_t name_len;
        size_t prefix_len;
        size_t filepath_len;
        size_t len;

        /* Calculate device path lengths */
        prefix_len = efi_path_len ( parent );
        name_len = strlen ( image->name );
        filepath_len = ( SIZE_OF_FILEPATH_DEVICE_PATH +
                         ( name_len + 1 /* NUL */ ) * sizeof ( wchar_t ) );
        len = ( prefix_len + filepath_len + sizeof ( *end ) );

        /* Allocate device path */
        path = zalloc ( len );
        if ( ! path )
                return NULL;

        /* Construct device path */
        memcpy ( path, parent, prefix_len );
        filepath = ( ( ( void * ) path ) + prefix_len );
        filepath->Header.Type = MEDIA_DEVICE_PATH;
        filepath->Header.SubType = MEDIA_FILEPATH_DP;
        filepath->Header.Length[0] = ( filepath_len & 0xff );
        filepath->Header.Length[1] = ( filepath_len >> 8 );
        efi_snprintf ( filepath->PathName, ( name_len + 1 /* NUL */ ),
                       "%s", image->name );
        end = ( ( ( void * ) filepath ) + filepath_len );
        efi_path_terminate ( end );

        return path;
}

References efi_path_len(), efi_path_terminate(), efi_snprintf(), end, FILEPATH_DEVICE_PATH::Header, len, EFI_DEVICE_PATH_PROTOCOL::Length, MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, memcpy(), image::name, NULL, FILEPATH_DEVICE_PATH::PathName, SIZE_OF_FILEPATH_DEVICE_PATH, strlen(), EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, and zalloc().

Referenced by efi_image_exec().

efi_image_cmdline()

static wchar_t* efi_image_cmdline ( struct image *  image )

static

Create command line for image.

Parameters

image

EFI image

Return values

cmdline

Command line, or NULL on failure

Definition at line 112 of file efi_image.c.

                                                           {
        wchar_t *cmdline;

        /* Allocate and construct command line */
        if ( efi_asprintf ( &cmdline, "%s%s%s", image->name,
                            ( image->cmdline ? " " : "" ),
                            ( image->cmdline ? image->cmdline : "" ) ) < 0 ) {
                return NULL;
        }

        return cmdline;
}

References cmdline, image::cmdline, efi_asprintf(), image::name, and NULL.

Referenced by efi_image_exec().

efi_image_exec()

static int efi_image_exec ( struct image *  image )

static

Execute EFI image.

Parameters

image

EFI image

Return values

rc	Return status code

Definition at line 131 of file efi_image.c.

                                                  {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_snp_device *snpdev;
        EFI_DEVICE_PATH_PROTOCOL *path;
        union {
                EFI_LOADED_IMAGE_PROTOCOL *image;
                void *interface;
        } loaded;
        struct image *shim;
        struct image *exec;
        EFI_HANDLE handle;
        EFI_MEMORY_TYPE type;
        wchar_t *cmdline;
        unsigned int toggle;
        EFI_STATUS efirc;
        int rc;

        /* Find an appropriate device handle to use */
        snpdev = last_opened_snpdev();
        if ( ! snpdev ) {
                DBGC ( image, "EFIIMAGE %s could not identify SNP device\n",
                       image->name );
                rc = -ENODEV;
                goto err_no_snpdev;
        }

        /* Use shim instead of directly executing image if applicable */
        shim = ( efi_can_load ( image ) ?
                 NULL : find_image_tag ( &efi_shim ) );
        exec = ( shim ? shim : image );
        if ( shim ) {
                DBGC ( image, "EFIIMAGE %s executing via %s\n",
                       image->name, shim->name );
        }

        /* Re-register as a hidden image to allow for access via file I/O */
        toggle = ( ~image->flags & IMAGE_HIDDEN );
        image->flags |= IMAGE_HIDDEN;
        if ( ( rc = register_image ( image ) ) != 0 )
                goto err_register_image;

        /* Install file I/O protocols */
        if ( ( rc = efi_file_install ( snpdev->handle ) ) != 0 ) {
                DBGC ( image, "EFIIMAGE %s could not install file protocol: "
                       "%s\n", image->name, strerror ( rc ) );
                goto err_file_install;
        }

        /* Install PXE base code protocol */
        if ( ( rc = efi_pxe_install ( snpdev->handle, snpdev->netdev ) ) != 0 ){
                DBGC ( image, "EFIIMAGE %s could not install PXE protocol: "
                       "%s\n", image->name, strerror ( rc ) );
                goto err_pxe_install;
        }

        /* Install iPXE download protocol */
        if ( ( rc = efi_download_install ( snpdev->handle ) ) != 0 ) {
                DBGC ( image, "EFIIMAGE %s could not install iPXE download "
                       "protocol: %s\n", image->name, strerror ( rc ) );
                goto err_download_install;
        }

        /* Create device path for image */
        path = efi_image_path ( exec, snpdev->path );
        if ( ! path ) {
                DBGC ( image, "EFIIMAGE %s could not create device path\n",
                       image->name );
                rc = -ENOMEM;
                goto err_image_path;
        }

        /* Create command line for image */
        cmdline = efi_image_cmdline ( image );
        if ( ! cmdline ) {
                DBGC ( image, "EFIIMAGE %s could not create command line\n",
                       image->name );
                rc = -ENOMEM;
                goto err_cmdline;
        }

        /* Install shim special handling if applicable */
        if ( shim &&
             ( ( rc = efi_shim_install ( shim, snpdev->handle,
                                         &cmdline ) ) != 0 ) ){
                DBGC ( image, "EFIIMAGE %s could not install shim handling: "
                       "%s\n", image->name, strerror ( rc ) );
                goto err_shim_install;
        }

        /* Attempt loading image */
        handle = NULL;
        if ( ( efirc = bs->LoadImage ( FALSE, efi_image_handle, path,
                                       user_to_virt ( exec->data, 0 ),
                                       exec->len, &handle ) ) != 0 ) {
                /* Not an EFI image */
                rc = -EEFI_LOAD ( efirc );
                DBGC ( image, "EFIIMAGE %s could not load: %s\n",
                       image->name, strerror ( rc ) );
                if ( efirc == EFI_SECURITY_VIOLATION ) {
                        goto err_load_image_security_violation;
                } else {
                        goto err_load_image;
                }
        }

        /* Get the loaded image protocol for the newly loaded image */
        efirc = bs->OpenProtocol ( handle, &efi_loaded_image_protocol_guid,
                                   &loaded.interface, efi_image_handle,
                                   NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL );
        if ( efirc ) {
                /* Should never happen */
                rc = -EEFI ( efirc );
                goto err_open_protocol;
        }

        /* Some EFI 1.10 implementations seem not to fill in DeviceHandle */
        if ( loaded.image->DeviceHandle == NULL ) {
                DBGC ( image, "EFIIMAGE %s filling in missing DeviceHandle\n",
                       image->name );
                loaded.image->DeviceHandle = snpdev->handle;
        }

        /* Sanity checks */
        assert ( loaded.image->ParentHandle == efi_image_handle );
        assert ( loaded.image->DeviceHandle == snpdev->handle );
        assert ( loaded.image->LoadOptionsSize == 0 );
        assert ( loaded.image->LoadOptions == NULL );

        /* Record image code type */
        type = loaded.image->ImageCodeType;

        /* Set command line */
        loaded.image->LoadOptions = cmdline;
        loaded.image->LoadOptionsSize =
                ( ( wcslen ( cmdline ) + 1 /* NUL */ ) * sizeof ( wchar_t ) );

        /* Release network devices for use via SNP */
        efi_snp_release();

        /* Wrap calls made by the loaded image (for debugging) */
        efi_wrap ( handle );

        /* Reset console since image will probably use it */
        console_reset();

        /* Start the image */
        if ( ( efirc = bs->StartImage ( handle, NULL, NULL ) ) != 0 ) {
                rc = -EEFI_START ( efirc );
                DBGC ( image, "EFIIMAGE %s could not start (or returned with "
                       "error): %s\n", image->name, strerror ( rc ) );
                goto err_start_image;
        }

        /* If image was a driver, connect it up to anything available */
        if ( type == EfiBootServicesCode ) {
                DBGC ( image, "EFIIMAGE %s connecting drivers\n", image->name );
                efi_driver_reconnect_all();
        }

        /* Success */
        rc = 0;

 err_start_image:
        efi_snp_claim();
 err_open_protocol:
        /* If there was no error, then the image must have been
         * started and returned successfully.  It either unloaded
         * itself, or it intended to remain loaded (e.g. it was a
         * driver).  We therefore do not unload successful images.
         *
         * If there was an error, attempt to unload the image.  This
         * may not work.  In particular, there is no way to tell
         * whether an error returned from StartImage() was due to
         * being unable to start the image (in which case we probably
         * should call UnloadImage()), or due to the image itself
         * returning an error (in which case we probably should not
         * call UnloadImage()).  We therefore ignore any failures from
         * the UnloadImage() call itself.
         */
 err_load_image_security_violation:
        if ( rc != 0 )
                bs->UnloadImage ( handle );
 err_load_image:
        if ( shim )
                efi_shim_uninstall();
 err_shim_install:
        free ( cmdline );
 err_cmdline:
        free ( path );
 err_image_path:
        efi_download_uninstall ( snpdev->handle );
 err_download_install:
        efi_pxe_uninstall ( snpdev->handle );
 err_pxe_install:
        efi_file_uninstall ( snpdev->handle );
 err_file_install:
        unregister_image ( image );
 err_register_image:
        image->flags ^= toggle;
 err_no_snpdev:
        return rc;
}

References assert(), EFI_SYSTEM_TABLE::BootServices, cmdline, console_reset(), image::data, DBGC, EEFI, EEFI_LOAD, EEFI_START, efi_can_load(), efi_download_install(), efi_download_uninstall(), efi_driver_reconnect_all(), efi_file_install(), efi_file_uninstall(), efi_image_cmdline(), efi_image_handle, efi_image_path(), efi_loaded_image_protocol_guid, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_pxe_install(), efi_pxe_uninstall(), EFI_SECURITY_VIOLATION, efi_shim_install(), efi_shim_uninstall(), efi_snp_claim(), efi_snp_release(), efi_systab, efi_wrap(), EfiBootServicesCode, ENODEV, ENOMEM, FALSE, find_image_tag(), image::flags, free, handle, efi_snp_device::handle, IMAGE_HIDDEN, last_opened_snpdev(), image::len, EFI_BOOT_SERVICES::LoadImage, image::name, efi_snp_device::netdev, NULL, EFI_BOOT_SERVICES::OpenProtocol, efi_snp_device::path, rc, register_image(), shim(), EFI_BOOT_SERVICES::StartImage, strerror(), type, EFI_BOOT_SERVICES::UnloadImage, unregister_image(), user_to_virt(), and wcslen().

efi_image_probe()

static int efi_image_probe ( struct image *  image )

static

Probe EFI image.

Parameters

image

EFI file

Return values

rc	Return status code

Definition at line 340 of file efi_image.c.

                                                   {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        static EFI_DEVICE_PATH_PROTOCOL empty_path = {
                .Type = END_DEVICE_PATH_TYPE,
                .SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE,
                .Length[0] = sizeof ( empty_path ),
        };
        EFI_HANDLE handle;
        EFI_STATUS efirc;
        int rc;

        /* Attempt loading image */
        handle = NULL;
        if ( ( efirc = bs->LoadImage ( FALSE, efi_image_handle, &empty_path,
                                       user_to_virt ( image->data, 0 ),
                                       image->len, &handle ) ) != 0 ) {
                /* Not an EFI image */
                rc = -EEFI_LOAD ( efirc );
                DBGC ( image, "EFIIMAGE %s could not load: %s\n",
                       image->name, strerror ( rc ) );
                if ( efirc == EFI_SECURITY_VIOLATION ) {
                        goto err_load_image_security_violation;
                } else {
                        goto err_load_image;
                }
        }

        /* Unload the image.  We can't leave it loaded, because we
         * have no "unload" operation.
         */
        bs->UnloadImage ( handle );

        return 0;

 err_load_image_security_violation:
        bs->UnloadImage ( handle );
 err_load_image:
        return rc;
}

References EFI_SYSTEM_TABLE::BootServices, image::data, DBGC, EEFI_LOAD, efi_image_handle, EFI_SECURITY_VIOLATION, efi_systab, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, FALSE, handle, image::len, EFI_BOOT_SERVICES::LoadImage, image::name, NULL, rc, strerror(), EFI_DEVICE_PATH_PROTOCOL::Type, EFI_BOOT_SERVICES::UnloadImage, and user_to_virt().

efi_pe_image_probe()

static int efi_pe_image_probe ( struct image *  image )

static

Probe EFI PE image.

Parameters

image

EFI file

Return values

rc	Return status code

The extremely broken UEFI Secure Boot model provides no way for us to unambiguously determine that a valid EFI executable image was rejected by LoadImage() because it failed signature verification. We must therefore use heuristics to guess whether not an image that was rejected by LoadImage() could still be loaded via a separate PE loader such as the UEFI shim.

Definition at line 393 of file efi_image.c.

                                                      {
        const UINT16 magic = ( ( sizeof ( UINTN ) == sizeof ( uint32_t ) ) ?
                               EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC :
                               EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC );
        union {
                EFI_IMAGE_DOS_HEADER dos;
                EFI_IMAGE_OPTIONAL_HEADER_UNION pe;
        } u;

        /* Check for existence of DOS header */
        if ( image->len < sizeof ( u.dos ) ) {
                DBGC ( image, "EFIIMAGE %s too short for DOS header\n",
                       image->name );
                return -ENOEXEC;
        }
        copy_from_user ( &u.dos, image->data, 0, sizeof ( u.dos ) );
        if ( u.dos.e_magic != EFI_IMAGE_DOS_SIGNATURE ) {
                DBGC ( image, "EFIIMAGE %s missing MZ signature\n",
                       image->name );
                return -ENOEXEC;
        }

        /* Check for existence of PE header */
        if ( ( image->len < u.dos.e_lfanew ) ||
             ( ( image->len - u.dos.e_lfanew ) < sizeof ( u.pe ) ) ) {
                DBGC ( image, "EFIIMAGE %s too short for PE header\n",
                       image->name );
                return -ENOEXEC;
        }
        copy_from_user ( &u.pe, image->data, u.dos.e_lfanew, sizeof ( u.pe ) );
        if ( u.pe.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE ) {
                DBGC ( image, "EFIIMAGE %s missing PE signature\n",
                       image->name );
                return -ENOEXEC;
        }

        /* Check PE header magic */
        if ( u.pe.Pe32.OptionalHeader.Magic != magic ) {
                DBGC ( image, "EFIIMAGE %s incorrect magic %04x\n",
                       image->name, u.pe.Pe32.OptionalHeader.Magic );
                return -ENOEXEC;
        }

        return 0;
}

References copy_from_user(), image::data, DBGC, EFI_IMAGE_DOS_SIGNATURE, EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC, EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC, EFI_IMAGE_NT_SIGNATURE, ENOEXEC, image::len, magic, image::name, and u.

__image_type()

struct image_type efi_image_type [] __image_type

(

PROBE_NORMAL

)

EFI image types.