OLD | NEW |
1 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved. | 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 | 2 * Use of this source code is governed by a BSD-style license that can be |
3 * found in the LICENSE file. | 3 * found in the LICENSE file. |
4 * | 4 * |
5 * Functions for generating and manipulating a verified boot kernel image. | 5 * Functions for generating and manipulating a verified boot kernel image. |
6 */ | 6 */ |
7 | 7 |
8 #include "kernel_image.h" | 8 #include "kernel_image.h" |
9 | 9 |
10 #include <fcntl.h> | 10 #include <fcntl.h> |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
49 | 49 |
50 KernelImage* ReadKernelImage(const char* input_file) { | 50 KernelImage* ReadKernelImage(const char* input_file) { |
51 uint64_t file_size; | 51 uint64_t file_size; |
52 int image_len = 0; /* Total size of the kernel image. */ | 52 int image_len = 0; /* Total size of the kernel image. */ |
53 int header_len = 0; | 53 int header_len = 0; |
54 int firmware_sign_key_len; | 54 int firmware_sign_key_len; |
55 int kernel_key_signature_len; | 55 int kernel_key_signature_len; |
56 int kernel_sign_key_len; | 56 int kernel_sign_key_len; |
57 int kernel_signature_len; | 57 int kernel_signature_len; |
58 uint8_t* kernel_buf; | 58 uint8_t* kernel_buf; |
| 59 uint8_t header_checksum[FIELD_LEN(header_checksum)]; |
59 MemcpyState st; | 60 MemcpyState st; |
60 KernelImage* image = KernelImageNew(); | 61 KernelImage* image = KernelImageNew(); |
61 | 62 |
62 if (!image) | 63 if (!image) |
63 return NULL; | 64 return NULL; |
64 | 65 |
65 kernel_buf = BufferFromFile(input_file, &file_size); | 66 kernel_buf = BufferFromFile(input_file, &file_size); |
66 image_len = file_size; | 67 image_len = file_size; |
67 | 68 |
68 st.remaining_len = image_len; | 69 st.remaining_len = image_len; |
(...skipping 26 matching lines...) Expand all Loading... |
95 return NULL; | 96 return NULL; |
96 } | 97 } |
97 | 98 |
98 /* Compute size of pre-processed RSA public keys and signatures. */ | 99 /* Compute size of pre-processed RSA public keys and signatures. */ |
99 firmware_sign_key_len = RSAProcessedKeySize(image->firmware_sign_algorithm); | 100 firmware_sign_key_len = RSAProcessedKeySize(image->firmware_sign_algorithm); |
100 kernel_key_signature_len = siglen_map[image->firmware_sign_algorithm]; | 101 kernel_key_signature_len = siglen_map[image->firmware_sign_algorithm]; |
101 kernel_sign_key_len = RSAProcessedKeySize(image->kernel_sign_algorithm); | 102 kernel_sign_key_len = RSAProcessedKeySize(image->kernel_sign_algorithm); |
102 kernel_signature_len = siglen_map[image->kernel_sign_algorithm]; | 103 kernel_signature_len = siglen_map[image->kernel_sign_algorithm]; |
103 | 104 |
104 /* Check whether key header length is correct. */ | 105 /* Check whether key header length is correct. */ |
105 header_len = (FIELD_LEN(header_version) + | 106 header_len = GetKernelHeaderLen(image); |
106 FIELD_LEN(header_len) + | |
107 FIELD_LEN(firmware_sign_algorithm) + | |
108 FIELD_LEN(kernel_sign_algorithm) + | |
109 FIELD_LEN(kernel_key_version) + | |
110 kernel_sign_key_len + | |
111 FIELD_LEN(header_checksum)); | |
112 | |
113 if (header_len != image->header_len) { | 107 if (header_len != image->header_len) { |
114 fprintf(stderr, "Header length mismatch. Got: %d, Expected: %d\n", | 108 fprintf(stderr, "Header length mismatch. Got: %d, Expected: %d\n", |
115 image->header_len, header_len); | 109 image->header_len, header_len); |
116 Free(kernel_buf); | 110 Free(kernel_buf); |
117 return NULL; | 111 return NULL; |
118 } | 112 } |
119 | 113 |
120 /* Read pre-processed public half of the kernel signing key. */ | 114 /* Read pre-processed public half of the kernel signing key. */ |
121 StatefulMemcpy(&st, &image->kernel_key_version, | 115 StatefulMemcpy(&st, &image->kernel_key_version, |
122 FIELD_LEN(kernel_key_version)); | 116 FIELD_LEN(kernel_key_version)); |
123 image->kernel_sign_key = (uint8_t*) Malloc(kernel_sign_key_len); | 117 image->kernel_sign_key = (uint8_t*) Malloc(kernel_sign_key_len); |
124 StatefulMemcpy(&st, image->kernel_sign_key, kernel_sign_key_len); | 118 StatefulMemcpy(&st, image->kernel_sign_key, kernel_sign_key_len); |
125 StatefulMemcpy(&st, image->header_checksum, FIELD_LEN(header_checksum)); | 119 StatefulMemcpy(&st, image->header_checksum, FIELD_LEN(header_checksum)); |
126 | 120 |
| 121 /* Check whether the header checksum matches. */ |
| 122 CalculateKernelHeaderChecksum(image, header_checksum); |
| 123 if (SafeMemcmp(header_checksum, image->header_checksum, |
| 124 FIELD_LEN(header_checksum))) { |
| 125 fprintf(stderr, "Invalid kernel header checksum!\n"); |
| 126 Free(kernel_buf); |
| 127 return NULL; |
| 128 } |
| 129 |
127 /* Read key signature. */ | 130 /* Read key signature. */ |
128 image->kernel_key_signature = (uint8_t*) Malloc(kernel_key_signature_len); | 131 image->kernel_key_signature = (uint8_t*) Malloc(kernel_key_signature_len); |
129 StatefulMemcpy(&st, image->kernel_key_signature, | 132 StatefulMemcpy(&st, image->kernel_key_signature, |
130 kernel_key_signature_len); | 133 kernel_key_signature_len); |
131 | 134 |
132 /* Read the kernel config. */ | 135 /* Read the kernel config. */ |
133 StatefulMemcpy(&st, &image->kernel_version, FIELD_LEN(kernel_version)); | 136 StatefulMemcpy(&st, &image->kernel_version, FIELD_LEN(kernel_version)); |
134 StatefulMemcpy(&st, &image->options.version, FIELD_LEN(options.version)); | 137 StatefulMemcpy(&st, &image->options.version, FIELD_LEN(options.version)); |
135 StatefulMemcpy(&st, &image->options.cmd_line, FIELD_LEN(options.cmd_line)); | 138 StatefulMemcpy(&st, &image->options.cmd_line, FIELD_LEN(options.cmd_line)); |
136 StatefulMemcpy(&st, &image->options.kernel_len, | 139 StatefulMemcpy(&st, &image->options.kernel_len, |
(...skipping 22 matching lines...) Expand all Loading... |
159 } | 162 } |
160 | 163 |
161 int GetKernelHeaderLen(const KernelImage* image) { | 164 int GetKernelHeaderLen(const KernelImage* image) { |
162 return (FIELD_LEN(header_version) + FIELD_LEN(header_len) + | 165 return (FIELD_LEN(header_version) + FIELD_LEN(header_len) + |
163 FIELD_LEN(firmware_sign_algorithm) + | 166 FIELD_LEN(firmware_sign_algorithm) + |
164 FIELD_LEN(kernel_sign_algorithm) + FIELD_LEN(kernel_key_version) + | 167 FIELD_LEN(kernel_sign_algorithm) + FIELD_LEN(kernel_key_version) + |
165 RSAProcessedKeySize(image->kernel_sign_algorithm) + | 168 RSAProcessedKeySize(image->kernel_sign_algorithm) + |
166 FIELD_LEN(header_checksum)); | 169 FIELD_LEN(header_checksum)); |
167 } | 170 } |
168 | 171 |
| 172 void CalculateKernelHeaderChecksum(const KernelImage* image, |
| 173 uint8_t* header_checksum) { |
| 174 uint8_t* checksum; |
| 175 DigestContext ctx; |
| 176 DigestInit(&ctx, SHA512_DIGEST_ALGORITHM); |
| 177 DigestUpdate(&ctx, (uint8_t*) &image->header_version, |
| 178 sizeof(image->header_version)); |
| 179 DigestUpdate(&ctx, (uint8_t*) &image->header_len, |
| 180 sizeof(image->header_len)); |
| 181 DigestUpdate(&ctx, (uint8_t*) &image->firmware_sign_algorithm, |
| 182 sizeof(image->firmware_sign_algorithm)); |
| 183 DigestUpdate(&ctx, (uint8_t*) &image->kernel_sign_algorithm, |
| 184 sizeof(image->kernel_sign_algorithm)); |
| 185 DigestUpdate(&ctx, (uint8_t*) &image->kernel_key_version, |
| 186 sizeof(image->kernel_key_version)); |
| 187 DigestUpdate(&ctx, image->kernel_sign_key, |
| 188 RSAProcessedKeySize(image->kernel_sign_algorithm)); |
| 189 checksum = DigestFinal(&ctx); |
| 190 Memcpy(header_checksum, checksum, FIELD_LEN(header_checksum)); |
| 191 Free(checksum); |
| 192 return; |
| 193 } |
| 194 |
169 uint8_t* GetKernelHeaderBlob(const KernelImage* image) { | 195 uint8_t* GetKernelHeaderBlob(const KernelImage* image) { |
170 uint8_t* header_blob = NULL; | 196 uint8_t* header_blob = NULL; |
171 MemcpyState st; | 197 MemcpyState st; |
172 | 198 |
173 header_blob = (uint8_t*) Malloc(GetKernelHeaderLen(image)); | 199 header_blob = (uint8_t*) Malloc(GetKernelHeaderLen(image)); |
174 st.remaining_len = GetKernelHeaderLen(image); | 200 st.remaining_len = GetKernelHeaderLen(image); |
175 st.remaining_buf = header_blob; | 201 st.remaining_buf = header_blob; |
176 | 202 |
177 StatefulMemcpy_r(&st, &image->header_version, FIELD_LEN(header_version)); | 203 StatefulMemcpy_r(&st, &image->header_version, FIELD_LEN(header_version)); |
178 StatefulMemcpy_r(&st, &image->header_len, FIELD_LEN(header_len)); | 204 StatefulMemcpy_r(&st, &image->header_len, FIELD_LEN(header_len)); |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
296 Free(kernel_blob); | 322 Free(kernel_blob); |
297 close(fd); | 323 close(fd); |
298 return 1; | 324 return 1; |
299 } | 325 } |
300 | 326 |
301 void PrintKernelImage(const KernelImage* image) { | 327 void PrintKernelImage(const KernelImage* image) { |
302 if (!image) | 328 if (!image) |
303 return; | 329 return; |
304 | 330 |
305 /* Print header. */ | 331 /* Print header. */ |
306 printf("Header Length = %d\n" | 332 printf("Header Version = %d\n" |
307 "Firmware Signing key algorithm id = %d\n" | 333 "Header Length = %d\n" |
308 "Kernel Signing key algorithm id = %d\n" | 334 "Kernel Key Signature Algorithm = %s\n" |
309 "Kernel Signature Algorithm = %s\n" | 335 "Kernel Signature Algorithm = %s\n" |
310 "Kernel Key Version = %d\n\n", | 336 "Kernel Key Version = %d\n\n", |
| 337 image->header_version, |
311 image->header_len, | 338 image->header_len, |
312 image->firmware_sign_algorithm, | 339 algo_strings[image->firmware_sign_algorithm], |
313 image->kernel_sign_algorithm, | |
314 algo_strings[image->kernel_sign_algorithm], | 340 algo_strings[image->kernel_sign_algorithm], |
315 image->kernel_key_version); | 341 image->kernel_key_version); |
316 /* TODO(gauravsh): Output hash and key signature here? */ | 342 /* TODO(gauravsh): Output hash and key signature here? */ |
317 /* Print preamble. */ | 343 /* Print preamble. */ |
318 printf("Kernel Version = %d\n" | 344 printf("Kernel Version = %d\n" |
319 "Kernel Config Version = %d.%d\n" | 345 "Kernel Config Version = %d.%d\n" |
320 "Kernel Config command line = %s\n" | 346 "Kernel Config command line = \"%s\"\n" |
321 "kernel Length = %" PRId64 "\n" | 347 "kernel Length = %" PRId64 "\n" |
322 "Kernel Load Address = %" PRId64 "\n" | 348 "Kernel Load Address = %" PRId64 "\n" |
323 "Kernel Entry Address = %" PRId64 "\n\n", | 349 "Kernel Entry Address = %" PRId64 "\n\n", |
324 image->kernel_version, | 350 image->kernel_version, |
325 image->options.version[0], image->options.version[1], | 351 image->options.version[0], image->options.version[1], |
326 image->options.cmd_line, | 352 image->options.cmd_line, |
327 image->options.kernel_len, | 353 image->options.kernel_len, |
328 image->options.kernel_load_addr, | 354 image->options.kernel_load_addr, |
329 image->options.kernel_entry_addr); | 355 image->options.kernel_entry_addr); |
330 /* TODO(gauravsh): Output kernel signature here? */ | 356 /* TODO(gauravsh): Output kernel signature here? */ |
(...skipping 346 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
677 kernel_signing_key_file, | 703 kernel_signing_key_file, |
678 image->kernel_sign_algorithm))) { | 704 image->kernel_sign_algorithm))) { |
679 fprintf(stderr, "Could not compute signature on the kernel.\n"); | 705 fprintf(stderr, "Could not compute signature on the kernel.\n"); |
680 return 0; | 706 return 0; |
681 } | 707 } |
682 image->kernel_signature = (uint8_t*) Malloc(signature_len); | 708 image->kernel_signature = (uint8_t*) Malloc(signature_len); |
683 Memcpy(image->kernel_signature, kernel_signature, signature_len); | 709 Memcpy(image->kernel_signature, kernel_signature, signature_len); |
684 Free(kernel_signature); | 710 Free(kernel_signature); |
685 return 1; | 711 return 1; |
686 } | 712 } |
OLD | NEW |