1 /* 2 * Copyright (C) 2015 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 <stdlib.h> 18 #include <sys/socket.h> 19 #include <sys/stat.h> 20 #include <sys/types.h> 21 #include <netinet/in.h> 22 #include <arpa/inet.h> 23 #include <dirent.h> 24 #include <errno.h> 25 #include <fcntl.h> 26 #include <fs_mgr.h> 27 #include <stdio.h> 28 #include <string.h> 29 #include <stdint.h> 30 #include <inttypes.h> 31 32 #include <algorithm> 33 #include <thread> 34 35 #define LOG_TAG "VoldCryptCmdListener" 36 37 #include <android-base/logging.h> 38 #include <android-base/stringprintf.h> 39 40 #include <cutils/fs.h> 41 #include <cutils/log.h> 42 #include <cutils/sockets.h> 43 44 #include <sysutils/SocketClient.h> 45 #include <private/android_filesystem_config.h> 46 47 #include "CryptCommandListener.h" 48 #include "Process.h" 49 #include "ResponseCode.h" 50 #include "cryptfs.h" 51 #include "Ext4Crypt.h" 52 #include "Utils.h" 53 54 #define DUMP_ARGS 0 55 56 CryptCommandListener::CryptCommandListener() : 57 FrameworkListener("cryptd", true) { 58 registerCmd(new CryptfsCmd()); 59 } 60 61 #if DUMP_ARGS 62 void CryptCommandListener::dumpArgs(int argc, char **argv, int argObscure) { 63 char buffer[4096]; 64 char *p = buffer; 65 66 memset(buffer, 0, sizeof(buffer)); 67 int i; 68 for (i = 0; i < argc; i++) { 69 unsigned int len = strlen(argv[i]) + 1; // Account for space 70 if (i == argObscure) { 71 len += 2; // Account for {} 72 } 73 if (((p - buffer) + len) < (sizeof(buffer)-1)) { 74 if (i == argObscure) { 75 *p++ = '{'; 76 *p++ = '}'; 77 *p++ = ' '; 78 continue; 79 } 80 strcpy(p, argv[i]); 81 p+= strlen(argv[i]); 82 if (i != (argc -1)) { 83 *p++ = ' '; 84 } 85 } 86 } 87 SLOGD("%s", buffer); 88 } 89 #else 90 void CryptCommandListener::dumpArgs(int /*argc*/, char ** /*argv*/, int /*argObscure*/) { } 91 #endif 92 93 int CryptCommandListener::sendGenericOkFailOnBool(SocketClient *cli, bool success) { 94 if (success) { 95 return cli->sendMsg(ResponseCode::CommandOkay, "Command succeeded", false); 96 } else { 97 return cli->sendMsg(ResponseCode::OperationFailed, "Command failed", false); 98 } 99 } 100 101 CryptCommandListener::CryptfsCmd::CryptfsCmd() : 102 VoldCommand("cryptfs") { 103 } 104 105 static int getType(const char* type) 106 { 107 if (!strcmp(type, "default")) { 108 return CRYPT_TYPE_DEFAULT; 109 } else if (!strcmp(type, "password")) { 110 return CRYPT_TYPE_PASSWORD; 111 } else if (!strcmp(type, "pin")) { 112 return CRYPT_TYPE_PIN; 113 } else if (!strcmp(type, "pattern")) { 114 return CRYPT_TYPE_PATTERN; 115 } else { 116 return -1; 117 } 118 } 119 120 static char* parseNull(char* arg) { 121 if (strcmp(arg, "!") == 0) { 122 return nullptr; 123 } else { 124 return arg; 125 } 126 } 127 128 static bool check_argc(SocketClient *cli, const std::string &subcommand, int argc, 129 int expected, std::string usage) { 130 assert(expected >= 2); 131 if (expected == 2) { 132 assert(usage.empty()); 133 } else { 134 assert(!usage.empty()); 135 assert(std::count(usage.begin(), usage.end(), ' ') + 3 == expected); 136 } 137 if (argc == expected) { 138 return true; 139 } 140 auto message = std::string() + "Usage: cryptfs " + subcommand; 141 if (!usage.empty()) { 142 message += " " + usage; 143 } 144 cli->sendMsg(ResponseCode::CommandSyntaxError, message.c_str(), false); 145 return false; 146 } 147 148 static int do_enablecrypto(char* arg2, char* arg4, int type, bool no_ui) { 149 int rc; 150 int tries; 151 for (tries = 0; tries < 2; ++tries) { 152 if (type == CRYPT_TYPE_DEFAULT) { 153 rc = cryptfs_enable_default(arg2, no_ui); 154 } else { 155 rc = cryptfs_enable(arg2, type, arg4, no_ui); 156 } 157 158 if (rc == 0) { 159 free(arg2); 160 free(arg4); 161 return 0; 162 } else if (tries == 0) { 163 Process::killProcessesWithOpenFiles(DATA_MNT_POINT, SIGKILL); 164 } 165 } 166 167 free(arg2); 168 free(arg4); 169 return -1; 170 } 171 172 int CryptCommandListener::CryptfsCmd::runCommand(SocketClient *cli, 173 int argc, char **argv) { 174 if ((cli->getUid() != 0) && (cli->getUid() != AID_SYSTEM)) { 175 cli->sendMsg(ResponseCode::CommandNoPermission, "No permission to run cryptfs commands", false); 176 return 0; 177 } 178 179 if (argc < 2) { 180 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing subcommand", false); 181 return 0; 182 } 183 184 int rc = 0; 185 186 std::string subcommand(argv[1]); 187 if (subcommand == "checkpw") { 188 if (!check_argc(cli, subcommand, argc, 3, "<passwd>")) return 0; 189 dumpArgs(argc, argv, 2); 190 rc = cryptfs_check_passwd(argv[2]); 191 } else if (subcommand == "restart") { 192 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 193 dumpArgs(argc, argv, -1); 194 195 // Spawn as thread so init can issue commands back to vold without 196 // causing deadlock, usually as a result of prep_data_fs. 197 std::thread(&cryptfs_restart).detach(); 198 } else if (subcommand == "cryptocomplete") { 199 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 200 dumpArgs(argc, argv, -1); 201 rc = cryptfs_crypto_complete(); 202 } else if (subcommand == "enablecrypto") { 203 const char* syntax = "Usage: cryptfs enablecrypto <wipe|inplace> " 204 "default|password|pin|pattern [passwd] [noui]"; 205 206 // This should be replaced with a command line parser if more options 207 // are added 208 bool valid = true; 209 bool no_ui = false; 210 int type = CRYPT_TYPE_DEFAULT; 211 int options = 4; // Optional parameters are at this offset 212 if (argc < 4) { 213 // Minimum 4 parameters 214 valid = false; 215 } else if (strcmp(argv[2], "wipe") && strcmp(argv[2], "inplace") ) { 216 // Second parameter must be wipe or inplace 217 valid = false; 218 } else { 219 // Third parameter must be valid type 220 type = getType(argv[3]); 221 if (type == -1) { 222 valid = false; 223 } else if (type != CRYPT_TYPE_DEFAULT) { 224 options++; 225 } 226 } 227 228 if (valid) { 229 if(argc < options) { 230 // Too few parameters 231 valid = false; 232 } else if (argc == options) { 233 // No more, done 234 } else if (argc == options + 1) { 235 // One option, must be noui 236 if (!strcmp(argv[options], "noui")) { 237 no_ui = true; 238 } else { 239 valid = false; 240 } 241 } else { 242 // Too many options 243 valid = false; 244 } 245 } 246 247 if (!valid) { 248 cli->sendMsg(ResponseCode::CommandSyntaxError, syntax, false); 249 return 0; 250 } 251 252 dumpArgs(argc, argv, 4); 253 254 // Spawn as thread so init can issue commands back to vold without 255 // causing deadlock, usually as a result of prep_data_fs. 256 char* arg2 = argc > 2 ? strdup(argv[2]) : NULL; 257 char* arg4 = argc > 4 ? strdup(argv[4]) : NULL; 258 std::thread(&do_enablecrypto, arg2, arg4, type, no_ui).detach(); 259 } else if (subcommand == "enablefilecrypto") { 260 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 261 dumpArgs(argc, argv, -1); 262 rc = cryptfs_enable_file(); 263 } else if (subcommand == "changepw") { 264 const char* syntax = "Usage: cryptfs changepw " 265 "default|password|pin|pattern [newpasswd]"; 266 const char* password; 267 if (argc == 3) { 268 password = ""; 269 } else if (argc == 4) { 270 password = argv[3]; 271 } else { 272 cli->sendMsg(ResponseCode::CommandSyntaxError, syntax, false); 273 return 0; 274 } 275 int type = getType(argv[2]); 276 if (type == -1) { 277 cli->sendMsg(ResponseCode::CommandSyntaxError, syntax, false); 278 return 0; 279 } 280 SLOGD("cryptfs changepw %s {}", argv[2]); 281 rc = cryptfs_changepw(type, password); 282 } else if (subcommand == "verifypw") { 283 if (!check_argc(cli, subcommand, argc, 3, "<passwd>")) return 0; 284 SLOGD("cryptfs verifypw {}"); 285 rc = cryptfs_verify_passwd(argv[2]); 286 } else if (subcommand == "getfield") { 287 if (!check_argc(cli, subcommand, argc, 3, "<fieldname>")) return 0; 288 char *valbuf; 289 int valbuf_len = PROPERTY_VALUE_MAX; 290 291 dumpArgs(argc, argv, -1); 292 293 // Increase the buffer size until it is big enough for the field value stored. 294 while (1) { 295 valbuf = (char*)malloc(valbuf_len); 296 if (valbuf == NULL) { 297 cli->sendMsg(ResponseCode::OperationFailed, "Failed to allocate memory", false); 298 return 0; 299 } 300 rc = cryptfs_getfield(argv[2], valbuf, valbuf_len); 301 if (rc != CRYPTO_GETFIELD_ERROR_BUF_TOO_SMALL) { 302 break; 303 } 304 free(valbuf); 305 valbuf_len *= 2; 306 } 307 if (rc == CRYPTO_GETFIELD_OK) { 308 cli->sendMsg(ResponseCode::CryptfsGetfieldResult, valbuf, false); 309 } 310 free(valbuf); 311 } else if (subcommand == "setfield") { 312 if (!check_argc(cli, subcommand, argc, 4, "<fieldname> <value>")) return 0; 313 dumpArgs(argc, argv, -1); 314 rc = cryptfs_setfield(argv[2], argv[3]); 315 } else if (subcommand == "mountdefaultencrypted") { 316 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 317 SLOGD("cryptfs mountdefaultencrypted"); 318 dumpArgs(argc, argv, -1); 319 320 // Spawn as thread so init can issue commands back to vold without 321 // causing deadlock, usually as a result of prep_data_fs. 322 std::thread(&cryptfs_mount_default_encrypted).detach(); 323 } else if (subcommand == "getpwtype") { 324 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 325 SLOGD("cryptfs getpwtype"); 326 dumpArgs(argc, argv, -1); 327 switch(cryptfs_get_password_type()) { 328 case CRYPT_TYPE_PASSWORD: 329 cli->sendMsg(ResponseCode::PasswordTypeResult, "password", false); 330 return 0; 331 case CRYPT_TYPE_PATTERN: 332 cli->sendMsg(ResponseCode::PasswordTypeResult, "pattern", false); 333 return 0; 334 case CRYPT_TYPE_PIN: 335 cli->sendMsg(ResponseCode::PasswordTypeResult, "pin", false); 336 return 0; 337 case CRYPT_TYPE_DEFAULT: 338 cli->sendMsg(ResponseCode::PasswordTypeResult, "default", false); 339 return 0; 340 default: 341 /** @TODO better error and make sure handled by callers */ 342 cli->sendMsg(ResponseCode::OpFailedStorageNotFound, "Error", false); 343 return 0; 344 } 345 } else if (subcommand == "getpw") { 346 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 347 SLOGD("cryptfs getpw"); 348 dumpArgs(argc, argv, -1); 349 const char* password = cryptfs_get_password(); 350 if (password) { 351 char* message = 0; 352 int size = asprintf(&message, "{{sensitive}} %s", password); 353 if (size != -1) { 354 cli->sendMsg(ResponseCode::CommandOkay, message, false); 355 memset(message, 0, size); 356 free (message); 357 return 0; 358 } 359 } 360 rc = -1; 361 } else if (subcommand == "clearpw") { 362 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 363 SLOGD("cryptfs clearpw"); 364 dumpArgs(argc, argv, -1); 365 cryptfs_clear_password(); 366 rc = 0; 367 368 } else if (subcommand == "isConvertibleToFBE") { 369 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 370 // ext4enc:TODO: send a CommandSyntaxError if argv[2] not an integer 371 SLOGD("cryptfs isConvertibleToFBE"); 372 dumpArgs(argc, argv, -1); 373 rc = cryptfs_isConvertibleToFBE(); 374 375 } else if (subcommand == "init_user0") { 376 if (!check_argc(cli, subcommand, argc, 2, "")) return 0; 377 return sendGenericOkFailOnBool(cli, e4crypt_init_user0()); 378 379 } else if (subcommand == "create_user_key") { 380 if (!check_argc(cli, subcommand, argc, 5, "<user> <serial> <ephemeral>")) return 0; 381 return sendGenericOkFailOnBool(cli, e4crypt_vold_create_user_key( 382 atoi(argv[2]), atoi(argv[3]), atoi(argv[4]) != 0)); 383 384 } else if (subcommand == "destroy_user_key") { 385 if (!check_argc(cli, subcommand, argc, 3, "<user>")) return 0; 386 return sendGenericOkFailOnBool(cli, e4crypt_destroy_user_key(atoi(argv[2]))); 387 388 } else if (subcommand == "add_user_key_auth") { 389 if (!check_argc(cli, subcommand, argc, 6, "<user> <serial> <token> <secret>")) return 0; 390 return sendGenericOkFailOnBool(cli, e4crypt_add_user_key_auth( 391 atoi(argv[2]), atoi(argv[3]), argv[4], argv[5])); 392 393 } else if (subcommand == "fixate_newest_user_key_auth") { 394 if (!check_argc(cli, subcommand, argc, 3, "<user>")) return 0; 395 return sendGenericOkFailOnBool(cli, e4crypt_fixate_newest_user_key_auth(atoi(argv[2]))); 396 397 } else if (subcommand == "unlock_user_key") { 398 if (!check_argc(cli, subcommand, argc, 6, "<user> <serial> <token> <secret>")) return 0; 399 return sendGenericOkFailOnBool(cli, e4crypt_unlock_user_key( 400 atoi(argv[2]), atoi(argv[3]), argv[4], argv[5])); 401 402 } else if (subcommand == "lock_user_key") { 403 if (!check_argc(cli, subcommand, argc, 3, "<user>")) return 0; 404 return sendGenericOkFailOnBool(cli, e4crypt_lock_user_key(atoi(argv[2]))); 405 406 } else if (subcommand == "prepare_user_storage") { 407 if (!check_argc(cli, subcommand, argc, 6, "<uuid> <user> <serial> <flags>")) return 0; 408 return sendGenericOkFailOnBool(cli, e4crypt_prepare_user_storage( 409 parseNull(argv[2]), atoi(argv[3]), atoi(argv[4]), atoi(argv[5]))); 410 411 } else if (subcommand == "destroy_user_storage") { 412 if (!check_argc(cli, subcommand, argc, 5, "<uuid> <user> <flags>")) return 0; 413 return sendGenericOkFailOnBool(cli, 414 e4crypt_destroy_user_storage(parseNull(argv[2]), atoi(argv[3]), atoi(argv[4]))); 415 416 } else { 417 dumpArgs(argc, argv, -1); 418 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown cryptfs subcommand", false); 419 return 0; 420 } 421 422 // Always report that the command succeeded and return the error code. 423 // The caller will check the return value to see what the error was. 424 char msg[255]; 425 snprintf(msg, sizeof(msg), "%d", rc); 426 cli->sendMsg(ResponseCode::CommandOkay, msg, false); 427 428 return 0; 429 } 430
