From 8f869aa1bc685b505c58e97b4e11a9c7491a16f9 Mon Sep 17 00:00:00 2001 From: Ken Sumrall Date: Fri, 3 Dec 2010 03:47:09 -0800 Subject: [PATCH] Support for encrypting /data on Stingray. There are still a few hacks and performance issues related to shutting down the framework in this code, but it is functional and tested. Without the UI changes, it requires cryptic adb shell commands to enable, which I shall not utter here. Change-Id: I0b8f90afd707e17fbdb0373d156236946633cf8b --- Android.mk | 3 +- CommandListener.cpp | 47 ++- CommandListener.h | 7 + cryptfs.c | 845 ++++++++++++++++++++++++++++++++++++++++++++ cryptfs.h | 60 ++++ 5 files changed, 960 insertions(+), 2 deletions(-) create mode 100644 cryptfs.c create mode 100644 cryptfs.h diff --git a/Android.mk b/Android.mk index e353a4f..7670474 100644 --- a/Android.mk +++ b/Android.mk @@ -21,7 +21,8 @@ common_src_files := \ Loop.cpp \ Devmapper.cpp \ ResponseCode.cpp \ - Xwarp.cpp + Xwarp.cpp \ + cryptfs.c common_c_includes := \ $(KERNEL_HEADERS) \ diff --git a/CommandListener.cpp b/CommandListener.cpp index bc6b9e0..ac46ac9 100644 --- a/CommandListener.cpp +++ b/CommandListener.cpp @@ -36,6 +36,7 @@ #include "Xwarp.h" #include "Loop.h" #include "Devmapper.h" +#include "cryptfs.h" CommandListener::CommandListener() : FrameworkListener("vold") { @@ -46,6 +47,7 @@ CommandListener::CommandListener() : registerCmd(new ShareCmd()); registerCmd(new StorageCmd()); registerCmd(new XwarpCmd()); + registerCmd(new CryptfsCmd()); } void CommandListener::dumpArgs(int argc, char **argv, int argObscure) { @@ -55,7 +57,7 @@ void CommandListener::dumpArgs(int argc, char **argv, int argObscure) { memset(buffer, 0, sizeof(buffer)); int i; for (i = 0; i < argc; i++) { - int len = strlen(argv[i]) + 1; // Account for space + unsigned int len = strlen(argv[i]) + 1; // Account for space if (i == argObscure) { len += 2; // Account for {} } @@ -505,3 +507,46 @@ int CommandListener::XwarpCmd::runCommand(SocketClient *cli, return 0; } + +CommandListener::CryptfsCmd::CryptfsCmd() : + VoldCommand("cryptfs") { +} + +int CommandListener::CryptfsCmd::runCommand(SocketClient *cli, + int argc, char **argv) { + dumpArgs(argc, argv, -1); + + if (argc < 2) { + cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); + return 0; + } + + int rc = 0; + + if (!strcmp(argv[1], "checkpw")) { + if (argc != 3) { + cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs checkpw ", false); + return 0; + } + rc = cryptfs_check_passwd(argv[2]); + } else if (!strcmp(argv[1], "enablecrypto")) { + if ( (argc != 4) || (strcmp(argv[2], "wipe") && strcmp(argv[2], "inplace")) ) { + cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs enablecrypto ", false); + return 0; + } + rc = cryptfs_enable(argv[2], argv[3]); + } else { + cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown cryptfs cmd", false); + } + + if (!rc) { + cli->sendMsg(ResponseCode::CommandOkay, "cryptfs operation succeeded", false); + } else { + int erno = errno; + rc = ResponseCode::convertFromErrno(); + cli->sendMsg(rc, "cryptfs operation failed", true); + } + + return 0; +} + diff --git a/CommandListener.h b/CommandListener.h index 75c7e81..7bae363 100644 --- a/CommandListener.h +++ b/CommandListener.h @@ -76,6 +76,13 @@ private: virtual ~XwarpCmd() {} int runCommand(SocketClient *c, int argc, char ** argv); }; + + class CryptfsCmd : public VoldCommand { + public: + CryptfsCmd(); + virtual ~CryptfsCmd() {} + int runCommand(SocketClient *c, int argc, char ** argv); + }; }; #endif diff --git a/cryptfs.c b/cryptfs.c new file mode 100644 index 0000000..ac2cefd --- /dev/null +++ b/cryptfs.c @@ -0,0 +1,845 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* TO DO: + * 1. Perhaps keep several copies of the encrypted key, in case something + * goes horribly wrong? + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "cryptfs.h" +#define LOG_TAG "Cryptfs" +#include "cutils/log.h" +#include "cutils/properties.h" + +#define DM_CRYPT_BUF_SIZE 4096 + +char *me = "cryptfs"; + +static void ioctl_init(struct dm_ioctl *io, size_t dataSize, const char *name, unsigned flags) +{ + memset(io, 0, dataSize); + io->data_size = dataSize; + io->data_start = sizeof(struct dm_ioctl); + io->version[0] = 4; + io->version[1] = 0; + io->version[2] = 0; + io->flags = flags; + if (name) { + strncpy(io->name, name, sizeof(io->name)); + } +} + +static unsigned int get_blkdev_size(int fd) +{ + unsigned int nr_sec; + + if ( (ioctl(fd, BLKGETSIZE, &nr_sec)) == -1) { + nr_sec = 0; + } + + return nr_sec; +} + +/* key can be NULL, in which case just write out the footer. Useful to + * update the failed mount count but not change the key. + */ +static int put_crypt_ftr_and_key(char *real_blk_name, struct crypt_mnt_ftr *crypt_ftr, + unsigned char *key) +{ + int fd; + unsigned int nr_sec, cnt; + off64_t off; + int rc = -1; + + if ( (fd = open(real_blk_name, O_RDWR)) < 0) { + SLOGE("Cannot open real block device %s\n", real_blk_name); + return -1; + } + + if ( (nr_sec = get_blkdev_size(fd)) == 0) { + SLOGE("Cannot get size of block device %s\n", real_blk_name); + goto errout; + } + + /* If it's an encrypted Android partition, the last 16 Kbytes contain the + * encryption info footer and key, and plenty of bytes to spare for future + * growth. + */ + off = ((off64_t)nr_sec * 512) - CRYPT_FOOTER_OFFSET; + + if (lseek64(fd, off, SEEK_SET) == -1) { + SLOGE("Cannot seek to real block device footer\n"); + goto errout; + } + + if ((cnt = write(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr))) != sizeof(struct crypt_mnt_ftr)) { + SLOGE("Cannot write real block device footer\n"); + goto errout; + } + + if (key) { + if (crypt_ftr->keysize != 16) { + SLOGE("Keysize of %d bits not supported for real block device %s\n", + crypt_ftr->keysize * 8, real_blk_name); + goto errout; + } + + if ( (cnt = write(fd, key, crypt_ftr->keysize)) != crypt_ftr->keysize) { + SLOGE("Cannot write key for real block device %s\n", real_blk_name); + goto errout; + } + } + + /* Success! */ + rc = 0; + +errout: + close(fd); + return rc; + +} + +static int get_crypt_ftr_and_key(char *real_blk_name, struct crypt_mnt_ftr *crypt_ftr, + unsigned char *key) +{ + int fd; + unsigned int nr_sec, cnt; + off64_t off; + int rc = -1; + + if ( (fd = open(real_blk_name, O_RDWR)) < 0) { + SLOGE("Cannot open real block device %s\n", real_blk_name); + return -1; + } + + if ( (nr_sec = get_blkdev_size(fd)) == 0) { + SLOGE("Cannot get size of block device %s\n", real_blk_name); + goto errout; + } + + /* If it's an encrypted Android partition, the last 16 Kbytes contain the + * encryption info footer and key, and plenty of bytes to spare for future + * growth. + */ +#if 1 /* The real location, use when the enable code works */ + off = ((off64_t)nr_sec * 512) - CRYPT_FOOTER_OFFSET; +#else + /* For testing, I'm slapping a handbuild header after my 200 megabyte + * /data partition. So my offset if 200 megabytes */ + off = 200*1024*1024; +#endif + + if (lseek64(fd, off, SEEK_SET) == -1) { + SLOGE("Cannot seek to real block device footer\n"); + goto errout; + } + + if ( (cnt = read(fd, crypt_ftr, sizeof(struct crypt_mnt_ftr))) != sizeof(struct crypt_mnt_ftr)) { + SLOGE("Cannot read real block device footer\n"); + goto errout; + } + + if (crypt_ftr->magic != CRYPT_MNT_MAGIC) { + SLOGE("Bad magic for real block device %s\n", real_blk_name); + goto errout; + } + + if (crypt_ftr->major_version != 1) { + SLOGE("Cannot understand major version %d real block device footer\n", + crypt_ftr->major_version); + goto errout; + } + + if (crypt_ftr->minor_version != 0) { + SLOGW("Warning: crypto footer minor version %d, expected 0, continuing...\n", + crypt_ftr->minor_version); + } + + if (crypt_ftr->ftr_size > sizeof(struct crypt_mnt_ftr)) { + /* the footer size is bigger than we expected. + * Skip to it's stated end so we can read the key. + */ + if (lseek(fd, crypt_ftr->ftr_size - sizeof(struct crypt_mnt_ftr), SEEK_CUR) == -1) { + SLOGE("Cannot seek to start of key\n"); + goto errout; + } + } + + if (crypt_ftr->keysize != 16) { + SLOGE("Keysize of %d bits not supported for real block device %s\n", + crypt_ftr->keysize * 8, real_blk_name); + goto errout; + } + + if ( (cnt = read(fd, key, crypt_ftr->keysize)) != crypt_ftr->keysize) { + SLOGE("Cannot read key for real block device %s\n", real_blk_name); + goto errout; + } + + /* Success! */ + rc = 0; + +errout: + close(fd); + return rc; +} + +/* Convert a binary key of specified length into an ascii hex string equivalent, + * without the leading 0x and with null termination + */ +void convert_key_to_hex_ascii(unsigned char *master_key, unsigned int keysize, + char *master_key_ascii) +{ + unsigned int i, a; + unsigned char nibble; + + for (i=0, a=0; i> 4) & 0xf; + master_key_ascii[a] = nibble + (nibble > 9 ? 0x37 : 0x30); + + nibble = master_key[i] & 0xf; + master_key_ascii[a+1] = nibble + (nibble > 9 ? 0x37 : 0x30); + } + + /* Add the null termination */ + master_key_ascii[a] = '\0'; + +} + +static int create_crypto_blk_dev(struct crypt_mnt_ftr *crypt_ftr, unsigned char *master_key, + char *real_blk_name, char *crypto_blk_name) +{ + char buffer[DM_CRYPT_BUF_SIZE]; + char master_key_ascii[129]; /* Large enough to hold 512 bit key and null */ + char *crypt_params; + struct dm_ioctl *io; + struct dm_target_spec *tgt; + unsigned int minor; + int fd; + int retval = -1; + char *name ="datadev"; /* FIX ME: Make me a parameter */ + + if ((fd = open("/dev/device-mapper", O_RDWR)) < 0 ) { + SLOGE("Cannot open device-mapper\n"); + goto errout; + } + + io = (struct dm_ioctl *) buffer; + + ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0); + if (ioctl(fd, DM_DEV_CREATE, io)) { + SLOGE("Cannot create dm-crypt device\n"); + goto errout; + } + + /* Get the device status, in particular, the name of it's device file */ + ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0); + if (ioctl(fd, DM_DEV_STATUS, io)) { + SLOGE("Cannot retrieve dm-crypt device status\n"); + goto errout; + } + minor = (io->dev & 0xff) | ((io->dev >> 12) & 0xfff00); + snprintf(crypto_blk_name, MAXPATHLEN, "/dev/block/dm-%u", minor); + + /* Load the mapping table for this device */ + tgt = (struct dm_target_spec *) &buffer[sizeof(struct dm_ioctl)]; + + ioctl_init(io, 4096, name, 0); + io->target_count = 1; + tgt->status = 0; + tgt->sector_start = 0; + tgt->length = crypt_ftr->fs_size; + strcpy(tgt->target_type, "crypt"); + + crypt_params = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec); + convert_key_to_hex_ascii(master_key, crypt_ftr->keysize, master_key_ascii); + sprintf(crypt_params, "%s %s 0 %s 0", crypt_ftr->crypto_type_name, + master_key_ascii, real_blk_name); + SLOGD("crypt_params = %s\n", crypt_params); + crypt_params += strlen(crypt_params) + 1; + crypt_params = (char *) (((unsigned long)crypt_params + 7) & ~8); /* Align to an 8 byte boundary */ + tgt->next = crypt_params - buffer; + + if (ioctl(fd, DM_TABLE_LOAD, io)) { + SLOGE("Cannot load dm-crypt mapping table.\n"); + goto errout; + } + + /* Resume this device to activate it */ + ioctl_init(io, 4096, name, 0); + + if (ioctl(fd, DM_DEV_SUSPEND, io)) { + SLOGE("Cannot resume the dm-crypt device\n"); + goto errout; + } + + /* We made it here with no errors. Woot! */ + retval = 0; + +errout: + close(fd); /* If fd is <0 from a failed open call, it's safe to just ignore the close error */ + + return retval; +} + +static int delete_crypto_blk_dev(char *crypto_blkdev) +{ + int fd; + char buffer[DM_CRYPT_BUF_SIZE]; + struct dm_ioctl *io; + char *name ="datadev"; /* FIX ME: Make me a paraameter */ + int retval = -1; + + if ((fd = open("/dev/device-mapper", O_RDWR)) < 0 ) { + SLOGE("Cannot open device-mapper\n"); + goto errout; + } + + io = (struct dm_ioctl *) buffer; + + ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0); + if (ioctl(fd, DM_DEV_REMOVE, io)) { + SLOGE("Cannot remove dm-crypt device\n"); + goto errout; + } + + /* We made it here with no errors. Woot! */ + retval = 0; + +errout: + close(fd); /* If fd is <0 from a failed open call, it's safe to just ignore the close error */ + + return retval; + +} + +/* If we need to debug this, look at Devmapper.cpp:dumpState(), + * It does DM_LIST_DEVICES, then iterates on each device and + * calls DM_DEV_STATUS. + */ + +#define HASH_COUNT 2000 +#define KEY_LEN_BYTES 16 +#define IV_LEN_BYTES 16 + +static int create_encrypted_random_key(char *passwd, unsigned char *master_key) +{ + int fd; + unsigned char buf[KEY_LEN_BYTES]; + unsigned char ikey[32+32] = { 0 }; /* Big enough to hold a 256 bit key and 256 bit IV */ + unsigned char salt[32] = { 0 }; + EVP_CIPHER_CTX e_ctx; + int encrypted_len, final_len; + + /* Get some random bits for a key */ + fd = open("/dev/urandom", O_RDONLY); + read(fd, buf, sizeof(buf)); + close(fd); + + /* Now encrypt it with the password */ + /* To Do: Make a salt based on some immutable data about this device. + * IMEI, or MEID, or CPU serial number, or whatever we can find + */ + /* Turn the password into a key and IV that can decrypt the master key */ + PKCS5_PBKDF2_HMAC_SHA1(passwd, strlen(passwd), salt, sizeof(salt), + HASH_COUNT, KEY_LEN_BYTES+IV_LEN_BYTES, ikey); + + /* Initialize the decryption engine */ + if (! EVP_EncryptInit(&e_ctx, EVP_aes_128_cbc(), ikey, ikey+KEY_LEN_BYTES)) { + SLOGE("EVP_EncryptInit failed\n"); + return -1; + } + EVP_CIPHER_CTX_set_padding(&e_ctx, 0); /* Turn off padding as our data is block aligned */ + /* Encrypt the master key */ + if (! EVP_EncryptUpdate(&e_ctx, master_key, &encrypted_len, + buf, KEY_LEN_BYTES)) { + SLOGE("EVP_EncryptUpdate failed\n"); + return -1; + } + if (! EVP_EncryptFinal(&e_ctx, master_key + encrypted_len, &final_len)) { + SLOGE("EVP_EncryptFinal failed\n"); + return -1; + } + + if (encrypted_len + final_len != KEY_LEN_BYTES) { + SLOGE("EVP_Encryption length check failed with %d, %d bytes\n", encrypted_len, final_len); + return -1; + } else { + return 0; + } +} + +static int decrypt_master_key(char *passwd, unsigned char *encrypted_master_key, + unsigned char *decrypted_master_key) +{ + unsigned char ikey[32+32] = { 0 }; /* Big enough to hold a 256 bit key and 256 bit IV */ + unsigned char salt[32] = { 0 }; + EVP_CIPHER_CTX d_ctx; + int decrypted_len, final_len; + + /* To Do: Make a salt based on some immutable data about this device. + * IMEI, or MEID, or CPU serial number, or whatever we can find + */ + /* Turn the password into a key and IV that can decrypt the master key */ + PKCS5_PBKDF2_HMAC_SHA1(passwd, strlen(passwd), salt, sizeof(salt), + HASH_COUNT, KEY_LEN_BYTES+IV_LEN_BYTES, ikey); + + /* Initialize the decryption engine */ + if (! EVP_DecryptInit(&d_ctx, EVP_aes_128_cbc(), ikey, ikey+KEY_LEN_BYTES)) { + return -1; + } + EVP_CIPHER_CTX_set_padding(&d_ctx, 0); /* Turn off padding as our data is block aligned */ + /* Decrypt the master key */ + if (! EVP_DecryptUpdate(&d_ctx, decrypted_master_key, &decrypted_len, + encrypted_master_key, KEY_LEN_BYTES)) { + return -1; + } + if (! EVP_DecryptFinal(&d_ctx, decrypted_master_key + decrypted_len, &final_len)) { + return -1; + } + + if (decrypted_len + final_len != KEY_LEN_BYTES) { + return -1; + } else { + return 0; + } +} + +static int get_orig_mount_parms(char *mount_point, char *fs_type, char *real_blkdev, + unsigned long *mnt_flags, char *fs_options) +{ + char mount_point2[32]; + char fs_flags[32]; + + property_get("ro.crypto.fs_type", fs_type, ""); + property_get("ro.crypto.fs_real_blkdev", real_blkdev, ""); + property_get("ro.crypto.fs_mnt_point", mount_point2, ""); + property_get("ro.crypto.fs_options", fs_options, ""); + property_get("ro.crypto.fs_flags", fs_flags, ""); + *mnt_flags = strtol(fs_flags, 0, 0); + + if (strcmp(mount_point, mount_point2)) { + /* Consistency check. These should match. If not, something odd happened. */ + return -1; + } + + return 0; +} + +static int wait_and_unmount(char *mountpoint) +{ + int i, rc; +#define WAIT_UNMOUNT_COUNT 100 + + /* Now umount the tmpfs filesystem */ + for (i=0; ifs_size = %lld\n", crypt_ftr.fs_size); + orig_failed_decrypt_count = crypt_ftr.failed_decrypt_count; + + if (! (crypt_ftr.flags & CRYPT_MNT_KEY_UNENCRYPTED) ) { + decrypt_master_key(passwd, encrypted_master_key, decrypted_master_key); + } + + if (create_crypto_blk_dev(&crypt_ftr, decrypted_master_key, + real_blkdev, crypto_blkdev)) { + SLOGE("Error creating decrypted block device\n"); + return -1; + } + + /* If init detects an encrypted filesystme, it writes a file for each such + * encrypted fs into the tmpfs /data filesystem, and then the framework finds those + * files and passes that data to me */ + /* Create a tmp mount point to try mounting the decryptd fs + * Since we're here, the mount_point should be a tmpfs filesystem, so make + * a directory in it to test mount the decrypted filesystem. + */ + sprintf(tmp_mount_point, "%s/tmp_mnt", mount_point); + mkdir(tmp_mount_point, 0755); + if ( mount(crypto_blkdev, tmp_mount_point, "ext4", MS_RDONLY, "") ) { + SLOGE("Error temp mounting decrypted block device\n"); + delete_crypto_blk_dev(crypto_blkdev); + crypt_ftr.failed_decrypt_count++; + } else { + /* Success, so just umount and we'll mount it properly when we restart + * the framework. + */ + umount(tmp_mount_point); + crypt_ftr.failed_decrypt_count = 0; + } + + if (orig_failed_decrypt_count != crypt_ftr.failed_decrypt_count) { + put_crypt_ftr_and_key(real_blkdev, &crypt_ftr, 0); + } + + if (crypt_ftr.failed_decrypt_count) { + /* We failed to mount the device, so return an error */ + rc = crypt_ftr.failed_decrypt_count; + + } else { + /* Woot! Success! Time to do the magic of unmounting the tmpfs + * disk and mounting the encrypted one. + */ + rc = cryptfs_restart(crypto_blkdev); + } + + return rc; +} + +int cryptfs_check_passwd(char *passwd) +{ + int rc = -1; + + rc = test_mount_encrypted_fs(passwd, "/data"); + + return rc; +} + +/* Initialize a crypt_mnt_ftr structure. The keysize is + * defaulted to 16 bytes, and the filesystem size to 0. + * Presumably, at a minimum, the caller will update the + * filesystem size and crypto_type_name after calling this function. + */ +static void cryptfs_init_crypt_mnt_ftr(struct crypt_mnt_ftr *ftr) +{ + ftr->magic = CRYPT_MNT_MAGIC; + ftr->major_version = 1; + ftr->minor_version = 0; + ftr->ftr_size = sizeof(struct crypt_mnt_ftr); + ftr->flags = 0; + ftr->keysize = 16; + ftr->spare1 = 0; + ftr->fs_size = 0; + ftr->failed_decrypt_count = 0; + ftr->crypto_type_name[0] = '\0'; +} + +static int cryptfs_enable_wipe(char *crypto_blkdev, off64_t size) +{ + char cmdline[256]; + int rc = -1; + + snprintf(cmdline, sizeof(cmdline), "/system/bin/make_ext4fs -a /data -l %lld %s", + size * 512, crypto_blkdev); + SLOGI("Making empty filesystem with command %s\n", cmdline); + if (system(cmdline)) { + SLOGE("Error creating empty filesystem on %s\n", crypto_blkdev); + } else { + SLOGD("Successfully created empty filesystem on %s\n", crypto_blkdev); + rc = 0; + } + + return rc; +} + +static inline int unix_read(int fd, void* buff, int len) +{ + int ret; + do { ret = read(fd, buff, len); } while (ret < 0 && errno == EINTR); + return ret; +} + +static inline int unix_write(int fd, const void* buff, int len) +{ + int ret; + do { ret = write(fd, buff, len); } while (ret < 0 && errno == EINTR); + return ret; +} + +#define CRYPT_INPLACE_BUFSIZE 4096 +#define CRYPT_SECTORS_PER_BUFSIZE (CRYPT_INPLACE_BUFSIZE / 512) +static int cryptfs_enable_inplace(char *crypto_blkdev, char *real_blkdev, off64_t size) +{ + int realfd, cryptofd; + char *buf[CRYPT_INPLACE_BUFSIZE]; + int rc = -1; + off64_t numblocks, i, remainder; + + if ( (realfd = open(real_blkdev, O_RDONLY)) < 0) { + SLOGE("Error opening real_blkdev %s for inplace encrypt\n", real_blkdev); + return -1; + } + + if ( (cryptofd = open(crypto_blkdev, O_WRONLY)) < 0) { + SLOGE("Error opening crypto_blkdev %s for inplace encrypt\n", crypto_blkdev); + close(realfd); + return -1; + } + + /* This is pretty much a simple loop of reading 4K, and writing 4K. + * The size passed in is the number of 512 byte sectors in the filesystem. + * So compute the number of whole 4K blocks we should read/write, + * and the remainder. + */ + numblocks = size / CRYPT_SECTORS_PER_BUFSIZE; + remainder = size % CRYPT_SECTORS_PER_BUFSIZE; + + SLOGE("Encrypting filesystem in place..."); + + /* process the majority of the filesystem in blocks */ + for (i=0; i