summaryrefslogtreecommitdiffstats
path: root/crypto/lollipop
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--crypto/fde/cryptfs.h (renamed from crypto/lollipop/cryptfs.h)119
-rw-r--r--crypto/fde/main.cpp (renamed from crypto/lollipop/main.c)21
-rw-r--r--crypto/lollipop/Android.mk62
-rw-r--r--crypto/lollipop/cryptfs.c1579
4 files changed, 67 insertions, 1714 deletions
diff --git a/crypto/lollipop/cryptfs.h b/crypto/fde/cryptfs.h
index cd07e5af7..c67113a75 100644
--- a/crypto/lollipop/cryptfs.h
+++ b/crypto/fde/cryptfs.h
@@ -14,6 +14,9 @@
* limitations under the License.
*/
+#ifndef ANDROID_VOLD_CRYPTFS_H
+#define ANDROID_VOLD_CRYPTFS_H
+
/* This structure starts 16,384 bytes before the end of a hardware
* partition that is encrypted, or in a separate partition. It's location
* is specified by a property set in init.<device>.rc.
@@ -26,8 +29,9 @@
* partition.
*/
+#include <stdbool.h>
+#include <stdint.h>
#include <cutils/properties.h>
-#include "openssl/sha.h"
/* The current cryptfs version */
#define CURRENT_MAJOR_VERSION 1
@@ -52,6 +56,16 @@
correctly marked partial encryption */
#define CRYPT_DATA_CORRUPT 0x8 /* Set when encryption is fine, but the
underlying volume is corrupt */
+#define CRYPT_FORCE_ENCRYPTION 0x10 /* Set when it is time to encrypt this
+ volume on boot. Everything in this
+ structure is set up correctly as
+ though device is encrypted except
+ that the master key is encrypted with the
+ default password. */
+#define CRYPT_FORCE_COMPLETE 0x20 /* Set when the above encryption cycle is
+ complete. On next cryptkeeper entry, match
+ the password. If it matches fix the master
+ key and remove this flag. */
#ifdef CONFIG_HW_DISK_ENCRYPTION
/* This flag is used to transition from L->M upgrade. L release passed
* a byte for every nible of user password while M release is passing
@@ -60,6 +74,7 @@
*/
#define CRYPT_ASCII_PASSWORD_UPDATED 0x1000
#endif
+
/* Allowed values for type in the structure below */
#define CRYPT_TYPE_PASSWORD 0 /* master_key is encrypted with a password
* Must be zero to be compatible with pre-L
@@ -73,14 +88,10 @@
#define CRYPT_MNT_MAGIC 0xD0B5B1C4
#define PERSIST_DATA_MAGIC 0xE950CD44
-#define SCRYPT_PROP "ro.crypto.scrypt_params"
-#define SCRYPT_DEFAULTS { 15, 3, 1 }
-
/* Key Derivation Function algorithms */
#define KDF_PBKDF2 1
#define KDF_SCRYPT 2
-/* TODO(paullawrence): Remove KDF_SCRYPT_KEYMASTER_UNPADDED and KDF_SCRYPT_KEYMASTER_BADLY_PADDED
- * when it is safe to do so. */
+/* Algorithms 3 & 4 deprecated before shipping outside of google, so removed */
#define KDF_SCRYPT_KEYMASTER_UNPADDED 3
#define KDF_SCRYPT_KEYMASTER_BADLY_PADDED 4
#define KDF_SCRYPT_KEYMASTER 5
@@ -91,6 +102,10 @@
/* __le32 and __le16 defined in system/extras/ext4_utils/ext4_utils.h */
#define __le8 unsigned char
+#if !defined(SHA256_DIGEST_LENGTH)
+#define SHA256_DIGEST_LENGTH 32
+#endif
+
struct crypt_mnt_ftr {
__le32 magic; /* See above */
__le16 major_version;
@@ -100,7 +115,7 @@ struct crypt_mnt_ftr {
__le32 keysize; /* in bytes */
__le32 crypt_type; /* how master_key is encrypted. Must be a
* CRYPT_TYPE_XXX value */
- __le64 fs_size; /* Size of the encrypted fs, in 512 byte sectors */
+ __le64 fs_size; /* Size of the encrypted fs, in 512 byte sectors */
__le32 failed_decrypt_count; /* count of # of failed attempts to decrypt and
mount, set to 0 on successful mount */
unsigned char crypto_type_name[MAX_CRYPTO_TYPE_NAME_LEN]; /* The type of encryption
@@ -151,79 +166,43 @@ struct crypt_mnt_ftr {
then we will be OK.
*/
unsigned char scrypted_intermediate_key[SCRYPT_LEN];
-};
-
-/* Persistant data that should be available before decryption.
- * Things like airplane mode, locale and timezone are kept
- * here and can be retrieved by the CryptKeeper UI to properly
- * configure the phone before asking for the password
- * This is only valid if the major and minor version above
- * is set to 1.1 or higher.
- *
- * This is a 4K structure. There are 2 copies, and the code alternates
- * writing one and then clearing the previous one. The reading
- * code reads the first valid copy it finds, based on the magic number.
- * The absolute offset to the first of the two copies is kept in rev 1.1
- * and higher crypt_mnt_ftr structures.
- */
-struct crypt_persist_entry {
- char key[PROPERTY_KEY_MAX];
- char val[PROPERTY_VALUE_MAX];
-};
-
-/* Should be exactly 4K in size */
-struct crypt_persist_data {
- __le32 persist_magic;
- __le32 persist_valid_entries;
- __le32 persist_spare[30];
- struct crypt_persist_entry persist_entry[0];
-};
-struct volume_info {
- unsigned int size;
- unsigned int flags;
- struct crypt_mnt_ftr crypt_ftr;
- char mnt_point[256];
- char blk_dev[256];
- char crypto_blkdev[256];
- char label[256];
+ /* sha of this structure with this element set to zero
+ Used when encrypting on reboot to validate structure before doing something
+ fatal
+ */
+ unsigned char sha256[SHA256_DIGEST_LENGTH];
};
-#define VOL_NONREMOVABLE 0x1
-#define VOL_ENCRYPTABLE 0x2
-#define VOL_PRIMARY 0x4
-#define VOL_PROVIDES_ASEC 0x8
#define DATA_MNT_POINT "/data"
/* Return values for cryptfs_crypto_complete */
#define CRYPTO_COMPLETE_NOT_ENCRYPTED 1
#define CRYPTO_COMPLETE_ENCRYPTED 0
-#define CRYPTO_COMPLETE_BAD_METADATA -1
-#define CRYPTO_COMPLETE_PARTIAL -2
-#define CRYPTO_COMPLETE_INCONSISTENT -3
-#define CRYPTO_COMPLETE_CORRUPT -4
+#define CRYPTO_COMPLETE_BAD_METADATA (-1)
+#define CRYPTO_COMPLETE_PARTIAL (-2)
+#define CRYPTO_COMPLETE_INCONSISTENT (-3)
+#define CRYPTO_COMPLETE_CORRUPT (-4)
/* Return values for cryptfs_enable_inplace*() */
#define ENABLE_INPLACE_OK 0
-#define ENABLE_INPLACE_ERR_OTHER -1
-#define ENABLE_INPLACE_ERR_DEV -2 /* crypto_blkdev issue */
+#define ENABLE_INPLACE_ERR_OTHER (-1)
+#define ENABLE_INPLACE_ERR_DEV (-2) /* crypto_blkdev issue */
-#ifdef __cplusplus
-extern "C" {
-#endif
+typedef int (*kdf_func)(const char* passwd, const unsigned char* salt, unsigned char* ikey,
+ void* params);
- typedef int (*kdf_func)(const char *passwd, const unsigned char *salt,
- unsigned char *ikey, void *params);
-
- void set_partition_data(const char* block_device, const char* key_location, const char* fs);
- int cryptfs_check_footer();
- int cryptfs_check_passwd(char *pw);
- int cryptfs_verify_passwd(char *newpw);
- int cryptfs_get_password_type(void);
- int delete_crypto_blk_dev(char *name);
- int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev,
- const unsigned char* key, int keysize, char* out_crypto_blkdev);
- int cryptfs_revert_ext_volume(const char* label);
-#ifdef __cplusplus
-}
-#endif
+int cryptfs_check_passwd(const char* pw);
+int cryptfs_verify_passwd(const char* pw);
+int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev, const unsigned char* key, int keysize, char* out_crypto_blkdev);
+int cryptfs_revert_ext_volume(const char* label);
+int cryptfs_get_password_type(void);
+
+uint32_t cryptfs_get_keysize();
+const char* cryptfs_get_crypto_name();
+
+void set_partition_data(const char* block_device, const char* key_location, const char* fs);
+int cryptfs_check_footer();
+int delete_crypto_blk_dev(const char *name);
+
+#endif /* ANDROID_VOLD_CRYPTFS_H */
diff --git a/crypto/lollipop/main.c b/crypto/fde/main.cpp
index 232afb959..7051a6d7b 100644
--- a/crypto/lollipop/main.c
+++ b/crypto/fde/main.cpp
@@ -24,9 +24,24 @@
#include "cutils/properties.h"
#include "crypto_scrypt.h"
-int main() {
- set_partition_data("/dev/block/platform/sdhci-tegra.3/by-name/UDA", "/dev/block/platform/sdhci-tegra.3/by-name/MD1", "f2fs");
+void usage() {
+ printf(" Usage:\n");
+ printf(" twrpdec /path/to/userdata /path/to/metadata filesystem password\n");
+ printf("\n");
+ printf(" The metadata path is the path to the footer. If no metadata\n");
+ printf(" partition is present then use footer for this argument.\n");
+ printf("\n");
+ printf(" Example:\n");
+ printf(" twrpdec /dev/block/bootdevice/by-name/userdata footer ext4 0000\n");
+}
+
+int main(int argc, char **argv) {
+ if (argc != 5) {
+ usage();
+ return -1;
+ }
+ set_partition_data(argv[1], argv[2], argv[3]);
//int ret = cryptfs_check_passwd("30303030");
- int ret = cryptfs_check_passwd("0000");
+ int ret = cryptfs_check_passwd(argv[4]);
return 0;
}
diff --git a/crypto/lollipop/Android.mk b/crypto/lollipop/Android.mk
deleted file mode 100644
index 1be412138..000000000
--- a/crypto/lollipop/Android.mk
+++ /dev/null
@@ -1,62 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-ifeq ($(TW_INCLUDE_CRYPTO), true)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := libcryptfslollipop
-LOCAL_MODULE_TAGS := eng optional
-LOCAL_CFLAGS :=
-LOCAL_SRC_FILES = cryptfs.c
-LOCAL_SHARED_LIBRARIES := libcrypto libhardware libcutils
-LOCAL_C_INCLUDES := external/openssl/include $(commands_recovery_local_path)/crypto/scrypt/lib/crypto
-
-ifeq ($(TARGET_HW_DISK_ENCRYPTION),true)
- ifeq ($(TARGET_CRYPTFS_HW_PATH),)
- LOCAL_C_INCLUDES += device/qcom/common/cryptfs_hw
- else
- LOCAL_C_INCLUDES += $(TARGET_CRYPTFS_HW_PATH)
- endif
- LOCAL_SHARED_LIBRARIES += libcryptfs_hw
- LOCAL_CFLAGS += -DCONFIG_HW_DISK_ENCRYPTION
-endif
-
-ifneq ($(wildcard hardware/libhardware/include/hardware/keymaster0.h),)
- LOCAL_CFLAGS += -DTW_CRYPTO_HAVE_KEYMASTERX
- LOCAL_C_INCLUDES += external/boringssl/src/include
-endif
-
-LOCAL_CFLAGS += -Wno-unused-function
-
-LOCAL_WHOLE_STATIC_LIBRARIES += libscrypttwrp_static
-
-include $(BUILD_SHARED_LIBRARY)
-
-
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := twrpdec
-LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_CLASS := RECOVERY_EXECUTABLES
-LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin
-LOCAL_SRC_FILES := main.c cryptfs.c
-LOCAL_SHARED_LIBRARIES := libcrypto libhardware libcutils libc
-LOCAL_C_INCLUDES := external/openssl/include $(commands_recovery_local_path)/crypto/scrypt/lib/crypto
-
-ifeq ($(TARGET_HW_DISK_ENCRYPTION),true)
- ifeq ($(TARGET_CRYPTFS_HW_PATH),)
- LOCAL_C_INCLUDES += device/qcom/common/cryptfs_hw
- else
- LOCAL_C_INCLUDES += $(TARGET_CRYPTFS_HW_PATH)
- endif
- LOCAL_SHARED_LIBRARIES += libcryptfs_hw
- LOCAL_CFLAGS += -DCONFIG_HW_DISK_ENCRYPTION
-endif
-
-ifneq ($(wildcard hardware/libhardware/include/hardware/keymaster0.h),)
- LOCAL_CFLAGS += -DTW_CRYPTO_HAVE_KEYMASTERX
- LOCAL_C_INCLUDES += external/boringssl/src/include
-endif
-
-LOCAL_WHOLE_STATIC_LIBRARIES += libscrypttwrp_static
-include $(BUILD_EXECUTABLE)
-
-endif
diff --git a/crypto/lollipop/cryptfs.c b/crypto/lollipop/cryptfs.c
deleted file mode 100644
index d3bf62955..000000000
--- a/crypto/lollipop/cryptfs.c
+++ /dev/null
@@ -1,1579 +0,0 @@
-/*
- * 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 <sys/types.h>
-#include <linux/types.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <ctype.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/ioctl.h>
-#include <linux/dm-ioctl.h>
-#include <libgen.h>
-#include <stdlib.h>
-#include <sys/param.h>
-#include <string.h>
-#include <sys/mount.h>
-#include <openssl/evp.h>
-#include <errno.h>
-#include <linux/kdev_t.h>
-#include <time.h>
-#include "cryptfs.h"
-#include "cutils/properties.h"
-#include "crypto_scrypt.h"
-
-#ifndef TW_CRYPTO_HAVE_KEYMASTERX
-#include <hardware/keymaster.h>
-#else
-#include <stdbool.h>
-#include <openssl/evp.h>
-#include <openssl/sha.h>
-#include <hardware/keymaster0.h>
-#include <hardware/keymaster1.h>
-#endif
-
-#ifndef min /* already defined by windows.h */
-#define min(a, b) ((a) < (b) ? (a) : (b))
-#endif
-
-#define UNUSED __attribute__((unused))
-
-#define UNUSED __attribute__((unused))
-
-#ifdef CONFIG_HW_DISK_ENCRYPTION
-#include "cryptfs_hw.h"
-#endif
-
-#define DM_CRYPT_BUF_SIZE 4096
-
-#define HASH_COUNT 2000
-#define KEY_LEN_BYTES 16
-#define IV_LEN_BYTES 16
-
-#define KEY_IN_FOOTER "footer"
-
-#define EXT4_FS 1
-#define F2FS_FS 2
-
-#define TABLE_LOAD_RETRIES 10
-
-#define RSA_KEY_SIZE 2048
-#define RSA_KEY_SIZE_BYTES (RSA_KEY_SIZE / 8)
-#define RSA_EXPONENT 0x10001
-#define KEYMASTER_CRYPTFS_RATE_LIMIT 1 // Maximum one try per second
-
-#define RETRY_MOUNT_ATTEMPTS 10
-#define RETRY_MOUNT_DELAY_SECONDS 1
-
-char *me = "cryptfs";
-
-static int master_key_saved = 0;
-static char key_fname[PROPERTY_VALUE_MAX] = "";
-static char real_blkdev[PROPERTY_VALUE_MAX] = "";
-static char file_system[PROPERTY_VALUE_MAX] = "";
-
-#ifdef CONFIG_HW_DISK_ENCRYPTION
-static int scrypt_keymaster(const char *passwd, const unsigned char *salt,
- unsigned char *ikey, void *params);
-static void convert_key_to_hex_ascii(const unsigned char *master_key,
- unsigned int keysize, char *master_key_ascii);
-static int get_keymaster_hw_fde_passwd(const char* passwd, unsigned char* newpw,
- unsigned char* salt,
- const struct crypt_mnt_ftr *ftr)
-{
- /* if newpw updated, return 0
- * if newpw not updated return -1
- */
- int rc = -1;
-
- if (should_use_keymaster()) {
- if (scrypt_keymaster(passwd, salt, newpw, (void*)ftr)) {
- printf("scrypt failed");
- } else {
- rc = 0;
- }
- }
-
- return rc;
-}
-
-static int verify_hw_fde_passwd(char *passwd, struct crypt_mnt_ftr* crypt_ftr)
-{
- unsigned char newpw[32] = {0};
- int key_index;
- if (get_keymaster_hw_fde_passwd(passwd, newpw, crypt_ftr->salt, crypt_ftr))
- key_index = set_hw_device_encryption_key(passwd,
- (char*) crypt_ftr->crypto_type_name);
- else
- key_index = set_hw_device_encryption_key((const char*)newpw,
- (char*) crypt_ftr->crypto_type_name);
- return key_index;
-}
-#endif
-
-void set_partition_data(const char* block_device, const char* key_location, const char* fs)
-{
- strcpy(key_fname, key_location);
- strcpy(real_blkdev, block_device);
- strcpy(file_system, fs);
-}
-
-#ifndef TW_CRYPTO_HAVE_KEYMASTERX
-static int keymaster_init(keymaster_device_t **keymaster_dev)
-{
- int rc;
-
- const hw_module_t* mod;
- rc = hw_get_module_by_class(KEYSTORE_HARDWARE_MODULE_ID, NULL, &mod);
- if (rc) {
- printf("could not find any keystore module\n");
- goto out;
- }
-
- rc = keymaster_open(mod, keymaster_dev);
- if (rc) {
- printf("could not open keymaster device in %s (%s)\n",
- KEYSTORE_HARDWARE_MODULE_ID, strerror(-rc));
- goto out;
- }
-
- return 0;
-
-out:
- *keymaster_dev = NULL;
- return rc;
-}
-
-/* Should we use keymaster? */
-static int keymaster_check_compatibility()
-{
- keymaster_device_t *keymaster_dev = 0;
- int rc = 0;
-
- if (keymaster_init(&keymaster_dev)) {
- printf("Failed to init keymaster\n");
- rc = -1;
- goto out;
- }
-
- printf("keymaster version is %d\n", keymaster_dev->common.module->module_api_version);
-
-#if (KEYMASTER_HEADER_VERSION >= 3)
- if (keymaster_dev->common.module->module_api_version
- < KEYMASTER_MODULE_API_VERSION_0_3) {
- rc = 0;
- goto out;
- }
-
- if (keymaster_dev->flags & KEYMASTER_BLOBS_ARE_STANDALONE) {
- rc = 1;
- }
-
-#endif
-out:
- keymaster_close(keymaster_dev);
- return rc;
-}
-
-/* Create a new keymaster key and store it in this footer */
-static int keymaster_create_key(struct crypt_mnt_ftr *ftr)
-{
- uint8_t* key = 0;
- keymaster_device_t *keymaster_dev = 0;
-
- if (keymaster_init(&keymaster_dev)) {
- printf("Failed to init keymaster\n");
- return -1;
- }
-
- int rc = 0;
-
- keymaster_rsa_keygen_params_t params;
- memset(&params, '\0', sizeof(params));
- params.public_exponent = RSA_EXPONENT;
- params.modulus_size = RSA_KEY_SIZE;
-
- size_t key_size;
- if (keymaster_dev->generate_keypair(keymaster_dev, TYPE_RSA, &params,
- &key, &key_size)) {
- printf("Failed to generate keypair\n");
- rc = -1;
- goto out;
- }
-
- if (key_size > KEYMASTER_BLOB_SIZE) {
- printf("Keymaster key too large for crypto footer\n");
- rc = -1;
- goto out;
- }
-
- memcpy(ftr->keymaster_blob, key, key_size);
- ftr->keymaster_blob_size = key_size;
-
-out:
- keymaster_close(keymaster_dev);
- free(key);
- return rc;
-}
-
-/* This signs the given object using the keymaster key. */
-static int keymaster_sign_object(struct crypt_mnt_ftr *ftr,
- const unsigned char *object,
- const size_t object_size,
- unsigned char **signature,
- size_t *signature_size)
-{
- int rc = 0;
- keymaster_device_t *keymaster_dev = 0;
- if (keymaster_init(&keymaster_dev)) {
- printf("Failed to init keymaster\n");
- return -1;
- }
-
- /* We currently set the digest type to DIGEST_NONE because it's the
- * only supported value for keymaster. A similar issue exists with
- * PADDING_NONE. Long term both of these should likely change.
- */
- keymaster_rsa_sign_params_t params;
- params.digest_type = DIGEST_NONE;
- params.padding_type = PADDING_NONE;
-
- unsigned char to_sign[RSA_KEY_SIZE_BYTES];
- size_t to_sign_size = sizeof(to_sign);
- memset(to_sign, 0, RSA_KEY_SIZE_BYTES);
-
- // To sign a message with RSA, the message must satisfy two
- // constraints:
- //
- // 1. The message, when interpreted as a big-endian numeric value, must
- // be strictly less than the public modulus of the RSA key. Note
- // that because the most significant bit of the public modulus is
- // guaranteed to be 1 (else it's an (n-1)-bit key, not an n-bit
- // key), an n-bit message with most significant bit 0 always
- // satisfies this requirement.
- //
- // 2. The message must have the same length in bits as the public
- // modulus of the RSA key. This requirement isn't mathematically
- // necessary, but is necessary to ensure consistency in
- // implementations.
- switch (ftr->kdf_type) {
- case KDF_SCRYPT_KEYMASTER_UNPADDED:
- // This is broken: It produces a message which is shorter than
- // the public modulus, failing criterion 2.
- memcpy(to_sign, object, object_size);
- to_sign_size = object_size;
- printf("Signing unpadded object\n");
- break;
- case KDF_SCRYPT_KEYMASTER_BADLY_PADDED:
- // This is broken: Since the value of object is uniformly
- // distributed, it produces a message that is larger than the
- // public modulus with probability 0.25.
- memcpy(to_sign, object, min(RSA_KEY_SIZE_BYTES, object_size));
- printf("Signing end-padded object\n");
- break;
- case KDF_SCRYPT_KEYMASTER:
- // This ensures the most significant byte of the signed message
- // is zero. We could have zero-padded to the left instead, but
- // this approach is slightly more robust against changes in
- // object size. However, it's still broken (but not unusably
- // so) because we really should be using a proper RSA padding
- // function, such as OAEP.
- //
- // TODO(paullawrence): When keymaster 0.4 is available, change
- // this to use the padding options it provides.
- memcpy(to_sign + 1, object, min(RSA_KEY_SIZE_BYTES - 1, object_size));
- printf("Signing safely-padded object\n");
- break;
- default:
- printf("Unknown KDF type %d\n", ftr->kdf_type);
- return -1;
- }
-
- rc = keymaster_dev->sign_data(keymaster_dev,
- &params,
- ftr->keymaster_blob,
- ftr->keymaster_blob_size,
- to_sign,
- to_sign_size,
- signature,
- signature_size);
-
- keymaster_close(keymaster_dev);
- return rc;
-}
-#else //#ifndef TW_CRYPTO_HAVE_KEYMASTERX
-static int keymaster_init(keymaster0_device_t **keymaster0_dev,
- keymaster1_device_t **keymaster1_dev)
-{
- int rc;
-
- const hw_module_t* mod;
- rc = hw_get_module_by_class(KEYSTORE_HARDWARE_MODULE_ID, NULL, &mod);
- if (rc) {
- printf("could not find any keystore module\n");
- goto err;
- }
-
- printf("keymaster module name is %s\n", mod->name);
- printf("keymaster version is %d\n", mod->module_api_version);
-
- *keymaster0_dev = NULL;
- *keymaster1_dev = NULL;
- if (mod->module_api_version == KEYMASTER_MODULE_API_VERSION_1_0) {
- printf("Found keymaster1 module, using keymaster1 API.\n");
- rc = keymaster1_open(mod, keymaster1_dev);
- } else {
- printf("Found keymaster0 module, using keymaster0 API.\n");
- rc = keymaster0_open(mod, keymaster0_dev);
- }
-
- if (rc) {
- printf("could not open keymaster device in %s (%s)\n",
- KEYSTORE_HARDWARE_MODULE_ID, strerror(-rc));
- goto err;
- }
-
- return 0;
-
-err:
- *keymaster0_dev = NULL;
- *keymaster1_dev = NULL;
- return rc;
-}
-
-/* Should we use keymaster? */
-static int keymaster_check_compatibility()
-{
- keymaster0_device_t *keymaster0_dev = 0;
- keymaster1_device_t *keymaster1_dev = 0;
- int rc = 0;
-
- if (keymaster_init(&keymaster0_dev, &keymaster1_dev)) {
- printf("Failed to init keymaster\n");
- rc = -1;
- goto out;
- }
-
- if (keymaster1_dev) {
- rc = 1;
- goto out;
- }
-
- // TODO(swillden): Check to see if there's any reason to require v0.3. I think v0.1 and v0.2
- // should work.
- if (keymaster0_dev->common.module->module_api_version
- < KEYMASTER_MODULE_API_VERSION_0_3) {
- rc = 0;
- goto out;
- }
-
- if (!(keymaster0_dev->flags & KEYMASTER_SOFTWARE_ONLY) &&
- (keymaster0_dev->flags & KEYMASTER_BLOBS_ARE_STANDALONE)) {
- rc = 1;
- }
-
-out:
- if (keymaster1_dev) {
- keymaster1_close(keymaster1_dev);
- }
- if (keymaster0_dev) {
- keymaster0_close(keymaster0_dev);
- }
- return rc;
-}
-
-/* Create a new keymaster key and store it in this footer */
-static int keymaster_create_key(struct crypt_mnt_ftr *ftr)
-{
- uint8_t* key = 0;
- keymaster0_device_t *keymaster0_dev = 0;
- keymaster1_device_t *keymaster1_dev = 0;
-
- if (keymaster_init(&keymaster0_dev, &keymaster1_dev)) {
- printf("Failed to init keymaster\n");
- return -1;
- }
-
- int rc = 0;
- size_t key_size = 0;
- if (keymaster1_dev) {
- keymaster_key_param_t params[] = {
- /* Algorithm & size specifications. Stick with RSA for now. Switch to AES later. */
- keymaster_param_enum(KM_TAG_ALGORITHM, KM_ALGORITHM_RSA),
- keymaster_param_int(KM_TAG_KEY_SIZE, RSA_KEY_SIZE),
- keymaster_param_long(KM_TAG_RSA_PUBLIC_EXPONENT, RSA_EXPONENT),
-
- /* The only allowed purpose for this key is signing. */
- keymaster_param_enum(KM_TAG_PURPOSE, KM_PURPOSE_SIGN),
-
- /* Padding & digest specifications. */
- keymaster_param_enum(KM_TAG_PADDING, KM_PAD_NONE),
- keymaster_param_enum(KM_TAG_DIGEST, KM_DIGEST_NONE),
-
- /* Require that the key be usable in standalone mode. File system isn't available. */
- keymaster_param_enum(KM_TAG_BLOB_USAGE_REQUIREMENTS, KM_BLOB_STANDALONE),
-
- /* No auth requirements, because cryptfs is not yet integrated with gatekeeper. */
- keymaster_param_bool(KM_TAG_NO_AUTH_REQUIRED),
-
- /* Rate-limit key usage attempts, to rate-limit brute force */
- keymaster_param_int(KM_TAG_MIN_SECONDS_BETWEEN_OPS, KEYMASTER_CRYPTFS_RATE_LIMIT),
- };
- keymaster_key_param_set_t param_set = { params, sizeof(params)/sizeof(*params) };
- keymaster_key_blob_t key_blob;
- keymaster_error_t error = keymaster1_dev->generate_key(keymaster1_dev, &param_set,
- &key_blob,
- NULL /* characteristics */);
- if (error != KM_ERROR_OK) {
- printf("Failed to generate keymaster1 key, error %d\n", error);
- rc = -1;
- goto out;
- }
-
- key = (uint8_t*)key_blob.key_material;
- key_size = key_blob.key_material_size;
- }
- else if (keymaster0_dev) {
- keymaster_rsa_keygen_params_t params;
- memset(&params, '\0', sizeof(params));
- params.public_exponent = RSA_EXPONENT;
- params.modulus_size = RSA_KEY_SIZE;
-
- if (keymaster0_dev->generate_keypair(keymaster0_dev, TYPE_RSA, &params,
- &key, &key_size)) {
- printf("Failed to generate keypair\n");
- rc = -1;
- goto out;
- }
- } else {
- printf("Cryptfs bug: keymaster_init succeeded but didn't initialize a device\n");
- rc = -1;
- goto out;
- }
-
- if (key_size > KEYMASTER_BLOB_SIZE) {
- printf("Keymaster key too large for crypto footer\n");
- rc = -1;
- goto out;
- }
-
- memcpy(ftr->keymaster_blob, key, key_size);
- ftr->keymaster_blob_size = key_size;
-
-out:
- if (keymaster0_dev)
- keymaster0_close(keymaster0_dev);
- if (keymaster1_dev)
- keymaster1_close(keymaster1_dev);
- free(key);
- return rc;
-}
-
-/* This signs the given object using the keymaster key. */
-static int keymaster_sign_object(struct crypt_mnt_ftr *ftr,
- const unsigned char *object,
- const size_t object_size,
- unsigned char **signature,
- size_t *signature_size)
-{
- int rc = 0;
- keymaster0_device_t *keymaster0_dev = 0;
- keymaster1_device_t *keymaster1_dev = 0;
- if (keymaster_init(&keymaster0_dev, &keymaster1_dev)) {
- printf("Failed to init keymaster\n");
- rc = -1;
- goto out;
- }
-
- unsigned char to_sign[RSA_KEY_SIZE_BYTES];
- size_t to_sign_size = sizeof(to_sign);
- memset(to_sign, 0, RSA_KEY_SIZE_BYTES);
-
- // To sign a message with RSA, the message must satisfy two
- // constraints:
- //
- // 1. The message, when interpreted as a big-endian numeric value, must
- // be strictly less than the public modulus of the RSA key. Note
- // that because the most significant bit of the public modulus is
- // guaranteed to be 1 (else it's an (n-1)-bit key, not an n-bit
- // key), an n-bit message with most significant bit 0 always
- // satisfies this requirement.
- //
- // 2. The message must have the same length in bits as the public
- // modulus of the RSA key. This requirement isn't mathematically
- // necessary, but is necessary to ensure consistency in
- // implementations.
- switch (ftr->kdf_type) {
- case KDF_SCRYPT_KEYMASTER:
- // This ensures the most significant byte of the signed message
- // is zero. We could have zero-padded to the left instead, but
- // this approach is slightly more robust against changes in
- // object size. However, it's still broken (but not unusably
- // so) because we really should be using a proper deterministic
- // RSA padding function, such as PKCS1.
- memcpy(to_sign + 1, object, min(RSA_KEY_SIZE_BYTES - 1, object_size));
- printf("Signing safely-padded object\n");
- break;
- default:
- printf("Unknown KDF type %d\n", ftr->kdf_type);
- rc = -1;
- goto out;
- }
-
- if (keymaster0_dev) {
- keymaster_rsa_sign_params_t params;
- params.digest_type = DIGEST_NONE;
- params.padding_type = PADDING_NONE;
-
- rc = keymaster0_dev->sign_data(keymaster0_dev,
- &params,
- ftr->keymaster_blob,
- ftr->keymaster_blob_size,
- to_sign,
- to_sign_size,
- signature,
- signature_size);
- goto out;
- } else if (keymaster1_dev) {
- keymaster_key_blob_t key = { ftr->keymaster_blob, ftr->keymaster_blob_size };
- keymaster_key_param_t params[] = {
- keymaster_param_enum(KM_TAG_PADDING, KM_PAD_NONE),
- keymaster_param_enum(KM_TAG_DIGEST, KM_DIGEST_NONE),
- };
- keymaster_key_param_set_t param_set = { params, sizeof(params)/sizeof(*params) };
- keymaster_operation_handle_t op_handle;
- keymaster_error_t error = keymaster1_dev->begin(keymaster1_dev, KM_PURPOSE_SIGN, &key,
- &param_set, NULL /* out_params */,
- &op_handle);
- if (error == KM_ERROR_KEY_RATE_LIMIT_EXCEEDED) {
- // Key usage has been rate-limited. Wait a bit and try again.
- sleep(KEYMASTER_CRYPTFS_RATE_LIMIT);
- error = keymaster1_dev->begin(keymaster1_dev, KM_PURPOSE_SIGN, &key,
- &param_set, NULL /* out_params */,
- &op_handle);
- }
- if (error != KM_ERROR_OK) {
- printf("Error starting keymaster signature transaction: %d\n", error);
- rc = -1;
- goto out;
- }
-
- keymaster_blob_t input = { to_sign, to_sign_size };
- size_t input_consumed;
- error = keymaster1_dev->update(keymaster1_dev, op_handle, NULL /* in_params */,
- &input, &input_consumed, NULL /* out_params */,
- NULL /* output */);
- if (error != KM_ERROR_OK) {
- printf("Error sending data to keymaster signature transaction: %d\n", error);
- rc = -1;
- goto out;
- }
- if (input_consumed != to_sign_size) {
- // This should never happen. If it does, it's a bug in the keymaster implementation.
- printf("Keymaster update() did not consume all data.\n");
- keymaster1_dev->abort(keymaster1_dev, op_handle);
- rc = -1;
- goto out;
- }
-
- keymaster_blob_t tmp_sig;
- error = keymaster1_dev->finish(keymaster1_dev, op_handle, NULL /* in_params */,
- NULL /* verify signature */, NULL /* out_params */,
- &tmp_sig);
- if (error != KM_ERROR_OK) {
- printf("Error finishing keymaster signature transaction: %d\n", error);
- rc = -1;
- goto out;
- }
-
- *signature = (uint8_t*)tmp_sig.data;
- *signature_size = tmp_sig.data_length;
- } else {
- printf("Cryptfs bug: keymaster_init succeded but didn't initialize a device.\n");
- rc = -1;
- goto out;
- }
-
- out:
- if (keymaster1_dev)
- keymaster1_close(keymaster1_dev);
- if (keymaster0_dev)
- keymaster0_close(keymaster0_dev);
-
- return rc;
-}
-#endif //#ifndef TW_CRYPTO_HAVE_KEYMASTERX
-
-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));
- }
-}
-
-/**
- * Gets the default device scrypt parameters for key derivation time tuning.
- * The parameters should lead to about one second derivation time for the
- * given device.
- */
-static void get_device_scrypt_params(struct crypt_mnt_ftr *ftr) {
- const int default_params[] = SCRYPT_DEFAULTS;
- int params[] = SCRYPT_DEFAULTS;
- char paramstr[PROPERTY_VALUE_MAX];
- char *token;
- char *saveptr;
- int i;
-
- property_get(SCRYPT_PROP, paramstr, "");
- if (paramstr[0] != '\0') {
- /*
- * The token we're looking for should be three integers separated by
- * colons (e.g., "12:8:1"). Scan the property to make sure it matches.
- */
- for (i = 0, token = strtok_r(paramstr, ":", &saveptr);
- token != NULL && i < 3;
- i++, token = strtok_r(NULL, ":", &saveptr)) {
- char *endptr;
- params[i] = strtol(token, &endptr, 10);
-
- /*
- * Check that there was a valid number and it's 8-bit. If not,
- * break out and the end check will take the default values.
- */
- if ((*token == '\0') || (*endptr != '\0') || params[i] < 0 || params[i] > 255) {
- break;
- }
- }
-
- /*
- * If there were not enough tokens or a token was malformed (not an
- * integer), it will end up here and the default parameters can be
- * taken.
- */
- if ((i != 3) || (token != NULL)) {
- printf("bad scrypt parameters '%s' should be like '12:8:1'; using defaults\n", paramstr);
- memcpy(params, default_params, sizeof(params));
- }
- }
-
- ftr->N_factor = params[0];
- ftr->r_factor = params[1];
- ftr->p_factor = params[2];
-}
-
-static unsigned int get_blkdev_size(int fd)
-{
- unsigned long nr_sec;
-
- if ( (ioctl(fd, BLKGETSIZE, &nr_sec)) == -1) {
- nr_sec = 0;
- }
-
- return (unsigned int) nr_sec;
-}
-
-static int get_crypt_ftr_info(char **metadata_fname, off64_t *off)
-{
- static int cached_data = 0;
- static off64_t cached_off = 0;
- static char cached_metadata_fname[PROPERTY_VALUE_MAX] = "";
- int fd;
- unsigned int nr_sec;
- int rc = -1;
-
- if (!cached_data) {
- printf("get_crypt_ftr_info crypto key location: '%s'\n", key_fname);
- if (!strcmp(key_fname, KEY_IN_FOOTER)) {
- if ( (fd = open(real_blkdev, O_RDWR)) < 0) {
- printf("Cannot open real block device %s\n", real_blkdev);
- return -1;
- }
-
- if ((nr_sec = get_blkdev_size(fd))) {
- /* 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.
- */
- strlcpy(cached_metadata_fname, real_blkdev, sizeof(cached_metadata_fname));
- cached_off = ((off64_t)nr_sec * 512) - CRYPT_FOOTER_OFFSET;
- cached_data = 1;
- } else {
- printf("Cannot get size of block device %s\n", real_blkdev);
- }
- close(fd);
- } else {
- strlcpy(cached_metadata_fname, key_fname, sizeof(cached_metadata_fname));
- cached_off = 0;
- cached_data = 1;
- }
- }
-
- if (cached_data) {
- if (metadata_fname) {
- *metadata_fname = cached_metadata_fname;
- }
- if (off) {
- *off = cached_off;
- }
- rc = 0;
- }
-
- return rc;
-}
-
-static int get_crypt_ftr_and_key(struct crypt_mnt_ftr *crypt_ftr)
-{
- int fd;
- unsigned int cnt;
- off64_t starting_off;
- int rc = -1;
- char *fname = NULL;
- struct stat statbuf;
-
- if (get_crypt_ftr_info(&fname, &starting_off)) {
- printf("Unable to get crypt_ftr_info\n");
- return -1;
- }
- if (fname[0] != '/') {
- printf("Unexpected value for crypto key location\n");
- return -1;
- }
- if ( (fd = open(fname, O_RDWR)) < 0) {
- printf("Cannot open footer file %s for get\n", fname);
- return -1;
- }
-
- /* Make sure it's 16 Kbytes in length */
- fstat(fd, &statbuf);
- if (S_ISREG(statbuf.st_mode) && (statbuf.st_size != 0x4000)) {
- printf("footer file %s is not the expected size!\n", fname);
- goto errout;
- }
-
- /* Seek to the start of the crypt footer */
- if (lseek64(fd, starting_off, SEEK_SET) == -1) {
- printf("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)) {
- printf("Cannot read real block device footer\n");
- goto errout;
- }
-
- if (crypt_ftr->magic != CRYPT_MNT_MAGIC) {
- printf("Bad magic for real block device %s\n", fname);
- goto errout;
- }
-
- if (crypt_ftr->major_version != CURRENT_MAJOR_VERSION) {
- printf("Cannot understand major version %d real block device footer; expected %d\n",
- crypt_ftr->major_version, CURRENT_MAJOR_VERSION);
- goto errout;
- }
-
- if (crypt_ftr->minor_version > CURRENT_MINOR_VERSION) {
- printf("Warning: crypto footer minor version %d, expected <= %d, continuing...\n",
- crypt_ftr->minor_version, CURRENT_MINOR_VERSION);
- }
-
- /* If this is a verion 1.0 crypt_ftr, make it a 1.1 crypt footer, and update the
- * copy on disk before returning.
- */
- /*if (crypt_ftr->minor_version < CURRENT_MINOR_VERSION) {
- upgrade_crypt_ftr(fd, crypt_ftr, starting_off);
- }*/
-
- /* Success! */
- rc = 0;
-
-errout:
- close(fd);
- return rc;
-}
-
-static int hexdigit (char c)
-{
- if (c >= '0' && c <= '9') return c - '0';
- c = tolower(c);
- if (c >= 'a' && c <= 'f') return c - 'a' + 10;
- return -1;
-}
-
-static unsigned char* convert_hex_ascii_to_key(const char* master_key_ascii,
- unsigned int* out_keysize)
-{
- unsigned int i;
- *out_keysize = 0;
-
- size_t size = strlen (master_key_ascii);
- if (size % 2) {
- printf("Trying to convert ascii string of odd length\n");
- return NULL;
- }
-
- unsigned char* master_key = (unsigned char*) malloc(size / 2);
- if (master_key == 0) {
- printf("Cannot allocate\n");
- return NULL;
- }
-
- for (i = 0; i < size; i += 2) {
- int high_nibble = hexdigit (master_key_ascii[i]);
- int low_nibble = hexdigit (master_key_ascii[i + 1]);
-
- if(high_nibble < 0 || low_nibble < 0) {
- printf("Invalid hex string\n");
- free (master_key);
- return NULL;
- }
-
- master_key[*out_keysize] = high_nibble * 16 + low_nibble;
- (*out_keysize)++;
- }
-
- return master_key;
-}
-
-/* Convert a binary key of specified length into an ascii hex string equivalent,
- * without the leading 0x and with null termination
- */
-static void convert_key_to_hex_ascii(const unsigned char *master_key,
- unsigned int keysize, char *master_key_ascii) {
- unsigned int i, a;
- unsigned char nibble;
-
- for (i=0, a=0; i<keysize; i++, a+=2) {
- /* For each byte, write out two ascii hex digits */
- nibble = (master_key[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 load_crypto_mapping_table(struct crypt_mnt_ftr *crypt_ftr, const unsigned char *master_key,
- const char *real_blk_name, const char *name, int fd,
- char *extra_params)
-{
- char buffer[DM_CRYPT_BUF_SIZE];
- struct dm_ioctl *io;
- struct dm_target_spec *tgt;
- char *crypt_params;
- char master_key_ascii[129]; /* Large enough to hold 512 bit key and null */
- int i;
-
- io = (struct dm_ioctl *) buffer;
-
- /* Load the mapping table for this device */
- tgt = (struct dm_target_spec *) &buffer[sizeof(struct dm_ioctl)];
-
- ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
- io->target_count = 1;
- tgt->status = 0;
- tgt->sector_start = 0;
- tgt->length = crypt_ftr->fs_size;
- crypt_params = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
-
-#ifdef CONFIG_HW_DISK_ENCRYPTION
- if(is_hw_disk_encryption((char*)crypt_ftr->crypto_type_name)) {
- strlcpy(tgt->target_type, "req-crypt",DM_MAX_TYPE_NAME);
- if (is_ice_enabled())
- convert_key_to_hex_ascii(master_key, sizeof(int), master_key_ascii);
- else
- convert_key_to_hex_ascii(master_key, crypt_ftr->keysize, master_key_ascii);
- }
- else {
- convert_key_to_hex_ascii(master_key, crypt_ftr->keysize, master_key_ascii);
- strlcpy(tgt->target_type, "crypt", DM_MAX_TYPE_NAME);
- }
-#else
- convert_key_to_hex_ascii(master_key, crypt_ftr->keysize, master_key_ascii);
- strlcpy(tgt->target_type, "crypt", DM_MAX_TYPE_NAME);
-#endif
-
- sprintf(crypt_params, "%s %s 0 %s 0 %s", crypt_ftr->crypto_type_name,
- master_key_ascii, real_blk_name, extra_params);
-
- printf("%s: target_type = %s\n", __func__, tgt->target_type);
- printf("%s: real_blk_name = %s, extra_params = %s\n", __func__, real_blk_name, extra_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;
-
- for (i = 0; i < TABLE_LOAD_RETRIES; i++) {
- if (! ioctl(fd, DM_TABLE_LOAD, io)) {
- break;
- }
- printf("%i\n", errno);
- usleep(500000);
- }
-
- if (i == TABLE_LOAD_RETRIES) {
- /* We failed to load the table, return an error */
- return -1;
- } else {
- return i + 1;
- }
-}
-
-
-static int get_dm_crypt_version(int fd, const char *name, int *version)
-{
- char buffer[DM_CRYPT_BUF_SIZE];
- struct dm_ioctl *io;
- struct dm_target_versions *v;
-
- io = (struct dm_ioctl *) buffer;
-
- ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
-
- if (ioctl(fd, DM_LIST_VERSIONS, io)) {
- return -1;
- }
-
- /* Iterate over the returned versions, looking for name of "crypt".
- * When found, get and return the version.
- */
- v = (struct dm_target_versions *) &buffer[sizeof(struct dm_ioctl)];
- while (v->next) {
-#ifdef CONFIG_HW_DISK_ENCRYPTION
- int flag;
- if (is_hw_fde_enabled()) {
- flag = (!strcmp(v->name, "crypt") || !strcmp(v->name, "req-crypt"));
- } else {
- flag = (!strcmp(v->name, "crypt"));
- }
- printf("get_dm_crypt_version flag: %i, name: '%s'\n", flag, v->name);
- if (flag) {
-#else
- if (! strcmp(v->name, "crypt")) {
-#endif
- /* We found the crypt driver, return the version, and get out */
- version[0] = v->version[0];
- version[1] = v->version[1];
- version[2] = v->version[2];
- return 0;
- }
- v = (struct dm_target_versions *)(((char *)v) + v->next);
- }
-
- return -1;
-}
-
-static int create_crypto_blk_dev(struct crypt_mnt_ftr *crypt_ftr, const unsigned char *master_key,
- const char *real_blk_name, char *crypto_blk_name, const char *name)
-{
- char buffer[DM_CRYPT_BUF_SIZE];
- struct dm_ioctl *io;
- unsigned int minor;
- int fd=0;
- int retval = -1;
- int version[3];
- char *extra_params;
- int load_count;
-#ifdef CONFIG_HW_DISK_ENCRYPTION
- char encrypted_state[PROPERTY_VALUE_MAX] = {0};
- char progress[PROPERTY_VALUE_MAX] = {0};
-#endif
-
- if ((fd = open("/dev/device-mapper", O_RDWR)) < 0 ) {
- printf("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)) {
- printf("Cannot create dm-crypt device %i\n", errno);
- 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)) {
- printf("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);
-
-#ifdef CONFIG_HW_DISK_ENCRYPTION
- if(is_hw_disk_encryption((char*)crypt_ftr->crypto_type_name)) {
- /* Set fde_enabled if either FDE completed or in-progress */
- property_get("ro.crypto.state", encrypted_state, ""); /* FDE completed */
- property_get("vold.encrypt_progress", progress, ""); /* FDE in progress */
- if (!strcmp(encrypted_state, "encrypted") || strcmp(progress, "")) {
- if (is_ice_enabled())
- extra_params = "fde_enabled ice";
- else
- extra_params = "fde_enabled";
- } else
- extra_params = "fde_disabled";
- } else {
- extra_params = "";
- if (! get_dm_crypt_version(fd, name, version)) {
- /* Support for allow_discards was added in version 1.11.0 */
- if ((version[0] >= 2) ||
- ((version[0] == 1) && (version[1] >= 11))) {
- extra_params = "1 allow_discards";
- printf("Enabling support for allow_discards in dmcrypt.\n");
- }
- }
- }
-#else
- extra_params = "";
- if (! get_dm_crypt_version(fd, name, version)) {
- /* Support for allow_discards was added in version 1.11.0 */
- if ((version[0] >= 2) ||
- ((version[0] == 1) && (version[1] >= 11))) {
- extra_params = "1 allow_discards";
- printf("Enabling support for allow_discards in dmcrypt.\n");
- }
- }
-#endif
-
- load_count = load_crypto_mapping_table(crypt_ftr, master_key, real_blk_name, name,
- fd, extra_params);
- if (load_count < 0) {
- printf("Cannot load dm-crypt mapping table.\n");
-
- // Remove the dm-crypt device, otherwise it cannot be used later on by other
- // processes (eg vold_decrypt) or further testing/debugging in recovery
- ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
- if (ioctl(fd, DM_DEV_REMOVE, io)) {
- printf("Cannot remove dm-crypt device %i\n", errno);
- }
- goto errout;
- } else if (load_count > 1) {
- printf("Took %d tries to load dmcrypt table.\n", load_count);
- }
-
- /* Resume this device to activate it */
- ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
-
- if (ioctl(fd, DM_DEV_SUSPEND, io)) {
- printf("Cannot resume the dm-crypt device\n");
-
- // Remove the dm-crypt device, otherwise it cannot be used later on by other
- // processes (eg vold_decrypt) or further testing/debugging in recovery
- ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);
- if (ioctl(fd, DM_DEV_REMOVE, io)) {
- printf("Cannot remove dm-crypt device %i\n", errno);
- }
- 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;
-}
-
-int delete_crypto_blk_dev(char *name)
-{
- int fd;
- char buffer[DM_CRYPT_BUF_SIZE];
- struct dm_ioctl *io;
- int retval = -1;
-
- if ((fd = open("/dev/device-mapper", O_RDWR)) < 0 ) {
- printf("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)) {
- printf("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;
-
-}
-
-static int pbkdf2(const char *passwd, const unsigned char *salt,
- unsigned char *ikey, void *params UNUSED)
-{
- printf("Using pbkdf2 for cryptfs KDF\n");
-
- /* Turn the password into a key and IV that can decrypt the master key */
- unsigned int keysize;
- char* master_key = (char*)convert_hex_ascii_to_key(passwd, &keysize);
- if (!master_key) return -1;
- PKCS5_PBKDF2_HMAC_SHA1(master_key, keysize, salt, SALT_LEN,
- HASH_COUNT, KEY_LEN_BYTES+IV_LEN_BYTES, ikey);
-
- memset(master_key, 0, keysize);
- free (master_key);
- return 0;
-}
-
-static int scrypt(const char *passwd, const unsigned char *salt,
- unsigned char *ikey, void *params)
-{
- printf("Using scrypt for cryptfs KDF\n");
-
- struct crypt_mnt_ftr *ftr = (struct crypt_mnt_ftr *) params;
-
- int N = 1 << ftr->N_factor;
- int r = 1 << ftr->r_factor;
- int p = 1 << ftr->p_factor;
-
- /* Turn the password into a key and IV that can decrypt the master key */
- unsigned int keysize;
- unsigned char* master_key = convert_hex_ascii_to_key(passwd, &keysize);
- if (!master_key) return -1;
- crypto_scrypt(master_key, keysize, salt, SALT_LEN, N, r, p, ikey,
- KEY_LEN_BYTES + IV_LEN_BYTES);
-
- memset(master_key, 0, keysize);
- free (master_key);
- return 0;
-}
-
-static int scrypt_keymaster(const char *passwd, const unsigned char *salt,
- unsigned char *ikey, void *params)
-{
- printf("Using scrypt with keymaster for cryptfs KDF\n");
-
- int rc;
- unsigned int key_size;
- size_t signature_size;
- unsigned char* signature;
- struct crypt_mnt_ftr *ftr = (struct crypt_mnt_ftr *) params;
-
- int N = 1 << ftr->N_factor;
- int r = 1 << ftr->r_factor;
- int p = 1 << ftr->p_factor;
-
- unsigned char* master_key = convert_hex_ascii_to_key(passwd, &key_size);
- if (!master_key) {
- printf("Failed to convert passwd from hex, using passwd instead\n");
- master_key = (unsigned char*)strdup(passwd);
- }
-
- rc = crypto_scrypt(master_key, key_size, salt, SALT_LEN,
- N, r, p, ikey, KEY_LEN_BYTES + IV_LEN_BYTES);
- memset(master_key, 0, key_size);
- free(master_key);
-
- if (rc) {
- printf("scrypt failed\n");
- return -1;
- }
-
- if (keymaster_sign_object(ftr, ikey, KEY_LEN_BYTES + IV_LEN_BYTES,
- &signature, &signature_size)) {
- printf("Signing failed\n");
- return -1;
- }
-
- rc = crypto_scrypt(signature, signature_size, salt, SALT_LEN,
- N, r, p, ikey, KEY_LEN_BYTES + IV_LEN_BYTES);
- free(signature);
-
- if (rc) {
- printf("scrypt failed\n");
- return -1;
- }
-
- return 0;
-}
-
-static int decrypt_master_key_aux(char *passwd, unsigned char *salt,
- unsigned char *encrypted_master_key,
- unsigned char *decrypted_master_key,
- kdf_func kdf, void *kdf_params,
- unsigned char** intermediate_key,
- size_t* intermediate_key_size)
-{
- unsigned char ikey[32+32] = { 0 }; /* Big enough to hold a 256 bit key and 256 bit IV */
- EVP_CIPHER_CTX d_ctx;
- int decrypted_len, final_len;
-
- /* Turn the password into an intermediate key and IV that can decrypt the
- master key */
- if (kdf(passwd, salt, ikey, kdf_params)) {
- printf("kdf failed\n");
- return -1;
- }
-
- /* 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;
- }
-#ifndef TW_CRYPTO_HAVE_KEYMASTERX
- if (! EVP_DecryptFinal(&d_ctx, decrypted_master_key + decrypted_len, &final_len)) {
-#else
- if (! EVP_DecryptFinal_ex(&d_ctx, decrypted_master_key + decrypted_len, &final_len)) {
-#endif
- return -1;
- }
-
- if (decrypted_len + final_len != KEY_LEN_BYTES) {
- return -1;
- }
-
- /* Copy intermediate key if needed by params */
- if (intermediate_key && intermediate_key_size) {
- *intermediate_key = (unsigned char*) malloc(KEY_LEN_BYTES);
- if (intermediate_key) {
- memcpy(*intermediate_key, ikey, KEY_LEN_BYTES);
- *intermediate_key_size = KEY_LEN_BYTES;
- }
- }
-
- return 0;
-}
-
-static void get_kdf_func(struct crypt_mnt_ftr *ftr, kdf_func *kdf, void** kdf_params)
-{
- if (ftr->kdf_type == KDF_SCRYPT_KEYMASTER_UNPADDED ||
- ftr->kdf_type == KDF_SCRYPT_KEYMASTER_BADLY_PADDED ||
- ftr->kdf_type == KDF_SCRYPT_KEYMASTER) {
- *kdf = scrypt_keymaster;
- *kdf_params = ftr;
- } else if (ftr->kdf_type == KDF_SCRYPT) {
- *kdf = scrypt;
- *kdf_params = ftr;
- } else {
- *kdf = pbkdf2;
- *kdf_params = NULL;
- }
-}
-
-static int decrypt_master_key(char *passwd, unsigned char *decrypted_master_key,
- struct crypt_mnt_ftr *crypt_ftr,
- unsigned char** intermediate_key,
- size_t* intermediate_key_size)
-{
- kdf_func kdf;
- void *kdf_params;
- int ret;
-
- get_kdf_func(crypt_ftr, &kdf, &kdf_params);
- ret = decrypt_master_key_aux(passwd, crypt_ftr->salt, crypt_ftr->master_key,
- decrypted_master_key, kdf, kdf_params,
- intermediate_key, intermediate_key_size);
- if (ret != 0) {
- printf("failure decrypting master key\n");
- }
-
- return ret;
-}
-
-static int try_mount_multiple_fs(const char *crypto_blkdev,
- const char *mount_point,
- const char *file_system)
-{
- if (!mount(crypto_blkdev, mount_point, file_system, 0, NULL))
- return 0;
- if (strcmp(file_system, "ext4") &&
- !mount(crypto_blkdev, mount_point, "ext4", 0, NULL))
- return 0;
- if (strcmp(file_system, "f2fs") &&
- !mount(crypto_blkdev, mount_point, "f2fs", 0, NULL))
- return 0;
- return 1;
-}
-
-static int test_mount_encrypted_fs(struct crypt_mnt_ftr* crypt_ftr,
- char *passwd, char *mount_point, char *label)
-{
- /* Allocate enough space for a 256 bit key, but we may use less */
- unsigned char decrypted_master_key[32];
- char crypto_blkdev[MAXPATHLEN];
- char tmp_mount_point[64];
- int rc = 0;
- unsigned char* intermediate_key = 0;
- size_t intermediate_key_size = 0;
-
- printf("crypt_ftr->fs_size = %lld\n", crypt_ftr->fs_size);
-
- if (! (crypt_ftr->flags & CRYPT_MNT_KEY_UNENCRYPTED) ) {
- if (decrypt_master_key(passwd, decrypted_master_key, crypt_ftr,
- &intermediate_key, &intermediate_key_size)) {
- printf("Failed to decrypt master key\n");
- rc = -1;
- goto errout;
- }
- }
-
-#ifdef CONFIG_HW_DISK_ENCRYPTION
- int key_index = 0;
- if(is_hw_disk_encryption((char*)crypt_ftr->crypto_type_name)) {
- key_index = verify_hw_fde_passwd(passwd, crypt_ftr);
-
- if (key_index < 0) {
- rc = 1;
- goto errout;
- }
- else {
- if (is_ice_enabled()) {
- if (create_crypto_blk_dev(crypt_ftr, (unsigned char*)&key_index,
- real_blkdev, crypto_blkdev, label)) {
- printf("Error creating decrypted block device");
- rc = -1;
- goto errout;
- }
- } else {
- if (create_crypto_blk_dev(crypt_ftr, decrypted_master_key,
- real_blkdev, crypto_blkdev, label)) {
- printf("Error creating decrypted block device");
- rc = -1;
- goto errout;
- }
- }
- }
- } else {
- /* in case HW FDE is delivered through OTA and device is already encrypted
- * using SW FDE, we should let user continue using SW FDE until userdata is
- * wiped.
- */
- if (create_crypto_blk_dev(crypt_ftr, decrypted_master_key,
- real_blkdev, crypto_blkdev, label)) {
- printf("Error creating decrypted block device");
- rc = -1;
- goto errout;
- }
- }
-#else
- // Create crypto block device - all (non fatal) code paths
- // need it
- if (create_crypto_blk_dev(crypt_ftr, decrypted_master_key,
- real_blkdev, crypto_blkdev, label)) {
- printf("Error creating decrypted block device\n");
- rc = -1;
- goto errout;
- }
-#endif
-
- /* Work out if the problem is the password or the data */
- unsigned char scrypted_intermediate_key[sizeof(crypt_ftr->
- scrypted_intermediate_key)];
- int N = 1 << crypt_ftr->N_factor;
- int r = 1 << crypt_ftr->r_factor;
- int p = 1 << crypt_ftr->p_factor;
-
- rc = crypto_scrypt(intermediate_key, intermediate_key_size,
- crypt_ftr->salt, sizeof(crypt_ftr->salt),
- N, r, p, scrypted_intermediate_key,
- sizeof(scrypted_intermediate_key));
-
- // Does the key match the crypto footer?
- if (rc == 0 && memcmp(scrypted_intermediate_key,
- crypt_ftr->scrypted_intermediate_key,
- sizeof(scrypted_intermediate_key)) == 0) {
- printf("Password matches\n");
- rc = 0;
- } else {
- /* Try mounting the file system anyway, just in case the problem's with
- * the footer, not the key. */
- sprintf(tmp_mount_point, "%s/tmp_mnt", mount_point);
- mkdir(tmp_mount_point, 0755);
- if (try_mount_multiple_fs(crypto_blkdev, tmp_mount_point, file_system)) {
- printf("Error temp mounting decrypted block device '%s'\n", crypto_blkdev);
- delete_crypto_blk_dev(label);
- rc = 1;
- } else {
- /* Success! */
- printf("Password did not match but decrypted drive mounted - continue\n");
- umount(tmp_mount_point);
- rc = 0;
- }
- }
-
- if (rc == 0) {
- // Don't increment the failed attempt counter as it doesn't
- // make sense to do so in TWRP
-
- /* Save the name of the crypto block device
- * so we can mount it when restarting the framework. */
- property_set("ro.crypto.fs_crypto_blkdev", crypto_blkdev);
-
- // TWRP shouldn't change the stored key
- }
-
- errout:
- if (intermediate_key) {
- memset(intermediate_key, 0, intermediate_key_size);
- free(intermediate_key);
- }
- return rc;
-}
-
-int check_unmounted_and_get_ftr(struct crypt_mnt_ftr* crypt_ftr)
-{
- char encrypted_state[PROPERTY_VALUE_MAX];
- property_get("ro.crypto.state", encrypted_state, "");
- if ( master_key_saved || strcmp(encrypted_state, "encrypted") ) {
- printf("encrypted fs already validated or not running with encryption,"
- " aborting\n");
- //return -1;
- }
-
- if (get_crypt_ftr_and_key(crypt_ftr)) {
- printf("Error getting crypt footer and key\n");
- return -1;
- }
-
- return 0;
-}
-
-int cryptfs_check_footer()
-{
- int rc = -1;
- struct crypt_mnt_ftr crypt_ftr;
-
- rc = get_crypt_ftr_and_key(&crypt_ftr);
-
- return rc;
-}
-
-int cryptfs_check_passwd(char *passwd)
-{
- struct crypt_mnt_ftr crypt_ftr;
- int rc;
-
- if (!passwd) {
- printf("cryptfs_check_passwd: passwd is NULL!\n");
- return -1;
- }
-
- rc = check_unmounted_and_get_ftr(&crypt_ftr);
- if (rc)
- return rc;
-
- rc = test_mount_encrypted_fs(&crypt_ftr, passwd,
- DATA_MNT_POINT, "userdata");
-
- // try falling back to Lollipop hex passwords
- if (rc) {
- int hex_pass_len = strlen(passwd) * 2 + 1;
- char *hex_passwd = (char *)malloc(hex_pass_len);
- if (hex_passwd) {
- convert_key_to_hex_ascii((unsigned char *)passwd,
- strlen(passwd), hex_passwd);
- rc = test_mount_encrypted_fs(&crypt_ftr, hex_passwd,
- DATA_MNT_POINT, "userdata");
- memset(hex_passwd, 0, hex_pass_len);
- free(hex_passwd);
- }
- }
-
- return rc;
-}
-
-/* Returns type of the password, default, pattern, pin or password.
- */
-int cryptfs_get_password_type(void)
-{
- struct crypt_mnt_ftr crypt_ftr;
-
- if (get_crypt_ftr_and_key(&crypt_ftr)) {
- printf("Error getting crypt footer and key\n");
- return -1;
- }
-
- if (crypt_ftr.flags & CRYPT_INCONSISTENT_STATE) {
- return -1;
- }
-
- return crypt_ftr.crypt_type;
-}
-
-/*
- * Called by vold when it's asked to mount an encrypted external
- * storage volume. The incoming partition has no crypto header/footer,
- * as any metadata is been stored in a separate, small partition.
- *
- * out_crypto_blkdev must be MAXPATHLEN.
- */
-int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev,
- const unsigned char* key, int keysize, char* out_crypto_blkdev) {
- int fd = open(real_blkdev, O_RDONLY|O_CLOEXEC);
- if (fd == -1) {
- printf("Failed to open %s: %s", real_blkdev, strerror(errno));
- return -1;
- }
-
- unsigned long nr_sec = 0;
- nr_sec = get_blkdev_size(fd);
- close(fd);
-
- if (nr_sec == 0) {
- printf("Failed to get size of %s: %s", real_blkdev, strerror(errno));
- return -1;
- }
-
- struct crypt_mnt_ftr ext_crypt_ftr;
- memset(&ext_crypt_ftr, 0, sizeof(ext_crypt_ftr));
- ext_crypt_ftr.fs_size = nr_sec;
- ext_crypt_ftr.keysize = keysize;
- strcpy((char*) ext_crypt_ftr.crypto_type_name, "aes-cbc-essiv:sha256");
-
- return create_crypto_blk_dev(&ext_crypt_ftr, key, real_blkdev,
- out_crypto_blkdev, label);
-}
-
-/*
- * Called by vold when it's asked to unmount an encrypted external
- * storage volume.
- */
-int cryptfs_revert_ext_volume(const char* label) {
- return delete_crypto_blk_dev((char*) label);
-}