X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fboot.c;h=5347fd7c1d45bbfbe748deaa12b44cdb2c4d930c;hp=ce9c1e099f071d51245b8610e90db514fcb7a29b;hb=454f924bbcda7904c4348ef45c3d0d293768a48c;hpb=1d69ceee0b8fac1f4451a75b6e4b14ee2d5d91dc diff --git a/discover/boot.c b/discover/boot.c index ce9c1e0..5347fd7 100644 --- a/discover/boot.c +++ b/discover/boot.c @@ -18,11 +18,15 @@ #include #include #include +#include #include "device-handler.h" #include "boot.h" #include "paths.h" #include "resource.h" +#include "platform.h" + +#include static const char *boot_hook_dir = PKG_SYSCONF_DIR "/boot.d"; enum { @@ -30,64 +34,116 @@ enum { BOOT_HOOK_EXIT_UPDATE = 2, }; -struct boot_task { - struct load_url_result *image; - struct load_url_result *initrd; - struct load_url_result *dtb; - const char *local_image; - const char *local_initrd; - const char *local_dtb; - const char *args; - boot_status_fn status_fn; - void *status_arg; - bool dry_run; - bool cancelled; -}; +static void __attribute__((format(__printf__, 4, 5))) update_status( + boot_status_fn fn, void *arg, int type, char *fmt, ...) +{ + struct status status; + va_list ap; + + va_start(ap, fmt); + status.message = talloc_vasprintf(NULL, fmt, ap); + va_end(ap); + + status.type = type; + + pb_debug("boot status: [%d] %s\n", type, status.message); + + fn(arg, &status); + + talloc_free(status.message); +} /** * kexec_load - kexec load helper. */ static int kexec_load(struct boot_task *boot_task) { - int result; - const char *argv[7]; - const char **p; + struct process *process; char *s_initrd = NULL; - char *s_dtb = NULL; char *s_args = NULL; + const char *argv[7]; + char *s_dtb = NULL; + const char **p; + int result; + + + boot_task->local_initrd_override = NULL; + boot_task->local_dtb_override = NULL; + boot_task->local_image_override = NULL; + + if ((result = gpg_validate_boot_files(boot_task))) { + if (result == KEXEC_LOAD_DECRYPTION_FALURE) { + pb_log("%s: Aborting kexec due to" + " decryption failure\n", __func__); + goto abort_kexec; + } + if (result == KEXEC_LOAD_SIGNATURE_FAILURE) { + pb_log("%s: Aborting kexec due to signature" + " verification failure\n", __func__); + goto abort_kexec; + } + } + + const char* local_initrd = (boot_task->local_initrd_override) ? + boot_task->local_initrd_override : boot_task->local_initrd; + const char* local_dtb = (boot_task->local_dtb_override) ? + boot_task->local_dtb_override : boot_task->local_dtb; + const char* local_image = (boot_task->local_image_override) ? + boot_task->local_image_override : boot_task->local_image; + + process = process_create(boot_task); + if (!process) { + pb_log("%s: failed to create process\n", __func__); + return -1; + } + + process->path = pb_system_apps.kexec; + process->argv = argv; + process->keep_stdout = true; + process->add_stderr = true; p = argv; *p++ = pb_system_apps.kexec; /* 1 */ *p++ = "-l"; /* 2 */ - if (boot_task->local_initrd) { + if (local_initrd) { s_initrd = talloc_asprintf(boot_task, "--initrd=%s", - boot_task->local_initrd); + local_initrd); assert(s_initrd); *p++ = s_initrd; /* 3 */ } - if (boot_task->local_dtb) { + if (local_dtb) { s_dtb = talloc_asprintf(boot_task, "--dtb=%s", - boot_task->local_dtb); + local_dtb); assert(s_dtb); *p++ = s_dtb; /* 4 */ } - if (boot_task->args) { - s_args = talloc_asprintf(boot_task, "--append=%s", - boot_task->args); - assert(s_args); - *p++ = s_args; /* 5 */ - } + s_args = talloc_asprintf(boot_task, "--append=%s", + boot_task->args ?: "\"\""); + assert(s_args); + *p++ = s_args; /* 5 */ - *p++ = boot_task->local_image; /* 6 */ + *p++ = local_image; /* 6 */ *p++ = NULL; /* 7 */ - result = process_run_simple_argv(boot_task, argv); + result = process_run_sync(process); + if (result) { + pb_log("%s: failed to run process\n", __func__); + goto abort_kexec; + } - if (result) + result = process->exit_status; + + if (result) { pb_log("%s: failed: (%d)\n", __func__, result); + update_status(boot_task->status_fn, boot_task->status_arg, + STATUS_ERROR, "%s", process->stdout_buf); + } + +abort_kexec: + gpg_validate_boot_files_cleanup(boot_task); return result; } @@ -128,27 +184,6 @@ static int kexec_reboot(struct boot_task *task) return result; } -static void __attribute__((format(__printf__, 4, 5))) update_status( - boot_status_fn fn, void *arg, int type, char *fmt, ...) -{ - struct boot_status status; - va_list ap; - - va_start(ap, fmt); - status.message = talloc_vasprintf(NULL, fmt, ap); - va_end(ap); - - status.type = type; - status.progress = -1; - status.detail = NULL; - - pb_debug("boot status: [%d] %s\n", type, status.message); - - fn(arg, &status); - - talloc_free(status.message); -} - static void boot_hook_update_param(void *ctx, struct boot_task *task, const char *name, const char *value) { @@ -176,7 +211,7 @@ static void boot_hook_update(struct boot_task *task, const char *hookname, char *buf) { char *line, *name, *val, *sep; - char *saveptr; + char *saveptr = NULL; for (;; buf = NULL) { @@ -205,6 +240,7 @@ static void boot_hook_setenv(struct boot_task *task) unsetenv("boot_initrd"); unsetenv("boot_dtb"); unsetenv("boot_args"); + unsetenv("boot_console"); setenv("boot_image", task->local_image, 1); if (task->local_initrd) @@ -213,6 +249,8 @@ static void boot_hook_setenv(struct boot_task *task) setenv("boot_dtb", task->local_dtb, 1); if (task->args) setenv("boot_args", task->args, 1); + if (task->boot_console) + setenv("boot_console", task->boot_console, 1); } static int hook_filter(const struct dirent *dirent) @@ -234,8 +272,8 @@ static void run_boot_hooks(struct boot_task *task) if (n < 1) return; - update_status(task->status_fn, task->status_arg, BOOT_STATUS_INFO, - "running boot hooks"); + update_status(task->status_fn, task->status_arg, STATUS_INFO, + _("Running boot hooks")); boot_hook_setenv(task); @@ -293,12 +331,19 @@ static int check_load(struct boot_task *task, const char *name, { if (!result) return 0; - if (result->status != LOAD_ERROR) + + if (result->status != LOAD_ERROR) { + update_status(task->status_fn, task->status_arg, + STATUS_ERROR, + _("Loaded %s from %s"), name, + pb_url_to_string(result->url)); return 0; + } update_status(task->status_fn, task->status_arg, - BOOT_STATUS_ERROR, - "Couldn't load %s", name); + STATUS_ERROR, + _("Couldn't load %s from %s"), name, + pb_url_to_string(result->url)); return -1; } @@ -372,22 +417,86 @@ static void boot_process(struct load_url_result *result, void *data) check_load(task, "dtb", task->dtb)) goto no_load; + if (task->verify_signature) { + if (load_pending(task->image_signature) || + load_pending(task->initrd_signature) || + load_pending(task->dtb_signature) || + load_pending(task->cmdline_signature)) + return; + } + if (task->decrypt_files) { + if (load_pending(task->cmdline_signature)) + return; + } + + if (task->verify_signature) { + if (check_load(task, "kernel image signature", + task->image_signature) || + check_load(task, "initrd signature", + task->initrd_signature) || + check_load(task, "dtb signature", + task->dtb_signature) || + check_load(task, "command line signature", + task->cmdline_signature)) + goto no_sig_load; + } + if (task->decrypt_files) { + if (load_pending(task->cmdline_signature)) + return; + + if (check_load(task, "command line signature", + task->cmdline_signature)) + goto no_decrypt_sig_load; + } + /* we make a copy of the local paths, as the boot hooks might update * and/or create these */ task->local_image = task->image ? task->image->local : NULL; task->local_initrd = task->initrd ? task->initrd->local : NULL; task->local_dtb = task->dtb ? task->dtb->local : NULL; + if (task->verify_signature) { + task->local_image_signature = task->image_signature ? + task->image_signature->local : NULL; + task->local_initrd_signature = task->initrd_signature ? + task->initrd_signature->local : NULL; + task->local_dtb_signature = task->dtb_signature ? + task->dtb_signature->local : NULL; + } + if (task->verify_signature || task->decrypt_files) { + task->local_cmdline_signature = task->cmdline_signature ? + task->cmdline_signature->local : NULL; + } + run_boot_hooks(task); - update_status(task->status_fn, task->status_arg, BOOT_STATUS_INFO, - "performing kexec_load"); + update_status(task->status_fn, task->status_arg, STATUS_INFO, + _("Performing kexec load")); rc = kexec_load(task); - if (rc) { + pb_log("%s: kexec_load returned %d\n", __func__, rc); + if (rc == KEXEC_LOAD_DECRYPTION_FALURE) { update_status(task->status_fn, task->status_arg, - BOOT_STATUS_ERROR, "kexec load failed"); + STATUS_ERROR, _("Decryption failed")); } + else if (rc == KEXEC_LOAD_SIGNATURE_FAILURE) { + update_status(task->status_fn, task->status_arg, + STATUS_ERROR, + _("Signature verification failed")); + } + else if (rc == KEXEC_LOAD_SIG_SETUP_INVALID) { + update_status(task->status_fn, task->status_arg, + STATUS_ERROR, + _("Invalid signature configuration")); + } + +no_sig_load: + cleanup_load(task->image_signature); + cleanup_load(task->initrd_signature); + cleanup_load(task->dtb_signature); + +no_decrypt_sig_load: + cleanup_load(task->cmdline_signature); no_load: cleanup_load(task->image); @@ -396,14 +505,13 @@ no_load: if (!rc) { update_status(task->status_fn, task->status_arg, - BOOT_STATUS_INFO, - "performing kexec reboot"); + STATUS_INFO, _("Performing kexec reboot")); rc = kexec_reboot(task); if (rc) { update_status(task->status_fn, task->status_arg, - BOOT_STATUS_ERROR, - "kexec reboot failed"); + STATUS_ERROR, + _("kexec reboot failed")); } } } @@ -417,8 +525,7 @@ static int start_url_load(struct boot_task *task, const char *name, *result = load_url_async(task, url, boot_process, task); if (!*result) { update_status(task->status_fn, task->status_arg, - BOOT_STATUS_ERROR, - "Error loading %s", name); + STATUS_ERROR, _("Error loading %s"), name); return -1; } return 0; @@ -429,19 +536,23 @@ struct boot_task *boot(void *ctx, struct discover_boot_option *opt, boot_status_fn status_fn, void *status_arg) { struct pb_url *image = NULL, *initrd = NULL, *dtb = NULL; + struct pb_url *image_sig = NULL, *initrd_sig = NULL, *dtb_sig = NULL, + *cmdline_sig = NULL; + const struct config *config = config_get(); struct boot_task *boot_task; const char *boot_desc; int rc; + int lockdown_type; if (opt && opt->option->name) boot_desc = opt->option->name; else if (cmd && cmd->boot_image_file) boot_desc = cmd->boot_image_file; else - boot_desc = "(unknown)"; + boot_desc = _("(unknown)"); - update_status(status_fn, status_arg, BOOT_STATUS_INFO, - "Booting %s.", boot_desc); + update_status(status_fn, status_arg, STATUS_INFO, + _("Booting %s"), boot_desc); if (cmd && cmd->boot_image_file) { image = pb_url_parse(opt, cmd->boot_image_file); @@ -449,8 +560,8 @@ struct boot_task *boot(void *ctx, struct discover_boot_option *opt, image = opt->boot_image->url; } else { pb_log("%s: no image specified\n", __func__); - update_status(status_fn, status_arg, BOOT_STATUS_INFO, - "Boot failed: no image specified"); + update_status(status_fn, status_arg, STATUS_INFO, + _("Boot failed: no image specified")); return NULL; } @@ -471,6 +582,10 @@ struct boot_task *boot(void *ctx, struct discover_boot_option *opt, boot_task->status_fn = status_fn; boot_task->status_arg = status_arg; + lockdown_type = lockdown_status(); + boot_task->verify_signature = (lockdown_type == PB_LOCKDOWN_SIGN); + boot_task->decrypt_files = (lockdown_type == PB_LOCKDOWN_DECRYPT); + if (cmd && cmd->boot_args) { boot_task->args = talloc_strdup(boot_task, cmd->boot_args); } else if (opt && opt->option->boot_args) { @@ -480,14 +595,64 @@ struct boot_task *boot(void *ctx, struct discover_boot_option *opt, boot_task->args = NULL; } + if (cmd && cmd->console && !config->manual_console) + boot_task->boot_console = talloc_strdup(boot_task, cmd->console); + else + boot_task->boot_console = config ? config->boot_console : NULL; + + if (boot_task->verify_signature || boot_task->decrypt_files) { + if (cmd && cmd->args_sig_file) { + cmdline_sig = pb_url_parse(opt, cmd->args_sig_file); + } else if (opt && opt->args_sig_file) { + cmdline_sig = opt->args_sig_file->url; + } else { + pb_log("%s: no command line signature file" + " specified\n", __func__); + update_status(status_fn, status_arg, STATUS_INFO, + _("Boot failed: no command line" + " signature file specified")); + talloc_free(boot_task); + return NULL; + } + } + /* start async loads for boot resources */ - rc = start_url_load(boot_task, "kernel image", image, &boot_task->image) - || start_url_load(boot_task, "initrd", initrd, &boot_task->initrd) - || start_url_load(boot_task, "dtb", dtb, &boot_task->dtb); + rc = start_url_load(boot_task, _("kernel image"), + image, &boot_task->image) + || start_url_load(boot_task, _("initrd"), initrd, &boot_task->initrd) + || start_url_load(boot_task, _("dtb"), dtb, &boot_task->dtb); + + if (boot_task->verify_signature) { + /* Generate names of associated signature files and load */ + if (image) { + image_sig = gpg_get_signature_url(ctx, image); + rc |= start_url_load(boot_task, + _("kernel image signature"), image_sig, + &boot_task->image_signature); + } + if (initrd) { + initrd_sig = gpg_get_signature_url(ctx, initrd); + rc |= start_url_load(boot_task, _("initrd signature"), + initrd_sig, &boot_task->initrd_signature); + } + if (dtb) { + dtb_sig = gpg_get_signature_url(ctx, dtb); + rc |= start_url_load(boot_task, _("dtb signature"), + dtb_sig, &boot_task->dtb_signature); + } + } + + if (boot_task->verify_signature || boot_task->decrypt_files) { + rc |= start_url_load(boot_task, + _("kernel command line signature"), cmdline_sig, + &boot_task->cmdline_signature); + } /* If all URLs are local, we may be done. */ if (rc) { - talloc_free(boot_task); + /* Don't call boot_cancel() to preserve the status update */ + boot_task->cancelled = true; + cleanup_cancellations(boot_task, NULL); return NULL; } @@ -500,8 +665,8 @@ void boot_cancel(struct boot_task *task) { task->cancelled = true; - update_status(task->status_fn, task->status_arg, BOOT_STATUS_INFO, - "Boot cancelled"); + update_status(task->status_fn, task->status_arg, STATUS_INFO, + _("Boot cancelled")); cleanup_cancellations(task, NULL); }