blob: 99f6069e3843fbbc8f9f3b8daed68241d5f6a73b [file] [log] [blame]
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001/*
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>
Ken Sumralle550f782013-08-20 13:48:23 -070024#include <sys/wait.h>
Ken Sumrall8f869aa2010-12-03 03:47:09 -080025#include <sys/stat.h>
26#include <fcntl.h>
Elliott Hughes73737162014-06-25 17:27:42 -070027#include <inttypes.h>
Ken Sumrall8f869aa2010-12-03 03:47:09 -080028#include <unistd.h>
29#include <stdio.h>
30#include <sys/ioctl.h>
31#include <linux/dm-ioctl.h>
32#include <libgen.h>
33#include <stdlib.h>
34#include <sys/param.h>
35#include <string.h>
36#include <sys/mount.h>
37#include <openssl/evp.h>
Ken Sumrall8ddbe402011-01-17 15:26:29 -080038#include <openssl/sha.h>
Ken Sumrall8f869aa2010-12-03 03:47:09 -080039#include <errno.h>
Ken Sumrall3ed82362011-01-28 23:31:16 -080040#include <ext4.h>
Ken Sumrall29d8da82011-05-18 17:20:07 -070041#include <linux/kdev_t.h>
Ken Sumralle5032c42012-04-01 23:58:44 -070042#include <fs_mgr.h>
Ken Sumrall8f869aa2010-12-03 03:47:09 -080043#include "cryptfs.h"
44#define LOG_TAG "Cryptfs"
45#include "cutils/log.h"
46#include "cutils/properties.h"
Ken Sumralladfba362013-06-04 16:37:52 -070047#include "cutils/android_reboot.h"
Ken Sumrall5d4c68e2011-01-30 19:06:03 -080048#include "hardware_legacy/power.h"
Ken Sumralle550f782013-08-20 13:48:23 -070049#include <logwrap/logwrap.h>
Ken Sumrall29d8da82011-05-18 17:20:07 -070050#include "VolumeManager.h"
Ken Sumrall9caab762013-06-11 19:10:20 -070051#include "VoldUtil.h"
Kenny Rootc4c70f12013-06-14 12:11:38 -070052#include "crypto_scrypt.h"
Ken Sumrall8f869aa2010-12-03 03:47:09 -080053
Mark Salyzyn5eecc442014-02-12 14:16:14 -080054#define UNUSED __attribute__((unused))
55
Ken Sumrall8f869aa2010-12-03 03:47:09 -080056#define DM_CRYPT_BUF_SIZE 4096
Ken Sumrall8ddbe402011-01-17 15:26:29 -080057#define DATA_MNT_POINT "/data"
Ken Sumrall8f869aa2010-12-03 03:47:09 -080058
Jason parks70a4b3f2011-01-28 10:10:47 -060059#define HASH_COUNT 2000
60#define KEY_LEN_BYTES 16
61#define IV_LEN_BYTES 16
62
Ken Sumrall29d8da82011-05-18 17:20:07 -070063#define KEY_IN_FOOTER "footer"
64
65#define EXT4_FS 1
66#define FAT_FS 2
67
Ken Sumralle919efe2012-09-29 17:07:41 -070068#define TABLE_LOAD_RETRIES 10
69
Ken Sumrall8f869aa2010-12-03 03:47:09 -080070char *me = "cryptfs";
71
Jason parks70a4b3f2011-01-28 10:10:47 -060072static unsigned char saved_master_key[KEY_LEN_BYTES];
Ken Sumrall3ad90722011-10-04 20:38:29 -070073static char *saved_mount_point;
Jason parks70a4b3f2011-01-28 10:10:47 -060074static int master_key_saved = 0;
Ken Sumrall160b4d62013-04-22 12:15:39 -070075static struct crypt_persist_data *persist_data = NULL;
Ken Sumrall56ad03c2013-02-13 13:00:19 -080076
77extern struct fstab *fstab;
Ken Sumrall8ddbe402011-01-17 15:26:29 -080078
Ken Sumralladfba362013-06-04 16:37:52 -070079static void cryptfs_reboot(int recovery)
80{
81 if (recovery) {
82 property_set(ANDROID_RB_PROPERTY, "reboot,recovery");
83 } else {
84 property_set(ANDROID_RB_PROPERTY, "reboot");
85 }
86 sleep(20);
87
88 /* Shouldn't get here, reboot should happen before sleep times out */
89 return;
90}
91
Ken Sumrall8f869aa2010-12-03 03:47:09 -080092static void ioctl_init(struct dm_ioctl *io, size_t dataSize, const char *name, unsigned flags)
93{
94 memset(io, 0, dataSize);
95 io->data_size = dataSize;
96 io->data_start = sizeof(struct dm_ioctl);
97 io->version[0] = 4;
98 io->version[1] = 0;
99 io->version[2] = 0;
100 io->flags = flags;
101 if (name) {
102 strncpy(io->name, name, sizeof(io->name));
103 }
104}
105
Kenny Rootc4c70f12013-06-14 12:11:38 -0700106/**
107 * Gets the default device scrypt parameters for key derivation time tuning.
108 * The parameters should lead to about one second derivation time for the
109 * given device.
110 */
111static void get_device_scrypt_params(struct crypt_mnt_ftr *ftr) {
112 const int default_params[] = SCRYPT_DEFAULTS;
113 int params[] = SCRYPT_DEFAULTS;
114 char paramstr[PROPERTY_VALUE_MAX];
115 char *token;
116 char *saveptr;
117 int i;
118
119 property_get(SCRYPT_PROP, paramstr, "");
120 if (paramstr[0] != '\0') {
121 /*
122 * The token we're looking for should be three integers separated by
123 * colons (e.g., "12:8:1"). Scan the property to make sure it matches.
124 */
Kenny Root2947e342013-08-14 15:54:49 -0700125 for (i = 0, token = strtok_r(paramstr, ":", &saveptr);
126 token != NULL && i < 3;
Kenny Rootc4c70f12013-06-14 12:11:38 -0700127 i++, token = strtok_r(NULL, ":", &saveptr)) {
128 char *endptr;
129 params[i] = strtol(token, &endptr, 10);
130
131 /*
132 * Check that there was a valid number and it's 8-bit. If not,
133 * break out and the end check will take the default values.
134 */
135 if ((*token == '\0') || (*endptr != '\0') || params[i] < 0 || params[i] > 255) {
136 break;
137 }
138 }
139
140 /*
141 * If there were not enough tokens or a token was malformed (not an
142 * integer), it will end up here and the default parameters can be
143 * taken.
144 */
145 if ((i != 3) || (token != NULL)) {
146 SLOGW("bad scrypt parameters '%s' should be like '12:8:1'; using defaults", paramstr);
147 memcpy(params, default_params, sizeof(params));
148 }
149 }
150
151 ftr->N_factor = params[0];
152 ftr->r_factor = params[1];
153 ftr->p_factor = params[2];
154}
155
Ken Sumrall3ed82362011-01-28 23:31:16 -0800156static unsigned int get_fs_size(char *dev)
157{
158 int fd, block_size;
159 struct ext4_super_block sb;
160 off64_t len;
161
162 if ((fd = open(dev, O_RDONLY)) < 0) {
163 SLOGE("Cannot open device to get filesystem size ");
164 return 0;
165 }
166
167 if (lseek64(fd, 1024, SEEK_SET) < 0) {
168 SLOGE("Cannot seek to superblock");
169 return 0;
170 }
171
172 if (read(fd, &sb, sizeof(sb)) != sizeof(sb)) {
173 SLOGE("Cannot read superblock");
174 return 0;
175 }
176
177 close(fd);
178
179 block_size = 1024 << sb.s_log_block_size;
180 /* compute length in bytes */
181 len = ( ((off64_t)sb.s_blocks_count_hi << 32) + sb.s_blocks_count_lo) * block_size;
182
183 /* return length in sectors */
184 return (unsigned int) (len / 512);
185}
186
Ken Sumrall160b4d62013-04-22 12:15:39 -0700187static int get_crypt_ftr_info(char **metadata_fname, off64_t *off)
188{
189 static int cached_data = 0;
190 static off64_t cached_off = 0;
191 static char cached_metadata_fname[PROPERTY_VALUE_MAX] = "";
192 int fd;
193 char key_loc[PROPERTY_VALUE_MAX];
194 char real_blkdev[PROPERTY_VALUE_MAX];
195 unsigned int nr_sec;
196 int rc = -1;
197
198 if (!cached_data) {
199 fs_mgr_get_crypt_info(fstab, key_loc, real_blkdev, sizeof(key_loc));
200
201 if (!strcmp(key_loc, KEY_IN_FOOTER)) {
202 if ( (fd = open(real_blkdev, O_RDWR)) < 0) {
203 SLOGE("Cannot open real block device %s\n", real_blkdev);
204 return -1;
205 }
206
207 if ((nr_sec = get_blkdev_size(fd))) {
208 /* If it's an encrypted Android partition, the last 16 Kbytes contain the
209 * encryption info footer and key, and plenty of bytes to spare for future
210 * growth.
211 */
212 strlcpy(cached_metadata_fname, real_blkdev, sizeof(cached_metadata_fname));
213 cached_off = ((off64_t)nr_sec * 512) - CRYPT_FOOTER_OFFSET;
214 cached_data = 1;
215 } else {
216 SLOGE("Cannot get size of block device %s\n", real_blkdev);
217 }
218 close(fd);
219 } else {
220 strlcpy(cached_metadata_fname, key_loc, sizeof(cached_metadata_fname));
221 cached_off = 0;
222 cached_data = 1;
223 }
224 }
225
226 if (cached_data) {
227 if (metadata_fname) {
228 *metadata_fname = cached_metadata_fname;
229 }
230 if (off) {
231 *off = cached_off;
232 }
233 rc = 0;
234 }
235
236 return rc;
237}
238
Ken Sumralle8744072011-01-18 22:01:55 -0800239/* key or salt can be NULL, in which case just skip writing that value. Useful to
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800240 * update the failed mount count but not change the key.
241 */
Ken Sumrall160b4d62013-04-22 12:15:39 -0700242static int put_crypt_ftr_and_key(struct crypt_mnt_ftr *crypt_ftr)
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800243{
244 int fd;
245 unsigned int nr_sec, cnt;
Ken Sumrall160b4d62013-04-22 12:15:39 -0700246 /* starting_off is set to the SEEK_SET offset
247 * where the crypto structure starts
248 */
249 off64_t starting_off;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800250 int rc = -1;
Ken Sumrall160b4d62013-04-22 12:15:39 -0700251 char *fname = NULL;
Ken Sumrall3be890f2011-09-14 16:53:46 -0700252 struct stat statbuf;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800253
Ken Sumrall160b4d62013-04-22 12:15:39 -0700254 if (get_crypt_ftr_info(&fname, &starting_off)) {
255 SLOGE("Unable to get crypt_ftr_info\n");
256 return -1;
257 }
258 if (fname[0] != '/') {
Ken Sumralle5032c42012-04-01 23:58:44 -0700259 SLOGE("Unexpected value for crypto key location\n");
Ken Sumrall160b4d62013-04-22 12:15:39 -0700260 return -1;
261 }
Ken Sumralle550f782013-08-20 13:48:23 -0700262 if ( (fd = open(fname, O_RDWR | O_CREAT, 0600)) < 0) {
263 SLOGE("Cannot open footer file %s for put\n", fname);
Ken Sumrall160b4d62013-04-22 12:15:39 -0700264 return -1;
265 }
266
267 /* Seek to the start of the crypt footer */
268 if (lseek64(fd, starting_off, SEEK_SET) == -1) {
269 SLOGE("Cannot seek to real block device footer\n");
270 goto errout;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800271 }
272
273 if ((cnt = write(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr))) != sizeof(struct crypt_mnt_ftr)) {
274 SLOGE("Cannot write real block device footer\n");
275 goto errout;
276 }
277
Ken Sumrall3be890f2011-09-14 16:53:46 -0700278 fstat(fd, &statbuf);
279 /* If the keys are kept on a raw block device, do not try to truncate it. */
Ken Sumralle550f782013-08-20 13:48:23 -0700280 if (S_ISREG(statbuf.st_mode)) {
Ken Sumrall29d8da82011-05-18 17:20:07 -0700281 if (ftruncate(fd, 0x4000)) {
Colin Cross59846b62014-02-06 20:34:29 -0800282 SLOGE("Cannot set footer file size\n");
Ken Sumralle8744072011-01-18 22:01:55 -0800283 goto errout;
284 }
285 }
286
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800287 /* Success! */
288 rc = 0;
289
290errout:
291 close(fd);
292 return rc;
293
294}
295
Ken Sumrall160b4d62013-04-22 12:15:39 -0700296static inline int unix_read(int fd, void* buff, int len)
297{
298 return TEMP_FAILURE_RETRY(read(fd, buff, len));
299}
300
301static inline int unix_write(int fd, const void* buff, int len)
302{
303 return TEMP_FAILURE_RETRY(write(fd, buff, len));
304}
305
306static void init_empty_persist_data(struct crypt_persist_data *pdata, int len)
307{
308 memset(pdata, 0, len);
309 pdata->persist_magic = PERSIST_DATA_MAGIC;
310 pdata->persist_valid_entries = 0;
311}
312
313/* A routine to update the passed in crypt_ftr to the lastest version.
314 * fd is open read/write on the device that holds the crypto footer and persistent
315 * data, crypt_ftr is a pointer to the struct to be updated, and offset is the
316 * absolute offset to the start of the crypt_mnt_ftr on the passed in fd.
317 */
318static void upgrade_crypt_ftr(int fd, struct crypt_mnt_ftr *crypt_ftr, off64_t offset)
319{
Kenny Root7434b312013-06-14 11:29:53 -0700320 int orig_major = crypt_ftr->major_version;
321 int orig_minor = crypt_ftr->minor_version;
Ken Sumrall160b4d62013-04-22 12:15:39 -0700322
Kenny Root7434b312013-06-14 11:29:53 -0700323 if ((crypt_ftr->major_version == 1) && (crypt_ftr->minor_version == 0)) {
324 struct crypt_persist_data *pdata;
325 off64_t pdata_offset = offset + CRYPT_FOOTER_TO_PERSIST_OFFSET;
Ken Sumrall160b4d62013-04-22 12:15:39 -0700326
Kenny Rootc4c70f12013-06-14 12:11:38 -0700327 SLOGW("upgrading crypto footer to 1.1");
328
Kenny Root7434b312013-06-14 11:29:53 -0700329 pdata = malloc(CRYPT_PERSIST_DATA_SIZE);
330 if (pdata == NULL) {
331 SLOGE("Cannot allocate persisent data\n");
332 return;
333 }
334 memset(pdata, 0, CRYPT_PERSIST_DATA_SIZE);
335
336 /* Need to initialize the persistent data area */
337 if (lseek64(fd, pdata_offset, SEEK_SET) == -1) {
338 SLOGE("Cannot seek to persisent data offset\n");
339 return;
340 }
341 /* Write all zeros to the first copy, making it invalid */
342 unix_write(fd, pdata, CRYPT_PERSIST_DATA_SIZE);
343
344 /* Write a valid but empty structure to the second copy */
345 init_empty_persist_data(pdata, CRYPT_PERSIST_DATA_SIZE);
346 unix_write(fd, pdata, CRYPT_PERSIST_DATA_SIZE);
347
348 /* Update the footer */
349 crypt_ftr->persist_data_size = CRYPT_PERSIST_DATA_SIZE;
350 crypt_ftr->persist_data_offset[0] = pdata_offset;
351 crypt_ftr->persist_data_offset[1] = pdata_offset + CRYPT_PERSIST_DATA_SIZE;
352 crypt_ftr->minor_version = 1;
Ken Sumrall160b4d62013-04-22 12:15:39 -0700353 }
354
Kenny Rootc4c70f12013-06-14 12:11:38 -0700355 if ((crypt_ftr->major_version == 1) && (crypt_ftr->minor_version)) {
356 SLOGW("upgrading crypto footer to 1.2");
JP Abgrall7bdfa522013-11-15 13:42:56 -0800357 /* But keep the old kdf_type.
358 * It will get updated later to KDF_SCRYPT after the password has been verified.
359 */
Kenny Rootc4c70f12013-06-14 12:11:38 -0700360 crypt_ftr->kdf_type = KDF_PBKDF2;
361 get_device_scrypt_params(crypt_ftr);
362 crypt_ftr->minor_version = 2;
363 }
364
Kenny Root7434b312013-06-14 11:29:53 -0700365 if ((orig_major != crypt_ftr->major_version) || (orig_minor != crypt_ftr->minor_version)) {
366 if (lseek64(fd, offset, SEEK_SET) == -1) {
367 SLOGE("Cannot seek to crypt footer\n");
368 return;
369 }
370 unix_write(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr));
Ken Sumrall160b4d62013-04-22 12:15:39 -0700371 }
Ken Sumrall160b4d62013-04-22 12:15:39 -0700372}
373
374
375static int get_crypt_ftr_and_key(struct crypt_mnt_ftr *crypt_ftr)
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800376{
377 int fd;
378 unsigned int nr_sec, cnt;
Ken Sumrall160b4d62013-04-22 12:15:39 -0700379 off64_t starting_off;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800380 int rc = -1;
Ken Sumrall160b4d62013-04-22 12:15:39 -0700381 char *fname = NULL;
Ken Sumrall29d8da82011-05-18 17:20:07 -0700382 struct stat statbuf;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800383
Ken Sumrall160b4d62013-04-22 12:15:39 -0700384 if (get_crypt_ftr_info(&fname, &starting_off)) {
385 SLOGE("Unable to get crypt_ftr_info\n");
386 return -1;
387 }
388 if (fname[0] != '/') {
Ken Sumralle5032c42012-04-01 23:58:44 -0700389 SLOGE("Unexpected value for crypto key location\n");
Ken Sumrall160b4d62013-04-22 12:15:39 -0700390 return -1;
391 }
392 if ( (fd = open(fname, O_RDWR)) < 0) {
Ken Sumralle550f782013-08-20 13:48:23 -0700393 SLOGE("Cannot open footer file %s for get\n", fname);
Ken Sumrall160b4d62013-04-22 12:15:39 -0700394 return -1;
395 }
396
397 /* Make sure it's 16 Kbytes in length */
398 fstat(fd, &statbuf);
399 if (S_ISREG(statbuf.st_mode) && (statbuf.st_size != 0x4000)) {
400 SLOGE("footer file %s is not the expected size!\n", fname);
401 goto errout;
402 }
403
404 /* Seek to the start of the crypt footer */
405 if (lseek64(fd, starting_off, SEEK_SET) == -1) {
406 SLOGE("Cannot seek to real block device footer\n");
407 goto errout;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800408 }
409
410 if ( (cnt = read(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr))) != sizeof(struct crypt_mnt_ftr)) {
411 SLOGE("Cannot read real block device footer\n");
412 goto errout;
413 }
414
415 if (crypt_ftr->magic != CRYPT_MNT_MAGIC) {
Ken Sumrall29d8da82011-05-18 17:20:07 -0700416 SLOGE("Bad magic for real block device %s\n", fname);
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800417 goto errout;
418 }
419
Kenny Rootc96a5f82013-06-14 12:08:28 -0700420 if (crypt_ftr->major_version != CURRENT_MAJOR_VERSION) {
421 SLOGE("Cannot understand major version %d real block device footer; expected %d\n",
422 crypt_ftr->major_version, CURRENT_MAJOR_VERSION);
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800423 goto errout;
424 }
425
Kenny Rootc96a5f82013-06-14 12:08:28 -0700426 if (crypt_ftr->minor_version > CURRENT_MINOR_VERSION) {
427 SLOGW("Warning: crypto footer minor version %d, expected <= %d, continuing...\n",
428 crypt_ftr->minor_version, CURRENT_MINOR_VERSION);
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800429 }
430
Ken Sumrall160b4d62013-04-22 12:15:39 -0700431 /* If this is a verion 1.0 crypt_ftr, make it a 1.1 crypt footer, and update the
432 * copy on disk before returning.
433 */
Kenny Rootc96a5f82013-06-14 12:08:28 -0700434 if (crypt_ftr->minor_version < CURRENT_MINOR_VERSION) {
Ken Sumrall160b4d62013-04-22 12:15:39 -0700435 upgrade_crypt_ftr(fd, crypt_ftr, starting_off);
Ken Sumralle8744072011-01-18 22:01:55 -0800436 }
437
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800438 /* Success! */
439 rc = 0;
440
441errout:
442 close(fd);
443 return rc;
444}
445
Ken Sumrall160b4d62013-04-22 12:15:39 -0700446static int validate_persistent_data_storage(struct crypt_mnt_ftr *crypt_ftr)
447{
448 if (crypt_ftr->persist_data_offset[0] + crypt_ftr->persist_data_size >
449 crypt_ftr->persist_data_offset[1]) {
450 SLOGE("Crypt_ftr persist data regions overlap");
451 return -1;
452 }
453
454 if (crypt_ftr->persist_data_offset[0] >= crypt_ftr->persist_data_offset[1]) {
455 SLOGE("Crypt_ftr persist data region 0 starts after region 1");
456 return -1;
457 }
458
459 if (((crypt_ftr->persist_data_offset[1] + crypt_ftr->persist_data_size) -
460 (crypt_ftr->persist_data_offset[0] - CRYPT_FOOTER_TO_PERSIST_OFFSET)) >
461 CRYPT_FOOTER_OFFSET) {
462 SLOGE("Persistent data extends past crypto footer");
463 return -1;
464 }
465
466 return 0;
467}
468
469static int load_persistent_data(void)
470{
471 struct crypt_mnt_ftr crypt_ftr;
472 struct crypt_persist_data *pdata = NULL;
473 char encrypted_state[PROPERTY_VALUE_MAX];
474 char *fname;
475 int found = 0;
476 int fd;
477 int ret;
478 int i;
479
480 if (persist_data) {
481 /* Nothing to do, we've already loaded or initialized it */
482 return 0;
483 }
484
485
486 /* If not encrypted, just allocate an empty table and initialize it */
487 property_get("ro.crypto.state", encrypted_state, "");
488 if (strcmp(encrypted_state, "encrypted") ) {
489 pdata = malloc(CRYPT_PERSIST_DATA_SIZE);
490 if (pdata) {
491 init_empty_persist_data(pdata, CRYPT_PERSIST_DATA_SIZE);
492 persist_data = pdata;
493 return 0;
494 }
495 return -1;
496 }
497
498 if(get_crypt_ftr_and_key(&crypt_ftr)) {
499 return -1;
500 }
501
502 if ((crypt_ftr.major_version != 1) || (crypt_ftr.minor_version != 1)) {
503 SLOGE("Crypt_ftr version doesn't support persistent data");
504 return -1;
505 }
506
507 if (get_crypt_ftr_info(&fname, NULL)) {
508 return -1;
509 }
510
511 ret = validate_persistent_data_storage(&crypt_ftr);
512 if (ret) {
513 return -1;
514 }
515
516 fd = open(fname, O_RDONLY);
517 if (fd < 0) {
518 SLOGE("Cannot open %s metadata file", fname);
519 return -1;
520 }
521
522 if (persist_data == NULL) {
523 pdata = malloc(crypt_ftr.persist_data_size);
524 if (pdata == NULL) {
525 SLOGE("Cannot allocate memory for persistent data");
526 goto err;
527 }
528 }
529
530 for (i = 0; i < 2; i++) {
531 if (lseek64(fd, crypt_ftr.persist_data_offset[i], SEEK_SET) < 0) {
532 SLOGE("Cannot seek to read persistent data on %s", fname);
533 goto err2;
534 }
535 if (unix_read(fd, pdata, crypt_ftr.persist_data_size) < 0){
536 SLOGE("Error reading persistent data on iteration %d", i);
537 goto err2;
538 }
539 if (pdata->persist_magic == PERSIST_DATA_MAGIC) {
540 found = 1;
541 break;
542 }
543 }
544
545 if (!found) {
546 SLOGI("Could not find valid persistent data, creating");
547 init_empty_persist_data(pdata, crypt_ftr.persist_data_size);
548 }
549
550 /* Success */
551 persist_data = pdata;
552 close(fd);
553 return 0;
554
555err2:
556 free(pdata);
557
558err:
559 close(fd);
560 return -1;
561}
562
563static int save_persistent_data(void)
564{
565 struct crypt_mnt_ftr crypt_ftr;
566 struct crypt_persist_data *pdata;
567 char *fname;
568 off64_t write_offset;
569 off64_t erase_offset;
570 int found = 0;
571 int fd;
572 int ret;
573
574 if (persist_data == NULL) {
575 SLOGE("No persistent data to save");
576 return -1;
577 }
578
579 if(get_crypt_ftr_and_key(&crypt_ftr)) {
580 return -1;
581 }
582
583 if ((crypt_ftr.major_version != 1) || (crypt_ftr.minor_version != 1)) {
584 SLOGE("Crypt_ftr version doesn't support persistent data");
585 return -1;
586 }
587
588 ret = validate_persistent_data_storage(&crypt_ftr);
589 if (ret) {
590 return -1;
591 }
592
593 if (get_crypt_ftr_info(&fname, NULL)) {
594 return -1;
595 }
596
597 fd = open(fname, O_RDWR);
598 if (fd < 0) {
599 SLOGE("Cannot open %s metadata file", fname);
600 return -1;
601 }
602
603 pdata = malloc(crypt_ftr.persist_data_size);
604 if (pdata == NULL) {
605 SLOGE("Cannot allocate persistant data");
606 goto err;
607 }
608
609 if (lseek64(fd, crypt_ftr.persist_data_offset[0], SEEK_SET) < 0) {
610 SLOGE("Cannot seek to read persistent data on %s", fname);
611 goto err2;
612 }
613
614 if (unix_read(fd, pdata, crypt_ftr.persist_data_size) < 0) {
615 SLOGE("Error reading persistent data before save");
616 goto err2;
617 }
618
619 if (pdata->persist_magic == PERSIST_DATA_MAGIC) {
620 /* The first copy is the curent valid copy, so write to
621 * the second copy and erase this one */
622 write_offset = crypt_ftr.persist_data_offset[1];
623 erase_offset = crypt_ftr.persist_data_offset[0];
624 } else {
625 /* The second copy must be the valid copy, so write to
626 * the first copy, and erase the second */
627 write_offset = crypt_ftr.persist_data_offset[0];
628 erase_offset = crypt_ftr.persist_data_offset[1];
629 }
630
631 /* Write the new copy first, if successful, then erase the old copy */
632 if (lseek(fd, write_offset, SEEK_SET) < 0) {
633 SLOGE("Cannot seek to write persistent data");
634 goto err2;
635 }
636 if (unix_write(fd, persist_data, crypt_ftr.persist_data_size) ==
637 (int) crypt_ftr.persist_data_size) {
638 if (lseek(fd, erase_offset, SEEK_SET) < 0) {
639 SLOGE("Cannot seek to erase previous persistent data");
640 goto err2;
641 }
642 fsync(fd);
643 memset(pdata, 0, crypt_ftr.persist_data_size);
644 if (unix_write(fd, pdata, crypt_ftr.persist_data_size) !=
645 (int) crypt_ftr.persist_data_size) {
646 SLOGE("Cannot write to erase previous persistent data");
647 goto err2;
648 }
649 fsync(fd);
650 } else {
651 SLOGE("Cannot write to save persistent data");
652 goto err2;
653 }
654
655 /* Success */
656 free(pdata);
657 close(fd);
658 return 0;
659
660err2:
661 free(pdata);
662err:
663 close(fd);
664 return -1;
665}
666
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800667/* Convert a binary key of specified length into an ascii hex string equivalent,
668 * without the leading 0x and with null termination
669 */
670void convert_key_to_hex_ascii(unsigned char *master_key, unsigned int keysize,
671 char *master_key_ascii)
672{
673 unsigned int i, a;
674 unsigned char nibble;
675
676 for (i=0, a=0; i<keysize; i++, a+=2) {
677 /* For each byte, write out two ascii hex digits */
678 nibble = (master_key[i] >> 4) & 0xf;
679 master_key_ascii[a] = nibble + (nibble > 9 ? 0x37 : 0x30);
680
681 nibble = master_key[i] & 0xf;
682 master_key_ascii[a+1] = nibble + (nibble > 9 ? 0x37 : 0x30);
683 }
684
685 /* Add the null termination */
686 master_key_ascii[a] = '\0';
687
688}
689
Ken Sumralldb5e0262013-02-05 17:39:48 -0800690static int load_crypto_mapping_table(struct crypt_mnt_ftr *crypt_ftr, unsigned char *master_key,
691 char *real_blk_name, const char *name, int fd,
692 char *extra_params)
693{
694 char buffer[DM_CRYPT_BUF_SIZE];
695 struct dm_ioctl *io;
696 struct dm_target_spec *tgt;
697 char *crypt_params;
698 char master_key_ascii[129]; /* Large enough to hold 512 bit key and null */
699 int i;
700
701 io = (struct dm_ioctl *) buffer;
702
703 /* Load the mapping table for this device */
704 tgt = (struct dm_target_spec *) &buffer[sizeof(struct dm_ioctl)];
705
706 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
707 io->target_count = 1;
708 tgt->status = 0;
709 tgt->sector_start = 0;
710 tgt->length = crypt_ftr->fs_size;
711 strcpy(tgt->target_type, "crypt");
712
713 crypt_params = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
714 convert_key_to_hex_ascii(master_key, crypt_ftr->keysize, master_key_ascii);
715 sprintf(crypt_params, "%s %s 0 %s 0 %s", crypt_ftr->crypto_type_name,
716 master_key_ascii, real_blk_name, extra_params);
717 crypt_params += strlen(crypt_params) + 1;
718 crypt_params = (char *) (((unsigned long)crypt_params + 7) & ~8); /* Align to an 8 byte boundary */
719 tgt->next = crypt_params - buffer;
720
721 for (i = 0; i < TABLE_LOAD_RETRIES; i++) {
722 if (! ioctl(fd, DM_TABLE_LOAD, io)) {
723 break;
724 }
725 usleep(500000);
726 }
727
728 if (i == TABLE_LOAD_RETRIES) {
729 /* We failed to load the table, return an error */
730 return -1;
731 } else {
732 return i + 1;
733 }
734}
735
736
737static int get_dm_crypt_version(int fd, const char *name, int *version)
738{
739 char buffer[DM_CRYPT_BUF_SIZE];
740 struct dm_ioctl *io;
741 struct dm_target_versions *v;
742 int i;
743
744 io = (struct dm_ioctl *) buffer;
745
746 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
747
748 if (ioctl(fd, DM_LIST_VERSIONS, io)) {
749 return -1;
750 }
751
752 /* Iterate over the returned versions, looking for name of "crypt".
753 * When found, get and return the version.
754 */
755 v = (struct dm_target_versions *) &buffer[sizeof(struct dm_ioctl)];
756 while (v->next) {
757 if (! strcmp(v->name, "crypt")) {
758 /* We found the crypt driver, return the version, and get out */
759 version[0] = v->version[0];
760 version[1] = v->version[1];
761 version[2] = v->version[2];
762 return 0;
763 }
764 v = (struct dm_target_versions *)(((char *)v) + v->next);
765 }
766
767 return -1;
768}
769
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800770static int create_crypto_blk_dev(struct crypt_mnt_ftr *crypt_ftr, unsigned char *master_key,
Ken Sumrall29d8da82011-05-18 17:20:07 -0700771 char *real_blk_name, char *crypto_blk_name, const char *name)
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800772{
773 char buffer[DM_CRYPT_BUF_SIZE];
774 char master_key_ascii[129]; /* Large enough to hold 512 bit key and null */
775 char *crypt_params;
776 struct dm_ioctl *io;
777 struct dm_target_spec *tgt;
778 unsigned int minor;
779 int fd;
Ken Sumralle919efe2012-09-29 17:07:41 -0700780 int i;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800781 int retval = -1;
Ken Sumralldb5e0262013-02-05 17:39:48 -0800782 int version[3];
783 char *extra_params;
784 int load_count;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800785
786 if ((fd = open("/dev/device-mapper", O_RDWR)) < 0 ) {
787 SLOGE("Cannot open device-mapper\n");
788 goto errout;
789 }
790
791 io = (struct dm_ioctl *) buffer;
792
793 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
794 if (ioctl(fd, DM_DEV_CREATE, io)) {
795 SLOGE("Cannot create dm-crypt device\n");
796 goto errout;
797 }
798
799 /* Get the device status, in particular, the name of it's device file */
800 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
801 if (ioctl(fd, DM_DEV_STATUS, io)) {
802 SLOGE("Cannot retrieve dm-crypt device status\n");
803 goto errout;
804 }
805 minor = (io->dev & 0xff) | ((io->dev >> 12) & 0xfff00);
806 snprintf(crypto_blk_name, MAXPATHLEN, "/dev/block/dm-%u", minor);
807
Ken Sumralldb5e0262013-02-05 17:39:48 -0800808 extra_params = "";
809 if (! get_dm_crypt_version(fd, name, version)) {
810 /* Support for allow_discards was added in version 1.11.0 */
811 if ((version[0] >= 2) ||
812 ((version[0] == 1) && (version[1] >= 11))) {
813 extra_params = "1 allow_discards";
814 SLOGI("Enabling support for allow_discards in dmcrypt.\n");
815 }
Ken Sumralle919efe2012-09-29 17:07:41 -0700816 }
817
Ken Sumralldb5e0262013-02-05 17:39:48 -0800818 load_count = load_crypto_mapping_table(crypt_ftr, master_key, real_blk_name, name,
819 fd, extra_params);
820 if (load_count < 0) {
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800821 SLOGE("Cannot load dm-crypt mapping table.\n");
822 goto errout;
Ken Sumralldb5e0262013-02-05 17:39:48 -0800823 } else if (load_count > 1) {
824 SLOGI("Took %d tries to load dmcrypt table.\n", load_count);
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800825 }
826
827 /* Resume this device to activate it */
Ken Sumralldb5e0262013-02-05 17:39:48 -0800828 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800829
830 if (ioctl(fd, DM_DEV_SUSPEND, io)) {
831 SLOGE("Cannot resume the dm-crypt device\n");
832 goto errout;
833 }
834
835 /* We made it here with no errors. Woot! */
836 retval = 0;
837
838errout:
839 close(fd); /* If fd is <0 from a failed open call, it's safe to just ignore the close error */
840
841 return retval;
842}
843
Ken Sumrall29d8da82011-05-18 17:20:07 -0700844static int delete_crypto_blk_dev(char *name)
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800845{
846 int fd;
847 char buffer[DM_CRYPT_BUF_SIZE];
848 struct dm_ioctl *io;
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800849 int retval = -1;
850
851 if ((fd = open("/dev/device-mapper", O_RDWR)) < 0 ) {
852 SLOGE("Cannot open device-mapper\n");
853 goto errout;
854 }
855
856 io = (struct dm_ioctl *) buffer;
857
858 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
859 if (ioctl(fd, DM_DEV_REMOVE, io)) {
860 SLOGE("Cannot remove dm-crypt device\n");
861 goto errout;
862 }
863
864 /* We made it here with no errors. Woot! */
865 retval = 0;
866
867errout:
868 close(fd); /* If fd is <0 from a failed open call, it's safe to just ignore the close error */
869
870 return retval;
871
872}
873
Mark Salyzyn5eecc442014-02-12 14:16:14 -0800874static void pbkdf2(char *passwd, unsigned char *salt, unsigned char *ikey, void *params UNUSED) {
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800875 /* Turn the password into a key and IV that can decrypt the master key */
Ken Sumralle8744072011-01-18 22:01:55 -0800876 PKCS5_PBKDF2_HMAC_SHA1(passwd, strlen(passwd), salt, SALT_LEN,
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800877 HASH_COUNT, KEY_LEN_BYTES+IV_LEN_BYTES, ikey);
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800878}
879
Kenny Rootc4c70f12013-06-14 12:11:38 -0700880static void scrypt(char *passwd, unsigned char *salt, unsigned char *ikey, void *params) {
881 struct crypt_mnt_ftr *ftr = (struct crypt_mnt_ftr *) params;
882
883 int N = 1 << ftr->N_factor;
884 int r = 1 << ftr->r_factor;
885 int p = 1 << ftr->p_factor;
886
887 /* Turn the password into a key and IV that can decrypt the master key */
888 crypto_scrypt((unsigned char *) passwd, strlen(passwd), salt, SALT_LEN, N, r, p, ikey,
889 KEY_LEN_BYTES + IV_LEN_BYTES);
890}
891
Ken Sumralle8744072011-01-18 22:01:55 -0800892static int encrypt_master_key(char *passwd, unsigned char *salt,
893 unsigned char *decrypted_master_key,
Kenny Rootc4c70f12013-06-14 12:11:38 -0700894 unsigned char *encrypted_master_key,
895 struct crypt_mnt_ftr *crypt_ftr)
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800896{
897 unsigned char ikey[32+32] = { 0 }; /* Big enough to hold a 256 bit key and 256 bit IV */
898 EVP_CIPHER_CTX e_ctx;
899 int encrypted_len, final_len;
900
901 /* Turn the password into a key and IV that can decrypt the master key */
Kenny Rootc4c70f12013-06-14 12:11:38 -0700902 get_device_scrypt_params(crypt_ftr);
903 scrypt(passwd, salt, ikey, crypt_ftr);
904
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800905 /* Initialize the decryption engine */
906 if (! EVP_EncryptInit(&e_ctx, EVP_aes_128_cbc(), ikey, ikey+KEY_LEN_BYTES)) {
907 SLOGE("EVP_EncryptInit failed\n");
908 return -1;
909 }
910 EVP_CIPHER_CTX_set_padding(&e_ctx, 0); /* Turn off padding as our data is block aligned */
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800911
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800912 /* Encrypt the master key */
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800913 if (! EVP_EncryptUpdate(&e_ctx, encrypted_master_key, &encrypted_len,
914 decrypted_master_key, KEY_LEN_BYTES)) {
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800915 SLOGE("EVP_EncryptUpdate failed\n");
916 return -1;
917 }
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800918 if (! EVP_EncryptFinal(&e_ctx, encrypted_master_key + encrypted_len, &final_len)) {
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800919 SLOGE("EVP_EncryptFinal failed\n");
920 return -1;
921 }
922
923 if (encrypted_len + final_len != KEY_LEN_BYTES) {
924 SLOGE("EVP_Encryption length check failed with %d, %d bytes\n", encrypted_len, final_len);
925 return -1;
926 } else {
927 return 0;
928 }
929}
930
JP Abgrall7bdfa522013-11-15 13:42:56 -0800931static int decrypt_master_key_aux(char *passwd, unsigned char *salt,
Ken Sumralle8744072011-01-18 22:01:55 -0800932 unsigned char *encrypted_master_key,
Kenny Rootc4c70f12013-06-14 12:11:38 -0700933 unsigned char *decrypted_master_key,
934 kdf_func kdf, void *kdf_params)
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800935{
936 unsigned char ikey[32+32] = { 0 }; /* Big enough to hold a 256 bit key and 256 bit IV */
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800937 EVP_CIPHER_CTX d_ctx;
938 int decrypted_len, final_len;
939
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800940 /* Turn the password into a key and IV that can decrypt the master key */
Kenny Rootc4c70f12013-06-14 12:11:38 -0700941 kdf(passwd, salt, ikey, kdf_params);
Ken Sumrall8f869aa2010-12-03 03:47:09 -0800942
943 /* Initialize the decryption engine */
944 if (! EVP_DecryptInit(&d_ctx, EVP_aes_128_cbc(), ikey, ikey+KEY_LEN_BYTES)) {
945 return -1;
946 }
947 EVP_CIPHER_CTX_set_padding(&d_ctx, 0); /* Turn off padding as our data is block aligned */
948 /* Decrypt the master key */
949 if (! EVP_DecryptUpdate(&d_ctx, decrypted_master_key, &decrypted_len,
950 encrypted_master_key, KEY_LEN_BYTES)) {
951 return -1;
952 }
953 if (! EVP_DecryptFinal(&d_ctx, decrypted_master_key + decrypted_len, &final_len)) {
954 return -1;
955 }
956
957 if (decrypted_len + final_len != KEY_LEN_BYTES) {
958 return -1;
959 } else {
960 return 0;
961 }
962}
963
Kenny Rootc4c70f12013-06-14 12:11:38 -0700964static void get_kdf_func(struct crypt_mnt_ftr *ftr, kdf_func *kdf, void** kdf_params)
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800965{
Kenny Rootc4c70f12013-06-14 12:11:38 -0700966 if (ftr->kdf_type == KDF_SCRYPT) {
967 *kdf = scrypt;
968 *kdf_params = ftr;
969 } else {
970 *kdf = pbkdf2;
971 *kdf_params = NULL;
972 }
973}
974
JP Abgrall7bdfa522013-11-15 13:42:56 -0800975static int decrypt_master_key(char *passwd, unsigned char *decrypted_master_key,
Kenny Rootc4c70f12013-06-14 12:11:38 -0700976 struct crypt_mnt_ftr *crypt_ftr)
977{
978 kdf_func kdf;
979 void *kdf_params;
980 int ret;
981
982 get_kdf_func(crypt_ftr, &kdf, &kdf_params);
JP Abgrall7bdfa522013-11-15 13:42:56 -0800983 ret = decrypt_master_key_aux(passwd, crypt_ftr->salt, crypt_ftr->master_key, decrypted_master_key, kdf,
Kenny Rootc4c70f12013-06-14 12:11:38 -0700984 kdf_params);
985 if (ret != 0) {
986 SLOGW("failure decrypting master key");
Kenny Rootc4c70f12013-06-14 12:11:38 -0700987 }
988
989 return ret;
990}
991
992static int create_encrypted_random_key(char *passwd, unsigned char *master_key, unsigned char *salt,
993 struct crypt_mnt_ftr *crypt_ftr) {
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800994 int fd;
Ken Sumralle8744072011-01-18 22:01:55 -0800995 unsigned char key_buf[KEY_LEN_BYTES];
Ken Sumrall8ddbe402011-01-17 15:26:29 -0800996 EVP_CIPHER_CTX e_ctx;
997 int encrypted_len, final_len;
998
999 /* Get some random bits for a key */
1000 fd = open("/dev/urandom", O_RDONLY);
Ken Sumralle8744072011-01-18 22:01:55 -08001001 read(fd, key_buf, sizeof(key_buf));
1002 read(fd, salt, SALT_LEN);
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001003 close(fd);
1004
1005 /* Now encrypt it with the password */
Kenny Rootc4c70f12013-06-14 12:11:38 -07001006 return encrypt_master_key(passwd, salt, key_buf, master_key, crypt_ftr);
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001007}
1008
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001009static int wait_and_unmount(char *mountpoint)
1010{
1011 int i, rc;
Ken Sumrall2eaf7132011-01-14 12:45:48 -08001012#define WAIT_UNMOUNT_COUNT 20
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001013
1014 /* Now umount the tmpfs filesystem */
1015 for (i=0; i<WAIT_UNMOUNT_COUNT; i++) {
1016 if (umount(mountpoint)) {
Ken Sumrall29d8da82011-05-18 17:20:07 -07001017 if (errno == EINVAL) {
1018 /* EINVAL is returned if the directory is not a mountpoint,
1019 * i.e. there is no filesystem mounted there. So just get out.
1020 */
1021 break;
1022 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001023 sleep(1);
1024 i++;
1025 } else {
1026 break;
1027 }
1028 }
1029
1030 if (i < WAIT_UNMOUNT_COUNT) {
1031 SLOGD("unmounting %s succeeded\n", mountpoint);
1032 rc = 0;
1033 } else {
1034 SLOGE("unmounting %s failed\n", mountpoint);
1035 rc = -1;
1036 }
1037
1038 return rc;
1039}
1040
Ken Sumrallc5872692013-05-14 15:26:31 -07001041#define DATA_PREP_TIMEOUT 200
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001042static int prep_data_fs(void)
1043{
1044 int i;
1045
1046 /* Do the prep of the /data filesystem */
1047 property_set("vold.post_fs_data_done", "0");
1048 property_set("vold.decrypt", "trigger_post_fs_data");
1049 SLOGD("Just triggered post_fs_data\n");
1050
Ken Sumrallc5872692013-05-14 15:26:31 -07001051 /* Wait a max of 50 seconds, hopefully it takes much less */
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001052 for (i=0; i<DATA_PREP_TIMEOUT; i++) {
Ken Sumrall29d8da82011-05-18 17:20:07 -07001053 char p[PROPERTY_VALUE_MAX];
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001054
1055 property_get("vold.post_fs_data_done", p, "0");
1056 if (*p == '1') {
1057 break;
1058 } else {
1059 usleep(250000);
1060 }
1061 }
1062 if (i == DATA_PREP_TIMEOUT) {
1063 /* Ugh, we failed to prep /data in time. Bail. */
Ken Sumrallc5872692013-05-14 15:26:31 -07001064 SLOGE("post_fs_data timed out!\n");
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001065 return -1;
1066 } else {
1067 SLOGD("post_fs_data done\n");
1068 return 0;
1069 }
1070}
1071
Ken Sumrall6864b7e2011-01-14 15:20:02 -08001072int cryptfs_restart(void)
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001073{
1074 char fs_type[32];
1075 char real_blkdev[MAXPATHLEN];
Ken Sumrall6864b7e2011-01-14 15:20:02 -08001076 char crypto_blkdev[MAXPATHLEN];
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001077 char fs_options[256];
1078 unsigned long mnt_flags;
1079 struct stat statbuf;
1080 int rc = -1, i;
Ken Sumrall0cc16632011-01-18 20:32:26 -08001081 static int restart_successful = 0;
1082
1083 /* Validate that it's OK to call this routine */
Jason parks70a4b3f2011-01-28 10:10:47 -06001084 if (! master_key_saved) {
Ken Sumrall0cc16632011-01-18 20:32:26 -08001085 SLOGE("Encrypted filesystem not validated, aborting");
1086 return -1;
1087 }
1088
1089 if (restart_successful) {
1090 SLOGE("System already restarted with encrypted disk, aborting");
1091 return -1;
1092 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001093
1094 /* Here is where we shut down the framework. The init scripts
1095 * start all services in one of three classes: core, main or late_start.
1096 * On boot, we start core and main. Now, we stop main, but not core,
1097 * as core includes vold and a few other really important things that
1098 * we need to keep running. Once main has stopped, we should be able
1099 * to umount the tmpfs /data, then mount the encrypted /data.
1100 * We then restart the class main, and also the class late_start.
1101 * At the moment, I've only put a few things in late_start that I know
1102 * are not needed to bring up the framework, and that also cause problems
1103 * with unmounting the tmpfs /data, but I hope to add add more services
1104 * to the late_start class as we optimize this to decrease the delay
1105 * till the user is asked for the password to the filesystem.
1106 */
1107
1108 /* The init files are setup to stop the class main when vold.decrypt is
1109 * set to trigger_reset_main.
1110 */
1111 property_set("vold.decrypt", "trigger_reset_main");
1112 SLOGD("Just asked init to shut down class main\n");
1113
Ken Sumrall92736ef2012-10-17 20:57:14 -07001114 /* Ugh, shutting down the framework is not synchronous, so until it
1115 * can be fixed, this horrible hack will wait a moment for it all to
1116 * shut down before proceeding. Without it, some devices cannot
1117 * restart the graphics services.
1118 */
1119 sleep(2);
Ken Sumrall9dedfd42012-10-09 14:16:59 -07001120
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001121 /* Now that the framework is shutdown, we should be able to umount()
1122 * the tmpfs filesystem, and mount the real one.
1123 */
1124
Ken Sumrall6864b7e2011-01-14 15:20:02 -08001125 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "");
1126 if (strlen(crypto_blkdev) == 0) {
1127 SLOGE("fs_crypto_blkdev not set\n");
1128 return -1;
1129 }
1130
Ken Sumralle5032c42012-04-01 23:58:44 -07001131 if (! (rc = wait_and_unmount(DATA_MNT_POINT)) ) {
1132 /* If that succeeded, then mount the decrypted filesystem */
Ken Sumrall56ad03c2013-02-13 13:00:19 -08001133 fs_mgr_do_mount(fstab, DATA_MNT_POINT, crypto_blkdev, 0);
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001134
Ken Sumralle5032c42012-04-01 23:58:44 -07001135 property_set("vold.decrypt", "trigger_load_persist_props");
1136 /* Create necessary paths on /data */
1137 if (prep_data_fs()) {
1138 return -1;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001139 }
Ken Sumralle5032c42012-04-01 23:58:44 -07001140
1141 /* startup service classes main and late_start */
1142 property_set("vold.decrypt", "trigger_restart_framework");
1143 SLOGD("Just triggered restart_framework\n");
1144
1145 /* Give it a few moments to get started */
1146 sleep(1);
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001147 }
1148
Ken Sumrall0cc16632011-01-18 20:32:26 -08001149 if (rc == 0) {
1150 restart_successful = 1;
1151 }
1152
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001153 return rc;
1154}
1155
Mark Salyzyn5eecc442014-02-12 14:16:14 -08001156static int do_crypto_complete(char *mount_point UNUSED)
Ken Sumrall7f7dbaa2011-02-01 15:46:41 -08001157{
1158 struct crypt_mnt_ftr crypt_ftr;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001159 char encrypted_state[PROPERTY_VALUE_MAX];
Ken Sumralle1a45852011-12-14 21:24:27 -08001160 char key_loc[PROPERTY_VALUE_MAX];
Ken Sumrall7f7dbaa2011-02-01 15:46:41 -08001161
1162 property_get("ro.crypto.state", encrypted_state, "");
1163 if (strcmp(encrypted_state, "encrypted") ) {
1164 SLOGE("not running with encryption, aborting");
1165 return 1;
1166 }
1167
Ken Sumrall160b4d62013-04-22 12:15:39 -07001168 if (get_crypt_ftr_and_key(&crypt_ftr)) {
Ken Sumrall56ad03c2013-02-13 13:00:19 -08001169 fs_mgr_get_crypt_info(fstab, key_loc, 0, sizeof(key_loc));
Ken Sumralle5032c42012-04-01 23:58:44 -07001170
Ken Sumralle1a45852011-12-14 21:24:27 -08001171 /*
1172 * Only report this error if key_loc is a file and it exists.
1173 * If the device was never encrypted, and /data is not mountable for
1174 * some reason, returning 1 should prevent the UI from presenting the
1175 * a "enter password" screen, or worse, a "press button to wipe the
1176 * device" screen.
1177 */
1178 if ((key_loc[0] == '/') && (access("key_loc", F_OK) == -1)) {
1179 SLOGE("master key file does not exist, aborting");
1180 return 1;
1181 } else {
1182 SLOGE("Error getting crypt footer and key\n");
1183 return -1;
1184 }
Ken Sumrall7f7dbaa2011-02-01 15:46:41 -08001185 }
1186
1187 if (crypt_ftr.flags & CRYPT_ENCRYPTION_IN_PROGRESS) {
1188 SLOGE("Encryption process didn't finish successfully\n");
1189 return -2; /* -2 is the clue to the UI that there is no usable data on the disk,
1190 * and give the user an option to wipe the disk */
1191 }
1192
1193 /* We passed the test! We shall diminish, and return to the west */
1194 return 0;
1195}
1196
Ken Sumrall29d8da82011-05-18 17:20:07 -07001197static int test_mount_encrypted_fs(char *passwd, char *mount_point, char *label)
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001198{
1199 struct crypt_mnt_ftr crypt_ftr;
1200 /* Allocate enough space for a 256 bit key, but we may use less */
Ken Sumrall160b4d62013-04-22 12:15:39 -07001201 unsigned char decrypted_master_key[32];
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001202 char crypto_blkdev[MAXPATHLEN];
1203 char real_blkdev[MAXPATHLEN];
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001204 char tmp_mount_point[64];
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001205 unsigned int orig_failed_decrypt_count;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001206 char encrypted_state[PROPERTY_VALUE_MAX];
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001207 int rc;
Kenny Rootc4c70f12013-06-14 12:11:38 -07001208 kdf_func kdf;
1209 void *kdf_params;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001210
Ken Sumrall0cc16632011-01-18 20:32:26 -08001211 property_get("ro.crypto.state", encrypted_state, "");
Jason parks70a4b3f2011-01-28 10:10:47 -06001212 if ( master_key_saved || strcmp(encrypted_state, "encrypted") ) {
Ken Sumrall0cc16632011-01-18 20:32:26 -08001213 SLOGE("encrypted fs already validated or not running with encryption, aborting");
1214 return -1;
1215 }
1216
Ken Sumrall56ad03c2013-02-13 13:00:19 -08001217 fs_mgr_get_crypt_info(fstab, 0, real_blkdev, sizeof(real_blkdev));
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001218
Ken Sumrall160b4d62013-04-22 12:15:39 -07001219 if (get_crypt_ftr_and_key(&crypt_ftr)) {
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001220 SLOGE("Error getting crypt footer and key\n");
1221 return -1;
1222 }
Ken Sumralld33d4172011-02-01 00:49:13 -08001223
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001224 SLOGD("crypt_ftr->fs_size = %lld\n", crypt_ftr.fs_size);
1225 orig_failed_decrypt_count = crypt_ftr.failed_decrypt_count;
1226
1227 if (! (crypt_ftr.flags & CRYPT_MNT_KEY_UNENCRYPTED) ) {
JP Abgrall7bdfa522013-11-15 13:42:56 -08001228 if (decrypt_master_key(passwd, decrypted_master_key, &crypt_ftr)) {
1229 SLOGE("Failed to decrypt master key\n");
1230 return -1;
1231 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001232 }
1233
1234 if (create_crypto_blk_dev(&crypt_ftr, decrypted_master_key,
Ken Sumrall29d8da82011-05-18 17:20:07 -07001235 real_blkdev, crypto_blkdev, label)) {
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001236 SLOGE("Error creating decrypted block device\n");
1237 return -1;
1238 }
1239
Alex Klyubin707795a2013-05-10 15:17:07 -07001240 /* If init detects an encrypted filesystem, it writes a file for each such
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001241 * encrypted fs into the tmpfs /data filesystem, and then the framework finds those
1242 * files and passes that data to me */
1243 /* Create a tmp mount point to try mounting the decryptd fs
1244 * Since we're here, the mount_point should be a tmpfs filesystem, so make
1245 * a directory in it to test mount the decrypted filesystem.
1246 */
1247 sprintf(tmp_mount_point, "%s/tmp_mnt", mount_point);
1248 mkdir(tmp_mount_point, 0755);
Ken Sumrall56ad03c2013-02-13 13:00:19 -08001249 if (fs_mgr_do_mount(fstab, DATA_MNT_POINT, crypto_blkdev, tmp_mount_point)) {
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001250 SLOGE("Error temp mounting decrypted block device\n");
Ken Sumrall29d8da82011-05-18 17:20:07 -07001251 delete_crypto_blk_dev(label);
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001252 crypt_ftr.failed_decrypt_count++;
1253 } else {
1254 /* Success, so just umount and we'll mount it properly when we restart
1255 * the framework.
1256 */
1257 umount(tmp_mount_point);
1258 crypt_ftr.failed_decrypt_count = 0;
1259 }
1260
1261 if (orig_failed_decrypt_count != crypt_ftr.failed_decrypt_count) {
Ken Sumrall160b4d62013-04-22 12:15:39 -07001262 put_crypt_ftr_and_key(&crypt_ftr);
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001263 }
1264
1265 if (crypt_ftr.failed_decrypt_count) {
1266 /* We failed to mount the device, so return an error */
1267 rc = crypt_ftr.failed_decrypt_count;
1268
1269 } else {
Ken Sumrall6864b7e2011-01-14 15:20:02 -08001270 /* Woot! Success! Save the name of the crypto block device
1271 * so we can mount it when restarting the framework.
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001272 */
Ken Sumrall6864b7e2011-01-14 15:20:02 -08001273 property_set("ro.crypto.fs_crypto_blkdev", crypto_blkdev);
Jason parks70a4b3f2011-01-28 10:10:47 -06001274
1275 /* Also save a the master key so we can reencrypted the key
1276 * the key when we want to change the password on it.
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001277 */
Jason parks70a4b3f2011-01-28 10:10:47 -06001278 memcpy(saved_master_key, decrypted_master_key, KEY_LEN_BYTES);
Ken Sumrall3ad90722011-10-04 20:38:29 -07001279 saved_mount_point = strdup(mount_point);
Jason parks70a4b3f2011-01-28 10:10:47 -06001280 master_key_saved = 1;
JP Abgrall7bdfa522013-11-15 13:42:56 -08001281 SLOGD("%s(): Master key saved\n", __FUNCTION__);
Ken Sumrall6864b7e2011-01-14 15:20:02 -08001282 rc = 0;
JP Abgrall7bdfa522013-11-15 13:42:56 -08001283 /*
1284 * Upgrade if we're not using the latest KDF.
1285 */
1286 if (crypt_ftr.kdf_type != KDF_SCRYPT) {
1287 crypt_ftr.kdf_type = KDF_SCRYPT;
1288 rc = encrypt_master_key(passwd, crypt_ftr.salt, saved_master_key, crypt_ftr.master_key,
1289 &crypt_ftr);
1290 if (!rc) {
1291 rc = put_crypt_ftr_and_key(&crypt_ftr);
1292 }
1293 SLOGD("Key Derivation Function upgrade: rc=%d\n", rc);
1294 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001295 }
1296
1297 return rc;
1298}
1299
Ken Sumrall0b8b5972011-08-31 16:14:23 -07001300/* Called by vold when it wants to undo the crypto mapping of a volume it
1301 * manages. This is usually in response to a factory reset, when we want
1302 * to undo the crypto mapping so the volume is formatted in the clear.
1303 */
1304int cryptfs_revert_volume(const char *label)
1305{
1306 return delete_crypto_blk_dev((char *)label);
1307}
1308
Ken Sumrall29d8da82011-05-18 17:20:07 -07001309/*
1310 * Called by vold when it's asked to mount an encrypted, nonremovable volume.
1311 * Setup a dm-crypt mapping, use the saved master key from
1312 * setting up the /data mapping, and return the new device path.
1313 */
1314int cryptfs_setup_volume(const char *label, int major, int minor,
1315 char *crypto_sys_path, unsigned int max_path,
1316 int *new_major, int *new_minor)
1317{
1318 char real_blkdev[MAXPATHLEN], crypto_blkdev[MAXPATHLEN];
1319 struct crypt_mnt_ftr sd_crypt_ftr;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001320 struct stat statbuf;
1321 int nr_sec, fd;
1322
1323 sprintf(real_blkdev, "/dev/block/vold/%d:%d", major, minor);
1324
Ken Sumrall160b4d62013-04-22 12:15:39 -07001325 get_crypt_ftr_and_key(&sd_crypt_ftr);
Ken Sumrall29d8da82011-05-18 17:20:07 -07001326
1327 /* Update the fs_size field to be the size of the volume */
1328 fd = open(real_blkdev, O_RDONLY);
1329 nr_sec = get_blkdev_size(fd);
1330 close(fd);
1331 if (nr_sec == 0) {
1332 SLOGE("Cannot get size of volume %s\n", real_blkdev);
1333 return -1;
1334 }
1335
1336 sd_crypt_ftr.fs_size = nr_sec;
1337 create_crypto_blk_dev(&sd_crypt_ftr, saved_master_key, real_blkdev,
1338 crypto_blkdev, label);
1339
1340 stat(crypto_blkdev, &statbuf);
1341 *new_major = MAJOR(statbuf.st_rdev);
1342 *new_minor = MINOR(statbuf.st_rdev);
1343
1344 /* Create path to sys entry for this block device */
1345 snprintf(crypto_sys_path, max_path, "/devices/virtual/block/%s", strrchr(crypto_blkdev, '/')+1);
1346
1347 return 0;
1348}
1349
Ken Sumrall7f7dbaa2011-02-01 15:46:41 -08001350int cryptfs_crypto_complete(void)
1351{
1352 return do_crypto_complete("/data");
1353}
1354
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001355int cryptfs_check_passwd(char *passwd)
1356{
1357 int rc = -1;
1358
Ken Sumrall29d8da82011-05-18 17:20:07 -07001359 rc = test_mount_encrypted_fs(passwd, DATA_MNT_POINT, "userdata");
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001360
1361 return rc;
1362}
1363
Ken Sumrall3ad90722011-10-04 20:38:29 -07001364int cryptfs_verify_passwd(char *passwd)
1365{
1366 struct crypt_mnt_ftr crypt_ftr;
1367 /* Allocate enough space for a 256 bit key, but we may use less */
Ken Sumrall160b4d62013-04-22 12:15:39 -07001368 unsigned char decrypted_master_key[32];
Ken Sumrall3ad90722011-10-04 20:38:29 -07001369 char encrypted_state[PROPERTY_VALUE_MAX];
1370 int rc;
1371
1372 property_get("ro.crypto.state", encrypted_state, "");
1373 if (strcmp(encrypted_state, "encrypted") ) {
1374 SLOGE("device not encrypted, aborting");
1375 return -2;
1376 }
1377
1378 if (!master_key_saved) {
1379 SLOGE("encrypted fs not yet mounted, aborting");
1380 return -1;
1381 }
1382
1383 if (!saved_mount_point) {
1384 SLOGE("encrypted fs failed to save mount point, aborting");
1385 return -1;
1386 }
1387
Ken Sumrall160b4d62013-04-22 12:15:39 -07001388 if (get_crypt_ftr_and_key(&crypt_ftr)) {
Ken Sumrall3ad90722011-10-04 20:38:29 -07001389 SLOGE("Error getting crypt footer and key\n");
1390 return -1;
1391 }
1392
1393 if (crypt_ftr.flags & CRYPT_MNT_KEY_UNENCRYPTED) {
1394 /* If the device has no password, then just say the password is valid */
1395 rc = 0;
1396 } else {
JP Abgrall7bdfa522013-11-15 13:42:56 -08001397 decrypt_master_key(passwd, decrypted_master_key, &crypt_ftr);
Ken Sumrall3ad90722011-10-04 20:38:29 -07001398 if (!memcmp(decrypted_master_key, saved_master_key, crypt_ftr.keysize)) {
1399 /* They match, the password is correct */
1400 rc = 0;
1401 } else {
1402 /* If incorrect, sleep for a bit to prevent dictionary attacks */
1403 sleep(1);
1404 rc = 1;
1405 }
1406 }
1407
1408 return rc;
1409}
1410
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001411/* Initialize a crypt_mnt_ftr structure. The keysize is
1412 * defaulted to 16 bytes, and the filesystem size to 0.
1413 * Presumably, at a minimum, the caller will update the
1414 * filesystem size and crypto_type_name after calling this function.
1415 */
1416static void cryptfs_init_crypt_mnt_ftr(struct crypt_mnt_ftr *ftr)
1417{
Ken Sumrall160b4d62013-04-22 12:15:39 -07001418 off64_t off;
1419
1420 memset(ftr, 0, sizeof(struct crypt_mnt_ftr));
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001421 ftr->magic = CRYPT_MNT_MAGIC;
Kenny Rootc96a5f82013-06-14 12:08:28 -07001422 ftr->major_version = CURRENT_MAJOR_VERSION;
1423 ftr->minor_version = CURRENT_MINOR_VERSION;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001424 ftr->ftr_size = sizeof(struct crypt_mnt_ftr);
Jason parks70a4b3f2011-01-28 10:10:47 -06001425 ftr->keysize = KEY_LEN_BYTES;
Ken Sumrall160b4d62013-04-22 12:15:39 -07001426
Kenny Rootc4c70f12013-06-14 12:11:38 -07001427 ftr->kdf_type = KDF_SCRYPT;
1428 get_device_scrypt_params(ftr);
1429
Ken Sumrall160b4d62013-04-22 12:15:39 -07001430 ftr->persist_data_size = CRYPT_PERSIST_DATA_SIZE;
1431 if (get_crypt_ftr_info(NULL, &off) == 0) {
1432 ftr->persist_data_offset[0] = off + CRYPT_FOOTER_TO_PERSIST_OFFSET;
1433 ftr->persist_data_offset[1] = off + CRYPT_FOOTER_TO_PERSIST_OFFSET +
1434 ftr->persist_data_size;
1435 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001436}
1437
Ken Sumrall29d8da82011-05-18 17:20:07 -07001438static int cryptfs_enable_wipe(char *crypto_blkdev, off64_t size, int type)
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001439{
Ken Sumralle550f782013-08-20 13:48:23 -07001440 const char *args[10];
1441 char size_str[32]; /* Must be large enough to hold a %lld and null byte */
1442 int num_args;
1443 int status;
1444 int tmp;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001445 int rc = -1;
1446
Ken Sumrall29d8da82011-05-18 17:20:07 -07001447 if (type == EXT4_FS) {
Ken Sumralle550f782013-08-20 13:48:23 -07001448 args[0] = "/system/bin/make_ext4fs";
1449 args[1] = "-a";
1450 args[2] = "/data";
1451 args[3] = "-l";
Elliott Hughes73737162014-06-25 17:27:42 -07001452 snprintf(size_str, sizeof(size_str), "%" PRId64, size * 512);
Ken Sumralle550f782013-08-20 13:48:23 -07001453 args[4] = size_str;
1454 args[5] = crypto_blkdev;
1455 num_args = 6;
1456 SLOGI("Making empty filesystem with command %s %s %s %s %s %s\n",
1457 args[0], args[1], args[2], args[3], args[4], args[5]);
Ken Sumrall29d8da82011-05-18 17:20:07 -07001458 } else if (type== FAT_FS) {
Ken Sumralle550f782013-08-20 13:48:23 -07001459 args[0] = "/system/bin/newfs_msdos";
1460 args[1] = "-F";
1461 args[2] = "32";
1462 args[3] = "-O";
1463 args[4] = "android";
1464 args[5] = "-c";
1465 args[6] = "8";
1466 args[7] = "-s";
Elliott Hughes73737162014-06-25 17:27:42 -07001467 snprintf(size_str, sizeof(size_str), "%" PRId64, size);
Ken Sumralle550f782013-08-20 13:48:23 -07001468 args[8] = size_str;
1469 args[9] = crypto_blkdev;
1470 num_args = 10;
1471 SLOGI("Making empty filesystem with command %s %s %s %s %s %s %s %s %s %s\n",
1472 args[0], args[1], args[2], args[3], args[4], args[5],
1473 args[6], args[7], args[8], args[9]);
Ken Sumrall29d8da82011-05-18 17:20:07 -07001474 } else {
1475 SLOGE("cryptfs_enable_wipe(): unknown filesystem type %d\n", type);
1476 return -1;
1477 }
1478
Ken Sumralle550f782013-08-20 13:48:23 -07001479 tmp = android_fork_execvp(num_args, (char **)args, &status, false, true);
1480
1481 if (tmp != 0) {
1482 SLOGE("Error creating empty filesystem on %s due to logwrap error\n", crypto_blkdev);
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001483 } else {
Ken Sumralle550f782013-08-20 13:48:23 -07001484 if (WIFEXITED(status)) {
1485 if (WEXITSTATUS(status)) {
1486 SLOGE("Error creating filesystem on %s, exit status %d ",
1487 crypto_blkdev, WEXITSTATUS(status));
1488 } else {
1489 SLOGD("Successfully created filesystem on %s\n", crypto_blkdev);
1490 rc = 0;
1491 }
1492 } else {
1493 SLOGE("Error creating filesystem on %s, did not exit normally\n", crypto_blkdev);
1494 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001495 }
1496
1497 return rc;
1498}
1499
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001500#define CRYPT_INPLACE_BUFSIZE 4096
1501#define CRYPT_SECTORS_PER_BUFSIZE (CRYPT_INPLACE_BUFSIZE / 512)
Ken Sumrall29d8da82011-05-18 17:20:07 -07001502static int cryptfs_enable_inplace(char *crypto_blkdev, char *real_blkdev, off64_t size,
1503 off64_t *size_already_done, off64_t tot_size)
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001504{
1505 int realfd, cryptofd;
1506 char *buf[CRYPT_INPLACE_BUFSIZE];
1507 int rc = -1;
1508 off64_t numblocks, i, remainder;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001509 off64_t one_pct, cur_pct, new_pct;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001510 off64_t blocks_already_done, tot_numblocks;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001511
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001512 if ( (realfd = open(real_blkdev, O_RDONLY)) < 0) {
1513 SLOGE("Error opening real_blkdev %s for inplace encrypt\n", real_blkdev);
1514 return -1;
1515 }
1516
1517 if ( (cryptofd = open(crypto_blkdev, O_WRONLY)) < 0) {
1518 SLOGE("Error opening crypto_blkdev %s for inplace encrypt\n", crypto_blkdev);
1519 close(realfd);
1520 return -1;
1521 }
1522
1523 /* This is pretty much a simple loop of reading 4K, and writing 4K.
1524 * The size passed in is the number of 512 byte sectors in the filesystem.
1525 * So compute the number of whole 4K blocks we should read/write,
1526 * and the remainder.
1527 */
1528 numblocks = size / CRYPT_SECTORS_PER_BUFSIZE;
1529 remainder = size % CRYPT_SECTORS_PER_BUFSIZE;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001530 tot_numblocks = tot_size / CRYPT_SECTORS_PER_BUFSIZE;
1531 blocks_already_done = *size_already_done / CRYPT_SECTORS_PER_BUFSIZE;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001532
1533 SLOGE("Encrypting filesystem in place...");
1534
Ken Sumrall29d8da82011-05-18 17:20:07 -07001535 one_pct = tot_numblocks / 100;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001536 cur_pct = 0;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001537 /* process the majority of the filesystem in blocks */
1538 for (i=0; i<numblocks; i++) {
Ken Sumrall29d8da82011-05-18 17:20:07 -07001539 new_pct = (i + blocks_already_done) / one_pct;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001540 if (new_pct > cur_pct) {
1541 char buf[8];
1542
1543 cur_pct = new_pct;
Elliott Hughes73737162014-06-25 17:27:42 -07001544 snprintf(buf, sizeof(buf), "%" PRId64, cur_pct);
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001545 property_set("vold.encrypt_progress", buf);
1546 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001547 if (unix_read(realfd, buf, CRYPT_INPLACE_BUFSIZE) <= 0) {
1548 SLOGE("Error reading real_blkdev %s for inplace encrypt\n", crypto_blkdev);
1549 goto errout;
1550 }
1551 if (unix_write(cryptofd, buf, CRYPT_INPLACE_BUFSIZE) <= 0) {
1552 SLOGE("Error writing crypto_blkdev %s for inplace encrypt\n", crypto_blkdev);
1553 goto errout;
1554 }
1555 }
1556
1557 /* Do any remaining sectors */
1558 for (i=0; i<remainder; i++) {
1559 if (unix_read(realfd, buf, 512) <= 0) {
1560 SLOGE("Error reading rival sectors from real_blkdev %s for inplace encrypt\n", crypto_blkdev);
1561 goto errout;
1562 }
1563 if (unix_write(cryptofd, buf, 512) <= 0) {
1564 SLOGE("Error writing final sectors to crypto_blkdev %s for inplace encrypt\n", crypto_blkdev);
1565 goto errout;
1566 }
1567 }
1568
Ken Sumrall29d8da82011-05-18 17:20:07 -07001569 *size_already_done += size;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001570 rc = 0;
1571
1572errout:
1573 close(realfd);
1574 close(cryptofd);
1575
1576 return rc;
1577}
1578
1579#define CRYPTO_ENABLE_WIPE 1
1580#define CRYPTO_ENABLE_INPLACE 2
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001581
1582#define FRAMEWORK_BOOT_WAIT 60
1583
Ken Sumrall29d8da82011-05-18 17:20:07 -07001584static inline int should_encrypt(struct volume_info *volume)
1585{
1586 return (volume->flags & (VOL_ENCRYPTABLE | VOL_NONREMOVABLE)) ==
1587 (VOL_ENCRYPTABLE | VOL_NONREMOVABLE);
1588}
1589
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001590int cryptfs_enable(char *howarg, char *passwd)
1591{
1592 int how = 0;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001593 char crypto_blkdev[MAXPATHLEN], real_blkdev[MAXPATHLEN], sd_crypto_blkdev[MAXPATHLEN];
Ken Sumralle5032c42012-04-01 23:58:44 -07001594 unsigned long nr_sec;
Ken Sumrall160b4d62013-04-22 12:15:39 -07001595 unsigned char decrypted_master_key[KEY_LEN_BYTES];
Ken Sumrall319b1042011-06-14 14:01:55 -07001596 int rc=-1, fd, i, ret;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001597 struct crypt_mnt_ftr crypt_ftr, sd_crypt_ftr;;
Ken Sumrall160b4d62013-04-22 12:15:39 -07001598 struct crypt_persist_data *pdata;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001599 char tmpfs_options[PROPERTY_VALUE_MAX];
1600 char encrypted_state[PROPERTY_VALUE_MAX];
Ken Sumrall5d4c68e2011-01-30 19:06:03 -08001601 char lockid[32] = { 0 };
Ken Sumrall29d8da82011-05-18 17:20:07 -07001602 char key_loc[PROPERTY_VALUE_MAX];
1603 char fuse_sdcard[PROPERTY_VALUE_MAX];
1604 char *sd_mnt_point;
1605 char sd_blk_dev[256] = { 0 };
1606 int num_vols;
1607 struct volume_info *vol_list = 0;
1608 off64_t cur_encryption_done=0, tot_encryption_size=0;
Ken Sumrall0cc16632011-01-18 20:32:26 -08001609
1610 property_get("ro.crypto.state", encrypted_state, "");
1611 if (strcmp(encrypted_state, "unencrypted")) {
1612 SLOGE("Device is already running encrypted, aborting");
Ken Sumrall3ed82362011-01-28 23:31:16 -08001613 goto error_unencrypted;
Ken Sumrall0cc16632011-01-18 20:32:26 -08001614 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001615
Ken Sumrall56ad03c2013-02-13 13:00:19 -08001616 fs_mgr_get_crypt_info(fstab, key_loc, 0, sizeof(key_loc));
Ken Sumrall29d8da82011-05-18 17:20:07 -07001617
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001618 if (!strcmp(howarg, "wipe")) {
1619 how = CRYPTO_ENABLE_WIPE;
1620 } else if (! strcmp(howarg, "inplace")) {
1621 how = CRYPTO_ENABLE_INPLACE;
1622 } else {
1623 /* Shouldn't happen, as CommandListener vets the args */
Ken Sumrall3ed82362011-01-28 23:31:16 -08001624 goto error_unencrypted;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001625 }
1626
Ken Sumrall56ad03c2013-02-13 13:00:19 -08001627 fs_mgr_get_crypt_info(fstab, 0, real_blkdev, sizeof(real_blkdev));
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001628
Ken Sumrall3ed82362011-01-28 23:31:16 -08001629 /* Get the size of the real block device */
1630 fd = open(real_blkdev, O_RDONLY);
1631 if ( (nr_sec = get_blkdev_size(fd)) == 0) {
1632 SLOGE("Cannot get size of block device %s\n", real_blkdev);
1633 goto error_unencrypted;
1634 }
1635 close(fd);
1636
1637 /* If doing inplace encryption, make sure the orig fs doesn't include the crypto footer */
Ken Sumrall29d8da82011-05-18 17:20:07 -07001638 if ((how == CRYPTO_ENABLE_INPLACE) && (!strcmp(key_loc, KEY_IN_FOOTER))) {
Ken Sumrall3ed82362011-01-28 23:31:16 -08001639 unsigned int fs_size_sec, max_fs_size_sec;
1640
1641 fs_size_sec = get_fs_size(real_blkdev);
1642 max_fs_size_sec = nr_sec - (CRYPT_FOOTER_OFFSET / 512);
1643
1644 if (fs_size_sec > max_fs_size_sec) {
1645 SLOGE("Orig filesystem overlaps crypto footer region. Cannot encrypt in place.");
1646 goto error_unencrypted;
1647 }
1648 }
1649
Ken Sumrall5d4c68e2011-01-30 19:06:03 -08001650 /* Get a wakelock as this may take a while, and we don't want the
1651 * device to sleep on us. We'll grab a partial wakelock, and if the UI
1652 * wants to keep the screen on, it can grab a full wakelock.
1653 */
Ken Sumrall29d8da82011-05-18 17:20:07 -07001654 snprintf(lockid, sizeof(lockid), "enablecrypto%d", (int) getpid());
Ken Sumrall5d4c68e2011-01-30 19:06:03 -08001655 acquire_wake_lock(PARTIAL_WAKE_LOCK, lockid);
1656
Jeff Sharkey7382f812012-08-23 14:08:59 -07001657 /* Get the sdcard mount point */
Jeff Sharkeyb77bc462012-10-01 14:36:26 -07001658 sd_mnt_point = getenv("EMULATED_STORAGE_SOURCE");
Jeff Sharkey7382f812012-08-23 14:08:59 -07001659 if (!sd_mnt_point) {
1660 sd_mnt_point = getenv("EXTERNAL_STORAGE");
1661 }
1662 if (!sd_mnt_point) {
1663 sd_mnt_point = "/mnt/sdcard";
1664 }
Ken Sumrall29d8da82011-05-18 17:20:07 -07001665
1666 num_vols=vold_getNumDirectVolumes();
1667 vol_list = malloc(sizeof(struct volume_info) * num_vols);
1668 vold_getDirectVolumeList(vol_list);
1669
1670 for (i=0; i<num_vols; i++) {
1671 if (should_encrypt(&vol_list[i])) {
1672 fd = open(vol_list[i].blk_dev, O_RDONLY);
1673 if ( (vol_list[i].size = get_blkdev_size(fd)) == 0) {
1674 SLOGE("Cannot get size of block device %s\n", vol_list[i].blk_dev);
1675 goto error_unencrypted;
1676 }
1677 close(fd);
1678
Ken Sumrall3b170052011-07-11 15:38:57 -07001679 ret=vold_disableVol(vol_list[i].label);
Ken Sumrall319b1042011-06-14 14:01:55 -07001680 if ((ret < 0) && (ret != UNMOUNT_NOT_MOUNTED_ERR)) {
1681 /* -2 is returned when the device exists but is not currently mounted.
1682 * ignore the error and continue. */
Ken Sumrall29d8da82011-05-18 17:20:07 -07001683 SLOGE("Failed to unmount volume %s\n", vol_list[i].label);
1684 goto error_unencrypted;
1685 }
1686 }
1687 }
1688
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001689 /* The init files are setup to stop the class main and late start when
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001690 * vold sets trigger_shutdown_framework.
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001691 */
1692 property_set("vold.decrypt", "trigger_shutdown_framework");
1693 SLOGD("Just asked init to shut down class main\n");
1694
Ken Sumrall425524d2012-06-14 20:55:28 -07001695 if (vold_unmountAllAsecs()) {
1696 /* Just report the error. If any are left mounted,
1697 * umounting /data below will fail and handle the error.
1698 */
1699 SLOGE("Error unmounting internal asecs");
1700 }
1701
Ken Sumrall29d8da82011-05-18 17:20:07 -07001702 property_get("ro.crypto.fuse_sdcard", fuse_sdcard, "");
1703 if (!strcmp(fuse_sdcard, "true")) {
1704 /* This is a device using the fuse layer to emulate the sdcard semantics
1705 * on top of the userdata partition. vold does not manage it, it is managed
1706 * by the sdcard service. The sdcard service was killed by the property trigger
1707 * above, so just unmount it now. We must do this _AFTER_ killing the framework,
1708 * unlike the case for vold managed devices above.
1709 */
1710 if (wait_and_unmount(sd_mnt_point)) {
1711 goto error_shutting_down;
1712 }
Ken Sumrall2eaf7132011-01-14 12:45:48 -08001713 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001714
1715 /* Now unmount the /data partition. */
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001716 if (wait_and_unmount(DATA_MNT_POINT)) {
Ken Sumrall3ed82362011-01-28 23:31:16 -08001717 goto error_shutting_down;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001718 }
1719
1720 /* Do extra work for a better UX when doing the long inplace encryption */
1721 if (how == CRYPTO_ENABLE_INPLACE) {
1722 /* Now that /data is unmounted, we need to mount a tmpfs
1723 * /data, set a property saying we're doing inplace encryption,
1724 * and restart the framework.
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001725 */
Ken Sumralle5032c42012-04-01 23:58:44 -07001726 if (fs_mgr_do_tmpfs_mount(DATA_MNT_POINT)) {
Ken Sumrall3ed82362011-01-28 23:31:16 -08001727 goto error_shutting_down;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001728 }
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001729 /* Tells the framework that inplace encryption is starting */
Ken Sumrall7df84122011-01-18 14:04:08 -08001730 property_set("vold.encrypt_progress", "0");
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001731
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001732 /* restart the framework. */
1733 /* Create necessary paths on /data */
1734 if (prep_data_fs()) {
Ken Sumrall3ed82362011-01-28 23:31:16 -08001735 goto error_shutting_down;
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001736 }
1737
Ken Sumrall92736ef2012-10-17 20:57:14 -07001738 /* Ugh, shutting down the framework is not synchronous, so until it
1739 * can be fixed, this horrible hack will wait a moment for it all to
1740 * shut down before proceeding. Without it, some devices cannot
1741 * restart the graphics services.
1742 */
1743 sleep(2);
1744
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001745 /* startup service classes main and late_start */
1746 property_set("vold.decrypt", "trigger_restart_min_framework");
1747 SLOGD("Just triggered restart_min_framework\n");
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001748
Ken Sumrall7df84122011-01-18 14:04:08 -08001749 /* OK, the framework is restarted and will soon be showing a
1750 * progress bar. Time to setup an encrypted mapping, and
1751 * either write a new filesystem, or encrypt in place updating
1752 * the progress bar as we work.
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001753 */
1754 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001755
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001756 /* Start the actual work of making an encrypted filesystem */
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001757 /* Initialize a crypt_mnt_ftr for the partition */
1758 cryptfs_init_crypt_mnt_ftr(&crypt_ftr);
Ken Sumrall160b4d62013-04-22 12:15:39 -07001759
Ken Sumrall29d8da82011-05-18 17:20:07 -07001760 if (!strcmp(key_loc, KEY_IN_FOOTER)) {
1761 crypt_ftr.fs_size = nr_sec - (CRYPT_FOOTER_OFFSET / 512);
1762 } else {
1763 crypt_ftr.fs_size = nr_sec;
1764 }
Ken Sumralld33d4172011-02-01 00:49:13 -08001765 crypt_ftr.flags |= CRYPT_ENCRYPTION_IN_PROGRESS;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001766 strcpy((char *)crypt_ftr.crypto_type_name, "aes-cbc-essiv:sha256");
1767
1768 /* Make an encrypted master key */
Kenny Rootc4c70f12013-06-14 12:11:38 -07001769 if (create_encrypted_random_key(passwd, crypt_ftr.master_key, crypt_ftr.salt, &crypt_ftr)) {
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001770 SLOGE("Cannot create encrypted master key\n");
Ken Sumrall3ed82362011-01-28 23:31:16 -08001771 goto error_unencrypted;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001772 }
1773
1774 /* Write the key to the end of the partition */
Ken Sumrall160b4d62013-04-22 12:15:39 -07001775 put_crypt_ftr_and_key(&crypt_ftr);
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001776
Ken Sumrall160b4d62013-04-22 12:15:39 -07001777 /* If any persistent data has been remembered, save it.
1778 * If none, create a valid empty table and save that.
1779 */
1780 if (!persist_data) {
1781 pdata = malloc(CRYPT_PERSIST_DATA_SIZE);
1782 if (pdata) {
1783 init_empty_persist_data(pdata, CRYPT_PERSIST_DATA_SIZE);
1784 persist_data = pdata;
1785 }
1786 }
1787 if (persist_data) {
1788 save_persistent_data();
1789 }
1790
JP Abgrall7bdfa522013-11-15 13:42:56 -08001791 decrypt_master_key(passwd, decrypted_master_key, &crypt_ftr);
Ken Sumrall29d8da82011-05-18 17:20:07 -07001792 create_crypto_blk_dev(&crypt_ftr, decrypted_master_key, real_blkdev, crypto_blkdev,
1793 "userdata");
1794
Ken Sumrall128626f2011-06-28 18:45:14 -07001795 /* The size of the userdata partition, and add in the vold volumes below */
1796 tot_encryption_size = crypt_ftr.fs_size;
1797
Ken Sumrall29d8da82011-05-18 17:20:07 -07001798 /* setup crypto mapping for all encryptable volumes handled by vold */
1799 for (i=0; i<num_vols; i++) {
1800 if (should_encrypt(&vol_list[i])) {
1801 vol_list[i].crypt_ftr = crypt_ftr; /* gotta love struct assign */
1802 vol_list[i].crypt_ftr.fs_size = vol_list[i].size;
1803 create_crypto_blk_dev(&vol_list[i].crypt_ftr, decrypted_master_key,
1804 vol_list[i].blk_dev, vol_list[i].crypto_blkdev,
1805 vol_list[i].label);
Ken Sumrall128626f2011-06-28 18:45:14 -07001806 tot_encryption_size += vol_list[i].size;
Ken Sumrall29d8da82011-05-18 17:20:07 -07001807 }
1808 }
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001809
1810 if (how == CRYPTO_ENABLE_WIPE) {
Ken Sumrall29d8da82011-05-18 17:20:07 -07001811 rc = cryptfs_enable_wipe(crypto_blkdev, crypt_ftr.fs_size, EXT4_FS);
1812 /* Encrypt all encryptable volumes handled by vold */
1813 if (!rc) {
1814 for (i=0; i<num_vols; i++) {
1815 if (should_encrypt(&vol_list[i])) {
1816 rc = cryptfs_enable_wipe(vol_list[i].crypto_blkdev,
1817 vol_list[i].crypt_ftr.fs_size, FAT_FS);
1818 }
1819 }
1820 }
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001821 } else if (how == CRYPTO_ENABLE_INPLACE) {
Ken Sumrall29d8da82011-05-18 17:20:07 -07001822 rc = cryptfs_enable_inplace(crypto_blkdev, real_blkdev, crypt_ftr.fs_size,
1823 &cur_encryption_done, tot_encryption_size);
1824 /* Encrypt all encryptable volumes handled by vold */
1825 if (!rc) {
1826 for (i=0; i<num_vols; i++) {
1827 if (should_encrypt(&vol_list[i])) {
1828 rc = cryptfs_enable_inplace(vol_list[i].crypto_blkdev,
1829 vol_list[i].blk_dev,
1830 vol_list[i].crypt_ftr.fs_size,
1831 &cur_encryption_done, tot_encryption_size);
1832 }
1833 }
1834 }
1835 if (!rc) {
1836 /* The inplace routine never actually sets the progress to 100%
1837 * due to the round down nature of integer division, so set it here */
1838 property_set("vold.encrypt_progress", "100");
1839 }
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001840 } else {
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001841 /* Shouldn't happen */
1842 SLOGE("cryptfs_enable: internal error, unknown option\n");
Ken Sumrall3ed82362011-01-28 23:31:16 -08001843 goto error_unencrypted;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001844 }
1845
1846 /* Undo the dm-crypt mapping whether we succeed or not */
Ken Sumrall29d8da82011-05-18 17:20:07 -07001847 delete_crypto_blk_dev("userdata");
1848 for (i=0; i<num_vols; i++) {
1849 if (should_encrypt(&vol_list[i])) {
1850 delete_crypto_blk_dev(vol_list[i].label);
1851 }
1852 }
1853
1854 free(vol_list);
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001855
1856 if (! rc) {
1857 /* Success */
Ken Sumrall7f7dbaa2011-02-01 15:46:41 -08001858
Ken Sumralld33d4172011-02-01 00:49:13 -08001859 /* Clear the encryption in progres flag in the footer */
1860 crypt_ftr.flags &= ~CRYPT_ENCRYPTION_IN_PROGRESS;
Ken Sumrall160b4d62013-04-22 12:15:39 -07001861 put_crypt_ftr_and_key(&crypt_ftr);
Ken Sumralld33d4172011-02-01 00:49:13 -08001862
Ken Sumrall29d8da82011-05-18 17:20:07 -07001863 sleep(2); /* Give the UI a chance to show 100% progress */
Ken Sumralladfba362013-06-04 16:37:52 -07001864 cryptfs_reboot(0);
Ken Sumrall3ed82362011-01-28 23:31:16 -08001865 } else {
Mike Lockwoodee6d8c42012-02-15 13:43:28 -08001866 char value[PROPERTY_VALUE_MAX];
1867
Ken Sumrall319369a2012-06-27 16:30:18 -07001868 property_get("ro.vold.wipe_on_crypt_fail", value, "0");
Mike Lockwoodee6d8c42012-02-15 13:43:28 -08001869 if (!strcmp(value, "1")) {
1870 /* wipe data if encryption failed */
1871 SLOGE("encryption failed - rebooting into recovery to wipe data\n");
1872 mkdir("/cache/recovery", 0700);
Nick Kralevich4684e582012-06-26 15:07:03 -07001873 int fd = open("/cache/recovery/command", O_RDWR|O_CREAT|O_TRUNC, 0600);
Mike Lockwoodee6d8c42012-02-15 13:43:28 -08001874 if (fd >= 0) {
1875 write(fd, "--wipe_data", strlen("--wipe_data") + 1);
1876 close(fd);
1877 } else {
1878 SLOGE("could not open /cache/recovery/command\n");
1879 }
Ken Sumralladfba362013-06-04 16:37:52 -07001880 cryptfs_reboot(1);
Mike Lockwoodee6d8c42012-02-15 13:43:28 -08001881 } else {
1882 /* set property to trigger dialog */
1883 property_set("vold.encrypt_progress", "error_partially_encrypted");
1884 release_wake_lock(lockid);
1885 }
Ken Sumrall3ed82362011-01-28 23:31:16 -08001886 return -1;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001887 }
1888
Ken Sumrall3ed82362011-01-28 23:31:16 -08001889 /* hrm, the encrypt step claims success, but the reboot failed.
1890 * This should not happen.
1891 * Set the property and return. Hope the framework can deal with it.
1892 */
1893 property_set("vold.encrypt_progress", "error_reboot_failed");
Ken Sumrall5d4c68e2011-01-30 19:06:03 -08001894 release_wake_lock(lockid);
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001895 return rc;
Ken Sumrall3ed82362011-01-28 23:31:16 -08001896
1897error_unencrypted:
Ken Sumrall29d8da82011-05-18 17:20:07 -07001898 free(vol_list);
Ken Sumrall3ed82362011-01-28 23:31:16 -08001899 property_set("vold.encrypt_progress", "error_not_encrypted");
Ken Sumrall5d4c68e2011-01-30 19:06:03 -08001900 if (lockid[0]) {
1901 release_wake_lock(lockid);
1902 }
Ken Sumrall3ed82362011-01-28 23:31:16 -08001903 return -1;
1904
1905error_shutting_down:
1906 /* we failed, and have not encrypted anthing, so the users's data is still intact,
1907 * but the framework is stopped and not restarted to show the error, so it's up to
1908 * vold to restart the system.
1909 */
1910 SLOGE("Error enabling encryption after framework is shutdown, no data changed, restarting system");
Ken Sumralladfba362013-06-04 16:37:52 -07001911 cryptfs_reboot(0);
Ken Sumrall3ed82362011-01-28 23:31:16 -08001912
1913 /* shouldn't get here */
1914 property_set("vold.encrypt_progress", "error_shutting_down");
Ken Sumrall29d8da82011-05-18 17:20:07 -07001915 free(vol_list);
Ken Sumrall5d4c68e2011-01-30 19:06:03 -08001916 if (lockid[0]) {
1917 release_wake_lock(lockid);
1918 }
Ken Sumrall3ed82362011-01-28 23:31:16 -08001919 return -1;
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001920}
1921
Jason parks70a4b3f2011-01-28 10:10:47 -06001922int cryptfs_changepw(char *newpw)
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001923{
1924 struct crypt_mnt_ftr crypt_ftr;
Ken Sumrall160b4d62013-04-22 12:15:39 -07001925 unsigned char decrypted_master_key[KEY_LEN_BYTES];
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001926
1927 /* This is only allowed after we've successfully decrypted the master key */
Jason parks70a4b3f2011-01-28 10:10:47 -06001928 if (! master_key_saved) {
Ken Sumrall0cc16632011-01-18 20:32:26 -08001929 SLOGE("Key not saved, aborting");
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001930 return -1;
1931 }
1932
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001933 /* get key */
Ken Sumrall160b4d62013-04-22 12:15:39 -07001934 if (get_crypt_ftr_and_key(&crypt_ftr)) {
Ken Sumrall57b63e62011-01-17 18:29:19 -08001935 SLOGE("Error getting crypt footer and key");
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001936 return -1;
1937 }
1938
Kenny Rootc4c70f12013-06-14 12:11:38 -07001939 encrypt_master_key(newpw, crypt_ftr.salt, saved_master_key, crypt_ftr.master_key, &crypt_ftr);
Ken Sumrall8ddbe402011-01-17 15:26:29 -08001940
Jason parks70a4b3f2011-01-28 10:10:47 -06001941 /* save the key */
Ken Sumrall160b4d62013-04-22 12:15:39 -07001942 put_crypt_ftr_and_key(&crypt_ftr);
Ken Sumrall8f869aa2010-12-03 03:47:09 -08001943
1944 return 0;
1945}
Ken Sumrall160b4d62013-04-22 12:15:39 -07001946
1947static int persist_get_key(char *fieldname, char *value)
1948{
1949 unsigned int i;
1950
1951 if (persist_data == NULL) {
1952 return -1;
1953 }
1954 for (i = 0; i < persist_data->persist_valid_entries; i++) {
1955 if (!strncmp(persist_data->persist_entry[i].key, fieldname, PROPERTY_KEY_MAX)) {
1956 /* We found it! */
1957 strlcpy(value, persist_data->persist_entry[i].val, PROPERTY_VALUE_MAX);
1958 return 0;
1959 }
1960 }
1961
1962 return -1;
1963}
1964
1965static int persist_set_key(char *fieldname, char *value, int encrypted)
1966{
1967 unsigned int i;
1968 unsigned int num;
1969 struct crypt_mnt_ftr crypt_ftr;
1970 unsigned int max_persistent_entries;
1971 unsigned int dsize;
1972
1973 if (persist_data == NULL) {
1974 return -1;
1975 }
1976
1977 /* If encrypted, use the values from the crypt_ftr, otherwise
1978 * use the values for the current spec.
1979 */
1980 if (encrypted) {
1981 if(get_crypt_ftr_and_key(&crypt_ftr)) {
1982 return -1;
1983 }
1984 dsize = crypt_ftr.persist_data_size;
1985 } else {
1986 dsize = CRYPT_PERSIST_DATA_SIZE;
1987 }
1988 max_persistent_entries = (dsize - sizeof(struct crypt_persist_data)) /
1989 sizeof(struct crypt_persist_entry);
1990
1991 num = persist_data->persist_valid_entries;
1992
1993 for (i = 0; i < num; i++) {
1994 if (!strncmp(persist_data->persist_entry[i].key, fieldname, PROPERTY_KEY_MAX)) {
1995 /* We found an existing entry, update it! */
1996 memset(persist_data->persist_entry[i].val, 0, PROPERTY_VALUE_MAX);
1997 strlcpy(persist_data->persist_entry[i].val, value, PROPERTY_VALUE_MAX);
1998 return 0;
1999 }
2000 }
2001
2002 /* We didn't find it, add it to the end, if there is room */
2003 if (persist_data->persist_valid_entries < max_persistent_entries) {
2004 memset(&persist_data->persist_entry[num], 0, sizeof(struct crypt_persist_entry));
2005 strlcpy(persist_data->persist_entry[num].key, fieldname, PROPERTY_KEY_MAX);
2006 strlcpy(persist_data->persist_entry[num].val, value, PROPERTY_VALUE_MAX);
2007 persist_data->persist_valid_entries++;
2008 return 0;
2009 }
2010
2011 return -1;
2012}
2013
2014/* Return the value of the specified field. */
2015int cryptfs_getfield(char *fieldname, char *value, int len)
2016{
2017 char temp_value[PROPERTY_VALUE_MAX];
2018 char real_blkdev[MAXPATHLEN];
2019 /* 0 is success, 1 is not encrypted,
2020 * -1 is value not set, -2 is any other error
2021 */
2022 int rc = -2;
2023
2024 if (persist_data == NULL) {
2025 load_persistent_data();
2026 if (persist_data == NULL) {
2027 SLOGE("Getfield error, cannot load persistent data");
2028 goto out;
2029 }
2030 }
2031
2032 if (!persist_get_key(fieldname, temp_value)) {
2033 /* We found it, copy it to the caller's buffer and return */
2034 strlcpy(value, temp_value, len);
2035 rc = 0;
2036 } else {
2037 /* Sadness, it's not there. Return the error */
2038 rc = -1;
2039 }
2040
2041out:
2042 return rc;
2043}
2044
2045/* Set the value of the specified field. */
2046int cryptfs_setfield(char *fieldname, char *value)
2047{
2048 struct crypt_persist_data stored_pdata;
2049 struct crypt_persist_data *pdata_p;
2050 struct crypt_mnt_ftr crypt_ftr;
2051 char encrypted_state[PROPERTY_VALUE_MAX];
2052 /* 0 is success, -1 is an error */
2053 int rc = -1;
2054 int encrypted = 0;
2055
2056 if (persist_data == NULL) {
2057 load_persistent_data();
2058 if (persist_data == NULL) {
2059 SLOGE("Setfield error, cannot load persistent data");
2060 goto out;
2061 }
2062 }
2063
2064 property_get("ro.crypto.state", encrypted_state, "");
2065 if (!strcmp(encrypted_state, "encrypted") ) {
2066 encrypted = 1;
2067 }
2068
2069 if (persist_set_key(fieldname, value, encrypted)) {
2070 goto out;
2071 }
2072
2073 /* If we are running encrypted, save the persistent data now */
2074 if (encrypted) {
2075 if (save_persistent_data()) {
2076 SLOGE("Setfield error, cannot save persistent data");
2077 goto out;
2078 }
2079 }
2080
2081 rc = 0;
2082
2083out:
2084 return rc;
2085}