diff options
author | Bill Richardson <wfrichar@chromium.org> | 2014-09-23 14:30:30 -0700 |
---|---|---|
committer | chrome-internal-fetch <chrome-internal-fetch@google.com> | 2014-09-25 20:27:00 +0000 |
commit | f318ee205cc8d92def925c6158272da8a63bf1ed (patch) | |
tree | a0c380fed4d67fbfec256babd3b29175be52464c /futility/cmd_vbutil_kernel.c | |
parent | d5aa5bdb292b64f259f55319fd83bd4a4d548a12 (diff) | |
download | vboot-f318ee205cc8d92def925c6158272da8a63bf1ed.tar.gz |
futility: implement vbutil_kernel using buffers, not files
The original vbutil_kernel command used file read and write to
make changes. Futility prefers to use memory-mapped files. This
rewrites cmd_vbutil_kernel.c to use that scheme.
BUG=none
BRANCH=ToT
TEST=make runtests
The original cmd_vbutil_kernel.c is renamed, and a test written
to ensure that the refactored version produces identical results.
Signed-off-by: Bill Richardson <wfrichar@chromium.org>
Change-Id: Ic6c3e12429a5dcb271f8136a9edac70807d66120
Reviewed-on: https://chromium-review.googlesource.com/219647
Reviewed-by: Randall Spangler <rspangler@chromium.org>
Diffstat (limited to 'futility/cmd_vbutil_kernel.c')
-rw-r--r-- | futility/cmd_vbutil_kernel.c | 743 |
1 files changed, 150 insertions, 593 deletions
diff --git a/futility/cmd_vbutil_kernel.c b/futility/cmd_vbutil_kernel.c index 855c7a53..92061f43 100644 --- a/futility/cmd_vbutil_kernel.c +++ b/futility/cmd_vbutil_kernel.c @@ -1,4 +1,5 @@ -/* Copyright 2012 The Chromium OS Authors. All rights reserved. +/* + * Copyright 2014 The Chromium OS Authors. All rights reserved. * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. * @@ -9,23 +10,28 @@ #include <fcntl.h> #include <getopt.h> #include <inttypes.h> /* For PRIu64 */ -#include <sys/ioctl.h> #include <linux/fs.h> /* For BLKGETSIZE64 */ #include <stdarg.h> -#include <stddef.h> #include <stdio.h> -#include <stdlib.h> #include <string.h> +#include <sys/ioctl.h> #include <sys/stat.h> -#include <sys/types.h> #include <unistd.h> -#include "cryptolib.h" #include "futility.h" #include "host_common.h" #include "kernel_blob.h" -#include "util_misc.h" -#include "vboot_common.h" +#include "vb1_helper.h" + +static void Fatal(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + fprintf(stderr, "ERROR: "); + vfprintf(stderr, format, ap); + va_end(ap); + exit(1); +} /* Global opts */ static int opt_verbose; @@ -133,15 +139,6 @@ static void print_help(const char *progname) printf(usage, progname, progname, progname); } -static void Fatal(const char *format, ...) -{ - va_list ap; - va_start(ap, format); - fprintf(stderr, "ERROR: "); - vfprintf(stderr, format, ap); - va_end(ap); - exit(1); -} /* Return an explanation when fread() fails. */ static const char *error_fread(FILE *fp) @@ -155,194 +152,14 @@ static const char *error_fread(FILE *fp) return retval; } -/* Return the smallest integral multiple of [alignment] that is equal - * to or greater than [val]. Used to determine the number of - * pages/sectors/blocks/whatever needed to contain [val] - * items/bytes/etc. */ -static uint64_t roundup(uint64_t val, uint64_t alignment) -{ - uint64_t rem = val % alignment; - if (rem) - return val + (alignment - rem); - return val; -} -/* Match regexp /\b--\b/ to delimit the start of the kernel commandline. If we - * don't find one, we'll use the whole thing. */ -static unsigned int find_cmdline_start(char *input, unsigned int max_len) -{ - int start = 0; - int i; - for (i = 0; i < max_len - 1 && input[i]; i++) { - if ('-' == input[i] && '-' == input[i + 1]) { - if ((i == 0 || ' ' == input[i - 1]) && - (i + 2 >= max_len || ' ' == input[i + 2])) { - /* found "--" with nothing before or after it */ - start = i + 2; /* hope for a trailing '\0' */ - break; - } - } - } - while (' ' == input[start]) /* skip leading spaces */ - start++; - - return start; -} - -/****************************************************************************/ -/* Here are globals containing all the bits & pieces I'm working on. */ - -/* The individual parts that go into the kernel blob */ -static uint8_t *g_kernel_data; -static uint64_t g_kernel_size; -static uint8_t *g_param_data; -static uint64_t g_param_size; -static uint8_t *g_config_data; -static uint64_t g_config_size; -static uint8_t *g_bootloader_data; -static uint64_t g_bootloader_size; -static uint64_t g_bootloader_address; - -/* The individual parts of the verification blob (including the data that - * immediately follows the headers) */ -static VbKeyBlockHeader *g_keyblock; -static VbKernelPreambleHeader *g_preamble; - -/****************************************************************************/ - -/* - * Read the kernel command line from a file. Get rid of \n characters along - * the way and verify that the line fits into a 4K buffer. - * - * Return the buffer contaning the line on success (and set the line length - * using the passed in parameter), or NULL in case something goes wrong. - */ -static uint8_t *sReadConfigFile(const char *config_file, uint64_t *config_size) -{ - uint8_t *config_buf; - int ii; - - config_buf = ReadFile(config_file, config_size); - Debug(" config file size=0x%" PRIx64 "\n", *config_size); - if (CROS_CONFIG_SIZE <= *config_size) { /* room for trailing '\0' */ - VbExError("Config file %s is too large (>= %d bytes)\n", - config_file, CROS_CONFIG_SIZE); - return NULL; - } - - /* Replace newlines with spaces */ - for (ii = 0; ii < *config_size; ii++) - if ('\n' == config_buf[ii]) - config_buf[ii] = ' '; - - return config_buf; -} - -/* Offset of kernel command line string from start of packed kernel blob */ -static uint64_t CmdLineOffset(VbKernelPreambleHeader *preamble) -{ - return preamble->bootloader_address - preamble->body_load_address - - CROS_CONFIG_SIZE - CROS_PARAMS_SIZE; -} - -/* This initializes g_vmlinuz and g_param from a standard vmlinuz file. - * It returns 0 on error. */ -static int ImportVmlinuzFile(const char *vmlinuz_file, enum arch_t arch, - uint64_t kernel_body_load_address) -{ - uint8_t *kernel_buf; - uint64_t kernel_size; - uint64_t kernel32_start = 0; - uint64_t kernel32_size = 0; - struct linux_kernel_params *params = NULL, *lh = NULL; - - /* Read the kernel */ - Debug("Reading %s\n", vmlinuz_file); - kernel_buf = ReadFile(vmlinuz_file, &kernel_size); - if (!kernel_buf) - return 0; - Debug(" kernel file size=0x%" PRIx64 "\n", kernel_size); - if (!kernel_size) - Fatal("Empty kernel file\n"); - - /* Go ahead and allocate the param region anyway. I don't think we need - * it for non-x86, but let's keep it for now. */ - g_param_size = CROS_PARAMS_SIZE; - g_param_data = VbExMalloc(g_param_size); - Memset(g_param_data, 0, g_param_size); - - /* Unless we're handling x86, the kernel is the kernel; we're done. */ - if (arch != ARCH_X86) { - g_kernel_data = kernel_buf; - g_kernel_size = kernel_size; - return 1; - } - - /* The first part of the x86 vmlinuz is a header, followed by a - * real-mode boot stub. We only want the 32-bit part. */ - lh = (struct linux_kernel_params *)kernel_buf; - kernel32_start = (lh->setup_sects + 1) << 9; - if (kernel32_start >= kernel_size) - Fatal("Malformed kernel\n"); - kernel32_size = kernel_size - kernel32_start; - - Debug(" kernel32_start=0x%" PRIx64 "\n", kernel32_start); - Debug(" kernel32_size=0x%" PRIx64 "\n", kernel32_size); - - /* Keep just the 32-bit kernel. */ - if (kernel32_size) { - g_kernel_size = kernel32_size; - g_kernel_data = VbExMalloc(g_kernel_size); - Memcpy(g_kernel_data, kernel_buf + kernel32_start, - kernel32_size); - } - - /* Copy the original zeropage data from kernel_buf into g_param_data, - * then tweak a few fields for our purposes */ - params = (struct linux_kernel_params *)(g_param_data); - Memcpy(&(params->setup_sects), &(lh->setup_sects), - offsetof(struct linux_kernel_params, e820_entries) - - offsetof(struct linux_kernel_params, setup_sects)); - params->boot_flag = 0; - params->ramdisk_image = 0; /* we don't support initrd */ - params->ramdisk_size = 0; - params->type_of_loader = 0xff; - /* We need to point to the kernel commandline arg. On disk, it will come - * right after the 32-bit part of the kernel. */ - params->cmd_line_ptr = kernel_body_load_address + - roundup(kernel32_size, CROS_ALIGN) + - find_cmdline_start((char *)g_config_data, g_config_size); - Debug(" cmdline_addr=0x%x\n", params->cmd_line_ptr); - Debug(" version=0x%x\n", params->version); - Debug(" kernel_alignment=0x%x\n", params->kernel_alignment); - Debug(" relocatable_kernel=0x%x\n", params->relocatable_kernel); - /* A fake e820 memory map with 2 entries */ - params->n_e820_entry = 2; - params->e820_entries[0].start_addr = 0x00000000; - params->e820_entries[0].segment_size = 0x00001000; - params->e820_entries[0].segment_type = E820_TYPE_RAM; - params->e820_entries[1].start_addr = 0xfffff000; - params->e820_entries[1].segment_size = 0x00001000; - params->e820_entries[1].segment_type = E820_TYPE_RESERVED; - - /* done */ - free(kernel_buf); - return 1; -} - -/* This returns just the kernel blob, with the verification blob separated - * and copied to new memory in g_keyblock and g_preamble. */ -static uint8_t *ReadOldBlobFromFileOrDie(const char *filename, +/* This reads a complete kernel partition into a buffer */ +static uint8_t *ReadOldKPartFromFileOrDie(const char *filename, uint64_t *size_ptr) { FILE *fp = NULL; struct stat statbuf; - VbKeyBlockHeader *key_block; - VbKernelPreambleHeader *preamble; - uint64_t now = 0; uint8_t *buf; - uint8_t *kernel_blob_data; - uint64_t kernel_blob_size; uint64_t file_size = 0; if (0 != stat(filename, &statbuf)) @@ -367,330 +184,20 @@ static uint8_t *ReadOldBlobFromFileOrDie(const char *filename, Fatal("Unable to open file %s: %s\n", filename, strerror(errno)); - buf = VbExMalloc(opt_pad); - if (1 != fread(buf, opt_pad, 1, fp)) - Fatal("Unable to read header from %s: %s\n", filename, - error_fread(fp)); - - /* Sanity-check the key_block */ - key_block = (VbKeyBlockHeader *) buf; - Debug("Keyblock is 0x%" PRIx64 " bytes\n", key_block->key_block_size); - now += key_block->key_block_size; - if (now > file_size) - Fatal("key_block_size advances past the end of the blob\n"); - if (now > opt_pad) - Fatal("key_block_size advances past %" PRIu64 " byte padding\n", - opt_pad); - /* LGTM */ - g_keyblock = (VbKeyBlockHeader *) VbExMalloc(key_block->key_block_size); - Memcpy(g_keyblock, key_block, key_block->key_block_size); - - /* And the preamble */ - preamble = (VbKernelPreambleHeader *) (buf + now); - Debug("Preamble is 0x%" PRIx64 " bytes\n", preamble->preamble_size); - now += preamble->preamble_size; - if (now > file_size) - Fatal("preamble_size advances past the end of the blob\n"); - if (now > opt_pad) - Fatal("preamble_size advances past %" PRIu64 " byte padding\n", - opt_pad); - /* LGTM */ - Debug(" kernel_version = %d\n", preamble->kernel_version); - Debug(" bootloader_address = 0x%" PRIx64 "\n", - preamble->bootloader_address); - Debug(" bootloader_size = 0x%" PRIx64 "\n", preamble->bootloader_size); - Debug(" kern_blob_size = 0x%" PRIx64 "\n", - preamble->body_signature.data_size); - g_preamble = - (VbKernelPreambleHeader *) VbExMalloc(preamble->preamble_size); - Memcpy(g_preamble, preamble, preamble->preamble_size); - - /* Now for the kernel blob */ - Debug("kernel blob is at offset 0x%" PRIx64 "\n", now); - if (0 != fseek(fp, now, SEEK_SET)) - Fatal("Unable to seek to 0x%" PRIx64 " in %s: %s\n", now, - filename, strerror(errno)); - - /* Sanity check */ - kernel_blob_size = file_size - now; - if (!kernel_blob_size) - Fatal("No kernel blob found\n"); - if (kernel_blob_size < preamble->body_signature.data_size) - fprintf(stderr, - "Warning: kernel file only has 0x%" PRIx64 " bytes\n", - kernel_blob_size); - kernel_blob_data = VbExMalloc(kernel_blob_size); - - /* Read it in */ - if (1 != fread(kernel_blob_data, kernel_blob_size, 1, fp)) - Fatal("Unable to read kernel blob from %s: %s\n", filename, + buf = malloc(file_size); + if (1 != fread(buf, file_size, 1, fp)) + Fatal("Unable to read entirety of %s: %s\n", filename, error_fread(fp)); - /* Done */ - VbExFree(buf); - - if (size_ptr) - *size_ptr = kernel_blob_size; - - return kernel_blob_data; -} - -/* Split a kernel blob into separate g_kernel, g_param, g_config, and - * g_bootloader parts. */ -static void UnpackKernelBlob(uint8_t *kernel_blob_data, - uint64_t kernel_blob_size) -{ - - uint64_t k_blob_size = g_preamble->body_signature.data_size; - uint64_t k_blob_ofs = 0; - uint64_t b_size = g_preamble->bootloader_size; - uint64_t b_ofs = k_blob_ofs + g_preamble->bootloader_address - - g_preamble->body_load_address; - uint64_t p_ofs = b_ofs - CROS_CONFIG_SIZE; - uint64_t c_ofs = p_ofs - CROS_PARAMS_SIZE; - - Debug("k_blob_size = 0x%" PRIx64 "\n", k_blob_size); - Debug("k_blob_ofs = 0x%" PRIx64 "\n", k_blob_ofs); - Debug("b_size = 0x%" PRIx64 "\n", b_size); - Debug("b_ofs = 0x%" PRIx64 "\n", b_ofs); - Debug("p_ofs = 0x%" PRIx64 "\n", p_ofs); - Debug("c_ofs = 0x%" PRIx64 "\n", c_ofs); - - g_kernel_size = c_ofs; - g_kernel_data = VbExMalloc(g_kernel_size); - Memcpy(g_kernel_data, kernel_blob_data, g_kernel_size); - - g_param_size = CROS_PARAMS_SIZE; - g_param_data = VbExMalloc(g_param_size); - Memcpy(g_param_data, kernel_blob_data + p_ofs, g_param_size); - - g_config_size = CROS_CONFIG_SIZE; - g_config_data = VbExMalloc(g_config_size); - Memcpy(g_config_data, kernel_blob_data + c_ofs, g_config_size); - - g_bootloader_size = b_size; - g_bootloader_data = VbExMalloc(g_bootloader_size); - Memcpy(g_bootloader_data, kernel_blob_data + b_ofs, g_bootloader_size); -} - -/****************************************************************************/ - -static uint8_t *CreateKernBlob(uint64_t kernel_body_load_address, - enum arch_t arch, uint64_t *size_ptr) -{ - uint8_t *kern_blob; - uint64_t kern_blob_size; - uint64_t now; - uint64_t bootloader_size = roundup(g_bootloader_size, CROS_ALIGN); - - /* Put the kernel blob together */ - kern_blob_size = roundup(g_kernel_size, CROS_ALIGN) + - CROS_CONFIG_SIZE + CROS_PARAMS_SIZE + bootloader_size; - Debug("kern_blob_size=0x%" PRIx64 "\n", kern_blob_size); - kern_blob = VbExMalloc(kern_blob_size); - Memset(kern_blob, 0, kern_blob_size); - now = 0; - - Debug("kernel goes at kern_blob+0x%" PRIx64 "\n", now); - - Memcpy(kern_blob + now, g_kernel_data, g_kernel_size); - now += roundup(g_kernel_size, CROS_ALIGN); - - Debug("config goes at kern_blob+0x%" PRIx64 "\n", now); - if (g_config_size) - Memcpy(kern_blob + now, g_config_data, g_config_size); - now += CROS_CONFIG_SIZE; - - Debug("params goes at kern_blob+0x%" PRIx64 "\n", now); - if (g_param_size) - Memcpy(kern_blob + now, g_param_data, g_param_size); - now += CROS_PARAMS_SIZE; - - Debug("bootloader goes at kern_blob+0x%" PRIx64 "\n", now); - g_bootloader_address = kernel_body_load_address + now; - Debug(" bootloader_address=0x%" PRIx64 "\n", g_bootloader_address); - Debug(" bootloader_size=0x%" PRIx64 "\n", bootloader_size); - if (bootloader_size) - Memcpy(kern_blob + now, g_bootloader_data, g_bootloader_size); - now += bootloader_size; - Debug("end of kern_blob at kern_blob+0x%" PRIx64 "\n", now); - - /* Done */ if (size_ptr) - *size_ptr = kern_blob_size; - - return kern_blob; -} - -static int Pack(const char *outfile, - uint8_t *kernel_blob, - uint64_t kernel_size, - int version, - uint64_t kernel_body_load_address, - VbPrivateKey *signpriv_key) -{ - VbSignature *body_sig; - FILE *f; - uint64_t i; - uint64_t written = 0; - - /* Sign the kernel data */ - body_sig = CalculateSignature(kernel_blob, kernel_size, signpriv_key); - if (!body_sig) - Fatal("Error calculating body signature\n"); - - /* Create preamble */ - g_preamble = CreateKernelPreamble(version, - kernel_body_load_address, - g_bootloader_address, - roundup(g_bootloader_size, - CROS_ALIGN), body_sig, - opt_pad - g_keyblock->key_block_size, - signpriv_key); - if (!g_preamble) { - VbExError("Error creating preamble.\n"); - return 1; - } - /* Write the output file */ - Debug("writing %s...\n", outfile); - f = fopen(outfile, "wb"); - if (!f) { - VbExError("Can't open output file %s\n", outfile); - return 1; - } - Debug("0x%" PRIx64 " bytes of key_block\n", g_keyblock->key_block_size); - Debug("0x%" PRIx64 " bytes of preamble\n", g_preamble->preamble_size); - i = ((1 != fwrite(g_keyblock, g_keyblock->key_block_size, 1, f)) || - (1 != fwrite(g_preamble, g_preamble->preamble_size, 1, f))); - if (i) { - VbExError("Can't write output file %s\n", outfile); - fclose(f); - unlink(outfile); - return 1; - } - written += g_keyblock->key_block_size; - written += g_preamble->preamble_size; - - if (!opt_vblockonly) { - Debug("0x%" PRIx64 " bytes of kern_blob\n", kernel_size); - i = (1 != fwrite(kernel_blob, kernel_size, 1, f)); - if (i) { - fclose(f); - unlink(outfile); - Fatal("Can't write output file %s\n", outfile); - } - written += kernel_size; - } - Debug("0x%" PRIx64 " bytes total\n", written); - fclose(f); - - /* Success */ - return 0; -} - -static int Verify(uint8_t *kernel_blob, - uint64_t kernel_size, - VbPublicKey *signpub_key, - const char *keyblock_outfile, - uint64_t min_version) -{ - VbPublicKey *data_key; - RSAPublicKey *rsa; - - if (0 != KeyBlockVerify(g_keyblock, g_keyblock->key_block_size, - signpub_key, (0 == signpub_key))) - Fatal("Error verifying key block.\n"); - - printf("Key block:\n"); - data_key = &g_keyblock->data_key; - if (opt_verbose) - printf(" Signature: %s\n", - signpub_key ? "valid" : "ignored"); - printf(" Size: 0x%" PRIx64 "\n", - g_keyblock->key_block_size); - printf(" Flags: %" PRIu64 " ", - g_keyblock->key_block_flags); - if (g_keyblock->key_block_flags & KEY_BLOCK_FLAG_DEVELOPER_0) - printf(" !DEV"); - if (g_keyblock->key_block_flags & KEY_BLOCK_FLAG_DEVELOPER_1) - printf(" DEV"); - if (g_keyblock->key_block_flags & KEY_BLOCK_FLAG_RECOVERY_0) - printf(" !REC"); - if (g_keyblock->key_block_flags & KEY_BLOCK_FLAG_RECOVERY_1) - printf(" REC"); - printf("\n"); - printf(" Data key algorithm: %" PRIu64 " %s\n", data_key->algorithm, - (data_key->algorithm < kNumAlgorithms ? - algo_strings[data_key->algorithm] : "(invalid)")); - printf(" Data key version: %" PRIu64 "\n", data_key->key_version); - printf(" Data key sha1sum: "); - PrintPubKeySha1Sum(data_key); - printf("\n"); - - if (keyblock_outfile) { - FILE *f = NULL; - f = fopen(keyblock_outfile, "wb"); - if (!f) - Fatal("Can't open key block file %s\n", - keyblock_outfile); - if (1 != fwrite(g_keyblock, g_keyblock->key_block_size, 1, f)) - Fatal("Can't write key block file %s\n", - keyblock_outfile); - fclose(f); - } + *size_ptr = file_size; - if (data_key->key_version < (min_version >> 16)) - Fatal("Data key version %" PRIu64 - " is lower than minimum %" PRIu64 ".\n", - data_key->key_version, (min_version >> 16)); - - rsa = PublicKeyToRSA(data_key); - if (!rsa) - Fatal("Error parsing data key.\n"); - - /* Verify preamble */ - if (0 != - VerifyKernelPreamble(g_preamble, g_preamble->preamble_size, rsa)) - Fatal("Error verifying preamble.\n"); - - printf("Preamble:\n"); - printf(" Size: 0x%" PRIx64 "\n", - g_preamble->preamble_size); - printf(" Header version: %" PRIu32 ".%" PRIu32 "\n", - g_preamble->header_version_major, - g_preamble->header_version_minor); - printf(" Kernel version: %" PRIu64 "\n", - g_preamble->kernel_version); - printf(" Body load address: 0x%" PRIx64 "\n", - g_preamble->body_load_address); - printf(" Body size: 0x%" PRIx64 "\n", - g_preamble->body_signature.data_size); - printf(" Bootloader address: 0x%" PRIx64 "\n", - g_preamble->bootloader_address); - printf(" Bootloader size: 0x%" PRIx64 "\n", - g_preamble->bootloader_size); - - if (g_preamble->kernel_version < (min_version & 0xFFFF)) - Fatal("Kernel version %" PRIu64 " is lower than minimum %" - PRIu64 ".\n", g_preamble->kernel_version, - (min_version & 0xFFFF)); - - /* Verify body */ - if (0 != VerifyData(kernel_blob, kernel_size, - &g_preamble->body_signature, rsa)) - Fatal("Error verifying kernel body.\n"); - printf("Body verification succeeded.\n"); - - if (opt_verbose) - printf("Config:\n%s\n", - kernel_blob + CmdLineOffset(g_preamble)); - - return 0; + return buf; } /****************************************************************************/ -static int do_vbutil_kernel(int argc, char *argv[]) +static int do_vbutil_kernel2(int argc, char *argv[]) { char *filename = NULL; char *oldfile = NULL; @@ -703,17 +210,30 @@ static int do_vbutil_kernel(int argc, char *argv[]) char *bootloader_file = NULL; char *config_file = NULL; enum arch_t arch = ARCH_X86; - char *address_str = NULL; uint64_t kernel_body_load_address = CROS_32BIT_ENTRY_ADDR; int mode = 0; int parse_error = 0; uint64_t min_version = 0; char *e; int i; + int rv; + VbKeyBlockHeader *keyblock = NULL; + VbKeyBlockHeader *t_keyblock = NULL; VbPrivateKey *signpriv_key = NULL; VbPublicKey *signpub_key = NULL; - uint8_t *kernel_blob = NULL; - uint64_t kernel_size = 0; + uint8_t *kpart_data = NULL; + uint64_t kpart_size = 0; + uint8_t *vmlinuz_buf = NULL; + uint64_t vmlinuz_size = 0; + uint8_t *t_config_data; + uint64_t t_config_size; + uint8_t *t_bootloader_data; + uint64_t t_bootloader_size; + VbKernelPreambleHeader *preamble = NULL; + uint8_t *kblob_data = NULL; + uint64_t kblob_size = 0; + uint8_t *vblock_data = NULL; + uint64_t vblock_size = 0; while (((i = getopt_long(argc, argv, ":", long_opts, NULL)) != -1) && !parse_error) { @@ -764,7 +284,6 @@ static int do_vbutil_kernel(int argc, char *argv[]) break; case OPT_KLOADADDR: - address_str = optarg; kernel_body_load_address = strtoul(optarg, &e, 0); if (!*optarg || (e && *e)) { fprintf(stderr, "Invalid --kloadaddr\n"); @@ -835,13 +354,11 @@ static int do_vbutil_kernel(int argc, char *argv[]) switch (mode) { case OPT_MODE_PACK: - /* Required */ - if (!keyblock_file) Fatal("Missing required keyblock file.\n"); - g_keyblock = (VbKeyBlockHeader *) ReadFile(keyblock_file, 0); - if (!g_keyblock) + t_keyblock = (VbKeyBlockHeader *)ReadFile(keyblock_file, 0); + if (!t_keyblock) Fatal("Error reading key block.\n"); if (!signprivkey_file) @@ -851,38 +368,66 @@ static int do_vbutil_kernel(int argc, char *argv[]) if (!signpriv_key) Fatal("Error reading signing key.\n"); - /* Optional */ - - if (config_file) { - Debug("Reading %s\n", config_file); - g_config_data = - sReadConfigFile(config_file, &g_config_size); - if (!g_config_data) - Fatal("Error reading config file.\n"); - } - - if (vmlinuz_file) - if (!ImportVmlinuzFile - (vmlinuz_file, arch, kernel_body_load_address)) - Fatal("Error reading kernel file.\n"); - - if (bootloader_file) { - Debug("Reading %s\n", bootloader_file); - g_bootloader_data = - ReadFile(bootloader_file, &g_bootloader_size); - if (!g_bootloader_data) - Fatal("Error reading bootloader file.\n"); - Debug(" bootloader file size=0x%" PRIx64 "\n", - g_bootloader_size); - } - - /* Do it */ - - kernel_blob = CreateKernBlob(kernel_body_load_address, arch, - &kernel_size); - - return Pack(filename, kernel_blob, kernel_size, - version, kernel_body_load_address, signpriv_key); + if (!config_file) + Fatal("Missing required config file.\n"); + + Debug("Reading %s\n", config_file); + t_config_data = + ReadConfigFile(config_file, &t_config_size); + if (!t_config_data) + Fatal("Error reading config file.\n"); + + if (!bootloader_file) + Fatal("Missing required bootloader file.\n"); + + Debug("Reading %s\n", bootloader_file); + t_bootloader_data = ReadFile(bootloader_file, + &t_bootloader_size); + if (!t_bootloader_data) + Fatal("Error reading bootloader file.\n"); + Debug(" bootloader file size=0x%" PRIx64 "\n", + t_bootloader_size); + + if (!vmlinuz_file) + Fatal("Missing required vmlinuz file.\n"); + Debug("Reading %s\n", vmlinuz_file); + vmlinuz_buf = ReadFile(vmlinuz_file, &vmlinuz_size); + if (!vmlinuz_buf) + Fatal("Error reading vmlinuz file.\n"); + Debug(" vmlinuz file size=0x%" PRIx64 "\n", + vmlinuz_size); + if (!vmlinuz_size) + Fatal("Empty vmlinuz file\n"); + + kblob_data = CreateKernelBlob( + vmlinuz_buf, vmlinuz_size, + arch, kernel_body_load_address, + t_config_data, t_config_size, + t_bootloader_data, t_bootloader_size, + &kblob_size); + if (!kblob_data) + Fatal("Unable to create kernel blob\n"); + + Debug("kblob_size = 0x%" PRIx64 "\n", kblob_size); + + vblock_data = SignKernelBlob(kblob_data, kblob_size, opt_pad, + version, kernel_body_load_address, + t_keyblock, signpriv_key, + &vblock_size); + if (!vblock_data) + Fatal("Unable to sign kernel blob\n"); + + Debug("vblock_size = 0x%" PRIx64 "\n", vblock_size); + + if (opt_vblockonly) + rv = WriteSomeParts(filename, + vblock_data, vblock_size, + NULL, 0); + else + rv = WriteSomeParts(filename, + vblock_data, vblock_size, + kblob_data, kblob_size); + return rv; case OPT_MODE_REPACK: @@ -898,52 +443,56 @@ static int do_vbutil_kernel(int argc, char *argv[]) if (!oldfile) Fatal("Missing previously packed blob.\n"); - /* Load the old blob */ - - kernel_blob = ReadOldBlobFromFileOrDie(oldfile, &kernel_size); - if (0 != Verify(kernel_blob, kernel_size, 0, 0, 0)) - Fatal("The oldblob doesn't verify\n"); - - /* Take it apart */ - - UnpackKernelBlob(kernel_blob, kernel_size); - free(kernel_blob); + /* Load the kernel partition */ + kpart_data = ReadOldKPartFromFileOrDie(oldfile, &kpart_size); - /* Load optional params */ + kblob_data = UnpackKPart(kpart_data, kpart_size, opt_pad, + &keyblock, &preamble, &kblob_size); - if (!version_str) - version = g_preamble->kernel_version; + if (!kblob_data) + Fatal("Unable to unpack kernel partition\n"); - if (!address_str) - kernel_body_load_address = - g_preamble->body_load_address; + kernel_body_load_address = preamble->body_load_address; + /* Update the config if asked */ if (config_file) { - if (g_config_data) - free(g_config_data); Debug("Reading %s\n", config_file); - g_config_data = - sReadConfigFile(config_file, &g_config_size); - if (!g_config_data) + t_config_data = + ReadConfigFile(config_file, &t_config_size); + if (!t_config_data) Fatal("Error reading config file.\n"); + if (0 != UpdateKernelBlobConfig( + kblob_data, kblob_size, + t_config_data, t_config_size)) + Fatal("Unable to update config\n"); } + if (!version_str) + version = preamble->kernel_version; + if (keyblock_file) { - if (g_keyblock) - free(g_keyblock); - g_keyblock = - (VbKeyBlockHeader *) ReadFile(keyblock_file, 0); - if (!g_keyblock) + t_keyblock = + (VbKeyBlockHeader *)ReadFile(keyblock_file, 0); + if (!t_keyblock) Fatal("Error reading key block.\n"); } - /* Put it back together */ - - kernel_blob = CreateKernBlob(kernel_body_load_address, arch, - &kernel_size); - - return Pack(filename, kernel_blob, kernel_size, - version, kernel_body_load_address, signpriv_key); + vblock_data = SignKernelBlob(kblob_data, kblob_size, opt_pad, + version, kernel_body_load_address, + t_keyblock ? t_keyblock : keyblock, + signpriv_key, &vblock_size); + if (!vblock_data) + Fatal("Unable to sign kernel blob\n"); + + if (opt_vblockonly) + rv = WriteSomeParts(filename, + vblock_data, vblock_size, + NULL, 0); + else + rv = WriteSomeParts(filename, + vblock_data, vblock_size, + kblob_data, kblob_size); + return rv; case OPT_MODE_VERIFY: @@ -957,10 +506,18 @@ static int do_vbutil_kernel(int argc, char *argv[]) /* Do it */ - kernel_blob = ReadOldBlobFromFileOrDie(filename, &kernel_size); + /* Load the kernel partition */ + kpart_data = ReadOldKPartFromFileOrDie(filename, &kpart_size); + + kblob_data = UnpackKPart(kpart_data, kpart_size, opt_pad, + 0, 0, &kblob_size); + if (!kblob_data) + Fatal("Unable to unpack kernel partition\n"); + + rv = VerifyKernelBlob(kblob_data, kblob_size, + signpub_key, keyblock_file, min_version); - return Verify(kernel_blob, kernel_size, signpub_key, - keyblock_file, min_version); + return rv; } fprintf(stderr, @@ -969,6 +526,6 @@ static int do_vbutil_kernel(int argc, char *argv[]) return 1; } -DECLARE_FUTIL_COMMAND(vbutil_kernel, do_vbutil_kernel, - "Creates, signs, and verifies the kernel blob", +DECLARE_FUTIL_COMMAND(vbutil_kernel, do_vbutil_kernel2, + "Creates, signs, and verifies the kernel partition", print_help); |