1 /* Copyright 2015 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 * This utility wraps around "cgpt" execution to work with NAND. If the target
6 * device is an MTD device, this utility will read the GPT structures from
7 * FMAP, invokes "cgpt" on that, and writes the result back to NOR flash. */
8
9 #include <err.h>
10 #include <errno.h>
11 #include <fcntl.h>
12 #include <inttypes.h>
13 #include <limits.h>
14 #include <linux/major.h>
15 #include <stdbool.h>
16 #include <stdlib.h>
17 #include <stdint.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22 #include <unistd.h>
23
24 #include "cgpt.h"
25 #include "cgpt_nor.h"
26 #include "cryptolib.h"
27
28 // Check if cmdline |argv| has "-D". "-D" signifies that GPT structs are stored
29 // off device, and hence we should not wrap around cgpt.
has_dash_D(int argc,const char * const argv[])30 static bool has_dash_D(int argc, const char *const argv[]) {
31 int i;
32 // We go from 2, because the second arg is a cgpt command such as "create".
33 for (i = 2; i < argc; ++i) {
34 if (strcmp("-D", argv[i]) == 0) {
35 return true;
36 }
37 }
38 return false;
39 }
40
41 // Check if |device_path| is an MTD device based on its major number being 90.
is_mtd(const char * device_path)42 static bool is_mtd(const char *device_path) {
43 struct stat stat;
44 if (lstat(device_path, &stat) != 0) {
45 return false;
46 }
47
48 if (major(stat.st_rdev) != MTD_CHAR_MAJOR) {
49 return false;
50 }
51
52 return true;
53 }
54
55 // Return the element in |argv| that is an MTD device.
find_mtd_device(int argc,const char * const argv[])56 static const char *find_mtd_device(int argc, const char *const argv[]) {
57 int i;
58 for (i = 2; i < argc; ++i) {
59 if (is_mtd(argv[i])) {
60 return argv[i];
61 }
62 }
63 return NULL;
64 }
65
wrap_cgpt(int argc,const char * const argv[],const char * mtd_device)66 static int wrap_cgpt(int argc,
67 const char *const argv[],
68 const char *mtd_device) {
69 uint8_t *original_hash = NULL;
70 uint8_t *modified_hash = NULL;
71 int ret = 0;
72
73 // Create a temp dir to work in.
74 ret++;
75 char temp_dir[] = "/tmp/cgpt_wrapper.XXXXXX";
76 if (ReadNorFlash(temp_dir) != 0) {
77 return ret;
78 }
79 char rw_gpt_path[PATH_MAX];
80 if (snprintf(rw_gpt_path, sizeof(rw_gpt_path), "%s/rw_gpt", temp_dir) < 0) {
81 goto cleanup;
82 }
83 original_hash = DigestFile(rw_gpt_path, SHA1_DIGEST_ALGORITHM);
84
85 // Obtain the MTD size.
86 ret++;
87 uint64_t drive_size = 0;
88 if (GetMtdSize(mtd_device, &drive_size) != 0) {
89 Error("Cannot get the size of %s.\n", mtd_device);
90 goto cleanup;
91 }
92
93 // Launch cgpt on "rw_gpt" with -D size.
94 ret++;
95 const char** my_argv = calloc(argc + 2 + 1, sizeof(char *));
96 if (my_argv == NULL) {
97 errno = ENOMEM;
98 goto cleanup;
99 }
100 memcpy(my_argv, argv, sizeof(char *) * argc);
101 char *real_cgpt;
102 if (asprintf(&real_cgpt, "%s.bin", argv[0]) == -1) {
103 free(my_argv);
104 goto cleanup;
105 }
106 my_argv[0] = real_cgpt;
107
108 int i;
109 for (i = 2; i < argc; ++i) {
110 if (strcmp(my_argv[i], mtd_device) == 0) {
111 my_argv[i] = rw_gpt_path;
112 }
113 }
114 my_argv[argc] = "-D";
115 char size[32];
116 snprintf(size, sizeof(size), "%" PRIu64, drive_size);
117 my_argv[argc + 1] = size;
118 i = ForkExecV(NULL, my_argv);
119 free(real_cgpt);
120 free(my_argv);
121 if (i != 0) {
122 Error("Cannot exec cgpt to modify rw_gpt.\n");
123 goto cleanup;
124 }
125
126 // Write back "rw_gpt" to NOR flash in two chunks.
127 ret++;
128 modified_hash = DigestFile(rw_gpt_path, SHA1_DIGEST_ALGORITHM);
129 if (original_hash != NULL && modified_hash != NULL) {
130 if (memcmp(original_hash, modified_hash, SHA1_DIGEST_SIZE) != 0) {
131 ret = WriteNorFlash(temp_dir);
132 } else {
133 ret = 0;
134 }
135 }
136
137 cleanup:
138 free(original_hash);
139 free(modified_hash);
140 RemoveDir(temp_dir);
141 return ret;
142 }
143
main(int argc,const char * argv[])144 int main(int argc, const char *argv[]) {
145 char resolved_cgpt[PATH_MAX];
146 pid_t pid = getpid();
147 char exe_link[40];
148
149 if (argc < 1) {
150 return -1;
151 }
152
153 snprintf(exe_link, sizeof(exe_link), "/proc/%d/exe", pid);
154 memset(resolved_cgpt, 0, sizeof(resolved_cgpt));
155 if (readlink(exe_link, resolved_cgpt, sizeof(resolved_cgpt) - 1) == -1) {
156 perror("readlink");
157 return -1;
158 }
159
160 argv[0] = resolved_cgpt;
161
162 if (argc > 2 && !has_dash_D(argc, argv)) {
163 const char *mtd_device = find_mtd_device(argc, argv);
164 if (mtd_device) {
165 return wrap_cgpt(argc, argv, mtd_device);
166 }
167 }
168
169 // Forward to cgpt as-is. Real cgpt has been renamed cgpt.bin.
170 char *real_cgpt;
171 if (asprintf(&real_cgpt, "%s.bin", argv[0]) == -1) {
172 return -1;
173 }
174 argv[0] = real_cgpt;
175 if (execv(argv[0], (char * const *)argv) == -1) {
176 err(-2, "execv(%s) failed", real_cgpt);
177 }
178 return -2;
179 }
180