VBoot Reference: Add kernel rollback prevention and choosing logic.

src/platform/vboot_reference/tests/test_common.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.
  *
  * Common functions used by tests.
  */
 
 #include "test_common.h"
 
 #include <stdio.h>
 
 #include "file_keys.h"
 #include "rsa_utility.h"
 #include "utility.h"
 
 /* ANSI Color coding sequences. */
 #define COL_GREEN "\e[1;32m"
 #define COL_RED "\e[0;31m"
 #define COL_STOP "\e[m"
 
 /* Global test success flag. */
 int gTestSuccess = 1;
 
 int TEST_EQ(int result, int expected_result, char* testname) {
   if (result == expected_result) {
-    fprintf(stderr, "%s Test " COL_GREEN " PASSED\n" COL_STOP, testname);
+    fprintf(stderr, "%s Test " COL_GREEN "PASSED\n" COL_STOP, testname);
     return 1;
   }
   else {
-    fprintf(stderr, "%s Test " COL_RED " FAILED\n" COL_STOP, testname);
+    fprintf(stderr, "%s Test " COL_RED "FAILED\n" COL_STOP, testname);
     gTestSuccess = 0;
     return 0;
   }
 }
 
 FirmwareImage* GenerateTestFirmwareImage(int algorithm,
                                          const uint8_t* firmware_sign_key,
                                          int firmware_key_version,
                                          int firmware_version,
                                          int firmware_len,
@@ skipping 54 matching lines @@
                                     firmware_key_version,
                                     firmware_version,
                                     firmware_len,
                                     root_key_file,
                                     firmware_key_file);
   firmware_blob = GetFirmwareBlob(image, &firmware_blob_len);
   FirmwareImageFree(image);
   return firmware_blob;
 }
 
-uint8_t* GenerateRollbackTestImage(int firmware_key_version,
-                                   int firmware_version,
-                                   int is_corrupt) {
+uint8_t* GenerateRollbackTestFirmwareBlob(int firmware_key_version,
+                                          int firmware_version,
+                                          int is_corrupt) {
   FirmwareImage* image = NULL;
   uint64_t len;
   uint8_t* firmware_blob = NULL;
   uint8_t* firmware_sign_key = NULL;
 
   firmware_sign_key = BufferFromFile("testkeys/key_rsa1024.keyb",
                                      &len);
   if (!firmware_sign_key)
     return NULL;
   image = GenerateTestFirmwareImage(0,  /* RSA1024/SHA1 */
@@ skipping 88 matching lines @@
                                   kernel_key_version,
                                   kernel_version,
                                   kernel_len,
                                   firmware_key_file,
                                   kernel_key_file);
 
   kernel_blob = GetKernelBlob(image, &kernel_blob_len);
   KernelImageFree(image);
   return kernel_blob;
 }
+
+uint8_t* GenerateRollbackTestKernelBlob(int kernel_key_version,
+                                        int kernel_version,
+                                        int is_corrupt) {
+ KernelImage* image = NULL;
+ uint64_t len;
+ uint8_t* kernel_blob = NULL;
+ uint8_t* kernel_sign_key = NULL;
+ kernel_sign_key = BufferFromFile("testkeys/key_rsa1024.keyb",
+                                  &len);
+ if (!kernel_sign_key)
+   return NULL;
+ image = GenerateTestKernelImage(0,  /* Firmware algo: RSA1024/SHA1 */
+                                 0,  /* Kernel algo: RSA1024/SHA1 */
+                                 kernel_sign_key,
+                                 kernel_key_version,
+                                 kernel_version,
+                                 1,  /* kernel length. */
+                                 "testkeys/key_rsa1024.pem",
+                                 "testkeys/key_rsa1024.pem");
+ if (!image)
+   return NULL;
+ if (is_corrupt) {
+   /* Invalidate image. */
+   Memset(image->kernel_data, 'X', image->options.kernel_len);
+ }
+ kernel_blob = GetKernelBlob(image, &len);
+ KernelImageFree(image);
+ return kernel_blob;
+}