CryptCommandListener.cpp

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