1 /*
2 * Copyright (C) 2017 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 /*
18 * Tool to create a directory with the right SELinux context applied, or
19 * apply the context if it's absent. Also fixes mode, uid, gid.
20 */
21
22 #include <iostream>
23 #include <string>
24 #include <vector>
25
26 #include <dirent.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31
32 #include <android-base/logging.h>
33 #include <android-base/scopeguard.h>
34
35 #include <cutils/fs.h>
36 #include <selinux/android.h>
37
38 #include "Utils.h"
39 #include "android/os/IVold.h"
40
41 #include <private/android_filesystem_config.h>
42
usage(const char * progname)43 static void usage(const char* progname) {
44 std::cerr << "Usage: " << progname << " [ prepare | destroy ] <volume_uuid> <user_id> <flags>"
45 << std::endl;
46 exit(-1);
47 }
48
small_int(const std::string & s)49 static bool small_int(const std::string& s) {
50 return !s.empty() && s.size() < 7 && s.find_first_not_of("0123456789") == std::string::npos;
51 }
52
valid_uuid(const std::string & s)53 static bool valid_uuid(const std::string& s) {
54 return s.size() < 40 && s.find_first_not_of("0123456789abcdefABCDEF-_") == std::string::npos;
55 }
56
prepare_dir_for_user(struct selabel_handle * sehandle,mode_t mode,uid_t uid,gid_t gid,const std::string & path,uid_t user_id)57 static bool prepare_dir_for_user(struct selabel_handle* sehandle, mode_t mode, uid_t uid, gid_t gid,
58 const std::string& path, uid_t user_id) {
59 auto clearfscreatecon = android::base::make_scope_guard([] { setfscreatecon(nullptr); });
60 auto secontext = std::unique_ptr<char, void (*)(char*)>(nullptr, freecon);
61 if (sehandle) {
62 char* tmp_secontext;
63
64 if (selabel_lookup(sehandle, &tmp_secontext, path.c_str(), S_IFDIR) == 0) {
65 secontext.reset(tmp_secontext);
66
67 if (user_id != (uid_t)-1) {
68 if (selinux_android_context_with_level(secontext.get(), &tmp_secontext, user_id,
69 (uid_t)-1) != 0) {
70 PLOG(ERROR) << "Unable to create context with level for: " << path;
71 return false;
72 }
73 secontext.reset(tmp_secontext); // Free the context
74 }
75 }
76 }
77
78 LOG(DEBUG) << "Setting up mode " << std::oct << mode << std::dec << " uid " << uid << " gid "
79 << gid << " context " << (secontext ? secontext.get() : "null")
80 << " on path: " << path;
81 if (secontext) {
82 if (setfscreatecon(secontext.get()) != 0) {
83 PLOG(ERROR) << "Unable to setfscreatecon for: " << path;
84 return false;
85 }
86 }
87 if (fs_prepare_dir(path.c_str(), mode, uid, gid) != 0) {
88 return false;
89 }
90 if (secontext) {
91 char* tmp_oldsecontext = nullptr;
92 if (lgetfilecon(path.c_str(), &tmp_oldsecontext) < 0) {
93 PLOG(ERROR) << "Unable to read secontext for: " << path;
94 return false;
95 }
96 auto oldsecontext = std::unique_ptr<char, void (*)(char*)>(tmp_oldsecontext, freecon);
97 if (strcmp(secontext.get(), oldsecontext.get()) != 0) {
98 LOG(INFO) << "Relabelling from " << ((char*)oldsecontext.get()) << " to "
99 << ((char*)secontext.get()) << ": " << path;
100 if (lsetfilecon(path.c_str(), secontext.get()) != 0) {
101 PLOG(ERROR) << "Relabelling failed for: " << path;
102 return false;
103 }
104 }
105 }
106 return true;
107 }
108
prepare_dir(struct selabel_handle * sehandle,mode_t mode,uid_t uid,gid_t gid,const std::string & path)109 static bool prepare_dir(struct selabel_handle* sehandle, mode_t mode, uid_t uid, gid_t gid,
110 const std::string& path) {
111 return prepare_dir_for_user(sehandle, mode, uid, gid, path, (uid_t)-1);
112 }
113
rmrf_contents(const std::string & path)114 static bool rmrf_contents(const std::string& path) {
115 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(path.c_str()), closedir);
116 if (!dirp) {
117 PLOG(ERROR) << "Unable to open directory: " << path;
118 return false;
119 }
120 bool res = true;
121 for (;;) {
122 errno = 0;
123 auto const entry = readdir(dirp.get());
124 if (!entry) {
125 if (errno) {
126 PLOG(ERROR) << "readdir failed on: " << path;
127 return false;
128 }
129 return res;
130 }
131 if (entry->d_name[0] == '.') continue;
132 auto subdir = path + "/" + entry->d_name;
133 if (0 !=
134 android::vold::ForkExecvp(std::vector<std::string>{"/system/bin/rm", "-rf", subdir})) {
135 LOG(ERROR) << "rm -rf failed on " << subdir;
136 res = false;
137 }
138 }
139 }
140
prepare_apex_subdirs(struct selabel_handle * sehandle,const std::string & path)141 static bool prepare_apex_subdirs(struct selabel_handle* sehandle, const std::string& path) {
142 if (!prepare_dir(sehandle, 0711, 0, 0, path + "/apexdata")) return false;
143
144 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir("/apex"), closedir);
145 if (!dirp) {
146 PLOG(ERROR) << "Unable to open apex directory";
147 return false;
148 }
149 struct dirent* entry;
150 while ((entry = readdir(dirp.get())) != nullptr) {
151 if (entry->d_type != DT_DIR) continue;
152
153 const char* name = entry->d_name;
154 // skip any starting with "."
155 if (name[0] == '.') continue;
156
157 if (strchr(name, '@') != NULL) continue;
158
159 if (!prepare_dir(sehandle, 0771, AID_ROOT, AID_SYSTEM, path + "/apexdata/" + name)) {
160 return false;
161 }
162 }
163 return true;
164 }
165
prepare_subdirs(const std::string & volume_uuid,int user_id,int flags)166 static bool prepare_subdirs(const std::string& volume_uuid, int user_id, int flags) {
167 struct selabel_handle* sehandle = selinux_android_file_context_handle();
168
169 if (flags & android::os::IVold::STORAGE_FLAG_DE) {
170 auto user_de_path = android::vold::BuildDataUserDePath(volume_uuid, user_id);
171 if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM, user_de_path, user_id)) {
172 return false;
173 }
174
175 auto misc_de_path = android::vold::BuildDataMiscDePath(volume_uuid, user_id);
176 if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM,
177 misc_de_path + "/sdksandbox", user_id)) {
178 return false;
179 }
180
181 if (volume_uuid.empty()) {
182 if (!prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/vold")) return false;
183 if (!prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/storaged")) return false;
184 if (!prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/rollback")) return false;
185 // TODO: Return false if this returns false once sure this should succeed.
186 prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/apexrollback");
187 prepare_apex_subdirs(sehandle, misc_de_path);
188
189 auto profiles_de_path = android::vold::BuildDataProfilesDePath(user_id);
190 if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM, profiles_de_path,
191 user_id)) {
192 return false;
193 }
194
195 auto vendor_de_path = android::vold::BuildDataVendorDePath(user_id);
196 if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, vendor_de_path + "/fpdata")) {
197 return false;
198 }
199 auto facedata_path = vendor_de_path + "/facedata";
200 if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, facedata_path)) {
201 return false;
202 }
203 }
204 }
205 if (flags & android::os::IVold::STORAGE_FLAG_CE) {
206 auto user_ce_path = android::vold::BuildDataUserCePath(volume_uuid, user_id);
207 if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM, user_ce_path, user_id)) {
208 return false;
209 }
210
211 auto misc_ce_path = android::vold::BuildDataMiscCePath(volume_uuid, user_id);
212 if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM,
213 misc_ce_path + "/sdksandbox", user_id)) {
214 return false;
215 }
216
217 if (volume_uuid.empty()) {
218 if (!prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/vold")) return false;
219 if (!prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/storaged")) return false;
220 if (!prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/rollback")) return false;
221 // TODO: Return false if this returns false once sure this should succeed.
222 prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/apexrollback");
223 prepare_apex_subdirs(sehandle, misc_ce_path);
224 // Give gmscore (who runs in cache group) access to the checkin directory. Also provide
225 // the user id to set the correct selinux mls_level.
226 if (!prepare_dir_for_user(sehandle, 0770, AID_SYSTEM, AID_CACHE,
227 misc_ce_path + "/checkin", user_id)) {
228 // TODO(b/203742483) the checkin directory was created with the wrong permission &
229 // context. Delete the directory to get these devices out of the bad state. Revert
230 // the change once the droidfood population is on newer build.
231 LOG(INFO) << "Failed to prepare the checkin directory, deleting for recreation";
232 android::vold::DeleteDirContentsAndDir(misc_ce_path + "/checkin");
233 if (!prepare_dir_for_user(sehandle, 0770, AID_SYSTEM, AID_CACHE,
234 misc_ce_path + "/checkin", user_id)) {
235 return false;
236 }
237 }
238
239 auto system_ce_path = android::vold::BuildDataSystemCePath(user_id);
240 if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, system_ce_path + "/backup")) {
241 return false;
242 }
243 if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM,
244 system_ce_path + "/backup_stage")) {
245 return false;
246 }
247 auto vendor_ce_path = android::vold::BuildDataVendorCePath(user_id);
248 auto facedata_path = vendor_ce_path + "/facedata";
249 if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, facedata_path)) {
250 return false;
251 }
252 }
253 }
254 return true;
255 }
256
destroy_subdirs(const std::string & volume_uuid,int user_id,int flags)257 static bool destroy_subdirs(const std::string& volume_uuid, int user_id, int flags) {
258 bool res = true;
259 if (flags & android::os::IVold::STORAGE_FLAG_CE) {
260 auto misc_ce_path = android::vold::BuildDataMiscCePath(volume_uuid, user_id);
261 res &= rmrf_contents(misc_ce_path);
262
263 if (volume_uuid.empty()) {
264 auto vendor_ce_path = android::vold::BuildDataVendorCePath(user_id);
265 res &= rmrf_contents(vendor_ce_path);
266 }
267 }
268 if (flags & android::os::IVold::STORAGE_FLAG_DE) {
269 auto misc_de_path = android::vold::BuildDataMiscDePath(volume_uuid, user_id);
270 res &= rmrf_contents(misc_de_path);
271
272 if (volume_uuid.empty()) {
273 auto vendor_de_path = android::vold::BuildDataVendorDePath(user_id);
274 res &= rmrf_contents(vendor_de_path);
275 }
276 }
277 return res;
278 }
279
main(int argc,const char * const argv[])280 int main(int argc, const char* const argv[]) {
281 android::base::InitLogging(const_cast<char**>(argv));
282 std::vector<std::string> args(argv + 1, argv + argc);
283
284 if (args.size() != 4 || !valid_uuid(args[1]) || !small_int(args[2]) || !small_int(args[3])) {
285 usage(argv[0]);
286 return -1;
287 }
288
289 auto volume_uuid = args[1];
290 int user_id = stoi(args[2]);
291 int flags = stoi(args[3]);
292 if (args[0] == "prepare") {
293 if (!prepare_subdirs(volume_uuid, user_id, flags)) return -1;
294 } else if (args[0] == "destroy") {
295 if (!destroy_subdirs(volume_uuid, user_id, flags)) return -1;
296 } else {
297 usage(argv[0]);
298 return -1;
299 }
300 return 0;
301 }
302