1 //
2 // Copyright (C) 2018 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "host_init_verifier.h"
18
19 #include <errno.h>
20 #include <getopt.h>
21 #include <pwd.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24
25 #include <fstream>
26 #include <iostream>
27 #include <iterator>
28 #include <string>
29 #include <vector>
30
31 #include <android-base/file.h>
32 #include <android-base/logging.h>
33 #include <android-base/parseint.h>
34 #include <android-base/strings.h>
35 #include <generated_android_ids.h>
36 #include <hidl/metadata.h>
37 #include <property_info_serializer/property_info_serializer.h>
38
39 #include "action.h"
40 #include "action_manager.h"
41 #include "action_parser.h"
42 #include "check_builtins.h"
43 #include "host_import_parser.h"
44 #include "host_init_stubs.h"
45 #include "interface_utils.h"
46 #include "parser.h"
47 #include "result.h"
48 #include "service.h"
49 #include "service_list.h"
50 #include "service_parser.h"
51
52 using namespace std::literals;
53
54 using android::base::ParseInt;
55 using android::base::ReadFileToString;
56 using android::base::Split;
57 using android::properties::BuildTrie;
58 using android::properties::ParsePropertyInfoFile;
59 using android::properties::PropertyInfoArea;
60 using android::properties::PropertyInfoEntry;
61
62 static std::vector<std::string> passwd_files;
63
GetVendorPasswd(const std::string & passwd_file)64 static std::vector<std::pair<std::string, int>> GetVendorPasswd(const std::string& passwd_file) {
65 std::string passwd;
66 if (!ReadFileToString(passwd_file, &passwd)) {
67 return {};
68 }
69
70 std::vector<std::pair<std::string, int>> result;
71 auto passwd_lines = Split(passwd, "\n");
72 for (const auto& line : passwd_lines) {
73 auto split_line = Split(line, ":");
74 if (split_line.size() < 3) {
75 continue;
76 }
77 int uid = 0;
78 if (!ParseInt(split_line[2], &uid)) {
79 continue;
80 }
81 result.emplace_back(split_line[0], uid);
82 }
83 return result;
84 }
85
GetVendorPasswd()86 static std::vector<std::pair<std::string, int>> GetVendorPasswd() {
87 std::vector<std::pair<std::string, int>> result;
88 for (const auto& passwd_file : passwd_files) {
89 auto individual_result = GetVendorPasswd(passwd_file);
90 std::move(individual_result.begin(), individual_result.end(),
91 std::back_insert_iterator(result));
92 }
93 return result;
94 }
95
getpwnam(const char * login)96 passwd* getpwnam(const char* login) { // NOLINT: implementing bad function.
97 // This isn't thread safe, but that's okay for our purposes.
98 static char static_name[32] = "";
99 static char static_dir[32] = "/";
100 static char static_shell[32] = "/system/bin/sh";
101 static passwd static_passwd = {
102 .pw_name = static_name,
103 .pw_dir = static_dir,
104 .pw_shell = static_shell,
105 .pw_uid = 0,
106 .pw_gid = 0,
107 };
108
109 for (size_t n = 0; n < android_id_count; ++n) {
110 if (!strcmp(android_ids[n].name, login)) {
111 snprintf(static_name, sizeof(static_name), "%s", android_ids[n].name);
112 static_passwd.pw_uid = android_ids[n].aid;
113 static_passwd.pw_gid = android_ids[n].aid;
114 return &static_passwd;
115 }
116 }
117
118 static const auto vendor_passwd = GetVendorPasswd();
119
120 for (const auto& [name, uid] : vendor_passwd) {
121 if (name == login) {
122 snprintf(static_name, sizeof(static_name), "%s", name.c_str());
123 static_passwd.pw_uid = uid;
124 static_passwd.pw_gid = uid;
125 return &static_passwd;
126 }
127 }
128
129 unsigned int oem_uid;
130 if (sscanf(login, "oem_%u", &oem_uid) == 1) {
131 snprintf(static_name, sizeof(static_name), "%s", login);
132 static_passwd.pw_uid = oem_uid;
133 static_passwd.pw_gid = oem_uid;
134 return &static_passwd;
135 }
136
137 errno = ENOENT;
138 return nullptr;
139 }
140
141 namespace android {
142 namespace init {
143
check_stub(const BuiltinArguments & args)144 static Result<void> check_stub(const BuiltinArguments& args) {
145 return {};
146 }
147
148 #include "generated_stub_builtin_function_map.h"
149
PrintUsage()150 void PrintUsage() {
151 std::cout << "usage: host_init_verifier [options] <init rc file>\n"
152 "\n"
153 "Tests an init script for correctness\n"
154 "\n"
155 "-p FILE\tSearch this passwd file for users and groups\n"
156 "--property_contexts=FILE\t Use this file for property_contexts\n"
157 << std::endl;
158 }
159
ReadInterfaceInheritanceHierarchy()160 Result<InterfaceInheritanceHierarchyMap> ReadInterfaceInheritanceHierarchy() {
161 InterfaceInheritanceHierarchyMap result;
162 for (const HidlInterfaceMetadata& iface : HidlInterfaceMetadata::all()) {
163 std::set<FQName> inherited_interfaces;
164 for (const std::string& intf : iface.inherited) {
165 FQName fqname;
166 if (!fqname.setTo(intf)) {
167 return Error() << "Unable to parse interface '" << intf << "'";
168 }
169 inherited_interfaces.insert(fqname);
170 }
171 FQName fqname;
172 if (!fqname.setTo(iface.name)) {
173 return Error() << "Unable to parse interface '" << iface.name << "'";
174 }
175 result[fqname] = inherited_interfaces;
176 }
177
178 return result;
179 }
180
181 const PropertyInfoArea* property_info_area;
182
HandlePropertyContexts(const std::string & filename,std::vector<PropertyInfoEntry> * property_infos)183 void HandlePropertyContexts(const std::string& filename,
184 std::vector<PropertyInfoEntry>* property_infos) {
185 auto file_contents = std::string();
186 if (!ReadFileToString(filename, &file_contents)) {
187 PLOG(ERROR) << "Could not read properties from '" << filename << "'";
188 exit(EXIT_FAILURE);
189 }
190
191 auto errors = std::vector<std::string>{};
192 ParsePropertyInfoFile(file_contents, true, property_infos, &errors);
193 for (const auto& error : errors) {
194 LOG(ERROR) << "Could not read line from '" << filename << "': " << error;
195 }
196 if (!errors.empty()) {
197 exit(EXIT_FAILURE);
198 }
199 }
200
main(int argc,char ** argv)201 int main(int argc, char** argv) {
202 android::base::InitLogging(argv, &android::base::StdioLogger);
203 android::base::SetMinimumLogSeverity(android::base::ERROR);
204
205 auto property_infos = std::vector<PropertyInfoEntry>();
206
207 while (true) {
208 static const char kPropertyContexts[] = "property-contexts=";
209 static const struct option long_options[] = {
210 {"help", no_argument, nullptr, 'h'},
211 {kPropertyContexts, required_argument, nullptr, 0},
212 {nullptr, 0, nullptr, 0},
213 };
214
215 int option_index;
216 int arg = getopt_long(argc, argv, "p:", long_options, &option_index);
217
218 if (arg == -1) {
219 break;
220 }
221
222 switch (arg) {
223 case 0:
224 if (long_options[option_index].name == kPropertyContexts) {
225 HandlePropertyContexts(optarg, &property_infos);
226 }
227 break;
228 case 'h':
229 PrintUsage();
230 return EXIT_FAILURE;
231 case 'p':
232 passwd_files.emplace_back(optarg);
233 break;
234 default:
235 std::cerr << "getprop: getopt returned invalid result: " << arg << std::endl;
236 return EXIT_FAILURE;
237 }
238 }
239
240 argc -= optind;
241 argv += optind;
242
243 if (argc != 1) {
244 PrintUsage();
245 return EXIT_FAILURE;
246 }
247
248 auto interface_inheritance_hierarchy_map = ReadInterfaceInheritanceHierarchy();
249 if (!interface_inheritance_hierarchy_map.ok()) {
250 LOG(ERROR) << interface_inheritance_hierarchy_map.error();
251 return EXIT_FAILURE;
252 }
253 SetKnownInterfaces(*interface_inheritance_hierarchy_map);
254
255 std::string serialized_contexts;
256 std::string trie_error;
257 if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
258 &trie_error)) {
259 LOG(ERROR) << "Unable to serialize property contexts: " << trie_error;
260 return EXIT_FAILURE;
261 }
262
263 property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
264
265 const BuiltinFunctionMap& function_map = GetBuiltinFunctionMap();
266 Action::set_function_map(&function_map);
267 ActionManager& am = ActionManager::GetInstance();
268 ServiceList& sl = ServiceList::GetInstance();
269 Parser parser;
270 parser.AddSectionParser("service", std::make_unique<ServiceParser>(
271 &sl, nullptr, *interface_inheritance_hierarchy_map));
272 parser.AddSectionParser("on", std::make_unique<ActionParser>(&am, nullptr));
273 parser.AddSectionParser("import", std::make_unique<HostImportParser>());
274
275 if (!parser.ParseConfigFileInsecure(*argv)) {
276 LOG(ERROR) << "Failed to open init rc script '" << *argv << "'";
277 return EXIT_FAILURE;
278 }
279 size_t failures = parser.parse_error_count() + am.CheckAllCommands() + sl.CheckAllCommands();
280 if (failures > 0) {
281 LOG(ERROR) << "Failed to parse init script '" << *argv << "' with " << failures
282 << " errors";
283 return EXIT_FAILURE;
284 }
285 return EXIT_SUCCESS;
286 }
287
288 } // namespace init
289 } // namespace android
290
main(int argc,char ** argv)291 int main(int argc, char** argv) {
292 return android::init::main(argc, argv);
293 }
294