cryptfs.c

   1 /*
   2  * Copyright (C) 2010 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 /* TO DO:
  18  *   1.  Perhaps keep several copies of the encrypted key, in case something
  19  *       goes horribly wrong?
  20  *
  21  */
  22
  23 #include <sys/types.h>
  24 #include <sys/wait.h>
  25 #include <sys/stat.h>
  26 #include <ctype.h>
  27 #include <fcntl.h>
  28 #include <inttypes.h>
  29 #include <unistd.h>
  30 #include <stdio.h>
  31 #include <sys/ioctl.h>
  32 #include <linux/dm-ioctl.h>
  33 #include <libgen.h>
  34 #include <stdlib.h>
  35 #include <sys/param.h>
  36 #include <string.h>
  37 #include <sys/mount.h>
  38 #include <openssl/evp.h>
  39 #include <openssl/sha.h>
  40 #include <errno.h>
  41 #include <ext4_utils/ext4.h>
  42 #include <ext4_utils/ext4_utils.h>
  43 #include <linux/kdev_t.h>
  44 #include <fs_mgr.h>
  45 #include <time.h>
  46 #include <math.h>
  47 #include <selinux/selinux.h>
  48 #include "cryptfs.h"
  49 #include "secontext.h"
  50 #define LOG_TAG "Cryptfs"
  51 #include "cutils/log.h"
  52 #include "cutils/properties.h"
  53 #include "cutils/android_reboot.h"
  54 #include "hardware_legacy/power.h"
  55 #include <logwrap/logwrap.h>
  56 #include "ScryptParameters.h"
  57 #include "VolumeManager.h"
  58 #include "VoldUtil.h"
  59 #include "crypto_scrypt.h"
  60 #include "Ext4Crypt.h"
  61 #include "f2fs_sparseblock.h"
  62 #include "CheckBattery.h"
  63 #include "Process.h"
  64 #include "Keymaster.h"
  65
  66 #include <bootloader_message/bootloader_message.h>
  67
  68 #define UNUSED __attribute__((unused))
  69
  70 #define DM_CRYPT_BUF_SIZE 4096
  71
  72 #define HASH_COUNT 2000
  73 #define KEY_LEN_BYTES 16
  74 #define IV_LEN_BYTES 16
  75
  76 #define KEY_IN_FOOTER  "footer"
  77
  78 #define DEFAULT_PASSWORD "default_password"
  79
  80 #define CRYPTO_BLOCK_DEVICE "userdata"
  81
  82 #define BREADCRUMB_FILE "/data/misc/vold/convert_fde"
  83
  84 #define EXT4_FS 1
  85 #define F2FS_FS 2
  86
  87 #define TABLE_LOAD_RETRIES 10
  88
  89 #define RSA_KEY_SIZE 2048
  90 #define RSA_KEY_SIZE_BYTES (RSA_KEY_SIZE / 8)
  91 #define RSA_EXPONENT 0x10001
  92 #define KEYMASTER_CRYPTFS_RATE_LIMIT 1  // Maximum one try per second
  93
  94 #define RETRY_MOUNT_ATTEMPTS 10
  95 #define RETRY_MOUNT_DELAY_SECONDS 1
  96
  97 char *me = "cryptfs";
  98
  99 static unsigned char saved_master_key[KEY_LEN_BYTES];
 100 static char *saved_mount_point;
 101 static int  master_key_saved = 0;
 102 static struct crypt_persist_data *persist_data = NULL;
 103
 104 /* Should we use keymaster? */
 105 static int keymaster_check_compatibility()
 106 {
 107     return keymaster_compatibility_cryptfs_scrypt();
 108 }
 109
 110 /* Create a new keymaster key and store it in this footer */
 111 static int keymaster_create_key(struct crypt_mnt_ftr *ftr)
 112 {
 113     if (ftr->keymaster_blob_size) {
 114         SLOGI("Already have key");
 115         return 0;
 116     }
 117
 118     int rc = keymaster_create_key_for_cryptfs_scrypt(RSA_KEY_SIZE, RSA_EXPONENT,
 119             KEYMASTER_CRYPTFS_RATE_LIMIT, ftr->keymaster_blob, KEYMASTER_BLOB_SIZE,
 120             &ftr->keymaster_blob_size);
 121     if (rc) {
 122         if (ftr->keymaster_blob_size > KEYMASTER_BLOB_SIZE) {
 123             SLOGE("Keymaster key blob to large)");
 124             ftr->keymaster_blob_size = 0;
 125         }
 126         SLOGE("Failed to generate keypair");
 127         return -1;
 128     }
 129     return 0;
 130 }
 131
 132 /* This signs the given object using the keymaster key. */
 133 static int keymaster_sign_object(struct crypt_mnt_ftr *ftr,
 134                                  const unsigned char *object,
 135                                  const size_t object_size,
 136                                  unsigned char **signature,
 137                                  size_t *signature_size)
 138 {
 139     unsigned char to_sign[RSA_KEY_SIZE_BYTES];
 140     size_t to_sign_size = sizeof(to_sign);
 141     memset(to_sign, 0, RSA_KEY_SIZE_BYTES);
 142
 143     // To sign a message with RSA, the message must satisfy two
 144     // constraints:
 145     //
 146     // 1. The message, when interpreted as a big-endian numeric value, must
 147     //    be strictly less than the public modulus of the RSA key.  Note
 148     //    that because the most significant bit of the public modulus is
 149     //    guaranteed to be 1 (else it's an (n-1)-bit key, not an n-bit
 150     //    key), an n-bit message with most significant bit 0 always
 151     //    satisfies this requirement.
 152     //
 153     // 2. The message must have the same length in bits as the public
 154     //    modulus of the RSA key.  This requirement isn't mathematically
 155     //    necessary, but is necessary to ensure consistency in
 156     //    implementations.
 157     switch (ftr->kdf_type) {
 158         case KDF_SCRYPT_KEYMASTER:
 159             // This ensures the most significant byte of the signed message
 160             // is zero.  We could have zero-padded to the left instead, but
 161             // this approach is slightly more robust against changes in
 162             // object size.  However, it's still broken (but not unusably
 163             // so) because we really should be using a proper deterministic
 164             // RSA padding function, such as PKCS1.
 165             memcpy(to_sign + 1, object, min(RSA_KEY_SIZE_BYTES - 1, object_size));
 166             SLOGI("Signing safely-padded object");
 167             break;
 168         default:
 169             SLOGE("Unknown KDF type %d", ftr->kdf_type);
 170             return -1;
 171     }
 172     return keymaster_sign_object_for_cryptfs_scrypt(ftr->keymaster_blob, ftr->keymaster_blob_size,
 173             KEYMASTER_CRYPTFS_RATE_LIMIT, to_sign, to_sign_size, signature, signature_size);
 174 }
 175
 176 /* Store password when userdata is successfully decrypted and mounted.
 177  * Cleared by cryptfs_clear_password
 178  *
 179  * To avoid a double prompt at boot, we need to store the CryptKeeper
 180  * password and pass it to KeyGuard, which uses it to unlock KeyStore.
 181  * Since the entire framework is torn down and rebuilt after encryption,
 182  * we have to use a daemon or similar to store the password. Since vold
 183  * is secured against IPC except from system processes, it seems a reasonable
 184  * place to store this.
 185  *
 186  * password should be cleared once it has been used.
 187  *
 188  * password is aged out after password_max_age_seconds seconds.
 189  */
 190 static char* password = 0;
 191 static int password_expiry_time = 0;
 192 static const int password_max_age_seconds = 60;
 193
 194 extern struct fstab *fstab;
 195
 196 enum RebootType {reboot, recovery, shutdown};
 197 static void cryptfs_reboot(enum RebootType rt)
 198 {
 199   switch(rt) {
 200       case reboot:
 201           property_set(ANDROID_RB_PROPERTY, "reboot");
 202           break;
 203
 204       case recovery:
 205           property_set(ANDROID_RB_PROPERTY, "reboot,recovery");
 206           break;
 207
 208       case shutdown:
 209           property_set(ANDROID_RB_PROPERTY, "shutdown");
 210           break;
 211     }
 212
 213     sleep(20);
 214
 215     /* Shouldn't get here, reboot should happen before sleep times out */
 216     return;
 217 }
 218
 219 static void ioctl_init(struct dm_ioctl *io, size_t dataSize, const char *name, unsigned flags)
 220 {
 221     memset(io, 0, dataSize);
 222     io->data_size = dataSize;
 223     io->data_start = sizeof(struct dm_ioctl);
 224     io->version[0] = 4;
 225     io->version[1] = 0;
 226     io->version[2] = 0;
 227     io->flags = flags;
 228     if (name) {
 229         strlcpy(io->name, name, sizeof(io->name));
 230     }
 231 }
 232
 233 /**
 234  * Gets the default device scrypt parameters for key derivation time tuning.
 235  * The parameters should lead to about one second derivation time for the
 236  * given device.
 237  */
 238 static void get_device_scrypt_params(struct crypt_mnt_ftr *ftr) {
 239     char paramstr[PROPERTY_VALUE_MAX];
 240     int Nf, rf, pf;
 241
 242     property_get(SCRYPT_PROP, paramstr, SCRYPT_DEFAULTS);
 243     if (!parse_scrypt_parameters(paramstr, &Nf, &rf, &pf)) {
 244         SLOGW("bad scrypt parameters '%s' should be like '12:8:1'; using defaults", paramstr);
 245         parse_scrypt_parameters(SCRYPT_DEFAULTS, &Nf, &rf, &pf);
 246     }
 247     ftr->N_factor = Nf;
 248     ftr->r_factor = rf;
 249     ftr->p_factor = pf;
 250 }
 251
 252 static unsigned int get_fs_size(char *dev)
 253 {
 254     int fd, block_size;
 255     struct ext4_super_block sb;
 256     off64_t len;
 257
 258     if ((fd = open(dev, O_RDONLY|O_CLOEXEC)) < 0) {
 259         SLOGE("Cannot open device to get filesystem size ");
 260         return 0;
 261     }
 262
 263     if (lseek64(fd, 1024, SEEK_SET) < 0) {
 264         SLOGE("Cannot seek to superblock");
 265         return 0;
 266     }
 267
 268     if (read(fd, &sb, sizeof(sb)) != sizeof(sb)) {
 269         SLOGE("Cannot read superblock");
 270         return 0;
 271     }
 272
 273     close(fd);
 274
 275     if (le32_to_cpu(sb.s_magic) != EXT4_SUPER_MAGIC) {
 276         SLOGE("Not a valid ext4 superblock");
 277         return 0;
 278     }
 279     block_size = 1024 << sb.s_log_block_size;
 280     /* compute length in bytes */
 281     len = ( ((off64_t)sb.s_blocks_count_hi << 32) + sb.s_blocks_count_lo) * block_size;
 282
 283     /* return length in sectors */
 284     return (unsigned int) (len / 512);
 285 }
 286
 287 static int get_crypt_ftr_info(char **metadata_fname, off64_t *off)
 288 {
 289   static int cached_data = 0;
 290   static off64_t cached_off = 0;
 291   static char cached_metadata_fname[PROPERTY_VALUE_MAX] = "";
 292   int fd;
 293   char key_loc[PROPERTY_VALUE_MAX];
 294   char real_blkdev[PROPERTY_VALUE_MAX];
 295   int rc = -1;
 296
 297   if (!cached_data) {
 298     fs_mgr_get_crypt_info(fstab, key_loc, real_blkdev, sizeof(key_loc));
 299
 300     if (!strcmp(key_loc, KEY_IN_FOOTER)) {
 301       if ( (fd = open(real_blkdev, O_RDWR|O_CLOEXEC)) < 0) {
 302         SLOGE("Cannot open real block device %s\n", real_blkdev);
 303         return -1;
 304       }
 305
 306       unsigned long nr_sec = 0;
 307       get_blkdev_size(fd, &nr_sec);
 308       if (nr_sec != 0) {
 309         /* If it's an encrypted Android partition, the last 16 Kbytes contain the
 310          * encryption info footer and key, and plenty of bytes to spare for future
 311          * growth.
 312          */
 313         strlcpy(cached_metadata_fname, real_blkdev, sizeof(cached_metadata_fname));
 314         cached_off = ((off64_t)nr_sec * 512) - CRYPT_FOOTER_OFFSET;
 315         cached_data = 1;
 316       } else {
 317         SLOGE("Cannot get size of block device %s\n", real_blkdev);
 318       }
 319       close(fd);
 320     } else {
 321       strlcpy(cached_metadata_fname, key_loc, sizeof(cached_metadata_fname));
 322       cached_off = 0;
 323       cached_data = 1;
 324     }
 325   }
 326
 327   if (cached_data) {
 328     if (metadata_fname) {
 329         *metadata_fname = cached_metadata_fname;
 330     }
 331     if (off) {
 332         *off = cached_off;
 333     }
 334     rc = 0;
 335   }
 336
 337   return rc;
 338 }
 339
 340 /* Set sha256 checksum in structure */
 341 static void set_ftr_sha(struct crypt_mnt_ftr *crypt_ftr)
 342 {
 343     SHA256_CTX c;
 344     SHA256_Init(&c);
 345     memset(crypt_ftr->sha256, 0, sizeof(crypt_ftr->sha256));
 346     SHA256_Update(&c, crypt_ftr, sizeof(*crypt_ftr));
 347     SHA256_Final(crypt_ftr->sha256, &c);
 348 }
 349
 350 /* key or salt can be NULL, in which case just skip writing that value.  Useful to
 351  * update the failed mount count but not change the key.
 352  */
 353 static int put_crypt_ftr_and_key(struct crypt_mnt_ftr *crypt_ftr)
 354 {
 355   int fd;
 356   unsigned int cnt;
 357   /* starting_off is set to the SEEK_SET offset
 358    * where the crypto structure starts
 359    */
 360   off64_t starting_off;
 361   int rc = -1;
 362   char *fname = NULL;
 363   struct stat statbuf;
 364
 365   set_ftr_sha(crypt_ftr);
 366
 367   if (get_crypt_ftr_info(&fname, &starting_off)) {
 368     SLOGE("Unable to get crypt_ftr_info\n");
 369     return -1;
 370   }
 371   if (fname[0] != '/') {
 372     SLOGE("Unexpected value for crypto key location\n");
 373     return -1;
 374   }
 375   if ( (fd = open(fname, O_RDWR | O_CREAT|O_CLOEXEC, 0600)) < 0) {
 376     SLOGE("Cannot open footer file %s for put\n", fname);
 377     return -1;
 378   }
 379
 380   /* Seek to the start of the crypt footer */
 381   if (lseek64(fd, starting_off, SEEK_SET) == -1) {
 382     SLOGE("Cannot seek to real block device footer\n");
 383     goto errout;
 384   }
 385
 386   if ((cnt = write(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr))) != sizeof(struct crypt_mnt_ftr)) {
 387     SLOGE("Cannot write real block device footer\n");
 388     goto errout;
 389   }
 390
 391   fstat(fd, &statbuf);
 392   /* If the keys are kept on a raw block device, do not try to truncate it. */
 393   if (S_ISREG(statbuf.st_mode)) {
 394     if (ftruncate(fd, 0x4000)) {
 395       SLOGE("Cannot set footer file size\n");
 396       goto errout;
 397     }
 398   }
 399
 400   /* Success! */
 401   rc = 0;
 402
 403 errout:
 404   close(fd);
 405   return rc;
 406
 407 }
 408
 409 static bool check_ftr_sha(const struct crypt_mnt_ftr *crypt_ftr)
 410 {
 411     struct crypt_mnt_ftr copy;
 412     memcpy(&copy, crypt_ftr, sizeof(copy));
 413     set_ftr_sha(&copy);
 414     return memcmp(copy.sha256, crypt_ftr->sha256, sizeof(copy.sha256)) == 0;
 415 }
 416
 417 static inline int unix_read(int  fd, void*  buff, int  len)
 418 {
 419     return TEMP_FAILURE_RETRY(read(fd, buff, len));
 420 }
 421
 422 static inline int unix_write(int  fd, const void*  buff, int  len)
 423 {
 424     return TEMP_FAILURE_RETRY(write(fd, buff, len));
 425 }
 426
 427 static void init_empty_persist_data(struct crypt_persist_data *pdata, int len)
 428 {
 429     memset(pdata, 0, len);
 430     pdata->persist_magic = PERSIST_DATA_MAGIC;
 431     pdata->persist_valid_entries = 0;
 432 }
 433
 434 /* A routine to update the passed in crypt_ftr to the lastest version.
 435  * fd is open read/write on the device that holds the crypto footer and persistent
 436  * data, crypt_ftr is a pointer to the struct to be updated, and offset is the
 437  * absolute offset to the start of the crypt_mnt_ftr on the passed in fd.
 438  */
 439 static void upgrade_crypt_ftr(int fd, struct crypt_mnt_ftr *crypt_ftr, off64_t offset)
 440 {
 441     int orig_major = crypt_ftr->major_version;
 442     int orig_minor = crypt_ftr->minor_version;
 443
 444     if ((crypt_ftr->major_version == 1) && (crypt_ftr->minor_version == 0)) {
 445         struct crypt_persist_data *pdata;
 446         off64_t pdata_offset = offset + CRYPT_FOOTER_TO_PERSIST_OFFSET;
 447
 448         SLOGW("upgrading crypto footer to 1.1");
 449
 450         pdata = malloc(CRYPT_PERSIST_DATA_SIZE);
 451         if (pdata == NULL) {
 452             SLOGE("Cannot allocate persisent data\n");
 453             return;
 454         }
 455         memset(pdata, 0, CRYPT_PERSIST_DATA_SIZE);
 456
 457         /* Need to initialize the persistent data area */
 458         if (lseek64(fd, pdata_offset, SEEK_SET) == -1) {
 459             SLOGE("Cannot seek to persisent data offset\n");
 460             free(pdata);
 461             return;
 462         }
 463         /* Write all zeros to the first copy, making it invalid */
 464         unix_write(fd, pdata, CRYPT_PERSIST_DATA_SIZE);
 465
 466         /* Write a valid but empty structure to the second copy */
 467         init_empty_persist_data(pdata, CRYPT_PERSIST_DATA_SIZE);
 468         unix_write(fd, pdata, CRYPT_PERSIST_DATA_SIZE);
 469
 470         /* Update the footer */
 471         crypt_ftr->persist_data_size = CRYPT_PERSIST_DATA_SIZE;
 472         crypt_ftr->persist_data_offset[0] = pdata_offset;
 473         crypt_ftr->persist_data_offset[1] = pdata_offset + CRYPT_PERSIST_DATA_SIZE;
 474         crypt_ftr->minor_version = 1;
 475         free(pdata);
 476     }
 477
 478     if ((crypt_ftr->major_version == 1) && (crypt_ftr->minor_version == 1)) {
 479         SLOGW("upgrading crypto footer to 1.2");
 480         /* But keep the old kdf_type.
 481          * It will get updated later to KDF_SCRYPT after the password has been verified.
 482          */
 483         crypt_ftr->kdf_type = KDF_PBKDF2;
 484         get_device_scrypt_params(crypt_ftr);
 485         crypt_ftr->minor_version = 2;
 486     }
 487
 488     if ((crypt_ftr->major_version == 1) && (crypt_ftr->minor_version == 2)) {
 489         SLOGW("upgrading crypto footer to 1.3");
 490         crypt_ftr->crypt_type = CRYPT_TYPE_PASSWORD;
 491         crypt_ftr->minor_version = 3;
 492     }
 493
 494     if ((orig_major != crypt_ftr->major_version) || (orig_minor != crypt_ftr->minor_version)) {
 495         if (lseek64(fd, offset, SEEK_SET) == -1) {
 496             SLOGE("Cannot seek to crypt footer\n");
 497             return;
 498         }
 499         unix_write(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr));
 500     }
 501 }
 502
 503
 504 static int get_crypt_ftr_and_key(struct crypt_mnt_ftr *crypt_ftr)
 505 {
 506   int fd;
 507   unsigned int cnt;
 508   off64_t starting_off;
 509   int rc = -1;
 510   char *fname = NULL;
 511   struct stat statbuf;
 512
 513   if (get_crypt_ftr_info(&fname, &starting_off)) {
 514     SLOGE("Unable to get crypt_ftr_info\n");
 515     return -1;
 516   }
 517   if (fname[0] != '/') {
 518     SLOGE("Unexpected value for crypto key location\n");
 519     return -1;
 520   }
 521   if ( (fd = open(fname, O_RDWR|O_CLOEXEC)) < 0) {
 522     SLOGE("Cannot open footer file %s for get\n", fname);
 523     return -1;
 524   }
 525
 526   /* Make sure it's 16 Kbytes in length */
 527   fstat(fd, &statbuf);
 528   if (S_ISREG(statbuf.st_mode) && (statbuf.st_size != 0x4000)) {
 529     SLOGE("footer file %s is not the expected size!\n", fname);
 530     goto errout;
 531   }
 532
 533   /* Seek to the start of the crypt footer */
 534   if (lseek64(fd, starting_off, SEEK_SET) == -1) {
 535     SLOGE("Cannot seek to real block device footer\n");
 536     goto errout;
 537   }
 538
 539   if ( (cnt = read(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr))) != sizeof(struct crypt_mnt_ftr)) {
 540     SLOGE("Cannot read real block device footer\n");
 541     goto errout;
 542   }
 543
 544   if (crypt_ftr->magic != CRYPT_MNT_MAGIC) {
 545     SLOGE("Bad magic for real block device %s\n", fname);
 546     goto errout;
 547   }
 548
 549   if (crypt_ftr->major_version != CURRENT_MAJOR_VERSION) {
 550     SLOGE("Cannot understand major version %d real block device footer; expected %d\n",
 551           crypt_ftr->major_version, CURRENT_MAJOR_VERSION);
 552     goto errout;
 553   }
 554
 555   if (crypt_ftr->minor_version > CURRENT_MINOR_VERSION) {
 556     SLOGW("Warning: crypto footer minor version %d, expected <= %d, continuing...\n",
 557           crypt_ftr->minor_version, CURRENT_MINOR_VERSION);
 558   }
 559
 560   /* If this is a verion 1.0 crypt_ftr, make it a 1.1 crypt footer, and update the
 561    * copy on disk before returning.
 562    */
 563   if (crypt_ftr->minor_version < CURRENT_MINOR_VERSION) {
 564     upgrade_crypt_ftr(fd, crypt_ftr, starting_off);
 565   }
 566
 567   /* Success! */
 568   rc = 0;
 569
 570 errout:
 571   close(fd);
 572   return rc;
 573 }
 574
 575 static int validate_persistent_data_storage(struct crypt_mnt_ftr *crypt_ftr)
 576 {
 577     if (crypt_ftr->persist_data_offset[0] + crypt_ftr->persist_data_size >
 578         crypt_ftr->persist_data_offset[1]) {
 579         SLOGE("Crypt_ftr persist data regions overlap");
 580         return -1;
 581     }
 582
 583     if (crypt_ftr->persist_data_offset[0] >= crypt_ftr->persist_data_offset[1]) {
 584         SLOGE("Crypt_ftr persist data region 0 starts after region 1");
 585         return -1;
 586     }
 587
 588     if (((crypt_ftr->persist_data_offset[1] + crypt_ftr->persist_data_size) -
 589         (crypt_ftr->persist_data_offset[0] - CRYPT_FOOTER_TO_PERSIST_OFFSET)) >
 590         CRYPT_FOOTER_OFFSET) {
 591         SLOGE("Persistent data extends past crypto footer");
 592         return -1;
 593     }
 594
 595     return 0;
 596 }
 597
 598 static int load_persistent_data(void)
 599 {
 600     struct crypt_mnt_ftr crypt_ftr;
 601     struct crypt_persist_data *pdata = NULL;
 602     char encrypted_state[PROPERTY_VALUE_MAX];
 603     char *fname;
 604     int found = 0;
 605     int fd;
 606     int ret;
 607     int i;
 608
 609     if (persist_data) {
 610         /* Nothing to do, we've already loaded or initialized it */
 611         return 0;
 612     }
 613
 614
 615     /* If not encrypted, just allocate an empty table and initialize it */
 616     property_get("ro.crypto.state", encrypted_state, "");
 617     if (strcmp(encrypted_state, "encrypted") ) {
 618         pdata = malloc(CRYPT_PERSIST_DATA_SIZE);
 619         if (pdata) {
 620             init_empty_persist_data(pdata, CRYPT_PERSIST_DATA_SIZE);
 621             persist_data = pdata;
 622             return 0;
 623         }
 624         return -1;
 625     }
 626
 627     if(get_crypt_ftr_and_key(&crypt_ftr)) {
 628         return -1;
 629     }
 630
 631     if ((crypt_ftr.major_version < 1)
 632         || (crypt_ftr.major_version == 1 && crypt_ftr.minor_version < 1)) {
 633         SLOGE("Crypt_ftr version doesn't support persistent data");
 634         return -1;
 635     }
 636
 637     if (get_crypt_ftr_info(&fname, NULL)) {
 638         return -1;
 639     }
 640
 641     ret = validate_persistent_data_storage(&crypt_ftr);
 642     if (ret) {
 643         return -1;
 644     }
 645
 646     fd = open(fname, O_RDONLY|O_CLOEXEC);
 647     if (fd < 0) {
 648         SLOGE("Cannot open %s metadata file", fname);
 649         return -1;
 650     }
 651
 652     pdata = malloc(crypt_ftr.persist_data_size);
 653     if (pdata == NULL) {
 654         SLOGE("Cannot allocate memory for persistent data");
 655         goto err;
 656     }
 657
 658     for (i = 0; i < 2; i++) {
 659         if (lseek64(fd, crypt_ftr.persist_data_offset[i], SEEK_SET) < 0) {
 660             SLOGE("Cannot seek to read persistent data on %s", fname);
 661             goto err2;
 662         }
 663         if (unix_read(fd, pdata, crypt_ftr.persist_data_size) < 0){
 664             SLOGE("Error reading persistent data on iteration %d", i);
 665             goto err2;
 666         }
 667         if (pdata->persist_magic == PERSIST_DATA_MAGIC) {
 668             found = 1;
 669             break;
 670         }
 671     }
 672
 673     if (!found) {
 674         SLOGI("Could not find valid persistent data, creating");
 675         init_empty_persist_data(pdata, crypt_ftr.persist_data_size);
 676     }
 677
 678     /* Success */
 679     persist_data = pdata;
 680     close(fd);
 681     return 0;
 682
 683 err2:
 684     free(pdata);
 685
 686 err:
 687     close(fd);
 688     return -1;
 689 }
 690
 691 static int save_persistent_data(void)
 692 {
 693     struct crypt_mnt_ftr crypt_ftr;
 694     struct crypt_persist_data *pdata;
 695     char *fname;
 696     off64_t write_offset;
 697     off64_t erase_offset;
 698     int fd;
 699     int ret;
 700
 701     if (persist_data == NULL) {
 702         SLOGE("No persistent data to save");
 703         return -1;
 704     }
 705
 706     if(get_crypt_ftr_and_key(&crypt_ftr)) {
 707         return -1;
 708     }
 709
 710     if ((crypt_ftr.major_version < 1)
 711         || (crypt_ftr.major_version == 1 && crypt_ftr.minor_version < 1)) {
 712         SLOGE("Crypt_ftr version doesn't support persistent data");
 713         return -1;
 714     }
 715
 716     ret = validate_persistent_data_storage(&crypt_ftr);
 717     if (ret) {
 718         return -1;
 719     }
 720
 721     if (get_crypt_ftr_info(&fname, NULL)) {
 722         return -1;
 723     }
 724
 725     fd = open(fname, O_RDWR|O_CLOEXEC);
 726     if (fd < 0) {
 727         SLOGE("Cannot open %s metadata file", fname);
 728         return -1;
 729     }
 730
 731     pdata = malloc(crypt_ftr.persist_data_size);
 732     if (pdata == NULL) {
 733         SLOGE("Cannot allocate persistant data");
 734         goto err;
 735     }
 736
 737     if (lseek64(fd, crypt_ftr.persist_data_offset[0], SEEK_SET) < 0) {
 738         SLOGE("Cannot seek to read persistent data on %s", fname);
 739         goto err2;
 740     }
 741
 742     if (unix_read(fd, pdata, crypt_ftr.persist_data_size) < 0) {
 743             SLOGE("Error reading persistent data before save");
 744             goto err2;
 745     }
 746
 747     if (pdata->persist_magic == PERSIST_DATA_MAGIC) {
 748         /* The first copy is the curent valid copy, so write to
 749          * the second copy and erase this one */
 750        write_offset = crypt_ftr.persist_data_offset[1];
 751        erase_offset = crypt_ftr.persist_data_offset[0];
 752     } else {
 753         /* The second copy must be the valid copy, so write to
 754          * the first copy, and erase the second */
 755        write_offset = crypt_ftr.persist_data_offset[0];
 756        erase_offset = crypt_ftr.persist_data_offset[1];
 757     }
 758
 759     /* Write the new copy first, if successful, then erase the old copy */
 760     if (lseek64(fd, write_offset, SEEK_SET) < 0) {
 761         SLOGE("Cannot seek to write persistent data");
 762         goto err2;
 763     }
 764     if (unix_write(fd, persist_data, crypt_ftr.persist_data_size) ==
 765         (int) crypt_ftr.persist_data_size) {
 766         if (lseek64(fd, erase_offset, SEEK_SET) < 0) {
 767             SLOGE("Cannot seek to erase previous persistent data");
 768             goto err2;
 769         }
 770         fsync(fd);
 771         memset(pdata, 0, crypt_ftr.persist_data_size);
 772         if (unix_write(fd, pdata, crypt_ftr.persist_data_size) !=
 773             (int) crypt_ftr.persist_data_size) {
 774             SLOGE("Cannot write to erase previous persistent data");
 775             goto err2;
 776         }
 777         fsync(fd);
 778     } else {
 779         SLOGE("Cannot write to save persistent data");
 780         goto err2;
 781     }
 782
 783     /* Success */
 784     free(pdata);
 785     close(fd);
 786     return 0;
 787
 788 err2:
 789     free(pdata);
 790 err:
 791     close(fd);
 792     return -1;
 793 }
 794
 795 /* Convert a binary key of specified length into an ascii hex string equivalent,
 796  * without the leading 0x and with null termination
 797  */
 798 static void convert_key_to_hex_ascii(const unsigned char *master_key,
 799                                      unsigned int keysize, char *master_key_ascii) {
 800     unsigned int i, a;
 801     unsigned char nibble;
 802
 803     for (i=0, a=0; i<keysize; i++, a+=2) {
 804         /* For each byte, write out two ascii hex digits */
 805         nibble = (master_key[i] >> 4) & 0xf;
 806         master_key_ascii[a] = nibble + (nibble > 9 ? 0x37 : 0x30);
 807
 808         nibble = master_key[i] & 0xf;
 809         master_key_ascii[a+1] = nibble + (nibble > 9 ? 0x37 : 0x30);
 810     }
 811
 812     /* Add the null termination */
 813     master_key_ascii[a] = '\0';
 814
 815 }
 816
 817 static int load_crypto_mapping_table(struct crypt_mnt_ftr *crypt_ftr,
 818         const unsigned char *master_key, const char *real_blk_name,
 819         const char *name, int fd, const char *extra_params) {
 820   _Alignas(struct dm_ioctl) char buffer[DM_CRYPT_BUF_SIZE];
 821   struct dm_ioctl *io;
 822   struct dm_target_spec *tgt;
 823   char *crypt_params;
 824   char master_key_ascii[129]; /* Large enough to hold 512 bit key and null */
 825   size_t buff_offset;
 826   int i;
 827
 828   io = (struct dm_ioctl *) buffer;
 829
 830   /* Load the mapping table for this device */
 831   tgt = (struct dm_target_spec *) &buffer[sizeof(struct dm_ioctl)];
 832
 833   ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
 834   io->target_count = 1;
 835   tgt->status = 0;
 836   tgt->sector_start = 0;
 837   tgt->length = crypt_ftr->fs_size;
 838   strlcpy(tgt->target_type, "crypt", DM_MAX_TYPE_NAME);
 839
 840   crypt_params = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
 841   convert_key_to_hex_ascii(master_key, crypt_ftr->keysize, master_key_ascii);
 842
 843   buff_offset = crypt_params - buffer;
 844   snprintf(crypt_params, sizeof(buffer) - buff_offset, "%s %s 0 %s 0 %s",
 845            crypt_ftr->crypto_type_name, master_key_ascii, real_blk_name,
 846            extra_params);
 847   crypt_params += strlen(crypt_params) + 1;
 848   crypt_params = (char *) (((unsigned long)crypt_params + 7) & ~8); /* Align to an 8 byte boundary */
 849   tgt->next = crypt_params - buffer;
 850
 851   for (i = 0; i < TABLE_LOAD_RETRIES; i++) {
 852     if (! ioctl(fd, DM_TABLE_LOAD, io)) {
 853       break;
 854     }
 855     usleep(500000);
 856   }
 857
 858   if (i == TABLE_LOAD_RETRIES) {
 859     /* We failed to load the table, return an error */
 860     return -1;
 861   } else {
 862     return i + 1;
 863   }
 864 }
 865
 866
 867 static int get_dm_crypt_version(int fd, const char *name,  int *version)
 868 {
 869     char buffer[DM_CRYPT_BUF_SIZE];
 870     struct dm_ioctl *io;
 871     struct dm_target_versions *v;
 872
 873     io = (struct dm_ioctl *) buffer;
 874
 875     ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
 876
 877     if (ioctl(fd, DM_LIST_VERSIONS, io)) {
 878         return -1;
 879     }
 880
 881     /* Iterate over the returned versions, looking for name of "crypt".
 882      * When found, get and return the version.
 883      */
 884     v = (struct dm_target_versions *) &buffer[sizeof(struct dm_ioctl)];
 885     while (v->next) {
 886         if (! strcmp(v->name, "crypt")) {
 887             /* We found the crypt driver, return the version, and get out */
 888             version[0] = v->version[0];
 889             version[1] = v->version[1];
 890             version[2] = v->version[2];
 891             return 0;
 892         }
 893         v = (struct dm_target_versions *)(((char *)v) + v->next);
 894     }
 895
 896     return -1;
 897 }
 898
 899 static int create_crypto_blk_dev(struct crypt_mnt_ftr *crypt_ftr,
 900         const unsigned char *master_key, const char *real_blk_name,
 901         char *crypto_blk_name, const char *name) {
 902   char buffer[DM_CRYPT_BUF_SIZE];
 903   struct dm_ioctl *io;
 904   unsigned int minor;
 905   int fd=0;
 906   int err;
 907   int retval = -1;
 908   int version[3];
 909   char *extra_params;
 910   int load_count;
 911
 912   if ((fd = open("/dev/device-mapper", O_RDWR|O_CLOEXEC)) < 0 ) {
 913     SLOGE("Cannot open device-mapper\n");
 914     goto errout;
 915   }
 916
 917   io = (struct dm_ioctl *) buffer;
 918
 919   ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
 920   err = ioctl(fd, DM_DEV_CREATE, io);
 921   if (err) {
 922     SLOGE("Cannot create dm-crypt device %s: %s\n", name, strerror(errno));
 923     goto errout;
 924   }
 925
 926   /* Get the device status, in particular, the name of it's device file */
 927   ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
 928   if (ioctl(fd, DM_DEV_STATUS, io)) {
 929     SLOGE("Cannot retrieve dm-crypt device status\n");
 930     goto errout;
 931   }
 932   minor = (io->dev & 0xff) | ((io->dev >> 12) & 0xfff00);
 933   snprintf(crypto_blk_name, MAXPATHLEN, "/dev/block/dm-%u", minor);
 934
 935   extra_params = "";
 936   if (! get_dm_crypt_version(fd, name, version)) {
 937       /* Support for allow_discards was added in version 1.11.0 */
 938       if ((version[0] >= 2) ||
 939           ((version[0] == 1) && (version[1] >= 11))) {
 940           extra_params = "1 allow_discards";
 941           SLOGI("Enabling support for allow_discards in dmcrypt.\n");
 942       }
 943   }
 944
 945   load_count = load_crypto_mapping_table(crypt_ftr, master_key, real_blk_name, name,
 946                                          fd, extra_params);
 947   if (load_count < 0) {
 948       SLOGE("Cannot load dm-crypt mapping table.\n");
 949       goto errout;
 950   } else if (load_count > 1) {
 951       SLOGI("Took %d tries to load dmcrypt table.\n", load_count);
 952   }
 953
 954   /* Resume this device to activate it */
 955   ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
 956
 957   if (ioctl(fd, DM_DEV_SUSPEND, io)) {
 958     SLOGE("Cannot resume the dm-crypt device\n");
 959     goto errout;
 960   }
 961
 962   /* We made it here with no errors.  Woot! */
 963   retval = 0;
 964
 965 errout:
 966   close(fd);   /* If fd is <0 from a failed open call, it's safe to just ignore the close error */
 967
 968   return retval;
 969 }
 970
 971 static int delete_crypto_blk_dev(char *name)
 972 {
 973   int fd;
 974   char buffer[DM_CRYPT_BUF_SIZE];
 975   struct dm_ioctl *io;
 976   int retval = -1;
 977
 978   if ((fd = open("/dev/device-mapper", O_RDWR|O_CLOEXEC)) < 0 ) {
 979     SLOGE("Cannot open device-mapper\n");
 980     goto errout;
 981   }
 982
 983   io = (struct dm_ioctl *) buffer;
 984
 985   ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
 986   if (ioctl(fd, DM_DEV_REMOVE, io)) {
 987     SLOGE("Cannot remove dm-crypt device\n");
 988     goto errout;
 989   }
 990
 991   /* We made it here with no errors.  Woot! */
 992   retval = 0;
 993
 994 errout:
 995   close(fd);    /* If fd is <0 from a failed open call, it's safe to just ignore the close error */
 996
 997   return retval;
 998
 999 }
1000
1001 static int pbkdf2(const char *passwd, const unsigned char *salt,
1002                   unsigned char *ikey, void *params UNUSED)
1003 {
1004     SLOGI("Using pbkdf2 for cryptfs KDF");
1005
1006     /* Turn the password into a key and IV that can decrypt the master key */
1007     return PKCS5_PBKDF2_HMAC_SHA1(passwd, strlen(passwd), salt, SALT_LEN,
1008                                   HASH_COUNT, KEY_LEN_BYTES + IV_LEN_BYTES,
1009                                   ikey) != 1;
1010 }
1011
1012 static int scrypt(const char *passwd, const unsigned char *salt,
1013                   unsigned char *ikey, void *params)
1014 {
1015     SLOGI("Using scrypt for cryptfs KDF");
1016
1017     struct crypt_mnt_ftr *ftr = (struct crypt_mnt_ftr *) params;
1018
1019     int N = 1 << ftr->N_factor;
1020     int r = 1 << ftr->r_factor;
1021     int p = 1 << ftr->p_factor;
1022
1023     /* Turn the password into a key and IV that can decrypt the master key */
1024     unsigned int keysize;
1025     crypto_scrypt((const uint8_t*)passwd, strlen(passwd),
1026                   salt, SALT_LEN, N, r, p, ikey,
1027                   KEY_LEN_BYTES + IV_LEN_BYTES);
1028
1029    return 0;
1030 }
1031
1032 static int scrypt_keymaster(const char *passwd, const unsigned char *salt,
1033                             unsigned char *ikey, void *params)
1034 {
1035     SLOGI("Using scrypt with keymaster for cryptfs KDF");
1036
1037     int rc;
1038     size_t signature_size;
1039     unsigned char* signature;
1040     struct crypt_mnt_ftr *ftr = (struct crypt_mnt_ftr *) params;
1041
1042     int N = 1 << ftr->N_factor;
1043     int r = 1 << ftr->r_factor;
1044     int p = 1 << ftr->p_factor;
1045
1046     rc = crypto_scrypt((const uint8_t*)passwd, strlen(passwd),
1047                        salt, SALT_LEN, N, r, p, ikey,
1048                        KEY_LEN_BYTES + IV_LEN_BYTES);
1049
1050     if (rc) {
1051         SLOGE("scrypt failed");
1052         return -1;
1053     }
1054
1055     if (keymaster_sign_object(ftr, ikey, KEY_LEN_BYTES + IV_LEN_BYTES,
1056                               &signature, &signature_size)) {
1057         SLOGE("Signing failed");
1058         return -1;
1059     }
1060
1061     rc = crypto_scrypt(signature, signature_size, salt, SALT_LEN,
1062                        N, r, p, ikey, KEY_LEN_BYTES + IV_LEN_BYTES);
1063     free(signature);
1064
1065     if (rc) {
1066         SLOGE("scrypt failed");
1067         return -1;
1068     }
1069
1070     return 0;
1071 }
1072
1073 static int encrypt_master_key(const char *passwd, const unsigned char *salt,
1074                               const unsigned char *decrypted_master_key,
1075                               unsigned char *encrypted_master_key,
1076                               struct crypt_mnt_ftr *crypt_ftr)
1077 {
1078     unsigned char ikey[32+32] = { 0 }; /* Big enough to hold a 256 bit key and 256 bit IV */
1079     EVP_CIPHER_CTX e_ctx;
1080     int encrypted_len, final_len;
1081     int rc = 0;
1082
1083     /* Turn the password into an intermediate key and IV that can decrypt the master key */
1084     get_device_scrypt_params(crypt_ftr);
1085
1086     switch (crypt_ftr->kdf_type) {
1087     case KDF_SCRYPT_KEYMASTER:
1088         if (keymaster_create_key(crypt_ftr)) {
1089             SLOGE("keymaster_create_key failed");
1090             return -1;
1091         }
1092
1093         if (scrypt_keymaster(passwd, salt, ikey, crypt_ftr)) {
1094             SLOGE("scrypt failed");
1095             return -1;
1096         }
1097         break;
1098
1099     case KDF_SCRYPT:
1100         if (scrypt(passwd, salt, ikey, crypt_ftr)) {
1101             SLOGE("scrypt failed");
1102             return -1;
1103         }
1104         break;
1105
1106     default:
1107         SLOGE("Invalid kdf_type");
1108         return -1;
1109     }
1110
1111     /* Initialize the decryption engine */
1112     EVP_CIPHER_CTX_init(&e_ctx);
1113     if (! EVP_EncryptInit_ex(&e_ctx, EVP_aes_128_cbc(), NULL, ikey, ikey+KEY_LEN_BYTES)) {
1114         SLOGE("EVP_EncryptInit failed\n");
1115         return -1;
1116     }
1117     EVP_CIPHER_CTX_set_padding(&e_ctx, 0); /* Turn off padding as our data is block aligned */
1118
1119     /* Encrypt the master key */
1120     if (! EVP_EncryptUpdate(&e_ctx, encrypted_master_key, &encrypted_len,
1121                             decrypted_master_key, KEY_LEN_BYTES)) {
1122         SLOGE("EVP_EncryptUpdate failed\n");
1123         return -1;
1124     }
1125     if (! EVP_EncryptFinal_ex(&e_ctx, encrypted_master_key + encrypted_len, &final_len)) {
1126         SLOGE("EVP_EncryptFinal failed\n");
1127         return -1;
1128     }
1129
1130     if (encrypted_len + final_len != KEY_LEN_BYTES) {
1131         SLOGE("EVP_Encryption length check failed with %d, %d bytes\n", encrypted_len, final_len);
1132         return -1;
1133     }
1134
1135     /* Store the scrypt of the intermediate key, so we can validate if it's a
1136        password error or mount error when things go wrong.
1137        Note there's no need to check for errors, since if this is incorrect, we
1138        simply won't wipe userdata, which is the correct default behavior
1139     */
1140     int N = 1 << crypt_ftr->N_factor;
1141     int r = 1 << crypt_ftr->r_factor;
1142     int p = 1 << crypt_ftr->p_factor;
1143
1144     rc = crypto_scrypt(ikey, KEY_LEN_BYTES,
1145                        crypt_ftr->salt, sizeof(crypt_ftr->salt), N, r, p,
1146                        crypt_ftr->scrypted_intermediate_key,
1147                        sizeof(crypt_ftr->scrypted_intermediate_key));
1148
1149     if (rc) {
1150       SLOGE("encrypt_master_key: crypto_scrypt failed");
1151     }
1152
1153     EVP_CIPHER_CTX_cleanup(&e_ctx);
1154
1155     return 0;
1156 }
1157
1158 static int decrypt_master_key_aux(const char *passwd, unsigned char *salt,
1159                                   unsigned char *encrypted_master_key,
1160                                   unsigned char *decrypted_master_key,
1161                                   kdf_func kdf, void *kdf_params,
1162                                   unsigned char** intermediate_key,
1163                                   size_t* intermediate_key_size)
1164 {
1165   unsigned char ikey[32+32] = { 0 }; /* Big enough to hold a 256 bit key and 256 bit IV */
1166   EVP_CIPHER_CTX d_ctx;
1167   int decrypted_len, final_len;
1168
1169   /* Turn the password into an intermediate key and IV that can decrypt the
1170      master key */
1171   if (kdf(passwd, salt, ikey, kdf_params)) {
1172     SLOGE("kdf failed");
1173     return -1;
1174   }
1175
1176   /* Initialize the decryption engine */
1177   EVP_CIPHER_CTX_init(&d_ctx);
1178   if (! EVP_DecryptInit_ex(&d_ctx, EVP_aes_128_cbc(), NULL, ikey, ikey+KEY_LEN_BYTES)) {
1179     return -1;
1180   }
1181   EVP_CIPHER_CTX_set_padding(&d_ctx, 0); /* Turn off padding as our data is block aligned */
1182   /* Decrypt the master key */
1183   if (! EVP_DecryptUpdate(&d_ctx, decrypted_master_key, &decrypted_len,
1184                             encrypted_master_key, KEY_LEN_BYTES)) {
1185     return -1;
1186   }
1187   if (! EVP_DecryptFinal_ex(&d_ctx, decrypted_master_key + decrypted_len, &final_len)) {
1188     return -1;
1189   }
1190
1191   if (decrypted_len + final_len != KEY_LEN_BYTES) {
1192     return -1;
1193   }
1194
1195   /* Copy intermediate key if needed by params */
1196   if (intermediate_key && intermediate_key_size) {
1197     *intermediate_key = (unsigned char*) malloc(KEY_LEN_BYTES);
1198     if (*intermediate_key) {
1199       memcpy(*intermediate_key, ikey, KEY_LEN_BYTES);
1200       *intermediate_key_size = KEY_LEN_BYTES;
1201     }
1202   }
1203
1204   EVP_CIPHER_CTX_cleanup(&d_ctx);
1205
1206   return 0;
1207 }
1208
1209 static void get_kdf_func(struct crypt_mnt_ftr *ftr, kdf_func *kdf, void** kdf_params)
1210 {
1211     if (ftr->kdf_type == KDF_SCRYPT_KEYMASTER) {
1212         *kdf = scrypt_keymaster;
1213         *kdf_params = ftr;
1214     } else if (ftr->kdf_type == KDF_SCRYPT) {
1215         *kdf = scrypt;
1216         *kdf_params = ftr;
1217     } else {
1218         *kdf = pbkdf2;
1219         *kdf_params = NULL;
1220     }
1221 }
1222
1223 static int decrypt_master_key(const char *passwd, unsigned char *decrypted_master_key,
1224                               struct crypt_mnt_ftr *crypt_ftr,
1225                               unsigned char** intermediate_key,
1226                               size_t* intermediate_key_size)
1227 {
1228     kdf_func kdf;
1229     void *kdf_params;
1230     int ret;
1231
1232     get_kdf_func(crypt_ftr, &kdf, &kdf_params);
1233     ret = decrypt_master_key_aux(passwd, crypt_ftr->salt, crypt_ftr->master_key,
1234                                  decrypted_master_key, kdf, kdf_params,
1235                                  intermediate_key, intermediate_key_size);
1236     if (ret != 0) {
1237         SLOGW("failure decrypting master key");
1238     }
1239
1240     return ret;
1241 }
1242
1243 static int create_encrypted_random_key(char *passwd, unsigned char *master_key, unsigned char *salt,
1244         struct crypt_mnt_ftr *crypt_ftr) {
1245     int fd;
1246     unsigned char key_buf[KEY_LEN_BYTES];
1247
1248     /* Get some random bits for a key */
1249     fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC);
1250     read(fd, key_buf, sizeof(key_buf));
1251     read(fd, salt, SALT_LEN);
1252     close(fd);
1253
1254     /* Now encrypt it with the password */
1255     return encrypt_master_key(passwd, salt, key_buf, master_key, crypt_ftr);
1256 }
1257
1258 int wait_and_unmount(const char *mountpoint, bool kill)
1259 {
1260     int i, err, rc;
1261 #define WAIT_UNMOUNT_COUNT 20
1262
1263     /*  Now umount the tmpfs filesystem */
1264     for (i=0; i<WAIT_UNMOUNT_COUNT; i++) {
1265         if (umount(mountpoint) == 0) {
1266             break;
1267         }
1268
1269         if (errno == EINVAL) {
1270             /* EINVAL is returned if the directory is not a mountpoint,
1271              * i.e. there is no filesystem mounted there.  So just get out.
1272              */
1273             break;
1274         }
1275
1276         err = errno;
1277
1278         /* If allowed, be increasingly aggressive before the last two retries */
1279         if (kill) {
1280             if (i == (WAIT_UNMOUNT_COUNT - 3)) {
1281                 SLOGW("sending SIGHUP to processes with open files\n");
1282                 vold_killProcessesWithOpenFiles(mountpoint, SIGTERM);
1283             } else if (i == (WAIT_UNMOUNT_COUNT - 2)) {
1284                 SLOGW("sending SIGKILL to processes with open files\n");
1285                 vold_killProcessesWithOpenFiles(mountpoint, SIGKILL);
1286             }
1287         }
1288
1289         sleep(1);
1290     }
1291
1292     if (i < WAIT_UNMOUNT_COUNT) {
1293       SLOGD("unmounting %s succeeded\n", mountpoint);
1294       rc = 0;
1295     } else {
1296       vold_killProcessesWithOpenFiles(mountpoint, 0);
1297       SLOGE("unmounting %s failed: %s\n", mountpoint, strerror(err));
1298       rc = -1;
1299     }
1300
1301     return rc;
1302 }
1303
1304 #define DATA_PREP_TIMEOUT 1000
1305 static int prep_data_fs(void)
1306 {
1307     int i;
1308
1309     // NOTE: post_fs_data results in init calling back around to vold, so all
1310     // callers to this method must be async
1311
1312     /* Do the prep of the /data filesystem */
1313     property_set("vold.post_fs_data_done", "0");
1314     property_set("vold.decrypt", "trigger_post_fs_data");
1315     SLOGD("Just triggered post_fs_data\n");
1316
1317     /* Wait a max of 50 seconds, hopefully it takes much less */
1318     for (i=0; i<DATA_PREP_TIMEOUT; i++) {
1319         char p[PROPERTY_VALUE_MAX];
1320
1321         property_get("vold.post_fs_data_done", p, "0");
1322         if (*p == '1') {
1323             break;
1324         } else {
1325             usleep(50000);
1326         }
1327     }
1328     if (i == DATA_PREP_TIMEOUT) {
1329         /* Ugh, we failed to prep /data in time.  Bail. */
1330         SLOGE("post_fs_data timed out!\n");
1331         return -1;
1332     } else {
1333         SLOGD("post_fs_data done\n");
1334         return 0;
1335     }
1336 }
1337
1338 static void cryptfs_set_corrupt()
1339 {
1340     // Mark the footer as bad
1341     struct crypt_mnt_ftr crypt_ftr;
1342     if (get_crypt_ftr_and_key(&crypt_ftr)) {
1343         SLOGE("Failed to get crypto footer - panic");
1344         return;
1345     }
1346
1347     crypt_ftr.flags |= CRYPT_DATA_CORRUPT;
1348     if (put_crypt_ftr_and_key(&crypt_ftr)) {
1349         SLOGE("Failed to set crypto footer - panic");
1350         return;
1351     }
1352 }
1353
1354 static void cryptfs_trigger_restart_min_framework()
1355 {
1356     if (fs_mgr_do_tmpfs_mount(DATA_MNT_POINT)) {
1357       SLOGE("Failed to mount tmpfs on data - panic");
1358       return;
1359     }
1360
1361     if (property_set("vold.decrypt", "trigger_post_fs_data")) {
1362         SLOGE("Failed to trigger post fs data - panic");
1363         return;
1364     }
1365
1366     if (property_set("vold.decrypt", "trigger_restart_min_framework")) {
1367         SLOGE("Failed to trigger restart min framework - panic");
1368         return;
1369     }
1370 }
1371
1372 /* returns < 0 on failure */
1373 static int cryptfs_restart_internal(int restart_main)
1374 {
1375     char crypto_blkdev[MAXPATHLEN];
1376     int rc = -1;
1377     static int restart_successful = 0;
1378
1379     /* Validate that it's OK to call this routine */
1380     if (! master_key_saved) {
1381         SLOGE("Encrypted filesystem not validated, aborting");
1382         return -1;
1383     }
1384
1385     if (restart_successful) {
1386         SLOGE("System already restarted with encrypted disk, aborting");
1387         return -1;
1388     }
1389
1390     if (restart_main) {
1391         /* Here is where we shut down the framework.  The init scripts
1392          * start all services in one of three classes: core, main or late_start.
1393          * On boot, we start core and main.  Now, we stop main, but not core,
1394          * as core includes vold and a few other really important things that
1395          * we need to keep running.  Once main has stopped, we should be able
1396          * to umount the tmpfs /data, then mount the encrypted /data.
1397          * We then restart the class main, and also the class late_start.
1398          * At the moment, I've only put a few things in late_start that I know
1399          * are not needed to bring up the framework, and that also cause problems
1400          * with unmounting the tmpfs /data, but I hope to add add more services
1401          * to the late_start class as we optimize this to decrease the delay
1402          * till the user is asked for the password to the filesystem.
1403          */
1404
1405         /* The init files are setup to stop the class main when vold.decrypt is
1406          * set to trigger_reset_main.
1407          */
1408         property_set("vold.decrypt", "trigger_reset_main");
1409         SLOGD("Just asked init to shut down class main\n");
1410
1411         /* Ugh, shutting down the framework is not synchronous, so until it
1412          * can be fixed, this horrible hack will wait a moment for it all to
1413          * shut down before proceeding.  Without it, some devices cannot
1414          * restart the graphics services.
1415          */
1416         sleep(2);
1417     }
1418
1419     /* Now that the framework is shutdown, we should be able to umount()
1420      * the tmpfs filesystem, and mount the real one.
1421      */
1422
1423     property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "");
1424     if (strlen(crypto_blkdev) == 0) {
1425         SLOGE("fs_crypto_blkdev not set\n");
1426         return -1;
1427     }
1428
1429     if (! (rc = wait_and_unmount(DATA_MNT_POINT, true)) ) {
1430         /* If ro.crypto.readonly is set to 1, mount the decrypted
1431          * filesystem readonly.  This is used when /data is mounted by
1432          * recovery mode.
1433          */
1434         char ro_prop[PROPERTY_VALUE_MAX];
1435         property_get("ro.crypto.readonly", ro_prop, "");
1436         if (strlen(ro_prop) > 0 && atoi(ro_prop)) {
1437             struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, DATA_MNT_POINT);
1438             rec->flags |= MS_RDONLY;
1439         }
1440
1441         /* If that succeeded, then mount the decrypted filesystem */
1442         int retries = RETRY_MOUNT_ATTEMPTS;
1443         int mount_rc;
1444
1445         /*
1446          * fs_mgr_do_mount runs fsck. Use setexeccon to run trusted
1447          * partitions in the fsck domain.
1448          */
1449         if (setexeccon(secontextFsck())){
1450             SLOGE("Failed to setexeccon");
1451             return -1;
1452         }
1453         while ((mount_rc = fs_mgr_do_mount(fstab, DATA_MNT_POINT,
1454                                            crypto_blkdev, 0))
1455                != 0) {
1456             if (mount_rc == FS_MGR_DOMNT_BUSY) {
1457                 /* TODO: invoke something similar to
1458                    Process::killProcessWithOpenFiles(DATA_MNT_POINT,
1459                                    retries > RETRY_MOUNT_ATTEMPT/2 ? 1 : 2 ) */
1460                 SLOGI("Failed to mount %s because it is busy - waiting",
1461                       crypto_blkdev);
1462                 if (--retries) {
1463                     sleep(RETRY_MOUNT_DELAY_SECONDS);
1464                 } else {
1465                     /* Let's hope that a reboot clears away whatever is keeping
1466                        the mount busy */
1467                     cryptfs_reboot(reboot);
1468                 }
1469             } else {
1470                 SLOGE("Failed to mount decrypted data");
1471                 cryptfs_set_corrupt();
1472                 cryptfs_trigger_restart_min_framework();
1473                 SLOGI("Started framework to offer wipe");
1474                 if (setexeccon(NULL)) {
1475                     SLOGE("Failed to setexeccon");
1476                 }
1477                 return -1;
1478             }
1479         }
1480         if (setexeccon(NULL)) {
1481             SLOGE("Failed to setexeccon");
1482             return -1;
1483         }
1484
1485         /* Create necessary paths on /data */
1486         if (prep_data_fs()) {
1487             return -1;
1488         }
1489         property_set("vold.decrypt", "trigger_load_persist_props");
1490
1491         /* startup service classes main and late_start */
1492         property_set("vold.decrypt", "trigger_restart_framework");
1493         SLOGD("Just triggered restart_framework\n");
1494
1495         /* Give it a few moments to get started */
1496         sleep(1);
1497     }
1498
1499     if (rc == 0) {
1500         restart_successful = 1;
1501     }
1502
1503     return rc;
1504 }
1505
1506 int cryptfs_restart(void)
1507 {
1508     SLOGI("cryptfs_restart");
1509     if (e4crypt_is_native()) {
1510         SLOGE("cryptfs_restart not valid for file encryption:");
1511         return -1;
1512     }
1513
1514     /* Call internal implementation forcing a restart of main service group */
1515     return cryptfs_restart_internal(1);
1516 }
1517
1518 static int do_crypto_complete(char *mount_point)
1519 {
1520   struct crypt_mnt_ftr crypt_ftr;
1521   char encrypted_state[PROPERTY_VALUE_MAX];
1522   char key_loc[PROPERTY_VALUE_MAX];
1523
1524   property_get("ro.crypto.state", encrypted_state, "");
1525   if (strcmp(encrypted_state, "encrypted") ) {
1526     SLOGE("not running with encryption, aborting");
1527     return CRYPTO_COMPLETE_NOT_ENCRYPTED;
1528   }
1529
1530   // crypto_complete is full disk encrypted status
1531   if (e4crypt_is_native()) {
1532     return CRYPTO_COMPLETE_NOT_ENCRYPTED;
1533   }
1534
1535   if (get_crypt_ftr_and_key(&crypt_ftr)) {
1536     fs_mgr_get_crypt_info(fstab, key_loc, 0, sizeof(key_loc));
1537
1538     /*
1539      * Only report this error if key_loc is a file and it exists.
1540      * If the device was never encrypted, and /data is not mountable for
1541      * some reason, returning 1 should prevent the UI from presenting the
1542      * a "enter password" screen, or worse, a "press button to wipe the
1543      * device" screen.
1544      */
1545     if ((key_loc[0] == '/') && (access("key_loc", F_OK) == -1)) {
1546       SLOGE("master key file does not exist, aborting");
1547       return CRYPTO_COMPLETE_NOT_ENCRYPTED;
1548     } else {
1549       SLOGE("Error getting crypt footer and key\n");
1550       return CRYPTO_COMPLETE_BAD_METADATA;
1551     }
1552   }
1553
1554   // Test for possible error flags
1555   if (crypt_ftr.flags & CRYPT_ENCRYPTION_IN_PROGRESS){
1556     SLOGE("Encryption process is partway completed\n");
1557     return CRYPTO_COMPLETE_PARTIAL;
1558   }
1559
1560   if (crypt_ftr.flags & CRYPT_INCONSISTENT_STATE){
1561     SLOGE("Encryption process was interrupted but cannot continue\n");
1562     return CRYPTO_COMPLETE_INCONSISTENT;
1563   }
1564
1565   if (crypt_ftr.flags & CRYPT_DATA_CORRUPT){
1566     SLOGE("Encryption is successful but data is corrupt\n");
1567     return CRYPTO_COMPLETE_CORRUPT;
1568   }
1569
1570   /* We passed the test! We shall diminish, and return to the west */
1571   return CRYPTO_COMPLETE_ENCRYPTED;
1572 }
1573
1574 static int test_mount_encrypted_fs(struct crypt_mnt_ftr* crypt_ftr,
1575                                    char *passwd, char *mount_point, char *label)
1576 {
1577   /* Allocate enough space for a 256 bit key, but we may use less */
1578   unsigned char decrypted_master_key[32];
1579   char crypto_blkdev[MAXPATHLEN];
1580   char real_blkdev[MAXPATHLEN];
1581   char tmp_mount_point[64];
1582   unsigned int orig_failed_decrypt_count;
1583   int rc;
1584   int use_keymaster = 0;
1585   int upgrade = 0;
1586   unsigned char* intermediate_key = 0;
1587   size_t intermediate_key_size = 0;
1588
1589   SLOGD("crypt_ftr->fs_size = %lld\n", crypt_ftr->fs_size);
1590   orig_failed_decrypt_count = crypt_ftr->failed_decrypt_count;
1591
1592   if (! (crypt_ftr->flags & CRYPT_MNT_KEY_UNENCRYPTED) ) {
1593     if (decrypt_master_key(passwd, decrypted_master_key, crypt_ftr,
1594                            &intermediate_key, &intermediate_key_size)) {
1595       SLOGE("Failed to decrypt master key\n");
1596       rc = -1;
1597       goto errout;
1598     }
1599   }
1600
1601   fs_mgr_get_crypt_info(fstab, 0, real_blkdev, sizeof(real_blkdev));
1602
1603   // Create crypto block device - all (non fatal) code paths
1604   // need it
1605   if (create_crypto_blk_dev(crypt_ftr, decrypted_master_key,
1606                             real_blkdev, crypto_blkdev, label)) {
1607      SLOGE("Error creating decrypted block device\n");
1608      rc = -1;
1609      goto errout;
1610   }
1611
1612   /* Work out if the problem is the password or the data */
1613   unsigned char scrypted_intermediate_key[sizeof(crypt_ftr->
1614                                                  scrypted_intermediate_key)];
1615   int N = 1 << crypt_ftr->N_factor;
1616   int r = 1 << crypt_ftr->r_factor;
1617   int p = 1 << crypt_ftr->p_factor;
1618
1619   rc = crypto_scrypt(intermediate_key, intermediate_key_size,
1620                      crypt_ftr->salt, sizeof(crypt_ftr->salt),
1621                      N, r, p, scrypted_intermediate_key,
1622                      sizeof(scrypted_intermediate_key));
1623
1624   // Does the key match the crypto footer?
1625   if (rc == 0 && memcmp(scrypted_intermediate_key,
1626                         crypt_ftr->scrypted_intermediate_key,
1627                         sizeof(scrypted_intermediate_key)) == 0) {
1628     SLOGI("Password matches");
1629     rc = 0;
1630   } else {
1631     /* Try mounting the file system anyway, just in case the problem's with
1632      * the footer, not the key. */
1633     snprintf(tmp_mount_point, sizeof(tmp_mount_point), "%s/tmp_mnt",
1634              mount_point);
1635     mkdir(tmp_mount_point, 0755);
1636     if (fs_mgr_do_mount(fstab, DATA_MNT_POINT, crypto_blkdev, tmp_mount_point)) {
1637       SLOGE("Error temp mounting decrypted block device\n");
1638       delete_crypto_blk_dev(label);
1639
1640       rc = ++crypt_ftr->failed_decrypt_count;
1641       put_crypt_ftr_and_key(crypt_ftr);
1642     } else {
1643       /* Success! */
1644       SLOGI("Password did not match but decrypted drive mounted - continue");
1645       umount(tmp_mount_point);
1646       rc = 0;
1647     }
1648   }
1649
1650   if (rc == 0) {
1651     crypt_ftr->failed_decrypt_count = 0;
1652     if (orig_failed_decrypt_count != 0) {
1653       put_crypt_ftr_and_key(crypt_ftr);
1654     }
1655
1656     /* Save the name of the crypto block device
1657      * so we can mount it when restarting the framework. */
1658     property_set("ro.crypto.fs_crypto_blkdev", crypto_blkdev);
1659
1660     /* Also save a the master key so we can reencrypted the key
1661      * the key when we want to change the password on it. */
1662     memcpy(saved_master_key, decrypted_master_key, KEY_LEN_BYTES);
1663     saved_mount_point = strdup(mount_point);
1664     master_key_saved = 1;
1665     SLOGD("%s(): Master key saved\n", __FUNCTION__);
1666     rc = 0;
1667
1668     // Upgrade if we're not using the latest KDF.
1669     use_keymaster = keymaster_check_compatibility();
1670     if (crypt_ftr->kdf_type == KDF_SCRYPT_KEYMASTER) {
1671         // Don't allow downgrade
1672     } else if (use_keymaster == 1 && crypt_ftr->kdf_type != KDF_SCRYPT_KEYMASTER) {
1673         crypt_ftr->kdf_type = KDF_SCRYPT_KEYMASTER;
1674         upgrade = 1;
1675     } else if (use_keymaster == 0 && crypt_ftr->kdf_type != KDF_SCRYPT) {
1676         crypt_ftr->kdf_type = KDF_SCRYPT;
1677         upgrade = 1;
1678     }
1679
1680     if (upgrade) {
1681         rc = encrypt_master_key(passwd, crypt_ftr->salt, saved_master_key,
1682                                 crypt_ftr->master_key, crypt_ftr);
1683         if (!rc) {
1684             rc = put_crypt_ftr_and_key(crypt_ftr);
1685         }
1686         SLOGD("Key Derivation Function upgrade: rc=%d\n", rc);
1687
1688         // Do not fail even if upgrade failed - machine is bootable
1689         // Note that if this code is ever hit, there is a *serious* problem
1690         // since KDFs should never fail. You *must* fix the kdf before
1691         // proceeding!
1692         if (rc) {
1693           SLOGW("Upgrade failed with error %d,"
1694                 " but continuing with previous state",
1695                 rc);
1696           rc = 0;
1697         }
1698     }
1699   }
1700
1701  errout:
1702   if (intermediate_key) {
1703     memset(intermediate_key, 0, intermediate_key_size);
1704     free(intermediate_key);
1705   }
1706   return rc;
1707 }
1708
1709 /*
1710  * Called by vold when it's asked to mount an encrypted external
1711  * storage volume. The incoming partition has no crypto header/footer,
1712  * as any metadata is been stored in a separate, small partition.
1713  *
1714  * out_crypto_blkdev must be MAXPATHLEN.
1715  */
1716 int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev,
1717         const unsigned char* key, int keysize, char* out_crypto_blkdev) {
1718     int fd = open(real_blkdev, O_RDONLY|O_CLOEXEC);
1719     if (fd == -1) {
1720         SLOGE("Failed to open %s: %s", real_blkdev, strerror(errno));
1721         return -1;
1722     }
1723
1724     unsigned long nr_sec = 0;
1725     get_blkdev_size(fd, &nr_sec);
1726     close(fd);
1727
1728     if (nr_sec == 0) {
1729         SLOGE("Failed to get size of %s: %s", real_blkdev, strerror(errno));
1730         return -1;
1731     }
1732
1733     struct crypt_mnt_ftr ext_crypt_ftr;
1734     memset(&ext_crypt_ftr, 0, sizeof(ext_crypt_ftr));
1735     ext_crypt_ftr.fs_size = nr_sec;
1736     ext_crypt_ftr.keysize = keysize;
1737     strcpy((char*) ext_crypt_ftr.crypto_type_name, "aes-cbc-essiv:sha256");
1738
1739     return create_crypto_blk_dev(&ext_crypt_ftr, key, real_blkdev,
1740             out_crypto_blkdev, label);
1741 }
1742
1743 /*
1744  * Called by vold when it's asked to unmount an encrypted external
1745  * storage volume.
1746  */
1747 int cryptfs_revert_ext_volume(const char* label) {
1748     return delete_crypto_blk_dev((char*) label);
1749 }
1750
1751 int cryptfs_crypto_complete(void)
1752 {
1753   return do_crypto_complete("/data");
1754 }
1755
1756 int check_unmounted_and_get_ftr(struct crypt_mnt_ftr* crypt_ftr)
1757 {
1758     char encrypted_state[PROPERTY_VALUE_MAX];
1759     property_get("ro.crypto.state", encrypted_state, "");
1760     if ( master_key_saved || strcmp(encrypted_state, "encrypted") ) {
1761         SLOGE("encrypted fs already validated or not running with encryption,"
1762               " aborting");
1763         return -1;
1764     }
1765
1766     if (get_crypt_ftr_and_key(crypt_ftr)) {
1767         SLOGE("Error getting crypt footer and key");
1768         return -1;
1769     }
1770
1771     return 0;
1772 }
1773
1774 int cryptfs_check_passwd(char *passwd)
1775 {
1776     SLOGI("cryptfs_check_passwd");
1777     if (e4crypt_is_native()) {
1778         SLOGE("cryptfs_check_passwd not valid for file encryption");
1779         return -1;
1780     }
1781
1782     struct crypt_mnt_ftr crypt_ftr;
1783     int rc;
1784
1785     rc = check_unmounted_and_get_ftr(&crypt_ftr);
1786     if (rc) {
1787         SLOGE("Could not get footer");
1788         return rc;
1789     }
1790
1791     rc = test_mount_encrypted_fs(&crypt_ftr, passwd,
1792                                  DATA_MNT_POINT, CRYPTO_BLOCK_DEVICE);
1793     if (rc) {
1794         SLOGE("Password did not match");
1795         return rc;
1796     }
1797
1798     if (crypt_ftr.flags & CRYPT_FORCE_COMPLETE) {
1799         // Here we have a default actual password but a real password
1800         // we must test against the scrypted value
1801         // First, we must delete the crypto block device that
1802         // test_mount_encrypted_fs leaves behind as a side effect
1803         delete_crypto_blk_dev(CRYPTO_BLOCK_DEVICE);
1804         rc = test_mount_encrypted_fs(&crypt_ftr, DEFAULT_PASSWORD,
1805                                      DATA_MNT_POINT, CRYPTO_BLOCK_DEVICE);
1806         if (rc) {
1807             SLOGE("Default password did not match on reboot encryption");
1808             return rc;
1809         }
1810
1811         crypt_ftr.flags &= ~CRYPT_FORCE_COMPLETE;
1812         put_crypt_ftr_and_key(&crypt_ftr);
1813         rc = cryptfs_changepw(crypt_ftr.crypt_type, passwd);
1814         if (rc) {
1815             SLOGE("Could not change password on reboot encryption");
1816             return rc;
1817         }
1818     }
1819
1820     if (crypt_ftr.crypt_type != CRYPT_TYPE_DEFAULT) {
1821         cryptfs_clear_password();
1822         password = strdup(passwd);
1823         struct timespec now;
1824         clock_gettime(CLOCK_BOOTTIME, &now);
1825         password_expiry_time = now.tv_sec + password_max_age_seconds;
1826     }
1827
1828     return rc;
1829 }
1830
1831 int cryptfs_verify_passwd(char *passwd)
1832 {
1833     struct crypt_mnt_ftr crypt_ftr;
1834     /* Allocate enough space for a 256 bit key, but we may use less */
1835     unsigned char decrypted_master_key[32];
1836     char encrypted_state[PROPERTY_VALUE_MAX];
1837     int rc;
1838
1839     property_get("ro.crypto.state", encrypted_state, "");
1840     if (strcmp(encrypted_state, "encrypted") ) {
1841         SLOGE("device not encrypted, aborting");
1842         return -2;
1843     }
1844
1845     if (!master_key_saved) {
1846         SLOGE("encrypted fs not yet mounted, aborting");
1847         return -1;
1848     }
1849
1850     if (!saved_mount_point) {
1851         SLOGE("encrypted fs failed to save mount point, aborting");
1852         return -1;
1853     }
1854
1855     if (get_crypt_ftr_and_key(&crypt_ftr)) {
1856         SLOGE("Error getting crypt footer and key\n");
1857         return -1;
1858     }
1859
1860     if (crypt_ftr.flags & CRYPT_MNT_KEY_UNENCRYPTED) {
1861         /* If the device has no password, then just say the password is valid */
1862         rc = 0;
1863     } else {
1864         decrypt_master_key(passwd, decrypted_master_key, &crypt_ftr, 0, 0);
1865         if (!memcmp(decrypted_master_key, saved_master_key, crypt_ftr.keysize)) {
1866             /* They match, the password is correct */
1867             rc = 0;
1868         } else {
1869             /* If incorrect, sleep for a bit to prevent dictionary attacks */
1870             sleep(1);
1871             rc = 1;
1872         }
1873     }
1874
1875     return rc;
1876 }
1877
1878 /* Initialize a crypt_mnt_ftr structure.  The keysize is
1879  * defaulted to 16 bytes, and the filesystem size to 0.
1880  * Presumably, at a minimum, the caller will update the
1881  * filesystem size and crypto_type_name after calling this function.
1882  */
1883 static int cryptfs_init_crypt_mnt_ftr(struct crypt_mnt_ftr *ftr)
1884 {
1885     off64_t off;
1886
1887     memset(ftr, 0, sizeof(struct crypt_mnt_ftr));
1888     ftr->magic = CRYPT_MNT_MAGIC;
1889     ftr->major_version = CURRENT_MAJOR_VERSION;
1890     ftr->minor_version = CURRENT_MINOR_VERSION;
1891     ftr->ftr_size = sizeof(struct crypt_mnt_ftr);
1892     ftr->keysize = KEY_LEN_BYTES;
1893
1894     switch (keymaster_check_compatibility()) {
1895     case 1:
1896         ftr->kdf_type = KDF_SCRYPT_KEYMASTER;
1897         break;
1898
1899     case 0:
1900         ftr->kdf_type = KDF_SCRYPT;
1901         break;
1902
1903     default:
1904         SLOGE("keymaster_check_compatibility failed");
1905         return -1;
1906     }
1907
1908     get_device_scrypt_params(ftr);
1909
1910     ftr->persist_data_size = CRYPT_PERSIST_DATA_SIZE;
1911     if (get_crypt_ftr_info(NULL, &off) == 0) {
1912         ftr->persist_data_offset[0] = off + CRYPT_FOOTER_TO_PERSIST_OFFSET;
1913         ftr->persist_data_offset[1] = off + CRYPT_FOOTER_TO_PERSIST_OFFSET +
1914                                     ftr->persist_data_size;
1915     }
1916
1917     return 0;
1918 }
1919
1920 static int cryptfs_enable_wipe(char *crypto_blkdev, off64_t size, int type)
1921 {
1922     const char *args[10];
1923     char size_str[32]; /* Must be large enough to hold a %lld and null byte */
1924     int num_args;
1925     int status;
1926     int tmp;
1927     int rc = -1;
1928
1929     if (type == EXT4_FS) {
1930 #ifdef TARGET_USES_MKE2FS
1931         args[0] = "/system/bin/mke2fs";
1932         args[1] = "-M";
1933         args[2] = "/data";
1934         args[3] = "-b";
1935         args[4] = "4096";
1936         args[5] = "-t";
1937         args[6] = "ext4";
1938         args[7] = crypto_blkdev;
1939         snprintf(size_str, sizeof(size_str), "%" PRId64, size / (4096 / 512));
1940         args[8] = size_str;
1941         num_args = 9;
1942 #else
1943         args[0] = "/system/bin/make_ext4fs";
1944         args[1] = "-a";
1945         args[2] = "/data";
1946         args[3] = "-l";
1947         snprintf(size_str, sizeof(size_str), "%" PRId64, size * 512);
1948         args[4] = size_str;
1949         args[5] = crypto_blkdev;
1950         num_args = 6;
1951 #endif
1952         SLOGI("Making empty filesystem with command %s %s %s %s %s %s\n",
1953               args[0], args[1], args[2], args[3], args[4], args[5]);
1954     } else if (type == F2FS_FS) {
1955         args[0] = "/system/bin/mkfs.f2fs";
1956         args[1] = "-t";
1957         args[2] = "-d1";
1958         args[3] = crypto_blkdev;
1959         snprintf(size_str, sizeof(size_str), "%" PRId64, size);
1960         args[4] = size_str;
1961         num_args = 5;
1962         SLOGI("Making empty filesystem with command %s %s %s %s %s\n",
1963               args[0], args[1], args[2], args[3], args[4]);
1964     } else {
1965         SLOGE("cryptfs_enable_wipe(): unknown filesystem type %d\n", type);
1966         return -1;
1967     }
1968
1969     tmp = android_fork_execvp(num_args, (char **)args, &status, false, true);
1970
1971     if (tmp != 0) {
1972       SLOGE("Error creating empty filesystem on %s due to logwrap error\n", crypto_blkdev);
1973     } else {
1974         if (WIFEXITED(status)) {
1975             if (WEXITSTATUS(status)) {
1976                 SLOGE("Error creating filesystem on %s, exit status %d ",
1977                       crypto_blkdev, WEXITSTATUS(status));
1978             } else {
1979                 SLOGD("Successfully created filesystem on %s\n", crypto_blkdev);
1980                 rc = 0;
1981             }
1982         } else {
1983             SLOGE("Error creating filesystem on %s, did not exit normally\n", crypto_blkdev);
1984        }
1985     }
1986
1987     return rc;
1988 }
1989
1990 #define CRYPT_INPLACE_BUFSIZE 4096
1991 #define CRYPT_SECTORS_PER_BUFSIZE (CRYPT_INPLACE_BUFSIZE / CRYPT_SECTOR_SIZE)
1992 #define CRYPT_SECTOR_SIZE 512
1993
1994 /* aligned 32K writes tends to make flash happy.
1995  * SD card association recommends it.
1996  */
1997 #define BLOCKS_AT_A_TIME 8
1998
1999 struct encryptGroupsData
2000 {
2001     int realfd;
2002     int cryptofd;
2003     off64_t numblocks;
2004     off64_t one_pct, cur_pct, new_pct;
2005     off64_t blocks_already_done, tot_numblocks;
2006     off64_t used_blocks_already_done, tot_used_blocks;
2007     char* real_blkdev, * crypto_blkdev;
2008     int count;
2009     off64_t offset;
2010     char* buffer;
2011     off64_t last_written_sector;
2012     int completed;
2013     time_t time_started;
2014     int remaining_time;
2015 };
2016
2017 static void update_progress(struct encryptGroupsData* data, int is_used)
2018 {
2019     data->blocks_already_done++;
2020
2021     if (is_used) {
2022         data->used_blocks_already_done++;
2023     }
2024     if (data->tot_used_blocks) {
2025         data->new_pct = data->used_blocks_already_done / data->one_pct;
2026     } else {
2027         data->new_pct = data->blocks_already_done / data->one_pct;
2028     }
2029
2030     if (data->new_pct > data->cur_pct) {
2031         char buf[8];
2032         data->cur_pct = data->new_pct;
2033         snprintf(buf, sizeof(buf), "%" PRId64, data->cur_pct);
2034         property_set("vold.encrypt_progress", buf);
2035     }
2036
2037     if (data->cur_pct >= 5) {
2038         struct timespec time_now;
2039         if (clock_gettime(CLOCK_MONOTONIC, &time_now)) {
2040             SLOGW("Error getting time");
2041         } else {
2042             double elapsed_time = difftime(time_now.tv_sec, data->time_started);
2043             off64_t remaining_blocks = data->tot_used_blocks
2044                                        - data->used_blocks_already_done;
2045             int remaining_time = (int)(elapsed_time * remaining_blocks
2046                                        / data->used_blocks_already_done);
2047
2048             // Change time only if not yet set, lower, or a lot higher for
2049             // best user experience
2050             if (data->remaining_time == -1
2051                 || remaining_time < data->remaining_time
2052                 || remaining_time > data->remaining_time + 60) {
2053                 char buf[8];
2054                 snprintf(buf, sizeof(buf), "%d", remaining_time);
2055                 property_set("vold.encrypt_time_remaining", buf);
2056                 data->remaining_time = remaining_time;
2057             }
2058         }
2059     }
2060 }
2061
2062 static void log_progress(struct encryptGroupsData const* data, bool completed)
2063 {
2064     // Precondition - if completed data = 0 else data != 0
2065
2066     // Track progress so we can skip logging blocks
2067     static off64_t offset = -1;
2068
2069     // Need to close existing 'Encrypting from' log?
2070     if (completed || (offset != -1 && data->offset != offset)) {
2071         SLOGI("Encrypted to sector %" PRId64,
2072               offset / info.block_size * CRYPT_SECTOR_SIZE);
2073         offset = -1;
2074     }
2075
2076     // Need to start new 'Encrypting from' log?
2077     if (!completed && offset != data->offset) {
2078         SLOGI("Encrypting from sector %" PRId64,
2079               data->offset / info.block_size * CRYPT_SECTOR_SIZE);
2080     }
2081
2082     // Update offset
2083     if (!completed) {
2084         offset = data->offset + (off64_t)data->count * info.block_size;
2085     }
2086 }
2087
2088 static int flush_outstanding_data(struct encryptGroupsData* data)
2089 {
2090     if (data->count == 0) {
2091         return 0;
2092     }
2093
2094     SLOGV("Copying %d blocks at offset %" PRIx64, data->count, data->offset);
2095
2096     if (pread64(data->realfd, data->buffer,
2097                 info.block_size * data->count, data->offset)
2098         <= 0) {
2099         SLOGE("Error reading real_blkdev %s for inplace encrypt",
2100               data->real_blkdev);
2101         return -1;
2102     }
2103
2104     if (pwrite64(data->cryptofd, data->buffer,
2105                  info.block_size * data->count, data->offset)
2106         <= 0) {
2107         SLOGE("Error writing crypto_blkdev %s for inplace encrypt",
2108               data->crypto_blkdev);
2109         return -1;
2110     } else {
2111       log_progress(data, false);
2112     }
2113
2114     data->count = 0;
2115     data->last_written_sector = (data->offset + data->count)
2116                                 / info.block_size * CRYPT_SECTOR_SIZE - 1;
2117     return 0;
2118 }
2119
2120 static int encrypt_groups(struct encryptGroupsData* data)
2121 {
2122     unsigned int i;
2123     u8 *block_bitmap = 0;
2124     unsigned int block;
2125     off64_t ret;
2126     int rc = -1;
2127
2128     data->buffer = malloc(info.block_size * BLOCKS_AT_A_TIME);
2129     if (!data->buffer) {
2130         SLOGE("Failed to allocate crypto buffer");
2131         goto errout;
2132     }
2133
2134     block_bitmap = malloc(info.block_size);
2135     if (!block_bitmap) {
2136         SLOGE("failed to allocate block bitmap");
2137         goto errout;
2138     }
2139
2140     for (i = 0; i < aux_info.groups; ++i) {
2141         SLOGI("Encrypting group %d", i);
2142
2143         u32 first_block = aux_info.first_data_block + i * info.blocks_per_group;
2144         u32 block_count = min(info.blocks_per_group,
2145                              aux_info.len_blocks - first_block);
2146
2147         off64_t offset = (u64)info.block_size
2148                          * aux_info.bg_desc[i].bg_block_bitmap;
2149
2150         ret = pread64(data->realfd, block_bitmap, info.block_size, offset);
2151         if (ret != (int)info.block_size) {
2152             SLOGE("failed to read all of block group bitmap %d", i);
2153             goto errout;
2154         }
2155
2156         offset = (u64)info.block_size * first_block;
2157
2158         data->count = 0;
2159
2160         for (block = 0; block < block_count; block++) {
2161             int used = (aux_info.bg_desc[i].bg_flags & EXT4_BG_BLOCK_UNINIT) ?
2162                     0 : bitmap_get_bit(block_bitmap, block);
2163             update_progress(data, used);
2164             if (used) {
2165                 if (data->count == 0) {
2166                     data->offset = offset;
2167                 }
2168                 data->count++;
2169             } else {
2170                 if (flush_outstanding_data(data)) {
2171                     goto errout;
2172                 }
2173             }
2174
2175             offset += info.block_size;
2176
2177             /* Write data if we are aligned or buffer size reached */
2178             if (offset % (info.block_size * BLOCKS_AT_A_TIME) == 0
2179                 || data->count == BLOCKS_AT_A_TIME) {
2180                 if (flush_outstanding_data(data)) {
2181                     goto errout;
2182                 }
2183             }
2184
2185             if (!is_battery_ok_to_continue()) {
2186                 SLOGE("Stopping encryption due to low battery");
2187                 rc = 0;
2188                 goto errout;
2189             }
2190
2191         }
2192         if (flush_outstanding_data(data)) {
2193             goto errout;
2194         }
2195     }
2196
2197     data->completed = 1;
2198     rc = 0;
2199
2200 errout:
2201     log_progress(0, true);
2202     free(data->buffer);
2203     free(block_bitmap);
2204     return rc;
2205 }
2206
2207 static int cryptfs_enable_inplace_ext4(char *crypto_blkdev,
2208                                        char *real_blkdev,
2209                                        off64_t size,
2210                                        off64_t *size_already_done,
2211                                        off64_t tot_size,
2212                                        off64_t previously_encrypted_upto)
2213 {
2214     u32 i;
2215     struct encryptGroupsData data;
2216     int rc; // Can't initialize without causing warning -Wclobbered
2217
2218     if (previously_encrypted_upto > *size_already_done) {
2219         SLOGD("Not fast encrypting since resuming part way through");
2220         return -1;
2221     }
2222
2223     memset(&data, 0, sizeof(data));
2224     data.real_blkdev = real_blkdev;
2225     data.crypto_blkdev = crypto_blkdev;
2226
2227     if ( (data.realfd = open(real_blkdev, O_RDWR|O_CLOEXEC)) < 0) {
2228         SLOGE("Error opening real_blkdev %s for inplace encrypt. err=%d(%s)\n",
2229               real_blkdev, errno, strerror(errno));
2230         rc = -1;
2231         goto errout;
2232     }
2233
2234     // Wait until the block device appears.  Re-use the mount retry values since it is reasonable.
2235     int retries = RETRY_MOUNT_ATTEMPTS;
2236     while ((data.cryptofd = open(crypto_blkdev, O_WRONLY|O_CLOEXEC)) < 0) {
2237         if (--retries) {
2238             SLOGE("Error opening crypto_blkdev %s for ext4 inplace encrypt. err=%d(%s), retrying\n",
2239                   crypto_blkdev, errno, strerror(errno));
2240             sleep(RETRY_MOUNT_DELAY_SECONDS);
2241         } else {
2242             SLOGE("Error opening crypto_blkdev %s for ext4 inplace encrypt. err=%d(%s)\n",
2243                   crypto_blkdev, errno, strerror(errno));
2244             rc = ENABLE_INPLACE_ERR_DEV;
2245             goto errout;
2246         }
2247     }
2248
2249     if (setjmp(setjmp_env)) {
2250         SLOGE("Reading ext4 extent caused an exception\n");
2251         rc = -1;
2252         goto errout;
2253     }
2254
2255     if (read_ext(data.realfd, 0) != 0) {
2256         SLOGE("Failed to read ext4 extent\n");
2257         rc = -1;
2258         goto errout;
2259     }
2260
2261     data.numblocks = size / CRYPT_SECTORS_PER_BUFSIZE;
2262     data.tot_numblocks = tot_size / CRYPT_SECTORS_PER_BUFSIZE;
2263     data.blocks_already_done = *size_already_done / CRYPT_SECTORS_PER_BUFSIZE;
2264
2265     SLOGI("Encrypting ext4 filesystem in place...");
2266
2267     data.tot_used_blocks = data.numblocks;
2268     for (i = 0; i < aux_info.groups; ++i) {
2269       data.tot_used_blocks -= aux_info.bg_desc[i].bg_free_blocks_count;
2270     }
2271
2272     data.one_pct = data.tot_used_blocks / 100;
2273     data.cur_pct = 0;
2274
2275     struct timespec time_started = {0};
2276     if (clock_gettime(CLOCK_MONOTONIC, &time_started)) {
2277         SLOGW("Error getting time at start");
2278         // Note - continue anyway - we'll run with 0
2279     }
2280     data.time_started = time_started.tv_sec;
2281     data.remaining_time = -1;
2282
2283     rc = encrypt_groups(&data);
2284     if (rc) {
2285         SLOGE("Error encrypting groups");
2286         goto errout;
2287     }
2288
2289     *size_already_done += data.completed ? size : data.last_written_sector;
2290     rc = 0;
2291
2292 errout:
2293     close(data.realfd);
2294     close(data.cryptofd);
2295
2296     return rc;
2297 }
2298
2299 static void log_progress_f2fs(u64 block, bool completed)
2300 {
2301     // Precondition - if completed data = 0 else data != 0
2302
2303     // Track progress so we can skip logging blocks
2304     static u64 last_block = (u64)-1;
2305
2306     // Need to close existing 'Encrypting from' log?
2307     if (completed || (last_block != (u64)-1 && block != last_block + 1)) {
2308         SLOGI("Encrypted to block %" PRId64, last_block);
2309         last_block = -1;
2310     }
2311
2312     // Need to start new 'Encrypting from' log?
2313     if (!completed && (last_block == (u64)-1 || block != last_block + 1)) {
2314         SLOGI("Encrypting from block %" PRId64, block);
2315     }
2316
2317     // Update offset
2318     if (!completed) {
2319         last_block = block;
2320     }
2321 }
2322
2323 static int encrypt_one_block_f2fs(u64 pos, void *data)
2324 {
2325     struct encryptGroupsData *priv_dat = (struct encryptGroupsData *)data;
2326
2327     priv_dat->blocks_already_done = pos - 1;
2328     update_progress(priv_dat, 1);
2329
2330     off64_t offset = pos * CRYPT_INPLACE_BUFSIZE;
2331
2332     if (pread64(priv_dat->realfd, priv_dat->buffer, CRYPT_INPLACE_BUFSIZE, offset) <= 0) {
2333         SLOGE("Error reading real_blkdev %s for f2fs inplace encrypt", priv_dat->crypto_blkdev);
2334         return -1;
2335     }
2336
2337     if (pwrite64(priv_dat->cryptofd, priv_dat->buffer, CRYPT_INPLACE_BUFSIZE, offset) <= 0) {
2338         SLOGE("Error writing crypto_blkdev %s for f2fs inplace encrypt", priv_dat->crypto_blkdev);
2339         return -1;
2340     } else {
2341         log_progress_f2fs(pos, false);
2342     }
2343
2344     return 0;
2345 }
2346
2347 static int cryptfs_enable_inplace_f2fs(char *crypto_blkdev,
2348                                        char *real_blkdev,
2349                                        off64_t size,
2350                                        off64_t *size_already_done,
2351                                        off64_t tot_size,
2352                                        off64_t previously_encrypted_upto)
2353 {
2354     struct encryptGroupsData data;
2355     struct f2fs_info *f2fs_info = NULL;
2356     int rc = ENABLE_INPLACE_ERR_OTHER;
2357     if (previously_encrypted_upto > *size_already_done) {
2358         SLOGD("Not fast encrypting since resuming part way through");
2359         return ENABLE_INPLACE_ERR_OTHER;
2360     }
2361     memset(&data, 0, sizeof(data));
2362     data.real_blkdev = real_blkdev;
2363     data.crypto_blkdev = crypto_blkdev;
2364     data.realfd = -1;
2365     data.cryptofd = -1;
2366     if ( (data.realfd = open64(real_blkdev, O_RDWR|O_CLOEXEC)) < 0) {
2367         SLOGE("Error opening real_blkdev %s for f2fs inplace encrypt\n",
2368               real_blkdev);
2369         goto errout;
2370     }
2371     if ( (data.cryptofd = open64(crypto_blkdev, O_WRONLY|O_CLOEXEC)) < 0) {
2372         SLOGE("Error opening crypto_blkdev %s for f2fs inplace encrypt. err=%d(%s)\n",
2373               crypto_blkdev, errno, strerror(errno));
2374         rc = ENABLE_INPLACE_ERR_DEV;
2375         goto errout;
2376     }
2377
2378     f2fs_info = generate_f2fs_info(data.realfd);
2379     if (!f2fs_info)
2380       goto errout;
2381
2382     data.numblocks = size / CRYPT_SECTORS_PER_BUFSIZE;
2383     data.tot_numblocks = tot_size / CRYPT_SECTORS_PER_BUFSIZE;
2384     data.blocks_already_done = *size_already_done / CRYPT_SECTORS_PER_BUFSIZE;
2385
2386     data.tot_used_blocks = get_num_blocks_used(f2fs_info);
2387
2388     data.one_pct = data.tot_used_blocks / 100;
2389     data.cur_pct = 0;
2390     data.time_started = time(NULL);
2391     data.remaining_time = -1;
2392
2393     data.buffer = malloc(f2fs_info->block_size);
2394     if (!data.buffer) {
2395         SLOGE("Failed to allocate crypto buffer");
2396         goto errout;
2397     }
2398
2399     data.count = 0;
2400
2401     /* Currently, this either runs to completion, or hits a nonrecoverable error */
2402     rc = run_on_used_blocks(data.blocks_already_done, f2fs_info, &encrypt_one_block_f2fs, &data);
2403
2404     if (rc) {
2405         SLOGE("Error in running over f2fs blocks");
2406         rc = ENABLE_INPLACE_ERR_OTHER;
2407         goto errout;
2408     }
2409
2410     *size_already_done += size;
2411     rc = 0;
2412
2413 errout:
2414     if (rc)
2415         SLOGE("Failed to encrypt f2fs filesystem on %s", real_blkdev);
2416
2417     log_progress_f2fs(0, true);
2418     free(f2fs_info);
2419     free(data.buffer);
2420     close(data.realfd);
2421     close(data.cryptofd);
2422
2423     return rc;
2424 }
2425
2426 static int cryptfs_enable_inplace_full(char *crypto_blkdev, char *real_blkdev,
2427                                        off64_t size, off64_t *size_already_done,
2428                                        off64_t tot_size,
2429                                        off64_t previously_encrypted_upto)
2430 {
2431     int realfd, cryptofd;
2432     char *buf[CRYPT_INPLACE_BUFSIZE];
2433     int rc = ENABLE_INPLACE_ERR_OTHER;
2434     off64_t numblocks, i, remainder;
2435     off64_t one_pct, cur_pct, new_pct;
2436     off64_t blocks_already_done, tot_numblocks;
2437
2438     if ( (realfd = open(real_blkdev, O_RDONLY|O_CLOEXEC)) < 0) {
2439         SLOGE("Error opening real_blkdev %s for inplace encrypt\n", real_blkdev);
2440         return ENABLE_INPLACE_ERR_OTHER;
2441     }
2442
2443     if ( (cryptofd = open(crypto_blkdev, O_WRONLY|O_CLOEXEC)) < 0) {
2444         SLOGE("Error opening crypto_blkdev %s for inplace encrypt. err=%d(%s)\n",
2445               crypto_blkdev, errno, strerror(errno));
2446         close(realfd);
2447         return ENABLE_INPLACE_ERR_DEV;
2448     }
2449
2450     /* This is pretty much a simple loop of reading 4K, and writing 4K.
2451      * The size passed in is the number of 512 byte sectors in the filesystem.
2452      * So compute the number of whole 4K blocks we should read/write,
2453      * and the remainder.
2454      */
2455     numblocks = size / CRYPT_SECTORS_PER_BUFSIZE;
2456     remainder = size % CRYPT_SECTORS_PER_BUFSIZE;
2457     tot_numblocks = tot_size / CRYPT_SECTORS_PER_BUFSIZE;
2458     blocks_already_done = *size_already_done / CRYPT_SECTORS_PER_BUFSIZE;
2459
2460     SLOGE("Encrypting filesystem in place...");
2461
2462     i = previously_encrypted_upto + 1 - *size_already_done;
2463
2464     if (lseek64(realfd, i * CRYPT_SECTOR_SIZE, SEEK_SET) < 0) {
2465         SLOGE("Cannot seek to previously encrypted point on %s", real_blkdev);
2466         goto errout;
2467     }
2468
2469     if (lseek64(cryptofd, i * CRYPT_SECTOR_SIZE, SEEK_SET) < 0) {
2470         SLOGE("Cannot seek to previously encrypted point on %s", crypto_blkdev);
2471         goto errout;
2472     }
2473
2474     for (;i < size && i % CRYPT_SECTORS_PER_BUFSIZE != 0; ++i) {
2475         if (unix_read(realfd, buf, CRYPT_SECTOR_SIZE) <= 0) {
2476             SLOGE("Error reading initial sectors from real_blkdev %s for "
2477                   "inplace encrypt\n", crypto_blkdev);
2478             goto errout;
2479         }
2480         if (unix_write(cryptofd, buf, CRYPT_SECTOR_SIZE) <= 0) {
2481             SLOGE("Error writing initial sectors to crypto_blkdev %s for "
2482                   "inplace encrypt\n", crypto_blkdev);
2483             goto errout;
2484         } else {
2485             SLOGI("Encrypted 1 block at %" PRId64, i);
2486         }
2487     }
2488
2489     one_pct = tot_numblocks / 100;
2490     cur_pct = 0;
2491     /* process the majority of the filesystem in blocks */
2492     for (i/=CRYPT_SECTORS_PER_BUFSIZE; i<numblocks; i++) {
2493         new_pct = (i + blocks_already_done) / one_pct;
2494         if (new_pct > cur_pct) {
2495             char buf[8];
2496
2497             cur_pct = new_pct;
2498             snprintf(buf, sizeof(buf), "%" PRId64, cur_pct);
2499             property_set("vold.encrypt_progress", buf);
2500         }
2501         if (unix_read(realfd, buf, CRYPT_INPLACE_BUFSIZE) <= 0) {
2502             SLOGE("Error reading real_blkdev %s for inplace encrypt", crypto_blkdev);
2503             goto errout;
2504         }
2505         if (unix_write(cryptofd, buf, CRYPT_INPLACE_BUFSIZE) <= 0) {
2506             SLOGE("Error writing crypto_blkdev %s for inplace encrypt", crypto_blkdev);
2507             goto errout;
2508         } else {
2509             SLOGD("Encrypted %d block at %" PRId64,
2510                   CRYPT_SECTORS_PER_BUFSIZE,
2511                   i * CRYPT_SECTORS_PER_BUFSIZE);
2512         }
2513
2514        if (!is_battery_ok_to_continue()) {
2515             SLOGE("Stopping encryption due to low battery");
2516             *size_already_done += (i + 1) * CRYPT_SECTORS_PER_BUFSIZE - 1;
2517             rc = 0;
2518             goto errout;
2519         }
2520     }
2521
2522     /* Do any remaining sectors */
2523     for (i=0; i<remainder; i++) {
2524         if (unix_read(realfd, buf, CRYPT_SECTOR_SIZE) <= 0) {
2525             SLOGE("Error reading final sectors from real_blkdev %s for inplace encrypt", crypto_blkdev);
2526             goto errout;
2527         }
2528         if (unix_write(cryptofd, buf, CRYPT_SECTOR_SIZE) <= 0) {
2529             SLOGE("Error writing final sectors to crypto_blkdev %s for inplace encrypt", crypto_blkdev);
2530             goto errout;
2531         } else {
2532             SLOGI("Encrypted 1 block at next location");
2533         }
2534     }
2535
2536     *size_already_done += size;
2537     rc = 0;
2538
2539 errout:
2540     close(realfd);
2541     close(cryptofd);
2542
2543     return rc;
2544 }
2545
2546 /* returns on of the ENABLE_INPLACE_* return codes */
2547 static int cryptfs_enable_inplace(char *crypto_blkdev, char *real_blkdev,
2548                                   off64_t size, off64_t *size_already_done,
2549                                   off64_t tot_size,
2550                                   off64_t previously_encrypted_upto)
2551 {
2552     int rc_ext4, rc_f2fs, rc_full;
2553     if (previously_encrypted_upto) {
2554         SLOGD("Continuing encryption from %" PRId64, previously_encrypted_upto);
2555     }
2556
2557     if (*size_already_done + size < previously_encrypted_upto) {
2558         *size_already_done += size;
2559         return 0;
2560     }
2561
2562     /* TODO: identify filesystem type.
2563      * As is, cryptfs_enable_inplace_ext4 will fail on an f2fs partition, and
2564      * then we will drop down to cryptfs_enable_inplace_f2fs.
2565      * */
2566     if ((rc_ext4 = cryptfs_enable_inplace_ext4(crypto_blkdev, real_blkdev,
2567                                 size, size_already_done,
2568                                 tot_size, previously_encrypted_upto)) == 0) {
2569       return 0;
2570     }
2571     SLOGD("cryptfs_enable_inplace_ext4()=%d\n", rc_ext4);
2572
2573     if ((rc_f2fs = cryptfs_enable_inplace_f2fs(crypto_blkdev, real_blkdev,
2574                                 size, size_already_done,
2575                                 tot_size, previously_encrypted_upto)) == 0) {
2576       return 0;
2577     }
2578     SLOGD("cryptfs_enable_inplace_f2fs()=%d\n", rc_f2fs);
2579
2580     rc_full = cryptfs_enable_inplace_full(crypto_blkdev, real_blkdev,
2581                                        size, size_already_done, tot_size,
2582                                        previously_encrypted_upto);
2583     SLOGD("cryptfs_enable_inplace_full()=%d\n", rc_full);
2584
2585     /* Hack for b/17898962, the following is the symptom... */
2586     if (rc_ext4 == ENABLE_INPLACE_ERR_DEV
2587         && rc_f2fs == ENABLE_INPLACE_ERR_DEV
2588         && rc_full == ENABLE_INPLACE_ERR_DEV) {
2589             return ENABLE_INPLACE_ERR_DEV;
2590     }
2591     return rc_full;
2592 }
2593
2594 #define CRYPTO_ENABLE_WIPE 1
2595 #define CRYPTO_ENABLE_INPLACE 2
2596
2597 #define FRAMEWORK_BOOT_WAIT 60
2598
2599 static int cryptfs_SHA256_fileblock(const char* filename, __le8* buf)
2600 {
2601     int fd = open(filename, O_RDONLY|O_CLOEXEC);
2602     if (fd == -1) {
2603         SLOGE("Error opening file %s", filename);
2604         return -1;
2605     }
2606
2607     char block[CRYPT_INPLACE_BUFSIZE];
2608     memset(block, 0, sizeof(block));
2609     if (unix_read(fd, block, sizeof(block)) < 0) {
2610         SLOGE("Error reading file %s", filename);
2611         close(fd);
2612         return -1;
2613     }
2614
2615     close(fd);
2616
2617     SHA256_CTX c;
2618     SHA256_Init(&c);
2619     SHA256_Update(&c, block, sizeof(block));
2620     SHA256_Final(buf, &c);
2621
2622     return 0;
2623 }
2624
2625 static int get_fs_type(struct fstab_rec *rec)
2626 {
2627     if (!strcmp(rec->fs_type, "ext4")) {
2628         return EXT4_FS;
2629     } else if (!strcmp(rec->fs_type, "f2fs")) {
2630         return F2FS_FS;
2631     } else {
2632         return -1;
2633     }
2634 }
2635
2636 static int cryptfs_enable_all_volumes(struct crypt_mnt_ftr *crypt_ftr, int how,
2637                                       char *crypto_blkdev, char *real_blkdev,
2638                                       int previously_encrypted_upto)
2639 {
2640     off64_t cur_encryption_done=0, tot_encryption_size=0;
2641     int rc = -1;
2642
2643     if (!is_battery_ok_to_start()) {
2644         SLOGW("Not starting encryption due to low battery");
2645         return 0;
2646     }
2647
2648     /* The size of the userdata partition, and add in the vold volumes below */
2649     tot_encryption_size = crypt_ftr->fs_size;
2650
2651     if (how == CRYPTO_ENABLE_WIPE) {
2652         struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, DATA_MNT_POINT);
2653         int fs_type = get_fs_type(rec);
2654         if (fs_type < 0) {
2655             SLOGE("cryptfs_enable: unsupported fs type %s\n", rec->fs_type);
2656             return -1;
2657         }
2658         rc = cryptfs_enable_wipe(crypto_blkdev, crypt_ftr->fs_size, fs_type);
2659     } else if (how == CRYPTO_ENABLE_INPLACE) {
2660         rc = cryptfs_enable_inplace(crypto_blkdev, real_blkdev,
2661                                     crypt_ftr->fs_size, &cur_encryption_done,
2662                                     tot_encryption_size,
2663                                     previously_encrypted_upto);
2664
2665         if (rc == ENABLE_INPLACE_ERR_DEV) {
2666             /* Hack for b/17898962 */
2667             SLOGE("cryptfs_enable: crypto block dev failure. Must reboot...\n");
2668             cryptfs_reboot(reboot);
2669         }
2670
2671         if (!rc) {
2672             crypt_ftr->encrypted_upto = cur_encryption_done;
2673         }
2674
2675         if (!rc && crypt_ftr->encrypted_upto == crypt_ftr->fs_size) {
2676             /* The inplace routine never actually sets the progress to 100% due
2677              * to the round down nature of integer division, so set it here */
2678             property_set("vold.encrypt_progress", "100");
2679         }
2680     } else {
2681         /* Shouldn't happen */
2682         SLOGE("cryptfs_enable: internal error, unknown option\n");
2683         rc = -1;
2684     }
2685
2686     return rc;
2687 }
2688
2689 int cryptfs_enable_internal(char *howarg, int crypt_type, char *passwd,
2690                             int no_ui)
2691 {
2692     int how = 0;
2693     char crypto_blkdev[MAXPATHLEN], real_blkdev[MAXPATHLEN];
2694     unsigned char decrypted_master_key[KEY_LEN_BYTES];
2695     int rc=-1, i;
2696     struct crypt_mnt_ftr crypt_ftr;
2697     struct crypt_persist_data *pdata;
2698     char encrypted_state[PROPERTY_VALUE_MAX];
2699     char lockid[32] = { 0 };
2700     char key_loc[PROPERTY_VALUE_MAX];
2701     int num_vols;
2702     off64_t previously_encrypted_upto = 0;
2703     bool rebootEncryption = false;
2704
2705     if (!strcmp(howarg, "wipe")) {
2706       how = CRYPTO_ENABLE_WIPE;
2707     } else if (! strcmp(howarg, "inplace")) {
2708       how = CRYPTO_ENABLE_INPLACE;
2709     } else {
2710       /* Shouldn't happen, as CommandListener vets the args */
2711       goto error_unencrypted;
2712     }
2713
2714     if (how == CRYPTO_ENABLE_INPLACE
2715           && get_crypt_ftr_and_key(&crypt_ftr) == 0) {
2716         if (crypt_ftr.flags & CRYPT_ENCRYPTION_IN_PROGRESS) {
2717             /* An encryption was underway and was interrupted */
2718             previously_encrypted_upto = crypt_ftr.encrypted_upto;
2719             crypt_ftr.encrypted_upto = 0;
2720             crypt_ftr.flags &= ~CRYPT_ENCRYPTION_IN_PROGRESS;
2721
2722             /* At this point, we are in an inconsistent state. Until we successfully
2723                complete encryption, a reboot will leave us broken. So mark the
2724                encryption failed in case that happens.
2725                On successfully completing encryption, remove this flag */
2726             crypt_ftr.flags |= CRYPT_INCONSISTENT_STATE;
2727
2728             put_crypt_ftr_and_key(&crypt_ftr);
2729         } else if (crypt_ftr.flags & CRYPT_FORCE_ENCRYPTION) {
2730             if (!check_ftr_sha(&crypt_ftr)) {
2731                 memset(&crypt_ftr, 0, sizeof(crypt_ftr));
2732                 put_crypt_ftr_and_key(&crypt_ftr);
2733                 goto error_unencrypted;
2734             }
2735
2736             /* Doing a reboot-encryption*/
2737             crypt_ftr.flags &= ~CRYPT_FORCE_ENCRYPTION;
2738             crypt_ftr.flags |= CRYPT_FORCE_COMPLETE;
2739             rebootEncryption = true;
2740         }
2741     }
2742
2743     property_get("ro.crypto.state", encrypted_state, "");
2744     if (!strcmp(encrypted_state, "encrypted") && !previously_encrypted_upto) {
2745         SLOGE("Device is already running encrypted, aborting");
2746         goto error_unencrypted;
2747     }
2748
2749     // TODO refactor fs_mgr_get_crypt_info to get both in one call
2750     fs_mgr_get_crypt_info(fstab, key_loc, 0, sizeof(key_loc));
2751     fs_mgr_get_crypt_info(fstab, 0, real_blkdev, sizeof(real_blkdev));
2752
2753     /* Get the size of the real block device */
2754     int fd = open(real_blkdev, O_RDONLY|O_CLOEXEC);
2755     if (fd == -1) {
2756         SLOGE("Cannot open block device %s\n", real_blkdev);
2757         goto error_unencrypted;
2758     }
2759     unsigned long nr_sec;
2760     get_blkdev_size(fd, &nr_sec);
2761     if (nr_sec == 0) {
2762         SLOGE("Cannot get size of block device %s\n", real_blkdev);
2763         goto error_unencrypted;
2764     }
2765     close(fd);
2766
2767     /* If doing inplace encryption, make sure the orig fs doesn't include the crypto footer */
2768     if ((how == CRYPTO_ENABLE_INPLACE) && (!strcmp(key_loc, KEY_IN_FOOTER))) {
2769         unsigned int fs_size_sec, max_fs_size_sec;
2770         fs_size_sec = get_fs_size(real_blkdev);
2771         if (fs_size_sec == 0)
2772             fs_size_sec = get_f2fs_filesystem_size_sec(real_blkdev);
2773
2774         max_fs_size_sec = nr_sec - (CRYPT_FOOTER_OFFSET / CRYPT_SECTOR_SIZE);
2775
2776         if (fs_size_sec > max_fs_size_sec) {
2777             SLOGE("Orig filesystem overlaps crypto footer region.  Cannot encrypt in place.");
2778             goto error_unencrypted;
2779         }
2780     }
2781
2782     /* Get a wakelock as this may take a while, and we don't want the
2783      * device to sleep on us.  We'll grab a partial wakelock, and if the UI
2784      * wants to keep the screen on, it can grab a full wakelock.
2785      */
2786     snprintf(lockid, sizeof(lockid), "enablecrypto%d", (int) getpid());
2787     acquire_wake_lock(PARTIAL_WAKE_LOCK, lockid);
2788
2789     /* The init files are setup to stop the class main and late start when
2790      * vold sets trigger_shutdown_framework.
2791      */
2792     property_set("vold.decrypt", "trigger_shutdown_framework");
2793     SLOGD("Just asked init to shut down class main\n");
2794
2795     /* Ask vold to unmount all devices that it manages */
2796     if (vold_unmountAll()) {
2797         SLOGE("Failed to unmount all vold managed devices");
2798     }
2799
2800     /* no_ui means we are being called from init, not settings.
2801        Now we always reboot from settings, so !no_ui means reboot
2802      */
2803     bool onlyCreateHeader = false;
2804     if (!no_ui) {
2805         /* Try fallback, which is to reboot and try there */
2806         onlyCreateHeader = true;
2807         FILE* breadcrumb = fopen(BREADCRUMB_FILE, "we");
2808         if (breadcrumb == 0) {
2809             SLOGE("Failed to create breadcrumb file");
2810             goto error_shutting_down;
2811         }
2812         fclose(breadcrumb);
2813     }
2814
2815     /* Do extra work for a better UX when doing the long inplace encryption */
2816     if (how == CRYPTO_ENABLE_INPLACE && !onlyCreateHeader) {
2817         /* Now that /data is unmounted, we need to mount a tmpfs
2818          * /data, set a property saying we're doing inplace encryption,
2819          * and restart the framework.
2820          */
2821         if (fs_mgr_do_tmpfs_mount(DATA_MNT_POINT)) {
2822             goto error_shutting_down;
2823         }
2824         /* Tells the framework that inplace encryption is starting */
2825         property_set("vold.encrypt_progress", "0");
2826
2827         /* restart the framework. */
2828         /* Create necessary paths on /data */
2829         if (prep_data_fs()) {
2830             goto error_shutting_down;
2831         }
2832
2833         /* Ugh, shutting down the framework is not synchronous, so until it
2834          * can be fixed, this horrible hack will wait a moment for it all to
2835          * shut down before proceeding.  Without it, some devices cannot
2836          * restart the graphics services.
2837          */
2838         sleep(2);
2839     }
2840
2841     /* Start the actual work of making an encrypted filesystem */
2842     /* Initialize a crypt_mnt_ftr for the partition */
2843     if (previously_encrypted_upto == 0 && !rebootEncryption) {
2844         if (cryptfs_init_crypt_mnt_ftr(&crypt_ftr)) {
2845             goto error_shutting_down;
2846         }
2847
2848         if (!strcmp(key_loc, KEY_IN_FOOTER)) {
2849             crypt_ftr.fs_size = nr_sec
2850               - (CRYPT_FOOTER_OFFSET / CRYPT_SECTOR_SIZE);
2851         } else {
2852             crypt_ftr.fs_size = nr_sec;
2853         }
2854         /* At this point, we are in an inconsistent state. Until we successfully
2855            complete encryption, a reboot will leave us broken. So mark the
2856            encryption failed in case that happens.
2857            On successfully completing encryption, remove this flag */
2858         if (onlyCreateHeader) {
2859             crypt_ftr.flags |= CRYPT_FORCE_ENCRYPTION;
2860         } else {
2861             crypt_ftr.flags |= CRYPT_INCONSISTENT_STATE;
2862         }
2863         crypt_ftr.crypt_type = crypt_type;
2864         strlcpy((char *)crypt_ftr.crypto_type_name, "aes-cbc-essiv:sha256", MAX_CRYPTO_TYPE_NAME_LEN);
2865
2866         /* Make an encrypted master key */
2867         if (create_encrypted_random_key(onlyCreateHeader ? DEFAULT_PASSWORD : passwd,
2868                                         crypt_ftr.master_key, crypt_ftr.salt, &crypt_ftr)) {
2869             SLOGE("Cannot create encrypted master key\n");
2870             goto error_shutting_down;
2871         }
2872
2873         /* Replace scrypted intermediate key if we are preparing for a reboot */
2874         if (onlyCreateHeader) {
2875             unsigned char fake_master_key[KEY_LEN_BYTES];
2876             unsigned char encrypted_fake_master_key[KEY_LEN_BYTES];
2877             memset(fake_master_key, 0, sizeof(fake_master_key));
2878             encrypt_master_key(passwd, crypt_ftr.salt, fake_master_key,
2879                                encrypted_fake_master_key, &crypt_ftr);
2880         }
2881
2882         /* Write the key to the end of the partition */
2883         put_crypt_ftr_and_key(&crypt_ftr);
2884
2885         /* If any persistent data has been remembered, save it.
2886          * If none, create a valid empty table and save that.
2887          */
2888         if (!persist_data) {
2889            pdata = malloc(CRYPT_PERSIST_DATA_SIZE);
2890            if (pdata) {
2891                init_empty_persist_data(pdata, CRYPT_PERSIST_DATA_SIZE);
2892                persist_data = pdata;
2893            }
2894         }
2895         if (persist_data) {
2896             save_persistent_data();
2897         }
2898     }
2899
2900     if (onlyCreateHeader) {
2901         sleep(2);
2902         cryptfs_reboot(reboot);
2903     }
2904
2905     if (how == CRYPTO_ENABLE_INPLACE && (!no_ui || rebootEncryption)) {
2906         /* startup service classes main and late_start */
2907         property_set("vold.decrypt", "trigger_restart_min_framework");
2908         SLOGD("Just triggered restart_min_framework\n");
2909
2910         /* OK, the framework is restarted and will soon be showing a
2911          * progress bar.  Time to setup an encrypted mapping, and
2912          * either write a new filesystem, or encrypt in place updating
2913          * the progress bar as we work.
2914          */
2915     }
2916
2917     decrypt_master_key(passwd, decrypted_master_key, &crypt_ftr, 0, 0);
2918     create_crypto_blk_dev(&crypt_ftr, decrypted_master_key, real_blkdev, crypto_blkdev,
2919                           CRYPTO_BLOCK_DEVICE);
2920
2921     /* If we are continuing, check checksums match */
2922     rc = 0;
2923     if (previously_encrypted_upto) {
2924         __le8 hash_first_block[SHA256_DIGEST_LENGTH];
2925         rc = cryptfs_SHA256_fileblock(crypto_blkdev, hash_first_block);
2926
2927         if (!rc && memcmp(hash_first_block, crypt_ftr.hash_first_block,
2928                           sizeof(hash_first_block)) != 0) {
2929             SLOGE("Checksums do not match - trigger wipe");
2930             rc = -1;
2931         }
2932     }
2933
2934     if (!rc) {
2935         rc = cryptfs_enable_all_volumes(&crypt_ftr, how,
2936                                         crypto_blkdev, real_blkdev,
2937                                         previously_encrypted_upto);
2938     }
2939
2940     /* Calculate checksum if we are not finished */
2941     if (!rc && how == CRYPTO_ENABLE_INPLACE
2942             && crypt_ftr.encrypted_upto != crypt_ftr.fs_size) {
2943         rc = cryptfs_SHA256_fileblock(crypto_blkdev,
2944                                       crypt_ftr.hash_first_block);
2945         if (rc) {
2946             SLOGE("Error calculating checksum for continuing encryption");
2947             rc = -1;
2948         }
2949     }
2950
2951     /* Undo the dm-crypt mapping whether we succeed or not */
2952     delete_crypto_blk_dev(CRYPTO_BLOCK_DEVICE);
2953
2954     if (! rc) {
2955         /* Success */
2956         crypt_ftr.flags &= ~CRYPT_INCONSISTENT_STATE;
2957
2958         if (how == CRYPTO_ENABLE_INPLACE
2959               && crypt_ftr.encrypted_upto != crypt_ftr.fs_size) {
2960             SLOGD("Encrypted up to sector %lld - will continue after reboot",
2961                   crypt_ftr.encrypted_upto);
2962             crypt_ftr.flags |= CRYPT_ENCRYPTION_IN_PROGRESS;
2963         }
2964
2965         put_crypt_ftr_and_key(&crypt_ftr);
2966
2967         if (how == CRYPTO_ENABLE_WIPE
2968               || crypt_ftr.encrypted_upto == crypt_ftr.fs_size) {
2969           char value[PROPERTY_VALUE_MAX];
2970           property_get("ro.crypto.state", value, "");
2971           if (!strcmp(value, "")) {
2972             /* default encryption - continue first boot sequence */
2973             property_set("ro.crypto.state", "encrypted");
2974             property_set("ro.crypto.type", "block");
2975             release_wake_lock(lockid);
2976             if (rebootEncryption && crypt_ftr.crypt_type != CRYPT_TYPE_DEFAULT) {
2977                 // Bring up cryptkeeper that will check the password and set it
2978                 property_set("vold.decrypt", "trigger_shutdown_framework");
2979                 sleep(2);
2980                 property_set("vold.encrypt_progress", "");
2981                 cryptfs_trigger_restart_min_framework();
2982             } else {
2983                 cryptfs_check_passwd(DEFAULT_PASSWORD);
2984                 cryptfs_restart_internal(1);
2985             }
2986             return 0;
2987           } else {
2988             sleep(2); /* Give the UI a chance to show 100% progress */
2989             cryptfs_reboot(reboot);
2990           }
2991         } else {
2992             sleep(2); /* Partially encrypted, ensure writes flushed to ssd */
2993             cryptfs_reboot(shutdown);
2994         }
2995     } else {
2996         char value[PROPERTY_VALUE_MAX];
2997
2998         property_get("ro.vold.wipe_on_crypt_fail", value, "0");
2999         if (!strcmp(value, "1")) {
3000             /* wipe data if encryption failed */
3001             SLOGE("encryption failed - rebooting into recovery to wipe data\n");
3002             if (!write_bootloader_message("--wipe_data\n--reason=cryptfs_enable_internal\n")) {
3003                 SLOGE("could not write bootloader message\n");
3004             }
3005             cryptfs_reboot(recovery);
3006         } else {
3007             /* set property to trigger dialog */
3008             property_set("vold.encrypt_progress", "error_partially_encrypted");
3009             release_wake_lock(lockid);
3010         }
3011         return -1;
3012     }
3013
3014     /* hrm, the encrypt step claims success, but the reboot failed.
3015      * This should not happen.
3016      * Set the property and return.  Hope the framework can deal with it.
3017      */
3018     property_set("vold.encrypt_progress", "error_reboot_failed");
3019     release_wake_lock(lockid);
3020     return rc;
3021
3022 error_unencrypted:
3023     property_set("vold.encrypt_progress", "error_not_encrypted");
3024     if (lockid[0]) {
3025         release_wake_lock(lockid);
3026     }
3027     return -1;
3028
3029 error_shutting_down:
3030     /* we failed, and have not encrypted anthing, so the users's data is still intact,
3031      * but the framework is stopped and not restarted to show the error, so it's up to
3032      * vold to restart the system.
3033      */
3034     SLOGE("Error enabling encryption after framework is shutdown, no data changed, restarting system");
3035     cryptfs_reboot(reboot);
3036
3037     /* shouldn't get here */
3038     property_set("vold.encrypt_progress", "error_shutting_down");
3039     if (lockid[0]) {
3040         release_wake_lock(lockid);
3041     }
3042     return -1;
3043 }
3044
3045 int cryptfs_enable(char *howarg, int type, char *passwd, int no_ui)
3046 {
3047     return cryptfs_enable_internal(howarg, type, passwd, no_ui);
3048 }
3049
3050 int cryptfs_enable_default(char *howarg, int no_ui)
3051 {
3052     return cryptfs_enable_internal(howarg, CRYPT_TYPE_DEFAULT,
3053                           DEFAULT_PASSWORD, no_ui);
3054 }
3055
3056 int cryptfs_changepw(int crypt_type, const char *newpw)
3057 {
3058     if (e4crypt_is_native()) {
3059         SLOGE("cryptfs_changepw not valid for file encryption");
3060         return -1;
3061     }
3062
3063     struct crypt_mnt_ftr crypt_ftr;
3064     int rc;
3065
3066     /* This is only allowed after we've successfully decrypted the master key */
3067     if (!master_key_saved) {
3068         SLOGE("Key not saved, aborting");
3069         return -1;
3070     }
3071
3072     if (crypt_type < 0 || crypt_type > CRYPT_TYPE_MAX_TYPE) {
3073         SLOGE("Invalid crypt_type %d", crypt_type);
3074         return -1;
3075     }
3076
3077     /* get key */
3078     if (get_crypt_ftr_and_key(&crypt_ftr)) {
3079         SLOGE("Error getting crypt footer and key");
3080         return -1;
3081     }
3082
3083     crypt_ftr.crypt_type = crypt_type;
3084
3085     rc = encrypt_master_key(crypt_type == CRYPT_TYPE_DEFAULT ? DEFAULT_PASSWORD
3086                                                         : newpw,
3087                        crypt_ftr.salt,
3088                        saved_master_key,
3089                        crypt_ftr.master_key,
3090                        &crypt_ftr);
3091     if (rc) {
3092         SLOGE("Encrypt master key failed: %d", rc);
3093         return -1;
3094     }
3095     /* save the key */
3096     put_crypt_ftr_and_key(&crypt_ftr);
3097
3098     return 0;
3099 }
3100
3101 static unsigned int persist_get_max_entries(int encrypted) {
3102     struct crypt_mnt_ftr crypt_ftr;
3103     unsigned int dsize;
3104     unsigned int max_persistent_entries;
3105
3106     /* If encrypted, use the values from the crypt_ftr, otherwise
3107      * use the values for the current spec.
3108      */
3109     if (encrypted) {
3110         if (get_crypt_ftr_and_key(&crypt_ftr)) {
3111             return -1;
3112         }
3113         dsize = crypt_ftr.persist_data_size;
3114     } else {
3115         dsize = CRYPT_PERSIST_DATA_SIZE;
3116     }
3117
3118     max_persistent_entries = (dsize - sizeof(struct crypt_persist_data)) /
3119         sizeof(struct crypt_persist_entry);
3120
3121     return max_persistent_entries;
3122 }
3123
3124 static int persist_get_key(const char *fieldname, char *value)
3125 {
3126     unsigned int i;
3127
3128     if (persist_data == NULL) {
3129         return -1;
3130     }
3131     for (i = 0; i < persist_data->persist_valid_entries; i++) {
3132         if (!strncmp(persist_data->persist_entry[i].key, fieldname, PROPERTY_KEY_MAX)) {
3133             /* We found it! */
3134             strlcpy(value, persist_data->persist_entry[i].val, PROPERTY_VALUE_MAX);
3135             return 0;
3136         }
3137     }
3138
3139     return -1;
3140 }
3141
3142 static int persist_set_key(const char *fieldname, const char *value, int encrypted)
3143 {
3144     unsigned int i;
3145     unsigned int num;
3146     unsigned int max_persistent_entries;
3147
3148     if (persist_data == NULL) {
3149         return -1;
3150     }
3151
3152     max_persistent_entries = persist_get_max_entries(encrypted);
3153
3154     num = persist_data->persist_valid_entries;
3155
3156     for (i = 0; i < num; i++) {
3157         if (!strncmp(persist_data->persist_entry[i].key, fieldname, PROPERTY_KEY_MAX)) {
3158             /* We found an existing entry, update it! */
3159             memset(persist_data->persist_entry[i].val, 0, PROPERTY_VALUE_MAX);
3160             strlcpy(persist_data->persist_entry[i].val, value, PROPERTY_VALUE_MAX);
3161             return 0;
3162         }
3163     }
3164
3165     /* We didn't find it, add it to the end, if there is room */
3166     if (persist_data->persist_valid_entries < max_persistent_entries) {
3167         memset(&persist_data->persist_entry[num], 0, sizeof(struct crypt_persist_entry));
3168         strlcpy(persist_data->persist_entry[num].key, fieldname, PROPERTY_KEY_MAX);
3169         strlcpy(persist_data->persist_entry[num].val, value, PROPERTY_VALUE_MAX);
3170         persist_data->persist_valid_entries++;
3171         return 0;
3172     }
3173
3174     return -1;
3175 }
3176
3177 /**
3178  * Test if key is part of the multi-entry (field, index) sequence. Return non-zero if key is in the
3179  * sequence and its index is greater than or equal to index. Return 0 otherwise.
3180  */
3181 static int match_multi_entry(const char *key, const char *field, unsigned index) {
3182     unsigned int field_len;
3183     unsigned int key_index;
3184     field_len = strlen(field);
3185
3186     if (index == 0) {
3187         // The first key in a multi-entry field is just the filedname itself.
3188         if (!strcmp(key, field)) {
3189             return 1;
3190         }
3191     }
3192     // Match key against "%s_%d" % (field, index)
3193     if (strlen(key) < field_len + 1 + 1) {
3194         // Need at least a '_' and a digit.
3195         return 0;
3196     }
3197     if (strncmp(key, field, field_len)) {
3198         // If the key does not begin with field, it's not a match.
3199         return 0;
3200     }
3201     if (1 != sscanf(&key[field_len],"_%d", &key_index)) {
3202         return 0;
3203     }
3204     return key_index >= index;
3205 }
3206
3207 /*
3208  * Delete entry/entries from persist_data. If the entries are part of a multi-segment field, all
3209  * remaining entries starting from index will be deleted.
3210  * returns PERSIST_DEL_KEY_OK if deletion succeeds,
3211  * PERSIST_DEL_KEY_ERROR_NO_FIELD if the field does not exist,
3212  * and PERSIST_DEL_KEY_ERROR_OTHER if error occurs.
3213  *
3214  */
3215 static int persist_del_keys(const char *fieldname, unsigned index)
3216 {
3217     unsigned int i;
3218     unsigned int j;
3219     unsigned int num;
3220
3221     if (persist_data == NULL) {
3222         return PERSIST_DEL_KEY_ERROR_OTHER;
3223     }
3224
3225     num = persist_data->persist_valid_entries;
3226
3227     j = 0; // points to the end of non-deleted entries.
3228     // Filter out to-be-deleted entries in place.
3229     for (i = 0; i < num; i++) {
3230         if (!match_multi_entry(persist_data->persist_entry[i].key, fieldname, index)) {
3231             persist_data->persist_entry[j] = persist_data->persist_entry[i];
3232             j++;
3233         }
3234     }
3235
3236     if (j < num) {
3237         persist_data->persist_valid_entries = j;
3238         // Zeroise the remaining entries
3239         memset(&persist_data->persist_entry[j], 0, (num - j) * sizeof(struct crypt_persist_entry));
3240         return PERSIST_DEL_KEY_OK;
3241     } else {
3242         // Did not find an entry matching the given fieldname
3243         return PERSIST_DEL_KEY_ERROR_NO_FIELD;
3244     }
3245 }
3246
3247 static int persist_count_keys(const char *fieldname)
3248 {
3249     unsigned int i;
3250     unsigned int count;
3251
3252     if (persist_data == NULL) {
3253         return -1;
3254     }
3255
3256     count = 0;
3257     for (i = 0; i < persist_data->persist_valid_entries; i++) {
3258         if (match_multi_entry(persist_data->persist_entry[i].key, fieldname, 0)) {
3259             count++;
3260         }
3261     }
3262
3263     return count;
3264 }
3265
3266 /* Return the value of the specified field. */
3267 int cryptfs_getfield(const char *fieldname, char *value, int len)
3268 {
3269     if (e4crypt_is_native()) {
3270         SLOGE("Cannot get field when file encrypted");
3271         return -1;
3272     }
3273
3274     char temp_value[PROPERTY_VALUE_MAX];
3275     /* CRYPTO_GETFIELD_OK is success,
3276      * CRYPTO_GETFIELD_ERROR_NO_FIELD is value not set,
3277      * CRYPTO_GETFIELD_ERROR_BUF_TOO_SMALL is buffer (as given by len) too small,
3278      * CRYPTO_GETFIELD_ERROR_OTHER is any other error
3279      */
3280     int rc = CRYPTO_GETFIELD_ERROR_OTHER;
3281     int i;
3282     char temp_field[PROPERTY_KEY_MAX];
3283
3284     if (persist_data == NULL) {
3285         load_persistent_data();
3286         if (persist_data == NULL) {
3287             SLOGE("Getfield error, cannot load persistent data");
3288             goto out;
3289         }
3290     }
3291
3292     // Read value from persistent entries. If the original value is split into multiple entries,
3293     // stitch them back together.
3294     if (!persist_get_key(fieldname, temp_value)) {
3295         // We found it, copy it to the caller's buffer and keep going until all entries are read.
3296         if (strlcpy(value, temp_value, len) >= (unsigned) len) {
3297             // value too small
3298             rc = CRYPTO_GETFIELD_ERROR_BUF_TOO_SMALL;
3299             goto out;
3300         }
3301         rc = CRYPTO_GETFIELD_OK;
3302
3303         for (i = 1; /* break explicitly */; i++) {
3304             if (snprintf(temp_field, sizeof(temp_field), "%s_%d", fieldname, i) >=
3305                     (int) sizeof(temp_field)) {
3306                 // If the fieldname is very long, we stop as soon as it begins to overflow the
3307                 // maximum field length. At this point we have in fact fully read out the original
3308                 // value because cryptfs_setfield would not allow fields with longer names to be
3309                 // written in the first place.
3310                 break;
3311             }
3312             if (!persist_get_key(temp_field, temp_value)) {
3313                   if (strlcat(value, temp_value, len) >= (unsigned)len) {
3314                       // value too small.
3315                       rc = CRYPTO_GETFIELD_ERROR_BUF_TOO_SMALL;
3316                       goto out;
3317                   }
3318             } else {
3319                 // Exhaust all entries.
3320                 break;
3321             }
3322         }
3323     } else {
3324         /* Sadness, it's not there.  Return the error */
3325         rc = CRYPTO_GETFIELD_ERROR_NO_FIELD;
3326     }
3327
3328 out:
3329     return rc;
3330 }
3331
3332 /* Set the value of the specified field. */
3333 int cryptfs_setfield(const char *fieldname, const char *value)
3334 {
3335     if (e4crypt_is_native()) {
3336         SLOGE("Cannot set field when file encrypted");
3337         return -1;
3338     }
3339
3340     char encrypted_state[PROPERTY_VALUE_MAX];
3341     /* 0 is success, negative values are error */
3342     int rc = CRYPTO_SETFIELD_ERROR_OTHER;
3343     int encrypted = 0;
3344     unsigned int field_id;
3345     char temp_field[PROPERTY_KEY_MAX];
3346     unsigned int num_entries;
3347     unsigned int max_keylen;
3348
3349     if (persist_data == NULL) {
3350         load_persistent_data();
3351         if (persist_data == NULL) {
3352             SLOGE("Setfield error, cannot load persistent data");
3353             goto out;
3354         }
3355     }
3356
3357     property_get("ro.crypto.state", encrypted_state, "");
3358     if (!strcmp(encrypted_state, "encrypted") ) {
3359         encrypted = 1;
3360     }
3361
3362     // Compute the number of entries required to store value, each entry can store up to
3363     // (PROPERTY_VALUE_MAX - 1) chars
3364     if (strlen(value) == 0) {
3365         // Empty value also needs one entry to store.
3366         num_entries = 1;
3367     } else {
3368         num_entries = (strlen(value) + (PROPERTY_VALUE_MAX - 1) - 1) / (PROPERTY_VALUE_MAX - 1);
3369     }
3370
3371     max_keylen = strlen(fieldname);
3372     if (num_entries > 1) {
3373         // Need an extra "_%d" suffix.
3374         max_keylen += 1 + log10(num_entries);
3375     }
3376     if (max_keylen > PROPERTY_KEY_MAX - 1) {
3377         rc = CRYPTO_SETFIELD_ERROR_FIELD_TOO_LONG;
3378         goto out;
3379     }
3380
3381     // Make sure we have enough space to write the new value
3382     if (persist_data->persist_valid_entries + num_entries - persist_count_keys(fieldname) >
3383         persist_get_max_entries(encrypted)) {
3384         rc = CRYPTO_SETFIELD_ERROR_VALUE_TOO_LONG;
3385         goto out;
3386     }
3387
3388     // Now that we know persist_data has enough space for value, let's delete the old field first
3389     // to make up space.
3390     persist_del_keys(fieldname, 0);
3391
3392     if (persist_set_key(fieldname, value, encrypted)) {
3393         // fail to set key, should not happen as we have already checked the available space
3394         SLOGE("persist_set_key() error during setfield()");
3395         goto out;
3396     }
3397
3398     for (field_id = 1; field_id < num_entries; field_id++) {
3399         snprintf(temp_field, sizeof(temp_field), "%s_%d", fieldname, field_id);
3400
3401         if (persist_set_key(temp_field, value + field_id * (PROPERTY_VALUE_MAX - 1), encrypted)) {
3402             // fail to set key, should not happen as we have already checked the available space.
3403             SLOGE("persist_set_key() error during setfield()");
3404             goto out;
3405         }
3406     }
3407
3408     /* If we are running encrypted, save the persistent data now */
3409     if (encrypted) {
3410         if (save_persistent_data()) {
3411             SLOGE("Setfield error, cannot save persistent data");
3412             goto out;
3413         }
3414     }
3415
3416     rc = CRYPTO_SETFIELD_OK;
3417
3418 out:
3419     return rc;
3420 }
3421
3422 /* Checks userdata. Attempt to mount the volume if default-
3423  * encrypted.
3424  * On success trigger next init phase and return 0.
3425  * Currently do not handle failure - see TODO below.
3426  */
3427 int cryptfs_mount_default_encrypted(void)
3428 {
3429     int crypt_type = cryptfs_get_password_type();
3430     if (crypt_type < 0 || crypt_type > CRYPT_TYPE_MAX_TYPE) {
3431         SLOGE("Bad crypt type - error");
3432     } else if (crypt_type != CRYPT_TYPE_DEFAULT) {
3433         SLOGD("Password is not default - "
3434               "starting min framework to prompt");
3435         property_set("vold.decrypt", "trigger_restart_min_framework");
3436         return 0;
3437     } else if (cryptfs_check_passwd(DEFAULT_PASSWORD) == 0) {
3438         SLOGD("Password is default - restarting filesystem");
3439         cryptfs_restart_internal(0);
3440         return 0;
3441     } else {
3442         SLOGE("Encrypted, default crypt type but can't decrypt");
3443     }
3444
3445     /** Corrupt. Allow us to boot into framework, which will detect bad
3446         crypto when it calls do_crypto_complete, then do a factory reset
3447      */
3448     property_set("vold.decrypt", "trigger_restart_min_framework");
3449     return 0;
3450 }
3451
3452 /* Returns type of the password, default, pattern, pin or password.
3453  */
3454 int cryptfs_get_password_type(void)
3455 {
3456     if (e4crypt_is_native()) {
3457         SLOGE("cryptfs_get_password_type not valid for file encryption");
3458         return -1;
3459     }
3460
3461     struct crypt_mnt_ftr crypt_ftr;
3462
3463     if (get_crypt_ftr_and_key(&crypt_ftr)) {
3464         SLOGE("Error getting crypt footer and key\n");
3465         return -1;
3466     }
3467
3468     if (crypt_ftr.flags & CRYPT_INCONSISTENT_STATE) {
3469         return -1;
3470     }
3471
3472     return crypt_ftr.crypt_type;
3473 }
3474
3475 const char* cryptfs_get_password()
3476 {
3477     if (e4crypt_is_native()) {
3478         SLOGE("cryptfs_get_password not valid for file encryption");
3479         return 0;
3480     }
3481
3482     struct timespec now;
3483     clock_gettime(CLOCK_BOOTTIME, &now);
3484     if (now.tv_sec < password_expiry_time) {
3485         return password;
3486     } else {
3487         cryptfs_clear_password();
3488         return 0;
3489     }
3490 }
3491
3492 void cryptfs_clear_password()
3493 {
3494     if (password) {
3495         size_t len = strlen(password);
3496         memset(password, 0, len);
3497         free(password);
3498         password = 0;
3499         password_expiry_time = 0;
3500     }
3501 }
3502
3503 int cryptfs_enable_file()
3504 {
3505     return e4crypt_initialize_global_de();
3506 }
3507
3508 int cryptfs_isConvertibleToFBE()
3509 {
3510     struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, DATA_MNT_POINT);
3511     return fs_mgr_is_convertible_to_fbe(rec) ? 1 : 0;
3512 }
3513
3514 int cryptfs_create_default_ftr(struct crypt_mnt_ftr* crypt_ftr, __attribute__((unused))int key_length)
3515 {
3516     if (cryptfs_init_crypt_mnt_ftr(crypt_ftr)) {
3517         SLOGE("Failed to initialize crypt_ftr");
3518         return -1;
3519     }
3520
3521     if (create_encrypted_random_key(DEFAULT_PASSWORD, crypt_ftr->master_key,
3522                                     crypt_ftr->salt, crypt_ftr)) {
3523         SLOGE("Cannot create encrypted master key\n");
3524         return -1;
3525     }
3526
3527     //crypt_ftr->keysize = key_length / 8;
3528     return 0;
3529 }
3530
3531 int cryptfs_get_master_key(struct crypt_mnt_ftr* ftr, const char* password,
3532                            unsigned char* master_key)
3533 {
3534     int rc;
3535
3536     unsigned char* intermediate_key = 0;
3537     size_t intermediate_key_size = 0;
3538
3539     if (password == 0 || *password == 0) {
3540         password = DEFAULT_PASSWORD;
3541     }
3542
3543     rc = decrypt_master_key(password, master_key, ftr, &intermediate_key,
3544                             &intermediate_key_size);
3545
3546     if (rc) {
3547         SLOGE("Can't calculate intermediate key");
3548         return rc;
3549     }
3550
3551     int N = 1 << ftr->N_factor;
3552     int r = 1 << ftr->r_factor;
3553     int p = 1 << ftr->p_factor;
3554
3555     unsigned char scrypted_intermediate_key[sizeof(ftr->scrypted_intermediate_key)];
3556
3557     rc = crypto_scrypt(intermediate_key, intermediate_key_size,
3558                        ftr->salt, sizeof(ftr->salt), N, r, p,
3559                        scrypted_intermediate_key,
3560                        sizeof(scrypted_intermediate_key));
3561
3562     free(intermediate_key);
3563
3564     if (rc) {
3565         SLOGE("Can't scrypt intermediate key");
3566         return rc;
3567     }
3568
3569     return memcmp(scrypted_intermediate_key, ftr->scrypted_intermediate_key,
3570                   intermediate_key_size);
3571 }
3572
3573 int cryptfs_set_password(struct crypt_mnt_ftr* ftr, const char* password,
3574                          const unsigned char* master_key)
3575 {
3576     return encrypt_master_key(password, ftr->salt, master_key, ftr->master_key,
3577                               ftr);
3578 }
3579
3580 void cryptfs_get_file_encryption_modes(const char **contents_mode_ret,
3581                                        const char **filenames_mode_ret)
3582 {
3583     struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, DATA_MNT_POINT);
3584     fs_mgr_get_file_encryption_modes(rec, contents_mode_ret, filenames_mode_ret);
3585 }