← Back to branch summary

~ubuntu-branches/ubuntu/trusty/vboot-utils/trusty

« back to all changes in this revision

Viewing changes to tests/kernel_image_tests.c

  • Committer: Package Import Robot
  • Author(s): Antonio Terceiro
  • Date: 2012-12-16 11:03:40 UTC
  • Revision ID: package-import@ubuntu.com-20121216110340-f7wcseecbc9jed5l
Tags: upstream-0~20121212
Import upstream version 0~20121212

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/kernel_image_tests.c
 
1
/* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 
2
 * Use of this source code is governed by a BSD-style license that can be
 
3
 * found in the LICENSE file.
 
4
 *
 
5
 * Tests for kernel image library.
 
6
 */
 
7
 
 
8
#include <stdio.h>
 
9
#include <stdlib.h>
 
10
 
 
11
#include "cryptolib.h"
 
12
#include "file_keys.h"
 
13
#include "kernel_image.h"
 
14
#include "test_common.h"
 
15
#include "utility.h"
 
16
 
 
17
/* Normal Kernel Blob Verification Tests. */
 
18
void VerifyKernelTest(uint8_t* kernel_blob, uint8_t* firmware_key_blob) {
 
19
  TEST_EQ(VerifyKernel(firmware_key_blob, kernel_blob, DEV_MODE_ENABLED),
 
20
          VERIFY_KERNEL_SUCCESS,
 
21
          "Normal Kernel Blob Verification (Dev Mode)");
 
22
 
 
23
  TEST_EQ(VerifyKernel(firmware_key_blob, kernel_blob, DEV_MODE_DISABLED),
 
24
          VERIFY_KERNEL_SUCCESS,
 
25
          "Normal Kernel Blob Verification (Trusted)");
 
26
}
 
27
 
 
28
 
 
29
/* Normal KernelImage Verification Tests. */
 
30
void VerifyKernelImageTest(KernelImage* image,
 
31
                          RSAPublicKey* firmware_key) {
 
32
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_ENABLED),
 
33
          VERIFY_KERNEL_SUCCESS,
 
34
          "Normal KernelImage Verification (Dev Mode)");
 
35
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_DISABLED),
 
36
          VERIFY_KERNEL_SUCCESS,
 
37
          "Normal KernelImage Verification (Trusted)");
 
38
}
 
39
 
 
40
/* Tampered KernelImage Verification Tests. */
 
41
void VerifyKernelImageTamperTest(KernelImage* image,
 
42
                                 RSAPublicKey* firmware_key) {
 
43
  image->bootloader_offset ^= 0xFF;
 
44
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_ENABLED),
 
45
          VERIFY_KERNEL_PREAMBLE_SIGNATURE_FAILED,
 
46
          "KernelImage Config Tamper Verification (Dev Mode)");
 
47
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_DISABLED),
 
48
          VERIFY_KERNEL_PREAMBLE_SIGNATURE_FAILED,
 
49
          "KernelImage Config Tamper Verification (Trusted)");
 
50
  image->bootloader_offset ^= 0xFF;
 
51
 
 
52
  image->kernel_data[0] = 'T';
 
53
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_ENABLED),
 
54
          VERIFY_KERNEL_SIGNATURE_FAILED,
 
55
          "KernelImage Tamper Verification (Dev Mode)");
 
56
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_DISABLED),
 
57
          VERIFY_KERNEL_SIGNATURE_FAILED,
 
58
          "KernelImage Tamper Verification (Trusted)");
 
59
  image->kernel_data[0] = 'K';
 
60
 
 
61
  image->kernel_key_signature[0] = 0xFF;
 
62
  image->kernel_key_signature[1] = 0x00;
 
63
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_ENABLED),
 
64
          VERIFY_KERNEL_SUCCESS,
 
65
          "KernelImage Key Signature Tamper Verification (Dev Mode)");
 
66
  TEST_EQ(VerifyKernelImage(firmware_key, image, DEV_MODE_DISABLED),
 
67
          VERIFY_KERNEL_KEY_SIGNATURE_FAILED,
 
68
          "KernelImage Key Signature Tamper Verification (Trusted)");
 
69
}
 
70
 
 
71
int main(int argc, char* argv[]) {
 
72
  uint64_t len;
 
73
  const char* firmware_key_file = NULL;
 
74
  const char* kernel_key_file = NULL;
 
75
  uint8_t* kernel_sign_key_buf = NULL;
 
76
  uint8_t* firmware_key_blob = NULL;
 
77
  uint8_t* kernel_blob = NULL;
 
78
  uint64_t kernel_blob_len = 0;
 
79
  KernelImage* image = NULL;
 
80
  RSAPublicKey* firmware_key = NULL;
 
81
  int error_code = 0;
 
82
 
 
83
  if(argc != 7) {
 
84
    fprintf(stderr, "Usage: %s <firmware signing algorithm> "  /* argv[1] */
 
85
            "<kernel signing algorithm> "  /* argv[2] */
 
86
            "<firmware key> "  /* argv[3] */
 
87
            "<processed firmware pubkey> "  /* argv[4] */
 
88
            "<kernel signing key> "  /* argv[5] */
 
89
            "<processed kernel signing key>\n",  /* argv[6] */
 
90
            argv[0]);
 
91
    return -1;
 
92
  }
 
93
 
 
94
  /* Read verification keys and create a test image. */
 
95
  firmware_key = RSAPublicKeyFromFile(argv[4]);
 
96
  firmware_key_blob = BufferFromFile(argv[4], &len);
 
97
  kernel_sign_key_buf = BufferFromFile(argv[6], &len);
 
98
  firmware_key_file = argv[3];
 
99
  kernel_key_file = argv[5];
 
100
 
 
101
  if (!firmware_key || !kernel_sign_key_buf || !kernel_sign_key_buf) {
 
102
    error_code = 1;
 
103
    goto failure;
 
104
  }
 
105
 
 
106
  image = GenerateTestKernelImage(atoi(argv[1]),
 
107
                                  atoi(argv[2]),
 
108
                                  kernel_sign_key_buf,
 
109
                                  1,  /* Kernel Key Version */
 
110
                                  1,  /* Kernel Version */
 
111
                                  1000,  /* Kernel Size */
 
112
                                  firmware_key_file,
 
113
                                  kernel_key_file,
 
114
                                  'K');
 
115
  if (!image) {
 
116
    error_code = 1;
 
117
    goto failure;
 
118
  }
 
119
 
 
120
  kernel_blob = GetKernelBlob(image, &kernel_blob_len);
 
121
 
 
122
  /* Test Kernel blob verify operations. */
 
123
  VerifyKernelTest(kernel_blob, firmware_key_blob);
 
124
 
 
125
  /* Test KernelImage verify operations. */
 
126
  VerifyKernelImageTest(image, firmware_key);
 
127
  VerifyKernelImageTamperTest(image, firmware_key);
 
128
 
 
129
  if (!gTestSuccess)
 
130
    error_code = 255;
 
131
 
 
132
failure:
 
133
  Free(kernel_blob);
 
134
  KernelImageFree(image);
 
135
  Free(kernel_sign_key_buf);
 
136
  Free(firmware_key_blob);
 
137
  RSAPublicKeyFree(firmware_key);
 
138
 
 
139
  return error_code;
 
140
}