fix clearing kernel attributes

firmware/lib/vboot_kernel.c

 /* Copyright (c) 2010 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.
  *
  * Functions for loading a kernel from disk.
  * (Firmware portion)
  */
 
 #include "vboot_kernel.h"
 
@@ skipping 195 matching lines @@
       uint64_t body_offset_sectors;
       uint64_t body_sectors;
 
       VBDEBUG(("Found kernel entry at %" PRIu64 " size %" PRIu64 "\n",
               part_start, part_size));
 
       /* Found at least one kernel partition. */
       found_partitions++;
 
       /* Read the first part of the kernel partition  */
-      if (part_size < kbuf_sectors)
+      if (part_size < kbuf_sectors) {
+        VBDEBUG(("Partition too small to hold kernel.\n"));
         goto bad_kernel;
-      if (0 != BootDeviceReadLBA(part_start, kbuf_sectors, kbuf))
+      }
+
+      if (0 != BootDeviceReadLBA(part_start, kbuf_sectors, kbuf)) {
+        VBDEBUG(("Unable to read start of partition.\n"));
         goto bad_kernel;
+      }
 
       /* Verify the key block.  In developer mode, we ignore the key
        * and use only the SHA-512 hash to verify the key block. */
       key_block = (VbKeyBlockHeader*)kbuf;
       if ((0 != KeyBlockVerify(key_block, KBUF_SIZE, kernel_subkey,
                                is_dev && !is_rec))) {
         VBDEBUG(("Verifying key block failed.\n"));
         goto bad_kernel;
       }
 
@@ skipping 18 matching lines @@
        * skipped in recovery and developer modes because those set
        * key_version=0 above. */
       key_version = key_block->data_key.key_version;
       if (key_version < (tpm_version >> 16)) {
         VBDEBUG(("Key version too old.\n"));
         goto bad_kernel;
       }
 
       /* Get the key for preamble/data verification from the key block */
       data_key = PublicKeyToRSA(&key_block->data_key);
-      if (!data_key)
+      if (!data_key) {
+        VBDEBUG(("Data key bad.\n"));
         goto bad_kernel;
+      }
 
       /* Verify the preamble, which follows the key block */
       preamble = (VbKernelPreambleHeader*)(kbuf + key_block->key_block_size);
       if ((0 != VerifyKernelPreamble(preamble,
                                      KBUF_SIZE - key_block->key_block_size,
                                      data_key))) {
         VBDEBUG(("Preamble verification failed.\n"));
         goto bad_kernel;
       }
 
       /* Check for rollback of kernel version.  Note this is implicitly
        * skipped in recovery and developer modes because rollback_index
        * sets those to 0 in those modes. */
       combined_version = ((key_version << 16) |
                           (preamble->kernel_version & 0xFFFF));
       if (combined_version < tpm_version) {
         VBDEBUG(("Kernel version too low.\n"));
         goto bad_kernel;
       }
 
       VBDEBUG(("Kernel preamble is good.\n"));
 
       /* Check for lowest version from a valid header. */
       if (lowest_version > combined_version)
         lowest_version = combined_version;
 
       /* If we already have a good kernel, no need to read another
        * one; we only needed to look at the versions to check for
-       * rollback. */
+       * rollback.  So skip to the next kernel preamble. */
       if (-1 != good_partition)
-        goto bad_kernel;
+        continue;
 
       /* Verify body load address matches what we expect */
       if ((preamble->body_load_address != (size_t)params->kernel_buffer) &&
           !(params->boot_flags & BOOT_FLAG_SKIP_ADDR_CHECK)) {
         VBDEBUG(("Wrong body load address.\n"));
         goto bad_kernel;
       }
 
       /* Verify kernel body starts at a multiple of the sector size. */
       body_offset = key_block->key_block_size + preamble->preamble_size;
@@ skipping 128 matching lines @@
     return LOAD_KERNEL_SUCCESS;
   }
 
   /* The BIOS may attempt to display different screens depending on whether
    * we find an invalid kernel partition (return LOAD_KERNEL_INVALID) or not.
    * But the flow is changing, so for now treating both cases as invalid gives
    * slightly less confusing user feedback. Sigh.
    */
   return LOAD_KERNEL_INVALID;
 }