Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | /* This structure starts 16,384 bytes before the end of a hardware |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 18 | * partition that is encrypted, or in a separate partition. It's location |
| 19 | * is specified by a property set in init.<device>.rc. |
| 20 | * The structure allocates 48 bytes for a key, but the real key size is |
| 21 | * specified in the struct. Currently, the code is hardcoded to use 128 |
| 22 | * bit keys. |
| 23 | * The fields after salt are only valid in rev 1.1 and later stuctures. |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 24 | * Obviously, the filesystem does not include the last 16 kbytes |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 25 | * of the partition if the crypt_mnt_ftr lives at the end of the |
| 26 | * partition. |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 27 | */ |
| 28 | |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 29 | #include <cutils/properties.h> |
Paul Lawrence | 8799917 | 2014-02-20 12:21:31 -0800 | [diff] [blame^] | 30 | #include <openssl/sha.h> |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 31 | |
Kenny Root | c96a5f8 | 2013-06-14 12:08:28 -0700 | [diff] [blame] | 32 | /* The current cryptfs version */ |
| 33 | #define CURRENT_MAJOR_VERSION 1 |
Paul Lawrence | f4faa57 | 2014-01-29 13:31:03 -0800 | [diff] [blame] | 34 | #define CURRENT_MINOR_VERSION 3 |
Kenny Root | c96a5f8 | 2013-06-14 12:08:28 -0700 | [diff] [blame] | 35 | |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 36 | #define CRYPT_FOOTER_OFFSET 0x4000 |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 37 | #define CRYPT_FOOTER_TO_PERSIST_OFFSET 0x1000 |
| 38 | #define CRYPT_PERSIST_DATA_SIZE 0x1000 |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 39 | |
| 40 | #define MAX_CRYPTO_TYPE_NAME_LEN 64 |
| 41 | |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 42 | #define MAX_KEY_LEN 48 |
Ken Sumrall | e874407 | 2011-01-18 22:01:55 -0800 | [diff] [blame] | 43 | #define SALT_LEN 16 |
Ken Sumrall | e874407 | 2011-01-18 22:01:55 -0800 | [diff] [blame] | 44 | |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 45 | /* definitions of flags in the structure below */ |
| 46 | #define CRYPT_MNT_KEY_UNENCRYPTED 0x1 /* The key for the partition is not encrypted. */ |
Ken Sumrall | d33d417 | 2011-02-01 00:49:13 -0800 | [diff] [blame] | 47 | #define CRYPT_ENCRYPTION_IN_PROGRESS 0x2 /* Set when starting encryption, |
| 48 | * clear when done before rebooting */ |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 49 | |
Paul Lawrence | f4faa57 | 2014-01-29 13:31:03 -0800 | [diff] [blame] | 50 | /* Allowed values for type in the structure below */ |
| 51 | #define CRYPT_TYPE_PASSWORD 0 /* master_key is encrypted with a password |
| 52 | * Must be zero to be compatible with pre-L |
| 53 | * devices where type is always password.*/ |
| 54 | #define CRYPT_TYPE_DEFAULT 1 /* master_key is encrypted with default |
| 55 | * password */ |
| 56 | #define CRYPT_TYPE_PATTERN 2 /* master_key is encrypted with a pattern */ |
| 57 | #define CRYPT_TYPE_PIN 3 /* master_key is encrypted with a pin */ |
| 58 | #define CRYPT_TYPE_MAX_TYPE 3 /* type cannot be larger than this value */ |
| 59 | |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 60 | #define CRYPT_MNT_MAGIC 0xD0B5B1C4 |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 61 | #define PERSIST_DATA_MAGIC 0xE950CD44 |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 62 | |
Kenny Root | c4c70f1 | 2013-06-14 12:11:38 -0700 | [diff] [blame] | 63 | #define SCRYPT_PROP "ro.crypto.scrypt_params" |
| 64 | #define SCRYPT_DEFAULTS { 15, 3, 1 } |
| 65 | |
| 66 | /* Key Derivation Function algorithms */ |
| 67 | #define KDF_PBKDF2 1 |
| 68 | #define KDF_SCRYPT 2 |
| 69 | |
Mark Salyzyn | 3e97127 | 2014-01-21 13:27:04 -0800 | [diff] [blame] | 70 | /* __le32 and __le16 defined in system/extras/ext4_utils/ext4_utils.h */ |
Kenny Root | c4c70f1 | 2013-06-14 12:11:38 -0700 | [diff] [blame] | 71 | #define __le8 unsigned char |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 72 | |
| 73 | struct crypt_mnt_ftr { |
Paul Lawrence | f4faa57 | 2014-01-29 13:31:03 -0800 | [diff] [blame] | 74 | __le32 magic; /* See above */ |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 75 | __le16 major_version; |
| 76 | __le16 minor_version; |
Paul Lawrence | f4faa57 | 2014-01-29 13:31:03 -0800 | [diff] [blame] | 77 | __le32 ftr_size; /* in bytes, not including key following */ |
| 78 | __le32 flags; /* See above */ |
| 79 | __le32 keysize; /* in bytes */ |
| 80 | __le32 crypt_type; /* how master_key is encrypted. Must be a |
| 81 | * CRYPT_TYPE_XXX value */ |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 82 | __le64 fs_size; /* Size of the encrypted fs, in 512 byte sectors */ |
| 83 | __le32 failed_decrypt_count; /* count of # of failed attempts to decrypt and |
Paul Lawrence | 8799917 | 2014-02-20 12:21:31 -0800 | [diff] [blame^] | 84 | mount, set to 0 on successful mount */ |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 85 | unsigned char crypto_type_name[MAX_CRYPTO_TYPE_NAME_LEN]; /* The type of encryption |
Paul Lawrence | 8799917 | 2014-02-20 12:21:31 -0800 | [diff] [blame^] | 86 | needed to decrypt this |
| 87 | partition, null terminated */ |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 88 | __le32 spare2; /* ignored */ |
| 89 | unsigned char master_key[MAX_KEY_LEN]; /* The encrypted key for decrypting the filesystem */ |
| 90 | unsigned char salt[SALT_LEN]; /* The salt used for this encryption */ |
| 91 | __le64 persist_data_offset[2]; /* Absolute offset to both copies of crypt_persist_data |
| 92 | * on device with that info, either the footer of the |
| 93 | * real_blkdevice or the metadata partition. */ |
| 94 | |
| 95 | __le32 persist_data_size; /* The number of bytes allocated to each copy of the |
| 96 | * persistent data table*/ |
Kenny Root | c4c70f1 | 2013-06-14 12:11:38 -0700 | [diff] [blame] | 97 | |
| 98 | __le8 kdf_type; /* The key derivation function used. */ |
| 99 | |
| 100 | /* scrypt parameters. See www.tarsnap.com/scrypt/scrypt.pdf */ |
| 101 | __le8 N_factor; /* (1 << N) */ |
| 102 | __le8 r_factor; /* (1 << r) */ |
| 103 | __le8 p_factor; /* (1 << p) */ |
Paul Lawrence | 8799917 | 2014-02-20 12:21:31 -0800 | [diff] [blame^] | 104 | __le64 encrypted_upto; /* If we are in state CRYPT_ENCRYPTION_IN_PROGRESS and |
| 105 | we have to stop (e.g. power low) this is the last |
| 106 | encrypted 512 byte sector.*/ |
| 107 | __le8 hash_first_block[SHA256_DIGEST_LENGTH]; /* When CRYPT_ENCRYPTION_IN_PROGRESS |
| 108 | set, hash of first block, used |
| 109 | to validate before continuing*/ |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 110 | }; |
| 111 | |
| 112 | /* Persistant data that should be available before decryption. |
| 113 | * Things like airplane mode, locale and timezone are kept |
| 114 | * here and can be retrieved by the CryptKeeper UI to properly |
| 115 | * configure the phone before asking for the password |
| 116 | * This is only valid if the major and minor version above |
| 117 | * is set to 1.1 or higher. |
| 118 | * |
| 119 | * This is a 4K structure. There are 2 copies, and the code alternates |
| 120 | * writing one and then clearing the previous one. The reading |
| 121 | * code reads the first valid copy it finds, based on the magic number. |
| 122 | * The absolute offset to the first of the two copies is kept in rev 1.1 |
| 123 | * and higher crypt_mnt_ftr structures. |
| 124 | */ |
| 125 | struct crypt_persist_entry { |
| 126 | char key[PROPERTY_KEY_MAX]; |
| 127 | char val[PROPERTY_VALUE_MAX]; |
| 128 | }; |
| 129 | |
| 130 | /* Should be exactly 4K in size */ |
| 131 | struct crypt_persist_data { |
| 132 | __le32 persist_magic; |
| 133 | __le32 persist_valid_entries; |
| 134 | __le32 persist_spare[30]; |
| 135 | struct crypt_persist_entry persist_entry[0]; |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 136 | }; |
| 137 | |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 138 | struct volume_info { |
| 139 | unsigned int size; |
| 140 | unsigned int flags; |
| 141 | struct crypt_mnt_ftr crypt_ftr; |
| 142 | char mnt_point[256]; |
| 143 | char blk_dev[256]; |
| 144 | char crypto_blkdev[256]; |
| 145 | char label[256]; |
| 146 | }; |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 147 | #define VOL_NONREMOVABLE 0x1 |
| 148 | #define VOL_ENCRYPTABLE 0x2 |
| 149 | #define VOL_PRIMARY 0x4 |
| 150 | #define VOL_PROVIDES_ASEC 0x8 |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 151 | |
JP Abgrall | 502dc74 | 2013-11-01 13:06:20 -0700 | [diff] [blame] | 152 | #define DATA_MNT_POINT "/data" |
| 153 | |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 154 | #ifdef __cplusplus |
| 155 | extern "C" { |
| 156 | #endif |
Kenny Root | c4c70f1 | 2013-06-14 12:11:38 -0700 | [diff] [blame] | 157 | |
Paul Lawrence | 1348603 | 2014-02-03 13:28:11 -0800 | [diff] [blame] | 158 | typedef int (*kdf_func)(const char *passwd, unsigned char *salt, |
| 159 | unsigned char *ikey, void *params); |
Kenny Root | c4c70f1 | 2013-06-14 12:11:38 -0700 | [diff] [blame] | 160 | |
Ken Sumrall | 7f7dbaa | 2011-02-01 15:46:41 -0800 | [diff] [blame] | 161 | int cryptfs_crypto_complete(void); |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 162 | int cryptfs_check_passwd(char *pw); |
Ken Sumrall | 3ad9072 | 2011-10-04 20:38:29 -0700 | [diff] [blame] | 163 | int cryptfs_verify_passwd(char *newpw); |
Ken Sumrall | 6864b7e | 2011-01-14 15:20:02 -0800 | [diff] [blame] | 164 | int cryptfs_restart(void); |
JP Abgrall | 502dc74 | 2013-11-01 13:06:20 -0700 | [diff] [blame] | 165 | int cryptfs_enable(char *flag, char *passwd, int allow_reboot); |
Paul Lawrence | 1348603 | 2014-02-03 13:28:11 -0800 | [diff] [blame] | 166 | int cryptfs_changepw(int type, const char *newpw); |
| 167 | int cryptfs_enable_default(char *flag, int allow_reboot); |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 168 | int cryptfs_setup_volume(const char *label, int major, int minor, |
| 169 | char *crypto_dev_path, unsigned int max_pathlen, |
| 170 | int *new_major, int *new_minor); |
Ken Sumrall | 0b8b597 | 2011-08-31 16:14:23 -0700 | [diff] [blame] | 171 | int cryptfs_revert_volume(const char *label); |
Ken Sumrall | 160b4d6 | 2013-04-22 12:15:39 -0700 | [diff] [blame] | 172 | int cryptfs_getfield(char *fieldname, char *value, int len); |
| 173 | int cryptfs_setfield(char *fieldname, char *value); |
Paul Lawrence | f4faa57 | 2014-01-29 13:31:03 -0800 | [diff] [blame] | 174 | int cryptfs_mount_default_encrypted(void); |
| 175 | int cryptfs_get_password_type(void); |
Paul Lawrence | 684dbdf | 2014-02-07 12:07:22 -0800 | [diff] [blame] | 176 | int cryptfs_just_decrypted(void); |
Ken Sumrall | 8f869aa | 2010-12-03 03:47:09 -0800 | [diff] [blame] | 177 | #ifdef __cplusplus |
| 178 | } |
| 179 | #endif |
| 180 | |